AudioSourceSTD.h

Go to the documentation of this file.

#pragma once
 
#include "AudioLogger.h"
#include "AudioTools/Disk/AudioSource.h"
#include "AudioTools/Disk/FileSystem.h"
#include "AudioTools/CoreAudio/AudioBasic/StrView.h"
#include <filesystem>
 
namespace audio_tools {
 
namespace fs = std::filesystem;
 
class AudioSourceSTD : public AudioSource {
public:
  AudioSourceSTD(const char *startFilePath = "/", const char *ext = ".mp3") {
    start_path = startFilePath;
    exension = ext;
    timeout_auto_next_value = 600000;
  }
 
  virtual ~AudioSourceSTD() {
    end();
  }
 
  virtual bool begin() override {
    TRACED();
    idx_pos = 0;
    return true;
  }
 
  virtual void end() {
    file.close();
  }
 
  virtual Stream *nextStream(int offset = 1) override {
    LOGI("nextStream: %d", offset);
    Stream* s = selectStream(idx_pos + offset);
    if (s == nullptr && offset > 0) {
      LOGI("Wrapping to start of directory");
      idx_pos = 0;
      s = selectStream(idx_pos);
    }
    return s;
  }
 
  virtual Stream *selectStream(int index) override {
    // Determine total mp3 file count to normalize index
    long count = size();
    LOGI("selectStream: %d of %d", index, (int) count);
    if (count <= 0) {
      LOGW("No audio files found under: %s", start_path ? start_path : "<null>");
      return nullptr;
    }
    int norm = index % count;
    if (norm < 0) norm += count;
    idx_pos = norm;
    file_name = get(norm);
    if (file_name==nullptr) {
      LOGW("Could not resolve index %d (normalized %d)", index, norm);
      return nullptr;
    }
    LOGI("Using file %s", file_name);
    file.close();
    file = SD.open(file_name);
    return file ? &file : nullptr;
  }
 
  virtual Stream *selectStream(const char *path) override {
    file.close();
    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() {
    if (count == 0){
      for (auto const& dir_entry : fs::recursive_directory_iterator(start_path)){
          if (isValidAudioFile(dir_entry))
            count++;
      }
    }
    return count;
  }
 
protected:
  File file;
  size_t idx_pos = 0;
  const char *file_name;
  std::string current_path; // holds persistent path string
  const char *exension = "";
  const char *start_path = nullptr;
  const char *file_name_pattern = "*";
  fs::directory_entry entry;
  long count = 0;
 
  const char* get(int idx){
      int count = 0;
      const char* result = nullptr;
      for (auto const& dir_entry : fs::recursive_directory_iterator(start_path)){
        if (isValidAudioFile(dir_entry)){
          if (count++==idx){
            entry = dir_entry;
            current_path = entry.path().string();
            result = current_path.c_str();
            break;
          }
        }
      }
      return result;
  }
 
  bool isValidAudioFile(fs::directory_entry file) {
    const std::filesystem::path path = file.path();
    const std::string filename = path.filename().string();
    const char *file_name_c = filename.c_str();
    if (file.is_directory()) {
      LOGD("-> isValidAudioFile: '%s': %d", file_name_c, false);
      return false;
    }
    StrView strFileTName(file_name_c);
    bool result = strFileTName.endsWithIgnoreCase(exension)
                  && strFileTName.matches(file_name_pattern);
    LOGD("-> isValidAudioFile: '%s': %d", file_name_c, result);
    return result;
  }
 
};
 
} // namespace audio_tools