TimedStream

Author: pschatzmann

examples/sandbox/streams-url-timed/streams-url-timed.ino

@@ -0,0 +1,44 @@
+/**
+ * 
+*/
+#include "AudioTools.h"
+#include "AudioCodecs/CodecMP3Helix.h"
+//#include "AudioLibs/AudioKit.h"
+
+
+URLStream url("ssid","password");
+I2SStream i2s; // or any other output of decoded stream (e.g. AudioKitStream)
+TimedStream timed(i2s, 10, 20); // timed output with times
+EncodedAudioStream dec(&timed, new MP3DecoderHelix()); // Decoding stream
+StreamCopy copier(dec, url); // copy url to decoder
+
+
+void setup(){
+  Serial.begin(115200);
+  AudioLogger::instance().begin(Serial, AudioLogger::Info);  
+
+  // setup i2s
+  auto config = i2s.defaultConfig(TX_MODE);
+  // you could define e.g your pins and change other settings
+  //config.pin_ws = 10;
+  //config.pin_bck = 11;
+  //config.pin_data = 12;
+  //config.mode = I2S_STD_FORMAT;
+  i2s.begin(config);
+
+  // start timed
+  //timed.setStartSecond(10);
+  //timed.setEndSecond(20);
+  timed.begin();
+
+  // setup I2S based on sampling rate provided by decoder
+  dec.begin();
+
+// mp3 radio
+  url.begin("http://stream.srg-ssr.ch/m/rsj/mp3_128","audio/mp3");
+
+}
+
+void loop(){
+  copier.copy();
+}

src/AudioTools/AudioStreams.h

@@ -1631,6 +1631,134 @@ class FilteredStream : public AudioStream {
 
 };
 
+/**
+ * @brief AudioStream class that can define a start and (an optional) stop time
+ * Usually it is used to wrap an Audio Sink (e.g. I2SStream), but wrapping an
+ * Audio Source is supported as well. Only wrap classes which represent PCM
+ * data!
+ * @author Phil Schatzmann
+ * @copyright GPLv3
+ */
+class TimedStream : public AudioStream {
+ public:
+  TimedStream(AudioStream &io, long startSeconds = 0, long endSeconds = -1) {
+    p_stream = &io;
+    p_print = &io;
+    p_info = &io;
+    setStartSecond(startSeconds);
+    setEndSecond(endSeconds);
+  }
+
+  TimedStream(AudioOutput &o, long startSeconds = 0, long endSeconds = -1) {
+    p_print = &o;
+    p_info = &o;
+    setStartSecond(startSeconds);
+    setEndSecond(endSeconds);
+  }
+
+  /// Defines the start time in seconds. The audio before the start time will be
+  /// skipped
+  void setStartSecond(long startSeconds) { start_seconds = startSeconds; }
+
+  /// Defines (an optional) the end time in seconds. After the end time no audio
+  /// is played and available() will return 0
+  void setEndSecond(long endSeconds) { end_seconds = endSeconds; }
+
+  /// Returns true if we are in a valid time range and are still playing sound
+  bool isPlaying() {
+    if (current_bytes < start_bytes) return false;
+    if (end_bytes > 0 && current_bytes > end_bytes) return false;
+    return true;
+  }
+
+  /// Returns true if we are not past the end time;
+  bool isActive() {
+    return (current_bytes < end_bytes && current_bytes > start_bytes);
+  }
+
+  bool begin(AudioInfo info) {
+    setAudioInfo(info);
+    return begin();
+  }
+
+  bool begin() {
+    calculateByteLimits();
+    current_bytes = 0;
+    return true;
+  }
+
+  operator bool() { return isActive(); }
+
+  /// Provides only data for the indicated start and end time. Only supported
+  /// for data which does not contain any heder information: so PCM, mp3 should
+  /// work!
+  size_t readBytes(uint8_t *buffer, size_t length) override {
+    // if reading is not supported we stop
+    if (p_stream == nullptr) return 0;
+    // if we are past the end we stop
+    if (!isActive()) return 0;
+    // read the data now
+    size_t result = 0;
+    do {
+      result = p_stream->readBytes(buffer, length);
+      current_bytes += length;
+      // ignore data before start time
+    } while (result > 0 && current_bytes < start_bytes);
+    return isPlaying() ? result : 0;
+  }
+
+  /// Plays only data for the indiated start and end time
+  size_t write(const uint8_t *buffer, size_t length) override {
+    current_bytes += length;
+    return isPlaying() ? p_print->write(buffer, length) : length;
+  }
+
+  /// Provides the available bytes until the end time has reached
+  int available() override {
+    if (p_stream == nullptr) return 0;
+    return isActive() ? p_stream->available() : 0;
+  }
+
+  /// Updates the AudioInfo in the current object and in the source or target
+  void setAudioInfo(AudioInfo info) override {
+    AudioStream::setAudioInfo(info);
+    p_info->setAudioInfo(info);
+    calculateByteLimits();
+  }
+
+  int availableForWrite() override { return p_print->availableForWrite(); }
+
+  /// Experimental: if used on mp3 you can set the compression ratio e.g. to 11
+  /// which will be used to approximate the time
+  void setCompressionRatio(float ratio) { compression_ratio = ratio; }
+
+  /// Calculates the bytes per second from the AudioInfo
+  int bytesPerSecond() {
+    return  info.sample_rate * info.channels * info.bits_per_sample / 8;
+  }
+
+ protected:
+  Stream *p_stream = nullptr;
+  Print *p_print = nullptr;
+  AudioInfoDependent *p_info = nullptr;
+  uint32_t start_seconds = 0;
+  uint32_t end_seconds = UINT32_MAX;
+  uint32_t start_bytes = 0;
+  uint32_t end_bytes = UINT32_MAX;
+  uint32_t current_bytes = 0;
+  float compression_ratio = 1.0;
+
+  void calculateByteLimits() {
+    int bytes_per_second = bytesPerSecond();
+    if (bytes_per_second > 0) {
+      start_bytes = bytes_per_second * start_seconds / compression_ratio;
+      end_bytes = bytes_per_second * end_seconds / compression_ratio;
+    } else {
+      LOGE("AudioInfo not defined");
+    }
+  }
+};
+
 
 #ifdef USE_TIMER
 /**