feat: add VVC NAL unit support to mp4ff-nallister

  - Add VVC codec option (-c vvc) to command line interface
  - Change return type of Sample.PresentationTime() to int64
  - Implement VVC AUD detection for Annex B stream processing

Author: tobbee

CHANGELOG.md

@@ -10,12 +10,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 
 - Basic VVC support with vvcC box and VvcDecoderConfigurationRecord
+- Support for parsing VVC NAL unit headers and listing types in mp4ff-nallister
 - Minimal AC-4 support by recognizing ac-4 as AudioSampleDescrition box
 - Support for Opus and dOps boxes
 
 ### Changed
 
 - Makefile update to setup and run pre-commit with configuration
+- Return type of Sample.PresentationTime is now int64 instead of uint64
+  This may happen together with edit lists (seen for VVC video)
 
 ## [0.49.0] - 2025-06-26
 

cmd/mp4ff-nallister/main.go

@@ -14,13 +14,14 @@ import (
 	"github.com/Eyevinn/mp4ff/internal"
 	"github.com/Eyevinn/mp4ff/mp4"
 	"github.com/Eyevinn/mp4ff/sei"
+	"github.com/Eyevinn/mp4ff/vvc"
 )
 
 const (
 	appName = "mp4ff-nallister"
 )
 
-var usg = `%s lists NAL units and slice types of AVC or HEVC tracks of an mp4 (ISOBMFF) file
+var usg = `%s lists NAL units and slice types of AVC, HEVC, or VVC tracks of an mp4 (ISOBMFF) file
 or a file containing a byte stream in Annex B format.
 
 Takes first video track in a progressive file and the first track in a fragmented file.
@@ -51,7 +52,7 @@ func parseOptions(fs *flag.FlagSet, args []string) (*options, error) {
 	opts := options{}
 
 	fs.IntVar(&opts.maxNrSamples, "m", -1, "Max nr of samples to parse")
-	fs.StringVar(&opts.codec, "c", "avc", "Codec to parse (avc or hevc)")
+	fs.StringVar(&opts.codec, "c", "avc", "Codec to parse (avc, hevc, or vvc)")
 	fs.IntVar(&opts.seiLevel, "sei", 0, "Level of SEI information (1 is interpret, 2 is dump hex)")
 	fs.IntVar(&opts.printRaw, "raw", 0, "nr raw NAL unit bytes to print")
 	fs.BoolVar(&opts.annexB, "annexb", false, "Input is Annex B stream file")
@@ -108,7 +109,8 @@ func run(args []string, stdout io.Writer) error {
 		}
 		var avcSPS *avc.SPS
 		for i, frame := range frames {
-			if o.codec == "avc" {
+			switch o.codec {
+			case "avc":
 				if avcSPS == nil {
 					for _, nalu := range frame {
 						if avc.GetNaluType(nalu[0]) == avc.NALU_SPS {
@@ -120,8 +122,12 @@ func run(args []string, stdout io.Writer) error {
 					}
 				}
 				err = printAVCNalus(stdout, avcSPS, frame, i+1, 0, o.seiLevel, o.printPsHex, o.printRaw)
-			} else {
+			case "hevc":
 				err = printHEVCNalus(stdout, frame, i+1, 0, o.seiLevel, o.printPsHex, o.printRaw)
+			case "vvc":
+				err = printVVCNalus(stdout, frame, i+1, 0, o.seiLevel, o.printPsHex, o.printRaw)
+			default:
+				return fmt.Errorf("unsupported codec: %s", o.codec)
 			}
 			if err != nil {
 				return fmt.Errorf("printing error: %w", err)
@@ -175,6 +181,8 @@ func parseProgressiveMp4(w io.Writer, f *mp4.File, maxNrSamples int, codec strin
 		}
 	} else if stbl.Stsd.HvcX != nil {
 		codec = "hevc"
+	} else if stbl.Stsd.VvcX != nil {
+		codec = "vvc"
 	}
 	nrSamples := stbl.Stsz.SampleNumber
 	mdat := f.Mdat
@@ -194,9 +202,9 @@ func parseProgressiveMp4(w io.Writer, f *mp4.File, maxNrSamples int, codec strin
 		}
 		size := stbl.Stsz.GetSampleSize(sampleNr)
 		decTime, _ := stbl.Stts.GetDecodeTime(uint32(sampleNr))
-		var cto int32 = 0
+		var cto int64 = 0
 		if stbl.Ctts != nil {
-			cto = stbl.Ctts.GetCompositionTimeOffset(uint32(sampleNr))
+			cto = int64(stbl.Ctts.GetCompositionTimeOffset(uint32(sampleNr)))
 		}
 		// Next find sample bytes as slice in mdat
 		offsetInMdatData := uint64(offset) - mdatPayloadStart
@@ -217,9 +225,11 @@ func parseProgressiveMp4(w io.Writer, f *mp4.File, maxNrSamples int, codec strin
 					}
 				}
 			}
-			err = printAVCNalus(w, avcSPS, nalus, sampleNr, decTime+uint64(cto), seiLevel, parameterSets, nrRaw)
+			err = printAVCNalus(w, avcSPS, nalus, sampleNr, int64(decTime)+cto, seiLevel, parameterSets, nrRaw)
 		case "hevc", "h.265", "h265":
-			err = printHEVCNalus(w, nalus, sampleNr, decTime+uint64(cto), seiLevel, parameterSets, nrRaw)
+			err = printHEVCNalus(w, nalus, sampleNr, int64(decTime)+cto, seiLevel, parameterSets, nrRaw)
+		case "vvc", "h.266", "h266":
+			err = printVVCNalus(w, nalus, sampleNr, int64(decTime)+cto, seiLevel, parameterSets, nrRaw)
 		default:
 			return fmt.Errorf("unknown codec: %s", codec)
 		}
@@ -258,6 +268,7 @@ func parseFragmentedMp4(w io.Writer, f *mp4.File, maxNrSamples int, codec string
 	var trex *mp4.TrexBox
 	var avcSPS *avc.SPS
 	var err error
+	var editListOffset int64 = 0
 	if f.Init != nil { // Auto-detect codec if moov box is there
 		moov := f.Init.Moov
 		videoTrak, ok := findFirstVideoTrak(moov)
@@ -275,8 +286,11 @@ func parseFragmentedMp4(w io.Writer, f *mp4.File, maxNrSamples int, codec string
 			}
 		} else if stbl.Stsd.HvcX != nil {
 			codec = "hevc"
+		} else if stbl.Stsd.VvcX != nil {
+			codec = "vvc"
 		}
 		trex, _ = moov.Mvex.GetTrex(videoTrak.Tkhd.TrackID)
+		editListOffset = getVideoListOffset(moov, videoTrak)
 	}
 	iSamples := make([]mp4.FullSample, 0)
 	for _, iSeg := range f.Segments {
@@ -295,9 +309,11 @@ func parseFragmentedMp4(w io.Writer, f *mp4.File, maxNrSamples int, codec string
 		}
 		switch codec {
 		case "avc", "h.264", "h264":
-			err = printAVCNalus(w, avcSPS, nalus, i+1, s.PresentationTime(), seiLevel, parameterSets, nrRaw)
+			err = printAVCNalus(w, avcSPS, nalus, i+1, s.PresentationTime()+editListOffset, seiLevel, parameterSets, nrRaw)
 		case "hevc", "h.265", "h265":
-			err = printHEVCNalus(w, nalus, i+1, s.PresentationTime(), seiLevel, parameterSets, nrRaw)
+			err = printHEVCNalus(w, nalus, i+1, s.PresentationTime()+editListOffset, seiLevel, parameterSets, nrRaw)
+		case "vvc", "h.266", "h266":
+			err = printVVCNalus(w, nalus, i+1, s.PresentationTime()+editListOffset, seiLevel, parameterSets, nrRaw)
 		default:
 			return fmt.Errorf("unknown codec: %s", codec)
 		}
@@ -312,7 +328,24 @@ func parseFragmentedMp4(w io.Writer, f *mp4.File, maxNrSamples int, codec string
 	return nil
 }
 
-func printAVCNalus(w io.Writer, avcSPS *avc.SPS, nalus [][]byte, nr int, pts uint64, seiLevel int, parameterSets bool, nrRaw int) error {
+func getVideoListOffset(moov *mp4.MoovBox, videoTrak *mp4.TrakBox) int64 {
+	editListOffset := int64(0)
+	for _, ch := range videoTrak.Children {
+		if ch.Type() == "edts" {
+			edts := ch.(*mp4.EdtsBox)
+			for _, el := range edts.Elst {
+				for _, entry := range el.Entries {
+					if entry.MediaTime < 0 {
+						editListOffset = int64(entry.SegmentDuration) * int64(videoTrak.Mdia.Mdhd.Timescale) / int64(moov.Mvhd.Timescale)
+					}
+				}
+			}
+		}
+	}
+	return editListOffset
+}
+
+func printAVCNalus(w io.Writer, avcSPS *avc.SPS, nalus [][]byte, nr int, pts int64, seiLevel int, parameterSets bool, nrRaw int) error {
 	msg := ""
 	var seiNALUs [][]byte
 	totLen := 0
@@ -363,7 +396,7 @@ func printAVCNalus(w io.Writer, avcSPS *avc.SPS, nalus [][]byte, nr int, pts uin
 	return nil
 }
 
-func printHEVCNalus(w io.Writer, nalus [][]byte, nr int, pts uint64, seiLevel int, parameterSets bool, nrRaw int) error {
+func printHEVCNalus(w io.Writer, nalus [][]byte, nr int, pts int64, seiLevel int, parameterSets bool, nrRaw int) error {
 	msg := ""
 	var seiNALUs [][]byte
 	totLen := 0
@@ -401,6 +434,52 @@ func printHEVCNalus(w io.Writer, nalus [][]byte, nr int, pts uint64, seiLevel in
 	return nil
 }
 
+func printVVCNalus(w io.Writer, nalus [][]byte, nr int, pts int64, seiLevel int, parameterSets bool, nrRaw int) error {
+	msg := ""
+	var seiNALUs [][]byte
+	totLen := 0
+	for i, nalu := range nalus {
+		totLen += 4 + len(nalu)
+		if i > 0 {
+			msg += ","
+		}
+		header, err := vvc.ParseNaluHeader(nalu)
+		if err != nil {
+			return fmt.Errorf("error parsing VVC NALU header: %w", err)
+		}
+		naluType := header.NaluType
+		if nrRaw > 0 {
+			msg += fmt.Sprintf("\n %s (%dB)", naluType, len(nalu))
+			msg += fmt.Sprintf(" raw: %s", bytesToStringN(nalu, nrRaw))
+		} else {
+			msg += fmt.Sprintf(" %s (%dB)", naluType, len(nalu))
+		}
+		if seiLevel > 0 && (naluType == vvc.NALU_SEI_PREFIX || naluType == vvc.NALU_SEI_SUFFIX) {
+			seiNALUs = append(seiNALUs, nalu)
+		}
+	}
+	fmt.Fprintf(w, "Sample %d, pts=%d (%dB):%s\n", nr, pts, totLen, msg)
+	printSEINALus(w, seiNALUs, "vvc", seiLevel, nil)
+	if parameterSets {
+		for _, nalu := range nalus {
+			header, err := vvc.ParseNaluHeader(nalu)
+			if err != nil {
+				continue
+			}
+			naluType := header.NaluType
+			switch naluType {
+			case vvc.NALU_VPS:
+				fmt.Fprintf(w, "  VPS: %s\n", hex.EncodeToString(nalu))
+			case vvc.NALU_SPS:
+				fmt.Fprintf(w, "  SPS: %s\n", hex.EncodeToString(nalu))
+			case vvc.NALU_PPS:
+				fmt.Fprintf(w, "  PPS: %s\n", hex.EncodeToString(nalu))
+			}
+		}
+	}
+	return nil
+}
+
 // printSEINALus - print interpreted information if seiLevel is >= 1. Add hex dump if seiLevel >= 2
 func printSEINALus(w io.Writer, seiNALUs [][]byte, codec string, seiLevel int, avcSPS *avc.SPS) {
 	if seiLevel < 1 {
@@ -412,7 +491,7 @@ func printSEINALus(w io.Writer, seiNALUs [][]byte, codec string, seiLevel int, a
 	case "avc":
 		seiCodec = sei.AVC
 		hdrLen = 1
-	case "hevc":
+	case "hevc", "vvc": // VVC uses same SEI format as HEVC
 		seiCodec = sei.HEVC
 		hdrLen = 2
 	}
@@ -476,6 +555,8 @@ func findAnnexBFrames(nalus [][]byte, codec string) ([][][]byte, error) {
 		isAUD = isAvcAudNalu
 	case "hevc":
 		isAUD = isHEVCAudNalu
+	case "vvc":
+		isAUD = isVVCAudNalu
 	default:
 		return nil, fmt.Errorf("unknown codec: %s", codec)
 	}
@@ -502,3 +583,11 @@ func isAvcAudNalu(nalu []byte) bool {
 func isHEVCAudNalu(nalu []byte) bool {
 	return hevc.GetNaluType(nalu[0]) == hevc.NALU_AUD
 }
+
+func isVVCAudNalu(nalu []byte) bool {
+	header, err := vvc.ParseNaluHeader(nalu)
+	if err != nil {
+		return false
+	}
+	return header.NaluType == vvc.NALU_AUD
+}

cmd/mp4ff-nallister/main_test.go

@@ -4,6 +4,9 @@ import (
 	"bytes"
 	"os"
 	"testing"
+
+	"github.com/Eyevinn/mp4ff/avc"
+	"github.com/Eyevinn/mp4ff/mp4"
 )
 
 func TestOptions(t *testing.T) {
@@ -28,7 +31,7 @@ func TestOptions(t *testing.T) {
 			goldenOut: "testdata/golden_prot_h264_4pics.txt", expectedErr: false},
 		{desc: "mp4H264", args: []string{appName, "testdata/h264.mp4"},
 			goldenOut: "testdata/golden_h264_mp4.txt", expectedErr: false},
-		{desc: "annexBHEVC", args: []string{appName, "-annexb", "-c", "hevc", "testdata/hevc.265"},
+		{desc: "annexBHEVC", args: []string{appName, "-annexb", "-c", "hevc", "-ps", "testdata/hevc.265"},
 			goldenOut: "testdata/golden_hevc_265.txt", expectedErr: false},
 		{desc: "annexBHEVC with SEI", args: []string{appName, "-annexb", "-c", "hevc", "-sei", "2", "testdata/hevc.265"},
 			goldenOut: "", expectedErr: false},
@@ -38,6 +41,10 @@ func TestOptions(t *testing.T) {
 			goldenOut: "testdata/golden_h264_frag_raw.txt", expectedErr: false},
 		{desc: "avcSeiTime", args: []string{appName, "-sei", "2", "-annexb", "testdata/4pics.264"},
 			goldenOut: "testdata/golden_4pic_sei_264.txt", expectedErr: false},
+		{desc: "vvc 2s", args: []string{appName, "../../mp4/testdata/vvc_400kbps_2s.mp4"}, expectedErr: false,
+			goldenOut: "testdata/golden_vvc_2s.txt"},
+		{desc: "vvc annexB", args: []string{appName, "-annexb", "-ps", "-c", "vvc", "testdata/annexb.vvc"}, expectedErr: false,
+			goldenOut: "testdata/golden_vvc_annexb.txt"},
 		{desc: "version", args: []string{appName, "-version"}, expectedErr: false},
 		{desc: "help", args: []string{appName, "-h"}, expectedErr: false},
 	}
@@ -75,3 +82,29 @@ func getExpected(t *testing.T, filename string) string {
 	r := bytes.ReplaceAll(b, []byte("\r\n"), []byte("\n"))
 	return string(r)
 }
+
+func MakeByteStream(t *testing.T, inFile, outFile string) {
+	t.Helper()
+	ifd, err := os.Open(inFile)
+	if err != nil {
+		t.Fatalf("could not open file %s: %s", inFile, err)
+	}
+	d, err := mp4.DecodeFile(ifd)
+	if err != nil {
+		t.Fatalf("could not decode file %s: %s", inFile, err)
+	}
+	fullSamples, err := d.Segments[0].Fragments[0].GetFullSamples(nil)
+	if err != nil {
+		t.Fatalf("could not get full samples: %s", err)
+	}
+	byteStream := make([]byte, 0, 1024)
+	for i := 0; i <= 5; i++ {
+		fs := fullSamples[i]
+		bs := avc.ConvertSampleToByteStream(fs.Data)
+		byteStream = append(byteStream, bs...)
+	}
+	err = os.WriteFile(outFile, byteStream, 0644)
+	if err != nil {
+		t.Fatalf("could not write file %s: %s", outFile, err)
+	}
+}

cmd/mp4ff-nallister/testdata/annexb.vvc

@@ -1 +1,4 @@
 Sample 1, pts=0 (14185B): VPS_32 (24B), SPS_33 (42B), PPS_34 (7B), SEI_39 (2340B), RAP_IDR_20 (914B), NonRAP_Trail_1 (266B), NonRAP_Trail_1 (160B), NonRAP_Trail_0 (151B), NonRAP_Trail_1 (276B), NonRAP_Trail_1 (192B), NonRAP_Trail_0 (212B), NonRAP_Trail_0 (183B), NonRAP_Trail_0 (190B), NonRAP_Trail_1 (353B), NonRAP_Trail_1 (178B), NonRAP_Trail_0 (177B), NonRAP_Trail_1 (258B), NonRAP_Trail_1 (184B), NonRAP_Trail_0 (171B), NonRAP_Trail_1 (227B), NonRAP_Trail_0 (176B), NonRAP_Trail_1 (220B), NonRAP_Trail_1 (267B), NonRAP_Trail_1 (224B), NonRAP_Trail_0 (200B), NonRAP_Trail_0 (200B), NonRAP_Trail_0 (198B), NonRAP_Trail_1 (228B), NonRAP_Trail_0 (191B), NonRAP_Trail_1 (288B), NonRAP_Trail_1 (326B), NonRAP_Trail_1 (212B), NonRAP_Trail_0 (214B), NonRAP_Trail_0 (201B), NonRAP_Trail_0 (209B), NonRAP_Trail_1 (298B), NonRAP_Trail_1 (202B), NonRAP_Trail_0 (194B), NonRAP_Trail_0 (191B), NonRAP_Trail_0 (200B), NonRAP_Trail_1 (328B), NonRAP_Trail_1 (204B), NonRAP_Trail_0 (201B), NonRAP_Trail_0 (199B), NonRAP_Trail_0 (205B), NonRAP_Trail_1 (222B), NonRAP_Trail_1 (194B), NonRAP_Trail_0 (177B), NonRAP_Trail_0 (187B), NonRAP_Trail_1 (331B), NonRAP_Trail_1 (211B), NonRAP_Trail_0 (180B), NonRAP_Trail_0 (197B), NonRAP_Trail_0 (189B)
+  VPS: 40010c01ffff01600000030090000003000003007b959809
+  SPS: 42010101600000030090000003000003007ba003c08010e596566924caf0169c20000003002000000641
+  PPS: 4401c172b46240

cmd/mp4ff-nallister/testdata/golden_hevc_265.txt

@@ -0,0 +1,50 @@
+Sample 1, pts=12288 (11051B): AUD_20 (3B), SPS_15 (176B), PPS_16 (13B), PREFIX_APS_17 (118B), IDR_W_RADL_7 (10721B)
+Sample 2, pts=7680 (2192B): AUD_20 (3B), PREFIX_APS_17 (62B), RADL_2 (2115B)
+Sample 3, pts=3584 (1846B): AUD_20 (3B), PREFIX_APS_17 (21B), RADL_2 (1810B)
+Sample 4, pts=1536 (1404B): AUD_20 (3B), PREFIX_APS_17 (41B), RADL_2 (1348B)
+Sample 5, pts=512 (683B): AUD_20 (3B), PREFIX_APS_17 (19B), RADL_2 (649B)
+Sample 6, pts=0 (655B): AUD_20 (3B), PREFIX_APS_17 (53B), RADL_2 (587B)
+Sample 7, pts=1024 (277B): AUD_20 (3B), PREFIX_APS_17 (8B), RADL_2 (254B)
+Sample 8, pts=2560 (453B): AUD_20 (3B), PREFIX_APS_17 (13B), RADL_2 (425B)
+Sample 9, pts=2048 (342B): AUD_20 (3B), RADL_2 (331B)
+Sample 10, pts=3072 (331B): AUD_20 (3B), RADL_2 (320B)
+Sample 11, pts=5632 (789B): AUD_20 (3B), PREFIX_APS_17 (38B), RADL_2 (736B)
+Sample 12, pts=4608 (437B): AUD_20 (3B), RADL_2 (426B)
+Sample 13, pts=4096 (273B): AUD_20 (3B), RADL_2 (262B)
+Sample 14, pts=5120 (263B): AUD_20 (3B), RADL_2 (252B)
+Sample 15, pts=6656 (404B): AUD_20 (3B), RADL_2 (393B)
+Sample 16, pts=6144 (257B): AUD_20 (3B), RADL_2 (246B)
+Sample 17, pts=7168 (281B): AUD_20 (3B), RADL_2 (270B)
+Sample 18, pts=11776 (822B): AUD_20 (3B), PREFIX_APS_17 (13B), RADL_2 (794B)
+Sample 19, pts=9728 (790B): AUD_20 (3B), PREFIX_APS_17 (36B), RADL_2 (739B)
+Sample 20, pts=8704 (443B): AUD_20 (3B), PREFIX_APS_17 (8B), RADL_2 (420B)
+Sample 21, pts=8192 (336B): AUD_20 (3B), RADL_2 (325B)
+Sample 22, pts=9216 (310B): AUD_20 (3B), RADL_2 (299B)
+Sample 23, pts=10752 (446B): AUD_20 (3B), RADL_2 (435B)
+Sample 24, pts=10240 (286B): AUD_20 (3B), RADL_2 (275B)
+Sample 25, pts=11264 (252B): AUD_20 (3B), RADL_2 (241B)
+Sample 26, pts=25088 (14691B): AUD_20 (3B), SPS_15 (176B), PPS_16 (13B), PREFIX_APS_17 (94B), IDR_W_RADL_7 (14385B)
+Sample 27, pts=20480 (4034B): AUD_20 (3B), PREFIX_APS_17 (69B), RADL_2 (3950B)
+Sample 28, pts=16384 (3323B): AUD_20 (3B), PREFIX_APS_17 (116B), RADL_2 (3192B)
+Sample 29, pts=14336 (2123B): AUD_20 (3B), PREFIX_APS_17 (63B), RADL_2 (2045B)
+Sample 30, pts=13312 (1158B): AUD_20 (3B), PREFIX_APS_17 (14B), RADL_2 (1129B)
+Sample 31, pts=12800 (610B): AUD_20 (3B), RADL_2 (599B)
+Sample 32, pts=13824 (361B): AUD_20 (3B), PREFIX_APS_17 (13B), RADL_2 (333B)
+Sample 33, pts=15360 (450B): AUD_20 (3B), PREFIX_APS_17 (15B), RADL_2 (420B)
+Sample 34, pts=14848 (385B): AUD_20 (3B), RADL_2 (374B)
+Sample 35, pts=15872 (313B): AUD_20 (3B), PREFIX_APS_17 (8B), RADL_2 (290B)
+Sample 36, pts=18432 (1241B): AUD_20 (3B), PREFIX_APS_17 (42B), RADL_2 (1184B)
+Sample 37, pts=17408 (613B): AUD_20 (3B), PREFIX_APS_17 (40B), RADL_2 (558B)
+Sample 38, pts=16896 (318B): AUD_20 (3B), RADL_2 (307B)
+Sample 39, pts=17920 (335B): AUD_20 (3B), RADL_2 (324B)
+Sample 40, pts=19456 (532B): AUD_20 (3B), PREFIX_APS_17 (10B), RADL_2 (507B)
+Sample 41, pts=18944 (334B): AUD_20 (3B), RADL_2 (323B)
+Sample 42, pts=19968 (342B): AUD_20 (3B), PREFIX_APS_17 (8B), RADL_2 (319B)
+Sample 43, pts=24576 (1461B): AUD_20 (3B), PREFIX_APS_17 (35B), RADL_2 (1411B)
+Sample 44, pts=22528 (1043B): AUD_20 (3B), PREFIX_APS_17 (50B), RADL_2 (978B)
+Sample 45, pts=21504 (459B): AUD_20 (3B), PREFIX_APS_17 (15B), RADL_2 (429B)
+Sample 46, pts=20992 (320B): AUD_20 (3B), RADL_2 (309B)
+Sample 47, pts=22016 (230B): AUD_20 (3B), RADL_2 (219B)
+Sample 48, pts=23552 (558B): AUD_20 (3B), PREFIX_APS_17 (14B), RADL_2 (529B)
+Sample 49, pts=23040 (341B): AUD_20 (3B), RADL_2 (330B)
+Sample 50, pts=24064 (336B): AUD_20 (3B), RADL_2 (325B)

cmd/mp4ff-nallister/testdata/golden_vvc_2s.txt

@@ -0,0 +1,8 @@
+Sample 1, pts=0 (11051B): AUD_20 (3B), SPS_15 (176B), PPS_16 (13B), PREFIX_APS_17 (118B), IDR_W_RADL_7 (10721B)
+  SPS: 007900ad0233800000800a0200b446a007374dba6469149bce1365630408278034833610864c442064883521e8f56a4bc926a4b2445a88bc449a88914911264889351962210b24216a10bc217ab525e4bd43483362419b1012210202454204048d210202458810122208091641012242024c81222102459081224409341224824e12709b222211164222444d22493a7fe9765fe7240000030004000003006784ec0061a80004c4b40030d40002625a10
+  PPS: 008100000501005a22241fb820
+Sample 2, pts=0 (2192B): AUD_20 (3B), PREFIX_APS_17 (62B), RADL_2 (2115B)
+Sample 3, pts=0 (1846B): AUD_20 (3B), PREFIX_APS_17 (21B), RADL_2 (1810B)
+Sample 4, pts=0 (1404B): AUD_20 (3B), PREFIX_APS_17 (41B), RADL_2 (1348B)
+Sample 5, pts=0 (683B): AUD_20 (3B), PREFIX_APS_17 (19B), RADL_2 (649B)
+Sample 6, pts=0 (655B): AUD_20 (3B), PREFIX_APS_17 (53B), RADL_2 (587B)