Cleanup QAudioFormat and friends

Reduce the amount of available formats, and always
use host endianness.

Return both sample rate and channel count as a range,
not a list of values.

Change-Id: I88389b49ace077764fb647f50834236448e55c0e
Reviewed-by: Doris Verria <doris.verria@qt.io>
Reviewed-by: Lars Knoll <lars.knoll@qt.io>

9 files changed, 108 insertions, 233 deletions

diff --git a/tests/auto/integration/qaudiodecoderbackend/tst_qaudiodecoderbackend.cpp b/tests/auto/integration/qaudiodecoderbackend/tst_qaudiodecoderbackend.cpp
index 1f4ff9959..f5f2069e6 100644
--- a/tests/auto/integration/qaudiodecoderbackend/tst_qaudiodecoderbackend.cpp
+++ b/tests/auto/integration/qaudiodecoderbackend/tst_qaudiodecoderbackend.cpp
@@ -137,8 +137,7 @@ void tst_QAudioDecoderBackend::fileTest()
     // Test file is 44.1K 16bit mono, 44094 samples
     QCOMPARE(buffer.format().channelCount(), 1);
     QCOMPARE(buffer.format().sampleRate(), 44100);
-    QCOMPARE(buffer.format().sampleSize(), 16);
-    QCOMPARE(buffer.format().sampleType(), QAudioFormat::SignedInt);
+    QCOMPARE(buffer.format().sampleFormat(), QAudioFormat::Int16);
     QCOMPARE(buffer.byteCount(), buffer.sampleCount() * 2); // 16bit mono
 
     // The decoder should still have no format set
@@ -194,9 +193,8 @@ void tst_QAudioDecoderBackend::fileTest()
     // change output audio format
     QAudioFormat format;
     format.setChannelCount(2);
-    format.setSampleSize(8);
     format.setSampleRate(11050);
-    format.setSampleType(QAudioFormat::SignedInt);
+    format.setSampleFormat(QAudioFormat::UInt8);
 
     d.setAudioFormat(format);
 
@@ -477,8 +475,7 @@ void tst_QAudioDecoderBackend::deviceTest()
     // Test file is 44.1K 16bit mono
     QCOMPARE(buffer.format().channelCount(), 1);
     QCOMPARE(buffer.format().sampleRate(), 44100);
-    QCOMPARE(buffer.format().sampleSize(), 16);
-    QCOMPARE(buffer.format().sampleType(), QAudioFormat::SignedInt);
+    QCOMPARE(buffer.format().sampleFormat(), QAudioFormat::Int16);
 
     QVERIFY(errorSpy.isEmpty());
 
@@ -527,9 +524,8 @@ void tst_QAudioDecoderBackend::deviceTest()
     // Now try changing formats
     QAudioFormat format;
     format.setChannelCount(2);
-    format.setSampleSize(8);
     format.setSampleRate(8000);
-    format.setSampleType(QAudioFormat::SignedInt);
+    format.setSampleFormat(QAudioFormat::UInt8);
 
     d.setAudioFormat(format);
 
diff --git a/tests/auto/integration/qaudiodeviceinfo/tst_qaudiodeviceinfo.cpp b/tests/auto/integration/qaudiodeviceinfo/tst_qaudiodeviceinfo.cpp
index be565c8b3..44e58fa84 100644
--- a/tests/auto/integration/qaudiodeviceinfo/tst_qaudiodeviceinfo.cpp
+++ b/tests/auto/integration/qaudiodeviceinfo/tst_qaudiodeviceinfo.cpp
@@ -48,15 +48,10 @@ private slots:
     void checkAvailableDefaultInput();
     void checkAvailableDefaultOutput();
     void channels();
-    void sampleSizes();
-    void byteOrders();
-    void sampleTypes();
+    void sampleFormat();
     void sampleRates();
     void isFormatSupported();
     void preferred();
-    void nearest();
-    void supportedChannelCounts();
-    void supportedSampleRates();
     void assignOperator();
     void id();
     void defaultConstructor();
@@ -99,32 +94,22 @@ void tst_QAudioDeviceInfo::checkAvailableDefaultOutput()
 
 void tst_QAudioDeviceInfo::channels()
 {
-    QList<int> avail = device->supportedChannelCounts();
-    QVERIFY(avail.size() > 0);
+    auto range = device->supportedChannelCounts();
+    QVERIFY(range.minimum > 0);
+    QVERIFY(range.maximum > range.minimum);
 }
 
-void tst_QAudioDeviceInfo::sampleSizes()
+void tst_QAudioDeviceInfo::sampleFormat()
 {
-    QList<int> avail = device->supportedSampleSizes();
-    QVERIFY(avail.size() > 0);
-}
-
-void tst_QAudioDeviceInfo::byteOrders()
-{
-    QList<QAudioFormat::Endian> avail = device->supportedByteOrders();
-    QVERIFY(avail.size() > 0);
-}
-
-void tst_QAudioDeviceInfo::sampleTypes()
-{
-    QList<QAudioFormat::SampleType> avail = device->supportedSampleTypes();
+    QList<QAudioFormat::SampleFormat> avail = device->supportedSampleFormats();
     QVERIFY(avail.size() > 0);
 }
 
 void tst_QAudioDeviceInfo::sampleRates()
 {
-    QList<int> avail = device->supportedSampleRates();
-    QVERIFY(avail.size() > 0);
+    auto range = device->supportedSampleRates();
+    QVERIFY(range.minimum > 0);
+    QVERIFY(range.maximum > range.minimum);
 }
 
 void tst_QAudioDeviceInfo::isFormatSupported()
@@ -132,9 +117,7 @@ void tst_QAudioDeviceInfo::isFormatSupported()
     QAudioFormat format;
     format.setSampleRate(44100);
     format.setChannelCount(2);
-    format.setSampleType(QAudioFormat::SignedInt);
-    format.setByteOrder(QAudioFormat::LittleEndian);
-    format.setSampleSize(16);
+    format.setSampleFormat(QAudioFormat::Int16);
 
     // Should always be true for these format
     QVERIFY(device->isFormatSupported(format));
@@ -145,43 +128,6 @@ void tst_QAudioDeviceInfo::preferred()
     QAudioFormat format = device->preferredFormat();
     QVERIFY(format.isValid());
     QVERIFY(device->isFormatSupported(format));
-    QVERIFY(device->nearestFormat(format) == format);
-}
-
-// Returns closest QAudioFormat to settings that system audio supports.
-void tst_QAudioDeviceInfo::nearest()
-{
-    /*
-    QAudioFormat format1, format2;
-    format1.setSampleRate(8000);
-    format2 = device->nearestFormat(format1);
-    QVERIFY(format2.sampleRate() == 44100);
-    */
-    QAudioFormat format;
-    format.setSampleRate(44100);
-    format.setChannelCount(2);
-    format.setSampleType(QAudioFormat::SignedInt);
-    format.setByteOrder(QAudioFormat::LittleEndian);
-    format.setSampleSize(16);
-
-    QAudioFormat format2 = device->nearestFormat(format);
-
-    // This is definitely dependent on platform support (but isFormatSupported tests that above)
-    QVERIFY(format2.sampleRate() == 44100);
-}
-
-// Returns a list of supported channel counts.
-void tst_QAudioDeviceInfo::supportedChannelCounts()
-{
-    QList<int> avail = device->supportedChannelCounts();
-    QVERIFY(avail.size() > 0);
-}
-
-// Returns a list of supported sample rates.
-void tst_QAudioDeviceInfo::supportedSampleRates()
-{
-    QList<int> avail = device->supportedSampleRates();
-    QVERIFY(avail.size() > 0);
 }
 
 // QAudioDeviceInfo's assignOperator method
diff --git a/tests/auto/integration/qaudioinput/tst_qaudioinput.cpp b/tests/auto/integration/qaudioinput/tst_qaudioinput.cpp
index b6f04428f..300dc9116 100644
--- a/tests/auto/integration/qaudioinput/tst_qaudioinput.cpp
+++ b/tests/auto/integration/qaudioinput/tst_qaudioinput.cpp
@@ -139,17 +139,9 @@ void tst_QAudioInput::generate_audiofile_testrows()
 
 QString tst_QAudioInput::formatToFileName(const QAudioFormat &format)
 {
-    const QString formatEndian = (format.byteOrder() == QAudioFormat::LittleEndian)
-        ?   QString("LE") : QString("BE");
-
-    const QString formatSigned = (format.sampleType() == QAudioFormat::SignedInt)
-        ?   QString("signed") : QString("unsigned");
-
-    return QString("%1_%2_%3_%4_%5")
+    return QString("%1_%2_%3")
         .arg(format.sampleRate())
-        .arg(format.sampleSize())
-        .arg(formatSigned)
-        .arg(formatEndian)
+        .arg(format.bytesPerSample())
         .arg(format.channelCount());
 }
 
@@ -173,16 +165,14 @@ void tst_QAudioInput::initTestCase()
 
     // PCM 8000  mono S8
     format.setSampleRate(8000);
-    format.setSampleSize(8);
-    format.setSampleType(QAudioFormat::SignedInt);
-    format.setByteOrder(QAudioFormat::LittleEndian);
+    format.setSampleFormat(QAudioFormat::UInt8);
     format.setChannelCount(1);
     if (audioDevice.isFormatSupported(format))
         testFormats.append(format);
 
     // PCM 11025 mono S16LE
     format.setSampleRate(11025);
-    format.setSampleSize(16);
+    format.setSampleFormat(QAudioFormat::Int16);
     if (audioDevice.isFormatSupported(format))
         testFormats.append(format);
 
@@ -236,12 +226,9 @@ void tst_QAudioInput::format()
             QString("channels: requested=%1, actual=%2").arg(requested.channelCount()).arg(actual.channelCount()).toLocal8Bit().constData());
     QVERIFY2((requested.sampleRate() == actual.sampleRate()),
             QString("sampleRate: requested=%1, actual=%2").arg(requested.sampleRate()).arg(actual.sampleRate()).toLocal8Bit().constData());
-    QVERIFY2((requested.sampleSize() == actual.sampleSize()),
-            QString("sampleSize: requested=%1, actual=%2").arg(requested.sampleSize()).arg(actual.sampleSize()).toLocal8Bit().constData());
-    QVERIFY2((requested.byteOrder() == actual.byteOrder()),
-            QString("byteOrder: requested=%1, actual=%2").arg(requested.byteOrder()).arg(actual.byteOrder()).toLocal8Bit().constData());
-    QVERIFY2((requested.sampleType() == actual.sampleType()),
-            QString("sampleType: requested=%1, actual=%2").arg(requested.sampleType()).arg(actual.sampleType()).toLocal8Bit().constData());
+    QVERIFY2((requested.sampleFormat() == actual.sampleFormat()),
+            QString("sampleFormat: requested=%1, actual=%2").arg(requested.sampleFormat()).arg(actual.sampleFormat()).toUtf8().constData());
+    QCOMPARE(actual, requested);
 }
 
 void tst_QAudioInput::invalidFormat_data()
@@ -264,7 +251,7 @@ void tst_QAudioInput::invalidFormat_data()
             << format;
 
     format = audioDevice.preferredFormat();
-    format.setSampleSize(0);
+    format.setSampleFormat(QAudioFormat::Unknown);
     QTest::newRow("Sample size 0")
             << format;
 }
@@ -633,7 +620,7 @@ void tst_QAudioInput::push()
     qint64 totalBytesRead = 0;
     bool firstBuffer = true;
     QByteArray buffer(AUDIO_BUFFER, 0);
-    qint64 len = (audioFormat.sampleRate()*audioFormat.channelCount()*(audioFormat.sampleSize()/8)*2); // 2 seconds
+    qint64 len = audioFormat.sampleRate()*audioFormat.bytesPerFrame()*2; // 2 seconds
     while (totalBytesRead < len) {
         QTRY_VERIFY_WITH_TIMEOUT(audioInput.bytesReady() >= audioInput.periodSize(), 10000);
         qint64 bytesRead = feed->read(buffer.data(), audioInput.periodSize());
@@ -714,7 +701,7 @@ void tst_QAudioInput::pushSuspendResume()
     qint64 totalBytesRead = 0;
     bool firstBuffer = true;
     QByteArray buffer(AUDIO_BUFFER, 0);
-    qint64 len = (audioFormat.sampleRate()*audioFormat.channelCount()*(audioFormat.sampleSize()/8)); // 1 seconds
+    qint64 len = audioFormat.sampleRate() * audioFormat.bytesPerFrame(); // 1 second
     while (totalBytesRead < len) {
         QTRY_VERIFY_WITH_TIMEOUT(audioInput.bytesReady() >= audioInput.periodSize(), 10000);
         qint64 bytesRead = feed->read(buffer.data(), audioInput.periodSize());
diff --git a/tests/auto/integration/qaudioinput/wavheader.cpp b/tests/auto/integration/qaudioinput/wavheader.cpp
index 1899480fd..b53bd5f0b 100644
--- a/tests/auto/integration/qaudioinput/wavheader.cpp
+++ b/tests/auto/integration/qaudioinput/wavheader.cpp
@@ -93,21 +93,21 @@ bool WavHeader::read(QIODevice &device)
                 && 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);
+                // ### FIX Big endian handling
+//                if (memcmp(&header.riff.descriptor.id, "RIFF", 4) == 0)
+//                    m_format.setByteOrder(QAudioFormat::LittleEndian);
+//                else
+//                    m_format.setByteOrder(QAudioFormat::BigEndian);
 
                 m_format.setChannelCount(qFromLittleEndian<quint16>(header.wave.numChannels));
                 m_format.setSampleRate(qFromLittleEndian<quint32>(header.wave.sampleRate));
-                m_format.setSampleSize(qFromLittleEndian<quint16>(header.wave.bitsPerSample));
 
                 switch(header.wave.bitsPerSample) {
                 case 8:
-                    m_format.setSampleType(QAudioFormat::UnSignedInt);
+                    m_format.setSampleFormat(QAudioFormat::UInt8);
                     break;
                 case 16:
-                    m_format.setSampleType(QAudioFormat::SignedInt);
+                    m_format.setSampleFormat(QAudioFormat::Int16);
                     break;
                 default:
                     result = false;
@@ -130,10 +130,11 @@ bool WavHeader::write(QIODevice &device)
     memset(&header, 0, HeaderLength);
 
     // RIFF header
-    if (m_format.byteOrder() == QAudioFormat::LittleEndian)
+    // ### handle big endian
+//    if (m_format.byteOrder() == QAudioFormat::LittleEndian)
         memcpy(header.riff.descriptor.id,"RIFF",4);
-    else
-        memcpy(header.riff.descriptor.id,"RIFX",4);
+//    else
+//        memcpy(header.riff.descriptor.id,"RIFX",4);
     qToLittleEndian<quint32>(quint32(m_dataLength + HeaderLength - 8),
                              reinterpret_cast<unsigned char*>(&header.riff.descriptor.size));
     memcpy(header.riff.type, "WAVE",4);
@@ -148,11 +149,11 @@ bool WavHeader::write(QIODevice &device)
                              reinterpret_cast<unsigned char*>(&header.wave.numChannels));
     qToLittleEndian<quint32>(quint32(m_format.sampleRate()),
                              reinterpret_cast<unsigned char*>(&header.wave.sampleRate));
-    qToLittleEndian<quint32>(quint32(m_format.sampleRate() * m_format.channelCount() * m_format.sampleSize() / 8),
+    qToLittleEndian<quint32>(quint32(m_format.sampleRate() * m_format.bytesPerFrame()),
                              reinterpret_cast<unsigned char*>(&header.wave.byteRate));
-    qToLittleEndian<quint16>(quint16(m_format.channelCount() * m_format.sampleSize() / 8),
+    qToLittleEndian<quint16>(quint16(m_format.bytesPerFrame()),
                              reinterpret_cast<unsigned char*>(&header.wave.blockAlign));
-    qToLittleEndian<quint16>(quint16(m_format.sampleSize()),
+    qToLittleEndian<quint16>(quint16(m_format.bytesPerSample() * 8),
                              reinterpret_cast<unsigned char*>(&header.wave.bitsPerSample));
 
     // DATA header
diff --git a/tests/auto/integration/qaudiooutput/tst_qaudiooutput.cpp b/tests/auto/integration/qaudiooutput/tst_qaudiooutput.cpp
index b2064ece7..973c4c237 100644
--- a/tests/auto/integration/qaudiooutput/tst_qaudiooutput.cpp
+++ b/tests/auto/integration/qaudiooutput/tst_qaudiooutput.cpp
@@ -121,24 +121,16 @@ private:
 
 QString tst_QAudioOutput::formatToFileName(const QAudioFormat &format)
 {
-    const QString formatEndian = (format.byteOrder() == QAudioFormat::LittleEndian)
-        ?   QString("LE") : QString("BE");
-
-    const QString formatSigned = (format.sampleType() == QAudioFormat::SignedInt)
-        ?   QString("signed") : QString("unsigned");
-
-    return QString("%1_%2_%3_%4_%5")
+    return QString("%1_%2_%3")
         .arg(format.sampleRate())
-        .arg(format.sampleSize())
-        .arg(formatSigned)
-        .arg(formatEndian)
+        .arg(format.bytesPerSample())
         .arg(format.channelCount());
 }
 
 void tst_QAudioOutput::createSineWaveData(const QAudioFormat &format, qint64 length, int sampleRate)
 {
-    const int channelBytes = format.sampleSize() / 8;
-    const int sampleBytes = format.channelCount() * channelBytes;
+    const int channelBytes = format.bytesPerSample();
+    const int sampleBytes = format.bytesPerFrame();
 
     Q_ASSERT(length % sampleBytes == 0);
     Q_UNUSED(sampleBytes); // suppress warning in release builds
@@ -149,25 +141,25 @@ void tst_QAudioOutput::createSineWaveData(const QAudioFormat &format, qint64 len
 
     while (length) {
         const qreal x = qSin(2 * M_PI * sampleRate * qreal(sampleIndex % format.sampleRate()) / format.sampleRate());
-        for (int i=0; i<format.channelCount(); ++i) {
-            if (format.sampleSize() == 8 && format.sampleType() == QAudioFormat::UnSignedInt) {
+        for (int i = 0; i < format.channelCount(); ++i) {
+            switch (format.sampleFormat()) {
+            case QAudioFormat::UInt8: {
                 const quint8 value = static_cast<quint8>((1.0 + x) / 2 * 255);
-                *reinterpret_cast<quint8*>(ptr) = value;
-            } else if (format.sampleSize() == 8 && format.sampleType() == QAudioFormat::SignedInt) {
-                const qint8 value = static_cast<qint8>(x * 127);
-                *reinterpret_cast<quint8*>(ptr) = value;
-            } else if (format.sampleSize() == 16 && format.sampleType() == QAudioFormat::UnSignedInt) {
-                quint16 value = static_cast<quint16>((1.0 + x) / 2 * 65535);
-                if (format.byteOrder() == QAudioFormat::LittleEndian)
-                    qToLittleEndian<quint16>(value, ptr);
-                else
-                    qToBigEndian<quint16>(value, ptr);
-            } else if (format.sampleSize() == 16 && format.sampleType() == QAudioFormat::SignedInt) {
+                *reinterpret_cast<quint8 *>(ptr) = value;
+            }
+            case QAudioFormat::Int16: {
                 qint16 value = static_cast<qint16>(x * 32767);
-                if (format.byteOrder() == QAudioFormat::LittleEndian)
-                    qToLittleEndian<qint16>(value, ptr);
-                else
-                    qToBigEndian<qint16>(value, ptr);
+                *reinterpret_cast<qint16 *>(ptr) = value;
+            }
+            case QAudioFormat::Int32: {
+                quint32 value = static_cast<quint32>(x) * std::numeric_limits<qint32>::max();
+                *reinterpret_cast<qint32 *>(ptr) = value;
+            }
+            case QAudioFormat::Float:
+                *reinterpret_cast<float *>(ptr) = x;
+            case QAudioFormat::Unknown:
+            case QAudioFormat::NSampleFormats:
+                break;
             }
 
             ptr += channelBytes;
@@ -212,16 +204,14 @@ void tst_QAudioOutput::initTestCase()
 
     // PCM 8000  mono S8
     format.setSampleRate(8000);
-    format.setSampleSize(8);
-    format.setSampleType(QAudioFormat::SignedInt);
-    format.setByteOrder(QAudioFormat::LittleEndian);
+    format.setSampleFormat(QAudioFormat::UInt8);
     format.setChannelCount(1);
     if (audioDevice.isFormatSupported(format))
         testFormats.append(format);
 
     // PCM 11025 mono S16LE
     format.setSampleRate(11025);
-    format.setSampleSize(16);
+    format.setSampleFormat(QAudioFormat::Int16);
     if (audioDevice.isFormatSupported(format))
         testFormats.append(format);
 
@@ -258,7 +248,7 @@ void tst_QAudioOutput::initTestCase()
 
     const QString temporaryAudioPath = m_temporaryDir->path() + slash;
     for (const QAudioFormat &format : qAsConst(testFormats)) {
-        qint64 len = (format.sampleRate()*format.channelCount()*(format.sampleSize()/8)*2); // 2 seconds
+        qint64 len = format.sampleRate()*format.bytesPerFrame()*2; // 2 seconds
         createSineWaveData(format, len);
         // Write generate sine wave data to file
         const QString fileName = temporaryAudioPath + QStringLiteral("generated")
@@ -284,12 +274,9 @@ void tst_QAudioOutput::format()
             QString("channels: requested=%1, actual=%2").arg(requested.channelCount()).arg(actual.channelCount()).toLocal8Bit().constData());
     QVERIFY2((requested.sampleRate() == actual.sampleRate()),
             QString("sampleRate: requested=%1, actual=%2").arg(requested.sampleRate()).arg(actual.sampleRate()).toLocal8Bit().constData());
-    QVERIFY2((requested.sampleSize() == actual.sampleSize()),
-            QString("sampleSize: requested=%1, actual=%2").arg(requested.sampleSize()).arg(actual.sampleSize()).toLocal8Bit().constData());
-    QVERIFY2((requested.byteOrder() == actual.byteOrder()),
-            QString("byteOrder: requested=%1, actual=%2").arg(requested.byteOrder()).arg(actual.byteOrder()).toLocal8Bit().constData());
-    QVERIFY2((requested.sampleType() == actual.sampleType()),
-            QString("sampleType: requested=%1, actual=%2").arg(requested.sampleType()).arg(actual.sampleType()).toLocal8Bit().constData());
+    QVERIFY2((requested.sampleFormat() == actual.sampleFormat()),
+            QString("sampleFormat: requested=%1, actual=%2").arg(requested.sampleFormat()).arg(actual.sampleFormat()).toLocal8Bit().constData());
+    QVERIFY(requested == actual);
 }
 
 void tst_QAudioOutput::invalidFormat_data()
@@ -312,7 +299,7 @@ void tst_QAudioOutput::invalidFormat_data()
             << format;
 
     format = audioDevice.preferredFormat();
-    format.setSampleSize(0);
+    format.setSampleFormat(QAudioFormat::Unknown);
     QTest::newRow("Sample size 0")
             << format;
 }
diff --git a/tests/auto/integration/qaudiooutput/wavheader.cpp b/tests/auto/integration/qaudiooutput/wavheader.cpp
index 1899480fd..1a4c358e7 100644
--- a/tests/auto/integration/qaudiooutput/wavheader.cpp
+++ b/tests/auto/integration/qaudiooutput/wavheader.cpp
@@ -93,21 +93,20 @@ bool WavHeader::read(QIODevice &device)
                 && 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)
+//                    m_format.setByteOrder(QAudioFormat::LittleEndian);
+//                else
+//                    m_format.setByteOrder(QAudioFormat::BigEndian);
 
                 m_format.setChannelCount(qFromLittleEndian<quint16>(header.wave.numChannels));
                 m_format.setSampleRate(qFromLittleEndian<quint32>(header.wave.sampleRate));
-                m_format.setSampleSize(qFromLittleEndian<quint16>(header.wave.bitsPerSample));
 
                 switch(header.wave.bitsPerSample) {
                 case 8:
-                    m_format.setSampleType(QAudioFormat::UnSignedInt);
+                    m_format.setSampleFormat(QAudioFormat::UInt8);
                     break;
                 case 16:
-                    m_format.setSampleType(QAudioFormat::SignedInt);
+                    m_format.setSampleFormat(QAudioFormat::Int16);
                     break;
                 default:
                     result = false;
@@ -130,10 +129,7 @@ bool WavHeader::write(QIODevice &device)
     memset(&header, 0, HeaderLength);
 
     // RIFF header
-    if (m_format.byteOrder() == QAudioFormat::LittleEndian)
-        memcpy(header.riff.descriptor.id,"RIFF",4);
-    else
-        memcpy(header.riff.descriptor.id,"RIFX",4);
+    memcpy(header.riff.descriptor.id,"RIFF",4);
     qToLittleEndian<quint32>(quint32(m_dataLength + HeaderLength - 8),
                              reinterpret_cast<unsigned char*>(&header.riff.descriptor.size));
     memcpy(header.riff.type, "WAVE",4);
@@ -148,11 +144,11 @@ bool WavHeader::write(QIODevice &device)
                              reinterpret_cast<unsigned char*>(&header.wave.numChannels));
     qToLittleEndian<quint32>(quint32(m_format.sampleRate()),
                              reinterpret_cast<unsigned char*>(&header.wave.sampleRate));
-    qToLittleEndian<quint32>(quint32(m_format.sampleRate() * m_format.channelCount() * m_format.sampleSize() / 8),
+    qToLittleEndian<quint32>(quint32(m_format.sampleRate() * m_format.bytesPerFrame()),
                              reinterpret_cast<unsigned char*>(&header.wave.byteRate));
-    qToLittleEndian<quint16>(quint16(m_format.channelCount() * m_format.sampleSize() / 8),
+    qToLittleEndian<quint16>(quint16(m_format.channelCount() * m_format.bytesPerSample()),
                              reinterpret_cast<unsigned char*>(&header.wave.blockAlign));
-    qToLittleEndian<quint16>(quint16(m_format.sampleSize()),
+    qToLittleEndian<quint16>(quint16(m_format.bytesPerSample() * 8),
                              reinterpret_cast<unsigned char*>(&header.wave.bitsPerSample));
 
     // DATA header
@@ -185,6 +181,7 @@ bool WavHeader::writeDataLength(QIODevice &device, qint64 dataLength)
         device.seek(40);
         unsigned char dataLengthLE[4];
         qToLittleEndian<quint32>(quint32(dataLength), dataLengthLE);
+        // ### Fix for big endian systems
         result = (device.write(reinterpret_cast<const char *>(dataLengthLE), 4) == 4);
     }
     return result;
diff --git a/tests/auto/unit/mockbackend/mockaudiodecodercontrol.h b/tests/auto/unit/mockbackend/mockaudiodecodercontrol.h
index ec7e8ad83..4216bde86 100644
--- a/tests/auto/unit/mockbackend/mockaudiodecodercontrol.h
+++ b/tests/auto/unit/mockbackend/mockaudiodecodercontrol.h
@@ -55,9 +55,8 @@ public:
         , mSerial(0)
     {
         mFormat.setChannelCount(1);
-        mFormat.setSampleSize(8);
+        mFormat.setSampleFormat(QAudioFormat::UInt8);
         mFormat.setSampleRate(1000);
-        mFormat.setSampleType(QAudioFormat::UnSignedInt);
     }
 
     QAudioDecoder::State state() const
diff --git a/tests/auto/unit/multimedia/qaudiobuffer/tst_qaudiobuffer.cpp b/tests/auto/unit/multimedia/qaudiobuffer/tst_qaudiobuffer.cpp
index 6daa7da1b..91401eeeb 100644
--- a/tests/auto/unit/multimedia/qaudiobuffer/tst_qaudiobuffer.cpp
+++ b/tests/auto/unit/multimedia/qaudiobuffer/tst_qaudiobuffer.cpp
@@ -60,8 +60,7 @@ tst_QAudioBuffer::tst_QAudioBuffer()
 {
     // Initialize some common buffers
     mFormat.setChannelCount(2);
-    mFormat.setSampleSize(16);
-    mFormat.setSampleType(QAudioFormat::UnSignedInt);
+    mFormat.setSampleFormat(QAudioFormat::Int16);
     mFormat.setSampleRate(10000);
 
     QByteArray b(4000, char(0x80));
@@ -236,18 +235,16 @@ void tst_QAudioBuffer::data()
 void tst_QAudioBuffer::durations()
 {
     QFETCH(int, channelCount);
-    QFETCH(int, sampleSize);
     QFETCH(int, frameCount);
     int sampleCount = frameCount * channelCount;
-    QFETCH(QAudioFormat::SampleType, sampleType);
+    QFETCH(QAudioFormat::SampleFormat, sampleFormat);
     QFETCH(int, sampleRate);
     QFETCH(qint64, duration);
     QFETCH(int, byteCount);
 
     QAudioFormat f;
     f.setChannelCount(channelCount);
-    f.setSampleType(sampleType);
-    f.setSampleSize(sampleSize);
+    f.setSampleFormat(sampleFormat);
     f.setSampleRate(sampleRate);
 
     QAudioBuffer b(frameCount, f);
@@ -261,21 +258,20 @@ void tst_QAudioBuffer::durations()
 void tst_QAudioBuffer::durations_data()
 {
     QTest::addColumn<int>("channelCount");
-    QTest::addColumn<int>("sampleSize");
     QTest::addColumn<int>("frameCount");
-    QTest::addColumn<QAudioFormat::SampleType>("sampleType");
+    QTest::addColumn<QAudioFormat::SampleFormat>("sampleType");
     QTest::addColumn<int>("sampleRate");
     QTest::addColumn<qint64>("duration");
     QTest::addColumn<int>("byteCount");
-    QTest::newRow("M8_1000_8K") << 1 << 8 << 1000 << QAudioFormat::UnSignedInt << 8000 << 125000LL << 1000;
-    QTest::newRow("M8_2000_8K") << 1 << 8 << 2000 << QAudioFormat::UnSignedInt << 8000 << 250000LL << 2000;
-    QTest::newRow("M8_1000_4K") << 1 << 8 << 1000 << QAudioFormat::UnSignedInt << 4000 << 250000LL << 1000;
+    QTest::newRow("M8_1000_8K") << 1 << 1000 << QAudioFormat::UInt8 << 8000 << 125000LL << 1000;
+    QTest::newRow("M8_2000_8K") << 1 << 2000 << QAudioFormat::UInt8 << 8000 << 250000LL << 2000;
+    QTest::newRow("M8_1000_4K") << 1 << 1000 << QAudioFormat::UInt8 << 4000 << 250000LL << 1000;
 
-    QTest::newRow("S8_1000_8K") << 2 << 8 << 500 << QAudioFormat::UnSignedInt << 8000 << 62500LL << 1000;
+    QTest::newRow("S8_1000_8K") << 2 << 500 << QAudioFormat::UInt8 << 8000 << 62500LL << 1000;
 
-    QTest::newRow("SF_1000_8K") << 2 << 32 << 500 << QAudioFormat::Float << 8000 << 62500LL << 4000;
+    QTest::newRow("SF_1000_8K") << 2 << 500 << QAudioFormat::Float << 8000 << 62500LL << 4000;
 
-    QTest::newRow("4x128_1000_16K") << 4 << 128 << 250 << QAudioFormat::SignedInt << 16000 << 15625LL << 16000;
+    QTest::newRow("S32_1000_16K") << 4 << 250 << QAudioFormat::Int32 << 16000 << 15625LL << 16000;
 }
 
 void tst_QAudioBuffer::stereoSample()
diff --git a/tests/auto/unit/multimedia/qaudioformat/tst_qaudioformat.cpp b/tests/auto/unit/multimedia/qaudioformat/tst_qaudioformat.cpp
index 6558f455d..ff5590a16 100644
--- a/tests/auto/unit/multimedia/qaudioformat/tst_qaudioformat.cpp
+++ b/tests/auto/unit/multimedia/qaudioformat/tst_qaudioformat.cpp
@@ -45,9 +45,7 @@ public:
 
 private slots:
     void checkNull();
-    void checkSampleSize();
-    void checkByteOrder();
-    void checkSampleType();
+    void checkSampleFormat();
     void checkEquality();
     void checkAssignment();
     void checkSampleRate();
@@ -69,54 +67,30 @@ void tst_QAudioFormat::checkNull()
 
     audioFormat0.setSampleRate(44100);
     audioFormat0.setChannelCount(2);
-    audioFormat0.setSampleSize(16);
-    audioFormat0.setSampleType(QAudioFormat::SignedInt);
+    audioFormat0.setSampleFormat(QAudioFormat::Int16);
     QVERIFY(audioFormat0.isValid());
 }
 
-void tst_QAudioFormat::checkSampleSize()
+void tst_QAudioFormat::checkSampleFormat()
 {
     QAudioFormat audioFormat;
-    audioFormat.setSampleSize(16);
-    QVERIFY(audioFormat.sampleSize() == 16);
-}
-
-void tst_QAudioFormat::checkByteOrder()
-{
-    QAudioFormat audioFormat;
-    audioFormat.setByteOrder(QAudioFormat::LittleEndian);
-    QVERIFY(audioFormat.byteOrder() == QAudioFormat::LittleEndian);
-
-    QTest::ignoreMessage(QtDebugMsg, "LittleEndian");
-    qDebug() << QAudioFormat::LittleEndian;
-
-    audioFormat.setByteOrder(QAudioFormat::BigEndian);
-    QVERIFY(audioFormat.byteOrder() == QAudioFormat::BigEndian);
-
-    QTest::ignoreMessage(QtDebugMsg, "BigEndian");
-    qDebug() << QAudioFormat::BigEndian;
-}
-
-void tst_QAudioFormat::checkSampleType()
-{
-    QAudioFormat audioFormat;
-    audioFormat.setSampleType(QAudioFormat::SignedInt);
-    QVERIFY(audioFormat.sampleType() == QAudioFormat::SignedInt);
-    QTest::ignoreMessage(QtDebugMsg, "SignedInt");
-    qDebug() << QAudioFormat::SignedInt;
+    audioFormat.setSampleFormat(QAudioFormat::Int16);
+    QVERIFY(audioFormat.sampleFormat() == QAudioFormat::Int16);
+    QTest::ignoreMessage(QtDebugMsg, "Int16");
+    qDebug() << QAudioFormat::Int16;
 
-    audioFormat.setSampleType(QAudioFormat::Unknown);
-    QVERIFY(audioFormat.sampleType() == QAudioFormat::Unknown);
+    audioFormat.setSampleFormat(QAudioFormat::Unknown);
+    QVERIFY(audioFormat.sampleFormat() == QAudioFormat::Unknown);
     QTest::ignoreMessage(QtDebugMsg, "Unknown");
     qDebug() << QAudioFormat::Unknown;
 
-    audioFormat.setSampleType(QAudioFormat::UnSignedInt);
-    QVERIFY(audioFormat.sampleType() == QAudioFormat::UnSignedInt);
-    QTest::ignoreMessage(QtDebugMsg, "UnSignedInt");
-    qDebug() << QAudioFormat::UnSignedInt;
+    audioFormat.setSampleFormat(QAudioFormat::UInt8);
+    QVERIFY(audioFormat.sampleFormat() == QAudioFormat::UInt8);
+    QTest::ignoreMessage(QtDebugMsg, "UInt8");
+    qDebug() << QAudioFormat::UInt8;
 
-    audioFormat.setSampleType(QAudioFormat::Float);
-    QVERIFY(audioFormat.sampleType() == QAudioFormat::Float);
+    audioFormat.setSampleFormat(QAudioFormat::Float);
+    QVERIFY(audioFormat.sampleFormat() == QAudioFormat::Float);
     QTest::ignoreMessage(QtDebugMsg, "Float");
     qDebug() << QAudioFormat::Float;
 }
@@ -133,15 +107,11 @@ void tst_QAudioFormat::checkEquality()
     // on filled formats
     audioFormat0.setSampleRate(8000);
     audioFormat0.setChannelCount(1);
-    audioFormat0.setSampleSize(8);
-    audioFormat0.setByteOrder(QAudioFormat::LittleEndian);
-    audioFormat0.setSampleType(QAudioFormat::UnSignedInt);
+    audioFormat0.setSampleFormat(QAudioFormat::UInt8);
 
     audioFormat1.setSampleRate(8000);
     audioFormat1.setChannelCount(1);
-    audioFormat1.setSampleSize(8);
-    audioFormat1.setByteOrder(QAudioFormat::LittleEndian);
-    audioFormat1.setSampleType(QAudioFormat::UnSignedInt);
+    audioFormat1.setSampleFormat(QAudioFormat::UInt8);
 
     QVERIFY(audioFormat0 == audioFormat1);
     QVERIFY(!(audioFormat0 != audioFormat1));
@@ -158,9 +128,7 @@ void tst_QAudioFormat::checkAssignment()
 
     audioFormat0.setSampleRate(8000);
     audioFormat0.setChannelCount(1);
-    audioFormat0.setSampleSize(8);
-    audioFormat0.setByteOrder(QAudioFormat::LittleEndian);
-    audioFormat0.setSampleType(QAudioFormat::UnSignedInt);
+    audioFormat0.setSampleFormat(QAudioFormat::UInt8);
 
     audioFormat1 = audioFormat0;
     QVERIFY(audioFormat1 == audioFormat0);
@@ -240,11 +208,9 @@ void tst_QAudioFormat::checkSizes_data()
     QAudioFormat f;
     QTest::newRow("invalid") << f << 0 << 0 << 0LL << 0 << 0 << 0LL << 0 << 0;
 
-    f.setByteOrder(QAudioFormat::LittleEndian);
     f.setChannelCount(1);
     f.setSampleRate(8000);
-    f.setSampleSize(8);
-    f.setSampleType(QAudioFormat::SignedInt);
+    f.setSampleFormat(QAudioFormat::UInt8);
 
     qint64 qrtr = 250000LL;
     qint64 half = 500000LL;
@@ -257,7 +223,7 @@ void tst_QAudioFormat::checkSizes_data()
     QTest::newRow("1ch_8b_8k_signed_16000") << f << 1 << 16000 << two << 16000 << 16000 << two << 16000 << 16000;
 
     // Mono 16bit
-    f.setSampleSize(16);
+    f.setSampleFormat(QAudioFormat::Int16);
     QTest::newRow("1ch_16b_8k_signed_8000") << f << 2 << 8000 << half << 4000 << 8000 << half << 8000 << 4000;
     QTest::newRow("1ch_16b_8k_signed_16000") << f << 2 << 16000 << one << 8000 << 16000 << one << 16000 << 8000;