import os

 import sys

 import lib

 import time

 import signal

 import socket

 import ConfigParser

 from select import *

 from subprocess import *

 class Media(object):

     def __init__(self, config):

         self.config = config

         self.args = ""

         self.language = "en"

         self.socket = None

         self.child_pid = None

         self.mplayer = None

         self.mencoder_pid = None

         self.mplayer_pid = None

         signal.signal(signal.SIGABRT, self.kill_handler)

     # __init__

     def kill_handler(self, sig, frame):

         try:

             os.kill(self.mplayer_pid.pid, signal.SIGKILL)

             log.debug("Killed Mplayer")

             sys.exit(0)

         except:

             log.error("Problems closing child")

     # kill_handler

     def set_args(self, options):

         for opt in options:

             if opt == "local":

                 self.mplayer = lib.which("mplayer")

             elif opt.find("language=") >= 0:

                 try:

                     self.language = opt.split("=")[1]

                 except:

                     log.error("Bad language option")

             elif opt.find("format=") >= 0:

                 try:

                     self.mux += " -mpegopts format=%s" % opt.split("=")[1]

                 except:

                     log.error("Bad format option")

     # set_args

     def run_mplayer(self):

         msg = self.filename

         if self.kind == "dvd":

             msg = "dvd://" + msg

         self.mplayer_pid = Popen([self.mplayer, self.filename, "1> %s" % os.devnull,\

                                   "2> %s" % os.devnull], stdout=PIPE, close_fds=True)

     # run_mplayer

     def setup_mencoder(self):

         self.path = self.config.get("Mencoder", "path")

         mp = Popen([self.path], stdout=PIPE, close_fds=True)

         version = mp.stdout.read().split("MEncoder ")[1].split(" (C)")[0].split("-")[-1]

         if version > "4.1.1": self.mencoder_old = False

         else: self.mencoder_old = True

         os.kill(mp.pid, signal.SIGKILL)

         log.info("Mencoder version: %s" % version)

         if self.mencoder_old:

             self.fifo = self.config.get("Mencoder", "fifo_path")

         else:

             self.fifo = "-"

     # setup_mencoder

     def setup_audio(self, acodec):

         if acodec == "mp3lame":

             return "-oac mp3lame -lameopts cbr:br=%s vol=5" % self.abitrate

         else:

             return = "-oac lavc -lavcopts acodec=%s:abitrate=%s" % (\

                 self.acodec, self.abitrate)

     def setup_filename(self, filename):

         try:

             self.kind, self.filename = filename.split("://")

         except:

             return (False, "Wrong filename protocol")

         audio = setup_audio(self.acodec)

         if self.kind == "file":

             if not os.path.exists(self.filename):

                 msg = "File requested does not exist. SETUP failed."

                 log.error(msg)

                 return (False, msg)

             self.args += " %s -mf fps=%s -of %s %s"\

                          " -ovc lavc -lavcopts vcodec=%s:vbitrate=%s -vf scale=%s:%s"\

                          " -really-quiet -o %s 2>/dev/null" % (

                 self.filename, self.fps, self.mux, audio, self.vcodec,

                 self.vbitrate, self.width, self.height, self.fifo)

         elif self.kind == "dvd":

             self.args += " dvd://%s -alang %s -vf scale=%s:%s %s"\

                          " -of %s -ovc lavc -lavcopts vcodec=%s:vbitrate=%s"\

                          " -ofps %s -really-quiet -o %s 2>/dev/null" % (

                 self.filename, self.language, self.width, self.height, audio,

                 self.mux, self.vcodec, self.vbitrate, self.fps, self.fifo)

         return (True, "")

     # setup_filename

     def setup_socket(self, socket):

         if socket != None:

             del(socket)

         socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

         socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

         try:

             socket.bind( ('', self.port) )

             socket.listen(1)

         except Exception, e:

             log.error("Could not create socket: %s" % e)

             return (False, e)

         return (True, "")

     '''

     MENCODER SETUP DESCRIPTION

     ===========================

     -> mux, vcodecs and acodecs

      |-> mencoder (-of | -ovc | -oac) help

     -> if used mpeg as mux:

      |-> to setup format: format=%s as an option at the end

     '''

     def setup(self, filename, mux, vcodec, vbitrate,\

               fps, acodec, abitrate, width, height, port, options):

         self.mux = mux

         self.vcodec = vcodec

         self.vbitrate = vbitrate

         self.fps = fps

         self.acodec = acodec

         self.abitrate = abitrate

         self.width = width

         self.height = height

         self.port = int(port)

         self.setup_mencoder()

         ret_val = self.setup_filename(filename)

         if not ret_val[0]:

             return ret_val[1]

         self.set_args(options)

         # good one: /tmp/dvb.mpg avi mpeg4 400 25 mp3lame 192 320 240 5000 file

         # /tmp/dvb.mpg mpeg mpeg1video 400 25 mp2 192 320 240 5000 format=mpeg1 file

         #4 mpeg mpeg1video 400 25 mp3lame 192 400 240 5000 language=en local dvd

         ret_val = setup_socket(self.socket)

         if not ret_val[0]:

             return ret_val[1]

         return True

     # setup

     def play(self):

         if self.mencoder_old:

             try:

                 os.mkfifo(self.fifo)

             except:

                 lib.log("Fifo already exists")

         lib.log("Starting Mencoder: %s %s" % (self.path, self.args) )

         # exec Mencoder

         if self.mencoder_old:

             self.mencoder_pid = Popen(self.path + self.args, shell=True,

                                       close_fds=True)

             self.pout = open(self.fifo)

         else:

             self.path += self.args

             pin, self.pout = os.popen2(self.path)

         self.child_pid = os.fork()

         if self.child_pid == 0:

             conn,addr= self.socket.accept()

             lib.log("Sending Data to client: %s" % addr[0])

             data = self.pout.read(1024)

             conn.settimeout(5)

             retry = 0

             while data != "" and retry < 5:

                 try:

                     conn.send(data)

                     r, w, x = select([conn], [], [], 0)

                     if conn in r:

                         back = conn.recv(1024)

                         if back == "OK" and self.mplayer and not self.mplayer_pid:

                             self.run_mplayer()

                 except socket.error:

                     lib.log("Socket error (maybe timeout ?)")

                     retry += 1

                 data = self.pout.read(1024)

             if retry < 5:

                 lib.log("Finished sending Data to client: %s" % addr[0])

             else:

                 lib.log("Client timed out")

             sys.exit(0)

     def stop(self):

         try:

             if self.mplayer_old:

                 os.kill(self.mencoder_pid.pid + 1, signal.SIGKILL)

             else:

                 self.pout.close()

             self.mplayer = None

         except:

             lib.log("Trying to stop before playing...")

         if self.socket != None:

             lib.log("Closing socket")

             self.socket.close()

             lib.log("Trying to stop Mencoder process")

             if self.child_pid != None:

                 os.kill(self.child_pid, signal.SIGABRT)