#vim:ts=4:sw=4:et

 import pygst

 pygst.require("0.10")

 import gst

 import gobject

 import time

 import lib.utils as utils

 import lib.server as server

 from threading import Thread

 __all__ = ("TranscoderGstreamer",)

 class TranscoderGstreamer(server.Transcoder):

     gstreamer_path = utils.which("gst-launch-0.10")

     name = "gstreamer"

     priority = -2

     # StreamListener()

     class StreamData:

         stream_count = 0

         def __init__(self, log, pipe, abin, vbin, sink):

             self.log = log

             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.Ready = False

         # __init__()

     # StreamData()

     def __init__(self, params):

         server.Transcoder.__init__(self, params)

         gobject.threads_init ()

         # set gstreamer basic options

         self.connection = None

         self.addr = None

         self.ready = False

         self.log.debug("Params for Gstreamer: %s" % self.params)

     # __init__()

     def _create_start_elements(self, uri):

         self.log.debug("Opening Uri:" + uri)

         src = gst.element_make_from_uri(gst.URI_SRC, uri, "src")

         decode = gst.element_factory_make("decodebin", "decode")

         mux = gst.element_factory_make("ffmux_mpeg", "mux")

         sink = gst.element_factory_make("fdsink", "sink")

         return [src, decode, mux, sink]

     # _create_start_elements()

     def _setup_video_encode(self, vbin, width, height):

         vqueue = gst.element_factory_make("queue", "vqueue")

         colorspace = gst.element_factory_make("ffmpegcolorspace", "")

         vrate = gst.element_factory_make("videorate", "vrate")

         #vencode = gst.element_factory_make("ffenc_mpeg4", "vencode")

         vencode = gst.element_factory_make("ffenc_mpeg1video", "vencode")

         vqueue_src = gst.element_factory_make("queue", "vqueue_src")

         vencode.set_property("bitrate", 200)

         vencode.set_property ("pass", 2)

         vencode.set_property ("quantizer", 5)

         if None in [vbin, vqueue, vrate, vencode, vqueue_src]:

             self.log.error("Fail to create video encode elements.")

             return False

         vbin.add(vqueue)

         if int(width) > 0 and int(height) > 0:

             self.log.debug("Formating output to %d / %d" % ( int(width), int(height)))

             vscale = gst.element_factory_make("ffvideoscale", "vscale")

             vbin.add(vscale);

             if not vqueue.link(vscale):

                 self.log.error("Fail to link video elements")

                 return False

             vbin.add(colorspace)

             if not vscale.link(colorspace, \

                 gst.caps_from_string("video/x-raw-yuv,width=(int)%d,height=(int)%d" %(\

                 int(width), int(height)))):

                 self.log.error("Fail to link video elements")

                 return False

         else:

             vbin.add(colorspace)

             vqueue.link(colorspace)

         vbin.add(vrate, vencode, vqueue_src)

         if not colorspace.link(vrate):

             self.log.error("Fail to colorspace with vrate")

             return False

         if not vrate.link(vencode, \

             gst.caps_from_string("video/x-raw-yuv,framerate=(fraction)10/1")):

             self.log.error("Fail to link vrate element")

             return False

         if not vencode.link(vqueue_src):

             self.log.error("Fail to link video encode with queue")

             return False

         vbin.add_pad(gst.GhostPad("sink", vqueue.get_pad("sink")))

         vbin.add_pad(gst.GhostPad("src", vqueue_src.get_pad("src")))

         return True

     # _setup_video_encode()

     def _setup_audio_encode(self, abin):

         aqueue = gst.element_factory_make("queue", "aqueue")

         aconvert = gst.element_factory_make("audioconvert", "aconvert")

         #aencode = gst.element_factory_make("queue", "aencode")

         #aencode = gst.element_factory_make("ffenc_mp2", "aencode")

         aencode = gst.element_factory_make("lame", "aencode")

         aqueue_src = gst.element_factory_make("queue", "aqueue_src")

         if None in [abin, aqueue, aencode, aqueue_src]:

             self.log.error("Fail to create video encode elements.")

             return False

         #aencode.set_property ("bitrate", 32)

         #aencode.set_property ("vbr-quality", 2)

         abin.add(aqueue, aconvert, aencode, aqueue_src)

         self.log.debug("Link queue -> aconvert")

         if not aqueue.link (aconvert):

             self.log.error("Fail to link queue video")

             return False

         self.log.debug("Link aconvert -> aencode")

         if not aconvert.link (aencode):

             self.log.error("Fail to link video elements")

             return False

         self.log.debug("Link aencode -> aqueue_src")

         if not aencode.link (aqueue_src):

             self.log.error("Fail to link aencode -> aqueue_src")

             return False

         self.log.debug("Link:OK")

         ghost_sink = gst.GhostPad("sink", aqueue.get_pad("sink"))

         ghost_src = gst.GhostPad("src", aqueue_src.get_pad("src"))

         #ghost_src.set_caps (gst.caps_from_string ("audio/mpeg,mpegversion=(int)1,layer=(int)3,rate=(int)32000"))

         abin.add_pad(ghost_sink)

         abin.add_pad(ghost_src)

         return True

     # _setup_audio_encode()

     def setup(self, uri, mux, vcodec, vbitrate,

               fps, acodec, abitrate, width, height, options):

         ## Pipelines

         pipe = gst.Pipeline()

         src, decode, mux, sink = self._create_start_elements(uri)

         if None in [src, decode, mux, sink]:

             self.log.info("Problems with while starting basic elements");

             return False

         #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()

         if not self._setup_video_encode(vbin, width, height):

             return False

         #audio encode

         #audio/x-raw-int ! queue ! audioconvert ! faac ! rtpmp4gpay !

         #udpsink name=upd_audio host=224.0.0.1 port=5002

         abin = gst.Bin()

         if not self._setup_audio_encode(abin):

             return False

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

             self.log.error("Fail to link audio with mux")

             return False

         if video_pad.link(mux_video) != gst.PAD_LINK_OK:

             self.log.error("Fail to link audio with mux")

             return False

         self.stream_data = self.StreamData(self.log, pipe, abin, vbin, sink)

         bus = pipe.get_bus()

         bus.add_signal_watch()

         bus.connect("message", self.__on_bus_message, self.stream_data)

         decode.connect("new-decoded-pad", self.__on_decode_new_pad, self.stream_data)

         decode.connect("unknown-type", self.__on_decode_unknown_type, self.stream_data)

         self.log.info("Setting PIPELINE state to PAUSED")

         pipe.set_state(gst.STATE_PAUSED)

         self.log.info("Running Loop")

         self.stream_data.Loop.run()

     # setup()

     def __on_bus_message(self, bus, message, stream_data):

         t = message.type

         self.log.debug("__on_bus_message")

         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:

                     self.log.info("Pipe paused")

                     stream_data.Loop.quit()

                     stream_data.Ready = True

         elif t == gst.MESSAGE_EOS:

             self.log.info("Pipe finished")

             if stream_data.Ready:

                 self.stop()

             else:

                 stream_data.Loop.quit()

         elif t == gst.MESSAGE_ERROR:

             err, debug = message.parse_error()

             self.log.error("Error: %s %s" %(err, debug))

             if stream_data.Ready:

                 self.stop()

             else:

                 stream_data.Loop.quit()

         return True

     # __on_bus_message()

     def __on_decode_unknown_type(self, decode, pad, caps, stream_data):

         self.log.info("Unknown Type")

         return None

     # __on_decode_unknown_type

     def __on_decode_new_pad(self, decode, pad, arg1, stream_data):

         caps = pad.get_caps().to_string()

         self.log.debug("New pad " + caps)

         if caps.rfind("audio") != -1:

             apad = stream_data.Abin.get_pad("sink")

             if pad.link(apad) != gst.PAD_LINK_OK:

                 self.log.error("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:

                 self.log.error("Error on link video pad")

                 return None

         else:

             self.log.error("Invalid caps")

         self.log.debug("Linked")

     # __on_decode_new_pad

     def start(self, outfd):

         params_first = self.params_first

         uri = '%s://%s' % (params_first("uri_prefix", ""), params_first("uri_path", ""))

         self.setup(uri, params_first("mux", "avi"),

                    params_first("vcodec", "ffenc_h263p"), params_first("vbitrate", 256000),

                    params_first("fps", 25),  params_first("acodec", "faac"),

                    params_first("abitrate", 192000),  params_first("width", 320),

                    params_first("height", 240), params_first("options", ""))

         self.log.debug("Play %s", outfd.fileno())

         self.stream_data.Sink.set_property("fd", outfd.fileno())

         self.log.info("Setting Pipeline state to PLAYING")

         self.stream_data.Pipe.set_state(gst.STATE_PLAYING)

         # keep playing until EOS

         self.stream_data.Loop.run()

         return True

     # start()

     def stop(self):

         self.log.info("Stop stream_data: %s" % self.stream_data)

         if self.stream_data:

             self.stream_data.Pipe.set_state(gst.STATE_NULL)

         self.stream_data.Ready = False

         self.stream_data.Loop.quit ()

         del self.stream_data

         self.stream_data = None

         time.sleep (2)

     # stop