path: root/tvapi/libtv/tvin/CTvin.cpp (plain)
blob: 07e5b674bb2d5d0ef6b896d9865e5e0e8c2d8fda

1
2	#include "CTvin.h"
3	#include <CTvLog.h>
4	#include <stdio.h>
5	#include <unistd.h>
6	#include <sys/types.h>
7	#include <sys/stat.h>
8	#include <sys/ioctl.h>
9	#include <fcntl.h>
10	#include <string.h>
11	#include <errno.h>
12	#include <dlfcn.h>
13	#include <linux/fb.h>
14	#include <stdlib.h>
15	#include <cutils/properties.h>
16	#include <cutils/log.h>
17	#include <sys/mman.h>
18	#include "../vpp/CPQdb.h"
19	#include "CAv.h"
20	#include "../tvsetting/CTvSetting.h"
21	#include "../tvutils/tvutils.h"
22	#include "../tvconfig/tvconfig.h"
23	#include "CFbcCommunication.h"
24
25
26	#ifdef LOG_TAG
27	#undef LOG_TAG
28	#define LOG_TAG "CTvin"
29	#endif
30
31	#define AFE_DEV_PATH "/dev/tvafe0"
32	#define HDMIRX_KSV_PATH "/dev/hdmirx0"
33
34
35	#define CC_SEL_VDIN_DEV (0)
36
37	#define MODE_3D_DISABLE 0x00000000
38	#define MODE_3D_ENABLE 0x00000001
39	#define MODE_AUTO 0x00000002
40	#define MODE_2D_TO_3D 0x00000004
41	#define MODE_LR 0x00000008
42	#define MODE_BT 0x00000010
43	#define MODE_LR_SWITCH 0x00000020
44	#define MODE_FIELD_DEPTH 0x00000040
45	#define MODE_3D_TO_2D_L 0x00000080
46	#define MODE_3D_TO_2D_R 0x00000100
47	#define LR_FORMAT_INDICATOR 0x00000200
48	#define BT_FORMAT_INDICATOR 0x00000400
49
50	/* ADC calibration pattern & format define */
51	/* default 100% 8 color-bar */
52	//#define VGA_SOURCE_RGB444
53	#define VGA_H_ACTIVE (1024)
54	#define VGA_V_ACTIVE (768)
55	#define COMP_H_ACTIVE (1280)
56	#define COMP_V_ACTIVE (720)
57	#define CVBS_H_ACTIVE (720)
58	#define CVBS_V_ACTIVE (480)
59
60	#define FBIOPUT_OSD_FREE_SCALE_ENABLE 0x4504
61	#define FBIOPUT_OSD_FREE_SCALE_WIDTH 0x4505
62	#define FBIOPUT_OSD_FREE_SCALE_HEIGHT 0x4506
63
64	typedef enum {
65	VIEWMODE_NULL = 0,
66	VIEWMODE_4_3,
67	VIEWMODE_16_9
68	} view_mode_t;
69	int CTvin::mSourceInputToPortMap[SOURCE_MAX];
70
71	CTvin::CTvin()
72	{
73	int i = 0;
74
75	m_vdin_dev_fd = -1;
76	afe_dev_fd = -1;
77
78	m_tvin_param.index = 0;
79	m_is_decoder_start = false;
80	gExistD2D3 = -1;
81	gVideoPath[0] = '\0';
82	m_pathid = TV_PATH_DECODER_3D_AMVIDEO;
83
84	for (i = 0; i < SOURCE_MAX; i++) {
85	mSourceInputToPortMap[i] = TVIN_PORT_NULL;
86	}
87
88	mSourceInputToPortMap[SOURCE_TV] = TVIN_PORT_CVBS3;
89	mSourceInputToPortMap[SOURCE_AV1] = TVIN_PORT_CVBS1;
90	mSourceInputToPortMap[SOURCE_AV2] = TVIN_PORT_CVBS2;
91	mSourceInputToPortMap[SOURCE_YPBPR1] = TVIN_PORT_COMP0;
92	mSourceInputToPortMap[SOURCE_YPBPR2] = TVIN_PORT_COMP1;
93	mSourceInputToPortMap[SOURCE_HDMI1] = TVIN_PORT_HDMI0;
94	mSourceInputToPortMap[SOURCE_HDMI2] = TVIN_PORT_HDMI2;
95	mSourceInputToPortMap[SOURCE_HDMI3] = TVIN_PORT_HDMI1;
96	mSourceInputToPortMap[SOURCE_VGA] = TVIN_PORT_VGA0;
97	mSourceInputToPortMap[SOURCE_MPEG] = TVIN_PORT_MPEG0;
98	mSourceInputToPortMap[SOURCE_DTV] = TVIN_PORT_DTV;
99	mSourceInputToPortMap[SOURCE_IPTV] = TVIN_PORT_BT656;
100	}
101
102	CTvin::~CTvin()
103	{
104	}
105
106	int CTvin::OpenTvin()
107	{
108	const char *config_value;
109	config_value = config_get_str ( CFG_SECTION_TV, "tvin.manual.set.tvpath", "null" );
110	strcpy ( config_tv_path, config_value );
111	memset ( config_default_path, 0x0, 64 );
112	config_value = config_get_str ( CFG_SECTION_TV, "tvin.manual.set.defaultpath", "null" );
113	strcpy ( config_default_path, config_value );
114	return 0;
115	}
116
117	int CTvin::IsFileExist ( const char *file_name )
118	{
119	struct stat tmp_st;
120
121	if ( stat ( file_name, &tmp_st ) < 0 ) {
122	return 0;
123	}
124
125	return 1;
126	}
127
128	char *CTvin::DelSub ( char *str, char *sub )
129	{
130	char *psrc = str, *pdest = str, *psub = NULL, *p = NULL;
131
132	if ( ( str == NULL ) || ( sub == NULL ) ) {
133	return NULL;
134	}
135
136	while ( *psrc ) {
137	p = psrc;
138	psub = sub;
139
140	while ( *p && *p == *psub ) {
141	p++;
142	psub++;
143	}
144
145	if ( *psub == 0 ) {
146	psrc = p;
147	} else {
148	*pdest++ = *psrc++;
149	}
150	}
151
152	*pdest = 0;
153
154	return str;
155	}
156
157	int CTvin::setMpeg2Vdin(int enable)
158	{
159	/* let output data loop to vdin */
160	FILE *fp = fopen ( "/sys/module/di/parameters/mpeg2vdin_en", "w" );
161
162	if ( fp == NULL ) {
163	LOGW ( "Open /sys/module/di/parameters/mpeg2vdin_en error\n" );
164	return -1;
165	}
166	fprintf ( fp, "%d", enable );
167	fclose ( fp );
168	return 0;
169	}
170
171	char *CTvin::VDIN_CheckVideoPath ( const char *videopath )
172	{
173	strncpy ( gVideoPath, videopath, sizeof ( gVideoPath ) );
174
175	if ( strstr ( videopath, "d2d3 " ) != NULL ) {
176	if ( gExistD2D3 == -1 ) {
177	gExistD2D3 = IsFileExist ( "/sys/class/d2d3/d2d3" );
178	}
179
180	if ( gExistD2D3 == 0 ) {
181	DelSub ( gVideoPath, "d2d3 " );
182	}
183	}
184
185	LOGW ( "%s, video path before check [%s]\n", CFG_SECTION_TV, videopath );
186	LOGW ( "%s, video path after check [%s]\n", CFG_SECTION_TV, gVideoPath );
187
188	return gVideoPath;
189	}
190
191	int CTvin::VDIN_AddPath ( const char *videopath )
192	{
193	FILE *fp = NULL;
194	int ret = -1;
195	char *tmp_video_path = NULL;
196
197	tmp_video_path = VDIN_CheckVideoPath ( videopath );
198
199	fp = fopen ( "/sys/class/vfm/map", "w" );
200
201	if ( fp == NULL ) {
202	LOGW ( "Open /sys/class/vfm/map error(%s)!\n", strerror ( errno ) );
203	return -1;
204	}
205
206	ret = fprintf ( fp, "%s", tmp_video_path );
207
208	if ( ret < 0 ) {
209	LOGW ( "Add VideoPath error(%s)!\n", strerror ( errno ) );
210	}
211
212	fclose ( fp );
213	fp = NULL;
214
215	return ret;
216	}
217
218	int CTvin::VDIN_RmDefPath ( void )
219	{
220	int fd = -1, ret;
221	char str[] = "rm default";
222
223
224	fd = open ( "/sys/class/vfm/map", O_RDWR );
225
226	if ( fd < 0 ) {
227	LOGW ( "Open /sys/class/vfm/map error(%s)!\n", strerror ( errno ) );
228	return -1;
229	}
230
231	ret = write ( fd, str, sizeof ( str ) );
232
233	if ( ret < 0 ) {
234	LOGW ( "Rm default path error(%s)!\n", strerror ( errno ) );
235	}
236
237	close ( fd );
238	fd = -1;
239
240	return ret;
241	}
242
243	int CTvin::VDIN_RmTvPath ( void )
244	{
245	int fd, ret;
246	char str[] = "rm tvpath";
247
248
249	fd = open ( "/sys/class/vfm/map", O_RDWR );
250
251	if ( fd < 0 ) {
252	LOGW ( "Open /sys/class/vfm/map error(%s)!\n", strerror ( errno ) );
253	return -1;
254	}
255
256	ret = write ( fd, str, sizeof ( str ) );
257
258	if ( ret <= 0 ) {
259	LOGW ( "Rm tv path error(%s)!\n", strerror ( errno ) );
260	}
261
262	close ( fd );
263	fd = -1;
264	return ret;
265	}
266
267	int CTvin::VDIN_AddVideoPath ( int selPath )
268	{
269	int ret = -1;
270
271	switch ( selPath ) {
272	case TV_PATH_VDIN_AMVIDEO:
273	ret = VDIN_AddPath ( "add tvpath vdin0 amvideo" );
274	break;
275
276	case TV_PATH_VDIN_DEINTERLACE_AMVIDEO:
277	ret = VDIN_AddPath ( "add tvpath vdin0 deinterlace amvideo" );
278	break;
279
280	case TV_PATH_VDIN_3D_AMVIDEO:
281	ret = VDIN_AddPath ( "add tvpath vdin0 ppmgr amvideo" );
282	break;
283
284	case TV_PATH_VDIN_NEW3D_AMVIDEO:
285	ret = VDIN_AddPath ( "add tvpath vdin0 deinterlace ppmgr d2d3 amvideo" );
286	break;
287
288	case TV_PATH_VDIN_NEW3D_WITHOUTPPMGR_AMVIDEO:
289	ret = VDIN_AddPath ( "add tvpath vdin0 deinterlace d2d3 amvideo" );
290	break;
291
292	case TV_PATH_DECODER_3D_AMVIDEO:
293	ret = VDIN_AddPath ( "add default decoder ppmgr deinterlace amvideo" );
294	break;
295
296	case TV_PATH_DECODER_AMVIDEO:
297	ret = VDIN_AddPath ( "add default decoder deinterlace amvideo" );
298	break;
299
300	case TV_PATH_VDIN_FREESCALE_AMVIDEO:
301	ret = VDIN_AddPath ( "add previewpath vdin0 freescale amvideo" );
302	break;
303
304	case TV_PATH_DECODER_NEW3D_AMVIDEO:
305	ret = VDIN_AddPath ( "add default decoder deinterlace ppmgr d2d3 amvideo" );
306	break;
307
308	case TV_PATH_DECODER_NEW3D_WITHOUTPPMGR_AMVIDEO:
309	ret = VDIN_AddPath ( "add default decoder deinterlace d2d3 amvideo" );
310	break;
311	}
312
313	return ret;
314	}
315
316	int CTvin::VDIN_RmPreviewPath ( void )
317	{
318	int fd, ret;
319	char str[] = "rm previewpath";
320
321
322	fd = open ( "/sys/class/vfm/map", O_RDWR );
323
324	if ( fd < 0 ) {
325	LOGW ( "Open /sys/class/vfm/map error(%s)!\n", strerror ( errno ) );
326	return -1;
327	}
328
329	ret = write ( fd, str, sizeof ( str ) );
330
331	if ( ret < 0 ) {
332	LOGW ( "Rm tv path error(%s)!\n", strerror ( errno ) );
333	}
334
335	close ( fd );
336	fd = -1;
337
338	return ret;
339	}
340
341	int CTvin::VDIN_OpenModule()
342	{
343	char file_name[64];
344	sprintf ( file_name, "/dev/vdin%d", CC_SEL_VDIN_DEV );
345	m_vdin_dev_fd = open ( file_name, O_RDWR );
346
347	if ( m_vdin_dev_fd < 0 ) {
348	LOGW ( "Open %s error(%s)!\n", file_name, strerror ( errno ) );
349	return -1;
350	}
351
352	memset ( &gTvinVDINParam, 0, sizeof ( gTvinVDINParam ) );
353	memset ( &gTvinVDINSignalInfo, 0, sizeof ( gTvinVDINSignalInfo ) );
354
355	LOGD ( "Open vdin module vdin_dev_fd = [%d]", m_vdin_dev_fd );
356
357	return m_vdin_dev_fd;
358	}
359
360	int CTvin::VDIN_GetVdinFd()
361	{
362	return m_vdin_dev_fd;
363	}
364
365	int CTvin::VDIN_CloseModule()
366	{
367	if ( m_vdin_dev_fd != -1 ) {
368	close ( m_vdin_dev_fd );
369	m_vdin_dev_fd = -1;
370	}
371
372	return 0;
373	}
374
375	int CTvin::VDIN_DeviceIOCtl ( int request, ... )
376	{
377	int tmp_ret = -1;
378	va_list ap;
379	void *arg;
380
381	if ( m_vdin_dev_fd >= 0 ) {
382	va_start ( ap, request );
383	arg = va_arg ( ap, void * );
384	va_end ( ap );
385
386	tmp_ret = ioctl ( m_vdin_dev_fd, request, arg );
387	return tmp_ret;
388	}
389
390	return -1;
391	}
392
393	int CTvin::VDIN_OpenPort ( tvin_port_t port )
394	{
395	int rt = -1;
396	struct tvin_parm_s vdinParam;
397	vdinParam.port = port;
398	vdinParam.index = 0;
399	rt = VDIN_DeviceIOCtl ( TVIN_IOC_OPEN, &vdinParam );
400
401	if ( rt < 0 ) {
402	LOGW ( "Vdin open port, error(%s)!", strerror ( errno ) );
403	}
404
405	return rt;
406	}
407
408	int CTvin::VDIN_ClosePort()
409	{
410	int rt = -1;
411
412	rt = VDIN_DeviceIOCtl ( TVIN_IOC_CLOSE );
413
414	if ( rt < 0 ) {
415	LOGW ( "Vdin close port, error(%s)!", strerror ( errno ) );
416	}
417
418	return rt;
419	}
420
421	int CTvin::VDIN_StartDec ( const struct tvin_parm_s *vdinParam )
422	{
423	int rt = -1;
424
425	if ( vdinParam == NULL ) {
426	return -1;
427	}
428
429	rt = VDIN_DeviceIOCtl ( TVIN_IOC_START_DEC, vdinParam );
430
431	LOGD ( "VDIN_StartDec:\n" );
432	LOGD ( "index = [%d]\n", vdinParam->index );
433	LOGD ( "port = [0x%x]\n", ( unsigned int ) vdinParam->port );
434	LOGD ( "format = [0x%x]\n", ( unsigned int ) ( vdinParam->info.fmt ) );
435
436	if ( rt < 0 ) {
437	LOGW ( "Vdin start decode, error(%s)!\n", strerror ( errno ) );
438	}
439
440	return rt;
441	}
442
443	int CTvin::VDIN_StopDec()
444	{
445	int rt = -1;
446
447	rt = VDIN_DeviceIOCtl ( TVIN_IOC_STOP_DEC );
448
449	if ( rt < 0 ) {
450	LOGW ( "Vdin stop decode, error(%s)", strerror ( errno ) );
451	}
452
453	return rt;
454	}
455
456	int CTvin::VDIN_GetSignalInfo ( struct tvin_info_s *SignalInfo )
457	{
458	int rt = -1;
459
460	rt = VDIN_DeviceIOCtl ( TVIN_IOC_G_SIG_INFO, SignalInfo );
461
462	if ( rt < 0 ) {
463	LOGW ( "Vdin get signal info, error(%s), ret = %d.\n", strerror ( errno ), rt );
464	//system("reboot");
465	}
466
467	return rt;
468	}
469
470	int CTvin::VDIN_SetVdinParam ( const struct tvin_parm_s *vdinParam )
471	{
472	int rt = -1, i = 0;
473
474	rt = VDIN_DeviceIOCtl ( TVIN_IOC_S_PARM, vdinParam );
475
476	if ( rt < 0 ) {
477	LOGW ( "Vdin set signal param, error(%s)\n", strerror ( errno ) );
478	}
479
480	return rt;
481	}
482
483	int CTvin::VDIN_GetVdinParam ( const struct tvin_parm_s *vdinParam )
484	{
485	int rt = -1, i = 0;
486
487	rt = VDIN_DeviceIOCtl ( TVIN_IOC_G_PARM, vdinParam );
488
489	if ( rt < 0 ) {
490	LOGW ( "Vdin get signal param, error(%s)\n", strerror ( errno ) );
491	}
492
493	return rt;
494	}
495
496	int CTvin::VDIN_OnoffVScaler ( int isOn )
497	{
498	FILE *fp = NULL;
499
500	if ( isOn == 1 ) {
501	isOn = 1;
502	} else {
503	isOn = 0;
504	}
505
506	fp = fopen ( "/sys/class/video/vscaler", "w" );
507	if ( fp == NULL ) {
508	LOGW ( "Open /sys/class/video/vscaler error(%s)!\n", strerror ( errno ) );
509	return -1;
510	}
511
512	fprintf ( fp, "%d", ( int ) isOn );
513	fclose ( fp );
514	fp = NULL;
515
516	return 0;
517	}
518
519	int CTvin::VDIN_GetDisplayVFreq (void)
520	{
521	int fd = -1;
522	char buf[32];
523
524	fd = open("/sys/class/display/mode", O_RDWR);
525	if (fd < 0) {
526	LOGW("Open /sys/class/display/mode error(%s)!\n", strerror(errno));
527	return -1;
528	}
529	memset(buf, 0, sizeof(buf));
530	read(fd, buf, sizeof(buf));
531	close(fd);
532	LOGD( "s%, VDIN_GetDisplayVFreq is %s\n", __FUNCTION__, buf);
533	if (strstr(buf, "50hz") != NULL) {
534	return 50;
535	} else if (strstr(buf, "60hz") != 0) {
536	return 60;
537	} else {
538	return 50;
539	}
540	}
541
542	int CTvin::VDIN_SetDisplayVFreq ( int freq, int display_resolution , bool isFbc)
543	{
544	FILE *fp = NULL;
545	const char *config_value = NULL;
546	static int display_mode_type = -1;
547	CFbcCommunication *pFBC = NULL;
548	static int last_freq = 50;
549
550	last_freq = VDIN_GetDisplayVFreq();
551	if (last_freq == freq) {
552	LOGD ( "%s, same freq, last_freq = %d, freq = %d.", __FUNCTION__, last_freq, freq);
553	return 0;
554	} else {
555	LOGD ( "%s, from last_freq[%d[ to new_freq[%d].", __FUNCTION__, last_freq, freq);
556	last_freq = freq;
557	}
558
559	if (display_mode_type == -1) {
560	config_value = config_get_str ( CFG_SECTION_TV, "tvin.display.mode.type", "null" );
561	if (strcasecmp(config_value, "null") == 0 || strcasecmp(config_value, "hdmi_out") == 0) {
562	display_mode_type = 0;
563	} else if (strcasecmp(config_value, "lvds_out") == 0) {
564	display_mode_type = 1;
565	} else {
566	display_mode_type = 0;
567	}
568	}
569
570	fp = fopen ( "/sys/class/display/mode", "w" );
571
572	if ( fp == NULL ) {
573	LOGW ( "Open /sys/class/display/mode error(%s)!\n", strerror ( errno ) );
574	return -1;
575	}
576
577	if ( isFbc ) {
578	pFBC = GetSingletonFBC();
579	if (pFBC != NULL) {
580	pFBC->cfbc_Set_VMute (COMM_DEV_SERIAL, 2);
581	usleep ( 300000 );
582	}
583	}
584
585	switch ( display_resolution ) {
586	case VPP_DISPLAY_RESOLUTION_1366X768:
587	if ( freq == 50 ) {
588	fprintf ( fp, "%s", "768p50hz" );
589	} else {
590	fprintf ( fp, "%s", "768p60hz" );
591	}
592	break;
593	case VPP_DISPLAY_RESOLUTION_3840X2160:
594	if ( freq == 50 ) {
595	if (isFbc) {
596	fprintf ( fp, "%s", "2160p50hz420" );
597	} else {
598	fprintf ( fp, "%s", "2160p50hz" );
599	}
600	} else {
601	if (isFbc) {
602	fprintf ( fp, "%s", "2160p60hz420" );
603	} else {
604	fprintf ( fp, "%s", "2160p60hz" );
605	}
606	}
607	break;
608	case VPP_DISPLAY_RESOLUTION_1920X1080:
609	default:
610	if ( freq == 50 ) {
611	fprintf ( fp, "%s", "1080p50hz" );
612	} else {
613	fprintf ( fp, "%s", "1080p60hz" );
614	}
615	break;
616	}
617
618	fclose ( fp );
619	fp = NULL;
620
621	return 0;
622	}
623
624	void CTvin::Tvin_SetDepthOf2Dto3D ( int value )
625	{
626	//value = -16~16
627	int tmp_value = DepthTable_2DTO3D[value + 16];
628	LOGD ( "%s, value: %d", __FUNCTION__, value );
629	VDIN_Set2D3DDepth ( value );
630	}
631
632
633	int CTvin::VDIN_Set2D3DDepth ( int count )
634	{
635	FILE *fp = NULL;
636
637
638	fp = fopen ( "/sys/module/d2d3/parameters/depth", "w" );
639
640	if ( fp == NULL ) {
641	LOGW ( "Open /sys/module/d2d3/parameters/depth ERROR(%s)!!\n", strerror ( errno ) );
642	return -1;
643	}
644
645	if ( count >= -127 && count <= 127 ) {
646	#ifdef LOGD_3D_FUNCTION
647	LOGD ( "set depth value (%d).\n", count );
648	#endif
649	} else {
650	count = 8 * 12;
651	LOGE ( "set depth value ERROR!! set default depth.\n" );
652	}
653
654	fprintf ( fp, "%d", count );
655	fclose ( fp );
656	fp = NULL;
657
658	return 0;
659	}
660
661	int CTvin::VDIN_Set2Dto3D ( int on_off )
662	{
663	struct tvin_parm_s VdinParam;
664	VDIN_GetVdinParam ( &VdinParam );
665	VdinParam.flag &= ( ~TVIN_PARM_FLAG_2D_TO_3D );
666	VdinParam.flag |= ( on_off ) ? ( TVIN_PARM_FLAG_2D_TO_3D ) : ( 0 );
667	return VDIN_SetVdinParam ( &VdinParam );
668	}
669
670	int CTvin::VDIN_Get_avg_luma(void)
671	{
672	unsigned int lum_sum, pixel_sum, luma_avg;
673	struct tvin_parm_s vdinParam;
674
675	if ( 0 == VDIN_GetVdinParam( &vdinParam )) {
676	lum_sum = vdinParam.luma_sum;
677	pixel_sum = vdinParam.pixel_sum * 2;
678	if (pixel_sum != 0 && m_is_decoder_start) {
679	luma_avg = lum_sum / pixel_sum;
680	} else {
681	luma_avg = 116;
682	}
683	} else {
684	return -1;
685	}
686	LOGD ( "VDIN_get_avg_lut lum_sum =%d,pixel_sum=%d,lut_avg=%d\n", lum_sum, pixel_sum, luma_avg);
687	return luma_avg;
688	}
689
690	int CTvin::VDIN_GetHistgram ( int *hisgram )
691	{
692	int i = 0;
693	struct tvin_parm_s vdinParam;
694
695	if ( NULL == hisgram ) {
696	return -1;
697	}
698
699	if ( 0 == VDIN_GetVdinParam ( &vdinParam ) ) {
700	for ( i = 0; i < CC_HIST_GRAM_BUF_SIZE; i++ ) {
701	hisgram[i] = ( int ) vdinParam.histgram[i];
702	}
703	} else {
704	return -1;
705	}
706
707	return 0;
708	}
709
710	int CTvin::VDIN_SetMVCViewMode ( int mode )
711	{
712	FILE *fp = NULL;
713
714
715	fp = fopen ( "/sys/module/amvdec_h264mvc/parameters/view_mode", "w" );
716
717	if ( fp == NULL ) {
718	LOGW ( "Open /sys/module/amvdec_h264mvc/parameters/view_mode error(%s)!\n", strerror ( errno ) );
719	return -1;
720	}
721
722	fprintf ( fp, "%d", ( int ) mode );
723
724	fclose ( fp );
725	fp = NULL;
726
727	return 0;
728	}
729
730	int CTvin::VDIN_GetMVCViewMode ( void )
731	{
732	FILE *fp = NULL;
733	int ret = 0;
734	int mode = 0;
735
736
737	fp = fopen ( "/sys/module/amvdec_h264mvc/parameters/view_mode", "w" );
738
739	if ( fp == NULL ) {
740	LOGW ( "Open /sys/module/amvdec_h264mvc/parameters/view_mode ERROR(%s)!!\n", strerror ( errno ) );
741	return -1;
742	}
743
744	ret = fread ( &mode, 1, 1, fp );
745	LOGD ( "fread /sys/module/amvdec_h264mvc/parameters/view_mode = [%d]", mode );
746
747	fclose ( fp );
748	fp = NULL;
749
750	return mode;
751	}
752
753	int CTvin::VDIN_SetDIBuffMgrMode ( int mgr_mode )
754	{
755	FILE *fp = NULL;
756
757
758	fp = fopen ( "sys/module/di/parameters/buf_mgr_mode", "w" );
759
760	if ( fp == NULL ) {
761	LOGW ( "Open /sys/module/di/parameters/buf_mgr_mode error(%s)!\n", strerror ( errno ) );
762	return -1;
763	}
764
765	fprintf ( fp, "%d", mgr_mode );
766
767	fclose ( fp );
768	fp = NULL;
769
770	return 0;
771	}
772
773	int CTvin::VDIN_SetDICFG ( int cfg )
774	{
775	FILE *fp = NULL;
776
777
778	fp = fopen ( "sys/class/deinterlace/di0/config", "w" );
779
780	if ( fp == NULL ) {
781	LOGW ( "Open /sys/class/deinterlace/di0/config error(%s)!\n", strerror ( errno ) );
782	return -1;
783	}
784
785	if ( 0 == cfg ) {
786	fprintf ( fp, "%s", "disable" );
787	} else {
788	fprintf ( fp, "%s", "enable" );
789	}
790
791	fclose ( fp );
792	fp = NULL;
793
794	return 0;
795	}
796
797	int CTvin::VDIN_SetDI3DDetc ( int enable )
798	{
799	FILE *fp = NULL;
800
801
802	fp = fopen ( "/sys/module/di/parameters/det3d_en", "w" );
803
804	if ( fp == NULL ) {
805	LOGW ( "Open /sys/module/di/parameters/det3d_en error(%s)!\n", strerror ( errno ) );
806	return -1;
807	}
808
809	fprintf ( fp, "%d", enable );
810
811
812	fclose ( fp );
813	fp = NULL;
814
815	return 0;
816	}
817
818	int CTvin::VDIN_Get3DDetc ( void )
819	{
820	int fd = -1;
821	int ret = -1;
822	char buf[10];
823
824	fd = open ( "/sys/module/di/parameters/det3d_en", O_RDWR );
825	if ( fd < 0 ) {
826	LOGW ( "Open /sys/module/di/parameters/det3d_en error(%s)!\n", strerror ( errno ) );
827	return -1;
828	}
829
830	ret = read ( fd, buf, sizeof ( buf ) );
831	close ( fd );
832	fd = -1;
833
834	if ( strcmp ( "enable", buf ) == 0 ) {
835	return 1;
836	} else {
837	return 0;
838	}
839	}
840
841
842	int CTvin::VDIN_GetVscalerStatus ( void )
843	{
844	int fd = -1;
845	int ret = -1;
846	char buf[7];
847
848	fd = open ( "/sys/class/video/vscaler", O_RDWR );
849	if ( fd < 0 ) {
850	LOGW ( "Open /sys/class/video/vscaler error(%s)!\n", strerror ( errno ) );
851	return -1;
852	}
853
854	ret = read ( fd, buf, sizeof ( buf ) );
855	close ( fd );
856	fd = -1;
857
858	sscanf ( buf, "%d", &ret );
859
860	ret = ( ( ret & 0x40000 ) == 0 ) ? 1 : 0;
861	if ( ret == 1 ) {
862	sleep ( 1 );
863	}
864
865	return ret;
866	}
867
868	int CTvin::VDIN_TurnOnBlackBarDetect ( int isEnable )
869	{
870	FILE *fp = NULL;
871
872	fp = fopen ( "/sys/module/tvin_vdin/parameters/black_bar_enable", "w" );
873	if ( fp == NULL ) {
874	LOGW ( "Open /sys/module/tvin_vdin/parameters/black_bar_enable error(%s)!\n", strerror ( errno ) );
875	return -1;
876	}
877
878	fprintf ( fp, "%d", isEnable );
879	fclose ( fp );
880	fp = NULL;
881
882	return 0;
883	}
884
885	int CTvin::VDIN_LoadHdcpKey ( unsigned char *hdcpkey_buff )
886	{
887	unsigned char testHdcp[368] = { 0x53, 0x4B, 0x59, 0x01, 0x00, 0x10, 0x0D, 0x15, 0x3A, 0x8E, 0x99, 0xEE, 0x2A, 0x55, 0x58, 0xEE, 0xED, 0x4B, 0xBE, 0x00, 0x74, 0xA9, 0x00, 0x10, 0x0A, 0x21, 0xE3,
888	0x30, 0x66, 0x34, 0xCE, 0x9C, 0xC7, 0x8B, 0x51, 0x27, 0xF9, 0x0B, 0xAD, 0x09, 0x5F, 0x4D, 0xC2, 0xCA, 0xA2, 0x13, 0x06, 0x18, 0x8D, 0x34, 0x82, 0x46, 0x2D, 0xC9, 0x4B, 0xB0, 0x1C, 0xDE,
889	0x3D, 0x49, 0x39, 0x58, 0xEF, 0x2B, 0x68, 0x39, 0x71, 0xC9, 0x4D, 0x25, 0xE9, 0x75, 0x4D, 0xAC, 0x62, 0xF5, 0xF5, 0x87, 0xA0, 0xB2, 0x4A, 0x60, 0xD3, 0xF1, 0x09, 0x3A, 0xB2, 0x3E, 0x19,
890	0x4F, 0x3B, 0x1B, 0x2F, 0x85, 0x14, 0x28, 0x44, 0xFC, 0x69, 0x6F, 0x50, 0x42, 0x81, 0xBF, 0x7C, 0x2B, 0x3A, 0x17, 0x2C, 0x15, 0xE4, 0x93, 0x77, 0x74, 0xE8, 0x1F, 0x1C, 0x38, 0x54, 0x49,
891	0x10, 0x64, 0x5B, 0x7D, 0x90, 0x3D, 0xA0, 0xE1, 0x8B, 0x67, 0x5C, 0x19, 0xE6, 0xCA, 0x9D, 0xE9, 0x68, 0x5A, 0xB5, 0x62, 0xDF, 0xA1, 0x28, 0xBC, 0x68, 0x82, 0x9A, 0x22, 0xC4, 0xDC, 0x48,
892	0x85, 0x0F, 0xF1, 0x3E, 0x05, 0xDD, 0x1B, 0x2D, 0xF5, 0x49, 0x3A, 0x15, 0x29, 0xE7, 0xB6, 0x0B, 0x2A, 0x40, 0xE3, 0xB0, 0x89, 0xD5, 0x75, 0x84, 0x2E, 0x76, 0xE7, 0xBC, 0x63, 0x67, 0xE3,
893	0x57, 0x67, 0x86, 0x81, 0xF4, 0xD7, 0xEA, 0x4D, 0x89, 0x8E, 0x37, 0x95, 0x59, 0x1C, 0x8A, 0xCD, 0x79, 0xF8, 0x4F, 0x82, 0xF2, 0x6C, 0x7E, 0x7F, 0x79, 0x8A, 0x6B, 0x90, 0xC0, 0xAF, 0x4C,
894	0x8D, 0x43, 0x47, 0x1F, 0x9A, 0xF1, 0xBB, 0x88, 0x64, 0x49, 0x14, 0x50, 0xD1, 0xC3, 0xDF, 0xA6, 0x87, 0xA0, 0x15, 0x98, 0x51, 0x81, 0xF5, 0x97, 0x55, 0x10, 0x4A, 0x99, 0x30, 0x54, 0xA4,
895	0xFC, 0xDA, 0x0E, 0xAC, 0x6A, 0xFA, 0x90, 0xEE, 0x12, 0x70, 0x69, 0x74, 0x63, 0x46, 0x63, 0xFB, 0xE6, 0x1F, 0x72, 0xEC, 0x43, 0x5D, 0x50, 0xFF, 0x03, 0x4F, 0x05, 0x33, 0x88, 0x36, 0x93,
896	0xE4, 0x72, 0xD5, 0xCC, 0x34, 0x52, 0x96, 0x15, 0xCE, 0xD0, 0x32, 0x52, 0x41, 0x4F, 0xBC, 0x2D, 0xDF, 0xC5, 0xD6, 0x7F, 0xD5, 0x74, 0xCE, 0x51, 0xDC, 0x10, 0x5E, 0xF7, 0xAA, 0x4A, 0x2D,
897	0x20, 0x9A, 0x17, 0xDD, 0x30, 0x89, 0x71, 0x82, 0x36, 0x50, 0x09, 0x1F, 0x7C, 0xF3, 0x12, 0xE9, 0x43, 0x10, 0x5F, 0x51, 0xBF, 0xB8, 0x45, 0xA8, 0x5A, 0x8D, 0x3F, 0x77, 0xE5, 0x96, 0x73,
898	0x68, 0xAB, 0x73, 0xE5, 0x4C, 0xFB, 0xE5, 0x98, 0xB9, 0xAE, 0x74, 0xEB, 0x51, 0xDB, 0x91, 0x07, 0x7B, 0x66, 0x02, 0x9B, 0x79, 0x03, 0xC5, 0x34, 0x1C, 0x58, 0x13, 0x31, 0xD2, 0x4A, 0xEC
899	};
900	int ret = -1;
901	int fd = -1;
902
903	fd = open ( "/sys/class/hdmirx/hdmirx0/edid", O_RDWR );
904	if ( fd < 0 ) {
905	LOGW ( "Open hdmi hdcp key error(%s)!!\n", strerror ( errno ) );
906	return -1;
907	}
908
909	ret = write ( fd, testHdcp, 368 );
910	if ( ret < 0 ) {
911	LOGD ( "Write hdmi hdcp key error(%s)!!\n", strerror ( errno ) );
912	}
913
914	close ( fd );
915	fd = -1;
916
917	return ret;
918	}
919
920	int CTvin::VDIN_KeepLastFrame ( int enable )
921	{
922	return 0;
923	/*
924	FILE *fp = NULL;
925	fp = fopen ( "/sys/module/amvideo/parameters/keep_old_frame", "w" );
926
927	if ( fp == NULL ) {
928	LOGW ( "Open /sys/module/amvideo/parameters/keep_old_frame error(%s)!\n", strerror ( errno ) );
929	return -1;
930	}
931
932	fprintf ( fp, "%d", enable );
933
934	fclose ( fp );
935	fp = NULL;
936
937	return 0;
938	*/
939	}
940
941	int CTvin::VDIN_SetVideoFreeze ( int enable )
942	{
943	FILE *fp = NULL;
944
945	fp = fopen ( "/sys/class/vdin/vdin0/attr", "w" );
946	if ( fp == NULL ) {
947	LOGW ( "Open /sys/class/vdin/vdin0/attr error(%s)!\n", strerror ( errno ) );
948	return -1;
949	}
950
951	if ( enable == 1 ) {
952	fprintf ( fp, "freeze" );
953	} else {
954	fprintf ( fp, "unfreeze" );
955	}
956
957	fclose ( fp );
958	fp = NULL;
959
960	return 0;
961	}
962
963	int CTvin::VDIN_SetDIBypasshd ( int enable )
964	{
965	FILE *fp = NULL;
966
967	fp = fopen ( "/sys/module/di/parameters/bypass_hd", "w" );
968	if ( fp == NULL ) {
969	LOGW ( "Open /sys/module/di/parameters/bypass_hd error(%s)!\n", strerror ( errno ) );
970	return -1;
971	}
972
973	fprintf ( fp, "%d", enable );
974	fclose ( fp );
975	fp = NULL;
976
977	return 0;
978	}
979
980	int CTvin::VDIN_SetDIBypassAll ( int enable )
981	{
982	FILE *fp = NULL;
983
984	fp = fopen ( "/sys/module/di/parameters/bypass_all", "w" );
985	if ( fp == NULL ) {
986	LOGW ( "Open /sys/module/di/parameters/bypass_all error(%s)!\n", strerror ( errno ) );
987	return -1;
988	}
989
990	fprintf ( fp, "%d", enable );
991	fclose ( fp );
992	fp = NULL;
993	return 0;
994	}
995
996	int CTvin::VDIN_SetDIBypass_Get_Buf_Threshold ( int enable )
997	{
998	FILE *fp = NULL;
999
1000	fp = fopen ( "/sys/module/di/parameters/bypass_get_buf_threshold", "w" );
1001	if ( fp == NULL ) {
1002	LOGW ( "Open /sys/module/di/parameters/bypass_get_buf_threshold error(%s)!\n", strerror ( errno ) );
1003	return -1;
1004	}
1005
1006	fprintf ( fp, "%d", enable );
1007	fclose ( fp );
1008	fp = NULL;
1009
1010	return 0;
1011
1012	}
1013
1014	int CTvin::VDIN_SetDIBypassProg ( int enable )
1015	{
1016	FILE *fp = NULL;
1017
1018	fp = fopen ( "/sys/module/di/parameters/bypass_prog", "w" );
1019	if ( fp == NULL ) {
1020	LOGW ( "Open /sys/module/di/parameters/bypass_prog error(%s)!\n", strerror ( errno ) );
1021	return -1;
1022	}
1023
1024	fprintf ( fp, "%d", enable );
1025	fclose ( fp );
1026	fp = NULL;
1027
1028	return 0;
1029	}
1030
1031	int CTvin::VDIN_SetDIBypassDynamic ( int flag )
1032	{
1033	FILE *fp = NULL;
1034
1035	fp = fopen ( "/sys/module/di/parameters/bypass_dynamic", "w" );
1036	if ( fp == NULL ) {
1037	LOGW ( "Open /sys/module/di/parameters/bypass_dynamic error(%s)!\n", strerror ( errno ) );
1038	return -1;
1039	}
1040
1041	fprintf ( fp, "%d", flag );
1042	fclose ( fp );
1043	fp = NULL;
1044
1045	return 0;
1046	}
1047
1048	int CTvin::VDIN_SetDIDet3DMode ( int value )
1049	{
1050	FILE *fp = NULL;
1051
1052	fp = fopen ( "/sys/module/di/parameters/det3d_mode", "w" );
1053	if ( fp == NULL ) {
1054	LOGW ( "Open /sys/module/di/parameters/det3d_mode error(%s)!\n", strerror ( errno ) );
1055	return -1;
1056	}
1057
1058	fprintf ( fp, "%d", value );
1059	fclose ( fp );
1060	fp = NULL;
1061
1062	return 0;
1063	}
1064
1065	int CTvin::VDIN_SetDIBypass3D ( int enable )
1066	{
1067	FILE *fp = NULL;
1068
1069	fp = fopen ( "/sys/module/di/parameters/bypass_3d", "w" );
1070
1071	if ( fp == NULL ) {
1072	LOGW ( "Open /sys/module/di/parameters/bypass_3d error(%s)!\n", strerror ( errno ) );
1073	return -1;
1074	}
1075
1076	fprintf ( fp, "%d", enable );
1077	fclose ( fp );
1078	fp = NULL;
1079
1080	return 0;
1081	}
1082
1083	int CTvin::VDIN_SetDIBypassPost ( int enable )
1084	{
1085	FILE *fp = NULL;
1086
1087	fp = fopen ( "/sys/module/di/parameters/bypass_post", "w" );
1088	if ( fp == NULL ) {
1089	LOGW ( "Open /sys/module/di/parameters/bypass_post error(%s)!\n", strerror ( errno ) );
1090	return -1;
1091	}
1092
1093	fprintf ( fp, "%d", enable );
1094	fclose ( fp );
1095	fp = NULL;
1096
1097	return 0;
1098	}
1099
1100	int CTvin::set3D_FL_Frame(int value)
1101	{
1102	FILE *fp = NULL;
1103	fp = fopen ( "/sys/module/amvideo/parameters/pause_one_3d_fl_frame", "w" );
1104	if ( fp == NULL ) {
1105	LOGW ( "Open /sys/module/amvideo/parameters/pause_one_3d_fl_frame error(%s)!\n", strerror ( errno ) );
1106	return -1;
1107	}
1108	fprintf ( fp, "%d", value );
1109	fclose ( fp );
1110	fp = NULL;
1111	return 0;
1112	}
1113
1114	int CTvin::setLatchFlag(int value)
1115	{
1116	int fd = -1;
1117	int nodeVal = 0;
1118	char s[10];
1119	FILE *fp = NULL;
1120	memset(s, 0, sizeof(s));
1121	read(fd, s, sizeof(s));
1122	close(fd);
1123	nodeVal = atoi(s);
1124	fp = fopen ( "/sys/module/am_vecm/parameters/vecm_latch_flag", "w" );
1125	if ( fp == NULL ) {
1126	LOGW ( "/sys/module/am_vecm/parameters/vecm_latch_flag error(%s)!\n", strerror ( errno ) );
1127	return -1;
1128	}
1129	fprintf ( fp, "%d", value | nodeVal);
1130	fclose ( fp );
1131	fp = NULL;
1132	LOGD ( "read vecm_latch_flag = (%s)====(0x%x), then set vecm_latch_flag | 0x%x = 0x%x.\n", s, nodeVal, value, value | nodeVal);
1133	return 0;
1134	}
1135
1136	int CTvin::VDIN_SetDIProg_Proc_Config ( int value )
1137	{
1138	FILE *fp = NULL;
1139
1140	fp = fopen ( "/sys/module/di/parameters/prog_proc_config", "w" );
1141	if ( fp == NULL ) {
1142	LOGW ( "Open /sys/module/di/parameters/prog_proc_config error(%s)!\n", strerror ( errno ) );
1143	return -1;
1144	}
1145
1146	fprintf ( fp, "%d", value );
1147	fclose ( fp );
1148	fp = NULL;
1149
1150	return 0;
1151	}
1152
1153	#if(1)
1154	int CTvin::VDIN_SetDIInput2Pre ( int value )
1155	{
1156	FILE *fp = NULL;
1157
1158	fp = fopen ( "/sys/module/di/parameters/input2pre", "w" );
1159	if ( fp == NULL ) {
1160	LOGW ( "Open /sys/module/di/parameters/input2pre error(%s)!\n", strerror ( errno ) );
1161	return -1;
1162	}
1163
1164	fprintf ( fp, "%d", value );
1165	fclose ( fp );
1166	fp = NULL;
1167
1168	return 0;
1169
1170	}
1171	#endif
1172	int CTvin::VDIN_SetVdinFlag ( int flag )
1173	{
1174	FILE *fp = NULL;
1175	int freq = 1200000;
1176
1177	fp = fopen ( "/sys/class/vdin/memp", "w" );
1178	if ( fp == NULL ) {
1179	LOGW ( "Open /sys/class/vdin/memp error(%s)!\n", strerror ( errno ) );
1180	return -1;
1181	}
1182
1183	fprintf ( fp, "%d", flag );
1184	fclose ( fp );
1185	fp = NULL;
1186
1187	return 0;
1188	}
1189
1190	int CTvin::VDIN_EnableRDMA ( int enable )
1191	{
1192	FILE *fp = NULL;
1193	fp = fopen ( "/sys/module/rdma/parameters/enable", "w" );
1194
1195	if ( fp == NULL ) {
1196	LOGW ( "Open /sys/module/rdma/parameters/enable error(%s)!\n", strerror ( errno ) );
1197	return -1;
1198	}
1199
1200	fprintf ( fp, "%d", enable );
1201	fclose ( fp );
1202	fp = NULL;
1203	return 0;
1204	}
1205
1206	// AFE
1207	int CTvin::AFE_OpenModule ( void )
1208	{
1209	if ( afe_dev_fd < 0 ) {
1210	afe_dev_fd = open ( AFE_DEV_PATH, O_RDWR );
1211
1212	if ( afe_dev_fd < 0 ) {
1213	LOGW ( "Open tvafe module, error(%s).\n", strerror ( errno ) );
1214	return -1;
1215	}
1216	}
1217
1218	return afe_dev_fd;
1219	}
1220
1221	void CTvin::AFE_CloseModule ( void )
1222	{
1223	if ( afe_dev_fd >= 0 ) {
1224	close ( afe_dev_fd );
1225	afe_dev_fd = -1;
1226	}
1227
1228	return;
1229	}
1230
1231	int CTvin::AFE_DeviceIOCtl ( int request, ... )
1232	{
1233	int tmp_ret = -1;
1234	va_list ap;
1235	void *arg;
1236
1237	if ( afe_dev_fd >= 0 ) {
1238	va_start ( ap, request );
1239	arg = va_arg ( ap, void * );
1240	va_end ( ap );
1241
1242	tmp_ret = ioctl ( afe_dev_fd, request, arg );
1243
1244	return tmp_ret;
1245	}
1246
1247	return -1;
1248	}
1249
1250	int CTvin::AFE_GetDeviceFileHandle()
1251	{
1252	return afe_dev_fd;
1253	}
1254
1255	int CTvin::AFE_SetVGAEdid ( const unsigned char *ediddata )
1256	{
1257	int rt = -1;
1258	struct tvafe_vga_edid_s vgaEdid;
1259
1260	#ifdef NO_IC_TEST
1261
1262	for ( int i = 0; i < 256; i++ ) {
1263	test_edid[i] = ediddata[i];
1264	}
1265
1266	#endif
1267
1268	for ( int i = 0; i < 256; i++ ) {
1269	vgaEdid.value[i] = ediddata[i];
1270	}
1271
1272	rt = AFE_DeviceIOCtl ( TVIN_IOC_S_AFE_VGA_EDID, &vgaEdid );
1273
1274	if ( rt < 0 ) {
1275	LOGW ( "AFE_SetVGAEdid, error(%s).!\n", strerror ( errno ) );
1276	}
1277
1278	return rt;
1279	}
1280
1281	int CTvin::AFE_GetVGAEdid ( unsigned char *ediddata )
1282	{
1283	int rt = -1;
1284	struct tvafe_vga_edid_s vgaEdid;
1285
1286	#ifdef NO_IC_TEST
1287
1288	for ( int i = 0; i < 256; i++ ) {
1289	ediddata[i] = test_edid[i];
1290	}
1291
1292	LOGD ( "AFE_GetVGAEdid:\n" );
1293	LOGD ( "===================================================\n" );
1294
1295	for ( int i = 0; i < 256; i++ ) {
1296	LOGD ( "vag edid[%d] = [0x%x].\n", i, ediddata[i] );
1297	}
1298
1299	LOGD ( "===================================================\n" );
1300	#endif
1301
1302	rt = AFE_DeviceIOCtl ( TVIN_IOC_G_AFE_VGA_EDID, &vgaEdid );
1303
1304	for ( int i = 0; i < 256; i++ ) {
1305	ediddata[i] = vgaEdid.value[i];
1306	}
1307
1308	if ( rt < 0 ) {
1309	LOGW ( "AFE_GetVGAEdid, error(%s)!\n", strerror ( errno ) );
1310	}
1311
1312	return rt;
1313	}
1314
1315	int CTvin::AFE_SetADCTimingAdjust ( const struct tvafe_vga_parm_s *timingadj )
1316	{
1317	int rt = -1;
1318
1319	if ( timingadj == NULL ) {
1320	return rt;
1321	}
1322
1323	rt = AFE_DeviceIOCtl ( TVIN_IOC_S_AFE_VGA_PARM, timingadj );
1324
1325	if ( rt < 0 ) {
1326	LOGW ( "AFE_SetADCTimingAdjust, error(%s)!\n", strerror ( errno ) );
1327	}
1328
1329	return rt;
1330	}
1331
1332	int CTvin::AFE_GetADCCurrentTimingAdjust ( struct tvafe_vga_parm_s *timingadj )
1333	{
1334	int rt = -1;
1335
1336	if ( timingadj == NULL ) {
1337	return rt;
1338	}
1339
1340	rt = AFE_DeviceIOCtl ( TVIN_IOC_G_AFE_VGA_PARM, timingadj );
1341
1342	if ( rt < 0 ) {
1343	LOGW ( "AFE_GetADCCurrentTimingAdjust, error(%s)!\n", strerror ( errno ) );
1344	return -1;
1345	}
1346
1347	return 0;
1348	}
1349
1350	int CTvin::AFE_VGAAutoAdjust ( struct tvafe_vga_parm_s *timingadj )
1351	{
1352	enum tvafe_cmd_status_e CMDStatus = TVAFE_CMD_STATUS_PROCESSING;
1353	struct tvin_parm_s tvin_para;
1354	int rt = -1, i = 0;
1355
1356	if ( timingadj == NULL ) {
1357	return -1;
1358	}
1359
1360	for ( i = 0, CMDStatus == TVAFE_CMD_STATUS_PROCESSING; i < 50; i++ ) {
1361	rt = AFE_DeviceIOCtl ( TVIN_IOC_G_AFE_CMD_STATUS, &CMDStatus );
1362
1363	if ( rt < 0 ) {
1364	LOGD ( "get afe CMD status, error(%s), fd(%d), return(%d).\n", strerror ( errno ), AFE_GetDeviceFileHandle(), rt );
1365	}
1366
1367	if ( ( CMDStatus == TVAFE_CMD_STATUS_IDLE ) || ( CMDStatus == TVAFE_CMD_STATUS_SUCCESSFUL ) ) {
1368	break;
1369	}
1370
1371	usleep ( 10 * 1000 );
1372	}
1373
1374	if ( ( CMDStatus == TVAFE_CMD_STATUS_PROCESSING ) || ( CMDStatus == TVAFE_CMD_STATUS_FAILED ) ) {
1375	return -1;
1376	}
1377
1378	for ( i = 0; i < 100; i++ ) {
1379	rt = VDIN_DeviceIOCtl ( TVIN_IOC_G_PARM, &tvin_para );
1380
1381	if ( tvin_para.info.status == TVIN_SIG_STATUS_STABLE ) {
1382	break;
1383	}
1384
1385	usleep ( 10 * 1000 );
1386	}
1387
1388	rt = AFE_DeviceIOCtl ( TVIN_IOC_S_AFE_VGA_AUTO );
1389
1390	if ( rt < 0 ) {
1391	timingadj->clk_step = 0;
1392	timingadj->phase = 0;
1393	timingadj->hpos_step = 0;
1394	timingadj->vpos_step = 0;
1395	AFE_DeviceIOCtl ( TVIN_IOC_S_AFE_VGA_PARM, timingadj );
1396	return rt;
1397	} else {
1398	;//AFE_DeviceIOCtl(TVIN_IOC_G_AFE_VGA_PARM, timingadj);
1399	}
1400
1401	for ( i = 0; i < 10; i++ ) {
1402	sleep ( 1 );
1403
1404	rt = AFE_DeviceIOCtl ( TVIN_IOC_G_AFE_CMD_STATUS, &CMDStatus );
1405
1406	if ( rt < 0 ) {
1407	return rt;
1408	} else {
1409	if ( CMDStatus == TVAFE_CMD_STATUS_SUCCESSFUL ) {
1410	usleep ( 100 * 1000 );
1411	AFE_GetADCCurrentTimingAdjust ( timingadj );
1412	LOGD ( "===================================================\n" );
1413	LOGW ( "AFE_VGAAutoAdjust, successfull!\n" );
1414	return 0;
1415	}
1416	}
1417	}
1418
1419	return -1;
1420	}
1421
1422	int CTvin::AFE_SetVGAAutoAjust ( void )
1423	{
1424	int rt = -1;
1425	tvafe_vga_parm_t timingadj;
1426	tvafe_cmd_status_t Status;
1427	rt = AFE_DeviceIOCtl ( TVIN_IOC_G_AFE_CMD_STATUS, &Status );
1428
1429	if ( ( Status == TVAFE_CMD_STATUS_IDLE ) || ( Status == TVAFE_CMD_STATUS_SUCCESSFUL ) ) {
1430	;
1431	} else {
1432	LOGW ( "AFE_SetVGAAutoAjust, TVIN_IOC_G_AFE_CMD_STATUS failed!\n" );
1433	return -1;
1434	}
1435
1436	rt = AFE_DeviceIOCtl ( TVIN_IOC_S_AFE_VGA_AUTO );
1437
1438	if ( rt < 0 ) {
1439	timingadj.clk_step = 0;
1440	timingadj.phase = 0;
1441	timingadj.hpos_step = 0;
1442	timingadj.vpos_step = 0;
1443	AFE_DeviceIOCtl ( TVIN_IOC_S_AFE_VGA_PARM, &timingadj );
1444	return rt;
1445	}
1446
1447	return 0;
1448	}
1449
1450	int CTvin::AFE_GetVGAAutoAdjustCMDStatus ( tvafe_cmd_status_t *Status )
1451	{
1452	int rt = -1;
1453
1454	if ( Status == NULL ) {
1455	return rt;
1456	}
1457
1458	rt = AFE_DeviceIOCtl ( TVIN_IOC_G_AFE_CMD_STATUS, Status );
1459
1460	if ( rt < 0 ) {
1461	LOGW ( "AFE_GetVGAAutoAdjustStatus, get status, error(%s) fd(%d) return(%d)\n", strerror ( errno ), AFE_GetDeviceFileHandle(), rt );
1462	return rt;
1463	}
1464
1465	return 0;
1466	}
1467
1468	int CTvin::AFE_GetAdcCal ( struct tvafe_adc_cal_s *adccalvalue )
1469	{
1470	int rt = -1;
1471
1472	rt = AFE_DeviceIOCtl ( TVIN_IOC_G_AFE_ADC_CAL, adccalvalue );
1473
1474	if ( rt < 0 ) {
1475	LOGW ( "AFE_GetADCGainOffset, error(%s)!\n", strerror ( errno ) );
1476	}
1477
1478	return rt;
1479	}
1480
1481	int CTvin::AFE_SetAdcCal ( struct tvafe_adc_cal_s *adccalvalue )
1482	{
1483	int rt = AFE_DeviceIOCtl ( TVIN_IOC_S_AFE_ADC_CAL, adccalvalue );
1484
1485	if ( rt < 0 ) {
1486	LOGW ( "AFE_SetAdcCal, error(%s)!", strerror ( errno ) );
1487	}
1488
1489	return rt;
1490	}
1491
1492	int CTvin::AFE_GetAdcCompCal ( struct tvafe_adc_comp_cal_s *adccalvalue )
1493	{
1494	int rt = -1;
1495
1496	rt = AFE_DeviceIOCtl ( TVIN_IOC_G_AFE_ADC_COMP_CAL, adccalvalue );
1497
1498	if ( rt < 0 ) {
1499	LOGW ( "AFE_GetYPbPrADCGainOffset, error(%s)!\n", strerror ( errno ) );
1500	}
1501
1502	return rt;
1503	}
1504
1505	int CTvin::AFE_SetAdcCompCal ( struct tvafe_adc_comp_cal_s *adccalvalue )
1506	{
1507	int rt = AFE_DeviceIOCtl ( TVIN_IOC_S_AFE_ADC_COMP_CAL, adccalvalue );
1508
1509	if ( rt < 0 ) {
1510	LOGW ( "AFE_SetYPbPrADCGainOffset, error(%s)!", strerror ( errno ) );
1511	}
1512
1513	return rt;
1514	}
1515	int CTvin::AFE_GetYPbPrWSSinfo ( struct tvafe_comp_wss_s *wssinfo )
1516	{
1517	int rt = AFE_DeviceIOCtl ( TVIN_IOC_G_AFE_COMP_WSS, wssinfo );
1518
1519	if ( rt < 0 ) {
1520	LOGW ( "AFE_GetYPbPrWSSinfo, error(%s)!", strerror ( errno ) );
1521	}
1522
1523	return rt;
1524	}
1525
1526	#define RGB444 3
1527	#define YCBCR422 2
1528	#define YCBCR444 3
1529	#define Y422_POS 0
1530	#define CB422_POS 1
1531	#define CR422_POS 3
1532	#define Y444_POS 0
1533	#define CB444_POS 1
1534	#define CR444_POS 2
1535	#define R444_POS 0
1536	#define G444_POS 1
1537	#define B444_POS 2
1538
1539	//=========== VGA =====================
1540	#define VGA_BUF_WID (VGA_H_ACTIVE)
1541
1542	#ifdef PATTERN_7_COLOR_BAR
1543	#define VGA_BAR_WID (VGA_H_ACTIVE/7)
1544	#define VGA_H_CUT_WID (10)
1545	#else
1546	#define VGA_BAR_WID (VGA_H_ACTIVE/8)
1547	#define VGA_H_CUT_WID (10)
1548	#endif
1549
1550	#define VGA_V_CUT_WID (40)
1551	#define VGA_V_CAL_WID (200+VGA_V_CUT_WID)
1552
1553	#define VGA_WHITE_HS (VGA_BAR_WID*0+VGA_H_CUT_WID)
1554	#define VGA_WHITE_HE (VGA_BAR_WID*1-VGA_H_CUT_WID-1)
1555	#define VGA_WHITE_VS (VGA_V_CUT_WID)
1556	#define VGA_WHITE_VE (VGA_V_CAL_WID-1)
1557	#define VGA_WHITE_SIZE ((VGA_WHITE_HE-VGA_WHITE_HS+1)*(VGA_WHITE_VE-VGA_WHITE_VS+1))
1558	#ifdef PATTERN_7_COLOR_BAR
1559	#define VGA_BLACK_HS (VGA_BAR_WID*6+VGA_H_CUT_WID)
1560	#define VGA_BLACK_HE (VGA_BAR_WID*7-VGA_H_CUT_WID-1)
1561	#define VGA_BLACK_VS (768-140)
1562	#define VGA_BLACK_VE (768-40-1)
1563	#define VGA_BLACK_SIZE ((VGA_BLACK_HE-VGA_BLACK_HS+1)*(VGA_BLACK_VE-VGA_BLACK_VS+1))
1564	#else
1565	#define VGA_BLACK_HS (VGA_BAR_WID*7+VGA_H_CUT_WID)
1566	#define VGA_BLACK_HE (VGA_BAR_WID*8-VGA_H_CUT_WID-1)
1567	#define VGA_BLACK_VS (VGA_V_CUT_WID)
1568	#define VGA_BLACK_VE (VGA_V_CAL_WID-1)
1569	#define VGA_BLACK_SIZE ((VGA_BLACK_HE-VGA_BLACK_HS+1)*(VGA_BLACK_VE-VGA_BLACK_VS+1))
1570	#endif
1571
1572	//=========== YPBPR =====================
1573	#define COMP_BUF_WID (COMP_H_ACTIVE)
1574
1575	#define COMP_BAR_WID (COMP_H_ACTIVE/8)
1576	#define COMP_H_CUT_WID (20)
1577	#define COMP_V_CUT_WID (100)
1578	#define COMP_V_CAL_WID (200+COMP_V_CUT_WID)
1579
1580	#define COMP_WHITE_HS (COMP_BAR_WID*0+COMP_H_CUT_WID)
1581	#define COMP_WHITE_HE (COMP_BAR_WID*1-COMP_H_CUT_WID-1)
1582	#define COMP_WHITE_VS (COMP_V_CUT_WID)
1583	#define COMP_WHITE_VE (COMP_V_CAL_WID-1)
1584	#define COMP_WHITE_SIZE ((COMP_WHITE_HE-COMP_WHITE_HS+1)*(COMP_WHITE_VE-COMP_WHITE_VS+1))
1585	#define CB_WHITE_SIZE ((COMP_WHITE_HE-COMP_WHITE_HS+1)*(COMP_WHITE_VE-COMP_WHITE_VS+1)/2)
1586	#define CR_WHITE_SIZE ((COMP_WHITE_HE-COMP_WHITE_HS+1)*(COMP_WHITE_VE-COMP_WHITE_VS+1)/2)
1587
1588	#define COMP_YELLOW_HS (COMP_BAR_WID*1+COMP_H_CUT_WID)
1589	#define COMP_YELLOW_HE (COMP_BAR_WID*2-COMP_H_CUT_WID-1)
1590	#define COMP_YELLOW_VS (COMP_V_CUT_WID)
1591	#define COMP_YELLOW_VE (COMP_V_CAL_WID-1)
1592	#define COMP_YELLOW_SIZE ((COMP_YELLOW_HE-COMP_YELLOW_HS+1)*(COMP_YELLOW_VE-COMP_YELLOW_VS+1)/2)
1593
1594	#define COMP_CYAN_HS (COMP_BAR_WID*2+COMP_H_CUT_WID)
1595	#define COMP_CYAN_HE (COMP_BAR_WID*3-COMP_H_CUT_WID-1)
1596	#define COMP_CYAN_VS (COMP_V_CUT_WID)
1597	#define COMP_CYAN_VE (COMP_V_CAL_WID-1)
1598	#define COMP_CYAN_SIZE ((COMP_CYAN_HE-COMP_CYAN_HS+1)*(COMP_CYAN_VE-COMP_CYAN_VS+1)/2)
1599
1600	#define COMP_RED_HS (COMP_BAR_WID*5+COMP_H_CUT_WID)
1601	#define COMP_RED_HE (COMP_BAR_WID*6-COMP_H_CUT_WID-1)
1602	#define COMP_RED_VS (COMP_V_CUT_WID)
1603	#define COMP_RED_VE (COMP_V_CAL_WID-1)
1604	#define COMP_RED_SIZE ((COMP_RED_HE-COMP_RED_HS+1)*(COMP_RED_VE-COMP_RED_VS+1)/2)
1605
1606	#define COMP_BLUE_HS (COMP_BAR_WID*6+COMP_H_CUT_WID)
1607	#define COMP_BLUE_HE (COMP_BAR_WID*7-COMP_H_CUT_WID-1)
1608	#define COMP_BLUE_VS (COMP_V_CUT_WID)
1609	#define COMP_BLUE_VE (COMP_V_CAL_WID-1)
1610	#define COMP_BLUE_SIZE ((COMP_BLUE_HE-COMP_BLUE_HS+1)*(COMP_BLUE_VE-COMP_BLUE_VS+1)/2)
1611
1612	#define COMP_BLACK_HS (COMP_BAR_WID*7+COMP_H_CUT_WID)
1613	#define COMP_BLACK_HE (COMP_BAR_WID*8-COMP_H_CUT_WID-1)
1614	#define COMP_BLACK_VS (COMP_V_CUT_WID)
1615	#define COMP_BLACK_VE (COMP_V_CAL_WID-1)
1616	#define COMP_BLACK_SIZE ((COMP_BLACK_HE-COMP_BLACK_HS+1)*(COMP_BLACK_VE-COMP_BLACK_VS+1))
1617	#define CB_BLACK_SIZE ((COMP_BLACK_HE-COMP_BLACK_HS+1)*(COMP_BLACK_VE-COMP_BLACK_VS+1)/2)
1618	#define CR_BLACK_SIZE ((COMP_BLACK_HE-COMP_BLACK_HS+1)*(COMP_BLACK_VE-COMP_BLACK_VS+1)/2)
1619
1620	//=========== CVBS =====================
1621	#define CVBS_BUF_WID (CVBS_H_ACTIVE)
1622	#define CVBS_BAR_WID (CVBS_H_ACTIVE/8)
1623	#define CVBS_H_CUT_WID (20)
1624
1625	#define CVBS_V_CUT_WID (40)
1626	#define CVBS_V_CAL_WID (140+CVBS_V_CUT_WID)
1627
1628	#define CVBS_WHITE_HS (CVBS_BAR_WID*0+CVBS_H_CUT_WID)
1629	#define CVBS_WHITE_HE (CVBS_BAR_WID*1-CVBS_H_CUT_WID-1)
1630	#define CVBS_WHITE_VS (CVBS_V_CUT_WID)
1631	#define CVBS_WHITE_VE (CVBS_V_CAL_WID-1)
1632	#define CVBS_WHITE_SIZE ((CVBS_WHITE_HE-CVBS_WHITE_HS+1)*(CVBS_WHITE_VE-CVBS_WHITE_VS+1))
1633
1634	#define CVBS_BLACK_HS (CVBS_BAR_WID*7+CVBS_H_CUT_WID)
1635	#define CVBS_BLACK_HE (CVBS_BAR_WID*8-CVBS_H_CUT_WID-1)
1636	#define CVBS_BLACK_VS (CVBS_V_CUT_WID)
1637	#define CVBS_BLACK_VE (CVBS_V_CAL_WID-1)
1638	#define CVBS_BLACK_SIZE ((CVBS_BLACK_HE-CVBS_BLACK_HS+1)*(CVBS_BLACK_VE-CVBS_BLACK_VS+1))
1639
1640	#define COMP_CAP_SIZE (COMP_H_ACTIVE*COMP_V_ACTIVE*YCBCR422)
1641	#ifdef VGA_SOURCE_RGB444
1642	#define VGA_CAP_SIZE (VGA_H_ACTIVE*VGA_V_ACTIVE*RGB444)
1643	#else
1644	#define VGA_CAP_SIZE (VGA_H_ACTIVE*VGA_V_ACTIVE*YCBCR444)
1645	#endif
1646	#define CVBS_CAP_SIZE (CVBS_H_ACTIVE*CVBS_V_ACTIVE)
1647
1648	#define PRE_0 -16
1649	#define PRE_1 -128
1650	#define PRE_2 -128
1651	#define COEF_00 1.164
1652	#define COEF_01 0
1653	#define COEF_02 1.793
1654	#define COEF_10 1.164
1655	#define COEF_11 -0.213
1656	#define COEF_12 -0.534
1657	#define COEF_20 1.164
1658	#define COEF_21 2.115
1659	#define COEF_22 0
1660	#define POST_0 0
1661	#define POST_1 0
1662	#define POST_2 0
1663
1664	unsigned int CTvin::data_limit ( float data )
1665	{
1666	if ( data < 0 ) {
1667	return ( 0 );
1668	} else if ( data > 255 ) {
1669	return ( 255 );
1670	} else {
1671	return ( ( unsigned int ) data );
1672	}
1673	}
1674
1675	void CTvin::matrix_convert_yuv709_to_rgb ( unsigned int y, unsigned int u, unsigned int v, unsigned int *r, unsigned int *g, unsigned int *b )
1676	{
1677	*r = data_limit ( ( ( float ) y + PRE_0 ) * COEF_00 + ( ( float ) u + PRE_1 ) * COEF_01 + ( ( float ) v + PRE_2 ) * COEF_02 + POST_0 + 0.5 );
1678	*g = data_limit ( ( ( float ) y + PRE_0 ) * COEF_10 + ( ( float ) u + PRE_1 ) * COEF_11 + ( ( float ) v + PRE_2 ) * COEF_12 + POST_1 + 0.5 );
1679	*b = data_limit ( ( ( float ) y + PRE_0 ) * COEF_20 + ( ( float ) u + PRE_1 ) * COEF_21 + ( ( float ) v + PRE_2 ) * COEF_22 + POST_2 + 0.5 );
1680	}
1681
1682	void CTvin::re_order ( unsigned int *a, unsigned int *b )
1683	{
1684	unsigned int c = 0;
1685
1686	if ( *a > *b ) {
1687	c = *a;
1688	*a = *b;
1689	*b = c;
1690	}
1691	}
1692
1693	char *CTvin::get_cap_addr ( enum adc_cal_type_e calType )
1694	{
1695	int n;
1696	char *dp;
1697
1698	for ( n = 0; n < 0x00ff; n++ ) {
1699	if ( VDIN_DeviceIOCtl ( TVIN_IOC_G_SIG_INFO, &gTvinAFESignalInfo ) < 0 ) {
1700	LOGW ( "get_cap_addr, get signal info, error(%s),fd(%d).\n", strerror ( errno ), m_vdin_dev_fd );
1701	return NULL;
1702	} else {
1703	if ( gTvinAFESignalInfo.status == TVIN_SIG_STATUS_STABLE ) {
1704	gTvinAFEParam.info.fmt = gTvinAFESignalInfo.fmt;
1705	break;
1706	}
1707	}
1708	}
1709
1710	if ( gTvinAFESignalInfo.status != TVIN_SIG_STATUS_STABLE ) {
1711	LOGD ( "get_cap_addr, signal isn't stable, out of calibration!\n" );
1712	return NULL;
1713	} else {
1714	if ( VDIN_DeviceIOCtl ( TVIN_IOC_STOP_DEC ) < 0 ) {
1715	LOGW ( "get_cap_addr, stop vdin, error (%s).\n", strerror ( errno ) );
1716	return NULL;
1717	}
1718
1719	usleep ( 1000 );
1720
1721	if ( calType == CAL_YPBPR ) {
1722	dp = ( char * ) mmap ( NULL, COMP_CAP_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, m_vdin_dev_fd, 0 );
1723	} else {
1724	dp = ( char * ) mmap ( NULL, VGA_CAP_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, m_vdin_dev_fd, 0 );
1725	}
1726
1727	if ( dp < 0 ) {
1728	LOGD ( "get_cap_addr, mmap failed!\n" );
1729	}
1730
1731	return dp;
1732	}
1733
1734	return NULL;
1735	}
1736
1737	inline unsigned char CTvin::get_mem_data ( char *dp, unsigned int addr )
1738	{
1739	return ( * ( dp + ( addr ^ 7 ) ) );
1740	}
1741
1742	int CTvin::get_frame_average ( enum adc_cal_type_e calType, struct adc_cal_s *mem_data )
1743	{
1744	unsigned int y = 0, cb = 0, cr = 0;
1745	unsigned int r = 0, g = 0, b = 0;
1746	unsigned long n;
1747	unsigned int i = 0, j = 0;
1748	char *dp = get_cap_addr ( calType );
1749
1750	if ( calType == CAL_YPBPR ) {
1751	for ( j = COMP_WHITE_VS; j <= COMP_WHITE_VE; j++ ) {
1752	for ( i = COMP_WHITE_HS; i <= COMP_WHITE_HE; i++ ) {
1753	mem_data->g_y_max += get_mem_data ( dp, ( ( COMP_BUF_WID * j + i ) * YCBCR422 ) );
1754	}
1755	}
1756
1757	mem_data->g_y_max /= COMP_WHITE_SIZE;
1758
1759	for ( j = COMP_WHITE_VS; j <= COMP_WHITE_VE; j++ ) {
1760	for ( i = COMP_WHITE_HS; i <= COMP_WHITE_HE; ) {
1761	mem_data->cb_white += get_mem_data ( dp, ( ( COMP_BUF_WID * j + i ) * YCBCR422 + CB422_POS ) );
1762	mem_data->cr_white += get_mem_data ( dp, ( ( COMP_BUF_WID * j + i ) * YCBCR422 + CR422_POS ) );
1763	i = i + 2;
1764	}
1765	}
1766
1767	mem_data->cb_white /= CB_WHITE_SIZE;
1768	mem_data->cr_white /= CR_WHITE_SIZE;
1769
1770	for ( j = COMP_RED_VS; j <= COMP_RED_VE; j++ ) {
1771	for ( i = COMP_RED_HS; i <= COMP_RED_HE; ) {
1772	mem_data->rcr_max += get_mem_data ( dp, ( ( COMP_BUF_WID * j + i ) * YCBCR422 + CR422_POS ) );
1773	i = i + 2;
1774	}
1775	}
1776
1777	mem_data->rcr_max /= COMP_RED_SIZE;
1778
1779	for ( j = COMP_BLUE_VS; j <= COMP_BLUE_VE; j++ ) {
1780	for ( i = COMP_BLUE_HS; i <= COMP_BLUE_HE; ) {
1781	mem_data->bcb_max += get_mem_data ( dp, ( ( COMP_BUF_WID * j + i ) * YCBCR422 + CB422_POS ) );
1782	i = i + 2;
1783	}
1784	}
1785
1786	mem_data->bcb_max /= COMP_BLUE_SIZE;
1787
1788	for ( j = COMP_BLACK_VS; j <= COMP_BLACK_VE; j++ ) {
1789	for ( i = COMP_BLACK_HS; i <= COMP_BLACK_HE; i++ ) {
1790	mem_data->g_y_min += get_mem_data ( dp, ( ( COMP_BUF_WID * j + i ) * YCBCR422 ) );
1791	}
1792	}
1793
1794	mem_data->g_y_min /= COMP_BLACK_SIZE;
1795
1796	for ( j = COMP_BLACK_VS; j <= COMP_BLACK_VE; j++ ) {
1797	for ( i = COMP_BLACK_HS; i <= COMP_BLACK_HE; ) {
1798	mem_data->cb_black += get_mem_data ( dp, ( ( COMP_BUF_WID * j + i ) * YCBCR422 + CB422_POS ) );
1799	mem_data->cr_black += get_mem_data ( dp, ( ( COMP_BUF_WID * j + i ) * YCBCR422 + CR422_POS ) );
1800	i = i + 2;
1801	}
1802	}
1803
1804	mem_data->cb_black /= CB_BLACK_SIZE;
1805	mem_data->cr_black /= CR_BLACK_SIZE;
1806
1807	/*
1808	for (j=COMP_BLACK_VS; j<=COMP_BLACK_VE; j++) {
1809	for (i=COMP_BLACK_HS; i<=COMP_BLACK_HE;) {
1810	//mem_data->cb_black += get_mem_data(dp, ((COMP_BUF_WID*j+i)*YCBCR422+CB422_POS));
1811	mem_data->cr_black += get_mem_data(dp, ((COMP_BUF_WID*j+i)*YCBCR422+CR422_POS));
1812	i = i+2;
1813	}
1814	}
1815	mem_data->cr_black /= CR_BLACK_SIZE;
1816	*/
1817	for ( j = COMP_CYAN_VS; j <= COMP_CYAN_VE; j++ ) {
1818	for ( i = COMP_CYAN_HS; i <= COMP_CYAN_HE; ) {
1819	mem_data->rcr_min += get_mem_data ( dp, ( ( COMP_BUF_WID * j + i ) * YCBCR422 + CR422_POS ) );
1820	i = i + 2;
1821	}
1822	}
1823
1824	mem_data->rcr_min /= COMP_CYAN_SIZE;
1825
1826	for ( j = COMP_YELLOW_VS; j <= COMP_YELLOW_VE; j++ ) {
1827	for ( i = COMP_YELLOW_HS; i <= COMP_YELLOW_HE; ) {
1828	mem_data->bcb_min += get_mem_data ( dp, ( COMP_BUF_WID * j + i ) * YCBCR422 + CB422_POS );
1829	i = i + 2;
1830	}
1831	}
1832
1833	mem_data->bcb_min /= COMP_YELLOW_SIZE;
1834
1835	} else if ( calType == CAL_VGA ) {
1836	for ( j = VGA_WHITE_VS; j <= VGA_WHITE_VE; j++ ) {
1837	for ( i = VGA_WHITE_HS; i <= VGA_WHITE_HE; i++ ) {
1838	#ifdef VGA_SOURCE_RGB444
1839	r = get_mem_data ( dp, ( ( VGA_BUF_WID * j + i ) * RGB444 + R444_POS ) );
1840	g = get_mem_data ( dp, ( ( VGA_BUF_WID * j + i ) * RGB444 + G444_POS ) );
1841	b = get_mem_data ( dp, ( ( VGA_BUF_WID * j + i ) * RGB444 + B444_POS ) );
1842	#else
1843	y = get_mem_data ( dp, ( ( VGA_BUF_WID * j + i ) * YCBCR444 + Y444_POS ) );
1844	cb = get_mem_data ( dp, ( ( VGA_BUF_WID * j + i ) * YCBCR444 + CB444_POS ) );
1845	cr = get_mem_data ( dp, ( ( VGA_BUF_WID * j + i ) * YCBCR444 + CR444_POS ) );
1846	matrix_convert_yuv709_to_rgb ( y, cb, cr, &r, &g, &b );
1847	#endif
1848	mem_data->rcr_max = mem_data->rcr_max + r;
1849	mem_data->g_y_max = mem_data->g_y_max + g;
1850	mem_data->bcb_max = mem_data->bcb_max + b;
1851	}
1852	}
1853
1854	mem_data->rcr_max = mem_data->rcr_max / VGA_WHITE_SIZE;
1855	mem_data->g_y_max = mem_data->g_y_max / VGA_WHITE_SIZE;
1856	mem_data->bcb_max = mem_data->bcb_max / VGA_WHITE_SIZE;
1857
1858	for ( j = VGA_BLACK_VS; j <= VGA_BLACK_VE; j++ ) {
1859	for ( i = VGA_BLACK_HS; i <= VGA_BLACK_HE; i++ ) {
1860	#ifdef VGA_SOURCE_RGB444
1861	r = get_mem_data ( dp, ( ( VGA_BUF_WID * j + i ) * RGB444 + R444_POS ) );
1862	g = get_mem_data ( dp, ( ( VGA_BUF_WID * j + i ) * RGB444 + G444_POS ) );
1863	b = get_mem_data ( dp, ( ( VGA_BUF_WID * j + i ) * RGB444 + B444_POS ) );
1864	#else
1865	y = get_mem_data ( dp, ( ( VGA_BUF_WID * j + i ) * YCBCR444 + Y444_POS ) );
1866	cb = get_mem_data ( dp, ( ( VGA_BUF_WID * j + i ) * YCBCR444 + CB444_POS ) );
1867	cr = get_mem_data ( dp, ( ( VGA_BUF_WID * j + i ) * YCBCR444 + CR444_POS ) );
1868	matrix_convert_yuv709_to_rgb ( y, cb, cr, &r, &g, &b );
1869	#endif
1870	mem_data->rcr_min = mem_data->rcr_min + r;
1871	mem_data->g_y_min = mem_data->g_y_min + g;
1872	mem_data->bcb_min = mem_data->bcb_min + b;
1873	}
1874	}
1875
1876	mem_data->rcr_min = mem_data->rcr_min / VGA_BLACK_SIZE;
1877	mem_data->g_y_min = mem_data->g_y_min / VGA_BLACK_SIZE;
1878	mem_data->bcb_min = mem_data->bcb_min / VGA_BLACK_SIZE;
1879
1880	} else { //CVBS
1881	for ( j = CVBS_WHITE_VS; j <= CVBS_WHITE_VE; j++ ) {
1882	for ( i = CVBS_WHITE_HS; i <= CVBS_WHITE_HE; i++ ) {
1883	mem_data->g_y_max += mem_data->g_y_max + get_mem_data ( dp, ( ( CVBS_BUF_WID * j + i ) * YCBCR422 ) );
1884	}
1885	}
1886
1887	mem_data->g_y_max /= COMP_WHITE_SIZE;
1888
1889	for ( j = CVBS_BLACK_VS; j <= CVBS_BLACK_VE; j++ ) {
1890	for ( i = CVBS_BLACK_HS; i <= CVBS_BLACK_HE; i++ ) {
1891	mem_data->g_y_min += mem_data->g_y_min + get_mem_data ( dp, ( ( CVBS_BUF_WID * j + i ) * YCBCR422 ) );
1892	}
1893	}
1894
1895	mem_data->g_y_min /= CVBS_BLACK_SIZE;
1896	}
1897
1898	if ( calType == CAL_YPBPR ) {
1899	munmap ( dp, COMP_CAP_SIZE );
1900	} else if ( calType == CAL_VGA ) {
1901	munmap ( dp, VGA_CAP_SIZE );
1902	} else {
1903	munmap ( dp, CVBS_CAP_SIZE );
1904	}
1905
1906	if ( VDIN_DeviceIOCtl ( TVIN_IOC_START_DEC, &gTvinAFEParam ) < 0 ) {
1907	LOGW ( "get_frame_average, get vdin signal info, error(%s),fd(%d).\n", strerror ( errno ), m_vdin_dev_fd );
1908	return NULL;
1909	} else {
1910	;
1911	}
1912
1913	return 0;
1914	}
1915
1916	#define ADC_CAL_FRAME_QTY_ORDER 2 //NOTE: MUST >=2!!
1917	struct adc_cal_s CTvin::get_n_frame_average ( enum adc_cal_type_e calType )
1918	{
1919	struct adc_cal_s mem_data = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
1920	unsigned int rcrmax[1 << ADC_CAL_FRAME_QTY_ORDER];
1921	unsigned int rcrmin[1 << ADC_CAL_FRAME_QTY_ORDER];
1922	unsigned int g_ymax[1 << ADC_CAL_FRAME_QTY_ORDER];
1923	unsigned int g_ymin[1 << ADC_CAL_FRAME_QTY_ORDER];
1924	unsigned int bcbmax[1 << ADC_CAL_FRAME_QTY_ORDER];
1925	unsigned int bcbmin[1 << ADC_CAL_FRAME_QTY_ORDER];
1926	unsigned int cbwhite[1 << ADC_CAL_FRAME_QTY_ORDER];
1927	unsigned int crwhite[1 << ADC_CAL_FRAME_QTY_ORDER];
1928	unsigned int cbblack[1 << ADC_CAL_FRAME_QTY_ORDER];
1929	unsigned int crblack[1 << ADC_CAL_FRAME_QTY_ORDER];
1930	unsigned int i = 0, j = 0;
1931
1932	for ( i = 0; i < ( 1 << ADC_CAL_FRAME_QTY_ORDER ); i++ ) {
1933	get_frame_average ( calType, &mem_data );
1934	rcrmax[i] = mem_data.rcr_max;
1935	rcrmin[i] = mem_data.rcr_min;
1936	g_ymax[i] = mem_data.g_y_max;
1937	g_ymin[i] = mem_data.g_y_min;
1938	bcbmax[i] = mem_data.bcb_max;
1939	bcbmin[i] = mem_data.bcb_min;
1940	cbwhite[i] = mem_data.cb_white;
1941	crwhite[i] = mem_data.cr_white;
1942	cbblack[i] = mem_data.cb_black;
1943	crblack[i] = mem_data.cr_black;
1944	}
1945
1946	for ( i = 0; i < ( 1 << ADC_CAL_FRAME_QTY_ORDER ) - 1; i++ ) {
1947	for ( j = 1; j < ( 1 << ADC_CAL_FRAME_QTY_ORDER ); j++ ) {
1948	re_order ( & ( rcrmax[i] ), & ( rcrmax[j] ) );
1949	re_order ( & ( rcrmin[i] ), & ( rcrmin[j] ) );
1950	re_order ( & ( g_ymax[i] ), & ( g_ymax[j] ) );
1951	re_order ( & ( g_ymin[i] ), & ( g_ymin[j] ) );
1952	re_order ( & ( bcbmax[i] ), & ( bcbmax[j] ) );
1953	re_order ( & ( bcbmin[i] ), & ( bcbmin[j] ) );
1954	re_order ( & ( cbwhite[i] ), & ( cbwhite[j] ) );
1955	re_order ( & ( crwhite[i] ), & ( crwhite[j] ) );
1956	re_order ( & ( cbblack[i] ), & ( cbblack[j] ) );
1957	re_order ( & ( crblack[i] ), & ( crblack[j] ) );
1958	}
1959	}
1960
1961	memset ( &mem_data, 0, sizeof ( mem_data ) );
1962
1963	for ( i = 0; i < ( 1 << ( ADC_CAL_FRAME_QTY_ORDER - 1 ) ); i++ ) { //(1<<(ADC_CAL_FRAME_QTY_ORDER-1))
1964	mem_data.rcr_max += rcrmax[i + ( 1 << ( ADC_CAL_FRAME_QTY_ORDER - 2 ) )];
1965	mem_data.rcr_min += rcrmin[i + ( 1 << ( ADC_CAL_FRAME_QTY_ORDER - 2 ) )];
1966	mem_data.g_y_max += g_ymax[i + ( 1 << ( ADC_CAL_FRAME_QTY_ORDER - 2 ) )];
1967	mem_data.g_y_min += g_ymin[i + ( 1 << ( ADC_CAL_FRAME_QTY_ORDER - 2 ) )];
1968	mem_data.bcb_max += bcbmax[i + ( 1 << ( ADC_CAL_FRAME_QTY_ORDER - 2 ) )];
1969	mem_data.bcb_min += bcbmin[i + ( 1 << ( ADC_CAL_FRAME_QTY_ORDER - 2 ) )];
1970	mem_data.cb_white += cbwhite[i + ( 1 << ( ADC_CAL_FRAME_QTY_ORDER - 2 ) )];
1971	mem_data.cr_white += crwhite[i + ( 1 << ( ADC_CAL_FRAME_QTY_ORDER - 2 ) )];
1972	mem_data.cb_black += cbblack[i + ( 1 << ( ADC_CAL_FRAME_QTY_ORDER - 2 ) )];
1973	mem_data.cr_black += crblack[i + ( 1 << ( ADC_CAL_FRAME_QTY_ORDER - 2 ) )];
1974	}
1975
1976
1977	mem_data.rcr_max >>= ( ADC_CAL_FRAME_QTY_ORDER - 1 );
1978	mem_data.rcr_min >>= ( ADC_CAL_FRAME_QTY_ORDER - 1 );
1979	mem_data.g_y_max >>= ( ADC_CAL_FRAME_QTY_ORDER - 1 );
1980	mem_data.g_y_min >>= ( ADC_CAL_FRAME_QTY_ORDER - 1 );
1981	mem_data.bcb_max >>= ( ADC_CAL_FRAME_QTY_ORDER - 1 );
1982	mem_data.bcb_min >>= ( ADC_CAL_FRAME_QTY_ORDER - 1 );
1983	mem_data.cb_white >>= ( ADC_CAL_FRAME_QTY_ORDER - 1 );
1984	mem_data.cr_white >>= ( ADC_CAL_FRAME_QTY_ORDER - 1 );
1985	mem_data.cb_black >>= ( ADC_CAL_FRAME_QTY_ORDER - 1 );
1986	mem_data.cr_black >>= ( ADC_CAL_FRAME_QTY_ORDER - 1 );
1987
1988	return mem_data;
1989	}
1990
1991	int CTvin::AFE_GetMemData ( int typeSel, struct adc_cal_s *mem_data )
1992	{
1993	int rt = -1;
1994
1995	if ( m_vdin_dev_fd < 0 || mem_data == NULL ) {
1996	LOGW ( "AFE_GetMemData, didn't open vdin fd, return!\n" );
1997	return -1;
1998	}
1999
2000	memset ( &gTvinAFEParam, 0, sizeof ( gTvinAFEParam ) );
2001	memset ( &gTvinAFESignalInfo, 0, sizeof ( gTvinAFESignalInfo ) );
2002
2003	if ( VDIN_DeviceIOCtl ( TVIN_IOC_G_PARM, &gTvinAFEParam ) < 0 ) {
2004	LOGW ( "AFE_GetMemData, get vdin param, error(%s), fd(%d)!\n", strerror ( errno ), m_vdin_dev_fd );
2005	return -1;
2006	}
2007
2008	gTvinAFEParam.flag = gTvinAFEParam.flag | TVIN_PARM_FLAG_CAP;
2009
2010	if ( VDIN_DeviceIOCtl ( TVIN_IOC_S_PARM, &gTvinAFEParam ) < 0 ) {
2011	LOGW ( "AFE_GetMemData, set vdin param error(%s)!\n", strerror ( errno ) );
2012	return -1;
2013	}
2014
2015	if ( typeSel == 0 ) {
2016	get_frame_average ( CAL_YPBPR, mem_data );
2017	} else if ( typeSel == 1 ) {
2018	get_frame_average ( CAL_VGA, mem_data );
2019	} else {
2020	*mem_data = get_n_frame_average ( CAL_CVBS );
2021	}
2022
2023	gTvinAFEParam.flag &= 0x11111110;
2024
2025	if ( VDIN_DeviceIOCtl ( TVIN_IOC_S_PARM, &gTvinAFEParam ) < 0 ) {
2026	LOGW ( "AFE_GetMemData, set vdin param error(%s)\n", strerror ( errno ) );
2027	return -1;
2028	}
2029
2030	LOGD ( "AFE_GetMemData, MAX ======> :\n Y(White)->%d \n Cb(Blue)->%d \n Cr(Red)->%d\n", mem_data->g_y_max, mem_data->bcb_max, mem_data->rcr_max );
2031	LOGD ( "AFE_GetMemData, MIN ======>:\n Y(Black)->%d \n Cb(Yellow)->%d \n Cr(Cyan)->%d\n Cb(White) ->%d\n Cb(Black)->%d\n Cr(Black)->%d\n", mem_data->g_y_min, mem_data->bcb_min, mem_data->rcr_min,
2032	mem_data->cb_white, mem_data->cb_black, mem_data->cr_black );
2033	return 0;
2034	}
2035
2036	int CTvin::AFE_GetCVBSLockStatus ( enum tvafe_cvbs_video_e *cvbs_lock_status )
2037	{
2038	int rt = -1;
2039
2040	rt = AFE_DeviceIOCtl ( TVIN_IOC_G_AFE_CVBS_LOCK, cvbs_lock_status );
2041
2042	if ( rt < 0 ) {
2043	LOGD ( "AFE_GetCVBSLockStatus, error: return(%d), error(%s)!\n", rt, strerror ( errno ) );
2044	} else {
2045	LOGD ( "AFE_GetCVBSLockStatus, value=%d.\n", *cvbs_lock_status );
2046	}
2047
2048	return *cvbs_lock_status;
2049	}
2050
2051	int CTvin::AFE_SetCVBSStd ( tvin_sig_fmt_t fmt )
2052	{
2053	int rt = -1;
2054
2055	LOGD ( "AFE_SetCVBSStd, sig_fmt = %d\n", fmt );
2056	rt = AFE_DeviceIOCtl ( TVIN_IOC_S_AFE_CVBS_STD, &fmt );
2057
2058	if ( rt < 0 ) {
2059	LOGD ( "AFE_SetCVBSStd, error: return(%d), error(%s)!\n", rt, strerror ( errno ) );
2060	}
2061
2062	return rt;
2063	}
2064
2065	int CTvin::TvinApi_SetStartDropFrameCn ( int count )
2066	{
2067	int ret = -1;
2068	char set_str[4];
2069
2070	memset ( set_str, 0, 4 );
2071	sprintf ( set_str, "%d", count );
2072	return SetFileAttrValue ( "/sys/module/di/parameters/start_frame_drop_count", set_str );
2073	}
2074
2075	int CTvin::TvinApi_SetVdinHVScale ( int vdinx, int hscale, int vscale )
2076	{
2077	int ret = -1;
2078	char set_str[32];
2079
2080	memset ( set_str, 0, 32 );
2081	sprintf ( set_str, "%s %d %d", "hvscaler", hscale, vscale );
2082
2083	if ( vdinx == 0 ) {
2084	ret = SetFileAttrValue ( "/sys/class/vdin/vdin0/attr", set_str );
2085	} else {
2086	ret = SetFileAttrValue ( "/sys/class/vdin/vdin1/attr", set_str );
2087	}
2088
2089	return ret;
2090	}
2091	int CTvin::TvinApi_SetCompPhase ( am_phase_t &am_phase )
2092	{
2093	int ret = -1, fd = -1;
2094	unsigned int i = 0;
2095	int idx = 0, len = 0;
2096	char str1[200], str2[100];
2097
2098	LOGD ( "enter,TvinApi_SetCompPhase" );
2099
2100	fd = open ( "/sys/module/tvin_afe/parameters/comp_phase", O_RDWR );
2101	if ( fd < 0 ) {
2102	LOGW ( "Open vdin_comp_phase_op_mutex error(%s)!!\n", strerror ( errno ) );
2103	return -1;
2104	}
2105
2106	for ( i = 0; i < am_phase.length; i++ ) {
2107	sprintf ( &str1[idx], "%d,", am_phase.phase[i] );
2108	sprintf ( str2, "%d,", am_phase.phase[i] );
2109	int len = strlen ( str2 );
2110	idx = idx + len;
2111	}
2112
2113	LOGD ( "##########str1 = %s\n", str1 );
2114
2115	ret = write ( fd, str1, strlen ( str1 ) );
2116	if ( ret < 0 ) {
2117	LOGD ( "Write vdin_comp_phase_op_mutex error(%s)!!\n", strerror ( errno ) );
2118	}
2119
2120	LOGD ( "write ok!!!" );
2121	close ( fd );
2122	fd = -1;
2123
2124	return ret;
2125	}
2126
2127	tvin_trans_fmt CTvin::TvinApi_Get3DDectMode()
2128	{
2129	int fd;
2130	int ret;
2131	char det_3d[10];
2132	int det_3dmode = 8;
2133	//LOGW("det_3dmode %d\n", det_3dmode);
2134
2135	fd = open ( "/sys/module/di/parameters/det3d_mode", O_RDWR );
2136	if ( fd < 0 ) {
2137	LOGW ( "/sys/module/di/parameters/det3d_mode error(%s)!!\n", strerror ( errno ) );
2138
2139	return TVIN_TFMT_3D_MAX;
2140	}
2141
2142	ret = read ( fd, det_3d, 10 );
2143	if ( ret < 0 ) {
2144	LOGW ( "/sys/module/di/parameters/det3d_mode error(%s)!!\n", strerror ( errno ) );
2145	}
2146
2147	det_3dmode = atoi ( det_3d );
2148	close ( fd );
2149	fd = -1;
2150
2151	return (tvin_trans_fmt)det_3dmode;
2152	}
2153
2154	int CTvin::TvinApi_SetCompPhaseEnable ( int enable )
2155	{
2156	int ret = -1;
2157	if ( enable == 1 ) {
2158	ret = SetFileAttrValue ( "/sys/module/tvin_afe/parameters/enable_dphase", "Y" );
2159	LOGD ( "%s, enable TvinApi_SetCompPhase.", CFG_SECTION_TV );
2160	}
2161
2162	return ret;
2163	}
2164
2165	int CTvin::VDIN_GetPortConnect ( int port )
2166	{
2167	int status = 0;
2168
2169	if ( VDIN_DeviceIOCtl ( TVIN_IOC_CALLMASTER_SET, &port ) < 0 ) {
2170	LOGW ( "TVIN_IOC_CALLMASTER_SET error(%s) port %d\n", strerror ( errno ), port );
2171	return 0;
2172	}
2173
2174	if ( VDIN_DeviceIOCtl ( TVIN_IOC_CALLMASTER_GET, &status ) < 0 ) {
2175	LOGW ( "TVIN_IOC_CALLMASTER_GET error(%s)\n", strerror ( errno ) );
2176	return 0;
2177	}
2178
2179	//LOGD("%s, port:%x,status:%d", CFG_SECTION_TV,port,status);
2180	return status;
2181	}
2182
2183	int CTvin::VDIN_OpenHDMIPinMuxOn ( bool flag )
2184	{
2185	FILE *fp = NULL;
2186
2187	fp = fopen ( "/sys/class/hdmirx/hdmirx0/debug", "w" );
2188	if ( fp == NULL ) {
2189	LOGW ( "Open /sys/class/hdmirx/hdmirx0/debug(%s)!\n", strerror ( errno ) );
2190	return -1;
2191	}
2192
2193	if ( flag ) {
2194	fprintf ( fp, "%s", "pinmux_on" );
2195	} else {
2196	fprintf ( fp, "%s", "pinmux_off" );
2197
2198	}
2199
2200	fclose ( fp );
2201	fp = NULL;
2202	return 1;
2203	}
2204
2205	int CTvin::VDIN_GetHdmiHdcpKeyKsvInfo(struct _hdcp_ksv *msg)
2206	{
2207	int m_ksv_dev_fd = -1;
2208
2209	if (msg == NULL) {
2210	LOGE("%s, msg is NULL\n", __FUNCTION__);
2211	}
2212
2213	//PrintMessage(__FUNCTION__, 0, msg);
2214
2215	m_ksv_dev_fd = open(HDMIRX_KSV_PATH, O_RDWR);
2216	if (m_ksv_dev_fd < 0) {
2217	LOGE("%s, Open file %s error: (%s)!\n", __FUNCTION__, HDMIRX_KSV_PATH, strerror ( errno ));
2218	return -1;
2219	}
2220	LOGD("# call ioctl with HDMI_IOC_HDCP_SENT_KSV #");
2221	ioctl(m_ksv_dev_fd, HDMI_IOC_HDCP_KSV, msg);
2222
2223	close(m_ksv_dev_fd);
2224	m_ksv_dev_fd = -1;
2225
2226	LOGD("msg->bksv0 is %x, msg->bksv1 is %x", msg->bksv0, msg->bksv1);
2227
2228	return 0;
2229	}
2230
2231
2232	int CTvin::get_hdmi_ksv_info(int source_input, int data_buf[])
2233	{
2234	if (source_input != SOURCE_HDMI1 && source_input != SOURCE_HDMI2 && source_input != SOURCE_HDMI3) {
2235	return -1;
2236	}
2237
2238	struct _hdcp_ksv msg;
2239	int ret = -1;
2240	ret = VDIN_GetHdmiHdcpKeyKsvInfo(&msg);
2241	memset((void *)data_buf, 0, 2);
2242	data_buf[0] = msg.bksv0;
2243	data_buf[1] = msg.bksv1;
2244	return ret;
2245	}
2246
2247
2248	int CTvin::TVAFE_EnablePlugInDetect ( bool flag )
2249	{
2250	FILE *fp = NULL;
2251	int status = 1;
2252
2253	fp = fopen ( "/sys/class/tvafe/tvafe0/debug", "w" );
2254	if ( fp == NULL ) {
2255	LOGW ( "Open /sys/class/tvafe/tvafe0/debug (%s)!\n", strerror ( errno ) );
2256	return -1;
2257	}
2258
2259	if ( flag ) {
2260	fprintf ( fp, "%s", "tvafe_enable" );
2261	} else {
2262	fprintf ( fp, "%s", "tvafe_down" );
2263
2264	}
2265
2266	fclose ( fp );
2267	fp = NULL;
2268	return status;
2269	}
2270
2271	int CTvin::TvinApi_GetHDMIAudioStatus ( void )
2272	{
2273	int fd;
2274	int val = 0;
2275	char bcmd[16];
2276	fd = open ( "/sys/module/tvin_hdmirx/parameters/auds_rcv_sts", O_RDONLY );
2277
2278	if ( fd >= 0 ) {
2279	read ( fd, bcmd, sizeof ( bcmd ) );
2280	val = strtol ( bcmd, NULL, 10 );
2281	close ( fd );
2282	} else {
2283	LOGE ( "open /sys/module/tvin_hdmirx/parameters/auds_rcv_sts ERROR(%s)!!\n", strerror ( errno ) );
2284	return -1;
2285	}
2286
2287	return val;
2288	}
2289
2290	int CTvin::TvinApi_LoadPLLValues ( am_regs_t regs )
2291	{
2292	int rt = AFE_DeviceIOCtl ( TVIN_IOC_LOAD_REG, &regs );
2293
2294	if ( rt < 0 ) {
2295	LOGE ( "TvinApi_LoadPLLValues, error(%s)!\n", strerror ( errno ) );
2296	}
2297
2298	return rt;
2299	}
2300
2301	int CTvin::TvinApi_LoadCVD2Values ( am_regs_t regs )
2302	{
2303	int rt = AFE_DeviceIOCtl ( TVIN_IOC_LOAD_REG, &regs );
2304
2305	if ( rt < 0 ) {
2306	LOGE ( "TvinApi_LoadCVD2Values, error(%s)!\n", strerror ( errno ) );
2307	}
2308
2309	return rt;
2310	}
2311
2312	int CTvin::TvinApi_GetFbSize ( unsigned int *fb_width, unsigned int *fb_height )
2313	{
2314	int fbfd = 0;
2315	struct fb_var_screeninfo vinfo;
2316	struct fb_fix_screeninfo finfo;
2317	int xres = 0, yres = 0, bits_per_pixel = 0;
2318
2319	fbfd = open ( "/dev/graphics/fb0", O_RDWR );
2320	if ( !fbfd ) {
2321	return -1;
2322	}
2323
2324	if ( ioctl ( fbfd, FBIOGET_FSCREENINFO, &finfo ) ) {
2325	goto fail_close_fb;
2326	}
2327
2328	if ( ioctl ( fbfd, FBIOGET_VSCREENINFO, &vinfo ) ) {
2329	goto fail_close_fb;
2330	}
2331
2332	*fb_width = vinfo.xres;
2333	*fb_height = vinfo.yres;
2334	return 1;
2335
2336	fail_close_fb:
2337	close ( fbfd );;
2338	return -1;
2339	}
2340
2341	tv_source_input_type_t CTvin::Tvin_SourceInputToSourceInputType ( tv_source_input_t source_input )
2342	{
2343	if (source_input == SOURCE_TV) {
2344	return SOURCE_TYPE_TV;
2345	} else if (source_input == SOURCE_AV1 || source_input == SOURCE_AV2) {
2346	return SOURCE_TYPE_AV;
2347	} else if (source_input == SOURCE_YPBPR1 || source_input == SOURCE_YPBPR2) {
2348	return SOURCE_TYPE_COMPONENT;
2349	} else if (source_input == SOURCE_VGA) {
2350	return SOURCE_TYPE_VGA;
2351	} else if (source_input == SOURCE_HDMI1 || source_input == SOURCE_HDMI2 || source_input == SOURCE_HDMI3) {
2352	return SOURCE_TYPE_HDMI;
2353	} else if (source_input == SOURCE_DTV) {
2354	return SOURCE_TYPE_DTV;
2355	} else if (source_input == SOURCE_IPTV) {
2356	return SOURCE_TYPE_IPTV;
2357	} else if (source_input == SOURCE_MPEG) {
2358	return SOURCE_TYPE_MPEG;
2359	}
2360
2361	return SOURCE_TYPE_MPEG;
2362	}
2363
2364	tv_source_input_type_t CTvin::Tvin_SourcePortToSourceInputType ( tvin_port_t source_port )
2365	{
2366	tv_source_input_t source_input = Tvin_PortToSourceInput(source_port);
2367	return Tvin_SourceInputToSourceInputType(source_input);
2368	}
2369
2370	tvin_port_t CTvin::Tvin_GetSourcePortBySourceType ( tv_source_input_type_t source_type )
2371	{
2372	tvin_port_t source_port;
2373
2374	switch ( source_type ) {
2375	case SOURCE_TYPE_TV:
2376	source_port = Tvin_GetSourcePortBySourceInput(SOURCE_TV);
2377	break;
2378	case SOURCE_TYPE_AV:
2379	source_port = Tvin_GetSourcePortBySourceInput(SOURCE_AV1);
2380	break;
2381	case SOURCE_TYPE_COMPONENT:
2382	source_port = Tvin_GetSourcePortBySourceInput(SOURCE_YPBPR1);
2383	break;
2384	case SOURCE_TYPE_VGA:
2385	source_port = Tvin_GetSourcePortBySourceInput(SOURCE_VGA);
2386	break;
2387	case SOURCE_TYPE_HDMI:
2388	source_port = TVIN_PORT_HDMI0;
2389	break;
2390	case SOURCE_TYPE_IPTV:
2391	source_port = Tvin_GetSourcePortBySourceInput(SOURCE_IPTV);
2392	break;
2393	case SOURCE_TYPE_DTV:
2394	source_port = Tvin_GetSourcePortBySourceInput(SOURCE_DTV);
2395	break;
2396	case SOURCE_TYPE_MPEG:
2397	default:
2398	source_port = Tvin_GetSourcePortBySourceInput(SOURCE_MPEG);
2399	break;
2400	}
2401
2402	return source_port;
2403	}
2404
2405	tvin_port_t CTvin::Tvin_GetSourcePortBySourceInput ( tv_source_input_t source_input )
2406	{
2407	tvin_port_t source_port = TVIN_PORT_NULL;
2408
2409	if ( source_input < SOURCE_TV || source_input >= SOURCE_MAX ) {
2410	source_port = TVIN_PORT_NULL;
2411	} else {
2412	source_port = ( tvin_port_t ) mSourceInputToPortMap[ ( int ) source_input];
2413	}
2414
2415	return source_port;
2416	}
2417
2418	tv_source_input_t CTvin::Tvin_PortToSourceInput ( tvin_port_t port )
2419	{
2420	int i;
2421
2422	for ( i = SOURCE_TV; i < SOURCE_MAX; i++ ) {
2423	if ( mSourceInputToPortMap[i] == port ) {
2424	break;
2425	}
2426	}
2427
2428	if ( i == SOURCE_MAX ) {
2429	return SOURCE_MAX;
2430	} else {
2431	return tv_source_input_t ( i );
2432	}
2433	}
2434
2435	unsigned int CTvin::Tvin_TransPortStringToValue(const char *port_str)
2436	{
2437	if (strcasecmp(port_str, "TVIN_PORT_CVBS0") == 0) {
2438	return TVIN_PORT_CVBS0;
2439	} else if (strcasecmp(port_str, "TVIN_PORT_CVBS1") == 0) {
2440	return TVIN_PORT_CVBS1;
2441	} else if (strcasecmp(port_str, "TVIN_PORT_CVBS2") == 0) {
2442	return TVIN_PORT_CVBS2;
2443	} else if (strcasecmp(port_str, "TVIN_PORT_CVBS3") == 0) {
2444	return TVIN_PORT_CVBS3;
2445	} else if (strcasecmp(port_str, "TVIN_PORT_COMP0") == 0) {
2446	return TVIN_PORT_COMP0;
2447	} else if (strcasecmp(port_str, "TVIN_PORT_COMP1") == 0) {
2448	return TVIN_PORT_COMP1;
2449	} else if (strcasecmp(port_str, "TVIN_PORT_VGA0") == 0) {
2450	return TVIN_PORT_VGA0;
2451	} else if (strcasecmp(port_str, "TVIN_PORT_HDMI0") == 0) {
2452	return TVIN_PORT_HDMI0;
2453	} else if (strcasecmp(port_str, "TVIN_PORT_HDMI1") == 0) {
2454	return TVIN_PORT_HDMI1;
2455	} else if (strcasecmp(port_str, "TVIN_PORT_HDMI2") == 0) {
2456	return TVIN_PORT_HDMI2;
2457	} else if (strcasecmp(port_str, "TVIN_PORT_HDMI3") == 0) {
2458	return TVIN_PORT_HDMI3;
2459	}
2460
2461	return TVIN_PORT_MPEG0;
2462	}
2463
2464	void CTvin::Tvin_LoadSourceInputToPortMap()
2465	{
2466	const char *config_value = NULL;
2467
2468	config_value = config_get_str(CFG_SECTION_SRC_INPUT, "ro.tv.tvinchannel.atv", "TVIN_PORT_CVBS3");
2469	mSourceInputToPortMap[SOURCE_TV] = Tvin_TransPortStringToValue(config_value);
2470
2471	config_value = config_get_str(CFG_SECTION_SRC_INPUT, "ro.tv.tvinchannel.av1", "TVIN_PORT_CVBS1");
2472	mSourceInputToPortMap[SOURCE_AV1] = Tvin_TransPortStringToValue(config_value);
2473
2474	config_value = config_get_str(CFG_SECTION_SRC_INPUT, "ro.tv.tvinchannel.av2", "TVIN_PORT_CVBS2");
2475	mSourceInputToPortMap[SOURCE_AV2] = Tvin_TransPortStringToValue(config_value);
2476
2477	config_value = config_get_str(CFG_SECTION_SRC_INPUT, "ro.tv.tvinchannel.ypbpr1", "TVIN_PORT_COMP0");
2478	mSourceInputToPortMap[SOURCE_YPBPR1] = Tvin_TransPortStringToValue(config_value);
2479
2480	config_value = config_get_str(CFG_SECTION_SRC_INPUT, "ro.tv.tvinchannel.ypbpr2", "TVIN_PORT_COMP1");
2481	mSourceInputToPortMap[SOURCE_YPBPR2] = Tvin_TransPortStringToValue(config_value);
2482
2483	config_value = config_get_str(CFG_SECTION_SRC_INPUT, "ro.tv.tvinchannel.hdmi1", "TVIN_PORT_HDMI0");
2484	mSourceInputToPortMap[SOURCE_HDMI1] = Tvin_TransPortStringToValue(config_value);
2485
2486	config_value = config_get_str(CFG_SECTION_SRC_INPUT, "ro.tv.tvinchannel.hdmi2", "TVIN_PORT_HDMI2");
2487	mSourceInputToPortMap[SOURCE_HDMI2] = Tvin_TransPortStringToValue(config_value);
2488
2489	config_value = config_get_str(CFG_SECTION_SRC_INPUT, "ro.tv.tvinchannel.hdmi3", "TVIN_PORT_HDMI1");
2490	mSourceInputToPortMap[SOURCE_HDMI3] = Tvin_TransPortStringToValue(config_value);
2491
2492	config_value = config_get_str(CFG_SECTION_SRC_INPUT, "ro.tv.tvinchannel.vga", "TVIN_PORT_VGA0");
2493	mSourceInputToPortMap[SOURCE_VGA] = Tvin_TransPortStringToValue(config_value);
2494
2495	mSourceInputToPortMap[SOURCE_MPEG] = TVIN_PORT_MPEG0;
2496	mSourceInputToPortMap[SOURCE_DTV] = TVIN_PORT_DTV;
2497	mSourceInputToPortMap[SOURCE_IPTV] = TVIN_PORT_BT656;
2498	}
2499
2500	int CTvin::Tvin_GetSourcePortByCECPhysicalAddress(int physical_addr)
2501	{
2502	if (physical_addr == 0x1000) {
2503	return TVIN_PORT_HDMI0;
2504	} else if (physical_addr == 0x2000) {
2505	return TVIN_PORT_HDMI1;
2506	} else if (physical_addr == 0x3000) {
2507	return TVIN_PORT_HDMI2;
2508	}
2509
2510	return TVIN_PORT_MAX;
2511	}
2512
2513	tv_audio_channel_t CTvin::Tvin_GetInputSourceAudioChannelIndex ( tv_source_input_t source_input )
2514	{
2515	int aud_chan = TV_AUDIO_LINE_IN_0;
2516	const char *config_value = NULL;
2517
2518	if ( source_input == SOURCE_TV ) {
2519	config_value = config_get_str(CFG_SECTION_TV, "tvin.aud.chan.atv", "2");
2520	} else if ( source_input == SOURCE_AV1 ) {
2521	config_value = config_get_str(CFG_SECTION_TV, "tvin.aud.chan.av1", "1");
2522	} else if ( source_input == SOURCE_AV2 ) {
2523	config_value = config_get_str(CFG_SECTION_TV, "tvin.aud.chan.av2", "3");
2524	} else if ( source_input == SOURCE_YPBPR1 ) {
2525	config_value = config_get_str(CFG_SECTION_TV, "tvin.aud.chan.comp1", "0");
2526	} else if ( source_input == SOURCE_YPBPR2 ) {
2527	config_value = config_get_str(CFG_SECTION_TV, "tvin.aud.chan.comp2", "0");
2528	} else if ( source_input == SOURCE_HDMI1 ) {
2529	config_value = config_get_str(CFG_SECTION_TV, "tvin.aud.chan.hdmi1", "0");
2530	} else if ( source_input == SOURCE_HDMI2 ) {
2531	config_value = config_get_str(CFG_SECTION_TV, "tvin.aud.chan.hdmi2", "0");
2532	} else if ( source_input == SOURCE_HDMI3 ) {
2533	config_value = config_get_str(CFG_SECTION_TV, "tvin.aud.chan.hdmi3", "0");
2534	} else if ( source_input == SOURCE_VGA ) {
2535	config_value = config_get_str(CFG_SECTION_TV, "tvin.aud.chan.vga", "0");
2536	} else if ( source_input == SOURCE_MPEG ) {
2537	config_value = config_get_str(CFG_SECTION_TV, "tvin.aud.chan.mpeg", "0");
2538	}
2539
2540	if (config_value != NULL) {
2541	aud_chan = strtol (config_value, NULL, 10);
2542	}
2543
2544	return ( tv_audio_channel_t ) aud_chan;
2545	}
2546
2547	tv_audio_in_source_type_t CTvin::Tvin_GetAudioInSourceType ( tv_source_input_t source_input )
2548	{
2549	const char *config_value = NULL;
2550
2551	if (source_input == SOURCE_TV) {
2552	config_value = config_get_str(CFG_SECTION_TV, "tvin.aud.insource.atv", "TV_AUDIO_IN_SOURCE_TYPE_LINEIN");
2553	if (strcasecmp(config_value, "TV_AUDIO_IN_SOURCE_TYPE_ATV") == 0) {
2554	return TV_AUDIO_IN_SOURCE_TYPE_ATV;
2555	}
2556	} else if (source_input == SOURCE_AV1 || source_input == SOURCE_AV2) {
2557	return TV_AUDIO_IN_SOURCE_TYPE_LINEIN;
2558	} else if (source_input == SOURCE_YPBPR1 || source_input == SOURCE_YPBPR2 || source_input == SOURCE_VGA) {
2559	return TV_AUDIO_IN_SOURCE_TYPE_LINEIN;
2560	} else if (source_input == SOURCE_HDMI1 || source_input == SOURCE_HDMI2 || source_input == SOURCE_HDMI3) {
2561	return TV_AUDIO_IN_SOURCE_TYPE_HDMI;
2562	}
2563
2564	return TV_AUDIO_IN_SOURCE_TYPE_LINEIN;
2565	}
2566
2567	int CTvin::isVgaFmtInHdmi ( tvin_sig_fmt_t fmt )
2568	{
2569	if ( fmt == TVIN_SIG_FMT_HDMI_640X480P_60HZ
2570	|| fmt == TVIN_SIG_FMT_HDMI_800X600_00HZ
2571	|| fmt == TVIN_SIG_FMT_HDMI_1024X768_00HZ
2572	|| fmt == TVIN_SIG_FMT_HDMI_720X400_00HZ
2573	|| fmt == TVIN_SIG_FMT_HDMI_1280X768_00HZ
2574	|| fmt == TVIN_SIG_FMT_HDMI_1280X800_00HZ
2575	|| fmt == TVIN_SIG_FMT_HDMI_1280X960_00HZ
2576	|| fmt == TVIN_SIG_FMT_HDMI_1280X1024_00HZ
2577	|| fmt == TVIN_SIG_FMT_HDMI_1360X768_00HZ
2578	|| fmt == TVIN_SIG_FMT_HDMI_1366X768_00HZ
2579	|| fmt == TVIN_SIG_FMT_HDMI_1600X1200_00HZ
2580	|| fmt == TVIN_SIG_FMT_HDMI_1920X1200_00HZ ) {
2581	LOGD ( "%s, HDMI source : VGA format.", CFG_SECTION_TV );
2582	return 1;
2583	}
2584
2585	return -1;
2586	}
2587
2588	int CTvin::isSDFmtInHdmi ( tvin_sig_fmt_t fmt )
2589	{
2590	if ( fmt == TVIN_SIG_FMT_HDMI_640X480P_60HZ
2591	|| fmt == TVIN_SIG_FMT_HDMI_720X480P_60HZ
2592	|| fmt == TVIN_SIG_FMT_HDMI_1440X480I_60HZ
2593	|| fmt == TVIN_SIG_FMT_HDMI_1440X240P_60HZ
2594	|| fmt == TVIN_SIG_FMT_HDMI_2880X480I_60HZ
2595	|| fmt == TVIN_SIG_FMT_HDMI_2880X240P_60HZ
2596	|| fmt == TVIN_SIG_FMT_HDMI_1440X480P_60HZ
2597	|| fmt == TVIN_SIG_FMT_HDMI_720X576P_50HZ
2598	|| fmt == TVIN_SIG_FMT_HDMI_1440X576I_50HZ
2599	|| fmt == TVIN_SIG_FMT_HDMI_1440X288P_50HZ
2600	|| fmt == TVIN_SIG_FMT_HDMI_2880X576I_50HZ
2601	|| fmt == TVIN_SIG_FMT_HDMI_2880X288P_50HZ
2602	|| fmt == TVIN_SIG_FMT_HDMI_1440X576P_50HZ
2603	|| fmt == TVIN_SIG_FMT_HDMI_2880X480P_60HZ
2604	|| fmt == TVIN_SIG_FMT_HDMI_2880X576P_60HZ
2605	|| fmt == TVIN_SIG_FMT_HDMI_720X576P_100HZ
2606	|| fmt == TVIN_SIG_FMT_HDMI_1440X576I_100HZ
2607	|| fmt == TVIN_SIG_FMT_HDMI_720X480P_120HZ
2608	|| fmt == TVIN_SIG_FMT_HDMI_1440X480I_120HZ
2609	|| fmt == TVIN_SIG_FMT_HDMI_720X576P_200HZ
2610	|| fmt == TVIN_SIG_FMT_HDMI_1440X576I_200HZ
2611	|| fmt == TVIN_SIG_FMT_HDMI_720X480P_240HZ
2612	|| fmt == TVIN_SIG_FMT_HDMI_1440X480I_240HZ
2613	|| fmt == TVIN_SIG_FMT_HDMI_800X600_00HZ
2614	|| fmt == TVIN_SIG_FMT_HDMI_720X400_00HZ ) {
2615	LOGD ( "%s, SD format.", CFG_SECTION_TV );
2616	return true;
2617	} else {
2618	LOGD ( "%s, HD format.", CFG_SECTION_TV );
2619	return false;
2620	}
2621	}
2622
2623	bool CTvin::Tvin_is50HzFrameRateFmt ( tvin_sig_fmt_t fmt )
2624	{
2625	/** component **/
2626	if ( fmt == TVIN_SIG_FMT_COMP_576P_50HZ_D000
2627	|| fmt == TVIN_SIG_FMT_COMP_576I_50HZ_D000
2628	|| fmt == TVIN_SIG_FMT_COMP_720P_50HZ_D000
2629	|| fmt == TVIN_SIG_FMT_COMP_1080P_50HZ_D000
2630	|| fmt == TVIN_SIG_FMT_COMP_1080I_50HZ_D000_A
2631	|| fmt == TVIN_SIG_FMT_COMP_1080I_50HZ_D000_B
2632	|| fmt == TVIN_SIG_FMT_COMP_1080I_50HZ_D000_C
2633	|| fmt == TVIN_SIG_FMT_COMP_1080P_24HZ_D000
2634	|| fmt == TVIN_SIG_FMT_COMP_1080P_25HZ_D000
2635	/** hdmi **/
2636	|| fmt == TVIN_SIG_FMT_HDMI_720X576P_50HZ
2637	|| fmt == TVIN_SIG_FMT_HDMI_1280X720P_50HZ
2638	|| fmt == TVIN_SIG_FMT_HDMI_1920X1080I_50HZ_A
2639	|| fmt == TVIN_SIG_FMT_HDMI_1440X576I_50HZ
2640	|| fmt == TVIN_SIG_FMT_HDMI_1440X288P_50HZ
2641	|| fmt == TVIN_SIG_FMT_HDMI_2880X576I_50HZ
2642	|| fmt == TVIN_SIG_FMT_HDMI_2880X288P_50HZ
2643	|| fmt == TVIN_SIG_FMT_HDMI_1440X576P_50HZ
2644	|| fmt == TVIN_SIG_FMT_HDMI_1920X1080P_50HZ
2645	|| fmt == TVIN_SIG_FMT_HDMI_1920X1080I_50HZ_B
2646	|| fmt == TVIN_SIG_FMT_HDMI_1280X720P_50HZ_FRAME_PACKING
2647	|| fmt == TVIN_SIG_FMT_HDMI_1920X1080I_50HZ_FRAME_PACKING
2648	|| fmt == TVIN_SIG_FMT_HDMI_720X576P_50HZ_FRAME_PACKING
2649	/** cvbs **/
2650	|| fmt == TVIN_SIG_FMT_CVBS_PAL_I
2651	|| fmt == TVIN_SIG_FMT_CVBS_PAL_M
2652	|| fmt == TVIN_SIG_FMT_CVBS_PAL_CN
2653	|| fmt == TVIN_SIG_FMT_CVBS_SECAM ) {
2654	LOGD ( "%s, Frame rate == 50Hz.", CFG_SECTION_TV );
2655	return true;
2656	} else {
2657	LOGD ( "%s, Frame rate != 50Hz.", CFG_SECTION_TV );
2658	return false;
2659	}
2660	}
2661
2662	bool CTvin::Tvin_IsDeinterlaceFmt ( tvin_sig_fmt_t fmt )
2663	{
2664	if ( fmt == TVIN_SIG_FMT_COMP_480I_59HZ_D940
2665	|| fmt == TVIN_SIG_FMT_COMP_576I_50HZ_D000
2666	|| fmt == TVIN_SIG_FMT_COMP_1080I_47HZ_D952
2667	|| fmt == TVIN_SIG_FMT_COMP_1080I_48HZ_D000
2668	|| fmt == TVIN_SIG_FMT_COMP_1080I_50HZ_D000_A
2669	|| fmt == TVIN_SIG_FMT_COMP_1080I_50HZ_D000_B
2670	|| fmt == TVIN_SIG_FMT_COMP_1080I_50HZ_D000_C
2671	|| fmt == TVIN_SIG_FMT_COMP_1080I_60HZ_D000
2672	|| fmt == TVIN_SIG_FMT_HDMI_1440X480I_120HZ
2673	|| fmt == TVIN_SIG_FMT_HDMI_1440X480I_240HZ
2674	|| fmt == TVIN_SIG_FMT_HDMI_1440X480I_60HZ
2675	|| fmt == TVIN_SIG_FMT_HDMI_1440X576I_100HZ
2676	|| fmt == TVIN_SIG_FMT_HDMI_1440X576I_200HZ
2677	|| fmt == TVIN_SIG_FMT_HDMI_1440X576I_50HZ
2678	|| fmt == TVIN_SIG_FMT_HDMI_1920X1080I_100HZ
2679	|| fmt == TVIN_SIG_FMT_HDMI_1920X1080I_120HZ
2680	|| fmt == TVIN_SIG_FMT_HDMI_1920X1080I_50HZ_A
2681	|| fmt == TVIN_SIG_FMT_HDMI_1920X1080I_50HZ_B
2682	|| fmt == TVIN_SIG_FMT_HDMI_1920X1080I_50HZ_FRAME_PACKING
2683	|| fmt == TVIN_SIG_FMT_HDMI_1920X1080I_60HZ
2684	|| fmt == TVIN_SIG_FMT_HDMI_1920X1080I_60HZ_FRAME_PACKING
2685	|| fmt == TVIN_SIG_FMT_HDMI_2880X480I_60HZ
2686	|| fmt == TVIN_SIG_FMT_HDMI_2880X576I_50HZ
2687	|| fmt == TVIN_SIG_FMT_CVBS_NTSC_M
2688	|| fmt == TVIN_SIG_FMT_CVBS_NTSC_443
2689	|| fmt == TVIN_SIG_FMT_CVBS_PAL_60
2690	|| fmt == TVIN_SIG_FMT_CVBS_PAL_CN
2691	|| fmt == TVIN_SIG_FMT_CVBS_PAL_I
2692	|| fmt == TVIN_SIG_FMT_CVBS_PAL_M
2693	|| fmt == TVIN_SIG_FMT_CVBS_SECAM ) {
2694	LOGD ( "%s, Interlace format.", CFG_SECTION_TV );
2695	return true;
2696	} else {
2697	LOGD ( "%s, Progressive format.", CFG_SECTION_TV );
2698	return false;
2699	}
2700	}
2701
2702	int CTvin::Tvin_StartDecoder ( tvin_info_t &info )
2703	{
2704	if ( m_is_decoder_start == false ) {
2705	m_tvin_param.info = info;
2706
2707	if ( VDIN_StartDec ( &m_tvin_param ) >= 0 ) {
2708	LOGD ( "StartDecoder succeed." );
2709	m_is_decoder_start = true;
2710	} else {
2711	LOGW ( "StartDecoder failed." );
2712	return -1;
2713	}
2714	} else {
2715	return -2;
2716	}
2717
2718	return 0;
2719	}
2720
2721	int CTvin::SwitchPort (tvin_port_t source_port )
2722	{
2723	int ret = 0;
2724	LOGD ("%s, source_port = %x", __FUNCTION__, source_port);
2725	ret = Tvin_StopDecoder();
2726	if ( 0 == ret || 1 == ret ) {
2727	if ( 1 == ret ) { //decode not started
2728	//mVpp.Tvin_SetVideoScreenColorType ( TV_SIGNAL_BLUE_PATTERN );
2729	}
2730	VDIN_ClosePort();
2731	} else {
2732	LOGW ( "%s,stop decoder failed.", __FUNCTION__);
2733	return -1;
2734	}
2735	// Open Port
2736	if ( VDIN_OpenPort ( source_port ) < 0 ) {
2737	LOGD ( "%s, OpenPort failed, source_port =%x ", __FUNCTION__, source_port );
2738	}
2739	m_tvin_param.port = source_port;
2740	return 0;
2741	}
2742
2743	int CTvin::Tvin_StopDecoder()
2744	{
2745	if ( m_is_decoder_start == true ) {
2746	if ( VDIN_StopDec() >= 0 ) {
2747	LOGD ( "StopDecoder ok!" );
2748	m_is_decoder_start = false;
2749	return 0;
2750	} else {
2751	LOGD ( "StopDecoder Failed!" );
2752	}
2753	} else {
2754	return 1;
2755	}
2756
2757	return -1;
2758	}
2759
2760	int CTvin::init_vdin ( void )
2761	{
2762	VDIN_OpenModule();
2763	return 0;
2764	}
2765
2766	int CTvin::uninit_vdin ( void )
2767	{
2768	VDIN_ClosePort();
2769	VDIN_CloseModule();
2770	return 0;
2771	}
2772
2773	int CTvin::Tvin_AddPath ( tvin_path_id_t pathid )
2774	{
2775	int ret = -1;
2776	int i = 0, dly = 10;
2777	tv_path_type_t pathtype;
2778
2779	if ( pathid >= TV_PATH_VDIN_AMVIDEO && pathid < TV_PATH_DECODER_3D_AMVIDEO ) {
2780	pathtype = TV_PATH_TYPE_TVIN;
2781	} else {
2782	pathtype = TV_PATH_TYPE_DEFAULT;
2783	}
2784
2785	if ( pathid >= TV_PATH_VDIN_AMVIDEO && pathid < TV_PATH_DECODER_3D_AMVIDEO ) {
2786	if ( m_pathid == pathid ) {
2787	LOGW ( "%s, no need to add the same tvin path.\n", CFG_SECTION_TV );
2788	return 0;
2789	}
2790
2791	for ( i = 0; i < 50; i++ ) {
2792	ret = VDIN_RmTvPath();
2793
2794	if ( ret > 0 ) {
2795	LOGD ( "%s, remove tvin path ok, %d ms gone.\n", CFG_SECTION_TV, ( dly * i ) );
2796	break;
2797	} else {
2798	LOGW ( "%s, remove tvin path faild, %d ms gone.\n", CFG_SECTION_TV, ( dly * i ) );
2799	usleep ( dly * 1000 );
2800	}
2801	}
2802	} else {
2803	for ( i = 0; i < 50; i++ ) {
2804	ret = VDIN_RmDefPath();
2805
2806	if ( ret > 0 ) {
2807	LOGD ( "%s, remove default path ok, %d ms gone.\n", CFG_SECTION_TV, ( dly * i ) );
2808	break;
2809	} else {
2810	LOGW ( "%s, remove default path faild, %d ms gone.\n", CFG_SECTION_TV, ( dly * i ) );
2811	usleep ( dly * 1000 );
2812	}
2813	}
2814	}
2815
2816	for ( i = 0; i < 50; i++ ) {
2817	if ( pathid >= TV_PATH_VDIN_AMVIDEO && pathid < TV_PATH_DECODER_3D_AMVIDEO ) {
2818	if ( strcmp ( config_tv_path, "null" ) == 0 ) {
2819	ret = VDIN_AddVideoPath ( pathid );
2820	} else {
2821	ret = VDIN_AddPath ( config_tv_path );
2822	}
2823	} else {
2824	if ( strcmp ( config_default_path, "null" ) == 0 ) {
2825	ret = VDIN_AddVideoPath ( pathid );
2826	} else {
2827	ret = VDIN_AddPath ( config_default_path );
2828	}
2829	}
2830
2831	if ( ret >= 0 ) {
2832	LOGD ( "%s, add pathid[%d] ok, %d ms gone.\n", CFG_SECTION_TV, pathid, i );
2833	break;
2834	} else {
2835	LOGW ( "%s, add pathid[%d] faild, %d ms gone.\n", CFG_SECTION_TV, pathid, i );
2836	usleep ( dly * 1000 );
2837	}
2838	}
2839
2840	if ( pathid >= TV_PATH_VDIN_AMVIDEO && pathid < TV_PATH_MAX ) {
2841	m_pathid = pathid;
2842	}
2843
2844	return ret;
2845	}
2846
2847
2848	int CTvin::Tvin_RemovePath ( tv_path_type_t pathtype )
2849	{
2850	int ret = -1;
2851	int i = 0, dly = 10;
2852
2853	for ( i = 0; i < 500; i++ ) {
2854	ret = Tvin_CheckPathActive ( pathtype, 0 );
2855
2856	if ( ret == TV_PATH_STATUS_INACTIVE ) {
2857	LOGD ( "%s, check path is inactive, %d ms gone.\n", CFG_SECTION_TV, ( dly * i ) );
2858	break;
2859	} else if ( ret == TV_PATH_STATUS_INACTIVE || ret == TV_PATH_STATUS_ERROR ) {
2860	usleep ( dly * 1000 );
2861	} else {
2862	break;
2863	}
2864	}
2865
2866	if ( i == 500 ) {
2867	LOGE ( "%s, check path active faild, %d ms gone.\n", CFG_SECTION_TV, ( dly * i ) );
2868	}
2869
2870	if ( pathtype == TV_PATH_TYPE_DEFAULT ) {
2871	for ( i = 0; i < 50; i++ ) {
2872	ret = VDIN_RmDefPath();
2873
2874	if ( ret > 0 ) {
2875	LOGD ( "%s, remove default path ok, %d ms gone.\n", CFG_SECTION_TV, ( dly * i ) );
2876	break;
2877	} else {
2878	LOGW ( "%s, remove default path faild, %d ms gone.\n", CFG_SECTION_TV, ( dly * i ) );
2879	usleep ( dly * 1000 );
2880	}
2881	}
2882	} else if ( pathtype == TV_PATH_TYPE_TVIN ) {
2883	for ( i = 0; i < 50; i++ ) {
2884	ret = VDIN_RmTvPath();
2885
2886	if ( ret > 0 ) {
2887	LOGD ( "%s, remove tvin path ok, %d ms gone.\n", CFG_SECTION_TV, ( dly * i ) );
2888	break;
2889	} else {
2890	LOGW ( "%s, remove tvin path faild, %d ms gone.\n", CFG_SECTION_TV, ( dly * i ) );
2891	usleep ( dly * 1000 );
2892	}
2893	}
2894
2895	m_pathid = TV_PATH_DECODER_3D_AMVIDEO;
2896	} else if ( pathtype == TV_PATH_TYPE_TVIN_PREVIEW ) {
2897	for ( i = 0; i < 50; i++ ) {
2898	ret = VDIN_RmPreviewPath();
2899
2900	if ( ret > 0 ) {
2901	LOGD ( "%s, remove preview path ok, %d ms gone.\n", CFG_SECTION_TV, ( dly * i ) );
2902	break;
2903	} else {
2904	LOGW ( "%s, remove preview path faild, %d ms gone.\n", CFG_SECTION_TV, ( dly * i ) );
2905	usleep ( dly * 1000 );
2906	}
2907	}
2908
2909	m_pathid = TV_PATH_DECODER_NEW3D_WITHOUTPPMGR_AMVIDEO;
2910	} else {
2911	ret = -1;
2912	}
2913
2914	return ret;
2915	}
2916
2917
2918	int CTvin::Tvin_CheckPathActive ( tv_path_type_t path_type, int isCheckD2D3 )
2919	{
2920	FILE *f;
2921	char path[256];
2922	char decoder_str[20] = "default {";
2923	char tvin_str[20] = "tvpath {";
2924	char decoder_active_str[20] = "decoder(1)";
2925	char tvin_active_str[20] = "vdin0(1)";
2926	char di_active_str[20] = "deinterlace(1)";
2927	char d2d3_active_str[20] = "d2d3(1)";
2928	char decoder_inactive_str[20] = "decoder(0)";
2929	char tvin_inactive_str[20] = "vdin0(0)";
2930	char di_inactive_str[20] = "deinterlace(0)";
2931	char d2d3_inactive_str[20] = "d2d3(0)";
2932
2933	char *str_find = NULL;
2934	char *active_str = NULL;
2935	char *inactive_str = NULL;
2936	int mount_freq;
2937	int match;
2938	int is_active = TV_PATH_STATUS_INACTIVE;
2939
2940	memset ( path, 0, 255 );
2941
2942	f = fopen ( "/sys/class/vfm/map", "r" );
2943	if ( !f ) {
2944	LOGE ( "%s, can not open /sys/class/vfm/map!\n", CFG_SECTION_TV );
2945	return TV_PATH_STATUS_NO_DEV;
2946	}
2947
2948	while ( fgets ( path, 254, f ) ) {
2949	if ( path_type == TV_PATH_TYPE_DEFAULT ) {
2950	str_find = strstr ( path, decoder_str );
2951	active_str = decoder_active_str;
2952	inactive_str = decoder_inactive_str;
2953	} else if ( path_type == TV_PATH_TYPE_TVIN || path_type == TV_PATH_TYPE_TVIN_PREVIEW ) {
2954	str_find = strstr ( path, tvin_str );
2955	active_str = tvin_active_str;
2956	inactive_str = tvin_inactive_str;
2957	} else {
2958	LOGW ( "%s, there is no %d path_type.\n", CFG_SECTION_TV, path_type );
2959	break;
2960	}
2961
2962	if ( str_find ) {
2963	if ( isCheckD2D3 == 0 ) {
2964	if ( strstr ( str_find, active_str ) && strstr ( str_find, di_active_str ) ) {
2965	is_active = TV_PATH_STATUS_ACTIVE;
2966	//LOGD("%s, %s is active.\n", CFG_SECTION_TV, path);
2967	} else if ( strstr ( str_find, inactive_str )
2968	&& ( strstr ( str_find, di_inactive_str ) || ( !strstr ( str_find, di_inactive_str ) ) )
2969	) {
2970	is_active = TV_PATH_STATUS_INACTIVE;
2971	//LOGD("%s, %s is inactive.\n", CFG_SECTION_TV, path);
2972	} else {
2973	is_active = TV_PATH_STATUS_ERROR;
2974	LOGE ( "%s, %s is error!\n", CFG_SECTION_TV, path );
2975	}
2976
2977	break;
2978	} else {
2979	if ( strstr ( str_find, active_str ) && strstr ( str_find, di_active_str ) && strstr ( str_find, d2d3_active_str ) ) {
2980	is_active = TV_PATH_STATUS_ACTIVE;
2981	//LOGD("%s, %s is active.\n", CFG_SECTION_TV, path);
2982	} else if ( strstr ( str_find, inactive_str )
2983	&& ( strstr ( str_find, di_inactive_str ) || ( !strstr ( str_find, di_inactive_str ) ) )
2984	&& ( strstr ( str_find, d2d3_inactive_str ) || ( !strstr ( str_find, d2d3_inactive_str ) ) )
2985	) {
2986	is_active = TV_PATH_STATUS_INACTIVE;
2987	//LOGD("%s, %s is inactive.\n", CFG_SECTION_TV, path);
2988	} else {
2989	is_active = TV_PATH_STATUS_ERROR;
2990	LOGE ( "%s, %s is error!\n", CFG_SECTION_TV, path );
2991	}
2992
2993	break;
2994	}
2995	}
2996	}
2997
2998	fclose ( f );
2999
3000	return is_active;
3001	}
3002
3003
3004	int CTvin::Tv_init_afe ( void )
3005	{
3006	AFE_OpenModule();
3007	return 0;
3008	}
3009
3010	int CTvin::Tv_uninit_afe ( void )
3011	{
3012	AFE_CloseModule();
3013	return 0;
3014	}
3015
3016	int CTvin::get_hdmi_sampling_rate()
3017	{
3018	int fd;
3019	int val = 0;
3020	char bcmd[16];
3021	fd = open ( "/sys/module/tvin_hdmirx/parameters/audio_sample_rate", O_RDONLY );
3022	if ( fd >= 0 ) {
3023	read ( fd, bcmd, sizeof ( bcmd ) );
3024	val = strtol ( bcmd, NULL, 10 );
3025	close ( fd );
3026	}
3027
3028	return val;
3029	}
3030
3031	//**************************************************************************
3032	CTvin::CTvinSigDetect::CTvinSigDetect ()
3033	{
3034	mDetectState = STATE_STOPED;
3035	mpObserver = NULL;
3036
3037	initSigState();
3038	}
3039
3040	CTvin::CTvinSigDetect::~CTvinSigDetect()
3041	{
3042	}
3043
3044	int CTvin::CTvinSigDetect::startDetect(bool bPause)
3045	{
3046	LOGD ( "startDetect()" );
3047
3048	if ( mDetectState == STATE_RUNNING || mDetectState == STATE_PAUSE ) {
3049	return mDetectState;
3050	}
3051
3052	m_cur_sig_info.trans_fmt = TVIN_TFMT_2D;
3053	m_cur_sig_info.fmt = TVIN_SIG_FMT_NULL;
3054	m_cur_sig_info.status = TVIN_SIG_STATUS_NULL;
3055	m_cur_sig_info.reserved = 0;
3056
3057	m_pre_sig_info = m_cur_sig_info;
3058
3059	m_request_pause_detect = bPause;
3060	this->run();
3061	return mDetectState;
3062	}
3063
3064	int CTvin::CTvinSigDetect::initSigState()
3065	{
3066	m_cur_sig_info.trans_fmt = TVIN_TFMT_2D;
3067	m_cur_sig_info.fmt = TVIN_SIG_FMT_NULL;
3068	m_cur_sig_info.status = TVIN_SIG_STATUS_NULL;
3069	m_cur_sig_info.reserved = 0;
3070	m_pre_sig_info = m_cur_sig_info;
3071	mKeepNosigTime = 0;
3072	m_is_nosig_checktimes_once_valid = false;
3073	mResumeLaterTime = 0;
3074	return 0;
3075	}
3076
3077	int CTvin::CTvinSigDetect::stopDetect()
3078	{
3079	CMutex::Autolock _l ( mLock );
3080	LOGD ( "stopDetect()" );
3081	requestExit();
3082	return 0;
3083	}
3084
3085	int CTvin::CTvinSigDetect::pauseDetect()
3086	{
3087	CMutex::Autolock _l ( mLock );
3088	LOGD ( "pauseDetect()" );
3089	m_request_pause_detect = true;
3090	return 0;
3091	}
3092
3093	int CTvin::CTvinSigDetect::requestAndWaitPauseDetect()
3094	{
3095	CMutex::Autolock _l ( mLock );
3096	LOGD ( "requestAndWaitPauseDetect()" );
3097	m_request_pause_detect = true;
3098
3099	if ( mDetectState == STATE_RUNNING ) {
3100	mRequestPauseCondition.wait ( mLock );
3101	}
3102
3103	return 0;
3104	}
3105
3106	int CTvin::CTvinSigDetect::resumeDetect(int later)//ms
3107	{
3108	CMutex::Autolock _l ( mLock );
3109	LOGD ( "resumeDetect()" );
3110	mResumeLaterTime = later;
3111	m_request_pause_detect = false;
3112	mDetectPauseCondition.signal();
3113	return 0;
3114	}
3115
3116	void CTvin::CTvinSigDetect::setVdinNoSigCheckKeepTimes(int times, bool isOnce)
3117	{
3118	LOGD("setVdinNoSigCheckKeepTimes mKeepNosigTime = %d, times = %d", mKeepNosigTime, times);
3119	mKeepNosigTime = times;
3120	m_is_nosig_checktimes_once_valid = isOnce;
3121	}
3122
3123	int CTvin::CTvinSigDetect::Tv_TvinSigDetect ( int &sleeptime )
3124	{
3125	CTvin tvin;
3126	tvin.VDIN_GetSignalInfo ( &m_cur_sig_info ); //get info
3127	//set no sig check times
3128	static long long sNosigKeepTime = 0;
3129	//LOGD("stime=%d status=%d, fmt = %d sNosigKeepTime = %d, mKeepNosigTime = %d", sleeptime, m_cur_sig_info.status,m_cur_sig_info.fmt, sNosigKeepTime, mKeepNosigTime);
3130	if ( m_cur_sig_info.status == TVIN_SIG_STATUS_NOSIG || m_cur_sig_info.status == TVIN_SIG_STATUS_NULL ) {
3131	sNosigKeepTime += sleeptime;
3132	if ( sNosigKeepTime > mKeepNosigTime ) { //real no sig
3133	//cur is no sig
3134	if ( m_is_nosig_checktimes_once_valid ) { //just once change,is nosig, and default it
3135	m_is_nosig_checktimes_once_valid = false;
3136	mKeepNosigTime = 0;
3137	}
3138	} else {//not
3139	m_cur_sig_info.status = m_pre_sig_info.status;
3140	}
3141	} else {
3142	sNosigKeepTime = 0;
3143	if ( m_is_nosig_checktimes_once_valid ) { //just once change,not nosig,default is
3144	m_is_nosig_checktimes_once_valid = false;
3145	mKeepNosigTime = 0;
3146	}
3147	}
3148
3149	//if state change
3150	if ( m_cur_sig_info.status != m_pre_sig_info.status ) {
3151	sleeptime = 20;
3152
3153	if ( m_cur_sig_info.status == TVIN_SIG_STATUS_STABLE ) { // to stable
3154	mpObserver->onSigToStable();
3155	} else if ( m_pre_sig_info.status == TVIN_SIG_STATUS_STABLE && m_cur_sig_info.status == TVIN_SIG_STATUS_UNSTABLE ) { //stable to unstable
3156	//mVpp.Tvin_SetVideoScreenColorType ( TV_SIGNAL_BLACK_PATTERN );
3157	mpObserver->onSigStableToUnstable();
3158	} else if ( m_pre_sig_info.status == TVIN_SIG_STATUS_STABLE && m_cur_sig_info.status == TVIN_SIG_STATUS_NOTSUP ) {
3159	mpObserver->onSigStableToUnSupport();
3160	} else if ( m_pre_sig_info.status == TVIN_SIG_STATUS_STABLE && m_cur_sig_info.status == TVIN_SIG_STATUS_NOSIG ) {
3161	mpObserver->onSigStableToNoSig();
3162	} else if ( m_pre_sig_info.status == TVIN_SIG_STATUS_UNSTABLE && m_cur_sig_info.status == TVIN_SIG_STATUS_NOTSUP ) {
3163	mpObserver->onSigUnStableToUnSupport();
3164	} else if ( m_pre_sig_info.status == TVIN_SIG_STATUS_UNSTABLE && m_cur_sig_info.status == TVIN_SIG_STATUS_NOSIG ) {
3165	mpObserver->onSigUnStableToNoSig();
3166	} else if ( m_pre_sig_info.status == TVIN_SIG_STATUS_NULL && m_cur_sig_info.status == TVIN_SIG_STATUS_NOSIG ) {
3167	mpObserver->onSigNullToNoSig();
3168	} else if ( m_pre_sig_info.status == TVIN_SIG_STATUS_NOSIG && m_cur_sig_info.status == TVIN_SIG_STATUS_UNSTABLE ) {
3169	mpObserver->onSigNoSigToUnstable();
3170	}
3171	} else { //state not change
3172	sleeptime = 20;
3173
3174	switch ( m_cur_sig_info.status ) {
3175	case TVIN_SIG_STATUS_STABLE:
3176	mpObserver->onSigStillStable();
3177	if ( m_cur_sig_info.trans_fmt != m_pre_sig_info.trans_fmt ) {
3178	mpObserver->onStableTransFmtChange();
3179	}
3180	if (m_cur_sig_info.fmt != m_pre_sig_info.fmt) {
3181	mpObserver->onStableSigFmtChange();
3182	}
3183	break;
3184
3185	case TVIN_SIG_STATUS_NOTSUP:
3186	mpObserver->onSigStillNoSupport();
3187	break;
3188
3189	case TVIN_SIG_STATUS_UNSTABLE:
3190	mpObserver->onSigStillUnstable();
3191	break;
3192
3193	case TVIN_SIG_STATUS_NOSIG:
3194	mpObserver->onSigStillNosig();
3195	break;
3196
3197	case TVIN_SIG_STATUS_NULL:
3198	default:
3199	mpObserver->onSigStillNull();
3200	break;
3201	}
3202	}
3203
3204	m_pre_sig_info = m_cur_sig_info;//backup info
3205	return sleeptime;
3206	}
3207
3208	bool CTvin::CTvinSigDetect::threadLoop()
3209	{
3210	//enter onStart()
3211	if ( mpObserver == NULL ) {
3212	return false;
3213	}
3214
3215	int sleeptime = 200;//ms
3216	mDetectState = STATE_RUNNING;
3217	mpObserver->onSigDetectEnter();
3218
3219	while ( !exitPending() ) { //requietexit() or requietexitWait() not call
3220	while ( m_request_pause_detect ) {
3221	mLock.lock();
3222	mRequestPauseCondition.broadcast();
3223	mDetectState = STATE_PAUSE;
3224	mDetectPauseCondition.wait ( mLock ); //first unlock,when return,lock again,so need,call unlock
3225	mDetectState = STATE_RUNNING;
3226	mLock.unlock();
3227	//
3228	while (!m_request_pause_detect && mResumeLaterTime > 0) {
3229	//LOGD("mResumeLaterTime = %d", mResumeLaterTime);
3230	usleep(10 * 1000);
3231	mResumeLaterTime -= 10;
3232	}
3233	}
3234
3235	mResumeLaterTime = 0;
3236	mpObserver->onSigDetectLoop();
3237	Tv_TvinSigDetect ( sleeptime );
3238	//可以优化
3239	if ( !m_request_pause_detect ) {
3240	usleep ( sleeptime * 1000 );
3241	}
3242	}
3243
3244	mDetectState = STATE_STOPED;
3245	mRequestPauseCondition.broadcast();
3246	//exit
3247	//return true, run again, return false,not run.
3248	return false;
3249	}
3250
3251	v4l2_std_id CTvin::CvbsFtmToV4l2ColorStd(tvin_sig_fmt_t fmt)
3252	{
3253	v4l2_std_id v4l2_std;
3254	if (fmt == TVIN_SIG_FMT_CVBS_NTSC_M || fmt == TVIN_SIG_FMT_CVBS_NTSC_443) {
3255	v4l2_std = V4L2_COLOR_STD_NTSC;
3256	} else if (fmt >= TVIN_SIG_FMT_CVBS_PAL_I && fmt <= TVIN_SIG_FMT_CVBS_PAL_CN) {
3257	v4l2_std = V4L2_COLOR_STD_PAL;
3258	} else if (fmt == TVIN_SIG_FMT_CVBS_SECAM) {
3259	v4l2_std = V4L2_COLOR_STD_SECAM;
3260	} else {
3261	v4l2_std = V4L2_COLOR_STD_PAL;
3262	}
3263	return v4l2_std;
3264	}
3265
3266	int CTvin::CvbsFtmToColorStdEnum(tvin_sig_fmt_t fmt)
3267	{
3268	v4l2_std_id v4l2_std;
3269	if (fmt == TVIN_SIG_FMT_CVBS_NTSC_M || fmt == TVIN_SIG_FMT_CVBS_NTSC_443) {
3270	v4l2_std = CC_ATV_VIDEO_STD_NTSC;
3271	} else if (fmt >= TVIN_SIG_FMT_CVBS_PAL_I && fmt <= TVIN_SIG_FMT_CVBS_PAL_CN) {
3272	v4l2_std = CC_ATV_VIDEO_STD_PAL;
3273	} else if (fmt == TVIN_SIG_FMT_CVBS_SECAM) {
3274	v4l2_std = CC_ATV_VIDEO_STD_SECAM;
3275	} else {
3276	v4l2_std = CC_ATV_VIDEO_STD_PAL;
3277	}
3278	return v4l2_std;
3279	}
3280
3281	int CTvin::GetITContent()
3282	{
3283	FILE *fp = NULL;
3284	int value = 0;
3285	fp = fopen("/sys/module/tvin_hdmirx/parameters/it_content", "r");
3286	if (fp == NULL) {
3287	LOGE ( "Open /sys/module/tvin_hdmirx/parameters/it_content error(%s)!\n", strerror ( errno ) );
3288	return -1;
3289	}
3290	fscanf(fp, "%d", &value );
3291	fclose(fp);
3292	fp = NULL;
3293	return value;
3294	}
3295	//**************************************************************************
3296