Kwave::RecordALSA Class Reference

#include <Record-ALSA.h>

Inheritance diagram for Kwave::RecordALSA:

Collaboration diagram for Kwave::RecordALSA:

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

Private Member Functions
void	detectSupportedFormats ()
int	initialize ()
int	mode2format (Kwave::Compression::Type compression, int bits, Kwave::SampleFormat::Format sample_format)
void	scanDevices ()
QString	alsaDeviceName (const QString &name)

Private Attributes
snd_pcm_t *	m_handle
snd_pcm_hw_params_t *	m_hw_params
snd_pcm_sw_params_t *	m_sw_params
int	m_open_result
unsigned int	m_tracks
double	m_rate
Kwave::Compression::Type	m_compression
unsigned int	m_bits_per_sample
unsigned int	m_bytes_per_sample
Kwave::SampleFormat::Format	m_sample_format
QList< int >	m_supported_formats
bool	m_initialized
unsigned int	m_buffer_size
snd_pcm_uframes_t	m_chunk_size

Static Private Attributes
static QMap< QString, QString >	m_device_list

Detailed Description

Definition at line 44 of file Record-ALSA.h.

Constructor & Destructor Documentation

RecordALSA()

Kwave::RecordALSA::RecordALSA

(

)

Constructor

Definition at line 198 of file Record-ALSA.cpp.

References m_hw_params, and m_sw_params.

    :Kwave::RecordDevice(), m_handle(Q_NULLPTR), m_hw_params(Q_NULLPTR),
     m_sw_params(Q_NULLPTR), m_open_result(0), m_tracks(0),
     m_rate(0.0), m_compression(Kwave::Compression::NONE),
     m_bits_per_sample(0), m_bytes_per_sample(0),
     m_sample_format(Kwave::SampleFormat::Unknown),
     m_supported_formats(), m_initialized(false), m_buffer_size(0),
     m_chunk_size(0)
{
    snd_pcm_hw_params_malloc(&m_hw_params);
    snd_pcm_sw_params_malloc(&m_sw_params);
    Q_ASSERT(m_hw_params);
    Q_ASSERT(m_sw_params);
}

~RecordALSA()

Kwave::RecordALSA::~RecordALSA ( )

virtual

Destructor

Definition at line 214 of file Record-ALSA.cpp.

References close(), m_hw_params, and m_sw_params.

{
    close();
    snd_pcm_hw_params_free(m_hw_params);
    snd_pcm_sw_params_free(m_sw_params);
}

Here is the call graph for this function:

Member Function Documentation

alsaDeviceName()

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

private

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 1105 of file Record-ALSA.cpp.

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

Referenced by open().

{
    if (m_device_list.isEmpty() || (name.length() &&
        !m_device_list.contains(name)))
    {
        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("RecordALSA::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:

bitsPerSample()

int Kwave::RecordALSA::bitsPerSample ( )

virtual

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

Implements Kwave::RecordDevice.

Definition at line 899 of file Record-ALSA.cpp.

References m_bits_per_sample.

{
    return m_bits_per_sample;
}

close()

int Kwave::RecordALSA::close ( )

virtual

Close the device

Implements Kwave::RecordDevice.

Definition at line 662 of file Record-ALSA.cpp.

References m_handle, m_initialized, m_open_result, and m_supported_formats.

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

{
    // close the device handle

    if (m_handle) {
        snd_pcm_drop(m_handle);
        snd_pcm_hw_free(m_handle);
        snd_pcm_close(m_handle);
    }
    m_handle = Q_NULLPTR;
    m_open_result = -EINVAL;

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

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

    return 0;
}

Here is the caller graph for this function:

compression()

Kwave::Compression::Type Kwave::RecordALSA::compression ( )

virtual

Returns the current compression type (0==none)

Implements Kwave::RecordDevice.

Definition at line 858 of file Record-ALSA.cpp.

References m_compression.

Referenced by detectCompressions().

{
    return m_compression;
}

Here is the caller graph for this function:

detectCompressions()

QList< Kwave::Compression::Type > Kwave::RecordALSA::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 827 of file Record-ALSA.cpp.

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

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

    // try all known sample formats
    foreach(int it, m_supported_formats)
    {
        const snd_pcm_format_t *fmt = &(_known_formats[it]);
        Kwave::Compression::Type compression = compression_of(*fmt);

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

//      Kwave::Compression t;
//      qDebug("found compression %d '%s'", compression,
//             DBG(t.name(t.findFromData(compression))));
        list.append(compression);
    }

    return list;
}

Here is the call graph for this function:

detectSampleFormats()

QList< Kwave::SampleFormat::Format > Kwave::RecordALSA::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 905 of file Record-ALSA.cpp.

References _known_formats, 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(int it, m_supported_formats)
    {
        const snd_pcm_format_t *fmt = &(_known_formats[it]);
        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 (snd_pcm_format_width(*fmt) != Kwave::toInt(m_bits_per_sample))
            continue;

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

//      Kwave::SampleFormat::Map sf;
//      qDebug("found sample format %u ('%s')", (int)sample_format,
//              DBG(sf.name(sf.findFromData(sample_format))));

        list.append(sample_format);
    }

    return list;
}

Here is the call graph for this function:

detectSampleRates()

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

virtual

get a list of supported sample rates

Implements Kwave::RecordDevice.

Definition at line 719 of file Record-ALSA.cpp.

References ELEMENTS_OF, m_handle, and m_hw_params.

{
    QList<double> list;

    if (!m_handle || !m_hw_params) return list;

    if (snd_pcm_hw_params_any(m_handle, m_hw_params) < 0) return list;

    static const unsigned int known_rates[] = {
          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
        196000, // (just for testing)
        256000  // (just for testing)
    };

    // try all known sample rates
    for (unsigned int i = 0; i < ELEMENTS_OF(known_rates); i++) {
        unsigned int rate = known_rates[i];

        int err = snd_pcm_hw_params_test_rate(m_handle, m_hw_params, rate, 0);
        if (err < 0) continue;

        // do not produce duplicates
        bool is_duplicate = false;
        foreach (const double &r, list)
            if (qFuzzyCompare(rate, r)) { is_duplicate = true; break; }
        if (is_duplicate) continue;

//      qDebug("found rate %u Hz", rate);
        list.append(rate);
    }

    return list;
}

detectSupportedFormats()

void Kwave::RecordALSA::detectSupportedFormats ( )

private

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

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

References _known_formats, m_handle, m_hw_params, and m_supported_formats.

Referenced by open().

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

    Q_ASSERT(m_handle);
    if (!m_handle || !m_hw_params) return;

    if (snd_pcm_hw_params_any(m_handle, m_hw_params) < 0) return;

    // 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(m_handle, m_hw_params, 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 it, m_supported_formats) {
            const snd_pcm_format_t *f = &_known_formats[it];
            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', '%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 "),
//          DBG(sf.description(sf.findFromData(sample_format_of(
//          DBG(t.description(t.findFromData(compression_of(
//              *fmt), true))));

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

}

Here is the caller graph for this function:

detectTracks()

int Kwave::RecordALSA::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 684 of file Record-ALSA.cpp.

References m_handle, and m_hw_params.

{
    min = max = 0;

    if (!m_handle || !m_hw_params) return -1;

    if (snd_pcm_hw_params_any(m_handle, m_hw_params) >= 0) {
        int err;
        if ((err = snd_pcm_hw_params_get_channels_min(m_hw_params, &min)) < 0)
            qWarning("RecordALSA::detectTracks: min: %s",
                     snd_strerror(err));
        if ((err = snd_pcm_hw_params_get_channels_max(m_hw_params, &max)) < 0)
            qWarning("RecordALSA::detectTracks: max: %s",
                     snd_strerror(err));
    }

//     qDebug("RecordALSA::detectTracks, min=%u, max=%u", min, max);
    return 0;
}

endianness()

Kwave::byte_order_t Kwave::RecordALSA::endianness ( )

virtual

Returns the current endianness (big/little)

Implements Kwave::RecordDevice.

Definition at line 950 of file Record-ALSA.cpp.

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

{
    int index = mode2format(m_compression, m_bits_per_sample, m_sample_format);
    return (index >= 0) ?
        endian_of(_known_formats[index]) : Kwave::UnknownEndian;
}

Here is the call graph for this function:

initialize()

int Kwave::RecordALSA::initialize ( )

private

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

Returns

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

Definition at line 329 of file Record-ALSA.cpp.

References _known_formats, DBG, Kwave::TypesMap< IDX, DATA >::description(), Kwave::TypesMap< IDX, DATA >::findFromData(), m_bits_per_sample, m_buffer_size, m_bytes_per_sample, m_chunk_size, m_compression, m_handle, m_hw_params, m_initialized, m_rate, m_sample_format, m_sw_params, m_tracks, mode2format(), name, Kwave::toInt(), and Kwave::toUint().

Referenced by read().

{
    int err;
    snd_output_t *output = Q_NULLPTR;

    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;

//     qDebug("RecordALSA::initialize");
    Q_ASSERT(!m_initialized);

    m_buffer_size = 0;

    Q_ASSERT(m_handle);
    if (!m_handle || !m_hw_params) return -EBADF; // file not opened

    // close the device if it was previously open
    snd_pcm_drop(m_handle);

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

    if ((err = snd_pcm_hw_params_any(m_handle, m_hw_params)) < 0) {
        qWarning("Cannot initialize hardware parameters: %s",
                 snd_strerror(err));
        snd_output_close(output);
        return -EIO;
    }

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

    int format_index = mode2format(m_compression, m_bits_per_sample,
                                   m_sample_format);
    Q_ASSERT(format_index >= 0);
    if (format_index < 0) {
        Kwave::SampleFormat::Map sf;

        qWarning("RecordkALSA::setFormat(): 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()));

        snd_output_close(output);
        return -EINVAL;
    }

    Q_ASSERT(format_index >= 0);
    snd_pcm_format_t alsa_format = _known_formats[format_index];
    m_bytes_per_sample = ((snd_pcm_format_physical_width(
        _known_formats[format_index])+7) >> 3) * m_tracks;

    err = snd_pcm_hw_params_test_format(m_handle, m_hw_params, alsa_format);
    if (err) {
        qWarning("RecordkALSA::setFormat(): format %u is not supported",
            static_cast<int>(alsa_format));
        snd_output_close(output);
        return -EINVAL;
    }

    // activate the settings
    err = snd_pcm_hw_params_set_format(m_handle, m_hw_params, alsa_format);
    if (err < 0) {
        qWarning("Cannot set sample format: %s", snd_strerror(err));
        snd_output_close(output);
        return -EINVAL;
    }

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

    unsigned int rrate = (m_rate > 0) ? Kwave::toUint(rint(m_rate)) : 0;
    err = snd_pcm_hw_params_set_rate_near(m_handle, m_hw_params, &rrate,
                                          Q_NULLPTR);
    if (err < 0) {
        qWarning("Cannot set sample rate: %s", snd_strerror(err));
        snd_output_close(output);
        return -EINVAL;
    }
//     qDebug("   real rate = %u", rrate);
    if (m_rate * 1.05 < rrate || m_rate * 0.95 > rrate) {
        qWarning("rate is not accurate (requested = %iHz, got = %iHz)",
                 Kwave::toInt(m_rate), Kwave::toInt(rrate));
    }
    m_rate = rrate;

    err = snd_pcm_hw_params_get_buffer_time_max(m_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, m_hw_params,
                                                     &period_time, Q_NULLPTR);
    } else {
        err = snd_pcm_hw_params_set_period_size_near(m_handle, m_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, m_hw_params,
                                                     &buffer_time, Q_NULLPTR);
    } else {
        err = snd_pcm_hw_params_set_buffer_size_near(m_handle, m_hw_params,
                                                     &buffer_frames);
    }
    Q_ASSERT(err >= 0);

//     qDebug("   setting hw_params");
    err = snd_pcm_hw_params(m_handle, m_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(m_hw_params, &m_chunk_size, Q_NULLPTR);
    snd_pcm_hw_params_get_buffer_size(m_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, m_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, m_sw_params, m_chunk_size);

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

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

    // write the software parameters to the recording device
    err = snd_pcm_sw_params(m_handle, m_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));
    }

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

    if ((err = snd_pcm_start(m_handle)) < 0) {
        snd_pcm_dump(m_handle, output);
        qWarning("cannot start interface: %s",snd_strerror(err));
    }

    // resize our buffer and reset it
    Q_ASSERT(m_chunk_size);
    Q_ASSERT(m_bytes_per_sample);

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

    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mode2format()

int Kwave::RecordALSA::mode2format ( Kwave::Compression::Type  compression, int  bits, Kwave::SampleFormat::Format  sample_format  )

private

create a ALSA 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, as defined in libaudiofile (signed or unsigned)

Returns

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

Definition at line 800 of file Record-ALSA.cpp.

References _known_formats, 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 (int index, m_supported_formats)
    {
        const snd_pcm_format_t *fmt = &_known_formats[index];

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

open()

QString Kwave::RecordALSA::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::number(EINVAL)	on invalid parameters
QString(...)	device specific error message (already translated)

Implements Kwave::RecordDevice.

Definition at line 274 of file Record-ALSA.cpp.

References _, alsaDeviceName(), close(), DBG, detectSupportedFormats(), m_handle, m_initialized, and m_open_result.

{
//     qDebug("RecordALSA::open(%s)", DBG(device));

    // close the previous device
    if (m_handle) close();
    m_initialized = false;

    if (!device.length()) return QString::number(EINVAL); // no device name

    // translate verbose name to internal ALSA name
    QString alsa_device = alsaDeviceName(device);
    qDebug("RecordALSA::open -> '%s'", DBG(alsa_device));

    if (!alsa_device.length()) return QString::number(EINVAL);

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

    // open the device in case it's not already open
    m_open_result = snd_pcm_open(&m_handle, alsa_device.toLocal8Bit().data(),
                                 SND_PCM_STREAM_CAPTURE,
                                 SND_PCM_NONBLOCK);
    if (m_open_result < 0) {
        m_handle = Q_NULLPTR;
        qWarning("RecordALSA::openDevice('%s') - failed, err=%d (%s)",
                 DBG(alsa_device),
                 m_open_result, snd_strerror(m_open_result));

        QString reason;
        switch (m_open_result) {
            case -ENOENT:
            case -ENODEV:
            case -ENXIO:
            case -EIO:
                reason = QString::number(ENODEV);
                break;
            case -EBUSY:
                reason = QString::number(EBUSY);
                break;
            default:
                reason = QString::fromLocal8Bit(snd_strerror(m_open_result));
                break;
        }
        return reason;
    }

    // now we can detect all supported formats
    detectSupportedFormats();

    return QString();
}

Here is the call graph for this function:

read()

int Kwave::RecordALSA::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 528 of file Record-ALSA.cpp.

References initialize(), m_bytes_per_sample, m_chunk_size, m_handle, m_initialized, m_open_result, m_rate, Kwave::toInt(), and Kwave::toUint().

{
    unsigned int length = buffer.size();

    if (!m_handle) return m_open_result; // file not opened / open has failed
    if (!length)   return 0;             // no buffer, nothing to do

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

    Q_ASSERT(m_chunk_size);
    if (!m_chunk_size) return 0;

    unsigned int chunk_bytes = Kwave::toUint(m_chunk_size) * m_bytes_per_sample;
    Q_ASSERT(chunk_bytes);
    if (!chunk_bytes) return 0;

    // align the buffer size to the chunk size if necessary
    unsigned int n = (length / chunk_bytes);
    if (length != (n * chunk_bytes)) {
        n++;
        length = n * chunk_bytes;
//      qDebug("resizing buffer %p from %u to %u bytes",
//             buffer.data(), buffer.size(), length);
        buffer.resize(length);
    }

    Q_ASSERT(length >= offset);
    Q_ASSERT(m_rate > 0);
    unsigned int samples = (length - offset) / m_bytes_per_sample;

    // do not read more than one chunk at a time
    if (samples > m_chunk_size)
        samples = Kwave::toUint(m_chunk_size);

#ifdef DEBUG
    // just for debugging: detect state changes of the device
    static snd_pcm_state_t last_state = SND_PCM_STATE_DISCONNECTED;
    snd_pcm_state_t state = snd_pcm_state(m_handle);
    if (state != last_state) {
        switch (state) {
            case SND_PCM_STATE_OPEN:
                qDebug("SND_PCM_STATE_OPEN");
                break;
            case SND_PCM_STATE_SETUP:
                qDebug("SND_PCM_STATE_SETUP");
                break;
            case SND_PCM_STATE_PREPARED:
                qDebug("ND_PCM_STATE_PREPARED");
                break;
            case SND_PCM_STATE_RUNNING:
                qDebug("SND_PCM_STATE_RUNNING");
                break;
            case SND_PCM_STATE_XRUN:
                qDebug("SND_PCM_STATE_XRUN");
                break;
            case SND_PCM_STATE_DRAINING:
                qDebug("SND_PCM_STATE_DRAINING");
                break;
            case SND_PCM_STATE_PAUSED:
                qDebug("SND_PCM_STATE_PAUSED");
                break;
            case SND_PCM_STATE_SUSPENDED:
                qDebug("SND_PCM_STATE_SUSPENDED");
                break;
            case SND_PCM_STATE_DISCONNECTED:
                qDebug("SND_PCM_STATE_DISCONNECTED");
                break;
        }
        last_state = state;
    }
#endif /* DEBUG */

    // try to read as much as the device accepts
    Q_ASSERT(samples);
    Q_ASSERT(offset + samples <= Kwave::toUint(buffer.size()));
    int r = Kwave::toInt(
        snd_pcm_readi(m_handle, buffer.data() + offset, samples)
    );

    // handle all negative result codes
    if (r == -EAGAIN) {
        unsigned int timeout = (m_rate > 0) ?
            (((1000 * samples) / 4) / Kwave::toUint(m_rate)) : 10U;
        snd_pcm_wait(m_handle, timeout);
        return -EAGAIN;
    } else if (r == -EPIPE) {
        // underrun -> start again
        qWarning("RecordALSA::read(), underrun");
        r = snd_pcm_prepare(m_handle);
        if (r >= 0) r = snd_pcm_start(m_handle);
        if (r < 0) {
            qWarning("RecordALSA::read(), "
                     "resume after underrun failed: %s",
                     snd_strerror(r));
            return r;
        }
        qWarning("RecordALSA::read(), after underrun: resuming");
        return -EAGAIN; // try again
    } else if (r == -ESTRPIPE) {
        qWarning("RecordALSA::read(), suspended. "\
                    "trying to resume...");
        while ((r = snd_pcm_resume(m_handle)) == -EAGAIN)
            return -EAGAIN; /* wait until suspend flag is released */
        if (r < 0) {
            qWarning("RecordALSA::read(), resume failed, "
                    "restarting stream.");
            if ((r = snd_pcm_prepare(m_handle)) < 0) {
                qWarning("RecordALSA::read(), resume error: %s",
                            snd_strerror(r));
                return r;
            }
        }
        qWarning("RecordALSA::read(), after suspend: resuming");
        return -EAGAIN; // try again
    } else if (r < 0) {
        qWarning("RecordALSA: read error: %s", snd_strerror(r));
        return r;
    }

    // no error, successfully read something:
    // advance in the buffer
//     qDebug("<<< after read, r=%d", r);
    Q_ASSERT(r <= Kwave::toInt(samples));
    if (r > Kwave::toInt(samples)) r = samples;

    return (r * m_bytes_per_sample);
}

Here is the call graph for this function:

sampleFormat()

Kwave::SampleFormat::Format Kwave::RecordALSA::sampleFormat ( )

virtual

Returns the current sample format (signed/unsigned)

Implements Kwave::RecordDevice.

Definition at line 944 of file Record-ALSA.cpp.

References m_sample_format.

{
    return m_sample_format;
}

sampleRate()

double Kwave::RecordALSA::sampleRate ( )

virtual

Returns the current sample rate of the device

Implements Kwave::RecordDevice.

Definition at line 794 of file Record-ALSA.cpp.

References m_rate.

{
    return m_rate;
}

scanDevices()

void Kwave::RecordALSA::scanDevices ( )

private

scan all ALSA devices, re-creates m_device_list

Definition at line 974 of file Record-ALSA.cpp.

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

Referenced by alsaDeviceName(), and supportedDevices().

{
    snd_ctl_t *handle = Q_NULLPTR;
    int card, err, dev;
    int idx;
    snd_ctl_card_info_t *info    = Q_NULLPTR;
    snd_pcm_info_t      *pcminfo = Q_NULLPTR;

    m_device_list.clear();

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

    snd_ctl_card_info_malloc(&info);
    snd_pcm_info_malloc(&pcminfo);

//     qDebug("**** List of RECORD 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_CAPTURE);
            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 = _("hw:%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 =
                            i18n("Card %1: ", card_name) +
                            _("|sound_card||") +
                            i18n("Device %1: ", device_name) +
                            _("|sound_device||") +
                            i18n("Subdevice %1: ", 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_name) +
                    _("|sound_card||") +
                    i18n("Device %1: ", device_name) +
                    _("|sound_subdevice")
                )/*.arg(card).arg(dev)*/;
//              qDebug("# '%s' -> '%s'", hw_device.data(), name.data());
                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 dsnoop plugin if any slave devices exist
    if (!m_device_list.isEmpty()) {
        m_device_list.insert(DEFAULT_DEVICE, _("plug:dsnoop"));
    }

    snd_ctl_card_info_free(info);
    snd_pcm_info_free(pcminfo);

    /*
     * BUG: this call is allowed due to ALSA documentation, but causes
     *      SIGSEGV when closing the record device. Somehow the internal
     *      structures of the PCM devices get messed up :-(
     *      (THE, 2009-07-18)
     */
    /* snd_config_update_free_global(); */
}

Here is the call graph for this function:

Here is the caller graph for this function:

setBitsPerSample()

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

virtual

Set the resolution in bits per sample

Parameters

new_bits

resolution [bits/sample]

Implements Kwave::RecordDevice.

Definition at line 891 of file Record-ALSA.cpp.

References m_bits_per_sample, and m_initialized.

{
    if (m_bits_per_sample != new_bits) m_initialized = false;
    m_bits_per_sample = new_bits;
    return 0;
}

setCompression()

int Kwave::RecordALSA::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 850 of file Record-ALSA.cpp.

References m_compression, and m_initialized.

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

setSampleFormat()

int Kwave::RecordALSA::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 936 of file Record-ALSA.cpp.

References m_initialized, and m_sample_format.

{
    if (m_sample_format != new_format) m_initialized = false;
    m_sample_format = new_format;
    return 0;
}

setSampleRate()

int Kwave::RecordALSA::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 786 of file Record-ALSA.cpp.

References m_initialized, and m_rate.

{
    if (!qFuzzyCompare(new_rate, m_rate)) m_initialized = false;
    m_rate = new_rate;
    return 0;
}

setTracks()

int Kwave::RecordALSA::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 705 of file Record-ALSA.cpp.

References m_initialized, m_tracks, and tracks().

{
    if (tracks != m_tracks) m_initialized = false;
    m_tracks = tracks;
    return 0;
}

Here is the call graph for this function:

supportedBits()

QList< unsigned int > Kwave::RecordALSA::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 864 of file Record-ALSA.cpp.

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

{
    QList<unsigned int> list;

    // try all known sample formats
    foreach(int it, m_supported_formats)
    {
        const snd_pcm_format_t *fmt = &(_known_formats[it]);
        const unsigned int bits = snd_pcm_format_width(*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;

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

    return list;
}

Here is the call graph for this function:

supportedDevices()

QStringList Kwave::RecordALSA::supportedDevices ( )

virtual

return a string list with supported device names

Implements Kwave::RecordDevice.

Definition at line 958 of file Record-ALSA.cpp.

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

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

    QStringList list = m_device_list.keys();

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

    list.append(_("#TREE#"));
    return list;
}

Here is the call graph for this function:

tracks()

int Kwave::RecordALSA::tracks ( )

virtual

Returns the current number of tracks

Implements Kwave::RecordDevice.

Definition at line 713 of file Record-ALSA.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::RecordALSA::m_bits_per_sample

private

resolution [bits per sample]

Definition at line 251 of file Record-ALSA.h.

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

m_buffer_size

unsigned int Kwave::RecordALSA::m_buffer_size

private

size of the transfer buffer in bytes

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

Referenced by initialize().

m_bytes_per_sample

unsigned int Kwave::RecordALSA::m_bytes_per_sample

private

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

Definition at line 257 of file Record-ALSA.h.

Referenced by initialize(), and read().

m_chunk_size

snd_pcm_uframes_t Kwave::RecordALSA::m_chunk_size

private

number of samples per period

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

Referenced by initialize(), and read().

m_compression

Kwave::Compression::Type Kwave::RecordALSA::m_compression

private

compression mode

Definition at line 248 of file Record-ALSA.h.

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

m_device_list

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

staticprivate

dictionary for translating verbose device names into ALSA hardware device names

initializer for the list of devices

Definition at line 239 of file Record-ALSA.h.

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

m_handle

snd_pcm_t* Kwave::RecordALSA::m_handle

private

handle of the source device or null if not open

Definition at line 224 of file Record-ALSA.h.

Referenced by close(), detectSampleRates(), detectSupportedFormats(), detectTracks(), initialize(), open(), and read().

m_hw_params

snd_pcm_hw_params_t* Kwave::RecordALSA::m_hw_params

private

ALSA hardware parameters

Definition at line 227 of file Record-ALSA.h.

Referenced by detectSampleRates(), detectSupportedFormats(), detectTracks(), initialize(), RecordALSA(), and ~RecordALSA().

m_initialized

bool Kwave::RecordALSA::m_initialized

private

true if initialize() has been successfully been run

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

Referenced by close(), initialize(), open(), read(), setBitsPerSample(), setCompression(), setSampleFormat(), setSampleRate(), and setTracks().

m_open_result

int Kwave::RecordALSA::m_open_result

private

result of the "open" call, of interest when m_handle == 0

Definition at line 233 of file Record-ALSA.h.

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

m_rate

double Kwave::RecordALSA::m_rate

private

sample rate

Definition at line 245 of file Record-ALSA.h.

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

m_sample_format

Kwave::SampleFormat::Format Kwave::RecordALSA::m_sample_format

private

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

Definition at line 260 of file Record-ALSA.h.

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

m_supported_formats

QList<int> Kwave::RecordALSA::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 268 of file Record-ALSA.h.

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

m_sw_params

snd_pcm_sw_params_t* Kwave::RecordALSA::m_sw_params

private

ALSA software parameters

Definition at line 230 of file Record-ALSA.h.

Referenced by initialize(), RecordALSA(), and ~RecordALSA().

m_tracks

unsigned int Kwave::RecordALSA::m_tracks

private

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

Definition at line 242 of file Record-ALSA.h.

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

---

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

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