class VLC: def __init__(self): self.Player = Instance('--loop') def addPlaylist(self): self.mediaList = self.Player.media_list_new() path = "/Users/avni_aaron/Desktop/Classical_music" songs = os.listdir(path) for s in songs: self.mediaList.add_media( self.Player.media_new(os.path.join(path, s))) self.listPlayer = self.Player.media_list_player_new() self.listPlayer.set_media_list(self.mediaList) def play(self): self.listPlayer.play() def next(self): self.listPlayer.next() def pause(self): self.listPlayer.pause() def previous(self): self.listPlayer.previous() def stop(self): self.listPlayer.stop() def set_volume(self, vol): self.listPlayer.audio_set_volume(vol)
def start_with_marquee(self, timeout=60): """这种方案是可以带字幕的,根据vlc自带测试源码改写""" movie = self.url # Need --sub-source=marq in order to use marquee below print(sys.argv[:]) instance = Instance(["--sub-source=marq"] + sys.argv[1:]) try: media = instance.media_new(movie) except (AttributeError, NameError) as e: sys.exit(1) player = instance.media_player_new() player.set_media(media) player.play() # Some marquee examples. Marquee requires '--sub-source marq' in the # Instance() call above, see <http://www.videolan.org/doc/play-howto/en/ch04.html> player.video_set_marquee_int(VideoMarqueeOption.Enable, 1) player.video_set_marquee_int(VideoMarqueeOption.Size, 24) # pixels player.video_set_marquee_int(VideoMarqueeOption.Position, Position.Bottom) player.video_set_marquee_int(VideoMarqueeOption.Timeout, 0) # millisec, 0==forever player.video_set_marquee_int(VideoMarqueeOption.Refresh, 1000) # millisec (or sec?) # t = '$L / $D or $P at $T' t = '%Y-%m-%d %H:%M:%S' player.video_set_marquee_string(VideoMarqueeOption.Text, str_to_bytes(t)) # Some event manager examples. Note, the callback can be any Python # callable and does not need to be decorated. Optionally, specify # any number of positional and/or keyword arguments to be passed # to the callback (in addition to the first one, an Event instance). event_manager = player.event_manager() event_manager.event_attach(EventType.MediaPlayerEndReached, end_callback) event_manager.event_attach(EventType.MediaPlayerPositionChanged, pos_callback, player) time.sleep(timeout)
def __init__(self, account, password, shuffle=False, loop=0, volume=50, muted=False, library_update=False, debug=False): self._api = Mobileclient(debug_logging=False) self._vlc = Instance() self._library_songs = None self._library_playlists = None self._queue_trackDict = [] self._queue_index = -99 # -1 = finished playing queue, -99 = empty queue, -2 = fresh start self._queue_history_backward = [] self._queue_history_forward = [] self._queue_shuffle_on = shuffle self._queue_loop_mode = loop # 0 = loop off, 1 = loop all, 2 = repeat one self._player = None self._player_state = 'stopped' # stopped, playing, or paused self._player_volume = volume self._player_volume_muted = muted self._command_dict = available_commands self._id_text = '[GooglePlayMusicPlayer] ' self._is_playing_before_pausing_for_command = False self._last_executed_command = 'stop' self._debug = debug self._api.login(account, password, Mobileclient.FROM_MAC_ADDRESS) self._library_load_data(library_update)
class audio_player: def __init__(self, mediapath = ''): self.mediapath = mediapath self.instance = Instance('--input-repeat=-1') self.player = self.instance.media_player_new() self.media = self.instance.media_new(self.mediapath) self.player.set_media(self.media) self.volume = 0 self.playing = False def load(self, mediapath): if self.mediapath != mediapath: self.mediapath = mediapath self.media = self.instance.media_new(self.mediapath) self.player.set_media(self.media) def play(self): if !self.playing: self.player.play() def pause(self): if self.playing: self.player.pause() def setvol(self, vol): if vol != self.volume: self.player.audio_set_volume(vol)
def start(self, timeout=60): """这种是最简方案,用来测试播放足够了 """ instance = Instance() player = instance.media_player_new() Media = instance.media_new(self.url) mrl = Media.get_mrl() player.set_media(Media) event_manager = player.event_manager() event_manager.event_attach(EventType.MediaPlayerOpening, self.open_callback) event_manager.event_attach(EventType.MediaPlayerPaused, self.paused_callback) event_manager.event_attach(EventType.MediaListPlayerStopped, self.media_list_stoped_callback) event_manager.event_attach(EventType.MediaParsedChanged, self.media_buffering_callback) event_manager.event_attach(EventType.MediaPlayerStopped, self.stoped_callback) event_manager.event_attach(EventType.MediaPlayerEndReached, self.end_callback) event_manager.event_attach( EventType.VlmMediaInstanceStatusPause, self.vlm_media_instance_status_pause_callback) event_manager.event_attach(EventType.VlmMediaInstanceStatusError, self.vlm_media_instance_error_callback) event_manager.event_attach(EventType.MediaPlayerPausableChanged, self.media_player_pausable_callback) event_manager.event_attach(EventType.MediaPlayerPositionChanged, self.pos_callback, player, Media) while self.start_status: player.play() # 如果是看直播这里直接写while True 即可 if player.get_state() == State.Stopped: for i in range(5): player.play() self.write_log(u"VLC播放停止了,第%d次尝试重连,总共尝试5次" % i) if player.get_state() == State.Opening or player.get_state( ) == State.Playing: break break if player.get_state() == State.Ended: for i in range(5): player.stop() self.start() self.write_log(u"VLC播放终止了,第%d次尝试重连,总共尝试5次" % i) if player.get_state() == State.Opening or player.get_state( ) == State.Playing: break break if player.get_state() == State.Error: for i in range(5): player.stop() self.start() self.write_log(u"VLC播放出错了,第%d次尝试重连,总共尝试5次" % i) if player.get_state() == State.Opening or player.get_state( ) == State.Playing: break break player.stop()
def __init__(self, mediapath = ''): self.mediapath = mediapath self.instance = Instance('--input-repeat=-1') self.player = self.instance.media_player_new() self.media = self.instance.media_new(self.mediapath) self.player.set_media(self.media) self.volume = 0 self.playing = False
def __init__(self): self._vlc_instance = Instance() self._volume = 100 self._song_list = [] self._song_finished_func = None self._song_started_func = None self._playlist_finished_func = None self._current_index = -1
def __init__(self, email, password, device_id): self.api = Mobileclient() self.vlc = Instance() self.loaded_tracks = [] self.playing = False self.thread_running = False self.player = self.vlc.media_player_new() self.track_index = -1 self.api.login(email, password, device_id)
class VLC: # Crea instancia de VLC def __init__(self): self.Player = Instance('--loop') #lo genera en modo bucle def addPlaylist( self, op ): #agrega a la lista de reproduccion dependiendo el tipo de archivo self.mediaList = self.Player.media_list_new( ) #crea lista de reproduccion vacia path = r"/home/pi/Desktop/PFE" songs = os.listdir(path) #crea lista de los archivos # for x in songs: # # print(x) for s in songs: #filtra tipo de archivo dependiendo la eleccion if op == 1: #fotos if '.jpg' in str(s) or 'png' in str(s) or 'jpeg' in str(s): self.mediaList.add_media( self.Player.media_new(os.path.join(path, s))) if op == 2: #videos if '.mp4' in str(s) or '.avi' in str(s): self.mediaList.add_media( self.Player.media_new(os.path.join(path, s))) if op == 3: #musica if '.mp3' in str(s): self.mediaList.add_media( self.Player.media_new(os.path.join(path, s))) self.listPlayer = self.Player.media_list_player_new( ) #crea lista de reproduccion vacia en la instancia de VLC self.listPlayer.set_media_list( self.mediaList ) #remplaza la lista de reproduccion de la instancia anterior con la nueva def play(self): #reproduce self.listPlayer.play() def next(self): #siguiente self.listPlayer.next() def pause(self): #pausa self.listPlayer.pause() def previous(self): #anterior self.listPlayer.previous() def stop(self): #Alto self.listPlayer.stop() def playpause(self): #itera entre reproducir y pausar if self.listPlayer.is_playing(): self.stop() else: self.play()
def start(self, timeout=60): u"""这种是最简方案,用来测试播放足够了 """ instance = Instance() player = instance.media_player_new() Media = instance.media_new(self.url) Media.get_mrl() player.set_media(Media) player.play() # 如果是看直播这里直接写while True 即可 time.sleep(timeout)
def play(self, sonido, volumen, loop=False): # HACER LOOP if self.mediaplayer: self.mediaplayer.stop() #self.vlc = vlc.MediaPlayer(self.path_sonidos+sonido) if loop: self.instance = Instance('--input-repeat=999999') else: self.instance = Instance() self.mediaplayer = self.instance.media_player_new() self.media = self.instance.media_new(self.path_sonidos + sonido) self.mediaplayer.set_media(self.media) self.set_vol(volumen) self.mediaplayer.play()
def __init__(self, file, s=turtle.Screen(), e=1, color=1): self.screen = s self.elasticity = e self.avgLine = [] self.color = color sound = AudioSegment.from_file(file, format=file[file.rfind(".") + 1:]) outPath = "read.wav" sound.export(outPath, format="wav") instance = Instance() self.mediaPlayer = instance.media_player_new() self.mediaPlayer.set_media(instance.media_new(outPath)) self.songFile = wave.open(outPath, 'r')
def __init__(self, file, s = turtle.Screen(), e = 1, color = 1): self.screen = s self.elasticity = e self.avgLine = [] self.color = color sound = AudioSegment.from_file( file, format=file[file.rfind(".")+1:]) outPath = "read.wav" sound.export(outPath, format = "wav") instance = Instance() self.mediaPlayer = instance.media_player_new() self.mediaPlayer.set_media(instance.media_new(outPath)) self.songFile = wave.open(outPath, 'r')
def start_streaming_player(port: int, file: str): cmd = [ "file://{}".format(file), "sout=#duplicate{dst=rtp{dst=127.0.0.1,port=" + str(port) + "}}", "no-sout-rtp-sap", "no-sout-standard-sap", "sout-keep" ] d("start streaming with arguments: {}".format(cmd)) vlc = VLC() media = vlc.media_new(*cmd) media.get_mrl() player = vlc.media_player_new() player.set_media(media) player.play() return player
def start(self): """ Start server process """ if MPLAYER in self.command: self.command += " -volume " + str(self.volume) current_folder = os.getcwd() if self.folder: os.chdir(self.folder) if MPD in self.command or MPLAYER in self.command: self.proxy = Popen(self.command, stdout=PIPE, stdin=PIPE, stderr=PIPE, shell=True, universal_newlines=True, bufsize=1) else: #VLC from vlc import Instance self.proxy = Instance(self.command) if self.folder: os.chdir(current_folder) return self.proxy
def start(self): """ Start server process """ if MPLAYER_NAME in self.start_command: self.start_command += " -volume " + str(self.volume) current_folder = os.getcwd() if self.folder: os.chdir(self.folder) if MPD_NAME in self.start_command or MPLAYER_NAME in self.start_command or \ SHAIRPORT_SYNC_NAME in self.start_command or RASPOTIFY_NAME in self.start_command: self.proxy = Popen(self.start_command, stdout=PIPE, stdin=PIPE, stderr=PIPE, shell=True) else: from vlc import Instance self.proxy = Instance(self.start_command) if self.folder: os.chdir(current_folder) return self.proxy
def __init__(self, numero, mqtt): self.path_sonidos = 'sonidos/' self.sonidos = [""] self.numero = numero self.mqtt = mqtt self.mqtt.client.on_message = self.on_message self.mqtt.client.subscribe("parlante" + str(numero), qos=1) self.instance = Instance() self.mediaplayer = None self.media = None self.modo = None self.sonido = None
def __init__(self, email, password, device_id): self.api = Mobileclient() self.vlc = Instance() self.loaded_tracks = [] self.playing = False self.thread_running = False self.api.login(email, password, device_id) if os.path.isfile("songs.json"): # Load from file print("Found songs data.") with open('songs.json') as input_file: self.song_library = json.load(input_file) else: self.song_library = self.api.get_all_songs() # Save to file with open('songs.json', 'w') as output_file: json.dump(self.song_library, output_file)
def start(self): # 这种是最简方案,用来测试播放足够了 instance = Instance() player = instance.media_player_new() Media = instance.media_new(self.url) Media.get_mrl() player.set_media(Media) player.play() event_manager = player.event_manager() # 播放到视频结尾时,返回end_callback()方法 # event_manager.event_attach(EventType.MediaPlayerEndReached, end_callback) # 播放进度发生改变时,继续播放视频并(在控制台)显示播放进度 event_manager.event_attach(EventType.MediaPlayerPositionChanged, pos_callback, player) # 如果是视频,会在视频的最后一个画面停止 while True: pass
class Player: def __init__(self): self.Player = Instance('--loop --no-video') self.volume = 50 self.listPlayer = None def setPlaylist(self, playlist): if self.listPlayer != None: self.listPlayer.stop() self.listPlayer.release() self.mediaList = self.Player.media_list_new() for song in playlist: self.mediaList.add_media(self.Player.media_new(song)) self.listPlayer = self.Player.media_list_player_new() self.listPlayer.set_media_list(self.mediaList) self.listPlayer.get_media_player().audio_set_volume(self.volume) def play(self, index): self.listPlayer.play_item_at_index(index) def next(self): self.listPlayer.next() def pause(self): self.listPlayer.pause() def previous(self): self.listPlayer.previous() def stop(self): self.listPlayer.stop() def setPosition(self, v): self.listPlayer.get_media_player().set_position(v) def setVolume(self, v): self.volume = int(v * 100) if self.listPlayer != None: self.listPlayer.get_media_player().audio_set_volume(self.volume) def addToQueue(self, song): self.mediaList.add_media(self.Player.media_new(song))
class testVLC: def __init__(self): self.list1 = playlist self.Player = Instance('--loop') def addPlaylist(self): self.mediaList = self.Player.media_list_new() for music in self.list1: self.mediaList.add_media(self.Player.media_new(music_dir+'/'+music)) self.listPlayer = self.Player.media_list_player_new() self.listPlayer.set_media_list(self.mediaList) def playPlaylist(self): self.listPlayer.play() def nextPlay(self): self.listPlayer.next() def pausePlaylist(self): self.listPlayer.pause() def stopPlaylist(self): self.listPlayer.stop()
def __init__(self,DEBUG = True, ACTIVE = ACTIVE): print("Loading VLC into memory") self.instance = Instance() print("Setting up Player") self.player = self.instance.media_player_new() self.ACTIVE = ACTIVE self.DEBUG = DEBUG
def __init__(self): pyspeaker.initSay() print "Init piTunes controller" self.client = soundcloud.Client(client_id='8da91e376c359e86e2ef2ea5f3008514') self.client = soundcloud.Client(client_id='8da91e376c359e86e2ef2ea5f3008514', client_secret='7b38fab0df5b9d131d388d7118c43467', username='******', password='******') self.still_running = True self.instance = Instance("") self.player = self.instance.media_player_new()
class Player(object): def __init__(self): self.vlc_instance = Instance() self.vlc_player = self.vlc_instance.media_player_new() def load_url(self, url): self.vlc_player.set_mrl(url) def unload(self): null_media = object.__new__(Media) null_media._as_parameter_ = ctypes.c_void_p(0) self.vlc_player.set_media(null_media) def _get_volume(self): return self.vlc_player.audio_get_volume() def _set_volume(self, volume): self.vlc_player.audio_set_volume(volume) volume = property(_get_volume, _set_volume) def _get_position(self): return self.vlc_player.get_time() / 1000.0 position = property(_get_position) def _get_loaded(self): return (self.vlc_player.get_state() == State.Opening or self.vlc_player.get_state() == State.Buffering or self.vlc_player.get_state() == State.Playing or self.vlc_player.get_state() == State.Paused or self.vlc_player.get_state() == State.Ended or self.vlc_player.get_state() == State.Stopped) loaded = property(_get_loaded) def _get_finished(self): return (self.vlc_player.get_state() == State.Ended or self.vlc_player.get_state() == State.Error or self.vlc_player.get_state() == State.Stopped) finished = property(_get_finished) def play(self): self.vlc_player.play() def pause(self): self.vlc_player.set_pause(True)
def make_instance(cls, verbose=False): assert isinstance(verbose, (int, bool)) args = [ '--sub-source=marq', '-V', 'caopengllayer', '--freetype-fontsize', '30', '--no-metadata-network-access', '--codec=x264,ffmpeg,videotoolbox', '--disable-screensaver', '--no-snapshot-preview', # Don't show a snapshot preview after taking it ] if verbose: args.append('--verbose={}'.format(int(verbose))) return Instance(args)
class Player(object): def __init__(self): self.vlc_instance = Instance() self.vlc_player = self.vlc_instance.media_player_new() def load_url(self, url): self.vlc_player.set_mrl(url) def unload(self): null_media = object.__new__(Media) null_media._as_parameter_ = ctypes.c_void_p(0) self.vlc_player.set_media(null_media) def _get_volume(self): return self.vlc_player.audio_get_volume() def _set_volume(self, volume): self.vlc_player.audio_set_mute(False) self.vlc_player.audio_set_volume(volume) volume = property(_get_volume, _set_volume) def _get_position(self): return self.vlc_player.get_time() / 1000.0 position = property(_get_position) def _get_loaded(self): return (self.vlc_player.get_state() == State.Opening or self.vlc_player.get_state() == State.Buffering or self.vlc_player.get_state() == State.Playing or self.vlc_player.get_state() == State.Paused or self.vlc_player.get_state() == State.Ended or self.vlc_player.get_state() == State.Stopped) loaded = property(_get_loaded) def _get_finished(self): return (self.vlc_player.get_state() == State.Ended or self.vlc_player.get_state() == State.Error or self.vlc_player.get_state() == State.Stopped) finished = property(_get_finished) def play(self): self.vlc_player.play() def pause(self): self.vlc_player.set_pause(True)
def __init__(self, args: Namespace, stream_consumer: StreamConsumer): self._observers: Set[PlayerObserver] = set() self._terminal_observers: Set[PlayerObserver] = set() self._stream_consumer = stream_consumer vlc_args = [ "--network-caching=" + str(NETWORK_CACHING_DURATION_IN_SECONDS * 1000) ] if args.verbose > 0: vlc_args.append('-' + 'v' * args.verbose) logger.debug('Init new VLC player with args %s ...', str(vlc_args)) self._vlc_instance: Instance = Instance(vlc_args) self._vlc_player: MediaPlayer = self._vlc_instance.media_player_new() logger.info('VLC player created. Player: %s', self._vlc_player) from .Track import NullTrack, TrackStatus self._null_track = NullTrack(args, self, TrackStatus.STOPPED) self._set_track(self._null_track) self._player_state = PlayerStatus.STOPPED self._update_player_state(PlayerStatus.STOPPED) self._init_track_end_callback() self._init_player_time_callback()
def start(self): """ Start server process """ if MPLAYER_NAME == self.client_name: self.start_command += " -volume " + str(self.volume) current_folder = os.getcwd() if self.folder: os.chdir(self.folder) names = [MPLAYER_NAME, SHAIRPORT_SYNC_NAME, RASPOTIFY_NAME] if MPD_NAME in self.client_name or self.client_name in names: self.proxy = Popen(self.start_command, stdout=PIPE, stdin=PIPE, stderr=PIPE, shell=True) elif VLC_NAME in self.client_name: from vlc import Instance self.proxy = Instance(self.start_command) if self.folder: os.chdir(current_folder) return self.proxy
def __init__(self, vlc: Instance, url: str): with YoutubeDL({"format": self.__ydl_format}) as ydl: info = ydl.extract_info(url, download=False) self.title = info["title"] # This means there's the video got splitted up to # video-only and audio-only if "requested_formats" in info: formats = info["requested_formats"] # TODO! maybe the order of formats matters self.video_url = formats[0]["url"] self.audio_url = formats[1]["url"] self.has_audio = False else: self.video_url = info["url"] self.thumbnail_url = info["thumbnail"] self.media = vlc.media_new(self.video_url) if not self.has_audio: self.media.slaves_add(1, 4, self.audio_url)
class VLC: def __init__(self, filename): self.Player = Instance('--fullscreen').media_player_new(filename) libvlc_set_fullscreen(self.Player, True) def loop(self): self.play() while True: start = random.randint(START, MIDDLE) end = random.randint(MIDDLE, END) self.seek(start) print(start, end) time.sleep(end - start) def play(self): self.Player.play() def seek(self, position): self.Player.set_time(position * 1000) def stop(self): self.Player.stop()
def __init__(self, **kwargs): self._length = 0 if self.instance is None: Logger.debug("SoundVLCPlayer: Creating an instance") SoundVLCPlayer.instance = Instance() super().__init__(**kwargs)
from vlc import Instance as VLC from pathlib import Path from sys import argv if len(argv) > 1: file = Path(argv[1]) if file.is_file(): cmd = [ "file://{}".format(file.absolute()), "sout=#duplicate{dst=rtp{dst=127.0.0.1,port=1234}}", "no-sout-rtp-sap", "no-sout-standard-sap", "sout-keep" ] print("start streaming with arguments: {}".format(cmd)) vlc = VLC() media = vlc.media_new(*cmd) print(media.get_mrl()) player = vlc.media_player_new() player.set_media(media) player.play()
class piTunesController: def __init__(self): pyspeaker.initSay() print "Init piTunes controller" self.client = soundcloud.Client(client_id='8da91e376c359e86e2ef2ea5f3008514') self.client = soundcloud.Client(client_id='8da91e376c359e86e2ef2ea5f3008514', client_secret='7b38fab0df5b9d131d388d7118c43467', username='******', password='******') self.still_running = True self.instance = Instance("") self.player = self.instance.media_player_new() def announce_track(self,track_request,suggested_track): username = track_request['username'] message = track_request['message'] title = suggested_track['track_details'].title description = suggested_track['track_details'].description if username: self.say("This ones going out for %s" % username) time.sleep(2) if (message and username): self.say("%s has asked me to say %s" % (username, message)) time.sleep(2) if title: self.say("Its a cheeky little number called %s" % title) time.sleep(2) self.say("Let me hear you say yo") time.sleep(2) def call_request_api(self): # return dummy request for now #request = {} #request['username'] = '******' #request['search'] = self.default_search #request['message'] = 'this one is for my mum' #print request url = "http://pitunes.herokuapp.com/api/next" resp = urllib2.urlopen(url) response_string = resp.read() print response_string request = json.loads(response_string) return request def filler_speech(self): self.say("Filler time") def play_track(self,track): try: url = track['stream_url'] print "Playing:" + url media = self.instance.media_new(url) self.player.set_media(media) self.player.play() time.sleep(5) # wait until track completes while(self.player.is_playing()): # sleep for a bit time.sleep(2) self.player.stop() except NameError: print('NameError: %s (%s vs LibVLC %s)' % (sys.exc_info()[1], __version__, libvlc_get_version())) sys.exit(1) def say(self, text): pyspeaker.say(text, "-ven+m8 -k5 -s150") time.sleep(2) def run(self): print "Starting piTunes controller" self.say("Starting piTunes controller") while(self.still_running): # get next track next_track_req = self.call_request_api() # if no track suggested if(next_track_req==None): self.filler_speech() else: # search soundcloud track=self.search_soundcloud(next_track_req['search']) if(track==None): self.filler_speech() # announce track self.announce_track(next_track_req, track) # play track self.play_track(track) # filler speak self.filler_speech() # repeat forever? def search_soundcloud(self,search): # fetch track to stream print "Searching for %s" % search self.say("Searching for %s" % search) #tracks = self.client.get('/tracks', q=search,duration={0:60000}) tracks = self.client.get('/tracks', q=search,duration={'from':0, 'to':60000}) if(tracks==None): return None total_tracks = len(tracks) print "Found %d" % total_tracks random_id = int(random.random()*total_tracks) print "Random_id:" + str(random_id) # get the tracks streaming URL track = tracks[random_id] stream_url = self.client.get(track.stream_url, allow_redirects=False) suggested_track = {} suggested_track['stream_url']=stream_url.location suggested_track['track_details'] = track print "Suggested Track" print "===============" title = suggested_track['track_details'].title description = suggested_track['track_details'].description if title: print "Title:"+title if description: print "Description:"+description return suggested_track def set_default_search(self,search): # fetch track to stream self.default_search = search
def __init__(self): self.Player = Instance('--loop')
def __init__(self, device_id): self.api = Mobileclient() self.api.logger.setLevel(logging.INFO) #print(utils.log_filepath) options = ["--aout=alsa", "-I dummy", "--fullscreen"] self.vlc = Instance(options) self.player = None self.loaded_tracks = [] self.playing = False self.repeat = Repeat.none self.random = False self.song_index = 0 self.now_playing_title = "" self.now_playing_artist = "" self.now_playing_playlist = "" # 取得したjsonの生データ self.song_library = [] self.playlist_library = [] # 整頓した楽曲ライブラリ self.songs = [] self.albums = [] self.playlists = [] self.artists = [] # play musicログイン if not os.path.exists(CREDENTIAL_FILE): self.api.perform_oauth(CREDENTIAL_FILE) self.api.oauth_login(device_id, CREDENTIAL_FILE) # 曲一覧読み込み if os.path.isfile(JSON_DIR + "songs.json"): # Load from file print("Found songs data.") with open(JSON_DIR + 'songs.json') as input_file: self.song_library = json.load(input_file) else: self.song_library = self.api.get_all_songs() # Save to file with open(JSON_DIR + 'songs.json', 'w') as output_file: json.dump(self.song_library, output_file) self.create_songs() self.create_albums() self.create_artists() # プレイリスト読み込み if os.path.isfile(JSON_DIR + "playlists.json"): # Load from file print("Found playlist data.") with open(JSON_DIR + 'playlists.json') as input_file: self.playlist_library = json.load(input_file) else: self.playlist_library = self.api.get_all_user_playlist_contents() # Save to file with open(JSON_DIR + 'playlists.json', 'w') as output_file: json.dump(self.playlist_library, output_file) #プレイリスト名編集 self.create_playlists() # 定時ライブラリ更新処理 t = threading.Timer(RELOAD_LIB_TIME, self.auto_reload) t.start()
from threading import Thread print("Determining Endpoints") #DEVICE_ID = '356a192b79' #DO NOT CHANGE THIS DEVICE_ID = 'da4b9237ba' ACTIVE = True ENDPOINT = "http://www.korestate.com/cloud/api/beta/koFuncs.php?q={target}&deviceId=%s" % DEVICE_ID REM_ENDPOINT = "http://www.korestate.com/cloud/api/beta/koReminder.php?deviceId=%s" % DEVICE_ID LANGUAGE = "en-us" kobo_voice = os.path.join(os.path.abspath(os.curdir), "kobo_voice.flac") DEBUG = False GOOGLE_SPEECH_KEY = "AIzaSyAQsZ8EA5lWYn09g09TPqVkQxIbU5QxH4I" print("Loading VLC into memory") instance = Instance() print("Setting up Player") player = instance.media_player_new() prompts = ("kobo","hobo","cobo","coco","como","comeaux","Google") stop_prompts = ("shut", "stop","quiet","don't listen") ####################################################################### ####################################################################### #######################################################################
def __init__(self): self.vlc_instance = Instance() self.vlc_player = self.vlc_instance.media_player_new()
class Processor(object): def __init__(self,DEBUG = True, ACTIVE = ACTIVE): print("Loading VLC into memory") self.instance = Instance() print("Setting up Player") self.player = self.instance.media_player_new() self.ACTIVE = ACTIVE self.DEBUG = DEBUG # print('MY SCOPE:::',vars()) def light_wrapper(func): def run_func(self,data): GPIO.output(11,True) func(self,data) GPIO.output(11,False) GPIO.cleanup return return run_func def raw_vlc_playback(self): if self.ACTIVE == False: return else: # print('PLAYING MEDIA') media = self.instance.media_new(my_file_name) self.player.set_media(media) self.player.play() return # @light_wrapper def vlc_playback(self, my_text): if self.ACTIVE == False: return else: # print("Sending to GTTS") tts = gTTS(text = my_text, lang = LANGUAGE, debug = self.DEBUG) # print("Text Processed") tts.write_to_fp() # print("ReceivED INFO PLAYING INFO FROM %s" % tts.latest_url ) media = self.instance.media_new(tts.latest_url) # print("Opening the media") self.player.set_media(media) self.player.play() return def processtime(self): date_time = time.ctime() cur_time = date_time[-13:-1].replace(":"," ") date = date_time[0:-13] return (cur_time,date) def sys_process(self,my_string): process_dict = { 'blue blue red blue' : (os._exit,0), 'red red blue red' : (lambda x :subprocess.call(['sudo','reboot']),0), 'stop listening' : (lambda x: vars().update({'ACTIVE' : False}), ''), 'start listening' : (lambda x: vars().update({'ACTIVE':True}), '') } try: prog_tup = process_dict[my_string] prog_tup[0](prog_tup[1]) except: return def task_thread(self,timing = 60): while True: time.sleep(.5) r = requests.get(REM_ENDPOINT) print(r) if len(r.content) > 0: self.vlc_playback(str(r.content)) else: pass