Additional adjustments to video pipeline

Author: omarroth

README.md

@@ -47,8 +47,11 @@ go build -o doubletake ./cmd/doubletake
 # Use saved credentials
 ./doubletake -target 192.168.1.77 -creds airplay-credentials.json
 
-# Adjust stream settings
-./doubletake -target 192.168.1.77 -width 1920 -height 1080 -fps 30 -bitrate 10000
+# Adjust stream settings (bitrate 0 = auto)
+./doubletake -target 192.168.1.77 -width 1920 -height 1080 -fps 30 -bitrate 0
+
+# Force a lower bitrate on weaker Wi-Fi
+./doubletake -target 192.168.1.77 -bitrate 4500
 
 # Hardware encoding
 ./doubletake -target 192.168.1.77 -hwaccel nvenc   # NVIDIA
@@ -70,7 +73,7 @@ go build -o doubletake ./cmd/doubletake
 | `-width` | 1920 | Stream width |
 | `-height` | 1080 | Stream height |
 | `-fps` | 30 | Frames per second |
-| `-bitrate` | 10000 | Video bitrate (kbps) |
+| `-bitrate` | 0 | Video bitrate in kbps (`0` = auto) |
 | `-hwaccel` | auto | Hardware accel: `auto`, `nvenc`, `vaapi`, `none` |
 | `-test` | false | Use synthetic video source |
 | `-debug` | false | Verbose debug logging |

cmd/doubletake/main.go

@@ -25,7 +25,7 @@ func main() {
 	width := flag.Int("width", 1920, "Stream width")
 	height := flag.Int("height", 1080, "Stream height")
 	fps := flag.Int("fps", 30, "Frames per second")
-	bitrate := flag.Int("bitrate", 10000, "Video bitrate in kbps (default 10000 = 10 Mbps)")
+	bitrate := flag.Int("bitrate", 0, "Video bitrate in kbps (0 = auto, default tunes for resolution/FPS)")
 	hwaccel := flag.String("hwaccel", "auto", "Hardware acceleration: auto, nvenc, vaapi, none")
 	testMode := flag.Bool("test", false, "Use synthetic video (videotestsrc) instead of screen capture for debugging")
 	noEncrypt := flag.Bool("no-encrypt", false, "Disable RTSP header encryption (debugging only; video frames are always encrypted)")

internal/airplay/audio.go

@@ -82,7 +82,7 @@ func StartAudioCapture(ctx context.Context) (*AudioCapture, error) {
 		"!", "audioconvert",
 		"!", "audioresample",
 		"!", "audio/x-raw,rate=44100,channels=2,format=S16LE",
-		"!", "queue", "max-size-buffers=4", "max-size-bytes=0", "max-size-time=0", "leaky=downstream",
+		"!", "queue", "max-size-buffers=2", "max-size-bytes=0", "max-size-time=0", "leaky=downstream",
 		"!",
 	)
 	gstArgs = append(gstArgs, encArgs...)

internal/airplay/capture.go

@@ -24,6 +24,12 @@ type CaptureConfig struct {
 	HWAccel string // "auto", "vaapi", "none"
 }
 
+const (
+	defaultVideoBitrateKbps = 4500
+	minVideoBitrateKbps     = 1800
+	maxVideoBitrateKbps     = 12000
+)
+
 // ScreenCapture manages screen capture via GStreamer.
 type ScreenCapture struct {
 	cmd      *exec.Cmd // gst-launch-1.0 process
@@ -80,7 +86,7 @@ func startWaylandCapture(ctx context.Context, cfg CaptureConfig) (*ScreenCapture
 		"pipewiresrc", fmt.Sprintf("fd=%d", pwFdNum), fmt.Sprintf("path=%d", nodeID), "do-timestamp=true",
 		"!", "videoconvert",
 		"!", "videoscale",
-		"!", "videorate",
+		"!", "videorate", "drop-only=true", "skip-to-first=true",
 		"!", fmt.Sprintf("video/x-raw,width=%d,height=%d,framerate=%d/1", cfg.Width, cfg.Height, fps),
 		"!", "queue", "max-size-buffers=1", "max-size-bytes=0", "max-size-time=0", "leaky=downstream",
 	}
@@ -90,7 +96,7 @@ func startWaylandCapture(ctx context.Context, cfg CaptureConfig) (*ScreenCapture
 	gstArgs = append(gstArgs, "!")
 	gstArgs = append(gstArgs, encoderParts.parts...)
 	gstArgs = append(gstArgs,
-		"!", "h264parse", "config-interval=-1",
+		"!", "h264parse", "config-interval=0",
 		"!", "video/x-h264,stream-format=byte-stream,alignment=au",
 		"!", "fdsink", "fd=1", "sync=false", "async=false",
 	)
@@ -179,7 +185,7 @@ func startX11Capture(ctx context.Context, cfg CaptureConfig) (*ScreenCapture, er
 	gstArgs = append(gstArgs, "!")
 	gstArgs = append(gstArgs, encoder.parts...)
 	gstArgs = append(gstArgs,
-		"!", "h264parse", "config-interval=-1",
+		"!", "h264parse", "config-interval=0",
 		"!", "video/x-h264,stream-format=byte-stream,alignment=au",
 		"!", "fdsink", "fd=1", "sync=false", "async=false",
 	)
@@ -354,7 +360,7 @@ func parseXrandrGeometry(line string) (xOffset, width int, ok bool) {
 // encoderResult holds the detected encoder pipeline parts and whether it needs
 // a vulkanupload step before the encoder.
 type encoderResult struct {
-	parts      []string
+	parts       []string
 	needsVulkan bool // encoder needs vulkanupload ! before it
 }
 
@@ -366,10 +372,8 @@ func detectGstEncoder(cfg CaptureConfig) encoderResult {
 	if fps <= 0 {
 		fps = 30
 	}
-	bitrate := cfg.Bitrate
-	if bitrate <= 0 {
-		bitrate = 10000
-	}
+	bitrate := captureBitrateKbps(cfg)
+	keyframeInterval := keyframeIntervalFrames(fps)
 	hwaccel := cfg.HWAccel
 
 	// Try Vulkan H.264 (NVENC via Vulkan API) — lowest latency, no CPU usage
@@ -380,7 +384,7 @@ func detectGstEncoder(cfg CaptureConfig) encoderResult {
 				parts: []string{
 					"vulkanh264enc",
 					"b-frames=0",
-					fmt.Sprintf("idr-period=%d", fps*2),
+					fmt.Sprintf("idr-period=%d", keyframeInterval),
 					"rate-control=cbr",
 					fmt.Sprintf("bitrate=%d", bitrate),
 				},
@@ -396,7 +400,7 @@ func detectGstEncoder(cfg CaptureConfig) encoderResult {
 			return encoderResult{parts: []string{
 				"nvh264enc",
 				fmt.Sprintf("bitrate=%d", bitrate),
-				fmt.Sprintf("gop-size=%d", fps*2),
+				fmt.Sprintf("gop-size=%d", keyframeInterval),
 				"bframes=0",
 				"rc-mode=cbr",
 				"preset=low-latency-hq",
@@ -415,7 +419,7 @@ func detectGstEncoder(cfg CaptureConfig) encoderResult {
 			return encoderResult{parts: []string{
 				"vah264enc",
 				fmt.Sprintf("bitrate=%d", bitrate),
-				fmt.Sprintf("key-int-max=%d", fps*2),
+				fmt.Sprintf("key-int-max=%d", keyframeInterval),
 				"b-frames=0",
 				"rate-control=cbr",
 			}}
@@ -427,16 +431,23 @@ func detectGstEncoder(cfg CaptureConfig) encoderResult {
 
 	// Software fallback: x264enc
 	log.Printf("[CAPTURE] using software encoding (x264enc)")
+	vbvBuf := vbvBufferKbit(bitrate, fps)
+	// Use VBR (pass=0) so the encoder can undershoot on simple scenes, saving
+	// headroom for complex frames. vbv-buf-capacity + vbv-maxrate cap bursts.
+	maxrate := bitrate + bitrate/4 // allow 25% overshoot on peaks
 	return encoderResult{parts: []string{
 		"x264enc",
 		"tune=zerolatency",
-		"speed-preset=ultrafast",
+		"speed-preset=superfast",
 		fmt.Sprintf("bitrate=%d", bitrate),
-		fmt.Sprintf("key-int-max=%d", fps*2),
+		fmt.Sprintf("vbv-buf-capacity=%d", vbvBuf),
+		fmt.Sprintf("key-int-max=%d", keyframeInterval),
+		"pass=0",
+		"option-string=" + fmt.Sprintf("vbv-maxrate=%d", maxrate),
 		"bframes=0",
+		"sliced-threads=true",
 		"byte-stream=true",
 		"aud=false",
-		"vbv-buf-capacity=50",
 	}}
 }
 
@@ -452,10 +463,8 @@ func StartTestCapture(ctx context.Context, cfg CaptureConfig) (*ScreenCapture, e
 		fps = 30
 	}
 
-	bitrate := cfg.Bitrate
-	if bitrate <= 0 {
-		bitrate = 10000
-	}
+	bitrate := captureBitrateKbps(cfg)
+	keyframeInterval := keyframeIntervalFrames(fps)
 
 	// GStreamer pipeline: videotestsrc → timeoverlay → x264enc High profile → Annex-B byte stream → stdout
 	// pattern=18 = ball (bouncing ball with motion); timeoverlay adds a frame counter
@@ -467,9 +476,11 @@ func StartTestCapture(ctx context.Context, cfg CaptureConfig) (*ScreenCapture, e
 		"!", "videoconvert",
 		"!", "x264enc",
 		"tune=zerolatency",
+		"speed-preset=superfast",
 		fmt.Sprintf("bitrate=%d", bitrate),
-		fmt.Sprintf("key-int-max=%d", fps*2),
+		fmt.Sprintf("key-int-max=%d", keyframeInterval),
 		"threads=1",
+		"sliced-threads=true",
 		"byte-stream=true",
 		"!", "video/x-h264,profile=high,stream-format=byte-stream",
 		"!", "fdsink", "fd=1",
@@ -525,6 +536,66 @@ func logStderr(prefix string, r io.Reader) {
 	}
 }
 
+func captureBitrateKbps(cfg CaptureConfig) int {
+	if cfg.Bitrate > 0 {
+		return cfg.Bitrate
+	}
+
+	fps := cfg.FPS
+	if fps <= 0 {
+		fps = 30
+	}
+	width := cfg.Width
+	if width <= 0 {
+		width = 1920
+	}
+	height := cfg.Height
+	if height <= 0 {
+		height = 1080
+	}
+
+	bitrate := recommendedBitrateKbps(width, height, fps)
+	log.Printf("[CAPTURE] auto bitrate selected: %d kbps for %dx%d@%dfps", bitrate, width, height, fps)
+	return bitrate
+}
+
+func recommendedBitrateKbps(width, height, fps int) int {
+	if width <= 0 || height <= 0 || fps <= 0 {
+		return defaultVideoBitrateKbps
+	}
+
+	bitrate := (width*height*fps + 7500) / 15000
+	if bitrate < minVideoBitrateKbps {
+		return minVideoBitrateKbps
+	}
+	if bitrate > maxVideoBitrateKbps {
+		return maxVideoBitrateKbps
+	}
+	return bitrate
+}
+
+func keyframeIntervalFrames(fps int) int {
+	if fps <= 0 {
+		fps = 30
+	}
+	return fps * 4
+}
+
+// vbvBufferKbit returns the x264 VBV buffer size in kbit for the given bitrate
+// and FPS. Sized at ~2 frames of data — enough headroom for the encoder to
+// handle scene changes without severe quality oscillation, but tight enough to
+// prevent large burst spikes that choke Wi-Fi links.
+func vbvBufferKbit(bitrateKbps, fps int) int {
+	if bitrateKbps <= 0 || fps <= 0 {
+		return 300
+	}
+	vbv := bitrateKbps * 2 / fps
+	if vbv < 200 {
+		return 200
+	}
+	return vbv
+}
+
 // requestScreencast uses the xdg-desktop-portal D-Bus API to request screen capture
 // permission and returns a PipeWire node ID, an fd for the portal's PipeWire remote,
 // and the D-Bus connection (which must stay open to keep the screencast session alive).

internal/airplay/capture_test.go

@@ -0,0 +1,87 @@
+package airplay
+
+import "testing"
+
+func TestRecommendedBitrateKbps(t *testing.T) {
+	tests := []struct {
+		name   string
+		width  int
+		height int
+		fps    int
+		want   int
+	}{
+		{
+			name:   "defaults when dimensions invalid",
+			width:  0,
+			height: 1080,
+			fps:    30,
+			want:   defaultVideoBitrateKbps,
+		},
+		{
+			name:   "low resolution clamps to floor",
+			width:  640,
+			height: 360,
+			fps:    30,
+			want:   minVideoBitrateKbps,
+		},
+		{
+			name:   "720p30 stays near wifi target",
+			width:  1280,
+			height: 720,
+			fps:    30,
+			want:   1843,
+		},
+		{
+			name:   "1080p30 uses wifi friendly auto bitrate",
+			width:  1920,
+			height: 1080,
+			fps:    30,
+			want:   4147,
+		},
+		{
+			name:   "high resolutions clamp to max",
+			width:  3840,
+			height: 2160,
+			fps:    60,
+			want:   maxVideoBitrateKbps,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := recommendedBitrateKbps(tt.width, tt.height, tt.fps); got != tt.want {
+				t.Fatalf("recommendedBitrateKbps(%d, %d, %d) = %d, want %d", tt.width, tt.height, tt.fps, got, tt.want)
+			}
+		})
+	}
+}
+
+func TestKeyframeIntervalFrames(t *testing.T) {
+	if got := keyframeIntervalFrames(30); got != 120 {
+		t.Fatalf("keyframeIntervalFrames(30) = %d, want 120", got)
+	}
+	if got := keyframeIntervalFrames(0); got != 120 {
+		t.Fatalf("keyframeIntervalFrames(0) = %d, want 120", got)
+	}
+}
+
+func TestVbvBufferKbit(t *testing.T) {
+	tests := []struct {
+		name    string
+		bitrate int
+		fps     int
+		want    int
+	}{
+		{"invalid returns default", 0, 30, 300},
+		{"low bitrate clamps to floor", 1800, 30, 200},
+		{"1080p30 auto bitrate", 4147, 30, 276},
+		{"high bitrate 60fps", 12000, 60, 400},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := vbvBufferKbit(tt.bitrate, tt.fps); got != tt.want {
+				t.Fatalf("vbvBufferKbit(%d, %d) = %d, want %d", tt.bitrate, tt.fps, got, tt.want)
+			}
+		})
+	}
+}