msapi_audio_dvb.c

mstar 776 开发的车载dvd

            return AU_SYS_M_A2;

        case AUDIO_SYSTEM_EIAJ:
            return AU_SYS_M_EIAJ;

        default:
            return AU_SYS_NOT_READY;
    }
}
#else // PAL
En_SIF_systemType msAPI_AUD_SifGetSystem(EnuTVColorSystem ucColorSys)
{
    U8  AUD_Tmp;

    if ( ucColorSys == TV_COLOR_SECAM )
    {
        AUD_Tmp = MDrv_AuSifGetMainSystem(AU_CARRIER1_IGNORE|AU_CARRIER2_L);
    }
    else
    {
        AUD_Tmp =  MDrv_AuSifGetMainSystem(AU_CARRIER1_IGNORE|AU_CARRIER2_DK);
    }

    return(AUD_Tmp);
}
#endif

//******************************************************************************
//Function name:    msAPI_AUD_SifSetSystem
//Passing parameter:    system type
//Return parameter:     void
//Description:          Set SIF standard
//  [Doxygen]
/// Set SIF standard
/// @param system_type \b IN system type
//******************************************************************************
void msAPI_AUD_SifSetSystem(En_SIF_systemType system_type)
{
    // TODO
    //if ( system_type != enCurSifSystem )
    //{
    MDrv_AuProcessSetMute(AUDIO_PATH_0, TRUE);
    MDrv_AuProcessSetMute(AUDIO_PATH_1, TRUE);

    if ( system_type != MSAPI_AUD_SIF_SYS_NOT_READY )
    {
        MDrv_AuSifSetSystem(system_type|AU_MODE_AUTO);
    }

    enCurSifSystem = system_type;
    //}

    #if (CHANNEL_SCAN_AUTO_TEST == 0)
    //printf("apiAud>> system_type %bu enCurSifSystem = %bu\n", (U8)system_type, (U8)enCurSifSystem);
    #endif

    AUD_DEBUG(printf("apiAud>> system_type %bu enCurSifSystem = %bu\n", (U8)system_type, (U8)enCurSifSystem));
}

//******************************************************************************
//Function name:    msAPI_AUD_Initialize
//Passing parameter:    MS_SoundSettingType* stSoundSetting: Sound setting structure pointer
//Return parameter:     none
//Description:      Audio initialization
//  [Doxygen]
/// Audio initialization
/// @param stSoundSetting \b IN Sound setting structure pointer
//******************************************************************************
void msAPI_AUD_Initialize(stUserSoundSettingType* stSoundSetting)
{
    BINFORMAT BinInfo;

    AUD_DEBUG(printf("msAPI_AUD_Initialize\n"));
    msAPI_AUD_SetDecCommand(MSAPI_AUD_STOP);

    XBYTE[0x2CE5] = 0x00;	// ADC Power on
    XBYTE[0x2CE4] = 0x00;	// ADC Power on
    XBYTE[0x2CE7] = 0x30;	// ADC Power on
    XBYTE[0x2CE6] = 0x00;	// ADC Power on
    // The following code would be removed to Audio Driver hereafter
    XBYTE[0x2CC1] &= 0xE7;         // turn on SIF ADC
    XBYTE[0x2CC0] &= 0xF3;          // turn on SIF ADC
    XBYTE[0x2CC2] &= 0xFC;        // turn on SIF ADC Vref Gen.
    XBYTE[0x2CD2] &= 0xEF;         // turn on SIF PLL
    XBYTE[0x2CC2] &= 0xFC;
    XBYTE[0x2CD2] &= 0xEF;

    BinInfo.B_ID = BIN_ID_CODE_AUDIO;

    if ( msAPI_MIU_Get_BinInfo(&BinInfo) != PASS )
    {
        AUD_DEBUG(printf("Audio: could not find Audio binary on flash.\r\n"));
        return;
    }

    MDrv_AudioSetBaseAddress(BinInfo.B_FAddr, MAD_BASE_BUFFER_ADR);

    // 0: AC3, 1:MPEG, 2:SIF BTSC
    MDrv_AudioInit(1);//, MAD_BASE_BUFFER_ADR);

    // keep the following reload functions - bj // TODO
    //MDrv_AuDvbReLoadCode(AU_DVB_STANDARD_MPEG);
    //MDrv_AuDvbReLoadCode(AU_DVB_STANDARD_AC3);
    //MDrv_AuSifReLoadCode(AU_STANDARD_BTSC);

    // set sound effect by user settings
    msAPI_AUD_SetBass(stSoundSetting->astSoundModeSetting[stSoundSetting->SoundMode].Bass);
    msAPI_AUD_SetTreble(stSoundSetting->astSoundModeSetting[stSoundSetting->SoundMode].Treble);
    msAPI_AUD_SetBalance(stSoundSetting->astSoundModeSetting[stSoundSetting->SoundMode].Balance);

    msAPI_AUD_SetSurround(SURROUND_MODE_MOUNTAIN);
    msAPI_AUD_SetAutoVolume(stSoundSetting->bEnableAVC);
    msAPI_AUD_SetSubwooferCutFreq(100);

    // init variables
    enCurAuInputSel = MSAPI_AUD_INPUT_DECORDER;
    enCurSoundMode = MSAPI_AUD_DVB_SOUNDMODE_NONE;
    enCurSifSoundMode = SOUND_MTS_NONE;

#if (AUDIO_DSP_CODE_SEL == AUDIO_DSP_CODE_DVB)
    enCurDecSystem = MSAPI_AUD_DVB_MPEG;
    enCurSifSystem = MSAPI_AUD_SIF_SYS_NOT_READY;
#else
    enCurDecSystem = MSAPI_AUD_DVB_NONE;
    #if (AUDIO_SYSTEM_SEL==AUDIO_SYSTEM_A2)
    enCurSifSystem = MSAPI_AUD_SIF_SYS_M_A2;
    #elif (AUDIO_SYSTEM_SEL==AUDIO_SYSTEM_EIAJ)
    enCurSifSystem = MSAPI_AUD_SIF_SYS_M_EIAJ;
    #else
    enCurSifSystem = MSAPI_AUD_SIF_SYS_M_BTSC;
    #endif
#endif

    MDrv_AuSetSPDIF_Path(1);

    // remove pop noise
    // Audio_Amplifier_ON();

    // keep MVD status
    enDecoderStatus = MSAPI_AUD_DVB_DECCMD_STOP;

    /* fine tune SAP detection for U02 */
    XBYTE[0x2CCF] = 0x28;

    XBYTE[0x2CC1] |= 0x02;
    //2CC0[9]=1                    (ENC=1)

    XBYTE[0x2CC5] |= 0x10;
    //2CC4[12]=1                   (AU_ADCREF_OV=1)

    XBYTE[0x2CC5] &= 0xF7;
    //2CC4[11]=0                   (AU_GSHIFT=0)

    XBYTE[0x2CC4] |= 0x80;
    //2CC4[7]=1                    (AU_AAF_CTRL_SEL=1)

    XBYTE[0x2CC7] = 0x10;
    //2CC6[15:8]=0001,0000         (ADC_BP[7:0]=0001,0000)

    XBYTE[0x2CC8] = 0x90;
    //2CC8[7:0]=1001,0000          (ADC_BM[7:0]=1001,0000)

    XBYTE[0x2CCA] = 0x55;
    XBYTE[0x2CCB] = 0x15;
    //2CCA[13:0]=01,0101,0101,0101 (ASIF_ICTRL[13:0]=01,0101,0101,0101)

    XBYTE[0x2CD1] = 0x6C;
    XBYTE[0x2CD0] = 0x00;
    //2CD0[15:13]=011              (ADC_VCTRL=011)
    //2CD0[11:0]=1100,0000,0000    (ASIF_ADCREF[11:0]=1100,0000,0000)
    /* end of SAP detection for U02 */
/* #if ( MS_BOARD_TYPE_SEL == BD_CUS1X_03)
    Audio_Lineout_nonStb();
    Audio_Lineout_ON();
    MDrv_Timer_Delayms(50);
    Audio_Amplifier_nonStb();
  #endif  */	// kevin 071023_3
}


//******************************************************************************
//Function name:    msAPI_AUD_AudioHandler
//Passing parameter:    none
//Return parameter:     none
//Description:
//  [Doxygen]
///
//******************************************************************************
void msAPI_AUD_AudioHandler(void)
{
	MDrv_AudioHandler();
}


//******************************************************************************
//Function name:    msAPI_AUD_SetSubwooferCutFreq
//Passing parameter:    Cut Off Freq
//Return parameter:     none
//Description:      Set Subwoofer cut off frequency
//  [Doxygen]
/// Set Subwoofer cut off frequency
/// @param cutOff_freq \b IN Cut Off Freq
//******************************************************************************
void msAPI_AUD_SetSubwooferCutFreq( U16 cutOff_freq )
{
    U8 cutOff_mode;

    AUD_DEBUG(printf("apiAud>> cutOff_freq = %u\n", cutOff_freq));

    cutOff_mode = (cutOff_freq - 50) / 50;

    if ( (cutOff_mode < 0) || (cutOff_mode > 15) )
    {
        cutOff_mode = 1;
    }

    MDrv_AuProcessSetSubwooferCutFreq(cutOff_mode);
}

//******************************************************************************
//Function name:    msAPI_AUD_SetAutoVolume
//Passing parameter:
//Return parameter:     none
//Description:      enable/disable AVC
//  [Doxygen]
/// enable/disable AVC
/// @param enAVC \b IN 1: enable , 0: disable
//******************************************************************************
void msAPI_AUD_SetAutoVolume( U8 enAVC )
{
    MDrv_AuProcessSetAutoVolume( enAVC );
}

//******************************************************************************
//Function name:    msAPI_AUD_SetVolume
//Passing parameter:    U8 Volume: Audio Volume
//Return parameter:     none
//Description:          0 ~ 100
//  [Doxygen]
/// Set Audio Volume
/// @param u8Volume \b IN Volume 0 ~ 100
//******************************************************************************
code U16 VolumeTab[]=
{
/*		// saturn1
0x3FF,0x1FF,0x1F3,0x1E0,0x1C4,0x1AE,0x199,0x187,0x16E,0x152,    // 0~9
0x145,0x139,0x12E,0x12A,0x11E,0x11A,0x113,0x10E,0x108,0x101,    // 10~19
0x0FE,0x0F8,0x0F3,0x0F0,0x0ED,0x0EA,0x0E7,0x0E4,0x0E1,0x0DD,    // 20~29
0x0DA,0x0D8,0x0D6,0x0D4,0x0D2,0x0D0,0x0CE,0x0CC,0x0CA,0x0C8,    // 30~39
0x0C6,0x0C4,0x0C2,0x0C0,0x0BE,0x0BC,0x0BA,0x0B8,0x0B6,0x0B4,   // 40~49
0x0B2,0x0B0,0x0AE,0x0AC,0x0AA,0x0A8,0x0A6,0x0A4,0x0A2,0x0A0,    // 50~59
0x09E,0x09C,0x09A,0x098,0x096,0x094,0x092,0x090,0x08E,0x08C,    // 60~69
0x08A,0x088,0x086,0x084,0x082,0x080,0x07E,0x07C,0x07A,0x078,    // 70~79
0x076,0x074,0x072,0x070,0x06E,0x06C,0x06A,0x068,0x066,0x064,    // 80~89
0x062,0x060,0x05E,0x05C,0x05A,0x058,0x056,0x054,0x052,0x050,0x04E    // 90~100
*/
// for 8зspeaker  2007.04.06
0x3FF,0x232,0x221,0x217,0x209,0x1D4,0x1A3,0x181,0x177,0x163,          //0~9
0x154,0x149,0x13F,0x138,0x131,0x12B,0x123,0x11D,0x118,0x113,          //10~19
0x10F,0x109,0x104,0x100,0x0FC,0x0F9,0x0F5,0x0F2,0x0EF,0x0EC,          //20~29
0x0E9,0x0E7,0x0E5,0x0E4,0x0E2,0x0E0,0x0DF,0x0DD,0x0DB,0x0DA,          //30~39
0x0D8,0x0D6,0x0D5,0x0D3,0x0D1,0x0D0,0x0CE,0x0CC,0x0CB,0x0C9,          //40~49
0x0C7,0x0C6,0x0C4,0x0C2,0x0C1,0x0BF,0x0BD,0x0BC,0x0BA,0x0B8,          //50~59
0x0B6,0x0B4,0x0B2,0x0B0,0x0AE,0x0AC,0x0AA,0x0A8,0x0A6,0x0A4,          //60~69
0x0A2,0x0A0,0x09E,0x09C,0x09A,0x098,0x096,0x094,0x092,0x090,          //70~79
0x08E,0x08C,0x08A,0x088,0x086,0x084,0x082,0x080,0x07E,0x07C,          //80~89
0x07A,0x078,0x076,0x074,0x072,0x070,0x06E,0x06C,0x06A,0x068,0x066 //90~100

};

void msAPI_AUD_SetVolume ( U8 u8Volume )
{
    U16 ActuallyValue;

    if( u8Volume < 0 || u8Volume > 100)
    {
        AUD_DEBUG(printf("Volume Min Max Error"));
        return;
    }

	ActuallyValue = VolumeTab[u8Volume];

    AUD_DEBUG(printf("apiAud>> Vol = %d Vol1= %bu Vol2 = %bu \r\n", (U16)ActuallyValue, (U8)((ActuallyValue&0x3F8)>>3) ,(U8)((ActuallyValue&0x0007)) ));

    MDrv_AuProcessAbsoluteVolume(AUDIO_PATH_0, (U8)((ActuallyValue&0x3F8)>>3), (U8)((ActuallyValue&0x0007)));

    AUD_DEBUG(printf("apiAud>> Vol = %bu\n", u8Volume));
//    MDrv_AuProcessSetVolume( AUDIO_PATH_0, u8Volume );
}

//******************************************************************************
//Function name:    msAPI_AUD_SetVolumeMap
//Passing parameter:    U8 u8MapNo:
//Return parameter:     none
//Description:
//  [Doxygen]
/// Set Audio Volume
/// @param u8MapNo \b IN
//******************************************************************************
void msAPI_AUD_SetVolumeMap ( U8 u8MapNo )
{
    AUD_DEBUG(printf("msAPI_AUD_SetVolumeMap>> map no. = %bu\n", u8MapNo));

    switch ( u8MapNo )
    {
        case 1:
            MDrv_AuProcessSetVolumeMap(0x7F, 0x4F, 0x28, 0x18, 0x0C);
            return;

        case 2:
            MDrv_AuProcessSetVolumeMap(0x7F, 0x54, 0x2D, 0x1D, 0x11);
            return;

        default:
            return;
    }
}

//******************************************************************************
//Function name:    msAPI_AUD_AbsoluteVolume
//Passing parameter:
//Return parameter:     none
//Description:
//  [Doxygen]
/// Set Absolute Volume
/// @param u8Vol1 \b IN: range from 0x00 to 0x7E , gain: +12db to   -114db (-1 db per step)
/// @param u8Vol2 \b IN: range from 0x00 to 0x07 , gain:  -0db to -0.875db (-0.125 db per step)
//******************************************************************************
void msAPI_AUD_AbsoluteVolume ( U8 u8Vol1, U8 u8Vol2 )
{
    AUD_DEBUG(printf("apiAud>> AbsoluteVolume: Vol1 = %bu, Vol2 = %bu\n", u8Vol1, u8Vol2));
    MDrv_AuProcessAbsoluteVolume(AUDIO_PATH_0, u8Vol1, u8Vol2);
}

//******************************************************************************
//Function name:    msAPI_AUD_SetPreScale
//Passing parameter:
//Return parameter:     none
//Description:
//  [Doxygen]
/// Set the pre-scale
/// @param u8Path \b IN: select channel
/// @param u8PreScale \b IN: range from 0x01 to 0x7F , gain: -3.294db to +14db (0.13725 db per step)
///                            0x00: disable pre-scale
///                            0x19: gain = 0db
///                            0x7F: gain = +14db
//******************************************************************************
void msAPI_AUD_SetPreScale ( U8 u8Path, U8 u8PreScale )
{
    AUD_DEBUG(printf("apiAud>> pre-scale: Path = %bu, PreScale = %bu\n", u8Path, u8PreScale));
    MDrv_AuProcessSetPreScale(u8Path, u8PreScale);
}


//******************************************************************************
//Function name:    msAPI_AUD_DisableChannel
//Passing parameter:
//Return parameter:     none
//Description:
//  [Doxygen]
/// Disable channel
/// @param u8Path \b IN: select channel
/// @param u8Disable \b IN: 1: disable channel, 0: enable channel
//******************************************************************************
void msAPI_AUD_DisableChannel( U8 u8Path, U8 u8Disable )
{
	AUD_DEBUG(printf("apiAud>> pre-scale: Path = %bu, Disable = %bu\n", u8Path, u8Disable));
	MDrv_AuProcessDisableChannel(u8Path, u8Disable);
}

//******************************************************************************
//Function name:    msAPI_AUD_SetBalance
//Passing parameter:    U8 u8Balance: audio balance (bit[0-4] = data, bit5 = L/R)
//Return parameter:     none
//Description:      Set audio balance. 0 ~ 100
//  [Doxygen]
/// Set audio balance. 0 ~ 100
/// @param u8Balance \b IN audio balance (bit[0-4] = data, bit5 = L/R)
//******************************************************************************
void msAPI_AUD_SetBalance ( U8 u8Balance )
{
    AUD_DEBUG(printf("apiAud>> Balance = %bu\n", u8Balance));
    MDrv_AuProcessSetBalance(AUDIO_PATH_0, u8Balance);
}

//******************************************************************************
//Function name:    msAPI_AUD_SetBass
//Passing parameter:    U8 u8Bass: audio bass(bit0 - bit5)
//Return parameter:     none
//Description:      Set audio bass. 0 ~ 100
//  [Doxygen]
/// Set audio bass. 0 ~ 100
/// @param u8Bass \b IN audio bass(bit0 - bit5)
//******************************************************************************
void msAPI_AUD_SetBass ( U8 u8Bass )
{
    AUD_DEBUG(printf("apiAud>> Bass = %bu\n", u8Bass));
    MDrv_AuProcessSetBass(AUDIO_PATH_0, u8Bass);
}

//******************************************************************************
//Function name:    msAPI_AUD_SetTreble
//Passing parameter:    U8 u8Treble: audio treble (bit0 - bit5)
//Return parameter:     none
//Description:      Set audio treble. 0 ~ 100
//  [Doxygen]
/// Set audio treble. 0 ~ 100
/// @param u8Treble \b IN audio treble (bit0 - bit5)
//******************************************************************************
void msAPI_AUD_SetTreble ( U8 u8Treble )
{