219 lines
6.4 KiB
Go
219 lines
6.4 KiB
Go
package metadata
|
|
|
|
import (
|
|
"fmt"
|
|
"math"
|
|
"os"
|
|
"path"
|
|
"regexp"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
"github.com/navidrome/navidrome/conf"
|
|
"github.com/navidrome/navidrome/log"
|
|
)
|
|
|
|
type Extractor interface {
|
|
Extract(files ...string) (map[string]*Tags, error)
|
|
}
|
|
|
|
func Extract(files ...string) (map[string]*Tags, error) {
|
|
var e Extractor
|
|
|
|
switch conf.Server.Scanner.Extractor {
|
|
case "taglib":
|
|
e = &taglibExtractor{}
|
|
case "ffmpeg":
|
|
e = &ffmpegExtractor{}
|
|
default:
|
|
log.Warn("Invalid Scanner.Extractor option. Using default taglib", "requested", conf.Server.Scanner.Extractor,
|
|
"validOptions", "ffmpeg,taglib")
|
|
e = &taglibExtractor{}
|
|
}
|
|
return e.Extract(files...)
|
|
}
|
|
|
|
type Tags struct {
|
|
filePath string
|
|
suffix string
|
|
fileInfo os.FileInfo
|
|
tags map[string][]string
|
|
custom map[string][]string
|
|
}
|
|
|
|
func NewTags(filePath string, tags, custom map[string][]string) *Tags {
|
|
fileInfo, err := os.Stat(filePath)
|
|
if err != nil {
|
|
log.Warn("Error stating file. Skipping", "filePath", filePath, err)
|
|
return nil
|
|
}
|
|
|
|
return &Tags{
|
|
filePath: filePath,
|
|
suffix: strings.ToLower(strings.TrimPrefix(path.Ext(filePath), ".")),
|
|
fileInfo: fileInfo,
|
|
tags: tags,
|
|
custom: custom,
|
|
}
|
|
}
|
|
|
|
// Common tags
|
|
|
|
func (t *Tags) Title() string { return t.getFirstTagValue("title", "sort_name", "titlesort") }
|
|
func (t *Tags) Album() string { return t.getFirstTagValue("album", "sort_album", "albumsort") }
|
|
func (t *Tags) Artist() string { return t.getFirstTagValue("artist", "sort_artist", "artistsort") }
|
|
func (t *Tags) AlbumArtist() string {
|
|
return t.getFirstTagValue("album_artist", "album artist", "albumartist")
|
|
}
|
|
func (t *Tags) SortTitle() string { return t.getSortTag("", "title", "name") }
|
|
func (t *Tags) SortAlbum() string { return t.getSortTag("", "album") }
|
|
func (t *Tags) SortArtist() string { return t.getSortTag("", "artist") }
|
|
func (t *Tags) SortAlbumArtist() string { return t.getSortTag("tso2", "albumartist", "album_artist") }
|
|
func (t *Tags) Genres() []string { return t.getAllTagValues("genre") }
|
|
func (t *Tags) Year() int { return t.getYear("date") }
|
|
func (t *Tags) Comment() string { return t.getFirstTagValue("comment") }
|
|
func (t *Tags) Lyrics() string { return t.getFirstTagValue("lyrics", "lyrics-eng") }
|
|
func (t *Tags) Compilation() bool { return t.getBool("tcmp", "compilation") }
|
|
func (t *Tags) TrackNumber() (int, int) { return t.getTuple("track", "tracknumber") }
|
|
func (t *Tags) DiscNumber() (int, int) { return t.getTuple("disc", "discnumber") }
|
|
func (t *Tags) DiscSubtitle() string {
|
|
return t.getFirstTagValue("tsst", "discsubtitle", "setsubtitle")
|
|
}
|
|
func (t *Tags) CatalogNum() string { return t.getFirstTagValue("catalognumber") }
|
|
func (t *Tags) Bpm() int { return (int)(math.Round(t.getFloat("tbpm", "bpm", "fbpm"))) }
|
|
func (t *Tags) HasPicture() bool { return t.getFirstTagValue("has_picture") != "" }
|
|
|
|
// MusicBrainz Identifiers
|
|
|
|
func (t *Tags) MbzTrackID() string { return t.getMbzID("musicbrainz_trackid", "musicbrainz track id") }
|
|
func (t *Tags) MbzAlbumID() string { return t.getMbzID("musicbrainz_albumid", "musicbrainz album id") }
|
|
func (t *Tags) MbzArtistID() string {
|
|
return t.getMbzID("musicbrainz_artistid", "musicbrainz artist id")
|
|
}
|
|
func (t *Tags) MbzAlbumArtistID() string {
|
|
return t.getMbzID("musicbrainz_albumartistid", "musicbrainz album artist id")
|
|
}
|
|
func (t *Tags) MbzAlbumType() string {
|
|
return t.getFirstTagValue("musicbrainz_albumtype", "musicbrainz album type")
|
|
}
|
|
func (t *Tags) MbzAlbumComment() string {
|
|
return t.getFirstTagValue("musicbrainz_albumcomment", "musicbrainz album comment")
|
|
}
|
|
|
|
// File properties
|
|
|
|
func (t *Tags) Duration() float32 { return float32(t.getFloat("duration")) }
|
|
func (t *Tags) BitRate() int { return t.getInt("bitrate") }
|
|
func (t *Tags) ModificationTime() time.Time { return t.fileInfo.ModTime() }
|
|
func (t *Tags) Size() int64 { return t.fileInfo.Size() }
|
|
func (t *Tags) FilePath() string { return t.filePath }
|
|
func (t *Tags) Suffix() string { return t.suffix }
|
|
|
|
func (t *Tags) getTags(tagNames ...string) []string {
|
|
allTags := append(tagNames, t.custom[tagNames[0]]...)
|
|
for _, tag := range allTags {
|
|
if v, ok := t.tags[tag]; ok {
|
|
return v
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (t *Tags) getFirstTagValue(tagNames ...string) string {
|
|
ts := t.getTags(tagNames...)
|
|
if len(ts) > 0 {
|
|
return ts[0]
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (t *Tags) getAllTagValues(tagNames ...string) []string {
|
|
tagNames = append(tagNames, t.custom[tagNames[0]]...)
|
|
var values []string
|
|
for _, tag := range tagNames {
|
|
if v, ok := t.tags[tag]; ok {
|
|
values = append(values, v...)
|
|
}
|
|
}
|
|
return values
|
|
}
|
|
|
|
func (t *Tags) getSortTag(originalTag string, tagNamess ...string) string {
|
|
formats := []string{"sort%s", "sort_%s", "sort-%s", "%ssort", "%s_sort", "%s-sort"}
|
|
all := []string{originalTag}
|
|
for _, tag := range tagNamess {
|
|
for _, format := range formats {
|
|
name := fmt.Sprintf(format, tag)
|
|
all = append(all, name)
|
|
}
|
|
}
|
|
return t.getFirstTagValue(all...)
|
|
}
|
|
|
|
var dateRegex = regexp.MustCompile(`([12]\d\d\d)`)
|
|
|
|
func (t *Tags) getYear(tagNames ...string) int {
|
|
tag := t.getFirstTagValue(tagNames...)
|
|
if tag == "" {
|
|
return 0
|
|
}
|
|
match := dateRegex.FindStringSubmatch(tag)
|
|
if len(match) == 0 {
|
|
log.Warn("Error parsing year date field", "file", t.filePath, "date", tag)
|
|
return 0
|
|
}
|
|
year, _ := strconv.Atoi(match[1])
|
|
return year
|
|
}
|
|
|
|
func (t *Tags) getBool(tagNames ...string) bool {
|
|
tag := t.getFirstTagValue(tagNames...)
|
|
if tag == "" {
|
|
return false
|
|
}
|
|
i, _ := strconv.Atoi(strings.TrimSpace(tag))
|
|
return i == 1
|
|
}
|
|
|
|
func (t *Tags) getTuple(tagNames ...string) (int, int) {
|
|
tag := t.getFirstTagValue(tagNames...)
|
|
if tag == "" {
|
|
return 0, 0
|
|
}
|
|
tuple := strings.Split(tag, "/")
|
|
t1, t2 := 0, 0
|
|
t1, _ = strconv.Atoi(tuple[0])
|
|
if len(tuple) > 1 {
|
|
t2, _ = strconv.Atoi(tuple[1])
|
|
} else {
|
|
t2tag := t.getFirstTagValue(tagNames[0] + "total")
|
|
t2, _ = strconv.Atoi(t2tag)
|
|
}
|
|
return t1, t2
|
|
}
|
|
|
|
func (t *Tags) getMbzID(tagNames ...string) string {
|
|
tag := t.getFirstTagValue(tagNames...)
|
|
if _, err := uuid.Parse(tag); err != nil {
|
|
return ""
|
|
}
|
|
return tag
|
|
}
|
|
|
|
func (t *Tags) getInt(tagNames ...string) int {
|
|
tag := t.getFirstTagValue(tagNames...)
|
|
i, _ := strconv.Atoi(tag)
|
|
return i
|
|
}
|
|
|
|
func (t *Tags) getFloat(tagNames ...string) float64 {
|
|
var tag = t.getFirstTagValue(tagNames...)
|
|
var value, err = strconv.ParseFloat(tag, 64)
|
|
if err != nil {
|
|
return 0
|
|
}
|
|
return value
|
|
}
|