Kwave::PlayBackALSA Class Reference

#include <PlayBack-ALSA.h>

Inheritance diagram for Kwave::PlayBackALSA:

Collaboration diagram for Kwave::PlayBackALSA:

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

Protected Member Functions
snd_pcm_t *	openDevice (const QString &device)
int	openDevice (const QString &device, unsigned int rate, unsigned int channels, unsigned int bits)
int	setFormat (snd_pcm_hw_params_t *hw_params, unsigned int bits)
int	flush ()
void	scanDevices ()
QString	alsaDeviceName (const QString &name)

Private Member Functions
QList< int >	detectSupportedFormats (const QString &device)
int	mode2format (int bits)

Private Attributes
QString	m_device_name
snd_pcm_t *	m_handle
double	m_rate
unsigned int	m_channels
unsigned int	m_bits
unsigned int	m_bytes_per_sample
unsigned int	m_bufbase
QByteArray	m_buffer
unsigned int	m_buffer_size
unsigned int	m_buffer_used
snd_pcm_format_t	m_format
snd_pcm_uframes_t	m_chunk_size
QList< int >	m_supported_formats
Kwave::SampleEncoder *	m_encoder

Static Private Attributes
static QMap< QString, QString >	m_device_list

Detailed Description

Definition at line 45 of file PlayBack-ALSA.h.

Constructor & Destructor Documentation

PlayBackALSA()

Kwave::PlayBackALSA::PlayBackALSA

(

)

Default constructor

Definition at line 191 of file PlayBack-ALSA.cpp.

    :Kwave::PlayBackDevice(),
    m_device_name(),
    m_handle(Q_NULLPTR),
    m_rate(0),
    m_channels(0),
    m_bits(0),
    m_bytes_per_sample(0),
    m_bufbase(0),
    m_buffer(),
    m_buffer_size(0),
    m_buffer_used(0),
    m_format(),
    m_chunk_size(0),
    m_supported_formats(),
    m_encoder(Q_NULLPTR)
{
}

~PlayBackALSA()

Kwave::PlayBackALSA::~PlayBackALSA ( )

virtual

Destructor

Definition at line 211 of file PlayBack-ALSA.cpp.

References close().

{
    close();
}

Here is the call graph for this function:

Member Function Documentation

alsaDeviceName()

QString Kwave::PlayBackALSA::alsaDeviceName ( const QString &  name )

protected

Translate a verbose device name into a ALSA hardware device name.

Parameters

name	verbose name of the device

Returns

device name that can be used for snd_pcm_open()

Definition at line 862 of file PlayBack-ALSA.cpp.

References _, DBG, m_device_list, name, and scanDevices().

Referenced by openDevice().

{
    if (m_device_list.isEmpty() || (name.length() &&
        !m_device_list.contains(name)))
    {
//      qDebug("### RESCAN ### (list.count=%d, name='%s')",
//             m_device_list.count(), name.data());
        scanDevices();
    }

    if (!m_device_list.contains(name)) {
        // maybe we already have a ALSA compatible name (like in init state)
        foreach (QString n, m_device_list.values())
            if (n == name) return n;

        qWarning("PlayBackALSA::alsaDeviceName('%s') - NOT FOUND", DBG(name));
        return _("");
    }
    return m_device_list[name];
}

Here is the call graph for this function:

Here is the caller graph for this function:

close()

int Kwave::PlayBackALSA::close ( )

virtual

Closes the output device.

See also

PlayBackDevice::close

Implements Kwave::PlayBackDevice.

Definition at line 720 of file PlayBack-ALSA.cpp.

References flush(), m_encoder, m_handle, and m_supported_formats.

Referenced by ~PlayBackALSA().

{
    flush();

    // close the device handle
    if (m_handle) snd_pcm_close(m_handle);
    m_handle = Q_NULLPTR;

    // get rid of the old sample encoder
    if (m_encoder) delete m_encoder;
    m_encoder = Q_NULLPTR;

    // clear the list of supported formats, nothing open -> nothing supported
    m_supported_formats.clear();

    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

detectChannels()

int Kwave::PlayBackALSA::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 965 of file PlayBack-ALSA.cpp.

References ALSA_MALLOC_WRAPPER, m_handle, and openDevice().

{
    min = max = 0;
    ALSA_MALLOC_WRAPPER(snd_pcm_hw_params) p;

    if (!p) return -1;

    snd_pcm_t *pcm = openDevice(device);
    if (!pcm) return -1;

    if (snd_pcm_hw_params_any(pcm, p) >= 0) {
        int err;

        if ((err = snd_pcm_hw_params_get_channels_min(p, &min)) < 0)
            qWarning("PlayBackALSA::detectTracks: min: %s",
                     snd_strerror(err));
        if ((err = snd_pcm_hw_params_get_channels_max(p, &max)) < 0)
            qWarning("PlayBackALSA::detectTracks: max: %s",
                     snd_strerror(err));
    }

    // close the device if *we* opened it
    if (pcm != m_handle) snd_pcm_close(pcm);

    return 0;
}

Here is the call graph for this function:

detectSupportedFormats()

QList< int > Kwave::PlayBackALSA::detectSupportedFormats ( const QString &  device )

private

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

Definition at line 283 of file PlayBack-ALSA.cpp.

References _known_formats, ALSA_MALLOC_WRAPPER, m_handle, m_supported_formats, and openDevice().

Referenced by open(), and supportedBits().

{
    // start with an empty list
    QList<int> supported_formats;

    ALSA_MALLOC_WRAPPER(snd_pcm_hw_params) p;

    if (!p) return supported_formats;

    snd_pcm_t *pcm = openDevice(device);
    if (!pcm) return supported_formats;

    if (snd_pcm_hw_params_any(pcm, p) < 0) {
        if (pcm != m_handle) snd_pcm_close(pcm);
        return supported_formats;
    }

    // try all known formats
//     qDebug("--- list of supported formats --- ");
    const unsigned int count =
        sizeof(_known_formats) / sizeof(_known_formats[0]);
    for (unsigned int i=0; i < count; i++) {
        // test the sample format
        snd_pcm_format_t format = _known_formats[i];
        int err = snd_pcm_hw_params_test_format(pcm, p, format);
        if (err < 0) continue;

        const snd_pcm_format_t *fmt = &(_known_formats[i]);

        // eliminate duplicate alsa sample formats (e.g. BE/LE)
        foreach (int index, m_supported_formats) {
            const snd_pcm_format_t *f = &_known_formats[index];
            if (*f == *fmt) {
                fmt = Q_NULLPTR;
                break;
            }
        }
        if (!fmt) continue;

//      Kwave::Compression t;
//      Kwave::SampleFormat::Map sf;
//      qDebug("#%2u, %2d, %2u bit [%u byte], %s, '%s'",
//          i,
//          *fmt,
//          snd_pcm_format_width(*fmt),
//          (snd_pcm_format_physical_width(*fmt)+7) >> 3,
//          endian_of(*fmt) == Kwave::CpuEndian ? "CPU" :
//          (endian_of(*fmt) == Kwave::LittleEndian ? "LE " : "BE "),
//          sf.description(sf.findFromData(sample_format_of(
//              *fmt), true)).local8Bit().data());

        supported_formats.append(i);
    }
//     qDebug("--------------------------------- ");

    if (pcm != m_handle) snd_pcm_close(pcm);
    return supported_formats;
}

Here is the call graph for this function:

Here is the caller graph for this function:

fileFilter()

QString Kwave::PlayBackALSA::fileFilter ( )

virtual

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

Reimplemented from Kwave::PlayBackDevice.

Definition at line 903 of file PlayBack-ALSA.cpp.

References _.

{
    return _("");
}

flush()

int Kwave::PlayBackALSA::flush ( )

protected

Writes the output buffer to the device

Definition at line 641 of file PlayBack-ALSA.cpp.

References m_buffer, m_buffer_size, m_buffer_used, m_bytes_per_sample, m_channels, m_chunk_size, m_format, m_handle, m_rate, Kwave::toInt(), and Kwave::toUint().

Referenced by close(), and write().

{
    if (!m_buffer_used) return 0; // nothing to do
    Q_ASSERT(m_channels);
    Q_ASSERT(m_bytes_per_sample);
    if (!m_channels || !m_bytes_per_sample) return -EINVAL;

    if (m_handle) {
        snd_pcm_uframes_t samples = m_buffer_used / m_bytes_per_sample;
        unsigned int buffer_samples = m_buffer_size / m_bytes_per_sample;
        unsigned int timeout = (m_rate > 0) ?
            3 * ((1000 * buffer_samples) /
            Kwave::toUint(m_rate)) : 1000U;
        quint8 *p = reinterpret_cast<quint8 *>(m_buffer.data());

        // pad the buffer with silence if necessary
        if (samples < m_chunk_size) {
            snd_pcm_format_set_silence(m_format,
                m_buffer.data() + samples * m_bytes_per_sample,
                Kwave::toUint((m_chunk_size - samples) * m_channels));
            samples = m_chunk_size;
            qDebug("--- added silence ---");
        }

        while (samples > 0) {
            // try to write as much as the device accepts
            int r = Kwave::toInt(snd_pcm_writei(m_handle, p, samples));
            if ((r == -EAGAIN) || ((r >= 0) && (r < Kwave::toInt(samples))))
            {
                snd_pcm_wait(m_handle, timeout);
            } else if (r == -EPIPE) {
                // underrun -> start again
                qWarning("PlayBackALSA::flush(), underrun");
                r = snd_pcm_prepare(m_handle);
                if (r < 0) {
                    qWarning("PlayBackALSA::flush(), "\
                             "resume after underrun failed: %s",
                             snd_strerror(r));
                    m_buffer_used = 0;
                    return r;
                }
                qWarning("PlayBackALSA::flush(), after underrun: resuming");
                continue; // try again
            } else if (r == -ESTRPIPE) {
                qWarning("PlayBackALSA::flush(), suspended. "\
                         "trying to resume...");
                while ((r = snd_pcm_resume(m_handle)) == -EAGAIN)
                    sleep(1); /* wait until suspend flag is released */
                if (r < 0) {
                    qWarning("PlayBackALSA::flush(), resume failed, "\
                             "restarting stream.");
                    if ((r = snd_pcm_prepare(m_handle)) < 0) {
                        qWarning("PlayBackALSA::flush(), resume error: %s",
                                 snd_strerror(r));
                        m_buffer_used = 0;
                        return r;
                    }
                }
                qWarning("PlayBackALSA::flush(), after suspend: resuming");
                continue; // try again
            } else if (r < 0) {
                qWarning("write error: %s", snd_strerror(r));
                m_buffer_used = 0;
                return r;
            }
            if (r > 0) {
                // advance in the buffer
                Q_ASSERT(r <= Kwave::toInt(samples));
                p       += r * m_bytes_per_sample;
                samples -= r;
            }
        }
    }

    m_buffer_used = 0;
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mode2format()

int Kwave::PlayBackALSA::mode2format ( int  bits )

private

create a ALSA device format (enum) from parameters.

Parameters

bits	the number of bits per sample, related to the decoded stream

Returns

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

Definition at line 261 of file PlayBack-ALSA.cpp.

References _known_formats, and m_supported_formats.

Referenced by setFormat().

{
    // loop over all supported formats and keep only those that are
    // compatible with the given compression, bits and sample format
    foreach (int index, m_supported_formats) {
        const snd_pcm_format_t *fmt = &_known_formats[index];

        if (snd_pcm_format_width(*fmt) != bits) 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 ;-)
//      qDebug("PlayBackALSA::mode2format -> %d", index);
        return index;
    }

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

Here is the caller graph for this function:

open()

QString Kwave::PlayBackALSA::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 540 of file PlayBack-ALSA.cpp.

References DBG, detectSupportedFormats(), m_bits, m_bufbase, m_buffer, m_buffer_size, m_buffer_used, m_bytes_per_sample, m_channels, m_chunk_size, m_device_name, m_encoder, m_handle, m_rate, m_supported_formats, openDevice(), and Kwave::toUint().

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

    m_device_name = device;
    m_rate        = rate;
    m_channels    = channels;
    m_bits        = 0;
    m_bufbase     = bufbase;
    m_buffer_size = 0;
    m_buffer_used = 0;
    m_handle      = Q_NULLPTR;

    // close the previous device
    if (m_handle) snd_pcm_close(m_handle);
    m_handle = Q_NULLPTR;
    if (m_encoder) delete m_encoder;
    m_encoder = Q_NULLPTR;

    // initialize the list of supported formats
    m_supported_formats = detectSupportedFormats(device);

    int err = openDevice(device, Kwave::toUint(rate), channels, bits);
    if (err) {
        QString reason;
        switch (err) {
            case ENOENT:
            case ENODEV:
            case ENXIO:
            case EIO:
                reason = i18n("I/O error. Maybe the driver\n"\
                "is not present in your kernel or it is not\n"\
                "properly configured.");
                break;
            case EBUSY:
                reason = i18n(
                "The device is busy. Maybe some other application is\n"\
                "currently using it. Please try again later.\n"\
                "(Hint: you might find out the name and process ID of\n"\
                "the program by calling: \"fuser -v %1\"\n"\
                "on the command line.)",
                m_device_name);
                break;
            default:
                reason = i18n("Opening the device '%1' failed: %2",
                    device.section(QLatin1Char('|'), 0, 0),
                    QString::fromLocal8Bit(snd_strerror(err)));
        }
        return reason;
    }

    // resize our buffer and reset it
    Q_ASSERT(m_chunk_size);
    Q_ASSERT(m_bytes_per_sample);
    unsigned int chunk_bytes = Kwave::toUint(m_chunk_size) * m_bytes_per_sample;
    Q_ASSERT(chunk_bytes);
    if (!chunk_bytes) return QString();
    unsigned int n = Kwave::toUint(ceil(
        static_cast<double>(1 << m_bufbase) /
        static_cast<double>(chunk_bytes)));
    if (n < 1) n = 1;
    m_buffer_size = n * chunk_bytes;
    m_buffer.resize(m_buffer_size);
    m_buffer_size = m_buffer.size();

//     qDebug("PlayBackALSA::open: OK, buffer resized to %u bytes",
//            m_buffer_size);

    return QString();
}

Here is the call graph for this function:

openDevice() [1/2]

snd_pcm_t * Kwave::PlayBackALSA::openDevice ( const QString &  device )

protected

Opens a physical device and returns its file descriptor (short version, used for probing / detecting)

Parameters

device

filename of the device

Returns

pcm stream or null pointer on errors

Definition at line 909 of file PlayBack-ALSA.cpp.

References _, alsaDeviceName(), DBG, and m_handle.

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

{
    snd_pcm_t *pcm = m_handle;

//     qDebug("PlayBackALSA::openDevice(%s)", device.local8Bit().data());

    // translate verbose name to internal ALSA name
    QString alsa_device = alsaDeviceName(device);

    if (!alsa_device.length()) return Q_NULLPTR;

    // workaround for bug in ALSA
    // if the device name ends with "," -> invalid name
    if (alsa_device.endsWith(_(","))) return Q_NULLPTR;

    if (!pcm) {
        // open the device in case it's not already open
        int err = snd_pcm_open(&pcm, alsa_device.toLocal8Bit().data(),
                               SND_PCM_STREAM_PLAYBACK,
                               SND_PCM_NONBLOCK);
        if (err < 0) {
            pcm = Q_NULLPTR;
            qWarning("PlayBackALSA::openDevice('%s') - failed, err=%d (%s)",
                     DBG(alsa_device), err, snd_strerror(err));
        }
    }

    return pcm;
}

Here is the call graph for this function:

Here is the caller graph for this function:

openDevice() [2/2]

int Kwave::PlayBackALSA::openDevice ( const QString &  device, unsigned int  rate, unsigned int  channels, unsigned int  bits  )

protected

Open the device and set all internal member variables that need to be initialized for playback.

Parameters

device	name of the ALSA device
rate	sample rate, rounded as unsigned int
channels	number of tracks/channels to use
bits	number of bits per sample

Returns

zero or positive if succeeded, or negative error code if failed

Definition at line 343 of file PlayBack-ALSA.cpp.

References _, ALSA_MALLOC_WRAPPER, alsaDeviceName(), DBG, m_channels, m_chunk_size, m_handle, m_rate, and setFormat().

{
    int err;
    snd_output_t *output = Q_NULLPTR;
    ALSA_MALLOC_WRAPPER(snd_pcm_hw_params) hw_params;
    ALSA_MALLOC_WRAPPER(snd_pcm_sw_params) sw_params;
    snd_pcm_uframes_t buffer_size;
    unsigned period_time = 0; // period time in us
    unsigned buffer_time = 0; // ring buffer length in us
    snd_pcm_uframes_t period_frames = 0;
    snd_pcm_uframes_t buffer_frames = 0;
    snd_pcm_uframes_t start_threshold, stop_threshold;

    m_chunk_size = 0;
    if (m_handle) snd_pcm_close(m_handle);
    m_handle = Q_NULLPTR;

    // translate verbose name to internal ALSA name
    QString alsa_device = alsaDeviceName(device);
    qDebug("PlayBackALSA::openDevice() - opening ALSA device '%s', "
           "%dHz %d channels, %u bit",
           DBG(alsa_device.split(_("|")).at(0)), rate, channels, bits);

    // workaround for bug in ALSA
    // if the device name ends with "," -> invalid name
    if (alsa_device.endsWith(_(","))) return -ENODEV;

    if (!rate) return -EINVAL;
    if (!channels) return -EINVAL;
    if (!bits) return -EINVAL;

    err = snd_output_stdio_attach(&output, stderr, 0);
    if (err < 0) {
        qWarning("Output failed: %s", snd_strerror(err));
    }

    // open a new one
    err = snd_pcm_open(&m_handle, alsa_device.toLocal8Bit().data(),
                            SND_PCM_STREAM_PLAYBACK,
                            SND_PCM_NONBLOCK);
    if (err < 0) return err;

#if 0
    // this would be very nice if it works, but currently (alsa-1.0.8)
    // it causes only a segfault :-(
    err = snd_spcm_init(m_handle,
        (unsigned int)m_rate,
        m_channels,
        SND_PCM_FORMAT_S16_LE,
        SND_PCM_SUBFORMAT_STD,
        SND_SPCM_LATENCY_MEDIUM,
        SND_PCM_ACCESS_RW_INTERLEAVED,
        SND_SPCM_XRUN_IGNORE
        );
    if (err < 0) {
        qWarning("Cannot initialize '%s': %s",
                 device.local8Bit().data(), snd_strerror(err));
        return err;
    }
#else
    if ((err = snd_pcm_hw_params_any(m_handle, hw_params)) < 0) {
        qWarning("Cannot initialize hardware parameters: %s",
                 snd_strerror(err));
        snd_output_close(output);
        return err;
    }

    err = snd_pcm_hw_params_set_access(m_handle, hw_params,
         SND_PCM_ACCESS_RW_INTERLEAVED);
    if (err < 0) {
        qWarning("Cannot set access type: %s", snd_strerror(err));
        snd_output_close(output);
        return err;
    }

    err = setFormat(hw_params, bits);
    if (err < 0) {
        qWarning("Cannot set sample format: %s", snd_strerror(err));
        snd_output_close(output);
        return err;
    }

    err = snd_pcm_hw_params_set_channels(m_handle, hw_params, channels);
    if (err < 0) {
        qWarning("Cannot set channel count: %s", snd_strerror(err));
        snd_output_close(output);
        return err;
    }

    unsigned int rrate = rate;
    err = snd_pcm_hw_params_set_rate_near(m_handle, hw_params, &rrate,
                                          Q_NULLPTR);
    if (err < 0) {
        qWarning("Cannot set sample rate: %s", snd_strerror(err));
        snd_output_close(output);
        return err;
    }
    qDebug("   real rate = %u", rrate);
    if (static_cast<float>(rate) * 1.05f < rrate ||
        static_cast<float>(rate) * 0.95f > rrate)
    {
        qWarning("rate is not accurate (requested = %iHz, got = %iHz)",
                  rate, rrate);
        qWarning("         please, try the plug plugin (-Dplug:%s)",
                 snd_pcm_name(m_handle));
    }

    err = snd_pcm_hw_params_get_buffer_time_max(hw_params, &buffer_time,
                                                Q_NULLPTR);
    Q_ASSERT(err >= 0);
    if (buffer_time > 500000) buffer_time = 500000;
    if (buffer_time > 0)
        period_time = buffer_time / 4;
    else
        period_frames = buffer_frames / 4;

    if (period_time > 0) {
        err = snd_pcm_hw_params_set_period_time_near(m_handle, hw_params,
                                                     &period_time, Q_NULLPTR);
    } else {
        err = snd_pcm_hw_params_set_period_size_near(m_handle, hw_params,
                                                     &period_frames, Q_NULLPTR);
    }
    Q_ASSERT(err >= 0);
    if (buffer_time > 0) {
        err = snd_pcm_hw_params_set_buffer_time_near(m_handle, hw_params,
                                                     &buffer_time, Q_NULLPTR);
    } else {
        err = snd_pcm_hw_params_set_buffer_size_near(m_handle, hw_params,
                                                     &buffer_frames);
    }
    Q_ASSERT(err >= 0);

    qDebug("   setting hw_params");
    err = snd_pcm_hw_params(m_handle, hw_params);
    if (err < 0) {
        snd_pcm_dump(m_handle, output);
        snd_output_close(output);
        qWarning("Cannot set parameters: %s", snd_strerror(err));
        return err;
    }

    snd_pcm_hw_params_get_period_size(hw_params, &m_chunk_size, Q_NULLPTR);
    snd_pcm_hw_params_get_buffer_size(hw_params, &buffer_size);
    if (m_chunk_size == buffer_size) {
        qWarning("Can't use period equal to buffer size (%lu == %lu)",
                 m_chunk_size, buffer_size);
        snd_output_close(output);
        return -EIO;
    }

    /* set software parameters */
    err = snd_pcm_sw_params_current(m_handle, sw_params);
    if (err < 0) {
        qWarning("Unable to determine current software parameters: %s",
                 snd_strerror(err));
        snd_output_close(output);
        return err;
    }

    err = snd_pcm_sw_params_set_avail_min(m_handle, sw_params, m_chunk_size);
    Q_ASSERT(err >= 0);

    /* round up to closest transfer boundary */
    start_threshold = 1;
    err = snd_pcm_sw_params_set_start_threshold(m_handle, sw_params,
                                                start_threshold);
    Q_ASSERT(err >= 0);
    stop_threshold = buffer_size;

    err = snd_pcm_sw_params_set_stop_threshold(m_handle, sw_params,
                                               stop_threshold);
    Q_ASSERT(err >= 0);

    // write the software parameters to the playback device
    err = snd_pcm_sw_params(m_handle, sw_params);
    if (err < 0) {
        qDebug("   activating snd_pcm_sw_params FAILED");
        snd_pcm_dump(m_handle, output);
        qWarning("Unable to set software parameters: %s", snd_strerror(err));
    }
#endif

    snd_pcm_dump(m_handle, output);
    snd_output_close(output);

    // prepare the device for playback
    if ((err = snd_pcm_prepare(m_handle)) < 0) {
        snd_pcm_dump(m_handle, output);
        qWarning("cannot prepare interface for use: %s", snd_strerror(err));
    }

    return 0;
}

Here is the call graph for this function:

scanDevices()

void Kwave::PlayBackALSA::scanDevices ( )

protected

scan all ALSA devices, re-creates m_device_list

Definition at line 739 of file PlayBack-ALSA.cpp.

References _, ALSA_MALLOC_WRAPPER, DBG, DEFAULT_DEVICE, m_device_list, name, NULL_DEVICE, and Kwave::toInt().

Referenced by alsaDeviceName(), and supportedDevices().

{
    snd_ctl_t *handle;
    int card, err, dev;
    int idx;
    ALSA_MALLOC_WRAPPER(snd_ctl_card_info) info;
    ALSA_MALLOC_WRAPPER(snd_pcm_info) pcminfo;

    m_device_list.clear();

    card = -1;
    if (snd_card_next(&card) < 0 || card < 0) {
        qWarning("no soundcards found...");
        return;
    }

//     qDebug("**** List of PLAYBACK Hardware Devices ****");
    while (card >= 0) {
        QString name;
        name = _("hw:%1");
        name = name.arg(card);
        if ((err = snd_ctl_open(&handle, name.toLocal8Bit().data(), 0)) < 0) {
            qWarning("control open (%i): %s", card, snd_strerror(err));
            goto next_card;
        }
        if ((err = snd_ctl_card_info(handle, info)) < 0) {
            qWarning("control hardware info (%i): %s",
                     card, snd_strerror(err));
            snd_ctl_close(handle);
            goto next_card;
        }
        dev = -1;
        while (1) {
            unsigned int count;
            if (snd_ctl_pcm_next_device(handle, &dev)<0)
                qWarning("snd_ctl_pcm_next_device");
            if (dev < 0)
                break;
            snd_pcm_info_set_device(pcminfo, dev);
            snd_pcm_info_set_subdevice(pcminfo, 0);
            snd_pcm_info_set_stream(pcminfo, SND_PCM_STREAM_PLAYBACK);
            if ((err = snd_ctl_pcm_info(handle, pcminfo)) < 0) {
                if (err != -ENOENT)
                    qWarning("control digital audio info (%i): %s", card,
                             snd_strerror(err));
                continue;
            }
            count = snd_pcm_info_get_subdevices_count(pcminfo);

//          qDebug("card %i: %s [%s], device %i: %s [%s]",
//              card,
//              snd_ctl_card_info_get_id(info),
//              snd_ctl_card_info_get_name(info),
//              dev,
//              snd_pcm_info_get_id(pcminfo),
//              snd_pcm_info_get_name(pcminfo));

            // add the device to the list
            QString hw_device;
            hw_device = _("plughw:%1,%2");
            hw_device = hw_device.arg(card).arg(dev);

            QString card_name   = _(snd_ctl_card_info_get_name(info));
            QString device_name = _(snd_pcm_info_get_name(pcminfo));

//          qDebug("  Subdevices: %i/%i\n",
//              snd_pcm_info_get_subdevices_avail(pcminfo), count);
            if (count > 1) {
                for (idx = 0; idx < Kwave::toInt(count); idx++) {
                    snd_pcm_info_set_subdevice(pcminfo, idx);
                    if ((err = snd_ctl_pcm_info(handle, pcminfo)) < 0) {
                        qWarning("ctrl digital audio playback info (%i): %s",
                                 card, snd_strerror(err));
                    } else {
                        QString hwdev = hw_device + _(",%1").arg(idx);
                        QString subdevice_name =
                            _(snd_pcm_info_get_subdevice_name(pcminfo));
                        QString full_name = QString(
                            i18n("Card %1: ", card) + card_name +
                            _("|sound_card||") +
                            i18n("Device %1: ", dev) + device_name +
                            _("|sound_device||") +
                            i18n("Subdevice %1: ", idx) + subdevice_name +
                            _("|sound_subdevice")
                        );
                        qDebug("# '%s' -> '%s'", DBG(hwdev), DBG(full_name));
                        m_device_list.insert(full_name, hwdev);
                    }
                }
            } else {
                // no sub-devices
                QString full_name = QString(
                    i18n("Card %1: ", card) +
                         card_name + _("|sound_card||") +
                    i18n("Device %1: ", dev) +
                          device_name + _("|sound_subdevice")
                );
//              qDebug("# '%s' -> '%s'", DBG(hw_device), DBG(name));
                m_device_list.insert(full_name, hw_device);
            }
        }
        snd_ctl_close(handle);
next_card:
        if (snd_card_next(&card) < 0) {
            qWarning("snd_card_next failed");
            break;
        }
    }

    // per default: offer the dmix plugin and the default device
    // if slave devices exist
    if (!m_device_list.isEmpty()) {
        m_device_list.insert(i18n("DMIX plugin") +
                             _("|sound_note"),
                             _("plug:dmix"));
        m_device_list.insert(DEFAULT_DEVICE, _("default"));
    } else {
        m_device_list.insert(NULL_DEVICE, _("null"));
    }

}

Here is the call graph for this function:

Here is the caller graph for this function:

setFormat()

int Kwave::PlayBackALSA::setFormat ( snd_pcm_hw_params_t *  hw_params, unsigned int  bits  )

protected

Used in "openDevice()" to set the member variables m_format, m_bytes_per_sample and m_bits according the given resolution in bits per sample. The number of bits per sample will be rounded up to the next multiple of 8. m_handle must already be an opened device.

Parameters

hw_params	valid ALSA hardware parameters
bits	number of bits per sample [1...32]

Returns

zero or positive if succeeded, or negative error code if failed

Definition at line 217 of file PlayBack-ALSA.cpp.

References _known_formats, endian_of(), m_bits, m_bytes_per_sample, m_channels, m_encoder, m_format, m_handle, mode2format(), and sample_format_of().

Referenced by openDevice().

{
    qDebug("PlayBackALSA::setFormat(..., bits=%u)", bits);
    m_format = SND_PCM_FORMAT_UNKNOWN;
    m_bits = 0;
    m_bytes_per_sample = 0;
    if (m_encoder) delete m_encoder;
    m_encoder = Q_NULLPTR;

    // get a format that matches the number of bits
    int format_index = mode2format(bits);
    if (format_index < 0) {
        qWarning("PlayBackALSA::setFormat(): %u bit is not supported", bits);
        return -EINVAL;
    }

    m_format = _known_formats[format_index];
    m_bits = snd_pcm_format_width(m_format);
    m_bytes_per_sample =
        ((snd_pcm_format_physical_width(m_format) + 7) >> 3) * m_channels;

    m_encoder = new Kwave::SampleEncoderLinear(
        sample_format_of(m_format),
        m_bits,
        endian_of(m_format)
    );
    Q_ASSERT(m_encoder);
    if (!m_encoder) {
        qWarning("PlayBackALSA: out of memory");
        return -ENOMEM;
    }

    // activate the settings
    Q_ASSERT(m_bits);
    Q_ASSERT(m_bytes_per_sample);
    Q_ASSERT(m_format != SND_PCM_FORMAT_UNKNOWN);
    int err = snd_pcm_hw_params_set_format(m_handle, hw_params, m_format);
    Q_ASSERT(!err);

    return err;
}

Here is the call graph for this function:

Here is the caller graph for this function:

supportedBits()

QList< unsigned int > Kwave::PlayBackALSA::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 940 of file PlayBack-ALSA.cpp.

References _known_formats, and detectSupportedFormats().

{
    QList<unsigned int> list;
    QList<int> supported_formats;

    // try all known sample formats
    supported_formats = detectSupportedFormats(device);
    foreach (int index, supported_formats) {
        const snd_pcm_format_t *fmt = &(_known_formats[index]);
        const unsigned int bits = snd_pcm_format_width(*fmt);

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

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

//      qDebug("found bits/sample %u", bits);
        list.append(bits);
    }

    return list;
}

Here is the call graph for this function:

supportedDevices()

QStringList Kwave::PlayBackALSA::supportedDevices ( )

virtual

return a string list with supported device names

Reimplemented from Kwave::PlayBackDevice.

Definition at line 884 of file PlayBack-ALSA.cpp.

References _, DEFAULT_DEVICE, m_device_list, NULL_DEVICE, and scanDevices().

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

    QStringList list = m_device_list.keys();

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

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

    return list;
}

Here is the call graph for this function:

write()

int Kwave::PlayBackALSA::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 615 of file PlayBack-ALSA.cpp.

References Kwave::SampleEncoder::encode(), flush(), m_buffer, m_buffer_size, m_buffer_used, m_bytes_per_sample, m_channels, m_encoder, and MEMCPY.

{
    Q_ASSERT(m_encoder);
    if (!m_encoder) return -EIO;

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

    QByteArray raw(bytes, char(0));
    m_encoder->encode(samples, m_channels, raw);
    MEMCPY(m_buffer.data() + m_buffer_used, raw.constData(), bytes);
    m_buffer_used += bytes;

    // write buffer to device if full
    if (m_buffer_used >= m_buffer_size) return flush();

    return 0;
}

Here is the call graph for this function:

Member Data Documentation

m_bits

unsigned int Kwave::PlayBackALSA::m_bits

private

Resolution in bits per sample

Definition at line 190 of file PlayBack-ALSA.h.

Referenced by open(), and setFormat().

m_bufbase

unsigned int Kwave::PlayBackALSA::m_bufbase

private

Exponent of the buffer size

Definition at line 199 of file PlayBack-ALSA.h.

Referenced by open().

m_buffer

QByteArray Kwave::PlayBackALSA::m_buffer

private

buffer with raw device data

Definition at line 202 of file PlayBack-ALSA.h.

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

m_buffer_size

unsigned int Kwave::PlayBackALSA::m_buffer_size

private

Buffer size on bytes

Definition at line 205 of file PlayBack-ALSA.h.

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

m_buffer_used

unsigned int Kwave::PlayBackALSA::m_buffer_used

private

number of bytes in the buffer

Definition at line 208 of file PlayBack-ALSA.h.

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

m_bytes_per_sample

unsigned int Kwave::PlayBackALSA::m_bytes_per_sample

private

Number of bytes per sample, already multiplied with the number of channels (m_channels)

Definition at line 196 of file PlayBack-ALSA.h.

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

m_channels

unsigned int Kwave::PlayBackALSA::m_channels

private

Number of channels

Definition at line 187 of file PlayBack-ALSA.h.

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

m_chunk_size

snd_pcm_uframes_t Kwave::PlayBackALSA::m_chunk_size

private

number of samples per period

Definition at line 214 of file PlayBack-ALSA.h.

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

m_device_list

QMap< QString, QString > Kwave::PlayBackALSA::m_device_list

staticprivate

dictionary for translating verbose device names into ALSA hardware device names (key = verbose name, data = ALSA hardware device name)

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

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

m_device_name

QString Kwave::PlayBackALSA::m_device_name

private

Name of the output device

Definition at line 178 of file PlayBack-ALSA.h.

Referenced by open().

m_encoder

Kwave::SampleEncoder* Kwave::PlayBackALSA::m_encoder

private

encoder for conversion from samples to raw

Definition at line 232 of file PlayBack-ALSA.h.

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

m_format

snd_pcm_format_t Kwave::PlayBackALSA::m_format

private

sample format, used for ALSA

Definition at line 211 of file PlayBack-ALSA.h.

Referenced by flush(), and setFormat().

m_handle

snd_pcm_t* Kwave::PlayBackALSA::m_handle

private

Handle of the output device

Definition at line 181 of file PlayBack-ALSA.h.

Referenced by close(), detectChannels(), detectSupportedFormats(), flush(), open(), openDevice(), and setFormat().

m_rate

double Kwave::PlayBackALSA::m_rate

private

Playback rate [samples/second]

Definition at line 184 of file PlayBack-ALSA.h.

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

m_supported_formats

QList<int> Kwave::PlayBackALSA::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 229 of file PlayBack-ALSA.h.

Referenced by close(), detectSupportedFormats(), mode2format(), and open().

---

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

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