示例#1
0
class VideoPlayer(Player):
    """
    plays a track using omxplayer
    _init_ iniitalises state and checks resources are available.
    use the returned instance reference in all other calls.
    At the end of the path (when closed) do not re-use, make instance= None and start again.
    States - 'initialised' when done successfully
    Initialisation is immediate so just returns with error code.
    """

    debug = False
    debug = True

    def __init__(self, show_id, showlist, root, canvas, show_params,
                 track_params, pp_dir, pp_home, pp_profile, end_callback,
                 command_callback):

        # initialise items common to all players
        Player.__init__(self, show_id, showlist, root, canvas, show_params,
                        track_params, pp_dir, pp_home, pp_profile,
                        end_callback, command_callback)
        # print ' !!!!!!!!!!!videoplayer init'
        self.mon.trace(self, '')
        self.video_start_timestamp = 0
        self.dm = DisplayManager()

        # get player parameters
        if self.track_params['omx-audio'] != "":
            self.omx_audio = self.track_params['omx-audio']
        else:
            self.omx_audio = self.show_params['omx-audio']
        if self.omx_audio != "": self.omx_audio = "-o " + self.omx_audio

        self.omx_max_volume_text = self.track_params['omx-max-volume']
        if self.omx_max_volume_text != "":
            self.omx_max_volume = int(self.omx_max_volume_text)
        else:
            self.omx_max_volume = 0

        if self.track_params['omx-volume'] != "":
            self.omx_volume = self.track_params['omx-volume']
        else:
            self.omx_volume = self.show_params['omx-volume']

        if self.omx_volume != "":
            self.omx_volume = int(self.omx_volume)
        else:
            self.omx_volume = 0

        self.omx_volume = min(self.omx_volume, self.omx_max_volume)

        if self.track_params['omx-window'] != '':
            self.omx_window = self.track_params['omx-window']
        else:
            self.omx_window = self.show_params['omx-window']

        if self.track_params['omx-other-options'] != '':
            self.omx_other_options = self.track_params['omx-other-options']
        else:
            self.omx_other_options = self.show_params['omx-other-options']

        if self.track_params['freeze-at-start'] != '':
            self.freeze_at_start = self.track_params['freeze-at-start']
        else:
            self.freeze_at_start = self.show_params['freeze-at-start']

        if self.track_params['freeze-at-end'] != '':
            freeze_at_end_text = self.track_params['freeze-at-end']
        else:
            freeze_at_end_text = self.show_params['freeze-at-end']

        if freeze_at_end_text == 'yes':
            self.freeze_at_end_required = True
        else:
            self.freeze_at_end_required = False

        if self.track_params['seamless-loop'] == 'yes':
            self.seamless_loop = ' --loop '
        else:
            self.seamless_loop = ''

        if self.track_params['pause-timeout'] != '':
            pause_timeout_text = self.track_params['pause-timeout']
        else:
            pause_timeout_text = self.show_params['pause-timeout']

        if pause_timeout_text.isdigit():
            self.pause_timeout = int(pause_timeout_text)
        else:
            self.pause_timeout = 0

        # initialise video playing state and signals
        self.quit_signal = False
        self.unload_signal = False
        self.play_state = 'initialised'
        self.frozen_at_end = False
        self.pause_timer = None

    # LOAD - creates and omxplayer instance, loads a track and then pause
    def load(self, track, loaded_callback, enable_menu):
        # instantiate arguments
        self.track = track
        self.loaded_callback = loaded_callback  #callback when loaded
        # print '!!!!!!!!!!! videoplayer load',self.track
        self.mon.log(
            self, "Load track received from show Id: " + str(self.show_id) +
            ' ' + self.track)
        self.mon.trace(self, '')

        # do common bits of  load
        Player.pre_load(self)

        # set up video display
        if self.track_params['display-name'] != "":
            video_display_name = self.track_params['display-name']
        else:
            video_display_name = self.show_canvas_display_name
        status, message, self.omx_display_id = self.dm.id_of_display(
            video_display_name)
        if status == 'error':
            self.mon.err(self, message)
            self.play_state = 'load-failed'
            if self.loaded_callback is not None:
                self.loaded_callback(
                    'error', 'Display not connected: ' + video_display_name)
                return

        # set up video window and calc orientation
        status, message, command, has_window, x1, y1, x2, y2 = self.parse_video_window(
            self.omx_window, self.omx_display_id)
        if status == 'error':
            self.mon.err(
                self,
                'omx window error: ' + message + ' in ' + self.omx_window)
            self.play_state = 'load-failed'
            if self.loaded_callback is not None:
                self.loaded_callback(
                    'error',
                    'omx window error: ' + message + ' in ' + self.omx_window)
                return
        else:
            if has_window is True:
                self.omx_window_processed = '--win " ' + str(x1) + ' ' + str(
                    y1) + ' ' + str(x2) + ' ' + str(y2) + ' " '
            else:
                self.omx_window_processed = self.omx_aspect_mode

        # load the plugin, this may modify self.track and enable the plugin drawign to canvas
        if self.track_params['plugin'] != '':
            status, message = self.load_plugin()
            if status == 'error':
                self.mon.err(self, message)
                self.play_state = 'load-failed'
                if self.loaded_callback is not None:
                    self.loaded_callback('error', message)
                    return

        # load the images and text
        status, message = self.load_x_content(enable_menu)
        if status == 'error':
            self.mon.err(self, message)
            self.play_state = 'load-failed'
            if self.loaded_callback is not None:
                self.loaded_callback('error', message)
                return

        if not (track[0:3] in ('udp', 'tcp')
                or track[0:4] in ('rtsp', 'rtmp')):

            if not os.path.exists(track):
                self.mon.err(self, "Track file not found: " + track)
                self.play_state = 'load-failed'
                if self.loaded_callback is not None:
                    self.loaded_callback('error',
                                         'track file not found: ' + track)
                    return

        self.omx = OMXDriver(self.canvas, self.pp_dir)
        self.start_state_machine_load(self.track)

    # SHOW - show a track
    def show(self, ready_callback, finished_callback, closed_callback):
        # print "!!!! videoplayer show"
        # instantiate arguments
        self.ready_callback = ready_callback  # callback when ready to show video
        self.finished_callback = finished_callback  # callback when finished showing
        self.closed_callback = closed_callback

        self.mon.trace(self, '')

        #  do animation at start etc.
        Player.pre_show(self)

        # start show state machine
        self.start_state_machine_show()
        self.video_start_timestamp = self.omx.video_start_timestamp
        global globalVideoTimestampStart
        globalVideoTimestampStart = self.video_start_timestamp
        self.mon.log(
            self, "Timestamp from show starting: " +
            str(self.omx.video_start_timestamp))

    # UNLOAD - abort a load when omplayer is loading or loaded
    def unload(self):
        self.mon.trace(self, '')

        self.mon.log(self,
                     ">unload received from show Id: " + str(self.show_id))
        self.start_state_machine_unload()

    # CLOSE - quits omxplayer from 'pause at end' state
    def close(self, closed_callback):
        self.mon.trace(self, '')
        self.mon.log(self,
                     ">close received from show Id: " + str(self.show_id))
        self.closed_callback = closed_callback
        self.start_state_machine_close()

    def input_pressed(self, symbol):
        if symbol[0:4] == 'omx-':
            if symbol[0:5] in ('omx-+', 'omx--', 'omx-='):
                if symbol[4] in ('+', '='):
                    self.inc_volume()
                else:
                    self.dec_volume()
            else:
                self.control(symbol[4])
        elif symbol == 'inc-volume':
            self.inc_volume()
        elif symbol == 'dec-volume':
            self.dec_volume()
        elif symbol == 'pause':
            self.pause()
        elif symbol == 'go':
            self.go()
        elif symbol == 'unmute':
            self.unmute()
        elif symbol == 'mute':
            self.mute()
        elif symbol == 'pause-on':
            self.pause_on()
        elif symbol == 'pause-off':
            self.pause_off()
        elif symbol == 'stop':
            self.stop()

    # respond to normal stop
    def stop(self):
        self.mon.log(self, ">stop received from show Id: " + str(self.show_id))
        # cancel the pause timer
        if self.pause_timer != None:
            self.canvas.after_cancel(self.pause_timer)
            self.pause_timer = None

        # send signal to freeze the track - causes either pause or quit depends on freeze at end
        if self.freeze_at_end_required is True:
            if self.play_state == 'showing' and self.frozen_at_end is False:
                self.frozen_at_end = True
                # pause the track
                self.omx.pause('freeze at end from user stop')
                self.quit_signal = True
                # and return to show so it can end  the track and the video in track ready callback
##                if self.finished_callback is not None:
##                    # print 'finished from stop'
##                    self.finished_callback('pause_at_end','pause at end')
            else:
                self.mon.log(self, "!<stop rejected")
        else:
            # freeze not required and its showing just stop the video
            if self.play_state == 'showing':
                self.quit_signal = True
            else:
                self.mon.log(self, "!<stop rejected")

    def inc_volume(self):
        self.mon.log(self,
                     ">inc-volume received from show Id: " + str(self.show_id))
        if self.play_state == 'showing' and self.frozen_at_end is False and self.omx.paused_at_start == 'done':
            self.omx.inc_volume()
            return True
        else:
            self.mon.log(self, "!<inc-volume rejected " + self.play_state)
            return False

    def dec_volume(self):
        self.mon.log(self,
                     ">dec-volume received from show Id: " + str(self.show_id))
        if self.play_state == 'showing' and self.frozen_at_end is False and self.omx.paused_at_start == 'done':
            self.omx.dec_volume()
            return True
        else:
            self.mon.log(self, "!<dec-volume rejected " + self.play_state)
            return False

    def mute(self):
        self.mon.log(self, ">mute received from show Id: " + str(self.show_id))
        if self.play_state == 'showing' and self.frozen_at_end is False and self.omx.paused_at_start == 'done':
            self.omx.mute()
            return True
        else:
            self.mon.log(self, "!<mute rejected " + self.play_state)
            return False

    def unmute(self):
        self.mon.log(self,
                     ">unmute received from show Id: " + str(self.show_id))
        if self.play_state == 'showing' and self.frozen_at_end is False and self.omx.paused_at_start == 'done':
            self.omx.unmute()
            return True
        else:
            self.mon.log(self, "!<unmute rejected " + self.play_state)
            return False

    # toggle pause
    def pause(self):
        self.mon.log(
            self, ">toggle pause received from show Id: " + str(self.show_id))
        if self.play_state == 'showing' and self.frozen_at_end is False and self.omx.paused_at_start == 'done':
            self.omx.toggle_pause('user')
            if self.omx.paused is True and self.pause_timeout > 0:
                # kick off the pause teimeout timer
                self.pause_timer = self.canvas.after(
                    self.pause_timeout * 1000, self.pause_timeout_callback)
            else:
                # cancel the pause timer
                if self.pause_timer != None:
                    self.canvas.after_cancel(self.pause_timer)
                    self.pause_timer = None
            return True
        else:
            self.mon.log(self, "!<pause rejected " + self.play_state)
            return False

    def pause_timeout_callback(self):
        self.pause_off()
        self.pause_timer = None

    # pause on
    def pause_on(self):
        self.mon.log(self,
                     ">pause on received from show Id: " + str(self.show_id))
        if self.play_state == 'showing' and self.frozen_at_end is False and self.omx.paused_at_start == 'done':
            self.omx.pause_on()
            if self.omx.paused is True and self.pause_timeout > 0:
                # kick off the pause teimeout timer
                self.pause_timer = self.canvas.after(
                    self.pause_timeout * 1000, self.pause_timeout_callback)
            return True
        else:
            self.mon.log(self, "!<pause on rejected " + self.play_state)
            return False

    # pause off
    def pause_off(self):
        self.mon.log(self,
                     ">pause off received from show Id: " + str(self.show_id))
        if self.play_state == 'showing' and self.frozen_at_end is False and self.omx.paused_at_start == 'done':
            self.omx.pause_off()
            if self.omx.paused is False:
                # cancel the pause timer
                if self.pause_timer != None:
                    self.canvas.after_cancel(self.pause_timer)
                    self.pause_timer = None
            return True
        else:
            self.mon.log(self, "!<pause off rejected " + self.play_state)
            return False

    # go after freeze at start
    def go(self):
        self.mon.log(self, ">go received from show Id: " + str(self.show_id))
        if self.play_state == 'showing' and self.omx.paused_at_start == 'True':
            self.omx.go()
            return True
        else:
            self.mon.log(self, "!<go rejected " + self.play_state)
            return False

    # other control when playing
    def control(self, char):
        if self.play_state == 'showing' and self.frozen_at_end is False and self.omx.paused_at_start == 'done' and char not in (
                'q'):
            self.mon.log(self, "> send control to omx: " + char)
            self.omx.control(char)
            return True
        else:
            self.mon.log(self, "!<control rejected")
            return False

# ***********************
# track showing state machine
# **********************

    """
    STATES OF STATE MACHINE
    Threre are ongoing states and states that are set just before callback

    >init - Create an instance of the class
    <On return - state = initialised   -  - init has been completed, do not generate errors here

    >load
        Fatal errors should be detected in load. If so  loaded_callback is called with 'load-failed'
         Ongoing - state=loading - load called, waiting for load to complete   
    < loaded_callback with status = normal
         state=loaded - load has completed and video paused before first frame      
    <loaded_callback with status=error
        state= load-failed - omxplayer process has been killed because of failure to load   

    On getting the loaded_callback with status=normal the track can be shown using show
    Duration obtained from track should always cause pause_at_end. if not please tell me as the fudge factor may need adjusting.


    >show
        show assumes a track has been loaded and is paused.
       Ongoing - state=showing - video is showing 
    <finished_callback with status = pause_at_end
            state=showing but frozen_at_end is True
    <closed_callback with status= normal
            state = closed - video has ended omxplayer has terminated.


    On getting finished_callback with status=pause_at end a new track can be shown and then use close to quit the video when new track is ready
    On getting closed_callback with status=  nice_day omxplayer closing should not be attempted as it is already closed
    Do not generate user errors in Show. Only generate system erros such as illegal state abd then use end()

    >close
       Ongoing state - closing - omxplayer processes are dying due to quit sent
    <closed_callback with status= normal - omxplayer is dead, can close the track instance.

    >unload
        Ongoing states - start_unload and unloading - omxplayer processes are dying due to quit sent.
        when unloading is complete state=unloaded
        I have not added a callback to unload. its easy to add one if you want.

    closed is needed because wait_for end in pp_show polls for closed and does not use closed_callback
    
    """
    def start_state_machine_load(self, track):
        self.track = track
        # initialise all the state machine variables
        self.loading_count = 0  # initialise loading timeout counter
        self.play_state = 'loading'

        # load the selected track
        # options= '  ' + self.omx_audio+ ' --vol -6000 ' + self.omx_window_processed + ' ' + self.seamless_loop + ' ' + self.omx_other_options +" "

        options = ' --display ' + str(
            self.omx_display_id
        ) + ' --no-osd ' + self.omx_audio + ' --vol -6000 ' + self.omx_window_processed + self.omx_rotate + ' ' + self.seamless_loop + ' ' + self.omx_other_options + " "
        self.omx.load(track, self.freeze_at_start, options,
                      self.mon.pretty_inst(self), self.omx_volume,
                      self.omx_max_volume)
        # self.mon.log (self,'Send load command track '+ self.track + 'with options ' + options + 'from show Id: '+ str(self.show_id))
        # print 'omx.load started ',self.track
        # and start polling for state changes
        self.tick_timer = self.canvas.after(50, self.load_state_machine)

    def start_state_machine_unload(self):
        # print ('videoplayer - starting unload',self.play_state)
        if self.play_state in ('closed', 'initialised', 'unloaded'):
            # omxplayer already closed
            self.play_state = 'unloaded'
            # print ' closed so no need to unload'
        else:
            if self.play_state == 'loaded':
                # load already complete so set unload signal and kick off state machine
                self.play_state = 'start_unload'
                self.unloading_count = 0
                self.unload_signal = True
                self.tick_timer = self.canvas.after(50,
                                                    self.load_state_machine)
            elif self.play_state == 'loading':
                # wait for load to complete before unloading - ???? must do this because does not respond to quit when loading
                # state machine will go to start_unloading state and stop omxplayer
                self.unload_signal = True
            else:
                self.mon.err(
                    self, 'illegal state in unload method: ' + self.play_state)
                self.end('error',
                         'illegal state in unload method: ' + self.play_state)

    def start_state_machine_show(self):
        if self.play_state == 'loaded':
            # print '\nstart show state machine ' + self.play_state
            self.play_state = 'showing'
            self.freeze_signal = False  # signal that user has pressed stop
            self.must_quit_signal = False
            # show the track and content
            self.omx.show(self.freeze_at_end_required)
            self.mon.log(self,
                         '>showing track from show Id: ' + str(self.show_id))

            # and start polling for state changes
            # print 'start show state machine show'
            self.tick_timer = self.canvas.after(0, self.show_state_machine)
        # race condition don't start state machine as unload in progress
        elif self.play_state == 'start_unload':
            pass
        else:
            self.mon.fatal(self,
                           'illegal state in show method ' + self.play_state)
            self.play_state = 'show-failed'
            if self.finished_callback is not None:
                self.finished_callback(
                    'error',
                    'illegal state in show method: ' + self.play_state)

    def start_state_machine_close(self):
        self.quit_signal = True
        # print 'start close state machine close'
        self.tick_timer = self.canvas.after(0, self.show_state_machine)

    def load_state_machine(self):
        # print 'vidoeplayer state is'+self.play_state
        if self.play_state == 'loading':
            # if omxdriver says loaded then can finish normally
            # self.mon.log(self,"      State machine: " + self.play_state)
            if self.omx.end_play_signal is True:
                # got nice day before the first timestamp
                self.mon.warn(self, self.track)
                self.mon.warn(
                    self,
                    "loading  - omxplayer ended before starting track with reason: "
                    + self.omx.end_play_reason + ' at ' +
                    str(self.omx.video_position))
                self.omx.kill()
                self.mon.err(self, 'omxplayer ended before loading track')
                self.play_state = 'load-failed'
                self.mon.log(
                    self, "      Entering state : " + self.play_state +
                    ' from show Id: ' + str(self.show_id))
                if self.loaded_callback is not None:
                    self.loaded_callback(
                        'error', 'omxplayer ended before loading track')
            else:
                # end play signal false  - continue waiting for first timestamp
                self.loading_count += 1
                # video has loaded
                if self.omx.start_play_signal is True:
                    self.mon.log(
                        self, "Loading complete from show Id: " +
                        str(self.show_id) + ' ' + self.track)
                    self.mon.log(
                        self, 'Got video duration from track, frezing at: ' +
                        str(self.omx.duration) + ' microsecs.')

                    if self.unload_signal is True:
                        # print('unload sig=true state= start_unload')
                        # need to unload, kick off state machine in 'start_unload' state
                        self.play_state = 'start_unload'
                        self.unloading_count = 0
                        self.mon.log(
                            self, "      Entering state : " + self.play_state +
                            ' from show Id: ' + str(self.show_id))
                        self.tick_timer = self.canvas.after(
                            200, self.load_state_machine)
                    else:
                        self.play_state = 'loaded'
                        self.mon.log(
                            self, "      Entering state : " + self.play_state +
                            ' from show Id: ' + str(self.show_id))
                        if self.loaded_callback is not None:
                            # print 'callback when loaded'
                            self.loaded_callback('normal', 'video loaded')
                else:
                    # start play signal false - continue to wait
                    if self.loading_count > 400:  #40 seconds
                        # deal with omxplayer crashing while  loading and hence not receive start_play_signal
                        self.mon.warn(self, self.track)
                        self.mon.warn(
                            self, "loading - videoplayer counted out: " +
                            self.omx.end_play_reason + ' at ' +
                            str(self.omx.video_position))
                        self.omx.kill()
                        self.mon.warn(
                            self,
                            'videoplayer counted out when loading track ')
                        self.play_state = 'load-failed'
                        self.mon.log(
                            self, "      Entering state : " + self.play_state +
                            ' from show Id: ' + str(self.show_id))
                        if self.loaded_callback is not None:
                            self.loaded_callback(
                                'error',
                                'omxplayer counted out when loading track')
                    else:
                        self.tick_timer = self.canvas.after(
                            100, self.load_state_machine)  #200

        elif self.play_state == 'start_unload':
            # omxplayer reports it is terminating
            # self.mon.log(self,"      State machine: " + self.play_state)

            # deal with unload signal
            if self.unload_signal is True:
                self.unload_signal = False
                self.omx.stop()

            if self.omx.end_play_signal is True:
                self.omx.end_play_signal = False
                self.mon.log(
                    self,
                    "            <end play signal received with reason: " +
                    self.omx.end_play_reason + ' at: ' +
                    str(self.omx.video_position))

                # omxplayer has been closed
                if self.omx.end_play_reason == 'nice_day':
                    # no problem with omxplayer
                    self.play_state = 'unloading'
                    self.unloading_count = 0
                    self.mon.log(
                        self, "      Entering state : " + self.play_state +
                        ' from show Id: ' + str(self.show_id))
                    self.tick_timer = self.canvas.after(
                        50, self.load_state_machine)
                else:
                    # unexpected reason
                    self.mon.err(
                        self, 'unexpected reason at unload: ' +
                        self.omx.end_play_reason)
                    self.end(
                        'error', 'unexpected reason at unload: ' +
                        self.omx.end_play_reason)
            else:
                # end play signal false
                self.tick_timer = self.canvas.after(50,
                                                    self.load_state_machine)

        elif self.play_state == 'unloading':
            # wait for unloading to complete
            self.mon.log(self, "      State machine: " + self.play_state)

            # if spawned process has closed can change to closed state
            if self.omx.is_running() is False:
                self.mon.log(self, "            <omx process is dead")
                self.play_state = 'unloaded'
                self.mon.log(
                    self, "      Entering state : " + self.play_state +
                    ' from show Id: ' + str(self.show_id))
            else:
                # process still running
                self.unloading_count += 1
                if self.unloading_count > 10:
                    # deal with omxplayer not terminating at the end of a track
                    self.mon.warn(self, self.track)
                    self.mon.warn(
                        self,
                        "            <unloading - omxplayer failed to close at: "
                        + str(self.omx.video_position))
                    self.mon.warn(self, 'omxplayer should now  be killed ')
                    self.omx.kill()
                    self.play_state = 'unloaded'
                    self.mon.log(
                        self, "      Entering state : " + self.play_state +
                        ' from show Id: ' + str(self.show_id))
                else:
                    self.tick_timer = self.canvas.after(
                        200, self.load_state_machine)
        else:
            self.mon.err(
                self,
                'illegal state in load state machine: ' + self.play_state)
            self.end('error',
                     'load state machine in illegal state: ' + self.play_state)

    def show_state_machine(self):
        # print self.play_state
        # if self.play_state != 'showing': print 'show state is '+self.play_state
        if self.play_state == 'showing':
            # service any queued stop signals by sending quit to omxplayer
            # self.mon.log(self,"      State machine: " + self.play_state)
            if self.quit_signal is True:
                self.quit_signal = False
                self.mon.log(self, "      quit video - Send stop to omxdriver")
                self.omx.stop()
                self.tick_timer = self.canvas.after(50,
                                                    self.show_state_machine)

            # omxplayer reports it is terminating
            elif self.omx.end_play_signal is True:
                self.omx.end_play_signal = False
                self.mon.log(
                    self, "end play signal received with reason: " +
                    self.omx.end_play_reason + ' at: ' +
                    str(self.omx.video_position))
                # paused at end of track so return so calling prog can release the pause
                if self.omx.end_play_reason == 'pause_at_end':
                    self.frozen_at_end = True
                    if self.finished_callback is not None:
                        self.finished_callback('pause_at_end', 'pause at end')

                elif self.omx.end_play_reason == 'nice_day':
                    # no problem with omxplayer
                    self.play_state = 'closing'
                    self.closing_count = 0
                    self.mon.log(
                        self, "      Entering state : " + self.play_state +
                        ' from show Id: ' + str(self.show_id))
                    self.tick_timer = self.canvas.after(
                        50, self.show_state_machine)
                else:
                    # unexpected reason
                    self.mon.err(
                        self, 'unexpected reason at end of show ' +
                        self.omx.end_play_reason)
                    self.play_state = 'show-failed'
                    if self.finished_callback is not None:
                        self.finished_callback(
                            'error', 'unexpected reason at end of show: ' +
                            self.omx.end_play_reason)

            else:
                # nothing to do just try again
                # print 'showing - try again'
                self.tick_timer = self.canvas.after(50,
                                                    self.show_state_machine)

        elif self.play_state == 'closing':
            # wait for closing to complete
            self.mon.log(self, "      State machine: " + self.play_state)
            if self.omx.is_running() is False:
                # if spawned process has closed can change to closed state
                self.mon.log(self, "            <omx process is dead")
                self.play_state = 'closed'
                # print 'process dead going to closed'
                self.omx = None
                self.mon.log(
                    self, "      Entering state : " + self.play_state +
                    ' from show Id: ' + str(self.show_id))
                if self.closed_callback is not None:
                    self.closed_callback('normal', 'omxplayer closed')
            else:
                # process still running
                self.closing_count += 1
                # print 'closing - waiting for process to die',self.closing_count
                if self.closing_count > 10:
                    # deal with omxplayer not terminating at the end of a track
                    # self.mon.warn(self,self.track)
                    # self.mon.warn(self,"omxplayer failed to close at: " + str(self.omx.video_position))
                    self.mon.warn(
                        self,
                        'failed to close - omxplayer now being killed with SIGINT'
                    )
                    self.omx.kill()
                    # print 'closing - precess will not die so ita been killed with SIGINT'
                    self.play_state = 'closed'
                    self.omx = None
                    self.mon.log(
                        self, "      Entering state : " + self.play_state +
                        ' from show Id: ' + str(self.show_id))
                    if self.closed_callback is not None:
                        self.closed_callback('normal',
                                             'closed omxplayer after sigint')
                else:
                    self.tick_timer = self.canvas.after(
                        200, self.show_state_machine)

        elif self.play_state == 'closed':
            # needed because wait_for_end polls the state and does not use callback
            self.mon.log(self, "      State machine: " + self.play_state)
            self.tick_timer = self.canvas.after(200, self.show_state_machine)

        else:
            self.mon.err(
                self,
                'unknown state in show/close state machine ' + self.play_state)
            self.play_state = 'show-failed'
            if self.finished_callback is not None:
                self.finished_callback(
                    'error',
                    'show state machine in unknown state: ' + self.play_state)

    def parse_video_window(self, line, display_id):
        # model other than 4 video is rotated by hdmi_display_rotate in config.txt
        if self.dm.model_of_pi() == 4:
            rotation = self.dm.real_display_orientation(self.omx_display_id)
        else:
            rotation = 'normal'

        if rotation == 'normal':
            self.omx_rotate = ''
        elif rotation == 'right':
            self.omx_rotate = ' --orientation 90 '
        elif rotation == 'left':
            self.omx_rotate = ' --orientation 270 '
        else:
            #inverted
            self.omx_rotate = ' --orientation 180 '
        fields = line.split()
        # check there is a command field
        if len(fields) < 1:
            return 'error', 'no type field: ' + line, '', False, 0, 0, 0, 0

        # deal with types which have no paramters
        if fields[0] in ('original', 'letterbox', 'fill', 'default',
                         'stretch'):
            if len(fields) != 1:
                return 'error', 'number of fields for original: ' + line, '', False, 0, 0, 0, 0
            if fields[0] in ('letterbox', 'fill', 'stretch'):
                self.omx_aspect_mode = ' --aspect-mode ' + fields[0]
            else:
                self.omx_aspect_mode = ''
            return 'normal', '', fields[0], False, 0, 0, 0, 0

        # deal with warp which has 0 or 1 or 4 parameters (1 is x+y+w*h)
        # check basic syntax
        if fields[0] != 'warp':
            return 'error', 'not a valid type: ' + fields[
                0], '', False, 0, 0, 0, 0
        if len(fields) not in (1, 2, 5):
            return 'error', 'wrong number of coordinates for warp: ' + line, '', False, 0, 0, 0, 0

        # deal with window coordinates, just warp
        if len(fields) == 1:
            has_window = True
            x1 = self.show_canvas_x1
            y1 = self.show_canvas_y1
            x2 = self.show_canvas_x2
            y2 = self.show_canvas_y2
        else:
            # window is specified warp + dimesions etc.
            status, message, x1, y1, x2, y2 = parse_rectangle(' '.join(
                fields[1:]))
            if status == 'error':
                return 'error', message, '', False, 0, 0, 0, 0
            has_window = True
        x1_res, y1_res, x2_res, y2_res = self.transform_for_rotation(
            display_id, rotation, x1, y1, x2, y2)
        return 'normal', '', fields[
            0], has_window, x1_res, y1_res, x2_res, y2_res

    def transform_for_rotation(self, display_id, rotation, x1, y1, x2, y2):

        # adjust rotation of video for display rotation

        video_width = x2 - x1
        video_height = y2 - y1
        display_width, display_height = self.dm.real_display_dimensions(
            display_id)

        if rotation == 'right':
            x1_res = display_height - video_height - y1
            x2_res = display_height - y1

            y1_res = y1
            y2_res = video_width + y1

        elif rotation == 'normal':
            x1_res = x1
            y1_res = y1
            x2_res = x2
            y2_res = y2

        elif rotation == 'left':
            x1_res = y1
            x2_res = video_height + y1

            y1_res = display_width - video_width - x1
            y2_res = display_width - x1

        else:
            # inverted
            x2_res = display_width - x1
            x1_res = display_width - video_width - x1

            y2_res = display_height - y1
            y1_res = display_height - video_height - y1

        if VideoPlayer.debug:
            print('\nWarp calculation for Display Id', display_id, rotation)
            print('Video Window', x1, y1, x2, y2)
            print('video width/height', video_width, video_height)
            print('display width/height', display_width, display_height)
            print('Translated Window', x1_res, y1_res, x2_res, y2_res)
        return x1_res, y1_res, x2_res, y2_res
示例#2
0
class VLCPlayer(Player):
    """
    plays a track using VLCDriver to access VLC via libvlc
    _init_ iniitalises state and checks resources are available.
    use the returned instance reference in all other calls.
    At the end of the path (when closed) do not re-use, make instance= None and start again.
    States - 'initialised' when done successfully.
    """

    debug = False
    debug = True

    def __init__(self, show_id, showlist, root, canvas, show_params,
                 track_params, pp_dir, pp_home, pp_profile, end_callback,
                 command_callback):

        # initialise items common to all players
        Player.__init__(self, show_id, showlist, root, canvas, show_params,
                        track_params, pp_dir, pp_home, pp_profile,
                        end_callback, command_callback)
        self.mon.trace(self, '')

        self.dm = DisplayManager()
        self.am = AudioManager()

        # get player parameters from show/track
        if self.track_params['vlc-audio'] != "":
            self.vlc_audio = self.track_params['vlc-audio']
        else:
            self.vlc_audio = self.show_params['vlc-audio']

        if self.track_params['vlc-volume'] != "":
            self.vlc_volume_text = self.track_params['vlc-volume']
        else:
            self.vlc_volume_text = self.show_params['vlc-volume']

        if self.track_params['vlc-window'] != '':
            self.vlc_window_text = self.track_params['vlc-window']
        else:
            self.vlc_window_text = self.show_params['vlc-window']

        if self.track_params['vlc-aspect-mode'] != '':
            self.vlc_aspect_mode = self.track_params['vlc-aspect-mode']
        else:
            self.vlc_aspect_mode = self.show_params['vlc-aspect-mode']

        if self.track_params['vlc-image-duration'] != '':
            self.vlc_image_duration_text = self.track_params[
                'vlc-image-duration']
        else:
            self.vlc_image_duration_text = self.show_params[
                'vlc-image-duration']

        if self.track_params['vlc-other-options'] != '':
            self.vlc_other_options = self.track_params['vlc-other-options']
        else:
            self.vlc_other_options = self.show_params['vlc-other-options']

        if self.track_params['vlc-layer'] != '':
            self.vlc_layer_text = self.track_params['vlc-layer']
        else:
            self.vlc_layer_text = self.show_params['vlc-layer']

        if self.track_params['vlc-freeze-at-start'] != '':
            self.freeze_at_start_text = self.track_params[
                'vlc-freeze-at-start']
        else:
            self.freeze_at_start_text = self.show_params['vlc-freeze-at-start']

        if self.track_params['vlc-freeze-at-end'] != '':
            self.freeze_at_end_text = self.track_params['vlc-freeze-at-end']
        else:
            self.freeze_at_end_text = self.show_params['vlc-freeze-at-end']

        if self.track_params['pause-timeout'] != '':
            pause_timeout_text = self.track_params['pause-timeout']
        else:
            pause_timeout_text = self.show_params['pause-timeout']

        if pause_timeout_text.isdigit():
            self.pause_timeout = int(pause_timeout_text)
        else:
            self.pause_timeout = 0

        # track only

        self.vlc_subtitles = self.track_params['vlc-subtitles']

        self.vlc_max_volume_text = self.track_params['vlc-max-volume']

        self.vlc_aspect_ratio = self.track_params['vlc-aspect-ratio']

        self.vlc_crop = self.track_params['vlc-crop']

        # initialise video playing state and signals
        self.quit_signal = False
        self.unload_signal = False
        self.play_state = 'initialised'
        self.frozen_at_end = False
        self.pause_timer = None

    # LOAD - creates a VLC instance, loads a track and then pause
    def load(self, track, loaded_callback, enable_menu):
        # instantiate arguments
        self.track = track
        self.loaded_callback = loaded_callback  #callback when loaded
        self.mon.log(
            self, "Load track received from show Id: " + str(self.show_id) +
            ' ' + self.track)
        self.mon.trace(self, '')

        #process vlc parameters
        status, message = self.process_params()
        if status == 'error':
            self.mon.err(self, message)
            self.play_state = 'load-failed'
            if self.loaded_callback is not None:
                self.loaded_callback('error', message)
                return

        #for pulse get sink name and check device is connected
        self.audio_sys = self.am.get_audio_sys()
        if self.audio_sys == 'pulse':
            status, message, self.vlc_sink = self.am.get_sink(self.vlc_audio)
            if status == 'error':
                self.mon.err(self, message)
                self.play_state = 'load-failed'
                if self.loaded_callback is not None:
                    self.loaded_callback('error', message)
                    return

            if not self.am.sink_connected(self.vlc_sink):
                self.mon.err(
                    self, self.vlc_audio +
                    ' audio device not connected\n\n    sink: ' +
                    self.vlc_sink)
                self.play_state = 'load-failed'
                if self.loaded_callback is not None:
                    self.loaded_callback('error', 'audio device not connected')
                    return
        else:
            self.mon.err(
                self,
                'audio systems other than pulseaudio are not supported\n hint: audio.cfg error'
            )
            self.play_state = 'load-failed'
            if self.loaded_callback is not None:
                self.loaded_callback('error', 'audio device not connected')
                return

        # do common bits of  load
        Player.pre_load(self)

        # load the plugin, this may modify self.track and enable the plugin drawing to canvas
        if self.track_params['plugin'] != '':
            status, message = self.load_plugin()
            if status == 'error':
                self.mon.err(self, message)
                self.play_state = 'load-failed'
                if self.loaded_callback is not None:
                    self.loaded_callback('error', message)
                    return

        # load the images and text
        status, message = self.load_x_content(enable_menu)
        if status == 'error':
            self.mon.err(self, message)
            self.play_state = 'load-failed'
            if self.loaded_callback is not None:
                self.loaded_callback('error', message)
                return

        # check file exists if not a mrl
        if not ':' in track:
            if not os.path.exists(track):
                self.mon.err(self, "Track file not found: " + track)
                self.play_state = 'load-failed'
                if self.loaded_callback is not None:
                    self.loaded_callback('error',
                                         'track file not found: ' + track)
                    return

        cmd = 'DISPLAY= python3 ' + self.pp_dir + '/pp_vlcdriver.py'
        #print (cmd)
        # need bash because of DISPLAY=
        self.vlcdriver = pexpect.spawn('/bin/bash', ['-c', cmd],
                                       encoding='utf-8')

        # get rid of driver start message
        start_message = self.vlcdriver.readline().strip('\r\n')
        if start_message != 'VLCDriver starting':
            self.mon.fatal(
                self, "VLCDriver failed\n Hint: sudo pip3 install python-vlc ")
            self.play_state = 'load-failed'
            if self.loaded_callback is not None:
                self.loaded_callback('error', 'VLCDriver starting')
                return
        self.vlcdriver.setecho(False)

        self.vlcdriver.sendline('iopts' + self.iopts)
        self.vlcdriver.sendline('pauseopts' + self.pauseopts)
        self.vlcdriver.sendline('track ' + track)

        # load the media
        self.vlcdriver.sendline('load')

        #get size of media, do after load and before play. Not used at the moment
        self.media_width, self.media_height = self.get_size()

        # calculate and send crop/aspect ratio and aspect mode. Done here as size might be needed in the future
        status, message = self.aspect_mode()
        if status != 'normal':
            self.mon.err(self, message)
            self.play_state = 'load-failed'
            if self.loaded_callback is not None:
                self.loaded_callback('error', 'track file not found: ' + track)
                return

        # play until pause at start
        self.vlcdriver.sendline('play')
        self.start_state_machine_load()

    # SHOW - show a track
    def show(self, ready_callback, finished_callback, closed_callback):
        self.ready_callback = ready_callback  # callback when paused after load ready to show video
        self.finished_callback = finished_callback  # callback when finished showing
        self.closed_callback = closed_callback

        self.mon.trace(self, '')

        #  do animation at start and ready_callback
        Player.pre_show(self)

        # start show state machine
        self.start_state_machine_show()

    # UNLOAD - abort a load when vlcdriver is loading or loaded
    def unload(self):
        self.mon.trace(self, '')
        self.mon.log(self,
                     ">unload received from show Id: " + str(self.show_id))
        self.start_state_machine_unload()

    # CLOSE - quits vlcdriver from 'pause at end' state
    def close(self, closed_callback):
        self.mon.trace(self, '')
        self.mon.log(self,
                     ">close received from show Id: " + str(self.show_id))
        self.closed_callback = closed_callback
        self.start_state_machine_close()

    def get_size(self):
        self.vlcdriver.sendline('get-size')
        resp = self.vlcdriver.readline().strip('\r\n')
        resp_list = resp.split(' ')
        return resp_list[0], resp_list[1]

    def get_state(self):
        self.vlcdriver.sendline('t')
        resp = self.vlcdriver.readline().strip('\r\n')
        #print (resp)
        return resp

# ***********************
# track showing state machine
# **********************

    """
    STATES OF STATE MACHINE
    Threre are ongoing states and states that are set just before callback

    >init - Create an instance of the class
    <On return - state = initialised   -  - init has been completed, do not generate errors here

    >load
        Fatal errors should be detected in load. If so  loaded_callback is called with 'load-failed'
         Ongoing - state=loading - load called, waiting for load to complete   
    < loaded_callback with status = normal
         state=loaded - load has completed and video paused before or after first frame      
    <loaded_callback with status=error
        state= load-failed -  failure to load   

    On getting the loaded_callback with status=normal the track can be shown using show


    >show
        show assumes a track has been loaded and is paused.
       Ongoing - state=showing - video is showing 
    <finished_callback with status = pause_at_end
            state=showing but frozen_at_end is True
    <closed_callback with status= normal
            state = closed - video has ended vlc has terminated.


    On getting finished_callback with status=pause_at end a new track can be shown and then use close to close the previous video when new track is ready
    On getting closed_callback with status=  nice_day vlcdriver closing should not be attempted as it is already closed
    Do not generate user errors in Show. Only generate system errors such as illegal state and then use end()

    >close
       Ongoing state - closing - vlcdriver processes are dying
    <closed_callback with status= normal - vlcdriver is dead, can close the track instance.

    >unload
        Ongoing states - start_unload and unloading - vlcdriver processes are dying.
        when unloading is complete state=unloaded
        I have not added a callback to unload. its easy to add one if you want.

    closed is needed because wait_for_end in pp_show polls for closed and does not use closed_callback
    
    """
    def start_state_machine_load(self):
        # initialise all the state machine variables
        self.play_state = 'loading'
        #self.set_volume(self.volume)
        self.tick_timer = self.canvas.after(1, self.load_state_machine)  #50

    def load_state_machine(self):
        if self.unload_signal is True:
            self.unload_signal = False
            self.state = 'unloading'
            self.vlcdriver.sendline('unload')
            self.root.after(100, self.load_state_machine)
        else:
            resp = self.get_state()
            # pp_vlcdriver changes state from load-loading when track is frozen at start.
            if resp == 'load-fail':
                self.play_state = 'load-failed'
                self.mon.log(
                    self, "      Entering state : " + self.play_state +
                    ' from show Id: ' + str(self.show_id))
                if self.loaded_callback is not None:
                    self.loaded_callback('error',
                                         'timeout when loading vlc track')
                return
            elif resp == 'load-unloaded':
                self.play_state = 'unloaded'
                self.mon.log(
                    self, "      Entering state : " + self.play_state +
                    ' from show Id: ' + str(self.show_id))
                # PP does not need this callback
                #if self.loaded_callback is not  None:
                #self.loaded_callback('normal','unloaded')
                return
            elif resp in ('load-ok', 'stop-frozen'):
                # stop received while in freeze-at-start - quit showing as soon as it starts
                if resp == 'stop-frozen':
                    self.quit_signal = True
                    self.mon.log(self,
                                 'stop received while in freeze-at-start')
                self.play_state = 'loaded'
                if self.vlc_sink != '':
                    self.set_device(self.vlc_sink)
                else:
                    self.set_device('')
                self.set_volume(self.volume)
                self.mon.log(
                    self, "      Entering state : " + self.play_state +
                    ' from show Id: ' + str(self.show_id))
                if self.loaded_callback is not None:
                    self.loaded_callback('normal', 'loaded')
                return
            else:
                self.root.after(10, self.load_state_machine)  #100

    def start_state_machine_unload(self):
        # print ('videoplayer - starting unload',self.play_state)
        if self.play_state in ('closed', 'initialised', 'unloaded'):
            # vlcdriver already closed
            self.play_state = 'unloaded'
            # print ' closed so no need to unload'
        else:
            if self.play_state == 'loaded':
                # load already complete so set unload signal and kick off load state machine
                self.play_state = 'start_unload'
                self.unload_signal = True
                self.tick_timer = self.canvas.after(50,
                                                    self.load_state_machine)

            elif self.play_state == 'loading':
                # signal load state machine to start_unloading state and stop vlcdriver
                self.unload_signal = True
            else:
                self.mon.err(
                    self, 'illegal state in unload method: ' + self.play_state)
                self.end('error',
                         'illegal state in unload method: ' + self.play_state)

    def start_state_machine_show(self):
        if self.play_state == 'loaded':
            # print '\nstart show state machine ' + self.play_state
            self.play_state = 'showing'
            self.freeze_signal = False  # signal that user has pressed stop
            self.must_quit_signal = False
            # show the track and content
            self.vlcdriver.sendline('show')
            self.mon.log(self,
                         '>showing track from show Id: ' + str(self.show_id))
            self.set_volume(self.volume)
            # and start polling for state changes
            # print 'start show state machine show'
            self.tick_timer = self.canvas.after(0, self.show_state_machine)
            """
            # race condition don't start state machine as unload in progress
            elif self.play_state == 'start_unload':
                pass
            """
        else:
            self.mon.fatal(self,
                           'illegal state in show method ' + self.play_state)
            self.play_state = 'show-failed'
            if self.finished_callback is not None:
                self.finished_callback(
                    'error',
                    'illegal state in show method: ' + self.play_state)

    def show_state_machine(self):
        if self.play_state == 'showing':
            if self.quit_signal is True:
                # service any queued stop signals by sending stop to vlcdriver
                self.quit_signal = False
                self.mon.log(self, "      stop video - Send stop to vlcdriver")
                self.vlcdriver.sendline('stop')
                self.tick_timer = self.canvas.after(10,
                                                    self.show_state_machine)
            else:
                resp = self.get_state()
                #print (resp)
                # driver changes state from show-showing depending on freeze-at-end.
                if resp == 'show-pauseatend':
                    self.mon.log(self, 'vlcdriver says pause_at_end')
                    self.frozen_at_end = True
                    if self.finished_callback is not None:
                        self.finished_callback('pause_at_end', 'pause at end')

                elif resp == 'show-niceday':
                    self.mon.log(self, 'vlcdriver says nice_day')
                    self.play_state = 'closing'
                    self.vlcdriver.sendline('close')
                    # and terminate the vlcdriver process through pexpect
                    self.vlcdriver.terminate()
                    self.tick_timer = self.canvas.after(
                        10, self.show_state_machine)

                elif resp == 'show-fail':
                    self.play_state = 'show-failed'
                    if self.finished_callback is not None:
                        self.finished_callback(
                            'error', 'pp_vlcdriver says show failed: ' +
                            self.play_state)
                else:
                    self.tick_timer = self.canvas.after(
                        30, self.show_state_machine)

        elif self.play_state == 'closing':
            # close the pexpect process
            self.vlcdriver.close()
            self.play_state = 'closed'
            # state change needed for wait for end
            self.mon.log(
                self, "      Entering state : " + self.play_state +
                ' from show Id: ' + str(self.show_id))
            if self.closed_callback is not None:
                self.closed_callback('normal', 'vlcdriver closed')

    # respond to normal stop
    def stop(self):
        self.mon.log(self, ">stop received from show Id: " + str(self.show_id))
        # cancel the pause timer
        if self.pause_timer != None:
            self.canvas.after_cancel(self.pause_timer)
            self.pause_timer = None
        self.vlcdriver.sendline('stop')

    def start_state_machine_close(self):
        # self.mon.log(self,">close received from show Id: "+ str(self.show_id))
        # cancel the pause timer
        if self.pause_timer != None:
            self.canvas.after_cancel(self.pause_timer)
            self.pause_timer = None
        self.vlcdriver.sendline('close')
        self.play_state = 'closing'
        #print ('start close state machine close')
        self.tick_timer = self.canvas.after(0, self.show_state_machine)

# ************************
# COMMANDS
# ************************

    def input_pressed(self, symbol):
        if symbol == 'inc-volume':
            self.inc_volume()
        elif symbol == 'dec-volume':
            self.dec_volume()
        elif symbol == 'pause':
            self.pause()
        elif symbol == 'go':
            self.go()
        elif symbol == 'unmute':
            self.unmute()
        elif symbol == 'mute':
            self.mute()
        elif symbol == 'pause-on':
            self.pause_on()
        elif symbol == 'pause-off':
            self.pause_off()
        elif symbol == 'stop':
            self.stop()

    def inc_volume(self):
        self.mon.log(self,
                     ">inc-volume received from show Id: " + str(self.show_id))
        if self.play_state == 'showing':
            if self.volume < self.max_volume:
                self.volume += 1
            self.set_volume(self.volume)
            return True
        else:
            self.mon.log(self, "!<inc-volume rejected " + self.play_state)
            return False

    def dec_volume(self):
        self.mon.log(self,
                     ">dec-volume received from show Id: " + str(self.show_id))

        if self.play_state == 'showing':
            if self.volume > 0:
                self.volume -= 1
            self.set_volume(self.volume)
            return True
        else:
            self.mon.log(self, "!<dec-volume rejected " + self.play_state)
            return False

    def set_volume(self, vol):
        # print ('SET VOLUME',vol)
        self.vlcdriver.sendline('vol ' + str(vol))

    def set_device(self, device):
        self.vlcdriver.sendline('device ' + device)

    def mute(self):
        self.mon.log(self, ">mute received from show Id: " + str(self.show_id))
        self.vlcdriver.sendline('mute')
        return True

    def unmute(self):
        self.mon.log(self,
                     ">unmute received from show Id: " + str(self.show_id))
        self.vlcdriver.sendline('unmute')

    # toggle pause
    def pause(self):
        self.mon.log(
            self, ">toggle pause received from show Id: " + str(self.show_id))
        self.vlcdriver.sendline('pause')
        reply = self.vlcdriver.readline().strip('\r\n')
        if reply == 'pause-on-ok':
            if self.pause_timeout > 0:
                # kick off the pause timeout timer
                self.pause_timer = self.canvas.after(
                    self.pause_timeout * 1000, self.pause_timeout_callback)
            return True
        elif reply == 'pause-off-ok':
            if self.pause_timer != None:
                # cancel the pause timer
                self.canvas.after_cancel(self.pause_timer)
                self.pause_timer = None
            return True
        else:
            self.mon.log(self, "!<toggle pause rejected " + self.play_state)
            return False

    def pause_timeout_callback(self):
        self.pause_off()
        self.pause_timer = None

    # pause on
    def pause_on(self):
        self.mon.log(self,
                     ">pause on received from show Id: " + str(self.show_id))
        self.vlcdriver.sendline('pause-on')
        reply = self.vlcdriver.readline().strip('\r\n')
        if reply == 'pause-on-ok':
            if self.pause_timeout > 0:
                # kick off the pause timeout timer
                self.pause_timer = self.canvas.after(
                    self.pause_timeout * 1000, self.pause_timeout_callback)
            return True
        else:
            self.mon.log(self, "!<pause on rejected " + self.play_state)
            return False

    # pause off
    def pause_off(self):
        self.mon.log(self,
                     ">pause off received from show Id: " + str(self.show_id))
        self.vlcdriver.sendline('pause-off')
        reply = self.vlcdriver.readline().strip('\r\n')
        if reply == 'pause-off-ok':
            if self.pause_timer != None:
                # cancel the pause timer
                self.canvas.after_cancel(self.pause_timer)
                self.pause_timer = None
            return True
        else:
            self.mon.log(self, "!<pause off rejected " + self.play_state)
            return False

    # go after freeze at start
    def go(self):
        self.vlcdriver.sendline('go')
        reply = self.vlcdriver.readline().strip('\r\n')
        if reply == 'go-ok':
            return True
        else:
            self.mon.log(self, "!<go rejected " + self.play_state)
            return False


# *****************************
# SETUP
# *****************************

    def process_params(self):

        # volume will be set during show by set_volume()
        # --------------------------------------
        if self.vlc_max_volume_text != "":
            if not self.vlc_max_volume_text.isdigit():
                return 'error', 'VLC Max Volume must be a positive integer: ' + self.vlc_max_volume_text
            self.max_volume = int(self.vlc_max_volume_text)
            if self.max_volume > 100:
                return 'error', 'VLC Max Volume must be <= 100: ' + self.vlc_max_volume_text
        else:
            self.max_volume = 100

        if self.vlc_volume_text != "":
            if not self.vlc_volume_text.isdigit():
                return 'error', 'VLC Volume must be a positive integer: ' + self.vlc_volume_text
            self.volume = int(self.vlc_volume_text)
            if self.volume > 100:
                return 'error', 'VLC Volume must be <= 100: ' + self.vlc_max_volume_text
        else:
            self.volume = 100

        self.volume = min(self.volume, self.max_volume)

        # instance options
        # ----------------

        #audio system - pulseaudio
        audio_opt = '--aout=pulse '

        # other options
        if self.vlc_other_options != '':
            other_opts = self.vlc_other_options + ' '
        else:
            other_opts = ''

        # subtitles
        if self.vlc_subtitles != 'yes':
            subtitle_opt = '--no-spu '
        else:
            subtitle_opt = ''

        # display
        # -------
        # start with board name
        if self.track_params['display-name'] != "":
            video_display_name = self.track_params['display-name']
        else:
            video_display_name = self.show_canvas_display_name
        # Is it valid and connected
        status, message, self.display_id = self.dm.id_of_display(
            video_display_name)
        if status == 'error':
            return 'error', message

        #convert to task bar names for vlc
        vlc_display_name = self.dm.vlc_display_name_map[video_display_name]

        display_opt = '--mmal-display=' + vlc_display_name + ' '
        # does it do DSI-1????

        # layer
        # ******
        if self.vlc_layer_text == '':
            layer_opt = ''
        elif self.vlc_layer_text == 'hidden':
            layer_opt = '--mmal-layer=-128 '
        else:
            if not self.vlc_layer_text.isdigit():
                return 'error', 'Display Layer is not a positive number: ' + self.vlc_layer_text
            layer_opt = '--mmal-layer=' + self.vlc_layer_text + ' '

        # image duration
        # **************
        if not self.vlc_image_duration_text.isdigit():
            return 'error', 'Image Duration is not a positive number: ' + self.vlc_image_duration_text
        if int(self.vlc_image_duration_text) == 0:
            image_duration_opt = '--image-duration -1 '
        else:
            image_duration_opt = '--image-duration ' + self.vlc_image_duration_text + ' '

        # video window
        # ************
        # parse video window and mangle wxh+x+y string for aspect_mode
        status, message, window_text = self.parse_vlc_video_window(
            self.vlc_window_text)
        if status == 'error':
            return 'error', message

        if window_text != '':
            window_opt = '--mmal-vout-window ' + window_text + ' '
        else:
            window_opt = ''

        # transformation
        # ***************
        # model other than 4 video is rotated by hdmi_display_rotate in config.txt
        if self.dm.model_of_pi() == 4:
            rotation = self.dm.real_display_orientation(self.display_id)
        else:
            rotation = 'normal'

        if rotation == 'normal':
            transform_opt = ' --mmal-vout-transform=0 '
        elif rotation == 'right':
            transform_opt = ' --mmal-vout-transform=90 '
        elif rotation == 'left':
            transform_opt = ' --mmal-vout-transform=270 '
        else:
            #inverted
            transform_opt = ' --mmal-vout-transform=180 '

        self.iopts = ' ' + window_opt + layer_opt + display_opt + transform_opt + subtitle_opt + audio_opt + image_duration_opt + other_opts

        # pause options
        #---------------

        if self.freeze_at_end_text == 'yes':
            self.freeze_at_end_required = True
        else:
            self.freeze_at_end_required = False

        freeze_start_opt = ' ' + self.freeze_at_start_text
        freeze_end_opt = ' ' + self.freeze_at_end_text

        self.pauseopts = freeze_start_opt + freeze_end_opt

        return 'normal', ''

    def aspect_mode(self):
        """
        In omxplayer Video Window has parameters only for warp, all other modes are centred the full screen

        In vlcplayer there are two fields, VLC Window and Aspect Mode. VLC Window position and sizes the window then
        Aspect Mode is applied to all results of VLC Window :
        
        stretch - transform video to make it fill the window with aspect ratio the same as the window

        fill - crop the video so that it fills the window while retaining the video's aspect ratio

        letterbox - vlc's default mode
                        adjust the video  so that whole video is seen in the window while keeping the video's aspect ratio
                        If the window's aspect ratio does not match that of the video media then the x,y, position will be incorrect,
                        (except on fullscreen). This is because the result is centred in the window.


        vlc - use vlc's aspect ratio and crop in the defined window
            Cannot use both crop and aspect ratio
            window size w*h needs to have the same ratio as the result of crop or aspect-ratio otherwise the displayed position will be incorrect
            values must be integers e.g 5.1:1 does not work 
            crop formats:    <aspect_num>:<aspect_den> e.g.4:3
                            <width>x<height>+<x>+<y>
                            <left>+<top>+<right>+<bottom>
            aspect ratio formats: <aspect_num>:<aspect_den> e.g.4:3
        """
        if self.vlc_aspect_mode == 'stretch':
            window_ratio = self.vlc_window_width / self.vlc_window_height
            self.vlcdriver.sendline('ratio ' + str(self.vlc_window_width) +
                                    ':' + str(self.vlc_window_height))
            return 'normal', ''

        elif self.vlc_aspect_mode == 'fill':
            self.vlcdriver.sendline('crop ' + str(self.vlc_window_width) +
                                    ':' + str(self.vlc_window_height))
            return 'normal', ''

        elif self.vlc_aspect_mode == 'letterbox':
            # default vlc behavior
            return 'normal', ''

        elif self.vlc_aspect_mode == 'vlc':
            if self.vlc_aspect_ratio != '' or self.vlc_crop != '':
                if self.vlc_crop != '':
                    self.vlcdriver.sendline('crop ' + self.vlc_crop)

                if self.vlc_aspect_ratio != '':
                    self.vlcdriver.sendline('ratio ' + self.vlc_aspect_ratio)
                return 'normal', ''
            else:
                return 'error', 'crop or aspect mode not specified for vlc option'
        else:
            return 'error', 'Aspect Mode cannot be blank ' + self.vlc_aspect_mode

    def parse_vlc_video_window(self, line):
        words = line.split()
        if len(words) not in (1, 2):
            return 'error', 'bad vlc video window form ' + line, ''

        if words[0] not in ('display', 'showcanvas'):
            return 'error', 'Bad VLC Window option: ' + line, ''

        if words[0] == 'display':
            x_org = 0
            y_org = 0
            width, height = self.dm.canvas_dimensions(self.display_id)

        if words[0] == 'showcanvas':
            x_org = self.show_canvas_x1
            y_org = self.show_canvas_y1
            width = self.show_canvas_width
            height = self.show_canvas_height

        #replace canvas/display height/width from spec
        x_offset = 0
        y_offset = 0
        if len(words) == 2:
            #pass in canvas/display width/height. Returns window width/height
            status, message, x_offset, y_offset, width, height = self.parse_dimensions(
                words[1], width, height)
            if status == 'error':
                return 'error', message, ''

        x = x_org + x_offset
        y = y_org + y_offset
        self.vlc_window_x = x
        self.vlc_window_y = y
        self.vlc_window_width = width
        self.vlc_window_height = height
        vlc_text = str(width) + 'x' + str(height) + '+' + str(x) + '+' + str(y)
        return 'normal', '', vlc_text

    def parse_dimensions(self, dim_text, show_width, show_height):
        # parse x+y+width*height or width*height
        if '+' in dim_text:
            # x+y+width*height
            fields = dim_text.split('+')
            if len(fields) != 3:
                return 'error', 'bad vlc video window form ' + dim_text, 0, 0, 0, 0

            if not fields[0].isdigit():
                return 'error', 'x value is not a positive decimal in vlc video window ' + dim_text, 0, 0, 0, 0
            else:
                x = int(fields[0])

            if not fields[1].isdigit():
                return 'error', 'y value is not a positive decimal in vlc video window ' + dim_text, 0, 0, 0, 0
            else:
                y = int(fields[1])

            dimensions = fields[2].split('*')
            if len(dimensions) != 2:
                return 'error', 'bad vlc video window dimensions ' + dim_text, 0, 0, 0, 0

            if not dimensions[0].isdigit():
                return 'error', 'width is not a positive decimal in vlc video window ' + dim_text, 0, 0, 0, 0
            else:
                width = int(dimensions[0])

            if not dimensions[1].isdigit():
                return 'error', 'height is not a positive decimal in vlc video window ' + dim_text, 0, 0, 0, 0
            else:
                height = int(dimensions[1])

            return 'normal', '', x, y, width, height
        else:
            dimensions = dim_text.split('*')
            if len(dimensions) != 2:
                return 'error', 'bad vlc video window dimensions ' + dim_text, 0, 0, 0, 0

            if not dimensions[0].isdigit():
                return 'error', 'width is not a positive decimal in vlc video window ' + dim_text, 0, 0, 0, 0
            else:
                window_width = int(dimensions[0])

            if not dimensions[1].isdigit():
                return 'error', 'height is not a positive decimal in vlc video window ' + dim_text, 0, 0, 0, 0
            else:
                window_height = int(dimensions[1])

            x = int((show_width - window_width) / 2)
            y = int((show_height - window_height) / 2)
            return 'normal', '', x, y, window_width, window_height