Changeset 846 for trunk/demos/spectrum/app/wavfile.cpp

Timestamp:

May 5, 2011, 5:36:53 AM (14 years ago)

Author:

Dmitry A. Kuminov

Message:

trunk: Merged in qt 4.7.2 sources from branches/vendor/nokia/qt.

Location:

trunk

Files:

• . (modified) (1 prop)
• demos/spectrum/app/wavfile.cpp (modified) (2 diffs)

trunk/demos/spectrum/app/wavfile.cpp

@@ -1 +1 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation ([email protected])
@@ -77 +77 @@
     RIFFHeader  riff;
     WAVEHeader  wave;
-    DATAHeader  data;
 };
 
-static const int HeaderLength = sizeof(CombinedHeader);
-
-
-WavFile::WavFile(const QAudioFormat &format, qint64 dataLength)
-    :   m_format(format)
-    ,   m_dataLength(dataLength)
+WavFile::WavFile(QObject *parent)
+    : QFile(parent)
+    , m_headerLength(0)
 {
 
 }
 
-bool WavFile::readHeader(QIODevice &device)
+bool WavFile::e)
 {
-    bool result = true;
+    close();
+    setFileName(fileName);
+    return QFile::open(QIODevice::ReadOnly) && readHeader();
+}
 
-    if (!device.isSequential())
-        result = device.seek(0);
-    // else, assume that current position is the start of the header
+const QAudioFormat &WavFile::fileFormat() const
+{
+    return m_fileFormat;
+}
 
+
+
+
+
+
+
+
+
+
+
     if (result) {
-        CombinedHeader header;
-        result = (device.read(reinterpret_cast<char *>(&header), HeaderLength) == HeaderLength);
-        if (result) {
-            if ((memcmp(&header.riff.descriptor.id, "RIFF", 4) == 0
-                || memcmp(&header.riff.descriptor.id, "RIFX", 4) == 0)
-                && memcmp(&header.riff.type, "WAVE", 4) == 0
-                && memcmp(&header.wave.descriptor.id, "fmt ", 4) == 0
-                && header.wave.audioFormat == 1 // PCM
-            ) {
-                if (memcmp(&header.riff.descriptor.id, "RIFF", 4) == 0)
-                    m_format.setByteOrder(QAudioFormat::LittleEndian);
-                else
-                    m_format.setByteOrder(QAudioFormat::BigEndian);
+        if ((memcmp(&header.riff.descriptor.id, "RIFF", 4) == 0
+            || memcmp(&header.riff.descriptor.id, "RIFX", 4) == 0)
+            && memcmp(&header.riff.type, "WAVE", 4) == 0
+            && memcmp(&header.wave.descriptor.id, "fmt ", 4) == 0
+            && (header.wave.audioFormat == 1 || header.wave.audioFormat == 0)) {
 
-                m_format.setChannels(qFromLittleEndian<quint16>(header.wave.numChannels));
-                m_format.setCodec("audio/pcm");
-                m_format.setFrequency(qFromLittleEndian<quint32>(header.wave.sampleRate));
-                m_format.setSampleSize(qFromLittleEndian<quint16>(header.wave.bitsPerSample));
+            // Read off remaining header information
+            DATAHeader dataHeader;
 
-                switch(header.wave.bitsPerSample) {
-                case 8:
-                    m_format.setSampleType(QAudioFormat::UnSignedInt);
-                    break;
-                case 16:
-                    m_format.setSampleType(QAudioFormat::SignedInt);
-                    break;
-                default:
-                    result = false;
-                }
+            if (qFromLittleEndian<quint32>(header.wave.descriptor.size) > sizeof(WAVEHeader)) {
+                // Extended data available
+                quint16 extraFormatBytes;
+                if (peek((char*)&extraFormatBytes, sizeof(quint16)) != sizeof(quint16))
+                    return false;
+                const qint64 throwAwayBytes = sizeof(quint16) + qFromLittleEndian<quint16>(extraFormatBytes);
+                if (read(throwAwayBytes).size() != throwAwayBytes)
+                    return false;
+            }
 
-                m_dataLength = device.size() - HeaderLength;
-            } else {
-                result = false;
-            }
+            if (read((char*)&dataHeader, sizeof(DATAHeader)) != sizeof(DATAHeader))
+                return false;
+
+            // Establish format
+            if (memcmp(&header.riff.descriptor.id, "RIFF", 4) == 0)
+                m_fileFormat.setByteOrder(QAudioFormat::LittleEndian);
+            else
+                m_fileFormat.setByteOrder(QAudioFormat::BigEndian);
+
+            int bps = qFromLittleEndian<quint16>(header.wave.bitsPerSample);
+            m_fileFormat.setChannels(qFromLittleEndian<quint16>(header.wave.numChannels));
+            m_fileFormat.setCodec("audio/pcm");
+            m_fileFormat.setFrequency(qFromLittleEndian<quint32>(header.wave.sampleRate));
+            m_fileFormat.setSampleSize(qFromLittleEndian<quint16>(header.wave.bitsPerSample));
+            m_fileFormat.setSampleType(bps == 8 ? QAudioFormat::UnSignedInt : QAudioFormat::SignedInt);
+        } else {
+            result = false;
         }
     }
-
+    m_headerLength = pos();
     return result;
 }
-
-bool WavFile::writeHeader(QIODevice &device)
-{
-    CombinedHeader header;
-
-    memset(&header, 0, HeaderLength);
-
-    // RIFF header
-    if (m_format.byteOrder() == QAudioFormat::LittleEndian)
-        strncpy(&header.riff.descriptor.id[0], "RIFF", 4);
-    else
-        strncpy(&header.riff.descriptor.id[0], "RIFX", 4);
-    qToLittleEndian<quint32>(quint32(m_dataLength + HeaderLength - 8),
-                             reinterpret_cast<unsigned char*>(&header.riff.descriptor.size));
-    strncpy(&header.riff.type[0], "WAVE", 4);
-
-    // WAVE header
-    strncpy(&header.wave.descriptor.id[0], "fmt ", 4);
-    qToLittleEndian<quint32>(quint32(16),
-                             reinterpret_cast<unsigned char*>(&header.wave.descriptor.size));
-    qToLittleEndian<quint16>(quint16(1),
-                             reinterpret_cast<unsigned char*>(&header.wave.audioFormat));
-    qToLittleEndian<quint16>(quint16(m_format.channels()),
-                             reinterpret_cast<unsigned char*>(&header.wave.numChannels));
-    qToLittleEndian<quint32>(quint32(m_format.frequency()),
-                             reinterpret_cast<unsigned char*>(&header.wave.sampleRate));
-    qToLittleEndian<quint32>(quint32(m_format.frequency() * m_format.channels() * m_format.sampleSize() / 8),
-                             reinterpret_cast<unsigned char*>(&header.wave.byteRate));
-    qToLittleEndian<quint16>(quint16(m_format.channels() * m_format.sampleSize() / 8),
-                             reinterpret_cast<unsigned char*>(&header.wave.blockAlign));
-    qToLittleEndian<quint16>(quint16(m_format.sampleSize()),
-                             reinterpret_cast<unsigned char*>(&header.wave.bitsPerSample));
-
-    // DATA header
-    strncpy(&header.data.descriptor.id[0], "data", 4);
-    qToLittleEndian<quint32>(quint32(m_dataLength),
-                             reinterpret_cast<unsigned char*>(&header.data.descriptor.size));
-
-    return (device.write(reinterpret_cast<const char *>(&header), HeaderLength) == HeaderLength);
-}
-
-const QAudioFormat& WavFile::format() const
-{
-    return m_format;
-}
-
-qint64 WavFile::dataLength() const
-{
-    return m_dataLength;
-}
-
-qint64 WavFile::headerLength()
-{
-    return HeaderLength;
-}
-
-bool WavFile::writeDataLength(QIODevice &device, qint64 dataLength)
-{
-    bool result = false;
-    if (!device.isSequential()) {
-        device.seek(40);
-        unsigned char dataLengthLE[4];
-        qToLittleEndian<quint32>(quint32(dataLength), dataLengthLE);
-        result = (device.write(reinterpret_cast<const char *>(dataLengthLE), 4) == 4);
-    }
-    return result;
-}
-
-#include <QFile>
-#include <QTextStream>
-
-qint64 WavFile::readData(QIODevice &device, QByteArray &buffer,
-                         QAudioFormat outputFormat)
-{
-    if (QAudioFormat() == outputFormat)
-        outputFormat = m_format;
-
-    qint64 result = 0;
-
-    QFile file("wav.txt");
-    file.open(QIODevice::WriteOnly | QIODevice::Text);
-    QTextStream stream;
-    stream.setDevice(&file);
-
-    if (isPCMS16LE(outputFormat) && isPCMS16LE(m_format)) {
-        QVector<char> inputSample(2 * m_format.channels());
-
-        qint16 *output = reinterpret_cast<qint16*>(buffer.data());
-
-        while (result < buffer.size()) {
-            if (device.read(inputSample.data(), inputSample.count())) {
-                int inputIdx = 0;
-                for (int outputIdx = 0; outputIdx < outputFormat.channels(); ++outputIdx) {
-                    const qint16* input = reinterpret_cast<const qint16*>(inputSample.data() + 2 * inputIdx);
-                    *output++ = qFromLittleEndian<qint16>(*input);
-                    result += 2;
-                    if (inputIdx < m_format.channels())
-                        ++inputIdx;
-                }
-            } else {
-                break;
-            }
-        }
-    }
-    return result;
-}
-