subprojects/gst-plugins-bad/sys/dvb/dvbbasebin.c

   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
 181 dvb_base_bin_ref_stream (DvbBaseBinStream * stream)
 182 {
 183   g_return_if_fail (stream != NULL);
 184   stream->usecount++;
 185 }
 186
 187 static void
 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 *
 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 *
 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 *
 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 *
 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
 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
 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
 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
 266 dvb_base_bin_do_tune (DvbBaseBin * dvbbasebin)
 267 {
 268   g_signal_emit_by_name (dvbbasebin->dvbsrc, "tune", NULL);
 269 }
 270
 271 static void
 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
 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
 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
 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
 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
 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
 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
 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 *
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
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
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
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
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
1151 dvb_base_bin_uri_get_type (GType type)
1152 {
1153   return GST_URI_SRC;
1154 }
1155
1156 static const gchar *const *
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 *
1165 dvb_base_bin_uri_get_uri (GstURIHandler * handler)
1166 {
1167   return g_strdup ("dvb://");
1168 }
1169
1170 static gboolean
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
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
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
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 }