Kwave::FlacDecoder Class Reference

#include <FlacDecoder.h>

Inheritance diagram for Kwave::FlacDecoder:

Collaboration diagram for Kwave::FlacDecoder:

Public Member Functions
	FlacDecoder ()
virtual	~FlacDecoder () 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
void	parseStreamInfo (const FLAC::Metadata::StreamInfo &stream_info)
void	parseVorbisComments (const FLAC::Metadata::VorbisComment &vorbis_comments)
virtual ::FLAC__StreamDecoderReadStatus	read_callback (FLAC__byte buffer[], size_t *bytes) Q_DECL_OVERRIDE
virtual ::FLAC__StreamDecoderWriteStatus	write_callback (const ::FLAC__Frame *frame, const FLAC__int32 *const buffer[]) Q_DECL_OVERRIDE
virtual void	metadata_callback (const ::FLAC__StreamMetadata *metadata) Q_DECL_OVERRIDE
virtual void	error_callback (::FLAC__StreamDecoderErrorStatus status) Q_DECL_OVERRIDE

Private Attributes
QIODevice *	m_source
Kwave::MultiWriter *	m_dest
Kwave::VorbisCommentMap	m_vorbis_comment_map

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 42 of file FlacDecoder.h.

Constructor & Destructor Documentation

FlacDecoder()

Kwave::FlacDecoder::FlacDecoder

(

)

Constructor

Definition at line 35 of file FlacDecoder.cpp.

References REGISTER_COMPRESSION_TYPES, and REGISTER_MIME_TYPES.

    :Kwave::Decoder(),
     FLAC::Decoder::Stream(),
     m_source(Q_NULLPTR),
     m_dest(Q_NULLPTR),
     m_vorbis_comment_map()
{
    REGISTER_MIME_TYPES
    REGISTER_COMPRESSION_TYPES
}

~FlacDecoder()

Kwave::FlacDecoder::~FlacDecoder ( )

virtual

Destructor

Definition at line 47 of file FlacDecoder.cpp.

References close(), and m_source.

{
    if (m_source) close();
}

Here is the call graph for this function:

Member Function Documentation

close()

void Kwave::FlacDecoder::close ( )

virtual

Closes the source.

Implements Kwave::Decoder.

Definition at line 326 of file FlacDecoder.cpp.

References m_source.

Referenced by ~FlacDecoder().

{
    finish();
    m_source = Q_NULLPTR;
}

Here is the caller graph for this function:

decode()

bool Kwave::FlacDecoder::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 304 of file FlacDecoder.cpp.

References Kwave::MultiWriter::last(), m_dest, m_source, Kwave::Decoder::metaData(), Kwave::MetaDataList::replace(), and Kwave::FileInfo::setLength().

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

    m_dest = &dst;

    // read in all remaining data
    qDebug("FlacDecoder::decode(...)");
    process_until_end_of_stream();

    m_dest = Q_NULLPTR;
    Kwave::FileInfo info(metaData());
    info.setLength(dst.last() ? (dst.last() + 1) : 0);
    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:

error_callback()

void Kwave::FlacDecoder::error_callback ( ::FLAC__StreamDecoderErrorStatus  status )

protectedvirtual

FLAC decoder interface: error callback.

Parameters

status

the FLAC status

Definition at line 250 of file FlacDecoder.cpp.

{
    qDebug("FlacDecoder::error_callback: status=%d", status);
}

instance()

Kwave::Decoder * Kwave::FlacDecoder::instance ( )

virtual

Returns a new instance of the decoder

Implements Kwave::Decoder.

Definition at line 53 of file FlacDecoder.cpp.

{
    return new Kwave::FlacDecoder();
}

metadata_callback()

void Kwave::FlacDecoder::metadata_callback ( const ::FLAC__StreamMetadata *  metadata )

protectedvirtual

FLAC decoder interface: callback for processing meta data.

Parameters

metadata

the FLAC meta data to be parsed

Definition at line 212 of file FlacDecoder.cpp.

References parseStreamInfo(), and parseVorbisComments().

{
    Q_ASSERT(metadata);
    if (!metadata) return;

    switch (metadata->type) {
        case FLAC__METADATA_TYPE_STREAMINFO: {
            FLAC::Metadata::StreamInfo stream_info(
                const_cast< ::FLAC__StreamMetadata * >(metadata), true);
            parseStreamInfo(stream_info);
            break;
        }
        case FLAC__METADATA_TYPE_PADDING:
            // -> ignored
            break;
        case FLAC__METADATA_TYPE_APPLICATION:
            qDebug("FLAC metadata: application data");
            break;
        case FLAC__METADATA_TYPE_SEEKTABLE:
            qDebug("FLAC metadata: seektable - not supported yet");
            break;
        case FLAC__METADATA_TYPE_VORBIS_COMMENT: {
            FLAC::Metadata::VorbisComment vorbis_comments(
                const_cast< ::FLAC__StreamMetadata * >(metadata), true);
            parseVorbisComments(vorbis_comments);
            break;
        }
        case FLAC__METADATA_TYPE_CUESHEET:
            qDebug("FLAC metadata: cuesheet - not supported yet");
            break;
        case FLAC__METADATA_TYPE_UNDEFINED:
        default:
            qDebug("FLAC metadata: unknown/undefined type");
    }
}

Here is the call graph for this function:

open()

bool Kwave::FlacDecoder::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 256 of file FlacDecoder.cpp.

References _, DEFAULT_MIME_TYPE, Kwave::MessageBox::error(), Kwave::Compression::FLAC, Kwave::INF_COMPRESSION, Kwave::INF_MIMETYPE, m_source, Kwave::Decoder::metaData(), Kwave::MetaDataList::replace(), and Kwave::FileInfo::set().

{
    metaData().clear();
    Q_ASSERT(!m_source);
    if (m_source) qWarning("FlacDecoder::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;

    /********** Decoder setup ************/
    qDebug("--- FlacDecoder::open() ---");
    set_metadata_respond_all();

    // initialize the stream
    FLAC__StreamDecoderInitStatus init_state = init();
    if (init_state > FLAC__STREAM_DECODER_INIT_STATUS_OK) {
        Kwave::MessageBox::error(widget, i18n(
           "Opening the FLAC bitstream failed."));
        return false;
    }

    // read in all metadata
    process_until_end_of_metadata();

    FLAC::Decoder::Stream::State state = get_state();
    if (state >= FLAC__STREAM_DECODER_END_OF_STREAM) {
        Kwave::MessageBox::error(widget, i18n(
           "Error while parsing the FLAC metadata. (%s)"),
           _(state.as_cstring()));
        return false;
    }

    // set some more standard properties
    Kwave::FileInfo info(metaData());
    info.set(Kwave::INF_MIMETYPE, _(DEFAULT_MIME_TYPE));
    info.set(Kwave::INF_COMPRESSION, Kwave::Compression::FLAC);
    metaData().replace(Kwave::MetaDataList(info));

    return true;
}

Here is the call graph for this function:

parseStreamInfo()

void Kwave::FlacDecoder::parseStreamInfo ( const FLAC::Metadata::StreamInfo &  stream_info )

protected

Parse information about the stream, like sample rate, resolution, channels etc...

Parameters

stream_info

FLAC metadata with stream information

Definition at line 141 of file FlacDecoder.cpp.

References Kwave::Decoder::metaData(), and Kwave::MetaDataList::replace().

Referenced by metadata_callback().

{
    qDebug("FLAC stream info");
    qDebug("\tmin_blocksize   = %d", stream_info.get_min_blocksize());
    qDebug("\tmax_blocksize   = %d", stream_info.get_max_blocksize());
    qDebug("\tmin_framesize   = %d", stream_info.get_min_framesize());
    qDebug("\tmax_framesize   = %d", stream_info.get_max_framesize());

    Kwave::FileInfo info(metaData());
    info.setRate(stream_info.get_sample_rate());
    info.setTracks(stream_info.get_channels());
    info.setBits(stream_info.get_bits_per_sample());
    info.setLength(stream_info.get_total_samples());
    metaData().replace(Kwave::MetaDataList(info));

    qDebug("Bitstream is %u channel, %uHz",
           stream_info.get_channels(),
           stream_info.get_sample_rate());
}

Here is the call graph for this function:

Here is the caller graph for this function:

parseVorbisComments()

void Kwave::FlacDecoder::parseVorbisComments ( const FLAC::Metadata::VorbisComment &  vorbis_comments )

protected

Parse vorbis comments

Parameters

vorbis_comments

list of vorbis comments, can be empty

Definition at line 163 of file FlacDecoder.cpp.

References Kwave::FileInfo::contains(), DBG, Kwave::FileInfo::get(), Kwave::INF_CREATION_DATE, Kwave::INF_SOFTWARE, m_vorbis_comment_map, Kwave::Decoder::metaData(), name, Kwave::MetaDataList::replace(), and Kwave::FileInfo::set().

Referenced by metadata_callback().

{
    Kwave::FileInfo info(metaData());

    // first of all: the vendor string, specifying the software
    QString vendor = QString::fromUtf8(reinterpret_cast<const char *>(
        vorbis_comments.get_vendor_string()));
    if (vendor.length()) {
        info.set(Kwave::INF_SOFTWARE, vendor);
        qDebug("Encoded by: '%s'\n\n", DBG(vendor));
    }

    // parse all vorbis comments into Kwave file properties
    for (unsigned int i = 0; i < vorbis_comments.get_num_comments(); i++) {
        FLAC::Metadata::VorbisComment::Entry comment =
            vorbis_comments.get_comment(i);
        Q_ASSERT(comment.is_valid());
        if (!comment.is_valid()) continue;

        QString name = QString::fromUtf8(
            comment.get_field_name(), comment.get_field_name_length());
        QString value = QString::fromUtf8(
            comment.get_field_value(), comment.get_field_value_length());

        if (!m_vorbis_comment_map.contains(name)) continue;

        // we have a known vorbis tag
        Kwave::FileProperty prop = m_vorbis_comment_map[name];
        info.set(prop, value);
    }

    // convert the date property to a QDate
    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);
     }

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

Here is the call graph for this function:

Here is the caller graph for this function:

read_callback()

FLAC__StreamDecoderReadStatus Kwave::FlacDecoder::read_callback ( FLAC__byte  buffer[], size_t *  bytes  )

protected

FLAC decoder interface: read callback.

Parameters

buffer	the byte buffer to be filled
bytes	pointer with the number of bytes to be read, can be modified

Returns

read state

Definition at line 59 of file FlacDecoder.cpp.

References m_source.

{
    Q_ASSERT(bytes);
    Q_ASSERT(m_source);
    if (!bytes || !m_source) return FLAC__STREAM_DECODER_READ_STATUS_ABORT;

    // check for EOF
    if (m_source->atEnd()) {
        *bytes = 0;
        return FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM;
    }

    // read into application buffer
    *bytes = static_cast<unsigned>(m_source->read(
        reinterpret_cast<char *>(&(buffer[0])),
        static_cast<qint64>(*bytes)
    ));

    if (!*bytes) return FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM;

    return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
}

write_callback()

FLAC__StreamDecoderWriteStatus Kwave::FlacDecoder::write_callback ( const ::FLAC__Frame *  frame, const FLAC__int32 *const  buffer[]  )

protected

FLAC decoder interface: write callback.

Parameters

frame	a FLAC frame structure
buffer	a buffer that contains the decoded samples

Returns

FLAC stream decoder write state

Definition at line 84 of file FlacDecoder.cpp.

References Kwave::FileInfo::bits(), Kwave::SampleArray::data(), Kwave::MultiWriter::isCanceled(), m_dest, Kwave::Decoder::metaData(), SAMPLE_BITS, and Kwave::FileInfo::tracks().

{
    Q_ASSERT(buffer);
    Q_ASSERT(frame);
    Q_ASSERT(m_dest);
    if (!buffer || !frame || !m_dest)
        return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;

    const unsigned int samples = frame->header.blocksize;

    const unsigned int tracks  = Kwave::FileInfo(metaData()).tracks();
    Q_ASSERT(samples);
    Q_ASSERT(tracks);
    if (!samples || !tracks)
        return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;

    Kwave::SampleArray dst(samples);

    // expand the samples up to the correct number of bits
    int shift = SAMPLE_BITS - Kwave::FileInfo(metaData()).bits();
    if (shift < 0) shift = 0;
    unsigned int mul = (1 << shift);

    // decode the samples into a temporary buffer and
    // flush it to the Writer(s), track by track
    for (unsigned int track=0; track < tracks; track++) {
        Kwave::Writer *writer = (*m_dest)[track];
        Q_ASSERT(writer);
        if (!writer) continue;
        const FLAC__int32 *src = buffer[track];
        sample_t *d = dst.data();

        for (unsigned int sample = 0; sample < samples; sample++) {
            // the following cast is only necessary if
            // sample_t is not equal to a quint32
            sample_t s  = static_cast<sample_t>(*src++);

            // correct precision
            if (shift) s *= mul;

            // write to destination buffer
            *d++ = s;
        }

        // flush the temporary buffer
        (*writer) << dst;
    }

    // at this point we check for a user-cancel
    return (m_dest->isCanceled()) ?
        FLAC__STREAM_DECODER_WRITE_STATUS_ABORT :
        FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
}

Here is the call graph for this function:

Member Data Documentation

m_dest

Kwave::MultiWriter* Kwave::FlacDecoder::m_dest

private

destination of the audio data

Definition at line 141 of file FlacDecoder.h.

Referenced by decode(), and write_callback().

m_source

QIODevice* Kwave::FlacDecoder::m_source

private

source of the audio data

Definition at line 138 of file FlacDecoder.h.

Referenced by close(), decode(), open(), read_callback(), and ~FlacDecoder().

m_vorbis_comment_map

Kwave::VorbisCommentMap Kwave::FlacDecoder::m_vorbis_comment_map

private

map for translating vorbis comments to FileInfo properties

Definition at line 144 of file FlacDecoder.h.

Referenced by parseVorbisComments().

---

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

• plugins/codec_flac/FlacDecoder.h
• plugins/codec_flac/FlacDecoder.cpp