DynamicMemoryStream correction

Author: pschatzmann

examples/examples-audiokit/streams-audiokit-ram-audiokit/streams-audiokit-ram-audiokit.ino

@@ -0,0 +1,69 @@
+/**
+ * @file streams-audiokit-sd-audiokit.ino
+ * @author Phil Schatzmann
+ * @brief We record the input from the microphone to a file and constantly repeat to play the file
+ * The input is triggered by pressing key 1. Recording stops when key 1 is released!
+ * @version 0.1
+ * @date 2022-09-01
+ * 
+ * @copyright Copyright (c) 2022
+ * 
+ */
+#include "AudioTools.h"
+#include "AudioLibs/AudioKit.h"
+#include "AudioLibs/MemoryManager.h"
+
+uint16_t sample_rate = 16000;
+uint8_t channels = 1;  // The stream will have 2 channels 
+AudioKitStream kit;
+MemoryManager memory(500); // Activate PSRAM for objects > 500 bytes
+DynamicMemoryStream recording(true); // Audio Stored on heap (PSRAM)
+StreamCopy copier; // copies data
+bool is_recording = false;  // flag to make sure that close is only executed one
+uint64_t end_time; // trigger to call endRecord
+ 
+
+void record_start(bool pinStatus, int pin, void* ref){
+  Serial.println("Recording...");
+  recording.begin();
+  copier.begin(recording, kit);  
+  is_recording = true; 
+}
+
+void record_end(bool pinStatus, int pin, void* ref){
+  if (recording == true){
+    Serial.println("Playing...");
+    is_recording = false;
+    copier.begin(kit, recording);  // start playback
+  }
+}
+
+void setup(){
+  Serial.begin(115200);
+  while(!Serial); // wait for serial to be ready
+  AudioLogger::instance().begin(Serial, AudioLogger::Info);  
+
+  // setup input and output
+  auto cfg = kit.defaultConfig(RXTX_MODE);
+  cfg.sd_active = true;
+  cfg.sample_rate = sample_rate;
+  cfg.channels = channels;
+  cfg.input_device = AUDIO_HAL_ADC_INPUT_LINE2;
+  kit.begin(cfg);
+  kit.setVolume(1.0);
+
+  // record when key 1 is pressed
+  kit.audioActions().add(PIN_KEY1, record_start, record_end);
+  Serial.println("Press Key 1 to record");
+
+}
+
+void loop(){
+
+  // record or play recording
+  copier.copy();  
+
+  // Process keys
+  kit.processActions();
+
+}

src/AudioTools/AudioStreams.h

@@ -319,17 +319,21 @@ class DynamicMemoryStream : public AudioStreamX {
   struct DataNode {
     int len=0;
     uint8_t* data=nullptr;
+
     DataNode() = default;
     /// Constructor
-    DataNode(void*data, int len){
+    DataNode(void*inData, int len){
       this->len = len;
-      this->data = new uint8_t[len];
+      this->data = (uint8_t*) malloc(len);
       assert(this->data!=nullptr);
-      memcpy(this->data, data, len);
+      memcpy(this->data, inData, len);
     }
 
     ~DataNode(){
-      if (data!=nullptr) delete[]data;
+      if (data!=nullptr) {
+         free(data);
+         data = nullptr;
+      }
     }
   };
 
@@ -365,7 +369,15 @@ class DynamicMemoryStream : public AudioStreamX {
   }
 
   void clear() {
-    audio_list.clear();
+    DataNode *p_node;
+    bool ok;
+    do{
+        ok = audio_list.pop_front(p_node);
+        if (ok){
+          delete p_node;
+        }
+    } while (ok);
+
     temp_audio.reset();
     total_available = 0;
     alloc_failed = false;
@@ -382,11 +394,11 @@ class DynamicMemoryStream : public AudioStreamX {
   }
 
   virtual size_t write(const uint8_t *buffer, size_t size) override {
-    DataNode node((void*)buffer, size);
-    if (node.data!=nullptr){
+    DataNode *p_node = new DataNode((void*)buffer, size);
+    if (p_node->data!=nullptr){
       alloc_failed = false;
       total_available += size;
-      audio_list.push_back(node);
+      audio_list.push_back(p_node);
 
       // setup interator to point to first record
       if (it == audio_list.end()){
@@ -404,7 +416,7 @@ class DynamicMemoryStream : public AudioStreamX {
   } 
 
   virtual int available() override {
-    return it == audio_list.end() ? 0 : (*it).len;
+    return it == audio_list.end() ? 0 : (*it)->len;
   }
 
   virtual size_t readBytes(uint8_t *buffer, size_t length) override {
@@ -424,13 +436,13 @@ class DynamicMemoryStream : public AudioStreamX {
     }
 
     // provide data from next node
-    DataNode node = *it;
-    int result_len = min(length, (size_t) node.len);
-    memcpy(buffer, node.data, result_len);
+    DataNode *p_node = *it;
+    int result_len = min(length, (size_t) p_node->len);
+    memcpy(buffer, p_node->data, result_len);
     // save unprocessed data to temp buffer
-    if (node.len>length){
-      uint8_t *start = node.data+result_len;
-      int uprocessed_len = node.len - length; 
+    if (p_node->len>length){
+      uint8_t *start = p_node->data+result_len;
+      int uprocessed_len = p_node->len - length; 
       temp_audio.writeArray(start, uprocessed_len);
     }
     //move to next pos
@@ -439,8 +451,8 @@ class DynamicMemoryStream : public AudioStreamX {
   }
 
 protected:
-  List<DataNode> audio_list;
-  List<DataNode>::Iterator it = audio_list.end();
+  List<DataNode*> audio_list;
+  List<DataNode*>::Iterator it = audio_list.end();
   size_t total_available=0;
   int default_buffer_size=DEFAULT_BUFFER_SIZE;
   bool alloc_failed = false;