# Difference Between Preview (CRF 22), Draft (CRF 28), and Final (CRF 20) Render Modes

> Understand the differences between preview CRF 22, draft CRF 28, and final CRF 20 render modes in video-use. Balance speed and visual fidelity with these quality presets.

- Repository: [Browser Use/video-use](https://github.com/browser-use/video-use)
- Tags: deep-dive
- Published: 2026-07-03

---

**The video-use rendering pipeline offers three quality presets—Draft (CRF 28), Preview (CRF 22), and Final (CRF 20)—that differ in resolution, encoder preset, and constant rate factor values hard-coded in [`helpers/render.py`](https://github.com/browser-use/video-use/blob/main/helpers/render.py) to balance speed against visual fidelity.**

The `browser-use/video-use` repository processes video through an `extract → concat → composite` workflow, supporting **preview**, **draft**, and **final render modes** selectable via command-line flags. Each mode configures FFmpeg parameters differently to match specific quality assurance needs, from quick boundary verification to production-ready output.

## The Three-Step Rendering Pipeline

Video-use processes source material through a consistent pipeline regardless of quality mode. The workflow extracts individual segments, concatenates them sequentially, and applies final compositing with color grading, 30ms audio fades, and optional HDR tone-mapping.

The **render modes** only affect the encoding parameters in the extraction and final compositing stages. All modes process the same visual effects; they differ only in resolution scaling, encoder preset speed, and **CRF** (Constant Rate Factor) values that control compression efficiency.

## Technical Comparison of Render Modes

Source code in [`helpers/render.py`](https://github.com/browser-use/video-use/blob/main/helpers/render.py) (lines 66-70) defines the quality ladder for each mode, while the final compositing stage (lines 61-62) applies additional quality constraints for production output.

### Draft Mode (CRF 28)

**Draft mode** prioritizes encoding speed over visual quality for rapid cut-point verification. When invoked with the `--draft` flag, the `extract_segment` function renders segments at **720p** resolution using `scale=-2:1280` for landscape or `scale=1280:-2` for portrait orientations.

This mode uses the `ultrafast` encoder preset with **CRF 28**, producing the smallest files and fastest encodes. The lower quality suffices for checking segment boundaries and rough timing without waiting for high-fidelity processing.

### Preview Mode (CRF 22)

**Preview mode** generates 1080p output at **CRF 22** using the `medium` encoder preset, offering a balance between quality and speed suitable for quality-control review. Activated with the `--preview` flag, this mode uses the same 1080p scaling parameters as final renders (`scale=-2:1920` for landscape, `scale=1920:-2` for portrait).

The **CRF 22** setting delivers near-final visual quality while maintaining reasonable encoding speeds, making it ideal for client review or internal approval before committing to the slower final render.

### Final Mode (CRF 20)

**Final mode** produces production-ready output through a two-stage quality process. Individual segment extraction uses **CRF 20** with the `fast` preset at 1080p resolution, as defined in `extract_segment` at lines 66-70.

The `build_final_composite` function (lines 61-62) then applies a stricter **CRF 18** for the merged output, ensuring maximum visual fidelity for the published video. This mode runs by default when neither `--draft` nor `--preview` flags are specified.

## Source Code Implementation

The quality parameters live in [`helpers/render.py`](https://github.com/browser-use/video-use/blob/main/helpers/render.py), where the `extract_segment` logic handles per-clip encoding:

- Lines 66-70 implement the quality ladder, mapping CLI flags to resolution scales, presets, and CRF values
- Lines 61-62 in `build_final_composite` enforce the final CRF 18 pass for the assembled video

All three modes share identical color grading and audio processing; only the FFmpeg encoding parameters differ.

## Command-Line Usage Examples

Invoke specific modes using flag arguments to [`helpers/render.py`](https://github.com/browser-use/video-use/blob/main/helpers/render.py):

```bash

# Draft mode: 720p, ultrafast, CRF 28

python helpers/render.py my_edl.json -o draft.mp4 --draft

# Preview mode: 1080p, medium preset, CRF 22

python helpers/render.py my_edl.json -o preview.mp4 --preview

# Final mode: 1080p extraction (CRF 20) + final composite (CRF 18)

python helpers/render.py my_edl.json -o final.mp4

```

Additional processing flags work consistently across all modes:

```bash

# Final mode with subtitles and loudness normalization

python helpers/render.py my_edl.json -o final.mp4 --build-subtitles

```

## Summary

- **Draft mode** (`--draft`): 720p resolution, `ultrafast` preset, **CRF 28**—fastest encoding for timeline verification
- **Preview mode** (`--preview`): 1080p resolution, `medium` preset, **CRF 22**—balanced quality for review cycles
- **Final mode** (default): 1080p extraction at **CRF 20** with `fast` preset, followed by final composite at **CRF 18**—maximum quality for publication
- All modes process identical color grades and audio fades; only encoding parameters differ in [`helpers/render.py`](https://github.com/browser-use/video-use/blob/main/helpers/render.py)

## Frequently Asked Questions

### What is CRF and why do the render modes use different values?

**CRF** (Constant Rate Factor) is a rate-control mode that maintains consistent visual quality across variable bitrates. Lower values indicate higher quality and larger file sizes. Draft mode uses **CRF 28** for speed, Preview uses **CRF 22** for balanced quality, and Final mode uses **CRF 20** (and **CRF 18** for the composite) to maximize fidelity for delivery.

### When should I use draft mode instead of preview mode?

Use **draft mode** when verifying cut points, testing segment boundaries, or checking rough timing, as the 720p resolution and `ultrafast` preset complete encoding in minimal time. Switch to **preview mode** when you need 1080p clarity for color checking or client approval, accepting the longer encode time for better visual accuracy.

### Why does final mode use two different CRF values?

The **final mode** applies **CRF 20** during the initial per-segment extraction phase to balance quality and processing speed, then applies a stricter **CRF 18** during the `build_final_composite` stage (lines 61-62 of [`helpers/render.py`](https://github.com/browser-use/video-use/blob/main/helpers/render.py)). This two-pass approach ensures the assembled video meets broadcast quality standards without re-encoding source material at maximum quality unnecessarily.

### Can I customize the CRF values or encoder presets?

The current implementation hard-codes CRF values and presets in [`helpers/render.py`](https://github.com/browser-use/video-use/blob/main/helpers/render.py) (lines 66-70). To modify quality settings, you must edit the source code directly in the `extract_segment` and `build_final_composite` functions, as no CLI flags expose these parameters for runtime adjustment.