path: root/tvapi/libtv/tv/CTv.cpp (plain)
blob: e435be7f3f7ae6efd8b3ff27be00c12cc283530c

1	//
2	//
3	// amlogic 2013
4	//
5	// @ Project : tv
6	// @ File Name : CTv.cpp
7	// @ Date : 2013-11
8	// @ Author :
9	#define LOG_TAG "CTv"
10
11	#include <stdio.h>
12	#include <unistd.h>
13	#include <fcntl.h>
14	#include <dirent.h>
15	#include <am_epg.h>
16	#include <am_mem.h>
17	#include "CTvDatabase.h"
18	#include <stdlib.h>
19	#include <string.h>
20	#include <malloc.h>
21	#include <pthread.h>
22	#include <sys/types.h>
23	#include <errno.h>
24	#include <dlfcn.h>
25	#include <cutils/properties.h>
26	#include <cutils/log.h>
27	#include <cutils/android_reboot.h>
28	#include <utils/threads.h>
29	#include <time.h>
30	#include <sys/prctl.h>
31	#include <getopt.h>
32	#include <errno.h>
33	#include <sys/types.h>
34	#include <sys/stat.h>
35	#include <fcntl.h>
36	#include <stdlib.h>
37	#ifdef ANDROID
38	#include <termios.h>
39	#endif
40	#include <string.h>
41	#include <signal.h>
42
43	#include "../version/version.h"
44	#include "../tvsetting/CTvSetting.h"
45	#include "../tvutils/tvutils.h"
46	#include "../tvconfig/tvconfig.h"
47	#include "../tvutils/CFile.h"
48	#include <hardware_legacy/power.h>
49	#include "../tvutils/serial_operate.h"
50
51	extern "C" {
52	#include "am_ver.h"
53	#include "am_misc.h"
54	#include "am_debug.h"
55	#include "am_fend.h"
56	}
57
58	#include <math.h>
59	#include <sys/ioctl.h>
60
61	#include "CTv.h"
62
63	using namespace android;
64
65	// Called each time a message is logged.
66	static void sqliteLogCallback(void *data, int iErrCode, const char *zMsg)
67	{
68	data = data;
69	LOGD( "showbo sqlite (%d) %s\n", iErrCode, zMsg);
70	}
71
72	CTv::CTv() :
73	mTvMsgQueue(this),
74	mTvScannerDetectObserver(this)
75	{
76	mAudioMuteStatusForTv = CC_AUDIO_UNMUTE;
77	mAudioMuteStatusForSystem = CC_AUDIO_UNMUTE;
78	//mpClient = pClient;
79	//copy file to param
80	if (Tv_Utils_IsFileExist ( TV_CONFIG_FILE_SYSTEM_PATH )) {
81	if (!Tv_Utils_IsFileExist ( TV_CONFIG_FILE_PARAM_PATH )) {
82	CFile file ( TV_CONFIG_FILE_SYSTEM_PATH );
83
84	if ( file.copyTo ( TV_CONFIG_FILE_PARAM_PATH ) != 0 ) {
85	LOGE ( "%s, copy file = %s , error", __FUNCTION__, TV_CONFIG_FILE_PARAM_PATH );
86	}
87	}
88	}
89
90	if (Tv_Utils_IsFileExist ( TV_CHANNEL_LIST_SYSTEM_PATH )) {
91	if (!Tv_Utils_IsFileExist ( TV_CHANNEL_LIST_PARAM_PATH )) {
92	CFile file ( TV_CHANNEL_LIST_SYSTEM_PATH );
93
94	if ( file.copyTo ( TV_CHANNEL_LIST_PARAM_PATH ) != 0 ) {
95	LOGE ( "%s, copy file = %s , error", __FUNCTION__, TV_CHANNEL_LIST_PARAM_PATH );
96	}
97	}
98	}
99
100	//ssm
101	if (Tv_Utils_IsFileExist ( TV_SSM_DATA_SYSTEM_PATH )) {
102	if (!Tv_Utils_IsFileExist ( TV_SSM_DATA_PARAM_PATH )) {
103	CFile file ( TV_SSM_DATA_SYSTEM_PATH );
104
105	if ( file.copyTo ( TV_SSM_DATA_PARAM_PATH ) != 0 ) {
106	LOGE ( "%s, copy file = %s , error", __FUNCTION__, TV_SSM_DATA_PARAM_PATH );
107	}
108	}
109	}
110
111	AM_EVT_Init();
112	//mTvEpg.setObserver ( &mTvMsgQueue );
113	mpObserver = NULL;
114	fbcIns = NULL;
115	dtv_auto_3d_flag = 0;
116	mAutoSetDisplayFreq = false;
117
118	tv_config_load ( TV_CONFIG_FILE_PATH );
119	sqlite3_config (SQLITE_CONFIG_SERIALIZED);
120	//sqlite3_config(SQLITE_CONFIG_LOG, &sqliteLogCallback, (void*)1);
121	sqlite3_soft_heap_limit(8 * 1024 * 1024);
122	// Initialize SQLite.
123	sqlite3_initialize();
124	CTvDatabase::GetTvDb()->InitTvDb ( TV_DB_PATH );
125
126	if ( CTvDimension::isDimensionTblExist() == false ) {
127	CTvDimension::builtinAtscDimensions();
128	}
129
130	CTvSettingLoad();
131
132	mDtvScanRunningStatus = DTV_SCAN_RUNNING_NORMAL;
133	if (hdmiOutWithFbc()) {
134	mHdmiOutFbc = true;
135	} else {
136	mHdmiOutFbc = false;
137	}
138
139	m_sig_stable_nums = 0;
140	mSetHdmiEdid = false;
141	m_cur_playing_prog_id = -1;
142
143	m_hdmi_audio_data = 0;
144	mSigDetectThread.setObserver ( this );
145	mSourceConnectDetectThread.setObserver ( this );
146	mHDMIRxCEC.setObserver(this);
147	mFrontDev.setObserver ( &mTvMsgQueue );
148	mpUpgradeFBC = NULL;
149	if (mHdmiOutFbc) {
150	fbcIns = GetSingletonFBC();
151
152	mpUpgradeFBC = new CUpgradeFBC();
153	mpUpgradeFBC->setObserver(this);
154	}
155	mSerialA.setObserver(this);
156	mSerialB.setObserver(this);
157	mSerialC.setObserver(this);
158	mSubtitle.setObserver(this);
159	mHeadSet.setObserver(this);
160	mTvScanner.setGlobalScanerObject(&mTvScanner);
161	mAv.setObserver(&mTvMsgQueue);
162	mMainVolLutTableExtraName[0] = '\0';
163	//-----------------------------------------------------------
164	mCurAudioMasterVolume = CC_DEF_SOUND_VOL;
165	mCurAudioBalance = CC_DEF_SOUND_BALANCE_VAL;
166	mCurAudioSupperBassVolume = CC_DEF_SUPPERBASS_VOL;
167	mCurAudioSupperBassSwitch = CC_SWITCH_OFF;
168	mCurAudioSRSSurround = CC_SWITCH_OFF;
169	mCurAudioSrsDialogClarity = CC_SWITCH_OFF;
170	mCurAudioSrsTruBass = CC_SWITCH_OFF;
171	mCurAudioSPDIFSwitch = CC_SWITCH_ON;
172	mCurAudioSPDIFMode = CC_SPDIF_MODE_PCM;
173	mCurAudioBassVolume = CC_DEF_BASS_TREBLE_VOL;
174	mCurAudioTrebleVolume = CC_DEF_BASS_TREBLE_VOL;
175	mCurAudioSoundMode = CC_SOUND_MODE_END;
176	mCurAudioWallEffect = CC_SWITCH_OFF;
177	mCurAudioEQMode = CC_EQ_MODE_START;
178	mCustomAudioMasterVolume = CC_DEF_SOUND_VOL;
179	mCustomAudioBalance = CC_DEF_SOUND_BALANCE_VAL;
180	mCustomAudioSupperBassVolume = CC_DEF_SUPPERBASS_VOL;
181	mCustomAudioSupperBassSwitch = CC_SWITCH_OFF;
182	mCustomAudioSRSSurround = CC_SWITCH_OFF;
183	mCustomAudioSrsDialogClarity = CC_SWITCH_OFF;
184	mCustomAudioSrsTruBass = CC_SWITCH_OFF;
185	mCustomAudioBassVolume = CC_DEF_BASS_TREBLE_VOL;
186	mCustomAudioTrebleVolume = CC_DEF_BASS_TREBLE_VOL;
187	mCustomAudioSoundMode = CC_SOUND_MODE_END;
188	mCustomAudioWallEffect = CC_SWITCH_OFF;
189	mCustomAudioEQMode = CC_EQ_MODE_START;
190	mCustomAudioSoundEnhancementSwitch = CC_SWITCH_OFF;
191	mVolumeCompensationVal = 0;
192
193	mMainVolumeBalanceVal = 0;
194	for (int i = 0; i < CC_BAND_ITEM_CNT; i++) {
195	mCustomEQGainBuf[i] = 0;
196	mCurEQGainBuf[i] = 0;
197	mCurEQGainChBuf[i] = 0;
198	}
199	static const int WALL_EFFECT_VALUE[CC_BAND_ITEM_CNT] = { 0, 0, 1, 2, 2, 0 };
200	for (int i = 0; i < CC_BAND_ITEM_CNT; i++) {
201	mWallEffectValueBuf[i] = WALL_EFFECT_VALUE[i];
202	}
203	mTvAction &= TV_ACTION_NULL;
204	mTvStatus = TV_INIT_ED;
205	print_version_info();
206	};
207
208	CTv::~CTv()
209	{
210	mpObserver = NULL;
211	CTvSettingunLoad();
212	CTvDatabase::deleteTvDb();
213	tv_config_unload();
214	mAv.Close();
215	mTvStatus = TV_INIT_ED;
216	mFrontDev.Close();
217
218	if (mpUpgradeFBC != NULL) {
219	delete mpUpgradeFBC;
220	mpUpgradeFBC = NULL;
221	}
222	}
223
224	void CTv::onEvent ( const CTvScanner::ScannerEvent &ev )
225	{
226	LOGD ( "%s, CTv::onEvent lockStatus = %d type = %d\n", __FUNCTION__, ev.mLockedStatus, ev.mType );
227
228	if ( mDtvScanRunningStatus == DTV_SCAN_RUNNING_ANALYZE_CHANNEL ) {
229	if ( ev.mType == CTvScanner::ScannerEvent::EVENT_SCAN_END ) {
230	CMessage msg;
231	msg.mType = CTvMsgQueue::TV_MSG_STOP_ANALYZE_TS;
232	msg.mpData = this;
233	mTvMsgQueue.sendMsg ( msg );
234	} else if ( ev.mType == CTvScanner::ScannerEvent::EVENT_STORE_END ) {
235	CTvEpg::EpgEvent epgev;
236	epgev.type = CTvEpg::EpgEvent::EVENT_CHANNEL_UPDATE_END;
237	mDtvScanRunningStatus = DTV_SCAN_RUNNING_NORMAL;
238	sendTvEvent ( epgev );
239	}
240	} else {
241	sendTvEvent ( ev );
242	}
243	}
244
245	void CTv::onEvent ( const CFrontEnd::FEEvent &ev )
246	{
247	const char *config_value = NULL;
248	LOGD ( "%s, FE event type = %d tvaction=%x", __FUNCTION__, ev.mCurSigStaus, mTvAction);
249	if (mTvAction & TV_ACTION_SCANNING) return;
250
251	//前端事件响应处理
252	if ( ev.mCurSigStaus == CFrontEnd::FEEvent::EVENT_FE_HAS_SIG ) { //作为信号稳定
253	if (/*m_source_input == SOURCE_TV || */m_source_input == SOURCE_DTV && (mTvAction & TV_ACTION_PLAYING)) { //atv and other tvin source not to use it, and if not playing, not use have sig
254	if ( m_win_mode == PREVIEW_WONDOW ) {
255	//mAv.setVideoAxis(m_win_pos.x1, m_win_pos.y1, m_win_pos.x2, m_win_pos.y2);
256	mAv.setVideoScreenMode ( CAv::VIDEO_WIDEOPTION_FULL_STRETCH );
257	}
258
259	if ( mAutoSetDisplayFreq) {
260	CTvin::getInstance()->VDIN_SetDisplayVFreq (50, mAv.getVideoDisplayResolution() , mHdmiOutFbc);
261	}
262	TvEvent::SignalInfoEvent ev;
263	ev.mStatus = TVIN_SIG_STATUS_STABLE;
264	ev.mTrans_fmt = TVIN_TFMT_2D;
265	ev.mFmt = TVIN_SIG_FMT_NULL;
266	ev.mReserved = 0;
267	sendTvEvent ( ev );
268	//if (mAv.WaittingVideoPlaying() == 0) {
269	SetDisplayMode ( CVpp::getInstance()->GetDisplayMode ( CTvin::Tvin_SourceInputToSourceInputType(m_source_input) ), CTvin::Tvin_SourceInputToSourceInputType(m_source_input), mAv.getVideoResolutionToFmt());
270	usleep(50 * 1000);
271	mAv.EnableVideoNow();
272	SetAudioMuteForTv ( CC_AUDIO_UNMUTE );
273	//}
274	Tv_SetAudioInSource(SOURCE_DTV);
275	}
276	} else if ( ev.mCurSigStaus == CFrontEnd::FEEvent::EVENT_FE_NO_SIG ) { //作为信号消失
277	if (/*m_source_input == SOURCE_TV || */m_source_input == SOURCE_DTV && (mTvAction & TV_ACTION_PLAYING)) { //just playing
278	config_value = config_get_str ( CFG_SECTION_TV, CFG_BLUE_SCREEN_COLOR, "null" );
279	if ( strcmp ( config_value, "black" ) == 0 ) {
280	mAv.DisableVideoWithBlackColor();
281	} else {
282	mAv.DisableVideoWithBlueColor();
283	}
284	SetAudioMuteForTv ( CC_AUDIO_MUTE );
285
286	TvEvent::SignalInfoEvent ev;
287	ev.mStatus = TVIN_SIG_STATUS_NOSIG;
288	ev.mTrans_fmt = TVIN_TFMT_2D;
289	ev.mFmt = TVIN_SIG_FMT_NULL;
290	ev.mReserved = 0;
291	sendTvEvent ( ev );
292	}
293	}
294	}
295
296	void CTv::onEvent ( const CTvEpg::EpgEvent &ev )
297	{
298	switch ( ev.type ) {
299	case CTvEpg::EpgEvent::EVENT_TDT_END:
300	LOGD ( "%s, CTv::onEvent epg time = %ld", __FUNCTION__, ev.time );
301	mTvTime.setTime ( ev.time );
302	break;
303
304	case CTvEpg::EpgEvent::EVENT_CHANNEL_UPDATE: {
305	LOGD ( "%s, CTv:: onEvent channel update", __FUNCTION__ );
306	CMessage msg;
307	msg.mType = CTvMsgQueue::TV_MSG_START_ANALYZE_TS;
308	msg.mpData = this;
309	mCurAnalyzeTsChannelID = ev.channelID;
310	mTvMsgQueue.sendMsg ( msg );
311	break;
312	}
313
314	default:
315	break;
316	}
317
318	sendTvEvent ( ev );
319	}
320
321	void CTv::onEvent(const CAv::AVEvent &ev)
322	{
323	const char *config_value = NULL;
324	LOGD("AVEvent = %d", ev.type);
325	switch ( ev.type ) {
326	case CAv::AVEvent::EVENT_AV_STOP: {
327	config_value = config_get_str ( CFG_SECTION_TV, CFG_BLUE_SCREEN_COLOR, "null" );
328	if ( strcmp ( config_value, "black" ) == 0 ) {
329	mAv.DisableVideoWithBlackColor();
330	} else {
331	mAv.DisableVideoWithBlueColor();
332	}
333	SetAudioMuteForTv ( CC_AUDIO_MUTE );
334
335	TvEvent::SignalInfoEvent ev;
336	ev.mStatus = TVIN_SIG_STATUS_NOSIG;
337	ev.mTrans_fmt = TVIN_TFMT_2D;
338	ev.mFmt = TVIN_SIG_FMT_NULL;
339	ev.mReserved = 0;
340	sendTvEvent ( ev );
341	break;
342	}
343
344	case CAv::AVEvent::EVENT_AV_RESUEM: {
345	//if (mAv.WaittingVideoPlaying() == 0) {
346	SetDisplayMode ( CVpp::getInstance()->GetDisplayMode ( CTvin::Tvin_SourceInputToSourceInputType(m_source_input) ),
347	CTvin::Tvin_SourceInputToSourceInputType(m_source_input),
348	mAv.getVideoResolutionToFmt());
349	usleep(50 * 1000);
350	mAv.EnableVideoNow();
351	SetAudioMuteForTv ( CC_AUDIO_UNMUTE );
352	//}
353	TvEvent::AVPlaybackEvent AvPlayBackEvt;
354	AvPlayBackEvt.mMsgType = TvEvent::AVPlaybackEvent::EVENT_AV_PLAYBACK_RESUME;
355	AvPlayBackEvt.mProgramId = ( int ) ev.param;
356	sendTvEvent(AvPlayBackEvt );
357	break;
358	}
359
360	case CAv::AVEvent::EVENT_AV_SCAMBLED: {
361	config_value = config_get_str ( CFG_SECTION_TV, CFG_BLUE_SCREEN_COLOR, "null" );
362	if ( strcmp ( config_value, "black" ) == 0 ) {
363	mAv.DisableVideoWithBlackColor();
364	} else {
365	mAv.DisableVideoWithBlueColor();
366	}
367	TvEvent::AVPlaybackEvent AvPlayBackEvt;
368	AvPlayBackEvt.mMsgType = TvEvent::AVPlaybackEvent::EVENT_AV_SCAMBLED;
369	AvPlayBackEvt.mProgramId = ( int ) ev.param;
370	sendTvEvent(AvPlayBackEvt );
371	break;
372	}
373
374	case CAv::AVEvent::EVENT_AV_UNSUPPORT: {
375	LOGD("To AVS or AVS+ format");//just avs format, not unsupport, and avs avs+
376	break;
377	}
378
379	default:
380	break;
381	}
382	}
383
384	CTv::CTvMsgQueue::CTvMsgQueue(CTv *tv)
385	{
386	mpTv = tv;
387	}
388
389	CTv::CTvMsgQueue::~CTvMsgQueue()
390	{
391	}
392
393	void CTv::CTvMsgQueue::handleMessage ( CMessage &msg )
394	{
395	LOGD ("%s, CTv::CTvMsgQueue::handleMessage type = %d", __FUNCTION__, msg.mType);
396
397	switch ( msg.mType ) {
398	case TV_MSG_COMMON:
399	break;
400
401	case TV_MSG_STOP_ANALYZE_TS:
402	//mpTv->Tv_Stop_Analyze_Ts();
403	break;
404
405	case TV_MSG_START_ANALYZE_TS:
406	//mpTv->Tv_Start_Analyze_Ts ( pTv->mCurAnalyzeTsChannelID );
407	break;
408
409	case TV_MSG_CHECK_FE_DELAY: {
410	mpTv->mFrontDev.checkStatusOnce();
411	break;
412	}
413
414	case TV_MSG_AV_EVENT: {
415	mpTv->onEvent(*((CAv::AVEvent *)(msg.mpPara)));
416	break;
417	}
418
419	case TV_MSG_FE_EVENT: {
420	mpTv->onEvent(*((CFrontEnd::FEEvent *)(msg.mpPara)));
421	break;
422	}
423
424	case TV_MSG_SCAN_EVENT: {
425	mpTv->onEvent(*((CTvScanner::ScannerEvent *)(msg.mpPara)));
426	break;
427	}
428
429	case TV_MSG_EPG_EVENT: {
430	mpTv->onEvent(*((CTvEpg::EpgEvent *)(msg.mpPara)));
431	break;
432	}
433
434	case TV_MSG_HDMI_SR_CHANGED: {
435	int sr = ((int *)(msg.mpPara))[0];
436	mpTv->onHdmiSrChanged(sr, (((int *)(msg.mpPara))[1] == 0) ? true : false);
437	break;
438	}
439
440	case TV_MSG_ENABLE_VIDEO_LATER: {
441	int fc = msg.mpPara[0];
442	mpTv->onEnableVideoLater(fc);
443	break;
444	}
445
446	default:
447	break;
448	}
449	}
450
451	void CTv::CTvMsgQueue::onEvent ( const CTvScanner::ScannerEvent &ev )
452	{
453	CMessage msg;
454	msg.mDelayMs = 0;
455	msg.mType = CTvMsgQueue::TV_MSG_SCAN_EVENT;
456	memcpy(msg.mpPara, &ev, sizeof(ev));
457	this->sendMsg ( msg );
458	}
459
460	void CTv::CTvMsgQueue::onEvent ( const CFrontEnd::FEEvent &ev )
461	{
462	CMessage msg;
463	msg.mDelayMs = 0;
464	msg.mType = CTvMsgQueue::TV_MSG_FE_EVENT;
465	memcpy(msg.mpPara, &ev, sizeof(ev));
466	this->sendMsg ( msg );
467	}
468
469	void CTv::CTvMsgQueue::onEvent ( const CTvEpg::EpgEvent &ev )
470	{
471	CMessage msg;
472	msg.mDelayMs = 0;
473	msg.mType = CTvMsgQueue::TV_MSG_EPG_EVENT;
474	memcpy(msg.mpPara, &ev, sizeof(ev));
475	this->sendMsg ( msg );
476	}
477
478	void CTv::CTvMsgQueue::onEvent(const CAv::AVEvent &ev)
479	{
480	CMessage msg;
481	msg.mDelayMs = 0;
482	msg.mType = CTvMsgQueue::TV_MSG_AV_EVENT;
483	memcpy(msg.mpPara, &ev, sizeof(ev));
484	this->sendMsg ( msg );
485	}
486
487	void CTv::onHdmiSrChanged(int sr, bool bInit)
488	{
489	if (bInit) {
490	LOGD ( "%s, Init HDMI audio, sampling rate:%d", __FUNCTION__, sr );
491	sr = HanldeAudioInputSr(sr);
492	InitTvAudio (sr, CC_IN_USE_SPDIF_DEVICE);
493	} else {
494	LOGD ( "%s, Reset HDMI sampling rate to %d", __FUNCTION__, sr );
495	AudioChangeSampleRate ( sr );
496	}
497	}
498
499	void CTv::onHMDIAudioStatusChanged(int status)
500	{
501	if (status == 0) {//change to no audio data
502	SetAudioMuteForTv ( CC_AUDIO_MUTE );
503	} else if (status == 1) {//change to audio data come
504	Tv_SetAudioInSource(m_source_input);
505	usleep(200 * 1000);
506	SetAudioMuteForTv ( CC_AUDIO_UNMUTE );
507	}
508	}
509
510	int CTv::setTvObserver ( TvIObserver *ob )
511	{
512	mpObserver = ob;
513	return 0;
514	}
515
516	void CTv::sendTvEvent ( const CTvEv &ev )
517	{
518	//AutoMutex lock(mLock);
519	/* send sigstate to AutoBackLight */
520	if (ev.getEvType() == CTvEv::TV_EVENT_SIGLE_DETECT) {
521	TvEvent::SignalInfoEvent *pEv = (TvEvent::SignalInfoEvent *)(&ev);
522	if (pEv->mStatus == TVIN_SIG_STATUS_STABLE) {
523	mAutoBackLight.updateSigState(mAutoBackLight.SIG_STATE_STABLE);
524	} else {
525	mAutoBackLight.updateSigState(mAutoBackLight.SIG_STATE_NOSIG);
526	}
527	}
528
529	LOGD ( "%s, tvaction=%x", __FUNCTION__, mTvAction);
530	if ((mTvAction & TV_ACTION_SCANNING) && (ev.getEvType() == CTvEv::TV_EVENT_SIGLE_DETECT)) {
531	LOGD("%s, when scanning, not send sig detect event", __FUNCTION__);
532	return;
533	}
534	if ( mpObserver != NULL ) {
535	mpObserver->onTvEvent ( ev );
536	}
537	}
538
539	int CTv::ClearAnalogFrontEnd()
540	{
541	return mFrontDev.ClearAnalogFrontEnd ();
542	}
543
544	int CTv::dtvAutoScan()
545	{
546	AutoMutex lock ( mLock );
547	mTvAction |= TV_ACTION_SCANNING;
548	//mTvEpg.leaveChannel();
549	mAv.StopTS ();
550	mAv.DisableVideoWithBlueColor();
551	CTvProgram::CleanAllProgramBySrvType ( CTvProgram::TYPE_DTV );
552	CTvProgram::CleanAllProgramBySrvType ( CTvProgram::TYPE_RADIO );
553	CTvEvent::CleanAllEvent();
554	mTvScanner.setObserver ( &mTvMsgQueue );
555	mDtvScanRunningStatus = DTV_SCAN_RUNNING_NORMAL;
556	mFrontDev.Open(FE_DTMB);
557	mTvScanner.autoDtmbScan();//dtmb
558	return 0;
559	}
560
561	int CTv::dtvCleanProgramByFreq ( int freq )
562	{
563	int iOutRet = 0;
564	CTvChannel channel;
565	iOutRet = CTvChannel::SelectByFreq ( freq, channel );
566	if ( -1 == iOutRet ) {
567	LOGD ( "%s, Warnning: Current Freq not have program info in the ts_table\n", __FUNCTION__ );
568	}
569
570	iOutRet == CTvProgram::deleteChannelsProgram ( channel );
571	return iOutRet;
572	}
573
574	int CTv::dtvManualScan (int beginFreq, int endFreq, int modulation)
575	{
576	AutoMutex lock ( mLock );
577	mTvAction |= TV_ACTION_SCANNING;
578	//mTvEpg.leaveChannel();
579	mAv.StopTS ();
580	mAv.DisableVideoWithBlueColor();
581	CTvChannel::DeleteBetweenFreq(beginFreq, endFreq);
582	mTvScanner.setObserver ( &mTvMsgQueue );
583	mDtvScanRunningStatus = DTV_SCAN_RUNNING_NORMAL;
584	mFrontDev.Open(FE_DTMB);
585	int iOutRet = mTvScanner.manualDtmbScan (beginFreq, endFreq, modulation); //dtmb
586	return iOutRet;
587	}
588
589	int CTv::dtvAutoScanAtscLock(int attenna, int videoStd, int audioStd)
590	{
591	//for warning
592	attenna = attenna;
593	videoStd = videoStd;
594	audioStd = audioStd;
595	//showboz
596	/* int minScanFreq, maxScanFreq, vStd, aStd;
597	vStd = CC_ATV_VIDEO_STD_PAL;
598	aStd = CC_ATV_AUDIO_STD_DK;
599	v4l2_std_id stdAndColor = mFrontDev.enumToStdAndColor(vStd, aStd);
600
601	AutoMutex lock ( mLock );
602	mTvAction |= TV_ACTION_SCANNING;
603	mTvEpg.leaveChannel();
604	mAv.StopTS ();
605	mAv.DisableVideoWithBlueColor();
606	CTvProgram::CleanAllProgramBySrvType ( CTvProgram::TYPE_DTV );
607	CTvProgram::CleanAllProgramBySrvType ( CTvProgram::TYPE_RADIO );
608	CTvEvent::CleanAllEvent();
609	mTvScanner.setObserver ( &mTvMsgQueue );
610	mDtvScanRunningStatus = DTV_SCAN_RUNNING_NORMAL;
611	mFrontDev.Open(FE_ATSC);
612	mTvScanner.autoAtscScan(CTvScanner::AM_ATSC_ATTENNA_TYPE_AIR, stdAndColor);//dtmb*/
613	return 0;
614	}
615
616	//searchType 0:not 256 1:is 256 Program
617	int CTv::atvAutoScan(int videoStd __unused, int audioStd __unused, int searchType)
618	{
619	int minScanFreq, maxScanFreq, vStd, aStd;
620	AutoMutex lock ( mLock );
621	mAv.DisableVideoWithBlueColor();
622	mTvAction |= TV_ACTION_SCANNING;
623	stopPlaying();
624	mTvScanner.setObserver ( &mTvMsgQueue );
625	SetAudioMuteForTv ( CC_AUDIO_MUTE );
626	getATVMinMaxFreq (&minScanFreq, &maxScanFreq );
627	if ( minScanFreq == 0 || maxScanFreq == 0 || minScanFreq > maxScanFreq ) {
628	LOGE ( "%s, auto scan freq set is error min=%d, max=%d", __FUNCTION__, minScanFreq, maxScanFreq );
629	return -1;
630	}
631	mSigDetectThread.setVdinNoSigCheckKeepTimes(1000, false);
632	mSigDetectThread.requestAndWaitPauseDetect();
633	mSigDetectThread.setObserver(&mTvScannerDetectObserver);
634	CTvin::getInstance()->Tvin_StopDecoder();
635	//if set std null AUTO, use default PAL/DK
636	//if(videoStd == CC_ATV_VIDEO_STD_AUTO) {
637	// vStd = CC_ATV_VIDEO_STD_PAL;
638	// aStd = CC_ATV_AUDIO_STD_DK;
639	//} else {
640	vStd = CC_ATV_VIDEO_STD_PAL;
641	aStd = CC_ATV_AUDIO_STD_DK;
642	//}
643	tvin_port_t source_port = CTvin::getInstance()->Tvin_GetSourcePortBySourceInput(SOURCE_TV);
644	CTvin::getInstance()->VDIN_OpenPort ( source_port );
645	v4l2_std_id stdAndColor = mFrontDev.enumToStdAndColor(vStd, aStd);
646
647	int fmt = CFrontEnd::stdEnumToCvbsFmt (vStd, aStd);
648	CTvin::getInstance()->AFE_SetCVBSStd ( ( tvin_sig_fmt_t ) TVIN_SIG_FMT_NULL );
649
650	if (searchType == 0) {
651	CTvProgram::CleanAllProgramBySrvType ( CTvProgram::TYPE_ATV );
652	} else if (searchType == 1) { //type for skyworth, and insert 256 prog, and just update ts table
653	}
654	minScanFreq = mFrontDev.formatATVFreq ( minScanFreq );
655	maxScanFreq = mFrontDev.formatATVFreq ( maxScanFreq );
656	LOGD("%s, atv auto scan vstd=%d, astd=%d stdandcolor=%lld", __FUNCTION__, vStd, aStd, stdAndColor);
657	mFrontDev.Open(FE_ANALOG);
658	mSigDetectThread.initSigState();
659	mSigDetectThread.resumeDetect();
660	mTvScanner.autoAtvScan ( minScanFreq, maxScanFreq, stdAndColor, searchType);
661	return 0;
662	}
663
664	int CTv::clearAllProgram(int arg0 __unused)
665	{
666	CTvProgram::CleanAllProgramBySrvType ( CTvProgram::TYPE_ATV );
667	CTvProgram::CleanAllProgramBySrvType ( CTvProgram::TYPE_TV );
668	CTvProgram::CleanAllProgramBySrvType ( CTvProgram::TYPE_DTV );
669	CTvProgram::CleanAllProgramBySrvType ( CTvProgram::TYPE_RADIO);
670	return 0;
671	}
672
673	int CTv::atvMunualScan ( int startFreq, int endFreq, int videoStd, int audioStd,
674	int store_Type , int channel_num )
675	{
676	int minScanFreq, maxScanFreq, vStd, aStd;
677
678	minScanFreq = mFrontDev.formatATVFreq ( startFreq );
679	maxScanFreq = mFrontDev.formatATVFreq ( endFreq );
680	if ( minScanFreq == 0 || maxScanFreq == 0 ) {
681	LOGE ( "%s, munual scan freq set is error min=%d, max=%d", __FUNCTION__, minScanFreq, maxScanFreq );
682	return -1;
683	}
684
685	//if set std null AUTO, use default PAL/DK
686	//if(videoStd == CC_ATV_VIDEO_STD_AUTO) {
687	// vStd = CC_ATV_VIDEO_STD_PAL;
688	// aStd = CC_ATV_AUDIO_STD_DK;
689	// } else {
690	vStd = videoStd;
691	aStd = audioStd;
692	// }
693
694	AutoMutex lock ( mLock );
695	mAv.DisableVideoWithBlueColor();
696	mTvAction |= TV_ACTION_SCANNING;
697	mTvScanner.setObserver ( &mTvMsgQueue );
698
699	SetAudioMuteForTv ( CC_AUDIO_MUTE );
700	v4l2_std_id stdAndColor = mFrontDev.enumToStdAndColor(vStd, aStd);
701
702	tvin_port_t source_port = CTvin::getInstance()->Tvin_GetSourcePortBySourceInput(SOURCE_TV);
703	CTvin::getInstance()->VDIN_OpenPort ( source_port );
704
705	int fmt = CFrontEnd::stdEnumToCvbsFmt (vStd, aStd);
706	CTvin::getInstance()->AFE_SetCVBSStd ( ( tvin_sig_fmt_t ) TVIN_SIG_FMT_NULL );
707	LOGD("%s, atv manual scan vstd=%d, astd=%d stdandcolor=%lld", __FUNCTION__, vStd, aStd, stdAndColor);
708	mFrontDev.Open(FE_ANALOG);
709	return mTvScanner.ATVManualScan ( minScanFreq, maxScanFreq, stdAndColor, store_Type, channel_num);
710	}
711
712	int CTv::getVideoFormatInfo ( int *pWidth, int *pHeight, int *pFPS, int *pInterlace )
713	{
714	int iOutRet = -1;
715	AM_AV_VideoStatus_t video_status;
716
717	do {
718	if ( NULL == pWidth || NULL == pHeight || NULL == pFPS || NULL == pInterlace ) {
719	break;
720	}
721
722	iOutRet = mAv.GetVideoStatus (&video_status );
723
724	if ( AM_SUCCESS != iOutRet ) {
725	LOGD ( "%s, ERROR: Cann't Get video format info\n", __FUNCTION__);
726	break;
727	}
728
729	*pWidth = video_status.src_w;
730	*pHeight = video_status.src_h;
731	*pFPS = video_status.fps;
732	*pInterlace = video_status.interlaced;
733	//LOGD("%s, w : %d h : %d fps : %d interlaced: %d\n", __FUNCTION__, video_status.src_w,video_status.src_h,video_status.fps,video_status.interlaced);
734	} while ( false );
735
736	return iOutRet;
737	}
738
739	int CTv::stopScanLock()
740	{
741	AutoMutex lock ( mLock );
742	return stopScan();
743	}
744
745	int CTv::stopScan()
746	{
747	const char *config_value = NULL;
748	if (!(mTvAction & TV_ACTION_SCANNING)) {
749	LOGD("%s, tv not scanning ,return\n", __FUNCTION__);
750	return 0;
751	}
752
753	LOGD("%s, tv scanning , stop it\n", __FUNCTION__);
754	config_value = config_get_str ( CFG_SECTION_TV, CFG_BLUE_SCREEN_COLOR, "null" );
755	if ( strcmp ( config_value, "black" ) == 0 ) {
756	mAv.DisableVideoWithBlackColor();
757	} else {
758	mAv.DisableVideoWithBlueColor();
759	}
760	mSigDetectThread.requestAndWaitPauseDetect();
761	mSigDetectThread.setObserver(this);
762	//mTvEpg.leaveChannel();
763	mTvScanner.stopScan();
764	mFrontDev.Close();
765	mTvAction &= ~TV_ACTION_SCANNING;
766	return 0;
767	}
768
769	int CTv::playProgramLock ( int progId )
770	{
771	/*AutoMutex lock ( mLock );
772	CTvProgram prog;
773	int ret = CTvProgram::selectByID ( progId, prog );
774
775	if ( ret != 0 ) {
776	return -1;
777	}
778	int type = prog.getProgType();
779	LOGD ( "%s, blackout = %dprog type = %d id = %d name = %s\n", __FUNCTION__, m_blackout_enable, type, progId, prog.getName().string() );
780	if (m_blackout_enable == 1) {
781	mAv.EnableVideoBlackout();
782	}else if (m_blackout_enable == 0){
783	mAv.DisableVideoBlackout();
784	}
785
786	mTvAction |= TV_ACTION_PLAYING;
787	m_cur_playing_prog_id = progId;
788	mFrontDev.Open(FE_ANALOG);
789	if ( m_source_input == SOURCE_TV && type == CTvProgram::TYPE_ATV ) {
790	playAtvProgram ( progId );
791	} else if ( m_source_input == SOURCE_DTV && ( type == CTvProgram::TYPE_DTV || type == CTvProgram::TYPE_RADIO ) ) {
792	playDtmbProgram ( progId );
793	} else {
794	LOGD ( "%s, source(%d) != type(%d),not play\n", __FUNCTION__, m_source_input, type );
795	}
796	//just for ui,left/right/stereo
797	int audio_ch = prog.getAudioChannel();
798	AM_AOUT_OutputMode_t channel = AM_AOUT_OUTPUT_STEREO;
799	if (audio_ch == 1) {
800	channel = AM_AOUT_OUTPUT_STEREO;
801	} else if (audio_ch == 2) {
802	channel = AM_AOUT_OUTPUT_DUAL_LEFT;
803	} else if (audio_ch == 3) {
804	channel = AM_AOUT_OUTPUT_DUAL_RIGHT;
805	}
806	setAudioChannel((int)channel);*/
807
808	progId = progId;
809	return 0;
810	}
811
812	int CTv::playDvbcProgram ( int progId )
813	{
814	LOGD ( "%s, progId = %d\n", __FUNCTION__, progId );
815
816	CTvProgram prog;
817	int ret = CTvProgram::selectByID ( progId, prog );
818	if ( ret != 0 ) {
819	return -1;
820	}
821
822	LOGD ( "%s, prog name = %s\n", __FUNCTION__, prog.getName().string() );
823	CTvChannel channel;
824	prog.getChannel ( channel );
825
826	mFrontDev.setPara ( channel.getMode(), channel.getFrequency(), channel.getSymbolRate(), channel.getModulation() );
827
828	int vpid = 0x1fff, apid = 0x1fff, vfmt = -1, afmt = -1;
829
830	CTvProgram::Video *pV = prog.getVideo();
831	if ( pV != NULL ) {
832	vpid = pV->getPID();
833	vfmt = pV->getFormat();
834	}
835
836	int aindex = prog.getCurrentAudio ( String8 ( "eng" ) );
837	if ( aindex >= 0 ) {
838	CTvProgram::Audio *pA = prog.getAudio ( aindex );
839	if ( pA != NULL ) {
840	apid = pA->getPID();
841	afmt = pA->getFormat();
842	}
843	}
844	mTvEpg.leaveProgram();
845	mTvEpg.leaveChannel();
846	startPlayTv ( SOURCE_DTV, vpid, apid, vfmt, afmt );
847
848	mTvEpg.enterChannel ( channel.getID() );
849	mTvEpg.enterProgram ( prog.getID() );
850	return 0;
851	}
852
853	int CTv::getAudioTrackNum ( int progId )
854	{
855	int iRet, iOutCnt = 0;
856	CTvProgram prog;
857
858	do {
859	if ( 0 > progId ) {
860	break;
861	}
862
863	iRet = CTvProgram::selectByID ( progId, prog );
864	if ( 0 != iRet ) {
865	break;
866	}
867
868	iOutCnt = prog.getAudioTrackSize();
869	} while ( false );
870
871	return iOutCnt;
872	}
873
874	int CTv::getAudioInfoByIndex ( int progId, int idx, int *pAFmt, String8 &lang )
875	{
876	int iRet, iOutRet = -1;
877	CTvProgram prog;
878	CTvProgram::Audio *pA = NULL;
879
880	do {
881	if ( NULL == pAFmt || idx < 0 ) {
882	break;
883	}
884
885	iRet = CTvProgram::selectByID ( progId, prog );
886	if ( 0 != iRet ) {
887	break;
888	}
889
890	if ( idx >= prog.getAudioTrackSize() ) {
891	break;
892	}
893
894	pA = prog.getAudio ( idx );
895	if ( NULL == pA ) {
896	break;
897	}
898
899	*pAFmt = pA->getFormat();
900	lang = pA->getLang();
901	} while ( false );
902
903	return iOutRet;
904	}
905
906	int CTv::switchAudioTrack (int aPid, int aFmt, int aParam __unused)
907	{
908	int iOutRet = 0;
909	do {
910	if ( aPid < 0 || aFmt < 0 ) {
911	break;
912	}
913
914	iOutRet = mAv.SwitchTSAudio (( uint16_t ) aPid, ( AM_AV_AFormat_t ) aFmt );
915	LOGD ( "%s, iOutRet = %d AM_AV_SwitchTSAudio\n", __FUNCTION__, iOutRet );
916	} while ( false );
917
918	return iOutRet;
919	}
920
921	int CTv::switchAudioTrack ( int progId, int idx )
922	{
923	int iOutRet = 0;
924	CTvProgram prog;
925	CTvProgram::Audio *pAudio = NULL;
926	int aPid = -1;
927	int aFmt = -1;
928
929	do {
930	if ( idx < 0 ) {
931	break;
932	}
933
934	iOutRet = CTvProgram::selectByID ( progId, prog );
935	if ( 0 != iOutRet ) {
936	break;
937	}
938	if (prog.getAudioTrackSize() <= 1) {
939	LOGD("%s, just one audio track, not to switch", __FUNCTION__);
940	break;
941	}
942	if ( idx >= prog.getAudioTrackSize() ) {
943	break;
944	}
945
946	pAudio = prog.getAudio ( idx );
947	if ( NULL == pAudio ) {
948	break;
949	}
950
951	aPid = pAudio->getPID();
952	aFmt = pAudio->getFormat();
953	if ( aPid < 0 || aFmt < 0 ) {
954	break;
955	}
956
957	iOutRet = mAv.SwitchTSAudio (( uint16_t ) aPid, ( AM_AV_AFormat_t ) aFmt );
958	LOGD ( "%s, iOutRet = %d AM_AV_SwitchTSAudio\n", __FUNCTION__, iOutRet );
959	} while ( false );
960
961	return iOutRet;
962	}
963
964	int CTv::ResetAudioDecoderForPCMOutput()
965	{
966	int iOutRet = 0;
967
968	iOutRet = mAv.ResetAudioDecoder ();
969	LOGD ( "%s, iOutRet = %d AM_AV_ResetAudioDecoder\n", __FUNCTION__, iOutRet );
970	return iOutRet;
971	}
972
973	int CTv::playDtvProgram ( int mode, int freq, int para1, int para2,
974	int vpid, int vfmt, int apid, int afmt, int pcr __unused, int audioCompetation)
975	{
976	AutoMutex lock ( mLock );
977	mTvAction |= TV_ACTION_PLAYING;
978	if ( m_blackout_enable == 1 ) {
979	mAv.EnableVideoBlackout();
980	} else if ( m_blackout_enable == 0 ) {
981	mAv.DisableVideoBlackout();
982	}
983	mFrontDev.Open(FE_ANALOG);
984	mFrontDev.setPara ( mode, freq, para1, para2);
985	mTvAction |= TV_ACTION_PLAYING;
986	startPlayTv ( SOURCE_DTV, vpid, apid, vfmt, afmt );
987
988	CMessage msg;
989	msg.mDelayMs = 2000;
990	msg.mType = CTvMsgQueue::TV_MSG_CHECK_FE_DELAY;
991	mTvMsgQueue.sendMsg ( msg );
992	SetCurProgramAudioVolumeCompensationVal ( audioCompetation );
993	return 0;
994	}
995
996	int CTv::playDtmbProgram ( int progId )
997	{
998	CTvProgram prog;
999	CTvChannel channel;
1000	int vpid = 0x1fff, apid = 0x1fff, vfmt = -1, afmt = -1;
1001	int aindex;
1002	CTvProgram::Audio *pA;
1003	CTvProgram::Video *pV;
1004	int ret = CTvProgram::selectByID ( progId, prog );
1005
1006	SetAudioMuteForTv ( CC_AUDIO_MUTE );
1007	saveDTVProgramID ( progId );
1008	prog.getChannel ( channel );
1009	//音量补偿
1010	int chanVolCompValue = 0;
1011	chanVolCompValue = GetAudioVolumeCompensationVal(progId);
1012	SetCurProgramAudioVolumeCompensationVal ( chanVolCompValue );
1013
1014	mFrontDev.setPara ( channel.getMode(), channel.getFrequency(), channel.getBandwidth(), 0 );
1015
1016	pV = prog.getVideo();
1017	if ( pV != NULL ) {
1018	vpid = pV->getPID();
1019	vfmt = pV->getFormat();
1020	}
1021
1022	aindex = prog.getCurrAudioTrackIndex();
1023	if ( -1 == aindex ) { //db is default
1024	aindex = prog.getCurrentAudio ( String8 ( "eng" ) );
1025	if ( aindex >= 0 ) {
1026	prog.setCurrAudioTrackIndex ( progId, aindex );
1027	}
1028	}
1029
1030	if ( aindex >= 0 ) {
1031	pA = prog.getAudio ( aindex );
1032	if ( pA != NULL ) {
1033	apid = pA->getPID();
1034	afmt = pA->getFormat();
1035	}
1036	}
1037
1038	mTvEpg.leaveProgram();
1039	mTvEpg.leaveChannel();
1040	startPlayTv ( SOURCE_DTV, vpid, apid, vfmt, afmt );
1041	mTvEpg.enterChannel ( channel.getID() );
1042	mTvEpg.enterProgram ( prog.getID() );
1043	return 0;
1044	}
1045
1046	int CTv::playAtvProgram (int freq, int videoStd, int audioStd, int fineTune __unused, int audioCompetation)
1047	{
1048	mTvAction |= TV_ACTION_PLAYING;
1049	if ( m_blackout_enable == 1 ) {
1050	mAv.EnableVideoBlackout();
1051	} else if ( m_blackout_enable == 0 ) {
1052	mAv.DisableVideoBlackout();
1053	}
1054	SetAudioMuteForTv ( CC_AUDIO_MUTE );
1055	//image selecting channel
1056	mSigDetectThread.requestAndWaitPauseDetect();
1057	CTvin::getInstance()->Tvin_StopDecoder();
1058	mFrontDev.Open(FE_ANALOG);
1059	//set CVBS
1060	int fmt = CFrontEnd::stdEnumToCvbsFmt (videoStd, audioStd);
1061	CTvin::getInstance()->AFE_SetCVBSStd ( ( tvin_sig_fmt_t ) fmt );
1062
1063	v4l2_std_id stdAndColor = mFrontDev.enumToStdAndColor (videoStd, audioStd);
1064	//set TUNER
1065	mFrontDev.setPara (FE_ANALOG, freq, stdAndColor, 1);
1066
1067	mSigDetectThread.setObserver ( this );
1068	mSigDetectThread.initSigState();
1069	mSigDetectThread.resumeDetect(1000);
1070
1071	SetCurProgramAudioVolumeCompensationVal ( audioCompetation );
1072	return 0;
1073	}
1074
1075	int CTv::resetFrontEndPara ( frontend_para_set_t feParms )
1076	{
1077	if ( feParms.mode == FE_ANALOG ) {
1078	int progID = -1;
1079	int tmpFreq = feParms.freq;
1080	int tmpfineFreq = feParms.para2;
1081	int mode = feParms.mode;
1082
1083	//get tunerStd from videoStd and audioStd
1084	v4l2_std_id stdAndColor = mFrontDev.enumToStdAndColor (feParms.videoStd, feParms.audioStd);
1085
1086	LOGD("%s, resetFrontEndPara-　vstd=%d astd=%d stdandcolor=%lld", __FUNCTION__, feParms.videoStd, feParms.audioStd, stdAndColor);
1087
1088	//set frontend parameters to tuner dev
1089	mSigDetectThread.requestAndWaitPauseDetect();
1090	CTvin::getInstance()->Tvin_StopDecoder();
1091
1092	//set CVBS
1093	int fmt = CFrontEnd::stdEnumToCvbsFmt (feParms.videoStd, feParms.audioStd );
1094	CTvin::getInstance()->AFE_SetCVBSStd ( ( tvin_sig_fmt_t ) fmt );
1095
1096	//set TUNER
1097	usleep(400 * 1000);
1098	mFrontDev.setPara ( FE_ANALOG, tmpFreq, stdAndColor, 1 );
1099	usleep(400 * 1000);
1100	if ( tmpfineFreq != 0 ) {
1101	mFrontDev.fineTune ( tmpfineFreq / 1000 );
1102	}
1103
1104	mSigDetectThread.initSigState();
1105	mSigDetectThread.resumeDetect();
1106	} else if ( feParms.mode == FE_DTMB ) {
1107	mFrontDev.setPara ( FE_DTMB, feParms.freq, feParms.para1, feParms.para2 );
1108	}
1109
1110	return 0;
1111	}
1112
1113	int CTv::resetDmxAndAvSource()
1114	{
1115	AM_DMX_Source_t curdmxSource;
1116	mFrontDev.GetTSSource ( &curdmxSource );
1117	LOGD ( "%s, AM_FEND_GetTSSource %d", __FUNCTION__, curdmxSource );
1118	mTvDmx.Close();
1119	AM_DMX_OpenPara_t para;
1120	memset ( &para, 0, sizeof ( para ) );
1121	mTvDmx.Open (para);
1122	mTvDmx.SetSource(curdmxSource );
1123	AM_AV_TSSource_t ts_source = ( AM_AV_TSSource_t ) curdmxSource;
1124	mAv.SetTSSource (ts_source );
1125	return 0;
1126	}
1127
1128	int CTv::SetCurProgramAudioVolumeCompensationVal ( int tmpVal )
1129	{
1130	SetAudioVolumeCompensationVal ( tmpVal );
1131	SetAudioMasterVolume (GetAudioMasterVolume() );
1132
1133	LOGD ( "%s, VolumeCompensationVal = %d, id = %d\n", __FUNCTION__, tmpVal, m_cur_playing_prog_id );
1134	CTvProgram prog;
1135	if ( CTvProgram::selectByID ( m_cur_playing_prog_id, prog ) != 0 ) {
1136	LOGE ( "%s, atv progID is not matching the db's ret = 0\n", __FUNCTION__ );
1137	return -1;
1138	}
1139
1140	if (prog.updateVolComp ( m_cur_playing_prog_id, tmpVal ) != 0 ) {
1141	LOGE ( "%s, atv progID is not matching the db's\n", __FUNCTION__);
1142	return -1;
1143	}
1144	return 0;
1145	}
1146
1147	int CTv::GetAudioVolumeCompensationVal(int progxxId __unused)
1148	{
1149	int tmpVolValue = 0;
1150	CTvProgram prog;
1151	if ( CTvProgram::selectByID ( m_cur_playing_prog_id, prog ) != 0 ) {
1152	LOGE ( "%s, atv progID is not matching the db's ret = 0\n", __FUNCTION__ );
1153	return tmpVolValue;
1154	}
1155	tmpVolValue = prog.getChanVolume ();
1156	LOGD ( "%s,progid = %d CompensationVal = %d\n", __FUNCTION__, m_cur_playing_prog_id, tmpVolValue );
1157	if (tmpVolValue > 20 || tmpVolValue < -20) tmpVolValue = 0;
1158	return tmpVolValue;
1159	}
1160
1161	int CTv::startPlayTv ( int source, int vid, int aid, int vfat, int afat )
1162	{
1163	if ( source == SOURCE_DTV ) {
1164	AM_FileEcho ( DEVICE_CLASS_TSYNC_AV_THRESHOLD_MIN, AV_THRESHOLD_MIN_MS );
1165	LOGD ( "%s, startPlayTv", __FUNCTION__);
1166	mAv.StartTS (vid, aid, ( AM_AV_VFormat_t ) vfat, ( AM_AV_AFormat_t ) afat );
1167	}
1168	return 0;
1169	}
1170
1171	int CTv::stopPlayingLock()
1172	{
1173	AutoMutex lock ( mLock );
1174	if (getSubSwitchStatus() == 1)
1175	stopSubtitle();
1176	return stopPlaying();
1177	}
1178
1179	int CTv::stopPlaying()
1180	{
1181	const char *config_value = NULL;
1182	if (!(mTvAction & TV_ACTION_PLAYING)) {
1183	LOGD("%s, stopplay cur action = %x not playing , return", __FUNCTION__, mTvAction);
1184	return 0;
1185	}
1186	mSigDetectThread.requestAndWaitPauseDetect();
1187	mAv.EnableVideoBlackout();
1188	if (m_source_input == SOURCE_TV) {
1189	//first mute
1190	SetAudioMuteForTv(CC_AUDIO_MUTE);
1191	ClearAnalogFrontEnd();
1192	} else if (m_source_input == SOURCE_DTV) {
1193	//mFrontDev.setPara(FE_DTMB, 51000000, 0, 0);
1194	mAv.StopTS ();
1195	//mTvEpg.leaveChannel();
1196	//mTvEpg.leaveProgram();
1197	}
1198	config_value = config_get_str ( CFG_SECTION_TV, CFG_BLUE_SCREEN_COLOR, "null" );
1199	if ( strcmp ( config_value, "black" ) == 0 ) {
1200	mAv.DisableVideoWithBlackColor();
1201	} else {
1202	mAv.DisableVideoWithBlueColor();
1203	}
1204	mTvAction &= ~TV_ACTION_PLAYING;
1205	return 0;
1206	}
1207
1208	int CTv::GetATVAFCType()
1209	{
1210	return 1;
1211	}
1212
1213	int CTv::GetATVSourceTimerSwitch()
1214	{
1215	return 1;
1216	}
1217
1218	int CTv::getAudioChannel()
1219	{
1220	int iRet = -1;
1221	AM_AOUT_OutputMode_t audioChanneleMod;
1222	do {
1223	iRet = mAv.AudioGetOutputMode (&audioChanneleMod );
1224	if ( AM_SUCCESS != iRet ) {
1225	LOGD ( "%s, audio GetOutputMode is FAILED %d\n", __FUNCTION__, iRet );
1226	break;
1227	}
1228	LOGD ( "%s, jianfei.lan getAudioChannel iRet : %d audioChanneleMod %d\n", __FUNCTION__, iRet, audioChanneleMod );
1229	} while ( 0 );
1230	return audioChanneleMod;
1231	}
1232
1233	int CTv::setAudioChannel ( int channelIdx )
1234	{
1235	int iOutRet = 0;
1236	AM_AOUT_OutputMode_t audioChanneleMod;
1237	LOGD ( "%s, channelIdx : %d\n", __FUNCTION__, channelIdx );
1238	audioChanneleMod = ( AM_AOUT_OutputMode_t ) channelIdx;
1239	iOutRet = mAv.AudioSetOutputMode (audioChanneleMod );
1240	int aud_ch = 1;
1241	if (audioChanneleMod == AM_AOUT_OUTPUT_STEREO) {
1242	aud_ch = 1;
1243	} else if (audioChanneleMod == AM_AOUT_OUTPUT_DUAL_LEFT) {
1244	aud_ch = 2;
1245	} else if (audioChanneleMod == AM_AOUT_OUTPUT_DUAL_RIGHT) {
1246	aud_ch = 3;
1247	}
1248	CTvProgram::updateAudioChannel(m_cur_playing_prog_id, aud_ch);
1249	if ( AM_SUCCESS != iOutRet) {
1250	LOGD ( "%s, jianfei.lan TV AM_AOUT_SetOutputMode device is FAILED %d\n", __FUNCTION__, iOutRet );
1251	}
1252	return 0;
1253	}
1254
1255	int CTv::getFrontendSignalStrength()
1256	{
1257	return mFrontDev.getStrength();
1258	}
1259
1260	int CTv::getFrontendSNR()
1261	{
1262	return mFrontDev.getSNR();
1263	}
1264
1265	int CTv::getFrontendBER()
1266	{
1267	return mFrontDev.getBER();
1268	}
1269
1270	int CTv::getChannelInfoBydbID ( int dbID, channel_info_t &chan_info )
1271	{
1272	CTvProgram prog;
1273	CTvChannel channel;
1274	Vector<sp<CTvProgram> > out;
1275	memset ( &chan_info, sizeof ( chan_info ), 0 );
1276	chan_info.freq = 44250000;
1277	chan_info.uInfo.atvChanInfo.videoStd = CC_ATV_VIDEO_STD_PAL;
1278	chan_info.uInfo.atvChanInfo.audioStd = CC_ATV_AUDIO_STD_DK;
1279	static const int CVBS_ID = -1;
1280	if (dbID == CVBS_ID) {
1281	unsigned char std;
1282	SSMReadCVBSStd(&std);
1283	chan_info.uInfo.atvChanInfo.videoStd = (atv_video_std_t)std;
1284	chan_info.uInfo.atvChanInfo.audioStd = CC_ATV_AUDIO_STD_DK;
1285	chan_info.uInfo.atvChanInfo.isAutoStd = (std == CC_ATV_VIDEO_STD_AUTO) ? 1 : 0;
1286	return 0;
1287	}
1288
1289	int ret = CTvProgram::selectByID ( dbID, prog );
1290	if ( ret != 0 ) {
1291	LOGD ( "getChannelinfo , select dbid=%d,is not exist", dbID);
1292	return -1;
1293	}
1294	prog.getChannel ( channel );
1295
1296	if ( CTvProgram::TYPE_ATV == prog.getProgType() ) {
1297	chan_info.freq = channel.getFrequency();
1298	chan_info.uInfo.atvChanInfo.finefreq = channel.getAfcData();
1299	LOGD("%s, get channel std = %d", __FUNCTION__, channel.getStd());
1300	chan_info.uInfo.atvChanInfo.videoStd =
1301	( atv_video_std_t ) CFrontEnd::stdAndColorToVideoEnum ( channel.getStd() );
1302	chan_info.uInfo.atvChanInfo.audioStd =
1303	( atv_audio_std_t ) CFrontEnd::stdAndColorToAudioEnum ( channel.getStd() );
1304	chan_info.uInfo.atvChanInfo.isAutoStd = ((channel.getStd() & V4L2_COLOR_STD_AUTO) == V4L2_COLOR_STD_AUTO) ? 1 : 0;
1305	} else if ( CTvProgram::TYPE_DTV == prog.getProgType() || CTvProgram::TYPE_RADIO == prog.getProgType()) {
1306	chan_info.freq = channel.getFrequency();
1307	chan_info.uInfo.dtvChanInfo.strength = getFrontendSignalStrength();
1308	chan_info.uInfo.dtvChanInfo.quality = getFrontendSNR();
1309	chan_info.uInfo.dtvChanInfo.ber = getFrontendBER();
1310	}
1311
1312	return 0;
1313	}
1314
1315	bool CTv::Tv_Start_Analyze_Ts ( int channelID )
1316	{
1317	int freq, ret;
1318	CTvChannel channel;
1319
1320	AutoMutex lock ( mLock );
1321	mAv.StopTS ();
1322	mAv.DisableVideoWithBlueColor();
1323	ret = CTvChannel::selectByID ( channelID, channel );
1324	if ( ret != 0 ) {
1325	LOGD ( "%s, CTv tv_updatats can not get freq by channel ID", __FUNCTION__ );
1326	return false;
1327	}
1328
1329	mTvAction |= TV_ACTION_SCANNING;
1330	freq = channel.getFrequency();
1331	LOGD ( "%s, the freq = %d", __FUNCTION__, freq );
1332	mDtvScanRunningStatus = DTV_SCAN_RUNNING_ANALYZE_CHANNEL;
1333	mTvScanner.setObserver ( &mTvMsgQueue );
1334	mTvScanner.manualDtmbScan ( freq, freq ); //dtmb
1335	return true;
1336	}
1337
1338	bool CTv::Tv_Stop_Analyze_Ts()
1339	{
1340	stopScanLock();
1341	return true;
1342	}
1343
1344	int CTv::saveATVProgramID ( int dbID )
1345	{
1346	config_set_int ( CFG_SECTION_TV, "atv.get.program.id", dbID );
1347	return 0;
1348	}
1349
1350	int CTv::getATVProgramID ( void )
1351	{
1352	return config_get_int ( CFG_SECTION_TV, "atv.get.program.id", -1 );
1353	}
1354
1355	int CTv::saveDTVProgramID ( int dbID )
1356	{
1357	config_set_int ( CFG_SECTION_TV, "dtv.get.program.id", dbID );
1358	return 0;
1359	}
1360
1361	int CTv::getDTVProgramID ( void )
1362	{
1363	return config_get_int ( CFG_SECTION_TV, "dtv.get.program.id", -1 );
1364	}
1365
1366	int CTv::getATVMinMaxFreq ( int *scanMinFreq, int *scanMaxFreq )
1367	{
1368	const char *strDelimit = ",";
1369	char *token = NULL;
1370
1371	*scanMinFreq = 44250000;
1372	*scanMaxFreq = 868250000;
1373
1374	const char *freqList = config_get_str ( CFG_SECTION_ATV, CFG_ATV_FREQ_LIST, "null" );
1375	if ( strcmp ( freqList, "null" ) == 0 ) {
1376	LOGE( "%s, atv freq list is null \n", __FUNCTION__ );
1377	return -1;
1378	}
1379
1380	char data_str[512] = {0};
1381	strncpy ( data_str, freqList, sizeof ( data_str ) - 1 );
1382
1383	char *pSave;
1384	token = strtok_r ( data_str, strDelimit, &pSave);
1385	sscanf ( token, "%d", scanMinFreq );
1386	token = strtok_r ( NULL, strDelimit , &pSave);
1387	if ( token != NULL ) {
1388	sscanf ( token, "%d", scanMaxFreq );
1389	}
1390	return 0;
1391	}
1392
1393	int CTv::IsDVISignal()
1394	{
1395	return ( ( TVIN_SIG_FMT_NULL != mSigDetectThread.getCurSigInfo().fmt ) && ( mSigDetectThread.getCurSigInfo().reserved & 0x1 ) );
1396	}
1397
1398	int CTv::getHDMIFrameRate()
1399	{
1400	int ConstRate[5] = {24, 25, 30, 50, 60};
1401	float ConstRateDiffHz[5] = {0.5, 0.5, 0.5, 2, 2};
1402	int fps = mSigDetectThread.getCurSigInfo().fps;
1403	for (int i = 0; i < 5; i++) {
1404	if (abs(ConstRate[i] - fps) < ConstRateDiffHz[i])
1405	fps = ConstRate[i];
1406	}
1407	return fps;
1408	}
1409
1410	tv_source_input_t CTv::GetLastSourceInput ( void )
1411	{
1412	return m_last_source_input;
1413	}
1414
1415	int CTv::isVgaFmtInHdmi ( void )
1416	{
1417	if ( CTvin::Tvin_SourceInputToSourceInputType(m_source_input) != SOURCE_TYPE_HDMI ) {
1418	return -1;
1419	}
1420	return CTvin::isVgaFmtInHdmi (mSigDetectThread.getCurSigInfo().fmt);
1421	}
1422
1423	int CTv::isSDFmtInHdmi ( void )
1424	{
1425	if ( CTvin::Tvin_SourceInputToSourceInputType(m_source_input) != SOURCE_TYPE_HDMI ) {
1426	return -1;
1427	}
1428	return CTvin::isSDFmtInHdmi (mSigDetectThread.getCurSigInfo().fmt);
1429	}
1430
1431	void CTv::print_version_info ( void )
1432	{
1433	// print tvapi version info
1434	LOGD ( "libtvservice git branch:%s\n", tvservice_get_git_branch_info() );
1435	LOGD ( "libtvservice git version:%s\n", tvservice_get_git_version_info() );
1436	LOGD ( "libtvservice Last Changed:%s\n", tvservice_get_last_chaned_time_info() );
1437	LOGD ( "libtvservice Last Build:%s\n", tvservice_get_build_time_info() );
1438	LOGD ( "libtvservice Builer Name:%s\n", tvservice_get_build_name_info() );
1439	LOGD ( "libtvservice board version:%s\n", tvservice_get_board_version_info() );
1440	LOGD ( "\n\n");
1441	// print dvb version info
1442	LOGD ( "libdvb git branch:%s\n", dvb_get_git_branch_info() );
1443	LOGD ( "libdvb git version:%s\n", dvb_get_git_version_info() );
1444	LOGD ( "libdvb Last Changed:%s\n", dvb_get_last_chaned_time_info() );
1445	LOGD ( "libdvb Last Build:%s\n", dvb_get_build_time_info() );
1446	LOGD ( "libdvb Builer Name:%s\n", dvb_get_build_name_info() );
1447	}
1448
1449	int CTv::Tvin_GetTvinConfig ( void )
1450	{
1451	const char *config_value;
1452
1453	config_value = config_get_str ( CFG_SECTION_TV, CFG_TVIN_KERNELPET_DISABLE, "null" );
1454	if ( strcmp ( config_value, "disable" ) == 0 ) {
1455	gTvinConfig.kernelpet_disable = true;
1456	} else {
1457	gTvinConfig.kernelpet_disable = false;
1458	}
1459
1460	config_value = config_get_str ( CFG_SECTION_TV, CFG_TVIN_KERNELPET_TIMEROUT, "null" );
1461	gTvinConfig.userpet_timeout = ( unsigned int ) strtol ( config_value, NULL, 10 );
1462
1463	if ( gTvinConfig.kernelpet_timeout <= 0 || gTvinConfig.kernelpet_timeout > 40 ) {
1464	gTvinConfig.kernelpet_timeout = 10;
1465	}
1466
1467	config_value = config_get_str ( CFG_SECTION_TV, CFG_TVIN_USERPET, "null" );
1468	if ( strcmp ( config_value, "enable" ) == 0 ) {
1469	gTvinConfig.userpet = true;
1470	} else {
1471	gTvinConfig.userpet = false;
1472	}
1473
1474	config_value = config_get_str ( CFG_SECTION_TV, CFG_TVIN_USERPET_TIMEROUT, "null" );
1475	gTvinConfig.userpet_timeout = ( unsigned int ) strtol ( config_value, NULL, 10 );
1476
1477	if ( gTvinConfig.userpet_timeout <= 0 || gTvinConfig.userpet_timeout > 100 ) {
1478	gTvinConfig.userpet_timeout = 10;
1479	}
1480
1481	config_value = config_get_str ( CFG_SECTION_TV, CFG_TVIN_USERPET_RESET, "null" );
1482	if ( strcmp ( config_value, "disable" ) == 0 ) {
1483	gTvinConfig.userpet_reset = 0;
1484	} else {
1485	gTvinConfig.userpet_reset = 1;
1486	}
1487	return 0;
1488	}
1489
1490	TvRunStatus_t CTv::GetTvStatus()
1491	{
1492	Mutex::Autolock _l ( mLock );
1493	return mTvStatus;
1494	}
1495
1496	int CTv::OpenTv ( void )
1497	{
1498	const char *value;
1499	Tv_Spread_Spectrum();
1500	//reboot system by fbc setting.
1501	value = config_get_str ( CFG_SECTION_TV, CFG_FBC_PANEL_INFO, "null" );
1502	LOGD("open tv, get fbc panel info:%s\n", value);
1503	if ( strcmp ( value, "edid" ) == 0 ) {
1504	reboot_sys_by_fbc_edid_info();
1505	} else if ( strcmp ( value, "uart" ) == 0 ) {
1506	reboot_sys_by_fbc_uart_panel_info(fbcIns);
1507	}
1508
1509	CTvin::getInstance()->Tvin_LoadSourceInputToPortMap();
1510
1511	SSMHandlePreCopying();
1512	if ( SSMDeviceMarkCheck() < 0 ) {
1513	SSMRestoreDeviceMarkValues();
1514	Tv_SSMRestoreDefaultSetting();
1515	}
1516	CTvin::getInstance()->OpenTvin();
1517	CTvin::getInstance()->init_vdin();
1518	CTvin::getInstance()->Tv_init_afe();
1519	CVpp::getInstance()->Vpp_Init(getPqDbPath());
1520	TvAudioOpen();
1521	SetAudioVolDigitLUTTable(SOURCE_MPEG);
1522
1523	SSMSetHDCPKey();
1524	system ( "/system/bin/dec" );
1525
1526	//set color filter
1527	// SetFileAttrValue ( "/sys/module/amvideo/parameters/filt_mode", "0x2100" );
1528	value = config_get_str ( CFG_SECTION_TV, CFG_TVIN_DISPLAY_FREQ_AUTO, "null" );
1529	if ( strcmp ( value, "enable" ) == 0 ) {
1530	mAutoSetDisplayFreq = true;
1531	} else {
1532	mAutoSetDisplayFreq = false;
1533	}
1534
1535	Tv_HandeHDMIEDIDFilePathConfig();
1536
1537	value = config_get_str ( CFG_SECTION_TV, CFG_SSM_HDMI_EDID_EN, "null" );
1538	if ( strtoul(value, NULL, 10) == 1 ) {
1539	LOGD( "%s, get config \"%s\" is \"%s\".\n", __FUNCTION__, CFG_SSM_HDMI_EDID_EN, value );
1540	//get hdmi edid use mode
1541	char prop_value[256] = {0};
1542	char *pEdid = NULL;
1543	property_get( UBOOTENV_OUTPUTMODE, prop_value, "null" );
1544	LOGD( "%s, get property [%s]:[%s]\n", __FUNCTION__, UBOOTENV_OUTPUTMODE, prop_value );
1545
1546	if ( strcmp ( prop_value, "null" ) != 0 )
1547	pEdid = prop_value;
1548	else
1549	pEdid = (char *)"hdmi_edid";//set default hdmi edid
1550
1551	config_set_str ( CFG_SECTION_TV, CS_HDMI_EDID_USE_CFG, pEdid );
1552	//set file's path for hdmi edid of each port
1553	for ( int i = 1; i <= SSM_HDMI_PORT_MAX; i++ ) {
1554	char edid_path[256] = {0};
1555	char edid_path_cfg[256] = {0};
1556	sprintf ( edid_path, "/system/etc/%s_port%d.bin", pEdid, i );
1557	sprintf ( edid_path_cfg, "ssm.handle.hdmi.port%d.edid.file.path", i );
1558	config_set_str ( CFG_SECTION_TV, edid_path_cfg, edid_path );
1559	}
1560
1561	mSetHdmiEdid = true;
1562	}
1563
1564	Tvin_GetTvinConfig();
1565	m_last_source_input = SOURCE_INVALID;
1566	m_source_input = SOURCE_INVALID;
1567	m_mode_3d = VIDEO_3D_MODE_DISABLE;
1568	m_hdmi_sampling_rate = 0;
1569	int8_t blackout_enable;
1570	SSMReadBlackoutEnable(&blackout_enable);
1571	m_blackout_enable = blackout_enable;
1572
1573	//dtv init
1574	//int rt = -1;
1575	//opendemux();
1576	//rt = mFrontDev.Open(FE_ANALOG);
1577	//mFrontDev.autoLoadFE();
1578	//rt = mFrontDev.Open(FE_ANALOG);
1579	AM_DMX_OpenPara_t para_dmx;
1580	memset ( &para_dmx, 0, sizeof ( AM_DMX_OpenPara_t ) );
1581	mTvDmx.Open(para_dmx );
1582	mTvDmx.SetSource (AM_DMX_SRC_TS2);
1583	mAv.Open();
1584	//mTvEpg.Init ( 0, 0, 1, "eng zho chi", "GB2312" );
1585	resetDmxAndAvSource();
1586	mSourceConnectDetectThread.startDetect();
1587
1588	if (SSMReadSerialCMDSwitchValue() == 1) {
1589	SetSerialSwitch(SERIAL_A, 1);
1590	}
1591	ClearAnalogFrontEnd();
1592
1593	mTvStatus = TV_OPEN_ED;
1594
1595	mHDMIRxCEC.start();
1596	mAutoPQparam.startAutoPQ(CTvin::Tvin_SourceInputToSourceInputType(SOURCE_MPEG));
1597	return 0;
1598	}
1599
1600	int CTv::CloseTv ( void )
1601	{
1602	LOGD ( "tv close");
1603	mSigDetectThread.stopDetect();
1604	if (mpUpgradeFBC != NULL) {
1605	mpUpgradeFBC->stop();
1606	}
1607	CTvin::getInstance()->Tv_uninit_afe();
1608	CTvin::getInstance()->uninit_vdin();
1609	CVpp::getInstance()->Vpp_Uninit();
1610	TvMisc_DisableWDT ( gTvinConfig.userpet );
1611	mTvStatus = TV_CLOSE_ED;
1612	return 0;
1613	}
1614
1615	int CTv::StartTvLock ()
1616	{
1617	LOGD ( "%s, tv start status = %d", __FUNCTION__, mTvStatus);
1618	if (mTvStatus == TV_START_ED)
1619	return 0;
1620
1621	Mutex::Autolock _l ( mLock );
1622	mTvAction |= TV_ACTION_STARTING;
1623	mAv.ClearVideoBuffer();
1624	SwitchAVOutBypass(0);
1625	InitSetTvAudioCard();
1626	SetAudioMuteForTv(CC_AUDIO_MUTE);
1627	mFrontDev.Open(FE_ANALOG);
1628	mFrontDev.autoLoadFE();
1629	mSigDetectThread.startDetect();
1630	mTvMsgQueue.startMsgQueue();
1631	resetDmxAndAvSource();
1632	SetDisplayMode ( CVpp::getInstance()->GetDisplayMode ( CTvin::Tvin_SourceInputToSourceInputType(m_source_input) ), CTvin::Tvin_SourceInputToSourceInputType(m_source_input), mSigDetectThread.getCurSigInfo().fmt);
1633	TvMisc_EnableWDT ( gTvinConfig.kernelpet_disable, gTvinConfig.userpet, gTvinConfig.kernelpet_timeout, gTvinConfig.userpet_timeout, gTvinConfig.userpet_reset );
1634	am_phase_t am_phase;
1635	if (CVpp::getInstance()->getPqData()->PQ_GetPhaseArray ( &am_phase ) == 0 ) {
1636	CTvin::getInstance()->TvinApi_SetCompPhase(am_phase);
1637	}
1638	CTvin::getInstance()->TvinApi_SetCompPhaseEnable ( 1 );
1639	CTvin::getInstance()->VDIN_EnableRDMA ( 1 );
1640
1641	//win pos
1642	tvin_window_pos_t win_pos;
1643	Vpp_GetDisplayResolutionInfo(&win_pos);
1644	SetPreviewWindow ( win_pos );
1645
1646	CTvin::getInstance()->Tvin_RemovePath ( TV_PATH_TYPE_TVIN );
1647	if ( CTvin::getInstance()->Tvin_RemovePath ( TV_PATH_TYPE_DEFAULT ) ) {
1648	CTvin::getInstance()->Tvin_AddPath ( TV_PATH_DECODER_NEW3D_WITHOUTPPMGR_AMVIDEO );
1649	}
1650
1651	mAv.SetVideoWindow (0, 0, 0, 0 );
1652
1653	mTvAction &= ~TV_ACTION_STARTING;
1654	mTvStatus = TV_START_ED;
1655	return 0;
1656	}
1657
1658	int CTv::DoInstabootSuspend()
1659	{
1660	CTvDatabase::GetTvDb()->UnInitTvDb();
1661	CTvSettingdoSuspend();
1662	CVpp::getInstance()->doSuspend();
1663	LOGD("%s, \n", __FUNCTION__);
1664	return 0;
1665	}
1666
1667	int CTv::DoInstabootResume()
1668	{
1669	CTvDatabase::GetTvDb()->InitTvDb(TV_DB_PATH);
1670	CTvSettingdoResume();
1671	CVpp::getInstance()->doResume();
1672	LOGD("%s, \n", __FUNCTION__);
1673	return 0;
1674	}
1675
1676	int CTv::DoSuspend(int type)
1677	{
1678	if (type == 1) {
1679	DoInstabootSuspend();
1680	}
1681	return 0;
1682	}
1683
1684	int CTv::DoResume(int type)
1685	{
1686	if (type == 1) {
1687	DoInstabootResume();
1688	}
1689	return 0;
1690	}
1691
1692	int CTv::StopTvLock ( void )
1693	{
1694	LOGD("%s, call Tv_Stop status = %d \n", __FUNCTION__, mTvStatus);
1695	const char *value;
1696	Mutex::Autolock _l ( mLock );
1697	mAv.DisableVideoWithBlackColor();
1698	CVpp::getInstance()->LoadVppSettings ( SOURCE_TYPE_MPEG, TVIN_SIG_FMT_NULL, INDEX_2D, TVIN_TFMT_2D );
1699	//we should stop audio first for audio mute.
1700	mTvAction |= TV_ACTION_STOPING;
1701	CTvin::getInstance()->Tvin_StopDecoder();
1702	CTvin::getInstance()->Tvin_RemovePath ( TV_PATH_TYPE_TVIN );
1703	CTvin::getInstance()->VDIN_ClosePort();
1704	mTvMsgQueue.clearMsg();
1705	mSigDetectThread.requestAndWaitPauseDetect();
1706	//stop scan if scanning
1707	stopScan();
1708	mFrontDev.SetAnalogFrontEndTimerSwitch(0);
1709	//first stop play(if playing)
1710	stopPlaying();
1711	//
1712	setAudioChannel(AM_AOUT_OUTPUT_STEREO);
1713	CTvin::getInstance()->setMpeg2Vdin(0);
1714	mAv.setLookupPtsForDtmb(0);
1715	SwitchAVOutBypass(0);
1716	tv_audio_channel_e audio_channel = CTvin::getInstance()->Tvin_GetInputSourceAudioChannelIndex (SOURCE_MPEG);
1717	AudioLineInSelectChannel( audio_channel );
1718	AudioCtlUninit();
1719	SetAudioVolDigitLUTTable(SOURCE_MPEG);
1720	Tv_SetAudioInSource(SOURCE_MPEG);
1721	tvin_window_pos_t win_pos;
1722	Vpp_GetDisplayResolutionInfo(&win_pos);
1723	SetPreviewWindow (win_pos );
1724	//CVpp::getInstance()->LoadVppSettings ( SOURCE_TYPE_MPEG, TVIN_SIG_FMT_NULL, INDEX_2D, TVIN_TFMT_2D );
1725	SetDisplayMode ( CVpp::getInstance()->GetDisplayMode ( CTvin::Tvin_SourceInputToSourceInputType(SOURCE_MPEG) ), CTvin::Tvin_SourceInputToSourceInputType(SOURCE_MPEG), mSigDetectThread.getCurSigInfo().fmt);
1726	RefreshAudioMasterVolume ( SOURCE_MPEG );
1727	CVpp::getInstance()->VPP_SetScalerPathSel(0);
1728	CVpp::getInstance()->VPP_SetVideoCrop ( 0, 0, 0, 0 );
1729	m_last_source_input = SOURCE_INVALID;
1730	m_source_input = SOURCE_INVALID;
1731	mFrontDev.Close();
1732	mTvAction &= ~TV_ACTION_STOPING;
1733	mTvStatus = TV_STOP_ED;
1734	if ( Get2d4gHeadsetEnable() == 1 ) {
1735	property_set("audio.tv_open.flg", "0");
1736	}
1737
1738	Tv_SetDDDRCMode(SOURCE_MPEG);
1739	mAv.DisableVideoWithBlackColor();
1740	//mAutoPQparam.startAutoPQ(CTvin::Tvin_SourceInputToSourceInputType(SOURCE_MPEG));
1741	mAv.ClearVideoBuffer();
1742	mAv.EnableVideoBlackout();
1743	SetAudioMuteForTv ( CC_AUDIO_UNMUTE );
1744	return 0;
1745	}
1746
1747	const char *CTv::getPqDbPath()
1748	{
1749	return config_get_str(CFG_SECTION_TV, CFG_PQ_DB_PATH, DEF_VALUE_PQ_DB_PATH);
1750	}
1751
1752	int CTv::Tv_MiscSetBySource ( tv_source_input_t source_input )
1753	{
1754	int ret = -1;
1755
1756	switch ( source_input ) {
1757	case SOURCE_TV:
1758	CVpp::getInstance()->VPP_SetScalerPathSel(1);
1759	ret = SetFileAttrValue ( SYS_VECM_DNLP_ADJ_LEVEL, "4" );
1760	break;
1761
1762	case SOURCE_HDMI1:
1763	case SOURCE_HDMI2:
1764	case SOURCE_HDMI3:
1765	CVpp::getInstance()->VPP_SetScalerPathSel(0);
1766	//ret = CVpp::getInstance()->Tv_SavePanoramaMode ( VPP_PANORAMA_MODE_FULL, SOURCE_TYPE_HDMI );
1767	ret |= SetFileAttrValue ( SYS_VECM_DNLP_ADJ_LEVEL, "5" );
1768	break;
1769
1770	case SOURCE_DTV:
1771	CVpp::getInstance()->VPP_SetScalerPathSel(0);
1772
1773	case SOURCE_AV1:
1774	case SOURCE_AV2:
1775	case SOURCE_VGA:
1776	CVpp::getInstance()->VPP_SetScalerPathSel(1);
1777	ret |= SetFileAttrValue ( SYS_VECM_DNLP_ADJ_LEVEL, "5" );
1778	break;
1779
1780	case SOURCE_SVIDEO:
1781	case SOURCE_IPTV:
1782	CVpp::getInstance()->VPP_SetScalerPathSel(1);
1783	default:
1784	CVpp::getInstance()->VPP_SetScalerPathSel(0);
1785	ret |= SetFileAttrValue ( SYS_VECM_DNLP_ADJ_LEVEL, "5" );
1786	break;
1787	}
1788	return ret;
1789	}
1790
1791	int CTv::SetSourceSwitchInput (tv_source_input_t source_input )
1792	{
1793	Mutex::Autolock _l ( mLock );
1794	LOGD ( "%s, source input = %d", __FUNCTION__, source_input );
1795	tv_source_input_t cur_source_input = m_source_input;
1796	tvin_port_t cur_port;
1797
1798	Tv_SetDDDRCMode(source_input);
1799	if (source_input == cur_source_input ) {
1800	LOGW ( "%s,same input change display mode", __FUNCTION__ );
1801	return 0;
1802	}
1803
1804	//if HDMI, need to set EDID of each port
1805	if (mSetHdmiEdid) {
1806	int tmp_ret = 0;
1807	switch ( source_input ) {
1808	case SOURCE_HDMI1:
1809	tmp_ret = SSMSetHDMIEdid(1);
1810	break;
1811	case SOURCE_HDMI2:
1812	tmp_ret = SSMSetHDMIEdid(2);
1813	break;
1814	case SOURCE_HDMI3:
1815	tmp_ret = SSMSetHDMIEdid(3);
1816	break;
1817	default:
1818	tmp_ret = -1;
1819	break;
1820	}
1821	if (tmp_ret < 0)
1822	LOGE ( "%s, do not set hdmi port%d edid.ret=%d", __FUNCTION__, source_input - 4, tmp_ret );
1823	}
1824	mTvAction |= TV_ACTION_SOURCE_SWITCHING;
1825	m_cur_playing_prog_id = -1;
1826	//
1827	SetAudioMuteForTv(CC_AUDIO_MUTE);
1828	mSigDetectThread.requestAndWaitPauseDetect();
1829	//const char *config_value = config_get_str ( CFG_SECTION_TV, CFG_BLUE_SCREEN_COLOR, "null" );
1830	//if ( strcmp ( config_value, "black" ) == 0 ) {
1831	// mAv.DisableVideoWithBlackColor();
1832	//} else {
1833	// mAv.DisableVideoWithBlueColor();
1834	//}
1835	mAv.DisableVideoWithBlackColor();
1836	//enable blackout, when play,disable it
1837	mAv.EnableVideoBlackout();
1838	//set front dev mode
1839	if ( source_input == SOURCE_TV ) {
1840	mFrontDev.Close();
1841	mFrontDev.Open(FE_ANALOG);
1842	mFrontDev.SetAnalogFrontEndTimerSwitch(GetATVSourceTimerSwitch());
1843	//mFrontDev.setMode ( FE_ANALOG );
1844	} else if ( source_input == SOURCE_DTV ) {
1845	mFrontDev.Close();
1846	mFrontDev.Open(FE_ANALOG);
1847	//mFrontDev.setMode ( FE_DTMB);
1848	mFrontDev.SetAnalogFrontEndTimerSwitch(0);
1849	} else {
1850	mFrontDev.Close();
1851	mFrontDev.SetAnalogFrontEndTimerSwitch(0);
1852	}
1853
1854	//ok
1855	m_last_source_input = m_source_input;
1856	m_source_input = source_input;
1857	SSMSaveSourceInput ( source_input );
1858
1859	tv_source_input_t pre_source_input = cur_source_input;//change
1860	cur_source_input = source_input;
1861
1862	SetAudioVolumeCompensationVal ( 0 );
1863
1864	if ( source_input == SOURCE_DTV ) {
1865	//we should stop audio first for audio mute.
1866	SwitchAVOutBypass(0);
1867	tv_audio_channel_e audio_channel = CTvin::getInstance()->Tvin_GetInputSourceAudioChannelIndex (SOURCE_MPEG);
1868	AudioLineInSelectChannel( audio_channel );
1869	AudioCtlUninit();
1870	SetAudioVolDigitLUTTable(SOURCE_MPEG);
1871	//
1872	CTvin::getInstance()->Tvin_StopDecoder();
1873	CTvin::getInstance()->Tvin_RemovePath ( TV_PATH_TYPE_TVIN );
1874	CTvin::getInstance()->VDIN_ClosePort();
1875	//double confirm we set the main volume lut buffer to mpeg
1876	RefreshAudioMasterVolume ( SOURCE_MPEG );
1877	RefreshSrsEffectAndDacGain();
1878	SetCustomEQGain();
1879	CTvin::getInstance()->setMpeg2Vdin(1);
1880	mAv.setLookupPtsForDtmb(1);
1881	//CVpp::getInstance()->LoadVppSettings ( SOURCE_TYPE_DTV, TVIN_SIG_FMT_NULL, INDEX_2D, TVIN_TFMT_2D );
1882	//mAutoPQparam.startAutoPQ(CTvin::Tvin_SourceInputToSourceInputType(SOURCE_DTV));
1883	Tv_SetAudioInSource ( source_input );
1884	} else {
1885	mAutoPQparam.stopAutoPQ();
1886	CTvin::getInstance()->setMpeg2Vdin(0);
1887	mAv.setLookupPtsForDtmb(0);
1888	CTvin::getInstance()->Tvin_AddPath ( TV_PATH_VDIN_NEW3D_WITHOUTPPMGR_AMVIDEO );
1889	}
1890	cur_port = CTvin::getInstance()->Tvin_GetSourcePortBySourceInput ( cur_source_input );
1891	Tv_MiscSetBySource ( source_input );
1892
1893	//only DTV->TVIN or TVIN->DTV need start resource detect thread
1894	if ( ( pre_source_input == SOURCE_DTV || cur_source_input == SOURCE_DTV ) &&
1895	( cur_source_input != pre_source_input ) ) {
1896	LOGD ( "%s, dtv need resource detect\n", __FUNCTION__ );
1897	int isNeedCheckD2D3 = ( gTvinConfig.memory512m) ? 1 : 0;
1898	static int sigchkcnt = 0;
1899	while ( true ) {
1900	if ( ( CTvin::getInstance()->Tvin_CheckPathActive ( TV_PATH_TYPE_DEFAULT, isNeedCheckD2D3 ) == TV_PATH_STATUS_INACTIVE )
1901	&& ( CTvin::getInstance()->Tvin_CheckPathActive ( TV_PATH_TYPE_TVIN, isNeedCheckD2D3 ) == TV_PATH_STATUS_INACTIVE ) ) {
1902	LOGD("%s, path check is ok, and break\n", __FUNCTION__);
1903	break;
1904	} else {
1905	if (sigchkcnt++ > 20) {
1906	sigchkcnt = 0;
1907	break;
1908	}
1909	LOGW ( "%s,resource is busy.", __FUNCTION__);
1910	}
1911	}
1912	}
1913
1914	if ( source_input != SOURCE_DTV ) {
1915	// Uninit data
1916	UnInitTvAudio();
1917	if (source_input == SOURCE_HDMI1 || source_input == SOURCE_HDMI2 || source_input == SOURCE_HDMI3 ||
1918	source_input == SOURCE_MPEG || source_input == SOURCE_DTV ) {
1919	SwitchAVOutBypass(0);
1920	} else {
1921	SwitchAVOutBypass(1);
1922	}
1923
1924	tv_audio_channel_e audio_channel = CTvin::getInstance()->Tvin_GetInputSourceAudioChannelIndex (source_input);
1925	AudioLineInSelectChannel( audio_channel );
1926
1927	Tv_SetAudioInSource ( source_input );
1928	if ( source_input == SOURCE_HDMI1 || source_input == SOURCE_HDMI2 || source_input == SOURCE_HDMI3 ) {
1929	m_hdmi_sampling_rate = 0;
1930	m_hdmi_audio_data = 0;
1931	} else {
1932	InitTvAudio ( 48000, CC_IN_USE_I2S_DEVICE);
1933	HanldeAudioInputSr(-1);
1934	}
1935	//===========================================
1936	if ( CTvin::getInstance()->SwitchPort ( cur_port ) == 0 ) { //ok
1937	//==========================================
1938	unsigned char std;
1939	SSMReadCVBSStd(&std);
1940	int fmt = CFrontEnd::stdEnumToCvbsFmt (std, CC_ATV_AUDIO_STD_AUTO);
1941	CTvin::getInstance()->AFE_SetCVBSStd ( ( tvin_sig_fmt_t ) fmt );
1942
1943	//for HDMI source connect detect
1944	CTvin::getInstance()->VDIN_OpenHDMIPinMuxOn(true);
1945	CVpp::getInstance()->Vpp_ResetLastVppSettingsSourceType();
1946
1947	m_sig_stable_nums = 0;
1948	mSigDetectThread.setObserver ( this );
1949	mSigDetectThread.initSigState();
1950	int resumeLater = 0;
1951	if (source_input == SOURCE_HDMI1 || source_input == SOURCE_HDMI2 || source_input == SOURCE_HDMI3) {
1952	resumeLater = 1000;
1953	} else {
1954	resumeLater = 1500;
1955	}
1956	mSigDetectThread.setVdinNoSigCheckKeepTimes(150, true);
1957	mSigDetectThread.resumeDetect(resumeLater);
1958	}
1959	}
1960
1961	Tv_SetAudioSourceType(source_input);
1962	RefreshAudioMasterVolume(source_input);
1963	Tv_SetAudioOutputSwap_Type(source_input);
1964	//Tv_ADCDigitalCapture_Volume();
1965	Tv_SetAVOutPut_Input_gain(source_input);
1966
1967	mTvAction &= ~ TV_ACTION_SOURCE_SWITCHING;
1968	return 0;
1969	}
1970
1971	void CTv::onSigToStable()
1972	{
1973	if (mAutoSetDisplayFreq) {
1974	int freq = 60;
1975	if (CTvin::Tvin_SourceInputToSourceInputType(m_source_input) == SOURCE_TYPE_HDMI ) {
1976	int fps = getHDMIFrameRate();
1977	LOGD("onSigToStable HDMI fps = %d", fps);
1978	if ((30 == fps) || (60 == fps)) {
1979	freq = 60;
1980	} else {
1981	freq = 50;
1982	}
1983	} else if ( CTvin::Tvin_is50HzFrameRateFmt ( mSigDetectThread.getCurSigInfo().fmt ) ) {
1984	freq = 50;
1985	}
1986
1987	CTvin::getInstance()->VDIN_SetDisplayVFreq ( freq, mAv.getVideoDisplayResolution(), mHdmiOutFbc );
1988	LOGD ( "%s, SetDisplayVFreq %dHZ.", __FUNCTION__, freq);
1989	}
1990	//showbo mark hdmi auto 3d, tran fmt is 3d, so switch to 3d
1991
1992	CVpp::getInstance()->LoadVppSettings (CTvin::Tvin_SourceInputToSourceInputType(m_source_input), mSigDetectThread.getCurSigInfo().fmt, Check2Dor3D(m_mode_3d, mSigDetectThread.getCurSigInfo().trans_fmt ), mSigDetectThread.getCurSigInfo().trans_fmt );
1993
1994	if ( m_win_mode == PREVIEW_WONDOW ) {
1995	mAv.setVideoAxis(m_win_pos.x1, m_win_pos.y1, m_win_pos.x2, m_win_pos.y2);
1996	mAv.setVideoScreenMode ( CAv::VIDEO_WIDEOPTION_FULL_STRETCH );
1997	} else {
1998	SetDisplayMode ( CVpp::getInstance()->GetDisplayMode ( CTvin::Tvin_SourceInputToSourceInputType(m_source_input) ), CTvin::Tvin_SourceInputToSourceInputType(m_source_input), mSigDetectThread.getCurSigInfo().fmt);
1999	}
2000	m_sig_stable_nums = 0;
2001	}
2002
2003	void CTv::onSigStillStable()
2004	{
2005	if ( m_sig_stable_nums == 20) {
2006	tvin_info_t info = mSigDetectThread.getCurSigInfo();
2007	TvEvent::SignalInfoEvent ev;
2008	ev.mTrans_fmt = info.trans_fmt;
2009	ev.mFmt = info.fmt;
2010	ev.mStatus = info.status;
2011	ev.mReserved = getHDMIFrameRate();
2012	sendTvEvent ( ev );
2013	}
2014	if (m_sig_stable_nums == 2) {
2015	LOGD("still stable , to start decoder");
2016	int startdec_status = CTvin::getInstance()->Tvin_StartDecoder ( mSigDetectThread.getCurSigInfo() );
2017	if ( startdec_status == 0 ) { //showboz codes from start decode fun
2018	const char *value = config_get_str ( CFG_SECTION_TV, CFG_TVIN_DB_REG, "null" );
2019	if ( strcmp ( value, "enable" ) == 0 ) {
2020	usleep ( 20 * 1000 );
2021	Tvin_SetPLLValues ();
2022	usleep ( 20 * 1000 );
2023	SetCVD2Values ();
2024	}
2025	}
2026	}
2027	if ( m_sig_stable_nums == 3) {
2028	LOGD("still stable , to unmute audio/video");
2029	CMessage msg;
2030	msg.mDelayMs = 0;
2031	msg.mType = CTvMsgQueue::TV_MSG_ENABLE_VIDEO_LATER;
2032	msg.mpPara[0] = 2;
2033	mTvMsgQueue.sendMsg ( msg );
2034	m_hdmi_audio_data = 0;
2035	}
2036	m_sig_stable_nums++;
2037	}
2038
2039	void CTv::onEnableVideoLater(int framecount)
2040	{
2041	LOGD("onEnableVideoLater framecount = %d", framecount);
2042	mAv.EnableVideoWhenVideoPlaying(2);
2043	if (CTvin::Tvin_SourceInputToSourceInputType(m_source_input) != SOURCE_TYPE_HDMI ) {
2044	SetAudioMuteForTv ( CC_AUDIO_UNMUTE );
2045	Tv_SetAudioInSource(m_source_input);
2046	}
2047	}
2048
2049	void CTv::Tv_SetAVOutPut_Input_gain(tv_source_input_t source_input)
2050	{
2051	int nPgaValueIndex = 0;
2052	int nAdcValueIndex = 0;
2053	int nDdcValueIndex = 0;
2054	int tmpAvoutBufPtr[9];
2055
2056	if (GetAvOutGainBuf_Cfg(tmpAvoutBufPtr) != 0) {
2057	GetDefaultAvOutGainBuf(tmpAvoutBufPtr);
2058	}
2059
2060	switch (source_input) {
2061	case SOURCE_AV1:
2062	case SOURCE_AV2:
2063	nPgaValueIndex = 0;
2064	nAdcValueIndex = 1;
2065	nDdcValueIndex = 2;
2066	break;
2067	case SOURCE_HDMI1:
2068	case SOURCE_HDMI2:
2069	case SOURCE_HDMI3:
2070	case SOURCE_DTV:
2071	case SOURCE_MPEG:
2072	nPgaValueIndex = 3;
2073	nAdcValueIndex = 4;
2074	nDdcValueIndex = 5;
2075	break;
2076	case SOURCE_TV:
2077	nPgaValueIndex = 6;
2078	nAdcValueIndex = 7;
2079	nDdcValueIndex = 8;
2080	break;
2081	default:
2082	break;
2083	}
2084
2085	SetPGA_IN_Value(tmpAvoutBufPtr[nPgaValueIndex]);
2086	SetADC_Digital_Capture_Volume(tmpAvoutBufPtr[nAdcValueIndex]);
2087	SetDAC_Digital_PlayBack_Volume(tmpAvoutBufPtr[nDdcValueIndex]);
2088	}
2089
2090	void CTv::onSigStableToUnstable()
2091	{
2092	LOGD ( "%s, stable to unstable\n", __FUNCTION__);
2093	SetAudioMuteForTv(CC_AUDIO_MUTE);
2094	mAv.DisableVideoWithBlackColor();
2095	CTvin::getInstance()->Tvin_StopDecoder();
2096	}
2097
2098	void CTv::onSigStableToUnSupport()
2099	{
2100	SetAudioMuteForTv(CC_AUDIO_MUTE);
2101	mAv.DisableVideoWithBlackColor();
2102	CTvin::getInstance()->Tvin_StopDecoder();
2103
2104	tvin_info_t info = mSigDetectThread.getCurSigInfo();
2105	TvEvent::SignalInfoEvent ev;
2106	ev.mTrans_fmt = info.trans_fmt;
2107	ev.mFmt = info.fmt;
2108	ev.mStatus = info.status;
2109	ev.mReserved = info.reserved;
2110	sendTvEvent ( ev );
2111	LOGD ( "%s, Enable blackscreen for signal change in StableToUnSupport!", __FUNCTION__ );
2112	}
2113
2114	void CTv::onSigStableToNoSig()
2115	{
2116	SetAudioMuteForTv(CC_AUDIO_MUTE);
2117	const char *value = config_get_str ( CFG_SECTION_TV, CFG_BLUE_SCREEN_COLOR, "null" );
2118	if ( strcmp ( value, "black" ) == 0 ) {
2119	mAv.DisableVideoWithBlackColor();
2120	} else {
2121	mAv.DisableVideoWithBlueColor();
2122	}
2123	//SetAudioMuteForTv(CC_AUDIO_MUTE);
2124	CTvin::getInstance()->Tvin_StopDecoder();
2125
2126	tvin_info_t info = mSigDetectThread.getCurSigInfo();
2127	TvEvent::SignalInfoEvent ev;
2128	ev.mTrans_fmt = info.trans_fmt;
2129	ev.mFmt = info.fmt;
2130	ev.mStatus = info.status;
2131	ev.mReserved = info.reserved;
2132	sendTvEvent ( ev );
2133	LOGD ( "%s, Enable bluescreen for signal change in StableToNoSig!", __FUNCTION__);
2134	}
2135
2136	void CTv::onSigUnStableToUnSupport()
2137	{
2138	mAv.DisableVideoWithBlackColor();
2139	CTvin::getInstance()->Tvin_StopDecoder();
2140	tvin_info_t info = mSigDetectThread.getCurSigInfo();
2141
2142	TvEvent::SignalInfoEvent ev;
2143	ev.mTrans_fmt = info.trans_fmt;
2144	ev.mFmt = info.fmt;
2145	ev.mStatus = info.status;
2146	ev.mReserved = info.reserved;
2147	sendTvEvent ( ev );
2148	LOGD ( "%s, Enable blackscreen for signal change in UnStableToUnSupport!", __FUNCTION__);
2149	}
2150
2151	void CTv::onSigUnStableToNoSig()
2152	{
2153	SetAudioMuteForTv(CC_AUDIO_MUTE);
2154	const char *value = config_get_str ( CFG_SECTION_TV, CFG_BLUE_SCREEN_COLOR, "null" );
2155	if ( strcmp ( value, "black" ) == 0 ) {
2156	mAv.DisableVideoWithBlackColor();
2157	} else {
2158	mAv.DisableVideoWithBlueColor();
2159	//SetAudioMuteForTv(CC_AUDIO_MUTE);
2160	}
2161	CTvin::getInstance()->Tvin_StopDecoder();
2162
2163	tvin_info_t info = mSigDetectThread.getCurSigInfo();
2164	TvEvent::SignalInfoEvent ev;
2165	ev.mTrans_fmt = info.trans_fmt;
2166	ev.mFmt = info.fmt;
2167	ev.mStatus = info.status;
2168	ev.mReserved = info.reserved;
2169	sendTvEvent ( ev );
2170	LOGD ( "%s, Enable bluescreen for signal change in UnStableToNoSig! status = %d", __FUNCTION__, ev.mStatus );
2171	}
2172
2173	void CTv::onSigNullToNoSig()
2174	{
2175	SetAudioMuteForTv(CC_AUDIO_MUTE);
2176	const char *value = config_get_str ( CFG_SECTION_TV, CFG_BLUE_SCREEN_COLOR, "null" );
2177	if ( strcmp ( value, "black" ) == 0 ) {
2178	mAv.DisableVideoWithBlackColor();
2179	} else {
2180	mAv.DisableVideoWithBlueColor();
2181	//SetAudioMuteForTv(CC_AUDIO_MUTE);
2182	}
2183	CTvin::getInstance()->Tvin_StopDecoder();
2184
2185	tvin_info_t info = mSigDetectThread.getCurSigInfo();
2186
2187	TvEvent::SignalInfoEvent ev;
2188	ev.mTrans_fmt = info.trans_fmt;
2189	ev.mFmt = info.fmt;
2190	ev.mStatus = info.status;
2191	ev.mReserved = info.reserved;
2192	sendTvEvent ( ev );
2193	LOGD ( "%s, Enable bluescreen for signal change in NullToNoSig!", __FUNCTION__);
2194	}
2195
2196	void CTv::onSigNoSigToUnstable()
2197	{
2198	const char *value = config_get_str ( CFG_SECTION_TV, CFG_BLUE_SCREEN_COLOR, "null" );
2199	if ( strcmp ( value, "black" ) == 0 ) {
2200	mAv.DisableVideoWithBlackColor();
2201	} else {
2202	mAv.DisableVideoWithBlueColor();
2203	}
2204	LOGD("Enable bluescreen for signal change in NoSigToUnstable\n");
2205	}
2206
2207	void CTv::onSigStillUnstable()
2208	{
2209	}
2210
2211	void CTv::onSigStillNosig()
2212	{
2213	}
2214
2215	void CTv::onSigStillNoSupport()
2216	{
2217	LOGD ( "%s, gxtvbb, don't send event when sitll not support", __FUNCTION__);
2218	/*
2219	tvin_info_t info = mSigDetectThread.getCurSigInfo();
2220	TvEvent::SignalInfoEvent SigEv;
2221	SigEv.mTrans_fmt = info.trans_fmt;
2222	SigEv.mFmt = info.fmt;
2223	SigEv.mStatus = info.status;
2224	SigEv.mReserved = info.reserved;
2225	sendTvEvent ( SigEv );
2226	LOGD ( "%s, Unsupport signal", __FUNCTION__);
2227	*/
2228	}
2229
2230	void CTv::onSigStillNull()
2231	{
2232	}
2233
2234	void CTv::onStableSigFmtChange()
2235	{
2236	if ( mAutoSetDisplayFreq) {
2237	if (CTvin::Tvin_SourceInputToSourceInputType(m_source_input) == SOURCE_TYPE_HDMI ) {
2238	int fps = getHDMIFrameRate();
2239	LOGD("onSigToStable HDMI fps get = %d", fps);
2240	}
2241	int freq = 60;
2242	if ( CTvin::Tvin_is50HzFrameRateFmt ( mSigDetectThread.getCurSigInfo().fmt ) ) {
2243	freq = 50;
2244	}
2245
2246	CTvin::getInstance()->VDIN_SetDisplayVFreq ( freq, mAv.getVideoDisplayResolution(), mHdmiOutFbc );
2247	LOGD ( "%s, SetDisplayVFreq %dHZ.", __FUNCTION__, freq);
2248	}
2249	//showbo mark hdmi auto 3d, tran fmt is 3d, so switch to 3d
2250	LOGD("hdmi trans_fmt = %d", mSigDetectThread.getCurSigInfo().trans_fmt);
2251
2252	//load pq parameters
2253	CVpp::getInstance()->LoadVppSettings (CTvin::Tvin_SourceInputToSourceInputType(m_source_input), mSigDetectThread.getCurSigInfo().fmt, Check2Dor3D(m_mode_3d, mSigDetectThread.getCurSigInfo().trans_fmt ), mSigDetectThread.getCurSigInfo().trans_fmt );
2254
2255	if ( m_win_mode == PREVIEW_WONDOW ) {
2256	mAv.setVideoAxis(m_win_pos.x1, m_win_pos.y1, m_win_pos.x2, m_win_pos.y2);
2257	mAv.setVideoScreenMode ( CAv::VIDEO_WIDEOPTION_FULL_STRETCH );
2258	} else {
2259	SetDisplayMode ( CVpp::getInstance()->GetDisplayMode ( CTvin::Tvin_SourceInputToSourceInputType(m_source_input) ), CTvin::Tvin_SourceInputToSourceInputType(m_source_input), mSigDetectThread.getCurSigInfo().fmt);
2260	}
2261	}
2262
2263	void CTv::onStableTransFmtChange()
2264	{
2265	LOGD("onStableTransFmtChange trans_fmt = %d", mSigDetectThread.getCurSigInfo().trans_fmt);
2266	}
2267
2268	void CTv::onSigDetectEnter()
2269	{
2270	}
2271
2272	void CTv::onSigDetectLoop()
2273	{
2274	if (( CTvin::Tvin_SourceInputToSourceInputType(m_source_input) == SOURCE_TYPE_HDMI ) ) {
2275	int sr = CTvin::getInstance()->get_hdmi_sampling_rate();
2276	if ( ( sr > 0 ) && ( sr != m_hdmi_sampling_rate ) ) {
2277	LOGD("HDMI SR CHANGED");
2278	CMessage msg;
2279	msg.mDelayMs = 0;
2280	msg.mType = CTvMsgQueue::TV_MSG_HDMI_SR_CHANGED;
2281	((int *)(msg.mpPara))[0] = sr;
2282	((int *)(msg.mpPara))[1] = m_hdmi_sampling_rate;
2283	mTvMsgQueue.sendMsg ( msg );
2284	m_hdmi_sampling_rate = sr;
2285	}
2286
2287	//m_hdmi_audio_data init is 0, not audio data , when switch to HDMI
2288	int hdmi_audio_data = CTvin::getInstance()->TvinApi_GetHDMIAudioStatus();
2289	if (hdmi_audio_data != m_hdmi_audio_data) {
2290	LOGD("HDMI auds_rcv_sts CHANGED = %d", hdmi_audio_data);
2291	m_hdmi_audio_data = hdmi_audio_data;
2292	onHMDIAudioStatusChanged(hdmi_audio_data);
2293	}
2294	}
2295	}
2296
2297	CTv::CTvDetectObserverForScanner::CTvDetectObserverForScanner(CTv *pTv)
2298	{
2299	mpTv = pTv;
2300	m_sig_stable_nums = 0;
2301	}
2302
2303	void CTv::CTvDetectObserverForScanner::onSigStableToUnstable()
2304	{
2305	LOGD ( "%s, stable to unstable\n", __FUNCTION__);
2306	mpTv->SetAudioMuteForTv(CC_AUDIO_MUTE);
2307	mpTv->SetAudioMuteForTv(CC_AUDIO_MUTE);
2308	const char *value = config_get_str ( CFG_SECTION_TV, CFG_BLUE_SCREEN_COLOR, "null" );
2309	if ( strcmp ( value, "black" ) == 0 ) {
2310	mpTv->mAv.DisableVideoWithBlackColor();
2311	} else {
2312	mpTv->mAv.DisableVideoWithBlueColor();
2313	}
2314	CTvin::getInstance()->Tvin_StopDecoder();
2315	}
2316
2317	void CTv::CTvDetectObserverForScanner::onSigUnStableToNoSig()
2318	{
2319	mpTv->SetAudioMuteForTv(CC_AUDIO_MUTE);
2320	const char *value = config_get_str ( CFG_SECTION_TV, CFG_BLUE_SCREEN_COLOR, "null" );
2321	if ( strcmp ( value, "black" ) == 0 ) {
2322	mpTv->mAv.DisableVideoWithBlackColor();
2323	} else {
2324	mpTv->mAv.DisableVideoWithBlueColor();
2325	}
2326	CTvin::getInstance()->Tvin_StopDecoder();
2327	}
2328
2329	void CTv::CTvDetectObserverForScanner::onSigStableToNoSig()
2330	{
2331	mpTv->SetAudioMuteForTv(CC_AUDIO_MUTE);
2332	const char *value = config_get_str ( CFG_SECTION_TV, CFG_BLUE_SCREEN_COLOR, "null" );
2333	if ( strcmp ( value, "black" ) == 0 ) {
2334	mpTv->mAv.DisableVideoWithBlackColor();
2335	} else {
2336	mpTv->mAv.DisableVideoWithBlueColor();
2337	}
2338	CTvin::getInstance()->Tvin_StopDecoder();
2339	LOGD ( "%s, Enable bluescreen for signal change in StableToNoSig!", __FUNCTION__);
2340	}
2341
2342	void CTv::CTvDetectObserverForScanner::onSigToStable()
2343	{
2344	mpTv->mAv.setVideoScreenMode ( CAv::VIDEO_WIDEOPTION_16_9 );
2345	m_sig_stable_nums = 0;
2346	}
2347
2348	void CTv::CTvDetectObserverForScanner::onSigStillStable()
2349	{
2350	if (m_sig_stable_nums == 1) {
2351	LOGD("%s still stable , to start decoder", __FUNCTION__);
2352	int startdec_status = CTvin::getInstance()->Tvin_StartDecoder (mpTv->mSigDetectThread.getCurSigInfo() );
2353	if ( startdec_status == 0 ) {
2354	const char *value = config_get_str ( CFG_SECTION_TV, CFG_TVIN_DB_REG, "null" );
2355	if ( strcmp ( value, "enable" ) == 0 ) {
2356	usleep ( 20 * 1000 );
2357	mpTv->Tvin_SetPLLValues ();
2358	usleep ( 20 * 1000 );
2359	mpTv->SetCVD2Values ();
2360	}
2361	}
2362	}
2363	if ( m_sig_stable_nums == 10 ) {
2364	mpTv->mAv.EnableVideoWhenVideoPlaying();
2365	}
2366	m_sig_stable_nums++;
2367	}
2368
2369	void CTv::onSourceConnect(int source_type, int connect_status)
2370	{
2371	TvEvent::SourceConnectEvent ev;
2372	ev.mSourceInput = source_type;
2373	ev.connectionState = connect_status;
2374	sendTvEvent(ev);
2375	}
2376
2377	void CTv::onVframeSizeChange()
2378	{
2379	if (m_source_input == SOURCE_DTV) {
2380	CVpp::getInstance()->LoadVppSettings ( SOURCE_TYPE_DTV, mAv.getVideoResolutionToFmt(), INDEX_2D, TVIN_TFMT_2D );
2381	} else if (m_source_input == SOURCE_INVALID) {
2382	CVpp::getInstance()->LoadVppSettings ( SOURCE_TYPE_MPEG, mAv.getVideoResolutionToFmt(), INDEX_2D, TVIN_TFMT_2D );
2383	}
2384	}
2385
2386	int CTv::GetSourceConnectStatus(tv_source_input_t source_input)
2387	{
2388	return mSourceConnectDetectThread.GetSourceConnectStatus((tv_source_input_t)source_input);
2389	}
2390
2391	tv_source_input_t CTv::GetCurrentSourceInputLock ( void )
2392	{
2393	Mutex::Autolock _l ( mLock );
2394	return m_source_input;
2395	}
2396
2397	//dtv and tvin
2398	tvin_info_t CTv::GetCurrentSignalInfo ( void )
2399	{
2400	tvin_trans_fmt det_fmt = TVIN_TFMT_2D;
2401	tvin_sig_status_t signalState = TVIN_SIG_STATUS_NULL;
2402	tvin_info_t signal_info = mSigDetectThread.getCurSigInfo();
2403
2404	int feState = mFrontDev.getStatus();
2405	if ( (CTvin::Tvin_SourceInputToSourceInputType(m_source_input) == SOURCE_TYPE_DTV ) ) {
2406	det_fmt = CTvin::getInstance()->TvinApi_Get3DDectMode();
2407	if ((feState & FE_HAS_LOCK) == FE_HAS_LOCK) {
2408	signal_info.status = TVIN_SIG_STATUS_STABLE;
2409	} else if ((feState & FE_TIMEDOUT) == FE_TIMEDOUT) {
2410	signal_info.status = TVIN_SIG_STATUS_NOSIG;
2411	}
2412	if ( det_fmt != TVIN_TFMT_2D ) {
2413	signal_info.trans_fmt = det_fmt;
2414	}
2415	signal_info.fmt = mAv.getVideoResolutionToFmt();
2416	}
2417	return signal_info;
2418	}
2419
2420	int CTv::Tv_GetHistgram(int *histgram_buf)
2421	{
2422	if (histgram_buf == NULL) {
2423	return -1;
2424	}
2425	return CTvin::getInstance()->VDIN_GetHistgram(histgram_buf);
2426	}
2427
2428	int CTv::Tv_Set3DMode ( VIDEO_3D_MODE_T mode )
2429	{
2430	if (mode == VIDEO_3D_MODE_AUTO) {
2431	CTvin::getInstance()->VDIN_SetDI3DDetc (1);
2432	} else {
2433	CTvin::getInstance()->VDIN_SetDI3DDetc (0);
2434	}
2435
2436	mAv.set3DMode(mode, 0, 0);
2437	m_mode_3d = mode;
2438	SSMSave3DMode ( ( unsigned char ) mode );
2439	return 0;
2440	}
2441
2442	VIDEO_3D_MODE_T CTv::Tv_Get3DMode ( void )
2443	{
2444	return m_mode_3d;
2445	}
2446
2447	int CTv::Tv_Set3DLRSwith ( int on_off)
2448	{
2449	LOGW ( "%s,Set3D LRSwith on_off %d", __FUNCTION__, on_off);
2450	mAv.set3DMode(m_mode_3d, on_off, 0);
2451	SSMSave3DLRSwitch(on_off);
2452	return 0;
2453	}
2454
2455	int CTv::Tv_Get3DLRSwith ( void )
2456	{
2457	unsigned char val = 0;
2458	SSMRead3DLRSwitch ( &val );
2459	return ( int ) val;
2460	}
2461
2462	int CTv::Tv_Set3DTo2DMode ( int mode)
2463	{
2464	LOGW ( "%s,Set3D to 2D mode %d", __FUNCTION__ , mode);
2465	mAv.set3DMode(m_mode_3d, 0, mode);
2466	SSMSave3DTO2D ( mode );
2467	return 0;
2468	}
2469
2470	int CTv::Tv_Get3DTo2DMode ( void )
2471	{
2472	unsigned char val = 0;
2473	SSMRead3DTO2D ( &val );
2474	return val;
2475	}
2476
2477	int CTv::Tv_Set3DDepth ( int value )
2478	{
2479	CTvin::getInstance()->Tvin_SetDepthOf2Dto3D( value );
2480	SSMSave3DDepth ( value );
2481	return 0;
2482	}
2483
2484	int CTv::GetSave3DDepth ( void )
2485	{
2486	unsigned char val = 0;
2487	SSMRead3DDepth ( &val );
2488	return val;
2489	}
2490
2491	is_3d_type_t CTv::Check2Dor3D ( VIDEO_3D_MODE_T mode3d, tvin_trans_fmt_t trans_fmt )
2492	{
2493	if ( mode3d == VIDEO_3D_MODE_DISABLE ) {
2494	return INDEX_2D;
2495	} else if ( mode3d == VIDEO_3D_MODE_AUTO ) {
2496	if ( trans_fmt == TVIN_TFMT_2D ) {
2497	return INDEX_2D;
2498	} else {
2499	return INDEX_3D;
2500	}
2501	} else {
2502	return INDEX_3D;
2503	}
2504	}
2505
2506	int CTv::Tvin_SetPLLValues ()
2507	{
2508	tvin_sig_fmt_t sig_fmt = mSigDetectThread.getCurSigInfo().fmt;
2509	tvin_port_t source_port = CTvin::Tvin_GetSourcePortBySourceInput(m_source_input);
2510	am_regs_t regs;
2511
2512	if ( CVpp::getInstance()->getPqData()->PQ_GetPLLParams ( source_port, sig_fmt, &regs ) == 0 ) {
2513	LOGD ("%s,PQ_GetPLLParams(source_port[%d], sig_fmt[%d],&regs).\n", __FUNCTION__, source_port, sig_fmt );
2514
2515	if ( CTvin::getInstance()->TvinApi_LoadPLLValues ( regs ) < 0 ) {
2516	LOGE ( "%s, TvinApi_LoadPLLValues failed!\n", __FUNCTION__ );
2517	return -1;
2518	}
2519	} else {
2520	LOGE ( "%s, PQ_GetPLLParams failed!\n", __FUNCTION__ );
2521	return -1;
2522	}
2523
2524	return 0;
2525	}
2526
2527	int CTv::SetCVD2Values ()
2528	{
2529	tvin_sig_fmt_t sig_fmt = mSigDetectThread.getCurSigInfo().fmt;
2530	tvin_port_t source_port = CTvin::Tvin_GetSourcePortBySourceInput(m_source_input);
2531	am_regs_t regs;
2532
2533	if (CVpp::getInstance()->getPqData()->PQ_GetCVD2Params ( source_port, sig_fmt, &regs ) == 0) {
2534	LOGD ( "%s, PQ_GetCVD2Params(source_port[%d], sig_fmt[%d],&regs).\n", __FUNCTION__,
2535	source_port, sig_fmt );
2536
2537	if ( CTvin::getInstance()->TvinApi_LoadCVD2Values ( regs ) < 0 ) {
2538	LOGE ( "%s, TvinApi_LoadCVD2Values failed!\n", __FUNCTION__);
2539	return -1;
2540	}
2541	} else {
2542	LOGE ( "%s, PQ_GetCVD2Params failed!\n", __FUNCTION__);
2543	return -1;
2544	}
2545
2546	return 0;
2547	}
2548
2549	int CTv::SetPreviewWindow ( tvin_window_pos_t pos )
2550	{
2551	m_win_pos.x1 = pos.x1;
2552	m_win_pos.y1 = pos.y1;
2553	m_win_pos.x2 = pos.x2;
2554	m_win_pos.y2 = pos.y2;
2555	LOGD ( "%s, SetPreviewWindow x = %d y=%d", __FUNCTION__, pos.x2, pos.y2 );
2556
2557	tvin_window_pos_t def_pos;
2558	Vpp_GetDisplayResolutionInfo(&def_pos);
2559
2560	if (pos.x1 != 0 || pos.y1 != 0 || pos.x2 != def_pos.x2 || pos.y2 != def_pos.y2) {
2561	m_win_mode = PREVIEW_WONDOW;
2562	} else {
2563	m_win_mode = NORMAL_WONDOW;
2564	}
2565
2566	return mAv.setVideoAxis(m_win_pos.x1, m_win_pos.y1, m_win_pos.x2, m_win_pos.y2);
2567	}
2568
2569	/*********************** Audio start **********************/
2570	int CTv::SetAudioVolDigitLUTTable ( tv_source_input_t source_input )
2571	{
2572	int tmpDefDigitLutBuf[CC_LUT_BUF_SIZE] = { 0 };
2573	int lut_table_index = 0;
2574	if (source_input == SOURCE_TV) {
2575	lut_table_index = CC_GET_LUT_TV;
2576	} else if (source_input == SOURCE_AV1 || source_input == SOURCE_AV2) {
2577	lut_table_index = CC_GET_LUT_AV;
2578	} else if (source_input == SOURCE_YPBPR1 || source_input == SOURCE_YPBPR2) {
2579	lut_table_index = CC_GET_LUT_COMP;
2580	} else if (source_input == SOURCE_VGA) {
2581	lut_table_index = CC_GET_LUT_VGA;
2582	} else if (source_input == SOURCE_HDMI1 || source_input == SOURCE_HDMI2 || source_input == SOURCE_HDMI3) {
2583	lut_table_index = CC_GET_LUT_HDMI;
2584	} else if ( source_input == SOURCE_MPEG ) {
2585	lut_table_index = CC_GET_LUT_MPEG;
2586	} else if ( source_input == SOURCE_DTV ) {
2587	lut_table_index = CC_GET_LUT_MPEG;
2588	} else if ( source_input == SOURCE_MAX) {
2589	return 0;
2590	}
2591	char MainVolLutTableName[128];
2592	const char *baseName = GetAudioAmpMainvolTableBaseName(lut_table_index);
2593	strcpy(MainVolLutTableName, baseName);
2594	const char *dName = ".";
2595	strcat(MainVolLutTableName, dName);
2596	strcat(MainVolLutTableName, GetMainVolLutTableExtraName());
2597	if ( GetAudioAmpMainvolBuf(MainVolLutTableName, tmpDefDigitLutBuf) == 0) {
2598	AudioSetVolumeDigitLUTBuf ( lut_table_index, tmpDefDigitLutBuf);
2599	}
2600	return 0;
2601	}
2602
2603	void CTv::RefreshAudioMasterVolume ( tv_source_input_t source_input )
2604	{
2605	if (source_input == SOURCE_HDMI1 || source_input == SOURCE_HDMI2 || source_input == SOURCE_HDMI3) {
2606	if ( GetAudioDVISupportEnable() == 1 ) {
2607	if ( IsDVISignal() ) {
2608	SetAudioVolDigitLUTTable ( SOURCE_MPEG );
2609	SetAudioMasterVolume ( GetAudioMasterVolume() );
2610	return;
2611	}
2612	}
2613	}
2614
2615	SetAudioVolDigitLUTTable ( source_input );
2616	SetAudioMasterVolume ( GetAudioMasterVolume() );
2617	}
2618
2619	int CTv::Tv_SetAudioInSource (tv_source_input_t source_input)
2620	{
2621	int vol = 255;
2622	if (source_input == SOURCE_TV) {
2623	if (CTvin::getInstance()->Tvin_GetAudioInSourceType(source_input) == TV_AUDIO_IN_SOURCE_TYPE_ATV) {
2624	AudioSetAudioInSource(CC_AUDIO_IN_SOURCE_ATV);
2625	vol = GetAudioInternalDACDigitalPlayBackVolume_Cfg(CC_AUDIO_IN_SOURCE_ATV);
2626	LOGD("%s, atv DAC_Digital_PlayBack_Volume = %d\n", __FUNCTION__, vol);
2627	} else {
2628	LOGD("%s, dtv DAC_Digital_PlayBack_Volume = %d\n", __FUNCTION__, vol);
2629	AudioSetAudioInSource(CC_AUDIO_IN_SOURCE_LINEIN);
2630	vol = GetAudioInternalDACDigitalPlayBackVolume_Cfg(CC_AUDIO_IN_SOURCE_LINEIN);
2631	}
2632	} else if (source_input == SOURCE_AV1 || source_input == SOURCE_AV2) {
2633	AudioSetAudioInSource(CC_AUDIO_IN_SOURCE_LINEIN);
2634	vol = GetAudioInternalDACDigitalPlayBackVolume_Cfg(CC_AUDIO_IN_SOURCE_LINEIN);
2635	} else if (source_input == SOURCE_HDMI1 || source_input == SOURCE_HDMI2 || source_input == SOURCE_HDMI3) {
2636	AudioSetAudioInSource(CC_AUDIO_IN_SOURCE_HDMI);
2637	vol = GetAudioInternalDACDigitalPlayBackVolume_Cfg(CC_AUDIO_IN_SOURCE_HDMI);
2638	} else if (source_input == SOURCE_YPBPR1 || source_input == SOURCE_YPBPR2 ||
2639	source_input == SOURCE_VGA) {
2640	AudioSetAudioInSource(CC_AUDIO_IN_SOURCE_LINEIN);
2641	vol = GetAudioInternalDACDigitalPlayBackVolume_Cfg(CC_AUDIO_IN_SOURCE_LINEIN);
2642	} else if (source_input == SOURCE_MPEG) {
2643	AudioSetAudioInSource(CC_AUDIO_IN_SOURCE_HDMI);
2644	vol = GetAudioInternalDACDigitalPlayBackVolume_Cfg(CC_AUDIO_IN_SOURCE_HDMI);
2645	} else if (source_input == SOURCE_DTV) {
2646	AudioSetAudioInSource(CC_AUDIO_IN_SOURCE_HDMI);
2647	vol = GetAudioInternalDACDigitalPlayBackVolume_Cfg(CC_AUDIO_IN_SOURCE_HDMI);
2648	LOGD("%s, dtv DAC_Digital_PlayBack_Volume = %d\n", __FUNCTION__, vol);
2649	}
2650	LOGD("%s, we have read SetDAC_Digital_PlayBack_Volume = %d\n", __FUNCTION__, vol);
2651
2652	return 0;
2653	}
2654
2655	int CTv::Tv_SetAudioSourceType (tv_source_input_t source_input)
2656	{
2657	int audio_source = -1;
2658
2659	if (source_input == SOURCE_TV) {
2660	audio_source = AUDIO_ATV_SOURCE;
2661	} else if (source_input == SOURCE_AV1 || source_input == SOURCE_AV2) {
2662	audio_source = AUDIO_AV_SOURCE;
2663	} else if (source_input == SOURCE_HDMI1 || source_input == SOURCE_HDMI2 ||
2664	source_input == SOURCE_HDMI3) {
2665	audio_source = AUDIO_HDMI_SOURCE;
2666	} else if (source_input == SOURCE_YPBPR1 || source_input == SOURCE_YPBPR2 ||
2667	source_input == SOURCE_VGA) {
2668	audio_source = AUDIO_AV_SOURCE;
2669	} else if (source_input == SOURCE_DTV) {
2670	audio_source = AUDIO_MPEG_SOURCE;
2671	} else {
2672	audio_source = AUDIO_MPEG_SOURCE;
2673	}
2674
2675	return AudioSetAudioSourceType(audio_source);
2676	}
2677
2678	void CTv::Tv_SetAudioOutputSwap_Type (tv_source_input_t source_input)
2679	{
2680	int sw_status = GetAudioOutputSwapStatus(source_input);
2681	SetOutput_Swap(sw_status);
2682	}
2683
2684	void CTv::Tv_ADCDigitalCapture_Volume (void)
2685	{
2686	int capture_vol = GetADCDigitalCaptureVol_Cfg();
2687	LOGD("%s, we have read ADCDigitalCaptureVol_Config = %d \n", __FUNCTION__, capture_vol);
2688	SetADC_Digital_Capture_Volume(capture_vol);
2689	}
2690
2691	void CTv::Tv_SetPGAIn_Gain (void)
2692	{
2693	int gain_val = GetAudioInternalDacPGAInGain_Cfg();
2694	LOGD("%s, we have read ADCDigitalCaptureVol_Config = %d \n", __FUNCTION__, gain_val);
2695	SetPGA_IN_Value(gain_val);
2696	}
2697
2698	void CTv::Tv_SetDACDigitalPlayBack_Volume (int audio_src_in_type)
2699	{
2700	int vol = GetAudioInternalDACDigitalPlayBackVolume_Cfg(audio_src_in_type);
2701	LOGD("%s, we have read DACDigitalPlayBackVolume config = %d \n", __FUNCTION__, vol);
2702	SetDAC_Digital_PlayBack_Volume(vol);
2703	}
2704	/*********************** Audio end **********************/
2705
2706	unsigned int CTv::Vpp_GetDisplayResolutionInfo(tvin_window_pos_t *win_pos)
2707	{
2708	int display_resolution = mAv.getVideoDisplayResolution();
2709	int width = 0, height = 0;
2710	switch (display_resolution) {
2711	case VPP_DISPLAY_RESOLUTION_1366X768:
2712	width = CC_RESOLUTION_1366X768_W;
2713	height = CC_RESOLUTION_1366X768_H;
2714	break;
2715	case VPP_DISPLAY_RESOLUTION_1920X1080:
2716	width = CC_RESOLUTION_1920X1080_W;
2717	height = CC_RESOLUTION_1920X1080_H;
2718	break;
2719	case VPP_DISPLAY_RESOLUTION_3840X2160:
2720	width = CC_RESOLUTION_3840X2160_W;
2721	height = CC_RESOLUTION_3840X2160_H;
2722	break;
2723	default:
2724	width = CC_RESOLUTION_3840X2160_W;
2725	height = CC_RESOLUTION_3840X2160_H;
2726	break;
2727	}
2728
2729	if (win_pos != NULL) {
2730	win_pos->x1 = 0;
2731	win_pos->y1 = 0;
2732	win_pos->x2 = width - 1;
2733	win_pos->y2 = height - 1;
2734	}
2735	return 0;
2736	}
2737
2738	int CTv::setBlackoutEnable(int enable)
2739	{
2740	m_blackout_enable = enable;
2741	return SSMSaveBlackoutEnable(enable);
2742	}
2743
2744	int CTv::getSaveBlackoutEnable()
2745	{
2746	int8_t enable;
2747	SSMReadBlackoutEnable(&enable);
2748	return enable;
2749	}
2750
2751	void CTv::startAutoBackLight()
2752	{
2753	if (mHdmiOutFbc) {
2754	Tv_FactorySet_FBC_Auto_Backlight_OnOff(1);
2755	} else {
2756	mAutoBackLight.startAutoBacklight(CTvin::Tvin_SourceInputToSourceInputType(m_source_input));
2757	}
2758	}
2759
2760	void CTv::stopAutoBackLight()
2761	{
2762	if (mHdmiOutFbc) {
2763	Tv_FactorySet_FBC_Auto_Backlight_OnOff(0);
2764	} else {
2765	mAutoBackLight.stopAutoBacklight();
2766	}
2767	}
2768
2769	int CTv::getAutoBackLight_on_off()
2770	{
2771	if (mHdmiOutFbc) {
2772	return Tv_FactoryGet_FBC_Auto_Backlight_OnOff();
2773	} else {
2774	return mAutoBackLight.isAutoBacklightOn() ? 1 : 0;
2775	}
2776	}
2777
2778	int CTv::getAverageLuma()
2779	{
2780	return CTvin::getInstance()->VDIN_Get_avg_luma();
2781	}
2782
2783	int CTv::setAutobacklightData(const char *value)
2784	{
2785	const char *KEY = "haier.autobacklight.mp.data";
2786
2787	const char *keyValue = config_get_str(CFG_SECTION_TV, KEY, "null");
2788	if (strcmp(keyValue, value) != 0) {
2789	config_set_str(CFG_SECTION_TV, KEY, value);
2790	LOGD("%s, config string now set as: %s \n", __FUNCTION__, keyValue);
2791	} else {
2792	LOGD("%s, config string has been set as: %s \n", __FUNCTION__, keyValue);
2793	}
2794	return 0;
2795	}
2796
2797	int CTv::getAutoBacklightData(int *data)
2798	{
2799	char datas[512] = {0};
2800	char delims[] = ",";
2801	char *result = NULL;
2802	const char *KEY = "haier.autobacklight.mp.data";
2803	int i = 0;
2804
2805	if (NULL == data) {
2806	LOGD("%s, data is null", __FUNCTION__);
2807	return -1;
2808	}
2809
2810	const char *keyValue = config_get_str(CFG_SECTION_TV, KEY, (char *) "null");
2811	if (strcmp(keyValue, "null") == 0) {
2812	LOGD("%s, value is NULL\n", __FUNCTION__);
2813	return -1;
2814	}
2815
2816	strncpy(datas, keyValue, sizeof(datas) - 1);
2817	result = strtok( datas, delims );
2818	while ( result != NULL ) {
2819	char *pd = strstr(result, ":");
2820	if (pd != NULL) {
2821	data[i] = strtol(pd + 1, NULL, 10 );
2822	i++;
2823	}
2824	result = strtok( NULL, delims );
2825	}
2826	return i;
2827	}
2828
2829	/*********************** SSM start **********************/
2830	int CTv::Tv_SSMRestoreDefaultSetting()
2831	{
2832	SSMRestoreDeviceMarkValues();
2833	AudioSSMRestoreDefaultSetting();
2834	CVpp::getInstance()->VPPSSMRestoreDefault();
2835	MiscSSMRestoreDefault();
2836	ReservedSSMRestoreDefault();
2837	SSMSaveCVBSStd ( 0 );
2838	SSMSaveLastSelectSourceInput ( SOURCE_TV );
2839	SSMSavePanelType ( 0 );
2840	//tvconfig default
2841	saveDTVProgramID ( -1 );
2842	saveATVProgramID ( -1 );
2843	SSMSaveStandbyMode( 0 );
2844	return 0;
2845	}
2846
2847	int CTv::clearDbAllProgramInfoTable()
2848	{
2849	return CTvDatabase::GetTvDb()->clearDbAllProgramInfoTable();
2850	}
2851
2852	int CTv::Tv_SSMFacRestoreDefaultSetting()
2853	{
2854	CVpp::getInstance()->VPPSSMFacRestoreDefault();
2855	AudioSSMRestoreDefaultSetting();
2856	MiscSSMFacRestoreDefault();
2857	return 0;
2858	}
2859	/*********************** SSM End **********************/
2860
2861	//not in CTv, not use lock
2862	void CTv::setSourceSwitchAndPlay()
2863	{
2864	int progID = 0;
2865	CTvProgram prog;
2866	LOGD ( "%s\n", __FUNCTION__ );
2867	static const int POWERON_SOURCE_TYPE_NONE = 0;//not play source
2868	static const int POWERON_SOURCE_TYPE_LAST = 1;//play last save source
2869	static const int POWERON_SOURCE_TYPE_SETTING = 2;//play ui set source
2870	int to_play_source = -1;
2871	int powerup_type = SSMReadPowerOnOffChannel();
2872	LOGD("read power on source type = %d", powerup_type);
2873	if (powerup_type == POWERON_SOURCE_TYPE_NONE) {
2874	return ;
2875	} else if (powerup_type == POWERON_SOURCE_TYPE_LAST) {
2876	to_play_source = SSMReadSourceInput();
2877	} else if (powerup_type == POWERON_SOURCE_TYPE_SETTING) {
2878	to_play_source = SSMReadLastSelectSourceInput();
2879	}
2880	SetSourceSwitchInput (( tv_source_input_t ) to_play_source );
2881	if ( to_play_source == SOURCE_TV ) {
2882	progID = getATVProgramID();
2883	} else if ( to_play_source == SOURCE_DTV ) {
2884	progID = getDTVProgramID();
2885	}
2886	playProgramLock(progID);
2887	}
2888
2889	int CTv::startCC(int country, int src, int channel, int service)
2890	{
2891	//turn_on_cc = true;
2892	return mSubtitle.sub_start_atsc_cc((enum cc_param_country)country, (enum cc_param_source_type)src, channel, (enum cc_param_caption_type)service);
2893	}
2894
2895	int CTv::stopCC()
2896	{
2897	//because cc,vchip data both come from vbi thread , here judge cc, vchip is whether both turn off
2898	/*turn_on_cc = false;
2899	if (config_get_int(CFG_SECTION_TV,"tv.vchip.enable", 0))
2900	{
2901	return 0; //at ATV if vchip is on, turn off CC, just set flag not display CC, but vchip still running
2902	}*/
2903	return mSubtitle.sub_stop_atsc_cc();
2904	}
2905
2906	void CTv::printDebugInfo()
2907	{
2908	print_version_info();
2909	LOGD("%s, TvAction = %x", __FUNCTION__, mTvAction);
2910	LOGD("%s, TvRunStatus = %d", __FUNCTION__, mTvStatus);
2911	LOGD("%s, TvCurSourceInput = %d", __FUNCTION__, m_source_input);
2912	LOGD("%s, TvLastSourceInput = %d", __FUNCTION__, m_last_source_input);
2913	}
2914	//==============vchip end================================
2915
2916	//----------------DVR API============================
2917	void CTv::SetRecordFileName ( char *name )
2918	{
2919	mTvRec.SetRecordFileName (name);
2920	}
2921
2922	void CTv::StartToRecord()
2923	{
2924	int progID = getDTVProgramID();
2925	mTvRec.StartRecord ( progID );
2926	}
2927
2928	void CTv::StopRecording()
2929	{
2930	mTvRec.StopRecord();
2931	}
2932
2933	void CTv::SetRecCurTsOrCurProgram ( int sel )
2934	{
2935	mTvRec.SetRecCurTsOrCurProgram ( sel );
2936	}
2937
2938	int CTv::GetDisplayResolutionConfig()
2939	{
2940	return mAv.getVideoDisplayResolution();
2941	}
2942
2943	int CTv::GetDisplayResolutionInfo()
2944	{
2945	return Vpp_GetDisplayResolutionInfo(NULL);
2946	}
2947
2948	void CTv::onHDMIRxCECMessage(int msg_len, unsigned char msg_buf[])
2949	{
2950	TvEvent::HDMIRxCECEvent ev;
2951
2952	int bufLen = sizeof(ev.mDataBuf) / sizeof(ev.mDataBuf[0]);
2953	if (msg_len > bufLen) {
2954	LOGE("%s, message len(%d) > buffer len(%d)", __FUNCTION__, msg_len, bufLen);
2955	return;
2956	}
2957
2958	ev.mDataCount = msg_len;
2959	for (int i = 0; i < msg_len; i++) {
2960	ev.mDataBuf[i] = msg_buf[i];
2961	}
2962	sendTvEvent(ev);
2963	}
2964
2965	int CTv::SendHDMIRxCECCustomMessage(unsigned char data_buf[])
2966	{
2967	return mHDMIRxCEC.SendCustomMessage(m_source_input, data_buf);
2968	}
2969
2970	int CTv::SendHDMIRxCECCustomMessageAndWaitReply(unsigned char data_buf[], unsigned char reply_buf[], int WaitCmd, int timeout)
2971	{
2972	return mHDMIRxCEC.SendCustomMessageAndWaitReply(m_source_input, data_buf, reply_buf, WaitCmd, timeout);
2973	}
2974
2975	int CTv::SendHDMIRxCECBoradcastStandbyMessage(void)
2976	{
2977	return mHDMIRxCEC.SendBoradcastStandbyMessage(m_source_input);
2978	}
2979
2980	int CTv::SendHDMIRxCECGiveCECVersionMessage(tv_source_input_t source_input, unsigned char data_buf[])
2981	{
2982	if (mHDMIRxCEC.processRefreshSrcDevice(source_input) == 0) {
2983	return mHDMIRxCEC.SendGiveCECVersionMessage(source_input, data_buf);
2984	}
2985
2986	return -1;
2987	}
2988
2989	int CTv::SendHDMIRxCECGiveDeviceVendorIDMessage(tv_source_input_t source_input, unsigned char data_buf[])
2990	{
2991	if (mHDMIRxCEC.processRefreshSrcDevice(source_input) == 0) {
2992	return mHDMIRxCEC.SendGiveDeviceVendorIDMessage(source_input, data_buf);
2993	}
2994
2995	return -1;
2996	}
2997
2998	int CTv::SendHDMIRxCECGiveOSDNameMessage(tv_source_input_t source_input, unsigned char data_buf[])
2999	{
3000	if (mHDMIRxCEC.processRefreshSrcDevice(source_input) == 0) {
3001	return mHDMIRxCEC.SendGiveOSDNameMessage(source_input, data_buf);
3002	}
3003
3004	return -1;
3005	}
3006
3007	int CTv::GetHdmiHdcpKeyKsvInfo(int data_buf[])
3008	{
3009	return CTvin::getInstance()->get_hdmi_ksv_info(m_source_input, data_buf);
3010	}
3011
3012	bool CTv::hdmiOutWithFbc()
3013	{
3014	const char *value = config_get_str(CFG_SECTION_TV, CFG_FBC_USED, "true");
3015	if (strcmp(value, "true") == 0) {
3016	return true;
3017	}
3018
3019	return false;
3020	}
3021
3022	void CTv::onUpgradeStatus(int state, int param)
3023	{
3024	TvEvent::UpgradeFBCEvent ev;
3025	ev.mState = state;
3026	ev.param = param;
3027	sendTvEvent(ev);
3028	}
3029
3030	int CTv::StartUpgradeFBC(char *file_name, int mode, int upgrade_blk_size)
3031	{
3032	if (mpUpgradeFBC != NULL) {
3033	mpUpgradeFBC->SetUpgradeFileName(file_name);
3034	mpUpgradeFBC->SetUpgradeMode(mode);
3035	mpUpgradeFBC->SetUpgradeBlockSize(upgrade_blk_size);
3036	mpUpgradeFBC->start();
3037	return 0;
3038	}
3039
3040	return -1;
3041	}
3042
3043	void CTv::onSerialCommunication(int dev_id, int rd_len, unsigned char data_buf[])
3044	{
3045	TvEvent::SerialCommunicationEvent ev;
3046
3047	if (rd_len > CC_MAX_SERIAL_RD_BUF_LEN) {
3048	LOGE("%s, rd_len(%d) > buffer len(%d)", __FUNCTION__, rd_len, CC_MAX_SERIAL_RD_BUF_LEN);
3049	return;
3050	}
3051
3052	ev.mDevId = dev_id;
3053	ev.mDataCount = rd_len;
3054	for (int i = 0; i < rd_len; i++) {
3055	ev.mDataBuf[i] = data_buf[i];
3056	}
3057	sendTvEvent(ev);
3058	}
3059
3060	int CTv::StartHeadSetDetect()
3061	{
3062	mHeadSet.startDetect();
3063	return 0;
3064	}
3065
3066	void CTv::onHeadSetDetect(int state, int para)
3067	{
3068	TvEvent::HeadSetOf2d4GEvent ev;
3069	if (state == 1)
3070	property_set("audio.headset_plug.enable", "1");
3071	else
3072	property_set("audio.headset_plug.enable", "0");
3073	ev.state = state;
3074	ev.para = para;
3075	sendTvEvent(ev);
3076	}
3077
3078	void CTv::onThermalDetect(int state)
3079	{
3080	const char *value;
3081	int val = 0;
3082	static int preValue = -1;
3083
3084	value = config_get_str ( CFG_SECTION_TV, CFG_TVIN_THERMAL_THRESHOLD_ENABLE, "null" );
3085	if ( strcmp ( value, "enable" ) == 0 ) {
3086	value = config_get_str ( CFG_SECTION_TV, CFG_TVIN_THERMAL_THRESHOLD_VALUE, "null" );
3087	int threshold = atoi(value);
3088	LOGD ( "%s, threshold value: %d\n", __FUNCTION__, threshold);
3089
3090	if (state > threshold) {
3091	const char *valueNormal = config_get_str ( CFG_SECTION_TV, CFG_TVIN_THERMAL_FBC_NORMAL_VALUE, "null" );
3092	val = atoi(valueNormal);
3093	if (val == 0) {
3094	val = 0x4210000; //normal default
3095	}
3096	LOGD ( "%s, current temp: %d set 1\n", __FUNCTION__, state);
3097	} else {
3098	const char *valueCold = config_get_str ( CFG_SECTION_TV, CFG_TVIN_THERMAL_FBC_COLD_VALUE, "null" );
3099	val = atoi(valueCold);
3100	if (val == 0) {
3101	val = 0x8210000; //cold default
3102	}
3103	LOGD ( "%s, current temp: 0x%x set 0\n", __FUNCTION__, state);
3104	}
3105
3106	if (preValue != val) {
3107	LOGD ( "%s, pre value :0x%x, new value :0x%x, bypass\n", __FUNCTION__, preValue, val);
3108	preValue = val;
3109	Tv_FactorySet_FBC_Thermal_State(val);
3110	}
3111	} else {
3112	LOGD ( "%s, tvin thermal threshold disable\n", __FUNCTION__);
3113	}
3114	}
3115
3116	int CTv::SetDebugSerialOnOff(int on_off)
3117	{
3118	if (on_off) {
3119	property_set(UBOOTENV_CONSOLE, "ttyS0,115200n8");
3120	} else {
3121	property_set(UBOOTENV_CONSOLE, "off");
3122	}
3123	return 0;
3124	}
3125
3126	int CTv::GetDebugSerialOnOff()
3127	{
3128	char prop[256] = {0};
3129	property_get(UBOOTENV_CONSOLE, prop, "null" );
3130	if (!strcmp(prop, "ttyS0,115200n8")) {
3131	return 1;
3132	} else {
3133	return 0;
3134	}
3135	}
3136
3137	int CTv::SetSerialSwitch(int dev_id, int switch_val)
3138	{
3139	int tmp_ret = 0;
3140	if (dev_id == SERIAL_A) {
3141	if (switch_val == 0) {
3142	tmp_ret |= mSerialA.stop();
3143	tmp_ret |= mSerialA.CloseModule();
3144
3145	tmp_ret |= system("start console");
3146	tmp_ret |= system("echo 7 > /proc/sys/kernel/printk");
3147	} else {
3148	tmp_ret |= system("echo 0 > /proc/sys/kernel/printk");
3149	tmp_ret |= system("stop console");
3150
3151	mSerialA.OpenModule(dev_id);
3152	tmp_ret |= mSerialA.start();
3153	}
3154	} else if (dev_id == SERIAL_B) {
3155	if (switch_val == 0) {
3156	tmp_ret |= mSerialB.stop();
3157	tmp_ret |= mSerialB.CloseModule();
3158	} else {
3159	mSerialB.OpenModule(dev_id);
3160	tmp_ret = mSerialB.start();
3161	}
3162	} else if (dev_id == SERIAL_C) {
3163	if (switch_val == 0) {
3164	tmp_ret |= mSerialC.stop();
3165	tmp_ret |= mSerialC.CloseModule();
3166	} else {
3167	mSerialC.OpenModule(dev_id);
3168	tmp_ret = mSerialC.start();
3169	}
3170	}
3171
3172	return tmp_ret;
3173	}
3174
3175	int CTv::SendSerialData(int dev_id, int data_len, unsigned char data_buf[])
3176	{
3177	int tmp_ret = 0;
3178
3179	if (dev_id == SERIAL_A) {
3180	tmp_ret = mSerialA.sendData(data_len, data_buf);
3181	} else if (dev_id == SERIAL_B) {
3182	tmp_ret = mSerialB.sendData(data_len, data_buf);
3183	} else if (dev_id == SERIAL_C) {
3184	tmp_ret = mSerialC.sendData(data_len, data_buf);
3185	}
3186
3187	return tmp_ret;
3188	}
3189
3190	int CTv::ChannelExport(const char *destPath)
3191	{
3192	char tmp[256];
3193	if (destPath == NULL) {
3194	destPath = "/storage/external_storage/sda1/";
3195	}
3196
3197	sprintf(tmp, "cp %s %s", DEF_VALUE_CAHNNEL_DB, destPath);
3198	if (system(tmp) >= 0) {
3199	LOGD("%s, copy dtv.db from /param to udisk success !", __FUNCTION__);
3200	system("sync");
3201	FILE *fp = fopen(destPath, "r");
3202	if (fp != NULL) {
3203	fclose(fp);
3204	fp = NULL;
3205	return 0;
3206	}
3207	}
3208
3209	return -1;
3210	}
3211
3212	int CTv::ChannelImport(const char *srcPath)
3213	{
3214	if (srcPath == NULL) {
3215	srcPath = "/storage/external_storage/sda1/dvb.db";
3216	}
3217
3218	if (Tv_Utils_IsFileExist(srcPath)) {
3219	char tmp[256];
3220	const char *destPath = config_get_str(CFG_SECTION_TV, CFG_CAHNNEL_DB, (char *) DEF_VALUE_CAHNNEL_DB);
3221
3222	LOGD("%s, file exist !" , srcPath);
3223	CTvDatabase::GetTvDb()->UnInitTvDb();
3224	sprintf(tmp, "rm %s", destPath);
3225	if (system(tmp) >= 0) {
3226	LOGD("%s, rm %s success !", __FUNCTION__, destPath);
3227	memset(tmp, 0, sizeof(tmp));
3228	sprintf(tmp, "cp %s %s", srcPath, destPath);
3229	if (system(tmp) >= 0) {
3230	LOGD("%s, copy to %s success !", srcPath, destPath);
3231	memset(tmp, 0, sizeof(tmp));
3232	sprintf(tmp, "chmod 777 %s", destPath);
3233	if (system(tmp) >= 0) {
3234	LOGD("chmod 777 %s success !", destPath);
3235	system("sync");
3236	CTvDatabase::GetTvDb()->InitTvDb(TV_DB_PATH);
3237	return 0;
3238	} else {
3239	LOGD("%s, %s chmod failed !", __FUNCTION__, destPath);
3240	return -1;
3241	}
3242	} else {
3243	LOGD("%s, copy dtv.db from udisk to %s failed !", __FUNCTION__, destPath);
3244	return -1;
3245	}
3246	} else {
3247	LOGD("%s, rm %s failed !", __FUNCTION__, destPath);
3248	return -2;
3249	}
3250	} else {
3251	LOGD("%s, dtv.db file does not exist in the udisk!" , srcPath);
3252	return -2;
3253	}
3254	}
3255
3256	int CTv::Tv_GetProjectInfo(project_info_t *ptrInfo)
3257	{
3258	return GetProjectInfo(ptrInfo, fbcIns);
3259	}
3260
3261	int CTv::Tv_GetPlatformType()
3262	{
3263	return mHdmiOutFbc ? 1 : 0;
3264	}
3265
3266	int CTv::Tv_HandeHDMIEDIDFilePathConfig()
3267	{
3268	char edid_path[256];
3269	char edid_path_cfg[256];
3270	bool fileExist = false;
3271
3272	const char *value = config_get_str(CFG_SECTION_TV, CFG_SSM_HDMI_EDID_EN, "null");
3273	if (strtoul(value, NULL, 10) == 1) {
3274	LOGD( "%s, get config [%s]:[%s]\n", __FUNCTION__, CFG_SSM_HDMI_EDID_EN, value);
3275	//get hdmi edid use mode
3276	char propValue[256] = {0};
3277	property_get(UBOOTENV_OUTPUTMODE, propValue, "null");
3278	LOGD( "%s, get property [%s]:[%s]\n", __FUNCTION__, UBOOTENV_OUTPUTMODE, propValue);
3279	if (strcmp(propValue, "null") != 0) {
3280	fileExist = true;
3281
3282	config_set_str ( CFG_SECTION_TV, CS_HDMI_EDID_USE_CFG, propValue);
3283	//set file's path for hdmi edid of each port
3284	for (int i = 1; i <= SSM_HDMI_PORT_MAX; i++) {
3285	memset( edid_path, '\0', 256);
3286	memset( edid_path_cfg, '\0', 256);
3287	sprintf(edid_path, "/system/etc/%s_port%d.bin", propValue, i);
3288	sprintf(edid_path_cfg, "ssm.handle.hdmi.port%d.edid.file.path", i);
3289	if (access(edid_path, 0) < 0) {
3290	fileExist = false;
3291	break;
3292	}
3293	config_set_str(CFG_SECTION_TV, edid_path_cfg, edid_path);
3294	}
3295	}
3296
3297	if (!fileExist) {
3298	//set default hdmi edid
3299	config_set_str(CFG_SECTION_TV, CS_HDMI_EDID_USE_CFG, "hdmi_edid");
3300	//set file's path for hdmi edid of each port
3301	for (int i = 1; i <= SSM_HDMI_PORT_MAX; i++) {
3302	memset(edid_path, '\0', 256);
3303	memset(edid_path_cfg, '\0', 256);
3304	sprintf(edid_path, "/system/etc/%s_port%d.bin", "hdmi_edid", i);
3305	sprintf(edid_path_cfg, "ssm.handle.hdmi.port%d.edid.file.path", i);
3306
3307	value = config_get_str(CFG_SECTION_TV, edid_path_cfg, "null");
3308	if (strcmp(value, edid_path) != 0) {
3309	config_set_str(CFG_SECTION_TV, edid_path_cfg, edid_path);
3310	}
3311	}
3312	}
3313
3314	mSetHdmiEdid = true;
3315	}
3316	return 0;
3317	}
3318
3319	int CTv::Tv_SetDDDRCMode(tv_source_input_t source_input)
3320	{
3321	if (source_input == SOURCE_DTV) {
3322	if (GetPlatformHaveDDFlag() == 1) {
3323	Tv_Utils_SetFileAttrStr(SYS_AUIDO_DSP_AC3_DRC, (char *)"drcmode 3");
3324	}
3325	} else {
3326	if (GetPlatformHaveDDFlag() == 1) {
3327	Tv_Utils_SetFileAttrStr(SYS_AUIDO_DSP_AC3_DRC, (char *)"drcmode 2");
3328	}
3329	}
3330	return 0;
3331	}
3332
3333	//PQ
3334	int CTv::Tv_SetBrightness ( int brightness, tv_source_input_type_t source_type, int is_save )
3335	{
3336	return CVpp::getInstance()->SetBrightness(brightness, (tv_source_input_type_t)source_type, mSigDetectThread.getCurSigInfo().fmt, mSigDetectThread.getCurSigInfo().trans_fmt, Check2Dor3D(m_mode_3d, mSigDetectThread.getCurSigInfo().trans_fmt ), is_save);
3337	}
3338
3339	int CTv::Tv_GetBrightness ( tv_source_input_type_t source_type )
3340	{
3341	return CVpp::getInstance()->GetBrightness((tv_source_input_type_t)source_type);
3342	}
3343
3344	int CTv::Tv_SaveBrightness ( int brightness, tv_source_input_type_t source_type )
3345	{
3346	return SSMSaveBrightness ( source_type, brightness );
3347	}
3348
3349	int CTv::Tv_SetContrast ( int contrast, tv_source_input_type_t source_type, int is_save )
3350	{
3351	return CVpp::getInstance()->SetContrast(contrast, (tv_source_input_type_t)source_type, mSigDetectThread.getCurSigInfo().fmt, mSigDetectThread.getCurSigInfo().trans_fmt, Check2Dor3D(m_mode_3d, mSigDetectThread.getCurSigInfo().trans_fmt ), is_save);
3352	}
3353
3354	int CTv::Tv_GetContrast ( tv_source_input_type_t source_type )
3355	{
3356	return CVpp::getInstance()->GetContrast((tv_source_input_type_t)source_type);
3357	}
3358
3359	int CTv::Tv_SaveContrast ( int contrast, tv_source_input_type_t source_type )
3360	{
3361	return SSMSaveContrast ( source_type, contrast );
3362	}
3363
3364	int CTv::Tv_SetSaturation ( int satuation, tv_source_input_type_t source_type, tvin_sig_fmt_t fmt, int is_save )
3365	{
3366	return CVpp::getInstance()->SetSaturation(satuation, (tv_source_input_type_t)source_type, (tvin_sig_fmt_t)fmt, mSigDetectThread.getCurSigInfo().trans_fmt, Check2Dor3D(m_mode_3d, mSigDetectThread.getCurSigInfo().trans_fmt ), is_save);
3367	}
3368
3369	int CTv::Tv_GetSaturation ( tv_source_input_type_t source_type )
3370	{
3371	return CVpp::getInstance()->GetSaturation((tv_source_input_type_t)source_type);
3372	}
3373
3374	int CTv::Tv_SaveSaturation ( int satuation, tv_source_input_type_t source_type )
3375	{
3376	return SSMSaveSaturation ( source_type, satuation );
3377	}
3378
3379	int CTv::Tv_SetHue ( int hue, tv_source_input_type_t source_type, tvin_sig_fmt_t fmt, int is_save )
3380	{
3381	return CVpp::getInstance()->SetHue(hue, (tv_source_input_type_t)source_type, (tvin_sig_fmt_t)fmt, mSigDetectThread.getCurSigInfo().trans_fmt, Check2Dor3D(m_mode_3d, mSigDetectThread.getCurSigInfo().trans_fmt ), is_save);
3382	}
3383
3384	int CTv::Tv_GetHue ( tv_source_input_type_t source_type )
3385	{
3386	return CVpp::getInstance()->GetHue((tv_source_input_type_t)source_type);
3387	}
3388
3389	int CTv::Tv_SaveHue ( int hue, tv_source_input_type_t source_type )
3390	{
3391	return SSMSaveHue ( source_type, hue );
3392	}
3393
3394	int CTv::Tv_SetPQMode ( vpp_picture_mode_t mode, tv_source_input_type_t source_type, int is_save )
3395	{
3396	return CVpp::getInstance()->SetPQMode((vpp_picture_mode_t)mode, (tv_source_input_type_t)source_type, mSigDetectThread.getCurSigInfo().fmt, mSigDetectThread.getCurSigInfo().trans_fmt, Check2Dor3D(m_mode_3d, mSigDetectThread.getCurSigInfo().trans_fmt ), is_save);
3397	}
3398
3399	vpp_picture_mode_t CTv::Tv_GetPQMode ( tv_source_input_type_t source_type )
3400	{
3401	return CVpp::getInstance()->GetPQMode((tv_source_input_type_t)source_type);
3402	}
3403
3404	int CTv::Tv_SavePQMode ( vpp_picture_mode_t mode, tv_source_input_type_t source_type )
3405	{
3406	return CVpp::getInstance()->SavePQMode ( mode, source_type );
3407	}
3408
3409	int CTv::Tv_SetSharpness ( int value, tv_source_input_type_t source_type, int en, int is_save )
3410	{
3411	return CVpp::getInstance()->SetSharpness(value, (tv_source_input_type_t)source_type, en, Check2Dor3D(m_mode_3d, mSigDetectThread.getCurSigInfo().trans_fmt ), mSigDetectThread.getCurSigInfo().fmt, mSigDetectThread.getCurSigInfo().trans_fmt, is_save);
3412	}
3413
3414	int CTv::Tv_GetSharpness ( tv_source_input_type_t source_type )
3415	{
3416	return CVpp::getInstance()->GetSharpness((tv_source_input_type_t)source_type);
3417	}
3418
3419	int CTv::Tv_SaveSharpness ( int value, tv_source_input_type_t source_type )
3420	{
3421	return SSMSaveSharpness ( source_type, value );
3422	}
3423
3424	int CTv::Tv_SetBacklight ( int value, tv_source_input_type_t source_type, int is_save )
3425	{
3426	if (mHdmiOutFbc) {
3427	return Tv_FactorySet_FBC_Backlight(value);
3428	} else {
3429	return CVpp::getInstance()->SetBacklight(value, (tv_source_input_type_t)source_type, is_save);
3430	}
3431	}
3432
3433	int CTv::Tv_GetBacklight ( tv_source_input_type_t source_type )
3434	{
3435	if (mHdmiOutFbc) {
3436	return Tv_FactoryGet_FBC_Backlight();
3437	} else {
3438	return CVpp::getInstance()->GetBacklight((tv_source_input_type_t)source_type);
3439	}
3440	}
3441
3442	int CTv::Tv_SaveBacklight ( int value, tv_source_input_type_t source_type )
3443	{
3444	return CVpp::getInstance()->SaveBacklight ( value, source_type );
3445	}
3446
3447	int CTv::Tv_SetBacklight_Switch ( int value )
3448	{
3449	if (mHdmiOutFbc) {
3450	return Tv_FactorySet_FBC_backlight_onoff(value);
3451	} else {
3452	return CVpp::getInstance()->VPP_SetBackLight_Switch(value);
3453	}
3454	}
3455
3456	int CTv::Tv_GetBacklight_Switch ( void )
3457	{
3458	if (mHdmiOutFbc) {
3459	return Tv_FactoryGet_FBC_backlight_onoff();
3460	} else {
3461	return CVpp::getInstance()->VPP_GetBackLight_Switch();
3462	}
3463	}
3464
3465	int CTv::Tv_SetColorTemperature ( vpp_color_temperature_mode_t mode, tv_source_input_type_t source_type, int is_save )
3466	{
3467	if (mHdmiOutFbc) {
3468	return Tv_FactorySet_FBC_ColorTemp_Mode(mode);
3469	} else {
3470	return CVpp::getInstance()->SetColorTemperature((vpp_color_temperature_mode_t)mode, (tv_source_input_type_t)source_type, is_save);
3471	}
3472	}
3473
3474	vpp_color_temperature_mode_t CTv::Tv_GetColorTemperature ( tv_source_input_type_t source_type )
3475	{
3476	if (mHdmiOutFbc) {
3477	return (vpp_color_temperature_mode_t)Tv_FactoryGet_FBC_ColorTemp_Mode();
3478	} else {
3479	return CVpp::getInstance()->GetColorTemperature((tv_source_input_type_t)source_type);
3480	}
3481	}
3482
3483	int CTv::Tv_SaveColorTemperature ( vpp_color_temperature_mode_t mode, tv_source_input_type_t source_type )
3484	{
3485	return CVpp::getInstance()->SaveColorTemp ( mode, source_type );
3486	}
3487
3488	int CTv::Tv_SetDisplayMode ( vpp_display_mode_t mode, tv_source_input_type_t source_type, tvin_sig_fmt_t fmt, int is_save )
3489	{
3490	int ret = 0;
3491	if (m_mode_3d == VIDEO_3D_MODE_DISABLE) {
3492	ret = SetDisplayMode((vpp_display_mode_t)mode, (tv_source_input_type_t)source_type, (tvin_sig_fmt_t)fmt);
3493	} else { //3D
3494	ret = SetDisplayMode(VPP_DISPLAY_MODE_PERSON, (tv_source_input_type_t)source_type, (tvin_sig_fmt_t)fmt);
3495	}
3496	if (ret == 0) {
3497	if (is_save == 1) {
3498	ret = ret | SSMSaveDisplayMode ( source_type, (int)mode );
3499	}
3500	}
3501	return ret;
3502	}
3503
3504	int CTv::SetDisplayMode ( vpp_display_mode_t display_mode, tv_source_input_type_t source_type, tvin_sig_fmt_t sig_fmt )
3505	{
3506	LOGD("SetDisplayMode, display_mode = %d, source_type = %d fmt = %d tranfmt = %d\n", display_mode, source_type, sig_fmt, mSigDetectThread.getCurSigInfo().trans_fmt);
3507
3508	tvin_cutwin_t cutwin = CVpp::getInstance()->GetOverscan ( source_type, sig_fmt, Check2Dor3D(m_mode_3d, mSigDetectThread.getCurSigInfo().trans_fmt ), mSigDetectThread.getCurSigInfo().trans_fmt);
3509	LOGD("SetDisplayMode , get crop %d %d %d %d \n", cutwin.vs, cutwin.hs, cutwin.ve, cutwin.he);
3510	int video_screen_mode = CAv::VIDEO_WIDEOPTION_16_9;
3511	tvin_window_pos_t win_pos;
3512	int display_resolution = Vpp_GetDisplayResolutionInfo(&win_pos);
3513
3514	switch ( display_mode ) {
3515	case VPP_DISPLAY_MODE_169:
3516	video_screen_mode = CAv::VIDEO_WIDEOPTION_16_9;
3517	break;
3518	case VPP_DISPLAY_MODE_MODE43:
3519	video_screen_mode = CAv::VIDEO_WIDEOPTION_4_3;
3520	break;
3521	case VPP_DISPLAY_MODE_NORMAL:
3522	video_screen_mode = CAv::VIDEO_WIDEOPTION_NORMAL;
3523	break;
3524	case VPP_DISPLAY_MODE_FULL:
3525	video_screen_mode = CAv::VIDEO_WIDEOPTION_NONLINEAR;
3526	CVpp::getInstance()->VPP_SetNonLinearFactor ( 20 );
3527	//CVpp::getInstance()->VPP_SetNonLinearFactor ( 20 );
3528	break;
3529	case VPP_DISPLAY_MODE_CROP_FULL:
3530	cutwin.vs = 0;
3531	cutwin.hs = 0;
3532	cutwin.ve = 0;
3533	cutwin.he = 0;
3534	break;
3535	case VPP_DISPLAY_MODE_NOSCALEUP:
3536	video_screen_mode = CAv::VIDEO_WIDEOPTION_NORMAL_NOSCALEUP;
3537	break;
3538	case VPP_DISPLAY_MODE_FULL_REAL:
3539	video_screen_mode = CAv::VIDEO_WIDEOPTION_16_9; //added for N360 by haifeng.liu
3540	break;
3541	case VPP_DISPLAY_MODE_PERSON:
3542	video_screen_mode = CAv::VIDEO_WIDEOPTION_FULL_STRETCH;
3543	cutwin.vs = cutwin.vs + 20;
3544	cutwin.ve = cutwin.ve + 20;
3545	break;
3546	case VPP_DISPLAY_MODE_MOVIE:
3547	video_screen_mode = CAv::VIDEO_WIDEOPTION_FULL_STRETCH;
3548	cutwin.vs = cutwin.vs + 40;
3549	cutwin.ve = cutwin.ve + 40;
3550	break;
3551	case VPP_DISPLAY_MODE_CAPTION:
3552	video_screen_mode = CAv::VIDEO_WIDEOPTION_FULL_STRETCH;
3553	cutwin.vs = cutwin.vs + 55;
3554	cutwin.ve = cutwin.ve + 55;
3555	break;
3556	case VPP_DISPLAY_MODE_ZOOM:
3557	video_screen_mode = CAv::VIDEO_WIDEOPTION_FULL_STRETCH;
3558	cutwin.vs = cutwin.vs + 70;
3559	cutwin.ve = cutwin.ve + 70;
3560	break;
3561	default:
3562	break;
3563	}
3564	if (source_type == SOURCE_TYPE_DTV || source_type == SOURCE_TYPE_MPEG) {
3565	cutwin.vs = cutwin.vs + 12;
3566	cutwin.ve = cutwin.ve + 12;
3567	cutwin.hs = cutwin.hs + 12;
3568	cutwin.he = cutwin.he + 12;
3569	}
3570	if (source_type == SOURCE_TYPE_HDMI) {
3571	if ((IsDVISignal()) || (CTvin::getInstance()->GetITContent() == 1) ||
3572	(display_mode == VPP_DISPLAY_MODE_FULL_REAL)) {
3573	cutwin.vs = 0;
3574	cutwin.hs = 0;
3575	cutwin.ve = 0;
3576	cutwin.he = 0;
3577	}
3578	}
3579
3580	//mAv.setVideoAxis ( win_pos.x1, win_pos.y1, win_pos.x2, win_pos.y2 );
3581	mAv.setVideoScreenMode(video_screen_mode);
3582	CVpp::getInstance()->VPP_SetVideoCrop(cutwin.vs, cutwin.hs, cutwin.ve, cutwin.he);
3583	return 0;
3584	}
3585
3586	vpp_display_mode_t CTv::Tv_GetDisplayMode ( tv_source_input_type_t source_type )
3587	{
3588	return CVpp::getInstance()->GetDisplayMode((tv_source_input_type_t)source_type);
3589	}
3590
3591	int CTv::Tv_SaveDisplayMode ( vpp_display_mode_t mode, tv_source_input_type_t source_type )
3592	{
3593	return SSMSaveDisplayMode ( source_type, (int)mode );
3594	}
3595
3596	int CTv::Tv_SetNoiseReductionMode ( vpp_noise_reduction_mode_t mode, tv_source_input_type_t source_type, int is_save )
3597	{
3598	return CVpp::getInstance()->SetNoiseReductionMode((vpp_noise_reduction_mode_t)mode, (tv_source_input_type_t)source_type, mSigDetectThread.getCurSigInfo().fmt, Check2Dor3D(m_mode_3d, mSigDetectThread.getCurSigInfo().trans_fmt ), mSigDetectThread.getCurSigInfo().trans_fmt, is_save);
3599	}
3600
3601	int CTv::Tv_SaveNoiseReductionMode ( vpp_noise_reduction_mode_t mode, tv_source_input_type_t source_type )
3602	{
3603	return CVpp::getInstance()->SaveNoiseReductionMode ( mode, source_type );
3604	}
3605
3606	int CTv::Tv_Set2k4k_ScalerUp_Mode ( int value )
3607	{
3608	int ret = 0, fmt_hd_sd = 0;
3609	int nodeVal = 0;
3610	char s[8];
3611
3612	LOGD("%s, value [%d]\n", __FUNCTION__ , value);
3613
3614	if ( CTvin::Tvin_SourceInputToSourceInputType(m_source_input) != SOURCE_TYPE_HDMI &&
3615	CTvin::Tvin_SourceInputToSourceInputType(m_source_input) != SOURCE_TYPE_AV &&
3616	CTvin::Tvin_SourceInputToSourceInputType(m_source_input) != SOURCE_TYPE_TV) {
3617	int fd = open(SYS_VIDEO_FRAME_HEIGHT, O_RDONLY);
3618	if (fd <= 0) {
3619	LOGE("open %s ERROR!!error = -%s- \n",SYS_VIDEO_FRAME_HEIGHT, strerror ( errno ));
3620	return -1;
3621	}
3622	read(fd, s, sizeof(s));
3623	close(fd);
3624	nodeVal = atoi(s);
3625	if (nodeVal < 900) {
3626	fmt_hd_sd = 0;
3627	} else {
3628	fmt_hd_sd = 1;
3629	}
3630	} else if ( CTvin::Tvin_SourceInputToSourceInputType(m_source_input) == SOURCE_TYPE_HDMI ) {
3631	if (isSDFmtInHdmi()) {
3632	fmt_hd_sd = 0;
3633	} else {
3634	fmt_hd_sd = 1;
3635	}
3636	} else if ( CTvin::Tvin_SourceInputToSourceInputType(m_source_input) == SOURCE_TYPE_AV ||
3637	CTvin::Tvin_SourceInputToSourceInputType(m_source_input) == SOURCE_TYPE_TV) {
3638	fmt_hd_sd = 0;
3639	}
3640
3641	switch (value) {
3642	case 1: // on
3643	if (fmt_hd_sd) {
3644	ret = Tv_Utils_SetFileAttrStr(SYS_VIDEO_SCALER_PATH_SEL, (char *)"0");
3645	} else {
3646	ret = Tv_Utils_SetFileAttrStr(SYS_VIDEO_SCALER_PATH_SEL, (char *)"1");
3647	}
3648	break;
3649
3650	case 0: // off
3651	default:
3652	if (fmt_hd_sd) {
3653	ret = Tv_Utils_SetFileAttrStr(SYS_VIDEO_SCALER_PATH_SEL, (char *)"1");
3654	} else {
3655	ret = Tv_Utils_SetFileAttrStr(SYS_VIDEO_SCALER_PATH_SEL, (char *)"0");
3656	}
3657	break;
3658	}
3659	return ret;
3660	}
3661
3662	int CTv::Tv_Get2k4k_ScalerUp_Mode ( void )
3663	{
3664	char attrV[64];
3665	int ret = 0, fmt_hd_sd = 0;
3666	int nodeVal = 0;
3667	char s[8];
3668
3669	memset (attrV, '\0', 64);
3670
3671	if ( CTvin::Tvin_SourceInputToSourceInputType(m_source_input) != SOURCE_TYPE_HDMI &&
3672	CTvin::Tvin_SourceInputToSourceInputType(m_source_input) != SOURCE_TYPE_AV &&
3673	CTvin::Tvin_SourceInputToSourceInputType(m_source_input) != SOURCE_TYPE_TV) {
3674	int fd = open(SYS_VIDEO_FRAME_HEIGHT, O_RDONLY);
3675	if (fd <= 0) {
3676	LOGE("open %s ERROR!!error = -%s- \n",SYS_VIDEO_FRAME_HEIGHT, strerror ( errno ));
3677	return -1;
3678	}
3679	read(fd, s, sizeof(s));
3680	close(fd);
3681	nodeVal = atoi(s);
3682	if (nodeVal < 900) {
3683	fmt_hd_sd = 0;
3684	} else {
3685	fmt_hd_sd = 1;
3686	}
3687	} else if ( CTvin::Tvin_SourceInputToSourceInputType(m_source_input) == SOURCE_TYPE_HDMI ) {
3688	if (isSDFmtInHdmi()) {
3689	fmt_hd_sd = 0;
3690	} else {
3691	fmt_hd_sd = 1;
3692	}
3693	} else if ( CTvin::Tvin_SourceInputToSourceInputType(m_source_input) == SOURCE_TYPE_AV || CTvin::Tvin_SourceInputToSourceInputType(m_source_input) == SOURCE_TYPE_TV) {
3694	fmt_hd_sd = 0;
3695	}
3696
3697	Tv_Utils_GetFileAttrStr(SYS_VIDEO_SCALER_PATH_SEL, 64, attrV);
3698	if (strncasecmp(attrV, "1", strlen ("1")) == 0) {
3699	if (fmt_hd_sd) {
3700	ret = 0;
3701	} else {
3702	ret = 1;
3703	}
3704	} else if (strncasecmp(attrV, "0", strlen ("0")) == 0) {
3705	if (fmt_hd_sd) {
3706	ret = 1;
3707	} else {
3708	ret = 0;
3709	}
3710	} else {
3711	ret = -1;
3712	}
3713
3714	return ret;
3715	}
3716
3717	int CTv::Tv_SetSplitScreenDemoStatus(tv_source_input_type_t source_type, int onoff_status)
3718	{
3719	int ret = 0;
3720	LOGD("%s, split screen demo status source[%d],onoff_stauts[%d]\n", __FUNCTION__ , source_type, onoff_status);
3721	if (1 == onoff_status) {
3722	ret = Tv_Utils_SetFileAttrStr(SYS_DROILOGIC_DEBUG, (char *)"w 0x503c0 v 0x31d6");//sharpness screen left
3723	ret |= Tv_Utils_SetFileAttrStr(SYS_DROILOGIC_DEBUG, (char *)"w 0x07 v 0x174d");//nr screen left
3724	} else if (0 == onoff_status) {
3725	ret = Tv_Utils_SetFileAttrStr(SYS_DROILOGIC_DEBUG, (char *)"w 0x503c0 v 0x31d6");//sharpness screen left
3726	ret |= Tv_Utils_SetFileAttrStr(SYS_DROILOGIC_DEBUG, (char *)"w 0x07 v 0x174d");//nr screen left
3727	}
3728
3729	if (fbcIns != NULL && 0 == ret) {
3730	ret |= fbcIns->cfbc_SET_SPLIT_SCREEN_DEMO(COMM_DEV_SERIAL, onoff_status);
3731	}
3732
3733	return ret;
3734	}
3735
3736	int CTv::Tv_GetSplitScreenDemoStatus(tv_source_input_type_t source_type)
3737	{
3738	source_type = source_type;
3739	return 0;
3740	}
3741
3742	vpp_noise_reduction_mode_t CTv::Tv_GetNoiseReductionMode ( tv_source_input_type_t source_type )
3743	{
3744	return CVpp::getInstance()->GetNoiseReductionMode((tv_source_input_type_t)source_type);
3745	}
3746
3747	/**
3748	* @parameter mode : 0:sharpness; 1:NR
3749	*
3750	1.sharpness分屏（可以控制宽度）
3751	分屏大小 寄存器范围是0x50000 冿x50780,左效果的范围越来越大?0x70780 冿x70000也是一枿
3752	左右调换控制 bit 17. 开僿控冿bit 16. 0-11bit 是控制宽度的。范围是0-0x780?920像素?
3753	左做效果处理 echo w 0x503c0 v 0x31d6 > /sys/class/amlogic/debug
3754	右做效果处理 echo w 0x703c0 v 0x31d6 > /sys/class/amlogic/debug
3755	echo w 0x403c0 v 0x31d6 > /sys/class/amlogic/debug
3756
3757	2. NR分屏(不能控制宽度)
3758	左做效果处理 echo w 0x07 v 0x174d > /sys /class/amlogic/debug
3759	右做效果处理 echo w 0x70 v 0x174d > /sys /class/amlogic/debug
3760	偿 echo w 0x77 v 0x174d > /sys/class/amlogic/debug
3761	*/
3762	int CTv::Tv_SplitScreenEffect(int mode, int width, int reverse)
3763	{
3764	int ret = -1;
3765
3766	if (mode == 0) {
3767	if (width == 0) {//close
3768	ret = CVpp::getInstance()->VPP_SplitScreenEffect(0x403c0, 0x31d6);
3769	} else {
3770	int val = 0;
3771	if (reverse == 0) {//left effect
3772	val = width + 0x50000;
3773	} else {//right effect
3774	val = 0x70780 - width;
3775	}
3776	ret = CVpp::getInstance()->VPP_SplitScreenEffect(val, 0x31d6);
3777	}
3778	} else if (mode == 1) {
3779	if (width == 0) {//close
3780	ret = CVpp::getInstance()->VPP_SplitScreenEffect(0x77, 0x174d);
3781	} else {
3782	if (reverse == 0)
3783	ret = CVpp::getInstance()->VPP_SplitScreenEffect(0x07, 0x174d);
3784	else
3785	ret = CVpp::getInstance()->VPP_SplitScreenEffect(0x70, 0x174d);
3786	}
3787	} else if (mode == 2) {
3788	}
3789
3790	return ret;
3791	}
3792
3793	int CTv::Tv_FactorySetPQMode_Brightness ( int source_type, int pq_mode, int brightness )
3794	{
3795	return CVpp::getInstance()->FactorySetPQMode_Brightness(source_type, pq_mode, brightness);
3796	}
3797
3798	int CTv::Tv_FactoryGetPQMode_Brightness ( int source_type, int pq_mode )
3799	{
3800	return CVpp::getInstance()->FactoryGetPQMode_Brightness(source_type, pq_mode);
3801	}
3802
3803	int CTv::Tv_FactorySetPQMode_Contrast ( int source_type, int pq_mode, int contrast )
3804	{
3805	return CVpp::getInstance()->FactorySetPQMode_Contrast(source_type, pq_mode, contrast);
3806	}
3807
3808	int CTv::Tv_FactoryGetPQMode_Contrast ( int source_type, int pq_mode )
3809	{
3810	return CVpp::getInstance()->FactoryGetPQMode_Contrast(source_type, pq_mode);
3811	}
3812
3813	int CTv::Tv_FactorySetPQMode_Saturation ( int source_type, int pq_mode, int saturation )
3814	{
3815	return CVpp::getInstance()->FactorySetPQMode_Saturation(source_type, pq_mode, saturation);
3816	}
3817
3818	int CTv::Tv_FactoryGetPQMode_Saturation ( int source_type, int pq_mode )
3819	{
3820	return CVpp::getInstance()->FactoryGetPQMode_Saturation(source_type, pq_mode);
3821	}
3822
3823	int CTv::Tv_FactorySetPQMode_Hue ( int source_type, int pq_mode, int hue )
3824	{
3825	return CVpp::getInstance()->FactorySetPQMode_Hue(source_type, pq_mode, hue);
3826	}
3827
3828	int CTv::Tv_FactoryGetPQMode_Hue ( int source_type, int pq_mode )
3829	{
3830	return CVpp::getInstance()->FactoryGetPQMode_Hue(source_type, pq_mode);
3831	}
3832
3833	int CTv::Tv_FactorySetPQMode_Sharpness ( int source_type, int pq_mode, int sharpness )
3834	{
3835	return CVpp::getInstance()->FactorySetPQMode_Sharpness(source_type, pq_mode, sharpness);
3836	}
3837
3838	int CTv::Tv_FactoryGetPQMode_Sharpness ( int source_type, int pq_mode )
3839	{
3840	return CVpp::getInstance()->FactoryGetPQMode_Sharpness(source_type, pq_mode);
3841	}
3842
3843	int CTv::GetColorTemperatureParams ( vpp_color_temperature_mode_t Tempmode, tcon_rgb_ogo_t *params )
3844	{
3845	if (mHdmiOutFbc) {
3846	int ret = Tv_FactoryGet_FBC_ColorTemp_Batch((vpp_color_temperature_mode_t)Tempmode, params);
3847	params->r_gain = Tv_FactoryWhiteBalanceFormatOutputFbcGainParams(params->r_gain);
3848	params->g_gain = Tv_FactoryWhiteBalanceFormatOutputFbcGainParams(params->g_gain);
3849	params->b_gain = Tv_FactoryWhiteBalanceFormatOutputFbcGainParams(params->b_gain);
3850	params->r_post_offset = Tv_FactoryWhiteBalanceFormatOutputFbcOffsetParams(params->r_post_offset);
3851	params->g_post_offset = Tv_FactoryWhiteBalanceFormatOutputFbcOffsetParams(params->g_post_offset);
3852	params->b_post_offset = Tv_FactoryWhiteBalanceFormatOutputFbcOffsetParams(params->b_post_offset);
3853	return ret;
3854	} else {
3855	return CVpp::getInstance()->GetColorTemperatureParams(Tempmode, params);
3856	}
3857	}
3858
3859	int CTv::Tv_FactorySetTestPattern ( int pattern )
3860	{
3861	switch ( pattern ) {
3862	case VPP_TEST_PATTERN_NONE:
3863	mAv.SetVideoScreenColor ( 3, 16, 128, 128 );
3864	break;
3865
3866	case VPP_TEST_PATTERN_RED:
3867	mAv.SetVideoScreenColor ( 0, 81, 90, 240 );
3868	break;
3869
3870	case VPP_TEST_PATTERN_GREEN:
3871	mAv.SetVideoScreenColor ( 0, 145, 54, 34 );
3872	break;
3873
3874	case VPP_TEST_PATTERN_BLUE:
3875	mAv.SetVideoScreenColor ( 0, 41, 240, 110 );
3876	break;
3877
3878	case VPP_TEST_PATTERN_WHITE:
3879	mAv.SetVideoScreenColor ( 0, 235, 128, 128 );
3880	break;
3881
3882	case VPP_TEST_PATTERN_BLACK:
3883	mAv.SetVideoScreenColor ( 0, 16, 128, 128 );
3884	break;
3885
3886	default:
3887	return -1;
3888	}
3889	return SSMSaveTestPattern ( pattern );
3890	}
3891
3892	int CTv::Tv_FactoryGetTestPattern ( void )
3893	{
3894	return CVpp::getInstance()->FactoryGetTestPattern();
3895	}
3896
3897	int CTv::Tv_FactorySetScreenColor ( int vdin_blending_mask, int y, int u, int v )
3898	{
3899	return mAv.SetVideoScreenColor ( vdin_blending_mask, y, u, v );
3900	}
3901
3902	int CTv::Tv_FactoryResetPQMode ( void )
3903	{
3904	return CVpp::getInstance()->FactoryResetPQMode();
3905	}
3906
3907	int CTv::Tv_FactoryResetColorTemp ( void )
3908	{
3909	return CVpp::getInstance()->FactoryResetColorTemp();
3910	}
3911
3912	int CTv::Tv_FactorySetParamsDefault ( void )
3913	{
3914	return CVpp::getInstance()->FactorySetParamsDefault();
3915	}
3916
3917	int CTv::Tv_FactorySetDDRSSC ( int step )
3918	{
3919	return CVpp::getInstance()->FactorySetDDRSSC(step);
3920	}
3921
3922	int CTv::Tv_FactoryGetDDRSSC ( void )
3923	{
3924	return CVpp::getInstance()->FactoryGetDDRSSC();
3925	}
3926
3927	int CTv::Tv_FactorySetLVDSSSC ( int step )
3928	{
3929	return CVpp::getInstance()->FactorySetLVDSSSC(step);
3930	}
3931
3932	int CTv::Tv_FactoryGetLVDSSSC ( void )
3933	{
3934	return CVpp::getInstance()->FactoryGetLVDSSSC();
3935	}
3936
3937	void CTv::Tv_Spread_Spectrum()
3938	{
3939	int value = 0;
3940	value = CVpp::getInstance()->FactoryGetLVDSSSC();
3941	CVpp::getInstance()->FactorySetLVDSSSC(value);
3942	}
3943
3944	int CTv::Tv_FactorySetNolineParams ( int noline_params_type, int source_type, noline_params_t noline_params )
3945	{
3946	return CVpp::getInstance()->FactorySetNolineParams(noline_params_type, source_type, noline_params);
3947	}
3948
3949	noline_params_t CTv::Tv_FactoryGetNolineParams ( int noline_params_type, int source_type )
3950	{
3951	return CVpp::getInstance()->FactoryGetNolineParams(noline_params_type, source_type);
3952	}
3953
3954	int CTv::Tv_FactorySetOverscan ( int source_type, int fmt, int status_3d, int trans_fmt, tvin_cutwin_t cutwin_t )
3955	{
3956	//tvin_cutwin_t cutwin_t = CVpp::getInstance()->Tv_FactoryGetOverscan(source_type, fmt, status_3d, trans_fmt);
3957	CVpp::getInstance()->FactorySetOverscan(source_type, fmt, status_3d, trans_fmt, cutwin_t);
3958	//} else {
3959	#if 0
3960	char val_buf[256];
3961	memset(val_buf, '\0', 256);
3962	LOGD("%s,%d: %d,%d,%d,%d", __FUNCTION__, __LINE__, ( int ) cutwin_t.vs, ( int ) cutwin_t.hs, ( int ) cutwin_t.ve, ( int ) cutwin_t.he);
3963	sprintf(val_buf, "%d,%d,%d,%d", ( int ) cutwin_t.vs, ( int ) cutwin_t.hs, ( int ) cutwin_t.ve, ( int ) cutwin_t.he );
3964	config_set_str(CFG_SECTION_TV, "vpp.overscan.dtv", val_buf);
3965	//}
3966	#endif
3967	return CVpp::getInstance()->VPP_SetVideoCrop ( ( int ) cutwin_t.vs, ( int ) cutwin_t.hs, ( int ) cutwin_t.ve, ( int ) cutwin_t.he );
3968	}
3969
3970	tvin_cutwin_t CTv::Tv_FactoryGetOverscan ( int source_type, int fmt, int status_3d, int trans_fmt )
3971	{
3972	status_3d = status_3d;
3973	return CVpp::getInstance()->FactoryGetOverscan(source_type, fmt, Check2Dor3D(m_mode_3d, (tvin_trans_fmt_t)trans_fmt), trans_fmt);
3974	#if 0
3975	else {
3976	tvin_cutwin_t cutwin;
3977	int ret = 0;
3978	char tmp_buf[16];
3979	tmp_buf[0] = 0;
3980
3981	if ((ret |= cfg_get_one_item("vpp.overscan.dtv", ",", 0, tmp_buf)) == 0) {
3982	cutwin.vs = strtol(tmp_buf, NULL, 10);
3983	}
3984	if ((ret |= cfg_get_one_item("vpp.overscan.dtv", ",", 1, tmp_buf)) == 0) {
3985	cutwin.hs = strtol(tmp_buf, NULL, 10);
3986	}
3987	if ((ret |= cfg_get_one_item("vpp.overscan.dtv", ",", 2, tmp_buf)) == 0) {
3988	cutwin.ve = strtol(tmp_buf, NULL, 10);
3989	}
3990	if ((ret |= cfg_get_one_item("vpp.overscan.dtv", ",", 3, tmp_buf)) == 0) {
3991	cutwin.he = strtol(tmp_buf, NULL, 10);
3992	}
3993	LOGD("%s,%d: %d,%d,%d,%d", __FUNCTION__, __LINE__, ( int ) cutwin.vs, ( int ) cutwin.hs, ( int ) cutwin.ve, ( int ) cutwin.he);
3994	return cutwin;
3995	}
3996	#endif
3997	}
3998
3999	int CTv::Tv_ReplacePqDb(const char *newFilePath)
4000	{
4001	return CVpp::getInstance()->getPqData()->replacePqDb(newFilePath);
4002	}
4003
4004	int CTv::Tv_FactorySet_FBC_Brightness ( int value )
4005	{
4006	//int temp_value = (255*value)/100;
4007	int temp_value = value;
4008
4009	if (fbcIns != NULL) {
4010	fbcIns->cfbc_Set_Brightness(COMM_DEV_SERIAL, temp_value);
4011	return 0;
4012	}
4013	return -1;
4014	}
4015
4016	int CTv::Tv_FactoryGet_FBC_Brightness ( void )
4017	{
4018	int temp_value = 0;
4019	int data = 0;
4020
4021	if (fbcIns != NULL) {
4022	fbcIns->cfbc_Get_Brightness(COMM_DEV_SERIAL, &temp_value);
4023	//data = (temp_value*100)/255;
4024	data = temp_value;
4025	return data;
4026	}
4027	return 0;
4028	}
4029
4030	int CTv::Tv_FactorySet_FBC_Contrast ( int value )
4031	{
4032	//int temp_value = (255*value)/100;
4033	int temp_value = value;
4034
4035	if (fbcIns != NULL) {
4036	fbcIns->cfbc_Set_Contrast(COMM_DEV_SERIAL, temp_value);
4037	return 0;
4038	}
4039	return -1;
4040	}
4041
4042	int CTv::Tv_FactoryGet_FBC_Contrast ( void )
4043	{
4044	int temp_value = 0;
4045	int data = 0;
4046
4047	if (fbcIns != NULL) {
4048	fbcIns->cfbc_Get_Contrast(COMM_DEV_SERIAL, &temp_value);
4049	//data = (temp_value*100)/255;
4050	data = temp_value;
4051	return data;
4052	}
4053	return 0;
4054	}
4055
4056	int CTv::Tv_FactorySet_FBC_Saturation ( int value )
4057	{
4058	//int temp_value = (255*value)/100;
4059	int temp_value = value;
4060
4061	if (fbcIns != NULL) {
4062	fbcIns->cfbc_Set_Saturation(COMM_DEV_SERIAL, temp_value);
4063	return 0;
4064	}
4065	return -1;
4066	}
4067
4068	int CTv::Tv_FactoryGet_FBC_Saturation ( void )
4069	{
4070	int temp_value = 0;
4071	int data = 0;
4072
4073	if (fbcIns != NULL) {
4074	fbcIns->cfbc_Get_Saturation(COMM_DEV_SERIAL, &temp_value);
4075	//data = (temp_value*100)/255;
4076	data = temp_value;
4077	return data;
4078	}
4079	return 0;
4080	}
4081
4082	int CTv::Tv_FactorySet_FBC_HueColorTint ( int value )
4083	{
4084	//int temp_value = (255*value)/100;
4085	int temp_value = value;
4086
4087	if (fbcIns != NULL) {
4088	fbcIns->cfbc_Set_HueColorTint(COMM_DEV_SERIAL, temp_value);
4089	return 0;
4090	}
4091	return -1;
4092	}
4093
4094	int CTv::Tv_FactoryGet_FBC_HueColorTint ( void )
4095	{
4096	int temp_value = 0;
4097	int data = 0;
4098
4099	if (fbcIns != NULL) {
4100	fbcIns->cfbc_Get_HueColorTint(COMM_DEV_SERIAL, &temp_value);
4101	//data = (temp_value*100)/255;
4102	data = temp_value;
4103	return data;
4104	}
4105	return 0;
4106	}
4107
4108	int CTv::Tv_FactorySet_FBC_Backlight ( int value )
4109	{
4110	int temp_value = value;
4111	if (fbcIns != NULL) {
4112	temp_value = temp_value * 255 / 100;
4113	fbcIns->cfbc_Set_Backlight(COMM_DEV_SERIAL, temp_value);
4114	return 0;
4115	}
4116	return -1;
4117	}
4118
4119	int CTv::Tv_FactoryGet_FBC_Backlight ( void )
4120	{
4121	int temp_value = 0;
4122	int data = 0;
4123
4124	if (fbcIns != NULL) {
4125	fbcIns->cfbc_Get_Backlight(COMM_DEV_SERIAL, &temp_value);
4126	if (temp_value * 100 % 255 == 0)
4127	temp_value = temp_value * 100 / 255;
4128	else
4129	temp_value = temp_value * 100 / 255 + 1;
4130	data = temp_value;
4131	return data;
4132	}
4133
4134	return 0;
4135	}
4136
4137	int CTv::Tv_FactorySet_FBC_Auto_Backlight_OnOff( unsigned char status)
4138	{
4139	if (fbcIns != NULL) {
4140	return fbcIns->cfbc_Set_Auto_Backlight_OnOff(COMM_DEV_SERIAL, status);
4141	}
4142
4143	return -1;
4144	}
4145
4146	int CTv::Tv_FactoryGet_FBC_Auto_Backlight_OnOff( void )
4147	{
4148	int temp_status = 0;
4149
4150	if (fbcIns != NULL) {
4151	fbcIns->cfbc_Get_Auto_Backlight_OnOff(COMM_DEV_SERIAL, &temp_status);
4152	return temp_status;
4153	}
4154	return 0;
4155	}
4156
4157	int CTv::Tv_FactorySet_FBC_ELEC_MODE( int value )
4158	{
4159	if (fbcIns != NULL) {
4160	fbcIns->cfbc_Set_AUTO_ELEC_MODE(COMM_DEV_SERIAL, value);
4161	SSMSaveFBCELECmodeVal(value);
4162	return 0;
4163	}
4164	return -1;
4165	}
4166
4167	int CTv::Tv_FactoryGet_FBC_ELEC_MODE( void )
4168	{
4169	int val = 0;
4170	SSMReadFBCELECmodeVal(&val);
4171	return val;
4172	}
4173
4174	int CTv::Tv_FactorySet_FBC_BACKLIGHT_N360( int value )
4175	{
4176	SSMSaveFBCELECmodeVal(value);
4177	return -1;
4178	}
4179
4180	int CTv::Tv_FactoryGet_FBC_BACKLIGHT_N360( void )
4181	{
4182	int val = 0;
4183	SSMReadFBCELECmodeVal(&val);
4184	return val;
4185	}
4186
4187	int CTv::Tv_FactorySet_FBC_Thermal_State( int value )
4188	{
4189	if (fbcIns != NULL) {
4190	fbcIns->cfbc_Set_Thermal_state(COMM_DEV_SERIAL, value);
4191	return 0;
4192	}
4193
4194	return -1;
4195	}
4196
4197	int CTv::Tv_FactorySet_FBC_Picture_Mode ( int mode )
4198	{
4199	if (fbcIns != NULL) {
4200	fbcIns->cfbc_Set_Picture_Mode(COMM_DEV_SERIAL, mode);
4201	return 0;
4202	}
4203
4204	return -1;
4205	}
4206
4207	int CTv::Tv_FactoryGet_FBC_Picture_Mode ( void )
4208	{
4209	int mode = 0;
4210
4211	if (fbcIns != NULL) {
4212	fbcIns->cfbc_Get_Picture_Mode(COMM_DEV_SERIAL, &mode);
4213	return mode;
4214	}
4215	return 0;
4216	}
4217
4218	int CTv::Tv_FactorySet_FBC_Set_Test_Pattern ( int mode )
4219	{
4220	if (fbcIns != NULL) {
4221	fbcIns->cfbc_Set_Test_Pattern(COMM_DEV_SERIAL, mode);
4222	return 0;
4223	}
4224
4225	return -1;
4226	}
4227
4228	int CTv::Tv_FactoryGet_FBC_Get_Test_Pattern ( void )
4229	{
4230	int mode = 0;
4231
4232	if (fbcIns != NULL) {
4233	fbcIns->cfbc_Get_Test_Pattern(COMM_DEV_SERIAL, &mode);
4234	return mode;
4235	}
4236
4237	return 0;
4238	}
4239
4240	int CTv::Tv_FactorySet_FBC_Gain_Red( int value )
4241	{
4242	int temp_value = 0;
4243
4244	//temp_value = (value*255)/2047;
4245	//value 0 ~ 2047
4246	temp_value = value;
4247
4248	if (fbcIns != NULL) {
4249	fbcIns->cfbc_Set_Gain_Red(COMM_DEV_SERIAL, temp_value);
4250	return 0;
4251	}
4252
4253	return -1;
4254	}
4255
4256	int CTv::Tv_FactoryGet_FBC_Gain_Red ( void )
4257	{
4258	int temp_value = 0, value = 0;
4259
4260	if (fbcIns != NULL) {
4261	fbcIns->cfbc_Get_Gain_Red(COMM_DEV_SERIAL, &temp_value);
4262	//value 0 ~ 2047
4263	//value = (temp_value*2047)/255;
4264	value = temp_value;
4265
4266	return value;
4267	}
4268
4269	return 0;
4270	}
4271
4272	int CTv::Tv_FactorySet_FBC_Gain_Green( int value )
4273	{
4274	int temp_value = 0;
4275
4276	//temp_value = (value*255)/2047;
4277	//value 0 ~ 2047
4278	temp_value = value;
4279
4280	if (fbcIns != NULL) {
4281	fbcIns->cfbc_Set_Gain_Green(COMM_DEV_SERIAL, temp_value);
4282	return 0;
4283	}
4284
4285	return -1;
4286	}
4287
4288	int CTv::Tv_FactoryGet_FBC_Gain_Green ( void )
4289	{
4290	int temp_value = 0, value = 0;
4291
4292	if (fbcIns != NULL) {
4293	fbcIns->cfbc_Get_Gain_Green(COMM_DEV_SERIAL, &temp_value);
4294	//value 0 ~ 2047
4295	//value = (temp_value*2047)/255;
4296	value = temp_value;
4297
4298	return value;
4299	}
4300
4301	return 0;
4302	}
4303
4304	int CTv::Tv_FactoryGet_FBC_VIDEO_MUTE ( void )
4305	{
4306	if (fbcIns != NULL) {
4307	fbcIns->cfbc_Set_VMute(COMM_DEV_SERIAL, 1);
4308	}
4309
4310	return 0;
4311	}
4312
4313	int CTv::Tv_FactorySet_FBC_Gain_Blue( int value )
4314	{
4315	int temp_value = 0;
4316
4317	//temp_value = (value*255)/2047;
4318	//value 0 ~ 2047
4319	temp_value = value;
4320
4321	if (fbcIns != NULL) {
4322	fbcIns->cfbc_Set_Gain_Blue(COMM_DEV_SERIAL, temp_value);
4323	return 0;
4324	}
4325
4326	return -1;
4327	}
4328
4329	int CTv::Tv_FactoryGet_FBC_Gain_Blue ( void )
4330	{
4331	int temp_value = 0, value = 0;
4332
4333	if (fbcIns != NULL) {
4334	fbcIns->cfbc_Get_Gain_Blue(COMM_DEV_SERIAL, &temp_value);
4335	//value 0 ~ 2047
4336	//value = (temp_value*2047)/255;
4337	value = temp_value;
4338
4339	return value;
4340	}
4341
4342	return 0;
4343	}
4344
4345	int CTv::Tv_FactorySet_FBC_Offset_Red( int value )
4346	{
4347	//value -1024~+1023
4348	int temp_value = 0;
4349
4350	//temp_value = (value+1024)*255/2047;
4351	temp_value = value;
4352
4353	if (fbcIns != NULL) {
4354	fbcIns->cfbc_Set_Offset_Red(COMM_DEV_SERIAL, temp_value);
4355	return 0;
4356	}
4357
4358	return -1;
4359	}
4360
4361	int CTv::Tv_FactoryGet_FBC_Offset_Red ( void )
4362	{
4363	int temp_value = 0, value = 0;
4364
4365	if (fbcIns != NULL) {
4366	fbcIns->cfbc_Get_Offset_Red(COMM_DEV_SERIAL, &temp_value);
4367	//value -1024~+1023
4368	//value = (temp_value*2047)/255 - 1024;
4369	value = temp_value;
4370
4371	return value;
4372	}
4373
4374	return 0;
4375	}
4376
4377	int CTv::Tv_FactorySet_FBC_Offset_Green( int value )
4378	{
4379	//value -1024~+1023
4380	int temp_value = 0;
4381
4382	//temp_value = (value+1024)*255/2047;
4383	temp_value = value;
4384
4385	if (fbcIns != NULL) {
4386	fbcIns->cfbc_Set_Offset_Green(COMM_DEV_SERIAL, temp_value);
4387	return 0;
4388	}
4389
4390	return -1;
4391	}
4392
4393	int CTv::Tv_FactoryGet_FBC_Offset_Green ( void )
4394	{
4395	int temp_value = 0, value = 0;
4396
4397	if (fbcIns != NULL) {
4398	fbcIns->cfbc_Get_Offset_Green(COMM_DEV_SERIAL, &temp_value);
4399	//value -1024~+1023
4400	//value = (temp_value*2047)/255 - 1024;
4401	value = temp_value;
4402
4403	return value;
4404	}
4405
4406	return 0;
4407	}
4408
4409	int CTv::Tv_FactorySet_FBC_Offset_Blue( int value )
4410	{
4411	//value -1024~+1023
4412	int temp_value = 0;
4413
4414	//temp_value = (value+1024)*255/2047;
4415	temp_value = value;
4416
4417	if (fbcIns != NULL) {
4418	fbcIns->cfbc_Set_Offset_Blue(COMM_DEV_SERIAL, value);
4419	return 0;
4420	}
4421
4422	return -1;
4423	}
4424
4425	int CTv::Tv_FactoryGet_FBC_Offset_Blue ( void )
4426	{
4427	int temp_value = 0, value = 0;
4428
4429	if (fbcIns != NULL) {
4430	fbcIns->cfbc_Get_Offset_Blue(COMM_DEV_SERIAL, &temp_value);
4431	//value -1024~+1023
4432	//value = (temp_value*2047)/255 - 1024;
4433	value = temp_value;
4434
4435	return value;
4436	}
4437
4438	return 0;
4439	}
4440
4441	int CTv::Tv_FactoryGetWhiteBalanceRedGain(int source_type, int colortemp_mode)
4442	{
4443	int ret = -1;
4444	if (!mHdmiOutFbc) { // not use fbc store the white balance params
4445	LOGD("--------- call none fbc method ---------");
4446	ret = CVpp::getInstance()->FactoryGetColorTemp_Rgain(source_type, colortemp_mode);
4447	} else { //use fbc store the white balance params
4448	LOGD("--------- call fbc method ---------");
4449	ret = Tv_FactoryGetItemFromBatch((vpp_color_temperature_mode_t)colortemp_mode, 0);
4450	}
4451	return ret;
4452	}
4453
4454	int CTv::Tv_FactoryGetWhiteBalanceGreenGain(int source_type, int colortemp_mode)
4455	{
4456	int ret = -1;
4457	if (!mHdmiOutFbc) { // not use fbc store the white balance params
4458	ret = CVpp::getInstance()->FactoryGetColorTemp_Ggain(source_type, colortemp_mode);
4459	} else { //use fbc store the white balance params
4460	ret = Tv_FactoryGetItemFromBatch((vpp_color_temperature_mode_t)colortemp_mode, 1);
4461	}
4462	return ret;
4463	}
4464
4465	int CTv::Tv_FactoryGetWhiteBalanceBlueGain(int source_type, int colortemp_mode)
4466	{
4467	int ret = -1;
4468	if (!mHdmiOutFbc) { // not use fbc store the white balance params
4469	ret = CVpp::getInstance()->FactoryGetColorTemp_Bgain(source_type, colortemp_mode);
4470	} else { //use fbc store the white balance params
4471	ret = Tv_FactoryGetItemFromBatch((vpp_color_temperature_mode_t)colortemp_mode, 2);
4472	}
4473	return ret;
4474	}
4475
4476	int CTv::Tv_FactoryGetWhiteBalanceRedOffset(int source_type, int colortemp_mode)
4477	{
4478	int ret = -1;
4479	if (!mHdmiOutFbc) { // not use fbc store the white balance params
4480	ret = CVpp::getInstance()->FactoryGetColorTemp_Roffset(source_type, colortemp_mode);
4481	} else { //use fbc store the white balance params
4482	ret = Tv_FactoryGetItemFromBatch((vpp_color_temperature_mode_t)colortemp_mode, 3);
4483	}
4484	return ret;
4485	}
4486
4487	int CTv::Tv_FactoryGetWhiteBalanceGreenOffset(int source_type, int colortemp_mode)
4488	{
4489	int ret = -1;
4490	if (!mHdmiOutFbc) { // not use fbc store the white balance params
4491	ret = CVpp::getInstance()->FactoryGetColorTemp_Goffset(source_type, colortemp_mode);
4492	} else { //use fbc store the white balance params
4493	ret = Tv_FactoryGetItemFromBatch((vpp_color_temperature_mode_t)colortemp_mode, 4);
4494	}
4495	return ret;
4496	}
4497
4498	int CTv::Tv_FactoryGetWhiteBalanceBlueOffset(int source_type, int colortemp_mode)
4499	{
4500	int ret = -1;
4501	if (!mHdmiOutFbc) { // not use fbc store the white balance params
4502	ret = CVpp::getInstance()->FactoryGetColorTemp_Boffset(source_type, colortemp_mode);
4503	} else { //use fbc store the white balance params
4504	ret = Tv_FactoryGetItemFromBatch((vpp_color_temperature_mode_t)colortemp_mode, 5);
4505	}
4506	return ret;
4507	}
4508
4509	int CTv::Tv_FactorySetWhiteBalanceRedGain(int source_type, int colortemp_mode, int value)
4510	{
4511	int ret = -1;
4512	if (value < 0) {
4513	value = 0;
4514	} else if (value > 2047) {
4515	value = 2047;
4516	}
4517	if (!mHdmiOutFbc) { // not use fbc store the white balance params
4518	ret = CVpp::getInstance()->FactorySetColorTemp_Rgain(source_type, colortemp_mode, value);
4519	if (ret != -1) {
4520	LOGD("save the red gain to flash");
4521	ret = CVpp::getInstance()->FactorySaveColorTemp_Rgain(source_type, colortemp_mode, value);
4522	}
4523	} else { //use fbc store the white balance params
4524	value = Tv_FactoryWhiteBalanceFormatInputFbcGainParams(value);
4525	ret = Tv_FactorySet_FBC_Gain_Red(value);
4526	}
4527	return ret;
4528	}
4529
4530	int CTv::Tv_FactorySetWhiteBalanceGreenGain(int source_type, int colortemp_mode, int value)
4531	{
4532	int ret = -1;
4533	if (value < 0) {
4534	value = 0;
4535	} else if (value > 2047) {
4536	value = 2047;
4537	}
4538	if (!mHdmiOutFbc) { // not use fbc store the white balance params
4539	ret = CVpp::getInstance()->FactorySetColorTemp_Ggain(source_type, colortemp_mode, value);
4540	if (ret != -1) {
4541	LOGD("save the green gain to flash");
4542	ret = CVpp::getInstance()->FactorySaveColorTemp_Ggain(source_type, colortemp_mode, value);
4543	}
4544	} else { //use fbc store the white balance params
4545	value = Tv_FactoryWhiteBalanceFormatInputFbcGainParams(value);
4546	ret = Tv_FactorySet_FBC_Gain_Green(value);
4547	}
4548	return ret;
4549	}
4550
4551	int CTv::Tv_FactorySetWhiteBalanceBlueGain(int source_type, int colortemp_mode, int value)
4552	{
4553	int ret = -1;
4554	if (value < 0) {
4555	value = 0;
4556	} else if (value > 2047) {
4557	value = 2047;
4558	}
4559	if (!mHdmiOutFbc) { // not use fbc store the white balance params
4560	ret = CVpp::getInstance()->FactorySetColorTemp_Bgain(source_type, colortemp_mode, value);
4561	if (ret != -1) {
4562	LOGD("save the blue gain to flash");
4563	ret = CVpp::getInstance()->FactorySaveColorTemp_Bgain(source_type, colortemp_mode, value);
4564	}
4565	} else { //use fbc store the white balance params
4566	value = Tv_FactoryWhiteBalanceFormatInputFbcGainParams(value);
4567	ret = Tv_FactorySet_FBC_Gain_Blue(value);
4568	}
4569	return ret;
4570	}
4571
4572	int CTv::Tv_FactorySetWhiteBalanceRedOffset(int source_type, int colortemp_mode, int value)
4573	{
4574	int ret = -1;
4575	if (value < -1024) {
4576	value = -1024;
4577	} else if (value > 1023) {
4578	value = 1023;
4579	}
4580	if (!mHdmiOutFbc) { // not use fbc store the white balance params
4581	ret = CVpp::getInstance()->FactorySetColorTemp_Roffset(source_type, colortemp_mode, value);
4582	if (ret != -1) {
4583	LOGD("save the red offset to flash");
4584	ret = CVpp::getInstance()->FactorySaveColorTemp_Roffset(source_type, colortemp_mode, value);
4585	}
4586	} else { //use fbc store the white balance params
4587	value = Tv_FactoryWhiteBalanceFormatInputFbcOffsetParams(value);
4588	ret = Tv_FactorySet_FBC_Offset_Red(value);
4589	}
4590	return ret;
4591	}
4592
4593	int CTv::Tv_FactorySetWhiteBalanceGreenOffset(int source_type, int colortemp_mode, int value)
4594	{
4595	int ret = -1;
4596	if (value < -1024) {
4597	value = -1024;
4598	} else if (value > 1023) {
4599	value = 1023;
4600	}
4601	if (!mHdmiOutFbc) { // not use fbc store the white balance params
4602	ret = CVpp::getInstance()->FactorySetColorTemp_Goffset(source_type, colortemp_mode, value);
4603	if (ret != -1) {
4604	LOGD("save the green offset to flash");
4605	ret = CVpp::getInstance()->FactorySaveColorTemp_Goffset(source_type, colortemp_mode, value);
4606	}
4607	} else { //use fbc store the white balance params
4608	value = Tv_FactoryWhiteBalanceFormatInputFbcOffsetParams(value);
4609	ret = Tv_FactorySet_FBC_Offset_Green(value);
4610	}
4611	return ret;
4612	}
4613
4614	int CTv::Tv_FactorySetWhiteBalanceBlueOffset(int source_type, int colortemp_mode, int value)
4615	{
4616	int ret = -1;
4617	if (value < -1024) {
4618	value = -1024;
4619	} else if (value > 1023) {
4620	value = 1023;
4621	}
4622	if (!mHdmiOutFbc) { // not use fbc store the white balance params
4623	ret = CVpp::getInstance()->FactorySetColorTemp_Boffset(source_type, colortemp_mode, value);
4624	if (ret != -1) {
4625	LOGD("save the blue offset to flash");
4626	ret = CVpp::getInstance()->FactorySaveColorTemp_Boffset(source_type, colortemp_mode, value);
4627	}
4628	} else { //use fbc store the white balance params
4629	value = Tv_FactoryWhiteBalanceFormatInputFbcOffsetParams(value);
4630	ret = Tv_FactorySet_FBC_Offset_Blue(value);
4631	}
4632	return ret;
4633	}
4634
4635	int CTv::Tv_FactorySetWhiteBalanceColorTempMode(int source_type, int colortemp_mode, int is_save)
4636	{
4637	int ret = -1;
4638	if (!mHdmiOutFbc) { // not use fbc store the white balance params
4639	ret = CVpp::getInstance()->SetColorTemperature((vpp_color_temperature_mode_t)colortemp_mode, (tv_source_input_type_t)source_type, is_save);
4640	} else { //use fbc store the white balance params
4641	ret = Tv_FactorySet_FBC_ColorTemp_Mode(colortemp_mode);
4642	}
4643	return ret;
4644	}
4645
4646	int CTv::Tv_FactoryGetWhiteBalanceColorTempMode(int source_type )
4647	{
4648	int ret = -1;
4649	if (!mHdmiOutFbc) { // not use fbc store the white balance params
4650	ret = CVpp::getInstance()->GetColorTemperature((tv_source_input_type_t)source_type);
4651	} else { //use fbc store the white balance params
4652	ret = Tv_FactoryGet_FBC_ColorTemp_Mode();
4653	}
4654	return ret;
4655	}
4656
4657	int CTv::Tv_FactoryWhiteBalanceFormatInputFbcGainParams(int value)
4658	{
4659	int ret = 1024;
4660	if (value < 0) {
4661	ret = 0;
4662	} else if (value > 2047) {
4663	ret = 2047;
4664	} else {
4665	ret = value;
4666	}
4667	ret = ret >> 3;
4668	return ret;
4669	}
4670
4671	int CTv::Tv_FactoryWhiteBalanceFormatInputFbcOffsetParams(int value)
4672	{
4673	int ret = 0;
4674	if (value < -1024) {
4675	ret = -1024;
4676	} else if (value > 1023) {
4677	ret = 1023;
4678	} else {
4679	ret = value;
4680	}
4681	ret += 1024;
4682	ret = ret >> 3;
4683	return ret;
4684	}
4685
4686	int CTv::Tv_FactoryWhiteBalanceFormatOutputFbcOffsetParams(int value)
4687	{
4688	if (value == 255) {
4689	value = 1023;
4690	} else {
4691	value = value << 3;
4692	value -= 1024;
4693	}
4694	return value;
4695	}
4696
4697	int CTv::Tv_FactoryWhiteBalanceFormatOutputFbcGainParams(int value)
4698	{
4699	value = value << 3;
4700	if (value < 0) {
4701	value = 0;
4702	} else if (value > 2047) {
4703	value = 2047;
4704	}
4705	return value;
4706	}
4707
4708	int CTv::Tv_FactorySaveWhiteBalancePramas(int source_type, int tempmode, int r_gain, int g_gain, int b_gain, int r_offset, int g_offset, int b_offset)
4709	{
4710	int ret = 0;
4711	if (!mHdmiOutFbc) { // not use fbc store the white balance params
4712	CVpp::getInstance()->SaveColorTemp((vpp_color_temperature_mode_t) tempmode, (tv_source_input_type_t) source_type);
4713	CVpp::getInstance()->FactorySaveColorTemp_Rgain(source_type, tempmode, r_gain);
4714	CVpp::getInstance()->FactorySaveColorTemp_Ggain(source_type, tempmode, g_gain);
4715	CVpp::getInstance()->FactorySaveColorTemp_Bgain(source_type, tempmode, b_gain);
4716	CVpp::getInstance()->FactorySaveColorTemp_Roffset(source_type, tempmode, r_offset);
4717	CVpp::getInstance()->FactorySaveColorTemp_Goffset(source_type, tempmode, g_offset);
4718	CVpp::getInstance()->FactorySaveColorTemp_Boffset(source_type, tempmode, b_offset);
4719	} else { //use fbc store the white balance params
4720	tcon_rgb_ogo_t params;
4721
4722	params.r_gain = Tv_FactoryWhiteBalanceFormatInputFbcGainParams(r_gain);
4723	params.g_gain = Tv_FactoryWhiteBalanceFormatInputFbcGainParams(g_gain);
4724	params.b_gain = Tv_FactoryWhiteBalanceFormatInputFbcGainParams(b_gain);
4725	params.r_post_offset = Tv_FactoryWhiteBalanceFormatInputFbcOffsetParams(r_offset);
4726	params.g_post_offset = Tv_FactoryWhiteBalanceFormatInputFbcOffsetParams(g_offset);
4727	params.b_post_offset = Tv_FactoryWhiteBalanceFormatInputFbcOffsetParams(b_offset);
4728	ret = Tv_FactorySet_FBC_ColorTemp_Batch((vpp_color_temperature_mode_t)tempmode, params);
4729	}
4730	return ret;
4731	}
4732
4733	/**
4734	* The color temperature enum order is diffrent bettewn G9 and Fbc, so we have to make a mapping
4735	**/
4736	int CTv::Tv_FactoryWhiteBalanceColorTempMappingG92Fbc(int Tempmode)
4737	{
4738	int ret = Tempmode;
4739	switch (Tempmode) {
4740	case 0: //standard
4741	ret = 1;
4742	break;
4743	case 1: //warm
4744	ret = 2;
4745	break;
4746	case 2: //cold
4747	ret = 0;
4748	break;
4749	default:
4750	break;
4751	}
4752	return ret;
4753	}
4754
4755	/**
4756	* The color temperature enum order is diffrent bettewn G9 and Fbc, so we have to make a mapping
4757	**/
4758	int CTv::Tv_FactoryWhiteBalanceColorTempMappingFbc2G9(int Tempmode)
4759	{
4760	int ret = Tempmode;
4761	switch (Tempmode) {
4762	case 0: //cold
4763	ret = 2;
4764	break;
4765	case 1: //standard
4766	ret = 0;
4767	break;
4768	case 2: //warm
4769	ret = 1;
4770	break;
4771	default:
4772	break;
4773	}
4774	return ret;
4775	}
4776
4777	int CTv::Tv_SetTestPattern(int value)
4778	{
4779	int ret = -1;
4780	if (fbcIns != NULL) {
4781	LOGD("%s, value is %d\n", __FUNCTION__, value);
4782	ret = fbcIns->cfbc_TestPattern_Select(COMM_DEV_SERIAL, value);
4783	}
4784
4785	return ret;
4786	}
4787
4788	int CTv::Tv_FactoryCloseWhiteBalanceGrayPattern()
4789	{
4790	int useFbc = 0;
4791	int ret = -1;
4792	if (!mHdmiOutFbc) { // not use fbc store the white balance params
4793	ret = CVpp::getInstance()->VPP_SetGrayPattern(0);
4794	} else { //use fbc store the white balance params
4795	ret = Tv_FactoryClose_FBC_GrayPattern();
4796	}
4797	return ret;
4798	}
4799
4800	int CTv::Tv_FactoryOpenWhiteBalanceGrayPattern()
4801	{
4802	int ret = 0;
4803	if (mHdmiOutFbc) { //use fbc store the white balance params
4804	ret = Tv_FactoryOpen_FBC_GrayPattern();
4805	}
4806	return ret;
4807	}
4808
4809	int CTv::Tv_FactorySetWhiteBalanceGrayPattern(int value)
4810	{
4811	int ret = -1;
4812	if (!mHdmiOutFbc) {
4813	ret = CVpp::getInstance()->VPP_SetGrayPattern(value);
4814	} else {
4815	ret = Tv_FactorySet_FBC_GrayPattern(value);
4816	}
4817	return ret;
4818	}
4819
4820	int CTv:: Tv_FactoryGetWhiteBalanceGrayPattern()
4821	{
4822	int ret = -1;
4823	if (!mHdmiOutFbc) {
4824	ret = CVpp::getInstance()->VPP_GetGrayPattern();
4825	}
4826	return ret;
4827	}
4828
4829	int CTv::Tv_FactorySet_FBC_GrayPattern(int value)
4830	{
4831	int ret = -1;
4832	unsigned char grayValue = 0;
4833	if (value > 255) {
4834	grayValue = 255;
4835	} else if (value < 0) {
4836	grayValue = 0;
4837	} else {
4838	grayValue = (unsigned char)(0xFF & value);
4839	}
4840	if (fbcIns != NULL) {
4841	ret = fbcIns->cfbc_WhiteBalance_SetGrayPattern(COMM_DEV_SERIAL, grayValue);
4842	}
4843	return ret;
4844	}
4845
4846	int CTv::Tv_FactoryOpen_FBC_GrayPattern()
4847	{
4848	int ret = -1;
4849	if (fbcIns != NULL) {
4850	ret = fbcIns->cfbc_WhiteBalance_GrayPattern_OnOff(COMM_DEV_SERIAL, 0);
4851	}
4852	return ret;
4853	}
4854
4855	int CTv::Tv_FactoryClose_FBC_GrayPattern()
4856	{
4857	int ret = -1;
4858	if (fbcIns != NULL) {
4859	ret = fbcIns->cfbc_WhiteBalance_GrayPattern_OnOff(COMM_DEV_SERIAL, 1);
4860	}
4861	return ret;
4862	}
4863
4864	int CTv::Tv_FactorySet_FBC_ColorTemp_Mode( int mode )
4865	{
4866	if (fbcIns != NULL) {
4867	fbcIns->cfbc_Set_ColorTemp_Mode(COMM_DEV_SERIAL, mode);
4868	return 0;
4869	}
4870
4871	return -1;
4872	}
4873
4874	int CTv::Tv_FactoryGet_FBC_ColorTemp_Mode ( void )
4875	{
4876	int temp_mode = 0;
4877
4878	if (fbcIns != NULL) {
4879	fbcIns->cfbc_Get_ColorTemp_Mode(COMM_DEV_SERIAL, &temp_mode);
4880	return temp_mode;
4881	}
4882
4883	return -1;
4884	}
4885
4886	int CTv::Tv_FactorySet_FBC_ColorTemp_Mode_N360( int mode )
4887	{
4888	if (fbcIns != NULL) {
4889	fbcIns->cfbc_Set_ColorTemp_Mode(COMM_DEV_SERIAL, mode);
4890	SSMSaveFBCN360ColorTempVal(mode);
4891	return 0;
4892	}
4893
4894	return -1;
4895	}
4896
4897	int CTv::Tv_FactoryGet_FBC_ColorTemp_Mode_N360 ( void )
4898	{
4899	int temp_mode = 0;
4900	SSMReadFBCN360ColorTempVal(&temp_mode);
4901	return temp_mode;
4902	}
4903
4904	int CTv::Tv_FactorySet_FBC_LockN_state(int value)
4905	{
4906	LOGE ("Tv_FactorySet_FBC_LockN_state %d!!!\n", value);
4907	if (fbcIns != NULL) {
4908	fbcIns->cfbc_Set_LockN_state(COMM_DEV_SERIAL, value);
4909	return 0;
4910	}
4911	return -1;
4912	}
4913
4914	int CTv::Tv_FactorySet_FBC_WB_Initial( int status )
4915	{
4916	if (fbcIns != NULL) {
4917	fbcIns->cfbc_Set_WB_Initial(COMM_DEV_SERIAL, status);
4918	return 0;
4919	}
4920
4921	return -1;
4922	}
4923
4924	int CTv::Tv_FactoryGet_FBC_WB_Initial ( void )
4925	{
4926	int temp_status = 0;
4927
4928	if (fbcIns != NULL) {
4929	fbcIns->cfbc_Get_WB_Initial(COMM_DEV_SERIAL, &temp_status);
4930	return temp_status;
4931	}
4932
4933	return 0;
4934	}
4935
4936	int CTv::Tv_FactorySet_FBC_ColorTemp_Batch(vpp_color_temperature_mode_t Tempmode, tcon_rgb_ogo_t params)
4937	{
4938	unsigned char mode = 0, r_gain, g_gain, b_gain, r_offset, g_offset, b_offset;
4939	switch (Tempmode) {
4940	case VPP_COLOR_TEMPERATURE_MODE_STANDARD:
4941	mode = 1; //COLOR_TEMP_STD
4942	break;
4943	case VPP_COLOR_TEMPERATURE_MODE_WARM:
4944	mode = 2; //COLOR_TEMP_WARM
4945	break;
4946	case VPP_COLOR_TEMPERATURE_MODE_COLD:
4947	mode = 0; //COLOR_TEMP_COLD
4948	break;
4949	case VPP_COLOR_TEMPERATURE_MODE_USER:
4950	mode = 3; //COLOR_TEMP_USER
4951	break;
4952	default:
4953	break;
4954	}
4955	r_gain = (params.r_gain * 255) / 2047; // u1.10, range 0~2047, default is 1024 (1.0x)
4956	g_gain = (params.g_gain * 255) / 2047;
4957	b_gain = (params.b_gain * 255) / 2047;
4958	r_offset = (params.r_post_offset + 1024) * 255 / 2047; // s11.0, range -1024~+1023, default is 0
4959	g_offset = (params.g_post_offset + 1024) * 255 / 2047;
4960	b_offset = (params.b_post_offset + 1024) * 255 / 2047;
4961	LOGD ( "~Tv_FactorySet_FBC_ColorTemp_Batch##%d,%d,%d,%d,%d,%d,##", r_gain, g_gain, b_gain, r_offset, g_offset, b_offset );
4962
4963	if (fbcIns != NULL) {
4964	fbcIns->cfbc_Set_WB_Batch(COMM_DEV_SERIAL, mode, r_gain, g_gain, b_gain, r_offset, g_offset, b_offset);
4965	return 0;
4966	}
4967
4968	return -1;
4969	}
4970
4971	int CTv::Tv_FactoryGet_FBC_ColorTemp_Batch ( vpp_color_temperature_mode_t Tempmode, tcon_rgb_ogo_t *params )
4972	{
4973	unsigned char mode = 0, r_gain, g_gain, b_gain, r_offset, g_offset, b_offset;
4974	switch (Tempmode) {
4975	case VPP_COLOR_TEMPERATURE_MODE_STANDARD:
4976	mode = 1; //COLOR_TEMP_STD
4977	break;
4978	case VPP_COLOR_TEMPERATURE_MODE_WARM:
4979	mode = 2; //COLOR_TEMP_WARM
4980	break;
4981	case VPP_COLOR_TEMPERATURE_MODE_COLD:
4982	mode = 0; //COLOR_TEMP_COLD
4983	break;
4984	case VPP_COLOR_TEMPERATURE_MODE_USER:
4985	mode = 3; //COLOR_TEMP_USER
4986	break;
4987	default:
4988	break;
4989	}
4990
4991	if (fbcIns != NULL) {
4992	fbcIns->cfbc_Get_WB_Batch(COMM_DEV_SERIAL, mode, &r_gain, &g_gain, &b_gain, &r_offset, &g_offset, &b_offset);
4993	LOGD ( "~Tv_FactoryGet_FBC_ColorTemp_Batch##%d,%d,%d,%d,%d,%d,##", r_gain, g_gain, b_gain, r_offset, g_offset, b_offset );
4994
4995	params->r_gain = (r_gain * 2047) / 255;
4996	params->g_gain = (g_gain * 2047) / 255;
4997	params->b_gain = (b_gain * 2047) / 255;
4998	params->r_post_offset = (r_offset * 2047) / 255 - 1024;
4999	params->g_post_offset = (g_offset * 2047) / 255 - 1024;
5000	params->b_post_offset = (b_offset * 2047) / 255 - 1024;
5001	return 0;
5002	}
5003
5004	return -1;
5005	}
5006
5007	int CTv::Tv_FactorySet_WB_G9_To_FBC( vpp_color_temperature_mode_t Tempmode, tcon_rgb_ogo_t params )
5008	{
5009	Tv_FactorySet_FBC_ColorTemp_Batch(Tempmode, params);
5010	return 0;
5011	}
5012
5013	int CTv::Tv_FactoryGet_WB_G9_To_FBC ( vpp_color_temperature_mode_t Tempmode, tcon_rgb_ogo_t *params )
5014	{
5015	int temp_status = 0;
5016	Tv_FactoryGet_FBC_ColorTemp_Batch(Tempmode, params);
5017	return temp_status;
5018	}
5019
5020	int CTv::Tv_FactoryGetItemFromBatch(vpp_color_temperature_mode_t colortemp_mode, int item)
5021	{
5022	tcon_rgb_ogo_t params;
5023	int ret = 0;
5024
5025	Tv_FactoryGet_FBC_ColorTemp_Batch((vpp_color_temperature_mode_t)colortemp_mode, &params);
5026	switch (item) {
5027	case 0:
5028	ret = Tv_FactoryWhiteBalanceFormatOutputFbcGainParams(params.r_gain);
5029	break;
5030	case 1:
5031	ret = Tv_FactoryWhiteBalanceFormatOutputFbcGainParams(params.g_gain);
5032	break;
5033	case 2:
5034	ret = Tv_FactoryWhiteBalanceFormatOutputFbcGainParams(params.b_gain);
5035	break;
5036	case 3:
5037	ret = Tv_FactoryWhiteBalanceFormatOutputFbcOffsetParams(params.r_post_offset);
5038	break;
5039	case 4:
5040	ret = Tv_FactoryWhiteBalanceFormatOutputFbcOffsetParams(params.g_post_offset);
5041	break;
5042	case 5:
5043	ret = Tv_FactoryWhiteBalanceFormatOutputFbcOffsetParams(params.b_post_offset);
5044	break;
5045	default:
5046	ret = 0;
5047	}
5048	return ret;
5049	}
5050
5051	int CTv::Tv_FactorySet_FBC_CM_OnOff( unsigned char status )
5052	{
5053	if (fbcIns != NULL) {
5054	fbcIns->cfbc_Set_CM(COMM_DEV_SERIAL, status);
5055	return 0;
5056	}
5057
5058	return -1;
5059	}
5060
5061	int CTv::Tv_FactoryGet_FBC_CM_OnOff (void)
5062	{
5063	int temp_status = 0;
5064
5065	if (fbcIns != NULL) {
5066	fbcIns->cfbc_Get_CM(COMM_DEV_SERIAL, &temp_status);
5067	return temp_status;
5068	}
5069
5070	return 0;
5071	}
5072
5073	int CTv::Tv_FactorySet_FBC_DNLP_OnOff( unsigned char status )
5074	{
5075	if (fbcIns != NULL) {
5076	fbcIns->cfbc_Set_DNLP(COMM_DEV_SERIAL, status);
5077	return 0;
5078	}
5079
5080	return -1;
5081	}
5082
5083	int CTv::Tv_FactoryGet_FBC_DNLP_OnOff (void)
5084	{
5085	int temp_status = 0;
5086
5087	if (fbcIns != NULL) {
5088	fbcIns->cfbc_Get_DNLP(COMM_DEV_SERIAL, &temp_status);
5089	return temp_status;
5090	}
5091
5092	return 0;
5093	}
5094
5095	int CTv::Tv_FactorySet_FBC_Gamma_OnOff( unsigned char status )
5096	{
5097	if (fbcIns != NULL) {
5098	fbcIns->cfbc_Set_Gamma(COMM_DEV_SERIAL, status);
5099	return 0;
5100	}
5101
5102	return -1;
5103	}
5104
5105	int CTv::Tv_FactoryGet_FBC_Gamma_OnOff (void)
5106	{
5107	int temp_status = 0;
5108
5109	if (fbcIns != NULL) {
5110	fbcIns->cfbc_Get_Gamma(COMM_DEV_SERIAL, &temp_status);
5111	return temp_status;
5112	}
5113
5114	return 0;
5115	}
5116
5117	int CTv::Tv_FactorySet_FBC_WhiteBalance_OnOff( unsigned char status )
5118	{
5119	if (fbcIns != NULL) {
5120	fbcIns->cfbc_Set_WhiteBalance_OnOff(COMM_DEV_SERIAL, status);
5121	return 0;
5122	}
5123
5124	return -1;
5125	}
5126
5127	int CTv::Tv_FactoryGet_FBC_WhiteBalance_OnOff (void)
5128	{
5129	int temp_status = 0;
5130
5131	if (fbcIns != NULL) {
5132	fbcIns->cfbc_Get_WhiteBalance_OnOff(COMM_DEV_SERIAL, &temp_status);
5133	return temp_status;
5134	}
5135
5136	return 0;
5137	}
5138
5139	int CTv::Tv_FactorySet_FBC_backlight_onoff ( int value )
5140	{
5141	if (fbcIns != NULL) {
5142	fbcIns->cfbc_Set_backlight_onoff(COMM_DEV_SERIAL, value);
5143	return 0;
5144	}
5145
5146	return -1;
5147	}
5148
5149	int CTv::Tv_FactoryGet_FBC_backlight_onoff ( void )
5150	{
5151	int temp_value = 0;
5152
5153	if (fbcIns != NULL) {
5154	fbcIns->cfbc_Get_backlight_onoff(COMM_DEV_SERIAL, &temp_value);
5155	return temp_value;
5156	}
5157
5158	return 0;
5159	}
5160
5161	int CTv::Tv_FactorySet_FBC_LVDS_SSG_Set( int value )
5162	{
5163	if (fbcIns != NULL) {
5164	fbcIns->cfbc_Set_LVDS_SSG_Set(COMM_DEV_SERIAL, value);
5165	return 0;
5166	}
5167
5168	return -1;
5169	}
5170
5171	int CTv::Tv_FactorySet_FBC_LightSensor_Status_N310 ( int value )
5172	{
5173	if (fbcIns != NULL) {
5174	fbcIns->cfbc_Set_LightSensor_N310(COMM_DEV_SERIAL, value);
5175	SSMSaveFBCN310LightsensorVal(value);
5176	return 0;
5177	}
5178
5179	return -1;
5180	}
5181
5182	int CTv::Tv_FactoryGet_FBC_LightSensor_Status_N310 ( void )
5183	{
5184	int data = 0;
5185	if (fbcIns != NULL) {
5186	SSMReadFBCN310LightsensorVal(&data);
5187	return data;
5188	}
5189
5190	return 0;
5191	}
5192
5193	int CTv::Tv_FactorySet_FBC_Dream_Panel_Status_N310 ( int value )
5194	{
5195	if (fbcIns != NULL) {
5196	fbcIns->cfbc_Set_Dream_Panel_N310(COMM_DEV_SERIAL, value);
5197	SSMSaveFBCN310Dream_PanelVal(value);
5198	return 0;
5199	}
5200
5201	return -1;
5202	}
5203
5204	int CTv::Tv_FactoryGet_FBC_Dream_Panel_Status_N310 ( void )
5205	{
5206	int data = 0;
5207	if (fbcIns != NULL) {
5208	SSMReadFBCN310Dream_PanelVal(&data);
5209	return data;
5210	}
5211
5212	return 0;
5213	}
5214
5215	int CTv::Tv_FactorySet_FBC_MULT_PQ_Status_N310 ( int value )
5216	{
5217	if (fbcIns != NULL) {
5218	fbcIns->cfbc_Set_MULT_PQ_N310(COMM_DEV_SERIAL, value);
5219	SSMSaveFBCN310MULT_PQVal(value);
5220	return 0;
5221	}
5222
5223	return -1;
5224	}
5225
5226	int CTv::Tv_FactoryGet_FBC_MULT_PQ_Status_N310 ( void )
5227	{
5228	int data = 0;
5229
5230	if (fbcIns != NULL) {
5231	SSMReadFBCN310MULT_PQVal(&data);
5232	return data;
5233	}
5234
5235	return 0;
5236	}
5237
5238	int CTv::Tv_FactorySet_FBC_MEMC_Status_N310 ( int value )
5239	{
5240	if (fbcIns != NULL) {
5241	fbcIns->cfbc_Set_MEMC_N310(COMM_DEV_SERIAL, value);
5242	SSMSaveFBCN310MEMCVal(value);
5243	return 0;
5244	}
5245
5246	return -1;
5247	}
5248
5249	int CTv::Tv_FactoryGet_FBC_MEMC_Status_N310 ( void )
5250	{
5251	int data = 0;
5252	if (fbcIns != NULL) {
5253	SSMReadFBCN310MEMCVal(&data);
5254	return data;
5255	}
5256
5257	return -1;
5258	}
5259
5260	int CTv::Tv_FactorySet_FBC_ColorTemp_Mode_N310( int mode )
5261	{
5262	//int colorTemp = 0;
5263	if (fbcIns != NULL) {
5264	//colorTemp = Tv_FactoryWhiteBalanceColorTempMappingG92Fbc(mode);
5265	fbcIns->cfbc_Set_ColorTemp_Mode(COMM_DEV_SERIAL, mode);
5266	SSMSaveFBCN310ColorTempVal(mode);
5267	return 0;
5268	}
5269
5270	return -1;
5271	}
5272
5273	int CTv::Tv_FactoryGet_FBC_ColorTemp_Mode_N310 ( void )
5274	{
5275	int mode = 0;
5276	if (fbcIns != NULL) {
5277	SSMReadFBCN310ColorTempVal(&mode);
5278	//mode = Tv_FactoryWhiteBalanceColorTempMappingFbc2G9(temp_mode);
5279
5280	return mode;
5281	}
5282	return -1;
5283	}
5284
5285	int CTv::Tv_FactorySet_FBC_Backlight_N310 ( int value )
5286	{
5287	if (fbcIns != NULL) {
5288	fbcIns->cfbc_Set_Backlight(COMM_DEV_SERIAL, value);
5289	SSMSaveFBCN310BackLightVal(value);
5290	return 0;
5291	}
5292
5293	return -1;
5294	}
5295
5296	int CTv::Tv_FactoryGet_FBC_Backlight_N310 ( void )
5297	{
5298	int val = 0;
5299
5300	if (fbcIns != NULL) {
5301	SSMReadFBCN310BackLightVal(&val);
5302	return val;
5303	}
5304
5305	return -1;
5306	}
5307
5308	int CTv::Tv_FactorySet_FBC_Bluetooth_IIS_N310 ( int value )
5309	{
5310	if (fbcIns != NULL) {
5311	fbcIns->cfbc_Set_Bluetooth_IIS_onoff(COMM_DEV_SERIAL, value);
5312	return 0;
5313	}
5314
5315	return -1;
5316	}
5317
5318	int CTv::Tv_FactoryGet_FBC_Bluetooth_IIS_N310 ( void )
5319	{
5320	int temp_value = 0;
5321
5322	if (fbcIns != NULL) {
5323	fbcIns->cfbc_Get_Bluetooth_IIS_onoff(COMM_DEV_SERIAL, &temp_value);
5324	return temp_value;
5325	}
5326
5327	return 0;
5328	}
5329
5330	int CTv::Tv_FactorySet_FBC_Led_N310 ( int val_1, int val_2, int val_3 )
5331	{
5332	int val = 0;
5333
5334	if (fbcIns != NULL) {
5335	val = fbcIns->cfbc_Set_Led_onoff(COMM_DEV_SERIAL, val_1, val_2, val_3);
5336	return val;
5337	}
5338
5339	return -1;
5340	}
5341
5342	int CTv::Tv_FactorySet_VbyOne_Spread_Spectrum_N311 ( int value )
5343	{
5344	if (fbcIns != NULL) {
5345	return -1;
5346	} else {
5347	LOGD("%s, Set spectrum for T868 V-by-one....%d....\n", __FUNCTION__ , value);
5348	SSMSaveN311_VbyOne_Spread_Spectrum_Val(value);
5349
5350	switch (value) {
5351	case 0:
5352	//SetFileAttrValue ( SYS_DROILOGIC_DEBUG ,"w 0x135c5091 c 0x10ca");
5353	//SetFileAttrValue ( SYS_DROILOGIC_DEBUG ,"w 0x801da72c c 0x10cb");
5354	break;
5355	case 1:
5356	SetFileAttrValue ( SYS_DROILOGIC_DEBUG, "w 0x1ba05091 c 0x10ca");
5357	SetFileAttrValue ( SYS_DROILOGIC_DEBUG, "w 0x80bda72c c 0x10cb");
5358	break;
5359	default:
5360	LOGD("%s, Set spectrum for T868 V-by-one....%d....\n", __FUNCTION__ , value);
5361	break;
5362	}
5363
5364	return 0;
5365	}
5366	}
5367
5368	int CTv::Tv_FactoryGet_VbyOne_Spread_Spectrum_N311 ( void )
5369	{
5370	int val = 0;
5371	if (fbcIns != NULL) {
5372	return -1;
5373	} else {
5374	SSMReadN311_VbyOne_Spread_Spectrum_Val(&val);
5375	return val;
5376	}
5377	}
5378
5379	int CTv::Tv_FactorySet_FBC_AP_STANDBY_N310 ( int value )
5380	{
5381	if (fbcIns != NULL) {
5382	fbcIns->cfbc_Set_AP_STANDBY_N310(COMM_DEV_SERIAL, value);
5383	return 0;
5384	}
5385
5386	return -1;
5387	}
5388
5389	int CTv::Tv_FactoryGet_FBC_AP_STANDBY_N310( void )
5390	{
5391	int temp_value = 0;
5392
5393	if (fbcIns != NULL) {
5394	fbcIns->cfbc_Get_AP_STANDBY_N310(COMM_DEV_SERIAL, &temp_value);
5395	return temp_value;
5396	}
5397
5398	return 0;
5399	}
5400
5401	int CTv::Tv_FactorySet_Uboot_Stage(int value)
5402	{
5403	if (fbcIns != NULL) {
5404	fbcIns->cfbc_Set_Fbc_Uboot_Stage(COMM_DEV_SERIAL, value);
5405	return 0;
5406	}
5407
5408	return -1;
5409	}
5410
5411	//audio
5412	void CTv::TvAudioOpen()
5413	{
5414	SetAudioAVOutMute(CC_AUDIO_UNMUTE);
5415	SetAudioSPDIFMute(CC_AUDIO_UNMUTE);
5416	project_info_t tmp_info;
5417	if (GetProjectInfo(&tmp_info) == 0) {
5418	strncpy(mMainVolLutTableExtraName, tmp_info.amp_curve_name, CC_PROJECT_INFO_ITEM_MAX_LEN - 1);
5419	}
5420	openTvAudio();
5421	}
5422
5423	void CTv::AudioCtlUninit()
5424	{
5425	int oldMuteStatus;
5426
5427	oldMuteStatus = GetAudioMuteForTv();
5428	SetAudioMuteForTv(CC_AUDIO_MUTE);
5429
5430	//AudioCtlUninit();
5431	AudioSetAudioInSource (CC_AUDIO_IN_SOURCE_HDMI);
5432	SetDAC_Digital_PlayBack_Volume(255);
5433	AudioSetAudioSourceType (AUDIO_MPEG_SOURCE);
5434	UnInitTvAudio();
5435	SetAudioVolumeCompensationVal(0);
5436	SetAudioMasterVolume(GetAudioMasterVolume());
5437	UnInitSetTvAudioCard();
5438
5439	SetAudioMuteForTv(oldMuteStatus);
5440	}
5441
5442	char *CTv::GetMainVolLutTableExtraName()
5443	{
5444	return mMainVolLutTableExtraName;
5445	}
5446
5447	//audio
5448	int CTv::SetAudioMuteForSystem(int muteOrUnmute)
5449	{
5450	int ret = 0;
5451	LOGD("SetAudioMuteForSystem sysMuteStats=%d, tvMuteStatus=%d, toMute=%d", mAudioMuteStatusForSystem, mAudioMuteStatusForTv, muteOrUnmute);
5452	mAudioMuteStatusForSystem = muteOrUnmute;
5453	ret |= SetDacMute(mAudioMuteStatusForSystem, CC_DAC_MUTE_TYPE_EXTERNAL);
5454	ret |= SetAudioI2sMute(mAudioMuteStatusForSystem | mAudioMuteStatusForTv);
5455	return ret;
5456	}
5457
5458	int CTv::GetAudioMuteForSystem()
5459	{
5460	return mAudioMuteStatusForSystem;
5461	}
5462
5463	int CTv::SetAudioMuteForTv(int muteOrUnmute)
5464	{
5465	int ret = 0;
5466	mAudioMuteStatusForTv = muteOrUnmute;
5467	LOGD("SetAudioMuteForTv sysMuteStats=%d, tvMuteStatus=%d, toMute=%d", mAudioMuteStatusForSystem, mAudioMuteStatusForTv, muteOrUnmute);
5468	ret |= SetDacMute(mAudioMuteStatusForSystem | mAudioMuteStatusForTv, CC_DAC_MUTE_TYPE_EXTERNAL | CC_DAC_MUTE_TYPE_INTERNAL);
5469	ret |= SetAudioI2sMute(mAudioMuteStatusForTv);
5470	return ret;
5471	}
5472
5473	int CTv::GetAudioMuteForTv()
5474	{
5475	return mAudioMuteStatusForTv;
5476	}
5477
5478	int CTv::GetDbxTvMode(int *mode, int *son_value, int *vol_value, int *sur_value)
5479	{
5480	*mode = 0;
5481	return SSMReadAudioDbxTvValue(son_value, vol_value, sur_value);
5482	}
5483
5484	int CTv::SetAudioSPDIFSwitch(int tmp_val)
5485	{
5486	int muteStatus = CC_AUDIO_UNMUTE;
5487
5488	SaveCurAudioSPDIFSwitch(tmp_val);
5489
5490	if (tmp_val == CC_SWITCH_OFF /*|| mAudioMuteStatusForSystem == CC_AUDIO_MUTE || mAudioMuteStatusForTv == CC_AUDIO_MUTE*/) {
5491	muteStatus = CC_AUDIO_MUTE;
5492	} else {
5493	muteStatus = CC_AUDIO_UNMUTE;
5494	}
5495
5496	SetAudioSPDIFMute(muteStatus);
5497	return 0;
5498	}
5499
5500	int CTv::AudioHandleHeadsetPlugIn()
5501	{
5502	return 0;
5503	}
5504
5505	int CTv::AudioHandleHeadsetPullOut()
5506	{
5507	return 0;
5508	}
5509
5510	int CTv::Tv_SetDRC_OnOff(int on_off)
5511	{
5512	on_off = on_off;
5513	return 0;
5514	}
5515
5516	int CTv::Tv_GetDRC_OnOff(void)
5517	{
5518	return 0;
5519	}
5520
5521	void CTv::updateSubtitle(int pic_width, int pic_height)
5522	{
5523	TvEvent::SubtitleEvent ev;
5524	ev.pic_width = pic_width;
5525	ev.pic_height = pic_height;
5526	sendTvEvent(ev);
5527	}
5528
5529	int CTv::setSubtitleBuffer(char *share_mem)
5530	{
5531	mSubtitle.setBuffer(share_mem);
5532	return 0;
5533	}
5534
5535	int CTv::initSubtitle(int bitmapWidth, int bitmapHeight)
5536	{
5537	return mSubtitle.sub_init(bitmapWidth, bitmapHeight);
5538	}
5539
5540	int CTv::lockSubtitle()
5541	{
5542	return mSubtitle.sub_lock();
5543	}
5544
5545	int CTv::unlockSubtitle()
5546	{
5547	return mSubtitle.sub_unlock();
5548	}
5549
5550	int CTv::getSubSwitchStatus()
5551	{
5552	return mSubtitle.sub_switch_status();
5553	}
5554
5555	int CTv::startSubtitle(int dmx_id, int pid, int page_id, int anc_page_id)
5556	{
5557	return mSubtitle.sub_start_dvb_sub(dmx_id, pid, page_id, anc_page_id);
5558	}
5559
5560	int CTv::stopSubtitle()
5561	{
5562	return mSubtitle.sub_stop_dvb_sub();
5563	}
5564
5565	//--------------------------------------------------
5566
5567
5568	//Audio Mute
5569	int CTv::SetAudioI2sMute(int muteStatus)
5570	{
5571	int vol = 256;
5572	if (muteStatus == CC_AUDIO_MUTE) {
5573	vol = 0;
5574	} else {
5575	vol = 256;
5576	}
5577	CFile::setFileAttrValue(SYS_AUIDO_DIRECT_RIGHT_GAIN, vol);
5578	CFile::setFileAttrValue(SYS_AUIDO_DIRECT_LEFT_GAIN, vol);
5579	return 0;
5580	}
5581
5582	int CTv::SetDacMute(int muteStatus, int mute_type)
5583	{
5584	int tmp_ret = 0;
5585	if (mute_type & CC_DAC_MUTE_TYPE_INTERNAL) {
5586	tmp_ret |= mAudioAlsa.SetInternalDacMute(muteStatus);
5587	}
5588
5589	if (mute_type & CC_DAC_MUTE_TYPE_EXTERNAL) {
5590	int set_val = 0;
5591	int aud_arch_type = GetAudioArchitectureTypeCFG();
5592
5593	if (aud_arch_type == CC_DAC_G9TV_EXTERNAL_DAC_ON_BOARD) {
5594	if (muteStatus == CC_AUDIO_MUTE) {
5595	set_val = CC_MUTE_ON;
5596	} else if (muteStatus == CC_AUDIO_UNMUTE) {
5597	set_val = CC_MUTE_OFF;
5598	} else {
5599	return -1;
5600	}
5601
5602	mAudioAlsa.SetExternalDacChannelSwitch(1, set_val);
5603	mAudioAlsa.SetExternalDacChannelSwitch(2, set_val);
5604	//showboz: can disable it
5605	mAudioAlsa.SetExternalDacChannelSwitch(3, set_val);
5606	} else if (aud_arch_type == CC_DAC_G9TV_EXTERNAL_DAC_OFF_BOARD_FBC) {
5607	SendCmdToOffBoardFBCExternalDac(AUDIO_CMD_SET_MUTE, muteStatus);
5608	} else if (aud_arch_type == CC_DAC_G9TV_EXTERNAL_DAC_CUSTOMER_LIB) {
5609	mCustomerCtrl.SetMute((muteStatus == CC_AUDIO_MUTE) ? CAudioCustomerCtrl::MUTE : CAudioCustomerCtrl::UNMUTE);
5610	} else if (aud_arch_type == CC_DAC_G9TV_EXTERNAL_DAC_DIGITAL) {
5611	mAudioAlsa.SetDigitalMute(muteStatus);
5612	}
5613	mAudioAlsa.setAudioPcmPlaybackMute(muteStatus);
5614	}
5615	return tmp_ret;
5616	}
5617
5618	int CTv::SetAudioAVOutMute(int muteStatus)
5619	{
5620	SSMSaveAudioAVOutMuteVal(muteStatus);
5621	return mAudioAlsa.SetInternalDacMute(muteStatus);
5622	}
5623
5624	int CTv::GetAudioAVOutMute()
5625	{
5626	int8_t tmp_ch = 0;
5627	SSMReadAudioAVOutMuteVal(&tmp_ch);
5628	return tmp_ch;
5629	}
5630
5631	int CTv::SetAudioSPDIFMute(int muteStatus)
5632	{
5633	if (GetCurAudioSPDIFSwitch() == CC_SWITCH_OFF) {
5634	muteStatus = CC_AUDIO_MUTE;
5635	}
5636
5637	SSMSaveAudioSPIDFMuteVal(muteStatus);
5638	return mAudioAlsa.SetSPDIFMute(muteStatus);
5639	}
5640
5641	int CTv::GetAudioSPDIFMute()
5642	{
5643	int8_t tmp_ch = 0;
5644	SSMReadAudioSPIDFMuteVal(&tmp_ch);
5645	return tmp_ch;
5646	}
5647
5648	int CTv::GetCurAudioSPDIFSwitch()
5649	{
5650	return mCurAudioSPDIFSwitch;
5651	}
5652
5653	int CTv::SaveCurAudioSPDIFSwitch(int tmp_val)
5654	{
5655	mCurAudioSPDIFSwitch = tmp_val;
5656	SSMSaveAudioSPDIFSwitchVal(tmp_val);
5657	return tmp_val;
5658	}
5659
5660	int CTv::LoadCurAudioSPDIFSwitch()
5661	{
5662	int8_t tmp_ch = 0;
5663	SSMReadAudioSPDIFSwitchVal(&tmp_ch);
5664	mCurAudioSPDIFSwitch = tmp_ch;
5665	if (mCurAudioSPDIFSwitch != CC_SWITCH_ON
5666	&& mCurAudioSPDIFSwitch != CC_SWITCH_OFF) {
5667	SaveCurAudioSPDIFSwitch (CC_SWITCH_ON);
5668	}
5669	return mCurAudioSPDIFSwitch;
5670	}
5671
5672	//Audio SPDIF Mode
5673	int CTv::SetAudioSPDIFMode(int tmp_val)
5674	{
5675	LOGD("%s : tmp_val = %d\n", __FUNCTION__, tmp_val);
5676	mCurAudioSPDIFMode = tmp_val;
5677	SetSPDIFMode(tmp_val);
5678	return 0;
5679	}
5680
5681	int CTv::GetCurAudioSPDIFMode()
5682	{
5683	return mCurAudioSPDIFMode;
5684	}
5685
5686	int CTv::SaveCurAudioSPDIFMode(int tmp_val)
5687	{
5688	mCurAudioSPDIFMode = tmp_val;
5689	SSMSaveAudioSPDIFModeVal(tmp_val);
5690	return tmp_val;
5691	}
5692
5693	int CTv::LoadCurAudioSPDIFMode()
5694	{
5695	int8_t tmp_ch = 0;
5696	SSMReadAudioSPDIFModeVal(&tmp_ch);
5697	mCurAudioSPDIFMode = tmp_ch;
5698	if (mCurAudioSPDIFMode != CC_SPDIF_MODE_PCM
5699	&& mCurAudioSPDIFMode != CC_SPDIF_MODE_RAW) {
5700	SaveCurAudioSPDIFMode (CC_SPDIF_MODE_PCM);
5701	}
5702	return mCurAudioSPDIFMode;
5703	}
5704
5705	int CTv::SetAudioMasterVolume(int tmp_vol)
5706	{
5707	mCustomAudioMasterVolume = tmp_vol;
5708
5709	//Volume Compensation
5710	tmp_vol += mVolumeCompensationVal;
5711
5712	if (tmp_vol > CC_MAX_SOUND_VOL) {
5713	tmp_vol = CC_MAX_SOUND_VOL;
5714	}
5715
5716	if (tmp_vol < CC_MIN_SOUND_VOL) {
5717	tmp_vol = CC_MIN_SOUND_VOL;
5718	}
5719
5720	int tmp_ret = 0;
5721	int aud_arch_type = GetAudioArchitectureTypeCFG();
5722
5723	if (aud_arch_type == CC_DAC_G9TV_INTERNAL_DAC) {
5724	tmp_ret = mAudioAlsa.SetInternalDacMainVolume(tmp_vol);
5725	} else if (aud_arch_type == CC_DAC_G9TV_EXTERNAL_DAC_ON_BOARD) {
5726	int digit_vol = 0;
5727	int vol_gain_val = 0;
5728	int vol_buf[2] = {0, 0};
5729
5730	//handle l&r channel volume for balance
5731	mAudioAlsa.CalculateBalanceVol(255, mMainVolumeBalanceVal, vol_buf);
5732
5733	tmp_ret |= mAudioAlsa.SetExternalDacChannelVolume(1, vol_buf[0]);
5734	tmp_ret |= mAudioAlsa.SetExternalDacChannelVolume(2, vol_buf[1]);
5735
5736	//handle master channel volume
5737	digit_vol = mAudioAlsa.TransVolumeBarVolToDigitalVol(mAudioAlsa.GetMainVolDigitLutBuf(), tmp_vol);
5738
5739	vol_gain_val = mAudioAlsa.GetMainVolumeGain();
5740	digit_vol += vol_gain_val;
5741	tmp_ret |= mAudioAlsa.SetExternalDacChannelVolume(0, digit_vol);
5742	} else if (aud_arch_type == CC_DAC_G9TV_EXTERNAL_DAC_OFF_BOARD_FBC) {
5743	tmp_ret = SendCmdToOffBoardFBCExternalDac(AUDIO_CMD_SET_VOLUME_BAR, tmp_vol);
5744	} else if (aud_arch_type == CC_DAC_G9TV_EXTERNAL_DAC_CUSTOMER_LIB) {
5745	tmp_ret = mCustomerCtrl.SetVolumeBar(tmp_vol);
5746	} else if (aud_arch_type == CC_DAC_G9TV_EXTERNAL_DAC_DIGITAL) {
5747	int vol_buf[2] = {0, 0};
5748	mAudioAlsa.CalculateBalanceVol(tmp_vol, mMainVolumeBalanceVal, vol_buf);
5749	tmp_ret = mAudioAlsa.SetDigitalMainVolume(vol_buf[0], vol_buf[1]);
5750	}
5751	if ( Get2d4gHeadsetEnable() == 1 ) {
5752	setAudioPcmPlaybackVolume(tmp_vol);
5753	}
5754	return 0;
5755	}
5756
5757	int CTv::GetAudioMasterVolume()
5758	{
5759	return mCustomAudioMasterVolume;
5760	}
5761
5762	int CTv::GetCurAudioMasterVolume()
5763	{
5764	return mCurAudioMasterVolume;
5765	}
5766
5767	int CTv::SaveCurAudioMasterVolume(int tmp_vol)
5768	{
5769	mCurAudioMasterVolume = tmp_vol;
5770	SSMSaveAudioMasterVolume(tmp_vol);
5771	return tmp_vol;
5772	}
5773
5774	int CTv::LoadCurAudioMasterVolume()
5775	{
5776	int8_t tmp_ch = 0;
5777	SSMReadAudioMasterVolume(&tmp_ch);
5778	mCurAudioMasterVolume = tmp_ch;
5779	if (mCurAudioMasterVolume < CC_MIN_SOUND_VOL
5780	|| mCurAudioMasterVolume > CC_MAX_SOUND_VOL) {
5781	SaveCurAudioMasterVolume (CC_DEF_SOUND_VOL);
5782	}
5783	mCustomAudioMasterVolume = mCurAudioMasterVolume;
5784
5785	return mCurAudioMasterVolume;
5786	}
5787
5788	int CTv::SetAudioBalance(int tmp_val)
5789	{
5790	mCustomAudioBalance = tmp_val;
5791
5792	int aud_arch_type = GetAudioArchitectureTypeCFG();
5793
5794	mMainVolumeBalanceVal = tmp_val;
5795
5796	if (aud_arch_type == CC_DAC_G9TV_EXTERNAL_DAC_OFF_BOARD_FBC) {
5797	SendCmdToOffBoardFBCExternalDac(AUDIO_CMD_SET_BALANCE, mMainVolumeBalanceVal);
5798	} else if (aud_arch_type == CC_DAC_G9TV_EXTERNAL_DAC_CUSTOMER_LIB) {
5799	mCustomerCtrl.SetBlance(mMainVolumeBalanceVal);
5800	} else {
5801	SetAudioMasterVolume(GetAudioMasterVolume());
5802	}
5803	return 0;
5804	}
5805
5806	int CTv::GetAudioBalance()
5807	{
5808	return mCustomAudioBalance;
5809	}
5810
5811	int CTv::GetCurAudioBalance()
5812	{
5813	return mCurAudioBalance;
5814	}
5815
5816	int CTv::SaveCurAudioBalance(int tmp_val)
5817	{
5818	mCurAudioBalance = tmp_val;
5819	SSMSaveAudioBalanceVal(tmp_val);
5820	return tmp_val;
5821	}
5822
5823	int CTv::LoadCurAudioBalance()
5824	{
5825	int8_t tmp_ch = 0;
5826	SSMReadAudioBalanceVal(&tmp_ch);
5827	mCurAudioBalance = tmp_ch;
5828	if (mCurAudioBalance < CC_MIN_SOUND_BALANCE_VAL
5829	|| mCurAudioBalance > CC_MAX_SOUND_BALANCE_VAL) {
5830	SaveCurAudioBalance (CC_DEF_SOUND_BALANCE_VAL);
5831	}
5832
5833	mCustomAudioBalance = mCurAudioBalance;
5834
5835	return mCurAudioBalance;
5836	}
5837
5838	int CTv::SetAudioVolumeCompensationVal(int tmp_vol_comp_val)
5839	{
5840	mVolumeCompensationVal = tmp_vol_comp_val;
5841	LOGD("%s, new vol comp value = %d.\n", __FUNCTION__, tmp_vol_comp_val);
5842	return mVolumeCompensationVal;
5843	}
5844
5845	int CTv::SetAudioSupperBassVolume(int tmp_vol)
5846	{
5847	mCustomAudioSupperBassVolume = tmp_vol;
5848
5849	int aud_arch_type = GetAudioArchitectureTypeCFG();
5850	int tmp_ret = 0;
5851
5852	if (aud_arch_type == CC_DAC_G9TV_INTERNAL_DAC) {
5853	return 0;
5854	} else if (aud_arch_type == CC_DAC_G9TV_EXTERNAL_DAC_ON_BOARD) {
5855	int digit_vol = 0;
5856	int vol_gain_val = 0;
5857
5858	digit_vol = mAudioAlsa.TransVolumeBarVolToDigitalVol(mAudioAlsa.GetMainVolDigitLutBuf(), tmp_vol);
5859
5860	vol_gain_val = mAudioAlsa.GetSupperBassVolumeGain();
5861	digit_vol += vol_gain_val;
5862	if (digit_vol < CC_MIN_DAC_SUB_WOOFER_VOLUME) {
5863	digit_vol = CC_MIN_DAC_SUB_WOOFER_VOLUME;
5864	} else if (digit_vol > CC_MAX_DAC_SUB_WOOFER_VOLUME) {
5865	digit_vol = CC_MAX_DAC_SUB_WOOFER_VOLUME;
5866	}
5867
5868	tmp_ret = mAudioAlsa.SetExternalDacChannelVolume(3, digit_vol);
5869	} else if (aud_arch_type == CC_DAC_G9TV_EXTERNAL_DAC_OFF_BOARD_FBC) {
5870	tmp_ret = SendCmdToOffBoardFBCExternalDac(AUDIO_CMD_SET_SUBCHANNEL_VOLUME, tmp_vol);
5871	}
5872
5873	return tmp_ret;
5874	}
5875
5876	int CTv::GetAudioSupperBassVolume()
5877	{
5878	return mCustomAudioSupperBassVolume;
5879	}
5880
5881	int CTv::GetCurAudioSupperBassVolume()
5882	{
5883	return mCurAudioSupperBassVolume;
5884	}
5885
5886	int CTv::SaveCurAudioSupperBassVolume(int tmp_vol)
5887	{
5888	mCurAudioSupperBassVolume = tmp_vol;
5889	SSMSaveAudioSupperBassVolume(tmp_vol);
5890
5891	return tmp_vol;
5892	}
5893
5894	int CTv::LoadCurAudioSupperBassVolume()
5895	{
5896	int8_t tmp_ch = 0;
5897	SSMReadAudioSupperBassVolume(&tmp_ch);
5898	mCurAudioSupperBassVolume = tmp_ch;
5899	if (mCurAudioSupperBassVolume < CC_MIN_SUPPERBASS_VOL
5900	|| mCurAudioSupperBassVolume > CC_MAX_SUPPERBASS_VOL) {
5901	SaveCurAudioSupperBassVolume (CC_DEF_SUPPERBASS_VOL);
5902	}
5903	mCustomAudioSupperBassVolume = mCurAudioSupperBassVolume;
5904
5905	return mCurAudioSupperBassVolume;
5906	}
5907
5908	int CTv::SetAudioSupperBassSwitch(int tmp_val)
5909	{
5910	mCustomAudioSupperBassSwitch = tmp_val;
5911
5912	if (GetAudioSupperBassSwitch() == CC_SWITCH_OFF) {
5913	return SetAudioSupperBassVolume(CC_MIN_SUPPERBASS_VOL);
5914	}
5915
5916	return SetAudioSupperBassVolume(GetAudioSupperBassVolume());
5917	}
5918
5919	int CTv::GetAudioSupperBassSwitch()
5920	{
5921	if (GetAudioSupperBassSwitchDisableCFG() != 0) {
5922	return CC_SWITCH_ON;
5923	}
5924
5925	return mCustomAudioSupperBassSwitch;
5926	}
5927
5928	int CTv::GetCurAudioSupperBassSwitch()
5929	{
5930	if (GetAudioSupperBassSwitchDisableCFG() != 0) {
5931	return CC_SWITCH_ON;
5932	}
5933
5934	return mCurAudioSupperBassSwitch;
5935	}
5936
5937	int CTv::SaveCurAudioSupperBassSwitch(int tmp_val)
5938	{
5939	mCurAudioSupperBassSwitch = tmp_val;
5940	SSMSaveAudioSupperBassSwitch(tmp_val);
5941	SetSupperBassSRSSpeakerSize();
5942	return tmp_val;
5943	}
5944
5945	int CTv::LoadCurAudioSupperBassSwitch()
5946	{
5947	int8_t tmp_ch = 0;
5948	SSMReadAudioSupperBassSwitch(&tmp_ch);
5949	mCurAudioSupperBassSwitch = tmp_ch;
5950	if (mCurAudioSupperBassSwitch != CC_SWITCH_ON
5951	&& mCurAudioSupperBassSwitch != CC_SWITCH_OFF) {
5952	SaveCurAudioSupperBassSwitch (CC_SWITCH_OFF);
5953	}
5954	mCustomAudioSupperBassSwitch = mCurAudioSupperBassSwitch;
5955
5956	return mCurAudioSupperBassSwitch;
5957	}
5958
5959	void CTv::SetSupperBassSRSSpeakerSize()
5960	{
5961	int tmp_speakersize = -1;
5962
5963	if (GetAudioSrsTruBass() == CC_SWITCH_ON) {
5964	tmp_speakersize = GetAudioSRSSupperBassTrubassSpeakerSizeCfg();
5965	if (tmp_speakersize >= 0) {
5966	mAudioEffect.SetSrsTrubassSpeakerSize(tmp_speakersize);
5967	}
5968	}
5969	}
5970
5971	int CTv::SetAudioSRSSurround(int tmp_val)
5972	{
5973	mCustomAudioSRSSurround = tmp_val;
5974	RefreshSrsEffectAndDacGain();
5975	return 0;
5976	}
5977
5978	int CTv::GetAudioSRSSurround()
5979	{
5980	return mCustomAudioSRSSurround;
5981	}
5982
5983	int CTv::GetCurAudioSRSSurround()
5984	{
5985	return mCurAudioSRSSurround;
5986	}
5987
5988	int CTv::SaveCurAudioSrsSurround(int tmp_val)
5989	{
5990	mCurAudioSRSSurround = tmp_val;
5991	SSMSaveAudioSRSSurroundSwitch(tmp_val);
5992	return tmp_val;
5993	}
5994
5995	int CTv::LoadCurAudioSrsSurround()
5996	{
5997	int8_t tmp_ch = 0;
5998
5999	SSMReadAudioSRSSurroundSwitch(&tmp_ch);
6000	mCurAudioSRSSurround = tmp_ch;
6001	if (mCurAudioSRSSurround != CC_SWITCH_ON
6002	&& mCurAudioSRSSurround != CC_SWITCH_OFF) {
6003	SaveCurAudioSrsSurround (CC_SWITCH_OFF);
6004	}
6005	mCustomAudioSRSSurround = mCurAudioSRSSurround;
6006
6007	return mCurAudioSRSSurround;
6008	}
6009
6010	int CTv::SetAudioSrsDialogClarity(int tmp_val)
6011	{
6012	mCustomAudioSrsDialogClarity = tmp_val;
6013	RefreshSrsEffectAndDacGain();
6014	return 0;
6015	}
6016
6017	int CTv::GetAudioSrsDialogClarity()
6018	{
6019	return mCustomAudioSrsDialogClarity;
6020	}
6021
6022	int CTv::GetCurAudioSrsDialogClarity()
6023	{
6024	return mCurAudioSrsDialogClarity;
6025	}
6026
6027	int CTv::SaveCurAudioSrsDialogClarity(int tmp_val)
6028	{
6029	mCurAudioSrsDialogClarity = tmp_val;
6030	SSMSaveAudioSRSDialogClaritySwitch(tmp_val);
6031	return tmp_val;
6032	}
6033
6034	int CTv::LoadCurAudioSrsDialogClarity()
6035	{
6036	int8_t tmp_ch = 0;
6037
6038	SSMReadAudioSRSDialogClaritySwitch(&tmp_ch);
6039	mCurAudioSrsDialogClarity = tmp_ch;
6040	if (mCurAudioSrsDialogClarity != CC_SWITCH_ON
6041	&& mCurAudioSrsDialogClarity != CC_SWITCH_OFF) {
6042	SaveCurAudioSrsDialogClarity (CC_SWITCH_OFF);
6043	}
6044	mCustomAudioSrsDialogClarity = mCurAudioSrsDialogClarity;
6045
6046	return mCurAudioSrsDialogClarity;
6047	}
6048
6049	int CTv::SetAudioSrsTruBass(int tmp_val)
6050	{
6051	mCustomAudioSrsTruBass = tmp_val;
6052	RefreshSrsEffectAndDacGain();
6053	return 0;
6054	}
6055
6056	int CTv::GetAudioSrsTruBass()
6057	{
6058	return mCustomAudioSrsTruBass;
6059	}
6060
6061	int CTv::GetCurAudioSrsTruBass()
6062	{
6063	return mCurAudioSrsTruBass;
6064	}
6065
6066	int CTv::SaveCurAudioSrsTruBass(int tmp_val)
6067	{
6068	mCurAudioSrsTruBass = tmp_val;
6069	SSMSaveAudioSRSTruBassSwitch(tmp_val);
6070	return tmp_val;
6071	}
6072
6073	int CTv::LoadCurAudioSrsTruBass()
6074	{
6075	int8_t tmp_ch = 0;
6076
6077	SSMReadAudioSRSTruBassSwitch(&tmp_ch);
6078	mCurAudioSrsTruBass = tmp_ch;
6079	if (mCurAudioSrsTruBass != CC_SWITCH_ON
6080	&& mCurAudioSrsTruBass != CC_SWITCH_OFF) {
6081	SaveCurAudioSrsTruBass (CC_SWITCH_OFF);
6082	}
6083	mCustomAudioSrsTruBass = mCurAudioSrsTruBass;
6084
6085	return mCurAudioSrsTruBass;
6086	}
6087
6088	void CTv::RefreshSrsEffectAndDacGain()
6089	{
6090	int tmp_gain_val = 0;
6091	int surround_switch = CC_SWITCH_OFF;
6092	int trubass_switch = CC_SWITCH_OFF;
6093	int dialogclarity_switch = CC_SWITCH_OFF;
6094	trubass_switch = GetAudioSrsTruBass();
6095	dialogclarity_switch = GetAudioSrsDialogClarity();
6096	surround_switch = GetAudioSRSSurround();
6097
6098	if (GetAudioSRSSourroundEnableCFG() == 0) {
6099	return;
6100	}
6101
6102	if (surround_switch == CC_SWITCH_ON) {
6103	mAudioEffect.SetSrsSurroundSwitch(CC_SWITCH_ON);
6104	tmp_gain_val = GetAudioSRSGainCfg(CFG_AUDIO_SRS_SOURROUND_GAIN, 50);
6105	mAudioEffect.SetSrsSurroundGain(tmp_gain_val);
6106
6107	int input_gain_val = GetAudioSRSGainCfg(CFG_AUDIO_SRS_INPUT_GAIN, 50);
6108	int out_gain_val = GetAudioSRSGainCfg(CFG_AUDIO_SRS_OUTPUT_GAIN, 50);
6109	mAudioEffect.SetSrsInputOutputGain(input_gain_val, out_gain_val);
6110
6111	if (trubass_switch == CC_SWITCH_ON
6112	&& dialogclarity_switch == CC_SWITCH_OFF) {
6113
6114	mAudioEffect.SetSrsTruBassSwitch (CC_SWITCH_ON);
6115	tmp_gain_val = GetAudioSRSGainCfg(CFG_AUDIO_SRS_TRUBASS_GAIN, 50);
6116	mAudioEffect.SetSrsTruBassGain(tmp_gain_val);
6117	tmp_gain_val = GetAudioSRSGainCfg(CFG_AUDIO_SRS_TRUBASS_SPEAKERSIZE, 2);
6118	mAudioEffect.SetSrsTrubassSpeakerSize(tmp_gain_val);
6119
6120	mAudioEffect.SetSrsDialogClaritySwitch (CC_SWITCH_OFF);
6121
6122	} else if (trubass_switch == CC_SWITCH_OFF
6123	&& dialogclarity_switch == CC_SWITCH_ON) {
6124
6125	mAudioEffect.SetSrsDialogClaritySwitch (CC_SWITCH_ON);
6126	tmp_gain_val = GetAudioSRSGainCfg(CFG_AUDIO_SRS_CLARITY_GAIN, 30);
6127	mAudioEffect.SetSrsDialogClarityGain(tmp_gain_val);
6128	tmp_gain_val = GetAudioSRSGainCfg(CFG_AUDIO_SRS_DEFINITION_GAIN, 20);
6129	mAudioEffect.SetSrsDefinitionGain(tmp_gain_val);
6130
6131	mAudioEffect.SetSrsTruBassSwitch (CC_SWITCH_OFF);
6132
6133	} else if (trubass_switch == CC_SWITCH_ON
6134	&& dialogclarity_switch == CC_SWITCH_ON) {
6135
6136	mAudioEffect.SetSrsTruBassSwitch (CC_SWITCH_ON);
6137	tmp_gain_val = GetAudioSRSGainCfg(CFG_AUDIO_SRS_TRUBASS_GAIN, 50);
6138	mAudioEffect.SetSrsTruBassGain(tmp_gain_val);
6139	tmp_gain_val = GetAudioSRSGainCfg(CFG_AUDIO_SRS_TRUBASS_SPEAKERSIZE, 2);
6140	mAudioEffect.SetSrsTrubassSpeakerSize(tmp_gain_val);
6141
6142	mAudioEffect.SetSrsDialogClaritySwitch(CC_SWITCH_ON);
6143	tmp_gain_val = GetAudioSRSGainCfg(CFG_AUDIO_SRS_CLARITY_GAIN, 30);
6144	mAudioEffect.SetSrsDialogClarityGain(tmp_gain_val);
6145	tmp_gain_val = GetAudioSRSGainCfg(CFG_AUDIO_SRS_DEFINITION_GAIN, 20);
6146	mAudioEffect.SetSrsDefinitionGain(tmp_gain_val);
6147
6148	} else if (trubass_switch == CC_SWITCH_OFF
6149	&& dialogclarity_switch == CC_SWITCH_OFF) {
6150	mAudioEffect.SetSrsTruBassSwitch (CC_SWITCH_OFF);
6151	mAudioEffect.SetSrsDialogClaritySwitch(CC_SWITCH_OFF);
6152	}
6153	SetSupperBassSRSSpeakerSize();
6154	} else {
6155	mAudioEffect.SetSrsSurroundSwitch (CC_SWITCH_OFF);
6156	mAudioEffect.SetSrsTruBassSwitch(CC_SWITCH_OFF);
6157	mAudioEffect.SetSrsDialogClaritySwitch(CC_SWITCH_OFF);
6158	}
6159	//Refesh DAC gain
6160	int main_gain_val = 0;
6161	if (surround_switch == CC_SWITCH_ON) {
6162	main_gain_val = GetAudioEffectAmplifierGainCfg(CFG_AUDIO_SRS_SOURROUND_MASTER_GAIN, 6, 24);
6163	if (dialogclarity_switch == CC_SWITCH_ON
6164	&& trubass_switch == CC_SWITCH_OFF) {
6165	main_gain_val = GetAudioEffectAmplifierGainCfg(CFG_AUDIO_SRS_CLARITY_MASTER_GAIN, 6, 24);
6166	} else if (dialogclarity_switch == CC_SWITCH_OFF
6167	&& trubass_switch == CC_SWITCH_ON) {
6168	main_gain_val = GetAudioEffectAmplifierGainCfg(CFG_AUDIO_SRS_TRUBASS_MASTER_GAIN, 6, 24);
6169	} else if (dialogclarity_switch == CC_SWITCH_ON
6170	&& trubass_switch == CC_SWITCH_ON) {
6171	main_gain_val = GetAudioEffectAmplifierGainCfg(CFG_AUDIO_SRS_TRUBASS_CLARITY_MASTER_GAIN, 6, 24);
6172	}
6173	}
6174	mAudioAlsa.SetMainVolumeGain(main_gain_val);
6175	}
6176
6177	int CTv::SetAudioBassVolume(int tmp_vol)
6178	{
6179	int nMinBassVol = 0, nMaxBassVol = 0;
6180
6181	nMinBassVol = GetBassUIMinGainVal();
6182	nMaxBassVol = GetBassUIMaxGainVal();
6183
6184	if (tmp_vol < nMinBassVol || tmp_vol > nMaxBassVol) {
6185	tmp_vol = (nMaxBassVol + nMinBassVol) / 2;
6186	}
6187
6188	mCustomAudioBassVolume = tmp_vol;
6189	tmp_vol = MappingTrebleBassAndEqualizer(GetAudioBassVolume(), 0,
6190	nMinBassVol, nMaxBassVol);
6191	return SetSpecialIndexEQGain(CC_EQ_BASS_IND, tmp_vol);
6192	}
6193
6194	int CTv::GetAudioBassVolume()
6195	{
6196	return mCustomAudioBassVolume;
6197	}
6198
6199	int CTv::GetCurAudioBassVolume()
6200	{
6201	return mCurAudioBassVolume;
6202	}
6203
6204	int CTv::SaveCurAudioBassVolume(int tmp_vol)
6205	{
6206	int nMinBassVol = 0, nMaxBassVol = 0;
6207
6208	nMinBassVol = GetBassUIMinGainVal();
6209	nMaxBassVol = GetBassUIMaxGainVal();
6210
6211	if (tmp_vol < nMinBassVol || tmp_vol > nMaxBassVol) {
6212	tmp_vol = (nMaxBassVol + nMinBassVol) / 2;
6213	}
6214
6215	RealSaveCurAudioBassVolume(tmp_vol, 1);
6216
6217	tmp_vol = MappingTrebleBassAndEqualizer(GetCurAudioBassVolume(), 0,
6218	nMinBassVol, nMaxBassVol);
6219	return SaveSpecialIndexEQGain(CC_EQ_BASS_IND, tmp_vol);
6220	}
6221
6222	int CTv::RealSaveCurAudioBassVolume(int tmp_vol, int sound_mode_judge)
6223	{
6224	mCurAudioBassVolume = tmp_vol;
6225	SSMSaveAudioBassVolume(tmp_vol);
6226
6227	if (sound_mode_judge == 1) {
6228	if (GetAudioSoundMode() != CC_SOUND_MODE_USER) {
6229	SaveCurAudioSoundMode (CC_SOUND_MODE_USER);
6230	mCustomAudioSoundMode = mCurAudioSoundMode;
6231	}
6232	}
6233	return mCurAudioBassVolume;
6234	}
6235
6236	int CTv::LoadCurAudioBassVolume()
6237	{
6238	int nMinBassVol = 0, nMaxBassVol = 0;
6239	int8_t tmp_ch = 0;
6240
6241	nMinBassVol = GetBassUIMinGainVal();
6242	nMaxBassVol = GetBassUIMaxGainVal();
6243
6244	SSMReadAudioBassVolume(&tmp_ch);
6245	mCurAudioBassVolume = tmp_ch;
6246	if (mCurAudioBassVolume < nMinBassVol
6247	|| mCurAudioBassVolume > nMaxBassVol) {
6248	RealSaveCurAudioBassVolume((nMaxBassVol + nMinBassVol) / 2, 0);
6249	}
6250
6251	mCustomAudioBassVolume = mCurAudioBassVolume;
6252	return mCurAudioBassVolume;
6253	}
6254
6255	int CTv::SetAudioTrebleVolume(int tmp_vol)
6256	{
6257	int nMinTrebleVol = 0, nMaxTrebleVol = 0;
6258
6259	nMinTrebleVol = GetTrebleUIMinGainVal();
6260	nMaxTrebleVol = GetTrebleUIMaxGainVal();
6261
6262	if (tmp_vol < nMinTrebleVol || tmp_vol > nMaxTrebleVol) {
6263	tmp_vol = (nMaxTrebleVol + nMinTrebleVol) / 2;
6264	}
6265
6266	mCustomAudioTrebleVolume = tmp_vol;
6267
6268	tmp_vol = MappingTrebleBassAndEqualizer(GetAudioTrebleVolume(), 0,
6269	nMinTrebleVol, nMaxTrebleVol);
6270	return SetSpecialIndexEQGain(CC_EQ_TREBLE_IND, tmp_vol);
6271	}
6272
6273	int CTv::GetAudioTrebleVolume()
6274	{
6275	return mCustomAudioTrebleVolume;
6276	}
6277
6278	int CTv::GetCurAudioTrebleVolume()
6279	{
6280	return mCurAudioTrebleVolume;
6281	}
6282
6283	int CTv::SaveCurAudioTrebleVolume(int tmp_vol)
6284	{
6285	int nMinTrebleVol = 0, nMaxTrebleVol = 0;
6286
6287	nMinTrebleVol = GetTrebleUIMinGainVal();
6288	nMaxTrebleVol = GetTrebleUIMaxGainVal();
6289
6290	if (tmp_vol < nMinTrebleVol || tmp_vol > nMaxTrebleVol) {
6291	tmp_vol = (nMaxTrebleVol + nMinTrebleVol) / 2;
6292	}
6293
6294	RealSaveCurAudioTrebleVolume(tmp_vol, 1);
6295
6296	tmp_vol = MappingTrebleBassAndEqualizer(GetCurAudioTrebleVolume(), 0,
6297	nMinTrebleVol, nMaxTrebleVol);
6298	return SaveSpecialIndexEQGain(CC_EQ_TREBLE_IND, tmp_vol);
6299	}
6300
6301	int CTv::RealSaveCurAudioTrebleVolume(int tmp_vol, int sound_mode_judge)
6302	{
6303	mCurAudioTrebleVolume = tmp_vol;
6304	SSMSaveAudioTrebleVolume(tmp_vol);
6305
6306	if (sound_mode_judge == 1) {
6307	if (GetAudioSoundMode() != CC_SOUND_MODE_USER) {
6308	SaveCurAudioSoundMode (CC_SOUND_MODE_USER);
6309	mCustomAudioSoundMode = mCurAudioSoundMode;
6310	}
6311	}
6312
6313	return mCurAudioTrebleVolume;
6314	}
6315
6316	int CTv::LoadCurAudioTrebleVolume()
6317	{
6318	int nMinTrebleVol = 0, nMaxTrebleVol = 0;
6319	int8_t tmp_ch = 0;
6320
6321	nMinTrebleVol = GetTrebleUIMinGainVal();
6322	nMaxTrebleVol = GetTrebleUIMaxGainVal();
6323
6324	SSMReadAudioTrebleVolume(&tmp_ch);
6325	mCurAudioTrebleVolume = tmp_ch;
6326	if (mCurAudioTrebleVolume < nMinTrebleVol
6327	|| mCurAudioTrebleVolume > nMaxTrebleVol) {
6328	RealSaveCurAudioTrebleVolume((nMaxTrebleVol + nMinTrebleVol) / 2, 0);
6329	}
6330
6331	mCustomAudioTrebleVolume = mCurAudioTrebleVolume;
6332	return mCurAudioTrebleVolume;
6333	}
6334
6335	int CTv::SetAudioSoundMode(int tmp_val)
6336	{
6337	mCustomAudioSoundMode = tmp_val;
6338	SetSpecialModeEQGain(mCustomAudioSoundMode);
6339
6340	HandleTrebleBassVolume();
6341	return 0;
6342	}
6343
6344	int CTv::GetAudioSoundMode()
6345	{
6346	return mCustomAudioSoundMode;
6347	}
6348
6349	int CTv::GetCurAudioSoundMode()
6350	{
6351	return mCurAudioSoundMode;
6352	}
6353
6354	int CTv::SaveCurAudioSoundMode(int tmp_val)
6355	{
6356	mCurAudioSoundMode = tmp_val;
6357	SSMSaveAudioSoundModeVal(tmp_val);
6358	return tmp_val;
6359	}
6360
6361	int CTv::LoadCurAudioSoundMode()
6362	{
6363	int8_t tmp_ch = 0;
6364	SSMReadAudioSoundModeVal(&tmp_ch);
6365	mCurAudioSoundMode = tmp_ch;
6366	if (mCurAudioSoundMode < CC_SOUND_MODE_START
6367	|| mCurAudioSoundMode > CC_SOUND_MODE_END) {
6368	SaveCurAudioSoundMode (CC_SOUND_MODE_STD);
6369	}
6370	mCustomAudioSoundMode = mCurAudioSoundMode;
6371	return mCurAudioSoundMode;
6372	}
6373
6374	int CTv::HandleTrebleBassVolume()
6375	{
6376	int tmp_vol = 0;
6377	int tmpEQGainBuf[128] = { 0 };
6378	int8_t tmp_ch = 0;
6379
6380	GetCustomEQGain(tmpEQGainBuf);
6381
6382	tmp_vol = MappingTrebleBassAndEqualizer(tmpEQGainBuf[CC_EQ_TREBLE_IND], 1,
6383	GetTrebleUIMinGainVal(), GetTrebleUIMaxGainVal());
6384	mCustomAudioTrebleVolume = tmp_vol;
6385	mCurAudioTrebleVolume = mCustomAudioTrebleVolume;
6386	tmp_ch = mCustomAudioTrebleVolume;
6387	SSMSaveAudioTrebleVolume(tmp_ch);
6388
6389	tmp_vol = MappingTrebleBassAndEqualizer(tmpEQGainBuf[CC_EQ_BASS_IND], 1,
6390	GetBassUIMinGainVal(), GetBassUIMaxGainVal());
6391	mCustomAudioBassVolume = tmp_vol;
6392	mCurAudioBassVolume = mCustomAudioBassVolume;
6393	tmp_ch = mCustomAudioBassVolume;
6394	SSMSaveAudioBassVolume(tmp_ch);
6395	return 0;
6396	}
6397
6398	int CTv::SetAudioWallEffect(int tmp_val)
6399	{
6400	int tmp_treble_val;
6401	int tmp_type = 0;
6402
6403	mCustomAudioWallEffect = tmp_val;
6404
6405	tmp_type = GetAudioWallEffectTypeCfg();
6406	if (tmp_type == 0) {
6407	SetCustomEQGain();
6408	} else if (tmp_type == 1) {
6409	int aud_arch_type = GetAudioArchitectureTypeCFG();
6410	if (aud_arch_type == CC_DAC_G9TV_INTERNAL_DAC) {
6411	return 0;
6412	} else if (aud_arch_type == CC_DAC_G9TV_EXTERNAL_DAC_ON_BOARD) {
6413	mAudioAlsa.SetExternalDacEQMode(tmp_val);
6414	} else if (aud_arch_type == CC_DAC_G9TV_EXTERNAL_DAC_OFF_BOARD_FBC) {
6415	SendCmdToOffBoardFBCExternalDac(AUDIO_CMD_SET_EQ_MODE, tmp_val);
6416	}
6417	}
6418	return 0;
6419	}
6420
6421	int CTv::GetAudioWallEffect()
6422	{
6423	return mCustomAudioWallEffect;
6424	}
6425
6426	int CTv::GetCurAudioWallEffect()
6427	{
6428	return mCurAudioWallEffect;
6429	}
6430
6431	int CTv::SaveCurAudioWallEffect(int tmp_val)
6432	{
6433	mCurAudioWallEffect = tmp_val;
6434	SSMSaveAudioWallEffectSwitch(tmp_val);
6435	return tmp_val;
6436	}
6437
6438	int CTv::LoadCurAudioWallEffect()
6439	{
6440	int8_t tmp_ch = 0;
6441	SSMReadAudioWallEffectSwitch(&tmp_ch);
6442	mCurAudioWallEffect = tmp_ch;
6443	if (mCurAudioWallEffect != CC_SWITCH_ON
6444	&& mCurAudioWallEffect != CC_SWITCH_OFF) {
6445	SaveCurAudioWallEffect (CC_SWITCH_OFF);
6446	}
6447
6448	mCustomAudioWallEffect = mCurAudioWallEffect;
6449	return mCurAudioWallEffect;
6450	}
6451
6452	int CTv::SetAudioEQMode(int tmp_val)
6453	{
6454	mCustomAudioEQMode = tmp_val;
6455	return 0;
6456	}
6457
6458	int CTv::GetAudioEQMode()
6459	{
6460	return mCustomAudioEQMode;
6461	}
6462
6463	int CTv::GetCurAudioEQMode()
6464	{
6465	return mCurAudioEQMode;
6466	}
6467
6468	int CTv::SaveCurAudioEQMode(int tmp_val)
6469	{
6470	mCurAudioEQMode = tmp_val;
6471	SSMSaveAudioEQModeVal(tmp_val);
6472
6473	return tmp_val;
6474	}
6475
6476	int CTv::LoadCurAudioEQMode()
6477	{
6478	int8_t tmp_ch = 0;
6479	SSMReadAudioEQModeVal(&tmp_ch);
6480	mCurAudioEQMode = tmp_ch;
6481	if (mCurAudioEQMode < CC_EQ_MODE_START
6482	|| mCurAudioEQMode > CC_EQ_MODE_END) {
6483	SaveCurAudioEQMode (CC_EQ_MODE_START);
6484	}
6485	mCustomAudioEQMode = mCurAudioEQMode;
6486
6487	return mCurAudioEQMode;
6488	}
6489
6490	int CTv::GetAudioEQRange(int range_buf[])
6491	{
6492	range_buf[0] = CC_MIN_EQ_GAIN_VAL;
6493	range_buf[1] = CC_MAX_EQ_GAIN_VAL;
6494	return 0;
6495	}
6496
6497	int CTv::GetAudioEQBandCount()
6498	{
6499	return mAudioEffect.GetEQBandCount();
6500	}
6501
6502	int CTv::SetAudioEQGain(int gain_buf[])
6503	{
6504	return AudioSetEQGain(gain_buf);
6505	}
6506
6507	int CTv::GetAudioEQGain(int gain_buf[])
6508	{
6509	return GetCustomEQGain(gain_buf);
6510	}
6511
6512	int CTv::GetCurAudioEQGain(int gain_buf[])
6513	{
6514	RealReadCurAudioEQGain(gain_buf);
6515	return 0;
6516	}
6517
6518	int CTv::SaveCurAudioEQGain(int gain_buf[])
6519	{
6520	return RealSaveCurAudioEQGain(gain_buf, 1);
6521	}
6522
6523	int CTv::RealReadCurAudioEQGain(int gain_buf[])
6524	{
6525	ArrayCopy(gain_buf, mCurEQGainBuf, GetAudioEQBandCount());
6526	return 0;
6527	}
6528
6529	int CTv::RealSaveCurAudioEQGain(int gain_buf[], int sound_mode_judge)
6530	{
6531	ArrayCopy(mCurEQGainBuf, gain_buf, GetAudioEQBandCount());
6532	ArrayCopy(mCurEQGainChBuf, gain_buf, GetAudioEQBandCount());
6533	SSMSaveAudioEQGain(0, GetAudioEQBandCount(), mCurEQGainChBuf);
6534
6535	if (sound_mode_judge == 1) {
6536	HandleTrebleBassVolume();
6537	SaveCurAudioSoundMode (CC_SOUND_MODE_USER);
6538	mCustomAudioSoundMode = mCurAudioSoundMode;
6539	}
6540
6541	return 0;
6542	}
6543
6544	int CTv::LoadCurAudioEQGain()
6545	{
6546	SSMReadAudioEQGain(0, GetAudioEQBandCount(), mCurEQGainChBuf);
6547	ArrayCopy(mCurEQGainBuf, mCurEQGainChBuf, GetAudioEQBandCount());
6548
6549	for (int i = 0; i < GetAudioEQBandCount(); i++) {
6550	if (mCurEQGainBuf[i] & 0x80) {
6551	mCurEQGainBuf[i] = mCurEQGainBuf[i] - 256;
6552	}
6553	}
6554	return 0;
6555	}
6556
6557	int CTv::SetAudioEQSwitch(int switch_val)
6558	{
6559	return mAudioEffect.SetEQSwitch(switch_val);
6560	}
6561
6562	int CTv::SetDbxTvMode(int mode, int son_value, int vol_value, int sur_value)
6563	{
6564	return mAudioEffect.DbxTv_SetMode(mode, son_value, vol_value, sur_value);
6565	}
6566
6567	int CTv::GetBassUIMinGainVal()
6568	{
6569	return 0;
6570	}
6571
6572	int CTv::GetBassUIMaxGainVal()
6573	{
6574	return 100;
6575	}
6576
6577	int CTv::GetTrebleUIMinGainVal()
6578	{
6579	return 0;
6580	}
6581
6582	int CTv::GetTrebleUIMaxGainVal()
6583	{
6584	return 100;
6585	}
6586
6587	int CTv::MappingLine(int map_val, int src_min, int src_max, int dst_min, int dst_max)
6588	{
6589	if (dst_min < 0) {
6590	return (map_val - (src_max + src_min) / 2) * (dst_max - dst_min)
6591	/ (src_max - src_min);
6592	} else {
6593	return (map_val - src_min) * (dst_max - dst_min) / (src_max - src_min);
6594	}
6595	}
6596
6597	int CTv::MappingTrebleBassAndEqualizer(int tmp_vol, int direct, int tb_min, int tb_max)
6598	{
6599	int tmp_ret = 0;
6600
6601	if (direct == 0) {
6602	tmp_ret = MappingLine(tmp_vol, tb_min, tb_max, CC_EQ_DEF_UI_MIN_GAIN, CC_EQ_DEF_UI_MAX_GAIN);
6603	} else {
6604	tmp_ret = MappingLine(tmp_vol, CC_EQ_DEF_UI_MIN_GAIN, CC_EQ_DEF_UI_MAX_GAIN, tb_min, tb_max);
6605	}
6606
6607	LOGD("%s, tmp_vol = %d, direct = %d, tmp_ret = %d\n", __FUNCTION__, tmp_vol,
6608	direct, tmp_ret);
6609
6610	return tmp_ret;
6611	}
6612
6613	int CTv::MappingEQGain(int src_gain_buf[], int dst_gain_buf[], int direct)
6614	{
6615	int i = 0;
6616	int nMinUIVal = 0, nMaxUIVal = 0, nMinVal = 0, nMaxVal = 0;
6617
6618	nMinUIVal = CC_EQ_DEF_UI_MIN_GAIN;
6619	nMaxUIVal = CC_EQ_DEF_UI_MAX_GAIN;
6620	nMinVal = CC_MIN_EQ_GAIN_VAL;
6621	nMaxVal = CC_MAX_EQ_GAIN_VAL;
6622
6623	if (nMinUIVal >= nMinVal && nMaxUIVal <= nMaxVal) {
6624	for (i = 0; i < GetAudioEQBandCount(); i++) {
6625	dst_gain_buf[i] = src_gain_buf[i];
6626	}
6627	} else {
6628	for (i = 0; i < GetAudioEQBandCount(); i++) {
6629	if (direct == 0) {
6630	dst_gain_buf[i] = MappingLine(src_gain_buf[i], nMinUIVal,
6631	nMaxUIVal, nMinVal, nMaxVal);
6632	} else {
6633	dst_gain_buf[i] = MappingLine(src_gain_buf[i], nMinVal, nMaxVal,
6634	nMinUIVal, nMaxUIVal);
6635	}
6636	}
6637	}
6638	return 0;
6639	}
6640
6641	int CTv::RestoreToAudioDefEQGain(int gain_buf[])
6642	{
6643	int i = 0;
6644
6645	for (i = 0; i < GetAudioEQBandCount(); i++) {
6646	gain_buf[i] = (CC_EQ_DEF_UI_MAX_GAIN + CC_EQ_DEF_UI_MIN_GAIN) / 2;
6647	}
6648
6649	ArrayCopy(mCurEQGainBuf, gain_buf, GetAudioEQBandCount());
6650	ArrayCopy(mCurEQGainChBuf, gain_buf, GetAudioEQBandCount());
6651	SSMSaveAudioEQGain(0, GetAudioEQBandCount(), mCurEQGainChBuf);
6652
6653	HandleTrebleBassVolume();
6654	SaveCurAudioSoundMode (CC_SOUND_MODE_STD);
6655	mCustomAudioSoundMode = mCurAudioSoundMode;
6656	return 0;
6657	}
6658
6659	int CTv::GetCustomEQGain(int gain_buf[])
6660	{
6661	ArrayCopy(gain_buf, mCustomEQGainBuf, GetAudioEQBandCount());
6662	return 0;
6663	}
6664
6665	int CTv::SetCustomEQGain()
6666	{
6667	int tmpEQGainBuf[128] = { 0 };
6668
6669	if (MappingEQGain(mCustomEQGainBuf, tmpEQGainBuf, 0) < 0) {
6670	return -1;
6671	}
6672
6673	return RealSetEQGain(tmpEQGainBuf);
6674	}
6675
6676	int CTv::AudioSetEQGain(int gain_buf[])
6677	{
6678	int tmpEQGainBuf[128] = { 0 };
6679
6680	ArrayCopy(mCustomEQGainBuf, gain_buf, GetAudioEQBandCount());
6681
6682	if (MappingEQGain(mCustomEQGainBuf, tmpEQGainBuf, 0) < 0) {
6683	return -1;
6684	}
6685
6686	return RealSetEQGain(tmpEQGainBuf);
6687	}
6688
6689	int CTv::handleEQGainBeforeSet(int src_buf[], int dst_buf[])
6690	{
6691	int i = 0, nMinGain, nMaxGain;
6692
6693	nMinGain = CC_MIN_EQ_GAIN_VAL;
6694	nMaxGain = CC_MAX_EQ_GAIN_VAL;
6695
6696	if (GetAudioWallEffect() == CC_SWITCH_ON && GetAudioWallEffectTypeCfg() == 0) {
6697	for (i = 0; i < GetAudioEQBandCount(); i++) {
6698	dst_buf[i] = mWallEffectValueBuf[i] + src_buf[i];
6699
6700	if (dst_buf[i] < nMinGain) {
6701	dst_buf[i] = nMinGain;
6702	}
6703
6704	if (dst_buf[i] > nMaxGain) {
6705	dst_buf[i] = nMaxGain;
6706	}
6707	}
6708	} else {
6709	for (i = 0; i < GetAudioEQBandCount(); i++) {
6710	dst_buf[i] = src_buf[i];
6711	}
6712	}
6713
6714	return 0;
6715	}
6716
6717	int CTv::RealSetEQGain(int gain_buf[])
6718	{
6719	if (GetAudioWallEffect() == CC_SWITCH_ON && GetAudioWallEffectTypeCfg() == 0) {
6720	for (int i = 0; i < GetAudioEQBandCount(); i++) {
6721	gain_buf[i] = mWallEffectValueBuf[i] + gain_buf[i];
6722
6723	if (gain_buf[i] < CC_MIN_EQ_GAIN_VAL) {
6724	gain_buf[i] = CC_MIN_EQ_GAIN_VAL;
6725	}
6726
6727	if (gain_buf[i] > CC_MAX_EQ_GAIN_VAL) {
6728	gain_buf[i] = CC_MAX_EQ_GAIN_VAL;
6729	}
6730	}
6731	}
6732
6733	mAudioEffect.SetEQValue(gain_buf);
6734	return 0;
6735	}
6736
6737	int CTv::SetAtvInGain(int gain_val)
6738	{
6739	char set_str[32] = {0};
6740
6741	sprintf ( set_str, "audio_gain_set %x", gain_val );
6742	return SetFileAttrValue ( SYS_ATV_DEMOD_DEBUG, set_str );
6743	}
6744
6745	int CTv::SetSpecialModeEQGain(int tmp_val)
6746	{
6747	int tmpEQPresetBufPtr[24];
6748	if (GetAudioEQPresetBufferPtr(tmpEQPresetBufPtr) != 0) {
6749	GetDefault_EQGain_Table(tmpEQPresetBufPtr);
6750	}
6751	int tmpEQGainBuf[128] = { 0 };
6752
6753	if (tmp_val == CC_SOUND_MODE_USER) {
6754	RealReadCurAudioEQGain(tmpEQGainBuf);
6755	} else {
6756	ArrayCopy(tmpEQGainBuf,
6757	tmpEQPresetBufPtr + tmp_val * GetAudioEQBandCount(),
6758	GetAudioEQBandCount());
6759	}
6760
6761	AudioSetEQGain(tmpEQGainBuf);
6762	return tmp_val;
6763	}
6764
6765	int CTv::SetSpecialIndexEQGain(int buf_index, int w_val)
6766	{
6767	int tmpEQGainBuf[128] = { 0 };
6768
6769	if (buf_index >= 0 && buf_index < GetAudioEQBandCount()) {
6770	RealReadCurAudioEQGain(tmpEQGainBuf);
6771	tmpEQGainBuf[buf_index] = w_val;
6772
6773	return AudioSetEQGain(tmpEQGainBuf);
6774	}
6775	return -1;
6776	}
6777
6778	int CTv::SaveSpecialIndexEQGain(int buf_index, int w_val)
6779	{
6780	int tmpEQGainBuf[128] = { 0 };
6781
6782	if (buf_index >= 0 && buf_index < GetAudioEQBandCount()) {
6783	RealReadCurAudioEQGain(tmpEQGainBuf);
6784	tmpEQGainBuf[buf_index] = w_val;
6785
6786	return RealSaveCurAudioEQGain(tmpEQGainBuf, 0);
6787	}
6788
6789	return 0;
6790	}
6791
6792	// amAudio
6793	int CTv::OpenAmAudio(unsigned int sr, int input_device, int output_device)
6794	{
6795	LOGD("OpenAmAudio input_device = %d", input_device);
6796	return amAudioOpen(sr, input_device, output_device);
6797	}
6798
6799	int CTv::CloseAmAudio(void)
6800	{
6801	return amAudioClose();
6802	}
6803
6804	int CTv::SetAmAudioInputSr(unsigned int sr, int output_device)
6805	{
6806	LOGD("SetAmAudioInputSr");
6807	return amAudioSetInputSr(sr, CC_IN_USE_SPDIF_DEVICE, output_device);
6808	}
6809
6810	int CTv::SetAmAudioOutputMode(int mode)
6811	{
6812	if (mode != CC_AMAUDIO_OUT_MODE_DIRECT && mode != CC_AMAUDIO_OUT_MODE_INTER_MIX
6813	&& mode != CC_AMAUDIO_OUT_MODE_DIRECT_MIX) {
6814	LOGE("%s, mode error, it should be mix or direct!\n", __FUNCTION__);
6815	return -1;
6816	}
6817
6818	return amAudioSetOutputMode(mode);
6819	}
6820
6821	int CTv::SetAmAudioMusicGain(int gain)
6822	{
6823	return amAudioSetMusicGain(gain);
6824	}
6825
6826	int CTv::SetAmAudioLeftGain(int gain)
6827	{
6828	return amAudioSetLeftGain(gain);
6829	}
6830
6831	int CTv::SetAmAudioRightGain(int gain)
6832	{
6833	return amAudioSetRightGain(gain);
6834	}
6835
6836	int CTv::SetAudioDumpDataFlag(int tmp_flag)
6837	{
6838	return amAudioSetDumpDataFlag(tmp_flag);
6839	}
6840
6841	int CTv::GetAudioDumpDataFlag()
6842	{
6843	return amAudioGetDumpDataFlag();
6844	}
6845
6846	void CTv::AudioSetVolumeDigitLUTBuf(int lut_table_index, int *MainVolLutBuf)
6847	{
6848	int tmpDefDigitLutBuf[CC_LUT_BUF_SIZE] = { 0 };
6849	mAudioAlsa.SetMainVolDigitLutBuf(MainVolLutBuf);
6850
6851	GetAudioAmpSupbassvolBuf(lut_table_index, tmpDefDigitLutBuf);
6852	mAudioAlsa.SetSupperBassVolDigitLutBuf(tmpDefDigitLutBuf);
6853	}
6854
6855	int CTv::InitTvAudio(int sr, int input_device)
6856	{
6857	OpenAmAudio(sr, input_device, CC_OUT_USE_AMAUDIO);
6858
6859	RefreshSrsEffectAndDacGain();
6860	SetCustomEQGain();
6861	return 0;
6862	}
6863
6864	int CTv::UnInitTvAudio()
6865	{
6866	return CloseAmAudio();
6867	}
6868
6869	int CTv::AudioChangeSampleRate(int sr)
6870	{
6871	sr = HanldeAudioInputSr(sr);
6872
6873	if (SetAmAudioInputSr(sr, CC_OUT_USE_AMAUDIO) != 0) {
6874	return -1;
6875	}
6876
6877	RefreshSrsEffectAndDacGain();
6878	SetCustomEQGain();
6879	return 0;
6880	}
6881
6882	int CTv::AudioSetAudioInSource(int audio_src_in_type)
6883	{
6884	return mAudioAlsa.SetAudioInSource(audio_src_in_type);
6885	}
6886
6887	int CTv::AudioSetAudioSourceType(int source_type)
6888	{
6889	int aud_arch_type = GetAudioArchitectureTypeCFG();
6890
6891	if (aud_arch_type == CC_DAC_G9TV_EXTERNAL_DAC_ON_BOARD) {
6892	} else if (aud_arch_type == CC_DAC_G9TV_EXTERNAL_DAC_OFF_BOARD_FBC) {
6893	SendCmdToOffBoardFBCExternalDac(AUDIO_CMD_SET_SOURCE, source_type);
6894	} else if (aud_arch_type == CC_DAC_G9TV_EXTERNAL_DAC_CUSTOMER_LIB) {
6895	mCustomerCtrl.SetSource(source_type);
6896	} else if (aud_arch_type == CC_DAC_G9TV_EXTERNAL_DAC_DIGITAL) {
6897	}
6898	return 0;
6899	}
6900
6901	int CTv::AudioLineInSelectChannel(int audio_channel)
6902	{
6903	LOGD ("%s, audio_channel = %d", __FUNCTION__, audio_channel);
6904	mAudioAlsa.SetInternalDacLineInSelectChannel(audio_channel);
6905	return 0;
6906	}
6907
6908	int CTv::SetKalaokIO(int level)
6909	{
6910	LOGD ("%s, SetKalaokIO = %d", __FUNCTION__, level);
6911	if (GetKaraokAvEnable() == 1) {
6912	mAudioAlsa.SetAudioSwitchIO(level);
6913	}
6914	return 0;
6915	}
6916
6917	int CTv::AudioSetLineInCaptureVolume(int l_vol, int r_vol)
6918	{
6919	mAudioAlsa.SetInternalDacLineInCaptureVolume(l_vol, r_vol);
6920	return 0;
6921	}
6922
6923	int CTv::openTvAudio()
6924	{
6925	int tmp_val = 0;
6926
6927	LOGD("%s, entering...\n", __FUNCTION__);
6928	UnInitSetTvAudioCard();
6929
6930	tmp_val = GetAudioDumpDataEnableFlagCfg();
6931	SetAudioDumpDataFlag(tmp_val);
6932
6933	tmp_val = GetAudioInternalDacPGAInGain_Cfg();
6934	mAudioAlsa.SetAudioInternalDacPGAInGain(tmp_val, tmp_val);
6935
6936	mAudioAlsa.SetMixerBypassSwitch (CC_SWITCH_OFF);
6937	mAudioAlsa.SetMixerDacSwitch (CC_SWITCH_ON);
6938
6939	LoadAudioCtl();
6940
6941	RefreshSrsEffectAndDacGain();
6942	InitSetAudioCtl();
6943	return 0;
6944	}
6945
6946	int CTv::closeTvAudio()
6947	{
6948	return 0;
6949	}
6950
6951	void CTv::LoadAudioCtl()
6952	{
6953	// Get Current Audio Volume
6954	LoadCurAudioMasterVolume();
6955
6956	// Get Current Audio Balance
6957	LoadCurAudioBalance();
6958
6959	// Get Current Supper Bass Switch
6960	LoadCurAudioSupperBassSwitch();
6961
6962	// Get Current Supper Bass Volume
6963	LoadCurAudioSupperBassVolume();
6964
6965	// Get Current SRSSurround
6966	LoadCurAudioSrsSurround();
6967
6968	// Get Current SRS DialogClarity
6969	LoadCurAudioSrsDialogClarity();
6970
6971	// Get Current SRS TruBass
6972	LoadCurAudioSrsTruBass();
6973
6974	// Get Current Audio Sound Mode
6975	LoadCurAudioSoundMode();
6976
6977	// Get Current Audio Bass and Treble
6978	LoadCurAudioBassVolume();
6979	LoadCurAudioTrebleVolume();
6980
6981	// Get Current Wall Effect
6982	LoadCurAudioWallEffect();
6983
6984	// Get Current spdif switch
6985	LoadCurAudioSPDIFSwitch();
6986
6987	// Get Current spdif mode
6988	LoadCurAudioSPDIFMode();
6989
6990	// Get Current EQ mode
6991	LoadCurAudioEQMode();
6992
6993	// Get Current EQ Gain
6994	LoadCurAudioEQGain();
6995	}
6996
6997	void CTv::InitSetAudioCtl()
6998	{
6999	// Set Current Audio balance value
7000	SetAudioBalance(GetAudioBalance());
7001
7002	// Set Current Audio Volume
7003	SetAudioMasterVolume(GetAudioMasterVolume());
7004
7005	// Set Current Supper Bass Volume
7006	SetAudioSupperBassVolume(GetAudioSupperBassVolume());
7007
7008	// Set Current Audio Sound Mode
7009	SetAudioSoundMode(GetAudioSoundMode());
7010
7011	// Set Current Audio SPDIF Switch
7012	SetAudioSPDIFSwitch(GetCurAudioSPDIFSwitch());
7013
7014	// Set Current Audio SPDIF mode
7015	SetAudioSPDIFMode(GetCurAudioSPDIFMode());
7016	}
7017
7018	int CTv::SetADC_Digital_Capture_Volume(int value)
7019	{
7020	return mAudioAlsa.SetAudioInternalDacADCDigitalCaptureVolume( value, value);
7021	}
7022
7023	int CTv::SetPGA_IN_Value(int value)
7024	{
7025	return mAudioAlsa.SetAudioInternalDacPGAInGain( value, value);
7026	}
7027
7028	int CTv::SetDAC_Digital_PlayBack_Volume(int value)
7029	{
7030	return mAudioAlsa.SetAudioInternalDacDACDigitalPlayBackVolume( value, value);
7031	}
7032
7033	int CTv::setAudioPcmPlaybackVolume(int val)
7034	{
7035	int pcm_volume = 0;
7036	pcm_volume = val / 2;
7037	if (pcm_volume > 24) pcm_volume = 24;
7038	//return SetAudioPcmPlaybackVolume(pcm_volume);
7039	return 0;
7040	}
7041
7042	int CTv::HanldeAudioInputSr(unsigned int sr)
7043	{
7044	int tmp_cfg = 0;
7045
7046	tmp_cfg = GetAudioResampleTypeCFG();
7047	if (tmp_cfg & CC_AUD_RESAMPLE_TYPE_HW) {
7048	mAudioAlsa.SetHardwareResample(sr);
7049	} else {
7050	mAudioAlsa.SetHardwareResample(-1);
7051	}
7052
7053	if (!(tmp_cfg & CC_AUD_RESAMPLE_TYPE_SW)) {
7054	sr = 48000;
7055	}
7056
7057	return sr;
7058	}
7059
7060	int CTv::AudioSSMRestoreDefaultSetting()
7061	{
7062	int i = 0, tmp_val = 0;
7063	int nMinUIVol = 0, nMaxUIVol = 0;
7064	int *tmp_ptr = NULL;
7065	int tmpEQGainBuf[128] = { 0 };
7066	unsigned char tmp_buf[CC_NO_LINE_POINTS_MAX_CNT] = { 0 };
7067
7068	// Save Current Audio Volume
7069	SaveCurAudioMasterVolume (CC_DEF_SOUND_VOL);
7070
7071	// Save Current Audio Balance
7072	SaveCurAudioBalance (CC_DEF_SOUND_BALANCE_VAL);
7073
7074	// Save Current Supper Bass Switch
7075	SaveCurAudioSupperBassSwitch (CC_SWITCH_OFF);
7076
7077	// Save Current Supper Bass Volume
7078	SaveCurAudioSupperBassVolume (CC_DEF_SUPPERBASS_VOL);
7079
7080	// Save Current SRSSurround
7081	SaveCurAudioSrsSurround(CC_SWITCH_OFF);
7082
7083	// Save Current SRS DialogClarity
7084	SaveCurAudioSrsDialogClarity(CC_SWITCH_OFF);
7085
7086	// Save Current SRS TruBass
7087	SaveCurAudioSrsTruBass(CC_SWITCH_OFF);
7088
7089	// Save Current Audio Sound Mode
7090	SaveCurAudioSoundMode (CC_SOUND_MODE_STD);
7091
7092	// Save Current Wall Effect
7093	SaveCurAudioWallEffect(CC_SWITCH_OFF);
7094
7095	// Save Current spdif switch
7096	SaveCurAudioSPDIFSwitch (CC_SWITCH_ON);
7097
7098	// Save Current spdif mode
7099	SaveCurAudioSPDIFMode (CC_SPDIF_MODE_PCM);
7100
7101	// Save Current avout and spidif mute state
7102	SSMSaveAudioSPIDFMuteVal(CC_AUDIO_MUTE);
7103	SSMSaveAudioAVOutMuteVal(CC_AUDIO_MUTE);
7104
7105	// Save Current EQ mode
7106	SaveCurAudioEQMode (CC_EQ_MODE_NOMAL);
7107
7108	// Save Current EQ Gain
7109	RestoreToAudioDefEQGain(tmpEQGainBuf);
7110
7111	// Save Current Audio Bass and Treble
7112	nMinUIVol = GetBassUIMinGainVal();
7113	nMaxUIVol = GetBassUIMaxGainVal();
7114	RealSaveCurAudioBassVolume((nMinUIVol + nMaxUIVol) / 2, 0);
7115
7116	nMinUIVol = GetTrebleUIMinGainVal();
7117	nMaxUIVol = GetTrebleUIMaxGainVal();
7118	RealSaveCurAudioTrebleVolume((nMinUIVol + nMaxUIVol) / 2, 0);
7119	return 0;
7120	}
7121
7122	int CTv::InitSetTvAudioCard()
7123	{
7124	int captureIdx = -1;
7125	char buf[32] = { 0 };
7126	char propValue[PROPERTY_VALUE_MAX];
7127
7128	#ifndef BOARD_ALSA_AUDIO_TINY
7129	snd_card_refresh_info();
7130	#endif
7131
7132	if (GetTvAudioCardNeedSet()) {
7133	int totleNum = 0;
7134	char cardName[64] = { 0 };
7135
7136	GetTvAudioCardName(cardName);
7137	/*
7138	memset(propValue, '\0', PROPERTY_VALUE_MAX);
7139	property_get(PROP_AUDIO_CARD_NUM, propValue, "0");
7140
7141	totleNum = strtoul(propValue, NULL, 10);
7142	LOGD("%s, totle number = %d\n", __FUNCTION__, totleNum);
7143	*/
7144	totleNum = 8;
7145
7146	for (int i = 0; i < totleNum; i++) {
7147	sprintf(buf, "snd.card.%d.name", i);
7148	memset(propValue, '\0', PROPERTY_VALUE_MAX);
7149	property_get(buf, propValue, "null");
7150
7151	LOGD("%s, key string \"%s\", value string \"%s\".\n", __FUNCTION__, buf, propValue);
7152	if (strcmp(propValue, cardName) == 0) {
7153	captureIdx = i;
7154	break;
7155	}
7156	}
7157	}
7158
7159	sprintf(buf, "%d", captureIdx);
7160	property_set(PROP_DEF_CAPTURE_NAME, buf);
7161	LOGD("%s, set \"%s\" as \"%s\".\n", __FUNCTION__, PROP_DEF_CAPTURE_NAME, buf);
7162	return 0;
7163	}
7164
7165	int CTv::UnInitSetTvAudioCard()
7166	{
7167	#ifndef BOARD_ALSA_AUDIO_TINY
7168	snd_card_refresh_info();
7169	#endif
7170	property_set(PROP_DEF_CAPTURE_NAME, "-1");
7171	LOGD("%s, set [%s]:[-1]\n", __FUNCTION__, PROP_DEF_CAPTURE_NAME);
7172	return 0;
7173	}
7174
7175	int CTv::SetSPDIFMode(int mode_val)
7176	{
7177	FILE *fp = fopen(SYS_SPDIF_MODE_DEV_PATH, "w");
7178	if (fp == NULL) {
7179	LOGE("%s, Open file %s error(%s)!\n", __FUNCTION__, SYS_SPDIF_MODE_DEV_PATH, strerror(errno));
7180	return -1;
7181	}
7182
7183	if (mode_val == CC_SPDIF_MODE_PCM) {
7184	fprintf(fp, "%d", 0);
7185	} else if (mode_val == CC_SPDIF_MODE_RAW ) {
7186	fprintf(fp, "%d", 1);
7187	}
7188
7189	fclose(fp);
7190	fp = NULL;
7191	return 0;
7192	}
7193
7194	int CTv::SwitchAVOutBypass(int sw)
7195	{
7196	if (sw == 0 ) {
7197	mAudioAlsa.SetMixerBypassSwitch ( CC_SWITCH_OFF );
7198	mAudioAlsa.SetMixerDacSwitch ( CC_SWITCH_ON );
7199	} else {
7200	mAudioAlsa.SetMixerBypassSwitch ( CC_SWITCH_ON );
7201	mAudioAlsa.SetMixerDacSwitch ( CC_SWITCH_OFF );
7202	}
7203	return 0;
7204	}
7205
7206	int CTv::SetAudioSwitchIO(int value)
7207	{
7208	return mAudioAlsa.SetAudioSwitchIO( value);
7209	}
7210
7211	int CTv::SetOutput_Swap(int value)
7212	{
7213	return mAudioAlsa.SetOutput_Swap( value);
7214	}
7215
7216	int CTv::SendCmdToOffBoardFBCExternalDac(int cmd, int para)
7217	{
7218	int set_val = 0;
7219	CFbcCommunication *pFBC = GetSingletonFBC();
7220	if (pFBC != NULL) {
7221	if (cmd == AUDIO_CMD_SET_MUTE) {
7222	if (para == CC_AUDIO_MUTE) {
7223	set_val = CC_MUTE_ON;
7224	} else if (para == CC_AUDIO_UNMUTE) {
7225	set_val = CC_MUTE_OFF;
7226	} else {
7227	return -1;
7228	}
7229
7230	return pFBC->cfbc_Set_Mute(COMM_DEV_SERIAL, set_val);
7231	} else if (cmd == AUDIO_CMD_SET_VOLUME_BAR) {
7232	LOGD("%s, send AUDIO_CMD_SET_VOLUME_BAR (para = %d) to fbc.\n", __FUNCTION__, para);
7233	return pFBC->cfbc_Set_Volume_Bar(COMM_DEV_SERIAL, para);
7234	} else if (cmd == AUDIO_CMD_SET_BALANCE) {
7235	LOGD("%s, send AUDIO_CMD_SET_BALANCE (para = %d) to fbc.\n", __FUNCTION__, para);
7236	return pFBC->cfbc_Set_Balance(COMM_DEV_SERIAL, para);
7237	} else if (cmd == AUDIO_CMD_SET_SOURCE) {
7238	LOGD("%s, send AUDIO_CMD_SET_SOURCE (para = %d) to fbc.\n", __FUNCTION__, para);
7239	return pFBC->cfbc_Set_FBC_Audio_Source(COMM_DEV_SERIAL, para);
7240	}
7241	}
7242	return 0;
7243	}
7244
7245	int CTv::GetHdmiAvHotplugDetectOnoff()
7246	{
7247	const char *value = config_get_str ( CFG_SECTION_TV, CFG_SSM_HDMI_AV_DETECT, "null" );
7248	if ( strtoul(value, NULL, 10) == 1 ) {
7249	return 1;
7250	}
7251
7252	return 0;
7253	}
7254
7255