249 lines
7.6 KiB
Python
249 lines
7.6 KiB
Python
import sys
|
|
import spotipy
|
|
import spotipy.util as util
|
|
import config as cfg
|
|
from PIL import Image, ImageDraw, ImageFont
|
|
import asyncio
|
|
from rgbmatrix import RGBMatrix, RGBMatrixOptions
|
|
import threading
|
|
import requests
|
|
from io import BytesIO
|
|
import time
|
|
|
|
client_id = cfg.client_id
|
|
client_secret = cfg.client_secret
|
|
redirect_uri = cfg.redirect_uri
|
|
username = cfg.username
|
|
|
|
scope = 'user-read-currently-playing'
|
|
|
|
options = RGBMatrixOptions()
|
|
options.rows = 32
|
|
options.cols = 64
|
|
options.chain_length = 6
|
|
options.parallel = 2
|
|
options.hardware_mapping = 'regular'
|
|
options.pixel_mapper_config = 'U-mapper'
|
|
options.limit_refresh_rate_hz = 240
|
|
options.gpio_slowdown = 4
|
|
options.brightness = 50
|
|
options.disable_hardware_pulsing = True
|
|
screen = RGBMatrix(options = options)
|
|
|
|
song_name=""
|
|
artist_name=""
|
|
|
|
cache_path="/home/pi/.cache-"+username
|
|
|
|
is_playing = False
|
|
|
|
is_scrolling_art = False
|
|
|
|
cover_art_offset_x = 0
|
|
cover_art_offset_y = 96
|
|
|
|
token = None #oauth2.SpotifyOAuth(username, scope, client_id, client_secret, redirect_uri)
|
|
|
|
#token = util.prompt_for_user_token(username, scope, client_id, client_secret, redirect_uri)
|
|
|
|
font = ImageFont.load_default()
|
|
|
|
def get_track():
|
|
print('getting current song info')
|
|
sp = spotipy.Spotify(auth=token)
|
|
track = sp.currently_playing()
|
|
if track is None:
|
|
return
|
|
global is_playing
|
|
is_playing = track['is_playing']
|
|
global song_name
|
|
song_name = track['item']['name']
|
|
global artist_name
|
|
artist_name = track['item']['artists'][0]['name']
|
|
for i in range(len(track['item']['artists'])-1):
|
|
artist_name +=', ' + track['item']['artists'][i+1]['name']
|
|
print('got info: ' + track['item']['name'] + ' - ' + track['item']['artists'][0]['name'])
|
|
#print('getting image')
|
|
image_url = track['item']['album']['images'][0]['url']
|
|
response = requests.get(image_url)
|
|
image = Image.open(BytesIO(response.content))
|
|
#print(image_url)
|
|
image = image.resize((32,32))
|
|
return image
|
|
|
|
def showImage(image, offset_x = 0, offset_y = 0):
|
|
image = image.convert('RGB')
|
|
width, height = image.size
|
|
for x in range(width):
|
|
for y in range(height):
|
|
r, g, b = image.getpixel((x, y))
|
|
screen.SetPixel(x+offset_x,y+offset_y,r,g,b)
|
|
|
|
|
|
|
|
#if token:
|
|
# sp = spotipy.Spotify(auth=token)
|
|
# track = sp.currently_playing()
|
|
# print(track['is_playing'])
|
|
# print(track['item']['name'] + ' - ' + track['item']['artists'][0]['name'])
|
|
# imageString = requests.get(track['item']['album']['images'][0]['url'])
|
|
# image = Image.open(BytesIO(imageString.content))
|
|
# image = image.resize((32,32))
|
|
# #image.save("thumbnail.jpg","JPEG")
|
|
#else:
|
|
# print("Can't get token for", username)
|
|
#def main():
|
|
# x = threading.Thread(target=draw)
|
|
# x.start()
|
|
|
|
|
|
def drawCanvas():
|
|
canvas = Image.new('RGB', (192, 128), color = 'black')
|
|
was_playing = is_playing
|
|
cover_art = get_track()
|
|
global is_scrolling_art
|
|
if (cover_art is None):
|
|
return
|
|
if(was_playing and not is_playing):
|
|
is_scrolling_art = True
|
|
scroll = threading.Thread(target=scrollDownSongInfo)
|
|
scroll.start()
|
|
|
|
if(not was_playing and is_playing):
|
|
is_scrolling_art = True
|
|
scroll = threading.Thread(target=scrollUpSongInfo)
|
|
scroll.start()
|
|
if is_scrolling_art:
|
|
return
|
|
if(is_playing):
|
|
canvas.paste(cover_art,(cover_art_offset_x,cover_art_offset_y))
|
|
songinfo = ImageDraw.Draw(canvas)
|
|
songinfo_offset_x = 33
|
|
songinfo_offset_y = 101
|
|
songinfo.text((songinfo_offset_x,songinfo_offset_y+11), song_name)
|
|
songinfo.text((songinfo_offset_x,songinfo_offset_y), artist_name)
|
|
|
|
#scrolling_text(song_name,songinfo_offset_x, songinfo_offset_y+10)
|
|
if(font.getsize(song_name)[0]>160):
|
|
x = threading.Thread(target=scrolling_text,args=(song_name,songinfo_offset_x,songinfo_offset_y+11))
|
|
x.start()
|
|
print('scrolling text started')
|
|
if(font.getsize(artist_name)[0]>160):
|
|
|
|
y = threading.Thread(target=scrolling_text,args=(artist_name,songinfo_offset_x,songinfo_offset_y))
|
|
y.start()
|
|
|
|
showImage(canvas)
|
|
|
|
def scrollDownSongInfo(offset_x=0,offset_y=96):
|
|
global is_scrolling_art
|
|
cover_art = get_track()
|
|
if (cover_art is None):
|
|
return
|
|
for i in range(33):
|
|
song_info_canvas = Image.new('RGB', (192,32), color = 'black')
|
|
songinfo = ImageDraw.Draw(song_info_canvas)
|
|
songinfo_offset_x = 33
|
|
songinfo.text((songinfo_offset_x,16+i), song_name)
|
|
songinfo.text((songinfo_offset_x,5+i), artist_name)
|
|
song_info_canvas.paste(cover_art,(0,i))
|
|
showImage(song_info_canvas, offset_x, offset_y)
|
|
time.sleep(0.001)
|
|
is_scrolling_art = False
|
|
|
|
def scrollUpSongInfo(offset_x=0, offset_y=96):
|
|
global is_scrolling_art
|
|
cover_art = get_track()
|
|
if (cover_art is None):
|
|
return
|
|
for i in range(33):
|
|
song_info_canvas = Image.new('RGB', (192,32), color = 'black')
|
|
songinfo = ImageDraw.Draw(song_info_canvas)
|
|
songinfo_offset_x = 33
|
|
songinfo.text((songinfo_offset_x,16+(33-i)), song_name)
|
|
songinfo.text((songinfo_offset_x,5+(33-i)), artist_name)
|
|
song_info_canvas.paste(cover_art,(0,(33-i)))
|
|
showImage(song_info_canvas, offset_x, offset_y)
|
|
time.sleep(0.001)
|
|
is_scrolling_art = False
|
|
|
|
def scrolling_text(text,offset_x=0,offset_y=0):
|
|
scroll_frame_time = (8/2)/(font.getsize(text)[0]-160)
|
|
#print(scroll_frame_time)
|
|
if(scroll_frame_time>0.03):
|
|
scroll_frame_time = 0.03
|
|
for i in range((font.getsize(text)[0]-160)):
|
|
scrolled_text_canvas = Image.new('RGB', (160, 11), color = 'black')
|
|
scrolled_text = ImageDraw.Draw(scrolled_text_canvas)
|
|
scrolled_text.text((-i,0), text)
|
|
showImage(scrolled_text_canvas, offset_x, offset_y)
|
|
time.sleep(scroll_frame_time)
|
|
#print('scrolled '+str(i)+' px')
|
|
if((5-(font.getsize(text)[0]-160)*2*scroll_frame_time)>0):
|
|
time.sleep(5-(font.getsize(text)[0]-160)*2*scroll_frame_time)
|
|
for i in range(font.getsize(text)[0]-160):
|
|
scrolled_text_canvas = Image.new('RGB', (160, 11), color = 'black')
|
|
scrolled_text = ImageDraw.Draw(scrolled_text_canvas)
|
|
scrolled_text.text(((-(font.getsize(text)[0]-160))+i+1,0), text)
|
|
showImage(scrolled_text_canvas, offset_x, offset_y)
|
|
time.sleep(scroll_frame_time)
|
|
#print('scrolled '+str(i)+' px')
|
|
|
|
|
|
def main():
|
|
get_access_token()
|
|
|
|
def get_access_token():
|
|
global token
|
|
sp_oauth = spotipy.SpotifyOAuth(
|
|
client_id,
|
|
client_secret,
|
|
redirect_uri,
|
|
scope=scope,
|
|
#cache_path=cache_path,
|
|
username=username,
|
|
open_browser=False
|
|
)
|
|
token_info = sp_oauth.get_cached_token()
|
|
|
|
if not token_info:
|
|
code = sp_oauth.get_auth_response()
|
|
token = sp_oauth.get_access_token(code, as_dict=False)
|
|
else:
|
|
if is_token_expired():
|
|
token_info = refresh_access_token(token_info)
|
|
token = token_info["access_token"]
|
|
|
|
def is_token_expired():
|
|
sp_oauth = spotipy.SpotifyOAuth(
|
|
client_id,
|
|
client_secret,
|
|
redirect_uri,
|
|
scope=scope,
|
|
#cache_path=cache_path,
|
|
username=username,
|
|
open_browser=False
|
|
)
|
|
token_info = sp_oauth.get_cached_token()
|
|
if not token_info:
|
|
return True
|
|
else:
|
|
return sp_oauth.is_token_expired(token_info)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|
|
print('led-matrix-viewer started')
|
|
|
|
while True:
|
|
# if(is_token_expired()):
|
|
# get_access_token()
|
|
drawCanvas()
|
|
time.sleep(10)
|
|
|
|
|
|
|
|
|
|
|
|
|