Kwave::MP3Decoder Class Reference

#include <MP3Decoder.h>

Inheritance diagram for Kwave::MP3Decoder:

Collaboration diagram for Kwave::MP3Decoder:

Public Member Functions
	MP3Decoder ()
virtual	~MP3Decoder ()
virtual Kwave::Decoder *	instance ()
virtual bool	open (QWidget *widget, QIODevice &source)
virtual bool	decode (QWidget *widget, Kwave::MultiWriter &dst)
virtual void	close ()
enum mad_flow	fillInput (struct mad_stream *stream)
enum mad_flow	processOutput (void *data, struct mad_header const *header, struct mad_pcm *pcm)
enum mad_flow	handleError (void *data, struct mad_stream *stream, struct mad_frame *frame)
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)

Private Member Functions
bool	parseMp3Header (const Mp3_Headerinfo &header, QWidget *widget)
bool	parseID3Tags (ID3_Tag &tag)
QString	parseId3Frame2String (const ID3_Frame *frame)

Private Attributes
ID3_PropertyMap	m_property_map
QIODevice *	m_source
Kwave::MultiWriter *	m_dest
unsigned char *	m_buffer
int	m_buffer_size
size_t	m_prepended_bytes
size_t	m_appended_bytes
unsigned int	m_failures
QWidget *	m_parent_widget

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 40 of file MP3Decoder.h.

Constructor & Destructor Documentation

MP3Decoder()

Kwave::MP3Decoder::MP3Decoder

(

)

Constructor

Definition at line 48 of file MP3Decoder.cpp.

References REGISTER_COMPRESSION_TYPES, and REGISTER_MIME_TYPES.

Referenced by instance().

    :Kwave::Decoder(),
     m_property_map(),
     m_source(Q_NULLPTR),
     m_dest(Q_NULLPTR),
     m_buffer(Q_NULLPTR),
     m_buffer_size(0),
     m_prepended_bytes(0),
     m_appended_bytes(0),
     m_failures(0),
     m_parent_widget(Q_NULLPTR)
{
    REGISTER_MIME_TYPES
    REGISTER_COMPRESSION_TYPES
}

Here is the caller graph for this function:

~MP3Decoder()

Kwave::MP3Decoder::~MP3Decoder ( )

virtual

Destructor

Definition at line 65 of file MP3Decoder.cpp.

References close(), m_buffer, and m_source.

{
    if (m_source) close();
    if (m_buffer) free(m_buffer);
}

Here is the call graph for this function:

Member Function Documentation

close()

void Kwave::MP3Decoder::close ( )

virtual

Closes the source.

Implements Kwave::Decoder.

Definition at line 733 of file MP3Decoder.cpp.

References m_source.

Referenced by ~MP3Decoder().

{
    m_source = Q_NULLPTR;
}

Here is the caller graph for this function:

decode()

bool Kwave::MP3Decoder::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 702 of file MP3Decoder.cpp.

References _error_adapter(), _input_adapter(), _output_adapter(), m_dest, m_failures, m_parent_widget, m_prepended_bytes, and m_source.

{
    Q_ASSERT(m_source);
    if (!m_source) return false;
    m_source->seek(m_prepended_bytes); // skip id3v2 tag

    // set target of the decoding
    m_dest = &dst;
    m_failures = 0;
    m_parent_widget = widget;

    // setup the decoder
    struct mad_decoder decoder;
    mad_decoder_init(&decoder, this,
                     _input_adapter,
                     Q_NULLPTR /* header */,
                     Q_NULLPTR /* filter */,
                     _output_adapter,
                     _error_adapter,
                     Q_NULLPTR /* message */);

    // decode through libmad...
    int result = mad_decoder_run(&decoder, MAD_DECODER_MODE_SYNC);

    // release the decoder
    mad_decoder_finish(&decoder);

    return (result == 0);
}

Here is the call graph for this function:

fillInput()

enum mad_flow Kwave::MP3Decoder::fillInput

(

struct mad_stream *

stream

)

Callback for filling libmad's input buffer

Definition at line 566 of file MP3Decoder.cpp.

References Kwave::MultiWriter::isCanceled(), m_appended_bytes, m_buffer, m_buffer_size, m_dest, m_source, and Kwave::toUint().

Referenced by _input_adapter().

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

    // check if the user pressed cancel
    if (m_dest->isCanceled()) return MAD_FLOW_STOP;

    // preserve the remaining bytes from the last pass
    size_t rest = stream->bufend - stream->next_frame;
    if (rest) memmove(m_buffer, stream->next_frame, rest);

    // clip source at "eof-appended_bytes"
    size_t bytes_to_read = m_buffer_size - rest;
    if (m_source->pos() + bytes_to_read > m_source->size() - m_appended_bytes)
        bytes_to_read = Kwave::toUint(
            m_source->size() - m_appended_bytes - m_source->pos());

    // abort if nothing more to read, even if there are
    // some "left-overs" from the previous pass
    if (!bytes_to_read) return MAD_FLOW_STOP;

    // read from source to fill up the buffer
    size_t size = rest;
    if (bytes_to_read) size += m_source->read(
        reinterpret_cast<char *>(m_buffer) + rest, bytes_to_read);
    if (!size) return MAD_FLOW_STOP; // no more data

    // buffer is filled -> process it
    mad_stream_buffer(stream, m_buffer, size);

    return MAD_FLOW_CONTINUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

handleError()

enum mad_flow Kwave::MP3Decoder::handleError	(	void *	data,
		struct mad_stream *	stream,
		struct mad_frame *	frame
	)

Callback for handling stream errors

Definition at line 503 of file MP3Decoder.cpp.

References _, m_buffer, m_failures, m_parent_widget, Kwave::MessageBox::warningContinueCancel(), and Kwave::MessageBox::warningYesNo().

Referenced by _error_adapter().

{
    if (m_failures >= 2) return MAD_FLOW_CONTINUE; // ignore errors
    if (stream->error == MAD_ERROR_NONE) return MAD_FLOW_CONTINUE; // ???

    QString error;
    switch (stream->error) {
        case MAD_ERROR_BUFLEN:
        case MAD_ERROR_BUFPTR:
        case MAD_ERROR_NOMEM:
            error = i18n("Out of memory");
            break;
        case MAD_ERROR_BADCRC:
            error = i18n("Checksum error");
            break;
        case MAD_ERROR_LOSTSYNC:
            error = i18n("Synchronization lost");
            break;
        case MAD_ERROR_BADLAYER:
        case MAD_ERROR_BADBITRATE:
        case MAD_ERROR_BADSAMPLERATE:
        case MAD_ERROR_BADEMPHASIS:
        case MAD_ERROR_BADBITALLOC:
        case MAD_ERROR_BADSCALEFACTOR:
        case MAD_ERROR_BADFRAMELEN:
        case MAD_ERROR_BADBIGVALUES:
        case MAD_ERROR_BADBLOCKTYPE:
        case MAD_ERROR_BADSCFSI:
        case MAD_ERROR_BADDATAPTR:
        case MAD_ERROR_BADPART3LEN:
        case MAD_ERROR_BADHUFFTABLE:
        case MAD_ERROR_BADHUFFDATA:
        case MAD_ERROR_BADSTEREO:
            error = i18n("File contains invalid data");
            break;
        default:
            QString err_hex = QString::number(
                static_cast<int>(stream->error), 16).toUpper();
            error = i18n("Unknown error 0x%1. Damaged file?", err_hex);
    }

    long unsigned int pos = stream->this_frame - m_buffer;
    int result = 0;
    error = i18n("An error occurred while decoding the file:\n'%1',\n"
                 "at position %2.", error, pos);
    if (!m_failures) {
        m_failures = 1;
        result = Kwave::MessageBox::warningContinueCancel(m_parent_widget,
                 error + _("\n") + i18n("Do you still want to continue?"));
        if (result != KMessageBox::Continue) return MAD_FLOW_BREAK;
    } else if (m_failures == 1) {
        result = Kwave::MessageBox::warningYesNo(m_parent_widget,
            error + _("\n") +
            i18n("Do you want to continue and ignore all following errors?"));
        m_failures++;
        if (result != KMessageBox::Yes) return MAD_FLOW_BREAK;
    }

    return MAD_FLOW_CONTINUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

instance()

Kwave::Decoder * Kwave::MP3Decoder::instance ( )

virtual

Returns a new instance of the decoder

Implements Kwave::Decoder.

Definition at line 72 of file MP3Decoder.cpp.

References MP3Decoder().

{
    return new MP3Decoder();
}

Here is the call graph for this function:

open()

bool Kwave::MP3Decoder::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

Bug:

: id3lib crashes in this line on some MP3 files

Implements Kwave::Decoder.

Definition at line 411 of file MP3Decoder.cpp.

References _, Kwave::INF_MIMETYPE, m_appended_bytes, m_buffer, m_buffer_size, m_prepended_bytes, m_source, Kwave::Decoder::metaData(), parseID3Tags(), parseMp3Header(), Kwave::MetaDataList::replace(), Kwave::FileInfo::set(), Kwave::MessageBox::sorry(), and Kwave::toUint().

{
    qDebug("MP3Decoder::open()");
    metaData().clear();
    Q_ASSERT(!m_source);
    if (m_source) qWarning("MP3Decoder::open(), already open !");

    /* open the file in readonly mode with seek enabled */
    if (src.isSequential()) return false;
    if (!src.open(QIODevice::ReadOnly)) {
        qWarning("unable to open source in read-only mode!");
        return false;
    }

    /* read all available ID3 tags */
    ID3_Tag tag;
    ID3_QIODeviceReader adapter(src);
    tag.Link(adapter, static_cast<flags_t>(ID3TT_ALL));

    qDebug("NumFrames = %u", Kwave::toUint(tag.NumFrames()));
    if (tag.GetSpec() != ID3V2_UNKNOWN) {
        qDebug("Size = %u",      Kwave::toUint(tag.Size()));
    }
    qDebug("HasLyrics = %d", tag.HasLyrics());
    qDebug("HasV1Tag = %d",  tag.HasV1Tag());
    qDebug("HasV2Tag = %d",  tag.HasV2Tag());

    m_prepended_bytes = tag.GetPrependedBytes();
    m_appended_bytes  = tag.GetAppendedBytes();
    qDebug("prepended=%lu, appended=%lu", m_prepended_bytes, m_appended_bytes);

    const Mp3_Headerinfo *mp3hdr = tag.GetMp3HeaderInfo();
    if (!mp3hdr) {
        Kwave::MessageBox::sorry(widget,
            i18n("The opened file is no MPEG file or it is damaged.\n"
            "No header information has been found."));
        return false;
    }

    /* parse the MP3 header */
    if (!parseMp3Header(*mp3hdr, widget)) return false;

    /* parse the ID3 tags */
    if (!parseID3Tags(tag)) return false;

    /* accept the source */
    m_source = &src;
    Kwave::FileInfo info(metaData());
    info.set(Kwave::INF_MIMETYPE, _("audio/mpeg"));
    metaData().replace(Kwave::MetaDataList(info));

    // allocate a transfer buffer with 128 kB
    if (m_buffer) free(m_buffer);
    m_buffer_size = (128 << 10);

    m_buffer = static_cast<unsigned char *>(malloc(m_buffer_size));
    if (!m_buffer) return false; // out of memory :-(

    return true;
}

Here is the call graph for this function:

parseId3Frame2String()

QString Kwave::MP3Decoder::parseId3Frame2String ( const ID3_Frame *  frame )

private

parse a ID3 frame into a string

Parameters

frame

a ID3 frame

Returns

QString with the content

Definition at line 399 of file MP3Decoder.cpp.

References _.

Referenced by parseID3Tags().

{
    QString s;
    char *text = ID3_GetString(frame, ID3FN_TEXT);
    if (text && strlen(text)) {
        s = _(text);
        ID3_FreeString(text);
    }
    return s;
}

Here is the caller graph for this function:

parseID3Tags()

bool Kwave::MP3Decoder::parseID3Tags ( ID3_Tag &  tag )

private

parse all known ID3 tags

Definition at line 211 of file MP3Decoder.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::GenreType::fromID3(), Kwave::FileInfo::get(), Kwave::INF_CD, Kwave::INF_CDS, Kwave::INF_CREATION_DATE, Kwave::INF_TRACK, Kwave::INF_TRACKS, m_property_map, Kwave::Decoder::metaData(), Kwave::GenreType::name(), parseId3Frame2String(), Kwave::ID3_PropertyMap::property(), Kwave::FileInfo::rate(), Kwave::MetaDataList::replace(), Kwave::FileInfo::set(), Kwave::FileInfo::setLength(), and Kwave::string2date().

Referenced by open().

{
    if (tag.NumFrames() < 1) return true; // no tags, nothing to do

    QDate creation_date;
    QTime creation_time;
    int year  = -1;
    int month = -1;
    int day   = -1;

    ID3_Tag::Iterator *it = tag.CreateIterator();
    ID3_Frame *frame = Q_NULLPTR;
    Kwave::FileInfo info(metaData());
    while (it && (frame = it->GetNext())) {
        const ID3_FrameID id = frame->GetID();
        const Kwave::FileProperty property = m_property_map.property(id);
        const ID3_PropertyMap::Encoding encoding = m_property_map.encoding(id);
        switch (encoding) {
            case ID3_PropertyMap::ENC_TEXT_PARTINSET:
            {
                QString s = parseId3Frame2String(frame);
                int cd  = 0;
                int cds = 0;
                if (s.contains(QLatin1Char('/'))) {
                    int i = s.indexOf(QLatin1Char('/'));
                    cd = s.left(i).toInt();
                    cds = s.mid(i + 1).toInt();
                } else {
                    cd = s.toInt();
                }
                if (cd  > 0) info.set(Kwave::INF_CD , QVariant(cd));
                if (cds > 0) info.set(Kwave::INF_CDS, QVariant(cds));
                break;
            }
            case ID3_PropertyMap::ENC_TRACK_NUM:
            {
                QString s = parseId3Frame2String(frame);
                int track  = 0;
                int tracks = 0;
                if (s.contains(QLatin1Char('/'))) {
                    int i = s.indexOf(QLatin1Char('/'));
                    track = s.left(i).toInt();
                    tracks = s.mid(i + 1).toInt();
                } else {
                    track = s.toInt();
                }
                if (track  > 0) info.set(Kwave::INF_TRACK , QVariant(track));
                if (tracks > 0) info.set(Kwave::INF_TRACKS, QVariant(tracks));
                break;
            }
            case ID3_PropertyMap::ENC_TERMS_OF_USE:
                // the same as ENC_COMMENT, but without "Description"
                /* FALLTHROUGH */
            case ID3_PropertyMap::ENC_COMMENT:
            {
                QString s = parseId3Frame2String(frame);

                // optionally prepend language
                char *lang = ID3_GetString(frame, ID3FN_LANGUAGE);
                if (lang) {
                    s = _("[") + _(lang) + _("] ") + s;
                    ID3_FreeString(lang);
                }

                // append to already existing tag, separated by a slash
                if (info.contains(property))
                    s = info.get(property).toString() + _(" / ") + s;
                info.set(property, QVariant(s));
                break;
            }
            case ID3_PropertyMap::ENC_GENRE_TYPE:
            {
                QString s = parseId3Frame2String(frame);
                int genre = Kwave::GenreType::fromID3(s);
                if (genre >= 0)
                    s = Kwave::GenreType::name(genre, false);
                info.set(property, QVariant(s));
                break;
            }
            case ID3_PropertyMap::ENC_LENGTH:
            {
                // length in ms -> convert this to samples
                QString       s    = parseId3Frame2String(frame);
                const double  rate = info.rate();
                bool          ok   = false;
                const double  ms   = s.toDouble(&ok) + 0.5;
                if (ok && (rate > 0)) {
                    // NOTE: this overwrites the length found in the header!
                    sample_index_t length = static_cast<sample_index_t>(
                        (rate * ms) / 1000.0);
                    info.setLength(length);
                }
                break;
            }
            case ID3_PropertyMap::ENC_TEXT_TIMESTAMP:
            {
                if (!creation_date.isValid()) {
                    QString s = parseId3Frame2String(frame);
                    switch (id)
                    {
                        case ID3FID_RECORDINGDATES:
                            // should be a ISO 8601 timestamp or similar
                            s = Kwave::string2date(s);
                            if (s.length())
                                creation_date =
                                    QDate::fromString(s, Qt::ISODate);
                            break;
                        case ID3FID_DATE: {
                            // DDMM
                            unsigned int ddmm = s.toUInt();
                            day   = ddmm / 100;
                            month = ddmm % 100;
                            break;
                        }
                        case ID3FID_YEAR: /* FALLTHROUGH */
                        case ID3FID_ORIGYEAR:
                            // YYYY
                            year = s.toUInt();
                            break;
                        default:
                            break;
                    }
                }

                if (creation_time.isValid()) {
                    switch (id)
                    {
                        case ID3FID_TIME:
                            creation_time = QTime::fromString(_("hhmm"));
                            break;
                        default:
                            break;
                    }
                }
                break;
            }
            case ID3_PropertyMap::ENC_TEXT_SLASH:
            {
                // append to already existing tag, separated by a slash
                QString s = parseId3Frame2String(frame);
                if (info.contains(property))
                    s = info.get(property).toString() + _(" / ") + s;
                info.set(property, QVariant(s));
                break;
            }
            case ID3_PropertyMap::ENC_TEXT_URL:   /* FALLTHROUGH */
            case ID3_PropertyMap::ENC_TEXT:
                info.set(property, QVariant(parseId3Frame2String(frame)));
                break;
            case ID3_PropertyMap::ENC_NONE: /* FALLTHROUGH */
            default:
            {
                QString s = parseId3Frame2String(frame);
                qWarning("unsupported ID3 tag: %d, descr: '%s', text: '%s'",
                         id, frame->GetDescription(), DBG(s));
                break;
            }
        }
    }

    /*
     * try to build a valid creation date/time
     */
    if (!creation_date.isValid()) {
        // no complete creation date - try to reassemble from found y/m/d
        creation_date = QDate(year, month, day);
    }
    if (creation_date.isValid() && creation_time.isValid()) {
        // full date + time
        QDateTime dt(creation_date, creation_time);
        info.set(Kwave::INF_CREATION_DATE, dt.toString(
            _("yyyy-MM-ddTHH:mm:ss")));
    } else if (creation_date.isValid()) {
        // date without time
        info.set(Kwave::INF_CREATION_DATE, creation_date.toString(
            _("yyyy-MM-dd")));
    } else if (year > 0) {
        // only year
        creation_date = QDate(year, 1, 1);
        info.set(Kwave::INF_CREATION_DATE, creation_date.toString(_("yyyy")));
    }

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

    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parseMp3Header()

bool Kwave::MP3Decoder::parseMp3Header ( const Mp3_Headerinfo &  header, QWidget *  widget  )

private

parse MP3 headers

Definition at line 78 of file MP3Decoder.cpp.

References _, Kwave::INF_BITRATE_NOMINAL, Kwave::INF_COMPRESSION, Kwave::INF_COPYRIGHTED, Kwave::INF_MPEG_EMPHASIS, Kwave::INF_MPEG_LAYER, Kwave::INF_MPEG_MODEEXT, Kwave::INF_MPEG_VERSION, Kwave::INF_ORIGINAL, Kwave::INF_PRIVATE, Kwave::Decoder::metaData(), Kwave::Compression::MPEG_LAYER_I, Kwave::Compression::MPEG_LAYER_II, Kwave::Compression::MPEG_LAYER_III, Kwave::MetaDataList::replace(), SAMPLE_BITS, Kwave::FileInfo::set(), Kwave::FileInfo::setBits(), Kwave::FileInfo::setLength(), Kwave::FileInfo::setRate(), Kwave::FileInfo::setTracks(), and Kwave::MessageBox::warningContinueCancel().

Referenced by open().

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

    /* first of all check CRC, it might be senseless if the file is broken */
    qDebug("crc = 0x%08X", header.crc);
    if ((header.crc == MP3CRC_MISMATCH) || (header.crc == MP3CRC_ERROR_SIZE)) {

        if (header.layer == MPEGLAYER_II) {
            qWarning("WARNING: file is MPEG layer II, CRC calculation "
                     "in id3lib is probably wrong - CRC check skipped");
        } else {
            if (Kwave::MessageBox::warningContinueCancel(widget,
                i18n("The file has an invalid checksum.\n"
                    "Do you still want to continue?"),
                    QString(), QString(), QString(),
                    _("accept_mp3_invalid_checksum"))
                        != KMessageBox::Continue) return false;
        }
    }

    /* MPEG layer */
    switch (header.layer) {
        case MPEGLAYER_I:
            info.set(Kwave::INF_COMPRESSION,
                     QVariant(Kwave::Compression::MPEG_LAYER_I));
            info.set(Kwave::INF_MPEG_LAYER, QVariant(1));
            break;
        case MPEGLAYER_II:
            info.set(Kwave::INF_COMPRESSION,
                     QVariant(Kwave::Compression::MPEG_LAYER_II));
            info.set(Kwave::INF_MPEG_LAYER, QVariant(2));
            break;
        case MPEGLAYER_III:
            info.set(Kwave::INF_COMPRESSION,
                     QVariant(Kwave::Compression::MPEG_LAYER_III));
            info.set(Kwave::INF_MPEG_LAYER, QVariant(3));
            break;
        default:
            qWarning("unknown mpeg layer '%d'", header.layer);
    }

    /* MPEG version */
    switch (header.version) {
        case MPEGVERSION_1:
            info.set(Kwave::INF_MPEG_VERSION, QVariant(1));
            break;
        case MPEGVERSION_2:
            info.set(Kwave::INF_MPEG_VERSION, QVariant(2));
            break;
        case MPEGVERSION_2_5:
            info.set(Kwave::INF_MPEG_VERSION, QVariant(2.5));
            break;
        default:
            qWarning("unknown mpeg version '%d'", header.version);
    }

    /* bit rate */
    if (header.bitrate > 0) info.set(Kwave::INF_BITRATE_NOMINAL,
        QVariant(header.bitrate));
    // NOTE: this is an enum value in libid3, but can also be treated
    // as unsigned integer without problems!

    /* channel mode */
    unsigned int tracks = 0;
    switch (header.channelmode) {
        case MP3CHANNELMODE_SINGLE_CHANNEL:
             tracks = 1;
             break;
        case MP3CHANNELMODE_STEREO:
             tracks = 2;
             break;
        case MP3CHANNELMODE_JOINT_STEREO:
             tracks = 2;
             break;
        case MP3CHANNELMODE_DUAL_CHANNEL:
             tracks = 2;
             break;
        default:
            QString mode;
            mode = mode.setNum(header.channelmode, 16);
            if (Kwave::MessageBox::warningContinueCancel(widget,
                i18n("The file contains an invalid channel mode 0x"
                     "%1\nAssuming Mono...", mode))
                     != KMessageBox::Continue) return false;
    }
    info.setTracks(tracks);

    /* MPEG Mode Extension */
    // only in "Joint Stereo" mode, then depends on Layer
    //
    // Layer I+II          |  Layer III
    //                     |  Intensity stereo MS Stereo
    //--------------------------------------------------
    // 0 - bands  4 to 31  |  off              off  -> 4
    // 1 - bands  8 to 31  |  on               off  -> 5
    // 2 - bands 12 to 31  |  off              on   -> 6
    // 3 - bands 16 to 31  |  on               on   -> 7
    if (header.channelmode == MP3CHANNELMODE_JOINT_STEREO) {
        int modeext = header.modeext;
        if (header.layer >= 3) modeext += 4;
        info.set(Kwave::INF_MPEG_MODEEXT, modeext);
    } else {
        int modeext = header.modeext;
        info.set(Kwave::INF_MPEG_MODEEXT, modeext);
    }

    /* Emphasis mode */
    // 0 = none
    // 1 = 50/15ms
    // 2 = reserved
    // 3 = CCIT J.17
    if (header.emphasis > 0)
        info.set(Kwave::INF_MPEG_EMPHASIS, header.emphasis);

//  qDebug("framesize=%d", header.framesize);
//  qDebug("frames = %u", header.frames);

    if (header.privatebit)  info.set(Kwave::INF_PRIVATE, header.privatebit);
    if (header.copyrighted) info.set(Kwave::INF_COPYRIGHTED, header.copyrighted);
    if (header.original)    info.set(Kwave::INF_ORIGINAL, header.original);

    info.setRate(header.frequency); // sample rate
    info.setBits(SAMPLE_BITS);      // fake Kwave's default resolution
    info.setLength(header.time * header.frequency);

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

    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

processOutput()

enum mad_flow Kwave::MP3Decoder::processOutput	(	void *	data,
		struct mad_header const *	header,
		struct mad_pcm *	pcm
	)

Calback for processing libmad's output

Definition at line 675 of file MP3Decoder.cpp.

References audio_linear_dither(), m_dest, SAMPLE_BITS, and Kwave::MultiTrackSink< SINK, INITIALIZE >::tracks().

Referenced by _output_adapter().

{
    static Kwave::audio_dither dither;
    qint32 sample;
    Kwave::SampleArray buffer(pcm->length);

    // loop over all tracks
    const unsigned int tracks = m_dest->tracks();
    for (unsigned int track = 0; track < tracks; ++track) {
        unsigned int nsamples = pcm->length;
        mad_fixed_t const *p = pcm->samples[track];
        unsigned int ofs = 0;

        // and render samples into Kwave's internal format
        while (nsamples--) {
            sample = static_cast<qint32>(audio_linear_dither(SAMPLE_BITS,
                     static_cast<mad_fixed_t>(*p++), &dither));
            buffer[ofs++] = static_cast<sample_t>(sample);
        }
        *(*m_dest)[track] << buffer;
    }

    return MAD_FLOW_CONTINUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_appended_bytes

size_t Kwave::MP3Decoder::m_appended_bytes

private

number of appended bytes / id3v1 tag

Definition at line 124 of file MP3Decoder.h.

Referenced by fillInput(), and open().

m_buffer

unsigned char* Kwave::MP3Decoder::m_buffer

private

buffer for libmad

Definition at line 115 of file MP3Decoder.h.

Referenced by fillInput(), handleError(), open(), and ~MP3Decoder().

m_buffer_size

int Kwave::MP3Decoder::m_buffer_size

private

size of m_buffer in bytes

Definition at line 118 of file MP3Decoder.h.

Referenced by fillInput(), and open().

m_dest

Kwave::MultiWriter* Kwave::MP3Decoder::m_dest

private

destination of the audio data

Definition at line 112 of file MP3Decoder.h.

Referenced by decode(), fillInput(), and processOutput().

m_failures

unsigned int Kwave::MP3Decoder::m_failures

private

number of failures

Definition at line 127 of file MP3Decoder.h.

Referenced by decode(), and handleError().

m_parent_widget

QWidget* Kwave::MP3Decoder::m_parent_widget

private

widget used for displaying error messages

Definition at line 130 of file MP3Decoder.h.

Referenced by decode(), and handleError().

m_prepended_bytes

size_t Kwave::MP3Decoder::m_prepended_bytes

private

number of prepended bytes / id3v2 tag

Definition at line 121 of file MP3Decoder.h.

Referenced by decode(), and open().

m_property_map

ID3_PropertyMap Kwave::MP3Decoder::m_property_map

private

property - to - ID3 mapping

Definition at line 106 of file MP3Decoder.h.

Referenced by parseID3Tags().

m_source

QIODevice* Kwave::MP3Decoder::m_source

private

source of the raw mp3 data

Definition at line 109 of file MP3Decoder.h.

Referenced by close(), decode(), fillInput(), open(), and ~MP3Decoder().

---

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

• plugins/codec_mp3/MP3Decoder.h
• plugins/codec_mp3/MP3Decoder.cpp