Add video_file_reader and test

Author: yzhao-nuro

.github/.ci.conf

@@ -0,0 +1,16 @@
+# SPDX-FileCopyrightText: 2025 The Pion community <https://pion.ly>
+# SPDX-License-Identifier: MIT
+
+PRE_TEST_HOOK=_install_dependencies_hook
+PRE_LINT_HOOK=_install_dependencies_hook
+GO_MOD_VERSION_EXPECTED=1.24
+SKIP_i386_TESTS=true
+SKIP_WINDOWS_TESTS=true
+SKIP_API_DIFF=true
+
+function _install_dependencies_hook(){
+  set -e
+
+  sudo apt-get update
+  sudo apt-get install -y libvpx-dev pkg-config
+}

.gitignore

@@ -14,15 +14,18 @@
 bin/
 vendor/
 node_modules/
+data/
 
 ### Files ###
 #############
 *.ivf
 *.ogg
+*.y4m
 tags
 cover.out
 *.sw[poe]
 *.wasm
 examples/sfu-ws/cert.pem
 examples/sfu-ws/key.pem
 wasm_exec.js
+bwe-test

.reuse/dep5

@@ -2,8 +2,8 @@ Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
 Upstream-Name: Pion
 Source: https://github.com/pion/
 
-Files: README.md DESIGN.md **/README.md AUTHORS.txt renovate.json go.mod go.sum **/go.mod **/go.sum .eslintrc.json package.json examples.json sfu-ws/flutter/.gitignore sfu-ws/flutter/pubspec.yaml c-data-channels/webrtc.h examples/examples.json yarn.lock
-Copyright: 2023 The Pion community <https://pion.ly>
+Files: README.md DESIGN.md **/README.md AUTHORS.txt renovate.json go.mod go.sum **/go.mod **/go.sum .eslintrc.json package.json examples.json sfu-ws/flutter/.gitignore sfu-ws/flutter/pubspec.yaml c-data-channels/webrtc.h examples/examples.json yarn.lock vnet/phases/*.json
+Copyright: 2025 The Pion community <https://pion.ly>
 License: MIT
 
 Files: testdata/seed/* testdata/fuzz/* **/testdata/fuzz/* api/*.txt

README.md

@@ -22,9 +22,22 @@ real-time media described in [RFC8867](https://www.rfc-editor.org/rfc/rfc8867.ht
 ### Implemented/Planned Test Cases and Applications
 The current implementation uses [`vnet.Net` from
 pion/transport](https://github.com/pion/transport) to simulate network
-constraints. There are two test applications, one using a simple simulcast-like
-setup and the other one using adaptive bitrate streaming with a synthetic
-encoder.
+constraints. There are three test applications:
+
+1. **Simulcast-like setup** - Uses a simple simulcast configuration
+2. **Adaptive bitrate streaming** - Uses synthetic encoder for adaptive bitrate
+3. **Video file reader** - Reads numbered JPG image files and sends them as video frames
+
+#### Video File Reader
+The video file reader (`VideoFileReader`) reads series of numbered JPG image files 
+(e.g., `frame_000.jpg`, `frame_001.jpg`, etc.) from a directory and sends them as 
+individual video frames using an `RTCSender`. This allows testing with real video 
+content while maintaining precise control over frame timing and network conditions.
+
+To use the video file reader test:
+- Create directories with numbered JPG files (e.g., `../sample_videos_0/`, `../sample_videos_1/`)
+- Files should be named with sequential numbers (frame_000.jpg, frame_001.jpg, etc.)
+- The reader automatically discovers, sorts, and cycles through the frames
 
 To run the simulcast test, you must create three input video files as described
 in the [bandwidth-esimation-from-disk
@@ -33,6 +46,7 @@ and place them in the `vnet` directory.
 
 - [ ] **Variable Available Capacity with a Single Flow**
 - [ ] **Variable Available Capacity with Multiple Flows**
+- [x] **Dual Video Tracks with Variable Available Capacity** - Uses video file reader with multiple video tracks
 - [ ] **Congested Feedback Link with Bi-directional Media Flows**
 - [ ] **Competing Media Flows with the Same Congestion Control Algorithm**
 - [ ] **Round Trip Time Fairness**
@@ -53,6 +67,17 @@ interface. In future, we might automate the evaluation.
 ### Running
 To run the tests, run `go test -v ./vnet/`.
 
+To run the main test application with all test cases (including the video file reader test):
+```bash
+cd vnet
+go run .
+```
+
+The application will run multiple test scenarios including:
+- ABR (Adaptive Bitrate) tests with single and multiple flows
+- Simulcast tests with single and multiple flows  
+- Video file reader test with dual video tracks (requires sample video directories)
+
 ### Roadmap
 The library is used as a part of our WebRTC implementation. Please refer to that [roadmap](https://github.com/pion/webrtc/issues/9) to track our major milestones.
 

go.mod

@@ -5,6 +5,7 @@ go 1.21
 toolchain go1.25.1
 
 require (
+	github.com/bamiaux/rez v0.0.0-20170731184118-29f4463c688b
 	github.com/pion/interceptor v0.1.41
 	github.com/pion/logging v0.2.4
 	github.com/pion/mediadevices v0.7.2
@@ -16,24 +17,21 @@ require (
 	golang.org/x/sync v0.11.0
 )
 
-require (
-	github.com/pion/dtls/v3 v3.0.7 // indirect
-	github.com/pion/ice/v4 v4.0.10 // indirect
-	github.com/pion/mdns/v2 v2.0.7 // indirect
-	github.com/pion/srtp/v3 v3.0.7 // indirect
-	github.com/pion/stun/v3 v3.0.0 // indirect
-	github.com/pion/turn/v4 v4.1.1 // indirect
-	github.com/wlynxg/anet v0.0.5 // indirect
-)
-
 require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/google/uuid v1.6.0 // indirect
 	github.com/pion/datachannel v1.5.10 // indirect
+	github.com/pion/dtls/v3 v3.0.7 // indirect
+	github.com/pion/ice/v4 v4.0.10 // indirect
+	github.com/pion/mdns/v2 v2.0.7 // indirect
 	github.com/pion/randutil v0.1.0 // indirect
 	github.com/pion/sctp v1.8.39 // indirect
 	github.com/pion/sdp/v3 v3.0.15 // indirect
+	github.com/pion/srtp/v3 v3.0.7 // indirect
+	github.com/pion/stun/v3 v3.0.0 // indirect
+	github.com/pion/turn/v4 v4.1.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/wlynxg/anet v0.0.5 // indirect
 	golang.org/x/crypto v0.33.0 // indirect
 	golang.org/x/image v0.23.0 // indirect
 	golang.org/x/net v0.35.0 // indirect

go.sum

@@ -1,3 +1,5 @@
+github.com/bamiaux/rez v0.0.0-20170731184118-29f4463c688b h1:5Ci5wpOL75rYF6RQGRoqhEAU6xLJ6n/D4SckXX1yB74=
+github.com/bamiaux/rez v0.0.0-20170731184118-29f4463c688b/go.mod h1:obBQGGIFbbv9KWg92Qu9UHeD94JXmHD1jovY/z6I3O8=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=

vnet/flow.go

@@ -11,11 +11,15 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"os"
+	"path/filepath"
+	"strings"
 
 	"github.com/pion/bwe-test/logging"
 	"github.com/pion/bwe-test/receiver"
 	"github.com/pion/bwe-test/sender"
 	plogging "github.com/pion/logging"
+	"github.com/pion/transport/v3/vnet"
 )
 
 // Flow represents a WebRTC connection between a sender and receiver over a virtual network.
@@ -31,8 +35,9 @@ func NewSimpleFlow(
 	id int,
 	senderMode senderMode,
 	dataDir string,
+	videoFiles ...VideoFileInfo,
 ) (Flow, error) {
-	snd, err := newSender(loggerFactory, nm, id, senderMode, dataDir)
+	snd, err := newSender(loggerFactory, nm, id, senderMode, dataDir, videoFiles...)
 	if err != nil {
 		return Flow{}, fmt.Errorf("new sender: %w", err)
 	}
@@ -47,7 +52,21 @@ func NewSimpleFlow(
 		return Flow{}, fmt.Errorf("sender create offer: %w", err)
 	}
 
-	rc, err := newReceiver(nm, id, dataDir)
+	// Create output file path for received video
+	outputVideoPath := ""
+	if senderMode == videoFileEncoderMode {
+		// Create a subdirectory for received videos
+		receivedDir := filepath.Join(dataDir, "received_video")
+		if mkdirErr := os.MkdirAll(receivedDir, 0o750); mkdirErr != nil {
+			return Flow{}, fmt.Errorf("mkdir received_video: %w", mkdirErr)
+		}
+
+		// For multiple tracks, we'll create output files for all tracks
+		// The receiver will handle multiple tracks automatically
+		outputVideoPath = filepath.Join(receivedDir, fmt.Sprintf("received_%d.ivf", id))
+	}
+
+	rc, err := newReceiver(nm, id, dataDir, outputVideoPath, loggerFactory)
 	if err != nil {
 		return Flow{}, fmt.Errorf("new sender: %w", err)
 	}
@@ -88,10 +107,13 @@ func (f Flow) Close() error {
 	return errors.Join(errs...)
 }
 
-var errUnknownSenderMode = errors.New("unknown sender mode")
+var (
+	errUnknownSenderMode = errors.New("unknown sender mode")
+	errVideoFileRequired = errors.New("videoFileEncoderMode requires at least one video file")
+)
 
 type sndr struct {
-	sender           *sender.Sender
+	sender           sender.WebRTCSender
 	ccLogger         io.WriteCloser
 	senderRTPLogger  io.WriteCloser
 	senderRTCPLogger io.WriteCloser
@@ -124,69 +146,102 @@ func newSender(
 	id int,
 	senderMode senderMode,
 	dataDir string,
+	videoFiles ...VideoFileInfo,
 ) (sndr, error) {
 	leftVnet, publicIPLeft, err := nm.GetLeftNet()
 	if err != nil {
 		return sndr{}, fmt.Errorf("get left net: %w", err)
 	}
 
+	loggers, err := createSenderLoggers(dataDir, id)
+	if err != nil {
+		return sndr{}, err
+	}
+
+	snd, err := createWebRTCSender(senderMode, leftVnet, publicIPLeft, loggers, loggerFactory, videoFiles...)
+	if err != nil {
+		return sndr{}, err
+	}
+
+	return sndr{
+		sender:           snd,
+		ccLogger:         loggers.ccLogger,
+		senderRTPLogger:  loggers.rtpLogger,
+		senderRTCPLogger: loggers.rtcpLogger,
+	}, nil
+}
+
+type senderLoggers struct {
+	ccLogger   io.WriteCloser
+	rtpLogger  io.WriteCloser
+	rtcpLogger io.WriteCloser
+}
+
+func createSenderLoggers(dataDir string, id int) (senderLoggers, error) {
 	ccLogger, err := logging.GetLogFile(fmt.Sprintf("%v/%v_cc.log", dataDir, id))
 	if err != nil {
-		return sndr{}, fmt.Errorf("get cc log file: %w", err)
+		return senderLoggers{}, fmt.Errorf("get cc log file: %w", err)
 	}
 
 	senderRTPLogger, err := logging.GetLogFile(fmt.Sprintf("%v/%v_sender_rtp.log", dataDir, id))
 	if err != nil {
-		return sndr{}, fmt.Errorf("get sender rtp log file: %w", err)
+		return senderLoggers{}, fmt.Errorf("get sender rtp log file: %w", err)
 	}
 
 	senderRTCPLogger, err := logging.GetLogFile(fmt.Sprintf("%v/%v_sender_rtcp.log", dataDir, id))
 	if err != nil {
-		return sndr{}, fmt.Errorf("get sender rtcp log file: %w", err)
+		return senderLoggers{}, fmt.Errorf("get sender rtcp log file: %w", err)
+	}
+
+	return senderLoggers{
+		ccLogger:   ccLogger,
+		rtpLogger:  senderRTPLogger,
+		rtcpLogger: senderRTCPLogger,
+	}, nil
+}
+
+func createWebRTCSender(
+	senderMode senderMode,
+	leftVnet *vnet.Net,
+	publicIPLeft string,
+	loggers senderLoggers,
+	loggerFactory plogging.LoggerFactory,
+	videoFiles ...VideoFileInfo,
+) (sender.WebRTCSender, error) {
+	commonOpts := []sender.Option{
+		sender.SetVnet(leftVnet, []string{publicIPLeft}),
+		sender.PacketLogWriter(loggers.rtpLogger, loggers.rtcpLogger),
+		sender.GCC(100_000),
+		sender.CCLogWriter(loggers.ccLogger),
+		sender.SetLoggerFactory(loggerFactory),
 	}
 
-	var snd *sender.Sender
 	switch senderMode {
 	case abrSenderMode:
-		snd, err = sender.NewSender(
+		return sender.NewSender(
 			sender.NewStatisticalEncoderSource(),
-			sender.SetVnet(leftVnet, []string{publicIPLeft}),
-			sender.PacketLogWriter(senderRTPLogger, senderRTCPLogger),
-			sender.GCC(100_000),
-			sender.CCLogWriter(ccLogger),
-			sender.SetLoggerFactory(loggerFactory),
+			commonOpts...,
 		)
-		if err != nil {
-			return sndr{}, fmt.Errorf("new abr sender: %w", err)
-		}
 	case simulcastSenderMode:
-		snd, err = sender.NewSender(
+		return sender.NewSender(
 			sender.NewSimulcastFilesSource(),
-			sender.SetVnet(leftVnet, []string{publicIPLeft}),
-			sender.PacketLogWriter(senderRTPLogger, senderRTCPLogger),
-			sender.GCC(100_000),
-			sender.CCLogWriter(ccLogger),
-			sender.SetLoggerFactory(loggerFactory),
+			commonOpts...,
 		)
-		if err != nil {
-			return sndr{}, fmt.Errorf("new simulcast sender: %w", err)
+	case videoFileEncoderMode:
+		if len(videoFiles) == 0 {
+			return nil, errVideoFileRequired
 		}
+		return NewVideoFileSender(videoFiles, commonOpts...)
 	default:
-		return sndr{}, fmt.Errorf("%w: %v", errUnknownSenderMode, senderMode)
+		return nil, fmt.Errorf("%w: %v", errUnknownSenderMode, senderMode)
 	}
-
-	return sndr{
-		sender:           snd,
-		ccLogger:         ccLogger,
-		senderRTPLogger:  senderRTPLogger,
-		senderRTCPLogger: senderRTCPLogger,
-	}, nil
 }
 
 type recv struct {
 	receiver           *receiver.Receiver
 	receiverRTPLogger  io.WriteCloser
 	receiverRTCPLogger io.WriteCloser
+	videoOutputFile    *os.File
 }
 
 func (s recv) Close() error {
@@ -207,13 +262,17 @@ func (s recv) Close() error {
 		errs = append(errs, err)
 	}
 
+	// videoOutputFile is no longer used - receiver handles file closing internally
+
 	return errors.Join(errs...)
 }
 
 func newReceiver(
 	nm *NetworkManager,
 	id int,
 	dataDir string,
+	outputVideoPath string,
+	loggerFactory plogging.LoggerFactory,
 ) (recv, error) {
 	rightVnet, publicIPRight, err := nm.GetRightNet()
 	if err != nil {
@@ -230,11 +289,22 @@ func newReceiver(
 		return recv{}, fmt.Errorf("get receiver rtcp log file: %w", err)
 	}
 
-	rc, err := receiver.NewReceiver(
+	// Create options for the receiver
+	opts := []receiver.Option{
 		receiver.SetVnet(rightVnet, []string{publicIPRight}),
 		receiver.PacketLogWriter(receiverRTPLogger, receiverRTCPLogger),
 		receiver.DefaultInterceptors(),
-	)
+		receiver.SetLoggerFactory(loggerFactory),
+	}
+
+	// Add video saving option if outputVideoPath is set
+	if outputVideoPath != "" {
+		// Use SaveVideo for video saving - remove .ivf extension from base path
+		baseOutputPath := strings.TrimSuffix(outputVideoPath, ".ivf")
+		opts = append(opts, receiver.SaveVideo(baseOutputPath))
+	}
+
+	rc, err := receiver.NewReceiver(opts...)
 	if err != nil {
 		return recv{}, fmt.Errorf("new receiver: %w", err)
 	}
@@ -243,5 +313,6 @@ func newReceiver(
 		receiver:           rc,
 		receiverRTPLogger:  receiverRTPLogger,
 		receiverRTCPLogger: receiverRTCPLogger,
+		videoOutputFile:    nil, // No longer used with multiple track approach
 	}, nil
 }