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/track_selection_test.go | |
| parent | d2b3cde2cff3cdfc0cf435e91fad6d40cbc8e85e (diff) | |
| download | mp4-30d1ade78dce56c97bb6e1585da3fcb71784c43e.tar.gz mp4-30d1ade78dce56c97bb6e1585da3fcb71784c43e.zip | |
fragment: support multi-track and per-track output
Diffstat (limited to 'fragment/track_selection_test.go')
| -rw-r--r-- | fragment/track_selection_test.go | 771 |
1 files changed, 771 insertions, 0 deletions
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 +} |
