import pygst pygst.require("0.10") import gst import gobject class Media: class StreamData: stream_count = 0 def __init__ (self, pipe, abin, vbin): self.stream_count += 1 self.Id = self.stream_count self.Pipe = pipe self.Abin = abin self.Vbin = vbin self.Loop = gobject.MainLoop() self.ACaps = "" self.VCaps = "" self.Ready = False def __init__(self, config): # set gstreamer basic options self.config = config self.pipe = None self.streams = [] def setup(self, filename, mux, vcodec, vbitrate, fps, acodec, abitrate, width, height, port, options): ## Pipelines self.pipe = gst.Pipeline () uri = "file://" + filename print "Opening Uri:" + uri src = gst.element_make_from_uri (gst.URI_SRC, uri, "src") if (src is None): return None decode = gst.element_factory_make ("decodebin", "decode") if (decode is None): return None #video encode #queue ! videoscale ! video/x-raw-yuv,width=240,height=144 ! videorate ! ffenc_h263p bitrate=256000 me-method=2 ! rtph263ppay ! udpsink host=224.0.0.1 port=5000 vbin = gst.Bin () vqueue = gst.element_factory_make ("queue", "vqueue") vscale = gst.element_factory_make ("videoscale", "vscale") vrate = gst.element_factory_make ("videorate", "vrate") vencode = gst.element_factory_make ("ffenc_mpeg4", "vencode") vpay = gst.element_factory_make ("rtpmp4vpay", "vpay") vsink = gst.element_factory_make ("udpsink", "vsink") if (None in [vbin, vqueue, vscale, vrate, vencode, vpay, vsink]): print "Fail to create video encode elements." return None vscale_pad = vscale.get_pad("sink") if (vscale_pad is None): print "Fail to get vscale sink pad." return None vscale_caps = gst.caps_from_string ("video/x-raw-yuv, width=%s, height=%s" % (width, height)) if (vscale_caps is None): print "Fail to create video caps" return None if (not vscale_pad.set_caps (vscale_caps)): print "Fail to set video output caps" return None vencode.set_property ("bitrate", 256000) vencode.set_property ("me-method", 2) vsink.set_property ("host", "224.0.0.1") vsink.set_property ("port", 5000) vbin.add (vqueue, vscale, vrate, vencode, vpay, vsink) if (not gst.element_link_many (vqueue, vscale, vrate, vencode, vpay, vsink)): print "Fail to link video elements" return None vbin.add_pad (gst.GhostPad ("sink", vqueue.get_pad ("sink"))) #audio encode #audio/x-raw-int ! queue ! audioconvert ! faac ! rtpmp4gpay ! udpsink name=upd_audio host=224.0.0.1 port=5002 abin = gst.Bin () aqueue = gst.element_factory_make ("queue", "vqueue") aconvert = gst.element_factory_make ("audioconvert", "aconvert") aencode = gst.element_factory_make ("faac", "aencode") apay = gst.element_factory_make ("rtpmp4gpay", "apay") asink = gst.element_factory_make ("udpsink", "asink") if (None in [abin, aqueue, aconvert, aencode, apay, asink]): print "Fail to create video encode elements." return None asink.set_property ("host", "224.0.0.1") asink.set_property ("port", 5002) abin.add (aqueue, aconvert, aencode, apay, asink) if (not gst.element_link_many (aqueue, aconvert, aencode, apay, asink)): print "Fail to link video elements" return None abin.add_pad (gst.GhostPad ("sink", aqueue.get_pad ("sink"))) self.pipe.add (src, decode, abin, vbin) gst.element_link_many (src, decode) stream_data = self.StreamData (self.pipe, abin, vbin) bus = self.pipe.get_bus() bus.add_signal_watch() bus.connect("message", self.__on_bus_message, stream_data) decode.connect("new-decoded-pad", self.__on_decode_new_pad, stream_data) decode.connect("unknown-type", self.__on_decode_unknown_type, stream_data) self.pipe.set_state (gst.STATE_PAUSED) print "Running Pipe" stream_data.Loop.run () print "End run" a_caps = stream_data.ACaps v_caps = stream_data.VCaps stream_id = stream_data.Id self.streams.append (stream_data) def play(self): print "Trying to play pipeline: %s" % self.pipe try: if (self.pipe): self.pipe.set_state(gst.STATE_PLAYING) except gobject.GError, e: print "Error: " + str(e) def stop(self): print "Trying to stop pipeline: %s" % self.pipe try: if (self.pipeline): self.pipeline.set_state(gst.STATE_NULL) except gobject.GError, e: print "Error: " + str(e) def __on_bus_message (self, bus, message, stream_data): t = message.type if (t == gst.MESSAGE_STATE_CHANGED): oldstate = -1 newstate = -1 pending = -1 oldstate, newstate, pending = message.parse_state_changed () if ((oldstate == gst.STATE_READY) and \ (newstate == gst.STATE_PAUSED) and \ (pending == gst.STATE_VOID_PENDING) and \ (stream_data.Ready == False)): state_changed_status, current_state, pending_state = stream_data.Pipe.get_state () if ((current_state == gst.STATE_PAUSED) and \ (pending_state == gst.STATE_VOID_PENDING)): print "Pipe paused" self.__fill_sink_pads (stream_data) stream_data.Loop.quit () stream_data.Ready = True elif (t == gst.MESSAGE_ERROR): err, debug = message.parse_error() print "Error: %s" % err, debug stream_data.Loop.quit () stream_data.Ready = False return True def __fill_sink_pads (self, stream_data): asink = stream_data.Abin.get_by_name ("asink") vsink = stream_data.Vbin.get_by_name ("vsink") asink_pad = asink.get_pad ("sink") stream_data.ACaps = asink_pad.get_negotiated_caps().to_string() print "ACAPS " + stream_data.ACaps vsink_pad = vsink.get_pad ("sink") stream_data.VCaps = vsink_pad.get_negotiated_caps().to_string() print "ACAPS " + stream_data.VCaps def __on_decode_unknown_type (self, decode, pad, caps, stream_data): print "Unknown Type" return None def __on_decode_new_pad (self, decode, pad, arg1, stream_data): caps = pad.get_caps().to_string() print "New pad " + caps if (caps.rfind ("audio") != -1): apad = stream_data.Abin.get_pad ("sink") if (pad.link (apad) != gst.PAD_LINK_OK): print "Error on link audio pad" return None elif (caps.rfind ("video") != -1): vpad = stream_data.Vbin.get_pad ("sink") if (pad.link (vpad) != gst.PAD_LINK_OK): print "Error on link video pad" return None else: print "Invalid caps"