Пример #1
0
    def play(self):
        """
        Start playback.
        """
        log.debug('mplayer start playback')

        # we know that self._mp_info has to be there or the object would
        # not be selected by the generic one. FIXME: verify that!
        assert(self._mp_info)

        # create mplayer object
        self._mplayer = ChildProcess(self._mp_cmd, gdb = log.getEffectiveLevel() == logging.DEBUG)

        # get argument and filter list
        args, filters = self._mplayer.args, self._mplayer.filters

        if 'x11' in self._mp_info['video_drivers']:
            args.append('-nomouseinput')

        #if 'outbuf' in self._mp_info['video_filters']:
        #    filters.append("outbuf=%s:yv12" % self._frame_shmkey)

        if self._properties['deinterlace'] == True or \
               (self._properties['deinterlace'] == 'auto' and \
                self._media.get('interlaced')):
            # add deinterlacer
            filters.append(config.mplayer.deinterlacer)


        if self._media.get('corrupt'):
            # File marked as corrupt. This happens for avi and mkv files
            # with no index. To make seeking work, add -idx
            args.append('-idx')
            
        # FIXME: self._filters_pre / add doesn't get included if no window.
        if self._window:
            self.configure_video()
        else:
            args.add(vo='null')

        self.configure_audio()

        # There is no way to make MPlayer ignore keys from the X11 window.  So
        # this hack makes a temp input file that maps all keys to a dummy (and
        # non-existent) command which causes MPlayer not to react to any key
        # presses, allowing us to implement our own handlers.  The temp file is
        # deleted once MPlayer has read it.
        tempfile = kaa.tempfile('popcorn/mplayer-input.conf')
        if not os.path.isfile(tempfile):
            keys = filter(lambda x: x not in string.whitespace, string.printable)
            keys = list(keys) + self._mp_info["keylist"]
            fd = open(tempfile, 'w')
            for key in keys:
                fd.write("%s noop\n" % key)
            fd.close()
        # only prevent input if the player is embedded
        if config.mplayer.embedded:
            args.add(input='conf=%s' % tempfile)

        # set properties subtitle filename and subtitle track
        if self._properties.get('subtitle-filename'):
            sub = self._properties.get('subtitle-filename')
            if os.path.splitext(sub)[1].lower() in ('.ifo', '.idx', '.sub'):
                args.add(vobsub=os.path.splitext(sub)[0],
                         vobsubid=self._properties.get('subtitle-track'))
            else:
                args.add(subfile=sub)
        elif self._properties.get('subtitle-track') != None:
            args.add(sid=self._properties.get('subtitle-track'))

        if self._properties.get('cache') == 'auto':
            if self._media.scheme == "dvd":
                args.add(cache=8192)
            if self._media.scheme == "vcd":
                args.add(cache=4096)
            if self._media.scheme == "dvb":
                args.add(cache=1024)
            if self._media.scheme == "http":
                args.add(cache=8192, cache_min=5)
            else:
                args.add(cache=5000)
        else:
            args.add(cache=self._properties.get('cache'))

        # connect to signals
        self._mplayer.signals['readline'].connect_weak(self._child_handle_line)

        # start playback
        self._mplayer.start(self._media).connect_weak(self._child_exited)
Пример #2
0
class MPlayer(MediaPlayer):

    RE_STATUS = re.compile("V:\s*([\d+\.]+)|A:\s*([\d+\.]+)\s\W")
    RE_SWS = re.compile("^SwScaler: [0-9]+x[0-9]+ -> ([0-9]+)x([0-9]+)")

    def __init__(self, properties):
        super(MPlayer, self).__init__(properties)
        self.state = STATE_NOT_RUNNING
        self._mp_cmd = config.mplayer.path
        if not self._mp_cmd:
            self._mp_cmd = kaa.utils.which("mplayer")

        if not self._mp_cmd:
            raise PlayerError, "No MPlayer executable found in PATH"

        self._mplayer = None

        self._filters_pre = []
        self._filters_add = []

        self._mp_info = _get_mplayer_info(self._mp_cmd, self._handle_mp_info)
        self._check_new_frame_t = kaa.WeakTimer(self._check_new_frame)
        self._cur_outbuf_mode = [True, False, None] # vo, shmem, size


    def __del__(self):
        if self._frame_shmem:
            self._frame_shmem.detach()
        if self._osd_shmem:
            self._osd_shmem.detach()


    def _handle_mp_info(self, info, exception=None, traceback=None):
        if exception is not None:
            self.state = STATE_NOT_RUNNING
            # TODO: handle me
            raise info
        self._mp_info = info



    #
    # child IO
    #

    def _child_handle_line(self, line):
        if re.search("@@@|outbuf|overlay", line, re.I):
            childlog(line)
        elif line[:2] not in ("A:", "V:"):
            childlog(line)

        if line.startswith("V:") or line.startswith("A:"):
            m = MPlayer.RE_STATUS.search(line)
            if m:
                old_pos = self.position
                p = (m.group(1) or m.group(2)).replace(",", ".")
                self.position = float(p)
                # if self.position - old_pos < 0 or \
                # self.position - old_pos > 1:
                # self.signals["seek"].emit(self.position)

                # XXX this logic won't work with seek-while-paused patch; state
                # will be "playing" after a seek.
                if self.state == STATE_PAUSED:
                    self.state = STATE_PLAYING
                if self.state == STATE_OPEN:
                    self.set_frame_output_mode()
                    self._mplayer.sub_visibility(False)
                    self.state = STATE_PLAYING
                    self.signals["stream_changed"].emit()

        elif line.startswith("  =====  PAUSE"):
            self.state = STATE_PAUSED

        elif line.startswith("ID_") and line.find("=") != -1:
            attr, value = line.split('=', 1)
            attr = attr[3:]
            info = { "VIDEO_FORMAT": ("vfourcc", str),
                     "VIDEO_BITRATE": ("vbitrate", int),
                     "VIDEO_WIDTH": ("width", int),
                     "VIDEO_HEIGHT": ("height", int),
                     "VIDEO_FPS": ("fps", float),
                     "VIDEO_ASPECT": ("aspect", float),
                     "AUDIO_FORMAT": ("afourcc", str),
                     "AUDIO_CODEC": ("acodec", str),
                     "AUDIO_BITRATE": ("abitrate", int),
                     "AUDIO_NCH": ("channels", int),
                     "LENGTH": ("length", float),
                     "FILENAME": ("filename", str) }
            if attr in info:
                self.streaminfo[info[attr][0]] = info[attr][1](value)

        elif line.startswith("Movie-Aspect"):
            aspect = line[16:].split(":")[0].replace(",", ".")
            if aspect[0].isdigit():
                self.streaminfo["aspect"] = float(aspect)

        elif line.startswith("VO:"):
            m = re.search("=> (\d+)x(\d+)", line)
            if m:
                vo_w, vo_h = int(m.group(1)), int(m.group(2))
                if "aspect" not in self.streaminfo or \
                       self.streaminfo["aspect"] == 0:
                    # No aspect defined, so base it on vo size.
                    self.streaminfo["aspect"] = vo_w / float(vo_h)

        elif line.startswith("overlay:") and line.find("reusing") == -1:
            m = re.search("(\d+)x(\d+)", line)
            if m:
                width, height = int(m.group(1)), int(m.group(2))
                try:
                    if self._osd_shmem:
                        self._osd_shmem.detach()
                except shm.error:
                    pass
                self._osd_shmem = shm.memory(\
                    shm.getshmid(self._osd_shmkey))
                self._osd_shmem.attach()

                self.signals["osd_configure"].emit(\
                    width, height, self._osd_shmem.addr + 16, width, height)

        elif line.startswith("outbuf:") and line.find("shmem key") != -1:
            try:
                if self._frame_shmem:
                    self._frame_shmem.detach()
            except shm.error:
                pass
            self._frame_shmem = shm.memory(shm.getshmid(self._frame_shmkey))
            self._frame_shmem.attach()
            self.set_frame_output_mode()  # Sync

        elif line.startswith("EOF code"):
            if self.state in (STATE_PLAYING, STATE_PAUSED):
                # The player may be idle bow, but we can't set the
                # state. If we do, generic will start a new file while
                # the mplayer process is still running and that does
                # not work. Unless we reuse mplayer proccesses we
                # don't react on EOF and only handle the dead
                # proccess.
                # self.state = STATE_IDLE
                pass

        elif line.startswith("FATAL:"):
            log.error(line.strip())


    def _child_exited(self, exitcode):
        log.info('mplayer exited')
        self.state = STATE_NOT_RUNNING


    def _is_alive(self):
        return self._mplayer and self._mplayer.running



    #
    # Methods for MediaPlayer subclasses
    #

    def open(self, media):
        """
        Open media.
        """
        if self.state != STATE_NOT_RUNNING:
            raise RuntimeError('mplayer not in STATE_NOT_RUNNING')

        args = []
        if media.scheme == "dvd":
            file, title = re.search("(.*?)(\/\d+)?$", media.url[4:]).groups()
            if file.replace('/', ''):
                if not os.path.isfile(file):
                    raise ValueError, "Invalid ISO file: %s" % file
                args.extend(('-dvd-device', file))
            args.append("dvd://")
            if title:
                args[-1] += title[1:]
        else:
            args.append(media.url)

        self._media = media
        self._media.mplayer_args = args
        self.state = STATE_OPENING

        # We have a problem at this point. The 'open' function is used to
        # open the stream and provide information about it. After that, the
        # caller can still change stuff before calling play. Mplayer doesn't
        # work that way so we have to run mplayer with -identify first.
        args = "-nolirc -nojoystick -identify -vo null -ao null -frames 0 -nocache"
        ident = kaa.Process(self._mp_cmd)
        ident.delimiter = ['\n', '\r']
        signal = ident.start(args.split(' ') + self._media.mplayer_args)
        signal.connect_weak(self._ident_exited)
        ident.signals['readline'].connect_weak(self._child_handle_line)


    def _ident_exited(self, code):
        """
        mplayer -identify finished
        """
        self.state = STATE_OPEN


    def configure_video(self):
        """
        Configure arguments and filter for video.
        """
        # get argument and filter list
        args, filters = self._mplayer.args, self._mplayer.filters

        # create filter list
        filters.extend(self._filters_pre[:])
        # FIXME: all this code seems to work. But I guess it has
        # some problems when we don't have an 1:1 pixel aspect
        # ratio on the monitor and using software scaler.

        aspect, dsize = self.aspect
        if hasattr(self._window, 'get_size'):
            size = self._window.get_size()
        else:
            # kaa.candy widget
            size = self._window.width, self._window.height
        # This may be needed for some non X based displays
        args.add(screenw=size[0], screenh=size[1])

        if not self._properties['scale'] == SCALE_IGNORE:
            # Expand to fit the given aspect. In scaled mode we don't
            # do that which will result in a scaled image filling
            # the whole screen
            filters.append('expand=:::::%s/%s' % tuple(aspect))
            # The expand filter has some strange side-effect on 4:3 content
            # on a 16:9 screen. With software scaling instead of black bars
            # on both sides you see garbage, without sws and xv output mplayer
            # uses gray bars. The following line removed that.
            args.append('-noslices')
            
        # FIXME: this only works if the window has the the aspect
        # as the full screen. In all other cases the window is not
        # fully used but at least with black bars.
        if self._properties['scale'] == SCALE_ZOOM:
            # This DOES NOT WORK as it should. The hardware scaler
            # will ignore the settings and keep aspect and does
            # not crop as default.  When using vo x11 and software
            # scaling, this lines do what they are supposed to do.
            filters.append('dsize=%s:%s:1' % size)
        else:
            # scale to window size
            # FIXME: add SCALE_4_3 and SCALE_16_9
            filters.append('dsize=%s:%s:0' % size)

        # add software scaler based on dsize arguments
        if self._properties.get('software-scaler') or \
               config.video.driver in ('x11',):
            filters.append('scale=0:0')
            args.add(sws=2)

        # add postprocessing
        if self._properties.get('postprocessing'):
            filters.append('pp')
            args.add(autoq=100)

        try:
            cpus = kaa.utils.get_num_cpus()
            args.add(lavdopts='fast:skiploopfilter=nonref:threads=%d' % cpus)
        except RuntimeError:
            pass

        # set monitor aspect (needed sometimes, not sure when and why)
        args.add(monitoraspect='%s:%s' % tuple(aspect))

        filters += self._filters_add
        #if 'overlay' in self._mp_info['video_filters']:
        #    filters.append("overlay=%s" % self._osd_shmkey)

        if isinstance(self._window, kaa.display.X11Window):
            if config.mplayer.embedded:
                args.add(wid="0x%x" % self._window.get_id())
            else:
                args.append('-fs')
            display = self._window.get_display().get_string()
            args.add(vo=config.video.driver, display=display,
                     colorkey=config.video.colorkey)
        elif self._window:
            args.append('-fs')
            args.add(vo=config.video.driver, colorkey=config.video.colorkey)
        else:
            args.add(vo='null')


    def configure_audio(self):
        """
        Configure arguments and filter for video.
        """
        # get argument and filter list
        args, filters = self._mplayer.args, self._mplayer.filters

        if config.audio.passthrough:
            args.add(ac='hwac3,hwdts,%s' % config.mplayer.audiocodecs)
        else:
            if config.mplayer.audiocodecs:
                args.add(ac='%s' % config.mplayer.audiocodecs)
            args.add(channels=config.audio.channels)

        args.add(ao=config.audio.driver)

        if config.audio.driver == 'alsa':
            args[-1] += ":noblock"
            n_channels = self.streaminfo.get('channels')
            if self.streaminfo.get('acodec') in ('a52', 'hwac3', 'ffdts', 'hwdts'):
                device = config.audio.device.passthrough
            elif n_channels == 1:
                device = config.audio.device.mono
            elif n_channels <= 4:
                device = config.audio.device.surround40
            elif n_channels <= 6:
                device = config.audio.device.surround51
            else:
                device = config.audio.device.stereo
            if device != '':
                args[-1] += ':device=' + device.replace(':', '=')

        # set property audio filename
        if self._properties.get('audio-filename'):
            args.add(audiofile=self._properties.get('audio-filename'))

        # set property audio track
        if self._properties.get('audio-track') is not None:
            args.add(aid=self._properties.get('audio-track'))


    def play(self):
        """
        Start playback.
        """
        log.debug('mplayer start playback')

        # we know that self._mp_info has to be there or the object would
        # not be selected by the generic one. FIXME: verify that!
        assert(self._mp_info)

        # create mplayer object
        self._mplayer = ChildProcess(self._mp_cmd, gdb = log.getEffectiveLevel() == logging.DEBUG)

        # get argument and filter list
        args, filters = self._mplayer.args, self._mplayer.filters

        if 'x11' in self._mp_info['video_drivers']:
            args.append('-nomouseinput')

        #if 'outbuf' in self._mp_info['video_filters']:
        #    filters.append("outbuf=%s:yv12" % self._frame_shmkey)

        if self._properties['deinterlace'] == True or \
               (self._properties['deinterlace'] == 'auto' and \
                self._media.get('interlaced')):
            # add deinterlacer
            filters.append(config.mplayer.deinterlacer)


        if self._media.get('corrupt'):
            # File marked as corrupt. This happens for avi and mkv files
            # with no index. To make seeking work, add -idx
            args.append('-idx')
            
        # FIXME: self._filters_pre / add doesn't get included if no window.
        if self._window:
            self.configure_video()
        else:
            args.add(vo='null')

        self.configure_audio()

        # There is no way to make MPlayer ignore keys from the X11 window.  So
        # this hack makes a temp input file that maps all keys to a dummy (and
        # non-existent) command which causes MPlayer not to react to any key
        # presses, allowing us to implement our own handlers.  The temp file is
        # deleted once MPlayer has read it.
        tempfile = kaa.tempfile('popcorn/mplayer-input.conf')
        if not os.path.isfile(tempfile):
            keys = filter(lambda x: x not in string.whitespace, string.printable)
            keys = list(keys) + self._mp_info["keylist"]
            fd = open(tempfile, 'w')
            for key in keys:
                fd.write("%s noop\n" % key)
            fd.close()
        # only prevent input if the player is embedded
        if config.mplayer.embedded:
            args.add(input='conf=%s' % tempfile)

        # set properties subtitle filename and subtitle track
        if self._properties.get('subtitle-filename'):
            sub = self._properties.get('subtitle-filename')
            if os.path.splitext(sub)[1].lower() in ('.ifo', '.idx', '.sub'):
                args.add(vobsub=os.path.splitext(sub)[0],
                         vobsubid=self._properties.get('subtitle-track'))
            else:
                args.add(subfile=sub)
        elif self._properties.get('subtitle-track') != None:
            args.add(sid=self._properties.get('subtitle-track'))

        if self._properties.get('cache') == 'auto':
            if self._media.scheme == "dvd":
                args.add(cache=8192)
            if self._media.scheme == "vcd":
                args.add(cache=4096)
            if self._media.scheme == "dvb":
                args.add(cache=1024)
            if self._media.scheme == "http":
                args.add(cache=8192, cache_min=5)
            else:
                args.add(cache=5000)
        else:
            args.add(cache=self._properties.get('cache'))

        # connect to signals
        self._mplayer.signals['readline'].connect_weak(self._child_handle_line)

        # start playback
        self._mplayer.start(self._media).connect_weak(self._child_exited)


    def stop(self):
        """
        Stop playback.
        """
        if self._mplayer:
            self._mplayer.stop()
            self.state = STATE_SHUTDOWN


    def pause(self):
        """
        Pause playback.
        """
        self._mplayer.pause()


    def resume(self):
        """
        Resume playback.
        """
        self._mplayer.pause()


    def seek(self, value, type):
        """
        SEEK_RELATIVE, SEEK_ABSOLUTE and SEEK_PERCENTAGE.
        """
        s = [SEEK_RELATIVE, SEEK_PERCENTAGE, SEEK_ABSOLUTE]
        self._mplayer.seek(value, s.index(type))


    #
    # Property settings
    #

    @runtime_policy(DEFER_UNTIL_PLAYING)
    def _set_prop_audio_delay(self, delay):
        """
        Sets audio delay. Positive value defers audio by delay.
        """
        self._mplayer.audio_delay(-delay, 1)


    @runtime_policy(IGNORE_UNLESS_PLAYING)
    def _set_prop_audio_track(self, id):
        """
        Change audio track (mpeg and mkv only)
        """
        self._mplayer.switch_audio(id)


    @runtime_policy(IGNORE_UNLESS_PLAYING)
    def _set_prop_subtitle_track(self, id):
        """
        Change subtitle track
        """
        self._mplayer.sub_select(id)


    @runtime_policy(IGNORE_UNLESS_PLAYING)
    def _set_prop_subtitle_filename(self, filename):
        """
        Change subtitle filename
        """
        self._mplayer.sub_load(filename)


    @runtime_policy(DEFER_UNTIL_PLAYING)
    def _set_prop_subtitle_visibility(self, enabled):
        """
        Change subtitle visibility
        """
        self._mplayer.sub_visibility(int(enabled))

    #
    # Methods for filter handling (not yet in generic and base)
    #
    # FIXME: no distinction between audio and video filters

    def prepend_filter(self, filter):
        """
        Add filter to the prepend list.
        """
        self._filters_pre.append(filter)


    def append_filter(self, filter):
        """
        Add filter to the normal filter list.
        """
        self._filters_add.append(filter)


    def get_filters(self):
        """
        Return all filter set.
        """
        return self._filters_pre + self._filters_add


    def remove_filter(self, filter):
        """
        Remove filter for filter list.
        """
        for l in (self._filters_pre, self._filters_add):
            if filter in l:
                l.remove(filter)


    #
    # Methods and helper for MediaPlayer subclasses for CAP_OSD
    #

    def osd_can_update(self):
        """
        Returns True if it is safe to write to the player's shared memory
        buffer used for OSD, and False otherwise.  If this buffer is written
        to even though this function returns False, the OSD may exhibit
        corrupt output or tearing during animations.
        See generic.osd_can_update for details.
        """
        if not self._osd_shmem:
            return False

        try:
            if ord(self._osd_shmem.read(1)) == BUFFER_UNLOCKED:
                return True
        except shm.error:
            self._osd_shmem.detach()
            self._osd_shmem = None

        return False



    def osd_update(self, alpha = None, visible = None, invalid_regions = None):
        """
        Updates the OSD of the player based on the given argments:
        See generic.osd_update for details.
        """
        cmd = []
        if alpha != None:
            cmd.append("alpha=%d" % alpha)
        if visible != None:
            cmd.append("visible=%d" % int(visible))
        if invalid_regions:
            for (x, y, w, h) in invalid_regions:
                cmd.append("invalidate=%d:%d:%d:%d" % (x, y, w, h))
        self._mplayer.overlay(','.join(cmd))
        self._overlay_set_lock(BUFFER_LOCKED)


    def _overlay_set_lock(self, byte):
        try:
            if self._osd_shmem and self._osd_shmem.attached:
                self._osd_shmem.write(chr(byte))
        except shm.error:
            self._osd_shmem.detach()
            self._osd_shmem = None



    #
    # Methods and helper for MediaPlayer subclasses for CAP_CANVAS
    #


    def set_frame_output_mode(self, vo = None, notify = None, size = None):
        """
        Controls if and how frames are delivered via the 'frame' signal, and
        whether or not frames are drawn to the vo driver's video window.
        See generic.set_frame_output_mode for details.
        """
        if vo != None:
            self._cur_outbuf_mode[0] = vo
        if notify != None:
            self._cur_outbuf_mode[1] = notify
            if notify:
                self._check_new_frame_t.start(0.01)
            else:
                self._check_new_frame_t.stop()
        if size != None:
            self._cur_outbuf_mode[2] = size

        if not self._is_alive():
            return

        mode = { (False, False): 0, (True, False): 1,
                 (False, True): 2, (True, True): 3 }
        mode = mode[tuple(self._cur_outbuf_mode[:2])]

        size = self._cur_outbuf_mode[2]
        if size == None:
            self._mplayer.outbuf(mode)
        else:
            self._mplayer.outbuf(mode, size[0], size[1])


    def unlock_frame_buffer(self):
        """
        Unlocks the frame buffer provided by the last 'frame' signal
        See generic.unlock_frame_buffer for details.
        """
        try:
            self._frame_shmem.write(chr(BUFFER_UNLOCKED))
        except shm.error:
            self._frame_shmem.detach()
            self._frame_shmem = None


    def _check_new_frame(self):
        if not self._frame_shmem:
            return

        try:
            lock, width, height, aspect = \
                  struct.unpack("hhhd", self._frame_shmem.read(16))
        except shm.error:
            self._frame_shmem.detach()
            self._frame_shmem = None
            return

        if lock & BUFFER_UNLOCKED:
            return

        if width > 0 and height > 0 and aspect > 0:
            self.signals["frame"].emit(\
                width, height, aspect, self._frame_shmem.addr + 16, "yv12")