How can you play two sources at the same time without stuttering?

[timeylies]

So I'm using the Ai-Thinker ESP32 Audiokit as a Bluetooth receiver with a display and I want it to play sounds if I connect or disconnect from it

I wanted to use the flash but it does not have enough memory for the audio files

So I want to use an sd card with the files so I can play from it

But when I do it, the Bluetooth audio stutters and it doesn't sound good

Here is the code:
`#include <Preferences.h>
#include <Pushbutton.h>
#define USE_SDFAT
#include "RotaryEncoder.h"
#include "AudioTools.h"
#include "AudioLibs/AudioKit.h"
#include "AudioCodecs/CodecMP3Helix.h"
#include "AudioLibs/AudioA2DP.h"
#include "LiquidCrystal_PCF8574.h"

BluetoothA2DPSink a2dp_sink;
AudioKitStream kit;
Equilizer3Bands eq(kit);
ConfigEquilizer3Bands cfg_eq;
RotaryEncoder encoder(18, 23, RotaryEncoder::LatchMode::FOUR3);
Pushbutton encoderB(5);
Preferences prefs;
const char startFilePath = "/";
const char ext = "mp3";
SdSpiConfig sdcfg(PIN_AUDIO_KIT_SD_CARD_CS, DEDICATED_SPI, SD_SCK_MHZ(10) , &AUDIOKIT_SD_SPI);
AudioSourceSdFat source(startFilePath, ext, sdcfg);
MP3DecoderHelix decoder; // or change to MP3DecoderMAD
AudioPlayer player(source, kit, decoder);

LiquidCrystal_PCF8574 lcd(0x27);
//Millis - Previous Millis things
unsigned long pM;
unsigned long pM1;
//LCD - Backlight
bool LCDBacklight;
void toggleLCDBL() {
if (!LCDBacklight) {
LCDBacklight = true;
} else {
LCDBacklight = false;
}
lcd.setBacklight(LCDBacklight);
}
//LCD - Volume
byte zero[] = {
B00000,
B00000,
B00000,
B00000,
B00000,
B00000,
B00000,
B00000
};
byte one[] = {
B10000,
B10000,
B10000,
B10000,
B10000,
B10000,
B10000,
B10000
};
byte two[] = {
B11000,
B11000,
B11000,
B11000,
B11000,
B11000,
B11000,
B11000
};
byte three[] = {
B11100,
B11100,
B11100,
B11100,
B11100,
B11100,
B11100,
B11100
};
byte four[] = {
B11110,
B11110,
B11110,
B11110,
B11110,
B11110,
B11110,
B11110
};
byte five[] = {
B11111,
B11111,
B11111,
B11111,
B11111,
B11111,
B11111,
B11111
};
void updateProgressBar(unsigned long count, unsigned long totalCount, int lineToPrintOn)
{
double factor = totalCount / 80.0;
int percent = (count + 1) / factor;
int number = percent / 5;
int remainder = percent % 5;
if (number > 0)
{
for (int j = 0; j < number; j++)
{
lcd.setCursor(j, lineToPrintOn);
lcd.write(6);
}
}
lcd.setCursor(number, lineToPrintOn);
lcd.write(remainder);
if (number < 16)
{
for (int j = number + 1; j <= 16; j++)
{
lcd.setCursor(j, lineToPrintOn);
lcd.write(1);
}
}
}
//LCD - Info Screen

//LCD - Volume Bar
bool volOnLcd;
//Main Menu
bool menuOnLcd;
int menuPosition = 0;
//Transport Controls
bool transportCtrlOnLcd = false;
bool transportCtrlSelected = false;
int transportCtrlPosition = 0;
/* Transport Control Positions:
0 = Play
1 = Pause
2 = Next
3 = Previous
*/
//EQ
bool eqOn = true;
bool eqOnLcd = false;
bool eqLowsSelected = false;
bool eqMidsSelected = false;
bool eqHighsSelected = false;
int maxGain = 10;
int minGain = 0;
int eqMenuPosition = 0;
//Communication - Arduino Mega (Main Controller)
bool eqLowMode;
bool eqMidMode;
bool eqHighMode;
bool sentEqValue = false;
//Settings
bool settingsOnLcd = false;
#define NUMELEMENTS(X) (sizeof(X) / sizeof(X[0]))

struct MENUITEM
{
char *title; // item title
bool (*action)(void *ptr); // function to execute
void *param; // parameter for function to execute
struct MENU *subMenu; // submenu for this menu item
};

struct MENU
{
char *title; // menu title
MENUITEM *items; // menu items
int numItems; // number of menu items
int selected; // item that is selected
struct MENU *parentMenu; // parent menu of this menu
};

/****************************
prototypes for all functions that can be called from the menus
***/
bool backToInfo(void );
bool toggleLCDBacklight(void );
bool showEq(void );
/
menu prototypes so compiler does not complain that it does not know the menu yet
only menus that can be a parent menu need to be here; others are allowed
****************************/
extern MENU mainMenu;

MENUITEM soundMenuItems[] =
{
{"Equilizer", showEq, NULL, NULL},
{"Back", NULL, NULL, NULL},
};

MENU soundMenu =
{
"Sound", soundMenuItems, NUMELEMENTS(soundMenuItems), 0, &mainMenu
};

MENUITEM displayMenuItems[] =
{
{"Toggle Bklight", toggleLCDBacklight, NULL, NULL},
{"Back", NULL, NULL, NULL},
};

MENU displayMenu =
{
"Display", displayMenuItems, NUMELEMENTS(displayMenuItems), 0, &mainMenu
};

MENUITEM mainMenuItems[] =
{
{"Sound", NULL, NULL, &soundMenu},
{"Display", NULL, NULL, &displayMenu},
{"Back", backToInfo, NULL, NULL},
};

MENU mainMenu =
{
"Main menu", mainMenuItems, NUMELEMENTS(mainMenuItems), 0, NULL
};

MENU *currentMenu = &mainMenu; // currently selected menu
bool (*currentAction)(void *ptr) = NULL; // function to execute
void *currentParam = NULL; // parameter for function to execute
//Settings params
bool backToInfo(void *) {
settingsOnLcd = false;
lcdInfo(0);
return true;
}
bool toggleLCDBacklight(void *) {
toggleLCDBL();
return true;
}
bool showEq(void *) {
settingsOnLcd = false;
eqOnLcd = true;
return true;
}
//Rotary Encoder
bool encoderCW;
bool encoderCCW;
void checkPosition()
{
encoder.tick(); // just call tick() to check the state.
}
//A2dp Bluetooth
String songName;
String songArtist;
bool connectedState;
bool lastConnectedState;
// Write A2DP data to eq in callback
void read_data_stream(const uint8_t *data, uint32_t length) {
if (eqOn) {
eq.write(data, length);
} else {
kit.write(data, length);
}
}
void avrc_metadata_callback(uint8_t id, const uint8_t *text) {
//Serial.printf(">id 0x%x, %s\n", id, text);

switch (id) {
case ESP_AVRC_MD_ATTR_TITLE:
songName = (char *)text;
break;
case ESP_AVRC_MD_ATTR_ARTIST:
songArtist = (char *)text;
break;
}
if (!menuOnLcd && !transportCtrlOnLcd && !settingsOnLcd && !eqOnLcd) {
lcdInfo(0);
}
if (songName == "") {
songName = "No Name";
return;
}
if (songArtist == "") {
songArtist = "No Artist";
return;
}
}

void setup() {
Serial.begin(115200);
AudioLogger::instance().begin(Serial, AudioLogger::Warning);
prefs.begin("Go-Kart-Audio", false);

// setup output
auto cfg = kit.defaultConfig(TX_MODE);
kit.begin(cfg);
kit.setVolume(prefs.getInt("volume", 10));

//setup lcd
setupLCD();

//setup encoder
attachInterrupt(digitalPinToInterrupt(23), checkPosition, CHANGE);
attachInterrupt(digitalPinToInterrupt(18), checkPosition, CHANGE);

//setup eq
cfg_eq = eq.defaultConfig();
cfg_eq.setAudioInfo(cfg);
cfg_eq.gain_low = prefs.getFloat("gain_low", 1.00);
cfg_eq.gain_medium = prefs.getFloat("gain_medium", 1.00);
cfg_eq.gain_high = prefs.getFloat("gain_high", 1.00);
eqOn = prefs.getBool("eqOn", true);
eq.begin(cfg_eq);

// setup player
player.setVolume(1);
player.begin();
player.setAutoNext(false);

// setup a2dp bluetooth
a2dp_sink.set_stream_reader(read_data_stream, false);
a2dp_sink.set_avrc_metadata_attribute_mask(ESP_AVRC_MD_ATTR_TITLE | ESP_AVRC_MD_ATTR_ARTIST);
a2dp_sink.set_avrc_metadata_callback(avrc_metadata_callback);
a2dp_sink.set_auto_reconnect(true, false, 1000);
a2dp_sink.start("TrixoleKart Go-Kart");

//show something on LCD
lcd.clear();
lcd.home();
lcd.print("No device");
lcd.setCursor(0, 1);
lcd.print("Connected");

}

void loop() {
encoder.tick();
if (sdCopy)
player.copy();
}
encoderDirection();
mainMenuVoid();
transportCtrls();
settings();
eqScreen();
SendToMega();
ReceiveFromMega();
if (!menuOnLcd && !transportCtrlOnLcd && !settingsOnLcd && !eqOnLcd) {
encoderVolume();
bluetoothA2dpState();
volClearAndReturn(3);
}
}
//Other Voids

//LCD - Start
void setupLCD() {
lcd.begin(16, 2);
LCDBacklight = true;
lcd.setBacklight(LCDBacklight);
lcd.createChar(1, zero);
lcd.createChar(2, one);
lcd.createChar(3, two);
lcd.createChar(4, three);
lcd.createChar(5, four);
lcd.createChar(6, five);
}
//LCD - Info
void lcdInfo(int mode) {
if (mode == 0) {
lcd.clear();
lcd.home();
lcd.print(songName);
lcd.setCursor(0, 1);
lcd.print(songArtist);
}
}
//LCD - Volume Bar
void lcdVolumeBar(int volume) {
lcd.setCursor(0, 0);
lcd.print(" Volume ");
updateProgressBar(volume, 100, 1);
pM = millis();
volOnLcd = true;
}
void volClearAndReturn(int interval) {
if (volOnLcd == true) {
if (millis() - pM >= interval * 1000) {
pM = millis();
volOnLcd = false;
lcdInfo(0);
}
}
}
//Rotary Encoder - Direction
void encoderDirection() {
switch ((int)(encoder.getDirection())) {
case 0:
encoderCW = 0;
encoderCCW = 0;
break;
case 1:
encoderCCW = 0;
encoderCW = 1;
break;
case -1:
encoderCW = 0;
encoderCCW = 1;
break;
}
}
//Rotary Encoder - Volume
void encoderVolume() {
int volume = kit.volume();
if (encoderCW == 1) {
kit.setVolume(volume + 6);
lcdVolumeBar(kit.volume());
prefs.putInt("volume", kit.volume());
}
if (encoderCCW == 1) {
kit.setVolume(volume - 4);
lcdVolumeBar(kit.volume());
prefs.putInt("volume", kit.volume());
}
}
//Bluetooth A2DP - Connected State
void bluetoothA2dpState() {
connectedState = a2dp_sink.is_connected();
if (connectedState == true && lastConnectedState != true) {
player.setIndex(3);
player.copy();
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("Connected to:");
lcd.setCursor(0, 1);
lcd.print(a2dp_sink.get_connected_source_name());
Serial.println(">Bluetooth A2DP: Connected to ");
Serial.print(a2dp_sink.get_connected_source_name());
delay(1000);
a2dp_sink.set_volume(127);
lcdInfo(0);
lastConnectedState = connectedState;
}
if (connectedState == false && lastConnectedState != false) {
player.setIndex(2);
lcd.clear();
lcd.setCursor(2, 0);
lcd.print("Disconnected");
Serial.println(">Bluetooth A2DP: Disconnected");
songName = "";
songArtist = "";
delay(1000);
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("No Device");
lcd.setCursor(0, 1);
lcd.print("Connected!");
lastConnectedState = connectedState;
}
}
void mainMenuVoid() {
if (menuOnLcd) {
if (encoderCW == 1) {
if (menuPosition < 2) menuPosition++;
switch (menuPosition) {
case 0:
lcd.clear();
lcd.home();
lcd.print("~Transport Ctrl");
lcd.setCursor(0, 1);
lcd.print(" Settings");
break;
case 1:
lcd.clear();
lcd.home();
lcd.print("~Settings");
lcd.setCursor(0, 1);
lcd.print(" Back");
break;
case 2:
lcd.clear();
lcd.home();
lcd.print("~Back");
break;
}
}
if (encoderCCW == 1) {
if (menuPosition > 0) menuPosition--;
switch (menuPosition) {
case 0:
lcd.clear();
lcd.home();
lcd.print("~Transport Ctrl");
lcd.setCursor(0, 1);
lcd.print(" Settings");
break;
case 1:
lcd.clear();
lcd.home();
lcd.print("~Settings");
lcd.setCursor(0, 1);
lcd.print(" Back");
break;
case 2:
lcd.clear();
lcd.home();
lcd.print("~Back");
break;
}
}
if (encoderB.getSingleDebouncedPress()) {
switch (menuPosition) {
case 0:
lcd.clear();
menuOnLcd = false;
transportCtrlOnLcd = true;
break;
case 1:
lcd.clear();
menuOnLcd = false;
currentMenu = &mainMenu;
currentMenu->selected = 0;
settingsOnLcd = true;
break;
case 2:
lcd.clear();
menuOnLcd = false;
lcdInfo(0);
break;
}
}
}
if (encoderB.getSingleDebouncedPress() && !menuOnLcd) {
menuPosition = 0;
menuOnLcd = true;
switch (menuPosition) {
case 0:
lcd.clear();
lcd.home();
lcd.print("~Transport Ctrl");
lcd.setCursor(0, 1);
lcd.print(" Settings");
break;
case 1:
lcd.clear();
lcd.home();
lcd.print("~Settings");
lcd.setCursor(0, 1);
lcd.print(" Back");
break;
case 2:
lcd.clear();
lcd.home();
lcd.print("~Back");
break;
}
}
}
void transportCtrls() {
if (transportCtrlOnLcd) {
if (!transportCtrlSelected) {
if (encoderCW == 1) {
if (transportCtrlPosition < 4) transportCtrlPosition++;
}
if (encoderCCW == 1) {
if (transportCtrlPosition > 0) transportCtrlPosition--;
}
switch (transportCtrlPosition) {
case 0:
lcd.home();
lcd.print("< Play >");
if (encoderB.getSingleDebouncedPress()) {
a2dp_sink.play();
}
break;
case 1:
lcd.home();
lcd.print("< Pause >");
if (encoderB.getSingleDebouncedPress()) {
a2dp_sink.pause();
}
break;
case 2:
lcd.home();
lcd.print("< Next >");
if (encoderB.getSingleDebouncedPress()) {
transportCtrlSelected = true;
}
break;
case 3:
lcd.home();
lcd.print("< Previous >");
if (encoderB.getSingleDebouncedPress()) {
transportCtrlSelected = true;
}
break;
case 4:
lcd.home();
lcd.print("< Back >");
if (encoderB.getSingleDebouncedPress()) {
transportCtrlOnLcd = false;
lcd.clear();
lcdInfo(0);
}
break;
}
}
if (transportCtrlSelected) {
switch (transportCtrlPosition) {
case 2:
lcd.home();
lcd.print("<< Next >>");
if (encoderB.getSingleDebouncedPress()) {
a2dp_sink.next();
}
break;
case 3:
lcd.home();
lcd.print("<< Previous >>");
if (encoderB.getSingleDebouncedPress()) {
a2dp_sink.previous();
}
break;
}
if (encoderCW == 1) {
transportCtrlSelected = false;
}
if (encoderCCW == 1) {
transportCtrlSelected = false;
}
}
}
}

//Equilizer Screen
void eqScreen() {
if (eqOnLcd) {
if (!eqLowsSelected && !eqMidsSelected && !eqHighsSelected) {
if (encoderCW == 1) {
lcd.clear();
if (eqMenuPosition < 4) eqMenuPosition++;
}
if (encoderCCW == 1) {
lcd.clear();

    if (eqMenuPosition > 0) eqMenuPosition--;
  }
  switch (eqMenuPosition) {
    case 0:
      lcd.home();
      lcd.print("<     Lows     >");
      lcd.setCursor(0, 1);
      lcd.print(cfg_eq.gain_low);
      if (encoderB.getSingleDebouncedPress()) {
        eqLowsSelected = true;
      }
      break;
    case 1:
      lcd.home();
      lcd.print("<     Mids     >");
      lcd.setCursor(0, 1);
      lcd.print(cfg_eq.gain_medium);
      if (encoderB.getSingleDebouncedPress()) {
        eqMidsSelected = true;
      }
      break;
    case 2:
      lcd.home();
      lcd.print("<     Highs    >");
      lcd.setCursor(0, 1);
      lcd.print(cfg_eq.gain_high);
      if (encoderB.getSingleDebouncedPress()) {
        eqHighsSelected = true;
      }
      break;
    case 3:
      lcd.home();
      lcd.print("<  EQ On/Off   >");
      lcd.setCursor(0, 1);
      if (eqOn) {
        lcd.print("On ");
      } else {
        lcd.print("Off");
      }
      if (encoderB.getSingleDebouncedPress()) {
        if (eqOn) {
          eqOn = false;
          prefs.putBool("eqOn", eqOn);

        } else {
          eqOn = true;
          prefs.putBool("eqOn", eqOn);
        }
      }
      break;
    case 4:
      lcd.home();
      lcd.print("<     Back     >");
      if (encoderB.getSingleDebouncedPress()) {
        eqOnLcd = false;
        lcd.clear();
        lcdInfo(0);
      }
      break;
  }
}
if (eqLowsSelected) {
  lcd.home();
  lcd.print("<<    Lows    >>");
  lcd.setCursor(0, 1);
  lcd.print(cfg_eq.gain_low);
  if (encoderCW == 1) {
    lcd.clear();
    if (cfg_eq.gain_low < maxGain) cfg_eq.gain_low += 0.50; prefs.putFloat("gain_low", cfg_eq.gain_low);
  }
  if (encoderCCW == 1) {
    lcd.clear();
    if (cfg_eq.gain_low > minGain) cfg_eq.gain_low -= 0.50; prefs.putFloat("gain_low", cfg_eq.gain_low);
  }
  if (encoderB.getSingleDebouncedPress()) {
    lcd.clear();
    eqLowsSelected = false;
  }
}
if (eqMidsSelected) {
  lcd.home();
  lcd.print("<<    Mids    >>");
  lcd.setCursor(0, 1);
  lcd.print(cfg_eq.gain_medium);
  if (encoderCW == 1) {
    lcd.clear();
    if (cfg_eq.gain_medium < maxGain) cfg_eq.gain_medium += 0.50; prefs.putFloat("gain_medium", cfg_eq.gain_medium);
  }
  if (encoderCCW == 1) {
    lcd.clear();
    if (cfg_eq.gain_medium > minGain) cfg_eq.gain_medium -= 0.50; prefs.putFloat("gain_medium", cfg_eq.gain_medium);
  }
  if (encoderB.getSingleDebouncedPress()) {
    lcd.clear();
    eqMidsSelected = false;
  }
}
if (eqHighsSelected) {
  lcd.home();
  lcd.print("<<    Highs   >>");
  lcd.setCursor(0, 1);
  lcd.print(cfg_eq.gain_high);
  if (encoderCW == 1) {
    lcd.clear();
    if (cfg_eq.gain_high < maxGain) cfg_eq.gain_high += 0.50; prefs.putFloat("gain_high", cfg_eq.gain_high);
  }
  if (encoderCCW == 1) {
    lcd.clear();
    if (cfg_eq.gain_high > minGain) cfg_eq.gain_high -= 0.50; prefs.putFloat("gain_high", cfg_eq.gain_high);
  }
  if (encoderB.getSingleDebouncedPress()) {
    lcd.clear();
    eqHighsSelected = false;
  }
}

}
}
//Settings
void settings() {
if (settingsOnLcd) {
for (int itemCnt = 0; itemCnt < 4; itemCnt++)
{
if (currentMenu->selected <= 2) {
if (currentMenu->selected == itemCnt)
{
lcd.setCursor(0, itemCnt);
lcd.print("");
}
else
{
lcd.setCursor(0, itemCnt);
lcd.print(" ");
}
}
if (currentMenu->selected >= 2 && currentMenu->selected <= 4) {
if (currentMenu->selected == itemCnt)
{
lcd.setCursor(0, itemCnt - 2);
lcd.print("");
}
else
{
lcd.setCursor(0, itemCnt - 2);
lcd.print(" ");
}
}
}
if (currentMenu->selected >= 0 && currentMenu->selected <= 1) {
if (currentMenu->numItems > 0) {
lcd.setCursor(1, 0);
lcd.print(currentMenu->items[0].title);
}
if (currentMenu->numItems > 1) {
lcd.setCursor(1, 1);
lcd.print(currentMenu->items[1].title);
}
}
if (currentMenu->selected >= 2 && currentMenu->selected <= 3) {
if (currentMenu->numItems > 2) {
lcd.setCursor(1, 0);
lcd.print(currentMenu->items[2].title);
}
if (currentMenu->numItems > 3) {
lcd.setCursor(1, 1);
lcd.print(currentMenu->items[3].title);
}
}

if (encoderCCW == 1) {
  lcd.clear();
  currentMenu->selected++;
  if (currentMenu->selected >= currentMenu->numItems)
  {
    currentMenu->selected = currentMenu->numItems - 1;
  }
}
if (encoderCW == 1) {
  lcd.clear();
  if (currentMenu->selected > 0)
  {
    currentMenu->selected--;
  }
}
if (encoderB.getSingleDebouncedPress()) {
  lcd.clear();
  if (currentMenu->items[currentMenu->selected].subMenu != NULL)
  {
    // if there is a submenu, change to submenu
    currentMenu = currentMenu->items[currentMenu->selected].subMenu;
  }
  else if (currentMenu->items[currentMenu->selected].action != NULL)
  {
    // if there is an action, setup current action and current parameter
    //currentMenu->items[currentMenu->selected].action(currentMenu->items[currentMenu->selected].param);
    currentAction = currentMenu->items[currentMenu->selected].action;
    currentParam = currentMenu->items[currentMenu->selected].param;
  }
  else if (currentMenu->parentMenu != NULL)
  {
    // if there is a paremnt menu, change to the parent menu
    currentMenu = currentMenu->parentMenu;
  }
  else
  {
    // if everything else fails, switch to main menu
    currentMenu = &mainMenu;
  }
}

}
if (currentAction != NULL)
{
if (currentAction(currentParam) == true)
{
currentAction = NULL;
currentParam = NULL;
}
}
}
//mega
void SendToMega() {
if (!eqLowMode && !eqMidMode && !eqHighMode) {
if (millis() - pM1 >= 500) {
pM1 = millis();
String data = songName + "," + songArtist + "," + String(a2dp_sink.get_connected_source_name()) + ", ";
Serial.print(data);
}
}
if (eqLowMode) {
if (!sentEqValue) {
Serial.println(cfg_eq.gain_low);
sentEqValue = true;
}
char iC = Serial.read();
switch (iC) {
case '+':
if (cfg_eq.gain_low < maxGain) cfg_eq.gain_low += 0.50; prefs.putFloat("gain_low", cfg_eq.gain_low);
Serial.println(cfg_eq.gain_low);
break;
case '-':
if (cfg_eq.gain_low > minGain) cfg_eq.gain_low -= 0.50; prefs.putFloat("gain_low", cfg_eq.gain_low);
Serial.println(cfg_eq.gain_low);
break;
case 'B':
eqLowMode = false;
sentEqValue = false;
break;
}
}
if (eqMidMode) {
if (!sentEqValue) {
Serial.println(cfg_eq.gain_medium);
sentEqValue = true;
}
char iC = Serial.read();
switch (iC) {
case '+':
if (cfg_eq.gain_medium < maxGain) cfg_eq.gain_medium += 0.50; prefs.putFloat("gain_low", cfg_eq.gain_medium);
Serial.println(cfg_eq.gain_medium);
break;
case '-':
if (cfg_eq.gain_medium > minGain) cfg_eq.gain_medium -= 0.50; prefs.putFloat("gain_low", cfg_eq.gain_medium);
Serial.println(cfg_eq.gain_medium);
break;
case 'B':
eqMidMode = false;
sentEqValue = false;
break;
}

}
if (eqHighMode) {
if (!sentEqValue) {
Serial.println(cfg_eq.gain_high);
sentEqValue = true;
}
char iC = Serial.read();
switch (iC) {
case '+':
if (cfg_eq.gain_high < maxGain) cfg_eq.gain_high += 0.50; prefs.putFloat("gain_low", cfg_eq.gain_high);
Serial.println(cfg_eq.gain_high);
break;
case '-':
if (cfg_eq.gain_high > minGain) cfg_eq.gain_high -= 0.50; prefs.putFloat("gain_low", cfg_eq.gain_high);
Serial.println(cfg_eq.gain_high);
break;
case 'B':
eqHighMode = false;
sentEqValue = false;
break;
}
}

}

void ReceiveFromMega() {
char iC = Serial.read();
switch (iC) {
case 'D':
toggleLCDBL();
break;
case 'N':
a2dp_sink.next();
break;
case 'P':
a2dp_sink.previous();
break;
case 'L':
eqLowMode = true;
break;
case 'M':
eqMidMode = true;
break;
case 'H':
eqHighMode = true;
break;
}
}`

[pschatzmann]

If the audio stutters you don't provide the audio data quick enough. I assume that you have added too much of a delay in the loop. Try to optimize your processing or use different tasks.