Kwave::AudiofileDecoder Class Reference

#include <AudiofileDecoder.h>

Inheritance diagram for Kwave::AudiofileDecoder:

Collaboration diagram for Kwave::AudiofileDecoder:

Public Member Functions
	AudiofileDecoder ()
virtual	~AudiofileDecoder () Q_DECL_OVERRIDE
virtual Kwave::Decoder *	instance () Q_DECL_OVERRIDE
virtual bool	open (QWidget *widget, QIODevice &source) Q_DECL_OVERRIDE
virtual bool	decode (QWidget *widget, Kwave::MultiWriter &dst) Q_DECL_OVERRIDE
virtual void	close () Q_DECL_OVERRIDE
Public Member Functions inherited from Kwave::Decoder
	Decoder ()
virtual	~Decoder ()
virtual Kwave::MetaDataList &	metaData ()
Public Member Functions inherited from Kwave::CodecBase
	CodecBase ()
virtual	~CodecBase ()
virtual bool	supports (const QMimeType &mimetype)
virtual bool	supports (const QString &mimetype_name)
virtual QStringList	extensions (const QString &mimetype_name) const
virtual const QList< CodecBase::MimeType >	mimeTypes ()
virtual const QList< Kwave::Compression::Type >	compressionTypes ()
virtual void	addMimeType (const char *name, const QString &description, const char *patterns)
virtual void	addCompression (Kwave::Compression::Type compression)
virtual QString	mimeTypeOf (const QUrl &url)

Private Attributes
QIODevice *	m_source
Kwave::VirtualAudioFile *	m_src_adapter

Additional Inherited Members
Signals inherited from Kwave::Decoder
void	sourceProcessed (quint64 pos)
Protected Attributes inherited from Kwave::Decoder
Kwave::MetaDataList	m_meta_data

Detailed Description

Definition at line 33 of file AudiofileDecoder.h.

Constructor & Destructor Documentation

AudiofileDecoder()

Kwave::AudiofileDecoder::AudiofileDecoder

(

)

Constructor

Definition at line 40 of file AudiofileDecoder.cpp.

References Kwave::CodecBase::addMimeType().

    :Kwave::Decoder(), m_source(Q_NULLPTR), m_src_adapter(Q_NULLPTR)
{
    /* defined in RFC 1521 */
    addMimeType("audio/basic",
                i18n("NeXT, Sun Audio"),
                "*.au; *.snd");

    /* some others, mime types might be wrong (I found no RFC or similar)  */
    addMimeType("audio/x-8svx",
                i18n("Amiga IFF/8SVX Sound File Format"),
                "*.iff; *.8svx");
    addMimeType("audio/x-aifc",
                i18n("Compressed Audio Interchange Format"),
                "*.aifc");
    addMimeType("audio/x-aiff", /* included in KDE */
                i18n("Audio Interchange Format"),
                "*.aif; *.aiff");
    addMimeType("audio/x-avr",
                i18n("Audio Visual Research File Format"),
                "*.avr");
    addMimeType("audio/x-caf",
                i18n("Core Audio File Format"),
                "*.caf");
    addMimeType("audio/x-ircam",
                i18n("Berkeley, IRCAM, Carl Sound Format"),
                "*.sf");
    addMimeType("audio/x-nist",
                i18n("NIST SPHERE Audio File Format"),
                "*.nist");
    addMimeType("audio/x-smp",
                i18n("Sample Vision Format"),
                "*.smp");
    addMimeType("audio/x-voc",
                i18n("Creative Voice"),
                "*.voc");
}

Here is the call graph for this function:

~AudiofileDecoder()

Kwave::AudiofileDecoder::~AudiofileDecoder ( )

virtual

Destructor

Definition at line 79 of file AudiofileDecoder.cpp.

References close(), m_source, and m_src_adapter.

{
    if (m_source) close();
    if (m_src_adapter) delete m_src_adapter;
}

Here is the call graph for this function:

Member Function Documentation

close()

void Kwave::AudiofileDecoder::close ( )

virtual

Closes the source.

Implements Kwave::Decoder.

Definition at line 294 of file AudiofileDecoder.cpp.

References m_source, and m_src_adapter.

Referenced by ~AudiofileDecoder().

{
    if (m_src_adapter) delete m_src_adapter;
    m_src_adapter = Q_NULLPTR;
    m_source = Q_NULLPTR;
}

Here is the caller graph for this function:

decode()

bool Kwave::AudiofileDecoder::decode ( QWidget *  widget, Kwave::MultiWriter &  dst  )

virtual

Decodes a stream of bytes into a MultiWriter

Parameters

widget	a widget that can be used for displaying message boxes or dialogs
dst	MultiWriter that receives the audio data

Returns

true if succeeded, false on errors

Implements Kwave::Decoder.

Definition at line 230 of file AudiofileDecoder.cpp.

References Kwave::VirtualAudioFile::handle(), Kwave::MultiWriter::isCanceled(), Kwave::FileInfo::length(), m_source, m_src_adapter, Kwave::Decoder::metaData(), SAMPLE_BITS, SAMPLE_STORAGE_BITS, Kwave::toUint(), and Kwave::FileInfo::tracks().

{
    Q_ASSERT(m_src_adapter);
    Q_ASSERT(m_source);
    if (!m_source) return false;
    if (!m_src_adapter) return false;

    AFfilehandle fh = m_src_adapter->handle();
    Q_ASSERT(fh);
    if (!fh) return false;

    unsigned int frame_size = Kwave::toUint(
        afGetVirtualFrameSize(fh, AF_DEFAULT_TRACK, 1));

    // allocate a buffer for input data
    const unsigned int buffer_frames = (8 * 1024);
    sample_storage_t *buffer =
        static_cast<sample_storage_t *>(malloc(buffer_frames * frame_size));
    Q_ASSERT(buffer);
    if (!buffer) return false;

    // read in from the audiofile source
    const unsigned int tracks = Kwave::FileInfo(metaData()).tracks();
    sample_index_t rest = Kwave::FileInfo(metaData()).length();
    while (rest) {
        unsigned int frames = buffer_frames;
        if (frames > rest) frames = Kwave::toUint(rest);
        int buffer_used = afReadFrames(fh,
            AF_DEFAULT_TRACK, reinterpret_cast<char *>(buffer), frames);

        // break if eof reached
        if (buffer_used <= 0) break;
        rest -= buffer_used;

        // split into the tracks
        sample_storage_t *p = buffer;
        unsigned int count = buffer_used;
        while (count) {
            for (unsigned int track = 0; track < tracks; track++) {
                sample_storage_t s = *p++;

                // adjust precision
                if (SAMPLE_STORAGE_BITS != SAMPLE_BITS) {
                    s /= (1 << (SAMPLE_STORAGE_BITS - SAMPLE_BITS));
                }

                // the following cast is only necessary if
                // sample_t is not equal to a quint32
                *(dst[track]) << static_cast<sample_t>(s);
            }
            --count;
        }

        // abort if the user pressed cancel
        if (dst.isCanceled()) break;
    }

    // return with a valid Signal, even if the user pressed cancel !
    if (buffer) free(buffer);
    return true;
}

Here is the call graph for this function:

instance()

Kwave::Decoder * Kwave::AudiofileDecoder::instance ( )

virtual

Returns a new instance of the decoder

Implements Kwave::Decoder.

Definition at line 86 of file AudiofileDecoder.cpp.

{
    return new Kwave::AudiofileDecoder();
}

open()

bool Kwave::AudiofileDecoder::open ( QWidget *  widget, QIODevice &  source  )

virtual

Opens the source and decodes the header information.

Parameters

widget	a widget that can be used for displaying message boxes or dialogs
source	file or other source with a stream of bytes

Returns

true if succeeded, false on errors

Implements Kwave::Decoder.

Definition at line 92 of file AudiofileDecoder.cpp.

References Kwave::FileInfo::bits(), DBG, Kwave::TypesMap< IDX, DATA >::description(), Kwave::SampleFormat::Double, Kwave::MessageBox::error(), Kwave::SampleFormat::Float, Kwave::Compression::fromAudiofile(), Kwave::VirtualAudioFile::handle(), Kwave::INF_COMPRESSION, Kwave::INF_SAMPLE_FORMAT, Kwave::VirtualAudioFile::lastError(), Kwave::FileInfo::length(), m_source, m_src_adapter, Kwave::Decoder::metaData(), Kwave::VirtualAudioFile::open(), Kwave::FileInfo::rate(), Kwave::MetaDataList::replace(), SAMPLE_STORAGE_BITS, Kwave::FileInfo::set(), Kwave::FileInfo::setBits(), Kwave::FileInfo::setLength(), Kwave::FileInfo::setRate(), Kwave::FileInfo::setTracks(), Kwave::SampleFormat::Signed, Kwave::Compression::toInt(), Kwave::toInt(), Kwave::FileInfo::tracks(), Kwave::SampleFormat::Unknown, and Kwave::SampleFormat::Unsigned.

{
    metaData().clear();
    Q_ASSERT(!m_source);
    if (m_source) qWarning("AudiofileDecoder::open(), already open !");

    // try to open the source
    if (!src.open(QIODevice::ReadOnly)) {
        qWarning("AudiofileDecoder::open(), failed to open source !");
        return false;
    }

    // source successfully opened
    m_source = &src;
    m_src_adapter = new Kwave::VirtualAudioFile(*m_source);

    Q_ASSERT(m_src_adapter);
    if (!m_src_adapter) return false;

    m_src_adapter->open(m_src_adapter, Q_NULLPTR);

    AFfilehandle fh = m_src_adapter->handle();
    if (!fh || (m_src_adapter->lastError() >= 0)) {
        QString reason;

        switch (m_src_adapter->lastError()) {
            case AF_BAD_NOT_IMPLEMENTED:
                reason = i18n("Format or function is not implemented");
                break;
            case AF_BAD_MALLOC:
                reason = i18n("Out of memory");
                break;
            case AF_BAD_HEADER:
                reason = i18n("File header is damaged");
                break;
            case AF_BAD_CODEC_TYPE:
                reason = i18n("Invalid codec type");
                break;
            case AF_BAD_OPEN:
                reason = i18n("Opening the file failed");
                break;
            case AF_BAD_READ:
                reason = i18n("Read access failed");
                break;
            case AF_BAD_SAMPFMT:
                reason = i18n("Invalid sample format");
                break;
            default:
                reason = reason.number(m_src_adapter->lastError());
        }

        QString text= i18n("An error occurred while opening the "\
            "file:\n'%1'", reason);
        Kwave::MessageBox::error(widget, text);

        return false;
    }

    AFframecount length = afGetFrameCount(fh, AF_DEFAULT_TRACK);
    unsigned int tracks = qMax(afGetVirtualChannels(fh, AF_DEFAULT_TRACK), 0);
    unsigned int bits = 0;
    double       rate = 0.0;
    int af_sample_format;
    afGetVirtualSampleFormat(fh, AF_DEFAULT_TRACK, &af_sample_format,
        reinterpret_cast<int *>(&bits));
    Kwave::SampleFormat::Format fmt;
    switch (af_sample_format)
    {
        case AF_SAMPFMT_TWOSCOMP:
            fmt = Kwave::SampleFormat::Signed;
            break;
        case AF_SAMPFMT_UNSIGNED:
            fmt = Kwave::SampleFormat::Unsigned;
            break;
        case AF_SAMPFMT_FLOAT:
            fmt = Kwave::SampleFormat::Float;
            break;
        case AF_SAMPFMT_DOUBLE:
            fmt = Kwave::SampleFormat::Double;
            break;
        default:
            fmt = Kwave::SampleFormat::Unknown;
            break;
    }

    // get sample rate, with fallback to 8kHz
    rate = afGetRate(fh, AF_DEFAULT_TRACK);
    if (rate < 1.0) {
        qWarning("\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"\
                 "WARNING: file has no sample rate!\n"\
                 "         => using 8000 samples/sec as fallback\n"\
                 "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
        rate = 8000.0;
    }

    Kwave::SampleFormat::Map sf;
    QString sample_format_name = sf.description(Kwave::SampleFormat(fmt), true);

    if (static_cast<signed int>(bits) < 0) bits = 0;

    int af_compression = afGetCompression(fh, AF_DEFAULT_TRACK);
    const Kwave::Compression compression(
        Kwave::Compression::fromAudiofile(af_compression)
    );

    Kwave::FileInfo info(metaData());
    info.setRate(rate);
    info.setBits(bits);
    info.setTracks(tracks);
    info.setLength(length);
    info.set(INF_SAMPLE_FORMAT, Kwave::SampleFormat(fmt).toInt());
    info.set(Kwave::INF_COMPRESSION, compression.toInt());
    metaData().replace(Kwave::MetaDataList(info));
    qDebug("-------------------------");
    qDebug("info:");
    qDebug("compression = %d", af_compression);
    qDebug("channels    = %d", info.tracks());
    qDebug("rate        = %0.0f", info.rate());
    qDebug("bits/sample = %d", info.bits());
    qDebug("length      = %lu samples",
           static_cast<unsigned long int>(info.length()));
    qDebug("format      = %d (%s)", af_sample_format,
                                    DBG(sample_format_name));
    qDebug("-------------------------");

    // set up libaudiofile to produce Kwave's internal sample format
#if Q_BYTE_ORDER == Q_BIG_ENDIAN
    afSetVirtualByteOrder(fh, AF_DEFAULT_TRACK, AF_BYTEORDER_BIGENDIAN);
#else
    afSetVirtualByteOrder(fh, AF_DEFAULT_TRACK, AF_BYTEORDER_LITTLEENDIAN);
#endif
    afSetVirtualSampleFormat(fh, AF_DEFAULT_TRACK,
        AF_SAMPFMT_TWOSCOMP, SAMPLE_STORAGE_BITS);

    return true;
}

Here is the call graph for this function:

Member Data Documentation

m_source

QIODevice* Kwave::AudiofileDecoder::m_source

private

source of the audio data

Definition at line 71 of file AudiofileDecoder.h.

Referenced by close(), decode(), open(), and ~AudiofileDecoder().

m_src_adapter

Kwave::VirtualAudioFile* Kwave::AudiofileDecoder::m_src_adapter

private

adapter for libaudiofile

Definition at line 74 of file AudiofileDecoder.h.

Referenced by close(), decode(), open(), and ~AudiofileDecoder().

---

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

• plugins/codec_audiofile/AudiofileDecoder.h
• plugins/codec_audiofile/AudiofileDecoder.cpp