from __future__ import division

 import os

 import sys

 import lib

 import time

 import shlex

 import signal

 import socket

 import ConfigParser

 import logging as log

 from select import *

 from subprocess import *

 class Media(object):

     def __init__(self, config):

         self.config = config

         self.do_cleanup()

     # __init__()

     def do_cleanup(self):

         self.path = ""

         self.args = []

         self.language = None

         self.subtitle = None

         self.mpegopts = None

         self.socket = None

         self.child_pid = None

         self.mplayer = None

         self.mencoder_pid = None

         self.mplayer_pid = None

         self.audio_opts = None

         self.video_opts = None

         self.gst_pipe = None

         self.gst_pid = None

         self.transcode_local = None

     # do_cleanup()

     def setup_opts(self, options):

         for opt in options:

             if opt == "local":

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

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

                 try:

                     lan = opt.split("=")[1]

                     if len(lan) < 2:

                         self.language = lan

                 except Exception, e:

                     log.error("Bad language option: %s" % opt)

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

                 try:

                     sub = opt.split("=")[1]

                     if len(sub) < 2:

                         self.language = sub

                 except Exception, e:

                     log.error("Bad subtitle option: %s" % opt)

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

                 try:

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

                 except Exception, e:

                     log.error("Bad format option: %s" % opt)

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

                 try:

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

                 except Exception, e:

                     log.error("Bad outfile option: %s" % opt)

     # setup_opts()

     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:

             try:

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

                 os.mkfifo(self.fifo)

             except Exception, e:

                 log.info("Fifo: %s" % e)

         else:

             self.fifo = "-"

     # setup_mencoder()

     def setup_audio(self):

         if self.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)

     # setup_audio()

     def setup_video(self):

         video = ""

         video += " -of %s" % self.mux

         video += " -ofps %s" % self.fps

         if self.vcodec == "nuv" or self.vcodec == "xvid"\

                or self.vcodec == "qtvideo" or self.vcodec == "copy":

             video += " -ovc %s" % self.vcodec

         else:

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

                 self.vcodec, self.vbitrate)

         if self.mux == "mpeg" and self.mpegopts is not None:

             video += " -mpegopts format=%s" % self.mpegopts

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

         return video

     # setup_video()

     def arg_append(self, args, options):

         l = shlex.split(options)

         for i in l:

             args.append(i)

     # arg_append()

     def setup_args(self, args):

         args.append(self.path)

         #args.append(self.filename)

         args.append("-")

         if self.language != None:

             self.arg_append(args, "-alang %s" % self.language)

         if self.subtitle != None:

             self.arg_append(args, "-slang %s" % self.subtitle)

             self.arg_append(args, "-subfps %s" % self.fps)

         self.arg_append(args, "-idx")

         self.arg_append(args, self.audio_opts)

         self.arg_append(args, self.video_opts)

         self.arg_append(args, "-really-quiet")

         self.arg_append(args, "-o %s" % self.fifo)

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

     # setup_args()

     def setup_filename(self, filename):

         try:

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

         except:

             return (False, "Wrong filename protocol")

         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)

         elif self.kind == "dvd":

             self.filename = "dvd://" + filename

         elif self.kind == "myth":

             self.filename = filename

             self.gst_pipe = os.pipe()

             print self.gst_pipe[0]

             print self.gst_pipe[1]

         return (True, "")

     # setup_filename()

     def setup_socket(self):

         if self.socket != None:

             self.socket = None

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

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

         try:

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

             self.socket.listen(1)

         except Exception, e:

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

             return (False, e)

         return (True, "")

     # setup_socket()

     '''

     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

     '''

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

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

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

     # file:///tmp/mpg/bad_day.mpg avi mpeg4 400 25 mp3 192 320 240

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

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

         if self.args != []:

             self.do_cleanup()

         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

         self.setup_opts(options)

         self.audio_opts = self.setup_audio()

         self.video_opts = self.setup_video()

         self.setup_args(self.args)

         ret_val = self.setup_socket()

         return ret_val

     # setup()

     def play_loop(self, conn):

         data = self.pout.read(4096)

         conn.settimeout(5)

         retry = 0

         if not self.transcode_local:

             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, e:

                     log.error("Socket error: %s" % e)

                     retry += 1

                 data = self.pout.read(4096)

                 print data

         else:

             local = open(self.transcode_local, "w")

             total = os.path.getsize(self.filename)

             partial = 4096

             while data != "":

                 try:

                     local.write(data)

                 except Exception, e:

                     log.error("Write error: %s" % e)

                 data = self.pout.read(4096)

                 partial += len(data)

                 conn.send("%.2f\n" % (partial * 100 / total) )

             local.close()

             conn.send("DONE\n")

         return retry

     # play_loop()

     def play(self):

         log.info("Starting Mencoder: %s" % self.args )

         if self.gst_pipe:

             try:

                 gst = [ lib.which("gst-launch-0.10") ]

                 self.arg_append(gst, "gnomevfssrc location=%s" % self.filename)

                 self.arg_append(gst, "! fdsink fd=%d" % self.gst_pipe[1])

                 self.gst_pid = Popen(gst, stdout=self.gst_pipe[1], close_fds=True)

                 log.info("Running Gstreamer: %s" % gst);

             except Exception, e:

                 msg = "Could not init Gstreamer: %s" % e

                 log.error(msg)

                 return (False, msg)

         try:

             if not self.gst_pipe:

                 self.stdin = open(self.filename)

             else:

                 self.stdin = self.gst_pipe[0]

             self.mencoder_pid = Popen(self.args, stdin=self.stdin, stdout=PIPE, close_fds=True)

         except Exception, e:

             msg = "Could not init Mencoder: %s" % e

             log.error(msg)

             return (False, msg)

         if self.mencoder_old: self.pout = open(self.fifo)

         else: self.pout = self.mencoder_pid.stdout

         self.child_pid = os.fork()

         if self.child_pid == 0:

             conn, addr = self.socket.accept()

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

             retry = self.play_loop(conn)

             if retry < 5:

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

             else:

                 log.error("Client timed out, retried more than %s times" % retry)

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

             sys.exit(0)

         return (True, "")

     # play()

     def stop(self):

         try:

             if self.mencoder_pid:

                 os.kill(self.mencoder_pid.pid, signal.SIGTERM)

                 self.mencoder_pid = None

             if self.mplayer_pid:

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

                 self.mplayer_pid = None

             if self.socket:

                 self.socket.close()

                 self.socket = None

             if self.child_pid:

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

                 self.child_pid = None

             if self.gst_pid:

                 os.kill(self.gst_pid.pid, signal.SIGTERM)

                 self.gst_pid = None

             self.do_cleanup()

             os.wait()

         except Exception, e:

             log.error("Stop error: %s" % e)

     # stop()