Brauche kurz Hilfe bei MP3-Player

[Tobias P. (hubertus)]

Hallo

angeregt durch einen anderen Thread, den ich hier mal gelesen habe, 
wollte ich auch einen eigenen MP3-Player bauen. Um zu testen, ob alles 
funktioniert, benutze ich das STM32F4 Discovery Board. Dort habe ich 
einen SD-Kartensockel angelötet. In meiner Software ist FATFS von 
ElmChan drin, sowie der Helix-Decoder.

Zuerst habe ich, um den Decoder zu testen, einfach eine kleine MP3-Datei 
als Array in den Flash des STM geladen und dann jeweils Stück für Stück 
in den RAM kopiert. Damit hat das Abspielen eines MP3 wunderbar 
geklappt, ohne Aussetzer oder so, selbst bei 48 kHz und 320 kBuit/s. 
Jetzt will ich das MP3-File allerdings von der SD-Karte lesen! Da ich 
später noch ein GUI implementieren will, habe ich mir gedacht, die SW 
als kleinen Zustandsautomaten zu implementierren. Hier mein main-Code:

__attribute__((noreturn)) void main(void)
{
   state_t state = init_play_mp3;
  int ind = 0;
  int remain_bytes;
  int free_samples;
  int bytes_to_read;

  int br;
  int filesize;
  memset(buf, 0, sizeof(buf));
  memset(sdbuf, 0, sizeof(sdbuf));


  init_hardware();

  mci_media_init();


  f_mount(&fs, "0:", 1);





  while(1)
  {



    switch(state)
    {
      case init_play_mp3:
      {
        init_mp3(buf, NUMOF_ELEMENTS(buf));
        state = preload_mp3_buffer;

        f_open(&fl, "0:/eminence_front.mp3", FA_READ);
          f_stat("0:/eminence_front.mp3", &fileinfo);
          filesize = fileinfo.fsize;

          ind = 0;

        break;
      }

      case preload_mp3_buffer:
      {
        int decoded_bytes;

        bytes_to_read = (filesize - ind) > BUFSZ ? BUFSZ : (filesize - ind);

        f_lseek(&fl, ind);
        f_read(&fl, sdbuf, bytes_to_read, &br);


        remain_bytes = decode_mp3(sdbuf, bytes_to_read);
        decoded_bytes = bytes_to_read - remain_bytes;

        ind = ind + decoded_bytes;

        free_samples = get_free_samps();


        if(free_samples < 4608)
        {
          start_playback();
          state = play_mp3;
        }

        break;
      }

      case play_mp3:
      {

        int prev_remain_bytes = 0;
        int decoded_bytes;

        free_samples = get_free_samps();
        if(free_samples > 2304*1)
        {



          GPIOC_BSRR = BIT_05;
          prev_remain_bytes = remain_bytes;

          remain_bytes = decode_mp3(&sdbuf[sizeof(sdbuf)-remain_bytes], remain_bytes);
          decoded_bytes = prev_remain_bytes - remain_bytes;
          ind = ind + decoded_bytes;

          GPIOC_BSRR = BIT_21;
        }


        if((remain_bytes < 512) || (decoded_bytes == 0))
        {

          GPIOD_BSRR = BIT_12;
          bytes_to_read = (filesize - ind) > BUFSZ ? BUFSZ : (filesize - ind);

          if(bytes_to_read < 100)
          {
            stop_playback();
            state = stop_mp3;
            break;
          }
          f_lseek(&fl, ind);
          f_read(&fl, sdbuf, bytes_to_read, &br);

          remain_bytes = bytes_to_read;

          GPIOD_BSRR = BIT_28;
        }



        break;
      }

      case stop_mp3:
      {
        free_mp3();
        state = init_play_mp3;
        ind = 0;
        break;
      }
    }
  }
}

Jetzt stelle ich allerdings fest, dass es gelegentlich zu kleinen 
Aussetzern kommt. Da alles funktioniert, wenn ich die Datei per memcpy() 
aus dem Flash kopiere und so decodieren, muss das Problem am 
Buffer-Management zusammen mit dem Lesen der SD-Karte zusammenhängen. 
Leider sehe ich gerade nicht, wo man was optimieren müsste. Wäre es 
möglich dass die Profis hier mal kurz auf meinen Code schauen? :-)