import sys
import gobject
gobject.threads_init ()
import gst

class PlayScaled (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_message_eos_cb)
        self.bus.connect ("message::error", self._bus_message_error_cb)

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

        self.decodebin = gst.element_factory_make ("decodebin")
        self.decodebin.connect ("new-decoded-pad", self._new_decoded_pad_cb)
        self.pipeline.add (self.decodebin)

        self.src.link (self.decodebin)

    def _bus_message_eos_cb (self, bus, message):
        print "EOS"
        self.loop.quit ()

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

    def _new_decoded_pad_cb (self, decodebin, pad, no_more):
        caps = pad.get_caps ()
        capsstr = str (caps)
        print "NEW PAD", str (pad), str (pad.get_caps ())
        if capsstr.startswith ("image/") or capsstr.startswith ("video/"):
            fcaps = gst.Caps (caps [0].get_name () + ", width=200, height=200")
            capsfilter = gst.element_factory_make ("capsfilter")
            capsfilter.props.caps = fcaps
            self.pipeline.add (capsfilter)
            videoscale = gst.element_factory_make ("videoscale")
            self.pipeline.add (videoscale)
            pad.link (videoscale.get_pad ("sink"))
            videoscale.link (capsfilter)
            csp = gst.element_factory_make ("ffmpegcolorspace")
            self.pipeline.add (csp)
            capsfilter.link (csp)
            sink = gst.element_factory_make ("ximagesink")
            self.pipeline.add (sink)
            csp.link (sink)

            for e in (videoscale, capsfilter, csp, sink):
                e.set_state (gst.STATE_PLAYING)

    def play (self):
        self.pipeline.set_state (gst.STATE_PLAYING)
        self.loop.run ()
        self.pipeline.set_state (gst.STATE_NULL)

PlayScaled ().play ()