Merge branch 'main' of https://github.com/pschatzmann/arduino-audio-tools

Author: pschatzmann

src/AudioTools/AudioCodecs/MP3HeaderParser.h

@@ -178,14 +178,14 @@ class MP3HeaderParser {
     }
 
     int getFrameLength() {
-      return int((144 * getBitrate() / getSampleRate()) + header.Padding);
+      return int((144 * getBitrate() / getSampleRate()) + Padding);
     }
 
   };
 
  public:
   /// parses the header string and returns true if this is a valid mp3 file
-  bool isValid(uint8_t* data, int len) {
+  bool isValid(const uint8_t* data, int len) {
     memset(&header, 0, sizeof(header));
     StrView str((char*)data, len);
 
@@ -219,11 +219,11 @@ class MP3HeaderParser {
     StrView header_str((char*)data + pos, len_available);
     header = readFrameHeader(header_str);
 
-    // check end of frame: it must contains a synch word
-    int pos = findSynchWord(header_str.c_str(), header_str.length());
+    // check end of frame: it must contains a sync word
+    int end_pos = findSyncWord((uint8_t*)header_str.c_str(), header_str.length());
     int pos_expected = getFrameLength();
     if (pos_expected < header_str.length()){
-      if (pos != pos_expected){
+      if (end_pos != pos_expected){
         LOGE("Expected SynchWord missing");
         return false;
       }

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; 
@@ -101,11 +108,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,141 @@
+#pragma once
+
+#include "AudioTools/CoreAudio/AudioBasic/StrView.h"
+#include "AudioTools/AudioCodecs/MP3HeaderParser.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 checkAACExt(uint8_t* start, size_t len) {
+    // quick check
+    if (!start[0] == 0xFF &&
+        (start[1] == 0xF0 || start[1] == 0xF1 || start[1] == 0xF9))        
+      return false;
+    MP3HeaderParser mp3;
+    // it should start with a synch word
+    if (mp3.findSyncWord(start, len)!=0){
+      return false;
+    }
+    // make sure that it is not an mp3
+    if (mp3.isValid(start, len)){
+      return false;
+    }
+    return true;
+  }
+
+  static bool checkMP3(uint8_t* start, size_t len) {
+    return memcmp(start, "ID3", 3) == 0 ||
+           (start[0] == 0xFF && ((start[1] & 0xE0) == 0xE0));
+  }
+
+  static bool checkMP3Ext(uint8_t* start, size_t len) {
+    MP3HeaderParser mp3;
+    return mp3.isValid(start, len);
+  }
+
+  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;