#!/usr/bin/env python

 __author__ = "Renato Filho"

 __author_email__ = "renato.filho@indt.org.br"

 __license__ = "GPL"

 __version__ = "0.2"

 import os

 import sys

 import shlex

 import signal

 import subprocess

 import time

 import select

 import fcntl

 import lib.utils as utils

 import lib.server as server

 import lib.transcoder as transcoder

 __all__ = ("TranscoderGMencoder",)

 class TranscoderGMencoder(transcoder.Transcoder):

     gmencoder_path = utils.which("gmencoder")

     name = "gmencoder"

     priority = -1

     proc = None

     def __init__(self, params):

         self.status = 0

         transcoder.Transcoder.__init__(self, params)

         self.opts = []

         self.opts.append (self.gmencoder_path)

         self.opts.append ("-d")

         self._parser_params ()

     # __init__()

     def _insert_param (self, name, value):

         if (value != ""):

             self.opts.append(name)

             self.opts.append(value)

     def _parser_params (self):

         self._insert_param("-i", \

             "%s://%s" % (self.params_first("type", "file"),

                          self.params_first("uri", "")))

         self._insert_param("--video-encode", self.params_first("ve", ""))

         self._insert_param("--video-opts", self.params_first ("video-opts", ""))

         self._insert_param("--video-fps", self.params_first("fps", ""))

         self._insert_param("--video-width", self.params_first("width", ""))

         self._insert_param("--video-height", self.params_first("height", ""))

         self._insert_param("--audio-encode", self.params_first("ae", ""))

         self._insert_param("--audio-opts", self.params_first ("audio-opts", ""))

         self._insert_param("--mux-element", self.params_first("mux", ""))

         self._insert_param("--audio-rate", self.params_first("audio-rate", ""))

     # _parse_params

     def start(self, outfd):

         outfile = self.params_first("outfile", "")

         if outfile != "":

             path = os.path.join(utils.config.get_transcoded_location(), outfile)

             self._insert_param("-o", "file://%s" % path)

         else:

             self._insert_param ("-o", "fd://%d" % outfd.fileno())

         cmd = " ".join(self.opts)

         self.log.info(self.tid, "GMencoder: %s" % cmd)

         try:

             self.proc = subprocess.Popen(self.opts, stdin=subprocess.PIPE,

                                          stdout=subprocess.PIPE)

             if outfile:

                outfd.write("OK   ")

         except Exception, e:

             self.log.error(self.tid, "Error: executing GMencoder: %s" % e)

             outfd.write("Error: GMencoder: %s" % e)

             return False

         try:

             if not outfile:

                 p = select.poll()

                 p.register (outfd, select.POLLNVAL | select.POLLERR |

                             select.POLLHUP)

             tries = 0

             while (self.proc and self.proc.poll() == None):

                 r, w, x = select.select([self.proc.stdout], [], [], 1)

                 if self.proc.stdout in r:

                     progress = self.proc.stdout.readline()

                     if (progress.find ("PROGRESS") >= 0):

                         self.status = progress.split (":")[1]

 		    elif (progress.find ("Erro") >= 0):

                         self.log.error(self.tid, "Detected problem @ gmencoder:"

                                        " %s" % progress)

                         if tries < 50:

                             tries += 1

                         else:

                             return False

 		    if not outfile:

 			    ret = p.poll(0)

 			    if ret:

 			    	self.log.info(self.tid, "* Lost connection *")

 		    		self.stop ()

 			    	return False

         except Exception, e:

             self.log.error(self.tid, "Problems handling data: %s" % e)

             return False

         self.status = 100;

         return True

     # start()

     def stop(self):

         if self.proc:

             self.log.info(self.tid, "Stopped GMencoder plugin")

             try:

                 os.kill(self.proc.pid, signal.SIGKILL)

                 self.proc.wait()

             except Exception, e:

                 pass

             self.proc = None

     # stop()

     def get_progress(self):

         return self.status

     def get_lenght(self):

         return -1

 # TranscoderGMencoder