# DaVinci Resolve: exact three-crop construction

**Manual-checked guide; no native Resolve execution or export has occurred.**
No project, Fusion setup or application-generated evidence is supplied. The
tested part is full-Chrome raster preparation from original editable SVG/code.
Do not call its PNGs “Resolve renders.”

Control names were checked in Blackmagic Design's **DaVinci Resolve 21 Reference
Manual** (July 10, 2026), SHA-256
`7bfdcf0296bd1e48aeca58a3d66026821cf9dec5f1f0e5fe7a4b936dbe34e799`.
Relevant printed pages: project settings 144–154, Inspector transform/cropping
441–442, and Change Clip Duration 713 (the dialog also works on the Edit page).
Official manual:
`https://documents.blackmagicdesign.com/UserManuals/DaVinci_Resolve_21_Reference_Manual.pdf`.
Record the installed version, Free/Studio edition, OS, GPU, driver and actual
available codecs before execution. This is not a claim about the latest release.

## 1. Prepare the three original crop plates

Run the `stage`, `svg` and `prepare` commands in `README.md`. Check the generated
`preparation.json`, dimensions **1920×1080**, font loading and input/SVG hashes.
This produces three PNGs **per content**. They are full-frame, opaque RGB views
of the oversized original text with its clipping already applied. No source
pixels, extracted source glyphs or source-video layer are used.

Do not drag the SVGs straight into Resolve: their SVG `foreignObject`/embedded
font path is tested in full Chrome, not Resolve's SVG importer. Use the generated
PNGs. Preserve the editable SVGs, font license and generator next to the project.
No native Text/Text+ approximation, OS font installation or extra Fusion nodes
are needed for this route. Text+ metrics have not been matched to Chrome here.

## 2. Create the native-cadence timeline first

1. Create a disposable project, not a production-project replacement. Before
   importing any media, open **File → Project Settings → Master Settings**.
   Set **Timeline resolution 1920×1080**, **Pixel aspect ratio Square**,
   **Timeline frame rate 23.976** (24000/1001), **Playback frame rate 23.976**,
   drop-frame timecode off and interlace processing off. Never choose 24 or 30.
   If the timeline rate is locked, make a new correctly configured timeline or
   project; do not retime this 33-frame shot to hide a rate mismatch.
2. For a controlled baseline, choose **Color science: DaVinci YRGB** (unmanaged)
   and **Timeline color space: Rec.709 Gamma 2.4**. Apply no input/output LUT,
   grade, automatic color management, display-look effect or adjustment clip.
   These are proposed reproduction settings, not recovered source settings.
   Native-export color equality remains unverified.
3. Under **Image Scaling → Input Scaling**, use **Center crop with no resizing**.
   All six plates already match the timeline. No fit/crop scaling should occur;
   reject a plate with different dimensions instead of stretching it.
4. Import the three PNGs for **one** variant as separate stills, not a numbered
   image sequence. If Resolve groups them, use the Media Storage option to show
   individual frames, then import them individually. In **Clip Attributes →
   Video**, confirm square pixels and **Data Levels: Full** for the RGB PNGs.
5. Create timeline `ParagraphCuts_Original`, start timecode **01:00:00:00**, using
   the project rate and raster. Build only this shot on **V1**, with no audio
   tracks containing clips. Repeat in `ParagraphCuts_Adaptation` with that
   variant's three PNGs. Do not mix content variants within a timeline.

## 3. Set frame durations and butt cuts numerically

Use **Clip → Change Clip Duration** (or the clip's context menu). Set **Format:
Frames**, enter the listed integer, then **Change**. Place the first plate on
V1 at the timeline start. Set its duration before adding the next plate. Append
the next plate to the previous plate's end with snapping enabled; then set that
plate's duration. This avoids leaving gaps when shortening pre-existing clips.

| V1 still, for either variant | Local range | Included frames | Duration field | Timeline In | Next cut / end-exclusive |
| --- | --- | --- | --- | --- | --- |
| `*-crop-1.png` | [0,7) | 0–6 | **7** | 01:00:00:00 | 01:00:00:07 |
| `*-crop-2.png` | [7,16) | 7–15 | **9** | 01:00:00:07 | 01:00:00:16 |
| `*-crop-3.png` | [16,33) | 16–32 | **17** | 01:00:00:16 | 01:00:01:09 |

`*` is `original` in the first timeline and `adaptation` in the second.
`resolve-cuts.csv` spells out all six filenames and frame boundaries.
At 23.976 NDF, timecode labels count 24 frames per displayed second; that does
**not** make the elapsed duration 1.375 seconds. Frame 32 is **01:00:01:08**,
the last included frame. **01:00:01:09 is excluded**, not an extra held frame.

There is no transition object between clips. Zero overlap, zero gap, zero fade
handles. Crop 2 replaces crop 1 immediately on frame 7; crop 3 immediately on
frame 16. No keyframe interpolation is needed. The first crop arrives as a cut
from a neighboring shot only if a surrounding edit supplies one.

## 4. Inspector settings: keep the prepared geometry unchanged

Select each still on the Edit page and check **Inspector → Video**:

| Control | Value for every still |
| --- | --- |
| Transform → Zoom X / Y | 1.000 / 1.000, linked |
| Transform → Position X / Y | 0 / 0 |
| Transform → Rotation Angle | 0 |
| Transform → Anchor Point X / Y | 0 / 0 |
| Transform → Pitch / Yaw | 0 / 0 |
| Transform → Flip Horizontal / Vertical | off / off |
| Cropping → Left / Right / Top / Bottom | 0 / 0 / 0 / 0 |
| Cropping → Softness | 0 |
| Dynamic Zoom | off |
| Composite mode / Opacity | Normal / 100% |
| Keyframes, transitions, fade handles | none |

Keep **Retime and Scaling → Scaling** at project settings and speed unchanged.
Do not enter the CSS X/Y values from `CONTENT_AND_TIMING.md` into Resolve's
Inspector. Those offsets, the final 1.28 scale and per-state line pitches are
already baked into **original-content plate geometry** by the editable SVG
preparation step. Applying them again would double the crop or scaling.

## 5. Inspect and export the actual timelines

At full raster, inspect local **0, 6, 7, 15, 16 and 32**, then all 33 frames.
Check complete formed text, unequal dwells, hard changes and the deliberate
off-screen paragraph. Play at normal speed on the actual workstation. Record
what was directly watched; scrubbing, frame metrics and browser callbacks are
not moving perception.

On **Deliver → Custom Export**, use a single clip, 1920×1080, 23.976 fps and
**Export Audio off**. For a compatible installation, select **MP4/H.264**,
progressive, high quality; record the available encoder and chosen data/color
level controls. Do not claim H.264 availability for untested Free/Linux systems.
If unavailable, stop and agree a supported codec/container rather than silently
changing the deliverable. Render the entire 33-frame timeline. If using an In/
Out range, set In on frame 0 and Out on frame **32 inclusive**; never 33.

Keep the outputs as `original.mp4` and `adaptation.mp4` in a new directory, then
run the same public `verify.py` against those movies and the prepared plates.
It must actually decode **66** output frames, verify silence and rational PTS,
and check cuts at 7/16. Do **not** pass `--baseline`: a native Resolve encode is
not expected to be byte-identical to Remotion. A mismatch must remain a failed
application check; do not loosen thresholds or invent a successful native run.

Save the project and record the Resolve version/edition, timeline setup, clip
durations, Inspector states, export controls, decoded checks and a real playback
review. Only those future application artifacts can close the **native Resolve
execution** gate. The guide and prepared PNGs do not close it.