MimeDetector: new setCheck method

Author: pschatzmann

src/AudioTools/AudioCodecs/MultiDecoder.h

@@ -3,7 +3,7 @@
 
 #include "AudioTools/AudioCodecs/AudioCodecsBase.h"
 #include "AudioTools/CoreAudio/AudioBasic/StrView.h"
-#include "AudioTools/CoreAudio/MimeDetector.h"
+#include "AudioTools/CoreAudio/AudioMetaData/MimeDetector.h"
 
 namespace audio_tools {
 
@@ -43,6 +43,13 @@ class MultiDecoder : public AudioDecoder {
     decoder.addNotifyAudioChange(*this);
     decoders.push_back(info);
   }
+  
+  /// Adds a decoder that will be selected by it's mime type and defines the mime checking logic
+  void addDecoder(AudioDecoder& decoder, const char* mime, bool(*check)(uint8_t*data, size_t len)) {
+    addDecoder(decoder, mime);
+    mime_detector.setCheck(mime, check);
+  }
+
 
   virtual void setOutput(Print &out_stream) override { 
     p_print = &out_stream; 
@@ -99,11 +106,6 @@ class MultiDecoder : public AudioDecoder {
     // decode the data
     return actual_decoder.decoder->write(data, len);
   }
-  /// Define your own custom mime detector
-  void setMimeDetector(const char* (*mimeDetectCallback)(uint8_t* data,
-                                                         size_t len)) {
-    mime_detector.setMimeDetector(mimeDetectCallback);
-  }
 
   virtual operator bool() { 
     if (actual_decoder.decoder == &nop) return false;

src/AudioTools/CoreAudio/AudioMetaData/MimeDetector.h

@@ -0,0 +1,118 @@
+#pragma once
+
+#include "AudioTools/CoreAudio/AudioBasic/StrView.h"
+
+namespace audio_tools {
+
+/**
+ * @brief  Logic to detemine the mime type from the content.
+ * By default the following mime types are supported (audio/aac, audio/mpeg,
+ * audio/vnd.wave, audio/ogg). You can register your own custom detection logic
+ * to cover additional file types.
+ * @ingroup codecs
+ * @ingroup decoder
+ * @author Phil Schatzmann
+ * @copyright GPLv3
+ */
+
+class MimeDetector {
+ public:
+  MimeDetector() {
+    setCheck("audio/aac", checkAAC);
+    setCheck("audio/mpeg", checkMP3);
+    setCheck("audio/vnd.wave", checkWAV);
+    setCheck("audio/ogg", checkOGG);
+  }
+
+  bool begin() {
+    is_first = true;
+    return true;
+  }
+
+  /// write the header to determine the mime
+  size_t write(uint8_t* data, size_t len) {
+    determineMime(data, len);
+    return len;
+  }
+
+  /// adds/updates the checking logic for the indicated mime
+  void setCheck(const char* mime, bool (*check)(uint8_t* start, size_t len)) {
+    StrView mime_str{mime};
+    for (int j = 0; j < checks.size(); j++) {
+      Check l_check = checks[j];
+      if (mime_str.equals(l_check.mime)) {
+        l_check.check = check;
+        return;
+      }
+    }
+    Check check_to_add{mime, check};
+    checks.push_back(check_to_add);
+  }
+ 
+  // /// Define the callback that will notify about mime changes
+  void setMimeCallback(void (*callback)(const char*)) {
+    TRACED();
+    this->notifyMimeCallback = callback;
+  }
+
+  /// Provides the actual mime type, that was determined from the first
+  /// available data
+  const char* mime() { return actual_mime; }
+
+  static bool checkAAC(uint8_t* start, size_t len) {
+    return start[0] == 0xFF &&
+           (start[1] == 0xF0 || start[1] == 0xF1 || start[1] == 0xF9);
+  }
+
+  static bool checkMP3(uint8_t* start, size_t len) {
+    return memcmp(start, "ID3", 3) == 0 ||
+           (start[0] == 0xFF && ((start[1] & 0xE0) == 0xE0));
+  }
+
+  static bool checkWAV(uint8_t* start, size_t len) {
+    return memcmp(start, "OggS", 4) == 0;
+  }
+
+  static bool checkOGG(uint8_t* start, size_t len) {
+    return memcmp(start, "OggS", 4) == 0;
+  }
+ 
+ protected:
+  struct Check {
+    const char* mime = nullptr;
+    bool (*check)(uint8_t* data, size_t len) = nullptr;
+    Check(const char* mime, bool (*check)(uint8_t* data, size_t len)) {
+      this->mime = mime;
+      this->check = check;
+    }
+    Check() = default;
+  };
+  Vector<Check> checks{0};
+  bool is_first = false;
+  const char* actual_mime = nullptr;
+  void (*notifyMimeCallback)(const char* mime) = nullptr;
+
+  /// Update the mime type
+  void determineMime(void* data, size_t len) {
+    if (is_first) {
+      actual_mime = lookupMime((uint8_t*)data, len);
+      if (notifyMimeCallback != nullptr && actual_mime != nullptr) {
+        notifyMimeCallback(actual_mime);
+      }
+      is_first = false;
+    }
+  }
+
+  /// Default logic which supports aac, mp3, wav and ogg
+  const char* lookupMime(uint8_t* data, size_t len) {
+    for (int j = 0; j < checks.size(); j++) {
+      Check l_check = checks[j];
+      if (l_check.check(data, len)) {
+        return l_check.mime;
+      }
+    }
+    return nullptr;
+  }
+};
+
+}  // namespace audio_tools

src/AudioTools/CoreAudio/MimeDetector.h

@@ -6,7 +6,7 @@
 #include "AudioTools/CoreAudio/BaseConverter.h"
 #include "AudioTools/CoreAudio/AudioLogger.h"
 #include "AudioTools/CoreAudio/AudioStreams.h"
-#include "AudioTools/CoreAudio/MimeDetector.h"
+#include "AudioTools/CoreAudio/AudioMetaData/MimeDetector.h"
 
 #define NOT_ENOUGH_MEMORY_MSG "Could not allocate enough memory: %d bytes"
 
@@ -352,10 +352,6 @@ class StreamCopyT {
             mime_detector.setMimeCallback(callback);
         }
 
-        /// Defines the mime detector
-        void setMimeDetector(const char* (*mimeDetectCallback)(uint8_t* data, size_t len)){
-            mime_detector.setMimeDetector(mimeDetectCallback);
-        }
 
     protected:
         Stream *from = nullptr;