AudioSourceFTP

Author: pschatzmann

examples/examples-player/player-ftp-audiokit/player-ftp-audiokit.ino

@@ -0,0 +1,80 @@
+/**
+ * @file player-ftp-audiokit.ino
+ * @brief AudioPlayer example that is using FTP as audio source
+ * @author Phil Schatzmann
+ * @copyright GPLv3
+ */
+
+#include "WiFi.h"
+#include "AudioTools.h"
+#include "AudioTools/AudioCodecs/CodecMP3Helix.h"
+#include "AudioTools/AudioLibs/AudioBoardStream.h"
+#include "AudioTools/Disk/AudioSourceFTP.h"
+
+const char* path = "Music/Tracy Chapman";
+const char* ext = "mp3";
+const char* ftp_user = "user";
+const char* ftp_pwd = "password";
+const char* ssid = "ssid";
+const char* ssid_pwd = "ssid-password";
+WiFiClient cmd;
+WiFiClient data;
+FTPClient ftp(cmd, data);
+AudioSourceFTP source(ftp, path, ext);
+AudioBoardStream i2s(AudioKitEs8388V1);
+MP3DecoderHelix decoder; 
+AudioPlayer player(source, i2s, decoder);
+
+void next(bool, int, void*) { player.next(); }
+
+void previous(bool, int, void*) { player.previous(); }
+
+void startStop(bool, int, void*) { player.setActive(!player.isActive()); }
+
+void setup() {
+  Serial.begin(115200);
+  AudioToolsLogger.begin(Serial, AudioToolsLogLevel::Info);
+  FTPLogger::setOutput(Serial);
+  FTPLogger::setLogLevel(LOG_DEBUG);
+
+  // connect to WIFI
+  WiFi.begin(ssid, ssid_pwd);
+  while (WiFi.status() != WL_CONNECTED) {
+    delay(500);
+    Serial.print(".");
+  }
+  Serial.println();
+  WiFi.setSleep(false);
+
+  // connect to ftp
+  if (!ftp.begin(IPAddress(192,168,1,39), ftp_user, ftp_pwd)){
+    Serial.println("ftp failed");
+    stop();
+  }
+
+  // setup output
+  auto cfg = i2s.defaultConfig(TX_MODE);
+  if (!i2s.begin(cfg)){
+    Serial.println("i2s failed");
+    stop();
+  }
+
+  // setup additional buttons
+  i2s.addDefaultActions();
+  i2s.addAction(i2s.getKey(1), startStop);
+  i2s.addAction(i2s.getKey(4), next);
+  i2s.addAction(i2s.getKey(3), previous);
+
+  // setup player
+  player.setVolume(0.7);
+  // load the directory 
+  if (!player.begin()){
+    Serial.println("player failed");
+    stop();
+  }
+}
+
+void loop() {
+  player.copy();
+  i2s.processActions();
+}

src/AudioTools/CoreAudio/AudioPlayer.h

@@ -389,6 +389,17 @@ class AudioPlayer : public AudioInfoSupport, public VolumeSupport {
     return copy(copier.bufferSize());
   }
 
+  /// Copies all the data
+  size_t copyAll() {
+    size_t result = 0;
+    size_t step = copy();
+    while(step > 0){
+      result += step;
+      step = copy();
+    }
+    return result;
+  }
+
   /// Copies the indicated number of bytes from the source to the decoder: Call this method in the loop.
   size_t copy(size_t bytes) {
     size_t result = 0;

src/AudioTools/Disk/AudioSourceFTP.h

@@ -0,0 +1,144 @@
+#include "ArduinoFTPClient.h"
+#include "AudioSource.h"
+#include "vector"
+
+namespace audio_tools {
+
+/**
+ * @brief An AudioSource that uses the
+ * https://github.com/pschatzmann/TinyFTPClient library to retrieve files from a
+ * FTP Server. You need to provide an FTPClient object to the constructor and
+ * make sure that you open it before you access the files. The storage of the
+ * expanded file names is done on the heap, so in order to limit the requested
+ * memory we can limit the number of files.
+ *
+ * @ingroup player
+ * @author Phil Schatzmann
+ * @copyright GPLv3
+ */
+
+
+class AudioSourceFTP : public AudioSource {
+ public:
+  AudioSourceFTP(FTPClient& client, const char* path, const char* ext,
+                 int files = 0) {
+    p_client = &client;
+    timeout_auto_next_value = 5000;
+    if (path) p_path = path;
+    setMaxFiles(files);
+  }
+
+  /// Resets the actual data
+  void begin()override {
+    TRACED();
+    idx = 0;
+    files.clear();
+    addDirectory(p_path);
+  }
+
+  /// Resets the actual data
+  void end() {
+    idx = 0;
+    files.clear();
+  }
+
+  /// Returns next audio stream
+  Stream* nextStream(int offset) override {
+    int tmp_idx = idx + offset;
+    if (!isValidIdx(tmp_idx)) return nullptr;
+    return selectStream(tmp_idx);
+  };
+
+  /// Returns previous audio stream
+  Stream* previousStream(int offset) override { return nextStream(-offset); };
+
+  /// Returns audio stream at the indicated index (the index is zero based, so
+  /// the first value is 0!)
+  Stream* selectStream(int index) override {
+    if (!isValidIdx(index)) return nullptr;
+    idx = index;
+    if (file) {
+       file.close();  // close the previous file
+    }
+    file = p_client->open(files[idx].name());
+    return &file;
+  }
+
+  /// Retrieves all files and returns the actual index of the stream
+  int index() override { return idx; }
+
+  /// Returns the FTPFile for the indicated path
+  Stream* selectStream(const char* path) override {
+    TRACED();
+    files.clear();
+    idx = 0;
+    addDirectory(path);
+    return selectStream(0);
+  }
+
+  /// provides the actual stream (e.g. file) name or url
+  const char* toStr() override {
+    return file.name();
+  }
+
+  /// Defines the max number of files (if value is >0)
+  void setMaxFiles(int maxCount) { max_files = maxCount; }
+
+  /// Adds all the files of a directory
+  bool addDirectory(const char* path) {
+    TRACED();
+    if (p_client == nullptr) return false;
+    FTPFile dir = p_client->open(path);
+    addFiles(dir, 1);
+    return true;
+  }
+
+  /// Returns the number of available files
+  size_t size() { return files.size(); }
+
+ protected:
+  std::vector<FTPFile> files;
+  FTPClient* p_client = nullptr;
+  FTPFile file;
+  int idx = 0;
+  size_t max_files = 0;
+  const char* p_ext = nullptr;
+  const char* p_path = "/";
+  bool is_first = true;
+
+  /// Adds all files recursively
+  void addFiles(FTPFile& dir, int level) {
+    if (!endsWith(dir.name(), p_ext)) {
+      LOGI("adding file %s", dir.name());
+      files.push_back(std::move(dir));
+    } else {
+      for (const auto& file : p_client->ls(dir.name())) {
+        if (endsWith(file.name(), p_ext)) {
+          LOGI("adding file %s", file.name());
+          files.push_back(std::move(file));
+        }
+        if (max_files > 0 && files.size() >= max_files) {
+          LOGI("max files reached: %d", max_files);
+          return;  // stop if we reached the max number of files
+        }
+      }
+    }
+  }
+
+  bool isValidIdx(int index) {
+    if (index < 0) return false;
+    if (index >= files.size()) {
+      LOGE("index %d is out of range (size: %d)", index, files.size());
+      return false;
+    }
+    return true;
+  }
+
+  bool endsWith(const char* file, const char* ext) {
+    if (file == nullptr) return false;
+    if (p_ext == nullptr) return true;
+    return (StrView(file).endsWith(ext));
+  }
+};
+
+}  // namespace audio_tools