STM32F429 WM8789 MP3

[Peter (Gast)]

Hallo,
ich versuche grade das Beispiel von ST zum laufen zu bekommen um MP3 von 
SD-Card Abzuspielen, es wird zwar die MP3 abgespielt aber extrem langsam 
und total verzerrt.
vielleicht kann mir einer weiterhelfen.
mfg

/* Private define ------------------------------------------------------------*/
#define READBUF_SIZE  (5 * 1024)       /* Value must min be 2xMAINBUF_SIZE = 2x1940 = 3880bytes */
#define BUFF_SIZE 4608
typedef struct buffs
{
  short BufData[BUFF_SIZE];
  struct buffs * Next;
}BuffDef;
BuffDef Buff[2];
BuffDef* BuffP = &Buff[0];
/* Private variables ---------------------------------------------------------*/
AUDIO_PlaybackBuffer_Status BufferStatus; /* Status of buffer */
s16 AudioBuffer[4608];          /* Playback buffer - Value must be 4608 to hold 2xMp3decoded frames */
MP3FrameInfo mp3FrameInfo;      /* Content is the output from MP3GetLastFrameInfo, 
                                   we only read this once, and conclude it will be the same in all frames
                                   Maybe this needs to be changed, for different requirements */
static HMP3Decoder hMP3Decoder; /* Content is the pointers to all buffers and information for the MP3 Library */
volatile uint32_t bytesLeft;    /* Saves how many bytes left in readbuf  */
volatile uint32_t outOfData;    /* Used to set when out of data to quit playback */
volatile AUDIO_PlaybackBuffer_Status  audio_buffer_fill ; 
volatile int Audio_buffer_index = 0;
volatile uint16_t Audio_buffer_size = 0;
volatile s16 Audio_buffer_local[LOCAL_BUFFER_SIZE];       /* working buffer for MONO mode management */
AUDIO_Playback_status_enum AUDIO_Playback_status ;
AUDIO_Format_enum AUDIO_Format ;
AUDIO_Length_enum AUDIO_Length ;
AUDIO_PlaybackBuffer_Status bufferstatus_local;
s8  *Audio_buffer;
int Audio_buffer_local_size = LOCAL_BUFFER_SIZE;
uint8_t readBuf[READBUF_SIZE];       /* Read buffer where data from SD card is read to */ 
uint8_t *readPtr;                    /* Pointer to the next new data */
uint32_t MP3Size;                  
uint32_t MP3_Data_Index;            
uint16_t AUDIO_Frequency ;
uint32_t n_Read;                     /* File R/W count */

FIL fsra;      // file objects
UINT ba;         /* File read/write count */







/*******************************************************************************
* Function Name  : AUDIO_PlaybackBuffer_Status
* Description    : Gets the status of Playback buffer
* Input          : - value: 0 = get the current status, else reset the flag
*                           passed in parameter
* Output         : None
* Return         : FULL=0, LOW_EMPTY=1, HIGH_EMPTY=2
* Attention     : None
*******************************************************************************/
AUDIO_PlaybackBuffer_Status AUDIO_PlaybackBuffer_GetStatus(AUDIO_PlaybackBuffer_Status value)
{
    if ( value )
        audio_buffer_fill &= ~value;
    return audio_buffer_fill; 
}

/*******************************************************************************
* Function Name  : AUDIO_Playback_Stop
* Description    : Stop the playback by stopping the DMA transfer
* Input          : None
* Output         : None
* Return         : None
* Attention     : None
*******************************************************************************/
void AUDIO_Playback_Stop(void)
{
  /* Enable the SAI DMA Stream*/
  DMA_Cmd(AUDIO_MAL_DMA_STREAM, DISABLE);

   AUDIO_Playback_status = NO_SOUND;       
   /* Shutdwon codec in order to avoid non expected voices */
   //codec_send( ACTIVE_CONTROL | INACTIVE );
}


/*******************************************************************************
* Function Name  : MP3_GetStrResult
* Description    : Convert file access error number in string
* Input          : None
* Output         : None
* Return         : None
* Attention     : None
*******************************************************************************/
const char* MP3_GetStrResult(int err)
{
    switch(err) {
        case ERR_MP3_NONE :                   return "ERR_MP3_NONE";
        case ERR_MP3_INDATA_UNDERFLOW :       return "ERR_MP3_INDATA_UNDERFLOW";
        case ERR_MP3_MAINDATA_UNDERFLOW :     return "ERR_MP3_MAINDATA_UNDERFLOW";
        case ERR_MP3_FREE_BITRATE_SYNC :      return "ERR_MP3_FREE_BITRATE_SYNC";
        case ERR_MP3_OUT_OF_MEMORY :          return "ERR_MP3_OUT_OF_MEMORY";
        case ERR_MP3_NULL_POINTER :           return "ERR_MP3_NULL_POINTER";
        case ERR_MP3_INVALID_FRAMEHEADER :    return "ERR_MP3_INVALID_FRAMEHEADER";   
        case ERR_MP3_INVALID_SIDEINFO :       return "ERR_MP3_INVALID_SIDEINFO"; 
        case ERR_MP3_INVALID_SCALEFACT :      return "ERR_MP3_INVALID_SCALEFACT";
        case ERR_MP3_INVALID_HUFFCODES :      return "ERR_MP3_INVALID_HUFFCODES";
        case ERR_MP3_INVALID_DEQUANTIZE :     return "ERR_MP3_INVALID_DEQUANTIZE";
        case ERR_MP3_INVALID_IMDCT :          return "ERR_MP3_INVALID_IMDCT";
        case ERR_MP3_INVALID_SUBBAND :        return "ERR_MP3_INVALID_SUBBAND";
        case ERR_UNKNOWN :                    return "ERR_UNKNOWN";  
        default :                             return "?";
    }  
}

/*******************************************************************************
* Function Name  : DMA_Configuration
* Description    : DMA1 channel5 configuration
* Input          : None
* Output         : None
* Return         : None
* Attention     : None
*******************************************************************************/
void DMA_Configuration( s8 * addr, int size)
{
  DMA_InitTypeDef DMA_InitStructure;

  /* Enable the SAI  */
  //SAI_Cmd(CODEC_SAI, DISABLE);
  
  /* Enable the DMA clock */
  RCC_AHB1PeriphClockCmd(AUDIO_MAL_DMA_CLOCK, ENABLE); 

    /* Configure the DMA Stream */
  DMA_Cmd(AUDIO_MAL_DMA_STREAM, DISABLE);
  DMA_DeInit(AUDIO_MAL_DMA_STREAM);
  
    if(AUDIO_Format == STEREO)
    {
       /* Uses the original buffer  */            
     DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t) addr; /* Set the buffer */
     DMA_InitStructure.DMA_BufferSize = size;             /* Set the size */
    }
    else
    {
       /* Uses the local buffer */
       if ( AUDIO_Length == LG_16_BITS )   size *= 2;   
       Audio_buffer = addr;                         /* Copy the pointer to real databuffer/source */
       Audio_buffer_index = 0;                      /* Copy the pointer to real databuffer/source */
       Audio_buffer_size = size;                    /* Size to the real databuffer/source */
     DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)Audio_buffer_local;   /* Set the buffer */
     DMA_InitStructure.DMA_BufferSize = ((Audio_buffer_local_size)/2);;    /* Set the size */
    }

  /* Set the parameters to be configured */
  DMA_InitStructure.DMA_Channel = AUDIO_MAL_DMA_CHANNEL;  
  DMA_InitStructure.DMA_PeripheralBaseAddr = CODEC_SAI_ADDRESS;
  DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral;
  DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
  DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
  DMA_InitStructure.DMA_PeripheralDataSize = AUDIO_MAL_DMA_PERIPH_DATA_SIZE;
  DMA_InitStructure.DMA_MemoryDataSize = AUDIO_MAL_DMA_MEM_DATA_SIZE; 
#ifdef AUDIO_MAL_MODE_NORMAL
  DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
#elif defined(AUDIO_MAL_MODE_CIRCULAR)
  DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
#else
  #error "AUDIO_MAL_MODE_NORMAL or AUDIO_MAL_MODE_CIRCULAR should be selected !!"
#endif /* AUDIO_MAL_MODE_NORMAL */  
  DMA_InitStructure.DMA_Priority = DMA_Priority_High;
  DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable;         
  DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;
  DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;
  DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;  
  DMA_Init(AUDIO_MAL_DMA_STREAM, &DMA_InitStructure);  

  /* Enable the selected DMA interrupts (selected in "stm32_eval_audio_codec.h" defines) */
#ifdef AUDIO_MAL_DMA_IT_TC_EN
  DMA_ITConfig(AUDIO_MAL_DMA_STREAM, DMA_IT_TC, ENABLE);
#endif /* AUDIO_MAL_DMA_IT_TC_EN */
#ifdef AUDIO_MAL_DMA_IT_HT_EN
  DMA_ITConfig(AUDIO_MAL_DMA_STREAM, DMA_IT_HT, ENABLE);
#endif /* AUDIO_MAL_DMA_IT_HT_EN */
#ifdef AUDIO_MAL_DMA_IT_TE_EN
  DMA_ITConfig(AUDIO_MAL_DMA_STREAM, DMA_IT_TE | DMA_IT_FE | DMA_IT_DME, ENABLE);
#endif /* AUDIO_MAL_DMA_IT_TE_EN */
  
  /* Enable the SAI DMA request */
  SAI_DMACmd(CODEC_SAI, ENABLE);
  /* Enable the SAI DMA Stream*/
  DMA_Cmd(AUDIO_MAL_DMA_STREAM, ENABLE);

  
  /* If the SAI peripheral is still not enabled, enable it */
  if (SAI_GetCmdStatus(CODEC_SAI) == DISABLE)
  {
    SAI_Cmd(CODEC_SAI, ENABLE);
  }  
}


/*******************************************************************************
* Function Name  : PlayAudioFile
* Description    : None
* Input          : None
* Output         : None
* Return         : None
* Attention     : None
*******************************************************************************/
void PlayAudioFile(void)
{
  Buff[0].Next = &Buff[1];
  Buff[1].Next = &Buff[0];
  
  static UINT br; 
  s32 offset;                                  // Used to save the offset to the next frame    
  int errs = 0;                                   // Return value from MP3decoder
  FRESULT res;
  FILINFO finfo;
  DIR dirs;  
   /* Reset counters */
   bytesLeft = 0;   
   outOfData = 0;   
 
  
  
   readPtr = readBuf;  
   hMP3Decoder = MP3InitDecoder();  

              //f_chdir("/MP3");
/**/
    if (f_opendir(&dirs, "") == FR_OK)         //Ŀ¼´ò¿ª³É¹¦ 
    {
      while (f_readdir(&dirs, &finfo) == FR_OK)      //Ŀ¼ÏÂÊÇ·ñÓÐÎļþ
      {
        if (finfo.fattrib & AM_ARC) 
        {
          if(!finfo.fname[0]) break;
          
          //Usart_Puts("\r\n Now Playing:[");
          //Usart_Puts(finfo.fname);
          //Usart_Puts("]\r\n");

           DrawString(200,350,finfo.fname,&Arial_16x25,Orange,BLACK);
          res = f_open(&fsra, finfo.fname, FA_OPEN_EXISTING | FA_READ);
          //res = f_open(&fsra, "FR", FA_READ);
          // Reset counters //
              

          res = f_read(&fsra,readBuf,READBUF_SIZE,&br);
          bytesLeft += br;
          
          //if( (res) ||(br == 0)) break;

          while(1)
          {
            
            
            // find start of next MP3 frame - assume EOF if no sync found //
            offset = MP3FindSyncWord(readPtr, bytesLeft);
            if (offset < 0) 
            {
                    outOfData = 1;
                    break;
            }
            else
            {
              readPtr += offset;                         //data start point
              bytesLeft -= offset;                 //in buffer
              errs = MP3Decode(hMP3Decoder, &readPtr, (int *)&bytesLeft, (short *)AudioBuffer, 0); 

              if (bytesLeft < READBUF_SIZE)
              {
                memmove(readBuf,readPtr,bytesLeft);
                res = f_read(&fsra, readBuf + bytesLeft, READBUF_SIZE - bytesLeft, &br);
                if( (res) ||(br == 0)) break;
                
                if (br < READBUF_SIZE - bytesLeft)
                memset(readBuf + bytesLeft + br, 0, READBUF_SIZE - bytesLeft - br);
                bytesLeft=READBUF_SIZE;
                readPtr=readBuf;                
              }

              MP3GetLastFrameInfo(hMP3Decoder, &mp3FrameInfo);
              
   // Select the correct samplerate and Mono/Stereo //
            AUDIO_Init_audio_mode( ( AUDIO_Length_enum )mp3FrameInfo.bitsPerSample,  \
            ((MP3DecInfo *)hMP3Decoder)->samprate,  \
            (((MP3DecInfo *)hMP3Decoder)->nChans==2) ? MONO : STEREO);
            }
          }
          f_close(&fsra);


        
        }
      }
      //break;
    }
    //OSTimeDly(10);

                  
   MP3GetLastFrameInfo(hMP3Decoder, &mp3FrameInfo); 
  
   /* Select the correct samplerate and Mono/Stereo */
   AUDIO_Init_audio_mode( ( AUDIO_Length_enum )mp3FrameInfo.bitsPerSample,  \
            ((MP3DecInfo *)hMP3Decoder)->samprate,  \
            (((MP3DecInfo *)hMP3Decoder)->nChans==1) ? MONO : STEREO);

}

void DMA2_Stream5_IRQHandler(void)
{   
  /* Transfer complete interrupt */
  if (DMA_GetFlagStatus(AUDIO_MAL_DMA_STREAM, AUDIO_MAL_DMA_FLAG_TC) != RESET)  /* DMA1 ͨµÀ5 ´«ÊäÍê³ÉÖÐ¶Ï */
  {           
    /* Clear the Interrupt flag */
    DMA_ClearFlag(AUDIO_MAL_DMA_STREAM, AUDIO_MAL_DMA_FLAG_TC);
      bufferstatus_local |= HIGH_EMPTY;
      if(AUDIO_Format == MONO)
      {
         AUDIO_Cpy_Mono();
      }
      else
      {
         audio_buffer_fill |= HIGH_EMPTY;
      }
  }

  if (DMA_GetFlagStatus(AUDIO_MAL_DMA_STREAM, AUDIO_MAL_DMA_FLAG_HT) != RESET)
  {      
    /* Clear the Interrupt flag */
    DMA_ClearFlag(AUDIO_MAL_DMA_STREAM, AUDIO_MAL_DMA_FLAG_HT); 
     bufferstatus_local |= LOW_EMPTY;
     if(AUDIO_Format == MONO)
     {
        AUDIO_Cpy_Mono();
     }
     else 
     {
        audio_buffer_fill |= LOW_EMPTY;
     }    
  }
}


/*******************************************************************************
* Function Name  : AUDIO_Cpy_Mono
* Description    : Copy Mono data to small buffer, set both Left+Right Channel 
*                  to samme value
* Input          : None
* Output         : None
* Return         : None
* Attention     : None
*******************************************************************************/
void AUDIO_Cpy_Mono(void)
{
    volatile uint16_t i;
    s16  temp;
    
    /* Stop if end of original buffer */
    if ( Audio_buffer_index > Audio_buffer_size )
        AUDIO_Playback_Stop();
    
    /* End of the first half working buffer  */
    if(bufferstatus_local & LOW_EMPTY)
    {
        if (AUDIO_Length == LG_16_BITS)
        {
            for( i=0 ; i < ((Audio_buffer_local_size / 4) - 1) ; i = i + 2 )
            {
                temp = *(s16*)(Audio_buffer+Audio_buffer_index);
                Audio_buffer_local[i+1] = Audio_buffer_local[i] = temp;
                Audio_buffer_index += 2;   /* 16 bit */
            }
        }
        else
        {
            for(i=0; i < ((Audio_buffer_local_size / 4)-1); i=i+2)
            {
                temp = ((s16)((*(Audio_buffer+Audio_buffer_index)^0x80)))<<8;
                Audio_buffer_local[i+1] = Audio_buffer_local[i] = temp;
                Audio_buffer_index++;      /* 8 bit */     
            }
        }
        bufferstatus_local &= ~LOW_EMPTY;
    }

    /* End of the second half working buffer */
    if(bufferstatus_local & HIGH_EMPTY)
    {
        if (AUDIO_Length == LG_16_BITS)
        {
            for( i = (Audio_buffer_local_size / 4) ; i < (Audio_buffer_local_size / 2 ); i = i + 2 )
            {
                temp = *(s16*)(Audio_buffer+Audio_buffer_index);
                Audio_buffer_local[i+1] = Audio_buffer_local[i] = temp;
                Audio_buffer_index += 2; /* 16 bit */
            }
        }
        else
        {
            for(i = (Audio_buffer_local_size / 4); i < ((Audio_buffer_local_size) / 2)-1; i=i+2)
            {
                temp = ((s16)((*(Audio_buffer+Audio_buffer_index)^0x80)))<<8;
                Audio_buffer_local[i+1] = Audio_buffer_local[i] = temp;
                Audio_buffer_index++;    /* 8 bit */     
            }
        }
        bufferstatus_local &= ~HIGH_EMPTY;
    }
    
    if ( Audio_buffer_index == (Audio_buffer_size/2) )
    {
        audio_buffer_fill |= LOW_EMPTY;
        if ( audio_buffer_fill & HIGH_EMPTY )         
        {
            AUDIO_Playback_Stop();
        }
    }
    if ( Audio_buffer_index >= Audio_buffer_size )
    {
        audio_buffer_fill |= HIGH_EMPTY;
        Audio_buffer_index = 0;
        if ( audio_buffer_fill & LOW_EMPTY )         
        {
            AUDIO_Playback_Stop();
        }
    }
}


/*******************************************************************************
* Function Name  : AUDIO_Init_audio_mode
* Description    : Initialization for Audio Mode use of the WM8731 codec.set WM8731
*                  to Audio Mode via I2C. enable STM32 I2S communication to send
*                  audio samples (SPI2/I2S2 port) in DMA mode
* Input          : - length: 8 bits or 16 bits length sample
*           - frequency:  8 KHz, 16 KHz, 22 KHz, 44 KHz, 48 KHz sample
*           - format: mono, stereo
* Output         : None
* Return         : None
* Attention     : None
*******************************************************************************/
void AUDIO_Init_audio_mode(AUDIO_Length_enum length, uint16_t frequency, AUDIO_Format_enum format)
{
   /* The MONO mode uses working buffer to dupplicate datas on the two channels
      and switch buffer half by half => uses DMA in circular mode */
  
   NVIC_InitTypeDef NVIC_InitStructure;

   StartPlay(frequency);
   /* DMA IRQ Channel configuration */
#if defined(AUDIO_MAL_DMA_IT_TC_EN) || defined(AUDIO_MAL_DMA_IT_HT_EN) || defined(AUDIO_MAL_DMA_IT_TE_EN)
  /* SAI DMA IRQ Channel configuration */
  NVIC_InitStructure.NVIC_IRQChannel = AUDIO_MAL_DMA_IRQ;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = EVAL_AUDIO_IRQ_PREPRIO;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = EVAL_AUDIO_IRQ_SUBRIO;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);
#endif 
  
   Audio_buffer_index = 0;
   AUDIO_Playback_status = NO_SOUND;
   AUDIO_Length = length;    
   AUDIO_Frequency = frequency;
   AUDIO_Format = format;

   /* Buffers are supposed to be empty here  */
   audio_buffer_fill = (AUDIO_PlaybackBuffer_Status) (LOW_EMPTY | HIGH_EMPTY );
   bufferstatus_local =  (AUDIO_PlaybackBuffer_Status) (LOW_EMPTY | HIGH_EMPTY );
   
   DMA_Configuration((s8 *)AudioBuffer,(mp3FrameInfo.outputSamps*2)); 

   printf( "-- MP3 file header information \r\n");
   printf( "-------------------------------- \r\n");
   printf( "-- MP3 bitrate        = %d\r\n", mp3FrameInfo.bitrate);     /* ±ÈÌØÂÊ */
   printf( "-- MP3 bitsPerSample  = %d\r\n", AUDIO_Length);
   printf( "-- MP3 samprate       = %d\r\n", AUDIO_Frequency);  
   printf( "-- MP3 nChans         = %d\r\n", AUDIO_Format);  
   printf( "-- MP3 nGranSamps     = %d\r\n", ((MP3DecInfo *)hMP3Decoder)->nGranSamps);
   /* Êý¾ÝÖ¡´óС FrameSize = (((MpegVersion == MPEG1 ? 144 : 72) * Bitrate) / SamplingRate) + PaddingBit */
   printf( "-- MP3 outputSamps    = %d\r\n", mp3FrameInfo.outputSamps);  
   printf( "-- MP3 layer          = %d\r\n", mp3FrameInfo.layer);
   printf( "-- MP3 version        = %d\r\n", mp3FrameInfo.version);
}

[Mw E. (Firma: fritzler-avr.de) (fritzler)]

Sourcen kann man auch als Datei anhängen statt als Wall Of Text im 
Thread.

Ansonsten word wohl der Systemtakt zu gering sein.

[Peter (Gast)]

Mw E. schrieb:
> Sourcen kann man auch als Datei anhängen statt als Wall Of Text im
> Thread.
>
Ja Richtuig sorry.

> Ansonsten word wohl der Systemtakt zu gering sein.

Der STM läuft mit 168MHz

[holger (Gast)]

>Der STM läuft mit 168MHz

Hast du das gemessen oder glaubst du das?

Auch mal Optimierung beim Compiler aktivieren.

[Peter (Gast)]

holger schrieb:
>>Der STM läuft mit 168MHz
>
> Hast du das gemessen oder glaubst du das?
> ja sonst würde der USB Teil nicht gehen


> Auch mal Optimierung beim Compiler aktivieren.
Hab ich

[Peter (Gast)]

wo gibt es denn Beispiele für den
stm32f429 und WM8789

[Peter (Gast)]

Ich habs jetzt nochmal etwas umgeändert, es hört sich füchterlich an.

[Mw E. (Firma: fritzler-avr.de) (fritzler)]

USB?
Ich denk das spielt von SD Karte?

Guck doch mal mit einem Oszi ob die LRCK zum DAC auch der Samplerate der 
MP3 entspricht.

[Peter (Gast)]

Mw E. schrieb:
> USB?
> Ich denk das spielt von SD Karte?
>
Die MP3 wird von der sd Card gelesen, USB brauch ich nur um die Daten 
zwischen PC und STM auszutauschen.

> Guck doch mal mit einem Oszi ob die LRCK zum DAC auch der Samplerate der
> MP3 entspricht.
ein OZZI hab ich leider nicht

[Peter (Gast)]

wenn ich das example  von st nehme wo die mp3 als Array vorliegt dan 
wird das auch korrekt abgespielt siehe anhang

[Mw E. (Firma: fritzler-avr.de) (fritzler)]

Dann kommen wohl die Daten zu langsam von der SD Karte.
Wie siehts denn aus wenn ersteinmal nur ein Array mit den MP3 Daten von 
der SD Karte füllst und dieses wie im Originalbeispiel abspielst?

Kannste mir mal noch in Worten erklären wie dein Code die Daten von der 
SD Karte ließt und dem MP3 decoder übergibt?

[Mw E. (Firma: fritzler-avr.de) (fritzler)]

ich glaub ich seh dein Problem:
MP3FindSyncWord gibt nicht zurück wie lang der MP3 Frame ist und die 
Decode Funktion ließt dann wohl über den Buffer hinaus.
Zudem kann diese Funktion wohl auch mal "falsch feuern".

Also du musst die Datei von der SD Karte Byteweise einlesen bis der 
Header kommt und dann gucken wie lang der Frame ist und diesen ind en 
BUffer kopieren.

Das Problem hatte ich bei nem Uni Projekt auch mal, daher eiskalt diesen 
Headerfinder selber geschrieben.
Siehe Anhang.

char filebuff[0x400*1024];     //Framebuffer
unsigned int my_frame_size = 0;  //Ausgabe von headerfind

//auf MP3 Header syncen (<2 sagt ungültig; > filebuff ist eindeutig zu groß als Header -> Decodefehler)
my_frame_size = 0;
while ((my_frame_size < 2) || (my_frame_size > sizeof(filebuff)-10)){ 
    //jaja, Billig FIFO
  filebuff[0] = filebuff[1];
  filebuff[1] = filebuff[2];
  filebuff[2] = filebuff[3];   
  filebuff[3] = fgetc(file_fd);
  my_frame_size = mp3decode_findheader(filebuff);
}

//restlichen Frame nachladen (Offset von 4, den Header haben wir ja schon)
fread ((void*)&filebuff[4], sizeof(char), my_frame_size - 4, file_fd);

//In den Decoder kippen

[Peter (Gast)]

Hallo
ihren Tipp den bekomme ich nicht so einfach umgesetzt dazu fehlt mir 
vielleicht auch die Erfahrung.

Wenn ich nun die Textausgabe Weglasse dann wir das mp3 zu schnell 
ausgegeben .
zum zweiten ist immer so ein knacken drin

void AUDIO_Init_audio_mode(AUDIO_Length_enum length, uint16_t frequency, AUDIO_Format_enum format)
{
   /* The MONO mode uses working buffer to dupplicate datas on the two channels
      and switch buffer half by half => uses DMA in circular mode */
  
   NVIC_InitTypeDef NVIC_InitStructure;

   StartPlay(frequency);
   /* DMA IRQ Channel configuration */
#if defined(AUDIO_MAL_DMA_IT_TC_EN) || defined(AUDIO_MAL_DMA_IT_HT_EN) || defined(AUDIO_MAL_DMA_IT_TE_EN)
  /* SAI DMA IRQ Channel configuration */
  NVIC_InitStructure.NVIC_IRQChannel = AUDIO_MAL_DMA_IRQ;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = EVAL_AUDIO_IRQ_PREPRIO;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = EVAL_AUDIO_IRQ_SUBRIO;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);
#endif 

   Audio_buffer_index = 0;
   AUDIO_Playback_status = NO_SOUND;
   AUDIO_Length = length;    
   AUDIO_Frequency = frequency;
   AUDIO_Format = format;

   /* Buffers are supposed to be empty here*/   
   audio_buffer_fill = (AUDIO_PlaybackBuffer_Status) (LOW_EMPTY | HIGH_EMPTY );
   bufferstatus_local =  (AUDIO_PlaybackBuffer_Status) (LOW_EMPTY | HIGH_EMPTY );
   
   DMA_Configuration((s8 *)AudioBuffer,(mp3FrameInfo.outputSamps*2)); 

   DrawString(200,200,"-- MP3 file header information ",&Arial_16x25,Orange,BLACK);

   sprintf(read_write_buffer,"MP3 bitrate  %d",mp3FrameInfo.bitrate);
   DrawString(200,225,read_write_buffer,&Arial_16x25,Orange,BLACK);
   /*
   sprintf(read_write_buffer,"MP3 bitsPerSample %d",AUDIO_Length);
   DrawString(200,250,read_write_buffer,&Arial_16x25,Orange,BLACK);   
   
   sprintf(read_write_buffer,"MP3 samprate  %d",AUDIO_Frequency);
   DrawString(200,275,read_write_buffer,&Arial_16x25,Orange,BLACK);

   sprintf(read_write_buffer,"MP3 nChans  %d",AUDIO_Format);
   DrawString(200,300,read_write_buffer,&Arial_16x25,Orange,BLACK);

//   sprintf(read_write_buffer,"MP3 nGranSamps %d",(MP3DecInfo *)hMP3Decoder)->nGranSamps);
//   DrawString(200,300,read_write_buffer,&Arial_16x25,Orange,BLACK);
   
   sprintf(read_write_buffer,"MP3 outputSamps  %d",mp3FrameInfo.outputSamps);
   DrawString(200,325,read_write_buffer,&Arial_16x25,Orange,BLACK);   
   
   sprintf(read_write_buffer,"MP3 layer  %d",mp3FrameInfo.layer);
   DrawString(200,350,read_write_buffer,&Arial_16x25,Orange,BLACK);      
   
   sprintf(read_write_buffer,"MP3 version  %d",mp3FrameInfo.version);
   DrawString(200,375,read_write_buffer,&Arial_16x25,Orange,BLACK);   
  */
  
}

[Mw E. (Firma: fritzler-avr.de) (fritzler)]

Also wenn dir etwas "Bytes in Buffer kopieren" schon zu viel ist, dann 
kann ich dir leider auch nicht wirklich weiterhelfen.

Ansonsten ist bei deinem Umbau wohl komplett die Synchronisation kaputt 
gegangen zwischen DMA zum I2S Anschluss und dem Buffer der Audioframes.

Wenn der DMA aus dem einen Audioframebuffer ließt, dann einen MP3 Frame 
dekodieren und in einen zweiten Audioframebuffer kippen.
Ist der DMA mit einem der AUdiobuffer fertig, dann umschalten und den 
nächstren MP3 Frame in den anderen Audioframebuffer kopieren.

[Peter (Gast)]

Hallo,

Mw E. schrieb:
> Also wenn dir etwas "Bytes in Buffer kopieren" schon zu viel ist,
> dann
> kann ich dir leider auch nicht wirklich weiterhelfen.

nein das ist mir nicht zu viel,
meine Frage ist nur wie wird das in zwei buffer eingelesen und wie gross 
müssen die buffer sein




>
> Ansonsten ist bei deinem Umbau wohl komplett die Synchronisation kaputt
> gegangen zwischen DMA zum I2S Anschluss und dem Buffer der Audioframes.
>
> Wenn der DMA aus dem einen Audioframebuffer ließt, dann einen MP3 Frame
> dekodieren und in einen zweiten Audioframebuffer kippen.
> Ist der DMA mit einem der AUdiobuffer fertig, dann umschalten und den
> nächstren MP3 Frame in den anderen Audioframebuffer kopieren.

Gibt es denn irgendwo ein Beispiel, denn für meinen DAC hab ich nirgends 
ein Beispiel gefunden wie das gemacht wird.
mfg

[Mw E. (Firma: fritzler-avr.de) (fritzler)]

Das funktionierende Beispiel haste doch schon? (mp3_audio_array.c)

Musst doch "nur" das Beispiel mit dem Abspielen aus dem Array so 
umbauen, dass der MP3Decoder die Daten von der SD Karte dekodiert.
Dazu habe ich dir sogar schon Code gegeben um die MP3 Frames und dessen 
Länge zu finden.

Du musst jetzt gucken wie dieses Beispiel die synchronisation mit dem 
DMA hinbekommt. ALso diesen Code mal selber reverse engineeren.
Es hilft übrigens ungemein dabei die gewonnen Kenntnisse 
nierderzuschreiben.
Dann merkt man ob man sich gedanklich verrant hat oder sich etwas 
widerspricht.
Sei es in Form von ausaführlichen KOmmentaren im Code oder hier im Forum 
als Beitrag.

[Peter (Gast)]

Hallo,
so nun läufts einwandfrei.
in der Ruhe liegt die Kraft.

[Mw E. (Firma: fritzler-avr.de) (fritzler)]

Woran lags denn?
Das dürfte zukünftige Leser hier interessieren.