def __init__(self, show_id, showlist, root, canvas, show_params,
track_params, pp_dir, pp_home, pp_profile, end_callback,
command_callback):
# initialise items common to all players
Player.__init__(self, show_id, showlist, root, canvas, show_params,
track_params, pp_dir, pp_home, pp_profile,
end_callback, command_callback)
self.mon.trace(self, '')
# and initialise things for this player
self.dm = DisplayManager()
# get duration limit (secs ) from profile
if self.track_params['duration'] != '':
self.duration_text = self.track_params['duration']
else:
self.duration_text = self.show_params['duration']
# process chrome window
if self.track_params['chrome-window'] != '':
self.chrome_window_text = self.track_params['chrome-window']
else:
self.chrome_window_text = self.show_params['chrome-window']
# process chrome things
if self.track_params['chrome-freeze-at-end'] != '':
self.freeze_at_end = self.track_params['chrome-freeze-at-end']
else:
self.freeze_at_end = self.show_params['chrome-freeze-at-end']
if self.track_params['chrome-zoom'] != '':
self.chrome_zoom_text = self.track_params['chrome-zoom']
else:
self.chrome_zoom_text = self.show_params['chrome-zoom']
if self.track_params['chrome-other-options'] != '':
self.chrome_other_options = self.track_params[
'chrome-other-options']
else:
self.chrome_other_options = self.show_params[
'chrome-other-options']
# Initialize variables
self.command_timer = None
self.tick_timer = None
self.quit_signal = False # signal that user has pressed stop
# initialise the play state
self.play_state = 'initialised'
self.load_state = ''
def __init__(self, show_id, showlist, show_params, root, pp_dir,
pp_profile, pp_home):
self.show_id = show_id
self.showlist = showlist
self.show_params = show_params
self.root = root
self.pp_dir = pp_dir
self.pp_profile = pp_profile
self.pp_home = pp_home
self.dm = DisplayManager()
self.mon = Monitor()
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
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
def __init__(self):
# gc.set_debug(gc.DEBUG_UNCOLLECTABLE|gc.DEBUG_INSTANCES|gc.DEBUG_OBJECTS|gc.DEBUG_SAVEALL)
gc.set_debug(gc.DEBUG_UNCOLLECTABLE | gc.DEBUG_SAVEALL)
self.pipresents_issue = "1.4.4"
self.pipresents_minorissue = '1.4.4a'
# position and size of window without -f command line option
self.nonfull_window_width = 0.45 # proportion of width
self.nonfull_window_height = 0.7 # proportion of height
self.nonfull_window_x = 0 # position of top left corner
self.nonfull_window_y = 0 # position of top left corner
StopWatch.global_enable = False
# set up the handler for SIGTERM
signal.signal(signal.SIGTERM, self.handle_sigterm)
# ****************************************
# Initialisation
# ***************************************
# get command line options
self.options = command_options()
# print (self.options)
# get Pi Presents code directory
pp_dir = sys.path[0]
self.pp_dir = pp_dir
if not os.path.exists(pp_dir + "/pipresents.py"):
if self.options['manager'] is False:
tkinter.messagebox.showwarning("Pi Presents",
"Bad Application Directory")
exit(102)
# Initialise logging and tracing
Monitor.log_path = pp_dir
self.mon = Monitor()
# Init in PiPresents only
self.mon.init()
# uncomment to enable control of logging from within a class
# Monitor.enable_in_code = True # enables control of log level in the code for a class - self.mon.set_log_level()
# make a shorter list to log/trace only some classes without using enable_in_code.
Monitor.classes = [
'PiPresents', 'HyperlinkShow', 'RadioButtonShow', 'ArtLiveShow',
'ArtMediaShow', 'MediaShow', 'LiveShow', 'MenuShow', 'GapShow',
'Show', 'ArtShow', 'AudioPlayer', 'BrowserPlayer', 'ImagePlayer',
'MenuPlayer', 'MessagePlayer', 'VideoPlayer', 'Player',
'MediaList', 'LiveList', 'ShowList', 'PathManager',
'ControlsManager', 'ShowManager', 'PluginManager',
'IOPluginManager', 'MplayerDriver', 'OMXDriver', 'UZBLDriver',
'TimeOfDay', 'ScreenDriver', 'Animate', 'OSCDriver',
'CounterManager', 'BeepsManager', 'Network', 'Mailer'
]
# Monitor.classes=['PiPresents','MediaShow','GapShow','Show','VideoPlayer','Player','OMXDriver']
# Monitor.classes=['OSCDriver']
# get global log level from command line
Monitor.log_level = int(self.options['debug'])
Monitor.manager = self.options['manager']
# print self.options['manager']
self.mon.newline(3)
self.mon.sched(
self, None,
"Pi Presents is starting, Version:" + self.pipresents_minorissue +
' at ' + time.strftime("%Y-%m-%d %H:%M.%S"))
self.mon.log(
self,
"Pi Presents is starting, Version:" + self.pipresents_minorissue +
' at ' + time.strftime("%Y-%m-%d %H:%M.%S"))
# self.mon.log (self," OS and separator:" + os.name +' ' + os.sep)
self.mon.log(self, "sys.path[0] - location of code: " + sys.path[0])
# log versions of Raspbian and omxplayer, and GPU Memory
with open("/boot/issue.txt") as ifile:
self.mon.log(self, '\nRaspbian: ' + ifile.read())
self.mon.log(
self,
'\n' + check_output(["omxplayer", "-v"], universal_newlines=True))
self.mon.log(
self,
'\nGPU Memory: ' + check_output(["vcgencmd", "get_mem", "gpu"],
universal_newlines=True))
if os.geteuid() == 0:
print('Do not run Pi Presents with sudo')
self.mon.log(self, 'Do not run Pi Presents with sudo')
self.mon.finish()
sys.exit(102)
if "DESKTOP_SESSION" not in os.environ:
print('Pi Presents must be run from the Desktop')
self.mon.log(self, 'Pi Presents must be run from the Desktop')
self.mon.finish()
sys.exit(102)
else:
self.mon.log(self, 'Desktop is ' + os.environ['DESKTOP_SESSION'])
# optional other classes used
self.root = None
self.ppio = None
self.tod = None
self.animate = None
self.ioplugin_manager = None
self.oscdriver = None
self.osc_enabled = False
self.tod_enabled = False
self.email_enabled = False
user = os.getenv('USER')
if user is None:
tkinter.messagebox.showwarning(
"You must be logged in to run Pi Presents")
exit(102)
if user != 'pi':
self.mon.warn(self, "You must be logged as pi to use GPIO")
self.mon.log(self, 'User is: ' + user)
# self.mon.log(self,"os.getenv('HOME') - user home directory (not used): " + os.getenv('HOME')) # does not work
# self.mon.log(self,"os.path.expanduser('~') - user home directory: " + os.path.expanduser('~')) # does not work
# check network is available
self.network_connected = False
self.network_details = False
self.interface = ''
self.ip = ''
self.unit = ''
# sets self.network_connected and self.network_details
self.init_network()
# start the mailer and send email when PP starts
self.email_enabled = False
if self.network_connected is True:
self.init_mailer()
if self.email_enabled is True and self.mailer.email_at_start is True:
subject = '[Pi Presents] ' + self.unit + ': PP Started on ' + time.strftime(
"%Y-%m-%d %H:%M")
message = time.strftime(
"%Y-%m-%d %H:%M"
) + '\nUnit: ' + self.unit + ' Profile: ' + self.options[
'profile'] + '\n ' + self.interface + '\n ' + self.ip
self.send_email('start', subject, message)
# get profile path from -p option
if self.options['profile'] != '':
self.pp_profile_path = "/pp_profiles/" + self.options['profile']
else:
self.mon.err(self, "Profile not specified in command ")
self.end('error',
'Profile not specified with the commands -p option')
# get directory containing pp_home from the command,
if self.options['home'] == "":
home = os.sep + 'home' + os.sep + user + os.sep + "pp_home"
else:
home = self.options['home'] + os.sep + "pp_home"
self.mon.log(self, "pp_home directory is: " + home)
# check if pp_home exists.
# try for 10 seconds to allow usb stick to automount
found = False
for i in range(1, 10):
self.mon.log(self,
"Trying pp_home at: " + home + " (" + str(i) + ')')
if os.path.exists(home):
found = True
self.pp_home = home
break
time.sleep(1)
if found is True:
self.mon.log(
self,
"Found Requested Home Directory, using pp_home at: " + home)
else:
self.mon.err(self, "Failed to find pp_home directory at " + home)
self.end('error', "Failed to find pp_home directory at " + home)
# check profile exists
self.pp_profile = self.pp_home + self.pp_profile_path
if os.path.exists(self.pp_profile):
self.mon.sched(self, None,
"Running profile: " + self.pp_profile_path)
self.mon.log(
self, "Found Requested profile - pp_profile directory is: " +
self.pp_profile)
else:
self.mon.err(
self, "Failed to find requested profile: " + self.pp_profile)
self.end('error',
"Failed to find requested profile: " + self.pp_profile)
self.mon.start_stats(self.options['profile'])
if self.options['verify'] is True:
self.mon.err(self,
"Validation option not supported - use the editor")
self.end('error',
'Validation option not supported - use the editor')
# initialise and read the showlist in the profile
self.showlist = ShowList()
self.showlist_file = self.pp_profile + "/pp_showlist.json"
if os.path.exists(self.showlist_file):
self.showlist.open_json(self.showlist_file)
else:
self.mon.err(self, "showlist not found at " + self.showlist_file)
self.end('error', "showlist not found at " + self.showlist_file)
# check profile and Pi Presents issues are compatible
if self.showlist.profile_version() != self.pipresents_version():
self.mon.err(
self,
"Version of showlist " + self.showlist.profile_version_string +
" is not same as Pi Presents")
self.end(
'error',
"Version of showlist " + self.showlist.profile_version_string +
" is not same as Pi Presents")
# get the 'start' show from the showlist
index = self.showlist.index_of_start_show()
if index >= 0:
self.showlist.select(index)
self.starter_show = self.showlist.selected_show()
else:
self.mon.err(self, "Show [start] not found in showlist")
self.end('error', "Show [start] not found in showlist")
# ********************
# SET UP THE GUI
# ********************
# turn off the screenblanking and saver
if self.options['noblank'] is True:
call(["xset", "s", "off"])
call(["xset", "s", "-dpms"])
# find connected displays and create a canvas for each display
self.dm = DisplayManager()
status, message, self.root = self.dm.init(self.options,
self.handle_user_abort)
if status != 'normal':
self.mon.err(self, message)
self.end('error', message)
self.mon.log(
self,
str(DisplayManager.num_displays) + ' Displays are connected:')
for display_name in DisplayManager.display_map:
status, message, display_id, canvas_obj = self.dm.id_of_canvas(
display_name)
if status != 'normal':
continue
width, height = self.dm.real_display_dimensions(display_id)
self.mon.log(
self, ' - ' + self.dm.name_of_display(display_id) + ' Id: ' +
str(display_id) + ' ' + str(width) + '*' + str(height))
canvas_obj.config(bg=self.starter_show['background-colour'])
# ****************************************
# INITIALISE THE TOUCHSCREEN DRIVER
# ****************************************
# each driver takes a set of inputs, binds them to symboic names
# and sets up a callback which returns the symbolic name when an input event occurs
self.sr = ScreenDriver()
# read the screen click area config file
reason, message = self.sr.read(pp_dir, self.pp_home, self.pp_profile)
if reason == 'error':
self.end('error', 'cannot find, or error in screen.cfg')
# create click areas on the canvases, must be polygon as outline rectangles are not filled as far as find_closest goes
reason, message = self.sr.make_click_areas(self.handle_input_event)
if reason == 'error':
self.mon.err(self, message)
self.end('error', message)
# ****************************************
# INITIALISE THE APPLICATION AND START
# ****************************************
self.shutdown_required = False
self.reboot_required = False
self.terminate_required = False
self.exitpipresents_required = False
# initialise the Beeps Manager
self.beepsmanager = BeepsManager()
self.beepsmanager.init(self.pp_home, self.pp_profile)
# initialise the I/O plugins by importing their drivers
self.ioplugin_manager = IOPluginManager()
reason, message = self.ioplugin_manager.init(self.pp_dir,
self.pp_profile,
self.root,
self.handle_input_event,
self.pp_home)
if reason == 'error':
# self.mon.err(self,message)
self.end('error', message)
# kick off animation sequencer
self.animate = Animate()
self.animate.init(pp_dir, self.pp_home, self.pp_profile, self.root,
200, self.handle_output_event)
self.animate.poll()
#create a showmanager ready for time of day scheduler and osc server
show_id = -1
self.show_manager = ShowManager(show_id, self.showlist,
self.starter_show, self.root,
self.pp_dir, self.pp_profile,
self.pp_home)
# first time through set callback to terminate Pi Presents if all shows have ended.
self.show_manager.init(self.all_shows_ended_callback,
self.handle_command, self.showlist)
# Register all the shows in the showlist
reason, message = self.show_manager.register_shows()
if reason == 'error':
self.mon.err(self, message)
self.end('error', message)
# Init OSCDriver, read config and start OSC server
self.osc_enabled = False
if self.network_connected is True:
if os.path.exists(self.pp_profile + os.sep + 'pp_io_config' +
os.sep + 'osc.cfg'):
self.oscdriver = OSCDriver()
reason, message = self.oscdriver.init(
self.pp_profile, self.unit, self.interface, self.ip,
self.handle_command, self.handle_input_event,
self.e_osc_handle_animate)
if reason == 'error':
self.mon.err(self, message)
self.end('error', message)
else:
self.osc_enabled = True
self.root.after(1000, self.oscdriver.start_server())
# initialise ToD scheduler calculating schedule for today
self.tod = TimeOfDay()
reason, message, self.tod_enabled = self.tod.init(
pp_dir, self.pp_home, self.pp_profile, self.showlist, self.root,
self.handle_command)
if reason == 'error':
self.mon.err(self, message)
self.end('error', message)
# warn if the network not available when ToD required
if self.tod_enabled is True and self.network_connected is False:
self.mon.warn(
self,
'Network not connected so Time of Day scheduler may be using the internal clock'
)
# init the counter manager
self.counter_manager = CounterManager()
if self.starter_show['counters-store'] == 'yes':
store_enable = True
else:
store_enable = False
reason, message = self.counter_manager.init(
self.pp_profile + '/counters.cfg', store_enable,
self.options['loadcounters'],
self.starter_show['counters-initial'])
if reason == 'error':
self.mon.err(self, message)
self.end('error', message)
# warn about start shows and scheduler
if self.starter_show['start-show'] == '' and self.tod_enabled is False:
self.mon.sched(
self, None,
"No Start Shows in Start Show and no shows scheduled")
self.mon.warn(
self, "No Start Shows in Start Show and no shows scheduled")
if self.starter_show['start-show'] != '' and self.tod_enabled is True:
self.mon.sched(
self, None,
"Start Shows in Start Show and shows scheduled - conflict?")
self.mon.warn(
self,
"Start Shows in Start Show and shows scheduled - conflict?")
# run the start shows
self.run_start_shows()
# kick off the time of day scheduler which may run additional shows
if self.tod_enabled is True:
self.tod.poll()
# start the I/O plugins input event generation
self.ioplugin_manager.start()
# start Tkinters event loop
self.root.mainloop()
class PiPresents(object):
def pipresents_version(self):
vitems = self.pipresents_issue.split('.')
if len(vitems) == 2:
# cope with 2 digit version numbers before 1.3.2
return 1000 * int(vitems[0]) + 100 * int(vitems[1])
else:
return 1000 * int(vitems[0]) + 100 * int(vitems[1]) + int(
vitems[2])
def __init__(self):
# gc.set_debug(gc.DEBUG_UNCOLLECTABLE|gc.DEBUG_INSTANCES|gc.DEBUG_OBJECTS|gc.DEBUG_SAVEALL)
gc.set_debug(gc.DEBUG_UNCOLLECTABLE | gc.DEBUG_SAVEALL)
self.pipresents_issue = "1.4.4"
self.pipresents_minorissue = '1.4.4a'
# position and size of window without -f command line option
self.nonfull_window_width = 0.45 # proportion of width
self.nonfull_window_height = 0.7 # proportion of height
self.nonfull_window_x = 0 # position of top left corner
self.nonfull_window_y = 0 # position of top left corner
StopWatch.global_enable = False
# set up the handler for SIGTERM
signal.signal(signal.SIGTERM, self.handle_sigterm)
# ****************************************
# Initialisation
# ***************************************
# get command line options
self.options = command_options()
# print (self.options)
# get Pi Presents code directory
pp_dir = sys.path[0]
self.pp_dir = pp_dir
if not os.path.exists(pp_dir + "/pipresents.py"):
if self.options['manager'] is False:
tkinter.messagebox.showwarning("Pi Presents",
"Bad Application Directory")
exit(102)
# Initialise logging and tracing
Monitor.log_path = pp_dir
self.mon = Monitor()
# Init in PiPresents only
self.mon.init()
# uncomment to enable control of logging from within a class
# Monitor.enable_in_code = True # enables control of log level in the code for a class - self.mon.set_log_level()
# make a shorter list to log/trace only some classes without using enable_in_code.
Monitor.classes = [
'PiPresents', 'HyperlinkShow', 'RadioButtonShow', 'ArtLiveShow',
'ArtMediaShow', 'MediaShow', 'LiveShow', 'MenuShow', 'GapShow',
'Show', 'ArtShow', 'AudioPlayer', 'BrowserPlayer', 'ImagePlayer',
'MenuPlayer', 'MessagePlayer', 'VideoPlayer', 'Player',
'MediaList', 'LiveList', 'ShowList', 'PathManager',
'ControlsManager', 'ShowManager', 'PluginManager',
'IOPluginManager', 'MplayerDriver', 'OMXDriver', 'UZBLDriver',
'TimeOfDay', 'ScreenDriver', 'Animate', 'OSCDriver',
'CounterManager', 'BeepsManager', 'Network', 'Mailer'
]
# Monitor.classes=['PiPresents','MediaShow','GapShow','Show','VideoPlayer','Player','OMXDriver']
# Monitor.classes=['OSCDriver']
# get global log level from command line
Monitor.log_level = int(self.options['debug'])
Monitor.manager = self.options['manager']
# print self.options['manager']
self.mon.newline(3)
self.mon.sched(
self, None,
"Pi Presents is starting, Version:" + self.pipresents_minorissue +
' at ' + time.strftime("%Y-%m-%d %H:%M.%S"))
self.mon.log(
self,
"Pi Presents is starting, Version:" + self.pipresents_minorissue +
' at ' + time.strftime("%Y-%m-%d %H:%M.%S"))
# self.mon.log (self," OS and separator:" + os.name +' ' + os.sep)
self.mon.log(self, "sys.path[0] - location of code: " + sys.path[0])
# log versions of Raspbian and omxplayer, and GPU Memory
with open("/boot/issue.txt") as ifile:
self.mon.log(self, '\nRaspbian: ' + ifile.read())
self.mon.log(
self,
'\n' + check_output(["omxplayer", "-v"], universal_newlines=True))
self.mon.log(
self,
'\nGPU Memory: ' + check_output(["vcgencmd", "get_mem", "gpu"],
universal_newlines=True))
if os.geteuid() == 0:
print('Do not run Pi Presents with sudo')
self.mon.log(self, 'Do not run Pi Presents with sudo')
self.mon.finish()
sys.exit(102)
if "DESKTOP_SESSION" not in os.environ:
print('Pi Presents must be run from the Desktop')
self.mon.log(self, 'Pi Presents must be run from the Desktop')
self.mon.finish()
sys.exit(102)
else:
self.mon.log(self, 'Desktop is ' + os.environ['DESKTOP_SESSION'])
# optional other classes used
self.root = None
self.ppio = None
self.tod = None
self.animate = None
self.ioplugin_manager = None
self.oscdriver = None
self.osc_enabled = False
self.tod_enabled = False
self.email_enabled = False
user = os.getenv('USER')
if user is None:
tkinter.messagebox.showwarning(
"You must be logged in to run Pi Presents")
exit(102)
if user != 'pi':
self.mon.warn(self, "You must be logged as pi to use GPIO")
self.mon.log(self, 'User is: ' + user)
# self.mon.log(self,"os.getenv('HOME') - user home directory (not used): " + os.getenv('HOME')) # does not work
# self.mon.log(self,"os.path.expanduser('~') - user home directory: " + os.path.expanduser('~')) # does not work
# check network is available
self.network_connected = False
self.network_details = False
self.interface = ''
self.ip = ''
self.unit = ''
# sets self.network_connected and self.network_details
self.init_network()
# start the mailer and send email when PP starts
self.email_enabled = False
if self.network_connected is True:
self.init_mailer()
if self.email_enabled is True and self.mailer.email_at_start is True:
subject = '[Pi Presents] ' + self.unit + ': PP Started on ' + time.strftime(
"%Y-%m-%d %H:%M")
message = time.strftime(
"%Y-%m-%d %H:%M"
) + '\nUnit: ' + self.unit + ' Profile: ' + self.options[
'profile'] + '\n ' + self.interface + '\n ' + self.ip
self.send_email('start', subject, message)
# get profile path from -p option
if self.options['profile'] != '':
self.pp_profile_path = "/pp_profiles/" + self.options['profile']
else:
self.mon.err(self, "Profile not specified in command ")
self.end('error',
'Profile not specified with the commands -p option')
# get directory containing pp_home from the command,
if self.options['home'] == "":
home = os.sep + 'home' + os.sep + user + os.sep + "pp_home"
else:
home = self.options['home'] + os.sep + "pp_home"
self.mon.log(self, "pp_home directory is: " + home)
# check if pp_home exists.
# try for 10 seconds to allow usb stick to automount
found = False
for i in range(1, 10):
self.mon.log(self,
"Trying pp_home at: " + home + " (" + str(i) + ')')
if os.path.exists(home):
found = True
self.pp_home = home
break
time.sleep(1)
if found is True:
self.mon.log(
self,
"Found Requested Home Directory, using pp_home at: " + home)
else:
self.mon.err(self, "Failed to find pp_home directory at " + home)
self.end('error', "Failed to find pp_home directory at " + home)
# check profile exists
self.pp_profile = self.pp_home + self.pp_profile_path
if os.path.exists(self.pp_profile):
self.mon.sched(self, None,
"Running profile: " + self.pp_profile_path)
self.mon.log(
self, "Found Requested profile - pp_profile directory is: " +
self.pp_profile)
else:
self.mon.err(
self, "Failed to find requested profile: " + self.pp_profile)
self.end('error',
"Failed to find requested profile: " + self.pp_profile)
self.mon.start_stats(self.options['profile'])
if self.options['verify'] is True:
self.mon.err(self,
"Validation option not supported - use the editor")
self.end('error',
'Validation option not supported - use the editor')
# initialise and read the showlist in the profile
self.showlist = ShowList()
self.showlist_file = self.pp_profile + "/pp_showlist.json"
if os.path.exists(self.showlist_file):
self.showlist.open_json(self.showlist_file)
else:
self.mon.err(self, "showlist not found at " + self.showlist_file)
self.end('error', "showlist not found at " + self.showlist_file)
# check profile and Pi Presents issues are compatible
if self.showlist.profile_version() != self.pipresents_version():
self.mon.err(
self,
"Version of showlist " + self.showlist.profile_version_string +
" is not same as Pi Presents")
self.end(
'error',
"Version of showlist " + self.showlist.profile_version_string +
" is not same as Pi Presents")
# get the 'start' show from the showlist
index = self.showlist.index_of_start_show()
if index >= 0:
self.showlist.select(index)
self.starter_show = self.showlist.selected_show()
else:
self.mon.err(self, "Show [start] not found in showlist")
self.end('error', "Show [start] not found in showlist")
# ********************
# SET UP THE GUI
# ********************
# turn off the screenblanking and saver
if self.options['noblank'] is True:
call(["xset", "s", "off"])
call(["xset", "s", "-dpms"])
# find connected displays and create a canvas for each display
self.dm = DisplayManager()
status, message, self.root = self.dm.init(self.options,
self.handle_user_abort)
if status != 'normal':
self.mon.err(self, message)
self.end('error', message)
self.mon.log(
self,
str(DisplayManager.num_displays) + ' Displays are connected:')
for display_name in DisplayManager.display_map:
status, message, display_id, canvas_obj = self.dm.id_of_canvas(
display_name)
if status != 'normal':
continue
width, height = self.dm.real_display_dimensions(display_id)
self.mon.log(
self, ' - ' + self.dm.name_of_display(display_id) + ' Id: ' +
str(display_id) + ' ' + str(width) + '*' + str(height))
canvas_obj.config(bg=self.starter_show['background-colour'])
# ****************************************
# INITIALISE THE TOUCHSCREEN DRIVER
# ****************************************
# each driver takes a set of inputs, binds them to symboic names
# and sets up a callback which returns the symbolic name when an input event occurs
self.sr = ScreenDriver()
# read the screen click area config file
reason, message = self.sr.read(pp_dir, self.pp_home, self.pp_profile)
if reason == 'error':
self.end('error', 'cannot find, or error in screen.cfg')
# create click areas on the canvases, must be polygon as outline rectangles are not filled as far as find_closest goes
reason, message = self.sr.make_click_areas(self.handle_input_event)
if reason == 'error':
self.mon.err(self, message)
self.end('error', message)
# ****************************************
# INITIALISE THE APPLICATION AND START
# ****************************************
self.shutdown_required = False
self.reboot_required = False
self.terminate_required = False
self.exitpipresents_required = False
# initialise the Beeps Manager
self.beepsmanager = BeepsManager()
self.beepsmanager.init(self.pp_home, self.pp_profile)
# initialise the I/O plugins by importing their drivers
self.ioplugin_manager = IOPluginManager()
reason, message = self.ioplugin_manager.init(self.pp_dir,
self.pp_profile,
self.root,
self.handle_input_event,
self.pp_home)
if reason == 'error':
# self.mon.err(self,message)
self.end('error', message)
# kick off animation sequencer
self.animate = Animate()
self.animate.init(pp_dir, self.pp_home, self.pp_profile, self.root,
200, self.handle_output_event)
self.animate.poll()
#create a showmanager ready for time of day scheduler and osc server
show_id = -1
self.show_manager = ShowManager(show_id, self.showlist,
self.starter_show, self.root,
self.pp_dir, self.pp_profile,
self.pp_home)
# first time through set callback to terminate Pi Presents if all shows have ended.
self.show_manager.init(self.all_shows_ended_callback,
self.handle_command, self.showlist)
# Register all the shows in the showlist
reason, message = self.show_manager.register_shows()
if reason == 'error':
self.mon.err(self, message)
self.end('error', message)
# Init OSCDriver, read config and start OSC server
self.osc_enabled = False
if self.network_connected is True:
if os.path.exists(self.pp_profile + os.sep + 'pp_io_config' +
os.sep + 'osc.cfg'):
self.oscdriver = OSCDriver()
reason, message = self.oscdriver.init(
self.pp_profile, self.unit, self.interface, self.ip,
self.handle_command, self.handle_input_event,
self.e_osc_handle_animate)
if reason == 'error':
self.mon.err(self, message)
self.end('error', message)
else:
self.osc_enabled = True
self.root.after(1000, self.oscdriver.start_server())
# initialise ToD scheduler calculating schedule for today
self.tod = TimeOfDay()
reason, message, self.tod_enabled = self.tod.init(
pp_dir, self.pp_home, self.pp_profile, self.showlist, self.root,
self.handle_command)
if reason == 'error':
self.mon.err(self, message)
self.end('error', message)
# warn if the network not available when ToD required
if self.tod_enabled is True and self.network_connected is False:
self.mon.warn(
self,
'Network not connected so Time of Day scheduler may be using the internal clock'
)
# init the counter manager
self.counter_manager = CounterManager()
if self.starter_show['counters-store'] == 'yes':
store_enable = True
else:
store_enable = False
reason, message = self.counter_manager.init(
self.pp_profile + '/counters.cfg', store_enable,
self.options['loadcounters'],
self.starter_show['counters-initial'])
if reason == 'error':
self.mon.err(self, message)
self.end('error', message)
# warn about start shows and scheduler
if self.starter_show['start-show'] == '' and self.tod_enabled is False:
self.mon.sched(
self, None,
"No Start Shows in Start Show and no shows scheduled")
self.mon.warn(
self, "No Start Shows in Start Show and no shows scheduled")
if self.starter_show['start-show'] != '' and self.tod_enabled is True:
self.mon.sched(
self, None,
"Start Shows in Start Show and shows scheduled - conflict?")
self.mon.warn(
self,
"Start Shows in Start Show and shows scheduled - conflict?")
# run the start shows
self.run_start_shows()
# kick off the time of day scheduler which may run additional shows
if self.tod_enabled is True:
self.tod.poll()
# start the I/O plugins input event generation
self.ioplugin_manager.start()
# start Tkinters event loop
self.root.mainloop()
# *********************
# RUN START SHOWS
# ********************
def run_start_shows(self):
self.mon.trace(self, 'run start shows')
# parse the start shows field and start the initial shows
show_refs = self.starter_show['start-show'].split()
for show_ref in show_refs:
reason, message = self.show_manager.control_a_show(
show_ref, 'open')
if reason == 'error':
self.mon.err(self, message)
# *********************
# User inputs
# ********************
def e_osc_handle_animate(self, line):
#jump out of server thread
self.root.after(1, lambda arg=line: self.osc_handle_animate(arg))
def osc_handle_animate(self, line):
self.mon.log(self, "animate command received: " + line)
#osc sends output events as a string
reason, message, delay, name, param_type, param_values = self.animate.parse_animate_fields(
line)
if reason == 'error':
self.mon.err(self, message)
self.end(reason, message)
self.handle_output_event(name, param_type, param_values, 0)
# output events are animate commands
def handle_output_event(self, symbol, param_type, param_values, req_time):
reason, message = self.ioplugin_manager.handle_output_event(
symbol, param_type, param_values, req_time)
if reason == 'error':
self.mon.err(self, message)
self.end(reason, message)
# all input events call this callback providing a symbolic name.
# handle events that affect PP overall, otherwise pass to all active shows
def handle_input_event(self, symbol, source):
self.mon.log(self, "event received: " + symbol + ' from ' + source)
if symbol == 'pp-terminate':
self.handle_user_abort()
elif symbol == 'pp-shutdown':
self.mon.err(
self,
'pp-shutdown removed in version 1.3.3a, see Release Notes')
self.end(
'error',
'pp-shutdown removed in version 1.3.3a, see Release Notes')
elif symbol == 'pp-shutdownnow':
# need root.after to grt out of st thread
self.root.after(1, self.shutdownnow_pressed)
return
elif symbol == 'pp-exitpipresents':
self.exitpipresents_required = True
if self.show_manager.all_shows_exited() is True:
# need root.after to grt out of st thread
self.root.after(1, self.e_all_shows_ended_callback)
return
reason, message = self.show_manager.exit_all_shows()
else:
# pass the input event to all registered shows
for show in self.show_manager.shows:
show_obj = show[ShowManager.SHOW_OBJ]
if show_obj is not None:
show_obj.handle_input_event(symbol)
# commands are generated by tracks and shows
# they can open or close shows, generate input events and do special tasks
# commands also generate osc outputs to other computers
# handles one command provided as a line of text
def handle_command(self, command_text, source='', show=''):
# print 'PIPRESENTS ',command_text,'\n Source',source,'from',show
self.mon.log(self, "command received: " + command_text)
if command_text.strip() == "":
return
fields = command_text.split()
if fields[0] in ('osc', 'OSC'):
if self.osc_enabled is True:
status, message = self.oscdriver.parse_osc_command(fields[1:])
if status == 'warn':
self.mon.warn(self, message)
if status == 'error':
self.mon.err(self, message)
self.end('error', message)
return
else:
return
if fields[0] == 'counter':
status, message = self.counter_manager.parse_counter_command(
fields[1:])
if status == 'error':
self.mon.err(self, message)
self.end('error', message)
return
if fields[0] == 'beep':
# cheat, field 0 will always be beep
message, fields = self.beepsmanager.parse_beep(command_text)
if message != '':
self.mon.err(self, message)
self.end('error', message)
return
location = self.beepsmanager.complete_path(fields[1])
if not os.path.exists(location):
message = 'Beep file does not exist: ' + location
self.mon.err(self, message)
self.end('error', message)
return
else:
self.beepsmanager.do_beep(location)
return
show_command = fields[0]
if len(fields) > 1:
show_ref = fields[1]
else:
show_ref = ''
if show_command in ('open', 'close', 'closeall', 'openexclusive'):
self.mon.sched(self, TimeOfDay.now,
command_text + ' received from show:' + show)
if self.shutdown_required is False and self.terminate_required is False:
reason, message = self.show_manager.control_a_show(
show_ref, show_command)
else:
return
elif show_command == 'monitor':
self.handle_monitor_command(show_ref)
return
elif show_command == 'cec':
self.handle_cec_command(show_ref)
return
elif show_command == 'event':
self.handle_input_event(show_ref, 'Show Control')
return
elif show_command == 'exitpipresents':
self.exitpipresents_required = True
if self.show_manager.all_shows_exited() is True:
# need root.after to get out of st thread
self.root.after(1, self.e_all_shows_ended_callback)
return
else:
reason, message = self.show_manager.exit_all_shows()
elif show_command == 'shutdownnow':
# need root.after to get out of st thread
self.root.after(1, self.shutdownnow_pressed)
return
elif show_command == 'reboot':
# need root.after to get out of st thread
self.root.after(1, self.reboot_pressed)
return
else:
reason = 'error'
message = 'command not recognised: ' + show_command
if reason == 'error':
self.mon.err(self, message)
return
def handle_monitor_command(self, command):
if command == 'on':
os.system('vcgencmd display_power 1 >/dev/null')
elif command == 'off':
os.system('vcgencmd display_power 0 >/dev/null')
def handle_cec_command(self, command):
if command == 'on':
os.system('echo "on 0" | cec-client -s')
elif command == 'standby':
os.system('echo "standby 0" | cec-client -s')
elif command == 'scan':
os.system('echo scan | cec-client -s -d 1')
# deal with differnt commands/input events
def shutdownnow_pressed(self):
self.shutdown_required = True
if self.show_manager.all_shows_exited() is True:
self.all_shows_ended_callback('normal', 'no shows running')
else:
# calls exit method of all shows, results in all_shows_closed_callback
self.show_manager.exit_all_shows()
def reboot_pressed(self):
self.reboot_required = True
if self.show_manager.all_shows_exited() is True:
self.all_shows_ended_callback('normal', 'no shows running')
else:
# calls exit method of all shows, results in all_shows_closed_callback
self.show_manager.exit_all_shows()
def handle_sigterm(self, signum, fframe):
self.mon.log(self, 'SIGTERM received - ' + str(signum))
self.terminate()
def handle_user_abort(self):
self.mon.log(self, 'User abort received')
self.terminate()
def terminate(self):
self.mon.log(self, "terminate received")
self.terminate_required = True
needs_termination = False
for show in self.show_manager.shows:
# print show[ShowManager.SHOW_OBJ], show[ShowManager.SHOW_REF]
if show[ShowManager.SHOW_OBJ] is not None:
needs_termination = True
self.mon.log(
self,
"Sent terminate to show " + show[ShowManager.SHOW_REF])
# call shows terminate method
# eventually the show will exit and after all shows have exited all_shows_callback will be executed.
show[ShowManager.SHOW_OBJ].terminate()
if needs_termination is False:
self.end('killed', 'killed - no termination of shows required')
# ******************************
# Ending Pi Presents after all the showers and players are closed
# **************************
def e_all_shows_ended_callback(self):
self.all_shows_ended_callback('normal', 'no shows running')
# callback from ShowManager when all shows have ended
def all_shows_ended_callback(self, reason, message):
for display_name in DisplayManager.display_map:
status, message, display_id, canvas_obj = self.dm.id_of_canvas(
display_name)
if status != 'normal':
continue
canvas_obj.config(bg=self.starter_show['background-colour'])
if reason in (
'killed', 'error'
) or self.shutdown_required is True or self.exitpipresents_required is True or self.reboot_required is True:
self.end(reason, message)
def end(self, reason, message):
self.mon.log(self, "Pi Presents ending with reason: " + reason)
if self.root is not None:
self.root.destroy()
self.tidy_up()
if reason == 'killed':
if self.email_enabled is True and self.mailer.email_on_terminate is True:
subject = '[Pi Presents] ' + self.unit + ': PP Exited with reason: Terminated'
message = time.strftime(
"%Y-%m-%d %H:%M"
) + '\n ' + self.unit + '\n ' + self.interface + '\n ' + self.ip
self.send_email(reason, subject, message)
self.mon.sched(self, None, "Pi Presents Terminated, au revoir\n")
self.mon.log(self, "Pi Presents Terminated, au revoir")
# close logging files
self.mon.finish()
print('Uncollectable Garbage', gc.collect())
# objgraph.show_backrefs(objgraph.by_type('Canvas'),filename='backrefs.png')
sys.exit(101)
elif reason == 'error':
if self.email_enabled is True and self.mailer.email_on_error is True:
subject = '[Pi Presents] ' + self.unit + ': PP Exited with reason: Error'
message_text = 'Error message: ' + message + '\n' + time.strftime(
"%Y-%m-%d %H:%M"
) + '\n ' + self.unit + '\n ' + self.interface + '\n ' + self.ip
self.send_email(reason, subject, message_text)
self.mon.sched(self, None,
"Pi Presents closing because of error, sorry\n")
self.mon.log(self, "Pi Presents closing because of error, sorry")
# close logging files
self.mon.finish()
print('uncollectable garbage', gc.collect())
sys.exit(102)
else:
self.mon.sched(self, None, "Pi Presents exiting normally, bye\n")
self.mon.log(self, "Pi Presents exiting normally, bye")
# close logging files
self.mon.finish()
if self.reboot_required is True:
# print 'REBOOT'
call(['sudo', 'reboot'])
if self.shutdown_required is True:
# print 'SHUTDOWN'
call(['sudo', 'shutdown', 'now', 'SHUTTING DOWN'])
print('uncollectable garbage', gc.collect())
sys.exit(100)
# tidy up all the peripheral bits of Pi Presents
def tidy_up(self):
self.handle_monitor_command('on')
self.mon.log(self, "Tidying Up")
# turn screen blanking back on
if self.options['noblank'] is True:
call(["xset", "s", "on"])
call(["xset", "s", "+dpms"])
# tidy up animation
if self.animate is not None:
self.animate.terminate()
# tidy up i/o plugins
if self.ioplugin_manager != None:
self.ioplugin_manager.terminate()
if self.osc_enabled is True:
self.oscdriver.terminate()
# tidy up time of day scheduler
if self.tod_enabled is True:
self.tod.terminate()
# *******************************
# Connecting to network and email
# *******************************
def init_network(self):
timeout = int(self.options['nonetwork'])
if timeout == 0:
self.network_connected = False
self.unit = ''
self.ip = ''
self.interface = ''
return
self.network = Network()
self.network_connected = False
# try to connect to network
self.mon.log(self,
'Waiting up to ' + str(timeout) + ' seconds for network')
success = self.network.wait_for_network(timeout)
if success is False:
self.mon.warn(
self, 'Failed to connect to network after ' + str(timeout) +
' seconds')
# tkMessageBox.showwarning("Pi Presents","Failed to connect to network so using fake-hwclock")
return
self.network_connected = True
self.mon.sched(
self, None, 'Time after network check is ' +
time.strftime("%Y-%m-%d %H:%M.%S"))
self.mon.log(
self, 'Time after network check is ' +
time.strftime("%Y-%m-%d %H:%M.%S"))
# Get web configuration
self.network_details = False
network_options_file_path = self.pp_dir + os.sep + 'pp_config' + os.sep + 'pp_web.cfg'
if not os.path.exists(network_options_file_path):
self.mon.warn(
self, "pp_web.cfg not found at " + network_options_file_path)
return
self.mon.log(self, 'Found pp_web.cfg in ' + network_options_file_path)
self.network.read_config(network_options_file_path)
self.unit = self.network.unit
# get interface and IP details of preferred interface
self.interface, self.ip = self.network.get_preferred_ip()
if self.interface == '':
self.network_connected = False
return
self.network_details = True
self.mon.log(
self, 'Network details ' + self.unit + ' ' + self.interface + ' ' +
self.ip)
def init_mailer(self):
self.email_enabled = False
email_file_path = self.pp_dir + os.sep + 'pp_config' + os.sep + 'pp_email.cfg'
if not os.path.exists(email_file_path):
self.mon.log(self, 'pp_email.cfg not found at ' + email_file_path)
return
self.mon.log(self, 'Found pp_email.cfg at ' + email_file_path)
self.mailer = Mailer()
self.mailer.read_config(email_file_path)
# all Ok so can enable email if config file allows it.
if self.mailer.email_allowed is True:
self.email_enabled = True
self.mon.log(self, 'Email Enabled')
def try_connect(self):
tries = 1
while True:
success, error = self.mailer.connect()
if success is True:
return True
else:
self.mon.log(
self, 'Failed to connect to email SMTP server ' +
str(tries) + '\n ' + str(error))
tries += 1
if tries > 5:
self.mon.log(
self, 'Failed to connect to email SMTP server after ' +
str(tries))
return False
def send_email(self, reason, subject, message):
if self.try_connect() is False:
return False
else:
success, error = self.mailer.send(subject, message)
if success is False:
self.mon.log(self, 'Failed to send email: ' + str(error))
success, error = self.mailer.disconnect()
if success is False:
self.mon.log(self,
'Failed disconnect after send:' + str(error))
return False
else:
self.mon.log(self, 'Sent email for ' + reason)
success, error = self.mailer.disconnect()
if success is False:
self.mon.log(
self,
'Failed disconnect from email server ' + str(error))
return True
def __init__(self):
self.mon = Monitor()
self.dm = DisplayManager()
class ScreenDriver(object):
image_obj = []
def __init__(self):
self.mon = Monitor()
self.dm = DisplayManager()
# read screen.cfg
def read(self, pp_dir, pp_home, pp_profile):
self.pp_dir = pp_dir
self.pp_home = pp_home
# try inside profile
tryfile = pp_profile + os.sep + 'pp_io_config' + os.sep + 'screen.cfg'
# self.mon.log(self,"Trying screen.cfg in profile at: "+ tryfile)
if os.path.exists(tryfile):
filename = tryfile
else:
#give congiparser an empty filename so it returns an empty config.
filename = ''
ScreenDriver.config = configparser.ConfigParser(
inline_comment_prefixes=(';', ))
ScreenDriver.config.read(filename)
if filename != '':
self.mon.log(self, "screen.cfg read from " + filename)
return 'normal', 'screen.cfg read'
def click_areas(self):
return ScreenDriver.config.sections()
def get(self, section, item):
return ScreenDriver.config.get(section, item)
def is_in_config(self, section, item):
return ScreenDriver.config.has_option(section, item)
def parse_displays(self, text):
return text.split(' ')
# make click areas on the screen, bind them to their symbolic name, and create a callback if it is clicked.
# click areas must be polygon as outline rectangles are not filled as far as find_closest goes
# canvas is the PiPresents canvas
def make_click_areas(self, callback):
self.callback = callback
reason = ''
ScreenDriver.image_obj = []
for area in self.click_areas():
if not self.is_in_config(area, 'displays'):
reason = 'error'
message = 'missing displays field in screen.cfg'
break
displays_list = self.parse_displays(self.get(area, 'displays'))
# print ('\n\n',displays_list)
reason, message, points = self.parse_points(
self.get(area, 'points'), self.get(area, 'name'))
if reason == 'error':
break
# calculate centre of polygon
vertices = len(points) // 2
# print area, 'vertices',vertices
sum_x = 0
sum_y = 0
for i in range(0, vertices):
# print i
sum_x = sum_x + int(points[2 * i])
# print int(points[2*i])
sum_y = sum_y + int(points[2 * i + 1])
# print int(points[2*i+1])
polygon_centre_x = sum_x / vertices
polygon_centre_y = sum_y / vertices
for display_name in DisplayManager.display_map:
if display_name in displays_list:
status, message, display_id, canvas = self.dm.id_of_canvas(
display_name)
if status != 'normal':
continue
canvas.create_polygon(
points,
fill=self.get(area, 'fill-colour'),
outline=self.get(area, 'outline-colour'),
tags=("pp-click-area", self.get(area, 'name')),
state='hidden')
# image for the button
if not self.is_in_config(area, 'image'):
reason = 'error'
message = 'missing image fields in screen.cfg'
break
image_name = self.get(area, 'image')
if image_name != '':
image_width = int(self.get(area, 'image-width'))
image_height = int(self.get(area, 'image-height'))
image_path = self.complete_path(image_name)
if os.path.exists(image_path) is True:
self.pil_image = Image.open(image_path)
else:
image_path = self.pp_dir + os.sep + 'pp_resources' + os.sep + 'button.jpg'
if os.path.exists(image_path) is True:
self.mon.warn(
self,
'Default button image used for ' + area)
self.pil_image = Image.open(image_path)
else:
self.mon.warn(
self,
'Button image does not exist for ' + area)
self.pil_image = None
if self.pil_image is not None:
self.pil_image = self.pil_image.resize(
(image_width - 1, image_height - 1))
photo_image_id = ImageTk.PhotoImage(self.pil_image)
# print (display_id, canvas,self.pil_image,photo_image_id,self.get(area,'name'))
image_id = canvas.create_image(
polygon_centre_x,
polygon_centre_y,
image=photo_image_id,
anchor=CENTER,
tags=('pp-click-area', self.get(area, 'name')),
state='hidden')
del self.pil_image
ScreenDriver.image_obj.append(photo_image_id)
# print (ScreenDriver.image_obj)
# write the label at the centroid
if self.get(area, 'text') != '':
canvas.create_text(polygon_centre_x,
polygon_centre_y,
text=self.get(area, 'text'),
fill=self.get(area, 'text-colour'),
font=self.get(area, 'text-font'),
tags=('pp-click-area',
self.get(area, 'name')),
state='hidden')
canvas.bind('<Button-1>', self.click_pressed)
if reason == 'error':
return 'error', message
else:
return 'normal', 'made click areas'
# callback for click on screen
def click_pressed(self, event):
x = event.x
y = event.y
# fail to correct the pointer position on touch so set for mouse click
# x,y,text=self.dm.correct_touchscreen_pointer(event,0,False)
overlapping = event.widget.find_overlapping(x - 5, y - 5, x + 5, y + 5)
for item in overlapping:
# print ScreenDriver.canvas.gettags(item)
if ('pp-click-area'
in event.widget.gettags(item)) and event.widget.itemcget(
item, 'state') == 'normal':
self.mon.log(
self, "Click on screen: " + event.widget.gettags(item)[1])
self.callback(event.widget.gettags(item)[1], 'SCREEN')
# need break as find_overlapping returns two results for each click, one with 'current' one without.
break
def is_click_area(self, test_area, canvas):
click_areas = canvas.find_withtag('pp-click-area')
for area in click_areas:
if test_area in canvas.gettags(area):
return True
return False
# use links with the symbolic name of click areas to enable the click areas in a show
def enable_click_areas(self, links, canvas):
for link in links:
if self.is_click_area(link[0], canvas) and link[1] != 'null':
# print 'enabling link ',link[0]
canvas.itemconfig(link[0], state='normal')
def hide_click_areas(self, links, canvas):
# hide click areas
for link in links:
if self.is_click_area(link[0], canvas) and link[1] != 'null':
# print 'disabling link ',link[0]
canvas.itemconfig(link[0], state='hidden')
# this does not seem to change the colour of the polygon
# ScreenDriver.canvas.itemconfig('pp-click-area',state='hidden')
canvas.update_idletasks()
def parse_points(self, points_text, area):
if points_text.strip() == '':
return 'error', 'No points in click area: ' + area, []
if '+' in points_text:
# parse x+y+width*height
fields = points_text.split('+')
if len(fields) != 3:
return 'error','Do not understand click area points: '+area,[]
dimensions = fields[2].split('*')
if len(dimensions) != 2:
return 'error','Do not understand click area points: '+area,[]
if not fields[0].isdigit():
return 'error','x1 is not a positive integer in click area: '+area,[]
else:
x1 = int(fields[0])
if not fields[1].isdigit():
return 'error','y1 is not a positive integer in click area: '+area,[]
else:
y1 = int(fields[1])
if not dimensions[0].isdigit():
return 'error','width1 is not a positive integer in click area: '+area,[]
else:
width = int(dimensions[0])
if not dimensions[1].isdigit():
return 'error','height is not a positive integer in click area: '+area,[]
else:
height = int(dimensions[1])
return 'normal', '', [
str(x1),
str(y1),
str(x1 + width),
str(y1),
str(x1 + width),
str(y1 + height),
str(x1),
str(y1 + height)
]
else:
# parse unlimited set of x,y,coords
points = points_text.split()
if len(points) < 6:
return 'error','Less than 3 vertices in click area: '+area,[]
if len(points) % 2 != 0:
return 'error','Odd number of points in click area: '+area,[]
for point in points:
if not point.isdigit():
return 'error','point is not a positive integer in click area: '+area,[]
return 'normal', 'parsed points OK', points
def complete_path(self, track_file):
# complete path of the filename of the selected entry
if track_file != '' and track_file[0] == "+":
track_file = self.pp_home + track_file[1:]
elif track_file[0] == "@":
track_file = self.pp_profile + track_file[1:]
return track_file
class ShowManager(object):
"""
ShowManager manages PiPresents' concurrent shows. It does not manage sub-shows or child-shows but has a bit of common code to initilise them
concurrent shows are always top level (level 0) shows:
They can be opened/closed by the start show(open only) or by 'open/close myshow' in the Show Control field of players, by time of day sceduler or by OSC
Two shows with the same show reference cannot be run concurrently as there is no way to reference an individual instance.
However a workaround is to make the secong instance a subshow of a mediashow with a different reference.
"""
# Declare class variables
shows = []
canvas = None #canvas for all shows
shutdown_required = False
SHOW_TEMPLATE = ['', None]
SHOW_REF = 0 # show-reference - name of the show as in editor
SHOW_OBJ = 1 # the python object
showlist = []
# Initialise class variables, first time through only in pipresents.py
def init(self, all_shows_ended_callback, command_callback, showlist):
ShowManager.all_shows_ended_callback = all_shows_ended_callback
ShowManager.shows = []
ShowManager.shutdown_required = False
ShowManager.command_callback = command_callback
ShowManager.showlist = showlist
# **************************************
# functions to manipulate show register
# **************************************
def register_shows(self):
for show in ShowManager.showlist.shows():
if show['show-ref'] != 'start':
reason, message = self.register_show(show['show-ref'])
if reason == 'error':
return reason, message
return 'normal', 'shows regiistered'
def register_show(self, ref):
registered = self.show_registered(ref)
if registered == -1:
ShowManager.shows.append(copy.deepcopy(ShowManager.SHOW_TEMPLATE))
index = len(ShowManager.shows) - 1
ShowManager.shows[index][ShowManager.SHOW_REF] = ref
ShowManager.shows[index][ShowManager.SHOW_OBJ] = None
self.mon.trace(
self, ' - register show: show_ref = ' + ref + ' index = ' +
str(index))
return 'normal', 'show registered'
else:
# self.mon.err(self, ' more than one show in showlist with show-ref: ' + ref )
return 'error', ' more than one show in showlist with show-ref: ' + ref
# is the show registered?
# can be used to return the index to the show
def show_registered(self, show_ref):
index = 0
for show in ShowManager.shows:
if show[ShowManager.SHOW_REF] == show_ref:
return index
index += 1
return -1
# needs calling program to check that the show is not already running
def set_running(self, index, show_obj):
ShowManager.shows[index][ShowManager.SHOW_OBJ] = show_obj
self.mon.trace(
self,
'show_ref= ' + ShowManager.shows[index][ShowManager.SHOW_REF] +
' show_id= ' + str(index))
# is the show running?
def show_running(self, index):
if ShowManager.shows[index][ShowManager.SHOW_OBJ] is not None:
return ShowManager.shows[index][ShowManager.SHOW_OBJ]
else:
return None
def set_exited(self, index):
ShowManager.shows[index][ShowManager.SHOW_OBJ] = None
self.mon.trace(
self,
'show_ref= ' + ShowManager.shows[index][ShowManager.SHOW_REF] +
' show_id= ' + str(index))
# are all shows exited?
def all_shows_exited(self):
all_exited = True
for show in ShowManager.shows:
if show[ShowManager.SHOW_OBJ] is not None:
all_exited = False
return all_exited
# fromat for printing
def pretty_shows(self):
shows = '\n'
for show in ShowManager.shows:
shows += show[ShowManager.SHOW_REF] + '\n'
return shows
# *********************************
# show control
# *********************************
# show manager can be initialised by a player, shower or by pipresents.py
# if by pipresents.py then show_id=-1
def __init__(self, show_id, showlist, show_params, root, pp_dir,
pp_profile, pp_home):
self.show_id = show_id
self.showlist = showlist
self.show_params = show_params
self.root = root
self.pp_dir = pp_dir
self.pp_profile = pp_profile
self.pp_home = pp_home
self.dm = DisplayManager()
self.mon = Monitor()
def control_a_show(self, show_ref, show_command):
if show_command == 'open':
return self.start_show(show_ref)
elif show_command == 'close':
return self.exit_show(show_ref)
elif show_command == 'closeall':
return self.exit_all_shows()
elif show_command == 'openexclusive':
return self.open_exclusive(show_ref)
else:
return 'error', 'command not recognised ' + show_command
def open_exclusive(self, show_ref):
self.exit_all_shows()
self.exclusive_show = show_ref
self.wait_for_openexclusive()
return 'normal', 'opened exclusive'
def wait_for_openexclusive(self):
if self.all_shows_exited() is False:
self.root.after(1, self.wait_for_openexclusive)
return
self.start_show(self.exclusive_show)
def exit_all_shows(self):
for show in ShowManager.shows:
self.exit_show(show[ShowManager.SHOW_REF])
return 'normal', 'exited all shows'
# kick off the exit sequence of a show by calling the shows exit method.
# it will result in all the shows in a stack being closed and end_play_show being called
def exit_show(self, show_ref):
index = self.show_registered(show_ref)
self.mon.log(
self,
"De-registering show " + show_ref + ' show index:' + str(index))
show_obj = self.show_running(index)
if show_obj is not None:
self.mon.log(
self, "Exiting show " + show_ref + ' show index:' + str(index))
show_obj.exit()
return 'normal', 'exited a concurrent show'
def start_show(self, show_ref):
index = self.show_registered(show_ref)
if index < 0:
return 'error', "Show not found in showlist: " + show_ref
show_index = self.showlist.index_of_show(show_ref)
show = self.showlist.show(show_index)
reason, message, show_canvas = self.compute_show_canvas(show)
if reason == 'error':
return reason, message
# print 'STARTING TOP LEVEL SHOW',show_canvas
self.mon.sched(
self, TimeOfDay.now, 'Starting Show: ' + show_ref +
' from show: ' + self.show_params['show-ref'])
self.mon.log(
self, 'Starting Show: ' + show_ref + ' from: ' +
self.show_params['show-ref'])
if self.show_running(index):
self.mon.sched(
self, TimeOfDay.now,
"show already running so ignoring command: " + show_ref)
self.mon.warn(
self, "show already running so ignoring command: " + show_ref)
return 'normal', 'this concurrent show already running'
show_obj = self.init_show(index, show, show_canvas)
if show_obj is None:
return 'error', "unknown show type in start concurrent show - " + show[
'type']
else:
self.set_running(index, show_obj)
# params - end_callback, show_ready_callback, parent_kickback_signal, level
show_obj.play(self._end_play_show, None, False, 0, [])
return 'normal', 'concurrent show started'
# used by shows to create subshows or child shows
def init_subshow(self, show_id, show, show_canvas):
return self.init_show(show_id, show, show_canvas)
def _end_play_show(self, index, reason, message):
show_ref_to_exit = ShowManager.shows[index][ShowManager.SHOW_REF]
show_to_exit = ShowManager.shows[index][ShowManager.SHOW_OBJ]
self.mon.sched(self, TimeOfDay.now, 'Closed show: ' + show_ref_to_exit)
self.mon.log(
self, 'Exited from show: ' + show_ref_to_exit + ' ' + str(index))
self.mon.log(self, 'Exited with Reason = ' + reason)
self.mon.trace(
self,
' Show is: ' + show_ref_to_exit + ' show index ' + str(index))
# closes the video/audio from last track then closes the track
# print 'show to exit ',show_to_exit, show_to_exit.current_player,show_to_exit.previous_player
self.set_exited(index)
if self.all_shows_exited() is True:
ShowManager.all_shows_ended_callback(reason, message)
return reason, message
# common function to initilaise the show by type
def init_show(
self,
show_id,
selected_show,
show_canvas,
):
if selected_show['type'] == "mediashow":
return MediaShow(show_id, selected_show, self.root, show_canvas,
self.showlist, self.pp_dir, self.pp_home,
self.pp_profile, ShowManager.command_callback)
elif selected_show['type'] == "liveshow":
return LiveShow(show_id, selected_show, self.root, show_canvas,
self.showlist, self.pp_dir, self.pp_home,
self.pp_profile, ShowManager.command_callback)
elif selected_show['type'] == "radiobuttonshow":
return RadioButtonShow(show_id, selected_show, self.root,
show_canvas, self.showlist, self.pp_dir,
self.pp_home, self.pp_profile,
ShowManager.command_callback)
elif selected_show['type'] == "hyperlinkshow":
return HyperlinkShow(show_id, selected_show, self.root,
show_canvas, self.showlist, self.pp_dir,
self.pp_home, self.pp_profile,
ShowManager.command_callback)
elif selected_show['type'] == "menu":
return MenuShow(show_id, selected_show, self.root, show_canvas,
self.showlist, self.pp_dir, self.pp_home,
self.pp_profile, ShowManager.command_callback)
elif selected_show['type'] == "artmediashow":
return ArtMediaShow(show_id, selected_show, self.root, show_canvas,
self.showlist, self.pp_dir, self.pp_home,
self.pp_profile, ShowManager.command_callback)
elif selected_show['type'] == "artliveshow":
return ArtLiveShow(show_id, selected_show, self.root, show_canvas,
self.showlist, self.pp_dir, self.pp_home,
self.pp_profile, ShowManager.command_callback)
else:
return None
def compute_show_canvas(self, show_params):
canvas = {}
display_name = show_params['display-name']
status, message, self.display_id, canvas_obj = self.dm.id_of_canvas(
display_name)
if status != 'normal':
return 'error', message, None
canvas['canvas-obj'] = canvas_obj
status, message, self.show_canvas_x1, self.show_canvas_y1, self.show_canvas_x2, self.show_canvas_y2 = self.parse_show_canvas(
show_params['show-canvas'])
if status == 'error':
return 'error', 'show canvas error: ' + message + ' in ' + show_params[
'show-canvas'], None
else:
self.show_canvas_width = self.show_canvas_x2 - self.show_canvas_x1
self.show_canvas_height = self.show_canvas_y2 - self.show_canvas_y1
self.show_canvas_centre_x = self.show_canvas_width / 2
self.show_canvas_centre_y = self.show_canvas_height / 2
canvas['show-canvas-x1'] = self.show_canvas_x1
canvas['show-canvas-y1'] = self.show_canvas_y1
canvas['show-canvas-x2'] = self.show_canvas_x2
canvas['show-canvas-y2'] = self.show_canvas_y2
canvas['show-canvas-width'] = self.show_canvas_width
canvas['show-canvas-height'] = self.show_canvas_height
canvas['show-canvas-centre-x'] = self.show_canvas_centre_x
canvas['show-canvas-centre-y'] = self.show_canvas_centre_y
canvas['display-name'] = display_name
canvas['display-id'] = self.display_id
return 'normal', '', canvas
def parse_show_canvas(self, text):
fields = text.split()
# blank so show canvas is the whole screen
if len(fields) < 1:
#get canvas dimensions from the display manager
width, height = self.dm.canvas_dimensions(self.display_id)
return 'normal', '', 0, 0, width, height
elif len(fields) in (1, 4):
# window is specified
status, message, x1, y1, x2, y2 = parse_rectangle(text)
if status == 'error':
return 'error', message, 0, 0, 0, 0
else:
return 'normal', '', x1, y1, x2, y2
else:
# error
return 'error', 'Wrong number of fields in Show canvas: ' + text, 0, 0, 0, 0
def __init__(self, show_id, showlist, root, canvas, show_params,
track_params, pp_dir, pp_home, pp_profile, end_callback,
command_callback):
# initialise items common to all players
Player.__init__(self, show_id, showlist, root, canvas, show_params,
track_params, pp_dir, pp_home, pp_profile,
end_callback, command_callback)
self.mon.trace(self, '')
self.dm = DisplayManager()
self.am = AudioManager()
# get player parameters from show/track
if self.track_params['vlc-audio'] != "":
self.vlc_audio = self.track_params['vlc-audio']
else:
self.vlc_audio = self.show_params['vlc-audio']
if self.track_params['vlc-volume'] != "":
self.vlc_volume_text = self.track_params['vlc-volume']
else:
self.vlc_volume_text = self.show_params['vlc-volume']
if self.track_params['vlc-window'] != '':
self.vlc_window_text = self.track_params['vlc-window']
else:
self.vlc_window_text = self.show_params['vlc-window']
if self.track_params['vlc-aspect-mode'] != '':
self.vlc_aspect_mode = self.track_params['vlc-aspect-mode']
else:
self.vlc_aspect_mode = self.show_params['vlc-aspect-mode']
if self.track_params['vlc-image-duration'] != '':
self.vlc_image_duration_text = self.track_params[
'vlc-image-duration']
else:
self.vlc_image_duration_text = self.show_params[
'vlc-image-duration']
if self.track_params['vlc-other-options'] != '':
self.vlc_other_options = self.track_params['vlc-other-options']
else:
self.vlc_other_options = self.show_params['vlc-other-options']
if self.track_params['vlc-layer'] != '':
self.vlc_layer_text = self.track_params['vlc-layer']
else:
self.vlc_layer_text = self.show_params['vlc-layer']
if self.track_params['vlc-freeze-at-start'] != '':
self.freeze_at_start_text = self.track_params[
'vlc-freeze-at-start']
else:
self.freeze_at_start_text = self.show_params['vlc-freeze-at-start']
if self.track_params['vlc-freeze-at-end'] != '':
self.freeze_at_end_text = self.track_params['vlc-freeze-at-end']
else:
self.freeze_at_end_text = self.show_params['vlc-freeze-at-end']
if self.track_params['pause-timeout'] != '':
pause_timeout_text = self.track_params['pause-timeout']
else:
pause_timeout_text = self.show_params['pause-timeout']
if pause_timeout_text.isdigit():
self.pause_timeout = int(pause_timeout_text)
else:
self.pause_timeout = 0
# track only
self.vlc_subtitles = self.track_params['vlc-subtitles']
self.vlc_max_volume_text = self.track_params['vlc-max-volume']
self.vlc_aspect_ratio = self.track_params['vlc-aspect-ratio']
self.vlc_crop = self.track_params['vlc-crop']
# initialise video playing state and signals
self.quit_signal = False
self.unload_signal = False
self.play_state = 'initialised'
self.frozen_at_end = False
self.pause_timer = None
class VLCPlayer(Player):
"""
plays a track using VLCDriver to access VLC via libvlc
_init_ iniitalises state and checks resources are available.
use the returned instance reference in all other calls.
At the end of the path (when closed) do not re-use, make instance= None and start again.
States - 'initialised' when done successfully.
"""
debug = False
debug = True
def __init__(self, show_id, showlist, root, canvas, show_params,
track_params, pp_dir, pp_home, pp_profile, end_callback,
command_callback):
# initialise items common to all players
Player.__init__(self, show_id, showlist, root, canvas, show_params,
track_params, pp_dir, pp_home, pp_profile,
end_callback, command_callback)
self.mon.trace(self, '')
self.dm = DisplayManager()
self.am = AudioManager()
# get player parameters from show/track
if self.track_params['vlc-audio'] != "":
self.vlc_audio = self.track_params['vlc-audio']
else:
self.vlc_audio = self.show_params['vlc-audio']
if self.track_params['vlc-volume'] != "":
self.vlc_volume_text = self.track_params['vlc-volume']
else:
self.vlc_volume_text = self.show_params['vlc-volume']
if self.track_params['vlc-window'] != '':
self.vlc_window_text = self.track_params['vlc-window']
else:
self.vlc_window_text = self.show_params['vlc-window']
if self.track_params['vlc-aspect-mode'] != '':
self.vlc_aspect_mode = self.track_params['vlc-aspect-mode']
else:
self.vlc_aspect_mode = self.show_params['vlc-aspect-mode']
if self.track_params['vlc-image-duration'] != '':
self.vlc_image_duration_text = self.track_params[
'vlc-image-duration']
else:
self.vlc_image_duration_text = self.show_params[
'vlc-image-duration']
if self.track_params['vlc-other-options'] != '':
self.vlc_other_options = self.track_params['vlc-other-options']
else:
self.vlc_other_options = self.show_params['vlc-other-options']
if self.track_params['vlc-layer'] != '':
self.vlc_layer_text = self.track_params['vlc-layer']
else:
self.vlc_layer_text = self.show_params['vlc-layer']
if self.track_params['vlc-freeze-at-start'] != '':
self.freeze_at_start_text = self.track_params[
'vlc-freeze-at-start']
else:
self.freeze_at_start_text = self.show_params['vlc-freeze-at-start']
if self.track_params['vlc-freeze-at-end'] != '':
self.freeze_at_end_text = self.track_params['vlc-freeze-at-end']
else:
self.freeze_at_end_text = self.show_params['vlc-freeze-at-end']
if self.track_params['pause-timeout'] != '':
pause_timeout_text = self.track_params['pause-timeout']
else:
pause_timeout_text = self.show_params['pause-timeout']
if pause_timeout_text.isdigit():
self.pause_timeout = int(pause_timeout_text)
else:
self.pause_timeout = 0
# track only
self.vlc_subtitles = self.track_params['vlc-subtitles']
self.vlc_max_volume_text = self.track_params['vlc-max-volume']
self.vlc_aspect_ratio = self.track_params['vlc-aspect-ratio']
self.vlc_crop = self.track_params['vlc-crop']
# initialise video playing state and signals
self.quit_signal = False
self.unload_signal = False
self.play_state = 'initialised'
self.frozen_at_end = False
self.pause_timer = None
# LOAD - creates a VLC instance, loads a track and then pause
def load(self, track, loaded_callback, enable_menu):
# instantiate arguments
self.track = track
self.loaded_callback = loaded_callback #callback when loaded
self.mon.log(
self, "Load track received from show Id: " + str(self.show_id) +
' ' + self.track)
self.mon.trace(self, '')
#process vlc parameters
status, message = self.process_params()
if status == 'error':
self.mon.err(self, message)
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error', message)
return
#for pulse get sink name and check device is connected
self.audio_sys = self.am.get_audio_sys()
if self.audio_sys == 'pulse':
status, message, self.vlc_sink = self.am.get_sink(self.vlc_audio)
if status == 'error':
self.mon.err(self, message)
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error', message)
return
if not self.am.sink_connected(self.vlc_sink):
self.mon.err(
self, self.vlc_audio +
' audio device not connected\n\n sink: ' +
self.vlc_sink)
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error', 'audio device not connected')
return
else:
self.mon.err(
self,
'audio systems other than pulseaudio are not supported\n hint: audio.cfg error'
)
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error', 'audio device not connected')
return
# do common bits of load
Player.pre_load(self)
# load the plugin, this may modify self.track and enable the plugin drawing to canvas
if self.track_params['plugin'] != '':
status, message = self.load_plugin()
if status == 'error':
self.mon.err(self, message)
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error', message)
return
# load the images and text
status, message = self.load_x_content(enable_menu)
if status == 'error':
self.mon.err(self, message)
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error', message)
return
# check file exists if not a mrl
if not ':' in track:
if not os.path.exists(track):
self.mon.err(self, "Track file not found: " + track)
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error',
'track file not found: ' + track)
return
cmd = 'DISPLAY= python3 ' + self.pp_dir + '/pp_vlcdriver.py'
#print (cmd)
# need bash because of DISPLAY=
self.vlcdriver = pexpect.spawn('/bin/bash', ['-c', cmd],
encoding='utf-8')
# get rid of driver start message
start_message = self.vlcdriver.readline().strip('\r\n')
if start_message != 'VLCDriver starting':
self.mon.fatal(
self, "VLCDriver failed\n Hint: sudo pip3 install python-vlc ")
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error', 'VLCDriver starting')
return
self.vlcdriver.setecho(False)
self.vlcdriver.sendline('iopts' + self.iopts)
self.vlcdriver.sendline('pauseopts' + self.pauseopts)
self.vlcdriver.sendline('track ' + track)
# load the media
self.vlcdriver.sendline('load')
#get size of media, do after load and before play. Not used at the moment
self.media_width, self.media_height = self.get_size()
# calculate and send crop/aspect ratio and aspect mode. Done here as size might be needed in the future
status, message = self.aspect_mode()
if status != 'normal':
self.mon.err(self, message)
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error', 'track file not found: ' + track)
return
# play until pause at start
self.vlcdriver.sendline('play')
self.start_state_machine_load()
# SHOW - show a track
def show(self, ready_callback, finished_callback, closed_callback):
self.ready_callback = ready_callback # callback when paused after load ready to show video
self.finished_callback = finished_callback # callback when finished showing
self.closed_callback = closed_callback
self.mon.trace(self, '')
# do animation at start and ready_callback
Player.pre_show(self)
# start show state machine
self.start_state_machine_show()
# UNLOAD - abort a load when vlcdriver is loading or loaded
def unload(self):
self.mon.trace(self, '')
self.mon.log(self,
">unload received from show Id: " + str(self.show_id))
self.start_state_machine_unload()
# CLOSE - quits vlcdriver from 'pause at end' state
def close(self, closed_callback):
self.mon.trace(self, '')
self.mon.log(self,
">close received from show Id: " + str(self.show_id))
self.closed_callback = closed_callback
self.start_state_machine_close()
def get_size(self):
self.vlcdriver.sendline('get-size')
resp = self.vlcdriver.readline().strip('\r\n')
resp_list = resp.split(' ')
return resp_list[0], resp_list[1]
def get_state(self):
self.vlcdriver.sendline('t')
resp = self.vlcdriver.readline().strip('\r\n')
#print (resp)
return resp
# ***********************
# track showing state machine
# **********************
"""
STATES OF STATE MACHINE
Threre are ongoing states and states that are set just before callback
>init - Create an instance of the class
<On return - state = initialised - - init has been completed, do not generate errors here
>load
Fatal errors should be detected in load. If so loaded_callback is called with 'load-failed'
Ongoing - state=loading - load called, waiting for load to complete
< loaded_callback with status = normal
state=loaded - load has completed and video paused before or after first frame
<loaded_callback with status=error
state= load-failed - failure to load
On getting the loaded_callback with status=normal the track can be shown using show
>show
show assumes a track has been loaded and is paused.
Ongoing - state=showing - video is showing
<finished_callback with status = pause_at_end
state=showing but frozen_at_end is True
<closed_callback with status= normal
state = closed - video has ended vlc has terminated.
On getting finished_callback with status=pause_at end a new track can be shown and then use close to close the previous video when new track is ready
On getting closed_callback with status= nice_day vlcdriver closing should not be attempted as it is already closed
Do not generate user errors in Show. Only generate system errors such as illegal state and then use end()
>close
Ongoing state - closing - vlcdriver processes are dying
<closed_callback with status= normal - vlcdriver is dead, can close the track instance.
>unload
Ongoing states - start_unload and unloading - vlcdriver processes are dying.
when unloading is complete state=unloaded
I have not added a callback to unload. its easy to add one if you want.
closed is needed because wait_for_end in pp_show polls for closed and does not use closed_callback
"""
def start_state_machine_load(self):
# initialise all the state machine variables
self.play_state = 'loading'
#self.set_volume(self.volume)
self.tick_timer = self.canvas.after(1, self.load_state_machine) #50
def load_state_machine(self):
if self.unload_signal is True:
self.unload_signal = False
self.state = 'unloading'
self.vlcdriver.sendline('unload')
self.root.after(100, self.load_state_machine)
else:
resp = self.get_state()
# pp_vlcdriver changes state from load-loading when track is frozen at start.
if resp == 'load-fail':
self.play_state = 'load-failed'
self.mon.log(
self, " Entering state : " + self.play_state +
' from show Id: ' + str(self.show_id))
if self.loaded_callback is not None:
self.loaded_callback('error',
'timeout when loading vlc track')
return
elif resp == 'load-unloaded':
self.play_state = 'unloaded'
self.mon.log(
self, " Entering state : " + self.play_state +
' from show Id: ' + str(self.show_id))
# PP does not need this callback
#if self.loaded_callback is not None:
#self.loaded_callback('normal','unloaded')
return
elif resp in ('load-ok', 'stop-frozen'):
# stop received while in freeze-at-start - quit showing as soon as it starts
if resp == 'stop-frozen':
self.quit_signal = True
self.mon.log(self,
'stop received while in freeze-at-start')
self.play_state = 'loaded'
if self.vlc_sink != '':
self.set_device(self.vlc_sink)
else:
self.set_device('')
self.set_volume(self.volume)
self.mon.log(
self, " Entering state : " + self.play_state +
' from show Id: ' + str(self.show_id))
if self.loaded_callback is not None:
self.loaded_callback('normal', 'loaded')
return
else:
self.root.after(10, self.load_state_machine) #100
def start_state_machine_unload(self):
# print ('videoplayer - starting unload',self.play_state)
if self.play_state in ('closed', 'initialised', 'unloaded'):
# vlcdriver already closed
self.play_state = 'unloaded'
# print ' closed so no need to unload'
else:
if self.play_state == 'loaded':
# load already complete so set unload signal and kick off load state machine
self.play_state = 'start_unload'
self.unload_signal = True
self.tick_timer = self.canvas.after(50,
self.load_state_machine)
elif self.play_state == 'loading':
# signal load state machine to start_unloading state and stop vlcdriver
self.unload_signal = True
else:
self.mon.err(
self, 'illegal state in unload method: ' + self.play_state)
self.end('error',
'illegal state in unload method: ' + self.play_state)
def start_state_machine_show(self):
if self.play_state == 'loaded':
# print '\nstart show state machine ' + self.play_state
self.play_state = 'showing'
self.freeze_signal = False # signal that user has pressed stop
self.must_quit_signal = False
# show the track and content
self.vlcdriver.sendline('show')
self.mon.log(self,
'>showing track from show Id: ' + str(self.show_id))
self.set_volume(self.volume)
# and start polling for state changes
# print 'start show state machine show'
self.tick_timer = self.canvas.after(0, self.show_state_machine)
"""
# race condition don't start state machine as unload in progress
elif self.play_state == 'start_unload':
pass
"""
else:
self.mon.fatal(self,
'illegal state in show method ' + self.play_state)
self.play_state = 'show-failed'
if self.finished_callback is not None:
self.finished_callback(
'error',
'illegal state in show method: ' + self.play_state)
def show_state_machine(self):
if self.play_state == 'showing':
if self.quit_signal is True:
# service any queued stop signals by sending stop to vlcdriver
self.quit_signal = False
self.mon.log(self, " stop video - Send stop to vlcdriver")
self.vlcdriver.sendline('stop')
self.tick_timer = self.canvas.after(10,
self.show_state_machine)
else:
resp = self.get_state()
#print (resp)
# driver changes state from show-showing depending on freeze-at-end.
if resp == 'show-pauseatend':
self.mon.log(self, 'vlcdriver says pause_at_end')
self.frozen_at_end = True
if self.finished_callback is not None:
self.finished_callback('pause_at_end', 'pause at end')
elif resp == 'show-niceday':
self.mon.log(self, 'vlcdriver says nice_day')
self.play_state = 'closing'
self.vlcdriver.sendline('close')
# and terminate the vlcdriver process through pexpect
self.vlcdriver.terminate()
self.tick_timer = self.canvas.after(
10, self.show_state_machine)
elif resp == 'show-fail':
self.play_state = 'show-failed'
if self.finished_callback is not None:
self.finished_callback(
'error', 'pp_vlcdriver says show failed: ' +
self.play_state)
else:
self.tick_timer = self.canvas.after(
30, self.show_state_machine)
elif self.play_state == 'closing':
# close the pexpect process
self.vlcdriver.close()
self.play_state = 'closed'
# state change needed for wait for end
self.mon.log(
self, " Entering state : " + self.play_state +
' from show Id: ' + str(self.show_id))
if self.closed_callback is not None:
self.closed_callback('normal', 'vlcdriver closed')
# respond to normal stop
def stop(self):
self.mon.log(self, ">stop received from show Id: " + str(self.show_id))
# cancel the pause timer
if self.pause_timer != None:
self.canvas.after_cancel(self.pause_timer)
self.pause_timer = None
self.vlcdriver.sendline('stop')
def start_state_machine_close(self):
# self.mon.log(self,">close received from show Id: "+ str(self.show_id))
# cancel the pause timer
if self.pause_timer != None:
self.canvas.after_cancel(self.pause_timer)
self.pause_timer = None
self.vlcdriver.sendline('close')
self.play_state = 'closing'
#print ('start close state machine close')
self.tick_timer = self.canvas.after(0, self.show_state_machine)
# ************************
# COMMANDS
# ************************
def input_pressed(self, symbol):
if symbol == 'inc-volume':
self.inc_volume()
elif symbol == 'dec-volume':
self.dec_volume()
elif symbol == 'pause':
self.pause()
elif symbol == 'go':
self.go()
elif symbol == 'unmute':
self.unmute()
elif symbol == 'mute':
self.mute()
elif symbol == 'pause-on':
self.pause_on()
elif symbol == 'pause-off':
self.pause_off()
elif symbol == 'stop':
self.stop()
def inc_volume(self):
self.mon.log(self,
">inc-volume received from show Id: " + str(self.show_id))
if self.play_state == 'showing':
if self.volume < self.max_volume:
self.volume += 1
self.set_volume(self.volume)
return True
else:
self.mon.log(self, "!<inc-volume rejected " + self.play_state)
return False
def dec_volume(self):
self.mon.log(self,
">dec-volume received from show Id: " + str(self.show_id))
if self.play_state == 'showing':
if self.volume > 0:
self.volume -= 1
self.set_volume(self.volume)
return True
else:
self.mon.log(self, "!<dec-volume rejected " + self.play_state)
return False
def set_volume(self, vol):
# print ('SET VOLUME',vol)
self.vlcdriver.sendline('vol ' + str(vol))
def set_device(self, device):
self.vlcdriver.sendline('device ' + device)
def mute(self):
self.mon.log(self, ">mute received from show Id: " + str(self.show_id))
self.vlcdriver.sendline('mute')
return True
def unmute(self):
self.mon.log(self,
">unmute received from show Id: " + str(self.show_id))
self.vlcdriver.sendline('unmute')
# toggle pause
def pause(self):
self.mon.log(
self, ">toggle pause received from show Id: " + str(self.show_id))
self.vlcdriver.sendline('pause')
reply = self.vlcdriver.readline().strip('\r\n')
if reply == 'pause-on-ok':
if self.pause_timeout > 0:
# kick off the pause timeout timer
self.pause_timer = self.canvas.after(
self.pause_timeout * 1000, self.pause_timeout_callback)
return True
elif reply == 'pause-off-ok':
if self.pause_timer != None:
# cancel the pause timer
self.canvas.after_cancel(self.pause_timer)
self.pause_timer = None
return True
else:
self.mon.log(self, "!<toggle pause rejected " + self.play_state)
return False
def pause_timeout_callback(self):
self.pause_off()
self.pause_timer = None
# pause on
def pause_on(self):
self.mon.log(self,
">pause on received from show Id: " + str(self.show_id))
self.vlcdriver.sendline('pause-on')
reply = self.vlcdriver.readline().strip('\r\n')
if reply == 'pause-on-ok':
if self.pause_timeout > 0:
# kick off the pause timeout timer
self.pause_timer = self.canvas.after(
self.pause_timeout * 1000, self.pause_timeout_callback)
return True
else:
self.mon.log(self, "!<pause on rejected " + self.play_state)
return False
# pause off
def pause_off(self):
self.mon.log(self,
">pause off received from show Id: " + str(self.show_id))
self.vlcdriver.sendline('pause-off')
reply = self.vlcdriver.readline().strip('\r\n')
if reply == 'pause-off-ok':
if self.pause_timer != None:
# cancel the pause timer
self.canvas.after_cancel(self.pause_timer)
self.pause_timer = None
return True
else:
self.mon.log(self, "!<pause off rejected " + self.play_state)
return False
# go after freeze at start
def go(self):
self.vlcdriver.sendline('go')
reply = self.vlcdriver.readline().strip('\r\n')
if reply == 'go-ok':
return True
else:
self.mon.log(self, "!<go rejected " + self.play_state)
return False
# *****************************
# SETUP
# *****************************
def process_params(self):
# volume will be set during show by set_volume()
# --------------------------------------
if self.vlc_max_volume_text != "":
if not self.vlc_max_volume_text.isdigit():
return 'error', 'VLC Max Volume must be a positive integer: ' + self.vlc_max_volume_text
self.max_volume = int(self.vlc_max_volume_text)
if self.max_volume > 100:
return 'error', 'VLC Max Volume must be <= 100: ' + self.vlc_max_volume_text
else:
self.max_volume = 100
if self.vlc_volume_text != "":
if not self.vlc_volume_text.isdigit():
return 'error', 'VLC Volume must be a positive integer: ' + self.vlc_volume_text
self.volume = int(self.vlc_volume_text)
if self.volume > 100:
return 'error', 'VLC Volume must be <= 100: ' + self.vlc_max_volume_text
else:
self.volume = 100
self.volume = min(self.volume, self.max_volume)
# instance options
# ----------------
#audio system - pulseaudio
audio_opt = '--aout=pulse '
# other options
if self.vlc_other_options != '':
other_opts = self.vlc_other_options + ' '
else:
other_opts = ''
# subtitles
if self.vlc_subtitles != 'yes':
subtitle_opt = '--no-spu '
else:
subtitle_opt = ''
# display
# -------
# start with board name
if self.track_params['display-name'] != "":
video_display_name = self.track_params['display-name']
else:
video_display_name = self.show_canvas_display_name
# Is it valid and connected
status, message, self.display_id = self.dm.id_of_display(
video_display_name)
if status == 'error':
return 'error', message
#convert to task bar names for vlc
vlc_display_name = self.dm.vlc_display_name_map[video_display_name]
display_opt = '--mmal-display=' + vlc_display_name + ' '
# does it do DSI-1????
# layer
# ******
if self.vlc_layer_text == '':
layer_opt = ''
elif self.vlc_layer_text == 'hidden':
layer_opt = '--mmal-layer=-128 '
else:
if not self.vlc_layer_text.isdigit():
return 'error', 'Display Layer is not a positive number: ' + self.vlc_layer_text
layer_opt = '--mmal-layer=' + self.vlc_layer_text + ' '
# image duration
# **************
if not self.vlc_image_duration_text.isdigit():
return 'error', 'Image Duration is not a positive number: ' + self.vlc_image_duration_text
if int(self.vlc_image_duration_text) == 0:
image_duration_opt = '--image-duration -1 '
else:
image_duration_opt = '--image-duration ' + self.vlc_image_duration_text + ' '
# video window
# ************
# parse video window and mangle wxh+x+y string for aspect_mode
status, message, window_text = self.parse_vlc_video_window(
self.vlc_window_text)
if status == 'error':
return 'error', message
if window_text != '':
window_opt = '--mmal-vout-window ' + window_text + ' '
else:
window_opt = ''
# transformation
# ***************
# model other than 4 video is rotated by hdmi_display_rotate in config.txt
if self.dm.model_of_pi() == 4:
rotation = self.dm.real_display_orientation(self.display_id)
else:
rotation = 'normal'
if rotation == 'normal':
transform_opt = ' --mmal-vout-transform=0 '
elif rotation == 'right':
transform_opt = ' --mmal-vout-transform=90 '
elif rotation == 'left':
transform_opt = ' --mmal-vout-transform=270 '
else:
#inverted
transform_opt = ' --mmal-vout-transform=180 '
self.iopts = ' ' + window_opt + layer_opt + display_opt + transform_opt + subtitle_opt + audio_opt + image_duration_opt + other_opts
# pause options
#---------------
if self.freeze_at_end_text == 'yes':
self.freeze_at_end_required = True
else:
self.freeze_at_end_required = False
freeze_start_opt = ' ' + self.freeze_at_start_text
freeze_end_opt = ' ' + self.freeze_at_end_text
self.pauseopts = freeze_start_opt + freeze_end_opt
return 'normal', ''
def aspect_mode(self):
"""
In omxplayer Video Window has parameters only for warp, all other modes are centred the full screen
In vlcplayer there are two fields, VLC Window and Aspect Mode. VLC Window position and sizes the window then
Aspect Mode is applied to all results of VLC Window :
stretch - transform video to make it fill the window with aspect ratio the same as the window
fill - crop the video so that it fills the window while retaining the video's aspect ratio
letterbox - vlc's default mode
adjust the video so that whole video is seen in the window while keeping the video's aspect ratio
If the window's aspect ratio does not match that of the video media then the x,y, position will be incorrect,
(except on fullscreen). This is because the result is centred in the window.
vlc - use vlc's aspect ratio and crop in the defined window
Cannot use both crop and aspect ratio
window size w*h needs to have the same ratio as the result of crop or aspect-ratio otherwise the displayed position will be incorrect
values must be integers e.g 5.1:1 does not work
crop formats: <aspect_num>:<aspect_den> e.g.4:3
<width>x<height>+<x>+<y>
<left>+<top>+<right>+<bottom>
aspect ratio formats: <aspect_num>:<aspect_den> e.g.4:3
"""
if self.vlc_aspect_mode == 'stretch':
window_ratio = self.vlc_window_width / self.vlc_window_height
self.vlcdriver.sendline('ratio ' + str(self.vlc_window_width) +
':' + str(self.vlc_window_height))
return 'normal', ''
elif self.vlc_aspect_mode == 'fill':
self.vlcdriver.sendline('crop ' + str(self.vlc_window_width) +
':' + str(self.vlc_window_height))
return 'normal', ''
elif self.vlc_aspect_mode == 'letterbox':
# default vlc behavior
return 'normal', ''
elif self.vlc_aspect_mode == 'vlc':
if self.vlc_aspect_ratio != '' or self.vlc_crop != '':
if self.vlc_crop != '':
self.vlcdriver.sendline('crop ' + self.vlc_crop)
if self.vlc_aspect_ratio != '':
self.vlcdriver.sendline('ratio ' + self.vlc_aspect_ratio)
return 'normal', ''
else:
return 'error', 'crop or aspect mode not specified for vlc option'
else:
return 'error', 'Aspect Mode cannot be blank ' + self.vlc_aspect_mode
def parse_vlc_video_window(self, line):
words = line.split()
if len(words) not in (1, 2):
return 'error', 'bad vlc video window form ' + line, ''
if words[0] not in ('display', 'showcanvas'):
return 'error', 'Bad VLC Window option: ' + line, ''
if words[0] == 'display':
x_org = 0
y_org = 0
width, height = self.dm.canvas_dimensions(self.display_id)
if words[0] == 'showcanvas':
x_org = self.show_canvas_x1
y_org = self.show_canvas_y1
width = self.show_canvas_width
height = self.show_canvas_height
#replace canvas/display height/width from spec
x_offset = 0
y_offset = 0
if len(words) == 2:
#pass in canvas/display width/height. Returns window width/height
status, message, x_offset, y_offset, width, height = self.parse_dimensions(
words[1], width, height)
if status == 'error':
return 'error', message, ''
x = x_org + x_offset
y = y_org + y_offset
self.vlc_window_x = x
self.vlc_window_y = y
self.vlc_window_width = width
self.vlc_window_height = height
vlc_text = str(width) + 'x' + str(height) + '+' + str(x) + '+' + str(y)
return 'normal', '', vlc_text
def parse_dimensions(self, dim_text, show_width, show_height):
# parse x+y+width*height or width*height
if '+' in dim_text:
# x+y+width*height
fields = dim_text.split('+')
if len(fields) != 3:
return 'error', 'bad vlc video window form ' + dim_text, 0, 0, 0, 0
if not fields[0].isdigit():
return 'error', 'x value is not a positive decimal in vlc video window ' + dim_text, 0, 0, 0, 0
else:
x = int(fields[0])
if not fields[1].isdigit():
return 'error', 'y value is not a positive decimal in vlc video window ' + dim_text, 0, 0, 0, 0
else:
y = int(fields[1])
dimensions = fields[2].split('*')
if len(dimensions) != 2:
return 'error', 'bad vlc video window dimensions ' + dim_text, 0, 0, 0, 0
if not dimensions[0].isdigit():
return 'error', 'width is not a positive decimal in vlc video window ' + dim_text, 0, 0, 0, 0
else:
width = int(dimensions[0])
if not dimensions[1].isdigit():
return 'error', 'height is not a positive decimal in vlc video window ' + dim_text, 0, 0, 0, 0
else:
height = int(dimensions[1])
return 'normal', '', x, y, width, height
else:
dimensions = dim_text.split('*')
if len(dimensions) != 2:
return 'error', 'bad vlc video window dimensions ' + dim_text, 0, 0, 0, 0
if not dimensions[0].isdigit():
return 'error', 'width is not a positive decimal in vlc video window ' + dim_text, 0, 0, 0, 0
else:
window_width = int(dimensions[0])
if not dimensions[1].isdigit():
return 'error', 'height is not a positive decimal in vlc video window ' + dim_text, 0, 0, 0, 0
else:
window_height = int(dimensions[1])
x = int((show_width - window_width) / 2)
y = int((show_height - window_height) / 2)
return 'normal', '', x, y, window_width, window_height
class pp_kbddriver(object):
# CLASS VARIABLES (pp_gpiodriver.)
driver_active = False
title = ''
config = None
def __init__(self):
self.mon = Monitor()
self.dm = DisplayManager()
def init(self,
filename,
filepath,
widget,
pp_dir,
pp_home,
pp_profile,
callback=None):
# instantiate arguments
self.widget = widget
self.filename = filename
self.filepath = filepath
self.callback = callback
pp_kbddriver.driver_active = False
# print filename,filepath
# read .cfg file.
reason, message = self._read(self.filename, self.filepath)
if reason == 'error':
return 'error', message
if self.config.has_section('DRIVER') is False:
return 'error', 'No DRIVER section in ' + self.filepath
#read information from DRIVER section
pp_kbddriver.title = self.config.get('DRIVER', 'title')
self.bind_printing = self.config.get('DRIVER', 'bind-printing')
# and bind the keys
self._bind_keys(widget, callback)
pp_kbddriver.driver_active = True
return 'normal', pp_kbddriver.title + 'Initialised'
def start(self):
return
# allow track plugins (or anyting else) to access analog input values
def get_input(self, channel):
return False, None
def terminate(self):
pp_kbddriver.driver_active = False
return
def is_active(self):
return pp_kbddriver.driver_active
def handle_output_event(self, name, param_type, param_values, req_time):
return 'normal', 'no output methods'
# sets up tkinter keyboard events such that any key press
# does a callback to 'callback' with the event object and a symbolic name.
def _bind_keys(self, widget, callback):
for display_name in DisplayManager.display_map:
status, message, display_id, canvas = self.dm.id_of_canvas(
display_name)
if status != 'normal':
continue
# bind all the normal keys that return a printing character such that x produces pp-key-x
if self.bind_printing == 'yes':
canvas.bind("<Key>",
lambda event: self._normal_key(callback, event))
for option in self.config.items('keys'):
condition = option[0]
symbolic_name = option[1]
# print condition,symbolic_name
# print condition,symbolic_name
canvas.bind(condition,
lambda event, name=symbolic_name: self.
_specific_key(callback, name))
def _specific_key(self, callback, name):
callback(name, pp_kbddriver.title)
# alphanumeric keys- convert to symbolic by adding pp-key-
def _normal_key(self, callback, event):
key = event.char
if key != '':
callback('pp-key-' + key, pp_kbddriver.title)
# read the key bindings from keys.cfg
def _read(self, filename, filepath):
if os.path.exists(filepath):
self.config = configparser.ConfigParser(
inline_comment_prefixes=(';', ))
self.config.optionxform = str
self.config.read(filepath)
return 'normal', filename + ' read'
else:
return 'error', filename + ' not found at: ' + filepath
class ChromePlayer(Player):
# ***************************************
# EXTERNAL COMMANDS
# ***************************************
def __init__(self, show_id, showlist, root, canvas, show_params,
track_params, pp_dir, pp_home, pp_profile, end_callback,
command_callback):
# initialise items common to all players
Player.__init__(self, show_id, showlist, root, canvas, show_params,
track_params, pp_dir, pp_home, pp_profile,
end_callback, command_callback)
self.mon.trace(self, '')
# and initialise things for this player
self.dm = DisplayManager()
# get duration limit (secs ) from profile
if self.track_params['duration'] != '':
self.duration_text = self.track_params['duration']
else:
self.duration_text = self.show_params['duration']
# process chrome window
if self.track_params['chrome-window'] != '':
self.chrome_window_text = self.track_params['chrome-window']
else:
self.chrome_window_text = self.show_params['chrome-window']
# process chrome things
if self.track_params['chrome-freeze-at-end'] != '':
self.freeze_at_end = self.track_params['chrome-freeze-at-end']
else:
self.freeze_at_end = self.show_params['chrome-freeze-at-end']
if self.track_params['chrome-zoom'] != '':
self.chrome_zoom_text = self.track_params['chrome-zoom']
else:
self.chrome_zoom_text = self.show_params['chrome-zoom']
if self.track_params['chrome-other-options'] != '':
self.chrome_other_options = self.track_params[
'chrome-other-options']
else:
self.chrome_other_options = self.show_params[
'chrome-other-options']
# Initialize variables
self.command_timer = None
self.tick_timer = None
self.quit_signal = False # signal that user has pressed stop
# initialise the play state
self.play_state = 'initialised'
self.load_state = ''
# LOAD - loads the browser and show stuff
def load(self, track, loaded_callback, enable_menu):
# instantiate arguments
self.loaded_callback = loaded_callback # callback when loaded
self.mon.trace(self, '')
status, message, duration100 = Player.parse_duration(
self.duration_text)
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
self.duration = 2 * duration100
# Is display valid and connected
status, message, self.display_id = self.dm.id_of_display(
self.show_canvas_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', 'cannot find file; ' + track)
return
# does media exist
if not ':' in track:
if not os.path.exists(track):
self.mon.err(self, 'cannot find file; ' + track)
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error', 'cannot find file; ' + track)
return
# add file:// to files.
if ':' in track:
self.current_url = track
else:
self.current_url = 'file://' + track
# do common bits of load
Player.pre_load(self)
# prepare chromium options
status, message = self.process_chrome_options()
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
# parse browser commands to self.command_list
reason, message = self.parse_commands(
self.track_params['browser-commands'])
if reason == '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 plugin, this may modify self.track and enable the plugin drawing to canvas
if self.track_params['plugin'] != '':
status, message = self.load_plugin()
if status == 'error':
self.mon.err(self, message)
self.play_state = 'load-failed'
if self.loaded_callback is not None:
self.loaded_callback('error', message)
return
# start loading the browser
self.play_state = 'loading'
# 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
#start the browser
self.driver_open()
# for kiosk and fullscreen need to get the url - in browser command for app mode
if self.app_mode is False:
self.driver_get(self.current_url)
self.mon.log(self,
'Loading browser from show Id: ' + str(self.show_id))
self.play_state = 'loaded'
# and start executing the browser commands
self.play_commands()
self.mon.log(self, " State machine: chromium loaded")
if self.loaded_callback is not None:
self.loaded_callback('normal', 'browser loaded')
return
# UNLOAD - abort a load when browser 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.driver_close()
self.play_state = 'closed'
# SHOW - show a track from its loaded state
def show(self, ready_callback, finished_callback, closed_callback):
# instantiate arguments
self.ready_callback = ready_callback # callback when ready to show a web page-
self.finished_callback = finished_callback # callback when finished showing - not used
self.closed_callback = closed_callback # callback when closed
self.mon.trace(self, '')
self.play_state = 'showing'
# init state and signals
self.quit_signal = False
# do common bits
Player.pre_show(self)
#self.driver.get(self.current_url)
self.duration_count = self.duration
self.tick_timer = self.canvas.after(10, self.show_state_machine)
def show_state_machine(self):
if self.play_state == 'showing':
self.duration_count -= 1
# self.mon.log(self," Show state machine: " + self.show_state)
# service any queued stop signals and test duration count
if self.quit_signal is True or (self.duration != 0
and self.duration_count == 0):
self.mon.log(self,
" Service stop required signal or timeout")
if self.command_timer != None:
self.canvas.after_cancel(self.command_timer)
self.command_timer = None
if self.quit_signal is True:
self.quit_signal = False
if self.freeze_at_end == 'yes':
self.mon.log(self, 'chrome says pause_at_end')
if self.finished_callback is not None:
self.finished_callback('pause_at_end', 'pause at end')
self.tick_timer = self.canvas.after(
50, self.show_state_machine)
else:
self.mon.log(self, 'chrome says niceday')
self.driver_close()
self.play_state = 'closed'
if self.closed_callback is not None:
self.closed_callback('normal', 'chromedriver closed')
return
else:
self.tick_timer = self.canvas.after(50,
self.show_state_machine)
# CLOSE - nothing to do in browserplayer - x content is removed by ready callback and hide browser does not implement pause_at_end
def close(self, closed_callback):
self.mon.trace(self, '')
self.closed_callback = closed_callback
self.mon.log(self,
">close received from show Id: " + str(self.show_id))
self.driver_close()
self.play_state = 'closed'
# PP does not use close callback but it does read self.play_state
def input_pressed(self, symbol):
self.mon.trace(self, symbol)
if symbol == 'pause':
self.pause()
elif symbol == 'pause-on':
self.pause_on()
elif symbol == 'pause-off':
self.pause_off()
elif symbol == 'stop':
self.stop()
# browsers do not do pause
def pause(self):
self.mon.log(self, "!<pause rejected")
return False
# browsers do not do pause
def pause_on(self):
self.mon.log(self, "!<pause on rejected")
return False
# browsers do not do pause
def pause_off(self):
self.mon.log(self, "!<pause off rejected")
return False
# 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
# ***********************
# veneer for controlling chromium browser
# ***********************
def driver_open(self):
tries = 4
while tries > 0:
try:
self.driver = webdriver.Chrome(options=self.chrome_options)
return
except Exception as e:
#print ("Failed to open Chromium", e, e.__class__,tries)
tries -= 1
def driver_close(self):
try:
self.driver.quit()
except WebDriverException as e:
self.mon.warn(self, 'Browser Closed in Close !!!!!!\n' + str(e))
except Exception as e:
print("Oops!", e, e.__class__, "occurred.")
else:
return
def driver_refresh(self):
try:
self.driver.refresh()
except WebDriverException as e:
self.mon.warn(self, 'Browser Closed in Refresh !!!!!!\n' + str(e))
except Exception as e:
print("Oops!", e, e.__class__, "occurred.")
else:
return
def driver_get(self, url):
self.mon.log(self, 'get: ' + url)
try:
self.driver.get(url)
except WebDriverException as e:
self.mon.warn(self, 'Browser Closed in Get !!!!!!\n' + str(e))
except Exception as e:
print("Oops!", e, e.__class__, "occurred.")
else:
return
# *******************
# browser commands
# ***********************
def parse_commands(self, command_text):
self.command_list = []
self.max_loops = -1 #loop continuous if no loop command
lines = command_text.split('\n')
for line in lines:
if line.strip() == '':
continue
#print (line)
reason, entry = self.parse_command(line)
if reason != 'normal':
return 'error', entry
self.command_list.append(copy.deepcopy(entry))
num_loops = 0
for entry in self.command_list:
if entry[0] == 'loop':
num_loops += 1
if num_loops > 1:
return 'error', str(
num_loops) + ' loop commands in browser commands'
return 'normal', ''
def parse_command(self, line):
fields = line.split()
#print (fields)
if len(fields) not in (1, 2):
return 'error', "incorrect number of fields in command: " + line
command = fields[0]
arg = ''
if command not in ('load', 'refresh', 'wait', 'loop'):
return 'error', 'unknown browser command: ' + line
if command in ('refresh', ) and len(fields) != 1:
return 'error', 'incorrect number of fields for ' + command + 'in: ' + line
if command in ('refresh', ):
return 'normal', [command, '']
if command == 'load':
if len(fields) != 2:
return 'error', 'incorrect number of fields for ' + command + 'in: ' + line
arg = fields[1]
track = self.complete_path(arg)
# does media exist
if not ':' in track:
if not os.path.exists(track):
return 'error', 'cannot find file: ' + track
# add file:// to files.
if ':' in track:
url = track
else:
url = 'file://' + track
return 'normal', [command, url]
if command == 'loop':
if len(fields) == 1:
arg = '-1'
self.max_loops = -1 #loop continuously if no argument
return 'normal', [command, arg]
elif len(fields) == 2:
if not fields[1].isdigit() or fields[1] == '0':
return 'error', 'Argument for Loop is not a positive number in: ' + line
else:
arg = fields[1]
self.max_loops = int(arg)
return 'normal', [command, arg]
else:
return 'error', 'incorrect number of fields for ' + command + 'in: ' + line
if command == 'wait':
if len(fields) != 2:
return 'error', 'incorrect number of fields for ' + command + 'in: ' + line
else:
arg = fields[1]
if not arg.isdigit():
return 'error', 'Argument for Wait is not 0 or positive number in: ' + line
else:
return 'normal', [command, arg]
def play_commands(self):
# init
if len(self.command_list) == 0:
return
self.loop_index = -1 # -1 no loop comand found
self.loop_count = 0
self.command_index = 0
self.next_command_index = 0 #start at beginning
#loop round executing the commands
self.canvas.after(100, self.execute_command)
def execute_command(self):
self.command_index = self.next_command_index
if self.command_index == len(self.command_list):
# past end of command list
self.quit_signal = True
return
if self.command_index == len(
self.command_list) - 1 and self.loop_index != -1:
# last in list and need to loop
self.next_command_index = self.loop_index
else:
self.next_command_index = self.command_index + 1
entry = self.command_list[self.command_index]
command = entry[0]
arg = entry[1]
self.mon.log(
self,
str(self.command_index) + ' Do ' + command + ' ' + arg +
' Next: ' + str(self.next_command_index))
# and execute command
if command == 'load':
self.driver_get(arg)
self.command_timer = self.canvas.after(10, self.execute_command)
elif command == 'refresh':
self.driver_refresh()
self.command_timer = self.canvas.after(10, self.execute_command)
elif command == 'wait':
self.command_timer = self.canvas.after(1000 * int(arg),
self.execute_command)
elif command == 'loop':
if self.loop_index == -1:
# found loop for first time
self.loop_index = self.command_index
self.loop_count = 0
self.mon.log(
self, 'Loop init To: ' + str(self.loop_index) +
' Count: ' + str(self.loop_count))
self.command_timer = self.canvas.after(10,
self.execute_command)
else:
self.loop_count += 1
self.mon.log(
self,
'Inc loop count: ' + ' Count: ' + str(self.loop_count))
# hit loop command after the requied number of loops
if self.loop_count == self.max_loops: #max loops is -1 for continuous
self.mon.log(
self,
'end of loop: ' + ' Count: ' + str(self.loop_count))
self.quit_signal = True
return
else:
self.mon.log(
self, 'Looping to: ' + str(self.loop_index) +
' Count: ' + str(self.loop_count))
self.command_timer = self.canvas.after(
10, self.execute_command)
elif command == 'exit':
self.quit_signal = True
return
def process_chrome_options(self):
self.chrome_options = Options()
#self.add_option("--incognito")
self.add_option("--noerrdialogs")
self.add_option("--disable-infobars")
self.add_option("--check-for-update-interval=31536000")
self.add_option('--disable-overlay-scrollbar')
self.chrome_options.add_experimental_option("excludeSwitches",
['enable-automation'])
try:
self.zoom = float(self.chrome_zoom_text)
except ValueError:
return 'error', 'Chrome Zoom is not a number' + self.chrome_zoom_text
self.add_option('--force-device-scale-factor=' + self.chrome_zoom_text)
status, message = self.process_chrome_window(self.chrome_window_text)
if status == 'error':
return 'error', message
status, message = self.add_other_options()
if status == 'error':
return 'error', message
return 'normal', ''
def add_other_options(self):
opts_list = self.chrome_other_options.split(' ')
#print (opts_list)
for opt in opts_list:
if opt == '':
continue
if opt[0:2] != '--':
return 'error', 'option is not preceded by -- : ' + opt
else:
self.add_option(opt)
return 'normal', ''
def add_option(self, option):
#print ('Adding Option: ',option)
self.chrome_options.add_argument(option)
def process_chrome_window(self, line):
#parse chrome window
# kiosk,fullscreen,showcanvas,display
# obxprop | grep "^_OB_APP" and click the window
self.app_mode = False
# showcanvas|display + [x+y+w*h]
words = line.split()
if len(words) not in (1, 2):
return 'error', 'bad Chrome Web Window form ' + line
if words[0] not in ('display', 'showcanvas', 'kiosk', 'fullscreen'):
return 'error', 'No or invalid Chrome Web Window mode: ' + line
if len(words) == 1 and words[0] == 'kiosk':
self.add_option('--kiosk')
x_org, y_org = self.dm.real_display_position(self.display_id)
self.add_option('--window-position=' + str(x_org) + ',' +
str(y_org))
return 'normal', ''
if len(words) == 1 and words[0] == 'fullscreen':
self.add_option('--start-fullscreen')
x_org, y_org = self.dm.real_display_position(self.display_id)
self.add_option('--window-position=' + str(x_org) + ',' +
str(y_org))
return 'normal', ''
# display or showcanvas with or without dimensions
self.app_mode = True
if words[0] == 'display':
x_org, y_org = self.dm.real_display_position(self.display_id)
width, height = self.dm.real_display_dimensions(self.display_id)
if words[0] == 'showcanvas':
x_org, y_org = self.dm.real_display_position(self.display_id)
x_org += self.show_canvas_x1
y_org += self.show_canvas_y1
width = self.show_canvas_width
height = self.show_canvas_height
x_offset = 0
y_offset = 0
#calc offset and width/height from dimensions
if len(words) > 1:
status, message, x_offset, y_offset, width, height = self.parse_dimensions(
words[1], width, height)
if status == 'error':
return 'error', message
#correct for zoom
width = int(width / self.zoom)
height = int(height / self.zoom)
x = x_org + x_offset
y = y_org + y_offset
self.chrome_window_x = x
self.chrome_window_y = y
self.chrome_window_width = width
self.chrome_window_height = height
#print ('app',self.app_mode,x,y,width,height)
self.add_option('--app=' + self.current_url)
self.add_option('--window-size=' + str(width) + ',' + str(height))
self.add_option('--window-position=' + str(x) + ',' + str(y))
return 'normal', ''
def parse_dimensions(self, dim_text, show_width, show_height):
if '+' in dim_text:
# parse x+y+width*height
fields = dim_text.split('+')
if len(fields) != 3:
return 'error', 'bad chrome window form ' + dim_text, 0, 0, 0, 0
if not fields[0].isdigit():
return 'error', 'x is not a positive decimal in chrome web window ' + dim_text, 0, 0, 0, 0
else:
x = int(fields[0])
if not fields[1].isdigit():
return 'error', 'y is not a positive decimal in chrome webwindow ' + dim_text, 0, 0, 0, 0
else:
y = int(fields[1])
dimensions = fields[2].split('*')
if len(dimensions) != 2:
return 'error', 'bad chrome web window dimensions ' + dim_text, '', 0, 0, 0, 0
if not dimensions[0].isdigit():
return 'error', 'width is not a positive decimal in chrome web window ' + dim_text, 0, 0, 0, 0
else:
width = int(dimensions[0])
if not dimensions[1].isdigit():
return 'error', 'height is not a positive decimal in chrome web window ' + dim_text, 0, 0, 0, 0
else:
height = int(dimensions[1])
return 'normal', '', x, y, width, height
else:
#width*height
dimensions = dim_text.split('*')
if len(dimensions) != 2:
return 'error', 'bad chrome web window dimensions ' + line, '', 0, 0, 0, 0
if not dimensions[0].isdigit():
return 'error', 'width is not a positive decimal in chrome web window ' + line, '', 0, 0, 0, 0
else:
window_width = int(dimensions[0])
if not dimensions[1].isdigit():
return 'error', 'height is not a positive decimal in chrome web window ' + line, '', 0, 0, 0, 0
else:
window_height = int(dimensions[1])
x = int((show_width - window_width) / 2)
y = int((show_height - window_height) / 2)
return 'normal', '', x, y, window_width, window_height
class pp_kbddriver_plus(object):
# control list items
NAME = 0 # symbolic name for input and output
DIRECTION = 1 # in/out
MATCH = 2 # for input the character/string to match (no EOL)
MODE = 3 # for input the match mode any-char,char,any-line,line
TEMPLATE = ['', '', '', '']
# CLASS VARIABLES (pp_kbddriver_plus.)
driver_active = False
title = '' # usd for error reporting and logging
tick_interval = '' # mS between polls of the serial input
match_mode = '' # char or line, whether input characters are matched for each character or a complete line
inputs = {}
# executed by main program and by each object using the driver
def __init__(self):
self.dm = DisplayManager()
# executed once from main program
def init(self,
filename,
filepath,
widget,
pp_dir,
pp_home,
pp_profile,
event_callback=None):
# instantiate arguments
self.widget = widget
self.filename = filename
self.filepath = filepath
self.event_callback = event_callback
pp_kbddriver_plus.driver_active = False
# read pp_kbddriver_plus.cfg file.
reason, message = self._read(self.filename, self.filepath)
if reason == 'error':
return 'error', message
if self.config.has_section('DRIVER') is False:
return 'error', 'No DRIVER section in ' + self.filepath
# all the below are used by another instance of pp_kbddriver_plus so must reference class variables
# read information from DRIVER section
pp_kbddriver_plus.title = self.config.get('DRIVER', 'title')
pp_kbddriver_plus.bind_printing = self.config.get(
'DRIVER', 'bind-printing')
# construct the control list from the config file
pp_kbddriver_plus.in_names = []
pp_kbddriver_plus.out_names = []
for section in self.config.sections():
if section == 'DRIVER':
continue
entry = copy.deepcopy(pp_kbddriver_plus.TEMPLATE)
entry[pp_kbddriver_plus.NAME] = self.config.get(section, 'name')
entry[pp_kbddriver_plus.DIRECTION] = self.config.get(
section, 'direction')
if entry[pp_kbddriver_plus.DIRECTION] == 'none':
continue
elif entry[pp_kbddriver_plus.DIRECTION] == 'in':
entry[pp_kbddriver_plus.MODE] = self.config.get(
section, 'mode')
if entry[pp_kbddriver_plus.MODE] in ('specific-character',
'specific-line'):
entry[pp_kbddriver_plus.MATCH] = self.config.get(
section, 'match')
pp_kbddriver_plus.in_names.append(copy.deepcopy(entry))
else:
return 'error', pp_kbddriver_plus.title + ' direction not in or out'
# print pp_kbddriver_plus.in_names
# bind the keys
self._bind_keys(widget, self._key_received)
# all ok so indicate the driver is active
pp_kbddriver_plus.driver_active = True
# init must return two arguments
return 'normal', pp_kbddriver_plus.title + ' active'
# sets up tkinter keyboard events such that any key press
# does a callback to _key_received() with the event object
def _bind_keys(self, widget, callback):
for display_name in DisplayManager.display_map:
status, message, display_id, canvas = self.dm.id_of_canvas(
display_name)
if status != 'normal':
continue
# bind all the normal keys that return a printing character such that x produces pp-key-x (but fileterd in _key_received)
canvas.bind("<Key>",
lambda event, match='<Key>', name='': self.
_key_received(event, match, name))
# print 'bind printing'
# Bind <Return> so that eol detection works, <Return> cannot be used to trigger an input event
# if you wnt that use keys.cfg
canvas.bind("<Return>",
lambda event, match='<Return>', name='': self.
_key_received(event, match, name))
# print 'bind Return to make eol work'
# go through entries and bind all specific-character matches to _key_received
for entry in pp_kbddriver_plus.in_names:
if entry[pp_kbddriver_plus.MODE] == 'specific-character':
match = entry[pp_kbddriver_plus.MATCH]
name = entry[pp_kbddriver_plus.NAME]
canvas.bind(match,
lambda event, match=match, name=name: self.
_key_received(event, match, name))
# print 'bind specific-char', match,name
# start method must be defined. If not using inputs just pass
def start(self):
pp_kbddriver_plus.inputs['current-character'] = ''
pp_kbddriver_plus.inputs['current-line'] = ''
pp_kbddriver_plus.inputs['previous-line'] = ''
def _key_received(self, event, match, name):
# generate the events with symbolic names if driver is active
if pp_kbddriver_plus.driver_active is True:
char = event.char
# print 'received ',char,match,name
# if char is eol then match the line and start a new line
if match == '<Return>':
# do match of line
# print 'do match line',pp_kbddriver_plus.inputs['current-line']
self.match_line(pp_kbddriver_plus.inputs['current-line'])
# shuffle and empty the buffer
pp_kbddriver_plus.inputs[
'previous-line'] = pp_kbddriver_plus.inputs['current-line']
pp_kbddriver_plus.inputs['current-line'] = ''
pp_kbddriver_plus.inputs['current-character'] = ''
if name != '':
# print 'bound <Return> key'
if self.event_callback is not None:
self.event_callback(name, pp_kbddriver_plus.title)
else:
# process a character
if char == '' and match == '<Key>':
# unbound special key
# print 'unbound special key ', match
pass
else:
# a character has been received
pp_kbddriver_plus.inputs['current-character'] = char
pp_kbddriver_plus.inputs['current-line'] += char
# print pp_kbddriver_plus.inputs['current-character'],pp_kbddriver_plus.inputs['current-line']
if match == '<Key>' and char != '' and self.bind_printing == 'yes':
# print 'printable key, bind-printing is yes',char,match
# printable character without overiding section
if self.event_callback is not None:
self.event_callback('pp-key-' + char,
pp_kbddriver_plus.title)
else:
if name != '':
# print 'bound non-printable character',char,name
if self.event_callback is not None:
self.event_callback(name,
pp_kbddriver_plus.title)
# look through entries for any-character
for entry in pp_kbddriver_plus.in_names:
if entry[pp_kbddriver_plus.MODE] == 'any-character':
# print 'match any character', char, 'current line is ',pp_kbddriver_plus.inputs['current-line']
if self.event_callback is not None:
self.event_callback(
entry[pp_kbddriver_plus.NAME],
pp_kbddriver_plus.title)
def match_line(self, line):
for entry in pp_kbddriver_plus.in_names:
if entry[pp_kbddriver_plus.MODE] == 'any-line':
# print 'match any line',line
if self.event_callback is not None:
self.event_callback(entry[pp_kbddriver_plus.NAME],
pp_kbddriver_plus.title)
if entry[pp_kbddriver_plus.
MODE] == 'specific-line' and line == entry[
pp_kbddriver_plus.MATCH]:
# print 'match specific line', line
if self.event_callback is not None:
self.event_callback(entry[pp_kbddriver_plus.NAME],
pp_kbddriver_plus.title)
# allow track plugins (or anything else) to access analog input values
def get_input(self, key):
if key in pp_kbddriver_plus.inputs:
return True, pp_kbddriver_plus.inputs[key]
else:
return False, None
# allow querying of driver state
def is_active(self):
return pp_kbddriver_plus.driver_active
# called by main program only. Called when PP is closed down
def terminate(self):
pp_kbddriver_plus.driver_active = False
# ************************************************
# output interface method
# this can be called from many objects so needs to operate on class variables
# ************************************************
# execute an output event
def handle_output_event(self, name, param_type, param_values, req_time):
return 'normal', 'no output methods'
# ***********************************
# reading .cfg file
# ************************************
def _read(self, filename, filepath):
if os.path.exists(filepath):
self.config = configparser.ConfigParser(
inline_comment_prefixes=(';', ))
self.config.read(filepath)
return 'normal', filename + ' read'
else:
return 'error', filename + ' not found at: ' + filepath
def __init__(self):
self.dm = DisplayManager()