def changer(file_name):
instance = vlc.Instance()
media = instance.media_new(file_name)
player = instance.media_player_new()
player.set_media(media)
player.play()
# duration = vlc.libvlc_media_get_duration(media)
# duration/=100
# print(duration)
while True:
time.sleep(0.2)
if(os.path.isfile('received')):
time.sleep(2)
break
pickle_in = open("received","rb")
genre_dict = pickle.load(pickle_in)
dict_size = len(genre_dict)
# print(dict_size)
time1 = 0
while True:
# message = server.recv(2048)
time.sleep(0.2)
if(vlc.libvlc_media_player_get_position(player) >= genre_dict[time1][0]):
eq_handle = vlc.libvlc_audio_equalizer_new_from_preset(genre2.get(genre_dict[time1][1].item()))
vlc.libvlc_media_player_set_equalizer(player,eq_handle)
vlc.libvlc_audio_equalizer_release(eq_handle)
print(get_key(genre2.get(genre_dict[time1][1].item())))
time1 = time1 + 1
if(time1>=dict_size):
break
def set_equalizer_preset(idx):
global equalizer
vlc.libvlc_audio_equalizer_release(equalizer)
equalizer = vlc.libvlc_audio_equalizer_new_from_preset(idx)
populate_equalizer_globals(equalizer, preset_idx=idx)
if equalizer_enabled:
player.set_equalizer(equalizer)
return get_status()
def set_equalizer_preset(idx):
global equalizer
vlc.libvlc_audio_equalizer_release(equalizer)
equalizer = vlc.libvlc_audio_equalizer_new_from_preset(idx)
populate_equalizer_globals(equalizer, preset_idx=idx)
if equalizer_enabled:
player.set_equalizer(equalizer)
return get_status()
def __init__(self): self.instance = vlc.Instance() self.player = self.instance.media_player_new() self.player.set_equalizer(vlc.libvlc_audio_equalizer_new_from_preset(17)) self.r = 4 self.c = 3 self.row = [16,20,21,22] self.col = [27,17,4] self.keys = [[[1,1],['a',3],['d',3]],[['g',3],['j',3],['m',3]],[['p',4],['t',3],['w',4]],[[2,1],[' ',1],[4,1]]] pins.setmode(pins.BCM) pins.setwarnings(0)
def __init__(self):
self.instance = vlc.Instance()
self.player = self.instance.media_player_new()
self.player.set_equalizer(
vlc.libvlc_audio_equalizer_new_from_preset(17))
5:13,
6:4,
7:18,
8:11,
9:17,
10:11,
11:17,
12:12,
13:1
}
instance = vlc.Instance()
media = instance.media_new("audio.mp3")
player = instance.media_player_new()
player.set_media(media)
player.play()
duration = libvlc_media_get_duration()
duration/=100
pickle_in = open("data2send","rb")
genre_dict = pickle.load(pickle_in)
dict_size = len(genre_dict)
time = 0
while True:
# message = server.recv(2048)
if(vlc.libvlc_media_player_get_time(player)>=genre_dict[time][0]):
vlc.libvlc_audio_equalizer_release(player)
vlc.libvlc_media_player_set_equalizer(player, vlc.libvlc_audio_equalizer_new_from_preset(genres.get(genre2.get(genre_dict[time][1]))))
time++
if(time>=dict_size):
break
def __init__(self, name, playlistPath, freq = 0, stop = False, pause = False, shuffle = False, start_random = False, equalizerName = None):
''' Represent a radio station and how it is played
Parameters
----------
name: str
The name of the station. Is displayed in the GUI only.
playlistPath: str
The thing that should be played. Basically everything that VLC understands.
Could be a local file, a playlist or an url.
freq: number
At what frequency the radio station can be heard.
It needs to be in any of the configured frequency bands.
For Example "102_400_000" will have the station at 102.4MHz.
You have to take care that no two stations are overlapping.
stop: bool, optional
If the playback should be stopped when the station is tuned out of.
This is a recommended option when playing web streams.
Has the advantage that bandwidth is saved when the stream is not played,
but at the disadvantage that there might be a small gap when tuning into that station
Another use-case is when you want that your file is played from the beginning when
tuning into that station, but at the (unrealistic) price of having it played from
start again when tuning away and in again.
(default False)
pause: bool, optional
If the playback should be paused when the station is tuned out of.
Lowers CPU when not playing, and – other than `stop` – allows instant continuation
of playback. But it comes with the price that the station will still play the same song
when you tune back in after 5 minutes.
(default False)
shuffle: bool
Shuffles track order when using a playlist.
(default False)
start_random: bool
Starts at a random position when using the playlist.
It is a lighter version of `shuffle` as it does not shuffle the track order, but still gives
a random entry point into the playlist.
(default False)
'''
self.name = name
self.freq = freq
self.shouldStop = stop
self.shouldPause = pause
self.shuffle = shuffle
self.start_random = start_random
self.lastPlayback = None
[self.minFreq, self.maxFreq, self.band] = self.__detectBand(freq)
self.vlcMediaListPlayer = vlcInstance.media_list_player_new()
tracks = self.__getTracksFromPlaylist(playlistPath)
if shuffle:
random.shuffle(tracks)
playlist = vlcInstance.media_list_new(tracks)
self.vlcMediaListPlayer.set_media_list(playlist)
self.getPlayer().set_role(vlc.MediaPlayerRole.Music)
self.vlcMediaListPlayer.set_playback_mode(vlc.PlaybackMode.loop)
self.setVolume(0)
if equalizerName:
if equalizerName in eqIndexByName:
equalizerIdx = eqIndexByName[equalizerName]
equalizer = vlc.libvlc_audio_equalizer_new_from_preset(equalizerIdx)
self.getPlayer().set_equalizer(equalizer)
else:
wlog("Equalizer with name {} does not exist. Valid values:".format(equalizerName))
wlog(", ".join(eqIndexByName.keys()))
if start_random:
self.vlcMediaListPlayer.play_item_at_index(random.randint(0, len(tracks)-1 ))
if not stop:
self.vlcMediaListPlayer.play()
if shuffle or start_random:
self.getPlayer().set_position(random.random())