import os

import shlex

import signal

import subprocess

import lib.utils as utils

import lib.server as server

__all__ = ("TranscoderMencoder",)

class TranscoderMencoder(server.Transcoder):

    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