import os

 import shlex

 import signal

 import subprocess

 import lib.utils as utils

 import lib.server as server

 __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

     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", "-")

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

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

         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"])

     # _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 start(self, outfd):

         cmd = " ".join(self.mencoder_opts)

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

         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

         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

     # stop()

 # TranscoderMencoder