From 36d91638688848c1bdd348a29961da4e9374744a Mon Sep 17 00:00:00 2001 From: David Howden Date: Wed, 27 May 2015 08:43:47 +1000 Subject: [PATCH] Refactored all MP4 code to better handle custom atoms --- mp4.go | 240 +++++++++++++++++++++++++++++---------------------------- 1 file changed, 121 insertions(+), 119 deletions(-) diff --git a/mp4.go b/mp4.go index 3deed5d..398fda4 100644 --- a/mp4.go +++ b/mp4.go @@ -21,6 +21,7 @@ var atomTypes = map[int]string{ 21: "uint8", } +// NB: atoms does not include "----", this is handled separately var atoms = atomNames(map[string]string{ "\xa9alb": "album", "\xa9art": "artist", @@ -70,63 +71,9 @@ func ReadAtoms(r io.ReadSeeker) (Metadata, error) { return m, err } -func readCustomAtom(r io.ReadSeeker, size uint32) (string, uint32, error) { - var datasize uint32 - var datapos int64 - var name string - var mean string - - for size > 8 { - var subsize uint32 - err := binary.Read(r, binary.BigEndian, &subsize) - if err != nil { - return "----", size - 4, err - } - subname, err := readString(r, 4) - if err != nil { - return "----", size - 8, err - } - b, err := readBytes(r, int(subsize-8)) - if err != nil { - return "----", size - subsize, err - } - // Remove the size of the atom from the size counter - size -= subsize - - switch string(subname) { - case "mean": - mean = string(b[4:]) - case "name": - name = string(b[4:]) - case "data": - datapos, err = r.Seek(0, os.SEEK_CUR) - if err != nil { - return "----", size, err - } - datasize = subsize - datapos -= int64(subsize) - } - } - // there should remain only the header size - if size != 8 { - return "----", size, errors.New("---- atom out of bound") - } - if mean == "com.apple.iTunes" && datasize != 0 && name != "" { - // we jump just before the data subatom - _, err := r.Seek(datapos, os.SEEK_SET) - if err != nil { - return "----", size, err - } - return name, datasize + 8, nil - } - return "----", size, nil -} - func (m metadataMP4) readAtoms(r io.ReadSeeker) error { for { - var size uint32 - ok := false - err := binary.Read(r, binary.BigEndian, &size) + name, size, err := readAtomHeader(r) if err != nil { if err == io.EOF { return nil @@ -134,11 +81,6 @@ func (m metadataMP4) readAtoms(r io.ReadSeeker) error { return err } - name, err := readString(r, 4) - if err != nil { - return err - } - switch name { case "meta": // next_item_id (int32) @@ -147,81 +89,141 @@ func (m metadataMP4) readAtoms(r io.ReadSeeker) error { return err } fallthrough + case "moov", "udta", "ilst": return m.readAtoms(r) - case "free": - _, err := r.Seek(int64(size-8), os.SEEK_CUR) - if err != nil { - return err - } - continue - case "mdat": // skip the data, the metadata can be at the end - _, err := r.Seek(int64(size-8), os.SEEK_CUR) - if err != nil { - return err - } - continue - case "----": - // Generic atom. - // Should have 3 sub atoms : mean, name and data. - // We check that mean=="com.apple.iTunes" and we use the subname as - // the name, and move to the data atom. - // If anything goes wrong, we jump at the end of the "----" atom. + } + + _, ok := atoms[name] + if name == "----" { name, size, err = readCustomAtom(r, size) if err != nil { return err } - ok = (name != "----") - default: - _, ok = atoms[name] + + if name != "----" { + ok = true + } } - b, err := readBytes(r, int(size-8)) - if err != nil { - return err - } - - // At this point, we allow all known atoms and the valid "----" atoms if !ok { + _, err := r.Seek(int64(size-8), os.SEEK_CUR) + if err != nil { + return err + } continue } - // 16: name + size + "data" + size (4 bytes each), have already read 8 - b = b[8:] - class := getInt(b[1:4]) - contentType, ok := atomTypes[class] - if !ok { - return fmt.Errorf("invalid content type: %v", class) - } - - b = b[8:] - switch name { - case "trkn", "disk": - m[name] = int(b[3]) - m[name+"_count"] = int(b[5]) - default: - var data interface{} - // 4: atom version (1 byte) + atom flags (3 bytes) - // 4: NULL (usually locale indicator) - switch contentType { - case "text": - data = string(b) - - case "uint8": - data = getInt(b[:1]) - - case "jpeg", "png": - data = &Picture{ - Ext: contentType, - MIMEType: "image/" + contentType, - Data: b, - } - } - m[name] = data + err = m.readAtomData(r, name, size-8) + if err != nil { + return err } } } +func (m metadataMP4) readAtomData(r io.ReadSeeker, name string, size uint32) error { + b, err := readBytes(r, int(size)) + if err != nil { + return err + } + + // "data" + size (4 bytes each) + b = b[8:] + + class := getInt(b[1:4]) + contentType, ok := atomTypes[class] + if !ok { + return fmt.Errorf("invalid content type: %v (%x) (%x)", class, b[1:4], b) + } + + // 4: atom version (1 byte) + atom flags (3 bytes) + // 4: NULL (usually locale indicator) + b = b[8:] + + if name == "trkn" || name == "disk" { + fmt.Printf("%#v: %x\n", name, b) + m[name] = int(b[3]) + m[name+"_count"] = int(b[5]) + return nil + } + + var data interface{} + switch contentType { + case "text": + data = string(b) + + case "uint8": + data = getInt(b[:1]) + + case "jpeg", "png": + data = &Picture{ + Ext: contentType, + MIMEType: "image/" + contentType, + Data: b, + } + } + m[name] = data + + return nil +} + +func readAtomHeader(r io.ReadSeeker) (name string, size uint32, err error) { + err = binary.Read(r, binary.BigEndian, &size) + if err != nil { + return + } + name, err = readString(r, 4) + return +} + +// Generic atom. +// Should have 3 sub atoms : mean, name and data. +// We check that mean is "com.apple.iTunes" and we use the subname as +// the name, and move to the data atom. +// If anything goes wrong, we jump at the end of the "----" atom. +func readCustomAtom(r io.ReadSeeker, size uint32) (string, uint32, error) { + subNames := make(map[string]string) + var dataSize uint32 + + for size > 8 { + subName, subSize, err := readAtomHeader(r) + if err != nil { + return "", 0, err + } + + // Remove the size of the atom from the size counter + size -= subSize + + switch subName { + case "mean", "name": + b, err := readBytes(r, int(subSize-8)) + if err != nil { + return "", 0, err + } + subNames[subName] = string(b[4:]) + + case "data": + // Found the "data" atom, rewind + dataSize = subSize + 8 // will need to re-read "data" + size (4 + 4) + _, err := r.Seek(-8, os.SEEK_CUR) + if err != nil { + return "", 0, err + } + } + } + + // there should remain only the header size + if size != 8 { + err := errors.New("---- atom out of bounds") + return "", 0, err + } + + if subNames["mean"] != "com.apple.iTunes" || subNames["name"] == "" || dataSize == 0 { + return "----", 0, nil + } + return subNames["name"], dataSize, nil +} + func (metadataMP4) Format() Format { return MP4 } func (metadataMP4) FileType() FileType { return AAC }