DecoderFromStreaming.h

#pragma once
 
#include "AudioCodecs/AudioEncoded.h"
#include "AudioTools/Buffers.h"
#include "AudioTools/AudioStreams.h"
 
namespace audio_tools {
 
class DecoderAdapter : public AudioDecoder {
public:
  DecoderAdapter(StreamingDecoder &dec, int bufferSize) {
    TRACED();
    p_dec = &dec;
    p_dec->setInput(queue);
    resize(bufferSize);
  }
 
  void setOutput(Print &out) override {
    p_dec->setOutput(out);
  }
 
  void setInput(Stream& in){
    p_dec->setInput(in);
  }
 
  bool begin() override {
    TRACED();
    active = true;
    bool rc = p_dec->begin();
    return rc;
  }
 
  void end() override {
    TRACED();
    active = false;
  }
 
  void resize(int size){
    buffer_size = size;
    // setup the buffer only if needed
    if (is_setup) rbuffer.resize(size);
  }
 
  size_t write(const void *data, size_t byteCount) override {
    TRACED();
    setupLazy();
    size_t result = queue.write((uint8_t *)data, byteCount);
    // trigger processing - we leave byteCount in the buffer
    // while(queue.available()>byteCount){
    //   p_dec->copy(); 
    //   delay(1);
    // }
    while(p_dec->copy());
    
    return result;
  }
 
  StreamingDecoder* getStreamingDecoder(){
    return p_dec;
  }
 
  operator bool() override { return active; }
 
protected:
  bool active = false;
  bool is_setup = false;
  int buffer_size;
  StreamingDecoder *p_dec = nullptr;
  RingBuffer<uint8_t> rbuffer{0};
  QueueStream<uint8_t> queue{rbuffer}; // convert Buffer to Stream
 
  void setupLazy(){
    if (!is_setup){
      rbuffer.resize(buffer_size);
      queue.begin();
      is_setup = true;
    }
  }
};
 
using DecoderFromStreaming = DecoderAdapter;
 
} // namespace audio_tools