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
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