Golang tag.Metadata类代码示例

// extractID3 attempts to extract MusicBrainz Picard tags from m.Raw(), where m.Format
// is assumed to be a supported version of ID3.
func extractID3(m tag.Metadata) Info {
	var txxx, ufid string
	switch m.Format() {
	case tag.ID3v2_2:
		txxx, ufid = "TXX", "UFI"
	case tag.ID3v2_3, tag.ID3v2_4:
		txxx, ufid = "TXXX", "UFID"
	}

	i := Info{}
	for k, v := range m.Raw() {
		switch {
		case strings.HasPrefix(k, txxx):
			if str, ok := v.(*tag.Comm); ok {
				i.set(str.Description, str.Text)
			}
		case strings.HasPrefix(k, ufid):
			if id, ok := v.(*tag.UFID); ok {
				if id.Provider == UFIDProviderURL {
					i.set(Recording, string(id.Identifier))
				}
			}
		}
	}
	return i
}

// Extract tags created by MusicBrainz Picard which can be used with with the MusicBrainz and LastFM APIs.
// See https://picard.musicbrainz.org/docs/mappings/ for more information.
func Extract(m tag.Metadata) Info {
	switch m.Format() {
	case tag.ID3v2_2, tag.ID3v2_3, tag.ID3v2_4:
		return extractID3(m)
	}
	return extractMP4Vorbis(m)
}

// extractMP4Vorbis attempts to extract MusicBrainz Picard tags from m.Raw(), where m.Format
// is assumed to be MP4 or VORBIS.
func extractMP4Vorbis(m tag.Metadata) Info {
	i := Info{}
	for t, v := range m.Raw() {
		if s, ok := v.(string); ok {
			i.set(t, s)
		}
	}
	return i
}

func dataURL(m tag.Metadata) string {
	p := m.Picture()
	if p == nil {
		return ""
	}
	if p.MIMEType == "-->" {
		return string(p.Data)
	}
	return fmt.Sprintf("data:%s;base64,%s", p.MIMEType, base64.StdEncoding.EncodeToString(p.Data))
}

// Get the new folder name
func getNewFolderName(m tag.Metadata) (string, error) {
	artist := m.AlbumArtist()

	if artist == "" {
		artist = m.Artist()
	}

	year := strconv.Itoa(m.Year())
	album := m.Album()

	if len(artist) == 0 {
		return "", errors.New("Artist not found")
	}

	if year == "0" {
		return "", errors.New("Year not found")
	}

	if len(album) == 0 {
		return "", errors.New("Album not found")
	}

	folder := artist + " - " + year + " - " + album

	return folder, nil
}

// Open the given file and return an http.File which contains the artwork, and hence
// the Name() of the returned file will have an extention for the artwork, not the
// media file.
func (afs artworkFileSystem) Open(ctx context.Context, path string) (http.File, error) {
	f, err := afs.FileSystem.Open(ctx, path)
	if err != nil {
		return nil, err
	}
	defer f.Close()

	stat, err := f.Stat()
	if err != nil {
		return nil, err
	}

	var m tag.Metadata
	m, err = tag.ReadFrom(f)
	if err != nil {
		return nil, fmt.Errorf("error extracting picture from '%v': %v", path, err)
	}

	p := m.Picture()
	if p == nil {
		return nil, fmt.Errorf("no picture attached to '%v'", path)
	}

	name := stat.Name()
	if p.Ext != "" {
		name += "." + p.Ext
	}

	return &file{
		ReadSeeker: bytes.NewReader(p.Data),
		stat: &fileInfo{
			name:    name,
			size:    int64(len(p.Data)),
			modTime: stat.ModTime(),
		},
	}, nil
}

func printMetadata(m tag.Metadata) {
	fmt.Printf("Metadata Format: %v\n", m.Format())
	fmt.Printf("File Type: %v\n", m.FileType())

	fmt.Printf(" Title: %v\n", m.Title())
	fmt.Printf(" Album: %v\n", m.Album())
	fmt.Printf(" Artist: %v\n", m.Artist())
	fmt.Printf(" Composer: %v\n", m.Composer())
	fmt.Printf(" Genre: %v\n", m.Genre())
	fmt.Printf(" Year: %v\n", m.Year())

	track, trackCount := m.Track()
	fmt.Printf(" Track: %v of %v\n", track, trackCount)

	disc, discCount := m.Disc()
	fmt.Printf(" Disc: %v of %v\n", disc, discCount)

	fmt.Printf(" Picture: %v\n", m.Picture())
	fmt.Printf(" Lyrics: %v\n", m.Lyrics())
}