gmyth: gmyth-stream/server/0.3/plugins/transcoders/mencoder.py@6e54ca4a4e9a

     1 #!/usr/bin/env python

     3 __author__ = "Artur Duque de Souza"

     4 __author_email__ = "artur.souza@indt.org.br"

     5 __license__ = "GPL"

     6 __version__ = "0.1"

     8 import os

     9 import shlex

    10 import signal

    11 import subprocess

    12 import time

    13 import fcntl

    15 import lib.utils as utils

    16 import lib.server as server

    17 import plugins.transcoders.mencoder_lib.mythtv as mythtv

    19 from select import select

    20 import lib.transcoder as transcoder

    22 __all__ = ("TranscoderMencoder",)

    24 class TranscoderMencoder(transcoder.Transcoder):

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

    26     mencoder_path = utils.which("mencoder")

    27     name = "mencoder"

    28     priority = -1

    29     args = {}

    30     proc = None

    31     gmyth = None

    33     # only works with avi container

    34     status = 0

    36     def _setup_params(self):

    37         params_first = self.params_first

    39         # general_opts

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

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

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

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

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

    46         # input_opt

    47         self.args["type"]     = params_first("type", "file")

    48         self.args["input"]    = params_first("uri", "-")

    50         # audio_opts

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

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

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

    55         # video_opts

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

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

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

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

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

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

    62     # _setup_params()

    65     def _setup_audio(self):

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

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

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

    69         else:

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

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

    73         return audio

    74     # _setup_audio()

    77     def _setup_video(self):

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

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

    81         vcodec = self.args["vcodec"]

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

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

    84             video += " -ovc %s" % vcodec

    85         else:

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

    87                 vcodec, self.args["vbitrate"])

    89         if self.args["mux"] == "mpeg":

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

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

    93         return video

    94     # _setup_video()

    97     def _arg_append(self, args, options):

    98         for arg in shlex.split(options):

    99             args.append(arg)

   100     # arg_append()

   102     def _setup_mencoder_opts(self, args):

   103         args.append(self.mencoder_path)

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

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

   107         else:

   108             args.append("-")

   110         if self.args["language"]:

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

   113         if self.args["subtitle"]:

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

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

   117         self._arg_append(args, "-idx")

   118         self._arg_append(args, "-cache 1024")

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

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

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

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

   125             self.args["outfile"] = ".transcoded/%s" % (

   126                                    os.path.basename(self.args["outfile"]))

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

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

   130     # _setup_args()

   132     def _setup_filename(self):

   133         """This function setups the file to encode parsing the uri.

   134         So, type can be:

   135         * file

   136         * dvd

   137         * myth

   139         If the last one is detected we have to parse the uri to find args.

   140         Then we store all the args inside a dictionary: self.args['gmyth-cat']

   141         """

   142         _type = self.args["type"]

   144         if _type == "file":

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

   146                 raise IOError,\

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

   148             else:

   149                 self.args["input"] = "file://%s" % self.args["input"]

   151         elif _type == "dvd":

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

   154         elif _type == "myth":

   155             self.args["gmyth-cat"] = mythtv._setup_mythfilename(self)

   156     # _setup_filename()

   159     def __init__(self, params):

   160         transcoder.Transcoder.__init__(self, params)

   161         self.mencoder_opts = []

   163         try:

   164             self._setup_params()

   165             self._setup_filename()

   166             self._setup_mencoder_opts(self.mencoder_opts)

   167         except Exception, e:

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

   169     # __init__()

   172     def _check_opened_file(self, stdw, _stdin):

   173         loop = True

   174         while loop:

   175             try:

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

   177             except:

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

   179     # _check_opened_file

   182     def _start_outfile(self, outfd):

   183         finished = False

   185         # Configuring stdin

   186         try:

   187             filename = self.args["input"].split("://")[1]

   188             _stdin = open(filename)

   189             size = int(os.path.getsize(filename))

   190         except Exception, e:

   191             self.log.error(self.tid, "Error: Mencoder stdin"\

   192                            " setup error: %s" % e)

   193             outfd.write("Error: Mencoder stdin setup error: %s" %e)

   194             return False

   196         self.status = 0

   197         total_read = 0

   199         # Configuring pipes

   200         stdr, stdw = os.pipe()

   202         if not self._run_mencoder(input=stdr):

   203             return False

   205         stdout = self._check_opened_file(stdw, _stdin)

   207         outfd.write("OK   ")

   209         try:

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

   211                 if not finished:

   212                     data_in = _stdin.read(4096)

   213                     if data_in != "":

   214                         os.write(stdw, data_in)

   215                         total_read += 4096

   216                         d = stdout.read(4096)

   217                         self.status = utils.progress_bar(int(total_read),

   218                                                          int(size), 50)

   219                     else:

   220                         finished = True

   221                         os.close(stdw)

   223                 else:

   224                     d = stdout.read(4096)

   226         except Exception, e:

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

   228             self.stop()

   229             return False

   231         self.log.info(self.tid, "OK: Done")

   232         return True

   233     # _start_outfile()

   235     def _start(self, outfd):

   236         # Play a file on disk or DVD

   237         if not self._run_mencoder(output=subprocess.PIPE):

   238             return False

   240         try:

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

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

   243                 outfd.write(d)

   244         except Exception, e:

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

   246             return False

   248         self.log.info(self.tid, "OK: Done")

   249         return True

   250     # _start()

   252     def _run_mencoder(self, input=None, output=None):

   253         try:

   254             self.proc = subprocess.Popen(self.mencoder_opts, stdin=input,

   255                                          stdout=output, close_fds=True)

   256         except Exception, e:

   257             self.log.error(self.tid, "Error: Mencoder: %s" % e)

   258             return False

   260         return True

   261     # _run_mencoder()

   263     def start(self, outfd):

   264         cmd = " ".join(self.mencoder_opts)

   265         self.log.debug(self.tid, "Plugin's tid: %s" % self.tid)

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

   267         #fixme

   269         ret = False

   271         if self.args["outfile"] == "-" and \

   272                self.args["type"] in ["file", "dvd"]:

   273             ret = self._start(outfd)

   275         elif self.args["type"] == "myth":

   276             ret = mythtv.start_myth(self, outfd)

   278         else:

   279             ret = self._start_outfile(outfd)

   281         self.stop()

   283         if not ret:

   284             self.log.error(self.tid, "Error: Problems while "\

   285                            "starting streaming.")

   287         return ret

   288     # start()

   290     def _aux_stop(self, obj, next=False):

   291         if obj:

   292             try:

   293                 os.kill(obj.pid, signal.SIGKILL)

   294                 if next:

   295                     os.kill(obj.pid+1, signal.SIGKILL)

   296             except OSError, e:

   297                 pass

   299             try:

   300                 obj.wait()

   301             except Exception, e:

   302                 pass

   304             obj = None

   305     # _aux_stop

   307     def stop(self):

   308         self._aux_stop(self.proc, True)

   309         self._aux_stop(self.gmyth)

   310     # stop()

   312 # TranscoderMencoder

author	morphbr
	Thu May 31 19:36:03 2007 +0100 (2007-05-31)
branch	trunk
changeset 728	6e54ca4a4e9a
parent 723	f5f7abc760aa
child 735	15a191556cd6
permissions	-rw-r--r--