MP4 Parser: Simplified API

Author: pschatzmann

src/AudioTools/AudioCodecs/AudioCodecsBase.h

@@ -28,9 +28,9 @@ class AudioDecoder : public AudioWriter, public AudioInfoSource {
   void setAudioInfo(AudioInfo from) override {
     TRACED();
     if (info != from) {
+      info = from;
       notifyAudioChange(from);
     }
-    info = from;
   }
   /// Defines where the decoded result is written to
   virtual void setOutput(AudioStream &out_stream) {

src/AudioTools/AudioCodecs/ContainerM4A.h

@@ -37,7 +37,9 @@ class ContainerM4A : public ContainerDecoder {
    * @param out_stream Output AudioStream.
    */
   void setOutput(Print& out_stream) override {
-    if (p_decoder != nullptr) p_decoder->setOutput(out_stream);
+    if (p_decoder != nullptr && p_decoder->getOutput()!=&out_stream) {
+      p_decoder->setOutput(out_stream);
+    } 
     ContainerDecoder::setOutput(out_stream);
   }
 
@@ -115,6 +117,10 @@ class ContainerM4A : public ContainerDecoder {
     return true;
   }
 
+  M4AAudioDemuxer& getDemuxer() {
+    return demux;
+  }
+
  protected:
   bool is_active = false;  ///< True if demuxer is active.
   bool is_magic_cookie_processed =
@@ -135,7 +141,7 @@ class ContainerM4A : public ContainerDecoder {
       return;
     }
     MultiDecoder& dec = *(self->p_decoder);
-    const char* current_mime = dec.selectedMime();
+    const char* old_mime = dec.selectedMime();
 
     // select decoder based on mime type
     if (!dec.selectDecoder(frame.mime)) {
@@ -158,9 +164,10 @@ class ContainerM4A : public ContainerDecoder {
     }
     // write encoded data to decoder
     dec.write(frame.data, frame.size);
+    
+    // restore previous decoder
+    dec.selectDecoder(old_mime);  
 
-    // restore the original mime type
-    dec.selectDecoder(current_mime);
   }
 };
 

src/AudioTools/AudioCodecs/M4AAudioDemuxer.h

@@ -28,8 +28,8 @@ class M4AAudioDemuxer : public M4ACommonDemuxer {
    * @brief Initializes the demuxer and resets state.
    */
   bool begin() {
-    codec = Codec::Unknown;
-    alacMagicCookie.clear();
+    audio_config.codec = Codec::Unknown;
+    audio_config.alacMagicCookie.clear();
     resize(default_size);
 
     stsz_processed = false;
@@ -58,51 +58,32 @@ class M4AAudioDemuxer : public M4ACommonDemuxer {
    * @brief Returns the ALAC magic cookie (codec config).
    * @return Reference to the ALAC magic cookie vector.
    */
-  Vector<uint8_t>& getALACMagicCookie() { return alacMagicCookie; }
+  Vector<uint8_t>& getALACMagicCookie() { return audio_config.alacMagicCookie; }
 
   /**
    * @brief Sets a reference pointer for callbacks.
    * @param ref Reference pointer.
    */
   void setReference(void* ref) { this->ref = ref; }
 
-  /**
-   * @brief Resizes the internal buffer.
-   * @param size New buffer size.
-   */
-  void resize(int size) {
-    default_size = size;
-    if (buffer.size() < size) {
-      buffer.resize(size);
-    }
+  void copyFrom(M4ACommonDemuxer& source) {
+    audio_config = source.getM4AAudioConfig();
   }
 
  protected:
-  SingleBuffer<uint8_t> buffer;     ///< Buffer for incremental data.
-  void* ref = nullptr;              ///< Reference pointer for callbacks.
-  size_t default_size = 2 * 1024;   ///< Default buffer size.
+  void* ref = nullptr;  ///< Reference pointer for callbacks.
 
   /**
    * @brief Setup all parser callbacks
    */
-  virtual void setupParser() {
+  void setupParser() override {
     // global box data callback to get sizes
     parser.setReference(this);
-    parser.setCallback(boxDataSetupCallback);
 
-    // incremental data callback
-    parser.setIncrementalDataCallback(incrementalBoxDataCallback);
-
-    // Register a specific incremental data callback for mdat
-    parser.setIncrementalDataCallback(
-        "mdat",
-        [](MP4Parser::Box& box, const uint8_t* data, size_t len, bool is_final,
-           void* ref) {
-          auto* self = static_cast<M4AAudioDemuxer*>(ref);
-          LOGI("*Box: %s, size: %u bytes", box.type, (unsigned)len);
-          self->sampleExtractor.write(data, len, is_final);
-        },
-        false);
+    // parsing for content of stsd (Sample Description Box)
+    parser.setCallback("stsd", [](MP4Parser::Box& box, void* ref) {
+      static_cast<M4AAudioDemuxer*>(ref)->onStsd(box);
+    });
 
     // parsing for content of stsd (Sample Description Box)
     parser.setCallback("esds", [](MP4Parser::Box& box, void* ref) {
@@ -114,107 +95,37 @@ class M4AAudioDemuxer : public M4ACommonDemuxer {
     parser.setCallback("alac", [](MP4Parser::Box& box, void* ref) {
       static_cast<M4AAudioDemuxer*>(ref)->onAlac(box);
     });
+
+    // mdat
     parser.setCallback(
         "mdat",
         [](MP4Parser::Box& box, void* ref) {
           M4AAudioDemuxer& self = *static_cast<M4AAudioDemuxer*>(ref);
           // mdat must not be buffered
-          LOGI("Box: %s, size: %u bytes", box.type, (unsigned)box.size);
-          self.sampleExtractor.setMaxSize(box.size);
+          LOGI("#%d Box: %s, size: %u of %u bytes", (unsigned) box.seq, box.type,(unsigned) box.available, (unsigned)box.size);
+          if (box.seq == 0) self.sampleExtractor.setMaxSize(box.size);
+          size_t written = self.sampleExtractor.write(box.data, box.available, box.is_complete);
+          assert(written == box.available);
         },
         false);  // 'false' prevents the generic callback from being executed
-  }
-
-  /**
-   * @brief Checks if a box type is relevant for audio demuxing.
-   * @param type Box type string.
-   * @return True if relevant, false otherwise.
-   */
-  static bool isRelevantBox(const char* type) {
-    // Check if the box is relevant for audio demuxing
-    return (StrView(type) == "stsd" || StrView(type) == "stsz" ||
-            StrView(type) == "stco");
-  }
-
-  /**
-   * @brief Callback for box data setup. If we contain data we add
-   * it to the buffer. If there is no data we set up the buffer to
-   * receive incremental data.
-   * @param box MP4 box.
-   * @param ref Reference pointer.
-   */
-  static void boxDataSetupCallback(MP4Parser::Box& box, void* ref) {
-    M4AAudioDemuxer& self = *static_cast<M4AAudioDemuxer*>(ref);
-
-    bool is_relevant = isRelevantBox(box.type);
-    if (is_relevant) {
-      LOGI("Box: %s, size: %u bytes", box.type, (unsigned)box.size);
-      if (box.data_size == 0) {
-        // setup for incremental processing
-        self.resize(box.size);
-        self.buffer.clear();
-      } else {
-        // we have the complete box data
-        self.processBox(box);
-      }
-    }
-  }
 
-  /**
-   * @brief Callback for incremental box data.
-   * @param box MP4 box.
-   * @param data Pointer to data.
-   * @param len Length of data.
-   * @param is_final True if this is the last chunk.
-   * @param ref Reference pointer.
-   */
-  static void incrementalBoxDataCallback(MP4Parser::Box& box,
-                                         const uint8_t* data, size_t len,
-                                         bool is_final, void* ref) {
-    M4AAudioDemuxer& self = *static_cast<M4AAudioDemuxer*>(ref);
-
-    // mdat is now handled by its specific incremental callback, so remove logic
-    // here
-
-    // only process relevant boxes
-    if (!isRelevantBox(box.type)) return;
-
-    LOGI("*Box: %s, size: %u bytes", box.type, (unsigned)len);
-
-    // others fill buffer incrementally
-    if (len > 0) {
-      size_t written = self.buffer.writeArray(data, len);
-      if (written != len) {
-        LOGE("Failed to write all data to buffer, written: %zu, expected: %zu",
-             written, len);
-      }
-    }
-
-    // on last chunk, call the specific box handler
-    if (is_final) {
-      MP4Parser::Box complete_box = box;
-      complete_box.data = self.buffer.data();
-      complete_box.data_size = self.buffer.size();
-      self.processBox(complete_box);
-      // The buffer might be quite large, so we resize it to the default size
-      self.resize(self.default_size);
-    }
-  }
+    // stsz
+    parser.setCallback(
+        "stsz",
+        [](MP4Parser::Box& box, void* ref) {
+          M4AAudioDemuxer& self = *static_cast<M4AAudioDemuxer*>(ref);
+          self.onStsz(box);
+        },
+        false);  // 'false' prevents the generic callback from being executed
 
-  /**
-   * @brief Processes a parsed MP4 box.
-   * @param box MP4 box.
-   */
-  void processBox(MP4Parser::Box& box) {
-    if (StrView(box.type) == "stsd") {
-      onStsd(box);
-    } else if (StrView(box.type) == "stsz") {
-      onStsz(box);
-    } else if (StrView(box.type) == "stco") {
-      // onStco(box); // currently not supported
-    }
+    // parser.setCallback(
+    //     "stco",
+    //     [](MP4Parser::Box& box, void* ref) {
+    //       M4AAudioDemuxer& self = *static_cast<M4AAudioDemuxer*>(ref);
+    //       self.onStco(box);
+    //     },
+    //     false);  // 'false' prevents the generic callback from being executed
   }
-
 };
 
 }  // namespace audio_tools