Kwave::RecordQt Class Reference

#include <Record-Qt.h>

Inheritance diagram for Kwave::RecordQt:

Collaboration diagram for Kwave::RecordQt:

Signals
void	sigCreateRequested (QAudioFormat &format, unsigned int buffer_size)
void	sigCloseRequested ()

Public Member Functions
	RecordQt ()
virtual	~RecordQt () Q_DECL_OVERRIDE
virtual QString	open (const QString &dev) Q_DECL_OVERRIDE
virtual Kwave::byte_order_t	endianness () Q_DECL_OVERRIDE
virtual Kwave::SampleFormat::Format	sampleFormat () Q_DECL_OVERRIDE
virtual int	setSampleFormat (Kwave::SampleFormat::Format new_format) Q_DECL_OVERRIDE
virtual QList< Kwave::SampleFormat::Format >	detectSampleFormats () Q_DECL_OVERRIDE
virtual int	bitsPerSample () Q_DECL_OVERRIDE
virtual int	setBitsPerSample (unsigned int new_bits) Q_DECL_OVERRIDE
virtual QList< unsigned int >	supportedBits () Q_DECL_OVERRIDE
virtual Kwave::Compression::Type	compression () Q_DECL_OVERRIDE
virtual int	setCompression (Kwave::Compression::Type new_compression) Q_DECL_OVERRIDE
virtual QList< Kwave::Compression::Type >	detectCompressions () Q_DECL_OVERRIDE
virtual double	sampleRate () Q_DECL_OVERRIDE
virtual int	setSampleRate (double &new_rate) Q_DECL_OVERRIDE
virtual QList< double >	detectSampleRates () Q_DECL_OVERRIDE
virtual int	tracks () Q_DECL_OVERRIDE
virtual int	setTracks (unsigned int &tracks) Q_DECL_OVERRIDE
virtual int	detectTracks (unsigned int &min, unsigned int &max) Q_DECL_OVERRIDE
virtual int	close () Q_DECL_OVERRIDE
virtual int	read (QByteArray &buffer, unsigned int offset) Q_DECL_OVERRIDE
virtual QStringList	supportedDevices () Q_DECL_OVERRIDE
Public Member Functions inherited from Kwave::RecordDevice
	RecordDevice ()
virtual	~RecordDevice ()
virtual QString	fileFilter ()

Private Slots
void	createInMainThread (QAudioFormat &format, unsigned int buffer_size)
void	closeInMainThread ()
void	notified ()

Private Member Functions
int	initialize (unsigned int buffer_size)
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
QAudioInput *	m_input
QIODevice *	m_source
Kwave::SampleFormat::Format	m_sample_format
quint8	m_tracks
double	m_rate
Kwave::Compression::Type	m_compression
unsigned int	m_bits_per_sample
QString	m_device
bool	m_initialized
QSemaphore	m_sem

Detailed Description

Definition at line 46 of file Record-Qt.h.

Constructor & Destructor Documentation

RecordQt()

Kwave::RecordQt::RecordQt

(

)

Constructor

Definition at line 60 of file Record-Qt.cpp.

References closeInMainThread(), Kwave::connect(), createInMainThread(), sigCloseRequested(), and sigCreateRequested().

    :QObject(Q_NULLPTR),
     Kwave::RecordDevice(),
     m_lock(QMutex::Recursive),
     m_device_name_map(),
     m_available_devices(),
     m_input(Q_NULLPTR),
     m_source(Q_NULLPTR),
     m_sample_format(Kwave::SampleFormat::Unknown),
     m_tracks(0),
     m_rate(0.0),
     m_compression(Kwave::Compression::NONE),
     m_bits_per_sample(0),
     m_device(),
     m_initialized(false),
     m_sem(0)
{
    connect(this, SIGNAL(sigCreateRequested(QAudioFormat&,uint)),
            this, SLOT(createInMainThread(QAudioFormat&,uint)),
            Qt::BlockingQueuedConnection);
    connect(this, SIGNAL(sigCloseRequested()),
            this, SLOT(closeInMainThread()),
            Qt::BlockingQueuedConnection);
}

Here is the call graph for this function:

~RecordQt()

Kwave::RecordQt::~RecordQt ( )

virtual

Destructor

Definition at line 86 of file Record-Qt.cpp.

References close().

{
    close();
}

Here is the call graph for this function:

Member Function Documentation

bitsPerSample()

int Kwave::RecordQt::bitsPerSample ( )

virtual

Returns the current resolution in bits per sample or a negative error code if failed

Implements Kwave::RecordDevice.

Definition at line 164 of file Record-Qt.cpp.

References m_bits_per_sample.

{
    return m_bits_per_sample;
}

close()

int Kwave::RecordQt::close ( )

virtual

Close the device

Implements Kwave::RecordDevice.

Definition at line 344 of file Record-Qt.cpp.

References closeInMainThread(), m_lock, and sigCloseRequested().

Referenced by open(), setBitsPerSample(), setCompression(), setSampleFormat(), setSampleRate(), setTracks(), and ~RecordQt().

{
    QMutexLocker _lock(&m_lock);

    if (QThread::currentThread() == qApp->thread())
        closeInMainThread();
    else
        emit sigCloseRequested();

    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

closeInMainThread

void Kwave::RecordQt::closeInMainThread ( )

privateslot

handles the request to close the device, running in the context of the main thread

Definition at line 327 of file Record-Qt.cpp.

References m_initialized, m_input, and m_source.

Referenced by close(), and RecordQt().

{
    if (m_source) {
        m_source->close();
        m_source = Q_NULLPTR;
    }
    if (m_input) {
        m_input->stop();
        m_input->reset();
        delete m_input;
        m_input = Q_NULLPTR;
    }

    m_initialized = false;
}

Here is the caller graph for this function:

compression()

Kwave::Compression::Type Kwave::RecordQt::compression ( )

virtual

Returns the current compression type (0==none)

Implements Kwave::RecordDevice.

Definition at line 201 of file Record-Qt.cpp.

References m_compression.

{
    return m_compression;
}

createInMainThread

void Kwave::RecordQt::createInMainThread ( QAudioFormat &  format, unsigned int  buffer_size  )

privateslot

handles the request to create the device, running in the context of the main thread

Parameters

format	reference to the audio format specification
buffer_size	size of the audio buffer in bytes

Definition at line 492 of file Record-Qt.cpp.

References BUFFER_SIZE_OVERCOMMIT, Kwave::connect(), m_input, m_lock, m_sem, m_source, and notified().

Referenced by initialize(), and RecordQt().

{
    QMutexLocker _lock(&m_lock);

    // reset the semaphore to zero
    m_sem.acquire(m_sem.available());

    // create a new audio device for the selected format
    m_input = new QAudioInput(format, this);
    Q_ASSERT(m_input);
    if (!m_input) return;
    connect(m_input, SIGNAL(notify()), this, SLOT(notified()));

    // set the buffer size, before starting to record
    m_input->setBufferSize(buffer_size * BUFFER_SIZE_OVERCOMMIT);

    // start recording engine
    m_source = m_input->start();
}

Here is the call graph for this function:

Here is the caller graph for this function:

detectCompressions()

QList< Kwave::Compression::Type > Kwave::RecordQt::detectCompressions ( )

virtual

Gets a list of supported compression types. If no compression is supported, the list might be empty.

Implements Kwave::RecordDevice.

Definition at line 217 of file Record-Qt.cpp.

References Kwave::Compression::NONE.

{
    QList<Kwave::Compression::Type> list;
    list.append(Kwave::Compression::NONE);
    return list;
}

detectSampleFormats()

QList< Kwave::SampleFormat::Format > Kwave::RecordQt::detectSampleFormats ( )

virtual

Gets a list of supported sample formats.

Note

this depends on the current setting of the compression!

Implements Kwave::RecordDevice.

Definition at line 107 of file Record-Qt.cpp.

References deviceInfo(), Kwave::SampleFormat::Float, m_device, m_lock, Kwave::SampleFormat::Signed, and Kwave::SampleFormat::Unsigned.

{
    QList<Kwave::SampleFormat::Format> list;
    QMutexLocker _lock(&m_lock); // context: main thread

    const QAudioDeviceInfo info(deviceInfo(m_device));

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

    // iterate over all supported bits per sample
    foreach (QAudioFormat::SampleType t, info.supportedSampleTypes()) {
        switch (t) {
            case QAudioFormat::SignedInt:
                list.append(Kwave::SampleFormat::Signed);
                break;
            case QAudioFormat::UnSignedInt:
                list.append(Kwave::SampleFormat::Unsigned);
                break;
            case QAudioFormat::Float:
                list.append(Kwave::SampleFormat::Float);
                break;
            default:
                break;
        }
    }

    return list;
}

Here is the call graph for this function:

detectSampleRates()

QList< double > Kwave::RecordQt::detectSampleRates ( )

virtual

get a list of supported sample rates

Implements Kwave::RecordDevice.

Definition at line 241 of file Record-Qt.cpp.

References deviceInfo(), m_device, and m_lock.

{
    QList<double> list;
    QMutexLocker _lock(&m_lock); // context: main thread

    const QAudioDeviceInfo info(deviceInfo(m_device));

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

    // iterate over all supported sample sizes
    foreach (int rate, info.supportedSampleRates()) {
        if (rate <= 0) continue;
        list.append(static_cast<double>(rate));
    }

    std::sort(list.begin(), list.end(), std::less<double>());
    return list;
}

Here is the call graph for this function:

detectTracks()

int Kwave::RecordQt::detectTracks ( unsigned int &  min, unsigned int &  max  )

virtual

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

Parameters

min	receives the lowest supported number of tracks
max	receives the highest supported number of tracks

Returns

zero or positive if ok, negative error number if failed

Implements Kwave::RecordDevice.

Definition at line 279 of file Record-Qt.cpp.

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

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

    const QAudioDeviceInfo info(deviceInfo(m_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::RecordQt::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 304 of file Record-Qt.cpp.

References DEFAULT_DEVICE, m_available_devices, and m_device_name_map.

Referenced by detectSampleFormats(), detectSampleRates(), detectTracks(), endianness(), initialize(), open(), and supportedBits().

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

    // 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:

endianness()

Kwave::byte_order_t Kwave::RecordQt::endianness ( )

virtual

Returns the current endianness (big/little)

Implements Kwave::RecordDevice.

Definition at line 138 of file Record-Qt.cpp.

References Kwave::BigEndian, deviceInfo(), Kwave::LittleEndian, m_device, m_lock, and Kwave::UnknownEndian.

{
    Kwave::byte_order_t byte_order = Kwave::UnknownEndian;
    QMutexLocker _lock(&m_lock); // context: main thread

    const QAudioDeviceInfo info(deviceInfo(m_device));

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

    // iterate over all supported bits per sample
    switch (info.preferredFormat().byteOrder()) {
        case QAudioFormat::LittleEndian:
            byte_order = Kwave::LittleEndian;
            break;
        case QAudioFormat::BigEndian:
            byte_order = Kwave::BigEndian;
            break;
        default:
            break;
    }

    return byte_order;
}

Here is the call graph for this function:

initialize()

int Kwave::RecordQt::initialize ( unsigned int  buffer_size )

private

Initialize the audio device with current parameters and prepare it for recording.

Parameters

buffer_size

size of the audio buffer in bytes

Returns

zero on success or negative error code -EINVAL or -EIO

Definition at line 432 of file Record-Qt.cpp.

References _, createInMainThread(), deviceInfo(), m_bits_per_sample, m_device, m_rate, m_tracks, sigCreateRequested(), and Kwave::toInt().

Referenced by read().

{
    // do sanity checks of the current parameters, otherwise Qt crashes
    // with floating point errors or similar
    if (m_rate < 1.0)          return -EINVAL;
    if (m_bits_per_sample < 1) return -EINVAL;
    if (m_tracks < 1)          return -EINVAL;
    if (!m_device.length())    return -EINVAL;

    const QAudioDeviceInfo info(deviceInfo(m_device));

    // find a supported sample format
    const QAudioFormat preferred_format(info.preferredFormat());
    QAudioFormat format(preferred_format);
    format.setSampleSize(Kwave::toInt(m_bits_per_sample));
    format.setChannelCount(Kwave::toInt(m_tracks));
    format.setSampleRate(Kwave::toInt(m_rate));
    format.setCodec(_("audio/pcm"));

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

    if (format.codec() != _("audio/pcm")) {
        qWarning("PCM encoding is not supported");
        return -EIO;
    }

    if (format.sampleSize() != Kwave::toInt(m_bits_per_sample)) {
        qWarning("%d bits per sample are not supported", m_bits_per_sample);
        return -EIO;
    }

    if (format.channelCount() != Kwave::toInt(m_tracks)) {
        qWarning("recording with %d channels is not supported", m_tracks);
        return -EIO;
    }

    if (format.sampleRate() != Kwave::toInt(m_rate)) {
        qWarning("sample rate %d Hz is not supported", Kwave::toInt(m_rate));
        return -EIO;
    }

    if ( (format.sampleType() != QAudioFormat::SignedInt) &&
         (format.sampleType() != QAudioFormat::UnSignedInt) )
    {
        qWarning("integer sample format is not supported");
        return -EIO;
    }

    // create a new Qt output device
    if (QThread::currentThread() == qApp->thread())
        createInMainThread(format, buffer_size);
    else
        emit sigCreateRequested(format, buffer_size);

    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

notified

void Kwave::RecordQt::notified ( )

privateslot

called when recorded data gets available

Definition at line 514 of file Record-Qt.cpp.

References m_sem.

Referenced by createInMainThread().

{
    m_sem.release();
}

Here is the caller graph for this function:

open()

QString Kwave::RecordQt::open ( const QString &  dev )

virtual

Open the record device.

Parameters

dev	path of the record device

Return values

QString()	if successful
QString::number(ENODEV)	if device not found
QString::number(EBUSY)	if device is busy
QString(...)	device specific error message (already translated)

Implements Kwave::RecordDevice.

Definition at line 391 of file Record-Qt.cpp.

References close(), deviceInfo(), m_device, m_lock, and scanDevices().

{

    // close the previous device
    close();

    QMutexLocker _lock(&m_lock);

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

    const QAudioDeviceInfo info(deviceInfo(device));
    if (info.isNull()) {
        return QString::number(ENODEV);
    }

    m_device = device;
    return QString();
}

Here is the call graph for this function:

read()

int Kwave::RecordQt::read ( QByteArray &  buffer, unsigned int  offset  )

virtual

Read the raw audio data from the record device.

Parameters

buffer	array of bytes to receive the audio data might be resized for alignment
offset	offset in bytes within the buffer

Returns

number of bytes read, zero or negative if failed

Implements Kwave::RecordDevice.

Definition at line 357 of file Record-Qt.cpp.

References BUFFER_SIZE_OVERCOMMIT, initialize(), m_initialized, m_input, m_sem, m_source, RECORD_POLL_TIMEOUT, and Kwave::toInt().

{
    if (buffer.isNull() || buffer.isEmpty())
        return 0; // no buffer, nothing to do

    int buffer_size = buffer.size();

    // we configure our device at a late stage, otherwise we would not
    // know the internal buffer size
    if (!m_initialized) {
        int err = initialize(buffer_size);
        if (err < 0) return -EAGAIN;
        m_initialized = true;
    }
    Q_ASSERT(m_source);
    Q_ASSERT(m_input);
    if (!m_source || !m_input)
        return -ENODEV;

    // adjust the buffer size if is has been changed in the plugin
    if ((buffer_size > 0) && (m_input->bufferSize() != buffer_size))
        m_input->setBufferSize(buffer_size * BUFFER_SIZE_OVERCOMMIT);

    // wait until some data gets available (with timeout)
    m_sem.tryAcquire(1, RECORD_POLL_TIMEOUT);

    char *p = buffer.data() + offset;
    unsigned int len = buffer.length() - offset;
    qint64 length = m_source->read(p, len);

    return (length < 1) ? -EAGAIN : Kwave::toInt(length);
}

Here is the call graph for this function:

sampleFormat()

Kwave::SampleFormat::Format Kwave::RecordQt::sampleFormat ( )

virtual

Returns the current sample format (signed/unsigned)

Implements Kwave::RecordDevice.

Definition at line 92 of file Record-Qt.cpp.

References m_sample_format.

{
    return m_sample_format;
}

sampleRate()

double Kwave::RecordQt::sampleRate ( )

virtual

Returns the current sample rate of the device

Implements Kwave::RecordDevice.

Definition at line 225 of file Record-Qt.cpp.

References m_rate.

{
    return m_rate;
}

scanDevices()

void Kwave::RecordQt::scanDevices ( )

private

scan all PulseAudio source, re-creates m_device_list

Definition at line 520 of file Record-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::AudioInput))
    {
        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("RecordQt::supportedDevices() "
                      "=> BUG: device with no name?");
            continue;
        }

        QString gui_name = qt_name + _("|sound_note");
        if (m_device_name_map.contains(gui_name)) {
            qWarning("RecordQt::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:

setBitsPerSample()

int Kwave::RecordQt::setBitsPerSample ( unsigned int  new_bits )

virtual

Set the resolution in bits per sample

Parameters

new_bits

resolution [bits/sample]

Returns

zero on success, negative error code if failed

Implements Kwave::RecordDevice.

Definition at line 170 of file Record-Qt.cpp.

References close(), and m_bits_per_sample.

{
    if (new_bits == m_bits_per_sample) return 0;

    close();
    m_bits_per_sample = new_bits;
    return 0;
}

Here is the call graph for this function:

setCompression()

int Kwave::RecordQt::setCompression ( Kwave::Compression::Type  new_compression )

virtual

Try to set a new compression type.

Parameters

new_compression

the identifier of the new compression

Returns

zero on success, negative error code if failed

See also

class Compression

Implements Kwave::RecordDevice.

Definition at line 207 of file Record-Qt.cpp.

References close(), and m_compression.

{
    if (new_compression != m_compression) {
        close();
        m_compression = new_compression;
    }
    return 0;
}

Here is the call graph for this function:

setSampleFormat()

int Kwave::RecordQt::setSampleFormat ( Kwave::SampleFormat::Format  new_format )

virtual

Try to set a new sample format (signed/unsigned)

Parameters

new_format

the identifier for the new format

Returns

zero on success, negative error code if failed

See also

class SampleFormat

Implements Kwave::RecordDevice.

Definition at line 98 of file Record-Qt.cpp.

References close(), and m_sample_format.

{
    if (m_sample_format == new_format) return 0;
    close();
    m_sample_format = new_format;
    return 0;
}

Here is the call graph for this function:

setSampleRate()

int Kwave::RecordQt::setSampleRate ( double &  new_rate )

virtual

Try to set a new sample rate.

Parameters

new_rate

the sample rate to be set [samples/second], can be modified and rounded up/down to the nearest supported sample rate if the underlying driver supports that.

Returns

zero on success, negative error code if failed

Implements Kwave::RecordDevice.

Definition at line 231 of file Record-Qt.cpp.

References close(), and m_rate.

{
    if (qFuzzyCompare(new_rate, m_rate))  return 0;

    close();
    m_rate = new_rate;
    return 0;
}

Here is the call graph for this function:

setTracks()

int Kwave::RecordQt::setTracks ( unsigned int &  tracks )

virtual

Try to set a new number of tracks.

Note

the device must be open

Parameters

tracks

the number of tracks to be set, can be modified and decreased to the next supported number of tracks if the underlying driver supports that.

Returns

zero on success, negative error code if failed

Implements Kwave::RecordDevice.

Definition at line 268 of file Record-Qt.cpp.

References close(), m_tracks, and tracks().

{
    if (tracks == m_tracks) return 0;
    if (tracks > 255) tracks = 255;

    close();
    m_tracks = static_cast<quint8>(tracks);
    return 0;
}

Here is the call graph for this function:

sigCloseRequested

void Kwave::RecordQt::sigCloseRequested ( )

signal

request closeInMainThread()

Referenced by close(), and RecordQt().

Here is the caller graph for this function:

sigCreateRequested

void Kwave::RecordQt::sigCreateRequested ( QAudioFormat &  format, unsigned int  buffer_size  )

signal

request createInMainThread()

Parameters

format	reference to the audio format specification
buffer_size	size of the audio buffer in bytes

Referenced by initialize(), and RecordQt().

Here is the caller graph for this function:

supportedBits()

QList< unsigned int > Kwave::RecordQt::supportedBits ( )

virtual

Detect a list of supported bits per sample.

Note

this depends on the compression type

Returns

a list of bits per sample, empty if failed

Implements Kwave::RecordDevice.

Definition at line 180 of file Record-Qt.cpp.

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

{
    QList<unsigned int> list;
    QMutexLocker _lock(&m_lock); // context: main thread

    const QAudioDeviceInfo info(deviceInfo(m_device));

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

    // iterate over all supported bits per sample
    foreach (int bits, info.supportedSampleSizes()) {
        if (bits <= 0) continue;
        list.append(Kwave::toUint(bits));
    }

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

Here is the call graph for this function:

supportedDevices()

QStringList Kwave::RecordQt::supportedDevices ( )

virtual

return a string list with supported device names

Implements Kwave::RecordDevice.

Definition at line 412 of file Record-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:

tracks()

int Kwave::RecordQt::tracks ( )

virtual

Returns the current number of tracks

Implements Kwave::RecordDevice.

Definition at line 262 of file Record-Qt.cpp.

References m_tracks.

Referenced by setTracks().

{
    return m_tracks;
}

Here is the caller graph for this function:

Member Data Documentation

m_available_devices

QList<QAudioDeviceInfo> Kwave::RecordQt::m_available_devices

private

list of available Qt output devices

Definition at line 250 of file Record-Qt.h.

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

m_bits_per_sample

unsigned int Kwave::RecordQt::m_bits_per_sample

private

resolution [bits per sample]

Definition at line 271 of file Record-Qt.h.

Referenced by bitsPerSample(), initialize(), and setBitsPerSample().

m_compression

Kwave::Compression::Type Kwave::RecordQt::m_compression

private

compression mode

Definition at line 268 of file Record-Qt.h.

Referenced by compression(), and setCompression().

m_device

QString Kwave::RecordQt::m_device

private

encoded name of the sink

Definition at line 274 of file Record-Qt.h.

Referenced by detectSampleFormats(), detectSampleRates(), detectTracks(), endianness(), initialize(), open(), and supportedBits().

m_device_name_map

QMap<QString, QString> Kwave::RecordQt::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 247 of file Record-Qt.h.

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

m_initialized

bool Kwave::RecordQt::m_initialized

private

true if initialize() has been successfully been run

Definition at line 277 of file Record-Qt.h.

Referenced by closeInMainThread(), and read().

m_input

QAudioInput* Kwave::RecordQt::m_input

private

Qt audio input instance

Definition at line 253 of file Record-Qt.h.

Referenced by closeInMainThread(), createInMainThread(), and read().

m_lock

QMutex Kwave::RecordQt::m_lock

private

mutex for locking the streaming thread against main thread

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

Referenced by close(), createInMainThread(), detectSampleFormats(), detectSampleRates(), detectTracks(), endianness(), open(), supportedBits(), and supportedDevices().

m_rate

double Kwave::RecordQt::m_rate

private

sample rate

Definition at line 265 of file Record-Qt.h.

Referenced by initialize(), sampleRate(), and setSampleRate().

m_sample_format

Kwave::SampleFormat::Format Kwave::RecordQt::m_sample_format

private

sample format (signed int, unsigned int, float, ...

Definition at line 259 of file Record-Qt.h.

Referenced by sampleFormat(), and setSampleFormat().

m_sem

QSemaphore Kwave::RecordQt::m_sem

private

semaphore for signaling "data available"

Definition at line 280 of file Record-Qt.h.

Referenced by createInMainThread(), notified(), and read().

m_source

QIODevice* Kwave::RecordQt::m_source

private

QIODevice for reading the data

Definition at line 256 of file Record-Qt.h.

Referenced by closeInMainThread(), createInMainThread(), and read().

m_tracks

quint8 Kwave::RecordQt::m_tracks

private

number of tracks [0...N-1]

Definition at line 262 of file Record-Qt.h.

Referenced by initialize(), setTracks(), and tracks().

---

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

• plugins/record/Record-Qt.h
• plugins/record/Record-Qt.cpp