ICYStream.h

#pragma once
#ifdef USE_URL_ARDUINO
 
#include "AudioConfig.h"
#include "AudioHttp/URLStreamBuffered.h"
#include "AudioMetaData/MetaDataICY.h"
 
namespace audio_tools {
 
class ICYStream : public AbstractURLStream {
 public:
  ICYStream(int readBufferSize = DEFAULT_BUFFER_SIZE) {
    TRACEI();
    setReadBufferSize(readBufferSize);
  }
 
  ICYStream(Client& clientPar, int readBufferSize = DEFAULT_BUFFER_SIZE) {
    TRACEI();
    setReadBufferSize(readBufferSize);
    setClient(clientPar);
  }
 
  ICYStream(const char* network, const char* password,
            int readBufferSize = DEFAULT_BUFFER_SIZE) {
    TRACEI();
    setReadBufferSize(readBufferSize);
    setSSID(network);
    setPassword(password);
  }
 
  virtual bool setMetadataCallback(void (*fn)(MetaDataType info,
                                              const char* str,
                                              int len)) override {
    TRACED();
    callback = fn;
    icy.setCallback(fn);
    return true;
  }
 
  // Icy http get request to the indicated url
  virtual bool begin(const char* urlStr, const char* acceptMime = nullptr,
                     MethodID action = GET, const char* reqMime = "",
                     const char* reqData = "") override {
    TRACED();
    // accept metadata
    url.httpRequest().header().put("Icy-MetaData", "1");
    bool result = url.begin(urlStr, acceptMime, action, reqMime, reqData);
 
    if (result) {
      // setup icy
      ICYUrlSetup icySetup;
      int iceMetaint = icySetup.setup(url.httpRequest());
      // 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* buffer, size_t len) override {
    size_t result = 0;
    if (icy.hasMetaData()) {
      // get data
      int read = url.readBytes(buffer, len);
      // remove metadata from data
      int pos = 0;
      for (int j = 0; j < read; j++) {
        icy.processChar(buffer[j]);
        if (icy.isData()) {
          buffer[pos++] = buffer[j];
        }
      }
      result = pos;
    } else {
      // fast access if there is no metadata
      result = url.readBytes(buffer, len);
    }
    LOGD("%s: %zu -> %zu", LOG_METHOD, len, result);
    return result;
  }
 
  // Read character and processes using 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; }
 
  virtual HttpRequest& httpRequest() override { return url.httpRequest(); }
 
  void setReadBufferSize(int readBufferSize) {
    url.setReadBufferSize(readBufferSize);
  }
 
  void setClient(Client& client) override { url.setClient(client); }
 
  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);}
 
 protected:
  URLStream url;
  MetaDataICY icy;  // icy state machine
  void (*callback)(MetaDataType info, const char* str, int len) = nullptr;
};
 
}  // namespace audio_tools
#endif