Stuff

import gobject
gobject.threads_init ()
import gst
import sys

class Switch (object):
    def __init__ (self):
        self.loop = gobject.MainLoop ()
        self.pipeline = gst.Pipeline ()
        self.bus = self.pipeline.get_bus ()
        self.bus.add_signal_watch ()
        self.bus.connect ("message::eos", self._bus_eos_cb)
        self.bus.connect ("message::error", self._bus_error_cb)

        self.src = gst.element_factory_make ("filesrc")
        self.src.props.location = sys.argv [1]gdfg

        self.queue = gst.element_factory_make ("queue")
        self.queue.props.max_size_buffers = 0

        self.mpegtsparse = gst.element_factory_make ("mpegtsparse")
        self.mpegtsparse.connect ("pad-added", self._mpegtsparse_pad_added_cb)
        self.mpegtsparse.connect ("pad-removed", self._mpegtsparse_pad_removed_cb)
        self.mpegtsparse.props.program_numbers = str (sys.argv [2])
        self.mpegtsparse.get_pad ("src").add_data_probe (self._mpegtsparse_shaddup_cb)

        self.xvimagesink = gst.element_factory_make ("xvimagesink")
        self.xvimagesink.props.sync = False

        self.pipeline.add (self.src, self.queue, self.mpegtsparse, self.xvimagesink)
        gst.element_link_many (self.src, self.queue, self.mpegtsparse)

        self.have_video = False

    def _mpegtsparse_shaddup_cb (self, pad, buffer):
        return False

    def _mpegtsparse_pad_added_cb (self, mpegtsparse, pad):
        print "mpegtpsarse pad added", pad
        program_number = pad.get_name ().split ("_")[1]
        self.flutsdemux = gst.element_factory_make ("flutsdemux")
        self.pipeline.add (self.flutsdemux)
        self.flutsdemux.props.program_number = int (program_number)
        self.flutsdemux.connect ("pad-added", self._flutsdemux_pad_added_cb)
        self.flutsdemux.set_state (gst.STATE_PLAYING)
        pad.link (self.flutsdemux.get_pad ("sink"))

    def _mpegtsparse_pad_removed_cb (self, mpegtsparse, pad):
        print "mpegtpsarse pad removed", pad
        self.pipeline.remove (self.flutsdemux)
        self.flutsdemux.set_state (gst.STATE_NULL)
        self.flutsdemux = None
        self.pipeline.remove (self.mpeg2dec)
        self.mpeg2dec.set_state (gst.STATE_NULL)
        self.mpeg2dec = None
        self.have_video = False

    def _flutsdemux_pad_added_cb (self, flutsdemux, pad):
        if pad.get_name ().startswith ("video_") and not self.have_video:
            print "linking flutsdemux pad", pad
            self.mpeg2dec = gst.element_factory_make ("mpeg2dec")
            self.pipeline.add (self.mpeg2dec)
            self.mpeg2dec.link (self.xvimagesink)
            self.mpeg2dec.set_state (gst.STATE_PLAYING)
            pad.link (self.mpeg2dec.get_pad ("sink"))
            self.have_video = True

    def _bus_error_cb (self, bus, message):
        print "ERROR", message
        self.loop.quit ()
    
    def _bus_eos_cb (self, bus, message):
        print "ERROR", message
        self.loop.quit ()

    def _switch_channel_cb (self):
        self.mpegtsparse.props.program_numbers = str (sys.argv [3])

    def run (self):
        self.pipeline.set_state (gst.STATE_PLAYING)
        gobject.timeout_add (10000, self._switch_channel_cb)
        try:
            self.loop.run ()
        finally:
            self.pipeline.set_state (gst.STATE_NULL)

def main ():
    Switch ().run ()

if __name__ == '__main__':
    main ()