class SpdifPlayback(WorkflowTestFixture): def setUpFixture(self): self.zone = self.get_testbed_device_by_model(SOUNDBAR) self.verifyTrueOrStop(self.zone.diag.is_toslink_connected(), 'TOSLINK should be connected') self.mplayer = Player(args=MPLAYER_ARGS) def tearDownFixture(self): self.mplayer.stop() self.mplayer.quit() def _is_stream_type_expected(self): """ Verifies TOSLINK Stream Type is expected :return: Is Stream Type expected? :rtype: :obj:`bool` """ return self.zone.diag.get_toslink_stream_type() == EXPECTED_STREAM_TYPE def test_spdif_playback(self): """ Verifies SPDIF playback by checking TOSLINK Stream Type """ self.mplayer.loadfile(TRACK) wait_until_true(lambda: self._is_stream_type_expected(), timeout_seconds=10, reason="Timed out waiting for expected stream type")
class MPlayer(object): def __init__(self, *args, **kwargs): self.argparser = None self.exit = False self.paused = False self.player = Player() def set_argparser(self, argparser): self.argparser = argparser def start(self, *args, **kwargs): pass @property def is_playing(self): if self.player.filename and not self.paused: status = True else: status = False return status def play(self, path, track, block=True): self.player.loadfile(path) self.player.pause() time.sleep(3) if block: while self.player.filename: if self.exit: break try: time.sleep(0.1) except KeyboardInterrupt: pass def pause(self): if self.is_playing: self.paused = True self.player.pause() def stop(self): self.player.stop() def resume(self): if not self.is_playing: self.pause = False self.player.pause() def shutdown(self): if self.player.is_alive(): self.player.quit()
class Sound(object): """ A Sound object is a simple abstraction of an underlying sound that can be played, stopped, etc. """ def __init__(self, path, volume=100): self.path = path # We need to set the volume when creating the mplayer process. If we # don't, the sound would start playing at 100% for about 1 sec before # the actual volume gets applied self.player = Player(stdout=PIPE, stderr=PIPE, args=('-volume {0}'.format(volume))) self.player.loadfile(self.path) # Pause the stream so we can't do something else before calling play() self.player.pause() def play(self, loop=False): if loop: self.player.loop = 0 self.player.pause() def pause(self): self.player.pause() def stop(self): self.player.stop() def get_volume(self): return self.player.volume def set_volume(self, volume): self.player.volume = volume def get_duration(self): return self.player.length def destroy(self): self.player.quit() def __del__(self): self.destroy()
class PiPlayBoxMode(BaseMode): def setup(self): self.modecolour = self.display.RED self.display.changeColour(self.modecolour) self.enabled = self.__ping() self.mplayer = None if self.enabled: self.actions = { 0: { "text": "Capital FM", "sound": "http://ice-sov.musicradio.com:80/CapitalMP3" }, 1: { "text": None, "sound": None }, 2: { "text": None, "sound": None }, 3: { "text": None, "sound": None }, 4: { "text": None, "sound": None }, 5: { "text": None, "sound": None }, 6: { "text": None, "sound": None }, 7: { "text": None, "sound": None } } self.addInterrupts() self.modename = "Internet Radio" self.subtext = "ONLINE" self.mplayer = Player() else: self.modename = "No Internet" self.subtext = "Connection" self.display.Update("%s\n%s" % (self.modename, self.subtext)) def __ping(self): self.display.Update("Checking if\nonline...") try: a = check_call( ["/bin/ping", "www.bbc.co.uk", "-c", "1", "-t", "200"]) return True except CalledProcessError: return False def addInterrupts(self): e = GPIO.add_event_detect for i in range(8): e(self.buttons[i], GPIO.RISING, lambda channel, x=i: self.buttonAction(x), bouncetime=600) def buttonAction(self, button): action = self.actions[button] if action["text"] is not None: self.display.Update(action["text"]) self.mplayer.stop() self.speaker.Unmute() self.mplayer.loadfile(action["sound"]) def quit(self): if self.mplayer is not None and self.mplayer.is_alive(): self.mplayer.stop() self.mplayer.quit() self.speaker.Mute() self.mplayer = None
class ZeroPlayer(Frame): def __init__(self, windowed=False): super().__init__() self.windowed = windowed self.user = getpass.getuser() if windowed: self.player = Player(args=('-xy', '800', '-geometry', '1100:100', '-noborder', '-ontop')) else: self.player = Player() self.mp3_search = "/media/" + self.user + "/*/*/*/*.mp*" self.m3u_def = "ALLTracks" self.m3u_dir = "/media/" + self.user + "/MUSIC/" self.mp4playing = False self.volume = 100 self.stop_start = 22 self.nexttrk = 27 self.prevtrk = 23 self.autoplay = 0 self.track = "" self.track_no = 0 self.drive_name = "" self.que_dir = self.m3u_dir + self.m3u_def + ".m3u" self.m = 0 self.counter5 = 0 self.trackchangetime = time.time() + GAPTIME self.status = IDLE self.cmdbutton = PLAYING self.play_stopped = False if RunningOnPi: print(alsaaudio.mixers()) if len(alsaaudio.mixers()) > 0: for mixername in alsaaudio.mixers(): self.m = alsaaudio.Mixer(mixername) self.m.setvolume(self.volume) self.gpio_enable = 1 GPIO.setmode(GPIO.BCM) GPIO.setwarnings(False) GPIO.setup(self.stop_start, GPIO.IN, pull_up_down=GPIO.PUD_UP) GPIO.setup(self.nexttrk, GPIO.IN, pull_up_down=GPIO.PUD_UP) GPIO.setup(self.prevtrk, GPIO.IN, pull_up_down=GPIO.PUD_UP) # setup GUI self.canvas = tk.Canvas(width=320, height=240) self.canvas.bind("<Key>", self.key) self.canvas.bind("<Button-1>", self.callback) self.canvas.pack() self.bgimg = ImageTk.PhotoImage( Image.open('Minibackground.png').resize((320, 240), Image.ANTIALIAS)) self.canvas.create_image(0, 0, anchor=tk.NW, image=self.bgimg) self.titlefont = tkinter.font.Font(family='KG Defying Gravity Bounce', size=28) self.artistfont = tkinter.font.Font(family='Victoria', size=30) self.numberfont = tkinter.font.Font(family='DotMatrix', size=20) self.title_id = None self.artist_id = None self.remining_id = None self.start_id = None self.stop_id = None self.startimg = ImageTk.PhotoImage( Image.open('play.png').resize((32, 32), Image.ANTIALIAS)) self.stopimg = ImageTk.PhotoImage( Image.open('stop.png').resize((32, 32), Image.ANTIALIAS)) self.canvas.focus_set() self.change_start_button() self.length = 27 if RunningOnPi: self.Check_switches() # check default .m3u exists, if not then make it if not os.path.exists(self.que_dir): self.Create_Playlist() self.init_tunes() self.Show_Track() def change_start_button(self): if self.status == PLAYING and self.cmdbutton == IDLE: if self.stop_id: self.canvas.delete(self.stop_id) self.stop_id = None self.start_id = self.canvas.create_image(20, 10, anchor=tk.NW, image=self.startimg) self.cmdbutton = PLAYING elif self.status == IDLE and self.cmdbutton == PLAYING: if self.start_id: self.canvas.delete(self.start_id) self.start_id = None self.stop_id = self.canvas.create_image(20, 10, anchor=tk.NW, image=self.stopimg) self.cmdbutton = IDLE def init_tunes(self): Tracks = [] with open(self.que_dir, "r") as textobj: line = textobj.readline() while line: Tracks.append(line.strip()) line = textobj.readline() self.tunes = [] for counter in range(0, len(Tracks)): z, self.drive_name1, self.drive_name2, self.drive_name, self.artist_name, self.album_name, self.track_name = Tracks[ counter].split('/') self.tunes.append(self.artist_name + "^" + self.album_name + "^" + self.track_name + "^" + self.drive_name + "^" + self.drive_name1 + "^" + self.drive_name2) def key(self, event): '''print("pressed", event.char)''' if event.char == 'w' and self.status == IDLE: self.Play() if event.char == 's' and self.status == PLAYING: self.Stop() if event.char == 'd': self.Next_Track() if event.char == 'a': self.Prev_Track() if event.char == 'q': quit() def callback(self, event): if time.time() < self.trackchangetime: return self.trackchangetime = time.time() + GAPTIME if event.y < 52: if self.status == PLAYING: print("clicked Stop", event.x, event.y) self.Stop() elif self.status == IDLE: print("clicked Play", event.x, event.y) self.Play() else: if event.x < 160: print("clicked Prev", event.x, event.y) self.Prev_Track() elif event.x > 160: print("clicked Next", event.x, event.y) self.Next_Track() def Check_switches(self): buttonPressed = False if GPIO.input(self.prevtrk) == 0: buttonPressed = True self.Prev_Track() elif GPIO.input(self.nexttrk) == 0: buttonPressed = True self.Next_Track() elif GPIO.input(self.stop_start) == 0: if self.status == PLAYING: buttonPressed = True self.Stop() elif self.status == IDLE: buttonPressed = True self.Play() if buttonPressed: self.after(200, self.Buttons_released) else: self.after(200, self.Check_switches) def Buttons_released(self): if self.status == IDLE: self.after(200, self.Check_switches) return buttonPressed = False if GPIO.input(self.prevtrk) == 0: buttonPressed = True elif GPIO.input(self.nexttrk) == 0: buttonPressed = True elif GPIO.input(self.stop_start) == 0: buttonPressed = True if buttonPressed: self.after(200, self.Buttons_released) else: self.after(200, self.Check_switches) def getline(self, str, breakpoint): if breakpoint is None: return str[0:TITLEHI] + ']\n[' + str[TITLEHI:] return str[0:breakpoint] + ']\n[' + str[breakpoint + 1:] def set_title(self, title): if self.title_id: self.canvas.delete(self.title_id) title_has_space = False title_has_lower = False for ch in title: if ch.islower(): title_has_lower = True if ch == ' ' or ch == '_': title_has_space = True modded = '' breakpoints = [] count = 0 if title_has_lower == True and title_has_space == False: ''' Add spaces before every uppercase letter ''' for ch in title: if ch.isupper(): if count == 0: modded = modded + ch.lower() count += 1 else: modded = modded + '|' + ch.lower() breakpoints.append(count) count += 2 if ch.islower(): modded = modded + ch count += 1 else: ''' Convert everything to lower case letters ''' for ch in title: if ch.isupper(): modded = modded + ch.lower() count += 1 if ch.islower(): modded = modded + ch count += 1 if ch == ' ' or ch == '_': modded = modded + '|' breakpoints.append(count) count += 1 modded = '[' + modded + ']' goodbreak = 0 extra = 0 if len(modded) > TITLEHI: ''' Insert linebreak for first line ''' goodbreak = 0 extra = 1 for b in breakpoints: if goodbreak == 0: goodbreak = b if b > TITLELO and b < TITLEHI + 1: goodbreak = b if goodbreak == 0: goodbreak = len(modded) elif len(modded) > goodbreak + extra: modded = self.getline(modded, goodbreak + extra) extra += 2 if len(modded[goodbreak + extra:]) > TITLEHI: ''' Insert linebreaks for second line ''' lastbreak = goodbreak for b in breakpoints: if b > lastbreak and goodbreak == lastbreak: goodbreak = b if b > lastbreak and b - lastbreak > TITLELO and b - lastbreak < TITLEHI + 1: goodbreak = b if len(modded) > goodbreak + extra: modded = self.getline(modded, goodbreak + extra) ''' Three lines is max for this display ''' self.title_id = self.canvas.create_text(320 / 2, 240 / 2 - 2, anchor='center', justify='center', text=modded, font=self.titlefont, fill='red') def set_artist(self, artist): if self.artist_id: self.canvas.delete(self.artist_id) self.artist_id = self.canvas.create_text(320 / 2, 210, anchor='center', text=artist, font=self.artistfont) def set_remining_time(self, remining_time=None): if self.remining_id: self.canvas.delete(self.remining_id) if not remining_time is None: self.remining_id = self.canvas.create_text(310, 30, anchor='e', text=remining_time, font=self.numberfont, fill='light green') def tune(self): if 'mp4' in self.track: return 4000.0 return 0.0 def Show_Track(self): if len(self.tunes) > 0: self.artist_name,self.album_name,self.track_name,self.drive_name,self.drive_name1,self.drive_name2 = \ self.tunes[self.track_no].split('^') self.track = os.path.join("/" + self.drive_name1, self.drive_name2, self.drive_name, self.artist_name, self.album_name, self.track_name) self.set_artist(self.artist_name) self.set_title(self.track_name[:-4]) if os.path.exists(self.track): audio = MediaInfo.parse(self.track) self.track_len = (audio.tracks[0].duration + self.tune()) / 1000.0 minutes = int(self.track_len // 60) seconds = int(self.track_len - (minutes * 60)) def Play(self): self.autoplay = 1 if self.status == IDLE: self.status = PLAYING self.Play_track() def Stop(self): self.status = IDLE self.autoplay = 0 def Next_Track(self): if self.status == PLAYING: self.status = IDLE while self.play_stopped: time.sleep(0.2) self.inc_track() elif self.status == IDLE: self.inc_track() def Prev_Track(self): if self.status == PLAYING: self.status = IDLE while self.play_stopped: time.sleep(0.2) self.dec_track(2) elif self.status == IDLE: self.dec_track() def Play_track(self): if self.status == IDLE: return if os.path.exists(self.track): if 'mp3' in self.track or not RunningOnPi or UseOmxplayer == False: self.player.stop() if self.mp4playing: os.killpg(self.p.pid, signal.SIGTERM) self.player.loadfile(self.track) else: self.player.stop() if self.mp4playing: os.killpg(self.p.pid, signal.SIGTERM) if self.windowed: rpistr = "omxplayer --win 800,90,1840,700 " + '"' + self.track + '"' else: rpistr = "omxplayer --win 0,49,320,240 " + '"' + self.track + '"' self.p = subprocess.Popen(rpistr, shell=True, preexec_fn=os.setsid) self.mp4playing = True self.start = time.time() else: return self.play_stopped = False self.player.time_pos = 0 self.show_remining_time() self.change_start_button() self.Play_track2() def Play_track2(self): if time.time() - self.start > self.track_len or self.status == IDLE: self.status = IDLE if self.mp4playing: os.killpg(self.p.pid, signal.SIGTERM) self.mp4playing = False self.player.stop() else: self.player.stop() self.show_remining_time() self.change_start_button() self.play_stopped = True if self.autoplay == 1: self.status = PLAYING self.inc_track() return self.show_remining_time() self.after(200, self.Play_track2) def show_remining_time(self): if self.status == IDLE: self.set_remining_time() return played = time.time() - self.start p_minutes = int(played // 60) p_seconds = int(played - (p_minutes * 60)) lefttime = self.track_len - played minutes = int(lefttime // 60) seconds = int(lefttime - (minutes * 60)) self.set_remining_time("%02d:%02d" % (minutes, seconds % 60)) def inc_track(self): self.track_no += 1 if self.track_no > len(self.tunes) - 1: self.track_no = 0 self.Show_Track() if self.autoplay == 1: self.status = PLAYING self.Play_track() else: self.status = IDLE def dec_track(self, val=1): for i in range(0, val): self.track_no -= 1 if self.track_no < 0: self.track_no = len(self.tunes) - 1 self.Show_Track() if self.autoplay == 1: self.Play_track() else: self.status = IDLE def Create_Playlist(self): self.timer = time.time() if self.status == PLAYING: self.status = IDLE self.player.stop() if os.path.exists(self.m3u_dir + self.m3u_def + ".m3u"): os.remove(self.m3u_dir + self.m3u_def + ".m3u") self.Tracks = glob.glob(self.mp3_search) if len(self.Tracks) > 0: with open(self.m3u_dir + self.m3u_def + ".m3u", 'w') as f: for item in sorted(self.Tracks): f.write("%s\n" % item)
old_vals = vals = ['0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0'] palette = palette_counter = 0 just_changed_palette = 0 while 1: x = ser.readline() vals = x.strip().split(',') print " " print old_vals print vals for i in range(0, len(vals)): if (int(vals[i]) == 1 and int(old_vals[i]) == 0): print "trigger " + str(i) if (i == 7): if (random.randint(0,1) == 0 or just_changed_palette == 1): just_changed_palette = 0 playerv.stop() vid = video_file(random.randint(1,total_video_files)) print vid playerv.loadfile(vid) playerv.fullscreen = True else: playerv.stop() playerv.loadfile(long_file(random.randint(1,total_long_files))) playerv.fullscreen = True elif (i == 8): palette_counter = palette_counter + 1 palette = palette_counter % total_palettes just_changed_palette = 1 print "counter is at " + str(palette_counter) print "palette is at " + str(palette) else:
class BasePlayer(object): def __init__(self, playEndedCallback): self.isPlaying = False self.mplayer = MPlayer(autospawn=False) self.timer = Timer(interval=1, function=Player.loop, args=[self]) self.timer.start() self.playEndedCallback = playEndedCallback def stop(self): self.isPlaying = False self.mplayer.stop() def pause_resume(self): self.mplayer.pause() def seek(self, amount): if self.mplayer.time_pos: self.mplayer.time_pos += amount def play(self, mediafile): self.isPlaying = True args = [] self.mplayer.args = args self.mplayer.spawn() if mediafile: self.mplayer.loadfile(mediafile) def quit(self): self.isPlaying = False self.timer.cancel() self.mplayer.quit() print "timer cancelled" @classmethod def loop(cls, player): #return if not playing if not player.isPlaying: return t = Timer(1, cls.loop, [player]) t.start() # from videotop import status_bar # status_bar.set_text("%s/%s -- curr: %s" % ( player.player.length, player.player.time_pos, player.current)) # print("%s/%s -- curr: %s" % ( player.mplayer.length, player.mplayer.time_pos, player.current)) if player.mplayer.length != None: time.sleep(1000) else: player.playEndedCallback() t.cancel() def __del__(self): self.quit()
class PlayerThread(threading.Thread): def __init__(self, subsonic, msg_queue): # Read config and setup the player accordingly self.config = read_config() self.download_queue = [] subsonic = Subsonic() self.subsonic = subsonic.connection self.mplayer = MPlayer( args=("-really-quiet", "-msglevel", "global=6", "-nolirc") ) self.mplayer.stdout.connect(self._handle_data) self.msg_queue = msg_queue super(PlayerThread, self).__init__() def _handle_data(self, data): # Handle the stdout stream coming back from MPlayer. if data.startswith('EOF code:'): if data.split(": ")[1] == "1": # EOF Code: 1 means that the song finished playing # by itself. Therefore we want to try to play the # next song in the queue. self.msg_queue.put("EOF") def _get_stream(self, song_id): return self.subsonic.stream(song_id) def _get_song(self, song_id): song_file = os.path.join(MUSIC_CACHE_DIR, "%s.mp3" % song_id) if os.path.exists(song_file): logger.info("The song with id %s was found in the cache" % song_id) # Check if file already exists in cache if not os.path.exists(MUSIC_CACHE_DIR): # Make sure the cache dir is present. os.makedirs(MUSIC_CACHE_DIR) if not song_id in self.download_queue: # Check if the song is not already downloading logger.debug("Downloading song with id: %s" % song_id) self.download_queue.append(song_id) try: stream = self._get_stream(song_id) f = open(song_file, "wb") f.write(stream.read()) f.close() logger.debug("Finished downloading song with id: %s" % song_id) except Exception as e: logger.error( "Could not download song with id: %s - Error was: %s" % ( song_id, e ) ) self.download_queue = [ x for x in self.download_queue if x != song_id ] else: logger.info( "Song with id %s is already in download queue. \ Doing nothing." % song_id ) # TODO: Handle this. Should we wait here for a little bit # and see if it finishes downloading? # At this point, if it clashes, it gets stuck in stopped state. return song_file def play_song(self, song_id): song_file = self._get_song(song_id) self.mplayer.stop() self.mplayer.loadfile(song_file) # Hacky, but needed to work. Check if Linux or Darwin, if so # also play the file after loading it. On OS X, pressing play # is not needed. if "linux" or "darwin" in platform: self.mplayer.pause() def play(self): if self.is_paused(): self.mplayer.pause() def pause(self): self.mplayer.pause() def stop(self): self.mplayer.stop() def seek(self, timedelta): if not self.is_stopped() and isinstance(timedelta, int): time_pos = self.mplayer.time_pos length = self.mplayer.length new_time_pos = time_pos + timedelta if new_time_pos < 0: new_time_pos = 0 elif new_time_pos > length: # So we have seeked passed the length of the song? # Play next song. self.msg_queue.put("EOF") self.mplayer.time_pos = new_time_pos def player_state(self): if self.is_playing(): return "Playing" elif self.is_paused(): return "Paused" else: return "Stopped" def is_playing(self): return bool(self.mplayer.filename and not self.mplayer.paused) def is_paused(self): return bool(self.mplayer.filename and self.mplayer.paused) def is_stopped(self): return bool(not self.mplayer.filename) def progress(self): ret = None if self.mplayer.time_pos: try: ret = { "percent": self.mplayer.percent_pos, "time": int(self.mplayer.time_pos), "length": int(self.mplayer.length), } except: ret = { "percent": 0, "time": 0, "length": 0, } return ret def quit(self): self.mplayer.quit()
class MusicPlayer(object): def __init__(self): self.playlist = [] # Array of all tracks self.playlist_id = 0 # Id of playlist self.current_track_index = 0 # Index of current song self.player = Player() # MPlayer instance self.webclient = Webclient() # Client for WebInterface self.mobileclient = Mobileclient() # Client for MobileInterface self.timer = None # Timer to start next track self.deviceid = 0 # DeviceId to use self.playtype = PlayType.LINEAR # LINEAR or SHUFFLE def login(self, username, password): """ Login to Google Music. Keyword arguments: username -- the username password -- the password Returns: True if successful else False """ # If either the web client or the mobile client failed to login return False if not self.webclient.login(username, password) or not self.mobileclient.login(username, password): return False # Use first found devices as ID devices = self.webclient.get_registered_devices(); # Convert HEX to INT self.deviceid = int(devices[0]['id'], 16) return True def load_playlist(self, playlist_name): # Load playlist for playlist in self.mobileclient.get_all_user_playlist_contents(): if playlist['name'] == playlist_name: for track_obj in playlist['tracks']: track_obj['track']['id'] = track_obj['id'] self.playlist.append(track_obj['track']) # Set playlist_id self.playlist_id = playlist['id'] break; # If playlist has not been found, create it if self.playlist_id == 0: self.playlist_id = self.mobileclient.create_playlist(playlist_name) def add_track_to_playlist(self, track): """ Append a track to the end of playlist Keyword arguments: track -- a dictionary containing the track informations """ track_id = self.mobileclient.add_songs_to_playlist(self.playlist_id, track['nid'])[0] track['id'] = track_id self.playlist.append(track) # Notify all clients about the new track factory.forwarder.dispatch(PLAYLIST_EVENT_TRACK_ADDED, json.dumps(track)) def remove_track_from_playlist(self, track_id): """ Removes a track from the playlist Keyword arguments: track_id -- The id of the track to remove """ self.mobileclient.remove_entries_from_playlist(track_id) index_to_remove = self._find_index_of_track_id(track_id) del self.playlist[index_to_remove] factory.forwarder.dispatch(PLAYLIST_EVENT_TRACK_REMOVED, track_id) def play_track(self, track_id): """ Play a track Keyword arguments: track_id -- Id of the track to play """ index_of_track = self._find_index_of_track_id(track_id) track_to_play = self.playlist[index_of_track] if track_to_play is not None: # Request stream url from google music stream_url = self.mobileclient.get_stream_url(track_to_play["storeId"], self.deviceid) # Load stream url to mplayer self.player.loadfile(stream_url) # For some reason OSX needs to unpause mplayer if sys.platform == "darwin": self.player.pause() # Set track self.current_track_index = index_of_track # Cancel previous timer if self.timer is not None: self.timer.cancel() # How many minutes does the track last track_duration = long(track_to_play["durationMillis"]) / 1000 # Set Timer to play next track when trackDuration is over self.timer = Timer(track_duration, self.play_next_track) self.timer.daemon = True self.timer.start() print "playing", track_to_play["artist"], " - ", track_to_play["title"], " : ", stream_url # Fire event that a new track is playing factory.forwarder.dispatch(TRACK_EVENT_PLAYBACK, json.dumps(track_to_play)) return True else: return False def play_next_track(self): """ Play the next track in the playlist. Returns: True or False """ if self.playtype == PlayType.LINEAR: # Index of next track to play next_track_index = self.current_track_index + 1 # Restart at index 0 if end of playlist is reached if next_track_index >= len(self.playlist): next_track_index = 0 elif self.playtype == PlayType.SHUFFLE: # Index of next track to play at random next_track_index = random.randrange(0, len(self.playlist), 1) # Obtain the id of the next track to play next_track_id = self.playlist[next_track_index]['id'] # Play track with that id return self.play_track(next_track_id) def play_previous_track(self): """ Play the previous track in the playlist. Returns: True or False """ if self.playtype == PlayType.LINEAR: # Index of previous track to play previous_track_index = self.current_track_index - 1 # Contiune from the end of the playlist if previous_track_index <= 0: previous_track_index = len(self.playlist) - 1 elif self.playtype == PlayType.SHUFFLE: # Index of the previous track is random previous_track_index = random.randrange(0, len(self.playlist), 1) # Obtain the id of the previous track to play previous_track_id = self.playlist[previous_track_index]['id'] # Play track with that id return self.play_track(previous_track_id) def stop(self): """ Stop playback. """ if self.timer is not None: self.timer.cancel() if self.player is not None: self.player.stop() def play(self): """ Start playing current track Returns: True if track has been started. Else False """ current_track_id = self.playlist[self.current_track_index] return self.play_track(current_track_id) def _find_index_of_track_id(self, track_id): index = 0 for track in self.playlist: if track['id'] == track_id: return index index += 1 return None
else: self.message = "" except: log.exception("Error in Media loop") self.stopping = True self.message = ", Errored" if __name__ == '__main__': print ("Showing all current settings") media = MediaPlayer(None) print ("Playing file %s", PANIC_ALARM) player = Player("-cache 1024") player.loadfile(PANIC_ALARM) player.loop = 0 # Set default prefix for all Player instances player.cmd_prefix = CmdPrefix.PAUSING_KEEP time.sleep(2) #~ try: meta = player.metadata['title'] print ("title : " + meta) #~ except Exception as e: #~ e = sys.exc_info()[0] #~ print "Error: %s" % e time.sleep(2) player.stop()
class MplayerAudio(): def __init__(self, config): self.config = config self.state = u'stopped' self.uri = None self.player = Player() def emit_data(buffer_): return Wrap(False) def emit_end_of_stream(self): pass def get_mute(self): return Wrap(self.player.mute) def get_position(self): return Wrap(1) ''' def get_volume(self): return Wrap(int(self.player.volume)) return Wrap(0) ''' def pause_playback(self): if not self.player.paused: self.player.pause() self.state = u'paused' return Wrap(True) ''' def prepare_change(self): pass ''' def set_appsrc(self, caps, need_data=None, enough_data=None, seek_data=None): pass def set_metadata(self, track): return Wrap(False) def set_mute(self, mute): self.player.mute = mute return Wrap(True) def set_position(self, position): return Wrap(False) def set_uri(self, uri): self.uri = uri return Wrap(True) def set_volume(self, volume): # self.player.volume = volume return Wrap(True) def start_playback(self): if self.player.paused: self.player.pause() if not self.player.filename: self.player.loadfile(self.uri.replace('mplayer:', '')) self.state = u'playing' return Wrap(True) def stop_playback(self): self.player.stop() self.state = u'stopped' return Wrap(True) def prepare_change(self): self.player.stop() return Wrap(True) def set_about_to_finish_callback(self, callback): pass
class MPlayer(QObject): stateChanged = pyqtSignal(int) def __init__(self, xid, *args, **kwargs): QObject.__init__(self, *args, **kwargs) self.mp = Player(args=('-wid', str(int(xid)), '-vf', 'eq2', '-fixed-vo', '-af', 'volume', '-volume', '0', '-cache', '512')) self.url = None self.player_state = PLAYERSTATE_STOPPED self.check_state = False def play(self, url): if self.url == url: return self.url = url if not self.check_state: self.check_state = True threading.Thread(target=self._monitor_state).start() self.mp.loadfile(self.url) def _monitor_state(self): while self.mp.filename is None: time.sleep(1) self.mp.pause() while self.check_state: state = PLAYERSTATE_STOPPED if self.mp is None: state = PLAYERSTATE_STOPPED if self.mp.filename is None: state = PLAYERSTATE_STOPPED if self.mp.paused: state = PLAYERSTATE_PAUSED if self.mp.filename and not self.mp.paused: state = PLAYERSTATE_PLAYING if state != self.player_state: self.player_state = state self.stateChanged.emit(state) return time.sleep(0.1) self.player_state = PLAYERSTATE_STOPPED def pause(self): if self.mp: self.mp.pause() if self.player_state == PLAYERSTATE_PAUSED: self.player_state = PLAYERSTATE_PLAYING else: self.player_state = PLAYERSTATE_PAUSED self.stateChanged.emit(self.player_state) def unpause(self): self.pause() def stop(self): if self.mp: self.mp.stop() self.stateChanged.emit(PLAYERSTATE_STOPPED) self.check_state = False self.url = None def setVolume(self, value): if self.mp: self.mp.volume = value def setEq(self, b, c, s, h): if self.mp: self.mp.brightness = b self.mp.contrast = c self.mp.saturation = s self.mp.hue = h def setRatio(self, ratio): if not self.mp: return if ratio == 0: ratio = 0 elif ratio == 1: ratio = 1 elif ratio == 2: ratio = 1.5 elif ratio == 3: ratio = 1.33 elif ratio == 4: ratio = 1.25 elif ratio == 5: ratio = 1.55 elif ratio == 64: ratio = 1.4 elif ratio == 7: ratio = 1.77 elif ratio == 8: ratio = 1.6 elif ratio == 9: ratio = 2.35 self.mp.switch_ratio(ratio) def state(self): # print("state: {0}".format(self.player_state)) return self.player_state