Kwave::Mul Class Reference

#include <Mul.h>

Inheritance diagram for Kwave::Mul:

Collaboration diagram for Kwave::Mul:

Public Slots
void	input_a (Kwave::SampleArray data)
void	input_b (Kwave::SampleArray data)
void	set_a (const QVariant &a)
void	set_b (const QVariant &b)

Signals
void	output (Kwave::SampleArray data)
Signals inherited from Kwave::StreamObject
void	attributeChanged (const QVariant value)

Public Member Functions
	Mul ()
virtual	~Mul () Q_DECL_OVERRIDE
virtual void	goOn () Q_DECL_OVERRIDE
Public Member Functions inherited from Kwave::SampleSource
	SampleSource (QObject *parent=Q_NULLPTR)
virtual	~SampleSource ()
virtual bool	done () const
Public Member Functions inherited from Kwave::StreamObject
	StreamObject (QObject *parent=Q_NULLPTR)
virtual	~StreamObject ()
virtual unsigned int	tracks () const
virtual Kwave::StreamObject *	operator[] (unsigned int track)
virtual unsigned int	tracksOfPort (const char *port) const
virtual Kwave::StreamObject *	port (const char *port, unsigned int track)
virtual unsigned int	blockSize () const
void	setAttribute (const char *attribute, const QVariant &value)

Private Member Functions
virtual void	multiply ()

Private Attributes
QQueue< Kwave::SampleArray >	m_queue_a
QQueue< Kwave::SampleArray >	m_queue_b
QSemaphore	m_sem_a
QSemaphore	m_sem_b
Kwave::SampleArray	m_a
Kwave::SampleArray	m_b
Kwave::SampleArray	m_buffer_x
bool	m_a_is_const
bool	m_b_is_const
float	m_value_a
float	m_value_b
QMutex	m_lock

Additional Inherited Members
Static Public Member Functions inherited from Kwave::StreamObject
static void	setInteractive (bool interactive)

Detailed Description

Definition at line 37 of file Mul.h.

Constructor & Destructor Documentation

Mul()

Kwave::Mul::Mul

(

)

Constructor

Definition at line 28 of file Mul.cpp.

    :Kwave::SampleSource(),
     m_queue_a(), m_queue_b(),
     m_sem_a(0), m_sem_b(0),
     m_a(), m_b(),
     m_buffer_x(blockSize()),
     m_a_is_const(false), m_b_is_const(false),
     m_value_a(0), m_value_b(0),
     m_lock()
{
}

~Mul()

Kwave::Mul::~Mul ( )

virtual

Destructor

Definition at line 41 of file Mul.cpp.

{
}

Member Function Documentation

goOn()

void Kwave::Mul::goOn ( )

virtual

does nothing, work is done automatically in multiply()

Implements Kwave::SampleSource.

Definition at line 46 of file Mul.cpp.

{
}

input_a

void Kwave::Mul::input_a ( Kwave::SampleArray  data )

slot

receives input data for input A

Definition at line 134 of file Mul.cpp.

References m_a_is_const, m_b_is_const, m_lock, m_queue_a, m_queue_b, m_sem_a, and multiply().

{
    {
        QMutexLocker lock(&m_lock);

        m_queue_a.enqueue(data);
        m_sem_a.release();
        m_a_is_const = false;
    }
    if (m_b_is_const || !m_queue_b.isEmpty()) multiply();
}

Here is the call graph for this function:

input_b

void Kwave::Mul::input_b ( Kwave::SampleArray  data )

slot

receives input data for input B

Definition at line 147 of file Mul.cpp.

References m_a_is_const, m_b_is_const, m_lock, m_queue_a, m_queue_b, m_sem_b, and multiply().

{
    {
        QMutexLocker lock(&m_lock);

        m_queue_b.enqueue(data);
        m_sem_b.release();
        m_b_is_const = false;
    }
    if (m_a_is_const || !m_queue_a.isEmpty()) multiply();
}

Here is the call graph for this function:

multiply()

void Kwave::Mul::multiply ( )

privatevirtual

does the calculation

Definition at line 51 of file Mul.cpp.

References Kwave::StreamObject::blockSize(), Kwave::SampleArray::constData(), Kwave::SampleArray::data(), float2sample(), m_a, m_a_is_const, m_b, m_b_is_const, m_buffer_x, m_lock, m_queue_a, m_queue_b, m_sem_a, m_sem_b, m_value_a, m_value_b, output(), Kwave::SampleArray::resize(), sample2float(), and Kwave::SampleArray::size().

Referenced by input_a(), and input_b().

{
    unsigned int count = blockSize();
    float a = 0;
    float b = 0;
    const sample_t *p_a = Q_NULLPTR;
    const sample_t *p_b = Q_NULLPTR;
    sample_t       *p_x = Q_NULLPTR;

    // get input A
    if (!m_a_is_const) {
        m_sem_a.acquire();
        {
            QMutexLocker lock(&m_lock);
            m_a = m_queue_a.dequeue();
        }
        if (m_a.size() < count) count = m_a.size();
    }
    else
    {
        QMutexLocker lock(&m_lock);
        a = m_value_a;
    }

    // get input B
    if (!m_b_is_const) {
        m_sem_b.acquire();
        {
            QMutexLocker lock(&m_lock);
            m_b = m_queue_b.dequeue();
        }
        if (m_b.size() < count) count = m_b.size();
    }
    else
    {
        QMutexLocker lock(&m_lock);
        b = m_value_b;
    }

    // check sizes of the buffers
    if (!m_a_is_const && (count > m_a.size()))
        count = m_a.size();
    if (!m_b_is_const && (count > m_b.size()))
        count = m_b.size();

    // special handling for zero length input
    if (!count) {
        emit output(Kwave::SampleArray()); // emit zero length output
        return;                            // and bail out
    }

//     if (!m_a_is_const && !m_b_is_const && (m_a.size() != m_b.size()))
//      qWarning("Kwave::Mul: block sizes differ: %u x %u -> shrinked to %u",
//          m_a.size(), m_b.size(), count);

    bool ok = m_buffer_x.resize(count);
    Q_ASSERT(ok);
    Q_UNUSED(ok);

    // get pointers to the buffer's raw data
    p_a = m_a.constData();
    p_b = m_b.constData();
    p_x = m_buffer_x.data();
    Q_ASSERT((m_a_is_const || p_a) && (m_b_is_const || p_b) && p_x);
    if ((!m_a_is_const && !p_a) || (!m_b_is_const && !p_b) || !p_x)
        return;

    // do the multiplication of the whole buffer
    for (; count; count--)
    {
        if (!m_a_is_const) { a = sample2float(*p_a); ++p_a; }
        if (!m_b_is_const) { b = sample2float(*p_b); ++p_b; }
        float y = a * b;
        if (y > float( 1.0)) y = float( 1.0);
        if (y < float(-1.0)) y = float(-1.0);
        *(p_x++) = float2sample(y);
    }

    // emit the result
    emit output(m_buffer_x);
}

Here is the call graph for this function:

Here is the caller graph for this function:

output

void Kwave::Mul::output ( Kwave::SampleArray  data )

signal

emits a block with the interpolated curve

Referenced by multiply().

Here is the caller graph for this function:

set_a

void Kwave::Mul::set_a ( const QVariant &  a )

slot

sets input A to a constant value (as float)

Definition at line 160 of file Mul.cpp.

References m_a_is_const, m_lock, and m_value_a.

{
    QMutexLocker lock(&m_lock);

    m_value_a = QVariant(a).toFloat();
    m_a_is_const = true;
}

set_b

void Kwave::Mul::set_b ( const QVariant &  b )

slot

sets input B to a constant value (as float)

Definition at line 169 of file Mul.cpp.

References m_b_is_const, m_lock, and m_value_b.

{
    QMutexLocker lock(&m_lock);

    m_value_b = QVariant(b).toFloat();
    m_b_is_const = true;
}

Member Data Documentation

m_a

Kwave::SampleArray Kwave::Mul::m_a

private

buffer for input A (currently in work)

Definition at line 88 of file Mul.h.

Referenced by multiply().

m_a_is_const

bool Kwave::Mul::m_a_is_const

private

if true, input A is a constant

Definition at line 97 of file Mul.h.

Referenced by input_a(), input_b(), multiply(), and set_a().

m_b

Kwave::SampleArray Kwave::Mul::m_b

private

buffer for input B (currently in work)

Definition at line 91 of file Mul.h.

Referenced by multiply().

m_b_is_const

bool Kwave::Mul::m_b_is_const

private

if true, input B is a constant

Definition at line 100 of file Mul.h.

Referenced by input_a(), input_b(), multiply(), and set_b().

m_buffer_x

Kwave::SampleArray Kwave::Mul::m_buffer_x

private

buffer for output data

Definition at line 94 of file Mul.h.

Referenced by multiply().

m_lock

QMutex Kwave::Mul::m_lock

private

mutex for locking access to the queues

Definition at line 109 of file Mul.h.

Referenced by input_a(), input_b(), multiply(), set_a(), and set_b().

m_queue_a

QQueue<Kwave::SampleArray> Kwave::Mul::m_queue_a

private

queue for input A

Definition at line 76 of file Mul.h.

Referenced by input_a(), input_b(), and multiply().

m_queue_b

QQueue<Kwave::SampleArray> Kwave::Mul::m_queue_b

private

queue for input B

Definition at line 79 of file Mul.h.

Referenced by input_a(), input_b(), and multiply().

m_sem_a

QSemaphore Kwave::Mul::m_sem_a

private

semaphore to wait for input on input A

Definition at line 82 of file Mul.h.

Referenced by input_a(), and multiply().

m_sem_b

QSemaphore Kwave::Mul::m_sem_b

private

semaphore to wait for input on input B

Definition at line 85 of file Mul.h.

Referenced by input_b(), and multiply().

m_value_a

float Kwave::Mul::m_value_a

private

if m_a_is_const is set, the value of A

Definition at line 103 of file Mul.h.

Referenced by multiply(), and set_a().

m_value_b

float Kwave::Mul::m_value_b

private

if m_b_is_const is set, the value of B

Definition at line 106 of file Mul.h.

Referenced by multiply(), and set_b().

---

The documentation for this class was generated from the following files:

• libkwave/modules/Mul.h
• libkwave/modules/Mul.cpp