FileLoop

Author: pschatzmann

examples/examples-audiokit/streams-file_loop-audiokit/streams-file_loop-audiokit.ino

@@ -0,0 +1,47 @@
+/**
+ * @file streams-sd-audiokit.ino
+ * @author Phil Schatzmann
+ * @brief Just a small demo, how to use files with the SD library
+ * @version 0.1
+ * @date 2022-10-09
+ * 
+ * @copyright Copyright (c) 2022
+ * 
+ */
+#include <SPI.h>
+#include <SD.h>
+#include "AudioTools.h"
+#include "AudioLibs/AudioKit.h"
+#include "AudioLibs/FileLoop.h"
+#include "AudioCodecs/CodecMP3Helix.h"
+
+
+const int chipSelect=PIN_AUDIO_KIT_SD_CARD_CS;
+AudioKitStream i2s; // final output of decoded stream
+EncodedAudioStream decoder(&i2s, new MP3DecoderHelix()); // Decoding stream
+FileLoop loopingFile;
+StreamCopy copier(decoder, audioFile); 
+
+void setup(){
+  Serial.begin(115200);
+  AudioLogger::instance().begin(Serial, AudioLogger::Info);  
+
+  // setup audiokit before SD!
+  auto config = i2s.defaultConfig(TX_MODE);
+  config.sd_active = true;
+  i2s.begin(config);
+
+  // setup file
+  SD.begin(chipSelect);
+  loopingFile.setFile(SD.open("/ZZ Top/Unknown Album/Lowrider.mp3"));
+  //loopingFile.setLoopCount(-1); // define loop count
+  //audioFile.setStartPos(44); // restart from pos 44
+  //if ((audioFile.size()-44) % 1024!=0) audioFile.setSize((((audioFile.size()-44)/1024)+1)*1024+44);
+
+  // setup I2S based on sampling rate provided by decoder
+  decoder.begin();
+}
+
+void loop(){
+  copier.copy();
+}

src/AudioLibs/FileLoop.h

@@ -0,0 +1,149 @@
+#pragma once
+
+#include "AudioTools/AudioStreams.h"
+#include "FS.h"
+
+namespace audio_tools {
+
+/**
+ * @brief A simple class which implements a automatic looping file.
+ * In order to support different file implementation the file class
+ * is a template parameter. The number of loops can be defined by
+ * calling setLoopCount().
+ * You can also optinally limit the total looping file size by calling 
+ * setSize();
+ * @ingroup io
+ * @author Phil Schatzmann
+ * @copyright GPLv3
+ */
+template <class FileType> class FileLoopT : public AudioStream {
+public:
+  FileLoopT() = default;
+  FileLoopT(FileType file, int count = -1, int rewindPos = 0) {
+    setFile(file);
+    setLoopCount(count);
+    setStartPos(rewindPos);
+  }
+
+  // restarts the file from the beginning
+  bool begin() override {
+    TRACEI();
+    current_file.seek(start_pos);
+    size_open = total_size;
+    return current_file;
+  }
+
+  // closes the file
+  void end() override { 
+    TRACEI();
+    current_file.close(); 
+  }
+
+  /// defines the file that is used for looping
+  void setFile(FileType file) { this->current_file = file; }
+
+  /// Returns the file
+  FileType &file(){
+    return current_file;
+  }
+
+  /// defines the start position after the rewind. E.g. for wav files this should be 44
+  void setStartPos(int pos) { start_pos = pos; }
+
+  /// defines the requested playing size in bytes
+  void setSize(size_t len) {
+    total_size = len;
+  }
+
+  /// You can be notified about a rewind 
+  void setCallback(void (*cb)(FileLoopT &loop)){
+    callback = cb;
+  }
+
+  /// count values: 0) do not loop, 1) loop once, n) loop n times, -1) loop
+  /// endless
+  void setLoopCount(int count) { loop_count = count; }
+
+  int available() override {
+    // if we manage the size, we return the open amount
+    if (total_size!=-1) return size_open;
+    // otherwise we return DEFAULT_BUFFER_SIZE if looping is active
+    return isLoopActive() ? DEFAULT_BUFFER_SIZE : current_file.available();
+  }
+
+  size_t readBytes(uint8_t *data, size_t len) {
+    LOGD("FileLoopT::readBytes %d at %d", len, current_file.position());
+    if (!current_file)
+      return 0;
+    
+    // limit the copy size if necessary
+    int copy_len = len;
+    if (total_size!=-1){
+      copy_len = min((int)len, size_open);
+    }
+
+    // read step 1;
+    int result1 = current_file.readBytes((char *)data, copy_len);
+    int result2 = 0;
+    int open = copy_len - result1;
+    if (isLoopActive() && open>0) {
+      LOGI("seek 0");
+      // looping logic -> rewind to beginning: read step 2
+      current_file.seek(start_pos);
+      // notify user
+      if (callback!=nullptr){
+        callback(*this);
+      }
+      result1 = current_file.readBytes((char *)data + result1, open);
+      if (loop_count>0)
+        loop_count--;
+    }
+    // determine the result size
+    int result = result1 + result2;
+    // calculate the size_open if necessary
+    if (total_size!=-1){
+      size_open -= result;
+    }
+    return result;
+  }
+
+  operator bool() {
+    return current_file;
+  }
+
+  /// Returns the (requested) file size
+  size_t size() {
+    return total_size == -1 ? current_file.size() : total_size;
+  }
+
+  /// @return true as long as we are looping
+  bool isLoopActive() { return loop_count > 0 || loop_count == -1; }
+
+protected:
+  int start_pos = 0;
+  int loop_count = -1;
+  int size_open = -1;
+  int total_size = -1;
+  void (*callback)(FileLoopT &loop) = nullptr;
+  FileType current_file;
+};
+
+/**
+ * @brief A simple class which implements a automatic looping file.
+ * The file needs to be of the class File from FS.h. The number of loops can be
+ * defined by calling setLoopCount().
+ * You can also optinally limit the total looping file size by calling 
+ * setSize();
+ * @ingroup io
+ * @author Phil Schatzmann
+ * @copyright GPLv3
+ */
+
+class FileLoop : public FileLoopT<File> {
+public:
+  FileLoop() = default;
+  FileLoop(File file, int count = -1, int rewindPos = 0)
+      : FileLoopT<File>(file, count, rewindPos) {}
+};
+
+} // namespace audio_tools