Open source Loom alternative. Beautiful, shareable screen recordings.
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
- Conventions and shared facts
- Media server
- Web app server-side ffmpeg
- Render farm
- Desktop recording
- Desktop export
- Web recorders on
main(MediaRecorder) - Browser WebCodecs encoders on
main - PR 2312 differences
- Running browser surfaces in headless Chrome with Playwright
- Ambiguities and assumptions
- 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 tof64, and the result is truncated tousize. That gives slightly odd values, for example 29,859,841. - PR browser export: uses JavaScript
f64withMath.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 intendedref 2never applies. subme 2andtrellis 0happen to equal the veryfast defaults.b-adaptis irrelevant becausebf 0.
Two more x264 behaviours, both verified:
maxrateis ignored. Cap setsrc_max_rate(M) but never setsrc_buffer_size. x264 logsVBV maxrate specified, but no bufsize, ignored, so every Cap libx264 bitrate encode is plain ABR (rc=abr, no VBV).keyint_minis clamped. Cap setskeyint_min = K. x264 clamps it toK/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)andmax_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_ENCODERset to1,true,yesoronforceslibx264(line 1192).requires_software_encoder(line 1062) never applies to exports. For recordings it forceslibx264when:- the preset is
HighThroughput, or - on macOS/Windows, FPS is above 0.9 times the estimated hardware maximum.
- the preset is
- 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_defaultsonly setsb,qminandqmax, sogop_sizekeeps the AVCodecContext default of 12.- Because Cap never sets
gfor VideoToolbox,MaxKeyFrameInterval = 12frames. This is not 2 s. max_b_framesdefaults to 0, soAllowFrameReordering = false(no B-frames).profile=mainmaps tokVTProfileLevel_H264_Main_AutoLevel.rc_max_ratemaps tokVTCompressionPropertyKey_DataRateLimitsas[M/8 bytes, 1 s].
NVENC:
gis set by Cap.bfstays at -1, meaning the preset decides.refsstays at 0 (default).rc-lookaheadandbufsizeare 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 autopicks 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 0before-an. This is the variant that applies to Chrome WebM recordings onmain. - 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:
fpsis the probedmetadata.fps.getOutputFps(fps) = min(120, max(1, round(fps*100)/100)), orDEFAULT_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_ENCODERdefaults to"libx264"(crates/render-farm/src/video.rsline 425). Production sets NVENC through the Dockerfile. - There is no automatic NVENC to libx264 fallback.
- If NVENC is unavailable,
find_by_namefails ("{encoder_name} unavailable"). RF_REQUIRE_GPUchecks atvideo.rslines 257 and 364 fail fast without a GPU.- libx264 is used only when
RF_ENCODERis 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=8294at 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) writesftyp(majorisom, minor0x200, brandsisom iso2 avc1 mp41), thenmoov,free,mdat. The moov is up front.- Video timescale is
fps*1000and sample delta is 1000 (CFR). - The
avc1entry (line 584) carriescolr nclx 1/1/1/0andpasp.
- HLS (
RF_HLSis on unless it is"0";RF_HLS_SEGMENT_SECONDSdefaults to 2;coordinator.tslines 94-95):- Segments are fMP4 with
init.mp4(line 1981) plusstyp+moof+mdat.m4sfiles. - Segment keys are
${prefix}/c${chunk}-p${firstPart}-${index}.m4s(hls.tsline 40). segmentFrames = round(fps*2)(line 1087).- The playlist (
fmp4.tslines 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.
- Segments are fMP4 with
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
-maxrateis 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
yuv420phas_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 passthroughkeeps the source VFR timestamps. - Colour: passed through.
- Container: MP4
+faststart, video only. - Hardware decode:
-hwaccel cudadecodes on the GPU but frames are downloaded (no-hwaccel_output_format), so-pix_fmt yuv420papplies.
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
Compatibilityif total RAM is under 16 GiB, elseBalanced.Ultrais opt-in. - Instant mode clamps the output to fit
(max, max*9/16): 1280x720 for free users, 1920x1080 for Pro (instant_recording.rslines 719-734).
Timestamps (all enc-ffmpeg recording paths):
VideoInfo.time_base = 1/1_000_000(crates/media-info/src/lib.rslines 47, 58, 89).update_pts(crates/enc-ffmpeg/src/base.rslines 76-104) setspts = round(capture_ts_secs * 1e6) - first_pts.- So output is VFR, following capture timestamps.
frame_rateis 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 useSegmentedVideoEncoder. prefer_videotoolbox_hw_inputis true for screen (macos_fragmented_m4s.rsline 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:
MacOSFragmentedM4SMuxerwith 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):
SegmentedVideoEncoderwith 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.rsline 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_amfwithquality=balanced,rc=vbr_latencyfirst) - 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) iscustom_bppif set, else the map.VideoInfois NV12 withtime_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, pluswith_crf(crf)ifoptimize_filesize. - The builder preset stays at its default
Ultrafast, which selects the libx264 "fast" set. - Container:
MP4File::init("output", path, self.optimize_filesize, ...).+faststartis written only whenoptimize_filesizeis true (crates/enc-ffmpeg/src/mux/mp4.rslines 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.tsxlines 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.rsget_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
gis 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.tspackages/recorder-core/src/recorder-utils.tsapps/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):
- WebM is supported and
preferStreamingUpload !== false: modestreaming-webm. - Otherwise the first supported MP4 candidate: mode
buffered-raw. - 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.tsconvertToMp4(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)withRECORDING_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.tslines 25-32:convertMedia({ container: "mp4", videoCodec: "h264", audioCodec: "aac" })withinstallAvcLevelClamp()active. It skips conversion when the input is already MP4 orcanConvertToMp4InBrowser(probeavc1.42E01F1280x720 plus AAC) fails.apps/web/components/tools/MediaFormatConverter.tsxlines 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. keyFrameIntervaldefaults to 2 s, by timestamp.latencyModedefaults to quality.- Codec is
avc1.6400LLfrom 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-ffmpegcrates/export/src/mp4.rscrates/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.42E01Elist), else buffered WebM. getMediaRecorderOptionsis 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/mp4MIME containingavc1.xxxxxx, the codec is rewritten topickMobileSafeAvcCodec(track W, H):64002A,640033or640034. The rewrite is kept only ifisTypeSupported. - The
avc1.42E01ESafari 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 usesvideo/webm;codecs=vp8in streaming mode, so the 1.3 VP8 scale applies.- Timeslice:
start(1000)for streaming, elsestart(200). The camera recorder usesstart(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-videostill 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 fromselectRecordingPipelineFromSupport.- No bitrate or keyframe option.
start(1000).- In Chrome this records
avc1.64002Astreaming 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.tslines 779-806browser-export-encoder.tsbrowser-export-estimate.tsbrowser-export-audio.tsbrowser-local-export.ts
Job inputs:
- fps is clamped to 1-120.
bitsPerPixeliscustom_bpporCOMPRESSION_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:
VideoFrametimestamp istrunc(frame/fps*1e6), and duration istrunc(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 ifcanEncodeAudio, else Opus.
Fallback:
- An error before the first progress message becomes
BrowserLocalExportUnavailable. tauri-bridge.tslines 248-271 then switches to the server export (section 8.6).- In headless Linux Chrome,
isConfigSupportedwithprefer-hardwarereturns 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_idc100 with constraint byte0x0C(Constrained High). level_idc31, 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.tsvalidates settings with zod (fps 1-60, x ≤ 3840, y ≤ 2160,custom_bpp≤ 1,optimize_filesizeoptional).- It spawns the native
exportbinary (crates/export/src/bin/web-editor.rsexport(), lines 512-566). - That binary clamps fps to
1..=60, caps size at 3840x2160, setsforce_ffmpeg_decoder = true, and callsMp4ExportSettings.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/nvidiactlexists.
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
workerSaveSettingswithoutoptimize_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.rsweb-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, bpp0.04..=0.18. - Builder:
.with_bpp(bpp).with_encoder_priority_override(&["libx264"]).build_standalone(). - Preset is the builder default
Ultrafastin non-export mode, givingpreset=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):
getOrientedLimitsswaps 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+faststartwhen audio is present, and inmuxMediaTracksToMp4.- Video encoder arguments are unchanged.
Render farm (PR):
transcode.tsonly addsdownloadSource.worker.tsline 721 keepsRF_TRANSCODE_ENCODER ?? "h264_nvenc".protocol.tsadds aCursorTaskthat runs the externalcap-cursor-servicebinary. Its encoding settings are not in this repo.
9. Running browser surfaces in headless Chrome with Playwright
- 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. - Feed the source frames:
- MediaRecorder: convert the raw input to y4m and use it as the fake camera:
Launch withffmpeg -f rawvideo -pix_fmt yuv420p -s WxH -r FPS -i in.yuv -f yuv4mpegpipe in.y4m--use-fake-device-for-media-stream --use-fake-ui-for-media-stream --use-file-for-fake-video-capture=/abs/in.y4m. Then callgetUserMedia({ 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.yuvover HTTP. SliceW*H*3/2bytes per frame and build:new VideoFrame(buf, { format: "I420", codedWidth: W, codedHeight: H, timestamp: Math.trunc(i/FPS*1e6), duration: Math.trunc(1e6/FPS) })
- MediaRecorder: convert the raw input to y4m and use it as the fake camera:
- Replace
hardwareAcceleration: "prefer-hardware"with"no-preference"or"prefer-software". Headless Linux Chrome 148 reportsprefer-hardwareunsupported, whileno-preferenceandprefer-software(OpenH264) work. This changes the encoder compared with production on Windows/macOS. - Linux Chrome supports neither AAC in MediaRecorder nor AAC in
AudioEncoder. Use the,opusMIME variants, or video-only. - Avoid
--dump-dom --virtual-time-budgetfor 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.0plus aptffmpegis unpinned. It is probably Debian's 5.1.x but not verified. Verification here used 6.1.1. The x264 presets and thefps_mode autochoice 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_sizedefault,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
idealconstraints, so actual capture size and fps may differ. The PR bitrate usestrack.getSettings(), so it follows the actual size. - Chrome MediaRecorder chooses its own H.264 level (it reported
avc1.640020for 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/mp4MIME 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=1in 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 |