ContainerM4A.h

#pragma once
 
#include "AudioTools/AudioCodecs/AudioCodecsBase.h"
#include "AudioTools/AudioCodecs/M4AAudioDemuxer.h"
#include "AudioTools/AudioCodecs/MultiDecoder.h"
 
namespace audio_tools {
 
class ContainerM4A : public ContainerDecoder {
 public:
  ContainerM4A() {
    demux.setReference(this);
    demux.setCallback(decodeAudio);
  };
 
  ContainerM4A(MultiDecoder& decoder) : ContainerM4A() { setDecoder(decoder); }
 
  void setOutput(Print& out_stream) override {
    if (p_decoder != nullptr && p_decoder->getOutput()!=&out_stream) {
      p_decoder->setOutput(out_stream);
    } 
    ContainerDecoder::setOutput(out_stream);
  }
 
  bool isResultPCM() override { return p_decoder != nullptr ? true : false; }
 
  bool begin() override {
    demux.begin();
    if (p_decoder) p_decoder->begin();
    is_active = true;
    return true;
  }
 
  void end() override {
    TRACED();
    is_active = false;
    is_magic_cookie_processed = false;
    if (p_decoder) p_decoder->end();
  }
 
  size_t write(const uint8_t* data, size_t len) override {
    if (is_active == false) return len;
    demux.write(data, len);
    return len;
  }
 
  operator bool() override { return is_active; }
  virtual void setSampleSizesBuffer(BaseBuffer<stsz_sample_size_t>& buffer) {
    demux.setSampleSizesBuffer(buffer);
  }
  virtual void setChunkOffsetsBuffer(BaseBuffer<uint32_t>& buffer) {
    demux.setChunkOffsetsBuffer(buffer);
  }
 
  bool setDecoder(MultiDecoder& decoder) {
    p_decoder = &decoder;
    p_decoder->addNotifyAudioChange(*this);
    return true;
  }
 
  M4AAudioDemuxer& getDemuxer() {
    return demux;
  }
 
 protected:
  bool is_active = false;  
  bool is_magic_cookie_processed =
      false;  
  MultiDecoder* p_decoder = nullptr;  
  M4AAudioDemuxer demux;              
 
  static void decodeAudio(const M4AAudioDemuxer::Frame& frame, void* ref) {
    ContainerM4A* self = static_cast<ContainerM4A*>(ref);
    if (self->p_decoder == nullptr) {
      self->p_print->write(frame.data, frame.size);
      return;
    }
    MultiDecoder& dec = *(self->p_decoder);
    const char* old_mime = dec.selectedMime();
 
    // select decoder based on mime type
    if (!dec.selectDecoder(frame.mime)) {
      const char* mime = frame.mime ? frame.mime : "(nullptr)";
      LOGE("No decoder found for mime type: %s", mime);
      return;
    }
 
    // for ALAC only: process magic cookie if not done yet
    if (StrView(frame.mime) == "audio/alac" &&
        !self->is_magic_cookie_processed) {
      auto& magic_cookie = self->demux.getALACMagicCookie();
      if (magic_cookie.size() > 0) {
        if (!dec.setCodecConfig(magic_cookie.data(), magic_cookie.size())) {
          LOGE("Failed to set ALAC magic cookie for decoder: %s",
               dec.selectedMime());
        }
      }
      self->is_magic_cookie_processed = true;
    }
    // write encoded data to decoder
    dec.write(frame.data, frame.size);
    
    // restore previous decoder
    dec.selectDecoder(old_mime);  
 
  }
};
 
}  // namespace audio_tools