summaryrefslogtreecommitdiff
path: root/tvapi/libtv/tv/CFrontEnd.cpp (plain)
blob: c45e62bafe388ac68604a11522296aaf1a6e8936
1#define LOG_TAG "CFrontEnd"
2
3#include <stdio.h>
4#include <unistd.h>
5#include <string.h>
6#include <fcntl.h>
7#include <errno.h>
8#include <sys/ioctl.h>
9#include <stdlib.h>
10#include <malloc.h>
11#include <sys/types.h>
12#include <dlfcn.h>
13#include <time.h>
14#include "am_misc.h"
15#include "am_debug.h"
16#include "CFrontEnd.h"
17#include "util.h"
18#include "tvin/CTvin.h"
19extern "C" {
20#include "am_av.h"
21#include "am_dmx.h"
22#include "linux/videodev2.h"
23#include "am_fend_ctrl.h"
24}
25
26CFrontEnd::CFrontEnd()
27{
28 mFrontDevID = FE_DEV_ID;
29 mpObserver = NULL;
30 mCurFineFreq = 0;
31 mCurMode = FE_ANALOG;
32 mCurFreq = -1;
33 mCurPara1 = -1;
34 mCurPara2 = -1;
35 mbFEOpened = false;
36}
37
38CFrontEnd::~CFrontEnd()
39{
40 AM_EVT_Unsubscribe(mFrontDevID, AM_FEND_EVT_STATUS_CHANGED, dmd_fend_callback, NULL);
41 if (mFrontDevID == FE_DEV_ID)
42 AM_FEND_Close(mFrontDevID);
43 mFrontDevID = -1;
44}
45
46int CFrontEnd::Open(int mode)
47{
48 AM_FEND_OpenPara_t para;
49 int rc = 0;
50
51 if (mbFEOpened) {
52 LOGD("FrontEnd have opened, return");
53 return 0;
54 }
55 mbFEOpened = true;
56 memset(&para, 0, sizeof(AM_FEND_OpenPara_t));
57 para.mode = mode;
58 rc = AM_FEND_Open(mFrontDevID, &para);
59 if ((rc == AM_FEND_ERR_BUSY) || (rc == 0)) {
60 AM_EVT_Subscribe(mFrontDevID, AM_FEND_EVT_STATUS_CHANGED, dmd_fend_callback, this);
61 LOGD("%s,frontend dev open success!\n", __FUNCTION__);
62 return 0;
63 } else {
64 LOGD("%s,frontend dev open failed! dvb error id is %d\n", __FUNCTION__, rc);
65 return -1;
66 }
67 mCurMode = mode;
68 mCurFreq = -1;
69 mCurPara1 = -1;
70 mCurPara2 = -1;
71}
72
73int CFrontEnd::Close()
74{
75 int rc = 0;
76 if (!mbFEOpened) {
77 LOGD("FrontEnd have close, but not return");
78 }
79 rc = AM_FEND_Close(mFrontDevID);
80 mbFEOpened = false;
81 mCurMode = -1;
82 mCurFreq = -1;
83 mCurPara1 = -1;
84 mCurPara2 = -1;
85 if (rc != 0) {
86 LOGD("%s,frontend_close fail! dvb error id is %d\n", __FUNCTION__, rc);
87 return -1;
88 } else {
89 LOGD("%s,close frontend is ok\n", __FUNCTION__);
90 }
91 return 0;
92}
93
94int CFrontEnd::setMode(int mode)
95{
96 int rc = 0;
97 if (mCurMode == mode) return 0;
98 rc = AM_FEND_SetMode(mFrontDevID, mode);
99
100 if (rc != 0) {
101 LOGD("%s,front dev set mode failed! dvb error id is %d\n", __FUNCTION__, rc);
102 return -1;
103 }
104 return 0;
105}
106
107int CFrontEnd::setPara(int mode, int freq, int para1, int para2)
108{
109 int ret = 0;
110 int buff_size = 32;
111 char VideoStdBuff[buff_size];
112 char audioStdBuff[buff_size];
113 if (mCurMode == mode && mCurFreq == freq && mCurPara1 == para1 && mCurPara2 == para2) {
114 LOGD("fe setpara is same return");
115 return 0;
116 }
117 mCurMode = mode;
118 mCurFreq = freq;
119 mCurPara1 = para1;
120 mCurPara2 = para2;
121
122 AM_FENDCTRL_DVBFrontendParameters_t dvbfepara;
123 memset(&dvbfepara, 0, sizeof(AM_FENDCTRL_DVBFrontendParameters_t));
124 LOGD("%s,set fe para mode = %d freq=%d p1=%d p2=%d", __FUNCTION__, mode, freq, para1, para2);
125 dvbfepara.m_type = mode;
126 switch (mode) {
127 case FE_OFDM:
128 dvbfepara.terrestrial.para.frequency = freq;
129 dvbfepara.terrestrial.para.u.ofdm.bandwidth = (fe_bandwidth_t)para1;
130 break;
131 case FE_DTMB:
132 LOGD("%s,FE_DTMB is support\n", __FUNCTION__);
133 LOGD("%s,freq = %d, bandwidth = %d\n", __FUNCTION__, freq, para1);
134 dvbfepara.dtmb.para.frequency = freq;
135 dvbfepara.dtmb.para.u.ofdm.bandwidth = (fe_bandwidth_t)para1;
136 break;
137 case FE_ATSC:
138 dvbfepara.atsc.para.frequency = freq;
139 dvbfepara.atsc.para.u.vsb.modulation = (fe_modulation_t)para1;
140 break;
141 case FE_QAM:
142 dvbfepara.cable.para.frequency = freq;
143 dvbfepara.cable.para.u.qam.symbol_rate = para1;
144 dvbfepara.cable.para.u.qam.modulation = (fe_modulation_t)para2;
145 break;
146 case FE_ANALOG:
147 LOGD("%s,FE_ANALOG is support\n", __FUNCTION__);
148 /*para2 is finetune data */
149 dvbfepara.analog.para.frequency = freq;
150 dvbfepara.analog.para.u.analog.std = para1;
151 dvbfepara.analog.para.u.analog.afc_range = AFC_RANGE;
152 if (para2 == 0) {
153 dvbfepara.analog.para.u.analog.flag |= ANALOG_FLAG_ENABLE_AFC;
154 } else {
155 dvbfepara.analog.para.u.analog.flag &= ~ANALOG_FLAG_ENABLE_AFC;
156 dvbfepara.analog.para.u.analog.afc_range = 0;
157 }
158
159 printAudioStdStr(para1, audioStdBuff, buff_size);
160 printVideoStdStr(para1, VideoStdBuff, buff_size);
161 LOGD("%s,freq = %dHz, video_std = %s, audio_std = %s, fineFreqOffset = %dHz\n", __FUNCTION__,
162 freq, VideoStdBuff, audioStdBuff, para2);
163
164 break;
165 }
166
167 ret = AM_FENDCTRL_SetPara(mFrontDevID, &dvbfepara);
168
169 if (ret != 0) {
170 LOGD("%s,fend set para failed! dvb error id is %d\n", __FUNCTION__, ret);
171 return -1;
172 }
173 return 0;
174}
175
176int CFrontEnd::fineTune(int fineFreq)
177{
178 int ret = 0;
179 if (mCurFineFreq == fineFreq) return -1;
180
181 mCurFineFreq = fineFreq;
182 ret = AM_FEND_FineTune(FE_DEV_ID, fineFreq);
183
184 if (ret != 0) {
185 LOGD("%s, fail! dvb error id is %d", __FUNCTION__, ret);
186 return -1;
187 }
188 return 0;
189}
190
191int CFrontEnd::GetTSSource(AM_DMX_Source_t *src)
192{
193 AM_FEND_GetTSSource(mFrontDevID, src);
194 return 0;
195}
196
197void CFrontEnd::dmd_fend_callback(long dev_no __unused, int event_type __unused, void *param, void *user_data)
198{
199 CFrontEnd *pFront = (CFrontEnd *)user_data;
200 if (NULL == pFront) {
201 LOGD("%s,warnning : dmd_fend_callback NULL == pFront\n", __FUNCTION__);
202 return ;
203 }
204 if (pFront->mpObserver == NULL) {
205 LOGD("%s,warnning : mpObserver NULL == mpObserver\n", __FUNCTION__);
206 return;
207 }
208 struct dvb_frontend_event *evt = (struct dvb_frontend_event *) param;
209 if (!evt)
210 return;
211
212 if (evt->status & FE_HAS_LOCK) {
213 pFront->mCurSigEv.mCurSigStaus = FEEvent::EVENT_FE_HAS_SIG;
214 pFront->mCurSigEv.mCurFreq = evt->parameters.frequency;
215 pFront->mpObserver->onEvent(pFront->mCurSigEv);
216 } else if (evt->status & FE_TIMEDOUT) {
217 pFront->mCurSigEv.mCurSigStaus = FEEvent::EVENT_FE_NO_SIG;
218 pFront->mCurSigEv.mCurFreq = evt->parameters.frequency;
219 pFront->mpObserver->onEvent(pFront->mCurSigEv);
220 }
221}
222
223int CFrontEnd::stdAndColorToAudioEnum(int data)
224{
225 atv_audio_std_t std = CC_ATV_AUDIO_STD_DK;
226 if (((data & V4L2_STD_PAL_DK) == V4L2_STD_PAL_DK) ||
227 ((data & V4L2_STD_SECAM_DK) == V4L2_STD_SECAM_DK)) {
228 std = CC_ATV_AUDIO_STD_DK;
229 } else if ((data & V4L2_STD_PAL_I) == V4L2_STD_PAL_I) {
230 std = CC_ATV_AUDIO_STD_I;
231 } else if (((data & V4L2_STD_PAL_BG) == V4L2_STD_PAL_BG) ||
232 ((data & V4L2_STD_SECAM_B) == V4L2_STD_SECAM_B) ||
233 ((data & V4L2_STD_SECAM_G) == V4L2_STD_SECAM_G )) {
234 std = CC_ATV_AUDIO_STD_BG;
235 } else if (((data & V4L2_STD_PAL_M) == V4L2_STD_PAL_M) ||
236 ((data & V4L2_STD_NTSC_M) == V4L2_STD_NTSC_M)) {
237 std = CC_ATV_AUDIO_STD_M;
238 } else if ((data & V4L2_STD_SECAM_L) == V4L2_STD_SECAM_L) {
239 std = CC_ATV_AUDIO_STD_L;
240 }
241 return std ;
242}
243
244int CFrontEnd::stdAndColorToVideoEnum(int std)
245{
246 atv_video_std_t video_standard = CC_ATV_VIDEO_STD_PAL;
247 if ((std & V4L2_COLOR_STD_PAL) == V4L2_COLOR_STD_PAL) {
248 video_standard = CC_ATV_VIDEO_STD_PAL;
249 } else if ((std & V4L2_COLOR_STD_NTSC) == V4L2_COLOR_STD_NTSC) {
250 video_standard = CC_ATV_VIDEO_STD_NTSC;
251 } else if ((std & V4L2_COLOR_STD_SECAM) == V4L2_COLOR_STD_SECAM) {
252 video_standard = CC_ATV_VIDEO_STD_SECAM;
253 }
254 return video_standard;
255}
256
257bool CFrontEnd::stdIsColorAuto(int std)
258{
259 return ((std & V4L2_COLOR_STD_AUTO) == V4L2_COLOR_STD_AUTO) ? true : false;
260}
261
262int CFrontEnd::addColorAutoFlag(int std)
263{
264 return std | V4L2_COLOR_STD_AUTO;
265}
266v4l2_std_id CFrontEnd::enumToStdAndColor(int videoStd, int audioStd)
267{
268 v4l2_std_id tmpTunerStd = 0;
269 if (videoStd == CC_ATV_VIDEO_STD_PAL) {
270 tmpTunerStd |= V4L2_COLOR_STD_PAL;
271 if (audioStd == CC_ATV_AUDIO_STD_DK) {
272 tmpTunerStd |= V4L2_STD_PAL_DK;
273 } else if (audioStd == CC_ATV_AUDIO_STD_I) {
274 tmpTunerStd |= V4L2_STD_PAL_I;
275 } else if (audioStd == CC_ATV_AUDIO_STD_BG) {
276 tmpTunerStd |= V4L2_STD_PAL_BG;
277 } else if (audioStd == CC_ATV_AUDIO_STD_M) {
278 tmpTunerStd |= V4L2_STD_PAL_M;
279 }
280 } else if (videoStd == CC_ATV_VIDEO_STD_NTSC || videoStd == CC_ATV_VIDEO_STD_AUTO) {
281 tmpTunerStd |= V4L2_COLOR_STD_NTSC;
282 if (audioStd == CC_ATV_AUDIO_STD_DK) {
283 tmpTunerStd |= V4L2_STD_PAL_DK;
284 } else if (audioStd == CC_ATV_AUDIO_STD_I) {
285 tmpTunerStd |= V4L2_STD_PAL_I;
286 } else if (audioStd == CC_ATV_AUDIO_STD_BG) {
287 tmpTunerStd |= V4L2_STD_PAL_BG;
288 } else if (audioStd == CC_ATV_AUDIO_STD_M) {
289 tmpTunerStd |= V4L2_STD_NTSC_M;
290 }
291 } else if (videoStd == CC_ATV_VIDEO_STD_SECAM) {
292 tmpTunerStd |= V4L2_COLOR_STD_SECAM;
293 if (audioStd == CC_ATV_AUDIO_STD_DK) {
294 tmpTunerStd |= V4L2_STD_SECAM_DK;
295 } else if (audioStd == CC_ATV_AUDIO_STD_I) {
296 tmpTunerStd |= V4L2_STD_PAL_I;
297 } else if (audioStd == CC_ATV_AUDIO_STD_BG) {
298 tmpTunerStd |= (V4L2_STD_SECAM_B | V4L2_STD_SECAM_G);
299 } else if (audioStd == CC_ATV_AUDIO_STD_M) {
300 tmpTunerStd |= V4L2_STD_NTSC_M;
301 } else if (audioStd == CC_ATV_AUDIO_STD_L) {
302 tmpTunerStd |= V4L2_STD_SECAM_L;
303 }
304
305 }
306 return tmpTunerStd;
307}
308
309int CFrontEnd::getPara(int *mode, int *freq, int *para1, int *para2)
310{
311
312 struct dvb_frontend_parameters para;
313 memset(&para, 0, sizeof(struct dvb_frontend_parameters));
314 /*if((ret1=AM_FEND_GetPara(mFrontDevID, &para))<0) {
315 LOGD("%s,getPara faiture\n", __FUNCTION__ );
316 return -1;
317
318 //fpara->mode = fend_mode ;
319
320 }*/
321 *mode = mCurMode;
322 *freq = mCurFreq;
323 *para1 = mCurPara1;
324 *para2 = mCurPara2;
325 return 0;
326}
327
328int CFrontEnd::getSNR()
329{
330 int snr = 0;
331 AM_FEND_GetSNR(mFrontDevID, &snr);
332 return snr;
333}
334
335int CFrontEnd::getBER()
336{
337 int ber = 0;
338 AM_FEND_GetBER(mFrontDevID, &ber);
339 return ber;
340}
341
342int CFrontEnd::getStrength()
343{
344 int Strength = 0;
345 AM_FEND_GetStrength(mFrontDevID, &Strength);
346 return Strength;
347}
348
349int CFrontEnd::formatATVFreq(int tmp_freq)
350{
351 const int ATV_1MHZ = 1000000;
352 const int ATV_50KHZ = 50 * 1000;
353 const int ATV_25KHZ = 25 * 1000;
354 int mastar = (tmp_freq / ATV_50KHZ) * ATV_50KHZ;
355 int follow = tmp_freq % ATV_50KHZ;
356 if (follow >= ATV_25KHZ) {
357 follow = ATV_50KHZ;
358 } else {
359 follow = 0;
360 }
361 return mastar + follow;
362}
363
364int CFrontEnd::printVideoStdStr(int compStd, char strBuffer[], int buff_size)
365{
366 memset(strBuffer, 0, buff_size);
367 int videoStd = stdAndColorToVideoEnum(compStd);
368 switch (videoStd) {
369 case CC_ATV_VIDEO_STD_AUTO:
370 strcpy(strBuffer, "AUTO");
371 break;
372 case CC_ATV_VIDEO_STD_PAL:
373 strcpy(strBuffer, "PAL");
374 break;
375 case CC_ATV_VIDEO_STD_NTSC:
376 strcpy(strBuffer, "NTSC");
377 break;
378 case CC_ATV_VIDEO_STD_SECAM:
379 strcpy(strBuffer, "SECAM");
380 break;
381 default:
382 strcpy(strBuffer, "UnkownVideo");
383 break;
384 }
385
386 return 0;
387}
388
389int CFrontEnd::printAudioStdStr(int compStd, char strBuffer[], int buff_size)
390{
391 memset(strBuffer, 0, buff_size);
392 int audioStd = stdAndColorToAudioEnum(compStd);
393 switch (audioStd) {
394 case CC_ATV_AUDIO_STD_DK:
395 strcpy(strBuffer, "DK");
396 break;
397 case CC_ATV_AUDIO_STD_I:
398 strcpy(strBuffer, "I");
399 break;
400 case CC_ATV_AUDIO_STD_BG:
401 strcpy(strBuffer, "BG");
402 break;
403 case CC_ATV_AUDIO_STD_M:
404 strcpy(strBuffer, "M");
405 break;
406 case CC_ATV_AUDIO_STD_L:
407 strcpy(strBuffer, "L");
408 break;
409 case CC_ATV_AUDIO_STD_AUTO:
410 strcpy(strBuffer, "AUTO");
411 break;
412 default:
413 strcpy(strBuffer, "UnkownAudio");
414 break;
415 }
416
417 return 0;
418}
419
420int CFrontEnd::autoLoadFE()
421{
422 FILE *fp = NULL;
423 int ret = -1;
424
425 fp = fopen ( "/sys/class/amlfe/setting", "w" );
426
427 if ( fp == NULL ) {
428 LOGW ( "Open /sys/class/amlfe/setting error(%s)!\n", strerror ( errno ) );
429 return -1;
430 }
431
432 ret = fprintf ( fp, "%s", "autoload" );
433
434 if ( ret < 0 ) {
435 LOGW ( "autoload FE error(%s)!\n", strerror ( errno ) );
436 }
437 LOGD("autoLoadFE");
438 fclose ( fp );
439 fp = NULL;
440
441 return ret;
442}
443
444int CFrontEnd::setCvbsAmpOut(int tmp)
445{
446 int rc = AM_SUCCESS;
447 rc = AM_FEND_SetCvbsAmpOut(mFrontDevID, tmp);
448 if (rc == AM_SUCCESS) {
449 LOGD("%s, sucessful!", __FUNCTION__);
450 rc = 0;
451 } else {
452 LOGD("%s, fail!", __FUNCTION__);
453 rc = -1;
454 }
455 return rc;
456}
457
458int CFrontEnd::setThreadDelay(int delay)
459{
460 int rc = AM_SUCCESS;
461
462 rc = AM_FEND_SetThreadDelay(mFrontDevID, delay);
463 if (rc == AM_SUCCESS) {
464 LOGD("frontend_setThreadDelay sucessful!\n");
465 return 0;
466 } else {
467 LOGD("frontend_setThreadDelay fail! %d\n\n", rc);
468 return -1;
469 }
470}
471
472int CFrontEnd::lock(int frequency, int symbol_rate, int modulation, int bandwidth __unused)
473{
474 int rt = -1;
475 struct dvb_frontend_parameters fparam;
476 struct dvb_frontend_info finfo;
477
478 memset(&fparam, 0, sizeof(struct dvb_frontend_parameters));
479 memset(&finfo, 0, sizeof(struct dvb_frontend_info));
480
481 AM_FEND_GetInfo(mFrontDevID, &finfo);
482
483 if (frequency == 0)
484 return -1;
485 fparam.frequency = frequency;
486
487 switch (finfo.type) {
488
489 case FE_QAM:
490 default:
491
492 if (symbol_rate == 0)
493 return -1;
494 fparam.u.qam.symbol_rate = symbol_rate;
495
496
497 if (modulation == 0)
498 return -1;
499 fparam.u.qam.modulation = (fe_modulation_t)modulation;
500
501 LOGD("mFrontDevID = %d;fre=%d;sym=%d;qam=%d ",
502 mFrontDevID, fparam.frequency, fparam.u.qam.symbol_rate, fparam.u.qam.modulation);
503 break;
504 case FE_OFDM:
505 case FE_ATSC:
506 LOGD("mFrontDevID = %d;fre=%d;bw=%d\n ",
507 mFrontDevID, fparam.frequency, fparam.u.ofdm.bandwidth);
508 break;
509 case FE_QPSK:
510 LOGD("QPSK are not supported.\n ");
511 break;
512 case FE_ANALOG:
513 LOGD("ANALOG is supported.\n ");
514 fparam.u.analog.std = V4L2_STD_PAL_I;
515 break;
516 }
517
518 fe_status_t status;
519
520 rt = AM_FEND_Lock(FE_DEV_ID, &fparam, &status);
521
522 if ((!rt) && (status & FE_HAS_LOCK)) {
523 LOGD("frontend_lock sucessful!\n");
524 return true;
525 } else {
526 LOGD("frontend_lock fail %d!\n", rt);
527 return false;
528 }
529}
530
531int CFrontEnd::getInfo()
532{
533 struct dvb_frontend_info finfo;
534
535 AM_FEND_GetInfo(mFrontDevID, &finfo);
536
537 //return fend_info; noitfy FrontEnd message
538 return 0;
539}
540
541int CFrontEnd::setTunerAfc(int afc)
542{
543 AM_FEND_SetAfc(FE_DEV_ID, afc);
544 return 0;
545}
546
547int CFrontEnd::getStatus()
548{
549 fe_status_t status;
550 AM_FEND_GetStatus(mFrontDevID, &status);
551
552 return status;
553}
554int CFrontEnd::checkStatusOnce()
555{
556 fe_status_t status;
557 AM_FEND_GetStatus(mFrontDevID, &status);
558 LOGD("%s,get status = %x", __FUNCTION__, status);
559 if (status & FE_HAS_LOCK) {
560 mCurSigEv.mCurSigStaus = FEEvent::EVENT_FE_HAS_SIG;
561 mCurSigEv.mCurFreq = 0;
562 mpObserver->onEvent(mCurSigEv);
563 } else if (status & FE_TIMEDOUT) {
564 mCurSigEv.mCurSigStaus = FEEvent::EVENT_FE_NO_SIG;
565 mCurSigEv.mCurFreq = 0;
566 mpObserver->onEvent(mCurSigEv);
567 }
568 return 0;
569}
570
571int CFrontEnd::stdEnumToCvbsFmt (int videoStd, int audioStd)
572{
573 tvin_sig_fmt_e cvbs_fmt = TVIN_SIG_FMT_NULL;
574
575 if ( videoStd == CC_ATV_VIDEO_STD_PAL ) {
576 cvbs_fmt = TVIN_SIG_FMT_CVBS_PAL_I;
577 if ( audioStd == CC_ATV_AUDIO_STD_DK ) {
578 cvbs_fmt = TVIN_SIG_FMT_CVBS_PAL_I;
579 } else if ( audioStd == CC_ATV_AUDIO_STD_I ) {
580 cvbs_fmt = TVIN_SIG_FMT_CVBS_PAL_I;
581 } else if ( audioStd == CC_ATV_AUDIO_STD_BG ) {
582 cvbs_fmt = TVIN_SIG_FMT_CVBS_PAL_I;
583 } else if ( audioStd == CC_ATV_AUDIO_STD_M ) {
584 cvbs_fmt = TVIN_SIG_FMT_CVBS_PAL_M;
585 }
586 } else if ( videoStd == CC_ATV_VIDEO_STD_NTSC ) {
587 cvbs_fmt = TVIN_SIG_FMT_CVBS_NTSC_M;
588 if ( audioStd == CC_ATV_AUDIO_STD_DK ) {
589 cvbs_fmt = TVIN_SIG_FMT_CVBS_NTSC_M;
590 } else if ( audioStd == CC_ATV_AUDIO_STD_I ) {
591 cvbs_fmt = TVIN_SIG_FMT_CVBS_NTSC_M;
592 } else if ( audioStd == CC_ATV_AUDIO_STD_BG ) {
593 cvbs_fmt = TVIN_SIG_FMT_CVBS_NTSC_M;
594 } else if ( audioStd == CC_ATV_AUDIO_STD_M ) {
595 cvbs_fmt = TVIN_SIG_FMT_CVBS_NTSC_M;
596 }
597 } else if ( videoStd == CC_ATV_VIDEO_STD_SECAM ) {
598 if ( audioStd == CC_ATV_AUDIO_STD_DK ) {
599 cvbs_fmt = TVIN_SIG_FMT_CVBS_SECAM;
600 } else if ( audioStd == CC_ATV_AUDIO_STD_I ) {
601 cvbs_fmt = TVIN_SIG_FMT_CVBS_SECAM;
602 } else if ( audioStd == CC_ATV_AUDIO_STD_BG ) {
603 cvbs_fmt = TVIN_SIG_FMT_CVBS_SECAM;
604 } else if ( audioStd == CC_ATV_AUDIO_STD_M ) {
605 cvbs_fmt = TVIN_SIG_FMT_CVBS_SECAM;
606 } else if ( audioStd == CC_ATV_AUDIO_STD_L ) {
607 cvbs_fmt = TVIN_SIG_FMT_CVBS_SECAM;
608 }
609 }
610 return cvbs_fmt;
611}
612
613int CFrontEnd::ClearAnalogFrontEnd()
614{
615 return this->setPara ( FE_ANALOG, 44250000, V4L2_COLOR_STD_PAL | V4L2_STD_PAL_DK, 0 );
616}
617
618/*to control afc function*/
619int CFrontEnd::SetAnalogFrontEndTimerSwitch(int onOff)
620{
621 FILE *fp = NULL;
622 int ret = -1;
623
624 fp = fopen ( "/sys/module/aml_fe/parameters/aml_timer_en", "w" );
625
626 if ( fp == NULL ) {
627 LOGW ( "Open /sys/module/aml_fe/parameters/aml_timer_en error(%s)!\n", strerror ( errno ) );
628 return -1;
629 }
630 if (onOff)
631 ret = fprintf(fp, "%s", "1");
632 else
633 ret = fprintf(fp, "%s", "0");
634 if ( ret < 0 ) {
635 LOGW ( "set aml_timer_en error(%s)!\n", strerror ( errno ) );
636 }
637 LOGD("SetAnalogFrontEndTimerSwitch %d", onOff);
638 fclose ( fp );
639 fp = NULL;
640
641 return ret;
642}
643
644int CFrontEnd::SetAnalogFrontEndSearhSlowMode(int onOff)
645{
646 FILE *fp = NULL;
647 int ret = -1;
648
649 fp = fopen ( "/sys/module/aml_fe/parameters/slow_mode", "w" );
650
651 if ( fp == NULL ) {
652 LOGW ( "Open /sys/module/aml_fe/parameters/slow_mode error(%s)!\n", strerror ( errno ) );
653 return -1;
654 }
655 if (onOff)
656 ret = fprintf(fp, "%s", "1");
657 else
658 ret = fprintf(fp, "%s", "0");
659 if ( ret < 0 ) {
660 LOGW ( "set aml_timer_en error(%s)!\n", strerror ( errno ) );
661 }
662 LOGD("SetAnalogFrontEndSearhSlowMode %d", onOff);
663 fclose ( fp );
664 fp = NULL;
665
666 return ret;
667}
668
generated by cgit at 2024-05-10 21:11:30 (GMT)