ContainerBinary DRAFT

Author: pschatzmann

cmake-tests/codec/container-binary/CMakeLists.txt

@@ -0,0 +1,30 @@
+cmake_minimum_required(VERSION 3.20)
+
+# set the project name
+project(container-binary)
+set (CMAKE_CXX_STANDARD 11)
+set (DCMAKE_CXX_FLAGS "-Werror")
+if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+    set (CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fno-omit-frame-pointer -fsanitize=address")
+    set (CMAKE_LINKER_FLAGS_DEBUG "${CMAKE_LINKER_FLAGS_DEBUG} -fno-omit-frame-pointer -fsanitize=address")
+endif()
+include(FetchContent)
+
+# Build with arduino-audio-tools
+if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
+    add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/../../.. ${CMAKE_CURRENT_BINARY_DIR}/arduino-audio-tools )
+endif()
+
+
+# build sketch as executable
+add_executable (container-binary container-binary.cpp)
+
+# set preprocessor defines
+target_compile_definitions(container-binary PUBLIC -DEXIT_ON_STOP -DIS_MIN_DESKTOP)
+
+# OS/X might need this setting for core audio
+#target_compile_definitions(portaudio PUBLIC -DPA_USE_COREAUDIO=1)
+
+# specify libraries
+target_link_libraries(container-binary arduino-audio-tools)
+

cmake-tests/codec/container-binary/container-binary.cpp

@@ -0,0 +1,46 @@
+/**
+ * @file communication-container-binary.ino
+ * @author Phil Schatzmann
+ * @brief generate sine wave -> encoder -> decoder -> audiokit (i2s)
+ * @version 0.1
+ * @date 2022-04-30
+ * 
+ * @copyright Copyright (c) 2022
+ * 
+ */
+#include "AudioTools.h"
+#include "AudioCodecs/ContainerBinary.h"
+
+AudioInfo info(8000,1,16);
+SineWaveGenerator<int16_t> sineWave( 32000);  // subclass of SoundGenerator with max amplitude of 32000
+GeneratedSoundStream<int16_t> sound( sineWave); // Stream generated from sine wave
+CsvStream<int16_t> out(Serial);
+EncodedAudioStream decoder(&out,new BinaryContainerDecoder()); // encode and write
+EncodedAudioStream encoder(&out,new BinaryContainerEncoder()); // encode and write
+StreamCopy copier(encoder, sound);     
+
+void setup() {
+  AudioLogger::instance().begin(Serial, AudioLogger::Warning);
+
+  // start 
+  Serial.println("starting...");
+  auto cfgi = out.defaultConfig(TX_MODE);
+  cfgi.copyFrom(info);
+  out.begin(cfgi);
+
+  // Setup sine wave
+  sineWave.begin(info, N_B4);
+
+  // start decoder
+  decoder.begin(info);
+
+  // start encoder
+  encoder.begin(info);
+
+  Serial.println("Test started...");
+}
+
+
+void loop() { 
+  copier.copy();
+}

src/AudioCodecs/AudioEncoded.h

@@ -257,6 +257,24 @@ class EncodedAudioPrint : public AudioStream {
     active = false;
   }
 
+  EncodedAudioPrint(AudioPrint *outputStream, AudioEncoder *encoder) {
+    TRACED();
+    ptr_out = outputStream;
+    encoder_ptr = encoder;
+    encoder_ptr->setOutputStream(*outputStream);
+    writer_ptr = encoder_ptr;
+    active = false;
+  }
+
+  EncodedAudioPrint(AudioStream *outputStream, AudioEncoder *encoder) {
+    TRACED();
+    ptr_out = outputStream;
+    encoder_ptr = encoder;
+    encoder_ptr->setOutputStream(*outputStream);
+    writer_ptr = encoder_ptr;
+    active = false;
+  }
+
   /**
    * @brief Construct a new Encoded Audio Stream object - the Output and
    * Encoder/Decoder needs to be defined with the corresponding setter methods.
@@ -282,9 +300,12 @@ class EncodedAudioPrint : public AudioStream {
 
   virtual void setAudioInfo(AudioInfo info) override {
     TRACED();
-    AudioStream::setAudioInfo(info);
-    decoder_ptr->setAudioInfo(info);
-    encoder_ptr->setAudioInfo(info);
+    if (this->info != info) {
+      this->info = info;
+      AudioStream::setAudioInfo(info);
+      decoder_ptr->setAudioInfo(info);
+      encoder_ptr->setAudioInfo(info);
+    }
   }
 
   /// Defines the output
@@ -294,6 +315,9 @@ class EncodedAudioPrint : public AudioStream {
   void setStream(Print *outputStream) { setOutput(outputStream); }
 
   void setEncoder(AudioEncoder *encoder) {
+    if (encoder == nullptr) {
+      encoder = CodecNOP::instance();
+    }
     encoder_ptr = encoder;
     writer_ptr = encoder;
     if (ptr_out != nullptr) {
@@ -302,6 +326,9 @@ class EncodedAudioPrint : public AudioStream {
   }
 
   void setDecoder(AudioDecoder *decoder) {
+    if (decoder == nullptr) {
+      decoder = CodecNOP::instance();
+    }
     decoder_ptr = decoder;
     writer_ptr = decoder;
     if (ptr_out != nullptr) {
@@ -312,13 +339,16 @@ class EncodedAudioPrint : public AudioStream {
   /// Starts the processing - sets the status to active
   bool begin() override {
     TRACED();
-    const CodecNOP *nop = CodecNOP::instance();
-    if (decoder_ptr != nop || encoder_ptr != nop) {
-      decoder_ptr->begin();
-      encoder_ptr->begin();
-      active = true;
-    } else {
-      LOGW("no decoder or encoder defined");
+
+    if (!active) {
+      const CodecNOP *nop = CodecNOP::instance();
+      if (decoder_ptr != nop || encoder_ptr != nop) {
+        active = true;
+        decoder_ptr->begin();
+        encoder_ptr->begin();
+      } else {
+        LOGW("no decoder or encoder defined");
+      }
     }
     return active;
   }
@@ -376,6 +406,7 @@ class EncodedAudioPrint : public AudioStream {
   AudioEncoder &encoder() { return *encoder_ptr; }
 
  protected:
+  AudioInfo info;
   AudioDecoder *decoder_ptr = CodecNOP::instance();  // decoder
   AudioEncoder *encoder_ptr = CodecNOP::instance();  // decoder
   AudioWriter *writer_ptr = nullptr;
@@ -561,129 +592,95 @@ class EncodedAudioStream : public EncodedAudioPrint {
 };
 
 /**
- * @brief ContainerTarget: forwards requests to both the output and the
- * encoder/decoder
+ * @brief Facade class which lets an AudioWriter behave like a Print
+ * @author Phil Schatzmann
+ * @copyright GPLv3
  *
  */
-class ContainerTarget {
- public:
-  virtual bool begin();
-  virtual void end();
-  virtual void setAudioInfo(AudioInfo info);
-  virtual size_t write(uint8_t *data, size_t size);
-};
 
-class ContainerTargetPrint : public ContainerTarget {
+class AudioWriterToPrint : public AudioPrint {
  public:
-  ContainerTargetPrint(Print &print, AudioWriter *writer) {
-    p_print = &print;
-    p_writer = writer;
-  }
-  virtual bool begin() {
-    if (p_writer) {
-      p_writer->begin();
-      p_writer->setOutputStream(*p_print);
-    }
-    return true;
-  }
-  virtual void end() {
-    if (p_writer) p_writer->end();
-  }
-  virtual void setAudioInfo(AudioInfo info) {
-    if (p_writer) p_writer->setAudioInfo(info);
-  }
-  virtual size_t write(uint8_t *data, size_t size) {
-    TRACED();
-    return p_writer ? p_writer->write(data, size) : p_print->write(data, size);
-  }
+  void setWriter(AudioWriter *writer) { p_writer = writer; }
+  size_t write(const uint8_t *in_ptr, size_t in_size) {
+    return p_writer->write(in_ptr, in_size);
+  };
 
  protected:
-  Print *p_print = nullptr;
   AudioWriter *p_writer = nullptr;
 };
 
-class ContainerTargetAudioPrint : public ContainerTarget {
+/**
+ * @brief ContainerTarget: forwards requests to both the output and the
+ * encoder/decoder and sets up the output chain for Containers. We also
+ * manage the proper sequence of the output classes
+ * @author Phil Schatzmann
+ * @copyright GPLv3
+ */
+class ContainerTarget {
  public:
-  ContainerTargetAudioPrint(AudioPrint &print, AudioWriter *writer) {
-    p_print = &print;
-    p_writer = writer;
-  }
-  virtual bool begin() {
-    if (p_writer) {
-      p_writer->begin();
-      p_writer->setOutputStream(*p_print);
-    }
-    return p_print->begin();
-  }
-  virtual void end() {
-    if (p_writer) p_writer->end();
-    p_print->end();
-  }
+  virtual bool begin() = 0;
+  virtual void end() = 0;
   virtual void setAudioInfo(AudioInfo info) {
-    if (p_writer) p_writer->setAudioInfo(info);
-
-    if (p_print->audioInfo() != info) {
-      p_print->setAudioInfo(info);
+    if (this->info != info) {
+      this->info = info;
+      if (p_writer1 != nullptr) p_writer1->setAudioInfo(info);
+      if (p_writer2 != nullptr) p_writer2->setAudioInfo(info);
     }
   }
-  virtual size_t write(uint8_t *data, size_t size) {
-    TRACED();
-    return p_writer ? p_writer->write(data, size) : p_print->write(data, size);
-  }
+  virtual size_t write(uint8_t *data, size_t size) = 0;
 
  protected:
-  AudioPrint *p_print;
-  AudioWriter *p_writer = nullptr;
+  AudioInfo info;
+  AudioWriter *p_writer1 = nullptr;
+  AudioWriter *p_writer2 = nullptr;
+  AudioWriterToPrint print2;
+  bool active = false;
 };
 
-class ContainerTargetAudioStream : public ContainerTarget {
+class ContainerTargetPrint : public ContainerTarget {
  public:
-  ContainerTargetAudioStream(AudioStream &print, AudioWriter *writer) {
+  void setupOutput(AudioWriter *writer1, AudioWriter *writer2, Print &print) {
     p_print = &print;
-    p_writer = writer;
-  }
-  virtual bool begin() {
-    if (p_writer) {
-      p_writer->begin();
-      p_writer->setOutputStream(*p_print);
-    }
-    return p_print->begin();
-  }
-  virtual void end() { p_print->end(); }
-  virtual void setAudioInfo(AudioInfo info) {
-    if (p_writer) p_writer->setAudioInfo(info);
-    if (p_print->audioInfo() != info) {
-      p_print->setAudioInfo(info);
-    }
-  }
-  virtual size_t write(uint8_t *data, size_t size) {
-    TRACED();
-    return p_writer ? p_writer->write(data, size) : p_print->write(data, size);
+    p_writer1 = writer1;
+    p_writer2 = writer2;
+    print2.setWriter(p_writer2);
   }
 
- protected:
-  AudioStream *p_print;
-  AudioWriter *p_writer = nullptr;
-};
-
-class ContainerTargetAudioWriter : public ContainerTarget {
- public:
-  ContainerTargetAudioWriter(AudioWriter *writer) {
-      p_writer = writer;
+  void setupOutput(AudioWriter *writer1, Print &print) {
+    p_print = &print;
+    p_writer1 = writer1;
   }
+
   virtual bool begin() {
-    p_writer->begin();
+    if (!active) {
+      active = true;
+      if (p_writer2 != nullptr) {
+        p_writer1->setOutputStream(print2);
+        p_writer2->setOutputStream(*p_print);
+        p_writer1->begin();
+        p_writer2->begin();
+      } else {
+        p_writer1->setOutputStream(*p_print);
+        p_writer1->begin();
+      }
+    }
     return true;
   }
-  virtual void end() { p_writer->end(); }
-  virtual void setAudioInfo(AudioInfo info) { p_writer->setAudioInfo(info); }
+  virtual void end() {
+    if (active) {
+      if (p_writer1 != nullptr) p_writer1->end();
+      if (p_writer2 != nullptr) p_writer2->end();
+    }
+    active = false;
+  }
   virtual size_t write(uint8_t *data, size_t size) {
     TRACED();
-    return p_writer->write(data, size);
+    return p_writer1->write(data, size);
   }
 
  protected:
-  AudioWriter *p_writer;
+  Print *p_print = nullptr;
+  AudioWriterToPrint print2;
 };
 
 }  // namespace audio_tools