154 lines
2.9 KiB
Go
154 lines
2.9 KiB
Go
package metadata
|
|
|
|
import (
|
|
"fmt"
|
|
"log/slog"
|
|
"os"
|
|
"path/filepath"
|
|
"regexp"
|
|
"slices"
|
|
"sort"
|
|
"strings"
|
|
|
|
"git.kapelle.org/niklas/ripsort/internal/clients/musicbrainz"
|
|
"github.com/dhowden/tag"
|
|
)
|
|
|
|
type Metadata struct {
|
|
Title *string
|
|
Artist []string
|
|
Album *string
|
|
AlbumArtist []string
|
|
Track int
|
|
TotalTracks int
|
|
Comment *string
|
|
ISRC *string
|
|
Date *string
|
|
Genre []string
|
|
SpotifyID *string
|
|
}
|
|
|
|
func ReadAudioTags(filePath string) (*Metadata, error) {
|
|
ext := strings.ToLower(filepath.Ext(filePath))
|
|
|
|
switch {
|
|
case ext == ".flac":
|
|
return readVorbisMetadata(filePath)
|
|
default:
|
|
return readGenericAudioTags(filePath)
|
|
}
|
|
}
|
|
|
|
func readGenericAudioTags(filePath string) (*Metadata, error) {
|
|
f, err := os.Open(filePath)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to open file: %w", err)
|
|
}
|
|
defer f.Close()
|
|
|
|
m, err := tag.ReadFrom(f)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to read tags: %w", err)
|
|
}
|
|
|
|
track, totalTracks := m.Track()
|
|
|
|
title := m.Title()
|
|
album := m.Album()
|
|
comment := m.Comment()
|
|
|
|
info := &Metadata{
|
|
Title: &title,
|
|
Artist: parseSeperatedTag(m.Artist()),
|
|
Album: &album,
|
|
AlbumArtist: parseSeperatedTag(m.AlbumArtist()),
|
|
Track: track,
|
|
TotalTracks: totalTracks,
|
|
Comment: &comment,
|
|
Genre: []string{m.Genre()},
|
|
}
|
|
|
|
commentToSpotifyid(info)
|
|
|
|
return info, nil
|
|
}
|
|
|
|
func parseSeperatedTag(s string) []string {
|
|
parsed := make([]string, 0)
|
|
|
|
for element := range strings.SplitSeq(s, ";") {
|
|
parsed = append(parsed, strings.TrimSpace(element))
|
|
}
|
|
|
|
return parsed
|
|
}
|
|
|
|
func UpdateMetadata(src, dst string, m Metadata) error {
|
|
|
|
ext := strings.ToLower(filepath.Ext(src))
|
|
|
|
switch {
|
|
case ext == ".flac":
|
|
return updateFlacMetadata(m, src, dst)
|
|
default:
|
|
slog.Warn("Unsupported format for updating metadata")
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
func commentToSpotifyid(m *Metadata) {
|
|
var re = regexp.MustCompile(`(?m)(https:\/\/open\.spotify\.com\/track\/)(.*)`)
|
|
|
|
if m.Comment == nil {
|
|
return
|
|
}
|
|
|
|
matches := re.FindAllStringSubmatch(*m.Comment, -1)
|
|
|
|
if len(matches) != 1 {
|
|
return
|
|
}
|
|
|
|
id := matches[0][2]
|
|
|
|
m.SpotifyID = &id
|
|
}
|
|
|
|
func SearchForGenre(mbc *musicbrainz.MusicBrainzClient, m *Metadata) ([]string, error) {
|
|
if m.ISRC == nil {
|
|
return []string{}, nil
|
|
}
|
|
|
|
res, err := mbc.SearchByISRC(*m.ISRC, musicbrainz.SearchOptions{})
|
|
if err != nil {
|
|
return []string{}, err
|
|
}
|
|
|
|
if len(res.Recordings) == 0 {
|
|
return []string{}, nil
|
|
}
|
|
|
|
allTags := []musicbrainz.Tag{}
|
|
|
|
for _, rec := range res.Recordings {
|
|
allTags = append(allTags, rec.Tags...)
|
|
}
|
|
|
|
sort.Slice(allTags[:], func(i int, j int) bool {
|
|
return allTags[i].Count > allTags[j].Count
|
|
})
|
|
|
|
allTags = slices.CompactFunc(allTags, func(lhs, rhs musicbrainz.Tag) bool {
|
|
return lhs.Name == rhs.Name
|
|
})
|
|
|
|
finalTags := []string{}
|
|
for _, tag := range allTags {
|
|
finalTags = append(finalTags, tag.Name)
|
|
}
|
|
|
|
return finalTags, nil
|
|
}
|