class VideoPlayer:
_CLOSED = "omx_closed" #probably will not exist
_STARTING = "omx_starting" #track is being prepared
_PLAYING = "omx_playing" #track is playing to the screen, may be paused
_ENDING = "omx_ending" #track is in the process of ending due to quit or end of track
# ***************************************
# EXTERNAL COMMANDS
# ***************************************
def __init__(self,
canvas,
cd,
track_params ):
"""
canvas - the canvas onto which the video is to be drawn (not!!)
cd - configuration dictionary
track_params - config dictionary for this track overides cd
"""
self.mon=Monitor()
self.mon.on()
#instantiate arguments
self.cd=cd #configuration dictionary for the videoplayer
self.canvas = canvas #canvas onto which video should be played but isn't! Use as widget for alarm
self.track_params=track_params
# get config from medialist if there.
if 'omx-audio' in self.track_params and self.track_params['omx-audio']<>"":
self.omx_audio= self.track_params['omx-audio']
else:
self.omx_audio= self.cd['omx-audio']
if self.omx_audio<>"": self.omx_audio= "-o "+ self.omx_audio
# could put instance generation in play, not sure which is better.
self.omx=OMXDriver()
self._tick_timer=None
self.error=False
self.terminate_required=False
self._init_play_state_machine()
def play(self, track,
end_callback,
ready_callback,
enable_menu=False,
starting_callback=None,
playing_callback=None,
ending_callback=None):
#instantiate arguments
self.ready_callback=ready_callback #callback when ready to play
self.end_callback=end_callback # callback when finished
self.starting_callback=starting_callback #callback during starting state
self.playing_callback=playing_callback #callback during playing state
self.ending_callback=ending_callback # callback during ending state
# enable_menu is not used by videoplayer
# and start playing the video.
if self.play_state == VideoPlayer._CLOSED:
self.mon.log(self,">play track received")
self._start_play_state_machine(track)
return True
else:
self.mon.log(self,"!< play track rejected")
return False
def key_pressed(self,key_name):
if key_name=='':
return
elif key_name in ('p',' '):
self._pause()
return
elif key_name=='escape':
self._stop()
return
def button_pressed(self,button,edge):
if button =='pause':
self._pause()
return
elif button=='stop':
self._stop()
return
def terminate(self,reason):
# circumvents state machine
self.terminate_required=True
if self.omx<>None:
self.mon.log(self,"sent terminate to omxdriver")
self.omx.terminate(reason)
else:
self.mon.log(self,"terminate, omxdriver not running")
self._end()
# ***************************************
# INTERNAL FUNCTIONS
# ***************************************
# respond to normal stop
def _stop(self):
# send signal to stop the track to the state machine
self.mon.log(self,">stop received")
self._stop_required_signal=True
#respond to internal error
def _error(self):
self.error=True
self._stop_required_signal=True
#toggle pause
def _pause(self):
if self.play_state in (VideoPlayer._PLAYING,VideoPlayer._ENDING):
self.omx.pause()
return True
else:
self.mon.log(self,"!<pause rejected")
return False
# other control when playing, used?
def _control(self,char):
if self.play_state==VideoPlayer._PLAYING:
self.mon.log(self,"> send control ot omx: "+ char)
self.omx.control(char)
return True
else:
self.mon.log(self,"!<control rejected")
return False
# called to end omxdriver
def _end(self):
if self._tick_timer<>None:
self.canvas.after_cancel(self._tick_timer)
self._tick_timer=None
if self.error==True:
self.end_callback("error",'error')
self=None
elif self.terminate_required==True:
self.end_callback("killed",'killed')
self=None
else:
self.end_callback('normal',"track has terminated")
self=None
# ***************************************
# # PLAYING STATE MACHINE
# ***************************************
"""self. play_state controls the playing sequence, it has the following values.
I am not entirely sure the starting and ending states are required.
- _closed - the omx process is not running, omx process can be initiated
- _starting - omx process is running but is not yet able to receive controls
- _playing - playing a track, controls can be sent
- _ending - omx is doing its termination, controls cannot be sent
"""
def _init_play_state_machine(self):
self._stop_required_signal=False
self.play_state=VideoPlayer._CLOSED
def _start_play_state_machine(self,track):
#initialise all the state machine variables
#self.iteration = 0 # for debugging
self._stop_required_signal=False # signal that user has pressed stop
self.play_state=VideoPlayer._STARTING
#play the selected track
options=self.omx_audio+" "+self.cd['omx-other-options']+" "
self.omx.play(track,options)
# and start polling for state changes
self._tick_timer=self.canvas.after(50, self._play_state_machine)
def _play_state_machine(self):
if self.play_state == VideoPlayer._CLOSED:
self.mon.log(self," State machine: " + self.play_state)
return
elif self.play_state == VideoPlayer._STARTING:
self.mon.log(self," State machine: " + self.play_state)
# if omxplayer is playing the track change to play state
if self.omx.start_play_signal==True:
self.mon.log(self," <start play signal received from omx")
self.omx.start_play_signal=False
# callback to the calling object to e.g remove egg timer.
if self.ready_callback<>None:
self.ready_callback()
self.play_state=VideoPlayer._PLAYING
self.mon.log(self," State machine: omx_playing started")
self._do_starting()
self._tick_timer=self.canvas.after(50, self._play_state_machine)
elif self.play_state == VideoPlayer._PLAYING:
# self.mon.log(self," State machine: " + self.play_state)
# service any queued stop signals
if self._stop_required_signal==True:
self.mon.log(self," Service stop required signal")
self._stop_omx()
self._stop_required_signal=False
self.play_state = VideoPlayer._ENDING
# omxplayer reports it is terminating so change to ending state
if self.omx.end_play_signal:
self.mon.log(self," <end play signal received")
self.mon.log(self," <end detected at: " + str(self.omx.video_position))
self.play_state = VideoPlayer._ENDING
self._do_playing()
self._tick_timer=self.canvas.after(200, self._play_state_machine)
elif self.play_state == VideoPlayer._ENDING:
self.mon.log(self," State machine: " + self.play_state)
self._do_ending()
# if spawned process has closed can change to closed state
self.mon.log (self," State machine : is omx process running? - " + str(self.omx.is_running()))
if self.omx.is_running() ==False:
self.mon.log(self," <omx process is dead")
self.play_state = VideoPlayer._CLOSED
self._end()
else:
self._tick_timer=self.canvas.after(200, self._play_state_machine)
# allow calling object do things in each state by calling the appropriate callback
def _do_playing(self):
self.video_position=self.omx.video_position
self.audio_position=self.omx.audio_position
if self.playing_callback<>None:
self.playing_callback()
def _do_starting(self):
self.video_position=0.0
self.audio_position=0.0
if self.starting_callback<>None:
self.starting_callback()
def _do_ending(self):
if self.ending_callback<>None:
self.ending_callback()
def _stop_omx(self):
# send signal to stop the track to the state machine
self.mon.log(self," >stop omx received from state machine")
if self.play_state==VideoPlayer._PLAYING:
self.omx.stop()
return True
else:
self.mon.log(self,"!<stop rejected")
return False
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 VideoPlayer:
""" plays a track using omxplayer
See pp_imageplayer for common software design description
"""
_CLOSED = "omx_closed" #probably will not exist
_STARTING = "omx_starting" #track is being prepared
_PLAYING = "omx_playing" #track is playing to the screen, may be paused
_ENDING = "omx_ending" #track is in the process of ending due to quit or end of track
# ***************************************
# EXTERNAL COMMANDS
# ***************************************
def __init__(self,
show_id,
root,
canvas,
show_params,
track_params ,
pp_dir,
pp_home,
pp_profile):
self.mon=Monitor()
self.mon.on()
#instantiate arguments
self.show_id=show_id
self.root=root
self.canvas = canvas
self.show_params=show_params
self.track_params=track_params
self.pp_dir=pp_dir
self.pp_home=pp_home
self.pp_profile=pp_profile
# get config from medialist if there.
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
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= "--vol "+ str(int(self.omx_volume)*100) + ' '
if self.track_params['omx-window']<>'':
self.omx_window= self.track_params['omx-window']
else:
self.omx_window= self.show_params['omx-window']
# get background image from profile.
self.background_file=''
if self.track_params['background-image']<>"":
self.background_file= self.track_params['background-image']
else:
if self.track_params['display-show-background']=='yes':
self.background_file= self.show_params['background-image']
# get background colour from profile.
if self.track_params['background-colour']<>"":
self.background_colour= self.track_params['background-colour']
else:
self.background_colour= self.show_params['background-colour']
self.centre_x = int(self.canvas['width'])/2
self.centre_y = int(self.canvas['height'])/2
#get animation instructions from profile
self.animate_begin_text=self.track_params['animate-begin']
self.animate_end_text=self.track_params['animate-end']
# open the plugin Manager
self.pim=PluginManager(self.show_id,self.root,self.canvas,self.show_params,self.track_params,self.pp_dir,self.pp_home,self.pp_profile)
#create an instance of PPIO so we can create gpio events
self.ppio = PPIO()
# could put instance generation in play, not sure which is better.
self.omx=OMXDriver(self.canvas)
self.tick_timer=None
self.init_play_state_machine()
def play(self, track,
showlist,
end_callback,
ready_callback,
enable_menu=False):
#instantiate arguments
self.track=track
self.showlist=showlist
self.ready_callback=ready_callback #callback when ready to play
self.end_callback=end_callback # callback when finished
self.enable_menu = enable_menu
# callback to the calling object to e.g remove egg timer and enable click areas.
if self.ready_callback<>None:
self.ready_callback()
# create an instance of showmanager so we can control concurrent shows
self.show_manager=ShowManager(self.show_id,self.showlist,self.show_params,self.root,self.canvas,self.pp_dir,self.pp_profile,self.pp_home)
#set up video window
reason,message,comand,has_window,x1,y1,x2,y2= self.parse_window(self.omx_window)
if reason =='error':
self.mon.err(self,'omx window error: ' + message + ' in ' + self.omx_window)
self.end_callback(reason,message)
else:
if has_window==True:
self.omx_window= '--win " '+ str(x1) + ' ' + str(y1) + ' ' + str(x2) + ' ' + str(y2) + ' " '
else:
self.omx_window=''
# Control other shows at beginning
reason,message=self.show_manager.show_control(self.track_params['show-control-begin'])
if reason in ('error','killed'):
self.end_callback(reason,message)
self=None
else:
#display content
reason,message=self.display_content()
if reason == 'error':
self.mon.err(self,message)
self.end_callback(reason,message)
self=None
else:
# create animation events
reason,message=self.ppio.animate(self.animate_begin_text,id(self))
if reason=='error':
self.mon.err(self,message)
self.end_callback(reason,message)
self=None
else:
# start playing the video.
if self.play_state == VideoPlayer._CLOSED:
self.mon.log(self,">play track received")
self.start_play_state_machine(self.track)
else:
self.mon.err(self,'play track rejected')
self.end_callback('error','play track rejected')
self=None
def terminate(self,reason):
# circumvents state machine and does not wait for omxplayer to close
if self.omx<>None:
self.mon.log(self,"sent terminate to omxdriver")
self.omx.terminate(reason)
self.end('killed',' end without waiting for omxplayer to finish') # end without waiting
else:
self.mon.log(self,"terminate, omxdriver not running")
self.end('killed','terminate, mplayerdriver not running')
def input_pressed(self,symbol):
if symbol[0:4]=='omx-':
self.control(symbol[4])
elif symbol =='pause':
self.pause()
elif symbol=='stop':
self.stop()
else:
pass
def get_links(self):
return self.track_params['links']
# ***************************************
# INTERNAL FUNCTIONS
# ***************************************
# respond to normal stop
def stop(self):
# send signal to stop the track to the state machine
self.mon.log(self,">stop received")
self.quit_signal=True
#toggle pause
def pause(self):
if self.play_state in (VideoPlayer._PLAYING,VideoPlayer._ENDING):
self.omx.pause()
return True
else:
self.mon.log(self,"!<pause rejected")
return False
# other control when playing
def control(self,char):
if self.play_state==VideoPlayer._PLAYING 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
# ***********************
# sequencing
# **********************
"""self. play_state controls the playing sequence, it has the following values.
I am not entirely sure the starting and ending states are required.
- _closed - the omx process is not running, omx process can be initiated
- _starting - omx process is running but is not yet able to receive controls
- _playing - playing a track, controls can be sent
- _ending - omx is doing its termination, controls cannot be sent
"""
def init_play_state_machine(self):
self.quit_signal=False
self.play_state=VideoPlayer._CLOSED
def start_play_state_machine(self,track):
#initialise all the state machine variables
#self.iteration = 0 # for debugging
self.quit_signal=False # signal that user has pressed stop
self.play_state=VideoPlayer._STARTING
#play the selected track
options=self.omx_audio+ " " + self.omx_volume + ' ' + self.omx_window + ' ' + self.show_params['omx-other-options']+" "
self.omx.play(track,options)
self.mon.log (self,'Playing track from show Id: '+ str(self.show_id))
# and start polling for state changes
self.tick_timer=self.canvas.after(50, self.play_state_machine)
def play_state_machine(self):
if self.play_state == VideoPlayer._CLOSED:
self.mon.log(self," State machine: " + self.play_state)
return
elif self.play_state == VideoPlayer._STARTING:
self.mon.log(self," State machine: " + self.play_state)
# if omxplayer is playing the track change to play state
if self.omx.start_play_signal==True:
self.mon.log(self," <start play signal received from omx")
self.omx.start_play_signal=False
self.play_state=VideoPlayer._PLAYING
self.mon.log(self," State machine: omx_playing started")
self.tick_timer=self.canvas.after(50, self.play_state_machine)
elif self.play_state == VideoPlayer._PLAYING:
# self.mon.log(self," State machine: " + self.play_state)
# service any queued stop signals
if self.quit_signal==True:
self.mon.log(self," Service stop required signal")
self.stop_omx()
self.quit_signal=False
# self.play_state = VideoPlayer._ENDING
# omxplayer reports it is terminating so change to ending state
if self.omx.end_play_signal:
self.mon.log(self," <end play signal received")
self.mon.log(self," <end detected at: " + str(self.omx.video_position))
if self.omx.end_play_reason<>'nice_day':
# deal with omxplayer not sending 'have a nice day'
self.mon.warn(self," <end detected at: " + str(self.omx.video_position))
self.mon.warn(self," <pexpect reports: "+self.omx.end_play_reason)
self.mon.warn(self,'pexpect.before is'+self.omx.xbefore)
self.play_state = VideoPlayer._ENDING
self.ending_count=0
self.tick_timer=self.canvas.after(200, self.play_state_machine)
elif self.play_state == VideoPlayer._ENDING:
self.mon.log(self," State machine: " + self.play_state)
# if spawned process has closed can change to closed state
self.mon.log (self," State machine : is omx process running? - " + str(self.omx.is_running()))
if self.omx.is_running() ==False:
self.mon.log(self," <omx process is dead")
self.play_state = VideoPlayer._CLOSED
self.end('normal','quit by user or system')
else:
self.ending_count+=1
if self.ending_count>10:
# deal with omxplayer not terminating at the end of a track
self.mon.warn(self," <omxplayer failed to close at: " + str(self.omx.video_position))
self.mon.warn(self,'pexpect.before is'+self.omx.xbefore)
self.omx.kill()
self.mon.warn(self,'omxplayer now terminated ')
self.play_state = VideoPlayer._CLOSED
self.end('normal','end from omxplayer failed to terminate')
else:
self.tick_timer=self.canvas.after(200, self.play_state_machine)
def stop_omx(self):
# send signal to stop the track to the state machine
self.mon.log(self," >stop omx received from state machine")
if self.play_state==VideoPlayer._PLAYING:
self.omx.stop()
return True
else:
self.mon.log(self,"!<stop rejected")
return False
# *****************
# ending the player
# *****************
def end(self,reason,message):
# stop the plugin
if self.track_params['plugin']<>'':
self.pim.stop_plugin()
# os.system("xrefresh -display :0")
# abort the timer
if self.tick_timer<>None:
self.canvas.after_cancel(self.tick_timer)
self.tick_timer=None
if reason in ('error','killed'):
self.end_callback(reason,message)
self=None
else:
# normal end so do show control and animation
# Control concurrent shows at end
reason,message=self.show_manager.show_control(self.track_params['show-control-end'])
if reason =='error':
self.mon.err(self,message)
self.end_callback(reason,message)
self=None
else:
# clear events list for this track
if self.track_params['animate-clear']=='yes':
self.ppio.clear_events_list(id(self))
# create animation events for ending
reason,message=self.ppio.animate(self.animate_begin_text,id(self))
if reason=='error':
self.mon.err(self,message)
self.end_callback(reason,message)
self=None
else:
self.end_callback('normal',"track has terminated or quit")
self=None
# *****************
# displaying things
# *****************
def display_content(self):
#background colour
if self.background_colour<>'':
self.canvas.config(bg=self.background_colour)
# delete previous content
self.canvas.delete('pp-content')
# background image
if self.background_file<>'':
self.background_img_file = self.complete_path(self.background_file)
if not os.path.exists(self.background_img_file):
self.mon.err(self,"Video background file not found: "+ self.background_img_file)
self.end('error',"Video background file not found")
else:
pil_background_img=PIL.Image.open(self.background_img_file)
self.background = PIL.ImageTk.PhotoImage(pil_background_img)
self.drawn = self.canvas.create_image(int(self.canvas['width'])/2,
int(self.canvas['height'])/2,
image=self.background,
anchor=CENTER,
tag='pp-content')
# execute the plugin if required
if self.track_params['plugin']<>'':
reason,message,self.track = self.pim.do_plugin(self.track,self.track_params['plugin'],)
if reason <> 'normal':
return reason,message
# display show text if enabled
if self.show_params['show-text']<> '' and self.track_params['display-show-text']=='yes':
self.canvas.create_text(int(self.show_params['show-text-x']),int(self.show_params['show-text-y']),
anchor=NW,
text=self.show_params['show-text'],
fill=self.show_params['show-text-colour'],
font=self.show_params['show-text-font'],
tag='pp-content')
# display track text if enabled
if self.track_params['track-text']<> '':
self.canvas.create_text(int(self.track_params['track-text-x']),int(self.track_params['track-text-y']),
anchor=NW,
text=self.track_params['track-text'],
fill=self.track_params['track-text-colour'],
font=self.track_params['track-text-font'],
tag='pp-content')
# display instructions if enabled
if self.enable_menu== True:
self.canvas.create_text(int(self.show_params['hint-x']),
int(self.show_params['hint-y']),
text=self.show_params['hint-text'],
fill=self.show_params['hint-colour'],
font=self.show_params['hint-font'],
anchor=NW,
tag='pp-content')
self.canvas.tag_raise('pp-click-area')
self.canvas.update_idletasks( )
return 'normal',''
# ****************
# utilities
# *****************
def complete_path(self,track_file):
# complete path of the filename of the selected entry
if track_file[0]=="+":
track_file=self.pp_home+track_file[1:]
self.mon.log(self,"Background image is "+ track_file)
return track_file
# original _
# warp _ or xy2
def parse_window(self,line):
fields = line.split()
# check there is a command field
if len(fields) < 1:
return 'error','no type field','',False,0,0,0,0
# deal with original which has 1
if fields[0]=='original':
if len(fields) <> 1:
return 'error','number of fields for original','',False,0,0,0,0
return 'normal','',fields[0],False,0,0,0,0
#deal with warp which has 1 or 5 arguments
# check basic syntax
if fields[0] <>'warp':
return 'error','not a valid type','',False,0,0,0,0
if len(fields) not in (1,5):
return 'error','wrong number of coordinates for warp','',False,0,0,0,0
# deal with window coordinates
if len(fields) == 5:
#window is specified
if not (fields[1].isdigit() and fields[2].isdigit() and fields[3].isdigit() and fields[4].isdigit()):
return 'error','coordinates are not positive integers','',False,0,0,0,0
has_window=True
return 'normal','',fields[0],has_window,int(fields[1]),int(fields[2]),int(fields[3]),int(fields[4])
else:
# fullscreen
has_window=True
return 'normal','',fields[0],has_window,0,0,self.canvas['width'],self.canvas['height']
class VideoPlayer:
""" plays a track using omxplayer
See pp_imageplayer for common software design description
"""
_CLOSED = "omx_closed" #probably will not exist
_STARTING = "omx_starting" #track is being prepared
_PLAYING = "omx_playing" #track is playing to the screen, may be paused
_ENDING = "omx_ending" #track is in the process of ending due to quit or end of track
# ***************************************
# EXTERNAL COMMANDS
# ***************************************
def __init__(self,
show_id,
root,
canvas,
show_params,
track_params ,
pp_dir,
pp_home,
pp_profile):
self.mon=Monitor()
self.mon.on()
#instantiate arguments
self.show_id=show_id
self.root=root
self.canvas = canvas
self.show_params=show_params
self.track_params=track_params
self.pp_dir=pp_dir
self.pp_home=pp_home
self.pp_profile=pp_profile
# get config from medialist if there.
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
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= "--vol "+ str(int(self.omx_volume)*100) + ' '
if self.track_params['omx-window']<>'':
self.omx_window= self.track_params['omx-window']
else:
self.omx_window= self.show_params['omx-window']
# get background image from profile.
self.background_file=''
if self.track_params['background-image']<>"":
self.background_file= self.track_params['background-image']
else:
if self.track_params['display-show-background']=='yes':
self.background_file= self.show_params['background-image']
# get background colour from profile.
if self.track_params['background-colour']<>"":
self.background_colour= self.track_params['background-colour']
else:
self.background_colour= self.show_params['background-colour']
self.centre_x = int(self.canvas['width'])/2
self.centre_y = int(self.canvas['height'])/2
#get animation instructions from profile
self.animate_begin_text=self.track_params['animate-begin']
self.animate_end_text=self.track_params['animate-end']
# open the plugin Manager
self.pim=PluginManager(self.show_id,self.root,self.canvas,self.show_params,self.track_params,self.pp_dir,self.pp_home,self.pp_profile)
#create an instance of PPIO so we can create gpio events
self.ppio = PPIO()
# could put instance generation in play, not sure which is better.
self.omx=OMXDriver(self.canvas)
self.tick_timer=None
self.init_play_state_machine()
def play(self, track,
showlist,
end_callback,
ready_callback,
enable_menu=False):
#instantiate arguments
self.track=track
self.showlist=showlist
self.ready_callback=ready_callback #callback when ready to play
self.end_callback=end_callback # callback when finished
self.enable_menu = enable_menu
# callback to the calling object to e.g remove egg timer and enable click areas.
if self.ready_callback<>None:
self.ready_callback()
# create an instance of showmanager so we can control concurrent shows
self.show_manager=ShowManager(self.show_id,self.showlist,self.show_params,self.root,self.canvas,self.pp_dir,self.pp_profile,self.pp_home)
#set up video window
reason,message,comand,has_window,x1,y1,x2,y2= self.parse_window(self.omx_window)
if reason =='error':
self.mon.err(self,'omx window error: ' + message + ' in ' + self.omx_window)
self.end_callback(reason,message)
else:
if has_window==True:
self.omx_window= '--win " '+ str(x1) + ' ' + str(y1) + ' ' + str(x2) + ' ' + str(y2) + ' " '
else:
self.omx_window=''
# Control other shows at beginning
reason,message=self.show_manager.show_control(self.track_params['show-control-begin'])
if reason in ('error','killed'):
self.end_callback(reason,message)
self=None
else:
#display content
reason,message=self.display_content()
if reason == 'error':
self.mon.err(self,message)
self.end_callback(reason,message)
self=None
else:
# create animation events
reason,message=self.ppio.animate(self.animate_begin_text,id(self))
if reason=='error':
self.mon.err(self,message)
self.end_callback(reason,message)
self=None
else:
# start playing the video.
if self.play_state == VideoPlayer._CLOSED:
self.mon.log(self,">play track received")
self.start_play_state_machine(self.track)
else:
self.mon.err(self,'play track rejected')
self.end_callback('error','play track rejected')
self=None
def terminate(self,reason):
# circumvents state machine and does not wait for omxplayer to close
if self.omx<>None:
self.mon.log(self,"sent terminate to omxdriver")
self.omx.terminate(reason)
self.end('killed',' end without waiting for omxplayer to finish') # end without waiting
else:
self.mon.log(self,"terminate, omxdriver not running")
self.end('killed','terminate, mplayerdriver not running')
def input_pressed(self,symbol):
if symbol[0:4]=='omx-':
self.control(symbol[4])
elif symbol =='pause':
self.pause()
elif symbol=='stop':
self.stop()
else:
pass
def get_links(self):
return self.track_params['links']
# ***************************************
# INTERNAL FUNCTIONS
# ***************************************
# respond to normal stop
def stop(self):
# send signal to stop the track to the state machine
self.mon.log(self,">stop received")
self.quit_signal=True
#toggle pause
def pause(self):
if self.play_state in (VideoPlayer._PLAYING,VideoPlayer._ENDING):
self.omx.pause()
return True
#NIK
# for pausing video after first frame
elif self.play_state == VideoPlayer._STARTING:
self.omx.delayed_pause = True
return True
#NIK
else:
self.mon.log(self,"!<pause rejected")
return False
# other control when playing
def control(self,char):
if self.play_state==VideoPlayer._PLAYING 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
# ***********************
# sequencing
# **********************
"""self. play_state controls the playing sequence, it has the following values.
I am not entirely sure the starting and ending states are required.
- _closed - the omx process is not running, omx process can be initiated
- _starting - omx process is running but is not yet able to receive controls
- _playing - playing a track, controls can be sent
- _ending - omx is doing its termination, controls cannot be sent
"""
def init_play_state_machine(self):
self.quit_signal=False
self.play_state=VideoPlayer._CLOSED
def start_play_state_machine(self,track):
#initialise all the state machine variables
#self.iteration = 0 # for debugging
self.quit_signal=False # signal that user has pressed stop
self.play_state=VideoPlayer._STARTING
#play the selected track
options=self.omx_audio+ " " + self.omx_volume + ' ' + self.omx_window + ' ' + self.show_params['omx-other-options']+" "
# NIK ADDITION
# adding subtitles file for video
if 'omx-subtitles' in self.track_params and self.track_params['omx-subtitles'] <> '':
subtitles_full_path = self.complete_path(self.track_params['omx-subtitles'])
if os.path.exists (subtitles_full_path):
options += '--font-size 40 --subtitles "' + subtitles_full_path + '" '
if 'omx-subtitles-numlines' in self.track_params and self.track_params['omx-subtitles-numlines'] <> '':
options += '--lines ' + self.track_params['omx-subtitles-numlines'] + ' '
# END NIK ADDITION
self.omx.play(track,options)
self.mon.log (self,'Playing track from show Id: '+ str(self.show_id))
# and start polling for state changes
self.tick_timer=self.canvas.after(50, self.play_state_machine)
def play_state_machine(self):
if self.play_state == VideoPlayer._CLOSED:
self.mon.log(self," State machine: " + self.play_state)
return
elif self.play_state == VideoPlayer._STARTING:
self.mon.log(self," State machine: " + self.play_state)
# if omxplayer is playing the track change to play state
if self.omx.start_play_signal==True:
self.mon.log(self," <start play signal received from omx")
self.omx.start_play_signal=False
self.play_state=VideoPlayer._PLAYING
self.mon.log(self," State machine: omx_playing started")
self.tick_timer=self.canvas.after(50, self.play_state_machine)
elif self.play_state == VideoPlayer._PLAYING:
# self.mon.log(self," State machine: " + self.play_state)
# service any queued stop signals
if self.quit_signal==True:
self.mon.log(self," Service stop required signal")
self.stop_omx()
self.quit_signal=False
# self.play_state = VideoPlayer._ENDING
# omxplayer reports it is terminating so change to ending state
if self.omx.end_play_signal:
self.mon.log(self," <end play signal received")
self.mon.log(self," <end detected at: " + str(self.omx.video_position))
if self.omx.end_play_reason<>'nice_day':
# deal with omxplayer not sending 'have a nice day'
self.mon.warn(self," <end detected at: " + str(self.omx.video_position))
self.mon.warn(self," <pexpect reports: "+self.omx.end_play_reason)
self.mon.warn(self,'pexpect.before is'+self.omx.xbefore)
self.play_state = VideoPlayer._ENDING
self.ending_count=0
self.tick_timer=self.canvas.after(200, self.play_state_machine)
elif self.play_state == VideoPlayer._ENDING:
self.mon.log(self," State machine: " + self.play_state)
# if spawned process has closed can change to closed state
self.mon.log (self," State machine : is omx process running? - " + str(self.omx.is_running()))
if self.omx.is_running() ==False:
self.mon.log(self," <omx process is dead")
self.play_state = VideoPlayer._CLOSED
self.end('normal','quit by user or system')
else:
self.ending_count+=1
if self.ending_count>10:
# deal with omxplayer not terminating at the end of a track
self.mon.warn(self," <omxplayer failed to close at: " + str(self.omx.video_position))
self.mon.warn(self,'pexpect.before is'+self.omx.xbefore)
self.omx.kill()
self.mon.warn(self,'omxplayer now terminated ')
self.play_state = VideoPlayer._CLOSED
self.end('normal','end from omxplayer failed to terminate')
else:
self.tick_timer=self.canvas.after(200, self.play_state_machine)
def stop_omx(self):
# send signal to stop the track to the state machine
self.mon.log(self," >stop omx received from state machine")
if self.play_state==VideoPlayer._PLAYING:
self.omx.stop()
return True
else:
self.mon.log(self,"!<stop rejected")
return False
# *****************
# ending the player
# *****************
def end(self,reason,message):
# stop the plugin
if self.track_params['plugin']<>'':
self.pim.stop_plugin()
# os.system("xrefresh -display :0")
# abort the timer
if self.tick_timer<>None:
self.canvas.after_cancel(self.tick_timer)
self.tick_timer=None
if reason in ('error','killed'):
self.end_callback(reason,message)
self=None
else:
# normal end so do show control and animation
# Control concurrent shows at end
reason,message=self.show_manager.show_control(self.track_params['show-control-end'])
if reason =='error':
self.mon.err(self,message)
self.end_callback(reason,message)
self=None
else:
# clear events list for this track
if self.track_params['animate-clear']=='yes':
self.ppio.clear_events_list(id(self))
# create animation events for ending
reason,message=self.ppio.animate(self.animate_end_text,id(self))
if reason=='error':
self.mon.err(self,message)
self.end_callback(reason,message)
self=None
else:
self.end_callback('normal',"track has terminated or quit")
self=None
# *****************
# displaying things
# *****************
def display_content(self):
#background colour
if self.background_colour<>'':
self.canvas.config(bg=self.background_colour)
# delete previous content
self.canvas.delete('pp-content')
# background image
if self.background_file<>'':
self.background_img_file = self.complete_path(self.background_file)
if not os.path.exists(self.background_img_file):
self.mon.err(self,"Video background file not found: "+ self.background_img_file)
self.end('error',"Video background file not found")
else:
pil_background_img=PIL.Image.open(self.background_img_file)
self.background = PIL.ImageTk.PhotoImage(pil_background_img)
self.drawn = self.canvas.create_image(int(self.canvas['width'])/2,
int(self.canvas['height'])/2,
image=self.background,
anchor=CENTER,
tag='pp-content')
# execute the plugin if required
if self.track_params['plugin']<>'':
reason,message,self.track = self.pim.do_plugin(self.track,self.track_params['plugin'],)
if reason <> 'normal':
return reason,message
# display show text if enabled
if self.show_params['show-text']<> '' and self.track_params['display-show-text']=='yes':
self.canvas.create_text(int(self.show_params['show-text-x']),int(self.show_params['show-text-y']),
anchor=NW,
text=self.show_params['show-text'],
fill=self.show_params['show-text-colour'],
font=self.show_params['show-text-font'],
tag='pp-content')
# display track text if enabled
if self.track_params['track-text']<> '':
self.canvas.create_text(int(self.track_params['track-text-x']),int(self.track_params['track-text-y']),
anchor=NW,
text=self.track_params['track-text'],
fill=self.track_params['track-text-colour'],
font=self.track_params['track-text-font'],
tag='pp-content')
# display instructions if enabled
if self.enable_menu== True:
self.canvas.create_text(int(self.show_params['hint-x']),
int(self.show_params['hint-y']),
text=self.show_params['hint-text'],
fill=self.show_params['hint-colour'],
font=self.show_params['hint-font'],
anchor=NW,
tag='pp-content')
self.canvas.tag_raise('pp-click-area')
self.canvas.update_idletasks( )
return 'normal',''
# ****************
# utilities
# *****************
def complete_path(self,track_file):
# complete path of the filename of the selected entry
if track_file[0]=="+":
track_file=self.pp_home+track_file[1:]
self.mon.log(self,"Background image is "+ track_file)
return track_file
# original _
# warp _ or xy2
def parse_window(self,line):
fields = line.split()
# check there is a command field
if len(fields) < 1:
return 'error','no type field','',False,0,0,0,0
# deal with original which has 1
if fields[0]=='original':
if len(fields) <> 1:
return 'error','number of fields for original','',False,0,0,0,0
return 'normal','',fields[0],False,0,0,0,0
#deal with warp which has 1 or 5 arguments
# check basic syntax
if fields[0] <>'warp':
return 'error','not a valid type','',False,0,0,0,0
if len(fields) not in (1,5):
return 'error','wrong number of coordinates for warp','',False,0,0,0,0
# deal with window coordinates
if len(fields) == 5:
#window is specified
if not (fields[1].isdigit() and fields[2].isdigit() and fields[3].isdigit() and fields[4].isdigit()):
return 'error','coordinates are not positive integers','',False,0,0,0,0
has_window=True
return 'normal','',fields[0],has_window,int(fields[1]),int(fields[2]),int(fields[3]),int(fields[4])
else:
# fullscreen
has_window=True
return 'normal','',fields[0],has_window,0,0,self.canvas['width'],self.canvas['height']
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.
"""
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, '')
# 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
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 = "--vol " + str(int(self.omx_volume) * 100) + ' '
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-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 = ''
# initialise video playing state and signals
self.quit_signal = False
self.unload_signal = False
self.play_state = 'initialised'
self.frozen_at_end = False
# 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 window
status, message, command, has_window, x1, y1, x2, y2 = self.parse_video_window(
self.omx_window)
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', message)
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 = ''
# 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 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')
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()
# 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-':
self.control(symbol[4])
elif symbol == 'pause':
self.pause()
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))
# 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")
# 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:
self.omx.toggle_pause('user')
return True
else:
self.mon.log(self, "!<pause 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 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.
eof and timeout are error conditions and should not happen. vidoeplayer recovers from these and continues.
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= timeout eof or nice_day omxplayer closing should not be attempted as it is already closed
Do not generate user errors in Show. Only geberate 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 = ' --no-osd ' + self.omx_audio + " " + self.omx_volume + ' ' + self.omx_window_processed + ' ' + self.seamless_loop + ' ' + self.omx_other_options + " "
self.omx.load(track, options, self.mon.pretty_inst(self))
# 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')
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)
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')
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, eof or timeout 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.mon.warn(self, 'pexpect.before is' + self.omx.xbefore)
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.mon.warn(self,
'pexpect.before is' + self.omx.xbefore)
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:
# problem with omxplayer
if self.omx.end_play_reason in ('eof', 'timeout'):
self.mon.warn(self, self.track)
self.mon.warn(
self,
" <start_unload - end detected at: " +
str(self.omx.video_position))
self.mon.warn(
self, " <pexpect reports: " +
self.omx.end_play_reason)
self.mon.warn(self,
'pexpect.before is' + self.omx.xbefore)
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')
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,
'pexpect.before is' + self.omx.xbefore)
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')
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)
elif self.omx.end_play_reason in ('eof', 'timeout'):
# problem with omxplayer
self.play_state = 'closing'
self.closing_count = 0
# self.mon.warn(self,self.track + ' ' + self.omx.caller)
self.mon.log(
self, " Entering state : " + self.play_state +
' from show Id: ' + str(self.show_id))
self.mon.warn(
self, "unexpected termination - : " +
self.omx.end_play_reason + ' at: ' +
str(self.omx.video_position) + ' ' + self.track + ' ' +
self.omx.caller)
self.mon.trace(self,
'pexpect.before is' + self.omx.xbefore)
# print 'showing - eof or timeout so go to closing to wait for precess to be dead'
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')
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,'pexpect.before is'+self.omx.xbefore)
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')
def parse_video_window(self, line):
fields = line.split()
# check there is a command field
if len(fields) < 1:
return 'error', 'no type field', '', False, 0, 0, 0, 0
# deal with original which has 1
if fields[0] == 'original':
if len(fields) != 1:
return 'error', 'number of fields for original', '', False, 0, 0, 0, 0
return 'normal', '', fields[0], False, 0, 0, 0, 0
# deal with warp which has 1 or 5 arguments
# check basic syntax
if fields[0] != 'warp':
return 'error', 'not a valid type', '', False, 0, 0, 0, 0
if len(fields) not in (1, 5):
return 'error', 'wrong number of coordinates for warp', '', False, 0, 0, 0, 0
# deal with window coordinates
if len(fields) == 5:
# window is specified
if not (fields[1].isdigit() and fields[2].isdigit()
and fields[3].isdigit() and fields[4].isdigit()):
return 'error', 'coordinates are not positive integers', '', False, 0, 0, 0, 0
has_window = True
return 'normal', '', fields[
0], has_window, self.show_canvas_x1 + int(
fields[1]), self.show_canvas_y1 + int(
fields[2]), self.show_canvas_x1 + int(
fields[3]), self.show_canvas_y1 + int(fields[4])
else:
# fullscreen
has_window = True
return 'normal', '', fields[
0], has_window, self.show_canvas_x1, self.show_canvas_y1, self.show_canvas_x2, self.show_canvas_y2
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.
"""
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,'')
# 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
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= "--vol "+ str(int(self.omx_volume)*100) + ' '
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-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=''
# initialise video playing state and signals
self.quit_signal=False
self.unload_signal=False
self.play_state='initialised'
self.frozen_at_end=False
# 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 window
status,message,command,has_window,x1,y1,x2,y2= self.parse_video_window(self.omx_window)
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',message)
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=''
# 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 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')
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()
# 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-':
self.control(symbol[4])
elif symbol == 'pause':
self.pause()
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))
# 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")
# 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:
self.omx.toggle_pause('user')
return True
else:
self.mon.log(self,"!<pause 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 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.
eof and timeout are error conditions and should not happen. vidoeplayer recovers from these and continues.
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= timeout eof or nice_day omxplayer closing should not be attempted as it is already closed
Do not generate user errors in Show. Only geberate 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= ' --no-osd ' + self.omx_audio+ " " + self.omx_volume + ' ' + self.omx_window_processed + ' ' + self.seamless_loop + ' ' + self.omx_other_options +" "
self.omx.load(track,options,self.mon.pretty_inst(self))
# 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')
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)
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')
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, eof or timeout 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.mon.warn(self,'pexpect.before is'+self.omx.xbefore)
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>200: #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.mon.warn(self,'pexpect.before is'+self.omx.xbefore)
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(200, self.load_state_machine)
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:
# problem with omxplayer
if self.omx.end_play_reason in ('eof','timeout'):
self.mon.warn(self,self.track)
self.mon.warn(self," <start_unload - end detected at: " + str(self.omx.video_position))
self.mon.warn(self," <pexpect reports: "+self.omx.end_play_reason)
self.mon.warn(self,'pexpect.before is'+self.omx.xbefore)
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')
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,'pexpect.before is'+self.omx.xbefore)
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')
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)
elif self.omx.end_play_reason in ('eof','timeout'):
# problem with omxplayer
self.play_state='closing'
self.closing_count=0
# self.mon.warn(self,self.track + ' ' + self.omx.caller)
self.mon.log(self," Entering state : " + self.play_state + ' from show Id: '+ str(self.show_id))
self.mon.warn(self,"unexpected termination - : "+self.omx.end_play_reason + ' at: ' + str(self.omx.video_position) + ' ' + self.track + ' ' + self.omx.caller)
self.mon.trace(self,'pexpect.before is'+self.omx.xbefore)
# print 'showing - eof or timeout so go to closing to wait for precess to be dead'
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')
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,'pexpect.before is'+self.omx.xbefore)
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')
def parse_video_window(self,line):
fields = line.split()
# check there is a command field
if len(fields) < 1:
return 'error','no type field','',False,0,0,0,0
# deal with original which has 1
if fields[0] == 'original':
if len(fields) != 1:
return 'error','number of fields for original','',False,0,0,0,0
return 'normal','',fields[0],False,0,0,0,0
# deal with warp which has 1 or 5 arguments
# check basic syntax
if fields[0] != 'warp':
return 'error','not a valid type','',False,0,0,0,0
if len(fields) not in (1,5):
return 'error','wrong number of coordinates for warp','',False,0,0,0,0
# deal with window coordinates
if len(fields) == 5:
# window is specified
if not (fields[1].isdigit() and fields[2].isdigit() and fields[3].isdigit() and fields[4].isdigit()):
return 'error','coordinates are not positive integers','',False,0,0,0,0
has_window=True
return 'normal','',fields[0],has_window,self.show_canvas_x1+int(fields[1]),self.show_canvas_y1+int(fields[2]),self.show_canvas_x1+int(fields[3]),self.show_canvas_y1+int(fields[4])
else:
# fullscreen
has_window=True
return 'normal','',fields[0],has_window,self.show_canvas_x1,self.show_canvas_y1,self.show_canvas_x2,self.show_canvas_y2