### Full Usage Example

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioFileSourceHTTPStream.md

Demonstrates a complete setup for streaming MP3 audio over WiFi using AudioFileSourceHTTPStream, AudioGeneratorMP3, and AudioOutputI2SNoDAC.

```cpp
#include <Arduino.h>
#include <WiFi.h>
#include <AudioGeneratorMP3.h>
#include <AudioFileSourceHTTPStream.h>
#include <AudioOutputI2SNoDAC.h>

const char *ssid = "YourSSID";
const char *password = "YourPassword";
const char *stream_url = "http://radio.example.com/stream.mp3";

AudioGeneratorMP3 *mp3 = nullptr;
AudioFileSourceHTTPStream *stream = nullptr;
AudioOutputI2SNoDAC *out = nullptr;

void setup() {
    Serial.begin(115200);
    
    WiFi.mode(WIFI_STA);
    WiFi.begin(ssid, password);
    
    while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
    }
    Serial.println("\nWiFi connected");
    
    stream = new AudioFileSourceHTTPStream(stream_url);
    out = new AudioOutputI2SNoDAC();
    mp3 = new AudioGeneratorMP3();
    
    stream->SetReconnect(5, 500);
    mp3->begin(stream, out);
}

void loop() {
    if (mp3->isRunning()) {
        if (!mp3->loop()) {
            mp3->stop();
            stream->close();
            Serial.println("Stream finished");
        }
    } else {
        delay(100);
    }
    
    // Keep stream buffer filled
    stream->loop();
}
```

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

### Basic MP3 Playback Setup and Loop

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioFileSource.md

Demonstrates the basic setup for playing an MP3 file from SPIFFS using AudioFileSourceSPIFFS, AudioGeneratorMP3, and AudioOutputI2SNoDAC. It includes opening the file, starting the output and generator, and handling the playback loop.

```cpp
#include <AudioFileSourceSPIFFS.h>
#include <AudioGeneratorMP3.h>
#include <AudioOutputI2SNoDAC.h>

AudioFileSourceSPIFFS *file = new AudioFileSourceSPIFFS();
AudioGeneratorMP3 *mp3 = new AudioGeneratorMP3();
AudioOutputI2SNoDAC *out = new AudioOutputI2SNoDAC();

void setup() {
    SPIFFS.begin();
    
    if (file->open("/audio.mp3")) {
        out->begin();
        mp3->begin(file, out);
    }
}

void loop() {
    if (mp3->isRunning()) {
        if (!mp3->loop()) {
            file->close();
        }
    }
}
```

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

### Basic MP3 Playback Setup and Loop

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioGeneratorMP3.md

This example demonstrates the typical usage pattern for playing an MP3 file from SPIFFS using AudioGeneratorMP3. It includes necessary includes, object instantiation, and the main loop for continuous playback.

```cpp
#include <Arduino.h>
#include <SPIFFS.h>
#include <AudioGeneratorMP3.h>
#include <AudioFileSourceSPIFFS.h>
#include <AudioFileSourceID3.h>
#include <AudioOutputI2SNoDAC.h>

AudioGeneratorMP3 *mp3 = nullptr;
AudioFileSourceSPIFFS *file = nullptr;
AudioFileSourceID3 *id3 = nullptr;
AudioOutputI2SNoDAC *out = nullptr;

void setup() {
    Serial.begin(115200);
    SPIFFS.begin();
    
    file = new AudioFileSourceSPIFFS("/song.mp3");
    id3 = new AudioFileSourceID3(file);
    out = new AudioOutputI2SNoDAC();
    mp3 = new AudioGeneratorMP3();
    
    mp3->begin(id3, out);
}

void loop() {
    if (mp3->isRunning()) {
        if (!mp3->loop()) {
            mp3->stop();
            Serial.println("Playback complete");
        }
    } else {
        delay(1000);
    }
}
```

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

### Minimal MP3 Player Example

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/README.md

This snippet demonstrates how to set up and play an MP3 file from SPIFFS using the library. It includes basic setup for the audio generator, file source, and output.

```cpp
#include <AudioFileSourceSPIFFS.h>
#include <AudioGeneratorMP3.h>
#include <AudioOutputI2SNoDAC.h>

void setup() {
    SPIFFS.begin();
    AudioGeneratorMP3 *mp3 = new AudioGeneratorMP3();
    AudioFileSourceSPIFFS *file = new AudioFileSourceSPIFFS("/song.mp3");
    AudioOutputI2SNoDAC *out = new AudioOutputI2SNoDAC();
    mp3->begin(file, out);
}

void loop() {
    if (mp3->isRunning()) {
        if (!mp3->loop()) mp3->stop();
    }
}
```

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

### Basic WAV Playback Setup and Loop

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioGeneratorWAV.md

This snippet demonstrates the basic setup and loop for playing a WAV file from SPIFFS using AudioGeneratorWAV. It initializes the necessary components, sets a custom buffer size, and handles the playback loop, stopping when the audio is finished.

```cpp
#include <Arduino.h>
#include <SPIFFS.h>
#include <AudioGeneratorWAV.h>
#include <AudioFileSourceSPIFFS.h>
#include <AudioOutputI2SNoDAC.h>

AudioGeneratorWAV *wav = nullptr;
AudioFileSourceSPIFFS *file = nullptr;
AudioOutputI2SNoDAC *out = nullptr;

void setup() {
    Serial.begin(115200);
    SPIFFS.begin();
    
    file = new AudioFileSourceSPIFFS("/sound.wav");
    out = new AudioOutputI2SNoDAC();
    wav = new AudioGeneratorWAV();
    
    wav->SetBufferSize(4096);
    wav->begin(file, out);
}

void loop() {
    if (wav->isRunning()) {
        if (!wav->loop()) {
            wav->stop();
            Serial.println("Done");
        }
    } else {
        delay(100);
    }
}
```

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

### Arduino IDE Library Installation

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/README.md

Instructions for installing the ESP8266Audio library via the Arduino IDE Library Manager or manually by cloning the repository.

```bash
# Arduino IDE: Sketch → Include Library → Manage Libraries → "ESP8266Audio"
# Or manually:
cd ~/Arduino/libraries
git clone https://github.com/earlephilhower/ESP8266Audio.git
```

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

### Install ESP8266Audio Library

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/OVERVIEW.md

Clone the library repository into your Arduino libraries directory to install it.

```bash
cd ~/Arduino/libraries
git clone https://github.com/earlephilhower/ESP8266Audio.git
```

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

### Platform.io Library Installation

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/README.md

Instructions for adding the ESP8266Audio library to a Platform.io project by modifying the `platformio.ini` file.

```ini
# Add to platformio.ini:
lib_deps = earlephilhower/ESP8266Audio
```

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

### Internet Radio Streamer Example

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/README.md

This example shows how to stream internet radio using the library. It requires WiFi connectivity and configures an HTTP stream source, MP3 generator, and I2S output.

```cpp
#include <WiFi.h>
#include <AudioFileSourceHTTPStream.h>
#include <AudioGeneratorMP3.h>
#include <AudioOutputI2SNoDAC.h>

WiFi.begin("SSID", "password");
AudioGeneratorMP3 *mp3 = new AudioGeneratorMP3();
AudioFileSourceHTTPStream *stream = new AudioFileSourceHTTPStream(
    "http://radio.example.com/stream.mp3"
);
AudioOutputI2SNoDAC *out = new AudioOutputI2SNoDAC();

void setup() {
    stream->SetReconnect(5, 500);
    mp3->begin(stream, out);
}

void loop() {
    if (mp3->isRunning()) {
        if (!mp3->loop()) mp3->stop();
    }
    stream->loop();
}
```

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

### Initialize and Play MP3 from SPIFFS

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioFileSourceFS.md

This example demonstrates how to set up and play an MP3 file stored on the SPIFFS filesystem. It includes necessary includes, object instantiation, and the main playback loop.

```cpp
#include <Arduino.h>
#include <SPIFFS.h>
#include <AudioFileSourceFS.h>
#include <AudioGeneratorMP3.h>
#include <AudioOutputI2SNoDAC.h>

AudioFileSourceFS *file = nullptr;
AudioGeneratorMP3 *mp3 = nullptr;
AudioOutputI2SNoDAC *out = nullptr;

void setup() {
    Serial.begin(115200);
    SPIFFS.begin();
    
    // Create file source from SPIFFS
    file = new AudioFileSourceFS(SPIFFS, "/music.mp3");
    
    out = new AudioOutputI2SNoDAC();
    mp3 = new AudioGeneratorMP3();
    
    if (mp3->begin(file, out)) {
        Serial.println("Ready to play");
    }
}

void loop() {
    if (mp3->isRunning()) {
        if (!mp3->loop()) {
            mp3->stop();
            file->close();
        }
    } else {
        delay(100);
    }
}
```

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

### Audio Mixer Example

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/README.md

This snippet demonstrates how to mix two audio sources using `AudioOutputMixer`. It sets up two input stubs and begins playback for both sources.

```cpp
AudioOutputMixer *mixer = new AudioOutputMixer(512, i2sout);
mixer->begin();

stub1 = mixer->NewInput();
stub2 = mixer->NewInput();

mp3_1->begin(file1, stub1);
mp3_2->begin(file2, stub2);

void loop() {
    mp3_1->loop();
    mp3_2->loop();
    mixer->loop();
}
```

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

### Basic Audio Playback Usage Pattern

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioGenerator.md

Demonstrates the typical setup and loop for playing an MP3 file using AudioGeneratorMP3, AudioFileSourceSPIFFS, and AudioOutputI2SNoDAC. Ensure necessary libraries are included and initialized.

```cpp
#include <AudioGeneratorMP3.h>
#include <AudioFileSourceSPIFFS.h>
#include <AudioOutputI2SNoDAC.h>

AudioGeneratorMP3 *mp3 = nullptr;
AudioFileSourceSPIFFS *file = nullptr;
AudioOutputI2SNoDAC *out = nullptr;

void setup() {
    Serial.begin(115200);
    SPIFFS.begin();
    
    file = new AudioFileSourceSPIFFS("/music.mp3");
    out = new AudioOutputI2SNoDAC();
    mp3 = new AudioGeneratorMP3();
    
    mp3->begin(file, out);
}

void loop() {
    if (mp3->isRunning()) {
        if (!mp3->loop()) {
            mp3->stop();
        }
    } else {
        delay(1000);
    }
}
```

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

### AudioOutputMixer Constructor Example

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioOutputMixer.md

Instantiates an AudioOutputMixer with a specified buffer size and an underlying audio output sink. Larger buffers reduce glitches but increase latency.

```cpp
AudioOutputI2SNoDAC *out = new AudioOutputI2SNoDAC();
AudioOutputMixer *mixer = new AudioOutputMixer(512, out);
```

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

### MP3 Playback with AudioOutputI2SNoDAC

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioOutput.md

Example demonstrating how to play an MP3 file from SPIFFS using AudioOutputI2SNoDAC. Ensure SPIFFS is initialized and audio file exists.

```cpp
#include <AudioOutputI2SNoDAC.h>
#include <AudioGeneratorMP3.h>
#include <AudioFileSourceSPIFFS.h>

AudioOutputI2SNoDAC *out = new AudioOutputI2SNoDAC();
AudioGeneratorMP3 *mp3 = new AudioGeneratorMP3();
AudioFileSourceSPIFFS *file = new AudioFileSourceSPIFFS("/audio.mp3");

void setup() {
    SPIFFS.begin();
    
    out->SetRate(44100);
    out->SetChannels(2);
    out->SetGain(0.9);
    out->begin();
    
    mp3->begin(file, out);
}

void loop() {
    if (mp3->isRunning()) {
        if (!mp3->loop()) {
            mp3->stop();
            out->stop();
        }
    } else {
        delay(100);
    }
    out->loop();
}
```

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

### begin

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioGenerator.md

Initializes the audio generator with a source file and an output sink. This method must be called before `loop()` and after both source and output objects are created. Each subclass performs format-specific parsing and setup.

```APIDOC
## begin(AudioFileSource *source, AudioOutput *output)

### Description
Initializes the generator with a source file and output sink. This must be called before `loop()` and after both source and output objects are created. Each subclass performs format-specific parsing and setup.

### Method
```cpp
virtual bool begin(AudioFileSource *source, AudioOutput *output)
```

### Parameters
#### Path Parameters
- **source** (AudioFileSource*) - Required - Pointer to an audio file source to decode
- **output** (AudioOutput*) - Required - Pointer to an audio output sink

### Returns
`bool` - `true` if initialization succeeds, `false` on error

### Example
```cpp
AudioFileSourceSPIFFS *file = new AudioFileSourceSPIFFS("/song.mp3");
AudioOutputI2SNoDAC *out = new AudioOutputI2SNoDAC();
AudioGeneratorMP3 *mp3 = new AudioGeneratorMP3();

if (mp3->begin(file, out)) {
    Serial.println("MP3 ready to play");
}
```
```

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

### Registering a Metadata Callback

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/types.md

Example of how to register a custom metadata callback function. This function will be invoked when metadata is found in the audio stream.

```cpp
void handleMetadata(void *cbData, const char *type, bool isUnicode, const char *str) {
    if (!strcmp(type, "TIT2")) {
        Serial.printf("Title: %s\n", str);
    }
}

mp3->RegisterMetadataCB(handleMetadata, NULL);
```

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

### Begin Method Failure Recovery

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/errors.md

This snippet shows how to handle a failure when starting an audio playback, specifically when the file format is invalid. It checks the return value of the begin() method and prints an error message if it fails.

```cpp
if (!mp3->begin(file, out)) {
    Serial.println("File is not a valid MP3");
    // Try different decoder or different file
}
```

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

### Implement Graceful Degradation for Audio Playback

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/errors.md

This example shows how to fall back to a different audio format (MP3) if the primary format (FLAC) fails to begin playback. It ensures audio continues playing.

```cpp
if (flac->begin(file, out)) {
    Serial.println("Playing FLAC");
} else {
    // Fallback to MP3
    file->close();
    file->open("/song.mp3");  // Same song in MP3 format
    mp3->begin(file, out);
    Serial.println("Playing MP3 instead");
}
```

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

### Basic FLAC Playback from SPIFFS

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioGeneratorFLAC.md

This snippet shows the essential setup and playback loop for playing a FLAC file from SPIFFS. Ensure the FLAC file is present in the SPIFFS filesystem and the necessary libraries are included.

```cpp
#include <Arduino.h>
#include <SPIFFS.h>
#include <AudioGeneratorFLAC.h>
#include <AudioFileSourceSPIFFS.h>
#include <AudioOutputI2SNoDAC.h>

AudioGeneratorFLAC *flac = nullptr;
AudioFileSourceSPIFFS *file = nullptr;
AudioOutputI2SNoDAC *out = nullptr;

void setup() {
    Serial.begin(115200);
    SPIFFS.begin();
    
    file = new AudioFileSourceSPIFFS("/music.flac");
    out = new AudioOutputI2SNoDAC();
    flac = new AudioGeneratorFLAC();
    
    if (flac->begin(file, out)) {
        Serial.println("FLAC ready");
    }
}

void loop() {
    if (flac->isRunning()) {
        if (!flac->loop()) {
            flac->stop();
            Serial.println("Playback complete");
        }
    } else {
        delay(100);
    }
}
```

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

### Common Methods

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/INDEX.md

This section lists the most frequently used methods for controlling audio playback, including starting, stopping, reading, and configuring playback parameters.

```APIDOC
## Common Methods

This section lists the most frequently used methods for controlling audio playback, including starting, stopping, reading, and configuring playback parameters.

### Method Signatures

- `begin(source, output)`: Starts audio playback. Returns a boolean indicating success.
- `loop()`: Processes the next audio chunk. Returns a boolean indicating if playback is ongoing.
- `stop()`: Stops the current audio playback. Returns a boolean indicating success.
- `isRunning()`: Checks if the audio playback is currently active. Returns a boolean.
- `open(filename)`: Opens a specified audio file for playback. Returns a boolean indicating success.
- `read(buffer, len)`: Reads a specified number of bytes into a buffer. Returns the number of bytes read (uint32_t).
- `SetRate(hz)`: Sets the audio sample rate in Hz. Returns a boolean indicating success.
- `SetChannels(n)`: Sets the number of audio channels (1 for mono, 2 for stereo). Returns a boolean indicating success.
- `ConsumeSample(sample)`: Outputs a single audio sample. Returns a boolean indicating success.
```

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

### Basic Usage Pattern

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/OVERVIEW.md

This is the standard pattern for using the ESP8266Audio library. It involves creating an audio file source, a decoder, and an audio output, then configuring and starting playback.

```cpp
// 1. Create source
AudioFileSourceFS *file = new AudioFileSourceFS(SPIFFS, "/song.mp3");

// 2. Create decoder
AudioGeneratorMP3 *mp3 = new AudioGeneratorMP3();

// 3. Create output
AudioOutputI2SNoDAC *out = new AudioOutputI2SNoDAC();

// 4. Configure output
out->SetRate(44100);
out->SetChannels(2);
out->begin();

// 5. Start playback
mp3->begin(file, out);

// 6. Main loop: call loop() frequently
void loop() {
    if (mp3->isRunning()) {
        if (!mp3->loop()) {
            mp3->stop();
        }
    }
}
```

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

### Initialize AudioOutputI2S

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioOutputI2S.md

Initializes I2S DMA, configures hardware registers, and starts the I2S clock. Must be called after setting rate, channels, buffers, and pinout.

```cpp
out->SetRate(44100);
out->SetChannels(2);
out->SetBuffers(5, 4608);
out->SetPinout(14, 15, 32, 13);
out->begin();
```

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

### Mixing Two MP3 Files with AudioOutputMixer

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioOutputMixer.md

This example demonstrates how to set up and use AudioOutputMixer to play and mix two MP3 files simultaneously. It requires SPIFFS for file storage and AudioOutputI2SNoDAC for output. Ensure the MP3 files are present in the SPIFFS filesystem.

```cpp
#include <Arduino.h>
#include <SPIFFS.h>
#include <AudioGeneratorMP3.h>
#include <AudioFileSourceSPIFFS.h>
#include <AudioOutputMixer.h>
#include <AudioOutputI2SNoDAC.h>

AudioOutputI2SNoDAC *i2sout = nullptr;
AudioOutputMixer *mixer = nullptr;

AudioGeneratorMP3 *mp3_1 = nullptr;
AudioGeneratorMP3 *mp3_2 = nullptr;

AudioFileSourceSPIFFS *file1 = nullptr;
AudioFileSourceSPIFFS *file2 = nullptr;

AudioOutputMixerStub *stub1 = nullptr;
AudioOutputMixerStub *stub2 = nullptr;

void setup() {
    Serial.begin(115200);
    SPIFFS.begin();
    
    // Create mixer
    i2sout = new AudioOutputI2SNoDAC();
    mixer = new AudioOutputMixer(512, i2sout);
    mixer->SetRate(44100);
    mixer->SetChannels(2);
    mixer->begin();
    
    // Create first generator
    file1 = new AudioFileSourceSPIFFS("/music1.mp3");
    mp3_1 = new AudioGeneratorMP3();
    stub1 = mixer->NewInput();
    mp3_1->begin(file1, stub1);
    
    // Create second generator
    file2 = new AudioFileSourceSPIFFS("/music2.mp3");
    mp3_2 = new AudioGeneratorMP3();
    stub2 = mixer->NewInput();
    mp3_2->begin(file2, stub2);
    
    Serial.println("Mixer ready with 2 inputs");
}

void loop() {
    // Feed generators
    if (mp3_1->isRunning()) {
        if (!mp3_1->loop()) {
            mp3_1->stop();
        }
    }
    
    if (mp3_2->isRunning()) {
        if (!mp3_2->loop()) {
            mp3_2->stop();
        }
    }
    
    // Mix and output
    mixer->loop();
    
    // Check if both finished
    if (!mp3_1->isRunning() && !mp3_2->isRunning()) {
        mixer->stop();
        Serial.println("All done");
        delay(1000);
    }
}

```

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

### Insufficient Memory Recovery

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/errors.md

This example shows how to recover from insufficient memory errors when allocating audio decoder buffers. It demonstrates using pre-allocated memory for the decoder.

```cpp
// Use pre-allocated memory instead
char buffer[AudioGeneratorMP3::preAllocSize()];
AudioGeneratorMP3 *mp3 = new AudioGeneratorMP3(buffer, sizeof(buffer));
```

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

### Minimal MP3 Playback Example

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/OVERVIEW.md

A basic Arduino sketch to play an MP3 file from SPIFFS using the ESP8266Audio library. Ensure you have a 'song.mp3' file uploaded to SPIFFS.

```cpp
#include <AudioFileSourceSPIFFS.h>
#include <AudioGeneratorMP3.h>
#include <AudioOutputI2SNoDAC.h>

AudioGeneratorMP3 *mp3;
AudioFileSourceSPIFFS *file;
AudioOutputI2SNoDAC *out;

void setup() {
    SPIFFS.begin();
    file = new AudioFileSourceSPIFFS("/song.mp3");
    out = new AudioOutputI2SNoDAC();
    mp3 = new AudioGeneratorMP3();
    mp3->begin(file, out);
}

void loop() {
    if (mp3->isRunning()) {
        if (!mp3->loop()) mp3->stop();
    }
}
```

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

### Install ESP8266Audio Library using Git

Source: https://github.com/earlephilhower/esp8266audio/blob/master/README.md

Clone the ESP8266Audio library into your Arduino libraries directory using Git. Ensure you are using a recent version of the ESP8266 or ESP32 Arduino core.

```shell
mkdir -p ~/Arduino/libraries
cd ~/Arduino/libraries
git clone https://github.com/earlephilhower/ESP8266Audio
```

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

### Create and Configure New Mixer Inputs

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioOutputMixer.md

Creates new input stubs for generators, allowing them to send audio to the mixer. Each generator requires its own stub. This example shows setting up two MP3 players with their respective stubs.

```cpp
AudioOutputMixerStub *stub1 = mixer->NewInput();
AudioOutputMixerStub *stub2 = mixer->NewInput();

if (!stub1 || !stub2) {
    Serial.println("Failed to allocate mixer inputs");
}

mp3_1->begin(file1, stub1);
mp3_2->begin(file2, stub2);
```

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

### begin

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioOutput.md

Initializes the output hardware or resources. Must be called after `SetRate()` and `SetChannels()`, and before consuming samples.

```APIDOC
## begin()

### Description
Initializes the output hardware or resources. Must be called after `SetRate()` and `SetChannels()`, before consuming samples. For I2S outputs, configures DMA and I2S periph. For buffered outputs, allocates RAM.

### Method
virtual bool begin()

### Parameters

No parameters.

### Returns
`bool` — `true` if initialization succeeds

### Example
```cpp
out->SetRate(44100);
out->SetChannels(2);
out->begin();
```
```

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

### begin

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioOutputI2S.md

Initializes the I2S hardware for audio output. This method must be called after setting the audio rate, channels, buffers, and pinout.

```APIDOC
## begin

### Description
Initializes I2S DMA, configures hardware registers, and starts the I2S clock. Must be called after `SetRate()`, `SetChannels()`, `SetBuffers()`, and `SetPinout()`.

### Method
```cpp
virtual bool begin() override
```

### Parameters
No parameters.

### Returns
`bool` — `true` if I2S hardware initialized successfully.
```

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

### Get Current Position

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioFileSourceHTTPStream.md

Returns the number of bytes that have been read from the stream so far.

```cpp
virtual uint32_t getPos() override
```

```cpp
uint32_t pos = stream->getPos();
Serial.printf("Read %d bytes\n", pos);
```

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

### Get mad_synth Structure Size

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioGeneratorMP3.md

Returns the size of the mad_synth structure, aligned to an 8-byte boundary.

```cpp
static constexpr int preAllocSynthSize()
```

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

### Create and Open AudioFileSourceFS with Filename

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioFileSourceFS.md

Instantiate AudioFileSourceFS and immediately open a specified file from the filesystem. Check isOpen() to confirm success.

```cpp
AudioFileSourceFS *file = new AudioFileSourceFS(SPIFFS, "/audio.mp3");
if (file->isOpen()) {
    Serial.println("File opened");
}
```

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

### Get mad_frame Structure Size

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioGeneratorMP3.md

Returns the size of the mad_frame structure, aligned to an 8-byte boundary.

```cpp
static constexpr int preAllocFrameSize()
```

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

### begin

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioGeneratorFLAC.md

Initializes the FLAC decoder and prepares it to play an audio file. It parses the FLAC header and extracts essential audio information.

```APIDOC
## begin(AudioFileSource *source, AudioOutput *output)

### Description
Initializes libflac decoder and reads STREAMINFO metadata block. Extracts sample rate, bit depth, and channel count. Sets these on the output automatically.

### Method
`bool begin(AudioFileSource *source, AudioOutput *output)`

### Parameters
#### Path Parameters
- **source** (AudioFileSource*) - Required - The source of the FLAC audio file.
- **output** (AudioOutput*) - Required - The audio output sink.

### Returns
`bool` - `true` if FLAC header parsing succeeds, `false` otherwise.

### Throws/Rejects
Returns `false` if the file is not a valid FLAC or if metadata reading fails.

### Example
```cpp
AudioFileSourceSPIFFS *file = new AudioFileSourceSPIFFS("/song.flac");
AudioOutputI2SNoDAC *out = new AudioOutputI2SNoDAC();
AudioGeneratorFLAC *flac = new AudioGeneratorFLAC();

if (flac->begin(file, out)) {
    Serial.println("FLAC ready");
} else {
    Serial.println("Invalid FLAC file");
}
```
```

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

### begin

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioGeneratorWAV.md

Initializes the WAV decoder with a file source and audio output. Parses the WAV header to extract audio format information.

```APIDOC
## begin(AudioFileSource *source, AudioOutput *output)

### Description
Parses WAV file header (RIFF, fmt, data chunks) and initializes decoder. Extracts sample rate, bit depth, and channel count from format chunk. Sets these on the output automatically.

### Method
`bool begin(AudioFileSource *source, AudioOutput *output)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **source** (AudioFileSource*) - Required - WAV file source
- **output** (AudioOutput*) - Required - Audio output sink

### Returns
- **bool** - `true` if WAV header is valid and readable, `false` otherwise.

### Example
```cpp
AudioFileSourceSPIFFS *file = new AudioFileSourceSPIFFS("/sound.wav");
AudioOutputI2SNoDAC *out = new AudioOutputI2SNoDAC();
AudioGeneratorWAV *wav = new AudioGeneratorWAV();

if (wav->begin(file, out)) {
    Serial.println("WAV ready");
} else {
    Serial.println("Invalid WAV file");
}
```
```

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

### Get mad_stream Structure Size

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioGeneratorMP3.md

Returns the size of the mad_stream structure, aligned to an 8-byte boundary.

```cpp
static constexpr int preAllocStreamSize()
```

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

### getPos

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioFileSourceHTTPStream.md

Gets the current position in bytes that has been read from the audio stream. This is useful for tracking download progress or resuming streams.

```APIDOC
## getPos

### Description
Gets the current position in bytes that has been read from the audio stream. This is useful for tracking download progress or resuming streams.

### Method
GET (Implicit)

### Returns
`uint32_t` - Current byte position.

### Example
```cpp
uint32_t pos = stream->getPos();
Serial.printf("Read %d bytes\n", pos);
```
```

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

### Get Input Buffer Size

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioGeneratorMP3.md

Returns the size of the input buffer, which is aligned to an 8-byte boundary. This value is typically 0x600 bytes.

```cpp
static constexpr int preAllocBuffSize()
```

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

### Get Audio File Size

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioFileSourceFS.md

Retrieves the total size of the audio file in bytes. This is useful for progress tracking and other file operations.

```cpp
uint32_t size = file->getSize();
Serial.printf("File size: %d bytes\n", size);
```

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

### Create AudioFileSourceFS with Filesystem

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioFileSourceFS.md

Instantiate AudioFileSourceFS with a filesystem object. You must call open() separately to specify the file.

```cpp
#include <SPIFFS.h>
#include <AudioFileSourceFS.h>

AudioFileSourceFS *file = new AudioFileSourceFS(SPIFFS);
file->open("/song.mp3");
```

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

### Begin WAV Playback

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioGeneratorWAV.md

Initializes the WAV decoder by parsing the WAV header from the provided source and setting up the audio output. Returns true if the WAV header is valid and readable.

```cpp
AudioFileSourceSPIFFS *file = new AudioFileSourceSPIFFS("/sound.wav");
AudioOutputI2SNoDAC *out = new AudioOutputI2SNoDAC();
AudioGeneratorWAV *wav = new AudioGeneratorWAV();

if (wav->begin(file, out)) {
    Serial.println("WAV ready");
} else {
    Serial.println("Invalid WAV file");
}
```

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

### isRunning

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioGeneratorMP3.md

Checks if the MP3 decoder is currently active. This method is useful for determining if playback has started and is ongoing between `begin()` and `stop()` calls.

```APIDOC
## isRunning

### Description
Checks whether the decoder is active between `begin()` and `stop()` calls.

### Method
`virtual bool isRunning() override`

### Parameters
No parameters.

### Returns
`bool` — `true` if currently decoding
```

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

### Basic TinySoundFont Integration and Playback

Source: https://github.com/earlephilhower/esp8266audio/blob/master/src/libtinysoundfont/README.md

Demonstrates how to load a SoundFont file, set output parameters, trigger a note, and render audio. Ensure TSF_IMPLEMENTATION is defined before including tsf.h for the library to be included.

```c++
#define TSF_IMPLEMENTATION
#include "tsf.h"

...

tsf* TinySoundFont = tsf_load_filename("soundfont.sf2");
tsf_set_output(TinySoundFont, TSF_MONO, 44100, 0); //sample rate
tsf_note_on(TinySoundFont, 0, 60, 1.0f); //preset 0, middle C
short HalfSecond[22050]; //synthesize 0.5 seconds
tsf_render_short(TinySoundFont, HalfSecond, 22050, 0);
```

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

### Registering a Status Callback

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/types.md

Example of how to register a custom status callback function. This function will be invoked with status codes and messages during stream processing.

```cpp
void handleStatus(void *cbData, int code, const char *string) {
    Serial.printf("Status %d: %s\n", code, string);
}

stream->RegisterStatusCB(handleStatus, NULL);
```

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

### Get Stream Size

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioFileSourceHTTPStream.md

Retrieves the total size of the audio stream in bytes. Returns 0 if the size is unknown, which is common for live streams.

```cpp
virtual uint32_t getSize() override
```

```cpp
uint32_t size = stream->getSize();
if (size > 0) {
    Serial.printf("Stream size: %d bytes\n", size);
} else {
    Serial.println("Size unknown (possibly live stream)");
}
```

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

### isRunning

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioGenerator.md

Checks whether the generator is currently active. Returns `true` between `begin()` and `stop()` calls, and `false` if playback has finished or never started.

```APIDOC
## isRunning()

### Description
Checks whether the generator is currently active. Returns `true` between `begin()` and `stop()` calls, and `false` if playback has finished or never started.

### Method
```cpp
virtual bool isRunning()
```

### Parameters
No parameters.

### Returns
`bool` - `true` if currently decoding and playing, `false` otherwise

### Example
```cpp
if (mp3->isRunning()) {
    Serial.println("Playing");
} else {
    Serial.println("Idle");
}
```
```

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

### Configure AudioFileSourceBuffer Allocation

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/configuration.md

Create a double-buffered wrapper for any audio source. Choose buffer size based on device memory and bandwidth needs.

```cpp
AudioFileSourceSPIFFS *file = new AudioFileSourceSPIFFS("/audio.mp3");
AudioFileSourceBuffer *buffered = new AudioFileSourceBuffer(file, 16384);
mp3->begin(buffered, out);
```

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

### URL Constructor

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioFileSourceHTTPStream.md

Creates and immediately opens an HTTP connection to the URL.

```APIDOC
## URL Constructor

```cpp
AudioFileSourceHTTPStream(const char *url)
```

### Description
Creates and immediately opens an HTTP connection to the URL.

### Parameters
#### Path Parameters
- **url** (const char*) - Required - HTTP or HTTPS URL to audio file

### Example
```cpp
AudioFileSourceHTTPStream *stream = new AudioFileSourceHTTPStream("http://radio.example.com/stream.mp3");
if (stream->isOpen()) {
    Serial.println("Connected");
}
```
```

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

### Basic Audio Playback Usage Pattern

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioOutputI2S.md

Demonstrates a typical usage pattern for playing an MP3 file from SPIFFS using AudioOutputI2S and AudioGeneratorMP3. Ensure SPIFFS is initialized and the audio file exists.

```cpp
#include <Arduino.h>
#include <AudioOutputI2S.h>
#include <AudioGeneratorMP3.h>
#include <AudioFileSourceSPIFFS.h>

AudioOutputI2S *out = nullptr;
AudioGeneratorMP3 *mp3 = nullptr;
AudioFileSourceSPIFFS *file = nullptr;

void setup() {
    Serial.begin(115200);
    SPIFFS.begin();
    
    out = new AudioOutputI2S();
    out->SetBuffers(8, 512);
    out->SetPinout(14, 15, 32, 13);
    out->SetRate(44100);
    out->SetChannels(2);
    out->begin();
    
    file = new AudioFileSourceSPIFFS("/music.mp3");
    mp3 = new AudioGeneratorMP3();
    mp3->begin(file, out);
}

void loop() {
    if (mp3->isRunning()) {
        if (!mp3->loop()) {
            mp3->stop();
        }
    }
}
```

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

### Create AudioGeneratorAAC with Default Constructor

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioGeneratorAAC.md

Instantiates an AudioGeneratorAAC object using internally allocated buffers. This is a simple way to start if custom memory management is not required.

```cpp
AudioGeneratorAAC *aac = new AudioGeneratorAAC();
```

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

### Get Pre-allocation Size for MP3 Buffers

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioGeneratorMP3.md

Retrieve the total memory required for the pre-allocated buffer constructor. This static method typically returns around 16KB on ESP8266.

```cpp
static constexpr int preAllocSize()
```

```cpp
int totalSize = AudioGeneratorMP3::preAllocSize();
Serial.printf("Need %d bytes for MP3 buffers\n", totalSize);
```

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

### Filesystem + Filename Constructor

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioFileSourceFS.md

Creates and immediately opens a file from the filesystem. This is a convenient constructor for opening a file upon instantiation.

```APIDOC
## Filesystem + Filename Constructor

### Description
Creates and immediately opens a file from the filesystem.

### Method
Constructor

### Parameters
#### Path Parameters
- **fs** (fs::FS&) - Required - Reference to filesystem object
- **filename** (const char*) - Required - Path to file to open

### Request Example
```cpp
AudioFileSourceFS *file = new AudioFileSourceFS(SPIFFS, "/audio.mp3");
if (file->isOpen()) {
    Serial.println("File opened");
}
```
```

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

### Get Current Read Position

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioFileSource.md

Returns the current read offset in the audio file in bytes. This is useful for implementing progress tracking and resume functionality in audio playback.

```cpp
uint32_t pos = file->getPos();
uint32_t size = file->getSize();
if (size > 0) {
    int percent = (100 * pos) / size;
    Serial.printf("Progress: %d%%\n", percent);
}
```

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

### Instantiate AudioGeneratorWAV

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioGeneratorWAV.md

Create a new WAV decoder instance. The internal buffer is allocated on the first begin() call.

```cpp
AudioGeneratorWAV *wav = new AudioGeneratorWAV();
```

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

### Create and Open HTTP Stream

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioFileSourceHTTPStream.md

Creates an AudioFileSourceHTTPStream instance and opens a connection to the specified URL. Use this when you have the URL at instantiation.

```cpp
AudioFileSourceHTTPStream *stream = new AudioFileSourceHTTPStream("http://radio.example.com/stream.mp3");
if (stream->isOpen()) {
    Serial.println("Connected");
}
```

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

### Get Audio File Position and Calculate Progress

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioFileSourceFS.md

Retrieves the current read position of the audio file and calculates the percentage of the file that has been processed. This is useful for displaying playback progress.

```cpp
uint32_t pos = file->getPos();
uint32_t total = file->getSize();
int percentComplete = (100 * pos) / total;
Serial.printf("Progress: %d%%\n", percentComplete);
```

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

### Initialize FLAC Playback

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioGeneratorFLAC.md

Begin FLAC playback by providing an AudioFileSource and an AudioOutput. This method parses the FLAC header, extracts metadata like sample rate and channel count, and sets them on the output. Returns false if the file is not a valid FLAC or if metadata reading fails.

```cpp
AudioFileSourceSPIFFS *file = new AudioFileSourceSPIFFS("/song.flac");
AudioOutputI2SNoDAC *out = new AudioOutputI2SNoDAC();
AudioGeneratorFLAC *flac = new AudioGeneratorFLAC();

if (flac->begin(file, out)) {
    Serial.println("FLAC ready");
} else {
    Serial.println("Invalid FLAC file");
}
```

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

### Seek Position in Audio File

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioFileSourceFS.md

Moves the file read position by a specified offset from a given direction (start, current, or end). Returns true if the seek operation is successful.

```cpp
file->seek(1000, 0);   // Seek to byte 1000 from start
file->seek(512, 1);    // Skip 512 bytes forward
file->seek(-256, 2);   // 256 bytes before end
```

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

### seek

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioFileSource.md

Seeks to a specific position within the file. The `dir` parameter determines the seek direction relative to the start, current position, or end of the file. Not all sources support seeking.

```APIDOC
## seek

```cpp
virtual bool seek(int32_t pos, int dir)
```

### Description
Seeks to a position in the file. Works like standard `fseek()`: `dir` of 0 seeks absolute from start, 1 from current position, 2 from end. Not all sources support seeking (HTTP streams may not).

### Parameters

#### Path Parameters

* **pos** (int32_t) - Required - Byte offset or relative position
* **dir** (int) - Required - Seek direction (0=start, 1=current, 2=end)

### Returns

* **bool** - `true` if seek succeeds, `false` if unsupported or out-of-bounds

### Example

```cpp
// Seek to byte 1000 from start
if (file->seek(1000, 0)) {
    Serial.println("Seeked successfully");
}

// Skip ahead 512 bytes from current position
file->seek(512, 1);
```
```

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

### AudioOutputMixer::begin

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioOutputMixer.md

Initializes the audio mixer and its underlying audio sink. This method also allocates the necessary internal buffers for accumulating audio samples.

```APIDOC
## begin

### Description
Initializes mixer and underlying sink. Allocates accumulation buffers.

### Method
(Implicitly called, typically after constructor)

### Endpoint
(N/A - Class method)

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- None

### Request Example
```cpp
mixer->SetRate(44100);
mixer->SetChannels(2);
mixer->begin();
```

### Response
#### Success Response
- **bool** - Returns true if initialization was successful, false otherwise.
```

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

### Initialize AudioGenerator with Source and Output

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioGenerator.md

Initializes the audio generator with a file source and an audio output. This must be called before the `loop()` method. Ensure both source and output objects are created prior to calling this method.

```cpp
AudioFileSourceSPIFFS *file = new AudioFileSourceSPIFFS("/song.mp3");
AudioOutputI2SNoDAC *out = new AudioOutputI2SNoDAC();
AudioGeneratorMP3 *mp3 = new AudioGeneratorMP3();

if (mp3->begin(file, out)) {
    Serial.println("MP3 ready to play");
}
```

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

### Filesystem Constructor

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioFileSourceFS.md

Creates a filesystem source without opening a file. The file must be opened later using the `open()` method.

```APIDOC
## Filesystem Constructor

### Description
Creates a filesystem source without opening a file. Call `open()` with filename.

### Method
Constructor

### Parameters
#### Path Parameters
- **fs** (fs::FS&) - Required - Reference to filesystem object

### Request Example
```cpp
#include <SPIFFS.h>
#include <AudioFileSourceFS.h>

AudioFileSourceFS *file = new AudioFileSourceFS(SPIFFS);
file->open("/song.mp3");
```
```

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

### Default Constructor

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioOutputI2S.md

Creates an I2S output instance with default settings. Requires subsequent calls to SetBuffers() and SetPinout() before begin().

```APIDOC
## AudioOutputI2S()

### Description
Creates I2S output with default settings. On ESP32, uses Port 0 in external I2S mode. On RP2040, uses standard I2S pins (BCLK=26, DOUT=28). Requires `SetBuffers()` and `SetPinout()` to be called before `begin()`.

### Example
```cpp
AudioOutputI2S *out = new AudioOutputI2S();
out->SetBuffers(8, 512);
out->SetPinout(14, 15, 32);
out->begin();
```
```

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

### Seek within Audio File

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioFileSource.md

Seeks to a specific position within the audio file. Not all sources support seeking. The 'dir' parameter specifies the seek origin (start, current, or end).

```cpp
// Seek to byte 1000 from start
if (file->seek(1000, 0)) {
    Serial.println("Seeked successfully");
}

// Skip ahead 512 bytes from current position
file->seek(512, 1);
```

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

### Open File with AudioFileSourceFS

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioFileSourceFS.md

Opens a file for reading from the associated filesystem. Returns true on success, false if the file is not found or inaccessible.

```cpp
if (file->open("/music/song.mp3")) {
    Serial.println("Opened");
} else {
    Serial.println("Not found");
}
```

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

### Default Constructor

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioFileSourceHTTPStream.md

Creates an HTTP stream source without connecting. Call `open()` with a URL to connect.

```APIDOC
## Default Constructor

```cpp
AudioFileSourceHTTPStream()
```

### Description
Creates an HTTP stream source without connecting. Call `open()` with a URL to connect.

### Example
```cpp
AudioFileSourceHTTPStream *stream = new AudioFileSourceHTTPStream();
stream->open("http://example.com/audio.mp3");
```
```

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

### Initialize Audio Output

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioOutput.md

Initializes the output hardware or resources. Must be called after SetRate() and SetChannels(), and before consuming samples.

```cpp
out->SetRate(44100);
out->SetChannels(2);
out->begin();
```

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

### Using AudioFileSourceICYStream for Metadata

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioFileSourceHTTPStream.md

Shows how to instantiate AudioFileSourceICYStream for streams that include SHOUTcast or ICY metadata like station name or song title.

```cpp
AudioFileSourceICYStream *stream = new AudioFileSourceICYStream("http://radio.example.com/stream");
```

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

### Project File Structure

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/README.md

This snippet outlines the directory structure of the ESP8266Audio project, indicating the location of the main README file and other documentation and API reference files.

```text
output/
├── README.md                          ← You are here
├── INDEX.md                           Navigation & class index
├── OVERVIEW.md                        Architecture & quick start
├── types.md                           Type definitions & enums
├── configuration.md                   All configuration options
├── errors.md                          Error codes & troubleshooting
└── api-reference/
    ├── AudioGenerator.md              Base decoder class
    ├── AudioFileSource.md             Base source class
    ├── AudioOutput.md                 Base output class
    ├── AudioGeneratorMP3.md           MP3 decoder
    ├── AudioGeneratorWAV.md           WAV decoder
    ├── AudioGeneratorFLAC.md          FLAC decoder
    ├── AudioGeneratorAAC.md           AAC decoder
    ├── AudioFileSourceFS.md           Filesystem source
    ├── AudioFileSourceHTTPStream.md   HTTP streaming source
    ├── AudioOutputI2S.md              I2S hardware output
    └── AudioOutputMixer.md            Audio mixer
```

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

### AudioGeneratorWAV Constructor

Source: https://github.com/earlephilhower/esp8266audio/blob/master/_autodocs/api-reference/AudioGeneratorWAV.md

Creates a new WAV decoder instance. The internal buffer is allocated on the first `begin()` call.

```APIDOC
## AudioGeneratorWAV()

### Description
Creates a new WAV decoder with default internal buffer size. Allocates buffer on first `begin()` call.

### Parameters
None

### Example
```cpp
AudioGeneratorWAV *wav = new AudioGeneratorWAV();
```
```