Kwave::VorbisEncoder Class Reference

#include <VorbisEncoder.h>

Inheritance diagram for Kwave::VorbisEncoder:

Collaboration diagram for Kwave::VorbisEncoder:

Public Member Functions
	VorbisEncoder ()
virtual	~VorbisEncoder () Q_DECL_OVERRIDE
virtual bool	open (QWidget *widget, const Kwave::FileInfo &info, Kwave::MultiTrackReader &src) Q_DECL_OVERRIDE
virtual bool	writeHeader (QIODevice &dst) Q_DECL_OVERRIDE
virtual bool	encode (Kwave::MultiTrackReader &src, QIODevice &dst) Q_DECL_OVERRIDE
virtual void	close () Q_DECL_OVERRIDE
Public Member Functions inherited from Kwave::OggSubEncoder
virtual	~OggSubEncoder ()

Private Member Functions
void	encodeProperties (const Kwave::FileInfo &info)

Private Attributes
Kwave::VorbisCommentMap	m_comments_map
Kwave::FileInfo	m_info
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 39 of file VorbisEncoder.h.

Constructor & Destructor Documentation

VorbisEncoder()

Kwave::VorbisEncoder::VorbisEncoder

(

)

Constructor

Definition at line 43 of file VorbisEncoder.cpp.

References m_og, m_op, m_os, m_vb, m_vc, m_vd, and m_vi.

    :m_comments_map(), m_info()
{
    memset(&m_os, 0x00, sizeof(m_os));
    memset(&m_og, 0x00, sizeof(m_og));
    memset(&m_op, 0x00, sizeof(m_op));

    memset(&m_vb, 0x00, sizeof(m_vb));
    memset(&m_vc, 0x00, sizeof(m_vc));
    memset(&m_vd, 0x00, sizeof(m_vd));
    memset(&m_vi, 0x00, sizeof(m_vi));
}

~VorbisEncoder()

Kwave::VorbisEncoder::~VorbisEncoder ( )

virtual

Destructor

Definition at line 57 of file VorbisEncoder.cpp.

References close().

{
    close();
}

Here is the call graph for this function:

Member Function Documentation

close()

void Kwave::VorbisEncoder::close ( )

virtual

finished the encoding, clean up

Implements Kwave::OggSubEncoder.

Definition at line 310 of file VorbisEncoder.cpp.

References m_os, m_vb, m_vc, m_vd, and m_vi.

Referenced by ~VorbisEncoder().

{
    ogg_stream_clear(&m_os);

    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:

encode()

bool Kwave::VorbisEncoder::encode ( Kwave::MultiTrackReader &  src, QIODevice &  dst  )

virtual

encode received ogg data

Parameters

src	MultiTrackReader used as source of the audio data
dst	a QIODevice that receives the raw data

Returns

true if succeeded, false if failed

Implements Kwave::OggSubEncoder.

Definition at line 229 of file VorbisEncoder.cpp.

References BUFFER_SIZE, Kwave::SampleArray::constData(), Kwave::MultiTrackReader::eof(), Kwave::MultiTrackReader::isCanceled(), Kwave::FileInfo::length(), m_info, m_og, m_op, m_os, m_vb, m_vd, sample2float(), Kwave::toUint(), and Kwave::FileInfo::tracks().

{
    bool                 eos    = false;
    const unsigned int   tracks = m_info.tracks();
    const sample_index_t length = m_info.length();

    sample_index_t rest = length;
    while (!eos && !src.isCanceled()) {
        if (src.eof()) {
            // end of file.  this can be done implicitly in the mainline,
            // but it's easier to see here in non-clever fashion.
            // Tell the library we're at end of stream so that it can handle
            // the last frame and mark end of stream in the output properly
            vorbis_analysis_wrote(&m_vd, 0);
        } else {
            // data to encode

            // expose the buffer to submit data
            float **buffer = vorbis_analysis_buffer(&m_vd, BUFFER_SIZE);
            unsigned int pos = 0;
            unsigned int len = (rest > BUFFER_SIZE) ? BUFFER_SIZE :
                                                      Kwave::toUint(rest);
            Kwave::SampleArray samples(BUFFER_SIZE);
            for (unsigned int track = 0; track < tracks; ++track) {
                float *p = buffer[track];
                unsigned int l = src[track]->read(samples, 0, len);
                const sample_t *s = samples.constData();

                const unsigned int block = 8;
                pos = 0;
                while (pos + block < l) {
                    for (unsigned int i = 0; i < block; ++i, ++pos)
                        p[pos] = sample2float(s[pos]);
                }
                while (pos < l) {
                    p[pos] = sample2float(s[pos]);
                    pos++;
                }
                while (pos < len)
                    p[pos++] = 0;
            }

            // tell the library how much we actually submitted
            vorbis_analysis_wrote(&m_vd, pos);
        }

        // vorbis does some data preanalysis, then divvies up blocks for
        // more involved (potentially parallel) processing.  Get a single
        // block for encoding now
        while (vorbis_analysis_blockout(&m_vd, &m_vb) == 1) {
            // analysis, assume we want to use bitrate management
            vorbis_analysis(&m_vb, Q_NULLPTR);
            vorbis_bitrate_addblock(&m_vb);

            while (vorbis_bitrate_flushpacket(&m_vd, &m_op)) {
                // weld the packet into the bitstream
                ogg_stream_packetin(&m_os, &m_op);

                // write out pages (if any)
                while (!eos) {
                    int result = ogg_stream_pageout(&m_os, &m_og);
                    if (!result) break;
                    dst.write(reinterpret_cast<char*>(m_og.header),
                              m_og.header_len);
                    dst.write(reinterpret_cast<char *>(m_og.body),
                              m_og.body_len);

                    // this could be set above, but for illustrative
                    // purposes, I do it here (to show that vorbis
                    // does know where the stream ends)
                    if (ogg_page_eos(&m_og)) eos = true;
                }
            }
        }
    }

    return true;
}

Here is the call graph for this function:

encodeProperties()

void Kwave::VorbisEncoder::encodeProperties ( const Kwave::FileInfo &  info )

private

Encodes all file properties into a vorbis comment

Definition at line 63 of file VorbisEncoder.cpp.

References Kwave::FileInfo::contains(), Kwave::FileInfo::get(), m_comments_map, m_vc, and UTF8.

Referenced by open().

{
    foreach (const QString &key, m_comments_map.keys()) {
        Kwave::FileProperty property = m_comments_map[key];
        if (!info.contains(property)) continue; // skip if not present

        // encode the property as string
        vorbis_comment_add_tag(&m_vc,
            UTF8(key),
            UTF8(info.get(property).toString())
        );
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

open()

bool Kwave::VorbisEncoder::open ( QWidget *  widget, const Kwave::FileInfo &  info, Kwave::MultiTrackReader &  src  )

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
src	MultiTrackReader used as source of the audio data

Returns

true if succeeded, false if failed

Implements Kwave::OggSubEncoder.

Definition at line 78 of file VorbisEncoder.cpp.

References Kwave::FileInfo::contains(), DEFAULT_BITRATE, encodeProperties(), Kwave::FileInfo::get(), Kwave::INF_BITRATE_LOWER, Kwave::INF_BITRATE_NOMINAL, Kwave::INF_BITRATE_UPPER, Kwave::INF_VBR_QUALITY, m_info, m_os, m_vb, m_vc, m_vd, m_vi, Kwave::FileInfo::rate(), Kwave::MessageBox::sorry(), Kwave::toInt(), Kwave::FileInfo::tracks(), and Kwave::MessageBox::warningContinueCancel().

{
    int ret = -1;

    Q_UNUSED(src);

    // get info: tracks, sample rate, bitrate(s)
    m_info = info;
    const unsigned int tracks = info.tracks();
    const long int sample_rate = static_cast<const long int>(info.rate());

    if (tracks > 2) {
        Kwave::MessageBox::sorry(widget,
            i18n("This codec supports only mono or stereo files, "
                 "%1 channels are not supported.", tracks));
        return false;
    }

    // ABR bitrates
    int bitrate_nominal = info.contains(Kwave::INF_BITRATE_NOMINAL) ?
        QVariant(info.get(Kwave::INF_BITRATE_NOMINAL)).toInt() : -1;
    int bitrate_lower = info.contains(Kwave::INF_BITRATE_LOWER) ?
        QVariant(info.get(Kwave::INF_BITRATE_LOWER)).toInt() : -1;
    int bitrate_upper = info.contains(Kwave::INF_BITRATE_UPPER) ?
        QVariant(info.get(Kwave::INF_BITRATE_UPPER)).toInt() : -1;

    // VBR quality
    int vbr_quality = info.contains(Kwave::INF_VBR_QUALITY) ?
        QVariant(info.get(Kwave::INF_VBR_QUALITY)).toInt() : -1;

    qDebug("OggEncoder: ABR=%d...%d...%d Bits/s, VBR=%d%%",
           bitrate_lower,bitrate_nominal,bitrate_upper,vbr_quality);

    if ((vbr_quality < 0) && (bitrate_nominal <= 0)) {
        // no quality and no bitrate given -> complain !
        if (Kwave::MessageBox::warningContinueCancel(widget,
            i18n("You have not selected any bitrate for the encoding. "
                 "Do you want to continue and encode with %1 kBit/s "
                 "or cancel and choose a different bitrate?",
                 DEFAULT_BITRATE / 1000)) != KMessageBox::Continue)
            return false; // <- canceled

        bitrate_nominal = DEFAULT_BITRATE;
        bitrate_lower = -1;
        bitrate_upper = -1;
    }

    // some checks first
    Q_ASSERT(tracks < 255);
    if (tracks > 255) return false;

    /********** Encode setup ************/
    vorbis_info_init(&m_vi);

    if ((bitrate_lower > 0) || (bitrate_upper > 0)) {
        // Encoding using ABR mode.
        bitrate_nominal = (bitrate_upper + bitrate_lower) / 2;
        ret = vorbis_encode_init(&m_vi, tracks, sample_rate,
                                 bitrate_upper,
                                 bitrate_nominal,
                                 bitrate_lower);
        qDebug("VorbisEncoder: ABR with %d...%d...%d Bits/s",
               bitrate_lower, bitrate_nominal, bitrate_upper);
    } else if ((vbr_quality < 0) && (bitrate_nominal > 0)) {
        // Encoding using constant bitrate in ABR mode
        ret = vorbis_encode_setup_managed(&m_vi, tracks, sample_rate,
              -1, bitrate_nominal, -1);

        // If OV_ECTL_RATEMANAGE2_SET is not defined, then your
        // libvorbis is just too old.
        if (!ret) ret =
              vorbis_encode_ctl(&m_vi, OV_ECTL_RATEMANAGE2_SET, Q_NULLPTR) ||
              vorbis_encode_setup_init(&m_vi);

        qDebug("VorbisEncoder: CBR with %d Bits/s", bitrate_nominal);
    } else if (vbr_quality >= 0) {
        // Encoding using VBR mode.
        ret = vorbis_encode_init_vbr(&m_vi, tracks, sample_rate,
            static_cast<float>(vbr_quality) / 100.0f);
        qDebug("OggEncoder: VBR with %d%%", vbr_quality);
    } else {
        // unknown setup !?
        qWarning("unknown Ogg/Vorbis setup: VBR quality=%d%%, "
                 "ABR lower=%d, ABR highest=%d, ABR nominal=%d",
                 vbr_quality, bitrate_lower, bitrate_upper,
                 bitrate_nominal);
        return false;
    }

    /* do not continue if setup failed; this can happen if we ask for a
       mode that libVorbis does not support (eg, too low a bitrate, etc,
       will return 'OV_EIMPL') */
    if (ret) {
        Kwave::MessageBox::sorry(widget, i18n("One or more encoding "
            "parameters are not supported. Please change the "
            "settings and try again."));
        return false;
    }

    // add all supported properties as file comments
    vorbis_comment_init(&m_vc);
    encodeProperties(info);

    // set up the analysis state and auxiliary encoding storage
    vorbis_analysis_init(&m_vd, &m_vi);
    vorbis_block_init(&m_vd, &m_vb);


    // set up our packet->stream encoder
    // pick a random serial number; that way we can more likely build
    // chained streams just by concatenation
    qsrand(QTime::currentTime().msec() ^ qrand());
    ogg_stream_init(&m_os, qrand());

    return true;
}

Here is the call graph for this function:

writeHeader()

bool Kwave::VorbisEncoder::writeHeader ( QIODevice &  dst )

virtual

write the header information

Parameters

dst	a QIODevice that receives the raw data

Returns

true if succeeded, false if failed

Implements Kwave::OggSubEncoder.

Definition at line 197 of file VorbisEncoder.cpp.

References m_og, m_os, m_vc, and m_vd.

{
    // Vorbis streams begin with three headers; the initial header (with
    // most of the codec setup parameters) which is mandated by the Ogg
    // bitstream spec.  The second header holds any comment fields.  The
    // third header holds the bitstream codebook.  We merely need to
    // make the headers, then pass them to libvorbis one at a time;
    // libvorbis handles the additional Ogg bitstream constraints
    ogg_packet header;
    ogg_packet header_comm;
    ogg_packet header_code;

    vorbis_analysis_headerout(&m_vd, &m_vc, &header, &header_comm,
                              &header_code);
    // automatically placed in its own page
    ogg_stream_packetin(&m_os, &header);
    ogg_stream_packetin(&m_os, &header_comm);
    ogg_stream_packetin(&m_os, &header_code);

    // This ensures the actual audio data will start on a
    // new page, as per spec
    while (ogg_stream_flush(&m_os, &m_og)) {
        dst.write(reinterpret_cast<char *>(m_og.header),
                  m_og.header_len);
        dst.write(reinterpret_cast<char *>(m_og.body),
                  m_og.body_len);
    }

    return true;
}

Member Data Documentation

m_comments_map

Kwave::VorbisCommentMap Kwave::VorbisEncoder::m_comments_map

private

map for translating Vorbis comments to Kwave FileInfo

Definition at line 91 of file VorbisEncoder.h.

Referenced by encodeProperties().

m_info

Kwave::FileInfo Kwave::VorbisEncoder::m_info

private

file info, set in open(...)

Definition at line 94 of file VorbisEncoder.h.

Referenced by encode(), and open().

m_og

ogg_page Kwave::VorbisEncoder::m_og

private

one Ogg bitstream page. Vorbis packets are inside

Definition at line 100 of file VorbisEncoder.h.

Referenced by encode(), VorbisEncoder(), and writeHeader().

m_op

ogg_packet Kwave::VorbisEncoder::m_op

private

one raw packet of data for decode

Definition at line 103 of file VorbisEncoder.h.

Referenced by encode(), and VorbisEncoder().

m_os

ogg_stream_state Kwave::VorbisEncoder::m_os

private

take physical pages, weld into a logical stream of packets

Definition at line 97 of file VorbisEncoder.h.

Referenced by close(), encode(), open(), VorbisEncoder(), and writeHeader().

m_vb

vorbis_block Kwave::VorbisEncoder::m_vb

private

local working space for packet->PCM decode

Definition at line 115 of file VorbisEncoder.h.

Referenced by close(), encode(), open(), and VorbisEncoder().

m_vc

vorbis_comment Kwave::VorbisEncoder::m_vc

private

struct that stores all the user comments

Definition at line 109 of file VorbisEncoder.h.

Referenced by close(), encodeProperties(), open(), VorbisEncoder(), and writeHeader().

m_vd

vorbis_dsp_state Kwave::VorbisEncoder::m_vd

private

central working state for the packet->PCM decoder

Definition at line 112 of file VorbisEncoder.h.

Referenced by close(), encode(), open(), VorbisEncoder(), and writeHeader().

m_vi

vorbis_info Kwave::VorbisEncoder::m_vi

private

struct that stores all the static vorbis bitstream settings

Definition at line 106 of file VorbisEncoder.h.

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

---

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

• plugins/codec_ogg/VorbisEncoder.h
• plugins/codec_ogg/VorbisEncoder.cpp