?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add DreX fourCCs
[vlc.git] / modules / access / dvb / scan.c
blob5f75e58a81a9b5834cba6407b8e61550f8f8a5bd
1 /*****************************************************************************
2 * scan.c: DVB scanner helpers
3 *****************************************************************************
4 * Copyright (C) 2008,2010 the VideoLAN team
5 *
6 * Authors: Laurent Aimar <fenrir@videolan.org>
7 * David Kaplan <david@2of1.org>
8 * Ilkka Ollakka <ileoo@videolan.org>
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23 *****************************************************************************/
24
25 /*****************************************************************************
26 * Preamble
27 *****************************************************************************/
28 #ifdef HAVE_CONFIG_H
29 # include "config.h"
30 #endif
31
32 #include <vlc_common.h>
33 #include <vlc_block.h>
34 #include <vlc_dialog.h>
35 #include <vlc_fs.h>
36 #include <vlc_charset.h>
37 #include <vlc_access.h>
38
39 #include <sys/types.h>
40
41 /* Include dvbpsi headers */
42 #include <dvbpsi/dvbpsi.h>
43 #include <dvbpsi/descriptor.h>
44 #include <dvbpsi/pat.h>
45 #include <dvbpsi/pmt.h>
46 #include <dvbpsi/dr.h>
47 #include <dvbpsi/psi.h>
48 #include <dvbpsi/demux.h>
49 #include <dvbpsi/sdt.h>
50 #ifdef _DVBPSI_DR_43_H_
51 # define DVBPSI_USE_NIT 1
52 # include <dvbpsi/nit.h>
53 #endif
54
55 #include "dvb.h"
56 #include "scan.h"
57 #include "../../demux/dvb-text.h"
58
59 typedef enum
60 {
61 SERVICE_UNKNOWN = 0,
62 SERVICE_DIGITAL_RADIO,
63 SERVICE_DIGITAL_TELEVISION,
64 SERVICE_DIGITAL_TELEVISION_AC_SD,
65 SERVICE_DIGITAL_TELEVISION_AC_HD,
66 } scan_service_type_t;
67
68 typedef struct
69 {
70 int i_program; /* program number (service id) */
71 scan_configuration_t cfg;
72 int i_snr;
73
74 scan_service_type_t type;
75 char *psz_name; /* channel name in utf8 or NULL */
76 int i_channel; /* -1 if unknown */
77 bool b_crypted; /* True if potentially crypted */
78
79 int i_network_id;
80
81 int i_nit_version;
82 int i_sdt_version;
83
84 } scan_service_t;
85
86 struct scan_t
87 {
88 vlc_object_t *p_obj;
89 struct dialog_progress_bar_t *p_dialog;
90 int64_t i_index;
91 scan_parameter_t parameter;
92 int64_t i_time_start;
93
94 int i_service;
95 scan_service_t **pp_service;
96 };
97
98 struct scan_session_t
99 {
100 vlc_object_t *p_obj;
101
102 scan_configuration_t cfg;
103 int i_snr;
104
105 dvbpsi_handle pat;
106 dvbpsi_pat_t *p_pat;
107 int i_nit_pid;
108
109 dvbpsi_handle sdt;
110 dvbpsi_sdt_t *p_sdt;
111
112 #ifdef DVBPSI_USE_NIT
113 dvbpsi_handle nit;
114 dvbpsi_nit_t *p_nit;
115 #else
116 # warning NIT is not supported by your libdvbpsi version
117 #endif
118
119 };
120
121 /* */
122 static scan_service_t *scan_service_New( int i_program,
123 const scan_configuration_t *p_cfg )
124 {
125 scan_service_t *p_srv = malloc( sizeof(*p_srv) );
126 if( !p_srv )
127 return NULL;
128
129 p_srv->i_program = i_program;
130 p_srv->cfg = *p_cfg;
131 p_srv->i_snr = -1;
132
133 p_srv->type = SERVICE_UNKNOWN;
134 p_srv->psz_name = NULL;
135 p_srv->i_channel = -1;
136 p_srv->b_crypted = false;
137
138 p_srv->i_network_id = -1;
139 p_srv->i_nit_version = -1;
140 p_srv->i_sdt_version = -1;
141
142 return p_srv;
143 }
144
145 static void scan_service_Delete( scan_service_t *p_srv )
146 {
147 free( p_srv->psz_name );
148 free( p_srv );
149 }
150
151 static uint32_t decode_BCD( uint32_t input )
152 {
153 uint32_t output = 0;
154 for( short index=28; index >= 0 ; index -= 4 )
155 {
156 output *= 10;
157 output += ((input >> index) & 0x0f);
158 };
159 return output;
160 }
161
162 static int scan_service_type( int service_type )
163 {
164 switch( service_type )
165 {
166 case 0x01: return SERVICE_DIGITAL_TELEVISION; break;
167 case 0x02: return SERVICE_DIGITAL_RADIO; break;
168 case 0x16: return SERVICE_DIGITAL_TELEVISION_AC_SD; break;
169 case 0x19: return SERVICE_DIGITAL_TELEVISION_AC_HD; break;
170 default: return SERVICE_UNKNOWN; break;
171 }
172 }
173
174 /* */
175 scan_t *scan_New( vlc_object_t *p_obj, const scan_parameter_t *p_parameter )
176 {
177 if( p_parameter->type == SCAN_DVB_T )
178 {
179 msg_Dbg( p_obj, "DVB-T scanning:" );
180 msg_Dbg( p_obj, " - frequency [%d, %d]",
181 p_parameter->frequency.i_min, p_parameter->frequency.i_max );
182 msg_Dbg( p_obj, " - bandwidth [%d,%d]",
183 p_parameter->bandwidth.i_min, p_parameter->bandwidth.i_max );
184 msg_Dbg( p_obj, " - exhaustive mode %s", p_parameter->b_exhaustive ? "on" : "off" );
185 }
186 else if( p_parameter->type == SCAN_DVB_C )
187 {
188 msg_Dbg( p_obj, "DVB-C scanning:" );
189 msg_Dbg( p_obj, " - frequency [%d, %d]",
190 p_parameter->frequency.i_min, p_parameter->frequency.i_max );
191 msg_Dbg( p_obj, " - bandwidth [%d,%d]",
192 p_parameter->bandwidth.i_min, p_parameter->bandwidth.i_max );
193 msg_Dbg( p_obj, " - exhaustive mode %s", p_parameter->b_exhaustive ? "on" : "off" );
194 msg_Dbg( p_obj, " - scannin modulations %s", p_parameter->b_modulation_set ? "off" : "on" );
195 }
196 else if( p_parameter->type == SCAN_DVB_S )
197 {
198 msg_Dbg( p_obj, "DVB-S scanning:" );
199 msg_Dbg( p_obj, " - satellite [%s]", p_parameter->sat_info.psz_name );
200 }
201 else
202 {
203 return NULL;
204 }
205 msg_Dbg( p_obj, " - use NIT %s", p_parameter->b_use_nit ? "on" : "off" );
206 msg_Dbg( p_obj, " - FTA only %s", p_parameter->b_free_only ? "on" : "off" );
207
208 scan_t *p_scan = malloc( sizeof( *p_scan ) );
209 if( unlikely(p_scan == NULL) )
210 return NULL;
211
212 p_scan->p_obj = VLC_OBJECT(p_obj);
213 p_scan->i_index = 0;
214 p_scan->p_dialog = NULL;
215 TAB_INIT( p_scan->i_service, p_scan->pp_service );
216 p_scan->parameter = *p_parameter;
217 p_scan->i_time_start = mdate();
218
219 return p_scan;
220 }
221
222 void scan_Destroy( scan_t *p_scan )
223 {
224 if( p_scan->p_dialog != NULL )
225 dialog_ProgressDestroy( p_scan->p_dialog );
226
227 for( int i = 0; i < p_scan->i_service; i++ )
228 scan_service_Delete( p_scan->pp_service[i] );
229 TAB_CLEAN( p_scan->i_service, p_scan->pp_service );
230 free( p_scan );
231 }
232
233 static int ScanDvbSNextFast( scan_t *p_scan, scan_configuration_t *p_cfg, double *pf_pos )
234 {
235 msg_Dbg( p_scan->p_obj, "Scan index %"PRId64, p_scan->i_index );
236
237 int *pi_count = &p_scan->parameter.sat_info.i_count;
238
239 if( !p_scan->parameter.sat_info.psz_name )
240 {
241 msg_Err( p_scan->p_obj, "no satellite selected" );
242 return VLC_EGENERIC;
243 }
244
245 /* if there are no transponders in mem, laod from config file */
246 if( !*pi_count )
247 {
248 DIR *p_dir;
249
250 char *psz_dir = NULL;
251 char *data_dir = config_GetDataDir( p_scan->p_obj );
252
253 if( asprintf( &psz_dir, "%s" DIR_SEP "dvb" DIR_SEP "dvb-s", data_dir ) == -1 )
254 psz_dir = NULL;
255 free( data_dir );
256
257 if( !psz_dir )
258 {
259 free( p_scan->parameter.sat_info.psz_name );
260 return VLC_EGENERIC;
261 }
262
263 /* open config directory */
264 if( !( p_dir = vlc_opendir( psz_dir ) ) )
265 {
266 msg_Err( p_scan->p_obj, "could not open satellite info directory (%s)", psz_dir );
267 free( p_scan->parameter.sat_info.psz_name );
268 return VLC_EGENERIC;
269 }
270
271 /* find the requested file in the directory */
272 for( ; ; ) {
273 char *psz_filename;
274
275 if( ! (psz_filename = vlc_readdir( p_dir ) ) )
276 break;
277
278 if( !strncmp( p_scan->parameter.sat_info.psz_name, psz_filename, 20 ) )
279 {
280 if( asprintf( &p_scan->parameter.sat_info.psz_path, "%s" DIR_SEP "%s", psz_dir, psz_filename ) == -1 )
281 p_scan->parameter.sat_info.psz_path = NULL;
282
283 free( psz_filename );
284 break;
285 }
286 }
287
288 closedir( p_dir );
289
290 if( !p_scan->parameter.sat_info.psz_path )
291 {
292 msg_Err( p_scan->p_obj, "could not find satellite config (%s)", p_scan->parameter.sat_info.psz_name );
293 free( p_scan->parameter.sat_info.psz_name );
294 return VLC_EGENERIC;
295 }
296
297 msg_Dbg( p_scan->p_obj, "using satellite config file (%s)", p_scan->parameter.sat_info.psz_path );
298
299 FILE *f = vlc_fopen( p_scan->parameter.sat_info.psz_path, "r" );
300
301 /* parse file */
302 if( f )
303 {
304 scan_dvbs_transponder_t *p_transponders = malloc( sizeof( scan_dvbs_transponder_t ) );
305 char type;
306 char psz_fec[3];
307
308 int res;
309 do
310 {
311 if ( ( res = fscanf( f, "%c %d %c %d %s\n",
312 &type,
313 &p_transponders[*pi_count].i_frequency,
314 &p_transponders[*pi_count].c_polarization,
315 &p_transponders[*pi_count].i_symbol_rate,
316 psz_fec ) ) != 5 )
317 {
318 msg_Dbg( p_scan->p_obj, "error parsing transponder from file" );
319 continue;
320 }
321
322 /* decode fec */
323 char psz_fec_list[] = "1/22/33/44/55/66/77/88/9";
324 char *p_fec = strstr( psz_fec_list, psz_fec );
325 if ( !p_fec )
326 p_transponders[*pi_count].i_fec = 9; /* FEC_AUTO */
327 else
328 p_transponders[*pi_count].i_fec = 1 + ( ( p_fec-psz_fec_list ) / 3 );
329
330 (*pi_count)++;
331
332 p_transponders = realloc(p_transponders, ( *pi_count + 1 ) * sizeof( scan_dvbs_transponder_t ) );
333 } while (res != EOF);
334
335 msg_Dbg( p_scan->p_obj, "parsed %d transponders from config", *pi_count);
336
337 fclose( f );
338 p_scan->parameter.sat_info.p_transponders = p_transponders;
339 }
340 else
341 {
342 msg_Err( p_scan->p_obj, "failed to open satellite file (%s)", p_scan->parameter.sat_info.psz_path );
343 free( p_scan->parameter.sat_info.psz_name );
344 free( p_scan->parameter.sat_info.psz_path );
345 return VLC_EGENERIC;
346 }
347 free( p_scan->parameter.sat_info.psz_name );
348 free( p_scan->parameter.sat_info.psz_path );
349 }
350
351 if( p_scan->i_index < *pi_count )
352 {
353 /* setup params for scan */
354 p_cfg->i_symbol_rate = p_scan->parameter.sat_info.p_transponders[p_scan->i_index].i_symbol_rate / 1000;
355 p_cfg->i_frequency = p_scan->parameter.sat_info.p_transponders[p_scan->i_index].i_frequency;
356 p_cfg->i_fec = p_scan->parameter.sat_info.p_transponders[p_scan->i_index].i_fec;
357 p_cfg->c_polarization = p_scan->parameter.sat_info.p_transponders[p_scan->i_index].c_polarization;
358
359 msg_Dbg( p_scan->p_obj,
360 "transponder [%"PRId64"/%d]: frequency=%d, symbolrate=%d, fec=%d, polarization=%c",
361 p_scan->i_index + 1,
362 *pi_count,
363 p_cfg->i_frequency,
364 p_cfg->i_symbol_rate,
365 p_cfg->i_fec,
366 p_cfg->c_polarization );
367
368 *pf_pos = (double)p_scan->i_index / *pi_count;
369
370 return VLC_SUCCESS;
371 }
372
373 if( p_scan->parameter.sat_info.p_transponders )
374 {
375 free( p_scan->parameter.sat_info.p_transponders );
376 p_scan->parameter.sat_info.p_transponders = NULL;
377 }
378
379 return VLC_EGENERIC;
380 }
381
382 static int ScanDvbCNextFast( scan_t *p_scan, scan_configuration_t *p_cfg, double *pf_pos )
383 {
384 msg_Dbg( p_scan->p_obj, "Scan index %"PRId64, p_scan->i_index );
385 /* Values taken from dvb-scan utils frequency-files, sorted by how
386 * often they appear. This hopefully speeds up finding services. */
387 static const unsigned int frequencies[] = { 41000, 39400, 40200,
388 38600, 41800, 36200, 44200, 43400, 37000, 35400, 42600, 37800,
389 34600, 45800, 45000, 46600, 32200, 51400, 49000, 33800, 31400,
390 30600, 47400, 71400, 69000, 68200, 58600, 56200, 54600, 49800,
391 48200, 33000, 79400, 72200, 69800, 67400, 66600, 65000, 64200,
392 61000, 55400, 53000, 52200, 50600, 29800, 16200, 15400, 11300,
393 78600, 77000, 76200, 75400, 74600, 73800, 73000, 70600, 57800,
394 57000, 53800, 12100, 81000, 77800, 65800, 63400, 61800, 29000,
395 17000, 85000, 84200, 83400, 81800, 80200, 59400, 36900, 28300,
396 26600, 25800, 25000, 24200, 23400, 85800, 74800, 73200, 72800,
397 72400, 72000, 66000, 65600, 60200, 42500, 41700, 40900, 40100,
398 39300, 38500, 37775, 37700, 37200, 36100, 35600, 35300, 34700,
399 34500, 33900, 33700, 32900, 32300, 32100, 31500, 31300, 30500,
400 29900, 29700, 29100, 28950, 28200, 28000, 27500, 27400, 27200,
401 26700, 25900, 25500, 25100, 24300, 24100, 23500, 23200, 22700,
402 22600, 21900, 21800, 21100, 20300, 19500, 18700, 17900, 17100,
403 16300, 15500, 14700, 14600, 14500, 14300, 13900, 13700, 13100,
404 12900, 12500, 12300
405 };
406 enum { num_frequencies = (sizeof(frequencies)/sizeof(*frequencies)) };
407
408 if( p_scan->i_index < num_frequencies )
409 {
410 p_cfg->i_frequency = 10000 * ( frequencies[ p_scan->i_index ] );
411 *pf_pos = (double)(p_scan->i_index * 1000 +
412 p_scan->parameter.i_symbolrate * 100 +
413 (256 - (p_scan->parameter.i_modulation >> 4)) )
414 / (num_frequencies * 1000 + 900 + 16);
415 return VLC_SUCCESS;
416 }
417 return VLC_EGENERIC;
418 }
419
420 static int ScanDvbNextExhaustive( scan_t *p_scan, scan_configuration_t *p_cfg, double *pf_pos )
421 {
422 if( p_scan->i_index > p_scan->parameter.frequency.i_count * p_scan->parameter.bandwidth.i_count )
423 return VLC_EGENERIC;
424
425 const int i_bi = p_scan->i_index % p_scan->parameter.bandwidth.i_count;
426 const int i_fi = p_scan->i_index / p_scan->parameter.bandwidth.i_count;
427
428 p_cfg->i_frequency = p_scan->parameter.frequency.i_min + i_fi * p_scan->parameter.frequency.i_step;
429 p_cfg->i_bandwidth = p_scan->parameter.bandwidth.i_min + i_bi * p_scan->parameter.bandwidth.i_step;
430
431 *pf_pos = (double)p_scan->i_index / p_scan->parameter.frequency.i_count;
432 return VLC_SUCCESS;
433 }
434
435 static int ScanDvbTNextFast( scan_t *p_scan, scan_configuration_t *p_cfg, double *pf_pos )
436 {
437 static const int i_band_count = 2;
438 static const struct
439 {
440 const char *psz_name;
441 int i_min;
442 int i_max;
443 }
444 band[2] =
445 {
446 { "VHF", 174, 230 },
447 { "UHF", 470, 862 },
448 };
449 const int i_offset_count = 5;
450 const int i_mhz = 1000000;
451
452 /* We will probe the whole band divided in all bandwidth possibility trying
453 * i_offset_count offset around the position
454 */
455 for( ;; p_scan->i_index++ )
456 {
457
458 const int i_bi = p_scan->i_index % p_scan->parameter.bandwidth.i_count;
459 const int i_oi = (p_scan->i_index / p_scan->parameter.bandwidth.i_count) % i_offset_count;
460 const int i_fi = (p_scan->i_index / p_scan->parameter.bandwidth.i_count) / i_offset_count;
461
462 const int i_bandwidth = p_scan->parameter.bandwidth.i_min + i_bi * p_scan->parameter.bandwidth.i_step;
463 int i;
464
465 for( i = 0; i < i_band_count; i++ )
466 {
467 if( i_fi >= band[i].i_min && i_fi <= band[i].i_max )
468 break;
469 }
470 if( i >=i_band_count )
471 {
472 if( i_fi > band[i_band_count-1].i_max )
473 return VLC_EGENERIC;
474 continue;
475 }
476
477 const int i_frequency_min = band[i].i_min*i_mhz + i_bandwidth*i_mhz/2;
478 const int i_frequency_base = i_fi*i_mhz;
479
480 if( i_frequency_base >= i_frequency_min && ( i_frequency_base - i_frequency_min ) % ( i_bandwidth*i_mhz ) == 0 )
481 {
482 const int i_frequency = i_frequency_base + ( i_oi - i_offset_count/2 ) * p_scan->parameter.frequency.i_step;
483
484 if( i_frequency < p_scan->parameter.frequency.i_min ||
485 i_frequency > p_scan->parameter.frequency.i_max )
486 continue;
487
488 p_cfg->i_frequency = i_frequency;
489 p_cfg->i_bandwidth = i_bandwidth;
490
491 int i_current = 0, i_total = 0;
492 for( int i = 0; i < i_band_count; i++ )
493 {
494 const int i_frag = band[i].i_max-band[i].i_min;
495
496 if( i_fi >= band[i].i_min )
497 i_current += __MIN( i_fi - band[i].i_min, i_frag );
498 i_total += i_frag;
499 }
500
501 *pf_pos = (double)( i_current + (double)i_oi / i_offset_count ) / i_total;
502 return VLC_SUCCESS;
503 }
504 }
505 }
506
507 static int ScanDvbCNext( scan_t *p_scan, scan_configuration_t *p_cfg, double *pf_pos )
508 {
509 bool b_servicefound = false;
510 #ifdef _DVBPSI_DR_44_H_
511 /* We iterate frequencies/modulations/symbolrates until we get first hit and find NIT,
512 from that we fill pp_service with configurations and after that we iterate over
513 pp_services for all that doesn't have name yet (tune to that cfg and get SDT and name
514 for channel).
515 */
516 for( int i = 0; i < p_scan->i_service; i++ )
517 {
518 /* We found radio/tv config that doesn't have a name,
519 lets tune to that mux
520 */
521 if( !p_scan->pp_service[i]->psz_name && ( p_scan->pp_service[i]->type != SERVICE_UNKNOWN ) )
522 {
523 p_cfg->i_frequency = p_scan->pp_service[i]->cfg.i_frequency;
524 p_cfg->i_symbolrate = p_scan->pp_service[i]->cfg.i_symbolrate;
525 p_cfg->i_modulation = p_scan->pp_service[i]->cfg.i_modulation;
526 p_scan->i_index = i+1;
527 msg_Dbg( p_scan->p_obj, "iterating to freq: %u, symbolrate %u, modulation %u index %d/%d",
528 p_cfg->i_frequency, p_cfg->i_symbolrate, p_cfg->i_modulation, p_scan->i_index, p_scan->i_service );
529 *pf_pos = (double)i/p_scan->i_service;
530 return VLC_SUCCESS;
531 }
532 }
533 /* We should have iterated all channels by now */
534 if( p_scan->i_service )
535 return VLC_EGENERIC;
536 #else
537 /* fallback to old, so when we get one channe, use that
538 symbolrate/modulation until bitter end
539 */
540 for( int i=0; i < p_scan->i_service; i++ )
541 {
542 b_servicefound = p_scan->pp_service[i]->type != SERVICE_UNKNOWN;
543 if( b_servicefound )
544 break;
545 }
546 #endif
547
548 if( !b_servicefound )
549 {
550 bool b_rotate=true;
551 if( !p_scan->parameter.b_modulation_set )
552 {
553 p_scan->parameter.i_modulation = (p_scan->parameter.i_modulation >> 1 );
554 /* if we iterated all modulations, move on */
555 /* dvb utils dvb-c channels files seems to have only
556 QAM64...QAM256, so lets just iterate over those */
557 if( p_scan->parameter.i_modulation < 64)
558 {
559 p_scan->parameter.i_modulation = 256;
560 } else {
561 b_rotate=false;
562 }
563 msg_Dbg( p_scan->p_obj, "modulation %d ", p_scan->parameter.i_modulation);
564 }
565 if( !p_scan->parameter.b_symbolrate_set )
566 {
567 /* symbol rates from dvb-tools dvb-c files */
568 static const unsigned short symbolrates[] = {
569 6900, 6875, 6950
570 /* With DR_44 we can cover other symbolrates from NIT-info
571 as all channel-seed files have atleast one channel that
572 has one of these symbolrate
573 */
574 #ifndef _DVBPSI_DR_44_H_
575 ,7000, 3450, 6111,
576 6428, 6952, 5900, 5000
577 #endif
578 };
579
580 enum { num_symbols = (sizeof(symbolrates)/sizeof(*symbolrates)) };
581
582 /* if we rotated modulations, rotate symbolrate */
583 if( b_rotate )
584 p_scan->parameter.i_symbolrate = (++p_scan->parameter.i_symbolrate % num_symbols );
585 p_cfg->i_symbolrate = 1000 * (symbolrates[ p_scan->parameter.i_symbolrate ] );
586 msg_Dbg( p_scan->p_obj, "symbolrate %d", p_cfg->i_symbolrate );
587 if( p_scan->parameter.i_symbolrate )
588 b_rotate=false;
589 }
590 if( !b_rotate && p_scan->i_index )
591 p_scan->i_index--;
592 }
593 p_cfg->i_modulation = p_scan->parameter.i_modulation;
594 if( !p_cfg->i_symbolrate )
595 p_cfg->i_symbolrate = var_GetInteger( p_scan->p_obj, "dvb-srate" );
596 if( !p_cfg->i_modulation )
597 p_cfg->i_modulation = var_GetInteger( p_scan->p_obj, "dvb-modulation" );
598
599 if( p_scan->parameter.b_exhaustive )
600 return ScanDvbNextExhaustive( p_scan, p_cfg, pf_pos );
601 else
602 return ScanDvbCNextFast( p_scan, p_cfg, pf_pos );
603 }
604
605 static int ScanDvbTNext( scan_t *p_scan, scan_configuration_t *p_cfg, double *pf_pos )
606 {
607 if( p_scan->parameter.b_exhaustive )
608 return ScanDvbNextExhaustive( p_scan, p_cfg, pf_pos );
609 else
610 return ScanDvbTNextFast( p_scan, p_cfg, pf_pos );
611 }
612
613 static int ScanDvbSNext( scan_t *p_scan, scan_configuration_t *p_cfg, double *pf_pos )
614 {
615 if( p_scan->parameter.b_exhaustive )
616 msg_Dbg( p_scan->p_obj, "no exhaustive svb-d scan mode" );
617
618 return ScanDvbSNextFast( p_scan, p_cfg, pf_pos );
619 }
620
621 int scan_Next( scan_t *p_scan, scan_configuration_t *p_cfg )
622 {
623 double f_position;
624 int i_ret;
625
626 if( scan_IsCancelled( p_scan ) )
627 return VLC_EGENERIC;
628
629 memset( p_cfg, 0, sizeof(*p_cfg) );
630 switch( p_scan->parameter.type )
631 {
632 case SCAN_DVB_T:
633 i_ret = ScanDvbTNext( p_scan, p_cfg, &f_position );
634 break;
635 case SCAN_DVB_C:
636 i_ret = ScanDvbCNext( p_scan, p_cfg, &f_position );
637 break;
638 case SCAN_DVB_S:
639 i_ret = ScanDvbSNext( p_scan, p_cfg, &f_position );
640 break;
641 default:
642 i_ret = VLC_EGENERIC;
643 break;
644 }
645
646 if( i_ret )
647 return i_ret;
648
649 char *psz_text;
650 int i_service = 0;
651
652 for( int i = 0; i < p_scan->i_service; i++ )
653 {
654 if( p_scan->pp_service[i]->psz_name )
655 i_service++;
656 }
657
658 const mtime_t i_eta = f_position > 0.005 ? (mdate() - p_scan->i_time_start) * ( 1.0 / f_position - 1.0 ) : -1;
659 char psz_eta[MSTRTIME_MAX_SIZE];
660
661 if( asprintf( &psz_text, _("%.1f MHz (%d services)\n~%s remaining"),
662 (double)p_cfg->i_frequency / 1000000, i_service, secstotimestr( psz_eta, i_eta/1000000 ) ) >= 0 )
663 {
664 if( i_eta >= 0 )
665 msg_Info( p_scan->p_obj, "Scan ETA %s | %f", secstotimestr( psz_eta, i_eta/1000000 ), f_position * 100 );
666
667 if( p_scan->p_dialog == NULL )
668 p_scan->p_dialog = dialog_ProgressCreate( p_scan->p_obj, _("Scanning DVB"), psz_text, _("Cancel") );
669 if( p_scan->p_dialog != NULL )
670 dialog_ProgressSet( p_scan->p_dialog, psz_text, f_position );
671 free( psz_text );
672 }
673
674 p_scan->i_index++;
675 return VLC_SUCCESS;
676 }
677
678 bool scan_IsCancelled( scan_t *p_scan )
679 {
680 return p_scan->p_dialog && dialog_ProgressCancelled( p_scan->p_dialog );
681 }
682
683 static scan_service_t *ScanFindService( scan_t *p_scan, int i_service_start, int i_program )
684 {
685 for( int i = i_service_start; i < p_scan->i_service; i++ )
686 {
687 if( p_scan->pp_service[i]->i_program == i_program )
688 return p_scan->pp_service[i];
689 }
690 return NULL;
691 }
692
693 /* FIXME handle properly string (convert to utf8) */
694 static void PATCallBack( scan_session_t *p_session, dvbpsi_pat_t *p_pat )
695 {
696 vlc_object_t *p_obj = p_session->p_obj;
697
698 msg_Dbg( p_obj, "PATCallBack" );
699
700 /* */
701 if( p_session->p_pat && p_session->p_pat->b_current_next )
702 {
703 dvbpsi_DeletePAT( p_session->p_pat );
704 p_session->p_pat = NULL;
705 }
706 if( p_session->p_pat )
707 {
708 dvbpsi_DeletePAT( p_pat );
709 return;
710 }
711
712 dvbpsi_pat_program_t *p_program;
713
714 /* */
715 p_session->p_pat = p_pat;
716
717 /* */
718 msg_Dbg( p_obj, "new PAT ts_id=%d version=%d current_next=%d",
719 p_pat->i_ts_id, p_pat->i_version, p_pat->b_current_next );
720 for( p_program = p_pat->p_first_program; p_program != NULL; p_program = p_program->p_next )
721 {
722 msg_Dbg( p_obj, " * number=%d pid=%d", p_program->i_number, p_program->i_pid );
723 if( p_program->i_number == 0 )
724 p_session->i_nit_pid = p_program->i_pid;
725 }
726 }
727 static void SDTCallBack( scan_session_t *p_session, dvbpsi_sdt_t *p_sdt )
728 {
729 vlc_object_t *p_obj = p_session->p_obj;
730
731 msg_Dbg( p_obj, "SDTCallBack" );
732
733 if( p_session->p_sdt && p_session->p_sdt->b_current_next )
734 {
735 dvbpsi_DeleteSDT( p_session->p_sdt );
736 p_session->p_sdt = NULL;
737 }
738 if( p_session->p_sdt )
739 {
740 dvbpsi_DeleteSDT( p_sdt );
741 return;
742 }
743
744 /* */
745 p_session->p_sdt = p_sdt;
746
747 /* */
748 msg_Dbg( p_obj, "new SDT ts_id=%d version=%d current_next=%d network_id=%d",
749 p_sdt->i_ts_id, p_sdt->i_version, p_sdt->b_current_next,
750 p_sdt->i_network_id );
751
752
753 dvbpsi_sdt_service_t *p_srv;
754 for( p_srv = p_sdt->p_first_service; p_srv; p_srv = p_srv->p_next )
755 {
756 dvbpsi_descriptor_t *p_dr;
757
758 msg_Dbg( p_obj, " * service id=%d eit schedule=%d present=%d running=%d free_ca=%d",
759 p_srv->i_service_id, p_srv->b_eit_schedule,
760 p_srv->b_eit_present, p_srv->i_running_status,
761 p_srv->b_free_ca );
762 for( p_dr = p_srv->p_first_descriptor; p_dr; p_dr = p_dr->p_next )
763 {
764 if( p_dr->i_tag == 0x48 )
765 {
766 dvbpsi_service_dr_t *pD = dvbpsi_DecodeServiceDr( p_dr );
767 char str2[257];
768
769 memcpy( str2, pD->i_service_name, pD->i_service_name_length );
770 str2[pD->i_service_name_length] = '\0';
771
772 msg_Dbg( p_obj, " - type=%d name=%s",
773 pD->i_service_type, str2 );
774 }
775 else
776 {
777 msg_Dbg( p_obj, " * dsc 0x%x", p_dr->i_tag );
778 }
779 }
780 }
781 }
782
783 #ifdef DVBPSI_USE_NIT
784 static void NITCallBack( scan_session_t *p_session, dvbpsi_nit_t *p_nit )
785 {
786 vlc_object_t *p_obj = p_session->p_obj;
787 access_t *p_access = (access_t*)p_obj;
788 access_sys_t *p_sys = p_access->p_sys;
789 scan_t *p_scan = p_sys->scan;
790
791 msg_Dbg( p_obj, "NITCallBack" );
792 msg_Dbg( p_obj, "new NIT network_id=%d version=%d current_next=%d",
793 p_nit->i_network_id, p_nit->i_version, p_nit->b_current_next );
794
795 /* */
796 if( p_session->p_nit && p_session->p_nit->b_current_next )
797 {
798 dvbpsi_DeleteNIT( p_session->p_nit );
799 p_session->p_nit = NULL;
800 }
801 if( p_session->p_nit )
802 {
803 dvbpsi_DeleteNIT( p_nit );
804 return;
805 }
806
807 /* */
808 p_session->p_nit = p_nit;
809
810 dvbpsi_descriptor_t *p_dsc;
811 for( p_dsc = p_nit->p_first_descriptor; p_dsc != NULL; p_dsc = p_dsc->p_next )
812 {
813 if( p_dsc->i_tag == 0x40 )
814 {
815 msg_Dbg( p_obj, " * network name descriptor" );
816 char str1[257];
817
818 memcpy( str1, p_dsc->p_data, p_dsc->i_length );
819 str1[p_dsc->i_length] = '\0';
820 msg_Dbg( p_obj, " * name %s", str1 );
821 }
822 else if( p_dsc->i_tag == 0x4a )
823 {
824 msg_Dbg( p_obj, " * linkage descriptor" );
825 uint16_t i_ts_id = GetWBE( &p_dsc->p_data[0] );
826 uint16_t i_on_id = GetWBE( &p_dsc->p_data[2] );
827 uint16_t i_service_id = GetWBE( &p_dsc->p_data[4] );
828 int i_linkage_type = p_dsc->p_data[6];
829
830 msg_Dbg( p_obj, " * ts_id %d", i_ts_id );
831 msg_Dbg( p_obj, " * on_id %d", i_on_id );
832 msg_Dbg( p_obj, " * service_id %d", i_service_id );
833 msg_Dbg( p_obj, " * linkage_type %d", i_linkage_type );
834 }
835 else
836 {
837 msg_Dbg( p_obj, " * dsc 0x%x", p_dsc->i_tag );
838 }
839 }
840
841 dvbpsi_nit_ts_t *p_ts;
842 for( p_ts = p_nit->p_first_ts; p_ts != NULL; p_ts = p_ts->p_next )
843 {
844 msg_Dbg( p_obj, " * ts ts_id=0x%x original_id=0x%x", p_ts->i_ts_id, p_ts->i_orig_network_id );
845
846 uint32_t i_private_data_id = 0;
847 dvbpsi_descriptor_t *p_dsc;
848 scan_configuration_t *p_cfg = malloc(sizeof(*p_cfg));
849 if(!p_cfg) return VLC_ENOMEM;
850 memset(p_cfg,0,sizeof(*p_cfg));
851 for( p_dsc = p_ts->p_first_descriptor; p_dsc != NULL; p_dsc = p_dsc->p_next )
852 {
853 if( p_dsc->i_tag == 0x41 )
854 {
855 msg_Dbg( p_obj, " * service list descriptor" );
856 for( int i = 0; i < p_dsc->i_length/3; i++ )
857 {
858 uint16_t i_service_id = GetWBE( &p_dsc->p_data[3*i+0] );
859 uint8_t i_service_type = p_dsc->p_data[3*i+2];
860 msg_Dbg( p_obj, " * service_id=%d type=%d", i_service_id, i_service_type );
861 #ifdef _DVBPSI_DR_44_H_
862 if( (ScanFindService( p_scan, 0, i_service_id ) == NULL) &&
863 scan_service_type( i_service_type ) != SERVICE_UNKNOWN )
864 {
865 scan_service_t *s = scan_service_New( i_service_id, p_cfg );
866 s->type = scan_service_type( i_service_type );
867 s->i_network_id = p_nit->i_network_id;
868 s->i_nit_version = p_nit->i_version;
869 TAB_APPEND( p_scan->i_service, p_scan->pp_service, s );
870 }
871 #endif
872 }
873 }
874 else if( p_dsc->i_tag == 0x5a )
875 {
876 dvbpsi_terr_deliv_sys_dr_t *p_t = dvbpsi_DecodeTerrDelivSysDr( p_dsc );
877 msg_Dbg( p_obj, " * terrestrial delivery system" );
878 msg_Dbg( p_obj, " * centre_frequency 0x%x", p_t->i_centre_frequency );
879 msg_Dbg( p_obj, " * bandwidth %d", 8 - p_t->i_bandwidth );
880 msg_Dbg( p_obj, " * constellation %d", p_t->i_constellation );
881 msg_Dbg( p_obj, " * hierarchy %d", p_t->i_hierarchy_information );
882 msg_Dbg( p_obj, " * code_rate hp %d lp %d", p_t->i_code_rate_hp_stream, p_t->i_code_rate_lp_stream );
883 msg_Dbg( p_obj, " * guard_interval %d", p_t->i_guard_interval );
884 msg_Dbg( p_obj, " * transmission_mode %d", p_t->i_transmission_mode );
885 msg_Dbg( p_obj, " * other_frequency_flag %d", p_t->i_other_frequency_flag );
886 }
887 #ifdef _DVBPSI_DR_44_H_
888 else if( p_dsc->i_tag == 0x44 )
889 {
890 dvbpsi_cable_deliv_sys_dr_t *p_t = dvbpsi_DecodeCableDelivSysDr( p_dsc );
891 msg_Dbg( p_obj, " * Cable delivery system");
892
893 pcfg->i_freqency = decode_BCD( p_t->i_frequency ) * 100;
894 msg_Dbg( p_obj, " * frequency %d", p_cfg->i_frequency );
895 p_cfg->i_symbolrate = decode_BCD( p_t->i_symbol_rate ) * 100;
896 msg_Dbg( p_obj, " * symbolrate %u", p_cfg->i_symbolrate );
897 p_cfg->i_modulation = (8 << p_t->i_modulation);
898 msg_Dbg( p_obj, " * modulation %u", p_cfg->i_modulation );
899 }
900 #endif
901 else if( p_dsc->i_tag == 0x5f )
902 {
903 msg_Dbg( p_obj, " * private data specifier descriptor" );
904 i_private_data_id = GetDWBE( &p_dsc->p_data[0] );
905 msg_Dbg( p_obj, " * value 0x%8.8x", i_private_data_id );
906 }
907 else if( i_private_data_id == 0x28 && p_dsc->i_tag == 0x83 )
908 {
909 msg_Dbg( p_obj, " * logical channel descriptor (EICTA)" );
910 for( int i = 0; i < p_dsc->i_length/4; i++ )
911 {
912 uint16_t i_service_id = GetWBE( &p_dsc->p_data[4*i+0] );
913 int i_channel_number = GetWBE( &p_dsc->p_data[4*i+2] ) & 0x3ff;
914 msg_Dbg( p_obj, " * service_id=%d channel_number=%d", i_service_id, i_channel_number );
915 scan_service_t *s = ScanFindService( p_scan, 0, i_service_id );
916 if( s && s->i_channel < 0 ) s->i_channel = i_channel_number;
917 }
918
919 }
920 else
921 {
922 msg_Warn( p_obj, " * dsc 0x%x", p_dsc->i_tag );
923 }
924 }
925 }
926 }
927 #endif
928
929 static void PSINewTableCallBack( scan_session_t *p_session, dvbpsi_handle h, uint8_t i_table_id, uint16_t i_extension )
930 {
931 if( i_table_id == 0x42 )
932 dvbpsi_AttachSDT( h, i_table_id, i_extension, (dvbpsi_sdt_callback)SDTCallBack, p_session );
933 #ifdef DVBPSI_USE_NIT
934 else if( i_table_id == 0x40 || i_table_id == 0x41 )
935 dvbpsi_AttachNIT( h, i_table_id, i_extension, (dvbpsi_nit_callback)NITCallBack, p_session );
936 #endif
937 }
938
939 scan_session_t *scan_session_New( vlc_object_t *p_obj,
940 const scan_configuration_t *p_cfg )
941 {
942 scan_session_t *p_session = malloc( sizeof( *p_session ) );
943 if( unlikely(p_session == NULL) )
944 return NULL;
945 p_session->p_obj = p_obj;
946 p_session->cfg = *p_cfg;
947 p_session->i_snr = -1;
948 p_session->pat = NULL;
949 p_session->p_pat = NULL;
950 p_session->i_nit_pid = -1;
951 p_session->sdt = NULL;
952 p_session->p_sdt = NULL;
953 #ifdef DVBPSI_USE_NIT
954 p_session->nit = NULL;
955 p_session->p_nit = NULL;
956 #endif
957 return p_session;;
958 }
959
960 void scan_session_Destroy( scan_t *p_scan, scan_session_t *p_session )
961 {
962 const int i_service_start = p_scan->i_service;
963
964 dvbpsi_pat_t *p_pat = p_session->p_pat;
965 dvbpsi_sdt_t *p_sdt = p_session->p_sdt;
966
967 #ifdef DVBPSI_USE_NIT
968 dvbpsi_nit_t *p_nit = p_session->p_nit;
969 #endif
970
971 if( p_pat )
972 {
973 /* Parse PAT */
974 dvbpsi_pat_program_t *p_program;
975 for( p_program = p_pat->p_first_program; p_program != NULL; p_program = p_program->p_next )
976 {
977 if( p_program->i_number == 0 ) /* NIT */
978 continue;
979
980 scan_service_t *s = ScanFindService( p_scan, 0, p_program->i_number );
981 if( s == NULL )
982 {
983 s = scan_service_New( p_program->i_number, &p_session->cfg );
984 TAB_APPEND( p_scan->i_service, p_scan->pp_service, s );
985 }
986 }
987 }
988 /* Parse SDT */
989 if( p_pat && p_sdt )
990 {
991 dvbpsi_sdt_service_t *p_srv;
992 for( p_srv = p_sdt->p_first_service; p_srv; p_srv = p_srv->p_next )
993 {
994 scan_service_t *s = ScanFindService( p_scan, 0, p_srv->i_service_id );
995 dvbpsi_descriptor_t *p_dr;
996
997 if( s )
998 s->b_crypted = p_srv->b_free_ca;
999
1000 for( p_dr = p_srv->p_first_descriptor; p_dr; p_dr = p_dr->p_next )
1001 {
1002 if( p_dr->i_tag == 0x48 )
1003 {
1004 dvbpsi_service_dr_t *pD = dvbpsi_DecodeServiceDr( p_dr );
1005
1006 if( s )
1007 {
1008 if( !s->psz_name )
1009 s->psz_name = vlc_from_EIT( pD->i_service_name,
1010 pD->i_service_name_length );
1011
1012 if( s->type == SERVICE_UNKNOWN )
1013 s->type = scan_service_type( pD->i_service_type );
1014 }
1015 }
1016 }
1017 }
1018 }
1019
1020 #ifdef DVBPSI_USE_NIT
1021 /* Parse NIT */
1022 if( p_pat && p_nit )
1023 {
1024 dvbpsi_nit_ts_t *p_ts;
1025 for( p_ts = p_nit->p_first_ts; p_ts != NULL; p_ts = p_ts->p_next )
1026 {
1027 uint32_t i_private_data_id = 0;
1028 dvbpsi_descriptor_t *p_dsc;
1029
1030 if( p_ts->i_orig_network_id != p_nit->i_network_id || p_ts->i_ts_id != p_pat->i_ts_id )
1031 continue;
1032
1033 for( p_dsc = p_ts->p_first_descriptor; p_dsc != NULL; p_dsc = p_dsc->p_next )
1034 {
1035 if( p_dsc->i_tag == 0x5f )
1036 {
1037 i_private_data_id = GetDWBE( &p_dsc->p_data[0] );
1038 }
1039 else if( i_private_data_id == 0x28 && p_dsc->i_tag == 0x83 )
1040 {
1041 for( int i = 0; i < p_dsc->i_length/4; i++ )
1042 {
1043 uint16_t i_service_id = GetWBE( &p_dsc->p_data[4*i+0] );
1044 int i_channel_number = GetWBE( &p_dsc->p_data[4*i+2] ) & 0x3ff;
1045
1046 scan_service_t *s = ScanFindService( p_scan, i_service_start, i_service_id );
1047 if( s && s->i_channel < 0 )
1048 s->i_channel = i_channel_number;
1049 }
1050 }
1051 }
1052 }
1053 }
1054 #endif
1055
1056 /* */
1057 for( int i = i_service_start; i < p_scan->i_service; i++ )
1058 {
1059 scan_service_t *p_srv = p_scan->pp_service[i];
1060
1061 p_srv->i_snr = p_session->i_snr;
1062 if( p_sdt )
1063 p_srv->i_sdt_version = p_sdt->i_version;
1064 #ifdef DVBPSI_USE_NIT
1065 if( p_nit )
1066 {
1067 p_srv->i_network_id = p_nit->i_network_id;
1068 p_srv->i_nit_version = p_nit->i_version;
1069 }
1070 #endif
1071 }
1072
1073
1074 /* */
1075 if( p_session->pat )
1076 dvbpsi_DetachPAT( p_session->pat );
1077 if( p_session->p_pat )
1078 dvbpsi_DeletePAT( p_session->p_pat );
1079
1080 if( p_session->sdt )
1081 dvbpsi_DetachDemux( p_session->sdt );
1082 if( p_session->p_sdt )
1083 dvbpsi_DeleteSDT( p_session->p_sdt );
1084 #ifdef DVBPSI_USE_NIT
1085 if( p_session->nit )
1086 dvbpsi_DetachDemux( p_session->nit );
1087 if( p_session->p_nit )
1088 dvbpsi_DeleteNIT( p_session->p_nit );
1089 #endif
1090 free( p_session );
1091 }
1092
1093 static int ScanServiceCmp( const void *a, const void *b )
1094 {
1095 scan_service_t *sa = *(scan_service_t**)a;
1096 scan_service_t *sb = *(scan_service_t**)b;
1097
1098 if( sa->i_channel == sb->i_channel )
1099 {
1100 if( sa->psz_name && sb->psz_name )
1101 return strcmp( sa->psz_name, sb->psz_name );
1102 return 0;
1103 }
1104 if( sa->i_channel == -1 )
1105 return 1;
1106 else if( sb->i_channel == -1 )
1107 return -1;
1108
1109 if( sa->i_channel < sb->i_channel )
1110 return -1;
1111 else if( sa->i_channel > sb->i_channel )
1112 return 1;
1113 return 0;
1114 }
1115
1116 static block_t *BlockString( const char *psz )
1117 {
1118 block_t *p = block_Alloc( strlen(psz) );
1119 if( p )
1120 memcpy( p->p_buffer, psz, p->i_buffer );
1121 return p;
1122 }
1123
1124 block_t *scan_GetM3U( scan_t *p_scan )
1125 {
1126 vlc_object_t *p_obj = p_scan->p_obj;
1127 block_t *p_playlist = NULL;
1128
1129 if( p_scan->i_service <= 0 )
1130 return NULL;
1131
1132 /* */
1133 qsort( p_scan->pp_service, p_scan->i_service, sizeof(scan_service_t*), ScanServiceCmp );
1134
1135 /* */
1136 p_playlist = BlockString( "#EXTM3U\n\n" );/* */
1137
1138 for( int i = 0; i < p_scan->i_service; i++ )
1139 {
1140 scan_service_t *s = p_scan->pp_service[i];
1141
1142 if( s->type == SERVICE_UNKNOWN )
1143 {
1144 /* We should only select service that have been described by SDT */
1145 msg_Dbg( p_obj, "scan_GetM3U: ignoring service number %d", s->i_program );
1146 continue;
1147 }
1148
1149 const char *psz_type;
1150 switch( s->type )
1151 {
1152 case SERVICE_DIGITAL_TELEVISION: psz_type = "Digital television"; break;
1153 case SERVICE_DIGITAL_TELEVISION_AC_SD: psz_type = "Digital television advanced codec SD"; break;
1154 case SERVICE_DIGITAL_TELEVISION_AC_HD: psz_type = "Digital television advanced codec HD"; break;
1155 case SERVICE_DIGITAL_RADIO: psz_type = "Digital radio"; break;
1156 default:
1157 psz_type = "Unknown";
1158 break;
1159 }
1160 msg_Warn( p_obj, "scan_GetM3U: service number %d type '%s' name '%s' channel %d cypted=%d| network_id %d (nit:%d sdt:%d)| f=%d bw=%d snr=%d modulation=%d",
1161 s->i_program, psz_type, s->psz_name, s->i_channel, s->b_crypted,
1162 s->i_network_id, s->i_nit_version, s->i_sdt_version,
1163 s->cfg.i_frequency, s->cfg.i_bandwidth, s->i_snr, s->cfg.i_modulation );
1164
1165 if( !s->cfg.i_fec )
1166 s->cfg.i_fec = 9; /* FEC_AUTO */
1167
1168 char *psz;
1169 if( asprintf( &psz, "#EXTINF:,,%s\n"
1170 "#EXTVLCOPT:program=%d\n"
1171 "dvb://frequency=%d:bandwidth=%d:voltage=%d:fec=%d:modulation=%d:srate=%d\n"
1172 "\n",
1173 s->psz_name && * s->psz_name ? s->psz_name : "Unknown",
1174 s->i_program,
1175 s->cfg.i_frequency,
1176 s->cfg.i_bandwidth,
1177 s->cfg.c_polarization == 'H' ? 18 : 13,
1178 s->cfg.i_fec,
1179 s->cfg.i_modulation,
1180 s->cfg.i_symbolrate ) < 0 )
1181 psz = NULL;
1182 if( psz )
1183 {
1184 block_t *p_block = BlockString( psz );
1185 if( p_block )
1186 block_ChainAppend( &p_playlist, p_block );
1187 }
1188 }
1189
1190 return p_playlist ? block_ChainGather( p_playlist ) : NULL;
1191 }
1192
1193 bool scan_session_Push( scan_session_t *p_scan, block_t *p_block )
1194 {
1195 if( p_block->i_buffer < 188 || p_block->p_buffer[0] != 0x47 )
1196 {
1197 block_Release( p_block );
1198 return false;
1199 }
1200
1201 /* */
1202 const int i_pid = ( (p_block->p_buffer[1]&0x1f)<<8) | p_block->p_buffer[2];
1203 if( i_pid == 0x00 )
1204 {
1205 if( !p_scan->pat )
1206 p_scan->pat = dvbpsi_AttachPAT( (dvbpsi_pat_callback)PATCallBack, p_scan );
1207
1208 if( p_scan->pat )
1209 dvbpsi_PushPacket( p_scan->pat, p_block->p_buffer );
1210 }
1211 else if( i_pid == 0x11 )
1212 {
1213 if( !p_scan->sdt )
1214 p_scan->sdt = dvbpsi_AttachDemux( (dvbpsi_demux_new_cb_t)PSINewTableCallBack, p_scan );
1215
1216 if( p_scan->sdt )
1217 dvbpsi_PushPacket( p_scan->sdt, p_block->p_buffer );
1218 }
1219 else /*if( i_pid == p_scan->i_nit_pid )*/
1220 {
1221 #ifdef DVBPSI_USE_NIT
1222 if( !p_scan->nit )
1223 p_scan->nit = dvbpsi_AttachDemux( (dvbpsi_demux_new_cb_t)PSINewTableCallBack, p_scan );
1224
1225 if( p_scan->nit )
1226 dvbpsi_PushPacket( p_scan->nit, p_block->p_buffer );
1227 #endif
1228 }
1229
1230 block_Release( p_block );
1231
1232 return p_scan->p_pat && p_scan->p_sdt &&
1233 #ifdef DVBPSI_USE_NIT
1234 p_scan->p_nit;
1235 #else
1236 true;
1237 #endif
1238 }
1239
1240 void scan_service_SetSNR( scan_session_t *p_session, int i_snr )
1241 {
1242 p_session->i_snr = i_snr;
1243 }
1244
VLC Development tree mirror