MP3 to WAV conversion -- Working

[hammerheaddown]

I have been trying everything to get this working, i wanted to use the wav download but the chuinks coming back when it was done downloaded were all staticy in between chunks and clipping it was odd

well i had no issues getting the mp3 downloads to work so i tried that

i have been trying to get it to 16000 hz 16 bit mono the same as my mic

void deepgramTTSAsMP3(const char* textToSpeech) {
    // Ensure the SD card is ready and overwrite the existing file
    if (SD.exists("/temp.mp3")) {
        SD.remove("/temp.mp3");
        Serial.println("Existing /temp.mp3 removed");
    }

    char escapedText[512];
    int j = 0;
    for (int i = 0; textToSpeech[i] != '\0'; i++) {
        if (textToSpeech[i] == '"') {
            escapedText[j++] = '\\';
        }
        escapedText[j++] = textToSpeech[i];
    }
    escapedText[j] = '\0';

    char requestBody[1024];
    JsonDocument doc;
    doc["text"] = escapedText;
    serializeJson(doc, requestBody);

    Serial.println("RequestBody: " + String(requestBody));

    #ifdef DEBUG_MODE
      Serial.println("Free Heap before TTS fetch: " + String(ESP.getFreeHeap()));
    #endif

    // Open MP3 file for writing
    File mp3File = SD.open("/temp.mp3", FILE_WRITE);
    if (!mp3File) {
        Serial.println("Failed to open /temp.mp3 for writing");
        return;
    }

    // HTTP setup for MP3 fetch
    HTTPClient http;
    http.begin("https://api.deepgram.com/v1/speak?model=aura-asteria-en");
    http.addHeader("Authorization", "Token " + String(deepgramApiKey));
    http.addHeader("Content-Type", "application/json");

    int httpCode = http.POST(requestBody);
    if (httpCode == HTTP_CODE_OK) {
        AudioToolsLogger.begin(Serial, AudioToolsLogLevel::Info); // Enable detailed logging
        Stream& httpStream = http.getStream();
        const size_t bufferSize = 2048; // Large buffer for streaming
        uint8_t buffer[bufferSize];
        size_t totalBytes = 0;

        // Setup MultiOutput for saving MP3 to SD only
        MultiOutput multiOut;
        multiOut.add(mp3File);
        multiOut.begin();

        bool dataAvailable = true;
        unsigned long lastDataTime = millis();
        unsigned long startTime = millis();

        // Fetch and save MP3 with extended timeout
        while (dataAvailable && (millis() - startTime < 60000)) { // 60-second timeout
            if (httpStream.available()) {
                size_t bytesRead = httpStream.readBytes(buffer, bufferSize);
                if (bytesRead > 0) {
                    multiOut.write(buffer, bytesRead);
                    totalBytes += bytesRead;

                    #ifdef DEBUG_MODE
                      Serial.println("Fetched and saved " + String(totalBytes) + " bytes of MP3, Heap: " + String(ESP.getFreeHeap()));
                    #endif

                    lastDataTime = millis();
                }
            } else {
                if (millis() - lastDataTime > 10000) { // 10-second inactivity timeout
                    Serial.println("No data for 10 seconds, stopping fetch");
                    dataAvailable = false;
                } else {
                    delay(100);
                }
            }
        }

        // Flush and cleanup
        multiOut.flush();
        multiOut.end();
        mp3File.close();

        if (totalBytes == 0) {
            Serial.println("No MP3 data fetched");
            SD.remove("/temp.mp3");
            return;
        }

      
        #ifdef DEBUG_MODE
          Serial.println("MP3 fetched and saved to /temp.mp3: " + String(totalBytes) + " bytes, Free heap: " + String(ESP.getFreeHeap()));
        #endif

    } else {
        Serial.printf("[HTTP] POST TTS... failed, error: %s\n", http.errorToString(httpCode).c_str());
        Serial.println("Response: " + http.getString());
        mp3File.close();
        SD.remove("/temp.mp3");
    }

    http.end();
    delay(500);
    printCommands();
}


void convertMP3ToWAVUsingStreamCopy() {
    Serial.println("Starting MP3 to WAV conversion with format conversion and resampling...");

    // Check if MP3 file exists
    if (!SD.exists("/temp.mp3")) {
        Serial.println("No MP3 file found at /temp.mp3");
        return;
    }

    // Extract MP3 metadata
    AudioInfo mp3Info = getMP3Metadata("/temp.mp3");
    int sourceSampleRate = mp3Info.sample_rate > 0 ? mp3Info.sample_rate : 22050; // Fallback if metadata fails
    int sourceChannels = mp3Info.channels > 0 ? mp3Info.channels : 1;
    int sourceBits = mp3Info.bits_per_sample > 0 ? mp3Info.bits_per_sample : 16;
    Serial.println("Source MP3 Metadata - Sample Rate: " + String(sourceSampleRate) + " Hz, Channels: " + String(sourceChannels) + ", Bits: " + String(sourceBits));
    Serial.println("Target WAV Output - Sample Rate: 16000 Hz, Channels: 1, Bits: 16");

    File mp3File = SD.open("/temp.mp3", FILE_READ);
    if (!mp3File) {
        Serial.println("Failed to open /temp.mp3 for reading");
        return;
    }

    // Open WAV file for writing, overwriting any existing file
    if (SD.exists("/temp.wav")) {
        SD.remove("/temp.wav");
    }
    File wavFile = SD.open("/temp.wav", FILE_WRITE);
    if (!wavFile) {
        Serial.println("Failed to open /temp.wav for writing");
        mp3File.close();
        return;
    }

    // Write initial WAV header for 16000 Hz, mono, 16-bit
    uint8_t wavHeader[44] = {
        'R', 'I', 'F', 'F', 0x00, 0x00, 0x00, 0x00, 'W', 'A', 'V', 'E', 'f', 'm', 't', ' ',
        0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x80, 0x3E, 0x00, 0x00, // 16000 Hz
        0x00, 0x7D, 0x00, 0x00, 0x02, 0x00, 0x10, 0x00, 'd', 'a', 't', 'a', 0x00, 0x00, 0x00, 0x00
    };
    wavFile.write(wavHeader, 44);
    Serial.println("WAV header written with sample rate: 16000 Hz");

    // Setup MP3 decoder with the source sample rate
    MP3DecoderHelix mp3Decoder;
    AudioInfo sourceInfo(sourceSampleRate, sourceChannels, sourceBits);
    mp3Decoder.setAudioInfo(sourceInfo);
    if (!mp3Decoder.begin()) {
        Serial.println("MP3 decoder begin failed");
        wavFile.close();
        mp3File.close();
        return;
    }
    Serial.println("MP3 decoder initialized with source sample rate: " + String(sourceSampleRate) + " Hz");

    // Setup ResampleStream to resample from sourceSampleRate to 16000 Hz
    ResampleStream resampler(wavFile);
    AudioInfo resamplerTargetInfo(16000, sourceChannels, sourceBits); // Intermediate: change sample rate, keep channels and bits
    resampler.setAudioInfo(resamplerTargetInfo);
    float stepSize = (float)sourceSampleRate / 16000.0; // 22050 / 16000 = 1.378125
    resampler.setStepSize(stepSize);
    if (!resampler.begin()) {
        Serial.println("Resampler begin failed");
        mp3Decoder.end();
        wavFile.close();
        mp3File.close();
        return;
    }
    Serial.println("Resampler initialized: " + String(sourceSampleRate) + " Hz to 16000 Hz, Step Size: " + String(stepSize));

    // Setup FormatConverterStream to convert channels and bit depth
    FormatConverterStream conv(resampler);
    AudioInfo convTargetInfo(16000, 1, 16); // Final: 16000 Hz, mono, 16-bit
    conv.begin(resamplerTargetInfo, convTargetInfo);
    Serial.println("FormatConverter initialized: Channels " + String(sourceChannels) + " to 1, Bits " + String(sourceBits) + " to 16");

    // Setup EncodedAudioStream to decode MP3 to PCM, outputting to the format converter
    EncodedAudioStream encodedStream(&conv, &mp3Decoder);
    encodedStream.begin();

    // Use StreamCopy to transfer data from mp3File through the pipeline with enhanced logic
    StreamCopy copier(encodedStream, mp3File);
    size_t totalBytesCopied = 0;
    const size_t maxRetries = 100; // Increased retries
    unsigned long lastCopyTime = millis();
    bool initialCopyAttempt = true; // Flag to ensure initial data is captured

    Serial.println("Starting copy with total bytes copied: " + String(totalBytesCopied));
    while (mp3File.available() || initialCopyAttempt) {
        size_t bytesCopied = copier.copy();
        if (bytesCopied == 0) {
            Serial.println("Warning: No bytes copied, possible invalid frame. Retrying...");
            for (int i = 0; i < maxRetries && bytesCopied == 0; i++) {
                delay(10);
                bytesCopied = copier.copy();
                if (bytesCopied > 0) {
                    Serial.println("Recovered " + String(bytesCopied) + " bytes after retry");
                    break;
                }
            }
            if (bytesCopied == 0 && (millis() - lastCopyTime > 5000)) {
                Serial.println("No data for 5 seconds, stopping copy");
                break;
            }
            if (initialCopyAttempt && bytesCopied == 0 && (millis() - lastCopyTime > 2000)) {
                Serial.println("Failed to copy initial data after 2 seconds, stopping to avoid skipping");
                break;
            }
        } else {
            totalBytesCopied += bytesCopied;
            lastCopyTime = millis();
            initialCopyAttempt = false; // Initial data captured successfully
            Serial.println("Copied " + String(bytesCopied) + " bytes, Total: " + String(totalBytesCopied) + ", Free Heap: " + String(ESP.getFreeHeap()));
        }
    }

    // Update WAV header with actual data size
    if (totalBytesCopied > 0) {
        uint32_t dataSize = totalBytesCopied;
        uint32_t fileSize = dataSize + 36; // Total file size - 8
        wavFile.seek(4); // Move to file size field
        wavFile.write((uint8_t*)&fileSize, 4);
        wavFile.seek(40); // Move to data size field
        wavFile.write((uint8_t*)&dataSize, 4);
        Serial.println("WAV header updated with data size: " + String(dataSize) + " bytes");
    } else {
        Serial.println("No data decoded, WAV file will be incomplete");
    }

    // Finalize and close
    encodedStream.flush();
    wavFile.flush();
    encodedStream.end();
    mp3Decoder.end();
    resampler.end();
    conv.end();
    wavFile.close();
    mp3File.close();
    Serial.println("MP3 converted to WAV at /temp.wav, Free heap: " + String(ESP.getFreeHeap()));
}

so the mp3 downloads no problem and the sketch is huge so was saving space here. i could not find a straight forward example on how to do this.

it almost works it plays on the board but not in audacity and stuff cause it is not making a correct wav file... and i know that is my fault but i cant seem to figure this out, tried resampling and filterstream and a few more these past few days

i know i prob over complicated this. i am going to use open ai for tts too so i wasnt sure which type of .mp3 files they use do wanted it sort of dynamic

[pschatzmann]

I think this is way too complicated: why don't you just adapt the approach from this example or this one when you want to decode to play back some audio ?

[hammerheaddown]

the same thing... i need it as a .wav at 1(6000 1 16) i do have the google in same sketch

i pay for deepgram and trying to get it to work. i will be looking into azure tho

is there a easy way to convert these or am i missing it in your docs or examples?

EDIT: i am going to try and get the wav to work with deepgram now. but still need the mp3 to wav conversion. again i thought i saw it but can not find it in any search in the wiki or examples

[pschatzmann]

I don't quite understand what you want to do, but you can decode to pcm with a decoder and encode to any supported format from pcm with an encoder: e.g if you receive mp3 and want to convert it to wav just chain two EncodedAudioStream objects.

Please read the Codec Wiki...

[hammerheaddown]

i tried with that other day, but maybe i had the chain wrong... TBH its more an issue i think on deepgram cause when i was doing it with encoded stream it was all suuuupppperrrr slowwwwwww type thing even tho it said the wav was 16000,1, 16

[hammerheaddown]

OMG after days it was a simper error in the way i constructed the post to deepgram and the encoded worked this time after i looked at their docs...

here is the updated and working sketch in case someone else ever needs it or similar.

Encode .mp3 and save to SD as a .wav audio file, while listening thru speaker

// Suppress annoying library warnings
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wformat"
#pragma GCC diagnostic ignored "-Wdelete-non-virtual-dtor"

#include "AudioTools.h"
#include "AudioTools/AudioCodecs/CodecMP3Helix.h"
#include "AudioTools/AudioCodecs/CodecWAV.h"
#include <WiFi.h>
#include <WiFiUdp.h>
#include <WiFiClientSecure.h>
#include <HTTPClient.h>
#include <ArduinoJson.h>
#include "freertos/FreeRTOS.h"
#include "freertos/queue.h"
#include <chrono> // For timekeeping
#include <SD.h>
#include <SPI.h>

// -------------------------- AMP Pin Setup ------------------------------------------
#define I2S_BCLK GPIO_NUM_5
#define I2S_DOUT GPIO_NUM_6
#define I2S_LRC  GPIO_NUM_14
i2s_chan_handle_t tx_handle;

// -------------------------- SD Pin Setup ------------------------------------------
#define SD_MISO GPIO_NUM_13
#define SD_MOSI GPIO_NUM_11
#define SD_SCK GPIO_NUM_12
#define SD_CS GPIO_NUM_10

#define SAMPLE_RATE 22050 // Deepgram Aura likely uses 22.05kHz, adjust if needed
AudioInfo info(SAMPLE_RATE, 1, 16);

// -------------------------- Wifi Credentials ------------------------------------------
const char *ssid = "";
const char *password = "";

// -------------------------- Deepgram Credentials ------------------------------------------
const char *deepgramApiKey = "";
#define STT_LANGUAGE "en"
#define TIMEOUT_DEEPGRAM 12
#define STT_KEYWORDS "&keywords=Gigolo&keywords=Google"
String optional_param = "?model=nova-2-general";

// -------------------------- Audio Tools Setup ----------------------------------------------
URLStream url;
I2SStream i2s;
EncodedAudioStream decoder(&i2s, new MP3DecoderHelix());
StreamCopy copier(decoder);

// --------------------------------------------------------------------------------------------

void SD_setup() {
    pinMode(SD_CS, OUTPUT);
    digitalWrite(SD_CS, HIGH);
    delay(10);
    SPI.begin(SD_SCK, SD_MISO, SD_MOSI, SD_CS);
    SPI.setFrequency(4000000); // 4MHz is reasonable for SD
    delay(100);
    if (!SD.begin(SD_CS)) {
        Serial.println("SD card mount failed!");
        while (1) delay(1000); // Halt if SD fails
    }
    Serial.println("SD card mounted successfully.");
}

void deepgramTTS(const char* textToSpeech) {
    char escapedText[512];
    int j = 0;
    for (int i = 0; textToSpeech[i] != '\0'; i++) {
        if (textToSpeech[i] == '"') {
            escapedText[j++] = '\\';
        }
        escapedText[j++] = textToSpeech[i];
    }
    escapedText[j] = '\0';

    char requestBody[1024];
    JsonDocument doc;
    doc["text"] = escapedText;
    serializeJson(doc, requestBody);

    Serial.println("RequestBody: " + String(requestBody));
    Serial.println("Free Heap before TTS fetch: " + String(ESP.getFreeHeap()));

    // Open file for writing as WAV
    if (SD.exists("/deepgram.wav")) {
        SD.remove("/deepgram.wav");
    }
    File wavFile = SD.open("/deepgram.wav", FILE_WRITE);
    if (!wavFile) {
        Serial.println("Failed to open /deepgram.wav for writing");
        return;
    }

    // HTTP setup
    HTTPClient http;
    http.begin("https://api.deepgram.com/v1/speak?model=aura-asteria-en");
    http.addHeader("Authorization", "Token " + String(deepgramApiKey));
    http.addHeader("Content-Type", "application/json");

    int httpCode = http.POST(requestBody);
    Serial.print("HTTP Response Code: ");
    Serial.println(httpCode);

    if (httpCode == HTTP_CODE_OK) {
        AudioToolsLogger.begin(Serial, AudioToolsLogLevel::Error);
        Stream& httpStream = http.getStream();
        const size_t bufferSize = 512;
        uint8_t buffer[bufferSize];
        size_t totalBytes = 0;

        // Setup MultiOutput with WAV encoding
        MultiOutput multiOut;
        I2SStream i2s;
        // First decode MP3, then encode to WAV
        EncodedAudioStream mp3Decoder(&i2s, new MP3DecoderHelix());
        EncodedAudioStream wavEncoder(&wavFile, new WAVEncoder());
        multiOut.add(wavEncoder);  // Save as WAV to SD
        multiOut.add(mp3Decoder);  // Play via I2S
        multiOut.begin();

        // Configure I2S
        auto cfg = i2s.defaultConfig(TX_MODE);
        cfg.pin_bck = I2S_BCLK;
        cfg.pin_ws = I2S_LRC;
        cfg.pin_data = I2S_DOUT;
        cfg.i2s_format = I2S_STD_FORMAT;
        cfg.sample_rate = SAMPLE_RATE;
        cfg.channels = 1;
        cfg.bits_per_sample = 16;
        i2s.begin(cfg);
        
        // Begin both encoder and decoder
        wavEncoder.begin();
        mp3Decoder.begin();

        bool dataAvailable = true;
        unsigned long lastDataTime = millis();
        unsigned long firstChunkTime = 0;
        bool firstChunkProcessed = false;

        // Fetch and process simultaneously
        while (dataAvailable) {
            if (httpStream.available()) {
                size_t bytesRead = httpStream.readBytes(buffer, bufferSize);
                if (bytesRead > 0) {
                    if (firstChunkTime == 0) {
                        firstChunkTime = millis();
                        Serial.println("First chunk received at: " + String(firstChunkTime) + " ms");
                    }
                    multiOut.write(buffer, bytesRead); // Write to WAV and decode/play
                    if (!firstChunkProcessed) {
                        unsigned long playbackStartTime = millis();
                        Serial.println("Playback started at: " + String(playbackStartTime) + " ms");
                        Serial.println("Delay from first chunk to playback: " + String(playbackStartTime - firstChunkTime) + " ms");
                        firstChunkProcessed = true;
                    }
                    totalBytes += bytesRead;
                    lastDataTime = millis();
                }
            } else {
                if (millis() - lastDataTime > 5000) {
                    Serial.println("No more data received, stopping fetch and playback");
                    dataAvailable = false;
                } else {
                    delay(100);
                }
            }
        }

        // Flush and cleanup
        multiOut.flush();
        multiOut.end();
        wavEncoder.end();
        mp3Decoder.end();
        i2s.end();
        wavFile.close();

        if (totalBytes == 0) {
            Serial.println("No audio data fetched");
            SD.remove("/deepgram.wav");
            return;
        }

        // Verify file size
        File verifyFile = SD.open("/deepgram.wav", FILE_READ);
        if (verifyFile) {
            Serial.println("Verified WAV file size on SD: " + String(verifyFile.size()) + " bytes");
            verifyFile.close();
        } else {
            Serial.println("Failed to verify WAV file size on SD");
        }

        Serial.println("WAV fetched, saved, and played from /deepgram.wav: " + String(totalBytes) + " bytes, Free heap: " + String(ESP.getFreeHeap()));
        http.end();
        delay(100); 
   
    } else {
        Serial.printf("[HTTP] POST TTS... failed, error: %s\n", http.errorToString(httpCode).c_str());
        Serial.println("Response: " + http.getString());
        wavFile.close();
        SD.remove("/deepgram.wav");
    }
}

void setup() {
    Serial.begin(115200);
    delay(10);

    SD_setup();
    #ifdef DEBUG_MODE
    Serial.println("Free Heap after SD setup: " + String(ESP.getFreeHeap()));
    #endif

    WiFi.begin(ssid, password);
    while (WiFi.status() != WL_CONNECTED) {
        delay(1000);
    }
    Serial.println("Connected to WiFi");
}

void loop() {
    deepgramTTS("well this only took 5 days and 2 years off my life to just over complicate it and its like 2 lines of code, lol ");
    delay(1000000);
}

[hammerheaddown]

in my excitement i realized it was not 1600hz but still 22050 hz

I have been trying to use resampling but its just acting a fool

void playAndResampleWav(const char* filename = "/wakewords/temp.wav") {
    File wavFile = SD.open(filename, FILE_READ);
    if (!wavFile) {
        Serial.println("Failed to open " + String(filename) + " for playback");
        return;
    }

    // Setup I2S output
    I2SStream i2s;
    auto cfg = i2s.defaultConfig(TX_MODE);
    cfg.pin_bck = I2S_BCLK;
    cfg.pin_ws = I2S_LRC;
    cfg.pin_data = I2S_DOUT;
    cfg.i2s_format = I2S_STD_FORMAT;
    cfg.sample_rate = 16000; // Target sample rate
    cfg.channels = 1;
    cfg.bits_per_sample = 16;
    i2s.begin(cfg);

    // Setup WAV decoder
    AudioInfo sourceInfo(22050, 1, 16);  // Input WAV format
    AudioInfo targetInfo(16000, 1, 16);  // Desired output format
    EncodedAudioStream wavDecoder(&wavFile, new WAVDecoder());
    wavDecoder.setAudioInfo(sourceInfo);
    wavDecoder.begin();

    // Setup FormatConverterStream for resampling
    FormatConverterStream converter(i2s); // Pass I2SStream by reference
    converter.setAudioInfo(targetInfo);
    converter.begin();

    // Copy the stream with resampling
    StreamCopy copier(converter, wavDecoder);
    copier.copyAll();

    // Cleanup
    converter.end();
    wavDecoder.end();
    i2s.end();
    wavFile.close();
    Serial.println("Playback and resampling completed for " + String(filename));
}

in the serial:

16:07:34.293 -> Free Heap before TTS fetch: 270880
16:07:34.381 -> Starting HTTP request...
16:07:34.381 -> HTTP headers set, sending POST request...
16:07:35.656 -> HTTP Response Code: 200
16:07:35.656 -> HTTP request successful, fetching stream...
16:07:35.701 -> First chunk received at: 3595 ms
16:07:44.235 -> No more data received, stopping fetch
16:07:44.326 -> Initial WAV Header Info - Sample Rate: 22050 Hz, Channels: 1, Bits per Sample: 16
16:07:44.326 -> WAV downloaded to /temp.wav: 43215 bytes
16:07:44.373 -> [W] I2SESP32V1.h : 243 - Using channel_format: I2SChannelSelect::Left for mono
16:07:44.373 -> [ 12278][E][esp32-hal-periman.c:180] perimanGetPinBus(): Invalid pin: 64
16:07:44.373 -> [ 12291][E][esp32-hal-gpio.c:176] __digitalWrite(): IO 64 is not set as GPIO.
16:07:56.968 -> [ 24876][E][esp32-hal-periman.c:180] perimanGetPinBus(): Invalid pin: 64
16:07:56.968 -> [ 24882][E][esp32-hal-gpio.c:176] __digitalWrite(): IO 64 is not set as GPIO.
16:07:56.968 -> Playback and resampling completed for /temp.wav

and it turns a womans voice into mans and slows it and it drags out
@pschatzmann what am i missing here? so confused tried resampling too and no luck there either

should be this difficult to change teh audio with making it unusable

[pschatzmann]

• a couple of comments: wavDecoder.setAudioInfo(sourceInfo); is pointless and it is just the other way round. The wav file contains the information and notifies others if possible
• You did not start the FormatConverterStream properly: usually you would call begin(AudioInfo from, AudioInfo to)
• By copying from the wavDecoder to converter, you loose the automatic notifications because there is no link.
  • It would be better to build a full chain on the output side and copy from the file.
  • or you could add a wavDecoder.addNotifyAudioInfo(converter)
  • or you could activate the audio info synchronization in the copier,
  • or you can just make sure that you got your manual settings right

[hammerheaddown]

void playAndResampleWav(const char* filename = "/temp.wav") {
    File wavFile = SD.open(filename, FILE_READ);
    if (!wavFile) {
        Serial.println("Failed to open " + String(filename) + " for playback");
        return;
    }

    // Setup I2S output
    I2SStream i2s;
    auto cfg = i2s.defaultConfig(TX_MODE);
    cfg.pin_bck = I2S_BCLK;
    cfg.pin_ws = I2S_LRC;
    cfg.pin_data = I2S_DOUT;
    cfg.i2s_format = I2S_STD_FORMAT;
    cfg.sample_rate = 16000; // Target sample rate
    cfg.channels = 1;
    cfg.bits_per_sample = 16;
    i2s.begin(cfg);

    // Setup WAV decoder with the file as input
    EncodedAudioStream wavDecoder(&wavFile, new WAVDecoder());
    wavDecoder.begin();

    // Setup FormatConverterStream for resampling
    AudioInfo sourceInfo(22050, 1, 16);  // Expected WAV format
    AudioInfo targetInfo(16000, 1, 16);  // Desired output format
    FormatConverterStream converter(i2s);
    converter.begin(sourceInfo, targetInfo); // Properly initialize resampling

    // Link the chain: WAVDecoder notifies FormatConverterStream of AudioInfo
    wavDecoder.addNotifyAudioChange(converter);

    // Copy directly from the file through the chain
    StreamCopy copier(converter, wavFile);
    copier.copyAll();

    // Cleanup
    converter.end();
    wavDecoder.end();
    i2s.end();
    wavFile.close();
    Serial.println("Playback and resampling completed for " + String(filename));
}

i am so lost i have read so many docs, its just errors and comp errors then the file wont work... im tearing what little hair out

and it is still not doing 16000 hz and look what it is doing to th efil in audacity... this time a is a bit better i can almost heat a little

[pschatzmann]

You chain is messed up: you should not copy and encoded file to the format converter w/o decoding it!
But I don't quite understand what you are trying to do here: why would you convert at all ? I2S can handle 22050 w/o issues...

[hammerheaddown]

so i am getting this issue:

23:27:52.197 -> SD card mounted successfully.
23:27:52.267 -> Free Heap Before Conversion: 312952
23:27:52.267 -> MP3 Info - Sample Rate: 44100 Hz, Channels: 2, Bits per Sample: 16
23:27:58.985 -> Copied 311040 bytes during conversion.
23:27:58.986 -> 
23:27:59.021 -> assert failed: void libhelix::MP3DecoderHelix::provideResult(MP3FrameInfo&) MP3DecoderHelix.h:155 (written == toWrite)
23:27:59.021 -> 
23:27:59.021 -> 
23:27:59.021 -> Backtrace: 0x40376642:0x3fcaa9c0 0x4037e4ad:0x3fcaa9e0 0x40384f19:0x3fcaaa00 0x42005cea:0x3fcaab30 0x42005d9d:0x3fcaab50 0x42005ca4:0x3fcaaba0 0x4200adf8:0x3fcaabc0 0x420040f6:0x3fcaabe0 0x42004834:0x3fcaac00 0x420074f1:0x3fcaac20 0x4200b78a:0x3fcaac40 0x4200ba03:0x3fcab6b0 0x4201ae83:0x3fcab6e0 0x4037f0f6:0x3fcab700
23:27:59.062 -> 
23:27:59.062 -> 

the code is:

// Suppress annoying library warnings
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wformat"
#pragma GCC diagnostic ignored "-Wdelete-non-virtual-dtor"

#include "AudioTools.h"
#include "AudioTools/AudioCodecs/CodecMP3Helix.h"
#include "AudioTools/AudioCodecs/CodecWAV.h"
#include <WiFi.h>
#include <WiFiUdp.h>
#include <WiFiClientSecure.h>
#include <HTTPClient.h>
#include <ArduinoJson.h>
#include "freertos/FreeRTOS.h"
#include "freertos/queue.h"
#include <chrono> // For timekeeping
#include <SD.h>
#include <SPI.h>

// -------------------------- AMP Pin Setup ------------------------------------------
#define I2S_BCLK GPIO_NUM_5
#define I2S_DOUT GPIO_NUM_6
#define I2S_LRC  GPIO_NUM_14
i2s_chan_handle_t tx_handle;
// -------------------------- SD Pin Setup ------------------------------------------
#define SD_MISO GPIO_NUM_13
#define SD_MOSI GPIO_NUM_11
#define SD_SCK GPIO_NUM_12
#define SD_CS GPIO_NUM_10
// -------------------------------------------------------------------------------------
#define TARGET_SAMPLE_RATE 16000
#define TARGET_CHANNELS 1
#define TARGET_BITS_PER_SAMPLE 16
// -------------------------------------------------------------------------------------

void SD_setup() {
    pinMode(SD_CS, OUTPUT);
    digitalWrite(SD_CS, HIGH);
    delay(10);
    SPI.begin(SD_SCK, SD_MISO, SD_MOSI, SD_CS);
    SPI.setFrequency(4000000); // 4MHz is reasonable for SD
    delay(100);
    if (!SD.begin(SD_CS)) {
        Serial.println("SD card mount failed!");
        while (1) delay(1000); // Halt if SD fails
    }
    Serial.println("SD card mounted successfully.");
}

// -------------------------------------------------------------------------------------
void convertMP3ToWAV(const char* mp3Filename, const char* wavFilename) {
    File mp3File = SD.open(mp3Filename, FILE_READ);
    if (!mp3File) {
        Serial.println("Failed to open MP3 file: " + String(mp3Filename));
        return;
    }

    if (SD.exists(wavFilename)) {
        SD.remove(wavFilename);
    }
    File wavFile = SD.open(wavFilename, FILE_WRITE);
    if (!wavFile) {
        Serial.println("Failed to create WAV file: " + String(wavFilename));
        mp3File.close();
        return;
    }

    EncodedAudioStream mp3Decoder(&mp3File, new MP3DecoderHelix());
    mp3Decoder.begin();
    
    AudioInfo sourceInfo = mp3Decoder.audioInfo();
    Serial.printf("MP3 Info - Sample Rate: %d Hz, Channels: %d, Bits per Sample: %d\n", 
                  sourceInfo.sample_rate, sourceInfo.channels, sourceInfo.bits_per_sample);
    
    AudioInfo targetInfo(TARGET_SAMPLE_RATE, TARGET_CHANNELS, TARGET_BITS_PER_SAMPLE);
    FormatConverterStream converter(wavFile);
    converter.begin(sourceInfo, targetInfo);

    EncodedAudioStream wavEncoder(&converter, new WAVEncoder());
    wavEncoder.setAudioInfo(targetInfo);
    wavEncoder.begin();

    StreamCopy copier(wavEncoder, mp3Decoder);
    copier.copyAll();

    wavEncoder.end();
    converter.end();
    mp3Decoder.end();
    mp3File.close();
    wavFile.close();

    Serial.println("Conversion complete: " + String(wavFilename));
}

// -------------------------------------------------------------------------------------
void setup() {
    Serial.begin(115200);

    delay(10);
    SD_setup();      
    #ifdef DEBUG_MODE
      Serial.println("Free Heap B4 we continue " + String(ESP.getFreeHeap()));
    #endif
    convertMP3ToWAV("/recordings/temp.mp3", "/recordings/output.wav");
}

// -------------------------------------------------------------------------------------
void loop() {
    // Your loop code here
}

i am using the Esp32 s3 16 ram , and i sorry yes i want them all uniform at the same rate etc for uniformity in case i come up with some genius idea later (lol) and i dont have a bunch of file that are some mp3 and wavs etc

[hammerheaddown]

changed to libMad and not getting the crash a but im not getting it to work

the top is teh wav... the waveform look good this time, but this is a prerecorded file for now lol

00:40:06.960 -> SD card mounted successfully.
00:40:06.960 -> MP3 File Size: 43259 bytes
00:40:07.188 -> Free Heap Before Conversion: 306612
00:40:07.188 -> MP3 Info - Sample Rate: 44100 Hz, Channels: 2, Bits per Sample: 16
00:40:07.188 -> Target Info - Sample Rate: 16000 Hz, Channels: 1, Bits per Sample: 16
00:40:08.876 -> Progress: Copied 32768 bytes so far
00:40:09.425 -> Progress: Copied 65536 bytes so far
00:40:09.982 -> Progress: Copied 98304 bytes so far
00:40:10.573 -> Progress: Copied 131072 bytes so far
00:40:11.117 -> Progress: Copied 163840 bytes so far
00:40:11.674 -> Progress: Copied 196608 bytes so far
00:40:12.214 -> Progress: Copied 229376 bytes so far
00:40:12.790 -> Progress: Copied 262144 bytes so far
00:40:13.287 -> Progress: Copied 294912 bytes so far
00:40:13.631 -> Warning: No more data to copy, stopping early.
00:40:13.631 -> Total Copied 312192 bytes during conversion.
00:40:13.677 -> WAV File Size: 56678 bytes
00:40:13.677 -> Free Heap After Conversion: 304916
00:40:13.677 -> Conversion complete: /output.wav

new attempt

void convertMP3ToWAV(const char* mp3Filename, const char* wavFilename) {
    File mp3File = SD.open(mp3Filename, FILE_READ);
    if (!mp3File || mp3File.size() == 0) {
        Serial.println("Failed to open MP3 file or file is empty: " + String(mp3Filename));
        return;
    }
    Serial.printf("MP3 File Size: %d bytes\n", mp3File.size());

    if (SD.exists(wavFilename)) {
        SD.remove(wavFilename);
    }
    File wavFile = SD.open(wavFilename, FILE_WRITE);
    if (!wavFile) {
        Serial.println("Failed to create WAV file: " + String(wavFilename));
        mp3File.close();
        return;
    }

    Serial.println("Free Heap Before Conversion: " + String(ESP.getFreeHeap()));
    
    EncodedAudioStream mp3Decoder(&mp3File, new MP3DecoderMAD());
    mp3Decoder.begin();
    
    AudioInfo sourceInfo = mp3Decoder.audioInfo();
    Serial.printf("MP3 Info - Sample Rate: %d Hz, Channels: %d, Bits per Sample: %d\n", 
                  sourceInfo.sample_rate, sourceInfo.channels, sourceInfo.bits_per_sample);
    
    AudioInfo targetInfo(TARGET_SAMPLE_RATE, TARGET_CHANNELS, TARGET_BITS_PER_SAMPLE);
    Serial.printf("Target Info - Sample Rate: %d Hz, Channels: %d, Bits per Sample: %d\n", 
                  targetInfo.sample_rate, targetInfo.channels, targetInfo.bits_per_sample);
    
    // Write WAV header (placeholder)
    uint32_t sampleRate = targetInfo.sample_rate; // Use target rate
    uint16_t channels = targetInfo.channels;
    uint16_t bitsPerSample = targetInfo.bits_per_sample;
    uint32_t byteRate = sampleRate * channels * (bitsPerSample / 8);
    uint16_t blockAlign = channels * (bitsPerSample / 8);
    uint32_t dataSize = 0; // Updated later
    
    wavFile.write((uint8_t*)"RIFF", 4);
    wavFile.write((uint8_t*)&dataSize, 4); // Placeholder for file size - 8
    wavFile.write((uint8_t*)"WAVE", 4);
    wavFile.write((uint8_t*)"fmt ", 4);
    uint32_t fmtSize = 16;
    wavFile.write((uint8_t*)&fmtSize, 4);
    uint16_t audioFormat = 1; // PCM
    wavFile.write((uint8_t*)&audioFormat, 2);
    wavFile.write((uint8_t*)&channels, 2);
    wavFile.write((uint8_t*)&sampleRate, 4);
    wavFile.write((uint8_t*)&byteRate, 4);
    wavFile.write((uint8_t*)&blockAlign, 2);
    wavFile.write((uint8_t*)&bitsPerSample, 2);
    wavFile.write((uint8_t*)"data", 4);
    wavFile.write((uint8_t*)&dataSize, 4); // Placeholder for data size

    // Convert and write data
    FormatConverterStream converter(wavFile);
    converter.begin(sourceInfo, targetInfo);
    StreamCopy copier(converter, mp3Decoder, 16384);
    size_t totalBytesCopied = 0;
    const size_t chunkSize = 1024 * 32;
    while (copier.available()) {
        size_t bytesCopied = copier.copy();
        totalBytesCopied += bytesCopied;
        if (totalBytesCopied % chunkSize == 0) {
            Serial.printf("Progress: Copied %d bytes so far\n", totalBytesCopied);
        }
        if (bytesCopied == 0) {
            Serial.println("Warning: No more data to copy, stopping early.");
            break;
        }
    }
    Serial.printf("Total Copied %d bytes during conversion.\n", totalBytesCopied);

    // Ensure all data is written
    converter.flush();
    delay(10);

    // Update WAV header
    uint32_t fileSize = totalBytesCopied + 36; // Data + header - 8
    uint32_t dataSizeFinal = totalBytesCopied;
    wavFile.seek(4);
    wavFile.write((uint8_t*)&fileSize, 4);
    wavFile.seek(40);
    wavFile.write((uint8_t*)&dataSizeFinal, 4);

    converter.end();
    mp3File.close();
    wavFile.flush();
    wavFile.close();

    File checkFile = SD.open(wavFilename, FILE_READ);
    Serial.printf("WAV File Size: %d bytes\n", checkFile.size());
    checkFile.close();

    Serial.println("Free Heap After Conversion: " + String(ESP.getFreeHeap()));
    Serial.println("Conversion complete: " + String(wavFilename));
}

there has to be a easier way to get this working, i have went thru so many examples here and cant get it... the wav file was only 0kb for a while and i was getting that crash every time with libmp3helix when it would try to close

[pschatzmann]

I don't recommend to use the decoding on the input side because you might run into the issue that the needed internal buffer is too small. Libhelix has a check, that I did not add to lbmad! I think this is described in the documentation. So if you want to stick with your way you will need to increase that buffer until the error goes away...

My same comments as above apply: so my recommended flow for converting the file format is is

File - copy -> EncodedAudioStream(mp3) -> FormatConverterStream -> EncodedAudioStream(wav) -> File

Use the WAVEncoder to write the wav file with header...

ps. Also don't allocate the decoders and encodes with new if all your other objects are on the stack: otherwise you create a bad memory leak! I also never used my functionality this way by allocating the whole thing on the stack...

[hammerheaddown]

mine went :
File (/temp.mp3) -> EncodedAudioStream (MP3DecoderMAD) -> FormatConverterStream -> Manual WAV Header + PCM Data -> File (/output.wav)

// Suppress annoying library warnings
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wformat"
#pragma GCC diagnostic ignored "-Wdelete-non-virtual-dtor"

#include "AudioTools.h"
//#include "AudioTools/AudioCodecs/CodecMP3Helix.h"
#include "AudioTools/AudioCodecs/CodecMP3MAD.h" 
#include "AudioTools/AudioCodecs/CodecWAV.h"
#include <SD.h>


// -------------------------- AMP Pin Setup ------------------------------------------
#define I2S_BCLK GPIO_NUM_5
#define I2S_DOUT GPIO_NUM_6
#define I2S_LRC  GPIO_NUM_14
i2s_chan_handle_t tx_handle;

// -------------------------- SD Pin Setup ------------------------------------------
#define SD_MISO GPIO_NUM_13
#define SD_MOSI GPIO_NUM_11
#define SD_SCK GPIO_NUM_12
#define SD_CS GPIO_NUM_10

// --------------------------  Global Variables -----------------------------------------
const char* mp3Filename = "/temp.mp3";
const char* wavFilename = "/output.wav";
#define TARGET_SAMPLE_RATE 16000
#define TARGET_CHANNELS 1
#define TARGET_BITS_PER_SAMPLE 16

// Task handle for conversion
TaskHandle_t conversionTaskHandle = NULL;

// -------------------------- SD Setup --------------------------------------
void SD_setup() {
    pinMode(SD_CS, OUTPUT);
    digitalWrite(SD_CS, HIGH);
    delay(10);
    SPI.begin(SD_SCK, SD_MISO, SD_MOSI, SD_CS);
    SPI.setFrequency(4000000); // 4MHz is reasonable for SD
    delay(100);
    if (!SD.begin(SD_CS)) {
        Serial.println("SD card mount failed!");
        while (1) delay(1000); // Halt if SD fails
    }
    Serial.println("SD card mounted successfully.");
}

// -------------------------- WAV conversion --------------------------------
void wavConversion(void *parameter) {

    File mp3File = SD.open(mp3Filename, FILE_READ);
    if (!mp3File || mp3File.size() == 0) {
        Serial.println("Failed to open MP3 file or file is empty: " + String(mp3Filename));
        vTaskDelete(NULL);
        return;
    }
    Serial.printf("MP3 File Size: %d bytes\n", mp3File.size());

    if (SD.exists(wavFilename)) {
        SD.remove(wavFilename);
    }
    File wavFile = SD.open(wavFilename, FILE_WRITE);
    if (!wavFile) {
        Serial.println("Failed to create WAV file: " + String(wavFilename));
        mp3File.close();
        vTaskDelete(NULL);
        return;
    }

    Serial.println("Free Heap Before Conversion: " + String(ESP.getFreeHeap()));
    
    EncodedAudioStream mp3Decoder(&mp3File, new MP3DecoderMAD());
    mp3Decoder.begin();
    
    // Get audio info directly from the MP3 file
    AudioInfo sourceInfo = mp3Decoder.audioInfo();
    Serial.printf("Decoder Reported - Sample Rate: %d Hz, Channels: %d, Bits per Sample: %d\n", 
                  sourceInfo.sample_rate, sourceInfo.channels, sourceInfo.bits_per_sample);

    // Validate and adjust if necessary (based on known issues with MAD)
    if (sourceInfo.sample_rate != 22050 || sourceInfo.channels != 1 || sourceInfo.bits_per_sample != 16) {
        Serial.println("Warning: Decoder misreported MP3 metadata. Applying correction based on prior validation.");
        sourceInfo.sample_rate = 22050;  // Default to VLC-confirmed value
        sourceInfo.channels = 1;         // Default to mono
        sourceInfo.bits_per_sample = 16; // Default to 16-bit
    }
    Serial.printf("Corrected Source Info - Sample Rate: %d Hz, Channels: %d, Bits per Sample: %d\n", 
                  sourceInfo.sample_rate, sourceInfo.channels, sourceInfo.bits_per_sample);
    
    AudioInfo targetInfo(TARGET_SAMPLE_RATE, TARGET_CHANNELS, TARGET_BITS_PER_SAMPLE);
    Serial.printf("Target Info - Sample Rate: %d Hz, Channels: %d, Bits per Sample: %d\n", 
                  targetInfo.sample_rate, targetInfo.channels, targetInfo.bits_per_sample);
    
    // Write WAV header (placeholder)
    uint32_t sampleRate = targetInfo.sample_rate;
    uint16_t channels = targetInfo.channels;
    uint16_t bitsPerSample = targetInfo.bits_per_sample;
    uint32_t byteRate = sampleRate * channels * (bitsPerSample / 8);
    uint16_t blockAlign = channels * (bitsPerSample / 8);
    uint32_t dataSize = 0;
    
    wavFile.write((uint8_t*)"RIFF", 4);
    wavFile.write((uint8_t*)&dataSize, 4); 
    wavFile.write((uint8_t*)"WAVE", 4);
    wavFile.write((uint8_t*)"fmt ", 4);
    uint32_t fmtSize = 16;
    wavFile.write((uint8_t*)&fmtSize, 4);
    uint16_t audioFormat = 1; // PCM
    wavFile.write((uint8_t*)&audioFormat, 2);
    wavFile.write((uint8_t*)&channels, 2);
    wavFile.write((uint8_t*)&sampleRate, 4);
    wavFile.write((uint8_t*)&byteRate, 4);
    wavFile.write((uint8_t*)&blockAlign, 2);
    wavFile.write((uint8_t*)&bitsPerSample, 2);
    wavFile.write((uint8_t*)"data", 4);
    wavFile.write((uint8_t*)&dataSize, 4); 


    FormatConverterStream converter(wavFile);
    converter.begin(sourceInfo, targetInfo);
    uint8_t* buffer = (uint8_t*)malloc(4096);
    if (!buffer) {
        Serial.println("Failed to allocate buffer!");
        mp3File.close();
        wavFile.close();
        vTaskDelete(NULL);
        return;
    }
    size_t totalBytesCopied = 0;
    const size_t chunkSize = 1024 * 32;
    while (mp3Decoder.available()) {
        size_t bytesRead = mp3Decoder.readBytes(buffer, 4096);
        if (bytesRead == 0) {
            Serial.println("Warning: No more data to read, stopping early. Available: " + String(mp3Decoder.available()));
            break;
        }
        size_t bytesWritten = converter.write(buffer, bytesRead);
        totalBytesCopied += bytesWritten;
        if (totalBytesCopied % chunkSize == 0) {
            Serial.printf("Progress: Copied %d bytes so far\n", totalBytesCopied);
        }

        delay(1);
    }
    Serial.printf("Total Copied %d bytes during conversion.\n", totalBytesCopied);

    free(buffer);
    converter.flush();
    delay(10);
    wavFile.flush();

    // Update WAV header
    uint32_t fileSize = totalBytesCopied + 36;
    uint32_t dataSizeFinal = totalBytesCopied;
    wavFile.seek(4);
    wavFile.write((uint8_t*)&fileSize, 4);
    wavFile.seek(40);
    wavFile.write((uint8_t*)&dataSizeFinal, 4);

    converter.end();
    mp3File.close();
    wavFile.close();

    File checkFile = SD.open(wavFilename, FILE_READ);
    Serial.printf("WAV File Size: %d bytes\n", checkFile.size());
    checkFile.close();

    Serial.println("Free Heap After Conversion: " + String(ESP.getFreeHeap()));
    Serial.println("Conversion complete: " + String(wavFilename));

    vTaskDelete(NULL);
}

void wavConversionTask() {
    xTaskCreate(
        wavConversion,    // Corrected function name
        "ConversionTask",
        8192,
        NULL,
        1,
        &conversionTaskHandle
    );
}

// -------------------------- Setup -----------------------------------------
void setup() {
    Serial.begin(115200);

    delay(10);
    SD_setup();      
    #ifdef DEBUG_MODE
      Serial.println("Free Heap B4 we continue " + String(ESP.getFreeHeap()));
    #endif
    
    wavConversionTask();
    
}

// -------------------------- Loop -----------------------------------------
void loop() {

}

so the problem i was having is MAD was mi reporting that the mp3 was 44100 but it was 22050 which was giving issues so i Instead, manually wrote t the WAV header and let FormatConverterStream write the PCM data directly.

i find your MP3 header parser and was digging thru it to use so i dont have to hard code the sample rate in case i get a mp3 that is 24000 or 32000 or something all api's do it a bit different i want it so i have everything universal if need be... then my OCD can move on lol

your idea prob would have done this in 10 lines of code lol, but i am trying lol... i did years of php programming and with ffmpeg (mostly batch files) as well so i have a tiny grasp of what i want to do, just moving to a new language programming has taken me some time... soon i wont be bugging u to death!

the results

but if you can show me something cleaner and shorter please do!

[pschatzmann]

I forgot to mention: the audio info is only available after you start decoding and not when you call begin. If you build the chain as described, the format notifications are all handled automatically: So be careful where you place the copy!

With File - copy -> EncodedAudioStream(mp3) -> FormatConverterStream -> EncodedAudioStream(wav) -> File
The decoder informs the FormatConverterStream(decoder) with the actual rate which confirms the FormatConverterStream(encoder) with the target rate.

With your flow you need to manage this yourself.

Something like this should to the job :

void wavConversion(void *parameter) {
    File mp3File = SD.open(mp3Filename, FILE_READ);
    File wavFile = SD.open(wavFilename, FILE_WRITE);
    MP3DecoderHelix mp3;
    WAVEncoder wav
    EncodedAudioStream wavDecoder(&wavFile, &wav); // encoding to wav
    FormatConverterStream converter(wavDecoder); // format convert to 16000 to wav file
    EncodedAudioStream mp3Decoder(&converter, &mp3); // decode mp3 to converter
    AudioInfo sourceInfo(44100,1,16); // values not really important in this case 
    AudioInfo targetInfo(16000,1,16);
    // start all objects
    wavDecoder.begin();
    mp3Decoder.begin();
    converter.begin(sourceInfo, targetInfo);
    // process chain: copy all data
    StreamCopy copier(mp3Decoder, mp3_file);
    copier.copyAll();
    // close files
    mp3File.close();
    wavFile.close();
}

It is important to close the files. My objects are implementing RAII, so if there are no bugs they should clean up themsleves after leaving the scope.

You should also add some error handling for the file open and all begin() calls.

[hammerheaddown]

i will be testing in the AM!

[pschatzmann]

I was testing some decoding with the setup of using stack variables w/o calling end;
I had to commit some corrections to the I2SStream and EncodedAudioStream to call end() in the destructor to make sure that the resources are released automatically.

[hammerheaddown]

i had to make a few adjustments and add to the wavConversionTask() buffer cause was getting the ol guru meditation fun lol

anyways i got it working with :

void wavConversion(void *parameter) {
    Serial.println("Starting wavConversion");

    File mp3File = SD.open(mp3Filename, FILE_READ);
    if (!mp3File || mp3File.size() == 0) {
        Serial.println("Failed to open MP3 file or file is empty: " + String(mp3Filename));
        vTaskDelete(NULL); // Safe to delete here since no resources are open
        return;
    }
    Serial.printf("MP3 File Size: %d bytes\n", mp3File.size());

    if (SD.exists(wavFilename)) {
        SD.remove(wavFilename);
    }
    File wavFile = SD.open(wavFilename, FILE_WRITE);
    if (!wavFile) {
        Serial.println("Failed to create WAV file: " + String(wavFilename));
        mp3File.close();
        vTaskDelete(NULL); // Safe to delete here after closing mp3File
        return;
    }

    Serial.println("Free Heap Before Conversion: " + String(ESP.getFreeHeap()));
    Serial.println("Initializing decoders");

    MP3DecoderHelix mp3;
    WAVEncoder wav;
    EncodedAudioStream wavDecoder(&wavFile, &wav);
    FormatConverterStream converter(wavDecoder);
    EncodedAudioStream mp3Decoder(&converter, &mp3);
    AudioInfo sourceInfo(44100, 1, 16);
    AudioInfo targetInfo(16000, 1, 16);

    Serial.println("Beginning streams");
    wavDecoder.begin();
    mp3Decoder.begin();
    converter.begin(sourceInfo, targetInfo);

    Serial.println("Starting copy");
    StreamCopy copier(mp3Decoder, mp3File);
    copier.copyAll();
    Serial.println("Copy complete");

    // Explicitly end streams to ensure all buffers are flushed
    mp3Decoder.end();
    converter.end();
    wavDecoder.end();

    Serial.println("Closing files");
    mp3File.close();
    wavFile.close();

    Serial.println("Conversion task complete");
    vTaskDelete(NULL); // Delete the task after all cleanup
}

void wavConversionTask() {
    xTaskCreate(
        wavConversion,
        "ConversionTask",
        16384,  // Keep increased stack size
        NULL,
        1,
        &conversionTaskHandle
    );
}

i will follow this up with the full working code to contact deepgram TTS

[hammerheaddown]

Full working code

Fetching MP3 and converting to WAV while listening thru MAX98357 I2S Audio Amplifier

// Suppress annoying library warnings
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wformat"
#pragma GCC diagnostic ignored "-Wdelete-non-virtual-dtor"

#include "AudioTools.h"
#include "AudioTools/AudioCodecs/CodecMP3Helix.h"
#include "AudioTools/AudioCodecs/CodecWAV.h"
#include <WiFi.h>
#include <WiFiUdp.h>
#include <WiFiClientSecure.h>
#include <HTTPClient.h>
#include <ArduinoJson.h>
#include "freertos/FreeRTOS.h"
#include "freertos/queue.h"
#include <chrono> // For timekeeping
#include <SD.h>
#include <SPI.h>


// -------------------------- AMP Pin Setup -------------------------------------------
#define I2S_BCLK GPIO_NUM_5
#define I2S_DOUT GPIO_NUM_6
#define I2S_LRC  GPIO_NUM_14
i2s_chan_handle_t tx_handle;

// -------------------------- SD Pin Setup ----------------------------------------------
#define SD_MISO GPIO_NUM_13
#define SD_MOSI GPIO_NUM_11
#define SD_SCK GPIO_NUM_12
#define SD_CS GPIO_NUM_10

#define SAMPLE_RATE 16000 
AudioInfo info(SAMPLE_RATE, 1, 16);

// -------------------------- Wifi Credentials --------------------------------------------
const char *ssid = "";
const char *password = "";

// -------------------------- Deepgram Credentials -------------------------------------
const char *deepgramApiKey = "";
#define STT_LANGUAGE "en"
#define TIMEOUT_DEEPGRAM 12
#define STT_KEYWORDS "&keywords=Gigolo&keywords=Google"
String optional_param = "?model=nova-2-general";

// -------------------------- Audio Tools Setup ------------------------------------------
URLStream url;
I2SStream i2s;
EncodedAudioStream mp3Decoder(&i2s, new MP3DecoderHelix());
StreamCopy copier;

// -------------------------- Global Variables for Conversion ---------------------------
const char* mp3Filename = "/recordings/temp.mp3";
const char* wavFilename = "/recordings/output.wav";
TaskHandle_t conversionTaskHandle = NULL;

// -----------------------------------------------------------------------------------------

void SD_setup() {
    pinMode(SD_CS, OUTPUT);
    digitalWrite(SD_CS, HIGH);
    delay(10);
    SPI.begin(SD_SCK, SD_MISO, SD_MOSI, SD_CS);
    SPI.setFrequency(4000000); // 4MHz is reasonable for SD
    delay(100);
    if (!SD.begin(SD_CS)) {
        Serial.println("SD card mount failed!");
        while (1) delay(1000); // Halt if SD fails
    }
    Serial.println("SD card mounted successfully.");
}

void wavConversion(void *parameter) {
    Serial.println("Starting wavConversion");

    File mp3File = SD.open(mp3Filename, FILE_READ);
    if (!mp3File || mp3File.size() == 0) {
        Serial.println("Failed to open MP3 file or file is empty: " + String(mp3Filename));
        vTaskDelete(NULL);
        return;
    }
    Serial.printf("MP3 File Size: %d bytes\n", mp3File.size());

    if (SD.exists(wavFilename)) {
        SD.remove(wavFilename);
    }
    File wavFile = SD.open(wavFilename, FILE_WRITE);
    if (!wavFile) {
        Serial.println("Failed to create WAV file: " + String(wavFilename));
        mp3File.close();
        vTaskDelete(NULL);
        return;
    }

    Serial.println("Free Heap Before Conversion: " + String(ESP.getFreeHeap()));
    Serial.println("Initializing decoders");

    MP3DecoderHelix mp3;
    WAVEncoder wav;
    EncodedAudioStream wavDecoder(&wavFile, &wav);
    FormatConverterStream converter(wavDecoder);
    EncodedAudioStream mp3Decoder(&converter, &mp3);
    AudioInfo sourceInfo(44100, 1, 16); // Assuming MP3 is 44.1kHz
    AudioInfo targetInfo(SAMPLE_RATE, 1, 16);

    Serial.println("Beginning streams");
    wavDecoder.begin();
    mp3Decoder.begin();
    converter.begin(sourceInfo, targetInfo);

    Serial.println("Starting copy");
    StreamCopy copier(mp3Decoder, mp3File);
    copier.copyAll();
    Serial.println("Copy complete");

    mp3Decoder.end();
    converter.end();
    wavDecoder.end();

    Serial.println("Closing files");
    mp3File.close();
    wavFile.close();

    Serial.println("Conversion task complete");
    vTaskDelete(NULL);
}

void wavConversionTask() {
    xTaskCreate(
        wavConversion,
        "ConversionTask",
        16384,
        NULL,
        1,
        &conversionTaskHandle
    );
}

void playWAVFile(const char* filename) {
    Serial.println("Starting WAV playback");

    File wavFile = SD.open(filename, FILE_READ);
    if (!wavFile || wavFile.size() == 0) {
        Serial.println("Failed to open WAV file or file is empty: " + String(filename));
        return;
    }
    Serial.printf("WAV File Size: %d bytes\n", wavFile.size());

    // Configure I2S
    auto cfg = i2s.defaultConfig(TX_MODE);
    cfg.pin_bck = I2S_BCLK;
    cfg.pin_ws = I2S_LRC;
    cfg.pin_data = I2S_DOUT;
    cfg.i2s_format = I2S_STD_FORMAT;
    cfg.sample_rate = SAMPLE_RATE;
    cfg.channels = 1;
    cfg.bits_per_sample = 16;
    i2s.begin(cfg);

    // Use raw I2SStream since WAV is already decoded
    StreamCopy wavCopier(i2s, wavFile);
    wavCopier.copyAll();

    i2s.end();
    wavFile.close();
    Serial.println("WAV playback complete");
}

void deepgramTTS(const char* textToSpeech) {
    char escapedText[512];
    int j = 0;
    for (int i = 0; textToSpeech[i] != '\0'; i++) {
        if (textToSpeech[i] == '"') {
            escapedText[j++] = '\\';
        }
        escapedText[j++] = textToSpeech[i];
    }
    escapedText[j] = '\0';

    char requestBody[1024];
    JsonDocument doc;
    doc["text"] = escapedText;
    serializeJson(doc, requestBody);

    Serial.println("RequestBody: " + String(requestBody));
    Serial.println("Free Heap before TTS fetch: " + String(ESP.getFreeHeap()));

    // Open file for writing
    if (SD.exists(mp3Filename)) {
        SD.remove(mp3Filename);
    }
    File mp3File = SD.open(mp3Filename, FILE_WRITE);
    if (!mp3File) {
        Serial.println("Failed to open " + String(mp3Filename) + " for writing");
        return;
    }

    // HTTP setup
    HTTPClient http;
    http.begin("https://api.deepgram.com/v1/speak?model=aura-luna-en");
    http.addHeader("Authorization", "Token " + String(deepgramApiKey));
    http.addHeader("Content-Type", "application/json");

    int httpCode = http.POST(requestBody);
    Serial.print("HTTP Response Code: ");
    Serial.println(httpCode);

    if (httpCode == HTTP_CODE_OK) {
        Stream& httpStream = http.getStream();
        const size_t bufferSize = 2048; // Increased buffer size
        uint8_t buffer[bufferSize];
        size_t totalBytes = 0;
        unsigned long lastDataTime = millis();
        const unsigned long timeout = 10000; // 10-second timeout

        // Get expected content length (if provided)
        int contentLength = http.getSize();
        Serial.println("Expected Content-Length: " + String(contentLength) + " bytes");

        // Fetch and save MP3 with timeout
        while (millis() - lastDataTime < timeout) {
            if (httpStream.available()) {
                size_t bytesRead = httpStream.readBytes(buffer, bufferSize);
                if (bytesRead > 0) {
                    mp3File.write(buffer, bytesRead);
                    totalBytes += bytesRead;
                    lastDataTime = millis(); // Reset timeout on data
                    Serial.println("Fetched " + String(totalBytes) + " bytes so far");
                }
            } else {
                delay(10); // Brief delay to avoid busy-waiting
            }
        }

        mp3File.close();
        http.end();

        if (totalBytes == 0) {
            Serial.println("No MP3 data fetched");
            SD.remove(mp3Filename);
            return;
        }

        Serial.println("MP3 fetched and saved to " + String(mp3Filename) + ": " + String(totalBytes) + " bytes");

        // Verify against Content-Length if available
        if (contentLength > 0 && totalBytes < contentLength) {
            Serial.println("Warning: Fetched " + String(totalBytes) + " bytes, but expected " + String(contentLength) + " bytes");
        }

        // Convert MP3 to WAV
        wavConversionTask();
        while (eTaskGetState(conversionTaskHandle) != eDeleted) {
            delay(100);
        }

        // Play the WAV file
        playWAVFile(wavFilename);

    } else {
        Serial.printf("[HTTP] POST TTS... failed, error: %s\n", http.errorToString(httpCode).c_str());
        Serial.println("Response: " + http.getString());
        mp3File.close();
        SD.remove(mp3Filename);
    }
}

void setup() {
    Serial.begin(115200);
    delay(10);

    SD_setup();
    #ifdef DEBUG_MODE
    Serial.println("Free Heap after SD setup: " + String(ESP.getFreeHeap()));
    #endif

    WiFi.begin(ssid, password);
    while (WiFi.status() != WL_CONNECTED) {
        delay(1000);
    }
    Serial.println("Connected to WiFi");
}

void loop() {
    deepgramTTS("I am truly sorry for the repeated errors. I am still under development and learning, but this is a particularly bad mistake that I need to address. Thank you for your patience and for pointing out my error.");
    delay(1000000);
}

this should work just fine using any mp3 downloaded off any TTS providers

I would def take out of the loop, i just have it there for simplicity sakes

[hammerheaddown]

thanks @pschatzmann for that code, it def helped clean it up and save a bunch of space in the sketch

[hammerheaddown]

@pschatzmann one quick question is there a quick and easy way to check that wav file after it plays to see the sample rate etc? maybe even duration. i want to be 100% it is 16000, 1, 16

thanks!

[pschatzmann]

If you set the log level to Info you should see it in the log