How to Use video-use Color Grade Presets: warm_cinematic vs neutral_punch Explained

video-use provides built-in FFmpeg-based color grade presets including warm_cinematic for stylized teal-orange looks and neutral_punch for subtle contrast boosts, both defined in helpers/grade.py and accessible via CLI or Python API.

The browser-use/video-use repository ships with a curated set of color grade presets that apply professional film looks through automated FFmpeg filter chains. These presets allow you to transform flat footage into polished content without manual color grading. Understanding the differences between the creative warm_cinematic and corrective neutral_punch options helps you choose the right look for your video pipeline.

What Are video-use Color Grade Presets?

Color grade presets in video-use are pre-configured FFmpeg filter strings stored as Python dictionaries in helpers/grade.py. Each preset combines contrast, brightness, saturation, and curve adjustments into a single filter chain that processes your video frames.

The system exposes these presets through multiple interfaces:

• Programmatically: via the get_preset() function
• CLI: via the --preset <name> argument
• EDL workflows: via the grade field in edit decision lists

When you request a preset, helpers/render.py calls resolve_grade_filter() to fetch the exact FFmpeg filter string and inject it into the rendering pipeline.

warm_cinematic vs neutral_punch: Technical Comparison

Both presets operate within safe ranges (±12% contrast) but serve different creative purposes.

warm_cinematic Preset

The warm_cinematic preset creates a deliberate retro-cinematic aesthetic using a three-stage FFmpeg filter chain:

1. EQ adjustment: eq=contrast=1.12:brightness=-0.02:saturation=0.88
2. Color balance: colorbalance=rs=0.02:gs=0.0:bs=-0.03:rm=0.04:gm=0.01:bm=-0.02:rh=0.08:gh=0.02:bh=-0.05
3. Master curves: curves=master='0/0 0.25/0.22 0.75/0.78 1/1'

This combination produces the classic teal-orange split: warm shadows and cool highlights that mimic film stock. The contrast boost of 1.12 adds punch while the reduced saturation (0.88) prevents colors from feeling oversaturated.

Use this preset when you want a stylized, creative look that evokes cinematic drama rather than documentary realism.

neutral_punch Preset

The neutral_punch preset offers a subtle corrective boost without color temperature shifts:

1. EQ adjustment: eq=contrast=1.06:brightness=0.0:saturation=1.0
2. Master curves: curves=master='0/0 0.25/0.23 0.75/0.77 1/1'

Noticeably absent is the colorbalance filter. This preset maintains neutral color temperature while adding a gentle S-curve that lifts shadows and rolls off highlights. The modest 1.06 contrast increase adds depth to flat footage without introducing a creative tint.

Use this preset for content that needs enhancement but must retain accurate colors for later grading stages.

How the Presets Work Under the Hood

When you specify a preset name, helpers/grade.py returns the corresponding FFmpeg filter string. The apply_grade() function then executes FFmpeg with the -vf (video filter) flag set to this string.

The filter chain processes each frame sequentially:

• eq (equalizer): Adjusts global contrast, brightness, and saturation
• colorbalance (warm_cinematic only): Shifts RGB values in shadows, midtones, and highlights
• curves: Applies a control-point based remap to the luminance curve

In helpers/render.py, the resolve_grade_filter() function checks the EDL's grade field. If set to "warm_cinematic" or "neutral_punch", it calls get_preset() to retrieve the filter; if set to "auto", it triggers data-driven analysis; if "none", it bypasses grading entirely.

How to Apply Color Grade Presets

Using the Python API

Import the grading utilities directly to apply presets programmatically:

from pathlib import Path
from helpers.grade import get_preset, apply_grade

src = Path("raw_clip.mp4")
dst = Path("graded_clip.mp4")

# Retrieve the warm_cinematic filter string

filter_str = get_preset("warm_cinematic")

# Apply the grade to the video

apply_grade(src, dst, filter_str)

The get_preset() function returns the raw FFmpeg filter string, while apply_grade() handles the FFmpeg execution with proper input/output handling.

Using the Command Line Interface

Process single files directly from the terminal without writing Python scripts:

# Apply warm_cinematic look to a video

python helpers/grade.py source.mov -o graded.mov --preset warm_cinematic

# Apply neutral_punch for subtle enhancement

python helpers/grade.py flat_footage.mp4 -o enhanced.mp4 --preset neutral_punch

The CLI automatically validates the preset name against available options and prints the chosen filter chain before execution.

Via the Render Pipeline (EDL)

For batch processing workflows, specify the preset in your edit decision list:

edl_entry = {
    "src": "interview_clip.mp4",
    "grade": "neutral_punch",  # Preset name passed to resolve_grade_filter()

    "start": 0.0,
    "duration": 15.5,
}

# In helpers/render.py:

# resolve_grade_filter() converts "neutral_punch" to the FFmpeg filter string

# and injects it into the segment extraction pipeline

This integration allows you to assign different presets to different clips within the same project while maintaining a unified rendering workflow.

Listing Available Presets

To discover all available options without reading the source code, use the list command:

python helpers/grade.py --list-presets

This outputs all defined presets with their filter strings:

subtle:
  eq=contrast=1.03:saturation=0.98

neutral_punch:
  eq=contrast=1.06:brightness=0.0:saturation=1.0,curves=master='0/0 0.25/0.23 0.75/0.77 1/1'

warm_cinematic:
  eq=contrast=1.12:brightness=-0.02:saturation=0.88,colorbalance=rs=0.02:gs=0.0:bs=-0.03:rm=0.04:gm=0.01:bm=-0.02:rh=0.08:gh=0.02:bh=-0.05,curves=master='0/0 0.25/0.22 0.75/0.78 1/1'

none:
  (no filter)

Summary

• video-use color grade presets are FFmpeg filter chains defined in helpers/grade.py and accessed via get_preset().
• warm_cinematic applies a creative teal-orange look with colorbalance adjustments and higher contrast (1.12), ideal for stylized content.
• neutral_punch provides subtle correction (contrast 1.06) without color shifts, suitable for footage needing gentle enhancement.
• Both presets integrate into the helpers/render.py pipeline through EDL grade fields or direct CLI/Python usage.
• Presets stay within safe ±12% contrast ranges to preserve latitude for downstream color grading.

Frequently Asked Questions

What is the difference between warm_cinematic and neutral_punch?

warm_cinematic is a creative preset that adds a deliberate color cast using the colorbalance filter to warm shadows and cool highlights, creating a cinematic teal-orange look with 1.12 contrast. neutral_punch is a corrective preset that skips color manipulation entirely, applying only a gentle contrast boost (1.06) and luminance curve to add depth while maintaining neutral color temperature.

How do I add custom color grade presets to video-use?

To create custom presets, add new entries to the preset dictionary in helpers/grade.py following the existing format: assign a unique name to an FFmpeg filter string combining eq=, optional colorbalance=, and curves= filters. Ensure your custom preset stays within the ±12% contrast boundary to avoid clipping, then access it via get_preset("your_custom_name") or the --preset CLI flag.

Can I use video-use presets without FFmpeg installed?

No. The presets are FFmpeg filter strings that require a local FFmpeg installation. The apply_grade() function in helpers/grade.py shells out to FFmpeg with the -vf flag set to the preset's filter chain. Without FFmpeg, the Python code can retrieve the filter string via get_preset(), but cannot process video files.

Where are color grade presets stored in the video-use repository?

All preset definitions reside in helpers/grade.py (lines 44-58 for the built-in options), which also contains the get_preset() lookup function and apply_grade() execution logic. The helpers/render.py file contains the resolve_grade_filter() function that integrates these presets into the EDL-based rendering pipeline.

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