AD2P as source in tasks

[p-jbouras]

Problem Description

I'm trying to play an mp3 file from sdcard using tasks to a bluetooth speaker and i was able to play the sound. After playing the mp3 i run the hibernate-method to close the resouces, but it get blocked on the "a2dp.end();" with the following output:

[I] AudioSourceSDFAT.h : 90 - void audio_tools::AudioSourceSDFAT<AudioFs, AudioFile>::end() [with AudioFs = SdFs; AudioFile = FsFile]
I (63820) gpio: GPIO[14]| InputEn: 1| OutputEn: 0| OpenDrain: 0| Pullup: 0| Pulldown: 0| Intr:0 
I (63821) gpio: GPIO[13]| InputEn: 1| OutputEn: 0| OpenDrain: 0| Pullup: 0| Pulldown: 0| Intr:0 
I (63829) gpio: GPIO[12]| InputEn: 1| OutputEn: 0| OpenDrain: 0| Pullup: 0| Pulldown: 0| Intr:0 
[I] AudioEncoded.h : 185 - virtual void audio_tools::EncodedAudioOutput::end()
[I] MetaDataID3.h : 595 - virtual void audio_tools::MetaDataID3::end()
[I] AudioPlayer.h : 234 - reset codec
[I] CodecMP3Helix.h : 82 - virtual bool audio_tools::MP3DecoderHelix::begin()
I (63876) BT_AV: disconect a2d: 11:22:33:44:55:66
I (63876) BT_AV: ==> a2dp esp_a2d_source_disconnect from: 11:22:33:44:55:66
D (67403) BT_API: bt_app_work_dispatch event 0xff00, param len 0
D (67404) BT_API: app_task_handler, signal: 0x1, event: 0xff00
D (67404) BT_AV: app_work_dispatched
I (67408) BT_AV: bt_app_av_sm_hdlr state CONNECTED, evt 0xff00
D (67415) BT_AV: process_user_state_callbacks
D (67419) BT_AV: bt_app_av_state_connected_hdlr evt 65280
D (67425) BT_AV: bt_app_av_media_proc evt 65280
I (67429) BT_AV: a2dp media started
D (77403) BT_API: bt_app_work_dispatch event 0xff00, param len 0
D (77403) BT_API: app_task_handler, signal: 0x1, event: 0xff00
D (77404) BT_AV: app_work_dispatched
I (77408) BT_AV: bt_app_av_sm_hdlr state CONNECTED, evt 0xff00
D (77414) BT_AV: process_user_state_callbacks
D (77418) BT_AV: bt_app_av_state_connected_hdlr evt 65280
D (77424) BT_AV: bt_app_av_media_proc evt 65280
I (77429) BT_AV: a2dp media started

I need to free the resources because the esp32 goes after playing the mp3 to light sleep mode and on wakeup the playback should start again.

Any idea what the problem is? or how to reuse BluetoothA2DPSource after a light sleep?

Best regards

Device Description

ESP32-D0WDQ6-V3 (Dual-core, 240MHz) with 16MB Flash and 8MB PSRAM.

Sketch

The class implementing the ad2p logic looks like this:

#ifndef BLUETOOTH_H
#define BLUETOOTH_H

#include "device.h"

#define USE_HELIX
#define USE_A2DP
#define USE_SDFAT

#include "AudioTools.h"
#include "AudioTools/AudioCodecs/CodecMP3Helix.h"
#include "AudioTools/Communication/A2DPStream.h"
#include "AudioTools/Concurrency/RTOS.h"
#include "AudioTools/Disk/AudioSourceSDFAT.h"
#include <SPI.h>
#include <stdint.h>

#define SD_SPI_CS_PIN 4

extern BufferRTOS<uint8_t> buffer;

int32_t dataCallback(uint8_t *data, int bytes);

class BluetoothSpeaker : public Device {
  public:
    BluetoothSpeaker(const char *device, const char *file, uint32_t connectionTimeout = 15000, float defaultVolume = 0.5f, float volumeStep = 0.1f) : source("/", "mp3", SD_SPI_CS_PIN, 25, SHARED_SPI), out(buffer), player(source, out, decoder) {
        this->device = device;
        this->file = file;
        this->connectionTimeout = connectionTimeout;
        this->defaultVolume = defaultVolume;
        this->volumeStep = volumeStep;
    }

  private:
    AudioSourceSDFAT<SdFs, FsFile> source;
    MP3DecoderHelix decoder;
    QueueStream<uint8_t> out;
    AudioPlayer player;
    BluetoothA2DPSource a2dp;

    const char *device = nullptr;
    const char *file = nullptr;
    uint32_t connectionTimeout;
    float defaultVolume;
    float volumeStep;

    volatile bool stopRequested = false;
    TaskHandle_t taskHandle = nullptr;

    static bool parse_mac(const char *str, esp_bd_addr_t addr) {
        return sscanf(str, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx", &addr[0], &addr[1], &addr[2], &addr[3], &addr[4], &addr[5]) == 6;
    }

    /// converts a esp_bd_addr_t to a string - the string is 18 characters long!
    static const char *to_str(esp_bd_addr_t bda) {
        static char bda_str[18];
        sprintf(bda_str, "%02x:%02x:%02x:%02x:%02x:%02x", bda[0], bda[1], bda[2], bda[3], bda[4], bda[5]);
        return (const char *)bda_str;
    }

  protected:
    void static startPlayingTask(void *pvParameters) {
        auto *self = static_cast<BluetoothSpeaker *>(pvParameters);
        self->doStartPlaying();
    }

    void static stopPlayingTask(void *pvParameters) {
        auto *self = static_cast<BluetoothSpeaker *>(pvParameters);
        self->doStopPlaying();
    }

    void doStartPlaying() {
        buffer.resize(15 * 1024);
        out.begin(95);
        player.setDelayIfOutputFull(0);
        player.setVolume(getVolume());
        player.begin();
        a2dp.set_data_callback(dataCallback);

        bool connected = a2dp.reconnect();
        if (!connected) {
            if (taskHandle != nullptr) {
                vTaskDelete(taskHandle);
                taskHandle = nullptr;
            }
            return;
        }

        if (!player.setPath(this->file)) {
            if (taskHandle != nullptr) {
                vTaskDelete(taskHandle);
                taskHandle = nullptr;
            }
            return;
        }

        stopRequested = false;
        player.play();
        while (player.copy() > 0 && !stopRequested) {
            vTaskDelay(1);
        }
        player.stop();

        if (taskHandle != nullptr) {
            vTaskDelete(taskHandle);
            taskHandle = nullptr;
        }
    }
	
    void doStopPlaying() {
        stopRequested = true;
        vTaskDelete(NULL);
    }

    static bool ssidCallback(const char *ssid, esp_bd_addr_t address, int rssi) {
        Serial.printf("SSID: %s, MAC: %s\n", ssid, to_str(address));
        return false;
    }

  public:

    void init() {
        a2dp.set_ssid_callback(ssidCallback);
        a2dp.start();
    }

    bool connect() {
        AudioToolsLogger.begin(Serial, AudioToolsLogLevel::Info);

        esp_bd_addr_t addr;
        parse_mac(mac.c_str(), "11:22:33:44:55:66");
        a2dp.set_auto_reconnect(addr);
        a2dp.set_auto_reconnect(true);

        while (!a2dp.is_connected()) {
            delay(1000);
        }

        return a2dp.is_connected();
    }

    bool isPlaying() {
        if (taskHandle == nullptr) {
            return false;
        }
        eTaskState state = eTaskGetState(taskHandle);
        return state != eDeleted && state != eInvalid;
    }

    void startPlaying() {
        xTaskCreatePinnedToCore(startPlayingTask, "startPlayingTask", 12000, this, 2, &taskHandle, 1);
    }

    void stopPlaying() {
        xTaskCreatePinnedToCore(stopPlayingTask, "stopPlayingTask", 12000, this, 2, NULL, 1);
    }

    void hibernate() {
        source.end();
        player.end();

        a2dp.set_auto_reconnect(false);
        a2dp.disconnect();
        a2dp.cancel_discovery();
        a2dp.end();
    }

};

#endif

Other Steps to Reproduce

No response

Provide your Version of the EP32 Arduino Core (or the IDF Version)

v5.2.2

I have checked existing issues, discussions and online documentation (incl. the Wiki)

• I confirm I have checked existing issues, discussions and online documentation (incl. the Wiki)

[pschatzmann]

I am sorry, but your whole processing logic doen't make any sense to me.
What exactly are you trying to achieve ?

[p-jbouras]

I start on the setup method the ad2p and call the hibernate() before going to light sleep mode and it is blocking.

#include "bluetooth.h"

#include "SPI.h"
#include <SdFat.h>

TimerHandle_t idleTimer;
constexpr uint32_t IDLE_TIMEOUT_MS = 15000;

volatile bool enterIdleState = false;

void handleIdle();

void idleTimeout(TimerHandle_t xTimer) {
    enterIdleState = true;
}

void notifyActivity() {
    xTimerReset(idleTimer, 0);
}

BluetoothSpeaker bluetoothSpeaker("MyMusic", "sample.mp3");

void handleIdle() {
    enterIdleState = false;
    bluetoothSpeaker.hibernate();
    lightSleep(30000);
}

void main_setup() {
    idleTimer = xTimerCreate("Idle",                         //
                             pdMS_TO_TICKS(IDLE_TIMEOUT_MS), //
                             pdFALSE,                        // one-shot
                             NULL,                           //
                             idleTimeout);

    xTimerStart(idleTimer, 0);

    bluetoothSpeaker.init();
    bluetoothSpeaker.connect();
    bluetoothSpeaker.startPlaying();
}

void main_loop() {
    if (bluetoothSpeaker.isPlaying()) {
        notifyActivity();
    }

    if (enterIdleState) {
        handleIdle();
    }

    delay(10);
}

[pschatzmann]

yes, but I don't think there is any need to call end.

In any case remember that all API calls are asynchonous, you would need to wait for the last action to complete before advancing:
do this in sequency is a really bad idea:

    a2dp.disconnect();
    a2dp.cancel_discovery();
    a2dp.end();
    lightSleep(30000);

You need to wait for each step to complete before going to the next one...

[p-jbouras]

So I need to add some delay to handle this? Is there no synchronous method in A2DPSource that manages this automatically?

Or do you know if there is any example code doing the cleanup process?

[pschatzmann]

That would be a way though quite un-save. The right way would be via the corresponding status getters or via event handlers.
e.g. while(get_connection_state()!=ESP_A2D_CONNECTION_STATE_DISCONNECTED) delay(100);

[p-jbouras]

I will try to adapt the calls.

The fact that most methods are asynchronus is a very important hint

[p-jbouras]

I have added polling of the connection state but its blocking in disconnect()

       a2dp.disconnect(); <------- BLOCKING
        while (a2dp.get_connection_state() != ESP_A2D_CONNECTION_STATE_DISCONNECTED) {
            delay(100);
        }

in the disconnect() method:

/// Closes the connection
void BluetoothA2DPCommon::disconnect() {
    ESP_LOGI(BT_AV_TAG, "disconect a2d: %s", to_str(last_connection));

    is_target_status_active = false;
    // Prevent automatic reconnect
    is_autoreconnect_allowed = false;

    esp_err_t status = esp_a2d_disconnect(last_connection); <------- BLOCKING
    if (status == ESP_FAIL) {
        ESP_LOGE(BT_AV_TAG, "Failed disconnecting to device!");
    }
}

I can hear the device getting disconnected, but maybe the esp32 is handling it.

I did also found that the a2dp.end() is doing the same, but using the 00:00:00:00:00:00 MAC adress which is may be not correct:

void BluetoothA2DPCommon::end(bool release_memory) {
    ESP_LOGI(BT_AV_TAG, "%s", __func__);
    // delay which prevents a crash when log level Warning or Error
    int wait_ms = 50;
    // reconnect should not work after end
    is_start_disabled = false;
    clean_last_connection();  <--------- SET MAC TO 00:00:00:00:00:00
    log_free_heap();

    // Disconnect and wait
    int limit = A2DP_DISCONNECT_LIMIT;
    if (is_connected()) {
        disconnect(); <------------- Disconnect against "00:00:00:00:00:00"?
        while (get_connection_state() != ESP_A2D_CONNECTION_STATE_DISCONNECTED) {
            delay_ms(100);
            if (limit-- < 0) {
                ESP_LOGW(BT_AV_TAG, "Waiting for Disconnect has timed out");
                break;
            };
        }
    }

I (179156) BT_AV: Available Heap: 4179667
I (179160) BT_AV: disconnect a2dp: 00:00:00:00:00:00
I (179166) BT_AV: ==> a2dp esp_a2d_source_disconnect from: 00:00:00:00:00:00
E (192457) BT_APPL: bta_av_str_stopped:audio_open_cnt=1, p_data 0x0
W (279385) BT_AV: Waiting for Disconnect has timed out

I found that a2dp.disconnect() is not blocking if called within a task.

Is there some point where i can debug the events?

[pschatzmann]

I committed a correction.

Set the logger to debug level to see more details...

[p-jbouras]

I have pulled the change but it is always blocking inside and outside the task.

This is the log while disconnecting and there is a supecious error message.

I (65532) BT_AV: disconect a2d: 11:22:33:44:55:66
I (65533) BT_AV: ==> a2dp esp_a2d_source_disconnect from: 11:22:33:44:55:66
D (67480) BT_API: bt_app_work_dispatch event 0xff00, param len 0
D (67481) BT_API: app_task_handler, signal: 0x1, event: 0xff00
D (67481) BT_AV: app_work_dispatched
I (67485) BT_AV: bt_app_av_sm_hdlr state CONNECTED, evt 0xff00
D (67491) BT_AV: process_user_state_callbacks
D (67496) BT_AV: bt_app_av_state_connected_hdlr evt 65280
D (67520) BT_API: bt_app_work_dispatch event 0xff00, param len 0
D (67520) BT_API: app_task_handler, signal: 0x1, event: 0xff00
D (67520) BT_AV: app_work_dispatched
I (67524) BT_AV: bt_app_av_sm_hdlr state CONNECTED, evt 0xff00
D (67531) BT_AV: process_user_state_callbacks
D (67535) BT_AV: bt_app_av_state_connected_hdlr evt 65280
E (71463) BT_APPL: bta_av_str_stopped:audio_open_cnt=1, p_data 0x0  <------------- ERROR
D (77480) BT_API: bt_app_work_dispatch event 0xff00, param len 0
D (77480) BT_API: app_task_handler, signal: 0x1, event: 0xff00
D (77481) BT_AV: app_work_dispatched
I (77485) BT_AV: bt_app_av_sm_hdlr state CONNECTED, evt 0xff00
D (77491) BT_AV: process_user_state_callbacks
D (77495) BT_AV: bt_app_av_state_connected_hdlr evt 65280
D (77520) BT_API: bt_app_work_dispatch event 0xff00, param len 0
D (77520) BT_API: app_task_handler, signal: 0x1, event: 0xff00
D (77520) BT_AV: app_work_dispatched
I (77524) BT_AV: bt_app_av_sm_hdlr state CONNECTED, evt 0xff00
D (77531) BT_AV: process_user_state_callbacks
D (77535) BT_AV: bt_app_av_state_connected_hdlr evt 65280
D (87480) BT_API: bt_app_work_dispatch event 0xff00, param len 0
D (87480) BT_API: app_task_handler, signal: 0x1, event: 0xff00
D (87481) BT_AV: app_work_dispatched
I (87485) BT_AV: bt_app_av_sm_hdlr state CONNECTED, evt 0xff00
D (87491) BT_AV: process_user_state_callbacks
D (87496) BT_AV: bt_app_av_state_connected_hdlr evt 65280
D (87520) BT_API: bt_app_work_dispatch event 0xff00, param len 0
D (87520) BT_API: app_task_handler, signal: 0x1, event: 0xff00
D (87520) BT_AV: app_work_dispatched
I (87524) BT_AV: bt_app_av_sm_hdlr state CONNECTED, evt 0xff00
D (87531) BT_AV: process_user_state_callbacks
D (87535) BT_AV: bt_app_av_state_connected_hdlr evt 65280
D (97480) BT_API: bt_app_work_dispatch event 0xff00, param len 0
D (97480) BT_API: app_task_handler, signal: 0x1, event: 0xff00
D (97481) BT_AV: app_work_dispatched
I (97484) BT_AV: bt_app_av_sm_hdlr state CONNECTED, evt 0xff00
D (97491) BT_AV: process_user_state_callbacks
D (97495) BT_AV: bt_app_av_state_connected_hdlr evt 65280
D (97520) BT_API: bt_app_work_dispatch event 0xff00, param len 0
D (97520) BT_API: app_task_handler, signal: 0x1, event: 0xff00
D (97520) BT_AV: app_work_dispatched
I (97524) BT_AV: bt_app_av_sm_hdlr state CONNECTED, evt 0xff00
D (97531) BT_AV: process_user_state_callbacks
D (97535) BT_AV: bt_app_av_state_connected_hdlr evt 65280

[pschatzmann]

I was running a test by calling disconnect() with a Serial println before and after the disconnect, so it was not hanging.
I was testing with Arduino Release v3.3.10 based on ESP-IDF v5.5.4

Try to make the simplest possible test case and use an actual ESP32 core...

[p-jbouras]

I did not find where the state "APP_AV_MEDIA_STATE_STOPPING" is set,

case APP_AV_MEDIA_STATE_STOPPING: {
      if (event == ESP_A2D_MEDIA_CTRL_ACK_EVT) {
        a2d = (esp_a2d_cb_param_t *)(param);
        if (a2d->media_ctrl_stat.cmd == ESP_A2D_MEDIA_CTRL_SUSPEND &&
            a2d->media_ctrl_stat.status == ESP_A2D_MEDIA_CTRL_ACK_SUCCESS) {
          ESP_LOGI(BT_AV_TAG,
                   "a2dp media stopped successfully, disconnecting...");
          s_media_state = APP_AV_MEDIA_STATE_IDLE;
          esp_a2d_source_disconnect(peer_bd_addr);
          s_a2d_state = APP_AV_STATE_DISCONNECTING;
        } else {
          ESP_LOGI(BT_AV_TAG, "a2dp media stopping...");
          esp_a2d_media_ctrl(ESP_A2D_MEDIA_CTRL_SUSPEND);
        }
      }
      break;
    }

As you can see the connect method is setting a state but disconnecting not:

esp_err_t esp_a2d_connect(esp_bd_addr_t peer) override {
    ESP_LOGI(BT_AV_TAG, "==> a2dp connecting to: %s", to_str(peer));
    s_media_state = 0;
    s_a2d_state = APP_AV_STATE_CONNECTING; <------------- State
    return esp_a2d_source_connect(peer);
  }

  esp_err_t esp_a2d_disconnect(esp_bd_addr_t peer) override {
    ESP_LOGI(BT_AV_TAG, "==> a2dp esp_a2d_source_disconnect from: %s",
             to_str(peer));
    //esp_a2d_media_ctrl(ESP_A2D_MEDIA_CTRL_SUSPEND);
    return esp_a2d_source_disconnect(peer);
  }

[pschatzmann]

Works as designed: esp_a2d_connect() is just initializing the state. The update of all states is handled by the event handlers....