blob: 49935b09ba1bcbcdae121ed082ce3977df1d2db2
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" |
17 | extern "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 | |
25 | CFrontEnd::CFrontEnd() |
26 | { |
27 | mFrontDevID = FE_DEV_ID; |
28 | mpObserver = NULL; |
29 | mCurFineFreq = 0; |
30 | mCurMode = FE_ANALOG; |
31 | } |
32 | |
33 | CFrontEnd::~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 | |
41 | int CFrontEnd::Open(int mode) |
42 | { |
43 | AM_FEND_OpenPara_t para; |
44 | int rc = 0; |
45 | |
46 | memset(¶, 0, sizeof(AM_FEND_OpenPara_t)); |
47 | para.mode = mode; |
48 | rc = AM_FEND_Open(mFrontDevID, ¶); |
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 | |
59 | int 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 | |
73 | int 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 | |
86 | int 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 | |
146 | int 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 | |
161 | int CFrontEnd::GetTSSource(AM_DMX_Source_t *src) |
162 | { |
163 | AM_FEND_GetTSSource(mFrontDevID, src); |
164 | return 0; |
165 | } |
166 | |
167 | void CFrontEnd::dmd_fend_callback(int 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 | |
193 | int 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 | |
214 | int 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 | |
227 | v4l2_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 | |
272 | int CFrontEnd::getPara(frontend_para_set_t *fpara) |
273 | { |
274 | int mode; |
275 | int ret1, ret2; |
276 | |
277 | struct dvb_frontend_parameters para; |
278 | memset(¶, 0, sizeof(struct dvb_frontend_parameters)); |
279 | if ((ret1 = AM_FEND_GetPara(mFrontDevID, ¶)) < 0) { |
280 | LOGD("%s,getPara faiture\n", __FUNCTION__ ); |
281 | return -1; |
282 | |
283 | //fpara->mode = fend_mode ; |
284 | |
285 | } |
286 | return 0; |
287 | } |
288 | |
289 | int CFrontEnd::getSNR() |
290 | { |
291 | int snr = 0; |
292 | AM_FEND_GetSNR(mFrontDevID, &snr); |
293 | return snr; |
294 | } |
295 | |
296 | int CFrontEnd::getBER() |
297 | { |
298 | int ber = 0; |
299 | AM_FEND_GetBER(mFrontDevID, &ber); |
300 | return ber; |
301 | } |
302 | |
303 | int CFrontEnd::getStrength() |
304 | { |
305 | int Strength = 0; |
306 | AM_FEND_GetStrength(mFrontDevID, &Strength); |
307 | return Strength; |
308 | } |
309 | |
310 | int 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 | |
321 | int 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 | |
346 | int 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 | |
377 | int 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 | |
401 | int 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 | |
415 | int 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 | |
429 | int 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 | |
488 | int 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 | |
499 | int CFrontEnd::getStatus() |
500 | { |
501 | fe_status_t status; |
502 | AM_FEND_GetStatus(mFrontDevID, &status); |
503 | |
504 | return status; |
505 | } |
506 | int 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 | |
523 | int 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 | |
565 | int CFrontEnd::ClearAnalogFrontEnd() |
566 | { |
567 | return this->setPara ( FE_ANALOG, 44250000, V4L2_COLOR_STD_PAL | V4L2_STD_PAL_DK, 0 ); |
568 | } |
569 |