summaryrefslogtreecommitdiff
path: root/tvapi/libtv/tv/CTvScanner.cpp (plain)
blob: ecfd6f94416478ac9cb85eab1d6340f535d97b4d
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
404
405#define dvb_fend_para(_p) ((struct dvb_frontend_parameters*)(&_p))
406#define IS_DVBT2_TS(_para) (_para.m_type == FE_OFDM && _para.terrestrial.para.u.ofdm.ofdm_mode == OFDM_DVBT2)
407#define IS_ISDBT_TS(_para) (_para.m_type == FE_ISDBT)
408
409dvbpsi_pat_t *CTvScanner::get_valid_pats(AM_SCAN_TS_t *ts)
410{
411 dvbpsi_pat_t *valid_pat = NULL;
412 if (!IS_DVBT2_TS(ts->digital.fend_para)) {
413 valid_pat = ts->digital.pats;
414 } else if (IS_ISDBT_TS(ts->digital.fend_para)) {
415 /* process for isdbt one-seg inserted PAT, which ts_id is 0xffff */
416 valid_pat = ts->digital.pats;
417 while (valid_pat != NULL && valid_pat->i_ts_id == 0xffff) {
418 valid_pat = valid_pat->p_next;
419 }
420
421 if (valid_pat == NULL && ts->digital.pats != NULL) {
422 valid_pat = ts->digital.pats;
423
424 if (ts->digital.sdts != NULL)
425 valid_pat->i_ts_id = ts->digital.sdts->i_ts_id;
426 }
427 } else {
428 int plp;
429
430 for (plp = 0; plp < ts->digital.dvbt2_data_plp_num; plp++) {
431 if (ts->digital.dvbt2_data_plps[plp].pats != NULL) {
432 valid_pat = ts->digital.dvbt2_data_plps[plp].pats;
433 break;
434 }
435 }
436 }
437
438 return valid_pat;
439}
440
441void CTvScanner::scan_process_ts_info(AM_SCAN_Result_t *result, AM_SCAN_TS_t *ts, ScannerEvent *evt)
442{
443 dvbpsi_nit_t *nit;
444 dvbpsi_descriptor_t *descr;
445
446 evt->mONetId = -1;
447 evt->mTsId = -1;
448
449 if (ts->digital.sdts)
450 evt->mONetId = ts->digital.sdts->i_network_id;
451 else if (IS_DVBT2_TS(ts->digital.fend_para) && ts->digital.dvbt2_data_plp_num > 0 && ts->digital.dvbt2_data_plps[0].sdts)
452 evt->mONetId = ts->digital.dvbt2_data_plps[0].sdts->i_network_id;
453 evt->mTsId = get_valid_pats(ts)->i_ts_id;
454
455 evt->mFrequency = (int)dvb_fend_para(ts->digital.fend_para)->frequency;
456 evt->mMode = ts->digital.fend_para.m_type;
457 if (IS_DVBT2_TS(ts->digital.fend_para))
458 evt->mOfdm_mode = (int)dvb_fend_para(ts->digital.fend_para)->u.ofdm.ofdm_mode;
459 else if ((ts->digital.fend_para.m_type == FE_DTMB) || (ts->digital.fend_para.m_type == FE_OFDM))
460 evt->mBandwidth = (int)dvb_fend_para(ts->digital.fend_para)->u.ofdm.bandwidth;
461 else if(ts->digital.fend_para.m_type == FE_QAM) {
462 evt->mSymbolRate = (int)dvb_fend_para(ts->digital.fend_para)->u.qam.symbol_rate;
463 evt->mModulation = (int)dvb_fend_para(ts->digital.fend_para)->u.qam.modulation;
464 }
465}
466void CTvScanner::scan_init_service_info(SCAN_ServiceInfo_t *srv_info)
467{
468 memset(srv_info, 0, sizeof(SCAN_ServiceInfo_t));
469 srv_info->vid = 0x1fff;
470 srv_info->vfmt = -1;
471 srv_info->free_ca = 1;
472 srv_info->srv_id = 0xffff;
473 srv_info->srv_dbid = -1;
474 srv_info->satpara_dbid = -1;
475 srv_info->pmt_pid = 0x1fff;
476 srv_info->plp_id = -1;
477 srv_info->sdt_version = 0xff;
478}
479int CTvScanner::get_pmt_pid(dvbpsi_pat_t *pats, int program_number)
480{
481 dvbpsi_pat_t *pat;
482 dvbpsi_pat_program_t *prog;
483
484 AM_SI_LIST_BEGIN(pats, pat)
485 AM_SI_LIST_BEGIN(pat->p_first_program, prog)
486 if (prog->i_number == program_number)
487 return prog->i_pid;
488 AM_SI_LIST_END()
489 AM_SI_LIST_END()
490
491 return 0x1fff;
492}
493
494void CTvScanner::scan_extract_ca_scrambled_flag(dvbpsi_descriptor_t *p_first_descriptor, int *flag)
495{
496 dvbpsi_descriptor_t *descr;
497
498 AM_SI_LIST_BEGIN(p_first_descriptor, descr)
499 if (descr->i_tag == AM_SI_DESCR_CA && ! *flag) {
500 LOGD( "Found CA descr, set scrambled flag to 1");
501 *flag = 1;
502 break;
503 }
504 AM_SI_LIST_END()
505}
506
507void CTvScanner::scan_extract_srv_info_from_sdt(AM_SCAN_Result_t *result, dvbpsi_sdt_t *sdts, SCAN_ServiceInfo_t *srv_info)
508{
509 dvbpsi_sdt_service_t *srv;
510 dvbpsi_sdt_t *sdt;
511 dvbpsi_descriptor_t *descr;
512 const uint8_t split = 0x80;
513 const int name_size = (int)sizeof(srv_info->name);
514 int curr_name_len = 0, tmp_len;
515 char name[AM_DB_MAX_SRV_NAME_LEN + 1];
516
517 UNUSED(result);
518
519#define COPY_NAME(_s, _slen)\
520 AM_MACRO_BEGIN\
521 int copy_len = ((curr_name_len+_slen)>=name_size) ? (name_size-curr_name_len) : _slen;\
522 if (copy_len > 0) {\
523 memcpy(srv_info->name+curr_name_len, _s, copy_len);\
524 curr_name_len += copy_len;\
525 }\
526 AM_MACRO_END
527
528
529 AM_SI_LIST_BEGIN(sdts, sdt)
530 AM_SI_LIST_BEGIN(sdt->p_first_service, srv)
531 /*从SDT表中查找该service并获取信息*/
532 if (srv->i_service_id == srv_info->srv_id) {
533 LOGD("SDT for service %d found!", srv_info->srv_id);
534 srv_info->eit_sche = (uint8_t)srv->b_eit_schedule;
535 srv_info->eit_pf = (uint8_t)srv->b_eit_present;
536 srv_info->rs = srv->i_running_status;
537 srv_info->free_ca = (uint8_t)srv->b_free_ca;
538 srv_info->sdt_version = sdt->i_version;
539
540 AM_SI_LIST_BEGIN(srv->p_first_descriptor, descr)
541 if (descr->p_decoded && descr->i_tag == AM_SI_DESCR_SERVICE) {
542 dvbpsi_service_dr_t *psd = (dvbpsi_service_dr_t *)descr->p_decoded;
543 if (psd->i_service_name_length > 0) {
544 name[0] = 0;
545 AM_SI_ConvertDVBTextCode((char *)psd->i_service_name, psd->i_service_name_length, \
546 name, AM_DB_MAX_SRV_NAME_LEN);
547 name[AM_DB_MAX_SRV_NAME_LEN] = 0;
548
549 /*3bytes language code, using xxx to simulate*/
550 COPY_NAME("xxx", 3);
551 /*following by name text*/
552 tmp_len = strlen(name);
553 COPY_NAME(name, tmp_len);
554 }
555 /*业务类型*/
556 srv_info->srv_type = psd->i_service_type;
557 /*service type 0x16 and 0x19 is user defined, as digital television service*/
558 /*service type 0xc0 is type of partial reception service in ISDBT*/
559 if ((srv_info->srv_type == 0x16) || (srv_info->srv_type == 0x19) || (srv_info->srv_type == 0xc0)) {
560 srv_info->srv_type = 0x1;
561 }
562 break;
563 }
564 AM_SI_LIST_END()
565
566 /* store multilingual service name */
567 AM_SI_LIST_BEGIN(srv->p_first_descriptor, descr)
568 if (descr->p_decoded && descr->i_tag == AM_SI_DESCR_MULTI_SERVICE_NAME) {
569 int i;
570 dvbpsi_multi_service_name_dr_t *pmsnd = (dvbpsi_multi_service_name_dr_t *)descr->p_decoded;
571
572 for (i = 0; i < pmsnd->i_name_count; i++) {
573 name[0] = 0;
574 AM_SI_ConvertDVBTextCode((char *)pmsnd->p_service_name[i].i_service_name,
575 pmsnd->p_service_name[i].i_service_name_length,
576 name, AM_DB_MAX_SRV_NAME_LEN);
577 name[AM_DB_MAX_SRV_NAME_LEN] = 0;
578
579 if (curr_name_len > 0) {
580 /*extra split mark*/
581 COPY_NAME(&split, 1);
582 }
583 /*3bytes language code*/
584 COPY_NAME(pmsnd->p_service_name[i].i_iso_639_code, 3);
585 /*following by name text*/
586 tmp_len = strlen(name);
587 COPY_NAME(name, tmp_len);
588 }
589 }
590 AM_SI_LIST_END()
591
592 /* set the ending null byte */
593 if (curr_name_len >= name_size)
594 srv_info->name[name_size - 1] = 0;
595 else
596 srv_info->name[curr_name_len] = 0;
597
598 break;
599 }
600 AM_SI_LIST_END()
601 AM_SI_LIST_END()
602}
603
604void CTvScanner::scan_update_service_info(AM_SCAN_Result_t *result, SCAN_ServiceInfo_t *srv_info)
605{
606#define str(i) (char*)(strings + i)
607
608 static char strings[14][256];
609
610 if (srv_info->src != FE_ANALOG) {
611 int standard = result->start_para->dtv_para.standard;
612 int mode = result->start_para->dtv_para.mode;
613
614 /* Transform service types for different dtv standards */
615 if (standard != AM_SCAN_DTV_STD_ATSC) {
616 if (srv_info->srv_type == 0x1)
617 srv_info->srv_type = AM_SCAN_SRV_DTV;
618 else if (srv_info->srv_type == 0x2)
619 srv_info->srv_type = AM_SCAN_SRV_DRADIO;
620 } else {
621 if (srv_info->srv_type == 0x2)
622 srv_info->srv_type = AM_SCAN_SRV_DTV;
623 else if (srv_info->srv_type == 0x3)
624 srv_info->srv_type = AM_SCAN_SRV_DRADIO;
625 }
626
627 /* if video valid, set this program to tv type,
628 * if audio valid, but video not found, set it to radio type,
629 * if both invalid, but service_type found in SDT/VCT, set to unknown service,
630 * this mechanism is OPTIONAL
631 */
632 if (srv_info->vid < 0x1fff) {
633 srv_info->srv_type = AM_SCAN_SRV_DTV;
634 } else if (srv_info->aud_info.audio_count > 0) {
635 srv_info->srv_type = AM_SCAN_SRV_DRADIO;
636 } else if (srv_info->srv_type == AM_SCAN_SRV_DTV ||
637 srv_info->srv_type == AM_SCAN_SRV_DRADIO) {
638 srv_info->srv_type = AM_SCAN_SRV_UNKNOWN;
639 }
640 /* Skip program for FTA mode */
641 if (srv_info->scrambled_flag && (mode & AM_SCAN_DTVMODE_FTA)) {
642 LOGD( "Skip program '%s' for FTA mode", srv_info->name);
643 return;
644 }
645
646 /* Skip program for service_type mode */
647 if (srv_info->srv_type == AM_SCAN_SRV_DTV && (mode & AM_SCAN_DTVMODE_NOTV)) {
648 LOGD( "Skip program '%s' for NO-TV mode", srv_info->name);
649 return;
650 }
651 if (srv_info->srv_type == AM_SCAN_SRV_DRADIO && (mode & AM_SCAN_DTVMODE_NORADIO)) {
652 LOGD( "Skip program '%s' for NO-RADIO mode", srv_info->name);
653 return;
654 }
655
656 /* Set default name to tv/radio program if no name specified */
657 if (!strcmp(srv_info->name, "") &&
658 (srv_info->srv_type == AM_SCAN_SRV_DTV ||
659 srv_info->srv_type == AM_SCAN_SRV_DRADIO)) {
660 strcpy(srv_info->name, "xxxNo Name");
661 }
662 }
663}
664
665void CTvScanner::scan_store_dvb_ts_evt_service(SCAN_ServiceInfo_t *srv)
666{
667 LOGD("scan_store_dvb_ts_evt_service freq:%d, sid:%d", m_s_Scanner->mCurEv.mFrequency, srv->srv_id);
668 m_s_Scanner->mCurEv.mServiceId = srv->srv_id;
669 strncpy(m_s_Scanner->mCurEv.mProgramName, srv->name, 1024);
670 m_s_Scanner->mCurEv.mprogramType = srv->srv_type;
671 m_s_Scanner->mCurEv.mVid = srv->vid;
672 m_s_Scanner->mCurEv.mVfmt = srv->vfmt;
673 m_s_Scanner->mCurEv.mAcnt = srv->aud_info.audio_count;
674 for (int i = 0; i < srv->aud_info.audio_count; i++) {
675 m_s_Scanner->mCurEv.mAid[i] = srv->aud_info.audios[i].pid;
676 m_s_Scanner->mCurEv.mAfmt[i] = srv->aud_info.audios[i].fmt;
677 strncpy(m_s_Scanner->mCurEv.mAlang[i], srv->aud_info.audios[i].lang, 10);
678 m_s_Scanner->mCurEv.mAtype[i] = srv->aud_info.audios[i].audio_type;
679 }
680 m_s_Scanner->mCurEv.mPcr = srv->pcr_pid;
681
682 m_s_Scanner->mCurEv.mMSG[0] = '\0';
683
684 m_s_Scanner->mCurEv.mType = ScannerEvent::EVENT_DTV_PROG_DATA;
685 m_s_Scanner->mpObserver->onEvent(m_s_Scanner->mCurEv);
686}
687
688void CTvScanner::scan_store_dvb_ts(AM_SCAN_Result_t *result, AM_SCAN_TS_t *ts)
689{
690 dvbpsi_pmt_t *pmt;
691 dvbpsi_pmt_es_t *es;
692 dvbpsi_descriptor_t *descr;
693 int src = result->start_para->dtv_para.source;
694 int mode = result->start_para->dtv_para.mode;
695 int net_dbid = -1, dbid = -1, orig_net_id = -1, satpara_dbid = -1;
696 char selbuf[256];
697 char insbuf[400];
698 AM_Bool_t store = AM_TRUE;
699 dvbpsi_pat_t *valid_pat = NULL;
700 uint8_t plp_id;
701 SCAN_ServiceInfo_t srv_info;
702
703 valid_pat = get_valid_pats(ts);
704 if (valid_pat == NULL) {
705 LOGD("No PAT found in ts, will not store to dbase");
706 return;
707 }
708
709 LOGD("@@ TS: src %d @@", src);
710
711 scan_process_ts_info(result, ts, &m_s_Scanner->mCurEv);
712
713 if (ts->digital.pmts || (IS_DVBT2_TS(ts->digital.fend_para) && ts->digital.dvbt2_data_plp_num > 0)) {
714 int loop_count, lc;
715 dvbpsi_sdt_t *sdt_list;
716 dvbpsi_pmt_t *pmt_list;
717 dvbpsi_pat_t *pat_list;
718
719 /* For DVB-T2, search for each PLP, else search in current TS*/
720 loop_count = IS_DVBT2_TS(ts->digital.fend_para) ? ts->digital.dvbt2_data_plp_num : 1;
721 LOGD("plp num %d", loop_count);
722
723 for (lc = 0; lc < loop_count; lc++) {
724 pat_list = IS_DVBT2_TS(ts->digital.fend_para) ? ts->digital.dvbt2_data_plps[lc].pats : ts->digital.pats;
725 pmt_list = IS_DVBT2_TS(ts->digital.fend_para) ? ts->digital.dvbt2_data_plps[lc].pmts : ts->digital.pmts;
726 sdt_list = IS_DVBT2_TS(ts->digital.fend_para) ? ts->digital.dvbt2_data_plps[lc].sdts : ts->digital.sdts;
727 plp_id = IS_DVBT2_TS(ts->digital.fend_para) ? ts->digital.dvbt2_data_plps[lc].id : -1;
728 LOGD("plp_id %d", plp_id);
729
730 AM_SI_LIST_BEGIN(pmt_list, pmt) {
731 scan_init_service_info(&srv_info);
732 srv_info.satpara_dbid = satpara_dbid;
733 srv_info.srv_id = pmt->i_program_number;
734 srv_info.src = src;
735 srv_info.pmt_pid = get_pmt_pid(pat_list, pmt->i_program_number);
736 srv_info.pcr_pid = pmt->i_pcr_pid;
737 srv_info.plp_id = plp_id;
738
739 /* looking for CA descr */
740 if (! srv_info.scrambled_flag) {
741 scan_extract_ca_scrambled_flag(pmt->p_first_descriptor, &srv_info.scrambled_flag);
742 }
743
744 AM_SI_LIST_BEGIN(pmt->p_first_es, es) {
745 AM_SI_ExtractAVFromES(es, &srv_info.vid, &srv_info.vfmt, &srv_info.aud_info);
746
747 if (store) {
748 AM_SI_ExtractDVBSubtitleFromES(es, &srv_info.sub_info);
749 AM_SI_ExtractDVBTeletextFromES(es, &srv_info.ttx_info);
750 }
751
752 if (! srv_info.scrambled_flag)
753 scan_extract_ca_scrambled_flag(es->p_first_descriptor, &srv_info.scrambled_flag);
754 }
755 AM_SI_LIST_END()
756
757 scan_extract_srv_info_from_sdt(result, sdt_list, &srv_info);
758
759 /*Store this service*/
760 scan_update_service_info(result, &srv_info);
761
762 scan_store_dvb_ts_evt_service(&srv_info);
763
764 }
765 AM_SI_LIST_END()
766
767 /* All programs in PMTs added, now trying the programs in SDT but NOT in PMT */
768 dvbpsi_sdt_service_t *srv;
769 dvbpsi_sdt_t *sdt;
770
771 AM_SI_LIST_BEGIN(ts->digital.sdts, sdt) {
772 AM_SI_LIST_BEGIN(sdt->p_first_service, srv) {
773 AM_Bool_t found_in_pmt = AM_FALSE;
774
775 /* Is already added in PMT? */
776 AM_SI_LIST_BEGIN(ts->digital.pmts, pmt)
777 if (srv->i_service_id == pmt->i_program_number) {
778 found_in_pmt = AM_TRUE;
779 break;
780 }
781 AM_SI_LIST_END()
782
783 if (found_in_pmt)
784 continue;
785
786 scan_init_service_info(&srv_info);
787 srv_info.satpara_dbid = satpara_dbid;
788 srv_info.srv_id = srv->i_service_id;
789 srv_info.src = src;
790
791 scan_extract_srv_info_from_sdt(result, sdt_list, &srv_info);
792
793 scan_update_service_info(result, &srv_info);
794
795 /*as no pmt for this srv, set type to data for invisible*/
796 srv_info.srv_type = 0;
797
798 scan_store_dvb_ts_evt_service(&srv_info);
799
800 }
801 AM_SI_LIST_END()
802 }
803 AM_SI_LIST_END()
804
805 }
806 }
807}
808
809void CTvScanner::dtv_scan_store(AM_SCAN_Result_t *result)
810{
811 AM_SCAN_TS_t *ts;
812
813 LOGD("Storing tses ...");
814
815 AM_SI_LIST_BEGIN(result->tses, ts) {
816 scan_store_dvb_ts(result, ts);
817 }
818 AM_SI_LIST_END()
819}
820
821int CTvScanner::manualDtmbScan(int beginFreq, int endFreq, int modulation)
822{
823 stopScan();
824
825 if(!mbScanStart) { //not start or stop
826 AM_SCAN_CreatePara_t para;
827 AM_DMX_OpenPara_t dmx_para;
828 AM_SCAN_Handle_t handle = 0;
829 int i;
830 // Create the scan
831 memset(&para, 0, sizeof(para));
832
833 para.fend_dev_id = 0;//default
834 para.mode = AM_SCAN_MODE_DTV_ATV;//DTV
835 para.atv_para.mode = AM_SCAN_ATVMODE_NONE;
836 para.dtv_para.mode = AM_SCAN_DTVMODE_MANUAL;
837 para.dtv_para.source = FE_DTMB;//fe_type
838 para.dtv_para.dmx_dev_id = 0;//default 0
839
840 Vector<sp<CTvChannel> > vcp;
841 CTvRegion::getChannelListByNameAndFreqRange("CHINA,Default DTMB ALL", beginFreq, endFreq, vcp);
842 int size = vcp.size();
843
844 //@author:hao.fu
845 if(size == 0) {
846 return -1;
847 }
848
849 if(!(para.dtv_para.fe_paras = static_cast<AM_FENDCTRL_DVBFrontendParameters_t *>(calloc(size, sizeof(AM_FENDCTRL_DVBFrontendParameters_t)))))
850 return -1;
851
852 for (i = 0; i < size; i++) {
853 para.dtv_para.fe_paras[i].m_type = 5;//MODE_DTMB
854 para.dtv_para.fe_paras[i].dtmb.para.frequency = vcp[i]->getFrequency();
855 para.dtv_para.fe_paras[i].dtmb.para.inversion = INVERSION_OFF;
856 para.dtv_para.fe_paras[i].dtmb.para.u.ofdm.bandwidth = (fe_bandwidth_t)(vcp[i]->getBandwidth());
857 if (modulation == -1)
858 para.dtv_para.fe_paras[i].cable.para.u.qam.modulation = (fe_modulation_t)(vcp[i]->getModulation());
859 else
860 para.dtv_para.fe_paras[i].cable.para.u.qam.modulation = (fe_modulation_t)modulation;
861 }
862
863 para.dtv_para.fe_cnt = size;
864 para.dtv_para.resort_all = AM_FALSE;
865 para.dtv_para.sort_method = AM_SCAN_SORT_BY_FREQ_SRV_ID;
866 para.store_cb = dtv_scan_store;
867
868
869 memset(&dmx_para, 0, sizeof(dmx_para));
870 AM_DMX_Open(para.dtv_para.dmx_dev_id, &dmx_para);
871
872 if ((para.dtv_para.mode & 0x07) != AM_SCAN_DTVMODE_NONE) {
873 AM_FEND_SetMode(para.fend_dev_id, para.dtv_para.source);
874 tv_scan_reconnect_dmx_to_fend(para.dtv_para.dmx_dev_id, para.fend_dev_id);
875 }
876
877 // Start Scan
878 if (AM_SCAN_Create(&para, &handle) != AM_SUCCESS) {
879 LOGD("SCAN CREATE fail");
880 handle = NULL;
881 } else {
882 mScanHandle = handle;
883 AM_SCAN_SetUserData(handle, (void *)this);
884 AM_EVT_Subscribe((long)handle, AM_SCAN_EVT_PROGRESS, tv_scan_evt_callback, NULL);
885 AM_EVT_Subscribe((long)handle, AM_SCAN_EVT_SIGNAL, tv_scan_evt_callback, NULL);
886 if (AM_SCAN_Start(handle) != AM_SUCCESS) {
887 AM_SCAN_Destroy(handle, AM_FALSE);
888 AM_EVT_Unsubscribe((long)handle, AM_SCAN_EVT_PROGRESS, tv_scan_evt_callback, NULL);
889 AM_EVT_Unsubscribe((long)handle, AM_SCAN_EVT_SIGNAL, tv_scan_evt_callback, NULL);
890 handle = NULL;
891 }
892 }
893 if (para.atv_para.fe_paras != NULL)
894 free(para.atv_para.fe_paras);
895 if (para.dtv_para.fe_paras != NULL)
896 free(para.dtv_para.fe_paras);
897
898 if (handle == NULL) {
899 return -1;
900 }
901 mbScanStart = true;//start call ok
902 } else {
903 LOGD("scanning and not stop");
904 }
905 return 0;
906}
907
908
909/*int CTvScanner::autoTvScan()
910{
911 stopScan();
912
913 if(!mbScanStart) { //not start or stop
914 AM_SCAN_CreatePara_t para;
915 AM_DMX_OpenPara_t dmx_para;
916 int handle = 0,i;
917 // Create the scan
918 memset(&para, 0, sizeof(para));
919
920 //strcpy(para.default_text_lang,"eng");//config
921 //strcpy(para.text_langs, "eng zho chi");//config
922 para.fend_dev_id = 0;//default
923 para.mode = AM_SCAN_MODE_DTV_ATV;//DTV
924 para.atv_para.mode = AM_SCAN_ATVMODE_NONE;
925 para.dtv_para.mode = AM_SCAN_DTVMODE_ALLBAND;//DTV_MODE_ALLBAND
926 //para.dtv_para.mode |= (*env)->GetIntField(env, para, doptions);//忽略
927 para.dtv_para.source = 1;//QAM
928 para.dtv_para.dmx_dev_id = 0;//default 0
929 Vector<sp<CTvChannel> > vcp;
930 //CTvDatabase::getChannelParaList("/data/tv_default.xml", vcp);//channel list from xml or db
931 CTvRegion::getChannelListByName("China,DVB-C allband", vcp);
932
933 int size = vcp.size();
934 LOGD("channel list size = %d", size);
935 if(!(para.dtv_para.fe_paras = static_cast<AM_FENDCTRL_DVBFrontendParameters_t*>(calloc(size, sizeof(AM_FENDCTRL_DVBFrontendParameters_t)))))
936 return -1;
937
938 //memset(pfp, 0, size * sizeof(AM_FENDCTRL_DVBFrontendParameters_t));
939
940 for (i = 0; i < size; i++) {
941 para.dtv_para.fe_paras[i].m_type = FE_QAM;
942 para.dtv_para.fe_paras[i].cable.para.frequency = vcp[i]->getFrequency();
943 para.dtv_para.fe_paras[i].cable.para.inversion = INVERSION_OFF;
944 para.dtv_para.fe_paras[i].cable.para.u.qam.symbol_rate = vcp[i]->getSymbolRate();
945 para.dtv_para.fe_paras[i].cable.para.u.qam.modulation = (fe_modulation_t)(vcp[i]->getModulation());
946 }
947 //allband
948 para.dtv_para.fe_cnt = size;
949
950 para.dtv_para.resort_all = AM_FALSE;
951 para.dtv_para.sort_method = AM_SCAN_SORT_BY_FREQ_SRV_ID;
952 para.store_cb = NULL;
953 memset(&dmx_para, 0, sizeof(dmx_para));
954 AM_DMX_Open(para.dtv_para.dmx_dev_id, &dmx_para);
955
956 if ((para.dtv_para.mode&0x07) != AM_SCAN_DTVMODE_NONE) {
957 AM_FEND_SetMode(para.fend_dev_id, para.dtv_para.source);
958 tv_scan_reconnect_dmx_to_fend(para.dtv_para.dmx_dev_id, para.fend_dev_id);
959 }
960
961 // prog->dmx_id = para.dtv_para.dmx_dev_id;
962 // prog->fend_id = para.fend_dev_id;
963 // prog->mode = para.dtv_para.mode;
964 // Start Scan
965 if (AM_SCAN_Create(&para, &handle) != AM_SUCCESS) {
966 LOGD("SCAN CREATE fail");
967 handle = 0;
968 } else {
969 LOGD("SCAN CREATE handle = %d", handle);
970 mScanHandle = handle;
971 AM_SCAN_SetUserData(handle, (void*)this);
972 //注册搜索事件
973 AM_EVT_Subscribe(handle, AM_SCAN_EVT_PROGRESS, tv_scan_evt_callback, NULL);
974 //注册信号质量通知事件
975 //AM_EVT_Subscribe(handle, AM_SCAN_EVT_SIGNAL, tv_scan_evt_callback, NULL);
976 if (AM_SCAN_Start(handle) != AM_SUCCESS) {
977 AM_SCAN_Destroy(handle, AM_FALSE);
978 AM_EVT_Unsubscribe(handle, AM_SCAN_EVT_PROGRESS, tv_scan_evt_callback, NULL);
979 // AM_EVT_Unsubscribe(handle, AM_SCAN_EVT_SIGNAL, tv_scan_evt_callback, NULL);
980 handle = 0;
981 }
982 }
983 if (para.atv_para.fe_paras != NULL)
984 free(para.atv_para.fe_paras);
985 if (para.dtv_para.fe_paras != NULL)
986 free(para.dtv_para.fe_paras);
987
988 if (handle == 0) {
989 return -1;
990 }
991 mbScanStart = true;//start call ok
992 } else {
993 LOGD("scanning and not stop");
994 }
995 return 0;
996}*/
997//only test for dtv allbland auto
998/*int CTvScanner::startScan()
999{
1000 stopScan();
1001
1002 if(!mbScanStart) { //not start or stop
1003 AM_SCAN_CreatePara_t para;
1004 AM_DMX_OpenPara_t dmx_para;
1005 int handle = 0,i;
1006 // Create the scan
1007 memset(&para, 0, sizeof(para));
1008
1009 //strcpy(para.default_text_lang,"eng");//config
1010 //strcpy(para.text_langs, "eng zho chi");//config
1011 para.fend_dev_id = 0;//default
1012 para.mode = AM_SCAN_MODE_DTV_ATV;//DTV
1013 para.atv_para.mode = AM_SCAN_ATVMODE_NONE;
1014 para.dtv_para.mode = 3;//DTV_MODE_ALLBAND
1015 //para.dtv_para.mode |= (*env)->GetIntField(env, para, doptions);//忽略
1016 para.dtv_para.source = 1;//QAM
1017 para.dtv_para.dmx_dev_id = 0;//default 0
1018 Vector<sp<CTvChannel> > vcp;
1019 //CTvDatabase::getChannelParaList("/data/tv_default.xml", vcp);//channel list from xml or db
1020 CTvRegion::getChannelListByName("China,DVB-C allband", vcp);
1021
1022 int size = vcp.size();
1023 LOGD("channel list size = %d", size);
1024 if(!(para.dtv_para.fe_paras = static_cast<AM_FENDCTRL_DVBFrontendParameters_t*>(calloc(size, sizeof(AM_FENDCTRL_DVBFrontendParameters_t)))))
1025 return -1;
1026
1027 //memset(pfp, 0, size * sizeof(AM_FENDCTRL_DVBFrontendParameters_t));
1028
1029 for (i = 0; i < size; i++) {
1030 para.dtv_para.fe_paras[i].m_type = FE_QAM;
1031 para.dtv_para.fe_paras[i].cable.para.frequency = vcp[i]->getFrequency();
1032 para.dtv_para.fe_paras[i].cable.para.inversion = INVERSION_OFF;
1033 para.dtv_para.fe_paras[i].cable.para.u.qam.symbol_rate = vcp[i]->getSymbolRate();
1034 para.dtv_para.fe_paras[i].cable.para.u.qam.modulation = (fe_modulation_t)(vcp[i]->getModulation());
1035 }
1036 //allband
1037 para.dtv_para.fe_cnt = size;
1038
1039 para.dtv_para.resort_all = AM_FALSE;
1040 para.dtv_para.sort_method = AM_SCAN_SORT_BY_FREQ_SRV_ID;
1041 para.store_cb = NULL;
1042
1043 memset(&dmx_para, 0, sizeof(dmx_para));
1044 AM_DMX_Open(para.dtv_para.dmx_dev_id, &dmx_para);
1045
1046 if ((para.dtv_para.mode&0x07) != AM_SCAN_DTVMODE_NONE) {
1047 AM_FEND_SetMode(para.fend_dev_id, para.dtv_para.source);
1048 tv_scan_reconnect_dmx_to_fend(para.dtv_para.dmx_dev_id, para.fend_dev_id);
1049 }
1050
1051 // prog->dmx_id = para.dtv_para.dmx_dev_id;
1052 // prog->fend_id = para.fend_dev_id;
1053 // prog->mode = para.dtv_para.mode;
1054 // Start Scan
1055 if (AM_SCAN_Create(&para, &handle) != AM_SUCCESS) {
1056 LOGD("SCAN CREATE fail");
1057 handle = 0;
1058 } else {
1059 mScanHandle = handle;
1060 AM_SCAN_SetUserData(handle, (void*)this);
1061 //注册搜索事件
1062 AM_EVT_Subscribe(handle, AM_SCAN_EVT_PROGRESS, tv_scan_evt_callback, NULL);
1063 //注册信号质量通知事件
1064 //AM_EVT_Subscribe(handle, AM_SCAN_EVT_SIGNAL, tv_scan_evt_callback, NULL);
1065 if (AM_SCAN_Start(handle) != AM_SUCCESS) {
1066 AM_SCAN_Destroy(handle, AM_FALSE);
1067 AM_EVT_Unsubscribe(handle, AM_SCAN_EVT_PROGRESS, tv_scan_evt_callback, NULL);
1068 // AM_EVT_Unsubscribe(handle, AM_SCAN_EVT_SIGNAL, tv_scan_evt_callback, NULL);
1069 handle = 0;
1070 }
1071 }
1072 if (para.atv_para.fe_paras != NULL)
1073 free(para.atv_para.fe_paras);
1074 if (para.dtv_para.fe_paras != NULL)
1075 free(para.dtv_para.fe_paras);
1076
1077 if (handle == 0) {
1078 return -1;
1079 }
1080 mbScanStart = true;//start call ok
1081 } else {
1082 LOGD("scanning and not stop");
1083 }
1084 return 0;
1085}*/
1086
1087
1088//only test for dtv allbland auto
1089int CTvScanner::autoDtmbScan()
1090{
1091 stopScan();
1092
1093 if(!mbScanStart) { //not start or stop
1094 AM_SCAN_CreatePara_t para;
1095 AM_DMX_OpenPara_t dmx_para;
1096 AM_SCAN_Handle_t handle = 0;
1097 // Create the scan
1098 memset(&para, 0, sizeof(para));
1099
1100 //strcpy(para.default_text_lang,"eng");//config
1101 //strcpy(para.text_langs, "local eng zho chi chs first");//config
1102 para.fend_dev_id = 0;//default
1103 para.mode = AM_SCAN_MODE_DTV_ATV;//DTV
1104 para.atv_para.mode = AM_SCAN_ATVMODE_NONE;
1105 para.dtv_para.mode = AM_SCAN_DTVMODE_ALLBAND;//DTV_MODE_ALLBAND
1106 //para.dtv_para.mode |= (*env)->GetIntField(env, para, doptions);//忽略
1107 para.dtv_para.source = FE_DTMB;//fe_type
1108 para.dtv_para.dmx_dev_id = 0;//default 0
1109 Vector<sp<CTvChannel> > vcp;
1110 //CTvDatabase::getChannelParaList("/data/tv_default.xml", vcp);//channel list from xml or db
1111 CTvRegion::getChannelListByName("CHINA,Default DTMB ALL", vcp);
1112
1113 int size = vcp.size();
1114 LOGD("channel list size = %d", size);
1115 //showboz
1116 if(size == 0) {
1117 CTvDatabase::GetTvDb()->importXmlToDB("/etc/tv_default.xml");
1118 CTvRegion::getChannelListByName("CHINA,Default DTMB ALL", vcp);
1119 size = vcp.size();
1120 }
1121
1122 if(!(para.dtv_para.fe_paras = static_cast<AM_FENDCTRL_DVBFrontendParameters_t *>(calloc(size, sizeof(AM_FENDCTRL_DVBFrontendParameters_t)))))
1123 return -1;
1124
1125 //memset(pfp, 0, size * sizeof(AM_FENDCTRL_DVBFrontendParameters_t));
1126
1127 for (int i = 0; i < size; i++) {
1128 para.dtv_para.fe_paras[i].m_type = 5;//MODE_DTMB
1129 para.dtv_para.fe_paras[i].dtmb.para.frequency = vcp[i]->getFrequency();
1130 para.dtv_para.fe_paras[i].dtmb.para.inversion = INVERSION_OFF;
1131 para.dtv_para.fe_paras[i].dtmb.para.u.ofdm.bandwidth = (fe_bandwidth_t)(vcp[i]->getBandwidth());
1132 }
1133 //allband
1134 para.dtv_para.fe_cnt = size;
1135
1136 para.dtv_para.resort_all = AM_FALSE;
1137 para.dtv_para.sort_method = AM_SCAN_SORT_BY_FREQ_SRV_ID;
1138 para.store_cb = dtv_scan_store;
1139
1140 memset(&dmx_para, 0, sizeof(dmx_para));
1141 AM_DMX_Open(para.dtv_para.dmx_dev_id, &dmx_para);
1142
1143 if ((para.dtv_para.mode & 0x07) != AM_SCAN_DTVMODE_NONE) {
1144 AM_FEND_SetMode(para.fend_dev_id, para.dtv_para.source);
1145 tv_scan_reconnect_dmx_to_fend(para.dtv_para.dmx_dev_id, para.fend_dev_id);
1146 }
1147
1148 // prog->dmx_id = para.dtv_para.dmx_dev_id;
1149 // prog->fend_id = para.fend_dev_id;
1150 // prog->mode = para.dtv_para.mode;
1151 // Start Scan
1152 if (AM_SCAN_Create(&para, &handle) != AM_SUCCESS) {
1153 LOGD("SCAN CREATE fail");
1154 handle = NULL;
1155 } else {
1156 mScanHandle = handle;
1157 AM_SCAN_SetUserData(handle, (void *)this);
1158 //注册搜索事件
1159 AM_EVT_Subscribe((long)handle, AM_SCAN_EVT_PROGRESS, tv_scan_evt_callback, NULL);
1160 //注册信号质量通知事件
1161 AM_EVT_Subscribe((long)handle, AM_SCAN_EVT_SIGNAL, tv_scan_evt_callback, NULL);
1162 if (AM_SCAN_Start(handle) != AM_SUCCESS) {
1163 AM_SCAN_Destroy(handle, AM_FALSE);
1164 AM_EVT_Unsubscribe((long)handle, AM_SCAN_EVT_PROGRESS, tv_scan_evt_callback, NULL);
1165 AM_EVT_Unsubscribe((long)handle, AM_SCAN_EVT_SIGNAL, tv_scan_evt_callback, NULL);
1166 handle = NULL;
1167 }
1168 }
1169 if (para.atv_para.fe_paras != NULL)
1170 free(para.atv_para.fe_paras);
1171 if (para.dtv_para.fe_paras != NULL)
1172 free(para.dtv_para.fe_paras);
1173
1174 if (handle == NULL) {
1175 return -1;
1176 }
1177 mbScanStart = true;//start call ok
1178 } else {
1179 LOGD("scanning and not stop");
1180 }
1181 return 0;
1182}
1183
1184/*int CTvScanner::autoAtscScan(int attennaType,int std)
1185{
1186 stopScan();
1187
1188 if(!mbScanStart) { //not start or stop
1189 AM_SCAN_CreatePara_t para;
1190 AM_DMX_OpenPara_t dmx_para;
1191 int handle = 0,i;
1192 // Create the scan
1193 memset(&para, 0, sizeof(para));
1194
1195 //strcpy(para.default_text_lang,"eng");//config
1196 //strcpy(para.text_langs, "local eng zho chi chs first");//config
1197 para.fend_dev_id = 0;//default
1198 para.mode = AM_SCAN_MODE_ADTV;//DTV
1199 para.atv_para.mode = AM_SCAN_ATVMODE_NONE;
1200
1201
1202 para.atv_para.default_std= std;
1203
1204
1205 para.dtv_para.mode = AM_SCAN_DTVMODE_ALLBAND;//DTV_MODE_ALLBAND
1206 //para.dtv_para.mode |= (*env)->GetIntField(env, para, doptions);//忽略
1207 para.dtv_para.source = FE_ATSC;//fe_type
1208 para.dtv_para.dmx_dev_id = 0;//default 0
1209 para.dtv_para.resort_all = AM_TRUE;
1210 para.dtv_para.clear_source = AM_TRUE;
1211 para.dtv_para.mix_tv_radio = AM_FALSE;
1212 para.dtv_para.sort_method = AM_SCAN_SORT_BY_FREQ_SRV_ID;
1213 para.store_cb = NULL;
1214 //para.dtv_para.attenna = attennaType;//see dvb atsc-cnc
1215
1216 para.dtv_para.standard = AM_SCAN_DTV_STD_ATSC;
1217
1218 mSource = para.dtv_para.source;
1219
1220 Vector<sp<CTvChannel> > vcp;
1221 //CTvDatabase::getChannelParaList("/data/tv_default.xml", vcp);//channel list from xml or db
1222 getAtscChannelPara(attennaType,vcp);
1223 LOGD("ANDESEN test attenna type is %d",attennaType);
1224
1225 int size = vcp.size();
1226 LOGD("channel list size = %d", size);
1227 //showboz
1228 if(size == 0) {
1229 CTvDatabase::GetTvDb()->importXmlToDB("/etc/tv_default.xml");
1230 getAtscChannelPara(attennaType,vcp);
1231 size = vcp.size();
1232 }
1233
1234 if(!(para.dtv_para.fe_paras = static_cast<AM_FENDCTRL_DVBFrontendParameters_t*>(calloc(size, sizeof(AM_FENDCTRL_DVBFrontendParameters_t)))))
1235 return -1;
1236
1237 //memset(pfp, 0, size * sizeof(AM_FENDCTRL_DVBFrontendParameters_t));
1238
1239 for (i = 0; i < size; i++) {
1240 para.dtv_para.fe_paras[i].m_type = 3;//MODE_ATSC
1241 para.dtv_para.fe_paras[i].m_logicalChannelNum = vcp[i]->getLogicalChannelNum();
1242 para.dtv_para.fe_paras[i].atsc.para.frequency = vcp[i]->getFrequency();
1243 para.dtv_para.fe_paras[i].atsc.para.u.vsb.modulation = (fe_modulation_t)(vcp[i]->getModulation());
1244 }
1245 //allband
1246 para.dtv_para.fe_cnt = size;
1247
1248 memset(&dmx_para, 0, sizeof(dmx_para));
1249 AM_DMX_Open(para.dtv_para.dmx_dev_id, &dmx_para);
1250
1251 if ((para.dtv_para.mode&0x07) != AM_SCAN_DTVMODE_NONE) {
1252 AM_FEND_SetMode(para.fend_dev_id, para.dtv_para.source);
1253 tv_scan_reconnect_dmx_to_fend(para.dtv_para.dmx_dev_id, para.fend_dev_id);
1254 }
1255
1256 // prog->dmx_id = para.dtv_para.dmx_dev_id;
1257 // prog->fend_id = para.fend_dev_id;
1258 // prog->mode = para.dtv_para.mode;
1259 // Start Scan
1260 if (AM_SCAN_Create(&para, &handle) != AM_SUCCESS) {
1261 LOGD("SCAN CREATE fail");
1262 handle = 0;
1263 } else {
1264 mScanHandle = handle;
1265 AM_SCAN_SetUserData(handle, (void*)this);
1266 //注册搜索事件
1267 AM_EVT_Unsubscribe(handle, AM_SCAN_EVT_PROGRESS, tv_scan_evt_callback, NULL);
1268 AM_EVT_Subscribe(handle, AM_SCAN_EVT_PROGRESS, tv_scan_evt_callback, NULL);
1269 //注册信号质量通知事件
1270 AM_EVT_Subscribe(handle, AM_SCAN_EVT_SIGNAL, tv_scan_evt_callback, NULL);
1271 if (AM_SCAN_Start(handle) != AM_SUCCESS) {
1272 AM_SCAN_Destroy(handle, AM_FALSE);
1273 AM_EVT_Unsubscribe(handle, AM_SCAN_EVT_PROGRESS, tv_scan_evt_callback, NULL);
1274 AM_EVT_Unsubscribe(handle, AM_SCAN_EVT_SIGNAL, tv_scan_evt_callback, NULL);
1275 handle = 0;
1276 }
1277 }
1278 if (para.atv_para.fe_paras != NULL)
1279 free(para.atv_para.fe_paras);
1280 if (para.dtv_para.fe_paras != NULL)
1281 free(para.dtv_para.fe_paras);
1282
1283 if (handle == 0) {
1284 return -1;
1285 }
1286 mbScanStart = true;//start call ok
1287 } else {
1288 LOGD("scanning and not stop");
1289 }
1290 return 0;
1291}*/
1292
1293
1294int CTvScanner::stopScan()
1295{
1296 LOGD("StopScan mScanHandle=%d", mScanHandle);
1297 //requestExit();
1298 if(mbScanStart) { //if start ok and not stop
1299 int ret = AM_SCAN_Destroy(mScanHandle, AM_TRUE);
1300 AM_EVT_Unsubscribe((long)mScanHandle, AM_SCAN_EVT_PROGRESS, tv_scan_evt_callback, NULL);
1301 AM_EVT_Unsubscribe((long)mScanHandle, AM_SCAN_EVT_SIGNAL, tv_scan_evt_callback, NULL);
1302 AM_SEC_Cache_Reset(0);
1303 //stop loop
1304 LOGD("StopScan , ret=%d", ret);
1305 mbScanStart = false;//stop ok
1306 } else {
1307 LOGD("not start scan or scan stoped");
1308 }
1309 return 0;
1310}
1311
1312void CTvScanner::tv_scan_evt_callback(long dev_no, int event_type, void *param, void *data)
1313{
1314 CTvScanner *pT = NULL;
1315 long long tmpFreq = 0;
1316
1317 LOGD("evt evt:%d", event_type);
1318 AM_SCAN_GetUserData((AM_SCAN_Handle_t)dev_no, (void **)&pT);
1319 if(pT == NULL) {
1320 return;
1321 }
1322 memset(pT->mCurEv.mProgramName, '\0', sizeof(pT->mCurEv.mProgramName));
1323 memset(pT->mCurEv.mMSG, '\0', sizeof(pT->mCurEv.mMSG));
1324 if (event_type == AM_SCAN_EVT_PROGRESS) {
1325 AM_SCAN_Progress_t *evt = (AM_SCAN_Progress_t *)param;
1326 switch (evt->evt) {
1327 case AM_SCAN_PROGRESS_SCAN_BEGIN:
1328 pT->mCurEv.mPercent = 0;
1329 break;
1330 case AM_SCAN_PROGRESS_NIT_BEGIN:
1331
1332 break;
1333 case AM_SCAN_PROGRESS_NIT_END:
1334
1335 break;
1336 case AM_SCAN_PROGRESS_TS_BEGIN: {
1337 AM_SCAN_TSProgress_t *tp = (AM_SCAN_TSProgress_t *)evt->data;
1338 if (tp == NULL)
1339 break;
1340 pT->mCurEv.mChannelNumber = tp->index;
1341 pT->mCurEv.mMode = tp->fend_para.m_type;
1342 pT->mCurEv.mFrequency = ((struct dvb_frontend_parameters *)(&tp->fend_para))->frequency;
1343 pT->mCurEv.mSymbolRate = tp->fend_para.cable.para.u.qam.symbol_rate;
1344 pT->mCurEv.mModulation = tp->fend_para.cable.para.u.qam.modulation;
1345 pT->mCurEv.mBandwidth = tp->fend_para.terrestrial.para.u.ofdm.bandwidth;
1346 pT->mCurEv.mOfdm_mode = tp->fend_para.terrestrial.para.u.ofdm.ofdm_mode;
1347 pT->mCurEv.mAudio = tp->fend_para.analog.para.u.analog.audmode;
1348 pT->mCurEv.mStandard = tp->fend_para.analog.para.u.analog.std;
1349 pT->mCurEv.mSat_polarisation = tp->fend_para.sat.polarisation;
1350 if (pT->mCurEv.mMode == FE_ANALOG) {
1351 if(pT->mSource == FE_ATSC) {
1352 pT->mCurEv.mPercent = (tp->index * 100) / tp->total;
1353 } else {
1354 pT->mCurEv.mPercent = 0;
1355 }
1356 } else {
1357 pT->mCurEv.mPercent = (tp->index * 100) / tp->total;
1358 }
1359
1360 if (pT->mCurEv.mTotalChannelCount == 0)
1361 pT->mCurEv.mTotalChannelCount = tp->total;
1362 if (pT->mCurEv.mPercent >= 100)
1363 pT->mCurEv.mPercent = 99;
1364
1365 pT->mCurEv.mLockedStatus = 0;
1366 pT->mCurEv.mType = ScannerEvent::EVENT_SCAN_PROGRESS;
1367
1368 pT->mpObserver->onEvent(pT->mCurEv);
1369 }
1370 break;
1371 case AM_SCAN_PROGRESS_TS_END: {
1372 /*pT->mCurEv.mLockedStatus = 0;
1373 pT->mCurEv.mType = ScannerEvent::EVENT_SCAN_PROGRESS;
1374 pT->mpObserver->onEvent(pT->mCurEv);*/
1375 }
1376 break;
1377
1378 case AM_SCAN_PROGRESS_PAT_DONE: /*{
1379 if(pT->mCurEv.mTotalChannelCount == 1) {
1380 pT->mCurEv.mType = ScannerEvent::EVENT_SCAN_PROGRESS;
1381 pT->mpObserver->onEvent(pT->mCurEv);
1382 }
1383 }*/
1384 break;
1385 case AM_SCAN_PROGRESS_SDT_DONE: /*{
1386 dvbpsi_sdt_t *sdts = (dvbpsi_sdt_t *)evt->data;
1387 dvbpsi_sdt_t *sdt;
1388
1389 if (pT->mCurEv.mTotalChannelCount == 1) {
1390 pT->mCurEv.mPercent += 25;
1391 if (pT->mCurEv.mPercent >= 100)
1392 pT->mCurEv.mPercent = 99;
1393 pT->mCurEv.mType = ScannerEvent::EVENT_SCAN_PROGRESS;
1394
1395 pT->mpObserver->onEvent(pT->mCurEv);
1396 }
1397 }*/
1398 break;
1399 case AM_SCAN_PROGRESS_CAT_DONE: /*{
1400 dvbpsi_cat_t *cat = (dvbpsi_cat_t *)evt->data;
1401 if (pT->mCurEv.mTotalChannelCount == 1) {
1402 pT->mCurEv.mPercent += 25;
1403 if (pT->mCurEv.mPercent >= 100)
1404 pT->mCurEv.mPercent = 99;
1405
1406 pT->mCurEv.mType = ScannerEvent::EVENT_SCAN_PROGRESS;
1407
1408 pT->mpObserver->onEvent(pT->mCurEv);
1409 }
1410 }*/
1411 break;
1412 case AM_SCAN_PROGRESS_PMT_DONE: /*{
1413 dvbpsi_pmt_t *pmt = (dvbpsi_pmt_t *)evt->data;
1414 if (pT->mCurEv.mTotalChannelCount == 1) {
1415 pT->mCurEv.mPercent += 25;
1416 if (pT->mCurEv.mPercent >= 100)
1417 pT->mCurEv.mPercent = 99;
1418
1419 pT->mCurEv.mType = ScannerEvent::EVENT_SCAN_PROGRESS;
1420 pT->mpObserver->onEvent(pT->mCurEv);
1421 }
1422 }*/
1423 break;
1424 case AM_SCAN_PROGRESS_MGT_DONE: {
1425 mgt_section_info_t *mgt = (mgt_section_info_t *)evt->data;
1426
1427 if (pT->mCurEv.mTotalChannelCount == 1) {
1428 pT->mCurEv.mPercent += 10;
1429 if (pT->mCurEv.mPercent >= 100)
1430 pT->mCurEv.mPercent = 99;
1431
1432 pT->mCurEv.mType = ScannerEvent::EVENT_SCAN_PROGRESS;
1433
1434 pT->mpObserver->onEvent(pT->mCurEv);
1435 }
1436 }
1437 break;
1438 case AM_SCAN_PROGRESS_VCT_DONE: {
1439 /*ATSC TVCT*/
1440 if (pT->mCurEv.mTotalChannelCount == 1) {
1441 pT->mCurEv.mPercent += 30;
1442 if (pT->mCurEv.mPercent >= 100)
1443 pT->mCurEv.mPercent = 99;
1444 pT->mCurEv.mType = ScannerEvent::EVENT_SCAN_PROGRESS;
1445
1446 pT->mpObserver->onEvent(pT->mCurEv);
1447 }
1448 }
1449 break;
1450 case AM_SCAN_PROGRESS_NEW_PROGRAM: {
1451 /* Notify the new searched programs */
1452 AM_SCAN_ProgramProgress_t *pp = (AM_SCAN_ProgramProgress_t *)evt->data;
1453 if (pp != NULL) {
1454 pT->mCurEv.mprogramType = pp->service_type;
1455 snprintf(pT->mCurEv.mProgramName, sizeof(pT->mCurEv.mProgramName), "%s", pp->name);
1456
1457 pT->mCurEv.mType = ScannerEvent::EVENT_SCAN_PROGRESS;
1458
1459 pT->mpObserver->onEvent(pT->mCurEv);
1460 }
1461 }
1462 break;
1463 case AM_SCAN_PROGRESS_BLIND_SCAN: {
1464 AM_SCAN_DTVBlindScanProgress_t *bs_prog = (AM_SCAN_DTVBlindScanProgress_t *)evt->data;
1465
1466 if (bs_prog) {
1467 pT->mCurEv.mPercent = bs_prog->progress;
1468
1469 snprintf(pT->mCurEv.mMSG, sizeof(pT->mCurEv.mMSG), "%s/%s %dMHz",
1470 bs_prog->polar == AM_FEND_POLARISATION_H ? "H" : "V",
1471 bs_prog->lo == AM_FEND_LOCALOSCILLATORFREQ_L ? "L-LOF" : "H-LOF",
1472 bs_prog->freq / 1000);
1473
1474 pT->mCurEv.mType = ScannerEvent::EVENT_BLINDSCAN_PROGRESS;
1475
1476 pT->mpObserver->onEvent(pT->mCurEv);
1477
1478 if (bs_prog->new_tp_cnt > 0) {
1479 int i = 0;
1480 for (i = 0; i < bs_prog->new_tp_cnt; i++) {
1481 LOGD("====New tp: %dkS/s %d====", bs_prog->new_tps[i].frequency,
1482 bs_prog->new_tps[i].u.qpsk.symbol_rate);
1483
1484 pT->mCurEv.mFrequency = bs_prog->new_tps[i].frequency;
1485 pT->mCurEv.mSymbolRate = bs_prog->new_tps[i].u.qpsk.symbol_rate;
1486 pT->mCurEv.mSat_polarisation = bs_prog->polar;
1487
1488 pT->mCurEv.mType = ScannerEvent::EVENT_BLINDSCAN_NEWCHANNEL;
1489
1490 pT->mpObserver->onEvent(pT->mCurEv);
1491 }
1492 }
1493 if (bs_prog->progress >= 100) {
1494
1495 pT->mCurEv.mType = ScannerEvent::EVENT_BLINDSCAN_END;
1496
1497 pT->mpObserver->onEvent(pT->mCurEv);
1498
1499 pT->mCurEv.mPercent = 0;
1500 }
1501 }
1502 }
1503 break;
1504 case AM_SCAN_PROGRESS_STORE_BEGIN: {
1505 pT->mCurEv.mType = ScannerEvent::EVENT_STORE_BEGIN;
1506 pT->mCurEv.mLockedStatus = 0;
1507 if(pT->mpObserver != NULL)
1508 pT->mpObserver->onEvent(pT->mCurEv);
1509 }
1510 break;
1511 case AM_SCAN_PROGRESS_STORE_END: {
1512 pT->mCurEv.mLockedStatus = 0;
1513 pT->mCurEv.mType = ScannerEvent::EVENT_STORE_END;
1514 pT->mpObserver->onEvent(pT->mCurEv);
1515 }
1516 break;
1517 case AM_SCAN_PROGRESS_SCAN_END: {
1518 pT->mCurEv.mPercent = 100;
1519 pT->mCurEv.mLockedStatus = 0;
1520 pT->mCurEv.mType = ScannerEvent::EVENT_SCAN_END;
1521 pT->mpObserver->onEvent(pT->mCurEv);
1522 }
1523 break;
1524 case AM_SCAN_PROGRESS_ATV_TUNING: {
1525 pT->mCurEv.mFrequency = (int)evt->data;
1526 pT->mCurEv.mLockedStatus = 0;
1527 tmpFreq = (pT->mCurEv.mFrequency - pT->mCurScanStartFreq) / 1000000;
1528 pT->mCurEv.mPercent = tmpFreq * 100UL / ((pT->mCurScanEndFreq - pT->mCurScanStartFreq) / 1000000);
1529 pT->mCurEv.mType = ScannerEvent::EVENT_SCAN_PROGRESS;
1530 pT->mpObserver->onEvent(pT->mCurEv);
1531 }
1532 break;
1533
1534 default:
1535 break;
1536 }
1537 } else if (event_type == AM_SCAN_EVT_SIGNAL) {
1538 AM_SCAN_DTVSignalInfo_t *evt = (AM_SCAN_DTVSignalInfo_t *)param;
1539 pT->mCurEv.mprogramType = 0xff;
1540 pT->mCurEv.mFrequency = (int)evt->frequency;
1541 pT->mCurEv.mLockedStatus = (evt->locked ? 1 : 0);
1542
1543 pT->mCurEv.mType = ScannerEvent::EVENT_SCAN_PROGRESS;
1544 if(pT->mCurEv.mMode != FE_ANALOG && evt->locked) {
1545 pT->mCurEv.mStrength = evt->strength;
1546 pT->mCurEv.mSnr = evt->snr;
1547 } else {
1548 pT->mCurEv.mStrength = 0;
1549 pT->mCurEv.mSnr = 0;
1550 }
1551
1552 if (pT->mCurEv.mMode == FE_ANALOG)
1553 pT->mpObserver->onEvent(pT->mCurEv);
1554 }
1555}
1556
1557void CTvScanner::tv_scan_reconnect_dmx_to_fend(int dmx_no, int fend_no)
1558{
1559 AM_DMX_Source_t src;
1560
1561 if (AM_FEND_GetTSSource(fend_no, &src) == AM_SUCCESS) {
1562 LOGD("Set demux%d source to %d", dmx_no, src);
1563 AM_DMX_SetSource(dmx_no, src);
1564 } else {
1565 LOGD("Cannot get frontend ts source!!");
1566 }
1567}
1568
1569int CTvScanner::getAtscChannelPara(int attennaType, Vector<sp<CTvChannel> > &vcp)
1570{
1571 switch(attennaType) { //region name should be remove to config file and read here
1572 case 1:
1573 CTvRegion::getChannelListByName("U.S.,ATSC Air", vcp);
1574 break;
1575 case 2:
1576 CTvRegion::getChannelListByName("U.S.,ATSC Cable Standard", vcp);
1577 break;
1578 case 3:
1579 CTvRegion::getChannelListByName("U.S.,ATSC Cable IRC", vcp);
1580 break;
1581 case 4:
1582 CTvRegion::getChannelListByName("U.S.,ATSC Cable HRC", vcp);
1583 break;
1584 default:
1585 return -1;
1586 }
1587
1588 return 0;
1589}
1590
1591
generated by cgit at 2024-05-14 09:59:49 (GMT)