MetaData.h

#pragma once
#include <stdlib.h>
#include "AudioConfig.h"
#include "AudioTools/AudioTypes.h"
#include "AudioTools/AudioStreams.h"
#include "AudioMetaData/MetaDataICY.h"
#include "AudioMetaData/MetaDataID3.h"
#include "AudioHttp/HttpRequest.h"
 
namespace audio_tools {
 
class MetaDataOutput : public AudioOutput {
  public:
 
    MetaDataOutput() = default;
    MetaDataOutput(MetaDataOutput const&) = delete;
    MetaDataOutput& operator=(MetaDataOutput const&) = delete;
 
    ~MetaDataOutput(){
        end();
        if (meta!=nullptr) delete meta;
    }
 
    virtual void setCallback(void (*fn)(MetaDataType info, const char* str, int len)) {
        TRACED();
        callback = fn; 
    }
 
#ifdef USE_URL_ARDUINO
 
    virtual void begin(HttpRequest &http) {
        TRACED();
        ICYUrlSetup icySetup;
        int metaInt = icySetup.setup(http);
        icySetup.executeCallback(callback);
        begin(metaInt);
    }
#endif
 
    virtual void begin(int iceMetaint=0) {
        LOGD("%s: %d", LOG_METHOD, iceMetaint);
        if (callback!=nullptr){
            if (meta == nullptr) {
#if defined(USE_URL_ARDUINO)
                meta = (iceMetaint > 0) ? new MetaDataICY() : (AbstractMetaData *)  new MetaDataID3();
#else
                meta =  new MetaDataID3();
#endif
            }
            meta->setCallback(callback);    
            meta->setIcyMetaInt(iceMetaint);
            meta->begin();
        } else {
            LOGI("callback not defined -> not Metadata processing")
        }
    }
 
    virtual void end() {
        if (callback!=nullptr && meta != nullptr) {
            TRACED();
            meta->end();
        }
    }
 
    virtual size_t write(const uint8_t *data, size_t length){
        LOGD("%s: %d", LOG_METHOD, (int)length);
 
        if (callback!=nullptr){
            if (meta!=nullptr){
                //CHECK_MEMORY();
                if (meta->write(data, length)!=length){
                    LOGE("Did not write all data");
                }
                //CHECK_MEMORY();
            } else {
                LOGW("meta is null");
            }
        }
        return length;
    }
 
     virtual size_t write(uint8_t c) {
         LOGE("Not Supported");
         return 0;
     }
 
  protected:
    AbstractMetaData *meta=nullptr;
    void (*callback)(MetaDataType info, const char* str, int len)=nullptr;
 
};
 
// legacy name
using MetaDataPrint = MetaDataOutput;
 
}