#vim:ts=4:sw=4:et import pygst pygst.require("0.10") import gst import gobject import socket from threading import Thread class Media: class StreamListener(Thread): def __init__ (self, stream_data): Thread.__init__(self) self.stream = stream_data print "Thread Created" def run (self): #Create socket print "Waiting connection" self.stream.Socket.listen(1) self.stream.Connection, self.stream.Addr = self.stream.Socket.accept () print "Connection requested" self.stream.Sink.set_property ("fd", self.stream.Connection.fileno()) self.stream.Pipe.set_state(gst.STATE_PLAYING) print "PLAYING" class StreamData: stream_count = 0 def __init__ (self, pipe, abin, vbin, sink): self.stream_count += 1 self.Id = self.stream_count self.Pipe = pipe self.Abin = abin self.Vbin = vbin self.Sink = sink self.Loop = gobject.MainLoop() self.ACaps = "" self.VCaps = "" self.Ready = False self.Socket = None self.Connection = None self.Addr = None def __init__(self, config): # set gstreamer basic options self.config = config self.streams = [] self.socket = None self.connection = None self.addr = None self.ready = False def setup(self, uri, mux, vcodec, vbitrate, fps, acodec, abitrate, width, height, port, options): ## Pipelines pipe = gst.Pipeline () print "Opening Uri:" + uri src = gst.element_make_from_uri (gst.URI_SRC, uri, "src") if (src is None): print "Fail to create src element" return None decode = gst.element_factory_make ("decodebin", "decode") if (decode is None): print "Fail to create decodebin" return None mux = gst.element_factory_make ("avimux", "mux") if (mux is None): print "Fail to create mux" return None sink = gst.element_factory_make ("fdsink", "sink") if (sink is None): print "Fail to create fdsink" 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") colorspace = gst.element_factory_make ("ffmpegcolorspace", "") vrate = gst.element_factory_make ("videorate", "vrate") vencode = gst.element_factory_make ("ffenc_h263p", "vencode") if (None in [vbin, vqueue, vscale, vrate, vencode]): 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=%d,height=(int)%d" % (int(width), int(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 ''' vbin.add (vqueue, vscale, colorspace, vrate, vencode) if (not vqueue.link (vscale)): print "Fail to link video elements" return None if (not vscale.link (colorspace, \ gst.caps_from_string ("video/x-raw-yuv,width=%d,height=(int)%d" % (int(width), int(height))))): print "Fail to link video elements" return None if (not gst.element_link_many (colorspace, vrate, vencode)): print "Fail to link video elements" return None vbin.add_pad (gst.GhostPad ("sink", vqueue.get_pad ("sink"))) vbin.add_pad (gst.GhostPad ("src", vencode.get_pad ("src"))) #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 ("ffenc_ac3", "aencode") aencode = gst.element_factory_make ("lame", "aencode") if (None in [abin, aqueue, aconvert, aencode]): print "Fail to create video encode elements." return None abin.add (aqueue, aconvert, aencode) if (not gst.element_link_many (aqueue, aconvert, aencode)): print "Fail to link video elements" return None abin.add_pad (gst.GhostPad ("sink", aqueue.get_pad ("sink"))) abin.add_pad (gst.GhostPad ("src", aencode.get_pad ("src"))) #Finish Pipeline pipe.add (src, decode, abin, vbin, mux, sink) gst.element_link_many (src, decode) gst.element_link_many (mux, sink) #Linking decode with mux mux_audio = mux.get_pad ("audio_0") mux_video = mux.get_pad ("video_0") audio_pad = abin.get_pad ("src") video_pad = vbin.get_pad ("src") if (audio_pad.link (mux_audio) != gst.PAD_LINK_OK): print "Fail to link audio with mux" return None if (video_pad.link (mux_video) != gst.PAD_LINK_OK): print "Fail to link audio with mux" return None stream_data = self.StreamData (pipe, abin, vbin, sink) bus = 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) pipe.set_state (gst.STATE_PAUSED) print "Running Pipe" stream_data.Loop.run () print "End run" #Create socket stream_data.Socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) print "Bind on port %d" % port stream_data.Socket.bind(('', int (port))) self.streams.append (stream_data) return (True, "") def play(self): stream = self.streams[0] current = self.StreamListener(stream) current.start () print "Saindo" return (True, "") def stop(self): stream = self.streams[0] stream.Pipe.set_state(gst.STATE_NULL) stream.Connection.close () return (True, "") 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" 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 __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"