Kwave::VorbisDecoder Class Reference

#include <VorbisDecoder.h>

Inheritance diagram for Kwave::VorbisDecoder:

Collaboration diagram for Kwave::VorbisDecoder:

Public Member Functions
	VorbisDecoder (QIODevice *source, ogg_sync_state &oy, ogg_stream_state &os, ogg_page &og, ogg_packet &op)
virtual	~VorbisDecoder () Q_DECL_OVERRIDE
virtual int	open (QWidget *widget, Kwave::FileInfo &info) Q_DECL_OVERRIDE
virtual int	decode (Kwave::MultiWriter &dst) Q_DECL_OVERRIDE
virtual void	reset () Q_DECL_OVERRIDE
virtual void	close (Kwave::FileInfo &info) Q_DECL_OVERRIDE
Public Member Functions inherited from Kwave::OggSubDecoder
virtual	~OggSubDecoder ()

Protected Member Functions
void	parseTag (Kwave::FileInfo &info, const char *tag, Kwave::FileProperty property)

Private Attributes
QIODevice *	m_source
qint64	m_stream_start_pos
sample_index_t	m_samples_written
ogg_sync_state &	m_oy
ogg_stream_state &	m_os
ogg_page &	m_og
ogg_packet &	m_op
vorbis_info	m_vi
vorbis_comment	m_vc
vorbis_dsp_state	m_vd
vorbis_block	m_vb

Detailed Description

Definition at line 36 of file VorbisDecoder.h.

Constructor & Destructor Documentation

VorbisDecoder()

Kwave::VorbisDecoder::VorbisDecoder ( QIODevice *  source, ogg_sync_state &  oy, ogg_stream_state &  os, ogg_page &  og, ogg_packet &  op  )

explicit

Constructor

Parameters

source	pointer to a QIODevice to read from, must not be null
oy	sync and verify incoming physical bitstream
os	take physical pages, weld into a logical stream of packets
og	one Ogg bitstream page, Vorbis packets are inside
op	one raw packet of data for decode

Definition at line 45 of file VorbisDecoder.cpp.

    :m_source(source), m_stream_start_pos(0), m_samples_written(0),
     m_oy(oy), m_os(os), m_og(og), m_op(op)
{
}

~VorbisDecoder()

virtual Kwave::VorbisDecoder::~VorbisDecoder ( )

inlinevirtual

destructor

Definition at line 55 of file VorbisDecoder.h.

References close(), decode(), open(), parseTag(), and reset().

{}

Here is the call graph for this function:

Member Function Documentation

close()

void Kwave::VorbisDecoder::close ( Kwave::FileInfo &  info )

virtual

finish the decoding, last chance to fix up some file info

Parameters

info	reference to a FileInfo to fill

Implements Kwave::OggSubDecoder.

Definition at line 307 of file VorbisDecoder.cpp.

References Kwave::FileInfo::contains(), DEFAULT_BITRATE, Kwave::INF_BITRATE_NOMINAL, Kwave::INF_VBR_QUALITY, Kwave::StandardBitrates::instance(), m_samples_written, m_source, m_stream_start_pos, Kwave::StandardBitrates::nearest(), Kwave::FileInfo::rate(), Kwave::FileInfo::set(), Kwave::toInt(), and Kwave::toUint().

Referenced by ~VorbisDecoder().

{
    if (!info.contains(Kwave::INF_BITRATE_NOMINAL) &&
        !info.contains(Kwave::INF_VBR_QUALITY))
    {
        qWarning("file contains neither nominal bitrate (ABR mode) "
                 "nor quality (VBR mode)");

        int bitrate = DEFAULT_BITRATE;

        if (Kwave::toInt(info.rate()) && m_samples_written) {
            // guess bitrates from the stream
            const qint64 stream_end_pos = m_source->pos();
            const qint64 stream_read = stream_end_pos -
                                             m_stream_start_pos + 1;
            double bits = static_cast<double>(stream_read) * 8.0;
            double seconds = static_cast<double>(m_samples_written) /
                static_cast<double>(info.rate());
            bitrate = Kwave::toUint(bits / seconds);

            // round to nearest standard bitrate
            bitrate = Kwave::StandardBitrates::instance().nearest(bitrate);
            qDebug("-> using guessed bitrate %d bits/sec", bitrate);
        } else {
            // guessing not possible -> use default
            qDebug("-> using default %d kBits/sec", bitrate);
        }

        info.set(Kwave::INF_BITRATE_NOMINAL, QVariant(bitrate));
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

decode()

int Kwave::VorbisDecoder::decode ( Kwave::MultiWriter &  dst )

virtual

decode received ogg data

Parameters

dst	a MultiWriter to be used as sink

Returns

-1 if failed or >= 0 if succeeded

Implements Kwave::OggSubDecoder.

Definition at line 267 of file VorbisDecoder.cpp.

References decodeFrame(), Kwave::MultiWriter::last(), m_op, m_samples_written, m_vb, and m_vd.

Referenced by ~VorbisDecoder().

{
    // we have a packet.  Decode it
    float **pcm;
    int samples;

    // test for success!
    if (vorbis_synthesis(&m_vb, &m_op) == 0)
        vorbis_synthesis_blockin(&m_vd, &m_vb);

    // **pcm is a multichannel float vector. In stereo, for example,
    // pcm[0] is left, and pcm[1] is right.  samples is the size of
    // each channel.  Convert the float values (-1.<=range<=1.) to
    // whatever PCM format and write it out
    while ((samples = vorbis_synthesis_pcmout(&m_vd, &pcm)) > 0)
    {
        int bout = decodeFrame(pcm, samples, dst);

        // tell libvorbis how many samples we
        // actually consumed
        vorbis_synthesis_read(&m_vd, bout);
    }

    m_samples_written = dst.last();
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

open()

int Kwave::VorbisDecoder::open ( QWidget *  widget, Kwave::FileInfo &  info  )

virtual

parse the header of the stream and initialize the decoder

Parameters

widget	a QWidget to be used as parent for error messages
info	reference to a FileInfo to fill

Returns

-1 if failed or +1 if succeeded

convert the date property to a QDate

Implements Kwave::OggSubDecoder.

Definition at line 73 of file VorbisDecoder.cpp.

References _, Kwave::FileInfo::contains(), DEFAULT_BITRATE, Kwave::MessageBox::error(), Kwave::FileInfo::get(), Kwave::INF_ALBUM, Kwave::INF_AUTHOR, Kwave::INF_BITRATE_LOWER, Kwave::INF_BITRATE_NOMINAL, Kwave::INF_BITRATE_UPPER, Kwave::INF_COMPRESSION, Kwave::INF_CONTACT, Kwave::INF_COPYRIGHT, Kwave::INF_CREATION_DATE, Kwave::INF_ESTIMATED_LENGTH, Kwave::INF_GENRE, Kwave::INF_ISRC, Kwave::INF_LICENSE, Kwave::INF_NAME, Kwave::INF_ORGANIZATION, Kwave::INF_PERFORMER, Kwave::INF_SOFTWARE, Kwave::INF_SOURCE, Kwave::INF_SUBJECT, Kwave::INF_TRACK, Kwave::INF_VBR_QUALITY, Kwave::INF_VERSION, m_og, m_op, m_os, m_oy, m_source, m_stream_start_pos, m_vb, m_vc, m_vd, m_vi, Kwave::Compression::OGG_VORBIS, parseTag(), Kwave::FileInfo::set(), Kwave::FileInfo::setRate(), Kwave::FileInfo::setTracks(), and Kwave::toInt().

Referenced by ~VorbisDecoder().

{
    // extract the initial header from the first page and verify that the
    // Ogg bitstream is in fact Vorbis data

    // I handle the initial header first instead of just having the code
    // read all three Vorbis headers at once because reading the initial
    // header is an easy way to identify a Vorbis bitstream and it's
    // useful to see that functionality separated out.
    vorbis_info_init(&m_vi);
    vorbis_comment_init(&m_vc);

    if (vorbis_synthesis_headerin(&m_vi, &m_vc, &m_op) < 0) {
        // error case; not a vorbis header
        Kwave::MessageBox::error(widget, i18n(
            "This Ogg bitstream does not contain any Vorbis audio data."));
        return -1;
    }

    // At this point, we're sure we're Vorbis.  We've set up the logical
    // (Ogg) bitstream decoder.  Get the comment and codebook headers and
    // set up the Vorbis decoder

    // The next two packets in order are the comment and codebook headers.
    // They're likely large and may span multiple pages.  Thus we read
    // and submit data until we get our two packets, watching that no
    // pages are missing.  If a page is missing, error out; losing a
    // header page is the only place where missing data is fatal. */
    unsigned int counter = 0;
    while (counter < 2) {
        while(counter < 2) {
            int result = ogg_sync_pageout(&m_oy, &m_og);
            if (result == 0) break; // Need more data
            // Don't complain about missing or corrupt data yet.  We'll
            // catch it at the packet output phase
            if (result == 1) {
                // we can ignore any errors here
                // as they'll also become apparent
                // at packetout
                ogg_stream_pagein(&m_os, &m_og);
                while (counter < 2) {
                    result = ogg_stream_packetout(&m_os, &m_op);
                    if (result == 0) break;
                    if (result < 0) {
                        // Uh oh; data at some point was corrupted or
                        // missing! We can't tolerate that in a header.
                        // Die.
                        Kwave::MessageBox::error(widget, i18n(
                            "Corrupt secondary header. Exiting."));
                        return -1;
                    }
                    vorbis_synthesis_headerin(&m_vi, &m_vc, &m_op);
                    counter++;
                }
            }
        }

        // no harm in not checking before adding more
        char *buffer = ogg_sync_buffer(&m_oy, 4096);
        qint64 bytes = m_source->read(buffer, 4096);
        if (!bytes && counter < 2) {
            Kwave::MessageBox::error(widget, i18n(
                "End of file before finding all Vorbis headers."));
            return -1;
        }
        ogg_sync_wrote(&m_oy, static_cast<long int>(bytes));
    }

    // OK, got and parsed all three headers. Initialize the Vorbis
    // packet->PCM decoder. */
    vorbis_synthesis_init(&m_vd, &m_vi); // central decode state
    vorbis_block_init(&m_vd, &m_vb); // local state for most of the decode
                                     // so multiple block decodes can
                                     // proceed in parallel.  We could init
                                     // multiple vorbis_block structures
                                     // for m_vd here

    // get the standard properties
    info.setTracks(m_vi.channels);
    info.setRate(m_vi.rate);
    info.set(Kwave::INF_COMPRESSION, Kwave::Compression::OGG_VORBIS);
    info.set(Kwave::INF_SOURCE, _(m_vc.vendor));
    if ((m_vi.bitrate_nominal > 0) &&
        (m_vi.bitrate_nominal < std::numeric_limits<int>::max()))
        info.set(Kwave::INF_BITRATE_NOMINAL,
        QVariant(Kwave::toInt(m_vi.bitrate_nominal)));
    if ((m_vi.bitrate_lower > 0) &&
        (m_vi.bitrate_lower < std::numeric_limits<int>::max()))
        info.set(Kwave::INF_BITRATE_LOWER,
        QVariant(Kwave::toInt(m_vi.bitrate_lower)));
    if ((m_vi.bitrate_upper > 0) &&
        (m_vi.bitrate_upper < std::numeric_limits<int>::max()))
        info.set(Kwave::INF_BITRATE_UPPER,
        QVariant(Kwave::toInt(m_vi.bitrate_upper)));

    // the first comment sometimes is used for the software version
    {
        char **ptr = m_vc.user_comments;
        QString s = _(*ptr);
        if (s.length() && !s.contains(QLatin1Char('='))) {
            info.set(Kwave::INF_SOFTWARE, s);
            qDebug("Bitstream is %d channel, %ldHz", m_vi.channels, m_vi.rate);
            qDebug("Encoded by: %s\n\n", m_vc.vendor);
        }
    }

    parseTag(info, "DATE",         Kwave::INF_CREATION_DATE);
    if (info.contains(Kwave::INF_CREATION_DATE)) {
        QString str_date  = QVariant(info.get(
            Kwave::INF_CREATION_DATE)).toString();
        QDate date;
        date = QDate::fromString(str_date, Qt::ISODate);
        if (!date.isValid()) {
            int year = str_date.toInt();
            date.setDate(year, 1, 1);
        }
        if (date.isValid()) info.set(Kwave::INF_CREATION_DATE, date);
    }

    // parse all other (simple) properties
    parseTag(info, "TITLE",        Kwave::INF_NAME);
    parseTag(info, "VERSION",      Kwave::INF_VERSION);
    parseTag(info, "ALBUM",        Kwave::INF_ALBUM);
    parseTag(info, "TRACKNUMBER",  Kwave::INF_TRACK);
    parseTag(info, "ARTIST",       Kwave::INF_AUTHOR);
    parseTag(info, "PERFORMER",    Kwave::INF_PERFORMER);
    parseTag(info, "COPYRIGHT",    Kwave::INF_COPYRIGHT);
    parseTag(info, "LICENSE",      Kwave::INF_LICENSE);
    parseTag(info, "ORGANIZATION", Kwave::INF_ORGANIZATION);
    parseTag(info, "DESCRIPTION",  Kwave::INF_SUBJECT);
    parseTag(info, "GENRE",        Kwave::INF_GENRE);
    parseTag(info, "LOCATION",     Kwave::INF_SOURCE);
    parseTag(info, "CONTACT",      Kwave::INF_CONTACT);
    parseTag(info, "ISRC",         Kwave::INF_ISRC);
    parseTag(info, "ENCODER",      Kwave::INF_SOFTWARE);
    parseTag(info, "VBR_QUALITY",  Kwave::INF_VBR_QUALITY);

    // estimate a length
    // estimate the length of the file from file size, bitrate, channels
    if (!m_source->isSequential()) {
        long int br = -1;
        if (            (m_vi.bitrate_nominal > 0)) br = m_vi.bitrate_nominal;
        if ((br < 0) && (m_vi.bitrate_upper   > 0)) br = m_vi.bitrate_upper;
        if ((br < 0) && (m_vi.bitrate_lower   > 0)) br = m_vi.bitrate_lower;
        qint64 file_size       = m_source->size();
        qreal rate             = m_vi.rate;
        qreal seconds          = (br > 0) ? (file_size / (br / 8)) :
                                             DEFAULT_BITRATE;
        sample_index_t samples = static_cast<sample_index_t>(seconds * rate);

        qDebug("    estimated length: %llu samples", samples);
        info.set(Kwave::INF_ESTIMATED_LENGTH, samples);
    }

    m_stream_start_pos = m_source->pos();

    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parseTag()

void Kwave::VorbisDecoder::parseTag ( Kwave::FileInfo &  info, const char *  tag, Kwave::FileProperty  property  )

protected

Searches for a vorbis comment and renders it into Kwave's FileInfo. If more than one occurrence is found, they are concatenated as a semicolon separated list.

Parameters

info	the file info object to add the tag value
tag	name of the field to search for
property	specifies the FileProperty for storing the result

Definition at line 57 of file VorbisDecoder.cpp.

References _, m_vc, and Kwave::FileInfo::set().

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

{
    int count = vorbis_comment_query_count(&m_vc, const_cast<char *>(tag));
    if (count < 1) return;
    QString value;
    for (int i = 0; i < count; ++i) {
        char *text = vorbis_comment_query(&m_vc, const_cast<char *>(tag), i);
        if (i) value += _("; ");
        value += QString::fromUtf8(text);
    }

    info.set(property, value);
}

Here is the call graph for this function:

Here is the caller graph for this function:

reset()

void Kwave::VorbisDecoder::reset ( )

virtual

reset the stream info

Implements Kwave::OggSubDecoder.

Definition at line 295 of file VorbisDecoder.cpp.

References m_vb, m_vc, m_vd, and m_vi.

Referenced by ~VorbisDecoder().

{
    // ogg_page and ogg_packet structs always point to storage in
    // libvorbis.  They're never freed or manipulated directly

    vorbis_block_clear(&m_vb);
    vorbis_dsp_clear(&m_vd);
    vorbis_comment_clear(&m_vc);
    vorbis_info_clear(&m_vi);  // must be called last
}

Here is the caller graph for this function:

Member Data Documentation

m_og

ogg_page& Kwave::VorbisDecoder::m_og

private

one Ogg bitstream page. Vorbis packets are inside

Definition at line 111 of file VorbisDecoder.h.

Referenced by open().

m_op

ogg_packet& Kwave::VorbisDecoder::m_op

private

one raw packet of data for decode

Definition at line 114 of file VorbisDecoder.h.

Referenced by decode(), and open().

m_os

ogg_stream_state& Kwave::VorbisDecoder::m_os

private

take physical pages, weld into a logical stream of packets

Definition at line 108 of file VorbisDecoder.h.

Referenced by open().

m_oy

ogg_sync_state& Kwave::VorbisDecoder::m_oy

private

sync and verify incoming physical bitstream

Definition at line 105 of file VorbisDecoder.h.

Referenced by open().

m_samples_written

sample_index_t Kwave::VorbisDecoder::m_samples_written

private

last known position in the output stream [samples]

Definition at line 102 of file VorbisDecoder.h.

Referenced by close(), and decode().

m_source

QIODevice* Kwave::VorbisDecoder::m_source

private

IO device to read from

Definition at line 96 of file VorbisDecoder.h.

Referenced by close(), and open().

m_stream_start_pos

qint64 Kwave::VorbisDecoder::m_stream_start_pos

private

first stream with audio data

Definition at line 99 of file VorbisDecoder.h.

Referenced by close(), and open().

m_vb

vorbis_block Kwave::VorbisDecoder::m_vb

private

local working space for packet->PCM decode

Definition at line 126 of file VorbisDecoder.h.

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

m_vc

vorbis_comment Kwave::VorbisDecoder::m_vc

private

struct that stores all the bitstream user comments

Definition at line 120 of file VorbisDecoder.h.

Referenced by open(), parseTag(), and reset().

m_vd

vorbis_dsp_state Kwave::VorbisDecoder::m_vd

private

central working state for the packet->PCM decoder

Definition at line 123 of file VorbisDecoder.h.

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

m_vi

vorbis_info Kwave::VorbisDecoder::m_vi

private

struct that stores all the static vorbis bitstream settings

Definition at line 117 of file VorbisDecoder.h.

Referenced by open(), and reset().

---

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

• plugins/codec_ogg/VorbisDecoder.h
• plugins/codec_ogg/VorbisDecoder.cpp