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