source: svn/trunk/zas_dstar/hal/common/dsthalaud.c @ 2

Last change on this file since 2 was 2, checked in by phkim, 11 years ago

1.phkim

  1. revision copy newcon3sk r27
File size: 27.4 KB
Line 
1/******************************************************************************
2 *_Copyright (c) 2009 Digital Stream Technology Inc. All Rights Reserved.
3 *
4 * Module:      dsthalaud.c
5 *
6 * Description
7 *     This file includes following Audio Processing functions;
8 *         - Audio Output Control (Mute/Fade in-out)
9 *         - Volume Control
10 *         - Basic Audio Processing (Bass/Treble/Balance)
11 *         - Advanced Audio Processing (AVL/SRS/MaxxBass/BBE)
12 *         - Audio Output Delay
13 *
14 * Notes
15 *     Audio decoders, AC3 and MPEG, are included in DTV block.
16 *
17 *
18 * @author Junku Park (hwatk@dstreamtech.com)
19 * @version $Revision: 1.1 $
20 *
21 ******************************************************************************/
22
23#include <stdlib.h>
24#include <string.h>
25
26#include "dsthalcommon.h"
27#include "dsthallocal.h"
28#include "dstdddtv.h"
29#include "dstddaud.h"
30#include "dstddsys.h"
31
32/******************************************************************************
33 * Global variable declaration
34 ******************************************************************************/
35DHL_AUDIO_CONFIG g_AudConfig = {0};
36int gAUDDbgLvl = 1;
37
38/******************************************************************************
39 * Imported variable declaration
40 ******************************************************************************/
41
42/******************************************************************************
43 * Imported function declaration
44 ******************************************************************************/
45
46/******************************************************************************
47 * Local definitions
48 ******************************************************************************/
49#define LOCK_AUD_MUTEX()        do { \
50                if ( OS_TakeMutex(g_AudConfig.Mutex) != OS_OK ) { \
51                        DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"MUTEX ERROR, LINE=%d\n", __LINE__); \
52                        goto done; \
53                } \
54        } while (0)
55
56#define UNLOCK_AUD_MUTEX()      do { \
57                if ( OS_GiveMutex(g_AudConfig.Mutex) != OS_OK ) { \
58                        DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"MUTEX ERROR, LINE=%d\n", __LINE__); \
59                } \
60        } while (0)
61
62#define AUDIOMUTE_TASK_PRIORITY         90
63#define AUDIOMUTE_TASK_STACKSIZE                16384
64#define MAX_AM_MESSAGES             120
65
66/******************************************************************************
67 * Local typedefs
68 ******************************************************************************/
69
70/******************************************************************************
71 * Local variables declaration
72 ******************************************************************************/
73static OS_MESSAGEQUEUE_ID AudioMuteQ;
74static OS_TASK_ID AudioMuteTaskId;
75static int tAudioMuteStarted = 0;
76
77/******************************************************************************
78 * Local function prototypes
79 ******************************************************************************/
80static int AudioMuteReq(DD_AUDIOMUTE AudioMuteAttr, int Arg);
81static DHL_RESULT AudioMuteInit(void);
82static DHL_RESULT AudioMuteStart(void);
83static DHL_RESULT AudioMuteStop(void);
84
85#if 0
86___COMMON_APIs___()
87#endif
88DHL_RESULT DHL_AUD_Init(void)
89{
90    DHL_RESULT dhlResult = DHL_OK;
91   
92        g_AudConfig.Treble = 50;
93        g_AudConfig.Bass = 50;
94        g_AudConfig.uVolLvl = 0;
95
96        g_AudConfig.bCurSpdifMute = _FALSE_;
97        g_AudConfig.bCurAuxMute = 0;
98
99    g_AudConfig.AudOutFormat = DHL_STREAM_AUDOUT_AC3;
100       
101        g_AudConfig.Mutex = OS_CreateMutex( "AUD_Mutex" );
102        if ( g_AudConfig.Mutex == (OS_MUTEX_ID)NULL ) 
103        {
104                DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD," |error|%d(0x%x)\r\n",__LINE__,dhlResult);
105                dhlResult = DHL_FAIL_CORE_DRIVER;
106                goto done;
107        }
108   
109    dhlResult = DD_AUD_Init();
110    SysASSERT( dhlResult == DHL_OK );
111   
112    g_AudConfig.bAudioHWInit = _TRUE_;
113   
114done:
115    return dhlResult;
116}
117
118DHL_RESULT DHL_AUD_Close(void)
119{
120    DHL_RESULT dhlResult = DHL_OK;
121   
122    dhlResult = AudioMuteStop();
123    SysASSERT( dhlResult == DHL_OK );
124   
125    return dhlResult;
126}
127
128#if 0
129___VOLUME_APIs___()
130#endif
131/******************************************************************************
132 * DHL_AUD_SetVolumeHP                                                         
133 *
134 * @param [in] uVolLvl (0 ~ 100)
135 * @return DHL_OK on success, otherwise DHL_FAIL                               
136 ******************************************************************************/
137DHL_RESULT DHL_AUD_SetVolumeHP(DS_U16 uVolLvl)
138{
139    DHL_RESULT  dhlResult = DHL_OK;
140       
141        if ( uVolLvl > 100 ) 
142        {
143                DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"ERROR: Argument is invalid, uVolLvl=%d\n", (int)uVolLvl);
144                return DHL_FAIL_INVALID_PARAM;
145        }
146       
147        g_AudConfig.uHPVolLvl = uVolLvl;
148        dhlResult = DD_AUD_SetVolumeHP(uVolLvl);
149       
150        if(DHL_ERROR(dhlResult))
151                DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|error|%d(0x%x)\r\n",__LINE__,dhlResult);
152
153        if(!DHL_ERROR(dhlResult))
154                DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|success|\r\n");
155       
156        return dhlResult;       
157}
158
159/********************************************************************************
160FUNCTION:                                                                   
161    DHL_AUD_SetVolume
162
163Purpose:                                                                   
164        set callback functions                 
165
166Arguments:                                                                     
167        [in] uVolLvl - limit 0-100
168Returns:                                                                   
169    DHL_RESULT   if success - DHL_OK fail - DHL_FAIL                           
170*********************************************************************************/
171DHL_RESULT DHL_AUD_SetVolume(DS_U16 uVolLvl)
172{
173    DHL_RESULT  dhlResult = DHL_OK;
174       
175        if ( uVolLvl > 100 ) 
176        {
177                DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"ERROR: Argument is invalid, uVolLvl=%d\n", (int)uVolLvl);
178                return DHL_FAIL_INVALID_PARAM;
179        }
180       
181        g_AudConfig.uVolLvl = uVolLvl;
182        dhlResult = DD_AUD_SetVolumeAMP(uVolLvl);
183       
184        if(DHL_ERROR(dhlResult))
185                DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|error|%d(0x%x)\r\n",__LINE__,dhlResult);
186
187        if(!DHL_ERROR(dhlResult))
188                DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|success|\r\n");
189       
190        return dhlResult;       
191}
192
193/********************************************************************************
194FUNCTION:                                                                   
195    DD_AUDIO_GetVolume                                                         
196
197Purpose:                                                                   
198        Get I2SO(AM) audio output information
199Arguments:                                                                     
200        [OUT] puVolLvl  - current am volume level
201        [OUT] pbMute    - _TRUE_ is audio mute enabled
202Returns:                                                                   
203    DHL_RESULT   if success - DHL_OK fail - DHL_FAIL                           
204*********************************************************************************/
205DHL_RESULT DHL_AUD_GetVolume(DS_U16 *puVolLvl, DS_BOOL *pbMute)
206{
207    DHL_RESULT  dhlResult = DHL_OK;
208
209        if ( !puVolLvl || !pbMute ) 
210        {
211                dhlResult = DHL_FAIL_NULL_POINTER;
212                goto done;
213        }
214       
215        *puVolLvl = g_AudConfig.uVolLvl;
216        *pbMute = g_AudConfig.bCurI2SMute;
217       
218done:
219        if(DHL_ERROR(dhlResult))
220                DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|error|%d(0x%x)\r\n",__LINE__,dhlResult);
221
222        if(!DHL_ERROR(dhlResult))
223                DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|success|\r\n");
224       
225        return dhlResult;       
226}
227
228/********************************************************************************
229FUNCTION:                                                                   
230    DHL_AUD_SetBalance                                                         
231
232Purpose:                                                                   
233        Set LR balance of audio amp output
234
235Arguments:                                                                     
236        [in] Balance - -50~0~50
237Returns:                                                                   
238    DHL_RESULT   if success - DHL_OK fail - DHL_FAIL                           
239*********************************************************************************/
240DHL_RESULT DHL_AUD_SetBalance(int Balance)
241{
242    DHL_RESULT  dhlResult = DHL_OK;
243
244        if ( Balance < -50 || Balance > 50 ) 
245        {
246                DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"ERROR: Argument is invalid, Balance=%d\n", Balance);
247                return DHL_FAIL_INVALID_PARAM;
248        }
249       
250        g_AudConfig.Balance = Balance;
251       
252        dhlResult = DD_AUD_SetBalance(Balance);
253        if(DHL_ERROR(dhlResult))
254                DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|error|%d(0x%x)\r\n",__LINE__,dhlResult);
255
256        if(!DHL_ERROR(dhlResult))
257                DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|success|\r\n");   
258
259        return dhlResult;       
260}
261
262/********************************************************************************
263FUNCTION:                                                                   
264    DHL_AUD_GetBalance                                                         
265
266Purpose:                                                                   
267        Get LR balance of audio amp output
268
269Arguments:                                                                     
270        [in-out] *pBalance - -50~0~50
271Returns:                                                                   
272    DHL_RESULT   if success - DHL_OK fail - DHL_FAIL                           
273*********************************************************************************/
274DHL_RESULT DHL_AUD_GetBalance(int *pBalance)
275{
276    DHL_RESULT  dhlResult = DHL_OK;
277
278        if ( !pBalance )
279                return DHL_FAIL_NULL_POINTER;
280
281        *pBalance = g_AudConfig.Balance;
282       
283        if(!DHL_ERROR(dhlResult))
284                DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|success|\r\n");   
285       
286        return dhlResult;       
287}
288
289/********************************************************************************
290FUNCTION:                                                                   
291    DHL_AUD_SetTreble
292
293Purpose:                                                                   
294        Audio Treble Control
295Arguments:                   
296        [in] Treble     : range 0~100                                                   
297Returns:                                                                   
298    DHL_RESULT   if success - DHL_OK fail - DHL_FAIL     
299*********************************************************************************/
300DHL_RESULT DHL_AUD_SetTreble(int Treble)
301{
302        DHL_RESULT      dhlResult = DHL_OK;
303
304        if ( Treble < 0 || Treble > 100 ) 
305        {
306                DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"ERROR: Argument is invalid, Treble=%d\n", Treble);
307                return DHL_FAIL_INVALID_PARAM;
308        }
309
310        g_AudConfig.Treble = Treble;
311       
312        dhlResult = DD_AUD_SetTrebleBass(g_AudConfig.Treble, g_AudConfig.Bass);
313        if(DHL_ERROR(dhlResult))
314                DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|error|%d(0x%x)\r\n",__LINE__,dhlResult);
315
316        if(!DHL_ERROR(dhlResult))
317                DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|success|\r\n");
318       
319        return dhlResult;
320}
321
322/********************************************************************************
323FUNCTION:                                                                   
324    DHL_AUD_GetTreble
325
326Purpose:                                                                   
327        Audio Treble and Bass Volume Control
328Arguments:                   
329        [i] Treble      : range 0~100                                                   
330Returns:                                                                   
331    DHL_RESULT   if success - DHL_OK fail - DHL_FAIL     
332*********************************************************************************/
333DHL_RESULT DHL_AUD_GetTreble(int *pTreble)
334{
335        DHL_RESULT      dhlResult = DHL_OK;
336
337        if ( !pTreble )
338                return DHL_FAIL_NULL_POINTER;
339
340        *pTreble = g_AudConfig.Treble;
341       
342        if(!DHL_ERROR(dhlResult))
343                DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|success|\r\n");
344       
345        return dhlResult;
346}
347
348/********************************************************************************
349FUNCTION:                                                                   
350    DHL_AUD_SetBass
351
352Purpose:                                                                   
353        Audio Treble and Bass Volume Control
354Arguments:                   
355        [i] Treble      : range 0~100                                                   
356Returns:                                                                   
357    DHL_RESULT   if success - DHL_OK fail - DHL_FAIL     
358*********************************************************************************/
359DHL_RESULT DHL_AUD_SetBass(int Bass)
360{
361        DHL_RESULT      dhlResult = DHL_OK;
362       
363        if ( Bass < 0 || Bass > 100 ) 
364        {
365                DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"ERROR: Argument is invalid, Bass=%d\n", Bass);
366                return DHL_FAIL_INVALID_PARAM;
367        }
368       
369        g_AudConfig.Bass = Bass;
370       
371        dhlResult = DD_AUD_SetTrebleBass(g_AudConfig.Treble, g_AudConfig.Bass);
372        if(DHL_ERROR(dhlResult))
373                DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|error|%d(0x%x)\r\n",__LINE__,dhlResult);
374
375        if(!DHL_ERROR(dhlResult))
376                DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|success|\r\n");
377       
378        return dhlResult;
379}
380
381/********************************************************************************
382FUNCTION:                                                                   
383    DHL_AUD_GetBass
384
385Purpose:                                                                   
386        Audio Treble and Bass Volume Control
387Arguments:                   
388        [i] Treble      : range 0~100                                                   
389Returns:                                                                   
390    DHL_RESULT   if success - DHL_OK fail - DHL_FAIL     
391*********************************************************************************/
392DHL_RESULT DHL_AUD_GetBass(int *pBass)
393{
394        DHL_RESULT      dhlResult = DHL_OK;
395       
396        if ( !pBass )
397                return DHL_FAIL_NULL_POINTER;
398       
399        *pBass = g_AudConfig.Bass;
400
401        if(!DHL_ERROR(dhlResult))
402                DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|success|\r\n");
403       
404        return dhlResult;
405}
406
407/********************************************************************************
408FUNCTION:                                                                   
409    DHL_AUD_SetAVL                                                     
410
411Purpose:                                                                   
412        Set audio AVL (Automatic Volume Leveller)
413
414Arguments:                                                                     
415        [in] Mode - [0:Off 1:On]
416Returns:                                                                   
417    DHL_RESULT   if success - DHL_OK fail - DHL_FAIL                           
418*********************************************************************************/
419DHL_RESULT DHL_AUD_SetAVL(DS_BOOL Mode)
420{
421    DHL_RESULT  dhlResult = DHL_OK;
422
423        dhlResult = DD_AUD_SetAVL(Mode);
424        if(DHL_ERROR(dhlResult))
425                DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|error|%d(0x%x)\r\n",__LINE__,dhlResult);
426
427        if(!DHL_ERROR(dhlResult))
428                DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|success|\r\n");   
429        return dhlResult;       
430}
431
432DHL_RESULT DHL_AUD_SetSRS(DS_BOOL Enable)
433{
434    DHL_RESULT  dhlResult = DHL_OK;
435
436        dhlResult = DD_AUD_SetSRS(Enable);
437        if(DHL_ERROR(dhlResult))
438                DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|error|%d(0x%x)\r\n",__LINE__,dhlResult);
439
440        if(!DHL_ERROR(dhlResult))
441                DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|success|\r\n");   
442   
443        return dhlResult;       
444}
445
446/********************************************************************************
447FUNCTION:                                                                   
448    DHL_AUD_SetAudioDelay                                                               
449Purpose:                                                                   
450
451Arguments:                                                                     
452        [IN] offset - offset (ms) range :0 ~ -120 ms
453        [IN] bAddSub - _TRUE_ is Add, _FALSE_ is Suntract
454Returns:                                                                   
455    DHL_RESULT   success - DHL_OK, fail - DHL_FAIL       
456*********************************************************************************/
457DHL_RESULT DHL_AUD_SetAudioDelay(DS_S32 offset)
458{
459        DHL_RESULT      dhlResult = DHL_OK;
460
461        g_AudConfig.iAudioDelay = offset;
462       
463        if( ( offset < 0 ) || ( offset > 120 )){
464                DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"ERROR, LINE=%d\n",__LINE__);
465                dhlResult = DHL_FAIL;
466                goto done;
467        }
468        dhlResult = DD_AUD_SetAudioDelay(offset);
469       
470        if(!DHL_ERROR(dhlResult))
471                DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD," |success| offset (%d) \r\n",offset);     
472
473done:
474        return dhlResult;
475}
476
477/********************************************************************************
478FUNCTION:                                                                   
479    DHL_AUD_AUDIO_MUTE                                                         
480
481Purpose:                                                                   
482        audio mixer mute (L/R)
483Arguments:                                                                     
484        [in] bMute - audio mute on (_TRUE_) or off (FALSE)
485Returns:                                                                   
486    DHL_RESULT   if success - DHL_OK fail - DHL_FAIL                           
487*********************************************************************************/
488DHL_RESULT DHL_AUD_MuteMain(DS_BOOL bMute)
489{
490    DHL_RESULT  dhlResult = DHL_OK;
491
492        LOCK_AUD_MUTEX();
493
494        g_AudConfig.bCurI2SMute = bMute;
495
496        dhlResult = DD_AUD_AudioMute(bMute);
497        if(DHL_ERROR(dhlResult))
498                DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|error|%d(0x%x)\r\n",__LINE__,dhlResult);
499
500        UNLOCK_AUD_MUTEX();
501
502done:
503        if(!DHL_ERROR(dhlResult))
504                DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|success| %s\r\n" ,(bMute==_TRUE_) ? "AMmuteOn":"AMmuteOff");     
505        return dhlResult;       
506}
507
508
509/********************************************************************************
510FUNCTION:                                                                   
511    DHL_AUD_AudioMuteSPDIF                                                             
512
513Purpose:                                                                   
514        spdif mute (SPDIF)
515Arguments:                                                                     
516        [in] bMute - audio mute on (_TRUE_) or off (FALSE)
517Returns:                                                                   
518    DHL_RESULT   if success - DHL_OK fail - DHL_FAIL                           
519*********************************************************************************/
520DHL_RESULT DHL_AUD_MuteSPDIF(DS_BOOL bMute)
521{
522    DHL_RESULT  dhlResult = DHL_OK;
523
524        if ( g_AudConfig.bCurSpdifMute == bMute )
525                return dhlResult;
526       
527        LOCK_AUD_MUTEX();
528               
529        g_AudConfig.bCurSpdifMute = bMute;
530       
531        if ( AudioMuteReq( DD_AUDIOMUTE_SPDIF, bMute ) < 0 ) 
532                dhlResult = DHL_FAIL;
533       
534        UNLOCK_AUD_MUTEX();
535
536done:
537        if(!DHL_ERROR(dhlResult))
538                DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|success| %s\r\n",(bMute==_TRUE_) ? "SPDIFmuteOn":"SPDIFmuteOff"); 
539        return dhlResult;       
540}
541
542DHL_RESULT DHL_AUD_MuteAUX(DS_BOOL bMute)
543{
544        DHL_RESULT      dhlResult = DHL_OK;
545
546        if ( g_AudConfig.bCurAuxMute == bMute )
547                return dhlResult;
548       
549        LOCK_AUD_MUTEX();
550        g_AudConfig.bCurAuxMute = bMute;
551       
552        dhlResult = DD_AUD_AudioMuteAUX(bMute);
553        if(DHL_ERROR(dhlResult))
554                DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|error|%d(0x%x)\r\n",__LINE__,dhlResult);
555       
556        UNLOCK_AUD_MUTEX();
557
558done:
559        if(!DHL_ERROR(dhlResult))
560                DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"|success| %s\r\n",(bMute==_TRUE_) ? "AUXmuteOn":"AUXmuteOff");     
561        return dhlResult;       
562}
563
564DHL_RESULT DHL_AUD_VolumeFadeInOut_I2S(DS_BOOL bFadeOut)
565{
566        DHL_RESULT      dhlResult = DHL_OK;
567
568        LOCK_AUD_MUTEX();
569
570        dhlResult = DD_AUD_VolumeFadeInOut_I2S(bFadeOut);
571       
572        UNLOCK_AUD_MUTEX();
573
574done:
575        return dhlResult;
576}
577
578DHL_RESULT DHL_AUD_VolumeFadeInOut_Amp(DS_BOOL bFadeOut)
579{
580        DHL_RESULT      dhlResult = DHL_OK;
581
582        LOCK_AUD_MUTEX();
583
584        dhlResult = DD_AUD_VolumeFadeInOut_Amp(bFadeOut);
585       
586        UNLOCK_AUD_MUTEX();
587
588done:
589        return dhlResult;
590}
591
592DHL_RESULT DHL_AUD_SetHPCallback( HPCallbackSource eventSource, 
593                                                                        P_DHL_HP_CALLBACK fn, DS_U32 userArg )
594{
595        DHL_RESULT dhlResult = DHL_OK;
596        P_DHL_HP pHPThread = &g_AudConfig.mHeadPhone;
597       
598        if ( (eventSource >= HPCALLBACK_MAX) || (eventSource <= HPCALLBACK_UNKNOWN) ) {
599                DHL_DbgPrintf( 0, DHLDBG_AUD, "Error: Callback Event Source is invalid, %d\n", eventSource );
600                return DHL_FAIL;
601        }
602       
603        if ( g_AudConfig.bAudioHWInit != _TRUE_ )
604    {
605                DHL_DbgPrintf( 0, DHLDBG_AUD, "Error: please call this function after av_init, %d\n", eventSource );
606                goto done;
607        }
608        /* State Checking */
609       
610        pHPThread->fnHPCallback[eventSource] = fn;
611        pHPThread->HPCallbackUserArg[eventSource] = userArg;
612
613done:
614        /* Give the MUTEX */
615       
616       
617       
618        return dhlResult;
619}
620
621void DHL_HP_MonitorThread(DS_U32 arg)
622{
623#if 0
624        P_DHL_HP hpThread = &g_AudConfig.mHeadPhone;
625        DHL_RESULT dhlResult = DHL_OK;
626        static int Init_State = 0;
627        while(1){
628                dhlResult = DD_AUD_IsHPAvail();
629                if (dhlResult != DHL_OK)
630                {
631                        if (hpThread->NotifyState == HP_DETECT)
632                        {
633                                hpThread->NotifyState = HP_UNDETECT;
634
635                                if ( hpThread->fnHPCallback[HPCALLBACK_STATUS_CHANGE] )
636                                        (hpThread->fnHPCallback[HPCALLBACK_STATUS_CHANGE])(HP_UNDETECT, hpThread->HPCallbackUserArg[HPCALLBACK_STATUS_CHANGE]);
637                        }
638                }
639                else
640                {
641                        if(hpThread->NotifyState == HP_UNDETECT)
642                        {
643                                // HP °¡ »ç¶óÁö¸é LR Ãâ·ÂÀÌ ³ª¿Â´Ù.
644                                // HP´Â DON'T CARE
645                                hpThread->NotifyState = HP_DETECT;
646
647                                dhlResult = DD_AUD_AudioMuteHP(0);      // unmute HP                           
648                                if(dhlResult != DHL_OK)
649                                        DHL_DbgPrintf( 0, DHLDBG_AUD, "ERROR: Cannot unmute HP!\n");
650
651                                if ( hpThread->fnHPCallback[HPCALLBACK_STATUS_CHANGE] )
652                                        (hpThread->fnHPCallback[HPCALLBACK_STATUS_CHANGE])(HP_DETECT, hpThread->HPCallbackUserArg[HPCALLBACK_STATUS_CHANGE]);
653                        }
654                }
655               
656                if(Init_State == 0)
657                {
658            if ( hpThread->fnHPCallback[HPCALLBACK_STATUS_CHANGE] )
659            {
660                (hpThread->fnHPCallback[HPCALLBACK_STATUS_CHANGE])(hpThread->NotifyState, hpThread->HPCallbackUserArg[HPCALLBACK_STATUS_CHANGE]);
661                Init_State = 1;
662            }                   
663                }
664
665                OS_mDelay(100); // 100ms ¿¡ Çѹø¾¿ º¯°æ »çÇ×À» üũ.
666        }
667#endif
668}
669
670#if 0
671static DHL_RESULT DHL_HP_DetectCallbackInit(void)
672{
673        DHL_RESULT dhlResult = DHL_OK;
674        P_DHL_HP hpThread = &g_AudConfig.mHeadPhone;
675        int i = 0;
676
677        for (i=0; i<(HPCALLBACK_MAX-1); i++) {
678                hpThread->fnHPCallback[i] = (P_DHL_HP_CALLBACK)0;
679                hpThread->HPCallbackUserArg[i] = 0;
680        }               
681
682        hpThread->hpThreadId = OS_SpawnTask( DHL_HP_MonitorThread, "tHPMonitor", 60, 4096, (DS_U32)0);
683        if ( hpThread->hpThreadId == 0 )
684                DHL_DbgPrintf( 0, DHLDBG_AUD, "ERROR: Cannot create HP thread!\n");
685        else
686                DHL_DbgPrintf( gAUDDbgLvl, DHLDBG_FE, "HP Thread ID = 0x%lx\n", hpThread->hpThreadId );
687       
688        return dhlResult;
689}
690#endif
691
692
693/********************************************************************************
694FUNCTION:                                                                   
695    DHL_AUD_PresetAudProcessor (DHL_AUD_PROC_TYPE type)                                                         
696
697Purpose:                                                                   
698
699Arguments:                                                                     
700        [in] type - audio processor type ( STA323W STA333W)
701
702Returns:                                                                   
703    DHL_RESULT   if success - DHL_OK fail - DHL_FAIL     
704Note
705        Call this function before DHL_AUD_INIT, surely
706*********************************************************************************/
707DHL_RESULT DHL_AUD_PresetAudProcessor(DHL_AUD_PROC_TYPE type)
708{
709        DHL_RESULT      dhlResult       = DHL_OK;
710        //dhlResult = DD_AUD_PresetAudProcessor(type);
711        return dhlResult;
712}
713
714/********************************************************************************
715FUNCTION:                                                                   
716    DHL_AUD_PresetAudioOut                                                             
717
718Purpose:                                                                   
719
720Arguments:                                                                     
721        [in] pAudConfig - audio output user configuration
722
723Returns:                                                                   
724    DHL_RESULT   if success - DHL_OK fail - DHL_FAIL     
725Note
726        Call this function before DHL_AUD_INIT, surely
727*********************************************************************************/
728DHL_RESULT DHL_AUD_PresetAudOutput(P_DHL_AUDIO_CONFIG pAudConfig)
729{
730    DHL_RESULT                  dhlResult       = DHL_OK;
731
732        memcpy( &g_AudConfig, pAudConfig, sizeof(DHL_AUDIO_CONFIG) );
733       
734        return dhlResult;
735}
736
737/********************************************************************************
738FUNCTION:                                                                   
739    DHL_AUD_ChangeAudOutFormat                                                         
740
741Purpose:                                                                   
742
743Arguments:                                                                     
744        [in] UserAudOutFmt - auudio output foramt (pcm or ac3)
745Returns:                                                                   
746    DHL_RESULT   if success - DHL_OK fail - DHL_FAIL                           
747*********************************************************************************/
748DHL_RESULT DHL_AUD_ChangeAudOutFormat(DHL_AUD_OUTPUT_FORMAT UserAudOutFmt)
749{
750    DHL_RESULT  dhlResult       = DHL_OK;
751
752        if ( g_AudConfig.AudOutFormat == UserAudOutFmt ) {
753                DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD," same skip: Cur=Req=%s\n", UserAudOutFmt == DHL_STREAM_AUDOUT_PCM ? "PCM" : "AC3" );
754                return dhlResult;
755        }
756       
757        g_AudConfig.AudOutFormat = UserAudOutFmt;       
758       
759        if ( g_AudConfig.bCurSpdifMute ){ // MUTE »óÅÂÀÏ °æ¿ì
760                DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD," mute skip: Cur=Req=%s\n", UserAudOutFmt == DHL_STREAM_AUDOUT_PCM ? "PCM" : "AC3" );
761                return dhlResult;
762        }
763       
764        LOCK_AUD_MUTEX();
765
766        if ( AudioMuteReq( DD_AUDIOMUTE_CHANGESPDIF, UserAudOutFmt ) < 0 ) 
767                dhlResult = DHL_FAIL;
768       
769        UNLOCK_AUD_MUTEX();
770
771done:
772        return dhlResult;
773}
774
775DHL_AUD_OUTPUT_FORMAT DHL_AUD_GetAudOutFormat(void)
776{
777    return g_AudConfig.AudOutFormat;
778}
779
780DHL_RESULT DHL_AUD_SetAMPPower(int n)
781{
782        return DD_AUD_SetAMPPower(n);
783}
784
785void DHL_AUD_PresetAudioOutput(int iAudOut)
786{
787    DD_AUD_PresetAudioOutput(iAudOut);
788    //HDMI_TX_PresetAudioInput(iAudOut);
789}
790
791
792DS_BOOL DHL_AUD_IsMainMuted(void)
793{
794        return g_AudConfig.bCurI2SMute;
795}
796
797DS_BOOL DHL_AUD_IsSpdifMuted(void)
798{
799        return g_AudConfig.bCurSpdifMute;
800}
801
802DS_BOOL DHL_AUD_IsAuxMuted(void)
803{
804        return g_AudConfig.bCurAuxMute;
805}
806
807#if 0
808___INTERNAL_FUNCTIONS___()
809#endif
810static int AudioMuteReq(DD_AUDIOMUTE AudioMuteAttr, int Arg)
811{
812        DS_U32 Msg[2];
813       
814        AudioMuteInit();
815       
816        Msg[0] = AudioMuteAttr;
817        Msg[1] = Arg;
818        if ( OS_SendMessage(AudioMuteQ, (DS_U32 *)Msg, sizeof(DS_U32) * 2) ) 
819        {
820                DHL_DbgPrintf(0,DDDBG_AV,"Cannot send msg AudioMute Thread.\n");
821                DstCore_QueueReset(AudioMuteQ);
822                return -1;
823        }
824       
825        return 0;
826}
827
828static int tAudioMute(DS_U32 *arg)
829{
830        DS_U32 msgLen;
831        DS_U32 ret;
832        static DS_U32 Msg[2];
833       
834        while(1) 
835    {
836                if ( tAudioMuteStarted == 0 ) 
837                {
838                        OS_mDelay(100);
839                        continue;
840                }
841               
842                ret = OS_ReceiveMessage(AudioMuteQ, Msg, sizeof(DS_U32)*2, &msgLen);
843                if ( ret ) 
844                {
845                        DHL_DbgPrintf(0,DDDBG_AV,"ERROR, LINE=%d\n", __LINE__);
846                        continue;
847                }
848               
849                switch(Msg[0]) 
850                {
851                        case DD_AUDIOMUTE_SPDIF:
852                                DD_AUD_AudioMuteSPDIF( Msg[1] );
853                                break;
854                       
855                        case DD_AUDIOMUTE_CHANGESPDIF:
856                                DD_AUD_ChangeAudOutFormat( Msg[1] );
857                                break;
858                               
859                        case DD_AUDIOMUTE_MAIN:
860                        case DD_AUDIOMUTE_AUX:
861                        case DD_AUDIOMUTE_HP:
862                        case DD_AUDIOMUTE_AMP:
863                        default:
864                                break;
865                }
866               
867                OS_mDelay(100);
868        }
869}
870
871static DHL_RESULT AudioMuteInit(void)
872{
873        DHL_RESULT dhlResult = DHL_OK;
874        static int bAudioMuteInit = 0;
875       
876        if ( bAudioMuteInit == 1 ) 
877                return dhlResult;
878
879        bAudioMuteInit = 1;
880
881        AudioMuteQ = OS_CreateMessageQueue("q_AudioMute", 0, MAX_AM_MESSAGES, sizeof(DS_U32)*2);
882        DHL_CHECK( AudioMuteQ != (DS_U32)NULL, dhlResult, DHL_FAIL_OUT_OF_RESOURCE );
883       
884        AudioMuteTaskId = OS_SpawnTask((void (*) (DS_U32))tAudioMute,"tAudioMute",AUDIOMUTE_TASK_PRIORITY,AUDIOMUTE_TASK_STACKSIZE,0);
885        DHL_CHECK( AudioMuteTaskId != (DS_U32)NULL, dhlResult, DHL_FAIL_OUT_OF_RESOURCE );
886       
887        AudioMuteStart();
888done:
889
890        return dhlResult;
891}
892
893static DHL_RESULT AudioMuteStart(void)
894{
895        DHL_RESULT dhlResult = DHL_OK;
896       
897        if ( tAudioMuteStarted == 1 )
898                return dhlResult;
899               
900        tAudioMuteStarted = 1;
901
902        return dhlResult;
903}
904
905static DHL_RESULT AudioMuteStop(void)
906{
907        DHL_RESULT dhlResult = DHL_OK;
908
909        return dhlResult;
910}
911
912void hamute(void)
913{
914        printf("HAL Mute Status\n");
915       
916        printf("Main Audio: %s(%d)\n", g_AudConfig.bCurI2SMute ? "muteOn" : "muteOff", g_AudConfig.bCurI2SMute);
917        printf("SPDIF Audio: %s(%d)\n", g_AudConfig.bCurSpdifMute ? "muteOn" : "muteOff", g_AudConfig.bCurSpdifMute);
918        printf("AUX Audio: %s(%d)\n\n", g_AudConfig.bCurAuxMute ? "muteOn" : "muteOff", g_AudConfig.bCurAuxMute);
919}
Note: See TracBrowser for help on using the repository browser.