Kwave::PlayBackPulseAudio Class Reference

#include <PlayBack-PulseAudio.h>

Inheritance diagram for Kwave::PlayBackPulseAudio:

Collaboration diagram for Kwave::PlayBackPulseAudio:

Classes
struct	sink_info_t

Public Member Functions
	PlayBackPulseAudio (const Kwave::FileInfo &info)
virtual	~PlayBackPulseAudio () 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
int	mainloopPoll (struct pollfd *ufds, unsigned long int nfds, int timeout)
Public Member Functions inherited from Kwave::PlayBackDevice
virtual	~PlayBackDevice ()
Public Member Functions inherited from Kwave::Runnable
virtual	~Runnable ()

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

Private Member Functions
void	notifyContext (pa_context *c)
void	notifySinkInfo (pa_context *c, const pa_sink_info *info, int eol)
void	notifyStreamState (pa_stream *stream)
void	notifyWrite (pa_stream *stream, size_t nbytes)
void	notifySuccess (pa_stream *stream, int success)
bool	connectToServer ()
void	disconnectFromServer ()
void	scanDevices ()

Static Private Member Functions
static void	pa_context_notify_cb (pa_context *c, void *data)
static void	pa_sink_info_cb (pa_context *c, const pa_sink_info *info, int eol, void *userdata)
static void	pa_stream_state_cb (pa_stream *p, void *userdata)
static void	pa_write_cb (pa_stream *p, size_t nbytes, void *userdata)
static void	pa_stream_success_cb (pa_stream *s, int success, void *userdata)

Private Attributes
Kwave::WorkerThread	m_mainloop_thread
QMutex	m_mainloop_lock
QWaitCondition	m_mainloop_signal
Kwave::FileInfo	m_info
double	m_rate
unsigned int	m_bytes_per_sample
void *	m_buffer
size_t	m_buffer_size
size_t	m_buffer_used
unsigned int	m_bufbase
pa_proplist *	m_pa_proplist
pa_mainloop *	m_pa_mainloop
pa_context *	m_pa_context
pa_stream *	m_pa_stream
QMap< QString, sink_info_t >	m_device_list

Detailed Description

Definition at line 48 of file PlayBack-PulseAudio.h.

Constructor & Destructor Documentation

PlayBackPulseAudio()

Kwave::PlayBackPulseAudio::PlayBackPulseAudio ( const Kwave::FileInfo &  info )

explicit

Constructor

Parameters

info	the current FileInfo with metadata

Definition at line 79 of file PlayBack-PulseAudio.cpp.

    :Kwave::PlayBackDevice(),
     m_mainloop_thread(this, QVariant()),
     m_mainloop_lock(),
     m_mainloop_signal(),
     m_info(info),
     m_rate(0),
     m_bytes_per_sample(0),
     m_buffer(Q_NULLPTR),
     m_buffer_size(0),
     m_buffer_used(0),
     m_bufbase(10),
     m_pa_proplist(Q_NULLPTR),
     m_pa_mainloop(Q_NULLPTR),
     m_pa_context(Q_NULLPTR),
     m_pa_stream(Q_NULLPTR),
     m_device_list()
{
}

~PlayBackPulseAudio()

Kwave::PlayBackPulseAudio::~PlayBackPulseAudio ( )

virtual

Destructor

Definition at line 100 of file PlayBack-PulseAudio.cpp.

References close().

{
    close();
}

Here is the call graph for this function:

Member Function Documentation

close()

int Kwave::PlayBackPulseAudio::close ( )

virtual

Closes the output device.

See also

PlayBackDevice::close

Implements Kwave::PlayBackDevice.

Definition at line 737 of file PlayBack-PulseAudio.cpp.

References disconnectFromServer(), flush(), m_buffer_size, m_buffer_used, m_bytes_per_sample, m_device_list, m_mainloop_lock, m_mainloop_signal, m_pa_context, m_pa_mainloop, m_pa_stream, m_rate, pa_stream_success_cb(), TIMEOUT_MIN_DRAIN, and Kwave::toInt().

Referenced by open(), and ~PlayBackPulseAudio().

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

    if (m_buffer_used) flush();

    if (m_pa_mainloop && m_pa_stream) {

        pa_operation *op = Q_NULLPTR;
        m_mainloop_lock.lock();
        op = pa_stream_drain(m_pa_stream, pa_stream_success_cb, this);
        Q_ASSERT(op);
        if (!op) qWarning("pa_stream_drain() failed: '%s'", pa_strerror(
            pa_context_errno(m_pa_context)));

        // calculate a reasonable time for the timeout (16 buffers)
        int samples_per_buffer = Kwave::toInt(
            m_buffer_size / m_bytes_per_sample
        );
        int ms = (!qFuzzyIsNull(m_rate)) ?
            Kwave::toInt((samples_per_buffer * 1000.0) / m_rate) : 0;
        int timeout = (ms + 1) * 4;
        if (timeout < TIMEOUT_MIN_DRAIN)
            timeout = TIMEOUT_MIN_DRAIN;

        qDebug("PlayBackPulseAudio::flush(): waiting for drain to finish...");
        while (op && (pa_operation_get_state(op) != PA_OPERATION_DONE)) {
            if (!PA_CONTEXT_IS_GOOD(pa_context_get_state(m_pa_context)) ||
                !PA_STREAM_IS_GOOD(pa_stream_get_state(m_pa_stream))) {
                qWarning("PlayBackPulseAudio::close(): bad stream state");
                break;
            }
            if (!m_mainloop_signal.wait(&m_mainloop_lock, timeout)) {
                qWarning("PlayBackPulseAudio::flush(): timed out after %u ms",
                         timeout);
                break;
            }
        }
        m_mainloop_lock.unlock();

        if (m_pa_stream) {
            pa_stream_disconnect(m_pa_stream);
            pa_stream_unref(m_pa_stream);
            m_pa_stream = Q_NULLPTR;
        }
    }

    disconnectFromServer();
    m_device_list.clear();

    QApplication::restoreOverrideCursor();
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

connectToServer()

bool Kwave::PlayBackPulseAudio::connectToServer ( )

private

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

Definition at line 318 of file PlayBack-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 open(), 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("PlayBackPulseAudio: 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) {
                qDebug("PlayBackPulseAudio: context is ready :-)");
                failed = false;
            }
        }
        m_mainloop_lock.unlock();

        if (failed) {
            qWarning("PlayBackPulseAudio: 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:

detectChannels()

int Kwave::PlayBackPulseAudio::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 915 of file PlayBack-PulseAudio.cpp.

References m_device_list.

{
    min = max = 0;

    if (m_device_list.isEmpty() || !m_device_list.contains(device))
        return -1;

    min = max = m_device_list[device].m_sample_spec.channels;
    return 0;
}

disconnectFromServer()

void Kwave::PlayBackPulseAudio::disconnectFromServer ( )

private

Disconnect from the PulseAudio server and clean up

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

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

Referenced by close(), and connectToServer().

{
    // 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;
        qDebug("PlayBackPulseAudio: mainloop freed");
    }

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

fileFilter()

QString Kwave::PlayBackPulseAudio::fileFilter ( )

virtual

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

Reimplemented from Kwave::PlayBackDevice.

Definition at line 890 of file PlayBack-PulseAudio.cpp.

References _, and supportedBits().

{
    return _("");
}

Here is the call graph for this function:

flush()

int Kwave::PlayBackPulseAudio::flush ( )

protected

Writes the output buffer to the device

Definition at line 653 of file PlayBack-PulseAudio.cpp.

References m_buffer, m_buffer_size, m_buffer_used, m_bytes_per_sample, m_mainloop_lock, m_mainloop_signal, m_pa_context, m_pa_mainloop, m_pa_stream, m_rate, TIMEOUT_MIN_FLUSH, and Kwave::toInt().

Referenced by close(), and write().

{
    if (!m_buffer_used || !m_pa_mainloop || !m_buffer || !m_buffer_size)
        return 0;
//     qDebug("PlayBackPulseAudio::flush(): using buffer %p (%u bytes)",
//             m_buffer, m_buffer_size);

    // calculate a reasonable time for the timeout (16 buffers)
    int samples_per_buffer = Kwave::toInt(
        m_buffer_size / m_bytes_per_sample
    );
    int ms = (!qFuzzyIsNull(m_rate)) ?
        Kwave::toInt((samples_per_buffer * 1000.0) / m_rate) : 0;
    int timeout = (ms + 1) * 16;
    if (timeout < TIMEOUT_MIN_FLUSH)
        timeout = TIMEOUT_MIN_FLUSH;

    // write out the buffer allocated before in "write"
    int result = 0;

    while (m_buffer_used) {
        size_t len;

        m_mainloop_lock.lock();
        while (!(len = pa_stream_writable_size(m_pa_stream))) {
            if (!PA_CONTEXT_IS_GOOD(pa_context_get_state(m_pa_context)) ||
                !PA_STREAM_IS_GOOD(pa_stream_get_state(m_pa_stream)) ||
                (static_cast<ssize_t>(len) == -1) )
            {
                qWarning("PlayBackPulseAudio::flush(): bad stream state");
                result = -1;
                break;
            }
            if (!m_mainloop_signal.wait(&m_mainloop_lock, timeout)) {
                qWarning("PlayBackPulseAudio::flush(): timed out after %u ms",
                         timeout);
                result = -1;
                break;
            }
        }
        m_mainloop_lock.unlock();
        if (result < 0) break;

        if (len > m_buffer_used) len = m_buffer_used;

//      qDebug("PlayBackPulseAudio::flush(): writing %u bytes...", len);
        m_mainloop_lock.lock();
        result = pa_stream_write(
                m_pa_stream,
                m_buffer,
                len,
                Q_NULLPTR,
                0,
                PA_SEEK_RELATIVE
        );
        m_mainloop_lock.unlock();

        if (result < 0) {
            qWarning("PlayBackPulseAudio::flush(): pa_stream_write failed");
            return -EIO;
        }

        m_buffer       = reinterpret_cast<quint8 *>(m_buffer) + len;
        m_buffer_used -= len;
    }

//     qDebug("PlayBackPulseAudio::flush(): flush done.");

    // buffer is written out now
    m_buffer_used = 0;
    m_buffer      = Q_NULLPTR;
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mainloopPoll()

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

our own poll function, for timeout support

Definition at line 306 of file PlayBack-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:

notifyContext()

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

private

Callback for pulse audio context state changes

Parameters

c	pulse server context

Definition at line 156 of file PlayBack-PulseAudio.cpp.

References m_mainloop_signal, and m_pa_context.

Referenced by pa_context_notify_cb().

{
    Q_ASSERT(c == m_pa_context);
    switch (pa_context_get_state(c))
    {
        case PA_CONTEXT_UNCONNECTED:
//          qDebug("PlayBackPulseAudio: PA_CONTEXT_UNCONNECTED!?");
            break;
        case PA_CONTEXT_CONNECTING:
//          qDebug("PlayBackPulseAudio: PA_CONTEXT_CONNECTING...");
            break;
        case PA_CONTEXT_AUTHORIZING:
//          qDebug("PlayBackPulseAudio: PA_CONTEXT_AUTHORIZING...");
            break;
        case PA_CONTEXT_SETTING_NAME:
//          qDebug("PlayBackPulseAudio: PA_CONTEXT_SETTING_NAME...");
            break;
        case PA_CONTEXT_READY:
//          qDebug("PlayBackPulseAudio: PA_CONTEXT_READY.");
            m_mainloop_signal.wakeAll();
            break;
        case PA_CONTEXT_TERMINATED:
            qWarning("PlayBackPulseAudio: PA_CONTEXT_TERMINATED");
            m_mainloop_signal.wakeAll();
            break;
        case PA_CONTEXT_FAILED:
            qWarning("PlayBackPulseAudio: PA_CONTEXT_FAILED");
            m_mainloop_signal.wakeAll();
            break;
    }
}

Here is the caller graph for this function:

notifySinkInfo()

void Kwave::PlayBackPulseAudio::notifySinkInfo ( pa_context *  c, const pa_sink_info *  info, int  eol  )

private

Callback for pulse sink info

Parameters

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

Definition at line 189 of file PlayBack-PulseAudio.cpp.

References Kwave::PlayBackPulseAudio::sink_info_t::m_card, Kwave::PlayBackPulseAudio::sink_info_t::m_description, m_device_list, Kwave::PlayBackPulseAudio::sink_info_t::m_driver, m_mainloop_signal, Kwave::PlayBackPulseAudio::sink_info_t::m_name, m_pa_context, Kwave::PlayBackPulseAudio::sink_info_t::m_sample_spec, and name.

Referenced by pa_sink_info_cb().

{
    Q_UNUSED(c);
    Q_ASSERT(c == m_pa_context);
    if (eol == 0) {
#if 0
        qDebug("PlayBackPulseAudio: [%d] sink='%s' (%s) driver='%s'"\
               "card=%d, ports=%d",
               info->index,
               info->name,
               info->description,
               info->driver,
               info->card,
               info->n_ports
        );
        for (int p = 0; p < info->n_ports; p++) {
            qDebug("                     [%2d] - '%s' (%s), prio=%d%s",
                   p,
                   info->ports[p]->name,
                   info->ports[p]->description,
                   info->ports[p]->priority,
                   (info->ports[p] == info->active_port) ? " <*>" : ""
            );
        }
#endif
        sink_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::PlayBackPulseAudio::notifyStreamState ( pa_stream *  stream )

private

Callback for pulse stream state changes

Parameters

stream

pulse audio stream

Definition at line 232 of file PlayBack-PulseAudio.cpp.

References 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);
//     switch (state) {
//      case PA_STREAM_UNCONNECTED:
//          qDebug("    -> UNCONNECTED"); break;
//      case PA_STREAM_CREATING:
//          qDebug("    -> CREATING"); break;
//      case PA_STREAM_READY:
//          qDebug("    -> READY"); break;
//      case PA_STREAM_FAILED:
//          qDebug("    -> FAILED"); break;
//      case PA_STREAM_TERMINATED:
//          qDebug("    -> TERMINATED"); break;
//      default:
//          Q_ASSERT(0 && "?");
//          qDebug("    -> ???"); break;
//     }
    switch (state) {
        case PA_STREAM_UNCONNECTED:
        case PA_STREAM_CREATING:
            break;
        case PA_STREAM_READY:
        case PA_STREAM_FAILED:
        case PA_STREAM_TERMINATED:
            m_mainloop_signal.wakeAll();
            break;
    }
}

Here is the caller graph for this function:

notifySuccess()

void Kwave::PlayBackPulseAudio::notifySuccess ( pa_stream *  stream, int  success  )

private

Callback after successful stream operations.

Parameters

stream	pulse audio stream
success	(unused)

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

References m_mainloop_signal, and m_pa_stream.

Referenced by pa_stream_success_cb().

{
//     qDebug("PlayBackPulseAudio::notifySuccess(stream=%p, success=%d)",
//         static_cast<void *>(stream), success);
    Q_UNUSED(success);

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

    m_mainloop_signal.wakeAll();
}

Here is the caller graph for this function:

notifyWrite()

void Kwave::PlayBackPulseAudio::notifyWrite ( pa_stream *  stream, size_t  nbytes  )

private

Callback after writing data.

Parameters

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

Definition at line 266 of file PlayBack-PulseAudio.cpp.

References m_mainloop_signal, and m_pa_stream.

Referenced by pa_write_cb().

{
//     qDebug("PlayBackPulseAudio::notifyWrite(stream=%p, nbytes=%u)",
//         static_cast<void *>(stream), nbytes);
    Q_UNUSED(nbytes);

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

    m_mainloop_signal.wakeAll();
}

Here is the caller graph for this function:

open()

QString Kwave::PlayBackPulseAudio::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 447 of file PlayBack-PulseAudio.cpp.

References _, close(), connectToServer(), Kwave::FileInfo::contains(), DBG, Kwave::FileInfo::get(), Kwave::INF_AUTHOR, Kwave::INF_COPYRIGHT, Kwave::INF_FILENAME, Kwave::INF_NAME, Kwave::INF_SOFTWARE, m_bufbase, m_buffer, m_buffer_size, m_bytes_per_sample, m_device_list, m_info, m_mainloop_lock, m_mainloop_signal, m_pa_context, m_pa_proplist, m_pa_stream, m_rate, name, pa_stream_state_cb(), pa_write_cb(), scanDevices(), SET_PROPERTY, and TIMEOUT_CONNECT_PLAYBACK.

{
    #define SET_PROPERTY(__property__,__info__)              \
        if (m_info.contains(__info__))                       \
            pa_proplist_sets(_proplist, __property__,        \
            m_info.get(__info__).toString().toUtf8().data())

    qDebug("PlayBackPulseAudio::open(device=%s,rate=%0.1f,channels=%u,"\
        "bits=%u, bufbase=%u)",
        DBG(device.split(_("|")).at(0)), rate, channels,
        bits, bufbase);

    m_rate = rate;

    if (channels > 255)
        return i18n("%1 channels are not supported, maximum is 255", channels);

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

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

    if (!m_device_list.contains(device)) scanDevices();
    if (!m_device_list.contains(device)) {
        return i18n(
            "The PulseAudio device '%1' is unknown or no longer connected",
            device.section(QLatin1Char('|'), 0, 0));
    }
    QString pa_device = m_device_list[device].m_name;

    // determine the buffer size
    m_bytes_per_sample = sizeof(sample_t) * channels;
    m_buffer_size      = 0;
    m_buffer           = Q_NULLPTR;
    m_bufbase          = bufbase;

    // build a property list for the stream
    pa_proplist *_proplist = pa_proplist_copy(m_pa_proplist);
    Q_ASSERT(_proplist);
    SET_PROPERTY(PA_PROP_MEDIA_TITLE,     Kwave::INF_NAME);
    SET_PROPERTY(PA_PROP_MEDIA_ARTIST,    Kwave::INF_AUTHOR);
#ifdef PA_PROP_MEDIA_COPYRIGHT
    SET_PROPERTY(PA_PROP_MEDIA_COPYRIGHT, Kwave::INF_COPYRIGHT);
#endif
#ifdef PA_PROP_MEDIA_SOFTWARE
    SET_PROPERTY(PA_PROP_MEDIA_SOFTWARE,  Kwave::INF_SOFTWARE);
#endif
//  SET_PROPERTY(PA_PROP_MEDIA_LANGUAGE,  Kwave::INF_...);
    SET_PROPERTY(PA_PROP_MEDIA_FILENAME,  Kwave::INF_FILENAME);
//  SET_PROPERTY(PA_PROP_MEDIA_ICON_NAME, Kwave::INF_...);

    // use Kwave's internal sample format as output
    pa_sample_spec sample_spec;
#if (Q_BYTE_ORDER == Q_BIG_ENDIAN)
    sample_spec.format = PA_SAMPLE_S24_32BE;
#else
    sample_spec.format = PA_SAMPLE_S24_32LE;
#endif
    sample_spec.channels = static_cast<uint8_t>(channels);
    sample_spec.rate     = static_cast<uint32_t>(m_rate);

    // use the current title / filename or fixed string as stream name
    QString name;
    if (m_info.contains(Kwave::INF_NAME)) // first choice: title
        name = m_info.get(Kwave::INF_NAME).toString();
    // fallback: filename
    if (!name.length() && m_info.contains(Kwave::INF_FILENAME))
        name = m_info.get(Kwave::INF_FILENAME).toString();
    if (!name.length()) // last resort: fixed string
        name = i18n("playback...");

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

    // create a new stream
    m_pa_stream = pa_stream_new_with_proplist(
        m_pa_context,
        name.toUtf8().data(),
        &sample_spec,
        Q_NULLPTR /* const pa_channel_map *map */,
        _proplist);
    pa_proplist_free(_proplist);

    if (!m_pa_stream) {
        m_mainloop_lock.unlock();
        return i18n("Failed to create a PulseAudio stream (%1).",
                    QString::fromLocal8Bit(
                    pa_strerror(pa_context_errno(m_pa_context))));
    }
    qDebug("PlayBackPulseAudio::open(...) - stream created as %p",
           static_cast<void *>(m_pa_stream));

    // register callbacks for changes in stream state and write events
    pa_stream_set_state_callback(m_pa_stream, pa_stream_state_cb, this);
    pa_stream_set_write_callback(m_pa_stream, pa_write_cb, this);

    // set buffer attributes
    if (m_bufbase < 10) m_bufbase = 10;
    const int s = ((1 << m_bufbase) * m_bytes_per_sample) / m_bytes_per_sample;
    pa_buffer_attr attr;
    attr.fragsize  = -1;
    attr.maxlength =  s;
    attr.minreq    = -1;
    attr.prebuf    = -1;
    attr.tlength   = -1;

    // connect the stream in playback mode
    int result = pa_stream_connect_playback(
        m_pa_stream,
        pa_device.length() ? pa_device.toUtf8().data() : Q_NULLPTR,
        &attr /* buffer attributes */,
        static_cast<pa_stream_flags_t>(
            PA_STREAM_INTERPOLATE_TIMING |
            PA_STREAM_AUTO_TIMING_UPDATE),
        Q_NULLPTR /* volume */,
        Q_NULLPTR /* sync stream */ );

    if (result >= 0) {
        m_mainloop_signal.wait(&m_mainloop_lock, TIMEOUT_CONNECT_PLAYBACK);
        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;
        return i18n("Failed to open a PulseAudio stream for playback (%1).",
                    QString::fromLocal8Bit(
                    pa_strerror(pa_context_errno(m_pa_context))));
    }

    return QString();
}

Here is the call graph for this function:

pa_context_notify_cb()

void Kwave::PlayBackPulseAudio::pa_context_notify_cb ( pa_context *  c, void *  data  )

staticprivate

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

Parameters

c	pulse server context
data	user data, pointer to a PlayBackPulseAudio object

Definition at line 106 of file PlayBack-PulseAudio.cpp.

References notifyContext().

Referenced by connectToServer().

{
    Kwave::PlayBackPulseAudio *playback_plugin =
        reinterpret_cast<Kwave::PlayBackPulseAudio *>(data);
    Q_ASSERT(playback_plugin);
    if (playback_plugin) playback_plugin->notifyContext(c);
}

Here is the call graph for this function:

Here is the caller graph for this function:

pa_sink_info_cb()

void Kwave::PlayBackPulseAudio::pa_sink_info_cb ( pa_context *  c, const pa_sink_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 sink info object
eol	if negative: error occurred, zero: more data follows, positive: end of info, done.
userdata	pointer to a PlayBackPulseAudio object

Definition at line 115 of file PlayBack-PulseAudio.cpp.

References notifySinkInfo().

Referenced by scanDevices().

{
    Kwave::PlayBackPulseAudio *playback_plugin =
        reinterpret_cast<Kwave::PlayBackPulseAudio *>(userdata);
    Q_ASSERT(playback_plugin);
    if (playback_plugin) playback_plugin->notifySinkInfo(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::PlayBackPulseAudio::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 PlayBackPulseAudio object

Definition at line 126 of file PlayBack-PulseAudio.cpp.

References notifyStreamState().

Referenced by open().

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

Here is the call graph for this function:

Here is the caller graph for this function:

pa_stream_success_cb()

void Kwave::PlayBackPulseAudio::pa_stream_success_cb ( pa_stream *  s, int  success, void *  userdata  )

staticprivate

called from pulse audio after data has been written

Parameters

s	pulse audio stream
success	indicates success (unused)
userdata	user data, pointer to a PlayBackPulseAudio object

Definition at line 145 of file PlayBack-PulseAudio.cpp.

References notifySuccess().

Referenced by close().

{
    Kwave::PlayBackPulseAudio *playback_plugin =
        reinterpret_cast<Kwave::PlayBackPulseAudio *>(userdata);
    Q_ASSERT(playback_plugin);
    if (playback_plugin) playback_plugin->notifySuccess(s, success);
}

Here is the call graph for this function:

Here is the caller graph for this function:

pa_write_cb()

void Kwave::PlayBackPulseAudio::pa_write_cb ( pa_stream *  p, size_t  nbytes, void *  userdata  )

staticprivate

called from pulse audio after data has been written

Parameters

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

Definition at line 135 of file PlayBack-PulseAudio.cpp.

References notifyWrite().

Referenced by open().

{
    Kwave::PlayBackPulseAudio *playback_plugin =
        reinterpret_cast<Kwave::PlayBackPulseAudio *>(userdata);
    Q_ASSERT(playback_plugin);
    if (playback_plugin) playback_plugin->notifyWrite(p, nbytes);
}

Here is the call graph for this function:

Here is the caller graph for this function:

run_wrapper()

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

protectedvirtual

re-implementation of the threaded mainloop of PulseAudio

Implements Kwave::Runnable.

Definition at line 728 of file PlayBack-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();
}

scanDevices()

void Kwave::PlayBackPulseAudio::scanDevices ( )

private

scan all PulseAudio sinks, re-creates m_device_list

Definition at line 793 of file PlayBack-PulseAudio.cpp.

References _, connectToServer(), Kwave::PlayBackPulseAudio::sink_info_t::m_card, Kwave::PlayBackPulseAudio::sink_info_t::m_description, m_device_list, Kwave::PlayBackPulseAudio::sink_info_t::m_driver, m_mainloop_lock, m_mainloop_signal, Kwave::PlayBackPulseAudio::sink_info_t::m_name, m_pa_context, Kwave::PlayBackPulseAudio::sink_info_t::m_sample_spec, name, pa_sink_info_cb(), and TIMEOUT_WAIT_DEVICE_SCAN.

Referenced by open(), and 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_sink_info = pa_context_get_sink_info_list(
        m_pa_context,
        pa_sink_info_cb,
        this
    );
    if (op_sink_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
//     qDebug("----------------------------------------");
    QMap<QString, sink_info_t> list;

    // first entry == default device
    sink_info_t i;
    pa_sample_spec s;
    s.format   = PA_SAMPLE_INVALID;
    s.rate     = 0;
    s.channels = 0;
    i.m_name        = QString();
    i.m_description = _("(server default)");
    i.m_driver      = QString();
    i.m_card        = -1;
    i.m_sample_spec = s;
    list[i18n("(Use server default)") + _("|sound_note")] = i;

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

        // if the name is not unique, add the internal sink name
        int unique = true;
        foreach (QString sn, m_device_list.keys()) {
            if (sn == sink) continue;
            if ((m_device_list[sn].m_description == description) &&
                (m_device_list[sn].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[sink].m_card != PA_INVALID_INDEX)
            description.append(_("|sound_device"));
        else
            description.append(_("|sound_note"));

//      qDebug("supported device: '%s'", DBG(description));
        list.insert(description, m_device_list[sink]);
    }
//     qDebug("----------------------------------------");

    m_device_list = list;
    m_mainloop_lock.unlock();
}

Here is the call graph for this function:

Here is the caller graph for this function:

supportedBits()

QList< unsigned int > Kwave::PlayBackPulseAudio::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 897 of file PlayBack-PulseAudio.cpp.

References m_device_list, and Kwave::toUint().

Referenced by fileFilter().

{
    QList<unsigned int> list;

    if ( m_device_list.isEmpty() || !m_device_list.contains(device) ||
         !pa_sample_spec_valid(&m_device_list[device].m_sample_spec) )
        return list;

    list.append(Kwave::toUint(
        pa_sample_size(&m_device_list[device].m_sample_spec) * 8)
    );

    return list;
}

Here is the call graph for this function:

Here is the caller graph for this function:

supportedDevices()

QStringList Kwave::PlayBackPulseAudio::supportedDevices ( )

virtual

return a string list with supported device names

Reimplemented from Kwave::PlayBackDevice.

Definition at line 874 of file PlayBack-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:

write()

int Kwave::PlayBackPulseAudio::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 589 of file PlayBack-PulseAudio.cpp.

References Kwave::SampleArray::constData(), flush(), m_bufbase, m_buffer, m_buffer_size, m_buffer_used, m_bytes_per_sample, m_mainloop_lock, m_pa_mainloop, m_pa_stream, MEMCPY, and Kwave::toUint().

{
    unsigned int bytes = m_bytes_per_sample;

    // abort if byte per sample is unknown
    Q_ASSERT(m_bytes_per_sample);
    Q_ASSERT(m_pa_mainloop);
    if (!m_bytes_per_sample || !m_pa_mainloop)
        return -EINVAL;

    // start with a new/empty buffer from PulseAudio
    if (!m_buffer) {
        m_mainloop_lock.lock();

        // estimate buffer size and round to whole samples
        size_t size = -1;
        m_buffer_size = (1 << m_bufbase) * m_bytes_per_sample;

        // get a buffer from PulseAudio
        int result = pa_stream_begin_write(m_pa_stream, &m_buffer, &size);
        size /= m_bytes_per_sample;
        size *= m_bytes_per_sample;

        // we don't use all of it to reduce latency, use only the
        // minimum of our configured size and pulse audio's offer
        if (size < m_buffer_size)
            m_buffer_size = size;

        m_mainloop_lock.unlock();

        if (result < 0) {
            qWarning("PlayBackPulseAudio: pa_stream_begin_write failed");
            return -EIO;
        }

//      qDebug("PlayBackPulseAudio::write(): got buffer %p, size=%u bytes",
//             m_buffer, m_buffer_size);
    }

    // abort with out-of-memory if failed
    Q_ASSERT(m_buffer);
    if (!m_buffer || !m_buffer_size)
        return -ENOMEM;

    Q_ASSERT (m_buffer_used + bytes <= m_buffer_size);
    if (m_buffer_used + bytes > m_buffer_size) {
        qWarning("PlayBackPulseAudio::write(): buffer overflow ?! (%u/%u)",
                 Kwave::toUint(m_buffer_used),
                 Kwave::toUint(m_buffer_size));
        m_buffer_used = 0;
        return -EIO;
    }

    // copy the samples
    MEMCPY(reinterpret_cast<quint8 *>(m_buffer) + m_buffer_used,
           samples.constData(), bytes);
    m_buffer_used += bytes;

    // write the buffer if it is full
    if (m_buffer_used >= m_buffer_size) return flush();
    return 0;
}

Here is the call graph for this function:

Member Data Documentation

m_bufbase

unsigned int Kwave::PlayBackPulseAudio::m_bufbase

private

exponent of the buffer size, buffer size should be (1 << m_bufbase)

Definition at line 276 of file PlayBack-PulseAudio.h.

Referenced by open(), and write().

m_buffer

void* Kwave::PlayBackPulseAudio::m_buffer

private

buffer with raw device data

Definition at line 264 of file PlayBack-PulseAudio.h.

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

m_buffer_size

size_t Kwave::PlayBackPulseAudio::m_buffer_size

private

buffer size in bytes

Definition at line 267 of file PlayBack-PulseAudio.h.

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

m_buffer_used

size_t Kwave::PlayBackPulseAudio::m_buffer_used

private

number of bytes in the buffer

Definition at line 270 of file PlayBack-PulseAudio.h.

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

m_bytes_per_sample

unsigned int Kwave::PlayBackPulseAudio::m_bytes_per_sample

private

number of bytes per sample x nr of channels

Definition at line 261 of file PlayBack-PulseAudio.h.

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

m_device_list

QMap<QString, sink_info_t> Kwave::PlayBackPulseAudio::m_device_list

private

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

Definition at line 294 of file PlayBack-PulseAudio.h.

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

m_info

Kwave::FileInfo Kwave::PlayBackPulseAudio::m_info

private

file info, for meta info like title, author, name etc.

Definition at line 255 of file PlayBack-PulseAudio.h.

Referenced by open().

m_mainloop_lock

QMutex Kwave::PlayBackPulseAudio::m_mainloop_lock

private

lock for the main loop

Definition at line 249 of file PlayBack-PulseAudio.h.

Referenced by close(), connectToServer(), disconnectFromServer(), flush(), mainloopPoll(), open(), run_wrapper(), scanDevices(), and write().

m_mainloop_signal

QWaitCondition Kwave::PlayBackPulseAudio::m_mainloop_signal

private

wait condition for mainloopWait/mainloopSignal

Definition at line 252 of file PlayBack-PulseAudio.h.

Referenced by close(), connectToServer(), flush(), notifyContext(), notifySinkInfo(), notifyStreamState(), notifySuccess(), notifyWrite(), open(), and scanDevices().

m_mainloop_thread

Kwave::WorkerThread Kwave::PlayBackPulseAudio::m_mainloop_thread

private

worker thread, running the event loop

Definition at line 246 of file PlayBack-PulseAudio.h.

Referenced by connectToServer(), and disconnectFromServer().

m_pa_context

pa_context* Kwave::PlayBackPulseAudio::m_pa_context

private

pulse: context of the connection to the server

Definition at line 285 of file PlayBack-PulseAudio.h.

Referenced by close(), connectToServer(), disconnectFromServer(), flush(), notifyContext(), notifySinkInfo(), open(), scanDevices(), and supportedDevices().

m_pa_mainloop

pa_mainloop* Kwave::PlayBackPulseAudio::m_pa_mainloop

private

pulse: main loop

Definition at line 282 of file PlayBack-PulseAudio.h.

Referenced by close(), connectToServer(), disconnectFromServer(), flush(), run_wrapper(), supportedDevices(), and write().

m_pa_proplist

pa_proplist* Kwave::PlayBackPulseAudio::m_pa_proplist

private

pulse: property list of the context

Definition at line 279 of file PlayBack-PulseAudio.h.

Referenced by connectToServer(), disconnectFromServer(), and open().

m_pa_stream

pa_stream* Kwave::PlayBackPulseAudio::m_pa_stream

private

pulse: playback stream

Definition at line 288 of file PlayBack-PulseAudio.h.

Referenced by close(), flush(), notifyStreamState(), notifySuccess(), notifyWrite(), open(), and write().

m_rate

double Kwave::PlayBackPulseAudio::m_rate

private

sample rate used when opening the device

Definition at line 258 of file PlayBack-PulseAudio.h.

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

---

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

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