Kwave::ChannelMixer Class Reference

#include <ChannelMixer.h>

Inheritance diagram for Kwave::ChannelMixer:

Collaboration diagram for Kwave::ChannelMixer:

Public Slots
void	input (Kwave::SampleArray data)

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

Public Member Functions
	ChannelMixer (unsigned int inputs, unsigned int outputs)
virtual	~ChannelMixer () Q_DECL_OVERRIDE
virtual bool	init ()
virtual unsigned int	tracksOfPort (const char *port) const Q_DECL_OVERRIDE
virtual Kwave::StreamObject *	port (const char *port, unsigned int track) 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	blockSize () const
void	setAttribute (const char *attribute, const QVariant &value)

Private Slots
void	idxInput (unsigned int index, Kwave::SampleArray data)

Private Member Functions
virtual void	mix ()

Private Attributes
Kwave::MixerMatrix *	m_matrix
unsigned int	m_inputs
unsigned int	m_outputs
QVector< QPointer< Kwave::StreamObject > >	m_indexer
QVector< QQueue< Kwave::SampleArray > >	m_input_queue
QVector< QPointer< Kwave::SampleBuffer > >	m_output_buffer
QMutex	m_lock

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

Detailed Description

Definition at line 41 of file ChannelMixer.h.

Constructor & Destructor Documentation

ChannelMixer()

Kwave::ChannelMixer::ChannelMixer	(	unsigned int	inputs,
		unsigned int	outputs
	)

Constructor

Parameters

inputs	number of input channels
outputs	number of output channels

Definition at line 35 of file ChannelMixer.cpp.

    :Kwave::SampleSource(),
     m_matrix(Q_NULLPTR),
     m_inputs(inputs),
     m_outputs(outputs),
     m_indexer(),
     m_input_queue(),
     m_output_buffer(),
     m_lock()
{
}

~ChannelMixer()

Kwave::ChannelMixer::~ChannelMixer ( )

virtual

Destructor

Definition at line 92 of file ChannelMixer.cpp.

References m_indexer, m_input_queue, m_lock, and m_output_buffer.

{
    QMutexLocker _lock(&m_lock);

    while (!m_indexer.isEmpty()) {
        Kwave::StreamObject *indexer = m_indexer[0];
        if (indexer) delete indexer;
        m_indexer.remove(0);
    }

    m_input_queue.clear();

    while (!m_output_buffer.isEmpty()) {
        Kwave::SampleBuffer *buffer = m_output_buffer[0];
        if (buffer) delete buffer;
        m_output_buffer.remove(0);
    }
}

Member Function Documentation

goOn()

virtual void Kwave::ChannelMixer::goOn ( )

inlinevirtual

does nothing, work is done automatically in mix()

Implements Kwave::SampleSource.

Definition at line 83 of file ChannelMixer.h.

            {
            }

idxInput

void Kwave::ChannelMixer::idxInput ( unsigned int  index, Kwave::SampleArray  data  )

privateslot

receives a block with index + input data

Definition at line 167 of file ChannelMixer.cpp.

References m_input_queue, m_inputs, m_lock, m_matrix, mix(), and Kwave::toInt().

Referenced by init(), port(), and tracksOfPort().

{
    QMutexLocker _lock(&m_lock);

    // put the data into the corresponding input queue
    Q_ASSERT(index < m_inputs);
    Q_ASSERT(Kwave::toInt(index) < m_input_queue.count());
    if (Kwave::toInt(index) < m_input_queue.count())
        m_input_queue[index].enqueue(data);

    // check: if there is one empty queue we are not yet ready for mixing
    bool ready = true;
    foreach (const QQueue<Kwave::SampleArray> &queue, m_input_queue) {
        if (queue.isEmpty()) {
            ready = false;
            break;
        }
    }

    // mix if we are ready
    if (ready && m_matrix) mix();
}

Here is the call graph for this function:

Here is the caller graph for this function:

init()

bool Kwave::ChannelMixer::init ( )

virtual

Init function, you must call it once after creating and before using this object. If the return value is false, you should delete this object.

Returns

true if succeeded, false if failed

Definition at line 48 of file ChannelMixer.cpp.

References Kwave::connect(), idxInput(), m_indexer, m_input_queue, m_inputs, m_matrix, m_output_buffer, m_outputs, output(), and Kwave::toInt().

Referenced by Kwave::MimeData::decode(), and Kwave::OpusEncoder::setupDownMix().

{
    if (!m_inputs || !m_outputs) return false;

    // create queues for the input data
    m_input_queue.resize(m_inputs);
    Q_ASSERT(m_input_queue.count() == Kwave::toInt(m_inputs));
    if (m_input_queue.count() != Kwave::toInt(m_inputs)) return false;

    // create the buffers for the output data
    for (unsigned int index = 0; index < m_outputs; ++index) {
        // create a buffer for the input
        Kwave::SampleBuffer *out_buffer = new Kwave::SampleBuffer();
        Q_ASSERT(out_buffer);
        if (!out_buffer) return false;
        m_output_buffer.append(out_buffer);
    }

    // create indexing proxies and connect their output to this mixer
    for (unsigned int index = 0; index < m_inputs; ++index) {
        Kwave::StreamObject *indexer = new Kwave::Indexer(index);
        Q_ASSERT(indexer);
        if (!indexer) return false;

        m_indexer.append(indexer);
        bool ok = Kwave::connect(
            *indexer, SIGNAL(output(uint,Kwave::SampleArray)),
            *this,    SLOT(idxInput(uint,Kwave::SampleArray)));
        Q_ASSERT(ok);
        if (!ok) return false;
    }

    // create the mixer matrix
    // create a translation matrix for mixing up/down to the desired
    // number of output channels
    m_matrix = new Kwave::MixerMatrix(m_inputs, m_outputs);
    Q_ASSERT(m_matrix);
    if (!m_matrix) return false;

    // everything succeeded
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

input

void Kwave::ChannelMixer::input ( Kwave::SampleArray  data )

inlineslot

dummy implementation, the real "input" is a multi-track slot and available through the port(...) interface only

Definition at line 98 of file ChannelMixer.h.

Referenced by mix(), port(), and tracksOfPort().

{ Q_UNUSED(data); }

Here is the caller graph for this function:

mix()

void Kwave::ChannelMixer::mix ( )

privatevirtual

does the calculation

Definition at line 191 of file ChannelMixer.cpp.

References Kwave::SampleArray::constData(), Kwave::SampleBuffer::constData(), Kwave::SampleBuffer::data(), Kwave::SampleArray::data(), Kwave::SampleBuffer::finished(), input(), m_input_queue, m_inputs, m_matrix, m_output_buffer, m_outputs, output(), Kwave::SampleArray::resize(), and Kwave::SampleArray::size().

Referenced by idxInput().

{
    Q_ASSERT(m_matrix);

    // all inputs should contain a buffer, dequeue them into a vector
    // and form an array of pointers to the raw data, for speeding up
    QVector<Kwave::SampleArray> v_input(m_inputs);
    QVarLengthArray<const sample_t *> input(m_inputs);
    unsigned int min_len = UINT_MAX;
    for (unsigned int track = 0; track < m_inputs; track++) {
        // dequeue the buffer with input data
        QQueue<Kwave::SampleArray> &queue = m_input_queue[track];
        Q_ASSERT(!queue.isEmpty());
        Kwave::SampleArray buffer = queue.dequeue();
        v_input[track] = buffer;

        // get a pointer for quick access
        const sample_t *raw_data = v_input[track].constData();
        input[track] = raw_data;

        // detect minimum input length
        min_len = qMin(min_len, buffer.size());
    }
    Q_ASSERT(min_len);
    if (!min_len) return; // zero length buffer in the queue, data underrun?

    // make sure all output buffers are large enough
    // and build an array of pointers to the raw data, for speeding up
    QVarLengthArray<sample_t *> output(m_outputs);
    for (unsigned int track = 0; track < m_outputs; track++) {
        Kwave::SampleBuffer *buffer = m_output_buffer[track];
        Q_ASSERT(buffer);
        if (!buffer) return;
        bool ok = true;
        if (buffer->constData().size() < min_len)
            ok &= buffer->data().resize(min_len);
        if (!ok) {
            qWarning("ChannelMixer: failed to increase buffer size to %u",
                     min_len);
            return; // OOM ?
        }
        output[track] = buffer->data().data();
    }

    // mix all channels together, using the mixer matrix
    for (unsigned int y = 0; y < m_outputs; y++) {
        sample_t *out = output[y];
        for (unsigned int pos = 0; pos < min_len; pos++) {
            double sum = 0.0;
            for (unsigned int x = 0; x < m_inputs; x++) {
                const double f = (*m_matrix)[x][y];
                const double i = static_cast<double>(input[x][pos]);
                sum += (f * i);
            }
            out[pos] = static_cast<sample_t>(sum);
        }

        // emit the output
        Kwave::SampleBuffer *out_buf = m_output_buffer[y];
        if (Q_UNLIKELY(out_buf->constData().size() > min_len)) {
            bool ok = out_buf->data().resize(min_len);
            Q_ASSERT(ok);
            Q_UNUSED(ok);
        }
        out_buf->finished();
    }

}

Here is the call graph for this function:

Here is the caller graph for this function:

output

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

signal

emits a block with output data

Referenced by init(), mix(), port(), and tracksOfPort().

Here is the caller graph for this function:

port()

Kwave::StreamObject * Kwave::ChannelMixer::port ( const char *  port, unsigned int  track  )

virtual

Returns an indexed port, identified by name

Parameters

port	name of the port (name of signal or slot)
track	index of the track

Reimplemented from Kwave::StreamObject.

Definition at line 140 of file ChannelMixer.cpp.

References _sig(), idxInput(), input(), m_indexer, m_lock, m_output_buffer, output(), and Kwave::toInt().

{
    Kwave::StreamObject *retval = Q_NULLPTR;
    QMutexLocker _lock(&m_lock);

    if (_sig(port) == _sig(SLOT(input(Kwave::SampleArray)))) {
        // input proxy
        Q_ASSERT(Kwave::toInt(track) < m_indexer.count());
        if (Kwave::toInt(track) >= m_indexer.count()) return Q_NULLPTR;
        retval = m_indexer.at(track);
    } else if (_sig(port) == _sig(SIGNAL(output(Kwave::SampleArray)))) {
        // output proxy
        Q_ASSERT(Kwave::toInt(track) < m_output_buffer.count());
        if (Kwave::toInt(track) >= m_output_buffer.count()) return Q_NULLPTR;
        retval = m_output_buffer[track];
    } else if (_sig(port) ==
               _sig(SLOT(idxInput(uint,Kwave::SampleArray)))) {
        retval = this;
    } else {
        qFatal("unknown port");
    }

    return retval;
}

Here is the call graph for this function:

tracksOfPort()

unsigned int Kwave::ChannelMixer::tracksOfPort ( const char *  port ) const

virtual

Returns the number of tracks of a input or output port. Can be overwritten for objects that have a different count of inputs and outputs.

Parameters

port	name of the port (name of signal or slot)

Returns

number of tracks of a input or output, default is the same as tracks()

Reimplemented from Kwave::StreamObject.

Definition at line 118 of file ChannelMixer.cpp.

References _sig(), idxInput(), input(), m_inputs, m_lock, m_outputs, and output().

{
    unsigned int retval = 0;
    QMutexLocker _lock(const_cast<QMutex *>(&m_lock));

    if (_sig(port) == _sig(SLOT(input(Kwave::SampleArray)))) {
        // input ports
        retval = m_inputs; // init is done
    } else if (_sig(port) == _sig(SIGNAL(output(Kwave::SampleArray)))) {
        // output ports
        retval = m_outputs;
    } else if (_sig(port) ==
               _sig(SLOT(idxInput(uint,Kwave::SampleArray)))) {
        retval = 1;
    } else {
        qFatal("unknown port");
    }

    return retval;
}

Here is the call graph for this function:

Member Data Documentation

m_indexer

QVector< QPointer<Kwave::StreamObject> > Kwave::ChannelMixer::m_indexer

private

Definition at line 121 of file ChannelMixer.h.

Referenced by init(), port(), and ~ChannelMixer().

m_input_queue

QVector< QQueue<Kwave::SampleArray> > Kwave::ChannelMixer::m_input_queue

private

queues for input data

Definition at line 124 of file ChannelMixer.h.

Referenced by idxInput(), init(), mix(), and ~ChannelMixer().

m_inputs

unsigned int Kwave::ChannelMixer::m_inputs

private

number of inputs

Definition at line 116 of file ChannelMixer.h.

Referenced by idxInput(), init(), mix(), and tracksOfPort().

m_lock

QMutex Kwave::ChannelMixer::m_lock

private

mutex for locking access to the queues

Definition at line 130 of file ChannelMixer.h.

Referenced by idxInput(), port(), tracksOfPort(), and ~ChannelMixer().

m_matrix

Kwave::MixerMatrix* Kwave::ChannelMixer::m_matrix

private

mixer matrix

Definition at line 113 of file ChannelMixer.h.

Referenced by idxInput(), init(), and mix().

m_output_buffer

QVector< QPointer<Kwave::SampleBuffer> > Kwave::ChannelMixer::m_output_buffer

private

buffers with output data

Definition at line 127 of file ChannelMixer.h.

Referenced by init(), mix(), port(), and ~ChannelMixer().

m_outputs

unsigned int Kwave::ChannelMixer::m_outputs

private

number of outputs

Definition at line 119 of file ChannelMixer.h.

Referenced by init(), mix(), and tracksOfPort().

---

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

• libkwave/modules/ChannelMixer.h
• libkwave/modules/ChannelMixer.cpp