Kwave::MP3Encoder Class Reference

#include <MP3Encoder.h>

Inheritance diagram for Kwave::MP3Encoder:

Collaboration diagram for Kwave::MP3Encoder:

Public Member Functions
	MP3Encoder ()
virtual	~MP3Encoder ()
virtual Kwave::Encoder *	instance ()
virtual bool	encode (QWidget *widget, Kwave::MultiTrackReader &src, QIODevice &dst, const Kwave::MetaDataList &meta_data)
virtual QList< Kwave::FileProperty >	supportedProperties ()
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)

Private Slots
void	dataAvailable ()

Private Member Functions
void	encodeID3Tags (const Kwave::MetaDataList &meta_data, ID3_Tag &tag)

Private Attributes
ID3_PropertyMap	m_property_map
QMutex	m_lock
QIODevice *	m_dst
QProcess	m_process
QString	m_program
QStringList	m_params
quint8	m_write_buffer [PIPE_BUF]
char	m_read_buffer [PIPE_BUF]

Detailed Description

Definition at line 42 of file MP3Encoder.h.

Constructor & Destructor Documentation

MP3Encoder()

Kwave::MP3Encoder::MP3Encoder

(

)

Constructor

Definition at line 52 of file MP3Encoder.cpp.

References Kwave::connect(), dataAvailable(), m_process, REGISTER_COMPRESSION_TYPES, and REGISTER_MIME_TYPES.

Referenced by instance().

    :Kwave::Encoder(),
     m_property_map(),
     m_lock(),
     m_dst(Q_NULLPTR),
     m_process(this),
     m_program(),
     m_params()
{
    REGISTER_MIME_TYPES
    REGISTER_COMPRESSION_TYPES

    connect(&m_process, SIGNAL(readyReadStandardOutput()),
            this, SLOT(dataAvailable()));
}

Here is the call graph for this function:

Here is the caller graph for this function:

~MP3Encoder()

Kwave::MP3Encoder::~MP3Encoder ( )

virtual

Destructor

Definition at line 69 of file MP3Encoder.cpp.

{
}

Member Function Documentation

dataAvailable

void Kwave::MP3Encoder::dataAvailable ( )

privateslot

called when data from the external process is available

Definition at line 569 of file MP3Encoder.cpp.

References m_dst, m_lock, m_process, and m_read_buffer.

Referenced by MP3Encoder().

{
    while (m_process.bytesAvailable()) {
        qint64 len = m_process.read(&(m_read_buffer[0]), sizeof(m_read_buffer));
        if (len) {
            QMutexLocker _lock(&m_lock);
            if (m_dst) m_dst->write(&(m_read_buffer[0]), len);
        }
    }
}

Here is the caller graph for this function:

encode()

bool Kwave::MP3Encoder::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 265 of file MP3Encoder.cpp.

References _, Kwave::FileInfo::bits(), Kwave::SampleArray::constData(), Kwave::FileInfo::contains(), DBG, encodeID3Tags(), Kwave::SampleReader::eof(), Kwave::MessageBox::error(), Kwave::MultiTrackReader::first(), Kwave::FileInfo::get(), Kwave::INF_BITRATE_LOWER, Kwave::INF_BITRATE_NOMINAL, Kwave::INF_BITRATE_UPPER, Kwave::INF_COPYRIGHTED, Kwave::INF_MPEG_EMPHASIS, Kwave::INF_ORIGINAL, Kwave::MultiTrackReader::isCanceled(), Kwave::MultiTrackReader::last(), Kwave::MP3EncoderSettings::load(), Kwave::MP3EncoderSettings::m_bits_per_sample, m_dst, Kwave::MP3EncoderSettings::m_format, m_lock, m_params, Kwave::MP3EncoderSettings::m_path, m_process, m_program, Kwave::MP3EncoderSettings::m_sample_rate, m_write_buffer, OPTION, OPTION_P, Kwave::FileInfo::rate(), Kwave::toUint(), Kwave::MultiTrackSource< SOURCE, INITIALIZE >::tracks(), and Kwave::MessageBox::warningContinueCancel().

Referenced by Kwave::MP3EncoderDialog::testSettings().

{
    bool result = true;
    ID3_Tag id3_tag;
    Kwave::MP3EncoderSettings settings;

    settings.load();

    ID3_TagType id3_tag_type = ID3TT_ID3V2;
    id3_tag.SetSpec(ID3V2_LATEST);

    const Kwave::FileInfo info(meta_data);

    // get info: tracks, sample rate
    const unsigned int tracks     = src.tracks();
    const sample_index_t length   = src.last() - src.first() + 1;
    unsigned int       bits       = qBound(8U, ((info.bits() + 7) & ~0x7), 32U);
    const double       rate       = info.rate();
    const unsigned int out_tracks = qMin(tracks, 2U);

    // when encoding track count > 2, show a warning that we will mix down
    // to stereo
    if (tracks > 2) {
        if (Kwave::MessageBox::warningContinueCancel(
            widget,
            i18n("The file format you have chosen supports only mono or "
                 "stereo. This file will be mixed down to stereo when "
                 "saving."),
            QString(), QString(), QString(),
            _("mp3_accept_down_mix_on_export")) != KMessageBox::Continue)
        {
            return false;
        }
    }

    // open the output device
    if (!dst.open(QIODevice::ReadWrite | QIODevice::Truncate)) {
        Kwave::MessageBox::error(widget,
            i18n("Unable to open the file for saving!"));
        return false;
    }

    m_dst  = &dst;
    m_params.clear();

    // encode meta data into with id3lib
    ID3_QIODeviceWriter id3_writer(dst);
    encodeID3Tags(meta_data, id3_tag);

    OPTION(m_flags.m_prepend);          // optional parameters at the very start

    // mandantory audio input format and encoding options
    OPTION(m_input.m_raw_format);       // input is raw audio
    OPTION(m_input.m_byte_order);       // byte swapping
    OPTION(m_input.m_signed);           // signed sample format

    // supported sample rates [kHz]
    // 8 / 11.025 / 12 / 16 / 22.05 / 24 /32 / 44.1 / 48
    // if our rate is not supported, lame automatically resamples with the
    // next higher supported rate
    if (settings.m_format.m_sample_rate.length()) {
        QString str = settings.m_format.m_sample_rate;
        if (str.contains(_("[%khz]"))) {
            str = str.replace(_("[%khz]"),
                _("%1")).arg(rate / 1000.0, 1, 'f', 2);
            m_params.append(str.split(QLatin1Char(' ')));
        } else {
            m_params.append(str.arg(rate).split(QLatin1Char(' ')));
        }
    }

    // bits per sample, supported by Kwave are: 8 / 16 / 24 / 32
    if (!settings.m_format.m_bits_per_sample.contains(QLatin1Char('%'))) {
        // bits/sample are not selectable => use default=16bit
        bits = 16;
        OPTION(m_format.m_bits_per_sample);
    } else {
        OPTION_P(m_format.m_bits_per_sample, bits);
    }

    // encode one track as "mono" and two tracks as "joint-stereo"
    if (tracks == 1) {
        OPTION(m_format.m_channels.m_mono);
    } else {
        OPTION(m_format.m_channels.m_stereo);
    }

    // nominal / lower / upper bitrate
    int bitrate_min =   8;
    int bitrate_max = 320;
    int bitrate_nom = 128;
    if (info.contains(Kwave::INF_BITRATE_NOMINAL)) {
        // nominal bitrate => use ABR mode
        bitrate_nom = info.get(Kwave::INF_BITRATE_NOMINAL).toInt() / 1000;
        bitrate_nom = qBound(bitrate_min, bitrate_nom, bitrate_max);
        OPTION_P(m_quality.m_bitrate.m_avg, bitrate_nom);
    }
    if (info.contains(Kwave::INF_BITRATE_LOWER)) {
        int bitrate = info.get(Kwave::INF_BITRATE_LOWER).toInt() / 1000;
        bitrate_min = qBound(bitrate_min, bitrate, bitrate_nom);
        OPTION_P(m_quality.m_bitrate.m_min, bitrate_min);
    }
    if (info.contains(Kwave::INF_BITRATE_UPPER)) {
        int bitrate = info.get(Kwave::INF_BITRATE_UPPER).toInt() / 1000;
        bitrate_max = qBound(bitrate_nom, bitrate, bitrate_max);
        OPTION_P(m_quality.m_bitrate.m_max, bitrate_max);
    }
    //  Kwave::INF_MPEG_LAYER,          /**< MPEG Layer, I/II/III */
    //  Kwave::INF_MPEG_MODEEXT,        /**< MPEG mode extension */
    //  Kwave::INF_MPEG_VERSION,        /**< MPEG version */

    /* MPEG emphasis mode */
    if (info.contains(Kwave::INF_MPEG_EMPHASIS)) {
        int emphasis = info.get(Kwave::INF_MPEG_EMPHASIS).toInt();
        switch (emphasis) {
            case  1:
                OPTION(m_encoding.m_emphasis.m_50_15ms);  // 1 = 50/15ms
                break;
            case  3:
                OPTION(m_encoding.m_emphasis.m_ccit_j17); // 3 = CCIT J.17
                break;
            case  0: /* FALLTHROUGH */
            default:
                OPTION(m_encoding.m_emphasis.m_none);     // 0 = none
                break;
        }
    }

    OPTION(m_encoding.m_noise_shaping); // noise shaping settings
    OPTION(m_encoding.m_compatibility); // compatibility options

    if (info.contains(Kwave::INF_COPYRIGHTED) && info.get(Kwave::INF_COPYRIGHTED).toBool()) {
        OPTION(m_flags.m_copyright);     // copyrighted
    }

    if (info.contains(Kwave::INF_ORIGINAL) && !info.get(Kwave::INF_ORIGINAL).toBool()) {
        OPTION(m_flags.m_original);     // original
    }

    OPTION(m_flags.m_protect);          // CRC protection
    OPTION(m_flags.m_append);           // optional parameters at the end

    m_params.append(_("-")); // infile  = stdin
    m_params.append(_("-")); // outfile = stdout

    m_program = settings.m_path;

    qDebug("MP3Encoder::encode(): %s %s",
           DBG(m_program), DBG(m_params.join(_(" ")))
    );

    m_process.setReadChannel(QProcess::StandardOutput);

    m_process.start(m_program, m_params);
    QString stdError;
    if (!m_process.waitForStarted()) {
        qWarning("cannot start program '%s'", DBG(m_program));
        m_process.waitForFinished();
        result = false;
    }

    // if a ID3v2 tag is requested, the tag comes at the start
    if (id3_tag_type == ID3TT_ID3V2)
        id3_tag.Render(id3_writer, id3_tag_type);

    // MP3 supports only mono and stereo, prepare a mixer matrix
    // (not used in case of tracks <= 2)
    Kwave::MixerMatrix mixer(tracks, out_tracks);

    // read in from the sample readers
    const unsigned int buf_len = sizeof(m_write_buffer);
    const int bytes_per_sample = bits / 8;

    sample_index_t rest = length;
    Kwave::SampleArray in_samples(tracks);
    Kwave::SampleArray out_samples(tracks);

    while (result && rest && (m_process.state() != QProcess::NotRunning)) {
        unsigned int x;
        unsigned int y;

        // merge the tracks into the sample buffer
        quint8 *dst_buffer = &(m_write_buffer[0]);
        unsigned int count = buf_len / (bytes_per_sample * tracks);
        if (rest < count) count = Kwave::toUint(rest);

        unsigned int written = 0;
        for (written = 0; written < count; written++) {
            const sample_t *src_buf = Q_NULLPTR;

            // fill input buffer with samples
            for (x = 0; x < tracks; ++x) {
                in_samples[x] = 0;
                Kwave::SampleReader *stream = src[x];
                Q_ASSERT(stream);
                if (!stream) continue;

                if (!stream->eof()) (*stream) >> in_samples[x];
            }

            if (tracks > 2) {
                // multiply matrix with input to get output
                const Kwave::SampleArray &in = in_samples;
                for (y = 0; y < out_tracks; ++y) {
                    double sum = 0;
                    for (x = 0; x < tracks; ++x)
                        sum += static_cast<double>(in[x]) * mixer[x][y];
                    out_samples[y] = static_cast<sample_t>(sum);
                }

                // use output of the matrix
                src_buf = out_samples.constData();
            } else {
                // use input buffer directly
                src_buf = in_samples.constData();
            }

            // sample conversion from 24bit to raw PCM, native endian
            for (y = 0; y < out_tracks; ++y) {
                sample_t s = *(src_buf++);
#if Q_BYTE_ORDER == Q_BIG_ENDIAN
                // big endian
                if (bits >= 8)
                    *(dst_buffer++) = static_cast<quint8>(s >> 16);
                if (bits > 8)
                    *(dst_buffer++) = static_cast<quint8>(s >> 8);
                if (bits > 16)
                    *(dst_buffer++) = static_cast<quint8>(s & 0xFF);
                if (bits > 24)
                    *(dst_buffer++) = 0x00;
#else
                // little endian
                if (bits > 24)
                    *(dst_buffer++) = 0x00;
                if (bits > 16)
                    *(dst_buffer++) = static_cast<quint8>(s & 0xFF);
                if (bits > 8)
                    *(dst_buffer++) = static_cast<quint8>(s >> 8);
                if (bits >= 8)
                    *(dst_buffer++) = static_cast<quint8>(s >> 16);
#endif
            }
        }

        // write out to the stdin of the external process
        qint64 bytes_written = m_process.write(
            reinterpret_cast<char *>(&(m_write_buffer[0])),
            written * (bytes_per_sample * tracks)
        );

        // break if eof reached or disk full
        if (!bytes_written) break;

        // wait for write to take all data...
        m_process.waitForBytesWritten();

        // abort if the user pressed cancel
        // --> this would leave a corrupted file !!!
        if (src.isCanceled()) break;

        Q_ASSERT(rest >= written);
        rest -= written;
    }

    // flush and close the write channel
    m_process.closeWriteChannel();

    // wait until the process has finished
    qDebug("wait for finish of the process");
    while (m_process.state() != QProcess::NotRunning) {
        m_process.waitForFinished(100);
        if (src.isCanceled()) break;
    }

    int exit_code = m_process.exitCode();
    qDebug("exit code=%d", exit_code);
    if (!result || (exit_code != 0)) {
        result = false;
        stdError = QString::fromLocal8Bit(m_process.readAllStandardError());
        qWarning("stderr output: %s", DBG(stdError));

        Kwave::MessageBox::error(widget,
            i18nc("%1=name of the external program, %2=stderr of the program",
            "An error occurred while calling the external encoder '%1':\n\n%2",
           m_program, stdError
        ));
    }

    // if a ID3v1 tag is requested, the tag comes at the end
    if (id3_tag_type != ID3TT_ID3V2)
        id3_tag.Render(id3_writer, id3_tag_type);

    {
        QMutexLocker _lock(&m_lock);
        m_dst = Q_NULLPTR;
        dst.close();
    }

    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

encodeID3Tags()

void Kwave::MP3Encoder::encodeID3Tags ( const Kwave::MetaDataList &  meta_data, ID3_Tag &  tag  )

private

encode all meta data into ID3 tags

Parameters

meta_data	reference to the meta data to encode
tag	the ID3 tag to receive the ID3 frames

Definition at line 86 of file MP3Encoder.cpp.

References _, Kwave::FileInfo::contains(), DBG, Kwave::ID3_PropertyMap::ENC_COMMENT, Kwave::ID3_PropertyMap::ENC_GENRE_TYPE, Kwave::ID3_PropertyMap::ENC_LENGTH, Kwave::ID3_PropertyMap::ENC_NONE, Kwave::ID3_PropertyMap::ENC_TERMS_OF_USE, Kwave::ID3_PropertyMap::ENC_TEXT, Kwave::ID3_PropertyMap::ENC_TEXT_PARTINSET, Kwave::ID3_PropertyMap::ENC_TEXT_SLASH, Kwave::ID3_PropertyMap::ENC_TEXT_TIMESTAMP, Kwave::ID3_PropertyMap::ENC_TEXT_URL, Kwave::ID3_PropertyMap::ENC_TRACK_NUM, Kwave::ID3_PropertyMap::encoding(), Kwave::ID3_PropertyMap::findProperty(), Kwave::GenreType::fromID3(), Kwave::FileInfo::get(), Kwave::INF_CD, Kwave::INF_CDS, Kwave::INF_TRACK, Kwave::INF_TRACKS, Kwave::FileInfo::length(), m_property_map, Kwave::GenreType::name(), Kwave::FileInfo::properties(), Kwave::FileInfo::rate(), and Kwave::string2date().

Referenced by encode().

{
    const Kwave::FileInfo info(meta_data);
    ID3_FrameInfo frameInfo;

    const QMap<Kwave::FileProperty, QVariant> properties(info.properties());
    QMap<Kwave::FileProperty, QVariant>::const_iterator it;
    for (it = properties.begin(); it != properties.end(); ++it) {
        const Kwave::FileProperty &property = it.key();
        const QVariant            &value    = it.value();

        ID3_FrameID id = m_property_map.findProperty(property);
        if (id == ID3FID_NOFRAME) continue;

        if (info.contains(Kwave::INF_CD) && (property == Kwave::INF_CDS))
            continue; /* INF_CDS has already been handled by INF_CD */
        if (info.contains(Kwave::INF_TRACK) && (property == Kwave::INF_TRACKS))
            continue; /* INF_TRACKS has already been handled by INF_TRACK */

        ID3_Frame *frame = new ID3_Frame;
        Q_ASSERT(frame);
        if (!frame) break;

        QString str_val = value.toString();
//      qDebug("encoding ID3 tag #%02d, property='%s', value='%s'",
//          static_cast<int>(id),
//          DBG(info.name(property)),
//          DBG(str_val)
//      );

        // encode in UCS16
        frame->SetID(id);
        ID3_Field *field = frame->GetField(ID3FN_TEXT);
        if (!field) {
            qWarning("no field, frame id=%d", static_cast<int>(id));
            delete frame;
            continue;
        }

        ID3_PropertyMap::Encoding encoding = m_property_map.encoding(id);
        switch (encoding) {
            case ID3_PropertyMap::ENC_TEXT_PARTINSET:
            {
                field->SetEncoding(ID3TE_UTF16);

                // if "number of CDs is available: append with "/"
                int cds = info.get(Kwave::INF_CDS).toInt();
                if (cds > 0)
                    str_val += _("/%1").arg(cds);

                field->Set(static_cast<const unicode_t *>(str_val.utf16()));
                break;
            }
            case ID3_PropertyMap::ENC_TRACK_NUM:
            {
                // if "number of tracks is available: append with "/"
                int tracks = info.get(Kwave::INF_TRACKS).toInt();
                if (tracks > 0)
                    str_val += _("/%1").arg(tracks);

                field->SetEncoding(ID3TE_UTF16);
                field->Set(static_cast<const unicode_t *>(str_val.utf16()));
                break;
            }
            case ID3_PropertyMap::ENC_TERMS_OF_USE:
                // the same as ENC_COMMENT, but without "Description"
                /* FALLTHROUGH */
            case ID3_PropertyMap::ENC_COMMENT:
            {
                // detect language at the start "[xxx] "
                QString lang;
                if (str_val.startsWith(QLatin1Char('[')) &&
                    (str_val.at(4) == QLatin1Char(']'))) {
                    lang     = str_val.mid(1,3);
                    str_val  = str_val.mid(5);
                    frame->GetField(ID3FN_DESCRIPTION)->Set("");
                    frame->GetField(ID3FN_LANGUAGE)->Set(
                        static_cast<const char *>(lang.toLatin1().data()));
                }
                /* frame->GetField(ID3FN_DESCRIPTION)->Set(""); */
                field->SetEncoding(ID3TE_UTF16);
                field->Set(static_cast<const unicode_t *>(str_val.utf16()));
                break;
            }
            case ID3_PropertyMap::ENC_GENRE_TYPE:
            {
                int genre = Kwave::GenreType::fromID3(str_val);
                if (genre >= 0)
                    str_val = Kwave::GenreType::name(genre, false);
                // else: user defined genre type, take it as it is

                field->SetEncoding(ID3TE_UTF16);
                field->Set(static_cast<const unicode_t *>(str_val.utf16()));
                break;
            }
            case ID3_PropertyMap::ENC_LENGTH:
            {
                // length in milliseconds
                const double         rate    = info.rate();
                const sample_index_t samples = info.length();
                if ((rate > 0) && samples) {
                    const sample_index_t ms = static_cast<sample_index_t>(
                        (static_cast<double>(samples) * 1E3) / rate);

                    str_val = QString::number(ms);

                    field->SetEncoding(ID3TE_UTF16);
                    field->Set(static_cast<const unicode_t *>(str_val.utf16()));
                } else {
                    delete frame;
                    frame = Q_NULLPTR;
                }
                break;
            }
            case ID3_PropertyMap::ENC_TEXT_TIMESTAMP:
            {
                // ISO 8601 timestamp: "yyyy-MM-ddTHH:mm:ss"
                QString s = Kwave::string2date(str_val);

                // if failed, try "yyyy" format (year only)
                if (!s.length()) {
                    int year = str_val.toInt();
                    if ((year > 0) && (year < 9999)) {
                        frame->SetID(ID3FID_YEAR);
                        // -> re-get the field !
                        // it has become invalid through "SetID()"
                        field = frame->GetField(ID3FN_TEXT);
                        if (!field) {
                            qWarning("no field, frame id=%d",
                                     static_cast<int>(id));
                            break;
                        }
                        s = _("%1").arg(year, 4, 10, QLatin1Char('0'));
                    }
                }

                if (s.length()) {
                    field->SetEncoding(ID3TE_UTF16);
                    field->Set(static_cast<const unicode_t *>(s.utf16()));
                } else {
                    // date is invalid, unknown format
                    qWarning("MP3Encoder::encodeID3Tags(): invalid date: '%s'",
                             DBG(str_val));
                    delete frame;
                    frame = Q_NULLPTR;
                }
                break;
            }
            case ID3_PropertyMap::ENC_TEXT_SLASH: /* FALLTHROUGH */
            case ID3_PropertyMap::ENC_TEXT_URL:   /* FALLTHROUGH */
            case ID3_PropertyMap::ENC_TEXT:
                field->SetEncoding(ID3TE_UTF16);
                field->Set(static_cast<const unicode_t *>(str_val.utf16()));
                break;
            case ID3_PropertyMap::ENC_NONE: /* FALLTHROUGH */
            default:
                // ignore
                delete frame;
                frame = Q_NULLPTR;
                break;
        }

        if (frame) tag.AttachFrame(frame);
    }

    tag.Strip();
    tag.Update();
}

Here is the call graph for this function:

Here is the caller graph for this function:

instance()

Kwave::Encoder * Kwave::MP3Encoder::instance ( )

virtual

Returns a new instance of the encoder

Implements Kwave::Encoder.

Definition at line 74 of file MP3Encoder.cpp.

References MP3Encoder().

{
    return new MP3Encoder();
}

Here is the call graph for this function:

supportedProperties()

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

virtual

Returns a list of supported file properties

Reimplemented from Kwave::Encoder.

Definition at line 80 of file MP3Encoder.cpp.

References m_property_map, and Kwave::ID3_PropertyMap::properties().

{
    return m_property_map.properties();
}

Here is the call graph for this function:

Member Data Documentation

m_dst

QIODevice* Kwave::MP3Encoder::m_dst

private

pointer to the QIODevice for storing, used while encoding

Definition at line 95 of file MP3Encoder.h.

Referenced by dataAvailable(), and encode().

m_lock

QMutex Kwave::MP3Encoder::m_lock

private

lock for protecting m_dst and m_process

Definition at line 92 of file MP3Encoder.h.

Referenced by dataAvailable(), and encode().

m_params

QStringList Kwave::MP3Encoder::m_params

private

list with commandline parameters

Definition at line 104 of file MP3Encoder.h.

Referenced by encode().

m_process

QProcess Kwave::MP3Encoder::m_process

private

the external process with the encoder

Definition at line 98 of file MP3Encoder.h.

Referenced by dataAvailable(), encode(), and MP3Encoder().

m_program

QString Kwave::MP3Encoder::m_program

private

path to the external program

Definition at line 101 of file MP3Encoder.h.

Referenced by encode().

m_property_map

ID3_PropertyMap Kwave::MP3Encoder::m_property_map

private

property - to - ID3 mapping

Definition at line 89 of file MP3Encoder.h.

Referenced by encodeID3Tags(), and supportedProperties().

m_read_buffer

char Kwave::MP3Encoder::m_read_buffer[PIPE_BUF]

private

buffer for reading from the encoder (size is not critical)

Definition at line 119 of file MP3Encoder.h.

Referenced by dataAvailable().

m_write_buffer

quint8 Kwave::MP3Encoder::m_write_buffer[PIPE_BUF]

private

buffer for writing to the encoder

Note

The size of this buffer should never be bigger than PIPE_BUF (see POSIX.1-2001), otherwise there could be some leftover when writing to the stdin queue of the process which would be caught and queued up within Qt. After some time that leads to a critically increasing memory consumption and a large delay when the progress bar has reached 99%.

Definition at line 116 of file MP3Encoder.h.

Referenced by encode().

---

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

• plugins/codec_mp3/MP3Encoder.h
• plugins/codec_mp3/MP3Encoder.cpp