Local · FFmpeg · Python

Two clips in.
One premium short out.

ReTones Content Engine turns a before/after screen recording and a product image into a finished 9:16 short — hook, before, a directional-blur punch zoom, after, product reveal, CTA. No CapCut. No manual editing. Fully automated, entirely local.

1080×1920Resolution
60 FPSFrame rate
~20sOutput length
6Scenes
The Timeline

Six scenes, ~20 seconds, zero manual cuts

Every frame below is pulled directly from a real render — the same pipeline that generated the demo above. Each scene is its own independently-rendered, independently-tunable module.

Hook scene — bold white text on black background0:00–0:02
Hook
fade + 105% scale
Before scene — full-bleed screen recording with BEFORE label0:02–0:06
Before
full-bleed, clean
Zoom transition scene — directional motion blur mid-punch-zoom0:06–0:07
Punch Zoom
100%→140% + blur + whoosh
After scene — settled at full frame after the zoom eases out0:07–0:12
After
eases 140%→100%
Product scene — product image with title and subtitle on dark background0:12–0:17
Product
slow zoom-in reveal
Outro scene — CTA text fading out on black0:17–0:20
Outro
logo + CTA, fade out
The Focal Point

Same crop, same corner — before, transition, and after all agree

The punch-zoom aims at a configurable focal point (default: top-right, where a plugin window usually sits) — and the before/after framing is biased toward that same region, so the cut into the zoom never feels like a re-frame.

Before frame
BEFOREflat curve
After frame
AFTERboosted +6dB

Converting 16:9 screen recordings to 9:16 by filling the frame crops away roughly two-thirds of the width no matter what — crop_focal_x/y decides which slice survives, and it's the single setting that matters most once real footage is dropped in.

How It Works

Built on FFmpeg's own math, not a video-editing SDK

No OpenCV, no GPU compute, no external motion-tracking. Every effect is either a native FFmpeg filter or a Pillow-rendered PNG overlay.

01

Scenes render independently

Each of the 6 scenes renders to its own intermediate clip with identical codec/fps/resolution, then a fast -c copy concat stitches them. Debuggable in isolation; a 7th scene is a one-line addition.

02

Ease curves as FFmpeg expressions

Zoom/pan uses an ease-in-out cubic curve, compiled to a zoompan expression string — FFmpeg evaluates it per-frame internally, no Python callback exists at that layer.

03

Motion blur via supersampling

The punch-zoom renders at 240fps, blends neighboring frames with tmix, then downsamples to 60fps. Blur direction falls straight out of actual pixel motion — no vector math.

04

Text as pixel-perfect overlays

Hooks, labels, and CTAs render via Pillow to transparent PNGs — auto-wrap, auto-shrink-to-fit, true letter-spacing — then FFmpeg simply overlays the result.

05

Synthesized whoosh, zero SFX library

The transition's whoosh is band-passed noise with an envelope, generated on the fly — dropping a real whoosh.wav into config overrides it.

06

Every constant lives in config

Durations, zoom range, focal point, colors, fonts, CRF — nothing is hardcoded in scene code. Batch-render an entire Projects/ folder with one command.

Export Spec

What comes out the other end

Resolution
1080 × 1920
Frame rate
60 fps
Codec
H.264 / AAC
Quality
CRF 16
Zoom range
100% → 140%
Runtime
Python + FFmpeg