108 lines
3.0 KiB
Go
108 lines
3.0 KiB
Go
package backend
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"net/http"
|
|
"regexp"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/dweymouth/supersonic/backend/mediaprovider"
|
|
)
|
|
|
|
// FetchLrcLibLyrics is a static function to search and fetch lyrics from lrclib.net
|
|
func FetchLrcLibLyrics(name, artist, album string, durationSecs int) (*mediaprovider.Lyrics, error) {
|
|
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
|
defer cancel()
|
|
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodGet, "https://lrclib.net/api/get", nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
req.Header.Add("Accept", "application/json")
|
|
req.Header.Add("User-Agent", "Supersonic")
|
|
|
|
q := req.URL.Query()
|
|
q.Add("track_name", name)
|
|
q.Add("artist_name", artist)
|
|
q.Add("album_name", album)
|
|
q.Add("duration", strconv.Itoa(durationSecs))
|
|
req.URL.RawQuery = q.Encode()
|
|
|
|
resp, err := http.DefaultClient.Do(req)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
return parseLrcLibResponse(resp)
|
|
}
|
|
|
|
func parseLrcLibResponse(resp *http.Response) (*mediaprovider.Lyrics, error) {
|
|
if resp.StatusCode == http.StatusNotFound {
|
|
return nil, errors.New("lrclib lyrics not found")
|
|
} else if resp.StatusCode != http.StatusOK {
|
|
return nil, fmt.Errorf("error from lrclib: status %d", resp.StatusCode)
|
|
}
|
|
|
|
var parsedResponse lrcLibResponse
|
|
if err := json.NewDecoder(resp.Body).Decode(&parsedResponse); err != nil {
|
|
return nil, fmt.Errorf("failed to decode lrclib response: %w", err)
|
|
}
|
|
lrcs := &mediaprovider.Lyrics{
|
|
Title: parsedResponse.TrackName,
|
|
Artist: parsedResponse.ArtistName,
|
|
}
|
|
if parsedResponse.SyncedLyrics != "" {
|
|
lines, err := parseSyncedLyrics(parsedResponse.SyncedLyrics)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
lrcs.Synced = true
|
|
lrcs.Lines = lines
|
|
} else {
|
|
for _, line := range strings.Split(parsedResponse.PlainLyrics, "\n") {
|
|
lrcs.Lines = append(lrcs.Lines, mediaprovider.LyricLine{Text: line})
|
|
}
|
|
}
|
|
return lrcs, nil
|
|
}
|
|
|
|
var syncedRegex = regexp.MustCompile(`^\[(\d\d):(\d\d\.\d\d\d?)\] ?(.+)$`)
|
|
|
|
func parseSyncedLyrics(synced string) ([]mediaprovider.LyricLine, error) {
|
|
var lines []mediaprovider.LyricLine
|
|
for _, line := range strings.Split(synced, "\n") {
|
|
matches := syncedRegex.FindStringSubmatch(line)
|
|
if len(matches) != 4 {
|
|
continue // malformed lyric line, attempt to continue
|
|
}
|
|
min, _ := strconv.Atoi(matches[1])
|
|
sec, _ := strconv.ParseFloat(matches[2], 64)
|
|
lines = append(lines, mediaprovider.LyricLine{
|
|
Start: float64(min)*60 + sec,
|
|
Text: matches[3],
|
|
})
|
|
}
|
|
var err error
|
|
if len(lines) == 0 {
|
|
err = errors.New("failed to parse synced lyrics")
|
|
}
|
|
return lines, err
|
|
}
|
|
|
|
type lrcLibResponse struct {
|
|
ID int `json:"id"`
|
|
TrackName string `json:"trackName"`
|
|
ArtistName string `json:"artistName"`
|
|
AlbumName string `json:"albumName"`
|
|
Duration float64 `json:"duration"`
|
|
Instrumental bool `json:"instrumental"`
|
|
PlainLyrics string `json:"plainLyrics"`
|
|
SyncedLyrics string `json:"syncedLyrics"`
|
|
}
|