Context Navigation

dsthalaud.c

Last change on this file was 76, checked in by megakiss, 10 years ago
1W 대기전력을 만족시키기 위하여 POWEROFF시 튜너를 Standby 상태로 함
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	******************************************************************************/
35	DHL_AUDIO_CONFIG g_AudConfig = {0};
36	int 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	******************************************************************************/
73	static OS_MESSAGEQUEUE_ID AudioMuteQ;
74	static OS_TASK_ID AudioMuteTaskId;
75	static int tAudioMuteStarted = 0;
76
77	/******************************************************************************
78	* Local function prototypes
79	******************************************************************************/
80	static int AudioMuteReq(DD_AUDIOMUTE AudioMuteAttr, int Arg);
81	static DHL_RESULT AudioMuteInit(void);
82	static DHL_RESULT AudioMuteStart(void);
83	static DHL_RESULT AudioMuteStop(void);
84
85	#if 0
86	___COMMON_APIs___()
87	#endif
88	DHL_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
114	done:
115	return dhlResult;
116	}
117
118	DHL_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	******************************************************************************/
137	DHL_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	/********************************************************************************
160	FUNCTION:
161	DHL_AUD_SetVolume
162
163	Purpose:
164	set callback functions
165
166	Arguments:
167	[in] uVolLvl - limit 0-100
168	Returns:
169	DHL_RESULT if success - DHL_OK fail - DHL_FAIL
170	*********************************************************************************/
171	DHL_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	/********************************************************************************
194	FUNCTION:
195	DD_AUDIO_GetVolume
196
197	Purpose:
198	Get I2SO(AM) audio output information
199	Arguments:
200	[OUT] puVolLvl - current am volume level
201	[OUT] pbMute - _TRUE_ is audio mute enabled
202	Returns:
203	DHL_RESULT if success - DHL_OK fail - DHL_FAIL
204	*********************************************************************************/
205	DHL_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
218	done:
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	/********************************************************************************
229	FUNCTION:
230	DHL_AUD_SetBalance
231
232	Purpose:
233	Set LR balance of audio amp output
234
235	Arguments:
236	[in] Balance - -50~0~50
237	Returns:
238	DHL_RESULT if success - DHL_OK fail - DHL_FAIL
239	*********************************************************************************/
240	DHL_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	/********************************************************************************
263	FUNCTION:
264	DHL_AUD_GetBalance
265
266	Purpose:
267	Get LR balance of audio amp output
268
269	Arguments:
270	[in-out] *pBalance - -50~0~50
271	Returns:
272	DHL_RESULT if success - DHL_OK fail - DHL_FAIL
273	*********************************************************************************/
274	DHL_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	/********************************************************************************
290	FUNCTION:
291	DHL_AUD_SetTreble
292
293	Purpose:
294	Audio Treble Control
295	Arguments:
296	[in] Treble : range 0~100
297	Returns:
298	DHL_RESULT if success - DHL_OK fail - DHL_FAIL
299	*********************************************************************************/
300	DHL_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	/********************************************************************************
323	FUNCTION:
324	DHL_AUD_GetTreble
325
326	Purpose:
327	Audio Treble and Bass Volume Control
328	Arguments:
329	[i] Treble : range 0~100
330	Returns:
331	DHL_RESULT if success - DHL_OK fail - DHL_FAIL
332	*********************************************************************************/
333	DHL_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	/********************************************************************************
349	FUNCTION:
350	DHL_AUD_SetBass
351
352	Purpose:
353	Audio Treble and Bass Volume Control
354	Arguments:
355	[i] Treble : range 0~100
356	Returns:
357	DHL_RESULT if success - DHL_OK fail - DHL_FAIL
358	*********************************************************************************/
359	DHL_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	/********************************************************************************
382	FUNCTION:
383	DHL_AUD_GetBass
384
385	Purpose:
386	Audio Treble and Bass Volume Control
387	Arguments:
388	[i] Treble : range 0~100
389	Returns:
390	DHL_RESULT if success - DHL_OK fail - DHL_FAIL
391	*********************************************************************************/
392	DHL_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	/********************************************************************************
408	FUNCTION:
409	DHL_AUD_SetAVL
410
411	Purpose:
412	Set audio AVL (Automatic Volume Leveller)
413
414	Arguments:
415	[in] Mode - [0:Off 1:On]
416	Returns:
417	DHL_RESULT if success - DHL_OK fail - DHL_FAIL
418	*********************************************************************************/
419	DHL_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
432	DHL_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	/********************************************************************************
447	FUNCTION:
448	DHL_AUD_SetAudioDelay
449	Purpose:
450
451	Arguments:
452	[IN] offset - offset (ms) range :0 ~ -120 ms
453	[IN] bAddSub - _TRUE_ is Add, _FALSE_ is Suntract
454	Returns:
455	DHL_RESULT success - DHL_OK, fail - DHL_FAIL
456	*********************************************************************************/
457	DHL_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
473	done:
474	return dhlResult;
475	}
476
477	/********************************************************************************
478	FUNCTION:
479	DHL_AUD_AUDIO_MUTE
480
481	Purpose:
482	audio mixer mute (L/R)
483	Arguments:
484	[in] bMute - audio mute on (_TRUE_) or off (FALSE)
485	Returns:
486	DHL_RESULT if success - DHL_OK fail - DHL_FAIL
487	*********************************************************************************/
488	DHL_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
502	done:
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	/********************************************************************************
510	FUNCTION:
511	DHL_AUD_AudioMuteSPDIF
512
513	Purpose:
514	spdif mute (SPDIF)
515	Arguments:
516	[in] bMute - audio mute on (_TRUE_) or off (FALSE)
517	Returns:
518	DHL_RESULT if success - DHL_OK fail - DHL_FAIL
519	*********************************************************************************/
520	DHL_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
536	done:
537	if(!DHL_ERROR(dhlResult))
538	DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"\|success\| %s\r\n",(bMute==_TRUE_) ? "SPDIFmuteOn":"SPDIFmuteOff");
539	return dhlResult;
540	}
541
542	DHL_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
558	done:
559	if(!DHL_ERROR(dhlResult))
560	DHL_DbgPrintf(gAUDDbgLvl,DHLDBG_AUD,"\|success\| %s\r\n",(bMute==_TRUE_) ? "AUXmuteOn":"AUXmuteOff");
561	return dhlResult;
562	}
563
564	DHL_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
574	done:
575	return dhlResult;
576	}
577
578	DHL_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
588	done:
589	return dhlResult;
590	}
591
592	DHL_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
613	done:
614	/* Give the MUTEX */
615
616
617
618	return dhlResult;
619	}
620
621	void 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
671	static 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	/********************************************************************************
694	FUNCTION:
695	DHL_AUD_PresetAudProcessor (DHL_AUD_PROC_TYPE type)
696
697	Purpose:
698
699	Arguments:
700	[in] type - audio processor type ( STA323W STA333W)
701
702	Returns:
703	DHL_RESULT if success - DHL_OK fail - DHL_FAIL
704	Note
705	Call this function before DHL_AUD_INIT, surely
706	*********************************************************************************/
707	DHL_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	/********************************************************************************
715	FUNCTION:
716	DHL_AUD_PresetAudioOut
717
718	Purpose:
719
720	Arguments:
721	[in] pAudConfig - audio output user configuration
722
723	Returns:
724	DHL_RESULT if success - DHL_OK fail - DHL_FAIL
725	Note
726	Call this function before DHL_AUD_INIT, surely
727	*********************************************************************************/
728	DHL_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	/********************************************************************************
738	FUNCTION:
739	DHL_AUD_ChangeAudOutFormat
740
741	Purpose:
742
743	Arguments:
744	[in] UserAudOutFmt - auudio output foramt (pcm or ac3)
745	Returns:
746	DHL_RESULT if success - DHL_OK fail - DHL_FAIL
747	*********************************************************************************/
748	DHL_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
771	done:
772	return dhlResult;
773	}
774
775	DHL_AUD_OUTPUT_FORMAT DHL_AUD_GetAudOutFormat(void)
776	{
777	return g_AudConfig.AudOutFormat;
778	}
779
780	DHL_RESULT DHL_AUD_SetAMPPower(int n)
781	{
782	return DD_AUD_SetAMPPower(n);
783	}
784
785	void DHL_AUD_PresetAudioOutput(int iAudOut)
786	{
787	DD_AUD_PresetAudioOutput(iAudOut);
788	//HDMI_TX_PresetAudioInput(iAudOut);
789	}
790
791
792	DS_BOOL DHL_AUD_IsMainMuted(void)
793	{
794	return g_AudConfig.bCurI2SMute;
795	}
796
797	DS_BOOL DHL_AUD_IsSpdifMuted(void)
798	{
799	return g_AudConfig.bCurSpdifMute;
800	}
801
802	DS_BOOL DHL_AUD_IsAuxMuted(void)
803	{
804	return g_AudConfig.bCurAuxMute;
805	}
806
807	#if 0
808	___INTERNAL_FUNCTIONS___()
809	#endif
810	static 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
828	static 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
871	static 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();
888	done:
889
890	return dhlResult;
891	}
892
893	static 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
905	static DHL_RESULT AudioMuteStop(void)
906	{
907	DHL_RESULT dhlResult = DHL_OK;
908
909	return dhlResult;
910	}
911
912	void 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.

Context Navigation

source: svn/zas_dstar/hal/common/dsthalaud.c

Download in other formats: