Mercurialgmyth / file revision
summary | shortlog | changelog | graph | tags | branches | files | changeset | file | revisions | annotate | diff | raw
gmyth-stream/server/plugins/transcoders/gmencoder.py
author renatofilho
Fri Feb 01 14:30:21 2008 +0000 (2008-02-01)
branchtrunk
changeset 905 d2d226b5a4bd
parent 894 20de88fec6f4
permissions -rw-r--r--
[svn r911] created release 0.7; moved debian dir to packages project 
     1 #!/usr/bin/env python

     2 

     3 __author__ = "Renato Filho"

     4 __author_email__ = "renato.filho@indt.org.br"

     5 __license__ = "GPL"

     6 __version__ = "0.2"

     7 

     8 import os

     9 import sys

    10 import shlex

    11 import signal

    12 import subprocess

    13 import time

    14 

    15 import select

    16 import fcntl

    17 

    18 import lib.utils as utils

    19 import lib.server as server

    20 import lib.transcoder as transcoder

    21 

    22 __all__ = ("TranscoderGMencoder",)

    23 

    24 class TranscoderGMencoder(transcoder.Transcoder):

    25     gmencoder_path = utils.which("gmencoder")

    26     name = "gmencoder"

    27     priority = -1

    28     proc = None

    29 

    30     def __init__(self, params):

    31         self.status = 0

    32         transcoder.Transcoder.__init__(self, params)

    33         self.opts = []

    34         self.opts.append (self.gmencoder_path)

    35         self.opts.append ("-d")

    36         self._parser_params ()

    37 

    38     # __init__()

    39 

    40     def _insert_param (self, name, value):

    41         if (value != ""):

    42             self.opts.append(name)

    43             self.opts.append(value)

    44 

    45     def _parser_params (self):

    46         self._insert_param("-i", \

    47             "%s://%s" % (self.params_first("type", "file"),

    48                          self.params_first("uri", "")))

    49         self._insert_param("--video-encode", self.params_first("ve", ""))

    50         self._insert_param("--video-opts", self.params_first ("video-opts", ""))

    51         self._insert_param("--video-fps", self.params_first("fps", ""))

    52         self._insert_param("--video-width", self.params_first("width", ""))

    53         self._insert_param("--video-height", self.params_first("height", ""))

    54         self._insert_param("--audio-encode", self.params_first("ae", ""))

    55         self._insert_param("--audio-opts", self.params_first ("audio-opts", ""))

    56         self._insert_param("--mux-element", self.params_first("mux", ""))

    57         self._insert_param("--audio-rate", self.params_first("audio-rate", ""))

    58     # _parse_params

    59 

    60     def start(self, outfd):

    61         outfile = self.params_first("outfile", "")

    62 

    63         if outfile != "":

    64             path = os.path.join(utils.config.get_transcoded_location(), outfile)

    65             self._insert_param("-o", "file://%s" % path)

    66         else:

    67             self._insert_param ("-o", "fd://%d" % outfd.fileno())

    68 

    69         cmd = " ".join(self.opts)

    70         self.log.info(self.tid, "GMencoder: %s" % cmd)

    71 

    72         try:

    73             self.proc = subprocess.Popen(self.opts, stdin=subprocess.PIPE,

    74                                          stdout=subprocess.PIPE)

    75 

    76             if outfile:

    77                outfd.write("OK   ")

    78 

    79         except Exception, e:

    80             self.log.error(self.tid, "Error: executing GMencoder: %s" % e)

    81             outfd.write("Error: GMencoder: %s" % e)

    82             return False

    83 

    84         try:

    85             if not outfile:

    86                 p = select.poll()

    87                 p.register (outfd, select.POLLNVAL | select.POLLERR |

    88                             select.POLLHUP)

    89             tries = 0

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

    91                 r, w, x = select.select([self.proc.stdout], [], [], 1)

    92                 if self.proc.stdout in r:

    93                     progress = self.proc.stdout.readline()

    94                     if (progress.find ("PROGRESS") >= 0):

    95                         self.status = progress.split (":")[1]

    96 		    elif (progress.find ("Erro") >= 0):

    97                         self.log.error(self.tid, "Detected problem @ gmencoder:"

    98                                        " %s" % progress)

    99                         if tries < 50:

   100                             tries += 1

   101                         else:

   102                             return False

   103 

   104 		    if not outfile:

   105 			    ret = p.poll(0)

   106 			    if ret:

   107 			    	self.log.info(self.tid, "* Lost connection *")

   108 		    		self.stop ()

   109 			    	return False

   110 

   111         except Exception, e:

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

   113             return False

   114 

   115         self.status = 100;

   116 

   117 

   118         return True

   119     # start()

   120 

   121 

   122     def stop(self):

   123         if self.proc:

   124             self.log.info(self.tid, "Stopped GMencoder plugin")

   125             try:

   126                 os.kill(self.proc.pid, signal.SIGKILL)

   127                 self.proc.wait()

   128             except Exception, e:

   129                 pass

   130 

   131             self.proc = None

   132     # stop()

   133 

   134     def get_progress(self):

   135         return self.status

   136 

   137     def get_lenght(self):

   138         return -1

   139 

   140 # TranscoderGMencoder
gmyth