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