#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"