Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Normal
Revision Log

close Warning: Can't use blame annotator:
No changeset 2 in the repository

dsthalcap.c @ 22

Last change on this file since 22 was 22, checked in by phkim, 11 years ago
phkim newcon3sk 를 kctv 로 브랜치 함
File size: 86.5 KB

Rev	Line
	1	/******************************************************************************
	2	*_Copyright (c) 2009 Digital Stream Technology Inc. All Rights Reserved.
	3	*
	4	* Module: dsthalcap.c
	5	*
	6	* Description
	7	* This file includes platform/vendor specific APIs.
	8	*
	9	* Notes
	10	*
	11	* @author Junku Park (hwatk@dstreamtech.com)
	12	* @version $Revision: 1.1 $
	13	*
	14	******************************************************************************/
	15
	16	#include "dsthalcommon.h"
	17	#include "dstddcap.h"
	18	#include "dstdddtv.h"
	19	#include "dstdddisp.h"
	20	#include "dstddpic.h"
	21	#include "dstddsys.h"
	22	#ifdef DMALLOC
	23	#include <dmalloc.h>
	24	#endif
	25
	26	/******************************************************************************
	27	* Global variable declaration
	28	******************************************************************************/
	29	DS_U32 gdhlCapDbgLvl = 1;
	30	DHL_CAP_CONFIG g_dhlcap;
	31	DS_U32 g_SourceChangeTime;
	32	int g_SyncLockDelay = 64;
	33
	34	/******************************************************************************
	35	* Imported variable declaration
	36	******************************************************************************/
	37	extern DHL_DTV_CONFIG g_dhldtv;
	38	extern int Popup_StartDelay;
	39	extern int Popup_EndDelay;
	40	extern DS_U32 lastAudioTime;
	41	extern P_DHL_CARD_CALLBACK g_CardCallback;
	42	/******************************************************************************
	43	* Imported function declaration
	44	******************************************************************************/
	45
	46	/******************************************************************************
	47	* Local definitions and typedefs
	48	******************************************************************************/
	49
	50	/******************************************************************************
	51	* Local variables declaration
	52	******************************************************************************/
	53	static DHL_CAP_CBFUNC_t g_CAP_CBFunc;
	54	static DHL_CAP_CBFUNC2_t g_CAP_CBFunc2;
	55	static int g_VideoFreeze = 0;
	56	static int g_VideoFreezePIP = 0;
	57	static int g_HPDEnable = 0;
	58	static P_DHL_PRG_INFO pPrgInfo = &g_dhldtv.PrgInfo;
	59	static int g_SourceChangeDelay = 0;
	60
	61	static int g_VGAPhase;
	62	static int g_VGAClock;
	63
	64	/******************************************************************************
	65	* Local function prototypes
	66	******************************************************************************/
	67	static DHL_RESULT Init_VI_Thread(void);
	68	static DHL_RESULT Start_VI_Thread(DS_BOOL bFocus);
	69	static DHL_RESULT Stop_VI_Thread(DS_BOOL bFocus);
	70
	71	/******************************************************************************
	72	* Function declaration
	73	******************************************************************************/
	74	void DumpVideoInput(void);
	75	void DumpAudioInput(void);
	76	DS_BOOL DHL_CAP_IsStartedVideo(void);
	77	DS_BOOL DHL_CAP_IsStartedVideoPIP(void);
	78
	79	#define LOCK_CAP_MUTEX() do { \
	80	if ( OS_TakeMutex(g_dhlcap.uMutex) != OS_OK ) { \
	81	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"MUTEX ERROR, LINE=%d\n", __LINE__); \
	82	goto done; \
	83	} \
	84	} while (0)
	85
	86	#define UNLOCK_CAP_MUTEX() do { \
	87	if ( OS_GiveMutex(g_dhlcap.uMutex) != OS_OK ) { \
	88	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"MUTEX ERROR, LINE=%d\n", __LINE__); \
	89	} \
	90	} while (0)
	91
	92	#if 0
	93	___Common_APIs___()
	94	#endif
	95	/********************************************************************************
	96	FUNCTION:
	97	DHL_CAP_Init
	98
	99	Purpose:
	100	video/audio capture components initialize(open->init->connect)
	101	Arguments:
	102
	103	Returns:
	104	DHL_RESULT success - DHL_OK
	105	fail - DHL_FAIL
	106	*********************************************************************************/
	107	DHL_RESULT DHL_CAP_Init(void)
	108	{
	109	DHL_RESULT dhlResult = DHL_OK;
	110	static int CapInitFlag = 0;
	111
	112	if ( CapInitFlag == 1 )
	113	return dhlResult;
	114	CapInitFlag = 1;
	115
	116	dhlResult = DD_CAP_Init();
	117	if(DHL_ERROR(dhlResult))
	118	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"\|error\|%d(0x%x)\r\n",__LINE__,dhlResult);
	119
	120	g_dhlcap.uMutex = OS_CreateMutex( "CAP_Mutex" );
	121	if ( g_dhlcap.uMutex == (OS_MUTEX_ID)0 ) {
	122	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP," \|error\|%d(0x%x)\r\n",__LINE__,dhlResult);
	123	dhlResult = DHL_FAIL_CORE_DRIVER;
	124	goto done;
	125	}
	126	#if 0
	127	dhlResult = DHL_CAP_StartAudio(); // DTV¿¡¼ BOOTING ½Ã CAP Audio°¡ ½ÃÀÛµÇÁö ¾Ê¾Æ¼ audio°¡ ³ª¿ÀÁö ¾Ê´Â¹®Á¦·Î Ãß°¡µÊ.
	128	if(DHL_ERROR(dhlResult))
	129	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"\|error\|%d(0x%x)\r\n",__LINE__,dhlResult);
	130	#endif
	131	dhlResult = Init_VI_Thread();
	132	if(DHL_ERROR(dhlResult))
	133	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"\|error\|%d(0x%x)\r\n",__LINE__,dhlResult);
	134
	135	done:
	136	if(!DHL_ERROR(dhlResult))
	137	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"\|success\|\r\n");
	138	return dhlResult;
	139	}
	140
	141	/********************************************************************************
	142	FUNCTION:
	143	DHL_CAP_PresetVideoFormat
	144
	145	Purpose:
	146
	147	Arguments:
	148
	149	Returns:
	150	DHL_RESULT success - DHL_OK, fail - DHL_FAIL
	151	*********************************************************************************/
	152	DHL_RESULT DHL_CAP_PresetVideoFormat(DHL_VIDEO_FORMAT vf, DS_BOOL Focus)
	153	{
	154	DHL_RESULT dhlResult = DHL_OK;
	155
	156	if ( Focus == DHL_FOCUS_MAIN )
	157	g_dhlcap.CapInMainFmt = vf;
	158	else
	159	g_dhlcap.CapInSubFmt = vf;
	160
	161	return dhlResult;
	162	}
	163
	164	/********************************************************************************
	165	FUNCTION:
	166	DHL_CAP_PresetVideoInput
	167
	168	Purpose:
	169
	170	Arguments:
	171
	172	Returns:
	173	DHL_RESULT success - DHL_OK, fail - DHL_FAIL
	174	*********************************************************************************/
	175	DHL_RESULT DHL_CAP_PresetVideoInput(DHL_CAP_VIDEO_INPUT vi)
	176	{
	177	DHL_RESULT dhlResult = DHL_OK;
	178
	179	g_dhlcap.CapInMainVideoSrc = vi;
	180
	181	return dhlResult;
	182	}
	183
	184	DHL_RESULT DHL_CAP_PresetVideoInputPIP(DHL_CAP_VIDEO_INPUT vi)
	185	{
	186	DHL_RESULT dhlResult = DHL_OK;
	187
	188	g_dhlcap.CapInSubVideoSrc = vi;
	189
	190	return dhlResult;
	191	}
	192
	193	DHL_RESULT DHL_CAP_PresetVideoSource(DHL_CAP_VIDEO_INPUT vi)
	194	{
	195	return DHL_CAP_PresetVideoInput(vi);
	196	}
	197
	198	DHL_RESULT DHL_CAP_PresetVideoSourcePIP(DHL_CAP_VIDEO_INPUT vi)
	199	{
	200	return DHL_CAP_PresetVideoInputPIP(vi);
	201	}
	202
	203	DHL_RESULT DHL_CAP_PresetCallback(DHL_CAP_CBFUNC_t cbFunc)
	204	{
	205	DHL_RESULT dhlResult = DHL_OK;
	206
	207	g_CAP_CBFunc = cbFunc;
	208
	209	return dhlResult;
	210	}
	211
	212	DHL_RESULT DHL_CAP_PresetCallback2(DHL_CAP_CBFUNC2_t cbFunc)
	213	{
	214	DHL_RESULT dhlResult = DHL_OK;
	215
	216	g_CAP_CBFunc2 = cbFunc;
	217
	218	return dhlResult;
	219	}
	220
	221	/********************************************************************************
	222	FUNCTION:
	223	DHL_CAP_PresetAudioInput
	224
	225	Purpose:
	226
	227	Arguments:
	228
	229	Returns:
	230	DHL_RESULT success - DHL_OK, fail - DHL_FAIL
	231	*********************************************************************************/
	232	DHL_RESULT DHL_CAP_PresetAudioInput(DHL_CAP_AUDIO_INPUT ai)
	233	{
	234	DHL_RESULT dhlResult = DHL_OK;
	235
	236	g_dhlcap.CapInAudioSrc = ai;
	237
	238	return dhlResult;
	239	}
	240
	241	/********************************************************************************
	242	FUNCTION:
	243	DHL_CAP_Start
	244
	245	Purpose:
	246
	247	Arguments:
	248	[in] bMain / bSub - specify window to be started or stopped.
	249
	250	Returns:
	251	DHL_RESULT success - DHL_OK, fail - DHL_FAIL
	252	*********************************************************************************/
	253	DHL_RESULT DHL_CAP_Start(DS_BOOL bMain, DS_BOOL bSub)
	254	{
	255	DHL_RESULT dhlResult = DHL_OK;
	256
	257	if (bMain) {
	258	dhlResult = DHL_CAP_StartVideo();
	259	if(DHL_ERROR(dhlResult))
	260	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"\|error\|%d(0x%x)\r\n",__LINE__,dhlResult);
	261	}
	262
	263	if (bSub) {
	264	dhlResult = DHL_CAP_StartVideoPIP();
	265	if(DHL_ERROR(dhlResult))
	266	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"\|error\|%d(0x%x)\r\n",__LINE__,dhlResult);
	267	}
	268
	269	dhlResult = DHL_CAP_StartAudio();
	270	if(DHL_ERROR(dhlResult))
	271	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"\|error\|%d(0x%x)\r\n",__LINE__,dhlResult);
	272
	273	if(!DHL_ERROR(dhlResult))
	274	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"\|success\|\r\n");
	275
	276	return dhlResult;
	277	}
	278
	279	/********************************************************************************
	280	FUNCTION:
	281	DHL_CAP_Stop
	282
	283	Purpose:
	284
	285	Arguments:
	286	[in] bMain / bSub - specify window to be started or stopped.
	287
	288	Returns:
	289	DHL_RESULT success - DHL_OK, fail - DHL_FAIL
	290	*********************************************************************************/
	291	DHL_RESULT DHL_CAP_Stop(DS_BOOL bMain, DS_BOOL bSub)
	292	{
	293	DHL_RESULT dhlResult = DHL_OK;
	294
	295	if (bMain) {
	296	dhlResult = DHL_CAP_StopVideo();
	297	if(DHL_ERROR(dhlResult))
	298	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"\|error\|%d(0x%x)\r\n",__LINE__,dhlResult);
	299	}
	300
	301	if (bSub) {
	302	dhlResult = DHL_CAP_StopVideoPIP();
	303	if(DHL_ERROR(dhlResult))
	304	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"\|error\|%d(0x%x)\r\n",__LINE__,dhlResult);
	305	}
	306
	307	dhlResult = DHL_CAP_StopAudio();
	308	if(DHL_ERROR(dhlResult))
	309	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"\|error\|%d(0x%x)\r\n",__LINE__,dhlResult);
	310
	311	if(DHL_ERROR(dhlResult))
	312	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"\|error\|%d(0x%x)\r\n",__LINE__,dhlResult);
	313
	314	if(!DHL_ERROR(dhlResult))
	315	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"\|success\|\r\n");
	316
	317	return dhlResult;
	318	}
	319
	320	/********************************************************************************
	321	FUNCTION:
	322	DHL_CAP_Close
	323
	324	Purpose:
	325
	326	Arguments:
	327
	328	Returns:
	329	DHL_RESULT success - DHL_OK, fail - DHL_FAIL
	330	*********************************************************************************/
	331	DHL_RESULT DHL_CAP_Close(void)
	332	{
	333	DHL_RESULT dhlResult = DHL_OK;
	334
	335	dhlResult = DD_CAP_Close();
	336
	337	if(DHL_ERROR(dhlResult))
	338	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"\|error\|%d(0x%x)\r\n",__LINE__,dhlResult);
	339
	340	if(!DHL_ERROR(dhlResult))
	341	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"\|success\|\r\n");
	342
	343	return dhlResult;
	344	}
	345
	346	/********************************************************************************
	347	FUNCTION:
	348	DHL_CAP_Pause
	349
	350	Purpose:
	351
	352	Arguments:
	353	[in] Focus - 0 for Main / 1 for Sub
	354
	355	Returns:
	356	DHL_RESULT success - DHL_OK, fail - DHL_FAIL
	357	*********************************************************************************/
	358	DHL_RESULT DHL_CAP_Pause(DS_BOOL Focus)
	359	{
	360	DHL_RESULT dhlResult = DHL_OK;
	361
	362	if (Focus == 0/Main/ && g_VideoFreeze == 1 ) {
	363	printf("\|%s:%d\| WARNING: This API is called twice.\n", __FUNCTION__, __LINE__);
	364	return dhlResult;
	365	}
	366	if (Focus == 1/Sub/ && g_VideoFreezePIP == 1 ) {
	367	printf("\|%s:%d\| WARNING: This API is called twice.\n", __FUNCTION__, __LINE__);
	368	return dhlResult;
	369	}
	370
	371	dhlResult = DD_CAP_VideoPause(Focus);
	372	if(DHL_ERROR(dhlResult))
	373	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"\|error\|%d(0x%x)\r\n",__LINE__,dhlResult);
	374
	375	if (Focus == 0)
	376	g_VideoFreeze = 1;
	377	else
	378	g_VideoFreezePIP = 1;
	379
	380	if(!DHL_ERROR(dhlResult))
	381	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"\|success\|\r\n");
	382
	383	return dhlResult;
	384	}
	385
	386	/********************************************************************************
	387	FUNCTION:
	388	DHL_CAP_Resume
	389
	390	Purpose:
	391
	392	Arguments:
	393	[in] Focus - 0 for Main / 1 for Sub
	394
	395	Returns:
	396	DHL_RESULT success - DHL_OK, fail - DHL_FAIL
	397	*********************************************************************************/
	398	DHL_RESULT DHL_CAP_Resume(DS_BOOL Focus)
	399	{
	400	DHL_RESULT dhlResult = DHL_OK;
	401
	402	if (Focus == 0/Main/ && g_VideoFreeze == 0 ) {
	403	printf("\|%s:%d\| WARNING: This API is called twice.\n", __FUNCTION__, __LINE__);
	404	return dhlResult;
	405	}
	406
	407	if (Focus == 1/Sub/ && g_VideoFreezePIP == 0 ) {
	408	printf("\|%s:%d\| WARNING: This API is called twice.\n", __FUNCTION__, __LINE__);
	409	return dhlResult;
	410	}
	411
	412	dhlResult = DD_CAP_VideoResume(Focus);
	413	if(DHL_ERROR(dhlResult))
	414	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"\|error\|%d(0x%x)\r\n",__LINE__,dhlResult);
	415
	416	if (Focus == 0)
	417	g_VideoFreeze = 0;
	418	else
	419	g_VideoFreezePIP = 0;
	420
	421	if(!DHL_ERROR(dhlResult))
	422	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"\|success\|\r\n");
	423
	424	return dhlResult;
	425	}
	426
	427	#if 0
	428	___Video_Capture_APIs___()
	429	#endif
	430
	431	/********************************************************************************
	432	FUNCTION:
	433	DHL_CAP_VideoStartEx
	434
	435	Purpose:
	436	Main, Sub Source¸¦ ÇÔ²² ½ÃÀÛ½ÃÅ°´Â ÇÔ¼ö.
	437
	438	Arguments:
	439	[in] bMain / bSub - specify window to be started or stopped.
	440
	441	Returns:
	442	DHL_RESULT success - DHL_OK, fail - DHL_FAIL
	443	*********************************************************************************/
	444	static DS_U8 PIPTable[11*11] = {
	445	// RF CVBS0 SV0 CV1 SV1 YPbPr0 YPbPr1 PC HDMI1 HDMI2 HDMI3
	446	/RF/ 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1,
	447	/CV0/ 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1,
	448	/SV0/ 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1,
	449	/CV1/ 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1,
	450	/SV1/ 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1,
	451	/YPbPr0/ 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1,
	452	/YPbPr1/ 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1,
	453	/PC/ 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1,
	454	/HDMI1/ 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0,
	455	/HDMI2/ 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0,
	456	/HDMI3/ 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0
	457	};
	458
	459	static int CheckPIPCombination(DHL_CAP_VIDEO_INPUT MainSrc, DHL_CAP_VIDEO_INPUT SubSrc)
	460	{
	461	int mainIdx, subIdx;
	462	int ret;
	463
	464	switch(MainSrc) {
	465	case DHL_CAP_DTV0_VIDEO: mainIdx = 0; break;
	466	case DHL_CAP_DTV1_VIDEO: return 0;
	467	case DHL_CAP_ATV0_VIDEO: mainIdx = 0; break;
	468	case DHL_CAP_ATV1_VIDEO: return 0;
	469	case DHL_CAP_CVBS0_VIDEO: mainIdx = 1; break;
	470	case DHL_CAP_CVBS1_VIDEO: mainIdx = 3; break;
	471	case DHL_CAP_CVBS2_VIDEO: return 0;
	472	case DHL_CAP_CVBS3_VIDEO: return 0;
	473	case DHL_CAP_SVIDEO0_VIDEO: mainIdx = 2; break;
	474	case DHL_CAP_SVIDEO1_VIDEO: mainIdx = 4; break;
	475	case DHL_CAP_SVIDEO2_VIDEO: return 0;
	476	case DHL_CAP_SVIDEO3_VIDEO: return 0;
	477	case DHL_CAP_YPBPR0_VIDEO: mainIdx = 5; break;
	478	case DHL_CAP_YPBPR1_VIDEO: mainIdx = 6; break;
	479	case DHL_CAP_YPBPR2_VIDEO: return 0;
	480	case DHL_CAP_YPBPR3_VIDEO: return 0;
	481	case DHL_CAP_HDMI0_VIDEO: mainIdx = 8; break;
	482	case DHL_CAP_HDMI1_VIDEO: mainIdx = 9; break;
	483	case DHL_CAP_HDMI2_VIDEO: mainIdx = 10; break;
	484	case DHL_CAP_HDMI3_VIDEO: return 0;
	485	case DHL_CAP_VGA0_VIDEO: mainIdx = 7; break;
	486	case DHL_CAP_VGA1_VIDEO: return 0;
	487	default:
	488	return 0;
	489	}
	490
	491	switch(SubSrc) {
	492	case DHL_CAP_DTV0_VIDEO: subIdx = 0; break;
	493	case DHL_CAP_DTV1_VIDEO: return 0;
	494	case DHL_CAP_ATV0_VIDEO: subIdx = 0; break;
	495	case DHL_CAP_ATV1_VIDEO: return 0;
	496	case DHL_CAP_CVBS0_VIDEO: subIdx = 1; break;
	497	case DHL_CAP_CVBS1_VIDEO: subIdx = 3; break;
	498	case DHL_CAP_CVBS2_VIDEO: return 0;
	499	case DHL_CAP_CVBS3_VIDEO: return 0;
	500	case DHL_CAP_SVIDEO0_VIDEO: subIdx = 2; break;
	501	case DHL_CAP_SVIDEO1_VIDEO: subIdx = 4; break;
	502	case DHL_CAP_SVIDEO2_VIDEO: return 0;
	503	case DHL_CAP_SVIDEO3_VIDEO: return 0;
	504	case DHL_CAP_YPBPR0_VIDEO: subIdx = 5; break;
	505	case DHL_CAP_YPBPR1_VIDEO: subIdx = 6; break;
	506	case DHL_CAP_YPBPR2_VIDEO: return 0;
	507	case DHL_CAP_YPBPR3_VIDEO: return 0;
	508	case DHL_CAP_HDMI0_VIDEO: subIdx = 8; break;
	509	case DHL_CAP_HDMI1_VIDEO: subIdx = 9; break;
	510	case DHL_CAP_HDMI2_VIDEO: subIdx = 10; break;
	511	case DHL_CAP_HDMI3_VIDEO: return 0;
	512	case DHL_CAP_VGA0_VIDEO: subIdx = 7; break;
	513	case DHL_CAP_VGA1_VIDEO: return 0;
	514	default:
	515	return 0;
	516	}
	517
	518	ret = PIPTable[mainIdx*11 + subIdx];
	519
	520	return ret;
	521	}
	522
	523	DHL_RESULT DHL_CAP_StartVideoEx(DHL_CAP_VIDEO_INPUT MainSrc, DHL_CAP_VIDEO_INPUT SubSrc, DHL_PIPMode_t PIPMode, DHL_PIP_t pipPos )
	524	{
	525	DHL_RESULT dhlResult = DHL_OK;
	526	int bAVStart = 0, bMainStart = 0, bSubStart = 0, bMainAspect = 0, bMainMuted = 0;
	527	DS_U16 vPid=0, aPid=0, pcrPid=0;
	528	int aType=0;
	529	DHL_CAP_Init();
	530
	531	//
	532	// Argument Check
	533	//
	534	if ( DHL_PIPMODE_NONE != PIPMode ) {
	535	if ( MainSrc > DHL_CAP_VIDEO_NONE \|\| MainSrc < DHL_CAP_DTV_VIDEO_START \|\|
	536	SubSrc > DHL_CAP_VIDEO_NONE \|\| SubSrc < DHL_CAP_DTV_VIDEO_START ) {
	537	DHL_DbgPrintf(0,DHLDBG_CAP,"ERROR: Invalid Source MainSrc=%d, SubSrc=%d\n", MainSrc, SubSrc);
	538	return DHL_FAIL;
	539	}
	540
	541	if ( (MainSrc >= DHL_CAP_ATV_VIDEO_START && MainSrc <= DHL_CAP_ATV_VIDEO_STOP) &&
	542	(SubSrc >= DHL_CAP_ATV_VIDEO_START && SubSrc <= DHL_CAP_ATV_VIDEO_STOP) ) {
	543	DHL_DbgPrintf(0,DHLDBG_CAP,"ERROR: Invalid Source MainSrc=%d, SubSrc=%d\n", MainSrc, SubSrc);
	544	return DHL_FAIL;
	545	}
	546
	547	if ( (MainSrc >= DHL_CAP_CVBS_VIDEO_START && MainSrc <= DHL_CAP_CVBS_VIDEO_STOP) &&
	548	(SubSrc >= DHL_CAP_CVBS_VIDEO_START && SubSrc <= DHL_CAP_CVBS_VIDEO_STOP) ) {
	549	DHL_DbgPrintf(0,DHLDBG_CAP,"ERROR: Invalid Source MainSrc=%d, SubSrc=%d\n", MainSrc, SubSrc);
	550	return DHL_FAIL;
	551	}
	552
	553	if ( (MainSrc >= DHL_CAP_SVIDEO_VIDEO_START && MainSrc <= DHL_CAP_SVIDEO_VIDEO_STOP) &&
	554	(SubSrc >= DHL_CAP_SVIDEO_VIDEO_START && SubSrc <= DHL_CAP_SVIDEO_VIDEO_STOP) ) {
	555	DHL_DbgPrintf(0,DHLDBG_CAP,"ERROR: Invalid Source MainSrc=%d, SubSrc=%d\n", MainSrc, SubSrc);
	556	return DHL_FAIL;
	557	}
	558
	559	if ( (MainSrc >= DHL_CAP_YPBPR_VIDEO_START && MainSrc <= DHL_CAP_YPBPR_VIDEO_STOP) &&
	560	(SubSrc >= DHL_CAP_YPBPR_VIDEO_START && SubSrc <= DHL_CAP_YPBPR_VIDEO_START) ) {
	561	DHL_DbgPrintf(0,DHLDBG_CAP,"ERROR: Invalid Source MainSrc=%d, SubSrc=%d\n", MainSrc, SubSrc);
	562	return DHL_FAIL;
	563	}
	564
	565	if ( (MainSrc >= DHL_CAP_HDMI_VIDEO_START && MainSrc <= DHL_CAP_HDMI_VIDEO_STOP) &&
	566	(SubSrc >= DHL_CAP_HDMI_VIDEO_START && SubSrc <= DHL_CAP_HDMI_VIDEO_STOP) ) {
	567	DHL_DbgPrintf(0,DHLDBG_CAP,"ERROR: Invalid Source MainSrc=%d, SubSrc=%d\n", MainSrc, SubSrc);
	568	return DHL_FAIL;
	569	}
	570
	571	if ( (MainSrc >= DHL_CAP_VGA_VIDEO_START && MainSrc <= DHL_CAP_VGA_VIDEO_STOP) &&
	572	(SubSrc >= DHL_CAP_VGA_VIDEO_START && SubSrc <= DHL_CAP_VGA_VIDEO_STOP) ) {
	573	DHL_DbgPrintf(0,DHLDBG_CAP,"ERROR: Invalid Source MainSrc=%d, SubSrc=%d\n", MainSrc, SubSrc);
	574	return DHL_FAIL;
	575	}
	576
	577	if ( SubSrc != DHL_CAP_VIDEO_NONE && PIPMode != DHL_PIPMODE_NONE ) {
	578	if ( CheckPIPCombination(MainSrc, SubSrc) == 0 ) {
	579	DHL_DbgPrintf(0,DHLDBG_CAP,"ERROR: Invalid Source MainSrc=%d, SubSrc=%d\n", MainSrc, SubSrc);
	580	return DHL_FAIL;
	581	}
	582	}
	583
	584	if ( MainSrc == SubSrc && MainSrc != DHL_CAP_VIDEO_NONE ) {
	585	/* Main & SubSrc is same, need to check other arguments. */
	586	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"skipped.\n");
	587	return dhlResult;
	588	}
	589	}
	590
	591	#if 0
	592	//
	593	// Workaround: Áö¿øÇÏÁö ¾Ê´Â SubSource Á¦¿Ü.
	594	//
	595	if ( SubSrc == DHL_CAP_VGA0_VIDEO/* \|\| SubSrc == DHL_CAP_DTV0_VIDEO*/ ) {
	596	DHL_DbgPrintf(0,DHLDBG_CAP,"ERROR: Currently SubSrc %d is not supported.\n", SubSrc);
	597	if (SubSrc == DHL_CAP_DTV0_VIDEO) {
	598	DHL_DbgPrintf(0,DHLDBG_CAP,"INFO: Force Sub mode to NTSC.\n");
	599	SubSrc = DHL_CAP_ATV0_VIDEO;
	600	} else
	601	return DHL_FAIL_NO_HARDWARE_SUPPORT;
	602	}
	603	#endif
	604
	605	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"\|%s\| MainSrc=%d, SubSrc=%d, PIPMode=%d, pipPos=%d\n", __FUNCTION__, MainSrc, SubSrc, PIPMode, pipPos );
	606
	607	//
	608	// Update next display parameters.
	609	//
	610	DHL_PIC_UpdateNextParam();
	611
	612	DHL_DbgPrintf(0,DHLDBG_CAP,"\|%s\| Line=%d\n", __FUNCTION__, __LINE__);
	613
	614	{
	615	//
	616	// Stop main/sub source.
	617	//
	618	if ( DHL_CAP_GetVideoSrc(0) != MainSrc )
	619	{
	620	/*
	621	* ÀÌÀü ¼Ò½º È¤Àº ´ÙÀ½ ¼Ò½º°¡ HDMIÀÎ °æ¿ì, g_SourceChangeDelay ÀÌÈÄ¿¡ ¼Ò½º ÀüÈ¯.
	622	* => Toshiba / SA-STB / Motorola-STB¿¡¼ÀÇ HDCP Error ¹®Á¦.
	623	*/
	624	if ( (DHL_CAP_GetVideoSrc(0) >= DHL_CAP_HDMI0_VIDEO && DHL_CAP_GetVideoSrc(0) <= DHL_CAP_HDMI3_VIDEO) \|\|
	625	(MainSrc >= DHL_CAP_HDMI0_VIDEO && MainSrc <= DHL_CAP_HDMI3_VIDEO) )
	626	{
	627	if ( g_SourceChangeDelay )
	628	{
	629	do
	630	{
	631	OS_mDelay(10);
	632	} while ( (OS_GetTickCount()-g_SourceChangeTime) < g_SourceChangeDelay );
	633	}
	634	}
	635
	636	//
	637	// AV ¸ÕÀú Á¤ÁöµÇ¾î¾ß ÇÔ.
	638	//
	639	if ( DHL_DTV_IsVideoStarted() )
	640	{
	641	vPid = pPrgInfo->VidPID;
	642	aPid = pPrgInfo->AudPID;
	643	pcrPid = pPrgInfo->PCRPID;
	644	aType = pPrgInfo->AudStreamType;
	645
	646	DHL_DTV_StopAV();
	647
	648	if ( MainSrc == DHL_CAP_DTV0_VIDEO \|\| SubSrc == DHL_CAP_DTV0_VIDEO )
	649	bAVStart = 1;
	650	}
	651
	652	dhlResult = DHL_CAP_StopVideo();
	653	if(DHL_ERROR(dhlResult))
	654	DHL_DbgPrintf(0,DHLDBG_CAP,"\|error\|%d(0x%x)\r\n",__LINE__,dhlResult);
	655
	656	DHL_DbgPrintf(0,DHLDBG_CAP,"\|%s\| Line=%d\n", __FUNCTION__, __LINE__);
	657	//
	658	// Main º¯°æ ½Ã, ³ëÀÌÁî°¡ ³²Áö ¾Êµµ·Ï ¹Ì¸® NRÀ» ²¨³õÀÚ.
	659	//
	660	dhlResult = DD_PIC_SetNR(0);
	661	if(DHL_ERROR(dhlResult))
	662	DHL_DbgPrintf(0,DHLDBG_CAP,"\|error\|%d(0x%x)\r\n",__LINE__,dhlResult);
	663	bMainStart = 1;
	664	DHL_DbgPrintf(0,DHLDBG_CAP,"\|%s\| Line=%d\n", __FUNCTION__, __LINE__);
	665
	666	//
	667	// ATV°¡ ¾Æ´Ï¸é ²ôÀÚ.
	668	//
	669	if ( MainSrc != DHL_CAP_ATV0_VIDEO && MainSrc != DHL_CAP_DTV0_VIDEO ) {
	670	dhlResult = DHL_FE_Start( TUNER_FAT, 63000, DEMOD_OFF, FREQ );
	671	}
	672
	673	if(DHL_ERROR(dhlResult))
	674	DHL_DbgPrintf(0,DHLDBG_CAP,"\|error\|%d(0x%x)\r\n",__LINE__,dhlResult);
	675
	676	g_SourceChangeTime = OS_GetTickCount();
	677	}
	678
	679	DHL_DbgPrintf(0,DHLDBG_CAP,"\|%s\| Line=%d\n", __FUNCTION__, __LINE__);
	680	if ( DHL_CAP_GetVideoSrc(1) != SubSrc \|\| PIPMode == DHL_PIPMODE_NONE ) {
	681	if ( PIPMode == DHL_PIPMODE_DW_NORMAL \|\| PIPMode == DHL_PIPMODE_DW_FULL \|\|
	682	PIPMode == DHL_PIPMODE_DW_NORMAL_NO_CROP \|\| PIPMode == DHL_PIPMODE_DW_FULL_NO_CROP \|\|
	683	g_dhlcap.pipMode == DHL_PIPMODE_DW_NORMAL \|\| g_dhlcap.pipMode == DHL_PIPMODE_DW_FULL \|\|
	684	g_dhlcap.pipMode == DHL_PIPMODE_DW_NORMAL_NO_CROP \|\| g_dhlcap.pipMode == DHL_PIPMODE_DW_FULL_NO_CROP ) {
	685	if ( !DHL_DISP_IsVideoMuted() ) {
	686	DD_DISP_VideoMute(1);
	687	bMainMuted = 1;
	688	}
	689	}
	690	dhlResult = DHL_CAP_StopVideoPIP();
	691	if(DHL_ERROR(dhlResult))
	692	DHL_DbgPrintf(0,DHLDBG_CAP,"\|error\|%d(0x%x)\r\n",__LINE__,dhlResult);
	693
	694	bSubStart = 1;
	695
	696	}
	697	if (bMainStart) {
	698	//
	699	// Change Video Source.
	700	//
	701	dhlResult = DHL_CAP_ChangeVideoSource(MainSrc);
	702	if(DHL_ERROR(dhlResult))
	703	DHL_DbgPrintf(0,DHLDBG_CAP,"\|error\|%d(0x%x)\r\n",__LINE__,dhlResult);
	704	}
	705	if (bSubStart) {
	706	//
	707	// PIPMode°¡ NONEÀÎ °æ¿ì, PIP Source ÀüÈ¯ÀÌ ÇÊ¿ä¾øÀ½.
	708	//
	709	if ( PIPMode != DHL_PIPMODE_NONE ) {
	710	dhlResult = DHL_CAP_ChangeVideoSourcePIP(SubSrc);
	711	if(DHL_ERROR(dhlResult))
	712	DHL_DbgPrintf(0,DHLDBG_CAP,"\|error\|%d(0x%x)\r\n",__LINE__,dhlResult);
	713	}
	714	}
	715	}
	716	//
	717	// DW°¡ EnableµÈ °æ¿ì, Àû¿ë.
	718	//
	719	if ( PIPMode == DHL_PIPMODE_DW_NORMAL \|\| PIPMode == DHL_PIPMODE_DW_FULL \|\| PIPMode == DHL_PIPMODE_DW_NORMAL_NO_CROP \|\| PIPMode == DHL_PIPMODE_DW_FULL_NO_CROP \|\| g_dhlcap.pipMode == DHL_PIPMODE_DW_NORMAL \|\| g_dhlcap.pipMode == DHL_PIPMODE_DW_FULL \|\| g_dhlcap.pipMode == DHL_PIPMODE_DW_NORMAL_NO_CROP \|\| g_dhlcap.pipMode == DHL_PIPMODE_DW_FULL_NO_CROP ) {
	720	if ( g_dhlcap.pipMode != PIPMode )
	721	bMainAspect = 1;
	722	}
	723	//
	724	// Change Video Parameters.
	725	//
	726	g_dhlcap.pipPosition = pipPos;
	727	g_dhlcap.pipMode = PIPMode;
	728	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"\|%s\| PIP Mode: %s (%d)\n", __FUNCTION__,
	729	PIPMode == DHL_PIPMODE_NONE ? "None" :
	730	PIPMode == DHL_PIPMODE_PIPSMALL ? "PIP-Small" :
	731	PIPMode == DHL_PIPMODE_PIPSMALL_NO_CROP ? "PIP-Small NO CROP" :
	732	PIPMode == DHL_PIPMODE_PIPLARGE ? "PIP-Large" :
	733	PIPMode == DHL_PIPMODE_PIPLARGE_NO_CROP ? "PIP-Large NO CROP" :
	734	PIPMode == DHL_PIPMODE_DW_NORMAL ? "DW-Normal" :
	735	PIPMode == DHL_PIPMODE_DW_NORMAL_NO_CROP ? "DW-Normal No Crop" :
	736	PIPMode == DHL_PIPMODE_DW_FULL ? "DW-Full" :
	737	PIPMode == DHL_PIPMODE_DW_FULL_NO_CROP ? "DW-Full No Crop" : "Unknown", PIPMode);
	738	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"\|%s\| PIP Position: %s (%d)\n", __FUNCTION__,
	739	pipPos == DHL_PIP_TOP_LEFT ? "Upper-Left" :
	740	pipPos == DHL_PIP_TOP_RIGHT ? "Upper-Right" :
	741	pipPos == DHL_PIP_BTM_LEFT ? "Upper-Right" :
	742	pipPos == DHL_PIP_BTM_RIGHT ? "Upper-Right" : "Unknown", pipPos );
	743	if ( PIPMode != DHL_PIPMODE_NONE \|\| bSubStart ) {
	744	dhlResult = DD_DISP_SetPIPStyle( PIPMode, pipPos );
	745	if(DHL_ERROR(dhlResult))
	746	DHL_DbgPrintf(0,DHLDBG_CAP,"\|error\|%d(0x%x)\r\n",__LINE__,dhlResult);
	747	}
	748	//
	749	// Start main/sub source.
	750	//
	751	{
	752	if ( bMainAspect )
	753	dhlResult = DD_DISP_SetAspectRatio( DHL_DISP_GetDispAspect() );
	754	if ( bMainStart ) {
	755	dhlResult = DHL_CAP_StartVideo();
	756	if(DHL_ERROR(dhlResult))
	757	DHL_DbgPrintf(0,DHLDBG_CAP,"\|error\|%d(0x%x)\r\n",__LINE__,dhlResult);
	758
	759	dhlResult = DHL_PIC_SetParams(bMainStart);
	760	if(DHL_ERROR(dhlResult))
	761	DHL_DbgPrintf(0,DHLDBG_CAP,"\|error\|%d(0x%x)\r\n",__LINE__,dhlResult);
	762	}
	763
	764	//
	765	// Handle noise reduction & deinterlace function here. (hwatk 070724)
	766	//
	767	switch( MainSrc ) {
	768	case DHL_CAP_DTV0_VIDEO:
	769	if ( PIPMode != DHL_PIPMODE_NONE )
	770	DHL_PIC_SetNR(0/OFF/);
	771	break;
	772
	773	case DHL_CAP_HDMI0_VIDEO:
	774	case DHL_CAP_HDMI1_VIDEO:
	775	case DHL_CAP_HDMI2_VIDEO:
	776	if ( PIPMode == DHL_PIPMODE_DW_NORMAL \|\| PIPMode == DHL_PIPMODE_DW_FULL \|\|
	777	PIPMode == DHL_PIPMODE_DW_NORMAL_NO_CROP \|\| PIPMode == DHL_PIPMODE_DW_FULL_NO_CROP )
	778	DHL_PIC_SetNR(0/OFF/);
	779	break;
	780
	781	case DHL_CAP_YPBPR0_VIDEO:
	782	case DHL_CAP_YPBPR1_VIDEO:
	783	if ( PIPMode == DHL_PIPMODE_DW_NORMAL \|\| PIPMode == DHL_PIPMODE_DW_FULL \|\|
	784	PIPMode == DHL_PIPMODE_DW_NORMAL_NO_CROP \|\| PIPMode == DHL_PIPMODE_DW_FULL_NO_CROP )
	785	DHL_PIC_SetNR(0/OFF/);
	786	break;
	787
	788	case DHL_CAP_VGA0_VIDEO:
	789	DHL_PIC_SetNR(1/ON/);
	790	break;
	791
	792	default:
	793	break;
	794	}
	795	if ( bSubStart ) {
	796	if ( PIPMode != DHL_PIPMODE_NONE && DHL_CAP_GetVideoSrc(1) != DHL_CAP_VIDEO_NONE ) {
	797	dhlResult = DHL_CAP_StartVideoPIP();
	798	if(DHL_ERROR(dhlResult))
	799	DHL_DbgPrintf(0,DHLDBG_CAP,"\|error\|%d(0x%x)\r\n",__LINE__,dhlResult);
	800	}
	801	}
	802	DumpVideoInput();
	803	}
	804
	805	if ( bAVStart ) {
	806	DHL_DbgPrintf(0,DHLDBG_CAP,"\|%s\| Line=%d\n", __FUNCTION__, __LINE__);
	807	dhlResult=DHL_DTV_StartAV(vPid, aPid, pcrPid, aType );
	808	if (dhlResult != DHL_OK)
	809	printf("\|%s\| ERROR, LINE=%d\n", __FUNCTION__, __LINE__);
	810	DHL_DbgPrintf(0,DHLDBG_CAP,"\|%s\| Line=%d\n", __FUNCTION__, __LINE__);
	811	}
	812	if (bMainMuted) {
	813	if ( !DHL_DISP_IsVideoMuted() ) {
	814	DD_DISP_VideoMute(0);
	815	}
	816	}
	817	if(!DHL_ERROR(dhlResult))
	818	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"\|success\|\r\n");
	819
	820	return dhlResult;
	821	}
	822
	823	/********************************************************************************
	824	FUNCTION:
	825	DHL_CAP_StartVideo
	826	DHL_CAP_StopVideo
	827
	828	Purpose:
	829
	830	Arguments:
	831	[in] bMain / bSub - specify window to be started or stopped.
	832
	833	Returns:
	834	DHL_RESULT success - DHL_OK, fail - DHL_FAIL
	835	*********************************************************************************/
	836	DHL_RESULT DHL_CAP_StartVideo(void)
	837	{
	838	DHL_RESULT dhlResult = DHL_OK;
	839
	840	DHL_CAP_Init();
	841
	842	if (g_dhlcap.isCapMainVideoStarted == 1)
	843	{
	844	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"skipped.\n");
	845	return dhlResult;
	846	}
	847
	848	if (DHL_CAP_GetVideoSrc(0) < DHL_CAP_DTV_VIDEO_START \|\| DHL_CAP_GetVideoSrc(0) >= DHL_CAP_VIDEO_END)
	849	{
	850	printf("\|%s\| Invalid input source: %d\n", __FUNCTION__, DHL_CAP_GetVideoSrc(0));
	851	return DHL_FAIL;
	852	}
	853
	854	if ( g_dhlcap.isCapSubVideoStarted == 1 )
	855	{
	856	if ( CheckPIPCombination( DHL_CAP_GetVideoSrc(0), DHL_CAP_GetVideoSrc(1) ) == 0 )
	857	{
	858	printf("\|%s\| ERROR: Invalid PIP combination, mainSrc=%d, subSrc=%d\n", __FUNCTION__, DHL_CAP_GetVideoSrc(0), DHL_CAP_GetVideoSrc(1));
	859	return DHL_FAIL;
	860	}
	861	}
	862
	863	g_dhlcap.isCapMainVideoStarted = 1;
	864	DumpVideoInput();
	865
	866	if ( DHL_DTV_IsAVStarted() )
	867	{
	868	DHL_DTV_StopAV();
	869	}
	870
	871	dhlResult = DD_CAP_StartVideo();
	872	SysASSERT( dhlResult == DHL_OK );
	873
	874	//dhlResult = DHL_DISP_SetDispParams();
	875	SysASSERT( dhlResult == DHL_OK );
	876
	877	dhlResult = Start_VI_Thread(0);
	878	SysASSERT( dhlResult == DHL_OK );
	879
	880	if ( (DHL_CAP_GetVideoSrc(0) >= DHL_CAP_ATV_VIDEO_START) && (DHL_CAP_GetVideoSrc(0) < DHL_CAP_HDMI_VIDEO_START))
	881	{
	882	dhlResult = DHL_CAP_CC_Start();
	883	SysASSERT( dhlResult == DHL_OK );
	884	}
	885
	886	SysENSURE( dhlResult == DHL_OK );
	887	return dhlResult;
	888	}
	889
	890	DHL_RESULT DHL_CAP_StopVideo(void)
	891	{
	892	DHL_RESULT dhlResult = DHL_OK;
	893
	894	DHL_CAP_Init();
	895
	896	if (g_dhlcap.isCapMainVideoStarted == 0)
	897	{
	898	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"skipped.\n");
	899	return dhlResult;
	900	}
	901
	902	g_dhlcap.isCapMainVideoStarted = 0;
	903	g_dhlcap.CapInMainVideoSrc = DHL_CAP_VIDEO_NONE;
	904
	905	dhlResult = DHL_CAP_CC_Stop();
	906	SysASSERT( dhlResult == DHL_OK );
	907
	908	dhlResult = DD_CAP_StopVideo();
	909	SysASSERT( dhlResult == DHL_OK );
	910
	911	dhlResult = Stop_VI_Thread(0);
	912	SysASSERT( dhlResult == DHL_OK );
	913
	914	SysENSURE( dhlResult == DHL_OK );
	915
	916	return dhlResult;
	917	}
	918
	919	DHL_RESULT DHL_CAP_StopVideoEx(void)
	920	{
	921	DHL_RESULT dhlResult = DHL_OK;
	922
	923	DHL_CAP_Init();
	924
	925	dhlResult = DHL_CAP_StopVideo();
	926	SysASSERT( dhlResult == DHL_OK );
	927
	928	dhlResult = DHL_CAP_StopVideoPIP();
	929	SysASSERT( dhlResult == DHL_OK );
	930
	931	SysENSURE( dhlResult == DHL_OK );
	932
	933	return dhlResult;
	934	}
	935
	936	DHL_RESULT DHL_CAP_StartVideoPIP(void)
	937	{
	938	DHL_RESULT dhlResult = DHL_OK;
	939
	940	DHL_CAP_Init();
	941
	942	if (g_dhlcap.isCapSubVideoStarted == 1)
	943	{
	944	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"skipped.\n");
	945	return dhlResult;
	946	}
	947
	948	if (DHL_CAP_GetVideoSrc(1) < DHL_CAP_DTV_VIDEO_START \|\| DHL_CAP_GetVideoSrc(1) >= DHL_CAP_VIDEO_END)
	949	{
	950	printf("\|%s\| Invalid input source: %d\n", __FUNCTION__, DHL_CAP_GetVideoSrc(1));
	951	return DHL_FAIL;
	952	}
	953
	954	if ( g_dhlcap.isCapMainVideoStarted == 1 )
	955	{
	956	if ( CheckPIPCombination( DHL_CAP_GetVideoSrc(0), DHL_CAP_GetVideoSrc(1) ) == 0 )
	957	{
	958	printf("\|%s\| ERROR: Invalid PIP combination, mainSrc=%d, subSrc=%d\n", __FUNCTION__, DHL_CAP_GetVideoSrc(0), DHL_CAP_GetVideoSrc(1));
	959	return DHL_FAIL;
	960	}
	961	}
	962
	963	g_dhlcap.isCapSubVideoStarted = 1;
	964
	965	DHL_PIC_UpdateNextParam();
	966
	967	DumpVideoInput();
	968
	969	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"\|%s\| AspectRatio = %s (%d)\n", __FUNCTION__,
	970	DHL_DISP_GetDispAspect() == DHL_DISP_ASPECT_1_1 ? "1:1" :
	971	DHL_DISP_GetDispAspect() == DHL_DISP_ASPECT_4_3 ? "4:3 Normal" :
	972	DHL_DISP_GetDispAspect() == DHL_DISP_ASPECT_16_9 ? "16:9 Normal" :
	973	DHL_DISP_GetDispAspect() == DHL_DISP_ASPECT_ZOOM1 ? "ZOOM1" :
	974	DHL_DISP_GetDispAspect() == DHL_DISP_ASPECT_ZOOM2 ? "ZOOM2" :
	975	DHL_DISP_GetDispAspect() == DHL_DISP_ASPECT_PANO ? "Panorama" :
	976	DHL_DISP_GetDispAspect() == DHL_DISP_EPG ? "EPG" : "Unknown", DHL_DISP_GetDispAspect());
	977
	978	dhlResult = DD_CAP_StartVideoPIP();
	979	if(DHL_ERROR(dhlResult))
	980	DHL_DbgPrintf(0,DHLDBG_CAP,"\|error\|%d(0x%x)\r\n",__LINE__,dhlResult);
	981
	982	dhlResult = Start_VI_Thread(1);
	983	if(DHL_ERROR(dhlResult))
	984	DHL_DbgPrintf(0,DHLDBG_CAP,"\|error\|%d(0x%x)\r\n",__LINE__,dhlResult);
	985
	986	if(!DHL_ERROR(dhlResult))
	987	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"\|success\|\r\n");
	988
	989	return dhlResult;
	990	}
	991
	992	DHL_RESULT DHL_CAP_StopVideoPIP(void)
	993	{
	994	DHL_RESULT dhlResult = DHL_OK;
	995
	996	DHL_CAP_Init();
	997
	998	if ( g_dhlcap.isCapSubVideoStarted == 0 ) {
	999	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"skipped.\n");
	1000	return dhlResult;
	1001	}
	1002
	1003	g_dhlcap.isCapSubVideoStarted = 0;
	1004	g_dhlcap.CapInSubVideoSrc = DHL_CAP_VIDEO_NONE;
	1005
	1006	dhlResult = DD_CAP_StopVideoPIP();
	1007	if(DHL_ERROR(dhlResult))
	1008	DHL_DbgPrintf(0,DHLDBG_CAP,"\|error\|%d(0x%x)\r\n",__LINE__,dhlResult);
	1009
	1010	dhlResult = Stop_VI_Thread(1);
	1011	if(DHL_ERROR(dhlResult))
	1012	DHL_DbgPrintf(0,DHLDBG_CAP,"\|error\|%d(0x%x)\r\n",__LINE__,dhlResult);
	1013
	1014	if(!DHL_ERROR(dhlResult))
	1015	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"\|success\|\r\n");
	1016
	1017	return dhlResult;
	1018	}
	1019
	1020	/********************************************************************************
	1021	FUNCTION:
	1022	DHL_CAP_ChangeVideoFormat
	1023
	1024	Purpose:
	1025	change input video format (480i,480p,720p,1080i)
	1026	Arguments:
	1027	[in] Focus - 0 for Main / 1 for Sub
	1028
	1029	Returns:
	1030	DHL_RESULT success - DHL_OK, fail - DHL_FAIL
	1031	*********************************************************************************/
	1032	DHL_RESULT DHL_CAP_ChangeVideoFormat(DHL_VIDEO_FORMAT UserVideoFormat, DS_BOOL Update, DS_BOOL Focus)
	1033	{
	1034	DHL_RESULT dhlResult = DHL_OK;
	1035
	1036	return dhlResult;
	1037	}
	1038
	1039	/********************************************************************************
	1040	FUNCTION:
	1041	DHL_CAP_ChangeVideoSource
	1042
	1043	Purpose:
	1044	change input video source
	1045	Arguments:
	1046	[in] Focus - 0 for Main / 1 for Sub
	1047
	1048	Returns:
	1049	DHL_RESULT success - DHL_OK, fail - DHL_FAIL
	1050	*********************************************************************************/
	1051	DHL_RESULT DHL_CAP_ChangeVideoSource(DHL_CAP_VIDEO_INPUT VideoInputSrc)
	1052	{
	1053	DHL_RESULT dhlResult = DHL_OK;
	1054
	1055	//dhlResult = DD_CAP_SetInputVidSource(VideoInputSrc,_FALSE_);
	1056	if ( g_dhlcap.CapInMainVideoSrc == VideoInputSrc ) {
	1057	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"skipped.\n");
	1058	return dhlResult;
	1059	}
	1060
	1061	if ( g_dhlcap.isCapSubVideoStarted == 1 ) {
	1062	if ( CheckPIPCombination( VideoInputSrc, DHL_CAP_GetVideoSrc(1) ) == 0 ) {
	1063	printf("\|%s\| ERROR: Invalid PIP combination, mainSrc=%d, subSrc=%d\n", __FUNCTION__, VideoInputSrc, DHL_CAP_GetVideoSrc(1));
	1064	return DHL_FAIL;
	1065	}
	1066	}
	1067
	1068	if ( DHL_CAP_IsStartedVideo() ) {
	1069	dhlResult = DHL_CAP_StopVideo();
	1070	if ( dhlResult != DHL_OK )
	1071	return dhlResult;
	1072	g_dhlcap.CapInMainVideoSrc = VideoInputSrc;
	1073	dhlResult = DHL_CAP_StartVideo();
	1074	if ( dhlResult != DHL_OK )
	1075	return dhlResult;
	1076	} else
	1077	g_dhlcap.CapInMainVideoSrc = VideoInputSrc;
	1078	DumpVideoInput();
	1079	return dhlResult;
	1080	}
	1081
	1082	DHL_RESULT DHL_CAP_ChangeVideoSourcePIP(DHL_CAP_VIDEO_INPUT VideoInputSrc)
	1083	{
	1084	DHL_RESULT dhlResult = DHL_OK;
	1085
	1086	//dhlResult = DD_CAP_SetInputVidSource(VideoInputSrc,_FALSE_);
	1087	if ( g_dhlcap.CapInSubVideoSrc == VideoInputSrc ) {
	1088	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"skipped.\n");
	1089	return dhlResult;
	1090	}
	1091
	1092	if ( g_dhlcap.isCapMainVideoStarted == 1 ) {
	1093	if ( CheckPIPCombination( DHL_CAP_GetVideoSrc(0), VideoInputSrc ) == 0 ) {
	1094	printf("\|%s\| ERROR: Invalid PIP combination, mainSrc=%d, subSrc=%d\n", __FUNCTION__, DHL_CAP_GetVideoSrc(0), VideoInputSrc);
	1095	return DHL_FAIL;
	1096	}
	1097	}
	1098
	1099	if ( DHL_CAP_IsStartedVideoPIP() ) {
	1100	dhlResult = DHL_CAP_StopVideoPIP();
	1101	if ( dhlResult != DHL_OK )
	1102	return dhlResult;
	1103
	1104	g_dhlcap.CapInSubVideoSrc = VideoInputSrc;
	1105
	1106	dhlResult = DHL_CAP_StartVideoPIP();
	1107	if ( dhlResult != DHL_OK )
	1108	return dhlResult;
	1109	} else
	1110	g_dhlcap.CapInSubVideoSrc = VideoInputSrc;
	1111
	1112	DumpVideoInput();
	1113
	1114	return dhlResult;
	1115	}
	1116
	1117	/********************************************************************************
	1118	FUNCTION:
	1119	DHL_CAP_SetBackgroundColour
	1120	Purpose:
	1121
	1122	Arguments:
	1123	[in] Focus - 0 for Main / 1 for Sub
	1124
	1125	Returns:
	1126	DHL_RESULT
	1127	Notes:
	1128	*********************************************************************************/
	1129	DHL_RESULT DHL_CAP_SetBackgroundColour( P_DHL_RGB_TRIPLET pRgb, P_DHL_RECT pRect, DS_BOOL Focus )
	1130	{
	1131	DHL_RESULT dhlResult = DHL_OK;
	1132
	1133	//dhlResult = DD_CAP_SetBackgroundColour(pRgb,pRect);
	1134
	1135	return dhlResult;
	1136	}
	1137	/********************************************************************************
	1138	FUNCTION:
	1139	DHL_CAP_VideoMute
	1140
	1141	Purpose:
	1142	Video overlay start/stop
	1143
	1144	Arguments:
	1145	[in] uMute - video mute on(_TRUE_)/off(_FALSE_)
	1146	[in] Focus - 0 for Main / 1 for Sub
	1147
	1148	Returns:
	1149	DHL_RESULT if success - DHL_OK fail - DHL_FAIL
	1150	*********************************************************************************/
	1151	DHL_RESULT DHL_CAP_MuteVideo(DS_BOOL bMute, DS_BOOL Focus)
	1152	{
	1153	DHL_RESULT dhlResult = DHL_OK;
	1154
	1155
	1156	if(DHL_ERROR(dhlResult))
	1157	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"\|error\|%d(0x%x)\r\n",__LINE__,dhlResult);
	1158
	1159	if(!DHL_ERROR(dhlResult))
	1160	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"\|success\|\r\n");
	1161	return dhlResult;
	1162	}
	1163
	1164	/********************************************************************************
	1165	FUNCTION:
	1166	DHL_CAP_GetVideoInputFmt
	1167	Purpose:
	1168
	1169	Arguments:
	1170
	1171	Returns:
	1172	DHL_VIDEO_FORMAT
	1173	*********************************************************************************/
	1174	DHL_VIDEO_FORMAT DHL_CAP_GetVideoInputFmt(DS_BOOL Focus)
	1175	{
	1176	if (Focus == DHL_FOCUS_MAIN)
	1177	return g_dhlcap.CapInMainFmt;
	1178	else
	1179	return g_dhlcap.CapInSubFmt;
	1180	}
	1181
	1182	DHL_CAP_VIDEO_INPUT DHL_CAP_GetVideoSrc(DS_BOOL Focus)
	1183	{
	1184	if (Focus == DHL_FOCUS_MAIN)
	1185	return g_dhlcap.CapInMainVideoSrc;
	1186	else
	1187	return g_dhlcap.CapInSubVideoSrc;
	1188	}
	1189
	1190	DS_BOOL DHL_CAP_IsStartedVideo(void)
	1191	{
	1192	return g_dhlcap.isCapMainVideoStarted;
	1193	}
	1194
	1195	DS_BOOL DHL_CAP_IsStartedVideoPIP(void)
	1196	{
	1197	return g_dhlcap.isCapSubVideoStarted;
	1198	}
	1199
	1200	/********************************************************************************
	1201	FUNCTION:
	1202	DHL_CAP_IsVideoSrcSD
	1203	Purpose:
	1204
	1205	Arguments:
	1206
	1207	Returns:
	1208	*********************************************************************************/
	1209	DS_BOOL DHL_CAP_IsVideoSrcSD(void)
	1210	{
	1211	DHL_VIDEO_FORMAT CurVidFmt = (DHL_VIDEO_FORMAT)0;
	1212
	1213	//CurVidFmt = DD_CAP_GetCurrentVidFmt();
	1214	CurVidFmt = CurVidFmt;
	1215
	1216	if(CurVidFmt == DHL_VIDEO_720p \|\| CurVidFmt == DHL_VIDEO_1080i)
	1217	return _FALSE_;
	1218	else
	1219	return _TRUE_;
	1220	}
	1221
	1222	DS_BOOL DHL_CAP_IsCVBSInput(DHL_CAP_VIDEO_INPUT vi)
	1223	{
	1224	#if 0
	1225	switch(vi) {
	1226	case DHL_CAP_CVBS0_VIDEO:
	1227	case DHL_CAP_SVIDEO0_VIDEO:
	1228	return DHL_SYS_GetGPIO( GPIO_AV1_DET ) == 1;
	1229
	1230	case DHL_CAP_CVBS1_VIDEO:
	1231	case DHL_CAP_SVIDEO1_VIDEO:
	1232	return DHL_SYS_GetGPIO( GPIO_AV2_DET ) == 1;
	1233
	1234	default:
	1235	return 1;
	1236	}
	1237	#endif
	1238	/* In default, CVBS */
	1239	return 1;
	1240	}
	1241
	1242	DHL_RESULT DHL_CAP_IsHDMIInput(DS_BOOL *bHDMI)
	1243	{
	1244	return DD_CAP_IsHDMIMode(bHDMI);
	1245	}
	1246
	1247	DHL_RESULT DHL_CAP_GetVideoTiming(DS_BOOL bFocus, DS_U16 phRes, DS_U16 pvRes, DS_U16 pRefreshRate, DS_BOOL pbInterlaced)
	1248	{
	1249	DHL_RESULT dhlResult = DHL_OK;
	1250
	1251	dhlResult = DD_CAP_GetVideoTiming(bFocus, phRes, pvRes, pRefreshRate, pbInterlaced);
	1252
	1253	return dhlResult;
	1254	}
	1255
	1256
	1257	/********************************************************************************
	1258	FUNCTION:
	1259	DHL_DTV_SetPIPMode
	1260
	1261	Purpose:
	1262
	1263	Arguments:
	1264	[in] bPIPMode
	1265	[in] bPOPMode
	1266	Returns:
	1267	DHL_RESULT if success - DHL_OK fail - DHL_FAIL
	1268	*********************************************************************************/
	1269	DHL_RESULT DHL_CAP_SetPIPMode( DHL_PIPMode_t PipMode , DHL_PIP_t pipPos )
	1270	{
	1271	DHL_RESULT dhlResult = DHL_OK;
	1272
	1273	g_dhlcap.pipMode = PipMode;
	1274	g_dhlcap.pipPosition = pipPos;
	1275
	1276	//
	1277	// Lower driver function shall be called here.
	1278	//
	1279	dhlResult = DD_DISP_SetPIPStyle( PipMode, pipPos );
	1280	if(DHL_ERROR(dhlResult))
	1281	DHL_DbgPrintf(0,DHLDBG_CAP,"\|error\|%d(0x%x)\r\n",__LINE__,dhlResult);
	1282
	1283	return dhlResult;
	1284	}
	1285
	1286	/********************************************************************************
	1287	FUNCTION:
	1288	DHL_DTV_SetPIPPosition
	1289
	1290	Purpose:
	1291
	1292	Arguments:
	1293	[in] popPos
	1294	[in] pipPos
	1295
	1296	Returns:
	1297	DHL_RESULT if success - DHL_OK fail - DHL_FAIL
	1298	*********************************************************************************/
	1299	DHL_RESULT DHL_CAP_SetPIPPosition( DHL_PIP_t pipPos )
	1300	{
	1301	DHL_RESULT dhlResult = DHL_OK;
	1302
	1303	g_dhlcap.pipPosition = pipPos;
	1304
	1305	//
	1306	// Lower driver function shall be called here.
	1307	//
	1308	dhlResult = DD_DISP_SetPIPLocation( pipPos );
	1309	if(DHL_ERROR(dhlResult))
	1310	DHL_DbgPrintf(0,DHLDBG_CAP,"\|error\|%d(0x%x)\r\n",__LINE__,dhlResult);
	1311
	1312	return dhlResult;
	1313	}
	1314
	1315	void DHL_CAP_SetSyncLock(int En)
	1316	{
	1317	DD_CAP_SetSyncLock(En);
	1318	}
	1319
	1320	void DHL_CAP_SetSyncLockEnable(int En)
	1321	{
	1322	g_dhlcap.SyncLockEnable = En;
	1323	DD_CAP_SetSyncLockEnable(En);
	1324	}
	1325
	1326	int DHL_CAP_GetSyncLockEnable(void)
	1327	{
	1328	return g_dhlcap.SyncLockEnable;
	1329	}
	1330
	1331	void DHL_CAP_ClearSyncLockOnMute(int En)
	1332	{
	1333	g_dhlcap.SyncLockOnMute = En;
	1334	DD_CAP_ClearSyncLockOnMute(En);
	1335	}
	1336
	1337	DS_U16 DHL_CAP_GetSignalNoise(void)
	1338	{
	1339	return DD_CAP_GetSignalNoise();
	1340	}
	1341
	1342	void DHL_CAP_SetAdaptiveNR(void)
	1343	{
	1344	DD_CAP_SetAdaptiveNR();
	1345	}
	1346
	1347	void DHL_CAP_GetHDMIFmt(DS_U32 phActive, DS_U32 phTotal, DS_U32 pvActive, DS_U32 pvTotal)
	1348	{
	1349	DD_CAP_GetHDMIFmt(phActive, phTotal, pvActive, pvTotal);
	1350	}
	1351
	1352	void DHL_CAP_GetRGBFmt(DS_U16 pwHR, DS_U16 pwVR, DS_U16 pwHW, DS_U16 pwVW, DS_U16 *pwPol)
	1353	{
	1354	DD_CAP_GetRGBFmt(pwHR, pwVR, pwHW, pwVW, pwPol);
	1355	}
	1356
	1357	//
	1358	// DHL_CAP_SetHPDEnable()
	1359	// HPD¸¦ »ç¿ëÇÒ Áö ¿©ºÎ¸¦ ¼±ÅÃÇÏ´Â ÇÔ¼ö.
	1360	// HDMI-TX°¡ ¿¬°áµÇÁö ¾Ê¾ÒÀ¸¸é, HDMI-RXµµ ¿¬°áµÇÁö ¾Êµµ·Ï ÇÏ±â À§ÇÔ.
	1361	//
	1362	void DHL_CAP_SetHPDEnable(int En)
	1363	{
	1364	g_HPDEnable = En;
	1365	DD_SYS_SetGPIODefault( GPIO_HDMI_HPD );
	1366	}
	1367
	1368	int DHL_CAP_GetHPDEnable(void)
	1369	{
	1370	return g_HPDEnable;
	1371	}
	1372
	1373	DHL_RESULT DHL_CAP_GetSrcVideoInfo(P_DHL_DTV_SRCVID_INFO pSrcInfo)
	1374	{
	1375	DHL_RESULT dhlResult = DHL_OK;
	1376
	1377	return dhlResult;
	1378	}
	1379
	1380
	1381	#if 0
	1382	___Audio_Capture_APIs___()
	1383	#endif
	1384	DHL_RESULT DHL_CAP_StartAudio(void)
	1385	{
	1386	DHL_RESULT dhlResult = DHL_OK;
	1387
	1388	if ( DHL_CAP_IsStartedAudio() == 1 )
	1389	{
	1390	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"skipped.\n");
	1391	return dhlResult;
	1392	}
	1393
	1394	if ( DHL_DTV_IsAVStarted() == _TRUE_ )
	1395	DHL_DTV_StopAudio();
	1396
	1397	dhlResult = DHL_AUD_VolumeFadeInOut_I2S(0);
	1398	SysASSERT( dhlResult == DHL_OK );
	1399
	1400	dhlResult = DD_CAP_StartAudio();
	1401	SysASSERT( dhlResult == DHL_OK );
	1402
	1403	OS_mDelay( Popup_StartDelay );
	1404
	1405	dhlResult = DHL_AUD_VolumeFadeInOut_I2S(1);
	1406	SysASSERT( dhlResult == DHL_OK );
	1407
	1408	DumpAudioInput();
	1409
	1410	g_dhlcap.isCapAudioStarted = 1;
	1411
	1412	SysENSURE( dhlResult == DHL_OK );
	1413
	1414	return dhlResult;
	1415	}
	1416
	1417	DHL_RESULT DHL_CAP_StopAudio(void)
	1418	{
	1419	DHL_RESULT dhlResult = DHL_OK;
	1420
	1421	if ( DHL_CAP_IsStartedAudio() == 0 )
	1422	{
	1423	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"skipped.\n");
	1424	return dhlResult;
	1425	}
	1426
	1427	dhlResult = DHL_AUD_VolumeFadeInOut_I2S(0);
	1428	SysASSERT( dhlResult == DHL_OK );
	1429
	1430	OS_mDelay(Popup_EndDelay);
	1431
	1432	dhlResult = DD_CAP_StopAudio();
	1433	SysASSERT( dhlResult == DHL_OK );
	1434
	1435	g_dhlcap.isCapAudioStarted = 0;
	1436
	1437	SysENSURE( dhlResult == DHL_OK );
	1438
	1439	return dhlResult;
	1440	}
	1441
	1442	/********************************************************************************
	1443	FUNCTION:
	1444	DHL_CAP_ChangeAudioFs
	1445
	1446	Purpose:
	1447	change input audio sampling frequency (22.05, 24.00, 44.10, 48.00, 96.00 KHz)
	1448	Arguments:
	1449
	1450	Returns:
	1451	DHL_RESULT success - DHL_OK, fail - DHL_FAIL
	1452	*********************************************************************************/
	1453	DHL_RESULT DHL_CAP_ChangeAudioFs(DHL_SAMPLING_RATE UserFs, DS_BOOL Update)
	1454	{
	1455	DHL_RESULT dhlResult = DHL_OK;
	1456
	1457	g_dhlcap.CapFs = UserFs;
	1458
	1459	return dhlResult;
	1460	}
	1461
	1462	/********************************************************************************
	1463	FUNCTION:
	1464	DHL_CAP_ChangeAudioSource
	1465
	1466	Purpose:
	1467	change input audio source (UOC3 or External)
	1468	Arguments:
	1469
	1470	Returns:
	1471	DHL_RESULT success - DHL_OK , fail - DHL_FAIL
	1472	*********************************************************************************/
	1473	DHL_RESULT DHL_CAP_ChangeAudioInput(DHL_CAP_AUDIO_INPUT AudioInputSrc)
	1474	{
	1475	DHL_RESULT dhlResult = DHL_OK;
	1476
	1477	if ( DHL_CAP_IsStartedAudio() ) {
	1478	dhlResult = DHL_CAP_StopAudio();
	1479	if ( dhlResult != DHL_OK ) {
	1480	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"ERROR, LINE=%d\n", __LINE__);
	1481	goto done;
	1482	}
	1483
	1484	g_dhlcap.CapInAudioSrc = AudioInputSrc;
	1485
	1486	dhlResult = DHL_CAP_StartAudio();
	1487	if ( dhlResult != DHL_OK ) {
	1488	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"ERROR, LINE=%d\n", __LINE__);
	1489	goto done;
	1490	}
	1491	} else {
	1492
	1493	g_dhlcap.CapInAudioSrc = AudioInputSrc;
	1494
	1495	// dhlResult = DHL_CAP_StartAudio();
	1496	// if ( dhlResult != DHL_OK ) {
	1497	// DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"ERROR, LINE=%d\n", __LINE__);
	1498	// goto done;
	1499	// }
	1500	}
	1501	DumpAudioInput();
	1502
	1503	done:
	1504	return dhlResult;
	1505	}
	1506
	1507	/********************************************************************************
	1508	FUNCTION:
	1509	DHL_CAP_GetAudioSrc
	1510	Purpose:
	1511	capture audio source's source location - HDMI,YPbPR,UOC..?
	1512	Arguments:
	1513
	1514	Returns:
	1515	DHL_CAP_AUDIO_INPUT
	1516	*********************************************************************************/
	1517	DHL_CAP_AUDIO_INPUT DHL_CAP_GetAudioSrc(void)
	1518	{
	1519	return g_dhlcap.CapInAudioSrc;
	1520	}
	1521
	1522	/********************************************************************************
	1523	FUNCTION:
	1524	DHL_CAP_IsStartedAudio
	1525	Purpose:
	1526
	1527	Arguments:
	1528
	1529	Returns:
	1530	DHL_RESULT success - DHL_OK, fail - DHL_FAIL
	1531	*********************************************************************************/
	1532	DS_BOOL DHL_CAP_IsStartedAudio(void)
	1533	{
	1534	return (g_dhlcap.isCapAudioStarted == 1);
	1535	}
	1536
	1537	/********************************************************************************
	1538	FUNCTION:
	1539	DHL_CAP_SetAudioDelay
	1540	Purpose:
	1541
	1542	Arguments:
	1543	[IN] offset - delay time (ms)
	1544	Returns:
	1545	DHL_RESULT success - DHL_OK, fail - DHL_FAIL
	1546	*********************************************************************************/
	1547	DHL_RESULT DHL_CAP_SetAudioDelay(DS_U32 offset)
	1548	{
	1549	DHL_RESULT dhlResult = DHL_OK;
	1550
	1551	// JFET20040812
	1552	// To Do - calculate delay time for audio si buffer offset
	1553	// tempopary value
	1554	offset = offset * 128;
	1555
	1556	g_dhlcap.iAudDelay = offset;
	1557
	1558	if(!DHL_ERROR(dhlResult))
	1559	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP," \|success\| set audio delay offset (%d) \r\n",offset/128);
	1560	return dhlResult;
	1561
	1562	}
	1563
	1564	/********************************************************************************
	1565	FUNCTION:
	1566	DHL_CAP_AudioRestart
	1567	Purpose:
	1568
	1569	Arguments:
	1570
	1571	Returns:
	1572	DHL_RESULT success - DHL_OK, fail - DHL_FAIL
	1573	Note:
	1574	JFET_20050312 \| ADD Log
	1575	- FADO using the separated mute control between I2S0 and SPDIF
	1576	- This function not used ATI API(ATI not support yet this feature)
	1577	- So I used the 'I2So_Stop' substitute for ths 'I2SO_Mute' for mute I2So.
	1578	- But it has some problems.
	1579	- This API is just workaround for solve the capture audio problem
	1580	*********************************************************************************/
	1581	DHL_RESULT DHL_CAP_RestartAudio(void)
	1582	{
	1583	DHL_RESULT dhlResult = DHL_OK;
	1584	dhlResult \|= DHL_CAP_StopAudio(); //capture audio stop
	1585	dhlResult \|= DHL_CAP_StartAudio(); //capture audio start
	1586	dhlResult \|= DHL_CAP_SetAudioDelay(46); //audio delay 10ms
	1587	if(!DHL_ERROR(dhlResult))
	1588	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP," \|success\| capture audio components restarted\r\n");
	1589	return dhlResult;
	1590	}
	1591
	1592	DHL_RESULT DHL_CAP_SetAudioInFrequency(int audInFreq)
	1593	{
	1594	return DD_CAP_SetAudioInFrequency(audInFreq);
	1595	}
	1596
	1597	int DHL_CAP_GetAudioInFrequency(void)
	1598	{
	1599	return 0;
	1600	}
	1601
	1602	#if 0
	1603	___Video_Input_Thread___ ()
	1604	#endif
	1605	#define VI_THREAD_DELAY 50
	1606	#define VI_THREAD_PRIORITY 150
	1607	#define VI_THREAD_STACKSIZE 32768
	1608
	1609	static DS_BOOL bThreadActive = _FALSE_;
	1610	static DS_BOOL bThreadActiveReq = _FALSE_;
	1611	static DS_U32 viThreadId = (DS_U32)0;
	1612
	1613	DHL_CAP_VideoTiming_t PrevVideoTiming, PrevVideoTimingPIP;
	1614	static void DHL_CAP_MonitorThread(DS_U32 arg)
	1615	{
	1616	DHL_CAP_VIDEO_INPUT vi;
	1617	DS_BOOL bInterlaced;
	1618	DS_U16 hRes, vRes, RefreshRate;
	1619	DHL_RESULT dhlResult = DHL_OK;
	1620	DHL_DTV_SRCVID_INFO info;
	1621	DHL_CAP_SRCASPECTRATIO Aspect = 0;
	1622	static DHL_DEV_CARD_STATUS l_status = 0;
	1623	DHL_DEV_CARD_STATUS c_status = 0;
	1624	extern void AudioLipSync(void);
	1625	extern char tdHDMISourceAspect(void);
	1626	extern unsigned char HDMI_RX_Get_Aspect(void);
	1627
	1628	while(1) {
	1629	if (bThreadActiveReq == _FALSE_)
	1630	{
	1631	DHL_DEV_GetCARDStatus(&c_status);
	1632	if(c_status != l_status)
	1633	{
	1634	if(g_CardCallback)
	1635	{
	1636	g_CardCallback(c_status);
	1637	l_status = c_status;
	1638	}
	1639	}
	1640	OS_mDelay(VI_THREAD_DELAY);
	1641	bThreadActive = _FALSE_;
	1642	continue;
	1643	}
	1644	bThreadActive = _TRUE_;
	1645	DHL_DEV_GetCARDStatus(&c_status);
	1646	if(c_status != l_status)
	1647	{
	1648	if(g_CardCallback)
	1649	{
	1650	g_CardCallback(c_status);
	1651	l_status = c_status;
	1652	}
	1653	}
	1654	if ( DHL_CAP_IsStartedVideo() && DD_CAP_IsInputSrcValid(0) )
	1655	{
	1656	vi = DHL_CAP_GetVideoSrc(0);
	1657	dhlResult = DHL_CAP_GetVideoTiming( 0/Main/, &hRes, &vRes, &RefreshRate, &bInterlaced );
	1658	if (dhlResult != DHL_OK)
	1659	{
	1660	printf("\|%s\| ERROR, LINE=%d\n", __FUNCTION__, __LINE__);
	1661	continue;
	1662	}
	1663
	1664	/*
	1665	* Retrieve source aspect ratio.
	1666	* DTV is from sequence header, HDMI is from AVI frame.
	1667	*/
	1668	Aspect = 0;
	1669	if ( DHL_IsVideoSourceDTV(vi) )
	1670	{
	1671	DHL_DTV_GetSrcVideoInfo(&info);
	1672	Aspect = (DHL_CAP_SRCASPECTRATIO)info.AspectRatio;
	1673	}
	1674	else if ( DHL_IsVideoSourceHDMI(vi) )
	1675	{
	1676	DHL_CAP_GetSrcVideoInfo(&info);
	1677	Aspect = (DHL_CAP_SRCASPECTRATIO)info.AspectRatio;
	1678	}
	1679
	1680	if ( vi != PrevVideoTiming.vi \|\| PrevVideoTiming.hRes != hRes \|\| PrevVideoTiming.vRes != vRes \|\|
	1681	PrevVideoTiming.bInterlaced != bInterlaced \|\| PrevVideoTiming.RefreshRate != RefreshRate \|\| PrevVideoTiming.Aspect != Aspect)
	1682	{
	1683	//
	1684	// Workaround: Source ÀüÈ¯ Á÷ÈÄ 3ÃÊ µ¿¾È È¸éÀ» º¸ÀÌÁö ¸»ÀÚ.
	1685	//
	1686	if ( (hRes && hRes != (DS_U16)-1) && (vRes && vRes != (DS_U16)-1) && (vi == DHL_CAP_YPBPR0_VIDEO \|\| vi == DHL_CAP_YPBPR1_VIDEO) ) {
	1687	if ( (OS_GetTickCount() - g_SourceChangeTime) < 300 ) {
	1688	continue;
	1689	}
	1690	}
	1691
	1692	if ( vi == DHL_CAP_DTV0_VIDEO && DHL_DTV_IsVideoStarted() )
	1693	{
	1694	if ( (hRes && hRes != (DS_U16)-1) && (vRes && vRes != (DS_U16)-1) )
	1695	{
	1696	if (DHL_CAP_IsStartedVideoPIP())
	1697	DHL_PIC_SetNR(0/OFF/);
	1698	else
	1699	DHL_PIC_SetNR(DHL_PIC_GetNR());
	1700
	1701	if ( !DHL_DMX_IsScrambleCheckStarted() )
	1702	{
	1703	SysCHECK( DHL_DTV_DoCallback( DHL_CB_NOTIFY_VSTARTING, 0 ) == DHL_OK );
	1704	}
	1705	}
	1706	else
	1707	{
	1708	//
	1709	// 720p -> 1080i µîÀ¸·Î ÇØ»óµµ º¯°æ ½Ã, ÀÌÀü ÇØ»óµµÀÇ È¸éÀÌ ³²¾ÆÀÖ´Â ¹®Á¦.
	1710	//
	1711	DHL_PIC_SetNR(0/OFF/);
	1712	}
	1713	}
	1714
	1715	switch(vi)
	1716	{
	1717	case DHL_CAP_ATV0_VIDEO:
	1718	if (!DHL_DISP_IsVideoMuted())
	1719	DD_DISP_VideoMute(0);
	1720	break;
	1721
	1722	case DHL_CAP_DTV0_VIDEO:
	1723	case DHL_CAP_YPBPR0_VIDEO:
	1724	case DHL_CAP_YPBPR1_VIDEO:
	1725	case DHL_CAP_HDMI0_VIDEO:
	1726	case DHL_CAP_HDMI1_VIDEO:
	1727	case DHL_CAP_HDMI2_VIDEO:
	1728	DHL_PIC_SetAutoMovieMode(DHL_PIC_GetAutoMovieMode());
	1729	if ( vRes != (DS_U16)-1 && vRes >= 720 )
	1730	{ /* 720p or higher */
	1731	if (DHL_CAP_IsStartedVideoPIP())
	1732	DHL_PIC_SetNR(0/OFF/);
	1733	}
	1734	else
	1735	{
	1736	DHL_PIC_SetNR(DHL_PIC_GetNR()/OFF/);
	1737	}
	1738	break;
	1739
	1740	default:
	1741	break;
	1742	}
	1743
	1744	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"\|tCapMonitor\| %s, VideoInput:%s(%d), (%d x %d %c @ %d Hz)\n", "Main",
	1745	vi == DHL_CAP_DTV0_VIDEO ? "DTV0" :
	1746	vi == DHL_CAP_DTV1_VIDEO ? "DTV1" :
	1747	vi == DHL_CAP_ATV0_VIDEO ? "ATV0" :
	1748	vi == DHL_CAP_ATV1_VIDEO ? "ATV1" :
	1749	vi == DHL_CAP_CVBS0_VIDEO ? "CVBS0" :
	1750	vi == DHL_CAP_CVBS1_VIDEO ? "CVBS1" :
	1751	vi == DHL_CAP_CVBS2_VIDEO ? "CVBS2" :
	1752	vi == DHL_CAP_CVBS3_VIDEO ? "CVBS3" :
	1753	vi == DHL_CAP_SVIDEO0_VIDEO ? "SVIDEO0" :
	1754	vi == DHL_CAP_SVIDEO1_VIDEO ? "SVIDEO1" :
	1755	vi == DHL_CAP_SVIDEO2_VIDEO ? "SVIDEO2" :
	1756	vi == DHL_CAP_SVIDEO3_VIDEO ? "SVIDEO3" :
	1757	vi == DHL_CAP_VGA0_VIDEO ? "VGA0" :
	1758	vi == DHL_CAP_VGA1_VIDEO ? "VGA1" :
	1759	vi == DHL_CAP_YPBPR0_VIDEO ? "YPBPR0" :
	1760	vi == DHL_CAP_YPBPR1_VIDEO ? "YPBPR1" :
	1761	vi == DHL_CAP_YPBPR2_VIDEO ? "YPBPR2" :
	1762	vi == DHL_CAP_YPBPR3_VIDEO ? "YPBPR3" :
	1763	vi == DHL_CAP_HDMI0_VIDEO ? "HDMI0" :
	1764
	1765	vi == DHL_CAP_HDMI2_VIDEO ? "HDMI2" :
	1766	vi == DHL_CAP_HDMI3_VIDEO ? "HDMI3" : "Unknown", vi, hRes, vRes, bInterlaced ? 'i' : 'p', RefreshRate);
	1767
	1768	if ( DHL_CAP_VGA0_VIDEO == vi )
	1769	{
	1770	if ( vRes == 0 \|\| vRes == (DS_U16)-1 )
	1771	{
	1772	DD_CAP_InvalidateVGACapData();
	1773	}
	1774	}
	1775
	1776	// Call cbFunc.
	1777	if (g_CAP_CBFunc && DD_CAP_IsInputSrcValid(0))
	1778	{
	1779	g_CAP_CBFunc( 0, vi, hRes, vRes, RefreshRate, bInterlaced );
	1780	}
	1781
	1782	if (g_CAP_CBFunc2 && DD_CAP_IsInputSrcValid(0))
	1783	{
	1784	g_CAP_CBFunc2( 0, vi, hRes, vRes, RefreshRate, bInterlaced ,Aspect);
	1785	}
	1786
	1787	switch(vi)
	1788	{
	1789	case DHL_CAP_ATV0_VIDEO:
	1790	case DHL_CAP_CVBS0_VIDEO:
	1791	case DHL_CAP_CVBS1_VIDEO:
	1792	case DHL_CAP_SVIDEO0_VIDEO:
	1793	case DHL_CAP_SVIDEO1_VIDEO:
	1794	case DHL_CAP_YPBPR0_VIDEO:
	1795	DD_CAP_ResetVBI(0);
	1796	//fieldMotion = DD_CAP_GetFieldMotion();
	1797	//frameMotion = DD_CAP_GetFrameMotion();
	1798	//printf("fieldMotion=%d, frameMotion=%d\n", fieldMotion, frameMotion);
	1799	break;
	1800	default:
	1801	break;
	1802	}
	1803	}
	1804
	1805	PrevVideoTiming.vi = vi;
	1806	PrevVideoTiming.hRes = hRes;
	1807	PrevVideoTiming.vRes = vRes;
	1808	PrevVideoTiming.RefreshRate = RefreshRate;
	1809	PrevVideoTiming.bInterlaced = bInterlaced;
	1810	PrevVideoTiming.Aspect = Aspect;
	1811	} /* if ( DHL_CAP_IsStartedVideo() && DD_CAP_IsInputSrcValid(0) ) */
	1812
	1813	if ( DHL_CAP_IsStartedVideoPIP() && DD_CAP_IsInputSrcValid(1) )
	1814	{
	1815	vi = DHL_CAP_GetVideoSrc(1);
	1816	dhlResult = DHL_CAP_GetVideoTiming( 1/Sub/, &hRes, &vRes, &RefreshRate, &bInterlaced );
	1817	if (dhlResult != DHL_OK)
	1818	{
	1819	printf("\|%s\| ERROR, LINE=%d\n", __FUNCTION__, __LINE__);
	1820	continue;
	1821	}
	1822
	1823	/*
	1824	* Retrieve source aspect ratio.
	1825	* DTV is from sequence header, HDMI is from AVI frame.
	1826	*/
	1827	Aspect = 0;
	1828	if ( DHL_IsVideoSourceDTV(vi) )
	1829	{
	1830	DHL_DTV_GetSrcVideoInfo(&info);
	1831	Aspect = (DHL_CAP_SRCASPECTRATIO)info.AspectRatio;
	1832	}
	1833	else if ( DHL_IsVideoSourceHDMI(vi) )
	1834	{
	1835	DHL_CAP_GetSrcVideoInfo(&info);
	1836	Aspect = (DHL_CAP_SRCASPECTRATIO)info.AspectRatio;
	1837	}
	1838
	1839	if ( vi != PrevVideoTimingPIP.vi \|\| PrevVideoTimingPIP.hRes != hRes \|\| PrevVideoTimingPIP.vRes != vRes \|\|
	1840	PrevVideoTimingPIP.bInterlaced != bInterlaced \|\| PrevVideoTimingPIP.RefreshRate != RefreshRate \|\| PrevVideoTimingPIP.Aspect != Aspect)
	1841	{
	1842	if ( vi == DHL_CAP_DTV0_VIDEO && DHL_DTV_IsVideoStarted() )
	1843	{
	1844	if ( (hRes && hRes != (DS_U16)-1) && (vRes && vRes != (DS_U16)-1) )
	1845	{
	1846	if ( !DHL_DMX_IsScrambleCheckStarted() )
	1847	{
	1848	SysCHECK( DHL_DTV_DoCallback( DHL_CB_NOTIFY_VSTARTING, 0 ) == DHL_OK );
	1849	}
	1850	}
	1851	}
	1852
	1853	if ( vi == DHL_CAP_ATV0_VIDEO )
	1854	{
	1855	if (!DHL_DISP_IsVideoMutedPIP())
	1856	DD_DISP_VideoMutePIP(0);
	1857	}
	1858
	1859	// Call cbFunc.
	1860	if (g_CAP_CBFunc && DD_CAP_IsInputSrcValid(1))
	1861	{
	1862	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"\|tCapMonitor\| %s, VideoInput:%s(%d), (%d x %d %c @ %d Hz)\n", "Sub",
	1863	vi == DHL_CAP_DTV0_VIDEO ? "DTV0" :
	1864	vi == DHL_CAP_DTV1_VIDEO ? "DTV1" :
	1865	vi == DHL_CAP_ATV0_VIDEO ? "ATV0" :
	1866	vi == DHL_CAP_ATV1_VIDEO ? "ATV1" :
	1867	vi == DHL_CAP_CVBS0_VIDEO ? "CVBS0" :
	1868	vi == DHL_CAP_CVBS1_VIDEO ? "CVBS1" :
	1869	vi == DHL_CAP_CVBS2_VIDEO ? "CVBS2" :
	1870	vi == DHL_CAP_CVBS3_VIDEO ? "CVBS3" :
	1871	vi == DHL_CAP_SVIDEO0_VIDEO ? "SVIDEO0" :
	1872	vi == DHL_CAP_SVIDEO1_VIDEO ? "SVIDEO1" :
	1873	vi == DHL_CAP_SVIDEO2_VIDEO ? "SVIDEO2" :
	1874	vi == DHL_CAP_SVIDEO3_VIDEO ? "SVIDEO3" :
	1875	vi == DHL_CAP_VGA0_VIDEO ? "VGA0" :
	1876	vi == DHL_CAP_VGA1_VIDEO ? "VGA1" :
	1877	vi == DHL_CAP_YPBPR0_VIDEO ? "YPBPR0" :
	1878	vi == DHL_CAP_YPBPR1_VIDEO ? "YPBPR1" :
	1879	vi == DHL_CAP_YPBPR2_VIDEO ? "YPBPR2" :
	1880	vi == DHL_CAP_YPBPR3_VIDEO ? "YPBPR3" :
	1881	vi == DHL_CAP_HDMI0_VIDEO ? "HDMI0" :
	1882	vi == DHL_CAP_HDMI1_VIDEO ? "HDMI1" :
	1883	vi == DHL_CAP_HDMI2_VIDEO ? "HDMI2" :
	1884	vi == DHL_CAP_HDMI3_VIDEO ? "HDMI3" : "Unknown", vi, hRes, vRes, bInterlaced ? 'i' : 'p', RefreshRate);
	1885
	1886	// Call cbFunc.
	1887	if (g_CAP_CBFunc && DD_CAP_IsInputSrcValid(1))
	1888	g_CAP_CBFunc( 1, vi, hRes, vRes, RefreshRate, bInterlaced );
	1889
	1890	if (g_CAP_CBFunc2 && DD_CAP_IsInputSrcValid(1))
	1891	g_CAP_CBFunc2( 1, vi, hRes, vRes, RefreshRate, bInterlaced ,Aspect);
	1892	}
	1893
	1894	if ( DHL_CAP_VGA0_VIDEO == vi )
	1895	{
	1896	if ( vRes == 0 \|\| vRes == (DS_U16)-1 )
	1897	{
	1898	DD_CAP_InvalidateVGACapData();
	1899	}
	1900	}
	1901
	1902	if ( DHL_CAP_GetVideoSrc(1) == DHL_CAP_VGA0_VIDEO )
	1903	DHL_CAP_SetVGADefault();
	1904
	1905	switch(vi)
	1906	{
	1907	case DHL_CAP_ATV0_VIDEO:
	1908	case DHL_CAP_CVBS0_VIDEO:
	1909	case DHL_CAP_CVBS1_VIDEO:
	1910	case DHL_CAP_SVIDEO0_VIDEO:
	1911	case DHL_CAP_SVIDEO1_VIDEO:
	1912	DD_CAP_ResetVBI(1);
	1913	//fieldMotion = DD_CAP_GetFieldMotion();
	1914	//frameMotion = DD_CAP_GetFrameMotion();
	1915	//printf("fieldMotion=%d, frameMotion=%d\n", fieldMotion, frameMotion);
	1916	break;
	1917	default:
	1918	break;
	1919	}
	1920	} /* ( vi != PrevVideoTimingPIP.vi \|\| PrevVideoTimingPIP.hRes != hRes \|\| PrevVideoTimingPIP.vRes != vRes \|\| ... */
	1921
	1922	PrevVideoTimingPIP.vi = vi;
	1923	PrevVideoTimingPIP.hRes = hRes;
	1924	PrevVideoTimingPIP.vRes = vRes;
	1925	PrevVideoTimingPIP.RefreshRate = RefreshRate;
	1926	PrevVideoTimingPIP.bInterlaced = bInterlaced;
	1927	PrevVideoTimingPIP.Aspect = Aspect;
	1928	} /* ( DHL_CAP_IsStartedVideoPIP() && DD_CAP_IsInputSrcValid(1) ) */
	1929
	1930	OS_mDelay(VI_THREAD_DELAY);
	1931	}
	1932	}
	1933
	1934	static DHL_RESULT Init_VI_Thread(void)
	1935	{
	1936	DHL_RESULT dhlResult = DHL_OK;
	1937
	1938	LOCK_CAP_MUTEX();
	1939
	1940	bThreadActive = _FALSE_;
	1941	bThreadActiveReq = _FALSE_;
	1942	viThreadId = OS_SpawnTask( DHL_CAP_MonitorThread, "tVIMonitor", 0, 4096, (DS_U32)0);
	1943	if ( !viThreadId ) {
	1944	printf("ERROR: Cannot create function tvVIMonitor.\n");
	1945	dhlResult = DHL_FAIL_OUT_OF_RESOURCE;
	1946	}
	1947
	1948	UNLOCK_CAP_MUTEX();
	1949	done:
	1950	return dhlResult;
	1951	}
	1952
	1953	static DHL_RESULT Start_VI_Thread(DS_BOOL bFocus)
	1954	{
	1955	DHL_RESULT dhlResult = DHL_OK;
	1956	volatile DS_U32 timeout;
	1957
	1958	LOCK_CAP_MUTEX();
	1959	if ( bThreadActiveReq && bThreadActive ) {
	1960	UNLOCK_CAP_MUTEX();
	1961	goto done;
	1962	}
	1963	bThreadActiveReq = _TRUE_;
	1964	UNLOCK_CAP_MUTEX();
	1965
	1966	timeout = OS_GetTickCount()+50;
	1967	do {
	1968	if ( bThreadActive == _TRUE_ )
	1969	break;
	1970	OS_mDelay(VI_THREAD_DELAY);
	1971	} while(timeout>OS_GetTickCount());
	1972
	1973	if ( bThreadActive != _TRUE_ && timeout>OS_GetTickCount() )
	1974	dhlResult = DHL_FAIL;
	1975
	1976	done:
	1977	return dhlResult;
	1978	}
	1979
	1980	static DHL_RESULT Stop_VI_Thread(DS_BOOL bFocus)
	1981	{
	1982	DHL_RESULT dhlResult = DHL_OK;
	1983	volatile DS_U32 timeout;
	1984
	1985	LOCK_CAP_MUTEX();
	1986	if ( !bThreadActiveReq && !bThreadActive ) {
	1987	UNLOCK_CAP_MUTEX();
	1988	goto done;
	1989	}
	1990
	1991	//
	1992	// MAIN/PIP Áß ÇÏ³ª¶óµµ ½ÃÀÛµÇ¾î ÀÖÀ¸¸é, Á¤ÁöÇÏÁö ¾Ê´Â´Ù.
	1993	//
	1994	if ( DHL_CAP_IsStartedVideo() \|\| DHL_CAP_IsStartedVideoPIP() ) {
	1995	UNLOCK_CAP_MUTEX();
	1996	goto done;
	1997	}
	1998
	1999	bThreadActiveReq = _FALSE_;
	2000	UNLOCK_CAP_MUTEX();
	2001
	2002	timeout = OS_GetTickCount()+50;
	2003	do {
	2004	if ( bThreadActive == _FALSE_ )
	2005	break;
	2006	OS_mDelay(VI_THREAD_DELAY);
	2007	} while(timeout>OS_GetTickCount());
	2008
	2009	if ( bThreadActive != _FALSE_ && timeout>OS_GetTickCount() )
	2010	dhlResult = DHL_FAIL;
	2011
	2012	done:
	2013	if ( !bFocus )
	2014	memset( &PrevVideoTiming, 0, sizeof(DHL_CAP_VideoTiming_t) );
	2015	else
	2016	memset( &PrevVideoTimingPIP, 0, sizeof(DHL_CAP_VideoTiming_t) );
	2017
	2018	return dhlResult;
	2019	}
	2020
	2021
	2022	#if 0
	2023	___VGA_Functions___()
	2024	#endif
	2025	//////////////////////////////////////////////////////////////////////////////////////
	2026	// VGA Functions
	2027	//
	2028	// Default: ÇöÀç ModeÀÇ ±âº» Á¤ÀÇ°ªÀ¸·Î ¼³Á¤ÇÔ. ÃÊ±â ¼¼ÆÃ ½Ã¿¡ È£ÃâµÇ¾î¾ß ÇÔ.
	2029	// Phase: 0 - 100 (Default:50)
	2030	// Clock: 0 - 100 (Default:50)
	2031	// HSize: 0 - 100 (Default:50)
	2032	// HPosition: 0 - 100 (Default:50)
	2033	// VSize: 0 - 100 (Default:50)
	2034	// VPosition: 0 - 100 (Default:50)
	2035	//
	2036	// AutoAdjustment: TBD. Cancel °¡´ÉÇÑ API¸¦ ÀÛ¼ºÇØ¾ßÇÔ. ÇöÀç Blocking ÇÔ¼öÀÓ.
	2037	//
	2038	//////////////////////////////////////////////////////////////////////////////////////
	2039	DHL_RESULT DHL_CAP_SetVGADefault(void)
	2040	{
	2041	DHL_RESULT dhlResult = DHL_OK;
	2042
	2043	dhlResult = DD_CAP_SetVGADefault();
	2044	if ( dhlResult != DHL_OK )
	2045	printf("\|%s\| failure. (ERR=%d)\n", __FUNCTION__, dhlResult);
	2046
	2047	return dhlResult;
	2048	}
	2049
	2050	DHL_RESULT DHL_CAP_SetVGAPhase(int Param)
	2051	{
	2052	DHL_RESULT dhlResult = DHL_OK;
	2053	static DS_U32 lastChangeTick = 0;
	2054
	2055	if (Param<0 \|\| Param>100) {
	2056	printf("\|%s\| ERROR: Invalid range: %d\n", __FUNCTION__, Param);
	2057	return DHL_FAIL_INVALID_PARAM;
	2058	}
	2059
	2060	//
	2061	// 50 mSec ÀÌ³»¿¡ Á¶Á¤ÇÏ¸é, ±â´Ù¸².
	2062	//
	2063	while ( (OS_GetTickCount() - lastChangeTick) < 5 )
	2064	OS_mDelay(10);
	2065	lastChangeTick = OS_GetTickCount();
	2066
	2067	g_VGAPhase = Param;
	2068	dhlResult = DD_CAP_SetVGAPhase(Param);
	2069	if ( dhlResult != DHL_OK )
	2070	printf("\|%s\| failure. (ERR=%d)\n", __FUNCTION__, dhlResult);
	2071
	2072	return dhlResult;
	2073	}
	2074
	2075	DHL_RESULT DHL_CAP_SetVGAClock(int Param)
	2076	{
	2077	DHL_RESULT dhlResult = DHL_OK;
	2078	static DS_U32 lastChangeTick = 0;
	2079
	2080	if (Param<0 \|\| Param>0x3FF) {
	2081	printf("\|%s\| ERROR: Invalid range: %d\n", __FUNCTION__, Param);
	2082	return DHL_FAIL_INVALID_PARAM;
	2083	}
	2084
	2085	//
	2086	// 50 mSec ÀÌ³»¿¡ Á¶Á¤ÇÏ¸é, ±â´Ù¸².
	2087	//
	2088	while ( (OS_GetTickCount() - lastChangeTick) < 5 )
	2089	OS_mDelay(10);
	2090	lastChangeTick = OS_GetTickCount();
	2091
	2092	g_VGAClock = Param;
	2093	dhlResult = DD_CAP_SetVGAClock(Param);
	2094	if ( dhlResult != DHL_OK )
	2095	printf("\|%s\| failure. (ERR=%d)\n", __FUNCTION__, dhlResult);
	2096
	2097	return dhlResult;
	2098	}
	2099
	2100	DHL_RESULT DHL_CAP_SetVGAHSize(int Param)
	2101	{
	2102	DHL_RESULT dhlResult = DHL_OK;
	2103	static DS_U32 lastChangeTick = 0;
	2104
	2105	if (Param<0 \|\| Param>100) {
	2106	printf("\|%s\| ERROR: Invalid range: %d\n", __FUNCTION__, Param);
	2107	return DHL_FAIL_INVALID_PARAM;
	2108	}
	2109
	2110	//
	2111	// 50 mSec ÀÌ³»¿¡ Á¶Á¤ÇÏ¸é, ±â´Ù¸².
	2112	//
	2113	while ( (OS_GetTickCount() - lastChangeTick) < 5 )
	2114	OS_mDelay(10);
	2115	lastChangeTick = OS_GetTickCount();
	2116
	2117	dhlResult = DD_CAP_SetVGAHSize(Param);
	2118	if ( dhlResult != DHL_OK )
	2119	printf("\|%s\| failure. (ERR=%d)\n", __FUNCTION__, dhlResult);
	2120
	2121	return dhlResult;
	2122	}
	2123
	2124	DHL_RESULT DHL_CAP_SetVGAHPosition(int Param)
	2125	{
	2126	DHL_RESULT dhlResult = DHL_OK;
	2127	static DS_U32 lastChangeTick = 0;
	2128
	2129	if (Param<0 \|\| Param>100) {
	2130	printf("\|%s\| ERROR: Invalid range: %d\n", __FUNCTION__, Param);
	2131	return DHL_FAIL_INVALID_PARAM;
	2132	}
	2133
	2134	//
	2135	// 50 mSec ÀÌ³»¿¡ Á¶Á¤ÇÏ¸é, ±â´Ù¸².
	2136	//
	2137	while ( (OS_GetTickCount() - lastChangeTick) < 5 )
	2138	OS_mDelay(10);
	2139	lastChangeTick = OS_GetTickCount();
	2140
	2141	dhlResult = DD_CAP_SetVGAHPosition(Param);
	2142	if ( dhlResult != DHL_OK )
	2143	printf("\|%s\| failure. (ERR=%d)\n", __FUNCTION__, dhlResult);
	2144
	2145	return dhlResult;
	2146	}
	2147
	2148	DHL_RESULT DHL_CAP_SetVGAVSize(int Param)
	2149	{
	2150	DHL_RESULT dhlResult = DHL_OK;
	2151	static DS_U32 lastChangeTick = 0;
	2152
	2153	if (Param<0 \|\| Param>100) {
	2154	printf("\|%s\| ERROR: Invalid range: %d\n", __FUNCTION__, Param);
	2155	return DHL_FAIL_INVALID_PARAM;
	2156	}
	2157
	2158	//
	2159	// 50 mSec ÀÌ³»¿¡ Á¶Á¤ÇÏ¸é, ±â´Ù¸².
	2160	//
	2161	while ( (OS_GetTickCount() - lastChangeTick) < 5 )
	2162	OS_mDelay(10);
	2163	lastChangeTick = OS_GetTickCount();
	2164
	2165	dhlResult = DD_CAP_SetVGAVSize(Param);
	2166	if ( dhlResult != DHL_OK )
	2167	printf("\|%s\| failure. (ERR=%d)\n", __FUNCTION__, dhlResult);
	2168
	2169	return dhlResult;
	2170	}
	2171
	2172	DHL_RESULT DHL_CAP_SetVGAVPosition(int Param)
	2173	{
	2174	DHL_RESULT dhlResult = DHL_OK;
	2175	static DS_U32 lastChangeTick = 0;
	2176
	2177	if (Param<0 \|\| Param>100) {
	2178	printf("\|%s\| ERROR: Invalid range: %d\n", __FUNCTION__, Param);
	2179	return DHL_FAIL_INVALID_PARAM;
	2180	}
	2181
	2182	//
	2183	// 50 mSec ÀÌ³»¿¡ Á¶Á¤ÇÏ¸é, ±â´Ù¸².
	2184	//
	2185	while ( (OS_GetTickCount() - lastChangeTick) < 5 )
	2186	OS_mDelay(10);
	2187	lastChangeTick = OS_GetTickCount();
	2188
	2189	dhlResult = DD_CAP_SetVGAVPosition(Param);
	2190	if ( dhlResult != DHL_OK )
	2191	printf("\|%s\| failure. (ERR=%d)\n", __FUNCTION__, dhlResult);
	2192
	2193	return dhlResult;
	2194	}
	2195
	2196	DHL_RESULT DHL_CAP_SetVGAAutoAdjustment(int Param)
	2197	{
	2198	DHL_RESULT dhlResult = DHL_OK;
	2199	#if 0
	2200	static DS_U32 lastChangeTick = 0;
	2201	extern void tvSetAutoAdjustmentCompleted(void);
	2202	DHL_CAP_VIDEO_INPUT vi;
	2203	static int bMuted = 0;
	2204
	2205	//
	2206	// 50 mSec ÀÌ³»¿¡ Á¶Á¤ÇÏ¸é, ±â´Ù¸².
	2207	//
	2208	while ( (OS_GetTickCount() - lastChangeTick) < 5 )
	2209	OS_mDelay(10);
	2210	lastChangeTick = OS_GetTickCount();
	2211
	2212	vi = DHL_CAP_GetVideoSrc(0);
	2213	if ( vi == DHL_CAP_VGA0_VIDEO && DHL_DISP_IsVideoMuted() )
	2214	{
	2215	DD_DISP_VideoMute(0);
	2216	bMuted = 1;
	2217	}
	2218
	2219	tvSetAutoAdjustmentCompleted();
	2220	dhlResult = DD_CAP_SetVGAAutoAdjustment(Param);
	2221	if ( dhlResult != DHL_OK )
	2222	printf("\|%s\| failure. (ERR=%d)\n", __FUNCTION__, dhlResult);
	2223
	2224	vi = DHL_CAP_GetVideoSrc(0);
	2225	if ( bMuted && DHL_DISP_IsVideoMuted() )
	2226	DD_DISP_VideoMute(1);
	2227	#endif
	2228	return dhlResult;
	2229	}
	2230
	2231	DHL_RESULT DHL_CAP_SetVGAAutoPhase(int Param)
	2232	{
	2233	DHL_RESULT dhlResult = DHL_OK;
	2234	static DS_U32 lastChangeTick = 0;
	2235
	2236	//
	2237	// 50 mSec ÀÌ³»¿¡ Á¶Á¤ÇÏ¸é, ±â´Ù¸².
	2238	//
	2239	while ( (OS_GetTickCount() - lastChangeTick) < 5 )
	2240	OS_mDelay(10);
	2241	lastChangeTick = OS_GetTickCount();
	2242
	2243	dhlResult = DD_CAP_SetVGAAutoPhase(Param);
	2244	if ( dhlResult != DHL_OK )
	2245	printf("\|%s\| failure. (ERR=%d)\n", __FUNCTION__, dhlResult);
	2246
	2247	return dhlResult;
	2248	}
	2249
	2250	DHL_RESULT DHL_CAP_GetVGAPhase(int *pParam)
	2251	{
	2252	DHL_RESULT dhlResult = DHL_OK;
	2253
	2254	if ( pParam == (int *)0 ) {
	2255	printf("\|%s\| ERROR: NULL Parameter.\n", __FUNCTION__);
	2256	return DHL_FAIL_NULL_POINTER;
	2257	}
	2258
	2259	dhlResult = DD_CAP_GetVGAPhase(&g_VGAPhase);
	2260	if ( dhlResult != DHL_OK )
	2261	printf("\|%s\| failure. (ERR=%d)\n", __FUNCTION__, dhlResult);
	2262
	2263	*pParam = g_VGAPhase;
	2264
	2265	return dhlResult;
	2266	}
	2267
	2268	DHL_RESULT DHL_CAP_GetVGAClock(int *pParam)
	2269	{
	2270	DHL_RESULT dhlResult = DHL_OK;
	2271
	2272	if ( pParam == (int *)0 ) {
	2273	printf("\|%s\| ERROR: NULL Parameter.\n", __FUNCTION__);
	2274	return DHL_FAIL_NULL_POINTER;
	2275	}
	2276
	2277	dhlResult = DD_CAP_GetVGAClock(&g_VGAClock);
	2278	if ( dhlResult != DHL_OK )
	2279	printf("\|%s\| failure. (ERR=%d)\n", __FUNCTION__, dhlResult);
	2280	*pParam = g_VGAClock;
	2281
	2282	return dhlResult;
	2283	}
	2284
	2285	DHL_RESULT DHL_CAP_GetVGAHSize(int *pParam)
	2286	{
	2287	DHL_RESULT dhlResult = DHL_OK;
	2288
	2289	if ( pParam == (int *)0 ) {
	2290	printf("\|%s\| ERROR: NULL Parameter.\n", __FUNCTION__);
	2291	return DHL_FAIL_NULL_POINTER;
	2292	}
	2293
	2294	dhlResult = DD_CAP_GetVGAHSize(pParam);
	2295	if ( dhlResult != DHL_OK )
	2296	printf("\|%s\| failure. (ERR=%d)\n", __FUNCTION__, dhlResult);
	2297
	2298	return dhlResult;
	2299	}
	2300
	2301	DHL_RESULT DHL_CAP_GetVGAHPosition(int *pParam)
	2302	{
	2303	DHL_RESULT dhlResult = DHL_OK;
	2304
	2305	if ( pParam == (int *)0 ) {
	2306	printf("\|%s\| ERROR: NULL Parameter.\n", __FUNCTION__);
	2307	return DHL_FAIL_NULL_POINTER;
	2308	}
	2309
	2310	dhlResult = DD_CAP_GetVGAHPosition(pParam);
	2311	if ( dhlResult != DHL_OK )
	2312	printf("\|%s\| failure. (ERR=%d)\n", __FUNCTION__, dhlResult);
	2313
	2314	return dhlResult;
	2315	}
	2316
	2317	DHL_RESULT DHL_CAP_GetVGAVSize(int *pParam)
	2318	{
	2319	DHL_RESULT dhlResult = DHL_OK;
	2320
	2321	if ( pParam == (int *)0 ) {
	2322	printf("\|%s\| ERROR: NULL Parameter.\n", __FUNCTION__);
	2323	return DHL_FAIL_NULL_POINTER;
	2324	}
	2325
	2326	dhlResult = DD_CAP_GetVGAVSize(pParam);
	2327	if ( dhlResult != DHL_OK )
	2328	printf("\|%s\| failure. (ERR=%d)\n", __FUNCTION__, dhlResult);
	2329
	2330	return dhlResult;
	2331	}
	2332
	2333	DHL_RESULT DHL_CAP_GetVGAVPosition(int *pParam)
	2334	{
	2335	DHL_RESULT dhlResult = DHL_OK;
	2336
	2337	if ( pParam == (int *)0 ) {
	2338	printf("\|%s\| ERROR: NULL Parameter.\n", __FUNCTION__);
	2339	return DHL_FAIL_NULL_POINTER;
	2340	}
	2341
	2342	dhlResult = DD_CAP_GetVGAVPosition(pParam);
	2343	if ( dhlResult != DHL_OK )
	2344	printf("\|%s\| failure. (ERR=%d)\n", __FUNCTION__, dhlResult);
	2345
	2346	return dhlResult;
	2347	}
	2348
	2349	DHL_RESULT DHL_CAP_SetVGACapture(VGA_CAPTURE_t *vc)
	2350	{
	2351	return DD_CAP_SetVGACapture(vc);
	2352	}
	2353
	2354	DHL_RESULT DHL_CAP_GetVGACapture(VGA_CAPTURE_t *vc)
	2355	{
	2356	return DD_CAP_GetVGACapture(vc);
	2357	}
	2358
	2359	DHL_RESULT DHL_CAP_DoVGAAutoColor(VGA_ADC_t *va)
	2360	{
	2361	return DD_CAP_DoVGAAutoColor(va);
	2362	}
	2363
	2364	DHL_RESULT DHL_CAP_SetVGAAutoColor(VGA_ADC_t *va)
	2365	{
	2366	return DD_CAP_SetVGAAutoColor(va);
	2367	}
	2368
	2369	//
	2370	// Backward Compatability APIs
	2371	//
	2372	#if 0
	2373	___Backward_Compatabilities___ ()
	2374	#endif
	2375	DHL_RESULT DHL_CAP_ChangeAudioSource(DHL_CAP_AUDIO_INPUT AudioInputSrc)
	2376	{
	2377	return DHL_CAP_ChangeAudioInput(AudioInputSrc);
	2378	}
	2379
	2380	DHL_RESULT DHL_CAP_PresetVC(DHL_VIDEO_FORMAT vf, DS_BOOL Focus)
	2381	{
	2382	return DHL_CAP_PresetVideoFormat(vf, Focus);
	2383	}
	2384
	2385	//
	2386	// Test Routines
	2387	//
	2388	#if 0
	2389	___Test_Routines_____________________________ ()
	2390	#endif
	2391	#define DHL_CAP_ASSERT(x) do { if (!(x)) { DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"ERROR, LINE=%d\n", __LINE__); } } while(0)
	2392	void TestAudioCapture(int audIn)
	2393	{
	2394	static int cap_init = 0;
	2395	DHL_RESULT dhlResult = DHL_OK;
	2396
	2397	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"audIn = %d\n", audIn);
	2398
	2399	if ( cap_init == 0 ) {
	2400	dhlResult = DHL_CAP_PresetAudioInput( DHL_CAP_ATV0_AUDIO );
	2401	DHL_CAP_ASSERT( dhlResult == DHL_OK );
	2402	DHL_CAP_Init();
	2403	cap_init=1;
	2404	}
	2405
	2406	dhlResult = DHL_CAP_Stop(1, 1);
	2407	DHL_CAP_ASSERT( dhlResult == DHL_OK );
	2408
	2409	dhlResult = DHL_CAP_ChangeAudioInput( (DHL_CAP_AUDIO_INPUT)audIn );
	2410	DHL_CAP_ASSERT( dhlResult == DHL_OK );
	2411
	2412	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP," Audio Input: %s\n",
	2413	audIn == DHL_CAP_DTV0_AUDIO ? "DTV0" :
	2414	audIn == DHL_CAP_DTV1_AUDIO ? "DTV1" :
	2415	audIn == DHL_CAP_ATV0_AUDIO ? "ATV0" :
	2416	audIn == DHL_CAP_ATV1_AUDIO ? "ATV1" :
	2417	audIn == DHL_CAP_CVBS0_AUDIO ? "CVBS0" :
	2418	audIn == DHL_CAP_CVBS1_AUDIO ? "CVBS1" :
	2419	audIn == DHL_CAP_CVBS2_AUDIO ? "CVBS2" :
	2420	audIn == DHL_CAP_CVBS3_AUDIO ? "CVBS3" :
	2421	audIn == DHL_CAP_SVIDEO0_AUDIO ? "SVIDEO0" :
	2422	audIn == DHL_CAP_SVIDEO1_AUDIO ? "SVIDEO1" :
	2423	audIn == DHL_CAP_SVIDEO2_AUDIO ? "SVIDEO2" :
	2424	audIn == DHL_CAP_SVIDEO3_AUDIO ? "SVIDEO3" :
	2425	audIn == DHL_CAP_YPBPR0_AUDIO ? "YPBPR0" :
	2426	audIn == DHL_CAP_YPBPR1_AUDIO ? "YPBPR1" :
	2427	audIn == DHL_CAP_YPBPR2_AUDIO ? "YPBPR2" :
	2428	audIn == DHL_CAP_YPBPR3_AUDIO ? "YPBPR3" :
	2429	audIn == DHL_CAP_HDMI0_AUDIO ? "HDMI0" :
	2430	audIn == DHL_CAP_HDMI1_AUDIO ? "HDMI1" :
	2431	audIn == DHL_CAP_HDMI2_AUDIO ? "HDMI2" :
	2432	audIn == DHL_CAP_HDMI3_AUDIO ? "HDMI3" : "Unknown" );
	2433
	2434	dhlResult = DHL_CAP_Start(1, 1);
	2435	DHL_CAP_ASSERT( dhlResult == DHL_OK );
	2436	}
	2437
	2438	void test_popup(int i1, int i2, int n)
	2439	{
	2440	int i;
	2441
	2442	if (n<=0) {
	2443	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"usage: test_popup [i1] [i2] [n]\n");
	2444	return;
	2445	}
	2446
	2447	for (i=0; i<n; i++) {
	2448	TestAudioCapture(i1);
	2449
	2450	TestAudioCapture(i2);
	2451
	2452	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP,"loop %d\n", i);
	2453	}
	2454	}
	2455
	2456	void DumpVideoInput(void)
	2457	{
	2458	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP," Main Video Input: %s\n",
	2459	g_dhlcap.CapInMainVideoSrc == DHL_CAP_DTV0_VIDEO ? "DTV0" :
	2460	g_dhlcap.CapInMainVideoSrc == DHL_CAP_DTV1_VIDEO ? "DTV1" :
	2461	g_dhlcap.CapInMainVideoSrc == DHL_CAP_ATV0_VIDEO ? "ATV0" :
	2462	g_dhlcap.CapInMainVideoSrc == DHL_CAP_ATV1_VIDEO ? "ATV1" :
	2463	g_dhlcap.CapInMainVideoSrc == DHL_CAP_CVBS0_VIDEO ? "CVBS0" :
	2464	g_dhlcap.CapInMainVideoSrc == DHL_CAP_CVBS1_VIDEO ? "CVBS1" :
	2465	g_dhlcap.CapInMainVideoSrc == DHL_CAP_CVBS2_VIDEO ? "CVBS2" :
	2466	g_dhlcap.CapInMainVideoSrc == DHL_CAP_CVBS3_VIDEO ? "CVBS3" :
	2467	g_dhlcap.CapInMainVideoSrc == DHL_CAP_SVIDEO0_VIDEO ? "SVIDEO0" :
	2468	g_dhlcap.CapInMainVideoSrc == DHL_CAP_SVIDEO1_VIDEO ? "SVIDEO1" :
	2469	g_dhlcap.CapInMainVideoSrc == DHL_CAP_SVIDEO2_VIDEO ? "SVIDEO2" :
	2470	g_dhlcap.CapInMainVideoSrc == DHL_CAP_SVIDEO3_VIDEO ? "SVIDEO3" :
	2471	g_dhlcap.CapInMainVideoSrc == DHL_CAP_VGA0_VIDEO ? "VGA0" :
	2472	g_dhlcap.CapInMainVideoSrc == DHL_CAP_VGA1_VIDEO ? "VGA1" :
	2473	g_dhlcap.CapInMainVideoSrc == DHL_CAP_YPBPR0_VIDEO ? "YPBPR0" :
	2474	g_dhlcap.CapInMainVideoSrc == DHL_CAP_YPBPR1_VIDEO ? "YPBPR1" :
	2475	g_dhlcap.CapInMainVideoSrc == DHL_CAP_YPBPR2_VIDEO ? "YPBPR2" :
	2476	g_dhlcap.CapInMainVideoSrc == DHL_CAP_YPBPR3_VIDEO ? "YPBPR3" :
	2477	g_dhlcap.CapInMainVideoSrc == DHL_CAP_HDMI0_VIDEO ? "HDMI0" :
	2478	g_dhlcap.CapInMainVideoSrc == DHL_CAP_HDMI1_VIDEO ? "HDMI1" :
	2479	g_dhlcap.CapInMainVideoSrc == DHL_CAP_HDMI2_VIDEO ? "HDMI2" :
	2480	g_dhlcap.CapInMainVideoSrc == DHL_CAP_HDMI3_VIDEO ? "HDMI3" : "Unknown" );
	2481
	2482	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP," Sub Video Input: %s\n",
	2483	g_dhlcap.CapInSubVideoSrc == DHL_CAP_DTV0_VIDEO ? "DTV0" :
	2484	g_dhlcap.CapInSubVideoSrc == DHL_CAP_DTV1_VIDEO ? "DTV1" :
	2485	g_dhlcap.CapInSubVideoSrc == DHL_CAP_ATV0_VIDEO ? "ATV0" :
	2486	g_dhlcap.CapInSubVideoSrc == DHL_CAP_ATV1_VIDEO ? "ATV1" :
	2487	g_dhlcap.CapInSubVideoSrc == DHL_CAP_CVBS0_VIDEO ? "CVBS0" :
	2488	g_dhlcap.CapInSubVideoSrc == DHL_CAP_CVBS1_VIDEO ? "CVBS1" :
	2489	g_dhlcap.CapInSubVideoSrc == DHL_CAP_CVBS2_VIDEO ? "CVBS2" :
	2490	g_dhlcap.CapInSubVideoSrc == DHL_CAP_CVBS3_VIDEO ? "CVBS3" :
	2491	g_dhlcap.CapInSubVideoSrc == DHL_CAP_SVIDEO0_VIDEO ? "SVIDEO0" :
	2492	g_dhlcap.CapInSubVideoSrc == DHL_CAP_SVIDEO1_VIDEO ? "SVIDEO1" :
	2493	g_dhlcap.CapInSubVideoSrc == DHL_CAP_SVIDEO2_VIDEO ? "SVIDEO2" :
	2494	g_dhlcap.CapInSubVideoSrc == DHL_CAP_SVIDEO3_VIDEO ? "SVIDEO3" :
	2495	g_dhlcap.CapInSubVideoSrc == DHL_CAP_VGA0_VIDEO ? "VGA0" :
	2496	g_dhlcap.CapInSubVideoSrc == DHL_CAP_VGA1_VIDEO ? "VGA1" :
	2497	g_dhlcap.CapInSubVideoSrc == DHL_CAP_YPBPR0_VIDEO ? "YPBPR0" :
	2498	g_dhlcap.CapInSubVideoSrc == DHL_CAP_YPBPR1_VIDEO ? "YPBPR1" :
	2499	g_dhlcap.CapInSubVideoSrc == DHL_CAP_YPBPR2_VIDEO ? "YPBPR2" :
	2500	g_dhlcap.CapInSubVideoSrc == DHL_CAP_YPBPR3_VIDEO ? "YPBPR3" :
	2501	g_dhlcap.CapInSubVideoSrc == DHL_CAP_HDMI0_VIDEO ? "HDMI0" :
	2502	g_dhlcap.CapInSubVideoSrc == DHL_CAP_HDMI1_VIDEO ? "HDMI1" :
	2503	g_dhlcap.CapInSubVideoSrc == DHL_CAP_HDMI2_VIDEO ? "HDMI2" :
	2504	g_dhlcap.CapInSubVideoSrc == DHL_CAP_HDMI3_VIDEO ? "HDMI3" : "Unknown" );
	2505	}
	2506
	2507	void DumpAudioInput(void)
	2508	{
	2509	DHL_DbgPrintf(gdhlCapDbgLvl,DHLDBG_CAP," Audio Input: %s\n",
	2510	g_dhlcap.CapInAudioSrc == DHL_CAP_DTV0_AUDIO ? "DTV0" :
	2511	g_dhlcap.CapInAudioSrc == DHL_CAP_DTV1_AUDIO ? "DTV1" :
	2512	g_dhlcap.CapInAudioSrc == DHL_CAP_ATV0_AUDIO ? "ATV0" :
	2513	g_dhlcap.CapInAudioSrc == DHL_CAP_ATV1_AUDIO ? "ATV1" :
	2514	g_dhlcap.CapInAudioSrc == DHL_CAP_CVBS0_AUDIO ? "CVBS0" :
	2515	g_dhlcap.CapInAudioSrc == DHL_CAP_CVBS1_AUDIO ? "CVBS1" :
	2516	g_dhlcap.CapInAudioSrc == DHL_CAP_CVBS2_AUDIO ? "CVBS2" :
	2517	g_dhlcap.CapInAudioSrc == DHL_CAP_CVBS3_AUDIO ? "CVBS3" :
	2518	g_dhlcap.CapInAudioSrc == DHL_CAP_SVIDEO0_AUDIO ? "SVIDEO0" :
	2519	g_dhlcap.CapInAudioSrc == DHL_CAP_SVIDEO1_AUDIO ? "SVIDEO1" :
	2520	g_dhlcap.CapInAudioSrc == DHL_CAP_SVIDEO2_AUDIO ? "SVIDEO2" :
	2521	g_dhlcap.CapInAudioSrc == DHL_CAP_SVIDEO3_AUDIO ? "SVIDEO3" :
	2522	g_dhlcap.CapInAudioSrc == DHL_CAP_VGA0_AUDIO ? "VGA0" :
	2523	g_dhlcap.CapInAudioSrc == DHL_CAP_VGA1_AUDIO ? "VGA1" :
	2524	g_dhlcap.CapInAudioSrc == DHL_CAP_YPBPR0_AUDIO ? "YPBPR0" :
	2525	g_dhlcap.CapInAudioSrc == DHL_CAP_YPBPR1_AUDIO ? "YPBPR1" :
	2526	g_dhlcap.CapInAudioSrc == DHL_CAP_YPBPR2_AUDIO ? "YPBPR2" :
	2527	g_dhlcap.CapInAudioSrc == DHL_CAP_YPBPR3_AUDIO ? "YPBPR3" :
	2528	g_dhlcap.CapInAudioSrc == DHL_CAP_HDMI0_AUDIO ? "HDMI0" :
	2529	g_dhlcap.CapInAudioSrc == DHL_CAP_HDMI1_AUDIO ? "HDMI1" :
	2530	g_dhlcap.CapInAudioSrc == DHL_CAP_HDMI2_AUDIO ? "HDMI2" :
	2531	g_dhlcap.CapInAudioSrc == DHL_CAP_HDMI3_AUDIO ? "HDMI3" : "Unknown" );
	2532	}
	2533
	2534	void hvi(int Focus)
	2535	{
	2536	DS_U16 hRes, vRes, rRate;
	2537	DS_BOOL Interlaced;
	2538	DHL_RESULT dhlResult = DHL_OK;
	2539
	2540	//DHL_RESULT DHL_CAP_GetVideoTiming(DS_BOOL bFocus, DS_U16 phRes, DS_U16 pvRes, DS_U16 pRefreshRate, DS_BOOL pbInterlaced)
	2541	hRes=vRes=rRate=Interlaced=-1;
	2542	dhlResult = DHL_CAP_GetVideoTiming(Focus ? 1 : 0, &hRes, &vRes, &rRate, &Interlaced);
	2543	if (dhlResult != DHL_OK)
	2544	printf("ERROR: DHL_CAP_GetVideoTiming cannot retrieve video timing information.\n");
	2545
	2546	printf("Video Input Information: (%d x %d)@%dHz %s\n", hRes, vRes, rRate, Interlaced ? "Interlaced" : "Progressive");
	2547	}
	2548
	2549	void check_pip(int arg)
	2550	{
	2551	int mainSrc, subSrc;
	2552
	2553	for (mainSrc = DHL_CAP_DTV0_VIDEO; mainSrc<DHL_CAP_VGA1_VIDEO; mainSrc++) {
	2554	for (subSrc = DHL_CAP_DTV0_VIDEO; subSrc<DHL_CAP_VGA1_VIDEO; subSrc++) {
	2555
	2556	if ( DHL_CAP_StartVideoEx( mainSrc, subSrc, DHL_PIPMODE_PIPSMALL, DHL_PIP_TOP_LEFT ) != DHL_OK ) {
	2557	printf("FAIL: mainSrc=%d, subSrc=%d ", mainSrc, subSrc);
	2558	} else {
	2559	OS_mDelay(1000);
	2560	printf("PASS: mainSrc=%d, subSrc=%d ", mainSrc, subSrc);
	2561	}
	2562
	2563	printf("mainSrc : %s ",
	2564	mainSrc == DHL_CAP_DTV0_VIDEO ? "DTV0" :
	2565	mainSrc == DHL_CAP_DTV1_VIDEO ? "DTV1" :
	2566	mainSrc == DHL_CAP_ATV0_VIDEO ? "ATV0" :
	2567	mainSrc == DHL_CAP_ATV1_VIDEO ? "ATV1" :
	2568	mainSrc == DHL_CAP_CVBS0_VIDEO ? "CVBS0" :
	2569	mainSrc == DHL_CAP_CVBS1_VIDEO ? "CVBS1" :
	2570	mainSrc == DHL_CAP_CVBS2_VIDEO ? "CVBS2" :
	2571	mainSrc == DHL_CAP_CVBS3_VIDEO ? "CVBS3" :
	2572	mainSrc == DHL_CAP_SVIDEO0_VIDEO ? "SVIDEO0" :
	2573	mainSrc == DHL_CAP_SVIDEO1_VIDEO ? "SVIDEO1" :
	2574	mainSrc == DHL_CAP_SVIDEO2_VIDEO ? "SVIDEO2" :
	2575	mainSrc == DHL_CAP_SVIDEO3_VIDEO ? "SVIDEO3" :
	2576	mainSrc == DHL_CAP_VGA0_VIDEO ? "VGA0" :
	2577	mainSrc == DHL_CAP_VGA1_VIDEO ? "VGA1" :
	2578	mainSrc == DHL_CAP_YPBPR0_VIDEO ? "YPBPR0" :
	2579	mainSrc == DHL_CAP_YPBPR1_VIDEO ? "YPBPR1" :
	2580	mainSrc == DHL_CAP_YPBPR2_VIDEO ? "YPBPR2" :
	2581	mainSrc == DHL_CAP_YPBPR3_VIDEO ? "YPBPR3" :
	2582	mainSrc == DHL_CAP_HDMI0_VIDEO ? "HDMI0" :
	2583	mainSrc == DHL_CAP_HDMI1_VIDEO ? "HDMI1" :
	2584	mainSrc == DHL_CAP_HDMI2_VIDEO ? "HDMI2" :
	2585	mainSrc == DHL_CAP_HDMI3_VIDEO ? "HDMI3" : "Unknown" );
	2586
	2587	printf("subSrc : %s\n",
	2588	subSrc == DHL_CAP_DTV0_VIDEO ? "DTV0" :
	2589	subSrc == DHL_CAP_DTV1_VIDEO ? "DTV1" :
	2590	subSrc == DHL_CAP_ATV0_VIDEO ? "ATV0" :
	2591	subSrc == DHL_CAP_ATV1_VIDEO ? "ATV1" :
	2592	subSrc == DHL_CAP_CVBS0_VIDEO ? "CVBS0" :
	2593	subSrc == DHL_CAP_CVBS1_VIDEO ? "CVBS1" :
	2594	subSrc == DHL_CAP_CVBS2_VIDEO ? "CVBS2" :
	2595	subSrc == DHL_CAP_CVBS3_VIDEO ? "CVBS3" :
	2596	subSrc == DHL_CAP_SVIDEO0_VIDEO ? "SVIDEO0" :
	2597	subSrc == DHL_CAP_SVIDEO1_VIDEO ? "SVIDEO1" :
	2598	subSrc == DHL_CAP_SVIDEO2_VIDEO ? "SVIDEO2" :
	2599	subSrc == DHL_CAP_SVIDEO3_VIDEO ? "SVIDEO3" :
	2600	subSrc == DHL_CAP_VGA0_VIDEO ? "VGA0" :
	2601	subSrc == DHL_CAP_VGA1_VIDEO ? "VGA1" :
	2602	subSrc == DHL_CAP_YPBPR0_VIDEO ? "YPBPR0" :
	2603	subSrc == DHL_CAP_YPBPR1_VIDEO ? "YPBPR1" :
	2604	subSrc == DHL_CAP_YPBPR2_VIDEO ? "YPBPR2" :
	2605	subSrc == DHL_CAP_YPBPR3_VIDEO ? "YPBPR3" :
	2606	subSrc == DHL_CAP_HDMI0_VIDEO ? "HDMI0" :
	2607	subSrc == DHL_CAP_HDMI1_VIDEO ? "HDMI1" :
	2608	subSrc == DHL_CAP_HDMI2_VIDEO ? "HDMI2" :
	2609	subSrc == DHL_CAP_HDMI3_VIDEO ? "HDMI3" : "Unknown" );
	2610
	2611	//printf("This combination, mainSrc=%d, subSrc=%d return error\n", mainSrc, subSrc);
	2612
	2613
	2614	//printf("press any key.\n"); getchar();
	2615	}
	2616	}
	2617	}
	2618
	2619	void hdmi_fmt2(void)
	2620	{
	2621	DS_U32 hPix, hTotal, vLine, vTotal;
	2622
	2623	DHL_CAP_GetHDMIFmt(&hPix, &hTotal, &vLine, &vTotal);
	2624
	2625	printf("H-Active: %ld\n", hPix);
	2626	printf("H-Total : %ld\n", hTotal);
	2627	printf("V-Active: %ld\n", vLine);
	2628	printf("V-Total : %ld\n", vTotal);
	2629	}
	2630
	2631	void rgb_fmt(void)
	2632	{
	2633	DS_U16 wHR, wVR, wHW, wVW, wPol;
	2634
	2635	DHL_CAP_GetRGBFmt(&wHR, &wVR, &wHW, &wVW, &wPol);
	2636
	2637	printf("RGB Info: wHR=%d, wVR=%d, wHW=%d, wVW=%d, wPol=%d\n", wHR, wVR, wHW, wVW, wPol);
	2638	}
	2639
	2640	void set_synclock_delay(int delay)
	2641	{
	2642	printf("Synclock Delay: %d -> %d\n", g_SyncLockDelay, delay);
	2643	g_SyncLockDelay = delay;
	2644	}
	2645
	2646	void set_source_change_delay(int delay)
	2647	{
	2648	printf("Source Change Delay: %d -> %d\n", g_SourceChangeDelay, delay);
	2649	g_SourceChangeDelay = delay;
	2650	}
	2651
	2652	void TestVGAParam(int arg)
	2653	{
	2654	int dwValue;
	2655	int i;
	2656
	2657	for (i=0; i<=100; i++) {
	2658	switch(arg) {
	2659	case 1:
	2660	printf("Test PHASE\n");
	2661	DHL_CAP_SetVGAPhase( i );
	2662	DHL_CAP_GetVGAPhase( &dwValue );
	2663	break;
	2664
	2665	case 2:
	2666	printf("TEST Clock\n");
	2667	DHL_CAP_SetVGAClock( i );
	2668	DHL_CAP_GetVGAClock( &dwValue );
	2669	break;
	2670
	2671	case 3:
	2672	printf("TEST HSize\n");
	2673	DHL_CAP_SetVGAHSize( i );
	2674	DHL_CAP_GetVGAHSize( &dwValue );
	2675	break;
	2676
	2677	case 4:
	2678	printf("TEST HPosition\n");
	2679	DHL_CAP_SetVGAHPosition( i );
	2680	DHL_CAP_GetVGAHPosition( &dwValue );
	2681	break;
	2682
	2683	case 5:
	2684	printf("TEST VSIZE\n");
	2685	DHL_CAP_SetVGAVSize( i );
	2686	DHL_CAP_GetVGAVSize( &dwValue );
	2687	break;
	2688
	2689	case 6:
	2690	printf("TEST VPOSITION\n");
	2691	DHL_CAP_SetVGAVPosition( i );
	2692	DHL_CAP_GetVGAVPosition( &dwValue );
	2693	break;
	2694
	2695	}
	2696
	2697	if ( i != dwValue ) {
	2698	printf("\|%s\| Value is different; expected=%d, read=%d\n", __FUNCTION__, i, dwValue);
	2699	break;
	2700	}
	2701	}
	2702
	2703	if ( i==101 )
	2704	printf("Passed.\n");
	2705	}
	2706
	2707	void PrintVGAParam(void)
	2708	{
	2709	int phase, clock, hsize, hpos, vsize, vpos;
	2710
	2711	phase = clock = hsize = hpos = vsize = vpos = -1;
	2712
	2713	DHL_CAP_GetVGAPhase( &phase );
	2714	DHL_CAP_GetVGAClock( &clock );
	2715	DHL_CAP_GetVGAHSize( &hsize );
	2716	DHL_CAP_GetVGAHPosition( &hpos );
	2717	DHL_CAP_GetVGAVSize( &vsize );
	2718	DHL_CAP_GetVGAVPosition( &vpos );
	2719
	2720	printf(" * VGA Parameters *\n");
	2721	printf("Phase: %d\n", phase);
	2722	printf("Clock: %d\n", clock);
	2723	printf("H-Size: %d\n", hsize);
	2724	printf("H-Position: %d\n", hpos);
	2725	printf("V-Size: %d\n", vsize);
	2726	printf("V-Position: %d\n", vpos);
	2727	}
	2728
	2729	void testVGAparam(int test, int from, int to, int delay)
	2730	{
	2731	int i;
	2732
	2733	if (!from && !to) {
	2734	usage:
	2735	printf("Usage: %s [Test#] [From] [To] [Delay]\n", __FUNCTION__);
	2736	printf(" 0: Phase\n");
	2737	printf(" 1: Clock\n");
	2738	printf(" 2: HSize\n");
	2739	printf(" 3: HPos \n");
	2740	printf(" 4: VSize\n");
	2741	printf(" 5: VPos \n");
	2742	return;
	2743	}
	2744
	2745	switch( test ) {
	2746	case 0:
	2747	printf("Phase Test from %d to %d\n", from, to);
	2748
	2749	for(i=from; i<=to; i++) {
	2750	DHL_CAP_SetVGAPhase( i );
	2751	if ( delay )
	2752	OS_mDelay(delay);
	2753	}
	2754	break;
	2755
	2756	case 1:
	2757	printf("Clock Test from %d to %d\n", from, to);
	2758
	2759	for(i=from; i<=to; i++) {
	2760	DHL_CAP_SetVGAClock( i );
	2761	if ( delay )
	2762	OS_mDelay(delay);
	2763	}
	2764	break;
	2765
	2766	case 2:
	2767	printf("HSize Test from %d to %d\n", from, to);
	2768
	2769	for(i=from; i<=to; i++) {
	2770	DHL_CAP_SetVGAHSize( i );
	2771	if ( delay )
	2772	OS_mDelay(delay);
	2773	}
	2774	break;
	2775
	2776	case 3:
	2777	printf("H-Position Test from %d to %d\n", from, to);
	2778
	2779	for(i=from; i<=to; i++) {
	2780	DHL_CAP_SetVGAHPosition( i );
	2781	if ( delay )
	2782	OS_mDelay(delay);
	2783	}
	2784	break;
	2785
	2786	case 4:
	2787	printf("VSize Test from %d to %d\n", from, to);
	2788
	2789	for(i=from; i<=to; i++) {
	2790	DHL_CAP_SetVGAVSize( i );
	2791	if ( delay )
	2792	OS_mDelay(delay);
	2793	}
	2794	break;
	2795
	2796	case 5:
	2797	printf("V-Position Test from %d to %d\n", from, to);
	2798
	2799	for(i=from; i<=to; i++) {
	2800	DHL_CAP_SetVGAVPosition( i );
	2801	if ( delay )
	2802	OS_mDelay(delay);
	2803	}
	2804	break;
	2805
	2806	default:
	2807	goto usage;
	2808	}
	2809	}
	2810
	2811	void get_vga_capture(void)
	2812	{
	2813	VGA_CAPTURE_t vc;
	2814
	2815	DHL_CAP_GetVGACapture(&vc);
	2816	printf("CAP > x=%d y=%d w=%d h=%d\n", vc.wX, vc.wY, vc.wWidth, vc.wHeight);
	2817	printf("DISP> x=%d y=%d w=%d h=%d\n", vc.wDispX, vc.wDispY, vc.wDispWidth, vc.wDispHeight);
	2818	printf("KEY > x=%d y=%d w=%d h=%d\n", vc.wDispKX, vc.wDispKY, vc.wDispKWidth, vc.wDispKHeight);
	2819	}
	2820
	2821	void set_vga_capture(int x, int y, int w, int h, int dx, int dy, int dw, int dh, int kx, int ky, int kw, int kh)
	2822	{
	2823	VGA_CAPTURE_t vc;
	2824
	2825	if ( !x \|\| !y \|\| !w \|\| !h )
	2826	{
	2827	printf("usage: %s x y w h\n", __FUNCTION__);
	2828	return;
	2829	}
	2830
	2831	vc.wX = x;
	2832	vc.wY = y;
	2833	vc.wWidth = w;
	2834	vc.wHeight = h;
	2835
	2836	vc.wDispX = dx;
	2837	vc.wDispY = dy;
	2838	vc.wDispWidth = dw;
	2839	vc.wDispHeight = dh;
	2840
	2841	vc.wDispKX = kx;
	2842	vc.wDispKY = ky;
	2843	vc.wDispKWidth = kw;
	2844	vc.wDispKHeight = kh;
	2845
	2846	printf("CAP > x=%d y=%d w=%d h=%d\n", vc.wX, vc.wY, vc.wWidth, vc.wHeight);
	2847	printf("DISP> x=%d y=%d w=%d h=%d\n", vc.wDispX, vc.wDispY, vc.wDispWidth, vc.wDispHeight);
	2848	printf("KEY > x=%d y=%d w=%d h=%d\n", vc.wDispKX, vc.wDispKY, vc.wDispKWidth, vc.wDispKHeight);
	2849
	2850	DHL_CAP_SetVGACapture(&vc);
	2851	}
	2852
	2853	void do_adc(void)
	2854	{
	2855	VGA_ADC_t va;
	2856
	2857	DHL_CAP_DoVGAAutoColor(&va);
	2858	printf("Offset> R:0x%02X G:0x%02X B:0x%02X\n", va.Off_R, va.Off_G, va.Off_B);
	2859	printf("Gain > R:0x%02X G:0x%02X B:0x%02X\n", va.Gain_R, va.Gain_G, va.Gain_B);
	2860	}
	2861
	2862	void set_adc(int oR, int oG, int oB, int gR, int gG, int gB)
	2863	{
	2864	VGA_ADC_t va;
	2865
	2866	va.Off_R = oR;
	2867	va.Off_G = oG;
	2868	va.Off_B = oB;
	2869
	2870	va.Gain_R = gR;
	2871	va.Gain_G = gG;
	2872	va.Gain_B = gB;
	2873
	2874	printf("Offset> R:0x%02X G:0x%02X B:0x%02X\n", va.Off_R, va.Off_G, va.Off_B);
	2875	printf("Gain > R:0x%02X G:0x%02X B:0x%02X\n", va.Gain_R, va.Gain_G, va.Gain_B);
	2876
	2877	DHL_CAP_SetVGAAutoColor(&va);
	2878	}

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: svn/zas_dstar/hal/common/dsthalcap.c @ 22

Download in other formats: