A2DPStream

[FinnHansen]

Hi there.
I have made a MP3 player using A2DPStream and CodeMP3Helix, the is playing 1 song on select.
I would like to be able to read when the song end, just a boolen, but how do i do that.

[XPMonline]

Hi, i assume this can be done via function av_playback_changed(). If your current track reached end, this callback state will be ESP_AVRC_RN_TRACK_REACHED_END.
So somethink like this:

void avrc_rn_playstatus_callback(esp_avrc_playback_stat_t playback) {
  switch (playback) {
    case : ESP_AVRC_RN_TRACK_REACHED_END //track reached end
      endtrack = true;
      break;
     }
}

[pschatzmann]

I think this should rather go to the AudioTools ?
I assume you use the Copier: so just check the result. At the end it returns the number of copied bytes of 0

[NehalAR]

@FinnHansen can you share your code I am trying to stream mp3 (converted into PCM) but all I am getting is noise, may be your code might help

[pschatzmann]

The audio-tools has some examples for this e.g. using the audio player. Please note that if the decoding does not give the expected sample rate, you should resample to 44100.

Please note that some users has issues by having not enough RAM when using A2DP and a mp3 decoder, so monitor the RAM usage!

[NehalAR]

@pschatzmann, I am trying to run the basic player a2dp example in audio-tools but getting this error:

... fatal error: AudioBoard.h: No such file or directory
2 | #include "AudioBoard.h" // install audio-driver library

I found this ticket but it doesn't make sense to downgrade the esp32 core if that what it means

[pschatzmann]

You would not use this unless you have an AudioKit or LyraT board to determine the SD pins!

[NehalAR]

@pschatzmann so I am trying to test this code but getting continuous resets:

#include "AudioTools.h"
#include "AudioTools/AudioLibs/A2DPStream.h"
#include "AudioTools/Disk/AudioSourceSDFAT.h"
#include "AudioTools/AudioCodecs/CodecMP3Helix.h"
#include "AudioTools/AudioLibs/AudioBoardStream.h" // for SD Pins

int sck = 32, miso = 33, mosi = 4, cs = 14;

int buffer_count = 30;
int buffer_size = 512;
const char *startFilePath="/sdcard";
const char* ext="mp3";
AudioSourceSDFAT source(startFilePath, ext, 14);
MP3DecoderHelix decoder;
//Setup of synchronized buffer
SynchronizedNBuffer buffer(buffer_size,buffer_count, portMAX_DELAY, 10);
QueueStream<uint8_t> out(buffer); // convert Buffer to Stream
AudioPlayer player(source, out, decoder);
BluetoothA2DPSource a2dp;

// Provide data to A2DP
int32_t get_data(uint8_t *data, int32_t bytes) {
   size_t result_bytes = buffer.readArray(data, bytes);
   //LOGI("get_data_channels %d -> %d of (%d)", bytes, result_bytes , buffer.available());
   return result_bytes;
}

void setup() {
 Serial.begin(115200);
 AudioToolsLogger.begin(Serial, AudioToolsLogLevel::Info);
  SPI.begin(sck, miso, mosi, cs);
 // sd_active is setting up SPI with the right SD pins by calling 
//  SPI.begin(PIN_AUDIO_KIT_SD_CARD_CLK, PIN_AUDIO_KIT_SD_CARD_MISO, PIN_AUDIO_KIT_SD_CARD_MOSI, PIN_AUDIO_KIT_SD_CARD_CS);

 // start QueueStream
 out.begin();

 // setup player
 player.setDelayIfOutputFull(0);
 player.setVolume(0.1);
 player.begin();
 
 // fill buffer with some data
 player.getStreamCopy().copyN(5); 

 // start a2dp source
 Serial.println("starting A2DP...");
 a2dp.start_raw("RONIN (R-140)", get_data);  
 Serial.println("Started!");

}

void loop() {
 // decode data to buffer
 player.copy();
}

16:40:06.825 -> configsip: 153911750, SPIWP:0xee
16:40:06.825 -> clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
16:40:06.862 -> mode:DIO, clock div:1
16:40:06.862 -> load:0x3fff0030,len:4916
16:40:06.862 -> load:0x40078000,len:16492
16:40:06.862 -> load:0x40080400,len:4
16:40:06.862 -> load:0x40080404,len:3524
16:40:06.862 -> entry 0x400805b8
16:40:07.659 -> [ 37][I][esp32-hal-psram.c:102] psramAddToHeap(): PSRAM added to the heap.
16:40:07.691 -> [I] AudioPlayer.h : 336 - setVolume(0.100000)
16:40:07.691 -> [I] VolumeStream.h : 199 - setVolume: 0.100000 at 0
16:40:07.691 -> [I] VolumeStream.h : 199 - setVolume: 0.100000 at 1
16:40:07.691 -> [I] MetaDataID3.h : 578 - virtual void audio_tools::MetaDataID3::begin()
16:40:07.691 -> [I] AudioSourceSDFAT.h : 104 - selectStream SDFAT: 0
16:40:07.733 -> [I] AudioSourceSDFAT.h : 123 - -> selectStream: /sdcard/test.mp3
16:40:07.733 -> [I] StreamCopy.h : 57 - buffer_size=1024
16:40:07.733 -> [I] StreamCopy.h : 173 - StreamCopy::copy 1024 -> 1024 -> 1024 bytes - in 1 hops
16:40:08.875 -> ets Jul 29 2019 12:21:46
16:40:08.875 ->
16:40:08.875 -> rst:0x8 (TG1WDT_SYS_RESET),boot:0x17 (SPI_FAST_FLASH_BOOT)
16:40:08.911 -> configsip: 153911750, SPIWP:0xee
16:40:08.911 -> clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
16:40:08.911 -> mode:DIO, clock div:1
16:40:08.911 -> load:0x3fff0030,len:4916
16:40:08.911 -> load:0x40078000,len:16492
16:40:08.911 -> load:0x40080400,len:4
16:40:08.911 -> load:0x40080404,len:3524
16:40:08.911 -> entry 0x400805b8
16:40:09.727 -> [ 37][I][esp32-hal-psram.c:102] psramAddToHeap(): PSRAM added to the heap.
16:40:09.765 -> [I] AudioPlayer.h : 336 - setVolume(0.100000)
16:40:09.765 -> [I] VolumeStream.h : 199 - setVolume: 0.100000 at 0
16:40:09.765 -> [I] VolumeStream.h : 199 - setVolume: 0.100000 at 1
16:40:09.765 -> [I] MetaDataID3.h : 578 - virtual void audio_tools::MetaDataID3::begin()
16:40:09.765 -> [I] AudioSourceSDFAT.h : 104 - selectStream SDFAT: 0
16:40:09.765 -> [I] AudioSourceSDFAT.h : 123 - -> selectStream: /sdcard/test.mp3
16:40:09.808 -> [I] StreamCopy.h : 57 - buffer_size=1024
16:40:09.808 -> [I] StreamCopy.h : 173 - StreamCopy::copy 1024 -> 1024 -> 1024 bytes - in 1 hops
16:40:10.944 -> ets Jul 29 2019 12:21:46

[pschatzmann]

The simplest example would be to use the decoder on the input side: I just added this and was running a test

[NehalAR]

I am flashing it. Will get back to you.

[NehalAR]

@pschatzmann unfortunately it just keeps getting connected and disconnected repeatedly.

//  We use the decoding on the input side to provid pcm data

#include "SPI.h"
#include "SD.h"
#include "AudioTools.h"
#include "AudioTools/AudioLibs/A2DPStream.h"
#include "AudioTools/AudioCodecs/CodecMP3Helix.h"
//#include "AudioTools/AudioLibs/AudioBoardStream.h" // for SPI pins

int sck = 32; int miso = 33; int mosi = 4; int cs = 14;

File file;
MP3DecoderHelix mp3;  // or change to MP3DecoderMAD
EncodedAudioStream decoder(&file, &mp3);
BluetoothA2DPSource a2dp_source;

// callback used by A2DP to provide the sound data - usually len is 128 2 channel int16 frames
int32_t get_sound_data(uint8_t* data, int32_t size) {
  int32_t result = decoder.readBytes((uint8_t*)data, size);
  delay(1); // feed the dog
  return result;
}

// Arduino Setup
void setup(void) {
  Serial.begin(115200);
  AudioToolsLogger.begin(Serial, AudioToolsLogLevel::Info);

  // open file
  //SPI.begin(PIN_AUDIO_KIT_SD_CARD_CLK, PIN_AUDIO_KIT_SD_CARD_MISO, PIN_AUDIO_KIT_SD_CARD_MOSI, PIN_AUDIO_KIT_SD_CARD_CS);
  SPI.begin(sck, miso, mosi, cs);
  if (!SD.begin(cs)) {
    Serial.println("SD Card Initialization Failed!");
    return;
  }
  else
    Serial.println("SD Card Initialized!");

  file = SD.open("/sdcard/test.mp3", FILE_READ);
  if (!file) {
    Serial.println("file failed");
    stop();
  }

  // open decoder
  if (!decoder.begin()) {
    Serial.println("decoder failed");
    stop();
  }

  // start the bluetooth
  Serial.println("starting A2DP...");
  a2dp_source.set_data_callback(get_sound_data);
  // a2dp_source.set_volume(30);
  a2dp_source.start("RONIN (R-140)");  
}

// Arduino loop - repeated processing 
void loop() {
  delay(1000);
}

so I just used my previously working example (bt_music_sender) and it works just fine. so there has to be something conflicting in this code

#include "BluetoothA2DPSource.h"
#include <math.h> 
#include "FS.h"
#include "SD.h"
#include "SPI.h"

int sck = 32;
int miso = 33;
int mosi = 4;
int cs = 14;


File audioFile;
BluetoothA2DPSource a2dp_source;

bool fileStarted = false;

int32_t get_audio_data(Frame *frame, int32_t frame_count) {
  if (!audioFile) return 0;

  if (!fileStarted) {
    audioFile.seek(44);
    fileStarted = true;
  }

  int bytesRead = audioFile.read((uint8_t *)frame, frame_count * sizeof(Frame));
  if (bytesRead <= 0) {
    Serial.println("End of file, restarting...");
    audioFile.seek(44);
    return 0;
  }

  return bytesRead / sizeof(Frame);
}

void setup() {
  Serial.begin(115200);
  SPI.begin(sck, miso, mosi, cs);
  if (!SD.begin(cs)) {
    Serial.println("SD Card Initialization Failed!");
    return;
  }
  else
    Serial.println("SD Card Initialized!");


  audioFile = SD.open("/sdcard/test_WAV.wav", FILE_READ);
  if (!audioFile) {
    Serial.println("Failed to open audio file!");
    return;
  }

  Serial.println("WAV file opened successfully!");
  Serial.println("Starting Bluetooth A2DP Source...");
  a2dp_source.set_auto_reconnect(false);
  a2dp_source.set_data_callback_in_frames(get_audio_data);
  a2dp_source.set_volume(40);
  a2dp_source.start("RONIN (R-140)");
}

void loop() {
  delay(1000);
}

[NehalAR]

may be try to test this audio on your end?

[NehalAR]

@pschatzmann when I comment this line the connection/disconnection atleast doesn't happen.
// int32_t result = decoder.readBytes((uint8_t*)data, size);

[pschatzmann]

This is because you don't provide any data, so it gets disconnected: double check your logic and maybe return the requested size by setting the result to zeros if there is not data available.

[pschatzmann]

I was updating the examples to use the latest API and retested this one: I confirm that if you take the latest version, it should work.
The decoding example on the input side from above was missing the necessary setup of the internal queue to handle the huge mp3 pcm size values...

[NehalAR]

let me test this.

[NehalAR]

both examples still doesn't work for me. Did you test the mp3 I sent?