Blog · Delivery
How to find flash frames before you deliver
· Updated · 4 min read
Short answer
A flash frame is a stray frame or few left at a cut. Search the timeline if your editor can, then check the rendered file: blackdetect with d=0 finds black ones, the same filter after negate finds white ones, and comparing each frame to the last finds the rest, because a one-frame flash makes two spikes in a row. Then look at what it finds.
On this page
A frame lasts 40 milliseconds at 25 fps, so you can miss one on a full watch and a viewer can still feel the bump.
The ffmpeg commands below were all run on November 4, 2026, with ffmpeg 8.1.1, on a test clip we built. It’s 10.08 seconds at 25 fps, with a one-frame black flash at 2.00, a one-frame white flash at 4.04, one stray frame of another picture at 6.08, and a 1-second freeze at 8.12. It’s synthetic, so expect noisier results from real footage.
How do they get into a cut?
Mostly from edits that leave a sliver behind:
- A trim that stops short. A razor or a roll or slide takes a clip down to a frame or two, and it stays there, too small to see at your zoom level.
- A gap on an upper track. One empty frame on V2 shows whatever is on V1 for that frame.
- A replaced shot that’s a frame shorter. The rest stays where it was, and the gap shows black or the track beneath.
- A speed change. New timing can leave a clip’s end a frame off where a neighbor begins.
- A round trip. An interchange file or a frame rate conversion can shift an edit by a frame.
Can you find them on the timeline?
Yes, if your editor has a search for short clips. Avid’s Editing Guide has Timeline > Find Flash Frame, which by default stops at clips of 9 frames or fewer, and Find Black Hole for filler. The Resolve 21 manual points to the Cut page’s Boring Detector: set its Jump Cuts slider to 2 frames, and shorter clips show red on the upper timeline. Without such a command, export an EDL and scan the event durations for anything short.
A timeline search can’t see what’s in a clip, though. So check the render too, because that’s what you deliver.
How do you catch black and white flashes?
Use blackdetect with its minimum duration set to zero. Its default is 2 seconds, which reported nothing on our clip.
ffmpeg -hide_banner -i cut.mp4 -an -vf blackdetect=d=0 -f null - 2>&1 | grep black_start
black_start:2 black_end:2.04 black_duration:0.04
For white, invert the picture first, so white reads as black:
ffmpeg -hide_banner -i cut.mp4 -an -vf negate,blackdetect=d=0 -f null - 2>&1 | grep black_start
black_start:4.04 black_end:4.08 black_duration:0.04
We’ve trimmed the filter’s name and address from the start of each output line here. The other defaults count a picture as black when 98% of its pixels are, and a pixel as black up to 10% of the luma range. A dark night scene can trip it, so read the timecodes before you change anything.
What does a scene-change search find?
The select filter with a scene threshold lists frames that look like a new shot:
ffmpeg -hide_banner -i cut.mp4 -an -vf "select='gt(scene,0.3)',metadata=print:file=-" -f null - 2>/dev/null | grep -E "pts_time|scene_score"
frame:0 pts:25600 pts_time:2
lavfi.scene_score=1.000000
frame:1 pts:51712 pts_time:4.04
lavfi.scene_score=0.904983
frame:2 pts:77824 pts_time:6.08
lavfi.scene_score=0.784783
frame:3 pts:116736 pts_time:9.12
lavfi.scene_score=0.484542
It found the start of all three flashes, including the stray frame the black checks can’t see. It didn’t find their ends. On our clip, the cuts at 2.04, 4.08 and 6.12 scored below the threshold, so looking for two hits close together wouldn’t work. Treat it as a list of cuts to look at.
It also reported the real cut at 9.12, and it can’t tell a flash from an ordinary cut. So we need a check that can.
How do you tell a flash from a normal cut?
Compare each frame with the one before. A normal cut makes one spike in that difference. A one-frame flash makes two in a row, one going in and one coming out.
ffmpeg -hide_banner -i cut.mp4 -an -vf "tblend=all_mode=difference,signalstats,metadata=print:key=lavfi.signalstats.YAVG:file=diffs.txt" -f null - 2>/dev/null
awk -F= '/pts_time/{split($0,a,"pts_time:"); t=a[2]} /YAVG/{if($2>20){if(p!=""&&t-p<0.5)printf "flash at %s, %.0f frame(s)\n",p,(t-p)*25;p=t}}' diffs.txt
flash at 2, 1 frame(s)
flash at 4.04, 1 frame(s)
flash at 6.08, 1 frame(s)
That’s all three flashes and not the real cut at 9.12. The 20 is the size of the spike that counts, the 0.5 is how close two spikes must be in seconds, and the 25 is the clip’s frame rate, so change it to match yours.
Where it fails. We built a second clip with one frame taken from later in the same shot, the kind of flash a bad trim on one take leaves. It stayed under a threshold of 20, and the scene search and blackdetect found nothing either. Its highest scene score was about 0.03. Lowering the threshold to 4 found it, at 1 second, because the steady difference on that clip sat near 2.6. On handheld footage or fast pans, a threshold that low will flag plenty of ordinary motion, so start from your own clip’s values and expect to look through false hits.
What else should you check before delivery?
Run these on the file you’re handing over, not a proxy.
Frozen frames. freezedetect defaults to 2 seconds, which missed our 1-second freeze, so shorten it.
ffmpeg -hide_banner -i cut.mp4 -an -vf freezedetect=d=0.5 -f null - 2>&1 | grep freeze_
lavfi.freezedetect.freeze_start: 8.12
lavfi.freezedetect.freeze_duration: 1
lavfi.freezedetect.freeze_end: 9.12
It has a blind spot. When we added grain with ffmpeg’s noise filter ahead of the check, the same freeze came back with nothing reported. A still with grain over it, or a noisy source, can get past the check.
Loudness and true peak. Compare these with your platform’s target.
ffmpeg -hide_banner -nostats -i cut.mp4 -vn -af ebur128=peak=true -f null - 2>&1 | grep -E "^ +(I|LRA|Peak):"
I: -41.1 LUFS
LRA: 0.0 LU
Peak: -37.6 dBFS
Picture and sound the same length. Ours differed by 0.08 seconds, which we’d put there on purpose.
ffprobe -v error -show_entries stream=codec_type,duration -of csv=p=0 cut.mp4
video,10.080000
audio,10.000000
Frame count and rate. Compare them with the timeline’s. This one decodes the whole video to count.
ffprobe -v error -count_frames -select_streams v:0 -show_entries stream=nb_read_frames,r_frame_rate -of csv=p=0 cut.mp4
25/1,252
A clean decode. No output means ffmpeg reported no errors from start to finish.
ffmpeg -v error -i cut.mp4 -f null -
Then watch it through once at full speed. A filter knows that a frame differs. It doesn’t know that the flash in the title sequence is the idea.
How does this work in nolanlabs?
Ask the agent to “find the flash frames” in the chat. Its look tool plays the cut back with flash frames, black, stills and jumps flagged, and any frames it looks at go to the agent you chose: with Nolan Edit, through nolanlabs.io to the company that runs its model. When a render finishes, the editor checks the file for loudness, true peak, loudness range, and black or frozen frames, and shows each result in the queue. One limit: that render check doesn’t list flash frames, so ask for them while the cut is still open.