diff options
| author | Onur Gündüz <ogunduz@gmail.com> | 2026-09-15 00:07:23 +0200 |
|---|---|---|
| committer | Onur Gündüz <ogunduz@gmail.com> | 2026-09-15 00:07:23 +0200 |
| commit | 30d1ade78dce56c97bb6e1585da3fcb71784c43e (patch) | |
| tree | 7986d3116d14748471519d14d5d7fe9de16f8715 /fragment | |
| parent | d2b3cde2cff3cdfc0cf435e91fad6d40cbc8e85e (diff) | |
| download | mp4-30d1ade78dce56c97bb6e1585da3fcb71784c43e.tar.gz mp4-30d1ade78dce56c97bb6e1585da3fcb71784c43e.zip | |
fragment: support multi-track and per-track output
Diffstat (limited to 'fragment')
| -rw-r--r-- | fragment/reader.go | 370 | ||||
| -rw-r--r-- | fragment/reader_test.go | 109 | ||||
| -rw-r--r-- | fragment/track_selection_test.go | 771 | ||||
| -rw-r--r-- | fragment/writer.go | 187 | ||||
| -rw-r--r-- | fragment/writer_benchmark_test.go | 80 |
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) + } +} |
