def play_video(): global player if switch_SD_HD.is_pressed: # Switch is in the 'SD' position led.color = Color('gold') if player is not None: player.stop() sleep(0.5) command = ['/usr/bin/tvservice -c "PAL 4:3"'] subprocess.call(command, shell=True) sleep(0.5) VIDEO_PATH = Path("/video/SD_DemoVideo.mp4") player = OMXPlayer(VIDEO_PATH, args=['--no-osd', '--no-keys', '--blank', '--loop']) else: led.color = Color('green') if player is not None: # i.e. first run player.stop() sleep(0.5) command = [ '/usr/bin/tvservice -p' ] # not needed on first run as output defaults to HDMI as HDMI connector is always present in demo box subprocess.call(command, shell=True) sleep(0.5) VIDEO_PATH = Path("/video/HD_DemoVideo.mp4") player = OMXPlayer(VIDEO_PATH, args=['--no-osd', '--no-keys', '--blank', '--loop'])
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 playVideos(vN): global playing global player global player1 global first print("Dentro funcion video >> " + str(vN)) vid = "/home/pi/Desktop/videocoto/videos/" + str(vN) + ".mp4" print("Toca reproducir ahora: " + vid) if playing == 0: print("Not Playing: " + str(playing)) VIDEO_PATH = Path(vid) if slave == False: player = OMXPlayer(VIDEO_PATH, args=omx_arg, dbus_name=bus[0]) if slave == True: player = OMXPlayer(VIDEO_PATH, args=omx_arg_pasive, dbus_name=bus[0]) player.seek(0) player.play() if first == 1: player1.stop() first = 1 playing = 1 elif playing == 1: print("Is Playing: " + str(playing)) VIDEO_PATH = Path(vid) if slave == False: player1 = OMXPlayer(VIDEO_PATH, args=omx_arg, dbus_name=bus[1]) if slave == True: player1 = OMXPlayer(VIDEO_PATH, args=omx_arg_pasive, dbus_name=bus[1]) player1.seek(0) player1.play() player.stop() playing = 0
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()
class Player: def __init__(self, url): self.url = url self.player = None self.state = True self.playlist = False self._play = True def start(self): if isinstance(self.url, string_types): cmd = 'youtube-dl -g -f best {0}'.format(self.url) yt_dl = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE) (url, err) = yt_dl.communicate() if yt_dl.returncode != 0: sys.stderr.write(err) print('error') yurl = url.decode('UTF-8').strip() self.player = OMXPlayer(yurl, args=['-o', 'hdmi']) return self.player.duration() def stop(self): self.player.stop() self._play = False self.player = None return False def skip(self): if self.playlist == True: self.player.stop() return True else: self.player.stop() return False def toggle(self): #false = not playing // true = playing if self.state == True: self.state = False self.player.pause() elif self.state == False: self.state = True self.player.play() else: return False def is_play(self): return self.player.can_control()
class PlayerControl: def __init__(self, logger, master, data, subreddit_dic, subreddit_list): self.data = data self.logging = logger self.subreddits = OrderedDict(subreddit_dic) self.subreddits_list = subreddit_list self.curr_subreddit = self.subreddits_list[0] self.playing = False self.paused = False self.spawn_new = False self.alive = False self.last_click = time() - 1 self.delay = 2 self.position = 0 self.root = master self.init_root() self.make_overlay() self.reddit = Reddit(self.data) self.toggle_loading_text() self.subreddits[self.curr_subreddit][2] = self.reddit.get_video_link( self.subreddits[self.curr_subreddit][0], 100) self.toggle_loading_text() self.logging.debug(self.subreddits[self.curr_subreddit][2]) self.play_vid() def init_root(self): self.root.bind("<Escape>", exit) self.root.overrideredirect(True) self.root.wait_visibility(self.root) self.root.wm_attributes("-alpha", 0.0) self.root.geometry("%dx%d+%d+%d" % (800, 480, 0, 0)) def make_overlay(self): self.create_bg() self.create_playback_buttons() self.create_subreddit_buttons() self.create_center_icon() self.create_loading_text() def create_bg(self): img = Image.open('images/background.jpg').resize((800, 480)) self.image = ImageTk.PhotoImage(img) self.panel = tk.Canvas(master=self.root) self.panel.create_image(0, 0, anchor=tk.NW, image=self.image) def create_center_icon(self): button_img = Image.open("images/subreddits/%s.png" % self.curr_subreddit).resize((200, 200)) self.center_icon = ImageTk.PhotoImage(button_img) self.panel.create_image(400, 170, image=self.center_icon) self.root.update() def create_loading_text(self): self.loading_hidden = True self.loading_text = self.panel.create_text( (400, 363), anchor=tk.S, font=('DinosaursAreAlive', 65, 'bold'), text="LOADING..", fill='RoyalBlue1', state=tk.HIDDEN) def toggle_loading_text(self): if self.loading_hidden: self.panel.itemconfig(self.loading_text, state=tk.NORMAL) self.loading_hidden = False else: self.panel.itemconfig(self.loading_text, state=tk.HIDDEN) self.loading_hidden = True self.root.update() def create_playback_buttons(self): self.playback_buttons = {} self.playback_button_photos = {} playback_types = ['next', 'play', 'prev', 'shutdown'] btn_positions = { "next": (800, 240), "play": (400, 480), "prev": (0, 240), "shutdown": (0, 480) } btn_anchors = { "next": tk.E, "play": tk.S, "prev": tk.W, "shutdown": tk.SW } btn_sizes = { "next": (150, 150), "play": (150, 150), "prev": (150, 150), "shutdown": (60, 60) } for playback_type in playback_types: button_img = Image.open("images/playback/%s.png" % playback_type).resize( btn_sizes[playback_type]) self.playback_button_photos[playback_type] = ImageTk.PhotoImage( button_img) self.playback_buttons[playback_type] = self.panel.create_image( btn_positions[playback_type], anchor=btn_anchors[playback_type], image=self.playback_button_photos[playback_type]) self.panel.tag_bind( self.playback_buttons[playback_type], '<Button-1>', getattr(self, '%s_button_func' % playback_type)) self.panel.pack(fill='both', expand='yes') def subreddit_button_event(self, event): x = event.x relative_x = x - 120 index = relative_x // 70 return self.change_subreddit(event, self.current_subreddit_keys[index]) def create_subreddit_buttons(self): self.subreddit_buttons = {} self.subreddit_button_photos = {} x_pos = 120 y_pos = 0 self.current_subreddit_keys = list( filter(lambda x: x != self.curr_subreddit, self.subreddits.keys())) for subreddit_key, _ in self.subreddits.items(): if subreddit_key == self.curr_subreddit: continue x_pos += 5 button_img = Image.open("images/subreddits/%s.png" % subreddit_key).resize((60, 60)) self.subreddit_button_photos[subreddit_key] = ImageTk.PhotoImage( button_img) self.subreddit_buttons[subreddit_key] = self.panel.create_image( x_pos, y_pos, anchor=tk.NW, image=self.subreddit_button_photos[subreddit_key]) self.panel.tag_bind( self.subreddit_buttons[subreddit_key], '<Button-1>', lambda event: self.subreddit_button_event(event)) x_pos += 65 self.root.update() def change_subreddit(self, event, subreddit): self.logging.debug("Change subreddit called to %s" % subreddit) curr_time = time() if curr_time - self.last_click > self.delay: self.last_click = time() if not self.alive: if self.subreddits[subreddit][2] == []: self.curr_subreddit = subreddit self.create_center_icon() self.create_subreddit_buttons() self.paused = False self.position = 0 self.toggle_loading_text() self.subreddits[ self.curr_subreddit][2] = self.reddit.get_video_link( self.subreddits[self.curr_subreddit][0], 100) self.toggle_loading_text() self.play_vid() else: self.curr_subreddit = subreddit self.create_center_icon() self.create_subreddit_buttons() self.paused = False self.position = 0 self.play_vid() def next_button_func(self, event): self.logging.debug("Next Pressed") curr_time = time() if curr_time - self.last_click > self.delay: self.last_click = time() if self.subreddits[self.curr_subreddit][1] < len( self.subreddits[self.curr_subreddit][2]): self.subreddits[self.curr_subreddit][1] += 1 else: self.subreddits[self.curr_subreddit][1] = 0 if self.alive: self.spawn_new = True self.player.stop() else: self.play_vid() def prev_button_func(self, event): self.logging.debug("Prev button func") curr_time = time() if curr_time - self.last_click > self.delay: self.last_click = time() if self.subreddits[self.curr_subreddit][1] > 0: self.subreddits[self.curr_subreddit][1] -= 1 else: self.subreddits[self.curr_subreddit][1] = len( self.subreddits[self.curr_subreddit][2]) - 1 if self.alive: self.spawn_new = True self.player.stop() else: self.play_vid() def play_button_func(self, event): curr_time = time() if curr_time - self.last_click > self.delay: self.last_click = time() self.play_vid() def shutdown_button_func(self, event): self.logging.debug("Shutdown") if not self.playing: self.root.withdraw() if tk.messagebox.askyesno("Shutdown", "Shutdown Moo-ltimedia Player?"): os.system('sudo shutdown -h now') else: self.root.deiconify() 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 play_vid_after(self, durr): self.logging.debug("Play vid func") self.position = 0 self.root.after(durr, self.play_vid()) def exit_event_func(self): self.logging.debug("Exit event func") self.playing = False self.root.update() if not self.paused: self.position = 0.0 if self.spawn_new: self.spawn_new = False self.play_vid_after(2000) else: self.alive = False def exit_button_func(self): self.logging.debug("Exit button func") if self.alive: self.player.stop() self.root.destroy()
class VideoPlayer: def __init__(self, VIDEO_NAME, IMAGE_WIDTH, IMAGE_HEIGHT, USING_VLC=False, audioPlayerRef=None, pygameRef=None): self.USING_VLC = USING_VLC self.VIDEO_FILE = VIDEO_NAME #get a reference to the audio player self.audioPlayerRef = audioPlayerRef self.player = None if self.USING_VLC: if (pygameRef == None): print( "VIDEOPLAYER ERROR: don't have a reference to pygame window!" ) self.vlcInstance = vlc.Instance() #tmp (remove comment here) self.media = self.vlcInstance.media_new('/home/pi/code/' + self.VIDEO_FILE) self.media = self.vlcInstance.media_new(self.VIDEO_FILE) # Create new instance of vlc player self.player = self.vlcInstance.media_player_new() self.player.stop() # Pass pygame window id to vlc player, so it can render its contents there. win_id = pygameRef.display.get_wm_info()['window'] self.player.set_xwindow(win_id) self.player.set_media(self.media) # TODO: correct the line below mouse.move(IMAGE_WIDTH, IMAGE_HEIGHT, True, 0) else: self.omx_stdin = None self.omx_process = None self.tot_sec = None self.STARTED = False self.PAUSED = False if (self.USING_VLC): print("VIDEOPLAYER: using VLC") else: print("VIDEOPLAYER: using OMX") # info about video self.info_video = {} self.chapters = self.get_chapters() self.curr_chapter = 0 print('VIDEOPLAYER: info video \n\t# chapter:{}\n\t{}'.format( len(self.chapters), self.chapters)) def start(self): print("VIDEOPLAYER: Starting video...") self.STARTED = True self.PAUSED = False if self.USING_VLC: self.player.play() else: if self.player: self.player.quit() self.player = None self.player = OMXPlayer(self.VIDEO_FILE, args=['--no-osd']) time.sleep(1) def stop(self): print("VIDEOPLAYER: Stopping video...") self.STARTED = False #TODO: is it necessary #self.PAUSED = True if self.USING_VLC: self.player.stop() else: self.player.quit() self.player = None def pause(self): print("VIDEOPLAYER: Pausing video...") # TODO: add some code here?? #self.PAUSED = True #?? def needUpdate(self): return (self.STARTED and self.player) def update(self): #print("VIDEOPLAYER: update") if self.USING_VLC: if self.player.get_length() - self.player.get_time( ) < 2000 and not self.PAUSED: print("VIDEOPLAYER VLC: a due secondi dalla fine") self.PAUSED = True self.player.set_pause(1) else: if self.player.duration() - self.player.position( ) < 2 and not self.PAUSED: print('VIDEOPLAYER OMX: a due secondi dalla fine') self.PAUSED = True self.player.pause() #self.printStatus() def printStatus(self): print("VIDEOPLAYER: started {}, paused {}".format( self.STARTED, self.PAUSED)) def changeChapter(self, chapter): print("VIDEOPLAYER: change chapter") if chapter != 0: print("VIDEOPLAYER: chapter != 0") # in origin era così riga commentata) #if self.PAUSED == True: #if self.PAUSED == False: #print("VIDEOPLAYER: paused is true") if self.USING_VLC: self.player.set_pause(0) else: if self.player: self.player.play() self.PAUSED = False if self.USING_VLC: self.handle_chapter_vlc(chapter) else: self.handle_chapter_omx(chapter) """ if self.USING_VLC: if self.player.get_length() - self.player.get_time() < 2000 and not self.PAUSED: self.PAUSED = True self.player.set_pause(1) else: if self.player.duration() - self.player.position() < 2 and not self.PAUSED: print('...pausing video') self.PAUSED = True self.player.pause() """ """ #not using language right now # return to italian language if self.audioPlayerRef: self.audioPlayerRef.switchToITA() """ def isPlaying(self): return self.STARTED def switch_language(self): print("Video: switch language...") if self.audioPlayerRef: self.audioPlayerRef.switchLanguage() if self.player: self.player.set_position(0) # get all chapters of video file def get_chapters(self): buff = sp.check_output([ "ffmpeg", "-i", self.VIDEO_FILE, "-f", 'ffmetadata', "file.txt", '-y' ], stderr=sp.STDOUT, universal_newlines=True) #print(buff) self.chapters = [] self.chapters_info = {} names = [] i = 0 for line in iter(buff.splitlines()): m = re.match( r".*Chapter #(\d+:\d+): start (\d+\.\d+), end (\d+\.\d+).*", line) if m != None and m.group(1) not in names: names.append(m.group(1)) self.chapters.append({ "name": i + 1, "start": float(m.group(2)), "end": float(m.group(3)) }) i = i + 1 if len(self.chapters) == 2: self.chapters[len(self.chapters) - 1]['name'] = 3 return self.chapters # check where i am: # 0: before chapter 1 # 1: chapter 1 # 2: chapter 2 # 3: chapter 3 # 10 last chapter def pos2chapter(self, pos): # ~ print('actual position', pos) for x in self.chapters: if pos >= x['start'] / 1000 and pos <= x['end']: return x['name'] if pos < self.chapters[0]['start']: return 0 if pos > self.chapters[len(self.chapters) - 1]['end']: return self.chapters[len(self.chapters) - 1]['name'] # vlc chapter manager def handle_chapter_vlc(self, c): print('VIDEOPLAYER VLC: going to', len(self.chapters), c) if len(self.chapters) == 2: if c == 3: print(1) self.player.set_chapter(1) if c == 1: print(2) self.player.set_chapter(0) else: self.player.set_chapter(c - 1) self.audioPlayerRef.stop() if c == 1: self.audioPlayerRef.start() self.curr_chapter = c # chapter manager def handle_chapter_omx(self, c): self.curr_chapter = self.pos2chapter(self.player.position()) print('VIDEOPLAYER OMX: Handle chapter: from', self.curr_chapter, 'to', c) # ~ if c != curr_chapter and c in [f['name'] for f in chapters]: if c in [f['name'] for f in self.chapters]: cpt = self.chapters[[ y for y, x in enumerate(self.chapters) if x['name'] == c ][0]] time.sleep(1) print('going to', cpt['start']) self.player.set_position(cpt['start']) time.sleep(1) self.audioPlayerRef.stop() if c == 1: self.audioPlayerRef.start() self.curr_chapter = c def kill(self): print("Kill video...") if self.USING_VLC: self.player.stop() else: self.player.quit() self.player = None
player.set_video_pos(0, 0, 700, int(512 * 2.14)) sleep(10) if noCommMode: # for debugging player.set_position(120 * 60) # player.play() # sleep(1) # player.pause() sleep(20) player.set_position(130 * 60) # player.play() sleep(20) player.set_position(140 * 60) sleep(20) player.stop() else: while True: data = conn.recv(1024) print('received: ' + str(data)) if data == 'term': break if '_' in data: cmd = data.split('_')[0] arg = float(data.split('_')[1]) if cmd == 'pause': player.set_position(arg) player.play() sleep(10) player.pause()
class ScreenMovie(LcarsScreen): def setup(self, all_sprites): ############ Start base screen ############# ### BASE_ui all_sprites.add(LcarsBackgroundImage(), layer=0) self.ui_screen_base = all_sprites.get_sprites_from_layer(0) all_sprites.add(LcarsTab(colours.COM2, 3, (50, 80)), layer=1) all_sprites.add(LcarsImageBlock(colours.BLUE5, pos=(50, 115), rectSize=(1688, 38)), layer=1) all_sprites.add(LcarsTab(colours.COM2, 4, (50, 1810)), layer=1) all_sprites.add(LcarsTab(colours.COM2, 1, (953, 50)), layer=1) all_sprites.add(LcarsImageBlock(colours.BLUE5, pos=(953, 1361), rectSize=(443, 77)), layer=1) all_sprites.add(LcarsBlockSmall( colours.BLUE6, (953, 116), "REWIND", self.rewHandler, textSize=.75, fontFace="assets/OpenSansCondensed-Bold.ttf"), layer=2) all_sprites.add(LcarsBlockSmall( colours.BLUE6, (953, 365), "PLAY", self.playHandler, textSize=.75, fontFace="assets/OpenSansCondensed-Bold.ttf"), layer=2) all_sprites.add(LcarsBlockSmall( colours.BLUE6, (953, 614), "F F", self.ffHandler, textSize=.75, fontFace="assets/OpenSansCondensed-Bold.ttf"), layer=2) all_sprites.add(LcarsBlockSmall( colours.BLUE6, (953, 863), "STOP", self.stopHandler, textSize=.75, fontFace="assets/OpenSansCondensed-Bold.ttf"), layer=2) all_sprites.add(LcarsBlockSmall( colours.BLUE6, (953, 1112), "BASE", self.mainHandler, textSize=.75, fontFace="assets/OpenSansCondensed-Bold.ttf"), layer=2) all_sprites.add(LcarsImageBlock(colours.BLUE5, pos=(953, 1361), rectSize=(443, 77)), layer=1) all_sprites.add(LcarsTab(colours.COM2, 2, (953, 1810)), layer=1) self.fileList = LcarsTextBlock(colours.BLUE6, (94, 365), self.dirlist(), rectSize=(1694, 781)) all_sprites.add(self.fileList, layer=3) all_sprites.add(LcarsImageBlock(colours.BLUE2, pos=(94, 116), text="01-3906", rectSize=(243, 100)), layer=3) all_sprites.add(LcarsImageBlock(colours.BLUE3, pos=(200, 116), text="96-4783", rectSize=(243, 500)), layer=3) all_sprites.add(LcarsImageBlock(colours.BLUE4, pos=(706, 116), text="32-6487", rectSize=(243, 163)), layer=3) all_sprites.add(LcarsElbow(colours.BLUE5, 0, (875, 116)), layer=3) all_sprites.add(LcarsImageBlock(colours.BLUE4, pos=(904, 398), rectSize=(1074, 43)), layer=3) all_sprites.add(LcarsImageBlock(colours.BLUE3, pos=(875, 1478), rectSize=(44, 72)), layer=3) all_sprites.add(LcarsElbow(colours.BLUE5, 3, (875, 1528)), layer=3) self.file_address = LcarsText( colours.BLACK, (900, 450), "NO MEDIA SELECTED", textSize=.75, fontFace="assets/OpenSansCondensed-Bold.ttf") all_sprites.add(self.file_address, layer=3) self.list_block = all_sprites.get_sprites_from_layer(3) #self.VIDEO_1_PATH = "./assets/video/LittleShopofHorrors1960Color.mp4" ### sound effects self.beep1 = Sound("assets/audio/panel/201.wav") self.lastClockUpdate = 0 #Sound("assets/audio/panel/220.wav").play() ############ End base screen ############# def dirlist(self, dirPath='./assets/video'): #os.scandir(dirPath) file_names = [] for item in os.scandir(dirPath): if item.is_file() or item.is_dir(): file_names.append(item.name) return file_names def update(self, screenSurface, fpsClock): if pygame.time.get_ticks() - self.lastClockUpdate > 500: if self.fileList.visible == True: if self.fileList.get_state() == None: self.file_address.setText("NO MEDIA SELECTED") else: self.file_address.setText(self.fileList.get_state()) self.lastClockUpdate = pygame.time.get_ticks() LcarsScreen.update(self, screenSurface, fpsClock) def handleEvents(self, event, fpsClock): if event.type == pygame.MOUSEBUTTONDOWN: self.beep1.play() if event.type == pygame.MOUSEBUTTONUP: return False def playHandler(self, item, event, clock): try: self.player.play_pause() except: try: self.VIDEO_1_PATH = './assets/video/' + self.fileList.get_state( ) self.player = OMXPlayer( self.VIDEO_1_PATH, dbus_name='org.mpris.MediaPlayer2.omxplayer1') self.player.set_aspect_mode('stretch') self.player.set_video_pos(116, 94, 1804, 947) self.player.set_alpha(255) self.showhide(self.list_block) except: pass def rewHandler(self, item, event, clock): try: self.player.action(omxkey.REWIND) except: pass def showhide(self, listofitems): for items in listofitems: items.visible = not items.visible def stopHandler(self, item, event, clock): try: self.player.stop() self.showhide(self.list_block) except: pass def ffHandler(self, item, event, clock): try: self.player.action(omxkey.FAST_FORWARD) except: pass ###### Screen Handling ##### def mainHandler(self, item, event, clock): try: self.player.stop() except: pass from screens.base import ScreenBase self.loadScreen(ScreenBase()) def logoutHandler(self, item, event, clock): from screens.authorize import ScreenAuthorize self.loadScreen(ScreenAuthorize()) def libraryHandler(self, item, event, clock): from screens.library import ScreenLibrary self.loadScreen(ScreenLibrary())
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) #player_battle.stop() #sleep(3)
class VideoPlayer: def __init__(self): self.process = None self.cmd = "" self.args = "" self.path = "" self.player = None def composeCommand(self): # split the command and use # the 'glob' module to expand the * wildchar #self.cmd = 'omxplayer --loop --no-osd --win "0 0 {} {}" --crop {},{},{},{} {}'.format(SCREENW, SCREENH, CROPX1, CROPY1, CROPX2, CROPY2, videoFileLocation) self.cmd = 'omxplayer --no-osd' self.args = shlex.split(self.cmd) self.args = self.args[:-1] + glob.glob(self.args[-1]) def loadVideo(self, path): self.path = path print(self.path) #~ self.cmd = 'omxplayer --no-osd {}'.format(videoName) #~ self.args = shlex.split( self.cmd ) #~ self.args = self.args[:-1] + glob.glob( self.args[-1] ) #~ # Open omxplayer #~ try: #~ print( " load the video " ) #~ self.process = Popen( self.args, stdin=PIPE, stdout=PIPE ) #~ print("This is the omxplayer process id: ", self.process.pid ) #~ except: #~ print("something went wrong") #~ quit() def play(self): #~ print("play") if self.player is None: self.player = OMXPlayer(self.path, args=['--no-osd', '--adev', 'local']) #~ self.player.play() #~ self.process.stdin.write(b'i') #~ self.process.stdin.flush() def stop(self): #~ print("stop") if self.player is not None: self.player.quit() self.player = None def pause(self): #~ print("pause") self.player.pause() #self.process.stdin.write(b'p') #self.process.stdin.flush() def kill(self): # quit omxplayer self.player.stop() #~ self.process.stdin.write(b'q') #~ self.process.stdin.flush() #~ self.process.stdin.close() def is_ended(self): if self.player is not None: #~ print(self.player.position()) # ~ if self.player.position() > 10 or self.player.duration() - self.player.position() < 0.2: if self.player.duration() - self.player.position() < 1: return True else: return False def next(self, videoName): self.stop() self.loadVideo(videoName) self.play()
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 OmxPlayer(BasePlayer): def __init__(self, hplayer, name): super().__init__(hplayer, name) self._validExt = [ 'mp4', 'm4v', 'mkv', 'avi', 'mov', 'flv', 'mpg', 'wmv', '3gp', 'mp3', 'aac', 'wma', 'wav', 'flac', 'aif', 'aiff', 'm4a', 'ogg', 'opus', 'webm', 'jpg', 'jpeg', 'gif', 'png', 'tif', 'tiff' ] self._thread = None self._runflag = threading.Event() self.player = None ############ ## private METHODS ############ # MPV THREAD def _mpv_thread(self): self.emit('player-ready') self.emit('status', self.status()) self.log("player ready") while self.isRunning(): self._runflag.wait(0.37) if self._runflag.isSet(): self.update('time', round(self.player.position(), 2)) time.sleep(0.05) self.isRunning(False) return def _onPlay(self, p): self.update('isPlaying', True) self.update('isPaused', False) self.emit('playing') self._runflag.set() self.log('play') def _onPause(self, p): self.update('isPlaying', False) self.update('isPaused', True) self.emit('paused') self._runflag.clear() self.log('pause') def _onExit(self, p, c): self.player._connection._bus.close() self.player._connection = None self.player = None self._runflag.clear() self.update('isPlaying', False) self.update('isPaused', False) self.emit('end') self.emit('stopped') self.log('stop') ########## ## Inherited "abstract" METHODS overloads ########## # # Start the player: # - instantiate mpv subprocess # - connect IPC socket i/o # def _start(self): # Playback thread self._thread = threading.Thread(target=self._mpv_thread) self._thread.start() # # Exit the player # - stop subprocess # - close IPC socket # def _quit(self): self.isRunning(False) if self._thread: # self.log("stopping process thread") self._thread.join() self.log("stopped") def _play(self, path): self.log("play", path) if self.player: self.player.quit() self.player = OMXPlayer(path, dbus_name='org.mpris.MediaPlayer2.omxplayer2') self.player.playEvent += self._onPlay self.player.pauseEvent += self._onPause # self.player.stopEvent += self._onStop self.player.exitEvent += self._onExit self.player.play() # self.player.set_video_pos(0,0,100,100) # self.update('duration', round(self.player.duration(),2)) def _stop(self): if self.player: self.player.stop() def _pause(self): if self.player: self.player.pause() def _resume(self): if self.player: self.player.play() def _seekTo(self, milli): if self.player: self.player.set_position(milli / 1000) # self.log("seek to", milli/1000) def _skip(self, milli): if self._status['time'] + milli / 1000 < self._status['duration']: if self.player: self.player.seek(milli / 1000) # self.log("skip", milli/1000) def _applyVolume(self, volume): if self.player: self.player.set_volume(volume / 10.0) self.log("VOLUME to", volume)
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 = []
def main(): #print( "main" ) global inputLen, prevInputLen, videoPlayer # Open video player try: print("MAIN: load the video ") videoPlayer = OMXPlayer(PATH_TO_VIDEO_FILE, args=['--no-osd', '--adev', 'local']) #videoPlayer.set_volume( AUDIO_MIN_VOLUME ) #2020-13-07 - we are not using VLC anymore :( # ~ videoPlayer = vlc.MediaPlayer( PATH_TO_VIDEO_FILE ) #process = Popen( args, stdin=PIPE, stdout=PIPE ) #print("This is the omxplayer process id: ", process.pid ) except Exception as exc: print("MAIN: something went wrong in creating the OMX video player {}". format(exc)) quit() #2020-13-07 - we are not a separate thread anymore to check for the actual playhead position #checkPositionThread = threading.Thread(target=checkLength) #checkPositionThread.start() print("MAIN: video length {}".format(videoPlayer.duration())) if B_USE_VIDEO: videoPlayer.set_volume(AUDIO_MIN_VOLUME) # 2020-07-13 - no need to use fullscreen anymore # ~ videoPlayer.toggle_fullscreen() # use it to go fullscreen videoPlayer.play() # initialize Button manager buttonManager = ButtonManager(goToStart_CB, muteAudio_CB, polarity=False) # get the current number of connected input devices inputLen = getInputDevices() prevInputLen = inputLen # start the shutdown handler function. # It will take care of opening and listening on a socket # for a "shutdown message" in order to kill the python process # and shutdown the RaspberryPi shutdownHandlerThread = threading.Thread(target=shutdownHandler) shutdownHandlerThread.start() # Main loop while True: # check if someone plugged in a mouse or a keyboard if (areThereNewInputsDevices()): # if a new input device has been found, tthis very script # must be stopped in order to let space for the user to work # with the Pi, so... # quit video player videoPlayer.stop( ) # will exit current vlc window (desktop will be visible) # TODO: kill all alive thread # find a way to do this # exit the python script quit() else: buttonManager.update() #print("MAIN: position {}".format(position) ) if B_USE_VIDEO: position = videoPlayer.position() if videoPlayer.duration() - position <= 1: videoPlayer.set_position(0.0) time.sleep(0.1)
def main(): userSelectedStream = 0 GPIO.add_event_detect(ButtonPin, GPIO.RISING, bouncetime=500) #set up button detechtion with debounce while True: ##main loop #check connection and fetch API while True: ApiData = fetch_Camera_API(droneRxIP,apiURL) #Get Camera list if len(ApiData) > 0: CamCount = len(ApiData) #count number of camera objects in json file print("Camera Count: ",CamCount) #count number of camears CamInfo={} CamInfo.clear() #fetch API Infomation for x in range(CamCount): #get Cam Name, Stream and Drone Named CamInfo[x] = {} CamInfo[x]['Name'] = ApiData[x]['camera_name'] CamInfo[x]['Stream'] = ApiData[x]['rtsp_link'] CamInfo[x]['Flyer'] = ApiData[x]['flyer_name'] print(CamInfo[x]['Name'], "-", CamInfo[x]['Stream'], "-", CamInfo[x]['Flyer']) break userSelectedStream = Stream_Selection_button(CamInfo,userSelectedStream) ##check selected camera number is real #Start player and check for button selection while True: if GPIO.event_detected(ButtonPin): #check button has been pressed print('Button pressed') userSelectedStream = userSelectedStream + 1 #increment selected stream by 1 userSelectedStream = Stream_Selection_button(CamInfo,userSelectedStream) try: if player1.is_playing() == True: print("got here") if CamInfo[userSelectedStream]['Stream'] != player1.get_source(): print("got here2") if do_CheckCamUrlStatus(CamInfo, userSelectedStream) == True: player1.load(CamInfo[userSelectedStream]['Stream']) lcd.clear() #print message to LCD lcd.message("Streaming\n") lcd.message(CamInfo[userSelectedStream]['Name']) else: try: player1.stop() except: pass print("Stream does not exist123") lcd.clear() lcd.print("Stream does not\n") lcd.print("exist") sleep(1) break else: print("Currently Streaming",player1.get_source()) except: if do_CheckCamUrlStatus(CamInfo, userSelectedStream) == True: print("expection got here") ####fix for chogm print(CamInfo[userSelectedStream]['Stream']) ####fix for chogm try: player1 = OMXPlayer(CamInfo[userSelectedStream]['Stream'], args=['-n','-1', '--live','-b', '--no-osd']) #-n -1 turns of audio decode print("expection got here!!!!!2") ####fix for chogm lcd.clear() #print message to LCD lcd.message("Streaming\n") lcd.message(CamInfo[userSelectedStream]['Name']) except: print("error here") try: player1.stop() except: pass print("Stream does not exist") lcd.clear() lcd.message("Stream does not\n") lcd.message("exist") sleep(1) break else: try: player1.stop() except: pass print("Stream does not exist") lcd.clear() lcd.message("Stream does not\n") lcd.message("exist") sleep(1) break sleep(.1)
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 Omx: def __init__(self, media_folder): self.player = None self.media_folder = media_folder self.expects_loading_exit = False self.looping = False def play(self, filename, loop=False): if self.player: self.expects_loading_exit = True self.player.load(filename) else: args = ['-b', '--no-osd', '-o', 'both'] if loop: args += ['--loop'] self.looping = True else: self.looping = False try: self.player = OMXPlayer(filename, args=args) except SystemError as e: print(e) self.player.stopEvent += self.on_player_stop self.player.exitEvent += self.on_player_exit def on_player_stop(self, player): self.player = None def on_player_exit(self, player, exit_status): if self.expects_loading_exit: self.expects_loading_exit = False else: self.player = None def stop(self): if not self.player: return self.player.stop() self.player = None def pause(self): if not self.player: return self.player.play_pause() def seek_fraction(self, fraction): if not self.player: return duration = self.player.duration() self.player.set_position(fraction * duration) def set_volume(self, volume): if not self.player: return if volume > 10: volume = 10 elif volume < 0: volume = 0 self.player.set_volume(volume) def get_source(self): """ Get player source and remove media folder """ source = self.player.get_source() if source.startswith(self.media_folder + "/"): return source[len(self.media_folder) + 1:] else: return source def status(self): if not self.player: return { 'status': 'stopped', 'source': None, } return { 'status': self.player.playback_status(), 'source': self.get_source(), 'position': self.player.position(), 'duration': self.player.duration(), 'volume': self.player.volume(), 'looping': self.looping, }
player_stop = OMXPlayer(BLACK_PATH, dbus_name='org.mpris.MediaPlayer2.omxplayer2') # it takes about this long for omxplayer to warm up and start displaying a picture on a rpi3 player_action.pause() sleep(2.5) player_stop.pause() try: while True: # Button was pressed if ( GPIO.input(button) == GPIO.LOW ): sleep(1) try: if (player_action.is_playing() == True): player_action.stop() sleep(1) player_action = OMXPlayer(VIDEO_PATH, dbus_name='org.mpris.MediaPlayer2.omxplayer1') else: player_action.play() sleep(1) except: sleep(1) except KeyboardInterrupt: try: player_action.quit() player_stop.quit()
class VideoPlayerScreen(Screen): slider = ObjectProperty() minimized = BooleanProperty(True) video_path = StringProperty() # 20200308tagesthemen.mp4 def is_playing(self): if hasattr(self, 'player'): try: return self.player.is_playing() except OMXPlayerDeadError: self.leave_player() return False else: return False def set_play_pause_bttn(self, *args): print(self.ids) if self.is_playing(): self.ids.play_pause_image.source = 'atlas://data/images/defaulttheme/media-playback-pause' else: self.ids.play_pause_image.source = 'atlas://data/images/defaulttheme/media-playback-start' def play(self): VIDEO_PATH = Path("videos/" + self.video_path) print(VIDEO_PATH) self.player = OMXPlayer(VIDEO_PATH, args=['-o', 'alsa', '--layer', '100000']) self.player.set_video_pos(0, 0, 800, 480) self.set_slider() self.change_size() Clock.schedule_interval(self.set_slider, 3) Clock.schedule_interval(self.set_play_pause_bttn, 1) def player_stop(self): Clock.unschedule(self.set_play_pause_bttn) Clock.unschedule(self.set_slider) if self.is_playing(): self.player.stop() @staticmethod def leave_player(): App.get_running_app().root.current = 'base' def play_pause(self): self.player.play_pause() def quit(self, gg, **kwargs): self.player.quit() App.get_running_app().stop() def set_slider(self, *args): try: pos = self.player.position() # in seconds as int duration = self.player.duration() # in seconds as float self.slider.value_normalized = pos / duration except OMXPlayerDeadError: self.leave_player() def set_videopos(self, *args): pos = self.player.position() # in seconds as int duration = self.player.duration() # in seconds as float if abs(pos / duration - self.slider.value_normalized) > 0.05: self.player.set_position(self.slider.value_normalized * duration) def change_size(self): if self.minimized: self.player.set_alpha(255) else: self.player.set_alpha(100) self.minimized = not self.minimized
class PlaybackController(object): def __init__(self): self.player = None self.queue = [] self.current_playbackitem = None self.volume = 0.6 def __str__(self): if self.current_playbackitem: return f"{self.get_status()} {self.current_playbackitem.get_title()}. {len(self.queue)} items in queue." else: return f"{self.get_status()}. {len(self.queue)} items in queue." def get_title(self): if self.current_playbackitem: return self.current_playbackitem.get_title() else: return "Not playing anything." def _on_omxplayer_exit(self, player, exit_status): log.info("OMXPlayer exit: {}".format(exit_status)) self.player = None if exit_status == 0: self.current_playbackitem = None self._new_player() def _new_player(self): """Creates a new player by popping from queue.""" log.info("Creating new OMXplayer.") if self.player is not None: self.player.quit() if self.current_playbackitem is None: if len(self.queue) == 0: raise ValueError("Nothing to play.") else: self.current_playbackitem = self.queue.pop(0) log.info("Creating player for video: {}".format( self.current_playbackitem)) self.player = OMXPlayer(self.current_playbackitem.get_direct_url()) self.player.set_volume(self.volume) self.player.exitEvent.subscribe(self._on_omxplayer_exit) def add_single_url(self, url): n_item = PlaybackItem(url) if n_item is not None: self.queue.append(n_item) return True raise ValueError("Could not get URL") def playlist(self, url): log.info("Adding every videos from playlist to queue.") ydl = youtube_dl.YoutubeDL({ 'logger': log, 'extract_flat': 'in_playlist', 'ignoreerrors': True, }) with ydl: # Downloading youtub-dl infos result = ydl.extract_info(url, download=False) for i in result['entries']: logger.info("queuing video") if i != result['entries'][0]: try: if "://" not in i['url']: self.add_single_url("https://youtube.com/?v=" + i['url']) else: self.add_single_url(i['url']) except Exception as e: log.error("Could not enqueue " + i['url']) log.error(e) def play(self): if self.get_status() == "Playing": log.debug("Playback already playing.") return if self.player is None and len(self.queue) > 0: self._new_player() else: log.error("Nothing to play!") def stop(self): if self.player is not None: self.player.stop() self.player = None def playpause(self): if self.player is None: log.error("No player running.") if len(self.queue) > 0: self.play() else: self.player.play_pause() def pause(self): if self.get_status() == "Paused": log.debug("Playback is already paused.") return def seek(self, seconds): if self.player is None: raise Exception("Player is not running") self.player.seek(seconds) def change_volume(self, increment): self.volume += increment if self.volume < 0.0: self.volume = 0.0 elif self.volume > 1.0: self.volume = 1.0 if self.player is not None: self.player.set_volume(self.volume) def get_volume(self): if self.player is not None: return self.player.volume() else: return self.volume def get_status(self): if self.player is None: return "Stopped" try: return self.player.playback_status() except OMXPlayerDeadError: log.error("OMXPlayer is dead.") self.player = None return "Stopped" def next_video(self): self.stop() self.current_playbackitem = None self._new_player() def shutdown(self): self.stop()