DECODER_config.c

Go to the documentation of this file.

/*****************************************************************************
                           C   M O D U L E   F I L E

    Copyright (c) 2003 Neuros Audio LLC, All rights reserved.

******************************************************************************/


/*-- HEADER FILE INCLUDES ---------------------------------------------------*/
#include "../SYSTEM/sys_hardware.h"
#include "../SYSTEM/sys_assert.h"
#include "../codec/codec.h"
#include "../coder/coder.h"
#include "decoder.h"

/*-- LOCAL DEFINITIONS ------------------------------------------------------*/
static void _xDAIS_init( void );
static void _wavConfig(void);
static void _mp3Config(void);
static void _wmaConfig(void);
static void _oggConfig(void);

/*-- STATIC DATA ------------------------------------------------------------*/
#pragma DATA_SECTION(_decPipeBuf,   "decoder_global")
// Allocte decoder pipe buffer separately to prevent memory fragmentation
// due to track changes among different formated music.
#define _DEC_PIPE_BUF_LEN           ((576+2)*4)
static int * _decPipeBuf;

/*-- GLOBAL DATA ------------------------------------------------------------*/
#pragma DATA_SECTION(Decoder,       "idata_resident")
st_DECODER Decoder;

#pragma DATA_SECTION(Decode,        "decoder_global")
#pragma DATA_SECTION(Decode_memRec, "decoder_global")
#pragma DATA_SECTION(Decode_params, "decoder_global")
#pragma DATA_SECTION(SpecAn,        "decoder_global")
#pragma DATA_SECTION(SpecAn_memRec, "decoder_global")
#pragma DATA_SECTION(SpecAn_params, "decoder_global")
/* These globals can be unioned with that of the encoder. */
IDECODE_Obj *       Decode;
IALG_MemRec *       Decode_memRec;
IDECODE_Params *    Decode_params;
                               
ISPECAN_Obj *       SpecAn;
IALG_MemRec *       SpecAn_memRec;
ISPECAN_Params *    SpecAn_params;

#pragma DATA_SECTION(Bitbuf_params, "decoder_global")
BITBUF_Params Bitbuf_params;

extern Uns mp3BitstreamData[];
extern Uns wavBitstreamData[];

#ifdef WMA_SUPPORT
extern void WMA_task(void);
extern Uns wmaBitstreamData[];
extern IDECODE_Obj WMA_TI_obj0;
extern IDECODE_Params WMA_TI_obj0_params;
extern IALG_MemRec WMA_TI_obj0_memRec[];
extern SramPP_Obj SRAMPP;
#endif

#ifdef WAV_SUPPORT
extern unsigned long wvReadPtr;
extern unsigned long wvEndOfReadPtr;
extern unsigned short wvSilence;
#endif

extern Uns mp3BitstreamData[];

/*-- FUNCTIONS --------------------------------------------------------------*/
#pragma CODE_SECTION(DECODER_config, ".decoder_code")
BOOL DECODER_config( DEC_TYPE eType )
{
    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;
}


#pragma CODE_SECTION(DECODER_releaseObj, ".decoder_code")
void DECODER_releaseObj(void)
{
    //PIPE_delete(&Decoder.pipe);
    if(_decPipeBuf) free(_decPipeBuf);
    _decPipeBuf = NULL;
    
    #ifdef WMA_SUPPORT
    if(AF_WMA == Audio.format) sramPP_delete(&SRAMPP);
    #endif
}


#pragma CODE_SECTION(_xDAIS_init, ".decoder_code")
static void _xDAIS_init( void )
{
    Decoder.decode      = Decode;   
    Decoder.decrypt     = &Decrypt;
    Decoder.specan      = SpecAn;
    
    /* This should be the input bitstream buffer size. */
    //Decoder.buffer_size =  INPUT_BUFFER_SIZE;
        
    if (Decoder.decrypt) 
    {       
            #if 0
        Bitbuf_params.numberOfBitstreams = 3;       
        BITBUF_init(&Decoder.bitbuf, &Bitbuf_params);
        Decoder.inputBitstrm        = &Decoder.bitbuf.bitstream[2];
        Decoder.decryptBitstrm  = &Decoder.bitbuf.bitstream[1];
        Decoder.decodeBitstrm   = &Decoder.bitbuf.bitstream[0];
            #endif
    }
    else 
    {      
        BITBUF_init(&Decoder.bitbuf, &Bitbuf_params);      
        Decoder.inputBitstrm        = &Decoder.bitbuf.bitstream[1];
        Decoder.decryptBitstrm  = 0;
        Decoder.decodeBitstrm   = &Decoder.bitbuf.bitstream[0];
    }
    
    SCRYPT_algInit(&Decrypt, Decrypt_memRec, NULL, &Decrypt_params);
    DECODE_algInit(Decode, Decode_memRec, NULL, Decode_params);
    SPECAN_algInit(SpecAn, SpecAn_memRec, NULL, SpecAn_params);
    DECODE_reset(Decoder.decode);
}

#ifdef WAV_SUPPORT
#pragma CODE_SECTION(_wavConfig, ".wav_code")
// Function configs WAV decoder.
static void _wavConfig(void)
{
    Coder.coder                     = DECODER__wav;
    Coder.media                     = DECODER__wavmedia;            
    Coder.init                      = DECODER__wavfirst;
    /* Create pipes. */
    if( PIPE_init(&Decoder.pipe, WAV_PIPE_FRAMELEN, 4, 
                    _decPipeBuf, _DEC_PIPE_BUF_LEN) == 0 ) 
        SYS_die(SYS_DECODER_CONFIG_WAV);

    Decoder.data                    = &wavBitstreamData[0];
    Decoder.buffer_size             =  WAV_INPUT_BUFFER_SIZE;
    Bitbuf_params.numberOfBitstreams= 2;
    Bitbuf_params.startOfBuffer     = &Decoder.data[0];
    Bitbuf_params.endOfBuffer       = &Decoder.data[WAV_INPUT_BUFFER_SIZE];

    Bitbuf_params.bitstream         = 0;
    Bitbuf_params.maxFreeSpace      = 0;
                
    BITBUF_init(&Decoder.bitbuf, &Bitbuf_params);      
    Decoder.inputBitstrm        = &Decoder.bitbuf.bitstream[1];
    Decoder.decryptBitstrm      = 0;
    Decoder.decodeBitstrm       = &Decoder.bitbuf.bitstream[0]; 
    
    wvReadPtr      = 0L;    
    wvEndOfReadPtr = 0L;
    wvSilence      = 0;
}
#endif

#pragma CODE_SECTION(_mp3Config, ".mp3_code")
// Function configs MP3 decoder.
static void _mp3Config(void)
{
    Coder.coder                     = DECODER__mp3;
    Coder.media                     = DECODER__mp3media;
    Coder.init                      = DECODER__mp3first;
            
    Decoder.data                    = &mp3BitstreamData[0];
    Decoder.buffer_size             =  INPUT_BUFFER_SIZE;
    Bitbuf_params.numberOfBitstreams= 2;
    Bitbuf_params.startOfBuffer     = &Decoder.data[0];
    Bitbuf_params.endOfBuffer       = &Decoder.data[INPUT_BUFFER_SIZE];

    Bitbuf_params.bitstream         = 0;
    Bitbuf_params.maxFreeSpace      = 0;

    /* Create pipes. */
    if( PIPE_init(&Decoder.pipe, MP3_PIPE_FRAMELEN, 2, 
                    _decPipeBuf, _DEC_PIPE_BUF_LEN) == 0 ) 
        SYS_die(SYS_DECODER_CONFIG_MP3);
            
    Decode          = &MP3_TI_obj0;         
    Decode_memRec   = MP3_TI_obj0_memRec;           
    Decode_params   = &MP3_TI_obj0_params;                               
    SpecAn          = &SPECMP3_TI_obj0;         
    SpecAn_memRec   = SPECMP3_TI_obj0_memRec;           
    SpecAn_params   = &SPECMP3_TI_obj0_params;
            
    _xDAIS_init();
    
    mp3ReadPtr      = 0;
    mp3EndOfReadPtr = 0;
    mp3Silence      = 0;
    mp3FrameIdx     = 0;
}

#ifdef WMA_SUPPORT
#pragma CODE_SECTION(_wmaConfig, ".wma_code")
// Function configs WMA decoder.
static void _wmaConfig(void)
{
    Coder.coder                     = DECODER__wma;
    Coder.subcoder                  = DECODER__wmatask;
    Coder.media                     = DECODER__wmamedia;            
    Coder.init                      = DECODER__wmafirst;
    Coder.subcoderInit              = DECODER__wmainit;

    Decoder.data                    = &wmaBitstreamData[0];
    Decoder.buffer_size             =  WMA_INPUT_BUFFER_SIZE;
    Bitbuf_params.numberOfBitstreams= 2;
    Bitbuf_params.startOfBuffer     = &Decoder.data[0];
    Bitbuf_params.endOfBuffer       = &Decoder.data[WMA_INPUT_BUFFER_SIZE];

    Bitbuf_params.bitstream         = 0;
    Bitbuf_params.maxFreeSpace      = 0;
            
    if( PIPE_init(&Decoder.pipe, WMA_PIPE_FRAMELEN, 2, 
                    _decPipeBuf, _DEC_PIPE_BUF_LEN) == 0 ) 
        SYS_die(SYS_DECODER_CONFIG_WMA);
            
    if (sramPP_init(&SRAMPP, 4096) == FALSE ) 
        SYS_die(SYS_DECODER_CONFIG_WMA2);
            
    Decode          = &WMA_TI_obj0;
    Decode_memRec   = WMA_TI_obj0_memRec;
    Decode_params   = &WMA_TI_obj0_params;
    SpecAn          =  0;
    SpecAn_memRec   = 0;
    SpecAn_params   = 0;
            
    _xDAIS_init();
}
#endif

#ifdef OGG_SUPPORT
#pragma CODE_SECTION(_oggConfig, ".ogg_code")
// Function configs OGG decoder.
static void _oggConfig(void)
{
    Coder.coder                     = DECODER__ogg;
    Coder.media                     = DECODER__oggmedia;            
    Coder.init                      = DECODER__oggfirst;

    /* Create pipes. */
    if( PIPE_init(&Decoder.pipe, OGG_PIPE_FRAMELEN, 32, 
                    _decPipeBuf, _DEC_PIPE_BUF_LEN) == 0 ) 
        SYS_die(SYS_DECODER_CONFIG_OGG);
}
#endif


#pragma CODE_SECTION(DECODER__nullsubcoder, ".decoder_code")
BOOL DECODER__nullsubcoder( void ){return TRUE;}


/*****************************************************************************
                Neuros Audio LLC. Confidential Proprietary
 *****************************************************************************/

---