FidelityFX Super Resolution

FidelityFX Super Resolution 1.0 (FSR)

Copyright (c) 2021 Advanced Micro Devices, Inc. All rights reserved. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Super Resolution (FSR)

Screenshot

AMD FidelityFX Super Resolution (FSR) is an open source, high-quality solution for producing high resolution frames from lower resolution inputs.

It uses a collection of cutting-edge algorithms with a particular emphasis on creating high-quality edges, giving large performance improvements compared to rendering at native resolution directly. FSR enables “practical performance” for costly render operations, such as hardware ray tracing.

You can find the binaries for FidelityFX FSR in the release section on GitHub.

Build Instructions

Prerequisites

To build the FSR sample, please follow the following instructions:

  1. Install the following tools:
  1. Generate the solutions:

    > cd \build
    > GenerateSolutions.bat
    
  2. Open the solutions in the DX12 or Vulkan directory (depending on your preference), compile and run.

Owner
GPUOpen Effects
Real-time visual effects from the GPUOpen initiative
GPUOpen Effects
Comments
  • AMD should reuse/adapt the academic State Of The Arts

    AMD should reuse/adapt the academic State Of The Arts

    Hi @rys It is often deeply institutionalized in companies and even in the human nature, to reinvent the wheel or to work in isolation. I have much admiration for AMD and its software developers and trying new approaches is a way to drive innovation. AMD FSR while not using neural networks is a very interesting way to look at the problem.

    But please AMD you are not alone, there is a widespread community of very smart people out there: the scholars and they regularly release innovations in machine learning, especially regarding the topic of super-resolution. It would be a shame if you didn't take strong inspiration from their amazing ideas that can be combined in order to create a synergetic algorithm, on par or superior to DLSS.

    The #1 reference website for tracking the state of the art is paperswithcode.com See: https://paperswithcode.com/task/multi-frame-super-resolution https://paperswithcode.com/task/image-super-resolution https://paperswithcode.com/task/video-super-resolution https://paperswithcode.com/task/super-resolution https://paperswithcode.com/task/3d-object-super-resolution Note that i also invite for a collaboration with Intel XeSS. You might also take inspiration from this new Nvidia open source library: https://www.phoronix.com/scan.php?page=news_item&px=NVIDIA-Image-Scaling-SDK

    The graal would be if for your next neural based DLSS competitor, to publish your results (PSNR, SSIM) on the same benchmarcks as paperswithcode.com, additionally it would be a great scientific contribution if you could submit to paperswithcode.com game/textures oriented datasets.

  • Strange noise

    Strange noise

    When I execute the FSRSample in my system (AMD RX 6800 XT Midnight Black), I hear a high-pitch noise apparently coming from the GPU. The noise changes as I rotate the scene or change options. I doesn't seem caused by fans, this doesn't happen running any game or other GPU-intensive program, including the Radeon app's GPU Stress Test. I am not crazy :) I can share a video that will show this behavior if necessary, the noise is low but very noticeable.

  • Noise free feature

    Noise free feature

    In FSR integration guide, it suggests FSR should be used before any effects introduce noise, if there is case I can't access engine source code, so I cant avoid this. Is there any idea or direction to investigate to apply FSR on the final image which has noise effect?

  • Update tools section in readme.md

    Update tools section in readme.md

    Summary of changes:

    1. Added Git as a required tool because GenerateSolutions.bat runs Git commands.
    2. Added instruction to install the "Desktop Development with C++" workload.
  • [iGPU as FSR Renderer] AMD Advantage Program Laptops

    [iGPU as FSR Renderer] AMD Advantage Program Laptops

    Attn FSR Team,

    Below Twitter video shares how iGPU could be utilized to boost FSR performance (10-25 FPS gain) by offloading FSR to iGPU and allowing dGPU handle the game code itself: https://twitter.com/Rommex1/status/1442579419177144322

    I wonder if this could becoming an official feature, as laptops such as AMD Advantage Program units (ASUS, MSI, Dell), where you have iGPU from AMD and dGPU from AMD, allowing iGPU handle FSR, could be indeed an interesting feature.

    Share your thoughts please,

    Thank you.

  • Bug fix to restore non-clipping behavior

    Bug fix to restore non-clipping behavior

    There is a bug in the {hitMin,hitMax} computation. The 'mn' and 'mx' variables only contain the {b,d,f,h} ring of taps (this is needed for the rcp() based term). However it is possible that the center {e} tap could exceed the minimum and maximum of the {b,d,f,h} ring, causing incorrect function. This change places {e} tap back into the non-rcp() based term for 'hitMin' and 'hitMax' correcting the maths and restoring non-clipping output. The bug manifests visually as over-sharpening isolated pixels.

  • DirectX Shader Compiler warning when disabling SAMPLE_SLOW_FALLBACK with VK FSR_Pass.hlsl shader

    DirectX Shader Compiler warning when disabling SAMPLE_SLOW_FALLBACK with VK FSR_Pass.hlsl shader

    When the "SAMPLE_SLOW_FALLBACK " is disabled, The DirectX Shader Compiler shows the warning:

    Dxil Compile: EngineShaders/FSR_Pass.hlsl:63:37: warning: conversion from larger type 'vector<float, 4>' to smaller type 'float16_t4', possible loss of data [-Wconversion] AH4 FsrRcasLoadH(ASW2 p) { return InputTexture.Load(ASW3(ASW2(p), 0)); }

  • question about luma*2

    question about luma*2

    Hi! about RCAS, why it is calculated as L = B*0.5 + (R*0.5) + G? I searched Luma at wiki。 B's coefficient seems is always <= 1.2, why using 0.5 as B's coefficents in code?

      // Luma times 2.
      AF1 bL=bB*AF1_(0.5)+(bR*AF1_(0.5)+bG);
      AF1 dL=dB*AF1_(0.5)+(dR*AF1_(0.5)+dG);
    

    I'm very confused about this , cloud you please teach me? Thanks so much!

  • Possible forgotten use of FSR_RCAS_DENOISE?

    Possible forgotten use of FSR_RCAS_DENOISE?

    Hi,

    We're implementing FSR in our project https://github.com/mbucchia/OpenXR-Toolkit and you have done an amazing job. It has been very easy to integrate and it is giving very good results in VR.

    I might be wrong but unless the shader compiler optimizes this out, it seems to me the following 3 lines of code could be enclosed in a #ifdef FSR_RCAS_DENOISE block, otherwise the shader is computing the nz value for nothing:

    https://github.com/GPUOpen-Effects/FidelityFX-FSR/blob/a21ffb8f6c13233ba336352bdff293894c706575/ffx-fsr/ffx_fsr1.h#L737-L739

    Thanks!

  • FSR code doesn't compile for HLSL 2021

    FSR code doesn't compile for HLSL 2021

    Hi,

    Microsoft recently upgraded its DXC compiler with new HLSL features.

    In HLSL 2021, int3 Z = X ? 1 : 0; has to be replaced with int3 Z = select(X, 1, 0);:

    In the case of FSR, lines 2040-2042 in ffx_a.h:

    AF2 AZolZeroPassF2(AF2 x,AF2 y){return AF2_AU2((AU2_AF2(x)!=AU2_(0))?AU2_(0):AU2_AF2(y));}
    AF3 AZolZeroPassF3(AF3 x,AF3 y){return AF3_AU3((AU3_AF3(x)!=AU3_(0))?AU3_(0):AU3_AF3(y));}
    AF4 AZolZeroPassF4(AF4 x,AF4 y){return AF4_AU4((AU4_AF4(x)!=AU4_(0))?AU4_(0):AU4_AF4(y));}
    

    Gives this error:

    ffx_a.h:2040:124: error: condition for short-circuiting ternary operator must be scalar
      float32_t2 AZolZeroPassF2(float32_t2 x,float32_t2 y){return asfloat(uint32_t2((asuint(float32_t2(x))!=AU2_x(uint32_t(0)))?AU2_x(uint32_t(0)):asuint(float32_t2(y))));}
    

    It can be fixed this way:

    AF2 AZolZeroPassF2(AF2 x,AF2 y){return AF2_AU2(select(AU2_AF2(x)!=AU2_(0),AU2_(0),AU2_AF2(y)));}
    AF3 AZolZeroPassF3(AF3 x,AF3 y){return AF3_AU3(select(AU3_AF3(x)!=AU3_(0),AU3_(0),AU3_AF3(y)));}
    AF4 AZolZeroPassF4(AF4 x,AF4 y){return AF4_AU4(select(AU4_AF4(x)!=AU4_(0),AU4_(0),AU4_AF4(y)));}
    

    Alternatively, one can use the __HLSL_VERSION to detect if the shader is being compiled with -HV 2021:

    #if __HLSL_VERSION==2021
      AF2 AZolZeroPassF2(AF2 x,AF2 y){return AF2_AU2(select(AU2_AF2(x)!=AU2_(0),AU2_(0),AU2_AF2(y)));}
      AF3 AZolZeroPassF3(AF3 x,AF3 y){return AF3_AU3(select(AU3_AF3(x)!=AU3_(0),AU3_(0),AU3_AF3(y)));}
      AF4 AZolZeroPassF4(AF4 x,AF4 y){return AF4_AU4(select(AU4_AF4(x)!=AU4_(0),AU4_(0),AU4_AF4(y)));}
    #else
      AF2 AZolZeroPassF2(AF2 x,AF2 y){return AF2_AU2((AU2_AF2(x)!=AU2_(0))?AU2_(0):AU2_AF2(y));}
      AF3 AZolZeroPassF3(AF3 x,AF3 y){return AF3_AU3((AU3_AF3(x)!=AU3_(0))?AU3_(0):AU3_AF3(y));}
      AF4 AZolZeroPassF4(AF4 x,AF4 y){return AF4_AU4((AU4_AF4(x)!=AU4_(0))?AU4_(0):AU4_AF4(y));}
    #endif
    
  • Question to FSR Team at AMD

    Question to FSR Team at AMD

    Question Below:

    Could you tell us more about how FSR benefits from the programmable cores within RDNA2 and if we have any plans to see AI/ML based FSR in the future? Now with AMD having data center facilities and powerful ML machines, it could be interesting.

Video, Image and GIF upscale/enlarge(Super-Resolution) and Video frame interpolation. Achieved with Waifu2x, SRMD, RealSR, Anime4K, RIFE, CAIN, DAIN and ACNet.
Video, Image and GIF upscale/enlarge(Super-Resolution) and Video frame interpolation. Achieved with Waifu2x, SRMD, RealSR,  Anime4K, RIFE, CAIN, DAIN and ACNet.

Video, Image and GIF upscale/enlarge(Super-Resolution) and Video frame interpolation. Achieved with Waifu2x, SRMD, RealSR, Anime4K, RIFE, CAIN, DAIN and ACNet.

Nov 30, 2022
Implementing Deep Convolutional Neural Network in C without External Libraries for YUV video Super-Resolution
Implementing Deep Convolutional Neural Network in C without External Libraries for YUV video Super-Resolution

DeepC: Implementing Deep Convolutional Neural Network in C without External Libraries for YUV video Super-Resolution This code uses FSRCNN algorithm t

Nov 28, 2022
[CVPR 2021] NormalFusion: Real-Time Acquisition of Surface Normals for High-Resolution RGB-D Scanning

NormalFusion: Real-Time Acquisition of Surface Normals for High-Resolution RGB-D Scanning Project Page | Paper | Supplemental material #1 | Supplement

Nov 24, 2022
Super Mario Remake using C++, SFML, and Image Processing which was a project for Structure Programming Course, 1st Year
Super Mario Remake using C++, SFML, and Image Processing which was a project for Structure Programming Course, 1st Year

Super Mario Remake We use : C++ in OOP concepts SFML for game animations and sound effects. Image processing (Tensorflow and openCV) to add additional

Sep 28, 2022
New ultra super robust and fast programming language, fully supportable by G++ and Clang

Cplusplusplus New ultra super robust and fast programming language, fully supportable by G++ and Clang How to use: Just write #include <C+++.h> in you

Nov 29, 2021
Super paramagnetic Clustering - Marcelo Blatt, Shai Wiseman, and Eytan Domany (1996)

SPC: Super Paramagnetic Clustering Documentation The file README.PDF includes: installation instructions, example runs, file formats and parameter def

Aug 30, 2022
Simple command line tool that processes image files using the FidelityFX Super Resolution (FSR) or Contrast Adaptive Sharpening (CAS) shader systems.

Simple command line tool that processes image files using the FidelityFX Super Resolution (FSR) or Contrast Adaptive Sharpening (CAS) shader systems.

Nov 20, 2022
FidelityFX Super Resolution
FidelityFX Super Resolution

FidelityFX Super Resolution 1.0 (FSR) Copyright (c) 2021 Advanced Micro Devices, Inc. All rights reserved. Permission is hereby granted, free of charg

Nov 26, 2022
Video, Image and GIF upscale/enlarge(Super-Resolution) and Video frame interpolation. Achieved with Waifu2x, SRMD, RealSR, Anime4K, RIFE, CAIN, DAIN and ACNet.
Video, Image and GIF upscale/enlarge(Super-Resolution) and Video frame interpolation. Achieved with Waifu2x, SRMD, RealSR,  Anime4K, RIFE, CAIN, DAIN and ACNet.

Video, Image and GIF upscale/enlarge(Super-Resolution) and Video frame interpolation. Achieved with Waifu2x, SRMD, RealSR, Anime4K, RIFE, CAIN, DAIN and ACNet.

Nov 30, 2022
Super Mario World Widescreen is your beloved Mario World SNES game but in the 16:9 resolution.
Super Mario World Widescreen is your beloved Mario World SNES game but in the 16:9 resolution.

Super Mario World Widescreen is your beloved Mario World SNES game but in the 16:9 resolution. This is possible by expanding the horizontal resolution by 96 pixels, increasing resolution from 256x224 to 352x224. Since the original SNES does not have this resolution, the emulator focused into high definition mods bsnes-hd must be used.

Nov 23, 2022
Video, Image and GIF upscale/enlarge(Super-Resolution) and Video frame interpolation. Achieved with Waifu2x, SRMD, RealSR, Anime4K, RIFE, CAIN, DAIN and ACNet.
Video, Image and GIF upscale/enlarge(Super-Resolution) and Video frame interpolation. Achieved with Waifu2x, SRMD, RealSR,  Anime4K, RIFE, CAIN, DAIN and ACNet.

Video, Image and GIF upscale/enlarge(Super-Resolution) and Video frame interpolation. Achieved with Waifu2x, SRMD, RealSR, Anime4K, RIFE, CAIN, DAIN and ACNet.

Nov 23, 2022
Implementing Deep Convolutional Neural Network in C without External Libraries for YUV video Super-Resolution
Implementing Deep Convolutional Neural Network in C without External Libraries for YUV video Super-Resolution

DeepC: Implementing Deep Convolutional Neural Network in C without External Libraries for YUV video Super-Resolution This code uses FSRCNN algorithm t

Nov 28, 2022
Add FidelityFX SuperResolution to SteamVR games

Modified OpenVR DLL with AMD FidelityFX SuperResolution Upscaler This modified openvr_api.dll allows you to apply FidelityFX SuperResolution upscaling

Nov 23, 2022
A sample demonstrating hybrid ray tracing and rasterisation for shadow rendering and use of the FidelityFX Denoiser.
A sample demonstrating hybrid ray tracing and rasterisation for shadow rendering and use of the FidelityFX Denoiser.

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Nov 30, 2022
This repository is used for automatic calibration between high resolution LiDAR and camera in targetless scenes.
This repository is used for automatic calibration between high resolution LiDAR and camera in targetless scenes.

livox_camera_calib livox_camera_calib is a robust, high accuracy extrinsic calibration tool between high resolution LiDAR (e.g. Livox) and camera in t

Nov 26, 2022
Multi-GNSS Precise Point Postioning with Ambiguity Resolution

This is demo for multi-GNSS precise point positioning with ambiguity resolution (PPP-AR), which is based on RTKLIB and RTKLIB_demo5. FEATURES ppp-ar w

Sep 30, 2022
[CVPR 2021] NormalFusion: Real-Time Acquisition of Surface Normals for High-Resolution RGB-D Scanning

NormalFusion: Real-Time Acquisition of Surface Normals for High-Resolution RGB-D Scanning Project Page | Paper | Supplemental material #1 | Supplement

Nov 24, 2022
A simple single header C/C++ Library for AABB Collision detection and resolution.
A simple single header C/C++ Library for AABB Collision detection and resolution.

A simple single header C/C++ Library for AABB Collision detection and resolution

Nov 14, 2021
Patch Onimusha 3 to allow any screen resolution and configure inputs.
Patch Onimusha 3 to allow any screen resolution and configure inputs.

Onimusha3Patch Patch Onmimusha 3 to allow any screen resolution. Fix the Configure input menu (see Configure input patch directory). How to use Compil

Nov 26, 2021
Display array is a board that sets 6 ST7735 display with a resolution of 80x160px in a linear array sharing the clock, data, rs, backlight pins together
Display array is a board that sets 6 ST7735 display with a resolution of 80x160px in a linear array sharing the clock, data, rs, backlight pins together

The display array is a board that sets 6 ST7735 display with a resolution of 80x160px in a linear array sharing the clock, data, rs, backlight pins together, and leaving individual access to the cs lines of each display, This board allows you to display images with a resolution of 480x160px.

Oct 29, 2022