import os

 import shlex

 import signal

 import subprocess

 import time

 import lib.utils as utils

 import lib.server as server

 from select import select

 __all__ = ("TranscoderMencoder",)

 class TranscoderMencoder(server.Transcoder):

     """Transcoder class that implements a transcoder using Mencoder"""

     mencoder_path = utils.which("mencoder")

     name = "mencoder"

     priority = -1

     args = {}

     proc = None

     # only works with avi container

     status = 0

     def _setup_params(self):

         params_first = self.params_first

         # general_opts

         self.args["local"]    = params_first("local", False)

         self.args["language"] = params_first("language", False)

         self.args["subtitle"] = params_first("subtitle", False)

         self.args["format"]   = params_first("format", "")

         self.args["outfile"]  = params_first("outfile", "-")

         self.args["sendback"] = params_first("sendback", True)

         # handle sendback variable

         if self.args["sendback"] == "False":

             self.args["sendback"] = False

         # input_opt

         uri = params_first("uri", "file://-").split("://")

         self.args["type"]     = uri[0]

         self.args["input"]    = uri[1]

         # audio_opts

         self.args["acodec"]   = params_first("acodec", "mp2")

         self.args["abitrate"] = params_first("abitrate", 192)

         self.args["volume"]   = params_first("volume", 5)

         # video_opts

         self.args["mux"]      = params_first("mux", "mpeg")

         self.args["fps"]      = params_first("fps", 25)

         self.args["vcodec"]   = params_first("vcodec", "mpeg1video")

         self.args["vbitrate"] = params_first("vbitrate", 400)

         self.args["width"]    = params_first("width", 320)

         self.args["height"]   = params_first("height", 240)

     # _setup_params()

     def _setup_audio(self):

         if self.args["acodec"] == "mp3lame":

             audio = "-oac mp3lame -lameopts cbr:br=%s vol=%s" % (

                 self.args["abitrate"], self.args["volume"])

         else:

             audio = "-oac lavc -lavcopts acodec=%s:abitrate=%s" % (

                 self.args["acodec"], self.args["abitrate"])

         return audio

     # _setup_audio()

     def _setup_video(self):

         video = " -of %s" % self.args["mux"]

         video += " -ofps %s" % self.args["fps"]

         vcodec = self.args["vcodec"]

         if vcodec == "nuv" or vcodec == "xvid"\

                or vcodec == "qtvideo" or vcodec == "copy":

             video += " -ovc %s" % vcodec

         else:

             video += " -ovc lavc -lavcopts vcodec=%s:vbitrate=%s" % (

                 vcodec, self.args["vbitrate"])

         video += " %s" % self.args["format"]

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

         return video

     # _setup_video()

     def _arg_append(self, args, options):

         for arg in shlex.split(options):

             args.append(arg)

     # arg_append()

     def _setup_mencoder_opts(self, args):

         args.append(self.mencoder_path)

         if self.args["outfile"] == "-" and self.args["type"]:

             args.append(self.args["input"])

         else:

             args.append("-")

         if self.args["language"]:

             self._arg_append(args, "-alang %s" % self.args["language"])

         if self.args["subtitle"]:

             self._arg_append(args, "-slang %s" % self.args["subtitle"])

             self._arg_append(args, "-subfps %s" % self.args["fps"])

         self._arg_append(args, "-idx")

         self._arg_append(args, self._setup_audio())

         self._arg_append(args, self._setup_video())

         self._arg_append(args, "-really-quiet")

         self._arg_append(args, "-o %s" % self.args["outfile"])

         self._arg_append(args, "2>%s" % os.devnull)

     # _setup_args()

     def _setup_filename(self):

         _type = self.args["type"]

         if _type == "file":

             if not os.path.exists(self.args["input"]):

                 raise IOError,\

                       "File requested does not exist: %s." % self.args["input"]

         elif _type == "dvd":

             self.args["input"] = "dvd://".join(self.args["input"])

         elif _type == "myth":

             # gmyth-cat -h 192.168.1.124 -p 6543 -c 111

             # gmyth-cat -h 192.168.1.124 -p 6543 -f file.nuv

             # myth://IP:PORT:type:file

             self.args["gmyth-cat"] = self.args["input"].split(":")

     # _setup_filename()

     def __init__(self, params):

         server.Transcoder.__init__(self, params)

         self.mencoder_opts = []

         try:

             self._setup_params()

             self._setup_filename()

             self._setup_mencoder_opts(self.mencoder_opts)

         except Exception, e:

             self.log.error(e)

     # __init__()

     def _check_opened_file(self, stdw, _stdin):

         loop = True

         while loop:

             try:

                 return open(self.args["outfile"])

             except:

                 os.write(stdw, _stdin.read(1024))

     # _check_opened_file

     def _start_outfile(self, outfd):

         finished = False

         # fix this (not necessary)

         outfd.write("OK")

         # Configuring stdin

         _stdin = open(self.args["input"])

         size = int(os.path.getsize(self.args["input"]))

         self.status = 0

         total_read = 0

         # Configuring pipes

         stdr, stdw = os.pipe()

         try:

             self.proc = subprocess.Popen(self.mencoder_opts, stdin=stdr, close_fds=True)

         except Exception, e:

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

             return False

         stdout = self._check_opened_file(stdw, _stdin)

         try:

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

                 if not finished:

                     data_in = _stdin.read(4096)

                     if data_in != "":

                         os.write(stdw, data_in)

                         total_read += 4096

                         d = stdout.read(4096)

                         if self.args["sendback"]:

                             outfd.write(d)

                         self.status = total_read * 100 / size

                     else:

                         finished = True

                         os.close(stdw)

                 else:

                     d = stdout.read(4096)

                     if self.args["sendback"] and d != "":

                         outfd.write(d)

         except Exception, e:

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

             return False

         self.log.info("%s: Finished sending data to client" % repr(self))

         if not self.args["sendback"]:

             outfd.write("DONE")

         return True

     # _start_outfile()

     def _start(self, outfd):

         try:

             self.proc = subprocess.Popen(self.mencoder_opts,

                                          stdout=subprocess.PIPE, close_fds=True)

         except Exception, e:

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

             return False

         try:

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

                 d = self.proc.stdout.read(1024)

                 outfd.write(d)

         except Exception, e:

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

             return False

         self.log.info("%s: Finished sending data to client" % repr(self))

         return True

     # _start()

     def start(self, outfd):

         cmd = " ".join(self.mencoder_opts)

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

         if self.args["outfile"] == "-":

             return self._start(outfd)

         else:

             return self._start_outfile(outfd)

     # 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

     # stop()

 # TranscoderMencoder