Unbewohnte
/
id3ed
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

❖ Simplified V1 ❖

main
Unbewohnte 3 years ago
parent
4207d8f1aa
commit
7bcbb733d3
13 changed files with 104 additions and 392 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. BIN
      testData/testwritev1.mp3
  2. 4
      util/conversion.go
  3. 3
      v1/constants.go
  4. 85
      v1/id3v11_test.go
  5. 62
      v1/read.go
  6. 6
      v1/tag.go
  7. 15
      v1/v11tag.go
  8. 129
      v1/v11write.go
  9. 26
      v1/v1_test.go
  10. 80
      v1/v1read.go
  11. 44
      v1/write.go
  12. 6
      v2/constants.go
  13. 36
      v2/v2tag.go

BIN
testData/testwritev1.mp3
View File

Binary file not shown.

4
util/conversion.go
Unescape View File

@ -7,8 +7,8 @@ import (
) )
// Decodes given byte into integer // Decodes given byte into integer
func ByteToInt(gByte byte) (int64, error) { func ByteToInt(gByte byte) (int, error) {
integer, err := strconv.ParseInt(fmt.Sprintf("%d", gByte), 10, 64) integer, err := strconv.Atoi(fmt.Sprintf("%d", gByte))
if err != nil { if err != nil {
return 0, err return 0, err
} }

3
v1/constants.go
Unescape View File

@ -3,3 +3,6 @@ package v1
const ID3v1IDENTIFIER string = "TAG" const ID3v1IDENTIFIER string = "TAG"
const ID3v1SIZE int = 128 // bytes const ID3v1SIZE int = 128 // bytes
const ID3v1INVALIDGENRE int = 255 const ID3v1INVALIDGENRE int = 255
const V1_0 string = "ID3v1.0"
const V1_1 string = "ID3v1.1"

85
v1/id3v11_test.go
Unescape View File

@ -1,85 +0,0 @@
package v1
import (
"fmt"
"os"
"path/filepath"
"testing"
)
var TESTV11TAG = &ID3v11Tag{
SongName: "testsong",
Artist: "testartist",
Album: "testalbum",
Year: 727,
Comment: "testcomment",
Track: 5,
Genre: "Blues",
}
func TestGetID3v11Tags(t *testing.T) {
testfile, err := os.Open(filepath.Join(TESTDATAPATH, "testreadv1.mp3"))
if err != nil {
t.Errorf("could not open file for testing: %s", err)
}
mp3tags, err := Getv11Tag(testfile)
if err != nil {
t.Errorf("GetID3v11Tag failed: %s", err)
}
if mp3tags.Artist != "Artist" {
fmt.Printf("%v", mp3tags.Artist)
t.Errorf("GetID3v11Tag failed: expected artist %s; got %s", "Artist", mp3tags.Artist)
}
if mp3tags.Track != 8 {
t.Errorf("GetID3v11Tag failed: expected track %d; got %d", 8, mp3tags.Track)
}
}
// WILL ADD NEW "TAG" WITHOUT REMOVING THE OLD ONE !!!
func TestWriteID3v11Tags(t *testing.T) {
f, err := os.OpenFile(filepath.Join(TESTDATAPATH, "testwritev1.mp3"), os.O_CREATE|os.O_RDWR, os.ModePerm)
if err != nil {
t.Errorf("%s", err)
}
defer f.Close()
tag := TESTV11TAG
err = tag.Write(f)
if err != nil {
t.Errorf("WriteID3v1Tags failed: %s", err)
}
readTags, err := Getv11Tag(f)
if err != nil {
t.Errorf("%s", err)
}
if readTags.Album != "testalbum" {
t.Errorf("WriteID3v11Tag failed: expected album %s; got %s", "testalbum", readTags.Album)
}
if readTags.Year != 727 {
t.Errorf("WriteID3v11Tag failed: expected year %d; got %d", 727, readTags.Year)
}
if readTags.Track != 10 {
t.Errorf("WriteID3v11Tag failed: expected track %d; got %d", 10, readTags.Track)
}
}
func TestWriteID3v11ToFile(t *testing.T) {
f, err := os.OpenFile(filepath.Join(TESTDATAPATH, "testwritev1.mp3"), os.O_CREATE|os.O_RDWR, os.ModePerm)
if err != nil {
t.Errorf("%s", err)
}
tag := TESTV11TAG
err = tag.WriteToFile(f)
if err != nil {
t.Errorf("WriteID3v1ToFile failed: %s", err)
}
}

62
v1/v11read.go → v1/read.go
Unescape View File

@ -9,14 +9,17 @@ import (
"github.com/Unbewohnte/id3ed/util" "github.com/Unbewohnte/id3ed/util"
) )
// Retrieves ID3v1.1 field values of provided io.ReadSeeker // Retrieves ID3v1 field values of provided io.ReadSeeker (usually a file)
func Getv11Tag(rs io.ReadSeeker) (*ID3v11Tag, error) { func Getv1Tag(rs io.ReadSeeker) (*ID3v1Tag, error) {
var tag ID3v1Tag
// set reader to the last 128 bytes // set reader to the last 128 bytes
_, err := rs.Seek(-int64(ID3v1SIZE), io.SeekEnd) _, err := rs.Seek(-int64(ID3v1SIZE), io.SeekEnd)
if err != nil { if err != nil {
return nil, fmt.Errorf("could not seek: %s", err) return nil, fmt.Errorf("could not seek: %s", err)
} }
// ID
identifier, err := util.Read(rs, 3) identifier, err := util.Read(rs, 3)
if err != nil { if err != nil {
return nil, err return nil, err
@ -27,21 +30,28 @@ func Getv11Tag(rs io.ReadSeeker) (*ID3v11Tag, error) {
return nil, fmt.Errorf("does not use ID3v1: expected %s; got %s", ID3v1IDENTIFIER, identifier) return nil, fmt.Errorf("does not use ID3v1: expected %s; got %s", ID3v1IDENTIFIER, identifier)
} }
// Songname
songname, err := util.ReadToString(rs, 30) songname, err := util.ReadToString(rs, 30)
if err != nil { if err != nil {
return nil, err return nil, err
} }
tag.SongName = songname
// Artist
artist, err := util.ReadToString(rs, 30) artist, err := util.ReadToString(rs, 30)
if err != nil { if err != nil {
return nil, err return nil, err
} }
tag.Artist = artist
// Album name
album, err := util.ReadToString(rs, 30) album, err := util.ReadToString(rs, 30)
if err != nil { if err != nil {
return nil, err return nil, err
} }
tag.Album = album
// Year
yearStr, err := util.ReadToString(rs, 4) yearStr, err := util.ReadToString(rs, 4)
if err != nil { if err != nil {
return nil, err return nil, err
@ -50,28 +60,31 @@ func Getv11Tag(rs io.ReadSeeker) (*ID3v11Tag, error) {
if err != nil { if err != nil {
return nil, fmt.Errorf("could not convert yearbytes into int: %s", err) return nil, fmt.Errorf("could not convert yearbytes into int: %s", err)
} }
tag.Year = year
comment, err := util.ReadToString(rs, 28) // Comment and Track
if err != nil { comment, err := util.Read(rs, 30)
return nil, err
}
// skip 1 null byte
_, err = util.Read(rs, 1)
if err != nil { if err != nil {
return nil, err return nil, err
} }
tag.Comment = util.ToString(comment)
tag.Track = 0
trackByte, err := util.Read(rs, 1) var track int = 0
if err != nil { // check if 29th byte is null byte (v1.0 or v1.1)
return nil, err if comment[28] == 0 {
} // it is v1.1, track number exists
track, err = util.ByteToInt(comment[29])
if err != nil {
return nil, fmt.Errorf("could not get int from byte: %s", err)
}
tag.Track = uint8(track)
track, err := util.ByteToInt(trackByte[0]) comment = comment[0:28]
if err != nil { tag.Comment = util.ToString(comment)
return nil, fmt.Errorf("cannot convert bytes to int: %s", err)
} }
// Genre
genreByte, err := util.Read(rs, 1) genreByte, err := util.Read(rs, 1)
if err != nil { if err != nil {
return nil, err return nil, err
@ -84,14 +97,13 @@ func Getv11Tag(rs io.ReadSeeker) (*ID3v11Tag, error) {
if !exists { if !exists {
genre = "" genre = ""
} }
tag.Genre = genre
if track == 0 {
tag.Version = V1_0
} else {
tag.Version = V1_1
}
return &ID3v11Tag{ return &tag, nil
SongName: songname,
Artist: artist,
Album: album,
Year: year,
Comment: comment,
Track: int(track),
Genre: genre,
}, nil
} }

6
v1/v1tag.go → v1/tag.go
Unescape View File

@ -3,14 +3,12 @@ package v1
// https://id3.org/ID3v1 - documentation // https://id3.org/ID3v1 - documentation
type ID3v1Tag struct { type ID3v1Tag struct {
Version string
SongName string SongName string
Artist string Artist string
Album string Album string
Year int Year int
Comment string Comment string
Track uint8 // basically a byte, but converted to int for convenience
Genre string Genre string
} }
func (*ID3v1Tag) Version() int {
return 10
}

15
v1/v11tag.go
Unescape View File

@ -1,15 +0,0 @@
package v1
type ID3v11Tag struct {
SongName string
Artist string
Album string
Year int
Comment string
Track int
Genre string
}
func (*ID3v11Tag) Version() int {
return 11
}

129
v1/v11write.go
Unescape View File

@ -1,129 +0,0 @@
package v1
import (
"bytes"
"encoding/binary"
"fmt"
"io"
"os"
"github.com/Unbewohnte/id3ed/util"
)
// Writes given ID3v1.1 tag to dst
// NOTE: will not remove already existing ID3v1.1 tag if it`s present,
// use ⁕WriteToFile⁕ method if you`re working with REAL mp3 files !!!
func (tag *ID3v11Tag) Write(dst io.WriteSeeker) error {
dst.Seek(0, io.SeekEnd)
// TAG
_, err := dst.Write([]byte(ID3v1IDENTIFIER))
if err != nil {
return fmt.Errorf("could not write to dst: %s", err)
}
// Song name
err = util.WriteToExtent(dst, []byte(tag.SongName), 30)
if err != nil {
return fmt.Errorf("could not write to dst: %s", err)
}
// Artist
err = util.WriteToExtent(dst, []byte(tag.Artist), 30)
if err != nil {
return fmt.Errorf("could not write to dst: %s", err)
}
// Album
err = util.WriteToExtent(dst, []byte(tag.Album), 30)
if err != nil {
return fmt.Errorf("could not write to dst: %s", err)
}
// Year
err = util.WriteToExtent(dst, []byte(fmt.Sprint(tag.Year)), 4)
if err != nil {
return fmt.Errorf("could not write to dst: %s", err)
}
// Comment
err = util.WriteToExtent(dst, []byte(tag.Comment), 28)
if err != nil {
return fmt.Errorf("could not write to dst: %s", err)
}
_, err = dst.Write([]byte{0})
if err != nil {
return fmt.Errorf("could not write to dst: %s", err)
}
// Track
trackBytes := make([]byte, 1)
binary.PutVarint(trackBytes, int64(tag.Track))
_, err = dst.Write(trackBytes)
if err != nil {
return fmt.Errorf("could not write to dst: %s", err)
}
//Genre
genreCode := util.GetKey(id3v1genres, tag.Genre)
if genreCode == -1 {
// if no genre found - encode genre code as 255
genreCode = ID3v1INVALIDGENRE
}
genrebyte := make([]byte, 1)
binary.PutVarint(genrebyte, int64(genreCode))
err = util.WriteToExtent(dst, genrebyte, 1)
if err != nil {
return fmt.Errorf("could not write to dst: %s", err)
}
return nil
}
// Checks for existing ID3v1.1 tag in file, if present - removes it and replaces with provided tag
func (tag *ID3v11Tag) WriteToFile(f *os.File) error {
defer f.Close()
// check for existing ID3v1.1 tag
_, err := f.Seek(-int64(ID3v1SIZE), io.SeekEnd)
if err != nil {
return fmt.Errorf("could not seek: %s", err)
}
identifier, err := util.Read(f, 3)
if err != nil {
// return err
return err
}
if !bytes.Equal(identifier, []byte(ID3v1IDENTIFIER)) {
// no existing identifier, just write given tag
err = tag.Write(f)
if err != nil {
return fmt.Errorf("could not write to writer: %s", err)
}
return nil
}
// does contain ID3v1.1 tag. Removing it
fStats, err := f.Stat()
if err != nil {
return fmt.Errorf("cannot get file stats: %s", err)
}
err = f.Truncate(fStats.Size() - int64(ID3v1SIZE))
if err != nil {
return fmt.Errorf("could not truncate file %s", err)
}
// writing new tag
err = tag.Write(f)
if err != nil {
return fmt.Errorf("could not write to writer: %s", err)
}
return nil
}

26
v1/id3v10_test.go → v1/v1_test.go
Unescape View File

@ -27,8 +27,20 @@ func TestGetv1Tags(t *testing.T) {
t.Errorf("GetID3v1Tag failed: %s", err) t.Errorf("GetID3v1Tag failed: %s", err)
} }
if tag.Version != V1_1 {
t.Errorf("GetID3v1Tag failed: expected version to be %s; got %s", V1_1, tag.Version)
}
if tag.Comment != "Comment here " { if tag.Comment != "Comment here " {
t.Errorf("GetID3v1Tag failed: expected %s; got %s", "Comment here ", tag.Comment) t.Errorf("GetID3v1Tag failed: expected comment to be %s; got %s", "Comment here ", tag.Comment)
}
if tag.Genre != "Soundtrack" {
t.Errorf("GetID3v1Tag failed: expected genre to be %s; got %s", "Soundtrack", tag.Genre)
}
if tag.Track != 8 {
t.Errorf("GetID3v1Tag failed: expected track number to be %d; got %d", 8, tag.Track)
} }
} }
@ -42,23 +54,23 @@ func TestWritev1Tags(t *testing.T) {
tag := TESTv1TAG tag := TESTv1TAG
// writing a tag // writing a tag
err = tag.Write(f) err = tag.write(f)
if err != nil { if err != nil {
t.Errorf("WriteID3v1Tag failed: %s", err) t.Errorf("WriteID3v1Tag failed: %s", err)
} }
// reading a tag // reading a tag
readTags, err := Getv1Tag(f) readTag, err := Getv1Tag(f)
if err != nil { if err != nil {
t.Errorf("%s", err) t.Errorf("%s", err)
} }
if readTags.Album != "testalbum" { if readTag.Album != "testalbum" {
t.Errorf("WriteID3v1Tag failed: expected %s; got %s", "testalbum", readTags.Album) t.Errorf("WriteID3v1Tag failed: expected %s; got %s", "testalbum", readTag.Album)
} }
if readTags.Year != 727 { if readTag.Year != 727 {
t.Errorf("WriteID3v1Tag failed: expected %d; got %d", 727, readTags.Year) t.Errorf("WriteID3v1Tag failed: expected %d; got %d", 727, readTag.Year)
} }
} }

80
v1/v1read.go
Unescape View File

@ -1,80 +0,0 @@
package v1
import (
"bytes"
"fmt"
"io"
"strconv"
"github.com/Unbewohnte/id3ed/util"
)
// Retrieves ID3v1 field values of provided io.ReadSeeker (usually a file)
func Getv1Tag(rs io.ReadSeeker) (*ID3v1Tag, error) {
// set reader to the last 128 bytes
_, err := rs.Seek(-int64(ID3v1SIZE), io.SeekEnd)
if err != nil {
return nil, fmt.Errorf("could not seek: %s", err)
}
tag, err := util.Read(rs, 3)
if err != nil {
return nil, err
}
if !bytes.Equal(tag, []byte(ID3v1IDENTIFIER)) {
// no TAG, given file does not use ID3v1
return nil, fmt.Errorf("does not use ID3v1: expected %s; got %s", ID3v1IDENTIFIER, tag)
}
songname, err := util.ReadToString(rs, 30)
if err != nil {
return nil, err
}
artist, err := util.ReadToString(rs, 30)
if err != nil {
return nil, err
}
album, err := util.ReadToString(rs, 30)
if err != nil {
return nil, err
}
yearStr, err := util.ReadToString(rs, 4)
if err != nil {
return nil, err
}
year, err := strconv.Atoi(yearStr)
if err != nil {
return nil, fmt.Errorf("could not convert yearbytes into int: %s", err)
}
comment, err := util.ReadToString(rs, 30)
if err != nil {
return nil, err
}
genreByte, err := util.Read(rs, 1)
if err != nil {
return nil, err
}
genreInt, err := util.ByteToInt(genreByte[0])
if err != nil {
return nil, fmt.Errorf("cannot convert bytes to int: %s", err)
}
genre, exists := id3v1genres[int(genreInt)]
if !exists {
genre = ""
}
return &ID3v1Tag{
SongName: songname,
Artist: artist,
Album: album,
Year: year,
Comment: comment,
Genre: genre,
}, nil
}

44
v1/v1write.go → v1/write.go
Unescape View File

@ -10,10 +10,10 @@ import (
"github.com/Unbewohnte/id3ed/util" "github.com/Unbewohnte/id3ed/util"
) )
// Writes given ID3v1.0 tag to given io.WriteSeeker. // Writes given ID3v1.0 or ID3v1.1 tag to given io.WriteSeeker.
// NOTE: will not remove already existing ID3v1 tag if it`s present, // NOTE: will not remove already existing ID3v1 tag if it`s present,
// use ⁕WriteToFile⁕ method if you`re working with REAL mp3 files !!! // use ⁕WriteToFile⁕ method if you`re working with REAL mp3 files !!!
func (tag *ID3v1Tag) Write(dst io.WriteSeeker) error { func (tag *ID3v1Tag) write(dst io.WriteSeeker) error {
dst.Seek(0, io.SeekEnd) dst.Seek(0, io.SeekEnd)
// ID // ID
@ -46,10 +46,34 @@ func (tag *ID3v1Tag) Write(dst io.WriteSeeker) error {
return fmt.Errorf("could not write to writer: %s", err) return fmt.Errorf("could not write to writer: %s", err)
} }
// Comment // Comment and Track
err = util.WriteToExtent(dst, []byte(tag.Comment), 30)
if err != nil { // check for track number, if specified and valid - comment must be shrinked to 28 bytes and 29th
return fmt.Errorf("could not write to writer: %s", err) // byte must be 0 byte (use ID3v1.1 instead of v1.0)
if tag.Track == 0 {
// write only 30 bytes long comment without track
err = util.WriteToExtent(dst, []byte(tag.Comment), 30)
if err != nil {
return fmt.Errorf("could not write to writer: %s", err)
}
} else {
// write 28 bytes long shrinked comment
err = util.WriteToExtent(dst, []byte(tag.Comment), 28)
if err != nil {
return fmt.Errorf("could not write to writer: %s", err)
}
// write 0 byte as padding
_, err = dst.Write([]byte{0})
if err != nil {
return fmt.Errorf("could not write to writer: %s", err)
}
// write track byte
_, err = dst.Write([]byte{byte(tag.Track)})
if err != nil {
return fmt.Errorf("could not write to writer: %s", err)
}
} }
// Genre // Genre
@ -69,7 +93,7 @@ func (tag *ID3v1Tag) Write(dst io.WriteSeeker) error {
return nil return nil
} }
// Checks for existing ID3v1 tag in file, if present - removes it and replaces with provided tag // Checks for existing ID3v1 or ID3v1.1 tag in file, if present - removes it and replaces with provided tag
func (tag *ID3v1Tag) WriteToFile(f *os.File) error { func (tag *ID3v1Tag) WriteToFile(f *os.File) error {
defer f.Close() defer f.Close()
@ -83,7 +107,7 @@ func (tag *ID3v1Tag) WriteToFile(f *os.File) error {
if !bytes.Equal(identifier, []byte(ID3v1IDENTIFIER)) { if !bytes.Equal(identifier, []byte(ID3v1IDENTIFIER)) {
// no existing identifier, just write given tag // no existing identifier, just write given tag
err = tag.Write(f) err = tag.write(f)
if err != nil { if err != nil {
return err return err
} }
@ -101,8 +125,8 @@ func (tag *ID3v1Tag) WriteToFile(f *os.File) error {
return fmt.Errorf("could not truncate file %s", err) return fmt.Errorf("could not truncate file %s", err)
} }
// writing new tag // writing a new tag
err = tag.Write(f) err = tag.write(f)
if err != nil { if err != nil {
return fmt.Errorf("could not write to writer: %s", err) return fmt.Errorf("could not write to writer: %s", err)
} }

6
v2/constants.go
Unescape View File

@ -7,6 +7,6 @@ const V2_2 string = "ID3v2.2"
const V2_3 string = "ID3v2.3" const V2_3 string = "ID3v2.3"
const V2_4 string = "ID3v2.4" const V2_4 string = "ID3v2.4"
const V2_2FrameNameSize uint = 3 const V2_2FrameIDSize uint = 3
const V2_3FrameNameSize uint = 4 const V2_3FrameIDSize uint = 4
const V2_4FrameNameSize uint = 4 const V2_4FrameIDSize uint = 4

36
v2/v2tag.go
Unescape View File

@ -1,34 +1,6 @@
package v2 package v2
// type ID3v2Tag struct { type ID3v2Tag struct {
// Header Header Header Header
// Frames []Frame Frames []Frame
// } }
// type V2TagReader interface {
// ReadFrames(io.ReadSeeker) ([]*Frame, error)
// GetHeader(io.ReadSeeker) (*Header, error)
// HasPadding(io.ReadSeeker) (bool, error)
// }
// type V2TagWriter interface {
// Write(*os.File) error
// }
// func Get(f *os.File) (*ID3v2Tag, error) {
// var tag ID3v2Tag
// header, err := GetHeader(f)
// if err != nil {
// return nil, err
// }
// frames, err := GetFrames(f)
// if err != nil {
// return nil, err
// }
// tag.Header = header
// tag.Frames = frames
// return &tag, nil
// }

Write Preview
Loading…
Cancel
Save