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