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)
Ejemplo n.º 2
0
    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)
Ejemplo n.º 4
0
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()
Ejemplo n.º 6
0
 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
Ejemplo n.º 7
0
 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
Ejemplo n.º 8
0
 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)
Ejemplo n.º 9
0
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()
Ejemplo n.º 10
0
 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)
Ejemplo n.º 11
0
 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()
Ejemplo n.º 12
0
    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')
Ejemplo n.º 13
0
    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')
Ejemplo n.º 14
0
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
Ejemplo n.º 15
0
    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
Ejemplo n.º 16
0
    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
Ejemplo n.º 17
0
    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
Ejemplo n.º 18
0
 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
Ejemplo n.º 20
0
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))
Ejemplo n.º 21
0
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()
Ejemplo n.º 22
0
    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
Ejemplo n.º 23
0
	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()
Ejemplo n.º 24
0
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)
Ejemplo n.º 25
0
 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)
Ejemplo n.º 26
0
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)
Ejemplo n.º 27
0
 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()
Ejemplo n.º 28
0
    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
Ejemplo n.º 29
0
    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)
Ejemplo n.º 30
0
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()
Ejemplo n.º 31
0
 def __init__(self, **kwargs):
     self._length = 0
     if self.instance is None:
         Logger.debug("SoundVLCPlayer: Creating an instance")
         SoundVLCPlayer.instance = Instance()
     super().__init__(**kwargs)
Ejemplo n.º 32
0
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()
Ejemplo n.º 33
0
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')
Ejemplo n.º 35
0
    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()
Ejemplo n.º 36
0
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")




#######################################################################
#######################################################################
#######################################################################
Ejemplo n.º 37
0
 def __init__(self):
     self.vlc_instance = Instance()
     self.vlc_player = self.vlc_instance.media_player_new()
Ejemplo n.º 38
0
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