DRAFT RTOS implementation

Author: pschatzmann

.gitignore

@@ -1,3 +1,4 @@
 .vscode/
 build/
-miniaudio.h
+miniaudio.h
+arduino-snapclient.code-workspace

examples/SnapClientFreeRTOS/SnapClientFreeRTOS.ino

@@ -0,0 +1,51 @@
+#include "AudioTools.h"
+#include "SnapClient.h"
+#include "api/SnapProcessorRTOS.h" // install https://github.com/pschatzmann/arduino-freertos-addons
+#include "AudioLibs/AudioBoardStream.h" // install https://github.com/pschatzmann/arduino-audio-driver
+#include "AudioCodecs/CodecOpus.h" // https://github.com/pschatzmann/arduino-libopus
+//#include "AudioCodecs/CodecFLAC.h"   // https://github.com/pschatzmann/arduino-libflac.git
+//#include "AudioCodecs/CodecVorbis.h" //https://github.com/pschatzmann/arduino-libvorbis-idec
+
+
+AudioBoardStream out(AudioKitEs8388V1);  // or replace with e.g. I2SStream out;
+//FLACDecoder flac;
+//VorbisDecoder ogg;
+//WAVDecoder pcm;
+OpusAudioDecoder opus;
+WiFiClient wifi;
+SnapProcessorRTOS rtos(1024*8);
+SnapTimeSyncDynamic synch(172, 10); // optional configuratioin
+SnapClient client(wifi, out, opus);
+
+void setup() {
+  Serial.begin(115200);
+
+  // login to wifi -> Define values in SnapConfig.h or replace them here
+  WiFi.begin(CONFIG_WIFI_SSID, CONFIG_WIFI_PASSWORD);
+  Serial.print("Connecting to WiFi ..");
+  while (WiFi.status() != WL_CONNECTED) {
+    Serial.print('.');
+    delay(1000);
+  }
+
+  // print ip address
+  Serial.println();
+  Serial.println(WiFi.localIP());
+
+  // use full volume of kit - volume control done by client
+  out.setVolume(1.0);
+
+  // Use FreeRTOS
+  client.setSnapProcessor(rtos);
+
+  // Define CONFIG_SNAPCAST_SERVER_HOST in SnapConfig.h or here
+  client.setServerIP(IPAddress(192,168,1,33));
+
+  // start snap client
+  client.begin(synch);
+}
+
+
+void loop() {
+  client.doLoop();
+}

src/SnapClient.h

@@ -32,53 +32,52 @@
 class SnapClient {
 
 public:
-  SnapClient(Client &client,AudioStream &stream, AudioDecoder &decoder) {
+  SnapClient(Client &client, AudioStream &stream, AudioDecoder &decoder) {
+    static AdapterAudioStreamToAudioOutput output_adapter;
     output_adapter.setStream(stream);
-    p_snapprocessor->setOutput(output_adapter);
-    p_snapprocessor->setDecoder(decoder);
-    setClient(client);
+    p_decoder = &decoder;
+    p_output = &output_adapter;
+    p_client = &client;
   }
 
   SnapClient(Client &client, AudioStream &stream, StreamingDecoder &decoder,
              int bufferSize = CONFIG_STREAMIN_DECODER_BUFFER) {
-    p_decoder_adapter = new DecoderFromStreaming(decoder, bufferSize);
+    static DecoderFromStreaming decoder_adapter(decoder, bufferSize);
+    static AdapterAudioStreamToAudioOutput output_adapter;
+    p_decoder = &decoder_adapter;
     output_adapter.setStream(stream);
-    p_snapprocessor->setOutput(output_adapter);
-    p_snapprocessor->setDecoder(*p_decoder_adapter);
-    setClient(client);
+    p_output = &output_adapter;
+    p_client = &client;
   }
 
   SnapClient(Client &client, AudioOutput &output, AudioDecoder &decoder) {
-    p_snapprocessor->setOutput(output);
-    p_snapprocessor->setDecoder(decoder);
-    setClient(client);
+    p_decoder = &decoder;
+    p_output = &output;
+    p_client = &client;
   }
 
   SnapClient(Client &client, AudioOutput &output, StreamingDecoder &decoder,
              int bufferSize = CONFIG_STREAMIN_DECODER_BUFFER) {
-    p_decoder_adapter = new DecoderFromStreaming(decoder, bufferSize);
-    p_snapprocessor->setOutput(output);
-    p_snapprocessor->setDecoder(*p_decoder_adapter);
-    setClient(client);
+    p_decoder = new DecoderFromStreaming(decoder, bufferSize);
+    p_output = &output;
+    p_client = &client;
   }
 
   /// Destructor
   ~SnapClient() {
-    if (p_decoder_adapter != nullptr)
-      delete p_decoder_adapter;
     end();
   }
 
   /// Defines an alternative commnuication client (default is WiFiClient)
-  void setClient(Client &client) { p_snapprocessor->setClient(client); }
+  void setClient(Client &client) { p_client = &client; }
 
   /// @brief Defines the Snapcast Server IP address
   /// @param address 
-  void setServerIP(IPAddress address) { p_snapprocessor->setServerIP(address); }
+  void setServerIP(IPAddress ipAddress) { this->address = ipAddress; }
 
   /// Defines the time synchronization logic
   void setSnapTimeSync(SnapTimeSync &timeSync){
-    p_snapprocessor->snapOutput().setSnapTimeSync(timeSync);
+    p_time_sync = &timeSync;
   }
 
   /// Starts the processing
@@ -112,6 +111,12 @@ class SnapClient {
     SnapTime::instance().setupSNTPTime();
 #endif
 
+    p_snapprocessor->setServerIP(address);
+    p_snapprocessor->setOutput(*p_output);
+    p_snapprocessor->snapOutput().setSnapTimeSync(*p_time_sync);
+    p_snapprocessor->setDecoder(*p_decoder);
+    p_snapprocessor->setClient(*p_client);
+
     // start tasks
     return p_snapprocessor->begin();
   }
@@ -136,18 +141,24 @@ class SnapClient {
     p_snapprocessor = &processor;
   }
 
+  /// Defines the Snap output implementation to be used
+  void setSnapOutput(SnapOutput &out){
+    p_snapprocessor->setSnapOutput(out);
+  }
+
   /// Call from Arduino Loop (when no tasks are used)
   void doLoop() { p_snapprocessor->doLoop(); }
 
 protected:
   const char *TAG = "SnapClient";
-  AdapterAudioStreamToAudioOutput output_adapter;
-  DecoderFromStreaming *p_decoder_adapter = nullptr;
   SnapTime &snap_time = SnapTime::instance();
-  // default setup
-  SnapOutput snap_output;
-  SnapProcessor default_processor{snap_output};
+  SnapProcessor default_processor;
   SnapProcessor *p_snapprocessor = &default_processor;
+  AudioOutput *p_output = nullptr;
+  AudioDecoder *p_decoder = nullptr;
+  Client *p_client = nullptr;
+  SnapTimeSync *p_time_sync = nullptr;
+  IPAddress address;
 
   void setupMDNS() {
 #if CONFIG_SNAPCLIENT_USE_MDNS && defined(ESP32)

src/api/SnapOutput.h

@@ -1,16 +1,19 @@
 #pragma once
 
-#include "Arduino.h" // for ESP.getPsramSize()
+#include <stdint.h>
+#include <sys/time.h>
+
+#include "Arduino.h"  // for ESP.getPsramSize()
 #include "AudioTools.h"
 #include "SnapCommon.h"
 #include "SnapConfig.h"
 #include "SnapLogger.h"
 #include "SnapTime.h"
 #include "SnapTimeSync.h"
-#include <stdint.h>
-#include <sys/time.h>
 
 class SnapProcessor;
+class SnapProcessorRTOS;
+
 /**
  * @brief Simple Output Class which uses the AudioTools to build an output chain
  * with volume control and a resampler
@@ -21,18 +24,16 @@ class SnapProcessor;
  **/
 
 class SnapOutput : public AudioInfoSupport {
-friend SnapProcessor;
-public:
-  // singleton: only access via instance class method
-  SnapOutput() {
-    // audio_info.sample_rate = 48000;
-    // audio_info.channels = 2;
-    // audio_info.bits_per_sample = 16;
-  }
+  friend SnapProcessor;
+  friend SnapProcessorRTOS;
+
+ public:
+  SnapOutput() = default;
 
   /// Starts the processing which is also starting the the dsp_i2s_task_handler
   /// task
   virtual bool begin() {
+    ESP_LOGI(TAG, "begin");
     is_sync_started = false;
     return audioBegin();
   }
@@ -41,7 +42,8 @@ friend SnapProcessor;
   virtual size_t write(const uint8_t *data, size_t size) {
     ESP_LOGD(TAG, "%zu", size);
     // only start to proces data after we received codec header
-    if (!is_audio_begin_called){
+    if (!is_audio_begin_called) {
+      ESP_LOGI(TAG, "not started");
       return 0;
     }
 
@@ -86,54 +88,51 @@ friend SnapProcessor;
 
   /// Defines the audio output chain to the final output
   void setOutput(AudioOutput &output) {
-    this->out = &output; // final output
+    this->out = &output;  // final output
     resample.setStream(output);
-    vol_stream.setStream(resample);        // adjust volume
+    vol_stream.setStream(resample);  // adjust volume
     timed_stream.setStream(vol_stream);
-    decoder_stream.setStream(&timed_stream); // decode to pcm
+    decoder_stream.setStream(&timed_stream);  // decode to pcm
   }
 
+  AudioOutput &getOutput() { return *out; }
+
   /// Defines the decoder class
   void setDecoder(AudioDecoder &dec) { decoder_stream.setDecoder(&dec); }
 
+  AudioDecoder &getDecoder() { return decoder_stream.decoder(); }
+
   /// setup of all audio objects
   void setAudioInfo(AudioInfo info) {
     ESP_LOGI(TAG, "sample_rate: %d, channels: %d, bits: %d", info.sample_rate,
              info.channels, info.bits_per_sample);
     audio_info = info;
-    if (is_audio_begin_called){
+    if (is_audio_begin_called) {
       vol_stream.setAudioInfo(info);
       out->setAudioInfo(info);
       timed_stream.setAudioInfo(info);
     }
   }
 
-  AudioInfo audioInfo(){
-    return audio_info;
-  }
+  AudioInfo audioInfo() { return audio_info; }
 
   /// Defines the time synchronization logic
-  void setSnapTimeSync(SnapTimeSync &timeSync){
-    p_snap_time_sync = &timeSync;
-  }
+  void setSnapTimeSync(SnapTimeSync &timeSync) { p_snap_time_sync = &timeSync; }
 
-  // do nothing
-  virtual void doLoop() {}
+  SnapTimeSync &snapTimeSync() { return *p_snap_time_sync; }
 
-  SnapTimeSync& snapTimeSync() {
-    return *p_snap_time_sync;
-  }
+  bool isStarted() { return is_audio_begin_called; }
 
-protected:
+ protected:
   const char *TAG = "SnapOutput";
   AudioOutput *out = nullptr;
   AudioInfo audio_info;
   EncodedAudioStream decoder_stream;
   VolumeStream vol_stream;
   ResampleStream resample;
   TimedStream timed_stream;
-  float vol = 1.0;        // volume in the range 0.0 - 1.0
-  float vol_factor = 1.0; //
+  float vol = 1.0;         // volume in the range 0.0 - 1.0
+  float vol_factor = 1.0;  //
   bool is_mute = false;
   SnapAudioHeader header;
   SnapTime &snap_time = SnapTime::instance();
@@ -144,9 +143,10 @@ friend SnapProcessor;
 
   /// setup of all audio objects
   bool audioBegin() {
-
-    if (out == nullptr)
+    if (out == nullptr) {
+      ESP_LOGI(TAG, "out is null");
       return false;
+    }
 
     // open volume control: allow amplification
     auto vol_cfg = vol_stream.defaultConfig();
@@ -178,7 +178,6 @@ friend SnapProcessor;
     return true;
   }
 
-
   /// to speed up or slow down playback
   void setPlaybackFactor(float fact) { resample.setStepSize(fact); }
 
@@ -193,8 +192,7 @@ friend SnapProcessor;
 
   void audioEnd() {
     ESP_LOGD(TAG, "start");
-    if (out == nullptr)
-      return;
+    if (out == nullptr) return;
     out->end();
   }
 
@@ -210,19 +208,18 @@ friend SnapProcessor;
   /// ignored - update playback speed
   bool synchronizePlayback() {
     bool result = true;
-    SnapTimeSync& ts = *p_snap_time_sync;
+    SnapTimeSync &ts = *p_snap_time_sync;
 
     // calculate how long we need to wait to playback the audio
     auto delay_ms = getDelayMs();
 
     if (!is_sync_started) {
-
       ts.begin(audio_info.sample_rate);
 
       // start audio when first package in the future becomes valid
       result = synchronizeOnStart(delay_ms);
     } else {
-      // provide the actual delay to the synch 
+      // provide the actual delay to the synch
       ts.updateActualDelay(delay_ms);
 
       if (ts.isSync()) {