MetaDataICY.h

#pragma once
#include "AudioToolsConfig.h"
#include "AbstractMetaData.h"
#include "AudioTools/CoreAudio/AudioBasic/StrView.h"
#include "AudioTools/Communication/HTTP/AbstractURLStream.h"
 
#ifndef AUDIOTOOLS_METADATA_ICY_ASCII_ONLY
#define AUDIOTOOLS_METADATA_ICY_ASCII_ONLY true
#endif
 
namespace audio_tools {
 
class MetaDataICY : public AbstractMetaData {
  enum Status { ProcessData, ProcessMetaData, SetupSize };
 
 public:
  MetaDataICY() = default;
 
  MetaDataICY(int metaint) { setIcyMetaInt(metaint); }
 
  virtual ~MetaDataICY() {}
 
  virtual void setIcyMetaInt(int value) override {
    this->mp3_blocksize = value;
  }
 
  virtual void setCallback(void (*fn)(MetaDataType info, const char* str,
                                      int len)) override {
    callback = fn;
  }
 
  virtual void setAudioDataCallback(void (*fn)(const uint8_t* str, int len),
                                    int bufferLen = 1024) {
    dataBuffer = new uint8_t[bufferLen];
    dataCallback = fn;
    dataLen = 0;
    dataPos = 0;
  }
 
  virtual bool begin() override {
    clear();
    LOGI("mp3_blocksize: %d", mp3_blocksize);
    return true;
  }
 
  virtual void end() override { clear(); }
 
  virtual size_t write(const uint8_t* data, size_t len) override {
    if (callback != nullptr) {
      for (size_t j = 0; j < len; j++) {
        processChar((char)data[j]);
      }
    }
    return len;
  }
 
  virtual Status status() { return currentStatus; }
 
  virtual bool isData() { return currentStatus == ProcessData; }
 
  virtual bool hasMetaData() { return this->mp3_blocksize > 0; }
 
  virtual int metaInt() { return mp3_blocksize; }
 
  virtual void processChar(char ch) {
    switch (nextStatus) {
      case ProcessData:
        currentStatus = ProcessData;
        processData(ch);
 
        // increment data counter and determine next status
        ++totalData;
        if (totalData >= mp3_blocksize) {
          LOGI("Data ended")
          totalData = 0;
          nextStatus = SetupSize;
        }
        break;
 
      case SetupSize:
        currentStatus = SetupSize;
        totalData = 0;
        metaDataPos = 0;
        metaDataLen = metaSize(ch);
        LOGI("metaDataLen: %d", metaDataLen);
        if (metaDataLen > 0) {
          if (metaDataLen > 200) {
            LOGI("Unexpected metaDataLen -> processed as data");
            nextStatus = ProcessData;
          } else {
            LOGI("Metadata found");
            setupMetaData(metaDataLen);
            nextStatus = ProcessMetaData;
          }
        } else {
          LOGI("Data found");
          nextStatus = ProcessData;
        }
        break;
 
      case ProcessMetaData:
        currentStatus = ProcessMetaData;
        metaData[metaDataPos++] = ch;
        if (metaDataPos >= metaDataLen) {
          processMetaData(metaData.data(), metaDataLen);
          LOGI("Metadata ended")
          nextStatus = ProcessData;
        }
        break;
    }
  }
 
 protected:
  Status nextStatus = ProcessData;
  Status currentStatus = ProcessData;
  void (*callback)(MetaDataType info, const char* str, int len) = nullptr;
  Vector<char> metaData{0};
  int totalData = 0;
  int mp3_blocksize = 0;
  int metaDataMaxLen = 0;
  int metaDataLen = 0;
  int metaDataPos = 0;
  bool is_data;  // indicates if the current byte is a data byte
  // data
  uint8_t* dataBuffer = nullptr;
  void (*dataCallback)(const uint8_t* str, int len) = nullptr;
  int dataLen = 0;
  int dataPos = 0;
 
  virtual void clear() {
    nextStatus = ProcessData;
    totalData = 0;
    metaData.resize(0);
    metaDataLen = 0;
    metaDataPos = 0;
    dataLen = 0;
    dataPos = 0;
  }
 
  virtual int metaSize(uint8_t metaSize) { return metaSize * 16; }
 
  virtual bool isPrintable(const char* str, int l) {
    int remain = 0;
    for (int j = 0; j < l; j++) {
      uint8_t ch = str[j];
      if (remain) {
        if (ch < 0x80 || ch > 0xbf) return false;
        remain--;
      } else {
        if (ch < 0x80) { // ASCII
            // Allow '\0' as printable (do not treat as control char)
            if (ch != '\n' && ch != '\r' && ch != '\t' && ch != 0 && (ch < 32 || ch == 127))
                return false; // control chars except allowed ones
        }
#if !AUDIOTOOLS_METADATA_ICY_ASCII_ONLY
        else if (ch >= 0xc2 && ch <= 0xdf) remain = 1;
        else if (ch >= 0xe0 && ch <= 0xef) remain = 2;
        else if (ch >= 0xf0 && ch <= 0xf4) remain = 3;
#endif
        else return false;
      }
    }
    return remain == 0;
  }
 
  virtual void setupMetaData(int meta_size) {
    TRACED();
    metaData.resize(meta_size + 1);
    metaDataMaxLen = meta_size;
    memset(metaData.data(), 0, meta_size + 1);
  }
 
  virtual void processMetaData(char* metaData, int len) {
    // CHECK_MEMORY();
    TRACED();
    metaData[len] = 0;
    if (isPrintable(metaData, len)) {
      LOGI("%s", metaData);
      StrView meta(metaData, len + 1, len);
      int start = meta.indexOf("StreamTitle=");
      if (start >= 0) {
        start += 12;
      }
      int end = meta.indexOf("';");
      if (start >= 0 && end > start) {
        metaData[end] = 0;
        if (callback != nullptr) {
          callback(Title, (const char*)metaData + start + 1, end - start);
        }
      }
      // CHECK_MEMORY();
    } else {
      // CHECK_MEMORY();
      // Don't print corrupted binary data - could contain terminal control codes
      LOGW("Unexpected Data: corrupted metadata block rejected (len=%d)", len);
      // Signal corruption to application so it can disconnect/reconnect
      if (callback != nullptr) {
        callback(Corrupted, nullptr, len);
      }
    }
  }
 
  virtual void processData(char ch) {
    if (dataBuffer != nullptr) {
      dataBuffer[dataPos++] = ch;
      // output data via callback
      if (dataPos >= dataLen) {
        dataCallback(dataBuffer, dataLen);
        dataPos = 0;
      }
    }
  }
};
 
class ICYUrlSetup {
 public:
  int setup(AbstractURLStream& url) {
    TRACED();
    p_url = &url;
    const char* iceMetaintStr = url.getReplyHeader("icy-metaint");
    if (iceMetaintStr) {
      LOGI("icy-metaint: %s", iceMetaintStr);
    } else {
      LOGE("icy-metaint not defined");
    }
    StrView value(iceMetaintStr);
    int iceMetaint = value.toInt();
    return iceMetaint;
  }
 
  void executeCallback(void (*callback)(MetaDataType info, const char* str,
                                        int len)) {
    TRACEI();
    if (callback == nullptr) {
      LOGW("callback not defined")
    }
    if (p_url == nullptr) {
      LOGW("http not defined")
    }
    // Callbacks filled from url reply for icy
    if (callback != nullptr && p_url != nullptr) {
      // handle icy parameters
      StrView genre(p_url->getReplyHeader("icy-genre"));
      if (!genre.isEmpty()) {
        callback(Genre, genre.c_str(), genre.length());
      }
 
      StrView descr(p_url->getReplyHeader("icy-description"));
      if (!descr.isEmpty()) {
        callback(Description, descr.c_str(), descr.length());
      }
 
      StrView name(p_url->getReplyHeader("icy-name"));
      if (!name.isEmpty()) {
        callback(Name, name.c_str(), name.length());
      }
    }
  }
 
 protected:
  AbstractURLStream* p_url = nullptr;
};
 
}  // namespace audio_tools