S.O.N.G/METANOIA
S.O.N.G/METANOIA
3
0
Fork 0
Code Issues Pull requests Releases Activity
METANOIA/handler/disc.go

905 lines
24 KiB
Go
Raw Blame History

package handler
import (
"bytes"
"encoding/base64"
"encoding/binary"
"facette.io/natsort"
"fmt"
"git.gammaspectra.live/S.O.N.G/Hibiki/panako"
"git.gammaspectra.live/S.O.N.G/Hibiki/utilities/specializedstore"
"git.gammaspectra.live/S.O.N.G/Kirika/audio"
"git.gammaspectra.live/S.O.N.G/Kirika/audio/format"
"git.gammaspectra.live/S.O.N.G/Kirika/audio/format/guess"
"git.gammaspectra.live/S.O.N.G/Kirika/audio/replaygain"
"git.gammaspectra.live/S.O.N.G/Kirika/hasher"
"git.gammaspectra.live/S.O.N.G/METANOIA/metadata"
"git.gammaspectra.live/S.O.N.G/METANOIA/utilities"
"github.com/dhowden/tag"
"github.com/oriser/regroup"
"io"
"io/ioutil"
"log"
"os"
"path"
"sort"
"strconv"
"strings"
"sync"
"sync/atomic"
"time"
"unicode"
)
type fileEntryList []fileEntry
const separatorTrimSet = ",.-_()[]{}"
func isSeparator(b byte) bool {
if b == ' ' {
return true
}
for i := 0; i < len(separatorTrimSet); i++ {
if separatorTrimSet[i] == b {
return true
}
}
return false
}
type analyzeEntry struct {
fileEntry
fileHandle *os.File
audioMetadata struct {
sampleRate int
channels int
samples int
}
replayGain struct {
albumGain float64
albumPeak float64
trackGain float64
trackPeak float64
}
fileMetadata tag.Metadata
panakoFingerprints []*panako.Fingerprint
hasherCrc32 *hasher.Hasher
hasherCueToolsCrc32 *hasher.Hasher
hasherAccurateRipV1 *hasher.Hasher
hasherAccurateRipV2 *hasher.Hasher
}
func (l fileEntryList) analyze(directory string, panakoInstance *panako.Instance) (entries []*analyzeEntry, fullCRC32 uint32, fullCTDBCRC32 uint32) {
var waitGroups []*sync.WaitGroup
printStrategy := panakoInstance.GetStrategy(specializedstore.NewMemoryStore(), audio.Linear)
var joinedCTDBChannels []format.AnalyzerChannel
var joinedChannels []format.AnalyzerChannel
var preLastTotalSamplesWaitGroup sync.WaitGroup
preLastTotalSamples := uint32(0)
var replayGainSources []audio.Source
for trackIndex, e := range l {
f, err := os.Open(path.Join(directory, e.Name))
if err != nil {
//TODO
log.Print(err)
continue
}
var source audio.Source
var analyzer format.AnalyzerChannel
meta, err := tag.ReadFrom(f)
if err != nil {
log.Print(err)
err = nil
}
f.Seek(0, io.SeekStart)
decoders, err := guess.GetDecoders(f, f.Name())
if err != nil { //cannot decode
//TODO
log.Print(err)
f.Close()
continue
}
if source, analyzer, err = guess.OpenAnalyzer(f, decoders); err != nil || source.Blocks == nil {
analyzer = nil
source, err = guess.Open(f, decoders)
}
if err != nil { //cannot decode
//TODO
log.Print(err)
f.Close()
continue
}
if source.Blocks == nil { //no known decoder
//TODO
log.Print(fmt.Errorf("no known decoder for %s", f.Name()))
f.Close()
continue
}
entry := &analyzeEntry{
fileEntry: e,
fileHandle: f,
fileMetadata: meta,
}
sources := source.Split(3)
var sinkWaitGroup sync.WaitGroup
sinkWaitGroup.Add(1)
preLastTotalSamplesWaitGroup.Add(1)
go func(source audio.Source, add bool) {
defer sinkWaitGroup.Done()
defer preLastTotalSamplesWaitGroup.Done()
entry.audioMetadata.sampleRate = source.SampleRate
entry.audioMetadata.channels = source.Channels
var samples int
for block := range source.Blocks {
samples += len(block) / source.Channels
}
entry.audioMetadata.samples = samples
if add {
atomic.AddUint32(&preLastTotalSamples, uint32(samples))
}
}(sources[0], trackIndex < len(l)-1)
sinkWaitGroup.Add(1)
go func(add bool) {
defer sinkWaitGroup.Done()
entry.panakoFingerprints = printStrategy.BlockChannelToFingerprints(sources[1].Blocks)
}(trackIndex < len(l)-1)
replayGainSources = append(replayGainSources, sources[2])
//TODO: handle extra appended/prepended silence
if analyzer != nil {
if trackIndex == 0 {
channels := analyzer.Split(4)
joinedChannels = append(joinedChannels, channels[0])
ctChannels := channels[1].SkipStartSamples(metadata.Int16SamplesPerSector * 10).Split(2)
joinedCTDBChannels = append(joinedCTDBChannels, ctChannels[0])
entry.hasherCueToolsCrc32 = hasher.NewHasher(ctChannels[1], hasher.HashtypeCrc32)
arChannels := channels[2].SkipStartSamples(metadata.Int16SamplesPerSector*5 - 1).Split(2)
entry.hasherAccurateRipV1 = hasher.NewHasher(arChannels[0], hasher.HashtypeAccurateRipV1Start)
entry.hasherAccurateRipV2 = hasher.NewHasher(arChannels[1], hasher.HashtypeAccurateRipV2Start)
entry.hasherCrc32 = hasher.NewHasher(channels[3], hasher.HashtypeCrc32)
} else if trackIndex == len(l)-1 {
channels := analyzer.Split(4)
joinedChannels = append(joinedChannels, channels[0])
ctChannels := channels[1].SkipEndSamplesMultiple(&preLastTotalSamplesWaitGroup, &preLastTotalSamples, metadata.Int16SamplesPerSector*10).Split(2)
joinedCTDBChannels = append(joinedCTDBChannels, ctChannels[0])
entry.hasherCueToolsCrc32 = hasher.NewHasher(ctChannels[1], hasher.HashtypeCrc32)
arChannels := channels[2].SkipEndSamples(metadata.Int16SamplesPerSector * 5).Split(2)
entry.hasherAccurateRipV1 = hasher.NewHasher(arChannels[0], hasher.HashtypeAccurateRipV1)
entry.hasherAccurateRipV2 = hasher.NewHasher(arChannels[1], hasher.HashtypeAccurateRipV2)
entry.hasherCrc32 = hasher.NewHasher(channels[3], hasher.HashtypeCrc32)
} else {
channels := analyzer.Split(5)
joinedChannels = append(joinedChannels, channels[0])
joinedCTDBChannels = append(joinedCTDBChannels, channels[1])
entry.hasherCrc32 = hasher.NewHasher(channels[2], hasher.HashtypeCrc32)
entry.hasherAccurateRipV1 = hasher.NewHasher(channels[3], hasher.HashtypeAccurateRipV1)
entry.hasherAccurateRipV2 = hasher.NewHasher(channels[4], hasher.HashtypeAccurateRipV2)
}
waitGroups = append(waitGroups, entry.hasherCrc32.GetWaitGroup(), entry.hasherAccurateRipV1.GetWaitGroup(), entry.hasherAccurateRipV2.GetWaitGroup())
if entry.hasherCueToolsCrc32 != nil {
waitGroups = append(waitGroups, entry.hasherCueToolsCrc32.GetWaitGroup())
}
}
waitGroups = append(waitGroups, &sinkWaitGroup)
entries = append(entries, entry)
}
var rgwg sync.WaitGroup
rgwg.Add(1)
go func() {
defer rgwg.Done()
albumGain, albumPeak, trackGains, trackPeaks, err := replaygain.GetAlbumReplayGain(replayGainSources)
if err != nil {
return
}
for i, e := range entries {
e.replayGain.albumGain = albumGain
e.replayGain.albumPeak = albumPeak
e.replayGain.trackGain = trackGains[i]
e.replayGain.trackPeak = trackPeaks[i]
}
}()
waitGroups = append(waitGroups, &rgwg)
fullHasher := hasher.NewHasher(format.MergeHasherChannels(joinedChannels...), hasher.HashtypeCrc32)
fullCTDBHasher := hasher.NewHasher(format.MergeHasherChannels(joinedCTDBChannels...), hasher.HashtypeCrc32)
fullHasher.Wait()
fullCTDBHasher.Wait()
fullCRC32 = binary.BigEndian.Uint32(fullHasher.GetResult())
fullCTDBCRC32 = binary.BigEndian.Uint32(fullCTDBHasher.GetResult())
//Wait for all tasks
for _, wg := range waitGroups {
wg.Wait()
}
return
}
type fileEntry struct {
Name string
NormalizedSortName string
NormalizedName string
}
func processAudioFiles(files []string) (result fileEntryList) {
result = make(fileEntryList, 0, len(files))
for _, f := range files {
normalized := utilities.NormalizeUnicode(f)
ext := strings.LastIndex(normalized, ".")
for k := 0; k < ext; k++ {
index := strings.IndexFunc(normalized[k:], unicode.IsNumber)
if index == -1 {
//wtf, no numbers?
result = append(result, fileEntry{
Name: f,
NormalizedSortName: strings.TrimSpace(strings.TrimLeft(strings.TrimSpace(normalized[:ext]), separatorTrimSet)),
NormalizedName: strings.TrimSpace(strings.TrimLeft(strings.TrimSpace(normalized[:ext]), separatorTrimSet)),
})
break
}
index += k
if index == 0 || isSeparator(normalized[index-1]) { //If it's start of string or prefixed by a space
normalized = normalized[index:ext]
firstNotNumber := strings.IndexFunc(normalized, func(r rune) bool {
return !unicode.IsNumber(r)
})
r := fileEntry{
Name: f,
NormalizedSortName: strings.TrimSpace(strings.TrimLeft(strings.TrimSpace(normalized), separatorTrimSet)),
NormalizedName: strings.TrimSpace(strings.TrimLeft(strings.TrimSpace(normalized[firstNotNumber:]), separatorTrimSet)),
}
result = append(result, r)
break
}
k = index
}
}
//Sort files naturally
sort.SliceStable(result, func(i, j int) bool {
return natsort.Compare(result[i].NormalizedSortName, result[j].NormalizedSortName)
})
return
}
type DiscHandlerResult struct {
TOC metadata.TOC
CRC32 uint32
CueToolsCRC32 uint32
Directory string
Tracks []DiscHandlerTrack
CommonMetadata map[string]string
Identifiers metadata.NameSlice
//DiscNumber 1-indexed disc number
DiscNumber int
DiscTotal int
Album string
ReplayGain struct {
Gain float64
Peak float64
}
}
func (d *DiscHandlerResult) ToMetadataAlbum() (album *metadata.Album) {
album = &metadata.Album{
SourceUniqueIdentifier: d.Directory,
License: metadata.License{
Code: metadata.Unknown,
},
Name: metadata.NameSlice{
{Kind: "file", Name: d.Album},
},
Identifiers: metadata.NameSlice{},
}
diskIds := make(metadata.NameSlice, 0)
diskIds = append(diskIds, metadata.Name{
Kind: "toc",
Name: d.TOC.String(),
})
diskIds = append(diskIds, metadata.Name{
Kind: "crc32",
Name: fmt.Sprintf("%08X", d.CRC32),
})
diskIds = append(diskIds, metadata.Name{
Kind: "ctdb_crc32",
Name: fmt.Sprintf("%08X", d.CueToolsCRC32),
})
for _, id := range d.Identifiers {
if id.Kind == "album" {
album.Name = append(album.Name, metadata.Name{
Kind: "file",
Name: id.Name,
})
} else if id.Kind == "catalog" {
album.Identifiers = append(album.Identifiers, id)
} else if id.Kind == "toc" || id.Kind == "cddb1" || id.Kind == "discid" {
diskIds = append(diskIds, id)
}
}
for k, v := range d.CommonMetadata {
if k == "date" {
if album.ReleaseDate, _ = time.ParseInLocation("2006.01.02", v, time.UTC); album.ReleaseDate.IsZero() {
if album.ReleaseDate, _ = time.ParseInLocation("2006-01-02", v, time.UTC); album.ReleaseDate.IsZero() {
album.ReleaseDate, _ = time.ParseInLocation("2006", v, time.UTC)
}
}
} else if k == "event" {
album.Links = append(album.Links, metadata.Link{
Kind: "release",
Name: metadata.NameSlice{
{Kind: "name", Name: v},
},
})
} else if k == "albumartist" || k == "artist" || k == "composer" || k == "mastering" || k == "performer" {
album.Roles = append(album.Roles, metadata.Role{
Kind: k,
Name: metadata.NameSlice{
{Kind: "file", Name: v},
},
})
} else if k == "lyricist" {
album.Roles = append(album.Roles, metadata.Role{
Kind: "lyrics",
Name: metadata.NameSlice{
{Kind: "file", Name: v},
},
})
} else if k == "guitar" {
album.Roles = append(album.Roles, metadata.Role{
Kind: "performer, guitar",
Name: metadata.NameSlice{
{Kind: "file", Name: v},
},
})
} else if k == "arrange" {
album.Roles = append(album.Roles, metadata.Role{
Kind: "arranger",
Name: metadata.NameSlice{
{Kind: "file", Name: v},
},
})
} else if k == "vocal" || k == "chorus" {
album.Roles = append(album.Roles, metadata.Role{
Kind: "vocals",
Name: metadata.NameSlice{
{Kind: "file", Name: v},
},
})
}
}
var arts []pictureEntry
discNumber := d.DiscNumber
discTotal := d.DiscTotal
if discTotal <= 0 {
discTotal = 1
}
if discNumber <= 0 || discNumber > discTotal {
discNumber = 1
}
album.Discs = make([]metadata.Disc, discTotal)
disc := metadata.Disc{
Identifiers: diskIds,
}
for _, track := range d.Tracks {
t := metadata.Track{
Name: metadata.NameSlice{
{Kind: "file", Name: track.TrackName},
},
Roles: make(metadata.RoleSlice, 0),
Duration: track.AudioMetadata.Duration,
}
if track.Fingerprints.CRC32 != 0 || track.Fingerprints.CueToolsCRC32 != 0 {
t.Identifiers = metadata.NameSlice{
{Kind: "crc32", Name: fmt.Sprintf("%08X", track.Fingerprints.CRC32)},
{Kind: "ctdb_crc32", Name: fmt.Sprintf("%08X", track.Fingerprints.CueToolsCRC32)},
{Kind: "accurateripv1", Name: fmt.Sprintf("%08X", track.Fingerprints.AccurateRipV1)},
{Kind: "accurateripv2", Name: fmt.Sprintf("%08X", track.Fingerprints.AccurateRipV2)},
}
}
if len(track.FileMetadata.Title) > 0 {
t.Name = append(t.Name, metadata.Name{
Kind: "file",
Name: track.FileMetadata.Title,
})
}
if len(track.FileMetadata.OriginalTitle) > 0 {
t.Links = append(t.Links, metadata.Link{
Kind: "original release title",
Name: metadata.NameSlice{
{Kind: "file", Name: track.FileMetadata.OriginalTitle},
},
})
}
for _, artist := range track.FileMetadata.Artists {
role := metadata.Role{
Kind: artist.Kind,
Name: metadata.NameSlice{
{Kind: "file", Name: artist.Name},
},
}
//only add when not shared
if album.Roles.Exists(role, false) == -1 {
t.Roles = append(t.Roles, role)
}
}
//TODO: check track number again?
if track.FileMetadata.Lyrics != "" {
//TODO: guess format?
lyrics := []metadata.Lyrics{
&metadata.TextLyrics{
Entries: strings.Split(strings.ReplaceAll(track.FileMetadata.Lyrics, "\r", ""), "\n\n"),
},
}
t.Lyrics = func() []metadata.Lyrics {
return lyrics
}
}
if len(track.FileMetadata.EmbeddedPicture.Data) > 0 {
for _, e := range arts {
if bytes.Compare(e.Data, track.FileMetadata.EmbeddedPicture.Data) == 0 {
goto skipAdd
}
}
arts = append(arts, track.FileMetadata.EmbeddedPicture)
skipAdd:
}
disc.Tracks = append(disc.Tracks, t)
}
//TODO: load files in current directory, find album art, then look for scans
for _, a := range arts {
mime := "application/octet-stream"
if a.Mime != "" {
mime = a.Mime
}
pictureType := "other"
if a.Kind == "" || strings.Index(strings.ToLower(a.Kind), "front") != -1 {
pictureType = "front"
} else if strings.Index(strings.ToLower(a.Kind), "back") != -1 {
pictureType = "back"
}
album.Art = append(album.Art, metadata.Name{
Kind: pictureType,
Name: fmt.Sprintf("data:%s;base64,%s", mime, base64.StdEncoding.EncodeToString(a.Data)),
})
}
album.Discs[discNumber-1] = disc
return album
}
type DiscHandlerTrack struct {
FileName string
TrackName string
SortName string
Fingerprints struct {
Panako []*panako.Fingerprint
CRC32 uint32
CueToolsCRC32 uint32
AccurateRipV1 uint32
AccurateRipV2 uint32
}
FileMetadata struct {
DiscNumber int
Artists metadata.NameSlice
Album string
Year int
TrackNumber int
Title string
OriginalTitle string
Lyrics string
EmbeddedPicture pictureEntry
}
AudioMetadata struct {
SampleRate int
Channels int
NumberOfFullSamples int
Duration time.Duration
ReplayGain struct {
Gain float64
Peak float64
}
}
}
type pictureEntry struct {
Kind string
Data []byte
Mime string
}
func HandleDiscEntry(panakoInstance *panako.Instance, pathEntry string) *DiscHandlerResult {
log.Printf("Handling %q", pathEntry)
entries, err := ioutil.ReadDir(pathEntry)
if err != nil {
return nil
}
var audioFiles []string
var imageFiles []string
var metadataFiles []string
var folders []string
for _, entry := range entries {
if !entry.IsDir() {
ext := path.Ext(entry.Name())
mime := utilities.GetMimeTypeFromExtension(ext)
isAudio := mime[0:6] == "audio/"
isAudioMetadata := mime == "text/x-log" || mime == "text/x-accurip" || mime == "text/x-cue" || mime == "text/x-toc"
isImage := mime[0:6] == "image/"
if isAudio {
audioFiles = append(audioFiles, entry.Name())
} else if isImage {
imageFiles = append(imageFiles, entry.Name())
} else if isAudioMetadata {
metadataFiles = append(metadataFiles, entry.Name())
}
} else {
folders = append(folders, entry.Name())
}
}
if len(audioFiles) == 0 {
return nil
}
sortedAudioEntries := processAudioFiles(audioFiles)
disc := &DiscHandlerResult{
Directory: pathEntry,
TOC: metadata.TOC{metadata.TocPregap},
CommonMetadata: make(map[string]string),
}
result, fullCRC32, fullCTDBCRC32 := sortedAudioEntries.analyze(pathEntry, panakoInstance)
defer func() {
for _, entry := range result {
entry.fileHandle.Close()
}
}()
disc.CRC32 = fullCRC32
disc.CueToolsCRC32 = fullCTDBCRC32
var discNumber int
var discTotal int
for _, entry := range result {
track := DiscHandlerTrack{
FileName: entry.Name,
TrackName: entry.NormalizedName,
SortName: entry.NormalizedSortName,
}
track.AudioMetadata.SampleRate = entry.audioMetadata.sampleRate
track.AudioMetadata.Channels = entry.audioMetadata.channels
track.AudioMetadata.NumberOfFullSamples = entry.audioMetadata.samples
track.AudioMetadata.ReplayGain.Gain = entry.replayGain.trackGain
track.AudioMetadata.ReplayGain.Peak = entry.replayGain.trackPeak
disc.ReplayGain.Gain = entry.replayGain.albumGain
disc.ReplayGain.Peak = entry.replayGain.albumPeak
track.AudioMetadata.Duration = time.Duration(float64(time.Second) * float64(track.AudioMetadata.NumberOfFullSamples) / float64(track.AudioMetadata.SampleRate))
track.Fingerprints.Panako = entry.panakoFingerprints
disc.TOC = append(disc.TOC, disc.TOC[len(disc.TOC)-1]+track.AudioMetadata.NumberOfFullSamples/metadata.Int16SamplesPerSector)
if entry.hasherCrc32 != nil {
track.Fingerprints.CRC32 = binary.BigEndian.Uint32(entry.hasherCrc32.GetResult())
track.Fingerprints.CueToolsCRC32 = track.Fingerprints.CRC32
}
if entry.hasherCueToolsCrc32 != nil {
track.Fingerprints.CueToolsCRC32 = binary.BigEndian.Uint32(entry.hasherCueToolsCrc32.GetResult())
}
if entry.hasherAccurateRipV1 != nil {
track.Fingerprints.AccurateRipV1 = binary.BigEndian.Uint32(entry.hasherAccurateRipV1.GetResult())
}
if entry.hasherAccurateRipV2 != nil {
track.Fingerprints.AccurateRipV2 = binary.BigEndian.Uint32(entry.hasherAccurateRipV2.GetResult())
}
track.FileMetadata.DiscNumber, _ = entry.fileMetadata.Disc()
track.FileMetadata.TrackNumber, _ = entry.fileMetadata.Track()
track.FileMetadata.Year = entry.fileMetadata.Year()
if entry.fileMetadata.Artist() != "" {
track.FileMetadata.Artists = append(track.FileMetadata.Artists, metadata.Name{
Kind: "artist",
Name: entry.fileMetadata.Artist(),
})
}
if entry.fileMetadata.AlbumArtist() != "" {
track.FileMetadata.Artists = append(track.FileMetadata.Artists, metadata.Name{
Kind: "albumartist",
Name: entry.fileMetadata.AlbumArtist(),
})
}
if entry.fileMetadata.Composer() != "" {
track.FileMetadata.Artists = append(track.FileMetadata.Artists, metadata.Name{
Kind: "composer",
Name: entry.fileMetadata.Composer(),
})
}
n, t := entry.fileMetadata.Disc()
if n != 0 && discNumber != -1 {
if discNumber == 0 {
discNumber = n
} else if discNumber != n {
discNumber = -1
}
}
if t != 0 && discTotal != -1 {
if discTotal == 0 {
discTotal = t
} else if discTotal != t {
discTotal = -1
}
}
track.FileMetadata.Lyrics = entry.fileMetadata.Lyrics()
rawValues := entry.fileMetadata.Raw()
for k, v := range rawValues {
str, ok := v.(string)
if !ok {
var number int
number, ok = v.(int)
if ok {
str = fmt.Sprint(number)
}
}
if ok && len(str) > 0 {
if k == "mastering" {
track.FileMetadata.Artists = append(track.FileMetadata.Artists, metadata.Name{
Kind: "mastering",
Name: str,
})
}
if k == "lyricist" {
track.FileMetadata.Artists = append(track.FileMetadata.Artists, metadata.Name{
Kind: "lyrics",
Name: str,
})
}
if k == "guitar" {
track.FileMetadata.Artists = append(track.FileMetadata.Artists, metadata.Name{
Kind: "performer, guitar",
Name: str,
})
}
if k == "arrange" {
track.FileMetadata.Artists = append(track.FileMetadata.Artists, metadata.Name{
Kind: "arranger",
Name: str,
})
}
if k == "vocal" {
track.FileMetadata.Artists = append(track.FileMetadata.Artists, metadata.Name{
Kind: "vocals",
Name: str,
})
}
if k == "chorus" {
track.FileMetadata.Artists = append(track.FileMetadata.Artists, metadata.Name{
Kind: "vocals",
Name: str,
})
}
if k == "performer" {
track.FileMetadata.Artists = append(track.FileMetadata.Artists, metadata.Name{
Kind: "performer",
Name: str,
})
}
if k == "originaltitle" {
track.FileMetadata.OriginalTitle = str
}
if k == "unsyncedlyrics" && track.FileMetadata.Lyrics == "" {
track.FileMetadata.Lyrics = str
}
value, exists := disc.CommonMetadata[k]
if !exists {
disc.CommonMetadata[k] = str
} else if len(value) > 0 && value != str {
disc.CommonMetadata[k] = ""
}
}
}
for k := range disc.CommonMetadata {
_, exists := rawValues[k]
if !exists {
disc.CommonMetadata[k] = ""
}
}
track.FileMetadata.Album = entry.fileMetadata.Album()
track.FileMetadata.Title = entry.fileMetadata.Title()
if p := entry.fileMetadata.Picture(); p != nil {
track.FileMetadata.EmbeddedPicture.Kind = p.Type
track.FileMetadata.EmbeddedPicture.Mime = p.MIMEType
track.FileMetadata.EmbeddedPicture.Data = p.Data
}
disc.Tracks = append(disc.Tracks, track)
}
for k, v := range disc.CommonMetadata {
if v == "" {
delete(disc.CommonMetadata, k)
}
}
if discNumber > 0 {
disc.DiscNumber = discNumber
}
if discNumber <= discTotal && discTotal > 0 {
disc.DiscTotal = discTotal
}
if catno, ok := disc.CommonMetadata["catalogid"]; ok {
for _, n := range strings.Split(catno, ";") {
disc.Identifiers = append(disc.Identifiers, metadata.Name{
Kind: "catalog",
Name: n,
})
}
}
if catno, ok := disc.CommonMetadata["catalognumber"]; ok {
for _, n := range strings.Split(catno, ";") {
disc.Identifiers = append(disc.Identifiers, metadata.Name{
Kind: "catalog",
Name: n,
})
}
}
if catno, ok := disc.CommonMetadata["labelno"]; ok {
for _, n := range strings.Split(catno, ";") {
disc.Identifiers = append(disc.Identifiers, metadata.Name{
Kind: "catalog",
Name: n,
})
}
}
if album, ok := disc.CommonMetadata["TALB"]; ok { //ID3v2;
disc.Identifiers = append(disc.Identifiers, metadata.Name{
Kind: "album",
Name: album,
})
disc.Album = album
}
if album, ok := disc.CommonMetadata["album"]; ok {
disc.Identifiers = append(disc.Identifiers, metadata.Name{
Kind: "album",
Name: album,
})
disc.Album = album
}
if discid, ok := disc.CommonMetadata["discid"]; ok {
disc.Identifiers = append(disc.Identifiers, metadata.Name{
Kind: "cddb1",
Name: discid,
})
}
if mbDiscId, ok := disc.CommonMetadata["musicbrainz_discid"]; ok {
disc.Identifiers = append(disc.Identifiers, metadata.Name{
Kind: "discid",
Name: mbDiscId,
})
}
if cdtoc, ok := disc.CommonMetadata["cdtoc"]; ok {
toc := metadata.TOC{}
for _, v := range strings.Split(cdtoc, "+")[1:] {
if number, err := strconv.ParseInt(v, 16, 0); err == nil {
toc = append(toc, int(number))
} else {
toc = metadata.TOC{}
break
}
}
if len(toc) > 0 {
toc = append(metadata.TOC{toc[len(toc)-1]}, toc[0:len(toc)-1]...)
disc.Identifiers = append(disc.Identifiers, metadata.Name{
Kind: "toc",
Name: toc.String(),
})
}
}
catalogRE := regroup.MustCompile(`(?i)[\[\(\{](?P<catno>(?:[a-z]{2,}-?[0-9][a-z0-9\-~]*)|(?:[0-9 ]{5,}))[\}\)\]]`)
m := &struct {
CatalogNumber string `regroup:"catno"`
}{}
if err = catalogRE.MatchToTarget(utilities.NormalizeUnicode(disc.Directory), m); err == nil {
//todo handle catalog number ranges
disc.Identifiers = append(disc.Identifiers, metadata.Name{
Kind: "catalog",
Name: m.CatalogNumber,
})
}
//TODO: get disc number via path
disc.TOC = append(metadata.TOC{disc.TOC[len(disc.TOC)-1]}, disc.TOC[0:len(disc.TOC)-1]...)
return disc
}
Reference in a new issue View git blame Copy permalink