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