Kwave::RecordPulseAudio Class Reference

#include <Record-PulseAudio.h>

Inheritance diagram for Kwave::RecordPulseAudio:

Collaboration diagram for Kwave::RecordPulseAudio:

Classes
struct	source_info_t

Public Member Functions
	RecordPulseAudio ()
virtual	~RecordPulseAudio () 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
int	mainloopPoll (struct pollfd *ufds, unsigned long int nfds, int timeout)
Public Member Functions inherited from Kwave::RecordDevice
	RecordDevice ()
virtual	~RecordDevice ()
virtual QString	fileFilter ()
Public Member Functions inherited from Kwave::Runnable
virtual	~Runnable ()

Protected Member Functions
virtual void	run_wrapper (const QVariant &params) Q_DECL_OVERRIDE

Private Member Functions
void	detectSupportedFormats (const QString &device)
void	notifySourceInfo (pa_context *c, const pa_source_info *info, int eol)
void	notifyContext (pa_context *c)
void	notifyStreamState (pa_stream *stream)
void	notifyRead (pa_stream *stream, size_t nbytes)
bool	connectToServer ()
void	disconnectFromServer ()
void	scanDevices ()
pa_sample_format_t	mode2format (int compression, int bits, Kwave::SampleFormat::Format sample_format)
int	initialize (uint32_t buffer_size)

Static Private Member Functions
static void	pa_context_notify_cb (pa_context *c, void *userdata)
static void	pa_source_info_cb (pa_context *c, const pa_source_info *info, int eol, void *userdata)
static void	pa_stream_state_cb (pa_stream *p, void *userdata)
static void	pa_read_cb (pa_stream *p, size_t nbytes, void *userdata)

Private Attributes
Kwave::WorkerThread	m_mainloop_thread
QMutex	m_mainloop_lock
QWaitCondition	m_mainloop_signal
Kwave::SampleFormat::Format	m_sample_format
quint8	m_tracks
double	m_rate
Kwave::Compression::Type	m_compression
unsigned int	m_bits_per_sample
QList< pa_sample_format_t >	m_supported_formats
bool	m_initialized
pa_proplist *	m_pa_proplist
pa_mainloop *	m_pa_mainloop
pa_context *	m_pa_context
pa_stream *	m_pa_stream
QString	m_pa_device
QString	m_name
QString	m_device
QMap< QString, source_info_t >	m_device_list

Detailed Description

Definition at line 49 of file Record-PulseAudio.h.

Constructor & Destructor Documentation

RecordPulseAudio()

Kwave::RecordPulseAudio::RecordPulseAudio

(

)

Constructor

Definition at line 199 of file Record-PulseAudio.cpp.

    :Kwave::RecordDevice(),
    m_mainloop_thread(this, QVariant()),
    m_mainloop_lock(),
    m_mainloop_signal(),
    m_sample_format(Kwave::SampleFormat::Unknown),
    m_tracks(0),
    m_rate(0.0),
    m_compression(Kwave::Compression::NONE),
    m_bits_per_sample(0),
    m_supported_formats(),
    m_initialized(false),
    m_pa_proplist(Q_NULLPTR),
    m_pa_mainloop(Q_NULLPTR),
    m_pa_context(Q_NULLPTR),
    m_pa_stream(Q_NULLPTR),
    m_pa_device(),
    m_name(i18n("Kwave record")),
    m_device_list()
{
}

~RecordPulseAudio()

Kwave::RecordPulseAudio::~RecordPulseAudio ( )

virtual

Destructor

Definition at line 222 of file Record-PulseAudio.cpp.

References disconnectFromServer(), and m_device_list.

{
    disconnectFromServer();
    m_device_list.clear();
}

Here is the call graph for this function:

Member Function Documentation

bitsPerSample()

int Kwave::RecordPulseAudio::bitsPerSample ( )

virtual

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

Implements Kwave::RecordDevice.

Definition at line 455 of file Record-PulseAudio.cpp.

References m_bits_per_sample.

{
    return m_bits_per_sample;
}

close()

int Kwave::RecordPulseAudio::close ( )

virtual

Close the device

Implements Kwave::RecordDevice.

Definition at line 639 of file Record-PulseAudio.cpp.

References m_initialized, m_mainloop_lock, m_mainloop_signal, m_pa_stream, and TIMEOUT_DISCONNECT_STREAM.

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

{
    if (m_pa_stream) {
        pa_stream_drop(m_pa_stream);

        m_mainloop_lock.lock();
        pa_stream_disconnect(m_pa_stream);
        qDebug("RecordPulseAudio::close() - waiting for stream disconnect...");
        m_mainloop_signal.wait(&m_mainloop_lock, TIMEOUT_DISCONNECT_STREAM);
        m_mainloop_lock.unlock();
        qDebug("RecordPulseAudio::close() - stream disconnect DONE");

        pa_stream_unref(m_pa_stream);
    }
    m_pa_stream = Q_NULLPTR;

    // we need to re-initialize the next time
    m_initialized = false;
    return 0;
}

Here is the caller graph for this function:

compression()

Kwave::Compression::Type Kwave::RecordPulseAudio::compression ( )

virtual

Returns the current compression type (0==none)

Implements Kwave::RecordDevice.

Definition at line 496 of file Record-PulseAudio.cpp.

References m_compression.

Referenced by detectCompressions().

{
    return m_compression;
}

Here is the caller graph for this function:

connectToServer()

bool Kwave::RecordPulseAudio::connectToServer ( )

private

Try to connect to the PulseAudio server and create a valid context

Definition at line 886 of file Record-PulseAudio.cpp.

References disconnectFromServer(), m_mainloop_lock, m_mainloop_signal, m_mainloop_thread, m_pa_context, m_pa_mainloop, m_pa_proplist, name, pa_context_notify_cb(), poll_func(), Kwave::WorkerThread::start(), TIMEOUT_CONNECT_TO_SERVER, and UTF8.

Referenced by initialize(), and scanDevices().

{
    if (m_pa_context) return true; // already connected

    // set hourglass cursor, we are waiting...
    QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));

    // create a property list for this application
    m_pa_proplist = pa_proplist_new();
    Q_ASSERT(m_pa_proplist);

    pa_proplist_sets(m_pa_proplist, PA_PROP_APPLICATION_LANGUAGE,
                     UTF8(QLocale::system().name()));
    pa_proplist_sets(m_pa_proplist, PA_PROP_APPLICATION_NAME,
                     UTF8(qApp->applicationName()));
    pa_proplist_sets(m_pa_proplist, PA_PROP_APPLICATION_ICON_NAME,
                     "kwave");
    pa_proplist_sets(m_pa_proplist, PA_PROP_APPLICATION_PROCESS_BINARY,
                     "kwave");
    pa_proplist_setf(m_pa_proplist, PA_PROP_APPLICATION_PROCESS_ID,
                    "%ld", static_cast<long int>(qApp->applicationPid()));
    KUser user;
    pa_proplist_sets(m_pa_proplist, PA_PROP_APPLICATION_PROCESS_USER,
                     UTF8(user.loginName()));
    pa_proplist_sets(m_pa_proplist, PA_PROP_APPLICATION_VERSION,
                     UTF8(qApp->applicationVersion()));

    pa_proplist_sets(m_pa_proplist, PA_PROP_MEDIA_ROLE, "production");

    // ignore SIGPIPE in this context
#ifdef HAVE_SIGNAL_H
    signal(SIGPIPE, SIG_IGN);
#endif

    m_pa_mainloop = pa_mainloop_new();
    Q_ASSERT(m_pa_mainloop);
    pa_mainloop_set_poll_func(m_pa_mainloop, poll_func, this);

    m_pa_context = pa_context_new_with_proplist(
        pa_mainloop_get_api(m_pa_mainloop),
        "Kwave",
        m_pa_proplist
    );

    // set the callback for getting informed about the context state
    pa_context_set_state_callback(m_pa_context, pa_context_notify_cb, this);

    // connect to the pulse audio server server
    bool failed = false;
    int error = pa_context_connect(
        m_pa_context,                       // context
        Q_NULLPTR,                          // server
        static_cast<pa_context_flags_t>(0), // flags
        Q_NULLPTR                           // API
    );
    if (error < 0)
    {
        qWarning("RecordPulseAudio: pa_contect_connect failed (%s)",
                  pa_strerror(pa_context_errno(m_pa_context)));
        failed = true;
    }

    if (!failed) {
        m_mainloop_lock.lock();
        m_mainloop_thread.start();

        // wait until the context state is either connected or failed
        failed = true;
        if ( m_mainloop_signal.wait(&m_mainloop_lock,
                                    TIMEOUT_CONNECT_TO_SERVER) )
        {
            if (pa_context_get_state(m_pa_context) == PA_CONTEXT_READY) {
                failed = false;
            }
        }
        m_mainloop_lock.unlock();

        if (failed) {
            qWarning("RecordPulseAudio: context FAILED (%s):-(",
                     pa_strerror(pa_context_errno(m_pa_context)));
        }
    }

    // if the connection failed, clean up
    if (failed) {
        disconnectFromServer();
    }

    QApplication::restoreOverrideCursor();

    return !failed;
}

Here is the call graph for this function:

Here is the caller graph for this function:

detectCompressions()

QList< Kwave::Compression::Type > Kwave::RecordPulseAudio::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 514 of file Record-PulseAudio.cpp.

References compression(), compression_of(), and m_supported_formats.

{
    QList<Kwave::Compression::Type> list;

    // try all known sample formats
    foreach (const pa_sample_format_t &fmt, m_supported_formats)
    {
        Kwave::Compression::Type compression = compression_of(fmt);

        // do not produce duplicates
        if (list.contains(compression)) continue;

        Kwave::Compression t(compression);
        list.append(compression);
    }

    return list;
}

Here is the call graph for this function:

detectSampleFormats()

QList< Kwave::SampleFormat::Format > Kwave::RecordPulseAudio::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 430 of file Record-PulseAudio.cpp.

References bits_of(), compression_of(), m_bits_per_sample, m_compression, m_supported_formats, sample_format_of(), and Kwave::toInt().

{
    QList<Kwave::SampleFormat::Format> list;

    // try all known sample formats
    foreach (const pa_sample_format_t &fmt, m_supported_formats)
    {
        const Kwave::SampleFormat::Format sample_format = sample_format_of(fmt);

        // only accept bits/sample if compression types
        // and bits per sample match
        if (compression_of(fmt) != m_compression) continue;
        if (bits_of(fmt) != Kwave::toInt(m_bits_per_sample))
            continue;

        // do not produce duplicates
        if (list.contains(sample_format)) continue;

        list.append(sample_format);
    }

    return list;
}

Here is the call graph for this function:

detectSampleRates()

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

virtual

get a list of supported sample rates

Implements Kwave::RecordDevice.

Definition at line 550 of file Record-PulseAudio.cpp.

References ELEMENTS_OF, m_device, and m_device_list.

{
    QList<double> list;

    static const unsigned int known_rates[] = {
          1,
          1000, // (just for testing)
          2000, // (just for testing)
          4000, // standard OSS
          5125, // seen in Harmony driver (HP712, 715/new)
          5510, // seen in AD1848 driver
          5512, // seen in ES1370 driver
          6215, // seen in ES188X driver
          6615, // seen in Harmony driver (HP712, 715/new)
          6620, // seen in AD1848 driver
          7350, // seen in AWACS and Burgundy sound driver
          8000, // standard OSS
          8820, // seen in AWACS and Burgundy sound driver
          9600, // seen in AD1848 driver
         11025, // soundblaster
         14700, // seen in AWACS and Burgundy sound driver
         16000, // standard OSS
         17640, // seen in AWACS and Burgundy sound driver
         18900, // seen in Harmony driver (HP712, 715/new)
         22050, // soundblaster
         24000, // seen in NM256 driver
         27428, // seen in Harmony driver (HP712, 715/new)
         29400, // seen in AWACS and Burgundy sound driver
         32000, // standard OSS
         32768, // seen in CS4299 driver
         33075, // seen in Harmony driver (HP712, 715/new)
         37800, // seen in Harmony driver (HP712, 715/new)
         44100, // soundblaster
         48000, // AC97
         64000, // AC97
         88200, // seen in RME96XX driver
         96000, // AC97
        128000, // (just for testing)
        192000 // AC97
    };

    pa_sample_spec sampleSpec = m_device_list[m_device].m_sample_spec;
    uint32_t rate = sampleSpec.rate;
    for (unsigned int i = 0; i < ELEMENTS_OF(known_rates); i++) {
        if(known_rates[i] <= rate) {
            list.append(known_rates[i]);
        }
    }

    return list;
}

detectSupportedFormats()

void Kwave::RecordPulseAudio::detectSupportedFormats ( const QString &  device )

private

Walk through the list of all known formats and collect the ones that are supported into "m_supported_formats".

Parameters

device

name of the device

Definition at line 229 of file Record-PulseAudio.cpp.

References _known_formats, bits_of(), compression_of(), Kwave::CpuEndian, DBG, Kwave::TypesMap< IDX, DATA >::description(), ELEMENTS_OF, endian_of(), Kwave::TypesMap< IDX, DATA >::findFromData(), Kwave::LittleEndian, m_device_list, m_supported_formats, Kwave::Compression::name(), and sample_format_of().

Referenced by open().

{
    // start with an empty list
    m_supported_formats.clear();

    // lookup in the device list
    if (!m_device_list.contains(device))
        return;

    const pa_sample_spec     &sampleSpec = m_device_list[device].m_sample_spec;
    const pa_sample_format_t &formatSpec = sampleSpec.format;

    // try all known formats
    qDebug("--- list of supported formats --- ");
    for(unsigned int i = 0; i < ELEMENTS_OF(_known_formats); ++i) {
        const pa_sample_format_t &fmt = _known_formats[i];

        if (formatSpec < _known_formats[i])
            continue;

        // TODO: avoid duplicate entries that differ only in endianness,
        //       prefer our own (native) endianness

        Kwave::Compression t(compression_of(fmt));
        Kwave::SampleFormat::Map sf;
        qDebug("#%2u, %2u bit [%u byte], %s, '%s', '%s'",
            i,
            bits_of(fmt),
            (bits_of(fmt) + 7) >> 3,
            endian_of(fmt) == Kwave::CpuEndian ? "CPU" :
            (endian_of(fmt) == Kwave::LittleEndian ? "LE " : "BE "),
            DBG(sf.description(sf.findFromData(sample_format_of(fmt)), true)),
            DBG(t.name())
        );

        m_supported_formats.append(fmt);
    }
    qDebug("--------------------------------- ");
}

Here is the call graph for this function:

Here is the caller graph for this function:

detectTracks()

int Kwave::RecordPulseAudio::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 number if ok, negative error number if failed

Implements Kwave::RecordDevice.

Definition at line 628 of file Record-PulseAudio.cpp.

References m_device, and m_device_list.

{
    pa_sample_spec sampleSpec = m_device_list[m_device].m_sample_spec;
    unsigned int channels = sampleSpec.channels;

    min = 1;
    max = qBound<unsigned int>(min, channels, PA_CHANNELS_MAX);
    return 0;
}

disconnectFromServer()

void Kwave::RecordPulseAudio::disconnectFromServer ( )

private

Disconnect from the PulseAudio server and clean up

Definition at line 980 of file Record-PulseAudio.cpp.

References Kwave::WorkerThread::cancel(), close(), m_mainloop_lock, m_mainloop_thread, m_pa_context, m_pa_mainloop, m_pa_proplist, and Kwave::WorkerThread::stop().

Referenced by connectToServer(), and ~RecordPulseAudio().

{
    close();

    // stop the main loop
    m_mainloop_thread.cancel();
    if (m_pa_mainloop) {
        m_mainloop_lock.lock();
        pa_mainloop_quit(m_pa_mainloop, 0);
        m_mainloop_lock.unlock();
    }
    m_mainloop_thread.stop();

    // disconnect the pulse context
    if (m_pa_context) {
        pa_context_disconnect(m_pa_context);
        pa_context_unref(m_pa_context);
        m_pa_context  = Q_NULLPTR;
    }

    // stop and free the main loop
    if (m_pa_mainloop) {
        pa_mainloop_free(m_pa_mainloop);
        m_pa_mainloop = Q_NULLPTR;
    }

    // release the property list
    if (m_pa_proplist) {
        pa_proplist_free(m_pa_proplist);
        m_pa_proplist = Q_NULLPTR;
    }

}

Here is the call graph for this function:

Here is the caller graph for this function:

endianness()

Kwave::byte_order_t Kwave::RecordPulseAudio::endianness ( )

virtual

Returns the current endianness (big/little)

Implements Kwave::RecordDevice.

Definition at line 404 of file Record-PulseAudio.cpp.

References endian_of(), m_bits_per_sample, m_compression, m_sample_format, mode2format(), and Kwave::UnknownEndian.

{
    pa_sample_format_t fmt = mode2format(m_compression, m_bits_per_sample,
                                         m_sample_format);
    return (fmt != PA_SAMPLE_INVALID) ?
        endian_of(fmt) : Kwave::UnknownEndian;
}

Here is the call graph for this function:

initialize()

int Kwave::RecordPulseAudio::initialize ( uint32_t  buffer_size )

private

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

Parameters

buffer_size

buffer size

Returns

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

Definition at line 713 of file Record-PulseAudio.cpp.

References connectToServer(), DBG, Kwave::TypesMap< IDX, DATA >::description(), Kwave::TypesMap< IDX, DATA >::findFromData(), m_bits_per_sample, m_compression, m_initialized, m_mainloop_lock, m_mainloop_signal, m_name, m_pa_context, m_pa_device, m_pa_stream, m_rate, m_sample_format, m_tracks, mode2format(), name, pa_read_cb(), pa_stream_state_cb(), and TIMEOUT_CONNECT_RECORD.

Referenced by read().

{
    Q_ASSERT(!m_initialized);

    // make sure that we are connected to the sound server
    if (!connectToServer()) {
        qWarning("Connecting to the PulseAudio server failed!");
        return -1;
    }

    pa_sample_format_t fmt = mode2format(m_compression, m_bits_per_sample,
                                         m_sample_format);
    if (fmt == PA_SAMPLE_INVALID) {
        Kwave::SampleFormat::Map sf;

        qWarning("format: no matching format for compression '%s', "
            "%d bits/sample, format '%s'",
            DBG(sf.description(sf.findFromData(m_sample_format), true)),
            m_bits_per_sample,
            DBG(Kwave::Compression(m_compression).name())
        );
        return -EINVAL;
    }

    pa_sample_spec sample_spec;
    sample_spec.channels = m_tracks;
    sample_spec.format = fmt;
    sample_spec.rate = static_cast<quint32>(m_rate);

    if(!pa_sample_spec_valid(&sample_spec)) {
        Kwave::SampleFormat::Map sf;

        qWarning("no valid pulse audio format: %d, rate: %0.3g, channels: %d",
                 static_cast<int>(fmt), m_rate, m_tracks);
        return -EINVAL;
    }

    // run with mainloop locked from here on...
    m_mainloop_lock.lock();

    pa_channel_map channel_map;
    pa_channel_map_init_extend(&channel_map, sample_spec.channels,
                               PA_CHANNEL_MAP_DEFAULT);

    if (!pa_channel_map_compatible(&channel_map, &sample_spec)) {
        qWarning("Channel map doesn't match sample specification!");
    }

    // create a new stream
    m_pa_stream = pa_stream_new(
        m_pa_context,
        m_name.toUtf8().constData(),
        &sample_spec,
        &channel_map);

    if (!m_pa_stream) {
        m_mainloop_lock.unlock();
        qWarning("Failed to create a PulseAudio stream %s",
                 pa_strerror(pa_context_errno(m_pa_context)));
        return -1;
    }

    pa_stream_set_state_callback(m_pa_stream, pa_stream_state_cb, this);
    pa_stream_set_read_callback(m_pa_stream, pa_read_cb, this);

    pa_buffer_attr attr;
    attr.fragsize  = buffer_size;
    attr.maxlength = static_cast<uint32_t>(-1);
    attr.minreq    = static_cast<uint32_t>(-1);
    attr.prebuf    = static_cast<uint32_t>(-1);
    attr.tlength   = static_cast<uint32_t>(-1);
    int flags      = PA_STREAM_ADJUST_LATENCY;

    // connect the stream in record mode
    int result = pa_stream_connect_record(
        m_pa_stream,
        m_pa_device.toUtf8().constData(),
        &attr,
        static_cast<pa_stream_flags_t>(flags));

    if (result >= 0) {
        m_mainloop_signal.wait(&m_mainloop_lock, TIMEOUT_CONNECT_RECORD);
        if (pa_stream_get_state(m_pa_stream) != PA_STREAM_READY)
            result = -1;
    }

    m_mainloop_lock.unlock();

    if (result < 0) {
        pa_stream_unref(m_pa_stream);
        m_pa_stream = Q_NULLPTR;
        qWarning("Failed to open a PulseAudio stream for record %s",
                 pa_strerror(pa_context_errno(m_pa_context)));
        return -1;
    }

    m_initialized = true;
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mainloopPoll()

int Kwave::RecordPulseAudio::mainloopPoll	(	struct pollfd *	ufds,
		unsigned long int	nfds,
		int	timeout
	)

our own poll function, for timeout support

Definition at line 874 of file Record-PulseAudio.cpp.

References m_mainloop_lock.

Referenced by poll_func().

{
    m_mainloop_lock.unlock();
    int retval = poll(ufds, nfds, timeout);
    m_mainloop_lock.lock();

    return retval;
}

Here is the caller graph for this function:

mode2format()

pa_sample_format_t Kwave::RecordPulseAudio::mode2format ( int  compression, int  bits, Kwave::SampleFormat::Format  sample_format  )

private

create a PulseAudio device format (enum) from parameters.

Parameters

compression

the compression type

See also

Compression

Parameters

bits	the number of bits per sample, related to the decoded stream
sample_format	the sample format (signed or unsigned)

Returns

the best matching format within the list of known formats, or PA_SAMPLE_INVALID if no match was found

Definition at line 381 of file Record-PulseAudio.cpp.

References bits_of(), compression_of(), m_supported_formats, and sample_format_of().

Referenced by endianness(), and initialize().

{
    // loop over all supported formats and keep only those that are
    // compatible with the given compression, bits and sample format
    foreach (const pa_sample_format_t &fmt, m_supported_formats)
    {
        if (compression_of(fmt) != compression) continue;
        if (bits_of(fmt) != bits) continue;
        if (!(sample_format_of(fmt) == sample_format)) continue;

        // mode is compatible
        // As the list of known formats is already sorted so that
        // the simplest formats come first, we don't have a lot
        // of work -> just take the first entry ;-)
        return fmt;
    }

    qWarning("RecordPulesAudio::mode2format -> no match found !?");
    return PA_SAMPLE_INVALID;
}

Here is the call graph for this function:

Here is the caller graph for this function:

notifyContext()

void Kwave::RecordPulseAudio::notifyContext ( pa_context *  c )

private

Callback for pulse audio context state changes

Parameters

c	pulse server context

Definition at line 345 of file Record-PulseAudio.cpp.

References DBG_CASE, m_mainloop_signal, and m_pa_context.

Referenced by pa_context_notify_cb().

{
    Q_ASSERT(c == m_pa_context);
    const pa_context_state_t state = pa_context_get_state(c);

#ifdef DEBUG
    #define DBG_CASE(x) case x: qDebug("RecordPulseAudio -> " #x ); break
    switch (state)
    {
        DBG_CASE(PA_CONTEXT_UNCONNECTED);
        DBG_CASE(PA_CONTEXT_CONNECTING);
        DBG_CASE(PA_CONTEXT_AUTHORIZING);
        DBG_CASE(PA_CONTEXT_SETTING_NAME);
        DBG_CASE(PA_CONTEXT_READY);
        DBG_CASE(PA_CONTEXT_TERMINATED);
        DBG_CASE(PA_CONTEXT_FAILED);
    }
    #undef DBG_CASE
#endif /* DEBUG */

    switch (state)
    {
        case PA_CONTEXT_UNCONNECTED: /* FALLTHROUGH */
        case PA_CONTEXT_CONNECTING:  /* FALLTHROUGH */
        case PA_CONTEXT_AUTHORIZING: /* FALLTHROUGH */
        case PA_CONTEXT_SETTING_NAME:
            break;
        case PA_CONTEXT_READY:       /* FALLTHROUGH */
        case PA_CONTEXT_TERMINATED:  /* FALLTHROUGH */
        case PA_CONTEXT_FAILED:
            m_mainloop_signal.wakeAll();
            break;
    }
}

Here is the caller graph for this function:

notifyRead()

void Kwave::RecordPulseAudio::notifyRead ( pa_stream *  stream, size_t  nbytes  )

private

Callback after reading data.

Parameters

stream	pulse audio stream
nbytes	number of read bytes, maybe (unused)

Definition at line 280 of file Record-PulseAudio.cpp.

References m_mainloop_signal, and m_pa_stream.

Referenced by pa_read_cb().

{
    Q_UNUSED(nbytes);
    Q_ASSERT(stream);

    if (!stream || (stream != m_pa_stream)) return;

    m_mainloop_signal.wakeAll();
}

Here is the caller graph for this function:

notifySourceInfo()

void Kwave::RecordPulseAudio::notifySourceInfo ( pa_context *  c, const pa_source_info *  info, int  eol  )

private

Callback for pulse sink info.

Parameters

c	pulse server context
info	pointer to a source info object
eol	if negative: error occurred, zero: more data follows, positive: end of info, done.

Definition at line 1026 of file Record-PulseAudio.cpp.

References Kwave::RecordPulseAudio::source_info_t::m_card, Kwave::RecordPulseAudio::source_info_t::m_description, m_device_list, Kwave::RecordPulseAudio::source_info_t::m_driver, m_mainloop_signal, Kwave::RecordPulseAudio::source_info_t::m_name, m_pa_context, Kwave::RecordPulseAudio::source_info_t::m_sample_spec, and name.

Referenced by pa_source_info_cb().

{
    Q_UNUSED(c);
    Q_ASSERT(c == m_pa_context);

    if (eol == 0) {
        source_info_t i;
        i.m_name        = QString::fromUtf8(info->name);
        i.m_description = QString::fromUtf8(info->description);
        i.m_driver      = QString::fromUtf8(info->driver);
        i.m_card        = info->card;
        i.m_sample_spec = info->sample_spec;

        QString name    = QString::number(m_device_list.count());
        m_device_list[name] = i;
    } else {
        m_mainloop_signal.wakeAll();
    }
}

Here is the caller graph for this function:

notifyStreamState()

void Kwave::RecordPulseAudio::notifyStreamState ( pa_stream *  stream )

private

Callback for pulse stream state changes

Parameters

stream

pulse audio stream

Definition at line 300 of file Record-PulseAudio.cpp.

References DBG_CASE, m_mainloop_signal, and m_pa_stream.

Referenced by pa_stream_state_cb().

{
    Q_ASSERT(stream);
    if (!stream || (stream != m_pa_stream)) return;

    pa_stream_state_t state = pa_stream_get_state(stream);

#ifdef DEBUG
    #define DBG_CASE(x) case x: qDebug("RecordPulseAudio -> " #x ); break
    switch (state)
    {
        DBG_CASE(PA_STREAM_CREATING);
        DBG_CASE(PA_STREAM_UNCONNECTED);
        DBG_CASE(PA_STREAM_FAILED);
        DBG_CASE(PA_STREAM_TERMINATED);
        DBG_CASE(PA_STREAM_READY);
    }
    #undef DBG_CASE
#endif /* DEBUG */

    switch (state) {
        case PA_STREAM_CREATING:
            break;
        case PA_STREAM_UNCONNECTED: /* FALLTHROUGH */
        case PA_STREAM_FAILED:      /* FALLTHROUGH */
        case PA_STREAM_TERMINATED:  /* FALLTHROUGH */
        case PA_STREAM_READY:
            m_mainloop_signal.wakeAll();
            break;
        default:
            Q_ASSERT(0 && "?");
            break;
    }
}

Here is the caller graph for this function:

open()

QString Kwave::RecordPulseAudio::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 814 of file Record-PulseAudio.cpp.

References close(), detectSupportedFormats(), m_device, m_device_list, m_name, m_pa_device, and m_pa_stream.

{
    // close the previous device
    if (m_pa_stream) close();

    QString pa_device;
    if (m_device_list.contains(device))
        pa_device = m_device_list[device].m_name;

    if (!pa_device.length())
        return QString::number(ENODEV);

    m_pa_device = pa_device;
    m_device    = device;

    // detect all formats the device knows
    detectSupportedFormats(device);

    return QString();
}

Here is the call graph for this function:

pa_context_notify_cb()

void Kwave::RecordPulseAudio::pa_context_notify_cb ( pa_context *  c, void *  userdata  )

staticprivate

called from pulse audio to inform about state changes of the server context.

Parameters

c	pulse server context
userdata	user data, pointer to a RecordPulseAudio object

Definition at line 336 of file Record-PulseAudio.cpp.

References notifyContext().

Referenced by connectToServer().

{
    Kwave::RecordPulseAudio *record_plugin =
        reinterpret_cast<Kwave::RecordPulseAudio *>(userdata);
    Q_ASSERT(record_plugin);
    if (record_plugin) record_plugin->notifyContext(c);
}

Here is the call graph for this function:

Here is the caller graph for this function:

pa_read_cb()

void Kwave::RecordPulseAudio::pa_read_cb ( pa_stream *  p, size_t  nbytes, void *  userdata  )

staticprivate

called from pulse audio after data has been read

Parameters

p	pulse audio stream
nbytes	number of read bytes, maybe (unused)
userdata	user data, pointer to a RecordPulseAudio object

Definition at line 270 of file Record-PulseAudio.cpp.

References notifyRead().

Referenced by initialize().

{
    Kwave::RecordPulseAudio *record_plugin =
        reinterpret_cast<Kwave::RecordPulseAudio *>(userdata);
    Q_ASSERT(record_plugin);
    if (record_plugin) record_plugin->notifyRead(p, nbytes);
}

Here is the call graph for this function:

Here is the caller graph for this function:

pa_source_info_cb()

void Kwave::RecordPulseAudio::pa_source_info_cb ( pa_context *  c, const pa_source_info *  info, int  eol, void *  userdata  )

staticprivate

called from pulse audio to inform about state changes of the server context.

Parameters

c	pulse server context
info	pointer to a source info object
eol	if negative: error occurred, zero: more data follows, positive: end of info, done.
userdata	pointer to a RecordPulseAudio object

Definition at line 1015 of file Record-PulseAudio.cpp.

References notifySourceInfo().

Referenced by scanDevices().

{
    Kwave::RecordPulseAudio *record_plugin =
        reinterpret_cast<Kwave::RecordPulseAudio *>(userdata);
    Q_ASSERT(record_plugin);
    if (record_plugin) record_plugin->notifySourceInfo(c, info, eol);
}

Here is the call graph for this function:

Here is the caller graph for this function:

pa_stream_state_cb()

void Kwave::RecordPulseAudio::pa_stream_state_cb ( pa_stream *  p, void *  userdata  )

staticprivate

called from pulse audio to inform about state changes of a stream.

Parameters

p	pulse audio stream
userdata	user data, pointer to a RecordPulseAudio object

Definition at line 291 of file Record-PulseAudio.cpp.

References notifyStreamState().

Referenced by initialize().

{
    Kwave::RecordPulseAudio *record_plugin =
        reinterpret_cast<Kwave::RecordPulseAudio *>(userdata);
    Q_ASSERT(record_plugin);
    if (record_plugin) record_plugin->notifyStreamState(p);
}

Here is the call graph for this function:

Here is the caller graph for this function:

read()

int Kwave::RecordPulseAudio::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 661 of file Record-PulseAudio.cpp.

References initialize(), m_initialized, m_mainloop_lock, m_pa_stream, MEMCPY, Kwave::toInt(), and Kwave::toUint().

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

    unsigned int length = buffer.size();

    // we configure our device at a late stage, not on the fly like in OSS
    if (!m_initialized) {
        int err = initialize(length);
        if (err < 0) return err;
    }

    m_mainloop_lock.lock();

    size_t freeBytes = length - offset;
    size_t readableSize = pa_stream_readable_size(m_pa_stream);
    if (readableSize > freeBytes) {
        size_t additional_size = readableSize - freeBytes;
        buffer.resize(static_cast<int>(length + additional_size));
    }

    size_t readLength = 0;
    if (readableSize > 0) {
        const void *audioBuffer = Q_NULLPTR;
        pa_stream_peek(m_pa_stream, &audioBuffer, &readLength);

        if (offset + readLength > Kwave::toUint(buffer.length())) {
            pa_stream_drop(m_pa_stream);
            m_mainloop_lock.unlock();
            return -EIO; // peek returned invalid length
        }

        char *data = buffer.data() + offset;
        if (audioBuffer) {
            MEMCPY(data, audioBuffer, readLength); // real data
        } else {
            memset(data, 0x00, readLength); // there was a gap
        }

        pa_stream_drop(m_pa_stream);

    } else {
        m_mainloop_lock.unlock();
        return -EAGAIN;
    }
    m_mainloop_lock.unlock();

    return Kwave::toInt(readLength);
}

Here is the call graph for this function:

run_wrapper()

void Kwave::RecordPulseAudio::run_wrapper ( const QVariant &  params )

protectedvirtual

re-implementation of the threaded mainloop of PulseAudio

Implements Kwave::Runnable.

Definition at line 852 of file Record-PulseAudio.cpp.

References m_mainloop_lock, and m_pa_mainloop.

{
    Q_UNUSED(params);
    m_mainloop_lock.lock();
    pa_mainloop_run(m_pa_mainloop, Q_NULLPTR);
    m_mainloop_lock.unlock();
    qDebug("RecordPulseAudio::run_wrapper - done.");
}

sampleFormat()

Kwave::SampleFormat::Format Kwave::RecordPulseAudio::sampleFormat ( )

virtual

Returns the current sample format (signed/unsigned)

Implements Kwave::RecordDevice.

Definition at line 413 of file Record-PulseAudio.cpp.

References m_sample_format.

{
    return m_sample_format;
}

sampleRate()

double Kwave::RecordPulseAudio::sampleRate ( )

virtual

Returns the current sample rate of the device

Implements Kwave::RecordDevice.

Definition at line 534 of file Record-PulseAudio.cpp.

References m_rate.

{
    return m_rate;
}

scanDevices()

void Kwave::RecordPulseAudio::scanDevices ( )

private

scan all PulseAudio source, re-creates m_device_list

Definition at line 1049 of file Record-PulseAudio.cpp.

References _, connectToServer(), m_device_list, m_mainloop_lock, m_mainloop_signal, m_pa_context, name, pa_source_info_cb(), and TIMEOUT_WAIT_DEVICE_SCAN.

Referenced by supportedDevices().

{
    if (!m_pa_context) connectToServer();
    if (!m_pa_context) return;

    // fetch the device list from the PulseAudio server
    m_mainloop_lock.lock();
    m_device_list.clear();
    pa_operation *op_source_info = pa_context_get_source_info_list(
        m_pa_context,
        pa_source_info_cb,
        this
    );
    if (op_source_info) {
        // set hourglass cursor, we have a long timeout...
        QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
        m_mainloop_signal.wait(&m_mainloop_lock, TIMEOUT_WAIT_DEVICE_SCAN);
        QApplication::restoreOverrideCursor();
    }

    // create a list with final names
    QMap<QString, source_info_t> list;

    foreach (QString source, m_device_list.keys()) {
        QString name        = m_device_list[source].m_name;
        QString description = m_device_list[source].m_description;
        QString driver      = m_device_list[source].m_driver;

        // if the name is not unique, add the internal source name
        int unique = true;
        foreach (QString s, m_device_list.keys()) {
            if (s == source) continue;
            if ((m_device_list[s].m_description == description) &&
                (m_device_list[s].m_driver      == driver))
            {
                unique = false;
                break;
            }
        }
        if (!unique) description += _(" [") + name + _("]");

        // mangle the driver name, e.g.
        // "module-alsa-sink.c" -> "alsa sink"
        QFileInfo f(driver);
        driver = f.baseName();
        driver.replace(_("-"), _(" "));
        driver.replace(_("_"), _(" "));
        if (driver.toLower().startsWith(_("module ")))
            driver.remove(0, 7);
        description.prepend(driver + _("|sound_card||"));

        // add the leaf node
        if (m_device_list[source].m_card != PA_INVALID_INDEX)
            description.append(_("|sound_device"));
        else
            description.append(_("|sound_note"));

        list.insert(description, m_device_list[source]);
    }

    m_device_list.clear();
    m_device_list = list;
    m_mainloop_lock.unlock();
}

Here is the call graph for this function:

Here is the caller graph for this function:

setBitsPerSample()

int Kwave::RecordPulseAudio::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 461 of file Record-PulseAudio.cpp.

References close(), and m_bits_per_sample.

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

Here is the call graph for this function:

setCompression()

int Kwave::RecordPulseAudio::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 502 of file Record-PulseAudio.cpp.

References close(), and m_compression.

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

Here is the call graph for this function:

setSampleFormat()

int Kwave::RecordPulseAudio::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 419 of file Record-PulseAudio.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::RecordPulseAudio::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 540 of file Record-PulseAudio.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::RecordPulseAudio::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 609 of file Record-PulseAudio.cpp.

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

{
    const quint8 max_tracks = std::numeric_limits<quint8>::max();

    if (tracks > max_tracks) {
        tracks = max_tracks;
        return -1;
    }

    if (tracks == m_tracks)
        return 0;

    close();
    m_tracks = static_cast<quint8>(tracks);

    return 0;
}

Here is the call graph for this function:

supportedBits()

QList< unsigned int > Kwave::RecordPulseAudio::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 471 of file Record-PulseAudio.cpp.

References bits_of(), compression_of(), m_compression, and m_supported_formats.

{
    QList<unsigned int> list;

    // try all known sample formats
    foreach(const pa_sample_format_t &fmt, m_supported_formats)
    {
        const unsigned int bits = bits_of(fmt);

        // 0  bits means invalid/does not apply
        if (!bits) continue;

        // only accept bits/sample if compression matches
        if (compression_of(fmt) != m_compression) continue;

        // do not produce duplicates
        if (list.contains(bits)) continue;

        list.append(bits);
    }

    return list;
}

Here is the call graph for this function:

supportedDevices()

QStringList Kwave::RecordPulseAudio::supportedDevices ( )

virtual

return a string list with supported device names

Implements Kwave::RecordDevice.

Definition at line 836 of file Record-PulseAudio.cpp.

References _, m_device_list, m_pa_context, m_pa_mainloop, and scanDevices().

{
    QStringList list;

    // re-validate the list if necessary
    scanDevices();

    if (!m_pa_mainloop || !m_pa_context) return list;

    list = m_device_list.keys();
    if (!list.isEmpty()) list.prepend(_("#TREE#"));

    return list;
}

Here is the call graph for this function:

tracks()

int Kwave::RecordPulseAudio::tracks ( )

virtual

Returns the current number of tracks

Implements Kwave::RecordDevice.

Definition at line 603 of file Record-PulseAudio.cpp.

References m_tracks.

Referenced by setTracks().

{
    return m_tracks;
}

Here is the caller graph for this function:

Member Data Documentation

m_bits_per_sample

unsigned int Kwave::RecordPulseAudio::m_bits_per_sample

private

resolution [bits per sample]

Definition at line 350 of file Record-PulseAudio.h.

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

m_compression

Kwave::Compression::Type Kwave::RecordPulseAudio::m_compression

private

compression mode

Definition at line 347 of file Record-PulseAudio.h.

Referenced by compression(), detectSampleFormats(), endianness(), initialize(), setCompression(), and supportedBits().

m_device

QString Kwave::RecordPulseAudio::m_device

private

encoded name of the sink

Definition at line 382 of file Record-PulseAudio.h.

Referenced by detectSampleRates(), detectTracks(), and open().

m_device_list

QMap<QString, source_info_t> Kwave::RecordPulseAudio::m_device_list

private

list of available devices key=full encoded name of the sink, data=info about the sink

Definition at line 388 of file Record-PulseAudio.h.

Referenced by detectSampleRates(), detectSupportedFormats(), detectTracks(), notifySourceInfo(), open(), scanDevices(), supportedDevices(), and ~RecordPulseAudio().

m_initialized

bool Kwave::RecordPulseAudio::m_initialized

private

true if initialize() has been successfully been run

Definition at line 361 of file Record-PulseAudio.h.

Referenced by close(), initialize(), and read().

m_mainloop_lock

QMutex Kwave::RecordPulseAudio::m_mainloop_lock

private

lock for the main loop

Definition at line 332 of file Record-PulseAudio.h.

Referenced by close(), connectToServer(), disconnectFromServer(), initialize(), mainloopPoll(), read(), run_wrapper(), and scanDevices().

m_mainloop_signal

QWaitCondition Kwave::RecordPulseAudio::m_mainloop_signal

private

wait condition for mainloopWait/mainloopSignal

Definition at line 335 of file Record-PulseAudio.h.

Referenced by close(), connectToServer(), initialize(), notifyContext(), notifyRead(), notifySourceInfo(), notifyStreamState(), and scanDevices().

m_mainloop_thread

Kwave::WorkerThread Kwave::RecordPulseAudio::m_mainloop_thread

private

worker thread, running the event loop

Definition at line 329 of file Record-PulseAudio.h.

Referenced by connectToServer(), and disconnectFromServer().

m_name

QString Kwave::RecordPulseAudio::m_name

private

record plugin name

Definition at line 379 of file Record-PulseAudio.h.

Referenced by initialize(), and open().

m_pa_context

pa_context* Kwave::RecordPulseAudio::m_pa_context

private

pulse: context of the connection to the server

Definition at line 370 of file Record-PulseAudio.h.

Referenced by connectToServer(), disconnectFromServer(), initialize(), notifyContext(), notifySourceInfo(), scanDevices(), and supportedDevices().

m_pa_device

QString Kwave::RecordPulseAudio::m_pa_device

private

pulse: device

Definition at line 376 of file Record-PulseAudio.h.

Referenced by initialize(), and open().

m_pa_mainloop

pa_mainloop* Kwave::RecordPulseAudio::m_pa_mainloop

private

pulse: main loop

Definition at line 367 of file Record-PulseAudio.h.

Referenced by connectToServer(), disconnectFromServer(), run_wrapper(), and supportedDevices().

m_pa_proplist

pa_proplist* Kwave::RecordPulseAudio::m_pa_proplist

private

pulse: property list of the context

Definition at line 364 of file Record-PulseAudio.h.

Referenced by connectToServer(), and disconnectFromServer().

m_pa_stream

pa_stream* Kwave::RecordPulseAudio::m_pa_stream

private

pulse: playback stream

Definition at line 373 of file Record-PulseAudio.h.

Referenced by close(), initialize(), notifyRead(), notifyStreamState(), open(), and read().

m_rate

double Kwave::RecordPulseAudio::m_rate

private

sample rate

Definition at line 344 of file Record-PulseAudio.h.

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

m_sample_format

Kwave::SampleFormat::Format Kwave::RecordPulseAudio::m_sample_format

private

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

Definition at line 338 of file Record-PulseAudio.h.

Referenced by endianness(), initialize(), sampleFormat(), and setSampleFormat().

m_supported_formats

QList<pa_sample_format_t> Kwave::RecordPulseAudio::m_supported_formats

private

list of supported formats of the current device, indices in the global list of known formats. Only valid after a successful call to "open()", otherwise empty

Definition at line 358 of file Record-PulseAudio.h.

Referenced by detectCompressions(), detectSampleFormats(), detectSupportedFormats(), mode2format(), and supportedBits().

m_tracks

quint8 Kwave::RecordPulseAudio::m_tracks

private

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

Definition at line 341 of file Record-PulseAudio.h.

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

---

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

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