def play_video(video): VIDEO_PATH = Path(video) player = None try: arguments = "--no-osd -o alsa --aspect-mode fill" if DEV_MODE: arguments = arguments + " --win '0 0 400 300'" player = OMXPlayer(VIDEO_PATH, args=arguments) # App is real slow to boot and start playing video time.sleep(1) player.play() except SystemError: print "OMXPlayer failed to start, maybe" print "Sleeping for 60 seconds in case it didn't actually fail..." time.sleep(60) except OMXPlayerDeadError: print "OMXPlayer appeared to close, video likely ended!" except DBusException: print "OMXPlayer not replying, video likely ended!" finally: return player
def play(self, audioID: str, saveID: str) -> NoReturn: """ Play a pre-recorded response from the cache, and then copy and resave it with a current audio index number. """ AUDIO_PATH = Path("../data/cache/responses/" + audioID + ".wav") audiolen = TinyTag.get( AUDIO_PATH ).duration # Get the duration of the recording of the reply try: player = OMXPlayer(AUDIO_PATH) # Play the recording # Handle potential errors when the user hasn't set a speech pause amount. # In these cases, no pause pause = float(self.cfg.pause if ( type(self.cfg.pause) is not None) else 0) sleep( audiolen + pause ) # Allow the audio to finish playing before quitting, and add a little leeway except Exception: raise AudioPlaybackError else: subprocess.call( f"cp ../data/cache/responses/{audioID}.wav ../data/cache/responses/{saveID}.wav", shell=True) pass finally: player.quit() # Exit the player
class Gameplay3(Result): t = 0.0 def __init__(self): super(Gameplay3, self).__init__() self.image = Sprite(position=(0, 0), image=load_image("images/things/intro.png")) self.next_state = "GAMEPLAY3a" def startup(self, persistent): self.rt = config.load("positions", "center", [[0, 0], [0, 0], [0, 0]]) self.persist = persistent video = "images/things/intro.mp4" if OMXPlayer is not None and os.path.isfile(video): self.player = OMXPlayer(video, args=['--no-osd', '--loop']) else: self.player = None self.t = 0 def update(self, dt): self.t += dt if self.t > 15000: self.done = True def draw(self, surface): self.image.draw(surface) def get_event(self, event): super(Gameplay3, self).get_event(event) if self.done and self.player is not None: self.player.quit() self.player = None
def play(self, movie, loop=None, vol=0): """Play the provided movie file, optionally looping it repeatedly.""" self.stop(3) # Up to 3 second delay to let the old player stop. # Assemble list of arguments. #args = ['omxplayer'] args = [] args.extend(['-o', self._sound]) # Add sound arguments. args.extend(self._extra_args) # Add extra arguments from config. if vol is not 0: args.extend(['--vol', str(vol)]) if loop is None: loop = movie.repeats if loop <= -1: args.append('--loop') # Add loop parameter if necessary. #if self._show_titles and movie.title: # srt_path = os.path.join(self._get_temp_directory(), 'video_looper.srt') # with open(srt_path, 'w') as f: # f.write(self._subtitle_header) # f.write(movie.title) # args.extend(['--subtitles', srt_path]) #args.append(movie.filename) # Add movie file path. # Run omxplayer process and direct standard output to /dev/null. #self._process = subprocess.Popen(args, # stdout=open(os.devnull, 'wb'), # close_fds=True) # OMXPlayer('path.mp4', args='--no-osd --no-keys -b') self._player = OMXPlayer(movie.filename, dbus_name='org.mpris.MediaPlayer2.omxplayer1', args=args) self._player.stopEvent = self.player_stop
def __play(self): logging.info("Starting OMXPlayer for {} at {}".format(self.vid_data.id, self.start_time)) args = ["-o", "local"] if self.start_time != 0: args += ["--pos", get_timestamp(self.start_time)] if Player.current_volume != 1 and Player.current_volume != 0: args += ["--vol", str(linear_to_mbels(Player.current_volume))] if Player.current_player is not None: Player.current_player.stop() Player.current_player = self Player.status = PlayerStatus.PLAYING self.omx = OMXPlayer(self.vid_data.url, args=args) self.omx.exitEvent += lambda p, code: self.stop() if self.done: self.omx.exitEvent += lambda p, code: self.done() self.start_timestamp = time.time() - self.start_time if Player.current_volume == 0: self.omx.mute() logging.info("OMXPlayer for {} has started".format(self.vid_data.id))
def loop(self): try: end_time = datetime.now() + timedelta(seconds=60) while (datetime.now() < end_time): self.data = self.audioinput() self.fft() if frequency_got == 1000 or frequency_got == -1000: #print("got it") player = OMXPlayer( path + "Hi, I have detected noise levels greater than the average value of 70 to 75 db. This is indicative of Cavitation, which could harm the equipment. I have raised an incident.mp3" ) player.set_volume(1) time.sleep(5) break #self.graphplot() #self.stream.stop_stream() #self.stream.close() except KeyboardInterrupt: self.pa.close() print("End...")
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
def mirror(self): self.player = OMXPlayer("udp://0.0.0.0:8090?listen", args=[ '-o', 'hdmi', '--lavfdopts', 'probesize:8000', '--timeout', '0', '--threshold', '0' ])
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")
def show_video(video, loop=True): global omx if os.path.exists(video): show_icon('') if platform.system() != 'Windows': if (omx != None): log.info('Starting video: ' + video) try: omx.load(video) except OMXPlayerDeadError: log.info('OMX was dead, creating new player for video: ' + video) omx = OMXPlayer(video, args=[ '--loop', '--no-osd', '--layer', '-1', '--no-keys', '-b' ]) else: log.info('Starting OMX with video: ' + video) omx = OMXPlayer( video, args=(['--loop'] if loop else []) + ['--no-osd', '--layer', '-1', '--no-keys', '-b']) else: stop_video() show_icon(MISSING_FILE_ICON) log.warning('Video not found: ' + video)
def sendSteps(songNum): # pulse reset signal before sending over steps resetLed.on() resetLed.off() # calculate sleep amount outside loop sleepAmount = 30 / OneThingBPM # asynchronously play audio if songNum == 0: player = OMXPlayer(Path(OneThingMP3Path)) else: player = OMXPlayer(Path(TheNightsMusic)) # send over steps if songNum == 0: chart = OneThingSteps else: chart = TheNightsSteps for step in chart: start = time() stepLeds.value = tuple(step) # pulse BPM clock bpmClockLed.on() end = time() # sleep appropriately sleep(sleepAmount - (end - start)) start = time() bpmClockLed.off() end = time() sleep(sleepAmount - (end - start)) # make sure steps don't persist on led matrix stepLeds.value = tuple([0] * 4)
def play(): global player if player: player.quit() filename = get_top() if mode == TOP20_MODE else get_random() episode = filename.replace('.mp4', '').replace('.mkv', '').split(' - ') color = TERM_COLORS.RANDOM isTop = '' # render top place if any if episode[0] in top_episode_list: isTop = 'Top# ' + str(20 - top_episode_list.index(episode[0])) + ' : ' color = TERM_COLORS.TOP20 print("\n\n\n Playing...") print(color + (Figlet(font=FONTS.SEASON, width=LINE_LENGTH) ).renderText(isTop + 's' + episode[0].replace('x', ' e')) + TERM_COLORS.ENDC + "\r") print(TERM_COLORS.TITLE + (Figlet(font=FONTS.TITLE, width=LINE_LENGTH) ).renderText(episode[1].replace('ü', 'u').replace('ú', 'u').replace( 'é', 'e').replace('á', 'a').replace('í', 'i').replace( 'ó', 'o').replace('ñ', 'n')) + TERM_COLORS.ENDC) player = OMXPlayer(Path(DIRECTORY + filename)) player.set_aspect_mode('fill')
class Radio: def __init__(self): self.stations = [('KPOA', 'https://16693.live.streamtheworld.com/KPOAFM.mp3 '), ('KAZU', 'https://icecastle.csumb.edu/live128'), ('KZSC', 'http://streaming.kzsc.org:8000/kzschigh')] self.station_index = 0 self.play = False self.player = False def __str__(self): state = "" if self.play: state = "on" else: state = "off" return "{} -- {}".format(self.stations[self.station_index][0], state) def get_stations(self): return self.stations def current(self): return self.stations[self.station_index] def next(self): if self.play: self.off() self.station_index = self.station_index + 1 if self.station_index > len(self.stations) - 1: self.station_index = 0 return self.stations[self.station_index] def previous(self): if self.play: self.off() self.station_index = self.station_index - 1 if self.station_index < 0: self.station_index = len(self.stations) - 1 return self.stations[self.station_index] def toggle(self): self.play = not self.play if not self.play: self.off() else: self.on() return self.play def on(self): self.play = True print("playing {}".format(self.stations[self.station_index][0])) self.player = OMXPlayer(self.stations[self.station_index][1]) return self.play def off(self): self.play = False if self.player: print("stopping {}".format(self.stations[self.station_index][0])) self.player.quit() return self.play
def play_vid(self): self.logging.debug("Play button func") self.logging.debug("Playing: {0} Paused: {1}".format( self.playing, self.paused)) self.logging.debug("Current subreddit index: %d" % self.subreddits[self.curr_subreddit][1]) self.logging.debug("Current video URL: %s" % self.subreddits[ self.curr_subreddit][2][self.subreddits[self.curr_subreddit][1]]) if not self.playing: if self.paused: self.player = OMXPlayer( self.subreddits[self.curr_subreddit][2][self.subreddits[ self.curr_subreddit][1]], args=[ '--aspect-mode', 'Letterbox', '--pos', self.position ]) self.paused = False else: self.player = OMXPlayer( self.subreddits[self.curr_subreddit][2][self.subreddits[ self.curr_subreddit][1]], args=['--aspect-mode', 'Letterbox']) self.alive = True self.player.exitEvent += lambda x, y: self.exit_event_func() self.root.update() self.playing = True else: self.paused = True self.playing = False self.position = self.player.position() self.player.stop()
def musicactions(): # if(request.method == 'GET'): s = request.query_string a = dict(item.split("=") for item in s.split("&")) action = a["action"] if (action == "stop"): global player global q if (q != True): print("QUIT") player.quit() q = True elif (action == "play"): global player q = False player = OMXPlayer("file.m4a") print(player) elif (action == "setvolume"): volume = float(a["volume"]) try: player.unmute() if (volume > 50): player.set_volume(450 * volume / 100) elif (volume < 50 and volume > 0): player.set_volume(-100 / (volume / 100)) elif (volume == 0): player.mute() except: #Exception as OMXPlayerDeadError: print("No Player") return "true"
class Gameplay3b(Result): animations = [] animation = None invert = 0 def __init__(self): super(Gameplay3b, self).__init__() self.images = [ Sprite(position=(0, 0), image=load_image("images/things/" + x + ".png")) for x in things ] self.next_state = "GAMEPLAY3a" #for i, thing in enumerate(things): # try: # anim = AnimatedSprite(position=pos[i], images=load_images("images/things/"+thing.lower()+"")) # self.animations.append(anim) # except Exception as e: # self.animations.append(None) # print(e) def startup(self, persistent): self.rt = config.load("positions", "center", [[0, 0], [0, 0], [0, 0]]) self.persist = persistent i = self.persist["choice"] if "choice" in self.persist else 0 self.image = self.images[i] # self.invert = things[i] in ["LUMI", "MURU"] video = "images/things/" + things[i].lower() + ".mp4" if OMXPlayer is not None and os.path.isfile(video): self.player = OMXPlayer(video, args=['--no-osd', '--loop']) else: self.player = None #try: # self.animation = None # gc.collect() # self.animation = AnimatedSprite(position=pos[i], images=load_images("images/things/" + things[i].lower() + "", False)) #except Exception as e: # self.animation = None # print(e) def get_event(self, event): super(Gameplay3b, self).get_event(event) if self.done and self.player is not None: self.player.quit() self.player = None def draw(self, surface): if self.invert: if self.animation is not None: self.animation.draw(surface) self.image.draw(surface) else: self.image.draw(surface) if self.animation is not None: self.animation.draw(surface) def update(self, dt): if self.animation is not None: self.animation.update(dt)
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 vid(self): print("video clicked, ID: " + self.ID) if os.path.isfile('/home/pi/proto/Twin/vid/' + self.ID + '.mp4'): player = OMXPlayer('/home/pi/proto/Twin/vid/' + self.ID + '.mp4') sleep(31) player.quit() else: print("동영상을 제공하지 않는 광고입니다.")
def vid(self): print("video clicked, ID: " + self.ID) if os.path.isfile('/home/pi/proto/Twin/vid/' + self.ID + '.mp4'): player = OMXPlayer('/home/pi/proto/Twin/vid/' + self.ID + '.mp4') sleep(31) player.quit() else: self.showMessageBox()
def play_pause(self): if self.omx: self.omx.play_pause() else: current_music_queue = list(self.current_music.queue) current_music = current_music_queue[0] if current_music_queue else None if current_music: self.omx = OMXPlayer(current_music['url'])
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 __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 threeD(self): print("3D clicked, ID: " + self.ID) if os.path.isfile('/home/pi/proto/Twin/3D/' + self.ID + '.mp4'): player = OMXPlayer('/home/pi/proto/Twin/3D/' + self.ID + '.mp4') sleep(31) player.quit() else: print("3D 모델을 제공하지 않는 광고입니다.")
def threeD(self): print("3D clicked, ID: " + self.currAD) if os.path.isfile('/home/pi/proto/Twin/3D/' + self.currAD + '.mp4'): player = OMXPlayer('/home/pi/proto/Twin/3D/' + self.currAD + '.mp4') sleep(31) player.quit() else: self.showMessageBox('3D모델')
def startup(self, persistent): self.rt = config.load("positions", "center", [[0, 0], [0, 0], [0, 0]]) self.persist = persistent video = "images/things/intro.mp4" if OMXPlayer is not None and os.path.isfile(video): self.player = OMXPlayer(video, args=['--no-osd', '--loop']) else: self.player = None self.t = 0
def play(self): self.player = OMXPlayer(self.path, args="-o local") self.player.exitEvent = self.exitEvent self.player.stopEvent = self.stopEvent while not self.finished: sleep(0.5) if self.syncCallback and not self.finished: self.syncCallback(self.player.position()) self.player.quit()
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 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 youtube(self): proc = subprocess.Popen(['youtube-dl', '-g', '-f', 'mp4', self.url], stdout=subprocess.PIPE) url = proc.stdout.read() if url.decode("utf-8") == '': return False self.player = OMXPlayer(url.decode("utf-8", "strict")[:-1], args=['-o', 'hdmi']) return True
def play(self): VIDEO_PATH = Path("videos/" + self.video_path) print(VIDEO_PATH) self.player = OMXPlayer(VIDEO_PATH, args=['-o', 'alsa', '--layer', '100000']) self.player.set_video_pos(0, 0, 800, 480) self.set_slider() self.change_size() Clock.schedule_interval(self.set_slider, 3) Clock.schedule_interval(self.set_play_pause_bttn, 1)
def init_player_obj(): # Initialize the OMXPlayer and sleep to load in video prod_args = ['--no-osd', '--vol', str(VIDEO_VOLUME), '-o', VIDEO_AUDIO_SOURCE] dev_args = ['--win', '0,40,600,400', '--no-osd', '--vol', str(VIDEO_VOLUME), '-o', VIDEO_AUDIO_SOURCE] player = OMXPlayer(VIDEO_PATH, dev_args, pause=True) player.pause() sleep(5) vid_tree_root = create_beyblade_vid_tree() player_obj = VidPlayer(player, vid_tree_root) print("Player ready") return player_obj
def playMedia(path="../tests/media/test_media_1.mp4", duration=0, position=0): player = OMXPlayer(path, args=["--no-osd"]) player.set_aspect_mode("fill") if position > 0: player.set_position(position) #player.duration() # this only works if this line is here if duration == 0: duration = player.duration() - position player.play() time.sleep(duration) player.quit()
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)
print('positioning to 2 %s (%s)' % (keyname, updown)) else: print('player cannot seek %s (%s)' % (keyname, updown)) elif keyname == b'KEY_4': if player.can_seek(): player.set_position(4) print('positioning to 4 %s (%s)' % (keyname, updown)) else: print('player cannot seek %s (%s)' % (keyname, updown)) elif keyname == b'KEY_9' and updown == b'00': print('calling aplay with audio path %s' % AUDIO_CHEER_PATH) subprocess.Popen(['aplay', AUDIO_CHEER_PATH]) print('goodbye') if __name__ == '__main__': init_irw() # Initialize the OMXPlayer and sleep to load in video player = OMXPlayer(VIDEO_PATH, args=['--no-osd', '--vol', str(VIDEO_VOLUME), '-o', VIDEO_AUDIO_SOURCE], pause=True) player.pause() sleep(3) try: run_player(player) except Exception as e: player.quit() raise e
#!/usr/bin/env python3 from omxplayer.player import OMXPlayer from pathlib import Path from time import sleep VIDEO_PATH_OPENING = Path("./assets/opening.mp4") VIDEO_PATH_BATTLE = Path("./assets/battle-test.mp4") player_opening = OMXPlayer(VIDEO_PATH_OPENING, args=['--no-osd'], pause=True) #player_battle = OMXPlayer(VIDEO_PATH_BATTLE) #player_battle.pause() sleep(5) player_opening.play() sleep(3) player_opening.stop() player_opening.quit() print("quit opening player") #sleep(3) #print("creating new player instance for the battle") #player_battle = OMXPlayer(VIDEO_PATH_BATTLE) #sleep(5)
def play_film(filename="demo.mp4", duration=0, position=0): debug("\nfilename:", filename) debug(" position:", position) debug(" duration:", duration) trim_from_end = 0.5 #trim_from_end = 0 player = OMXPlayer(filename) player.set_position(0.0) debug(" pre-play pos:", player.position()) player.play() # check and set position full_length = player.duration() # if the position is imposible, set it to 0 if position <= 0 or position > full_length: position = 0.0 player.set_position(position) # check and set duration length_to_end = player.duration() # if duration is imposible, set it to the length_to_end if duration == 0 or duration > length_to_end: wait = length_to_end - trim_from_end else: wait = duration if wait < 0: wait = 0 debug(" full length: ", full_length) debug(" length to end: ", length_to_end) debug(" wait: ", wait) sleep(wait) debug(" post sleep pos:", player.position()) player.pause() player.quit() debug(" post pause pos:", player.position()) return True
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)
#!/usr/bin/env python3 from omxplayer.player import OMXPlayer from pathlib import Path from time import sleep import logging logging.basicConfig(level=logging.INFO) VIDEO_1_PATH = "../tests/media/test_media_1.mp4" player_log = logging.getLogger("Player 1") player = OMXPlayer(VIDEO_1_PATH, dbus_name='org.mpris.MediaPlayer2.omxplayer1') player.playEvent += lambda _: player_log.info("Play") player.pauseEvent += lambda _: player_log.info("Pause") player.stopEvent += lambda _: player_log.info("Stop") # it takes about this long for omxplayer to warm up and start displaying a picture on a rpi3 sleep(2.5) player.set_position(5) player.pause() sleep(2) player.set_aspect_mode('stretch') player.set_video_pos(0, 0, 200, 200) player.play()
def __init__(self): #loading settings from setup.config settings = sl_settings.Settings() if not settings.load(): error(1) ip_setup = dynamic_ip() ip_setup.set(settings.get("ip_address")) plr = OMXPlayer(settings.get("file_name"),["--blank","--no-osd"]) if settings.get("ismaster") == "True": if ip_setup.waitForConnections(settings.get("num_clients")): ip_setup.sendStartSignal() else: ip_setup.connectToServer() ip_setup.waitForStartSignal() print "this function is not ready yet" ### TODO: error check #loop_time = plr.duration() - float(settings.get("load_time")) plr.play() while True: try: if settings.get("ismaster") == "False": ip_setup.waitForStartSignal() plr.set_position(0) elif settings.get("ismaster") == "True": sleep(plr.duration() - 1.0) #sleep(6) ip_setup.sendStartSignal() plr.set_position(0) except KeyboardInterrupt: print "interrupted!" ip_setup.closeConnection() ip_setup.setOldIp() plr.stop() plr.quit() break #plr.stop() ip_setup.setOldIp()
#!/usr/bin/env python3 from omxplayer.player import OMXPlayer from pathlib import Path from time import sleep VIDEO_PATH = Path("../tests/media/test_media_1.mp4") player = OMXPlayer(VIDEO_PATH) sleep(5) player.quit()