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;