/* GStreamer DVB source * Copyright (C) 2006 Zaheer Abbas Merali * Copyright (C) 2014 Samsung Electronics. All rights reserved. * @Author: Reynaldo H. Verdejo Pinochet * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public * License along with this library; if not, write to the * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, * Boston, MA 02110-1301, USA. */ /** * SECTION:element-dvbsrc * * dvbsrc can be used to capture media from DVB cards. Supported DTV * broadcasting standards include DVB-T/C/S, ATSC ,ISDB-T and DTMB. * * * Example launch line * |[ * gst-launch dvbsrc modulation="QAM 64" trans-mode=8k bandwidth=8 frequency=514000000 code-rate-lp=AUTO code-rate-hp=2/3 guard=4 hierarchy=0 ! mpegtsdemux name=demux ! queue max-size-buffers=0 max-size-time=0 ! mpeg2dec ! xvimagesink demux. ! queue max-size-buffers=0 max-size-time=0 ! mad ! alsasink * ]| Captures a full transport stream from DVB card 0 that is a DVB-T card at tuned frequency 514000000 Hz with other parameters as seen in the pipeline and renders the first TV program on the transport stream. * |[ * gst-launch dvbsrc modulation="QAM 64" trans-mode=8k bandwidth=8 frequency=514000000 code-rate-lp=AUTO code-rate-hp=2/3 guard=4 hierarchy=0 pids=100:256:257 ! mpegtsdemux name=demux ! queue max-size-buffers=0 max-size-time=0 ! mpeg2dec ! xvimagesink demux. ! queue max-size-buffers=0 max-size-time=0 ! mad ! alsasink * ]| Captures and renders a transport stream from DVB card 0 that is a DVB-T card for a program at tuned frequency 514000000 Hz with PMT PID 100 and elementary stream PIDs of 256, 257 with other parameters as seen in the pipeline. * |[ * gst-launch dvbsrc polarity="h" frequency=11302000 symbol-rate=27500 diseqc-source=0 pids=50:102:103 ! mpegtsdemux name=demux ! queue max-size-buffers=0 max-size-time=0 ! mpeg2dec ! xvimagesink demux. ! queue max-size-buffers=0 max-size-time=0 ! mad ! alsasink * ]| Captures and renders a transport stream from DVB card 0 that is a DVB-S card for a program at tuned frequency 11302000 kHz, symbol rate of 27500 kBd (kilo bauds) with PMT PID of 50 and elementary stream PIDs of 102 and 103. * |[ gst-launch dvbsrc frequency=515142857 guard=16 trans-mode="8k" isdbt-layer-enabled=7 isdbt-partial-reception=1 isdbt-layera-fec="2/3" isdbt-layera-modulation="QPSK" isdbt-layera-segment-count=1 isdbt-layera-time-interleaving=4 isdbt-layerb-fec="3/4" isdbt-layerb-modulation="qam-64" isdbt-layerb-segment-count=12 isdbt-layerb-time-interleaving=2 isdbt-layerc-fec="1/2" isdbt-layerc-modulation="qam-64" isdbt-layerc-segment-count=0 isdbt-layerc-time-interleaving=0 delsys="isdb-t" ! tsdemux ! "video/x-h264" ! h264parse ! queue ! avdec_h264 ! videoconvert ! queue ! autovideosink * ]| Captures and renders the video track of TV Paraíba HD (Globo affiliate) in Campina Grande, Brazil. This is an ISDB-T (Brazilian ISDB-Tb variant) broadcast. * */ /* * History of DVB_API_VERSION 5 minor changes * * API Addition/changes in reverse order (most recent first) * * Minor 10 (statistics properties) * DTV_STAT_* * FE_SCALE_* * * Minor 9 * DTV_LNA * LNA_AUTO * * Minor 8 * FE_CAN_MULTISTREAM * DTV_ISDBS_TS_ID_LEGACY (was DVB_ISDBS_TS_ID) * DTV_DVBT2_PLP_ID_LEGACY (was DVB_DVBT2_PLP_ID) * NO_STREAM_ID_FILTER * INTERLEAVING_AUTO * * Minor 7 (DTMB Support) * FEC_2_5 * QAM_4_NR * TRANSMISSION_MODE_C1 / _C3780 * GUARD_INTERVAL_PN420 / _PN595 / _PN945 * INTERLEAVING_NONE / _240 / _720 * DTV_INTERLEAVING * SYS_DTMB (Renamed from SYS_DMBTH but has safety #define) * * Minor 6 (ATSC-MH) * DTV_ATSCMH_* (for those not defined in later versions) * * Somewhere in between 5 and 6: * SYS_DVBC_ANNEX_A / _C (Safety #define for _AC => A) * * Minor 5 (Note : minimum version we support according to configure.ac) * DTV_ENUM_DELSYS */ /* We know we have at least DVB_API_VERSION >= 5 (minor 5) */ #define HAVE_V5_MINOR(minor) ((DVB_API_VERSION > 5) || \ (DVB_API_VERSION_MINOR >= (minor))) #ifdef HAVE_CONFIG_H #include "config.h" #endif #include "gstdvbsrc.h" #include #include #include #include #include #include #include #include #include #include "_stdint.h" #include #include #include #include #include /* Before 5.6 we map A to AC */ #if !HAVE_V5_MINOR(6) #define SYS_DVBC_ANNEX_A SYS_DVBC_ANNEX_AC #endif /* NO_STREAM_ID_FILTER introduced in minor 8 */ #ifndef NO_STREAM_ID_FILTER #define NO_STREAM_ID_FILTER (~0U) #endif /* DTV_STREAM_ID introduced in minor 8 (redefine) */ #ifndef DTV_STREAM_ID #define DTV_STREAM_ID DTV_ISDBS_TS_ID #endif GST_DEBUG_CATEGORY_STATIC (gstdvbsrc_debug); #define GST_CAT_DEFAULT (gstdvbsrc_debug) /** * Can't be greater than DTV_IOCTL_MAX_MSGS but we are * not using more than 25 for the largest use case (ISDB-T). * * Bump as needed. */ #define NUM_DTV_PROPS 25 /* Signals */ enum { SIGNAL_TUNING_START, SIGNAL_TUNING_DONE, SIGNAL_TUNING_FAIL, SIGNAL_TUNE, LAST_SIGNAL }; /* Arguments */ enum { ARG_0, ARG_DVBSRC_ADAPTER, ARG_DVBSRC_FRONTEND, ARG_DVBSRC_DISEQC_SRC, ARG_DVBSRC_FREQUENCY, ARG_DVBSRC_POLARITY, ARG_DVBSRC_PIDS, ARG_DVBSRC_SYM_RATE, ARG_DVBSRC_BANDWIDTH, ARG_DVBSRC_CODE_RATE_HP, ARG_DVBSRC_CODE_RATE_LP, ARG_DVBSRC_GUARD, ARG_DVBSRC_MODULATION, ARG_DVBSRC_TRANSMISSION_MODE, ARG_DVBSRC_HIERARCHY_INF, ARG_DVBSRC_TUNE, ARG_DVBSRC_INVERSION, ARG_DVBSRC_STATS_REPORTING_INTERVAL, ARG_DVBSRC_TIMEOUT, ARG_DVBSRC_TUNING_TIMEOUT, ARG_DVBSRC_DVB_BUFFER_SIZE, ARG_DVBSRC_DELSYS, ARG_DVBSRC_PILOT, ARG_DVBSRC_ROLLOFF, ARG_DVBSRC_STREAM_ID, ARG_DVBSRC_BANDWIDTH_HZ, ARG_DVBSRC_ISDBT_LAYER_ENABLED, ARG_DVBSRC_ISDBT_PARTIAL_RECEPTION, ARG_DVBSRC_ISDBT_SOUND_BROADCASTING, ARG_DVBSRC_ISDBT_SB_SUBCHANNEL_ID, ARG_DVBSRC_ISDBT_SB_SEGMENT_IDX, ARG_DVBSRC_ISDBT_SB_SEGMENT_COUNT, ARG_DVBSRC_ISDBT_LAYERA_FEC, ARG_DVBSRC_ISDBT_LAYERA_MODULATION, ARG_DVBSRC_ISDBT_LAYERA_SEGMENT_COUNT, ARG_DVBSRC_ISDBT_LAYERA_TIME_INTERLEAVING, ARG_DVBSRC_ISDBT_LAYERB_FEC, ARG_DVBSRC_ISDBT_LAYERB_MODULATION, ARG_DVBSRC_ISDBT_LAYERB_SEGMENT_COUNT, ARG_DVBSRC_ISDBT_LAYERB_TIME_INTERLEAVING, ARG_DVBSRC_ISDBT_LAYERC_FEC, ARG_DVBSRC_ISDBT_LAYERC_MODULATION, ARG_DVBSRC_ISDBT_LAYERC_SEGMENT_COUNT, ARG_DVBSRC_ISDBT_LAYERC_TIME_INTERLEAVING, ARG_DVBSRC_LNB_SLOF, ARG_DVBSRC_LNB_LOF1, ARG_DVBSRC_LNB_LOF2, ARG_DVBSRC_INTERLEAVING }; #define DEFAULT_ADAPTER 0 #define DEFAULT_FRONTEND 0 #define DEFAULT_DISEQC_SRC -1 /* disabled */ #define DEFAULT_FREQUENCY 0 #define DEFAULT_POLARITY "H" #define DEFAULT_PIDS "8192" /* Special value meaning 'all' PIDs */ #define DEFAULT_SYMBOL_RATE 0 #define DEFAULT_BANDWIDTH_HZ 8000000 #define DEFAULT_BANDWIDTH BANDWIDTH_8_MHZ #define DEFAULT_CODE_RATE_HP FEC_AUTO #define DEFAULT_CODE_RATE_LP FEC_1_2 #define DEFAULT_GUARD GUARD_INTERVAL_1_16 #define DEFAULT_MODULATION QAM_16 #define DEFAULT_TRANSMISSION_MODE TRANSMISSION_MODE_8K #define DEFAULT_HIERARCHY HIERARCHY_1 #define DEFAULT_INVERSION INVERSION_ON #define DEFAULT_STATS_REPORTING_INTERVAL 100 #define DEFAULT_TIMEOUT 1000000 /* 1 second */ #define DEFAULT_TUNING_TIMEOUT 10 * GST_SECOND /* 10 seconds */ #define DEFAULT_DVB_BUFFER_SIZE (10*188*1024) /* kernel default is 8192 */ #define DEFAULT_BUFFER_SIZE 8192 /* not a property */ #define DEFAULT_DELSYS SYS_UNDEFINED #define DEFAULT_PILOT PILOT_AUTO #define DEFAULT_ROLLOFF ROLLOFF_AUTO #define DEFAULT_STREAM_ID NO_STREAM_ID_FILTER #define DEFAULT_ISDBT_LAYER_ENABLED 7 #define DEFAULT_ISDBT_PARTIAL_RECEPTION 1 #define DEFAULT_ISDBT_SOUND_BROADCASTING 0 #define DEFAULT_ISDBT_SB_SUBCHANNEL_ID -1 #define DEFAULT_ISDBT_SB_SEGMENT_IDX 0 #define DEFAULT_ISDBT_SB_SEGMENT_COUNT 1 #define DEFAULT_ISDBT_LAYERA_FEC FEC_AUTO #define DEFAULT_ISDBT_LAYERA_MODULATION QAM_AUTO #define DEFAULT_ISDBT_LAYERA_SEGMENT_COUNT -1 #define DEFAULT_ISDBT_LAYERA_TIME_INTERLEAVING -1 #define DEFAULT_ISDBT_LAYERB_FEC FEC_AUTO #define DEFAULT_ISDBT_LAYERB_MODULATION QAM_AUTO #define DEFAULT_ISDBT_LAYERB_SEGMENT_COUNT -1 #define DEFAULT_ISDBT_LAYERB_TIME_INTERLEAVING -1 #define DEFAULT_ISDBT_LAYERC_FEC FEC_AUTO #define DEFAULT_ISDBT_LAYERC_MODULATION QAM_AUTO #define DEFAULT_ISDBT_LAYERC_SEGMENT_COUNT -1 #define DEFAULT_ISDBT_LAYERC_TIME_INTERLEAVING -1 #define DEFAULT_LNB_SLOF (11700*1000UL) #define DEFAULT_LNB_LOF1 (9750*1000UL) #define DEFAULT_LNB_LOF2 (10600*1000UL) #if HAVE_V5_MINOR(7) #define DEFAULT_INTERLEAVING INTERLEAVING_AUTO #else #define DEFAULT_INTERLEAVING 0 #endif static void gst_dvbsrc_output_frontend_stats (GstDvbSrc * src); #define GST_TYPE_DVBSRC_CODE_RATE (gst_dvbsrc_code_rate_get_type ()) static GType gst_dvbsrc_code_rate_get_type (void) { static GType dvbsrc_code_rate_type = 0; static GEnumValue code_rate_types[] = { {FEC_NONE, "NONE", "none"}, {FEC_1_2, "1/2", "1/2"}, {FEC_2_3, "2/3", "2/3"}, {FEC_3_4, "3/4", "3/4"}, {FEC_4_5, "4/5", "4/5"}, {FEC_5_6, "5/6", "5/6"}, {FEC_6_7, "6/7", "6/7"}, {FEC_7_8, "7/8", "7/8"}, {FEC_8_9, "8/9", "8/9"}, {FEC_AUTO, "AUTO", "auto"}, {FEC_3_5, "3/5", "3/5"}, {FEC_9_10, "9/10", "9/10"}, {FEC_2_5, "2/5", "2/5"}, {0, NULL, NULL}, }; if (!dvbsrc_code_rate_type) { dvbsrc_code_rate_type = g_enum_register_static ("GstDvbSrcCode_Rate", code_rate_types); } return dvbsrc_code_rate_type; } #define GST_TYPE_DVBSRC_MODULATION (gst_dvbsrc_modulation_get_type ()) static GType gst_dvbsrc_modulation_get_type (void) { static GType dvbsrc_modulation_type = 0; static GEnumValue modulation_types[] = { {QPSK, "QPSK", "qpsk"}, {QAM_16, "QAM 16", "qam-16"}, {QAM_32, "QAM 32", "qam-32"}, {QAM_64, "QAM 64", "qam-64"}, {QAM_128, "QAM 128", "qam-128"}, {QAM_256, "QAM 256", "qam-256"}, {QAM_AUTO, "AUTO", "auto"}, {VSB_8, "8VSB", "8vsb"}, {VSB_16, "16VSB", "16vsb"}, {PSK_8, "8PSK", "8psk"}, {APSK_16, "16APSK", "16apsk"}, {APSK_32, "32APSK", "32apsk"}, {DQPSK, "DQPSK", "dqpsk"}, {QAM_4_NR, "QAM 4 NR", "qam-4-nr"}, {0, NULL, NULL}, }; if (!dvbsrc_modulation_type) { dvbsrc_modulation_type = g_enum_register_static ("GstDvbSrcModulation", modulation_types); } return dvbsrc_modulation_type; } #define GST_TYPE_DVBSRC_TRANSMISSION_MODE (gst_dvbsrc_transmission_mode_get_type ()) static GType gst_dvbsrc_transmission_mode_get_type (void) { static GType dvbsrc_transmission_mode_type = 0; static GEnumValue transmission_mode_types[] = { {TRANSMISSION_MODE_2K, "2K", "2k"}, {TRANSMISSION_MODE_8K, "8K", "8k"}, {TRANSMISSION_MODE_AUTO, "AUTO", "auto"}, {TRANSMISSION_MODE_4K, "4K", "4k"}, {TRANSMISSION_MODE_1K, "1K", "1k"}, {TRANSMISSION_MODE_16K, "16K", "16k"}, {TRANSMISSION_MODE_32K, "32K", "32k"}, #if HAVE_V5_MINOR(7) {TRANSMISSION_MODE_C1, "C1", "c1"}, {TRANSMISSION_MODE_C3780, "C3780", "c3780"}, #endif {0, NULL, NULL}, }; if (!dvbsrc_transmission_mode_type) { dvbsrc_transmission_mode_type = g_enum_register_static ("GstDvbSrcTransmission_Mode", transmission_mode_types); } return dvbsrc_transmission_mode_type; } #define GST_TYPE_DVBSRC_BANDWIDTH (gst_dvbsrc_bandwidth_get_type ()) static GType gst_dvbsrc_bandwidth_get_type (void) { static GType dvbsrc_bandwidth_type = 0; static GEnumValue bandwidth_types[] = { {BANDWIDTH_8_MHZ, "8", "8"}, {BANDWIDTH_7_MHZ, "7", "7"}, {BANDWIDTH_6_MHZ, "6", "6"}, {BANDWIDTH_AUTO, "AUTO", "AUTO"}, {BANDWIDTH_5_MHZ, "5", "5"}, {BANDWIDTH_10_MHZ, "10", "10"}, {BANDWIDTH_1_712_MHZ, "1.712", "1.712"}, {0, NULL, NULL}, }; if (!dvbsrc_bandwidth_type) { dvbsrc_bandwidth_type = g_enum_register_static ("GstDvbSrcBandwidth", bandwidth_types); } return dvbsrc_bandwidth_type; } #define GST_TYPE_DVBSRC_GUARD (gst_dvbsrc_guard_get_type ()) static GType gst_dvbsrc_guard_get_type (void) { static GType dvbsrc_guard_type = 0; static GEnumValue guard_types[] = { {GUARD_INTERVAL_1_32, "32", "32"}, {GUARD_INTERVAL_1_16, "16", "16"}, {GUARD_INTERVAL_1_8, "8", "8"}, {GUARD_INTERVAL_1_4, "4", "4"}, {GUARD_INTERVAL_AUTO, "AUTO", "auto"}, {GUARD_INTERVAL_1_128, "128", "128"}, {GUARD_INTERVAL_19_128, "19/128", "19/128"}, {GUARD_INTERVAL_19_256, "19/256", "19/256"}, #if HAVE_V5_MINOR(7) {GUARD_INTERVAL_PN420, "PN420", "pn420"}, {GUARD_INTERVAL_PN595, "PN595", "pn595"}, {GUARD_INTERVAL_PN945, "PN945", "pn945"}, #endif {0, NULL, NULL}, }; if (!dvbsrc_guard_type) { dvbsrc_guard_type = g_enum_register_static ("GstDvbSrcGuard", guard_types); } return dvbsrc_guard_type; } #define GST_TYPE_DVBSRC_HIERARCHY (gst_dvbsrc_hierarchy_get_type ()) static GType gst_dvbsrc_hierarchy_get_type (void) { static GType dvbsrc_hierarchy_type = 0; static GEnumValue hierarchy_types[] = { {HIERARCHY_NONE, "NONE", "none"}, {HIERARCHY_1, "1", "1"}, {HIERARCHY_2, "2", "2"}, {HIERARCHY_4, "4", "4"}, {HIERARCHY_AUTO, "AUTO", "auto"}, {0, NULL, NULL}, }; if (!dvbsrc_hierarchy_type) { dvbsrc_hierarchy_type = g_enum_register_static ("GstDvbSrcHierarchy", hierarchy_types); } return dvbsrc_hierarchy_type; } #define GST_TYPE_DVBSRC_INVERSION (gst_dvbsrc_inversion_get_type ()) static GType gst_dvbsrc_inversion_get_type (void) { static GType dvbsrc_inversion_type = 0; static GEnumValue inversion_types[] = { {INVERSION_OFF, "OFF", "off"}, {INVERSION_ON, "ON", "on"}, {INVERSION_AUTO, "AUTO", "auto"}, {0, NULL, NULL}, }; if (!dvbsrc_inversion_type) { dvbsrc_inversion_type = g_enum_register_static ("GstDvbSrcInversion", inversion_types); } return dvbsrc_inversion_type; } #define GST_TYPE_DVBSRC_DELSYS (gst_dvbsrc_delsys_get_type ()) static GType gst_dvbsrc_delsys_get_type (void) { static GType dvbsrc_delsys_type = 0; static GEnumValue delsys_types[] = { {SYS_UNDEFINED, "UNDEFINED", "undefined"}, {SYS_DVBC_ANNEX_A, "DVB-C-A", "dvb-c-a"}, {SYS_DVBC_ANNEX_B, "DVB-C-B", "dvb-c-b"}, {SYS_DVBT, "DVB-T", "dvb-t"}, {SYS_DSS, "DSS", "dss"}, {SYS_DVBS, "DVB-S", "dvb-s"}, {SYS_DVBS2, "DVB-S2", "dvb-s2"}, {SYS_DVBH, "DVB-H", "dvb-h"}, {SYS_ISDBT, "ISDB-T", "isdb-t"}, {SYS_ISDBS, "ISDB-S", "isdb-s"}, {SYS_ISDBC, "ISDB-C", "isdb-c"}, {SYS_ATSC, "ATSC", "atsc"}, {SYS_ATSCMH, "ATSC-MH", "atsc-mh"}, #if HAVE_V5_MINOR(7) {SYS_DTMB, "DTMB", "dtmb"}, #endif {SYS_CMMB, "CMMB", "cmmb"}, {SYS_DAB, "DAB", "dab"}, {SYS_DVBT2, "DVB-T2", "dvb-t2"}, {SYS_TURBO, "TURBO", "turbo"}, #if HAVE_V5_MINOR(6) {SYS_DVBC_ANNEX_C, "DVB-C-C", "dvb-c-c"}, #endif {0, NULL, NULL}, }; if (!dvbsrc_delsys_type) { dvbsrc_delsys_type = g_enum_register_static ("GstDvbSrcDelsys", delsys_types); } return dvbsrc_delsys_type; } #define GST_TYPE_DVBSRC_PILOT (gst_dvbsrc_pilot_get_type ()) static GType gst_dvbsrc_pilot_get_type (void) { static GType dvbsrc_pilot_type = 0; static GEnumValue pilot_types[] = { {PILOT_ON, "ON", "on"}, {PILOT_OFF, "OFF", "off"}, {PILOT_AUTO, "AUTO", "auto"}, {0, NULL, NULL}, }; if (!dvbsrc_pilot_type) { dvbsrc_pilot_type = g_enum_register_static ("GstDvbSrcPilot", pilot_types); } return dvbsrc_pilot_type; } #define GST_TYPE_DVBSRC_ROLLOFF (gst_dvbsrc_rolloff_get_type ()) static GType gst_dvbsrc_rolloff_get_type (void) { static GType dvbsrc_rolloff_type = 0; static GEnumValue rolloff_types[] = { {ROLLOFF_35, "35", "35"}, {ROLLOFF_20, "20", "20"}, {ROLLOFF_25, "25", "25"}, {ROLLOFF_AUTO, "auto", "auto"}, {0, NULL, NULL}, }; if (!dvbsrc_rolloff_type) { dvbsrc_rolloff_type = g_enum_register_static ("GstDvbSrcRolloff", rolloff_types); } return dvbsrc_rolloff_type; } #define GST_TYPE_INTERLEAVING (gst_dvbsrc_interleaving_get_type ()) static GType gst_dvbsrc_interleaving_get_type (void) { static GType dvbsrc_interleaving_type = 0; static GEnumValue interleaving_types[] = { #if HAVE_V5_MINOR(7) {INTERLEAVING_NONE, "NONE", "none"}, {INTERLEAVING_AUTO, "AUTO", "auto"}, {INTERLEAVING_240, "240", "240"}, {INTERLEAVING_720, "720", "720"}, #endif {0, NULL, NULL}, }; if (!dvbsrc_interleaving_type) { dvbsrc_interleaving_type = g_enum_register_static ("GstDvbSrcInterleaving", interleaving_types); } return dvbsrc_interleaving_type; } static void gst_dvbsrc_finalize (GObject * object); static void gst_dvbsrc_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec); static void gst_dvbsrc_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec); static GstFlowReturn gst_dvbsrc_create (GstPushSrc * element, GstBuffer ** buffer); static gboolean gst_dvbsrc_start (GstBaseSrc * bsrc); static gboolean gst_dvbsrc_stop (GstBaseSrc * bsrc); static GstStateChangeReturn gst_dvbsrc_change_state (GstElement * element, GstStateChange transition); static gboolean gst_dvbsrc_unlock (GstBaseSrc * bsrc); static gboolean gst_dvbsrc_unlock_stop (GstBaseSrc * bsrc); static gboolean gst_dvbsrc_is_seekable (GstBaseSrc * bsrc); static gboolean gst_dvbsrc_get_size (GstBaseSrc * src, guint64 * size); static void gst_dvbsrc_do_tune (GstDvbSrc * src); static gboolean gst_dvbsrc_tune (GstDvbSrc * object); static gboolean gst_dvbsrc_set_fe_params (GstDvbSrc * object, struct dtv_properties *props); static gboolean gst_dvbsrc_tune_fe (GstDvbSrc * object); static void gst_dvbsrc_set_pes_filters (GstDvbSrc * object); static void gst_dvbsrc_unset_pes_filters (GstDvbSrc * object); static gboolean gst_dvbsrc_is_valid_modulation (guint delsys, guint mod); /** * This loop should be safe enough considering: * * 1.- EINTR suggest the next ioctl might succeed * 2.- It's highly unlikely you will end up spining * before your entire system goes nuts due to * the massive number of interrupts. * * We don't check for EAGAIN here cause we are opening * the frontend in blocking mode. */ #define LOOP_WHILE_EINTR(v,func) do { (v) = (func); } \ while ((v) == -1 && errno == EINTR); static GstStaticPadTemplate ts_src_factory = GST_STATIC_PAD_TEMPLATE ("src", GST_PAD_SRC, GST_PAD_ALWAYS, GST_STATIC_CAPS ("video/mpegts, " "mpegversion = (int) 2," "systemstream = (boolean) TRUE")); /* ****************************** * * * GObject Related * * * * * ****************************** */ #define gst_dvbsrc_parent_class parent_class G_DEFINE_TYPE (GstDvbSrc, gst_dvbsrc, GST_TYPE_PUSH_SRC); static guint gst_dvbsrc_signals[LAST_SIGNAL] = { 0 }; /* initialize the plugin's class */ static void gst_dvbsrc_class_init (GstDvbSrcClass * klass) { GObjectClass *gobject_class; GstElementClass *gstelement_class; GstBaseSrcClass *gstbasesrc_class; GstPushSrcClass *gstpushsrc_class; GstDvbSrcClass *gstdvbsrc_class; gobject_class = (GObjectClass *) klass; gstelement_class = (GstElementClass *) klass; gstbasesrc_class = (GstBaseSrcClass *) klass; gstpushsrc_class = (GstPushSrcClass *) klass; gstdvbsrc_class = (GstDvbSrcClass *) klass; gobject_class->set_property = gst_dvbsrc_set_property; gobject_class->get_property = gst_dvbsrc_get_property; gobject_class->finalize = gst_dvbsrc_finalize; gstelement_class->change_state = GST_DEBUG_FUNCPTR (gst_dvbsrc_change_state); gst_element_class_add_pad_template (gstelement_class, gst_static_pad_template_get (&ts_src_factory)); gst_element_class_set_static_metadata (gstelement_class, "DVB Source", "Source/Video", "Digital Video Broadcast Source", "P2P-VCR, C-Lab, University of Paderborn, " "Zaheer Abbas Merali \n" "Reynaldo H. Verdejo Pinochet "); gstbasesrc_class->start = GST_DEBUG_FUNCPTR (gst_dvbsrc_start); gstbasesrc_class->stop = GST_DEBUG_FUNCPTR (gst_dvbsrc_stop); gstbasesrc_class->unlock = GST_DEBUG_FUNCPTR (gst_dvbsrc_unlock); gstbasesrc_class->unlock_stop = GST_DEBUG_FUNCPTR (gst_dvbsrc_unlock_stop); gstbasesrc_class->is_seekable = GST_DEBUG_FUNCPTR (gst_dvbsrc_is_seekable); gstbasesrc_class->get_size = GST_DEBUG_FUNCPTR (gst_dvbsrc_get_size); gstpushsrc_class->create = GST_DEBUG_FUNCPTR (gst_dvbsrc_create); gstdvbsrc_class->do_tune = GST_DEBUG_FUNCPTR (gst_dvbsrc_do_tune); g_object_class_install_property (gobject_class, ARG_DVBSRC_ADAPTER, g_param_spec_int ("adapter", "The adapter device number", "The DVB adapter device number (eg. 0 for adapter0)", 0, 16, DEFAULT_ADAPTER, G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, ARG_DVBSRC_FRONTEND, g_param_spec_int ("frontend", "The frontend device number", "The frontend device number (eg. 0 for frontend0)", 0, 16, DEFAULT_FRONTEND, G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, ARG_DVBSRC_FREQUENCY, g_param_spec_uint ("frequency", "Center frequency", "Center frequency to tune into. Measured in kHz for the satellite " "distribution standars and Hz for all the rest", 0, G_MAXUINT, DEFAULT_FREQUENCY, GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, ARG_DVBSRC_POLARITY, g_param_spec_string ("polarity", "polarity", "(DVB-S/S2) Polarity [vhHV] (eg. V for Vertical)", DEFAULT_POLARITY, GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE | G_PARAM_CONSTRUCT)); g_object_class_install_property (gobject_class, ARG_DVBSRC_PIDS, g_param_spec_string ("pids", "pids", "Colon seperated list of pids (eg. 110:120)", DEFAULT_PIDS, GST_PARAM_MUTABLE_PLAYING | G_PARAM_WRITABLE)); g_object_class_install_property (gobject_class, ARG_DVBSRC_SYM_RATE, g_param_spec_uint ("symbol-rate", "symbol rate", "(DVB-S/S2, DVB-C) Symbol rate in kBd (kilo bauds)", 0, G_MAXUINT, DEFAULT_SYMBOL_RATE, GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, ARG_DVBSRC_TUNE, g_param_spec_pointer ("tune", "tune", "Atomically tune to channel. (For Apps)", G_PARAM_WRITABLE)); g_object_class_install_property (gobject_class, ARG_DVBSRC_DISEQC_SRC, g_param_spec_int ("diseqc-source", "diseqc source", "(DVB-S/S2) Selected DiSEqC source. Only needed if you have a " "DiSEqC switch. Otherwise leave at -1 (disabled)", -1, 7, DEFAULT_DISEQC_SRC, GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE)); /* DVB-T, additional properties */ g_object_class_install_property (gobject_class, ARG_DVBSRC_BANDWIDTH_HZ, g_param_spec_uint ("bandwidth-hz", "bandwidth-hz", "(DVB-T) Bandwidth in Hz", 0, G_MAXUINT, DEFAULT_BANDWIDTH_HZ, GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE)); #ifndef GST_REMOVE_DEPRECATED g_object_class_install_property (gobject_class, ARG_DVBSRC_BANDWIDTH, g_param_spec_enum ("bandwidth", "bandwidth", "(DVB-T) Bandwidth. Deprecated", GST_TYPE_DVBSRC_BANDWIDTH, DEFAULT_BANDWIDTH, GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE | G_PARAM_DEPRECATED)); #endif /* FIXME: DVB-C, DVB-S, DVB-S2 named it as innerFEC */ g_object_class_install_property (gobject_class, ARG_DVBSRC_CODE_RATE_HP, g_param_spec_enum ("code-rate-hp", "code-rate-hp", "(DVB-T, DVB-S/S2 and DVB-C) High priority code rate", GST_TYPE_DVBSRC_CODE_RATE, DEFAULT_CODE_RATE_HP, GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, ARG_DVBSRC_CODE_RATE_LP, g_param_spec_enum ("code-rate-lp", "code-rate-lp", "(DVB-T) Low priority code rate", GST_TYPE_DVBSRC_CODE_RATE, DEFAULT_CODE_RATE_LP, GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE)); /* FIXME: should the property be called 'guard-interval' then? */ g_object_class_install_property (gobject_class, ARG_DVBSRC_GUARD, g_param_spec_enum ("guard", "guard", "(DVB-T) Guard Interval", GST_TYPE_DVBSRC_GUARD, DEFAULT_GUARD, GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, ARG_DVBSRC_MODULATION, g_param_spec_enum ("modulation", "modulation", "(DVB-T/T2/C/S2, TURBO and ATSC) Modulation type", GST_TYPE_DVBSRC_MODULATION, DEFAULT_MODULATION, GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE)); /* FIXME: property should be named 'transmission-mode' */ g_object_class_install_property (gobject_class, ARG_DVBSRC_TRANSMISSION_MODE, g_param_spec_enum ("trans-mode", "trans-mode", "(DVB-T) Transmission mode", GST_TYPE_DVBSRC_TRANSMISSION_MODE, DEFAULT_TRANSMISSION_MODE, GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, ARG_DVBSRC_HIERARCHY_INF, g_param_spec_enum ("hierarchy", "hierarchy", "(DVB-T) Hierarchy information", GST_TYPE_DVBSRC_HIERARCHY, DEFAULT_HIERARCHY, GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, ARG_DVBSRC_INVERSION, g_param_spec_enum ("inversion", "inversion", "(DVB-T and DVB-C) Inversion information", GST_TYPE_DVBSRC_INVERSION, DEFAULT_INVERSION, GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, ARG_DVBSRC_STATS_REPORTING_INTERVAL, g_param_spec_uint ("stats-reporting-interval", "stats-reporting-interval", "The number of reads before reporting frontend stats", 0, G_MAXUINT, DEFAULT_STATS_REPORTING_INTERVAL, GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, ARG_DVBSRC_TIMEOUT, g_param_spec_uint64 ("timeout", "Timeout", "Post a message after timeout microseconds (0 = disabled)", 0, G_MAXUINT64, DEFAULT_TIMEOUT, G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, ARG_DVBSRC_TUNING_TIMEOUT, g_param_spec_uint64 ("tuning-timeout", "Tuning Timeout", "Milliseconds to wait before giving up tuning/locking on a signal", 0, G_MAXUINT64, DEFAULT_TUNING_TIMEOUT, GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, ARG_DVBSRC_DVB_BUFFER_SIZE, g_param_spec_uint ("dvb-buffer-size", "dvb-buffer-size", "The kernel buffer size used by the DVB api", 0, G_MAXUINT, DEFAULT_DVB_BUFFER_SIZE, G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, ARG_DVBSRC_DELSYS, g_param_spec_enum ("delsys", "delsys", "Delivery System", GST_TYPE_DVBSRC_DELSYS, DEFAULT_DELSYS, G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, ARG_DVBSRC_PILOT, g_param_spec_enum ("pilot", "pilot", "Pilot (DVB-S2)", GST_TYPE_DVBSRC_PILOT, DEFAULT_PILOT, GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, ARG_DVBSRC_ROLLOFF, g_param_spec_enum ("rolloff", "rolloff", "Rolloff (DVB-S2)", GST_TYPE_DVBSRC_ROLLOFF, DEFAULT_ROLLOFF, GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, ARG_DVBSRC_STREAM_ID, g_param_spec_int ("stream-id", "stream-id", "(DVB-T2 and DVB-S2 max 255, ISDB max 65535) Stream ID " "(-1 = disabled)", -1, 65535, DEFAULT_STREAM_ID, GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE)); /* Additional ISDB-T properties */ /* Valid values are 0x1 0x2 0x4 |-ables */ g_object_class_install_property (gobject_class, ARG_DVBSRC_ISDBT_LAYER_ENABLED, g_param_spec_uint ("isdbt-layer-enabled", "ISB-T layer enabled", "(ISDB-T) Layer Enabled (7 = All layers)", 1, 7, DEFAULT_ISDBT_LAYER_ENABLED, GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, ARG_DVBSRC_ISDBT_PARTIAL_RECEPTION, g_param_spec_int ("isdbt-partial-reception", "ISB-T partial reception", "(ISDB-T) Partial Reception (-1 = AUTO)", -1, 1, DEFAULT_ISDBT_PARTIAL_RECEPTION, GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, ARG_DVBSRC_ISDBT_SOUND_BROADCASTING, g_param_spec_int ("isdbt-sound-broadcasting", "ISB-T sound broadcasting", "(ISDB-T) Sound Broadcasting", 0, 1, DEFAULT_ISDBT_SOUND_BROADCASTING, GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, ARG_DVBSRC_ISDBT_SB_SUBCHANNEL_ID, g_param_spec_int ("isdbt-sb-subchannel-id", "ISB-T SB subchannel ID", "(ISDB-T) SB Subchannel ID (-1 = AUTO)", -1, 41, DEFAULT_ISDBT_SB_SEGMENT_IDX, GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, ARG_DVBSRC_ISDBT_SB_SEGMENT_IDX, g_param_spec_int ("isdbt-sb-segment-idx", "ISB-T SB segment IDX", "(ISDB-T) SB segment IDX", 0, 12, DEFAULT_ISDBT_SB_SEGMENT_IDX, GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, ARG_DVBSRC_ISDBT_SB_SEGMENT_COUNT, g_param_spec_uint ("isdbt-sb-segment-count", "ISB-T SB segment count", "(ISDB-T) SB segment count", 1, 13, DEFAULT_ISDBT_SB_SEGMENT_COUNT, GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, ARG_DVBSRC_ISDBT_LAYERA_FEC, g_param_spec_enum ("isdbt-layera-fec", "ISDB-T layer A FEC", "(ISDB-T) layer A Forward Error Correction", GST_TYPE_DVBSRC_CODE_RATE, DEFAULT_ISDBT_LAYERA_FEC, GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, ARG_DVBSRC_ISDBT_LAYERB_FEC, g_param_spec_enum ("isdbt-layerb-fec", "ISDB-T layer B FEC", "(ISDB-T) layer B Forward Error Correction", GST_TYPE_DVBSRC_CODE_RATE, DEFAULT_ISDBT_LAYERB_FEC, GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, ARG_DVBSRC_ISDBT_LAYERC_FEC, g_param_spec_enum ("isdbt-layerc-fec", "ISDB-T layer A FEC", "(ISDB-T) layer C Forward Error Correction", GST_TYPE_DVBSRC_CODE_RATE, DEFAULT_ISDBT_LAYERC_FEC, GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, ARG_DVBSRC_ISDBT_LAYERA_MODULATION, g_param_spec_enum ("isdbt-layera-modulation", "ISDBT layer A modulation", "(ISDB-T) Layer A modulation type", GST_TYPE_DVBSRC_MODULATION, DEFAULT_ISDBT_LAYERA_MODULATION, GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, ARG_DVBSRC_ISDBT_LAYERB_MODULATION, g_param_spec_enum ("isdbt-layerb-modulation", "ISDBT layer B modulation", "(ISDB-T) Layer B modulation type", GST_TYPE_DVBSRC_MODULATION, DEFAULT_ISDBT_LAYERB_MODULATION, GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, ARG_DVBSRC_ISDBT_LAYERC_MODULATION, g_param_spec_enum ("isdbt-layerc-modulation", "ISDBT layer C modulation", "(ISDB-T) Layer C modulation type", GST_TYPE_DVBSRC_MODULATION, DEFAULT_ISDBT_LAYERC_MODULATION, GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, ARG_DVBSRC_ISDBT_LAYERA_SEGMENT_COUNT, g_param_spec_int ("isdbt-layera-segment-count", "ISB-T layer A segment count", "(ISDB-T) Layer A segment count (-1 = AUTO)", -1, 13, DEFAULT_ISDBT_LAYERA_SEGMENT_COUNT, GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, ARG_DVBSRC_ISDBT_LAYERB_SEGMENT_COUNT, g_param_spec_int ("isdbt-layerb-segment-count", "ISB-T layer B segment count", "(ISDB-T) Layer B segment count (-1 = AUTO)", -1, 13, DEFAULT_ISDBT_LAYERB_SEGMENT_COUNT, GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, ARG_DVBSRC_ISDBT_LAYERC_SEGMENT_COUNT, g_param_spec_int ("isdbt-layerc-segment-count", "ISB-T layer C segment count", "(ISDB-T) Layer C segment count (-1 = AUTO)", -1, 13, DEFAULT_ISDBT_LAYERC_SEGMENT_COUNT, GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, ARG_DVBSRC_ISDBT_LAYERA_TIME_INTERLEAVING, g_param_spec_int ("isdbt-layera-time-interleaving", "ISB-T layer A time interleaving ", "(ISDB-T) Layer A time interleaving (-1 = AUTO)", -1, 8, DEFAULT_ISDBT_LAYERA_TIME_INTERLEAVING, GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, ARG_DVBSRC_ISDBT_LAYERB_TIME_INTERLEAVING, g_param_spec_int ("isdbt-layerb-time-interleaving", "ISB-T layer B time interleaving ", "(ISDB-T) Layer B time interleaving (-1 = AUTO)", -1, 8, DEFAULT_ISDBT_LAYERB_TIME_INTERLEAVING, GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, ARG_DVBSRC_ISDBT_LAYERC_TIME_INTERLEAVING, g_param_spec_int ("isdbt-layerc-time-interleaving", "ISB-T layer C time interleaving ", "(ISDB-T) Layer C time interleaving (-1 = AUTO)", -1, 8, DEFAULT_ISDBT_LAYERC_TIME_INTERLEAVING, GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE)); /* LNB properties (Satellite distribution standards) */ g_object_class_install_property (gobject_class, ARG_DVBSRC_LNB_SLOF, g_param_spec_uint ("lnb-slof", "Tuning Timeout", "LNB's Upper bound for low band reception (kHz)", 0, G_MAXUINT, DEFAULT_LNB_SLOF, GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, ARG_DVBSRC_LNB_LOF1, g_param_spec_uint ("lnb-lof1", "Low band local oscillator frequency", "LNB's Local oscillator frequency used for low band reception (kHz)", 0, G_MAXUINT, DEFAULT_LNB_LOF1, GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, ARG_DVBSRC_LNB_LOF2, g_param_spec_uint ("lnb-lof2", "High band local oscillator frequency", "LNB's Local oscillator frequency used for high band reception (kHz)", 0, G_MAXUINT, DEFAULT_LNB_LOF2, GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE)); /* Additional DTMB properties */ g_object_class_install_property (gobject_class, ARG_DVBSRC_INTERLEAVING, g_param_spec_enum ("interleaving", "DTMB Interleaving", "(DTMB) Interleaving type", GST_TYPE_INTERLEAVING, DEFAULT_INTERLEAVING, GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE)); /** * GstDvbSrc::tuning-start: * @gstdvbsrc: the element on which the signal is emitted * * Signal emited when the element first attempts to tune the * frontend tunner to a given frequency. */ gst_dvbsrc_signals[SIGNAL_TUNING_START] = g_signal_new ("tuning-start", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, 0, NULL, NULL, NULL, G_TYPE_NONE, 0); /** * GstDvbSrc::tuning-done: * @gstdvbsrc: the element on which the signal is emitted * * Signal emited when the tunner has successfully got a lock on a signal. */ gst_dvbsrc_signals[SIGNAL_TUNING_DONE] = g_signal_new ("tuning-done", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, 0, NULL, NULL, NULL, G_TYPE_NONE, 0); /** * GstDvbSrc::tuning-fail: * @gstdvbsrc: the element on which the signal is emitted * * Signal emited when the tunner failed to get a lock on the * signal. */ gst_dvbsrc_signals[SIGNAL_TUNING_FAIL] = g_signal_new ("tuning-fail", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, 0, NULL, NULL, NULL, G_TYPE_NONE, 0); /** * GstDvbSrc::tune: * @gstdvbsrc: the element on which the signal is emitted * * Signal emited from the application to the element, instructing it * to tune. */ gst_dvbsrc_signals[SIGNAL_TUNING_FAIL] = g_signal_new ("tune", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (GstDvbSrcClass, do_tune), NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); } /* initialize the new element * instantiate pads and add them to element * set functions * initialize structure */ static void gst_dvbsrc_init (GstDvbSrc * object) { int i = 0; GST_INFO_OBJECT (object, "gst_dvbsrc_init"); GST_DEBUG_OBJECT (object, "Kernel DVB API version %d.%d", DVB_API_VERSION, DVB_API_VERSION_MINOR); /* We are a live source */ gst_base_src_set_live (GST_BASE_SRC (object), TRUE); /* And we wanted timestamped output */ gst_base_src_set_do_timestamp (GST_BASE_SRC (object), TRUE); gst_base_src_set_format (GST_BASE_SRC (object), GST_FORMAT_TIME); object->fd_frontend = -1; object->fd_dvr = -1; for (i = 0; i < MAX_FILTERS; i++) { object->pids[i] = G_MAXUINT16; object->fd_filters[i] = -1; } /* PID 8192 on DVB gets the whole transport stream */ object->pids[0] = 8192; object->dvb_buffer_size = DEFAULT_DVB_BUFFER_SIZE; object->adapter_number = DEFAULT_ADAPTER; object->frontend_number = DEFAULT_FRONTEND; object->diseqc_src = DEFAULT_DISEQC_SRC; object->send_diseqc = (DEFAULT_DISEQC_SRC != -1); object->tone = SEC_TONE_OFF; /* object->pol = DVB_POL_H; *//* set via G_PARAM_CONSTRUCT */ object->sym_rate = DEFAULT_SYMBOL_RATE; object->bandwidth = DEFAULT_BANDWIDTH; object->code_rate_hp = DEFAULT_CODE_RATE_HP; object->code_rate_lp = DEFAULT_CODE_RATE_LP; object->guard_interval = DEFAULT_GUARD; object->modulation = DEFAULT_MODULATION; object->transmission_mode = DEFAULT_TRANSMISSION_MODE; object->hierarchy_information = DEFAULT_HIERARCHY; object->inversion = DEFAULT_INVERSION; object->stats_interval = DEFAULT_STATS_REPORTING_INTERVAL; object->delsys = DEFAULT_DELSYS; object->pilot = DEFAULT_PILOT; object->rolloff = DEFAULT_ROLLOFF; object->stream_id = DEFAULT_STREAM_ID; object->isdbt_layer_enabled = DEFAULT_ISDBT_LAYER_ENABLED; object->isdbt_partial_reception = DEFAULT_ISDBT_PARTIAL_RECEPTION; object->isdbt_sound_broadcasting = DEFAULT_ISDBT_SOUND_BROADCASTING; object->isdbt_sb_subchannel_id = DEFAULT_ISDBT_SB_SUBCHANNEL_ID; object->isdbt_sb_segment_idx = DEFAULT_ISDBT_SB_SEGMENT_IDX; object->isdbt_sb_segment_count = DEFAULT_ISDBT_SB_SEGMENT_COUNT; object->isdbt_layera_fec = DEFAULT_ISDBT_LAYERA_FEC; object->isdbt_layera_modulation = DEFAULT_ISDBT_LAYERA_MODULATION; object->isdbt_layera_segment_count = DEFAULT_ISDBT_LAYERA_SEGMENT_COUNT; object->isdbt_layera_time_interleaving = DEFAULT_ISDBT_LAYERA_TIME_INTERLEAVING; object->isdbt_layerb_fec = DEFAULT_ISDBT_LAYERB_FEC; object->isdbt_layerb_modulation = DEFAULT_ISDBT_LAYERB_MODULATION; object->isdbt_layerb_segment_count = DEFAULT_ISDBT_LAYERB_SEGMENT_COUNT; object->isdbt_layerb_time_interleaving = DEFAULT_ISDBT_LAYERB_TIME_INTERLEAVING; object->isdbt_layerc_fec = DEFAULT_ISDBT_LAYERC_FEC; object->isdbt_layerc_modulation = DEFAULT_ISDBT_LAYERC_MODULATION; object->isdbt_layerc_segment_count = DEFAULT_ISDBT_LAYERC_SEGMENT_COUNT; object->isdbt_layerc_time_interleaving = DEFAULT_ISDBT_LAYERC_TIME_INTERLEAVING; object->lnb_slof = DEFAULT_LNB_SLOF; object->lnb_lof1 = DEFAULT_LNB_LOF1; object->lnb_lof2 = DEFAULT_LNB_LOF2; object->interleaving = DEFAULT_INTERLEAVING; g_mutex_init (&object->tune_mutex); object->timeout = DEFAULT_TIMEOUT; object->tuning_timeout = DEFAULT_TUNING_TIMEOUT; } static void gst_dvbsrc_set_pids (GstDvbSrc * dvbsrc, const gchar * pid_string) { if (!strcmp (pid_string, "8192")) { /* get the whole ts */ int pid_count = 1; dvbsrc->pids[0] = 8192; while (pid_count < MAX_FILTERS) { dvbsrc->pids[pid_count++] = G_MAXUINT16; } } else { int pid = 0; int pid_count; gchar **pids; char **tmp; tmp = pids = g_strsplit (pid_string, ":", MAX_FILTERS); /* always add the PAT and CAT pids */ dvbsrc->pids[0] = 0; dvbsrc->pids[1] = 1; pid_count = 2; while (*pids != NULL && pid_count < MAX_FILTERS) { pid = strtol (*pids, NULL, 0); if (pid > 1 && pid <= 8192) { GST_INFO_OBJECT (dvbsrc, "\tParsed Pid: %d", pid); dvbsrc->pids[pid_count] = pid; pid_count++; } pids++; } while (pid_count < MAX_FILTERS) { dvbsrc->pids[pid_count++] = G_MAXUINT16; } g_strfreev (tmp); } /* if we are in playing or paused, then set filters now */ GST_INFO_OBJECT (dvbsrc, "checking if playing for setting pes filters"); if (GST_ELEMENT (dvbsrc)->current_state == GST_STATE_PLAYING || GST_ELEMENT (dvbsrc)->current_state == GST_STATE_PAUSED) { GST_INFO_OBJECT (dvbsrc, "Setting pes filters now"); gst_dvbsrc_set_pes_filters (dvbsrc); } } static void gst_dvbsrc_set_property (GObject * _object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstDvbSrc *object; g_return_if_fail (GST_IS_DVBSRC (_object)); object = GST_DVBSRC (_object); switch (prop_id) { case ARG_DVBSRC_ADAPTER: object->adapter_number = g_value_get_int (value); break; case ARG_DVBSRC_FRONTEND: object->frontend_number = g_value_get_int (value); break; case ARG_DVBSRC_DISEQC_SRC: if (object->diseqc_src != g_value_get_int (value)) { object->diseqc_src = g_value_get_int (value); object->send_diseqc = TRUE; } GST_INFO_OBJECT (object, "Set Property: ARG_DVBSRC_DISEQC_ID"); break; case ARG_DVBSRC_FREQUENCY: object->freq = g_value_get_uint (value); GST_INFO_OBJECT (object, "Set Property: ARG_DVBSRC_FREQUENCY (%d Hz)", object->freq); break; case ARG_DVBSRC_POLARITY: { const char *s = NULL; s = g_value_get_string (value); if (s != NULL) { object->pol = (s[0] == 'h' || s[0] == 'H') ? DVB_POL_H : DVB_POL_V; GST_INFO_OBJECT (object, "Set Property: ARG_DVBSRC_POLARITY"); GST_INFO_OBJECT (object, "\t%s", (s[0] == 'h' || s[0] == 'H') ? "DVB_POL_H" : "DVB_POL_V"); } break; } case ARG_DVBSRC_PIDS: { const gchar *pid_string; pid_string = g_value_get_string (value); GST_INFO_OBJECT (object, "Set Property: ARG_DVBSRC_PIDS %s", pid_string); if (pid_string) gst_dvbsrc_set_pids (object, pid_string); break; } case ARG_DVBSRC_SYM_RATE: object->sym_rate = g_value_get_uint (value); GST_INFO_OBJECT (object, "Set Property: ARG_DVBSRC_SYM_RATE to value %d", object->sym_rate); break; case ARG_DVBSRC_BANDWIDTH_HZ: object->bandwidth = g_value_get_uint (value); break; case ARG_DVBSRC_BANDWIDTH: switch (g_value_get_enum (value)) { case BANDWIDTH_8_MHZ: object->bandwidth = 8000000; break; case BANDWIDTH_7_MHZ: object->bandwidth = 7000000; break; case BANDWIDTH_6_MHZ: object->bandwidth = 6000000; break; case BANDWIDTH_5_MHZ: object->bandwidth = 5000000; break; case BANDWIDTH_10_MHZ: object->bandwidth = 10000000; break; case BANDWIDTH_1_712_MHZ: object->bandwidth = 1712000; break; default: /* we don't know which bandwidth is set */ object->bandwidth = 0; break; } break; case ARG_DVBSRC_CODE_RATE_HP: object->code_rate_hp = g_value_get_enum (value); break; case ARG_DVBSRC_CODE_RATE_LP: object->code_rate_lp = g_value_get_enum (value); break; case ARG_DVBSRC_GUARD: object->guard_interval = g_value_get_enum (value); break; case ARG_DVBSRC_MODULATION: object->modulation = g_value_get_enum (value); break; case ARG_DVBSRC_TRANSMISSION_MODE: object->transmission_mode = g_value_get_enum (value); break; case ARG_DVBSRC_HIERARCHY_INF: object->hierarchy_information = g_value_get_enum (value); break; case ARG_DVBSRC_INVERSION: object->inversion = g_value_get_enum (value); break; case ARG_DVBSRC_TUNE: GST_INFO_OBJECT (object, "Set Property: ARG_DVBSRC_TUNE"); gst_dvbsrc_do_tune (object); break; case ARG_DVBSRC_STATS_REPORTING_INTERVAL: object->stats_interval = g_value_get_uint (value); object->stats_counter = 0; break; case ARG_DVBSRC_TIMEOUT: object->timeout = g_value_get_uint64 (value); break; case ARG_DVBSRC_TUNING_TIMEOUT: object->tuning_timeout = g_value_get_uint64 (value); break; case ARG_DVBSRC_DVB_BUFFER_SIZE: object->dvb_buffer_size = g_value_get_uint (value); break; case ARG_DVBSRC_DELSYS: object->delsys = g_value_get_enum (value); break; case ARG_DVBSRC_PILOT: object->pilot = g_value_get_enum (value); break; case ARG_DVBSRC_ROLLOFF: object->rolloff = g_value_get_enum (value); break; case ARG_DVBSRC_STREAM_ID: object->stream_id = g_value_get_int (value); break; case ARG_DVBSRC_ISDBT_LAYER_ENABLED: object->isdbt_layer_enabled = g_value_get_uint (value); break; case ARG_DVBSRC_ISDBT_PARTIAL_RECEPTION: object->isdbt_partial_reception = g_value_get_int (value); break; case ARG_DVBSRC_ISDBT_SOUND_BROADCASTING: object->isdbt_sound_broadcasting = g_value_get_int (value); break; case ARG_DVBSRC_ISDBT_SB_SUBCHANNEL_ID: object->isdbt_sb_subchannel_id = g_value_get_int (value); break; case ARG_DVBSRC_ISDBT_SB_SEGMENT_IDX: object->isdbt_sb_segment_idx = g_value_get_int (value); break; case ARG_DVBSRC_ISDBT_SB_SEGMENT_COUNT: object->isdbt_sb_segment_count = g_value_get_uint (value); break; case ARG_DVBSRC_ISDBT_LAYERA_FEC: object->isdbt_layera_fec = g_value_get_enum (value); break; case ARG_DVBSRC_ISDBT_LAYERA_MODULATION: object->isdbt_layera_modulation = g_value_get_enum (value); break; case ARG_DVBSRC_ISDBT_LAYERA_SEGMENT_COUNT: object->isdbt_layera_segment_count = g_value_get_int (value); break; case ARG_DVBSRC_ISDBT_LAYERA_TIME_INTERLEAVING: object->isdbt_layera_time_interleaving = g_value_get_int (value); break; case ARG_DVBSRC_ISDBT_LAYERB_FEC: object->isdbt_layerb_fec = g_value_get_enum (value); break; case ARG_DVBSRC_ISDBT_LAYERB_MODULATION: object->isdbt_layerb_modulation = g_value_get_enum (value); break; case ARG_DVBSRC_ISDBT_LAYERB_SEGMENT_COUNT: object->isdbt_layerb_segment_count = g_value_get_int (value); break; case ARG_DVBSRC_ISDBT_LAYERB_TIME_INTERLEAVING: object->isdbt_layerb_time_interleaving = g_value_get_int (value); break; case ARG_DVBSRC_ISDBT_LAYERC_FEC: object->isdbt_layerc_fec = g_value_get_enum (value); break; case ARG_DVBSRC_ISDBT_LAYERC_MODULATION: object->isdbt_layerc_modulation = g_value_get_enum (value); break; case ARG_DVBSRC_ISDBT_LAYERC_SEGMENT_COUNT: object->isdbt_layerc_segment_count = g_value_get_int (value); break; case ARG_DVBSRC_ISDBT_LAYERC_TIME_INTERLEAVING: object->isdbt_layerc_time_interleaving = g_value_get_int (value); break; case ARG_DVBSRC_LNB_SLOF: object->lnb_slof = g_value_get_uint (value); break; case ARG_DVBSRC_LNB_LOF1: object->lnb_lof1 = g_value_get_uint (value); break; case ARG_DVBSRC_LNB_LOF2: object->lnb_lof2 = g_value_get_uint (value); break; case ARG_DVBSRC_INTERLEAVING: object->interleaving = g_value_get_enum (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); } } static void gst_dvbsrc_get_property (GObject * _object, guint prop_id, GValue * value, GParamSpec * pspec) { GstDvbSrc *object; g_return_if_fail (GST_IS_DVBSRC (_object)); object = GST_DVBSRC (_object); switch (prop_id) { case ARG_DVBSRC_ADAPTER: g_value_set_int (value, object->adapter_number); break; case ARG_DVBSRC_FRONTEND: g_value_set_int (value, object->frontend_number); break; case ARG_DVBSRC_FREQUENCY: g_value_set_uint (value, object->freq); break; case ARG_DVBSRC_POLARITY: if (object->pol == DVB_POL_H) g_value_set_static_string (value, "H"); else g_value_set_static_string (value, "V"); break; case ARG_DVBSRC_SYM_RATE: g_value_set_uint (value, object->sym_rate); break; case ARG_DVBSRC_DISEQC_SRC: g_value_set_int (value, object->diseqc_src); break; case ARG_DVBSRC_BANDWIDTH_HZ: g_value_set_uint (value, object->bandwidth); break; case ARG_DVBSRC_BANDWIDTH:{ int tmp; if (!object->bandwidth) tmp = BANDWIDTH_AUTO; else if (object->bandwidth <= 1712000) tmp = BANDWIDTH_1_712_MHZ; else if (object->bandwidth <= 5000000) tmp = BANDWIDTH_5_MHZ; else if (object->bandwidth <= 6000000) tmp = BANDWIDTH_6_MHZ; else if (object->bandwidth <= 7000000) tmp = BANDWIDTH_7_MHZ; else if (object->bandwidth <= 8000000) tmp = BANDWIDTH_8_MHZ; else if (object->bandwidth <= 10000000) tmp = BANDWIDTH_10_MHZ; else tmp = BANDWIDTH_AUTO; g_value_set_enum (value, tmp); break; } case ARG_DVBSRC_CODE_RATE_HP: g_value_set_enum (value, object->code_rate_hp); break; case ARG_DVBSRC_CODE_RATE_LP: g_value_set_enum (value, object->code_rate_lp); break; case ARG_DVBSRC_GUARD: g_value_set_enum (value, object->guard_interval); break; case ARG_DVBSRC_MODULATION: g_value_set_enum (value, object->modulation); break; case ARG_DVBSRC_TRANSMISSION_MODE: g_value_set_enum (value, object->transmission_mode); break; case ARG_DVBSRC_HIERARCHY_INF: g_value_set_enum (value, object->hierarchy_information); break; case ARG_DVBSRC_INVERSION: g_value_set_enum (value, object->inversion); break; case ARG_DVBSRC_STATS_REPORTING_INTERVAL: g_value_set_uint (value, object->stats_interval); break; case ARG_DVBSRC_TIMEOUT: g_value_set_uint64 (value, object->timeout); break; case ARG_DVBSRC_TUNING_TIMEOUT: g_value_set_uint64 (value, object->tuning_timeout); break; case ARG_DVBSRC_DVB_BUFFER_SIZE: g_value_set_uint (value, object->dvb_buffer_size); break; case ARG_DVBSRC_DELSYS: g_value_set_enum (value, object->delsys); break; case ARG_DVBSRC_PILOT: g_value_set_enum (value, object->pilot); break; case ARG_DVBSRC_ROLLOFF: g_value_set_enum (value, object->rolloff); break; case ARG_DVBSRC_STREAM_ID: g_value_set_int (value, object->stream_id); break; case ARG_DVBSRC_ISDBT_LAYER_ENABLED: g_value_set_uint (value, object->isdbt_layer_enabled); break; case ARG_DVBSRC_ISDBT_PARTIAL_RECEPTION: g_value_set_int (value, object->isdbt_partial_reception); break; case ARG_DVBSRC_ISDBT_SOUND_BROADCASTING: g_value_set_int (value, object->isdbt_sound_broadcasting); break; case ARG_DVBSRC_ISDBT_SB_SUBCHANNEL_ID: g_value_set_int (value, object->isdbt_sb_subchannel_id); break; case ARG_DVBSRC_ISDBT_SB_SEGMENT_IDX: g_value_set_int (value, object->isdbt_sb_segment_idx); break; case ARG_DVBSRC_ISDBT_SB_SEGMENT_COUNT: g_value_set_uint (value, object->isdbt_sb_segment_count); break; case ARG_DVBSRC_ISDBT_LAYERA_FEC: g_value_set_enum (value, object->isdbt_layera_fec); break; case ARG_DVBSRC_ISDBT_LAYERA_MODULATION: g_value_set_enum (value, object->isdbt_layera_modulation); break; case ARG_DVBSRC_ISDBT_LAYERA_SEGMENT_COUNT: g_value_set_int (value, object->isdbt_layera_segment_count); break; case ARG_DVBSRC_ISDBT_LAYERA_TIME_INTERLEAVING: g_value_set_int (value, object->isdbt_layera_time_interleaving); break; case ARG_DVBSRC_ISDBT_LAYERB_FEC: g_value_set_enum (value, object->isdbt_layerb_fec); break; case ARG_DVBSRC_ISDBT_LAYERB_MODULATION: g_value_set_enum (value, object->isdbt_layerb_modulation); break; case ARG_DVBSRC_ISDBT_LAYERB_SEGMENT_COUNT: g_value_set_int (value, object->isdbt_layerb_segment_count); break; case ARG_DVBSRC_ISDBT_LAYERB_TIME_INTERLEAVING: g_value_set_int (value, object->isdbt_layerb_time_interleaving); break; case ARG_DVBSRC_ISDBT_LAYERC_FEC: g_value_set_enum (value, object->isdbt_layerc_fec); break; case ARG_DVBSRC_ISDBT_LAYERC_MODULATION: g_value_set_enum (value, object->isdbt_layerc_modulation); break; case ARG_DVBSRC_ISDBT_LAYERC_SEGMENT_COUNT: g_value_set_int (value, object->isdbt_layerc_segment_count); break; case ARG_DVBSRC_ISDBT_LAYERC_TIME_INTERLEAVING: g_value_set_int (value, object->isdbt_layerc_time_interleaving); break; case ARG_DVBSRC_LNB_SLOF: g_value_set_uint (value, object->lnb_slof); break; case ARG_DVBSRC_LNB_LOF1: g_value_set_uint (value, object->lnb_lof1); break; case ARG_DVBSRC_LNB_LOF2: g_value_set_uint (value, object->lnb_lof2); break; case ARG_DVBSRC_INTERLEAVING: g_value_set_enum (value, object->interleaving); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); } } static gboolean gst_dvbsrc_close_devices (GstDvbSrc * object) { gst_dvbsrc_unset_pes_filters (object); close (object->fd_dvr); object->fd_dvr = -1; close (object->fd_frontend); object->fd_frontend = -1; return TRUE; } static gboolean gst_dvbsrc_check_delsys (struct dtv_property *prop, guchar delsys) { int i; for (i = 0; i < prop->u.buffer.len; i++) { if (prop->u.buffer.data[i] == delsys) return TRUE; } GST_LOG ("Adapter does not support delsys: %d", delsys); return FALSE; } static gboolean gst_dvbsrc_open_frontend (GstDvbSrc * object, gboolean writable) { struct dvb_frontend_info fe_info; struct dtv_properties props; struct dtv_property dvb_prop[1]; gchar *frontend_dev; GstStructure *adapter_structure; char *adapter_name = NULL; gint err; frontend_dev = g_strdup_printf ("/dev/dvb/adapter%d/frontend%d", object->adapter_number, object->frontend_number); GST_INFO_OBJECT (object, "Using frontend device: %s", frontend_dev); /* open frontend */ LOOP_WHILE_EINTR (object->fd_frontend, open (frontend_dev, writable ? O_RDWR : O_RDONLY)); if (object->fd_frontend < 0) { switch (errno) { case ENOENT: GST_ELEMENT_ERROR (object, RESOURCE, NOT_FOUND, (_("Device \"%s\" does not exist."), frontend_dev), (NULL)); break; default: GST_ELEMENT_ERROR (object, RESOURCE, OPEN_READ_WRITE, (_("Could not open frontend device \"%s\"."), frontend_dev), GST_ERROR_SYSTEM); break; } g_free (frontend_dev); return FALSE; } GST_DEBUG_OBJECT (object, "Device opened, querying information"); LOOP_WHILE_EINTR (err, ioctl (object->fd_frontend, FE_GET_INFO, &fe_info)); if (err) { GST_ELEMENT_ERROR (object, RESOURCE, SETTINGS, (_("Could not get settings from frontend device \"%s\"."), frontend_dev), GST_ERROR_SYSTEM); close (object->fd_frontend); g_free (frontend_dev); return FALSE; } GST_DEBUG_OBJECT (object, "check delivery systems"); dvb_prop[0].cmd = DTV_ENUM_DELSYS; props.num = 1; props.props = dvb_prop; LOOP_WHILE_EINTR (err, ioctl (object->fd_frontend, FE_GET_PROPERTY, &props)); if (err) { GST_ELEMENT_ERROR (object, RESOURCE, SETTINGS, (_("Cannot enumerate delivery systems from frontend device \"%s\"."), frontend_dev), GST_ERROR_SYSTEM); close (object->fd_frontend); g_free (frontend_dev); return FALSE; } GST_DEBUG_OBJECT (object, "Got information about adapter : %s", fe_info.name); adapter_name = g_strdup (fe_info.name); adapter_structure = gst_structure_new ("dvb-adapter", "name", G_TYPE_STRING, adapter_name, /* Capability supported auto params */ "auto-inversion", G_TYPE_BOOLEAN, fe_info.caps & FE_CAN_INVERSION_AUTO, "auto-qam", G_TYPE_BOOLEAN, fe_info.caps & FE_CAN_QAM_AUTO, "auto-transmission-mode", G_TYPE_BOOLEAN, fe_info.caps & FE_CAN_TRANSMISSION_MODE_AUTO, "auto-guard-interval", G_TYPE_BOOLEAN, fe_info.caps & FE_CAN_GUARD_INTERVAL_AUTO, "auto-hierarchy", G_TYPE_BOOLEAN, fe_info.caps & FE_CAN_HIERARCHY_AUTO, "auto-fec", G_TYPE_BOOLEAN, fe_info.caps & FE_CAN_FEC_AUTO, NULL); /* Capability delivery systems */ if (gst_dvbsrc_check_delsys (&dvb_prop[0], SYS_DVBC_ANNEX_A)) { gst_structure_set (adapter_structure, "dvb-c-a", G_TYPE_STRING, "DVB-C ANNEX A", NULL); object->best_guess_delsys = SYS_DVBC_ANNEX_A; } if (gst_dvbsrc_check_delsys (&dvb_prop[0], SYS_DVBC_ANNEX_B)) { gst_structure_set (adapter_structure, "dvb-c-b", G_TYPE_STRING, "DVB-C ANNEX C", NULL); object->best_guess_delsys = SYS_DVBC_ANNEX_B; } if (gst_dvbsrc_check_delsys (&dvb_prop[0], SYS_DVBT)) { gst_structure_set (adapter_structure, "dvb-t", G_TYPE_STRING, "DVB-T", NULL); object->best_guess_delsys = SYS_DVBT; } if (gst_dvbsrc_check_delsys (&dvb_prop[0], SYS_DSS)) { gst_structure_set (adapter_structure, "dss", G_TYPE_STRING, "DSS", NULL); object->best_guess_delsys = SYS_DSS; } if (gst_dvbsrc_check_delsys (&dvb_prop[0], SYS_DVBS)) { gst_structure_set (adapter_structure, "dvb-s", G_TYPE_STRING, "DVB-S", NULL); object->best_guess_delsys = SYS_DVBS; } if (gst_dvbsrc_check_delsys (&dvb_prop[0], SYS_DVBS2)) { gst_structure_set (adapter_structure, "dvb-s2", G_TYPE_STRING, "DVB-S2", NULL); object->best_guess_delsys = SYS_DVBS2; } if (gst_dvbsrc_check_delsys (&dvb_prop[0], SYS_DVBH)) { gst_structure_set (adapter_structure, "dvb-h", G_TYPE_STRING, "DVB-H", NULL); object->best_guess_delsys = SYS_DVBH; } if (gst_dvbsrc_check_delsys (&dvb_prop[0], SYS_ISDBT)) { gst_structure_set (adapter_structure, "isdb-t", G_TYPE_STRING, "ISDB-T", NULL); object->best_guess_delsys = SYS_ISDBT; } if (gst_dvbsrc_check_delsys (&dvb_prop[0], SYS_ISDBS)) { gst_structure_set (adapter_structure, "isdb-s", G_TYPE_STRING, "ISDB-S", NULL); object->best_guess_delsys = SYS_ISDBS; } if (gst_dvbsrc_check_delsys (&dvb_prop[0], SYS_ISDBC)) { gst_structure_set (adapter_structure, "isdb-c", G_TYPE_STRING, "ISDB-C", NULL); object->best_guess_delsys = SYS_ISDBC; } if (gst_dvbsrc_check_delsys (&dvb_prop[0], SYS_ATSC)) { gst_structure_set (adapter_structure, "atsc", G_TYPE_STRING, "ATSC", NULL); object->best_guess_delsys = SYS_ATSC; } if (gst_dvbsrc_check_delsys (&dvb_prop[0], SYS_ATSCMH)) { gst_structure_set (adapter_structure, "atsc-mh", G_TYPE_STRING, "ATSC-MH", NULL); object->best_guess_delsys = SYS_ATSCMH; } #if HAVE_V5_MINOR(7) if (gst_dvbsrc_check_delsys (&dvb_prop[0], SYS_DTMB)) { gst_structure_set (adapter_structure, "dtmb", G_TYPE_STRING, "DTMB", NULL); object->best_guess_delsys = SYS_DTMB; } #endif if (gst_dvbsrc_check_delsys (&dvb_prop[0], SYS_CMMB)) { gst_structure_set (adapter_structure, "cmmb", G_TYPE_STRING, "CMMB", NULL); object->best_guess_delsys = SYS_CMMB; } if (gst_dvbsrc_check_delsys (&dvb_prop[0], SYS_DAB)) { gst_structure_set (adapter_structure, "dab", G_TYPE_STRING, "DAB", NULL); object->best_guess_delsys = SYS_DAB; } if (gst_dvbsrc_check_delsys (&dvb_prop[0], SYS_DVBT2)) { gst_structure_set (adapter_structure, "dvb-t2", G_TYPE_STRING, "DVB-T2", NULL); object->best_guess_delsys = SYS_DVBT2; } if (gst_dvbsrc_check_delsys (&dvb_prop[0], SYS_TURBO)) { gst_structure_set (adapter_structure, "turbo", G_TYPE_STRING, "TURBO", NULL); object->best_guess_delsys = SYS_TURBO; } if (gst_dvbsrc_check_delsys (&dvb_prop[0], SYS_DVBC_ANNEX_C)) { gst_structure_set (adapter_structure, "dvb-c-c", G_TYPE_STRING, "DVB-C ANNEX C", NULL); object->best_guess_delsys = SYS_DVBC_ANNEX_C; } GST_INFO_OBJECT (object, "DVB card: %s ", adapter_name); GST_TRACE_OBJECT (object, "%s description: %" GST_PTR_FORMAT, adapter_name, adapter_structure); gst_element_post_message (GST_ELEMENT_CAST (object), gst_message_new_element (GST_OBJECT (object), adapter_structure)); g_free (frontend_dev); g_free (adapter_name); return TRUE; } static gboolean gst_dvbsrc_open_dvr (GstDvbSrc * object) { gchar *dvr_dev; gint err; dvr_dev = g_strdup_printf ("/dev/dvb/adapter%d/dvr%d", object->adapter_number, object->frontend_number); GST_INFO_OBJECT (object, "Using dvr device: %s", dvr_dev); /* open DVR */ if ((object->fd_dvr = open (dvr_dev, O_RDONLY | O_NONBLOCK)) < 0) { switch (errno) { case ENOENT: GST_ELEMENT_ERROR (object, RESOURCE, NOT_FOUND, (_("Device \"%s\" does not exist."), dvr_dev), (NULL)); break; default: GST_ELEMENT_ERROR (object, RESOURCE, OPEN_READ, (_("Could not open file \"%s\" for reading."), dvr_dev), GST_ERROR_SYSTEM); break; } g_free (dvr_dev); return FALSE; } g_free (dvr_dev); GST_INFO_OBJECT (object, "Setting DVB kernel buffer size to %d ", object->dvb_buffer_size); LOOP_WHILE_EINTR (err, ioctl (object->fd_dvr, DMX_SET_BUFFER_SIZE, object->dvb_buffer_size)); if (err) { GST_INFO_OBJECT (object, "ioctl DMX_SET_BUFFER_SIZE failed (%d)", errno); return FALSE; } return TRUE; } static void gst_dvbsrc_finalize (GObject * _object) { GstDvbSrc *object; GST_DEBUG_OBJECT (_object, "gst_dvbsrc_finalize"); g_return_if_fail (GST_IS_DVBSRC (_object)); object = GST_DVBSRC (_object); /* freeing the mutex segfaults somehow */ g_mutex_clear (&object->tune_mutex); if (G_OBJECT_CLASS (parent_class)->finalize) G_OBJECT_CLASS (parent_class)->finalize (_object); } /* ****************************** * * * Plugin Realization * * * ****************************** */ /* entry point to initialize the plug-in * initialize the plug-in itself * register the element factories and pad templates * register the features */ gboolean gst_dvbsrc_plugin_init (GstPlugin * plugin) { GST_DEBUG_CATEGORY_INIT (gstdvbsrc_debug, "dvbsrc", 0, "DVB Source Element"); return gst_element_register (plugin, "dvbsrc", GST_RANK_NONE, GST_TYPE_DVBSRC); } static GstFlowReturn gst_dvbsrc_read_device (GstDvbSrc * object, int size, GstBuffer ** buffer) { gint count = 0; gint ret_val = 0; GstBuffer *buf = gst_buffer_new_and_alloc (size); GstClockTime timeout = object->timeout * GST_USECOND; GstMapInfo map; g_return_val_if_fail (GST_IS_BUFFER (buf), GST_FLOW_ERROR); if (object->fd_dvr < 0) return GST_FLOW_ERROR; gst_buffer_map (buf, &map, GST_MAP_WRITE); while (count < size) { ret_val = gst_poll_wait (object->poll, timeout); GST_LOG_OBJECT (object, "select returned %d", ret_val); if (G_UNLIKELY (ret_val < 0)) { if (errno == EBUSY) goto stopped; else if (errno == EINTR) continue; else goto select_error; } else if (G_UNLIKELY (!ret_val)) { /* timeout, post element message */ gst_element_post_message (GST_ELEMENT_CAST (object), gst_message_new_element (GST_OBJECT (object), gst_structure_new_empty ("dvb-read-failure"))); } else { int nread = read (object->fd_dvr, map.data + count, size - count); if (G_UNLIKELY (nread < 0)) { GST_WARNING_OBJECT (object, "Unable to read from device: /dev/dvb/adapter%d/dvr%d (%d)", object->adapter_number, object->frontend_number, errno); gst_element_post_message (GST_ELEMENT_CAST (object), gst_message_new_element (GST_OBJECT (object), gst_structure_new_empty ("dvb-read-failure"))); } else count = count + nread; } } gst_buffer_unmap (buf, &map); gst_buffer_resize (buf, 0, count); *buffer = buf; return GST_FLOW_OK; stopped: { GST_DEBUG_OBJECT (object, "stop called"); gst_buffer_unmap (buf, &map); gst_buffer_unref (buf); return GST_FLOW_FLUSHING; } select_error: { GST_ELEMENT_ERROR (object, RESOURCE, READ, (NULL), ("select error %d: %s (%d)", ret_val, g_strerror (errno), errno)); gst_buffer_unmap (buf, &map); gst_buffer_unref (buf); return GST_FLOW_ERROR; } } static GstFlowReturn gst_dvbsrc_create (GstPushSrc * element, GstBuffer ** buf) { gint buffer_size; GstFlowReturn retval = GST_FLOW_ERROR; GstDvbSrc *object; object = GST_DVBSRC (element); GST_LOG ("fd_dvr: %d", object->fd_dvr); buffer_size = DEFAULT_BUFFER_SIZE; /* device can not be tuned during read */ g_mutex_lock (&object->tune_mutex); if (object->fd_dvr > -1) { /* --- Read TS from DVR device --- */ GST_DEBUG_OBJECT (object, "Reading from DVR device"); retval = gst_dvbsrc_read_device (object, buffer_size, buf); if (object->stats_interval && ++object->stats_counter == object->stats_interval) { gst_dvbsrc_output_frontend_stats (object); object->stats_counter = 0; } } g_mutex_unlock (&object->tune_mutex); return retval; } static GstStateChangeReturn gst_dvbsrc_change_state (GstElement * element, GstStateChange transition) { GstDvbSrc *src; GstStateChangeReturn ret; src = GST_DVBSRC (element); ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); switch (transition) { case GST_STATE_CHANGE_NULL_TO_READY: /* open frontend then close it again, just so caps sent */ gst_dvbsrc_open_frontend (src, FALSE); if (src->fd_frontend) { close (src->fd_frontend); } break; default: break; } return ret; } static gboolean gst_dvbsrc_start (GstBaseSrc * bsrc) { GstDvbSrc *src = GST_DVBSRC (bsrc); gst_dvbsrc_open_frontend (src, TRUE); if (!gst_dvbsrc_tune (src)) { GST_ERROR_OBJECT (src, "Not able to lock on to the dvb channel"); gst_dvbsrc_unset_pes_filters (src); close (src->fd_frontend); return FALSE; } if (!gst_dvbsrc_open_dvr (src)) { GST_ERROR_OBJECT (src, "Not able to open dvr_device"); /* unset filters also */ gst_dvbsrc_unset_pes_filters (src); close (src->fd_frontend); return FALSE; } if (!(src->poll = gst_poll_new (TRUE))) { GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ_WRITE, (NULL), ("could not create an fdset: %s (%d)", g_strerror (errno), errno)); /* unset filters also */ gst_dvbsrc_unset_pes_filters (src); close (src->fd_frontend); return FALSE; } else { gst_poll_fd_init (&src->poll_fd_dvr); src->poll_fd_dvr.fd = src->fd_dvr; gst_poll_add_fd (src->poll, &src->poll_fd_dvr); gst_poll_fd_ctl_read (src->poll, &src->poll_fd_dvr, TRUE); } return TRUE; } static gboolean gst_dvbsrc_stop (GstBaseSrc * bsrc) { GstDvbSrc *src = GST_DVBSRC (bsrc); gst_dvbsrc_close_devices (src); if (src->poll) { gst_poll_free (src->poll); src->poll = NULL; } return TRUE; } static gboolean gst_dvbsrc_unlock (GstBaseSrc * bsrc) { GstDvbSrc *src = GST_DVBSRC (bsrc); gst_poll_set_flushing (src->poll, TRUE); return TRUE; } static gboolean gst_dvbsrc_unlock_stop (GstBaseSrc * bsrc) { GstDvbSrc *src = GST_DVBSRC (bsrc); gst_poll_set_flushing (src->poll, FALSE); return TRUE; } static gboolean gst_dvbsrc_is_seekable (GstBaseSrc * bsrc) { return FALSE; } static gboolean gst_dvbsrc_is_valid_modulation (guint delsys, guint mod) { /* FIXME: check valid modulations for other broadcast standards */ switch (delsys) { case SYS_ISDBT: if (mod == QAM_AUTO || mod == QPSK || mod == QAM_16 || mod == QAM_64 || mod == DQPSK) return TRUE; break; default: GST_FIXME ("No delsys/modulation sanity checks implemented for this " "delivery system"); return TRUE; } return FALSE; } static gboolean gst_dvbsrc_get_size (GstBaseSrc * src, guint64 * size) { return FALSE; } static void gst_dvbsrc_do_tune (GstDvbSrc * src) { /* if we are in paused/playing state tune now, otherwise in ready * to paused state change */ if (GST_STATE (src) > GST_STATE_READY) gst_dvbsrc_tune (src); } static void gst_dvbsrc_output_frontend_stats (GstDvbSrc * src) { fe_status_t status; uint16_t snr, _signal; uint32_t ber, bad_blks; GstMessage *message; GstStructure *structure; int fe_fd = src->fd_frontend; gint err; LOOP_WHILE_EINTR (err, ioctl (fe_fd, FE_READ_STATUS, &status)); if (err) goto error_out; LOOP_WHILE_EINTR (err, ioctl (fe_fd, FE_READ_SIGNAL_STRENGTH, &_signal)); if (err) goto error_out; LOOP_WHILE_EINTR (err, ioctl (fe_fd, FE_READ_SNR, &snr)); if (err) goto error_out; LOOP_WHILE_EINTR (err, ioctl (fe_fd, FE_READ_BER, &ber)); if (err) goto error_out; LOOP_WHILE_EINTR (err, ioctl (fe_fd, FE_READ_UNCORRECTED_BLOCKS, &bad_blks)); if (err) goto error_out; structure = gst_structure_new ("dvb-frontend-stats", "status", G_TYPE_INT, status, "signal", G_TYPE_INT, _signal, "snr", G_TYPE_INT, snr, "ber", G_TYPE_INT, ber, "unc", G_TYPE_INT, bad_blks, "lock", G_TYPE_BOOLEAN, status & FE_HAS_LOCK, NULL); message = gst_message_new_element (GST_OBJECT (src), structure); gst_element_post_message (GST_ELEMENT (src), message); return; error_out: GST_WARNING_OBJECT (src, "Failed to get statistics from the device: %s", g_strerror (errno)); } struct diseqc_cmd { struct dvb_diseqc_master_cmd cmd; uint32_t wait; }; static void diseqc_send_msg (int fd, fe_sec_voltage_t v, struct diseqc_cmd *cmd, fe_sec_tone_mode_t t, fe_sec_mini_cmd_t b) { gint err; LOOP_WHILE_EINTR (err, ioctl (fd, FE_SET_TONE, SEC_TONE_OFF)); if (err) { GST_ERROR ("Setting tone to off failed"); return; } LOOP_WHILE_EINTR (err, ioctl (fd, FE_SET_VOLTAGE, v)); if (err) { GST_ERROR ("Setting voltage failed"); return; } g_usleep (15 * 1000); GST_LOG ("diseqc: 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x", cmd->cmd.msg[0], cmd->cmd.msg[1], cmd->cmd.msg[2], cmd->cmd.msg[3], cmd->cmd.msg[4], cmd->cmd.msg[5]); LOOP_WHILE_EINTR (err, ioctl (fd, FE_DISEQC_SEND_MASTER_CMD, &cmd->cmd)); if (err) { GST_ERROR ("Sending DiSEqC command failed"); return; } g_usleep (cmd->wait * 1000); g_usleep (15 * 1000); LOOP_WHILE_EINTR (err, ioctl (fd, FE_DISEQC_SEND_BURST, b)); if (err) { GST_ERROR ("Sending burst failed"); return; } g_usleep (15 * 1000); LOOP_WHILE_EINTR (err, ioctl (fd, FE_SET_TONE, t)); if (err) { GST_ERROR ("Setting tone failed"); return; } } /* digital satellite equipment control, * specification is available from http://www.eutelsat.com/ */ static void diseqc (int secfd, int sat_no, int voltage, int tone) { struct diseqc_cmd cmd = { {{0xe0, 0x10, 0x38, 0xf0, 0x00, 0x00}, 4}, 0 }; /* param: high nibble: reset bits, low nibble set bits, * bits are: option, position, polarizaion, band */ cmd.cmd.msg[3] = 0xf0 | (((sat_no * 4) & 0x0f) | (tone == SEC_TONE_ON ? 1 : 0) | (voltage == SEC_VOLTAGE_13 ? 0 : 2)); /* send twice because some DiSEqC switches do not respond correctly the * first time */ diseqc_send_msg (secfd, voltage, &cmd, tone, sat_no % 2 ? SEC_MINI_B : SEC_MINI_A); diseqc_send_msg (secfd, voltage, &cmd, tone, sat_no % 2 ? SEC_MINI_B : SEC_MINI_A); } inline static void set_prop (struct dtv_property *props, int *n, guint32 cmd, guint32 data) { if (*n == NUM_DTV_PROPS) { g_critical ("Index out of bounds"); } else { props[*n].cmd = cmd; props[(*n)++].u.data = data; } } static gboolean gst_dvbsrc_tune_fe (GstDvbSrc * object) { GstPoll *poll_set; GstPollFD fe_fd; fe_status_t status; struct dtv_properties props; struct dtv_property dvb_prop[NUM_DTV_PROPS]; GstClockTimeDiff elapsed_time, timeout_step = 500 * GST_MSECOND; GstClockTime start; gint err; GST_DEBUG_OBJECT (object, "Starting the frontend tuning process"); if (object->fd_frontend < 0) { GST_INFO_OBJECT (object, "Frontend not open: tuning later"); return FALSE; } GST_DEBUG_OBJECT (object, "check delivery systems"); dvb_prop[0].cmd = DTV_ENUM_DELSYS; props.num = 1; props.props = dvb_prop; LOOP_WHILE_EINTR (err, ioctl (object->fd_frontend, FE_GET_PROPERTY, &props)); if (err) { GST_WARNING_OBJECT (object, "Error enumerating delsys: %s", g_strerror (errno)); return FALSE; } /* If there's no delivery system set yet. Choose the * last from the list of frontend supported ones */ if (object->delsys == SYS_UNDEFINED) { object->delsys = object->best_guess_delsys; } else if (!gst_dvbsrc_check_delsys (&dvb_prop[0], object->delsys)) { GST_WARNING_OBJECT (object, "Delsys fail %u", object->delsys); return FALSE; } gst_dvbsrc_unset_pes_filters (object); g_mutex_lock (&object->tune_mutex); gst_poll_fd_init (&fe_fd); fe_fd.fd = object->fd_frontend; poll_set = gst_poll_new (TRUE); if (!gst_poll_add_fd (poll_set, &fe_fd)) { GST_WARNING_OBJECT (object, "Could not add frontend fd to poll set"); goto fail; } gst_poll_fd_ctl_read (poll_set, &fe_fd, TRUE); memset (dvb_prop, 0, sizeof (dvb_prop)); dvb_prop[0].cmd = DTV_CLEAR; LOOP_WHILE_EINTR (err, ioctl (object->fd_frontend, FE_SET_PROPERTY, &props)); if (err) { GST_WARNING_OBJECT (object, "Error resetting tuner: %s", g_strerror (errno)); } memset (dvb_prop, 0, sizeof (dvb_prop)); if (!gst_dvbsrc_set_fe_params (object, &props)) { GST_WARNING_OBJECT (object, "Could not set frontend params"); goto fail; } GST_DEBUG_OBJECT (object, "Setting %d properties", props.num); LOOP_WHILE_EINTR (err, ioctl (object->fd_frontend, FE_SET_PROPERTY, &props)); if (err) { GST_WARNING_OBJECT (object, "Error tuning channel: %s (%d)", g_strerror (errno), errno); goto fail; } g_signal_emit (object, gst_dvbsrc_signals[SIGNAL_TUNING_START], 0); LOOP_WHILE_EINTR (err, ioctl (object->fd_frontend, FE_READ_STATUS, &status)); if (err) { GST_WARNING_OBJECT (object, "Failed querying frontend for tuning status:" " %s (%d)", g_strerror (errno), errno); goto fail_with_signal; } /* signal locking loop */ elapsed_time = 0; start = gst_util_get_timestamp (); while (!(status & FE_HAS_LOCK) && elapsed_time <= object->tuning_timeout) { if (gst_poll_wait (poll_set, timeout_step) == -1) goto fail_with_signal; LOOP_WHILE_EINTR (err, ioctl (object->fd_frontend, FE_READ_STATUS, &status)); if (err) { GST_WARNING_OBJECT (object, "Failed querying frontend for tuning status" " %s (%d)", g_strerror (errno), errno); goto fail_with_signal; } gst_dvbsrc_output_frontend_stats (object); /* keep retrying forever if tuning_timeout = 0 */ if (object->tuning_timeout) elapsed_time = GST_CLOCK_DIFF (start, gst_util_get_timestamp ()); GST_LOG_OBJECT (object, "Tuning. Time elapsed %" G_GUINT64_FORMAT " Limit %" G_GUINT64_FORMAT, elapsed_time, object->tuning_timeout); } if (!(status & FE_HAS_LOCK)) { GST_WARNING_OBJECT (object, "Unable to lock on signal at desired frequency"); goto fail_with_signal; } GST_LOG_OBJECT (object, "status == 0x%02x", status); g_signal_emit (object, gst_dvbsrc_signals[SIGNAL_TUNING_DONE], 0); GST_DEBUG_OBJECT (object, "Successfully set frontend tuning params"); gst_poll_free (poll_set); g_mutex_unlock (&object->tune_mutex); return TRUE; fail_with_signal: g_signal_emit (object, gst_dvbsrc_signals[SIGNAL_TUNING_FAIL], 0); fail: GST_WARNING_OBJECT (object, "Could not tune to desired frequency"); gst_poll_free (poll_set); g_mutex_unlock (&object->tune_mutex); return FALSE; } static gboolean gst_dvbsrc_set_fe_params (GstDvbSrc * object, struct dtv_properties *props) { fe_sec_voltage_t voltage; unsigned int freq = object->freq; unsigned int sym_rate = object->sym_rate * 1000; int inversion = object->inversion; int n; gint err; /* first 3 entries are reserved */ n = 3; /** * We are not dropping out but issuing a warning in case of wrong * parameter combinations as failover behavior should be mandated * by the driver. Worst case scenario it will just fail at tuning. */ switch (object->delsys) { case SYS_DVBS: case SYS_DVBS2: case SYS_TURBO: if (freq > 2200000) { /* this must be an absolute frequency */ if (freq < object->lnb_slof) { freq -= object->lnb_lof1; object->tone = SEC_TONE_OFF; } else { freq -= object->lnb_lof2; object->tone = SEC_TONE_ON; } } inversion = INVERSION_AUTO; set_prop (props->props, &n, DTV_SYMBOL_RATE, sym_rate); set_prop (props->props, &n, DTV_INNER_FEC, object->code_rate_hp); GST_INFO_OBJECT (object, "Tuning DVB-S/DVB-S2/Turbo to L-Band:%u, Pol:%d, srate=%u, 22kHz=%s", freq, object->pol, sym_rate, object->tone == SEC_TONE_ON ? "on" : "off"); if (object->pol == DVB_POL_H) voltage = SEC_VOLTAGE_18; else voltage = SEC_VOLTAGE_13; if (object->diseqc_src == -1 || object->send_diseqc == FALSE) { set_prop (props->props, &n, DTV_VOLTAGE, voltage); /* DTV_TONE not yet implemented * set_prop (fe_props_array, &n, DTV_TONE, object->tone) */ LOOP_WHILE_EINTR (err, ioctl (object->fd_frontend, FE_SET_TONE, object->tone)); if (err) { GST_WARNING_OBJECT (object, "Couldn't set tone: %s", g_strerror (errno)); } } else { GST_DEBUG_OBJECT (object, "Sending DiSEqC"); diseqc (object->fd_frontend, object->diseqc_src, voltage, object->tone); /* Once DiSEqC source is set, do not set it again until * app decides to change it * object->send_diseqc = FALSE; */ } if ((object->delsys == SYS_DVBS2) || (object->delsys == SYS_TURBO)) set_prop (props->props, &n, DTV_MODULATION, object->modulation); if (object->delsys == SYS_DVBS2) { set_prop (props->props, &n, DTV_PILOT, object->pilot); set_prop (props->props, &n, DTV_ROLLOFF, object->rolloff); set_prop (props->props, &n, DTV_STREAM_ID, object->stream_id); } break; case SYS_DVBT: case SYS_DVBT2: if (object->delsys == SYS_DVBT) { if (object->transmission_mode != TRANSMISSION_MODE_AUTO && object->transmission_mode != TRANSMISSION_MODE_2K && object->transmission_mode != TRANSMISSION_MODE_8K) { GST_WARNING_OBJECT (object, "Wrong DVB-T parameter combination: " "transmission mode should be either AUTO, 2K or 8K"); } if (object->bandwidth != 6000000 && object->bandwidth != 7000000 && object->bandwidth != 8000000) { GST_WARNING_OBJECT (object, "Wrong DVB-T parameter value: bandwidth " "is %d but only 6, 7 and 8 MHz are allowed", object->bandwidth); } } else if (object->delsys == SYS_DVBT2) { if (object->transmission_mode != TRANSMISSION_MODE_AUTO && object->transmission_mode != TRANSMISSION_MODE_1K && object->transmission_mode != TRANSMISSION_MODE_2K && object->transmission_mode != TRANSMISSION_MODE_4K && object->transmission_mode != TRANSMISSION_MODE_8K && object->transmission_mode != TRANSMISSION_MODE_16K && object->transmission_mode != TRANSMISSION_MODE_32K) { GST_WARNING_OBJECT (object, "Wrong DVB-T2 parameter combination: " "transmission mode should be either AUTO, 1K, 2K, 4K, 8K, 16K " "or 32K"); } } set_prop (props->props, &n, DTV_BANDWIDTH_HZ, object->bandwidth); set_prop (props->props, &n, DTV_CODE_RATE_HP, object->code_rate_hp); set_prop (props->props, &n, DTV_CODE_RATE_LP, object->code_rate_lp); set_prop (props->props, &n, DTV_MODULATION, object->modulation); set_prop (props->props, &n, DTV_TRANSMISSION_MODE, object->transmission_mode); set_prop (props->props, &n, DTV_GUARD_INTERVAL, object->guard_interval); set_prop (props->props, &n, DTV_HIERARCHY, object->hierarchy_information); if (object->delsys == SYS_DVBT2) { set_prop (props->props, &n, DTV_STREAM_ID, object->stream_id); } GST_INFO_OBJECT (object, "Tuning DVB-T/DVB_T2 to %d Hz", freq); break; case SYS_DVBC_ANNEX_A: case SYS_DVBC_ANNEX_B: #if HAVE_V5_MINOR(6) case SYS_DVBC_ANNEX_C: #endif GST_INFO_OBJECT (object, "Tuning DVB-C/ClearCable to %d, srate=%d", freq, sym_rate); set_prop (props->props, &n, DTV_MODULATION, object->modulation); if (object->delsys != SYS_DVBC_ANNEX_B) { set_prop (props->props, &n, DTV_INNER_FEC, object->code_rate_hp); set_prop (props->props, &n, DTV_SYMBOL_RATE, sym_rate); } break; case SYS_ATSC: GST_INFO_OBJECT (object, "Tuning ATSC to %d", freq); set_prop (props->props, &n, DTV_MODULATION, object->modulation); break; case SYS_ISDBT: if (object->isdbt_partial_reception == 1 && object->isdbt_layera_segment_count != 1) { GST_WARNING_OBJECT (object, "Wrong ISDB-T parameter combination: " "partial reception is set but layer A segment count is not 1"); } if (!object->isdbt_sound_broadcasting) { GST_INFO_OBJECT (object, "ISDB-T sound broadcasting is not set. " "Driver will likely ignore values set for isdbt-sb-subchannel-id, " "isdbt-sb-segment-idx and isdbt-sb-segment-count"); } if (object->isdbt_layerc_modulation == DQPSK && object->isdbt_layerb_modulation != DQPSK) { GST_WARNING_OBJECT (object, "Wrong ISDB-T parameter combination: " "layer C modulation is DQPSK but layer B modulation is different"); } if (object->bandwidth != 6000000) { GST_WARNING_OBJECT (object, "Wrong ISDB-T parameter value: bandwidth " "is %d but only 6 MHz is allowed", object->bandwidth); } GST_INFO_OBJECT (object, "Tuning ISDB-T to %d", freq); set_prop (props->props, &n, DTV_BANDWIDTH_HZ, object->bandwidth); set_prop (props->props, &n, DTV_GUARD_INTERVAL, object->guard_interval); set_prop (props->props, &n, DTV_TRANSMISSION_MODE, object->transmission_mode); set_prop (props->props, &n, DTV_ISDBT_LAYER_ENABLED, object->isdbt_layer_enabled); set_prop (props->props, &n, DTV_ISDBT_PARTIAL_RECEPTION, object->isdbt_partial_reception); set_prop (props->props, &n, DTV_ISDBT_SOUND_BROADCASTING, object->isdbt_sound_broadcasting); set_prop (props->props, &n, DTV_ISDBT_SB_SUBCHANNEL_ID, object->isdbt_sb_subchannel_id); set_prop (props->props, &n, DTV_ISDBT_SB_SEGMENT_IDX, object->isdbt_sb_segment_idx); set_prop (props->props, &n, DTV_ISDBT_SB_SEGMENT_COUNT, object->isdbt_sb_segment_count); set_prop (props->props, &n, DTV_ISDBT_LAYERA_FEC, object->isdbt_layera_fec); set_prop (props->props, &n, DTV_ISDBT_LAYERA_MODULATION, object->isdbt_layera_modulation); set_prop (props->props, &n, DTV_ISDBT_LAYERA_SEGMENT_COUNT, object->isdbt_layera_segment_count); set_prop (props->props, &n, DTV_ISDBT_LAYERA_TIME_INTERLEAVING, object->isdbt_layera_time_interleaving); set_prop (props->props, &n, DTV_ISDBT_LAYERB_FEC, object->isdbt_layerb_fec); set_prop (props->props, &n, DTV_ISDBT_LAYERB_MODULATION, object->isdbt_layerb_modulation); set_prop (props->props, &n, DTV_ISDBT_LAYERB_SEGMENT_COUNT, object->isdbt_layerb_segment_count); set_prop (props->props, &n, DTV_ISDBT_LAYERB_TIME_INTERLEAVING, object->isdbt_layerb_time_interleaving); set_prop (props->props, &n, DTV_ISDBT_LAYERC_FEC, object->isdbt_layerc_fec); set_prop (props->props, &n, DTV_ISDBT_LAYERC_MODULATION, object->isdbt_layerc_modulation); set_prop (props->props, &n, DTV_ISDBT_LAYERC_SEGMENT_COUNT, object->isdbt_layerc_segment_count); set_prop (props->props, &n, DTV_ISDBT_LAYERC_TIME_INTERLEAVING, object->isdbt_layerc_time_interleaving); break; #if HAVE_V5_MINOR(7) case SYS_DTMB: set_prop (props->props, &n, DTV_BANDWIDTH_HZ, object->bandwidth); set_prop (props->props, &n, DTV_MODULATION, object->modulation); set_prop (props->props, &n, DTV_INVERSION, object->inversion); set_prop (props->props, &n, DTV_INNER_FEC, object->code_rate_hp); set_prop (props->props, &n, DTV_TRANSMISSION_MODE, object->transmission_mode); set_prop (props->props, &n, DTV_GUARD_INTERVAL, object->guard_interval); set_prop (props->props, &n, DTV_INTERLEAVING, object->interleaving); /* FIXME: Make the LNA on/off switch a property and proxy on dvbbasebin */ /* FIXME: According to v4l advice (see libdvbv5 implementation) this * property should be set separately as not all drivers will ignore it * if unsupported. An alternative would be to get the dvb API contract * revised on this regard */ set_prop (props->props, &n, DTV_LNA, LNA_AUTO); GST_INFO_OBJECT (object, "Tuning DTMB to %d Hz", freq); break; #endif default: GST_ERROR_OBJECT (object, "Unknown frontend type %u", object->delsys); return FALSE; } if (!gst_dvbsrc_is_valid_modulation (object->delsys, object->modulation)) { GST_WARNING_OBJECT (object, "Attempting an invalid modulation/delsys combination"); } set_prop (props->props, &n, DTV_TUNE, 0); props->num = n; /* set first three entries */ n = 0; set_prop (props->props, &n, DTV_DELIVERY_SYSTEM, object->delsys); set_prop (props->props, &n, DTV_FREQUENCY, freq); set_prop (props->props, &n, DTV_INVERSION, inversion); return TRUE; } static gboolean gst_dvbsrc_tune (GstDvbSrc * object) { /* found in mail archive on linuxtv.org * What works well for us is: * - first establish a TS feed (i.e. tune the frontend and check for success) * - then set filters (PES/sections) * - then tell the MPEG decoder to start * - before tuning: first stop the MPEG decoder, then stop all filters */ if (!gst_dvbsrc_tune_fe (object)) { GST_WARNING_OBJECT (object, "Unable to tune frontend"); return FALSE; } gst_dvbsrc_set_pes_filters (object); return TRUE; } static void gst_dvbsrc_unset_pes_filters (GstDvbSrc * object) { int i = 0; GST_INFO_OBJECT (object, "clearing PES filter"); for (i = 0; i < MAX_FILTERS; i++) { if (object->fd_filters[i] == -1) continue; close (object->fd_filters[i]); object->fd_filters[i] = -1; } } static void gst_dvbsrc_set_pes_filters (GstDvbSrc * object) { int *fd; int pid, i; struct dmx_pes_filter_params pes_filter; gint err; gchar *demux_dev = g_strdup_printf ("/dev/dvb/adapter%d/demux%d", object->adapter_number, object->frontend_number); GST_INFO_OBJECT (object, "Setting PES filter"); for (i = 0; i < MAX_FILTERS; i++) { if (object->pids[i] == G_MAXUINT16) break; fd = &object->fd_filters[i]; pid = object->pids[i]; if (*fd >= 0) close (*fd); if ((*fd = open (demux_dev, O_RDWR)) < 0) { GST_ERROR_OBJECT (object, "Error opening demuxer: %s (%s)", g_strerror (errno), demux_dev); continue; } g_return_if_fail (*fd != -1); pes_filter.pid = pid; pes_filter.input = DMX_IN_FRONTEND; pes_filter.output = DMX_OUT_TS_TAP; pes_filter.pes_type = DMX_PES_OTHER; pes_filter.flags = DMX_IMMEDIATE_START; GST_INFO_OBJECT (object, "Setting pes-filter, pid = %d, type = %d", pes_filter.pid, pes_filter.pes_type); LOOP_WHILE_EINTR (err, ioctl (*fd, DMX_SET_PES_FILTER, &pes_filter)); if (err) GST_WARNING_OBJECT (object, "Error setting PES filter on %s: %s", demux_dev, g_strerror (errno)); } g_free (demux_dev); }