video.py

import gobject, pygst
pygst.require('0.10')
import gst
from PyQt4.QtGui import QMainWindow, QWidget, QApplication
import sys

class Video(QMainWindow):
    def __init__(self):
        QMainWindow.__init__(self)
        container = QWidget()
        self.setCentralWidget(container)
        self.windowId = container.winId()
        self.setGeometry(300,300,800,600)
        self.show()

        self.pipeline = gst.Pipeline("player")
        #~ sel

    def setupLocal(self):

        self.source = gst.element_factory_make("v4l2src", "source")

        self.vidcolorspace = gst.element_factory_make("ffmpegcolorspace","vidcolorspace")
        self.imgcolorspace = gst.element_factory_make("ffmpegcolorspace","imgcolorspace")
        self.tee = gst.element_factory_make("tee", "tee")

        self.vidqueue = gst.element_factory_make("queue", "videoqueue")
        self.imgqueue = gst.element_factory_make("queue", "imgqueue")

        self.sink = gst.element_factory_make("xvimagesink", "sink")
        self.fvidscale_cap = gst.element_factory_make("capsfilter", "fvidscale_cap")
        self.fvidscale = gst.element_factory_make("videoscale", "fvidscale")
        self.caps = gst.caps_from_string('video/x-raw-yuv')
        self.fvidscale_cap.set_property('caps', caps)
        self.source.set_property("device", "/dev/video1")

        self.imagesink = gst.element_factory_make("fakesink", "image_sink");

        self.pipeline.add(self.source, self.fvidscale, self.fvidscale_cap, self.colorspace, self.tee,\
            self.vidqueue, self.sink, self.imgqueue, self.imgsink)
        gst.element_link_many(self.source, self.fvidscale, self.fvidscale_cap, self.colorspace, self.tee,\
            self.vidqueue, self.sink)
        gst.element_link_many(self.source, self.fvidscale, self.fvidscale_cap, self.colorspace, self.tee,\
            self.imgqueue, self.imgsink)

        self.imgsink.set_property("signal-handoffs", True)
        fakesink.connect("handoff", buffer_cb)

        self.bus = self.pipeline.get_bus()
        self.bus.add_signal_watch()
        self.bus.enable_sync_message_emission()
        self.bus.connect("message", self.on_message)
        self.bus.connect("sync-message::element", self.on_sync_message)

        self.start_preview()

    #~ def setupRTSP(self, loc):
        #~ pipeline = gst.parse_launch("rtspsrc location=rtsp://localhost:9400/test name=source latency=0 ! decodebin2 ! autovideosink")
        #~ source = pipeline.get_by_name("source")
        #~ source.props.location =  loc
        #~
        #~ source = gst.element_factory_make("rtspsrc", "source")
        #~ source.set_property("location", loc)
        #~
        #~ decode = gst.element_factory_make("decodebin2", "decoder")
        #~ decode.connect("new-decoded-pad", self.OnDynamicPad)
        #~
        #~ self.sink = gst.element_factory_make("xvimagesink", "sink")
        #~ fvidscale_cap = gst.element_factory_make("capsfilter", "fvidscale_cap")
        #~ fvidscale = gst.element_factory_make("videoscale", "fvidscale")
        #~ caps = gst.caps_from_string('video/x-raw-yuv, width=800,height=600')
        #~ fvidscale_cap.set_property('caps', caps)
        #~
        #~ self.convert = gst.element_factory_make("autovideoconvert", "sink")
        #~
        #~ self.pipeline.add(source)
        #~ self.pipeline.add(decode)
        #~ self.pipeline.add(fvidscale)
        #~ self.pipeline.add(fvidscale_cap)
        #~ self.pipeline.add(self.convert)
        #~ self.pipeline.add(sink)

    #~ def getImage(self):
        #~
        #~ self.stop_preview(fileloc)
        #~
        #~ self.pipeline.remove(self.sink)
        #~ pngenc = gst.element_factory_make("pngenc","pngencoder")
        #~ pngenc.set_property("snapshot","true")
        #~
        #~ filesink = gst.element_factory_make("filesink")
        #~ filesink.set_property("location", fileloc)
        #~
        #~ self.pipeline.add(pngeng, filesink)
        #~ gst.element_link_many(self.source, self.fvidscale, self.fvidscale_cap, self.colorspace, pngenc, filesink)
        #~
        #~ self.bus = self.pipeline.get_bus()
        #~ self.bus.add_signal_watch()
        #~ self.bus.enable_sync_message_emission()
        #~ self.bus.connect("message", self.on_message)
        #~ self.bus.connect("sync-message::element", self.on_sync_message)
        #~
        #~
        #~ self.start_preview()
        #~
        #~ # Wait for a picture to finish
        #~ msg = bus.poll(gst.MESSAGE_EOS|gst.MESSAGE_ERROR, -1)
        #~ if msg.type == gst.MESSAGE_ERROR:
            #~ err,debug = msg.parse_error()
            #~ raise Exception(debug)
#~
        #~ self.stop_preview()
        #~
        #~ self.pipeline.remove(filesink)

    def OnDynamicPad(self, dbin, pad, islast):
        print "OnDynamicPad Called!"
        pad.link(self.convert.get_pad("sink"))

    def on_message(self, bus, message):

        t = message.type
        if t == gst.MESSAGE_EOS:
            self.pipeline.set_state(gst.STATE_NULL)
            print "end of message"
        elif t == gst.MESSAGE_ERROR:
            err, debug = message.parse_error()
            print "Error: %s" % err, debug
            self.pipeline.set_state(gst.STATE_NULL)

    def on_sync_message(self, bus, message):
        if message.structure is None:
            return
        message_name = message.structure.get_name()
        if message_name == "prepare-xwindow-id":
            win_id = self.windowId
            assert win_id
            imagesink = message.src
            imagesink.set_xwindow_id(win_id)

    def start_preview(self):
        self.pipeline.set_state(gst.STATE_PLAYING)
        print "should be playing"

    def stop_preview(self):
        """
        Stop the preview from the camera
        """
        if self.pipeline:
            self.pipe.set_state(gst.STATE_NULL)
            print "should be stopped"

#~ if __name__ == "__main__":
    #~ gobject.threads_init()
    #~ app = QApplication(sys.argv)
    #~ video = Video()
    #~ video.setUpGst()
    #~ video.startPrev()
    #~ sys.exit(app.exec_())