Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

75.0 KB
Raw Blame

Cap H.264 production encoding baselines

This file lists the exact H.264 encoder settings used by each Cap surface, so a benchmark harness can reproduce them on Linux.

Sources and environment

Item Value
Cap repo /workspace on branch main, commit d327051c1 (read only)
PR 2312 FETCH_HEAD = 549c5afa9 (origin/feature/web-editor-desktop-parity), read with git show FETCH_HEAD:<path>
Rust ffmpeg bindings ffmpeg-next, CapSoftware fork rev 49db1fede112
Verification ffmpeg 6.1.1-3ubuntu5
Verification libx264 core 164 r3108
Verification Chrome Google Chrome 148.0.7778.96 at /usr/local/bin/google-chrome, headless
Verification CPU nproc = 4

Line numbers refer to main unless marked "PR".

A value marked "verified" was observed in an encode on this VM, either in ffprobe output or in the x264 SEI options string. A value marked "source" was read from code but not run. Hardware encoders (VideoToolbox, NVENC, QSV, AMF, Media Foundation, AVFoundation) cannot run on this VM.

Contents

  1. Conventions and shared facts
  2. Media server
  3. Web app server-side ffmpeg
  4. Render farm
  5. Desktop recording
  6. Desktop export
  7. Web recorders on main (MediaRecorder)
  8. Browser WebCodecs encoders on main
  9. PR 2312 differences
  10. Running browser surfaces in headless Chrome with Playwright
  11. Ambiguities and assumptions
  12. Summary table

0. Conventions and shared facts

0.1 Placeholders

Placeholder Meaning
W, H Output width and height
FPS Frame rate
B Target bitrate in bit/s
M maxrate, always B * 3 / 2 with integer division where Cap sets it
K Keyframe interval in frames
N nproc

All ffmpeg reproductions read raw input with:

-f rawvideo -pix_fmt yuv420p -s WxH -r FPS -i in.yuv

0.2 Shared bits-per-pixel (bpp) bitrate model

Desktop export, desktop recording through enc-ffmpeg, the render farm, and the PR browser export all use this model.

Implementation Location
get_bitrate crates/enc-ffmpeg/src/video/h264.rs lines 1651-1658
bitrate crates/render-farm/src/video.rs lines 184-187
exportBitrate (PR) packages/editor-solid-web/src/browser-export-estimate.ts

The formula is:

B = W * H * ((max(FPS - 30, 0) * 0.6) + 30) * bpp
M = B * 3 / 2        (Rust only: encoder.set_max_bit_rate(bitrate * 3 / 2))

How each implementation computes it:

  • Rust: bpp is an f32, widened to f64, and the result is truncated to usize. That gives slightly odd values, for example 29,859,841.
  • PR browser export: uses JavaScript f64 with Math.round.

Worked values for the Rust model, shown as B (M):

bpp 1280x720@30 1920x1080@30 1920x1080@60 3840x2160@30
1.0 27,648,000 (41,472,000) 62,208,000 (93,312,000) 99,532,800 (149,299,200) 248,832,000 (373,248,000)
0.3 8,294,400 (12,441,600) 18,662,400 (27,993,600) 29,859,841 (44,789,761) 74,649,602 (111,974,403)
0.18 4,976,640 (7,464,960) 11,197,440 (16,796,160) 17,915,904 (26,873,856) 44,789,761 (67,184,641)
0.15 4,147,200 (6,220,800) 9,331,200 (13,996,800) 14,929,920 (22,394,880) 37,324,801 (55,987,201)
0.08 2,211,839 (3,317,758) 4,976,639 (7,464,958) 7,962,623 (11,943,934) 19,906,559 (29,859,838)
0.04 1,105,919 (1,658,878) 2,488,319 (3,732,478) 3,981,311 (5,971,966) 9,953,279 (14,929,918)

Browser model (Math.round, f64), B only:

bpp 1280x720@30 1920x1080@30 1920x1080@60 3840x2160@30
0.3 8,294,400 18,662,400 29,859,840 74,649,600
0.15 4,147,200 9,331,200 14,929,920 37,324,800
0.08 2,211,840 4,976,640 7,962,624 19,906,560
0.04 1,105,920 2,488,320 3,981,312 9,953,280

0.3 Shared keyframe interval

crates/enc-ffmpeg/src/video/h264.rs lines 1223-1239:

DEFAULT_KEYFRAME_INTERVAL_SECS = 2
K = round(2 * FPS).max(1)
FPS K
30 60
60 120

The render farm uses fps * 2 with integer fps (crates/render-farm/src/video.rs line 473; keyframe secs = 2 at line 629). That gives the same values.

0.4 How Cap's x264 options reach libx264 (applies to every enc-ffmpeg and render-farm libx264 path)

Options are passed as an AVDictionary to open_as_with, which calls avcodec_open2. Keys that libx264/AVCodecContext does not recognise are silently left unconsumed and ignored.

Key Status
preset, tune, crf, threads, bf, rc-lookahead, aq-mode, trellis, g, keyint_min Consumed
b-adapt Ignored. The real option name is b_strategy.
ref Ignored. The real option name is refs.
subme Ignored. The real option name is subq.
pix_fmt Ignored. It is not a codec option.

Effect, verified from the x264 SEI string:

  • The export/render-farm "fast" set produces ref=1 subme=2, which are the veryfast preset defaults. The intended ref 2 never applies.
  • subme 2 and trellis 0 happen to equal the veryfast defaults.
  • b-adapt is irrelevant because bf 0.

Two more x264 behaviours, both verified:

  • maxrate is ignored. Cap sets rc_max_rate (M) but never sets rc_buffer_size. x264 logs VBV maxrate specified, but no bufsize, ignored, so every Cap libx264 bitrate encode is plain ABR (rc=abr, no VBV).
  • keyint_min is clamped. Cap sets keyint_min = K. x264 clamps it to K/2 + 1, so 60 becomes 31 and 120 becomes 61.

0.5 Shared enc-ffmpeg encoder context

Source: crates/enc-ffmpeg/src/video/h264.rs lines 775-816.

Threading: threads = available_parallelism() via set_threading(Config::count(...)).

Colour tags:

  • colorspace BT709
  • color_range MPEG (limited)
  • color_primaries BT709
  • color_trc BT709

Rate control:

  • CRF mode: bit_rate = 0.
  • Otherwise: bit_rate = get_bitrate(out_w, out_h, fps, bpp) and max_bit_rate = bit_rate * 3 / 2.

Timing:

  • Encoder time base is the input VideoInfo.time_base.
  • Muxer stream time base is 1/90000 (lines 286 and 413).

Pixel format (lines 671-688):

  • Uses the input format if the encoder supports it.
  • Otherwise YUV420P for libx264 and NV12 for the others.

Scaler (lines 627-657):

  • BICUBIC when resizing, FAST_BILINEAR otherwise.
  • RGB input uses BT.709 coefficients, full-range in, limited-range out.

Encoder priority:

Platform Order
macOS h264_videotoolbox, libx264
Windows, NVIDIA GPU h264_nvenc, h264_mf, h264_qsv, h264_amf, libx264
Windows, AMD GPU h264_amf, h264_mf, h264_nvenc, h264_qsv, libx264
Windows, Intel GPU h264_qsv, h264_mf, h264_nvenc, h264_amf, libx264
Windows, other or unknown GPU h264_nvenc, h264_qsv, h264_amf, h264_mf, libx264
Windows, GPU without hardware encoding libx264
Linux with /dev/nvidiactl present h264_nvenc, libx264
Linux otherwise libx264

Sources: get_default_encoder_priority at lines 1133-1173 and linux_encoder_priority at lines 1124-1131.

Priority overrides:

  • CAP_EXPORT_FORCE_SOFTWARE_ENCODER set to 1, true, yes or on forces libx264 (line 1192).
  • requires_software_encoder (line 1062) never applies to exports. For recordings it forces libx264 when:
    • the preset is HighThroughput, or
    • on macOS/Windows, FPS is above 0.9 times the estimated hardware maximum.
  • A CRF request always forces libx264 (line 1241).
  • Windows export with an AMD GPU uses h264_amf, h264_mf, h264_nvenc, h264_qsv, libx264 (lines 1201-1221).

Fallback: encoders are tried in priority order, and the first that opens is used.

0.6 Option sets per encoder

Source: crates/enc-ffmpeg/src/video/h264.rs lines 1258-1357, quoted literally.

h264_videotoolbox

Mode Options
Export realtime=false, profile=main, allow_sw=0
Recording realtime=true, prio_speed=true, profile=main

No g is set in either mode.

h264_nvenc

Mode Options
Export preset=p5, tune=hq, rc=vbr, spatial-aq=1, temporal-aq=1, b_ref_mode=middle, g=K
Recording preset=p4, tune=ll, rc=vbr, spatial-aq=1, temporal-aq=1, g=K

h264_qsv

Mode Options
Export preset=medium, look_ahead=1, look_ahead_depth=20, g=K
Recording preset=faster, look_ahead=1, g=K

h264_amf

Mode Options
Export quality=quality, rc=vbr_peak, g=K
Recording quality=balanced, rc=vbr_latency, g=K

h264_mf

Mode Options
Export hw_encoding=true, scenario=0, quality=0, g=K
Recording hw_encoding=true, scenario=4, quality=1, g=K

libx264, which branch applies:

Condition Options
CRF requested preset=slow, crf=<crf>, pix_fmt=yuv420p (ignored)
Export, preset Slow preset=slow
Export, preset Medium preset=medium
Export, any other preset preset=veryfast, threads=N, bf=0, rc-lookahead=10, b-adapt=0 (ignored), aq-mode=1, ref=2 (ignored), subme=2 (ignored), trellis=0
Recording, Slow or Medium preset=veryfast, tune=zerolatency
Recording, Ultrafast or HighThroughput preset=ultrafast, tune=zerolatency

All libx264 branches also set g=K and keyint_min=K.

0.7 VideoToolbox and NVENC defaults that Cap inherits (source: FFmpeg 7.1)

VideoToolbox (libavcodec/videotoolboxenc.c):

  • vt_defaults only sets b, qmin and qmax, so gop_size keeps the AVCodecContext default of 12.
  • Because Cap never sets g for VideoToolbox, MaxKeyFrameInterval = 12 frames. This is not 2 s.
  • max_b_frames defaults to 0, so AllowFrameReordering = false (no B-frames).
  • profile=main maps to kVTProfileLevel_H264_Main_AutoLevel.
  • rc_max_rate maps to kVTCompressionPropertyKey_DataRateLimits as [M/8 bytes, 1 s].

NVENC:

  • g is set by Cap.
  • bf stays at -1, meaning the preset decides.
  • refs stays at 0 (default).
  • rc-lookahead and bufsize are not set by Cap.

0.8 Audio summary

Surface Audio
Media server processVideo AAC 128k
Media server edit AAC 160k
Render farm AAC 320 kbps, 48 kHz
Desktop enc-ffmpeg AAC 320 kbps

The desktop value comes from crates/enc-ffmpeg/src/audio/aac.rs line 33: OUTPUT_BITRATE: usize = 320 * 1000; // 128k. The trailing comment is stale.


1. Media server (apps/media-server)

Image: apps/media-server/Dockerfile uses FROM oven/bun:1.4.0 plus apt ffmpeg, with no version pinned.

1.1 MS-TRANSCODE: processVideo video transcode

Location: apps/media-server/src/lib/media-video.ts.

Lines What
162-172 DEFAULT_OPTIONS
47-50 Level size constants
1288-1302 needsVideoTranscode
1304-1306 needsAudioTranscode
1405-1420 pickMobileSafeH264Level
1483-1581 processVideo

Constants resolved from DEFAULT_OPTIONS:

Option Value
maxWidth 1920
maxHeight 1080
crf 23
preset "medium"
audioBitrate "128k"
videoBitrate "5M" (defined, never used in any argument)
remuxOnly false
normalizeH264Level false

Literal argument vector when videoTranscode is true:

ffmpeg -threads 2 [extraInputArgs] -i <in>
  -c:v libx264 -preset medium -crf 23
  -vf "scale='min(1920,iw)':'min(1080,ih)':force_original_aspect_ratio=decrease,scale=trunc(iw/2)*2:trunc(ih/2)*2"
  -pix_fmt yuv420p -level:v <4.2|5.1|5.2>
  [-bf 0]                                  # only when source codec is vp8 or vp9
  <-c:a aac -b:a 128k | -c:a copy | -an>
  -movflags +faststart [extraOutputArgs] -progress pipe:2 -y <out>.mp4

When it runs. needsVideoTranscode is true when any of these hold:

  • source width > maxWidth, or height > maxHeight
  • the codec is not h264
  • the probed source H.264 level is above the target level

Level choice (pickMobileSafeH264Level) uses the target size (min(srcW, maxW), min(srcH, maxH)):

Target size Level
≤2048x1088 4.2
≤4096x2304 5.1
Larger 5.2

With the defaults every transcode is level 4.2.

Callers:

Caller Options passed Effect
Web workflows (process-video.ts, admin reprocess) No size or quality options Defaults apply: a 1080p cap, level 4.2
/video/convert (routes/video.ts line 594) Source dimensions as max No downscale; 4K gets level 5.1
Multipart (multipart.ts line 977) remuxOnly: true for web MP4 Video and audio copied

Audio:

  • Source audio is AAC: -c:a copy.
  • Other source audio: -c:a aac -b:a 128k.
  • No audio: -an.

Resilient mode. The retry path adds these flags, built at routes/video.ts lines 842-847:

Position Flags
Input -err_detect ignore_err -fflags +genpts+discardcorrupt
Output -max_muxing_queue_size 1024

Encoder settings:

Setting Value
Encoder libx264
Rate control CRF 23. No bitrate cap or VBV.
GOP x264 defaults: keyint 250, keyint_min 25, scenecut 40 (verified)
B-frames, VP8/VP9 source -bf 0 (verified bframes=0)
B-frames, other sources x264 medium default bframes=3
Preset / tune medium, no tune
x264 internals at medium ref=3, subme=7, trellis=1, rc_lookahead=40 (verified)
Profile High (x264 automatic, verified)
Level Forced by -level:v (verified 42)
Pixel format yuv420p

Threads. -threads 2 is placed before -i, so it applies to the decoder only. The encoder uses ffmpeg's automatic count: verified threads=6 on 4 cores.

Colour. No colour options are set, so tags are passed through from the decoder. Untagged sources stay untagged.

Scaling:

  • First: fit inside 1920x1080, preserving aspect ratio, never upscaling.
  • Then: round both dimensions down to even.
  • Scaler flags: swscale default (bicubic).

Frame rate:

  • No -r, no fps filter, no -fps_mode/-vsync.
  • The ffmpeg CLI fps_mode auto picks CFR for the MP4 muxer, so VFR browser captures are duplicated/dropped to the rate ffmpeg guesses for the input.
  • Verified: a VFR WebM tagged 30/1 came out as 90 frames at 30/1.

Container: MP4 with +faststart. Audio, when transcoded, is AAC 128k.

Reproduction on Linux (verified):

ffmpeg -y -threads 2 -f rawvideo -pix_fmt yuv420p -s WxH -r FPS -i in.yuv \
  -c:v libx264 -preset medium -crf 23 \
  -vf "scale='min(1920,iw)':'min(1080,ih)':force_original_aspect_ratio=decrease,scale=trunc(iw/2)*2:trunc(ih/2)*2" \
  -pix_fmt yuv420p -level:v 4.2 -an -movflags +faststart ms_transcode.mp4
  • MS-TRANSCODE-VPX: add -bf 0 before -an. This is the variant that applies to Chrome WebM recordings on main.
  • 3840x2160 input: with default options, the output is 1920x1080 at level 4.2.

1.2 MS-LEVELFIX: level rewrite without re-encode (dormant)

Location: media-video.ts lines 1533-1539.

ffmpeg -threads 2 -i <in> -c:v copy -bsf:v h264_metadata=level=<4.2|5.1|5.2> ... -movflags +faststart -progress pipe:2 -y <out>

It runs only when opts.normalizeH264Level is true and the source fits inside the size limits with a level above the target. No caller sets normalizeH264Level, so this is not reached in production. A too-high level instead causes a full MS-TRANSCODE.

1.3 Other media-server ffmpeg invocations (no H.264 encode)

Copy path: -c:v copy in processVideo, used for H.264 sources within the size and level limits.

Container repair (media-video.ts lines 1325-1361):

ffmpeg -threads 2 -err_detect ignore_err -fflags +genpts+igndts -i <in> -c copy -y <out>.mkv

Edit concat (media-edit.ts buildConcatArgs, line 207):

ffmpeg -hide_banner -y -f concat -safe 0 -i <list> -map 0 -c copy -movflags +faststart <out>

Unused: buildTranscodeSegmentArgs and buildStreamCopySegmentArgs in media-edit.ts have no callers.

1.4 MS-EDIT: edited-video render (renderEditedVideo)

Location: apps/media-server/src/lib/media-edit.ts.

Lines What
83-87 getOutputFps
151-205 buildTranscodeEditArgs
446-469 renderEditedVideo

It is called from routes/video.ts line 1168.

Inputs and constants:

  • fps is the probed metadata.fps.
  • getOutputFps(fps) = min(120, max(1, round(fps*100)/100)), or DEFAULT_OUTPUT_FPS = 30 when fps is missing or invalid.
  • Up to MAX_TRANSCODE_RANGES_PER_BATCH = 4 ranges per ffmpeg run. Multiple batches are joined by the concat copy in section 1.3.

Literal arguments:

ffmpeg -hide_banner -y
  (-ss <start> -t <dur> -i <in>) x ranges
  -filter_complex "[i:v:0]fps=F,setpts=PTS-STARTPTS[vi];[i:a:0]asetpts=PTS-STARTPTS[ai];...;[v0][a0]...concat=n=R:v=1:a=1[v][a]"
  -map [v] -c:v libx264 -preset fast -crf 18 -pix_fmt yuv420p -enc_time_base:v 1/F
  (-map [a] -c:a aac -b:a 160k | -an)
  -movflags +faststart <out>

Without audio, each video filter is [i:v:0]fps=F,setpts=PTS-STARTPTS[vi] and the concat is concat=n=R:v=1:a=0[v].

Encoder settings:

Setting Value
Encoder libx264
Rate control CRF 18
GOP x264 default keyint 250, min 25
B-frames x264 fast default bframes=3, b_adapt=1 (verified has_b_frames=2)
Preset / tune fast, no tune
x264 internals at fast ref=2, subme=6, rc_lookahead=30 (verified)
Profile High (verified)
Level x264 automatic (verified 3.1 at 720p30)
Pixel format yuv420p
Colour Passed through from input

Frame rate: CFR at F, enforced by the fps filter, with -enc_time_base:v 1/F.

Container and audio: MP4 with +faststart; AAC 160k.

Reproduction on Linux (single range, no audio, exactly the filter string the code builds; verified):

ffmpeg -hide_banner -y -f rawvideo -pix_fmt yuv420p -s WxH -r FPS -i in.yuv \
  -filter_complex "[0:v:0]fps=FPS,setpts=PTS-STARTPTS[v0];[v0]concat=n=1:v=1:a=0[v]" \
  -map "[v]" -c:v libx264 -preset fast -crf 18 -pix_fmt yuv420p -enc_time_base:v 1/FPS \
  -an -movflags +faststart ms_edit.mp4

2. Web app server-side ffmpeg

2.1 WEB-LOOM-FFMPEG: Loom download conversion

Location: apps/web/lib/video-convert.ts, used by app/api/tools/loom-download/route.ts.

It first tries a remux (line 212):

ffmpeg -y -i <url> -c copy -movflags +faststart <out>

If the remux fails, it re-encodes (line 223):

ffmpeg -y -i <url> -c:v libx264 -preset veryfast -pix_fmt yuv420p -c:a aac -b:a 128k -movflags +faststart <out>

Encoder settings:

Setting Value
Rate control CRF 23 (libx264 default, no -crf given)
GOP 250/25
B-frames veryfast default bframes=3 (verified has_b_frames=2)
Profile / level High, automatic level (verified 3.1 at 720p30)
Frame rate CLI auto, so CFR for MP4
Colour Passed through
Container MP4 +faststart
Audio AAC 128k

Reproduction on Linux (verified):

ffmpeg -y -f rawvideo -pix_fmt yuv420p -s WxH -r FPS -i in.yuv \
  -c:v libx264 -preset veryfast -pix_fmt yuv420p -an -movflags +faststart web_loom_ffmpeg.mp4

3. Render farm

3.1 Runtime configuration

Location: apps/render-farm/Dockerfile.

  • Base image: Debian trixie, using Debian's ffmpeg.
  • Lines 47-49:
    ENV RF_ENCODER=h264_nvenc
    ENV RF_NVENC_PRESET=p1
    ENV RF_REQUIRE_GPU=1
    

Encoder selection and fallback:

  • In code, RF_ENCODER defaults to "libx264" (crates/render-farm/src/video.rs line 425). Production sets NVENC through the Dockerfile.
  • There is no automatic NVENC to libx264 fallback.
  • If NVENC is unavailable, find_by_name fails ("{encoder_name} unavailable").
  • RF_REQUIRE_GPU checks at video.rs lines 257 and 364 fail fast without a GPU.
  • libx264 is used only when RF_ENCODER is overridden.

Job defaults (apps/render-farm/src/coordinator.ts lines 374-384):

Field Value
compression Maximum
fps 30
resolution [1920, 1080]
Worker threads per task 8 (line 1067)

Compression map (apps/render-farm/src/protocol.ts COMPRESSION_BPP):

Compression bpp
Maximum 0.3
Social 0.15
Web 0.08
Potato 0.04

3.2 RF-RENDER-NVENC and RF-RENDER-X264: chunked render encode

Location: crates/render-farm/src/video.rs encode, lines 415-512.

Common settings, both encoders:

Setting Value
Input pixel format NV12, or CUDA surfaces when NVENC and the renderer produced GPU frames (Linux)
Time base 1/fps
Frame rate fps/1 (CFR; frame-numbered)
Colour BT709 colorspace, MPEG (limited) range, BT709 primaries, BT709 trc
Bitrate bit_rate = bitrate(W, H, fps, bpp), max_bit_rate = B * 3 / 2
Flags GLOBAL_HEADER
K fps * 2

NVENC dictionary (production):

Option Value
preset RF_NVENC_PRESET or "p1"
tune RF_NVENC_TUNE or "hq"
rc constqp with qp=0 if tune is "lossless", otherwise vbr
spatial-aq RF_NVENC_SAQ or "1"
temporal-aq RF_NVENC_TAQ or "1"
bf 0
g K
forced-idr 1

NVENC does not get the thread setting.

libx264 dictionary (override only):

Option Value
preset veryfast
threads 8
bf 0
rc-lookahead 10
b-adapt 0 (ignored)
aq-mode 1
ref 2 (ignored)
subme 2 (ignored)
trellis 0
g K
keyint_min K

The context threading count is also 8.

Rate control:

  • NVENC: VBR with average B and max M. bufsize is not set, so NVENC's default VBV applies.
  • libx264: ABR at B, maxrate ignored (verified rc=abr bitrate=8294 at 720p30, Maximum).

GOP:

  • NVENC: K with forced IDR. Each HLS segment of round(fps*2) frames is one GOP.
  • libx264: keyint K, keyint_min clamped to K/2+1 (verified 60/31), scenecut 40, no B-frames.

Profile and level:

  • NVENC: not set, so the encoder picks it. The preset decides profile; High is expected.
  • libx264: High, automatic level (verified High).

Container. The farm writes its own boxes rather than using ffmpeg's muxer:

  • MP4 (apps/render-farm/src/mp4.ts):
    • buildHeader (line 654) writes ftyp (major isom, minor 0x200, brands isom iso2 avc1 mp41), then moov, free, mdat. The moov is up front.
    • Video timescale is fps*1000 and sample delta is 1000 (CFR).
    • The avc1 entry (line 584) carries colr nclx 1/1/1/0 and pasp.
  • HLS (RF_HLS is on unless it is "0"; RF_HLS_SEGMENT_SECONDS defaults to 2; coordinator.ts lines 94-95):
    • Segments are fMP4 with init.mp4 (line 1981) plus styp+moof+mdat .m4s files.
    • Segment keys are ${prefix}/c${chunk}-p${firstPart}-${index}.m4s (hls.ts line 40).
    • segmentFrames = round(fps*2) (line 1087).
    • The playlist (fmp4.ts lines 267-285) has #EXT-X-VERSION:7, #EXT-X-TARGETDURATION:<HLS_SEGMENT_SECONDS+2> = 4, #EXT-X-MEDIA-SEQUENCE:0, #EXT-X-PLAYLIST-TYPE:EVENT, #EXT-X-INDEPENDENT-SEGMENTS, #EXT-X-MAP, #EXTINF:<toFixed(3)> and #EXT-X-ENDLIST.

Audio: AAC at 320,000 bit/s and 48,000 Hz (crates/render-farm/src/audio.rs).

Worked bitrates at Maximum (bpp 0.3):

Resolution B M
1920x1080@30 (job default) 18,662,400 27,993,600
1920x1080@60 29,859,841 44,789,761
1280x720@30 8,294,400
3840x2160@30 74,649,602

Other compressions follow the table in section 0.2.

Reproduction on Linux.

RF-RENDER-X264 (verified; the x264 SEI matches ref=1 subme=2 trellis=0 threads=8 keyint=60 keyint_min=31 rc_lookahead=10 rc=abr bitrate=8294):

ffmpeg -y -f rawvideo -pix_fmt yuv420p -s WxH -r FPS -i in.yuv \
  -pix_fmt nv12 -c:v libx264 -preset veryfast -threads 8 -b:v B -maxrate M \
  -bf 0 -rc-lookahead 10 -aq-mode 1 -trellis 0 -g K -keyint_min K \
  -colorspace bt709 -color_primaries bt709 -color_trc bt709 -color_range tv \
  -an -movflags +faststart rf_render_x264.mp4
  • -maxrate is included because the production code sets it. It has no effect without -bufsize.
  • The farm's own MP4 writer is approximated with -movflags +faststart (moov first).

HLS approximation (verified to produce #EXT-X-VERSION:7, PLAYLIST-TYPE:EVENT, INDEPENDENT-SEGMENTS, EXT-X-MAP init.mp4). Replace the last line of the previous command with:

  -f hls -hls_time 2 -hls_segment_type fmp4 -hls_playlist_type event \
  -hls_fmp4_init_filename init.mp4 -hls_flags independent_segments out/rf.m3u8

This approximation differs from production in two ways:

  • ffmpeg writes TARGETDURATION 2, while the farm writes 4.
  • Segment names differ.

RF-RENDER-X264-INTENDED is not production. It shows what the dictionary was meant to do: add -refs 2 -subq 2 -b_strategy 0.

RF-RENDER-NVENC cannot run on this VM. On an NVIDIA host:

ffmpeg -y -f rawvideo -pix_fmt yuv420p -s WxH -r FPS -i in.yuv \
  -pix_fmt nv12 -c:v h264_nvenc -preset p1 -tune hq -rc vbr -b:v B -maxrate M \
  -spatial-aq 1 -temporal-aq 1 -bf 0 -g K -forced-idr 1 \
  -colorspace bt709 -color_primaries bt709 -color_trc bt709 -color_range tv \
  -an -movflags +faststart rf_render_nvenc.mp4

3.3 RF-TRANSCODE: source preparation before rendering

Location: apps/render-farm/src/transcode.ts.

Lines What
7-49 transcodeArgs
56 MAX_REMUX_KEYFRAME_GAP_SECONDS = 4
77-111 canRemux
113 remuxArgs

worker.ts line 705 sets TRANSCODE_ENCODER = process.env.RF_TRANSCODE_ENCODER ?? "h264_nvenc". keyframeSeconds is TRANSCODE_KEYFRAME_SECONDS = 1 (coordinator.ts line 1551).

Remux path. It is used when canRemux is true:

  • codec h264
  • yuv420p
  • has_b_frames=0
  • every packet has pts == dts
  • keyframe gaps ≤ 4 s, including the tail
ffmpeg -hide_banner -nostdin -y -loglevel error -progress pipe:1 -nostats -i <in> -map 0:v:0 -an -c:v copy -movflags +faststart <out>

Transcode path, literal (with keyframeSeconds = 1):

ffmpeg -hide_banner -nostdin -y -loglevel error -progress pipe:1 -nostats
  [-hwaccel cuda]                          # NVENC only
  -i <in> -map 0:v:0 -an -fps_mode passthrough -pix_fmt yuv420p -c:v <encoder>
  NVENC:   -preset p1 -rc vbr -cq 19 -b:v 0
  libx264: -preset veryfast -crf 18
  -bf 0 -force_key_frames "expr:gte(t,n_forced*1)"
  [-forced-idr 1]                          # NVENC only
  -movflags +faststart <out>

Encoder settings:

Setting NVENC (production default) libx264
Rate control Constant-quality VBR, -cq 19, -b:v 0 CRF 18
Preset p1 veryfast
Keyframes Forced every 1 s, as IDR Forced every 1 s, on top of x264 keyint 250 / min 25 / scenecut 40
B-frames None None
  • Profile and level: encoder automatic. libx264 verified High.
  • Frame rate: -fps_mode passthrough keeps the source VFR timestamps.
  • Colour: passed through.
  • Container: MP4 +faststart, video only.
  • Hardware decode: -hwaccel cuda decodes on the GPU but frames are downloaded (no -hwaccel_output_format), so -pix_fmt yuv420p applies.

Reproduction on Linux.

RF-TRANSCODE-X264 (verified keyframes at 0, 1, 2 s, bframes=0, High):

ffmpeg -hide_banner -nostdin -y -f rawvideo -pix_fmt yuv420p -s WxH -r FPS -i in.yuv \
  -map 0:v:0 -an -fps_mode passthrough -pix_fmt yuv420p -c:v libx264 -preset veryfast -crf 18 \
  -bf 0 -force_key_frames "expr:gte(t,n_forced*1)" -movflags +faststart rf_transcode_x264.mp4

RF-TRANSCODE-NVENC cannot run on this VM:

ffmpeg -hide_banner -nostdin -y -hwaccel cuda -i in.mp4 -map 0:v:0 -an -fps_mode passthrough \
  -pix_fmt yuv420p -c:v h264_nvenc -preset p1 -rc vbr -cq 19 -b:v 0 -bf 0 \
  -force_key_frames "expr:gte(t,n_forced*1)" -forced-idr 1 -movflags +faststart rf_transcode_nvenc.mp4

4. Desktop recording

4.1 Common facts

Defaults (crates/recording/src/defaults.rs):

Constant Value
DEFAULT_STUDIO_MAX_FPS 60
CAMERA_ACTIVE_STUDIO_MAX_FPS 30
DEFAULT_INSTANT_MODE_FPS 30
FREE_INSTANT_MODE_MAX_RESOLUTION 1280
PRO_INSTANT_MODE_MAX_RESOLUTION 1920
DEFAULT_CRASH_RECOVERY_RECORDING true, so fragmented recording is the default
DEFAULT_OUT_OF_PROCESS_MUXER false
  • Default studio quality is Compatibility if total RAM is under 16 GiB, else Balanced. Ultra is opt-in.
  • Instant mode clamps the output to fit (max, max*9/16): 1280x720 for free users, 1920x1080 for Pro (instant_recording.rs lines 719-734).

Timestamps (all enc-ffmpeg recording paths):

  • VideoInfo.time_base = 1/1_000_000 (crates/media-info/src/lib.rs lines 47, 58, 89).
  • update_pts (crates/enc-ffmpeg/src/base.rs lines 76-104) sets pts = round(capture_ts_secs * 1e6) - first_pts.
  • So output is VFR, following capture timestamps.
  • frame_rate is the capture rate. It is used only for bitrate and K.

Fragmented container. SegmentedVideoEncoder (crates/enc-ffmpeg/src/mux/segmented_stream.rs lines 195-240) uses the ffmpeg dash muxer writing dash_manifest.mpd:

Muxer option Value
init_seg_name init.mp4
media_seg_name segment_$Number%03d$.m4s
seg_duration <secs>
use_timeline 1
use_template 1
single_file 0
hls_playlist 1

Output files, verified: init.mp4, segment_001.m4s, ..., master.m3u8, and media_0.m3u8 (#EXT-X-VERSION:6 with PROGRAM-DATE-TIME).

4.2 Linux (X11 capture)

Location: crates/recording/src/capture_pipeline.rs lines 374-430, and crates/recording/src/output_pipeline/ffmpeg.rs.

Studio: SegmentedVideoMuxer, 2 s segments, preset Medium when quality is Ultra, otherwise Ultrafast.

Instant: SegmentedVideoMuxer, 2 s segments, preset Ultrafast, output size clamped as in section 4.1.

bpp is always 0.3. start_encoder (ffmpeg.rs lines 648-672) hardcodes bpp: H264EncoderBuilder::QUALITY_BPP (0.3) for every quality and for instant mode. Instant mode does not use 0.15 here, unlike macOS and Windows. prefer_videotoolbox_hw_input is false.

Camera: SegmentedVideoMuxer with a 3 s segment (line 825). The muxer default is 3 s (line 471).

Encoder: /dev/nvidiactl present gives h264_nvenc (recording set: p4, ll, vbr, AQ, g=K), otherwise libx264.

libx264 settings:

Quality Preset / tune
Balanced or Compatibility ultrafast + zerolatency
Ultra (preset Medium) veryfast + zerolatency
Setting Value
Rate control ABR at B (bpp 0.3), maxrate ignored
GOP keyint K, keyint_min clamped to K/2+1
Scenecut 0 (zerolatency)
B-frames None
Pixel format yuv420p, converted from capture format by swscale (BT.709, full-range in, limited out)
Colour BT.709 tags

Verified ultrafast/zerolatency output at 720p30:

  • Constrained Baseline, level 3.2
  • cabac=0 ref=1 subme=0 trellis=0 8x8dct=0 sliced_threads=1 bframes=0 keyint=60 keyint_min=31 scenecut=0 rc=abr mbtree=0 aq=0

Worked B at bpp 0.3:

Resolution B
1280x720@30 8,294,400
1920x1080@30 18,662,400
1920x1080@60 29,859,841
3840x2160@30 74,649,602

K is 60 at 30 fps and 120 at 60 fps.

Audio: AAC 320 kbps via enc-ffmpeg.

Reproduction on Linux.

DESK-REC-X264 (verified):

mkdir -p out && ffmpeg -y -f rawvideo -pix_fmt yuv420p -s WxH -r FPS -i in.yuv \
  -c:v libx264 -preset ultrafast -tune zerolatency -threads N -b:v B -maxrate M -g K -keyint_min K \
  -pix_fmt yuv420p -colorspace bt709 -color_primaries bt709 -color_trc bt709 -color_range tv -an \
  -f dash -seg_duration 2 -use_timeline 1 -use_template 1 -single_file 0 -hls_playlist 1 \
  -init_seg_name init.mp4 -media_seg_name 'segment_$Number%03d$.m4s' out/dash_manifest.mpd

DESK-REC-X264-ULTRA: the same command with -preset veryfast. B stays at bpp 0.3 on Linux.

Difference from production: the raw input is CFR. Production uses VFR capture timestamps in a 1/1e6 time base.

4.3 macOS (cannot run on this VM)

Fragmented studio (default) (capture_pipeline.rs lines 113-226):

  • Muxer: MacOSFragmentedM4SMuxer, or the out-of-process muxer when enabled. Both use SegmentedVideoEncoder.
  • prefer_videotoolbox_hw_input is true for screen (macos_fragmented_m4s.rs line 295) and false for camera (line 682).
  • Defaults (lines 185-187): 2 s segments, Ultrafast, bpp 0.3.
Quality bpp Preset
Ultra 1.0 Medium
Compatibility 0.15 Ultrafast
Balanced 0.3 Ultrafast

DESK-REC-VT (h264_videotoolbox, recording set):

Setting Value
Options realtime=true, prio_speed=true, profile=main
Bitrate B; DataRateLimits = M/8 bytes per 1 s
GOP 12 frames (FFmpeg default; Cap sets no g)
B-frames None (frame reordering off)
Level Main AutoLevel
Input NV12 hardware surfaces, no scaling
Colour BT.709 tags
Fallback libx264 (section 0.6 recording set) when VideoToolbox fails to open or fps exceeds 0.9 times the estimated VideoToolbox maximum

Platform command (not runnable here):

ffmpeg -f rawvideo -pix_fmt nv12 -s WxH -r FPS -i in.nv12 -c:v h264_videotoolbox -realtime true -prio_speed true -profile:v main -b:v B -maxrate M -colorspace bt709 -color_primaries bt709 -color_trc bt709 -color_range tv out.mp4

Production passes no -g, so the ffmpeg CLI default gop_size (12) also applies here.

Non-fragmented studio: AVFoundationMp4Muxer (crates/recording/src/output_pipeline/macos.rs lines 326-352) builds cap_enc_avfoundation::MP4Encoder (crates/enc-avfoundation/src/mp4.rs).

Setting Value
Settings base OutputSettingsAssistant::with_preset(h264_3840x2160) (line 251)
Output height ensure_even(output_height or source height)
Output width Proportional, even (lines 260-268)
Bitrate AVVideoAverageBitRateKey from the formulas below
AVVideoAllowFrameReorderingKey ultra && !instant
AVVideoExpectedSourceFrameRateKey fps
AVVideoMaxKeyFrameIntervalKey floor(0.75 * fps).max(1)
Colour ITU_R_709_2 for transfer, primaries and matrix (lines 325-339)
Writer expects_media_data_in_real_time true
Profile, level, entropy coding AVFoundation defaults

Bitrate formulas (lines 1070-1109), with pixels = W*H and f = min(fps, 60)/30:

Profile Formula
Balanced max(pixels*f*5, 8,000,000)
Ultra clamp(pixels*f*10, 8,000,000, 120,000,000)
Compatibility clamp(pixels*f*2.5, 2,500,000, 10,000,000)
Instant 1,500,000 + pixels/(1920*1080)*1,500,000 + f*500,000

Worked values:

Profile 1280x720@30 1920x1080@30 1920x1080@60 3840x2160@30
Balanced 8,000,000 10,368,000 20,736,000 41,472,000
Ultra 9,216,000 20,736,000 41,472,000 82,944,000
Compatibility 2,500,000 5,184,000 10,000,000 10,000,000
Instant 2,666,666 3,500,000 4,000,000 8,000,000

Keyframe interval: 22 at 30 fps, 45 at 60 fps.

Instant mode:

  • Screen: MacOSFragmentedM4SMuxer with bpp 0.15 through VideoToolbox, 2 s segments.
  • Camera-only instant: AVFoundation init_instant_mode (instant formula, no reordering).

Studio camera: AVFoundationCameraMuxer (macos.rs lines 973-995), using the Compatibility profile when the compatibility flag is set, otherwise Balanced. Reordering is off.

AVFoundation reproduction is a platform API (AVAssetWriter with the keys above). There is no ffmpeg equivalent.

4.4 Windows (cannot run on this VM)

Fragmented studio (default) (capture_pipeline.rs lines 247-369, win_fragmented_m4s.rs):

  • SegmentedVideoEncoder with 2 s segments (line 232). The camera uses 3 s (line 659).
  • Hardware input is false.
Quality bpp Preset
Ultra 1.0 Medium
Other 0.3 Ultrafast

The encoder follows the Windows priority in section 0.5, with the recording option sets from section 0.6.

NVENC example (platform command):

ffmpeg ... -c:v h264_nvenc -preset p4 -tune ll -rc vbr -spatial-aq 1 -temporal-aq 1 -g K -b:v B -maxrate M -colorspace bt709 -color_primaries bt709 -color_trc bt709 -color_range tv -f dash ...

Instant: 2 s segments, Ultrafast, bpp 0.15.

Non-fragmented studio: WindowsMuxer (output_pipeline/win.rs).

Setting Value
frame_rate 30
bitrate_multiplier 0.3 for Ultra, else 0.15
fragmented false
frag_duration_us 2,000,000
  • Encoder: cap_enc_mediafoundation::H264Encoder (crates/enc-mediafoundation/src/video/h264.rs).
    • MF_MT_AVG_BITRATE (line 359) = calculate_bitrate (lines 693-696): W*H*((max(fps-30,0)/2)+30)*multiplier, with fps 30.
    • MF_MT_FRAME_RATE = frame_rate/1 (line 366).
    • No GOP, profile or rate-control mode is set, so these are Media Foundation transform defaults.
  • Frame pacing at 1/frame_rate (win.rs line 340) gives CFR at 30 fps.

Worked MF bitrates (fps fixed at 30):

Multiplier 1280x720 1920x1080 1920x1080 (60 fps capture) 3840x2160
0.3 8,294,400 18,662,400 18,662,400 74,649,600
0.15 4,147,200 9,331,200 9,331,200 37,324,800

Software fallback (win.rs lines 229-243): H264Encoder::builder(video_config) with builder defaults (bpp 0.3, Ultrafast, recording mode, default priority). It is used when:

  • software is forced
  • the primary GPU is AMD (so AMD goes through h264_amf with quality=balanced, rc=vbr_latency first)
  • Media Foundation init or validation fails

Camera: Media Foundation multiplier 0.2 at the camera fps (win.rs line 763).


5. Desktop export

Location: crates/export/src/mp4.rs.

Compression map:

Compression bpp (lines 147-152) CRF (lines 156-161)
Maximum 0.3 24
Social 0.15 28
Web 0.08 32
Potato 0.04 36

Mp4ExportSettings (lines 180-190):

Field Notes
fps
resolution_base
compression
custom_bpp
force_ffmpeg_decoder
optimize_filesize serde default false
  • effective_bpp (line 193) is custom_bpp if set, else the map.
  • VideoInfo is NV12 with time_base = 1/fps (lines 365-367). Frames are numbered, so output is CFR.
  • Builder chain: with_bpp, with_export_priority (is_export = true), with_export_settings, with_external_conversion, plus with_crf(crf) if optimize_filesize.
  • The builder preset stays at its default Ultrafast, which selects the libx264 "fast" set.
  • Container: MP4File::init("output", path, self.optimize_filesize, ...). +faststart is written only when optimize_filesize is true (crates/enc-ffmpeg/src/mux/mp4.rs lines 44-90). Default exports have the moov at the end.
  • Audio: AAC 320 kbps.
  • macOS: want_hw_input = !optimize_filesize && frame is a Surface.

UI defaults (apps/desktop/src/routes/editor/ExportPage.tsx):

Setting Value
Format Mp4
fps 30 (options 15/30/60, lines 79-83)
Resolution 720p 1280x720
Compression Maximum
optimizeFilesize false
Custom bpp slider 0.02 to 0.5, step 0.01 (lines 1408-1410)
  • Resolution options (Header.tsx lines 33-37): 720p 1280x720, 1080p 1920x1080, 4K 3840x2160.
  • Output size is rounded: width up to a multiple of 4, height up to even (crates/rendering/src/lib.rs get_output_size, lines 3228-3242).

5.1 DESK-EXPORT-X264-{Maximum,Social,Web,Potato}: default export on Linux, or any platform's software fallback

Encoder settings: libx264 export "fast" set plus g=K, keyint_min=K, threads=N.

Setting Value
Rate control ABR at B, maxrate ignored
GOP K, min K/2+1
B-frames None
Preset / tune veryfast, no tune
Effective internals ref=1, subme=2, trellis=0, rc_lookahead=10
Profile / level High, automatic level
Colour BT.709 limited
Container MP4 without faststart; track time base 1/90000

Verified at 720p30 Maximum: SEI identical to the render farm except threads=4.

Worked B per quality (Rust model, section 0.2):

Compression 1280x720@30 1920x1080@30 1920x1080@60 3840x2160@30
Maximum 8,294,400 18,662,400 29,859,841 74,649,602
Social 4,147,200 9,331,200 14,929,920 37,324,801
Web 2,211,839 4,976,639 7,962,623 19,906,559
Potato 1,105,919 2,488,319 3,981,311 9,953,279

K is 60 at 30 fps and 120 at 60 fps. The desktop UI also offers 15 fps, where K = 30.

Reproduction on Linux (verified):

ffmpeg -y -f rawvideo -pix_fmt yuv420p -s WxH -r FPS -i in.yuv \
  -pix_fmt nv12 -c:v libx264 -preset veryfast -threads N -b:v B -maxrate M \
  -bf 0 -rc-lookahead 10 -aq-mode 1 -trellis 0 -g K -keyint_min K \
  -colorspace bt709 -color_primaries bt709 -color_trc bt709 -color_range tv \
  -an -video_track_timescale 90000 desk_export_x264.mp4

5.2 DESK-EXPORT-CRF-{24,28,32,36}: "Optimize file size"

CRF forces libx264. Dictionary: preset=slow, crf=<24|28|32|36>, pix_fmt=yuv420p (ignored), g=K, keyint_min=K. Threading is N through the context. No bitrate is set (bit_rate = 0).

Setting Value
Rate control CRF
GOP K, min K/2+1
B-frames x264 slow default: bframes=3, b_adapt=1
Preset slow
Effective internals ref=5, subme=8, trellis=2, rc_lookahead=50
Profile High
Colour BT.709 limited
Container MP4 with +faststart

Verified at 720p30, CRF 24: ref=5 subme=8 trellis=2 threads=4 bframes=3 keyint=60 keyint_min=31 rc_lookahead=50 rc=crf crf=24.0.

Compression maps to CRF as Maximum 24, Social 28, Web 32, Potato 36.

Reproduction on Linux (verified):

ffmpeg -y -f rawvideo -pix_fmt yuv420p -s WxH -r FPS -i in.yuv \
  -pix_fmt nv12 -c:v libx264 -preset slow -crf 24 -threads N -g K -keyint_min K \
  -colorspace bt709 -color_primaries bt709 -color_trc bt709 -color_range tv \
  -an -movflags +faststart -video_track_timescale 90000 desk_export_crf24.mp4

5.3 Hardware export variants (cannot run on this VM)

All variants use the same B and M as section 5.1.

DESK-EXPORT-VT (macOS default):

  • Options: realtime=false, profile=main, allow_sw=0; b B, maxrate M.
  • GOP is 12 frames because no g is set. There are no B-frames.
  • Input is NV12 surfaces.
ffmpeg ... -c:v h264_videotoolbox -realtime false -profile:v main -allow_sw 0 -b:v B -maxrate M ...

DESK-EXPORT-NVENC (Windows NVIDIA, or Linux with /dev/nvidiactl):

-c:v h264_nvenc -preset p5 -tune hq -rc vbr -spatial-aq 1 -temporal-aq 1 -b_ref_mode middle -g K -b:v B -maxrate M

DESK-EXPORT-QSV:

-c:v h264_qsv -preset medium -look_ahead 1 -look_ahead_depth 20 -g K -b:v B -maxrate M

DESK-EXPORT-AMF:

-c:v h264_amf -quality quality -rc vbr_peak -g K -b:v B -maxrate M

DESK-EXPORT-MF:

-c:v h264_mf -hw_encoding true -scenario 0 -quality 0 -g K -b:v B -maxrate M

6. Web recorders on main (MediaRecorder)

6.1 BR-MR-MAIN: dashboard web recorder

Locations:

  • packages/recorder-core/src/recorder-constants.ts
  • packages/recorder-core/src/recorder-utils.ts
  • apps/web/app/(org)/dashboard/caps/components/web-recorder-dialog/useWebRecorder.ts

Capture constraints (recorder-constants.ts lines 9-19): {frameRate:{ideal:30}, width:{ideal:1920}, height:{ideal:1080}}. These are ideal values, not exact.

MIME candidates:

List Candidates
WEBM_MIME_TYPES (lines 94-97), withAudio video/webm;codecs=vp9,opus, video/webm;codecs=vp8,opus
WEBM_MIME_TYPES, videoOnly video/webm;codecs=vp9, video/webm;codecs=vp8, video/webm
MP4_MIME_TYPES (lines 82-92), withAudio video/mp4;codecs="avc1.42E01E,mp4a.40.2", video/mp4;codecs="avc1.4d401e,mp4a.40.2"
MP4_MIME_TYPES, videoOnly video/mp4;codecs="avc1.42E01E", video/mp4;codecs="avc1.4d401e", video/mp4

Pipeline selection (selectRecordingPipelineFromSupport, lines 140-190):

  1. WebM is supported and preferStreamingUpload !== false: mode streaming-webm.
  2. Otherwise the first supported MP4 candidate: mode buffered-raw.
  3. Otherwise WebM in mode buffered-raw.

shouldPreferStreamingUpload (lines 105-130) returns false for iOS, Firefox and Safari, and true for Chromium brands.

Recorder options (getMediaRecorderOptions, lines 36-41):

{ mimeType, videoKeyFrameIntervalDuration: 2_000 }

No videoBitsPerSecond is set, so the browser default applies (Chrome: 2.5 Mbps video, 128 kbps audio). It is constructed at useWebRecorder.ts line 1101.

Timeslice:

  • streaming-webm: start(1000) (INSTANT_UPLOAD_REQUEST_INTERVAL_MS, line 75).
  • If that throws: start() with manual flushing.
  • buffered-raw: start(200) (line 1141).

What each browser records:

Browser Output
Chrome / Edge VP9 + Opus WebM. This is not H.264.
Safari H.264 MP4, avc1.42E01E,mp4a.40.2 (Constrained Baseline 3.0 requested; Safari's own encoder)
Firefox First supported MP4 candidate, else WebM

videoInstantCreate is called with videoCodec: "h264" (line 1056).

Server step:

  • Chrome VP9 is transcoded by MS-TRANSCODE-VPX: libx264 medium, CRF 23, -bf 0, capped at 1080p, level 4.2, CFR, AAC 128k.
  • Safari H.264 at or below 1080p and level 4.2 is copied.
  • recording-conversion.ts convertToMp4 (line 127) is unused.

Reproduction on Linux. Chrome via Playwright:

new MediaRecorder(stream, { mimeType: "video/webm;codecs=vp9,opus", videoKeyFrameIntervalDuration: 2000 })
recorder.start(1000)

Then apply MS-TRANSCODE-VPX to the WebM (use -i rec.webm in place of the rawvideo input).

BR-MR-MAIN-MP4 (Safari-path equivalent in Chrome): { mimeType: 'video/mp4;codecs="avc1.42E01E"', videoKeyFrameIntervalDuration: 2000 } with start(200). Linux Chrome has no AAC MediaRecorder encoder, so the mp4a.40.2 variants are unsupported there.

6.2 BR-MR-EXT-MAIN: Chrome extension

Location: apps/chrome-extension/src/offscreen/recorder.ts.

  • new MediaRecorder(recordingStream, { mimeType: pipeline.mimeType }) at lines 944-946.
  • No keyframe or bitrate options.
  • start(RECORDING_TIMESLICE_MS) with RECORDING_TIMESLICE_MS = 1000 (lines 70, 1086).
  • In Chrome this gives VP9/Opus WebM at the Chrome default bitrate, then MS-TRANSCODE-VPX.

Reproduction: new MediaRecorder(stream, { mimeType: "video/webm;codecs=vp9,opus" }); recorder.start(1000).

6.3 BR-MR-TOOLS: SpeedController and TrimmingTool

Location: apps/web/components/tools/SpeedController.tsx and TrimmingTool.tsx.

  • Source: canvas.captureStream(60) (SpeedController line 243, TrimmingTool line 408).
  • Options: { mimeType: selectedMimeType, videoBitsPerSecond: 5000000 } (SpeedController line 263, TrimmingTool line 446).
  • Timeslice: start(1000) in SpeedController (line 296), start(100) in TrimmingTool (line 485).

MIME list for MP4 input (non-MP4 input uses the same WebM entries first, then video/mp4):

"video/mp4", "video/webm;codecs=vp9,opus", "video/webm;codecs=vp8,opus", "video/webm;codecs=vp9", "video/webm;codecs=vp8", "video/webm"

Reproduction: new MediaRecorder(canvas.captureStream(60), { mimeType: "video/mp4", videoBitsPerSecond: 5000000 }). The codec Chrome picks for bare video/mp4 is browser-dependent.


7. Browser WebCodecs encoders on main

7.1 BR-WC-REMOTION: Remotion convertMedia

Packages: @remotion/webcodecs 4.0.484 and mediabunny 1.49.0, unpacked to /tmp for reading.

Callers:

  • apps/web/app/s/[videoId]/_components/timeline/recording/convert-comment-media.ts lines 25-32: convertMedia({ container: "mp4", videoCodec: "h264", audioCodec: "aac" }) with installAvcLevelClamp() active. It skips conversion when the input is already MP4 or canConvertToMp4InBrowser (probe avc1.42E01F 1280x720 plus AAC) fails.
  • apps/web/components/tools/MediaFormatConverter.tsx lines 650-657: convertMedia({ container: "mp4", videoCodec: "h264" }) with no clamp.

VideoEncoderConfig built by Remotion:

Field Value
bitrate Not set in Chrome. Safari: 3,000,000.
framerate Source fps
hardwareAcceleration Tries prefer-hardware, then prefer-software
Keyframes Every 40 frames
Codec avc1.64 + 00 + level from Remotion's width/height/fps table (profile byte always 0x64)

Level clamp. installAvcLevelClamp (avc-level-clamp.ts) patches VideoEncoder.prototype.configure to replace the codec with pickMobileSafeAvcCodec(width, height):

Size Codec
≤2048x1088 avc1.64002A
≤4096x2304 avc1.640033
Larger avc1.640034

Chromium default bitrate when none is given (media/base/video_encoder.cc GetDefaultVideoEncodeBitrate, source only):

2,000,000 * clamp(fps,1,300) * clamp(W*H,1,64M) / (1280*720*30)

The result is clamped to at least 10,000.

Worked values:

1280x720@30 1920x1080@30 1920x1080@60 3840x2160@30
Chromium default bitrate 2,000,000 4,500,000 9,000,000 18,000,000
Codec without clamp avc1.64001F avc1.64002A avc1.64002A avc1.640034
Codec with clamp avc1.64002A avc1.64002A avc1.64002A avc1.640033

Container: MP4 written by Remotion. Audio is AAC; Linux Chrome has no AAC AudioEncoder, so comment media with audio is left as WebM there.

Reproduction on Linux (Playwright, Google Chrome):

new VideoEncoder(...).configure({
  codec: "avc1.64002A",            // with clamp; "avc1.64001F" etc. without
  width: W,
  height: H,
  framerate: FPS,
  hardwareAcceleration: "prefer-software",
})

Set keyFrame: true every 40th frame and leave bitrate unset. Headless Linux Chrome rejects prefer-hardware (verified), so Remotion's software retry is the path that runs.

7.2 BR-WC-MEDIABUNNY-LOOM: Loom browser conversion

Location: apps/web/lib/loom-browser-conversion.ts (same on main and the PR).

DASH WebM path (lines 644-662):

new Mp4OutputFormat({ fastStart: false })
new VideoSampleSource({ codec: "avc", bitrate: QUALITY_HIGH, hardwareAcceleration: "prefer-hardware", alpha: "discard" })
new AudioSampleSource({ codec: "aac", bitrate: QUALITY_MEDIUM })

Conversion path (lines 857-873):

Mp4OutputFormat({ fastStart: false })
Conversion.init({
  video: { codec: "avc", bitrate: QUALITY_HIGH, hardwareAcceleration: "prefer-hardware" },
  audio: { codec: "aac", bitrate: QUALITY_MEDIUM },
})

mediabunny 1.49.0 behaviour (source):

  • Quality factors: VERY_LOW 0.3, LOW 0.6, MEDIUM 1, HIGH 2, VERY_HIGH 4.
  • Video bitrate: ceil(3e6 * (W*H/2073600)^0.95 * 1.0(avc) * 2 / 1000) * 1000. It does not depend on fps.
  • keyFrameInterval defaults to 2 s, by timestamp.
  • latencyMode defaults to quality.
  • Codec is avc1.6400LL from mediabunny's AVC level table, chosen by macroblocks and bitrate.
  • The config adds avc: { format: "avc" }.
  • Timestamps are passed through from the source (VFR).
  • AAC QUALITY_MEDIUM is 128,000 bit/s.

Worked values:

1280x720 1920x1080 (any fps) 3840x2160
Video bitrate 2,778,000 6,000,000 22,393,000
Codec avc1.64001F avc1.640028 avc1.640033

Container: MP4 with the moov at the end (fastStart: false).

Reproduction on Linux:

VideoEncoder.configure({
  codec: "avc1.640028",
  width: 1920,
  height: 1080,
  bitrate: 6000000,
  framerate: FPS,
  hardwareAcceleration: "no-preference",
  alpha: "discard",
  avc: { format: "avc" },
})

prefer-hardware is unsupported in headless Linux Chrome (verified). Force a keyframe every 2 s of timestamp.


8. PR 2312 differences (FETCH_HEAD 549c5afa9)

The PR does not change:

  • crates/enc-ffmpeg
  • crates/export/src/mp4.rs
  • crates/render-farm/src/video.rs
  • the desktop capture pipelines

8.1 BR-MR-PR-SCREEN, BR-MR-PR-CAMERA, BR-MR-PR-OVERLAY: web recorder

Location (PR): packages/recorder-core/src/recorder-encoding.ts.

MIME candidates: recorder-constants.ts lines 96-102 add:

List Candidates
STREAMING_MP4_MIME_TYPES, withAudio video/mp4;codecs="avc1.64002A,mp4a.40.2", video/mp4;codecs="avc1.64002A,opus"
STREAMING_MP4_MIME_TYPES, videoOnly video/mp4;codecs="avc1.64002A"

Pipeline selection (recorder-utils.ts lines 139-211):

  • If preferStreamingUpload !== false: streaming MP4, else streaming WebM. Both use mode "streaming".
  • Otherwise buffered MP4 (avc1.42E01E list), else buffered WebM.
  • getMediaRecorderOptions is removed.

Bitrate tiers (BITRATES, lines 45-49), in bit/s for captures with ≤1280x720, ≤1920x1088, ≤2560x1600 and larger pixel counts:

Content ≤720p ≤1080p ≤1600p Larger
screen 2,500,000 4,000,000 6,000,000 10,000,000
camera 2,600,000 4,500,000 6,500,000 10,000,000
cameraOverlay 2,000,000 3,500,000 5,000,000 8,000,000
  • recordingBitrate (lines 57-74): above 40 fps, Math.round(base * 1.5).
  • Missing width/height default to 1920x1080. Missing fps defaults to 30.

Recorder options (recorderOptions, lines 87-117):

{ mimeType, videoBitsPerSecond: round(tier * bitrateScale * (vp8 ? 1.3 : 1)), videoKeyFrameIntervalDuration: 2000 }
  • For a video/mp4 MIME containing avc1.xxxxxx, the codec is rewritten to pickMobileSafeAvcCodec(track W, H): 64002A, 640033 or 640034. The rewrite is kept only if isTypeSupported.
  • The avc1.42E01E Safari candidate is also rewritten.
  • W, H and fps come from track.getSettings().

Quality settings (web-recorder-dialog/recording-quality.ts, PR):

Setting Value
Default screenHeight 1080, frameRate 30, cameraHeight 1080, level standard
Screen height options 1080 / 1440 / 2160
fps options 30 / 60
Camera height options 720 / 1080
qualityBitrateScale high = 1.6, standard = 1
Storage localStorage "cap-web-recorder-quality"

Capture constraints (capture-streams.ts): { frameRate: { ideal: q.frameRate ?? 30 }, width: { ideal: round(h*16/9) }, height: { ideal: h } }. DEFAULT_CAMERA_QUALITY is 1080@30.

useWebRecorder (PR):

  • The display recorder uses recorderOptions(pipeline.mimeType, mixedStream.getVideoTracks()[0], isSupported, qualityBitrateScale(quality), recordingMode === "camera" ? "camera" : "screen") (lines 1753-1762 of the PR file).
  • The separate camera recorder records a video-only stream with "cameraOverlay" (lines 1764-1775).
  • selectPairedCameraPipeline (lines 77-93): if the display pipeline is buffered-raw MP4 (Safari), the camera uses video/webm;codecs=vp8 in streaming mode, so the 1.3 VP8 scale applies.
  • Timeslice: start(1000) for streaming, else start(200). The camera recorder uses start(1000).

Worked videoBitsPerSecond:

Content Scale 1280x720@30 1920x1080@30 1920x1080@60 3840x2160@30
screen standard 2,500,000 4,000,000 6,000,000 10,000,000
screen high (1.6) 4,000,000 6,400,000 9,600,000 16,000,000
camera standard 2,600,000 4,500,000 6,750,000 10,000,000
camera high (1.6) 4,160,000 7,200,000 10,800,000 16,000,000
cameraOverlay standard 2,000,000 3,500,000 5,250,000 8,000,000
cameraOverlay high (1.6) 3,200,000 5,600,000 8,400,000 12,800,000
cameraOverlay, VP8 (Safari camera) standard 2,600,000 4,550,000 6,825,000 10,400,000

At 2560x1440@30 (the PR's 1440 option), screen standard is 6,000,000.

Observed Chrome 148 behaviour on Linux (verified, canvas source, 1280x720, 2,500,000 bit/s, avc1.64002A, 2 s keyframes):

Property Observed
Reported recorder.mimeType video/mp4;codecs=avc1.640020. Chrome picked level 3.2 itself.
Profile High
B-frames has_b_frames=0
Colour tags smpte170m, tv range
Container Fragmented MP4: ftyp, moov, then moof/mdat per 1 s timeslice
Timestamps VFR (avg 29.8 fps)
Keyframes At 0, 2.03 and 4.06 s, plus extra encoder-chosen IDRs on scene changes
Achieved rate 1.94 Mbit/s on synthetic content
Supported withAudio MIME avc1.64002A,opus (no AAC)

Server step:

  • PR media server: H.264 at or below 1080p and level 4.2 has its video copied; Opus audio is transcoded to AAC 128k.
  • 1440p and 2160p captures are transcoded down to 1080p with MS-TRANSCODE. The PR process-video still passes no size options.
  • Render-farm sources from these recordings usually take the remux path, because they have 2 s keyframes and no B-frames.

Reproduction on Linux (Playwright, Google Chrome, fake-camera track from in.y4m; see section 9):

// BR-MR-PR-SCREEN at 1920x1080@30, standard
new MediaRecorder(stream, { mimeType: 'video/mp4;codecs="avc1.64002A,opus"', videoBitsPerSecond: 4000000, videoKeyFrameIntervalDuration: 2000 }); rec.start(1000);
// BR-MR-PR-CAMERA at 1920x1080@30: videoBitsPerSecond 4500000
// BR-MR-PR-OVERLAY at 1920x1080@30: videoBitsPerSecond 3500000
// 3840x2160: mimeType 'video/mp4;codecs="avc1.640033,opus"' (only if isTypeSupported), bitrate per table

8.2 Chrome extension (PR)

recorder.ts lines 1318-1340 (PR):

  • recorderOptions(pipeline.mimeType, recordingStream.getVideoTracks()[0], isSupported, 1, request.mode === "camera" ? "camera" : "screen") for the main track.
  • "cameraOverlay" for the camera track.
  • Timeslice 1000.

The bitrates match the standard rows of the table in section 8.1.

8.3 BR-MR-CLIP-PR: editor clip recorder

Location: apps/web/lib/editor-clip-recorder.ts.

  • new MediaRecorder(stream, { mimeType }), with the MIME from selectRecordingPipelineFromSupport.
  • No bitrate or keyframe option.
  • start(1000).
  • In Chrome this records avc1.64002A streaming MP4 at the Chrome default (2.5 Mbps).

Reproduction: new MediaRecorder(stream, { mimeType: 'video/mp4;codecs="avc1.64002A,opus"' }); rec.start(1000).

8.4 BR-WC-EXPORT-PR: browser local export (WebCodecs)

Locations (PR):

  • packages/editor-solid-web/src/browser-export-worker.ts lines 779-806
  • browser-export-encoder.ts
  • browser-export-estimate.ts
  • browser-export-audio.ts
  • browser-local-export.ts

Job inputs:

  • fps is clamped to 1-120.
  • bitsPerPixel is custom_bpp or COMPRESSION_BPP: Maximum 0.3, Social 0.15, Web 0.08, Potato 0.04.
  • optimize_filesize, GIF and cursor-only exports are not handled locally and go to the server.

Constants:

Constant Safari Other browsers
HOLDS_QUALITY_FRAMES true false
KEYFRAME_SECONDS 5 2
BITRATE_SCALE 1.35 1

Config, literal:

const bitrate = Math.round(exportBitrate(width, height, job.fps, job.bitsPerPixel) * BITRATE_SCALE);
// guarded by mediabunny canEncodeVideo("avc", { width, height, bitrate })
const encoderConfig: VideoEncoderConfig = {
  codec: avcCodecString(width, height, bitrate),
  width, height, bitrate,
  framerate: job.fps,
  latencyMode: HOLDS_QUALITY_FRAMES ? "realtime" : "quality",
  hardwareAcceleration: "prefer-hardware",
  alpha: "discard",
  avc: { format: "avc" },
};

Codec string (avcCodecString): avc1.6400LL, where LL is the first entry of AVC_LEVELS with ceil(W/16)*ceil(H/16) <= maxMacroblocks and bitrate <= maxBitrate. The table mirrors mediabunny.

Frames and keyframes:

  • VideoFrame timestamp is trunc(frame/fps*1e6), and duration is trunc(1e6/fps). This is CFR.
  • A keyframe is requested when floor(frame/fps/KEYFRAME_SECONDS) changes: every 2 s, or every 5 s on Safari.
  • Up to 4 frames are queued in the encoder.

Container and audio:

  • Mp4OutputFormat({ fastStart: file ? "reserve" : "in-memory" }). Either way the moov is at the front.
  • Packets are re-stamped frame/fps.
  • Audio: 48 kHz stereo, AAC at EXPORT_AUDIO_BITRATE = 320,000 if canEncodeAudio, else Opus.

Fallback:

  • An error before the first progress message becomes BrowserLocalExportUnavailable.
  • tauri-bridge.ts lines 248-271 then switches to the server export (section 8.6).
  • In headless Linux Chrome, isConfigSupported with prefer-hardware returns unsupported (verified), so the PR as written falls back to the server there.

Worked values (non-Safari, Maximum 0.3):

1280x720@30 1920x1080@30 1920x1080@60 3840x2160@30
Bitrate 8,294,400 18,662,400 29,859,840 74,649,600
Codec avc1.64001F avc1.640028 avc1.640029 avc1.640033

Codecs at Social, Web and Potato: 64001F, 640028, 640028, 640033.

Safari at Maximum (×1.35): 11,197,440 / 25,194,240 / 40,310,784 / 100,776,960.

K is 60 at 30 fps and 120 at 60 fps (Safari: 150 at 30 fps).

Reproduction on Linux (Playwright, Google Chrome; substitute hardwareAcceleration):

VideoEncoder.configure({
  codec: "avc1.640028",
  width: 1920,
  height: 1080,
  bitrate: 18662400,
  framerate: 30,
  latencyMode: "quality",
  hardwareAcceleration: "no-preference",   // production: "prefer-hardware"
  alpha: "discard",
  avc: { format: "avc" },
})
// encode(frame, { keyFrame: Math.floor(i/30/2) !== Math.floor((i-1)/30/2) || i === 0 })

Observed Chrome 148 software path on Linux (verified, 1280x720, avc1.640028 requested, 4,976,640 bit/s):

  • avcC profile_idc 100 with constraint byte 0x0C (Constrained High).
  • level_idc 31, not the requested 0x28.
  • No B-frames.
  • Requested keyframes were honoured, with extra encoder-inserted IDRs on scene changes.

8.5 BR-WC-AUDIO2VIDEO-PR: audio-only to video

Location: apps/web/lib/audio-to-video.ts.

// 1280x720 canvas
new Mp4OutputFormat({ fastStart: "in-memory" })
new CanvasSource(canvas, { codec: "avc", bitrate: 150_000, keyFrameInterval: 60, latencyMode: "realtime" })
// frameRate 1
// audio: AAC (Opus if unsupported) at 160_000
  • Codec: avc1.64001F (mediabunny).
  • Keyframe interval: 60 s, which is 60 frames at 1 fps.

Reproduction:

VideoEncoder.configure({
  codec: "avc1.64001F",
  width: 1280,
  height: 720,
  bitrate: 150000,
  framerate: 1,
  latencyMode: "realtime",
  hardwareAcceleration: "no-preference",
  avc: { format: "avc" },
})

Set keyFrame every 60th frame.

8.6 Server export and web Save (PR)

Server export:

  • apps/media-server/src/lib/editor-exports.ts validates settings with zod (fps 1-60, x ≤ 3840, y ≤ 2160, custom_bpp ≤ 1, optimize_filesize optional).
  • It spawns the native export binary (crates/export/src/bin/web-editor.rs export(), lines 512-566).
  • That binary clamps fps to 1..=60, caps size at 3840x2160, sets force_ffmpeg_decoder = true, and calls Mp4ExportSettings.export.
  • So it is identical to section 5: on a Linux server, DESK-EXPORT-X264-* by default, DESK-EXPORT-CRF-* with optimize file size, and NVENC p5 if /dev/nvidiactl exists.

Web Save (apps/web/lib/render-farm-start.ts):

Setting Value
Resolution SAVE_RESOLUTION = [1920, 1080]
fps clamp(round(fps ?? 30), 24, 60)
Format Mp4
Compression Maximum
custom_bpp null
  • Rendered by RF-RENDER-NVENC in production.
  • At 30 fps: B = 18,662,400, M = 27,993,600, K = 60. At 60 fps: B = 29,859,841, K = 120.
  • The fallback worker save uses the same workerSaveSettings without optimize_filesize, so it has no faststart.

8.7 PR-PREVIEW-X264: live editor preview stream

Locations:

  • crates/editor/src/bin/web-editor-service/preview_h264.rs
  • web-editor-service.rs (default preview_fps 60 at line 1255; bpp 18/100 at line 990; {"bitrate":"low"} gives 4/100 and {"bitrate":"high"} gives 18/100, lines 1053-1056)

Configuration:

  • VideoInfo: RGBA, time_base 1/1_000_000, frame_rate fps/1.
  • Validation: fps 1..=60, bpp 0.04..=0.18.
  • Builder: .with_bpp(bpp).with_encoder_priority_override(&["libx264"]).build_standalone().
  • Preset is the builder default Ultrafast in non-export mode, giving preset=ultrafast, tune=zerolatency, g=K, keyint_min=K.

Encoder settings:

Setting Value
Rate control ABR at B, maxrate ignored
GOP 2*fps, so 120 at the default 60 fps
Profile Constrained Baseline (verified)
Colour BT.709 limited, from RGBA via swscale
Output Raw AVC packets with avcC description, sent to the browser decoder. There is no container.

Worked B:

Resolution bpp 0.18 bpp 0.04
1280x720@60 7,962,624 1,769,471
1920x1080@60 17,915,904 3,981,311

Reproduction on Linux (verified at 720p30):

ffmpeg -y -f rawvideo -pix_fmt yuv420p -s WxH -r FPS -i in.yuv \
  -c:v libx264 -preset ultrafast -tune zerolatency -threads N -b:v B -maxrate M -g K -keyint_min K \
  -pix_fmt yuv420p -colorspace bt709 -color_primaries bt709 -color_trc bt709 -color_range tv \
  -an -f h264 preview.h264

The production defaults are FPS=60, K=120 and bpp 0.18.

8.8 PR media server and render farm changes

media-video.ts (PR):

  • getOrientedLimits swaps the max width and height for portrait sources, so the limit becomes 1080x1920.
  • Level selection uses the long and short edge.
  • AUDIO_RUN_ARGS = ["-chunk_duration", "1000000"] is appended after +faststart when audio is present, and in muxMediaTracksToMp4.
  • Video encoder arguments are unchanged.

Render farm (PR):

  • transcode.ts only adds downloadSource.
  • worker.ts line 721 keeps RF_TRANSCODE_ENCODER ?? "h264_nvenc".
  • protocol.ts adds a CursorTask that runs the external cap-cursor-service binary. Its encoding settings are not in this repo.

9. Running browser surfaces in headless Chrome with Playwright

  1. Use Google Chrome, not Playwright's bundled Chromium, which lacks proprietary H.264/MP4 support:
    chromium.launch({ executablePath: "/usr/local/bin/google-chrome", args: [...] })
    
    channel: "chrome" also works.
  2. Feed the source frames:
    • MediaRecorder: convert the raw input to y4m and use it as the fake camera:
      ffmpeg -f rawvideo -pix_fmt yuv420p -s WxH -r FPS -i in.yuv -f yuv4mpegpipe in.y4m
      
      Launch with --use-fake-device-for-media-stream --use-fake-ui-for-media-stream --use-file-for-fake-video-capture=/abs/in.y4m. Then call getUserMedia({ video: { width: { exact: W }, height: { exact: H }, frameRate: { exact: FPS } } }). The fake device loops the file. Content type changes only the bitrate tier, so the same track works for the screen, camera and overlay variants.
    • WebCodecs: serve in.yuv over HTTP. Slice W*H*3/2 bytes per frame and build:
      new VideoFrame(buf, { format: "I420", codedWidth: W, codedHeight: H, timestamp: Math.trunc(i/FPS*1e6), duration: Math.trunc(1e6/FPS) })
      
  3. Replace hardwareAcceleration: "prefer-hardware" with "no-preference" or "prefer-software". Headless Linux Chrome 148 reports prefer-hardware unsupported, while no-preference and prefer-software (OpenH264) work. This changes the encoder compared with production on Windows/macOS.
  4. Linux Chrome supports neither AAC in MediaRecorder nor AAC in AudioEncoder. Use the ,opus MIME variants, or video-only.
  5. Avoid --dump-dom --virtual-time-budget for encoder probes. Virtual time stalls the encoders. Post results from the page to a local HTTP endpoint instead (used here: about 8 s per probe).

10. Ambiguities and assumptions

  • Media-server ffmpeg version: oven/bun:1.4.0 plus apt ffmpeg is unpinned. It is probably Debian's 5.1.x but not verified. Verification here used 6.1.1. The x264 presets and the fps_mode auto choice of CFR for MP4 are expected to match.
  • Media-server output frame rate: for VFR WebM input, the output rate is whatever ffmpeg guesses (r_frame_rate, often the stream's nominal 30/1 or a 1000/1 time base fallback). The repro uses the raw input rate.
  • VideoToolbox GOP of 12 comes from the FFmpeg 7.1 source (AVCodecContext gop_size default, vt_defaults). It is not observed on a Mac. The FFmpeg version linked into the desktop app was not checked.
  • NVENC, QSV, AMF, Media Foundation and AVFoundation: B-frames, profile, level, VBV and lookahead not set by Cap come from encoder or preset defaults. These were not observed.
  • Rust f32 model: f32-to-f64 rounding makes some values 1-3 bit/s off the browser model. Benchmarks should use the Rust values for Rust surfaces.
  • getDisplayMedia and getUserMedia use ideal constraints, so actual capture size and fps may differ. The PR bitrate uses track.getSettings(), so it follows the actual size.
  • Chrome MediaRecorder chooses its own H.264 level (it reported avc1.640020 for 720p) and inserts scene-change IDRs. On Windows/macOS Chrome uses platform hardware encoders, whose output will differ from Linux OpenH264.
  • Chromium default WebCodecs bitrate comes from the Chromium source. The probe's achieved rate on synthetic content was dominated by scene-change IDRs, so it is not evidence either way.
  • The video/mp4 MIME without codecs (web tools) leaves the codec choice to the browser.
  • Instant-mode output size on desktop is clamped to fit within (max, max*9/16). The free/Pro limit comes from the account, which is outside the encoder code.
  • cap-cursor-service (PR cursor-only render) is an external binary whose encoding is unknown.
  • libx264 dictionary keys: the "ignored" list is based on FFmpeg option names and on observed ref=1 in the output. A different FFmpeg build linked into the desktop app could accept other aliases. This was not checked.

11. Summary table

surface encoder rate control GOP preset/tune profile/level container repro command id
Media server processVideo (non-H.264, >1080p or level too high) libx264 CRF 23, no cap x264 default 250/25, scenecut; -bf 0 for VP8/VP9 source, else 3 B-frames medium / none High / forced 4.2 (5.1, 5.2 above 2048x1088) MP4 +faststart, CFR (auto), AAC 128k MS-TRANSCODE, MS-TRANSCODE-VPX
Media server level fix (dormant) copy + h264_metadata n/a source n/a level rewritten MP4 +faststart MS-LEVELFIX
Media server edit render libx264 CRF 18 250/25, 3 B-frames fast / none High / auto MP4 +faststart, CFR via fps filter, AAC 160k MS-EDIT
Web Loom download fallback libx264 CRF 23 (default) 250/25, 3 B-frames veryfast / none High / auto MP4 +faststart, AAC 128k WEB-LOOM-FFMPEG
Render farm render (production) h264_nvenc VBR B, max 1.5B (bpp model, default Maximum 0.3) 2*fps, forced IDR, bf 0 p1 / hq, spatial+temporal AQ encoder default Custom MP4 (moov first) or fMP4 HLS 2 s, AAC 320k RF-RENDER-NVENC
Render farm render (override) libx264 ABR B, maxrate ignored 2*fps, min fps+1, bf 0 veryfast (ref 1, rc-lookahead 10) High / auto as above RF-RENDER-X264
Render farm source transcode (production) h264_nvenc VBR CQ 19, b:v 0 forced IDR every 1 s, bf 0 p1 / none encoder default MP4 +faststart, VFR passthrough, no audio RF-TRANSCODE-NVENC
Render farm source transcode (override) libx264 CRF 18 forced every 1 s plus 250/25, bf 0 veryfast / none High / auto MP4 +faststart, VFR passthrough RF-TRANSCODE-X264
Desktop recording Linux (Balanced/Compat/Instant) libx264 (h264_nvenc p4/ll if /dev/nvidiactl) ABR B at bpp 0.3, maxrate ignored 2*fps, min fps+1, scenecut 0, bf 0 ultrafast / zerolatency Constrained Baseline / auto (3.2 at 720p30) DASH fMP4 2 s + HLS playlists, VFR, AAC 320k DESK-REC-X264
Desktop recording Linux Ultra libx264 ABR B at bpp 0.3 2*fps, min fps+1, bf 0 veryfast / zerolatency auto DASH fMP4 2 s DESK-REC-X264-ULTRA
Desktop recording macOS fragmented (default) h264_videotoolbox (libx264 fallback) ABR B (bpp 0.3 / 1.0 Ultra / 0.15 Compat or Instant), DataRateLimits 1.5B per s 12 frames (not set), no B-frames realtime, prio_speed Main / AutoLevel DASH fMP4 2 s, VFR DESK-REC-VT (not runnable)
Desktop recording macOS non-fragmented and camera AVFoundation AverageBitRate (Balanced/Ultra/Compat/Instant formulas) floor(0.75*fps); reordering only Ultra n/a AVFoundation default MP4 (AVAssetWriter) DESK-REC-AVF (not runnable)
Desktop recording Windows fragmented (default) nvenc/mf/qsv/amf, then libx264 VBR B (bpp 0.3 / 1.0 Ultra / 0.15 Instant), max 1.5B 2*fps NVENC p4/ll; QSV faster; AMF balanced vbr_latency; MF scenario 4 encoder default DASH fMP4 2 s DESK-REC-WIN-HW (not runnable)
Desktop recording Windows non-fragmented Media Foundation AVG_BITRATE, fps fixed 30, multiplier 0.15 (0.3 Ultra) MFT default MFT default MFT default MP4, CFR 30 DESK-REC-WINMF (not runnable)
Desktop export (default, Linux or software) libx264 ABR B: 0.3 / 0.15 / 0.08 / 0.04 2*fps, min fps+1, bf 0 veryfast (ref 1, rc-lookahead 10, trellis 0) High / auto MP4, moov at end, CFR, AAC 320k DESK-EXPORT-X264-{Maximum,Social,Web,Potato}
Desktop export, Optimize file size libx264 CRF 24 / 28 / 32 / 36 2*fps, min fps+1, 3 B-frames slow / none High / auto MP4 +faststart DESK-EXPORT-CRF-{24,28,32,36}
Desktop export macOS h264_videotoolbox ABR B, DataRateLimits 1.5B 12 frames (not set) realtime false, allow_sw 0 Main / AutoLevel MP4, moov at end DESK-EXPORT-VT (not runnable)
Desktop export Windows/Linux NVIDIA h264_nvenc VBR B, max 1.5B 2*fps p5 / hq, b_ref_mode middle, AQ encoder default MP4, moov at end DESK-EXPORT-NVENC (not runnable)
Desktop export QSV / AMF / MF h264_qsv / h264_amf / h264_mf VBR(-peak) B, max 1.5B 2*fps medium la 20 / quality vbr_peak / scenario 0 quality 0 encoder default MP4, moov at end DESK-EXPORT-QSV, -AMF, -MF (not runnable)
Web recorder main, Chrome MediaRecorder VP9 (H.264 made by MS-TRANSCODE-VPX) browser default 2.5 Mbps 2 s requested n/a VP9 WebM streaming, 1 s slices BR-MR-MAIN
Web recorder main, Safari/Firefox MediaRecorder H.264 browser default 2 s requested n/a avc1.42E01E / 4d401e requested MP4 buffered, 200 ms slices BR-MR-MAIN-MP4
Chrome extension main MediaRecorder VP9 browser default browser default n/a VP9 WebM, 1 s slices BR-MR-EXT-MAIN
Web tools (speed, trim) MediaRecorder 5,000,000 browser default n/a browser choice for video/mp4 MP4 or WebM BR-MR-TOOLS
Comment media / format converter WebCodecs via Remotion none (Chromium default formula; Safari 3M) 40 frames prefer-hardware, then software 0x64, level table; clamp to 64002A/640033/640034 for comments MP4 (AAC) BR-WC-REMOTION
Loom browser conversion WebCodecs via mediabunny QUALITY_HIGH (2.778M / 6M / 22.393M) 2 s prefer-hardware, latency quality 6400LL from mediabunny table MP4 moov at end, AAC 128k BR-WC-MEDIABUNNY-LOOM
PR web recorder screen/camera/overlay MediaRecorder H.264 tier bit/s × 1.5 above 40 fps × 1.6 high × 1.3 VP8 2 s requested n/a avc1.64002A / 640033 / 640034 (Chrome picks actual level) fragmented MP4 streaming, 1 s slices BR-MR-PR-SCREEN, -CAMERA, -OVERLAY
PR editor clip recorder MediaRecorder H.264 browser default browser default n/a avc1.64002A fragmented MP4, 1 s slices BR-MR-CLIP-PR
PR browser export WebCodecs bpp model × (Safari 1.35) 2 s (Safari 5 s) prefer-hardware, latency quality (Safari realtime) avc1.6400LL from table MP4 moov first, AAC 320k or Opus BR-WC-EXPORT-PR
PR audio-to-video WebCodecs via mediabunny 150,000 60 frames at 1 fps latency realtime avc1.64001F MP4 moov first, audio 160k BR-WC-AUDIO2VIDEO-PR
PR editor preview stream libx264 ABR bpp 0.18 (low 0.04) 2*fps (120 at 60 fps), min fps+1 ultrafast / zerolatency Constrained Baseline / auto raw AVC packets PR-PREVIEW-X264
PR server export as desktop export as desktop export as desktop export as desktop export as desktop export MP4 DESK-EXPORT-X264-, DESK-EXPORT-CRF-
PR web Save as render farm render, 1920x1080 Maximum, fps 24-60 VBR B, max 1.5B 2*fps p1 / hq encoder default Custom MP4 or fMP4 HLS RF-RENDER-NVENC