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)
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_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)
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(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()
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))
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 __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 __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(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 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, 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 Player(object):
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()
def auto_reload(self):
while True:
if not self.playing:
break
time.sleep(60)
self.reload_library()
print("[ music list auto reloaded ]")
t = threading.Timer(RELOAD_LIB_TIME, self.auto_reload)
t.start()
def reload_library(self):
# 曲一覧読み込み
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()
# プレイリスト読み込み
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()
def create_songs(self):
self.songs = []
# 曲名編集
for index, song in enumerate(self.song_library):
self.songs.append({})
self.songs[index].update({"original_name": song['title']})
self.songs[index].update(
{"name": cir.convert_into_romaji(song['title'])})
self.songs[index].update({"artist": song['artist']})
self.songs[index].update({"trackId": song['id']})
self.songs[index].update({"source": 1})
#print(self.songs[index])
#sleep(0.1)
print("[ create_songs finished ]")
def create_playlists(self):
self.playlists = []
#プレイリスト名編集
for index, playlist in enumerate(self.playlist_library):
self.playlists.append({})
self.playlists[index].update({"original_name": playlist['name']})
self.playlists[index].update(
{"name": cir.convert_into_romaji(playlist['name'])})
self.playlists[index].update({"tracks": playlist['tracks']})
print(self.playlists[index]['name'])
print("[ create_playlists finished ]")
def create_albums(self):
self.albums = []
# アルバムリスト作成
for song in self.song_library:
album_found = False
track = {}
for index, album in enumerate(self.albums):
# アルバムがすでに登録されていた場合
if album['original_name'] == song['album']:
album_found = True
track.update({"trackId": song['id']})
track.update({"source": 1})
track.update({"trackNumber": song['trackNumber']})
self.albums[index]['tracks'].append(track)
#print(self.albums[index])
break
if album_found:
continue
#新規アルバム作成
albums_len = len(self.albums)
self.albums.append({})
self.albums[albums_len].update({"original_name": song['album']})
self.albums[albums_len].update(
{"name": cir.convert_into_romaji(song['album'])})
track.update({"trackId": song['id']})
track.update({"source": 1})
track.update({"trackNumber": song['trackNumber']})
self.albums[albums_len].update({"tracks": [track]})
#print(self.albums[albums_len])
# tracknumberでソート
for album in self.albums:
album['tracks'] = sorted(album['tracks'],
key=lambda x: x['trackNumber'])
print(album["name"])
print("[ create_albums finished ]")
def create_artists(self):
self.artists = []
# アーティストリスト作成
for song in self.song_library:
artist_found = False
track = {}
for index, artist in enumerate(self.artists):
# アーティストがすでに登録されていた場合
if artist['original_name'] == song['artist']:
artist_found = True
track.update({"trackId": song['id']})
track.update({"source": 1})
track.update({"trackNumber": song['trackNumber']})
self.artists[index]['tracks'].append(track)
break
if artist_found:
continue
#新規アルバム作成
artists_len = len(self.artists)
self.artists.append({})
self.artists[artists_len].update({"original_name": song['artist']})
self.artists[artists_len].update(
{"name": cir.convert_into_romaji(song['artist'])})
track.update({"trackId": song['id']})
track.update({"source": 1})
track.update({"trackNumber": song['trackNumber']})
self.artists[artists_len].update({"tracks": [track]})
print(self.artists[artists_len]["name"])
print("[ create_artists finished ]")
def load_playlist(self, name):
name = name.strip().lower()
print("Looking for...", name)
top_diff = 0.0
top_playlist = {}
# 検索
for playlist_dict in self.playlists:
playlist_name = playlist_dict['name'].strip().lower()
diff = difflib.SequenceMatcher(None, playlist_name, name).ratio()
if diff > top_diff:
print("diff match...", playlist_dict['name'], ":", diff)
top_playlist = playlist_dict
top_diff = diff
else:
pass
#print("Found...", playlist_dict['name'])
# 一番マッチしたものを返す
if top_diff > DIFF_ARGS:
self.loaded_tracks = []
print(top_diff)
print("Found match...", top_playlist['name'])
for track_dict in top_playlist['tracks']:
self.loaded_tracks.append(track_dict)
self.now_playing_playlist = top_playlist['original_name']
return top_playlist['original_name']
else:
return None
def load_song(self, name):
name = name.strip().lower()
print("Looking for...", name)
top_diff = 0.0
top_song = {}
for song_dict in self.songs:
song_name = song_dict['name'].strip().lower()
diff = difflib.SequenceMatcher(None, song_name, name).ratio()
#print(diff)
if diff > top_diff:
print("diff match...", song_dict['name'], ":", diff)
top_song = song_dict
top_diff = diff
else:
pass
#print("Found...", song_dict['name'])
# 一番マッチしたものを返す
if top_diff > DIFF_ARGS:
self.loaded_tracks = []
print(top_diff)
print("Found match...", top_song['name'])
self.loaded_tracks.append(top_song)
self.now_playing_playlist = ""
return top_song['original_name']
else:
return None
def load_album(self, name):
name = name.strip().lower()
print("Looking for...", name)
top_diff = 0.0
top_album = {}
for album_dict in self.albums:
album_name = album_dict['name'].strip().lower()
diff = difflib.SequenceMatcher(None, album_name, name).ratio()
#print(diff)
if diff > top_diff:
print("diff match...", album_dict['name'], ":", diff)
top_album = album_dict
top_diff = diff
else:
pass
#print("Found...", album_dict['name'])
# 一番マッチしたものを返す
if top_diff > DIFF_ARGS:
self.loaded_tracks = []
print(top_diff)
print("Found match...", top_album['name'])
for track_dict in top_album['tracks']:
self.loaded_tracks.append(track_dict)
self.now_playing_playlist = top_album['original_name']
return top_album['original_name']
else:
return None
def load_artist(self, name):
name = name.strip().lower()
print("Looking for...", name)
top_diff = 0.0
top_artist = {}
for artist_dict in self.artists:
artist_name = artist_dict['name'].strip().lower()
diff = difflib.SequenceMatcher(None, artist_name, name).ratio()
#print(diff)
if diff > top_diff:
print("diff match...", artist_dict['name'], ":", diff)
top_artist = artist_dict
top_diff = diff
else:
pass
# 一番マッチしたものを返す
if top_diff > DIFF_ARGS:
self.loaded_tracks = []
print(top_diff)
print("Found match...", top_artist['name'])
for track_dict in top_artist['tracks']:
self.loaded_tracks.append(track_dict)
self.now_playing_playlist = top_artist['original_name']
return top_artist['original_name']
else:
return None
def load_cloud(self, name, isArtist=True, isSong=True, isAlbum=True):
search = self.api.search(name)
# アーティストのトップ曲を流す
if search["artist_hits"] and isArtist:
for index in range(len(search["artist_hits"])):
artist_id = search["artist_hits"][index]["artist"]["artistId"]
artist = self.api.get_artist_info(artist_id,
max_top_tracks=MAX_TRACK,
include_albums=False,
max_rel_artist=0)
if "topTracks" in artist.keys():
break
if "topTracks" in artist.keys():
self.loaded_tracks = []
for track_dict in artist["topTracks"]:
track_dict.update({"track": track_dict})
track_dict.update({"trackId": track_dict["storeId"]})
track_dict.update({"source": "2"})
self.loaded_tracks.append(track_dict)
self.now_playing_playlist = ""
return artist["name"]
# 単曲を流す（複数にしたほうがいいかも）
elif search["song_hits"] and isSong:
self.loaded_tracks = []
for index, track_dict in enumerate(search["song_hits"]):
if index >= MAX_TRACK: break
track_dict.update({"trackId": track_dict["track"]["storeId"]})
track_dict.update({"source": "2"})
self.loaded_tracks.append(track_dict)
self.now_playing_playlist = ""
return self.loaded_tracks[0]["track"]["title"]
# アルバムを流す（正確さに欠ける）
elif search["album_hits"] and isAlbum:
album_id = search["album_hits"][0]["album"]["albumId"]
album = self.api.get_album_info(album_id)
self.loaded_tracks = []
for track_dict in album["tracks"]:
track_dict.update({"track": track_dict})
track_dict.update({"trackId": track_dict["storeId"]})
track_dict.update({"source": "2"})
self.loaded_tracks.append(track_dict)
self.now_playing_playlist = album["name"]
return album["name"]
# ステーション（ここまで回ってこない気が・・・）
elif search["station_hits"]:
pass
return None
def end_callback(self, event, track_index):
# ランダム再生時処理
if self.random:
self.song_index = random.randint(0, len(self.loaded_tracks) - 1)
self.play_song(self.loaded_tracks[self.song_index])
event_manager = self.player.event_manager()
event_manager.event_attach(EventType.MediaPlayerEndReached,
self.end_callback, self.song_index + 1)
return
# 一曲リピート
if self.repeat == Repeat.song:
self.play_song(self.loaded_tracks[track_index - 1])
event_manager = self.player.event_manager()
event_manager.event_attach(EventType.MediaPlayerEndReached,
self.end_callback, track_index)
return
# 通常再生・プレイリストリピート
if track_index < len(self.loaded_tracks):
self.song_index = track_index
self.play_song(self.loaded_tracks[track_index])
event_manager = self.player.event_manager()
event_manager.event_attach(EventType.MediaPlayerEndReached,
self.end_callback, track_index + 1)
else:
if self.repeat == Repeat.playlist:
self.start_playlist()
else:
self.playing = False
self.song_index = 0
def start_playlist(self):
if len(self.loaded_tracks) > 0:
# ランダム再生時処理
if self.random:
self.song_index = random.randint(0,
len(self.loaded_tracks) - 1)
else:
# 通常再生
self.song_index = 0
self.play_song(self.loaded_tracks[self.song_index])
event_manager = self.player.event_manager()
event_manager.event_attach(EventType.MediaPlayerEndReached,
self.end_callback, self.song_index + 1)
return True
return False
def play_song(self, song_dict):
stream_url = self.api.get_stream_url(song_dict['trackId'])
self.player = self.vlc.media_player_new()
media = self.vlc.media_new(stream_url)
self.player.set_media(media)
self.player.play()
self.playing = True
if (song_dict['source'] == '2'):
self.now_playing_artist, self.now_playing_title = self.get_song_details(
song_dict)
else:
self.now_playing_artist, self.now_playing_title = self.get_local_song_details(
song_dict['trackId'])
print("Playing...", self.now_playing_artist, " - ",
self.now_playing_title)
def stop(self):
if self.player != None:
self.player.stop()
self.player = None
self.playing = False
self.repeat = Repeat.none
self.random = False
self.song_index = 0
self.now_playing_title = ""
self.now_playing_artist = ""
def pause(self):
if self.player == None:
return False
if self.playing == True:
self.player.set_pause(1)
self.playing = False
return True
return False
def resume(self):
if self.player == None:
return False
if self.playing == False:
self.player.set_pause(0)
self.playing = True
return True
return False
def next(self):
if self.player == None:
return False
# ランダム
if self.random:
self.song_index = random.randint(0, len(self.loaded_tracks) - 1)
self.player.stop()
self.play_song(self.loaded_tracks[self.song_index])
event_manager = self.player.event_manager()
event_manager.event_detach(EventType.MediaPlayerEndReached)
event_manager.event_attach(EventType.MediaPlayerEndReached,
self.end_callback, self.song_index + 1)
return True
# 通常
if self.song_index + 1 < len(self.loaded_tracks):
self.song_index += 1
self.player.stop()
self.play_song(self.loaded_tracks[self.song_index])
event_manager = self.player.event_manager()
event_manager.event_detach(EventType.MediaPlayerEndReached)
event_manager.event_attach(EventType.MediaPlayerEndReached,
self.end_callback, self.song_index + 1)
return True
else:
if self.repeat == Repeat.playlist:
self.start_playlist()
return True
return False
def prev(self):
if self.player == None:
return False
if self.song_index - 1 <= 0:
self.song_index -= 1
self.player.stop()
self.play_song(self.loaded_tracks[self.song_index])
event_manager = self.player.event_manager()
event_manager.event_detach(EventType.MediaPlayerEndReached)
event_manager.event_attach(EventType.MediaPlayerEndReached,
self.end_callback, self.song_index + 1)
return True
return False
def get_local_song_details(self, track_id):
for song_dict in self.song_library:
if track_id == song_dict['id']:
return song_dict['artist'], song_dict['title']
def get_song_details(self, song_dict):
return song_dict['track']['albumArtist'], song_dict['track']['title']
def set_volume(self, volume):
if self.player:
self.player.audio_set_volume(volume)
class Player(object):
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)
def load_song(self, name):
name = name.strip().lower()
print("Looking for song: ", name)
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)
for song_dict in self.song_library:
song_name = song_dict['title'].strip().lower()
if (song_name == name) or (name in song_name):
print("Found match: ", song_dict['title'])
self.loaded_tracks.append(song_dict)
return song_dict['title']
else:
print("Song not found :(")
return None
def load_playlist(self, name):
name = name.strip().lower()
print("Looking for playlist: ", name)
if os.path.isfile("playlists.json"):
# Load from file
print("Found playlist data.")
with open('playlists.json') as input_file:
self.playlists = json.load(input_file)
else:
self.playlists = self.api.get_all_user_playlist_contents()
# Save to file
with open('playlists.json', 'w') as output_file:
json.dump(self.playlists, output_file)
self.loaded_tracks = []
for playlist_dict in self.playlists:
playlist_name = playlist_dict['name'].strip().lower()
if (playlist_name == name) or (name in playlist_name):
print("Found match...", playlist_dict['name'])
for track_dict in playlist_dict['tracks']:
self.loaded_tracks.append(track_dict)
return playlist_dict['name']
else:
print("Found...", playlist_dict['name'])
return None
def end_callback(self, event, track_index):
if track_index < len(self.loaded_tracks):
self.play_song(self.loaded_tracks[track_index])
event_manager = self.player.event_manager()
event_manager.event_attach(EventType.MediaPlayerEndReached, self.end_callback, track_index + 1)
self.playing = True
else:
self.playing = False
def start_playlist(self):
if len(self.loaded_tracks) > 0:
self.track_index = 0
self.play_song(self.loaded_tracks[self.track_index])
if len(self.loaded_tracks) > 1:
event_manager = self.player.event_manager()
event_manager.event_attach(EventType.MediaPlayerEndReached, self.end_callback, 1)
def play_song(self, song_dict):
stream_url = ""
if 'trackId' in song_dict:
stream_url = self.api.get_stream_url(song_dict['trackId'])
else:
stream_url = self.api.get_stream_url(song_dict['nid'])
media = self.vlc.media_new(stream_url)
self.player.set_media(media)
self.player.play()
song_string = ""
# for playlists there are track dictionaries
if 'track' in song_dict:
song_string = song_dict['track']['artist'] + " - " + song_dict['track']['title']
else:
song_string = song_dict['artist'] + " - " + song_dict['title']
print("Playing ", song_string)
self.playing = True
def stop(self):
if self.player != None:
self.player.stop()
self.thread_running = False
self.playing = False
def toggle_pause(self):
if self.player != None:
self.player.pause()
def next(self):
if self.player != None:
if self.track_index < (len(self.loaded_tracks) - 1):
self.track_index += 1
self.play_song(self.loaded_tracks[self.track_index])
def previous(self):
if self.player != None:
if self.track_index > 0:
self.track_index -= 1
self.play_song(self.loaded_tracks[self.track_index])
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
class Player(object):
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 load_playlist(self, name):
name = name.strip().lower()
print("Looking for...", name)
if os.path.isfile("playlists.json"):
# Load from file
print("Found playlist data.")
with open('playlists.json') as input_file:
self.playlists = json.load(input_file)
else:
self.playlists = self.api.get_all_user_playlist_contents()
# Save to file
with open('playlists.json', 'w') as output_file:
json.dump(self.playlists, output_file)
self.loaded_tracks = []
for playlist_dict in self.playlists:
playlist_name = playlist_dict['name'].strip().lower()
if (playlist_name == name) or (name in playlist_name):
print("Found match...", playlist_dict['name'])
for track_dict in playlist_dict['tracks']:
self.loaded_tracks.append(track_dict)
return playlist_dict['name']
else:
print("Found...", playlist_dict['name'])
return None
def end_callback(self, event, track_index):
if track_index < len(self.loaded_tracks):
self.play_song(self.loaded_tracks[track_index])
event_manager = self.player.event_manager()
event_manager.event_attach(EventType.MediaPlayerEndReached, self.end_callback, track_index + 1)
self.playing = True
else:
self.playing = False
def start_playlist(self):
if len(self.loaded_tracks) > 0:
self.play_song(self.loaded_tracks[0])
if len(self.loaded_tracks) > 1:
event_manager = self.player.event_manager()
event_manager.event_attach(EventType.MediaPlayerEndReached, self.end_callback, 1)
def play_song(self, song_dict):
stream_url = self.api.get_stream_url(song_dict['trackId'])
self.player = self.vlc.media_player_new()
media = self.vlc.media_new(stream_url)
self.player.set_media(media)
self.player.play()
song_string = ""
if (song_dict['source'] == '2'):
song_string = self.get_song_details(song_dict)
else:
song_string = self.get_local_song_details(song_dict['trackId'])
print("Playing...",song_string)
if enable_display:
scrollphat.clear()
scrollphat.write_string(" "*5+song_string)
if not self.thread_running:
thread = Thread(target=self.scroll_string)
thread.start()
self.playing = True
def scroll_string(self):
self.thread_running = True
while self.thread_running:
scrollphat.scroll()
time.sleep(0.1)
def stop(self):
if self.player != None:
self.player.stop()
if enable_display:
scrollphat.clear()
self.thread_running = False
self.playing = False
def get_local_song_details(self, track_id):
for song_dict in self.song_library:
if track_id == song_dict['id']:
return song_dict['albumArtist']+" - "+song_dict['title']
def get_song_details(self, song_dict):
return song_dict['track']['albumArtist']+" - "+song_dict['track']['title']
class YoutubePLR:
def __init__(self):
self.Player = Instance('--loop')
def Vplayer(self, url):
url = str(url)
video = pafy.new(url)
messagebox.showinfo(
"Notice", " Please Wait.... Seeking video may take some time")
best = video.getbest()
self.media_list = self.Player.media_list_new()
self.media_player = self.Player.media_list_player_new()
self.media = self.Player.media_new(best.url)
self.media_list.add_media(self.media)
self.media_player.set_media_list(self.media_list)
self.media_player.play()
time.sleep(15)
def stopVideo(self):
#media.stop()
print("Stoping")
self.media_player.stop()
#sys.exit()
def callSearch(self):
messagebox.showinfo("Notice",
" Please Wait.... Searching may take some time.")
videoName = str(self.video_Name.get())
print(videoName)
if videoName is not None:
videosSearch = VideosSearch(str(videoName), limit=5)
for i in range(5):
self.titleList.append(
str(videosSearch.result()['result'][i]['title'][0:45]))
self.linkList.append(
videosSearch.result()['result'][i]['link'])
for i in range(5):
print(self.titleList[i], "\t\t", self.linkList[i])
#print(videosSearch.result()['result'][i]['title'][0:45])
time.sleep(5)
self.WidgetResult()
else:
print("Null Search")
def Browse(self):
download_Directory = filedialog.askdirectory(
initialdir=pathlib.Path.cwd())
self.download_Path.set(download_Directory)
def Download(self, url):
Youtube_link = str(url)
print(Youtube_link)
download_Folder = self.download_Path.get()
print(download_Folder)
if download_Folder == None or download_Folder == "":
messagebox.showwarning("Choose Location",
"Choose a valid location in browse option")
return
try:
getVideo = pafy.new(Youtube_link)
vidBest = getVideo.getbest()
print(" Downloading -----", vidBest.resolution, vidBest.extension,
" .....Please Wait ")
messagebox.showinfo(
"Notice", " Please Wait.... Downloading may take some time")
vidBest.download(download_Folder)
messagebox.showinfo("Successfully",
"Downloaded and Saved in\n" + download_Folder)
except:
print("Connection Error")
def Widgets(self):
Label(self.root,
text="Youtube Player and Downloader",
font=("Gill Sans Ultra Bold Condensed", 30),
bg="#000000",
fg="#f9540b").grid(row=1, columnspan=3, padx=18)
link_label = Label(self.root,
text="Search Video",
bg="#E8D579",
width=20)
link_label.grid(row=3, column=0, pady=10, padx=10)
linkText = Entry(self.root, width=40, textvariable=self.video_Name)
linkText.insert(END, 'attention')
linkText.grid(row=3, column=1, pady=10, padx=5)
Search_B = Button(self.root,
text="Search",
command=self.callSearch,
width=15,
bg="#05E8E0")
Search_B.grid(row=3, column=2, pady=10, padx=5)
def WidgetResult(self):
self.root.geometry("690x360")
colrLab = "#cccccc"
colrBut = "#fd9c35"
#command= lambda: self.Vplayer(self.linkList[0])
destination_label = Label(self.root,
text="Destination",
bg="#E8D579",
width=20)
destination_label.grid(row=4, column=0, pady=10, padx=10)
destiText = Entry(self.root, width=40, textvariable=self.download_Path)
destiText.insert(END, '')
destiText.grid(row=4, column=1, pady=10, padx=5)
browse_B = Button(self.root,
text="Browse",
command=self.Browse,
width=15,
bg="#05E8E0")
browse_B.grid(row=4, column=2, pady=10, padx=5)
# Search list
resultLabel_1 = Label(self.root,
text=self.titleList[0],
bg=colrLab,
width=50) #1
resultLabel_1.grid(row=5, columnspan=2, pady=5, padx=5)
Search_B_1 = Button(self.root,
text="Play",
command=lambda: self.Vplayer(self.linkList[0]),
width=10,
bg=colrBut)
Search_B_1.grid(row=5, column=2, pady=1, padx=1)
Download_B_1 = Button(self.root,
text="Download",
command=lambda: self.Download(self.linkList[0]),
width=10,
bg="#a2cf6e",
bd=1)
Download_B_1.grid(row=5, column=3, pady=3, padx=3)
resultLabel_2 = Label(self.root,
text=self.titleList[1],
bg=colrLab,
width=50) #2
resultLabel_2.grid(row=6, columnspan=2, pady=5, padx=5)
Search_B_2 = Button(self.root,
text="Play",
command=lambda: self.Vplayer(self.linkList[1]),
width=10,
bg=colrBut)
Search_B_2.grid(row=6, column=2, pady=1, padx=1)
Download_B_2 = Button(self.root,
text="Download",
command=lambda: self.Download(self.linkList[1]),
width=10,
bg="#a2cf6e",
bd=1)
Download_B_2.grid(row=6, column=3, pady=3, padx=3)
resultLabel_3 = Label(self.root,
text=self.titleList[2],
bg=colrLab,
width=50) #3
resultLabel_3.grid(row=7, columnspan=2, pady=5, padx=5)
Search_B_3 = Button(self.root,
text="Play",
command=lambda: self.Vplayer(self.linkList[2]),
width=10,
bg=colrBut)
Search_B_3.grid(row=7, column=2, pady=1, padx=1)
Download_B_3 = Button(self.root,
text="Download",
command=lambda: self.Download(self.linkList[2]),
width=10,
bg="#a2cf6e",
bd=1)
Download_B_3.grid(row=7, column=3, pady=3, padx=3)
resultLabel_4 = Label(self.root,
text=self.titleList[3],
bg=colrLab,
width=50) #4
resultLabel_4.grid(row=8, columnspan=2, pady=5, padx=5)
Search_B_4 = Button(self.root,
text="Play",
command=lambda: self.Vplayer(self.linkList[3]),
width=10,
bg=colrBut)
Search_B_4.grid(row=8, column=2, pady=1, padx=1)
Download_B_4 = Button(self.root,
text="Download",
command=lambda: self.Download(self.linkList[3]),
width=10,
bg="#a2cf6e",
bd=1)
Download_B_4.grid(row=8, column=3, pady=3, padx=3)
resultLabel_5 = Label(self.root,
text=self.titleList[4],
bg=colrLab,
width=50) #5
resultLabel_5.grid(row=9, columnspan=2, pady=5, padx=5)
Search_B_5 = Button(self.root,
text="Play",
command=lambda: self.Vplayer(self.linkList[4]),
width=10,
bg=colrBut)
Search_B_5.grid(row=9, column=2, pady=1, padx=1)
Download_B_5 = Button(self.root,
text="Download",
command=lambda: self.Download(self.linkList[4]),
width=10,
bg="#a2cf6e",
bd=1)
Download_B_5.grid(row=9, column=3, pady=3, padx=3)
Stop_B = Button(self.root,
text="Stop Video",
command=self.stopVideo,
width=20,
bg="#a2cf6e")
Stop_B.grid(row=10, column=1, pady=8, padx=3)
#Download_B=Button(self.root,text="Download",command=Download,width=20,bg="#a2cf6e",bd=1)
#Download_B.grid(row=9,column=1,pady=3,padx=3)
def Start(self):
self.root = Tk()
self.root.geometry("600x130")
#self.root.resizable(0,0)
self.root.title("Youtube Video Downloader")
self.root.config(background="#000000")
self.video_Name = StringVar()
self.download_Path = StringVar()
self.titleList = []
self.linkList = []
self.Widgets()
self.root.mainloop()
class Parlante:
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 on_message(self, client, userdata, msg):
# hay un cambio
print(str(msg.payload))
comando, modo, volumen, sonido = str(msg.payload).split(':')
self.analizar_mensaje(comando, modo, sonido, volumen)
def cambiar_era(self):
self.play("Cambio.mp3", 30)
time.sleep(3)
self.stop()
self.play(self.sonido, self.volumen, loop=True)
def analizar_mensaje(self, comando, modo, sonido, volumen):
if comando:
self.comando = comando
self.modo = modo
self.sonido = sonido
self.volumen = volumen
if comando == 'set_volume':
self.set_vol(volumen)
elif comando == 'cambio_era':
self.cambiar_era()
elif comando == 'reset':
self.stop()
self.__init__(self.numero, self.mqtt)
self.estado_inicial()
elif comando == 'loop' and modo == 'inicial':
self.stop()
self.__init__(self.numero, self.mqtt)
self.estado_inicial()
elif comando == 'stop':
self.stop()
elif comando == 'loop':
self.play(self.sonido, self.volumen, loop=True)
def set_vol(self, vol):
if self.mediaplayer:
#self.vlc.audio_set_volume(int(vol))
self.mediaplayer.audio_set_volume(50)
def stop(self):
if self.mediaplayer:
self.mediaplayer.stop()
def estado_inicial(self):
self.play("Glitch.mp3", 100, loop=True)
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()
class Player(Tk.Frame):
"""The main window has to deal with events.
"""
def __init__(self, parent, title=None):
Tk.Frame.__init__(self, parent)
self.Player = Instance('--loop')
self.parent = parent
#before new update
# q1="""SELECT `episode_table`.`episode_num`,
# `episode_table`.`episode_time`,
# `episode_table`.`episode_season`
#FROM `personal_use`.`episode_table`;"""
# results = read_query(connection, q1)
# self.episode_num=results[0][0]-1 ##subracting 1 to match array position of real episode
# self.episode_season=results[0][2]
# self.episode_time=results[0][1]
self.first_entrence = 0
self.label_arr = []
self.running = 0
self.dirname = ""
self.videos = []
self.video_len = 0
if title == None:
title = "tk_vlc"
self.parent.title(title)
# Menu Bar
# File Menu
menubar = Tk.Menu(self.parent)
self.parent.config(menu=menubar)
fileMenu = Tk.Menu(menubar)
fileMenu.add_command(label="Open", underline=0, command=self.OnOpen)
fileMenu.add_command(label="Exit", underline=1, command=self._quit)
menubar.add_cascade(label="File", menu=fileMenu)
# The second panel holds controls
self.player = None
self.videopanel = ttk.Frame(self.parent)
self.canvas = Tk.Canvas(self.videopanel).pack(fill=Tk.BOTH, expand=1)
self.videopanel.pack(fill=Tk.BOTH, expand=1)
ctrlpanel = ttk.Frame(self.parent)
pause = ttk.Button(ctrlpanel, text="Pause", command=self.OnPause)
play = ttk.Button(ctrlpanel, text="Play", command=self.OnPlay)
stop = ttk.Button(ctrlpanel, text="Stop", command=self.OnStop)
next = ttk.Button(ctrlpanel, text="Next", command=self.OnNext)
previous = ttk.Button(ctrlpanel,
text="Previous",
command=self.OnPrevious)
volume = ttk.Button(ctrlpanel, text="Volume", command=self.OnSetVolume)
pause.pack(side=Tk.LEFT)
play.pack(side=Tk.LEFT)
stop.pack(side=Tk.LEFT)
next.pack(side=Tk.LEFT)
previous.pack(side=Tk.LEFT)
volume.pack(side=Tk.LEFT)
self.volume_var = Tk.IntVar()
self.volslider = Tk.Scale(ctrlpanel,
variable=self.volume_var,
command=self.volume_sel,
from_=0,
to=100,
orient=Tk.HORIZONTAL,
length=100)
self.volslider.pack(side=Tk.LEFT)
ctrlpanel.pack(side=Tk.BOTTOM)
ctrlpanel2 = ttk.Frame(self.parent)
self.scale_var = Tk.DoubleVar()
self.timeslider_last_val = ""
self.timeslider = Tk.Scale(ctrlpanel2,
variable=self.scale_var,
command=self.scale_sel,
from_=0,
to=1000,
orient=Tk.HORIZONTAL,
length=500)
self.timeslider.pack(side=Tk.BOTTOM, fill=Tk.X, expand=1)
self.timeslider_last_update = time.time()
ctrlpanel2.pack(side=Tk.BOTTOM, fill=Tk.X)
# VLC player controls
self.Instance = vlc.Instance()
self.player = self.Instance.media_player_new()
self.timer = ttkTimer(self.OnTimer, 1.0)
self.timer.start()
self.parent.update()
def printSomething(self, txt):
# if you want the button to disappear:
# button.destroy() or button.pack_forget()
# 0 is unnecessary
if len(self.label_arr) > 0:
self.label_arr[-1].destroy()
label = Tk.Label(root, text=txt)
# this creates x as a new label to the GUI
label.pack()
self.label_arr.append(label)
def OnNext(self):
if self.episode_num < len(self.videos) - 1: ##in season
self.episode_num += 1
# q1="""TRUNCATE `personal_use`.`episode_table`;"""
# execute_query(connection, q1)
# q1="""INSERT INTO `personal_use`.`episode_table`
# (`episode_num`,
# `episode_time`,
# `episode_season`)
# VALUES
# ("""+str(self.episode_num+1)+""","""+str(self.episode_time)+""","""+str(self.episode_season)+""");"""
# execute_query(connection,q1)
q1 = """UPDATE `personal_use`.`episode_table`
SET
`episode_num`= """ + str(self.episode_num + 1) + """,
`episode_time` = """ + str(self.episode_time) + """,
`episode_season`=""" + str(self.episode_season) + """
WHERE `show_name`='""" + str(self.show_name) + """';
"""
execute_query(connection, q1)
self.Create(self.dirname, self.videos[self.episode_num])
self.OnPlay()
else: ##start new season
self.episode_season += 1
self.episode_num = 1
#q1 = """TRUNCATE `personal_use`.`episode_table`;"""
#execute_query(connection, q1)
#q1 = """INSERT INTO `personal_use`.`episode_table`
# (`episode_num`,
# `episode_time`,
# `episode_season`)
# VALUES
# (""" + str(self.episode_num) + """,""" + str(self.episode_time) + """,""" + str(
# self.episode_season) + """);"""
#execute_query(connection, q1)
q1 = """UPDATE `personal_use`.`episode_table`
SET
`episode_num`= """ + str(self.episode_num) + """,
`episode_time` = """ + str(self.episode_time) + """,
`episode_season`=""" + str(
self.episode_season) + """
WHERE `show_name`='""" + str(
self.show_name) + """';
"""
execute_query(connection, q1)
self.episode_num -= 1 ##so it will match the array
self.OnOpen()
def OnPrevious(self):
if self.episode_num > 0: ##in season
self.episode_num -= 1
#q1 = """TRUNCATE `personal_use`.`episode_table`;"""
#execute_query(connection, q1)
#q1 = """INSERT INTO `personal_use`.`episode_table`
# (`episode_num`,
# `episode_time`,
# `episode_season`)
# VALUES
# (""" + str(self.episode_num+1) + """,""" + str(self.episode_time) + """,""" + str(
# self.episode_season) + """);"""
#execute_query(connection, q1)
q1 = """UPDATE `personal_use`.`episode_table`
SET
`episode_num`= """ + str(
self.episode_num + 1) + """,
`episode_time` = """ + str(
self.episode_time) + """,
`episode_season`=""" + str(
self.episode_season) + """
WHERE `show_name`='""" + str(
self.show_name) + """';
"""
execute_query(connection, q1)
self.Create(self.dirname, self.videos[self.episode_num])
self.OnPlay()
else: ##back to previous season
self.episode_season -= 1
#self.dirname = r"C:\Users\tonyh\OneDrive\Desktop\shows and movies\shows\that 70s show\season"
#self.dirname += str(self.episode_season)
self.dirname = r"C:\Users\tonyh\OneDrive\Desktop\shows and movies\shows"
self.dirname += "\\"
self.dirname += self.show_name
self.dirname += "\\"
self.dirname += "season"
self.dirname += str(self.episode_season)
self.mediaList = self.Player.media_list_new()
self.videos = os.listdir(self.dirname)
self.episode_num = len(self.videos)
#q1 = """TRUNCATE `personal_use`.`episode_table`;"""
#execute_query(connection, q1)
#q1 = """INSERT INTO `personal_use`.`episode_table`
# (`episode_num`,
# `episode_time`,
# `episode_season`)
# VALUES
# (""" + str(self.episode_num) + """,""" + str(
# self.episode_time) + """,""" + str(
# self.episode_season) + """);"""
#execute_query(connection, q1)
q1 = """UPDATE `personal_use`.`episode_table`
SET
`episode_num`= """ + str(
self.episode_num) + """,
`episode_time` = """ + str(
self.episode_time) + """,
`episode_season`=""" + str(
self.episode_season) + """
WHERE `show_name`='""" + str(
self.show_name) + """';
"""
execute_query(connection, q1)
self.episode_num -= 1 ##so it will match the array
self.OnOpen()
def OnExit(self, evt):
"""Closes the window.
"""
self.Close()
def OnOpen(self):
"""Pop up a new dialow window to choose a file, then play the selected file.
"""
# if a file is already running, then stop it.
self.OnStop()
# Create a file dialog opened in the current home directory, where
# you can display all kind of files, having as title "Choose a file".
#p = pathlib.Path(os.path.expanduser("~"))
p = pathlib.Path(
os.path.expanduser(
r"C:\Users\tonyh\OneDrive\Desktop\shows and movies\shows\show names"
))
fullname = askopenfilename(initialdir=p,
title="choose your file",
filetypes=(("all files", "*.*"),
("mp4 files", "*.mp4")))
#if os.path.isfile(fullname):
# print(fullname)
# splt = os.path.split(fullname)
#dirname = os.path.dirname(fullname)
#new addition
filename = os.path.basename(fullname)
filename = filename[:-4] ##deletes the .txt from the name
print(filename)
#self.dirname=r"C:\Users\tonyh\OneDrive\Desktop\shows and movies\shows\that 70s show\season1"
##defining the properties of the show:
q1 = """SELECT `episode_table`.`episode_num`,
`episode_table`.`episode_time`,
`episode_table`.`episode_season`
FROM `personal_use`.`episode_table`
WHERE `episode_table`.`show_name`='""" + filename + """'"""
results = read_query(connection, q1)
self.episode_num = results[0][
0] - 1 ##subracting 1 to match array position of real episode
self.episode_season = results[0][2]
self.episode_time = results[0][1]
self.show_name = filename
##new addition
self.dirname = r"C:\Users\tonyh\OneDrive\Desktop\shows and movies\shows"
self.dirname += "\\"
self.dirname += filename
self.dirname += "\\"
self.dirname += "season"
self.dirname += str(self.episode_season)
##before updating
#self.dirname=r"C:\Users\tonyh\OneDrive\Desktop\shows and movies\shows\that 70s show\season"
#self.dirname+=str(self.episode_season)
##tony
##creating the array of episodes
self.mediaList = self.Player.media_list_new()
self.videos = os.listdir(self.dirname)
for v in self.videos:
self.mediaList.add_media(
self.Player.media_new(os.path.join(self.dirname, v)))
self.listPlayer = self.Player.media_list_player_new()
self.listPlayer.set_media_list(self.mediaList)
self.Create(self.dirname, self.videos[self.episode_num])
# Creation
#self.Media = self.Instance.media_new(str(os.path.join(dirname, filename)))
#self.player.set_media(self.Media)
# Report the title of the file chosen
# title = self.player.get_title()
# if an error was encountred while retriving the title, then use
# filename
# if title == -1:
# title = filename
# self.SetTitle("%s - tkVLCplayer" % title)
# set the window id where to render VLC's video output
##tony: you turned of this so it opens a seperate window
#if platform.system() == 'Windows':
# self.player.set_hwnd(self.GetHandle())
#else:
# self.player.set_xwindow(self.GetHandle()) # this line messes up windows
# FIXME: this should be made cross-platform
self.OnPlay()
# set the volume slider to the current volume
# self.volslider.SetValue(self.player.audio_get_volume() / 2)
self.volslider.set(self.player.audio_get_volume())
def Create(self, dirname, filename):
if self.first_entrence == 0: ##if first time then start from the time you stopped
self.Media = self.Instance.media_new(
str(os.path.join(dirname, filename)))
self.Media.add_option('start-time=' + str(self.episode_time) + '')
self.player.set_media(self.Media)
self.first_entrence += 1
else:
self.Media = self.Instance.media_new(
str(os.path.join(dirname, filename)))
self.player.set_media(self.Media)
self.video_len = VideoFileClip(str(os.path.join(dirname, filename)))
self.video_len = self.video_len.duration
self.running = 1
self.printSomething(filename)
def OnPlay(self):
"""Toggle the status to Play/Pause.
If no file is loaded, open the dialog window.
"""
# check if there is a file to play, otherwise open a
# Tk.FileDialog to select a file
if not self.player.get_media():
self.OnOpen()
else:
# Try to launch the media, if this fails display an error message
if self.player.play() == -1:
self.errorDialog("Unable to play.")
def GetHandle(self):
return self.videopanel.winfo_id()
# def OnPause(self, evt):
def OnPause(self):
"""Pause the player.
"""
self.player.pause()
def OnStop(self):
"""Stop the player.
"""
self.player.stop()
# reset the time slider
if self.first_entrence != 0:
self.timeslider.set(0)
def OnTimer(self):
"""Update the time slider according to the current movie time.
"""
if self.player == None:
return
# since the self.player.get_length can change while playing,
# re-set the timeslider to the correct range.
length = self.player.get_length()
dbl = length * 0.001
self.timeslider.config(to=dbl)
# update the time on the slider
tyme = self.player.get_time()
if tyme == -1:
tyme = 0
dbl = tyme * 0.001
if self.first_entrence != 0: ##important for starting from saved time
self.episode_time = dbl
self.timeslider_last_val = ("%.0f" % dbl) + ".0"
# don't want to programatically change slider while user is messing with it.
# wait 2 seconds after user lets go of slider
if time.time() > (self.timeslider_last_update + 2.0):
self.timeslider.set(dbl)
if self.running == 1:
if dbl > self.video_len - 1:
time.sleep(5)
if dbl > self.video_len - 1:
self.running = 0
self.player.set_time(0)
self.OnNext()
def scale_sel(self, evt):
if self.player == None:
return
nval = self.scale_var.get()
sval = str(nval)
if self.timeslider_last_val != sval:
# this is a hack. The timer updates the time slider.
# This change causes this rtn (the 'slider has changed' rtn) to be invoked.
# I can't tell the difference between when the user has manually moved the slider and when
# the timer changed the slider. But when the user moves the slider tkinter only notifies
# this rtn about once per second and when the slider has quit moving.
# Also, the tkinter notification value has no fractional seconds.
# The timer update rtn saves off the last update value (rounded to integer seconds) in timeslider_last_val
# if the notification time (sval) is the same as the last saved time timeslider_last_val then
# we know that this notification is due to the timer changing the slider.
# otherwise the notification is due to the user changing the slider.
# if the user is changing the slider then I have the timer routine wait for at least
# 2 seconds before it starts updating the slider again (so the timer doesn't start fighting with the
# user)
# selection = "Value, last = " + sval + " " + str(self.timeslider_last_val)
# print("selection= ", selection)
self.timeslider_last_update = time.time()
mval = "%.0f" % (nval * 1000)
self.player.set_time(int(mval)) # expects milliseconds
def volume_sel(self, evt):
if self.player == None:
return
volume = self.volume_var.get()
if volume > 100:
volume = 100
if self.player.audio_set_volume(volume) == -1:
self.errorDialog("Failed to set volume")
def OnToggleVolume(self, evt):
"""Mute/Unmute according to the audio button.
"""
is_mute = self.player.audio_get_mute()
self.player.audio_set_mute(not is_mute)
# update the volume slider;
# since vlc volume range is in [0, 200],
# and our volume slider has range [0, 100], just divide by 2.
self.volume_var.set(self.player.audio_get_volume())
def OnSetVolume(self):
"""Set the volume according to the volume sider.
"""
volume = self.volume_var.get()
print("volume= ", volume)
# volume = self.volslider.get() * 2
# vlc.MediaPlayer.audio_set_volume returns 0 if success, -1 otherwise
if volume > 100:
volume = 100
if self.player.audio_set_volume(volume) == -1:
self.errorDialog("Failed to set volume")
def errorDialog(self, errormessage):
"""Display a simple error dialog.
"""
edialog = Tk.tkMessageBox.showerror(self, 'Error', errormessage)
def _quit(self):
q1 = """UPDATE `personal_use`.`episode_table` SET `episode_num` = """ + str(
self.episode_num + 1) + """,`episode_time` = '""" + str(
self.episode_time) + """',`episode_season` ='""" + str(
self.episode_season) + """' WHERE
`show_name` = '""" + str(self.show_name) + """';"""
execute_query(connection, q1)
print("_quit: bye")
root = Tk_get_root()
root.quit() # stops mainloop
root.destroy() # this is necessary on Windows to prevent
# Fatal Python Error: PyEval_RestoreThread: NULL tstate
os._exit(1)
class MyMediaPlayer(object):
"""
Simple audio/video player based on VLC player.
"""
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 subscribe_song_finished(self, func, *args, **kwargs):
"""
Subscriber for when player finishes a song
"""
self._song_finished_func = functools.partial(func, *args, **kwargs)
def subscribe_playlist_finished(self, func, *args, **kwargs):
"""
Subscriber for when player finishes all songs in existing playlist
"""
self._playlist_finished_func = functools.partial(func, *args, **kwargs)
def subscribe_song_started(self, func, *args, **kwargs):
"""
Subscriber for when player finishes a song
"""
self._song_started_func = functools.partial(func, *args, **kwargs)
def _finished_song_event(self, event):
"""
Event for when a player finishes a song.
"""
config.logging.debug(f'Event from VLC player: {event}')
self._play_next()
if self._song_finished_func:
self._song_finished_func()
def _finished_playlist_event(self):
"""
Event for when a player finishes a song.
"""
config.logging.debug(f'Finished playlist event')
if self._playlist_finished_func:
self._playlist_finished_func()
def _started_song_event(self, event):
"""
Event for when a player starts a song.
"""
config.logging.debug(f'Event from VLC player: {event}')
if self._song_started_func:
self._song_started_func()
@check_song_list
def play(self, *, songs):
"""
Plays the given song list (a list of Song objects).
"""
if songs:
self._song_list.extend(songs)
# stop any current play
self.stop()
# start playing the next song (self._current_index points to that)
self._play_next()
@check_song_list
def add_to_playlist(self, *, songs):
"""
Appends a song or a list of songs to the existing playlist.
"""
if songs:
self._song_list.extend(songs)
@check_song_list
def delete_from_playlist(self, *, songs):
"""
Deletes a song or a list of songs from the existing playlist.
"""
for song in songs:
for song_player in self._song_list:
# TODO: implement a proper check (do not use ids because that's only for favorite songs)
if song == song_player:
self._song_list.remove(song_player)
break
# TODO: remove from the list. Check the id of the song to identify it
@check_media
def stop(self):
"""
Stops the player.
"""
self._player.stop()
@check_media
def pause(self):
"""
Pauses and resumes the music.
"""
self._player.pause()
@check_media
def get_time(self):
"""
Gets the elapsed time of the current song.
"""
time = self._player.get_time()
time_str = str(int(time / 60000)) + ':' + format(int((time % 60000) / 1000), '02d')
return time_str
@check_media
def set_volume(self, volume):
"""
Sets the volume of the player.
"""
if isinstance(volume, str):
volume = float(volume)
if isinstance(volume, (float, int)):
volume = int(round(volume))
self._volume = volume
self._player.audio_set_volume(volume)
@check_media
def is_playing(self):
"""
Checks if any media is playing.
"""
return self._player.get_state() == State.Playing
@check_media
def get_length(self):
"""
Gets the length of the current media playing.
"""
return self._player.get_duration()
@check_media
def get_current_song(self):
"""
Gets the info from the mp3 playing currently
"""
song = None
if self._current_index < len(self._song_list):
song = self._song_list[self._current_index]
return song
def _play_next(self):
"""
Plays the next song in the list
"""
self._current_index += 1
if len(self._song_list) > self._current_index:
self._media = self._vlc_instance.media_new(self._song_list[self._current_index].abs_path)
self._player = self._vlc_instance.media_player_new()
self._player.set_media(self._media)
self._player.event_manager().event_attach(EventType.MediaPlayerEndReached, self._finished_song_event)
self._player.event_manager().event_attach(EventType.MediaPlayerPlaying, self._started_song_event)
self._player.audio_set_volume(self._volume)
self._player.play()
elif len(self._song_list) == self._current_index:
self._finished_playlist_event()
config.logger.debug('Finished playing the list of songs')
else:
config.logger.error(
f'Current playing index is {self._current_index} and the length of the list is {len(self._song_list)}')
class PiecesPlayer(QWidget):
""" main widget of application (used as widget inside PiecesMainWindow) """
def __init__(self, parent):
""" standard constructor: set up class variables, ui elements
and layout """
# TODO: split current piece info into separate lineedits for title, album name and length
# TODO: make time changeable by clicking next to the slider (not only
# by dragging the slider)
# TODO: add "about" action to open info dialog in new "help" menu
# TODO: add option to loop current piece (?)
# TODO: more documentation
# TODO: add some "whole piece time remaining" indicator? (complicated)
# TODO: implement a playlist of pieces that can be edited and enable
# going back to the previous piece (also un- and re-shuffling?)
# TODO: implement debug dialog as menu action (if needed)
if not isinstance(parent, PiecesMainWindow):
raise ValueError('Parent widget must be a PiecesMainWindow')
super(PiecesPlayer, self).__init__(parent=parent)
# -- declare and setup variables for storing information --
# various data
self._set_str = '' # string of currently loaded directory sets
self._pieces = {} # {<piece1>: [<files piece1 consists of>], ...}
self._playlist = [] # list of keys of self._pieces (determines order)
self._shuffled = True # needed for (maybe) reshuffling when looping
# doc for self._history:
# key: timestamp ('HH:MM:SS'),
# value: info_str of piece that started playing at that time
self._history = {}
self._status = 'Paused'
self._current_piece = {'title': '', 'files': [], 'play_next': 0}
self._default_volume = 60 # in percent from 0 - 100
self._volume_before_muted = self._default_volume
# set to true by self.__event_movement_ended and used by self.__update
self._skip_to_next = False
# vlc-related variables
self._vlc_instance = VLCInstance()
self._vlc_mediaplayer = self._vlc_instance.media_player_new()
self._vlc_mediaplayer.audio_set_volume(self._default_volume)
self._vlc_medium = None
self._vlc_events = self._vlc_mediaplayer.event_manager()
# -- create and setup ui elements --
# buttons
self._btn_play_pause = QPushButton(QIcon(get_icon_path('play')), '')
self._btn_previous = QPushButton(QIcon(get_icon_path('previous')), '')
self._btn_next = QPushButton(QIcon(get_icon_path('next')), '')
self._btn_volume = QPushButton(QIcon(get_icon_path('volume-high')), '')
self._btn_loop = QPushButton(QIcon(get_icon_path('loop')), '')
self._btn_loop.setCheckable(True)
self._btn_play_pause.clicked.connect(self.__action_play_pause)
self._btn_previous.clicked.connect(self.__action_previous)
self._btn_next.clicked.connect(self.__action_next)
self._btn_volume.clicked.connect(self.__action_volume_clicked)
# labels
self._lbl_current_piece = QLabel('Current piece:')
self._lbl_movements = QLabel('Movements:')
self._lbl_time_played = QLabel('00:00')
self._lbl_time_left = QLabel('-00:00')
self._lbl_volume = QLabel('100%')
# needed so that everything has the same position
# independent of the number of digits of volume
self._lbl_volume.setMinimumWidth(55)
# sliders
self._slider_time = QSlider(Qt.Horizontal)
self._slider_volume = QSlider(Qt.Horizontal)
self._slider_time.sliderReleased.connect(
self.__event_time_changed_by_user)
self._slider_volume.valueChanged.connect(self.__event_volume_changed)
self._slider_time.setRange(0, 100)
self._slider_volume.setRange(0, 100)
self._slider_volume.setValue(self._default_volume)
self._slider_volume.setMinimumWidth(100)
# other elements
self._checkbox_loop_playlist = QCheckBox('Loop playlist')
self._lineedit_current_piece = QLineEdit()
self._lineedit_current_piece.setReadOnly(True)
self._lineedit_current_piece.textChanged.connect(
self.__event_piece_text_changed)
self._listwidget_movements = QListWidget()
self._listwidget_movements.itemClicked.connect(
self.__event_movement_selected)
# -- create layout and insert ui elements--
self._layout = QVBoxLayout(self)
# row 0 (name of current piece)
self._layout_piece_name = QHBoxLayout()
self._layout_piece_name.addWidget(self._lbl_current_piece)
self._layout_piece_name.addWidget(self._lineedit_current_piece)
self._layout.addLayout(self._layout_piece_name)
# rows 1 - 5 (movements of current piece)
self._layout.addWidget(self._lbl_movements)
self._layout.addWidget(self._listwidget_movements)
# row 6 (time)
self._layout_time = QHBoxLayout()
self._layout_time.addWidget(self._lbl_time_played)
self._layout_time.addWidget(self._slider_time)
self._layout_time.addWidget(self._lbl_time_left)
self._layout.addLayout(self._layout_time)
# row 7 (buttons and volume)
self._layout_buttons_and_volume = QHBoxLayout()
self._layout_buttons_and_volume.addWidget(self._btn_play_pause)
self._layout_buttons_and_volume.addWidget(self._btn_previous)
self._layout_buttons_and_volume.addWidget(self._btn_next)
self._layout_buttons_and_volume.addWidget(self._btn_loop)
self._layout_buttons_and_volume.addSpacing(40)
# distance between loop and volume buttons: min. 40, but stretchable
self._layout_buttons_and_volume.addStretch()
self._layout_buttons_and_volume.addWidget(self._btn_volume)
self._layout_buttons_and_volume.addWidget(self._slider_volume)
self._layout_buttons_and_volume.addWidget(self._lbl_volume)
self._layout.addLayout(self._layout_buttons_and_volume)
# -- setup hotkeys --
self._KEY_CODES_PLAY_PAUSE = [269025044]
self._KEY_CODES_NEXT = [269025047]
self._KEY_CODES_PREVIOUS = [269025046]
self._keyboard_listener = keyboard.Listener(on_press=self.__on_press)
self._keyboard_listener.start()
QShortcut(QKeySequence('Space'), self, self.__action_play_pause)
# -- various setup --
self._timer = QTimer(self)
self._timer.timeout.connect(self.__update)
self._timer.start(100) # update every 100ms
self.setMinimumWidth(900)
self.setMinimumHeight(400)
# get directory set(s) input and set up self._pieces
# (exec_ means we'll wait for the user input before continuing)
DirectorySetChooseDialog(self, self.set_pieces_and_playlist).exec_()
# skip to next movement / next piece when current one has ended
self._vlc_events.event_attach(VLCEventType.MediaPlayerEndReached,
self.__event_movement_ended)
def __action_next(self):
""" switches to next file in self._current_piece['files']
or to the next piece, if the current piece has ended """
reset_pause_after_current = False
# current movement is last of the current piece
if self._current_piece['play_next'] == -1:
if len(self._playlist) == 0: # reached end of playlist
if self._btn_loop.isChecked():
self._playlist = list(self._pieces.keys())
if self._shuffled:
shuffle(self._playlist)
return
if self._status == 'Playing':
self.__action_play_pause()
self._current_piece['title'] = ''
self._current_piece['files'] = []
self._current_piece['play_next'] = -1
self._lineedit_current_piece.setText('')
self.__update_movement_list()
self.parentWidget().update_status_bar(
self._status, 'End of playlist reached.')
return
else:
if self.parentWidget().get_exit_after_current():
self.parentWidget().exit()
if self.parentWidget().get_pause_after_current():
self.__action_play_pause()
reset_pause_after_current = True
# reset of the menu action will be at the end of this
# function, or else we won't stay paused
self._current_piece['title'] = self._playlist.pop(0)
self._current_piece['files'] = [
p[1:-1] for p in self._pieces[self._current_piece['title']]
]
# some pieces only have one movement
self._current_piece['play_next'] = \
1 if len(self._current_piece['files']) > 1 else -1
self.__update_vlc_medium(0)
self._lineedit_current_piece.setText(
create_info_str(self._current_piece['title'],
self._current_piece['files']))
self.__update_movement_list()
self._history[datetime.now().strftime('%H:%M:%S')] = \
self._lineedit_current_piece.text()
else:
self.__update_vlc_medium(self._current_piece['play_next'])
# next is last movement
if self._current_piece['play_next'] == \
len(self._current_piece['files']) - 1:
self._current_piece['play_next'] = -1
else: # there are at least two movements of current piece left
self._current_piece['play_next'] += 1
if self._status == 'Paused' and not reset_pause_after_current:
self.__action_play_pause()
elif reset_pause_after_current:
self.parentWidget().set_pause_after_current(False)
else:
self._vlc_mediaplayer.play()
self.parentWidget().update_status_bar(
self._status,
f'{len(self._pieces) - len(self._playlist)}/{len(self._pieces)}')
def __action_play_pause(self):
""" (gets called when self._btn_play_pause is clicked)
toggles playing/pausing music and updates everything as needed """
# don't do anything now (maybe end of playlist reached?)
if self._current_piece['title'] == '':
return
if self._status == 'Paused':
if not self._vlc_medium:
self.__action_next()
self._vlc_mediaplayer.play()
self._btn_play_pause.setIcon(QIcon(get_icon_path('pause')))
self._status = 'Playing'
else:
self._vlc_mediaplayer.pause()
self._btn_play_pause.setIcon(QIcon(get_icon_path('play')))
self._status = 'Paused'
self.parentWidget().update_status_bar(
self._status,
f'{len(self._pieces) - len(self._playlist)}/{len(self._pieces)}')
def __action_previous(self):
""" (called when self._btn_previous ist clicked)
goes back one movement of the current piece, if possible
(cannot go back to previous piece) """
# can't go back to previous piece, but current one has no or one movement
if len(self._current_piece['files']) <= 1:
pass
# currently playing first movement, so nothing to do as well
elif self._current_piece['play_next'] == 1:
pass
else: # we can go back one movement
# currently at last movement
if self._current_piece['play_next'] == -1:
# set play_next to last movement
self._current_piece['play_next'] = \
len(self._current_piece['files']) - 1
else: # currently before last movement
# set play_next to current movement
self._current_piece['play_next'] -= 1
self._vlc_mediaplayer.stop()
self.__update_vlc_medium(self._current_piece['play_next'] - 1)
self._vlc_mediaplayer.play()
def __action_volume_clicked(self):
""" (called when self._btn_volume is clicked)
(un)mutes volume """
if self._slider_volume.value() == 0: # unmute volume
self._slider_volume.setValue(self._volume_before_muted)
else: # mute volume
self._volume_before_muted = self._slider_volume.value()
self._slider_volume.setValue(0)
def __event_movement_ended(self, event):
""" (called when self._vlc_media_player emits a MediaPlayerEndReached
event)
sets self._skip_to_next to True so the next self.__update call
will trigger self.__action_next """
self._skip_to_next = True
def __event_movement_selected(self):
""" (called when self._listwidget_movements emits itemClicked)
skips to the newly selected movement """
index = self._listwidget_movements.indexFromItem(
self._listwidget_movements.currentItem()).row()
# user selected a movement different from the current one
if index != self.__get_current_movement_index():
self._current_piece['play_next'] = index
self.__action_next()
def __event_piece_text_changed(self):
""" (called when self._lineedit_current_piece emits textChanged)
ensures that the user sees the beginning of the text in
self._lineedit_current_piece (if text is too long, the end will be
cut off and the user must scroll manually to see it) """
self._lineedit_current_piece.setCursorPosition(0)
def __event_volume_changed(self):
""" (called when value of self._slider_volume changes)
updates text of self._lbl_volume to new value of self._slider_value
and sets icon of self._btn_volume to a fitting one """
volume = self._slider_volume.value()
self._lbl_volume.setText(f'{volume}%')
if volume == 0:
self._btn_volume.setIcon(QIcon(get_icon_path('volume-muted')))
elif volume < 34:
self._btn_volume.setIcon(QIcon(get_icon_path('volume-low')))
elif volume < 67:
self._btn_volume.setIcon(QIcon(get_icon_path('volume-medium')))
else:
self._btn_volume.setIcon(QIcon(get_icon_path('volume-high')))
self._vlc_mediaplayer.audio_set_volume(volume)
def __event_time_changed_by_user(self):
""" (called when user releases self._slider_time)
synchronizes self._vlc_mediaplayer's position to the new value
of self._slider_time """
self._vlc_mediaplayer.set_position(self._slider_time.value() / 100)
def __get_current_movement_index(self):
""" returns the index of the current movement in
self._current_piece['files'] """
play_next = self._current_piece['play_next']
if play_next == -1:
return len(self._current_piece['files']) - 1
else:
return play_next - 1
def __on_press(self, key):
""" (called by self._keyboard_listener when a key is pressed)
looks up key code corresponding to key and calls the appropriate
action function """
try: # key is not always of the same type (why would it be?!)
key_code = key.vk
except AttributeError:
key_code = key.value.vk
if key_code in self._KEY_CODES_PLAY_PAUSE:
self.__action_play_pause()
elif key_code in self._KEY_CODES_NEXT:
self.__action_next()
elif key_code in self._KEY_CODES_PREVIOUS:
self.__action_previous()
def __update_movement_list(self):
""" removes all items currently in self._listwidget_movements and adds
everything in self._current_piece['files] """
# TODO: use ID3 title instead of filename
while self._listwidget_movements.count() > 0:
self._listwidget_movements.takeItem(0)
files = self._current_piece['files']
if os_name == 'nt': # windows paths look different than posix paths
# remove path to file, title number and .mp3 ending
files = [i[i.rfind('\\') + 3:-4] for i in files]
else:
files = [i[i.rfind('/') + 4:-4] for i in files]
self._listwidget_movements.addItems(files)
def __update(self):
""" (periodically called when self._timer emits timeout signal)
updates various ui elements"""
# -- select currently playing movement in self._listwidget_movements --
if self._listwidget_movements.count() > 0:
self._listwidget_movements.item(
self.__get_current_movement_index()).setSelected(True)
# -- update text of self._lbl_time_played and self._lbl_time_left,
# if necessary --
if self._vlc_medium:
try:
time_played = self._vlc_mediaplayer.get_time()
medium_duration = self._vlc_medium.get_duration()
# other values don't make sense (but do occur)
if (time_played >= 0) and (time_played <= medium_duration):
self._lbl_time_played.setText(
get_time_str_from_ms(time_played))
else:
self._lbl_time_played.setText(get_time_str_from_ms(0))
self._lbl_time_left.setText(
f'-{get_time_str_from_ms(medium_duration - time_played)}')
except OSError: # don't know why that occurs sometimes
pass
# -- update value of self._slider_time --
# don't reset slider to current position if user is dragging it
if not self._slider_time.isSliderDown():
try:
self._slider_time.setValue(
self._vlc_mediaplayer.get_position() * 100)
except OSError: # don't know why that occurs sometimes
pass
if self._skip_to_next:
self._skip_to_next = False
self.__action_next()
def __update_vlc_medium(self, files_index):
old_medium = self._vlc_medium
self._vlc_medium = self._vlc_instance.media_new(
self._current_piece['files'][files_index])
self._vlc_medium.parse()
self._vlc_mediaplayer.set_media(self._vlc_medium)
if old_medium: # only release if not None
old_medium.release()
def get_history(self):
""" getter function for parent widget """
return self._history
def get_set_str(self):
""" getter function for parent widget """
return self._set_str if self._set_str != '' \
else 'No directory set loaded.'
def set_pieces_and_playlist(self, pieces, playlist, set_str, shuffled):
""" needed so that DirectorySetChooseDialog can set our self._pieces
and self._playlist """
# just to be sure
if isinstance(pieces, dict) and isinstance(playlist, list):
self._vlc_mediaplayer.stop()
self._set_str = set_str
self._pieces = pieces
self._playlist = playlist
self._shuffled = shuffled
self._current_piece['title'] = self._playlist.pop(0)
self._current_piece['files'] = [
p.replace('"', '')
for p in self._pieces[self._current_piece['title']]
]
self._current_piece['play_next'] = \
1 if len(self._current_piece['files']) > 1 else -1
self._lineedit_current_piece.setText(
create_info_str(self._current_piece['title'],
self._current_piece['files']))
self.__update_movement_list()
self.__update_vlc_medium(0)
self._history[datetime.now().strftime('%H:%M:%S')] = \
self._lineedit_current_piece.text()
def exit(self):
""" exits cleanly """
try: # don't know why that occurs sometimes
self._vlc_mediaplayer.stop()
self._vlc_mediaplayer.release()
self._vlc_instance.release()
except OSError:
pass
self._keyboard_listener.stop()
def play(self):
with open("urllist.txt", "r") as f:
url = f.readline().strip()
link = url.split(";")
if link[0]:
try:
self.threadLock.acquire()
audio = pafy.new(link[0])
best = audio.getbest()
playurl = best.url
vInstance = Instance("--novideo")
self.player = vInstance.media_player_new()
media = vInstance.media_new(playurl)
self.player.set_media(media)
if audio.duration == "00:00:00":
self.update()
self.logBrowser.append(
"Denied. Tried to play livestream video...")
self.threadLock.release()
return
self.player.play()
self.player.audio_set_volume(int(self.volume))
self.nowPlaying = audio.title
self.totalTimeLabel.setText(audio.duration)
h, m, s = audio.duration.split(":")
duration = int(h) * 3600 + int(m) * 60 + int(s)
# print(duration)
ticker = 1 / duration
try:
self.nowPlayingLabel.setText(
f"Now Playing: {self.nowPlaying}")
self.logBrowser.append(f"Now playing: {self.nowPlaying}")
with open("nowPlaying.txt", "w", encoding="utf-8") as f:
f.write(self.nowPlaying + ' ')
except:
self.nowPlaying = self.nowPlayingLabel.encode(
"unicode_escape")
self.nowPlayingLabel.setText(
f"Now Playing: {self.nowPlaying}")
self.logBrowser.append(f"Now playing: {self.nowPlaying}")
with open("nowPlaying.txt", "w", encoding="utf-8") as f:
f.write(str(self.nowPlaying) + ' ')
self.playButton.setEnabled(False)
self.threadLock.release()
self.deleteButton.setEnabled(False)
self.skipButton.setEnabled(False)
try:
ticker2 = int(link[1]) / duration
self.songPosition = ticker2
self.player.set_position(ticker2)
self.timeSlider.setValue(self.songPosition)
except IndexError:
pass
# Redundant code, remove in future™
for i in range(1):
self.songPosition += ticker
self.timeSlider.setValue(self.songPosition)
self.getTime()
time.sleep(1)
if self.player.get_state() == State.Ended:
self.nowPlayingLabel.setText("RETRYING CONNECTION")
self.play()
else:
self.update()
self.skipButton.setEnabled(True)
self.deleteButton.setEnabled(True)
try:
self.songPosition = ticker2 + (1 * ticker)
self.timeSlider.setValue(ticker2 + (1 * ticker))
except UnboundLocalError:
self.songPosition = ticker * 1
self.timeSlider.setValue(ticker * 1)
timeout = time.time() + TIMEOUT
while self.player.get_state(
) == State.Playing or self.player.get_state() == State.Paused:
if not self.paused:
self.songPosition += ticker
self.timeSlider.setValue(self.songPosition)
# print(self.songPosition)
# print(self.timeSlider.value())
self.getTime()
time.sleep(1)
if time.time() > timeout:
global TIME_LIMIT
if TIME_LIMIT:
break
if not self.run:
self.player.stop()
sys.exit()
self.songPosition = 0
self.timeSlider.setValue(0)
self.player.stop()
self.play()
except Exception as e:
self.threadLock.release()
self.errorDialog.setWindowTitle("Warning")
self.errorDialog.showMessage(str(e))
self.update()
self.play()
else:
self.playButton.setEnabled(True)
self.nowPlayingLabel.setText("Now Playing:")
self.currentTimeLabel.setText("00:00:00")
self.totalTimeLabel.setText("00:00:00")
with open("nowPlaying.txt", "w", encoding="utf-8") as f:
f.write("No songs playing currently. ")
class Music_Player():
def __init__(self):
self.player = None
self.playing = False
self.song_dictionary = {}
self.current_playlist = []
self.music_dirs = []
self.current_song_index = 0
self.is_online = False
self.muted = False
self.current_volume = 100
def start(self, music_dirs):
self.music_dirs = music_dirs
self.create_playlist()
self.vlcInstance = Instance('--novideo')
self.player = self.vlcInstance.media_player_new()
def create_playlist(self):
self.current_playlist = []
path_list = []
for music_dir in self.music_dirs:
path_list = self.get_songs_in_folder(music_dir, path_list)
for song_path in path_list:
song_name = self.get_song_name(song_path)
self.song_dictionary[song_name] = song_path
self.current_playlist.append(song_name)
self.current_song_index = 0
self.is_online = False
def set_custom_playlist(self, list):
self.current_playlist = list
self.current_song_index = 0
def create_online_dictionary(self, song_name):
self.song_dictionary = yt_search(song_name)
self.current_playlist = []
for song in self.song_dictionary.keys():
self.current_playlist.append(song)
self.current_song_index = 0
self.is_online = True
def shuffle_playlist(self):
random.shuffle(self.current_playlist)
self.current_song_index = 0
def next(self):
if len(self.current_playlist) > 0:
self.current_song_index = (self.current_song_index + 1) % len(
self.current_playlist)
if self.playing:
self.stop()
self.play()
def skip_to_song(self, index):
self.current_song_index = index % len(self.current_playlist)
def previous(self):
if len(self.current_playlist) > 0:
self.current_song_index = (self.current_song_index - 1) % len(
self.current_playlist)
if self.playing:
self.stop()
self.play()
def stop(self):
self.player.stop()
self.playing = False
def play(self):
if self.current_playlist:
if self.playing == False:
song_name = self.current_playlist[self.current_song_index]
song = self.song_dictionary[song_name]
if self.is_online == True:
song = yt_stream(song)
media = self.vlcInstance.media_new(song)
media.get_mrl()
self.player.set_media(media)
self.player.play()
self.playing = True
time.sleep(1)
else:
self.player.pause()
def get_duration(self):
song_duration = self.player.get_length() / 1000
return time.strftime('%H:%M:%S', time.gmtime(song_duration))
def get_time(self):
song_time = self.player.get_time() / 1000
return time.strftime('%H:%M:%S', time.gmtime(song_time))
def pause(self):
self.player.pause()
def get_state(self):
return self.player.get_state()
def get_songs_in_folder(self, path, song_list):
for file in os.listdir(path):
file_path = os.path.join(path, file)
if (os.path.isdir(file_path)):
self.get_songs_in_folder(file_path, song_list)
elif (file_path.endswith('.mp3')):
song_list.append(file_path)
song_list = list(dict.fromkeys(song_list))
return song_list
def get_current_playlist(self):
return self.current_playlist
def get_song_name(self, song):
# if (song.startswith('https://www.youtube.com/watch')):
# return yt_get_title(song)
if platform.system() == 'Windows':
return song.split('\\')[-1][:-4]
else:
return song.split('/')[-1][:-4]
def get_current_song_name(self):
if not self.current_playlist:
return ""
return self.current_playlist[self.current_song_index]
def get_current_song_path(self):
if not self.current_playlist:
return ""
song_name = self.current_playlist[self.current_song_index]
song = self.song_dictionary[song_name]
return song
def get_elapsed_percentage(self):
percentage = self.player.get_position() * 100
return percentage
def get_volume(self):
return self.player.audio_get_volume()
def set_volume(self, volume):
self.current_volume = volume
if self.muted == False:
self.player.audio_set_volume(self.current_volume)
def mute(self):
if self.muted == True:
self.player.audio_set_volume(self.current_volume)
self.muted = False
else:
self.player.audio_set_volume(0)
self.muted = True
def seek(self, position):
self.player.set_position(position)
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
class GooglePlayMusicPlayer(object):
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)
### LIBRARY Functions ###
def _library_load_data(self, force_online=False):
if (not force_online) and os.path.isfile('songs.json'):
# Load from file
if self._debug is True:
print(self._id_text + 'Found local song data.')
with open('songs.json') as input_file:
self._library_songs = json.load(input_file)
else:
self._library_songs = self._api.get_all_songs()
# Save to file
with open('songs.json', 'w') as output_file:
json.dump(self._library_songs, output_file)
if (not force_online) and os.path.isfile('playlists.json'):
# Load from file
if self._debug is True:
print(self._id_text + 'Found local playlist data.')
with open('playlists.json') as input_file:
self._library_playlists = json.load(input_file)
else:
self._library_playlists = self._api.get_all_user_playlist_contents(
)
# Save to file
with open('playlists.json', 'w') as output_file:
json.dump(self._library_playlists, output_file)
def _library_get_song_details(self, track_id):
for song_dict in self._library_songs:
if track_id == song_dict['id']:
return song_dict['artist'] + " - " + song_dict['title']
return "Unknown Artist - Unknown Title"
### End LIBRARY Functions ###
### QUEUE Functions ###
def _queue_load_playlist(self, playlist):
playlist_name = playlist.strip().lower()
self._queue_reset()
for playlist_dict in self._library_playlists:
actual_playlist_name = playlist_dict['name'].strip().lower()
if playlist_name in actual_playlist_name:
if self._debug is True:
print(self._id_text + "Found match...",
playlist_dict['name'])
for track_dict in playlist_dict['tracks']:
self._queue_trackDict.append(track_dict)
if len(self._queue_trackDict) != 0:
self._queue_index = -2
return playlist_dict['name']
else:
if self._debug is True:
print(self._id_text + "Found...", playlist_dict['name'])
if self._debug is True:
print(self._id_text +
"Nothing matches... Playlist was not loaded...")
return None
def _queue_reset(self):
self._controller_stop()
self._queue_trackDict = []
self._queue_index = -99
self._queue_history_backward = []
self._queue_history_forward = []
def _queue_reset_index(self):
if self._queue_shuffle_on is True:
self._queue_index = self._queue_random_index()
else:
self._queue_index = 0
def _queue_reset_history(self):
self._queue_history_backward = []
self._queue_history_forward = []
def _queue_random_index(self):
while True:
random_number = random.randrange(0, len(self._queue_trackDict))
if (self._queue_index != random_number) or (len(
self._queue_trackDict) == 1):
break
return random_number
def _queue_next(self):
if len(self._queue_trackDict) == 0:
self._queue_index = -99
return
if self._queue_loop_mode == 2: # repeat one
return
if self._queue_shuffle_on is True:
self._queue_history_backward.append(self._queue_index)
if len(self._queue_history_forward) > 0:
self._queue_index = self._queue_history_forward.pop()
else:
self._queue_index = self._queue_random_index()
else:
self._queue_index += 1
if (self._queue_index >= len(
self._queue_trackDict)) and (self._queue_loop_mode == 0):
self._queue_index = -1
else:
self._queue_index %= len(self._queue_trackDict)
def _queue_previous(self):
if len(self._queue_trackDict) == 0:
self._queue_index = -99
return
if self._queue_shuffle_on is True:
if len(self._queue_history_backward) > 0:
self._queue_history_forward.append(self._queue_index)
self._queue_index = self._queue_history_backward.pop()
else:
self._queue_index = max(0, self._queue_index - 1)
def _queue_get(self):
if self._queue_index == -2:
self._queue_reset_index()
return self._queue_get()
if self._queue_index == -1:
self._queue_reset_index()
return None
if (self._queue_index < 0) or (self._queue_index >= len(
self._queue_trackDict)):
return None
return self._queue_trackDict[self._queue_index]
### End QUEUE Functions ###
### PLAYER & CONTROLLER Functions ###
def _controller_play_song(self, song_dict):
stream_url = self._api.get_stream_url(song_dict['trackId'])
self._player = self._vlc.media_player_new()
media = self._vlc.media_new(stream_url)
self._player.set_media(media)
if self._player_volume_muted is True:
self._player.audio_set_volume(0)
else:
self._player.audio_set_volume(self._player_volume)
self._player.play()
self._player_state = 'playing'
self._player.event_manager().event_attach(
EventType.MediaPlayerEndReached,
self._controller_finish_and_play_next)
song_info_string = self._library_get_song_details(song_dict['trackId'])
print(self._id_text + "Playing... " + song_info_string + " (" +
song_dict['id'] + ")")
def _controller_play(self):
if self._player_state == 'stopped':
song_dict = self._queue_get()
if song_dict == None:
return
self._controller_play_song(song_dict)
elif self._player_state == 'playing':
return
elif self._player_state == 'paused':
self._player.set_pause(0)
self._player_state = 'playing'
def _controller_pause(self):
if self._player_state == 'playing':
self._player.set_pause(1)
self._player_state = 'paused'
def _controller_stop(self):
if self._player_state in ['playing', 'paused']:
self._player.stop()
self._player_state = 'stopped'
def _controller_finish_and_play_next(self, event):
self._player_state = 'stopped'
self._api.increment_song_playcount(
self._queue_trackDict[self._queue_index]['id'])
self._controller_next()
self._controller_play()
def _controller_next(self):
saved_player_state = self._player_state
self._controller_stop()
self._queue_next()
if saved_player_state != 'stopped':
self._controller_play()
def _controller_previous(self):
saved_player_state = self._player_state
self._controller_stop()
self._queue_previous()
if saved_player_state != 'stopped':
self._controller_play()
def _controller_shuffle(self, mode): # mode False = off, mode True = on
self._queue_shuffle_on = mode
self._queue_reset_history()
def _controller_loop(
self,
mode): # mode 0 = loop off, mode 1 = loop all, mode 2 = repeat one
self._queue_loop_mode = mode
def _controller_volume_adjust(self, direction, amount):
if direction is 'up':
self._player_volume = min(self._player_volume + amount, 100)
else:
self._player_volume = max(0, self._player_volume - amount)
if self._player is not None:
self._player.audio_set_volume(self._player_volume)
self._player_volume_muted = False
def _controller_volume_mute(self):
if self._player_volume_muted is False:
if self._player is not None:
self._player.audio_set_volume(0)
self._player_volume_muted = True
def _controller_volume_unmute(self):
if self._player_volume_muted is True:
if self._player is not None:
self._player.audio_set_volume(self._player_volume)
self._player_volume_muted = False
### End PLAYER & CONTROL Functions ###
def load_playlist(self, playlist_name):
self._last_executed_command = 'load'
return self._queue_load_playlist(playlist_name)
def play(self):
self._last_executed_command = 'play'
self._controller_play()
def pause(self):
self._last_executed_command = 'pause'
self._controller_pause()
def stop(self):
self._last_executed_command = 'stop'
self._controller_stop()
def next(self):
self._last_executed_command = 'next'
self._controller_next()
def previous(self):
self._last_executed_command = 'previous'
self._controller_previous()
def shuffle(self, command):
self._last_executed_command = 'shuffle'
if command in [0, 1]:
self._controller_shuffle(True if command is 1 else False)
elif command is 2:
return self._queue_shuffle_on
def loop(self, command):
self._last_executed_command = 'loop'
if command in [0, 1, 2]:
self._controller_loop(command)
elif command is 3:
return self._queue_loop_mode
def volume_adjust(self, direction, amount):
self._last_executed_command = 'volume'
if direction in ['up', 'down']:
self._controller_volume_adjust(direction, amount)
def mute(self):
self._last_executed_command = 'mute'
self._controller_volume_mute()
def unmute(self):
self._last_executed_command = 'unmute'
self._controller_volume_unmute()
def get_command_list(self):
return self._command_dict.keys()
def pause_for_command(self):
if self._player_state is 'playing':
self._is_playing_before_pausing_for_command = True
self._controller_pause()
else:
self._is_playing_before_pausing_for_command = False
def resume_after_command(self, force):
if self._is_playing_before_pausing_for_command is True:
if (force is True) or (self._last_executed_command
not in ['play', 'pause', 'stop']):
self._controller_play()
# from google assistant voice command control (import this file from google AIY)
def run_command(self, action):
if 'play' in action:
playlist = action.replace("play", "").strip()
if self.load_playlist(playlist) is None:
return ('I am not able to find ' + playlist)
self.play()
elif self._command_dict[action] == 'play':
self.play()
elif self._command_dict[action] == 'pause':
self.pause()
elif self._command_dict[action] == 'stop':
self.stop()
elif self._command_dict[action] == 'next':
self.next()
elif self._command_dict[action] == 'previous':
self.previous()
elif self._command_dict[action] == 'shuffle off':
self.shuffle(0)
elif self._command_dict[action] == 'shuffle on':
self.shuffle(1)
elif self._command_dict[action] == 'shuffle status':
s = 'on' if self.shuffle(2) is True else 'off'
return ('Shuffle is ' + s)
elif self._command_dict[action] == 'looping off':
self.loop(0)
elif self._command_dict[action] == 'looping all':
self.loop(1)
elif self._command_dict[action] == 'looping one':
self.loop(2)
elif self._command_dict[action] == 'looping status':
s = self.loop(3)
msg = 'is off' if s is 0 else (
'all songs' if s is 1 else 'this song')
return ('looping ' + msg)
elif self._command_dict[action] == 'volume up':
self.volume_adjust('up', 10)
elif self._command_dict[action] == 'volume down':
self.volume_adjust('down', 10)
elif self._command_dict[action] == 'mute':
self.mute()
elif self._command_dict[action] == 'unmute':
self.unmute()
else: # probably won't get here
print(self._id_text + 'Not a valid action...')
return ('I don\'t know what to do.')
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()
def play(self):
with open('urllist.txt', 'r') as f:
url = f.readline().strip()
if url:
try:
self.threadLock.acquire()
video = pafy.new(url)
best = video.getbest()
playurl = best.url
vInstance = Instance('--novideo')
self.player = vInstance.media_player_new()
media = vInstance.media_new(playurl)
self.player.set_media(media)
self.player.play()
self.player.audio_set_volume(int(self.volume))
self.nowPlaying = video.title
self.durationLabel.config(text=video.duration)
h, m, s = video.duration.split(':')
duration = int(h) * 3600 + int(m) * 60 + int(s)
ticker = 1 / duration
try:
self.nowPlayingLabel.config(
text=f'Now Playing: {self.nowPlaying}')
with open('nowPlaying.txt', 'w', encoding='utf-8') as f:
f.write(self.nowPlaying + ' ')
except:
self.nowPlaying = self.nowPlaying.encode('unicode_escape')
self.nowPlayingLabel.config(
text=f'Now Playing: {self.nowPlaying}')
with open('nowPlaying.txt', 'w', encoding='utf-8') as f:
f.write(str(self.nowPlaying) + ' ')
self.playButton.config(state='disabled')
self.threadLock.release()
self.shuffleButton.config(state='disabled')
self.deleteButton.config(state='disabled')
self.nextButton.config(state='disabled')
for i in range(3):
self.songPosition += ticker
self.musicScrubber.set(self.songPosition)
self.get_time()
time.sleep(1)
if self.player.get_state() == State.Ended:
self.nowPlayingLabel.config(text='RETRYING CONNECTION')
self.play()
else:
self.update()
self.shuffleButton.config(state='normal')
self.deleteButton.config(state='normal')
self.nextButton.config(state='normal')
self.songPosition = ticker * 3
self.musicScrubber.set(ticker * 3)
while self.player.get_state(
) == State.Playing or self.player.get_state() == State.Paused:
if self.paused == False:
self.songPosition += ticker
self.musicScrubber.set(self.songPosition)
self.get_time()
time.sleep(1)
if self.run == False:
self.player.stop()
sys.exit()
self.songPosition = 0
self.musicScrubber.set(0)
self.player.stop()
self.play()
except Exception as error:
self.threadLock.release()
tkinter.messagebox.showwarning(title='Warning', message=error)
self.update()
self.play()
else:
self.playButton.config(state='normal')
self.nowPlayingLabel.config(text='Now Playing:')
self.durationLabel.config(text='00:00:00')
self.timeLabel.config(text='00:00:00 /')
with open('nowPlaying.txt', 'w', encoding='utf-8') as f:
f.write(
'No songs playing. Donate to have your song played on stream. '
)