Playback stops with [E] SDDirect.h : 81

[BorpaBoatski]

Using:
Arduino UNO R4 Wifi
VS1053 MP3 Shield
Sandisk microSD

I'm aiming to make a media player that is suppose to run almost the whole day. However, I found that after my player does several loops, it would stop and give this message [E] SDDirect.h : 81. Searching online and it seems to be running out of RAM. I added this block to print the SRAM of my process:

int FreeMemory()
{
  char top;
  return &top - reinterpret_cast<char*>(sbrk(0));
}

The results are summed as follows:

Memory 19207
... <- Repeated value
...
Now Playing 2
Memory 18719
...
...
Now Playing 0
Memory 18315
...
...

So it seems to be losing memory every time the track changes. How do I free up the memory that was used by previous track? I have attached my code in the .zip file.

LosingMemoryExample.zip

[pschatzmann]

Hmm, this will be difficult to find!

• I suggest to start with the simplest sketch possible: just remove all your logic to exclude that that the issue has been caused by your code. e.g. the PrintFiles never closes root.
• Then there are 3 potential sources of the problem that we can try to exlude separatly: AudioSourceSD, VS1053Stream and
  AudioPlayer.
  • step 1: replace VS1053Stream with a NullStream and check if the memory leak remains
  • step 2: replace AudioSourceSD with a AudioSourceCallback class: this might be a better aproach for your case anyhow: just provide a callback via setCallbackNextStream that provides the next file to play.
  • step 3: replace the AudioPlayer and just copy the whole file to the VS1053Stream

I think VS1053Stream is rarely used: so it might come from there ?

ps. This assumes that the memory leak is not in the SD library, so this might need to be tested separatly. You can try to replace it with SDFAT.

[pschatzmann]

I committed a correction to the VS1053Stream in the AudioTools. There was a potential memory leak when calling end() and begin().
If the issue remains, I will need to look into the VS1053 library.

[BorpaBoatski]

I replaced my VS1053Stream with the corrected version. Unfortunately, I am still seeing the same memory loss.

[pschatzmann]

Unfortunatly I don't have the hardware setup to test this properly. So I created the following test sketch that just opens, writes data and closes the VS1053Stream:

#include "AudioTools.h"
#include "AudioTools/AudioLibs/VS1053Stream.h"
#include <unistd.h>

VS1053Stream vs1053;  // final output

int freeMemory() {
  char top;
  return &top - reinterpret_cast<char*>(sbrk(0));
}


void setup() {
  Serial.begin(115200);
  while (!Serial)
    ;
  AudioToolsLogger.begin(Serial, AudioToolsLogLevel::Warning);

  // setup output
  auto cfg = vs1053.defaultConfig();
  cfg.is_encoded_data = true;  // vs1053 is accepting encoded data
  vs1053.begin(cfg);
}

void loop() {
  vs1053.end();
  Serial.print("rc = ");
  Serial.print(vs1053.begin());
  for (int i = 0; i < 1000; i++) vs1053.writeSilence(1000);
  Serial.print(" / free ram: ");
  Serial.println(freeMemory());
}

I could not reproduce any memory leak:

rc = 1/ free ram: 25675
rc = 1/ free ram: 25675
rc = 1/ free ram: 25675
rc = 1/ free ram: 25675
rc = 1/ free ram: 25675
rc = 1/ free ram: 25675
rc = 1/ free ram: 25675
rc = 1/ free ram: 25675
rc = 1/ free ram: 25675
rc = 1/ free ram: 25675
rc = 1/ free ram: 25675
rc = 1/ free ram: 25675

[pschatzmann]

The same with the following player test sketch that just generates 0 values during 5 seconds:

#include "AudioTools.h"
#include "AudioTools/AudioLibs/VS1053Stream.h"
#include "AudioTools/AudioCodecs/CodecCopy.h"
#include <unistd.h>

const char* startFilePath = "/";
const char* ext = "mp3";
Stream* nextStreamCallback(int offset);
AudioSourceCallback source(nextStreamCallback);
VS1053Stream vs1053;  // final output
AudioPlayer player(source, vs1053, *new CopyDecoder());
NullStream zeros;
TimedStream timed;

// provide the next "file"
Stream* nextStreamCallback(int offset) {
  timed.begin();
  return &timed;
}

// report the free RAM
int freeMemory() {
  char top;
  return &top - reinterpret_cast<char*>(sbrk(0));
}

void setup() {
  Serial.begin(115200);
  AudioToolsLogger.begin(Serial, AudioToolsLogLevel::Warning);

  timed.setStream(zeros);
  timed.setEndSec(5);

  // setup output
  auto cfg = vs1053.defaultConfig();
  cfg.is_encoded_data = true;  // vs1053 is accepting encoded data
  vs1053.begin(cfg);
  vs1053.setVolume(1.0);  // full volume

  // setup player
  player.begin();
}

void loop() {
  if (!player.copy()) {
    Serial.print("free ram: ");
    Serial.println(freeMemory());
  }
}

Which gives the following log:

ree ram: 20691
free ram: 20691
free ram: 20691
free ram: 20691
free ram: 20691
free ram: 20691
free ram: 20691
free ram: 20691
free ram: 20691
free ram: 20691
free ram: 20691
free ram: 20691

I was testing with the 1.5.1 core version!

[BorpaBoatski]

I tested with the sketch you just posted and I am getting the same result where the memory is constant. I downloaded the latest release which was 1.2.1. Where do I find 1.5.1?

I think the issue could be coming from the stream. I added the AudioSourceSD into your sketch as the source for the player and now I'm getting the losing memory issue again. You recommended changing the AudioSourceSD class to AudioSourceCallback. How do I provide the file for it to play?

[pschatzmann]

This is what I get:

I found the problem: for the AudioSourceSD, the last file was not closed: I committed a correction to align the logic whith what has been implemnted for SDFAT.

If you want to use the callback, you would do something like this:

// provide the next "file"
File actual_file;
Stream* nextStreamCallback(int offset) {
  actual_file.close();
  actual_file = SD.open(your next file name)
  return &actual_file;
}

[BorpaBoatski]

Oh the board package. Yes, mine is at 1.5.1.

I tried with the corrected AudioSourceSD but still not improvement there.

HOWEVER. Your idea of using the nextStreamCallback is working! There's no memory loss being shown.

[BorpaBoatski]

Just to update. Right now I have it playing the playlist constantly and on shuffle as well with no loss in memory. However, once I attempt to fading the volume of the vs1053 or running begin() or end() to start/stop playback. The memory takes a hit again. Interestingly, even if the memory value drops really low, the playback is still working fine compared to last time where it would cease completely. I think this is just a limitation of the memory printing(?) Any ideas?

[BorpaBoatski]

I have managed to leave the player running all night! I also did a small test by having the player end() and begin() every end of playlist and it seems to be doing fine. (will try another overnight test again with this) Many thanks @pschatzmann! This is the current version of my sketch:

#include "AudioTools.h"
#include "AudioTools/AudioLibs/VS1053Stream.h"
#include "AudioTools/AudioCodecs/CodecCopy.h"
#include "AudioTools/Disk/AudioSourceSD.h"

extern "C" char* sbrk(int incr);

const char *startFilePath="/";
const char* c_MP3Ext="MP3";
Stream* NextStreamCallback(int offset);
AudioSourceCallback source(NextStreamCallback);
VS1053Stream vs1053; //final output
AudioPlayer player(source, vs1053, *new CopyDecoder());

const int c_SDPin = 9;
bool playing = false;
unsigned long cachedTime;
const float audioFadeOutDuration = 3;
const float audioFadeInDuration = .5;
const int c_KnownAudioCount = 3;
String fileList[c_KnownAudioCount];
int playOrder[c_KnownAudioCount];
int newOrder[c_KnownAudioCount];
int playIndex = -1;
unsigned long memoryPrint;
File playingFile;

void SetupAudioPlayer()
{
  GetFileNames();
  ShufflePlaylist(0);
  //AudioToolsLogger.begin(Serial, AudioToolsLogLevel::Info);
  auto _cfg = vs1053.defaultConfig();
  _cfg.is_encoded_data = true;
  vs1053.begin(_cfg);
  vs1053.setVolume(0); 
  cachedTime = millis();

  ///Test
  player.begin();
  vs1053.setVolume(1); 
}

void LoopAudioPlayer()
{
  unsigned long _currentMillis = millis();

  //Serial.print(F("Memory "));
  //Serial.println(FreeMemory());

  if(playing) player.copy();

  if(active)
  {
    if(!playing)
    {
      playing = true;
      player.begin();
    }

    if(vs1053.volume() < 1) FadeVolume(true, _currentMillis);
  }
  else 
  {
    if(playing) FadeVolume(false, _currentMillis);
  }

  cachedTime = _currentMillis;
}

Stream* NextStreamCallback(int offset)
{
  //Serial.println(F("Next"));
  playingFile.close();
  playIndex++;

  if(playIndex >= c_KnownAudioCount) 
  {
    player.end();
    delay(1000);
    ShufflePlaylist(c_KnownAudioCount - 1);
    playIndex = -1;
    player.begin();
    PrintMemory();
  }

  playingFile = SD.open(fileList[playOrder[playIndex]]);
  Serial.print(F("Now Playing "));
  Serial.println(fileList[playOrder[playIndex]]);
  String _bleMessage = F("Playing ");
  _bleMessage += fileList[playOrder[playIndex]];
  NewBLEMessageLine(_bleMessage);

  return &playingFile;
}

void FadeVolume(bool fadeIn, unsigned long currentMillis)
{
  float _volume = vs1053.volume();
  float _deltaTime = (currentMillis - cachedTime) / 1000.0;
  float _fadeVolume = _volume;

  if(fadeIn) _fadeVolume += _deltaTime / audioFadeInDuration;
  else _fadeVolume -= _deltaTime / audioFadeOutDuration * .2;

  // Serial.print(F("Millis "));
  // Serial.print(currentMillis);
  // Serial.print(F(" - "));
  // Serial.print(cachedTime);
  // Serial.print(F(" = "));
  // Serial.println(_deltaTime);

  // Serial.print(F("DeltaTime "));
  // Serial.println(_deltaTime);

  // Serial.print(F("New Volume "));
  // Serial.println(_fadeVolume);

  vs1053.setVolume(_fadeVolume);
  // Serial.print(F("Set Volume "));
  // Serial.println(vs1053.volume());

  if(!fadeIn && _fadeVolume <= .8)
  {
    // Serial.print("PlayIndex in FadeVolume ");
    // Serial.println(playIndex);
    ShufflePlaylist(playIndex);
    playIndex = -1;
    playing = false;
    player.end();
    //Serial.println(F("Player stopped"));
    NewBLEMessageLine(F("Player Stopped"));
    return;
  }
}


void ShufflePlaylist(int prevIndex)
{
  // Serial.println("Begin Shuffle");
  // Serial.print("Prev Index ");
  // Serial.println(playIndex);

  for(int i = 0; i < c_KnownAudioCount; i++)
  {
    newOrder[i] = i;
  }

  ///Fisher-Yates shuffle
  for(int i = c_KnownAudioCount - 1; i > 0; i--)
  {
    int _randomIndex = random(0, i + 1);
    int _temp = newOrder[i];
    newOrder[i] = newOrder[_randomIndex];
    newOrder[_randomIndex] = _temp;
  }

  // Serial.print("newOrder[0] ");
  // Serial.print(newOrder[0]);
  // Serial.print(" = playOrder[prevIndex] ");
  // Serial.print(playOrder[prevIndex]);
  // Serial.println("?");

  // Serial.println(F("New Order "));
  //PrintPlaylist(newOrder);

  ///Do not match first playing index with last playing track index
  if(newOrder[0] == playOrder[prevIndex])
  {
    int _randomIndex = random(1, 3);

    // Serial.print("Swapping [0] with ");
    // Serial.println(_randomIndex);

    int _temp = newOrder[0];
    newOrder[0] = newOrder[_randomIndex];
    newOrder[_randomIndex] = _temp;

    //Serial.println(F("Post Swap New Order "));
    //PrintPlaylist(newOrder);
  }

  // Serial.println(F("Play Order "));
  // PrintPlaylist(playOrder);

  ///Transfer values
  for(int i = 0; i < c_KnownAudioCount; i++)
  {
    playOrder[i] = newOrder[i];
  }

  Serial.print(F("New Playlist "));
  PrintPlaylist(playOrder);
}

void PrintPlaylist(int order[])
{
  String _blePlaylist = "New Playlist {";
  Serial.print("{");

  for(int i=0; i<c_KnownAudioCount; i++)
  {
    Serial.print(order[i]);
    _blePlaylist += order[i];

    if(i < c_KnownAudioCount - 1) 
    {
      Serial.print(",");
      _blePlaylist += ",";
    }
  }

  Serial.println("}");
  _blePlaylist += "}";
  NewBLEMessageLine(_blePlaylist);
}

void GetFileNames()
{
  if(!SD.begin(c_SDPin)) 
  {
    Serial.println("SD Failed");
    return;
  }

  int _inputIndex = 0;
  File root = SD.open("/");
  while(true)
  {
    File entry = root.openNextFile();
    if(!entry) break;
    
    if(!IsMP3File(entry.name()))
    {
      Serial.print(F("Skipping "));
      Serial.println(entry.name());
      entry.close();
      continue;
    }

    fileList[_inputIndex] = entry.name();
    _inputIndex++;
    Serial.println(entry.name());
    entry.close();
  }

  root.close();
}

bool IsMP3File(char* fileName)
{
  char* _dot = strrchr(fileName, '.');

  if(_dot == NULL) return false;

  char* _extension = _dot + 1;

  return strcmp(_extension, c_MP3Ext) == 0;
}