summaryrefslogtreecommitdiff
path: root/tvapi/libtv/tv/CTvScanner.cpp (plain)
blob: e66ae0b58381eaef16783b341d2afd4eee5a3f37
1//
2//
3// amlogic 2013
4//
5// @ Project : tv
6// @ File Name :
7// @ Date : 2013-11
8// @ Author :
9//
10//
11#include "CTvScanner.h"
12#include "CTvProgram.h"
13#include "CTvRegion.h"
14#include "CFrontEnd.h"
15#ifdef LOG_TAG
16#undef LOG_TAG
17#define LOG_TAG "CTvScanner"
18#endif
19
20
21//int CTvScanner::getStartPara()
22//{
23//
24//}
25CTvScanner::CTvScanner(CTvin *pTvin)
26{
27 mbScanStart = false;
28 mpObserver = NULL;
29 mSource = 0xff;
30 mMinFreq = 1;
31 mMaxFreq = 100;
32 mCurScanStartFreq = 1;
33 mCurScanEndFreq = 100;
34 mpTvin = pTvin;
35}
36
37CTvScanner::~CTvScanner()
38{
39 AM_EVT_Unsubscribe(mScanHandle, AM_SCAN_EVT_PROGRESS, tv_scan_evt_callback, NULL);
40 AM_EVT_Unsubscribe(mScanHandle, AM_SCAN_EVT_SIGNAL, tv_scan_evt_callback, NULL);
41}
42
43
44AM_Bool_t CTvScanner::atv_cvbs_lock_check(v4l2_std_id *colorStd)
45{
46 tvafe_cvbs_video_t cvbs_lock_status;
47 int ret, i = 0;
48
49 *colorStd = 0;
50 while (i < 20) {
51 ret = mpTvin->AFE_GetCVBSLockStatus(&cvbs_lock_status);
52
53 if (cvbs_lock_status == TVAFE_CVBS_VIDEO_HV_LOCKED)
54 //||cvbs_lock_status == TVAFE_CVBS_VIDEO_V_LOCKED
55 //||cvbs_lock_status == TVAFE_CVBS_VIDEO_H_LOCKED)
56 {
57 usleep(2000 * 1000);
58 tvin_info_t info;
59 mpTvin->VDIN_GetSignalInfo(&info);
60 *colorStd = CTvin::CvbsFtmToV4l2ColorStd(info.fmt);
61 LOGD("atv_cvbs_lock_check locked and cvbs fmt = 0x%x std = 0x%x", info.fmt, *colorStd);
62 return true;
63 }
64 usleep(50 * 1000);
65 i++;
66 }
67 return false;
68}
69
70AM_Bool_t CTvScanner::s_atv_cvbs_lock_check(void *data)
71{
72 if (data == NULL) return false;
73 AM_SCAN_ATV_LOCK_PARA_t *pAtvPara = (AM_SCAN_ATV_LOCK_PARA_t *)data;
74 CTvScanner *pScan = (CTvScanner *)(pAtvPara->pData);
75 v4l2_std_id std;
76 AM_Bool_t isLock = pScan->atv_cvbs_lock_check(&std);
77 pAtvPara->pOutColorSTD = std;
78 return isLock;
79}
80
81int CTvScanner::ATVManualScan(int min_freq, int max_freq, int std, int store_Type, int channel_num)
82{
83 stopScan();
84 if (min_freq <= 0 || max_freq <= 0 || min_freq == max_freq) {
85 LOGD("atv manual scan freq error start = %d end = %d", min_freq, max_freq);
86 return -1;
87 }
88 int direction = (max_freq >= min_freq) ? 1 : 0;
89
90 if (!mbScanStart) { //not start or stop
91 //
92 mCurScanStartFreq = min_freq;
93 mCurScanEndFreq = max_freq;
94 AM_SCAN_CreatePara_t para;
95 AM_DMX_OpenPara_t dmx_para;
96 int handle = 0, i;
97 LOGD("startScanThread");
98 // Create the scan
99 memset(&para, 0, sizeof(para));
100 para.fend_dev_id = 0;//default
101 para.mode = AM_SCAN_MODE_ATV_DTV;//
102 para.atv_para.mode = AM_SCAN_ATVMODE_MANUAL;
103 para.atv_para.storeMode = store_Type;
104 para.dtv_para.mode = AM_SCAN_DTVMODE_NONE;
105
106 para.atv_para.am_scan_atv_cvbs_lock = s_atv_cvbs_lock_check;
107
108 para.atv_para.fe_cnt = 3;
109 para.atv_para.fe_paras = static_cast<AM_FENDCTRL_DVBFrontendParameters_t *>(calloc(3, sizeof(AM_FENDCTRL_DVBFrontendParameters_t)));
110 if (para.atv_para.fe_paras != NULL) {
111 memset(para.atv_para.fe_paras, 0, 3 * sizeof(AM_FENDCTRL_DVBFrontendParameters_t));
112 para.atv_para.fe_paras[0].m_type = FE_ANALOG;
113 para.atv_para.fe_paras[0].analog.para.frequency = min_freq;
114 para.atv_para.fe_paras[1].m_type = FE_ANALOG;
115 para.atv_para.fe_paras[1].analog.para.frequency = max_freq;
116 para.atv_para.fe_paras[2].m_type = FE_ANALOG;
117 para.atv_para.fe_paras[2].analog.para.frequency = min_freq;
118 }
119 para.atv_para.direction = direction;
120 para.atv_para.default_std = std;
121
122 para.atv_para.channel_id = -1;
123 para.atv_para.cvbs_unlocked_step = 1000000;
124 para.atv_para.cvbs_locked_step = 3000000;
125 para.atv_para.afc_range = 2000000;
126
127 para.dtv_para.resort_all = AM_FALSE;
128 para.dtv_para.sort_method = AM_SCAN_SORT_BY_FREQ_SRV_ID;
129 para.store_cb = NULL;
130 para.atv_para.channel_num = channel_num;
131
132 memset(&dmx_para, 0, sizeof(dmx_para));
133 AM_DMX_Open(para.dtv_para.dmx_dev_id, &dmx_para);
134
135 if ((para.dtv_para.mode & 0x07) != AM_SCAN_DTVMODE_NONE) {
136 AM_FEND_SetMode(para.fend_dev_id, para.dtv_para.source);
137 tv_scan_reconnect_dmx_to_fend(para.dtv_para.dmx_dev_id, para.fend_dev_id);
138 }
139
140 LOGD("atv manual scan mode = %d", para.dtv_para.mode);
141 // Start Scan
142 if (AM_SCAN_Create(&para, &handle) != AM_SUCCESS) {
143 LOGD("SCAN CREATE fail");
144 handle = 0;
145 } else {
146 mScanHandle = handle;
147 AM_SCAN_SetUserData(handle, (void *)this);
148 AM_EVT_Subscribe(handle, AM_SCAN_EVT_PROGRESS, tv_scan_evt_callback, NULL);
149 AM_EVT_Subscribe(handle, AM_SCAN_EVT_SIGNAL, tv_scan_evt_callback, NULL);
150 if (AM_SCAN_Start(handle) != AM_SUCCESS) {
151 AM_SCAN_Destroy(handle, AM_FALSE);
152 AM_EVT_Unsubscribe(handle, AM_SCAN_EVT_PROGRESS, tv_scan_evt_callback, NULL);
153 AM_EVT_Unsubscribe(handle, AM_SCAN_EVT_SIGNAL, tv_scan_evt_callback, NULL);
154 handle = 0;
155 }
156 }
157 if (para.atv_para.fe_paras != NULL)
158 free(para.atv_para.fe_paras);
159 if (para.dtv_para.fe_paras != NULL)
160 free(para.dtv_para.fe_paras);
161
162 if (handle == 0) {
163 return -1;
164 }
165 mbScanStart = true;//start call ok
166 } else {
167 LOGD("scanning and not stop");
168 }
169
170 return 0;
171
172}
173int CTvScanner::autoAtvScan(int min_freq, int max_freq, int std, int search_type)
174{
175 stopScan();
176 if (min_freq <= 0 || max_freq <= 0 || min_freq > max_freq)
177 return -1;
178 if (!mbScanStart) { //not start or stop
179 mCurScanStartFreq = min_freq;
180 mCurScanEndFreq = max_freq;
181
182 AM_SCAN_CreatePara_t para;
183 AM_DMX_OpenPara_t dmx_para;
184 int handle = 0, i;
185 // Create the scan
186 memset(&para, 0, sizeof(para));
187
188 para.fend_dev_id = 0;//default
189 para.mode = AM_SCAN_MODE_ATV_DTV;//
190 if (search_type == 1)
191 para.atv_para.storeMode = 1;
192 else
193 para.atv_para.storeMode = 0;
194 para.dtv_para.mode = AM_SCAN_DTVMODE_NONE;
195
196 para.atv_para.am_scan_atv_cvbs_lock = s_atv_cvbs_lock_check;
197
198 para.atv_para.fe_cnt = 3;
199 para.atv_para.fe_paras = static_cast<AM_FENDCTRL_DVBFrontendParameters_t *>(calloc(3, sizeof(AM_FENDCTRL_DVBFrontendParameters_t)));
200 if (para.atv_para.fe_paras != NULL) {
201 memset(para.atv_para.fe_paras, 0, 3 * sizeof(AM_FENDCTRL_DVBFrontendParameters_t));
202 para.atv_para.fe_paras[0].m_type = FE_ANALOG;
203 para.atv_para.fe_paras[0].analog.para.frequency = min_freq;
204 para.atv_para.fe_paras[1].m_type = FE_ANALOG;
205 para.atv_para.fe_paras[1].analog.para.frequency = max_freq;
206 para.atv_para.fe_paras[2].m_type = FE_ANALOG;
207 para.atv_para.fe_paras[2].analog.para.frequency = 0;
208 }
209
210 para.atv_para.direction = 0;
211 para.atv_para.default_std = std;
212
213 para.atv_para.channel_id = -1;
214 para.atv_para.afc_unlocked_step = 3000000;
215 para.atv_para.cvbs_unlocked_step = 1500000;
216 para.atv_para.cvbs_locked_step = 6000000;
217 para.atv_para.afc_range = 2000000;
218
219 para.dtv_para.resort_all = AM_FALSE;
220 para.dtv_para.sort_method = AM_SCAN_SORT_BY_FREQ_SRV_ID;
221 para.store_cb = NULL;
222
223 memset(&dmx_para, 0, sizeof(dmx_para));
224 AM_DMX_Open(para.dtv_para.dmx_dev_id, &dmx_para);
225
226 if ((para.dtv_para.mode & 0x07) != AM_SCAN_DTVMODE_NONE) {
227 AM_FEND_SetMode(para.fend_dev_id, para.dtv_para.source);
228 tv_scan_reconnect_dmx_to_fend(para.dtv_para.dmx_dev_id, para.fend_dev_id);
229 }
230
231 // prog->dmx_id = para.dtv_para.dmx_dev_id;
232 // prog->fend_id = para.fend_dev_id;
233 // prog->mode = para.dtv_para.mode;
234 LOGD(" mode = %d", para.dtv_para.mode);
235 // Start Scan
236 if (AM_SCAN_Create(&para, &handle) != AM_SUCCESS) {
237 LOGD("SCAN CREATE fail");
238 handle = 0;
239 } else {
240 mScanHandle = handle;
241 AM_SCAN_SetUserData(handle, (void *)this);
242 //注册搜索事件
243 AM_EVT_Subscribe(handle, AM_SCAN_EVT_PROGRESS, tv_scan_evt_callback, NULL);
244 //注册信号质量通知事件
245 AM_EVT_Subscribe(handle, AM_SCAN_EVT_SIGNAL, tv_scan_evt_callback, NULL);
246 if (AM_SCAN_Start(handle) != AM_SUCCESS) {
247 AM_SCAN_Destroy(handle, AM_FALSE);
248 AM_EVT_Unsubscribe(handle, AM_SCAN_EVT_PROGRESS, tv_scan_evt_callback, NULL);
249 AM_EVT_Unsubscribe(handle, AM_SCAN_EVT_SIGNAL, tv_scan_evt_callback, NULL);
250 handle = 0;
251 }
252 }
253 if (para.atv_para.fe_paras != NULL)
254 free(para.atv_para.fe_paras);
255 if (para.dtv_para.fe_paras != NULL)
256 free(para.dtv_para.fe_paras);
257
258 if (handle == 0) {
259 return -1;
260 }
261 mbScanStart = true;//start call ok
262 } else {
263 LOGD("scanning and not stop");
264 }
265
266 return 0;
267}
268
269int CTvScanner::manualAtscScan(int channelID, int attennaType, int std)
270{
271 stopScan();
272 if (!mbScanStart) { //not start or stop
273 AM_SCAN_CreatePara_t para;
274 AM_DMX_OpenPara_t dmx_para;
275 int handle = 0, i;
276 // Create the scan
277 memset(&para, 0, sizeof(para));
278
279 //strcpy(para.default_text_lang,"eng");//config
280 //strcpy(para.text_langs, "local eng zho chi chs first");//config
281 para.fend_dev_id = 0;//default
282 para.mode = AM_SCAN_MODE_ADTV;//DTV
283 para.atv_para.mode = AM_SCAN_ATVMODE_NONE;
284
285
286 para.atv_para.default_std = std;
287
288
289 para.dtv_para.mode = AM_SCAN_DTVMODE_MANUAL;//DTV_MODE_ALLBAND
290 //para.dtv_para.mode |= (*env)->GetIntField(env, para, doptions);//忽略
291 para.dtv_para.source = FE_ATSC;//fe_type
292 para.dtv_para.dmx_dev_id = 0;//default 0
293 para.dtv_para.resort_all = AM_TRUE;
294 para.dtv_para.clear_source = AM_FALSE;
295 para.dtv_para.mix_tv_radio = AM_FALSE;
296 para.dtv_para.sort_method = AM_SCAN_SORT_BY_FREQ_SRV_ID;
297 para.store_cb = NULL;
298 //para.dtv_para.attenna = attennaType;
299
300 para.dtv_para.standard = AM_SCAN_DTV_STD_ATSC;
301
302 mSource = para.dtv_para.source;
303
304 Vector<sp<CTvChannel> > vcp;
305 //CTvDatabase::getChannelParaList("/data/tv_default.xml", vcp);//channel list from xml or db
306 getAtscChannelPara(attennaType, vcp);
307 LOGD("ANDESEN test attenna type is %d", attennaType);
308
309 int size = vcp.size();
310 LOGD("channel list size = %d", size);
311 //showboz
312 if (size == 0) {
313 CTvDatabase::GetTvDb()->importXmlToDB("/etc/tv_default.xml");
314 getAtscChannelPara(attennaType, vcp);
315 size = vcp.size();
316 }
317
318 if (!(para.dtv_para.fe_paras = static_cast<AM_FENDCTRL_DVBFrontendParameters_t *>(calloc(1, sizeof(AM_FENDCTRL_DVBFrontendParameters_t)))))
319 return -1;
320
321 //memset(pfp, 0, size * sizeof(AM_FENDCTRL_DVBFrontendParameters_t));
322
323 for (i = 0; i < size; i++) {
324 if (channelID == vcp[i]->getLogicalChannelNum()) {
325 para.dtv_para.fe_paras[0].m_type = 3;//MODE_ATSC
326 para.dtv_para.fe_paras[0].m_logicalChannelNum = vcp[i]->getLogicalChannelNum();
327 para.dtv_para.fe_paras[0].atsc.para.frequency = vcp[i]->getFrequency();
328 para.dtv_para.fe_paras[0].atsc.para.u.vsb.modulation = (fe_modulation_t)(vcp[i]->getModulation());
329 LOGD("andesen test atsc manual type=%d,num=%d,freq=%d,modu=%d",
330 para.dtv_para.fe_paras[0].m_type, para.dtv_para.fe_paras[0].m_logicalChannelNum,
331 para.dtv_para.fe_paras[0].atsc.para.frequency, para.dtv_para.fe_paras[0].atsc.para.u.vsb.modulation);
332 }
333 }
334 //allband
335 para.dtv_para.fe_cnt = 1;
336 memset(&dmx_para, 0, sizeof(dmx_para));
337 AM_DMX_Open(para.dtv_para.dmx_dev_id, &dmx_para);
338
339 if ((para.dtv_para.mode & 0x07) != AM_SCAN_DTVMODE_NONE) {
340 AM_FEND_SetMode(para.fend_dev_id, para.dtv_para.source);
341 tv_scan_reconnect_dmx_to_fend(para.dtv_para.dmx_dev_id, para.fend_dev_id);
342 }
343
344 // prog->dmx_id = para.dtv_para.dmx_dev_id;
345 // prog->fend_id = para.fend_dev_id;
346 // prog->mode = para.dtv_para.mode;
347 // Start Scan
348 if (AM_SCAN_Create(&para, &handle) != AM_SUCCESS) {
349 LOGD("SCAN CREATE fail");
350 handle = 0;
351 } else {
352 mScanHandle = handle;
353 AM_SCAN_SetUserData(handle, (void *)this);
354 //注册搜索事件
355 AM_EVT_Subscribe(handle, AM_SCAN_EVT_PROGRESS, tv_scan_evt_callback, NULL);
356 //注册信号质量通知事件
357 AM_EVT_Subscribe(handle, AM_SCAN_EVT_SIGNAL, tv_scan_evt_callback, NULL);
358 if (AM_SCAN_Start(handle) != AM_SUCCESS) {
359 AM_SCAN_Destroy(handle, AM_FALSE);
360 AM_EVT_Unsubscribe(handle, AM_SCAN_EVT_PROGRESS, tv_scan_evt_callback, NULL);
361 AM_EVT_Unsubscribe(handle, AM_SCAN_EVT_SIGNAL, tv_scan_evt_callback, NULL);
362 handle = 0;
363 }
364 }
365 if (para.atv_para.fe_paras != NULL)
366 free(para.atv_para.fe_paras);
367 if (para.dtv_para.fe_paras != NULL)
368 free(para.dtv_para.fe_paras);
369
370 if (handle == 0) {
371 return -1;
372 }
373 mbScanStart = true;//start call ok
374 } else {
375 LOGD("scanning and not stop");
376 }
377 return 0;
378}
379
380int CTvScanner::manualDtmbScan(int beginFreq, int endFreq, int modulation)
381{
382 stopScan();
383
384 if (!mbScanStart) { //not start or stop
385 AM_SCAN_CreatePara_t para;
386 AM_DMX_OpenPara_t dmx_para;
387 int handle = 0, i;
388 // Create the scan
389 memset(&para, 0, sizeof(para));
390
391 para.fend_dev_id = 0;//default
392 para.mode = AM_SCAN_MODE_DTV_ATV;//DTV
393 para.atv_para.mode = AM_SCAN_ATVMODE_NONE;
394 para.dtv_para.mode = AM_SCAN_DTVMODE_MANUAL;
395 para.dtv_para.source = FE_DTMB;//fe_type
396 para.dtv_para.dmx_dev_id = 0;//default 0
397
398 Vector<sp<CTvChannel> > vcp;
399 CTvRegion::getChannelListByNameAndFreqRange("CHINA,Default DTMB ALL", beginFreq, endFreq, vcp);
400 int size = vcp.size();
401
402 //@author:hao.fu
403 if (size == 0) {
404 return -1;
405 }
406
407 if (!(para.dtv_para.fe_paras = static_cast<AM_FENDCTRL_DVBFrontendParameters_t *>(calloc(size, sizeof(AM_FENDCTRL_DVBFrontendParameters_t)))))
408 return -1;
409
410 for (i = 0; i < size; i++) {
411 para.dtv_para.fe_paras[i].m_type = 5;//MODE_DTMB
412 para.dtv_para.fe_paras[i].dtmb.para.frequency = vcp[i]->getFrequency();
413 para.dtv_para.fe_paras[i].dtmb.para.inversion = INVERSION_OFF;
414 para.dtv_para.fe_paras[i].dtmb.para.u.ofdm.bandwidth = (fe_bandwidth_t)(vcp[i]->getBandwidth());
415 if (modulation == -1)
416 para.dtv_para.fe_paras[i].cable.para.u.qam.modulation = (fe_modulation_t)(vcp[i]->getModulation());
417 else
418 para.dtv_para.fe_paras[i].cable.para.u.qam.modulation = (fe_modulation_t)modulation;
419 }
420
421 para.dtv_para.fe_cnt = size;
422 para.dtv_para.resort_all = AM_FALSE;
423 para.dtv_para.sort_method = AM_SCAN_SORT_BY_FREQ_SRV_ID;
424 para.store_cb = NULL;
425
426
427 memset(&dmx_para, 0, sizeof(dmx_para));
428 AM_DMX_Open(para.dtv_para.dmx_dev_id, &dmx_para);
429
430 if ((para.dtv_para.mode & 0x07) != AM_SCAN_DTVMODE_NONE) {
431 AM_FEND_SetMode(para.fend_dev_id, para.dtv_para.source);
432 tv_scan_reconnect_dmx_to_fend(para.dtv_para.dmx_dev_id, para.fend_dev_id);
433 }
434
435 // Start Scan
436 if (AM_SCAN_Create(&para, &handle) != AM_SUCCESS) {
437 LOGD("SCAN CREATE fail");
438 handle = 0;
439 } else {
440 mScanHandle = handle;
441 AM_SCAN_SetUserData(handle, (void *)this);
442 AM_EVT_Subscribe(handle, AM_SCAN_EVT_PROGRESS, tv_scan_evt_callback, NULL);
443 AM_EVT_Subscribe(handle, AM_SCAN_EVT_SIGNAL, tv_scan_evt_callback, NULL);
444 if (AM_SCAN_Start(handle) != AM_SUCCESS) {
445 AM_SCAN_Destroy(handle, AM_FALSE);
446 AM_EVT_Unsubscribe(handle, AM_SCAN_EVT_PROGRESS, tv_scan_evt_callback, NULL);
447 AM_EVT_Unsubscribe(handle, AM_SCAN_EVT_SIGNAL, tv_scan_evt_callback, NULL);
448 handle = 0;
449 }
450 }
451 if (para.atv_para.fe_paras != NULL)
452 free(para.atv_para.fe_paras);
453 if (para.dtv_para.fe_paras != NULL)
454 free(para.dtv_para.fe_paras);
455
456 if (handle == 0) {
457 return -1;
458 }
459 mbScanStart = true;//start call ok
460 } else {
461 LOGD("scanning and not stop");
462 }
463 return 0;
464}
465
466
467int CTvScanner::autoTvScan()
468{
469 stopScan();
470
471 if (!mbScanStart) { //not start or stop
472 AM_SCAN_CreatePara_t para;
473 AM_DMX_OpenPara_t dmx_para;
474 int handle = 0, i;
475 // Create the scan
476 memset(&para, 0, sizeof(para));
477
478 //strcpy(para.default_text_lang,"eng");//config
479 //strcpy(para.text_langs, "eng zho chi");//config
480 para.fend_dev_id = 0;//default
481 para.mode = AM_SCAN_MODE_DTV_ATV;//DTV
482 para.atv_para.mode = AM_SCAN_ATVMODE_NONE;
483 para.dtv_para.mode = AM_SCAN_DTVMODE_ALLBAND;//DTV_MODE_ALLBAND
484 //para.dtv_para.mode |= (*env)->GetIntField(env, para, doptions);//忽略
485 para.dtv_para.source = 1;//QAM
486 para.dtv_para.dmx_dev_id = 0;//default 0
487 Vector<sp<CTvChannel> > vcp;
488 //CTvDatabase::getChannelParaList("/data/tv_default.xml", vcp);//channel list from xml or db
489 CTvRegion::getChannelListByName("China,DVB-C allband", vcp);
490
491 int size = vcp.size();
492 LOGD("channel list size = %d", size);
493 if (!(para.dtv_para.fe_paras = static_cast<AM_FENDCTRL_DVBFrontendParameters_t *>(calloc(size, sizeof(AM_FENDCTRL_DVBFrontendParameters_t)))))
494 return -1;
495
496 //memset(pfp, 0, size * sizeof(AM_FENDCTRL_DVBFrontendParameters_t));
497
498 for (i = 0; i < size; i++) {
499 para.dtv_para.fe_paras[i].m_type = FE_QAM;
500 para.dtv_para.fe_paras[i].cable.para.frequency = vcp[i]->getFrequency();
501 para.dtv_para.fe_paras[i].cable.para.inversion = INVERSION_OFF;
502 para.dtv_para.fe_paras[i].cable.para.u.qam.symbol_rate = vcp[i]->getSymbolRate();
503 para.dtv_para.fe_paras[i].cable.para.u.qam.modulation = (fe_modulation_t)(vcp[i]->getModulation());
504 }
505 //allband
506 para.dtv_para.fe_cnt = size;
507
508 para.dtv_para.resort_all = AM_FALSE;
509 para.dtv_para.sort_method = AM_SCAN_SORT_BY_FREQ_SRV_ID;
510 para.store_cb = NULL;
511 memset(&dmx_para, 0, sizeof(dmx_para));
512 AM_DMX_Open(para.dtv_para.dmx_dev_id, &dmx_para);
513
514 if ((para.dtv_para.mode & 0x07) != AM_SCAN_DTVMODE_NONE) {
515 AM_FEND_SetMode(para.fend_dev_id, para.dtv_para.source);
516 tv_scan_reconnect_dmx_to_fend(para.dtv_para.dmx_dev_id, para.fend_dev_id);
517 }
518
519 // prog->dmx_id = para.dtv_para.dmx_dev_id;
520 // prog->fend_id = para.fend_dev_id;
521 // prog->mode = para.dtv_para.mode;
522 // Start Scan
523 if (AM_SCAN_Create(&para, &handle) != AM_SUCCESS) {
524 LOGD("SCAN CREATE fail");
525 handle = 0;
526 } else {
527 LOGD("SCAN CREATE handle = %d", handle);
528 mScanHandle = handle;
529 AM_SCAN_SetUserData(handle, (void *)this);
530 //注册搜索事件
531 AM_EVT_Subscribe(handle, AM_SCAN_EVT_PROGRESS, tv_scan_evt_callback, NULL);
532 //注册信号质量通知事件
533 //AM_EVT_Subscribe(handle, AM_SCAN_EVT_SIGNAL, tv_scan_evt_callback, NULL);
534 if (AM_SCAN_Start(handle) != AM_SUCCESS) {
535 AM_SCAN_Destroy(handle, AM_FALSE);
536 AM_EVT_Unsubscribe(handle, AM_SCAN_EVT_PROGRESS, tv_scan_evt_callback, NULL);
537 // AM_EVT_Unsubscribe(handle, AM_SCAN_EVT_SIGNAL, tv_scan_evt_callback, NULL);
538 handle = 0;
539 }
540 }
541 if (para.atv_para.fe_paras != NULL)
542 free(para.atv_para.fe_paras);
543 if (para.dtv_para.fe_paras != NULL)
544 free(para.dtv_para.fe_paras);
545
546 if (handle == 0) {
547 return -1;
548 }
549 mbScanStart = true;//start call ok
550 } else {
551 LOGD("scanning and not stop");
552 }
553 return 0;
554}
555//only test for dtv allbland auto
556int CTvScanner::startScan()
557{
558 stopScan();
559
560 if (!mbScanStart) { //not start or stop
561 AM_SCAN_CreatePara_t para;
562 AM_DMX_OpenPara_t dmx_para;
563 int handle = 0, i;
564 // Create the scan
565 memset(&para, 0, sizeof(para));
566
567 //strcpy(para.default_text_lang,"eng");//config
568 //strcpy(para.text_langs, "eng zho chi");//config
569 para.fend_dev_id = 0;//default
570 para.mode = AM_SCAN_MODE_DTV_ATV;//DTV
571 para.atv_para.mode = AM_SCAN_ATVMODE_NONE;
572 para.dtv_para.mode = 3;//DTV_MODE_ALLBAND
573 //para.dtv_para.mode |= (*env)->GetIntField(env, para, doptions);//忽略
574 para.dtv_para.source = 1;//QAM
575 para.dtv_para.dmx_dev_id = 0;//default 0
576 Vector<sp<CTvChannel> > vcp;
577 //CTvDatabase::getChannelParaList("/data/tv_default.xml", vcp);//channel list from xml or db
578 CTvRegion::getChannelListByName("China,DVB-C allband", vcp);
579
580 int size = vcp.size();
581 LOGD("channel list size = %d", size);
582 if (!(para.dtv_para.fe_paras = static_cast<AM_FENDCTRL_DVBFrontendParameters_t *>(calloc(size, sizeof(AM_FENDCTRL_DVBFrontendParameters_t)))))
583 return -1;
584
585 //memset(pfp, 0, size * sizeof(AM_FENDCTRL_DVBFrontendParameters_t));
586
587 for (i = 0; i < size; i++) {
588 para.dtv_para.fe_paras[i].m_type = FE_QAM;
589 para.dtv_para.fe_paras[i].cable.para.frequency = vcp[i]->getFrequency();
590 para.dtv_para.fe_paras[i].cable.para.inversion = INVERSION_OFF;
591 para.dtv_para.fe_paras[i].cable.para.u.qam.symbol_rate = vcp[i]->getSymbolRate();
592 para.dtv_para.fe_paras[i].cable.para.u.qam.modulation = (fe_modulation_t)(vcp[i]->getModulation());
593 }
594 //allband
595 para.dtv_para.fe_cnt = size;
596
597 para.dtv_para.resort_all = AM_FALSE;
598 para.dtv_para.sort_method = AM_SCAN_SORT_BY_FREQ_SRV_ID;
599 para.store_cb = NULL;
600
601 memset(&dmx_para, 0, sizeof(dmx_para));
602 AM_DMX_Open(para.dtv_para.dmx_dev_id, &dmx_para);
603
604 if ((para.dtv_para.mode & 0x07) != AM_SCAN_DTVMODE_NONE) {
605 AM_FEND_SetMode(para.fend_dev_id, para.dtv_para.source);
606 tv_scan_reconnect_dmx_to_fend(para.dtv_para.dmx_dev_id, para.fend_dev_id);
607 }
608
609 // prog->dmx_id = para.dtv_para.dmx_dev_id;
610 // prog->fend_id = para.fend_dev_id;
611 // prog->mode = para.dtv_para.mode;
612 // Start Scan
613 if (AM_SCAN_Create(&para, &handle) != AM_SUCCESS) {
614 LOGD("SCAN CREATE fail");
615 handle = 0;
616 } else {
617 mScanHandle = handle;
618 AM_SCAN_SetUserData(handle, (void *)this);
619 //注册搜索事件
620 AM_EVT_Subscribe(handle, AM_SCAN_EVT_PROGRESS, tv_scan_evt_callback, NULL);
621 //注册信号质量通知事件
622 //AM_EVT_Subscribe(handle, AM_SCAN_EVT_SIGNAL, tv_scan_evt_callback, NULL);
623 if (AM_SCAN_Start(handle) != AM_SUCCESS) {
624 AM_SCAN_Destroy(handle, AM_FALSE);
625 AM_EVT_Unsubscribe(handle, AM_SCAN_EVT_PROGRESS, tv_scan_evt_callback, NULL);
626 // AM_EVT_Unsubscribe(handle, AM_SCAN_EVT_SIGNAL, tv_scan_evt_callback, NULL);
627 handle = 0;
628 }
629 }
630 if (para.atv_para.fe_paras != NULL)
631 free(para.atv_para.fe_paras);
632 if (para.dtv_para.fe_paras != NULL)
633 free(para.dtv_para.fe_paras);
634
635 if (handle == 0) {
636 return -1;
637 }
638 mbScanStart = true;//start call ok
639 } else {
640 LOGD("scanning and not stop");
641 }
642 return 0;
643}
644
645
646//only test for dtv allbland auto
647int CTvScanner::autoDtmbScan()
648{
649 stopScan();
650
651 if (!mbScanStart) { //not start or stop
652 AM_SCAN_CreatePara_t para;
653 AM_DMX_OpenPara_t dmx_para;
654 int handle = 0, i;
655 // Create the scan
656 memset(&para, 0, sizeof(para));
657
658 //strcpy(para.default_text_lang,"eng");//config
659 //strcpy(para.text_langs, "local eng zho chi chs first");//config
660 para.fend_dev_id = 0;//default
661 para.mode = AM_SCAN_MODE_DTV_ATV;//DTV
662 para.atv_para.mode = AM_SCAN_ATVMODE_NONE;
663 para.dtv_para.mode = AM_SCAN_DTVMODE_ALLBAND;//DTV_MODE_ALLBAND
664 //para.dtv_para.mode |= (*env)->GetIntField(env, para, doptions);//忽略
665 para.dtv_para.source = FE_DTMB;//fe_type
666 para.dtv_para.dmx_dev_id = 0;//default 0
667 Vector<sp<CTvChannel> > vcp;
668 //CTvDatabase::getChannelParaList("/data/tv_default.xml", vcp);//channel list from xml or db
669 CTvRegion::getChannelListByName("CHINA,Default DTMB ALL", vcp);
670
671 int size = vcp.size();
672 LOGD("channel list size = %d", size);
673 //showboz
674 if (size == 0) {
675 CTvDatabase::GetTvDb()->importXmlToDB("/etc/tv_default.xml");
676 CTvRegion::getChannelListByName("CHINA,Default DTMB ALL", vcp);
677 size = vcp.size();
678 }
679
680 if (!(para.dtv_para.fe_paras = static_cast<AM_FENDCTRL_DVBFrontendParameters_t *>(calloc(size, sizeof(AM_FENDCTRL_DVBFrontendParameters_t)))))
681 return -1;
682
683 //memset(pfp, 0, size * sizeof(AM_FENDCTRL_DVBFrontendParameters_t));
684
685 for (i = 0; i < size; i++) {
686 para.dtv_para.fe_paras[i].m_type = 5;//MODE_DTMB
687 para.dtv_para.fe_paras[i].dtmb.para.frequency = vcp[i]->getFrequency();
688 para.dtv_para.fe_paras[i].dtmb.para.inversion = INVERSION_OFF;
689 para.dtv_para.fe_paras[i].dtmb.para.u.ofdm.bandwidth = (fe_bandwidth_t)(vcp[i]->getBandwidth());
690 }
691 //allband
692 para.dtv_para.fe_cnt = size;
693
694 para.dtv_para.resort_all = AM_FALSE;
695 para.dtv_para.sort_method = AM_SCAN_SORT_BY_FREQ_SRV_ID;
696 para.store_cb = NULL;
697
698 memset(&dmx_para, 0, sizeof(dmx_para));
699 AM_DMX_Open(para.dtv_para.dmx_dev_id, &dmx_para);
700
701 if ((para.dtv_para.mode & 0x07) != AM_SCAN_DTVMODE_NONE) {
702 AM_FEND_SetMode(para.fend_dev_id, para.dtv_para.source);
703 tv_scan_reconnect_dmx_to_fend(para.dtv_para.dmx_dev_id, para.fend_dev_id);
704 }
705
706 // prog->dmx_id = para.dtv_para.dmx_dev_id;
707 // prog->fend_id = para.fend_dev_id;
708 // prog->mode = para.dtv_para.mode;
709 // Start Scan
710 if (AM_SCAN_Create(&para, &handle) != AM_SUCCESS) {
711 LOGD("SCAN CREATE fail");
712 handle = 0;
713 } else {
714 mScanHandle = handle;
715 AM_SCAN_SetUserData(handle, (void *)this);
716 //注册搜索事件
717 AM_EVT_Subscribe(handle, AM_SCAN_EVT_PROGRESS, tv_scan_evt_callback, NULL);
718 //注册信号质量通知事件
719 AM_EVT_Subscribe(handle, AM_SCAN_EVT_SIGNAL, tv_scan_evt_callback, NULL);
720 if (AM_SCAN_Start(handle) != AM_SUCCESS) {
721 AM_SCAN_Destroy(handle, AM_FALSE);
722 AM_EVT_Unsubscribe(handle, AM_SCAN_EVT_PROGRESS, tv_scan_evt_callback, NULL);
723 AM_EVT_Unsubscribe(handle, AM_SCAN_EVT_SIGNAL, tv_scan_evt_callback, NULL);
724 handle = 0;
725 }
726 }
727 if (para.atv_para.fe_paras != NULL)
728 free(para.atv_para.fe_paras);
729 if (para.dtv_para.fe_paras != NULL)
730 free(para.dtv_para.fe_paras);
731
732 if (handle == 0) {
733 return -1;
734 }
735 mbScanStart = true;//start call ok
736 } else {
737 LOGD("scanning and not stop");
738 }
739 return 0;
740}
741
742int CTvScanner::autoAtscScan(int attennaType, int std)
743{
744 stopScan();
745
746 if (!mbScanStart) { //not start or stop
747 AM_SCAN_CreatePara_t para;
748 AM_DMX_OpenPara_t dmx_para;
749 int handle = 0, i;
750 // Create the scan
751 memset(&para, 0, sizeof(para));
752
753 //strcpy(para.default_text_lang,"eng");//config
754 //strcpy(para.text_langs, "local eng zho chi chs first");//config
755 para.fend_dev_id = 0;//default
756 para.mode = AM_SCAN_MODE_ADTV;//DTV
757 para.atv_para.mode = AM_SCAN_ATVMODE_NONE;
758
759
760 para.atv_para.default_std = std;
761
762
763 para.dtv_para.mode = AM_SCAN_DTVMODE_ALLBAND;//DTV_MODE_ALLBAND
764 //para.dtv_para.mode |= (*env)->GetIntField(env, para, doptions);//忽略
765 para.dtv_para.source = FE_ATSC;//fe_type
766 para.dtv_para.dmx_dev_id = 0;//default 0
767 para.dtv_para.resort_all = AM_TRUE;
768 para.dtv_para.clear_source = AM_TRUE;
769 para.dtv_para.mix_tv_radio = AM_FALSE;
770 para.dtv_para.sort_method = AM_SCAN_SORT_BY_FREQ_SRV_ID;
771 para.store_cb = NULL;
772 //para.dtv_para.attenna = attennaType;//see dvb atsc-cnc
773
774 para.dtv_para.standard = AM_SCAN_DTV_STD_ATSC;
775
776 mSource = para.dtv_para.source;
777
778 Vector<sp<CTvChannel> > vcp;
779 //CTvDatabase::getChannelParaList("/data/tv_default.xml", vcp);//channel list from xml or db
780 getAtscChannelPara(attennaType, vcp);
781 LOGD("ANDESEN test attenna type is %d", attennaType);
782
783 int size = vcp.size();
784 LOGD("channel list size = %d", size);
785 //showboz
786 if (size == 0) {
787 CTvDatabase::GetTvDb()->importXmlToDB("/etc/tv_default.xml");
788 getAtscChannelPara(attennaType, vcp);
789 size = vcp.size();
790 }
791
792 if (!(para.dtv_para.fe_paras = static_cast<AM_FENDCTRL_DVBFrontendParameters_t *>(calloc(size, sizeof(AM_FENDCTRL_DVBFrontendParameters_t)))))
793 return -1;
794
795 //memset(pfp, 0, size * sizeof(AM_FENDCTRL_DVBFrontendParameters_t));
796
797 for (i = 0; i < size; i++) {
798 para.dtv_para.fe_paras[i].m_type = 3;//MODE_ATSC
799 para.dtv_para.fe_paras[i].m_logicalChannelNum = vcp[i]->getLogicalChannelNum();
800 para.dtv_para.fe_paras[i].atsc.para.frequency = vcp[i]->getFrequency();
801 para.dtv_para.fe_paras[i].atsc.para.u.vsb.modulation = (fe_modulation_t)(vcp[i]->getModulation());
802 }
803 //allband
804 para.dtv_para.fe_cnt = size;
805
806 memset(&dmx_para, 0, sizeof(dmx_para));
807 AM_DMX_Open(para.dtv_para.dmx_dev_id, &dmx_para);
808
809 if ((para.dtv_para.mode & 0x07) != AM_SCAN_DTVMODE_NONE) {
810 AM_FEND_SetMode(para.fend_dev_id, para.dtv_para.source);
811 tv_scan_reconnect_dmx_to_fend(para.dtv_para.dmx_dev_id, para.fend_dev_id);
812 }
813
814 // prog->dmx_id = para.dtv_para.dmx_dev_id;
815 // prog->fend_id = para.fend_dev_id;
816 // prog->mode = para.dtv_para.mode;
817 // Start Scan
818 if (AM_SCAN_Create(&para, &handle) != AM_SUCCESS) {
819 LOGD("SCAN CREATE fail");
820 handle = 0;
821 } else {
822 mScanHandle = handle;
823 AM_SCAN_SetUserData(handle, (void *)this);
824 //注册搜索事件
825 AM_EVT_Unsubscribe(handle, AM_SCAN_EVT_PROGRESS, tv_scan_evt_callback, NULL);
826 AM_EVT_Subscribe(handle, AM_SCAN_EVT_PROGRESS, tv_scan_evt_callback, NULL);
827 //注册信号质量通知事件
828 AM_EVT_Subscribe(handle, AM_SCAN_EVT_SIGNAL, tv_scan_evt_callback, NULL);
829 if (AM_SCAN_Start(handle) != AM_SUCCESS) {
830 AM_SCAN_Destroy(handle, AM_FALSE);
831 AM_EVT_Unsubscribe(handle, AM_SCAN_EVT_PROGRESS, tv_scan_evt_callback, NULL);
832 AM_EVT_Unsubscribe(handle, AM_SCAN_EVT_SIGNAL, tv_scan_evt_callback, NULL);
833 handle = 0;
834 }
835 }
836 if (para.atv_para.fe_paras != NULL)
837 free(para.atv_para.fe_paras);
838 if (para.dtv_para.fe_paras != NULL)
839 free(para.dtv_para.fe_paras);
840
841 if (handle == 0) {
842 return -1;
843 }
844 mbScanStart = true;//start call ok
845 } else {
846 LOGD("scanning and not stop");
847 }
848 return 0;
849}
850
851
852int CTvScanner::stopScan()
853{
854 LOGD("StopScan mScanHandle=%d", mScanHandle);
855 //requestExit();
856 if (mbScanStart) { //if start ok and not stop
857 int ret = AM_SCAN_Destroy(mScanHandle, AM_TRUE);
858 AM_EVT_Unsubscribe(mScanHandle, AM_SCAN_EVT_PROGRESS, tv_scan_evt_callback, NULL);
859 AM_EVT_Unsubscribe(mScanHandle, AM_SCAN_EVT_SIGNAL, tv_scan_evt_callback, NULL);
860 AM_SEC_Cache_Reset(0);
861 //stop loop
862 LOGD("StopScan , ret=%d", ret);
863 mbScanStart = false;//stop ok
864 } else {
865 LOGD("not start scan or scan stoped");
866 }
867 return 0;
868}
869
870void CTvScanner::tv_scan_evt_callback(int dev_no, int event_type, void *param, void *data)
871{
872 CTvScanner *pT = NULL;
873 long long tmpFreq = 0;
874 AM_SCAN_GetUserData(dev_no, (void **)&pT);
875 if (pT == NULL) {
876 return;
877 }
878 memset(pT->mCurEv.mProgramName, '\0', sizeof(pT->mCurEv.mProgramName));
879 memset(pT->mCurEv.mMSG, '\0', sizeof(pT->mCurEv.mMSG));
880 if (event_type == AM_SCAN_EVT_PROGRESS) {
881 AM_SCAN_Progress_t *evt = (AM_SCAN_Progress_t *)param;
882 switch (evt->evt) {
883 case AM_SCAN_PROGRESS_SCAN_BEGIN:
884 pT->mCurEv.mPercent = 0;
885 break;
886 case AM_SCAN_PROGRESS_NIT_BEGIN:
887
888 break;
889 case AM_SCAN_PROGRESS_NIT_END:
890
891 break;
892 case AM_SCAN_PROGRESS_TS_BEGIN: {
893 AM_SCAN_TSProgress_t *tp = (AM_SCAN_TSProgress_t *)evt->data;
894 if (tp == NULL)
895 break;
896 pT->mCurEv.mChannelNumber = tp->index;
897 pT->mCurEv.mMode = tp->fend_para.m_type;
898 pT->mCurEv.mFrequency = ((struct dvb_frontend_parameters *)(&tp->fend_para))->frequency;
899 pT->mCurEv.mSymbolRate = tp->fend_para.cable.para.u.qam.symbol_rate;
900 pT->mCurEv.mModulation = tp->fend_para.cable.para.u.qam.modulation;
901 pT->mCurEv.mBandwidth = tp->fend_para.terrestrial.para.u.ofdm.bandwidth;
902 pT->mCurEv.mOfdm_mode = tp->fend_para.terrestrial.para.u.ofdm.ofdm_mode;
903 pT->mCurEv.mAudio = tp->fend_para.analog.para.u.analog.audmode;
904 pT->mCurEv.mStandard = tp->fend_para.analog.para.u.analog.std;
905 pT->mCurEv.mSat_polarisation = tp->fend_para.sat.polarisation;
906 if (pT->mCurEv.mMode == FE_ANALOG) {
907 if (pT->mSource == FE_ATSC) {
908 pT->mCurEv.mPercent = (tp->index * 100) / tp->total;
909 } else {
910 pT->mCurEv.mPercent = 0;
911 }
912 } else {
913 pT->mCurEv.mPercent = (tp->index * 100) / tp->total;
914 }
915
916 if (pT->mCurEv.mTotalChannelCount == 0)
917 pT->mCurEv.mTotalChannelCount = tp->total;
918 if (pT->mCurEv.mPercent >= 100)
919 pT->mCurEv.mPercent = 99;
920
921 pT->mCurEv.mLockedStatus = 0;
922 pT->mCurEv.mType = ScannerEvent::EVENT_SCAN_PROGRESS;
923
924 pT->mpObserver->onEvent(pT->mCurEv);
925 }
926 break;
927 case AM_SCAN_PROGRESS_TS_END: {
928 /*pT->mCurEv.mLockedStatus = 0;
929 pT->mCurEv.mType = ScannerEvent::EVENT_SCAN_PROGRESS;
930 pT->mpObserver->onEvent(pT->mCurEv);*/
931 }
932 break;
933
934 case AM_SCAN_PROGRESS_PAT_DONE: /*{
935 if (pT->mCurEv.mTotalChannelCount == 1) {
936 pT->mCurEv.mType = ScannerEvent::EVENT_SCAN_PROGRESS;
937 pT->mpObserver->onEvent(pT->mCurEv);
938 }
939 }*/
940 break;
941 case AM_SCAN_PROGRESS_SDT_DONE: /*{
942 dvbpsi_sdt_t *sdts = (dvbpsi_sdt_t *)evt->data;
943 dvbpsi_sdt_t *sdt;
944
945 if (pT->mCurEv.mTotalChannelCount == 1) {
946 pT->mCurEv.mPercent += 25;
947 if (pT->mCurEv.mPercent >= 100)
948 pT->mCurEv.mPercent = 99;
949 pT->mCurEv.mType = ScannerEvent::EVENT_SCAN_PROGRESS;
950
951 pT->mpObserver->onEvent(pT->mCurEv);
952 }
953 }*/
954 break;
955 case AM_SCAN_PROGRESS_CAT_DONE: /*{
956 dvbpsi_cat_t *cat = (dvbpsi_cat_t *)evt->data;
957 if (pT->mCurEv.mTotalChannelCount == 1) {
958 pT->mCurEv.mPercent += 25;
959 if (pT->mCurEv.mPercent >= 100)
960 pT->mCurEv.mPercent = 99;
961
962 pT->mCurEv.mType = ScannerEvent::EVENT_SCAN_PROGRESS;
963
964 pT->mpObserver->onEvent(pT->mCurEv);
965 }
966 }*/
967 break;
968 case AM_SCAN_PROGRESS_PMT_DONE: /*{
969 dvbpsi_pmt_t *pmt = (dvbpsi_pmt_t *)evt->data;
970 if (pT->mCurEv.mTotalChannelCount == 1) {
971 pT->mCurEv.mPercent += 25;
972 if (pT->mCurEv.mPercent >= 100)
973 pT->mCurEv.mPercent = 99;
974
975 pT->mCurEv.mType = ScannerEvent::EVENT_SCAN_PROGRESS;
976 pT->mpObserver->onEvent(pT->mCurEv);
977 }
978 }*/
979 break;
980 case AM_SCAN_PROGRESS_MGT_DONE: {
981 mgt_section_info_t *mgt = (mgt_section_info_t *)evt->data;
982
983 if (pT->mCurEv.mTotalChannelCount == 1) {
984 pT->mCurEv.mPercent += 10;
985 if (pT->mCurEv.mPercent >= 100)
986 pT->mCurEv.mPercent = 99;
987
988 pT->mCurEv.mType = ScannerEvent::EVENT_SCAN_PROGRESS;
989
990 pT->mpObserver->onEvent(pT->mCurEv);
991 }
992 }
993 break;
994 case AM_SCAN_PROGRESS_VCT_DONE: {
995 /*ATSC TVCT*/
996 if (pT->mCurEv.mTotalChannelCount == 1) {
997 pT->mCurEv.mPercent += 30;
998 if (pT->mCurEv.mPercent >= 100)
999 pT->mCurEv.mPercent = 99;
1000 pT->mCurEv.mType = ScannerEvent::EVENT_SCAN_PROGRESS;
1001
1002 pT->mpObserver->onEvent(pT->mCurEv);
1003 }
1004 }
1005 break;
1006 case AM_SCAN_PROGRESS_NEW_PROGRAM: {
1007 /* Notify the new searched programs */
1008 AM_SCAN_ProgramProgress_t *pp = (AM_SCAN_ProgramProgress_t *)evt->data;
1009 if (pp != NULL) {
1010 pT->mCurEv.mprogramType = pp->service_type;
1011 snprintf(pT->mCurEv.mProgramName, sizeof(pT->mCurEv.mProgramName), "%s", pp->name);
1012
1013 pT->mCurEv.mType = ScannerEvent::EVENT_SCAN_PROGRESS;
1014
1015 pT->mpObserver->onEvent(pT->mCurEv);
1016 }
1017 }
1018 break;
1019 case AM_SCAN_PROGRESS_BLIND_SCAN: {
1020 AM_SCAN_DTVBlindScanProgress_t *bs_prog = (AM_SCAN_DTVBlindScanProgress_t *)evt->data;
1021
1022 if (bs_prog) {
1023 pT->mCurEv.mPercent = bs_prog->progress;
1024
1025 snprintf(pT->mCurEv.mMSG, sizeof(pT->mCurEv.mMSG), "%s/%s %dMHz",
1026 bs_prog->polar == AM_FEND_POLARISATION_H ? "H" : "V",
1027 bs_prog->lo == AM_FEND_LOCALOSCILLATORFREQ_L ? "L-LOF" : "H-LOF",
1028 bs_prog->freq / 1000);
1029
1030 pT->mCurEv.mType = ScannerEvent::EVENT_BLINDSCAN_PROGRESS;
1031
1032 pT->mpObserver->onEvent(pT->mCurEv);
1033
1034 if (bs_prog->new_tp_cnt > 0) {
1035 int i = 0;
1036 for (i = 0; i < bs_prog->new_tp_cnt; i++) {
1037 LOGD("====New tp: %dkS/s %d====", bs_prog->new_tps[i].frequency,
1038 bs_prog->new_tps[i].u.qpsk.symbol_rate);
1039
1040 pT->mCurEv.mFrequency = bs_prog->new_tps[i].frequency;
1041 pT->mCurEv.mSymbolRate = bs_prog->new_tps[i].u.qpsk.symbol_rate;
1042 pT->mCurEv.mSat_polarisation = bs_prog->polar;
1043
1044 pT->mCurEv.mType = ScannerEvent::EVENT_BLINDSCAN_NEWCHANNEL;
1045
1046 pT->mpObserver->onEvent(pT->mCurEv);
1047 }
1048 }
1049 if (bs_prog->progress >= 100) {
1050
1051 pT->mCurEv.mType = ScannerEvent::EVENT_BLINDSCAN_END;
1052
1053 pT->mpObserver->onEvent(pT->mCurEv);
1054
1055 pT->mCurEv.mPercent = 0;
1056 }
1057 }
1058 }
1059 break;
1060 case AM_SCAN_PROGRESS_STORE_BEGIN: {
1061 pT->mCurEv.mType = ScannerEvent::EVENT_STORE_BEGIN;
1062 pT->mCurEv.mLockedStatus = 0;
1063 if (pT->mpObserver != NULL)
1064 pT->mpObserver->onEvent(pT->mCurEv);
1065 }
1066 break;
1067 case AM_SCAN_PROGRESS_STORE_END: {
1068 pT->mCurEv.mLockedStatus = 0;
1069 pT->mCurEv.mType = ScannerEvent::EVENT_STORE_END;
1070 pT->mpObserver->onEvent(pT->mCurEv);
1071 }
1072 break;
1073 case AM_SCAN_PROGRESS_SCAN_END: {
1074 pT->mCurEv.mPercent = 100;
1075 pT->mCurEv.mLockedStatus = 0;
1076 pT->mCurEv.mType = ScannerEvent::EVENT_SCAN_END;
1077 pT->mpObserver->onEvent(pT->mCurEv);
1078 }
1079 break;
1080 case AM_SCAN_PROGRESS_ATV_TUNING: {
1081 pT->mCurEv.mFrequency = (int)evt->data;
1082 pT->mCurEv.mLockedStatus = 0;
1083 tmpFreq = (pT->mCurEv.mFrequency - pT->mCurScanStartFreq) / 1000000;
1084 pT->mCurEv.mPercent = tmpFreq * 100UL / ((pT->mCurScanEndFreq - pT->mCurScanStartFreq) / 1000000);
1085 pT->mCurEv.mType = ScannerEvent::EVENT_SCAN_PROGRESS;
1086 pT->mpObserver->onEvent(pT->mCurEv);
1087 }
1088 break;
1089
1090 default:
1091 break;
1092 }
1093 } else if (event_type == AM_SCAN_EVT_SIGNAL) {
1094 AM_SCAN_DTVSignalInfo_t *evt = (AM_SCAN_DTVSignalInfo_t *)param;
1095 pT->mCurEv.mprogramType = 0xff;
1096 pT->mCurEv.mFrequency = (int)evt->frequency;
1097 pT->mCurEv.mLockedStatus = (evt->locked ? 1 : 0);
1098
1099 pT->mCurEv.mType = ScannerEvent::EVENT_SCAN_PROGRESS;
1100 if (pT->mCurEv.mMode != FE_ANALOG && evt->locked) {
1101 pT->mCurEv.mStrength = evt->strength;
1102 pT->mCurEv.mSnr = evt->snr;
1103 } else {
1104 pT->mCurEv.mStrength = 0;
1105 pT->mCurEv.mSnr = 0;
1106 }
1107
1108 if (pT->mCurEv.mMode == FE_ANALOG)
1109 pT->mpObserver->onEvent(pT->mCurEv);
1110 }
1111}
1112
1113void CTvScanner::tv_scan_reconnect_dmx_to_fend(int dmx_no, int fend_no)
1114{
1115 AM_DMX_Source_t src;
1116
1117 if (AM_FEND_GetTSSource(fend_no, &src) == AM_SUCCESS) {
1118 LOGD("Set demux%d source to %d", dmx_no, src);
1119 AM_DMX_SetSource(dmx_no, src);
1120 } else {
1121 LOGD("Cannot get frontend ts source!!");
1122 }
1123}
1124
1125int CTvScanner::getAtscChannelPara(int attennaType, Vector<sp<CTvChannel> > &vcp)
1126{
1127 switch (attennaType) { //region name should be remove to config file and read here
1128 case 1:
1129 CTvRegion::getChannelListByName("U.S.,ATSC Air", vcp);
1130 break;
1131 case 2:
1132 CTvRegion::getChannelListByName("U.S.,ATSC Cable Standard", vcp);
1133 break;
1134 case 3:
1135 CTvRegion::getChannelListByName("U.S.,ATSC Cable IRC", vcp);
1136 break;
1137 case 4:
1138 CTvRegion::getChannelListByName("U.S.,ATSC Cable HRC", vcp);
1139 break;
1140 default:
1141 return -1;
1142 }
1143
1144 return 0;
1145}
1146
1147
generated by cgit at 2024-05-12 21:02:39 (GMT)