V2TSR

What it is

V2TSR (short for Vid2Text-SR) takes a podcast recording and makes a cleaner, sharper 4K version of it. It cleans up sensor noise, can correct exposure, applies a colour look, sharpens, can raise the frame rate, and encodes on the graphics card.

It comes in two layers. The pipeline is a command-line script built on FFmpeg, and it is the single source of truth for how a video gets rendered. The desktop app is a small window on top of it: pick videos, pick a look, press Start. The app builds the exact command you would type yourself, so anything the app makes, the command line can make too.

It runs on a Windows laptop with an RTX 4050 Laptop GPU, an 8-core Intel Core Ultra 7 and 16 GB of RAM. Every number on this page was measured on that machine.

Plain crop, scale and light sharpenV2TSR Unprompted chain

The chain

Before anything renders, V2TSR reads the file (size, frame rate, duration, codec, rotation, so portrait stays portrait) and proves which encoder works by test-encoding 10 frames on each candidate: NVIDIA first, then Intel, then AMD, then the CPU. It does the same for GPU decoding and GPU scaling. Nothing is assumed.

Why this order

• Clean before anything else. Denoising, exposure and sharpening all run at the source size in the default chain. That's far cheaper than at 4K, and the upscaler then fills in already-clean pixels instead of enlarging noise.
• Exposure before sharpening, so the sharpen amount applies to the final contrast, not to a frame that's about to get brighter.
• Frame rate before the upscale. Interpolating at 4K runs at about 0.35 fps. Moving it before the upscale took a 4-second test clip from 10:17 to 1:38, then to 1:04 once the upscale moved to the GPU.
• The GPU scaler has to be last. Once frames are on the graphics card, FFmpeg's other filters can't touch them. That's why the Unprompted profile, which grades and sharpens after scaling, uses the CPU Lanczos scaler instead.

Getting the video in

By default the source is streamed through a text (Base64) copy in 50 MB chunks and decoded back on the fly. Base64 is about 1.33x the size of the video. If the file's index sits at the start it's piped straight into FFmpeg; if not, it's decoded to a temporary file first. --direct-input skips the round trip and reads the file directly, which saves about 2.3x the source size on disk. The app always uses the round trip.

The exposure measurement (--grade auto)

It builds one brightness histogram for the whole clip from frames shrunk to 320 px wide, 4 per second. The black point is the darkest 0.5% and the white point the brightest 0.5%, aiming the middle brightness at 0.42 with the gain capped at 1.6x and the curve's gamma held between 0.60 and 1.15. Default strength is 0.8.

Guards keep it from doing harm. A clip with almost no tonal range (a title card or a fade) is left alone. The black point never goes past 0.25. The correction backs off if it would make the middle worse. A clip that's already well exposed isn't touched.

Looks

The look is the colour grade, set with --look (default Clean bright). There are 15. --look also accepts a path to a .cube LUT file. A LUT is global, so it can't brighten a face without also brightening the wall behind it.

Detail presets

A detail preset is a pair: how much noise to remove and how much to sharpen. Set it with --detail (default Crisp). --denoise and --sharpen replace either half on its own, or turn it off.

How to read hqdn3d=a:b:c:d: the first two numbers are cleanup within one frame (brightness, colour), the last two are cleanup across frames. Across-frame cleanup removes grain that flickers frame to frame without softening edges much, which is why the Unprompted preset leans on it.

The Unprompted profile

--profile unprompted is the setting every Unprompted video uses. It was picked from a side-by-side test on 5 November 2026: the darker, camera-natural version with medium across-frame cleanup won. The brighter, more heavily denoised 60 fps version lost. Since 6 November the same chain is used on every reel and every YouTube video, not only full episodes. Reels run it at 1080×1920 instead of 4K.

The full chain it produces: format → hqdn3d=0.5:0.5:8:6 → Lanczos to 4K → eq=contrast=1.04:saturation=1.05 → unsharp=5:5:0.6:5:5:0.0 → yuv420p, at the source frame rate, CQ 16. A render from the profile matched the approved test sample at 44.9 dB PSNR; the remaining difference is encoding.

Frame rate

The default target is 60 fps (--fps 60). What happens depends on the source:

--interp auto (default) uses RIFE when its environment works, and otherwise warns and falls back to minterpolate. Asking for --interp rife when it isn't available stops with an error instead of silently changing method. RIFE computes motion at half resolution by default (--rife-scale 0.5), which is about 3x faster at the same quality.

In the RIFE path, one FFmpeg decodes and cleans, RIFE generates the frames in between, and a second FFmpeg upscales and encodes. The audio is copied aside first and joined back during the encode.

RIFE is the RIFE v4 model (MIT licence) running in half precision on CUDA. There is no AI upscaler: scaling is Lanczos on the CPU or bicubic on the GPU. Neural upscaling was tried and is only practical on short clips with this GPU.

Encoding

Output is H.264 by default. HEVC is about 40% smaller, and AV1 is available on the command line. Quality is constant-quality (CQ): lower is better. The default is 19, and the Unprompted profile uses 16.

H.264 uses the High profile. HEVC is tagged hvc1 so Apple devices play it. Audio is copied as-is when it fits in an MP4, otherwise it's re-encoded to AAC at 192 kb/s. Files get +faststart so they play while they download. Renders are written to *.partial.mp4 and only renamed once they finish, so a half-written file never looks done.

The app

Opening it: the desktop or Start menu shortcut. Opening it twice brings the open window to the front, and videos dropped on the icon go into the open window's queue. When the app's own files change, it shows "V2TSR was updated" with a Restart now button and keeps your queue. Changes to the render engine need no restart at all. The title bar shows which version is running.

Where things go

• Finished render: <name>_4k60.mp4 in a remaster folder next to the source, or in the folder you chose. The name says 4k60 even when the Unprompted profile keeps 30 fps.
• Preview: 10 seconds starting at a third of the way in (at most 60 s; from the start for clips of 20 s or less). It opens in your video player.
• Drive move: uploads one at a time, in their own process so they keep going after the window closes, and keep the laptop awake. Each upload retries up to 8 times, 10 minutes apart. The local file is deleted only after the copy on Drive has the same checksum. Any failure keeps the local file.

Safety checks

1. Disk space before starting. Output size is estimated from measured rates (16.5 MB/s for 4K60 H.264, 10 MB/s for HEVC or AV1, both with 10% headroom) plus 1 GB. The temporary working copies are counted too. If the working folder and the output share a drive, both are checked against that one drive. Not enough space stops the render before it starts. The app adds its own check (estimate × 1.3 + 5 GB) and asks before going ahead.
2. No overwriting. The app asks before replacing a file, and the pipeline refuses unless told to.
3. The finished file is checked for the right frame size, a frame rate within 0.5, a duration within 1 second, and audio present. It also needs at least 98% of the frames it should have. That last check exists because a damaged recording once came out with the right duration but thousands of frames missing.
4. A watchdog on the RIFE path. If any step errors, or no new frame arrives for 3 minutes (5 for the first frame), it stops all of them instead of hanging. Paused or asleep time doesn't count.
5. Retries in the app. A GPU failure is retried once after 10 seconds. Any other failure marks that video Failed and the queue carries on.
6. Keeping the machine on. The laptop stays awake while rendering. The app warns about running on battery (the GPU drops to about 20 W and renders run 2-5x slower), another render already running, and uploads still in progress. Cancel cleans up the partial file.

Measured numbers

"Real time" means a 10-minute video takes 10 minutes. 0.5x real time means it takes 20.

The app's estimates come from these: 0.45x real time for 30 fps sources, 0.94x for 60 fps sources, about 0.68 GB per minute for H.264 and 0.41 GB per minute for HEVC. Quality of RIFE's made-up frames against real 60 fps frames: 44.6 dB PSNR (minterpolate 45.8 dB). Both are close to the real thing.

Limits and decisions

Limits

• RIFE only doubles the frame rate. Any other rate falls back to minterpolate, which is slow.
• The GPU scaler uses bicubic, not Lanczos. FFmpeg's GPU Lanczos wraps its overshoot around (pure white turns black), which left dotted outlines on hard edges: 612 pixels off by more than 60 levels on a test frame, against a maximum of 39 with bicubic. 4K renders made before the switch have the artifact.
• A LUT is global. It can't light a face without lighting the wall too.
• The app's Unprompted checkbox text undersells it. It says "light grain cleanup" and 30 fps. The profile actually uses medium across-frame cleanup and keeps the source's frame rate, so a 60 fps source stays 60.

Decisions

Flag reference