vs1053_avr_renesas_uno.cpp

Go to the documentation of this file.

#include <vs1053_avr_renesas_uno.h>
// Include the SPI library.
#include "SPI.h"
// Excludes the avr/pgmspace library as it is incompatible with the Renesas architecture.
#if !defined(ARDUINO_ARCH_RENESAS)  
// The avr/pgmspace library for storing the LUT in program flash memory instead of SRAM.
#include <avr/pgmspace.h>            
#endif                                

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
 
/*
 * Retrieves the interrupt identifier corresponding to the MP3_DREQ pin.
 * If the pin is valid for interrupts, its IRQ number is assigned. 
 */
int8_t irq = digitalPinToInterrupt(MP3_DREQ);   

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;

uint32_t vs1053::spi_Max_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_Max_Rate = 1000000; // 1 MHz for initializations. 
  delay(10); 
 
  // Let's check the status of the VS1053.
  int MP3Mode = Mp3ReadRegister(SCI_MODE);
 
/* // Debug information disabled.
  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);
 */
   
  // Validate VS1053 initialization.
  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.
 
  // Adjust SPI based on microcontroller type.
#if (ARDUINO_ARCH_AVR)
  spi_Max_Rate = 4000000; // 4 MHz for AVR based boards.
#elif (ARDUINO_ARCH_RENESAS)
  spi_Max_Rate = 7900000; // 7.9 MHz for Arduino UNO R4 boards.
#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.
    SPI.endTransaction(); // ends SPI transaction, freeing the bus.   
  }
 
  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();
  SPI.endTransaction(); // ends SPI transaction, freeing the bus.  
 
  // 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();
    SPI.endTransaction(); // ends SPI transaction, freeing the bus.  
//  }
  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;
 
  // Calculate the length of the file name.
  int len = strlen(fileName); 
  
  // Only know how to read bitrate from MP3 file. ignore the rest.
  // Note bitrate may get updated later by getAudioInfo().
  if (len > 3 && !strcasecmp(fileName + len - 3, "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)) { // !true if Version 1, !false version 2 and 2.5.
            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 port configuration.
  SPI.beginTransaction(SPISettings(spi_Max_Rate, MSBFIRST, SPI_MODE0)); 
}
 
//------------------------------------------------------------------------------
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.
  SPI.endTransaction(); // ends SPI transaction, freeing the bus.  
 
  // 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.
  
  // 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.
  SPI.endTransaction(); // ends SPI transaction, freeing the bus.  
 
  // 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();
  
  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 == irq
  interrupts(); // renable interrupts for other processes.
#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 == irq
   noInterrupts(); // 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.
    SPI.endTransaction(); // ends SPI transaction, freeing the bus.  
 
    // 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 == irq
  interrupts(); // renable interrupts for other processes.
#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)); // wait until DREQ is or goes high.
 
#if !defined(USE_MP3_REFILL_MEANS) || USE_MP3_REFILL_MEANS == irq
  noInterrupts(); // 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)); // wait until DREQ is or goes high.
    }
    SPI.transfer( pgm_read_byte_near( &(SingleMIDInoteFile[y]))); // send next byte.
  }
  dcs_high(); // deselect Data.
  SPI.endTransaction(); // ends SPI transaction, freeing the bus.  
 
#if !defined(USE_MP3_REFILL_MEANS) || USE_MP3_REFILL_MEANS == irq
  interrupts(); // 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 == irq
      refill();                                                   
      attachInterrupt(irq, 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 == irq  
  detachInterrupt(irq);
#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.
    SPI.endTransaction(); // ends SPI transaction, freeing the bus.  
  }
 
  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.
    SPI.endTransaction(); // ends SPI transaction, freeing the bus.  
 
    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.
        SPI.endTransaction(); // ends SPI transaction, freeing the bus.  
      }
      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 (len > 4 &&
      (!strcasecmp(filename + len - 4, ".mp3") 
      || !strcasecmp(filename + len - 4, ".aac")
      || !strcasecmp(filename + len - 4, ".wma")
      || !strcasecmp(filename + len - 4, ".wav")
      || !strcasecmp(filename + len - 4, ".fla")
      || !strcasecmp(filename + len - 4, ".mid"))) {
    
    result = true;
  } else {
    result = false;
  }
  return result;
}