aboutsummaryrefslogtreecommitdiff
path: root/codec.go
diff options
context:
space:
mode:
authorOnur Gündüz <ogunduz@gmail.com>2026-02-12 04:01:44 +0100
committerOnur Gündüz <ogunduz@gmail.com>2026-02-12 04:01:44 +0100
commit31fb8566283849ef802bf64d80812250953a1024 (patch)
tree9d9c12f8f3d12996e5b49d17373347cd29aa07cd /codec.go
parentb521231b5b3174a9b1fe15161f9aec462e9675cb (diff)
downloadmp4-31fb8566283849ef802bf64d80812250953a1024.tar.gz
mp4-31fb8566283849ef802bf64d80812250953a1024.zip
Add MP4 codec and descriptor parsing
Diffstat (limited to 'codec.go')
-rw-r--r--codec.go1196
1 files changed, 1196 insertions, 0 deletions
diff --git a/codec.go b/codec.go
new file mode 100644
index 0000000..be78577
--- /dev/null
+++ b/codec.go
@@ -0,0 +1,1196 @@
+package mp4
+
+import (
+ "encoding/binary"
+ "fmt"
+)
+
+// Codec types for each known box.
+
+// Ftyp represents the file type box.
+type Ftyp struct {
+ Brand [4]byte
+ BrandVersion uint32
+ CompatibleBrands [][4]byte
+}
+
+// Mvhd represents the movie header box.
+type Mvhd struct {
+ CTime [4]byte // raw 4-byte date
+ MTime [4]byte
+ TimeScale uint32
+ Duration uint32
+ PreferredRate [4]byte // raw 16.16 fixed
+ PreferredVolume [2]byte // raw 8.8 fixed
+ Matrix [36]byte
+ PreviewTime uint32
+ PreviewDuration uint32
+ PosterTime uint32
+ SelectionTime uint32
+ SelectionDuration uint32
+ CurrentTime uint32
+ NextTrackId uint32
+}
+
+// Tkhd represents the track header box.
+type Tkhd struct {
+ CTime [4]byte
+ MTime [4]byte
+ TrackId uint32
+ Duration uint32
+ Layer uint16
+ AlternateGroup uint16
+ Volume uint16
+ Matrix [36]byte
+ TrackWidth uint32
+ TrackHeight uint32
+}
+
+// Mdhd represents the media header box.
+type Mdhd struct {
+ CTime [8]byte // 4 or 8 bytes depending on version
+ MTime [8]byte
+ TimeScale uint32
+ Duration uint64
+ Language uint16
+ Quality uint16
+ V1 bool // true if version 1
+}
+
+// Vmhd represents the video media header box.
+type Vmhd struct {
+ GraphicsMode uint16
+ Opcolor [3]uint16
+}
+
+// Smhd represents the sound media header box.
+type Smhd struct {
+ Balance uint16
+}
+
+// Stsd represents the sample description box.
+type Stsd struct {
+ Entries []*Box
+}
+
+// VisualSampleEntry represents a visual sample entry (e.g. avc1).
+type VisualSampleEntry struct {
+ DataReferenceIndex uint16
+ Width uint16
+ Height uint16
+ HResolution uint32
+ VResolution uint32
+ FrameCount uint16
+ CompressorName string
+ Depth uint16
+ Children []*Box
+}
+
+// AvcC represents the AVC configuration box.
+type AvcC struct {
+ MimeCodec string
+ Buffer []byte
+}
+
+// AudioSampleEntry represents an audio sample entry (e.g. mp4a).
+type AudioSampleEntry struct {
+ DataReferenceIndex uint16
+ ChannelCount uint16
+ SampleSize uint16
+ SampleRate uint32
+ Children []*Box
+}
+
+// Esds represents the elementary stream descriptor box.
+type Esds struct {
+ MimeCodec string
+ Buffer []byte
+}
+
+// Stsz represents the sample size box.
+type Stsz struct {
+ SampleSize uint32
+ Entries []uint32
+}
+
+// Stco represents the chunk offset box (also used for stss).
+type Stco struct {
+ Entries []uint32
+}
+
+// Co64 represents the 64-bit chunk offset box.
+type Co64 struct {
+ Entries []uint64
+}
+
+// STTSEntry is a time-to-sample entry.
+type STTSEntry struct {
+ Count uint32
+ Duration uint32
+}
+
+// Stts represents the time-to-sample box.
+type Stts struct {
+ Entries []STTSEntry
+}
+
+// CTTSEntry is a composition offset entry.
+type CTTSEntry struct {
+ Count uint32
+ CompositionOffset int32
+}
+
+// Ctts represents the composition offset box.
+type Ctts struct {
+ Entries []CTTSEntry
+}
+
+// STSCEntry is a sample-to-chunk entry.
+type STSCEntry struct {
+ FirstChunk uint32
+ SamplesPerChunk uint32
+ SampleDescriptionId uint32
+}
+
+// Stsc represents the sample-to-chunk box.
+type Stsc struct {
+ Entries []STSCEntry
+}
+
+// DrefEntry is a data reference entry.
+type DrefEntry struct {
+ Type [4]byte
+ Buf []byte
+}
+
+// DrefBox represents the data reference box.
+type DrefBox struct {
+ Entries []DrefEntry
+}
+
+// ElstEntry is an edit list entry.
+type ElstEntry struct {
+ TrackDuration uint32
+ MediaTime int32
+ MediaRate [4]byte // raw fixed 16.16
+}
+
+// Elst represents the edit list box.
+type Elst struct {
+ Entries []ElstEntry
+}
+
+// Hdlr represents the handler reference box.
+type Hdlr struct {
+ HandlerType [4]byte
+ Name string
+}
+
+// Mehd represents the movie extends header box.
+type Mehd struct {
+ FragmentDuration uint32
+}
+
+// Trex represents the track extends box.
+type Trex struct {
+ TrackId uint32
+ DefaultSampleDescriptionIndex uint32
+ DefaultSampleDuration uint32
+ DefaultSampleSize uint32
+ DefaultSampleFlags uint32
+}
+
+// Mfhd represents the movie fragment header box.
+type Mfhd struct {
+ SequenceNumber uint32
+}
+
+// Tfhd represents the track fragment header box.
+type Tfhd struct {
+ TrackId uint32
+}
+
+// Tfdt represents the track fragment decode time box.
+type Tfdt struct {
+ BaseMediaDecodeTime uint32
+}
+
+// TrunEntry is a track run entry.
+type TrunEntry struct {
+ SampleDuration uint32
+ SampleSize uint32
+ SampleFlags uint32
+ SampleCompositionTimeOffset int32
+}
+
+// Trun represents the track run box.
+type Trun struct {
+ DataOffset int32
+ Entries []TrunEntry
+}
+
+// Mdat represents the media data box.
+type Mdat struct {
+ Buffer []byte
+ ContentLength int
+}
+
+// codec is an internal interface for box-specific encoding/decoding.
+type codec struct {
+ decode func(box *Box, buf []byte, start, end int) error
+ encode func(box *Box, buf []byte, offset int) int
+ encodingLength func(box *Box) int
+}
+
+var codecs = map[BoxType]*codec{}
+
+func getCodec(t BoxType) *codec {
+ return codecs[t]
+}
+
+func init() {
+ codecs[TypeFtyp] = &codec{decodeFtyp, encodeFtyp, encodingLengthFtyp}
+ codecs[TypeMvhd] = &codec{decodeMvhd, encodeMvhd, encodingLengthMvhd}
+ codecs[TypeTkhd] = &codec{decodeTkhd, encodeTkhd, encodingLengthTkhd}
+ codecs[TypeMdhd] = &codec{decodeMdhd, encodeMdhd, encodingLengthMdhd}
+ codecs[TypeVmhd] = &codec{decodeVmhd, encodeVmhd, encodingLengthVmhd}
+ codecs[TypeSmhd] = &codec{decodeSmhd, encodeSmhd, encodingLengthSmhd}
+ codecs[TypeStsd] = &codec{decodeStsd, encodeStsd, encodingLengthStsd}
+ codecs[TypeAvc1] = &codec{decodeVisual, encodeVisual, encodingLengthVisual}
+ codecs[TypeAvcC] = &codec{decodeAvcC, encodeAvcC, encodingLengthAvcC}
+ codecs[TypeMp4a] = &codec{decodeAudio, encodeAudio, encodingLengthAudio}
+ codecs[TypeEsds] = &codec{decodeEsds, encodeEsds, encodingLengthEsds}
+ codecs[TypeStsz] = &codec{decodeStsz, encodeStsz, encodingLengthStsz}
+ codecs[TypeStco] = &codec{decodeStco, encodeStco, encodingLengthStco}
+ codecs[TypeStss] = &codec{decodeStco, encodeStco, encodingLengthStco} // same format as stco
+ codecs[TypeCo64] = &codec{decodeCo64, encodeCo64, encodingLengthCo64}
+ codecs[TypeStts] = &codec{decodeStts, encodeStts, encodingLengthStts}
+ codecs[TypeCtts] = &codec{decodeCtts, encodeCtts, encodingLengthCtts}
+ codecs[TypeStsc] = &codec{decodeStsc, encodeStsc, encodingLengthStsc}
+ codecs[TypeDref] = &codec{decodeDref, encodeDref, encodingLengthDref}
+ codecs[TypeElst] = &codec{decodeElst, encodeElst, encodingLengthElst}
+ codecs[TypeHdlr] = &codec{decodeHdlr, encodeHdlr, encodingLengthHdlr}
+ codecs[TypeMehd] = &codec{decodeMehd, encodeMehd, encodingLengthMehd}
+ codecs[TypeTrex] = &codec{decodeTrex, encodeTrex, encodingLengthTrex}
+ codecs[TypeMfhd] = &codec{decodeMfhd, encodeMfhd, encodingLengthMfhd}
+ codecs[TypeTfhd] = &codec{decodeTfhd, encodeTfhd, encodingLengthTfhd}
+ codecs[TypeTfdt] = &codec{decodeTfdt, encodeTfdt, encodingLengthTfdt}
+ codecs[TypeTrun] = &codec{decodeTrun, encodeTrun, encodingLengthTrun}
+ codecs[TypeMdat] = &codec{decodeMdat, encodeMdat, encodingLengthMdat}
+}
+
+// --- ftyp ---
+
+func decodeFtyp(box *Box, buf []byte, start, end int) error {
+ b := buf[start:end]
+ if len(b) < 8 {
+ return fmt.Errorf("ftyp too short")
+ }
+ f := &Ftyp{}
+ copy(f.Brand[:], b[0:4])
+ f.BrandVersion = be.Uint32(b[4:8])
+ for i := 8; i+4 <= len(b); i += 4 {
+ var brand [4]byte
+ copy(brand[:], b[i:i+4])
+ f.CompatibleBrands = append(f.CompatibleBrands, brand)
+ }
+ box.Ftyp = f
+ return nil
+}
+
+func encodeFtyp(box *Box, buf []byte, offset int) int {
+ f := box.Ftyp
+ b := buf[offset:]
+ copy(b[0:4], f.Brand[:])
+ be.PutUint32(b[4:8], f.BrandVersion)
+ for i, brand := range f.CompatibleBrands {
+ copy(b[8+i*4:], brand[:])
+ }
+ return 8 + len(f.CompatibleBrands)*4
+}
+
+func encodingLengthFtyp(box *Box) int {
+ return 8 + len(box.Ftyp.CompatibleBrands)*4
+}
+
+// --- mvhd ---
+
+func decodeMvhd(box *Box, buf []byte, start, _ int) error {
+ b := buf[start:]
+ m := &Mvhd{}
+ copy(m.CTime[:], b[0:4])
+ copy(m.MTime[:], b[4:8])
+ m.TimeScale = be.Uint32(b[8:12])
+ m.Duration = be.Uint32(b[12:16])
+ copy(m.PreferredRate[:], b[16:20])
+ copy(m.PreferredVolume[:], b[20:22])
+ copy(m.Matrix[:], b[32:68])
+ m.PreviewTime = be.Uint32(b[68:72])
+ m.PreviewDuration = be.Uint32(b[72:76])
+ m.PosterTime = be.Uint32(b[76:80])
+ m.SelectionTime = be.Uint32(b[80:84])
+ m.SelectionDuration = be.Uint32(b[84:88])
+ m.CurrentTime = be.Uint32(b[88:92])
+ m.NextTrackId = be.Uint32(b[92:96])
+ box.Mvhd = m
+ return nil
+}
+
+func encodeMvhd(box *Box, buf []byte, offset int) int {
+ b := buf[offset:]
+ m := box.Mvhd
+ copy(b[0:4], m.CTime[:])
+ copy(b[4:8], m.MTime[:])
+ be.PutUint32(b[8:12], m.TimeScale)
+ be.PutUint32(b[12:16], m.Duration)
+ copy(b[16:20], m.PreferredRate[:])
+ copy(b[20:22], m.PreferredVolume[:])
+ clearBytes(b, 22, 32)
+ copy(b[32:68], m.Matrix[:])
+ be.PutUint32(b[68:72], m.PreviewTime)
+ be.PutUint32(b[72:76], m.PreviewDuration)
+ be.PutUint32(b[76:80], m.PosterTime)
+ be.PutUint32(b[80:84], m.SelectionTime)
+ be.PutUint32(b[84:88], m.SelectionDuration)
+ be.PutUint32(b[88:92], m.CurrentTime)
+ be.PutUint32(b[92:96], m.NextTrackId)
+ return 96
+}
+
+func encodingLengthMvhd(_ *Box) int { return 96 }
+
+// --- tkhd ---
+
+func decodeTkhd(box *Box, buf []byte, start, _ int) error {
+ b := buf[start:]
+ t := &Tkhd{}
+ copy(t.CTime[:], b[0:4])
+ copy(t.MTime[:], b[4:8])
+ t.TrackId = be.Uint32(b[8:12])
+ t.Duration = be.Uint32(b[16:20])
+ t.Layer = be.Uint16(b[28:30])
+ t.AlternateGroup = be.Uint16(b[30:32])
+ t.Volume = be.Uint16(b[32:34])
+ copy(t.Matrix[:], b[36:72])
+ t.TrackWidth = be.Uint32(b[72:76])
+ t.TrackHeight = be.Uint32(b[76:80])
+ box.Tkhd = t
+ return nil
+}
+
+func encodeTkhd(box *Box, buf []byte, offset int) int {
+ b := buf[offset:]
+ t := box.Tkhd
+ copy(b[0:4], t.CTime[:])
+ copy(b[4:8], t.MTime[:])
+ be.PutUint32(b[8:12], t.TrackId)
+ clearBytes(b, 12, 16)
+ be.PutUint32(b[16:20], t.Duration)
+ clearBytes(b, 20, 28)
+ be.PutUint16(b[28:30], t.Layer)
+ be.PutUint16(b[30:32], t.AlternateGroup)
+ be.PutUint16(b[32:34], t.Volume)
+ clearBytes(b, 34, 36)
+ copy(b[36:72], t.Matrix[:])
+ be.PutUint32(b[72:76], t.TrackWidth)
+ be.PutUint32(b[76:80], t.TrackHeight)
+ return 80
+}
+
+func encodingLengthTkhd(_ *Box) int { return 80 }
+
+// --- mdhd ---
+
+func decodeMdhd(box *Box, buf []byte, start, end int) error {
+ b := buf[start:end]
+ m := &Mdhd{}
+ contentLen := end - start
+
+ if contentLen != 20 {
+ // version 1: 8-byte times
+ m.V1 = true
+ copy(m.CTime[:], b[0:8])
+ copy(m.MTime[:], b[8:16])
+ m.TimeScale = be.Uint32(b[16:20])
+ // Read 6 bytes for duration (48-bit)
+ m.Duration = uint64(b[20])<<40 | uint64(b[21])<<32 | uint64(b[22])<<24 |
+ uint64(b[23])<<16 | uint64(b[24])<<8 | uint64(b[25])
+ m.Language = be.Uint16(b[28:30])
+ m.Quality = be.Uint16(b[30:32])
+ } else {
+ copy(m.CTime[:4], b[0:4])
+ copy(m.MTime[:4], b[4:8])
+ m.TimeScale = be.Uint32(b[8:12])
+ m.Duration = uint64(be.Uint32(b[12:16]))
+ m.Language = be.Uint16(b[16:18])
+ m.Quality = be.Uint16(b[18:20])
+ }
+ box.Mdhd = m
+ return nil
+}
+
+func encodeMdhd(box *Box, buf []byte, offset int) int {
+ b := buf[offset:]
+ m := box.Mdhd
+
+ if m.V1 {
+ copy(b[0:8], m.CTime[:])
+ copy(b[8:16], m.MTime[:])
+ be.PutUint32(b[16:20], m.TimeScale)
+ // Write 6 bytes for duration
+ b[20] = byte(m.Duration >> 40)
+ b[21] = byte(m.Duration >> 32)
+ b[22] = byte(m.Duration >> 24)
+ b[23] = byte(m.Duration >> 16)
+ b[24] = byte(m.Duration >> 8)
+ b[25] = byte(m.Duration)
+ clearBytes(b, 26, 28)
+ be.PutUint16(b[28:30], m.Language)
+ be.PutUint16(b[30:32], m.Quality)
+ return 32
+ }
+
+ copy(b[0:4], m.CTime[:4])
+ copy(b[4:8], m.MTime[:4])
+ be.PutUint32(b[8:12], m.TimeScale)
+ be.PutUint32(b[12:16], uint32(m.Duration))
+ be.PutUint16(b[16:18], m.Language)
+ be.PutUint16(b[18:20], m.Quality)
+ return 20
+}
+
+func encodingLengthMdhd(box *Box) int {
+ if box.Mdhd.V1 {
+ return 32
+ }
+ return 20
+}
+
+// --- vmhd ---
+
+func decodeVmhd(box *Box, buf []byte, start, _ int) error {
+ b := buf[start:]
+ box.Vmhd = &Vmhd{
+ GraphicsMode: be.Uint16(b[0:2]),
+ Opcolor: [3]uint16{be.Uint16(b[2:4]), be.Uint16(b[4:6]), be.Uint16(b[6:8])},
+ }
+ return nil
+}
+
+func encodeVmhd(box *Box, buf []byte, offset int) int {
+ b := buf[offset:]
+ v := box.Vmhd
+ be.PutUint16(b[0:2], v.GraphicsMode)
+ be.PutUint16(b[2:4], v.Opcolor[0])
+ be.PutUint16(b[4:6], v.Opcolor[1])
+ be.PutUint16(b[6:8], v.Opcolor[2])
+ return 8
+}
+
+func encodingLengthVmhd(_ *Box) int { return 8 }
+
+// --- smhd ---
+
+func decodeSmhd(box *Box, buf []byte, start, _ int) error {
+ box.Smhd = &Smhd{Balance: be.Uint16(buf[start:])}
+ return nil
+}
+
+func encodeSmhd(box *Box, buf []byte, offset int) int {
+ be.PutUint16(buf[offset:], box.Smhd.Balance)
+ clearBytes(buf, offset+2, offset+4)
+ return 4
+}
+
+func encodingLengthSmhd(_ *Box) int { return 4 }
+
+// --- stsd ---
+
+func decodeStsd(box *Box, buf []byte, start, end int) error {
+ b := buf[start:end]
+ num := int(be.Uint32(b[0:4]))
+ s := &Stsd{Entries: make([]*Box, num)}
+ ptr := 4
+ for i := 0; i < num; i++ {
+ entry, err := Decode(buf, start+ptr, end)
+ if err != nil {
+ return err
+ }
+ s.Entries[i] = entry
+ ptr += int(entry.Size)
+ }
+ box.Stsd = s
+ return nil
+}
+
+func encodeStsd(box *Box, buf []byte, offset int) int {
+ s := box.Stsd
+ be.PutUint32(buf[offset:], uint32(len(s.Entries)))
+ ptr := offset + 4
+ for _, entry := range s.Entries {
+ n, _ := encodeBox(entry, buf, ptr)
+ ptr += n
+ }
+ return ptr - offset
+}
+
+func encodingLengthStsd(box *Box) int {
+ total := 4
+ for _, entry := range box.Stsd.Entries {
+ total += int(EncodingLength(entry))
+ }
+ return total
+}
+
+// --- avc1 / VisualSampleEntry ---
+
+func decodeVisual(box *Box, buf []byte, start, end int) error {
+ b := buf[start:end]
+ length := end - start
+ nameLen := int(b[42])
+ if nameLen > 31 {
+ nameLen = 31
+ }
+ v := &VisualSampleEntry{
+ DataReferenceIndex: be.Uint16(b[6:8]),
+ Width: be.Uint16(b[24:26]),
+ Height: be.Uint16(b[26:28]),
+ HResolution: be.Uint32(b[28:32]),
+ VResolution: be.Uint32(b[32:36]),
+ FrameCount: be.Uint16(b[40:42]),
+ CompressorName: string(b[43 : 43+nameLen]),
+ Depth: be.Uint16(b[74:76]),
+ }
+
+ ptr := 78
+ for length-ptr >= 8 {
+ child, err := Decode(buf, start+ptr, end)
+ if err != nil {
+ return err
+ }
+ v.Children = append(v.Children, child)
+ ptr += int(child.Size)
+ }
+ box.Visual = v
+ return nil
+}
+
+func encodeVisual(box *Box, buf []byte, offset int) int {
+ b := buf[offset:]
+ v := box.Visual
+ clearBytes(b, 0, 6)
+ be.PutUint16(b[6:8], v.DataReferenceIndex)
+ clearBytes(b, 8, 24)
+ be.PutUint16(b[24:26], v.Width)
+ be.PutUint16(b[26:28], v.Height)
+ hRes := v.HResolution
+ if hRes == 0 {
+ hRes = 0x480000
+ }
+ be.PutUint32(b[28:32], hRes)
+ vRes := v.VResolution
+ if vRes == 0 {
+ vRes = 0x480000
+ }
+ be.PutUint32(b[32:36], vRes)
+ clearBytes(b, 36, 40)
+ fc := v.FrameCount
+ if fc == 0 {
+ fc = 1
+ }
+ be.PutUint16(b[40:42], fc)
+ nameLen := len(v.CompressorName)
+ if nameLen > 31 {
+ nameLen = 31
+ }
+ b[42] = byte(nameLen)
+ copy(b[43:], v.CompressorName[:nameLen])
+ clearBytes(b, 43+nameLen, 74)
+ depth := v.Depth
+ if depth == 0 {
+ depth = 0x18
+ }
+ be.PutUint16(b[74:76], depth)
+ binary.BigEndian.PutUint16(b[76:78], 0xffff) // -1 as int16
+
+ ptr := 78
+ for _, child := range v.Children {
+ n, _ := encodeBox(child, buf, offset+ptr)
+ ptr += n
+ }
+ return ptr
+}
+
+func encodingLengthVisual(box *Box) int {
+ n := 78
+ for _, child := range box.Visual.Children {
+ n += int(EncodingLength(child))
+ }
+ return n
+}
+
+// --- avcC ---
+
+func decodeAvcC(box *Box, buf []byte, start, end int) error {
+ b := buf[start:end]
+ a := &AvcC{
+ Buffer: make([]byte, len(b)),
+ }
+ copy(a.Buffer, b)
+ if len(b) >= 4 {
+ a.MimeCodec = fmt.Sprintf("%02x%02x%02x", b[1], b[2], b[3])
+ }
+ box.AvcC = a
+ return nil
+}
+
+func encodeAvcC(box *Box, buf []byte, offset int) int {
+ copy(buf[offset:], box.AvcC.Buffer)
+ return len(box.AvcC.Buffer)
+}
+
+func encodingLengthAvcC(box *Box) int { return len(box.AvcC.Buffer) }
+
+// --- mp4a / AudioSampleEntry ---
+
+func decodeAudio(box *Box, buf []byte, start, end int) error {
+ b := buf[start:end]
+ length := end - start
+ a := &AudioSampleEntry{
+ DataReferenceIndex: be.Uint16(b[6:8]),
+ ChannelCount: be.Uint16(b[16:18]),
+ SampleSize: be.Uint16(b[18:20]),
+ SampleRate: be.Uint32(b[24:28]),
+ }
+
+ ptr := 28
+ for length-ptr >= 8 {
+ child, err := Decode(buf, start+ptr, end)
+ if err != nil {
+ return err
+ }
+ a.Children = append(a.Children, child)
+ ptr += int(child.Size)
+ }
+ box.Audio = a
+ return nil
+}
+
+func encodeAudio(box *Box, buf []byte, offset int) int {
+ b := buf[offset:]
+ a := box.Audio
+ clearBytes(b, 0, 6)
+ be.PutUint16(b[6:8], a.DataReferenceIndex)
+ clearBytes(b, 8, 16)
+ cc := a.ChannelCount
+ if cc == 0 {
+ cc = 2
+ }
+ be.PutUint16(b[16:18], cc)
+ ss := a.SampleSize
+ if ss == 0 {
+ ss = 16
+ }
+ be.PutUint16(b[18:20], ss)
+ clearBytes(b, 20, 24)
+ be.PutUint32(b[24:28], a.SampleRate)
+
+ ptr := 28
+ for _, child := range a.Children {
+ n, _ := encodeBox(child, buf, offset+ptr)
+ ptr += n
+ }
+ return ptr
+}
+
+func encodingLengthAudio(box *Box) int {
+ n := 28
+ for _, child := range box.Audio.Children {
+ n += int(EncodingLength(child))
+ }
+ return n
+}
+
+// --- esds ---
+
+func decodeEsds(box *Box, buf []byte, start, end int) error {
+ b := buf[start:end]
+ e := &Esds{
+ Buffer: make([]byte, len(b)),
+ }
+ copy(e.Buffer, b)
+
+ // Parse descriptor for mimeCodec
+ desc := decodeDescriptor(b, 0, len(b))
+ if desc != nil && desc.tagName == "ESDescriptor" {
+ if dcd, ok := desc.children["DecoderConfigDescriptor"]; ok {
+ oti := dcd.oti
+ if oti != 0 {
+ e.MimeCodec = fmt.Sprintf("%x", oti)
+ if dsi, ok := dcd.children["DecoderSpecificInfo"]; ok && len(dsi.buffer) > 0 {
+ audioConfig := (dsi.buffer[0] & 0xf8) >> 3
+ if audioConfig != 0 {
+ e.MimeCodec += fmt.Sprintf(".%d", audioConfig)
+ }
+ }
+ }
+ }
+ }
+ box.Esds = e
+ return nil
+}
+
+func encodeEsds(box *Box, buf []byte, offset int) int {
+ copy(buf[offset:], box.Esds.Buffer)
+ return len(box.Esds.Buffer)
+}
+
+func encodingLengthEsds(box *Box) int { return len(box.Esds.Buffer) }
+
+// --- stsz ---
+
+func decodeStsz(box *Box, buf []byte, start, _ int) error {
+ b := buf[start:]
+ sampleSize := be.Uint32(b[0:4])
+ num := int(be.Uint32(b[4:8]))
+ entries := make([]uint32, num)
+ for i := 0; i < num; i++ {
+ if sampleSize == 0 {
+ entries[i] = be.Uint32(b[8+i*4:])
+ } else {
+ entries[i] = sampleSize
+ }
+ }
+ box.Stsz = &Stsz{SampleSize: sampleSize, Entries: entries}
+ return nil
+}
+
+func encodeStsz(box *Box, buf []byte, offset int) int {
+ b := buf[offset:]
+ s := box.Stsz
+ be.PutUint32(b[0:4], 0)
+ be.PutUint32(b[4:8], uint32(len(s.Entries)))
+ for i, e := range s.Entries {
+ be.PutUint32(b[8+i*4:], e)
+ }
+ return 8 + len(s.Entries)*4
+}
+
+func encodingLengthStsz(box *Box) int {
+ return 8 + len(box.Stsz.Entries)*4
+}
+
+// --- stco / stss ---
+
+func decodeStco(box *Box, buf []byte, start, _ int) error {
+ b := buf[start:]
+ num := int(be.Uint32(b[0:4]))
+ entries := make([]uint32, num)
+ for i := 0; i < num; i++ {
+ entries[i] = be.Uint32(b[4+i*4:])
+ }
+ box.Stco = &Stco{Entries: entries}
+ return nil
+}
+
+func encodeStco(box *Box, buf []byte, offset int) int {
+ b := buf[offset:]
+ s := box.Stco
+ be.PutUint32(b[0:4], uint32(len(s.Entries)))
+ for i, e := range s.Entries {
+ be.PutUint32(b[4+i*4:], e)
+ }
+ return 4 + len(s.Entries)*4
+}
+
+func encodingLengthStco(box *Box) int {
+ return 4 + len(box.Stco.Entries)*4
+}
+
+// --- co64 ---
+
+func decodeCo64(box *Box, buf []byte, start, _ int) error {
+ b := buf[start:]
+ num := int(be.Uint32(b[0:4]))
+ entries := make([]uint64, num)
+ for i := 0; i < num; i++ {
+ entries[i] = be.Uint64(b[4+i*8:])
+ }
+ box.Co64 = &Co64{Entries: entries}
+ return nil
+}
+
+func encodeCo64(box *Box, buf []byte, offset int) int {
+ b := buf[offset:]
+ s := box.Co64
+ be.PutUint32(b[0:4], uint32(len(s.Entries)))
+ for i, e := range s.Entries {
+ be.PutUint64(b[4+i*8:], e)
+ }
+ return 4 + len(s.Entries)*8
+}
+
+func encodingLengthCo64(box *Box) int {
+ return 4 + len(box.Co64.Entries)*8
+}
+
+// --- stts ---
+
+func decodeStts(box *Box, buf []byte, start, _ int) error {
+ b := buf[start:]
+ num := int(be.Uint32(b[0:4]))
+ entries := make([]STTSEntry, num)
+ for i := 0; i < num; i++ {
+ ptr := 4 + i*8
+ entries[i] = STTSEntry{
+ Count: be.Uint32(b[ptr:]),
+ Duration: be.Uint32(b[ptr+4:]),
+ }
+ }
+ box.Stts = &Stts{Entries: entries}
+ return nil
+}
+
+func encodeStts(box *Box, buf []byte, offset int) int {
+ b := buf[offset:]
+ s := box.Stts
+ be.PutUint32(b[0:4], uint32(len(s.Entries)))
+ for i, e := range s.Entries {
+ ptr := 4 + i*8
+ be.PutUint32(b[ptr:], e.Count)
+ be.PutUint32(b[ptr+4:], e.Duration)
+ }
+ return 4 + len(s.Entries)*8
+}
+
+func encodingLengthStts(box *Box) int {
+ return 4 + len(box.Stts.Entries)*8
+}
+
+// --- ctts ---
+
+func decodeCtts(box *Box, buf []byte, start, _ int) error {
+ b := buf[start:]
+ num := int(be.Uint32(b[0:4]))
+ entries := make([]CTTSEntry, num)
+ for i := 0; i < num; i++ {
+ ptr := 4 + i*8
+ entries[i] = CTTSEntry{
+ Count: be.Uint32(b[ptr:]),
+ CompositionOffset: int32(be.Uint32(b[ptr+4:])),
+ }
+ }
+ box.Ctts = &Ctts{Entries: entries}
+ return nil
+}
+
+func encodeCtts(box *Box, buf []byte, offset int) int {
+ b := buf[offset:]
+ s := box.Ctts
+ be.PutUint32(b[0:4], uint32(len(s.Entries)))
+ for i, e := range s.Entries {
+ ptr := 4 + i*8
+ be.PutUint32(b[ptr:], e.Count)
+ be.PutUint32(b[ptr+4:], uint32(e.CompositionOffset))
+ }
+ return 4 + len(s.Entries)*8
+}
+
+func encodingLengthCtts(box *Box) int {
+ return 4 + len(box.Ctts.Entries)*8
+}
+
+// --- stsc ---
+
+func decodeStsc(box *Box, buf []byte, start, _ int) error {
+ b := buf[start:]
+ num := int(be.Uint32(b[0:4]))
+ entries := make([]STSCEntry, num)
+ for i := 0; i < num; i++ {
+ ptr := 4 + i*12
+ entries[i] = STSCEntry{
+ FirstChunk: be.Uint32(b[ptr:]),
+ SamplesPerChunk: be.Uint32(b[ptr+4:]),
+ SampleDescriptionId: be.Uint32(b[ptr+8:]),
+ }
+ }
+ box.Stsc = &Stsc{Entries: entries}
+ return nil
+}
+
+func encodeStsc(box *Box, buf []byte, offset int) int {
+ b := buf[offset:]
+ s := box.Stsc
+ be.PutUint32(b[0:4], uint32(len(s.Entries)))
+ for i, e := range s.Entries {
+ ptr := 4 + i*12
+ be.PutUint32(b[ptr:], e.FirstChunk)
+ be.PutUint32(b[ptr+4:], e.SamplesPerChunk)
+ be.PutUint32(b[ptr+8:], e.SampleDescriptionId)
+ }
+ return 4 + len(s.Entries)*12
+}
+
+func encodingLengthStsc(box *Box) int {
+ return 4 + len(box.Stsc.Entries)*12
+}
+
+// --- dref ---
+
+func decodeDref(box *Box, buf []byte, start, _ int) error {
+ b := buf[start:]
+ num := int(be.Uint32(b[0:4]))
+ entries := make([]DrefEntry, num)
+ ptr := 4
+ for i := 0; i < num; i++ {
+ size := int(be.Uint32(b[ptr:]))
+ var t [4]byte
+ copy(t[:], b[ptr+4:ptr+8])
+ dataBuf := make([]byte, size-8)
+ copy(dataBuf, b[ptr+8:ptr+size])
+ entries[i] = DrefEntry{Type: t, Buf: dataBuf}
+ ptr += size
+ }
+ box.Dref = &DrefBox{Entries: entries}
+ return nil
+}
+
+func encodeDref(box *Box, buf []byte, offset int) int {
+ b := buf[offset:]
+ d := box.Dref
+ be.PutUint32(b[0:4], uint32(len(d.Entries)))
+ ptr := 4
+ for _, e := range d.Entries {
+ size := 8 + len(e.Buf)
+ be.PutUint32(b[ptr:], uint32(size))
+ copy(b[ptr+4:], e.Type[:])
+ copy(b[ptr+8:], e.Buf)
+ ptr += size
+ }
+ return ptr
+}
+
+func encodingLengthDref(box *Box) int {
+ total := 4
+ for _, e := range box.Dref.Entries {
+ total += 8 + len(e.Buf)
+ }
+ return total
+}
+
+// --- elst ---
+
+func decodeElst(box *Box, buf []byte, start, _ int) error {
+ b := buf[start:]
+ num := int(be.Uint32(b[0:4]))
+ entries := make([]ElstEntry, num)
+ for i := 0; i < num; i++ {
+ ptr := 4 + i*12
+ var mr [4]byte
+ copy(mr[:], b[ptr+8:ptr+12])
+ entries[i] = ElstEntry{
+ TrackDuration: be.Uint32(b[ptr:]),
+ MediaTime: int32(be.Uint32(b[ptr+4:])),
+ MediaRate: mr,
+ }
+ }
+ box.Elst = &Elst{Entries: entries}
+ return nil
+}
+
+func encodeElst(box *Box, buf []byte, offset int) int {
+ b := buf[offset:]
+ s := box.Elst
+ be.PutUint32(b[0:4], uint32(len(s.Entries)))
+ for i, e := range s.Entries {
+ ptr := 4 + i*12
+ be.PutUint32(b[ptr:], e.TrackDuration)
+ be.PutUint32(b[ptr+4:], uint32(e.MediaTime))
+ copy(b[ptr+8:ptr+12], e.MediaRate[:])
+ }
+ return 4 + len(s.Entries)*12
+}
+
+func encodingLengthElst(box *Box) int {
+ return 4 + len(box.Elst.Entries)*12
+}
+
+// --- hdlr ---
+
+func decodeHdlr(box *Box, buf []byte, start, end int) error {
+ b := buf[start:end]
+ h := &Hdlr{}
+ copy(h.HandlerType[:], b[4:8])
+ h.Name = readString(b, 20, end-start)
+ box.Hdlr = h
+ return nil
+}
+
+func encodeHdlr(box *Box, buf []byte, offset int) int {
+ b := buf[offset:]
+ h := box.Hdlr
+ nameLen := len(h.Name)
+ total := 21 + nameLen
+ clearBytes(b, 0, total)
+ copy(b[4:8], h.HandlerType[:])
+ copy(b[20:], h.Name)
+ b[20+nameLen] = 0
+ return total
+}
+
+func encodingLengthHdlr(box *Box) int {
+ return 21 + len(box.Hdlr.Name)
+}
+
+// --- mehd ---
+
+func decodeMehd(box *Box, buf []byte, start, _ int) error {
+ box.Mehd = &Mehd{FragmentDuration: be.Uint32(buf[start:])}
+ return nil
+}
+
+func encodeMehd(box *Box, buf []byte, offset int) int {
+ be.PutUint32(buf[offset:], box.Mehd.FragmentDuration)
+ return 4
+}
+
+func encodingLengthMehd(_ *Box) int { return 4 }
+
+// --- trex ---
+
+func decodeTrex(box *Box, buf []byte, start, _ int) error {
+ b := buf[start:]
+ box.Trex = &Trex{
+ TrackId: be.Uint32(b[0:4]),
+ DefaultSampleDescriptionIndex: be.Uint32(b[4:8]),
+ DefaultSampleDuration: be.Uint32(b[8:12]),
+ DefaultSampleSize: be.Uint32(b[12:16]),
+ DefaultSampleFlags: be.Uint32(b[16:20]),
+ }
+ return nil
+}
+
+func encodeTrex(box *Box, buf []byte, offset int) int {
+ b := buf[offset:]
+ t := box.Trex
+ be.PutUint32(b[0:4], t.TrackId)
+ be.PutUint32(b[4:8], t.DefaultSampleDescriptionIndex)
+ be.PutUint32(b[8:12], t.DefaultSampleDuration)
+ be.PutUint32(b[12:16], t.DefaultSampleSize)
+ be.PutUint32(b[16:20], t.DefaultSampleFlags)
+ return 20
+}
+
+func encodingLengthTrex(_ *Box) int { return 20 }
+
+// --- mfhd ---
+
+func decodeMfhd(box *Box, buf []byte, start, _ int) error {
+ box.Mfhd = &Mfhd{SequenceNumber: be.Uint32(buf[start:])}
+ return nil
+}
+
+func encodeMfhd(box *Box, buf []byte, offset int) int {
+ be.PutUint32(buf[offset:], box.Mfhd.SequenceNumber)
+ return 4
+}
+
+func encodingLengthMfhd(_ *Box) int { return 4 }
+
+// --- tfhd ---
+
+func decodeTfhd(box *Box, buf []byte, start, _ int) error {
+ box.Tfhd = &Tfhd{TrackId: be.Uint32(buf[start:])}
+ return nil
+}
+
+func encodeTfhd(box *Box, buf []byte, offset int) int {
+ be.PutUint32(buf[offset:], box.Tfhd.TrackId)
+ return 4
+}
+
+func encodingLengthTfhd(_ *Box) int { return 4 }
+
+// --- tfdt ---
+
+func decodeTfdt(box *Box, buf []byte, start, _ int) error {
+ box.Tfdt = &Tfdt{BaseMediaDecodeTime: be.Uint32(buf[start:])}
+ return nil
+}
+
+func encodeTfdt(box *Box, buf []byte, offset int) int {
+ be.PutUint32(buf[offset:], box.Tfdt.BaseMediaDecodeTime)
+ return 4
+}
+
+func encodingLengthTfdt(_ *Box) int { return 4 }
+
+// --- trun ---
+
+func decodeTrun(box *Box, buf []byte, start, _ int) error {
+ b := buf[start:]
+ num := int(be.Uint32(b[0:4]))
+ t := &Trun{
+ DataOffset: int32(be.Uint32(b[4:8])),
+ Entries: make([]TrunEntry, num),
+ }
+ ptr := 8
+ for i := 0; i < num; i++ {
+ e := TrunEntry{
+ SampleDuration: be.Uint32(b[ptr:]),
+ SampleSize: be.Uint32(b[ptr+4:]),
+ SampleFlags: be.Uint32(b[ptr+8:]),
+ SampleCompositionTimeOffset: int32(be.Uint32(b[ptr+12:])),
+ }
+ t.Entries[i] = e
+ ptr += 16
+ }
+ box.Trun = t
+ return nil
+}
+
+func encodeTrun(box *Box, buf []byte, offset int) int {
+ b := buf[offset:]
+ t := box.Trun
+ be.PutUint32(b[0:4], uint32(len(t.Entries)))
+ be.PutUint32(b[4:8], uint32(t.DataOffset))
+ ptr := 8
+ for _, e := range t.Entries {
+ be.PutUint32(b[ptr:], e.SampleDuration)
+ be.PutUint32(b[ptr+4:], e.SampleSize)
+ be.PutUint32(b[ptr+8:], e.SampleFlags)
+ be.PutUint32(b[ptr+12:], uint32(e.SampleCompositionTimeOffset))
+ ptr += 16
+ }
+ return ptr
+}
+
+func encodingLengthTrun(box *Box) int {
+ return 8 + len(box.Trun.Entries)*16
+}
+
+// --- mdat ---
+
+func decodeMdat(box *Box, buf []byte, start, end int) error {
+ b := make([]byte, end-start)
+ copy(b, buf[start:end])
+ box.Mdat = &Mdat{Buffer: b}
+ return nil
+}
+
+func encodeMdat(box *Box, buf []byte, offset int) int {
+ m := box.Mdat
+ if m.Buffer != nil {
+ copy(buf[offset:], m.Buffer)
+ return len(m.Buffer)
+ }
+ return m.ContentLength
+}
+
+func encodingLengthMdat(box *Box) int {
+ m := box.Mdat
+ if m.Buffer != nil {
+ return len(m.Buffer)
+ }
+ return m.ContentLength
+}