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
