AudioSourceSD.h

#pragma once
#include "SD.h"
#include "SPI.h"
#include "AudioLogger.h"
#include "AudioTools/Disk/AudioSource.h"
#include "SDDirect.h"
 
namespace audio_tools {
 
 
class AudioSourceSD : public AudioSource {
public:
  AudioSourceSD(const char *startFilePath = "/", const char *ext = ".mp3", int chipSelect = PIN_CS, bool setupIndex=true) {
    start_path = startFilePath;
    extension = ext;
    setup_index = setupIndex;
    p_spi = &SPI;
    cs = chipSelect;
  }
 
#ifdef USE_SD_SUPPORTS_SPI
 
  // Pass your own spi instance, in case you need a dedicated one
  AudioSourceSD(const char *startFilePath, const char *ext, int chipSelect, SPIClass &spiInstance, bool setupIndex=true) {
    start_path = startFilePath;
    extension = ext;
    setup_index = setupIndex;
    p_spi = &spiInstance;
    cs = chipSelect;
  }
 
#endif
 
  virtual bool begin() override {
    TRACED();
    if (!is_sd_setup) {
      int retry = 10;
      while (!start_sd()) {
        LOGE("SD.begin cs=%d failed", cs);
        delay(500);
        if (--retry <= 0) {
          return false;
        }
      }
      is_sd_setup = true;
    }
    idx.begin(start_path, extension, file_name_pattern);
    idx_pos = 0;
    return is_sd_setup;
  }
 
  void end() {
    file.close();
    SD.end();
    is_sd_setup = false;
  }
 
  virtual Stream *nextStream(int offset = 1) override {
    LOGI("nextStream: %d", offset);
    return selectStream(idx_pos + offset);
  }
 
  virtual Stream *selectStream(int index) override {
    LOGI("selectStream SD: %d", index);
    if (index > -1) {  // avoid invalid position
      idx_pos = index;
    }
    return selectStream(idx[idx_pos]);
  }
 
  virtual Stream *selectStream(const char *path) override {
    file.close();
    if (path == nullptr) {
      LOGE("Filename is null")
      return nullptr;
    }
    file = SD.open(path);
    file_name = file.name();
    LOGI("-> selectStream: %s", path);
    return file ? &file : nullptr;
  }
 
  void setFileFilter(const char *filter) { file_name_pattern = filter; }
 
  int index() { return idx_pos; }
 
  const char *toStr() { return file_name; }
 
  // provides default setting go to the next
  virtual bool isAutoNext() { return true; }
 
  virtual void setPath(const char *p) { start_path = p; }
 
  long size() { return idx.size();}
 
protected:
#if defined(USE_SD_NO_NS)
  SDDirect<SDClass, File> idx{SD};
#else
  SDDirect<fs::SDFS,fs::File> idx{SD};
#endif
  File file;
  size_t idx_pos = 0;
  const char *file_name;
  const char *extension = nullptr;
  const char *start_path = nullptr;
  const char *file_name_pattern = "*";
  bool setup_index = true;
  bool is_sd_setup = false;
  int cs;
  SPIClass *p_spi = nullptr;
 
  bool start_sd(){
#ifdef USE_SD_SUPPORTS_SPI
      return SD.begin(cs, *p_spi);
#else
      return SD.begin(cs);
#endif
  }
 
};
 
} // namespace audio_tools