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

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 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 (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, 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:

# 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:

# 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

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). 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 (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.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}