mp3_decode.c

瑞芯微RK2608固件源代码

        if (MusicPlayInfo.Mode == MUSIC_DECODE_ONE) {
        //返回到资源管理器，选择当前歌曲
            Fun1MsgArray[0] = MSG_FUNCTION1_NONE;
            Fun1ModuleChange();
            Mp3ToBrowser(TO_CURRENT_FILE);
            return;
        }
        
        if ((MusicPlayInfo.RepMode == MUSIC_REPMODE_NORMAL) && (SysFile1Info.PlayedFileNum >= SysFile1Info.TotalFiles)) {
            Fun1MsgArray[0] = MSG_FUNCTION1_NONE;
            Fun1ModuleChange();
            
            if (MusicPlayInfo.Range == MSG_FIND_FILE_ALL) {
            //返回到资源管理器，选择第一首歌曲
                Mp3ToBrowser(TO_DEV_FIRST_FILE);
            } else {
            //返回到资源管理器，选择当前歌曲
                Mp3ToBrowser(TO_CURRENT_FILE);
            }
            return;
        }
        
        FileClose(hMainFile);
        if (Sys2InitFlag.bc.bLrcModuleInitEnable == 0) {
            Fun2MsgArray[0] = MSG_FUNCTION2_NONE;
            Fun2ModuleChange();
        }
        //ScrollStringDispDisable();
        PostFun1Message(MSG_FUNCTION1_FILE_FIND,MSG_FIND_MUSIC_FILE,MSG_FIND_FILE_NEXT,MusicPlayInfo.Range,MusicPlayInfo.Order/*,0,0,0*/);
    }
}
/*------------------------------------------------------------------------------
Function: MP3????????????
Input   : ??
Output  : ??
------------------------------------------------------------------------------*/
__attribute__((section(".mp3_text,\"ax\"")))
void MP3DecodeErrorProc(void)
{
    ClearPcmData();
    
    MP3DecodeErrorTimes ++;
    
    if(MP3DecodeBadFrameCount < 8) {
        MP3DecodeBadFrameCount = 0;
    }
}

__attribute__((section(".mp3_text,\"ax\"")))
void MP3DecodePlay(void)
{
    unsigned long MP3DecodeRerurnVal;
    unsigned int i,j;
    
    if((MusicPlayInfo.AB == MUSIC_DECODE_AB) && (MP3FileOffSet >= MP3FileOffSetB))
    {   /*AB End Position Check!*/
        MP3FileOffSet = MP3FileOffSetA;
        FileSeek(MP3FileOffSet, SEEK_SET, hMainFile);
        Mp3PlayFlag.bc.bMP3DecodeInit = 1;
        
        if (MP3DecodeBadFrameCount >= 8) {
            MusicCodecMute(1);
        }
        MP3DecodeBadFrameCount = 0;
    }
    
    if(Mp3PlayFlag.bc.bMP3DecodeInit)
    {
        Mp3PlayFlag.bc.bMP3DecodeInit = 0;
        
        MP3Obj.head_pkptr = (short *)(ApplicationInputBufferStart);
        MP3FrameParams.alloc=&alloc_table;
        MP3Obj.head_pack_state = 0;
        MP3Obj.head_totbit = 0;
        MP3DecodeInputBufWordsUsed = 0;
        MP3DecodeInputBufWordsRemaining = 0;
        MP3Obj.main_init=1;
        Mp3PlayFlag.bc.bMP3DecodeError = 0;
        MP3_Init_MP3(&MP3Obj);
    
        MusicPlayInfo.TimeGuageVal = (unsigned int)(MP3FileOffSet* TIME_GUAGE_CONST / SysFile1Info.Fdt.FileSize);
        
        MP3TimeGuageCount = (unsigned long)(MP3FileOffSet % (SysFile1Info.Fdt.FileSize / TIME_GUAGE_CONST));
        MusicDispFlag |= MUSIC_DISPFLAG_GUAGE;
        
        MP3TimeCount = (unsigned long)(MP3FileOffSet % (((unsigned long)(MusicPlayInfo.FirstBitrate) *125)/20));
        //GetMp3CurTime();
        Mp3CurrTimeSec = (unsigned long)(MP3FileOffSet / ((unsigned long)(MusicPlayInfo.FirstBitrate) *125));
    }
    //----------------------------------------------------------------------------------------------
    //MP3 Decode Main Loop 20051020
    if(Mp3PlayFlag.bc.bMP3DecodeEnable)
    {
        Mp3PlayFlag.bc.bBufferIndex = ~Mp3PlayFlag.bc.bBufferIndex;
        pMP3DecodeOutputBuf = FirstPCMOutAddress + Mp3PlayFlag.bc.bBufferIndex * PCM_OUT_BUF_LENGTH;
        
        MP3DecodeInputBufWordsUsed = MP3Obj.head_pkptr - (short *)(ApplicationInputBufferStart);
        if(MP3DecodeInputBufWordsUsed>MP3DecodeInputBufWordsRemaining) Mp3PlayFlag.bc.bMP3DecodeError = 1; //2005-10-9 fsh
        if(Mp3PlayFlag.bc.bMP3DecodeError == 1) MP3DecodeInputBufWordsUsed = 40;
        MP3DecodeInputBufWordsRemaining = MP3DecodeInputBufWordsRemaining - MP3DecodeInputBufWordsUsed;
        //----------------------------------------------------------------------
        for(i=0; i<MP3DecodeInputBufWordsRemaining; i++)
            ApplicationInputBufferStart[i] = ApplicationInputBufferStart[i + MP3DecodeInputBufWordsUsed];
            
        for( ; i < APPLICATION_INPUT_BUF_LENGTH; i++ )
            ApplicationInputBufferStart[i] = 0;
        //----------------------------------------------------------------------
        
        while(MP3DecodeInputBufWordsRemaining < MP3_DECODE_MAX_FRAME_LENGTH)/*MP3_DECODE_MAX_FRAME_LENGTH = 868*/
        {
            MP3DecodeRerurnVal = FileRead((unsigned char*)MP3DecodeTempReadoutBuf,512,hMainFile);
            MP3FileOffSet += MP3DecodeRerurnVal;
            MP3TimeCount += MP3DecodeRerurnVal;
            MP3TimeGuageCount += MP3DecodeRerurnVal;

            Byte2Word(ApplicationInputBufferStart+MP3DecodeInputBufWordsRemaining, MP3DecodeTempReadoutBuf, MP3DecodeRerurnVal >> 1);
            
            MP3DecodeInputBufWordsRemaining += (MP3DecodeRerurnVal >> 1); 
            
            if(MP3DecodeRerurnVal < 512)
            {   /*File End!*/
                PostFun1Message(MSG_FUNCTION1_MUSIC_MP3,MSG_FUNCTION1_MP3_END,0,0,0/*,0,0,0*/);
                MusicPlayInfo.TimeGuageVal ++;
                MusicDispFlag |= MUSIC_DISPFLAG_GUAGE;
                Mp3PlayFlag.bc.bMP3DecodeEnable = 0;
                break;
            }
        }
        
        MP3Obj.head_pkptr   = (short *)(ApplicationInputBufferStart);
        MP3Obj.head_totbit -= (MP3DecodeInputBufWordsUsed << 4);
        
        if(Mp3PlayFlag.bc.bMP3DecodeError == 1) 
        {
            Mp3PlayFlag.bc.bMP3DecodeError = 0;
            
            MP3Obj.head_pack_state = 0;
            MP3Obj.head_totbit = 0;
            MP3_Init_MP3(&MP3Obj);
        }
        if(MP3DecodeErrorTimes >= 100)
        {
            MP3DecodeErrorTimes =0;
            PostFun1Message(MSG_FUNCTION1_MUSIC_MP3,MSG_FUNCTION1_MP3_END,0,0,0/*,0,0,0*/);
            return;            
        }   
        
        MP3_FrameDecode(pMP3DecodeOutputBuf, &MP3FrameParams, &MP3Obj);
        switch(MP3FrameParams.MP3_ErrCode)
        {       
        case 0: 
            if(MP3DecodeBadFrameCount < 8)
            {
                if(++MP3DecodeBadFrameCount == 8)
                {
                    MusicCodecMute(0);
                }
            }
            FillPcmData();
            MP3DecodeErrorTimes = 0;
            if(MusicPlayInfo.Eq == MUSIC_DECODE_EQ_3D) 
            {   
                Mp3Dsurround(pPCMOutputBuf, PCMOutBufferLength ) ;//
            }

            if ((DisplayFlag == DISP_MUSIC) && (SystemInfo.bc.bBackLightStatus != 2) && (MusicPlayInfo.DispState != LRC_DISPLAY) && (StroboscopeCount >= 2))
            {   //100ms
                StroboscopeCount = 0;
                specline10((long *)pPCMOutputBuf,(short*)StroboscopeArray);
                MusicDispFlag |= MUSIC_DISPFLAG_SPECTRUM;
            }
            
            MP3DecodeRerurnVal = MP3_Decode_Freq_Tbl[MP3FrameParams.header.version][MP3FrameParams.header.sampling_frequency]; 
            
            if(MP3FrameParams.mpeg2_5==2) MP3DecodeRerurnVal = MP3DecodeRerurnVal >> 1; 
                
            if( MusicPlayInfo.Freq != MP3DecodeRerurnVal)
            {   /*Sampling Frequence*/
                MusicPlayInfo.Freq = MP3DecodeRerurnVal;
                Mp3SamplingFreqSet(MusicPlayInfo.Freq);
                Mp3CpuFreqSet(MusicPlayInfo.Freq);
            }
            
            if((MusicPlayInfo.Bitrate != MP3FrameParams.Bitrate ))
            {   /* Bitrate */
                MusicPlayInfo.Bitrate = MP3FrameParams.Bitrate;
                if(BitrateCount >= 8)
                {   //400ms
                    BitrateCount = 0;
                    MusicDispFlag |= MUSIC_DISPFLAG_BITRATE;
                }
            }
            break;
            
        case 1:
            MP3DecodeErrorProc();
            break;
        case 2:
            MP3Obj.main_init=1;
            MP3DecodeErrorProc();
            break;
            
      /*case 3:
        case 4:
        case 5:
        case 6:*/
        default:
            Mp3PlayFlag.bc.bMP3DecodeInit = 1;
            Mp3PlayFlag.bc.bMP3DecodeError = 1;
            MP3DecodeErrorProc();
            break;
        } 
    }
}
/*------------------------------------------------------------------------------
Function: MP3????????????
Input   : ??
Output  : ??
------------------------------------------------------------------------------*/
__attribute__((section(".mp3_text,\"ax\"")))
#if 0
void MP3DecodeTimeUpdate(void)
{
    unsigned long TempL;
    //----------------------------------------------------------------------------------------------
    //Time Update 20051020
    TempL = SysFile1Info.Fdt.FileSize / TIME_GUAGE_CONST;
    if(MP3TimeGuageCount >= TempL)
    {   /*Time Guage*/
        MP3TimeGuageCount -= TempL;
        MusicPlayInfo.TimeGuageVal ++;
        MusicDispFlag |= MUSIC_DISPFLAG_GUAGE;
    }
    
    TempL = (unsigned long)((MusicPlayInfo.FirstBitrate * 125)/20);
    if(MP3TimeCount >= TempL)
    {   //50ms
        MP3TimeCount -= TempL;
        BitrateCount ++ ;
        StroboscopeCount ++;
        if((++DecodeCount) >= 20) {
            DecodeCount = 0;
            Mp3CurrTimeSec ++;
            MusicDispFlag |= (MUSIC_DISPFLAG_CUR_TIME | MUSIC_DISPFLAG_FREE_TIME);
        }
    }
    
    if((MusicPlayInfo.Mode == MUSIC_DECODE_BROWSE) && (Mp3CurrTimeSec >= 10))
        PostFun1Message(MSG_FUNCTION1_MUSIC_MP3,MSG_FUNCTION1_MP3_END,0,0,0/*,0,0,0*/);
}
#else
void MP3DecodeTimeUpdate(void)
{
    unsigned long TempL;
    //----------------------------------------------------------------------------------------------
    //Time Update 20051020
    TempL = (MP3FileOffSet*TIME_GUAGE_CONST)/SysFile1Info.Fdt.FileSize;
    
    if(TempL != MusicPlayInfo.TimeGuageVal){
        MusicPlayInfo.TimeGuageVal = TempL;
        MusicDispFlag |= MUSIC_DISPFLAG_GUAGE;
    }
    
    TempL = (unsigned long)(MP3FileOffSet / ((unsigned long)(MusicPlayInfo.FirstBitrate) *125));
    
    if((Mp3CurrTimeSec != TempL)/* && (TempL <= Mp3Total)*/)
    {
        Mp3CurrTimeSec = TempL;
        MusicDispFlag |= (MUSIC_DISPFLAG_CUR_TIME | MUSIC_DISPFLAG_FREE_TIME);
    }

    if((MusicPlayInfo.Mode == MUSIC_DECODE_BROWSE) && (Mp3CurrTimeSec >= 10))
        PostFun1Message(MSG_FUNCTION1_MUSIC_MP3,MSG_FUNCTION1_MP3_END,0,0,0/*,0,0,0*/);
}
#endif
//******************************************************************************