Summary of "Как работает виртуальное разрешение (DL)DSR | Как настроить плавность?"

Main ideas and concepts covered

Why “smoothness” matters in (DL)DSR
- The talk focuses on what DSR/DLDSR actually do and what the smoothness slider controls.
- It clarifies that DLDSR is not just “DSR with the same slider.”
- DLDSR uses a separate neural-network-based reconstruction that already changes sharpness, and then the smoothness parameter can further reduce “excess” sharpness.
Core prerequisite: image sampling and aliasing
- The video starts from signal processing to explain sampling frequency and how aliasing happens when samples are insufficient.
- In rendering:
  - A continuous scene is sampled into a discrete pixel grid.
  - Higher resolution = more samples = better reconstruction.
- Insufficient sampling causes high-frequency detail to break first (similar to how aliasing shows up in audio).
Two different resolutions: input vs output
- Input resolution: how the engine/camera samples the 3D scene.
- Output resolution: the final rasterized image sent to the display.
- If the input lacks detail, distant/small/high-detail regions can show artifacts.
- The solution is to increase effective sampling using (virtual) higher resolution.
What virtual resolution (DSR/DLDSR) does
- DSR/DLDSR tricks the game into rendering to a larger internal render target than the monitor’s native resolution.
- Example:
  - Monitor: 1920×1080
  - DSR factor 2.25 → render target becomes ~2880×1620
- This can be verified with a GPU/debug tool (e.g., RenderDoc) by checking the swapchain image resolution before presentation.
- The upscaled render target is then downsampled by the driver/display path to fit the monitor.
Why DSR quality can degrade for certain scaling factors
- When the scaling ratio is not a clean multiple of 2, the downsampling alignment becomes irregular.
- This can cause:
  - severe aliasing
  - irregular edges
  - “shimmering”/pixel-level artifacts (especially noticeable on hair/shaders)
- This is a key motivation for DLDSR.
DLDSR’s advantage (neural reconstruction)
- DLDSR is introduced as a neural-network-based approach (convolutional architecture + trained weights).
- It aims to reduce the artifacts that appear in regular DSR with non-multiple scaling.
- Claims mentioned in comparisons:
  - DLDSR at ~2.25× can produce edge quality comparable to DSR 4×
  - DLDSR reduces aliasing and improves edge handling under both TAA and non-TAA situations.
The smoothness slider: what it actually controls
- The slider corresponds to how aggressively the system filters/smooths during downsampling.
- Regular DSR downsampling uses a Gaussian blur / convolution filter:
  - NVIDIA describes a 13-point Gaussian filter
  - The kernel is 13×13, conceptually implementable as two passes 13×1 + 1×13 for performance
- Main controllable parameter: sigma (standard deviation):
  - Larger sigma → stronger averaging → more blur
  - Smaller sigma (near 0) → less smoothing → sharper, but can lead to overly sharp / excess sharpness
Why smoothness exists: balancing detail vs artifacts
- DSR’s goal is essentially: “render high detail, then compress.”
- Without enough smoothing, downsampling can preserve undesirable high-frequency behavior, producing an over-sharpened look.
- Too much smoothing causes visible blur.
- The slider is presented as a subjective tuning knob because different users prefer different tradeoffs.
Testing DLDSR vs DSR and verifying the slider effect
- Subjective comparisons:
  - DLDSR vs DSR at comparable factors
  - with and without smoothness adjustments
- Objective evaluation:
  - The speaker uses SSIM (Structural Similarity Index) to measure pixel-by-pixel visual similarity.
- Key conclusion described:
  - With appropriate settings, DLDSR is not worse than regular DSR at similar effective detail, and may be better or comparable—including cases around half input resolution.
  - SSIM suggests smoothness=0% can cause more measurable deviation than mid-range smoothing.
Where this leads next
- A follow-up is promised on:
  - resolution/sampling in more detail
  - what upscalers (like DLSS) do algorithmically
  - why that’s complex

Methodologies / “instruction-like” elements presented

1) Understanding aliasing via sampling (conceptual steps)

Treat images as signals (a 2D generalization of 1D audio signals).
Recognize frequency meaning:
- High frequencies → rapid changes / fine detail
- Low frequencies → smooth areas
Apply the sampling principle:
- Digitization needs enough samples; otherwise aliasing occurs.
Connect to rendering:
- If the render/input resolution can’t represent high-frequency content, those details become distorted.

2) Checking what resolution DSR actually renders at (practical workflow described)

Use a GPU debugger (example: RenderDoc).
Inspect the frame right before it is presented (before present).
Examine the Swapchain image / render target dimensions.
Confirm that enabling DSR at a factor (example 2.25×) yields an internal target such as:
- 1920×1080 → ~2880×1620

3) Comparing (DL)DSR quality: subjective + objective approaches

Subjective comparisons
- Compare visually across:
  - native/in-game scaling
  - DSR at a factor (e.g., 2.25× and/or 4×)
  - DLDSR at a factor (e.g., 2.25×)
- Adjust “smoothness” when needed for fair visual comparison.
Objective pixel similarity
- Ensure images align pixel-by-pixel (e.g., consistent camera position via a photo mode workflow).
- Compute SSIM between image pairs.
- Interpret SSIM:
  - near 1.0 → very similar
  - lower values → more structural/perceptual differences

Speakers / sources featured (and referenced)

Speaker

M. (the presenter)

Referenced external sources / creators / organizations

Digital Foundry (referenced for visual comparison and discussion)
Alex Batalia (research/video referenced; notably in 2022)
NVIDIA (documentation and claims about DSR filtering/Gaussian filter)
AMD (mentioned in the context of VSR)
YouTube video about DLSS / prior work by the same speaker (referenced from 2021)
Habr (referenced as a source for Gaussian/kernel visualization)
SSIM (Structural Similarity Index) methodology
Nyquist–Shannon theorem / Kotelnikov theorem (sampling theory underlying the discussion)