M4AAudioDemuxer.h

#pragma once
 
#include "AudioTools/AudioCodecs/M4ACommonDemuxer.h"
 
namespace audio_tools {
 
class M4AAudioDemuxer : public M4ACommonDemuxer {
 public:
  M4AAudioDemuxer() { setupParser(); }
 
  void setCallback(FrameCallback cb) override {
    sampleExtractor.setReference(ref);
    sampleExtractor.setCallback(cb);
  }
  void setCallback(FrameCallback cb) override  {…}
 
  bool begin() {
    audio_config.codec = Codec::Unknown;
    audio_config.alacMagicCookie.clear();
    resize(default_size);
 
    stsz_processed = false;
    stco_processed = false;
 
    // When codec/sampleSizes/callback/ref change, update the extractor:
    parser.begin();
    sampleExtractor.begin();
    return true;
  }
  bool begin() {…}
 
  void write(const uint8_t* data, size_t len) { parser.write(data, len); }
 
  int availableForWrite() { return parser.availableForWrite(); }
 
  Vector<uint8_t>& getALACMagicCookie() { return audio_config.alacMagicCookie; }
 
  void setReference(void* ref) { this->ref = ref; }
 
  void copyFrom(M4ACommonDemuxer& source) {
    audio_config = source.getM4AAudioConfig();
  }
 
 protected:
  void* ref = nullptr;  
 
  void setupParser() override {
    // global box data callback to get sizes
    parser.setReference(this);
 
    // 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) {
      static_cast<M4AAudioDemuxer*>(ref)->onEsds(box);
    });
    parser.setCallback("mp4a", [](MP4Parser::Box& box, void* ref) {
      static_cast<M4AAudioDemuxer*>(ref)->onMp4a(box);
    });
    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("#%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
 
    // 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
 
    // 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
  }
  void setupParser() override  {…}
};
class M4AAudioDemuxer : public M4ACommonDemuxer {…};
 
}  // namespace audio_tools