def playVideoGo(video_name, start=0, length=0): print "Incoming video request" videofile_path = "video/"+ video_name # TODO check is file en with mp4 or mov print "video to play: " + videofile_path video = OMXPlayer(videofile_path, pause=True) # set video clip duration if start > 0: video.set_position(start) # set video clip duration if length == 0: dur = video.duration() durint = int(dur) video.play() time.sleep(durint) else: video.play() print length time.sleep(length) print("Stop playing") video.quit() return "Video file played, lol"
def playVideoGo(video_name, start=0, length=0): print "Incoming video request" videofile_path = "video/" + video_name # TODO check is file en with mp4 or mov print "video to play: " + videofile_path video = OMXPlayer(videofile_path, pause=True) # set video clip duration if start > 0: video.set_position(start) # set video clip duration if length == 0: dur = video.duration() durint = int(dur) video.play() time.sleep(durint) else: video.play() print length time.sleep(length) print("Stop playing") video.quit() return "Video file played, lol"
class Controller(object): def __init__(self): pass def check_new_files(self): ''' check new files from _DIR ''' self._files = [] for files in os.listdir(_DIR): if files.endswith(('wmv', 'mp4', 'mov', 'avi')): self._files.append(os.path.join(_DIR, files)) else: pass def play_files(self): ''' Play all the files sequentially ''' self.idx = 0 while True: # Loop over list of files self.current_file = self._files[self.idx] self.idx = (self.idx + 1) % len(self._files) self.next_file = self._files[self.idx] # Play files one after the other self.player(self.current_file) def player(self, current_file): print(current_file,'\n','\tPlaying') # Set output window size self.omx = OMXPlayer(current_file, args=["--win", " 0,0,640,480"]) self.omx.play() try: self.omx.set_position(15.0) while True: try: if not(self.omx.playback_status()): # If file ended.. stop playback print('\n\tStopped\n') self.omx.stop() break else: # Print time elapsed print('\r\t','{0:.2f}'.format(self.omx.position()), '/', '{0:.2f}'.format(self.omx.duration())+ ' seconds', end = ''), sys.stdout.flush() except Exception, e: # dBUS exception for file that # finished playing. Ignore! pass except KeyboardInterrupt, e: # Catch Ctrl+C and stop playing # current file print('Stopping Playback..', e) self.omx.stop()
def omxplayer_process(queue): try: player_num = 0 last_video = None video = True while video: #log.debug("Warte auf Befehle") video = queue.get() try: # block queue queue.put_nowait(True) except: ... log.debug('Play {}'.format(video)) if not last_video == video: try: player.quit() except: killall_omxplayer() log.debug('Load new Video: {}'.format(video)) dbus_name = 'org.mpris.MediaPlayer2.omxplayer{}'.format( player_num) player = OMXPlayer(video, args=omxplayer_args, dbus_name=dbus_name, pause=True) player_num += 1 #log.debug(player.volume()) player.set_volume(1.0) time.sleep(1) # das erste Video soll nicht abgespielt werden, sondern nur einen Kaltstart vermeiden if not last_video == None: player.set_alpha(255) player.play_sync() player.pause() player.set_alpha(0) player.set_position(0) log.debug('Video fertig: {}'.format(video)) last_video = video try: # clean queue queue.get_nowait() except: ... except KeyboardInterrupt: ... finally: killall_omxplayer()
def testVideo(video_id=None): print "Incoming video request" vid1 = OMXPlayer(TEST_MEDIA_FILE_1, pause=True) print("Start playing") vid1.set_position(70) dur = vid1.duration() print dur vid1.play() sleep(2) print("Stop playing") vid1.pause() time.sleep(2) vid1.load(TEST_MEDIA_FILE_2) vid1.play() sleep(2) print("Exit") vid1.quit()
class PlayVoidAudio(Thread): def __init__(self): Thread.__init__(self) def terminate(self): # activated by Stop button self.player.stop() print('Terminating thread...') def run(self): self.player = OMXPlayer( '/home/pi/donics/MoS_TimingRemix_3Void_CleanStartEnd.mp3') self.player.pause() self.player.pause() self.player.set_position(0.0) #time.sleep(.1) print "play" self.player.play()
class TV(threading.Thread): def __init__(self): super(TV, self).__init__() print("Initializing TV") self.red_alert = False self.player = None self.reset() #Register Events signal('SYSTEM_stopping').connect(self.clean_up) signal('tv.redalert').connect(self.alert) signal('alert.red.toggle').connect(self.alert) signal('code_47').connect(self.reset) def reset(self, sender='anonymous'): os.system('pkill omxplayer') self.player = OMXPlayer("http://repo.posttwo.pt/redalert.mp4", args=['--no-osd', '--no-keys', '-b', '--loop']) self.player.pause() def tv_set_pi(self): subprocess.call("echo 'as' | cec-client -s &", shell=True) #os.system('echo "as" | cec-client -s') def tv_set_chrome(self): subprocess.call("echo 'txn 4f:82:20:00' | cec-client -s &", shell=True) #os.system('echo "txn 4f:82:20:00" | cec-client -s') def alert(self, sender='anonymous'): if not self.red_alert: self.red_alert = True self.tv_set_pi() print("RED ALERT ON") self.player.set_position(0) self.player.play() else: self.red_alert = False self.tv_set_chrome() self.player.pause() def clean_up(self, sender='anonymous'): print("TV Cleaning Up") self.player.quit()
class Player: def __init__(self, path): self.path = path self.player = OMXPlayer( self.path, args=["--loop", "-o", "local", "--win", "0,0,640,480"]) # self.player.play() # self.player.set_position(10.0) # self.player.pause() def play(self): self.player.play() def pause(self): self.player.pause() def toggle(self): self.player.play_pause() def reset(self): self.player.pause() self.player.set_position(0.0)
subprocess.call('sudo pkill omxplayer', shell=True) GPIO.add_event_detect(force_stop_gpio_i, GPIO.FALLING, callback=quit_program, bouncetime=100) logger = logging.getLogger('male_zuccini') logger.info('creating omxplayer objects') idle_movie_controller = OMXPlayer(filename=idle_video_file, args=['--loop', '--no-osd']) after_movie_controller = OMXPlayer(filename=after_video_file, args=['--no-osd']) after_movie_controller.pause() after_movie_controller.set_position(0) blink_movie_controller = OMXPlayer(filename=blink_video_file, args=['--loop', '--no-osd']) logger.info('finished creating omxplayer objects') def state_idle(): logger.info('starting state_idle') start_time = time.time() idle_movie_controller.play() while running: if not GPIO.input(male_to_female_i): start_time = time.time() time.sleep(0.05) if (time.time() - start_time) >= DEBOUNCE_TIME_TH:
class Video(object): currentTime = 0; startTime = 0; player = OMXPlayer(dir_path + "/a.mp3", pause=True); id = ""; listId = ""; state = ""; info = {}; def dispstart(self): return self.startTime; def dispcur(self): return self.currentTime; def setStartTime(self, time): self.startTime = time; def setCurrentTime(self, time): self.currentTime = time; def getCurrentTime(self): now = int(time.time()); self.currentTime = now - self.startTime; return self.currentTime; def create(self): videoToPlay = pafy.new("https://www.youtube.com/watch?v=" + self.info["encrypted_id"]); bestaudio = videoToPlay.getbestaudio(preftype="m4a", ftypestrict=True); file_name = dir_path + "/music/" + self.id + ".m4a"; try : bestaudio.download(file_name); except: pass self.player.quit() self.player = OMXPlayer(file_name, pause=True); AudioSegment.from_file(file_name).export(dir_path + "/music/" + self.id + ".mp3", format="mp3"); r = requests.post(addr_serv + "/serv", data=str(self.id)); if r.status_code != 200: print(r); print("error post to 2nd server"); else: print("postb 2nd ok"); def seek(self, timeValue): self.player.set_position(timeValue); def play(self): now = int(time.time()); self.startTime = now - self.currentTime; # calculate the starting point self.state = "1"; self.player.play(); r = requests.post(addr_serv + "/serv", data=self.state); if r.status_code != 200: print(r); print("error post to 2nd server"); else: print("postb 2nd ok"); def pause(self): self.getCurrentTime(); self.state = "2"; self.player.pause(); r = requests.post(addr_serv + "/serv", data=self.state); if r.status_code != 200: print(r); print("error post to 2nd server"); else: print("postb 2nd ok"); def stop(self): # useless for the moment but mayby later... self.state = "0"; def volume(self, volume): self.player.set_volume(-6000 + volume * 60); #-6000/100 car omx va de -6000 a 0 et volume de 0 a 100
class tree_player(object): """ control one screen on the "Big Tree display" toggle between two different movies according to GPIO input signal """ def __init__(self, gpio_number, movie_1, movie_2): self.logger = logging.getLogger('tree_player') self.logger.info('starting player') self.logger.info('movie 1: {}'.format(movie_1)) self.logger.info('movie 2: {}'.format(movie_2)) self.logger.info('GPIO: {} (BCM)'.format(gpio_number)) self.stop_gpio = 21 self.logger.info('stop GPIO: {} (BCM)'.format(self.stop_gpio)) self.control_gpio = gpio_number self.movie_1 = movie_1 self.movie_2 = movie_2 self.current_state = None self.polling_tries = 0 self.stop_state = 0 self.stop_tries = 0 GPIO.setmode(GPIO.BCM) GPIO.setup(self.control_gpio, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) GPIO.setup(self.stop_gpio, GPIO.IN, pull_up_down=GPIO.PUD_UP) #GPIO.add_event_detect(self.control_gpio, GPIO.BOTH, callback=self.event, bouncetime=300) #GPIO.add_event_detect(self.stop_gpio, GPIO.FALLING, callback=self.quit, bouncetime=200) #self.movie_1_controller = omxplayer.OMXPlayer(mediafile=self.movie_1, args=r'--loop -b --no-osd', start_playback=False) #self.movie_2_controller = omxplayer.OMXPlayer(mediafile=self.movie_2, args=r'--loop -b --no-osd', start_playback=False) self.movie_1_controller = OMXPlayer(filename=self.movie_1, args=['--loop', '-b', '--no-osd']) self.movie_2_controller = OMXPlayer(filename=self.movie_2, args=['--loop', '-b', '--no-osd']) sleep(1) self.running = True self.button_reader_thread = threading.Thread(target=self.button_reader) self.button_reader_thread.start() def button_reader(self): self.logger.info('button_reader started') while self.running: current_state = self.read_current_buttons_state() if current_state != self.current_state and self.polling_tries == 20: self.current_state = current_state self.main_loop() elif current_state != self.current_state and self.polling_tries < 20: self.polling_tries += 1 else: self.polling_tries = 1 stop_state = not GPIO.input(self.stop_gpio) if stop_state and self.stop_tries == 50: self.quit() elif stop_state and self.stop_tries < 50: self.stop_tries += 1 else: self.stop_tries = 1 sleep(0.005) self.logger.info('button_reader ended') def read_current_buttons_state(self): """ read control_gpio state """ return GPIO.input(self.control_gpio) def main_loop(self): """ one iteration of main loop, called when input is changed, stop one movie, seek to 0 (so next time we start from beginning) and play other movie :return: """ current_state = self.current_state if current_state: self.logger.info('state changed to HIGH, show BAD fruit movie') self.movie_2_controller.pause() sleep(0.1) self.movie_2_controller.set_position(0) sleep(0.1) self.movie_1_controller.play() else: self.logger.info('state changed to LOW, show GOOD fruit movie') self.movie_1_controller.pause() sleep(0.1) self.movie_1_controller.set_position(0) sleep(0.1) self.movie_2_controller.play() sleep(0.3) def quit(self): self.logger.info('in quit()') self.running = False sleep(0.1) GPIO.cleanup() self.logger.info('stopping both movies') self.movie_1_controller.stop() self.movie_2_controller.stop() sleep(0.5) self.logger.info('closing both players') try: self.movie_1_controller.quit() except Exception as ex: self.logger.error('while closing player 1, got ex: {}'.format(ex)) try: self.movie_2_controller.quit() except Exception as ex: self.logger.error('while closing player 2, got ex: {}'.format(ex)) sleep(0.5) self.logger.info('quit function ended')
class Player: def __init__(self, init_layer=1, init_idleClip=None, init_autoIdle=False, init_volume=0.5): self.omx = None self.clip = None self.isStopping = False self.layer = init_layer self.setIdleClip(init_idleClip) self.autoIdle = init_autoIdle self.volumeSetting='--vol -6000' if init_volume == 0: self.volumeSetting=('--vol ' + str(ceil(2000 * (log10(init_volume))))) print(self.volumeSetting) # pre: # post: returns true if omx is not None def isPlaying(self): return self.omx is not None # pre: expects desired is of type Clip # post: sets the idle clip to be a looping version of the desired clip def setIdleClip(self, desired): if desired is not None: self.idleClip = Clip(desired.location, True) # TODO: ensure this doesnt pile up clips over time else: self.idleClip = None return self.idleClip # pre: expects desired to be of type boolean # post: sets the auto idle option to the desired value def setAutoIdle(self, desired): self.autoIdle = desired return self.autoIdle def isIdle(self): return (self.clip == self.idleClip) def playIdle(self): self.play(self.idleClip) # pre: # post: stops the current clip and plays the desired clip def play(self, desiredClip): if (desiredClip is not None): if self.isPlaying(): self.stop() self.clip = desiredClip if (self.clip.isLooping == False): self.omx = OMXPlayer(self.clip.location, args=['--layer', str(self.layer), '--no-osd', '--no-keys']) else: self.omx = OMXPlayer(self.clip.location, args=['--layer', str(self.layer), '--no-osd', '--no-keys', '--loop']) if (self.idleClip is not desiredClip): self.omx.exitEvent += lambda a, b: self.clipEndEvent() # will this assign multiple times? # pre: # post: starts idling on the idleClip if autoIdle is true, otherwise stops playing the current clip def endClip(self): self.stop() if (self.autoIdle and self.idleClip is not None): self.play(self.idleClip) # pre: # post: stops playing the current clip def stop(self): self.isStopping = True if self.isPlaying(): self.omx.quit() self.clip = None self.omx = None self.isStopping = False # pre: # post: resets the current position of the clip to its start def reset(self): self.omx.set_position(0) def clipEndEvent(self): print("clip end") self.omx = None if (self.isStopping is False): self.play(self.idleClip)
mt_dev = mtc_pos - lastm print "(%.2f) %.2f %.2f" % (difference, mtc_pos, player_pos) # av.append(player_pos) # if len(av) > 10: # av.pop(0) # pl_av = sum(av)/len(av) # # print "Video: %.2f / %.2f (%.2f) MTC: %.2f" % (player_pos, pl_av, pl_dev, mtc_pos) # # # print "%3f %6f" % (pl_dev, mt_dev) # # print sum(av)/len(av) # if difference > 5 or difference < -1: pause_pos = mtc.getS()+5 player.set_position(pause_pos) print "seeking to %f" % (pause_pos / 60) player.pause() player_pos = player.position() while mtc.getS() < player_pos: pass player.play() # if difference > 0.2: # player.pause() # player.play() if difference > tol and speed == 0: player.action(1) speed = -1 elif difference < -tol and speed == 0: player.action(2)
class Player: def __init__(self, appli): self.currVideo = None self.formatId = 0 self.subtitleId = -1 self.audioStreamId = 0 self.omxProcess = None self.currTotViewed = 0 self.lastPos = 0 self.appli = appli self.wasPlaying = False def LoadVideo(self, video): if self.isStarted(): self.stop() self.wasPlaying = False self.currVideo = video self.formatId = 0 self.subtitleId = -1 self.audioStreamId = 0 self.currTotViewed = 0 self.lastPos = 0 # Set the format of the video def setVideoFormat(self, formatId): if self.currVideo and formatId != self.formatId: # If the video has this format if self.currVideo.getFormat(formatId): oldFormat = self.formatId self.formatId = formatId if self.isStarted(): self.wasPlaying = False oldPos = self.getPosition() wasPlaying = self.isPlaying() # Try to play the new format but fallback on the previous one if it fails if self.tryPlayingFormat( formatId) or self.tryPlayingFormat(oldFormat): self.setPosition(oldPos) if not wasPlaying: self.playPause() else: return False return True return False # Set a different audio stream def setAudioFormat(self, formatId): try: if self.isStarted(): if self.omxProcess.select_audio(formatId): self.audioStreamId = formatId return True else: return False else: return False except: self.clearPlayer() return False # Set a subtitle track def setSubtitlesFormat(self, formatId): try: if self.isStarted(): if formatId > -1: self.omxProcess.show_subtitles() if self.omxProcess.select_subtitle(formatId): self.subtitleId = formatId return True else: return False else: self.subtitleId = -1 return self.omxProcess.hide_subtitles() else: return False except: self.clearPlayer() return False # Tries to play or pause the current video def playPause(self): if self.currVideo: if self.isStarted(): try: if self.isPlaying(): self.omxProcess.pause() else: self.omxProcess.play() return True except: self.clearPlayer() return False else: ok = False if self.formatId != 0: ok = self.tryPlayingFormat(self.formatId) if not ok: # Try to play formats starting from the highest resolution one for fid in range(1, len(self.currVideo.getFormatList())): if self.tryPlayingFormat(fid): ok = True break return ok return False def stop(self): self.wasPlaying = False try: if self.omxProcess: self.omxProcess.quit() self.omxProcess = None return True return False except: self.clearPlayer() return False # Tries to play a given format of the video def tryPlayingFormat(self, formatId): if self.isStarted(): self.stop() try: self.formatId = formatId print('Trying to play ', formatId, 'path:', self.currVideo.getRessourcePath(formatId)) self.omxProcess = OMXPlayer( self.currVideo.getRessourcePath(formatId), args=['-b']) # Wait a bit for loading before disqualifying the format while self.omxProcess.playback_status() == 'Paused': sleep(0.01) if self.isPlaying(): print('isplaying:True') return True except Exception as e: self.clearPlayer() print(str(e), str(self.currVideo.getFormatList())) # Handle the case in which the format couldn't be played self.stop() self.formatId = 0 return False def isPlaying(self): try: return self.omxProcess and self.omxProcess.is_playing() except: self.clearPlayer() return False def isStarted(self): try: return self.omxProcess and self.omxProcess.can_play() except: self.clearPlayer() return False def isPaused(self): return self.isStarted() and not self.isPlaying() def getPosition(self): try: if self.isStarted(): return self.omxProcess.position() else: return 0 except: self.clearPlayer() return 0 def getDuration(self): try: if self.isStarted(): return int(self.omxProcess.duration()) elif self.currVideo: return self.currVideo.duration else: return 1 except: self.clearPlayer() return 1 def getSubtitles(self): subs = {-1: 'None'} try: if self.isStarted(): for substr in self.omxProcess.list_subtitles(): idx, lng, name, cdc, actv = substr.split(':') subs[idx] = lng + (('-' + name) if len(name) > 0 else '') if actv: self.subtitleId = idx return subs except: self.clearPlayer() return subs def hasSubtitles(self): try: return self.isStarted() and len( self.omxProcess.list_subtitles()) > 0 except: self.clearPlayer() return False def getAudioStreams(self): auds = {} try: if self.isStarted(): for audstr in self.omxProcess.list_audio(): idx, lng, name, cdc, actv = audstr.split(':') auds[idx] = lng + (('-' + name) if len(name) > 0 else '') if actv: self.audioStreamId = idx return auds except: self.clearPlayer() return auds def hasAudioStreams(self): try: return self.isStarted() and len(self.omxProcess.list_audio()) > 1 except: self.clearPlayer() return False def hasVideoStreams(self): if self.currVideo: okFormatList = json.loads(self.currVideo.okFormatsList) return len(okFormatList) > 2 else: return False def getStatus(self): isPlaying = self.isPlaying() isPaused = self.isPaused() currPos = self.getPosition() dur = self.getDuration() if isPlaying or isPaused: self.wasPlaying = True self.currTotViewed += currPos - self.lastPos self.lastPos = currPos with self.appli.threadLock: if self.currTotViewed / dur > Parameters.get().viewedThreshold: self.currVideo.viewed = True self.currVideo.save() self.appli.updatePart('playlist') else: with self.appli.threadLock: pt = Parameters.get().autoRestartPosThresh if self.wasPlaying and pt < self.lastPos < self.getDuration() - pt: self.tryPlayingFormat(self.formatId) self.setPosition(self.lastPos) return { 'position': currPos, 'duration': dur, 'isPlaying': isPlaying, 'isPaused': isPaused } def setPosition(self, newPos): try: # If the video is not started, start it and jump to the position if self.isStarted() or self.playPause(): self.omxProcess.set_position(newPos) return True else: return False except: self.clearPlayer() return False def getFormatList(self): return self.currVideo.getFormatList() if self.currVideo else [] def getFormatListItems(self): return [(fid, f['name']) for fid, f in enumerate(self.getFormatList())] def clearPlayer(self): if self.omxProcess: try: self.omxProcess.quit() except: pass self.omxProcess = None
class MediaOmxplayerPlugin(MediaPlugin): """ Plugin to control video and media playback using OMXPlayer. Requires: * **omxplayer** installed on your system (see your distro instructions) * **omxplayer-wrapper** (``pip install omxplayer-wrapper``) """ def __init__(self, args=None, *argv, timeout: float = 20., **kwargs): """ :param args: Arguments that will be passed to the OMXPlayer constructor (e.g. subtitles, volume, start position, window size etc.) see https://github.com/popcornmix/omxplayer#synopsis and https://python-omxplayer-wrapper.readthedocs.io/en/latest/omxplayer/#omxplayer.player.OMXPlayer :type args: list :param timeout: How long the plugin should wait for a video to start upon play request (default: 20 seconds). """ super().__init__(*argv, **kwargs) if args is None: args = [] self.args = args self.timeout = timeout self._player = None self._handlers = {e.value: [] for e in PlayerEvent} self._play_started = threading.Event() @action def play(self, resource=None, subtitles=None, *args, **kwargs): """ Play or resume playing a resource. :param resource: Resource to play. Supported types: * Local files (format: ``file://<path>/<file>``) * Remote videos (format: ``https://<url>/<resource>``) * YouTube videos (format: ``https://www.youtube.com/watch?v=<id>``) * Torrents (format: Magnet links, Torrent URLs or local Torrent files) :param subtitles: Subtitles file """ if not resource: if not self._player: self.logger.warning('No OMXPlayer instances running') else: self._player.play() return self.status() else: self._play_started.clear() self._post_event(MediaPlayRequestEvent, resource=resource) if subtitles: args += ('--subtitles', subtitles) resource = self._get_resource(resource) if self._player: try: self._player.stop() self._player = None except Exception as e: self.logger.exception(e) self.logger.warning( 'Unable to stop a previously running instance ' + 'of OMXPlayer, trying to play anyway') from dbus import DBusException try: from omxplayer import OMXPlayer self._player = OMXPlayer(resource, args=self.args) except DBusException as e: self.logger.warning( 'DBus connection failed: you will probably not ' + 'be able to control the media') self.logger.exception(e) self._post_event(MediaPlayEvent, resource=resource) self._init_player_handlers() if not self._play_started.wait(timeout=self.timeout): self.logger.warning( f'The player has not sent a play started event within {self.timeout}' ) return self.status() @action def pause(self): """ Pause the playback """ if self._player: self._player.play_pause() return self.status() @action def stop(self): """ Stop the playback (same as quit) """ return self.quit() @action def quit(self): """ Quit the player """ from omxplayer.player import OMXPlayerDeadError if self._player: try: try: self._player.stop() except Exception as e: self.logger.warning(f'Could not stop player: {str(e)}') self._player.quit() except OMXPlayerDeadError: pass finally: self._player = None return {'status': 'stop'} def get_volume(self) -> float: """ :return: The player volume in percentage [0, 100]. """ if self._player: return self._player.volume() * 100 @action def voldown(self, step=10.0): """ Decrease the volume. :param step: Volume decrease step between 0 and 100 (default: 10%). :type step: float """ if self._player: self.set_volume(max(0, self.get_volume() - step)) return self.status() @action def volup(self, step=10.0): """ Increase the volume. :param step: Volume increase step between 0 and 100 (default: 10%). :type step: float """ if self._player: self.set_volume(min(100, self.get_volume() + step)) return self.status() @action def back(self, offset=30): """ Back by (default: 30) seconds """ if self._player: self._player.seek(-offset) return self.status() @action def forward(self, offset=30): """ Forward by (default: 30) seconds """ if self._player: self._player.seek(offset) return self.status() @action def next(self): """ Play the next track/video """ if self._player: self._player.stop() if self._videos_queue: video = self._videos_queue.pop(0) self.play(video) return self.status() @action def hide_subtitles(self): """ Hide the subtitles """ if self._player: self._player.hide_subtitles() return self.status() @action def hide_video(self): """ Hide the video """ if self._player: self._player.hide_video() return self.status() @action def is_playing(self): """ :returns: True if it's playing, False otherwise """ return self._player.is_playing() @action def load(self, resource, pause=False, **kwargs): """ Load a resource/video in the player. :param resource: URL or filename to load :type resource: str :param pause: If set, load the video in paused mode (default: False) :type pause: bool """ if self._player: self._player.load(resource, pause=pause) return self.status() @action def metadata(self): """ Get the metadata of the current video """ if self._player: return self._player.metadata() return self.status() @action def mute(self): """ Mute the player """ if self._player: self._player.mute() return self.status() @action def unmute(self): """ Unmute the player """ if self._player: self._player.unmute() return self.status() @action def seek(self, position): """ Seek to the specified number of seconds from the start. :param position: Number of seconds from the start :type position: float """ if self._player: self._player.set_position(position) return self.status() @action def set_position(self, position): """ Seek to the specified number of seconds from the start (same as :meth:`.seek`). :param position: Number of seconds from the start :type position: float """ return self.seek(position) @action def set_volume(self, volume): """ Set the volume :param volume: Volume value between 0 and 100 :type volume: float """ if self._player: self._player.set_volume(volume / 100) return self.status() @action def status(self): """ Get the current player state. :returns: A dictionary containing the current state. Format:: output = { "duration": Duration in seconds, "filename": Media filename, "fullscreen": true or false, "mute": true or false, "path": Media path "pause": true or false, "position": Position in seconds "seekable": true or false "state": play, pause or stop "title": Media title "url": Media url "volume": Volume between 0 and 100 "volume_max": 100, } """ from omxplayer.player import OMXPlayerDeadError from dbus import DBusException if not self._player: return {'state': PlayerState.STOP.value} try: state = self._player.playback_status().lower() except (OMXPlayerDeadError, DBusException) as e: self.logger.warning(f'Could not retrieve player status: {e}') if isinstance(e, OMXPlayerDeadError): self._player = None return {'state': PlayerState.STOP.value} if state == 'playing': state = PlayerState.PLAY.value elif state == 'stopped': state = PlayerState.STOP.value elif state == 'paused': state = PlayerState.PAUSE.value return { 'duration': self._player.duration(), 'filename': urllib.parse.unquote(self._player.get_source()).split('/')[-1] if self._player.get_source().startswith('file://') else None, 'fullscreen': self._player.fullscreen(), 'mute': self._player._is_muted, 'path': self._player.get_source(), 'pause': state == PlayerState.PAUSE.value, 'position': max(0, self._player.position()), 'seekable': self._player.can_seek(), 'state': state, 'title': urllib.parse.unquote(self._player.get_source()).split('/')[-1] if self._player.get_source().startswith('file://') else None, 'url': self._player.get_source(), 'volume': self.get_volume(), 'volume_max': 100, } def add_handler(self, event_type, callback): if event_type not in self._handlers.keys(): raise AttributeError( '{} is not a valid PlayerEvent type'.format(event_type)) self._handlers[event_type].append(callback) @staticmethod def _post_event(evt_type, **evt): bus = get_bus() bus.post(evt_type(player='local', plugin='media.omxplayer', **evt)) def on_play(self): def _f(player): if self.volume and not self._play_started.is_set(): self.set_volume(self.volume) self._play_started.set() resource = player.get_source() self._post_event(MediaPlayEvent, resource=resource) for callback in self._handlers[PlayerEvent.PLAY.value]: callback(resource) return _f def on_pause(self): def _f(player): resource = player.get_source() self._post_event(MediaPauseEvent, resource=resource) for callback in self._handlers[PlayerEvent.PAUSE.value]: callback(resource) return _f def on_stop(self): def _f(*_, **__): self._post_event(MediaStopEvent) for callback in self._handlers[PlayerEvent.STOP.value]: callback() return _f def on_seek(self): def _f(player, *_, **__): self._post_event(MediaSeekEvent, position=player.position()) return _f def _init_player_handlers(self): if not self._player: return self._player.playEvent += self.on_play() self._player.pauseEvent += self.on_pause() self._player.stopEvent += self.on_stop() self._player.exitEvent += self.on_stop() self._player.positionEvent += self.on_seek() self._player.seekEvent += self.on_seek() def toggle_subtitles(self, *args, **kwargs): raise NotImplementedError def set_subtitles(self, filename, *args, **kwargs): raise NotImplementedError def remove_subtitles(self, *args, **kwargs): raise NotImplementedError
#This code is for debugging purposes, incase system freezes it forces close after 30 seconds timeout = time.time() + 30 while True: button_quit = GPIO.input(5) button_lose = GPIO.input(6) button_win = GPIO.input(13) button_start = GPIO.input(19) button_loop = GPIO.input(26) print('Error Code #002') player.play() if (button_loop == False): print('Loop Trigger by GameMaster') # cuFunctions.loopvideo(player()) player.set_position(0) print('Error Code #A01') while(True): button_start = GPIO.input(19)#WHY DOES THIS HAVE TO BE HERE? HOLY CRAP button_quit = GPIO.input(5) print('Error Code #A02') if (player.position() > 10):#Seconds until the system loops back to 0 print('Loop Triggered by System') player.set_position(0) print('Error Code #A03') if (button_start == False):#When start pressed, game starts, then break out of loopvideo function print('Game Start Triggered by GameMaster') print('Error Code #A04') player.set_position(600) time.sleep(1) break#Break Wroks, use return for function Def
pwm_smoke1.stop() pwm_smoke2.stop() pwm_smoke3.stop() pwm_heat.stop() action_on = False #----------------------------- #Main code try: # player-Objekt erzeugen,parametrieren und das Video und Aktoren auf 0 setzen player = OMXPlayer('/home/pi/Desktop/R_A_vid_v2.mp4', args=['--win', '0 0 1920 1080', '--no-osd']) player.set_position(0) player.play() action(0, 0, 0, 0, 0) # stetige Abfrage welche Aktoren angesteuert werden wollen. wenn nichts geschieht, GPIO_Reset wird ausgefuert # in den jeweiligen Zeitintervallen werden die Aktoren angesteuert while 1: while 3 < player.position() < 5 and player.is_playing(): action(25, 100, 0, 0, 0) print(player.position()) GPIO_reset() while 21 - 15 < player.position() < 21 and player.is_playing(): action(0, 0, 0, 0, 100) print(player.position()) GPIO_reset()
#!/usr/bin/env python2 from omxplayer import OMXPlayer from time import sleep from smoke_tests import TEST_MEDIA_FILE_1 print(TEST_MEDIA_FILE_1) vid1 = OMXPlayer(TEST_MEDIA_FILE_1) print("Start playing") vid1.set_position(5) vid1.play() sleep(2) print("Stop playing") vid1.pause() sleep(2) print("Exit") vid1.quit()