class ToonPlayer(object):
"""omxplayer-wrapper throws an exception if it can't find an
active dbus listing. This isn't really what I want so I'll
fix that with my own class and some composition.
-b is here to black out the background terminal.
"""
def __init__(self, source):
self._player = OMXPlayer(source, '-b')
sleep(2)
def play(self, source):
self._player.load(source)
def seek(self, time):
self._player.seek(time)
def active(self):
try:
if self._player.is_playing():
return True
else:
return False
except Exception as ex:
return False
class Video_Player:
def __init__(self, player_id, video_path):
self.player_id = player_id
self.video_path = video_path
self.player = OMXPlayer(video_path,
args=['--loop'],
dbus_name="org.mpris.MediaPlayer2.player" +
player_id)
sleep(2)
#
def load(self, video_path):
self.player.hide_video()
self.video_path = video_path
self.player.load(video_path)
def play(self):
self.player.play()
self.player.show_video()
def pause(self):
self.player.hide_video()
self.player.pause()
def stop(self):
self.player.stop()
def start_video_player(
): # Starte OMX Videoplayer der am unteren Bildschirmrand angezeigt wird
# TODO global variablen checken, file_list muss ziemlich sicher nicht global sein,
# video_player wahrscheinlich auch nicht, first_time_video_played wird gar nicht benutzt
global file_list, video_player, index_video, first_time_video_played
print("Laenge von Filelist: {}".format(len(file_list)))
t = threading.currentThread()
index_video = 0
while getattr(t, "running", True):
if len(file_list) > 0:
print("File exists: {}".format(
os.path.exists(file_list[index_video])))
if os.path.exists(file_list[index_video]):
filey = file_list[index_video]
print("VIDEO Playing {}".format(filey), flush=True)
t = threading.Event()
index_video = index_video + 1
if index_video > len(file_list) - 1:
index_video = 0
try:
video_player_playing = video_player.is_playing()
except:
video_player_playing = False
if not video_player_playing:
video_player = OMXPlayer(
filey,
args=[
'--orientation', '270', '--win',
'1312,0,1920,1080', '--no-osd', '--vol',
'-10000000'
],
dbus_name='org.mpris.MeidlaPlayer2.omxplayer1')
else:
video_player.load(filey)
try:
duration_of_video = video_player.duration() + 3
except:
duration_of_video = 3
print("duration of video failed", flush=True)
print(duration_of_video, flush=True)
video_player.mute()
if max_people_reached():
video_player.hide_video()
video_player.play_sync()
sleep(3)
# sleep(duration_of_video)
else:
break
else:
break
def display_rtsp_stream(number):
camera_url = cfg['cam' + str(number)]['url']
lock.acquire()
global g_player
if not g_player:
# first call - for parameters see https://github.com/popcornmix/omxplayer#synopsis
g_player = OMXPlayer(camera_url, ['--no-osd', '--no-keys', '--live'])
else:
if g_player.get_source() != camera_url:
g_player.load(camera_url) # play new stream
lock.release()
def start_video_player():
global file_list, video_player, index_video, first_time_video_played
print("Laenge von Filelist: {}".format(len(file_list)))
t = threading.currentThread()
index_video = 0
while getattr(t, "running", True):
if len(file_list) > 0:
print("File exists: {}".format(
os.path.exists(file_list[index_video])))
if os.path.exists(file_list[index_video]):
filey = file_list[index_video]
print("VIDEO Playing {}".format(filey), flush=True)
t = threading.Event()
index_video = index_video + 1
if index_video > len(file_list) - 1:
index_video = 0
try:
video_player_playing = video_player.is_playing()
except:
video_player_playing = False
print(video_player_playing)
if not video_player_playing:
video_player = OMXPlayer(
filey,
args=[
'--orientation', '270', '--win',
'1312,0,1920,1080', '--no-osd', '--vol',
'-10000000'
],
dbus_name='org.mpris.MeidlaPlayer2.omxplayer1')
else:
video_player.load(filey)
try:
duration_of_video = video_player.duration() + 3
except:
duration_of_video = 3
print("duration of video failed", flush=True)
print(duration_of_video, flush=True)
video_player.mute()
if max_people_reached():
video_player.hide_video()
video_player.play_sync()
sleep(3)
#sleep(duration_of_video)
else:
break
else:
break
class Player:
player = None
playing = False
volume = 0.5
file = 'stub.mp3' # file playing
files = []
currentNumberFile = 0
def __init__(self):
self.totalObject = glob.glob('../*')
for item in self.totalObject:
if os.path.isdir(item):
self.files.append(item)
self.files += glob.glob('../*.mp3')
self.files += glob.glob('../*.wav')
self.countFiles = len(self.files)
self.currentNumberFile = 0
if self.playing == False:
self.playFile(self.file)
def quitPlayer(self):
if self.player != None:
if self.playing != False:
self.playing = False
self.player.quit()
def playerExit(self, code):
self.playing = False
self.player = None
def playFile(self, fileName):
if self.player == None:
self.player = OMXPlayer(fileName)
self.player.set_volume(self.volume)
self.player.exitEvent += lambda _, exit_code: self.playerExit(
exit_code)
else:
self.player.load(fileName)
self.playing = True
def increseVolume(self):
if self.player != None:
if self.volume < 1:
self.volume += 0.1
self.player.set_volume(self.volume)
def decreseVolume(self):
if self.player != None:
if self.volume > 0:
self.volume -= 0.1
self.player.set_volume(self.volume)
) #player_log.info("Play")
player2.pauseEvent += lambda _: print("Pause event triggered for 2"
) #player_log.info("Pause")
player2.stopEvent += lambda _: print("Stop event triggered for 2"
) #player_log.info("Stop")
time.sleep(2.5)
player2.play()
# it takes about this long for omxplayer to warm up and start displaying a picture on a rpi3
time.sleep(15.5)
player2.set_position(20)
player2.pause()
time.sleep(2)
#player.set_aspect_mode('stretch')
#player.set_video_pos(0, 0, 200, 200)
player2.play()
time.sleep(5)
player2.pause()
player2.load(VIDEO_1_PATH)
player2.play()
#player1.play()
time.sleep(5)
#player1.quit()
player2.quit()
#!/usr/bin/env python3
from omxplayer.player import OMXPlayer
from pathlib import Path
from time import sleep
VIDEO_PATH00 = Path("/home/pi/Miac/01.mp4")
player00 = OMXPlayer(VIDEO_PATH00, args='-b')
player00.pause()
player00.hide_video()
sleep(2)
VIDEO_PATH = Path("/home/pi/Miac/03.mp4")
player = OMXPlayer(VIDEO_PATH)
sleep(1)
player.quit()
player.load(VIDEO_PATH)
sleep(2)
player.pause()
print(player.stopEvent)
sleep(2)
player.hide_video()
sleep(2)
player.show_video()
player.quit()
sleep(3)
player00.quit()
class ScreenController:
video_playlist = []
player1 = None
player2 = None
index = None
number_of_cycles = 0
currentIndex = None
nextIndex = None
layer = 10
baseUrl = "http://10.0.0.111:8080/video/"
fadeTime = 2
fadeStep = 5
lowerAlpha = 50
upperAlpha = 250
def __init__(self):
self.index = 0
self.currentIndex = 0
self.nextIndex = self.currentIndex + 1
self.player_log = logging.getLogger("Player")
def setup_player_one(self):
self.player1 = OMXPlayer(self.baseUrl +
self.video_playlist[self.currentIndex],
args='--win 0,0,1920,1080 --layer 2',
dbus_name='orb.mpris.MediaPlayer2.omxplayer1',
pause=True)
self.player1.playEvent += lambda _: self.player_log.info(" 1 Play")
self.player1.pauseEvent += lambda _: self.player_log.info("1 Pause")
self.player1.stopEvent += lambda _: self.player_log.info("1 Stop")
def setup_player_two(self):
self.player2 = OMXPlayer(self.baseUrl +
self.video_playlist[self.nextIndex],
args='--win 0,0,1920,1080 --layer 1',
dbus_name='orb.mpris.MediaPlayer2.omxplayer2',
pause=True)
self.player2.playEvent += lambda _: self.player_log.info(" 2 Play")
self.player2.pauseEvent += lambda _: self.player_log.info("2 Pause")
self.player2.stopEvent += lambda _: self.player_log.info("2 Stop")
def start_playlist(self, videos):
self.layer = len(videos) + 1
videos.sort(reverse=False, key=self.sort_videos)
for x in videos:
self.video_playlist.append(x['id'])
self.setup_player_one()
self.setup_player_two()
self.play_videos(True)
def start_stream(self, stream_id):
videos = json.load(open('videos.json', 'r'))
video = next((item for item in videos if item["id"] == stream_id),
None)
url = video.uri
self.player1 = OMXPlayer(url,
args='--win 0,0,1920,1080',
dbus_name='orb.mpris.MediaPlayer2.omxplayer1')
def stop_stream(self):
self.player1.quit()
def play_single_video(self, video_id):
# videos = json.load(open('videos.json', 'r'))
# video = next((item for item in videos if item["id"] == video_id), None)
url = self.baseUrl + video_id
# check if player is already playing
# if it is playing then fade out player 1
# start player 2 with new video fading in
# quit player 1
# do the same for player 2
if self.player1 == None:
self.player1 = OMXPlayer(
url,
args='--win 0,0,1920,1080 --layer 2',
dbus_name='orb.mpris.MediaPlayer2.omxplayer1')
self.player2 = None
else:
self.player2 = OMXPlayer(
url,
args='--win 0,0,1920,1080 --layer 1',
dbus_name='orb.mpris.MediaPlayer2.omxplayer2')
self.player1 = None
def play_videos(self, init=False):
# Load players with appropiate indexes
if init == False:
self.player1.load(self.baseUrl +
self.video_playlist[self.currentIndex],
pause=True)
self.player2.load(self.baseUrl +
self.video_playlist[self.nextIndex],
pause=True)
# else:
# self.player1.set_alpha(255)
# self.player2.set_alpha(255)
# Play video on player one
self.player1.play()
print("first video started")
#self.fade_player_in(self.player1)
# Sleep for video duration - 2 * self.fadeTime seconds because there are two following fades which sleep for fadeTime seconds each
sleep(self.player1.duration() - (2 * self.fadeTime))
self.player2.play()
print("second video started")
# Start fading player one out and player two in for fadeTime seconds each
self.fade_player_out(self.player1)
self.fade_player_in(self.player2)
# Stop Video One
print("first video quit start")
self.player1.quit()
print("first video quit finished")
# Play for total duration - 1 second
sleep(self.player2.duration() - self.fadeTime)
# Fade player
# self.fade_player_out(self.player2)
self.player2.quit()
# Set new current and next index
self.reset_indexes()
# Recursively call play videos
self.number_of_cycles = self.number_of_cycles + 1
if (self.number_of_cycles < 3):
#if(self.layer > 1):
#self.layer = self.layer - 2
self.play_videos(False)
def reset_indexes(self):
if self.nextIndex + 1 >= len(self.video_playlist):
self.currentIndex = 0
else:
self.currentIndex = self.nextIndex + 1
if self.currentIndex + 1 >= len(self.video_playlist):
self.nextIndex = 0
else:
self.nextIndex = self.currentIndex + 1
print('----AFTER CURRENT----')
print(self.currentIndex)
print('----AFTER NEXT----')
print(self.nextIndex)
def fade_player_out(self, player):
print('----fade_player_out START----')
alpha = self.upperAlpha
no_of_steps = (self.upperAlpha - self.lowerAlpha) / self.fadeTime
fadeSleep = self.fadeTime / no_of_steps
for x in range(no_of_steps):
sleep(fadeSleep)
alpha = alpha - ((self.upperAlpha - self.lowerAlpha) / no_of_steps)
player.set_alpha(alpha)
print('----fade_player_out END----')
def fade_player_in(self, player):
alpha = self.lowerAlpha
no_of_steps = (self.upperAlpha - self.lowerAlpha) / self.fadeTime
fadeSleep = self.fadeTime / no_of_steps
for x in range(no_of_steps):
sleep(fadeSleep)
alpha = alpha + ((self.upperAlpha - self.lowerAlpha) / no_of_steps)
player.set_alpha(alpha)
def get_remaining_seconds(self, player):
remaining_seconds = player.duration() - player.position()
return remaining_seconds
def sort_videos(self, video):
return video['order']
def is_nearly_finished(self, player):
amountPlayed = 0
if player.position() > 0:
amountPlayed = player.position()
percentPlayed = amountPlayed / player.duration()
print(percentPlayed)
if (percentPlayed > 0.9):
return True
else:
return False
#!/usr/bin/env python3
#
#https://python-omxplayer-wrapper.readthedocs.io/en/latest/omxplayer/
from omxplayer.player import OMXPlayer
from pathlib import Path
from time import sleep
VIDEO_PATH = Path("videos/beeLong.mp4")
player = OMXPlayer(VIDEO_PATH)
sleep(5)
player.pause()
player.load("videos/Test0.mp4")
sleep(10)
player.quit()
class OMXPlayerTests(unittest.TestCase):
TEST_FILE_NAME = "./test.mp4"
TEST_URL = "rtmp://192.168.0.1/live/mystream"
def test_opens_file_in_omxplayer(self, popen, *args):
self.patch_and_run_omxplayer()
devnull = MOCK_OPEN()
popen.assert_called_once_with(
['omxplayer', './test.mp4'],
preexec_fn=os.setsid,
stdin=devnull,
stdout=devnull)
@patch('time.sleep')
def test_tries_to_open_dbus_again_if_it_cant_connect(self, *args):
# TODO: Shouldn't this be DBusConnectionError not SystemError
with self.assertRaises(SystemError):
dbus_connection = Mock(side_effect=DBusConnectionError)
self.patch_and_run_omxplayer(Connection=dbus_connection)
self.assertEqual(50, self.player.tries)
@parameterized.expand([
['can_quit', 'CanQuit', [], []],
['can_set_fullscreen', 'CanSetFullscreen', [], []],
['identity', 'Identity', [], []]
])
def test_root_interface_commands(self, popen, sleep, isfile, killpg, command_name,
interface_command_name, *args):
self.patch_and_run_omxplayer()
self.patch_interface_and_run_command('_get_root_interface',
command_name,
interface_command_name, *args)
@parameterized.expand([
['pause', 'Pause', [], []],
['stop', 'Stop', [], []],
['seek', 'Seek', [100], [100]],
['set_position', 'SetPosition', [1], [dbus.ObjectPath("/not/used"),
dbus.Int64(1000000)]],
['list_subtitles', 'ListSubtitles', [], []],
['action', 'Action', ['p'], ['p']]
])
def test_player_interface_commands(self, popen, sleep, isfile, killpg, command_name,
interface_command_name, *args):
self.patch_and_run_omxplayer()
self.patch_interface_and_run_command('_get_player_interface',
command_name,
interface_command_name, *args)
@parameterized.expand([
['can_play', 'CanPlay', [], []],
['can_seek', 'CanSeek', [], []],
['can_control', 'CanControl', [], []],
['playback_status', 'PlaybackStatus', [], []],
['volume', 'Volume', [], []],
['mute', 'Mute', [], []],
['unmute', 'Unmute', [], []],
['position', 'Position', [], []],
['duration', 'Duration', [], []],
['minimum_rate', 'MinimumRate', [], []],
['maximum_rate', 'MaximumRate', [], []],
])
def test_properties_interface_commands(self, popen, sleep, isfile, killpg, command_name,
interface_command_name, *args):
self.patch_and_run_omxplayer()
self.patch_interface_and_run_command('_get_properties_interface',
command_name,
interface_command_name, *args)
def test_quitting(self, popen, sleep, isfile, killpg, *args):
omxplayer_process = Mock()
popen.return_value = omxplayer_process
self.patch_and_run_omxplayer()
with patch('os.getpgid', Mock(return_value=omxplayer_process.pid)):
self.player.quit()
killpg.assert_called_once_with(omxplayer_process.pid, signal.SIGTERM)
def test_quitting_waits_for_omxplayer_to_die(self, popen, sleep, isfile, killpg, *args):
omxplayer_process = Mock()
popen.return_value = omxplayer_process
self.patch_and_run_omxplayer()
with patch('os.getpgid'):
self.player.quit()
omxplayer_process.wait.assert_has_calls([call()])
def test_check_process_still_exists_before_dbus_call(self, *args):
self.patch_and_run_omxplayer()
self.player._process = process = Mock(return_value=None)
process.poll.return_value = None
self.player.can_quit()
process.poll.assert_called_once_with()
def test_checks_media_file_exists_before_launching_player(self, *args):
with patch('os.path') as ospath:
self.patch_and_run_omxplayer()
ospath.isfile.assert_called_once_with(self.TEST_FILE_NAME)
def test_player_doesnt_check_source_path_exists_for_a_url(self, *args):
with patch('os.path') as ospath:
self.patch_and_run_omxplayer_url()
ospath.isfile.assert_not_called()
def test_stop_event(self, *args):
self.patch_and_run_omxplayer(active=True)
callback = Mock()
self.player.stopEvent += callback
self.player.stop()
callback.assert_called_once_with(self.player)
def test_play_event(self, *args):
self.patch_and_run_omxplayer(active=True)
callback = Mock()
self.player.playEvent += callback
with patch.object(self.player, 'is_playing', return_value=False):
self.player.play()
callback.assert_called_once_with(self.player)
def test_pause_event(self, *args):
self.patch_and_run_omxplayer(active=True)
callback = Mock()
self.player.pauseEvent += callback
with patch.object(self.player, 'is_playing', return_value=True):
self.player.pause()
callback.assert_called_once_with(self.player)
def test_play_event_by_play_pause(self, *args):
self.patch_and_run_omxplayer(active=True)
callback = Mock()
self.player.playEvent += callback
with patch.object(self.player, 'is_playing', return_value=False):
self.player.pause()
# play
self.player.play_pause()
callback.assert_called_once_with(self.player)
def test_pause_event_by_play_pause(self, *args):
self.patch_and_run_omxplayer(active=True)
callback = Mock()
self.player.pauseEvent += callback
with patch.object(self.player, 'is_playing', return_value=True):
self.player.play()
# pause
self.player.play_pause()
callback.assert_called_once_with(self.player)
def test_seek_event(self, *args):
self.patch_and_run_omxplayer(active=True)
callback = Mock()
self.player.seekEvent += callback
self.player.seek(3.4)
callback.assert_called_once_with(self.player, 3.4)
def test_position_event(self, *args):
self.patch_and_run_omxplayer(active=True)
callback = Mock()
self.player.positionEvent += callback
self.player.set_position(5.01)
callback.assert_called_once_with(self.player, 5.01)
def patch_interface_and_run_command(self, interface_name,
command_name, interface_command_name,
command_args,
expected_args):
self.player._process.poll = Mock(return_value=None)
with patch.object(self.player, interface_name) as interface:
self.run_command(command_name, *command_args)
# generates a call of the form `call().CanQuit`
expected_call = getattr(call(), interface_command_name)(*expected_args)
interface.assert_has_calls([expected_call])
def run_command(self, command_name, *args):
command = getattr(self.player, command_name)
command(*args)
# Must have the prefix 'patch' for the decorators to take effect
def patch_and_run_omxplayer(self, Connection=Mock(), active=False):
bus_address_finder = Mock()
bus_address_finder.get_address.return_val = "example_bus_address"
self.player = OMXPlayer(self.TEST_FILE_NAME,
bus_address_finder=bus_address_finder,
Connection=Connection)
if active:
self.player._process.poll = Mock(return_value=None)
def patch_and_run_omxplayer_url(self, Connection=Mock(), active=False):
bus_address_finder = Mock()
bus_address_finder.get_address.return_val = "example_bus_address"
self.player = OMXPlayer(self.TEST_URL,
bus_address_finder=bus_address_finder,
Connection=Connection)
if active:
self.player._process.poll = Mock(return_value=None)
def test_load(self, popen, sleep, isfile, killpg, *args):
omxplayer_process = Mock()
popen.return_value = omxplayer_process
with patch('os.getpgid', Mock(return_value=omxplayer_process.pid)):
self.patch_and_run_omxplayer(active=True)
# initial load
self.assertEqual(self.player.get_filename(), './test.mp4')
killpg.assert_not_called()
popen.assert_called_once_with(['omxplayer', './test.mp4'],
preexec_fn=os.setsid,
stdin=MOCK_OPEN(),
stdout=MOCK_OPEN())
# load new video in same OMXPlayer instance
self.player.load('./test2.mp4')
# verify new video is registered in OMXPlayer
self.assertEqual(self.player.get_filename(), './test2.mp4')
# verify omxplayer process for previous video was killed
killpg.assert_called_once_with(omxplayer_process.pid, signal.SIGTERM)
# verify a new process was started for the second time
self.assertEqual(popen.call_count, 2)
def test_init_without_pause(self, popen, sleep, isfile, killpg, *args):
with patch.object(OMXPlayer, 'pause', return_value=None) as mock_method:
self.patch_and_run_omxplayer()
self.assertEqual(mock_method.call_count, 0)
def test_init_pause(self, popen, sleep, isfile, killpg, *args):
with patch.object(OMXPlayer, 'pause', return_value=None) as mock_method:
# self.patch_and_run_omxplayer(pause=False)
bus_address_finder = Mock()
bus_address_finder.get_address.return_val = "example_bus_address"
self.player = OMXPlayer(self.TEST_FILE_NAME,
bus_address_finder=bus_address_finder,
Connection=Mock(),
pause=True)
self.assertEqual(mock_method.call_count, 1)
def test_load_and_pause(self, popen, sleep, isfile, killpg, *args):
with patch.object(OMXPlayer, 'pause', return_value=None) as mock_method:
self.patch_and_run_omxplayer()
self.player.load('./test2.mp4', pause=True)
self.assertEqual(mock_method.call_count, 1)
def test_load_without_pause(self, popen, sleep, isfile, killpg, *args):
with patch.object(OMXPlayer, 'pause', return_value=None) as mock_method:
self.patch_and_run_omxplayer()
self.player.load('./test2.mp4')
self.assertEqual(mock_method.call_count, 0)
folder = 'media/'
vidType = 'mp4'
files = os.listdir(folder)
vids = []
for name in files:
if vidType in name:
vids.append(name)
print(vids)
#loop all videos in the folder
myPath = folder + vids[0]
player = OMXPlayer(myPath, args=['--blank', '--loop'])
while True:
for v in range(len(vids)):
myPath = folder + vids[v]
player.load(myPath)
sleep(20)
'''
while True:
try:
player.is_playing()
except:
break;
'''
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 ScreenController:
video_playlist = []
player1 = None
player2 = None
index = None
index = None
def __init__(self):
self.video_playlist = [
VideoFile(1, "/media/pi/TOSHIBA1/Apocalyptic.mp4"),
VideoFile(2, "/media/pi/TOSHIBA1/ledtime.mp4")
]
self.index = 0
self.player_log = logging.getLogger("Player")
def setup_player_one(self):
self.player1 = OMXPlayer(self.video_playlist[self.index].path,
args='--win 0,0,1920,1080 --layer 2',
bus_address_finder=None,
Connection=None,
dbus_name='orb.mpris.MediaPlayer2.omxplayer1',
pause=True)
self.player1.playEvent += lambda _: self.player_log.info(" 1 Play")
self.player1.pauseEvent += lambda _: self.player_log.info("1 Pause")
self.player1.stopEvent += lambda _: self.player_log.info("1 Stop")
def setup_player_two(self):
self.player2 = OMXPlayer(self.video_playlist[self.index + 1].path,
args='--win 0,0,1920,1080 --layer 3',
bus_address_finder=None,
Connection=None,
dbus_name='orb.mpris.MediaPlayer2.omxplayer2',
pause=True)
self.player2.playEvent += lambda _: self.player_log.info(" 2 Play")
self.player2.pauseEvent += lambda _: self.player_log.info("2 Pause")
self.player2.stopEvent += lambda _: self.player_log.info("2 Stop")
def start_playlist(self):
self.setup_player_one()
self.setup_player_two()
self.play_videos()
def play_videos(self):
alpha1 = 255
self.player1.load(self.video_playlist[self.index].path, True)
self.player2.load(self.video_playlist[self.index + 1].path, True)
self.player1.play()
while self.is_nearly_finished(self.player1) == False:
sleep(1)
#while self.is_nearly_finished(self.player1) == True and alpha1 > 0:
#reductionRate = self.get_remaining_seconds(self.player1)
#alpha1 = alpha1 - reductionRate
#self.player1.set_alpha(alpha1)
#sleep(1)
self.player2.play()
self.player1.stop()
while self.is_nearly_finished(self.player2) == False:
sleep(1)
self.player2.stop()
def get_remaining_seconds(self, player):
remaining_seconds = player.duration() - player.position()
return remaining_seconds
def is_nearly_finished(self, player):
amountPlayed = 0
if player.position() > 0:
amountPlayed = player.position()
percentPlayed = amountPlayed / player.duration()
print(percentPlayed)
if (percentPlayed > 0.9):
return True
else:
return False
class MoviePlayer(metaclass=EventDispatcher):
# Evemts
MOVIE_STOP_EVENT = "MoviePlayer:Stop"
MOVIE_START_EVENT = "MoviePlayer:Start"
MOVIE_TRIGER_EVENT = "MoviePlayer:Trigger"
MOVIE_PLAY_EVENT = "MoviePlayer:Play"
MOVIE_EXIT_EVENT = "MoviePlayer:Exit"
player = None
isPlaying = False
_triggers = []
def __init__(self, volume=4):
self.volume = volume
def play(self, url, loop=False):
self.path = Path(url)
self._triggers = []
if (self.player == None):
#, '--vol', '0'
props = ['--no-osd', '--no-keys']
if (loop):
props.append('--loop')
self.player = OMXPlayer(self.path, args=props)
# self.player.pauseEvent += lambda _: player_log.info("Pause")
# self.player.playEvent += lambda _: player_log.info("Play")
self.player.exitEvent += lambda _, exit_code: self.handleExit(
exit_code)
else:
self.player.load(self.path)
self.isPlaying = True
def handleExit(self, eve):
self.isPlaying = False
self.emit_event(MoviePlayer.MOVIE_EXIT_EVENT)
def addTriggers(self, triggers):
self._triggers = []
if (len(triggers) > 0):
for trigger in triggers:
self._triggers.append(
Trigger(trigger["time"], trigger["actions"]))
def update(self):
try:
if (self.isPlaying == True and self.player != None
and len(self._triggers) > 0
and self.player.is_playing() == True):
frame = self.player.position()
for t in self._triggers:
if (frame >= t.frame):
self._triggers.remove(t)
self.emit_event(MoviePlayer.MOVIE_TRIGER_EVENT,
t.actions)
except:
pass
def pause(self):
self.isPlaying = False
def stop(self):
self.isPlaying = False
self._triggers = []
try:
self.player.stop()
self.player = None
except ValueError:
print("Oops! That was no valid number. Try again...")
def destroy(self):
self.player.quit()
self.player = None
self._triggers = []
class OMXPlayerTests(unittest.TestCase):
TEST_FILE_NAME = "./test.mp4"
TEST_URL = "rtmp://192.168.0.1/live/mystream"
def test_opens_file_in_omxplayer(self, popen, *args):
self.patch_and_run_omxplayer()
devnull = MOCK_OPEN()
popen.assert_called_once_with(
['omxplayer', './test.mp4'],
preexec_fn=os.setsid,
stdin=devnull,
stdout=devnull)
@patch('time.sleep')
def test_tries_to_open_dbus_again_if_it_cant_connect(self, *args):
# TODO: Shouldn't this be DBusConnectionError not SystemError
with self.assertRaises(SystemError):
dbus_connection = Mock(side_effect=DBusConnectionError)
self.patch_and_run_omxplayer(Connection=dbus_connection)
self.assertEqual(50, self.player.tries)
@parameterized.expand([
['can_quit', 'CanQuit', [], []],
['can_set_fullscreen', 'CanSetFullscreen', [], []],
['identity', 'Identity', [], []]
])
def test_root_interface_properties(self, popen, sleep, isfile, killpg, atexit, command_name,
property_name, command_args, expected_dbus_call_args):
self.patch_and_run_omxplayer()
self.player._root_interface.dbus_interface = "org.mpris.MediaPlayer2"
interface = self.player._properties_interface
interface.reset_mock()
self.patch_interface_and_run_command(command_name, command_args)
expected_call = call.Get("org.mpris.MediaPlayer2", property_name, *expected_dbus_call_args)
interface.assert_has_calls([expected_call])
@parameterized.expand([
['pause', 'Pause', [], []],
['stop', 'Stop', [], []],
['seek', 'Seek', [100], [dbus.Int64(100 * 1e6)]],
['set_position', 'SetPosition', [1], [dbus.ObjectPath("/not/used"), dbus.Int64(1000000)]],
['list_subtitles', 'ListSubtitles', [], []],
['mute', 'Mute', [], []],
['unmute', 'Unmute', [], []],
['action', 'Action', ['p'], ['p']]
])
def test_player_interface_commands(self, popen, sleep, isfile, killpg, atexit, command_name,
interface_command_name, command_args, expected_dbus_call_args):
self.patch_and_run_omxplayer()
self.player._player_interface.dbus_interface = "org.mpris.MediaPlayer2"
interface = self.player._player_interface
interface.reset_mock()
self.patch_interface_and_run_command(command_name, command_args)
expected_call = getattr(call, interface_command_name)(*expected_dbus_call_args)
interface.assert_has_calls([expected_call])
@parameterized.expand([
['can_play', 'CanPlay', True, dbus.Boolean(True)],
['can_seek', 'CanSeek', False, dbus.Boolean(False)],
['can_control', 'CanControl', True, dbus.Boolean(True)],
['playback_status', 'PlaybackStatus', "playing", dbus.String("playing")],
['position', 'Position', 1.2, dbus.Int64(1.2 * 1000 * 1000)],
['duration', 'Duration', 10.1, dbus.Int64(10.1 * 1000 * 1000)],
['volume', 'Volume', 10, dbus.Int64(10)],
['minimum_rate', 'MinimumRate', 0.1, dbus.Double(0.1)],
['maximum_rate', 'MaximumRate', 4.0, dbus.Double(4.0)],
])
def test_player_interface_properties(self, popen, sleep, isfile, killpg, atexit,
command_name, property_name, expected_result, property_result):
interface_address = "org.mpris.MediaPlayer2"
self.patch_and_run_omxplayer()
self.player._root_interface.dbus_interface = interface_address
interface = self.player._properties_interface
interface.reset_mock()
mock = interface.Get
mock.configure_mock(return_value=property_result)
result = self.patch_interface_and_run_command(command_name, [])
interface.assert_has_calls([(call.Get(interface_address, property_name))])
self.assertEqual(expected_result, result)
def test_quitting(self, popen, sleep, isfile, killpg, *args):
omxplayer_process = Mock()
popen.return_value = omxplayer_process
self.patch_and_run_omxplayer()
with patch('os.getpgid', Mock(return_value=omxplayer_process.pid)):
self.player.quit()
killpg.assert_called_once_with(omxplayer_process.pid, signal.SIGTERM)
def test_quitting_waits_for_omxplayer_to_die(self, popen, *args):
omxplayer_process = Mock()
popen.return_value = omxplayer_process
self.patch_and_run_omxplayer()
with patch('os.getpgid'):
self.player.quit()
omxplayer_process.wait.assert_has_calls([call()])
def test_check_process_still_exists_before_dbus_call(self, *args):
self.patch_and_run_omxplayer()
self.player._process = process = Mock(return_value=None)
process.poll.return_value = None
self.player.can_quit()
process.poll.assert_called_once_with()
def test_stop_event(self, *args):
self.patch_and_run_omxplayer(active=True)
callback = Mock()
self.player.stopEvent += callback
self.player.stop()
callback.assert_called_once_with(self.player)
def test_play_event(self, *args):
self.patch_and_run_omxplayer(active=True)
callback = Mock()
self.player.playEvent += callback
with patch.object(self.player, 'is_playing', return_value=False):
self.player.play()
callback.assert_called_once_with(self.player)
def test_pause_event(self, *args):
self.patch_and_run_omxplayer(active=True)
callback = Mock()
self.player.pauseEvent += callback
with patch.object(self.player, 'is_playing', return_value=True):
self.player.pause()
callback.assert_called_once_with(self.player)
def test_play_event_by_play_pause(self, *args):
self.patch_and_run_omxplayer(active=True)
callback = Mock()
self.player.playEvent += callback
with patch.object(self.player, 'is_playing', return_value=False):
self.player.pause()
# play
self.player.play_pause()
callback.assert_called_once_with(self.player)
def test_pause_event_by_play_pause(self, *args):
self.patch_and_run_omxplayer(active=True)
callback = Mock()
self.player.pauseEvent += callback
with patch.object(self.player, 'is_playing', return_value=True):
self.player.play()
# pause
self.player.play_pause()
callback.assert_called_once_with(self.player)
def test_seek_event(self, *args):
self.patch_and_run_omxplayer(active=True)
callback = Mock()
self.player.seekEvent += callback
self.player.seek(3.4)
callback.assert_called_once_with(self.player, 3.4)
def test_position_event(self, *args):
self.patch_and_run_omxplayer(active=True)
callback = Mock()
self.player.positionEvent += callback
self.player.set_position(5.01)
callback.assert_called_once_with(self.player, 5.01)
def patch_interface_and_run_command(self, command_name, command_args):
self.player._process.poll = Mock(return_value=None)
result = getattr(self.player, command_name)(*command_args)
return result
# Must have the prefix 'patch' for the decorators to take effect
def patch_and_run_omxplayer(self, Connection=Mock(), active=False):
bus_address_finder = Mock()
bus_address_finder.get_address.return_val = "example_bus_address"
self.player = OMXPlayer(self.TEST_FILE_NAME,
bus_address_finder=bus_address_finder,
Connection=Connection)
if active:
self.player._process.poll = Mock(return_value=None)
def patch_and_run_omxplayer_url(self, Connection=Mock(), active=False):
bus_address_finder = Mock()
bus_address_finder.get_address.return_val = "example_bus_address"
self.player = OMXPlayer(self.TEST_URL,
bus_address_finder=bus_address_finder,
Connection=Connection)
if active:
self.player._process.poll = Mock(return_value=None)
def test_load(self, popen, sleep, isfile, killpg, *args):
omxplayer_process = Mock()
popen.return_value = omxplayer_process
with patch('os.getpgid', Mock(return_value=omxplayer_process.pid)):
self.patch_and_run_omxplayer(active=True)
# initial load
self.assertEqual(self.player.get_filename(), './test.mp4')
killpg.assert_not_called()
popen.assert_called_once_with(['omxplayer', './test.mp4'],
preexec_fn=os.setsid,
stdin=MOCK_OPEN(),
stdout=MOCK_OPEN())
# load new video in same OMXPlayer instance
self.player.load('./test2.mp4')
# verify new video is registered in OMXPlayer
self.assertEqual(self.player.get_filename(), './test2.mp4')
# verify omxplayer process for previous video was killed
killpg.assert_called_once_with(omxplayer_process.pid, signal.SIGTERM)
# verify a new process was started for the second time
self.assertEqual(popen.call_count, 2)
def test_init_without_pause(self, *args):
with patch.object(OMXPlayer, 'pause', return_value=None) as pause_method:
self.patch_and_run_omxplayer()
self.assertEqual(pause_method.call_count, 0)
def test_init_pause(self, *args):
with patch.object(OMXPlayer, 'pause', return_value=None) as pause_method:
# self.patch_and_run_omxplayer(pause=False)
bus_address_finder = Mock()
bus_address_finder.get_address.return_val = "example_bus_address"
self.player = OMXPlayer(self.TEST_FILE_NAME,
bus_address_finder=bus_address_finder,
Connection=Mock(),
pause=True)
self.assertEqual(pause_method.call_count, 1)
def test_load_and_pause(self, *args):
with patch.object(OMXPlayer, 'pause', return_value=None) as pause_method:
self.patch_and_run_omxplayer()
self.player.load('./test2.mp4', pause=True)
self.assertEqual(pause_method.call_count, 1)
def test_load_without_pause(self, *args):
with patch.object(OMXPlayer, 'pause', return_value=None) as pause_method:
self.patch_and_run_omxplayer()
self.player.load('./test2.mp4')
self.assertEqual(pause_method.call_count, 0)
def test_register_quit_handler_atexit(self, popen, sleep, isfile, killpg, atexit):
self.patch_and_run_omxplayer()
atexit.assert_called_once_with(self.player.quit)
class Video(Player):
"""Video player class."""
def __init__(self):
"""Init as Player."""
super(Video, self).__init__()
self.logger = logging.getLogger("oxo")
self.close_player = False
self.stopped = False
@classmethod
def filepath(cls, clip):
"""Return disk location of a clip."""
return os.path.join(DATA_DIR, "clips", clip["filename"])
def run(self):
"""Thread target."""
while not self.stopped:
current_clip = Video.get_next()
if current_clip is None:
self.logger.debug("No clips in database. Waiting...")
sleep(5)
else:
self.logger.debug(
"Starting video player with clip [{}]".format(
current_clip["filename"][:6]))
full_path = self.filepath(current_clip)
if machine() == "armv7l":
player_args = [
'--blank', '-o', 'hdmi', '--loop', '--no-osd',
'--aspect-mode', 'fill', '--win', "'0, 0, 810, 540'"
]
else:
player_args = ['-b', '--loop']
if self.player is None:
self.player = OMXPlayer(full_path, player_args)
else:
self.player.load(full_path, player_args)
self.player.play()
sleep(5)
self.player.pause()
self.logger.debug("Exit video player")
@classmethod
def interact(cls, line, stdin):
"""Enqueue clips continuously through mplayer STDIN."""
start_playback = "Starting playback..."
logger = logging.getLogger("oxo")
if start_playback in line:
nextclip = cls.get_next()
path = cls.filepath(nextclip)
cmd = "loadfile {} 1\n".format(path)
logger.info("Enqueued clip {}".format(nextclip['filename']))
stdin.put(cmd)
@classmethod
def get_next(cls):
"""Select recently added video or a random one from db."""
q = Query()
q_incoming = db.search(q.incoming == True)
if len(q_incoming) > 0:
rv = q_incoming[0]
db.update({"incoming": False}, q.incoming == True)
logger.info("Enqueuing shortlisted clip {}".format(rv["filename"]))
else:
q = Query()
try:
q_clips = db.search(q.type == "clip")
except JSONDecodeError:
rv = None
else:
rv = choice(q_clips) if len(q_clips) > 0 else None
return rv
def stop(self):
"""Quit omxplayer instance."""
self.logger.debug("Stopping {} player...".format(
self.__class__.__name__))
self.stopped = True
if self.running:
self.player.quit()
self.logger.info("{} stopped".format(self.__class__.__name__))
else:
self.logger.debug("{} did not play".format(
self.__class__.__name__))
player1.pause() player1.hide_video() player1.set_position(videos[0].start) player1.set_volume(videos[0].volume) player1.set_aspect_mode(videos[0].aspect) # Show player 1 player1.show_video() player1.play() sleep(5) # Load player 1 with video 2 player1.pause() player1.hide_video() player1.load(videos[1].path, pause=True) player1.set_position(videos[1].start) player1.set_volume(videos[1].volume) player1.set_aspect_mode(videos[1].aspect) player1.show_video() player1.play() sleep(5) # Load player 1 with video 3 player1.pause() player1.hide_video() player1.load(videos[2].path, pause=True) player1.set_position(videos[2].start) player1.set_volume(videos[2].volume) player1.set_aspect_mode(videos[2].aspect)
class OMXPlayerTests(unittest.TestCase):
TEST_FILE_NAME = "./test.mp4"
TEST_URL = "rtmp://192.168.0.1/live/mystream"
def test_opens_file_in_omxplayer(self, popen, *args):
self.patch_and_run_omxplayer()
devnull = MOCK_OPEN()
popen.assert_called_once_with(['omxplayer', './test.mp4'],
preexec_fn=os.setsid,
stdin=devnull,
stdout=devnull)
@patch('time.sleep')
def test_tries_to_open_dbus_again_if_it_cant_connect(self, *args):
# TODO: Shouldn't this be DBusConnectionError not SystemError
with self.assertRaises(SystemError):
dbus_connection = Mock(side_effect=DBusConnectionError)
self.patch_and_run_omxplayer(Connection=dbus_connection)
self.assertEqual(50, self.player.tries)
def test_dbus_failure_kills(self, popen, sleep, isfile, killpg, *args):
omxplayer_process = Mock()
popen.return_value = omxplayer_process
dbus_connection = Mock(side_effect=DBusConnectionError)
with patch('os.getpgid', Mock(return_value=omxplayer_process.pid)):
with self.assertRaises(SystemError):
self.patch_and_run_omxplayer(Connection=dbus_connection)
killpg.assert_called_once_with(omxplayer_process.pid,
signal.SIGTERM)
def test_thread_failure_kills(self, popen, sleep, isfile, killpg, *args):
omxplayer_process = Mock()
popen.return_value = omxplayer_process
with patch('threading.Thread', Mock(side_effect=RuntimeError)):
with patch('os.getpgid', Mock(return_value=omxplayer_process.pid)):
with self.assertRaises(RuntimeError):
self.patch_and_run_omxplayer()
killpg.assert_called_once_with(omxplayer_process.pid,
signal.SIGTERM)
@parameterized.expand([['can_quit', 'CanQuit', [], []],
['can_set_fullscreen', 'CanSetFullscreen', [], []],
['identity', 'Identity', [], []]])
def test_root_interface_properties(self, popen, sleep, isfile, killpg,
atexit, command_name, property_name,
command_args, expected_dbus_call_args):
self.patch_and_run_omxplayer()
self.player._root_interface.dbus_interface = "org.mpris.MediaPlayer2"
interface = self.player._properties_interface
interface.reset_mock()
self.patch_interface_and_run_command(command_name, command_args)
expected_call = call.Get("org.mpris.MediaPlayer2", property_name,
*expected_dbus_call_args)
interface.assert_has_calls([expected_call])
@parameterized.expand(
[['pause', 'Pause', [], []], ['stop', 'Stop', [], []],
['seek', 'Seek', [100], [dbus.Int64(100 * 1e6)]],
[
'set_position', 'SetPosition', [1],
[dbus.ObjectPath("/not/used"),
dbus.Int64(1000000)]
], ['set_layer', 'SetLayer', [1], [dbus.Int64(1)]],
['list_subtitles', 'ListSubtitles', [], []], ['mute', 'Mute', [], []],
['unmute', 'Unmute', [], []], ['action', 'Action', ['p'], ['p']]])
def test_player_interface_commands(self, popen, sleep, isfile, killpg,
atexit, command_name,
interface_command_name, command_args,
expected_dbus_call_args):
self.patch_and_run_omxplayer()
self.player._player_interface.dbus_interface = "org.mpris.MediaPlayer2"
interface = self.player._player_interface
interface.reset_mock()
self.patch_interface_and_run_command(command_name, command_args)
expected_call = getattr(
call, interface_command_name)(*expected_dbus_call_args)
interface.assert_has_calls([expected_call])
@parameterized.expand([
['can_play', 'CanPlay', True,
dbus.Boolean(True)],
['can_seek', 'CanSeek', False,
dbus.Boolean(False)],
['can_control', 'CanControl', True,
dbus.Boolean(True)],
[
'playback_status', 'PlaybackStatus', "playing",
dbus.String("playing")
],
['position', 'Position', 1.2,
dbus.Int64(1.2 * 1000 * 1000)],
['duration', 'Duration', 10.1,
dbus.Int64(10.1 * 1000 * 1000)],
['volume', 'Volume', 10, dbus.Int64(10)],
['minimum_rate', 'MinimumRate', 0.1,
dbus.Double(0.1)],
['maximum_rate', 'MaximumRate', 4.0,
dbus.Double(4.0)],
])
def test_player_interface_properties(self, popen, sleep, isfile, killpg,
atexit, command_name, property_name,
expected_result, property_result):
interface_address = "org.mpris.MediaPlayer2"
self.patch_and_run_omxplayer()
self.player._root_interface.dbus_interface = interface_address
interface = self.player._properties_interface
interface.reset_mock()
mock = interface.Get
mock.configure_mock(return_value=property_result)
result = self.patch_interface_and_run_command(command_name, [])
interface.assert_has_calls([(call.Get(interface_address,
property_name))])
self.assertEqual(expected_result, result)
def test_quitting(self, popen, sleep, isfile, killpg, *args):
omxplayer_process = Mock()
popen.return_value = omxplayer_process
self.patch_and_run_omxplayer()
with patch('os.getpgid', Mock(return_value=omxplayer_process.pid)):
self.player.quit()
killpg.assert_called_once_with(omxplayer_process.pid,
signal.SIGTERM)
def test_quitting_waits_for_omxplayer_to_die(self, popen, *args):
omxplayer_process = Mock()
popen.return_value = omxplayer_process
self.patch_and_run_omxplayer()
with patch('os.getpgid'):
self.player.quit()
omxplayer_process.wait.assert_has_calls([call()])
def test_quitting_when_already_dead(self, popen, sleep, isfile, killpg,
*args):
omxplayer_process = Mock()
popen.return_value = omxplayer_process
self.patch_and_run_omxplayer()
# Pretend the process is already dead
killpg.configure_mock(side_effect=OSError)
with patch('os.getpgid', Mock(return_value=omxplayer_process.pid)):
# This tests that quit handles the OSError
self.player.quit()
killpg.assert_called_once_with(omxplayer_process.pid,
signal.SIGTERM)
def test_quitting_twice(self, popen, sleep, isfile, killpg, *args):
omxplayer_process = Mock()
popen.return_value = omxplayer_process
self.patch_and_run_omxplayer()
with patch('os.getpgid', Mock(return_value=omxplayer_process.pid)):
# This should not raise, and call killpg once
self.player.quit()
self.player.quit()
killpg.assert_called_once_with(omxplayer_process.pid,
signal.SIGTERM)
def test_check_process_still_exists_before_dbus_call(self, *args):
self.patch_and_run_omxplayer()
self.player._process = process = Mock(return_value=None)
process.poll.return_value = None
self.player.can_quit()
process.poll.assert_called_once_with()
def test_stop_event(self, *args):
self.patch_and_run_omxplayer(active=True)
callback = Mock()
self.player.stopEvent += callback
self.player.stop()
callback.assert_called_once_with(self.player)
def test_play_event(self, *args):
self.patch_and_run_omxplayer(active=True)
callback = Mock()
self.player.playEvent += callback
with patch.object(self.player, 'is_playing', return_value=False):
self.player.play()
callback.assert_called_once_with(self.player)
def test_pause_event(self, *args):
self.patch_and_run_omxplayer(active=True)
callback = Mock()
self.player.pauseEvent += callback
with patch.object(self.player, 'is_playing', return_value=True):
self.player.pause()
callback.assert_called_once_with(self.player)
def test_play_event_by_play_pause(self, *args):
self.patch_and_run_omxplayer(active=True)
callback = Mock()
self.player.playEvent += callback
with patch.object(self.player, 'is_playing', return_value=False):
self.player.pause()
# play
self.player.play_pause()
callback.assert_called_once_with(self.player)
def test_pause_event_by_play_pause(self, *args):
self.patch_and_run_omxplayer(active=True)
callback = Mock()
self.player.pauseEvent += callback
with patch.object(self.player, 'is_playing', return_value=True):
self.player.play()
# pause
self.player.play_pause()
callback.assert_called_once_with(self.player)
def test_seek_event(self, *args):
self.patch_and_run_omxplayer(active=True)
callback = Mock()
self.player.seekEvent += callback
self.player.seek(3.4)
callback.assert_called_once_with(self.player, 3.4)
def test_position_event(self, *args):
self.patch_and_run_omxplayer(active=True)
callback = Mock()
self.player.positionEvent += callback
self.player.set_position(5.01)
callback.assert_called_once_with(self.player, 5.01)
def patch_interface_and_run_command(self, command_name, command_args):
self.player._process.poll = Mock(return_value=None)
result = getattr(self.player, command_name)(*command_args)
return result
# Must have the prefix 'patch' for the decorators to take effect
def patch_and_run_omxplayer(self, Connection=Mock(), active=False):
bus_address_finder = Mock()
bus_address_finder.get_address.return_val = "example_bus_address"
self.player = OMXPlayer(self.TEST_FILE_NAME,
bus_address_finder=bus_address_finder,
Connection=Connection)
if active:
self.player._process.poll = Mock(return_value=None)
def patch_and_run_omxplayer_url(self, Connection=Mock(), active=False):
bus_address_finder = Mock()
bus_address_finder.get_address.return_val = "example_bus_address"
self.player = OMXPlayer(self.TEST_URL,
bus_address_finder=bus_address_finder,
Connection=Connection)
if active:
self.player._process.poll = Mock(return_value=None)
def test_load(self, popen, sleep, isfile, killpg, *args):
omxplayer_process = Mock()
popen.return_value = omxplayer_process
with patch('os.getpgid', Mock(return_value=omxplayer_process.pid)):
self.patch_and_run_omxplayer(active=True)
# initial load
self.assertEqual(self.player.get_filename(), './test.mp4')
killpg.assert_not_called()
popen.assert_called_once_with(['omxplayer', './test.mp4'],
preexec_fn=os.setsid,
stdin=MOCK_OPEN(),
stdout=MOCK_OPEN())
# load new video in same OMXPlayer instance
self.player.load('./test2.mp4')
# verify new video is registered in OMXPlayer
self.assertEqual(self.player.get_filename(), './test2.mp4')
# verify omxplayer process for previous video was killed
killpg.assert_called_once_with(omxplayer_process.pid,
signal.SIGTERM)
# verify a new process was started for the second time
self.assertEqual(popen.call_count, 2)
def test_init_without_pause(self, *args):
with patch.object(OMXPlayer, 'pause',
return_value=None) as pause_method:
self.patch_and_run_omxplayer()
self.assertEqual(pause_method.call_count, 0)
def test_init_pause(self, *args):
with patch.object(OMXPlayer, 'pause',
return_value=None) as pause_method:
# self.patch_and_run_omxplayer(pause=False)
bus_address_finder = Mock()
bus_address_finder.get_address.return_val = "example_bus_address"
self.player = OMXPlayer(self.TEST_FILE_NAME,
bus_address_finder=bus_address_finder,
Connection=Mock(),
pause=True)
self.assertEqual(pause_method.call_count, 1)
def test_load_and_pause(self, *args):
with patch.object(OMXPlayer, 'pause',
return_value=None) as pause_method:
self.patch_and_run_omxplayer()
self.player.load('./test2.mp4', pause=True)
self.assertEqual(pause_method.call_count, 1)
def test_load_without_pause(self, *args):
with patch.object(OMXPlayer, 'pause',
return_value=None) as pause_method:
self.patch_and_run_omxplayer()
self.player.load('./test2.mp4')
self.assertEqual(pause_method.call_count, 0)
def test_register_quit_handler_atexit(self, popen, sleep, isfile, killpg,
atexit):
self.patch_and_run_omxplayer()
atexit.assert_called_once_with(self.player.quit)
year = int(target)
except:
year = 0
if year == 0:
exit()
else:
# Normal Mode
c = ser.read_until()
cmd = c.decode('ascii', "ignore")
if cmd.startswith("G"):
# 'GO' Command: Switch to startup clip, then go get a list of the closest file(s)
year = int(cmd[1:5])
try:
player.load(path + startup_clip)
time.sleep(1)
player.pause()
except:
print("player died")
print("Requested year: " + str(year))
pl = get_files(year)
for i in range(len(pl)):
p = library[pl[i]]
print(
str(pl[i]) + ": (" + str(p['year']) + "." + str(p['month']) +
" ) " + p['file'] + " @" + str(p['last_play']))
do_style(1)
class Player:
def __init__(self, video_file):
self.player = None
self.path = ''
self.load(video_file)
def load(self, video_file):
print('Player loading {0}'.format(video_file))
#if self.player != None:
# self.player.stop()
# del self.player
self.path = os.path.join(media_dir, video_file)
if self.player is None:
self.player = OMXPlayer(self.path, args=['--loop', '--blank', '-o', 'both'])
else:
self.player.load(self.path)
self.player.stopEvent += lambda _: self._complete()
self.player.pauseEvent += lambda _: self._pauseEvent()
self.player.playEvent += lambda _: self._playEvent()
self.player.positionEvent += lambda _: self._positionEvent()
self.player.seekEvent += lambda _: self._seekEvent()
def _complete(self):
print('Playback finished.')
def _pauseEvent(self):
print('Player pause event.')
def _playEvent(self):
print('Player play event.')
def _positionEvent(self):
print('Player position event.')
def _positionEvent(self):
print('Player seek event.')
def set_pause(self, p):
if p:
self.player.pause()
else:
self.player.play()
def get_pause(self):
if self.player.is_playing():
return False
else:
return True
def toggle_pause(self):
if self.player.is_playing():
self.player.pause()
else:
self.player.play()
def stop(self):
self.player.stop()
def quit(self):
self.player.quit()
def reload(self):
print('Reloading {0}'.format(self.path))
self.load(self.path)
def get_path(self):
return self.path
class ScreenController:
video_playlist = []
player1 = None
player2 = None
index = None
number_of_cycles = 0
currentIndex = None
nextIndex = None
def __init__(self):
self.video_playlist = [VideoFile(1, "/media/pi/TOSHIBA1/Apocalyptic.mp4"), VideoFile(2, "/media/pi/TOSHIBA1/ledtime.mp4"), VideoFile(3, "/media/pi/TOSHIBA1/DiscoLightsVidevo.mov")]
self.index = 0
self.currentIndex = 0
self.nextIndex = self.currentIndex+1
self.player_log = logging.getLogger("Player")
def setup_player_one(self):
self.player1 = OMXPlayer(self.video_playlist[self.index].path, args='--win 0,0,1920,1080 --layer 2', dbus_name='orb.mpris.MediaPlayer2.omxplayer1', pause = True)
self.player1.playEvent += lambda _: self.player_log.info(" 1 Play")
self.player1.pauseEvent += lambda _: self.player_log.info("1 Pause")
self.player1.stopEvent += lambda _: self.player_log.info("1 Stop")
def setup_player_two(self):
self.player2 = OMXPlayer(self.video_playlist[self.index + 1].path, args='--win 0,0,1920,1080 --layer 1', dbus_name='orb.mpris.MediaPlayer2.omxplayer2', pause = True)
self.player2.playEvent += lambda _: self.player_log.info(" 2 Play")
self.player2.pauseEvent += lambda _: self.player_log.info("2 Pause")
self.player2.stopEvent += lambda _: self.player_log.info("2 Stop")
def start_playlist(self):
self.setup_player_one();
self.setup_player_two();
self.play_videos(True);
def play_videos(self, init = False):
# Load players with appropiate indexes
self.player1.load(self.video_playlist[self.currentIndex].path, True)
self.player2.load(self.video_playlist[self.nextIndex].path, True)
self.player1.set_alpha(255)
self.player2.set_alpha(255)
# Play for total duration - 1 second
self.player1.play()
sleep(self.player1.duration()-1)
# Fade player
self.fade_player_out(self.player1)
# Play for total duration - 1 second
self.player2.play()
sleep(self.player2.duration()-1)
# Set new current and next index
self.reset_indexes()
# Recursively call play videos
self.number_of_cycles = self.number_of_cycles + 1
if(self.number_of_cycles < 2):
self.play_videos(False)
# Fade player
self.fade_player_out(self.player2)
def reset_indexes(self):
if self.nextIndex + 1 >= len(self.video_playlist):
self.currentIndex = 0
else :
self.currentIndex = self.nextIndex + 1
if self.currentIndex + 1 >= len(self.video_playlist):
self.nextIndex = 0
else:
self.nextIndex = self.currentIndex + 1
print('AFTER CURRENT')
print(self.currentIndex)
print('AFTER NEXT')
print(self.nextIndex)
def fade_player_out(self, player):
alpha = 200
for x in range(6):
sleep(0.1)
alpha = alpha - 20
player.set_alpha(alpha)
alpha = 200
def get_remaining_seconds(self, player):
remaining_seconds = player.duration() - player.position()
return remaining_seconds
def is_nearly_finished(self, player):
amountPlayed = 0
if player.position() > 0:
amountPlayed = player.position();
percentPlayed = amountPlayed/player.duration()
print(percentPlayed)
if(percentPlayed > 0.9):
return True;
else:
return False;
