Mercurialgmyth / file revision
summary | shortlog | changelog | graph | tags | branches | files | changeset | file | revisions | annotate | diff | raw
gmyth-stream/server/plugins/transcoders/gmencoder.py
author melunko
Mon Mar 03 13:11:54 2008 +0000 (2008-03-03)
branchtrunk
changeset 936 d389914210cf
parent 894 20de88fec6f4
permissions -rw-r--r--
[svn r945] gmyth library version incremented to 0.8 
     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