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

> Master video-use color grade presets like warm_cinematic and neutral_punch. Learn how these FFmpeg-based tools enhance your video contrast and color styling for professional results via CLI or Python API.

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

---

**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`](https://github.com/browser-use/video-use/blob/main/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`](https://github.com/browser-use/video-use/blob/main/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`](https://github.com/browser-use/video-use/blob/main/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`](https://github.com/browser-use/video-use/blob/main/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`](https://github.com/browser-use/video-use/blob/main/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:

```python
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:

```bash

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

```python
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:

```bash
python helpers/grade.py --list-presets

```

This outputs all defined presets with their filter strings:

```text
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`](https://github.com/browser-use/video-use/blob/main/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`](https://github.com/browser-use/video-use/blob/main/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`](https://github.com/browser-use/video-use/blob/main/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`](https://github.com/browser-use/video-use/blob/main/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`](https://github.com/browser-use/video-use/blob/main/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`](https://github.com/browser-use/video-use/blob/main/helpers/render.py) file contains the `resolve_grade_filter()` function that integrates these presets into the EDL-based rendering pipeline.