AudioSource.h

#pragma once
#include "AudioTools/CoreAudio/AudioBasic/Str.h"
#include "AudioTools/CoreAudio/AudioMetaData/AbstractMetaData.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* selectStream(int index) {…}
 
  virtual Stream* setIndex(int index) { return selectStream(index); }
 
  virtual int index() { return -1; }
 
  virtual Stream* selectStream(const char* path) = 0;
 
  virtual void setTimeoutAutoNext(int millisec) {
    timeout_auto_next_value = millisec;
  }
  virtual void setTimeoutAutoNext(int 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); }
 
  virtual const char* toStr() { return nullptr; }
 
 protected:
  int timeout_auto_next_value = 500;
};
class AudioSource {…};
 
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 void begin() override  {…}
 
  virtual Stream* nextStream(int offset) override {
    TRACED();
    return nextStreamCallback == nullptr ? nullptr : nextStreamCallback(offset);
  }
  virtual Stream* nextStream(int offset) override  {…}
 
  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(int index) override  {…}
  virtual Stream* selectStream(const char* path) override {
    this->path = path;
    return indexStreamCallback == nullptr ? nullptr : indexStreamCallback(-1);
  };
  virtual Stream* selectStream(const char* path) override  {…}
 
  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; }
 
  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;
};
class AudioSourceCallback : public AudioSource {…};
 
}  // namespace audio_tools