Kwave::PlayBackOSS Class Reference

#include <PlayBack-OSS.h>

Inheritance diagram for Kwave::PlayBackOSS:

Collaboration diagram for Kwave::PlayBackOSS:

Public Member Functions
	PlayBackOSS ()
virtual	~PlayBackOSS () 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
void	format2mode (int format, int &compression, int &bits, Kwave::SampleFormat::Format &sample_format) const
int	openDevice (const QString &device)
void	flush ()

Protected Attributes
QString	m_device_name
int	m_handle
double	m_rate
unsigned int	m_channels
unsigned int	m_bits
unsigned int	m_bufbase
Kwave::SampleArray	m_buffer
QByteArray	m_raw_buffer
unsigned int	m_buffer_size
unsigned int	m_buffer_used
Kwave::SampleEncoder *	m_encoder
int	m_oss_version

Detailed Description

Definition at line 37 of file PlayBack-OSS.h.

Constructor & Destructor Documentation

PlayBackOSS()

Kwave::PlayBackOSS::PlayBackOSS

(

)

Default constructor

Definition at line 87 of file PlayBack-OSS.cpp.

    :Kwave::PlayBackDevice(),
    m_device_name(),
    m_handle(-1),
    m_rate(0),
    m_channels(0),
    m_bits(0),
    m_bufbase(0),
    m_buffer(),
    m_raw_buffer(),
    m_buffer_size(0),
    m_buffer_used(0),
    m_encoder(Q_NULLPTR),
    m_oss_version(-1)
{
}

~PlayBackOSS()

Kwave::PlayBackOSS::~PlayBackOSS ( )

virtual

Destructor

Definition at line 105 of file PlayBack-OSS.cpp.

References close().

{
    close();
}

Here is the call graph for this function:

Member Function Documentation

close()

int Kwave::PlayBackOSS::close ( )

virtual

Closes the output device.

See also

PlayBackDevice::close

Implements Kwave::PlayBackDevice.

Definition at line 310 of file PlayBack-OSS.cpp.

References flush(), m_encoder, and m_handle.

Referenced by detectChannels(), supportedBits(), and ~PlayBackOSS().

{
    flush();

    // close the device handle
    if (m_handle) ::close(m_handle);

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

    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

detectChannels()

int Kwave::PlayBackOSS::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 572 of file PlayBack-OSS.cpp.

References close(), m_handle, MAX_CHANNELS, openDevice(), SNDCTL_DSP_CHANNELS, and Kwave::toInt().

{
    int fd, t, err = -1;

    min = 0;
    max = 0;

    fd = openDevice(device);
    if (fd < 0) return -1;

    // find the smalles number of tracks, limit to MAX_CHANNELS
    for (t=1; t < MAX_CHANNELS; t++) {
        int real_tracks = t;
        err = ioctl(fd, SNDCTL_DSP_CHANNELS, &real_tracks);
        Q_ASSERT(real_tracks == t);
        if (err >= 0) {
            min = real_tracks;
            break;
        }
    }
    if (t >= MAX_CHANNELS) {
        // no minimum track number found :-o
        qWarning("no minimum track number found, err=%d", err);
        // close the device if *we* opened it
        if ((fd != m_handle) && (fd >= 0)) ::close(fd);
        return err;
    }

    // find the highest number of tracks, start from MAX_CHANNELS downwards
    for (t = MAX_CHANNELS; t >= Kwave::toInt(min); t--) {
        int real_tracks = t;
        err = ioctl(fd, SNDCTL_DSP_CHANNELS, &real_tracks);
        Q_ASSERT(real_tracks == t);
        if (err >= 0) {
            max = real_tracks;
            break;
        }
    }
    max = t;
//     qDebug("PlayBackOSS::detectTracks, min=%u, max=%u", min, max);

    // close the device if *we* opened it
    if ((fd != m_handle) && (fd >= 0)) ::close(fd);
    return 0;
}

Here is the call graph for this function:

fileFilter()

QString Kwave::PlayBackOSS::fileFilter ( )

virtual

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

Reimplemented from Kwave::PlayBackDevice.

Definition at line 396 of file PlayBack-OSS.cpp.

References _.

{
    QString filter;

    if (filter.length()) filter += _("\n");
    filter += _("dsp*|") + i18n("OSS playback device (dsp*)");

    if (filter.length()) filter += _("\n");
    filter += _("adsp*|") + i18n("ALSA playback device (adsp*)");

    if (filter.length()) filter += _("\n");
    filter += _("*|") + i18n("Any device (*)");

    return filter;
}

flush()

void Kwave::PlayBackOSS::flush ( )

protected

Writes the output buffer to the device

Definition at line 293 of file PlayBack-OSS.cpp.

References Kwave::SampleEncoder::encode(), m_buffer, m_buffer_used, m_encoder, m_handle, m_raw_buffer, Kwave::SampleEncoder::rawBytesPerSample(), and write().

Referenced by close(), and write().

{
    if (!m_buffer_used || !m_encoder) return; // nothing to do

    // convert into byte stream
    unsigned int bytes = m_buffer_used * m_encoder->rawBytesPerSample();
    m_encoder->encode(m_buffer, m_buffer_used, m_raw_buffer);

    ssize_t res = 0;
    if (m_handle)
        res = ::write(m_handle, m_raw_buffer.data(), bytes);
    if (res < 0) perror(__FUNCTION__);

    m_buffer_used = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

format2mode()

void Kwave::PlayBackOSS::format2mode ( int  format, int &  compression, int &  bits, Kwave::SampleFormat::Format &  sample_format  ) const

protected

split a device format bitmask into its parameters. (copied from playback plugin)

Parameters

format	the device specific format
compression	receives a compression type

See also

Compression

Parameters

bits	receives the number of bits per sample, related to the decoded stream
sample_format	receives the sample format, as defined in libaudiofile (signed or unsigned)

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

References AFMT_S24_BE, AFMT_S24_LE, AFMT_S32_BE, AFMT_S32_LE, Kwave::Compression::G711_ALAW, Kwave::Compression::G711_ULAW, m_oss_version, Kwave::Compression::MPEG_LAYER_II, Kwave::Compression::MS_ADPCM, Kwave::Compression::NONE, Kwave::SampleFormat::Signed, Kwave::SampleFormat::Unknown, and Kwave::SampleFormat::Unsigned.

Referenced by supportedBits().

{
    switch (format) {
        case AFMT_MU_LAW:
            compression   = Kwave::Compression::G711_ULAW;
            sample_format = Kwave::SampleFormat::Signed;
            bits          = 16;
            break;
        case AFMT_A_LAW:
            compression   = Kwave::Compression::G711_ALAW;
            sample_format = Kwave::SampleFormat::Unsigned;
            bits          = 16;
            break;
        case AFMT_IMA_ADPCM:
            compression   = Kwave::Compression::MS_ADPCM;
            sample_format = Kwave::SampleFormat::Signed;
            bits          = 16;
            break;
        case AFMT_U8:
            compression   = Kwave::Compression::NONE;
            sample_format = Kwave::SampleFormat::Unsigned;
            bits          = 8;
            break;
        case AFMT_S16_LE:
        case AFMT_S16_BE:
            compression   = Kwave::Compression::NONE;
            sample_format = Kwave::SampleFormat::Signed;
            bits          = 16;
            break;
        case AFMT_S8:
            compression   = Kwave::Compression::NONE;
            sample_format = Kwave::SampleFormat::Signed;
            bits          = 8;
            break;
        case AFMT_U16_LE:
        case AFMT_U16_BE:
            compression   = Kwave::Compression::NONE;
            sample_format = Kwave::SampleFormat::Unsigned;
            bits          = 16;
            break;
        case AFMT_MPEG:
            compression   = static_cast<int>(
                            Kwave::Compression::MPEG_LAYER_II);
            sample_format = Kwave::SampleFormat::Signed;
            bits          = 16;
            break;
#if 0
        case AFMT_AC3: /* Dolby Digital AC3 */
            compression   = Kwave::SampleFormat::Unknown;
            sample_format = 0;
            bits          = 16;
            break;
#endif
        case AFMT_S24_LE:
        case AFMT_S24_BE:
            if (m_oss_version >= 0x040000) {
                compression   = Kwave::Compression::NONE;
                sample_format = Kwave::SampleFormat::Signed;
                bits          = 24;
                break;
            } /* FALLTHROUGH */
        case AFMT_S32_LE:
        case AFMT_S32_BE:
            if (m_oss_version >= 0x040000) {
                compression   = Kwave::Compression::NONE;
                sample_format = Kwave::SampleFormat::Signed;
                bits          = 32;
                break;
            } /* FALLTHROUGH */
        default:
            compression   = -1;
            sample_format = Kwave::SampleFormat::Unknown;
            bits          = -1;
    }

}

Here is the caller graph for this function:

open()

QString Kwave::PlayBackOSS::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 111 of file PlayBack-OSS.cpp.

References _, AFMT_S24_LE, AFMT_S32_LE, DBG, Kwave::LittleEndian, m_bits, m_bufbase, m_buffer, m_buffer_size, m_buffer_used, m_channels, m_device_name, m_encoder, m_handle, m_oss_version, m_rate, m_raw_buffer, MAX_PLAYBACK_BUFFER, MIN_PLAYBACK_BUFFER, Kwave::SampleEncoder::rawBytesPerSample(), Kwave::SampleArray::resize(), Kwave::SampleFormat::Signed, SNDCTL_DSP_CHANNELS, SNDCTL_DSP_SETFMT, SNDCTL_DSP_SPEED, Kwave::toInt(), and Kwave::SampleFormat::Unsigned.

Referenced by openDevice().

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

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

    // prepeare for playback by opening the sound device
    // and initializing with the proper settings
    m_handle = ::open(m_device_name.toLocal8Bit(), O_WRONLY | O_NONBLOCK);
    if (m_handle == -1) {
        QString reason;
        switch (errno) {
            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.section(QLatin1Char('|'), 0, 0));
                break;
            default:
                reason = QString::fromLocal8Bit(strerror(errno));
        }
        return reason;
    }

    // the device was opened in non-blocking mode to detect if it is
    // busy or not - but from now on we need blocking mode again
    ::fcntl(m_handle, F_SETFL, fcntl(m_handle, F_GETFL) & ~O_NONBLOCK);
    if (fcntl(m_handle, F_GETFL) & O_NONBLOCK) {
        // resetting O:NONBLOCK failed
        return i18n("The device '%1' cannot be opened "\
                    "in the correct mode.",
                    m_device_name.section(QLatin1Char('|'), 0, 0));
    }

    // query OSS driver version
    m_oss_version = 0x030000;
#ifdef OSS_GETVERSION
    ioctl(m_handle, OSS_GETVERSION, &m_oss_version);
#endif

    int format;
    switch (m_bits) {
        case  8: format = AFMT_U8;     break;
        case 24: format = AFMT_S24_LE; break;
        case 32: format = AFMT_S32_LE; break;
        default: format = AFMT_S16_LE;
    }

    // number of bits per sample
    int oldformat = format;
    if ((ioctl(m_handle, SNDCTL_DSP_SETFMT, &format) == -1) ||
        (format != oldformat)) {
        return i18n("%1 bits per sample are not supported", m_bits);
    }

    // channels selection
    if ((ioctl(m_handle, SNDCTL_DSP_CHANNELS, &m_channels) == -1) ||
        (format != oldformat)) {
        return i18n("%1 channels playback is not supported", m_channels);
    }

    // playback rate, we allow up to 10% variation
    int int_rate = Kwave::toInt(m_rate);
    if ((ioctl(m_handle, SNDCTL_DSP_SPEED, &int_rate) == -1) ||
        (int_rate < 0.9 * m_rate) || (int_rate > 1.1 * m_rate)) {
        return i18n("Playback rate %1 Hz is not supported", int_rate);
    }
    m_rate = int_rate;

    // buffer size
    Q_ASSERT(bufbase >= MIN_PLAYBACK_BUFFER);
    Q_ASSERT(bufbase <= MAX_PLAYBACK_BUFFER);
    if (bufbase < MIN_PLAYBACK_BUFFER) bufbase = MIN_PLAYBACK_BUFFER;
    if (bufbase > MAX_PLAYBACK_BUFFER) bufbase = MAX_PLAYBACK_BUFFER;
    if (ioctl(m_handle, SNDCTL_DSP_SETFRAGMENT, &bufbase) == -1) {
        return i18n("Unusable buffer size: %1", 1 << bufbase);
    }

    // get the real buffer size in bytes
    ioctl(m_handle, SNDCTL_DSP_GETBLKSIZE, &m_buffer_size);

    // create the sample encoder
    // we assume that OSS is always little endian
    if (m_encoder) delete m_encoder;

    switch (m_bits) {
        case 8:
            m_encoder = new Kwave::SampleEncoderLinear(
                Kwave::SampleFormat::Unsigned, 8, Kwave::LittleEndian);
            break;
        case 24:
            if (m_oss_version >= 0x040000) {
                m_encoder = new Kwave::SampleEncoderLinear(
                Kwave::SampleFormat::Signed, 24, Kwave::LittleEndian);
                break;
            } // else:
            /* FALLTHROUGH */
        case 32:
            if (m_oss_version >= 0x040000) {
                m_encoder = new Kwave::SampleEncoderLinear(
                    Kwave::SampleFormat::Signed, 32, Kwave::LittleEndian);
                break;
            }
            // else:
            /* FALLTHROUGH */
        default:
            m_encoder = new Kwave::SampleEncoderLinear(
                Kwave::SampleFormat::Signed, 16, Kwave::LittleEndian);
            break;
    }

    Q_ASSERT(m_encoder);
    if (!m_encoder) return i18n("Out of memory");

    // resize the raw buffer
    m_raw_buffer.resize(m_buffer_size);

    // resize our buffer (size in samples) and reset it
    m_buffer_size /= m_encoder->rawBytesPerSample();
    if (!m_buffer.resize(m_buffer_size))
        return i18n("Out of memory");

    return QString();
}

Here is the call graph for this function:

Here is the caller graph for this function:

openDevice()

int Kwave::PlayBackOSS::openDevice ( const QString &  device )

protected

Opens a physical device and returns its file descriptor

Parameters

device

filename of the device

Returns

file descriptor >= 0 or negative value on errors

Definition at line 492 of file PlayBack-OSS.cpp.

References DBG, m_handle, m_oss_version, and open().

Referenced by detectChannels(), and supportedBits().

{
    int fd = m_handle;

//     qDebug("PlayBackOSS::openDevice(%s)", device.local8Bit().data());
    if (!device.length()) return -1;

    if (fd <= 0) {
        // open the device in case it's not already open
        fd = ::open(device.toLocal8Bit(), O_WRONLY | O_NONBLOCK);
        if (fd <= 0) {
            qWarning("PlayBackOSS::openDevice('%s') - failed, errno=%d (%s)",
                 DBG(device),
                 errno, strerror(errno));
        } else {
            // we use blocking mode
            ::fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) & ~O_NONBLOCK);
            // query OSS driver version
            m_oss_version = -1;
#ifdef OSS_GETVERSION
            ioctl(fd, OSS_GETVERSION, &m_oss_version);
#endif
        }
    }
    if (fd <= 0) {
        qWarning("PlayBackOSS::openDevice('%s') - failed, errno=%d (%s)",
                 DBG(device), errno, strerror(errno));
    }

    return fd;
}

Here is the call graph for this function:

Here is the caller graph for this function:

supportedBits()

QList< unsigned int > Kwave::PlayBackOSS::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 525 of file PlayBack-OSS.cpp.

References close(), format2mode(), m_handle, Kwave::Compression::NONE, and openDevice().

{
    QList<unsigned int> bits;
    bits.clear();
    int err = -1;
    int mask = AFMT_QUERY;
    int fd;

//     qDebug("PlayBackOSS::supportedBits(%s)", device.local8Bit().data());

    fd = openDevice(device);
    if (fd >= 0) {
        err = ::ioctl(fd, SNDCTL_DSP_GETFMTS, &mask);
        if (err < 0) {
            qWarning("PlayBackOSS::supportedBits() - "\
                     "SNDCTL_DSP_GETFMTS failed, "\
                     "fd=%d, result=%d, error=%d (%s)",
                     fd, err, errno, strerror(errno));
        }
    }

    // close the device if *we* opened it
    if ((fd != m_handle) && (fd >= 0)) ::close(fd);

    if (err < 0) return bits;

    // mask out all modes that do not match the current compression
    const int compression = Kwave::Compression::NONE;
    for (unsigned int bit=0; bit < (sizeof(mask) << 3); bit++) {
        if (!(mask & (1 << bit))) continue;

        // format is supported, split into compression, bits, sample format
        int c, b;
        Kwave::SampleFormat::Format s;
        format2mode(1 << bit, c, b, s);
        if (b < 0) continue; // unknown -> skip

        // take the mode if compression matches and it is not already known
        if ((c == compression) && !(bits.contains(b))) {
            bits += b;
        }
    }

    return bits;
}

Here is the call graph for this function:

supportedDevices()

QStringList Kwave::PlayBackOSS::supportedDevices ( )

virtual

return a string list with supported device names

Reimplemented from Kwave::PlayBackDevice.

Definition at line 379 of file PlayBack-OSS.cpp.

References _, scanDirectory(), and scanFiles().

{
    QStringList list, dirlist;

    scanDirectory(list, _("/dev"));
    scanDirectory(list, _("/dev/snd"));
    scanDirectory(list, _("/dev/sound"));
    scanFiles(dirlist, _("/dev/oss"), _("[^.]*"));
    foreach (QString dir, dirlist)
        scanDirectory(list, dir);
    list.append(_("#EDIT#"));
    list.append(_("#SELECT#"));

    return list;
}

Here is the call graph for this function:

write()

int Kwave::PlayBackOSS::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 259 of file PlayBack-OSS.cpp.

References flush(), m_buffer, m_buffer_size, m_buffer_used, MEMCPY, and Kwave::SampleArray::size().

Referenced by flush().

{
    Q_ASSERT (m_buffer_used <= m_buffer_size);
    if (m_buffer_used > m_buffer_size) {
        qWarning("PlayBackOSS::write(): buffer overflow ?!");
        m_buffer_used = m_buffer_size;
        flush();
        return -EIO;
    }

    // number of samples left in the buffer
    unsigned int remaining = samples.size();
    unsigned int offset    = 0;
    while (remaining) {
        unsigned int length = remaining;
        if (m_buffer_used + length > m_buffer_size)
            length = m_buffer_size - m_buffer_used;

        MEMCPY(&(m_buffer[m_buffer_used]),
               &(samples[offset]),
               length * sizeof(sample_t));
        m_buffer_used += length;
        offset        += length;
        remaining     -= length;

        // write buffer to device if it has become full
        if (m_buffer_used >= m_buffer_size)
            flush();
    }

    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_bits

unsigned int Kwave::PlayBackOSS::m_bits

protected

Resolution in bits per sample

Definition at line 139 of file PlayBack-OSS.h.

Referenced by open().

m_bufbase

unsigned int Kwave::PlayBackOSS::m_bufbase

protected

Exponent of the buffer size

Definition at line 142 of file PlayBack-OSS.h.

Referenced by open().

m_buffer

Kwave::SampleArray Kwave::PlayBackOSS::m_buffer

protected

buffer with samples data

Definition at line 145 of file PlayBack-OSS.h.

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

m_buffer_size

unsigned int Kwave::PlayBackOSS::m_buffer_size

protected

Buffer size on bytes

Definition at line 151 of file PlayBack-OSS.h.

Referenced by open(), and write().

m_buffer_used

unsigned int Kwave::PlayBackOSS::m_buffer_used

protected

number of bytes in the buffer

Definition at line 154 of file PlayBack-OSS.h.

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

m_channels

unsigned int Kwave::PlayBackOSS::m_channels

protected

Number of channels

Definition at line 136 of file PlayBack-OSS.h.

Referenced by open().

m_device_name

QString Kwave::PlayBackOSS::m_device_name

protected

Name of the output device

Definition at line 127 of file PlayBack-OSS.h.

Referenced by open().

m_encoder

Kwave::SampleEncoder* Kwave::PlayBackOSS::m_encoder

protected

encoder for converting from samples to raw format

Definition at line 157 of file PlayBack-OSS.h.

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

m_handle

int Kwave::PlayBackOSS::m_handle

protected

Handle of the output device

Definition at line 130 of file PlayBack-OSS.h.

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

m_oss_version

int Kwave::PlayBackOSS::m_oss_version

protected

OSS driver version

Definition at line 160 of file PlayBack-OSS.h.

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

m_rate

double Kwave::PlayBackOSS::m_rate

protected

Playback rate [samples/second]

Definition at line 133 of file PlayBack-OSS.h.

Referenced by open().

m_raw_buffer

QByteArray Kwave::PlayBackOSS::m_raw_buffer

protected

buffer with raw data

Definition at line 148 of file PlayBack-OSS.h.

Referenced by flush(), and open().

---

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

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