class Mp3Player(): def __init__(self): Player.exec_path = '/usr/bin/mplayer' Player.introspect() self.p = Player() def playAlbum(self, filename): self.p.loadlist(filename) def pause(self): self.p.pause() def previous(self): #TODO on press allway the previous track is playerd. normaly the first press goes back #to the start of the current track # -- to archive this we should first read the current positon .. is it is > XX sec we seek to 0 if below we go to previous track self.p.pt_step(-1) def next(self): self.p.pt_step(1)
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 camlapse(object):
def __init__(self, pf): # inits with a file name, if it exists, loads the project, else makes a new one
pDir = os.path.dirname(os.path.realpath(__file__))+'/'+pf
subprocess.call("killall PTPCamera", shell=True)
self.player = Player()
self.pname = pf
self.WEEK_FPH = [1,24,60,120,360,720,1440,2880,5760,11520,23040,46080,86400,86400]
self.lastFrame = datetime.now()
self.spf = 1
self.fph = 1
self.videoSpeed = 1.0
self.currentVideoSpeed = 0.009
if os.path.isdir(pDir):
print "Loading project : %s" % (pf)
self.loadProject(pf)
else:
print "New project : %s" % (pf)
self.newProject(pf)
#---------------------------------------------------------------------------
# Saving and loading
#---------------------------------------------------------------------------
def newProject(self, pf):
# create project folder and support subfolders
self.projectDir = os.path.dirname(os.path.realpath(__file__))+'/'+pf
self.pictureDir = self.projectDir+'/'+'pictures'
self.videoDir = self.projectDir+'/'+'videos'
self.tmpDir = self.projectDir+'/'+'tmp'
cmd = 'mkdir ' + self.projectDir
subprocess.call(cmd, shell=True)
cmd = 'mkdir ' + self.pictureDir
subprocess.call(cmd, shell=True)
cmd = 'mkdir ' + self.videoDir
subprocess.call(cmd, shell=True)
cmd = 'mkdir ' + self.tmpDir
subprocess.call(cmd, shell=True)
self.frameIndex = 0
self.startTime = datetime.now()
self.newXML()
# do enough to have the first video
self.doLapse()
self.doLapse()
self.doLapse()
# begin video playback
self.startVideoPlayback()
def loadProject(self, pf):
self.projectDir = pf
self.pname = pf
self.pictureDir = self.projectDir+'/'+'pictures'
self.videoDir = self.projectDir+'/'+'videos'
self.tmpDir = self.projectDir+'/'+'tmp'
self.loadXML()
path, dirs, files = os.walk(self.pictureDir).next()
self.frameIndex = len(files) + 1
# begin video playback
self.startVideoPlayback()
def saveVideo(self, saveFolder):
return True # create a copy of the video file to a specific directory
#---------------------------------------------------------------------------
# File Management
#---------------------------------------------------------------------------
def getPhotoFile(self, id):
return self.pictureDir+'/'+'%s_photo_%d.jpg' % (self.pname,id)
def getVideoFile(self):
return self.videoDir+'/'+'%s_video.mpg' % (self.pname)
def getVideoFrameFile(self):
return self.tmpDir+'/'+'%s_videoFrame.mpg' % (self.pname)
def getXMLfile(self):
return self.projectDir+'/'+'%s_data.xml' % (self.pname)
#---------------------------------------------------------------------------
# XML parts
#---------------------------------------------------------------------------
def newXML(self):
root = ET.Element("clProject")
sd = ET.SubElement(root, "time")
sd.set('startTime', self.startTime.strftime("%Y-%m-%d %H:%M:%S"))
fi = ET.SubElement(root,"stats")
fi.set('frameCount', str(self.frameIndex))
self.tree = ET.ElementTree(root)
self.tree.write(self.getXMLfile())# , pretty_print=True)
def loadXML(self):
self.tree = ET.parse(self.getXMLfile())
sd = self.tree.find('time')
self.startTime = datetime.strptime(sd.get('startTime'),"%Y-%m-%d %H:%M:%S")
def updateXML(self):
#fi = self.tree()
self.tree.write(self.getXMLfile())#, pretty_print=True)
#---------------------------------------------------------------------------
# Camera control
#---------------------------------------------------------------------------
def takePhoto(self, id):
if not os.path.isfile(self.getPhotoFile(id)):
cmd = 'gphoto2 --quiet --filename %s --capture-image-and-download' % (self.getPhotoFile(id))
subprocess.call(cmd, shell=True)
#---------------------------------------------------------------------------
# Video process
#---------------------------------------------------------------------------
def makeVideoFrame(self, id):
if os.path.isfile(self.getVideoFrameFile()):
cmd = 'rm '+ self.getVideoFrameFile()
subprocess.call(cmd, shell=True)
cmd = 'ffmpeg -loglevel panic -f image2 -i %s -r 25 %s' % (self.getPhotoFile(id), self.getVideoFrameFile())
subprocess.call(cmd, shell=True)
def addFrameToVideo(self):
if not os.path.isfile(self.getVideoFrameFile()):
cmd = 'mv %s %s' % (self.getVideoFrameFile(), self.getVideoFile()) #if no video exists create one
else:
cmd = 'cat %s >> %s' % (self.getVideoFrameFile(), self.getVideoFile())
subprocess.call(cmd, shell=True)
#---------------------------------------------------------------------------
# Video Playback
#---------------------------------------------------------------------------
def startVideoPlayback(self):
self.player.loadfile(self.getVideoFile())
print "Video File Loaded"
self.player.pause()
self.player.fullscreen = 1
self.player.loop = 0
self.updateVideo()
def updateVideo(self):
self.getPlaybackSpeed()
if self.videoSpeed > 0.01: # fast enough for mplayer to do the playback
if self.videoSpeed - self.currentVideoSpeed > 0.0001:
self.player.pause(0)
self.player.speed = self.videoSpeed
self.currentVideoSpeed = self.videoSpeed
print "Video speed updated"
else: # step the frames
self.stepVideo()
def stepVideo(self):
td = datetime.now() - self.lastFrame
if td.seconds > self.spf:
self.player.pause(0)
self.player.frame_step()
self.lastFrame = datetime.now()
def getPlaybackSpeed(self):
total = self.getWeek() # 3.5 weeks
weeks = int(total)
lrp = total - weeks
if weeks < len(self.WEEK_FPH)-1:
a = self.WEEK_FPH[weeks]
b = self.WEEK_FPH[weeks+1]
self.fph = self.lerp(a,b,lrp)
else: self.fph = self.WEEK_FPH[len(self.WEEK_FPH)-1]
self.spf = 3600/self.fph # seconds per frame
self.videoSpeed = self.fph/float(90000) # speed scaler for 25fps
def lerp(self, a, b, l):
return a+((b-a)*l)
#---------------------------------------------------------------------------
# time stuff
#---------------------------------------------------------------------------
def getWeek(self): #return interger of the week!
td = datetime.now() - self.startTime
return (td.days/7)+float(td.seconds)/604800
# number of weeks + current week progress seconds in a week 604800
#---------------------------------------------------------------------------
# Accesors
#---------------------------------------------------------------------------
def getFrameCount(self):
return self.frameIndex
def getTimeElapsed(self):
return True # calculate and return months/days h:m:s elapsed
def printStartTime(self):
print self.startTime
#---------------------------------------------------------------------------
# Modifiers
#---------------------------------------------------------------------------
#---------------------------------------------------------------------------
# main Loops
#---------------------------------------------------------------------------
def main(self):
while True:
self.doLapse()
self.updateVideo()
def doLapse(self):
self.takePhoto(self.frameIndex)
self.makeVideoFrame(self.frameIndex)
self.addFrameToVideo()
self.frameIndex += 1
newFile.close();
# criação de componentes
player = Player();
player.volume = 30;
gerarPlaylist();
player.loadlist("novaPlaylist.txt");
player.volume = 30;
botao1 = Button(11);
botao2 = Button(12);
botao3 = Button(13);
led1 = LED(21);
led3 = LED(23);
lcd = Adafruit_CharLCD(2, 3, 4, 5, 6, 7, 16, 2);
player.pause()
led1.blink()
botao2.when_pressed = tocarPausarMusica;
botao3.when_held = acelerarMusica;
botao3.when_released = avancarMusica;
botao1.when_pressed = voltarFaixa;
inicio = 0;
fim = 16;
# loop infinito
while True:
exibirFaixa()
sleep(0.5);
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()
def main():
try:
print("Selecting stream...")
sys.stdout.flush()
if os.path.isfile(alt_music_list_path):
alt_music_list_file = open(alt_music_list_path, 'r')
alt_music_list = [f.strip() for f in alt_music_list_file.readlines()]
print("Alternative list available")
sys.stdout.flush()
else:
alt_music_list = []
if store in alt_music_list:
CODE = 'f6403f66f656451f8fcbf4b4fe881d9b'
else:
CODE = '79c6519c9d1b46fc8d6d341d92f4eb4d'
CURL = commands.getoutput("curl -s 'https://api.rebrandly.com/v1/links/%s' -H 'apikey: 77a44fcac24946679e800fadc4f84958'" % CODE)
JSON = json.loads(CURL)
STREAM = JSON["destination"]
print("Checking stream...")
sys.stdout.flush()
if int(urllib.urlopen(STREAM).getcode()) != 200:
raise Exception("Stream not available. Restarting")
print("Starting player...")
sys.stdout.flush()
player = Player(args=('-ao alsa:device=hw=1.0'))
player.loadfile(STREAM)
print("Playing %s" % STREAM)
sys.stdout.flush()
print("Checking for announcements...")
sys.stdout.flush()
announcements = []
if os.path.exists(announcements_lang_path):
announcements = [os.path.join(announcements_lang_path, f) for f in os.listdir(announcements_lang_path) if not f.startswith('.') and os.path.isfile(os.path.join(announcements_lang_path, f))]
# announcements_date_file = "%s.mp3" % datetime.today().strftime('%Y-%m-%d')
# if country == 'sweden' and os.path.exists(announcements_date_path) and os.path.isfile(os.path.join(announcements_date_path, announcements_date_file)):
# announcements.append(os.path.join(announcements_date_path, announcements_date_file))
if announcements:
print("Announcements found for %s" % country)
sys.stdout.flush()
print("Waiting for cache. Sleeping for 2 mins")
sys.stdout.flush()
sleep(120)
while True:
for announce in announcements:
for n in range(GAP):
if not player.is_alive():
raise Exception("Player not playing. Restarting")
if player.filename is None:
raise Exception("No internet connected. Restarting")
sleep(1)
player.pause()
player_announce = Player(announce)
sleep(1)
duration = int(math.ceil(player_announce.length))
if (duration > 30):
duration -= 27
else:
duration -= 1
sleep(duration)
player_announce.quit()
player.pause()
else:
print("No announcements found for %s" % country)
sys.stdout.flush()
print("Waiting for cache. Sleeping for 2 mins")
sys.stdout.flush()
sleep(120)
while True:
if not player.is_alive():
raise Exception("Player not playing. Restarting")
if player.filename is None:
raise Exception("No internet connected. Restarting")
sleep(1)
except Exception as e:
try:
player.quit()
except:
pass
print(e)
sys.stdout.flush()
main()
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
class MediaPlayer(threading.Thread):
def __init__(self, mqttbroker, settings):
threading.Thread.__init__(self)
self.settings = settings
self.player = False
self.effect = False
self.CurrentStation = ""
self.CurrentStationNo = -1
self.CurrentURL = ""
self.stopping = False
self.message = ""
self.mqttbroker = mqttbroker
self.increasingvolume = -1
self.alarmThread = None
self.playerrestarting = False
def playerActive(self):
# True if playing or mid restart
return self.player!=False or self.playerrestarting
def playerPaused(self):
if self.player:
return self.player.paused
else:
return True # not running actually!
def playerActiveStation(self):
if self.player:
return self.CurrentStation
else:
return "None"
def playerActiveStationNo(self):
if self.player:
return self.CurrentStationNo
else:
return -1
def soundAlarm(self, alarmThread, Station = -1, StartVolume = -1):
# STation = Station Number
# StartVolume = Increasing volume from this level
log.info("Playing alarm")
self.alarmThread = alarmThread
self.increasingvolume = StartVolume
if (StartVolume != -1):
self.settings.setVolume(StartVolume)
self.playStation(Station)
log.debug("Alarm process opened")
# Wait a few seconds and see if the mplayer instance is still running
time.sleep(self.settings.getInt('radio_delay'))
if alarmThread.isSnoozing() or alarmThread.getNextAlarm() is None:
# We've snoozed or cancelled the alarm, so no need to check for player
log.debug("Media player senses alarm already cancelled/snoozed, so not checking for mplayer instance")
return
# Fetch the number of mplayer processes running
processes = subprocess.Popen('ps aux | grep mplayer | egrep -v "grep" | wc -l',
stdout=subprocess.PIPE,
shell=True
)
num = int(processes.stdout.read())
if num < 2 and self.player is not False:
log.error("Could not find mplayer instance, playing panic alarm")
self.stopPlayer()
time.sleep(2)
self.playMedia(PANIC_ALARM,0)
def playStation(self,station=-1):
if station==-1:
station = self.settings.getInt('station')
try:
stationinfo = self.settings.getStationInfo(station)
except:
log.debug("invalid station no '%s'", str(station))
stationinfo = None
if (stationinfo != None):
# Only change if its differant URL
if (self.CurrentURL != stationinfo['url']):
log.info("Playing station %s", stationinfo['name'])
log.debug("Playing URL %s", stationinfo['url'])
self.player = Player() # did have "-cache 2048"
self.player.loadlist(stationinfo['url'])
self.player.loop = 0
self.CurrentStation = stationinfo['name']
self.CurrentStationNo = station
self.CurrentURL = stationinfo['url']
else:
log.info("Already Playing %s", stationinfo['name'])
if (self.mqttbroker != None):
self.mqttbroker.publish("radio/station",self.CurrentStation)
self.mqttbroker.publish("radio/stationno",str(self.CurrentStationNo))
self.mqttbroker.publish("radio/state","ON")
self.mqttbroker.publish("radio/mute","OFF")
def playStationURL(self,stationName, StationURL, StationNo = -1):
log.info("Playing station %s", stationName)
log.debug("Playing URL %s", StationURL)
self.player = Player("-cache 320") # did have "-cache 2048"
self.player.loadlist(StationURL)
self.player.loop = 0
self.CurrentStation = stationName
self.CurrentStationNo = StationNo
self.CurrentURL = StationURL
if (self.mqttbroker != None):
self.mqttbroker.publish("radio/station",self.CurrentStation)
self.mqttbroker.publish("radio/stationno",str(StationNo))
self.mqttbroker.publish("radio/state","ON")
self.mqttbroker.publish("radio/mute","OFF")
def playMedia(self,file,loop=-1):
log.info("Playing file %s", file)
self.player = Player()
self.player.loadfile(file)
self.player.loop = loop
self.CurrentStation = file
self.CurrentStationNo = -1
self.CurrentURL = file
if (self.mqttbroker != None):
self.mqttbroker.publish("radio/station",self.CurrentStation)
self.mqttbroker.publish("radio/stationno",str(self.CurrentStationNo))
self.mqttbroker.publish("radio/state","ON")
self.mqttbroker.publish("radio/mute","OFF")
# Play some speech. None-blocking equivalent of playSpeech, which also pays attention to sfx_enabled setting
def playVoice(self,text):
if (self.settings.get('sfx_enabled')==0) or (self.settings.getIntOrSet('quiet_reboot') == 1):
# We've got sound effects disabled, so skip
log.info("Sound effects disabled, not playing voice")
return
path = self.settings.get("tts_path");
log.info("Playing voice: '%s' through `%s`" % (text,path))
if path == "pico2wave":
play = subprocess.Popen('pico2wave -l en-GB -w /tmp/texttosay.wav "%s" && aplay -q /tmp/texttosay.wav' % (text), shell=True)
else:
play = subprocess.Popen('echo "%s" | %s 2>/dev/null' % (text,path), shell=True)
# Play some speech. Warning: Blocks until we're done speaking
def playSpeech(self,text):
if (self.settings.get('sfx_enabled')==0) or (self.settings.getIntOrSet('quiet_reboot') == 1):
# We've got sound effects disabled, so skip
log.info("Sound effects disabled, not playing voice")
return
path = self.settings.get("tts_path");
log.info("Playing speech: '%s' through `%s`" % (text,path))
if path == "pico2wave":
play = subprocess.Popen('pico2wave -l en-GB -w /tmp/texttosay.wav "%s" && aplay -q /tmp/texttosay.wav' % (text), shell=True)
else:
play = subprocess.Popen('echo "%s" | %s 2>/dev/null' % (text,path), shell=True)
play.wait()
def stopPlayer(self):
if self.player:
self.player.quit()
self.player = False
self.CurrentURL = ""
self.CurrentStationNo = -1
self.CurrentStation = "N/A"
log.info("Player process terminated")
if (self.mqttbroker != None):
self.mqttbroker.publish("radio/station",self.CurrentStation)
self.mqttbroker.publish("radio/stationno",str(self.CurrentStationNo))
self.mqttbroker.publish("radio/state","OFF")
self.mqttbroker.publish("radio/mute","OFF")
def pausePlayer(self):
if self.player:
self.player.pause()
log.info("Player process paused/unpaused")
if (self.mqttbroker != None):
self.mqttbroker.publish("radio/state","ON")
self.mqttbroker.publish("radio/mute","ON")
return self.player.paused
else:
return True # not running actually!
def restartPlayer(self):
self.playerrestarting = True
CurrentURL = self.CurrentURL
CurrentStation = self.CurrentStation
CurrentStationNo = self.CurrentStationNo
log.info("Player Restarting")
self.stopPlayer()
time.sleep(2)
self.playerrestarting = False
self.playStationURL(CurrentStation, CurrentURL, CurrentStationNo)
def publish(self):
self.mqttbroker.publish("radio/volumepercent", self.settings.getInt("volumepercent"))
self.mqttbroker.publish("radio/station",self.CurrentStation)
self.mqttbroker.publish("radio/stationno",str(self.CurrentStationNo))
if self.player:
self.mqttbroker.publish("radio/state","ON")
else:
self.mqttbroker.publish("radio/state","OFF")
def on_message(self, topic ,payload):
method = topic[0:topic.find("/")] # before first "/"
item = topic[topic.rfind("/")+1:] # after last "/"
log.debug("radio method='%s', item='%s'", method, item)
done = False
try:
if (method == "radio"):
if item == "state":
if (payload.upper() == "ON"):
self.playStation(-1)
elif (payload.upper() == "OFF"):
self.stopPlayer()
else:
log.info("Invalid payload state '%s' [ON/OFF]", payload)
done = True
elif item == "stationno":
try:
stationno = int(payload)
self.playStation(stationno)
except ValueError:
log.warn("Could not decode %s as station no", payload)
done = True
elif (item == "volumepercent"):
try:
self.settings.setVolume(int(payload))
except ValueError:
log.warn("Could not decode %s as volume percent", payload)
done = True
except Exception as e:
log.debug("on_message Error: %s" , e)
return done
def run(self):
self.SleepTime = float(0.1)
lastplayerpos = 1 # media player position
NoneCount = 0
checkmessage = 50
lastmediatitle = ""
if (self.mqttbroker != None):
self.mqttbroker.set_radio(self)
self.publish()
log.info("Player thread started")
while(not self.stopping):
time.sleep(self.SleepTime)
try:
checkmessage -= 1
if (checkmessage <= 0):
checkmessage = 25
if self.playerActive(): # self.menu.backgroundRadioActive():
checkmessage = 10
try:
currentplayerpos = self.player.stream_pos
if (currentplayerpos > lastplayerpos) and (currentplayerpos != None):
self.message = ", Radio Playing"
NoneCount = 0
elif (currentplayerpos == None) or (lastplayerpos == -1):
log.info("last %s, current pos %s",lastplayerpos, currentplayerpos) #, self.media.player.stream_length)
self.message = ", Radio Buffering"
if (lastplayerpos == 0) and (currentplayerpos == None):
NoneCount += 1
else:
self.message = ", Radio Paused"
log.info("last %s, current pos %s ",lastplayerpos, currentplayerpos) #, self.media.player.stream_length)
if self.playerPaused() == False:
NoneCount += 1
lastplayerpos = currentplayerpos
try:
if lastmediatitle != (self.player.media_title):
log.info('media_title "%s" was "%s"', self.player.media_title, lastmediatitle)
lastmediatitle = str(self.player.media_title)
except:
#log.info("no media title")
lastmediatitle = ""
try:
metadata = self.player.metadata
for item in metadata:
log.info("metadata %s", item)
except:
#log.debug("no metadata, %s", metadata)
metadata = ""
try:
log.info("metadata %s", self.player.metadata[0])
except:
metadata = ""
except Exception as e: # stream not valid I guess
log.error("Error: %s" , e)
self.message = ", Radio Erroring"
NoneCount += 1
#~ lastplayerpos = currentplayerpos
if (NoneCount > 20): # or (currentplayerpos == None):
log.info("Player may be stuck, restarting")
NoneCount = 0
self.restartPlayer()
# DO we need to increase the volume?
if (self.increasingvolume != -1):
# if we have something to play increase volume
if currentplayerpos != None:
self.increasingvolume += 2
if self.increasingvolume >= self.alarmThread.alarmVolume: #settings.getInt('volume'):
#self.settings.setVolume(self.settings.getInt('volume'))
self.settings.setVolume(self.alarmThread.alarmVolume)
self.increasingvolume = -1 # At required volume
log.info("Reached alarm volume level")
else:
self.settings.setVolume(self.increasingvolume)
#try:
# metadata = self.player.metadata or {}
# log.info("Track %s", metadata.get('track', ''))
# log.info("Comment %s", metadata.get('comment', ''))
# log.info("artist %s", metadata.get('artist', ''))
# log.info("album %s", metadata.get('album', ''))
#except Exception as e: # stream not valid I guess
# log.error("metadata error: %s" , e)
else:
self.message = ""
except:
log.exception("Error in Media loop")
self.stopping = True
self.message = ", Errored"
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
