1 /*
2 * dvbbasebin.c -
3 * Copyright (C) 2007 Alessandro Decina
4 * Copyright (C) 2014 Samsung Electronics. All rights reserved.
5 *
6 * Authors:
7 * Alessandro Decina <alessandro.d@gmail.com>
8 * Reynaldo H. Verdejo Pinochet <reynaldo@osg.samsung.com>
9 *
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Library General Public
12 * License as published by the Free Software Foundation; either
13 * version 2 of the License, or (at your option) any later version.
14 *
15 * This library 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 GNU
18 * Library General Public License for more details.
19 *
20 * You should have received a copy of the GNU Library General Public
21 * License along with this library; if not, write to the
22 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
23 * Boston, MA 02110-1301, USA.
24 */
25
26
27 #ifdef HAVE_CONFIG_H
28 #include "config.h"
29 #endif
30 #include <stdlib.h>
31 #include <string.h>
32 #include <gst/mpegts/mpegts.h>
33 #include "dvbbasebin.h"
34 #include "parsechannels.h"
35
36 GST_DEBUG_CATEGORY (dvb_base_bin_debug);
37 #define GST_CAT_DEFAULT dvb_base_bin_debug
38
39 static GstStaticPadTemplate src_template =
40 GST_STATIC_PAD_TEMPLATE ("src", GST_PAD_SRC,
41 GST_PAD_ALWAYS,
42 GST_STATIC_CAPS ("video/mpegts, " "systemstream = (boolean) true ")
43 );
44
45 static GstStaticPadTemplate program_template =
46 GST_STATIC_PAD_TEMPLATE ("program_%u", GST_PAD_SRC,
47 GST_PAD_REQUEST,
48 GST_STATIC_CAPS ("video/mpegts, " "systemstream = (boolean) true ")
49 );
50
51 enum
52 {
53 /* FILL ME */
54 SIGNAL_TUNING_START,
55 SIGNAL_TUNING_DONE,
56 SIGNAL_TUNING_FAIL,
57 SIGNAL_TUNE,
58 LAST_SIGNAL
59 };
60
61 enum
62 {
63 ARG_0,
64 PROP_ADAPTER,
65 PROP_FRONTEND,
66 PROP_DISEQC_SRC,
67 PROP_FREQUENCY,
68 PROP_POLARITY,
69 PROP_SYMBOL_RATE,
70 PROP_BANDWIDTH,
71 PROP_CODE_RATE_HP,
72 PROP_CODE_RATE_LP,
73 PROP_GUARD,
74 PROP_MODULATION,
75 PROP_TRANS_MODE,
76 PROP_HIERARCHY,
77 PROP_INVERSION,
78 PROP_PROGRAM_NUMBERS,
79 PROP_STATS_REPORTING_INTERVAL,
80 PROP_TUNING_TIMEOUT,
81 PROP_DELSYS,
82 PROP_PILOT,
83 PROP_ROLLOFF,
84 PROP_STREAM_ID,
85 PROP_BANDWIDTH_HZ,
86 PROP_ISDBT_LAYER_ENABLED,
87 PROP_ISDBT_PARTIAL_RECEPTION,
88 PROP_ISDBT_SOUND_BROADCASTING,
89 PROP_ISDBT_SB_SUBCHANNEL_ID,
90 PROP_ISDBT_SB_SEGMENT_IDX,
91 PROP_ISDBT_SB_SEGMENT_COUNT,
92 PROP_ISDBT_LAYERA_FEC,
93 PROP_ISDBT_LAYERA_MODULATION,
94 PROP_ISDBT_LAYERA_SEGMENT_COUNT,
95 PROP_ISDBT_LAYERA_TIME_INTERLEAVING,
96 PROP_ISDBT_LAYERB_FEC,
97 PROP_ISDBT_LAYERB_MODULATION,
98 PROP_ISDBT_LAYERB_SEGMENT_COUNT,
99 PROP_ISDBT_LAYERB_TIME_INTERLEAVING,
100 PROP_ISDBT_LAYERC_FEC,
101 PROP_ISDBT_LAYERC_MODULATION,
102 PROP_ISDBT_LAYERC_SEGMENT_COUNT,
103 PROP_ISDBT_LAYERC_TIME_INTERLEAVING,
104 PROP_LNB_SLOF,
105 PROP_LNB_LOF1,
106 PROP_LNB_LOF2,
107 PROP_INTERLEAVING
108 };
109
110 typedef struct
111 {
112 guint16 pid;
113 guint usecount;
114 } DvbBaseBinStream;
115
116 typedef struct
117 {
118 gint program_number;
119 guint16 pmt_pid;
120 guint16 pcr_pid;
121 GstMpegtsSection *section;
122 GstMpegtsSection *old_section;
123 const GstMpegtsPMT *pmt;
124 const GstMpegtsPMT *old_pmt;
125 gboolean selected;
126 gboolean pmt_active;
127 gboolean active;
128 GstPad *ghost;
129 } DvbBaseBinProgram;
130
131 static void dvb_base_bin_set_property (GObject * object, guint prop_id,
132 const GValue * value, GParamSpec * pspec);
133 static void dvb_base_bin_get_property (GObject * object, guint prop_id,
134 GValue * value, GParamSpec * pspec);
135 static void dvb_base_bin_dispose (GObject * object);
136 static void dvb_base_bin_finalize (GObject * object);
137
138 static void dvb_base_bin_task (DvbBaseBin * basebin);
139
140 static GstStateChangeReturn dvb_base_bin_change_state (GstElement * element,
141 GstStateChange transition);
142 static void dvb_base_bin_handle_message (GstBin * bin, GstMessage * message);
143 static void dvb_base_bin_pat_info_cb (DvbBaseBin * dvbbasebin,
144 GstMpegtsSection * pat);
145 static void dvb_base_bin_pmt_info_cb (DvbBaseBin * dvbbasebin,
146 GstMpegtsSection * pmt);
147 static GstPad *dvb_base_bin_request_new_pad (GstElement * element,
148 GstPadTemplate * templ, const gchar * name, const GstCaps * caps);
149 static void dvb_base_bin_release_pad (GstElement * element, GstPad * pad);
150 static void dvb_base_bin_rebuild_filter (DvbBaseBin * dvbbasebin);
151 static void
152 dvb_base_bin_deactivate_program (DvbBaseBin * dvbbasebin,
153 DvbBaseBinProgram * program);
154
155 static void dvb_base_bin_uri_handler_init (gpointer g_iface,
156 gpointer iface_data);
157
158 static void dvb_base_bin_program_destroy (gpointer data);
159
160 /* Proxy callbacks for dvbsrc signals */
161 static void tuning_start_signal_cb (GObject * object, DvbBaseBin * dvbbasebin);
162 static void tuning_done_signal_cb (GObject * object, DvbBaseBin * dvbbasebin);
163 static void tuning_fail_signal_cb (GObject * object, DvbBaseBin * dvbbasebin);
164
165 static void dvb_base_bin_do_tune (DvbBaseBin * dvbbasebin);
166
167 #define dvb_base_bin_parent_class parent_class
168 G_DEFINE_TYPE_EXTENDED (DvbBaseBin, dvb_base_bin, GST_TYPE_BIN,
169 0,
170 G_IMPLEMENT_INTERFACE (GST_TYPE_URI_HANDLER,
171 dvb_base_bin_uri_handler_init));
172
173
174 static void
dvb_base_bin_ref_stream(DvbBaseBinStream * stream)175 dvb_base_bin_ref_stream (DvbBaseBinStream * stream)
176 {
177 g_return_if_fail (stream != NULL);
178 stream->usecount++;
179 }
180
181 static void
dvb_base_bin_unref_stream(DvbBaseBinStream * stream)182 dvb_base_bin_unref_stream (DvbBaseBinStream * stream)
183 {
184 g_return_if_fail (stream != NULL);
185 g_return_if_fail (stream->usecount > 0);
186 stream->usecount--;
187 }
188
189 static DvbBaseBinStream *
dvb_base_bin_add_stream(DvbBaseBin * dvbbasebin,guint16 pid)190 dvb_base_bin_add_stream (DvbBaseBin * dvbbasebin, guint16 pid)
191 {
192 DvbBaseBinStream *stream;
193
194 stream = g_new0 (DvbBaseBinStream, 1);
195 stream->pid = pid;
196 stream->usecount = 0;
197
198 g_hash_table_insert (dvbbasebin->streams,
199 GINT_TO_POINTER ((gint) pid), stream);
200
201 return stream;
202 }
203
204 static DvbBaseBinStream *
dvb_base_bin_get_stream(DvbBaseBin * dvbbasebin,guint16 pid)205 dvb_base_bin_get_stream (DvbBaseBin * dvbbasebin, guint16 pid)
206 {
207 return (DvbBaseBinStream *) g_hash_table_lookup (dvbbasebin->streams,
208 GINT_TO_POINTER ((gint) pid));
209 }
210
211 static DvbBaseBinProgram *
dvb_base_bin_add_program(DvbBaseBin * dvbbasebin,gint program_number)212 dvb_base_bin_add_program (DvbBaseBin * dvbbasebin, gint program_number)
213 {
214 DvbBaseBinProgram *program;
215
216 program = g_new0 (DvbBaseBinProgram, 1);
217 program->program_number = program_number;
218 program->selected = FALSE;
219 program->active = FALSE;
220 program->pmt_pid = G_MAXUINT16;
221 program->pcr_pid = G_MAXUINT16;
222 program->pmt = NULL;
223 program->old_pmt = NULL;
224
225 g_hash_table_insert (dvbbasebin->programs,
226 GINT_TO_POINTER (program_number), program);
227
228 return program;
229 }
230
231 static DvbBaseBinProgram *
dvb_base_bin_get_program(DvbBaseBin * dvbbasebin,gint program_number)232 dvb_base_bin_get_program (DvbBaseBin * dvbbasebin, gint program_number)
233 {
234 return (DvbBaseBinProgram *) g_hash_table_lookup (dvbbasebin->programs,
235 GINT_TO_POINTER (program_number));
236 }
237
238
239 static guint dvb_base_bin_signals[LAST_SIGNAL] = { 0 };
240
241 static void
tuning_start_signal_cb(GObject * object,DvbBaseBin * dvbbasebin)242 tuning_start_signal_cb (GObject * object, DvbBaseBin * dvbbasebin)
243 {
244 g_signal_emit (dvbbasebin, dvb_base_bin_signals[SIGNAL_TUNING_START], 0);
245 }
246
247 static void
tuning_done_signal_cb(GObject * object,DvbBaseBin * dvbbasebin)248 tuning_done_signal_cb (GObject * object, DvbBaseBin * dvbbasebin)
249 {
250 g_signal_emit (dvbbasebin, dvb_base_bin_signals[SIGNAL_TUNING_DONE], 0);
251 }
252
253 static void
tuning_fail_signal_cb(GObject * object,DvbBaseBin * dvbbasebin)254 tuning_fail_signal_cb (GObject * object, DvbBaseBin * dvbbasebin)
255 {
256 g_signal_emit (dvbbasebin, dvb_base_bin_signals[SIGNAL_TUNING_FAIL], 0);
257 }
258
259 static void
dvb_base_bin_do_tune(DvbBaseBin * dvbbasebin)260 dvb_base_bin_do_tune (DvbBaseBin * dvbbasebin)
261 {
262 g_signal_emit_by_name (dvbbasebin->dvbsrc, "tune", NULL);
263 }
264
265 static void
dvb_base_bin_class_init(DvbBaseBinClass * klass)266 dvb_base_bin_class_init (DvbBaseBinClass * klass)
267 {
268 GObjectClass *gobject_class;
269 GstElementClass *element_class;
270 GstBinClass *bin_class;
271 DvbBaseBinClass *dvbbasebin_class;
272 GstElementFactory *dvbsrc_factory;
273 GObjectClass *dvbsrc_class;
274 typedef struct
275 {
276 guint prop_id;
277 const gchar *prop_name;
278 } ProxyedProperty;
279 ProxyedProperty *walk;
280 ProxyedProperty proxyed_properties[] = {
281 {PROP_ADAPTER, "adapter"},
282 {PROP_FRONTEND, "frontend"},
283 {PROP_DISEQC_SRC, "diseqc-source"},
284 {PROP_FREQUENCY, "frequency"},
285 {PROP_POLARITY, "polarity"},
286 {PROP_SYMBOL_RATE, "symbol-rate"},
287 #ifndef GST_REMOVE_DEPRECATED
288 {PROP_BANDWIDTH, "bandwidth"},
289 #endif
290 {PROP_CODE_RATE_HP, "code-rate-hp"},
291 {PROP_CODE_RATE_LP, "code-rate-lp"},
292 {PROP_GUARD, "guard"},
293 {PROP_MODULATION, "modulation"},
294 {PROP_TRANS_MODE, "trans-mode"},
295 {PROP_HIERARCHY, "hierarchy"},
296 {PROP_INVERSION, "inversion"},
297 {PROP_STATS_REPORTING_INTERVAL, "stats-reporting-interval"},
298 {PROP_TUNING_TIMEOUT, "tuning-timeout"},
299 {PROP_DELSYS, "delsys"},
300 {PROP_PILOT, "pilot"},
301 {PROP_ROLLOFF, "rolloff"},
302 {PROP_STREAM_ID, "stream-id"},
303 {PROP_BANDWIDTH_HZ, "bandwidth-hz"},
304 {PROP_ISDBT_LAYER_ENABLED, "isdbt-layer-enabled"},
305 {PROP_ISDBT_PARTIAL_RECEPTION, "isdbt-partial-reception"},
306 {PROP_ISDBT_SOUND_BROADCASTING, "isdbt-sound-broadcasting"},
307 {PROP_ISDBT_SB_SUBCHANNEL_ID, "isdbt-sb-subchannel-id"},
308 {PROP_ISDBT_SB_SEGMENT_IDX, "isdbt-sb-segment-idx"},
309 {PROP_ISDBT_SB_SEGMENT_COUNT, "isdbt-sb-segment-count"},
310 {PROP_ISDBT_LAYERA_FEC, "isdbt-layera-fec"},
311 {PROP_ISDBT_LAYERA_MODULATION, "isdbt-layera-modulation"},
312 {PROP_ISDBT_LAYERA_SEGMENT_COUNT, "isdbt-layera-segment-count"},
313 {PROP_ISDBT_LAYERA_TIME_INTERLEAVING, "isdbt-layera-time-interleaving"},
314 {PROP_ISDBT_LAYERB_FEC, "isdbt-layerb-fec"},
315 {PROP_ISDBT_LAYERB_MODULATION, "isdbt-layerb-modulation"},
316 {PROP_ISDBT_LAYERB_SEGMENT_COUNT, "isdbt-layerb-segment-count"},
317 {PROP_ISDBT_LAYERB_TIME_INTERLEAVING, "isdbt-layerb-time-interleaving"},
318 {PROP_ISDBT_LAYERC_FEC, "isdbt-layerc-fec"},
319 {PROP_ISDBT_LAYERC_MODULATION, "isdbt-layerc-modulation"},
320 {PROP_ISDBT_LAYERC_SEGMENT_COUNT, "isdbt-layerc-segment-count"},
321 {PROP_ISDBT_LAYERC_TIME_INTERLEAVING, "isdbt-layerc-time-interleaving"},
322 {PROP_LNB_SLOF, "lnb-slof"},
323 {PROP_LNB_LOF1, "lnb-lof1"},
324 {PROP_LNB_LOF2, "lnb-lof2"},
325 {PROP_INTERLEAVING, "interleaving"},
326 {0, NULL}
327 };
328
329 bin_class = GST_BIN_CLASS (klass);
330 bin_class->handle_message = dvb_base_bin_handle_message;
331
332 element_class = GST_ELEMENT_CLASS (klass);
333
334 element_class->change_state = dvb_base_bin_change_state;
335 element_class->request_new_pad = dvb_base_bin_request_new_pad;
336 element_class->release_pad = dvb_base_bin_release_pad;
337
338 gst_element_class_add_static_pad_template (element_class, &program_template);
339 gst_element_class_add_static_pad_template (element_class, &src_template);
340
341 gst_element_class_set_static_metadata (element_class, "DVB bin",
342 "Source/Bin/Video",
343 "Access descramble and split DVB streams",
344 "Alessandro Decina <alessandro.d@gmail.com>\n"
345 "Reynaldo H. Verdejo Pinochet <reynaldo@osg.samsung.com>");
346
347 gobject_class = G_OBJECT_CLASS (klass);
348 gobject_class->set_property = dvb_base_bin_set_property;
349 gobject_class->get_property = dvb_base_bin_get_property;
350 gobject_class->dispose = dvb_base_bin_dispose;
351 gobject_class->finalize = dvb_base_bin_finalize;
352
353 dvbbasebin_class = (DvbBaseBinClass *) klass;
354 dvbbasebin_class->do_tune = dvb_base_bin_do_tune;
355
356 /* install dvbsrc properties */
357 dvbsrc_factory = gst_element_factory_find ("dvbsrc");
358 dvbsrc_class =
359 g_type_class_ref (gst_element_factory_get_element_type (dvbsrc_factory));
360 walk = proxyed_properties;
361 while (walk->prop_name != NULL) {
362 GParamSpec *pspec;
363 GParamSpec *our_pspec;
364
365 pspec = g_object_class_find_property (dvbsrc_class, walk->prop_name);
366 if (pspec != NULL) {
367 GType param_type = G_PARAM_SPEC_TYPE (pspec);
368
369 if (param_type == G_TYPE_PARAM_INT) {
370 GParamSpecInt *src_pspec = G_PARAM_SPEC_INT (pspec);
371
372 our_pspec = g_param_spec_int (g_param_spec_get_name (pspec),
373 g_param_spec_get_nick (pspec), g_param_spec_get_blurb (pspec),
374 src_pspec->minimum, src_pspec->maximum, src_pspec->default_value,
375 pspec->flags);
376 } else if (param_type == G_TYPE_PARAM_UINT) {
377 GParamSpecUInt *src_pspec = G_PARAM_SPEC_UINT (pspec);
378
379 our_pspec = g_param_spec_uint (g_param_spec_get_name (pspec),
380 g_param_spec_get_nick (pspec), g_param_spec_get_blurb (pspec),
381 src_pspec->minimum, src_pspec->maximum, src_pspec->default_value,
382 pspec->flags);
383 } else if (param_type == G_TYPE_PARAM_UINT64) {
384 GParamSpecUInt64 *src_pspec = G_PARAM_SPEC_UINT64 (pspec);
385
386 our_pspec = g_param_spec_uint64 (g_param_spec_get_name (pspec),
387 g_param_spec_get_nick (pspec), g_param_spec_get_blurb (pspec),
388 src_pspec->minimum, src_pspec->maximum, src_pspec->default_value,
389 pspec->flags);
390 } else if (param_type == G_TYPE_PARAM_STRING) {
391 GParamSpecString *src_pspec = G_PARAM_SPEC_STRING (pspec);
392
393 our_pspec = g_param_spec_string (g_param_spec_get_name (pspec),
394 g_param_spec_get_nick (pspec), g_param_spec_get_blurb (pspec),
395 src_pspec->default_value, pspec->flags);
396 } else if (param_type == G_TYPE_PARAM_ENUM) {
397 GParamSpecEnum *src_pspec = G_PARAM_SPEC_ENUM (pspec);
398
399 our_pspec = g_param_spec_enum (g_param_spec_get_name (pspec),
400 g_param_spec_get_nick (pspec), g_param_spec_get_blurb (pspec),
401 pspec->value_type, src_pspec->default_value, pspec->flags);
402 } else {
403 GST_ERROR ("Unsupported property type %s for property %s",
404 g_type_name (param_type), g_param_spec_get_name (pspec));
405 ++walk;
406 continue;
407 }
408
409 g_object_class_install_property (gobject_class, walk->prop_id, our_pspec);
410 } else {
411 g_warning ("dvbsrc has no property named %s", walk->prop_name);
412 }
413 ++walk;
414 }
415 g_type_class_unref (dvbsrc_class);
416
417 g_object_class_install_property (gobject_class, PROP_PROGRAM_NUMBERS,
418 g_param_spec_string ("program-numbers",
419 "Program Numbers",
420 "Colon separated list of programs", "", G_PARAM_READWRITE));
421 /**
422 * DvbBaseBin::tuning-start:
423 * @dvbbasebin: the element on which the signal is emitted
424 *
425 * Signal emited when the element first attempts to tune the
426 * frontend tunner to a given frequency.
427 */
428 dvb_base_bin_signals[SIGNAL_TUNING_START] =
429 g_signal_new ("tuning-start", G_TYPE_FROM_CLASS (klass),
430 G_SIGNAL_RUN_LAST, 0, NULL, NULL, NULL, G_TYPE_NONE, 0);
431 /**
432 * DvbBaseBin::tuning-done:
433 * @dvbbasebin: the element on which the signal is emitted
434 *
435 * Signal emited when the tunner has successfully got a lock on a signal.
436 */
437 dvb_base_bin_signals[SIGNAL_TUNING_DONE] =
438 g_signal_new ("tuning-done", G_TYPE_FROM_CLASS (klass),
439 G_SIGNAL_RUN_LAST, 0, NULL, NULL, NULL, G_TYPE_NONE, 0);
440 /**
441 * DvbBaseBin::tuning-fail:
442 * @dvbbasebin: the element on which the signal is emitted
443 *
444 * Signal emited when the tunner failed to get a lock on the
445 * signal.
446 */
447 dvb_base_bin_signals[SIGNAL_TUNING_FAIL] =
448 g_signal_new ("tuning-fail", G_TYPE_FROM_CLASS (klass),
449 G_SIGNAL_RUN_LAST, 0, NULL, NULL, NULL, G_TYPE_NONE, 0);
450
451 /**
452 * DvbBaseBin::tune:
453 * @dvbbasesink: the element on which the signal is emitted
454 *
455 * Signal emited from the application to the element, instructing it
456 * to tune.
457 */
458 dvb_base_bin_signals[SIGNAL_TUNE] =
459 g_signal_new ("tune", G_TYPE_FROM_CLASS (klass),
460 G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
461 G_STRUCT_OFFSET (DvbBaseBinClass, do_tune),
462 NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
463 }
464
465 static void
dvb_base_bin_reset(DvbBaseBin * dvbbasebin)466 dvb_base_bin_reset (DvbBaseBin * dvbbasebin)
467 {
468 if (dvbbasebin->hwcam) {
469 cam_device_close (dvbbasebin->hwcam);
470 cam_device_free (dvbbasebin->hwcam);
471 dvbbasebin->hwcam = NULL;
472 }
473 dvbbasebin->trycam = TRUE;
474 }
475
476 static const gint16 initial_pids[] = { 0, 1, 0x10, 0x11, 0x12, 0x14, -1 };
477
478 static void
dvb_base_bin_init(DvbBaseBin * dvbbasebin)479 dvb_base_bin_init (DvbBaseBin * dvbbasebin)
480 {
481 DvbBaseBinStream *stream;
482 GstPad *ghost, *pad;
483 int i;
484
485 dvbbasebin->dvbsrc = gst_element_factory_make ("dvbsrc", NULL);
486 dvbbasebin->buffer_queue = gst_element_factory_make ("queue", NULL);
487 dvbbasebin->tsparse = gst_element_factory_make ("tsparse", NULL);
488
489 g_object_set (dvbbasebin->buffer_queue, "max-size-buffers", 0,
490 "max-size-bytes", 0, "max-size-time", (guint64) 0, NULL);
491
492 gst_bin_add_many (GST_BIN (dvbbasebin), dvbbasebin->dvbsrc,
493 dvbbasebin->buffer_queue, dvbbasebin->tsparse, NULL);
494
495 gst_element_link_many (dvbbasebin->dvbsrc,
496 dvbbasebin->buffer_queue, dvbbasebin->tsparse, NULL);
497
498 /* Proxy dvbsrc signals */
499 g_signal_connect (dvbbasebin->dvbsrc, "tuning-start",
500 G_CALLBACK (tuning_start_signal_cb), dvbbasebin);
501 g_signal_connect (dvbbasebin->dvbsrc, "tuning-done",
502 G_CALLBACK (tuning_done_signal_cb), dvbbasebin);
503 g_signal_connect (dvbbasebin->dvbsrc, "tuning-fail",
504 G_CALLBACK (tuning_fail_signal_cb), dvbbasebin);
505
506 /* Expose tsparse source pad */
507 if (dvbbasebin->tsparse != NULL) {
508 pad = gst_element_get_static_pad (dvbbasebin->tsparse, "src");
509 ghost = gst_ghost_pad_new ("src", pad);
510 gst_object_unref (pad);
511 } else {
512 ghost = gst_ghost_pad_new_no_target ("src", GST_PAD_SRC);
513 }
514 gst_element_add_pad (GST_ELEMENT (dvbbasebin), ghost);
515
516 dvbbasebin->programs = g_hash_table_new_full (g_direct_hash, g_direct_equal,
517 NULL, dvb_base_bin_program_destroy);
518 dvbbasebin->streams = g_hash_table_new_full (g_direct_hash, g_direct_equal,
519 NULL, g_free);
520
521 dvbbasebin->pmtlist = NULL;
522 dvbbasebin->pmtlist_changed = FALSE;
523
524 dvbbasebin->disposed = FALSE;
525 dvb_base_bin_reset (dvbbasebin);
526
527 /* add PAT, CAT, NIT, SDT, EIT, TDT to pids filter for dvbsrc */
528 i = 0;
529 while (initial_pids[i] >= 0) {
530 stream = dvb_base_bin_add_stream (dvbbasebin, (guint16) initial_pids[i]);
531 dvb_base_bin_ref_stream (stream);
532 i++;
533 }
534 dvb_base_bin_rebuild_filter (dvbbasebin);
535
536 g_rec_mutex_init (&dvbbasebin->lock);
537 dvbbasebin->task =
538 gst_task_new ((GstTaskFunction) dvb_base_bin_task, dvbbasebin, NULL);
539 gst_task_set_lock (dvbbasebin->task, &dvbbasebin->lock);
540 dvbbasebin->poll = gst_poll_new (TRUE);
541 }
542
543 static void
dvb_base_bin_dispose(GObject * object)544 dvb_base_bin_dispose (GObject * object)
545 {
546 DvbBaseBin *dvbbasebin = GST_DVB_BASE_BIN (object);
547
548 if (!dvbbasebin->disposed) {
549 /* remove mpegtsparse BEFORE dvbsrc, since the mpegtsparse::pad-removed
550 * signal handler uses dvbsrc */
551 dvb_base_bin_reset (dvbbasebin);
552 if (dvbbasebin->tsparse != NULL)
553 gst_bin_remove (GST_BIN (dvbbasebin), dvbbasebin->tsparse);
554 gst_bin_remove (GST_BIN (dvbbasebin), dvbbasebin->dvbsrc);
555 gst_bin_remove (GST_BIN (dvbbasebin), dvbbasebin->buffer_queue);
556 g_free (dvbbasebin->program_numbers);
557 gst_poll_free (dvbbasebin->poll);
558 gst_object_unref (dvbbasebin->task);
559 g_rec_mutex_clear (&dvbbasebin->lock);
560 dvbbasebin->disposed = TRUE;
561 }
562
563 if (G_OBJECT_CLASS (parent_class)->dispose)
564 G_OBJECT_CLASS (parent_class)->dispose (object);
565 }
566
567 static void
dvb_base_bin_finalize(GObject * object)568 dvb_base_bin_finalize (GObject * object)
569 {
570 DvbBaseBin *dvbbasebin = GST_DVB_BASE_BIN (object);
571
572 g_hash_table_destroy (dvbbasebin->streams);
573 g_hash_table_destroy (dvbbasebin->programs);
574 g_list_free (dvbbasebin->pmtlist);
575
576 if (G_OBJECT_CLASS (parent_class)->finalize)
577 G_OBJECT_CLASS (parent_class)->finalize (object);
578 }
579
580 static void
dvb_base_bin_set_program_numbers(DvbBaseBin * dvbbasebin,const gchar * pn)581 dvb_base_bin_set_program_numbers (DvbBaseBin * dvbbasebin, const gchar * pn)
582 {
583 gchar **strv, **walk;
584 DvbBaseBinProgram *program;
585
586 /* Split up and update programs */
587 strv = g_strsplit (pn, ":", 0);
588
589 for (walk = strv; *walk; walk++) {
590 gint program_number = strtol (*walk, NULL, 0);
591
592 program = dvb_base_bin_get_program (dvbbasebin, program_number);
593 if (program == NULL) {
594 program = dvb_base_bin_add_program (dvbbasebin, program_number);
595 program->selected = TRUE;
596 }
597 }
598
599 g_strfreev (strv);
600
601 /* FIXME : Deactivate programs no longer selected */
602
603 g_free (dvbbasebin->program_numbers);
604 dvbbasebin->program_numbers = g_strdup (pn);
605
606 if (0)
607 dvb_base_bin_deactivate_program (dvbbasebin, NULL);
608 }
609
610 static void
dvb_base_bin_set_property(GObject * object,guint prop_id,const GValue * value,GParamSpec * pspec)611 dvb_base_bin_set_property (GObject * object, guint prop_id,
612 const GValue * value, GParamSpec * pspec)
613 {
614 DvbBaseBin *dvbbasebin = GST_DVB_BASE_BIN (object);
615
616 switch (prop_id) {
617 case PROP_ADAPTER:
618 case PROP_DISEQC_SRC:
619 case PROP_FRONTEND:
620 case PROP_FREQUENCY:
621 case PROP_POLARITY:
622 case PROP_SYMBOL_RATE:
623 case PROP_BANDWIDTH:
624 case PROP_CODE_RATE_HP:
625 case PROP_CODE_RATE_LP:
626 case PROP_GUARD:
627 case PROP_MODULATION:
628 case PROP_TRANS_MODE:
629 case PROP_HIERARCHY:
630 case PROP_INVERSION:
631 case PROP_STATS_REPORTING_INTERVAL:
632 case PROP_TUNING_TIMEOUT:
633 case PROP_DELSYS:
634 case PROP_PILOT:
635 case PROP_ROLLOFF:
636 case PROP_STREAM_ID:
637 case PROP_BANDWIDTH_HZ:
638 case PROP_ISDBT_LAYER_ENABLED:
639 case PROP_ISDBT_PARTIAL_RECEPTION:
640 case PROP_ISDBT_SOUND_BROADCASTING:
641 case PROP_ISDBT_SB_SUBCHANNEL_ID:
642 case PROP_ISDBT_SB_SEGMENT_IDX:
643 case PROP_ISDBT_SB_SEGMENT_COUNT:
644 case PROP_ISDBT_LAYERA_FEC:
645 case PROP_ISDBT_LAYERA_MODULATION:
646 case PROP_ISDBT_LAYERA_SEGMENT_COUNT:
647 case PROP_ISDBT_LAYERA_TIME_INTERLEAVING:
648 case PROP_ISDBT_LAYERB_FEC:
649 case PROP_ISDBT_LAYERB_MODULATION:
650 case PROP_ISDBT_LAYERB_SEGMENT_COUNT:
651 case PROP_ISDBT_LAYERB_TIME_INTERLEAVING:
652 case PROP_ISDBT_LAYERC_FEC:
653 case PROP_ISDBT_LAYERC_MODULATION:
654 case PROP_ISDBT_LAYERC_SEGMENT_COUNT:
655 case PROP_ISDBT_LAYERC_TIME_INTERLEAVING:
656 case PROP_LNB_SLOF:
657 case PROP_LNB_LOF1:
658 case PROP_LNB_LOF2:
659 case PROP_INTERLEAVING:
660 /* FIXME: check if we can tune (state < PLAYING || program-numbers == "") */
661 g_object_set_property (G_OBJECT (dvbbasebin->dvbsrc), pspec->name, value);
662 break;
663 case PROP_PROGRAM_NUMBERS:
664 dvb_base_bin_set_program_numbers (dvbbasebin, g_value_get_string (value));
665 break;
666 default:
667 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
668 }
669 }
670
671 static void
dvb_base_bin_get_property(GObject * object,guint prop_id,GValue * value,GParamSpec * pspec)672 dvb_base_bin_get_property (GObject * object, guint prop_id,
673 GValue * value, GParamSpec * pspec)
674 {
675 DvbBaseBin *dvbbasebin = GST_DVB_BASE_BIN (object);
676
677 switch (prop_id) {
678 case PROP_ADAPTER:
679 case PROP_FRONTEND:
680 case PROP_DISEQC_SRC:
681 case PROP_FREQUENCY:
682 case PROP_POLARITY:
683 case PROP_SYMBOL_RATE:
684 case PROP_BANDWIDTH:
685 case PROP_CODE_RATE_HP:
686 case PROP_CODE_RATE_LP:
687 case PROP_GUARD:
688 case PROP_MODULATION:
689 case PROP_TRANS_MODE:
690 case PROP_HIERARCHY:
691 case PROP_INVERSION:
692 case PROP_STATS_REPORTING_INTERVAL:
693 case PROP_TUNING_TIMEOUT:
694 case PROP_DELSYS:
695 case PROP_PILOT:
696 case PROP_ROLLOFF:
697 case PROP_STREAM_ID:
698 case PROP_BANDWIDTH_HZ:
699 case PROP_ISDBT_LAYER_ENABLED:
700 case PROP_ISDBT_PARTIAL_RECEPTION:
701 case PROP_ISDBT_SOUND_BROADCASTING:
702 case PROP_ISDBT_SB_SUBCHANNEL_ID:
703 case PROP_ISDBT_SB_SEGMENT_IDX:
704 case PROP_ISDBT_SB_SEGMENT_COUNT:
705 case PROP_ISDBT_LAYERA_FEC:
706 case PROP_ISDBT_LAYERA_MODULATION:
707 case PROP_ISDBT_LAYERA_SEGMENT_COUNT:
708 case PROP_ISDBT_LAYERA_TIME_INTERLEAVING:
709 case PROP_ISDBT_LAYERB_FEC:
710 case PROP_ISDBT_LAYERB_MODULATION:
711 case PROP_ISDBT_LAYERB_SEGMENT_COUNT:
712 case PROP_ISDBT_LAYERB_TIME_INTERLEAVING:
713 case PROP_ISDBT_LAYERC_FEC:
714 case PROP_ISDBT_LAYERC_MODULATION:
715 case PROP_ISDBT_LAYERC_SEGMENT_COUNT:
716 case PROP_ISDBT_LAYERC_TIME_INTERLEAVING:
717 case PROP_LNB_SLOF:
718 case PROP_LNB_LOF1:
719 case PROP_LNB_LOF2:
720 case PROP_INTERLEAVING:
721 g_object_get_property (G_OBJECT (dvbbasebin->dvbsrc), pspec->name, value);
722 break;
723 case PROP_PROGRAM_NUMBERS:
724 g_value_set_string (value, dvbbasebin->program_numbers);
725 break;
726 default:
727 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
728 }
729 }
730
731 static GstPad *
dvb_base_bin_request_new_pad(GstElement * element,GstPadTemplate * templ,const gchar * name,const GstCaps * caps)732 dvb_base_bin_request_new_pad (GstElement * element,
733 GstPadTemplate * templ, const gchar * name, const GstCaps * caps)
734 {
735 DvbBaseBin *dvbbasebin = GST_DVB_BASE_BIN (element);
736 GstPad *pad;
737 GstPad *ghost;
738 gchar *pad_name;
739
740 GST_DEBUG_OBJECT (dvbbasebin, "New pad requested %s", GST_STR_NULL (name));
741
742 if (dvbbasebin->tsparse == NULL)
743 return NULL;
744
745 if (name == NULL)
746 name = GST_PAD_TEMPLATE_NAME_TEMPLATE (templ);
747
748 pad = gst_element_get_request_pad (dvbbasebin->tsparse, name);
749 if (pad == NULL)
750 return NULL;
751
752 pad_name = gst_pad_get_name (pad);
753 ghost = gst_ghost_pad_new (pad_name, pad);
754 gst_object_unref (pad);
755 g_free (pad_name);
756 gst_element_add_pad (element, ghost);
757
758 return ghost;
759 }
760
761 static void
dvb_base_bin_release_pad(GstElement * element,GstPad * pad)762 dvb_base_bin_release_pad (GstElement * element, GstPad * pad)
763 {
764 GstGhostPad *ghost;
765 GstPad *target;
766
767 g_return_if_fail (GST_IS_DVB_BASE_BIN (element));
768
769 ghost = GST_GHOST_PAD (pad);
770 target = gst_ghost_pad_get_target (ghost);
771 gst_element_release_request_pad (GST_ELEMENT (GST_DVB_BASE_BIN
772 (element)->tsparse), target);
773 gst_object_unref (target);
774
775 gst_element_remove_pad (element, pad);
776 }
777
778 static void
dvb_base_bin_reset_pmtlist(DvbBaseBin * dvbbasebin)779 dvb_base_bin_reset_pmtlist (DvbBaseBin * dvbbasebin)
780 {
781 CamConditionalAccessPmtFlag flag;
782 GList *walk;
783 GstMpegtsPMT *pmt;
784
785 walk = dvbbasebin->pmtlist;
786 while (walk) {
787 if (walk->prev == NULL) {
788 if (walk->next == NULL)
789 flag = CAM_CONDITIONAL_ACCESS_PMT_FLAG_ONLY;
790 else
791 flag = CAM_CONDITIONAL_ACCESS_PMT_FLAG_FIRST;
792 } else {
793 if (walk->next == NULL)
794 flag = CAM_CONDITIONAL_ACCESS_PMT_FLAG_LAST;
795 else
796 flag = CAM_CONDITIONAL_ACCESS_PMT_FLAG_MORE;
797 }
798
799 pmt = (GstMpegtsPMT *) walk->data;
800 cam_device_set_pmt (dvbbasebin->hwcam, pmt, flag);
801
802 walk = walk->next;
803 }
804
805 dvbbasebin->pmtlist_changed = FALSE;
806 }
807
808 static void
dvb_base_bin_init_cam(DvbBaseBin * dvbbasebin)809 dvb_base_bin_init_cam (DvbBaseBin * dvbbasebin)
810 {
811 gint adapter;
812 gchar *ca_file;
813
814 g_object_get (dvbbasebin->dvbsrc, "adapter", &adapter, NULL);
815 /* TODO: handle multiple cams */
816 ca_file = g_strdup_printf ("/dev/dvb/adapter%d/ca0", adapter);
817 if (g_file_test (ca_file, G_FILE_TEST_EXISTS)) {
818 dvbbasebin->hwcam = cam_device_new ();
819 /* device_open() can block up to 5s ! */
820 if (!cam_device_open (dvbbasebin->hwcam, ca_file)) {
821 GST_ERROR_OBJECT (dvbbasebin, "could not open %s", ca_file);
822 cam_device_free (dvbbasebin->hwcam);
823 dvbbasebin->hwcam = NULL;
824 }
825 }
826
827 dvbbasebin->trycam = FALSE;
828
829 g_free (ca_file);
830 }
831
832 static GstStateChangeReturn
dvb_base_bin_change_state(GstElement * element,GstStateChange transition)833 dvb_base_bin_change_state (GstElement * element, GstStateChange transition)
834 {
835 DvbBaseBin *dvbbasebin;
836 GstStateChangeReturn ret;
837
838 dvbbasebin = GST_DVB_BASE_BIN (element);
839
840 switch (transition) {
841 case GST_STATE_CHANGE_NULL_TO_READY:
842 if (dvbbasebin->tsparse == NULL) {
843 GST_ELEMENT_ERROR (dvbbasebin, CORE, MISSING_PLUGIN, (NULL),
844 ("No 'tsparse' element, check your GStreamer installation."));
845 return GST_STATE_CHANGE_FAILURE;
846 }
847 break;
848 default:
849 break;
850 }
851
852 ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
853
854 switch (transition) {
855 case GST_STATE_CHANGE_READY_TO_PAUSED:
856 gst_poll_set_flushing (dvbbasebin->poll, FALSE);
857 g_rec_mutex_lock (&dvbbasebin->lock);
858 gst_task_start (dvbbasebin->task);
859 g_rec_mutex_unlock (&dvbbasebin->lock);
860 break;
861 case GST_STATE_CHANGE_PAUSED_TO_READY:
862 gst_poll_set_flushing (dvbbasebin->poll, TRUE);
863 g_rec_mutex_lock (&dvbbasebin->lock);
864 gst_task_stop (dvbbasebin->task);
865 g_rec_mutex_unlock (&dvbbasebin->lock);
866 dvb_base_bin_reset (dvbbasebin);
867 break;
868 default:
869 break;
870 }
871
872 return ret;
873 }
874
875 static void
foreach_stream_build_filter(gpointer key,gpointer value,gpointer user_data)876 foreach_stream_build_filter (gpointer key, gpointer value, gpointer user_data)
877 {
878 DvbBaseBin *dvbbasebin = GST_DVB_BASE_BIN (user_data);
879 DvbBaseBinStream *stream = (DvbBaseBinStream *) value;
880 gchar *tmp, *pid;
881
882 GST_DEBUG ("stream %d usecount %d", stream->pid, stream->usecount);
883
884 if (stream->usecount > 0) {
885 /* TODO: use g_strjoinv FTW */
886 tmp = dvbbasebin->filter;
887 pid = g_strdup_printf ("%d", stream->pid);
888 dvbbasebin->filter = g_strjoin (":", pid, dvbbasebin->filter, NULL);
889
890 g_free (pid);
891 g_free (tmp);
892 }
893 }
894
895 static void
dvb_base_bin_rebuild_filter(DvbBaseBin * dvbbasebin)896 dvb_base_bin_rebuild_filter (DvbBaseBin * dvbbasebin)
897 {
898 g_hash_table_foreach (dvbbasebin->streams,
899 foreach_stream_build_filter, dvbbasebin);
900
901 if (dvbbasebin->filter == NULL)
902 /* fix dvbsrc to handle NULL filter */
903 dvbbasebin->filter = g_strdup ("");
904
905 GST_INFO_OBJECT (dvbbasebin, "rebuilt filter %s", dvbbasebin->filter);
906
907 /* FIXME: find a way to not add unwanted pids controlled by app */
908 g_object_set (dvbbasebin->dvbsrc, "pids", dvbbasebin->filter, NULL);
909 g_free (dvbbasebin->filter);
910 dvbbasebin->filter = NULL;
911 }
912
913 static void
dvb_base_bin_remove_pmt_streams(DvbBaseBin * dvbbasebin,const GstMpegtsPMT * pmt)914 dvb_base_bin_remove_pmt_streams (DvbBaseBin * dvbbasebin,
915 const GstMpegtsPMT * pmt)
916 {
917 gint i;
918 DvbBaseBinStream *stream;
919
920 for (i = 0; i < pmt->streams->len; i++) {
921 GstMpegtsPMTStream *pmtstream = g_ptr_array_index (pmt->streams, i);
922
923 stream = dvb_base_bin_get_stream (dvbbasebin, pmtstream->pid);
924 if (stream == NULL) {
925 GST_WARNING_OBJECT (dvbbasebin, "removing unknown stream %d ??",
926 pmtstream->pid);
927 continue;
928 }
929
930 dvb_base_bin_unref_stream (stream);
931 }
932 }
933
934 static void
dvb_base_bin_add_pmt_streams(DvbBaseBin * dvbbasebin,const GstMpegtsPMT * pmt)935 dvb_base_bin_add_pmt_streams (DvbBaseBin * dvbbasebin, const GstMpegtsPMT * pmt)
936 {
937 DvbBaseBinStream *stream;
938 gint i;
939
940 for (i = 0; i < pmt->streams->len; i++) {
941 GstMpegtsPMTStream *pmtstream = g_ptr_array_index (pmt->streams, i);
942
943 GST_DEBUG ("filtering stream %d stream_type %d", pmtstream->pid,
944 pmtstream->stream_type);
945
946 stream = dvb_base_bin_get_stream (dvbbasebin, pmtstream->pid);
947 if (stream == NULL)
948 stream = dvb_base_bin_add_stream (dvbbasebin, pmtstream->pid);
949 dvb_base_bin_ref_stream (stream);
950 }
951 }
952
953 static void
dvb_base_bin_activate_program(DvbBaseBin * dvbbasebin,DvbBaseBinProgram * program)954 dvb_base_bin_activate_program (DvbBaseBin * dvbbasebin,
955 DvbBaseBinProgram * program)
956 {
957 DvbBaseBinStream *stream;
958
959 if (program->old_pmt) {
960 dvb_base_bin_remove_pmt_streams (dvbbasebin, program->old_pmt);
961 dvbbasebin->pmtlist = g_list_remove (dvbbasebin->pmtlist, program->old_pmt);
962 }
963
964 /* activate the PMT and PCR streams. If the PCR stream is in the PMT its
965 * usecount will be incremented by 2 here and decremented by 2 when the
966 * program is deactivated */
967 if (!program->pmt_active) {
968 stream = dvb_base_bin_get_stream (dvbbasebin, program->pmt_pid);
969 if (stream == NULL)
970 stream = dvb_base_bin_add_stream (dvbbasebin, program->pmt_pid);
971 dvb_base_bin_ref_stream (stream);
972 program->pmt_active = TRUE;
973 }
974
975 if (program->pmt) {
976 guint16 old_pcr_pid;
977
978 old_pcr_pid = program->pcr_pid;
979 program->pcr_pid = program->pmt->pcr_pid;
980 if (old_pcr_pid != G_MAXUINT16 && old_pcr_pid != program->pcr_pid) {
981 dvb_base_bin_unref_stream (dvb_base_bin_get_stream (dvbbasebin,
982 old_pcr_pid));
983 }
984
985 stream = dvb_base_bin_get_stream (dvbbasebin, program->pcr_pid);
986 if (stream == NULL)
987 stream = dvb_base_bin_add_stream (dvbbasebin, program->pcr_pid);
988 dvb_base_bin_ref_stream (stream);
989
990 dvb_base_bin_add_pmt_streams (dvbbasebin, program->pmt);
991 dvbbasebin->pmtlist =
992 g_list_append (dvbbasebin->pmtlist, (gpointer) program->pmt);
993 dvbbasebin->pmtlist_changed = TRUE;
994 program->active = TRUE;
995 }
996
997 dvb_base_bin_rebuild_filter (dvbbasebin);
998 }
999
1000 static void
dvb_base_bin_deactivate_program(DvbBaseBin * dvbbasebin,DvbBaseBinProgram * program)1001 dvb_base_bin_deactivate_program (DvbBaseBin * dvbbasebin,
1002 DvbBaseBinProgram * program)
1003 {
1004 DvbBaseBinStream *stream;
1005
1006 stream = dvb_base_bin_get_stream (dvbbasebin, program->pmt_pid);
1007 if (stream != NULL) {
1008 dvb_base_bin_unref_stream (stream);
1009 }
1010
1011 stream = dvb_base_bin_get_stream (dvbbasebin, program->pcr_pid);
1012 if (stream != NULL) {
1013 dvb_base_bin_unref_stream (stream);
1014 }
1015
1016 if (program->pmt) {
1017 dvb_base_bin_remove_pmt_streams (dvbbasebin, program->pmt);
1018 dvbbasebin->pmtlist = g_list_remove (dvbbasebin->pmtlist, program->pmt);
1019 dvbbasebin->pmtlist_changed = TRUE;
1020 }
1021
1022 dvb_base_bin_rebuild_filter (dvbbasebin);
1023 program->pmt_active = FALSE;
1024 program->active = FALSE;
1025 }
1026
1027 static void
dvb_base_bin_handle_message(GstBin * bin,GstMessage * message)1028 dvb_base_bin_handle_message (GstBin * bin, GstMessage * message)
1029 {
1030 DvbBaseBin *dvbbasebin;
1031
1032 dvbbasebin = GST_DVB_BASE_BIN (bin);
1033
1034 /* note: message->src might be a GstPad, so use element cast w/o typecheck */
1035 if (GST_ELEMENT_CAST (message->src) == dvbbasebin->tsparse) {
1036 GstMpegtsSection *section = gst_message_parse_mpegts_section (message);
1037
1038 if (section) {
1039 switch (GST_MPEGTS_SECTION_TYPE (section)) {
1040 case GST_MPEGTS_SECTION_PAT:
1041 dvb_base_bin_pat_info_cb (dvbbasebin, section);
1042 break;
1043 case GST_MPEGTS_SECTION_PMT:
1044 dvb_base_bin_pmt_info_cb (dvbbasebin, section);
1045 break;
1046 default:
1047 break;
1048 }
1049 gst_mpegts_section_unref (section);
1050 }
1051 }
1052
1053 /* chain up */
1054 GST_BIN_CLASS (parent_class)->handle_message (bin, message);
1055 }
1056
1057
1058
1059 static void
dvb_base_bin_pat_info_cb(DvbBaseBin * dvbbasebin,GstMpegtsSection * section)1060 dvb_base_bin_pat_info_cb (DvbBaseBin * dvbbasebin, GstMpegtsSection * section)
1061 {
1062 GPtrArray *pat;
1063 DvbBaseBinProgram *program;
1064 DvbBaseBinStream *stream;
1065 guint old_pmt_pid;
1066 gint i;
1067 gboolean rebuild_filter = FALSE;
1068
1069 if (!(pat = gst_mpegts_section_get_pat (section))) {
1070 GST_WARNING_OBJECT (dvbbasebin, "got invalid PAT");
1071 return;
1072 }
1073
1074 for (i = 0; i < pat->len; i++) {
1075 GstMpegtsPatProgram *patp = g_ptr_array_index (pat, i);
1076
1077 program = dvb_base_bin_get_program (dvbbasebin, patp->program_number);
1078 if (program == NULL)
1079 program = dvb_base_bin_add_program (dvbbasebin, patp->program_number);
1080
1081 old_pmt_pid = program->pmt_pid;
1082 program->pmt_pid = patp->network_or_program_map_PID;
1083
1084 if (program->selected) {
1085 /* PAT update */
1086 if (old_pmt_pid != G_MAXUINT16 && old_pmt_pid != program->pmt_pid) {
1087 dvb_base_bin_unref_stream (dvb_base_bin_get_stream (dvbbasebin,
1088 old_pmt_pid));
1089 }
1090
1091 stream = dvb_base_bin_get_stream (dvbbasebin, program->pmt_pid);
1092 if (stream == NULL)
1093 stream = dvb_base_bin_add_stream (dvbbasebin, program->pmt_pid);
1094
1095 dvb_base_bin_ref_stream (stream);
1096
1097 rebuild_filter = TRUE;
1098 }
1099 }
1100 g_ptr_array_unref (pat);
1101
1102 if (rebuild_filter)
1103 dvb_base_bin_rebuild_filter (dvbbasebin);
1104 }
1105
1106 static void
dvb_base_bin_pmt_info_cb(DvbBaseBin * dvbbasebin,GstMpegtsSection * section)1107 dvb_base_bin_pmt_info_cb (DvbBaseBin * dvbbasebin, GstMpegtsSection * section)
1108 {
1109 const GstMpegtsPMT *pmt;
1110 DvbBaseBinProgram *program;
1111 guint program_number;
1112
1113 pmt = gst_mpegts_section_get_pmt (section);
1114 if (G_UNLIKELY (pmt == NULL)) {
1115 GST_WARNING_OBJECT (dvbbasebin, "Received invalid PMT");
1116 return;
1117 }
1118
1119 program_number = section->subtable_extension;
1120
1121 program = dvb_base_bin_get_program (dvbbasebin, program_number);
1122 if (program == NULL) {
1123 GST_WARNING ("got PMT for program %d but program not in PAT",
1124 program_number);
1125 program = dvb_base_bin_add_program (dvbbasebin, program_number);
1126 }
1127
1128 program->old_pmt = program->pmt;
1129 program->old_section = program->section;
1130 program->pmt = pmt;
1131 program->section = gst_mpegts_section_ref (section);
1132
1133 /* activate the program if it's selected and either it's not active or its pmt
1134 * changed */
1135 if (program->selected && (!program->active || program->old_pmt != NULL))
1136 dvb_base_bin_activate_program (dvbbasebin, program);
1137
1138 if (program->old_pmt) {
1139 gst_mpegts_section_unref (program->old_section);
1140 program->old_pmt = NULL;
1141 }
1142 }
1143
1144 static guint
dvb_base_bin_uri_get_type(GType type)1145 dvb_base_bin_uri_get_type (GType type)
1146 {
1147 return GST_URI_SRC;
1148 }
1149
1150 static const gchar *const *
dvb_base_bin_uri_get_protocols(GType type)1151 dvb_base_bin_uri_get_protocols (GType type)
1152 {
1153 static const gchar *protocols[] = { "dvb", NULL };
1154
1155 return protocols;
1156 }
1157
1158 static gchar *
dvb_base_bin_uri_get_uri(GstURIHandler * handler)1159 dvb_base_bin_uri_get_uri (GstURIHandler * handler)
1160 {
1161 return g_strdup ("dvb://");
1162 }
1163
1164 static gboolean
dvb_base_bin_uri_set_uri(GstURIHandler * handler,const gchar * uri,GError ** error)1165 dvb_base_bin_uri_set_uri (GstURIHandler * handler, const gchar * uri,
1166 GError ** error)
1167 {
1168 DvbBaseBin *dvbbasebin = GST_DVB_BASE_BIN (handler);
1169 GError *err = NULL;
1170 gchar *location;
1171
1172 location = gst_uri_get_location (uri);
1173
1174 if (location == NULL)
1175 goto no_location;
1176
1177 /* FIXME: here is where we parse channels.conf */
1178 if (!set_properties_for_channel (GST_ELEMENT (dvbbasebin), location, &err))
1179 goto set_properties_failed;
1180
1181 g_free (location);
1182 return TRUE;
1183
1184 post_error_and_exit:
1185 {
1186 gst_element_message_full (GST_ELEMENT (dvbbasebin), GST_MESSAGE_ERROR,
1187 err->domain, err->code, g_strdup (err->message), NULL, __FILE__,
1188 GST_FUNCTION, __LINE__);
1189 g_propagate_error (error, err);
1190 return FALSE;
1191 }
1192 no_location:
1193 {
1194 g_set_error (&err, GST_URI_ERROR, GST_URI_ERROR_BAD_URI,
1195 "No details to DVB URI");
1196 goto post_error_and_exit;
1197 }
1198 set_properties_failed:
1199 {
1200 g_free (location);
1201 if (!err)
1202 g_set_error (&err, GST_URI_ERROR, GST_URI_ERROR_BAD_REFERENCE,
1203 "Could not find information for channel");
1204 goto post_error_and_exit;
1205 }
1206 }
1207
1208 static void
dvb_base_bin_uri_handler_init(gpointer g_iface,gpointer iface_data)1209 dvb_base_bin_uri_handler_init (gpointer g_iface, gpointer iface_data)
1210 {
1211 GstURIHandlerInterface *iface = (GstURIHandlerInterface *) g_iface;
1212
1213 iface->get_type = dvb_base_bin_uri_get_type;
1214 iface->get_protocols = dvb_base_bin_uri_get_protocols;
1215 iface->get_uri = dvb_base_bin_uri_get_uri;
1216 iface->set_uri = dvb_base_bin_uri_set_uri;
1217 }
1218
1219 gboolean
gst_dvb_base_bin_plugin_init(GstPlugin * plugin)1220 gst_dvb_base_bin_plugin_init (GstPlugin * plugin)
1221 {
1222 GST_DEBUG_CATEGORY_INIT (dvb_base_bin_debug, "dvbbasebin", 0, "DVB bin");
1223
1224 cam_init ();
1225
1226 return gst_element_register (plugin, "dvbbasebin",
1227 GST_RANK_NONE, GST_TYPE_DVB_BASE_BIN);
1228 }
1229
1230 static void
dvb_base_bin_program_destroy(gpointer data)1231 dvb_base_bin_program_destroy (gpointer data)
1232 {
1233 DvbBaseBinProgram *program;
1234
1235 program = (DvbBaseBinProgram *) data;
1236
1237 if (program->pmt) {
1238 program->pmt = NULL;
1239 gst_mpegts_section_unref (program->section);
1240 }
1241
1242 g_free (program);
1243 }
1244
1245 static void
dvb_base_bin_task(DvbBaseBin * basebin)1246 dvb_base_bin_task (DvbBaseBin * basebin)
1247 {
1248 gint pollres;
1249
1250 GST_DEBUG_OBJECT (basebin, "In task");
1251
1252 /* If we haven't tried to open the cam, try now */
1253 if (G_UNLIKELY (basebin->trycam))
1254 dvb_base_bin_init_cam (basebin);
1255
1256 /* poll with timeout */
1257 pollres = gst_poll_wait (basebin->poll, GST_SECOND / 4);
1258
1259 if (G_UNLIKELY (pollres == -1)) {
1260 gst_task_stop (basebin->task);
1261 return;
1262 }
1263 if (basebin->hwcam) {
1264 cam_device_poll (basebin->hwcam);
1265
1266 if (basebin->pmtlist_changed) {
1267 if (cam_device_ready (basebin->hwcam)) {
1268 GST_DEBUG_OBJECT (basebin, "pmt list changed");
1269 dvb_base_bin_reset_pmtlist (basebin);
1270 } else {
1271 GST_DEBUG_OBJECT (basebin, "pmt list changed but CAM not ready");
1272 }
1273 }
1274 }
1275 }
1276