Introduction

AMD FidelityFX Super Resolution 2.0 (FSR 2.0) is available from tomorrow, May 12, with the latest version of "Deathloop." Announced earlier this Spring, FSR 2.0 is a major update to AMD's performance enhancement rivaling NVIDIA DLSS, which lets you improve framerates at minimal loss to image quality. Both FSR and DLSS work on the principle of getting the game to render everything except the HUD and post-FX at a lower resolution than the display is capable of and upscaling it using sophisticated algorithms that make the output look as if it were rendered at native resolution. AMD and NVIDIA take different paths to achieving this goal.



In this review, we're comparing FSR 2.0 and its various performance levels with the image quality of FSR 1.0 and NVIDIA DLSS / DLAA.

FSR 1.0 Recap

Let's start with a quick history lesson. AMD's first version of FidelityFX Super Resolution, aka "FSR 1.0" (our review), launched roughly one year ago, takes into account only the currently displayed image, and upscales it using the Lanczos algorithm. Even though it's a relatively simple approach, the results were astonishing, especially considering the limited complexity of the algorithm. Working with only a single frame means FSR 1.0 had only limited information to work with—this was NVIDIA's strongest argument for DLSS. DLSS, on the other hand, takes a sequence of images, i.e., it has knowledge of the recent history, which gives it additional information it fuses into the single output frame, making it more than an upscaler. The drawback of such temporal algorithms is that the scene in a video game is not static and rather changes all the time, which can often lead to ghosting artifacts, but more on that later.

FSR 2.0

In order to generate a better output image, FSR needs more data, which is why AMD created a temporal upscaling algorithm that is conceptually roughly similar to NVIDIA's DLSS 2.0. Much like FSR 1.0, FSR 2.0 is a shader-based technology, which relies on programmable shaders and hence is hardware-agnostic—it is designed to work on all hardware, even graphics cards from NVIDIA and Intel. DLSS, on the other hand, is an NVIDIA-exclusive technology that uses the AI-math-optimized Tensor Cores available in newer generations of NVIDIA hardware.

Under the hood, FSR 2.0 still uses the Lanczos algorithm to upscale the low-resolution image to the final render size. Instead of taking just the current frame as input, data from several frames is combined into a single buffer, which is then upscaled using Lanczos. The frames the game developers feed to FSR have to be slightly jittered, which means the camera moves by a tiny tiny sub-pixel-sized amount to pick up additional information for each frame. FSR will then assign an "importance" score to each pixel that not only takes into account how old that information is, but also the distance to the target pixel.


FSR 2.0 sits at the same location in the game's rendering pipeline as FSR 1.0. It takes in the 3D scene ("Color Buffer") rendered by the game at a lower resolution, just like FSR 1.0. What's new is that game developers now feed motion vectors and depth information into the algorithm, too, just like in DLSS 2.0.

Motion vectors are a piece of information that express how the scene has changed from one frame to the other. For example, when the player pans the camera in a first-person game, the whole "screen" moves in a specific direction—that's encoded in the motion vectors. What's stored as well is how things like enemies and animated objects in the scene have moved. Basically, it's a map of pixels that has data for each pixel, from where to where it moved between two consecutive frames.

The depth buffer is used to express the distance from the camera for each single pixel on screen. The screen image on your monitor is just lots of colored pixels, your brain then figures out what objects you're supposed to see and how far they are away. To make it easy for FSR to calculate distances, the depth buffer is generated by the game and contains a number for each pixel that doesn't represent its color, but the distance to the underlying visible object instead. This information is used by FSR 2.0 to eliminate ghosting artifacts.