QIODevice(parent),
haveFormat(false),
dataSize(0),
- remaining(0),
source(s),
- state(QWaveDecoder::InitialState)
+ state(QWaveDecoder::InitialState),
+ junkToSkip(0),
+ bigEndian(false)
{
open(QIODevice::ReadOnly | QIODevice::Unbuffered);
void QWaveDecoder::handleData()
{
- bool valid = true;
+ // As a special "state", if we have junk to skip, we do
+ if (junkToSkip > 0) {
+ discardBytes(junkToSkip); // this also updates junkToSkip
+
+ // If we couldn't skip all the junk, return
+ if (junkToSkip > 0)
+ return;
+ }
+
if (state == QWaveDecoder::InitialState) {
if (source->bytesAvailable() < qint64(sizeof(RIFFHeader)))
return;
RIFFHeader riff;
source->read(reinterpret_cast<char *>(&riff), sizeof(RIFFHeader));
- if (qstrncmp(riff.descriptor.id, "RIFF", 4) != 0 ||
+ // RIFF = little endian RIFF, RIFX = big endian RIFF
+ if (((qstrncmp(riff.descriptor.id, "RIFF", 4) != 0) && (qstrncmp(riff.descriptor.id, "RIFX", 4) != 0)) ||
qstrncmp(riff.type, "WAVE", 4) != 0) {
source->disconnect(SIGNAL(readyRead()), this, SLOT(handleData()));
emit invalidFormat();
return;
} else {
state = QWaveDecoder::WaitingForFormatState;
+ if (qstrncmp(riff.descriptor.id, "RIFX", 4) == 0)
+ bigEndian = true;
+ else
+ bigEndian = false;
}
}
if (state == QWaveDecoder::WaitingForFormatState) {
- if (valid = findChunk("fmt ")) {
+ if (findChunk("fmt ")) {
chunk descriptor;
- source->peek(reinterpret_cast<char *>(&descriptor), sizeof(chunk));
+ peekChunk(&descriptor);
if (source->bytesAvailable() < qint64(descriptor.size + sizeof(chunk)))
return;
if (descriptor.size > sizeof(WAVEHeader))
discardBytes(descriptor.size - sizeof(WAVEHeader));
+ // Swizzle this
+ if (bigEndian) {
+ wave.audioFormat = qFromBigEndian<quint16>(wave.audioFormat);
+ }
+
if (wave.audioFormat != 0 && wave.audioFormat != 1) {
+ // 32bit wave files have format == 0xFFFE (WAVE_FORMAT_EXTENSIBLE).
+ // but don't support them at the moment.
source->disconnect(SIGNAL(readyRead()), this, SLOT(handleData()));
emit invalidFormat();
return;
} else {
- int bps = qFromLittleEndian<quint16>(wave.bitsPerSample);
-
format.setCodec(QLatin1String("audio/pcm"));
- format.setSampleType(bps == 8 ? QAudioFormat::UnSignedInt : QAudioFormat::SignedInt);
- format.setByteOrder(QAudioFormat::LittleEndian);
- format.setFrequency(qFromLittleEndian<quint32>(wave.sampleRate));
- format.setSampleSize(bps);
- format.setChannels(qFromLittleEndian<quint16>(wave.numChannels));
+
+ if (bigEndian) {
+ int bps = qFromBigEndian<quint16>(wave.bitsPerSample);
+
+ format.setSampleType(bps == 8 ? QAudioFormat::UnSignedInt : QAudioFormat::SignedInt);
+ format.setByteOrder(QAudioFormat::BigEndian);
+ format.setFrequency(qFromBigEndian<quint32>(wave.sampleRate));
+ format.setSampleSize(bps);
+ format.setChannels(qFromBigEndian<quint16>(wave.numChannels));
+ } else {
+ int bps = qFromLittleEndian<quint16>(wave.bitsPerSample);
+
+ format.setSampleType(bps == 8 ? QAudioFormat::UnSignedInt : QAudioFormat::SignedInt);
+ format.setByteOrder(QAudioFormat::LittleEndian);
+ format.setFrequency(qFromLittleEndian<quint32>(wave.sampleRate));
+ format.setSampleSize(bps);
+ format.setChannels(qFromLittleEndian<quint16>(wave.numChannels));
+ }
state = QWaveDecoder::WaitingForDataState;
}
}
if (state == QWaveDecoder::WaitingForDataState) {
- if (valid = findChunk("data")) {
+ if (findChunk("data")) {
source->disconnect(SIGNAL(readyRead()), this, SLOT(handleData()));
chunk descriptor;
source->read(reinterpret_cast<char *>(&descriptor), sizeof(chunk));
+ if (bigEndian)
+ descriptor.size = qFromBigEndian<quint32>(descriptor.size);
+
dataSize = descriptor.size;
haveFormat = true;
}
}
- if (source->atEnd() || !valid) {
+ if (source->atEnd()) {
source->disconnect(SIGNAL(readyRead()), this, SLOT(handleData()));
emit invalidFormat();
return;
}
-
}
bool QWaveDecoder::enoughDataAvailable()
{
- if (source->bytesAvailable() < qint64(sizeof(chunk)))
+ chunk descriptor;
+ if (!peekChunk(&descriptor))
return false;
- chunk descriptor;
- source->peek(reinterpret_cast<char *>(&descriptor), sizeof(chunk));
+ // This is only called for the RIFF/RIFX header, before bigEndian is set,
+ // so we have to manually swizzle
+ if (qstrncmp(descriptor.id, "RIFX", 4) == 0)
+ descriptor.size = qFromBigEndian<quint32>(descriptor.size);
if (source->bytesAvailable() < qint64(sizeof(chunk) + descriptor.size))
return false;
bool QWaveDecoder::findChunk(const char *chunkId)
{
- if (source->bytesAvailable() < qint64(sizeof(chunk)))
- return false;
-
chunk descriptor;
- source->peek(reinterpret_cast<char *>(&descriptor), sizeof(chunk));
+ if (!peekChunk(&descriptor))
+ return false;
if (qstrncmp(descriptor.id, chunkId, 4) == 0)
return true;
- while (source->bytesAvailable() >= qint64(sizeof(chunk) + descriptor.size)) {
- discardBytes(sizeof(chunk) + descriptor.size);
+ // It's possible that bytes->available() is less than the chunk size
+ // if it's corrupt.
+ junkToSkip = qint64(sizeof(chunk) + descriptor.size);
+ while (source->bytesAvailable() > 0) {
+ // Skip the current amount
+ if (junkToSkip > 0)
+ discardBytes(junkToSkip);
- source->peek(reinterpret_cast<char *>(&descriptor), sizeof(chunk));
+ // If we still have stuff left, just exit and try again later
+ // since we can't call peekChunk
+ if (junkToSkip > 0)
+ return false;
+
+ if (!peekChunk(&descriptor))
+ return false;
if (qstrncmp(descriptor.id, chunkId, 4) == 0)
return true;
return false;
}
+// Handles endianness
+bool QWaveDecoder::peekChunk(chunk *pChunk)
+{
+ if (source->bytesAvailable() < qint64(sizeof(chunk)))
+ return false;
+
+ source->peek(reinterpret_cast<char *>(pChunk), sizeof(chunk));
+ if (bigEndian)
+ pChunk->size = qFromBigEndian<quint32>(pChunk->size);
+
+ return true;
+}
+
void QWaveDecoder::discardBytes(qint64 numBytes)
{
- if (source->isSequential())
- source->read(numBytes);
- else
+ // Discards a number of bytes
+ // If the iodevice doesn't have this many bytes in it,
+ // remember how much more junk we have to skip.
+ if (source->isSequential()) {
+ QByteArray r = source->read(numBytes); // uggh, wasted memory
+ if (r.size() < numBytes)
+ junkToSkip = numBytes - r.size();
+ else
+ junkToSkip = 0;
+ } else {
+ quint64 origPos = source->pos();
source->seek(source->pos() + numBytes);
+ junkToSkip = origPos + numBytes - source->pos();
+ }
}
QT_END_NAMESPACE
#include <QtTest/QtTest>
#include <private/qwavedecoder_p.h>
-#ifndef QTRY_VERIFY
-#define QTRY_VERIFY(__expr) \
+#ifndef QTRY_COMPARE
+#define QTRY_COMPARE(__expr, __expected) \
do { \
const int __step = 50; \
const int __timeout = 10000; \
if (!(__expr)) { \
QTest::qWait(0); \
} \
- for (int __i = 0; __i < __timeout && !(__expr); __i+=__step) { \
+ for (int __i = 0; __i < __timeout && !((__expr) == (__expected)); __i+=__step) { \
QTest::qWait(__step); \
} \
- QVERIFY(__expr); \
+ QCOMPARE(__expr, __expected); \
} while (0)
#endif
QTest::newRow("File isawav_2_16_8000_be.wav") << QString("isawav_2_16_8000_be.wav") << tst_QWaveDecoder::None << 2 << 16 << 8000 << QAudioFormat::BigEndian;
QTest::newRow("File isawav_2_16_44100_be.wav") << QString("isawav_2_16_44100_be.wav") << tst_QWaveDecoder::None << 2 << 16 << 44100 << QAudioFormat::BigEndian;
- QTest::newRow("File isawav_1_32_8000_le.wav") << QString("isawav_1_32_8000_le.wav") << tst_QWaveDecoder::None << 1 << 32 << 8000 << QAudioFormat::LittleEndian;
- QTest::newRow("File isawav_1_32_44100_le.wav") << QString("isawav_1_32_44100_le.wav") << tst_QWaveDecoder::None << 1 << 32 << 44100 << QAudioFormat::LittleEndian;
- QTest::newRow("File isawav_2_32_8000_be.wav") << QString("isawav_2_32_8000_be.wav") << tst_QWaveDecoder::None << 2 << 32 << 8000 << QAudioFormat::BigEndian;
- QTest::newRow("File isawav_2_32_44100_be.wav") << QString("isawav_2_32_44100_be.wav") << tst_QWaveDecoder::None << 2 << 32 << 44100 << QAudioFormat::BigEndian;
+ // 32 bit waves are not supported
+ QTest::newRow("File isawav_1_32_8000_le.wav") << QString("isawav_1_32_8000_le.wav") << tst_QWaveDecoder::FormatDescriptor << 1 << 32 << 8000 << QAudioFormat::LittleEndian;
+ QTest::newRow("File isawav_1_32_44100_le.wav") << QString("isawav_1_32_44100_le.wav") << tst_QWaveDecoder::FormatDescriptor << 1 << 32 << 44100 << QAudioFormat::LittleEndian;
+ QTest::newRow("File isawav_2_32_8000_be.wav") << QString("isawav_2_32_8000_be.wav") << tst_QWaveDecoder::FormatDescriptor << 2 << 32 << 8000 << QAudioFormat::BigEndian;
+ QTest::newRow("File isawav_2_32_44100_be.wav") << QString("isawav_2_32_44100_be.wav") << tst_QWaveDecoder::FormatDescriptor << 2 << 32 << 44100 << QAudioFormat::BigEndian;
}
void tst_QWaveDecoder::integrity()
QFETCH(int, samplerate);
QFETCH(QAudioFormat::Endian, byteorder);
+
QFile stream;
stream.setFileName(QString("data/") + file);
stream.open(QIODevice::ReadOnly);
QSignalSpy invalidFormatSpy(&waveDecoder, SIGNAL(invalidFormat()));
if (corruption == NotAWav) {
- QTRY_VERIFY(validFormatSpy.count() == 0);
- QTRY_VERIFY(invalidFormatSpy.count() == 0);
+ QTRY_COMPARE(validFormatSpy.count(), 0);
+ QTRY_COMPARE(invalidFormatSpy.count(), 0);
} else if (corruption == NoSampleData) {
- QTRY_VERIFY(validFormatSpy.count() == 1);
- QTRY_VERIFY(invalidFormatSpy.count() == 0);
+ QTRY_COMPARE(validFormatSpy.count(), 1);
+ QTRY_COMPARE(invalidFormatSpy.count(), 0);
QVERIFY(waveDecoder.audioFormat().isValid());
QVERIFY(waveDecoder.size() == 0);
QVERIFY(waveDecoder.duration() == 0);
} else if (corruption == FormatDescriptor) {
- QTRY_VERIFY(invalidFormatSpy.count() == 1);
- QTRY_VERIFY(validFormatSpy.count() == 0);
+ QTRY_COMPARE(invalidFormatSpy.count(), 1);
+ QTRY_COMPARE(validFormatSpy.count(), 0);
} else if (corruption == FormatString) {
- QTRY_VERIFY(invalidFormatSpy.count() == 1);
- QTRY_VERIFY(validFormatSpy.count() == 0);
+ QTRY_COMPARE(invalidFormatSpy.count(), 1);
+ QTRY_COMPARE(validFormatSpy.count(), 0);
QVERIFY(!waveDecoder.audioFormat().isValid());
} else if (corruption == DataDescriptor) {
- QTRY_VERIFY(validFormatSpy.count() == 1);
- QTRY_VERIFY(invalidFormatSpy.count() == 0);
+ QTRY_COMPARE(validFormatSpy.count(), 0);
+ QTRY_COMPARE(invalidFormatSpy.count(), 1);
QVERIFY(waveDecoder.size() == 0);
} else if (corruption == None) {
- QTRY_VERIFY(validFormatSpy.count() == 1);
- QTRY_VERIFY(invalidFormatSpy.count() == 0);
+ QTRY_COMPARE(validFormatSpy.count(), 1);
+ QTRY_COMPARE(invalidFormatSpy.count(), 0);
QVERIFY(waveDecoder.audioFormat().isValid());
QVERIFY(waveDecoder.size() > 0);
QVERIFY(waveDecoder.duration() == 250);
QWaveDecoder waveDecoder(&stream);
QSignalSpy validFormatSpy(&waveDecoder, SIGNAL(formatKnown()));
- QTRY_VERIFY(validFormatSpy.count() == 1);
+ QTRY_COMPARE(validFormatSpy.count(), 1);
QVERIFY(waveDecoder.size() > 0);
QByteArray buffer;
QWaveDecoder waveDecoder(&stream);
QSignalSpy validFormatSpy(&waveDecoder, SIGNAL(formatKnown()));
- QTRY_VERIFY(validFormatSpy.count() == 1);
+ QTRY_COMPARE(validFormatSpy.count(), 1);
QVERIFY(waveDecoder.size() > 0);
qint64 readSize = 0;
projects / platform / upstream / qtmultimedia.git / commitdiff