WavAudioImporter: have an enum for WAV audio formats.

Together with debug output it allowed me to reduce the amount of error
branches.

src/MagnumPlugins/WavAudioImporter/Test/WavImporterTest.cpp

@@ -30,6 +30,7 @@
 #include <Corrade/Utility/Directory.h>
 
 #include "MagnumPlugins/WavAudioImporter/WavImporter.h"
+#include "MagnumPlugins/WavAudioImporter/WavHeader.h"
 
 #include "configure.h"
 
@@ -60,6 +61,8 @@ class WavImporterTest: public TestSuite::Tester {
         void stereo64f();
 
         void surround616();
+
+        void debugAudioFormat();
 };
 
 WavImporterTest::WavImporterTest() {
@@ -82,7 +85,9 @@ WavImporterTest::WavImporterTest() {
               &WavImporterTest::mono32f,
               &WavImporterTest::stereo32f,
               &WavImporterTest::stereo64f,
-              &WavImporterTest::surround616});
+              &WavImporterTest::surround616,
+
+              &WavImporterTest::debugAudioFormat});
 }
 
 void WavImporterTest::wrongSize() {
@@ -109,7 +114,7 @@ void WavImporterTest::unsupportedFormat() {
 
     WavImporter importer;
     CORRADE_VERIFY(!importer.openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "unsupportedFormat.wav")));
-    CORRADE_COMPARE(out.str(), "Audio::WavImporter::openData(): unsupported audio format 2\n");
+    CORRADE_COMPARE(out.str(), "Audio::WavImporter::openData(): unsupported format Audio::WavAudioFormat(0x2)\n");
 }
 
 void WavImporterTest::unsupportedChannelCount() {
@@ -231,7 +236,14 @@ void WavImporterTest::surround616() {
     WavImporter importer;
 
     CORRADE_VERIFY(!importer.openFile(Utility::Directory::join(WAVAUDIOIMPORTER_TEST_DIR, "surround616.wav")));
-    CORRADE_COMPARE(out.str(), "Audio::WavImporter::openData(): unsupported audio format: extensible not implememented 65534\n");
+    CORRADE_COMPARE(out.str(), "Audio::WavImporter::openData(): unsupported format Audio::WavAudioFormat::Extensible\n");
+}
+
+void WavImporterTest::debugAudioFormat() {
+    std::ostringstream out;
+
+    Debug{&out} << WavAudioFormat::IeeeFloat << WavAudioFormat(0xdead);
+    CORRADE_COMPARE(out.str(), "Audio::WavAudioFormat::IeeeFloat Audio::WavAudioFormat(0xdead)\n");
 }
 
 }}}

src/MagnumPlugins/WavAudioImporter/WavHeader.cpp

@@ -35,4 +35,20 @@ static_assert(sizeof(RiffChunk) == 8, "RiffChunk size is not 8 bytes");
 static_assert(sizeof(WavHeaderChunk) == 12, "WavHeaderChunk size is not 12 bytes");
 static_assert(sizeof(WavFormatChunk) == 24, "WavFormatChunk size is not 18 bytes");
 
+Debug& operator<<(Debug& debug, const WavAudioFormat value) {
+    switch(value) {
+        /* LCOV_EXCL_START */
+        #define _c(value) case WavAudioFormat::value: return debug << "Audio::WavAudioFormat::" #value;
+        _c(Pcm)
+        _c(IeeeFloat)
+        _c(ALaw)
+        _c(MuLaw)
+        _c(Extensible)
+        #undef _c
+        /* LCOV_EXCL_STOP */
+    }
+
+    return debug << "Audio::WavAudioFormat(" << Debug::nospace << reinterpret_cast<void*>(UnsignedShort(value)) << Debug::nospace << ")";
+}
+
 }}

src/MagnumPlugins/WavAudioImporter/WavHeader.h

@@ -29,10 +29,19 @@
  * @brief Struct @ref Magnum::Audio::RiffChunk, @ref Magnum::Audio::WavHeaderChunk, @ref Magnum::Audio::WavFormatChunk, enum @ref Magnum::Audio::WavAudioFormat
  */
 
-#include "Magnum/Types.h"
+#include "MagnumPlugins/WavAudioImporter/WavImporter.h"
 
 namespace Magnum { namespace Audio {
 
+/** @brief WAV audio format */
+enum class WavAudioFormat: UnsignedShort {
+    Pcm = 0x0001,           /**< PCM */
+    IeeeFloat = 0x0003,     /**< IEEE Float */
+    ALaw = 0x0006,          /**< A-Law */
+    MuLaw = 0x0007,         /**< μ-Law */
+    Extensible = 0xfffe     /**< Extensible */
+};
+
 #pragma pack(1)
 /** @brief RIFF chunk */
 struct RiffChunk {
@@ -53,7 +62,7 @@ struct WavHeaderChunk {
 /** @brief WAV 'fmt' header */
 struct WavFormatChunk {
     RiffChunk chunk;                /**< @brief Starting RIFF chunk */
-    UnsignedShort audioFormat;      /**< @brief 1 = PCM */
+    WavAudioFormat audioFormat;     /**< @brief Audio format */
     UnsignedShort numChannels;      /**< @brief 1 = Mono, 2 = Stereo */
     UnsignedInt sampleRate;         /**< @brief Sample rate in Hz */
     UnsignedInt byteRate;           /**< @brief Bytes per second */
@@ -62,6 +71,9 @@ struct WavFormatChunk {
 };
 #pragma pack()
 
+/** @debugoperatorenum{WavAudioFormat} */
+MAGNUM_WAVAUDIOIMPORTER_EXPORT Debug& operator<<(Debug& debug, WavAudioFormat value);
+
 }}
 
 #endif

src/MagnumPlugins/WavAudioImporter/WavImporter.cpp

@@ -31,12 +31,6 @@
 
 #include "MagnumPlugins/WavAudioImporter/WavHeader.h"
 
-#define WAVE_FORMAT_PCM 0x0001
-#define WAVE_FORMAT_IEEE_FLOAT 0x0003
-#define WAVE_FORMAT_ALAW 0x0006
-#define WAVE_FORMAT_MULAW 0x0007
-#define WAVE_FORMAT_EXTENSIBLE 0xFFFE
-
 namespace Magnum { namespace Audio {
 
 WavImporter::WavImporter() = default;
@@ -125,7 +119,7 @@ void WavImporter::doOpenData(Containers::ArrayView<const char> data) {
         formatChunk->bitsPerSample);
 
     /* Check PCM format */
-    if(formatChunk->audioFormat == WAVE_FORMAT_PCM) {
+    if(formatChunk->audioFormat == WavAudioFormat::Pcm) {
         /* Decide about format */
         if(formatChunk->numChannels == 1 && formatChunk->bitsPerSample == 8)
             _format = Buffer::Format::Mono8;
@@ -143,7 +137,7 @@ void WavImporter::doOpenData(Containers::ArrayView<const char> data) {
         }
 
     /* Check IEEE Float format */
-    } else if(formatChunk->audioFormat == WAVE_FORMAT_IEEE_FLOAT) {
+    } else if(formatChunk->audioFormat == WavAudioFormat::IeeeFloat) {
         if(formatChunk->numChannels == 1 && formatChunk->bitsPerSample == 32)
             _format = Buffer::Format::MonoFloat;
         else if(formatChunk->numChannels == 2 && formatChunk->bitsPerSample == 32)
@@ -160,7 +154,7 @@ void WavImporter::doOpenData(Containers::ArrayView<const char> data) {
         }
 
     /* Check ALAW format */
-    } else if(formatChunk->audioFormat == WAVE_FORMAT_ALAW) {
+    } else if(formatChunk->audioFormat == WavAudioFormat::ALaw) {
         if(formatChunk->numChannels == 1)
             _format = Buffer::Format::MonoALaw;
         else if(formatChunk->numChannels == 2)
@@ -173,7 +167,7 @@ void WavImporter::doOpenData(Containers::ArrayView<const char> data) {
         }
 
     /* Check MULAW format */
-    } else if(formatChunk->audioFormat == WAVE_FORMAT_MULAW) {
+    } else if(formatChunk->audioFormat == WavAudioFormat::MuLaw) {
         if(formatChunk->numChannels == 1)
             _format = Buffer::Format::MonoMuLaw;
         else if(formatChunk->numChannels == 2)
@@ -184,13 +178,10 @@ void WavImporter::doOpenData(Containers::ArrayView<const char> data) {
                     << "bits per sample";
             return;
         }
-    /* We do not currently support EXTENSIBLE formats */
+
-    } else if(formatChunk->audioFormat == WAVE_FORMAT_EXTENSIBLE) {
+    /* Unknown/unimplemented format */
-        Error() << "Audio::WavImporter::openData(): unsupported audio format: extensible not implememented" << formatChunk->audioFormat;
-        return;
-    /* Unknown format */
     } else {
-        Error() << "Audio::WavImporter::openData(): unsupported audio format" << formatChunk->audioFormat;
+        Error() << "Audio::WavImporter::openData(): unsupported format" << formatChunk->audioFormat;
         return;
     }