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   gst_object_unref(pad);
 764
 765   return ghost;
 766 }
 767
 768 static void
 769 dvb_base_bin_release_pad (GstElement * element, GstPad * pad)
 770 {
 771   GstGhostPad *ghost;
 772   GstPad *target;
 773
 774   g_return_if_fail (GST_IS_DVB_BASE_BIN (element));
 775
 776   ghost = GST_GHOST_PAD (pad);
 777   target = gst_ghost_pad_get_target (ghost);
 778   gst_element_release_request_pad (GST_ELEMENT (GST_DVB_BASE_BIN
 779           (element)->tsparse), target);
 780   gst_object_unref (target);
 781
 782   gst_element_remove_pad (element, pad);
 783 }
 784
 785 static void
 786 dvb_base_bin_reset_pmtlist (DvbBaseBin * dvbbasebin)
 787 {
 788   CamConditionalAccessPmtFlag flag;
 789   GList *walk;
 790   GstMpegtsPMT *pmt;
 791
 792   walk = dvbbasebin->pmtlist;
 793   while (walk) {
 794     if (walk->prev == NULL) {
 795       if (walk->next == NULL)
 796         flag = CAM_CONDITIONAL_ACCESS_PMT_FLAG_ONLY;
 797       else
 798         flag = CAM_CONDITIONAL_ACCESS_PMT_FLAG_FIRST;
 799     } else {
 800       if (walk->next == NULL)
 801         flag = CAM_CONDITIONAL_ACCESS_PMT_FLAG_LAST;
 802       else
 803         flag = CAM_CONDITIONAL_ACCESS_PMT_FLAG_MORE;
 804     }
 805
 806     pmt = (GstMpegtsPMT *) walk->data;
 807     cam_device_set_pmt (dvbbasebin->hwcam, pmt, flag);
 808
 809     walk = walk->next;
 810   }
 811
 812   dvbbasebin->pmtlist_changed = FALSE;
 813 }
 814
 815 static void
 816 dvb_base_bin_init_cam (DvbBaseBin * dvbbasebin)
 817 {
 818   gint adapter;
 819   gchar *ca_file;
 820
 821   g_object_get (dvbbasebin->dvbsrc, "adapter", &adapter, NULL);
 822   /* TODO: handle multiple cams */
 823   ca_file = g_strdup_printf ("/dev/dvb/adapter%d/ca0", adapter);
 824   if (g_file_test (ca_file, G_FILE_TEST_EXISTS)) {
 825     dvbbasebin->hwcam = cam_device_new ();
 826     /* device_open() can block up to 5s ! */
 827     if (!cam_device_open (dvbbasebin->hwcam, ca_file)) {
 828       GST_ERROR_OBJECT (dvbbasebin, "could not open %s", ca_file);
 829       cam_device_free (dvbbasebin->hwcam);
 830       dvbbasebin->hwcam = NULL;
 831     }
 832   }
 833
 834   dvbbasebin->trycam = FALSE;
 835
 836   g_free (ca_file);
 837 }
 838
 839 static GstStateChangeReturn
 840 dvb_base_bin_change_state (GstElement * element, GstStateChange transition)
 841 {
 842   DvbBaseBin *dvbbasebin;
 843   GstStateChangeReturn ret;
 844
 845   dvbbasebin = GST_DVB_BASE_BIN (element);
 846
 847   switch (transition) {
 848     case GST_STATE_CHANGE_NULL_TO_READY:
 849       if (dvbbasebin->tsparse == NULL) {
 850         GST_ELEMENT_ERROR (dvbbasebin, CORE, MISSING_PLUGIN, (NULL),
 851             ("No 'tsparse' element, check your GStreamer installation."));
 852         return GST_STATE_CHANGE_FAILURE;
 853       }
 854       break;
 855     default:
 856       break;
 857   }
 858
 859   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
 860
 861   switch (transition) {
 862     case GST_STATE_CHANGE_READY_TO_PAUSED:
 863       gst_poll_set_flushing (dvbbasebin->poll, FALSE);
 864       g_rec_mutex_lock (&dvbbasebin->lock);
 865       gst_task_start (dvbbasebin->task);
 866       g_rec_mutex_unlock (&dvbbasebin->lock);
 867       break;
 868     case GST_STATE_CHANGE_PAUSED_TO_READY:
 869       gst_poll_set_flushing (dvbbasebin->poll, TRUE);
 870       g_rec_mutex_lock (&dvbbasebin->lock);
 871       gst_task_stop (dvbbasebin->task);
 872       g_rec_mutex_unlock (&dvbbasebin->lock);
 873       dvb_base_bin_reset (dvbbasebin);
 874       break;
 875     default:
 876       break;
 877   }
 878
 879   return ret;
 880 }
 881
 882 static void
 883 foreach_stream_build_filter (gpointer key, gpointer value, gpointer user_data)
 884 {
 885   DvbBaseBin *dvbbasebin = GST_DVB_BASE_BIN (user_data);
 886   DvbBaseBinStream *stream = (DvbBaseBinStream *) value;
 887   gchar *tmp, *pid;
 888
 889   GST_DEBUG ("stream %d usecount %d", stream->pid, stream->usecount);
 890
 891   if (stream->usecount > 0) {
 892     /* TODO: use g_strjoinv FTW */
 893     tmp = dvbbasebin->filter;
 894     pid = g_strdup_printf ("%d", stream->pid);
 895     dvbbasebin->filter = g_strjoin (":", pid, dvbbasebin->filter, NULL);
 896
 897     g_free (pid);
 898     g_free (tmp);
 899   }
 900 }
 901
 902 static void
 903 dvb_base_bin_rebuild_filter (DvbBaseBin * dvbbasebin)
 904 {
 905   g_hash_table_foreach (dvbbasebin->streams,
 906       foreach_stream_build_filter, dvbbasebin);
 907
 908   if (dvbbasebin->filter == NULL)
 909     /* fix dvbsrc to handle NULL filter */
 910     dvbbasebin->filter = g_strdup ("");
 911
 912   GST_INFO_OBJECT (dvbbasebin, "rebuilt filter %s", dvbbasebin->filter);
 913
 914   /* FIXME: find a way to not add unwanted pids controlled by app */
 915   g_object_set (dvbbasebin->dvbsrc, "pids", dvbbasebin->filter, NULL);
 916   g_free (dvbbasebin->filter);
 917   dvbbasebin->filter = NULL;
 918 }
 919
 920 static void
 921 dvb_base_bin_remove_pmt_streams (DvbBaseBin * dvbbasebin,
 922     const GstMpegtsPMT * pmt)
 923 {
 924   gint i;
 925   DvbBaseBinStream *stream;
 926
 927   for (i = 0; i < pmt->streams->len; i++) {
 928     GstMpegtsPMTStream *pmtstream = g_ptr_array_index (pmt->streams, i);
 929
 930     stream = dvb_base_bin_get_stream (dvbbasebin, pmtstream->pid);
 931     if (stream == NULL) {
 932       GST_WARNING_OBJECT (dvbbasebin, "removing unknown stream %d ??",
 933           pmtstream->pid);
 934       continue;
 935     }
 936
 937     dvb_base_bin_unref_stream (stream);
 938   }
 939 }
 940
 941 static void
 942 dvb_base_bin_add_pmt_streams (DvbBaseBin * dvbbasebin, const GstMpegtsPMT * pmt)
 943 {
 944   DvbBaseBinStream *stream;
 945   gint i;
 946
 947   for (i = 0; i < pmt->streams->len; i++) {
 948     GstMpegtsPMTStream *pmtstream = g_ptr_array_index (pmt->streams, i);
 949
 950     GST_DEBUG ("filtering stream %d stream_type %d", pmtstream->pid,
 951         pmtstream->stream_type);
 952
 953     stream = dvb_base_bin_get_stream (dvbbasebin, pmtstream->pid);
 954     if (stream == NULL)
 955       stream = dvb_base_bin_add_stream (dvbbasebin, pmtstream->pid);
 956     dvb_base_bin_ref_stream (stream);
 957   }
 958 }
 959
 960 static void
 961 dvb_base_bin_activate_program (DvbBaseBin * dvbbasebin,
 962     DvbBaseBinProgram * program)
 963 {
 964   DvbBaseBinStream *stream;
 965
 966   if (program->old_pmt) {
 967     dvb_base_bin_remove_pmt_streams (dvbbasebin, program->old_pmt);
 968     dvbbasebin->pmtlist = g_list_remove (dvbbasebin->pmtlist, program->old_pmt);
 969   }
 970
 971   /* activate the PMT and PCR streams. If the PCR stream is in the PMT its
 972    * usecount will be incremented by 2 here and decremented by 2 when the
 973    * program is deactivated */
 974   if (!program->pmt_active) {
 975     stream = dvb_base_bin_get_stream (dvbbasebin, program->pmt_pid);
 976     if (stream == NULL)
 977       stream = dvb_base_bin_add_stream (dvbbasebin, program->pmt_pid);
 978     dvb_base_bin_ref_stream (stream);
 979     program->pmt_active = TRUE;
 980   }
 981
 982   if (program->pmt) {
 983     guint16 old_pcr_pid;
 984
 985     old_pcr_pid = program->pcr_pid;
 986     program->pcr_pid = program->pmt->pcr_pid;
 987     if (old_pcr_pid != G_MAXUINT16 && old_pcr_pid != program->pcr_pid) {
 988       dvb_base_bin_unref_stream (dvb_base_bin_get_stream (dvbbasebin,
 989               old_pcr_pid));
 990     }
 991
 992     stream = dvb_base_bin_get_stream (dvbbasebin, program->pcr_pid);
 993     if (stream == NULL)
 994       stream = dvb_base_bin_add_stream (dvbbasebin, program->pcr_pid);
 995     dvb_base_bin_ref_stream (stream);
 996
 997     dvb_base_bin_add_pmt_streams (dvbbasebin, program->pmt);
 998     dvbbasebin->pmtlist =
 999         g_list_append (dvbbasebin->pmtlist, (gpointer) program->pmt);
1000     dvbbasebin->pmtlist_changed = TRUE;
1001     program->active = TRUE;
1002   }
1003
1004   dvb_base_bin_rebuild_filter (dvbbasebin);
1005 }
1006
1007 static void
1008 dvb_base_bin_deactivate_program (DvbBaseBin * dvbbasebin,
1009     DvbBaseBinProgram * program)
1010 {
1011   DvbBaseBinStream *stream;
1012
1013   stream = dvb_base_bin_get_stream (dvbbasebin, program->pmt_pid);
1014   if (stream != NULL) {
1015     dvb_base_bin_unref_stream (stream);
1016   }
1017
1018   stream = dvb_base_bin_get_stream (dvbbasebin, program->pcr_pid);
1019   if (stream != NULL) {
1020     dvb_base_bin_unref_stream (stream);
1021   }
1022
1023   if (program->pmt) {
1024     dvb_base_bin_remove_pmt_streams (dvbbasebin, program->pmt);
1025     dvbbasebin->pmtlist = g_list_remove (dvbbasebin->pmtlist, program->pmt);
1026     dvbbasebin->pmtlist_changed = TRUE;
1027   }
1028
1029   dvb_base_bin_rebuild_filter (dvbbasebin);
1030   program->pmt_active = FALSE;
1031   program->active = FALSE;
1032 }
1033
1034 static void
1035 dvb_base_bin_handle_message (GstBin * bin, GstMessage * message)
1036 {
1037   DvbBaseBin *dvbbasebin;
1038
1039   dvbbasebin = GST_DVB_BASE_BIN (bin);
1040
1041   /* note: message->src might be a GstPad, so use element cast w/o typecheck */
1042   if (GST_ELEMENT_CAST (message->src) == dvbbasebin->tsparse) {
1043     GstMpegtsSection *section = gst_message_parse_mpegts_section (message);
1044
1045     if (section) {
1046       switch (GST_MPEGTS_SECTION_TYPE (section)) {
1047         case GST_MPEGTS_SECTION_PAT:
1048           dvb_base_bin_pat_info_cb (dvbbasebin, section);
1049           break;
1050         case GST_MPEGTS_SECTION_PMT:
1051           dvb_base_bin_pmt_info_cb (dvbbasebin, section);
1052           break;
1053         default:
1054           break;
1055       }
1056       gst_mpegts_section_unref (section);
1057     }
1058   }
1059
1060   /* chain up */
1061   GST_BIN_CLASS (parent_class)->handle_message (bin, message);
1062 }
1063
1064
1065
1066 static void
1067 dvb_base_bin_pat_info_cb (DvbBaseBin * dvbbasebin, GstMpegtsSection * section)
1068 {
1069   GPtrArray *pat;
1070   DvbBaseBinProgram *program;
1071   DvbBaseBinStream *stream;
1072   guint old_pmt_pid;
1073   gint i;
1074   gboolean rebuild_filter = FALSE;
1075
1076   if (!(pat = gst_mpegts_section_get_pat (section))) {
1077     GST_WARNING_OBJECT (dvbbasebin, "got invalid PAT");
1078     return;
1079   }
1080
1081   for (i = 0; i < pat->len; i++) {
1082     GstMpegtsPatProgram *patp = g_ptr_array_index (pat, i);
1083
1084     program = dvb_base_bin_get_program (dvbbasebin, patp->program_number);
1085     if (program == NULL)
1086       program = dvb_base_bin_add_program (dvbbasebin, patp->program_number);
1087
1088     old_pmt_pid = program->pmt_pid;
1089     program->pmt_pid = patp->network_or_program_map_PID;
1090
1091     if (program->selected) {
1092       /* PAT update */
1093       if (old_pmt_pid != G_MAXUINT16 && old_pmt_pid != program->pmt_pid) {
1094         dvb_base_bin_unref_stream (dvb_base_bin_get_stream (dvbbasebin,
1095                 old_pmt_pid));
1096       }
1097
1098       stream = dvb_base_bin_get_stream (dvbbasebin, program->pmt_pid);
1099       if (stream == NULL)
1100         stream = dvb_base_bin_add_stream (dvbbasebin, program->pmt_pid);
1101
1102       dvb_base_bin_ref_stream (stream);
1103
1104       rebuild_filter = TRUE;
1105     }
1106   }
1107   g_ptr_array_unref (pat);
1108
1109   if (rebuild_filter)
1110     dvb_base_bin_rebuild_filter (dvbbasebin);
1111 }
1112
1113 static void
1114 dvb_base_bin_pmt_info_cb (DvbBaseBin * dvbbasebin, GstMpegtsSection * section)
1115 {
1116   const GstMpegtsPMT *pmt;
1117   DvbBaseBinProgram *program;
1118   guint program_number;
1119
1120   pmt = gst_mpegts_section_get_pmt (section);
1121   if (G_UNLIKELY (pmt == NULL)) {
1122     GST_WARNING_OBJECT (dvbbasebin, "Received invalid PMT");
1123     return;
1124   }
1125
1126   program_number = section->subtable_extension;
1127
1128   program = dvb_base_bin_get_program (dvbbasebin, program_number);
1129   if (program == NULL) {
1130     GST_WARNING ("got PMT for program %d but program not in PAT",
1131         program_number);
1132     program = dvb_base_bin_add_program (dvbbasebin, program_number);
1133   }
1134
1135   program->old_pmt = program->pmt;
1136   program->old_section = program->section;
1137   program->pmt = pmt;
1138   program->section = gst_mpegts_section_ref (section);
1139
1140   /* activate the program if it's selected and either it's not active or its pmt
1141    * changed */
1142   if (program->selected && (!program->active || program->old_pmt != NULL))
1143     dvb_base_bin_activate_program (dvbbasebin, program);
1144
1145   if (program->old_pmt) {
1146     gst_mpegts_section_unref (program->old_section);
1147     program->old_pmt = NULL;
1148   }
1149 }
1150
1151 static guint
1152 dvb_base_bin_uri_get_type (GType type)
1153 {
1154   return GST_URI_SRC;
1155 }
1156
1157 static const gchar *const *
1158 dvb_base_bin_uri_get_protocols (GType type)
1159 {
1160   static const gchar *protocols[] = { "dvb", NULL };
1161
1162   return protocols;
1163 }
1164
1165 static gchar *
1166 dvb_base_bin_uri_get_uri (GstURIHandler * handler)
1167 {
1168   return g_strdup ("dvb://");
1169 }
1170
1171 static gboolean
1172 dvb_base_bin_uri_set_uri (GstURIHandler * handler, const gchar * uri,
1173     GError ** error)
1174 {
1175   DvbBaseBin *dvbbasebin = GST_DVB_BASE_BIN (handler);
1176   GError *err = NULL;
1177   gchar *location;
1178
1179   location = gst_uri_get_location (uri);
1180
1181   if (location == NULL)
1182     goto no_location;
1183
1184   /* FIXME: here is where we parse channels.conf */
1185   if (!set_properties_for_channel (GST_ELEMENT (dvbbasebin), location, &err))
1186     goto set_properties_failed;
1187
1188   g_free (location);
1189   return TRUE;
1190
1191 post_error_and_exit:
1192   {
1193     gst_element_message_full (GST_ELEMENT (dvbbasebin), GST_MESSAGE_ERROR,
1194         err->domain, err->code, g_strdup (err->message), NULL, __FILE__,
1195         GST_FUNCTION, __LINE__);
1196     g_propagate_error (error, err);
1197     return FALSE;
1198   }
1199 no_location:
1200   {
1201     g_set_error (&err, GST_URI_ERROR, GST_URI_ERROR_BAD_URI,
1202         "No details to DVB URI");
1203     goto post_error_and_exit;
1204   }
1205 set_properties_failed:
1206   {
1207     g_free (location);
1208     if (!err)
1209       g_set_error (&err, GST_URI_ERROR, GST_URI_ERROR_BAD_REFERENCE,
1210           "Could not find information for channel");
1211     goto post_error_and_exit;
1212   }
1213 }
1214
1215 static void
1216 dvb_base_bin_uri_handler_init (gpointer g_iface, gpointer iface_data)
1217 {
1218   GstURIHandlerInterface *iface = (GstURIHandlerInterface *) g_iface;
1219
1220   iface->get_type = dvb_base_bin_uri_get_type;
1221   iface->get_protocols = dvb_base_bin_uri_get_protocols;
1222   iface->get_uri = dvb_base_bin_uri_get_uri;
1223   iface->set_uri = dvb_base_bin_uri_set_uri;
1224 }
1225
1226
1227 static void
1228 dvb_base_bin_program_destroy (gpointer data)
1229 {
1230   DvbBaseBinProgram *program;
1231
1232   program = (DvbBaseBinProgram *) data;
1233
1234   if (program->pmt) {
1235     program->pmt = NULL;
1236     gst_mpegts_section_unref (program->section);
1237   }
1238
1239   g_free (program);
1240 }
1241
1242 static void
1243 dvb_base_bin_task (DvbBaseBin * basebin)
1244 {
1245   gint pollres;
1246
1247   GST_DEBUG_OBJECT (basebin, "In task");
1248
1249   /* If we haven't tried to open the cam, try now */
1250   if (G_UNLIKELY (basebin->trycam))
1251     dvb_base_bin_init_cam (basebin);
1252
1253   /* poll with timeout */
1254   pollres = gst_poll_wait (basebin->poll, GST_SECOND / 4);
1255
1256   if (G_UNLIKELY (pollres == -1)) {
1257     gst_task_stop (basebin->task);
1258     return;
1259   }
1260   if (basebin->hwcam) {
1261     cam_device_poll (basebin->hwcam);
1262
1263     if (basebin->pmtlist_changed) {
1264       if (cam_device_ready (basebin->hwcam)) {
1265         GST_DEBUG_OBJECT (basebin, "pmt list changed");
1266         dvb_base_bin_reset_pmtlist (basebin);
1267       } else {
1268         GST_DEBUG_OBJECT (basebin, "pmt list changed but CAM not ready");
1269       }
1270     }
1271   }
1272 }