Kwave::OggDecoder Class Reference

#include <OggDecoder.h>

Inheritance diagram for Kwave::OggDecoder:

Collaboration diagram for Kwave::OggDecoder:

Public Member Functions
	OggDecoder ()
virtual	~OggDecoder () 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)

Protected Member Functions
int	parseHeader (QWidget *widget)

Private Attributes
Kwave::OggSubDecoder *	m_sub_decoder
QIODevice *	m_source
ogg_sync_state	m_oy
ogg_stream_state	m_os
ogg_page	m_og
ogg_packet	m_op

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 32 of file OggDecoder.h.

Constructor & Destructor Documentation

OggDecoder()

Kwave::OggDecoder::OggDecoder

(

)

Constructor

Definition at line 44 of file OggDecoder.cpp.

References Kwave::CodecBase::addMimeType(), REGISTER_COMPRESSION_TYPE_OGG_OPUS, REGISTER_COMPRESSION_TYPE_OGG_VORBIS, REGISTER_OGG_OPUS_MIME_TYPES, and REGISTER_OGG_VORBIS_MIME_TYPES.

    :Kwave::Decoder(), m_sub_decoder(Q_NULLPTR), m_source(Q_NULLPTR)
{
#ifdef HAVE_OGG_OPUS
    REGISTER_OGG_OPUS_MIME_TYPES
    REGISTER_COMPRESSION_TYPE_OGG_OPUS
#endif /* HAVE_OGG_OPUS */

#ifdef HAVE_OGG_VORBIS
    REGISTER_OGG_VORBIS_MIME_TYPES
    REGISTER_COMPRESSION_TYPE_OGG_VORBIS
#endif /* HAVE_OGG_VORBIS */

    /* Ogg audio, as per RFC5334 */
    addMimeType("audio/ogg",         i18n("Ogg audio"),        "*.oga");
    addMimeType("application/ogg",   i18n("Ogg audio"),        "*.ogx");

}

Here is the call graph for this function:

~OggDecoder()

Kwave::OggDecoder::~OggDecoder ( )

virtual

Destructor

Definition at line 64 of file OggDecoder.cpp.

References close(), and m_source.

{
    if (m_source) close();
}

Here is the call graph for this function:

Member Function Documentation

close()

void Kwave::OggDecoder::close ( )

virtual

Closes the source.

Implements Kwave::Decoder.

Definition at line 275 of file OggDecoder.cpp.

References m_source, and m_sub_decoder.

Referenced by ~OggDecoder().

{
    m_source = Q_NULLPTR;
    delete m_sub_decoder;
    m_sub_decoder = Q_NULLPTR;
}

Here is the caller graph for this function:

decode()

bool Kwave::OggDecoder::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 200 of file OggDecoder.cpp.

References Kwave::OggSubDecoder::close(), Kwave::OggSubDecoder::decode(), Kwave::MessageBox::error(), Kwave::MultiWriter::isCanceled(), m_og, m_op, m_os, m_oy, m_source, m_sub_decoder, Kwave::Decoder::metaData(), parseHeader(), Kwave::MetaDataList::replace(), Kwave::OggSubDecoder::reset(), Kwave::Decoder::sourceProcessed(), and Kwave::toInt().

{
    int eos = 0;

    Q_ASSERT(m_source);
    Q_ASSERT(m_sub_decoder);
    if (!m_source || !m_sub_decoder) return false;

    // we repeat if the bitstream is chained
    while (!dst.isCanceled()) {
        // The rest is just a straight decode loop until end of stream
        while (!eos) {
            while (!eos) {
                int result = ogg_sync_pageout(&m_oy, &m_og);
                if (result == 0) break; // need more data
                if (result < 0) {
                    // missing or corrupt data at this page position
                    Kwave::MessageBox::error(widget, i18n(
                        "Corrupt or missing data in bitstream. Continuing."
                        ));
                } else {
                    // can safely ignore errors at this point
                    ogg_stream_pagein(&m_os, &m_og);
                    while (1) {
                        result = ogg_stream_packetout(&m_os, &m_op);

                        if (result == 0) break; // need more data
                        if (result < 0) {
                            // missing or corrupt data at this page position
                            // no reason to complain; already complained above
                        } else {
                            result = m_sub_decoder->decode(dst);
                            if (result < 0)
                                break;

                            // signal the current position
                            emit sourceProcessed(m_source->pos());
                        }
                    }
                    if (ogg_page_eos(&m_og) || dst.isCanceled()) eos = 1;
                }
            }

            if (!eos) {
                char *buffer = ogg_sync_buffer(&m_oy, 4096);
                int bytes = Kwave::toInt(m_source->read(buffer, 4096));
                ogg_sync_wrote(&m_oy, bytes);
                if (!bytes) eos = 1;
            }
        }

        // clean up this logical bitstream; before exit we see if we're
        // followed by another [chained]
        ogg_stream_clear(&m_os);
        m_sub_decoder->reset();

        // parse the next header, maybe we parse a stream or chain...
        if (eos || (parseHeader(widget) < 1)) break;
    }

    // OK, clean up the framer
    ogg_sync_clear(&m_oy);

    // signal the current position
    emit sourceProcessed(m_source->pos());

    Kwave::FileInfo info(metaData());
    m_sub_decoder->close(info);
    metaData().replace(Kwave::MetaDataList(info));

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

Here is the call graph for this function:

instance()

Kwave::Decoder * Kwave::OggDecoder::instance ( )

virtual

Returns a new instance of the decoder

Implements Kwave::Decoder.

Definition at line 70 of file OggDecoder.cpp.

{
    return new Kwave::OggDecoder();
}

open()

bool Kwave::OggDecoder::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 173 of file OggDecoder.cpp.

References m_oy, m_source, Kwave::Decoder::metaData(), and parseHeader().

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

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

    // take over the source
    m_source = &src;

    /********** Decode setup ************/
    qDebug("--- OggDecoder::open() ---");
    ogg_sync_init(&m_oy); // Now we can read pages

    // read the header the first time
    if (parseHeader(widget) < 0)
        return false;

    return true;
}

Here is the call graph for this function:

parseHeader()

int Kwave::OggDecoder::parseHeader ( QWidget *  widget )

protected

Try to parse header frames.

Parameters

widget

a QWidget for displaying error messages

Returns

-1 for error (return false) 1 if ready to continue

Definition at line 76 of file OggDecoder.cpp.

References _, Kwave::MessageBox::error(), Kwave::INF_MIMETYPE, m_og, m_op, m_os, m_oy, m_source, m_sub_decoder, Kwave::Decoder::metaData(), Kwave::OggSubDecoder::open(), Kwave::MetaDataList::replace(), SAMPLE_BITS, Kwave::FileInfo::set(), Kwave::FileInfo::setBits(), and Kwave::FileInfo::setLength().

Referenced by decode(), and open().

{
    // grab some data at the head of the stream.  We want the first page
    // (which is guaranteed to be small and only contain the Vorbis
    // stream initial header) We need the first page to get the stream
    // serialno.

    // submit a 4k block to libvorbis' Ogg layer
    char *buffer = ogg_sync_buffer(&m_oy, 4096);
    Q_ASSERT(buffer);
    if (!buffer) return -1;

    long int bytes = static_cast<long int>(m_source->read(buffer, 4096));
    if ((bytes <= 0) && (!m_source->pos())) {
        Kwave::MessageBox::error(widget, i18n(
            "Ogg bitstream has zero-length."));
        return -1;
    }
    ogg_sync_wrote(&m_oy, bytes);

    // Get the first page.
    if (ogg_sync_pageout(&m_oy, &m_og) != 1) {
        // have we simply run out of data?  If so, we're done.
        if (bytes < 4096) return 0;

        // error case. seems not be Vorbis data
        Kwave::MessageBox::error(widget, i18n(
             "Input does not appear to be an Ogg bitstream."));
        return -1;
    }

    // Get the serial number and set up the rest of decode.
    // serialno first; use it to set up a logical stream
    ogg_stream_init(&m_os, ogg_page_serialno(&m_og));

    // get the first packet
    if (ogg_stream_pagein(&m_os, &m_og) < 0) {
        // error; stream version mismatch perhaps
        Kwave::MessageBox::error(widget, i18n(
            "Error reading first page of the Ogg bitstream data."));
        return -1;
    }

    if ((ogg_stream_packetout(&m_os, &m_op) != 1) || (m_op.bytes < 8)) {
        // no page? must not be vorbis
        Kwave::MessageBox::error(widget, i18n(
            "Error reading initial header packet."));
        return -1;
    }

    // get rid of the previous sub decoder
    if (m_sub_decoder) {
        delete m_sub_decoder;
        m_sub_decoder = Q_NULLPTR;
    }

    Kwave::FileInfo info(metaData());

    // ---------------------------------
    // auto-detect the sub decoder
#ifdef HAVE_OGG_OPUS
    if (memcmp(m_op.packet, "OpusHead", 8) == 0) {
        qDebug("    OggDecoder: detected Opus codec");
        m_sub_decoder =
            new Kwave::OpusDecoder(m_source, m_oy, m_os, m_og, m_op);
        info.set(Kwave::INF_MIMETYPE, _("audio/opus"));
    }
#endif /* HAVE_OGG_OPUS */
#ifdef HAVE_OGG_VORBIS
    if (memcmp(m_op.packet + 1, "vorbis", 6) == 0) {
        qDebug("    OggDecoder: detected Vorbis codec");
        m_sub_decoder =
            new Kwave::VorbisDecoder(m_source, m_oy, m_os, m_og, m_op);
        info.set(Kwave::INF_MIMETYPE, _("audio/x-vorbis+ogg"));
    }
#endif /* HAVE_OGG_VORBIS */

    if (!m_sub_decoder) {
        qDebug("--- dump of the first 8 bytes of the packet: ---");
        for (unsigned int i = 0; i < 8; i++)
            qDebug("%2d: 0x%02X - '%c'", i, m_op.packet[i], m_op.packet[i]);

        Kwave::MessageBox::error(widget, i18n(
            "Error: Codec not supported"));
        return -1;
    }

    info.setLength(0);         // use streaming
    info.setBits(SAMPLE_BITS); // use Kwave's internal resolution
    if (m_sub_decoder->open(widget, info) < 0)
        return -1;

    metaData().replace(Kwave::MetaDataList(info));
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_og

ogg_page Kwave::OggDecoder::m_og

private

one Ogg bitstream page. Vorbis packets are inside

Definition at line 93 of file OggDecoder.h.

Referenced by decode(), and parseHeader().

m_op

ogg_packet Kwave::OggDecoder::m_op

private

one raw packet of data for decode

Definition at line 96 of file OggDecoder.h.

Referenced by decode(), and parseHeader().

m_os

ogg_stream_state Kwave::OggDecoder::m_os

private

take physical pages, weld into a logical stream of packets

Definition at line 90 of file OggDecoder.h.

Referenced by decode(), and parseHeader().

m_oy

ogg_sync_state Kwave::OggDecoder::m_oy

private

sync and verify incoming physical bitstream

Definition at line 87 of file OggDecoder.h.

Referenced by decode(), open(), and parseHeader().

m_source

QIODevice* Kwave::OggDecoder::m_source

private

source of the audio data

Definition at line 84 of file OggDecoder.h.

Referenced by close(), decode(), open(), parseHeader(), and ~OggDecoder().

m_sub_decoder

Kwave::OggSubDecoder* Kwave::OggDecoder::m_sub_decoder

private

sub decoder, can be Vorbis, Opus, Speex or whatever...

Definition at line 81 of file OggDecoder.h.

Referenced by close(), decode(), and parseHeader().

---

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

• plugins/codec_ogg/OggDecoder.h
• plugins/codec_ogg/OggDecoder.cpp