class Player(object):
def __init__(self, media_dir):
self.media_dir = media_dir
self.player = None
self.subtitles = True
def play(self, filename):
if self.player:
self.player.quit()
self.player = None
video_path = Path(self.media_dir + filename)
self.player = OMXPlayer(video_path, args=['--no-osd'])
def quit(self):
self.player.quit()
self.player = None
def pause(self):
self.player.play_pause()
def seek(self, val):
self.player.set_position(val)
def set_volume(self, val):
self.player.set_volume(val)
def toggle_subtitles(self):
if self.subtitles:
self.player.hide_subtitles()
else:
self.player.show_subtitles()
self.subtitles = not self.subtitles
def set_subtitle_track(self, val):
self.player.select_subtitle(val)
@property
def status(self):
if self.player != None:
return {
'time': int(self.player.position()),
'length': int(self.player.duration()),
'volume': int(self.player.volume()),
'subtitle_tracks': self.player.list_subtitles()
}
return {'time': 0, 'length': 0, 'volume': 0, 'subtitle_tracks': []}
class VideoPlayerScreen(Screen):
slider = ObjectProperty()
minimized = BooleanProperty(True)
video_path = StringProperty() # 20200308tagesthemen.mp4
def is_playing(self):
if hasattr(self, 'player'):
try:
return self.player.is_playing()
except OMXPlayerDeadError:
self.leave_player()
return False
else:
return False
def set_play_pause_bttn(self, *args):
print(self.ids)
if self.is_playing():
self.ids.play_pause_image.source = 'atlas://data/images/defaulttheme/media-playback-pause'
else:
self.ids.play_pause_image.source = 'atlas://data/images/defaulttheme/media-playback-start'
def play(self):
VIDEO_PATH = Path("videos/" + self.video_path)
print(VIDEO_PATH)
self.player = OMXPlayer(VIDEO_PATH,
args=['-o', 'alsa', '--layer', '100000'])
self.player.set_video_pos(0, 0, 800, 480)
self.set_slider()
self.change_size()
Clock.schedule_interval(self.set_slider, 3)
Clock.schedule_interval(self.set_play_pause_bttn, 1)
def player_stop(self):
Clock.unschedule(self.set_play_pause_bttn)
Clock.unschedule(self.set_slider)
if self.is_playing():
self.player.stop()
@staticmethod
def leave_player():
App.get_running_app().root.current = 'base'
def play_pause(self):
self.player.play_pause()
def quit(self, gg, **kwargs):
self.player.quit()
App.get_running_app().stop()
def set_slider(self, *args):
try:
pos = self.player.position() # in seconds as int
duration = self.player.duration() # in seconds as float
self.slider.value_normalized = pos / duration
except OMXPlayerDeadError:
self.leave_player()
def set_videopos(self, *args):
pos = self.player.position() # in seconds as int
duration = self.player.duration() # in seconds as float
if abs(pos / duration - self.slider.value_normalized) > 0.05:
self.player.set_position(self.slider.value_normalized * duration)
def change_size(self):
if self.minimized:
self.player.set_alpha(255)
else:
self.player.set_alpha(100)
self.minimized = not self.minimized
class VideoPlayer:
def __init__(self, root, message_handler, data, name):
self.root = root
self.message_handler = message_handler
self.data = data
self.omx_player = None
self.name = name
self.omx_running = False
self.status = 'EMPTY'
self.total_length = 0.0
self.bankslot_number = '*-*'
self.start = -1.0
self.end = -1.0
self.rate = 1
self.crop_length = 0.0
self.location = ''
self.load_attempts = 0
self.alpha = 0
def try_load(self, layer):
load_attempts = 0
while (load_attempts < 2):
load_attempts = load_attempts + 1
if self.load(layer):
print('load success')
return True
else:
print('load failed')
self.message_handler.set_message('ERROR', 'failed to load')
self.status = 'ERROR'
return False
def load(self, layer):
#try:
self.get_context_for_player()
is_dev_mode, first_screen_arg, second_screen_arg = self.set_screen_size_for_dev_mode(
)
arguments = [
'--no-osd', '--layer',
str(layer), '--adev', 'local', '--alpha', '0', first_screen_arg,
second_screen_arg
]
if not is_dev_mode:
arguments.append('--blank=0x{}'.format(
self.data.get_background_colour()))
self.status = 'LOADING'
print('the location is {}'.format(self.location))
if self.location == '':
self.status = 'EMPTY'
return True
self.omx_player = OMXPlayer(self.location,
args=arguments,
dbus_name=self.name)
self.omx_running = True
self.total_length = self.omx_player.duration(
) # <-- uneeded once self.duration stores float
if (self.end is -1):
self.end = self.total_length
if (self.start is -1):
self.start = 0
self.crop_length = self.end - self.start
print('{}: the duration is {}'.format(self.name, self.total_length))
if self.start > 0.9:
self.set_position(self.start - 0.9)
if 'show' in self.data.settings['sampler']['ON_LOAD']['value']:
self.set_alpha_value(255)
else:
self.set_alpha_value(0)
self.pause_at_start()
return True
#except (ValueError, SystemError) as e:
# print(e)
#self.message_handler.set_message('ERROR', 'load attempt fail')
#return False
def pause_at_start(self):
position = self.get_position()
start_threshold = round(self.start - 0.02, 2)
if position > start_threshold:
if self.status == 'LOADING':
self.status = 'LOADED'
self.omx_player.pause()
elif self.omx_running:
self.root.after(5, self.pause_at_start)
def start_video(self):
if 'show' in self.data.settings['sampler']['ON_START']['value']:
self.set_alpha_value(255)
else:
self.set_alpha_value(0)
if 'play' in self.data.settings['sampler']['ON_START']['value']:
self.status = 'PLAYING'
self.omx_player.play()
else:
self.status = 'START'
self.pause_at_end()
def pause_at_end(self):
position = self.get_position()
end_threshold = self.end - 0.2
if (position > end_threshold):
self.status = 'FINISHED'
self.omx_player.pause()
print('its paused at end!')
elif (self.omx_running):
self.root.after(5, self.pause_at_end)
def reload(self, layer):
self.exit()
self.omx_running = False
self.try_load(layer)
def is_loaded(self):
return self.status is 'LOADED'
def is_finished(self):
return self.status is 'FINISHED'
def get_position(self):
try:
return self.omx_player.position()
except:
print('{}: error get_position'.format(self.name))
return -1
def get_context_for_player(self):
next_context = self.data.get_next_context()
self.location = next_context['location']
#self.total_length = next_context['length']
self.start = next_context['start']
self.end = next_context['end']
self.bankslot_number = next_context['bankslot_number']
self.rate = next_context['rate']
def toggle_pause(self):
self.omx_player.play_pause()
self.status = self.omx_player.playback_status().upper()
def toggle_show(self):
if self.alpha > 127:
self.show_toggle_on = False
self.set_alpha_value(0)
else:
self.show_toggle_on = True
self.set_alpha_value(255)
def set_alpha_value(self, amount):
self.omx_player.set_alpha(amount)
self.alpha = amount
def seek(self, amount):
position = self.get_position()
after_seek_position = position + amount
if after_seek_position > self.start and after_seek_position < self.end:
self.set_position(after_seek_position)
#self.player.seek(amount)
else:
self.message_handler.set_message('INFO',
'can not seek outside range')
def change_rate(self, amount):
new_rate = self.rate + amount
if (new_rate > self.omx_player.minimum_rate()
and new_rate < self.omx_player.maximum_rate()):
updated_speed = self.omx_player.set_rate(new_rate)
self.rate = new_rate
print('max rate {} , min rate {} '.format(
self.omx_player.maximum_rate(),
self.omx_player.minimum_rate()))
return new_rate
else:
self.message_handler.set_message(
'INFO', 'can not set speed outside of range')
return self.rate
def set_position(self, position):
self.omx_player.set_position(position)
def exit(self):
try:
self.omx_player.quit()
self.status = 'EMPTY'
self.omx_running = False
except:
pass
def set_screen_size_for_dev_mode(self):
## only dev mode is needed now that auto handles all modes... can be removed probably ...
if self.data.settings['other']['DEV_MODE_RESET']['value'] == 'on':
return True, '--win', '50,350,550,750'
else:
aspect_mode = self.data.settings['video']['SCREEN_MODE']['value']
return False, '--aspect-mode', aspect_mode
class VideoPlayerScreen(Screen):
slider = ObjectProperty()
minimized = BooleanProperty(False)
@staticmethod
def clearbckgrnd():
Window.clearcolor = (0, 0, 0, 0)
@staticmethod
def addbckgrnd():
Window.clearcolor = (0, 0, 0, 1)
def play(self):
VIDEO_PATH = Path("../videos/20200308tagesthemen.mp4")
self.player = OMXPlayer(VIDEO_PATH,
args=['-o', 'alsa', '--layer', '10000'])
#self.player = OMXPlayer('/home/pi/Documents/Radio/videos/20200223tagesthemen.mp4')
self.player.set_video_pos(0, 0, 800, 480)
#self.player.hide_video()
#self.player.show_video()
self.player.set_alpha(100)
self.set_slider()
#Clock.schedule_once(self.quit, 20)
Clock.schedule_interval(self.set_slider, 3)
def playpause(self):
self.player.play_pause()
def quit(self, gg, **kwargs):
self.player.quit()
App.get_running_app().stop()
def set_slider(self, *args):
pos = self.player.position() # in seconds as int
duration = self.player.duration() # in seconds as float
#return pos/duration
self.slider.value_normalized = pos / duration
#return 0.5
def set_videopos(self, *args):
pos = self.player.position() # in seconds as int
duration = self.player.duration() # in seconds as float
if abs(pos / duration - self.slider.value_normalized) > 0.05:
self.player.set_position(self.slider.value_normalized * duration)
def change_size(self):
# pass
#width 800
#height 480
# check if crop as alternative
if self.minimized:
# self.player.set_video_pos(2,2,798,478)
self.player.set_alpha(255)
else:
# self.player.set_video_pos(2,2,798,418)
self.player.set_alpha(100)
self.minimized = not self.minimized
class VideoPlayer(object):
def __init__(self):
self.player = None
self.logger = LogObject('Video Player')
self.args = ['-b']
self.STATUS_MAP = {
'volume': self._videoVolume,
'length': self._videoLength,
'playback': self._playbackStatus,
'position': self._videoPosition
}
self.CONTROL_MAP = {
'playpause': self._playPause,
'stop': self._stop,
'mute': self._mute,
'unmute': self._unmute,
'play': self._play,
'pause': self._pause
}
self.SEEK_MAP = {'relative': self._seek, 'absolute': self._setPosition}
def playUrl(self, url):
if not self.player:
self.player = OMXPlayer(url, args=self.args)
else:
self.player.load(url)
def setVolume(self, volume):
self._checkPlayerExist()
try:
self.player.set_volume(volume)
return self.logger.writeAndReturnLog('VOL0003', {'volume': volume})
except (AttributeError, OMXPlayerDeadError):
self._raisePlayerError('VOL0004')
def sendCommand(self, command):
self._checkPlayerExist()
try:
return self.CONTROL_MAP[command]()
except (AttributeError, OMXPlayerDeadError):
self._raisePlayerError('CTRL0003')
def _stop(self):
self.player.quit()
return self.logger.writeAndReturnLog('CTRL0004')
def _mute(self):
self.player.mute()
return self.logger.writeAndReturnLog('CTRL0006')
def _unmute(self):
self.player.unmute()
return self.logger.writeAndReturnLog('CTRL0007')
def _playPause(self):
self.player.play_pause()
return self.logger.writeAndReturnLog('CTRL0005')
def _play(self):
self.player.play()
return self.logger.writeAndReturnLog('CTRL0008')
def _pause(self):
self.player.pause()
return self.logger.writeAndReturnLog('CTRL0009')
def seek(self, option, time):
self._checkPlayerExist()
try:
return self.SEEK_MAP[option](time)
except (AttributeError, OMXPlayerDeadError):
self._raisePlayerError('SEEK0007')
def _seek(self, seekTime):
self.player.seek(seekTime)
return self.logger.writeAndReturnLog('SEEK0005',
{'position': seekTime})
def _setPosition(self, position):
if position > self._videoLength() or position < 0:
self._raisePlayerError('SEEK0004', {'position': position})
self.player.set_position(position)
return self.logger.writeAndReturnLog('SEEK0006',
{'position': position})
def _checkPlayerExist(self):
if not self.player:
self._raisePlayerError('CTRL0003')
def videoStatus(self, status):
if not self.player:
self._raisePlayerError('STAT0003')
try:
return self.STATUS_MAP[status]()
except (AttributeError, OMXPlayerDeadError):
self._raisePlayerError('STAT0003')
def _videoPosition(self):
return self.player.position()
def _videoLength(self):
return self.player.duration()
def _videoVolume(self):
return self.player.volume()
def _playbackStatus(self):
return self.player.playback_status()
def _raisePlayerError(self, logReference, variablesDict={}):
returnMsg = self.logger.writeAndReturnLog(logReference, variablesDict)
raise PlayerError(returnMsg)
class Omx:
def __init__(self, media_folder):
self.player = None
self.media_folder = media_folder
self.expects_loading_exit = False
self.looping = False
def play(self, filename, loop=False):
if self.player:
self.expects_loading_exit = True
self.player.load(filename)
else:
args = ['-b', '--no-osd', '-o', 'both']
if loop:
args += ['--loop']
self.looping = True
else:
self.looping = False
try:
self.player = OMXPlayer(filename, args=args)
except SystemError as e:
print(e)
self.player.stopEvent += self.on_player_stop
self.player.exitEvent += self.on_player_exit
def on_player_stop(self, player):
self.player = None
def on_player_exit(self, player, exit_status):
if self.expects_loading_exit:
self.expects_loading_exit = False
else:
self.player = None
def stop(self):
if not self.player:
return
self.player.stop()
self.player = None
def pause(self):
if not self.player:
return
self.player.play_pause()
def seek_fraction(self, fraction):
if not self.player:
return
duration = self.player.duration()
self.player.set_position(fraction * duration)
def set_volume(self, volume):
if not self.player:
return
if volume > 10:
volume = 10
elif volume < 0:
volume = 0
self.player.set_volume(volume)
def get_source(self):
""" Get player source and remove media folder """
source = self.player.get_source()
if source.startswith(self.media_folder + "/"):
return source[len(self.media_folder) + 1:]
else:
return source
def status(self):
if not self.player:
return {
'status': 'stopped',
'source': None,
}
return {
'status': self.player.playback_status(),
'source': self.get_source(),
'position': self.player.position(),
'duration': self.player.duration(),
'volume': self.player.volume(),
'looping': self.looping,
}
class MyOMXPlayer:
def __init__(self, config):
"""Create an instance of a video player that runs omxplayer in the
background.
"""
self._process = None
self._player = None
self._temp_directory = None
self._load_config(config)
def __del__(self):
if self._temp_directory:
shutil.rmtree(self._temp_directory)
def _get_temp_directory(self):
if not self._temp_directory:
self._temp_directory = tempfile.mkdtemp()
return self._temp_directory
def _load_config(self, config):
self._extensions = config.get('omxplayer', 'extensions') \
.translate(str.maketrans('', '', ' \t\r\n.')) \
.split(',')
self._extra_args = config.get('omxplayer', 'extra_args').split()
self._sound = config.get('omxplayer', 'sound').lower()
assert self._sound in (
'hdmi', 'local', 'both', 'alsa'
), 'Unknown omxplayer sound configuration value: {0} Expected hdmi, local, both or alsa.'.format(
self._sound)
self._alsa_hw_device = parse_hw_device(config.get('alsa', 'hw_device'))
if self._alsa_hw_device != None and self._sound == 'alsa':
self._sound = 'alsa:hw:{},{}'.format(self._alsa_hw_device[0],
self._alsa_hw_device[1])
self._show_titles = config.getboolean('omxplayer', 'show_titles')
if self._show_titles:
title_duration = config.getint('omxplayer', 'title_duration')
if title_duration >= 0:
m, s = divmod(title_duration, 60)
h, m = divmod(m, 60)
self._subtitle_header = '00:00:00,00 --> {:d}:{:02d}:{:02d},00\n'.format(
h, m, s)
else:
self._subtitle_header = '00:00:00,00 --> 99:59:59,00\n'
def supported_extensions(self):
"""Return list of supported file extensions."""
return self._extensions
def player_stop(self):
self._player = None
def play(self, movie, loop=None, vol=0):
"""Play the provided movie file, optionally looping it repeatedly."""
self.stop(3) # Up to 3 second delay to let the old player stop.
# Assemble list of arguments.
#args = ['omxplayer']
args = []
args.extend(['-o', self._sound]) # Add sound arguments.
args.extend(self._extra_args) # Add extra arguments from config.
if vol is not 0:
args.extend(['--vol', str(vol)])
if loop is None:
loop = movie.repeats
if loop <= -1:
args.append('--loop') # Add loop parameter if necessary.
#if self._show_titles and movie.title:
# srt_path = os.path.join(self._get_temp_directory(), 'video_looper.srt')
# with open(srt_path, 'w') as f:
# f.write(self._subtitle_header)
# f.write(movie.title)
# args.extend(['--subtitles', srt_path])
#args.append(movie.filename) # Add movie file path.
# Run omxplayer process and direct standard output to /dev/null.
#self._process = subprocess.Popen(args,
# stdout=open(os.devnull, 'wb'),
# close_fds=True)
# OMXPlayer('path.mp4', args='--no-osd --no-keys -b')
self._player = OMXPlayer(movie.filename,
dbus_name='org.mpris.MediaPlayer2.omxplayer1',
args=args)
self._player.stopEvent = self.player_stop
# if vol is not 0:
# self._player.set_volume(str(vol))
def is_playing(self):
"""Return true if the video player is running, false otherwise."""
#if self._process is None:
# return False
#self._process.poll()
#return self._process.returncode is None
if self._player is None:
return False
try:
if self._player.playback_status() is "Stopped":
self._player = None
return False
else:
return True
except:
self._player = None
return False
#if self._player.playback_status() is "Stopped":
# return False
#return self._player.is_playing()
return True
def pause(self):
#subprocess.call(['/home/pi/pi_video_looper/Adafruit_Video_Looper/dbuscontrol.sh', 'pause'])
if self._player is not None:
self._player.play_pause()
def resume(self):
#subprocess.call(['/home/pi/pi_video_looper/Adafruit_Video_Looper/dbuscontrol.sh', 'play'])
if self._player is not None:
self._player.play_pause()
def stop(self, block_timeout_sec=0):
"""Stop the video player. block_timeout_sec is how many seconds to
block waiting for the player to stop before moving on.
"""
# Stop the player if it's running.
#if self._process is not None and self._process.returncode is None:
# There are a couple processes used by omxplayer, so kill both
# with a pkill command.
# subprocess.call(['pkill', '-9', 'omxplayer'])
# If a blocking timeout was specified, wait up to that amount of time
# for the process to stop.
#start = time.time()
#while self._process is not None and self._process.returncode is None:
# if (time.time() - start) >= block_timeout_sec:
# break
# time.sleep(0)
# Let the process be garbage collected.
#self._process = None
if self._player is not None:
self._player.quit()
self._player = None
@staticmethod
def can_loop_count():
return False
class PlaybackController(object):
def __init__(self):
self.player = None
self.queue = []
self.current_playbackitem = None
self.volume = 0.6
def __str__(self):
if self.current_playbackitem:
return f"{self.get_status()} {self.current_playbackitem.get_title()}. {len(self.queue)} items in queue."
else:
return f"{self.get_status()}. {len(self.queue)} items in queue."
def get_title(self):
if self.current_playbackitem:
return self.current_playbackitem.get_title()
else:
return "Not playing anything."
def _on_omxplayer_exit(self, player, exit_status):
log.info("OMXPlayer exit: {}".format(exit_status))
self.player = None
if exit_status == 0:
self.current_playbackitem = None
self._new_player()
def _new_player(self):
"""Creates a new player by popping from queue."""
log.info("Creating new OMXplayer.")
if self.player is not None:
self.player.quit()
if self.current_playbackitem is None:
if len(self.queue) == 0:
raise ValueError("Nothing to play.")
else:
self.current_playbackitem = self.queue.pop(0)
log.info("Creating player for video: {}".format(
self.current_playbackitem))
self.player = OMXPlayer(self.current_playbackitem.get_direct_url())
self.player.set_volume(self.volume)
self.player.exitEvent.subscribe(self._on_omxplayer_exit)
def add_single_url(self, url):
n_item = PlaybackItem(url)
if n_item is not None:
self.queue.append(n_item)
return True
raise ValueError("Could not get URL")
def playlist(self, url):
log.info("Adding every videos from playlist to queue.")
ydl = youtube_dl.YoutubeDL({
'logger': log,
'extract_flat': 'in_playlist',
'ignoreerrors': True,
})
with ydl: # Downloading youtub-dl infos
result = ydl.extract_info(url, download=False)
for i in result['entries']:
logger.info("queuing video")
if i != result['entries'][0]:
try:
if "://" not in i['url']:
self.add_single_url("https://youtube.com/?v=" +
i['url'])
else:
self.add_single_url(i['url'])
except Exception as e:
log.error("Could not enqueue " + i['url'])
log.error(e)
def play(self):
if self.get_status() == "Playing":
log.debug("Playback already playing.")
return
if self.player is None and len(self.queue) > 0:
self._new_player()
else:
log.error("Nothing to play!")
def stop(self):
if self.player is not None:
self.player.stop()
self.player = None
def playpause(self):
if self.player is None:
log.error("No player running.")
if len(self.queue) > 0:
self.play()
else:
self.player.play_pause()
def pause(self):
if self.get_status() == "Paused":
log.debug("Playback is already paused.")
return
def seek(self, seconds):
if self.player is None:
raise Exception("Player is not running")
self.player.seek(seconds)
def change_volume(self, increment):
self.volume += increment
if self.volume < 0.0:
self.volume = 0.0
elif self.volume > 1.0:
self.volume = 1.0
if self.player is not None:
self.player.set_volume(self.volume)
def get_volume(self):
if self.player is not None:
return self.player.volume()
else:
return self.volume
def get_status(self):
if self.player is None:
return "Stopped"
try:
return self.player.playback_status()
except OMXPlayerDeadError:
log.error("OMXPlayer is dead.")
self.player = None
return "Stopped"
def next_video(self):
self.stop()
self.current_playbackitem = None
self._new_player()
def shutdown(self):
self.stop()
