MultiDecoder.h

 
#pragma once
 
#include "AudioTools/AudioCodecs/AudioCodecsBase.h"
#include "AudioTools/CoreAudio/AudioBasic/StrView.h"
#include "AudioTools/CoreAudio/AudioHttp/AbstractURLStream.h"
#include "AudioTools/CoreAudio/AudioMetaData/MimeDetector.h"
#include "AudioTools/AudioCodecs/StreamingDecoder.h"
 
namespace audio_tools {
 
class MultiDecoder : public AudioDecoder {
 public:
  MultiDecoder() = default;
  
  MultiDecoder(MimeSource& mimeSource) { setMimeSource(mimeSource); }
 
 #ifdef USE_EXPERIMENTAL 
  ~MultiDecoder() {
    // Clean up any adapters we created
    for (auto* adapter : adapters) {
      delete adapter;
    }
    adapters.clear();    
  }
#endif
 
  bool begin() override {
    mime_detector.begin();
    is_first = true;
    if (p_print == nullptr) {
      LOGE("No output defined");
      return false;
    }
    return true;
  }
 
  void end() override {
    if (actual_decoder.decoder != nullptr && actual_decoder.is_open) {
      actual_decoder.decoder->end();
    }
    actual_decoder.is_open = false;
    actual_decoder.decoder = nullptr;
    actual_decoder.mime = nullptr;
    is_first = true;
  }
 
  void addDecoder(AudioDecoder& decoder, const char* mime) {
    DecoderInfo info{mime, &decoder};
    decoder.addNotifyAudioChange(*this);
    decoders.push_back(info);
  }
 
  void addDecoder(AudioDecoder& decoder, const char* mime,
                  bool (*check)(uint8_t* data, size_t len)) {
    addDecoder(decoder, mime);
    mime_detector.setCheck(mime, check);
  }
 
  void setOutput(Print& out_stream) override {
    p_print = &out_stream;
  }
 
  void setMimeSource(MimeSource& mimeSource) { p_mime_source = &mimeSource; }
 
  bool selectDecoder(const char* mime) {
    bool result = false;
    if (mime == nullptr) return false;
    // do nothing if no change
    if (StrView(mime).equals(actual_decoder.mime)) {
      is_first = false;
      return true;
    }
    // close actual decoder 
    if (actual_decoder.decoder != this) end();
 
    // find the corresponding decoder
    selected_mime = nullptr;
    for (int j = 0; j < decoders.size(); j++) {
      DecoderInfo info = decoders[j];
      if (StrView(info.mime).equals(mime)) {
        LOGI("Using decoder for %s (%s)", info.mime, mime);
        actual_decoder = info;
        // define output if it has not been defined
        if (p_print != nullptr && actual_decoder.decoder != this 
          && actual_decoder.decoder->getOutput() == nullptr) {
          actual_decoder.decoder->setOutput(*p_print);
        }
        if (!*actual_decoder.decoder) {
          actual_decoder.decoder->begin();
          LOGI("Decoder %s started", actual_decoder.mime);
        }
        result = true;
        selected_mime = mime;
        break;
      }
    }
    is_first = false;
    return result;
  }
 
  const char* selectedMime() { return selected_mime; }
 
  size_t write(const uint8_t* data, size_t len) override {
    if (is_first) {
      const char* mime = nullptr;
      if (p_mime_source != nullptr) {
        // get content type from http header
        mime = p_mime_source->mime();
        if (mime) LOGI("mime from http request: %s", mime);
      }
      if (mime == nullptr) {
        // use the mime detector
        mime_detector.write((uint8_t*)data, len);
        mime = mime_detector.mime();
        if (mime) LOGI("mime from mime_detector: %s", mime);
      }
      if (mime != nullptr) {
        // select the decoder based on the detemined mime type
        if (!selectDecoder(mime)) {
          LOGE("The decoder could not be found for %s", mime);
          actual_decoder.decoder = &nop;
          actual_decoder.is_open = true;
        }
      }
      is_first = false;
    }
    // check if we have a decoder
    if (actual_decoder.decoder == nullptr) return 0;
    // decode the data
    return actual_decoder.decoder->write(data, len);
  }
 
  virtual operator bool() override {
    if (actual_decoder.decoder == &nop) return false;
    return is_first || actual_decoder.is_open;
  };
 
  bool setCodecConfig(const uint8_t* data, size_t len) override {
    if (actual_decoder.decoder == nullptr) {
      LOGE("No decoder defined, cannot set codec config");
      return false;
    }
    return actual_decoder.decoder->setCodecConfig(data, len);
  }
 
  MimeDetector& mimeDetector() { return mime_detector; }
 
#ifdef USE_EXPERIMENTAL 
 
  void addDecoder(StreamingDecoder& decoder, const char* mime,
                  int bufferSize = 1024) {
    if (mime != nullptr) {
      // Create a DecoderAdapter to wrap the StreamingDecoder
      decoder.addNotifyAudioChange(*this);
      auto adapter = new DecoderAdapter(decoder, bufferSize);
      adapters.push_back(adapter);  // Store for cleanup
      
      // Add the adapter as a regular AudioDecoder
      addDecoder(*adapter, mime);
    } else {
      LOGE("MIME type is nullptr - cannot add StreamingDecoder");
    }
  }
#endif
 
 protected:
  struct DecoderInfo {
    const char* mime = nullptr;           
    AudioDecoder* decoder = nullptr;      
    bool is_open = false;                 
    
    DecoderInfo() = default;
    
    DecoderInfo(const char* mime, AudioDecoder* decoder) {
      this->mime = mime;
      this->decoder = decoder;
    }
  } actual_decoder;                       
  
  Vector<DecoderInfo> decoders{0};        
#ifdef USE_EXPERIMENTAL 
  Vector<DecoderAdapter*> adapters{0};    
#endif
  MimeDetector mime_detector;             
  CodecNOP nop;                           
  MimeSource* p_mime_source = nullptr;    
  bool is_first = true;                   
  const char* selected_mime = nullptr;    
};
 
}  // namespace audio_tools