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