Kwave::PlayBackQt Class Reference

#include <PlayBack-Qt.h>

Inheritance diagram for Kwave::PlayBackQt:

Collaboration diagram for Kwave::PlayBackQt:

Classes
class	Buffer

Public Member Functions
	PlayBackQt ()
virtual	~PlayBackQt () Q_DECL_OVERRIDE
virtual QString	open (const QString &device, double rate, unsigned int channels, unsigned int bits, unsigned int bufbase) Q_DECL_OVERRIDE
virtual int	write (const Kwave::SampleArray &samples) Q_DECL_OVERRIDE
virtual int	close () Q_DECL_OVERRIDE
virtual QStringList	supportedDevices () Q_DECL_OVERRIDE
virtual QString	fileFilter () Q_DECL_OVERRIDE
virtual QList< unsigned int >	supportedBits (const QString &device) Q_DECL_OVERRIDE
virtual int	detectChannels (const QString &device, unsigned int &min, unsigned int &max) Q_DECL_OVERRIDE
Public Member Functions inherited from Kwave::PlayBackDevice
virtual	~PlayBackDevice ()

Private Slots
void	stateChanged (QAudio::State state)

Private Member Functions
void	createEncoder (const QAudioFormat &format)
void	scanDevices ()
QAudioDeviceInfo	deviceInfo (const QString &device) const

Private Attributes
QMutex	m_lock
QMap< QString, QString >	m_device_name_map
QList< QAudioDeviceInfo >	m_available_devices
QAudioOutput *	m_output
unsigned int	m_buffer_size
Kwave::SampleEncoder *	m_encoder
Kwave::PlayBackQt::Buffer	m_buffer

Detailed Description

Definition at line 47 of file PlayBack-Qt.h.

Constructor & Destructor Documentation

PlayBackQt()

Kwave::PlayBackQt::PlayBackQt

(

)

Default constructor

Definition at line 44 of file PlayBack-Qt.cpp.

    :QObject(), Kwave::PlayBackDevice(),
     m_lock(QMutex::Recursive),
     m_device_name_map(),
     m_available_devices(),
     m_output(Q_NULLPTR),
     m_buffer_size(0),
     m_encoder(Q_NULLPTR)
{
}

~PlayBackQt()

Kwave::PlayBackQt::~PlayBackQt ( )

virtual

Destructor

Definition at line 56 of file PlayBack-Qt.cpp.

References close().

{
    close();
}

Here is the call graph for this function:

Member Function Documentation

close()

int Kwave::PlayBackQt::close ( )

virtual

Closes the output device.

See also

PlayBackDevice::close

Implements Kwave::PlayBackDevice.

Definition at line 305 of file PlayBack-Qt.cpp.

References Kwave::PlayBackQt::Buffer::bytesAvailable(), Kwave::PlayBackQt::Buffer::drain(), Kwave::SampleEncoder::encode(), m_available_devices, m_buffer, m_device_name_map, m_encoder, m_lock, m_output, and Kwave::PlayBackQt::Buffer::stop().

Referenced by open(), Kwave::PlayBackQt::Buffer::stop(), and ~PlayBackQt().

{
    qDebug("Kwave::PlayBackQt::close()");

    QMutexLocker _lock(&m_lock); // context: main thread

    if (m_output && m_encoder) {
        unsigned int pad_bytes_cnt   = m_output->periodSize();
        unsigned int bytes_per_frame = m_output->format().bytesPerFrame();
        unsigned int pad_samples_cnt = pad_bytes_cnt / bytes_per_frame;
        Kwave::SampleArray pad_samples(pad_samples_cnt);
        QByteArray pad_bytes(pad_bytes_cnt, char(0));
        m_encoder->encode(pad_samples, pad_samples_cnt, pad_bytes);

        m_buffer.drain(pad_bytes);

        // stopping the engine might block, so we need to do this unlocked
        qDebug("Kwave::PlayBackQt::close() - flushing..., state=%d",
               m_output->state());
        while (
            m_output &&
            (m_output->state() == QAudio::ActiveState) &&
            m_buffer.bytesAvailable()
        ) {
            m_lock.unlock();
            qApp->processEvents(QEventLoop::ExcludeUserInputEvents);
            m_lock.lock();
        }
        qDebug("Kwave::PlayBackQt::close() - flushing done.");
        m_lock.unlock();
        m_output->stop();
        m_buffer.stop();
        m_lock.lock();
    }

    delete m_output;
    m_output = Q_NULLPTR;

    delete m_encoder;
    m_encoder = Q_NULLPTR;

    m_device_name_map.clear();
    m_available_devices.clear();

    qDebug("Kwave::PlayBackQt::close() - DONE");
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

createEncoder()

void Kwave::PlayBackQt::createEncoder ( const QAudioFormat &  format )

private

creates a sample encoder for playback, for linear formats

Parameters

format

the preferred format of the audio output device

Definition at line 62 of file PlayBack-Qt.cpp.

References Kwave::BigEndian, Kwave::LittleEndian, m_encoder, Kwave::SampleFormat::Signed, Kwave::SampleFormat::Unknown, Kwave::UnknownEndian, and Kwave::SampleFormat::Unsigned.

Referenced by open().

{
    // discard the old encoder
    delete m_encoder;
    m_encoder = Q_NULLPTR;

    // get the sample format
    Kwave::SampleFormat::Format sample_format = Kwave::SampleFormat::Unknown;
    switch (format.sampleType()) {
        case QAudioFormat::SignedInt:
            sample_format = Kwave::SampleFormat::Signed;
            break;
        case QAudioFormat::UnSignedInt:
            sample_format = Kwave::SampleFormat::Unsigned;
            break;
        default:
            sample_format = Kwave::SampleFormat::Unknown;
            break;
    }
    if (sample_format == Kwave::SampleFormat::Unknown) {
        qWarning("PlayBackQt: unsupported sample format %d",
                 static_cast<int>(format.sampleType()));
        return;
    }

    unsigned int bits = 0;
    switch (format.sampleSize()) {
        case  8: bits =  8; break;
        case 16: bits = 16; break;
        case 24: bits = 24; break;
        case 32: bits = 32; break;
        default: bits =  0; break;
    }
    if (bits == 0) {
        qWarning("PlayBackQt: unsupported bits per sample: %d",
                 static_cast<int>(format.sampleSize()));
        return;
    }

    Kwave::byte_order_t endian = Kwave::UnknownEndian;
    switch (format.byteOrder()) {
        case QAudioFormat::BigEndian:    endian = Kwave::BigEndian;     break;
        case QAudioFormat::LittleEndian: endian = Kwave::LittleEndian;  break;
        default:                         endian = Kwave::UnknownEndian; break;
    }
    if (endian == Kwave::UnknownEndian) {
        qWarning("PlayBackQt: unsupported byte order in audio format: %d",
                 static_cast<int>(format.byteOrder()));
        return;
    }

    // create the sample encoder
    m_encoder = new Kwave::SampleEncoderLinear(sample_format, bits, endian);
}

Here is the caller graph for this function:

detectChannels()

int Kwave::PlayBackQt::detectChannels ( const QString &  device, unsigned int &  min, unsigned int &  max  )

virtual

Detect the minimum and maximum number of channels. If the detection fails, minimum and maximum are set to zero.

Parameters

device	filename of the device
min	receives the lowest supported number of channels
max	receives the highest supported number of channels

Returns

zero or positive number if ok, negative error number if failed

Reimplemented from Kwave::PlayBackDevice.

Definition at line 435 of file PlayBack-Qt.cpp.

References deviceInfo(), m_lock, and Kwave::toUint().

{
    QMutexLocker _lock(&m_lock); // context: main thread

    const QAudioDeviceInfo info(deviceInfo(device));

    max = std::numeric_limits<unsigned int>::min();
    min = std::numeric_limits<unsigned int>::max();

    // no devices at all -> empty
    if (info.isNull()) return -1;

    // iterate over all supported sample sizes
    foreach (int channels, info.supportedChannelCounts()) {
        if (channels <= 0) continue;
        unsigned int c = Kwave::toUint(channels);
        if (c < 1) continue;
        if (c < min) min = c;
        if (c > max) max = c;
    }

    return (max > 0) ? max : -1;
}

Here is the call graph for this function:

deviceInfo()

QAudioDeviceInfo Kwave::PlayBackQt::deviceInfo ( const QString &  device ) const

private

Gets the full device info of a playback device, identified by the device name.

Parameters

device

name of the device or empty string for default

Returns

a QAudioDeviceInfo

Definition at line 282 of file PlayBack-Qt.cpp.

References DEFAULT_DEVICE, m_available_devices, and m_device_name_map.

Referenced by detectChannels(), open(), and supportedBits().

{
    // check for default device
    if (!device.length() || (device == DEFAULT_DEVICE))
        return QAudioDeviceInfo::defaultOutputDevice();

    // check if the device name is known
    if (m_device_name_map.isEmpty() || !m_device_name_map.contains(device))
        return QAudioDeviceInfo();

    // translate the path into a Qt audio output device name
    // iterate over all available devices
    const QString dev_name = m_device_name_map[device];
    foreach (const QAudioDeviceInfo &dev, m_available_devices) {
        if (dev.deviceName() == dev_name)
            return QAudioDeviceInfo(dev);
    }

    // fallen through: return empty info
    return QAudioDeviceInfo();
}

Here is the caller graph for this function:

fileFilter()

QString Kwave::PlayBackQt::fileFilter ( )

virtual

return a string suitable for a "File Open..." dialog

Reimplemented from Kwave::PlayBackDevice.

Definition at line 408 of file PlayBack-Qt.cpp.

References _.

{
    return _("");
}

open()

QString Kwave::PlayBackQt::open ( const QString &  device, double  rate, unsigned int  channels, unsigned int  bits, unsigned int  bufbase  )

virtual

Opens the device for playback.

See also

PlayBackDevice::open

Implements Kwave::PlayBackDevice.

Definition at line 118 of file PlayBack-Qt.cpp.

References _, close(), Kwave::connect(), createEncoder(), DBG, deviceInfo(), m_buffer, m_buffer_size, m_encoder, m_lock, m_output, Kwave::SampleEncoder::rawBytesPerSample(), scanDevices(), Kwave::PlayBackQt::Buffer::setTimeout(), Kwave::PlayBackQt::Buffer::start(), stateChanged(), Kwave::toInt(), and Kwave::toUint().

Referenced by Kwave::PlayBackQt::Buffer::start().

{
    qDebug("PlayBackQt::open(device='%s', rate=%0.1f,channels=%u, bits=%u, "
           "bufbase=%u)", DBG(device), rate, channels, bits, bufbase);

    if ((rate < double(1.0f))  || !channels || !bits || !bufbase)
        return i18n("One or more invalid/out of range arguments.");

    // close the previous device
    close();

    QMutexLocker _lock(&m_lock); // context: main thread

    // make sure we have a valid list of devices
    scanDevices();

    const QAudioDeviceInfo info(deviceInfo(device));
    if (info.isNull()) {
        return i18n("The audio device '%1' is unknown or no longer connected",
                    device.section(QLatin1Char('|'), 0, 0));
    }

    // find a supported sample format
    const QAudioFormat preferred_format(info.preferredFormat());
    QAudioFormat format(preferred_format);
    format.setSampleSize(Kwave::toInt(bits));
    format.setChannelCount(Kwave::toInt(channels));
    format.setSampleRate(Kwave::toInt(rate));

    // find a replacement format with matching codec, channels, bits and rate
    if (!format.isValid() || !info.isFormatSupported(format))
        format = info.nearestFormat(format);

    if (format.codec() != _("audio/pcm"))
        return i18n("PCM encoding is not supported");

    if (format.sampleSize() != Kwave::toInt(bits))
        return i18n("%1 bits per sample are not supported", bits);

    if (format.channelCount() != Kwave::toInt(channels))
        return i18n("playback with %1 channels is not supported", channels);

    if (format.sampleRate() != Kwave::toInt(rate))
        return i18n("sample rate %1 Hz is not supported", Kwave::toInt(rate));

    if ( (format.sampleType() != QAudioFormat::SignedInt) &&
         (format.sampleType() != QAudioFormat::UnSignedInt) )
        return i18n("integer sample format is not supported");

    // create a sample encoder
    createEncoder(format);
    Q_ASSERT(m_encoder);
    if (!m_encoder) return i18n("Out of memory");

    // create a new Qt output device
    m_output = new QAudioOutput(format, this);
    Q_ASSERT(m_output);
    if (!m_output) return i18n("Out of memory");

    // connect the state machine and the notification engine
    connect(m_output, SIGNAL(stateChanged(QAudio::State)),
            this,     SLOT(stateChanged(QAudio::State)));

    // calculate the buffer size in bytes
    if (bufbase < 8)
        bufbase = 8;
    m_buffer_size = (1U << bufbase);
    qDebug("    buffer size = %u", m_buffer_size);

    // in the rare case that out backend already gives us a period size,
    // check out buffer size against it
    m_buffer_size = qMax(m_buffer_size, Kwave::toUint(m_output->periodSize()));

    m_buffer.start(m_buffer_size, 0);

    // open the output device for writing
    m_output->start(&m_buffer);

    // calculate an appropriate timeout, based on the period and buffer sizes
    const int period_size = m_output->periodSize();
    qDebug("    period_size = %d", period_size);
    unsigned int bytes_per_frame = m_encoder->rawBytesPerSample() * channels;
    unsigned int buffer_size = qMax(qMax<int>(period_size, m_buffer_size),
                                    m_output->bufferSize());
    unsigned int buffer_frames =
        ((buffer_size * 2) + (bytes_per_frame - 1)) / bytes_per_frame;
    int timeout = qMax(Kwave::toInt((1000 * buffer_frames) / rate), 100);
    qDebug("    timeout = %d ms", timeout);
    m_buffer.setTimeout(timeout);

    if (m_output->error() != QAudio::NoError) {
        qDebug("error no: %d", int(m_output->error()));
        return i18n("Opening the Qt Multimedia device '%1' failed", device);
    }

    return QString();
}

Here is the call graph for this function:

Here is the caller graph for this function:

scanDevices()

void Kwave::PlayBackQt::scanDevices ( )

private

scan all Qt audio output devices, re-creates m_device_list

Definition at line 374 of file PlayBack-Qt.cpp.

References _, DBG, m_available_devices, and m_device_name_map.

Referenced by open(), and supportedDevices().

{
    m_available_devices.clear();
    m_device_name_map.clear();

    // get the list of available audio output devices from Qt
    foreach (const QAudioDeviceInfo &device,
             QAudioDeviceInfo::availableDevices(QAudio::AudioOutput))
    {
        QString qt_name = device.deviceName();

        // for debugging: list all devices
//      qDebug("name='%s'", DBG(qt_name));

        // device name not available ?
        if (!qt_name.length()) {
            qWarning("PlayBackQt::supportedDevices() "
                      "=> BUG: device with no name?");
            continue;
        }

        QString gui_name = qt_name + _("|sound_note");
        if (m_device_name_map.contains(gui_name)) {
            qWarning("PlayBackQt::supportedDevices() "
            "=> BUG: duplicate device name: '%s'", DBG(gui_name));
            continue;
        }

        m_available_devices.append(device);
        m_device_name_map[gui_name] = qt_name;
    }
}

Here is the caller graph for this function:

stateChanged

void Kwave::PlayBackQt::stateChanged ( QAudio::State  state )

privateslot

connected to the audio output device and gets notified in case of state changes like start/stop of the stream or errors.

Parameters

state

the new device state, like active, stopped, idle etc.

Definition at line 247 of file PlayBack-Qt.cpp.

References m_output.

Referenced by open().

{
    Q_ASSERT(m_output);
    if (!m_output) return;

    if (m_output->error() != QAudio::NoError) {
        qDebug("PlaybBackQt::stateChanged(%d), ERROR=%d, "
               "buffer free=%d",
               static_cast<int>(state),
               static_cast<int>(m_output->error()),
               m_output->bytesFree()
        );
    }
    switch (state) {
        case QAudio::ActiveState:
            qDebug("PlaybBackQt::stateChanged(ActiveState)");
            break;
        case QAudio::SuspendedState:
            qDebug("PlaybBackQt::stateChanged(SuspendedState)");
            break;
        case QAudio::StoppedState: {
            qDebug("PlaybBackQt::stateChanged(StoppedState)");
            break;
        }
        case QAudio::IdleState:
            qDebug("PlaybBackQt::stateChanged(IdleState)");
            break;
        default:
            qWarning("PlaybBackQt::stateChanged(%d)",
                     static_cast<int>(state));
            break;
    }
}

Here is the caller graph for this function:

supportedBits()

QList< unsigned int > Kwave::PlayBackQt::supportedBits ( const QString &  device )

virtual

returns a list of supported bits per sample resolutions of a given device.

Parameters

device

filename of the device

Returns

list of supported bits per sample, or empty on errors

Implements Kwave::PlayBackDevice.

Definition at line 414 of file PlayBack-Qt.cpp.

References deviceInfo(), m_lock, and Kwave::toUint().

{
    QMutexLocker _lock(&m_lock); // context: main thread

    QList<unsigned int> list;
    const QAudioDeviceInfo info(deviceInfo(device));

    // no devices at all -> empty list
    if (info.isNull()) return list;

    // iterate over all supported sample sizes
    foreach (int bits, info.supportedSampleSizes()) {
        if (!list.contains(bits) && (bits > 0))
            list <<  Kwave::toUint(bits);
    }

    std::sort(list.begin(), list.end(), std::greater<unsigned int>());
    return list;
}

Here is the call graph for this function:

supportedDevices()

QStringList Kwave::PlayBackQt::supportedDevices ( )

virtual

return a string list with supported device names

Reimplemented from Kwave::PlayBackDevice.

Definition at line 354 of file PlayBack-Qt.cpp.

References _, DEFAULT_DEVICE, m_available_devices, m_device_name_map, m_lock, and scanDevices().

{
    QMutexLocker _lock(&m_lock); // context: main thread

    // re-validate the list if necessary
    if (m_device_name_map.isEmpty() || m_available_devices.isEmpty())
        scanDevices();

    QStringList list = m_device_name_map.keys();

    // move the "default" device to the start of the list
    if (list.contains(DEFAULT_DEVICE))
        list.move(list.indexOf(DEFAULT_DEVICE), 0);

    if (!list.isEmpty()) list.append(_("#TREE#"));

    return list;
}

Here is the call graph for this function:

write()

int Kwave::PlayBackQt::write ( const Kwave::SampleArray &  samples )

virtual

Writes an array of samples to the output device.

See also

PlayBackDevice::write

Implements Kwave::PlayBackDevice.

Definition at line 219 of file PlayBack-Qt.cpp.

References Kwave::SampleEncoder::encode(), m_buffer, m_encoder, m_lock, m_output, Kwave::SampleEncoder::rawBytesPerSample(), Kwave::SampleArray::size(), and Kwave::PlayBackQt::Buffer::writeData().

{
    QByteArray frame;

    {
        QMutexLocker _lock(&m_lock); // context: worker thread

        if (!m_encoder || !m_output) return -EIO;

        int bytes_per_sample = m_encoder->rawBytesPerSample();
        int bytes_raw        = samples.size() * bytes_per_sample;

        frame.resize(bytes_raw);
        frame.fill(char(0));
        m_encoder->encode(samples, samples.size(), frame);
    }

    qint64 written = m_buffer.writeData(frame.constData(), frame.size());
    if (written != frame.size()) {
        qDebug("WARNING: Kwave::PlayBackQt::write: written=%lld/%d",
               written, frame.size());
        return -EIO;
    }

    return 0;
}

Here is the call graph for this function:

Member Data Documentation

m_available_devices

QList<QAudioDeviceInfo> Kwave::PlayBackQt::m_available_devices

private

list of available Qt output devices

Definition at line 231 of file PlayBack-Qt.h.

Referenced by close(), deviceInfo(), scanDevices(), and supportedDevices().

m_buffer

Kwave::PlayBackQt::Buffer Kwave::PlayBackQt::m_buffer

private

Definition at line 242 of file PlayBack-Qt.h.

Referenced by close(), open(), and write().

m_buffer_size

unsigned int Kwave::PlayBackQt::m_buffer_size

private

buffer size in bytes

Definition at line 237 of file PlayBack-Qt.h.

Referenced by open().

m_device_name_map

QMap<QString, QString> Kwave::PlayBackQt::m_device_name_map

private

dictionary for translating verbose device names into Qt audio output device names (key = verbose name, data = Qt output device name)

Definition at line 228 of file PlayBack-Qt.h.

Referenced by close(), deviceInfo(), scanDevices(), and supportedDevices().

m_encoder

Kwave::SampleEncoder* Kwave::PlayBackQt::m_encoder

private

encoder for converting from samples to raw format

Definition at line 240 of file PlayBack-Qt.h.

Referenced by close(), createEncoder(), open(), and write().

m_lock

QMutex Kwave::PlayBackQt::m_lock

private

mutex for locking the streaming thread against main thread

Definition at line 221 of file PlayBack-Qt.h.

Referenced by close(), detectChannels(), open(), supportedBits(), supportedDevices(), and write().

m_output

QAudioOutput* Kwave::PlayBackQt::m_output

private

Qt audio output instance

Definition at line 234 of file PlayBack-Qt.h.

Referenced by close(), open(), stateChanged(), and write().

---

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

• plugins/playback/PlayBack-Qt.h
• plugins/playback/PlayBack-Qt.cpp