/****************************************************************************** *_Copyright (c) 2009 Digital Stream Technology Inc. All Rights Reserved. * * Module: dsthalaud.c * * Description * This file includes following Audio Processing functions; * - Audio Output Control (Mute/Fade in-out) * - Volume Control * - Basic Audio Processing (Bass/Treble/Balance) * - Advanced Audio Processing (AVL/SRS/MaxxBass/BBE) * - Audio Output Delay * * Notes * Audio decoders, AC3 and MPEG, are included in DTV block. * * * @author Junku Park (hwatk@dstreamtech.com) * @version $Revision: 1.1 $ * ******************************************************************************/ #include #include #include "dsthalcommon.h" #include "dsthallocal.h" #include "dstdddtv.h" #include "dstddaud.h" #include "dstddsys.h" /****************************************************************************** * Global variable declaration ******************************************************************************/ DHL_AUDIO_CONFIG g_AudConfig = {0}; int gAUDDbgLvl = 1; /****************************************************************************** * Imported variable declaration ******************************************************************************/ /****************************************************************************** * Imported function declaration ******************************************************************************/ /****************************************************************************** * Local definitions ******************************************************************************/ #define LOCK_AUD_MUTEX() do { \ if ( OS_TakeMutex(g_AudConfig.Mutex) != OS_OK ) { \ DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"MUTEX ERROR, LINE=%d\n", __LINE__); \ goto done; \ } \ } while (0) #define UNLOCK_AUD_MUTEX() do { \ if ( OS_GiveMutex(g_AudConfig.Mutex) != OS_OK ) { \ DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"MUTEX ERROR, LINE=%d\n", __LINE__); \ } \ } while (0) #define AUDIOMUTE_TASK_PRIORITY 90 #define AUDIOMUTE_TASK_STACKSIZE 16384 #define MAX_AM_MESSAGES 120 /****************************************************************************** * Local typedefs ******************************************************************************/ /****************************************************************************** * Local variables declaration ******************************************************************************/ static OS_MESSAGEQUEUE_ID AudioMuteQ; static OS_TASK_ID AudioMuteTaskId; static int tAudioMuteStarted = 0; /****************************************************************************** * Local function prototypes ******************************************************************************/ static int AudioMuteReq(DD_AUDIOMUTE AudioMuteAttr, int Arg); static DHL_RESULT AudioMuteInit(void); static DHL_RESULT AudioMuteStart(void); static DHL_RESULT AudioMuteStop(void); #if 0 ___COMMON_APIs___() #endif DHL_RESULT DHL_AUD_Init(void) { DHL_RESULT dhlResult = DHL_OK; g_AudConfig.Treble = 50; g_AudConfig.Bass = 50; g_AudConfig.uVolLvl = 0; g_AudConfig.bCurSpdifMute = _FALSE_; g_AudConfig.bCurAuxMute = 0; g_AudConfig.AudOutFormat = DHL_STREAM_AUDOUT_AC3; g_AudConfig.Mutex = OS_CreateMutex( "AUD_Mutex" ); if ( g_AudConfig.Mutex == (OS_MUTEX_ID)NULL ) { DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD," |error|%d(0x%x)\r\n",__LINE__,dhlResult); dhlResult = DHL_FAIL_CORE_DRIVER; goto done; } dhlResult = DD_AUD_Init(); SysASSERT( dhlResult == DHL_OK ); g_AudConfig.bAudioHWInit = _TRUE_; done: return dhlResult; } DHL_RESULT DHL_AUD_Close(void) { DHL_RESULT dhlResult = DHL_OK; dhlResult = AudioMuteStop(); SysASSERT( dhlResult == DHL_OK ); return dhlResult; } #if 0 ___VOLUME_APIs___() #endif /****************************************************************************** * DHL_AUD_SetVolumeHP * * @param [in] uVolLvl (0 ~ 100) * @return DHL_OK on success, otherwise DHL_FAIL ******************************************************************************/ DHL_RESULT DHL_AUD_SetVolumeHP(DS_U16 uVolLvl) { DHL_RESULT dhlResult = DHL_OK; if ( uVolLvl > 100 ) { DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"ERROR: Argument is invalid, uVolLvl=%d\n", (int)uVolLvl); return DHL_FAIL_INVALID_PARAM; } g_AudConfig.uHPVolLvl = uVolLvl; dhlResult = DD_AUD_SetVolumeHP(uVolLvl); if(DHL_ERROR(dhlResult)) DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|error|%d(0x%x)\r\n",__LINE__,dhlResult); if(!DHL_ERROR(dhlResult)) DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|success|\r\n"); return dhlResult; } /******************************************************************************** FUNCTION: DHL_AUD_SetVolume Purpose: set callback functions Arguments: [in] uVolLvl - limit 0-100 Returns: DHL_RESULT if success - DHL_OK fail - DHL_FAIL *********************************************************************************/ DHL_RESULT DHL_AUD_SetVolume(DS_U16 uVolLvl) { DHL_RESULT dhlResult = DHL_OK; if ( uVolLvl > 100 ) { DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"ERROR: Argument is invalid, uVolLvl=%d\n", (int)uVolLvl); return DHL_FAIL_INVALID_PARAM; } g_AudConfig.uVolLvl = uVolLvl; dhlResult = DD_AUD_SetVolumeAMP(uVolLvl); if(DHL_ERROR(dhlResult)) DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|error|%d(0x%x)\r\n",__LINE__,dhlResult); if(!DHL_ERROR(dhlResult)) DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|success|\r\n"); return dhlResult; } /******************************************************************************** FUNCTION: DD_AUDIO_GetVolume Purpose: Get I2SO(AM) audio output information Arguments: [OUT] puVolLvl - current am volume level [OUT] pbMute - _TRUE_ is audio mute enabled Returns: DHL_RESULT if success - DHL_OK fail - DHL_FAIL *********************************************************************************/ DHL_RESULT DHL_AUD_GetVolume(DS_U16 *puVolLvl, DS_BOOL *pbMute) { DHL_RESULT dhlResult = DHL_OK; if ( !puVolLvl || !pbMute ) { dhlResult = DHL_FAIL_NULL_POINTER; goto done; } *puVolLvl = g_AudConfig.uVolLvl; *pbMute = g_AudConfig.bCurI2SMute; done: if(DHL_ERROR(dhlResult)) DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|error|%d(0x%x)\r\n",__LINE__,dhlResult); if(!DHL_ERROR(dhlResult)) DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|success|\r\n"); return dhlResult; } /******************************************************************************** FUNCTION: DHL_AUD_SetBalance Purpose: Set LR balance of audio amp output Arguments: [in] Balance - -50~0~50 Returns: DHL_RESULT if success - DHL_OK fail - DHL_FAIL *********************************************************************************/ DHL_RESULT DHL_AUD_SetBalance(int Balance) { DHL_RESULT dhlResult = DHL_OK; if ( Balance < -50 || Balance > 50 ) { DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"ERROR: Argument is invalid, Balance=%d\n", Balance); return DHL_FAIL_INVALID_PARAM; } g_AudConfig.Balance = Balance; dhlResult = DD_AUD_SetBalance(Balance); if(DHL_ERROR(dhlResult)) DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|error|%d(0x%x)\r\n",__LINE__,dhlResult); if(!DHL_ERROR(dhlResult)) DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|success|\r\n"); return dhlResult; } /******************************************************************************** FUNCTION: DHL_AUD_GetBalance Purpose: Get LR balance of audio amp output Arguments: [in-out] *pBalance - -50~0~50 Returns: DHL_RESULT if success - DHL_OK fail - DHL_FAIL *********************************************************************************/ DHL_RESULT DHL_AUD_GetBalance(int *pBalance) { DHL_RESULT dhlResult = DHL_OK; if ( !pBalance ) return DHL_FAIL_NULL_POINTER; *pBalance = g_AudConfig.Balance; if(!DHL_ERROR(dhlResult)) DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|success|\r\n"); return dhlResult; } /******************************************************************************** FUNCTION: DHL_AUD_SetTreble Purpose: Audio Treble Control Arguments: [in] Treble : range 0~100 Returns: DHL_RESULT if success - DHL_OK fail - DHL_FAIL *********************************************************************************/ DHL_RESULT DHL_AUD_SetTreble(int Treble) { DHL_RESULT dhlResult = DHL_OK; if ( Treble < 0 || Treble > 100 ) { DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"ERROR: Argument is invalid, Treble=%d\n", Treble); return DHL_FAIL_INVALID_PARAM; } g_AudConfig.Treble = Treble; dhlResult = DD_AUD_SetTrebleBass(g_AudConfig.Treble, g_AudConfig.Bass); if(DHL_ERROR(dhlResult)) DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|error|%d(0x%x)\r\n",__LINE__,dhlResult); if(!DHL_ERROR(dhlResult)) DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|success|\r\n"); return dhlResult; } /******************************************************************************** FUNCTION: DHL_AUD_GetTreble Purpose: Audio Treble and Bass Volume Control Arguments: [i] Treble : range 0~100 Returns: DHL_RESULT if success - DHL_OK fail - DHL_FAIL *********************************************************************************/ DHL_RESULT DHL_AUD_GetTreble(int *pTreble) { DHL_RESULT dhlResult = DHL_OK; if ( !pTreble ) return DHL_FAIL_NULL_POINTER; *pTreble = g_AudConfig.Treble; if(!DHL_ERROR(dhlResult)) DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|success|\r\n"); return dhlResult; } /******************************************************************************** FUNCTION: DHL_AUD_SetBass Purpose: Audio Treble and Bass Volume Control Arguments: [i] Treble : range 0~100 Returns: DHL_RESULT if success - DHL_OK fail - DHL_FAIL *********************************************************************************/ DHL_RESULT DHL_AUD_SetBass(int Bass) { DHL_RESULT dhlResult = DHL_OK; if ( Bass < 0 || Bass > 100 ) { DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"ERROR: Argument is invalid, Bass=%d\n", Bass); return DHL_FAIL_INVALID_PARAM; } g_AudConfig.Bass = Bass; dhlResult = DD_AUD_SetTrebleBass(g_AudConfig.Treble, g_AudConfig.Bass); if(DHL_ERROR(dhlResult)) DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|error|%d(0x%x)\r\n",__LINE__,dhlResult); if(!DHL_ERROR(dhlResult)) DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|success|\r\n"); return dhlResult; } /******************************************************************************** FUNCTION: DHL_AUD_GetBass Purpose: Audio Treble and Bass Volume Control Arguments: [i] Treble : range 0~100 Returns: DHL_RESULT if success - DHL_OK fail - DHL_FAIL *********************************************************************************/ DHL_RESULT DHL_AUD_GetBass(int *pBass) { DHL_RESULT dhlResult = DHL_OK; if ( !pBass ) return DHL_FAIL_NULL_POINTER; *pBass = g_AudConfig.Bass; if(!DHL_ERROR(dhlResult)) DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|success|\r\n"); return dhlResult; } /******************************************************************************** FUNCTION: DHL_AUD_SetAVL Purpose: Set audio AVL (Automatic Volume Leveller) Arguments: [in] Mode - [0:Off 1:On] Returns: DHL_RESULT if success - DHL_OK fail - DHL_FAIL *********************************************************************************/ DHL_RESULT DHL_AUD_SetAVL(DS_BOOL Mode) { DHL_RESULT dhlResult = DHL_OK; dhlResult = DD_AUD_SetAVL(Mode); if(DHL_ERROR(dhlResult)) DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|error|%d(0x%x)\r\n",__LINE__,dhlResult); if(!DHL_ERROR(dhlResult)) DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|success|\r\n"); return dhlResult; } DHL_RESULT DHL_AUD_SetSRS(DS_BOOL Enable) { DHL_RESULT dhlResult = DHL_OK; dhlResult = DD_AUD_SetSRS(Enable); if(DHL_ERROR(dhlResult)) DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|error|%d(0x%x)\r\n",__LINE__,dhlResult); if(!DHL_ERROR(dhlResult)) DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|success|\r\n"); return dhlResult; } /******************************************************************************** FUNCTION: DHL_AUD_SetAudioDelay Purpose: Arguments: [IN] offset - offset (ms) range :0 ~ -120 ms [IN] bAddSub - _TRUE_ is Add, _FALSE_ is Suntract Returns: DHL_RESULT success - DHL_OK, fail - DHL_FAIL *********************************************************************************/ DHL_RESULT DHL_AUD_SetAudioDelay(DS_S32 offset) { DHL_RESULT dhlResult = DHL_OK; g_AudConfig.iAudioDelay = offset; if( ( offset < 0 ) || ( offset > 120 )){ DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"ERROR, LINE=%d\n",__LINE__); dhlResult = DHL_FAIL; goto done; } dhlResult = DD_AUD_SetAudioDelay(offset); if(!DHL_ERROR(dhlResult)) DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD," |success| offset (%d) \r\n",offset); done: return dhlResult; } /******************************************************************************** FUNCTION: DHL_AUD_AUDIO_MUTE Purpose: audio mixer mute (L/R) Arguments: [in] bMute - audio mute on (_TRUE_) or off (FALSE) Returns: DHL_RESULT if success - DHL_OK fail - DHL_FAIL *********************************************************************************/ DHL_RESULT DHL_AUD_MuteMain(DS_BOOL bMute) { DHL_RESULT dhlResult = DHL_OK; LOCK_AUD_MUTEX(); g_AudConfig.bCurI2SMute = bMute; dhlResult = DD_AUD_AudioMute(bMute); if(DHL_ERROR(dhlResult)) DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|error|%d(0x%x)\r\n",__LINE__,dhlResult); UNLOCK_AUD_MUTEX(); done: if(!DHL_ERROR(dhlResult)) DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|success| %s\r\n" ,(bMute==_TRUE_) ? "AMmuteOn":"AMmuteOff"); return dhlResult; } /******************************************************************************** FUNCTION: DHL_AUD_AudioMuteSPDIF Purpose: spdif mute (SPDIF) Arguments: [in] bMute - audio mute on (_TRUE_) or off (FALSE) Returns: DHL_RESULT if success - DHL_OK fail - DHL_FAIL *********************************************************************************/ DHL_RESULT DHL_AUD_MuteSPDIF(DS_BOOL bMute) { DHL_RESULT dhlResult = DHL_OK; if ( g_AudConfig.bCurSpdifMute == bMute ) return dhlResult; LOCK_AUD_MUTEX(); g_AudConfig.bCurSpdifMute = bMute; if ( AudioMuteReq( DD_AUDIOMUTE_SPDIF, bMute ) < 0 ) dhlResult = DHL_FAIL; UNLOCK_AUD_MUTEX(); done: if(!DHL_ERROR(dhlResult)) DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|success| %s\r\n",(bMute==_TRUE_) ? "SPDIFmuteOn":"SPDIFmuteOff"); return dhlResult; } DHL_RESULT DHL_AUD_MuteAUX(DS_BOOL bMute) { DHL_RESULT dhlResult = DHL_OK; if ( g_AudConfig.bCurAuxMute == bMute ) return dhlResult; LOCK_AUD_MUTEX(); g_AudConfig.bCurAuxMute = bMute; dhlResult = DD_AUD_AudioMuteAUX(bMute); if(DHL_ERROR(dhlResult)) DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|error|%d(0x%x)\r\n",__LINE__,dhlResult); UNLOCK_AUD_MUTEX(); done: if(!DHL_ERROR(dhlResult)) DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|success| %s\r\n",(bMute==_TRUE_) ? "AUXmuteOn":"AUXmuteOff"); return dhlResult; } DHL_RESULT DHL_AUD_VolumeFadeInOut_I2S(DS_BOOL bFadeOut) { DHL_RESULT dhlResult = DHL_OK; LOCK_AUD_MUTEX(); dhlResult = DD_AUD_VolumeFadeInOut_I2S(bFadeOut); UNLOCK_AUD_MUTEX(); done: return dhlResult; } DHL_RESULT DHL_AUD_VolumeFadeInOut_Amp(DS_BOOL bFadeOut) { DHL_RESULT dhlResult = DHL_OK; LOCK_AUD_MUTEX(); dhlResult = DD_AUD_VolumeFadeInOut_Amp(bFadeOut); UNLOCK_AUD_MUTEX(); done: return dhlResult; } DHL_RESULT DHL_AUD_SetHPCallback( HPCallbackSource eventSource, P_DHL_HP_CALLBACK fn, DS_U32 userArg ) { DHL_RESULT dhlResult = DHL_OK; P_DHL_HP pHPThread = &g_AudConfig.mHeadPhone; if ( (eventSource >= HPCALLBACK_MAX) || (eventSource <= HPCALLBACK_UNKNOWN) ) { DHL_DbgPrintf( 0, DHLDBG_AUD, "Error: Callback Event Source is invalid, %d\n", eventSource ); return DHL_FAIL; } if ( g_AudConfig.bAudioHWInit != _TRUE_ ) { DHL_DbgPrintf( 0, DHLDBG_AUD, "Error: please call this function after av_init, %d\n", eventSource ); goto done; } /* State Checking */ pHPThread->fnHPCallback[eventSource] = fn; pHPThread->HPCallbackUserArg[eventSource] = userArg; done: /* Give the MUTEX */ return dhlResult; } void DHL_HP_MonitorThread(DS_U32 arg) { #if 0 P_DHL_HP hpThread = &g_AudConfig.mHeadPhone; DHL_RESULT dhlResult = DHL_OK; static int Init_State = 0; while(1){ dhlResult = DD_AUD_IsHPAvail(); if (dhlResult != DHL_OK) { if (hpThread->NotifyState == HP_DETECT) { hpThread->NotifyState = HP_UNDETECT; if ( hpThread->fnHPCallback[HPCALLBACK_STATUS_CHANGE] ) (hpThread->fnHPCallback[HPCALLBACK_STATUS_CHANGE])(HP_UNDETECT, hpThread->HPCallbackUserArg[HPCALLBACK_STATUS_CHANGE]); } } else { if(hpThread->NotifyState == HP_UNDETECT) { // HP 가 사라지면 LR 출력이 나온다. // HP는 DON'T CARE hpThread->NotifyState = HP_DETECT; dhlResult = DD_AUD_AudioMuteHP(0); // unmute HP if(dhlResult != DHL_OK) DHL_DbgPrintf( 0, DHLDBG_AUD, "ERROR: Cannot unmute HP!\n"); if ( hpThread->fnHPCallback[HPCALLBACK_STATUS_CHANGE] ) (hpThread->fnHPCallback[HPCALLBACK_STATUS_CHANGE])(HP_DETECT, hpThread->HPCallbackUserArg[HPCALLBACK_STATUS_CHANGE]); } } if(Init_State == 0) { if ( hpThread->fnHPCallback[HPCALLBACK_STATUS_CHANGE] ) { (hpThread->fnHPCallback[HPCALLBACK_STATUS_CHANGE])(hpThread->NotifyState, hpThread->HPCallbackUserArg[HPCALLBACK_STATUS_CHANGE]); Init_State = 1; } } OS_mDelay(100); // 100ms 에 한번씩 변경 사항을 체크. } #endif } #if 0 static DHL_RESULT DHL_HP_DetectCallbackInit(void) { DHL_RESULT dhlResult = DHL_OK; P_DHL_HP hpThread = &g_AudConfig.mHeadPhone; int i = 0; for (i=0; i<(HPCALLBACK_MAX-1); i++) { hpThread->fnHPCallback[i] = (P_DHL_HP_CALLBACK)0; hpThread->HPCallbackUserArg[i] = 0; } hpThread->hpThreadId = OS_SpawnTask( DHL_HP_MonitorThread, "tHPMonitor", 60, 4096, (DS_U32)0); if ( hpThread->hpThreadId == 0 ) DHL_DbgPrintf( 0, DHLDBG_AUD, "ERROR: Cannot create HP thread!\n"); else DHL_DbgPrintf( gAUDDbgLvl, DHLDBG_FE, "HP Thread ID = 0x%lx\n", hpThread->hpThreadId ); return dhlResult; } #endif /******************************************************************************** FUNCTION: DHL_AUD_PresetAudProcessor (DHL_AUD_PROC_TYPE type) Purpose: Arguments: [in] type - audio processor type ( STA323W STA333W) Returns: DHL_RESULT if success - DHL_OK fail - DHL_FAIL Note Call this function before DHL_AUD_INIT, surely *********************************************************************************/ DHL_RESULT DHL_AUD_PresetAudProcessor(DHL_AUD_PROC_TYPE type) { DHL_RESULT dhlResult = DHL_OK; //dhlResult = DD_AUD_PresetAudProcessor(type); return dhlResult; } /******************************************************************************** FUNCTION: DHL_AUD_PresetAudioOut Purpose: Arguments: [in] pAudConfig - audio output user configuration Returns: DHL_RESULT if success - DHL_OK fail - DHL_FAIL Note Call this function before DHL_AUD_INIT, surely *********************************************************************************/ DHL_RESULT DHL_AUD_PresetAudOutput(P_DHL_AUDIO_CONFIG pAudConfig) { DHL_RESULT dhlResult = DHL_OK; memcpy( &g_AudConfig, pAudConfig, sizeof(DHL_AUDIO_CONFIG) ); return dhlResult; } /******************************************************************************** FUNCTION: DHL_AUD_ChangeAudOutFormat Purpose: Arguments: [in] UserAudOutFmt - auudio output foramt (pcm or ac3) Returns: DHL_RESULT if success - DHL_OK fail - DHL_FAIL *********************************************************************************/ DHL_RESULT DHL_AUD_ChangeAudOutFormat(DHL_AUD_OUTPUT_FORMAT UserAudOutFmt) { DHL_RESULT dhlResult = DHL_OK; if ( g_AudConfig.AudOutFormat == UserAudOutFmt ) { DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD," same skip: Cur=Req=%s\n", UserAudOutFmt == DHL_STREAM_AUDOUT_PCM ? "PCM" : "AC3" ); return dhlResult; } g_AudConfig.AudOutFormat = UserAudOutFmt; if ( g_AudConfig.bCurSpdifMute ){ // MUTE 상태일 경우 DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD," mute skip: Cur=Req=%s\n", UserAudOutFmt == DHL_STREAM_AUDOUT_PCM ? "PCM" : "AC3" ); return dhlResult; } LOCK_AUD_MUTEX(); if ( AudioMuteReq( DD_AUDIOMUTE_CHANGESPDIF, UserAudOutFmt ) < 0 ) dhlResult = DHL_FAIL; UNLOCK_AUD_MUTEX(); done: return dhlResult; } DHL_AUD_OUTPUT_FORMAT DHL_AUD_GetAudOutFormat(void) { return g_AudConfig.AudOutFormat; } DHL_RESULT DHL_AUD_SetAMPPower(int n) { return DD_AUD_SetAMPPower(n); } void DHL_AUD_PresetAudioOutput(int iAudOut) { DD_AUD_PresetAudioOutput(iAudOut); //HDMI_TX_PresetAudioInput(iAudOut); } DS_BOOL DHL_AUD_IsMainMuted(void) { return g_AudConfig.bCurI2SMute; } DS_BOOL DHL_AUD_IsSpdifMuted(void) { return g_AudConfig.bCurSpdifMute; } DS_BOOL DHL_AUD_IsAuxMuted(void) { return g_AudConfig.bCurAuxMute; } #if 0 ___INTERNAL_FUNCTIONS___() #endif static int AudioMuteReq(DD_AUDIOMUTE AudioMuteAttr, int Arg) { DS_U32 Msg[2]; AudioMuteInit(); Msg[0] = AudioMuteAttr; Msg[1] = Arg; if ( OS_SendMessage(AudioMuteQ, (DS_U32 *)Msg, sizeof(DS_U32) * 2) ) { DHL_DbgPrintf(0,DDDBG_AV,"Cannot send msg AudioMute Thread.\n"); DstCore_QueueReset(AudioMuteQ); return -1; } return 0; } static int tAudioMute(DS_U32 *arg) { DS_U32 msgLen; DS_U32 ret; static DS_U32 Msg[2]; while(1) { if ( tAudioMuteStarted == 0 ) { OS_mDelay(100); continue; } ret = OS_ReceiveMessage(AudioMuteQ, Msg, sizeof(DS_U32)*2, &msgLen); if ( ret ) { DHL_DbgPrintf(0,DDDBG_AV,"ERROR, LINE=%d\n", __LINE__); continue; } switch(Msg[0]) { case DD_AUDIOMUTE_SPDIF: DD_AUD_AudioMuteSPDIF( Msg[1] ); break; case DD_AUDIOMUTE_CHANGESPDIF: DD_AUD_ChangeAudOutFormat( Msg[1] ); break; case DD_AUDIOMUTE_MAIN: case DD_AUDIOMUTE_AUX: case DD_AUDIOMUTE_HP: case DD_AUDIOMUTE_AMP: default: break; } OS_mDelay(100); } } static DHL_RESULT AudioMuteInit(void) { DHL_RESULT dhlResult = DHL_OK; static int bAudioMuteInit = 0; if ( bAudioMuteInit == 1 ) return dhlResult; bAudioMuteInit = 1; AudioMuteQ = OS_CreateMessageQueue("q_AudioMute", 0, MAX_AM_MESSAGES, sizeof(DS_U32)*2); DHL_CHECK( AudioMuteQ != (DS_U32)NULL, dhlResult, DHL_FAIL_OUT_OF_RESOURCE ); AudioMuteTaskId = OS_SpawnTask((void (*) (DS_U32))tAudioMute,"tAudioMute",AUDIOMUTE_TASK_PRIORITY,AUDIOMUTE_TASK_STACKSIZE,0); DHL_CHECK( AudioMuteTaskId != (DS_U32)NULL, dhlResult, DHL_FAIL_OUT_OF_RESOURCE ); AudioMuteStart(); done: return dhlResult; } static DHL_RESULT AudioMuteStart(void) { DHL_RESULT dhlResult = DHL_OK; if ( tAudioMuteStarted == 1 ) return dhlResult; tAudioMuteStarted = 1; return dhlResult; } static DHL_RESULT AudioMuteStop(void) { DHL_RESULT dhlResult = DHL_OK; return dhlResult; } void hamute(void) { printf("HAL Mute Status\n"); printf("Main Audio: %s(%d)\n", g_AudConfig.bCurI2SMute ? "muteOn" : "muteOff", g_AudConfig.bCurI2SMute); printf("SPDIF Audio: %s(%d)\n", g_AudConfig.bCurSpdifMute ? "muteOn" : "muteOff", g_AudConfig.bCurSpdifMute); printf("AUX Audio: %s(%d)\n\n", g_AudConfig.bCurAuxMute ? "muteOn" : "muteOff", g_AudConfig.bCurAuxMute); }