feat: tag wav files with id3 and info chunks

2026-08-05 22:51:43 +02:00
parent b804c5e288
commit 84dd371fdd
4 changed files with 540 additions and 31 deletions
@@ -0,0 +1,256 @@
+package tag
+
+import (
+	"bytes"
+	"encoding/binary"
+	"errors"
+	"io"
+	"os"
+	"strings"
+
+	"github.com/bogem/id3v2/v2"
+)
+
+type wavTagger struct {
+	path string
+}
+
+type wavChunk struct {
+	id      string
+	payload []byte
+}
+
+type infoField struct {
+	id    string
+	value string
+}
+
+func (t *wavTagger) write(m Metadata) error {
+	id3Chunk, err := buildID3Chunk(m)
+	if err != nil {
+		return err
+	}
+
+	var chunks []wavChunk
+	if info := buildInfoChunk(m); info != nil {
+		chunks = append(chunks, wavChunk{id: "LIST", payload: info})
+	}
+	if id3Chunk != nil {
+		chunks = append(chunks, wavChunk{id: "id3 ", payload: id3Chunk})
+	}
+
+	return rewriteWAV(t.path, chunks)
+}
+
+func buildID3Chunk(m Metadata) ([]byte, error) {
+	tag := id3v2.NewEmptyTag()
+	applyID3Frames(tag, m)
+	if !tag.HasFrames() {
+		return nil, nil
+	}
+
+	var buf bytes.Buffer
+	if _, err := tag.WriteTo(&buf); err != nil {
+		return nil, err
+	}
+
+	return buf.Bytes(), nil
+}
+
+func buildInfoChunk(m Metadata) []byte {
+	fields := []infoField{
+		{"INAM", m.Title},
+		{"IART", m.Artists},
+		{"IGNR", m.Genre},
+		{"ITRK", m.TrackNumber},
+	}
+
+	if m.Album != nil {
+		date := m.Album.ReleaseDate
+		if parts := strings.Split(date, "-"); len(parts) == 3 {
+			date = parts[0]
+		}
+
+		fields = append(fields,
+			infoField{"IPRD", m.Album.Title},
+			infoField{"ICRD", date},
+			infoField{"ICMT", m.Album.ProducerLine},
+			infoField{"ICOP", m.Album.Copyright},
+		)
+	}
+
+	var buf bytes.Buffer
+	buf.WriteString("INFO")
+
+	for _, field := range fields {
+		if field.value == "" {
+			continue
+		}
+		writeChunk(&buf, field.id, append([]byte(field.value), 0))
+	}
+
+	if buf.Len() == 4 {
+		return nil
+	}
+
+	return buf.Bytes()
+}
+
+func writeChunk(w io.Writer, id string, payload []byte) {
+	header := make([]byte, 0, 8)
+	header = append(header, id...)
+	header = binary.LittleEndian.AppendUint32(header, uint32(len(payload)))
+
+	w.Write(header)
+	w.Write(payload)
+	if len(payload)%2 != 0 {
+		w.Write([]byte{0})
+	}
+}
+
+func rewriteWAV(path string, chunks []wavChunk) error {
+	src, err := os.Open(path)
+	if err != nil {
+		return err
+	}
+	defer src.Close()
+
+	header := make([]byte, 12)
+	if _, err := io.ReadFull(src, header); err != nil {
+		return err
+	}
+	if string(header[0:4]) != "RIFF" || string(header[8:12]) != "WAVE" {
+		return errors.New("not a wav file")
+	}
+
+	tmpPath := path + ".tmp"
+	dst, err := os.Create(tmpPath)
+	if err != nil {
+		return err
+	}
+	done := false
+	defer func() {
+		if !done {
+			dst.Close()
+			os.Remove(tmpPath)
+		}
+	}()
+
+	if _, err := dst.Write(header); err != nil {
+		return err
+	}
+
+	size, err := copyChunks(dst, src)
+	if err != nil {
+		return err
+	}
+
+	for _, chunk := range chunks {
+		var buf bytes.Buffer
+		writeChunk(&buf, chunk.id, chunk.payload)
+		if _, err := dst.Write(buf.Bytes()); err != nil {
+			return err
+		}
+		size += int64(buf.Len())
+	}
+
+	riffSize := make([]byte, 4)
+	binary.LittleEndian.PutUint32(riffSize, uint32(size))
+	if _, err := dst.WriteAt(riffSize, 4); err != nil {
+		return err
+	}
+
+	if err := dst.Sync(); err != nil {
+		return err
+	}
+	if err := dst.Close(); err != nil {
+		return err
+	}
+	if err := os.Rename(tmpPath, path); err != nil {
+		return err
+	}
+	done = true
+
+	return nil
+}
+
+func copyChunks(dst io.Writer, src io.Reader) (int64, error) {
+	size := int64(4)
+	head := make([]byte, 8)
+
+	for {
+		if _, err := io.ReadFull(src, head); err != nil {
+			if errors.Is(err, io.EOF) || errors.Is(err, io.ErrUnexpectedEOF) {
+				return size, nil
+			}
+			return size, err
+		}
+
+		id := string(head[0:4])
+		payloadSize := int64(binary.LittleEndian.Uint32(head[4:8]))
+
+		if id == "id3 " || id == "ID3 " {
+			if err := skipPayload(src, payloadSize); err != nil {
+				return size, err
+			}
+			continue
+		}
+
+		if id == "LIST" {
+			payload := make([]byte, payloadSize)
+			if _, err := io.ReadFull(src, payload); err != nil {
+				return size, err
+			}
+			if err := skipPad(src, payloadSize); err != nil {
+				return size, err
+			}
+			if bytes.HasPrefix(payload, []byte("INFO")) {
+				continue
+			}
+
+			var buf bytes.Buffer
+			writeChunk(&buf, id, payload)
+			if _, err := dst.Write(buf.Bytes()); err != nil {
+				return size, err
+			}
+			size += int64(buf.Len())
+
+			continue
+		}
+
+		if _, err := dst.Write(head); err != nil {
+			return size, err
+		}
+		if _, err := io.CopyN(dst, src, payloadSize); err != nil {
+			return size, err
+		}
+		size += 8 + payloadSize
+
+		if payloadSize%2 != 0 {
+			if _, err := dst.Write([]byte{0}); err != nil {
+				return size, err
+			}
+			size++
+			if err := skipPad(src, payloadSize); err != nil {
+				return size, err
+			}
+		}
+	}
+}
+
+func skipPayload(src io.Reader, payloadSize int64) error {
+	if _, err := io.CopyN(io.Discard, src, payloadSize); err != nil {
+		return err
+	}
+	return skipPad(src, payloadSize)
+}
+
+func skipPad(src io.Reader, payloadSize int64) error {
+	if payloadSize%2 == 0 {
+		return nil
+	}
+	if _, err := io.CopyN(io.Discard, src, 1); err != nil && !errors.Is(err, io.EOF) {
+		return err
+	}
+	return nil
+}