### Configuring and Starting FadeStream

Source: https://github.com/pschatzmann/arduino-audio-tools/wiki/Interactive-Audio

This snippet shows the necessary steps to configure and start the FadeStream within the setup phase of an Arduino sketch.

```APIDOC
## Extending the Setup

### Description
This code demonstrates how to initialize and start the `FadeStream` object by calling its `begin()` method with the appropriate configuration.

### Method
N/A (Code Example)

### Endpoint
N/A (Code Example)

### Parameters
N/A (Code Example)

### Request Example
```cpp
  // Setup fade
  fade.begin(cfg);
```

### Response
N/A (Code Example)

### Response Example
N/A (Code Example)
```

--------------------------------

### Install Library via Git

Source: https://github.com/pschatzmann/arduino-audio-tools/blob/main/README.md

Command-line instructions to clone the library repository into the Arduino libraries directory.

```bash
cd  ~/Documents/Arduino/libraries
git clone https://github.com/pschatzmann/arduino-audio-tools.git
```

--------------------------------

### Arduino Setup Function (C++)

Source: https://github.com/pschatzmann/arduino-audio-tools/wiki/Interactive-Audio

The main Arduino setup function initializes serial communication, the audio logger, and the I2S audio output. It configures the I2S stream with default settings, initializes the sound generation stream to match I2S parameters, and calls setupActions() to prepare the interactive audio controls.

```C++
void setup() {
  Serial.begin(115200);
  AudioLogger::instance().begin(Serial,AudioLogger::Info);

  // Setup output
  auto cfg = i2s.defaultConfig(TX_MODE);
  // add additional settings e.g. to define your pins or a different sample rate
  i2s.begin(cfg);

  // Setup sound generation based on Audioi2s settings
  in.begin(cfg);

  // activate keys
  setupActions();

}
```

--------------------------------

### Configure and Start Audio Effects

Source: https://github.com/pschatzmann/arduino-audio-tools/wiki/Audio-Effects

Shows how to add an ADSR gain effect to the stream and initialize the hardware configuration in the setup function.

```C++
ADSRGain adsr(0.0001,0.0001, 0.9 , 0.0002);

void setup() {
  effects.addEffect(adsr);
  auto cfg = i2s.defaultConfig(TX_MODE);
  i2s.begin(cfg);
  sine.begin(cfg, 0);
  sine_stream.begin(cfg);
  effects.begin(cfg);
}
```

--------------------------------

### Basic API Examples - Arduino

Source: https://github.com/pschatzmann/arduino-audio-tools/blob/main/examples/build-examples-log.txt

Demonstrates fundamental functionalities of the Arduino Audio Tools library's basic API. These examples typically involve reading analog data, processing it via ADC, and outputting results serially or to buffers. They serve as a starting point for understanding core library operations.

```Arduino
// Example: base-adc-average-mono-serial
// Reads analog data, averages it, and sends it over serial.
// Dependencies: Arduino core libraries.
// Input: Analog pin readings.
// Output: Averaged mono audio data via Serial.
void setup() {
  Serial.begin(115200);
  // Initialize ADC and other necessary components
}

void loop() {
  // Read analog data
  // Average the data
  // Send over serial
}

```

```Arduino
// Example: base-adc-measure
// Measures analog input and provides raw data.
// Dependencies: Arduino core libraries.
// Input: Analog pin readings.
// Output: Raw analog data.
void setup() {
  Serial.begin(115200);
  // Initialize ADC
}

void loop() {
  // Read analog data
  int value = analogRead(A0);
  Serial.println(value);
  delay(10);
}

```

```Arduino
// Example: base-adc-serial
// Reads analog data and sends it directly over serial.
// Dependencies: Arduino core libraries.
// Input: Analog pin readings.
// Output: Raw analog data via Serial.
void setup() {
  Serial.begin(115200);
  // Initialize ADC
}

void loop() {
  int value = analogRead(A0);
  Serial.println(value);
  delay(10);
}

```

```Arduino
// Example: base-file_raw-serial
// Reads raw data from a file and sends it over serial.
// Dependencies: File system library (e.g., SPIFFS, SD).
// Input: Raw audio file.
// Output: Raw audio data via Serial.
#include <FS.h>

void setup() {
  Serial.begin(115200);
  SPIFFS.begin(); // Or SD.begin()
}

void loop() {
  File file = SPIFFS.open("/audio.raw", "r"); // Or "/sd/audio.raw"
  if (file) {
    while (file.available()) {
      Serial.write(file.read());
    }
    file.close();
  }
  delay(1000);
}

```

```Arduino
// Example: base-SynchronizedBufferRTOS
// Demonstrates synchronized buffer operations using RTOS features.
// Dependencies: RTOS library (e.g., FreeRTOS).
// Input: Data to be buffered.
// Output: Synchronized data streams.
#include <freertos/FreeRTOS.h>
#include <freertos/task.h>

void setup() {
  // Initialize RTOS and buffers
}

void loop() {
  // Task to produce data
  // Task to consume data
  // Synchronization mechanisms
  vTaskDelay(pdMS_TO_TICKS(100));
}

```

--------------------------------

### CMake Configuration for FFT Example

Source: https://github.com/pschatzmann/arduino-audio-tools/blob/main/tests-cmake/fft/CMakeLists.txt

This CMakeLists.txt file configures the build process for the FFT example. It sets project properties, compiler flags, includes the arduino-audio-tools library, downloads a necessary header, and defines the build target.

```cmake
cmake_minimum_required(VERSION 3.20)


# set the project name
project(fft)
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")

# Emulator is not necessary for -DIS_MIN_DESKTOP
set(ADD_ARDUINO_EMULATOR OFF CACHE BOOL "Add Arduino Emulator Library") 
set(ADD_PORTAUDIO OFF CACHE BOOL "No Portaudio") 

# 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()

# Download miniaudio.h
file(DOWNLOAD https://raw.githubusercontent.com/mackron/miniaudio/master/miniaudio.h
    ${CMAKE_CURRENT_SOURCE_DIR}/miniaudio.h)


# build sketch as executable
add_executable (fft fft.cpp)

# set preprocessor defines
target_compile_definitions(fft PUBLIC -DIS_DESKTOP)

# specify libraries
target_link_libraries(fft arduino-audio-tools)

# access to miniaudio in sketch directory
target_include_directories(fft PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
```

--------------------------------

### Configure and Start FadeStream

Source: https://github.com/pschatzmann/arduino-audio-tools/wiki/Interactive-Audio

Configures and starts the FadeStream object using provided settings. This step is crucial after initializing the FadeStream and before audio processing begins to ensure the fade effect is properly applied.

```C++
  // Setup fade
  fade.begin(cfg);

```

--------------------------------

### Player Examples - Arduino

Source: https://github.com/pschatzmann/arduino-audio-tools/blob/main/examples/build-examples-log.txt

These examples showcase the audio playback capabilities of the Arduino Audio Tools library. They cover various audio sources like SD cards, FTP, and different output methods such as I2S and AudioKit. Examples include handling callbacks, different file formats, and file systems.

```Arduino
// Example: player-callback-i2s
// Plays audio from a source using I2S output with callback handling.
// Dependencies: Audio library, I2S driver.
// Input: Audio data source.
// Output: Audio playback via I2S.
#include <Audio.h>

Audio audio;

void setup() {
  // Initialize audio, I2S, and set callback
  audio.setPinout(I2S_BCLK, I2S_LRC, I2S_DOUT);
  audio.setVolume(5);
  audio.connecttohost("stream.example.com"); // Or load from file
}

void loop() {
  audio.update();
}

void audio_info(const char *info) {
  Serial.println(info);
}

void audio_eof_mp3(const char *info) {
  Serial.println("End of file");
}

```

```Arduino
// Example: player-ftp-audiokit
// Plays audio files from an FTP server using AudioKit.
// Dependencies: Audio library, FTP client, AudioKit.
// Input: Audio file on FTP server.
// Output: Audio playback via AudioKit.
#include <Audio.h>
#include <WiFi.h>
#include <WiFiClient.h>

Audio audio;
WiFiClient client;

void setup() {
  WiFi.begin("ssid", "password");
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
  }
  audio.setAudioPort(80, "/stream.mp3"); // Example URL
  audio.connecttohost("ftp.example.com"); // FTP host
}

void loop() {
  audio.update();
}

```

```Arduino
// Example: player-littlefs-i2s
// Plays audio files stored on LittleFS using I2S output.
// Dependencies: Audio library, LittleFS, I2S driver.
// Input: Audio file on LittleFS.
// Output: Audio playback via I2S.
#include <Audio.h>
#include <LittleFS.h>

Audio audio;

void setup() {
  LittleFS.begin();
  audio.setPinout(I2S_BCLK, I2S_LRC, I2S_DOUT);
  audio.loop("/audio.mp3"); // Path to audio file on LittleFS
}

void loop() {
  audio.update();
}

```

```Arduino
// Example: player-sd-audiokit
// Plays audio files from an SD card using AudioKit.
// Dependencies: Audio library, SD card library, AudioKit.
// Input: Audio file on SD card.
// Output: Audio playback via AudioKit.
#include <Audio.h>
#include <SD.h>

Audio audio;

void setup() {
  SD.begin();
  audio.setAudioPort(80, "/audio.mp3"); // Example URL
  audio.connecttohost("sd:/audio.mp3"); // Path on SD card
}

void loop() {
  audio.update();
}

```

```Arduino
// Example: player-sdfat-analog
// Plays audio from SD using SDFat library with analog output.
// Dependencies: Audio library, SDFat library.
// Input: Audio file on SD card.
// Output: Analog audio output.
#include <Audio.h>
#include <SDFat.h>

Audio audio;
SDFat SD;

void setup() {
  SD.begin();
  audio.setPinout(A0, A1, A2); // Example analog pins
  audio.loop("/audio.mp3");
}

void loop() {
  audio.update();
}

```

```Arduino
// Example: player-sdfat-audiokit
// Plays audio files from an SD card using SDFat and AudioKit.
// Dependencies: Audio library, SDFat library, AudioKit.
// Input: Audio file on SD card.
// Output: Audio playback via AudioKit.
#include <Audio.h>
#include <SDFat.h>

Audio audio;
SDFat SD;

void setup() {
  SD.begin();
  audio.setAudioPort(80, "/audio.mp3"); // Example URL
  audio.connecttohost("sdfat:/audio.mp3"); // Path on SD card
}

void loop() {
  audio.update();
}

```

```Arduino
// Example: player-sdfat-ffti2s
// Plays audio from SD using SDFat and outputs via I2S with FFT.
// Dependencies: Audio library, SDFat library, I2S driver.
// Input: Audio file on SD card.
// Output: Audio playback via I2S with FFT data.
#include <Audio.h>
#include <SDFat.h>

Audio audio;
SDFat SD;

void setup() {
  SD.begin();
  audio.setPinout(I2S_BCLK, I2S_LRC, I2S_DOUT);
  audio.fft_init(1024, FFT_REAL, 10);
  audio.loop("/audio.mp3");
}

void loop() {
  audio.update();
  if (audio.fft_run())
    // Process FFT data
}

```

```Arduino
// Example: player-sdfat-i2s
// Plays audio files from an SD card using SDFat and I2S output.
// Dependencies: Audio library, SDFat library, I2S driver.
// Input: Audio file on SD card.
// Output: Audio playback via I2S.
#include <Audio.h>
#include <SDFat.h>

Audio audio;
SDFat SD;

void setup() {
  SD.begin();
  audio.setPinout(I2S_BCLK, I2S_LRC, I2S_DOUT);
  audio.loop("/audio.mp3");
}

void loop() {
  audio.update();
}

```

```Arduino
// Example: player-sd-i2s
// Plays audio files from an SD card using standard SD library and I2S output.
// Dependencies: Audio library, SD library, I2S driver.
// Input: Audio file on SD card.
// Output: Audio playback via I2S.
#include <Audio.h>
#include <SD.h>

Audio audio;

void setup() {
  SD.begin();
  audio.setPinout(I2S_BCLK, I2S_LRC, I2S_DOUT);
  audio.loop("/audio.mp3");
}

void loop() {
  audio.update();
}

```

```Arduino
// Example: player-sd_m4a-audiokit
// Plays M4A audio files from an SD card using AudioKit.
// Dependencies: Audio library, SD card library, AudioKit.
// Input: M4A audio file on SD card.
// Output: Audio playback via AudioKit.
#include <Audio.h>
#include <SD.h>

Audio audio;

void setup() {
  SD.begin();
  audio.setAudioPort(80, "/audio.m4a"); // Example URL
  audio.connecttohost("sd:/audio.m4a"); // Path on SD card
}

void loop() {
  audio.update();
}

```

```Arduino
// Example: player-sdmmc-audiokit
// Plays audio files from an SD/MMC card using AudioKit.
// Dependencies: Audio library, SD/MMC library, AudioKit.
// Input: Audio file on SD/MMC card.
// Output: Audio playback via AudioKit.
#include <Audio.h>
#include <SD_MMC.h>

Audio audio;

void setup() {
  SD_MMC.begin();
  audio.setAudioPort(80, "/audio.mp3"); // Example URL
  audio.connecttohost("sdmmc:/audio.mp3"); // Path on SD/MMC card
}

void loop() {
  audio.update();
}

```

```Arduino
// Example: player-spiffs-i2s
// Plays audio files from SPIFFS file system using I2S output.
// Dependencies: Audio library, SPIFFS, I2S driver.
// Input: Audio file on SPIFFS.
// Output: Audio playback via I2S.
#include <Audio.h>
#include <SPIFFS.h>

Audio audio;

void setup() {
  SPIFFS.begin();
  audio.setPinout(I2S_BCLK, I2S_LRC, I2S_DOUT);
  audio.loop("/audio.mp3"); // Path to audio file on SPIFFS
}

void loop() {
  audio.update();
}

```

```Arduino
// Example: player-vector_sdfat-audiokit
// Plays audio from a vector stored on SD using SDFat and AudioKit.
// Dependencies: Audio library, SDFat library, AudioKit.
// Input: Vector data representing audio on SD card.
// Output: Audio playback via AudioKit.
#include <Audio.h>
#include <SDFat.h>
#include <vector>

Audio audio;
SDFat SD;

void setup() {
  SD.begin();
  std::vector<uint8_t> audioData;
  // Load audio data into the vector from SD card
  audio.setAudioPort(80, "/audio.mp3"); // Example URL
  audio.connecttohost(audioData.data(), audioData.size()); // Play from vector
}

void loop() {
  audio.update();
}

```

--------------------------------

### CMake Project Setup and Dependency Fetching

Source: https://github.com/pschatzmann/arduino-audio-tools/blob/main/tests-cmake/codec/aac-fdk/CMakeLists.txt

This snippet sets up the CMake project, defines the C++ standard and flags, and fetches external dependencies like arduino-audio-tools and fdk-aac using FetchContent. It ensures that subdirectories are correctly included for building.

```cmake
cmake_minimum_required(VERSION 3.20)

# set the project name
project(aac-fdk)
set (CMAKE_CXX_STANDARD 11)
set (DCMAKE_CXX_FLAGS "-Werror")
# add_compile_options(-Wstack-usage=1024)
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 with arduino-fdk-aac
FetchContent_Declare(fdk_aac GIT_REPOSITORY "https://github.com/pschatzmann/arduino-fdk-aac.git" GIT_TAG main )
FetchContent_GetProperties(fdk_aac)
if(NOT fdk_aac_POPULATED)
    FetchContent_Populate(fdk_aac)
    add_subdirectory(${fdk_aac_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR}/fdk_aac)
endif()
```

--------------------------------

### Generate Sine Wave Test Tone

Source: https://github.com/pschatzmann/arduino-audio-tools/wiki/Introduction

Sets up a SineWaveGenerator and routes the output to a CsvOutput stream. This example demonstrates initializing audio parameters and starting the generator with a specific frequency.

```C++
#include "AudioTools.h"

AudioInfo info(44100, 2, 16);
SineWaveGenerator<int16_t> sineWave(32000);
GeneratedSoundStream<int16_t> in(sineWave);
CsvOutput<int16_t> out(Serial);

void setup(void) {
  Serial.begin(115200);
  AudioToolsLogger.begin(Serial, AudioToolsLogLevel::Info);
  auto config = out.defaultConfig();
  config.copyFrom(info);
  out.begin(config);
  in.begin(info);
  sineWave.begin(info, N_B4);
}
```

--------------------------------

### Allocate Vector in Setup for PSRAM

Source: https://github.com/pschatzmann/arduino-audio-tools/wiki/Vector,-Allocators-&-PSRAM

Demonstrates allocating a Vector in the setup() function to ensure PSRAM is available. This is crucial for ESP32 projects where global variables might not have access to PSRAM at initialization.

```C++
Vector<int16_t> vector{0};

void setup() {
    vector.resize(100000);
}
```

--------------------------------

### CMake Project Setup and Dependencies

Source: https://github.com/pschatzmann/arduino-audio-tools/blob/main/tests-cmake/codec/adpcm/CMakeLists.txt

Configures the CMake project, sets the C++ standard and flags, and includes external dependencies like PortAudio and adpcm using FetchContent. It also adds the arduino-audio-tools library as a subdirectory.

```cmake
cmake_minimum_required(VERSION 3.20)

# set the project name
project(adpcm-test)
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)

# Add PortAudio for desktop build
add_compile_options(-DIS_DESKTOP)
FetchContent_Declare(portaudio GIT_REPOSITORY "https://github.com/PortAudio/portaudio.git" GIT_TAG v19.7.0 )
FetchContent_GetProperties(portaudio)
if(NOT portaudio_POPULATED)
    FetchContent_Populate(portaudio)
    add_subdirectory(${portaudio_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR}/portaudio)
endif()

# 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 with arduino-adpcm
FetchContent_Declare(adpcm_ffmpeg GIT_REPOSITORY "https://github.com/pschatzmann/adpcm" GIT_TAG main )
FetchContent_GetProperties(adpcm_ffmpeg)
if(NOT adpcm_ffmpeg)
    FetchContent_Populate(adpcm_ffmpeg)
    add_subdirectory(${adpcm_ffmpeg_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR}/adpcm)
endif()

# build sketch as executable
add_executable (adpcm-test adpcm.cpp)

# set preprocessor defines
target_compile_definitions(adpcm-test PUBLIC -DARDUINO -DUSE_PORTAUDIO -DIS_DESKTOP)

# specify libraries
target_link_libraries(adpcm-test portaudio arduino_emulator adpcm_ffmpeg arduino-audio-tools)
```

--------------------------------

### ESP-IDF Integration for Audio Tools

Source: https://github.com/pschatzmann/arduino-audio-tools/wiki/Using-the-Framework-w-o-Arduino

Example of setting up a sine wave generator using I2S output within an ESP-IDF project. It demonstrates renaming main.c to main.cpp and wrapping Arduino-style setup/loop functions within app_main.

```C++
#include "AudioTools.h"

uint16_t sample_rate=44100;
uint8_t channels = 2;
SineWaveGenerator<int16_t> sineWave(32000);
GeneratedSoundStream<int16_t> sound(sineWave);
I2SStream out;
StreamCopy copier(out, sound);

void setup(void) {
  auto config = out.defaultConfig(TX_MODE);
  config.sample_rate = sample_rate;
  config.channels = channels;
  config.bits_per_sample = 16;
  out.begin(config);
  sineWave.begin(channels, sample_rate, N_B4);
}

void loop() {
  copier.copy();
}

extern "C" void app_main() {
    setup();
    while(true) loop();
}
```

--------------------------------

### Starting a FreeRTOS Task

Source: https://github.com/pschatzmann/arduino-audio-tools/wiki/Multicore-Processing

Demonstrates how to create and begin a new FreeRTOS task for concurrent operations. This is useful for running background processes like screen updates or user input handling without blocking the main audio processing.

```C++
#include "AudioTools.h"
#include "AudioTools/Concurrency/RTOS.h"

Task task("write", 3000, 10, 0);
void method(){}
task.begin(method);
```

--------------------------------

### CMake Project Setup and Dependency Fetching (CMake)

Source: https://github.com/pschatzmann/arduino-audio-tools/blob/main/tests-cmake/codec/alac/CMakeLists.txt

Configures the CMake build system for the project, sets the C++ standard, and fetches the 'codec-alac' dependency from GitHub. It includes logic to populate the dependency if it hasn't been already and adds its subdirectory to the build.

```cmake
cmake_minimum_required(VERSION 3.20)

# set the project name
project(alac)
set (CMAKE_CXX_STANDARD 11)
set (DCMAKE_CXX_FLAGS "-Werror")

include(FetchContent)
option(BUILD_SHARED_LIBS "Build using shared libraries" OFF)

# Build with arduino-fdk-aac
FetchContent_Declare(codec-alac GIT_REPOSITORY "https://github.com/pschatzmann/codec-alac.git" GIT_TAG main )
FetchContent_GetProperties(codec-alac)
if(NOT codec-alac_POPULATED)
    FetchContent_Populate(codec-alac)
    add_subdirectory(${codec-alac_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR}/codec-alac)
endif()
```

--------------------------------

### FadeStream Integration Example

Source: https://github.com/pschatzmann/arduino-audio-tools/wiki/Interactive-Audio

This example demonstrates how to integrate the FadeStream into an audio processing chain to manage fades.

```APIDOC
## FadeStream Integration

### Description
This section shows how to add a `FadeStream` to an audio processing chain to prepare for fade operations, either on the input or output side.

### Method
N/A (Code Example)

### Endpoint
N/A (Code Example)

### Parameters
N/A (Code Example)

### Request Example
```cpp
#include "AudioTools.h"

I2SStream i2s;
SineWaveGenerator<int16_t> sine;
GeneratedSoundStream<int16_t> in(sine);
FadeStream fade(in); 
StreamCopy copier(i2s, fade); 
AudioActions action;
```

### Response
N/A (Code Example)

### Response Example
N/A (Code Example)
```

--------------------------------

### PlatformIO Configuration with Specific Library Version

Source: https://github.com/pschatzmann/arduino-audio-tools/wiki/Working-with-PlatformIO

Example of how to specify a particular Git version (tag) for the arduino-audio-tools library in the platformio.ini file.

```ini
lib_deps = https://github.com/pschatzmann/arduino-audio-tools.git#v0.9.8
```

--------------------------------

### CMake Project Setup and Dependencies

Source: https://github.com/pschatzmann/arduino-audio-tools/blob/main/tests-cmake/codec/mp3-lame/CMakeLists.txt

This CMake script configures the project, sets C++ standards, and includes external libraries like arduino-audio-tools and liblame using FetchContent. It also defines preprocessor macros for the Arduino environment.

```cmake
cmake_minimum_required(VERSION 3.20)

# set the project name
project(mp3-lame)
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 with liblame 
FetchContent_Declare(arduino_liblame GIT_REPOSITORY "https://github.com/pschatzmann/arduino-liblame.git" GIT_TAG main )
FetchContent_GetProperties(arduino_liblame)
if(NOT arduino_liblame_POPULATED)
    FetchContent_Populate(arduino_liblame)
    add_subdirectory(${arduino_liblame_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR}/arduino_liblame)
endif()

# build sketch as executable
add_executable (mp3-lame mp3-lame.cpp)
# set preprocessor defines
target_compile_definitions(mp3-lame PUBLIC -DARDUINO -DUSE_PORTAUDIO -DIS_DESKTOP)

# specify libraries
target_link_libraries(mp3-lame portaudio arduino_emulator arduino_liblame arduino-audio-tools)
```

--------------------------------

### CMake Project Setup and Dependency Fetching

Source: https://github.com/pschatzmann/arduino-audio-tools/blob/main/tests-cmake/codec/container-avi-movie/CMakeLists.txt

This CMake script configures a project, sets C++ standards, and fetches external dependencies like PortAudio. It's designed for desktop builds and integrates with the Arduino Audio Tools library.

```cmake
cmake_minimum_required(VERSION 3.20)

# set the project name
project(container-avi-movie)
set (CMAKE_CXX_STANDARD 11)
set (DCMAKE_CXX_FLAGS "-Werror")

# add_compile_options(-Wstack-usage=1024)
include(FetchContent)

# Add Portaduio for desktop build
add_compile_options(-DIS_DESKTOP)
FetchContent_Declare(portaudio GIT_REPOSITORY "https://github.com/PortAudio/portaudio.git" GIT_TAG v19.7.0 )
FetchContent_GetProperties(portaudio)
if(NOT portaudio_POPULATED)
    FetchContent_Populate(portaudio)
    add_subdirectory(${portaudio_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR}/portaudio)
endif()

# 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()

# OpenCV
find_package( OpenCV REQUIRED )
include_directories( ${OpenCV_INCLUDE_DIRS} )

# build sketch as executable
add_executable (container-avi-movie container-avi-movie.cpp)

# set preprocessor defines
target_compile_definitions(container-avi-movie PUBLIC -DUSE_PORTAUDIO -DIS_MIN_DESKTOP)
target_include_directories(container-avi-movie PRIVATE "${arduino_emulator_SOURCE_DIR}/ArduinoCore-Linux/libraries/SdFat" )

# OS/X might need this setting for core audio
#target_compile_definitions(portaudio PUBLIC -DPA_USE_COREAUDIO=1)

# specify libraries
target_link_libraries(container-avi-movie portaudio arduino-audio-tools  ${OpenCV_LIBS})
```

--------------------------------

### Vector Memory Allocation Examples

Source: https://github.com/pschatzmann/arduino-audio-tools/wiki/Vector,-Allocators-&-PSRAM

Provides examples of allocating Vectors using different allocators (PSRAM, RAM, or default). The DefaultAllocator attempts to use PSRAM first and falls back to RAM if PSRAM is unavailable or fails.

```C++
#include "AudioTools.h"

Vector<int16_t> vectorPSRAM{0}; // same as vectorPSRAM{0, DefaultAllocator};
Vector<int16_t> vectorRAM{10000}; // Allocation in RAM because PSRAM fails.
Vector<int16_t> vectorRAM1{10000, DefaultAllocatorRAM}; // allocation in RAM
Vector<int16_t> vectorRAM2{0, DefaultAllocatorRAM}; // allocation in RAM

void setup() {
  vectorPSRAM.resize(10000); // allocate data in PSRAM 
  vectorRAM2.resize(10000); // allocate data in RAM
}
```

--------------------------------

### CMake Project Setup and Dependency Fetching

Source: https://github.com/pschatzmann/arduino-audio-tools/blob/main/tests-cmake/codec/m4a-extractor/CMakeLists.txt

Configures the CMake build environment, sets the project name and C++ standard, and fetches external dependencies (codec-alac and libhelix) using FetchContent. It ensures these dependencies are populated and added to the build.

```cmake
cmake_minimum_required(VERSION 3.20)

# set the project name
project(m4a-extractor)
set (CMAKE_CXX_STANDARD 11)
set (DCMAKE_CXX_FLAGS "-Werror")

include(FetchContent)
option(BUILD_SHARED_LIBS "Build using shared libraries" OFF)

# Build with alac
FetchContent_Declare(codec-alac GIT_REPOSITORY "https://github.com/pschatzmann/codec-alac.git" GIT_TAG main )
FetchContent_GetProperties(codec-alac)
if(NOT codec-alac_POPULATED)
    FetchContent_Populate(codec-alac)
    add_subdirectory(${codec-alac_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR}/codec-alac)
endif()

# Build with libhelix
FetchContent_Declare(helix GIT_REPOSITORY "https://github.com/pschatzmann/arduino-libhelix.git" GIT_TAG main )
FetchContent_GetProperties(helix)
if(NOT helix_POPULATED)
    FetchContent_Populate(helix)
    add_subdirectory(${helix_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR}/helix)
endif()


# provide 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()
```

--------------------------------

### Stream Examples - Arduino

Source: https://github.com/pschatzmann/arduino-audio-tools/blob/main/examples/build-examples-log.txt

These examples demonstrate various audio streaming functionalities using the Arduino Audio Tools library. They cover generating audio streams from different sources like ADC, arrays, and files, and routing them through various outputs like I2S, serial, and PWM. Advanced stream manipulation like ADSR envelopes and format conversion are also shown.

```Arduino
// Example: streams-adc-i2s
// Streams audio data from an ADC to an I2S output.
// Dependencies: Audio library, I2S driver.
// Input: Analog pin readings.
// Output: Audio stream via I2S.
#include <Audio.h>

Audio audio;

void setup() {
  audio.setPinout(I2S_BCLK, I2S_LRC, I2S_DOUT);
  // Configure ADC
}

void loop() {
  int adcValue = analogRead(A0);
  // Convert adcValue to audio sample and stream via I2S
  audio.writeStream(sample);
}

```

```Arduino
// Example: streams-adc-serial
// Streams audio data from an ADC to the serial port.
// Dependencies: Arduino core libraries.
// Input: Analog pin readings.
// Output: Audio data stream via Serial.
void setup() {
  Serial.begin(115200);
  // Configure ADC
}

void loop() {
  int adcValue = analogRead(A0);
  // Convert adcValue to audio sample and send over serial
  Serial.println(adcValue);
  delay(1);
}

```

```Arduino
// Example: streams-adsr-i2s
// Applies an ADSR (Attack, Decay, Sustain, Release) envelope to an audio stream and outputs via I2S.
// Dependencies: Audio library, I2S driver.
// Input: Audio stream.
// Output: ADSR-modulated audio stream via I2S.
#include <Audio.h>

Audio audio;

void setup() {
  audio.setPinout(I2S_BCLK, I2S_LRC, I2S_DOUT);
  // Initialize ADSR parameters
}

void loop() {
  // Get next audio sample
  float sample = audio.readStream();
  // Apply ADSR envelope to the sample
  float modulatedSample = applyADSR(sample);
  // Write modulated sample to I2S
  audio.writeStream(modulatedSample);
}

float applyADSR(float input) {
  // ADSR envelope logic here
  return input;
}

```

```Arduino
// Example: streams-generator-analog
// Generates an audio stream and outputs it via analog pins.
// Dependencies: Arduino core libraries.
// Input: None (generates internally).
// Output: Analog audio signal.
void setup() {
  // Configure analog output pins
}

void loop() {
  // Generate audio sample
  float sample = generateSample();
  // Output sample to analog pin
  // analogWrite(pin, sample);
}

float generateSample() {
  // Audio generation logic (e.g., sine wave)
  return 0.0;
}

```

```Arduino
// Example: streams-generator-bin-serial
// Generates a binary audio stream and sends it over the serial port.
// Dependencies: Arduino core libraries.
// Input: None (generates internally).
// Output: Binary audio data via Serial.
void setup() {
  Serial.begin(115200);
}

void loop() {
  // Generate audio sample (e.g., byte value)
  byte audioByte = generateAudioByte();
  // Send byte over serial
  Serial.write(audioByte);
}

byte generateAudioByte() {
  // Binary audio generation logic
  return 0;
}

```

```Arduino
// Example: streams-generator-formatconverter-i2s
// Generates an audio stream, converts its format, and outputs via I2S.
// Dependencies: Audio library, I2S driver.
// Input: None (generates internally).
// Output: Formatted audio stream via I2S.
#include <Audio.h>

Audio audio;

void setup() {
  audio.setPinout(I2S_BCLK, I2S_LRC, I2S_DOUT);
  // Initialize format converter
}

void loop() {
  // Generate audio sample
  float sample = generateSample();
  // Convert format if necessary
  // Write converted sample to I2S
  audio.writeStream(convertedSample);
}

float generateSample() {
  // Audio generation logic
  return 0.0;
}

```

```Arduino
// Example: streams-generator_fromarray-analog
// Generates an audio stream from a pre-defined array and outputs via analog pins.
// Dependencies: Arduino core libraries.
// Input: Array of audio samples.
// Output: Analog audio signal.
float audioSamples[] = {0.1, 0.2, 0.3, ...};
int numSamples = sizeof(audioSamples) / sizeof(audioSamples[0]);
int currentIndex = 0;

void setup() {
  // Configure analog output pins
}

void loop() {
  // Get sample from array
  float sample = audioSamples[currentIndex];
  // Output sample to analog pin
  // analogWrite(pin, sample);
  
  currentIndex = (currentIndex + 1) % numSamples;
}

```

```Arduino
// Example: streams-generator-i2s
// Generates a basic audio stream and outputs it via I2S.
// Dependencies: Audio library, I2S driver.
// Input: None (generates internally).
// Output: Audio stream via I2S.
#include <Audio.h>

Audio audio;

void setup() {
  audio.setPinout(I2S_BCLK, I2S_LRC, I2S_DOUT);
}

void loop() {
  // Generate audio sample
  float sample = generateSample();
  // Write sample to I2S
  audio.writeStream(sample);
}

float generateSample() {
  // Audio generation logic (e.g., sine wave)
  return 0.0;
}

```

```Arduino
// Example: streams-generator-merge-pwm
// Merges multiple audio streams and outputs the result via PWM.
// Dependencies: Arduino core libraries.
// Input: Multiple audio streams.
// Output: Merged audio stream via PWM.
void setup() {
  // Configure PWM pins
}

void loop() {
  // Get samples from different streams
  float sample1 = getStream1Sample();
  float sample2 = getStream2Sample();
  // Merge samples (e.g., sum)
  float mergedSample = sample1 + sample2;
  // Output merged sample via PWM
  // analogWrite(pwmPin, mergedSample);
}

```

```Arduino
// Example: streams-generator-pwm
// Generates an audio stream and outputs it via PWM.
// Dependencies: Arduino core libraries.
// Input: None (generates internally).
// Output: Audio stream via PWM.
void setup() {
  // Configure PWM pin
}

void loop() {
  // Generate audio sample
  float sample = generateSample();
  // Output sample via PWM
  // analogWrite(pwmPin, sample);
}

float generateSample() {
  // Audio generation logic
  return 0.0;
}

```

```Arduino
// Example: streams-generator-r2r
// Generates an audio stream for a Resistor-to-Resistor (R2R) DAC.
// Dependencies: Arduino core libraries.
// Input: None (generates internally).
// Output: Digital signals for R2R DAC.
void setup() {
  // Configure digital pins for R2R DAC
}

void loop() {
  // Generate audio sample (e.g., byte)
  byte audioByte = generateAudioByte();
  // Output byte to R2R DAC pins
  // for (int i = 0; i < 8; i++) {
  //   digitalWrite(dacPins[i], (audioByte >> i) & 1);
  // }
}

byte generateAudioByte() {
  // Audio generation logic for R2R DAC
  return 0;
}

```

```Arduino
// Example: streams-generator-serial
// Generates an audio stream and sends it over the serial port.
// Dependencies: Arduino core libraries.
// Input: None (generates internally).
// Output: Audio data stream via Serial.
void setup() {
  Serial.begin(115200);
}

void loop() {
  // Generate audio sample
  float sample = generateSample();
  // Convert sample to a format suitable for serial transmission (e.g., string, byte)
  // Serial.println(sample);
}

float generateSample() {
  // Audio generation logic
  return 0.0;
}

```

```Arduino
// Example: streams-generator-spdif
// Generates an audio stream formatted for S/PDIF output.
// Dependencies: Audio library (potentially with S/PDIF support).
// Input: None (generates internally).
// Output: S/PDIF audio stream.
#include <Audio.h>

Audio audio;

void setup() {
  // Initialize S/PDIF output pins and format
  // audio.setSPDIFPin(SPDIF_OUT_PIN);
}

void loop() {
  // Generate audio sample
  float sample = generateSample();
  // Format sample for S/PDIF and send
  // audio.writeSPDIF(formattedSample);
}

float generateSample() {
  // Audio generation logic
  return 0.0;
}

```

```Arduino
// Example: streams-generator-timedstream-serial
// Generates an audio stream at a specific rate and sends it over serial.
// Dependencies: Arduino core libraries.
// Input: None (generates internally).
// Output: Timed audio data stream via Serial.
void setup() {
  Serial.begin(115200);
  // Set timer for specific sample rate
}

void loop() {
  // Generate audio sample
  float sample = generateSample();
  // Send sample over serial
  // Serial.println(sample);
  // Ensure timing is maintained
}

float generateSample() {
  // Audio generation logic
  return 0.0;
}

```

```Arduino
// Example: streams-generator-volume
// Generates an audio stream and adjusts its volume before output.
// Dependencies: Arduino core libraries.
// Input: None (generates internally).
// Output: Audio stream with adjusted volume.
float volume = 0.5; // Volume level between 0.0 and 1.0

void setup() {
  // Initialize output (e.g., Serial, PWM, I2S)
}

void loop() {
  // Generate audio sample
  float sample = generateSample();
  // Adjust volume
  float adjustedSample = sample * volume;
  // Output adjusted sample
  // outputSample(adjustedSample);
}

float generateSample() {
  // Audio generation logic
  return 0.0;
}

```

```Arduino
// Example: streams-generator-wm8960
// Generates an audio stream intended for playback through a WM8960 audio codec.
// Dependencies: Audio library, WM8960 driver (if specific).
// Input: None (generates internally).
// Output: Audio stream compatible with WM8960 (likely I2S).
#include <Audio.h>

Audio audio;

void setup() {
  // Initialize I2S for WM8960
  audio.setPinout(WM8960_I2S_BCLK, WM8960_I2S_LRC, WM8960_I2S_DOUT);
}

void loop() {
  // Generate audio sample
  float sample = generateSample();
  // Write sample to I2S for WM8960
  audio.writeStream(sample);
}

float generateSample() {
  // Audio generation logic
  return 0.0;
}

```

```Arduino
// Example: streams-i2s-filter-i2s
// Applies a digital filter to an I2S audio stream and outputs the result via I2S.
// Dependencies: Audio library, I2S driver, filter implementation.
// Input: I2S audio stream.
// Output: Filtered I2S audio stream.
#include <Audio.h>

Audio audio;

void setup() {
  audio.setPinout(I2S_BCLK, I2S_LRC, I2S_DOUT);
  // Initialize filter coefficients
}

void loop() {
  // Read sample from I2S input
  float inputSample = audio.readStream();
  // Apply filter
  float filteredSample = applyFilter(inputSample);
  // Write filtered sample to I2S output
  audio.writeStream(filteredSample);
}

float applyFilter(float sample) {
  // Digital filter implementation (e.g., FIR, IIR)
  return sample;
}

```

```Arduino
// Example: streams-i2s-i2s
// Reads an audio stream from I2S input and writes it directly to I2S output.
// Dependencies: Audio library, I2S driver.
// Input: I2S audio stream.
// Output: I2S audio stream.
#include <Audio.h>

Audio audio;

void setup() {
  audio.setPinout(I2S_BCLK, I2S_LRC, I2S_DOUT);
}

void loop() {
  // Read sample from I2S input
  float sample = audio.readStream();
  // Write sample to I2S output
  audio.writeStream(sample);
}

```

```Arduino
// Example: streams-i2s-i2s-2
// Reads an audio stream from a second I2S input and writes it to I2S output.
// Dependencies: Audio library, I2S driver.
// Input: Second I2S audio stream.
// Output: I2S audio stream.
#include <Audio.h>

Audio audio;

void setup() {
  // Configure two I2S interfaces if supported, or use different pins
  audio.setPinout(I2S_BCLK, I2S_LRC, I2S_DOUT);
  // audio.setSecondI2SPinout(...);
}

void loop() {
  // Read sample from the second I2S input
  float sample = audio.readSecondStream(); // Hypothetical function
  // Write sample to I2S output
  audio.writeStream(sample);
}

```

```Arduino
// Example: streams-i2s_pdm-serial
// Reads an audio stream from PDM (Pulse Density Modulation) input and sends it over serial.
// Dependencies: Audio library, PDM library.
// Input: PDM audio stream.
// Output: Audio data stream via Serial.
#include <Audio.h>

Audio audio;

void setup() {
  Serial.begin(115200);
  // Initialize PDM input
  // audio.setInput(PDM);
}

void loop() {
  // Read PDM sample
  int pdmSample = audio.readPDM(); // Hypothetical function
  // Convert PDM sample to a suitable format and send over serial
  Serial.println(pdmSample);
}

```

```Arduino
// Example: streams-i2s-serial
// Reads an audio stream from I2S input and sends it over the serial port.
// Dependencies: Audio library, I2S driver.
// Input: I2S audio stream.
// Output: Audio data stream via Serial.
#include <Audio.h>

Audio audio;

void setup() {
  Serial.begin(115200);
  audio.setPinout(I2S_BCLK, I2S_LRC, I2S_DOUT);
}

void loop() {
  // Read sample from I2S input
  float sample = audio.readStream();
  // Send sample over serial
  Serial.println(sample);
}

```

```Arduino

```

--------------------------------

### Pipe Audio Output via Command Line

Source: https://github.com/pschatzmann/arduino-audio-tools/wiki/Running-an-Audio-Sketch-on-the-Desktop

Example of piping audio output from the generator executable to the system audio player (aplay).

```bash
./generator | aplay -f cd
```

--------------------------------

### Initialize AudioEffectStream with Sine Wave Generator

Source: https://github.com/pschatzmann/arduino-audio-tools/wiki/Audio-Effects

Demonstrates the basic setup of an AudioEffectStream by connecting a generated sine wave stream to an I2S output stream via a copier.

```C++
#include "AudioTools.h"

SineWaveGenerator<int16_t> sine;
GeneratedSoundStream<int16_t> sine_stream(sine); 
AudioEffectStream effects(sine_stream);
I2SStream out;
StreamCopy copier(out, effects);
```