AudioSource.h

#pragma once
#include "AudioTools/CoreAudio/AudioBasic/Str.h"
 
namespace audio_tools {
 
class AudioSource {
public:
    virtual void begin() = 0;
 
    virtual Stream* nextStream(int offset) = 0;
 
    virtual Stream* previousStream(int offset) {
        return nextStream(-offset);
    };
 
    virtual Stream* selectStream(int index) {
        LOGE("Not Supported!");
        return nullptr;
    }
 
    virtual Stream* setIndex(int index) {
        return selectStream(index);
    }
 
    virtual Stream* selectStream(const char* path) = 0;
 
    virtual void setTimeoutAutoNext(int millisec) {
        timeout_auto_next_value = millisec;
    }
 
    virtual int timeoutAutoNext() {
        return timeout_auto_next_value;
    }
 
    // only the ICYStream supports this
    virtual bool setMetadataCallback(void (*fn)(MetaDataType info, const char* str, int len), ID3TypeSelection sel=SELECT_ICY) {
        return false;
    }
 
    virtual void setTimeout(int millisec) {};
 
    virtual bool isAutoNext() {return true; }
 
    Stream* operator[](int idx){
        return setIndex(idx);
    }
 
 
protected:
    int timeout_auto_next_value = 500;
};
 
class AudioSourceCallback : public AudioSource {
public:
    AudioSourceCallback() {
    }
 
    AudioSourceCallback(Stream* (*nextStreamCallback)(int offset), void (*onStartCallback)() = nullptr) {
        TRACED();
        this->onStartCallback = onStartCallback;
        this->nextStreamCallback = nextStreamCallback;
    }
 
    virtual void begin() override {
        TRACED();
        if (onStartCallback != nullptr) onStartCallback();
    };
 
    virtual Stream* nextStream(int offset) override {
        TRACED();
        return nextStreamCallback == nullptr ? nullptr : nextStreamCallback(offset);
    }
 
    virtual Stream* selectStream(int index) override {
        LOGI("selectStream: %d", index);
        if (indexStreamCallback==nullptr){
            LOGI("setCallbackSelectStream not provided");
            if (index>0) {
                begin();
                return nextStream(index);
            } else {
                // nextStream(0) will return the directory but we need a file
                return nextStream(1);
            }
        }
        return indexStreamCallback(index);
    }
    virtual Stream* selectStream(const char* path) override {
        this->path = path;
        return indexStreamCallback == nullptr ? nullptr : indexStreamCallback(-1);
    };
 
    void setCallbackOnStart(void (*callback)()) {
        onStartCallback = callback;
    }
 
    void setCallbackNextStream(Stream* (*callback)(int offset)) {
        nextStreamCallback = callback;
    }
 
    void setCallbackSelectStream(Stream* (*callback)(int idx)) {
        indexStreamCallback = callback;
    }
 
    virtual bool isAutoNext() override {
        return auto_next;
    }
 
    virtual void setAutoNext(bool a){
        auto_next = a;
    }
 
    // returns the requested path: relevant when provided idx in callback is -1
    virtual const char* getPath() {
        return path;
    }
 
protected:
    void (*onStartCallback)() = nullptr;
    bool auto_next = true;
    Stream* (*nextStreamCallback)(int offset) = nullptr;
    Stream* (*indexStreamCallback)(int index) = nullptr;
    const char*path=nullptr;
};
 
#if defined(USE_URL_ARDUINO) && ( defined(ESP32) || defined(ESP8266) )
 
class AudioSourceURL : public AudioSource {
public:
    template<typename T, size_t N>
    AudioSourceURL(AbstractURLStream& urlStream, T(&urlArray)[N], const char* mime, int startPos = 0) {
        TRACED();
        this->actual_stream = &urlStream;
        this->mime = mime;
        this->urlArray = urlArray;
        this->max = N;
        this->pos = startPos - 1;
        this->timeout_auto_next_value = 20000;
    }
 
    virtual void begin() override {
        TRACED();
        this->pos = 0;
    }
 
    Stream* selectStream(int idx) override {
        pos = idx;
        if (pos < 0) {
            pos = 0;
            LOGI("url array out of limits: %d -> %d", idx, pos);
        }
        if (pos >= size()) {
            pos = size() - 1;
            LOGI("url array out of limits: %d -> %d", idx, pos);
        }
        LOGI("selectStream: %d/%d -> %s", pos, size() - 1, value(pos));
        if (started) actual_stream->end();
        actual_stream->begin(value(pos), mime);
        started = true;
        return actual_stream;
    }
 
    Stream* nextStream(int offset) override {
        pos += offset;
        if (pos < 0 || pos >= size()) {
            pos = 0;
        }
        LOGI("nextStream: %d/%d -> %s", pos, max-1, value(pos));
        return selectStream(pos);
    }
 
    Stream* previousStream(int offset) override {
        pos -= offset;
        if (pos < 0 || pos >= size()) {
            pos = size() - 1;
        }
        LOGI("previousStream: %d/%d -> %s", pos, size() - 1, value(pos));
        return selectStream(pos);
    }
 
    Stream* selectStream(const char* path) override {
        LOGI("selectStream: %s", path);
        if (started) actual_stream->end();
        actual_stream->begin(path, mime);
        started = true;
        return actual_stream;
    }
 
    int index() {
        return pos;
    }
 
    const char *toStr() {
        return value(pos);
    }
 
    void setTimeout(int millisec){
        actual_stream->setTimeout(millisec);
    }
 
    // provides go not to the next on error
    virtual bool isAutoNext() {
        return true;
    };
 
    // only the ICYStream supports this
    bool setMetadataCallback(void (*fn)(MetaDataType info, const char* str, int len), ID3TypeSelection sel=SELECT_ICY) {
        TRACEI();
        return actual_stream->setMetadataCallback(fn);
    }
 
 
protected:
    AbstractURLStream* actual_stream = nullptr;
    const char** urlArray = nullptr;
    int pos = 0;
    int max = 0;
    const char* mime = nullptr;
    bool started = false;
 
    AudioSourceURL() = default;
 
    virtual const char* value(int pos){
        if (urlArray==nullptr) return nullptr;
        return urlArray[pos];
    }
 
    virtual int size(){
        return max;
    }
 
};
 
class AudioSourceDynamicURL : public AudioSourceURL {
public:
    template<typename T, size_t N>
    AudioSourceDynamicURL(AbstractURLStream& urlStream, T(&urlArray)[N], const char* mime, int startPos = 0) {
        this->actual_stream = &urlStream;
        this->mime = mime;
        this->pos = startPos - 1;
        this->timeout_auto_next_value = 20000;   
        for (int j=0;j<N;j++){
            addURL(urlArray[j]);
        }    
    }
 
    AudioSourceDynamicURL(AbstractURLStream& urlStream, const char* mime, int startPos = 0) {
        this->actual_stream = &urlStream;
        this->mime = mime;
        this->pos = startPos - 1;
        this->timeout_auto_next_value = 20000;   
    }
 
    void addURL(const char* url){
        url_vector.push_back(url);
    }
 
    void clear(){
        url_vector.clear();
    }
 
protected:
    Vector<Str> url_vector;
 
    const char* value(int pos) override {
        return url_vector[pos].c_str();
    }
 
    int size() override {
        return url_vector.size();
    }
 
};
 
 
#endif
 
}