aboutsummaryrefslogtreecommitdiff
path: root/fragment
diff options
context:
space:
mode:
authorOnur Gündüz <ogunduz@gmail.com>2026-09-15 00:07:23 +0200
committerOnur Gündüz <ogunduz@gmail.com>2026-09-15 00:07:23 +0200
commit30d1ade78dce56c97bb6e1585da3fcb71784c43e (patch)
tree7986d3116d14748471519d14d5d7fe9de16f8715 /fragment
parentd2b3cde2cff3cdfc0cf435e91fad6d40cbc8e85e (diff)
downloadmp4-30d1ade78dce56c97bb6e1585da3fcb71784c43e.tar.gz
mp4-30d1ade78dce56c97bb6e1585da3fcb71784c43e.zip
fragment: support multi-track and per-track output
Diffstat (limited to 'fragment')
-rw-r--r--fragment/reader.go370
-rw-r--r--fragment/reader_test.go109
-rw-r--r--fragment/track_selection_test.go771
-rw-r--r--fragment/writer.go187
-rw-r--r--fragment/writer_benchmark_test.go80
5 files changed, 1320 insertions, 197 deletions
diff --git a/fragment/reader.go b/fragment/reader.go
index c051b21..d07fdff 100644
--- a/fragment/reader.go
+++ b/fragment/reader.go
@@ -47,10 +47,12 @@ var (
ErrInvalidTimeRange = errors.New("invalid time range")
// ErrReaderNotInitialized is returned when ReadFragment or Seek is called before initialization.
ErrReaderNotInitialized = errors.New("reader not initialized")
- // ErrNoVideoTrack is returned when no video track is found in the init segment.
- ErrNoVideoTrack = errors.New("no video track")
// ErrInvalidDuration is returned when a non-positive target duration is set.
ErrInvalidDuration = errors.New("invalid target duration")
+ // ErrTrackNotFound is returned when a requested track is not present.
+ ErrTrackNotFound = errors.New("track not found")
+ // ErrUnalignedVideoTrack is returned when video tracks do not share fragment boundaries.
+ ErrUnalignedVideoTrack = errors.New("unaligned video track")
)
const (
@@ -62,13 +64,9 @@ const (
// (unless a sync point forces a break).
minFragmentDuration = 1
- // maxTracks is the maximum number of concurrent tracks supported.
- // Limited to 4 to keep per-track arrays on the stack and avoid
- // heap allocations in the hot path.
- maxTracks = 4
-
- // movieTimescale is the timescale written into the init segment's mvhd.
- movieTimescale = 1000
+ // defaultMovieTimescale is written into the init segment's mvhd when the
+ // source movie timescale is missing or zero.
+ defaultMovieTimescale = 1000
)
// InitSegment holds parsed initialization data (ftyp+moov) for a fragmented MP4.
@@ -76,6 +74,8 @@ type InitSegment struct {
Tracks []*track.Track
Duration uint64
buf []byte
+
+ movieTimescale uint32
}
// VideoTrack returns the first video track, or nil.
@@ -103,6 +103,23 @@ func (s *InitSegment) Bytes() []byte {
return s.buf
}
+// MovieTimescale returns the source movie's timescale used by Duration.
+func (s *InitSegment) MovieTimescale() uint32 {
+ return s.movieTimescale
+}
+
+// TrackBytes builds an initialization segment containing only trackID. dst is
+// reused when it has enough capacity, allowing callers that build many
+// renditions to retain their own buffers without an allocation after warmup.
+func (s *InitSegment) TrackBytes(dst []byte, trackID uint32) ([]byte, error) {
+ selected := track.FindTrack(s.Tracks, trackID)
+ if selected == nil {
+ return nil, ErrTrackNotFound
+ }
+ tracks := [1]*track.Track{selected}
+ return buildInitSegment(dst, tracks[:], s.movieTimescale, s.Duration), nil
+}
+
// Fragment represents samples for one moof+mdat pair.
//
// Returned by [Reader.ReadFragment]; valid until the next ReadFragment call.
@@ -118,14 +135,9 @@ type Reader struct {
sc mp4.Scanner
initSeg *InitSegment // points to initSegStorage once initialized
- trackIdx [maxTracks]int
- dtsBase [maxTracks]int64
- dtsBaseSet [maxTracks]bool
- trackCount int
- videoTrackID uint32
+ trackState []readerTrackState
- videoRun [2]int // last fragment's video sample range [start, end)
- audioRun [2]int // last fragment's audio sample range [start, end)
+ selectedTrackID uint32
sequenceNum uint32
startTime float64
@@ -143,6 +155,14 @@ type Reader struct {
filtered []*track.Track // reused backing for initSegStorage.Tracks
}
+type readerTrackState struct {
+ dtsBase int64
+ sampleIdx int
+ runStart int
+ runEnd int
+ dtsBaseSet bool
+}
+
// NewReader creates a new fragment reader. It parses the moov box from
// the provided reader and builds the init segment for fragmented MP4 output.
// The returned [InitSegment] contains the serialized ftyp+moov and the parsed
@@ -168,6 +188,7 @@ func (f *Reader) Reset(rs io.ReadSeeker) (*InitSegment, error) {
initBuf: f.initBuf[:0],
fragSamples: f.fragSamples[:0],
filtered: f.filtered[:0],
+ trackState: f.trackState[:0],
targetDuration: f.targetDuration,
}
return f.readInit()
@@ -205,6 +226,22 @@ func (f *Reader) SetTargetDuration(seconds float64) error {
return nil
}
+// SelectTrack makes trackID the fragment cut driver and excludes every other
+// track from subsequent fragments. Passing an unknown track ID returns
+// ErrTrackNotFound. Selection resets reading to the configured time range.
+func (f *Reader) SelectTrack(trackID uint32) error {
+ if f.initSeg == nil {
+ return ErrReaderNotInitialized
+ }
+ if track.FindTrack(f.initSeg.Tracks, trackID) == nil {
+ return ErrTrackNotFound
+ }
+ f.selectedTrackID = trackID
+ f.sequenceNum = 1
+ f.initTrackIndices()
+ return nil
+}
+
// readInit parses the moov box and builds the init segment.
func (f *Reader) readInit() (*InitSegment, error) {
if f.initSeg != nil {
@@ -216,90 +253,102 @@ func (f *Reader) readInit() (*InitSegment, error) {
return nil, err
}
- tracks, _, duration, err := track.ParseTracksInto(f.allTracks, moovBuf)
+ tracks, movieTimescale, duration, err := track.ParseTracksInto(f.allTracks, moovBuf)
if err != nil {
return nil, err
}
f.allTracks = tracks
- // Filter to first video + first audio only.
+ // Retain every playable track in source order. The parsed allTracks slice is
+ // kept separately so Reset can reuse every Track and its sample storage.
f.filtered = f.filtered[:0]
- hasVideo, hasAudio := false, false
for _, t := range tracks {
- if t.Kind == track.TrackVideo && !hasVideo {
+ if t.Kind == track.TrackVideo || t.Kind == track.TrackAudio {
f.filtered = append(f.filtered, t)
- hasVideo = true
- } else if t.Kind == track.TrackAudio && !hasAudio {
- f.filtered = append(f.filtered, t)
- hasAudio = true
}
}
if len(f.filtered) == 0 {
return nil, ErrNoPlayableTracks
}
+ if movieTimescale == 0 {
+ movieTimescale = defaultMovieTimescale
+ }
initSeg := &f.initSegStorage
initSeg.Tracks = f.filtered
initSeg.Duration = duration
- initSeg.buf = f.buildInitSegment(initSeg.Tracks, initSeg.Duration)
+ initSeg.movieTimescale = movieTimescale
+ f.initBuf = buildInitSegment(f.initBuf, initSeg.Tracks, movieTimescale, initSeg.Duration)
+ initSeg.buf = f.initBuf
f.initSeg = initSeg
- f.trackCount = len(initSeg.Tracks)
f.sequenceNum = 1
-
- if vt := initSeg.VideoTrack(); vt != nil {
- f.videoTrackID = vt.ID
- }
+ f.resizeTrackState(len(initSeg.Tracks))
f.initTrackIndices()
return initSeg, nil
}
-func (f *Reader) initTrackIndices() {
- f.dtsBaseSet = [maxTracks]bool{}
- f.dtsBase = [maxTracks]int64{}
-
- videoTrack := f.initSeg.VideoTrack()
- var videoStartPTS int64
+func (f *Reader) resizeTrackState(n int) {
+ f.trackState = resizeAndClear(f.trackState, n)
+}
- for i, t := range f.initSeg.Tracks {
- if t.Kind == track.TrackVideo && f.startTime > 0 {
- idx := f.findSampleAfter(t, f.startTime)
- n := len(t.Samples)
+func resizeAndClear[T any](s []T, n int) []T {
+ if cap(s) < n {
+ return make([]T, n)
+ }
+ s = s[:n]
+ clear(s)
+ return s
+}
- if f.endTime > 0 && idx < n {
- endTimeScaled := int64(f.endTime * float64(t.TimeScale))
- if t.Samples[idx].PTS() >= endTimeScaled {
- idx = f.findSampleBefore(t, f.startTime)
- }
- }
+func (f *Reader) initTrackIndices() {
+ clear(f.trackState)
- f.trackIdx[i] = idx
- if idx < n {
- videoStartPTS = t.Samples[idx].PTS()
+ driver := f.cutTrack()
+ driverIdx := f.getTrackIndex(driver.ID)
+ idx := 0
+ if f.startTime > 0 {
+ requireSync := driver.Kind == track.TrackVideo
+ idx = f.findSampleAfter(driver, f.startTime, requireSync)
+ if f.endTime > 0 && idx < len(driver.Samples) {
+ endTimeScaled := int64(f.endTime * float64(driver.TimeScale))
+ if driver.Samples[idx].PTS() >= endTimeScaled {
+ idx = f.findSampleBefore(driver, f.startTime, requireSync)
}
- } else if t.Kind == track.TrackVideo {
- f.trackIdx[i] = 0
}
}
+ f.trackState[driverIdx].sampleIdx = idx
+ var driverStartPTS int64
+ if idx < len(driver.Samples) {
+ driverStartPTS = driver.Samples[idx].PTS()
+ }
for i, t := range f.initSeg.Tracks {
- if t.Kind == track.TrackVideo {
+ if i == driverIdx {
continue
}
- if f.startTime > 0 && videoTrack != nil {
- audioStartTicks := videoStartPTS * int64(t.TimeScale) / int64(videoTrack.TimeScale)
+ if f.startTime > 0 {
+ startTicks := driverStartPTS * int64(t.TimeScale) / int64(driver.TimeScale)
idx := sort.Search(len(t.Samples), func(j int) bool {
- return t.Samples[j].PTS() >= audioStartTicks
+ return t.Samples[j].PTS() >= startTicks
})
- f.trackIdx[i] = idx
- } else {
- f.trackIdx[i] = 0
+ f.trackState[i].sampleIdx = idx
}
}
}
-func (f *Reader) findSampleAfter(track *track.Track, timeSeconds float64) int {
+func (f *Reader) cutTrack() *track.Track {
+ if f.selectedTrackID != 0 {
+ return track.FindTrack(f.initSeg.Tracks, f.selectedTrackID)
+ }
+ if video := f.initSeg.VideoTrack(); video != nil {
+ return video
+ }
+ return f.initSeg.AudioTrack()
+}
+
+func (f *Reader) findSampleAfter(track *track.Track, timeSeconds float64, requireSync bool) int {
scaledTime := int64(timeSeconds * float64(track.TimeScale))
n := len(track.Samples)
idx := sort.Search(n, func(i int) bool {
@@ -308,7 +357,7 @@ func (f *Reader) findSampleAfter(track *track.Track, timeSeconds float64) int {
if idx >= n {
return n - 1
}
- for idx < n && !track.Samples[idx].IsSync() {
+ for requireSync && idx < n && !track.Samples[idx].IsSync() {
idx++
}
if idx >= n {
@@ -317,13 +366,13 @@ func (f *Reader) findSampleAfter(track *track.Track, timeSeconds float64) int {
return idx
}
-func (f *Reader) findSampleBefore(track *track.Track, timeSeconds float64) int {
+func (f *Reader) findSampleBefore(track *track.Track, timeSeconds float64, requireSync bool) int {
scaledTime := int64(timeSeconds * float64(track.TimeScale))
n := len(track.Samples)
idx := max(sort.Search(n, func(i int) bool {
return track.Samples[i].PTS() > scaledTime
})-1, 0)
- for idx > 0 && !track.Samples[idx].IsSync() {
+ for requireSync && idx > 0 && !track.Samples[idx].IsSync() {
idx--
}
return idx
@@ -339,100 +388,108 @@ func (f *Reader) getTrackIndex(trackID uint32) int {
}
// appendSample adds a sample with DTS rebased relative to the first sample per track.
-func (f *Reader) appendSample(trackIdx int, s track.Sample) {
- if !f.dtsBaseSet[trackIdx] {
- f.dtsBase[trackIdx] = s.DTS
- f.dtsBaseSet[trackIdx] = true
+func (f *Reader) appendSample(state *readerTrackState, s track.Sample) {
+ if !state.dtsBaseSet {
+ state.dtsBase = s.DTS
+ state.dtsBaseSet = true
}
- s.DTS -= f.dtsBase[trackIdx]
+ s.DTS -= state.dtsBase
f.fragSamples = append(f.fragSamples, s)
}
-// ReadFragment returns the next fragment.
+// ReadFragment returns the next fragment. A track selected with SelectTrack
+// drives cuts by itself. Otherwise video drives cuts when present, and audio
+// drives cuts for audio-only input.
// Returns [io.EOF] when there are no more fragments to read.
func (f *Reader) ReadFragment() (*Fragment, error) {
if f.initSeg == nil {
return nil, ErrReaderNotInitialized
}
- videoTrack := f.initSeg.VideoTrack()
- if videoTrack == nil {
- return nil, ErrNoVideoTrack
- }
-
- videoTrackIdx := f.getTrackIndex(videoTrack.ID)
- videoSampleIdx := f.trackIdx[videoTrackIdx]
+ driver := f.cutTrack()
+ driverIdx := f.getTrackIndex(driver.ID)
+ driverState := &f.trackState[driverIdx]
+ driverSampleIdx := driverState.sampleIdx
- if videoSampleIdx >= len(videoTrack.Samples) {
+ if driverSampleIdx >= len(driver.Samples) {
return nil, io.EOF
}
var endTimeScaled int64
if f.endTime > 0 {
- endTimeScaled = int64(f.endTime * float64(videoTrack.TimeScale))
+ endTimeScaled = int64(f.endTime * float64(driver.TimeScale))
}
- if endTimeScaled > 0 && videoTrack.Samples[videoSampleIdx].PTS() >= endTimeScaled {
+ if endTimeScaled > 0 && driver.Samples[driverSampleIdx].PTS() >= endTimeScaled {
return nil, io.EOF
}
- startDTS := videoTrack.Samples[videoSampleIdx].DTS
- threshold := int64(f.targetDuration * float64(videoTrack.TimeScale))
- lastVideoIdx := videoSampleIdx
+ startDTS := driver.Samples[driverSampleIdx].DTS
+ threshold := int64(f.targetDuration * float64(driver.TimeScale))
+ lastDriverIdx := driverSampleIdx
- for lastVideoIdx < len(videoTrack.Samples) {
- s := videoTrack.Samples[lastVideoIdx]
+ for lastDriverIdx < len(driver.Samples) {
+ s := driver.Samples[lastDriverIdx]
if endTimeScaled > 0 && s.PTS() >= endTimeScaled {
break
}
- if endTimeScaled == 0 && lastVideoIdx > videoSampleIdx && s.IsSync() {
+ cutPoint := driver.Kind == track.TrackAudio || s.IsSync()
+ if endTimeScaled == 0 && lastDriverIdx > driverSampleIdx && cutPoint {
if s.DTS-startDTS >= threshold {
break
}
}
- lastVideoIdx++
+ lastDriverIdx++
}
- if lastVideoIdx == videoSampleIdx {
+ if lastDriverIdx == driverSampleIdx {
return nil, io.EOF
}
- f.videoRun = [2]int{videoSampleIdx, lastVideoIdx}
- f.audioRun = [2]int{}
+ if f.selectedTrackID != 0 {
+ for i := range f.trackState {
+ f.trackState[i].runStart = 0
+ f.trackState[i].runEnd = 0
+ }
+ }
+ driverState.runStart = driverSampleIdx
+ driverState.runEnd = lastDriverIdx
- var audioStart [maxTracks]int
- var audioEnd [maxTracks]int
- need := lastVideoIdx - videoSampleIdx
+ need := lastDriverIdx - driverSampleIdx
- fragStartPTS := videoTrack.Samples[videoSampleIdx].PTS()
+ fragStartPTS := driver.Samples[driverSampleIdx].PTS()
var fragEndPTS int64
- if lastVideoIdx < len(videoTrack.Samples) {
- fragEndPTS = videoTrack.Samples[lastVideoIdx].PTS()
+ if lastDriverIdx < len(driver.Samples) {
+ fragEndPTS = driver.Samples[lastDriverIdx].PTS()
} else {
- lastSample := videoTrack.Samples[lastVideoIdx-1]
+ lastSample := driver.Samples[lastDriverIdx-1]
fragEndPTS = lastSample.DTS + int64(lastSample.Duration)
}
- for i, t := range f.initSeg.Tracks {
- if t.Kind == track.TrackVideo {
- continue
- }
- startTicks := fragStartPTS * int64(t.TimeScale) / int64(videoTrack.TimeScale)
- endTicks := fragEndPTS * int64(t.TimeScale) / int64(videoTrack.TimeScale)
- idx := f.trackIdx[i]
- n := len(t.Samples)
- for idx < n && t.Samples[idx].PTS() < startTicks {
- idx++
- }
- audioStart[i] = idx
- for idx < n && t.Samples[idx].PTS() < endTicks {
- idx++
- }
- audioEnd[i] = idx
- if t.Kind == track.TrackAudio {
- f.audioRun = [2]int{audioStart[i], audioEnd[i]}
+ if f.selectedTrackID == 0 {
+ for i, t := range f.initSeg.Tracks {
+ if i == driverIdx {
+ continue
+ }
+ startTicks := fragStartPTS * int64(t.TimeScale) / int64(driver.TimeScale)
+ endTicks := fragEndPTS * int64(t.TimeScale) / int64(driver.TimeScale)
+ state := &f.trackState[i]
+ idx := state.sampleIdx
+ n := len(t.Samples)
+ for idx < n && t.Samples[idx].PTS() < startTicks {
+ idx++
+ }
+ start := idx
+ for idx < n && t.Samples[idx].PTS() < endTicks {
+ idx++
+ }
+ if t.Kind == track.TrackVideo && start < idx && !t.Samples[start].IsSync() {
+ return nil, ErrUnalignedVideoTrack
+ }
+ state.runStart = start
+ state.runEnd = idx
+ need += idx - start
}
- need += idx - audioStart[i]
}
if cap(f.fragSamples) < need {
@@ -440,21 +497,23 @@ func (f *Reader) ReadFragment() (*Fragment, error) {
}
f.fragSamples = f.fragSamples[:0]
- // Append video samples
- for i := videoSampleIdx; i < lastVideoIdx; i++ {
- f.appendSample(videoTrackIdx, videoTrack.Samples[i])
+ for i := driverSampleIdx; i < lastDriverIdx; i++ {
+ f.appendSample(driverState, driver.Samples[i])
}
- f.trackIdx[videoTrackIdx] = lastVideoIdx
+ driverState.sampleIdx = lastDriverIdx
- for i, t := range f.initSeg.Tracks {
- if t.Kind == track.TrackVideo {
- continue
- }
- // Append audio samples
- for j := audioStart[i]; j < audioEnd[i]; j++ {
- f.appendSample(i, t.Samples[j])
+ if f.selectedTrackID == 0 {
+ for i, t := range f.initSeg.Tracks {
+ if i == driverIdx {
+ continue
+ }
+ state := &f.trackState[i]
+ start, end := state.runStart, state.runEnd
+ for j := start; j < end; j++ {
+ f.appendSample(state, t.Samples[j])
+ }
+ state.sampleIdx = end
}
- f.trackIdx[i] = audioEnd[i]
}
f.frag.Samples = f.fragSamples
@@ -463,16 +522,34 @@ func (f *Reader) ReadFragment() (*Fragment, error) {
return &f.frag, nil
}
-// VideoRun returns the video track's sample range [start, end) in the most
-// recent fragment returned by ReadFragment.
+// TrackRun returns a track's sample range [start, end) in the most recent
+// fragment returned by ReadFragment. It returns (0, 0) for an unknown track.
+func (f *Reader) TrackRun(trackID uint32) (start, end int) {
+ i := f.getTrackIndex(trackID)
+ if i < 0 {
+ return 0, 0
+ }
+ return f.trackState[i].runStart, f.trackState[i].runEnd
+}
+
+// VideoRun returns the first video track's sample range [start, end) in the
+// most recent fragment returned by ReadFragment.
func (f *Reader) VideoRun() (start, end int) {
- return f.videoRun[0], f.videoRun[1]
+ video := f.initSeg.VideoTrack()
+ if video == nil {
+ return 0, 0
+ }
+ return f.TrackRun(video.ID)
}
-// AudioRun returns the audio track's sample range [start, end) in the most
-// recent fragment, or (0, 0) when there is no audio track.
+// AudioRun returns the first audio track's sample range [start, end) in the
+// most recent fragment, or (0, 0) when there is no audio track.
func (f *Reader) AudioRun() (start, end int) {
- return f.audioRun[0], f.audioRun[1]
+ audio := f.initSeg.AudioTrack()
+ if audio == nil {
+ return 0, 0
+ }
+ return f.TrackRun(audio.ID)
}
// Seek repositions reading to the given time (in seconds).
@@ -524,17 +601,22 @@ func (f *Reader) findMoov() ([]byte, error) {
return nil, ErrNoMoov
}
-// buildInitSegment constructs ftyp+moov for fragmented MP4.
-func (f *Reader) buildInitSegment(tracks []*track.Track, duration uint64) []byte {
+// buildInitSegment constructs ftyp+moov for fragmented MP4, reusing dst when
+// it has enough capacity.
+func buildInitSegment(dst []byte, tracks []*track.Track, movieTimescale uint32, duration uint64) []byte {
+ if movieTimescale == 0 {
+ movieTimescale = defaultMovieTimescale
+ }
+
estSize := 256
for _, track := range tracks {
estSize += 256 + len(track.HdlrRaw()) + len(track.DinfRaw()) + len(track.StsdRaw()) + len(track.TkhdRaw()) + len(track.MdhdRaw())
}
- if cap(f.initBuf) < estSize {
- f.initBuf = make([]byte, estSize)
+ if cap(dst) < estSize {
+ dst = make([]byte, estSize)
}
- buf := f.initBuf[:estSize]
+ buf := dst[:estSize]
w := mp4.NewWriter(buf)
w.WriteFtyp([4]byte{'i', 's', 'o', '5'}, 0,
@@ -542,10 +624,16 @@ func (f *Reader) buildInitSegment(tracks []*track.Track, duration uint64) []byte
w.StartBox(mp4.TypeMoov)
{
- w.WriteMvhd(movieTimescale, 0, uint32(len(tracks)+1))
+ nextTrackID := uint32(1)
+ for _, track := range tracks {
+ if track.ID >= nextTrackID {
+ nextTrackID = track.ID + 1
+ }
+ }
+ w.WriteMvhd(movieTimescale, 0, nextTrackID)
for _, track := range tracks {
- writeInitTrak(&w, track)
+ writeInitTrak(&w, movieTimescale, track)
}
w.StartBox(mp4.TypeMvex)
@@ -562,13 +650,13 @@ func (f *Reader) buildInitSegment(tracks []*track.Track, duration uint64) []byte
return w.Bytes()
}
-func writeInitTrak(w *mp4.Writer, track *track.Track) {
+func writeInitTrak(w *mp4.Writer, movieTimescale uint32, track *track.Track) {
w.StartBox(mp4.TypeTrak)
{
writeTkhdZeroDuration(w, track)
if mt, ok := track.EditMediaTime(); ok && track.TimeScale > 0 {
- segDur := track.Duration * movieTimescale / uint64(track.TimeScale)
+ segDur := track.Duration * uint64(movieTimescale) / uint64(track.TimeScale)
w.StartBox(mp4.TypeEdts)
w.WriteElst([]mp4.ElstEntry{{
SegmentDuration: segDur,
diff --git a/fragment/reader_test.go b/fragment/reader_test.go
index 946490f..f8fd731 100644
--- a/fragment/reader_test.go
+++ b/fragment/reader_test.go
@@ -1,6 +1,7 @@
package fragment_test
import (
+ "encoding/binary"
"io"
"os"
"reflect"
@@ -11,6 +12,7 @@ import (
)
const testFile = "../test-data/big-buck-bunny-480p-30sec.mp4"
+const audioTestFile = "../test-data/aac-10s.mp4"
func openTestFile(t testing.TB) *os.File {
t.Helper()
@@ -113,6 +115,113 @@ func TestReadFragments(t *testing.T) {
t.Logf("fragments=%d totalSamples=%d", fragCount, totalSamples)
}
+func TestReadAudioOnlyFragments(t *testing.T) {
+ f, err := os.Open(audioTestFile)
+ if err != nil {
+ t.Skipf("test file not available: %v", err)
+ }
+ defer f.Close()
+ r, init, err := fragment.NewReader(f)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if init.VideoTrack() != nil || init.AudioTrack() == nil {
+ t.Fatalf("audio-only tracks = %+v", init.Tracks)
+ }
+ if err := r.SetTargetDuration(3); err != nil {
+ t.Fatal(err)
+ }
+ if err := r.Seek(4); err != nil {
+ t.Fatal(err)
+ }
+ fr, err := r.ReadFragment()
+ if err != nil {
+ t.Fatal(err)
+ }
+ vs, ve := r.VideoRun()
+ as, ae := r.AudioRun()
+ if vs != 0 || ve != 0 || as <= 0 || ae <= as || len(fr.Samples) != ae-as {
+ t.Fatalf("video=[%d,%d) audio=[%d,%d) samples=%d", vs, ve, as, ae, len(fr.Samples))
+ }
+}
+
+// movieTimescale returns the mvhd timescale from an ftyp+moov or bare moov buffer.
+func movieTimescale(tb testing.TB, buf []byte) uint32 {
+ tb.Helper()
+ r := mp4.NewReader(buf)
+ for r.Next() {
+ if r.Type() != mp4.TypeMoov {
+ continue
+ }
+ r.Enter()
+ for r.Next() {
+ if r.Type() == mp4.TypeMvhd {
+ ts, _, _ := r.ReadMvhd()
+ return ts
+ }
+ }
+ r.Exit()
+ }
+ tb.Fatal("mvhd not found")
+ return 0
+}
+
+// TestInitSegmentCarriesSourceMovieTimescale overwrites the source movie
+// timescale with a distinctive value and checks the init segment's mvhd reports
+// it, proving the timescale comes from the source rather than a fixed constant.
+func TestInitSegmentCarriesSourceMovieTimescale(t *testing.T) {
+ data, err := os.ReadFile(testFile)
+ if err != nil {
+ t.Skipf("test file not available: %v", err)
+ }
+
+ // The version-0 mvhd timescale sits after the 4-byte creation and
+ // modification times in the box data.
+ const wantTS = 90000
+ patched := false
+ r := mp4.NewReader(data)
+ for r.Next() && !patched {
+ if r.Type() != mp4.TypeMoov {
+ continue
+ }
+ r.Enter()
+ for r.Next() {
+ if r.Type() == mp4.TypeMvhd {
+ if r.Version() != 0 {
+ t.Skip("mvhd is not version 0")
+ }
+ off := r.DataOffset()
+ binary.BigEndian.PutUint32(data[off+8:off+12], wantTS)
+ patched = true
+ break
+ }
+ }
+ r.Exit()
+ }
+ if !patched {
+ t.Fatal("mvhd not found in source")
+ }
+
+ tmp, err := os.CreateTemp(t.TempDir(), "patched-*.mp4")
+ if err != nil {
+ t.Fatal(err)
+ }
+ if _, err := tmp.Write(data); err != nil {
+ t.Fatal(err)
+ }
+ if _, err := tmp.Seek(0, io.SeekStart); err != nil {
+ t.Fatal(err)
+ }
+
+ _, initSeg, err := fragment.NewReader(tmp)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if got := movieTimescale(t, initSeg.Bytes()); got != wantTS {
+ t.Errorf("init movie timescale = %d, want %d", got, wantTS)
+ }
+}
+
func TestWriteFragment(t *testing.T) {
f := openTestFile(t)
defer f.Close()
diff --git a/fragment/track_selection_test.go b/fragment/track_selection_test.go
new file mode 100644
index 0000000..a632553
--- /dev/null
+++ b/fragment/track_selection_test.go
@@ -0,0 +1,771 @@
+package fragment_test
+
+import (
+ "bytes"
+ "io"
+ "os"
+ "os/exec"
+ "path/filepath"
+ "slices"
+ "strconv"
+ "strings"
+ "testing"
+
+ "github.com/tetsuo/mp4"
+ "github.com/tetsuo/mp4/fragment"
+ "github.com/tetsuo/mp4/track"
+)
+
+const muxedTestFile = "../test-data/h264-aac-10s.mp4"
+const multiTrackTestFile = "../test-data/h264-2video-2audio-3s.mp4"
+const sixTrackTestFile = "../test-data/aac-6track-1s.mp4"
+
+var trackInitSink []byte
+
+func TestReaderPreservesAllPlayableTracks(t *testing.T) {
+ f, err := os.Open(multiTrackTestFile)
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer f.Close()
+
+ r, init, err := fragment.NewReader(f)
+ if err != nil {
+ t.Fatal(err)
+ }
+ wantIDs := []uint32{1, 2, 3, 4}
+ gotIDs := make([]uint32, len(init.Tracks))
+ for i := range init.Tracks {
+ gotIDs[i] = init.Tracks[i].ID
+ }
+ if !slices.Equal(gotIDs, wantIDs) {
+ t.Fatalf("reader track ids = %v, want %v", gotIDs, wantIDs)
+ }
+ initTrackIDs, trexIDs, _ := initIDs(t, init.Bytes())
+ if !slices.Equal(initTrackIDs, wantIDs) || !slices.Equal(trexIDs, wantIDs) {
+ t.Fatalf("init track ids = %v, trex ids = %v, want %v", initTrackIDs, trexIDs, wantIDs)
+ }
+
+ if err := r.SetTargetDuration(1); err != nil {
+ t.Fatal(err)
+ }
+ fr, err := r.ReadFragment()
+ if err != nil {
+ t.Fatal(err)
+ }
+ original := slices.Clone(fr.Samples)
+ for _, selected := range init.Tracks {
+ t.Run("track-"+strconv.FormatUint(uint64(selected.ID), 10), func(t *testing.T) {
+ start, end := r.TrackRun(selected.ID)
+ want := samplesForTrack(original, selected.ID)
+ if end-start != len(want) || len(want) == 0 {
+ t.Fatalf("track run = [%d,%d), fragment samples = %d", start, end, len(want))
+ }
+ if selected.Kind == track.TrackVideo && !want[0].IsSync() {
+ t.Fatal("video fragment does not start with a sync sample")
+ }
+
+ trackInit, err := init.TrackBytes(make([]byte, 0, len(init.Bytes())), selected.ID)
+ if err != nil {
+ t.Fatal(err)
+ }
+ trackIDs, trackTrexIDs, _ := initIDs(t, trackInit)
+ if !slices.Equal(trackIDs, []uint32{selected.ID}) || !slices.Equal(trackTrexIDs, []uint32{selected.ID}) {
+ t.Fatalf("selected init track ids = %v, trex ids = %v", trackIDs, trackTrexIDs)
+ }
+ verifySelectedFragment(t, f, fr, original, selected)
+ })
+ }
+ if start, end := r.TrackRun(0); start != 0 || end != 0 {
+ t.Fatalf("unknown track run = [%d,%d), want [0,0)", start, end)
+ }
+ if !slices.Equal(fr.Samples, original) {
+ t.Fatal("track writes mutated the source fragment")
+ }
+}
+
+func TestReaderSupportsMoreThanFourTracks(t *testing.T) {
+ f, err := os.Open(sixTrackTestFile)
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer f.Close()
+
+ r, init, err := fragment.NewReader(f)
+ if err != nil {
+ t.Fatal(err)
+ }
+ wantIDs := []uint32{1, 2, 3, 4, 5, 6}
+ gotIDs := make([]uint32, len(init.Tracks))
+ for i := range init.Tracks {
+ gotIDs[i] = init.Tracks[i].ID
+ }
+ if !slices.Equal(gotIDs, wantIDs) {
+ t.Fatalf("reader track ids = %v, want %v", gotIDs, wantIDs)
+ }
+ if err := r.SetTargetDuration(0.25); err != nil {
+ t.Fatal(err)
+ }
+
+ counts := make(map[uint32]int, len(wantIDs))
+ for {
+ fr, err := r.ReadFragment()
+ if err == io.EOF {
+ break
+ }
+ if err != nil {
+ t.Fatal(err)
+ }
+ for i := range fr.Samples {
+ counts[fr.Samples[i].TrackID]++
+ }
+ }
+ for _, id := range wantIDs {
+ if counts[id] == 0 {
+ t.Fatalf("track %d has no fragmented samples", id)
+ }
+ }
+
+ var readErr error
+ allocs := testing.AllocsPerRun(100, func() {
+ readErr = r.Seek(0)
+ if readErr != nil {
+ return
+ }
+ for {
+ _, readErr = r.ReadFragment()
+ if readErr == io.EOF {
+ readErr = nil
+ return
+ }
+ if readErr != nil {
+ return
+ }
+ }
+ })
+ if readErr != nil {
+ t.Fatal(readErr)
+ }
+ if allocs != 0 {
+ t.Fatalf("warm six-track read allocations = %v, want 0", allocs)
+ }
+}
+
+func TestSixTrackFragmentRoundTripFFprobe(t *testing.T) {
+ if _, err := exec.LookPath("ffprobe"); err != nil {
+ t.Skip("ffprobe not installed")
+ }
+ f, err := os.Open(sixTrackTestFile)
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer f.Close()
+
+ r, init, err := fragment.NewReader(f)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if err := r.SetTargetDuration(0.25); err != nil {
+ t.Fatal(err)
+ }
+ var output bytes.Buffer
+ w := fragment.NewWriter(&output)
+ if err := w.WriteInit(init); err != nil {
+ t.Fatal(err)
+ }
+ for {
+ fr, err := r.ReadFragment()
+ if err == io.EOF {
+ break
+ }
+ if err != nil {
+ t.Fatal(err)
+ }
+ if err := w.WriteFragment(fr, f); err != nil {
+ t.Fatal(err)
+ }
+ }
+
+ path := filepath.Join(t.TempDir(), "six-track.mp4")
+ if err := os.WriteFile(path, output.Bytes(), 0o600); err != nil {
+ t.Fatal(err)
+ }
+ probe, err := exec.Command("ffprobe", "-v", "error", "-show_entries", "stream=codec_type", "-of", "csv=p=0", path).Output()
+ if err != nil {
+ t.Fatalf("ffprobe: %v", err)
+ }
+ want := []string{"audio", "audio", "audio", "audio", "audio", "audio"}
+ if got := strings.Fields(string(probe)); !slices.Equal(got, want) {
+ t.Fatalf("ffprobe stream types = %v, want %v", got, want)
+ }
+}
+
+func TestTrackInitContainsOnlySelectedTrack(t *testing.T) {
+ f, err := os.Open(muxedTestFile)
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer f.Close()
+
+ _, init, err := fragment.NewReader(f)
+ if err != nil {
+ t.Fatal(err)
+ }
+ video, audio := init.VideoTrack(), init.AudioTrack()
+ if video == nil || audio == nil {
+ t.Fatal("fixture must contain video and audio")
+ }
+
+ for _, tc := range []struct {
+ name string
+ selected *track.Track
+ }{{"video", video}, {"audio", audio}} {
+ t.Run(tc.name, func(t *testing.T) {
+ selected := tc.selected
+ buf := make([]byte, 0, len(init.Bytes()))
+ got, err := init.TrackBytes(buf, selected.ID)
+ if err != nil {
+ t.Fatal(err)
+ }
+ trackIDs, trexIDs, nextTrackID := initIDs(t, got)
+ if !slices.Equal(trackIDs, []uint32{selected.ID}) {
+ t.Fatalf("init track ids = %v, want [%d]", trackIDs, selected.ID)
+ }
+ if !slices.Equal(trexIDs, []uint32{selected.ID}) {
+ t.Fatalf("init trex ids = %v, want [%d]", trexIDs, selected.ID)
+ }
+ if nextTrackID <= selected.ID {
+ t.Fatalf("init next track id = %d, want greater than %d", nextTrackID, selected.ID)
+ }
+ })
+ }
+
+ if _, err := init.TrackBytes(nil, 0); err == nil {
+ t.Fatal("unknown track id was accepted")
+ }
+}
+
+func TestWriteFragmentTrackPreservesSelectedSamples(t *testing.T) {
+ f, err := os.Open(muxedTestFile)
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer f.Close()
+
+ r, init, err := fragment.NewReader(f)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if err := r.SetTargetDuration(2); err != nil {
+ t.Fatal(err)
+ }
+ fr, err := r.ReadFragment()
+ if err != nil {
+ t.Fatal(err)
+ }
+ original := slices.Clone(fr.Samples)
+ if err := fragment.NewWriter(io.Discard).PrepareTrack(fr, 0); err != fragment.ErrTrackNotFound {
+ t.Fatalf("unknown track error = %v, want %v", err, fragment.ErrTrackNotFound)
+ }
+
+ for _, tc := range []struct {
+ name string
+ selected *track.Track
+ }{{"video", init.VideoTrack()}, {"audio", init.AudioTrack()}} {
+ t.Run(tc.name, func(t *testing.T) {
+ verifySelectedFragment(t, f, fr, original, tc.selected)
+ })
+ }
+
+ if !slices.Equal(fr.Samples, original) {
+ t.Fatal("track writes mutated the source fragment")
+ }
+}
+
+func TestWriterSupportsMoreThanFourMuxedTracks(t *testing.T) {
+ samples := make([]track.Sample, 5)
+ for i := range samples {
+ samples[i].Offset = int64(i)
+ samples[i].TrackID = uint32(i + 1)
+ samples[i].Duration = 1
+ samples[i].SetSize(1, true)
+ }
+ fr := &fragment.Fragment{Samples: samples, SequenceNum: 1}
+ var out bytes.Buffer
+ w := fragment.NewWriter(&out)
+ if err := w.WriteFragment(fr, bytes.NewReader([]byte{1, 2, 3, 4, 5})); err != nil {
+ t.Fatal(err)
+ }
+ got, sequence, err := fragment.ParseSegment(out.Bytes())
+ if err != nil {
+ t.Fatal(err)
+ }
+ if sequence != 1 || len(got) != len(samples) {
+ t.Fatalf("sequence = %d, samples = %d", sequence, len(got))
+ }
+ for i := range got {
+ if got[i].TrackID != samples[i].TrackID {
+ t.Fatalf("sample %d track id = %d, want %d", i, got[i].TrackID, samples[i].TrackID)
+ }
+ }
+}
+
+func TestWriterGrowsMoofForLargeMultitrackFragment(t *testing.T) {
+ samples := make([]track.Sample, 5000)
+ for i := range samples {
+ samples[i].TrackID = uint32(i%6 + 1)
+ samples[i].Duration = 1024
+ samples[i].SetSize(0, true)
+ }
+ fr := &fragment.Fragment{Samples: samples, SequenceNum: 7}
+ var out bytes.Buffer
+ if err := fragment.NewWriter(&out).WriteFragment(fr, bytes.NewReader(nil)); err != nil {
+ t.Fatal(err)
+ }
+ got, sequence, err := fragment.ParseSegment(out.Bytes())
+ if err != nil {
+ t.Fatal(err)
+ }
+ if sequence != 7 || len(got) != len(samples) {
+ t.Fatalf("sequence = %d, samples = %d, want 7 and %d", sequence, len(got), len(samples))
+ }
+ counts := make(map[uint32]int, 6)
+ for i := range got {
+ counts[got[i].TrackID]++
+ }
+ for id := uint32(1); id <= 6; id++ {
+ if counts[id] == 0 {
+ t.Fatalf("track %d has no parsed samples", id)
+ }
+ }
+}
+
+func TestReaderRejectsUnalignedVideoTrack(t *testing.T) {
+ f, err := os.Open(multiTrackTestFile)
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer f.Close()
+
+ r, init, err := fragment.NewReader(f)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if err := r.SetTargetDuration(1); err != nil {
+ t.Fatal(err)
+ }
+ if _, err := r.ReadFragment(); err != nil {
+ t.Fatal(err)
+ }
+ secondVideo := init.Tracks[1]
+ if secondVideo.Kind != track.TrackVideo {
+ t.Fatal("fixture track 2 must be video")
+ }
+ _, next := r.TrackRun(secondVideo.ID)
+ if next >= len(secondVideo.Samples) || !secondVideo.Samples[next].IsSync() {
+ t.Fatal("fixture video tracks must have an aligned second fragment")
+ }
+ secondVideo.Samples[next].SetSize(secondVideo.Samples[next].Size(), false)
+ if _, err := r.ReadFragment(); err != fragment.ErrUnalignedVideoTrack {
+ t.Fatalf("unaligned read error = %v, want %v", err, fragment.ErrUnalignedVideoTrack)
+ }
+}
+
+func TestSelectedVideoDrivesItsOwnFragmentBoundaries(t *testing.T) {
+ f, err := os.Open(multiTrackTestFile)
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer f.Close()
+
+ r, init, err := fragment.NewReader(f)
+ if err != nil {
+ t.Fatal(err)
+ }
+ firstVideo, selected := init.Tracks[0], init.Tracks[1]
+ if firstVideo.Kind != track.TrackVideo || selected.Kind != track.TrackVideo {
+ t.Fatal("fixture tracks 1 and 2 must be video")
+ }
+ for i := 1; i < len(firstVideo.Samples); i++ {
+ firstVideo.Samples[i].SetSize(firstVideo.Samples[i].Size(), false)
+ }
+ if err := r.SetTargetDuration(1); err != nil {
+ t.Fatal(err)
+ }
+ if err := r.SelectTrack(selected.ID); err != nil {
+ t.Fatal(err)
+ }
+
+ fragments := 0
+ for {
+ fr, err := r.ReadFragment()
+ if err == io.EOF {
+ break
+ }
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(fr.Samples) == 0 || !fr.Samples[0].IsSync() {
+ t.Fatalf("fragment %d does not start with a selected-track sync sample", fragments)
+ }
+ for i := range fr.Samples {
+ if fr.Samples[i].TrackID != selected.ID {
+ t.Fatalf("fragment %d sample %d track id = %d, want %d", fragments, i, fr.Samples[i].TrackID, selected.ID)
+ }
+ }
+ fragments++
+ }
+ if fragments < 2 {
+ t.Fatalf("selected track produced %d fragment, want at least 2", fragments)
+ }
+}
+
+func TestSelectedTrackIgnoresUnalignedVideoTrack(t *testing.T) {
+ f, err := os.Open(multiTrackTestFile)
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer f.Close()
+
+ r, init, err := fragment.NewReader(f)
+ if err != nil {
+ t.Fatal(err)
+ }
+ selected, otherVideo := init.Tracks[0], init.Tracks[1]
+ if selected.Kind != track.TrackVideo || otherVideo.Kind != track.TrackVideo {
+ t.Fatal("fixture tracks 1 and 2 must be video")
+ }
+ unaligned := false
+ for i := 1; i < len(otherVideo.Samples); i++ {
+ if otherVideo.Samples[i].IsSync() {
+ otherVideo.Samples[i].SetSize(otherVideo.Samples[i].Size(), false)
+ unaligned = true
+ break
+ }
+ }
+ if !unaligned {
+ t.Fatal("fixture second video must have another sync sample")
+ }
+ if err := r.SetTargetDuration(1); err != nil {
+ t.Fatal(err)
+ }
+ if err := r.SelectTrack(selected.ID); err != nil {
+ t.Fatal(err)
+ }
+
+ fragments := 0
+ for {
+ fr, err := r.ReadFragment()
+ if err == io.EOF {
+ break
+ }
+ if err != nil {
+ t.Fatal(err)
+ }
+ for i := range fr.Samples {
+ if fr.Samples[i].TrackID != selected.ID {
+ t.Fatalf("fragment %d sample %d track id = %d, want %d", fragments, i, fr.Samples[i].TrackID, selected.ID)
+ }
+ }
+ fragments++
+ }
+ if fragments < 2 {
+ t.Fatalf("selected track produced %d fragment, want at least 2", fragments)
+ }
+}
+
+func TestSelectTrackRejectsUnknownTrack(t *testing.T) {
+ f, err := os.Open(multiTrackTestFile)
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer f.Close()
+ r, _, err := fragment.NewReader(f)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if err := r.SelectTrack(0); err != fragment.ErrTrackNotFound {
+ t.Fatalf("error = %v, want %v", err, fragment.ErrTrackNotFound)
+ }
+}
+
+func TestSelectedTracksFFprobe(t *testing.T) {
+ if _, err := exec.LookPath("ffprobe"); err != nil {
+ t.Skip("ffprobe not installed")
+ }
+ f, err := os.Open(multiTrackTestFile)
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer f.Close()
+
+ r, init, err := fragment.NewReader(f)
+ if err != nil {
+ t.Fatal(err)
+ }
+ type output struct {
+ track *track.Track
+ buf bytes.Buffer
+ w *fragment.Writer
+ }
+ outputs := make([]output, len(init.Tracks))
+ for i, selected := range init.Tracks {
+ trackInit, err := init.TrackBytes(nil, selected.ID)
+ if err != nil {
+ t.Fatal(err)
+ }
+ outputs[i].track = selected
+ outputs[i].buf.Write(trackInit)
+ outputs[i].w = fragment.NewWriter(&outputs[i].buf)
+ }
+ for {
+ fr, err := r.ReadFragment()
+ if err == io.EOF {
+ break
+ }
+ if err != nil {
+ t.Fatal(err)
+ }
+ for i := range outputs {
+ selected := outputs[i].track
+ if len(samplesForTrack(fr.Samples, selected.ID)) == 0 {
+ continue
+ }
+ if err := outputs[i].w.WriteFragmentTrack(fr, selected.ID, f); err != nil {
+ t.Fatal(err)
+ }
+ }
+ }
+
+ for i := range outputs {
+ out := &outputs[i]
+ t.Run("track-"+strconv.FormatUint(uint64(out.track.ID), 10), func(t *testing.T) {
+ path := filepath.Join(t.TempDir(), "track.mp4")
+ if err := os.WriteFile(path, out.buf.Bytes(), 0o600); err != nil {
+ t.Fatal(err)
+ }
+ probe, err := exec.Command("ffprobe", "-v", "error", "-show_entries", "stream=codec_type", "-of", "csv=p=0", path).Output()
+ if err != nil {
+ t.Fatalf("ffprobe: %v", err)
+ }
+ want := "audio"
+ if out.track.Kind == track.TrackVideo {
+ want = "video"
+ }
+ if got := strings.Fields(string(probe)); !slices.Equal(got, []string{want}) {
+ t.Fatalf("ffprobe stream types = %v, want [%s]", got, want)
+ }
+ })
+ }
+}
+
+func verifySelectedFragment(t *testing.T, src io.ReaderAt, fr *fragment.Fragment, original []track.Sample, selected *track.Track) {
+ t.Helper()
+ var out bytes.Buffer
+ w := fragment.NewWriter(&out)
+ if err := w.WriteFragmentTrack(fr, selected.ID, src); err != nil {
+ t.Fatal(err)
+ }
+
+ got, seq, err := fragment.ParseSegment(out.Bytes())
+ if err != nil {
+ t.Fatal(err)
+ }
+ if seq != fr.SequenceNum {
+ t.Fatalf("sequence = %d, want %d", seq, fr.SequenceNum)
+ }
+ want := samplesForTrack(original, selected.ID)
+ if len(got) != len(want) {
+ t.Fatalf("samples = %d, want %d", len(got), len(want))
+ }
+ for i := range want {
+ if !sameSample(got[i], want[i]) {
+ t.Fatalf("sample %d metadata = %+v, want %+v", i, got[i], want[i])
+ }
+ wantBytes := make([]byte, want[i].Size())
+ if _, err := src.ReadAt(wantBytes, want[i].Offset); err != nil && err != io.EOF {
+ t.Fatal(err)
+ }
+ gotBytes := out.Bytes()[got[i].Offset : got[i].Offset+int64(got[i].Size())]
+ if !bytes.Equal(gotBytes, wantBytes) {
+ t.Fatalf("sample %d media bytes changed", i)
+ }
+ }
+}
+
+func BenchmarkTrackInitBytes(b *testing.B) {
+ f, err := os.Open(muxedTestFile)
+ if err != nil {
+ b.Fatal(err)
+ }
+ defer f.Close()
+
+ _, init, err := fragment.NewReader(f)
+ if err != nil {
+ b.Fatal(err)
+ }
+ video := init.VideoTrack()
+ if video == nil {
+ b.Fatal("fixture must contain video")
+ }
+
+ dst := make([]byte, 0, len(init.Bytes()))
+ dst, err = init.TrackBytes(dst, video.ID)
+ if err != nil {
+ b.Fatal(err)
+ }
+ b.ResetTimer()
+ b.ReportAllocs()
+ for b.Loop() {
+ dst, err = init.TrackBytes(dst[:0], video.ID)
+ if err != nil {
+ b.Fatal(err)
+ }
+ }
+ trackInitSink = dst
+}
+
+func BenchmarkReaderFragments(b *testing.B) {
+ benchmarkReaderFragments(b, muxedTestFile)
+}
+
+func BenchmarkReaderFourTracks(b *testing.B) {
+ benchmarkReaderFragments(b, multiTrackTestFile)
+}
+
+func BenchmarkReaderSixTracks(b *testing.B) {
+ benchmarkReaderFragments(b, sixTrackTestFile)
+}
+
+func BenchmarkReaderSelectedTrack(b *testing.B) {
+ f, err := os.Open(multiTrackTestFile)
+ if err != nil {
+ b.Fatal(err)
+ }
+ defer f.Close()
+
+ r, init, err := fragment.NewReader(f)
+ if err != nil {
+ b.Fatal(err)
+ }
+ if err := r.SetTargetDuration(1); err != nil {
+ b.Fatal(err)
+ }
+ if err := r.SelectTrack(init.Tracks[1].ID); err != nil {
+ b.Fatal(err)
+ }
+ for {
+ if _, err := r.ReadFragment(); err == io.EOF {
+ break
+ } else if err != nil {
+ b.Fatal(err)
+ }
+ }
+
+ b.ResetTimer()
+ b.ReportAllocs()
+ for b.Loop() {
+ if err := r.Seek(0); err != nil {
+ b.Fatal(err)
+ }
+ for {
+ if _, err := r.ReadFragment(); err == io.EOF {
+ break
+ } else if err != nil {
+ b.Fatal(err)
+ }
+ }
+ }
+}
+
+func benchmarkReaderFragments(b *testing.B, path string) {
+ b.Helper()
+ f, err := os.Open(path)
+ if err != nil {
+ b.Fatal(err)
+ }
+ defer f.Close()
+
+ r, _, err := fragment.NewReader(f)
+ if err != nil {
+ b.Fatal(err)
+ }
+ if err := r.SetTargetDuration(1); err != nil {
+ b.Fatal(err)
+ }
+ for {
+ if _, err := r.ReadFragment(); err == io.EOF {
+ break
+ } else if err != nil {
+ b.Fatal(err)
+ }
+ }
+
+ b.ResetTimer()
+ b.ReportAllocs()
+ for b.Loop() {
+ if err := r.Seek(0); err != nil {
+ b.Fatal(err)
+ }
+ for {
+ if _, err := r.ReadFragment(); err == io.EOF {
+ break
+ } else if err != nil {
+ b.Fatal(err)
+ }
+ }
+ }
+}
+
+func samplesForTrack(samples []track.Sample, trackID uint32) []track.Sample {
+ out := make([]track.Sample, 0, len(samples))
+ for i := range samples {
+ if samples[i].TrackID == trackID {
+ out = append(out, samples[i])
+ }
+ }
+ return out
+}
+
+func sameSample(a, b track.Sample) bool {
+ return a.TrackID == b.TrackID && a.DTS == b.DTS && a.Duration == b.Duration &&
+ a.PresentationOffset == b.PresentationOffset && a.Size() == b.Size() &&
+ a.IsSync() == b.IsSync()
+}
+
+func initIDs(t *testing.T, data []byte) (trackIDs, trexIDs []uint32, nextTrackID uint32) {
+ t.Helper()
+ r := mp4.NewReader(data)
+ for r.Next() {
+ if r.Type() != mp4.TypeMoov {
+ continue
+ }
+ r.Enter()
+ for r.Next() {
+ switch r.Type() {
+ case mp4.TypeMvhd:
+ _, _, nextTrackID = r.ReadMvhd()
+ case mp4.TypeTrak:
+ r.Enter()
+ for r.Next() {
+ if r.Type() == mp4.TypeTkhd {
+ id, _, _, _ := r.ReadTkhd()
+ trackIDs = append(trackIDs, id)
+ }
+ }
+ r.Exit()
+ case mp4.TypeMvex:
+ r.Enter()
+ for r.Next() {
+ if r.Type() == mp4.TypeTrex {
+ id, _, _, _, _ := r.ReadTrex()
+ trexIDs = append(trexIDs, id)
+ }
+ }
+ r.Exit()
+ }
+ }
+ r.Exit()
+ }
+ return trackIDs, trexIDs, nextTrackID
+}
diff --git a/fragment/writer.go b/fragment/writer.go
index a992a0d..723371b 100644
--- a/fragment/writer.go
+++ b/fragment/writer.go
@@ -7,6 +7,8 @@ import (
"github.com/tetsuo/mp4"
)
+const defaultWriterTrackCapacity = 4
+
// Writer writes fragmented MP4 segments.
type Writer struct {
w io.Writer
@@ -21,9 +23,13 @@ type Writer struct {
mdatPayload int64
// Per-track scratch buffers.
- sampleIdx [maxTracks][]int
- trunBuf [maxTracks][]mp4.TrunEntry
- ranges []byteRange
+ trackIDs []uint32
+ sampleIdx [][]int
+ trunBuf [][]mp4.TrunEntry
+ trafs []trafInfo
+ trackDataOffset []int32
+ patches []trunPatch
+ ranges []byteRange
}
type byteRange struct {
@@ -31,6 +37,17 @@ type byteRange struct {
size int64
}
+type trafInfo struct {
+ trackID uint32
+ baseDTS int64
+ hasCtts bool
+}
+
+type trunPatch struct {
+ pos int
+ dataStart int32
+}
+
// NewWriter creates a fragment writer which writes to the provided [io.Writer].
func NewWriter(w io.Writer) *Writer {
wr := &Writer{
@@ -38,12 +55,7 @@ func NewWriter(w io.Writer) *Writer {
buf: make([]byte, 65536),
ranges: make([]byteRange, 0, 1024),
}
- for i := range wr.sampleIdx {
- wr.sampleIdx[i] = make([]int, 0, 512)
- }
- for i := range wr.trunBuf {
- wr.trunBuf[i] = make([]mp4.TrunEntry, 0, 512)
- }
+ wr.ensureTrackGroups(defaultWriterTrackCapacity)
return wr
}
@@ -67,9 +79,19 @@ func (w *Writer) WriteFragment(frag *Fragment, src io.ReaderAt) error {
return w.WriteBodyRange(w.w, src, 0, w.BodySize())
}
-// BodySize returns the byte size of the body (moof + mdat) of the fragment last
-// passed to [Writer.Prepare]. It is moofSize + 8 + sum(sample sizes), all known
-// from sample metadata, so the size is available before any media is read.
+// WriteFragmentTrack writes a single-track moof+mdat fragment. Only samples
+// whose track id equals trackID are described and copied from src.
+func (w *Writer) WriteFragmentTrack(frag *Fragment, trackID uint32, src io.ReaderAt) error {
+ if err := w.PrepareTrack(frag, trackID); err != nil {
+ return err
+ }
+ return w.WriteBodyRange(w.w, src, 0, w.BodySize())
+}
+
+// BodySize returns the byte size of the body (moof + mdat) prepared by the last
+// call to [Writer.Prepare] or [Writer.PrepareTrack]. It is moofSize + 8 +
+// sum(sample sizes), all known from sample metadata, so the size is available
+// before any media is read.
func (w *Writer) BodySize() int64 {
return int64(len(w.moof)) + 8 + w.mdatPayload
}
@@ -77,33 +99,56 @@ func (w *Writer) BodySize() int64 {
// Prepare builds the moof for frag from sample metadata alone, reading no media.
// It records the moof bytes and the mdat payload size so [Writer.BodySize] and
// [Writer.WriteBodyRange] can write the body, or a byte window of it, afterward.
-// The recorded state is valid until the next call to Prepare on this writer.
+// The recorded state is valid until the next call to Prepare or PrepareTrack on
+// this writer.
func (w *Writer) Prepare(frag *Fragment) error {
+ return w.prepare(frag, 0, false)
+}
+
+// PrepareTrack is Prepare for one track. It builds a moof and mdat layout from
+// only the samples whose track id equals trackID, without copying sample
+// metadata or reading media bytes.
+func (w *Writer) PrepareTrack(frag *Fragment, trackID uint32) error {
+ return w.prepare(frag, trackID, true)
+}
+
+func (w *Writer) prepare(frag *Fragment, trackID uint32, singleTrack bool) error {
// Group samples by track
- var trackIDs [maxTracks]uint32
groupCount := 0
for i := range w.sampleIdx {
w.sampleIdx[i] = w.sampleIdx[i][:0]
}
- for i := range frag.Samples {
- s := &frag.Samples[i]
- found := false
- for g := 0; g < groupCount; g++ {
- if trackIDs[g] == s.TrackID {
- w.sampleIdx[g] = append(w.sampleIdx[g], i)
- found = true
- break
+ if singleTrack {
+ w.ensureTrackGroups(1)
+ w.trackIDs[0] = trackID
+ for i := range frag.Samples {
+ if frag.Samples[i].TrackID == trackID {
+ w.sampleIdx[0] = append(w.sampleIdx[0], i)
}
}
- if !found {
- if groupCount >= maxTracks {
- continue
+ if len(w.sampleIdx[0]) == 0 {
+ return ErrTrackNotFound
+ }
+ groupCount = 1
+ } else {
+ for i := range frag.Samples {
+ s := &frag.Samples[i]
+ found := false
+ for g := 0; g < groupCount; g++ {
+ if w.trackIDs[g] == s.TrackID {
+ w.sampleIdx[g] = append(w.sampleIdx[g], i)
+ found = true
+ break
+ }
+ }
+ if !found {
+ w.ensureTrackGroups(groupCount + 1)
+ w.trackIDs[groupCount] = s.TrackID
+ w.sampleIdx[groupCount] = append(w.sampleIdx[groupCount], i)
+ groupCount++
}
- trackIDs[groupCount] = s.TrackID
- w.sampleIdx[groupCount] = append(w.sampleIdx[groupCount], i)
- groupCount++
}
}
@@ -133,19 +178,14 @@ func (w *Writer) Prepare(frag *Fragment) error {
mdatHeaderSize := int32(8)
// Build trun entries per track group
- type trafInfo struct {
- trackID uint32
- baseDTS int64
- hasCtts bool
- }
- var trafs [maxTracks]trafInfo
-
+ sampleCount := 0
for g := 0; g < groupCount; g++ {
- ti := &trafs[g]
- ti.trackID = trackIDs[g]
+ ti := &w.trafs[g]
+ *ti = trafInfo{trackID: w.trackIDs[g]}
w.trunBuf[g] = w.trunBuf[g][:0]
indices := w.sampleIdx[g]
+ sampleCount += len(indices)
if len(indices) > 0 {
ti.baseDTS = frag.Samples[indices[0]].DTS
}
@@ -166,23 +206,16 @@ func (w *Writer) Prepare(frag *Fragment) error {
}
// Track data layout in mdat
- var trackDataOffsets [maxTracks]int32
var accum int32
for g := 0; g < groupCount; g++ {
- trackDataOffsets[g] = accum
+ w.trackDataOffset[g] = accum
for _, idx := range w.sampleIdx[g] {
accum += int32(frag.Samples[idx].Size())
}
}
// Build moof, recording trun data_offset positions for backpatching
- type trunPatch struct {
- pos int
- dataStart int32
- }
- var patches [maxTracks]trunPatch
- patchCount := 0
-
+ w.ensureMoofCapacity(groupCount, sampleCount)
mw := mp4.NewWriter(w.buf)
mw.Reset()
@@ -190,7 +223,7 @@ func (w *Writer) Prepare(frag *Fragment) error {
mw.WriteMfhd(frag.SequenceNum)
for g := 0; g < groupCount; g++ {
- ti := &trafs[g]
+ ti := &w.trafs[g]
entries := w.trunBuf[g]
n := len(entries)
@@ -247,12 +280,9 @@ func (w *Writer) Prepare(frag *Fragment) error {
mw.WriteTfdt(uint64(ti.baseDTS))
trunStart := mw.Len()
- if patchCount < maxTracks {
- patches[patchCount] = trunPatch{
- pos: trunStart + 16, // offset to data_offset field
- dataStart: trackDataOffsets[g],
- }
- patchCount++
+ w.patches[g] = trunPatch{
+ pos: trunStart + 16, // offset to data_offset field
+ dataStart: w.trackDataOffset[g],
}
mw.WriteTrun(trunFlags, 0, firstSampleFlags, entries)
@@ -260,13 +290,16 @@ func (w *Writer) Prepare(frag *Fragment) error {
}
mw.EndBox() // moof
+ if err := mw.Err(); err != nil {
+ return err
+ }
moofSize := int32(mw.Len())
// Backpatch data_offset fields
moofBytes := mw.Bytes()
- for i := 0; i < patchCount; i++ {
- p := patches[i]
+ for i := 0; i < groupCount; i++ {
+ p := w.patches[i]
dataOffset := moofSize + mdatHeaderSize + p.dataStart
binary.BigEndian.PutUint32(moofBytes[p.pos:], uint32(dataOffset))
}
@@ -276,12 +309,54 @@ func (w *Writer) Prepare(frag *Fragment) error {
return nil
}
+func (w *Writer) ensureTrackGroups(n int) {
+ old := len(w.trackIDs)
+ if old >= n {
+ return
+ }
+ w.trackIDs = growSlice(w.trackIDs, n)
+ w.sampleIdx = growSlice(w.sampleIdx, n)
+ w.trunBuf = growSlice(w.trunBuf, n)
+ w.trafs = growSlice(w.trafs, n)
+ w.trackDataOffset = growSlice(w.trackDataOffset, n)
+ w.patches = growSlice(w.patches, n)
+ for i := old; i < n; i++ {
+ capacity := 0
+ if i < defaultWriterTrackCapacity {
+ capacity = 512
+ }
+ w.sampleIdx[i] = make([]int, 0, capacity)
+ w.trunBuf[i] = make([]mp4.TrunEntry, 0, capacity)
+ }
+}
+
+func growSlice[T any](s []T, n int) []T {
+ if cap(s) >= n {
+ return s[:n]
+ }
+ capacity := max(n, max(defaultWriterTrackCapacity, cap(s)*2))
+ grown := make([]T, n, capacity)
+ copy(grown, s)
+ return grown
+}
+
+func (w *Writer) ensureMoofCapacity(trackCount, sampleCount int) {
+ // This bound covers every optional trun field and fixed box field emitted by
+ // prepare. It grows only when a larger fragment is first encountered.
+ need := 128 + trackCount*128 + sampleCount*20
+ if cap(w.buf) >= need {
+ return
+ }
+ w.buf = make([]byte, max(need, cap(w.buf)*2))
+}
+
// WriteBodyRange writes the body bytes in [start, end) to dst, reading sample
// bytes from src only for the portion of the window that overlaps the sample
// data. Offsets are relative to the start of the body: the moof occupies
// [0, moofSize), the 8-byte mdat header [moofSize, moofSize+8), and the sample
// data the remainder up to [Writer.BodySize]. It must be called after
-// [Writer.Prepare]. start and end must satisfy 0 <= start <= end <= BodySize.
+// [Writer.Prepare] or [Writer.PrepareTrack]. start and end must satisfy
+// 0 <= start <= end <= BodySize.
func (w *Writer) WriteBodyRange(dst io.Writer, src io.ReaderAt, start, end int64) error {
moofSize := int64(len(w.moof))
diff --git a/fragment/writer_benchmark_test.go b/fragment/writer_benchmark_test.go
new file mode 100644
index 0000000..5ad98c1
--- /dev/null
+++ b/fragment/writer_benchmark_test.go
@@ -0,0 +1,80 @@
+package fragment
+
+import (
+ "io"
+ "testing"
+
+ "github.com/tetsuo/mp4/track"
+)
+
+func BenchmarkWriterPrepare(b *testing.B) {
+ samples, _ := buildSamples()
+ frag := Fragment{Samples: samples, SequenceNum: 1}
+ w := NewWriter(io.Discard)
+
+ b.ReportAllocs()
+ for b.Loop() {
+ if err := w.Prepare(&frag); err != nil {
+ b.Fatal(err)
+ }
+ }
+}
+
+func BenchmarkWriterPrepareTrack(b *testing.B) {
+ samples, _ := buildSamples()
+ frag := Fragment{Samples: samples, SequenceNum: 1}
+ w := NewWriter(io.Discard)
+
+ b.ReportAllocs()
+ for b.Loop() {
+ if err := w.PrepareTrack(&frag, 1); err != nil {
+ b.Fatal(err)
+ }
+ }
+}
+
+func BenchmarkWriterPrepareSixTracks(b *testing.B) {
+ samples := make([]track.Sample, 600)
+ for i := range samples {
+ samples[i].TrackID = uint32(i%6 + 1)
+ samples[i].Duration = 1024
+ samples[i].SetSize(128, true)
+ }
+ frag := Fragment{Samples: samples, SequenceNum: 1}
+ w := NewWriter(io.Discard)
+ if err := w.Prepare(&frag); err != nil {
+ b.Fatal(err)
+ }
+
+ b.ResetTimer()
+ b.ReportAllocs()
+ for b.Loop() {
+ if err := w.Prepare(&frag); err != nil {
+ b.Fatal(err)
+ }
+ }
+}
+
+func TestWriterPrepareSixTracksHasNoWarmAllocations(t *testing.T) {
+ samples := make([]track.Sample, 600)
+ for i := range samples {
+ samples[i].TrackID = uint32(i%6 + 1)
+ samples[i].Duration = 1024
+ samples[i].SetSize(128, true)
+ }
+ frag := Fragment{Samples: samples, SequenceNum: 1}
+ w := NewWriter(io.Discard)
+ if err := w.Prepare(&frag); err != nil {
+ t.Fatal(err)
+ }
+ var prepareErr error
+ allocs := testing.AllocsPerRun(100, func() {
+ prepareErr = w.Prepare(&frag)
+ })
+ if prepareErr != nil {
+ t.Fatal(prepareErr)
+ }
+ if allocs != 0 {
+ t.Fatalf("warm six-track prepare allocations = %v, want 0", allocs)
+ }
+}