chips.c

ct952 source code use for Digital Frame Photo

            HAL_WriteAM(HAL_AM_SURR_EN, 0);
        }

        // TCC274, move to a function to set variable
        _SetDualMode();

        HAL_WriteAM(HAL_AM_CHANNEL_MODE, _bChannelMode); //_bChannelMode

        HAL_WriteAM(HAL_AM_LFE_OUTPUT, _bLFE); //_bLFE

        HAL_WriteAM(HAL_AM_AC3_KOK_MODE, __bVocal); //__bVocal
        HAL_WriteAM(HAL_AM_DUAL_MODE, _bDualMode); //_bDualMode

        if(_bSpDifMode != 2)
        {
            HAL_WriteAM(HAL_AM_SPDIF_MODE, (_bSpDifMode&0x01)); //0:pcm 1:raw
        }
        else
        {   // Joey2.51: if _bSpDifMode == 2 (spdif off), switch to spdif raw, because spdif PCM not supported by DTS
            HAL_WriteAM(HAL_AM_SPDIF_MODE, 1);  // spdif raw (avoid DTS hang)
        }

        HAL_WriteAM(HAL_AM_PCM_SCALE, __dwVolAudio); //16 bits
        __dwPreVolAudio = __dwVolAudio;

        // Joey2.75: Add AC3 downmix scale control. The scale value can be 0~15.
        HAL_WriteAM(HAL_AM_AC3_DOWN_MIX_SCALE, 15);

        //Kevin1.26, SPDIF enable -> fade in
        //Kevin1.10, Control Analog Output on/off
        CHIPS_ControlAnalogOutput();

        // LLY.103-1, replace with function API
        CHIPS_ControlSPDIFOutput();

        // Brian.173, enable the MIC input after mute
        CHIPS_MICEnable(TRUE);
    }

    return TRUE;
}

//  *********************************************************************
//  Function    :  CHIPS_MICEnable
//  Description :  Enable/Disable MIC Input.
//  Arguments   :  bEnable : enable or disable MIC input
//              :  TRUE: enable
//              :  FASLE: disable
//  Return      :  none.
//  Change      :
//  Side Effect :
//  *********************************************************************
// Brian.173
// LLY.273-1, must add "NOAGRES" pragma
// because CHIPS_MICEnable() --> CHIPS_OpenAudio() --> ISR
//#pragma NOAREGS         // may be called in ISR
void CHIPS_MICEnable(BYTE bEnable)
{
#ifdef NO_MIC_INPUT
    //kevin0.66, fix pause->normal play => noise (HW bug: Proc1 access AIU => unpack error)
	HAL_WriteAM(HAL_AM_MIC_PCM_SCALE, 0);
#else //#ifdef NO_MIC_INPUT
    if(bEnable)
    {
        //kevin0.66, fix pause->normal play => noise (HW bug: Proc1 access AIU => unpack error)
        HAL_WriteAM(HAL_AM_MIC_PCM_SCALE, __wMICVol);
    }
    else
    {
        //kevin0.66, fix pause->normal play => noise (HW bug: Proc1 access AIU => unpack error)
        HAL_WriteAM(HAL_AM_MIC_PCM_SCALE, 0);
    }
#endif //#ifdef NO_MIC_INPUT
}

//  *********************************************************************
//  Function    :  CHIPS_SoftMute
//  Description :  Do soft mute.
//  Arguments   :  none.
//  Return      :  none.
//  Change      :
//  Side Effect :
//  *********************************************************************
// LLY.273, remodify the procedure
// LLY.273-1, must add "NOAGRES" pragma
// because CHIPS_SoftMute() --> CHIPS_OpenAudio() --> ISR
//#pragma NOAREGS         // may be called in ISR
void CHIPS_SoftMute(void)
{
    DWORD dwTimerCount_FadeOut; //kevin1.07
    DWORD dwTemp;

    HAL_ReadAM(HAL_AM_REAL_PCM_SCALE, &dwTemp);

    if(dwTemp == 0)
    {
        HAL_WriteAM(HAL_AM_PCM_SCALE, 0);
        return;
    }

    HAL_WriteAM(HAL_AM_PCM_SCALE, 0);

    //kevin1.07, wait for fade out to be done
    dwTimerCount_FadeOut = OS_GetSysTimer();

    while((OS_GetSysTimer()-dwTimerCount_FadeOut) < COUNT_250_MSEC) //kevin1.11, 50M->250M
    {
        //kevin1.11, fix fade out may not be completed
        HAL_ReadAM(HAL_AM_REAL_PCM_SCALE, &dwTemp);

        if(dwTemp == 0)
        {
            OS_DelayTime(COUNT_50_MSEC);
            // LLY2.61, porting Chuan's code to pass Dolby Certification -- mute is 0dB
#if defined(CT909P_IC_SYSTEM) || defined(CT909G_IC_SYSTEM)
            REG_PLAT_RESET_CONTROL_ENABLE = PLAT_RESET_AIU_DAC_ENABLE;
            REG_PLAT_RESET_CONTROL_DISABLE = PLAT_RESET_AIU_DAC_DISABLE;
#endif // #if defined(CT909P_IC_SYSTEM) || defined(CT909G_IC_SYSTEM)
            break;
        }

        OS_YieldThread();
    }

    /*
    if(dwTemp != 0)
    {
        DBG_Printf(DBG_THREAD_PARSER, DBG_INFO_PRINTF, "PCM sca=%lx\n", dwTemp);
    }
    */
}

// Brian.170
//  *********************************************************************
//  Function    :   CHIPS_SWMICDetect()
//  Description :   It read the MIC input and compare it with threshlod,
//                  and determine the __sbMICDetect value
//  Arguments   :   None
//  Return      :   None
//  Side Effect :
//  *********************************************************************
void CHIPS_MICDetect(void)
{
}

// J500KWShih_231, mpeg error concealment
//  *********************************************************************
//  Function    :   CHIPS_ControlMPEGEErrorConcealment()
//  Description :   It read the MIC input and compare it with threshlod,
//                  and determine the __sbMICDetect value
//  Arguments   :   None
//  Return      :   None
//  Side Effect :
//  *********************************************************************
void CHIPS_ControlMPEGEErrorConcealment(BYTE bEnable)
{
    HAL_WriteAM(HAL_AM_WMA_MPEG_ERROR_CONCEALMENT_MASK, bEnable);
}

#ifdef DOLBY_CERTIFICATION //kevin0.80
BYTE CHIPS_Dolby_ProcessKey(void)
{
    if (__bKey==KEY_N1)
    {
            static BYTE    _bCenterDelay=0; //bit[2:0]: 0~5

            switch (_bCenterDelay)
            {
            case 0:
                strcpy(__bMsgString, "c delay0");
                break;
            case 1:
                strcpy(__bMsgString, "c delay1");
                break;
            case 2:
                strcpy(__bMsgString, "c delay2");
                break;
            case 3:
                strcpy(__bMsgString, "c delay3");
                break;
            case 4:
                strcpy(__bMsgString, "c delay4");
                break;
            case 5:
                strcpy(__bMsgString, "c delay5");
                break;
            }

            OSD_Output(MSG_STRING, 0, 0x3);

            HAL_WriteAM( HAL_AM_CENTER_DELAY, _bCenterDelay);

            _bCenterDelay++;
            if (_bCenterDelay>5)
                _bCenterDelay = 0;

            return KEY_NO_KEY;
    }

    else if (__bKey==KEY_N2)
    {
        static BYTE    _bSurrDelay=0; //bit[7:3]: 0~31

        switch (_bSurrDelay)
        {
        case 0:
            strcpy(__bMsgString, "s delay0");
            break;
        case 1:
            strcpy(__bMsgString, "s delay1");
            break;
        case 2:
            strcpy(__bMsgString, "s delay2");
            break;
        case 3:
            strcpy(__bMsgString, "s delay3");
            break;
        case 4:
            strcpy(__bMsgString, "s delay4");
            break;
        case 5:
            strcpy(__bMsgString, "s delay5");
            break;
        case 6:
            strcpy(__bMsgString, "s delay6");
            break;
        case 7:
            strcpy(__bMsgString, "s delay7");
            break;
        case 8:
            strcpy(__bMsgString, "s delay8");
            break;
        case 9:
            strcpy(__bMsgString, "s delay9");
            break;
        case 10:
            strcpy(__bMsgString, "s delay10");
            break;
        case 11:
            strcpy(__bMsgString, "s delay11");
            break;
        case 12:
            strcpy(__bMsgString, "s delay12");
            break;
        case 13:
            strcpy(__bMsgString, "s delay13");
            break;
        case 14:
            strcpy(__bMsgString, "s delay14");
            break;
        case 15:
            strcpy(__bMsgString, "s delay15");
            break;
        }

        OSD_Output(MSG_STRING, 0, 0x3);

        HAL_WriteAM( HAL_AM_SURROUND_DELAY, _bSurrDelay);

        _bSurrDelay++;
        if (_bSurrDelay>15)
            _bSurrDelay = 0;

        return KEY_NO_KEY;
    }
    else if (__bKey == KEY_N3)
    {
        static BYTE    bDownMixMode=0; //0~2

        extern BYTE    _bChannelMode ;
        extern char    _bLFE ;

        switch (bDownMixMode)
        {
        case 0:
            _bChannelMode=CHIPS_LCRLSRS;
            _bLFE=1;
            strcpy(__bMsgString, "5.1 ch");
            break;
        case 1:
            _bChannelMode=CHIPS_LRD;
            _bLFE=0;
            CHIPS_DownMixMode(AC3_DOWNMIX_LTRT);
            strcpy(__bMsgString, "2ch LtRt");
            break;
        case 2:
            _bChannelMode=CHIPS_LR;
            _bLFE=0;
            CHIPS_DownMixMode(AC3_DOWNMIX_LORO);
            strcpy(__bMsgString, "2ch LoRo");
            break;
        case 3:
            _bChannelMode=CHIPS_LR;
            _bLFE=0;
            CHIPS_DownMixMode(AC3_DOWNMIX_AUTO);
            strcpy(__bMsgString, "2ch Auto");
            break;
        }
        CHIPS_OpenAudio(TRUE);
        OSD_Output(MSG_STRING, 0, 0x5);
        bDownMixMode++;
        if (bDownMixMode>3)
            bDownMixMode = 0;

        return KEY_NO_KEY;
    }
    else if (__bKey == KEY_N4)
    {
        static BYTE    bACMOD=0;    //0~6

        extern BYTE    _bChannelMode ;
        extern char    _bLFE ;

        //CHIPS_Initial (CHIPS_INIT_CHANNELMODE) ;

        switch(bACMOD)
        {
        case 0:
            _bChannelMode=CHIPS_C;
            _bLFE=0;
            strcpy(__bMsgString, "acmod1_0");
            break;
        case 1:
            _bChannelMode=CHIPS_LR;
            _bLFE=0;
            strcpy(__bMsgString, "acmod2_0");
            break;
        case 2:
            _bChannelMode=CHIPS_LRLS;
            _bLFE=0;
            strcpy(__bMsgString, "acmod2_1");
            break;
        case 3:
            _bChannelMode=CHIPS_LRLSRS;
            _bLFE=0;
            strcpy(__bMsgString, "acmod2_2");
            break;
        case 4:
            _bChannelMode=CHIPS_LCR;
            _bLFE=0;
            strcpy(__bMsgString, "acmod3_0");
            break;
        case 5:
            _bChannelMode=CHIPS_LCRLS;
            _bLFE=0;
            strcpy(__bMsgString, "acmod3_1");
            break;
        case 6:
            _bChannelMode=CHIPS_LCRLSRS;
            _bLFE=1;
            strcpy(__bMsgString, "acmod3_2");
            break;
        }
        CHIPS_OpenAudio(TRUE);
        OSD_Output(MSG_STRING, 0, 0x5);
        bACMOD++;
        if (bACMOD>6)
            bACMOD = 0;

        return KEY_NO_KEY;
    }
    else if (__bKey == KEY_N5)
    {
        static BYTE    bBassMode=0;    //0~3

        switch (bBassMode)
        {
        case 0:
            strcpy(__bMsgString, "no bass");
            break;
        case 1:
            strcpy(__bMsgString, "conf 1");
            break;
        case 2:
            strcpy(__bMsgString, "conf 3+sub");
            break;
        case 3:
            strcpy(__bMsgString, "conf3 no sub");
            break;
        }
        HAL_WriteAM(HAL_AM_BASS_MANAGE_CONFIG, bBassMode);
        OSD_Output(MSG_STRING, 0, 0x5);

        bBassMode++;
        if (bBassMode>3)
            bBassMode = 0;

        return KEY_NO_KEY;
    }
    //kevin1.05, center/surr delay waveform inverse: add test key before doing/leaving delay testing
    else if (__bKey == KEY_N6)
    {
    	strcpy(__bMsgString, "test delay");
        HAL_WriteAM(HAL_AM_TEST_CENTERSURR_DELAY, 1);
        OSD_Output(MSG_STRING, 0, 0x5);

        return KEY_NO_KEY;
    }
    else if (__bKey == KEY_N7)
    {
    	strcpy(__bMsgString, "not test delay");
        HAL_WriteAM(HAL_AM_TEST_CENTERSURR_DELAY, 0);
        OSD_Output(MSG_STRING, 0, 0x5);

        return KEY_NO_KEY;
    }

    return KEY_BYPASS;
}
#endif