vs1053_SdFat.cpp

Go to the documentation of this file.

#include <vs1053_SdFat.h>
// inslude the SPI library:
#include "SPI.h"
//avr pgmspace library for storing the LUT in program flash instead of sram
#include <avr/pgmspace.h>

static const uint16_t bitrate_table[15][6] PROGMEM = {
                 { 0,   0,  0,  0,  0,  0}, //0000
                 { 32, 32, 32, 32,  8,  8}, //0001
                 { 64, 48, 40, 48, 16, 16}, //0010
                 { 96, 56, 48, 56, 24, 24}, //0011
                 {128, 64, 56, 64, 32, 32}, //0100
                 {160, 80, 64, 80, 40, 40}, //0101
                 {192, 96, 80, 96, 48, 48}, //0110
                 {224,112, 96,112, 56, 56}, //0111
                 {256,128,112,128, 64, 64}, //1000
                 {288,160,128,144, 80, 80}, //1001
                 {320,192,160,160, 96, 69}, //1010
                 {352,224,192,176,112,112}, //1011
                 {384,256,224,192,128,128}, //1100
                 {416,320,256,224,144,144}, //1101
                 {448,384,320,256,160,160}  //1110
               };

/*
 * Format of a MIDI file into a char arrar. Simply one note on and then off.
*/
// MIDI Event Specifics
#define MIDI_NOTE_ON             9
#define MIDI_NOTE_OFF            8

// MIDI File structure
// Header Chunk
#define MIDI_HDR_CHUNK_ID     0x4D, 0x54, 0x68, 0x64  // const for MIDI
#define MIDI_CHUNKSIZE           0,    0,    0,    6
#define MIDI_FORMAT              0,    0              // VSdsp only support Format 0!
#define MIDI_NUMBER_OF_TRACKS    0,    1              // ergo must be 1 track
#define MIDI_TIME_DIVISION       0,   96
// Track Chunk
#define MIDI_TRACK_CHUNK_ID   0x4D, 0x54, 0x72, 0x6B  // const for MIDI
#define MIDI_CHUNK_SIZE          0,    0,    0, sizeof(MIDI_EVENT_NOTE_ON) + sizeof(MIDI_EVENT_NOTE_OFF) + sizeof(MIDI_END_OF_TRACK) // hard coded with zero padded
// Events
#define MIDI_EVENT_NOTE_ON       0, (MIDI_NOTE_ON<<4) + MIDI_CHANNEL, MIDI_NOTE_NUMBER, MIDI_INTENSITY
#define MIDI_EVENT_NOTE_OFF   MIDI_NOTE_DURATION, (MIDI_NOTE_OFF<<4) + MIDI_CHANNEL, MIDI_NOTE_NUMBER, MIDI_INTENSITY
//
#define MIDI_END_OF_TRACK        0, 0xFF, 0x2F,    0

PROGMEM const uint8_t SingleMIDInoteFile[] = {MIDI_HDR_CHUNK_ID, MIDI_CHUNKSIZE, MIDI_FORMAT, MIDI_NUMBER_OF_TRACKS, MIDI_TIME_DIVISION, MIDI_TRACK_CHUNK_ID, MIDI_CHUNK_SIZE, MIDI_EVENT_NOTE_ON, MIDI_EVENT_NOTE_OFF, MIDI_END_OF_TRACK};

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
/* Initialize static classes and variables
 */

SdFile   vs1053::track;

state_m  vs1053::playing_state;

uint16_t vs1053::spi_Read_Rate;
uint16_t vs1053::spi_Write_Rate;

// only needed for specific means of refilling
#if defined(USE_MP3_REFILL_MEANS) && USE_MP3_REFILL_MEANS == USE_MP3_SimpleTimer
  SimpleTimer timer;
  int timerId_mp3;
#endif

//buffer for music
uint8_t  vs1053::mp3DataBuffer[32];

//------------------------------------------------------------------------------
uint8_t  vs1053::begin() {

/*
 This test is to assit in the migration from versions prior to 1.01.00.
 It is not really needed, simply prints an easy error, to better assist.
 If you are using SdFat objects other than "sd" the below may be omitted.
 or whant to save 222 bytes of Flash space.
 */
#if (1)
if (int8_t(sd.vol()->fatType()) == 0) {
  Serial.println(F("If you get this error, you likely do not have a sd.begin in the main sketch, See Trouble Shooting Guide!"));
  Serial.println(F("http://mpflaga.github.com/Sparkfun-MP3-Player-Shield-Arduino-Library/#Troubleshooting"));
}
#endif

  pinMode(MP3_DREQ, INPUT);
  pinMode(MP3_XCS, OUTPUT);
  pinMode(MP3_XDCS, OUTPUT);
  pinMode(MP3_RESET, OUTPUT);

#if PERF_MON_PIN != -1
  pinMode(PERF_MON_PIN, OUTPUT);
  digitalWrite(PERF_MON_PIN,HIGH);
#endif

  cs_high();  //MP3_XCS, Init Control Select to deselected
  dcs_high(); //MP3_XDCS, Init Data Select to deselected
  digitalWrite(MP3_RESET, LOW); //Put VS1053 into hardware reset

  playing_state = initialized;

  uint8_t result = vs_init();
  if(result) {
    return result;
  }

#if defined(USE_MP3_REFILL_MEANS) && USE_MP3_REFILL_MEANS == USE_MP3_Timer1
  Timer1.initialize(MP3_REFILL_PERIOD);
#elif defined(USE_MP3_REFILL_MEANS) && USE_MP3_REFILL_MEANS == USE_MP3_SimpleTimer
  timerId_mp3 = timer.setInterval(MP3_REFILL_PERIOD, refill);
  timer.disable(timerId_mp3);
#endif

  return 0;
}

void vs1053::end() {

  stopTrack(); // Stop and CLOSE any open tracks.
  disableRefill(); // shut down specific interrupts
  cs_high();  //MP3_XCS, Init Control Select to deselected
  dcs_high(); //MP3_XDCS, Init Data Select to deselected

  // most importantly...
  digitalWrite(MP3_RESET, LOW); //Put VS1053 into hardware reset

  playing_state = deactivated;
}

//------------------------------------------------------------------------------
uint8_t vs1053::vs_init() {

  //Initialize VS1053 chip

  //Reset if not already
  delay(100); // keep clear of anything prior
  digitalWrite(MP3_RESET, LOW); //Shut down VS1053
  delay(100);

  //Bring out of reset
  digitalWrite(MP3_RESET, HIGH); //Bring up VS1053

  //From section 7.6 of datasheet, max SCI reads are CLKI/7.
  //Assuming CLKI = 12.288MgHz for Shield and 16.0MgHz for Arduino
  //The VS1053's internal clock multiplier SCI_CLOCKF:SC_MULT is 1.0x after power up.
  //For a maximum SPI rate of 1.8MgHz = (CLKI/7) = (12.288/7) the VS1053's default.

  //Warning:
  //Note that spi transfers interleave between SdCard and VS10xx.
  //Where Sd2Card.cpp sets SPCR & SPSR each and every transfer

  //The SDfatlib using SPI_FULL_SPEED results in an 8MHz spi clock rate,
  //faster than initial allowed spi rate of 1.8MgHz.

  // set initial mp3's spi to safe rate
  spi_Read_Rate  = SPI_CLOCK_DIV16;
  spi_Write_Rate = SPI_CLOCK_DIV16;
  delay(10);

   //Let's check the status of the VS1053
  int MP3Mode = Mp3ReadRegister(SCI_MODE);

/*
  Serial.print(F("SCI_Mode (0x4800) = 0x"));
  Serial.println(MP3Mode, HEX);

  int MP3Status = Mp3ReadRegister(SCI_Status);
  Serial.print(F("SCI_Status (0x48) = 0x"));
  Serial.println(MP3Status, HEX);

  int MP3Clock = Mp3ReadRegister(SCI_CLOCKF);
  Serial.print(F("SCI_ClockF = 0x"));
  Serial.println(MP3Clock, HEX);
  */

  if(MP3Mode != (SM_LINE1 | SM_SDINEW)) return 4;

  //Now that we have the VS1053 up and running, increase the internal clock multiplier and up our SPI rate
  Mp3WriteRegister(SCI_CLOCKF, 0x6000); //Set multiplier to 3.0x
  //Internal clock multiplier is now 3x.
  //Therefore, max SPI speed is 52MgHz.

#if (F_CPU == 16000000 )
  spi_Read_Rate  = SPI_CLOCK_DIV4; //use safe SPI rate of (16MHz / 4 = 4MHz)
  spi_Write_Rate = SPI_CLOCK_DIV2; //use safe SPI rate of (16MHz / 2 = 8MHz)
#else
  // must be 8000000
  spi_Read_Rate  = SPI_CLOCK_DIV2; //use safe SPI rate of (8MHz / 2 = 4MHz)
  spi_Write_Rate = SPI_CLOCK_DIV2; //use safe SPI rate of (8MHz / 2 = 4MHz)
#endif

  delay(10); // settle time

  //test reading after data rate change
  int MP3Clock = Mp3ReadRegister(SCI_CLOCKF);
  if(MP3Clock != 0x6000) return 5;

  setVolume(40, 40);
  // one would think the following patch would over write the volume.
  // But the SCI_VOL register space is not in the VSdsp's WRAM space.
  // Note to keep an eye on it for future patches.

  if(VSLoadUserCode("patches.053")) return 6;

  delay(100); // just a good idea to let settle.

  return 0; // indicating all was good.
}

//------------------------------------------------------------------------------
uint8_t vs1053::VSLoadUserCode(char* fileName){

  union twobyte val;
  union twobyte addr;
  union twobyte n;

  if(!digitalRead(MP3_RESET)) return 3;
  if(isPlaying()) return 1;
  if(!digitalRead(MP3_RESET)) return 3;

  //Open the file in read mode.
  if(!track.open(fileName, O_READ)) return 2;
  //playing_state = loading;
  //while(i<size_of_Plugin/sizeof(Plugin[0])) {
  while(1) {
    //addr = Plugin[i++];
    if(!track.read(addr.byte, 2)) break;
    //n = Plugin[i++];
    if(!track.read(n.byte, 2)) break;
    if(n.word & 0x8000U) { /* RLE run, replicate n samples */
      n.word &= 0x7FFF;
      //val = Plugin[i++];
      if(!track.read(val.byte, 2)) break;
      while(n.word--) {
        Mp3WriteRegister(addr.word, val.word);
      }
    } else {           /* Copy run, copy n samples */
      while(n.word--) {
        //val = Plugin[i++];
        if(!track.read(val.byte, 2))   break;
        Mp3WriteRegister(addr.word, val.word);
      }
    }
  }
  track.close(); //Close out this track
  //playing_state = ready;
  return 0;
}

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// @{
// SelfTest_Group

//------------------------------------------------------------------------------
uint8_t vs1053::enableTestSineWave(uint8_t freq) {

  if(isPlaying() || !digitalRead(MP3_RESET)) {
    Serial.println(F("Warning Tests are not available."));
    return -1;
  }

  uint16_t MP3SCI_MODE = Mp3ReadRegister(SCI_MODE);
  if(MP3SCI_MODE & SM_TESTS) {
    return 2;
  }

  Mp3WriteRegister(SCI_MODE, MP3SCI_MODE | SM_TESTS);

  for(int y = 0 ; y <= 1 ; y++) { // need to do it twice if it was already done once before
    //Wait for DREQ to go high indicating IC is available
    while(!digitalRead(MP3_DREQ)) ;
    //Select control
    dcs_low();
    //SCI consists of instruction byte, address byte, and 16-bit data word.
    SPI.transfer(0x53);
    SPI.transfer(0xEF);
    SPI.transfer(0x6E);
    SPI.transfer(freq);
    SPI.transfer(0x00);
    SPI.transfer(0x00);
    SPI.transfer(0x00);
    SPI.transfer(0x00);
    while(!digitalRead(MP3_DREQ)) ; //Wait for DREQ to go high indicating command is complete
    dcs_high(); //Deselect Control
  }

  playing_state = testing_sinewave;
  return 1;
}

//------------------------------------------------------------------------------
uint8_t vs1053::disableTestSineWave() {

  if(isPlaying() || !digitalRead(MP3_RESET)) {
    Serial.println(F("Warning Tests are not available."));
    return -1;
  }

  uint16_t MP3SCI_MODE = Mp3ReadRegister(SCI_MODE);
  if(!(MP3SCI_MODE & SM_TESTS)) {
    return 0;
  }

  //Wait for DREQ to go high indicating IC is available
  while(!digitalRead(MP3_DREQ)) ;

  //Select SPI Control channel
  dcs_low();

  //SDI consists of instruction byte, address byte, and 16-bit data word.
  SPI.transfer(0x45);
  SPI.transfer(0x78);
  SPI.transfer(0x69);
  SPI.transfer(0x74);
  SPI.transfer(0x00);
  SPI.transfer(0x00);
  SPI.transfer(0x00);
  SPI.transfer(0x00);
  while(!digitalRead(MP3_DREQ)) ; //Wait for DREQ to go high indicating command is complete

  //Deselect SPI Control channel
  dcs_high();

  // turn test mode bit off
  Mp3WriteRegister(SCI_MODE, Mp3ReadRegister(SCI_MODE) & ~SM_TESTS);

  playing_state = ready;
  return 0;
}

//------------------------------------------------------------------------------
uint16_t vs1053::memoryTest() {

  if(isPlaying() || !digitalRead(MP3_RESET)) {
    Serial.println(F("Warning Tests are not available."));
    return -1;
  }

  playing_state = testing_memory;

  vs_init();

  uint16_t MP3SCI_MODE = Mp3ReadRegister(SCI_MODE);
  if(MP3SCI_MODE & SM_TESTS) {
    playing_state = ready;
    return 2;
  }

  Mp3WriteRegister(SCI_MODE, MP3SCI_MODE | SM_TESTS);

//  for(int y = 0 ; y <= 1 ; y++) { // need to do it twice if it was already done once before
    //Wait for DREQ to go high indicating IC is available
    while(!digitalRead(MP3_DREQ)) ;

    //Select SPI Control channel
    dcs_low();

    //SCI consists of instruction byte, address byte, and 16-bit data word.
    SPI.transfer(0x4D);
    SPI.transfer(0xEA);
    SPI.transfer(0x6D);
    SPI.transfer(0x54);
    SPI.transfer(0x00);
    SPI.transfer(0x00);
    SPI.transfer(0x00);
    SPI.transfer(0x00);
    while(!digitalRead(MP3_DREQ)) ; //Wait for DREQ to go high indicating command is complete

    //Deselect SPI Control channel
    dcs_high();
//  }
  delay(250);

  uint16_t MP3SCI_HDAT0 = Mp3ReadRegister(SCI_HDAT0);

  Mp3WriteRegister(SCI_MODE, Mp3ReadRegister(SCI_MODE) & ~SM_TESTS);

  vs_init();

  playing_state = ready;
  return MP3SCI_HDAT0;
}
// @}
// SelfTest_Group

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// @{
// Volume_Group

//------------------------------------------------------------------------------
void vs1053::setVolume(uint16_t data) {
  union twobyte val;
  val.word = data;
  setVolume(val.byte[1], val.byte[0]);
}

//------------------------------------------------------------------------------
void vs1053::setVolume(uint8_t data) {
  setVolume(data, data);
}

//------------------------------------------------------------------------------
void vs1053::setVolume(uint8_t leftchannel, uint8_t rightchannel){

  VolL = leftchannel;
  VolR = rightchannel;
  Mp3WriteRegister(SCI_VOL, leftchannel, rightchannel);
}

//------------------------------------------------------------------------------
uint16_t vs1053::getVolume() {
  uint16_t MP3SCI_VOL = Mp3ReadRegister(SCI_VOL);
  return MP3SCI_VOL;
}
// @}
// Volume_Group

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// @{
// Base_Treble_Group

//------------------------------------------------------------------------------
uint16_t vs1053::getTrebleFrequency()
{
  union sci_bass_m sci_base_value;
  sci_base_value.word = Mp3ReadRegister(SCI_BASS);
  return (sci_base_value.nibble.Treble_Freqlimt * 1000);
}

//------------------------------------------------------------------------------
int8_t vs1053::getTrebleAmplitude()
{
  union sci_bass_m sci_base_value;
  sci_base_value.word = Mp3ReadRegister(SCI_BASS);
  return (sci_base_value.nibble.Treble_Amplitude);
}
//------------------------------------------------------------------------------
uint16_t vs1053::getBassFrequency()
{
  union sci_bass_m sci_base_value;
  sci_base_value.word = Mp3ReadRegister(SCI_BASS);
  return (sci_base_value.nibble.Bass_Freqlimt * 10);
}

//------------------------------------------------------------------------------
int8_t vs1053::getBassAmplitude()
{
  union sci_bass_m sci_base_value;
  sci_base_value.word = Mp3ReadRegister(SCI_BASS);
  return (sci_base_value.nibble.Bass_Amplitude);
}
//------------------------------------------------------------------------------
void vs1053::setTrebleFrequency(uint16_t frequency)
{
  union sci_bass_m sci_base_value;

  frequency /= 1000;

  if(frequency < 1)
  {
      frequency = 1;
  }
  else if(frequency > 15)
  {
      frequency = 15;
  }
  
  sci_base_value.word = Mp3ReadRegister(SCI_BASS);
  sci_base_value.nibble.Treble_Freqlimt = frequency;
  Mp3WriteRegister(SCI_BASS, sci_base_value.word); 
}

//------------------------------------------------------------------------------
void vs1053::setTrebleAmplitude(int8_t amplitude)
{
  union sci_bass_m sci_base_value;


  if(amplitude < -8)
  {
      amplitude = -8;
  }
  else if(amplitude > 7)
  {
      amplitude = 7;
  }

  sci_base_value.word = Mp3ReadRegister(SCI_BASS);
  sci_base_value.nibble.Treble_Amplitude = amplitude;
  Mp3WriteRegister(SCI_BASS, sci_base_value.word); 
}

//------------------------------------------------------------------------------
void vs1053::setBassFrequency(uint16_t frequency)
{
  union sci_bass_m sci_base_value;

  frequency /= 10;

  if(frequency < 2)
  {
      frequency = 2;
  }
  else if(frequency > 15)
  {
      frequency = 15;
  }

  sci_base_value.word = Mp3ReadRegister(SCI_BASS);
  sci_base_value.nibble.Bass_Freqlimt = frequency;
  Mp3WriteRegister(SCI_BASS, sci_base_value.word); 
}

//------------------------------------------------------------------------------
void vs1053::setBassAmplitude(uint8_t amplitude)
{
  union sci_bass_m sci_base_value;

  if(amplitude < 0)
  {
      amplitude = 0;
  }
  else if(amplitude > 15)
  {
      amplitude = 15;
  }

  sci_base_value.word = Mp3ReadRegister(SCI_BASS);
  sci_base_value.nibble.Bass_Amplitude = amplitude;
  Mp3WriteRegister(SCI_BASS, sci_base_value.word); 
}
// @}
// Base_Treble_Group

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// @{
// PlaySpeed_Group

//------------------------------------------------------------------------------
uint16_t vs1053::getPlaySpeed() {
  uint16_t MP3playspeed = Mp3ReadWRAM(para_playSpeed);
  return MP3playspeed;
}

//------------------------------------------------------------------------------
void vs1053::setPlaySpeed(uint16_t data) {
  Mp3WriteWRAM(para_playSpeed, data);
}
// @}
//PlaySpeed_Group

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// @{
// EarSpeaker_Group

//------------------------------------------------------------------------------
uint8_t vs1053::getEarSpeaker() {
  uint8_t result = 0;
  uint16_t MP3SCI_MODE = Mp3ReadRegister(SCI_MODE);

  // SM_EARSPEAKER bits are not adjacent hence need to add them together
  if(MP3SCI_MODE & SM_EARSPEAKER_LO) {
    result += 0b01;
  }
  if(MP3SCI_MODE & SM_EARSPEAKER_HI) {
    result += 0b10;
  }
  return result;
}

//------------------------------------------------------------------------------
void vs1053::setEarSpeaker(uint16_t EarSpeaker) {
  uint16_t MP3SCI_MODE = Mp3ReadRegister(SCI_MODE);

  // SM_EARSPEAKER bits are not adjacent hence need to add them individually
  if(EarSpeaker & 0b01) {
    MP3SCI_MODE |=  SM_EARSPEAKER_LO;
  } else {
    MP3SCI_MODE &= ~SM_EARSPEAKER_LO;
  }

  if(EarSpeaker & 0b10) {
    MP3SCI_MODE |=  SM_EARSPEAKER_HI;
  } else {
    MP3SCI_MODE &= ~SM_EARSPEAKER_HI;
  }
  Mp3WriteRegister(SCI_MODE, MP3SCI_MODE);
}
// @}
// EarSpeaker_Group

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// @{
// Differential_Output_Mode_Group

//------------------------------------------------------------------------------
uint8_t vs1053::getDifferentialOutput() {
  uint8_t result = 0;
  uint16_t MP3SCI_MODE = Mp3ReadRegister(SCI_MODE);

  if(MP3SCI_MODE & SM_DIFF) {
    result = 1;
  }
  return result;
}

//------------------------------------------------------------------------------
void vs1053::setDifferentialOutput(uint16_t DiffMode) {
  uint16_t MP3SCI_MODE = Mp3ReadRegister(SCI_MODE);

  if(DiffMode) {
    MP3SCI_MODE |=  SM_DIFF;
  } else {
    MP3SCI_MODE &= ~SM_DIFF;
  }
  Mp3WriteRegister(SCI_MODE, MP3SCI_MODE);
}
// @}
// Differential_Output_Mode_Group

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// @{
// Stereo_Group

//------------------------------------------------------------------------------
uint16_t vs1053::getMonoMode() {
  uint16_t result = (Mp3ReadWRAM(para_MonoOutput) & 0x0001);
  return result;
}

//------------------------------------------------------------------------------
void vs1053::setMonoMode(uint16_t StereoMode) {
  uint16_t data = (Mp3ReadWRAM(para_MonoOutput) & ~0x0001); // preserve other bits
  Mp3WriteWRAM(0x1e09, (StereoMode | (data & 0x0001)));
}
// @}
// Stereo_Group

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// @{
// Play_Control_Group

//------------------------------------------------------------------------------
uint8_t vs1053::playTrack(uint8_t trackNo){

  //a storage place for track names
  char trackName[] = "track001.mp3";
  uint8_t trackNumber = 1;

  //tack the number onto the rest of the filename
  sprintf(trackName, "track%03d.mp3", trackNo);

  //play the file
  return playMP3(trackName);
}

//------------------------------------------------------------------------------
uint8_t vs1053::playMP3(char* fileName, uint32_t timecode) {

  if(isPlaying()) return 1;
  if(!digitalRead(MP3_RESET)) return 3;

  //Open the file in read mode.
  if(!track.open(fileName, O_READ)) return 2;

  // find length of arrary at pointer
  int fileNamefileName_length = 0;
  while(*(fileName + fileNamefileName_length))
    fileNamefileName_length++;

  // Only know how to read bitrate from MP3 file. ignore the rest.
  // Note bitrate may get updated later by getAudioInfo()
  if(strstr(strlwr(fileName), "mp3") )  {
    getBitRateFromMP3File(fileName);
    if (timecode > 0) {
      track.seekSet(timecode * bitrate + start_of_music); // skip to X ms.
    }
  }

  playing_state = playback;

  Mp3WriteRegister(SCI_DECODE_TIME, 0); // Reset the Decode and bitrate from previous play back.
  delay(100); // experimentally found that we need to let this settle before sending data.

  //gotta start feeding that hungry mp3 chip
  refill();

  //attach refill interrupt off DREQ line, pin 2
  enableRefill();

  return 0;
}

//------------------------------------------------------------------------------
void vs1053::stopTrack(){

  if(((playing_state != playback) && (playing_state != paused_playback)) || !digitalRead(MP3_RESET))
    return;

  //cancel external interrupt
  disableRefill();
  playing_state = ready;

  track.close(); //Close out this track

  flush_cancel(pre); //possible mode of "none" for faster response.

  //Serial.println(F("Track is done!"));

}

//------------------------------------------------------------------------------
uint8_t vs1053::isPlaying(){
  uint8_t result;

  if(!digitalRead(MP3_RESET))
    result = 3;
  else if(getState() == playback)
    result = 1;
  else if(getState() == paused_playback)
    result = 1;
  else
    result = 0;

  return result;
}

state_m vs1053::getState(){
 return playing_state;
}

//------------------------------------------------------------------------------
void vs1053::pauseDataStream(){

  //cancel external interrupt
  if((playing_state == playback) && digitalRead(MP3_RESET))
  {
    disableRefill();
    playing_state = paused_playback;
  }
}

//------------------------------------------------------------------------------
void vs1053::resumeDataStream(){

  if((playing_state == paused_playback) && digitalRead(MP3_RESET)) {
    //see if it is already ready for more
    refill();

    playing_state = playback;
    //attach refill interrupt off DREQ line, pin 2
    enableRefill();
  }
}

//------------------------------------------------------------------------------
void vs1053::pauseMusic() {
  pauseDataStream();
}

//------------------------------------------------------------------------------
uint8_t vs1053::resumeMusic(uint32_t timecode) {
  if((playing_state == paused_playback) && digitalRead(MP3_RESET)) {

    if(!track.seekSet(((timecode * Mp3ReadWRAM(para_byteRate))/1000) + start_of_music))    //if(!track.seekCur((uint32_t(timecode/1000 * Mp3ReadWRAM(para_byteRate)))))
      return 2;

    resumeDataStream();
    return 0;
  }
  return 1;
}

//------------------------------------------------------------------------------
bool vs1053::resumeMusic() {
  if((playing_state == paused_playback) && digitalRead(MP3_RESET)) {
    resumeDataStream();
    return 0;
  }
  return 1;
}

//------------------------------------------------------------------------------
uint8_t vs1053::skip(int32_t timecode){

  if(isPlaying() && digitalRead(MP3_RESET)) {

    //stop interupt for now
    disableRefill();
    playing_state = paused_playback;

    // try to set the files position to current position + offset(in bytes)
    // as calculated from current byte rate, as per VSdsp.
    if(!track.seekCur((uint32_t(timecode/1000 * Mp3ReadWRAM(para_byteRate))))) // skip next X ms.
      return 2;

    Mp3WriteRegister(SCI_VOL, 0xFE, 0xFE);
    //seeked successfully

    flush_cancel(pre); //possible mode of "none" for faster response.

    //gotta start feeding that hungry mp3 chip
    refill();

    //again, I'm being bad and not following the spec sheet.
    //I already turned the volume down, so when the MP3 chip gets upset at me
    //for just slammin in new bits of the file, you won't hear it.
    //so we'll wait a bit, and restore the volume to previous level
    delay(50);

    //one of these days I'll come back and try to do it the right way.
    setVolume(VolL,VolR);

    playing_state = playback;
    //attach refill interrupt off DREQ line, pin 2
    enableRefill();

    return 0;
  }

  return 1;
}

//------------------------------------------------------------------------------
uint8_t vs1053::skipTo(uint32_t timecode){

  if(isPlaying() && digitalRead(MP3_RESET)) {

    //stop interupt for now
    disableRefill();
    playing_state = paused_playback;

    // try to set the files position to current position + offset(in bytes)
    // as calculated from current byte rate, as per VSdsp.
    if(!track.seekSet(((timecode * Mp3ReadWRAM(para_byteRate))/1000) + start_of_music)) // skip to X ms.
    //if(!track.seekCur((uint32_t(timecode/1000 * Mp3ReadWRAM(para_byteRate))))) // skip next X ms.
      return 2;

    Mp3WriteRegister(SCI_VOL, 0xFE, 0xFE);
    //seeked successfully

    flush_cancel(pre); //possible mode of "none" for faster response.

    //gotta start feeding that hungry mp3 chip
    refill();

    //again, I'm being bad and not following the spec sheet.
    //I already turned the volume down, so when the MP3 chip gets upset at me
    //for just slammin in new bits of the file, you won't hear it.
    //so we'll wait a bit, and restore the volume to previous level
    delay(50);

    //one of these days I'll come back and try to do it the right way.
    setVolume(VolL,VolR);

    playing_state = playback;
    //attach refill interrupt off DREQ line, pin 2
    enableRefill();

    return 0;
  }

  return 1;
}

//------------------------------------------------------------------------------
uint32_t vs1053::currentPosition(){

  return(Mp3ReadRegister(SCI_DECODE_TIME) << 10); // multiply by 1024 to convert to milliseconds.
}

// @}
// Play_Control_Group

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// @{
// Audio_Information_Group

//------------------------------------------------------------------------------
void vs1053::trackArtist(char* infobuffer){
  getTrackInfo(TRACK_ARTIST, infobuffer);
}

//------------------------------------------------------------------------------
void vs1053::trackTitle(char* infobuffer){
  getTrackInfo(TRACK_TITLE, infobuffer);
}

//------------------------------------------------------------------------------
void vs1053::trackAlbum(char* infobuffer){
  getTrackInfo(TRACK_ALBUM, infobuffer);
}

//------------------------------------------------------------------------------
void vs1053::getTrackInfo(uint8_t offset, char* infobuffer){

  //disable interupts
  if(playing_state == playback) {
    disableRefill();
  }

  //record current file position
  uint32_t currentPos = track.curPosition();

  //skip to end
  track.seekEnd((-128 + offset));

  //read 30 bytes of tag informat at -128 + offset
  track.read(infobuffer, 30);
  infobuffer = strip_nonalpha_inplace(infobuffer);

  //seek back to saved file position
  track.seekSet(currentPos);

  //renable interupt
  if(playing_state == playback) {
    enableRefill();
  }

}

//------------------------------------------------------------------------------
void vs1053::getAudioInfo() {

  //disable interupts
  // already disabled in Mp3ReadRegister function
  //pauseDataStream();

  Serial.print(F("HDAT1"));
  Serial.print(F("\tHDAT0"));
  Serial.print(F("\tVOL"));
  Serial.print(F("\tMode"));
  Serial.print(F("\tStatus"));
  Serial.print(F("\tClockF"));
  Serial.print(F("\tpversion"));
  Serial.print(F("\t[Bytes/S]"));
  Serial.print(F("\t[KBits/S]"));
  Serial.print(F("\tPlaySpeed"));
  Serial.print(F("\tDECODE_TIME"));
  Serial.print(F("\tCurrentPos"));
  Serial.println();


  uint16_t MP3HDAT1 = Mp3ReadRegister(SCI_HDAT1);
  Serial.print(F("0x"));
  Serial.print(MP3HDAT1, HEX);

  uint16_t MP3HDAT0 = Mp3ReadRegister(SCI_HDAT0);
  Serial.print(F("\t0x"));
  Serial.print(MP3HDAT0, HEX);

  uint16_t MP3SCI_VOL = Mp3ReadRegister(SCI_VOL);
  Serial.print(F("\t0x"));
  Serial.print(MP3SCI_VOL, HEX);

  uint16_t MP3Mode = Mp3ReadRegister(SCI_MODE);
  Serial.print(F("\t0x"));
  Serial.print(MP3Mode, HEX);

  uint16_t MP3Status = Mp3ReadRegister(SCI_STATUS);
  Serial.print(F("\t0x"));
  Serial.print(MP3Status, HEX);

  uint16_t MP3Clock = Mp3ReadRegister(SCI_CLOCKF);
  Serial.print(F("\t0x"));
  Serial.print(MP3Clock, HEX);

  uint16_t MP3para_version = Mp3ReadWRAM(para_version);
  Serial.print(F("\t0x"));
  Serial.print(MP3para_version, HEX);

  uint16_t MP3ByteRate = Mp3ReadWRAM(para_byteRate);
  Serial.print(F("\t\t"));
  Serial.print(MP3ByteRate, HEX);

  Serial.print(F("\t\t"));
  Serial.print((MP3ByteRate>>7), DEC); // shift 7 is the same as *8/1024, and easier math.

  uint16_t MP3playSpeed = Mp3ReadWRAM(para_playSpeed);
  Serial.print(F("\t\t"));
  Serial.print(MP3playSpeed, HEX);

  uint16_t MP3SCI_DECODE_TIME = Mp3ReadRegister(SCI_DECODE_TIME);
  Serial.print(F("\t\t"));
  Serial.print(MP3SCI_DECODE_TIME, DEC);

  Serial.print(F("\t\t"));
  Serial.print(currentPosition(), DEC);

  Serial.println();
}

//------------------------------------------------------------------------------
void vs1053::getBitRateFromMP3File(char* fileName) {
  //look for first MP3 frame (11 1's)
  bitrate = 0;
  uint8_t temp = 0;
  uint8_t row_num =0;

    for(uint16_t i = 0; i<65535; i++) {
      if(track.read() == 0xFF) {

        temp = track.read();

        if(((temp & 0b11100000) == 0b11100000) && ((temp & 0b00000110) != 0b00000000)) {

          //found the 11 1's
          //parse version, layer and bitrate out and save bitrate
          if(!(temp & 0b00001000)) { 
            row_num = 3;
          }
          else if((temp & 0b00000110) == 0b00000100) { //true if layer 2, false if layer 1 or 3
            row_num += 1;
          }
          else if((temp & 0b00000110) == 0b00000010) { //true if layer 3, false if layer 2 or 1
            row_num += 2;
          } else {
            continue; // Not found, need to skip the rest and continue looking.
                      // \warning But this can lead to a dead end and file end of file.
          }

          //parse bitrate code from next byte
          temp = track.read();
          temp = temp>>4;

          //lookup bitrate
          bitrate = pgm_read_word_near ( &(bitrate_table[temp][row_num]) );

          //convert kbps to Bytes per mS
          bitrate /= 8;

          //record file position
          track.seekCur(-3);
          start_of_music = track.curPosition();

//          Serial.print(F("POS: "));
//          Serial.println(start_of_music);

//          Serial.print(F("Bitrate: "));
//          Serial.println(bitrate);

          //break out of for loop
          break;

        }
      }
    }
  }

//------------------------------------------------------------------------------
int8_t vs1053::getVUmeter() {
  if(Mp3ReadRegister(SCI_STATUS) & SS_VU_ENABLE) {
    return 1;
  }
  return 0;
 }

//------------------------------------------------------------------------------
int8_t vs1053::setVUmeter(int8_t enable) {
  uint16_t MP3Status = Mp3ReadRegister(SCI_STATUS);

  if(enable) {
    Mp3WriteRegister(SCI_STATUS, MP3Status | SS_VU_ENABLE);
  } else {
    Mp3WriteRegister(SCI_STATUS, MP3Status & ~SS_VU_ENABLE);
  }
  return 1; // in future return if not available, if patch not applied.
 }

//------------------------------------------------------------------------------
int16_t vs1053::getVUlevel() {
  return Mp3ReadRegister(SCI_AICTRL3);
}

// @}
// Audio_Information_Group

//------------------------------------------------------------------------------
void vs1053::setBitRate(uint16_t bitr){

  bitrate = bitr;
  return;
}

//------------------------------------------------------------------------------
void vs1053::spiInit() {
  //Set SPI bus for write
  SPI.setBitOrder(MSBFIRST);
  SPI.setDataMode(SPI_MODE0);
  SPI.setClockDivider(spi_Write_Rate);
}

//------------------------------------------------------------------------------
void vs1053::cs_low() {
  spiInit();
  digitalWrite(MP3_XCS, LOW);
}

//------------------------------------------------------------------------------
void vs1053::cs_high() {
  digitalWrite(MP3_XCS, HIGH);
}

//------------------------------------------------------------------------------
void vs1053::dcs_low() {
  spiInit();
  digitalWrite(MP3_XDCS, LOW);
}

//------------------------------------------------------------------------------
void vs1053::dcs_high() {
  digitalWrite(MP3_XDCS, HIGH);
}

//------------------------------------------------------------------------------
void vs1053::Mp3WriteRegister(uint8_t addressbyte, uint16_t data) {
  union twobyte val;
  val.word = data;
  Mp3WriteRegister(addressbyte, val.byte[1], val.byte[0]);
}

//------------------------------------------------------------------------------
void vs1053::Mp3WriteRegister(uint8_t addressbyte, uint8_t highbyte, uint8_t lowbyte) {

  // skip if the chip is in reset.
  if(!digitalRead(MP3_RESET)) return;

  //cancel interrupt if playing
  if(playing_state == playback)
    disableRefill();

  //Wait for DREQ to go high indicating IC is available
  while(!digitalRead(MP3_DREQ)) ;

  cs_low(); //Select control

  //SCI consists of instruction byte, address byte, and 16-bit data word.
  SPI.transfer(0x02); //Write instruction
  SPI.transfer(addressbyte);
  SPI.transfer(highbyte);
  SPI.transfer(lowbyte);
  while(!digitalRead(MP3_DREQ)) ; //Wait for DREQ to go high indicating command is complete
  cs_high(); //Deselect Control

  //resume interrupt if playing.
  if(playing_state == playback) {
    //see if it is already ready for more
    refill();

    //attach refill interrupt off DREQ line, pin 2
    enableRefill();
  }

}

//------------------------------------------------------------------------------
uint16_t vs1053::Mp3ReadRegister (uint8_t addressbyte){

  union twobyte resultvalue;

  // skip if the chip is in reset.
  if(!digitalRead(MP3_RESET)) return 0;

  //cancel interrupt if playing
  if(playing_state == playback)
    disableRefill();

  while(!digitalRead(MP3_DREQ)) ; //Wait for DREQ to go high indicating IC is available

  cs_low(); //Select control
  SPI.setClockDivider(spi_Read_Rate); // correct the clock speed as from cs_low()

  //SCI consists of instruction byte, address byte, and 16-bit data word.
  SPI.transfer(0x03);  //Read instruction
  SPI.transfer(addressbyte);

  resultvalue.byte[1] = SPI.transfer(0xFF); //Read the first byte
  while(!digitalRead(MP3_DREQ)) ; //Wait for DREQ to go high indicating command is complete
  resultvalue.byte[0] = SPI.transfer(0xFF); //Read the second byte
  while(!digitalRead(MP3_DREQ)) ; //Wait for DREQ to go high indicating command is complete

  cs_high(); //Deselect Control

  //resume interrupt if playing.
  if(playing_state == playback) {
    //see if it is already ready for more
    refill();

    //attach refill interrupt off DREQ line, pin 2
    enableRefill();
  }
  return resultvalue.word;
}

//------------------------------------------------------------------------------
uint16_t vs1053::Mp3ReadWRAM (uint16_t addressbyte){

  unsigned short int tmp1,tmp2;

  //Set SPI bus for write
  spiInit();
  SPI.setClockDivider(spi_Read_Rate);

  Mp3WriteRegister(SCI_WRAMADDR, addressbyte);
  tmp1 = Mp3ReadRegister(SCI_WRAM);

  Mp3WriteRegister(SCI_WRAMADDR, addressbyte);
  tmp2 = Mp3ReadRegister(SCI_WRAM);

  if(tmp1==tmp2) return tmp1;
  Mp3WriteRegister(SCI_WRAMADDR, addressbyte);
  tmp2 = Mp3ReadRegister(SCI_WRAM);

  if(tmp1==tmp2) return tmp1;
  Mp3WriteRegister(SCI_WRAMADDR, addressbyte);
  tmp2 = Mp3ReadRegister(SCI_WRAM);

  if(tmp1==tmp2) return tmp1;
  return tmp1;
}

//------------------------------------------------------------------------------
//Write the 16-bit value of a VS10xx WRAM location
void vs1053::Mp3WriteWRAM(uint16_t addressbyte, uint16_t data){

  Mp3WriteRegister(SCI_WRAMADDR, addressbyte);
  Mp3WriteRegister(SCI_WRAM, data);
}

//------------------------------------------------------------------------------
void vs1053::available() {
#if defined(USE_MP3_REFILL_MEANS) && USE_MP3_REFILL_MEANS == USE_MP3_SimpleTimer
  timer.run();
#elif defined(USE_MP3_REFILL_MEANS) && USE_MP3_REFILL_MEANS == USE_MP3_Polled
  refill();
#endif
}

//------------------------------------------------------------------------------
void vs1053::refill() {

  //Serial.println(F("filling"));
#if PERF_MON_PIN != -1
  digitalWrite(PERF_MON_PIN,LOW);
#endif

  // no need to keep interrupts blocked, allow other ISR such as timer0 to continue
#if !defined(USE_MP3_REFILL_MEANS) || USE_MP3_REFILL_MEANS == USE_MP3_INTx
  sei();
#endif

  while(digitalRead(MP3_DREQ)) {

    if(!track.read(mp3DataBuffer, sizeof(mp3DataBuffer))) { //Go out to SD card and try reading 32 new bytes of the song
      track.close(); //Close out this track
      playing_state = ready;

      //cancel external interrupt
      disableRefill();

      flush_cancel(post); //possible mode of "none" for faster response.

      //Oh no! There is no data left to read!
      //Time to exit
      break;
    }


    //Once DREQ is released (high) we now feed 32 bytes of data to the VS1053 from our SD read buffer
#if !defined(USE_MP3_REFILL_MEANS) || USE_MP3_REFILL_MEANS == USE_MP3_INTx
    cli(); // allow transfer to occur with out interruption.
#endif
    dcs_low(); //Select Data
    for(uint8_t y = 0 ; y < sizeof(mp3DataBuffer) ; y++) {
      //while(!digitalRead(MP3_DREQ)); // wait until DREQ is or goes high // turns out it is not needed.
      SPI.transfer(mp3DataBuffer[y]); // Send SPI byte
    }

    dcs_high(); //Deselect Data
    //We've just dumped 32 bytes into VS1053 so our SD read buffer is empty. go get more data
#if !defined(USE_MP3_REFILL_MEANS) || USE_MP3_REFILL_MEANS == USE_MP3_INTx
    sei();
#endif
  }

#if PERF_MON_PIN != -1
  digitalWrite(PERF_MON_PIN,HIGH);
#endif
}

//------------------------------------------------------------------------------
void vs1053::SendSingleMIDInote() {

  if(!digitalRead(MP3_RESET))
    return;

  //cancel and store current state to restore after
  disableRefill();
  state_m prv_state = playing_state;
  playing_state = playMIDIbeep;
  
  // need to quickly purge the exiting formate of decoder.
  flush_cancel(none);

  // wait for VS1053 to be available.
  while(!digitalRead(MP3_DREQ)); 

#if !defined(USE_MP3_REFILL_MEANS) || USE_MP3_REFILL_MEANS == USE_MP3_INTx
  cli(); // allow transfer to occur with out interruption.
#endif

  dcs_low(); //Select Data
  for(uint8_t y = 0 ; y < sizeof(SingleMIDInoteFile) ; y++) { // sizeof(mp3DataBuffer)
    // Every 32 check if not ready for next buffer chunk.
    if ( !(y % 32) ) {
      while(!digitalRead(MP3_DREQ));
    }
    SPI.transfer( pgm_read_byte_near( &(SingleMIDInoteFile[y]))); // Send next byte
  }
  dcs_high(); //Deselect Data

#if !defined(USE_MP3_REFILL_MEANS) || USE_MP3_REFILL_MEANS == USE_MP3_INTx
  sei();  // renable interrupts for other processes
#endif

  flush_cancel(none); // need to quickly purge the exiting format of decoder.
  playing_state = prv_state;
  enableRefill();
}

//------------------------------------------------------------------------------
void vs1053::enableRefill() {
  if(playing_state == playback) {
    #if defined(USE_MP3_REFILL_MEANS) && USE_MP3_REFILL_MEANS == USE_MP3_Timer1
      Timer1.attachInterrupt( refill );
    #elif defined(USE_MP3_REFILL_MEANS) && USE_MP3_REFILL_MEANS == USE_MP3_SimpleTimer
      timer.enable(timerId_mp3);
    #elif !defined(USE_MP3_REFILL_MEANS) || USE_MP3_REFILL_MEANS == USE_MP3_INTx
      attachInterrupt(MP3_DREQINT, refill, RISING);
    #endif
  }
}

//------------------------------------------------------------------------------
void vs1053::disableRefill() {
#if defined(USE_MP3_REFILL_MEANS) && USE_MP3_REFILL_MEANS == USE_MP3_Timer1
  Timer1.detachInterrupt();
#elif defined(USE_MP3_REFILL_MEANS) && USE_MP3_REFILL_MEANS == USE_MP3_SimpleTimer
  timer.disable(timerId_mp3);
#elif !defined(USE_MP3_REFILL_MEANS) || USE_MP3_REFILL_MEANS == USE_MP3_INTx
  detachInterrupt(MP3_DREQINT);
#endif
}

//------------------------------------------------------------------------------
void vs1053::flush_cancel(flush_m mode) {
  int8_t endFillByte = (int8_t) (Mp3ReadWRAM(para_endFillByte) & 0xFF);

  if((mode == post) || (mode == both)) {

    dcs_low(); //Select Data
    for(int y = 0 ; y < 2052 ; y++) {
      while(!digitalRead(MP3_DREQ)); // wait until DREQ is or goes high
      SPI.transfer(endFillByte); // Send SPI byte
    }
    dcs_high(); //Deselect Data
  }

  for (int n = 0; n < 64 ; n++)
  {
//    Mp3WriteRegister(SCI_MODE, SM_LINE1 | SM_SDINEW | SM_CANCEL); // old way of SCI_MODE WRITE.
    Mp3WriteRegister(SCI_MODE, (Mp3ReadRegister(SCI_MODE) | SM_CANCEL));

    dcs_low(); //Select Data
    for(int y = 0 ; y < 32 ; y++) {
      while(!digitalRead(MP3_DREQ)); // wait until DREQ is or goes high
      SPI.transfer(endFillByte); // Send SPI byte
    }
    dcs_high(); //Deselect Data

    int cancel = Mp3ReadRegister(SCI_MODE) & SM_CANCEL;
    if(cancel == 0) {
      // Cancel has succeeded.
      if((mode == pre) || (mode == both)) {
        dcs_low(); //Select Data
        for(int y = 0 ; y < 2052 ; y++) {
          while(!digitalRead(MP3_DREQ)); // wait until DREQ is or goes high
          SPI.transfer(endFillByte); // Send SPI byte
        }
        dcs_high(); //Deselect Data
      }
      return;
    }
  }
  // Cancel has not succeeded.
  //Serial.println(F("Warning: VS10XX chip did not cancel, reseting chip!"));
//  Mp3WriteRegister(SCI_MODE, SM_LINE1 | SM_SDINEW | SM_RESET); // old way of SCI_MODE WRITE.
  Mp3WriteRegister(SCI_MODE, (Mp3ReadRegister(SCI_MODE) | SM_RESET));  // software reset. but vs_init will HW reset anyways.
//  vs_init(); // perform hardware reset followed by re-initializing.
  //vs_init(); // however, vs1053::begin() is member function that does not exist statically.
}


//------------------------------------------------------------------------------
uint8_t vs1053::ADMixerLoad(char* fileName){

  if(!digitalRead(MP3_RESET)) return 3;
  if(isPlaying() != FALSE)
    return 1;

  playing_state = loading;
  if(VSLoadUserCode(fileName)) {
    playing_state = ready;
    return 2;
    // Serial.print(F("Error: ")); Serial.print(fileName); Serial.println(F(", file not found, skipping."));
  }

  // Set Input Mode to either Line1 or Microphone.
#if defined(VS_LINE1_MODE)
    Mp3WriteRegister(SCI_MODE, (Mp3ReadRegister(SCI_MODE) | SM_LINE1));
#else
    Mp3WriteRegister(SCI_MODE, (Mp3ReadRegister(SCI_MODE) & ~SM_LINE1));
#endif
  playing_state = ready;
  return 0;
}

//------------------------------------------------------------------------------
void vs1053::ADMixerVol(int8_t ADM_volume){
  union twobyte MP3AIADDR;
  union twobyte MP3AICTRL0;

  MP3AIADDR.word = Mp3ReadRegister(SCI_AIADDR);

  if((ADM_volume > -3) || (-31 > ADM_volume)) {
    // Disable Mixer Patch
    MP3AIADDR.word = 0x0F01;
    Mp3WriteRegister(SCI_AIADDR, MP3AIADDR.word);
  } else {
    // Set Volume
    //MP3AICTRL0.word = Mp3ReadRegister(SCI_AICTRL0);
    MP3AICTRL0.byte[1] = (uint8_t) ADM_volume; // upper byte appears to have no affect
    MP3AICTRL0.byte[0] = (uint8_t) ADM_volume;
    Mp3WriteRegister(SCI_AICTRL0, MP3AICTRL0.word);

    // Enable Mixer Patch
    MP3AIADDR.word = 0x0F00;
    Mp3WriteRegister(SCI_AIADDR, MP3AIADDR.word);
  }
}


//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Global Function

char* strip_nonalpha_inplace(char *s) {
  for ( ; *s && !isalpha(*s); ++s)
    ; // skip leading non-alpha chars
  if(*s == '\0')
    return s; // there are no alpha characters

  char *tail = s + strlen(s);
  for ( ; !isalpha(*tail); --tail)
    ; // skip trailing non-alpha chars
  *++tail = '\0'; // truncate after the last alpha

  return s;
}

bool isFnMusic(char* filename) {
  int8_t len = strlen(filename);
  bool result;
  if (  strstr(strlwr(filename + (len - 4)), ".mp3")
     || strstr(strlwr(filename + (len - 4)), ".aac")
     || strstr(strlwr(filename + (len - 4)), ".wma")
     || strstr(strlwr(filename + (len - 4)), ".wav")
     || strstr(strlwr(filename + (len - 4)), ".fla")
     || strstr(strlwr(filename + (len - 4)), ".mid")
    ) {
    result = true;
  } else {
    result = false;
  }
  return result;
}