fix(deps): update module github.com/pion/rtp to v1.8.22

Generated by Renovate Bot

.github/workflows/ci.yaml

@@ -22,7 +22,7 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v4
       - name: Setup Go
-        uses: actions/setup-go@v5
+        uses: actions/setup-go@v6
         with:
           go-version: ${{ matrix.go }}
       - name: Install dependencies
@@ -53,7 +53,7 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v4
       - name: Setup Go
-        uses: actions/setup-go@v5
+        uses: actions/setup-go@v6
         with:
           go-version: ${{ matrix.go }}
       - name: Install dependencies
@@ -76,7 +76,7 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v4
       - name: Setup Go
-        uses: actions/setup-go@v5
+        uses: actions/setup-go@v6
         with:
           go-version: stable
       - name: Installing go-licenses

.github/workflows/pkg-codec-ffmpeg-ci.yaml

@@ -1,157 +0,0 @@
-name: pkg/codec/ffmpeg CI
-on:
-  pull_request:
-    branches:
-      - master
-    paths:
-      - pkg/codec/ffmepg
-  push:
-    branches:
-      - master
-    paths:
-      - pkg/codec/ffmepg
-
-jobs:
-  build-linux:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        go:
-          - '1.21' # oldest version this package supports
-          - '1.22' # oldstable Go version
-          - '1.23' # stable Go version
-    name: Linux Go ${{ matrix.go }}
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - name: Setup Go
-        uses: actions/setup-go@v5
-        with:
-          go-version: ${{ matrix.go }}
-      - name: Install dependencies
-        run: |
-          sudo apt-get update -qq
-          sudo apt-get install --no-install-recommends -y \
-            libopus-dev \
-            libva-dev \
-            libvpx-dev \
-            libx11-dev \
-            libx264-dev \
-            libxext-dev \
-            nasm \
-            yasm
-      - name: Cache FFmpeg build
-        uses: actions/cache@v4
-        id: ffmpeg-cache
-        with:
-          path: |
-            pkg/codec/ffmpeg/tmp/n7.0
-          key: ffmpeg-linux-n7.0-${{ hashFiles('pkg/codec/ffmpeg/Makefile') }}
-          restore-keys: |
-            ffmpeg-linux-n7.0-
-      - name: Check if FFmpeg libraries exist
-        id: ffmpeg-check
-        working-directory: pkg/codec/ffmpeg
-        run: |
-          echo "=== Checking FFmpeg cache status ==="
-          if [ -f "tmp/n7.0/lib/libavcodec.a" ] && [ -f "tmp/n7.0/lib/pkgconfig/libavcodec.pc" ]; then
-            echo "FFmpeg libraries found in cache"
-            echo "ffmpeg_exists=true" >> $GITHUB_OUTPUT
-          else
-            echo "FFmpeg libraries missing or incomplete"
-            ls -la tmp/ 2>/dev/null || echo "tmp directory does not exist"
-            ls -la tmp/n7.0/ 2>/dev/null || echo "n7.0 directory does not exist"
-            ls -la tmp/n7.0/lib/ 2>/dev/null || echo "lib directory does not exist"
-            echo "ffmpeg_exists=false" >> $GITHUB_OUTPUT
-          fi
-      - name: Build FFmpeg (if not cached or incomplete)
-        if: steps.ffmpeg-cache.outputs.cache-hit != 'true' || steps.ffmpeg-check.outputs.ffmpeg_exists != 'true'
-        working-directory: pkg/codec/ffmpeg
-        run: make build-ffmpeg
-      - name: Verify FFmpeg installation
-        working-directory: pkg/codec/ffmpeg
-        run: |
-          ls -la tmp/n7.0/
-          ls -la tmp/n7.0/lib/ || echo "lib directory not found"
-          ls -la tmp/n7.0/include/ || echo "include directory not found"
-          pkg-config --exists --print-errors libavcodec || echo "pkg-config check failed"
-        env:
-          PKG_CONFIG_PATH: ${{ github.workspace }}/pkg/codec/ffmpeg/tmp/n7.0/lib/pkgconfig
-      - name: Run pkg/codec/ffmpeg Test Suite
-        working-directory: pkg/codec/ffmpeg
-        run: |
-          make test
-        env:
-          PKG_CONFIG_PATH: ${{ github.workspace }}/pkg/codec/ffmpeg/tmp/n7.0/lib/pkgconfig
-      - uses: codecov/codecov-action@v5
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}
-  build-darwin:
-    strategy:
-      fail-fast: false
-      matrix:
-        go:
-          - '1.22'
-          - '1.23'
-    runs-on: macos-latest
-    name: Darwin Go ${{ matrix.go }}
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - name: Setup Go
-        uses: actions/setup-go@v5
-        with:
-          go-version: ${{ matrix.go }}
-      - name: Install dependencies
-        run: |
-          brew install \
-            pkg-config \
-            opus \
-            libvpx \
-            x264
-      - name: Cache FFmpeg build
-        uses: actions/cache@v4
-        id: ffmpeg-cache
-        with:
-          path: |
-            pkg/codec/ffmpeg/tmp/n7.0
-          key: ffmpeg-darwin-n7.0-${{ hashFiles('pkg/codec/ffmpeg/Makefile') }}
-          restore-keys: |
-            ffmpeg-darwin-n7.0-
-      - name: Check if FFmpeg libraries exist
-        id: ffmpeg-check
-        working-directory: pkg/codec/ffmpeg
-        run: |
-          if [ -f "tmp/n7.0/lib/libavcodec.a" ] && [ -f "tmp/n7.0/lib/pkgconfig/libavcodec.pc" ]; then
-            echo "ffmpeg_exists=true" >> $GITHUB_OUTPUT
-          else
-            echo "ffmpeg_exists=false" >> $GITHUB_OUTPUT
-          fi
-      - name: Build FFmpeg (if not cached or incomplete)
-        if: steps.ffmpeg-cache.outputs.cache-hit != 'true' || steps.ffmpeg-check.outputs.ffmpeg_exists != 'true'
-        working-directory: pkg/codec/ffmpeg
-        run: make build-ffmpeg
-      - name: Run Test Suite
-        working-directory: pkg/codec/ffmpeg
-        run: |
-          make test
-        env:
-          PKG_CONFIG_PATH: ${{ github.workspace }}/pkg/codec/ffmpeg/tmp/n7.0/lib/pkgconfig
-      - uses: codecov/codecov-action@v5
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}
-  check-licenses:
-    runs-on: ubuntu-latest
-    name: Check Licenses
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - name: Setup Go
-        uses: actions/setup-go@v5
-        with:
-          go-version: stable
-      - name: Installing go-licenses
-        run: go install github.com/google/go-licenses@latest
-      - name: Checking licenses
-        run: go-licenses check ./...

README.md

@@ -164,24 +164,6 @@ An open source API that allows applications such as VLC media player or GStreame
 * Installation:
   * Ubuntu: `apt install libva-dev`
 
-#### Video codecs implemented using ffmpeg
-
-* Package: [github.com/pion/mediadevices/pkg/codec/ffmpeg](https://pkg.go.dev/github.com/pion/mediadevices/pkg/codec/ffmpeg)
-* Installation: You need to enable CGO, and provide the ffmpeg headers and libraries when compiling. For more detail, checkout
-https://github.com/asticode/go-astiav?tab=readme-ov-file#install-ffmpeg-from-source.
-  * NVENC: If you want to use nvenc, you need to install [FFmpeg/nv-codec-headers](https://github.com/FFmpeg/nv-codec-headers) too.
-  Make sure that your driver's version is supported by the nv-codec-headers version you are installing.
-  To install it, clone the repo, checkout to wanted version, and `sudo make install`.
-
-> Currently, only ffmpeg n7.0 and n7.1 are supported.
-
-##### nvenc
-
-Requires ffmpeg build with `--enable-nonfree --enable-nvenc`.
-
-##### x264
-
-Requires ffmpeg build with `--enable-libx264 --enable-gpl`.
 
 #### Audio Codecs
 

go.mod

@@ -10,9 +10,9 @@ require (
 	github.com/pion/interceptor v0.1.40
 	github.com/pion/logging v0.2.4
 	github.com/pion/rtcp v1.2.15
-	github.com/pion/rtp v1.8.19
+	github.com/pion/rtp v1.8.22
 	github.com/pion/webrtc/v4 v4.1.2
-	github.com/stretchr/testify v1.10.0
+	github.com/stretchr/testify v1.11.1
 	golang.org/x/image v0.23.0
 )
 

go.sum

@@ -38,8 +38,8 @@ github.com/pion/randutil v0.1.0 h1:CFG1UdESneORglEsnimhUjf33Rwjubwj6xfiOXBa3mA=
 github.com/pion/randutil v0.1.0/go.mod h1:XcJrSMMbbMRhASFVOlj/5hQial/Y8oH/HVo7TBZq+j8=
 github.com/pion/rtcp v1.2.15 h1:LZQi2JbdipLOj4eBjK4wlVoQWfrZbh3Q6eHtWtJBZBo=
 github.com/pion/rtcp v1.2.15/go.mod h1:jlGuAjHMEXwMUHK78RgX0UmEJFV4zUKOFHR7OP+D3D0=
-github.com/pion/rtp v1.8.19 h1:jhdO/3XhL/aKm/wARFVmvTfq0lC/CvN1xwYKmduly3c=
-github.com/pion/rtp v1.8.19/go.mod h1:bAu2UFKScgzyFqvUKmbvzSdPr+NGbZtv6UB2hesqXBk=
+github.com/pion/rtp v1.8.22 h1:8NCVDDF+uSJmMUkjLJVnIr/HX7gPesyMV1xFt5xozXc=
+github.com/pion/rtp v1.8.22/go.mod h1:rF5nS1GqbR7H/TCpKwylzeq6yDM+MM6k+On5EgeThEM=
 github.com/pion/sctp v1.8.39 h1:PJma40vRHa3UTO3C4MyeJDQ+KIobVYRZQZ0Nt7SjQnE=
 github.com/pion/sctp v1.8.39/go.mod h1:cNiLdchXra8fHQwmIoqw0MbLLMs+f7uQ+dGMG2gWebE=
 github.com/pion/sdp/v3 v3.0.13 h1:uN3SS2b+QDZnWXgdr69SM8KB4EbcnPnPf2Laxhty/l4=
@@ -56,8 +56,8 @@ github.com/pion/webrtc/v4 v4.1.2 h1:mpuUo/EJ1zMNKGE79fAdYNFZBX790KE7kQQpLMjjR54=
 github.com/pion/webrtc/v4 v4.1.2/go.mod h1:xsCXiNAmMEjIdFxAYU0MbB3RwRieJsegSB2JZsGN+8U=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 github.com/wlynxg/anet v0.0.5 h1:J3VJGi1gvo0JwZ/P1/Yc/8p63SoW98B5dHkYDmpgvvU=
 github.com/wlynxg/anet v0.0.5/go.mod h1:eay5PRQr7fIVAMbTbchTnO9gG65Hg/uYGdc7mguHxoA=
 golang.org/x/crypto v0.33.0 h1:IOBPskki6Lysi0lo9qQvbxiQ+FvsCC/YWOecCHAixus=

mediastream_test.go

@@ -2,6 +2,7 @@ package mediadevices
 
 import (
 	"io"
+	"slices"
 	"testing"
 
 	"github.com/pion/mediadevices/pkg/codec"
@@ -93,13 +94,7 @@ func TestMediaStreamFilters(t *testing.T) {
 		}
 
 		for _, a := range actual {
-			found := false
-			for _, e := range expected {
-				if e == a {
-					found = true
-					break
-				}
-			}
+			found := slices.Contains(expected, a)
 
 			if !found {
 				t.Fatalf("%s: Expected to find %p in the query results", t.Name(), a)

pkg/codec/bitrate_tracker.go

@@ -0,0 +1,48 @@
+package codec
+
+import (
+	"time"
+)
+
+type BitrateTracker struct {
+	windowSize time.Duration
+	buffer     []int
+	times      []time.Time
+}
+
+func NewBitrateTracker(windowSize time.Duration) *BitrateTracker {
+	return &BitrateTracker{
+		windowSize: windowSize,
+	}
+}
+
+func (bt *BitrateTracker) AddFrame(sizeBytes int, timestamp time.Time) {
+	bt.buffer = append(bt.buffer, sizeBytes)
+	bt.times = append(bt.times, timestamp)
+
+	// Remove old entries outside the window
+	cutoff := timestamp.Add(-bt.windowSize)
+	i := 0
+	for ; i < len(bt.times); i++ {
+		if bt.times[i].After(cutoff) {
+			break
+		}
+	}
+	bt.buffer = bt.buffer[i:]
+	bt.times = bt.times[i:]
+}
+
+func (bt *BitrateTracker) GetBitrate() float64 {
+	if len(bt.times) < 2 {
+		return 0
+	}
+	totalBytes := 0
+	for _, b := range bt.buffer {
+		totalBytes += b
+	}
+	duration := bt.times[len(bt.times)-1].Sub(bt.times[0]).Seconds()
+	if duration <= 0 {
+		return 0
+	}
+	return float64(totalBytes*8) / duration // bits per second
+}

pkg/codec/bitrate_tracker_test.go

@@ -0,0 +1,19 @@
+package codec
+
+import (
+	"math"
+	"testing"
+	"time"
+)
+
+func TestBitrateTracker(t *testing.T) {
+	packetSize := 1000
+	bt := NewBitrateTracker(time.Second)
+	bt.AddFrame(packetSize, time.Now())
+	bt.AddFrame(packetSize, time.Now().Add(time.Millisecond*100))
+	bt.AddFrame(packetSize, time.Now().Add(time.Millisecond*999))
+	eps := float64(packetSize*8) / 10
+	if got, want := bt.GetBitrate(), float64(packetSize*8)*3; math.Abs(got-want) > eps {
+		t.Fatalf("GetBitrate() = %v, want %v (|diff| <= %v)", got, want, eps)
+	}
+}

pkg/codec/codec.go

@@ -1,6 +1,8 @@
 package codec
 
 import (
+	"image"
+	"io"
 	"time"
 
 	"github.com/pion/mediadevices/pkg/io/audio"
@@ -153,10 +155,19 @@ type ReadCloser interface {
 	Controllable
 }
 
+type VideoDecoderBuilder interface {
+	BuildVideoDecoder(r io.Reader, p prop.Media) (VideoDecoder, error)
+}
+
+type VideoDecoder interface {
+	Read() (image.Image, func(), error)
+	Close() error
+}
+
 // EncoderController is the interface allowing to control the encoder behaviour after it's initialisation.
 // It will possibly have common control method in the future.
 // A controller can have optional methods represented by *Controller interfaces
-type EncoderController interface{}
+type EncoderController any
 
 // Controllable is a interface representing a encoder which can be controlled
 // after it's initialisation with an EncoderController
@@ -179,6 +190,12 @@ type BitRateController interface {
 	SetBitRate(int) error
 }
 
+type QPController interface {
+	EncoderController
+	// DynamicQPControl adjusts the QP of the encoder based on the current and target bitrate
+	DynamicQPControl(currentBitrate int, targetBitrate int) error
+}
+
 // BaseParams represents an codec's encoding properties
 type BaseParams struct {
 	// Target bitrate in bps.

pkg/codec/ffmpeg/.gitignore

@@ -1 +0,0 @@
-tmp

pkg/codec/ffmpeg/Makefile

@@ -1,41 +0,0 @@
-version=n7.0
-srcPath=tmp/$(version)/src
-installPath=tmp/$(version)
-CGO_CFLAGS := -I$(CURDIR)/$(installPath)/include/
-CGO_LDFLAGS := -L$(CURDIR)/$(installPath)/lib/
-PKG_CONFIG_PATH := $(CURDIR)/$(installPath)/lib/pkgconfig
-configure := --enable-libx264 --enable-gpl
-
-# Main test target - depends on FFmpeg being built
-test: $(installPath)/lib/libavcodec.a
-	PKG_CONFIG_PATH=$(PKG_CONFIG_PATH) CGO_CFLAGS="$(CGO_CFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" go test -v .
-
-# Separate target for building FFmpeg (used by CI when cache miss)
-build-ffmpeg: $(installPath)/lib/libavcodec.a
-	@echo "FFmpeg build completed"
-
-# Clean incomplete builds before starting
-clean-incomplete:
-	@if [ -d "$(srcPath)" ] && [ ! -f "$(installPath)/lib/libavcodec.a" ]; then \
-		echo "Cleaning incomplete build..."; \
-		rm -rf $(srcPath); \
-	fi
-
-# FFmpeg build rule
-$(installPath)/lib/libavcodec.a: clean-incomplete $(srcPath)/Makefile
-	cd $(srcPath) && make -j4
-	cd $(srcPath) && make install
-	@echo "Installation completed, checking results..."
-	@ls -la $(installPath)/lib/ || echo "lib directory not found"
-	@ls -la $(installPath)/include/ || echo "include directory not found"
-
-$(srcPath)/Makefile: $(srcPath)/.git
-	cd $(srcPath) && ./configure --prefix=$(CURDIR)/$(installPath) $(configure)
-
-$(srcPath)/.git:
-	rm -rf $(srcPath)
-	mkdir -p $(srcPath)
-	cd $(srcPath) && git clone https://github.com/FFmpeg/FFmpeg .
-	cd $(srcPath) && git checkout $(version)
-
-.PHONY: test build-ffmpeg clean-incomplete

pkg/codec/ffmpeg/errors.go

@@ -1,18 +0,0 @@
-package ffmpeg
-
-import (
-	"errors"
-)
-
-var (
-	errFailedToCreateHwDevice    = errors.New("ffmpeg: failed to create device")
-	errCodecNotFound             = errors.New("ffmpeg: codec not found")
-	errFailedToCreateCodecCtx    = errors.New("ffmpeg: failed to allocate codec context")
-	errFailedToCreateHwFramesCtx = errors.New("ffmpeg: failed to create hardware frames context")
-	errFailedToInitHwFramesCtx   = errors.New("ffmpeg: failed to initialize hardware frames context")
-	errFailedToOpenCodecCtx      = errors.New("ffmpeg: failed to open codec context")
-	errFailedToAllocFrame        = errors.New("ffmpeg: failed to allocate frame")
-	errFailedToAllocSwBuf        = errors.New("ffmpeg: failed to allocate software buffer")
-	errFailedToAllocHwBuf        = errors.New("ffmpeg: failed to allocate hardware buffer")
-	errFailedToAllocPacket       = errors.New("ffmpeg: failed to allocate packet")
-)

pkg/codec/ffmpeg/ffmpeg.go

@@ -1,439 +0,0 @@
-// Package ffmpeg brings libavcodec's encoding capabilities to mediadevices.
-// This package requires ffmpeg headers and libraries to be built.
-// For more information, see https://github.com/asticode/go-astiav?tab=readme-ov-file#install-ffmpeg-from-source.
-//
-// Currently, only nvenc, x264, vaapi are implemented, but extending this to other ffmpeg supported codecs should
-// be simple.
-package ffmpeg
-
-import (
-	"errors"
-	"io"
-	"sync"
-
-	"github.com/asticode/go-astiav"
-	"github.com/pion/mediadevices/pkg/codec"
-	"github.com/pion/mediadevices/pkg/io/video"
-	"github.com/pion/mediadevices/pkg/prop"
-)
-
-type baseEncoder struct {
-	codecCtx       *astiav.CodecContext
-	frame          *astiav.Frame
-	packet         *astiav.Packet
-	width          int
-	height         int
-	r              video.Reader
-	nextIsKeyFrame bool
-	mu             sync.Mutex
-	closed         bool
-}
-
-type hardwareEncoder struct {
-	baseEncoder
-
-	hwFramesCtx *astiav.HardwareFramesContext
-	hwFrame     *astiav.Frame
-}
-
-type softwareEncoder struct {
-	baseEncoder
-}
-
-func newHardwareEncoder(r video.Reader, p prop.Media, params Params) (*hardwareEncoder, error) {
-	if p.FrameRate == 0 {
-		p.FrameRate = params.FrameRate
-	}
-	astiav.SetLogLevel(astiav.LogLevel(astiav.LogLevelWarning))
-
-	var hardwareDeviceType astiav.HardwareDeviceType
-	switch params.codecName {
-	case "h264_nvenc", "hevc_nvenc", "av1_nvenc":
-		hardwareDeviceType = astiav.HardwareDeviceType(astiav.HardwareDeviceTypeCUDA)
-	case "vp8_vaapi", "vp9_vaapi", "h264_vaapi", "hevc_vaapi":
-		hardwareDeviceType = astiav.HardwareDeviceType(astiav.HardwareDeviceTypeVAAPI)
-	}
-
-	hwDevice, err := astiav.CreateHardwareDeviceContext(
-		hardwareDeviceType,
-		params.hardwareDevice,
-		nil,
-		0,
-	)
-	if err != nil {
-		return nil, errFailedToCreateHwDevice
-	}
-
-	codec := astiav.FindEncoderByName(params.codecName)
-	if codec == nil {
-		return nil, errCodecNotFound
-	}
-
-	codecCtx := astiav.AllocCodecContext(codec)
-	if codecCtx == nil {
-		return nil, errFailedToCreateCodecCtx
-	}
-
-	// Configure codec context
-	codecCtx.SetWidth(p.Width)
-	codecCtx.SetHeight(p.Height)
-	codecCtx.SetTimeBase(astiav.NewRational(1, int(p.FrameRate)))
-	codecCtx.SetFramerate(codecCtx.TimeBase().Invert())
-	codecCtx.SetBitRate(int64(params.BitRate))
-	codecCtx.SetRateControlMaxRate(int64(params.BitRate + params.BitRate/10))
-	codecCtx.SetRateControlMinRate(int64(params.BitRate - params.BitRate/10))
-	codecCtx.SetGopSize(params.KeyFrameInterval)
-	codecCtx.SetMaxBFrames(0)
-	switch params.codecName {
-	case "h264_nvenc", "hevc_nvenc", "av1_nvenc":
-		codecCtx.SetPixelFormat(astiav.PixelFormat(astiav.PixelFormatCuda))
-	case "vp8_vaapi", "vp9_vaapi", "h264_vaapi", "hevc_vaapi":
-		codecCtx.SetPixelFormat(astiav.PixelFormat(astiav.PixelFormatVaapi))
-	}
-	codecOptions := codecCtx.PrivateData().Options()
-	switch params.codecName {
-	case "av1_nvenc":
-		codecCtx.SetProfile(astiav.Profile(astiav.ProfileAv1Main))
-		codecOptions.Set("tier", "0", 0)
-	case "h264_vaapi":
-		codecCtx.SetProfile(astiav.Profile(astiav.ProfileH264Main))
-		codecOptions.Set("profile", "main", 0)
-		codecOptions.Set("level", "1", 0)
-	case "hevc_vaapi":
-		codecCtx.SetProfile(astiav.Profile(astiav.ProfileHevcMain))
-		codecOptions.Set("profile", "main", 0)
-		codecOptions.Set("tier", "main", 0)
-		codecOptions.Set("level", "1", 0)
-	}
-	switch params.codecName {
-	case "h264_nvenc", "hevc_nvenc", "av1_nvenc":
-		codecOptions.Set("forced-idr", "1", 0)
-		codecOptions.Set("zerolatency", "1", 0)
-		codecOptions.Set("intra-refresh", "1", 0)
-		codecOptions.Set("delay", "0", 0)
-		codecOptions.Set("tune", "ll", 0)
-		codecOptions.Set("preset", "p1", 0)
-		codecOptions.Set("rc", "vbr", 0)
-	case "vp8_vaapi", "vp9_vaapi", "h264_vaapi", "hevc_vaapi":
-		codecOptions.Set("rc_mode", "CBR", 0)
-	}
-
-	// Create hardware frames context
-	hwFramesCtx := astiav.AllocHardwareFramesContext(hwDevice)
-	hwDevice.Free()
-	if hwFramesCtx == nil {
-		codecCtx.Free()
-		return nil, errFailedToCreateHwFramesCtx
-	}
-
-	// Set hardware frames context parameters
-	hwFramesCtx.SetWidth(p.Width)
-	hwFramesCtx.SetHeight(p.Height)
-	switch params.codecName {
-	case "h264_nvenc", "hevc_nvenc", "av1_nvenc":
-		hwFramesCtx.SetHardwarePixelFormat(astiav.PixelFormat(astiav.PixelFormatCuda))
-	case "vp8_vaapi", "vp9_vaapi", "h264_vaapi", "hevc_vaapi":
-		hwFramesCtx.SetHardwarePixelFormat(astiav.PixelFormat(astiav.PixelFormatVaapi))
-	}
-	hwFramesCtx.SetSoftwarePixelFormat(params.pixelFormat)
-
-	if err = hwFramesCtx.Initialize(); err != nil {
-		codecCtx.Free()
-		hwFramesCtx.Free()
-		return nil, errFailedToInitHwFramesCtx
-	}
-	codecCtx.SetHardwareFramesContext(hwFramesCtx)
-
-	// Open codec context
-	if err = codecCtx.Open(codec, nil); err != nil {
-		codecCtx.Free()
-		hwFramesCtx.Free()
-		return nil, errFailedToOpenCodecCtx
-	}
-
-	softwareFrame := astiav.AllocFrame()
-	if softwareFrame == nil {
-		codecCtx.Free()
-		hwFramesCtx.Free()
-		return nil, errFailedToAllocFrame
-	}
-
-	softwareFrame.SetWidth(p.Width)
-	softwareFrame.SetHeight(p.Height)
-	softwareFrame.SetPixelFormat(params.pixelFormat)
-
-	if err = softwareFrame.AllocBuffer(0); err != nil {
-		softwareFrame.Free()
-		codecCtx.Free()
-		hwFramesCtx.Free()
-		return nil, errFailedToAllocSwBuf
-	}
-
-	hardwareFrame := astiav.AllocFrame()
-
-	if err = hardwareFrame.AllocHardwareBuffer(hwFramesCtx); err != nil {
-		softwareFrame.Free()
-		hardwareFrame.Free()
-		codecCtx.Free()
-		hwFramesCtx.Free()
-		return nil, errFailedToAllocHwBuf
-	}
-
-	packet := astiav.AllocPacket()
-	if packet == nil {
-		softwareFrame.Free()
-		hardwareFrame.Free()
-		codecCtx.Free()
-		hwFramesCtx.Free()
-		return nil, errFailedToAllocPacket
-	}
-
-	return &hardwareEncoder{
-		baseEncoder: baseEncoder{
-			codecCtx:       codecCtx,
-			frame:          softwareFrame,
-			packet:         packet,
-			width:          p.Width,
-			height:         p.Height,
-			r:              r,
-			nextIsKeyFrame: false,
-		},
-		hwFramesCtx: hwFramesCtx,
-		hwFrame:     hardwareFrame,
-	}, nil
-}
-
-func (e *hardwareEncoder) Controller() codec.EncoderController {
-	return e
-}
-
-func (e *hardwareEncoder) Read() ([]byte, func(), error) {
-	e.mu.Lock()
-	defer e.mu.Unlock()
-
-	if e.closed {
-		return nil, func() {}, io.EOF
-	}
-
-	img, release, err := e.r.Read()
-	if err != nil {
-		return nil, func() {}, err
-	}
-	defer release()
-
-	if e.nextIsKeyFrame {
-		e.frame.SetPictureType(astiav.PictureType(astiav.PictureTypeI))
-		e.hwFrame.SetPictureType(astiav.PictureType(astiav.PictureTypeI))
-		e.nextIsKeyFrame = false
-	} else {
-		e.frame.SetPictureType(astiav.PictureType(astiav.PictureTypeNone))
-		e.hwFrame.SetPictureType(astiav.PictureType(astiav.PictureTypeNone))
-	}
-
-	if err = e.frame.Data().FromImage(img); err != nil {
-		return nil, func() {}, err
-	}
-	if err = e.frame.TransferHardwareData(e.hwFrame); err != nil {
-		return nil, func() {}, err
-	}
-	if err = e.codecCtx.SendFrame(e.hwFrame); err != nil {
-		return nil, func() {}, err
-	}
-
-	if err = e.codecCtx.ReceivePacket(e.packet); err != nil {
-		return nil, func() {}, err
-	}
-
-	data := make([]byte, e.packet.Size())
-	copy(data, e.packet.Data())
-	e.packet.Unref()
-
-	return data, func() {}, nil
-}
-
-// ForceKeyFrame forces the next frame to be encoded as a keyframe
-func (e *hardwareEncoder) ForceKeyFrame() error {
-	e.mu.Lock()
-	defer e.mu.Unlock()
-	e.nextIsKeyFrame = true
-	return nil
-}
-
-func (e *hardwareEncoder) SetBitRate(bitrate int) error {
-	e.mu.Lock()
-	defer e.mu.Unlock()
-	e.codecCtx.SetBitRate(int64(bitrate))
-	e.codecCtx.SetRateControlMaxRate(int64(bitrate + bitrate/10))
-	e.codecCtx.SetRateControlMinRate(int64(bitrate - bitrate/10))
-	return nil
-}
-
-func (e *hardwareEncoder) Close() error {
-	e.mu.Lock()
-	defer e.mu.Unlock()
-
-	if e.packet != nil {
-		e.packet.Free()
-	}
-	if e.frame != nil {
-		e.frame.Free()
-	}
-	if e.hwFrame != nil {
-		e.hwFrame.Free()
-	}
-	if e.codecCtx != nil {
-		e.codecCtx.Free()
-	}
-	if e.hwFramesCtx != nil {
-		e.hwFramesCtx.Free()
-	}
-
-	e.closed = true
-	return nil
-}
-
-func newSoftwareEncoder(r video.Reader, p prop.Media, params Params) (*softwareEncoder, error) {
-	if p.FrameRate == 0 {
-		p.FrameRate = params.FrameRate
-	}
-	astiav.SetLogLevel(astiav.LogLevel(astiav.LogLevelWarning))
-
-	codec := astiav.FindEncoderByName(params.codecName)
-	if codec == nil {
-		return nil, errCodecNotFound
-	}
-
-	codecCtx := astiav.AllocCodecContext(codec)
-	if codecCtx == nil {
-		return nil, errFailedToCreateCodecCtx
-	}
-
-	// Configure codec context
-	codecCtx.SetWidth(p.Width)
-	codecCtx.SetHeight(p.Height)
-	codecCtx.SetTimeBase(astiav.NewRational(1, int(p.FrameRate)))
-	codecCtx.SetFramerate(codecCtx.TimeBase().Invert())
-	codecCtx.SetPixelFormat(astiav.PixelFormat(astiav.PixelFormatYuv420P))
-	codecCtx.SetBitRate(int64(params.BitRate))
-	codecCtx.SetGopSize(params.KeyFrameInterval)
-	codecCtx.SetMaxBFrames(0)
-	codecOptions := codecCtx.PrivateData().Options()
-	codecOptions.Set("preset", "ultrafast", 0)
-	codecOptions.Set("tune", "zerolatency", 0)
-	codecCtx.SetFlags(astiav.CodecContextFlags(astiav.CodecContextFlagLowDelay))
-
-	// Open codec context
-	if err := codecCtx.Open(codec, nil); err != nil {
-		codecCtx.Free()
-		return nil, errFailedToOpenCodecCtx
-	}
-
-	softwareFrame := astiav.AllocFrame()
-	if softwareFrame == nil {
-		codecCtx.Free()
-		return nil, errFailedToAllocFrame
-	}
-
-	softwareFrame.SetWidth(p.Width)
-	softwareFrame.SetHeight(p.Height)
-	softwareFrame.SetPixelFormat(astiav.PixelFormat(astiav.PixelFormatYuv420P))
-
-	if err := softwareFrame.AllocBuffer(0); err != nil {
-		softwareFrame.Free()
-		codecCtx.Free()
-		return nil, errFailedToAllocSwBuf
-	}
-
-	packet := astiav.AllocPacket()
-	if packet == nil {
-		softwareFrame.Free()
-		codecCtx.Free()
-		return nil, errFailedToAllocPacket
-	}
-
-	return &softwareEncoder{
-		baseEncoder: baseEncoder{
-			codecCtx:       codecCtx,
-			frame:          softwareFrame,
-			packet:         packet,
-			width:          p.Width,
-			height:         p.Height,
-			r:              video.ToI420(r),
-			nextIsKeyFrame: false,
-		},
-	}, nil
-}
-
-func (e *softwareEncoder) Read() ([]byte, func(), error) {
-	e.mu.Lock()
-	defer e.mu.Unlock()
-	if e.closed {
-		return nil, func() {}, io.EOF
-	}
-	img, release, err := e.r.Read()
-	if err != nil {
-		return nil, func() {}, err
-	}
-	defer release()
-	if e.nextIsKeyFrame {
-		e.frame.SetPictureType(astiav.PictureType(astiav.PictureTypeI))
-		e.nextIsKeyFrame = false
-	} else {
-		e.frame.SetPictureType(astiav.PictureType(astiav.PictureTypeNone))
-	}
-	if err = e.frame.Data().FromImage(img); err != nil {
-		return nil, func() {}, err
-	}
-	if err = e.codecCtx.SendFrame(e.frame); err != nil {
-		return nil, func() {}, err
-	}
-	for {
-		if err = e.codecCtx.ReceivePacket(e.packet); err != nil {
-			if errors.Is(err, astiav.ErrEof) || errors.Is(err, astiav.ErrEagain) {
-				continue
-			}
-			return nil, func() {}, err
-		}
-		break
-	}
-	data := make([]byte, e.packet.Size())
-	copy(data, e.packet.Data())
-	e.packet.Unref()
-	return data, func() {}, nil
-}
-
-func (e *softwareEncoder) Controller() codec.EncoderController {
-	return e
-}
-
-func (e *softwareEncoder) ForceKeyFrame() error {
-	e.mu.Lock()
-	defer e.mu.Unlock()
-	e.nextIsKeyFrame = true
-	return nil
-}
-
-func (e *softwareEncoder) SetBitRate(bitrate int) error {
-	e.mu.Lock()
-	defer e.mu.Unlock()
-	e.codecCtx.SetBitRate(int64(bitrate))
-	return nil
-}
-
-func (e *softwareEncoder) Close() error {
-	e.mu.Lock()
-	defer e.mu.Unlock()
-
-	if e.packet != nil {
-		e.packet.Free()
-	}
-	if e.frame != nil {
-		e.frame.Free()
-	}
-	if e.codecCtx != nil {
-		e.codecCtx.Free()
-	}
-
-	e.closed = true
-	return nil
-}

pkg/codec/ffmpeg/ffmpeg_test.go

@@ -1,357 +0,0 @@
-package ffmpeg
-
-import (
-	"context"
-	"image"
-	"io"
-	"sync/atomic"
-	"testing"
-	"time"
-
-	"github.com/pion/mediadevices/pkg/codec"
-	"github.com/pion/mediadevices/pkg/codec/internal/codectest"
-	"github.com/pion/mediadevices/pkg/frame"
-	"github.com/pion/mediadevices/pkg/io/video"
-	"github.com/pion/mediadevices/pkg/prop"
-)
-
-func TestEncoder(t *testing.T) {
-	for name, factory := range map[string]func() (codec.VideoEncoderBuilder, error){
-		"x264": func() (codec.VideoEncoderBuilder, error) {
-			p, err := NewH264X264Params()
-			p.FrameRate = 30
-			p.BitRate = 1000000
-			p.KeyFrameInterval = 60
-			return &p, err
-		},
-	} {
-		factory := factory
-		t.Run(name, func(t *testing.T) {
-			t.Run("SimpleRead", func(t *testing.T) {
-				p, err := factory()
-				if err != nil {
-					t.Fatal(err)
-				}
-				codectest.VideoEncoderSimpleReadTest(t, p,
-					prop.Media{
-						Video: prop.Video{
-							Width:       256,
-							Height:      144,
-							FrameFormat: frame.FormatI420,
-						},
-					},
-					image.NewYCbCr(
-						image.Rect(0, 0, 256, 144),
-						image.YCbCrSubsampleRatio420,
-					),
-				)
-			})
-			t.Run("CloseTwice", func(t *testing.T) {
-				p, err := factory()
-				if err != nil {
-					t.Fatal(err)
-				}
-				codectest.VideoEncoderCloseTwiceTest(t, p, prop.Media{
-					Video: prop.Video{
-						Width:       640,
-						Height:      480,
-						FrameRate:   30,
-						FrameFormat: frame.FormatI420,
-					},
-				})
-			})
-			t.Run("ReadAfterClose", func(t *testing.T) {
-				p, err := factory()
-				if err != nil {
-					t.Fatal(err)
-				}
-				codectest.VideoEncoderReadAfterCloseTest(t, p,
-					prop.Media{
-						Video: prop.Video{
-							Width:       256,
-							Height:      144,
-							FrameFormat: frame.FormatI420,
-						},
-					},
-					image.NewYCbCr(
-						image.Rect(0, 0, 256, 144),
-						image.YCbCrSubsampleRatio420,
-					),
-				)
-			})
-		})
-	}
-}
-
-func TestImageSizeChange(t *testing.T) {
-	t.Skip("Changing image size on the fly is currently not supported")
-
-	for name, factory := range map[string]func() (codec.VideoEncoderBuilder, error){
-		"x264": func() (codec.VideoEncoderBuilder, error) {
-			p, err := NewH264X264Params()
-			p.FrameRate = 30
-			p.BitRate = 1000000
-			p.KeyFrameInterval = 60
-			return &p, err
-		},
-	} {
-		factory := factory
-		t.Run(name, func(t *testing.T) {
-			param, err := factory()
-			if err != nil {
-				t.Fatal(err)
-			}
-
-			for name, testCase := range map[string]struct {
-				initialWidth, initialHeight int
-				width, height               int
-			}{
-				"NoChange": {
-					320, 240,
-					320, 240,
-				},
-				"Enlarge": {
-					320, 240,
-					640, 480,
-				},
-				"Shrink": {
-					640, 480,
-					320, 240,
-				},
-			} {
-				testCase := testCase
-				t.Run(name, func(t *testing.T) {
-					var cnt uint32
-					r, err := param.BuildVideoEncoder(
-						video.ReaderFunc(func() (image.Image, func(), error) {
-							i := atomic.AddUint32(&cnt, 1)
-							if i == 1 {
-								return image.NewYCbCr(
-									image.Rect(0, 0, testCase.width, testCase.height),
-									image.YCbCrSubsampleRatio420,
-								), func() {}, nil
-							}
-							return nil, nil, io.EOF
-						}),
-						prop.Media{
-							Video: prop.Video{
-								Width:       testCase.initialWidth,
-								Height:      testCase.initialHeight,
-								FrameRate:   1,
-								FrameFormat: frame.FormatI420,
-							},
-						},
-					)
-					if err != nil {
-						t.Fatal(err)
-					}
-					_, rel, err := r.Read()
-					if err != nil {
-						t.Fatal(err)
-					}
-					rel()
-					_, _, err = r.Read()
-					if err != io.EOF {
-						t.Fatal(err)
-					}
-				})
-			}
-		})
-	}
-}
-
-func TestRequestKeyFrame(t *testing.T) {
-	for name, factory := range map[string]func() (codec.VideoEncoderBuilder, error){
-		"x264": func() (codec.VideoEncoderBuilder, error) {
-			p, err := NewH264X264Params()
-			p.FrameRate = 30
-			p.BitRate = 1000000
-			p.KeyFrameInterval = 60
-			return &p, err
-		},
-	} {
-		factory := factory
-		t.Run(name, func(t *testing.T) {
-			param, err := factory()
-			if err != nil {
-				t.Fatal(err)
-			}
-
-			var initialWidth, initialHeight, width, height int = 320, 240, 320, 240
-
-			var cnt uint32
-			r, err := param.BuildVideoEncoder(
-				video.ReaderFunc(func() (image.Image, func(), error) {
-					i := atomic.AddUint32(&cnt, 1)
-					if i == 3 {
-						return nil, nil, io.EOF
-					}
-					return image.NewYCbCr(
-						image.Rect(0, 0, width, height),
-						image.YCbCrSubsampleRatio420,
-					), func() {}, nil
-				}),
-				prop.Media{
-					Video: prop.Video{
-						Width:       initialWidth,
-						Height:      initialHeight,
-						FrameRate:   1,
-						FrameFormat: frame.FormatI420,
-					},
-				},
-			)
-			if err != nil {
-				t.Fatal(err)
-			}
-			_, rel, err := r.Read()
-			if err != nil {
-				t.Fatal(err)
-			}
-			rel()
-			r.Controller().(codec.KeyFrameController).ForceKeyFrame()
-			_, rel, err = r.Read()
-			if err != nil {
-				t.Fatal(err)
-			}
-			// TODO: check if this is a key frame
-			// if !r.(*encoder).isKeyFrame {
-			// 	t.Fatal("Not a key frame")
-			// }
-			rel()
-			_, _, err = r.Read()
-			if err != io.EOF {
-				t.Fatal(err)
-			}
-		})
-
-	}
-}
-
-func TestSetBitrate(t *testing.T) {
-	for name, factory := range map[string]func() (codec.VideoEncoderBuilder, error){
-		"x264": func() (codec.VideoEncoderBuilder, error) {
-			p, err := NewH264X264Params()
-			p.FrameRate = 30
-			p.BitRate = 1000000
-			p.KeyFrameInterval = 60
-			return &p, err
-		},
-	} {
-		factory := factory
-		t.Run(name, func(t *testing.T) {
-			param, err := factory()
-			if err != nil {
-				t.Fatal(err)
-			}
-
-			var initialWidth, initialHeight, width, height int = 320, 240, 320, 240
-
-			var cnt uint32
-			r, err := param.BuildVideoEncoder(
-				video.ReaderFunc(func() (image.Image, func(), error) {
-					i := atomic.AddUint32(&cnt, 1)
-					if i == 3 {
-						return nil, nil, io.EOF
-					}
-					return image.NewYCbCr(
-						image.Rect(0, 0, width, height),
-						image.YCbCrSubsampleRatio420,
-					), func() {}, nil
-				}),
-				prop.Media{
-					Video: prop.Video{
-						Width:       initialWidth,
-						Height:      initialHeight,
-						FrameRate:   1,
-						FrameFormat: frame.FormatI420,
-					},
-				},
-			)
-			if err != nil {
-				t.Fatal(err)
-			}
-			_, rel, err := r.Read()
-			if err != nil {
-				t.Fatal(err)
-			}
-			rel()
-			err = r.Controller().(codec.BitRateController).SetBitRate(1000) // 1000 bit/second is ridiculously low, but this is a testcase.
-			if err != nil {
-				t.Fatal(err)
-			}
-			_, rel, err = r.Read()
-			if err != nil {
-				t.Fatal(err)
-			}
-			rel()
-			_, _, err = r.Read()
-			if err != io.EOF {
-				t.Fatal(err)
-			}
-		})
-
-	}
-}
-
-func TestShouldImplementBitRateControl(t *testing.T) {
-	e := &softwareEncoder{}
-	if _, ok := e.Controller().(codec.BitRateController); !ok {
-		t.Error()
-	}
-}
-
-func TestShouldImplementKeyFrameControl(t *testing.T) {
-	e := &softwareEncoder{}
-	if _, ok := e.Controller().(codec.KeyFrameController); !ok {
-		t.Error()
-	}
-}
-
-func TestEncoderFrameMonotonic(t *testing.T) {
-	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-	defer cancel()
-
-	params, err := NewH264X264Params()
-	params.FrameRate = 30
-	params.BitRate = 1000000
-	params.KeyFrameInterval = 60
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	encoder, err := params.BuildVideoEncoder(
-		video.ReaderFunc(func() (image.Image, func(), error) {
-			return image.NewYCbCr(
-				image.Rect(0, 0, 320, 240),
-				image.YCbCrSubsampleRatio420,
-			), func() {}, nil
-		},
-		), prop.Media{
-			Video: prop.Video{
-				Width:       320,
-				Height:      240,
-				FrameRate:   30,
-				FrameFormat: frame.FormatI420,
-			},
-		})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	ticker := time.NewTicker(33 * time.Millisecond)
-	defer ticker.Stop()
-	ctxx, cancell := context.WithCancel(ctx)
-	defer cancell()
-	for {
-		select {
-		case <-ctxx.Done():
-			return
-		case <-ticker.C:
-			_, rel, err := encoder.Read()
-			if err != nil {
-				t.Fatal(err)
-			}
-			rel()
-		}
-	}
-}

pkg/codec/ffmpeg/go.mod

@@ -1,36 +0,0 @@
-module github.com/pion/mediadevices/pkg/codec/ffmpeg
-
-go 1.21
-
-replace github.com/pion/mediadevices => ../../../
-
-require (
-	github.com/asticode/go-astiav v0.35.1
-	github.com/pion/mediadevices v0.7.1
-)
-
-require (
-	github.com/asticode/go-astikit v0.42.0 // indirect
-	github.com/google/uuid v1.6.0 // indirect
-	github.com/pion/datachannel v1.5.10 // indirect
-	github.com/pion/dtls/v3 v3.0.6 // indirect
-	github.com/pion/ice/v4 v4.0.10 // indirect
-	github.com/pion/interceptor v0.1.37 // indirect
-	github.com/pion/logging v0.2.3 // indirect
-	github.com/pion/mdns/v2 v2.0.7 // indirect
-	github.com/pion/randutil v0.1.0 // indirect
-	github.com/pion/rtcp v1.2.15 // indirect
-	github.com/pion/rtp v1.8.15 // indirect
-	github.com/pion/sctp v1.8.39 // indirect
-	github.com/pion/sdp/v3 v3.0.11 // indirect
-	github.com/pion/srtp/v3 v3.0.4 // indirect
-	github.com/pion/stun/v3 v3.0.0 // indirect
-	github.com/pion/transport/v3 v3.0.7 // indirect
-	github.com/pion/turn/v4 v4.0.0 // indirect
-	github.com/pion/webrtc/v4 v4.1.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
-	golang.org/x/sys v0.30.0 // indirect
-)

pkg/codec/ffmpeg/go.sum

@@ -1,56 +0,0 @@
-github.com/asticode/go-astiav v0.35.1 h1:jq27Ihf+GXtOTnhzNTcpKrW1iLNRAuPSoarh7/SapYc=
-github.com/asticode/go-astiav v0.35.1/go.mod h1:K7D8UC6GeQt85FUxk2KVwYxHnotrxuEnp5evkkudc2s=
-github.com/asticode/go-astikit v0.42.0 h1:pnir/2KLUSr0527Tv908iAH6EGYYrYta132vvjXsH5w=
-github.com/asticode/go-astikit v0.42.0/go.mod h1:h4ly7idim1tNhaVkdVBeXQZEE3L0xblP7fCWbgwipF0=
-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=
-github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/pion/datachannel v1.5.10 h1:ly0Q26K1i6ZkGf42W7D4hQYR90pZwzFOjTq5AuCKk4o=
-github.com/pion/datachannel v1.5.10/go.mod h1:p/jJfC9arb29W7WrxyKbepTU20CFgyx5oLo8Rs4Py/M=
-github.com/pion/dtls/v3 v3.0.6 h1:7Hkd8WhAJNbRgq9RgdNh1aaWlZlGpYTzdqjy9x9sK2E=
-github.com/pion/dtls/v3 v3.0.6/go.mod h1:iJxNQ3Uhn1NZWOMWlLxEEHAN5yX7GyPvvKw04v9bzYU=
-github.com/pion/ice/v4 v4.0.10 h1:P59w1iauC/wPk9PdY8Vjl4fOFL5B+USq1+xbDcN6gT4=
-github.com/pion/ice/v4 v4.0.10/go.mod h1:y3M18aPhIxLlcO/4dn9X8LzLLSma84cx6emMSu14FGw=
-github.com/pion/interceptor v0.1.37 h1:aRA8Zpab/wE7/c0O3fh1PqY0AJI3fCSEM5lRWJVorwI=
-github.com/pion/interceptor v0.1.37/go.mod h1:JzxbJ4umVTlZAf+/utHzNesY8tmRkM2lVmkS82TTj8Y=
-github.com/pion/logging v0.2.3 h1:gHuf0zpoh1GW67Nr6Gj4cv5Z9ZscU7g/EaoC/Ke/igI=
-github.com/pion/logging v0.2.3/go.mod h1:z8YfknkquMe1csOrxK5kc+5/ZPAzMxbKLX5aXpbpC90=
-github.com/pion/mdns/v2 v2.0.7 h1:c9kM8ewCgjslaAmicYMFQIde2H9/lrZpjBkN8VwoVtM=
-github.com/pion/mdns/v2 v2.0.7/go.mod h1:vAdSYNAT0Jy3Ru0zl2YiW3Rm/fJCwIeM0nToenfOJKA=
-github.com/pion/randutil v0.1.0 h1:CFG1UdESneORglEsnimhUjf33Rwjubwj6xfiOXBa3mA=
-github.com/pion/randutil v0.1.0/go.mod h1:XcJrSMMbbMRhASFVOlj/5hQial/Y8oH/HVo7TBZq+j8=
-github.com/pion/rtcp v1.2.15 h1:LZQi2JbdipLOj4eBjK4wlVoQWfrZbh3Q6eHtWtJBZBo=
-github.com/pion/rtcp v1.2.15/go.mod h1:jlGuAjHMEXwMUHK78RgX0UmEJFV4zUKOFHR7OP+D3D0=
-github.com/pion/rtp v1.8.15 h1:MuhuGn1cxpVCPLNY1lI7F1tQ8Spntpgf12ob+pOYT8s=
-github.com/pion/rtp v1.8.15/go.mod h1:bAu2UFKScgzyFqvUKmbvzSdPr+NGbZtv6UB2hesqXBk=
-github.com/pion/sctp v1.8.39 h1:PJma40vRHa3UTO3C4MyeJDQ+KIobVYRZQZ0Nt7SjQnE=
-github.com/pion/sctp v1.8.39/go.mod h1:cNiLdchXra8fHQwmIoqw0MbLLMs+f7uQ+dGMG2gWebE=
-github.com/pion/sdp/v3 v3.0.11 h1:VhgVSopdsBKwhCFoyyPmT1fKMeV9nLMrEKxNOdy3IVI=
-github.com/pion/sdp/v3 v3.0.11/go.mod h1:88GMahN5xnScv1hIMTqLdu/cOcUkj6a9ytbncwMCq2E=
-github.com/pion/srtp/v3 v3.0.4 h1:2Z6vDVxzrX3UHEgrUyIGM4rRouoC7v+NiF1IHtp9B5M=
-github.com/pion/srtp/v3 v3.0.4/go.mod h1:1Jx3FwDoxpRaTh1oRV8A/6G1BnFL+QI82eK4ms8EEJQ=
-github.com/pion/stun/v3 v3.0.0 h1:4h1gwhWLWuZWOJIJR9s2ferRO+W3zA/b6ijOI6mKzUw=
-github.com/pion/stun/v3 v3.0.0/go.mod h1:HvCN8txt8mwi4FBvS3EmDghW6aQJ24T+y+1TKjB5jyU=
-github.com/pion/transport/v3 v3.0.7 h1:iRbMH05BzSNwhILHoBoAPxoB9xQgOaJk+591KC9P1o0=
-github.com/pion/transport/v3 v3.0.7/go.mod h1:YleKiTZ4vqNxVwh77Z0zytYi7rXHl7j6uPLGhhz9rwo=
-github.com/pion/turn/v4 v4.0.0 h1:qxplo3Rxa9Yg1xXDxxH8xaqcyGUtbHYw4QSCvmFWvhM=
-github.com/pion/turn/v4 v4.0.0/go.mod h1:MuPDkm15nYSklKpN8vWJ9W2M0PlyQZqYt1McGuxG7mA=
-github.com/pion/webrtc/v4 v4.1.0 h1:yq/p0G5nKGbHISf0YKNA8Yk+kmijbblBvuSLwaJ4QYg=
-github.com/pion/webrtc/v4 v4.1.0/go.mod h1:cgEGkcpxGkT6Di2ClBYO5lP9mFXbCfEOrkYUpjjCQO4=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
-github.com/wlynxg/anet v0.0.5 h1:J3VJGi1gvo0JwZ/P1/Yc/8p63SoW98B5dHkYDmpgvvU=
-github.com/wlynxg/anet v0.0.5/go.mod h1:eay5PRQr7fIVAMbTbchTnO9gG65Hg/uYGdc7mguHxoA=
-golang.org/x/crypto v0.33.0 h1:IOBPskki6Lysi0lo9qQvbxiQ+FvsCC/YWOecCHAixus=
-golang.org/x/crypto v0.33.0/go.mod h1:bVdXmD7IV/4GdElGPozy6U7lWdRXA4qyRVGJV57uQ5M=
-golang.org/x/image v0.23.0 h1:HseQ7c2OpPKTPVzNjG5fwJsOTCiiwS4QdsYi5XU6H68=
-golang.org/x/image v0.23.0/go.mod h1:wJJBTdLfCCf3tiHa1fNxpZmUI4mmoZvwMCPP0ddoNKY=
-golang.org/x/net v0.35.0 h1:T5GQRQb2y08kTAByq9L4/bz8cipCdA8FbRTXewonqY8=
-golang.org/x/net v0.35.0/go.mod h1:EglIi67kWsHKlRzzVMUD93VMSWGFOMSZgxFjparz1Qk=
-golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
-golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

pkg/codec/ffmpeg/params.go

@@ -1,191 +0,0 @@
-package ffmpeg
-
-import (
-	"github.com/asticode/go-astiav"
-	"github.com/pion/mediadevices/pkg/codec"
-	"github.com/pion/mediadevices/pkg/io/video"
-	"github.com/pion/mediadevices/pkg/prop"
-)
-
-type Params struct {
-	codec.BaseParams
-	codecName      string
-	hardwareDevice string
-	pixelFormat    astiav.PixelFormat
-	FrameRate      float32
-}
-
-type VP8Params struct {
-	Params
-}
-
-func NewVP8VAAPIParams(hardwareDevice string, pixelFormat astiav.PixelFormat) (VP8Params, error) {
-	return VP8Params{
-		Params: Params{
-			codecName:      "vp8_vaapi",
-			hardwareDevice: hardwareDevice,
-			pixelFormat:    pixelFormat,
-		},
-	}, nil
-}
-
-func (p *VP8Params) RTPCodec() *codec.RTPCodec {
-	return codec.NewRTPVP8Codec(90000)
-}
-
-func (p *VP8Params) BuildVideoEncoder(r video.Reader, property prop.Media) (codec.ReadCloser, error) {
-	readCloser, err := newHardwareEncoder(r, property, p.Params)
-	if err != nil {
-		return nil, err
-	}
-	return readCloser, nil
-}
-
-type VP9Params struct {
-	Params
-}
-
-func NewVP9VAAPIParams(hardwareDevice string, pixelFormat astiav.PixelFormat) (VP8Params, error) {
-	return VP8Params{
-		Params: Params{
-			codecName:      "vp9_vaapi",
-			hardwareDevice: hardwareDevice,
-			pixelFormat:    pixelFormat,
-		},
-	}, nil
-}
-
-func (p *VP9Params) RTPCodec() *codec.RTPCodec {
-	return codec.NewRTPVP9Codec(90000)
-}
-
-func (p *VP9Params) BuildVideoEncoder(r video.Reader, property prop.Media) (codec.ReadCloser, error) {
-	readCloser, err := newHardwareEncoder(r, property, p.Params)
-	if err != nil {
-		return nil, err
-	}
-	return readCloser, nil
-}
-
-type H264Params struct {
-	Params
-}
-
-func NewH264NVENCParams(hardwareDevice string, pixelFormat astiav.PixelFormat) (H264Params, error) {
-	return H264Params{
-		Params: Params{
-			codecName:      "h264_nvenc",
-			hardwareDevice: hardwareDevice,
-			pixelFormat:    pixelFormat,
-		},
-	}, nil
-}
-
-func NewH264VAAPIParams(hardwareDevice string, pixelFormat astiav.PixelFormat) (H264Params, error) {
-	return H264Params{
-		Params: Params{
-			codecName:      "h264_vaapi",
-			hardwareDevice: hardwareDevice,
-			pixelFormat:    pixelFormat,
-		},
-	}, nil
-}
-
-// RTPCodec represents the codec metadata
-func (p *H264Params) RTPCodec() *codec.RTPCodec {
-	return codec.NewRTPH264Codec(90000)
-}
-
-func (p *H264Params) BuildVideoEncoder(r video.Reader, property prop.Media) (codec.ReadCloser, error) {
-	readCloser, err := newHardwareEncoder(r, property, p.Params)
-	if err != nil {
-		return nil, err
-	}
-	return readCloser, nil
-}
-
-type H264SoftwareParams struct {
-	Params
-}
-
-func NewH264X264Params() (H264SoftwareParams, error) {
-	return H264SoftwareParams{
-		Params: Params{
-			codecName: "libx264",
-		},
-	}, nil
-}
-
-func (p *H264SoftwareParams) RTPCodec() *codec.RTPCodec {
-	return codec.NewRTPH264Codec(90000)
-}
-
-func (p *H264SoftwareParams) BuildVideoEncoder(r video.Reader, property prop.Media) (codec.ReadCloser, error) {
-	readCloser, err := newSoftwareEncoder(r, property, p.Params)
-	if err != nil {
-		return nil, err
-	}
-	return readCloser, nil
-}
-
-type H265Params struct {
-	Params
-}
-
-func NewH265NVENCParams(hardwareDevice string, pixelFormat astiav.PixelFormat) (H265Params, error) {
-	return H265Params{
-		Params: Params{
-			codecName:      "hevc_nvenc",
-			hardwareDevice: hardwareDevice,
-			pixelFormat:    pixelFormat,
-		},
-	}, nil
-}
-
-func NewH265VAAPIParams(hardwareDevice string, pixelFormat astiav.PixelFormat) (H265Params, error) {
-	return H265Params{
-		Params: Params{
-			codecName:      "hevc_vaapi",
-			hardwareDevice: hardwareDevice,
-			pixelFormat:    pixelFormat,
-		},
-	}, nil
-}
-
-func (p *H265Params) RTPCodec() *codec.RTPCodec {
-	return codec.NewRTPH265Codec(90000)
-}
-
-func (p *H265Params) BuildVideoEncoder(r video.Reader, property prop.Media) (codec.ReadCloser, error) {
-	readCloser, err := newHardwareEncoder(r, property, p.Params)
-	if err != nil {
-		return nil, err
-	}
-	return readCloser, nil
-}
-
-type AV1Params struct {
-	Params
-}
-
-func NewAV1NVENCParams(hardwareDevice string, pixelFormat astiav.PixelFormat) (AV1Params, error) {
-	return AV1Params{
-		Params: Params{
-			codecName:      "av1_nvenc",
-			hardwareDevice: hardwareDevice,
-			pixelFormat:    pixelFormat,
-		},
-	}, nil
-}
-
-func (p *AV1Params) RTPCodec() *codec.RTPCodec {
-	return codec.NewRTPAV1Codec(90000)
-}
-
-func (p *AV1Params) BuildVideoEncoder(r video.Reader, property prop.Media) (codec.ReadCloser, error) {
-	readCloser, err := newHardwareEncoder(r, property, p.Params)
-	if err != nil {
-		return nil, err
-	}
-	return readCloser, nil
-}

pkg/codec/vpx/vpx.go

@@ -54,6 +54,7 @@ import (
 	"fmt"
 	"image"
 	"io"
+	"math"
 	"sync"
 	"time"
 	"unsafe"
@@ -81,6 +82,12 @@ type encoder struct {
 	closed bool
 }
 
+const (
+	kRateControlThreshold = 0.15
+	kMinQuantizer         = 20
+	kMaxQuantizer         = 63
+)
+
 // VP8Params is codec specific paramaters
 type VP8Params struct {
 	Params
@@ -254,6 +261,10 @@ func (e *encoder) Read() ([]byte, func(), error) {
 		e.raw.d_w, e.raw.d_h = C.uint(width), C.uint(height)
 	}
 
+	if ec := C.vpx_codec_enc_config_set(e.codec, e.cfg); ec != 0 {
+		return nil, func() {}, fmt.Errorf("vpx_codec_enc_config_set failed (%d)", ec)
+	}
+
 	duration := t.Sub(e.tLastFrame).Microseconds()
 	// VPX doesn't allow 0 duration. If 0 is given, vpx_codec_encode will fail with VPX_CODEC_INVALID_PARAM.
 	// 0 duration is possible because mediadevices first gets the frame meta data by reading from the source,
@@ -322,6 +333,24 @@ func (e *encoder) SetBitRate(bitrate int) error {
 	return nil
 }
 
+func (e *encoder) DynamicQPControl(currentBitrate int, targetBitrate int) error {
+	e.mu.Lock()
+	defer e.mu.Unlock()
+	bitrateDiff := math.Abs(float64(currentBitrate - targetBitrate))
+	if bitrateDiff <= float64(currentBitrate)*kRateControlThreshold {
+		return nil
+	}
+	currentMax := e.cfg.rc_max_quantizer
+
+	if targetBitrate < currentBitrate {
+		e.cfg.rc_max_quantizer = min(currentMax+1, kMaxQuantizer)
+	} else {
+		e.cfg.rc_max_quantizer = max(currentMax-1, kMinQuantizer)
+	}
+	e.cfg.rc_min_quantizer = e.cfg.rc_max_quantizer
+	return nil
+}
+
 func (e *encoder) Controller() codec.EncoderController {
 	return e
 }

pkg/codec/vpx/vpx_decoder.go

@@ -0,0 +1,155 @@
+package vpx
+
+/*
+#cgo pkg-config: vpx
+#include <stdlib.h>
+#include <stdint.h>
+#include <vpx/vpx_decoder.h>
+#include <vpx/vpx_codec.h>
+#include <vpx/vpx_image.h>
+#include <vpx/vp8dx.h>
+
+vpx_codec_iface_t *ifaceVP8Decoder() {
+   return vpx_codec_vp8_dx();
+}
+vpx_codec_iface_t *ifaceVP9Decoder() {
+   return vpx_codec_vp9_dx();
+}
+
+// Allocates a new decoder context
+vpx_codec_ctx_t* newDecoderCtx() {
+    return (vpx_codec_ctx_t*)malloc(sizeof(vpx_codec_ctx_t));
+}
+
+// Initializes the decoder
+vpx_codec_err_t decoderInit(vpx_codec_ctx_t* ctx, vpx_codec_iface_t* iface) {
+    return vpx_codec_dec_init_ver(ctx, iface, NULL, 0, VPX_DECODER_ABI_VERSION);
+}
+
+// Decodes an encoded frame
+vpx_codec_err_t decodeFrame(vpx_codec_ctx_t* ctx, const uint8_t* data, unsigned int data_sz) {
+    return vpx_codec_decode(ctx, data, data_sz, NULL, 0);
+}
+
+// Creates an iterator
+vpx_codec_iter_t* newIter() {
+    return (vpx_codec_iter_t*)malloc(sizeof(vpx_codec_iter_t));
+}
+
+// Returns the next decoded frame
+vpx_image_t* getFrame(vpx_codec_ctx_t* ctx, vpx_codec_iter_t* iter) {
+    return vpx_codec_get_frame(ctx, iter);
+}
+
+// Frees a decoded frane
+void freeFrame(vpx_image_t* f) {
+	vpx_img_free(f);
+}
+
+// Frees a decoder context
+void freeDecoderCtx(vpx_codec_ctx_t* ctx) {
+    vpx_codec_destroy(ctx);
+    free(ctx);
+}
+
+*/
+import "C"
+import (
+	"fmt"
+	"image"
+	"io"
+	"sync"
+	"time"
+	"unsafe"
+
+	"github.com/pion/mediadevices/pkg/codec"
+	"github.com/pion/mediadevices/pkg/prop"
+)
+
+type decoder struct {
+	codec      *C.vpx_codec_ctx_t
+	raw        *C.vpx_image_t
+	cfg        *C.vpx_codec_dec_cfg_t
+	iter       C.vpx_codec_iter_t
+	frameIndex int
+	tStart     time.Time
+	tLastFrame time.Time
+	reader     io.Reader
+	buf        []byte
+
+	mu     sync.Mutex
+	closed bool
+}
+
+func BuildVideoDecoder(r io.Reader, property prop.Media) (codec.VideoDecoder, error) {
+	return NewDecoder(r, property)
+}
+
+func NewDecoder(r io.Reader, p prop.Media) (codec.VideoDecoder, error) {
+	cfg := &C.vpx_codec_dec_cfg_t{}
+	cfg.threads = 1
+	cfg.w = C.uint(p.Width)
+	cfg.h = C.uint(p.Height)
+
+	codec := C.newDecoderCtx()
+	if C.decoderInit(codec, C.ifaceVP8Decoder()) != C.VPX_CODEC_OK {
+		return nil, fmt.Errorf("vpx_codec_dec_init failed")
+	}
+
+	return &decoder{
+		codec:  codec,
+		cfg:    cfg,
+		iter:   nil, // initialize to NULL to start iteration
+		reader: r,
+		buf:    make([]byte, 1024*1024),
+	}, nil
+}
+
+func (d *decoder) Read() (image.Image, func(), error) {
+	var input *C.vpx_image_t
+	for {
+		input = C.getFrame(d.codec, &d.iter)
+		if input != nil {
+			break
+		}
+		d.iter = nil
+		// Read if there are no remained frames in the decoder
+		n, err := d.reader.Read(d.buf)
+		if err != nil {
+			return nil, nil, err
+		}
+		status := C.decodeFrame(d.codec, (*C.uint8_t)(&d.buf[0]), C.uint(n))
+		if status != C.VPX_CODEC_OK {
+			return nil, nil, fmt.Errorf("decode failed: %v", status)
+		}
+	}
+	w := int(input.d_w)
+	h := int(input.d_h)
+	yStride := int(input.stride[0])
+	uStride := int(input.stride[1])
+	vStride := int(input.stride[2])
+
+	ySrc := unsafe.Slice((*byte)(unsafe.Pointer(input.planes[0])), yStride*h)
+	uSrc := unsafe.Slice((*byte)(unsafe.Pointer(input.planes[1])), uStride*h/2)
+	vSrc := unsafe.Slice((*byte)(unsafe.Pointer(input.planes[2])), vStride*h/2)
+
+	dst := image.NewYCbCr(image.Rect(0, 0, w, h), image.YCbCrSubsampleRatio420)
+
+	// copy luma
+	for r := 0; r < h; r++ {
+		copy(dst.Y[r*dst.YStride:r*dst.YStride+w], ySrc[r*yStride:r*yStride+w])
+	}
+	// copy chroma
+	for r := 0; r < h/2; r++ {
+		copy(dst.Cb[r*dst.CStride:r*dst.CStride+w/2], uSrc[r*uStride:r*uStride+w/2])
+		copy(dst.Cr[r*dst.CStride:r*dst.CStride+w/2], vSrc[r*vStride:r*vStride+w/2])
+	}
+	C.freeFrame(input)
+	return dst, func() {}, nil
+}
+
+func (d *decoder) Close() error {
+	C.freeDecoderCtx(d.codec)
+	d.closed = true
+	return nil
+}

pkg/codec/vpx/vpx_test.go

@@ -4,6 +4,9 @@ import (
 	"context"
 	"image"
 	"io"
+	"math"
+	"math/rand"
+	"sync"
 	"sync/atomic"
 	"testing"
 	"time"
@@ -13,6 +16,7 @@ import (
 	"github.com/pion/mediadevices/pkg/frame"
 	"github.com/pion/mediadevices/pkg/io/video"
 	"github.com/pion/mediadevices/pkg/prop"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestEncoder(t *testing.T) {
@@ -360,3 +364,155 @@ func TestEncoderFrameMonotonic(t *testing.T) {
 		}
 	}
 }
+
+func TestVP8DynamicQPControl(t *testing.T) {
+	t.Run("VP8", func(t *testing.T) {
+		p, err := NewVP8Params()
+		if err != nil {
+			t.Fatal(err)
+		}
+		p.LagInFrames = 0 // Disable frame lag buffering for real-time encoding
+		p.RateControlEndUsage = RateControlCBR
+		totalFrames := 100
+		frameRate := 10
+		initialWidth, initialHeight := 800, 600
+		var cnt uint32
+
+		r, err := p.BuildVideoEncoder(
+			video.ReaderFunc(func() (image.Image, func(), error) {
+				i := atomic.AddUint32(&cnt, 1)
+				if i == uint32(totalFrames+1) {
+					return nil, nil, io.EOF
+				}
+				img := image.NewYCbCr(image.Rect(0, 0, initialWidth, initialHeight), image.YCbCrSubsampleRatio420)
+				r := rand.New(rand.NewSource(time.Now().UnixNano()))
+				for i := range img.Y {
+					img.Y[i] = uint8(r.Intn(256))
+				}
+				for i := range img.Cb {
+					img.Cb[i] = uint8(r.Intn(256))
+				}
+				for i := range img.Cr {
+					img.Cr[i] = uint8(r.Intn(256))
+				}
+				return img, func() {}, nil
+			}),
+			prop.Media{
+				Video: prop.Video{
+					Width:       initialWidth,
+					Height:      initialHeight,
+					FrameRate:   float32(frameRate),
+					FrameFormat: frame.FormatI420,
+				},
+			},
+		)
+		if err != nil {
+			t.Fatal(err)
+		}
+		initialBitrate := 100
+		currentBitrate := initialBitrate
+		targetBitrate := 300
+		for i := 0; i < totalFrames; i++ {
+			r.Controller().(codec.KeyFrameController).ForceKeyFrame()
+			r.Controller().(codec.QPController).DynamicQPControl(currentBitrate, targetBitrate)
+			data, rel, err := r.Read()
+			if err != nil {
+				t.Fatal(err)
+			}
+			rel()
+			encodedSize := len(data)
+			currentBitrate = encodedSize * 8 / 1000 / frameRate
+		}
+		assert.Less(t, math.Abs(float64(targetBitrate-currentBitrate)), math.Abs(float64(initialBitrate-currentBitrate)))
+	})
+}
+
+func TestVP8EncodeDecode(t *testing.T) {
+	t.Run("VP8", func(t *testing.T) {
+		initialWidth, initialHeight := 800, 600
+		reader, writer := io.Pipe()
+		decoder, err := BuildVideoDecoder(reader, prop.Media{
+			Video: prop.Video{
+				Width:       initialWidth,
+				Height:      initialHeight,
+				FrameFormat: frame.FormatI420,
+			},
+		})
+		if err != nil {
+			t.Fatalf("Error creating VP8 decoder: %v", err)
+		}
+		defer decoder.Close()
+
+		// [... encoder setup code ...]
+		p, err := NewVP8Params()
+		if err != nil {
+			t.Fatal(err)
+		}
+		p.LagInFrames = 0 // Disable frame lag buffering for real-time encoding
+		p.RateControlEndUsage = RateControlCBR
+		totalFrames := 10
+		var cnt uint32
+		r, err := p.BuildVideoEncoder(
+			video.ReaderFunc(func() (image.Image, func(), error) {
+				i := atomic.AddUint32(&cnt, 1)
+				if i == uint32(totalFrames+1) {
+					return nil, nil, io.EOF
+				}
+				img := image.NewYCbCr(image.Rect(0, 0, initialWidth, initialHeight), image.YCbCrSubsampleRatio420)
+				return img, func() {}, nil
+			}),
+			prop.Media{
+				Video: prop.Video{
+					Width:       initialWidth,
+					Height:      initialHeight,
+					FrameRate:   30,
+					FrameFormat: frame.FormatI420,
+				},
+			},
+		)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		var wg sync.WaitGroup
+		wg.Add(1)
+
+		counter := 0
+		go func() {
+			defer wg.Done()
+			for {
+				img, rel, err := decoder.Read()
+				if err == io.EOF {
+					return
+				}
+				if err != nil {
+					t.Errorf("decoder read error: %v", err)
+					return
+				}
+				assert.Equal(t, initialWidth, img.Bounds().Dx())
+				assert.Equal(t, initialHeight, img.Bounds().Dy())
+				rel()
+				counter++
+			}
+		}()
+
+		// --- feed encoded frames to writer
+		for {
+			data, rel, err := r.Read()
+			if err == io.EOF {
+				break
+			}
+			if err != nil {
+				t.Fatalf("encoder error: %v", err)
+			}
+			_, werr := writer.Write(data)
+			rel()
+			if werr != nil {
+				t.Fatalf("writer error: %v", werr)
+			}
+		}
+		writer.Close()
+		wg.Wait()
+		assert.Equal(t, totalFrames, counter)
+	})
+}

pkg/driver/vncdriver/vnc/client.go

@@ -1,7 +1,8 @@
 // Package vnc implements a VNC client.
 //
 // References:
-//   [PROTOCOL]: http://tools.ietf.org/html/rfc6143
+//
+//	[PROTOCOL]: http://tools.ietf.org/html/rfc6143
 package vnc
 
 import (
@@ -96,7 +97,7 @@ func (c *ClientConn) CutText(text string) error {
 	var buf bytes.Buffer
 
 	// This is the fixed size data we'll send
-	fixedData := []interface{}{
+	fixedData := []any{
 		uint8(6),
 		uint8(0),
 		uint8(0),
@@ -141,7 +142,7 @@ func (c *ClientConn) FramebufferUpdateRequest(incremental bool, x, y, width, hei
 		incrementalByte = 1
 	}
 
-	data := []interface{}{
+	data := []any{
 		uint8(3),
 		incrementalByte,
 		x, y, width, height,
@@ -172,7 +173,7 @@ func (c *ClientConn) KeyEvent(keysym uint32, down bool) error {
 		downFlag = 1
 	}
 
-	data := []interface{}{
+	data := []any{
 		uint8(4),
 		downFlag,
 		uint8(0),
@@ -199,7 +200,7 @@ func (c *ClientConn) KeyEvent(keysym uint32, down bool) error {
 func (c *ClientConn) PointerEvent(mask ButtonMask, x, y uint16) error {
 	var buf bytes.Buffer
 
-	data := []interface{}{
+	data := []any{
 		uint8(5),
 		uint8(mask),
 		x,
@@ -225,7 +226,7 @@ func (c *ClientConn) PointerEvent(mask ButtonMask, x, y uint16) error {
 //
 // See RFC 6143 Section 7.5.2
 func (c *ClientConn) SetEncodings(encs []Encoding) error {
-	data := make([]interface{}, 3+len(encs))
+	data := make([]any, 3+len(encs))
 	data[0] = uint8(2)
 	data[1] = uint8(0)
 	data[2] = uint16(len(encs))
@@ -319,7 +320,7 @@ func (c *ClientConn) handshake() error {
 	}
 
 	// Respond with the version we will support
-	if maxMinor<8 {
+	if maxMinor < 8 {
 		if _, err = c.c.Write([]byte("RFB 003.003\n")); err != nil {
 			return err
 		}
@@ -331,7 +332,7 @@ func (c *ClientConn) handshake() error {
 		if numSecurityTypes == 0 {
 			return fmt.Errorf("no security types: %s", c.readErrorReason())
 		}
-	}else{
+	} else {
 		if _, err = c.c.Write([]byte("RFB 003.008\n")); err != nil {
 			return err
 		}

pkg/driver/vncdriver/vnc/server_messages.go

@@ -63,7 +63,7 @@ func (*FramebufferUpdateMessage) Read(c *ClientConn, r io.Reader) (ServerMessage
 		var encodingType int32
 
 		rect := &rects[i]
-		data := []interface{}{
+		data := []any{
 			&rect.X,
 			&rect.Y,
 			&rect.Width,
@@ -128,7 +128,7 @@ func (*SetColorMapEntriesMessage) Read(c *ClientConn, r io.Reader) (ServerMessag
 	for i := uint16(0); i < numColors; i++ {
 
 		color := &result.Colors[i]
-		data := []interface{}{
+		data := []any{
 			&color.R,
 			&color.G,
 			&color.B,

pkg/io/audio/broadcast.go

@@ -27,7 +27,7 @@ func NewBroadcaster(source Reader, config *BroadcasterConfig) *Broadcaster {
 		coreConfig = config.Core
 	}
 
-	broadcaster := io.NewBroadcaster(io.ReaderFunc(func() (interface{}, func(), error) {
+	broadcaster := io.NewBroadcaster(io.ReaderFunc(func() (any, func(), error) {
 		return source.Read()
 	}), coreConfig)
 
@@ -39,11 +39,11 @@ func NewBroadcaster(source Reader, config *BroadcasterConfig) *Broadcaster {
 // buffer, this means that slow readers might miss some data if they're really late and the data is no longer
 // in the ring buffer.
 func (broadcaster *Broadcaster) NewReader(copyChunk bool) Reader {
-	copyFn := func(src interface{}) interface{} { return src }
+	copyFn := func(src any) any { return src }
 
 	if copyChunk {
 		buffer := wave.NewBuffer()
-		copyFn = func(src interface{}) interface{} {
+		copyFn = func(src any) any {
 			realSrc, _ := src.(wave.Audio)
 			buffer.StoreCopy(realSrc)
 			return buffer.Load()
@@ -60,7 +60,7 @@ func (broadcaster *Broadcaster) NewReader(copyChunk bool) Reader {
 
 // ReplaceSource replaces the underlying source. This operation is thread safe.
 func (broadcaster *Broadcaster) ReplaceSource(source Reader) error {
-	return broadcaster.ioBroadcaster.ReplaceSource(io.ReaderFunc(func() (interface{}, func(), error) {
+	return broadcaster.ioBroadcaster.ReplaceSource(io.ReaderFunc(func() (any, func(), error) {
 		return source.Read()
 	}))
 }

pkg/io/broadcast.go

@@ -17,7 +17,7 @@ const (
 var errEmptySource = fmt.Errorf("Source can't be nil")
 
 type broadcasterData struct {
-	data  interface{}
+	data  any
 	count uint32
 	err   error
 }
@@ -124,10 +124,10 @@ func NewBroadcaster(source Reader, config *BroadcasterConfig) *Broadcaster {
 // copyFn is used to copy the data from the source to individual readers. Broadcaster uses a small ring
 // buffer, this means that slow readers might miss some data if they're really late and the data is no longer
 // in the ring buffer.
-func (broadcaster *Broadcaster) NewReader(copyFn func(interface{}) interface{}) Reader {
+func (broadcaster *Broadcaster) NewReader(copyFn func(any) any) Reader {
 	currentCount := broadcaster.buffer.lastCount()
 
-	return ReaderFunc(func() (data interface{}, release func(), err error) {
+	return ReaderFunc(func() (data any, release func(), err error) {
 		currentCount++
 		if push := broadcaster.buffer.acquire(currentCount); push != nil {
 			data, _, err = broadcaster.source.Load().(Reader).Read()

pkg/io/broadcast_test.go

@@ -57,7 +57,7 @@ func TestBroadcast(t *testing.T) {
 					frameCount := 0
 					frameSent := 0
 					lastSend := time.Now()
-					src = ReaderFunc(func() (interface{}, func(), error) {
+					src = ReaderFunc(func() (any, func(), error) {
 						if pauseCond.src && frameSent == 30 {
 							time.Sleep(time.Second)
 						}
@@ -85,7 +85,7 @@ func TestBroadcast(t *testing.T) {
 					wg.Add(n)
 					for i := 0; i < n; i++ {
 						go func() {
-							reader := broadcaster.NewReader(func(src interface{}) interface{} { return src })
+							reader := broadcaster.NewReader(func(src any) any { return src })
 							count := 0
 							lastFrameCount := -1
 							droppedFrames := 0

pkg/io/reader.go

@@ -11,13 +11,13 @@ type Reader interface {
 	// there will be new allocations during streaming, and old unused memory will become garbage. As a consequence,
 	// these garbage will put a lot of pressure to the garbage collector and makes it to run more often and finish
 	// slower as the heap memory usage increases and more garbage to collect.
-	Read() (data interface{}, release func(), err error)
+	Read() (data any, release func(), err error)
 }
 
 // ReaderFunc is a proxy type for Reader
-type ReaderFunc func() (data interface{}, release func(), err error)
+type ReaderFunc func() (data any, release func(), err error)
 
-func (f ReaderFunc) Read() (data interface{}, release func(), err error) {
+func (f ReaderFunc) Read() (data any, release func(), err error) {
 	data, release, err = f()
 	return
 }

pkg/io/video/broadcast.go

@@ -27,7 +27,7 @@ func NewBroadcaster(source Reader, config *BroadcasterConfig) *Broadcaster {
 		coreConfig = config.Core
 	}
 
-	broadcaster := io.NewBroadcaster(io.ReaderFunc(func() (interface{}, func(), error) {
+	broadcaster := io.NewBroadcaster(io.ReaderFunc(func() (any, func(), error) {
 		return source.Read()
 	}), coreConfig)
 
@@ -39,11 +39,11 @@ func NewBroadcaster(source Reader, config *BroadcasterConfig) *Broadcaster {
 // buffer, this means that slow readers might miss some data if they're really late and the data is no longer
 // in the ring buffer.
 func (broadcaster *Broadcaster) NewReader(copyFrame bool) Reader {
-	copyFn := func(src interface{}) interface{} { return src }
+	copyFn := func(src any) any { return src }
 
 	if copyFrame {
 		buffer := NewFrameBuffer(0)
-		copyFn = func(src interface{}) interface{} {
+		copyFn = func(src any) any {
 			realSrc, _ := src.(image.Image)
 			buffer.StoreCopy(realSrc)
 			return buffer.Load()
@@ -60,7 +60,7 @@ func (broadcaster *Broadcaster) NewReader(copyFrame bool) Reader {
 
 // ReplaceSource replaces the underlying source. This operation is thread safe.
 func (broadcaster *Broadcaster) ReplaceSource(source Reader) error {
-	return broadcaster.ioBroadcaster.ReplaceSource(io.ReaderFunc(func() (interface{}, func(), error) {
+	return broadcaster.ioBroadcaster.ReplaceSource(io.ReaderFunc(func() (any, func(), error) {
 		return source.Read()
 	}))
 }

pkg/prop/duration.go

@@ -3,6 +3,7 @@ package prop
 import (
 	"fmt"
 	"math"
+	"slices"
 	"strings"
 	"time"
 )
@@ -54,10 +55,8 @@ type DurationOneOf []time.Duration
 
 // Compare implements DurationConstraint.
 func (d DurationOneOf) Compare(a time.Duration) (float64, bool) {
-	for _, ii := range d {
-		if ii == a {
-			return 0.0, true
-		}
+	if slices.Contains(d, a) {
+		return 0.0, true
 	}
 	return 1.0, false
 }

pkg/prop/float.go

@@ -3,6 +3,7 @@ package prop
 import (
 	"fmt"
 	"math"
+	"slices"
 	"strings"
 )
 
@@ -53,10 +54,8 @@ type FloatOneOf []float32
 
 // Compare implements FloatConstraint.
 func (f FloatOneOf) Compare(a float32) (float64, bool) {
-	for _, ff := range f {
-		if ff == a {
-			return 0.0, true
-		}
+	if slices.Contains(f, a) {
+		return 0.0, true
 	}
 	return 1.0, false
 }

pkg/prop/format.go

@@ -3,6 +3,7 @@ package prop
 import (
 	"fmt"
 	"github.com/pion/mediadevices/pkg/frame"
+	"slices"
 	"strings"
 )
 
@@ -56,10 +57,8 @@ type FrameFormatOneOf []frame.Format
 
 // Compare implements FrameFormatConstraint.
 func (f FrameFormatOneOf) Compare(a frame.Format) (float64, bool) {
-	for _, ff := range f {
-		if ff == a {
-			return 0.0, true
-		}
+	if slices.Contains(f, a) {
+		return 0.0, true
 	}
 	return 1.0, false
 }

pkg/prop/int.go

@@ -3,6 +3,7 @@ package prop
 import (
 	"fmt"
 	"math"
+	"slices"
 	"strings"
 )
 
@@ -53,10 +54,8 @@ type IntOneOf []int
 
 // Compare implements IntConstraint.
 func (i IntOneOf) Compare(a int) (float64, bool) {
-	for _, ii := range i {
-		if ii == a {
-			return 0.0, true
-		}
+	if slices.Contains(i, a) {
+		return 0.0, true
 	}
 	return 1.0, false
 }

pkg/prop/prop.go

@@ -32,7 +32,7 @@ func (m *Media) String() string {
 	return prettifyStruct(m)
 }
 
-func prettifyStruct(i interface{}) string {
+func prettifyStruct(i any) string {
 	var rows []string
 	var addRows func(int, reflect.Value)
 	addRows = func(level int, obj reflect.Value) {
@@ -67,7 +67,7 @@ type setterFn func(fieldA, fieldB reflect.Value)
 
 // merge merges all the field values from o to p, except zero values. It's guaranteed that setterFn will be called
 // when fieldA and fieldB are not struct.
-func (p *Media) merge(o interface{}, set setterFn) {
+func (p *Media) merge(o any, set setterFn) {
 	rp := reflect.ValueOf(p).Elem()
 	ro := reflect.ValueOf(o)
 
@@ -159,13 +159,13 @@ func (p *MediaConstraints) FitnessDistance(o Media) (float64, bool) {
 }
 
 type comparisons []struct {
-	desired, actual interface{}
+	desired, actual any
 }
 
-func (c *comparisons) add(desired, actual interface{}) {
+func (c *comparisons) add(desired, actual any) {
 	if desired != nil {
 		*c = append(*c,
-			struct{ desired, actual interface{} }{
+			struct{ desired, actual any }{
 				desired, actual,
 			},
 		)

pkg/prop/string.go

@@ -2,6 +2,7 @@ package prop
 
 import (
 	"fmt"
+	"slices"
 	"strings"
 )
 
@@ -55,10 +56,8 @@ type StringOneOf []string
 
 // Compare implements StringConstraint.
 func (f StringOneOf) Compare(a string) (float64, bool) {
-	for _, ff := range f {
-		if ff == a {
-			return 0.0, true
-		}
+	if slices.Contains(f, a) {
+		return 0.0, true
 	}
 	return 1.0, false
 }