# How the Self-Evaluation Loop Verifies Cut Boundaries in Rendered Video Output

> Learn how the self-evaluation loop verifies cut boundaries in rendered video. It extracts edit segments, applies audio fades, and concatenates results for fast draft inspection.

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

---

**The self-evaluation loop in the browser-use/video-use repository verifies cut boundaries by extracting every edit segment independently at low resolution, applying precise audio fades, and concatenating the results into a fast draft video that editors can inspect before committing to a full-quality render.**

The `browser-use/video-use` project provides a lightweight draft mode designed to catch timing errors early in the editing pipeline. Instead of rendering the full composite, the self-evaluation loop isolates each cut defined in the edit decision list (EDL), preserves exact start and end times, and assembles a previewable base video so boundary errors are caught before the expensive final pass.

## Per-Segment Extraction with Precise Timing

At the core of the loop is `extract_segment()` in [`helpers/render.py`](https://github.com/browser-use/video-use/blob/main/helpers/render.py) (lines 61–70). This function takes a source video path, a start time, and a duration, then produces a short standalone MP4 containing only that slice.

To guarantee frame-accurate boundaries, the underlying FFmpeg command places the `-ss` seek flag **before** `-i`. This input-side seeking strategy is both faster and more accurate than output-side seeking, ensuring the extracted clip begins exactly at the EDL-specified timestamp.

### Audio Fade Handles to Prevent Boundary Pops

Cut points can introduce audible clicks when audio waveforms are severed at non-zero crossings. To prevent this, `extract_segment()` appends a 30 ms `afade` at the head and tail of every extracted segment (lines 87–90 in [`helpers/render.py`](https://github.com/browser-use/video-use/blob/main/helpers/render.py)). These micro-fades make each segment safe for headphone checks so editors can verify that cuts sound as clean as they look.

### Draft-Quality Encoding for Rapid Feedback

When the pipeline runs in self-evaluation mode, it forces a low-quality encoding ladder to maximize speed. The draft preset targets 720p resolution using the `ultrafast` encoder preset and a CRF of 28, as noted in the help text around line 587 of [`helpers/render.py`](https://github.com/browser-use/video-use/blob/main/helpers/render.py). The resulting files are large relative to quality but decode instantly, keeping the feedback loop tight while preserving the exact temporal boundaries defined in the EDL.

## Iterating Over All Cuts in the EDL

The `extract_all_segments()` function (lines 14–31 in [`helpers/render.py`](https://github.com/browser-use/video-use/blob/main/helpers/render.py)) drives the loop. It accepts the parsed EDL, resolves every source path, and calls `extract_segment()` once per edit range.

During execution, the function prints each cut’s start and end times (lines 55–58) to the console. This audit trail lets editors cross-reference the rendered segments against their original edit notes before any heavy compositing begins.

## Verifying Cut Boundaries via Lossless Concatenation

After all individual segments are materialized, the pipeline calls `concat_segments()` to join them with a lossless concat demuxer. Because each segment was extracted with the exact start and end timestamps supplied in the EDL, the resulting base video represents a frame-level faithful preview of the finished timeline.

Editors can play back this composite to confirm that:

- No frames are dropped or duplicated at cut points.
- Dialogue or action lines up across source boundaries.
- The overall pacing matches the intent of the EDL.

If the draft playback is approved, the project proceeds to the higher-quality preview and final passes. If a boundary is off, the EDL is corrected and the self-evaluation loop runs again.

## Running the Self-Evaluation Loop from the Command Line

The draft mode is exposed through the `--draft` argument in [`helpers/render.py`](https://github.com/browser-use/video-use/blob/main/helpers/render.py). When invoked, the pipeline skips the expensive final-quality passes and performs only the cut-point verification sequence.

```bash

# Full-quality final render

python helpers/render.py project.edl.json -o final.mp4

# Fast self-evaluation/cut-point verification only

python helpers/render.py project.edl.json -o draft.mp4 --draft

```

As described in the argparse help text (lines 85–88), the `--draft` flag explicitly triggers cut-point verification only, making the intent of the run unambiguous.

You can also trigger the same workflow programmatically:

```python
from pathlib import Path
from helpers.render import extract_all_segments, concat_segments

edl = {
    "ranges": [
        {"source": "cam1", "start": 0.0, "end": 5.2},
        {"source": "cam2", "start": 5.2, "end": 12.0},
    ],
    "sources": {"cam1": "videos/cam1.mp4", "cam2": "videos/cam2.mp4"},
}

edit_dir = Path("my_project")
segments = extract_all_segments(edl, edit_dir, preview=False, draft=True)
base_path = edit_dir / "base_draft.mp4"
concat_segments(segments, base_path, edit_dir)

# base_path now contains a quick-check video with all cuts applied.

```

### Optional Visual Verification

For editors who want a graphical cross-reference alongside the draft video, [`helpers/timeline_view.py`](https://github.com/browser-use/video-use/blob/main/helpers/timeline_view.py) provides a filmstrip and waveform drill-down for any given time range. This view complements the self-evaluation loop by adding a visual layer to the temporal checks.

## Summary

- The self-evaluation loop lives in [`helpers/render.py`](https://github.com/browser-use/video-use/blob/main/helpers/render.py) and centers on `extract_segment()` and `extract_all_segments()`.
- Each EDL range is extracted independently with input-side `-ss` seeking for frame-accurate boundaries.
- A 30 ms `afade` at each segment edge prevents audible pops during quick checks.
- Draft mode encodes at 720p/`ultrafast`/CRF 28 to keep iteration fast.
- Segments are concatenated losslessly into a base draft video that editors can inspect before final rendering.
- The `--draft` CLI flag triggers this verification path explicitly.

## Frequently Asked Questions

### How does the self-evaluation loop maintain frame-accurate cut points?

The loop uses FFmpeg with the `-ss` seek flag placed before the `-i` input flag inside `extract_segment()`. This input-side seeking method is faster and more accurate than output-side seeking, ensuring each extracted segment starts exactly at the timestamp defined in the EDL.

### Why does the draft mode add audio fades to every segment?

A 30 ms `afade` is applied to the head and tail of each extracted clip to prevent audible pops that occur when waveforms are cut at non-zero crossings. This makes the draft segments suitable for quick headphone checks without distracting artifacts.

### What video quality does the draft self-evaluation use?

Draft mode forces a low-resolution ladder of 720p with the `ultrafast` encoder preset and a CRF value of 28. These settings prioritize encoding speed over fidelity so editors can iterate quickly, while the exact temporal boundaries from the EDL remain intact.

### Can I verify cuts without generating the final high-resolution render?

Yes. Passing `--draft` to [`helpers/render.py`](https://github.com/browser-use/video-use/blob/main/helpers/render.py) runs only the cut-point verification pass. The script extracts every EDL range, prints the start and end times for audit, and concatenates the segments into a low-resolution base video, skipping the expensive final-quality render entirely.