decoder.h File Reference

---

Detailed Description

Decoder module C header file.

REVISION

• 11/05/2003 M.GAO
  Initial creation.
• 01/27/2004 M.GAO
  Added decoder cache depth support function prototype.
• 03/04/2004 M.GAO
  Removed decoder EOF flag controls.

Definition in file decoder.h.

#include "../feature.h"
#include "../TISTD/dectask.h"
#include "../TISTD/idecode.h"
#include "../TISTD/iscrypt.h"
#include "../TISTD/ispecan.h"
#include "../PIPE/pipe.h"
#include "vorbis/OGGV_ogg.h"
#include "../TISTD/wma_ti.h"

Include dependency graph for decoder.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	st_WARNING
	Decoder warning structure. More...
struct	st_DECODER
	Decoder control structure definition. More...
Defines
#define	READ_THRESHOLD   0x400
	Threshold to minize the media reading frequency.
Enumerations
enum	DEC_TYPE
	Decoder type definition.
Functions
BOOL	DECODER__mp3first (void)
	Function check to set up mp3 decoder input bit stream.
USHORT	DECODER__mp3media (void)
	Function serves as the decoder media access task handle.
BOOL	DECODER__mp3 (void)
	Function serves as the mp3 decoder task handle.
BOOL	DECODER__wavfirst (void)
	Function check to set up WAV decoder input bit stream.
USHORT	DECODER__wavmedia (void)
	Function serves as the WAV decoder media access task handle.
BOOL	DECODER__wav (void)
	Function serves as the wav decoder task handle.
BOOL	DECODER__wmainit (void)
	Function check to init WMA decoder input bit stream.
BOOL	DECODER__wmafirst (void)
	Function bridges the WMA subcoder to main decoder handle.
USHORT	DECODER__wmamedia (void)
	Function serves as the WMA decoder media access task handle.
BOOL	DECODER__wma (void)
	Function serves as the WMA decoder data output task handle.
BOOL	DECODER__wmatask (void)
	Function serves as the WMA decoder task handle.
BOOL	DECODER__oggfirst (void)
	Function check to set up OGG decoder input bit stream.
USHORT	DECODER__oggmedia (void)
	Function serves as the OGG decoder media access task handle.
BOOL	DECODER__ogg (void)
	Function serves as the OGG decoder task handle.
int *	DECODER_main (void)
	Function fetches decoder output upon PCM request.
void	DECODER_cache (void)
	Function serves as the decoder cache task handle.
BOOL	DECODER_config (DEC_TYPE)
	Function configures the decoder module.
void	DECODER_releaseObj (void)
	Function releases all decoder allocated objects.
BOOL	DECODER_cacheInit (void)
	Function initialized the decoder cache.
void	DECODER_cacheDepthReset (unsigned short)
	Function resets cache depth controls.
unsigned short	DECODER_getData (int *, unsigned long, unsigned short)
	Function feeds data into docoder bit stream/buffer.
Variables
st_DECODER	Decoder
	Decoder globals.

---

Function Documentation

BOOL DECODER__mp3 (  void   )

Function serves as the mp3 decoder task handle. Returns: FALSE if more data is needed, otherwise TRUE; Definition at line 69 of file DECODER__mp3.c. References Audio, st_DECODER::averageWordRate, st_DECODER::decode, st_DECODER::decodeBitstrm, Decoder, st_DECODER::decrypt, st_DECODER::firstPacketOffset, st_DECODER::flag, GEN_zeroOut(), st_DECODER::inputBitstrm, st_AUDIO::offset, st_DECODER::pipe, PIPE_writeNext(), st_AUDIO::playtime, st_PCM::sampleRate, SAUDIOTIME_UPDT, and st_DECODER::status. Referenced by DECODER__mp3first(). { PIPE_Obj * pipe = &Decoder.pipe; int error = DECODE_NO_ERROR; int dataLength, newDataLength; BOOL ret = TRUE; unsigned long tmpUL = Audio.playtime; // Try to decode as long as output pipe is open. while( PIPE_writeFrameNum(pipe) ) { BITSTRM_pack(Decoder.decodeBitstrm); dataLength = BITSTRM_numDataWords(Decoder.decodeBitstrm); // is there enough data to be decoded? if( dataLength < INPUT_BUFFER_SIZE - READ_THRESHOLD ) ret = FALSE; if( dataLength < (Decoder.status.frameSize + VBR_RESERVED_FORSAFE) ) { // NO. data not enough yet, bring up media task. return ret; } // YES. valid data detected, prepare to decode. if ( Decoder.flag & (DEC_FFWD|DEC_FRWD|DEC_MEDIASEEK) ) { //BITSTRM_remove(Decoder.decodeBitstrm, dataLength); //BITSTRM_pack(Decoder.decodeBitstrm); BITSTRM_reset(Decoder.decodeBitstrm); if(Decoder.flag & DEC_MEDIASEEK) { mp3ReadPtr = Audio.offset; DECODE_reset(Decoder.decode); Decoder.flag &= ~DEC_MEDIASEEK; } else { if(Decoder.flag & DEC_FFWD) mp3ReadPtr += mp3FastFwdLen; else if(mp3ReadPtr>mp3FastFwdLen+Decoder.firstPacketOffset) mp3ReadPtr -= mp3FastFwdLen; else { // Send silence to get rid of the noise. mp3Silence = 8; mp3ReadPtr = Decoder.firstPacketOffset; } } mp3EndOfReadPtr = mp3ReadPtr; Decoder.flag &= ~(DEC_FFWD|DEC_FRWD); ret = FALSE; tmpUL = 0; if(mp3ReadPtr > Decoder.firstPacketOffset) tmpUL = (mp3ReadPtr-Decoder.firstPacketOffset)/Decoder.averageWordRate; mp3FrameIdx = (tmpUL*(Decoder.status.sampleRate/36))>>4; break; } else { if(mp3Silence) { GEN_zeroOut((UINT16*)pipe->WrFrame.Frame, MP3_PIPE_FRAMELEN); mp3Silence--; } else { // decode the bitstream error = DECODE_decode( Decoder.decode, Decoder.decodeBitstrm, (Int *)pipe->WrFrame.Frame); BITSTRM_pack(Decoder.decodeBitstrm); newDataLength = BITSTRM_numDataWords(Decoder.decodeBitstrm); mp3ReadPtr += dataLength-newDataLength; if (error == DECODE_NO_ERROR) { // Get decode status, which will be checked in codec data // feed routine. DECODE_getStatus(Decoder.decode, &Decoder.status); if(Decoder.status.isValid) { unsigned long sampleRate = Decoder.status.sampleRate; Pcm.sampleRate = sampleRate; PCM_samplerateChanged(); mp3FastFwdLen = 5L*Decoder.status.bitRate>>4; mp3FrameIdx++; tmpUL = (mp3FrameIdx<<4)/(sampleRate/36); } } } } // Any error detected? if (error == DECODE_NO_ERROR) PIPE_writeNext(pipe); else if(error == DECODE_ERROR) { // Error, resync on the next call. Note that the output // pipe frame is kept for next decoding attempt. SCRYPT_reset(Decoder.decrypt); DECODE_reset(Decoder.decode); BITSTRM_reset(Decoder.inputBitstrm); } //else if (error == DECODE_NO_DATA){} } // Check to update time. if ( Audio.playtime != tmpUL ) { Audio.playtime = tmpUL; mMSG_send(sysMsgQ, SYS_MSG_ID, SAUDIOTIME_UPDT, DONTCARE, 0); } return ret; }

Here is the call graph for this function:

BOOL DECODER__mp3first (  void   )

Function check to set up mp3 decoder input bit stream. Returns: TRUE if valid MP3 sync is found, otherwise FALSE. Definition at line 37 of file DECODER__mp3first.c. References Audio, st_DECODER::averageWordRate, st_DECODER::decodeBitstrm, Decoder, DECODER__mp3(), st_AUDIO::duration, st_AUDIO::file, st_DECODER::firstPacketOffset, st_DECODER::flag, st_AUDIO::fptr, st_AUDIO::offset, st_PCM::sampleRate, File::size, and st_DECODER::status. { USHORT strmLen; //USHORT * pDst; /* Locate first available frame sync. */ //while(1) { /* This will cause potential reentry problem in media task! BITSTRM_pack(Decoder.inputBitstrm); strmLen = BITSTRM_numWordsFree(Decoder.inputBitstrm); pDst = (unsigned short *)BITSTRM_writePtr(Decoder.inputBitstrm); strmLen = DECODER_getData((int*)pDst, strmLen); // Is data available? if(strmLen == 0) break; // Add to decoder bitstream object. BITSTRM_add(Decoder.inputBitstrm, strmLen); */ BITSTRM_pack(Decoder.decodeBitstrm); strmLen = BITSTRM_numDataWords(Decoder.decodeBitstrm); if(strmLen > 32) { if( DECODER__mp3findSync(&Decoder, 0) == 0 ) { PCM_samplerateChanged(); Pcm.sampleRate = Decoder.status.sampleRate; // Initialize status frameSize, which will then be used // in DECODER__mp3 to determine if enough data is // available in input bitstream. Decoder.status.frameSize = MAX_INPUT_FRAME_SIZE; mp3FastFwdLen = 5L*Decoder.status.bitRate>>4; BITSTRM_pack(Decoder.decodeBitstrm); strmLen = BITSTRM_numDataWords(Decoder.decodeBitstrm); Decoder.firstPacketOffset = Audio.fptr - strmLen; Decoder.averageWordRate = (Audio.file.size-Decoder.firstPacketOffset)/(Audio.duration+1); if(0 == Decoder.averageWordRate) Decoder.averageWordRate = Decoder.status.bitRate>>4; if(Audio.offset) { Decoder.flag |= DEC_FFWD|DEC_MEDIASEEK; DECODER__mp3(); } return TRUE; } } } // Return FALSE if sync is not found, coder will keep calling this routine // until sync is found or media has been gone through completely. return FALSE; }

Here is the call graph for this function:

USHORT DECODER__mp3media (  void   )

Function serves as the decoder media access task handle. Returns: Data length in words that are added into bitstream. Definition at line 38 of file DECODER__mp3media.c. References Audio, Decoder, DECODER_getData(), st_AUDIO::fptr, and st_DECODER::inputBitstrm. { USHORT * pDst; USHORT strmLen; USHORT dataLen = 0; BITSTRM_pack(Decoder.inputBitstrm); strmLen = BITSTRM_numWordsFree(Decoder.inputBitstrm); if( (strmLen > READ_THRESHOLD) ) { Audio.fptr = mp3EndOfReadPtr; pDst = (unsigned short *)BITSTRM_writePtr(Decoder.inputBitstrm); dataLen = DECODER_getData((int*)pDst, Audio.fptr, strmLen); Audio.fptr += dataLen; mp3EndOfReadPtr = Audio.fptr; /* Add to decoder bitstream object. */ BITSTRM_add(Decoder.inputBitstrm, dataLen); } return dataLen; }

Here is the call graph for this function:

BOOL DECODER__ogg (  void   )

Function serves as the OGG decoder task handle. Returns: OGG is responsible to post media task as needed. Definition at line 38 of file DECODER__ogg.c. References Decoder. Referenced by DECODER__oggfirst(). { OGGV_decode(&Decoder); return TRUE; }

BOOL DECODER__oggfirst (  void   )

Function check to set up OGG decoder input bit stream. Returns: TRUE if valid OGG stream is found, otherwise FALSE. Definition at line 38 of file DECODER__oggfirst.c. References Audio, Decoder, DECODER__ogg(), st_DECODER::flag, st_AUDIO::offset, st_PCM::sampleRate, and st_DECODER::status. { OGGV_first(&Decoder); DECODER__ogg(); if(Decoder.status.isValid) { PCM_samplerateChanged(); Pcm.sampleRate = Decoder.status.sampleRate; // Reset bookmark. if(Audio.offset) { Decoder.flag |= DEC_FFWD|DEC_MEDIASEEK; } return TRUE; } return FALSE; }

Here is the call graph for this function:

USHORT DECODER__oggmedia (  void   )

Function serves as the OGG decoder media access task handle. Returns: Always return 0OGG is responsible to post coder task as needed. Definition at line 78 of file DECODER__oggmedia.c. References Decoder. { OGGV_demux(&Decoder); return 0; }

BOOL DECODER__wav (  void   )

Function serves as the wav decoder task handle. Returns: FALSE if more data is needed, otherwise TRUE; Definition at line 50 of file DECODER__wav.c. References Audio, st_DECODER::decodeBitstrm, Decoder, DECODER__wavdecode(), st_DECODER::firstPacketOffset, st_DECODER::flag, GEN_zeroOut(), st_AUDIO::offset, st_DECODER::pipe, PIPE_writeNext(), st_AUDIO::playtime, SAUDIOTIME_UPDT, and st_DECODER::status. Referenced by DECODER__wavfirst(). { unsigned long tmpUL; PIPE_Obj * pipe = &Decoder.pipe; int error = DECODE_NO_ERROR; int dataLength; BOOL ret = TRUE; // Try to decode as long as output pipe is open. while( PIPE_writeFrameNum(pipe) ) { BITSTRM_pack(Decoder.decodeBitstrm); dataLength = BITSTRM_numDataWords(Decoder.decodeBitstrm); // YES. valid data detected, prepare to decode. if ( Decoder.flag & (DEC_FFWD|DEC_FRWD|DEC_MEDIASEEK) ) { BITSTRM_remove(Decoder.decodeBitstrm, dataLength); if(Decoder.flag & DEC_MEDIASEEK) { wvEndOfReadPtr = Audio.offset; Decoder.flag &= ~DEC_MEDIASEEK; } else { if(Decoder.flag & DEC_FFWD) wvEndOfReadPtr += wvFastFwdLen; else if(wvEndOfReadPtr>wvFastFwdLen+Decoder.firstPacketOffset) wvEndOfReadPtr -= wvFastFwdLen; else { // Send silence to get rid of the noise. wvSilence = 6L*Decoder.status.bitRate/8000L; wvEndOfReadPtr = Decoder.firstPacketOffset; } } wvReadPtr = wvEndOfReadPtr; Decoder.flag &= ~(DEC_FFWD|DEC_FRWD); ret = FALSE; break; } else { if(wvSilence) { GEN_zeroOut((UINT16*)pipe->WrFrame.Frame, WAV_PIPE_FRAMELEN); wvSilence--; } else { // is there enough data to be decoded? if( dataLength < WAV_INPUT_BUFFER_SIZE - READ_THRESHOLD_WAV ) ret = FALSE; if( dataLength < (Decoder.status.frameSize) ) { // NO. data not enough yet, bring up media task. return ret; } // decode the bitstream error = DECODER__wavdecode(Decoder.decodeBitstrm, (Int *)pipe->WrFrame.Frame); } // no error, output the data, prepare for the next write as well. if (error == DECODE_NO_ERROR) PIPE_writeNext(pipe); } } BITSTRM_pack(Decoder.decodeBitstrm); // Check to update time. tmpUL = 0; if(wvReadPtr > Decoder.firstPacketOffset) tmpUL = (wvReadPtr-Decoder.firstPacketOffset)/wvAverageWordRate; if ( Audio.playtime != tmpUL ) { Audio.playtime = tmpUL; mMSG_send(sysMsgQ, SYS_MSG_ID, SAUDIOTIME_UPDT, DONTCARE, 0); } return ret; }

Here is the call graph for this function:

BOOL DECODER__wavfirst (  void   )

Function check to set up WAV decoder input bit stream. Returns: TRUE if valid WAV header is found, otherwise FALSE. Definition at line 46 of file DECODER__wavfirst.c. References Audio, st_DECODER::decodeBitstrm, Decoder, DECODER__wav(), DECODER__wavReadHeader(), st_DECODER::flag, st_AUDIO::offset, st_PCM::sampleRate, and st_DECODER::status. { USHORT strmLen; //USHORT * pDst; // Check WAV header. */ BITSTRM_pack(Decoder.decodeBitstrm); strmLen = BITSTRM_numDataWords(Decoder.decodeBitstrm); if(strmLen > sizeof(st_WAVHEADER)) { if( TRUE == DECODER__wavReadHeader(&Decoder) ) { PCM_samplerateChanged(); Pcm.sampleRate = Decoder.status.sampleRate; // Reset bookmark. if(Audio.offset) { Decoder.flag |= DEC_FFWD|DEC_MEDIASEEK; DECODER__wav(); } BITSTRM_pack(Decoder.decodeBitstrm); return TRUE; } } // Return FALSE if header is invalid, coder will keep calling this routine // until valid header is found or media has been gone through completely. return FALSE; }

Here is the call graph for this function:

USHORT DECODER__wavmedia (  void   )

Function serves as the WAV decoder media access task handle. Returns: Data length in words that are added into bitstream. Definition at line 41 of file DECODER__wavmedia.c. References Audio, Decoder, DECODER_getData(), st_AUDIO::fptr, and st_DECODER::inputBitstrm. { USHORT * pDst; USHORT strmLen; USHORT dataLen = 0; BITSTRM_pack(Decoder.inputBitstrm); strmLen = BITSTRM_numWordsFree(Decoder.inputBitstrm); if( (strmLen > READ_THRESHOLD_WAV) ) { Audio.fptr = wvEndOfReadPtr; pDst = (unsigned short *)BITSTRM_writePtr(Decoder.inputBitstrm); dataLen = DECODER_getData((int*)pDst, Audio.fptr, strmLen); Audio.fptr += dataLen; wvEndOfReadPtr = Audio.fptr; /* Add to decoder bitstream object. */ BITSTRM_add(Decoder.inputBitstrm, dataLen); } return dataLen; }

Here is the call graph for this function:

BOOL DECODER__wma (  void   )

Function serves as the WMA decoder data output task handle. Returns: FALSE if more data is needed, otherwise TRUE; NOTE: this data ouput task always returns TRUE. Definition at line 61 of file DECODER__wma.c. References Audio, st_DECODER::averageWordRate, st_DECODER::decode, st_DECODER::decodeBitstrm, Decoder, st_DECODER::decrypt, st_DECODER::firstPacketOffset, st_DECODER::flag, st_DECODER::inputBitstrm, st_DECODER::pipe, PIPE_writeNext(), st_AUDIO::playtime, SAUDIOTIME_UPDT, and st_DECODER::status. { PIPE_Obj * pipe = &Decoder.pipe; int error = DECODE_NO_ERROR; ULONG tmpUL; // Try to decode as long as output pipe is open. while( PIPE_writeFrameNum(pipe) ) { if ( Decoder.flag & (DEC_FFWD|DEC_FRWD) ) { if(0== SEM_count(SEM_subcoder)) SEM_post(SEM_subcoder); } error = DECODE_decode( Decoder.decode, Decoder.decodeBitstrm, (Int *)pipe->WrFrame.Frame ); DECODE_getStatus(Decoder.decode, &Decoder.status); if (error == DECODE_NO_ERROR) { // no error, so output the data, prepare for the next write as well. PIPE_writeNext(pipe); //if ( Decoder.status.bitRate ) if(Decoder.averageWordRate) { // (wordsize*2)/(bitrate/8) //tmpUL = (wmadecode.startOfDataFileAdr-FIRST_PACKET_OFFSET) // /(Decoder.status.bitRate>>4); tmpUL = 0; if(wmadecode.startOfDataFileAdr > Decoder.firstPacketOffset) tmpUL = (wmadecode.startOfDataFileAdr-Decoder.firstPacketOffset)/ Decoder.averageWordRate; if ( Audio.playtime != tmpUL ) { Audio.playtime = tmpUL; mMSG_send(sysMsgQ, SYS_MSG_ID, SAUDIOTIME_UPDT, DONTCARE, 0); } } } else if(error == DECODE_ERROR) { // Error, resync on the next call. Note that the output // pipe frame is kept for next decoding attempt. SCRYPT_reset(Decoder.decrypt); DECODE_reset(Decoder.decode); BITSTRM_reset(Decoder.inputBitstrm); } else if(error == DECODE_NO_DATA) { if(0 == SEM_count(SEM_subcoder)) SEM_post(SEM_subcoder); break; } } return TRUE; }

Here is the call graph for this function:

BOOL DECODER__wmafirst (  void   )

Function bridges the WMA subcoder to main decoder handle. Returns: TRUE if subcoder has been inited, otherwise FALSE. Definition at line 90 of file DECODER__wmafirst.c. References st_CODER::subcoderInit. { if(Coder.subcoderInit) return FALSE; else return TRUE; }

BOOL DECODER__wmainit (  void   )

Function check to init WMA decoder input bit stream. Returns: TRUE if valid WMA stream header is found, otherwise FALSE. Definition at line 41 of file DECODER__wmafirst.c. References Audio, st_DECODER::averageWordRate, st_DECODER::decode, st_DECODER::decodeBitstrm, Decoder, DECODER__wmatask(), st_AUDIO::duration, st_AUDIO::file, st_DECODER::firstPacketOffset, st_DECODER::flag, st_AUDIO::offset, st_PCM::sampleRate, File::size, and st_DECODER::status. { USHORT strmLen; BITSTRM_pack(Decoder.decodeBitstrm); strmLen = BITSTRM_numDataWords(Decoder.decodeBitstrm); if(strmLen > WMA_MAX_INPUT_FRAME_SIZE) { // Decode to validate audio data and return status. WMA_task(); DECODE_getStatus(Decoder.decode, &Decoder.status); BITSTRM_pack(Decoder.decodeBitstrm); if(Decoder.status.isValid) { PCM_samplerateChanged(); Pcm.sampleRate = Decoder.status.sampleRate; Decoder.averageWordRate = (Audio.file.size-FIRST_PACKET_OFFSET)/(Audio.duration+1); if(0 == Decoder.averageWordRate) Decoder.averageWordRate = Decoder.status.bitRate>>4; // Aligned on packet length boundary. wmaFastFwdLen = 5L*(Decoder.status.bitRate>>4); wmaFastFwdLen /= Decoder.status.frameSize; wmaFastFwdLen *= Decoder.status.frameSize; Decoder.firstPacketOffset = FIRST_PACKET_OFFSET; // Seek to start offset. if(Audio.offset) { Decoder.flag |= DEC_FFWD|DEC_MEDIASEEK; DECODER__wmatask(); } return TRUE; } } return FALSE; }

Here is the call graph for this function:

USHORT DECODER__wmamedia (  void   )

Function serves as the WMA decoder media access task handle. Returns: Data length in words that are added into bitstream. Definition at line 41 of file DECODER__wmamedia.c. References Audio, Decoder, DECODER_getData(), st_AUDIO::fptr, and st_DECODER::inputBitstrm. { USHORT * pDst; USHORT strmLen; USHORT dataLen = 0; BITSTRM_pack(Decoder.inputBitstrm); strmLen = BITSTRM_numWordsFree(Decoder.inputBitstrm); if( (strmLen > READ_THRESHOLD_WMA) ) { // Fetch start offset. Audio.fptr = wmadecode.endOfDataFileAdr; pDst = (unsigned short *)BITSTRM_writePtr(Decoder.inputBitstrm); dataLen = DECODER_getData((int*)pDst, Audio.fptr, strmLen); Audio.fptr += dataLen; /* Add to decoder bitstream object. */ BITSTRM_add(Decoder.inputBitstrm, dataLen); } if(SEM_count(SEM_subcoder) == 0) SEM_post(SEM_subcoder); return dataLen; }

Here is the call graph for this function:

BOOL DECODER__wmatask (  void   )

Function serves as the WMA decoder task handle. Returns: FALSE if more data is needed, otherwise TRUE; Definition at line 129 of file DECODER__wma.c. References Audio, st_DECODER::decodeBitstrm, Decoder, st_DECODER::flag, and st_AUDIO::offset. Referenced by DECODER__wmainit(). { // Try to decode as long as output buffer is available. while( sramPP_isWritable( &SRAMPP ) ) { BITSTRM_pack(Decoder.decodeBitstrm); if ( Decoder.flag & (DEC_FFWD|DEC_MEDIASEEK) ) { seekMode = 1; if(Decoder.flag & DEC_MEDIASEEK) { g_ErrorRetryPos = Audio.offset<<1; Decoder.flag &= ~DEC_MEDIASEEK; } else g_ErrorRetryPos += wmaFastFwdLen; Decoder.flag &= ~DEC_FFWD; } else if ( Decoder.flag & DEC_FRWD ) { seekMode = -1; g_ErrorRetryPos -= wmaFastFwdLen; Decoder.flag &= ~DEC_FRWD; } WMA_task(); } BITSTRM_pack(Decoder.decodeBitstrm); return TRUE; }

void DECODER_cache (  void   )

Function serves as the decoder cache task handle. This task feeds the cache. Definition at line 156 of file DECODER_getData.c. References st_CACHE::actvFileSize, st_CACHE::actvStartClus, Audio, st_AUDIO::cachefile, DECODER_cacheDepthReset(), st_CACHE::done, st_CACHE::endSec, FAT_fread(), FAT_fseek(), st_AUDIO::file, st_CODER::flag, NAND_writeSec(), st_CACHE::next, st_CACHE::prev, SCURRENTAUDIOFILE, st_CACHE::secNum, st_CACHE::secOffset, SEEK_HEAD, File::size, SNEXTAUDIOFILE, File::startClus, and st_CACHE::startSec. { unsigned short len; st_CACHE * c; unsigned short buf[256]; if( F_CODER_CACHESETIDLE & Coder.flag ) { SEM_post(SEM_cacheIdle); return; } // On entry, check the lower threshold. if( (!(F_CODER_CACHESHUTDOWN & Coder.flag)) && (cacheDepth > cacheLowerThreshold) ) { CACHE_RETURN(); } while(1) { if( F_CODER_CACHESHUTDOWN & Coder.flag ) { _cacheShutdown(buf); SEM_post(SEM_cacheIdle); CACHE_RETURN(); } if( F_CODER_CACHESETIDLE & Coder.flag ) { SEM_post(SEM_cacheIdle); } // Every time cache gets posted, check will be done // in the following order, // 1) Is current audio file in cache queue and has it been fully cached? // 2) Is it necessary to update cache to read in more new data? // File in cache and fully cached, check to read in more. if( (rdCache->actvStartClus == Audio.file.startClus)&& (rdCache->actvFileSize == Audio.file.size)&& (rdCache->done == TRUE) ) { if(wrCache->done == TRUE) { // Try next file. mMSG_send(uiParentMsgQ, SYS_MSG_ID, SNEXTAUDIOFILE, 1, SYS_FOREVER); // Get a copy of cachefile handle. //TSK_disable(); cachefile = Audio.cachefile; //TSK_enable(); c = _cachePosition(&cachefile); //if( (c->done == TRUE)&&(c == cacheHead) ) //{ // Already cached all tracks. //msgOUT.id = SYS_MSG_ID; //msgOUT.d1 = SCURRENTAUDIOFILE; //mMSG_send(uiParentMsgQ, &msgOUT, SYS_FOREVER); //CACHE_RETURN(); //} //else if( (c->actvStartClus == cachefile.startClus)&& (c->actvFileSize == cachefile.size)&& (c->done == TRUE) ) { cacheDepth += c->secNum; if(c->actvStartClus != wrCache->actvStartClus) { wrCacheSec += c->secNum; if(wrCacheSec > SYS_cacheEndSec()) wrCacheSec -= SYS_cacheSecNum(); } CACHE_RETURN(); //continue; } else { FAT_fseek(&cachefile, 0, SEEK_HEAD); //TSK_disable(); cacheTail = c->next; cacheTail->actvStartClus = 0; cacheTail->done = FALSE; if(cacheTail == cacheHead) cacheHead = cacheHead->next; wrCache = c; wrCacheSec = wrCache->startSec = wrCache->endSec = c->prev->endSec; wrCache->secNum = 0; wrCache->secOffset= 0; wrCache->actvStartClus = cachefile.startClus; wrCache->actvFileSize = cachefile.size; wrCache->done = FALSE; //TSK_enable(); } } } else { if( (wrCache->actvStartClus != Audio.file.startClus)|| (wrCache->actvFileSize != Audio.file.size)|| (wrCache != rdCache)) { ULONG secOffset = 0; mMSG_send(uiParentMsgQ, SYS_MSG_ID, SCURRENTAUDIOFILE, DONTCARE, SYS_FOREVER); //TSK_disable(); cachefile = Audio.file; //TSK_enable(); if(prevOffset > 0x40000) { secOffset = prevOffset/256; FAT_fseek(&cachefile, secOffset*256, SEEK_HEAD); } else FAT_fseek(&cachefile, 0, SEEK_HEAD); //TSK_disable(); if(wrCache->done == TRUE) { wrCacheSec = wrCache->endSec; wrCache = wrCache->next; wrCache->startSec = wrCacheSec; } else wrCacheSec = wrCache->startSec; cacheTail = wrCache->next; cacheTail->actvStartClus = 0; cacheTail->done = FALSE; if(cacheTail == cacheHead) cacheHead = cacheHead->next; wrCache->actvStartClus = cachefile.startClus; wrCache->actvFileSize = cachefile.size; wrCache->endSec = wrCacheSec ; wrCache->secNum = 0; wrCache->done = FALSE; wrCache->secOffset= secOffset; rdCache = wrCache; cacheDepth = 0; //TSK_enable(); } } // Check cache depth. if(cacheDepth > cacheUpperThreshold) { DECODER_cacheDepthReset(2); mMSG_send(uiParentMsgQ, SYS_MSG_ID, SNEXTAUDIOFILE, 0, SYS_FOREVER); CACHE_RETURN(); } if(SYS_nextCacheSec(wrCache->endSec) == cacheHead->startSec) { //TSK_disable(); if( (cacheHead != wrCache) ) { if(cacheHead != rdCache) cacheHead = cacheHead->next; else CACHE_RETURN(); } else { // Cache is full. cacheHead->secOffset++; cacheHead->secNum--; cacheHead->startSec = SYS_nextCacheSec(cacheHead->startSec); } //TSK_enable(); } len = FAT_fread(&cachefile, buf, 256); NAND_writeSec(wrCacheSec, buf, FALSE); cacheDepth++; wrCacheSec = SYS_nextCacheSec(wrCacheSec); wrCache->endSec = wrCacheSec; wrCache->secNum++; if(len<256) wrCache->done = TRUE; SYS_swWdtReset(); } }

Here is the call graph for this function:

void DECODER_cacheDepthReset (  unsigned short  mode  )

Function resets cache depth controls. This function also resets cache check state to verify if file exists in cache. Parameters: mode  Cache depth control mode. 0: reset to default. 1: Double current. 2: Increment. Definition at line 406 of file DECODER_getData.c. Referenced by DECODER_cache(), DECODER_cacheInit(), and UI_PSF_play(). { TSK_disable(); inCacheState = INCACHE_CHECK; if(0 == mode) { cacheUpperThreshold = 0x1000; cacheLowerThreshold = 0x800; } else { if(1 == mode) // Double upper threshold. { cacheUpperThreshold <<= 1; } else // Increment upper threshold. { cacheUpperThreshold += 0x1000; } if(cacheUpperThreshold >= SYS_cacheSecNum() ) { // Aligned to NAND page boundary. cacheUpperThreshold = SYS_cacheSecNum() - 62; } } TSK_enable(); }

BOOL DECODER_config (  DEC_TYPE  eType  )

Function configures the decoder module. Parameters: eType  Decoder type. Definition at line 97 of file DECODER_config.c. References st_CODER::cache, st_CODER::cacheInit, Decoder, st_DECODER::flag, st_CODER::mediaInit, st_DECODER::pipe, PIPE_reset(), st_CODER::subcoder, SYS_die(), and st_DECODER::type. Referenced by AUDIO_config(). { Decoder.type = eType; Coder.subcoder = DECODER__nullsubcoder; Coder.cache = DECODER_cache; Coder.cacheInit = DECODER_cacheInit; Coder.mediaInit = NULL; _decPipeBuf = (int*)malloc(_DEC_PIPE_BUF_LEN); if(NULL == _decPipeBuf) SYS_die(SYS_DECODER_CONFIG); switch(eType) { #ifdef WAV_SUPPORT case DECWAV: _wavConfig(); break; #endif // WAV_SUPPORT case DECMP3: _mp3Config(); break; #ifdef WMA_SUPPORT case DECWMA: _wmaConfig(); break; #endif // WMA_SUPPORT #ifdef OGG_SUPPORT case DECOGG: _oggConfig(); break; #endif //OGG_SUPPORT } /* Reset the decoder pipe. */ PIPE_reset(&Decoder.pipe); /* Clear decoder file flag. */ Decoder.flag = 0; return TRUE; }

Here is the call graph for this function:

unsigned short DECODER_getData (  int *  pD, unsigned long  offset, unsigned short  reqLen )

Function feeds data into docoder bit stream/buffer. A NAND cache is managed here if HDD is present. Parameters: pD  Decoder input data pointer. offset  Requested data offset in media file. reqLen  Requested data length in words. Returns: Available data length in words. Definition at line 132 of file DECODER_getData.c. References Audio, FAT_fread(), FAT_fseek(), st_AUDIO::file, File::ptr, and SEEK_MID. Referenced by DECODER__mp3media(), DECODER__oggRead(), DECODER__wavmedia(), and DECODER__wmamedia(). { unsigned short len; File * fp = &Audio.file; if(FALSE == _isCacheHit(fp, offset, &reqLen)) { if(offset != fp->ptr) FAT_fseek(fp, (long)(offset-fp->ptr), SEEK_MID); len = FAT_fread(fp, (unsigned short*)pD, reqLen); } else { len = _cacheRead(offset, (unsigned short*)pD, reqLen); } if(len == 0) DECODER_stop(); return len; }

Here is the call graph for this function:

int* DECODER_main (  void   )

Function fetches decoder output upon PCM request. All decoders share this same pipe interface although they might use different sized pipes. Returns: Readable pipe frame if data is available, otherwise NULL. Definition at line 45 of file DECODER_main.c. References AI_STOP, Decoder, st_DECODER::flag, st_CODER::flag, st_DECODER::pipe, PIPE_readNext(), SAUDIOCTL, SEM_coder, and SENDOFMUSIC. Referenced by AUDIO_start(). { PIPE_Obj * pipe = &Decoder.pipe; if(Decoder.flag & DEC_PIPE_READNEXT_PENDING) { PIPE_readNext(pipe); Decoder.flag &= ~DEC_PIPE_READNEXT_PENDING; if(SEM_count(SEM_coder) == 0) SEM_post(SEM_coder); } if( PIPE_readFrameNum(pipe) ) { Decoder.flag |= DEC_PIPE_READNEXT_PENDING; return pipe->RdFrame.Frame; } else if(Coder.flag & F_CODER_DEC_EOF) { if(!(Coder.flag&F_CODER_DEC_EOF_POSTED)) { Coder.flag |= F_CODER_DEC_EOF_POSTED; mMSG_send(sysMsgQ, SYS_MSG_ID, SAUDIOCTL, AI_STOP, SYS_FOREVER); mMSG_send(uiChildMsgQ, SYS_MSG_ID, SENDOFMUSIC, DONTCARE, SYS_FOREVER); } return NULL; } if(SEM_count(SEM_coder) == 0) SEM_post(SEM_coder); return NULL; }

Here is the call graph for this function:

---

Variable Documentation

st_DECODER Decoder

Decoder globals. Note that this global will be used by PCM SWIs, it has to be resident all the time. Definition at line 49 of file DECODER_config.c. Referenced by AUDIO_setFilePtr(), DECODER__mp3(), DECODER__mp3first(), DECODER__mp3media(), DECODER__ogg(), DECODER__oggfirst(), DECODER__oggmedia(), DECODER__wav(), DECODER__wavdecode(), DECODER__wavfirst(), DECODER__wavmedia(), DECODER__wavReadHeader(), DECODER__wma(), DECODER__wmainit(), DECODER__wmamedia(), DECODER__wmatask(), DECODER_config(), and DECODER_main().

---