MultiDecoder.h

Go to the documentation of this file.

 
#pragma once
 
#include <cstring>
#include "AudioTools/AudioCodecs/AudioCodecsBase.h"
#include "AudioTools/CoreAudio/AudioBasic/StrView.h"
#include "AudioTools/Communication/HTTP/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
 
  const char* mime() override { return actual_decoder.mime; }
 
  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 = nullptr) {
    const char* existing_mime = mime != nullptr ? mime : mime_detector.mime();
    LOGI("Adding decoder for %s", existing_mime);
    DecoderInfo info{existing_mime, &decoder};
    decoder.addNotifyAudioChange(*this);
    decoders.push_back(info);
  }
 
  void setOutput(Print& out_stream) override {
    p_print = &out_stream;
  }
 
  void setMimeSource(MimeSource& mimeSource) { p_mime_source = &mimeSource; }
 
  static void baseMimeType(const char* mime, char* out, size_t outSize) {
    size_t len = 0;
    while (mime[len] != '\0' && mime[len] != ';' && len < outSize - 1) len++;
    while (len > 0 && (mime[len - 1] == ' ' || mime[len - 1] == '\t')) len--;
    memcpy(out, mime, len);
    out[len] = '\0';
  }
 
  bool selectDecoder(const char* mime) {
    bool result = false;
    if (mime == nullptr) return false;
    // Same mime as before (e.g. back-to-back tracks of the same format):
    // still restart the decoder so state (bit reservoir, frame buffers,
    // etc.) from the previous track does not leak into the next one -
    // just keep the already resolved DecoderInfo instead of re-searching
    // the decoders list.
    if (StrView(mime).equalsIgnoreCase(actual_decoder.mime)) {
      is_first = false;
      if (actual_decoder.decoder != nullptr) {
        if (actual_decoder.is_open) actual_decoder.decoder->end();
        actual_decoder.decoder->begin();
        actual_decoder.is_open = true;
      }
      return true;
    }
    // close actual decoder
    if (actual_decoder.decoder != this) end();
 
    // A source may report a MIME type with an RFC 6381-style "codecs"
    // (or other) parameter, e.g. "audio/mpeg; codecs=\"mpeg1-layer2\"" -
    // a decoder registered for that exact parameterized type (a more
    // specific match) must win over one only registered for the plain
    // base type ("audio/mpeg"). Two passes, not one combined check: a
    // single pass stops at the first entry that matches *either* way, so
    // a generic base-type decoder registered before the specific one
    // would otherwise shadow it purely by list order.
    char base[64];
    baseMimeType(mime, base, sizeof(base));
    int exact_j = -1, base_j = -1;
    for (int j = 0; j < decoders.size(); j++) {
      if (StrView(decoders[j].mime).equalsIgnoreCase(mime)) { exact_j = j; break; }
      if (base_j < 0 && StrView(decoders[j].mime).equalsIgnoreCase(base)) base_j = j;
    }
    int match_j = exact_j >= 0 ? exact_j : base_j;
 
    // find the corresponding decoder
    selected_mime = nullptr;
    if (match_j >= 0) {
      DecoderInfo info = decoders[match_j];
      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);
      }
      // mark as open so that a later end()/format switch actually calls
      // decoder->end() instead of silently skipping it (is_open defaults
      // to false and was previously only ever set for the 'nop' fallback)
      actual_decoder.is_open = true;
      result = true;
      selected_mime = mime;
    }
    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