Kwave::FlacEncoder Class Reference

#include <FlacEncoder.h>

Inheritance diagram for Kwave::FlacEncoder:

Collaboration diagram for Kwave::FlacEncoder:

Classes
class	VorbisCommentContainer

Public Member Functions
	FlacEncoder ()
virtual	~FlacEncoder () Q_DECL_OVERRIDE
virtual Kwave::Encoder *	instance () Q_DECL_OVERRIDE
virtual bool	encode (QWidget *widget, Kwave::MultiTrackReader &src, QIODevice &dst, const Kwave::MetaDataList &meta_data) Q_DECL_OVERRIDE
virtual QList< Kwave::FileProperty >	supportedProperties () Q_DECL_OVERRIDE
Public Member Functions inherited from Kwave::Encoder
	Encoder ()
virtual	~Encoder ()
virtual QList< Kwave::FileProperty >	unsupportedProperties (const QList< Kwave::FileProperty > &properties_to_check)
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
virtual ::FLAC__StreamEncoderWriteStatus	write_callback (const FLAC__byte buffer[], size_t bytes, unsigned samples, unsigned current_frame) Q_DECL_OVERRIDE
virtual void	metadata_callback (const ::FLAC__StreamMetadata *metadata) Q_DECL_OVERRIDE
virtual void	encodeMetaData (const Kwave::FileInfo &info, QVector< FLAC__StreamMetadata *> &flac_metadata)

Private Attributes
Kwave::VorbisCommentMap	m_vorbis_comment_map
QIODevice *	m_dst

Detailed Description

Definition at line 43 of file FlacEncoder.h.

Constructor & Destructor Documentation

FlacEncoder()

Kwave::FlacEncoder::FlacEncoder

(

)

Constructor

Definition at line 46 of file FlacEncoder.cpp.

References REGISTER_COMPRESSION_TYPES, and REGISTER_MIME_TYPES.

    :Kwave::Encoder(), FLAC::Encoder::Stream(),
     m_vorbis_comment_map(), m_dst(Q_NULLPTR)
{
    REGISTER_MIME_TYPES
    REGISTER_COMPRESSION_TYPES
}

~FlacEncoder()

Kwave::FlacEncoder::~FlacEncoder ( )

virtual

Destructor

Definition at line 55 of file FlacEncoder.cpp.

{
}

Member Function Documentation

encode()

bool Kwave::FlacEncoder::encode ( QWidget *  widget, Kwave::MultiTrackReader &  src, QIODevice &  dst, const Kwave::MetaDataList &  meta_data  )

virtual

Encodes a signal into a stream of bytes.

Parameters

widget	a widget that can be used for displaying message boxes or dialogs
src	MultiTrackReader used as source of the audio data
dst	file or other source to receive a stream of bytes
meta_data	meta data of the file to save

Returns

true if succeeded, false on errors

Implements Kwave::Encoder.

Definition at line 167 of file FlacEncoder.cpp.

References Kwave::FileInfo::bits(), Kwave::StreamObject::blockSize(), Kwave::SampleArray::data(), encodeMetaData(), Kwave::MessageBox::error(), Kwave::MultiTrackReader::isCanceled(), Kwave::FileInfo::length(), m_dst, Kwave::FileInfo::rate(), Kwave::SampleArray::resize(), SAMPLE_BITS, Kwave::SampleArray::size(), Kwave::toUint(), and Kwave::FileInfo::tracks().

{
    bool result = true;

    qDebug("FlacEncoder::encode()");
    const Kwave::FileInfo info(meta_data);
    m_dst  = &dst;

    // get info: tracks, sample rate
    int            tracks = info.tracks();
    unsigned int   bits   = info.bits();
    sample_index_t length = info.length();

    set_compression_level(5); // @todo make the FLAC compression configurable
    set_channels(static_cast<unsigned>(tracks));
    set_bits_per_sample(static_cast<unsigned>(bits));
    set_sample_rate(static_cast<unsigned>(info.rate()));
    set_total_samples_estimate(static_cast<FLAC__uint64>(length));
    set_verify(false); // <- set to "true" for debugging

    // use mid-side stereo encoding if we have two channels
    set_do_mid_side_stereo(tracks == 2);
    set_loose_mid_side_stereo(tracks == 2);

    // encode meta data, most of them as vorbis comments
    QVector<FLAC__StreamMetadata *> flac_metadata;
    encodeMetaData(info, flac_metadata);

    // convert container to a list of pointers
    unsigned int meta_count = flac_metadata.size();
    if (meta_count) {
        // WARNING: this only stores the pointer, it does not copy!
        if (!set_metadata(flac_metadata.data(), meta_count)) {
            qWarning("FlacEncoder: setting meta data failed !?");
        }
    }

    QVector<FLAC__int32 *> flac_buffer;
    do {
        // open the output device
        if (!dst.open(QIODevice::ReadWrite | QIODevice::Truncate)) {
            Kwave::MessageBox::error(widget,
                i18n("Unable to open the file for saving."));
            result = false;
            break;
        }

        // initialize the FLAC stream, this already writes some meta info
        FLAC__StreamEncoderInitStatus init_state = init();
        if (init_state != FLAC__STREAM_ENCODER_INIT_STATUS_OK) {
            qWarning("state = %d", static_cast<int>(init_state));
            Kwave::MessageBox::error(widget,
                i18n("Unable to open the FLAC encoder."));
            result = false;
            break;
        }

        // allocate output buffers, with FLAC 32 bit format
        unsigned int len = src.blockSize(); // samples
        for (int track=0; track < tracks; track++)
        {
            FLAC__int32 *buffer =
                static_cast<FLAC__int32 *>(malloc(sizeof(FLAC__int32) * len));
            Q_ASSERT(buffer);
            if (!buffer) break;
            flac_buffer.append(buffer);
        }

        // allocate input buffer, with Kwave's sample_t
        Kwave::SampleArray in_buffer(len);
        Q_ASSERT(in_buffer.size() == len);
        Q_ASSERT(flac_buffer.size() == tracks);

        if ((in_buffer.size() < len) || (flac_buffer.size() < tracks))
        {
            Kwave::MessageBox::error(widget, i18n("Out of memory"));
            result = false;
            break;
        }

        // calculate divisor for reaching the proper resolution
        int shift = SAMPLE_BITS - bits;
        if (shift < 0) shift = 0;
        FLAC__int32 div = (1 << shift);
        if (div == 1) div = 0;
        const FLAC__int32 clip_min = -(1 << bits);
        const FLAC__int32 clip_max =  (1 << bits) - 1;

        sample_index_t rest = length;
        while (rest && len && !src.isCanceled() && result) {
            // limit to rest of signal
            if (len > rest) len = Kwave::toUint(rest);
            if (!in_buffer.resize(len)) {
                Kwave::MessageBox::error(widget, i18n("Out of memory"));
                result = false;
                break;
            }

            // add all samples to one single buffer
            for (int track = 0; track < tracks; track++) {
                Kwave::SampleReader *reader = src[track];
                Q_ASSERT(reader);
                if (!reader) break;

                (*reader) >> in_buffer;           // read samples into in_buffer
                unsigned int l = in_buffer.size();// in_buffer might be empty!
                if (l < len) {
                    if (!in_buffer.resize(len)) {
                        Kwave::MessageBox::error(widget, i18n("Out of memory"));
                        result = false;
                        break;
                    }
                    while (l < len) in_buffer[l++] = 0;
                }

                FLAC__int32 *buf = flac_buffer.at(track);
                Q_ASSERT(buf);
                if (!buf) break;

                const Kwave::SampleArray &in = in_buffer;
                for (unsigned int in_pos = 0; in_pos < len; in_pos++) {
                    FLAC__int32 s = in[in_pos];
                    if (div) s /= div;
                    if (s > clip_max) s = clip_max;
                    if (s < clip_min) s = clip_min;
                    *buf = s;
                    buf++;
                }
            }
            if (!result) break; // error occurred?

            // process all collected samples
            FLAC__int32 **buffer = flac_buffer.data();
            bool processed = process(buffer, static_cast<unsigned>(len));
            if (!processed) {
                result = false;
                break;
            }

            rest -= len;
        }

    } while (false);

    // close the output device and the FLAC stream
    finish();

    // clean up all FLAC metadata
    while (!flac_metadata.isEmpty()) {
        FLAC__StreamMetadata *m = flac_metadata[0];
        if (m) FLAC__metadata_object_delete(m);
        flac_metadata.remove(0);
    }

    m_dst = Q_NULLPTR;
    dst.close();

    while (!flac_buffer.isEmpty()) {
        FLAC__int32 *buf = flac_buffer.first();
        if (buf) free(buf);
        flac_buffer.remove(0);
    }

    return result;
}

Here is the call graph for this function:

encodeMetaData()

void Kwave::FlacEncoder::encodeMetaData ( const Kwave::FileInfo &  info, QVector< FLAC__StreamMetadata *> &  flac_metadata  )

protectedvirtual

Encode all Kwave file info into FLAC meta data

Parameters

info	information about the file to be saved
flac_metadata	QList with collects the FLAC metadata

Definition at line 145 of file FlacEncoder.cpp.

References Kwave::FlacEncoder::VorbisCommentContainer::add(), Kwave::FileInfo::contains(), Kwave::FlacEncoder::VorbisCommentContainer::data(), Kwave::FileInfo::get(), and m_vorbis_comment_map.

Referenced by encode().

{
    // encode all Vorbis comments
    VorbisCommentMap::ConstIterator it;
    VorbisCommentContainer vc;
    for (it = m_vorbis_comment_map.constBegin();
         it != m_vorbis_comment_map.constEnd();
         ++it)
    {
        if (!info.contains(it.value())) continue; // not present -> skip

        QString value = info.get(it.value()).toString();
        vc.add(it.key(), value);
    }
    flac_metadata.append(vc.data());

    // todo: add cue sheet etc here...

}

Here is the call graph for this function:

Here is the caller graph for this function:

instance()

Kwave::Encoder * Kwave::FlacEncoder::instance ( )

virtual

Returns a new instance of the encoder

Implements Kwave::Encoder.

Definition at line 60 of file FlacEncoder.cpp.

{
    return new Kwave::FlacEncoder();
}

metadata_callback()

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

protectedvirtual

Callback for encoding meta data

Parameters

metadata

pointer to a FLAC metadata structure that will be filled

Definition at line 90 of file FlacEncoder.cpp.

{
    /* we are not interested in the FLAC metadata */
}

supportedProperties()

QList< Kwave::FileProperty > Kwave::FlacEncoder::supportedProperties ( )

virtual

Returns a list of supported file properties

Reimplemented from Kwave::Encoder.

Definition at line 66 of file FlacEncoder.cpp.

References m_vorbis_comment_map.

{
    return m_vorbis_comment_map.values();
}

write_callback()

FLAC__StreamEncoderWriteStatus Kwave::FlacEncoder::write_callback ( const FLAC__byte  buffer[], size_t  bytes, unsigned  samples, unsigned  current_frame  )

protected

Callback for writing data to the FLAC layer

Parameters

buffer	array with samples
bytes	length of the buffer in bytes
samples	the number of samples
current_frame	index of the current frame

Returns

FLAC stream encoder write status

Definition at line 72 of file FlacEncoder.cpp.

References m_dst.

{
    Q_ASSERT(m_dst);
    if (!m_dst) return FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR;

    qint64 written = m_dst->write(
        reinterpret_cast<const char *>(&(buffer[0])),
        static_cast<qint64>(bytes)
    );

    return (written == static_cast<qint64>(bytes)) ?
        FLAC__STREAM_ENCODER_WRITE_STATUS_OK :
        FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR;
}

Member Data Documentation

m_dst

QIODevice* Kwave::FlacEncoder::m_dst

private

pointer to the QIODevice for storing, used while encoding

Definition at line 140 of file FlacEncoder.h.

Referenced by encode(), and write_callback().

m_vorbis_comment_map

Kwave::VorbisCommentMap Kwave::FlacEncoder::m_vorbis_comment_map

private

map for translating vorbis comments to FileInfo properties

Definition at line 137 of file FlacEncoder.h.

Referenced by encodeMetaData(), and supportedProperties().

---

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

• plugins/codec_flac/FlacEncoder.h
• plugins/codec_flac/FlacEncoder.cpp