aboutsummaryrefslogtreecommitdiff
path: root/iter.go
diff options
context:
space:
mode:
authorOnur Gündüz <ogunduz@gmail.com>2026-02-13 11:24:24 +0100
committerOnur Gündüz <ogunduz@gmail.com>2026-02-13 11:28:45 +0100
commitf4b35bb7f4475db77fa6969eb42964824f616fb0 (patch)
tree54046849b6606d8160b563077234c3ff284a96a7 /iter.go
parent8502816a943bb33705a7775838c760ed72046ae8 (diff)
downloadmp4-f4b35bb7f4475db77fa6969eb42964824f616fb0.tar.gz
mp4-f4b35bb7f4475db77fa6969eb42964824f616fb0.zip
v2
Diffstat (limited to 'iter.go')
-rw-r--r--iter.go524
1 files changed, 524 insertions, 0 deletions
diff --git a/iter.go b/iter.go
new file mode 100644
index 0000000..8fb4697
--- /dev/null
+++ b/iter.go
@@ -0,0 +1,524 @@
+package mp4
+
+import (
+ "encoding/binary"
+ "math"
+)
+
+var be = binary.BigEndian
+
+const uint32Max = math.MaxUint32
+
+// StszIter iterates over sample sizes in an stsz box.
+type StszIter struct {
+ buf []byte
+ sampleSize uint32
+ count uint32
+ index uint32
+}
+
+// NewStszIter creates an iterator from stsz box data.
+func NewStszIter(data []byte) StszIter {
+ if len(data) < 8 {
+ return StszIter{}
+ }
+ return StszIter{
+ buf: data,
+ sampleSize: be.Uint32(data[0:4]),
+ count: be.Uint32(data[4:8]),
+ }
+}
+
+// Count returns the total number of samples.
+func (it *StszIter) Count() uint32 { return it.count }
+
+// Next returns the next sample size. Returns (0, false) when done.
+func (it *StszIter) Next() (uint32, bool) {
+ if it.index >= it.count {
+ return 0, false
+ }
+ var size uint32
+ if it.sampleSize != 0 {
+ size = it.sampleSize
+ } else {
+ offset := 8 + int(it.index)*4
+ if offset+4 > len(it.buf) {
+ return 0, false
+ }
+ size = be.Uint32(it.buf[offset:])
+ }
+ it.index++
+ return size, true
+}
+
+// Co64Iter iterates over uint64 chunk offsets in a co64 box.
+type Co64Iter struct {
+ buf []byte
+ count uint32
+ index uint32
+}
+
+// NewCo64Iter creates an iterator from co64 box data.
+func NewCo64Iter(data []byte) Co64Iter {
+ if len(data) < 4 {
+ return Co64Iter{}
+ }
+ return Co64Iter{
+ buf: data,
+ count: be.Uint32(data[0:4]),
+ }
+}
+
+// Count returns the total number of entries.
+func (it *Co64Iter) Count() uint32 { return it.count }
+
+// Next returns the next chunk offset. Returns (0, false) when done.
+func (it *Co64Iter) Next() (uint64, bool) {
+ if it.index >= it.count {
+ return 0, false
+ }
+ offset := 4 + int(it.index)*8
+ if offset+8 > len(it.buf) {
+ return 0, false
+ }
+ v := be.Uint64(it.buf[offset:])
+ it.index++
+ return v, true
+}
+
+// SttsEntry is a time-to-sample entry.
+type SttsEntry struct {
+ Count uint32
+ Duration uint32
+}
+
+// SttsIter iterates over stts entries.
+type SttsIter struct {
+ buf []byte
+ count uint32
+ index uint32
+}
+
+// NewSttsIter creates an iterator from stts box data.
+func NewSttsIter(data []byte) SttsIter {
+ if len(data) < 4 {
+ return SttsIter{}
+ }
+ return SttsIter{
+ buf: data,
+ count: be.Uint32(data[0:4]),
+ }
+}
+
+// Count returns the total number of entries.
+func (it *SttsIter) Count() uint32 { return it.count }
+
+// Next returns the next entry. Returns false when done.
+func (it *SttsIter) Next() (SttsEntry, bool) {
+ if it.index >= it.count {
+ return SttsEntry{}, false
+ }
+ offset := 4 + int(it.index)*8
+ if offset+8 > len(it.buf) {
+ return SttsEntry{}, false
+ }
+ e := SttsEntry{
+ Count: be.Uint32(it.buf[offset:]),
+ Duration: be.Uint32(it.buf[offset+4:]),
+ }
+ it.index++
+ return e, true
+}
+
+// CttsEntry is a composition offset entry.
+type CttsEntry struct {
+ Count uint32
+ Offset int32
+}
+
+// CttsIter iterates over ctts entries.
+type CttsIter struct {
+ buf []byte
+ count uint32
+ index uint32
+}
+
+// NewCttsIter creates an iterator from ctts box data.
+func NewCttsIter(data []byte) CttsIter {
+ if len(data) < 4 {
+ return CttsIter{}
+ }
+ return CttsIter{
+ buf: data,
+ count: be.Uint32(data[0:4]),
+ }
+}
+
+// Count returns the total number of entries.
+func (it *CttsIter) Count() uint32 { return it.count }
+
+// Next returns the next entry. Returns false when done.
+func (it *CttsIter) Next() (CttsEntry, bool) {
+ if it.index >= it.count {
+ return CttsEntry{}, false
+ }
+ offset := 4 + int(it.index)*8
+ if offset+8 > len(it.buf) {
+ return CttsEntry{}, false
+ }
+ e := CttsEntry{
+ Count: be.Uint32(it.buf[offset:]),
+ Offset: int32(be.Uint32(it.buf[offset+4:])),
+ }
+ it.index++
+ return e, true
+}
+
+// StscEntry is a sample-to-chunk entry.
+type StscEntry struct {
+ FirstChunk uint32
+ SamplesPerChunk uint32
+ SampleDescriptionId uint32
+}
+
+// StscIter iterates over stsc entries.
+type StscIter struct {
+ buf []byte
+ count uint32
+ index uint32
+}
+
+// NewStscIter creates an iterator from stsc box data.
+func NewStscIter(data []byte) StscIter {
+ if len(data) < 4 {
+ return StscIter{}
+ }
+ return StscIter{
+ buf: data,
+ count: be.Uint32(data[0:4]),
+ }
+}
+
+// Count returns the total number of entries.
+func (it *StscIter) Count() uint32 { return it.count }
+
+// Next returns the next entry. Returns false when done.
+func (it *StscIter) Next() (StscEntry, bool) {
+ if it.index >= it.count {
+ return StscEntry{}, false
+ }
+ offset := 4 + int(it.index)*12
+ if offset+12 > len(it.buf) {
+ return StscEntry{}, false
+ }
+ e := StscEntry{
+ FirstChunk: be.Uint32(it.buf[offset:]),
+ SamplesPerChunk: be.Uint32(it.buf[offset+4:]),
+ SampleDescriptionId: be.Uint32(it.buf[offset+8:]),
+ }
+ it.index++
+ return e, true
+}
+
+// ElstEntry is an edit list entry.
+type ElstEntry struct {
+ SegmentDuration uint64
+ MediaTime int64
+ MediaRateInt int16
+ MediaRateFrac int16
+}
+
+// ElstIter iterates over elst entries.
+type ElstIter struct {
+ buf []byte
+ count uint32
+ index uint32
+ version uint8
+}
+
+// NewElstIter creates an iterator from elst box data with the given version.
+func NewElstIter(data []byte, version uint8) ElstIter {
+ if len(data) < 4 {
+ return ElstIter{}
+ }
+ return ElstIter{
+ buf: data,
+ count: be.Uint32(data[0:4]),
+ version: version,
+ }
+}
+
+// Count returns the total number of entries.
+func (it *ElstIter) Count() uint32 { return it.count }
+
+// Next returns the next entry. Returns false when done.
+func (it *ElstIter) Next() (ElstEntry, bool) {
+ if it.index >= it.count {
+ return ElstEntry{}, false
+ }
+ var e ElstEntry
+ if it.version == 1 {
+ stride := 20
+ offset := 4 + int(it.index)*stride
+ if offset+stride > len(it.buf) {
+ return ElstEntry{}, false
+ }
+ e.SegmentDuration = be.Uint64(it.buf[offset:])
+ e.MediaTime = int64(be.Uint64(it.buf[offset+8:]))
+ e.MediaRateInt = int16(be.Uint16(it.buf[offset+16:]))
+ e.MediaRateFrac = int16(be.Uint16(it.buf[offset+18:]))
+ } else {
+ stride := 12
+ offset := 4 + int(it.index)*stride
+ if offset+stride > len(it.buf) {
+ return ElstEntry{}, false
+ }
+ e.SegmentDuration = uint64(be.Uint32(it.buf[offset:]))
+ e.MediaTime = int64(int32(be.Uint32(it.buf[offset+4:])))
+ e.MediaRateInt = int16(be.Uint16(it.buf[offset+8:]))
+ e.MediaRateFrac = int16(be.Uint16(it.buf[offset+10:]))
+ }
+ it.index++
+ return e, true
+}
+
+// TrunEntry is a track run sample entry.
+type TrunEntry struct {
+ Duration uint32
+ Size uint32
+ Flags uint32
+ CompositionTimeOffset int32
+}
+
+// Trun flags.
+const (
+ TrunDataOffsetPresent = 0x000001
+ TrunFirstSampleFlagsPresent = 0x000004
+ TrunSampleDurationPresent = 0x000100
+ TrunSampleSizePresent = 0x000200
+ TrunSampleFlagsPresent = 0x000400
+ TrunSampleCompositionTimeOffsetPresent = 0x000800
+)
+
+// TrunIter iterates over trun entries.
+type TrunIter struct {
+ buf []byte
+ flags uint32
+ count uint32
+ index uint32
+ dataOffset int32
+ firstSampleFlags uint32
+ stride int
+ entriesStart int
+}
+
+// NewTrunIter creates an iterator from trun box data with the given flags.
+func NewTrunIter(data []byte, flags uint32) TrunIter {
+ if len(data) < 4 {
+ return TrunIter{}
+ }
+ it := TrunIter{
+ buf: data,
+ flags: flags,
+ count: be.Uint32(data[0:4]),
+ }
+ ptr := 4
+ if flags&TrunDataOffsetPresent != 0 {
+ if ptr+4 > len(data) {
+ return TrunIter{}
+ }
+ it.dataOffset = int32(be.Uint32(data[ptr:]))
+ ptr += 4
+ }
+ if flags&TrunFirstSampleFlagsPresent != 0 {
+ if ptr+4 > len(data) {
+ return TrunIter{}
+ }
+ it.firstSampleFlags = be.Uint32(data[ptr:])
+ ptr += 4
+ }
+ it.entriesStart = ptr
+
+ if flags&TrunSampleDurationPresent != 0 {
+ it.stride += 4
+ }
+ if flags&TrunSampleSizePresent != 0 {
+ it.stride += 4
+ }
+ if flags&TrunSampleFlagsPresent != 0 {
+ it.stride += 4
+ }
+ if flags&TrunSampleCompositionTimeOffsetPresent != 0 {
+ it.stride += 4
+ }
+ return it
+}
+
+// Count returns the total number of samples.
+func (it *TrunIter) Count() uint32 { return it.count }
+
+// DataOffset returns the trun data offset.
+func (it *TrunIter) DataOffset() int32 { return it.dataOffset }
+
+// FirstSampleFlags returns the first sample flags, if present.
+func (it *TrunIter) FirstSampleFlags() uint32 { return it.firstSampleFlags }
+
+// Next returns the next sample entry. Returns false when done.
+func (it *TrunIter) Next() (TrunEntry, bool) {
+ if it.index >= it.count {
+ return TrunEntry{}, false
+ }
+ offset := it.entriesStart + int(it.index)*it.stride
+ if offset+it.stride > len(it.buf) {
+ return TrunEntry{}, false
+ }
+ var e TrunEntry
+ p := offset
+ if it.flags&TrunSampleDurationPresent != 0 {
+ e.Duration = be.Uint32(it.buf[p:])
+ p += 4
+ }
+ if it.flags&TrunSampleSizePresent != 0 {
+ e.Size = be.Uint32(it.buf[p:])
+ p += 4
+ }
+ if it.flags&TrunSampleFlagsPresent != 0 {
+ e.Flags = be.Uint32(it.buf[p:])
+ p += 4
+ }
+ if it.flags&TrunSampleCompositionTimeOffsetPresent != 0 {
+ e.CompositionTimeOffset = int32(be.Uint32(it.buf[p:]))
+ }
+ it.index++
+ return e, true
+}
+
+// Uint32Iter iterates over uint32 entries (stco, stss).
+type Uint32Iter struct {
+ buf []byte
+ count uint32
+ index uint32
+}
+
+// NewUint32Iter creates an iterator from box data containing a count + uint32 entries.
+func NewUint32Iter(data []byte) Uint32Iter {
+ if len(data) < 4 {
+ return Uint32Iter{}
+ }
+ return Uint32Iter{
+ buf: data,
+ count: be.Uint32(data[0:4]),
+ }
+}
+
+// Count returns the total number of entries.
+func (it *Uint32Iter) Count() uint32 { return it.count }
+
+// Next returns the next entry. Returns (0, false) when done.
+func (it *Uint32Iter) Next() (uint32, bool) {
+ if it.index >= it.count {
+ return 0, false
+ }
+ offset := 4 + int(it.index)*4
+ if offset+4 > len(it.buf) {
+ return 0, false
+ }
+ v := be.Uint32(it.buf[offset:])
+ it.index++
+ return v, true
+}
+
+// FtypInfo holds parsed fields from an ftyp box.
+type FtypInfo struct {
+ MajorBrand [4]byte
+ MinorVersion uint32
+ Compatible [][4]byte
+}
+
+// ReadFtyp parses an ftyp box.
+func ReadFtyp(data []byte) FtypInfo {
+ f := FtypInfo{
+ MinorVersion: be.Uint32(data[4:8]),
+ }
+ copy(f.MajorBrand[:], data[0:4])
+ for i := 8; i+4 <= len(data); i += 4 {
+ var b [4]byte
+ copy(b[:], data[i:i+4])
+ f.Compatible = append(f.Compatible, b)
+ }
+ return f
+}
+
+// VisualSampleEntry holds parsed fields from a visual sample entry (e.g. avc1).
+type VisualSampleEntry struct {
+ DataReferenceIndex uint16
+ Width uint16
+ Height uint16
+ HResolution uint32 // 16.16 fixed point
+ VResolution uint32 // 16.16 fixed point
+ FrameCount uint16
+ CompressorName string
+ Depth uint16
+ ChildOffset int // byte offset within data where child boxes begin
+}
+
+// ReadVisualSampleEntry parses a visual sample entry from box data.
+// Child boxes (e.g. avcC) start at ChildOffset within the data.
+func ReadVisualSampleEntry(data []byte) VisualSampleEntry {
+ nameLen := min(int(data[42]), 31)
+ return VisualSampleEntry{
+ DataReferenceIndex: be.Uint16(data[6:8]),
+ Width: be.Uint16(data[24:26]),
+ Height: be.Uint16(data[26:28]),
+ HResolution: be.Uint32(data[28:32]),
+ VResolution: be.Uint32(data[32:36]),
+ FrameCount: be.Uint16(data[40:42]),
+ CompressorName: string(data[43 : 43+nameLen]),
+ Depth: be.Uint16(data[74:76]),
+ ChildOffset: 78,
+ }
+}
+
+// AudioSampleEntry holds parsed fields from an audio sample entry (e.g. mp4a).
+type AudioSampleEntry struct {
+ DataReferenceIndex uint16
+ ChannelCount uint16
+ SampleSize uint16
+ SampleRate uint32 // 16.16 fixed point
+ ChildOffset int // byte offset within data where child boxes begin
+}
+
+// ReadAudioSampleEntry parses an audio sample entry from box data.
+// Child boxes (e.g. esds) start at ChildOffset within the data.
+func ReadAudioSampleEntry(data []byte) AudioSampleEntry {
+ return AudioSampleEntry{
+ DataReferenceIndex: be.Uint16(data[6:8]),
+ ChannelCount: be.Uint16(data[16:18]),
+ SampleSize: be.Uint16(data[18:20]),
+ SampleRate: be.Uint32(data[24:28]),
+ ChildOffset: 28,
+ }
+}
+
+// ReadAvcC extracts the codec profile string from avcC box data.
+// Returns a string like "64001f" for use in MIME type codec parameters.
+func ReadAvcC(data []byte) string {
+ if len(data) < 4 {
+ return ""
+ }
+ var buf [6]byte
+ buf[0] = hexDigit(data[1] >> 4)
+ buf[1] = hexDigit(data[1] & 0x0f)
+ buf[2] = hexDigit(data[2] >> 4)
+ buf[3] = hexDigit(data[2] & 0x0f)
+ buf[4] = hexDigit(data[3] >> 4)
+ buf[5] = hexDigit(data[3] & 0x0f)
+ return string(buf[:])
+}
+
+const hexChars = "0123456789abcdef"
+
+// hexDigit returns the lowercase hex character for a 4-bit nibble.
+func hexDigit(b byte) byte {
+ return hexChars[b&0x0f]
+}