# Multi-Frame Super-Resolution, Compared: BasicVSR, BSRT, and Deep Burst SR

- Link: https://blog.curbsoftware.com/civicset-multi-frame-super-resolution-compared/
- Published: 2026-08-16T00:00:00+00:00
- Author: curbsoftware

Every camera that shoots a burst or a video clip is quietly collecting more detail
than any single frame contains. Hand motion, rolling shutter, and optical blur scatter
that detail across neighboring frames at sub-pixel offsets: each frame samples the
scene through a slightly different grid. Multi-frame super-resolution (MFSR) is 
the family of techniques that registers those frames against each other and fuses
the scattered detail back into one image. The models differ enormously in what they
accept as input and how they align it, and those two choices explain almost everything
else about them.

This article compares three reference points in the modern landscape: **BasicVSR/
BasicVSR++** for continuous video, **Deep Burst Super-Resolution (DBSR)** for RAW
sensor bursts, and the **Burst Super-Resolution Transformer (BSRT)**, which pushed
burst SR further with transformer-based fusion.

## The classical foundation: shift-and-add

Before deep learning, MFSR was a registration-and-averaging problem. Estimate the
sub-pixel translation of each frame against a reference, resample every frame onto
a common high-resolution grid, and accumulate. The astronomy community's drizzle
algorithm formalized this for undersampled telescope imagery, and the same idea (
cross-correlation shift estimation, bilinear resampling into a float accumulator,
then a final upscale) remains a respectable baseline when frames differ only by 
translation. Its ceiling is equally well understood: it models none of the optics,
the noise, or the demosaicing, and it breaks down the moment motion stops being 
a pure translation. Everything below exists to remove one of those limitations.

## BasicVSR and BasicVSR++: the video baseline done right

BasicVSR (CVPR 2021) is a study in restraint. The authors decompose video super-
resolution into four functionalities (**propagation, alignment, aggregation, and
upsampling**) and then assemble a bidirectional recurrent network almost entirely
from generic parts: residual blocks for features, a small optical-flow network (
SPyNet) for alignment, and straightforward feature fusion before upsampling. Because
the recurrent stream passes information forward and backward through the whole sequence,
each output frame can draw on every other frame, not just its temporal neighbors.
The paper's claim is efficiency: it outperformed the state of the art of its time
with fewer parameters and faster inference, and it doubles as a backbone you can
extend. Its sibling IconVSR adds two such extensions (an information-refill mechanism
and coupled propagation) for sharper 4× results at comparable speed.

BasicVSR++ (CVPR 2022) is where the extensions get systematic. It replaces the propagation
structure with **second-order grid propagation** (each step reaches across the temporal
grid two frames back, not one) and swaps flow-warped alignment for **flow-guided
deformable alignment**, letting a deformable convolution refine the optical-flow
estimate in feature space. The reported gain over BasicVSR is **0.82 dB PSNR at 
a similar parameter count**. On the standard REDS4 benchmark (BI degradation), MMagic's
published checkpoints put BasicVSR at **31.42 dB / 0.8909 SSIM** and BasicVSR++ 
at **32.39 dB / 0.9069**; trained on Vimeo-90K instead, BasicVSR reaches **37.20
dB** on Vimeo-90K-T (BI). In competition, BasicVSR++ took three championships and
one runner-up finish across the NTIRE 2021 Video Restoration and Enhancement tracks.
Both models are maintained today inside [MMagic](https://github.com/open-mmlab/mmagic)(
configs and pretrained weights for BasicVSR, IconVSR, BasicVSR++, and RealBasicVSR),
which has effectively become the reference implementation.

## Deep Burst Super-Resolution: treating the sensor honestly

DBSR (CVPR 2021, Bhat et al.) changes the input contract. Instead of processed sRGB
frames, it consumes a burst of **noisy, mosaicked RAW images** (14 frames in its
benchmarks) and must produce a clean, demosaicked, 4×-super-resolved RGB image in
one pass. That contract folds three problems into one network: super-resolution,
denoising, and demosaicing.

Architecturally, DBSR extracts deep features from every frame and **aligns those
embeddings explicitly using pixel-wise optical flow** (a pretrained PWC-Net), rather
than warping pixels before feature extraction. An attention-based fusion module 
then decides, per location, how much each aligned frame contributes. Training uses
bursts synthesized from the Zurich RAW-to-RGB dataset through an inverse camera 
pipeline (translation, downsampling, mosaicing, and realistic noise) and evaluation
runs on both that synthetic set (300 validation bursts; the paper reports **39.09
dB PSNR / 0.945 MS-SSIM**) and the real-world BurstSR set of Samsung Galaxy S8 RAW
bursts with DSLR ground truth (**47.76 dB** under the challenge's alignment-and-
color-corrected metric, not comparable to the synthetic number, but indicative of
how much information a real burst carries).

DBSR also defined the benchmark it competes on: the [NTIRE 2021 Burst Super-Resolution Challenge](https://github.com/goutamgmb/NTIRE21_BURSTSR)
adopted its datasets and evaluation protocol, with DBSR serving as the challenge
baseline. The challenge itself was won by EBSR, a deformable-convolution approach
that, like several of its successors, borrowed DBSR's problem statement wholesale.

## BSRT: deformable alignment meets Swin Transformers

The Burst Super-Resolution Transformer (CVPR Workshops 2022, Luo et al.) starts 
from the same RAW-burst contract as DBSR but rebuilds the machinery. Alignment is
a **Pyramid Flow-Guided Deformable Convolution Network**: optical flow (again from
a pretrained PWC-Net) pre-aligns frames, and a pyramid of deformable convolutions
refines that alignment in feature space, aggregating texture across frames that 
flow alone cannot register. The backbone is built from **Swin Transformer blocks
and groups**, whose windowed attention captures long-range dependencies that convolutional
burst fusion misses. BSRT won the **real-world track of the NTIRE 2022 Burst Super-
Resolution Challenge** and set a new state of the art on both synthetic and real
BurstSR data, training on the NTIRE 2021 synthetic and real sets. An extended journal
version, BSRT++, followed in 2024. The [reference implementation](https://github.com/Algolzw/BSRT)
is MIT-licensed PyTorch, with one practical caveat: it builds DCNv2 (deformable 
convolution) from source, so reproducing it takes more than `pip install`.

## The wider map

Two neighbors are worth knowing. **EBSR**, the NTIRE 2021 winner mentioned above,
introduced the enhanced deformable-convolutional alignment grid that BSRT's flow-
guided variant builds upon. And in the satellite domain, the ESA Proba-V challenge
produced a family of non-sequential MFSR networks (DeepSum and its successors) that
register and fuse as few as nine low-resolution frames of the same ground patch;
a compact [PyTorch reimplementation](https://github.com/taynoel/Multi-Frame-Super-Resolution)
uses spatial-transformer registration nets with a two-stream fusion module, and 
is a readable example of the whole genre.

## Comparing them, dimension by dimension

### Input domain

 * **BasicVSR/++**: continuous sRGB video: frames are dense in time and already 
   processed.
 * **DBSR**: RAW Bayer bursts (RGGB, noisy, mosaicked), 14 frames, taken seconds
   apart.
 * **BSRT**: the same RAW burst contract as DBSR.
 * **Satellite MFSR**: short non-sequential bursts (9+ frames) of the same static
   target.

The RAW-versus-sRGB split is the most consequential line in the field: a RAW-domain
model inherits denoising and demosaicing as part of the task, and cannot be fed 
ordinary video without an inverse pipeline.

### Alignment mechanism

 * **BasicVSR**: optical-flow warping of features between recurrent steps.
 * **BasicVSR++**: flow-guided _deformable_ alignment: flow proposes, DCN refines.
 * **DBSR**: pixel-wise optical flow applied to deep feature embeddings.
 * **BSRT**: pyramid flow-guided deformable convolution: flow pre-alignment refined
   across scales.

The progression is consistent across both families: pure flow gives way to flow-
conditioned deformable convolution, because bursts and hard video motion violate
flow's smoothness assumptions.

### Aggregation and fusion

 * **BasicVSR/++**: implicit fusion inside the recurrent stream (plus IconVSR's 
   explicit information refills).
 * **DBSR**: attention-weighted per-location fusion of aligned embeddings.
 * **BSRT**: Swin Transformer burst fusion over aligned multi-frame features.

### What the network owes you

A video model owes one upsampled frame per input frame. A burst model owes a single
clean RGB image (super-resolution _plus_ denoising _plus_ demosaicing) from the 
whole burst. The second contract is harder, which is why RAW burst models can post
PSNR numbers that look (and are) incomparable with sRGB video benchmarks.

### Efficiency and practicality

BasicVSR's founding claim was efficiency against then-SOTA, and it still holds: 
it remains the sensible default when compute matters. BasicVSR++ buys 0.82 dB for
a similar parameter count. The burst models are a different regime (trained on multi-
GPU setups with patch-based crops) and BSRT adds a from-source DCNv2 build to the
bill.

### Code, weights, and licenses

 * [BasicVSR / IconVSR](https://github.com/ckkelvinchan/BasicVSR-IconVSR) (Apache-
   2.0), with maintained configs and weights in [MMagic](https://github.com/open-mmlab/mmagic).
 * [DBSR](https://github.com/goutamgmb/deep-burst-sr) and the [NTIRE21 challenge toolkit](https://github.com/goutamgmb/NTIRE21_BURSTSR).
 * [BSRT](https://github.com/Algolzw/BSRT) (MIT).

## Further reading

 * [BasicVSR: The Search for Essential Components in Video Super-Resolution and Beyond](https://arxiv.org/abs/2012.02181),
   Chan et al., CVPR 2021, plus the [project page](https://ckkelvinchan.github.io/projects/BasicVSR/).
 * [Deep Burst Super-Resolution](https://arxiv.org/abs/2101.10997), Bhat et al.,
   CVPR 2021.
 * [BSRT: Improving Burst Super-Resolution with Swin Transformer and Flow-Guided Deformable Alignment](https://arxiv.org/abs/2204.08332),
   Luo et al., CVPR Workshops 2022.
 * MMagic config readmes for [BasicVSR](https://github.com/open-mmlab/mmagic/blob/main/configs/basicvsr/README.md)
   and [BasicVSR++](https://github.com/open-mmlab/mmagic/blob/main/configs/basicvsr_pp/README.md)
   carry the full benchmark tables and training recipes.

The unifying lesson across all of them is the one the classical shift-and-add baseline
already taught: alignment quality bounds everything downstream. What changed is 
that alignment moved into feature space, became learnable, and now carries most 
of the performance gains the field has made since.
