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