Changes for aoo (#2037)

* CodecNetworkFormat

* AOO Draft

* AAOSourceLine: FormatConverter as object

* AAOSink improvements

* AAOSink: use MultiDecoder

* AOOSink: added CodecFactory

* OutputMixer: availablePercent

* DRAFT examples

* Cleanup Ringbuffer

* aao examples corrections

* OutputMixer: support custom buffer types

* Cleanup NBuffer

* SingleBuffer: optional attributes

* DRAFT AOOSinkSingle

* aoo corrections

* Priority Queue

* Delete aoo

Author: pschatzmann

src/AudioTools/AudioCodecs/AudioCodecs.h

@@ -29,3 +29,4 @@
 #include "AudioTools/AudioCodecs/CodecMTS.h"
 #include "AudioTools/AudioCodecs/CodecADTS.h"
 #include "AudioTools/AudioCodecs/CodecNetworkFormat.h"
+#include "AudioTools/AudioCodecs/CodecFactory.h"

src/AudioTools/AudioCodecs/CodecFactory.h

@@ -0,0 +1,64 @@
+#pragma once
+
+#include "AudioTools/AudioCodecs/AudioCodecsBase.h"
+
+namespace audio_tools {
+/**
+ * @brief Factory for creating new decoders based on the mime type or id
+ * @ingroup codecs
+ * @ingroup decoder
+ * @author Phil Schatzmann
+ */
+class CodecFactory {
+ public:
+  bool addDecoder(const char* id, AudioDecoder* (*cb)()) {
+    if (id == nullptr || cb == nullptr) return false;
+    DecoderFactoryLine line;
+    line.id = id;
+    line.cb = cb;
+    decoders.push_back(line);
+    return true;
+  }
+
+  bool addEncoder(const char* id, AudioEncoder* (*cb)()) {
+    if (id == nullptr || cb == nullptr) return false;
+    EncoderFactoryLine line;
+    line.id = id;
+    line.cb = cb;
+    encoders.push_back(line);
+    return true;
+  }
+
+  /// create a new decoder instance
+  AudioDecoder* createDecoder(const char* str) {
+    for (auto& line : decoders) {
+      if (line.id.equals(str)) {
+        return line.cb();
+      }
+    }
+    return nullptr;
+  }
+  /// create a new encoder instance
+  AudioEncoder* createEncoder(const char* str) {
+    for (auto& line : encoders) {
+      if (line.id.equals(str)) {
+        return line.cb();
+      }
+    }
+    return nullptr;
+  }
+
+ protected:
+  struct DecoderFactoryLine {
+    Str id;
+    AudioDecoder* (*cb)() = nullptr;
+  };
+  struct EncoderFactoryLine {
+    Str id;
+    AudioEncoder* (*cb)() = nullptr;
+  };
+  Vector<DecoderFactoryLine> decoders;
+  Vector<EncoderFactoryLine> encoders;
+};
+
+}  // namespace audio_tools

src/AudioTools/Communication/UDPStream.h

@@ -72,6 +72,7 @@ class UDPStream : public BaseStream {
     connect();
     remote_address_ext = IPAddress((uint32_t)0);
     remote_port_ext = port_ext != 0 ? port_ext : port;
+    printIP();
     return p_udp->begin(port);
   }
 
@@ -126,11 +127,17 @@ class UDPStream : public BaseStream {
 protected:
   WiFiUDP default_udp;
   UDP *p_udp = &default_udp;
-  uint16_t remote_port_ext;
+  uint16_t remote_port_ext = 0;
   IPAddress remote_address_ext;
   const char *ssid = nullptr;
   const char *password = nullptr;
 
+  void printIP(){
+      Serial.print(WiFi.localIP());
+      Serial.print(":");
+      Serial.println(remote_port_ext);
+  }
+
   /// connect to WIFI if necessary
   void connect() {
     if (WiFi.status() != WL_CONNECTED && ssid != nullptr &&
@@ -142,9 +149,9 @@ class UDPStream : public BaseStream {
     }
 #if defined(ESP32)
     if (WiFi.status() == WL_CONNECTED) {
+      esp_wifi_set_ps(WIFI_PS_NONE);
       // Performance Hack
       // client.setNoDelay(true);
-      esp_wifi_set_ps(WIFI_PS_NONE);
     }
 #endif
   }

src/AudioTools/CoreAudio/AudioBasic/Collections.h

@@ -11,4 +11,5 @@
 #include "AudioTools/CoreAudio/AudioBasic/Collections/Queue.h"
 #include "AudioTools/CoreAudio/AudioBasic/Collections/QueueFromVector.h"
 #include "AudioTools/CoreAudio/AudioBasic/Collections/BitVector.h"
-#include "AudioTools/CoreAudio/AudioBasic/Collections/Slice.h"
+#include "AudioTools/CoreAudio/AudioBasic/Collections/Slice.h"
+#include "AudioTools/CoreAudio/AudioBasic/Collections/PriorityQueue.h"

src/AudioTools/CoreAudio/AudioBasic/Collections/PriorityQueue.h

@@ -0,0 +1,52 @@
+#pragma once
+#include "AudioTools/CoreAudio/AudioBasic/Collections/List.h"
+
+namespace audio_tools {
+
+/**
+ * @brief Priority Queue which is based on a List. The order of the elements is
+ * defined by a compare function which is provided in the constructor. If the
+ * function returns > 0 if v1 > v2, the data will be provided in increasing
+ * order.
+ * @ingroup collections
+ * @author Phil Schatzmann
+ * @copyright GPLv3
+ * @tparam T
+ */
+template <class T>
+class PriorityQueue {
+ public:
+  PriorityQueue(int (*compare)(T &v1, T &v2)) { compare_cb = compare; };
+
+  bool enqueue(T &&data) {
+    for (auto it = l.begin(); it != l.end(); ++it) {
+      if (compare_cb(*it, data) > 0) {
+        l.insert(it, data);
+        return true;
+      }
+    }
+    return l.push_back(data);
+  }
+
+  bool peek(T &data) {
+    if (l.end()->prior == nullptr) return false;
+    data = *(l.end()->prior);
+    return true;
+  }
+
+  bool dequeue(T &data) { return l.pop_front(data); }
+
+  size_t size() { return l.size(); }
+
+  bool clear() { return l.clear(); }
+
+  bool empty() { return l.empty(); }
+
+  void setAllocator(Allocator &allocator) { l.setAllocator(allocator); }
+
+ protected:
+  List<T> l;
+  int (*compare_cb)(T &v1, T &v2);
+};
+
+}  // namespace audio_tools

src/AudioTools/CoreAudio/AudioBasic/Collections/QueueFromVector.h

@@ -82,6 +82,10 @@ class QueueFromVector {
             vector.setAllocator(allocator);
         }
 
+        Vector<T>& toVector() {
+            return vector;
+        }
+
     protected:
         Vector<T> vector;
         int32_t _end_pos = 0;

src/AudioTools/CoreAudio/AudioOutput.h

@@ -296,7 +296,8 @@ class HexDumpOutput : public AudioOutput {
 
 
 /**
- * @brief Mixing of multiple outputs to one final output
+ * @brief Mixing of multiple outputs to one final output.
+ * By default a RingBuffer is used as buffer type.
  * @ingroup transform
  * @author Phil Schatzmann
  * @copyright GPLv3
@@ -340,12 +341,10 @@ class OutputMixer : public Print {
   }
 
   /// Starts the processing.
-  bool begin(int copy_buffer_size_bytes = DEFAULT_BUFFER_SIZE,
-             MemoryType memoryType = PS_RAM) {
+  bool begin(int copy_buffer_size_bytes = DEFAULT_BUFFER_SIZE) {
     is_active = true;
     size_bytes = copy_buffer_size_bytes;
     stream_idx = 0;
-    memory_type = memoryType;
     allocate_buffers(size_bytes);
     return true;
   }
@@ -381,7 +380,7 @@ class OutputMixer : public Print {
   size_t write(int idx, const uint8_t *buffer_c, size_t bytes) {
     LOGD("write idx %d: %d", idx, bytes);
     size_t result = 0;
-    RingBuffer<T> *p_buffer = idx < output_count ? buffers[idx] : nullptr;
+    BaseBuffer<T> *p_buffer = idx < output_count ? buffers[idx] : nullptr;
     assert(p_buffer != nullptr);
     size_t samples = bytes / sizeof(T);
     if (p_buffer->availableForWrite() >= samples) {
@@ -401,20 +400,25 @@ class OutputMixer : public Print {
 
   /// Provides the bytes available to write for the indicated stream index
   int availableForWrite(int idx) {
-    RingBuffer<T> *p_buffer = buffers[idx];
+    BaseBuffer<T> *p_buffer = buffers[idx];
     if (p_buffer == nullptr)
       return 0;
     return p_buffer->availableForWrite() * sizeof(T);
   }
 
   /// Provides the available bytes in the buffer
   int available(int idx){
-    RingBuffer<T> *p_buffer = buffers[idx];
+    BaseBuffer<T> *p_buffer = buffers[idx];
     if (p_buffer == nullptr)
       return 0;
     return p_buffer->available() * sizeof(T);
   }
 
+  /// Provides the % fill level of the buffer for the indicated index
+  int availablePercent(int idx){
+    return 100.0 * available(idx) / size_bytes;
+  }
+
   /// Force output to final destination
   void flushMixer() {
     LOGD("flush");
@@ -465,7 +469,6 @@ class OutputMixer : public Print {
     size_bytes = size;
   }
 
-
   size_t writeSilence(size_t bytes)  {
     if (bytes == 0) return 0;
     uint8_t silence[bytes];
@@ -495,8 +498,18 @@ class OutputMixer : public Print {
     stream_idx++;
   }
 
+  /// Define callback to allocate custum buffer types
+  void setCreateBufferCallback(BaseBuffer<T>* (*cb)(int size) ){
+    create_buffer_cb = cb;
+  }
+
+  /// Provides the write buffer for the indicated index
+  BaseBuffer<T>* getBuffer(int idx){
+    return idx < output_count ? buffers[idx] : nullptr;
+  }
+
 protected:
-  Vector<RingBuffer<T> *> buffers{0};
+  Vector<BaseBuffer<T> *> buffers{0};
   Vector<T> output{0};
   Vector<float> weights{0};
   Print *p_final_output = nullptr;
@@ -505,9 +518,13 @@ class OutputMixer : public Print {
   int stream_idx = 0;
   int size_bytes = 0;
   int output_count = 0;
-  MemoryType memory_type;
   void *p_memory = nullptr;
   bool is_auto_index = true;
+  BaseBuffer<T>* (*create_buffer_cb)(int size) = create_buffer; 
+
+  static BaseBuffer<T>* create_buffer(int size) {
+    return new RingBuffer<T>(size / sizeof(T));
+  }
 
   void update_total_weights() {
     total_weights = 0.0;
@@ -522,22 +539,7 @@ class OutputMixer : public Print {
       if (buffers[j] != nullptr) {
         delete buffers[j];
       }
-#if defined(ESP32) && defined(ARDUINO)
-      if (memory_type == PS_RAM && ESP.getFreePsram() >= size) {
-        p_memory = ps_malloc(size);
-        LOGI("Buffer %d allocated %d bytes in PS_RAM", j, size);
-      } else {
-        p_memory = malloc(size);
-        LOGI("Buffer %d allocated %d bytes in RAM", j, size);
-      }
-      if (p_memory != nullptr) {
-        buffers[j] = new (p_memory) RingBuffer<T>(size / sizeof(T));
-      } else {
-        LOGE("Not enough memory to allocate %d bytes", size);
-      }
-#else
-      buffers[j] = new RingBuffer<T>(size / sizeof(T));
-#endif
+      buffers[j] = create_buffer(size);
     }
   }
 
@@ -546,11 +548,6 @@ class OutputMixer : public Print {
     for (int j = 0; j < output_count; j++) {
       if (buffers[j] != nullptr) {
         delete buffers[j];
-#ifdef ESP32
-        if (p_memory != nullptr) {
-          free(p_memory);
-        }
-#endif
         buffers[j] = nullptr;
       }
     }