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