Kwave::WavDecoder Class Reference

#include <WavDecoder.h>

Inheritance diagram for Kwave::WavDecoder:

Collaboration diagram for Kwave::WavDecoder:

Public Member Functions
	WavDecoder ()
virtual	~WavDecoder () 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
bool	repair (QList< Kwave::RecoverySource *> *repair_list, Kwave::RIFFChunk *riff_chunk, Kwave::RIFFChunk *fmt_chunk, Kwave::RIFFChunk *data_chunk)
bool	repairChunk (QList< Kwave::RecoverySource *> *repair_list, Kwave::RIFFChunk *chunk, quint32 &offset)

Private Member Functions
void	addPropertyChunk (const Kwave::FileProperty property, const QByteArray &chunk_name)

Private Attributes
QIODevice *	m_source
Kwave::VirtualAudioFile *	m_src_adapter
QStringList	m_known_chunks
Kwave::WavPropertyMap	m_property_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 43 of file WavDecoder.h.

Constructor & Destructor Documentation

WavDecoder()

Kwave::WavDecoder::WavDecoder

(

)

Constructor

Definition at line 61 of file WavDecoder.cpp.

References _, Kwave::WavPropertyMap::chunks(), m_known_chunks, m_property_map, name, REGISTER_COMPRESSION_TYPES, and REGISTER_MIME_TYPES.

    :Kwave::Decoder(),
     m_source(Q_NULLPTR),
     m_src_adapter(Q_NULLPTR),
     m_known_chunks(),
     m_property_map()
{
    REGISTER_MIME_TYPES
    REGISTER_COMPRESSION_TYPES

    // native WAVE chunk names
    m_known_chunks.append(_("cue ")); /* Markers */
    m_known_chunks.append(_("data")); /* Sound Data */
    m_known_chunks.append(_("fact")); /* Fact (length in samples) */
    m_known_chunks.append(_("fmt ")); /* Format */
    m_known_chunks.append(_("inst")); /* Instrument */
    m_known_chunks.append(_("labl")); /* label */
    m_known_chunks.append(_("ltxt")); /* labeled text */
    m_known_chunks.append(_("note")); /* note chunk */
    m_known_chunks.append(_("plst")); /* Play List */
    m_known_chunks.append(_("smpl")); /* Sampler */

    // add all sub-chunks of the LIST chunk (properties)
    foreach (const QByteArray &name, m_property_map.chunks())
        m_known_chunks.append(QLatin1String(name));

    // some chunks known from AIFF format
    m_known_chunks.append(_("FVER"));
    m_known_chunks.append(_("COMM"));
    m_known_chunks.append(_("wave"));
    m_known_chunks.append(_("SSND"));

    // chunks of .lbm image files, IFF format
    m_known_chunks.append(_("BMHD"));
    m_known_chunks.append(_("CMAP"));
    m_known_chunks.append(_("BODY"));
}

Here is the call graph for this function:

~WavDecoder()

Kwave::WavDecoder::~WavDecoder ( )

virtual

Destructor

Definition at line 100 of file WavDecoder.cpp.

References close(), m_source, and m_src_adapter.

{
    if (m_source) close();
    if (m_src_adapter) delete m_src_adapter;
}

Here is the call graph for this function:

Member Function Documentation

addPropertyChunk()

void Kwave::WavDecoder::addPropertyChunk ( const Kwave::FileProperty  property, const QByteArray &  chunk_name  )

private

adds an entry to m_known_chunks and to m_property_map

close()

void Kwave::WavDecoder::close ( )

virtual

Closes the source.

Implements Kwave::Decoder.

Definition at line 808 of file WavDecoder.cpp.

References m_source, and m_src_adapter.

Referenced by ~WavDecoder().

{
    if (m_src_adapter) delete m_src_adapter;
    m_src_adapter = Q_NULLPTR;
    m_source = Q_NULLPTR;
}

Here is the caller graph for this function:

decode()

bool Kwave::WavDecoder::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 596 of file WavDecoder.cpp.

References Kwave::VirtualAudioFile::handle(), Kwave::MultiWriter::isCanceled(), Kwave::FileInfo::length(), m_source, m_src_adapter, Kwave::Decoder::metaData(), SAMPLE_BITS, SAMPLE_STORAGE_BITS, Kwave::toInt(), Kwave::toUint(), and Kwave::MultiTrackSink< SINK, INITIALIZE >::tracks().

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

    AFfilehandle fh = m_src_adapter->handle();
    Q_ASSERT(fh);
    if (!fh) return false;

//     info().dump();
    const unsigned int tracks = dst.tracks();

    // allocate an array of Writers, for speeding up
    QVector<Kwave::Writer *>writers(tracks);
    Q_ASSERT(writers.count() == Kwave::toInt(dst.tracks()));
    if (writers.count() != Kwave::toInt(dst.tracks())) return false;
    for (unsigned int t = 0; t < tracks; t++)
        writers[t] = dst[t];
    Kwave::Writer **writer_fast = writers.data();

    unsigned int frame_size = Kwave::toUint(
        afGetVirtualFrameSize(fh, AF_DEFAULT_TRACK, 1));

    // allocate a buffer for input data
    const unsigned int buffer_frames = (8 * 1024);
    sample_storage_t *buffer = static_cast<sample_storage_t *>(
        malloc(buffer_frames * frame_size));
    Q_ASSERT(buffer);
    if (!buffer) return false;

    // read in from the audiofile source
    Q_ASSERT(tracks == Kwave::FileInfo(metaData()).tracks());
    sample_index_t rest = Kwave::FileInfo(metaData()).length();
    while (rest) {
        unsigned int frames = buffer_frames;
        if (frames > rest) frames = Kwave::toUint(rest);
        unsigned int buffer_used = afReadFrames(fh,
            AF_DEFAULT_TRACK, reinterpret_cast<char *>(buffer), frames);

        // break if eof reached
        if (!buffer_used) break;
        rest -= buffer_used;

        // split into the tracks
        sample_storage_t *p = buffer;
        for (unsigned int count = buffer_used; count; count--) {
            for (unsigned int track = 0; track < tracks; track++) {
                sample_storage_t s = *p++;

                // adjust precision
                if (SAMPLE_STORAGE_BITS != SAMPLE_BITS) {
                    s /= (1 << (SAMPLE_STORAGE_BITS - SAMPLE_BITS));
                }

                // the following cast is only necessary if
                // sample_t is not equal to a sample_storage_t
                Q_ASSERT(writer_fast[track]);
                *(writer_fast[track]) << static_cast<sample_t>(s);
            }
        }

        // abort if the user pressed cancel
        if (dst.isCanceled()) break;
    }

    // return with a valid Signal, even if the user pressed cancel !
    if (buffer) free(buffer);
    return true;
}

Here is the call graph for this function:

instance()

Kwave::Decoder * Kwave::WavDecoder::instance ( )

virtual

Returns a new instance of the decoder

Implements Kwave::Decoder.

Definition at line 107 of file WavDecoder.cpp.

{
    return new Kwave::WavDecoder();
}

open()

bool Kwave::WavDecoder::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 113 of file WavDecoder.cpp.

References _, Kwave::min_wav_header_t::bitwidth, Kwave::min_wav_header_t::blockalign, Kwave::min_wav_header_t::bytespersec, Kwave::min_wav_header_t::channels, CHECK, Kwave::RIFFParser::chunkCount(), Kwave::connect(), Kwave::WavPropertyMap::containsChunk(), Kwave::RIFFChunk::dataLength(), Kwave::RIFFChunk::dataStart(), Kwave::SampleFormat::Double, Kwave::RIFFParser::dumpStructure(), Kwave::MessageBox::error(), Kwave::RIFFParser::findChunk(), Kwave::RIFFParser::findMissingChunk(), Kwave::WavFormatMap::findName(), Kwave::SampleFormat::Float, Kwave::min_wav_header_t::format, Kwave::Compression::fromAudiofile(), Kwave::VirtualAudioFile::handle(), Kwave::INF_COMPRESSION, Kwave::INF_SAMPLE_FORMAT, Kwave::RIFFParser::isSane(), Kwave::VirtualAudioFile::lastError(), Kwave::VirtualAudioFile::lastErrorText(), Kwave::RIFFChunk::length(), m_known_chunks, m_property_map, m_source, m_src_adapter, Kwave::Decoder::metaData(), Kwave::wav_fmt_header_t::min, Kwave::RIFFChunk::name(), name, Kwave::VirtualAudioFile::open(), Kwave::RIFFParser::parse(), Kwave::RIFFChunk::physLength(), Kwave::WavPropertyMap::property(), repair(), Kwave::RIFFParser::repair(), Kwave::MetaDataList::replace(), SAMPLE_STORAGE_BITS, Kwave::min_wav_header_t::samplerate, Kwave::FileInfo::set(), Kwave::FileInfo::setBits(), Kwave::FileInfo::setLength(), Kwave::FileInfo::setRate(), Kwave::FileInfo::setTracks(), Kwave::SampleFormat::Signed, Kwave::MessageBox::sorry(), Kwave::LabelList::sort(), Kwave::RIFFChunk::subChunks(), Kwave::Compression::toInt(), Kwave::toInt(), Kwave::LabelList::toMetaDataList(), Kwave::SampleFormat::Unknown, Kwave::SampleFormat::Unsigned, and Kwave::MessageBox::warningContinueCancel().

{
    Kwave::FileInfo info;
    Kwave::LabelList labels;
    metaData().clear();

    Q_ASSERT(!m_source);
    bool need_repair = false;
    if (m_source) qWarning("WavDecoder::open(), already open !");

    // try to open the source
    if (!src.open(QIODevice::ReadOnly)) {
        qWarning("failed to open source !");
        return false;
    }

    QStringList main_chunks;
    main_chunks.append(_("RIFF")); /* RIFF, little-endian */
    main_chunks.append(_("RIFX")); /* RIFF, big-endian */
    main_chunks.append(_("FORM")); /* used in AIFF, BE or IFF/.lbm */
    main_chunks.append(_("LIST")); /* additional information */
    main_chunks.append(_("adtl")); /* Associated Data */

    Kwave::RIFFParser parser(src, main_chunks, m_known_chunks);

    // prepare a progress dialog
    QProgressDialog progress(widget);
    progress.setWindowTitle(i18n("Auto Repair"));
    progress.setModal(true);
    progress.setMinimumDuration(0);
    progress.setMaximum(100);
    progress.setAutoClose(true);
    progress.setValue(0);
    progress.setLabelText(i18n("Reading..."));
    connect(&parser,   SIGNAL(progress(int)),
            &progress, SLOT(setValue(int)));
    connect(&parser,   SIGNAL(action(QString)),
            &progress, SLOT(setLabelText(QString)));
    Kwave::ConfirmCancelProxy confirm_cancel(widget,
                       &progress, SIGNAL(canceled()),
                       &parser,   SLOT(cancel()));

    // parse, including endianness detection
    parser.parse();
    progress.reset();
    if (progress.wasCanceled()) return false;

//     qDebug("--- RIFF file structure after first pass ---");
//     parser.dumpStructure();

    // check if there is a RIFF chunk at all...
    Kwave::RIFFChunk *riff_chunk = parser.findChunk("/RIFF:WAVE");
    Kwave::RIFFChunk *fact_chunk = parser.findChunk("/RIFF:WAVE/fact");
    Kwave::RIFFChunk *fmt_chunk  = parser.findChunk("/RIFF:WAVE/fmt ");
    Kwave::RIFFChunk *data_chunk = parser.findChunk("/RIFF:WAVE/data");

    if (!riff_chunk || !fmt_chunk || !data_chunk || !parser.isSane()) {
        if (Kwave::MessageBox::warningContinueCancel(widget,
            i18n("The file has been structurally damaged or "
                 "it is no WAV file.\n"
                 "Should Kwave try to repair it?"),
            i18n("Kwave Auto Repair"),
            i18n("&Repair")) != KMessageBox::Continue)
        {
            // user didn't let us try :-(
            return false;
        }

        need_repair = true;
    }

    // collect all missing chunks
    if (!riff_chunk) riff_chunk = parser.findMissingChunk("RIFF:WAVE");
    if (progress.wasCanceled()) return false;

    if (!fmt_chunk) {
        parser.findMissingChunk("fmt ");
        fmt_chunk = parser.findChunk("/RIFF:WAVE/fmt ");
        if (progress.wasCanceled()) return false;
        if (!fmt_chunk)  fmt_chunk  = parser.findChunk("fmt ");
        need_repair = true;
    }

    if (!data_chunk) {
        parser.findMissingChunk("data");
        data_chunk = parser.findChunk("/RIFF:WAVE/data");
        if (progress.wasCanceled()) return false;
        if (!data_chunk) data_chunk = parser.findChunk("data");
        need_repair = true;
    }

    // not everything found -> need heavy repair actions !
    if (!fmt_chunk || !data_chunk || need_repair) {
        qDebug("doing heavy repair actions...");
        parser.dumpStructure();
        parser.repair();
        parser.dumpStructure();
        if (progress.wasCanceled()) return false;

        if (!fmt_chunk)  fmt_chunk  = parser.findChunk("/RIFF:WAVE/fmt ");
        if (!fmt_chunk)  fmt_chunk  = parser.findChunk("/RIFF/fmt ");
        if (!fmt_chunk)  fmt_chunk  = parser.findChunk("fmt ");
        if (!data_chunk) data_chunk = parser.findChunk("/RIFF:WAVE/data");
        if (!data_chunk) data_chunk = parser.findChunk("/RIFF/data");
        if (!data_chunk) data_chunk = parser.findChunk("data");
        need_repair = true;
    }

    quint32 fmt_offset = 0;
    if (fmt_chunk) fmt_offset = fmt_chunk->dataStart();
//     qDebug("fmt chunk starts at 0x%08X", fmt_offset);

//     quint32 data_offset = 0;
    quint32 data_size = 0;
    if (data_chunk) {
//      data_offset = data_chunk->dataStart();
        data_size   = data_chunk->physLength();
//      qDebug("data chunk at 0x%08X (%u byte)", data_offset, data_size);
    }

    if (!data_size) {
        // hide progress bar, finally
        progress.hide();
        qApp->processEvents();

        // show final error message
        Kwave::MessageBox::sorry(widget,
            i18n("The opened file is no WAV file or it is damaged:\n"
            "There is not enough valid sound data.\n\n"
            "It makes no sense to continue now."));
        return false;
    }

    // WORKAROUND: if there is a fact chunk, it must not contain zero
    //             for the moment the only workaround known is to open
    //             such broken files in repair mode
    if (fact_chunk) {
        qint64 offset = fact_chunk->dataStart();
        union {
            quint32 len;
            char    bytes[4];
        } fact;
        fact.len = 0;
        src.seek(offset);
        src.read(&(fact.bytes[0]), 4);
        if ((fact.len == 0x00000000) || (fact.len == 0xFFFFFFFF)) {
            qWarning("WARNING: invalid 'fact' chunk content: 0x%08X "
                     "-> silent repair mode", fact.len);
            need_repair = true;
        }
    }

    // final check for structural integrity:
    // we should have exactly one RIFF, fmt and data chunk !
    if ((parser.chunkCount("fmt ") != 1) ||
        (parser.chunkCount("data") != 1))
    {
        // hide progress bar, temporarily
        progress.hide();
        qApp->processEvents();

        if (Kwave::MessageBox::warningContinueCancel(widget,
            i18n("The WAV file seems to be damaged:\n"
                 "Some chunks are duplicate or missing.\n\n"
                 "Kwave will only use the first ones and ignore\n"
                 "the rest. This might lead to loss of data.\n"
                 "If you want to get your file repaired completely,\n"
                 "please write an email to the Kwave mailing list\n"
                 "and we will help you."),
            i18n("Kwave Auto Repair")
            ) != KMessageBox::Continue)
        {
            // user decided to abort and repair on his own
            // good luck!
            return false;
        }
        need_repair = true;

        // show progress bar again
        progress.show();
        qApp->processEvents();
    }

    // source successfully opened
    m_source = &src;

    // read the wave header
    Kwave::wav_fmt_header_t header;

    unsigned int rate = 0;
    unsigned int bits = 0;

    src.seek(fmt_offset);

    // get the encoded block of data from the mime source
    CHECK(src.size() > static_cast<qint64>(sizeof(Kwave::wav_header_t) + 8));

    // get the header
    src.read(reinterpret_cast<char *>(&header), sizeof(Kwave::wav_fmt_header_t));
    header.min.format      = qFromLittleEndian<quint16>(header.min.format);
    header.min.channels    = qFromLittleEndian<quint16>(header.min.channels);
    header.min.samplerate  = qFromLittleEndian<quint32>(header.min.samplerate);
    header.min.bytespersec = qFromLittleEndian<quint32>(header.min.bytespersec);
    header.min.blockalign  = qFromLittleEndian<quint16>(header.min.blockalign);
    header.min.bitwidth    = qFromLittleEndian<quint16>(header.min.bitwidth);

    unsigned int tracks = header.min.channels;
    rate = header.min.samplerate;
    bits = header.min.bitwidth;

    Kwave::WavFormatMap known_formats;
    QString format_name = known_formats.findName(header.min.format);

//     qDebug("-------------------------");
//     qDebug("wav header:");
//     qDebug("format      = 0x%04X, (%s)", header.min.format,
//                                          DBG(format_name));
//     qDebug("channels    = %d", header.min.channels);
//     qDebug("rate        = %u", header.min.samplerate);
//     qDebug("bytes/s     = %u", header.min.bytespersec);
//     qDebug("block align = %d", header.min.blockalign);
//     qDebug("bits/sample = %d", header.min.bitwidth);
//     qDebug("-------------------------");

    // open the file through libaudiofile :)
    if (need_repair) {
        QList<Kwave::RecoverySource *> *repair_list =
            new QList<Kwave::RecoverySource *>();
        Q_ASSERT(repair_list);
        if (!repair_list) return false;

        Kwave::RIFFChunk *root = (riff_chunk) ? riff_chunk : parser.findChunk("");
//      parser.dumpStructure();
//      qDebug("riff chunk = %p, parser.findChunk('')=%p", riff_chunk,
//          parser.findChunk(""));
        repair(repair_list, root, fmt_chunk, data_chunk);
        m_src_adapter = new Kwave::RepairVirtualAudioFile(*m_source, repair_list);
    } else {
        m_src_adapter = new Kwave::VirtualAudioFile(*m_source);
    }

    Q_ASSERT(m_src_adapter);
    if (!m_src_adapter) return false;

    m_src_adapter->open(m_src_adapter, Q_NULLPTR);

    AFfilehandle fh = m_src_adapter->handle();
    if (!fh || (m_src_adapter->lastError() >= 0)) {
        QString reason;

        switch (m_src_adapter->lastError()) {
            case AF_BAD_NOT_IMPLEMENTED:
                reason = i18n("Format or function is not implemented") +
                         _("\n(") + format_name + _(")");
                break;
            case AF_BAD_MALLOC:
                reason = i18n("Out of memory");
                break;
            case AF_BAD_HEADER:
                reason = i18n("file header is damaged");
                break;
            case AF_BAD_CODEC_TYPE:
                reason = i18n("Invalid codec type") +
                         _("\n(") + format_name + _(")");
                break;
            case AF_BAD_OPEN:
                reason = i18n("Opening the file failed");
                break;
            case AF_BAD_READ:
                reason = i18n("Read access failed");
                break;
            case AF_BAD_SAMPFMT:
                reason = i18n("Invalid sample format");
                break;
            default:
                reason = i18n("internal libaudiofile error #%1: '%2'",
                    m_src_adapter->lastError(),
                    m_src_adapter->lastErrorText()
                );
        }

        QString text= i18n("An error occurred while opening the file:\n'%1'",
                            reason);
        Kwave::MessageBox::error(widget, text);

        return false;
    }

    AFframecount length = afGetFrameCount(fh, AF_DEFAULT_TRACK);
    tracks = afGetVirtualChannels(fh, AF_DEFAULT_TRACK);

    int af_sample_format;
    afGetVirtualSampleFormat(fh, AF_DEFAULT_TRACK, &af_sample_format,
        reinterpret_cast<int *>(&bits));
    if (static_cast<signed int>(bits) < 0) bits = 0;
    Kwave::SampleFormat::Format fmt;
    switch (af_sample_format)
    {
        case AF_SAMPFMT_TWOSCOMP:
            fmt = Kwave::SampleFormat::Signed;
            break;
        case AF_SAMPFMT_UNSIGNED:
            fmt = Kwave::SampleFormat::Unsigned;
            break;
        case AF_SAMPFMT_FLOAT:
            fmt = Kwave::SampleFormat::Float;
            break;
        case AF_SAMPFMT_DOUBLE:
            fmt = Kwave::SampleFormat::Double;
            break;
        default:
            fmt = Kwave::SampleFormat::Unknown;
            break;
    }

    int af_compression = afGetCompression(fh, AF_DEFAULT_TRACK);
    const Kwave::Compression compression(
        Kwave::Compression::fromAudiofile(af_compression)
    );

    info.setRate(rate);
    info.setBits(bits);
    info.setTracks(tracks);
    info.setLength(length);
    info.set(Kwave::INF_SAMPLE_FORMAT, Kwave::SampleFormat(fmt).toInt());
    info.set(Kwave::INF_COMPRESSION, compression.toInt());

    // read in all info from the LIST (INFO) chunk
    Kwave::RIFFChunk *info_chunk = parser.findChunk("/RIFF:WAVE/LIST:INFO");
    if (info_chunk) {
        // found info chunk !
        Kwave::RIFFChunkList &list = info_chunk->subChunks();
        foreach (Kwave::RIFFChunk *chunk, list) {
            if (!chunk) continue;
            if (!m_property_map.containsChunk(chunk->name())) continue;

            // read the content into a QString
            Kwave::FileProperty prop = m_property_map.property(chunk->name());
            unsigned int ofs = chunk->dataStart();
            unsigned int len = chunk->dataLength();
            QByteArray buffer(len + 1, 0x00);
            src.seek(ofs);
            src.read(buffer.data(), len);
            buffer[len] = 0;
            QString value;
            value = QString::fromUtf8(buffer);
            info.set(prop, value);
        }
    }

    // read in the Labels (cue list)
    Kwave::RIFFChunk *cue_chunk = parser.findChunk("/RIFF:WAVE/cue ");
    if (cue_chunk) {
        // found a cue list chunk !
        quint32 count;

        src.seek(cue_chunk->dataStart());
        src.read(reinterpret_cast<char *>(&count), 4);
        count = qFromLittleEndian<quint32>(count);
//      unsigned int length = cue_chunk->dataLength();
//      qDebug("cue list found: %u entries, %u bytes (should be: %u)",
//          count, length, count * (6 * 4) + 4);

        for (unsigned int i = 0; i < count; i++) {
            quint32 data, index, position;
            src.seek(cue_chunk->dataStart() + 4 + ((6 * 4) * i));
            /*
             * typedef struct {
             *     quint32 dwIdentifier; <- index
             *     quint32 dwPosition;   <- 0
             *     quint32 fccChunk;     <- 'data'
             *     quint32 dwChunkStart; <- 0
             *     quint32 dwBlockStart; <- 0
             *     quint32 dwSampleOffset; <- label.pos()
             * } cue_list_entry_t;
             */

            /* dwIdentifier */
            src.read(reinterpret_cast<char *>(&data), 4);
            index = qFromLittleEndian<quint32>(data);

            /* dwPosition (ignored) */
            src.read(reinterpret_cast<char *>(&data), 4);

            /* fccChunk */
            src.read(reinterpret_cast<char *>(&data), 4);
            /* we currently support only 'data' */
            if (qstrncmp(reinterpret_cast<const char *>(&data), "data", 4)) {
                qWarning("cue list entry %d refers to '%s', "
                         "which is not supported -> skipped",
                         index, QByteArray(
                         reinterpret_cast<const char *>(&data), 4).data());
                continue;
            }
            src.read(reinterpret_cast<char *>(&data), 4);
            /* dwChunkStart (must be 0) */
            if (data != 0) {
                qWarning("cue list entry %d has dwChunkStart != 0 -> skipped",
                         index);
                continue;
            }
            src.read(reinterpret_cast<char *>(&data), 4);
            /* dwBlockStart (must be 0) */
            if (data != 0) {
                qWarning("cue list entry %d has dwBlockStart != 0 -> skipped",
                         index);
                continue;
            }

            src.read(reinterpret_cast<char *>(&data), 4); /* dwSampleOffset */
            position = qFromLittleEndian<quint32>(data);

            // as we now have index and position, find out the name
            QByteArray name = "";
            Kwave::RIFFChunk *adtl_chunk =
                parser.findChunk("/RIFF:WAVE/LIST:adtl");
            if (adtl_chunk) {
                Kwave::RIFFChunk *labl_chunk = Q_NULLPTR;
                bool found = false;
                QListIterator<Kwave::RIFFChunk *> it(adtl_chunk->subChunks());
                while (it.hasNext()) {
                    quint32 labl_index;
                    labl_chunk = it.next();
                    /*
                     * typedef struct {
                     *     quint32 dwChunkID;    <- 'labl'
                     *     quint32 dwChunkSize;  (without padding !)
                     *     quint32 dwIdentifier; <- index
                     *     char    dwText[];       <- label->name()
                     * } label_list_entry_t;
                     */
                    if (labl_chunk->name() != "labl") continue;

                    data = 0;
                    src.seek(labl_chunk->dataStart());
                    src.read(reinterpret_cast<char *>(&data), 4); /* dwIdentifier */
                    labl_index = qFromLittleEndian<quint32>(data);
                    if (labl_index == index) {
                        found = true;
                        break; /* found it! */
                    }
                }
                if (found) {
                    Q_ASSERT(labl_chunk);
                    unsigned int len = labl_chunk->length();
                    if (len > 4) {
                        len -= 4;
                        name.resize(len);
                        src.seek(labl_chunk->dataStart() + 4);
                        src.read(static_cast<char *>(name.data()), len);
                        if (name[name.count() - 1] != '\0')
                            name += '\0';
                    }
                }
            }

            if (!name.length()) {
//              qDebug("cue list entry %d has no name", index);
                name = "";
            }

            // put a new label into the list
            QString str = QString::fromUtf8(name);
            labels.append(Kwave::Label(position, str));
        }
    }
    labels.sort();
    metaData().replace(Kwave::MetaDataList(info));
    metaData().replace(labels.toMetaDataList());

    // set up libaudiofile to produce Kwave's internal sample format
#if Q_BYTE_ORDER == Q_BIG_ENDIAN
    afSetVirtualByteOrder(fh, AF_DEFAULT_TRACK, AF_BYTEORDER_BIGENDIAN);
#else
    afSetVirtualByteOrder(fh, AF_DEFAULT_TRACK, AF_BYTEORDER_LITTLEENDIAN);
#endif
    afSetVirtualSampleFormat(fh, AF_DEFAULT_TRACK,
        AF_SAMPFMT_TWOSCOMP, SAMPLE_STORAGE_BITS);

    return true;
}

Here is the call graph for this function:

repair()

bool Kwave::WavDecoder::repair ( QList< Kwave::RecoverySource *> *  repair_list, Kwave::RIFFChunk *  riff_chunk, Kwave::RIFFChunk *  fmt_chunk, Kwave::RIFFChunk *  data_chunk  )

protected

Fix all inconsistencies and create a repar list.

Definition at line 737 of file WavDecoder.cpp.

References Kwave::RIFFChunk::Empty, Kwave::RIFFChunk::fixSize(), Kwave::RIFFChunk::Garbage, Kwave::RIFFChunk::Main, Kwave::RIFFChunk::name(), Kwave::RIFFChunk::physLength(), Kwave::RIFFChunk::physStart(), repairChunk(), Kwave::RIFFChunk::setType(), Kwave::RIFFChunk::subChunks(), and Kwave::RIFFChunk::type().

Referenced by open(), and repairChunk().

{
    Q_ASSERT(fmt_chunk);
    Q_ASSERT(data_chunk);
    if (!fmt_chunk || !data_chunk) return false;

    // --- first create a chunk tree for the structure ---

    // make a new "RIFF" chunk as root
    Kwave::RIFFChunk new_root(Q_NULLPTR, "RIFF", "WAVE", 0,0,0);
    new_root.setType(Kwave::RIFFChunk::Main);

    // create a new "fmt " chunk
    Kwave::RIFFChunk *new_fmt = new(std::nothrow)
        Kwave::RIFFChunk(&new_root, "fmt ",Q_NULLPTR, 0,
        fmt_chunk->physStart(), fmt_chunk->physLength());
    Q_ASSERT(new_fmt);
    if (!new_fmt) return false;
    new_root.subChunks().append(new_fmt);

    // create a new "data" chunk
    Kwave::RIFFChunk *new_data =
        new Kwave::RIFFChunk(&new_root, "data", Q_NULLPTR, 0,
        data_chunk->physStart(), data_chunk->physLength());
    Q_ASSERT(new_data);
    if (!new_data) return false;
    new_root.subChunks().append(new_data);

    // if we have a RIFF chunk, add it's subchunks, except "fmt " and "data"
    // we keep only pointers here, just for getting the right structure,
    // sizes and start positions.
    // NOTE: The sizes might be re-assigned and get invalid afterwards!!!
    if (riff_chunk) {
        Kwave::RIFFChunkList &list = riff_chunk->subChunks();
        foreach (Kwave::RIFFChunk *chunk, list) {
            if (!chunk) continue;
            if (chunk->name() == "fmt ") continue;
            if (chunk->name() == "data") continue;
            if (chunk->name() == "RIFF") continue;
            if (chunk->type() == Kwave::RIFFChunk::Empty) continue;
            if (chunk->type() == Kwave::RIFFChunk::Garbage) continue;

            new_root.subChunks().append(chunk);
        }
    }

    // fix all node sizes (compress)
    new_root.fixSize();

    // attention: some of the offsets belong to source file, some belong
    // to reconstructed buffers! only the sizes are correct.
//    new_root.dumpStructure();

    // --- set up the repair list ---

    // RIFF chunk length
    quint32 offset = 0;
    bool repaired = repairChunk(repair_list, &new_root, offset);

    // clean up...
    new_root.subChunks().clear();
    delete new_fmt;
    delete new_data;

    return (repaired);
}

Here is the call graph for this function:

Here is the caller graph for this function:

repairChunk()

bool Kwave::WavDecoder::repairChunk ( QList< Kwave::RecoverySource *> *  repair_list, Kwave::RIFFChunk *  chunk, quint32 &  offset  )

protected

Adds a chunk to a repair list

Definition at line 669 of file WavDecoder.cpp.

References Kwave::RIFFChunk::dataLength(), Kwave::RIFFChunk::dataStart(), Kwave::RIFFChunk::format(), m_source, Kwave::RIFFChunk::Main, Kwave::RIFFChunk::name(), Kwave::RIFFChunk::physLength(), repair(), Kwave::RIFFChunk::Root, Kwave::RIFFChunk::subChunks(), and Kwave::RIFFChunk::type().

Referenced by repair().

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

    char buffer[16];
    quint32 length;
    Kwave::RecoverySource *repair = Q_NULLPTR;

    // create buffer with header
    strncpy(buffer, chunk->name().data(), 4);
    length = (chunk->type() == Kwave::RIFFChunk::Main) ? chunk->physLength() :
                                                         chunk->dataLength();
    buffer[4] = (length      ) & 0xFF;
    buffer[5] = (length >>  8) & 0xFF;
    buffer[6] = (length >> 16) & 0xFF;
    buffer[7] = (length >> 24) & 0xFF;
    if (chunk->type() == Kwave::RIFFChunk::Main) {
        strncpy(&(buffer[8]), chunk->format().data(), 4);
        repair = new Kwave::RecoveryBuffer(offset, 12, buffer);
        qDebug("[0x%08X-0x%08X] - main header '%s' (%s), len=%u",
              offset, offset+11, chunk->name().data(),
              chunk->format().data(), length);
        offset += 12;
    } else {
        repair = new Kwave::RecoveryBuffer(offset, 8, buffer);
        qDebug("[0x%08X-0x%08X] - sub header '%s', len=%u",
              offset, offset+7, chunk->name().data(), length);
        offset += 8;
    }
    Q_ASSERT(repair);
    if (!repair) return false;
    repair_list->append(repair);

    // map the chunk's data if not main or root
    if ((chunk->type() != Kwave::RIFFChunk::Root) &&
        (chunk->type() != Kwave::RIFFChunk::Main))
    {
        repair = new Kwave::RecoveryMapping(offset, chunk->physLength(),
                                            *m_source, chunk->dataStart());
        qDebug("[0x%08X-0x%08X] - restoring from offset 0x%08X (%u)",
              offset, offset+chunk->physLength()-1, chunk->dataStart(),
              chunk->physLength());
        Q_ASSERT(repair);
        if (!repair) return false;
        repair_list->append(repair);

        offset += chunk->physLength();
    }

    // recursively go over all sub-chunks
    Kwave::RIFFChunkList &list = chunk->subChunks();
    foreach (Kwave::RIFFChunk *c, list) {
        if (!c) continue;
        if (!repairChunk(repair_list, c, offset))
            return false;
    }

    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_known_chunks

QStringList Kwave::WavDecoder::m_known_chunks

private

list of all known chunk names

Definition at line 111 of file WavDecoder.h.

Referenced by open(), and WavDecoder().

m_property_map

Kwave::WavPropertyMap Kwave::WavDecoder::m_property_map

private

map for translating chunk names to FileInfo properties

Definition at line 114 of file WavDecoder.h.

Referenced by open(), and WavDecoder().

m_source

QIODevice* Kwave::WavDecoder::m_source

private

source of the audio data

Definition at line 105 of file WavDecoder.h.

Referenced by close(), decode(), open(), repairChunk(), and ~WavDecoder().

m_src_adapter

Kwave::VirtualAudioFile* Kwave::WavDecoder::m_src_adapter

private

adapter for libaudiofile

Definition at line 108 of file WavDecoder.h.

Referenced by close(), decode(), open(), and ~WavDecoder().

---

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

• plugins/codec_wav/WavDecoder.h
• plugins/codec_wav/WavDecoder.cpp