ICYStreamT.h

#pragma once
#include "AudioTools/CoreAudio/AudioHttp/AbstractURLStream.h"
#include "AudioTools/CoreAudio/AudioMetaData/MetaDataICY.h"
#include "AudioToolsConfig.h"
 
namespace audio_tools {
 
template <class T>
class ICYStreamT : public AbstractURLStream {
 public:
  ICYStreamT(int readBufferSize = DEFAULT_BUFFER_SIZE) {
    TRACEI();
    setReadBufferSize(readBufferSize);
  }
 
  ICYStreamT(const char* ssid, const char* password,
             int readBufferSize = DEFAULT_BUFFER_SIZE)
      : ICYStreamT(readBufferSize) {
    TRACEI();
    setSSID(ssid);
    setPassword(password);
  }
 
  ICYStreamT(Client& clientPar, int readBufferSize = DEFAULT_BUFFER_SIZE)
      : ICYStreamT(readBufferSize) {
    TRACEI();
    setClient(clientPar);
  }
 
  virtual bool setMetadataCallback(void (*fn)(MetaDataType info,
                                              const char* str,
                                              int len)) override {
    TRACED();
    callback = fn;
    icy.setCallback(fn);
    return true;
  }
 
  // Performs an HTTP request to the indicated URL with ICY metadata enabled
  virtual bool begin(const char* urlStr, const char* acceptMime = nullptr,
                     MethodID action = GET, const char* reqMime = "",
                     const char* reqData = "") override {
    TRACED();
    // accept metadata
    addRequestHeader("Icy-MetaData", "1");
    bool result = url.begin(urlStr, acceptMime, action, reqMime, reqData);
 
    if (result) {
      // setup icy
      ICYUrlSetup icySetup;
      int iceMetaint = icySetup.setup(*this);
      // callbacks from http request
      icySetup.executeCallback(callback);
      icy.setIcyMetaInt(iceMetaint);
      icy.begin();
 
      if (!icy.hasMetaData()) {
        LOGW("url does not provide metadata");
      }
    }
    return result;
  }
 
  virtual void end() override {
    TRACED();
    url.end();
    icy.end();
  }
 
  virtual int available() override { return url.available(); }
 
  virtual size_t readBytes(uint8_t* data, size_t len) override {
    size_t result = 0;
    if (icy.hasMetaData()) {
      // get data
      int read = url.readBytes(data, len);
      // remove metadata from data
      int pos = 0;
      for (int j = 0; j < read; j++) {
        icy.processChar(data[j]);
        if (icy.isData()) {
          data[pos++] = data[j];
        }
      }
      result = pos;
    } else {
      // fast access if there is no metadata
      result = url.readBytes(data, len);
    }
    LOGD("%s: %zu -> %zu", LOG_METHOD, len, result);
    return result;
  }
 
  // Reads a single audio byte, skipping metadata via the MetaDataICY state engine
  virtual int read() override {
    int ch = -1;
 
    // get next data byte
    do {
      ch = url.read();
      if (ch == -1) {
        break;
      }
 
      icy.processChar(ch);
    } while (!icy.isData());
    return ch;
  }
 
  operator bool() { return url; }
 
  void setReadBufferSize(int readBufferSize) {
    url.setReadBufferSize(readBufferSize);
  }
 
  void setSSID(const char* ssid) override { url.setSSID(ssid); }
 
  void setPassword(const char* password) override { url.setPassword(password); }
 
  void setPowerSave(bool active) { url.setPowerSave(active); }
 
  void setCACert(const char* cert) { url.setCACert(cert); }
  void addRequestHeader(const char* key, const char* value) override {
    url.addRequestHeader(key, value);
  }
  const char* getReplyHeader(const char* key) override {
    return url.getReplyHeader(key);
  }
 
  virtual HttpRequest& httpRequest() override { return url.httpRequest(); }
 
  void setClient(Client& client) override { url.setClient(client); }
 
  void setConnectionClose(bool flag) override { url.setConnectionClose(flag); }
  const char* urlStr() override { return url.urlStr(); }
  size_t totalRead() override { return url.totalRead(); };
  int contentLength() override { return url.contentLength(); };
  bool waitForData(int timeout) override { return url.waitForData(timeout); }
 
 protected:
  T url;
  MetaDataICY icy;  // icy state machine
  void (*callback)(MetaDataType info, const char* str, int len) = nullptr;
};
 
}  // namespace audio_tools