Optical Flow vs Frame Blending: Better Slow Motion

Optical flow estimates motion between recorded frames to synthesize intermediate images; frame blending combines neighboring images without necessarily tracking their movement. Optical flow can make slow motion smoother, but it can also warp subjects or backgrounds. Frame blending can avoid those motion-estimation failures while introducing ghosting. The better choice depends on source timing, playback speed, and the artifacts your shot can tolerate.

Start by asking how many recorded moments the edit actually has available. High-frame-rate capture may already provide every frame needed for your chosen slow motion. Other footage needs repeated, blended, or synthesized images. Neither a larger fps label nor a more expensive algorithm establishes a better result.

This guide moves from those distinctions to exact timing, an artifact atlas, and a repeatable comparison worksheet. For general vocabulary, see video editing terminology explained. For capture and delivery-rate fundamentals, use the separate frame-rate guide.

What the interpolation methods actually do

A retimed clip asks for a picture at a source time that may fall between two recorded frames. The interpolation method decides what picture occupies that output slot. These are practical families, not mutually exclusive definitions of how an entire application works.

Optical flow estimates apparent movement in the image plane. It does not directly measure an object's true three-dimensional path. A moving shadow, reflection, occluded hand, and background texture can all complicate the estimate. A synthesis stage uses those estimates to place image content at an intermediate time.

Frame blending is simpler conceptually: imagine fading between two nearby moments. At a midpoint, a basic equal blend gives both images a contribution. If a ball moved substantially, the result may contain two faint balls instead of one correctly positioned ball. Other blending implementations can weight frames differently; the label alone does not define every detail.

The categories overlap. A flow-based method can blend warped images. A learned model can estimate flow rather than replacing it. Apple's retiming guide explicitly describes its machine-learning option as using bidirectional optical flow. The RIFE research paper likewise describes a neural network that estimates intermediate flows.

FFmpeg provides another useful distinction: its minterpolate filter offers duplication, blending, and motion-compensated modes in one filter. Motion compensation there includes block-based options; it is not evidence that every editor's optical-flow option uses the same algorithm. Compare specific implementations and versions, not just marketing labels.

Calculate the frames before choosing a method

For a constant-frame-rate source and a constant positive speed, define three values: Fs is source fps, Fp is the frame rate of the grid this retiming pass generates, and S is playback speed as a decimal. Thus 100% speed means S = 1, while 20% means S = 0.2. Assume no earlier reinterpretation of the source and aligned starting times.

That grid is normally the project rate. If a 24 fps timeline is later exported at 60 fps, the export may resample already-rendered 24 fps pictures instead of reevaluating the source at 60 fps. Treat that as a separate conversion unless the application documents otherwise. To calculate final output in one pass, project and export rates must match, or the retimer must generate images directly at the final output times. Merely changing the export rate does not guarantee that behavior.

• Output duration = selected source duration / S. Slowing the same action increases its duration.
• Recorded-frame availability per output second = Fs × S. Slowing down spreads the existing samples over more playback time.
• Source-frame advance per output frame = Fs × S / Fp. Call this advance q; it reveals where each output picture must come from.
• One-to-one speed = Fp / Fs. At this speed, with aligned frame origins, each source frame can occupy one output frame.

When q is below one, repetition or interpolation is needed to fill the output grid. When q exceeds one, the output advances past some recorded frames, but a noninteger advance can still request intermediate times. Having many source frames does not guarantee that the two time grids line up exactly.

These equations describe frame mapping, not perceived quality. Finite outputs also need an endpoint policy: if requested duration × Fp is not an integer, the editor must choose how to handle the final partial interval. Check the rendered duration and final usable picture. A correctly mapped shot can still contain excessive capture blur, poor focus, compression damage, or distracting movement. Use the math to establish the question before evaluating the answer an algorithm supplies.

Work through three illustrative retiming examples

Example one: genuine 120 fps capture into 24 fps

Imagine a two-second capture containing 240 frames at exactly 120 fps. Playing those 240 frames once each at exactly 24 fps gives 240 / 24 = 10 seconds. Relative to the original two-second action, playback speed is 2 / 10 = 20%. No synthesized intermediate pictures are required for that mapping.

The source must actually be represented as 120 fps footage. Some cameras record high-speed action into a file already conformed for slow playback. Inspect the imported clip's rate and duration before applying another 20% change, or you may slow an already-slow file again. Apple's Automatic Speed explanation describes using every original frame at the project rate.

Example two: 30 fps converted to 60 fps without slowing

Imagine ten seconds represented by 300 frames at 30 fps. A ten-second 60 fps deliverable needs 600 output slots. Duplication could repeat existing images; blending or motion compensation could synthesize intermediate appearances. The action still takes ten seconds, so this is frame-rate conversion, not slow motion.

By contrast, playing those original 300 frames once each at 60 fps would take five seconds and speed the action up. Always record whether your operation changes timestamps, changes the number of output pictures, or both. A file's fps label does not describe the creative operation by itself.

Example three: a 30 fps shot at quarter speed in 24 fps

Imagine a four-second source selection. At 25% speed it lasts 16 seconds, so the 24 fps output needs 384 slots. The original selection contains 120 recorded frames, distributed across that longer duration: just 7.5 captured moments per output second.

The ratio is 384 / 120 = 3.2 output slots per recorded frame on average. That does not mean a simple repeat-each-frame-three-times recipe will work. Exact sample positions vary, and the beginning and end need explicit handling. If a hand crosses a face in this shot, interpolation is being asked to invent several appearances around a difficult event. Less extreme slowing or a different take may be the better edit.

Understand timestamps, fractions, and cadence

For an aligned constant-rate source, output frame number n occurs at output time n / Fp and requests source time S × n / Fp. Its fractional source-frame position is u(n) = n × Fs × S / Fp. An unaligned in-point adds an offset. Integer positions correspond to captured frames; fractional positions require a selection or synthesis policy.

Illustrative cadence calculation: use 30 fps source footage, 24 fps output, and 50% speed. The source-frame advance is 30 × 0.5 / 24 = 0.625.

The requested fractions are not all midpoints. A method that looks convincing at halfway positions may behave differently near an endpoint. A nearest-frame method and a floor-selection method can also produce different repeat patterns. Apple's rate-conform manual distinguishes those sampling choices.

Preserve exact rational rates. Source 60000/1001 into output 24000/1001 at 40% gives q = 1. True 60 fps into 24000/1001 at the same speed gives q = 1.001, not exactly one. Rounding both rates to convenient labels hides a real timing difference.

For variable-frame-rate sources, use actual presentation timestamps rather than applying a constant-Fs formula to every frame. A speed ramp also needs a changing source-time map, not one fixed multiplier. Inspect cadence across the ramp and export with the intended timestamps; a plausible header rate does not prove evenly timed motion.

Separate capture motion blur from interpolation

A camera frame integrates light during an exposure. That creates motion blur inside the recorded image. Interpolation estimates what to display between recorded images; it does not automatically replace the exposure history or recover a clean pose hidden by blur.

Illustrative capture comparison: a moving arm recorded at 30 fps with a 1/60-second exposure may occupy a long smear in each frame. The same action captured at 120 fps with a 1/240-second exposure can have less movement within each exposure, assuming other conditions are comparable. Slowing the first recording does not turn its smeared images into the second recording.

Shorter exposures can make correspondence easier by keeping some edges clearer, but they can also produce a sharper, more staccato appearance and require different lighting or sensitivity. Longer exposures can hide small cadence steps while making fine motion harder to estimate. Neither exposure choice is universally correct.

Frame-blended ghosting is not the same thing as physically captured motion blur. Two overlaid positions can look like transparent duplicates rather than one continuous exposure. Optical flow can warp the existing blur along with the subject, producing stretched trails or unstable edges.

Judge capture blur in original frames before blaming interpolation. Also distinguish temporal synthesis from AI upscaling and sharpening, which address spatial appearance. More pixels, stronger edges, and more output frames solve different problems; stacking them does not establish that missing detail has been recovered accurately.

Artifact atlas for difficult motion

This is a text diagnostic atlas, not a report of benchmark renders or a gallery of unseen comparison images. Use it to name a failure, locate its likely cause, and choose what to compare next. Artifacts are tendencies, not guaranteed outcomes for every implementation.

Occlusion deserves particular attention. When a person walks past a sign, part of the sign disappears and later reappears. The algorithm has evidence from neighboring views, but not necessarily the exact hidden appearance at every requested time. More computation cannot guarantee the true answer to an unobserved event.

Transparency presents a different ambiguity. A moving reflection in a window can overlap a stationary scene behind the glass. One apparent-motion estimate cannot always describe both layers. Alpha-channel support is another, separate question: a filter that processes ordinary opaque video is not automatically safe for a transparent overlay.

Cuts are not ordinary motion. FFmpeg's minterpolate documentation describes scene-change detection that substitutes duplicates instead of interpolated frames when a change is detected. Detection is useful, but it is not a guarantee; a flash can resemble a cut, and a subtle cut may be missed. Retiming isolated shots is safer than asking a method to interpret an assembled montage as continuous action.

Choose the least damaging method shot by shot

Start with captured frames when they provide the required timing. If the shot needs synthesized appearances, compare simple sampling, blending, and motion-aware output. A visually acceptable compromise is more useful than selecting the most elaborate mode by default.

Analysis and synthesis have costs: source resolution, output duration, output frame count, search settings, model design, hardware, and memory all matter. A larger search or a learned option is not automatically faster, slower, or better in every environment. Document the specific implementation when discussing cost.

Apple's retiming guide notes that its more advanced methods require analysis and rendering, and identifies hardware requirements for the machine-learning option. Those documented requirements are not comparative measurements of other editors. A preset named Better or Best should still pass your shot-level acceptance checks.

Consider an editorial alternative before escalating computation: use a shorter slowed interval, a different speed, another angle, a deliberate hold, or the native motion. Preserving a clean face can matter more than achieving the slowest possible gesture.

Run a reproducible comparison on your own footage

The following is a proposed comparison protocol, not a claim that we ran an external test. Its purpose is to make a reader's result repeatable and prevent differences in source selection, preview quality, or export settings from masquerading as algorithm differences.

1. Define the question. Record the action you want to emphasize, intended output rate, selected source interval, exact speed, and acceptable artifacts. Decide whether preserving factual detail is more important than perceived smoothness.
2. Freeze the source. Use the same source file and interpretation for every variant. Record its identity, rate or timestamp behavior, dimensions, color treatment, and whether it was already retimed. Keep the original available for reference.
3. Choose revealing excerpts. Include ordinary motion and difficult events such as a crossing limb, repeated pattern, or frame-edge entry. Preserve identical in-points, out-points, and available handles across variants. Do not give one method an easier portion of the take.
4. Duplicate the edit, not the task. Keep the same crop, speed curve, stabilization state, effects, project rate, and output dimensions. Change only the interpolation method for the baseline comparison. Record the method's quality or analysis settings explicitly.
5. Control analysis and caching. Wait for each required analysis and render to finish. Invalidate or rebuild stale results after changing relevant settings. Do not compare a cached final-quality variant with another variant still using a draft preview path.
6. Export comparable files. Use the same export codec, encoder settings, resolution, frame rate, color interpretation, and source representation. Avoid mixing proxy input with original input. A proxy workflow can help assembly, but final analysis must use the intended finishing media.
7. Review motion and individual frames. First watch at intended playback speed and display size, then frame-step the same critical timestamps. Inspect faces, hands, edges, repeated textures, and boundaries. Disable display motion smoothing when it would add another interpolation stage.
8. Record a decision with evidence. Note the artifact, affected time range, selected method, and reason. Retain rejected variants or their settings so another editor can reproduce the comparison without guessing.

Equal settings do not mean every algorithm has an equivalent internal quality slider. Use documented comparable final-quality configurations, explain remaining differences, and separate a baseline comparison from a later tuned comparison. Once you alter several parameters, record that you are comparing recipes rather than one isolated variable.

If you also measure processing time, specify hardware, software version, source range, cache state, background workload, and whether the clock includes analysis and encoding. Report repeated runs and variation rather than one unexplained number. No timing numbers in this guide represent such a measurement.

Finally, check the player. A dropped-frame preview can make a clean output look choppy. If results differ between viewers, investigate decoding and display cadence before changing the retime. Likewise, a paused frame that looks unusual may be unobtrusive in motion; evaluate both, with stricter standards when the picture communicates factual detail.

Use FFmpeg controls without changing the question

FFmpeg makes three separate operations explicit. Its fps filter converts to a constant output rate by duplicating or dropping frames. Its setpts filter changes presentation timestamps. Its minterpolate filter can fill an output frame grid through duplication, blending, or motion compensation.

Those distinctions prevent a common mistake: changing only the output rate and assuming the action must have slowed. Timestamp spacing controls duration; the resampling or interpolation stage controls the images supplied at the requested times.

For an illustrative half-speed video-only operation, doubling timestamp distances from the selected start would stretch the action, after which interpolation could supply the intended 24 fps output grid. That description is not a complete encoding command: trimming, timebase, endpoint handling, audio, pixel formats, and output encoding still need explicit decisions.

FFmpeg documents its blend mode as a mean of neighboring frames. Do not assume its output is identical to an editor's time-weighted frame blending at every fractional position. Nor should you assume mci reproduces a named commercial optical-flow mode. The documentation supports understanding the controls, not claiming equivalence among implementations.

Changing video timestamps alone does not correctly retime sound. Handle audio duration and any pitch-preservation processing separately, and verify synchronization after reassembly. A visually smooth comparison with an unnoticed audio mismatch is not a finished result.

Finish slow motion without breaking the edit

Retiming changes more than motion appearance. Extending a source selection may move later clips, or a fixed timeline slot may show less of the action. Apple's speed-change instructions distinguish those outcomes through ripple behavior. Check that the intended event still completes rather than assuming the old out-point remains meaningful.

Place titles, graphics, and final captions with the new timing in mind. When possible, interpolate the underlying shot before adding sharp overlays, rather than asking the motion estimator to carry both camera movement and independently animated lettering. If transparency must survive, verify the entire processing and export path explicitly.

Do not use optical flow as a universal repair for abrupt dialogue edits. Missing phonemes, unnatural breath timing, and unwanted cut placement are editorial problems; see removing silence without choppy cuts. A synthesized bridge can change a face without repairing the sentence.

For documentary, instructional, or evidentiary use, keep the unaltered source and identify synthesized slow motion when it could affect interpretation. Interpolation produces estimates, not recovered history. Content credentials for video address provenance questions, but provenance records do not independently prove that a synthesized intermediate pose is accurate.

We write as the Loopdesk Team. This article does not verify optical-flow, frame-blending, or learned-interpolation controls in Loopdesk. Consult the current Loopdesk feature specifications and confirm the specific retiming and export behavior before relying on it. Browser delivery or AI branding alone establishes neither the algorithm nor its suitability for your shot.

Use the slow motion worksheet and correctness checks

Keep the worksheet with the project, especially when the final render happens on another machine. Record exact values and observed acceptance decisions rather than only the chosen preset name.

Use four quick correctness checks. 120 into 24 at 20%: a one-to-one mapping is possible. 30 into 60 with unchanged duration: conversion, not slow motion. An output position of 1.875: not a captured frame index, so selection or synthesis policy matters. A smooth invented finger position: not proof that the finger was there during recording.

If those answers hold and the rendered excerpt passes the artifact checks, you have a defensible shot-level choice. Repeat the process for materially different footage rather than promoting one successful setting into a universal preset. The objective is controlled, understandable motion, not the largest frame count.

Frequently asked questions

What is the difference between optical flow and frame blending?

Frame blending combines neighboring images, often producing ghosting. Optical-flow interpolation estimates motion and warps image regions to create intermediate frames. It can look smoother but may distort difficult movement.

Is optical flow always better than frame blending?

No. It can fail around occlusion, fast limbs, fine patterns, transparency, and cuts. Compare identical rendered excerpts at the intended speed and output rate; choose the result with fewer distracting artifacts.

What speed makes 120 fps footage slow motion at 24 fps?

Use 20% speed for a one-to-one frame mapping: 24 / 120 = 0.2. A two-second capture becomes ten seconds. This assumes genuine 120 fps footage, exact 24 fps output, and no earlier slow-motion conform.

Does converting 30 fps to 60 fps create slow motion?

Not if duration stays unchanged. It creates twice as many output frame slots per second using repeated, blended, or synthesized images. Slow motion requires stretching the action over more playback time.

Can optical flow recover frames the camera missed?

No. It estimates plausible intermediate images from recorded frames; it cannot establish exactly what happened between exposures or reveal unseen detail with certainty. Preserve originals when factual accuracy matters.

Is AI interpolation separate from optical flow?

Not necessarily. Learned interpolation can estimate optical flow and blend warped frames. These labels describe overlapping techniques, not mutually exclusive categories or guaranteed quality levels.

Why do hands or faces warp in slow motion?

Fast movement, overlapping surfaces, blur, and newly revealed regions can confuse motion correspondence. Shorten the slow section, use a less extreme speed, try another method, or choose a better source take.

Should I judge interpolation while using proxies?

Use proxies to plan timing, but judge the final result with originals and final-quality rendering. Different input detail, caches, or preview quality can hide artifacts or change the analysis.

Does Loopdesk offer optical flow or learned interpolation?

This article does not verify those controls in Loopdesk. Check current feature specifications and confirm the supported retiming method, frame rates, and export behavior for your workflow.

Sources

Primary references checked on September 14, 2026. The arithmetic examples and comparison protocol are illustrative; this guide does not report external benchmark results.

• FFmpeg Filters: minterpolate — duplication, blending, motion compensation, rational output rates, and scene-change controls.
• FFmpeg Filters: fps — constant-rate conversion by duplication or dropping, including timestamp rounding.
• FFmpeg Filters: setpts and asetpts — presentation timestamps and speed-change expressions.
• Apple: Change clip speed — retiming, Automatic Speed, audio pitch, and interpolation options.
• Apple: Conform frame sizes and rates — sampling choices and project-rate interpretation.
• Huang and colleagues: Real-Time Intermediate Flow Estimation for Video Frame Interpolation — a primary research example of learned, flow-based interpolation.