MetaDataICY.h

#pragma once
#include "AudioConfig.h"
#ifdef USE_URL_ARDUINO
 
#include "AbstractMetaData.h"
#include "AudioTools/CoreAudio/AudioBasic/StrView.h"
#include "AudioTools/CoreAudio/AudioHttp/HttpRequest.h"
 
namespace audio_tools {
 
class MetaDataICY : public AbstractMetaData {
 
    enum Status {ProcessData, ProcessMetaData, SetupSize};
 
    public:
        MetaDataICY() = default;
 
        MetaDataICY(int metaint){
            setIcyMetaInt(metaint);
        }
 
        ~MetaDataICY(){
            if (metaData!=nullptr) delete[]metaData;
        }
        
        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 void begin() override {
            clear();
            LOGI("mp3_blocksize: %d", mp3_blocksize);
        }
 
        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, metaDataLen);
                        LOGI("Metadata ended")
                        nextStatus = ProcessData;
                    }
                    break;
            }
        }
 
 
    protected:
        Status nextStatus = ProcessData;
        Status currentStatus = ProcessData;
        void (*callback)(MetaDataType info, const char* str, int len) = nullptr;
        char* metaData=nullptr;
        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;
            metaDataLen = 0;
            metaDataPos = 0;
            dataLen = 0;
            dataPos = 0;
        }
 
        virtual int metaSize(uint8_t metaSize){
            return metaSize*16;
        }
 
        virtual bool isAscii(char* result, int l){
            // check on first 10 characters
            int m = l < 5 ? l : 10;
            for (int j=0; j<m; j++){
                if (!isascii(result[j])) return false;
            }
            return true;
        }
 
        virtual void setupMetaData(int meta_size) {
            TRACED();
            if (meta_size>0){
                if (metaData==nullptr){
                    metaData = new char[meta_size+1];
                    metaDataMaxLen = meta_size;
                    LOGD("metaDataMaxLen: %d", metaDataMaxLen);
                } else {
                    if (meta_size>metaDataMaxLen){
                        delete [] metaData; 
                        metaData = new char[meta_size+1];
                        metaDataMaxLen = meta_size;
                        LOGD("metaDataMaxLen: %d", metaDataMaxLen);
                    }
                }
                memset(metaData, 0, meta_size);
            }
        }
 
        virtual void processMetaData( char* metaData, int len) {
            //CHECK_MEMORY();
            TRACED();
            metaData[len]=0;
            if (isAscii(metaData, 12)){
                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();
                LOGW("Unexpected Data: %s", metaData);
            }
        }
 
        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(HttpRequest &http ) {
            TRACED();
            p_http = &http;
            const char* iceMetaintStr = http.reply().get("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_http==nullptr){
                LOGW("http not defined")
            }
            // Callbacks filled from url reply for icy
            if (callback!=nullptr && p_http!=nullptr) {
                // handle icy parameters
                StrView genre(p_http->reply().get("icy-genre"));
                if (!genre.isEmpty()){
                    callback(Genre, genre.c_str(), genre.length());
                }
 
                StrView descr(p_http->reply().get("icy-description"));
                if (!descr.isEmpty()){
                    callback(Description, descr.c_str(), descr.length());
                }
 
                StrView name(p_http->reply().get("icy-name"));
                if (!name.isEmpty()){
                    callback(Name, name.c_str(), name.length());
                } 
            }
        }
 
    protected:
        HttpRequest *p_http = nullptr;
 
};
 
}
 
#endif