Kwave::RIFFParser Class Reference

#include <RIFFParser.h>

Inheritance diagram for Kwave::RIFFParser:

Collaboration diagram for Kwave::RIFFParser:

Public Slots
void	cancel ()

Signals
void	action (const QString &name)
void	progress (int percent)

Public Member Functions
	RIFFParser (QIODevice &device, const QStringList &main_chunks, const QStringList &known_subchunks)
virtual	~RIFFParser ()
bool	parse ()
bool	parse (Kwave::RIFFChunk *parent, quint32 offset, quint32 length)
bool	isSane ()
void	dumpStructure ()
Kwave::RIFFChunk *	findChunk (const QByteArray &path)
unsigned int	chunkCount (const QByteArray &path)
Kwave::RIFFChunk *	findMissingChunk (const QByteArray &name)
void	repair ()

Protected Member Functions
QByteArray	read4ByteString (qint64 offset)
Kwave::RIFFChunk::ChunkType	guessType (const QByteArray &name)
bool	isValidName (const char *name)
bool	isKnownName (const QByteArray &name)
void	detectEndianness ()
Kwave::RIFFChunk *	addChunk (Kwave::RIFFChunk *parent, const QByteArray &name, const QByteArray &format, quint32 length, quint32 phys_offset, quint32 phys_length, Kwave::RIFFChunk::ChunkType type)
bool	addGarbageChunk (Kwave::RIFFChunk *parent, quint32 offset, quint32 length)
bool	addEmptyChunk (Kwave::RIFFChunk *parent, const QByteArray &name, quint32 offset)
void	listAllChunks (Kwave::RIFFChunk &parent, Kwave::RIFFChunkList &list)
Kwave::RIFFChunk *	chunkAt (quint32 offset)
QList< quint32 >	scanForName (const QByteArray &name, quint32 offset, quint32 length, int progress_start=0, int progress_count=1)

Private Member Functions
void	collectGarbage ()
bool	joinGarbageToEmpty ()
void	fixGarbageEnds ()
void	discardGarbage (Kwave::RIFFChunk &chunk)

Private Attributes
QIODevice &	m_dev
Kwave::RIFFChunk	m_root
QStringList	m_main_chunk_names
QStringList	m_sub_chunk_names
Kwave::byte_order_t	m_endianness
bool	m_cancel

Detailed Description

Definition at line 38 of file RIFFParser.h.

Constructor & Destructor Documentation

RIFFParser()

Kwave::RIFFParser::RIFFParser	(	QIODevice &	device,
		const QStringList &	main_chunks,
		const QStringList &	known_subchunks
	)

Constructor.

Parameters

device	QIODevice to parse through.
main_chunks	list of known names of main chunks
known_subchunks	list of known subchunks

Definition at line 58 of file RIFFParser.cpp.

References m_root, Kwave::RIFFChunk::Root, and Kwave::RIFFChunk::setType().

    :m_dev(device),
     m_root(Q_NULLPTR, "", "", toUint32(device.size()), 0,
            toUint32(device.size())),
     m_main_chunk_names(main_chunks), m_sub_chunk_names(known_subchunks),
     m_endianness(Kwave::UnknownEndian), m_cancel(false)
{
    m_root.setType(Kwave::RIFFChunk::Root);
}

Here is the call graph for this function:

~RIFFParser()

Kwave::RIFFParser::~RIFFParser ( )

virtual

Destructor

Definition at line 71 of file RIFFParser.cpp.

{
}

Member Function Documentation

action

void Kwave::RIFFParser::action ( const QString &  name )

signal

emits the name of the currently performed action

Referenced by detectEndianness(), and findMissingChunk().

Here is the caller graph for this function:

addChunk()

Kwave::RIFFChunk * Kwave::RIFFParser::addChunk ( Kwave::RIFFChunk *  parent, const QByteArray &  name, const QByteArray &  format, quint32  length, quint32  phys_offset, quint32  phys_length, Kwave::RIFFChunk::ChunkType  type  )

protected

Creates and adds a new chunk. Will be parented to the first non-garbage chunk.

Parameters

parent	pointer to the parent node (or null if root node)
name	the 4-byte name of the chunk
format	the 4-byte format specifier, only valid for main chunks, contains invalid data in sub-chunks
length	size of the chunk's data
phys_offset	start of the chunk name in the source
phys_length	length allocated in the source (file)
type	chunk type,

See also

RIFFChunk::ChunkType

Returns

pointer to the new created chunk

Definition at line 235 of file RIFFParser.cpp.

References Kwave::RIFFChunk::Garbage, m_root, Kwave::RIFFChunk::parent(), Kwave::RIFFChunk::physStart(), Kwave::RIFFChunk::setType(), Kwave::RIFFChunk::subChunks(), and Kwave::RIFFChunk::type().

Referenced by addEmptyChunk(), addGarbageChunk(), and parse().

{
    // do not add anything to garbage, use the garbage's parent instead
    while (parent && (parent->type() == Kwave::RIFFChunk::Garbage)) {
        parent = parent->parent();
    }

    // if no parent found, use root
    if (!parent) {
        parent = &m_root;
    }
    Q_ASSERT(parent);

    // create a new chunk object
    Kwave::RIFFChunk *chunk = new Kwave::RIFFChunk(
        parent, name, format, length, phys_offset, phys_length);
    Q_ASSERT(chunk);
    if (!chunk) return Q_NULLPTR;
    chunk->setType(type);

    // sort the chunk into the parent, order by physical start
    Kwave::RIFFChunk *before = Q_NULLPTR;
    Kwave::RIFFChunkList &chunks = parent->subChunks();
    foreach (Kwave::RIFFChunk *c, chunks) {
        if (!c) continue;
        quint32 pos = c->physStart();
        if (pos > phys_offset) {
            before = c;
            break;
        }
    }

    int index = (before) ? chunks.indexOf(before) : chunks.size();
    chunks.insert(index, chunk);

    return chunk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

addEmptyChunk()

bool Kwave::RIFFParser::addEmptyChunk ( Kwave::RIFFChunk *  parent, const QByteArray &  name, quint32  offset  )

protected

Adds a chunk with a valid name and no length information.

Parameters

parent	pointer to the parent node
name	the valid name of the chunk
offset	start of the chunk name in the source

Returns

true if creation succeeded, false if out of memory

Definition at line 293 of file RIFFParser.cpp.

References addChunk(), and Kwave::RIFFChunk::Empty.

Referenced by parse().

{
    // create the new chunk first
    Kwave::RIFFChunk *chunk = addChunk(parent, name, "----", 0, offset,
            0, Kwave::RIFFChunk::Empty);
    return (chunk);
}

Here is the call graph for this function:

Here is the caller graph for this function:

addGarbageChunk()

bool Kwave::RIFFParser::addGarbageChunk ( Kwave::RIFFChunk *  parent, quint32  offset, quint32  length  )

protected

Adds a chunk that has no valid name and thus is not recognized. It is assumed that it only contains undecodeable garbage without any valid name, length or other header information.

Parameters

parent	pointer to the parent node
offset	start of the chunk name in the source
length	length of the garbage area in bytes

Returns

true if creation succeeded, false if out of memory

Definition at line 278 of file RIFFParser.cpp.

References addChunk(), Kwave::RIFFChunk::Garbage, and name.

Referenced by parse().

{
    qDebug("adding garbage chunk at 0x%08X, length=%u",offset,length);

    // create the new chunk first
    QByteArray name(16, 0);
    qsnprintf(name.data(), name.size(), "[0x%08X]", offset);
    Kwave::RIFFChunk *chunk = addChunk(parent, name, "", length, offset,
                                length, Kwave::RIFFChunk::Garbage);
    return (chunk);
}

Here is the call graph for this function:

Here is the caller graph for this function:

cancel

void Kwave::RIFFParser::cancel ( )

slot

Cancels the current action.

Definition at line 816 of file RIFFParser.cpp.

References m_cancel.

{
    qDebug("RIFFParser: --- cancel ---");
    m_cancel = true;
}

chunkAt()

Kwave::RIFFChunk * Kwave::RIFFParser::chunkAt ( quint32  offset )

protected

Returns a pointer to a chunk that starts at a given offset or zero if none found.

Parameters

offset

the start position (physical start)

Returns

pointer to the chunk or zero

Definition at line 534 of file RIFFParser.cpp.

References listAllChunks(), m_root, and Kwave::RIFFChunk::physStart().

Referenced by parse().

{
    Kwave::RIFFChunkList list;
    listAllChunks(m_root, list);
    foreach (Kwave::RIFFChunk *chunk, list)
        if (chunk && chunk->physStart() == offset) return chunk;
        return Q_NULLPTR;
}

Here is the call graph for this function:

Here is the caller graph for this function:

chunkCount()

unsigned int Kwave::RIFFParser::chunkCount

(

const QByteArray &

path

)

Returns the number of times a chunk is present

Definition at line 463 of file RIFFParser.cpp.

References listAllChunks(), m_root, Kwave::RIFFChunk::name(), and Kwave::RIFFChunk::path().

Referenced by Kwave::WavDecoder::open().

{
    unsigned int count = 0;
    Kwave::RIFFChunkList chunks;
    listAllChunks(m_root, chunks);

    foreach (Kwave::RIFFChunk *chunk, chunks) {
        if (!chunk) continue;
        if (path.contains("/")) {
            // search for full path
            if (chunk->path() == path) ++count;
        } else {
            // search for name only
            if (chunk->name() == path) ++count;
        }
    }

    return count;
}

Here is the call graph for this function:

Here is the caller graph for this function:

collectGarbage()

void Kwave::RIFFParser::collectGarbage ( )

private

clear all main chunks that contain only garbage and convert them into garbage chunks

Definition at line 632 of file RIFFParser.cpp.

References Kwave::RIFFChunk::Garbage, listAllChunks(), m_cancel, m_root, Kwave::RIFFChunk::physEnd(), Kwave::RIFFChunk::physStart(), Kwave::RIFFChunk::setLength(), Kwave::RIFFChunk::setType(), Kwave::RIFFChunk::subChunks(), and Kwave::RIFFChunk::type().

Referenced by repair().

{
    // clear all main chunks that contain only garbage and convert them
    // into garbage chunks
    bool start_over;
    do {
        start_over = false;
        Kwave::RIFFChunkList chunks;
        listAllChunks(m_root, chunks);

        foreach (Kwave::RIFFChunk *chunk, chunks) {
            if (!chunk) continue;
            if (start_over || m_cancel) break;

            // skip garbage chunks themselfes
            if (chunk->type() == Kwave::RIFFChunk::Garbage) continue;

            Kwave::RIFFChunkList &subchunks = chunk->subChunks();
            bool contains_only_garbage = true;
            foreach (Kwave::RIFFChunk *sub, subchunks) {
                if (m_cancel) break;
                if (sub && (sub->type() != Kwave::RIFFChunk::Garbage)) {
                    contains_only_garbage = false;
                    break;
                }
            }

            if (subchunks.count() && contains_only_garbage) {
                quint32 start = chunk->physStart();
                quint32 end   = chunk->physEnd();

                qDebug("chunk at 0x%08X contains only garbage!", start);
                // -> convert into a garbage chunk !
                chunk->setType(Kwave::RIFFChunk::Garbage);
                chunk->setLength(end - start + 4 + 1);
                while (!subchunks.isEmpty()) {
                    Kwave::RIFFChunk *c = subchunks.takeLast();
                    if (c) delete c;
                }
                chunks.clear();

                // start over the scan...
                start_over = true;
                break;
            }
        }
    } while (start_over && !m_cancel);
}

Here is the call graph for this function:

Here is the caller graph for this function:

detectEndianness()

void Kwave::RIFFParser::detectEndianness ( )

protected

Tries to detect the endianness of the source. If successful, the endianness will be set. If failed, will be set to "Unknown".

Definition at line 107 of file RIFFParser.cpp.

References _, action(), Kwave::BigEndian, Kwave::LittleEndian, m_cancel, m_dev, m_endianness, m_main_chunk_names, m_root, m_sub_chunk_names, name, Kwave::RIFFChunk::physLength(), Kwave::RIFFChunk::physStart(), progress(), read4ByteString(), scanForName(), and Kwave::UnknownEndian.

Referenced by parse().

{
    // first try the easy way, works if file is sane
    QString sane_name = QLatin1String(read4ByteString(0));
    if (sane_name == _("RIFF")) {
        m_endianness = LittleEndian;
        return;
    }
    if (sane_name == _("RIFX")) {
        m_endianness = Kwave::BigEndian;
        return;
    }

    // ok, our file is damaged at least a bit, try to discover
    emit action(i18n("Detecting endianness (standard search)..."));
    emit progress(0);

    QList<quint32> riff_offsets = scanForName("RIFF",
        m_root.physStart(), m_root.physLength(), 0, 2);
    if (m_cancel) return;

    QList<quint32> rifx_offsets = scanForName("RIFX",
        m_root.physStart(), m_root.physLength(), 1, 2);
    if (m_cancel) return;

    // if RIFF found and RIFX not found -> little endian
    if (riff_offsets.count() && !rifx_offsets.count()) {
        qDebug("detected little endian format");
        m_endianness = LittleEndian;
        emit progress(100);
        return;
    }

    // if RIFX found and RIFF not found -> big endian
    if (rifx_offsets.count() && !riff_offsets.count()) {
        qDebug("detected big endian format");
        m_endianness = Kwave::BigEndian;
        emit progress(100);
        return;
    }

    // not detectable -> detect by searching all known chunks and
    // detect best match
    emit action(i18n("Detecting endianness (statistic search)..."));
    qDebug("doing statistic search to determine endianness...");
    unsigned int le_matches = 0;
    unsigned int be_matches = 0;
    QStringList names;
    names += m_main_chunk_names;
    names += m_sub_chunk_names;

    // average length should be approx. half of file size
    double half = (m_dev.size() >> 1);

    // loop over all chunk names
    int count = names.count();
    int index = 0;
    foreach (QString chunk_name, names) {
        // scan all offsets where the name matches
        QByteArray name = chunk_name.toLatin1();
        QList<quint32> offsets = scanForName(name,
            m_root.physStart(), m_root.physLength(),
            index, count);
        if (m_cancel) return;

        // loop over all found offsets
        foreach (quint32 ofs, offsets) {
            m_dev.seek(ofs + 4);

            // read length, assuming little endian
            quint32 len = 0;
            m_dev.read(reinterpret_cast<char *>(&len), 4);
            double dist_le = fabs(half - qFromLittleEndian<quint32>(len));
            double dist_be = fabs(half - qFromBigEndian<quint32>(len));

            // evaluate distance to average length
            if (dist_be > dist_le) ++le_matches;
            if (dist_le > dist_be) ++be_matches;
        }

        emit progress(100 * (++index) / count);
    }
    qDebug("big endian matches:    %u", be_matches);
    qDebug("little endian matches: %u", le_matches);

    if (le_matches > be_matches) {
        qDebug("assuming little endian");
        m_endianness = Kwave::LittleEndian;
    } else if (be_matches > le_matches) {
        qDebug("assuming big endian");
        m_endianness = Kwave::BigEndian;
    } else {
        // give up :-(
        qDebug("unable to determine endianness");
        m_endianness = Kwave::UnknownEndian;
    }

    emit progress(100);
}

Here is the call graph for this function:

Here is the caller graph for this function:

discardGarbage()

void Kwave::RIFFParser::discardGarbage ( Kwave::RIFFChunk &  chunk )

private

Discards all garbage sub-chunks

Definition at line 796 of file RIFFParser.cpp.

References Kwave::RIFFChunk::Garbage, m_cancel, Kwave::RIFFChunk::subChunks(), and Kwave::RIFFChunk::type().

Referenced by repair().

{
    QMutableListIterator<Kwave::RIFFChunk *> it(chunk.subChunks());
    while (it.hasNext()) {
        Kwave::RIFFChunk *ch = it.next();
        if (m_cancel) break;
        if (!ch) continue;
        if (ch->type() == Kwave::RIFFChunk::Garbage) {
            // garbage found -> deleting it
            it.remove();
            delete ch;
        } else {
            // recursively delete garbage
            discardGarbage(*ch);
        }
    }

}

Here is the call graph for this function:

Here is the caller graph for this function:

dumpStructure()

void Kwave::RIFFParser::dumpStructure

(

)

Dumps the structure of all chunks, useful for debugging.

Definition at line 431 of file RIFFParser.cpp.

References Kwave::RIFFChunk::dumpStructure(), and m_root.

Referenced by Kwave::WavDecoder::open().

{
    m_root.dumpStructure();
}

Here is the call graph for this function:

Here is the caller graph for this function:

findChunk()

Kwave::RIFFChunk * Kwave::RIFFParser::findChunk

(

const QByteArray &

path

)

Tries to find a chunk in the tree of parsed chunks, only accepting a full match.

Parameters

path	the full path of the chunk to be searched

Returns

the found chunk or zero if nothing found

Definition at line 443 of file RIFFParser.cpp.

References listAllChunks(), m_root, Kwave::RIFFChunk::name(), and Kwave::RIFFChunk::path().

Referenced by Kwave::WavDecoder::open().

{
    Kwave::RIFFChunkList chunks;
    listAllChunks(m_root, chunks);

    foreach (Kwave::RIFFChunk *chunk, chunks) {
        if (!chunk) continue;
        if (path.contains("/")) {
            // search for full path
            if (chunk->path() == path) return chunk;
        } else {
            // search for name only
            if (chunk->name() == path) return chunk;
        }
    }

    return Q_NULLPTR;
}

Here is the call graph for this function:

Here is the caller graph for this function:

findMissingChunk()

Kwave::RIFFChunk * Kwave::RIFFParser::findMissingChunk

(

const QByteArray &

name

)

Tries very hard to find a missing chunk by stepping through the whole file or source.

Parameters

name	the 4-byte name of the chunk

Returns

the found chunk or zero if nothing found

Definition at line 544 of file RIFFParser.cpp.

References action(), Kwave::RIFFChunk::Garbage, listAllChunks(), m_cancel, m_root, parse(), Kwave::RIFFChunk::physEnd(), Kwave::RIFFChunk::physLength(), Kwave::RIFFChunk::physStart(), progress(), scanForName(), and Kwave::RIFFChunk::type().

Referenced by Kwave::WavDecoder::open().

{
    emit action(i18n("Searching for missing chunk '%1'...",
                QLatin1String(name)));
    emit progress(0);

    bool found_something = false;

    // first search in all garbage areas
    Kwave::RIFFChunkList all_chunks;
    listAllChunks(m_root, all_chunks);

    int index = 0;
    int count = all_chunks.count();
    foreach (Kwave::RIFFChunk *chunk, all_chunks) {
        if (m_cancel) break;
        if (!chunk) continue;
        if (chunk->type() == Kwave::RIFFChunk::Garbage) {
            // search for the name
            qDebug("searching in garbage at 0x%08X", chunk->physStart());
            QList<quint32> offsets = scanForName(name,
                chunk->physStart(), chunk->physLength(),
                index, count);
            if (offsets.count()) found_something = true;

            // process the results -> convert them into chunks
            quint32 end = chunk->physEnd();
            foreach (quint32 pos, offsets) {
                if (m_cancel) break;
                quint32 len = end - pos + 1;
                qDebug("found at [0x%08X...0x%08X] len=%u", pos, end, len);
                parse(chunk, pos, len);
                qDebug("-------------------------------");
            }
        }
        ++index;
    }

    // not found in garbage? search over the rest of the file"
    if (!found_something && !m_cancel) {
        qDebug("brute-force search from 0x%08X to 0x%08X",
            0, m_root.physEnd());
        QList<quint32> offsets = scanForName(name, 0, m_root.physLength());

        // process the results -> convert them into chunks
        quint32 end = m_root.physEnd();
        foreach (quint32 pos, offsets) {
            if (m_cancel) break;
            quint32 len = end - pos + 1;
            qDebug("found at [0x%08X...0x%08X] len=%u", pos, end, len);
            parse(&m_root, pos, len);
            qDebug("-------------------------------");
        }
    }

    return Q_NULLPTR;
}

Here is the call graph for this function:

Here is the caller graph for this function:

fixGarbageEnds()

void Kwave::RIFFParser::fixGarbageEnds ( )

private

fixes the end of garbage chunks to no longer overlap valid chunks

Definition at line 682 of file RIFFParser.cpp.

References Kwave::RIFFChunk::Garbage, Kwave::RIFFChunk::isChildOf(), listAllChunks(), m_cancel, m_root, Kwave::RIFFChunk::name(), Kwave::RIFFChunk::physEnd(), Kwave::RIFFChunk::physStart(), Kwave::RIFFChunk::setLength(), and Kwave::RIFFChunk::type().

Referenced by repair().

{
    qDebug("fixing ends of garbage chunks...");

    Kwave::RIFFChunkList chunks;
    listAllChunks(m_root, chunks);
    QListIterator<Kwave::RIFFChunk *> it1(chunks);
    QListIterator<Kwave::RIFFChunk *> it2(chunks);

    // try all combinations of chunks
    if (it1.hasNext()) it1.next();
    while (it1.hasNext() && !m_cancel) {
        Kwave::RIFFChunk *c1 = it1.next();
        it2 = it1;
        if (it2.hasNext()) it2.next();
        while (it2.hasNext() && !m_cancel) {
            Kwave::RIFFChunk *c2 = it2.next();

            // children always overlap their parents
            if (c2->isChildOf(c1)) continue;

            // get ranges
            quint32 s1 = c1->physStart();
            quint32 e1 = c1->physEnd();
            quint32 s2 = c2->physStart();
            quint32 e2 = c2->physEnd();

            // check for overlaps
            if ((s2 <= e1) && (e2 >= s1)) {
                qDebug("overlap detected:");
                qDebug("    at 0x%08X...0x%08X '%s'",
                    s1, e1, c1->name().data());
                qDebug("    at 0x%08X...0x%08X '%s'",
                    s2, e2, c2->name().data());

                if ((c1->type() == Kwave::RIFFChunk::Garbage) && (s1 < s2)) {
                    // shorten garbage
                    e1 = s2 - 1;
                    quint32 len = e1 - s1 + 1;
                    qDebug("shortening garbage to %u bytes", len);
                    c1->setLength(len);
                }
            }
        }
    }

}

Here is the call graph for this function:

Here is the caller graph for this function:

guessType()

Kwave::RIFFChunk::ChunkType Kwave::RIFFParser::guessType ( const QByteArray &  name )

protected

Tries to find the chunk name in the list of known main chunk names and returns RIFFChunk::Main if successful. Otherwise returns RIFFChunk::Sub or RIFFChunk::Garbage if the chunk name is not valid.

Parameters

name	the name of the chunk

Returns

RIFFChunk::Main or RIFFChunk::Sub or RIFFChunk::Garbage

Definition at line 91 of file RIFFParser.cpp.

References Kwave::RIFFChunk::Garbage, isValidName(), m_main_chunk_names, Kwave::RIFFChunk::Main, and Kwave::RIFFChunk::Sub.

Referenced by joinGarbageToEmpty(), and parse().

{
    if (!isValidName(name)) return Kwave::RIFFChunk::Garbage;
    return (m_main_chunk_names.contains(QLatin1String(name))) ?
        Kwave::RIFFChunk::Main : Kwave::RIFFChunk::Sub;
}

Here is the call graph for this function:

Here is the caller graph for this function:

isKnownName()

bool Kwave::RIFFParser::isKnownName ( const QByteArray &  name )

protected

Returns true if the given chunk name is known as main or sub chunk

Definition at line 99 of file RIFFParser.cpp.

References m_main_chunk_names, and m_sub_chunk_names.

Referenced by joinGarbageToEmpty().

{
    if (m_main_chunk_names.contains(QLatin1String(name))) return true;
    if (m_sub_chunk_names.contains(QLatin1String(name))) return true;
    return false;
}

Here is the caller graph for this function:

isSane()

bool Kwave::RIFFParser::isSane

(

)

Returns true if the source contains no structural errors and no garbage or empty chunks.

Definition at line 437 of file RIFFParser.cpp.

References Kwave::RIFFChunk::isSane(), and m_root.

Referenced by Kwave::WavDecoder::open().

{
    return m_root.isSane();
}

Here is the call graph for this function:

Here is the caller graph for this function:

isValidName()

bool Kwave::RIFFParser::isValidName ( const char *  name )

protected

Returns true if the given chunk name is valid

Definition at line 76 of file RIFFParser.cpp.

Referenced by guessType(), and parse().

{
    int i;
    for (i=0; i < 4; ++i) {
        char c = name[i];
        if ((c >= 'a') && (c <= 'z')) continue;
        if ((c >= 'A') && (c <= 'Z')) continue;
        if ((c >= '0') && (c <= '9')) continue;
        if ((c == ' ') || (c == '(') || (c == ')'))continue;
        return false;
    }
    return true;
}

Here is the caller graph for this function:

joinGarbageToEmpty()

bool Kwave::RIFFParser::joinGarbageToEmpty ( )

private

joins garbage to previous empty chunks. If a chunk follows a previously empty chunk with an unknown name it will be joined too.

Returns

true if it needs an additional pass

Definition at line 731 of file RIFFParser.cpp.

References Kwave::RIFFChunk::dataLength(), Kwave::RIFFChunk::dataStart(), Kwave::RIFFChunk::Empty, Kwave::RIFFChunk::Garbage, guessType(), isKnownName(), listAllChunks(), m_cancel, m_root, Kwave::RIFFChunk::Main, Kwave::RIFFChunk::name(), Kwave::RIFFChunk::parent(), parse(), Kwave::RIFFChunk::physLength(), Kwave::RIFFChunk::physStart(), read4ByteString(), Kwave::RIFFChunk::setFormat(), Kwave::RIFFChunk::setLength(), Kwave::RIFFChunk::setType(), Kwave::RIFFChunk::subChunks(), and Kwave::RIFFChunk::type().

Referenced by repair().

{
    qDebug("joining garbage to empty chunks (and to garbage)...");

    Kwave::RIFFChunkList chunks;
    listAllChunks(m_root, chunks);
    QMutableListIterator<Kwave::RIFFChunk *> it1(chunks);
    QMutableListIterator<Kwave::RIFFChunk *> it2(chunks);

    // join garbage to empty chunks
    if (it2.hasNext()) it2.next();
    while (it2.hasNext() && it1.hasNext() && !m_cancel) {
        Kwave::RIFFChunk *chunk = it1.next();
        Kwave::RIFFChunk *next  = it2.next();
        if (!chunk || !next) continue;
        bool join = false;

        if ( ((chunk->type() == Kwave::RIFFChunk::Empty) ||
            (chunk->dataLength() == 0)) &&
            ((next->type() == Kwave::RIFFChunk::Garbage) ||
                (!isKnownName(next->name())) ) )
        {
            // join garbage and unknown stuff to empty
            join = true;
        }

        if ( (chunk->type() == Kwave::RIFFChunk::Garbage) &&
            (next->type() == Kwave::RIFFChunk::Garbage) )
        {
            // join garbage to garbage
            join = true;
        }

        if (join) {
            if ((next->type() == Kwave::RIFFChunk::Garbage) ||
                (!isKnownName(next->name())) )
            {
                quint32 len = next->physLength() + 4;
                qDebug("joining garbage to empty chunk '%s' at 0x%08X, %u bytes",
                    chunk->name().data(), chunk->physStart(), len);
                chunk->setLength(len);
                chunk->setType(guessType(chunk->name()));

                // remove the garbage chunk, it's no longer needed
                it2.remove();
                if (next->parent())
                    next->parent()->subChunks().removeAll(next);
                delete next;

                if (chunk->type() == Kwave::RIFFChunk::Main) {
                    // was joined to a main chunk -> parse again!
                    chunk->setFormat(read4ByteString(chunk->physStart() + 8));
                    parse(chunk, chunk->dataStart(), chunk->dataLength());
                }

                // need_one_more_pass !
                return true;
            }
        }
    }

    return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

listAllChunks()

void Kwave::RIFFParser::listAllChunks ( Kwave::RIFFChunk &  parent, Kwave::RIFFChunkList &  list  )

protected

Recursively creates a "flat" list of all chunks.

Parameters

parent	node to start with
list	receives references to the chunks

Definition at line 525 of file RIFFParser.cpp.

References Kwave::RIFFChunk::subChunks().

Referenced by chunkAt(), chunkCount(), collectGarbage(), findChunk(), findMissingChunk(), fixGarbageEnds(), and joinGarbageToEmpty().

{
    list.append(&parent);
    foreach (Kwave::RIFFChunk *chunk, parent.subChunks())
        if (chunk) listAllChunks(*chunk, list);
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse() [1/2]

bool Kwave::RIFFParser::parse

(

)

Parses the whole source.

Returns

true if passed without any error

Definition at line 219 of file RIFFParser.cpp.

References detectEndianness(), m_dev, m_endianness, m_root, toUint32(), and Kwave::UnknownEndian.

Referenced by findMissingChunk(), joinGarbageToEmpty(), Kwave::WavDecoder::open(), and parse().

{
    // first of all we have to find out the endianness of our source
    detectEndianness();

    // not detectable -> no chance of finding anything useful -> give up!
    if (m_endianness == Kwave::UnknownEndian) {
        qWarning("unable to detect endianness -> giving up!");
        return false;
    }

    // find all primary chunks
    return parse(&m_root, 0, toUint32(m_dev.size()));
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse() [2/2]

bool Kwave::RIFFParser::parse	(	Kwave::RIFFChunk *	parent,
		quint32	offset,
		quint32	length
	)

Parses a range of the source and adds all found chunks to a list of chunks. Also parses recursively for sub-chunks and builds a tree.

Parameters

parent	pointer to the parent node
offset	start of the chunk name in the source
length	size of the area where to search

Returns

true if passed without any error

Definition at line 304 of file RIFFParser.cpp.

References addChunk(), addEmptyChunk(), addGarbageChunk(), chunkAt(), Kwave::RIFFChunk::dataLength(), Kwave::RIFFChunk::dataStart(), guessType(), isValidName(), m_cancel, m_dev, m_endianness, m_root, Kwave::RIFFChunk::Main, Kwave::RIFFChunk::name(), name, parse(), Kwave::RIFFChunk::path(), Kwave::RIFFChunk::physEnd(), Kwave::RIFFChunk::physLength(), read4ByteString(), Kwave::RIFFChunk::setType(), Kwave::RIFFChunk::Sub, Kwave::RIFFChunk::subChunks(), and SYSTEM_ENDIANNES.

{
    bool error = false;
    Kwave::RIFFChunkList found_chunks;

    Q_ASSERT(parent);
    if (m_dev.isSequential()) return false;
    if (!parent) return false;

    // be more robust if the file has not correctly padded
    if (length & 1) length++;

    do {
//      qDebug("RIFFParser::parse(offset=0x%08X, length=0x%08X)",
//          offset, length);

        // make sure that we are still in the source (file)
        if (offset >= m_dev.size()) {
            error = true;
            break;
        }

        // abort search if we passed the same position twice
        // (this might happen if an intensive search is performed
        // and one position can be reached in two or more ways)
        // only exception: the root chunk, this always overlaps
        // with the first chunk at start of search!
        Kwave::RIFFChunk *prev = chunkAt(offset);
        if (prev && (m_root.subChunks().count())) break;

        // chunks with less than 4 bytes are not possible
        if (length < 4) {
            qWarning("chunk with less than 4 bytes at offset 0x%08X, "\
                    "length=%u bytes!", offset, length);
            // too short stuff is "garbage"
            addGarbageChunk(parent, offset, length);
            error = true;
            break;
        }

        m_dev.seek(offset);

        // get the chunk name
        QByteArray name = read4ByteString(m_dev.pos());

        // check if the name really contains only ASCII characters
        if (!isValidName(name)) {
            qWarning("invalid chunk name at offset 0x%08X", offset);
            // unreadable name -> make it a "garbage" chunk
            qDebug("addGarbageChunk(offset=0x%08X, length=0x%08X)",
                    offset, length);
            addGarbageChunk(parent, offset, length);
            error = true;
            break;
        }

        // get the length stored in the chunk itself
        quint32 len = 0;
        if (length >= 8) {
            // length information present
            m_dev.read(reinterpret_cast<char *>(&len), 4);
            if (m_endianness != SYSTEM_ENDIANNES) len = qbswap<quint32>(len);
        }
        if (len == 0) {
            // valid name but no length information -> badly truncated
            // -> make it a zero-length chunk
            qDebug("empty chunk '%s' at 0x%08X", name.data(), offset);
            addEmptyChunk(parent, name, offset);

            if (length > 8) {
                // there's some garbage behind
                offset += 8;
                length -= 8;
            }
            error = true;
            continue;
        }

        // read the format if present
        QByteArray format = read4ByteString(m_dev.pos());

        // calculate the physical length of the chunk
        quint32 phys_len = (length - 8 < len) ? (length - 8) : len;
        if (phys_len & 1) phys_len++;

        // now create a new chunk, per default type is "sub-chunk"
/*      qDebug("new chunk, name='%s', len=0x%08X, ofs=0x%08X, "\
            "phys_len=0x%08X (next=0x%08X)",
            name.data(),
            len,offset,phys_len, offset+phys_len+8); */
        Kwave::RIFFChunk *chunk = addChunk(parent, name, format, len, offset,
            phys_len, Kwave::RIFFChunk::Sub);
        if (!chunk) break;
        found_chunks.append(chunk);

        // if not at the end of the file, parse all further chunks
        length -= chunk->physLength() + 8;
        offset  = chunk->physEnd() + 1;
//      qDebug("   parse loop end: offset=0x%08X, length=0x%08X",offset,length);
    } while (length && !m_cancel);

    // parse for sub-chunks in the chunks we newly found
    foreach (Kwave::RIFFChunk *chunk, found_chunks) {
        if (!chunk) continue;
        if ( (guessType(chunk->name()) == Kwave::RIFFChunk::Main) &&
            (chunk->dataLength() >= 4) )
        {
            chunk->setType(Kwave::RIFFChunk::Main);

            QByteArray path = (parent ? parent->path() : QByteArray("")) +
                            '/' + chunk->name();
/*          qDebug("scanning for chunks in '%s' (format='%s'), "\
                "offset=0x%08X, length=0x%08X",
                path.data(), chunk->format().data(),
                chunk->dataStart(), chunk->dataLength());*/
            if (!parse(chunk, chunk->dataStart(), chunk->dataLength())) {
                error = true;
            }

        }
    }

    return (!error && !m_cancel);
}

Here is the call graph for this function:

progress

void Kwave::RIFFParser::progress ( int  percent )

signal

emits a progress in percent

Referenced by detectEndianness(), findMissingChunk(), and scanForName().

Here is the caller graph for this function:

read4ByteString()

QByteArray Kwave::RIFFParser::read4ByteString ( qint64  offset )

protected

Reads a 4-byte string from the source device at a given offset. The current source position will be set to 4 bytes after the given offset afterwards.

Parameters

offset

position within the source, no range checks!

Returns

string with 4 bytes

Definition at line 208 of file RIFFParser.cpp.

References m_dev.

Referenced by detectEndianness(), joinGarbageToEmpty(), and parse().

{
    char s[5] = {0, 0, 0, 0, 0};

    m_dev.seek(offset);
    m_dev.read(&s[0], 4);

    return QByteArray(s);
}

Here is the caller graph for this function:

repair()

void Kwave::RIFFParser::repair

(

)

Tries to repair the RIFF file by solving inconsistencies

See also

collectGarbage()

joinGarbageToEmpty()

fixGarbageEnds()

discardGarbage()

Definition at line 603 of file RIFFParser.cpp.

References collectGarbage(), discardGarbage(), fixGarbageEnds(), joinGarbageToEmpty(), m_cancel, and m_root.

Referenced by Kwave::WavDecoder::open().

{
    bool one_more_pass = true;

    while (one_more_pass && !m_cancel) {
        // crawl in garbage for all known chunks and sub-chunks
        // crawlInGarbage();

        // clear all main chunks that contain only garbage and convert them
        // into garbage chunks. maybe they were only false hits in a previous
        // search in garbage
        collectGarbage();

        // join garbage to empty chunks
        if (joinGarbageToEmpty()) continue;

        // resolve overlaps of garbage with other chunks
        fixGarbageEnds();

        // throw away all remaining garbage
        qDebug("discarding garbage...");
        discardGarbage(m_root);

        // done, no more passes needed
        one_more_pass = false;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

scanForName()

QList< quint32 > Kwave::RIFFParser::scanForName ( const QByteArray &  name, quint32  offset, quint32  length, int  progress_start = 0, int  progress_count = 1  )

protected

Performs a scan for a 4-character chunk name over a range of the source. Also emits progress bar info from [(start/count) ... ((start+1)/count-1)]

Parameters

name	the name of the chunk to be found
offset	position for start of the scan
length	number of bytes to scan
progress_start	start of the progress [0..progress_count-1]
progress_count	number of progress sections

Returns

list of positions of where the name exists

Definition at line 484 of file RIFFParser.cpp.

References m_cancel, m_dev, and progress().

Referenced by detectEndianness(), and findMissingChunk().

{
    QList<quint32> matches;
    if (length < 4) return matches;
    quint32 end = offset + ((length > 4) ? (length - 4) : 0);
    char buffer[5];
    memset(buffer, 0x00, sizeof(buffer));

    m_dev.seek(offset);
    m_dev.read(&buffer[0], 4);

    qDebug("scannig for '%s' at [0x%08X...0x%08X] ...", name.data(),
        offset, end);
    quint32 pos;
    int next = 1;
    for (pos = offset; (pos <= end) && !m_cancel; ++pos) {
        if (name == buffer) {
            // found the name
            matches.append(pos);
        }
        // try the next offset
        buffer[0] = buffer[1];
        buffer[1] = buffer[2];
        buffer[2] = buffer[3];
        m_dev.getChar(&(buffer[3]));

        // update progress bar
        if (!--next && progress_count && (end > offset)) {
            int percent = (((100*progress_start + (100*(pos-offset)) /
                    (end-offset))) / progress_count);
            emit progress(percent);
            next = (end-offset)/100;
        }
    }

    return matches;
}

Here is the caller graph for this function:

Member Data Documentation

m_cancel

bool Kwave::RIFFParser::m_cancel

private

can be set to true in order to cancel a running operation

Definition at line 271 of file RIFFParser.h.

Referenced by cancel(), collectGarbage(), detectEndianness(), discardGarbage(), findMissingChunk(), fixGarbageEnds(), joinGarbageToEmpty(), parse(), repair(), and scanForName().

m_dev

QIODevice& Kwave::RIFFParser::m_dev

private

I/O device with the source of the file

Definition at line 256 of file RIFFParser.h.

Referenced by detectEndianness(), parse(), read4ByteString(), and scanForName().

m_endianness

Kwave::byte_order_t Kwave::RIFFParser::m_endianness

private

endianness of the RIFF file, auto-detected

Definition at line 268 of file RIFFParser.h.

Referenced by detectEndianness(), and parse().

m_main_chunk_names

QStringList Kwave::RIFFParser::m_main_chunk_names

private

list of known names of main chunks

Definition at line 262 of file RIFFParser.h.

Referenced by detectEndianness(), guessType(), and isKnownName().

m_root

Kwave::RIFFChunk Kwave::RIFFParser::m_root

private

root chunk of the source

Definition at line 259 of file RIFFParser.h.

Referenced by addChunk(), chunkAt(), chunkCount(), collectGarbage(), detectEndianness(), dumpStructure(), findChunk(), findMissingChunk(), fixGarbageEnds(), isSane(), joinGarbageToEmpty(), parse(), repair(), and RIFFParser().

m_sub_chunk_names

QStringList Kwave::RIFFParser::m_sub_chunk_names

private

list of known names of sub chunks

Definition at line 265 of file RIFFParser.h.

Referenced by detectEndianness(), and isKnownName().

---

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

• plugins/codec_wav/RIFFParser.h
• plugins/codec_wav/RIFFParser.cpp