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