import lib.utils as utils

 import lib.server as server

 import os

 import signal

 import subprocess

 __all__ = ("TranscoderMencoder",)

 class TranscoderMencoder(server.Transcoder):

     mencoder_path = utils.which("mencoder")

     def_mencoder_outfile = os.path.join(os.path.sep, "tmp",

                                         "mencoder-fifo-%(uid)s-%(pid)s")

     name = "mencoder"

     priority = -1

     def __init__(self, params):

         server.Transcoder.__init__(self, params)

         self.proc = None

         self.args = None

         vars = {"uid": os.getuid(), "pid": os.getpid()}

         mencoder_outfile_base = self.def_mencoder_outfile % vars

         mencoder_outfile = mencoder_outfile_base

         i = 0

         while os.path.exists(mencoder_outfile):

             i += 1

             mencoder_outfile = mencoder_outfile_base + ".%s" % i

         self.mencoder_outfile = mencoder_outfile

         os.mkfifo(self.mencoder_outfile)

         args = [self.mencoder_path, "-really-quiet",

                 "-o", self.mencoder_outfile]

         params_first = self.params_first

         type = params_first("type")

         location = params_first("location")

         args.append("%s://%s" % (type, location))

         mux = params_first("mux", "avi")

         args.extend(["-of", mux])

         acodec = params_first("acodec", "mp3")

         abitrate = params_first("abitrate", "128")

         if acodec == "mp3lame":

             args.extend(["-oac", "mp3lame", "-lameopts",

                          "cbr:br=%s" % abitrate])

         else:

             args.extend(["-oac", "lavc", "-lavcopts",

                          "acodec=%s:abitrate=%s" % (acodec, abitrate)])

         vcodec = params_first("vcodec", "mpeg4")

         vbitrate = params_first("vbitrate", "400")

         args.extend(["-ovc", "lavc", "-lavcopts",

                      "vcodec=%s:vbitrate=%s" % (vcodec, vbitrate)])

         fps = params_first("fps", "24")

         args.extend(["-ofps", fps])

         width = params_first("width", "320")

         height = params_first("height", "240")

         args.extend(["-vf", "scale=%s:%s" % (width, height)])

         self.args = args

     # __init__()

     def _unlink_fifo(self):

         try:

             os.unlink(self.mencoder_outfile)

         except Exception, e:

             pass

     # _unlink_fifo()

     def start(self, outfd):

         cmd = " ".join(self.args)

         self.log.info("Mencoder: %s" % cmd)

         try:

             self.proc = subprocess.Popen(self.args, close_fds=True)

         except Exception, e:

             self.log.error("Error executing mencoder: %s" % cmd)

             return False

         try:

             fifo_read = open(self.mencoder_outfile)

         except Exception, e:

             self.log.error("Error opening fifo: %s" % cmd)

             return False

         try:

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

                 d = fifo_read.read(1024)

                 outfd.write(d)

         except Exception, e:

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

             self._unlink_fifo()

             return False

         self._unlink_fifo()

         return True

     # start()

     def stop(self):

         if self.proc:

             try:

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

             except OSError, e:

                 pass

             try:

                 self.proc.wait()

             except Exception, e:

                 pass

             self.proc = None

         self._unlink_fifo()

     # stop()

 # TranscoderMencoder