MiniAudioStream

pschatzmann · pschatzmann · commit a87e4249a32d · 2023-04-24T19:15:51.000+02:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -12,8 +12,7 @@ include(FetchContent)
 add_library(arduino-audio-tools INTERFACE)
 
 option(BUILD_SHARED_LIBS "Build using shared libraries" OFF)
-option(ADD_MINIAUDIO "Add Miniaudio Library" OFF)
-option(ADD_PORTAUDIO "Add Portaudio Library" ON)
+option(ADD_PORTAUDIO "Add Portaudio Library" OFF)
 option(ADD_ARDUINO_EMULATOR "Add Arduino Emulator Library" ON)
 
 
@@ -38,6 +37,7 @@ if (ADD_PORTAUDIO)
     endif()
 endif()
 
+
 if (ADD_ARDUINO_EMULATOR)
     # Build with Linux Arduino Emulator
     FetchContent_Declare(arduino_emulator GIT_REPOSITORY "https://github.com/pschatzmann/Arduino-Emulator.git" GIT_TAG main )
diff --git a/cmake-tests/miniaudio/CMakeLists.txt b/cmake-tests/miniaudio/CMakeLists.txt
@@ -0,0 +1,28 @@
+cmake_minimum_required(VERSION 3.20)
+
+
+# set the project name
+project(generator)
+set (CMAKE_CXX_STANDARD 11)
+set (DCMAKE_CXX_FLAGS "-Werror")
+set (CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -O0 -ldl -lpthread -lm")
+set (CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -O0 -ldl -lpthread -lm")
+
+# 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 (generator generator.cpp)
+
+# set preprocessor defines
+target_compile_definitions(generator PUBLIC DEXIT_ON_STOP -DIS_MIN_DESKTOP)
+
+# specify libraries
+target_link_libraries(generator arduino-audio-tools)
+
+# access to miniaudio in sketch directory
+target_include_directories(generator PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
+
diff --git a/cmake-tests/miniaudio/generator.cpp b/cmake-tests/miniaudio/generator.cpp
@@ -0,0 +1,28 @@
+// Simple wrapper for Arduino sketch to compilable with cpp in cmake
+#include "AudioTools.h"
+#include "AudioLibs/MiniAudioStream.h"
+#include "AudioLibs/StdioStream.h"
+
+//LinuxStdio out;                            // Output to stdio on Desktop
+MiniAudioStream out;                         // Output to MiniAudioStream
+SineWaveGenerator<int16_t> sine_wave;        // subclass of SoundGenerator with max amplitude
+GeneratedSoundStream<int16_t> in_stream(sine_wave); // Stream generated from sine wave
+StreamCopy copier(out, in_stream);                  // copies sound to out
+
+void setup(){
+  AudioLogger::instance().begin(Serial, AudioLogger::Warning);
+
+  auto cfg = out.defaultConfig(TX_MODE);
+  //cfg.sample_rate = 22000;
+  if (!out.begin(cfg)){
+    stop();
+  }
+
+  sine_wave.begin(cfg, N_B4);
+  in_stream.begin();
+}
+
+void loop(){
+    copier.copy();
+}
+
diff --git a/src/AudioConfig.h b/src/AudioConfig.h
@@ -11,9 +11,9 @@
 #  include "Arduino.h"
 #elif defined(IS_DESKTOP_WITH_TIME_ONLY)
 #  include "AudioLibs/MillisDesktop.h"
-#  include "AudioLibs/NoArduino.h"
+#  include "AudioLibs/Desktop/NoArduino.h"
 #else 
-#  include "AudioLibs/NoArduino.h"
+#  include "AudioLibs/Desktop/NoArduino.h"
 #  define IS_JUPYTER
 #endif
 #include <string.h>
@@ -554,6 +554,13 @@ using WiFiServerSecure = BearSSL::WiFiServerSecure;
 typedef WiFiClient WiFiClientSecure;
 #endif
 
+#ifdef IS_MIN_DESKTOP
+#  include "AudioLibs/Desktop/NoArduino.h"
+#  include "AudioLibs/Desktop/Millis.h"
+#  include "AudioLibs/Desktop/Main.h"
+#  include "AudioLibs/Desktop/File.h"
+#endif
+
 #ifndef ARDUINO
 #  define USE_STREAM_WRITE_OVERRIDE
 #endif
diff --git a/src/AudioLibs/Desktop/File.h b/src/AudioLibs/Desktop/File.h
@@ -1,5 +1,5 @@
 #pragma once
-#include "AudioLibs/NoArduino.h"
+#include "AudioLibs/Desktop/NoArduino.h"
 #include <iostream>
 #include <fstream>
 #include <sys/stat.h>
@@ -18,6 +18,9 @@ enum SeekMode { SeekSet = 0, SeekCur = 1, SeekEnd = 2 };
 class File : public Stream {
   public:
     File() = default;
+    File(const char* fn) {
+        open(fn, FILE_READ);
+    }
     
     void open(const char* name, FileMode mode){
         file_path = name;
diff --git a/src/AudioLibs/Desktop/JupyterAudio.h b/src/AudioLibs/Desktop/JupyterAudio.h
@@ -1,5 +1,5 @@
 #pragma once
-#include "AudioLibs/NoArduino.h"
+#include "AudioLibs/Desktop/NoArduino.h"
 #include "AudioTools/AudioStreams.h"
 #include "AudioTools/AudioPrint.h"
 #include "AudioCodecs/CodecWAV.h"
diff --git a/src/AudioLibs/Desktop/Main.h b/src/AudioLibs/Desktop/Main.h
@@ -0,0 +1,14 @@
+/**
+ * Generic main for desktop arduino emulation
+*/
+#pragma once
+
+void loop();
+void setup();
+
+int main (void) { 
+    setup();
+    while(true){
+        loop();
+    }
+ }	
diff --git a/src/AudioLibs/Desktop/Millis.h b/src/AudioLibs/Desktop/Millis.h
@@ -1,5 +1,5 @@
 #pragma once
-#include "AudioLibs/NoArduino.h"
+#include "AudioLibs/Desktop/NoArduino.h"
 #include <iostream>
 
 #define DESKTOP_MILLIS_DEFINED
diff --git a/src/AudioLibs/Desktop/NoArduino.h b/src/AudioLibs/Desktop/NoArduino.h
diff --git a/src/AudioLibs/Jupyter.h b/src/AudioLibs/Jupyter.h
@@ -1,4 +1,4 @@
 #pragma once
-#include "MillisDesktop.h"
-#include "Jupyter/JupyterAudio.h"
-#include "Jupyter/File.h"
+#include "Desktop/Millis.h"
+#include "Desktop/JupyterAudio.h"
+#include "Desktop/File.h"
diff --git a/src/AudioLibs/MiniAudioStream.h b/src/AudioLibs/MiniAudioStream.h
@@ -0,0 +1,216 @@
+#pragma once
+/**
+ * @brief MiniAudio
+ * @author Phil Schatzmann
+ * @copyright GPLv3
+ */
+
+#include <mutex>
+#include <thread>
+#include "AudioTools.h"
+
+#define MINIAUDIO_IMPLEMENTATION
+#include "miniaudio.h"
+
+#define MA_BUFFER_COUNT 20
+#define MA_START_COUNT MA_BUFFER_COUNT-2
+
+namespace audio_tools {
+/**
+ * @brief Configuration for MiniAudio
+ * @author Phil Schatzmann
+ * @copyright GPLv3
+ */
+class MiniAudioConfig : public AudioInfo {
+ public:
+  MiniAudioConfig() {
+    sample_rate = 44100;
+    channels = 2;
+    bits_per_sample = 16;
+  };
+  MiniAudioConfig(const MiniAudioConfig &) = default;
+  MiniAudioConfig(const AudioInfo &in) {
+    sample_rate = in.sample_rate;
+    channels = in.channels;
+    bits_per_sample = in.bits_per_sample;
+  }
+
+  bool is_input = false;
+  bool is_output = true;
+};
+
+/**
+ * @brief MiniAudio: https://miniaud.io/
+ * @ingroup io
+ * @author Phil Schatzmann
+ * @copyright GPLv3
+ */
+class MiniAudioStream : public AudioStream {
+ public:
+  MiniAudioStream() = default;
+  ~MiniAudioStream() { end(); };
+
+  MiniAudioConfig defaultConfig(RxTxMode mode = RXTX_MODE) {
+    MiniAudioConfig info;
+    info.sample_rate = 44100;
+    info.channels = 2;
+    info.bits_per_sample = 16;
+    switch (mode) {
+      case RX_MODE:
+        info.is_input = true;
+        info.is_output = false;
+        break;
+      case TX_MODE:
+        info.is_input = false;
+        info.is_output = true;
+        break;
+      case RXTX_MODE:
+        info.is_input = true;
+        info.is_output = true;
+        break;
+      default:
+        info.is_input = false;
+        info.is_output = false;
+        break;
+    }
+    return info;
+  }
+
+  void setAudioInfo(AudioInfo in) override {
+    if (in.sample_rate != info.sample_rate || in.channels != info.channels ||
+        in.bits_per_sample != info.bits_per_sample) {
+      end();
+      begin(in);
+    }
+  }
+
+  bool begin(MiniAudioConfig info) {
+    this->info = info;
+    this->config = info;
+
+    if (info.is_output && !info.is_input)
+        config_ma = ma_device_config_init(ma_device_type_playback);
+    else if (!info.is_output && info.is_input)
+        config_ma = ma_device_config_init(ma_device_type_capture);
+    else if (info.is_output && info.is_input)
+        config_ma = ma_device_config_init(ma_device_type_duplex);
+    else if (!info.is_output && !info.is_input)
+        config_ma = ma_device_config_init(ma_device_type_loopback);
+    
+
+    config_ma.playback.channels = info.channels;
+    config_ma.sampleRate = info.sample_rate;
+    config_ma.dataCallback = data_callback;
+    switch (info.bits_per_sample) {
+      case 16:
+        config_ma.playback.format = ma_format_s16;
+        break;
+      case 24:
+        config_ma.playback.format = ma_format_s24;
+        break;
+      case 32:
+        config_ma.playback.format = ma_format_s32;
+        break;
+      default:
+        LOGE("Invalid format");
+        return false;
+    }
+    config_ma.pUserData = this;
+
+    if (ma_device_init(NULL, &config_ma, &device_ma) != MA_SUCCESS) {
+      // Failed to initialize the device.
+      return false;
+    }
+
+    // The device is sleeping by default so you'll  need to start it manually.
+    ma_device_start(&device_ma);
+
+    is_active = true;
+    return is_active;
+  }
+
+  void end() {
+    is_active = false;
+    is_playing = false;
+    // This will stop the device so no need to do that manually.
+    ma_device_uninit(&device_ma);
+    // release buffer memory
+    delete (p_buffer_in);
+    p_buffer_in = nullptr;
+    delete (p_buffer_out);
+    p_buffer_out = nullptr;
+  }
+
+  int availableForWrite() override { return p_buffer_out==nullptr? 0 : p_buffer_out->availableForWrite(); }
+
+  size_t write(const uint8_t *data, size_t len) override {
+    if (p_buffer_out==nullptr) return 0;
+    LOGD("write: %zu", len);
+    //std::lock_guard<mutex> qLock(mtxQueue);
+    size_t result = p_buffer_out->writeArray(data, len);
+    if (!is_playing && p_buffer_out->bufferCountFilled()>=MA_START_COUNT) {
+      is_playing = true;
+    }
+    //std::this_thread::yield();
+    return result;
+  }
+
+  int available() override {  return p_buffer_in==nullptr ? 0 : p_buffer_in->available(); }
+
+  size_t readBytes(uint8_t *data, size_t len) override {
+    if (p_buffer_in==nullptr) return 0;
+    LOGD("write: %zu", len);
+    //std::lock_guard<mutex> qLock(mtxQueue);
+    return p_buffer_in->readArray(data, len);
+  }
+
+ protected:
+  MiniAudioConfig config;
+  ma_device_config config_ma;
+  ma_device device_ma;
+  bool is_playing = false;
+  bool is_active = false;
+  bool is_buffers_setup = false;
+  NBuffer<uint8_t> *p_buffer_out = nullptr;
+  NBuffer<uint8_t> *p_buffer_in = nullptr;
+  //std::mutex mtxQueue;
+
+  // In playback mode copy data to pOutput. In capture mode read data from
+  // pInput. In full-duplex mode, both pOutput and pInput will be valid and
+  // you can move data from pInput into pOutput. Never process more than
+  // frameCount frames.
+
+  void setupBuffers(int size) {
+    if (is_buffers_setup) return;
+    if (p_buffer_out == nullptr && config.is_output)
+      p_buffer_out = new NBuffer<uint8_t>(size, MA_BUFFER_COUNT);
+    if (p_buffer_in==nullptr && config.is_input)
+      p_buffer_in = new NBuffer<uint8_t>(size, MA_BUFFER_COUNT);
+    is_buffers_setup = true;
+  }
+
+  static void data_callback(ma_device *pDevice, void *pOutput,
+                            const void *pInput, ma_uint32 frameCount) {
+    MiniAudioStream *self = (MiniAudioStream *)pDevice->pUserData;
+    AudioInfo cfg = self->audioInfo();
+
+    int bytes = frameCount * cfg.channels * cfg.bits_per_sample / 8;
+    self->setupBuffers(bytes);
+
+    if (pInput) {
+      //std::unique_lock<mutex> qLock(self->mtxQueue);
+      self->p_buffer_in->writeArray((uint8_t *)pInput, bytes);
+    }
+
+    if (pOutput) {
+      memset(pOutput, 0, bytes);
+      if (self->is_playing ) {
+          //std::lock_guard<mutex> qLock(self->mtxQueue);
+          self->p_buffer_out->readArray((uint8_t *)pOutput, bytes);
+          std::this_thread::yield();
+      }
+    } 
+  }
+};
+
+}  // namespace audio_tools
diff --git a/src/AudioTools/Buffers.h b/src/AudioTools/Buffers.h
diff --git a/src/Experiments/MiniAudioStream.h b/src/Experiments/MiniAudioStream.h
