package v2 import ( "bytes" "fmt" "io" "github.com/Unbewohnte/id3ed/util" ) // Main header`s flags type HeaderFlags struct { Unsynchronisated bool Compressed bool HasExtendedHeader bool Experimental bool FooterPresent bool } // ID3v2.x`s main header structure type Header struct { Identifier string Flags HeaderFlags Version string Size uint32 ExtendedHeader ExtendedHeader } // extended header`s flags type ExtendedHeaderFlags struct { UpdateTag bool CRCpresent bool HasRestrictions bool Restrictions byte // a `lazy` approach :), just for now, maybe... } type ExtendedHeader struct { Size uint32 Flags ExtendedHeaderFlags PaddingSize uint32 CRCdata []byte } // Reads and structuralises extended header. Must // be called AFTER the main header has beeen read (does not seek). // ALSO ISN`T TESTED !!! func (h *Header) readExtendedHeader(r io.Reader) error { h.ExtendedHeader = ExtendedHeader{} if !h.Flags.HasExtendedHeader { return nil } var extended ExtendedHeader // extended size extendedSize, err := util.Read(r, 4) if err != nil { return fmt.Errorf("could not read from reader: %s", err) } switch h.Version { case V2_3: extended.Size = util.BytesToInt(extendedSize) case V2_4: extended.Size = util.BytesToIntSynchsafe(extendedSize) } // extended flags switch h.Version { case V2_3: extendedFlag, err := util.Read(r, 2) // reading flag byte and a null-byte after if err != nil { return fmt.Errorf("could not read from reader: %s", err) } flagbits := fmt.Sprintf("%08b", extendedFlag[0]) if flagbits[0] == 1 { extended.Flags.CRCpresent = true } else { extended.Flags.CRCpresent = false } case V2_4: // skipping `Number of flag bytes` because it`s always `1` _, err := util.Read(r, 1) if err != nil { return fmt.Errorf("could not read from reader: %s", err) } flagByte, err := util.Read(r, 1) if err != nil { return fmt.Errorf("could not read from reader: %s", err) } flagBits := fmt.Sprintf("%08b", flagByte[0]) if flagBits[1] == 1 { extended.Flags.UpdateTag = true } else { extended.Flags.UpdateTag = false } if flagBits[2] == 1 { extended.Flags.CRCpresent = true } else { extended.Flags.CRCpresent = false } if flagBits[3] == 1 { extended.Flags.HasRestrictions = true } else { extended.Flags.HasRestrictions = false } } // extracting data given by flags switch h.Version { case V2_3: if extended.Flags.CRCpresent { crcData, err := util.Read(r, 4) if err != nil { return fmt.Errorf("could not read from reader: %s", err) } extended.CRCdata = crcData } case V2_4: // `Each flag that is set in the extended header has data attached` if extended.Flags.UpdateTag { // skipping null-byte length of `UpdateTag` _, err := util.Read(r, 1) if err != nil { return fmt.Errorf("could not read from reader: %s", err) } } if extended.Flags.CRCpresent { crclen, err := util.Read(r, 1) if err != nil { return fmt.Errorf("could not read from reader: %s", err) } crcData, err := util.Read(r, uint64(crclen[0])) if err != nil { return fmt.Errorf("could not read from reader: %s", err) } extended.CRCdata = crcData } if extended.Flags.HasRestrictions { // skipping one-byte length of `Restrictions`, because it`s always `1` _, err := util.Read(r, 1) if err != nil { return fmt.Errorf("could not read from reader: %s", err) } restrictionsByte, err := util.Read(r, 1) if err != nil { return fmt.Errorf("could not read from reader: %s", err) } // a `lazy` approach :), just for now extended.Flags.Restrictions = restrictionsByte[0] } } // extracting other version-dependent header data // padding if V2_3 if h.Version == V2_3 { paddingSizeBytes, err := util.Read(r, 4) if err != nil { return fmt.Errorf("could not read from reader: %s", err) } paddingSize := util.BytesToInt(paddingSizeBytes) extended.PaddingSize = paddingSize } // finally `attaching` parsed extended header to the main *Header h.ExtendedHeader = extended return nil } // Reads and structuralises ID3v2 header and if present - extended header. // Returns a blank header struct if encountered an error func readHeader(rs io.ReadSeeker) (Header, error) { _, err := rs.Seek(0, io.SeekStart) if err != nil { return Header{}, fmt.Errorf("could not seek: %s", err) } hBytes, err := util.Read(rs, uint64(HEADERSIZE)) if err != nil { return Header{}, fmt.Errorf("could not read from reader: %s", err) } var header Header identifier := hBytes[0:3] // check if has identifier ID3v2 if !bytes.Equal([]byte(HEADERIDENTIFIER), identifier) { return Header{}, ErrDoesNotUseID3v2 } header.Identifier = string(identifier) // version majorVersion := int(hBytes[3]) revisionNumber := int(hBytes[4]) switch majorVersion { case 2: header.Version = V2_2 case 3: header.Version = V2_3 case 4: header.Version = V2_4 default: return Header{}, fmt.Errorf("ID3v2.%d.%d is not supported or invalid", majorVersion, revisionNumber) } // flags flags := hBytes[5] flagBits := fmt.Sprintf("%08b", flags) // 1 byte is 8 bits // v3.0 and v4.0 have different amount of flags switch header.Version { case V2_2: if flagBits[0] == 1 { header.Flags.Unsynchronisated = true } else { header.Flags.Unsynchronisated = false } if flagBits[1] == 1 { header.Flags.Compressed = true } else { header.Flags.Compressed = false } case V2_3: if flagBits[0] == 1 { header.Flags.Unsynchronisated = true } else { header.Flags.Unsynchronisated = false } if flagBits[1] == 1 { header.Flags.HasExtendedHeader = true } else { header.Flags.HasExtendedHeader = false } if flagBits[2] == 1 { header.Flags.Experimental = true } else { header.Flags.Experimental = false } // always false, because ID3v2.3.0 does not support footers header.Flags.FooterPresent = false case V2_4: if flagBits[0] == 1 { header.Flags.Unsynchronisated = true } else { header.Flags.Unsynchronisated = false } if flagBits[1] == 1 { header.Flags.HasExtendedHeader = true } else { header.Flags.HasExtendedHeader = false } if flagBits[2] == 1 { header.Flags.Experimental = true } else { header.Flags.Experimental = false } if flagBits[3] == 1 { header.Flags.FooterPresent = true } else { header.Flags.FooterPresent = false } } // size sizeBytes := hBytes[6:] size := util.BytesToIntSynchsafe(sizeBytes) header.Size = size if header.Flags.HasExtendedHeader { err = header.readExtendedHeader(rs) if err != nil { return header, err } } return header, nil }