Initial content

.gitattributes

@@ -33,3 +33,10 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.dds filter=lfs diff=lfs merge=lfs -text
+*.vgf filter=lfs diff=lfs merge=lfs -text
+*.dll filter=lfs diff=lfs merge=lfs -text
+*.exe filter=lfs diff=lfs merge=lfs -text
+*.spv filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,2 @@
+out/
+bin/linux-x86_64/

LICENSE

@@ -0,0 +1,2 @@
+The license for the model source code can be found at https://github.com/arm/neural-graphics-model-gym/blob/main/LICENSES/Apache-2.0.txt
+The license for the content of this repository can be found in Arm_AI_Model_Community_License_v1_0_PRE-1154.pdf

README.md

@@ -0,0 +1,150 @@
+---
+license: other
+pipeline_tag: image-to-image
+tags:
+- android
+- neural-graphics
+- gaming
+- graphics
+language:
+- en
+---
+
+# Neural Super Sampling (NSS)
+
+Neural Super Sampling (NSS) is an innovative, efficient network for temporal super sampling on mobile devices. Content rendered at 540p can be upscaled to 1080p, resulting in up to 50% GPU savings. With our retraining tools content creators and game studios can build derivatives of the model suited to artwork style and performance requirements.
+
+### 🎥 Neural Super Sampling Demo
+
+<video controls width="100%">
+  <source src="https://huggingface.co/Arm/TestNSS/resolve/main/resources/Enchanted_Castle_NSS_Demo.mp4" type="video/mp4">
+  Your browser does not support the video tag.
+</video>
+
+[▶️ Watch in separate tab](https://huggingface.co/arm/nss/resolve/main/nss_demo.mp4)
+
+## Model Details
+
+Neural Super Sampling (NSS) is a parameter prediction model for real-time temporal super sampling developed by Arm, optimized for execution on Neural Accelerators (NX) in mobile GPUs. It enables high-resolution rendering at a lower compute cost by reconstructing high-quality output frames from low-resolution temporal inputs. NSS is particularly suited for mobile gaming, XR, and other power-constrained graphics use cases.
+
+- **Developed by:** Arm Limited
+- **Model type:** Temporal image super sampling
+- **License:** Other
+- **Repository:** [Neural Graphics Model Gym](https://github.com/arm/neural-graphics-model-gym)
+- **Paper:** [How Neural Super Sampling Works](https://community.arm.com/arm-community-blogs/b/mobile-graphics-and-gaming-blog/posts/how-arm-neural-super-sampling-works) 
+- **Quickstart with ML extensions for Vulkan®**: [ML extensions for Vulkan® Quickstart Guide](https://learn.arm.com/learning-paths/mobile-graphics-and-gaming/vulkan-ml-sample/)
+- **Quickstart with Unreal**: [Neural Super Sampling Quickstart Guide](https://learn.arm.com/learning-paths/mobile-graphics-and-gaming/nss-unreal/) for NSS integration into Unreal Engine
+
+NSS is under active development with regular updates planned. Follow Arm to get the latest.
+
+## Uses
+
+NSS can be directly integrated into graphics pipelines using ML extensions for Vulkan®. See included ML SDK for Vulkan [scenario](https://huggingface.co/Arm/TestNSS/tree/main/scenario) for the simplest way to evaluate the model. The scenario includes the necessary pre- and post-processing compute shaders along with a single frame worth of input data.
+
+The recommended way of integrating the model into a graphics pipeline is by using the [VGF Library](https://github.com/arm/ai-ml-sdk-vgf-library/tree/main) from the ML SDK for Vulkan. 
+
+NSS is released under a [permissive license](https://huggingface.co/Arm/TestNSS/blob/main/Arm_AI_Model_Community_License_v1_0_PRE-1154.pdf) designed to foster innovation in the graphics industry and provide differentiation to content creators.
+
+### Direct Use
+
+NSS has been integrated into Unreal Engine via two plugins, the [NSS Plugin for Unreal Engine](https://github.com/arm/nss-unreal-plugin/) and [Unreal NNE Plugin for ML extensions for Vulkan](https://github.com/arm/ml-extensions-for-vulkan-unreal-plugin/). See our [quick start guide](https://learn.arm.com/learning-paths/mobile-graphics-and-gaming/nss-unreal/) for step-by-step instructions on how to use NSS in Unreal® Engine.
+
+### Out-of-Scope Use
+
+- Not suited for non-temporal tasks such as a standalone image upsampling
+
+## Bias, Risks, and Limitations
+
+- Requires accurate motion vectors and frame history for stable output
+- May underperform in extremely low framerate scenarios (<10 FPS) with fast camera movement
+- Padding of the input is needed if input dimensions are not divisible by 8
+
+### Recommendations
+
+For ultra-low-FPS use cases, reduce the camera speed, acceleration, or both so that the relative motion between frames mimics the
+application running at a higher frame rate.
+
+## How to Get Started with the Model
+
+This repository contains pre-trained weights and compiled NSS model in VGF format ready for integration with Vulkan applications.
+
+The included Scenario demonstrates full execution of the model on a Vulkan compute-capable system. An Emulation Layer is provided to implement ML Extensions for Vulkan where it is not supported by the native Vulkan driver.
+
+### Download and Prepare the Scenario
+
+Clone the NSS model repository from Hugging Face
+```powershell
+git clone https://huggingface.co/Arm/TestNSS
+cd TestNSS
+```
+
+### Run the Scenario
+
+The NSS Hugging Face repository includes pre-built Windows® binaries for ML Emulation Layer for Vulkan and Scenario Runner. For other platforms,
+- build from source following the instructions for [Building the Emulation Layer from source](https://github.com/arm/ai-ml-emulation-layer-for-vulkan/blob/main/README.md#building-the-emulation-layer-from-source) and [Building the Scenario Runner from source](https://github.com/arm/ai-ml-sdk-scenario-runner/blob/main/README.md#building-scenario-runner-from-source)
+- adapt the instructions below accordingly 
+
+1. Set the required environment variables:
+
+   On Windows:
+   ```powershell
+   $env:VK_LAYER_PATH="$PWD\bin\windows-x86_64"
+   $env:VK_INSTANCE_LAYERS="VK_LAYER_ML_Graph_Emulation;VK_LAYER_ML_Tensor_Emulation"
+   ```
+
+   On Linux (assuming the Emulation Layer binaries and JSON files and Scenario Runner executable are copied to `bin/linux-x86_64`):
+   ```powershell
+   export LD_LIBRARY_PATH=$PWD/bin/linux-x86_64:$LD_LIBRARY_PATH
+   export VK_LAYER_PATH=$PWD/bin/linux-x86_64
+   export VK_INSTANCE_LAYERS=VK_LAYER_ML_Graph_Emulation:VK_LAYER_ML_Tensor_Emulation
+   ```
+   
+2. Execute the scenario:
+
+   On Windows:
+   ```powershell
+   bin\windows-x86_64\scenario-runner.exe --scenario scenario\scenario.json --output out
+   ```
+
+   On Linux:
+   ```powershell
+   bin/linux-x86_64/scenario-runner --scenario scenario/scenario.json --output out
+   ```
+   
+- Output images are encoded as `B10G11R11_UFLOAT`. This format is common for framebuffers but not widely supported by image viewers. Use [RenderDoc](https://renderdoc.org/) to view these images.
+
+## Training and Evaluation
+
+For background on NSS architecture and training read our blog: [How Neural Super Sampling Works](https://community.arm.com/arm-community-blogs/b/mobile-graphics-and-gaming-blog/posts/how-arm-neural-super-sampling-works) 
+
+Training and evaluation details, including model architecture code, training pipeline, and test configurations, are available at:
+
+- Model training code: https://github.com/arm/neural-graphics-model-gym
+- Examples and tutorials: https://github.com/arm/neural-graphics-model-gym-examples
+- Sample dataset: https://huggingface.co/datasets/Arm/neural-graphics-dataset
+
+### 🔎 Model Explorer VGF extension
+
+The [VGF extension to Model Explorer](https://github.com/arm/vgf-adapter-model-explorer) provides a simple interface to visualize model and analyse VGF composition. 
+
+![Model Explorer screenshot](resources/model-explorer-screenshot.png)
+
+## License
+
+- The license for the model source code can be found [here](https://github.com/arm/neural-graphics-model-gym/blob/main/LICENSES/Apache-2.0.txt).
+- The license for the content of this repository can be found [here](https://huggingface.co/Arm/TestNSS/blob/main/Arm_AI_Model_Community_License_v1_0_PRE-1154.pdf)
+
+## More Information
+
+🧑‍🔬 More technical details about the model can be found in the [NSS Guide](https://developer.arm.com/documentation/110290/latest/).
+
+👩🏽‍💻 Our [Neural Graphics Development Kit](https://developer.arm.com/mobile-graphics-and-gaming/neural-graphics-for-mobile) contains engine plugins, model training tools, code examples and extensive developer documentation.
+
+🙋🏻‍♀️ For questions or feedback please [start a discussion](https://huggingface.co/Arm/TestNSS/discussions)
+
+## Trademark notice
+Arm® is a registered trademarks of Arm Limited (or its subsidiaries) in the US and/or elsewhere.
+
+Windows® is a trademark of the Microsoft group of companies.
+
+Vulkan® is a registered trademark of the [Khronos® Group](https://www.khronos.org/legal/trademarks).

bin/windows-x86_64/VkLayer_Graph.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0a2fd54f62bef850685bcc4331714e0590a0a3aef28ea2dd6aa8c9e6f68f4da0
+size 7437312

bin/windows-x86_64/VkLayer_Graph.json

@@ -0,0 +1,29 @@
+{
+    "file_format_version": "1.0.0",
+    "layer": {
+        "name": "VK_LAYER_ML_Graph_Emulation",
+        "type": "INSTANCE",
+        "library_path": ".\\VkLayer_Graph.dll",
+        "api_version": "1.3.0",
+        "implementation_version": "1",
+        "description": "ML Graph Emulation Layer",
+        "functions": {
+            "vkGetInstanceProcAddr": "graphGetInstanceProcAddr",
+            "vkGetDeviceProcAddr": "graphGetDeviceProcAddr"
+        },
+        "device_extensions": [
+            {
+                "name": "VK_ARM_data_graph",
+                "spec_version": "1",
+                "entrypoints": [
+                    "vkGetPhysicalDeviceGraphInstructionSetsARM",
+                    "vkCreateGraphPipelinesARM",
+                    "vkCreateGraphPipelineSessionARM",
+                    "vkGetGraphPipelineSessionMemoryRequirementsARM",
+                    "vkBindGraphPipelineSessionMemoryARM",
+                    "vkDestroyGraphPipelineSessionARM",
+                    "vkCmdDispatchGraphARM"
+                ]
+            }]
+    }
+}

bin/windows-x86_64/VkLayer_Tensor.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:15a7e7f9b4ff74f530a550669740f1c8b5295bdbe9a0474da3e3b9e906c4ce76
+size 5689344

bin/windows-x86_64/VkLayer_Tensor.json

@@ -0,0 +1,31 @@
+{
+    "file_format_version": "1.0.0",
+    "layer": {
+        "name": "VK_LAYER_ML_Tensor_Emulation",
+        "type": "INSTANCE",
+        "library_path": ".\\VkLayer_Tensor.dll",
+        "api_version": "1.3.0",
+        "implementation_version": "1",
+        "description": "ML Tensor Emulation Layer",
+        "functions": {
+            "vkGetInstanceProcAddr": "tensorGetInstanceProcAddr",
+            "vkGetDeviceProcAddr": "tensorGetDeviceProcAddr"
+        },
+        "device_extensions": [
+            {
+                "name": "VK_ARM_tensors",
+                "spec_version": "1",
+                "entrypoints": [
+                    "vkCreateTensorARM",
+                    "vkDestroyTensorARM",
+                    "vkCreateTensorViewARM",
+                    "vkDestroyTensorViewARM",
+                    "vkGetTensorMemoryRequirementsARM",
+                    "vkBindTensorMemoryARM",
+                    "vkGetDeviceTensorMemoryRequirementsARM",
+                    "vkCmdCopyTensorARM"
+                ]
+            }
+        ]
+    }
+}

bin/windows-x86_64/scenario-runner.exe

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5a99f1076dec1f504d64387969a3d18dc687c7f95c505dca812e4fcbca60f3d2
+size 5285376

nss_v1_fp32.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:391ad31f72783175afcb94180e0d8ffad7a34a6d848edfdea3409677236fc1da
+size 553364

nss_v1_int8.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:57ebcd81596ca7720015fc42b8c3d509c45d0c031244b024c7d1056b671dce9d
+size 665897

nss_v1_int8.vgf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f2bb554b54f186111150cbe3f80b258300d22e6e6e23610a6c519abe1962d8f9
+size 162900

nss_v1_int8_metadata.json

@@ -0,0 +1,79 @@
+{
+    "dm_scale_on_no_motion": [
+        0.617464542388916
+    ],
+    "inputs": {
+        "x": {
+            "SINT": {
+                "scale": 0.003921568859368563,
+                "zero_point": -128
+            },
+            "SNORM": {
+                "scale": 0.49803924513980746,
+                "zero_point": -1.0078740157480315
+            }
+        }
+    },
+    "outputs": {
+        "activation_post_process_45": {
+            "SINT": {
+                "scale": 0.003937007859349251,
+                "zero_point": -127
+            },
+            "SNORM": {
+                "scale": 0.49999999813735485,
+                "zero_point": -1.0
+            }
+        },
+        "activation_post_process_50": {
+            "SINT": {
+                "scale": 0.003937007859349251,
+                "zero_point": -127
+            },
+            "SNORM": {
+                "scale": 0.49999999813735485,
+                "zero_point": -1.0
+            }
+        },
+        "activation_post_process_55": {
+            "SINT": {
+                "scale": 0.003937007859349251,
+                "zero_point": -127
+            },
+            "SNORM": {
+                "scale": 0.49999999813735485,
+                "zero_point": -1.0
+            }
+        },
+        "activation_post_process_60": {
+            "SINT": {
+                "scale": 0.003937007859349251,
+                "zero_point": -127
+            },
+            "SNORM": {
+                "scale": 0.49999999813735485,
+                "zero_point": -1.0
+            }
+        },
+        "activation_post_process_65": {
+            "SINT": {
+                "scale": 0.003937007859349251,
+                "zero_point": -127
+            },
+            "SNORM": {
+                "scale": 0.49999999813735485,
+                "zero_point": -1.0
+            }
+        },
+        "activation_post_process_70": {
+            "SINT": {
+                "scale": 0.003937007859349251,
+                "zero_point": -127
+            },
+            "SNORM": {
+                "scale": 0.49999999813735485,
+                "zero_point": -1.0
+            }
+        }
+    }
+}

resources/Enchanted_Castle_NSS_Demo.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:13cc07b5829e7335b94b548314dd189add180ae4b6fd4d1529db37de72a9c3d8
+size 96767057

scenario/0_pre_process.comp

@@ -0,0 +1,572 @@
+//
+// -----------------------------------------------------------------------------
+// The proprietary software and information contained in this file is
+// confidential and may only be used by an authorized person under a valid
+// licensing agreement from Arm Limited or its affiliates.
+//
+// Copyright (C) 2025. Arm Limited or its affiliates. All rights reserved.
+//
+// This entire notice must be reproduced on all copies of this file and
+// copies of this file may only be made by an authorized person under a valid
+// licensing agreement from Arm Limited or its affiliates.
+// -----------------------------------------------------------------------------
+//
+#version 460
+#extension GL_EXT_shader_8bit_storage : require
+#extension GL_EXT_shader_16bit_storage : require
+#extension GL_EXT_shader_explicit_arithmetic_types : require
+#extension GL_EXT_shader_explicit_arithmetic_types_int8 : require
+#extension GL_EXT_shader_explicit_arithmetic_types_float16 : require
+#extension GL_EXT_shader_explicit_arithmetic_types_float32 : require
+#extension GL_GOOGLE_include_directive : enable
+#extension GL_ARM_tensors : require
+
+// includes
+#include "typedefs.h"
+#include "common.h"
+
+// types
+
+struct TensorElement
+{
+    int8_t4 wh_rgb_col_r;      // warped_history.rgb, jittered_colour.r
+    int8_t4 col_gb_dm_fback_r; // jittered_colour.gb, disocclusion mask, feedback.r
+    int8_t4 fback_gba_ld;      // feedback.gba, luma derivative
+};
+
+// inputs
+layout (set=0, binding=0) uniform mediump   sampler2D _ColourTex;               // 540p  | R11G11B10 32bpp
+layout (set=0, binding=1) uniform highp     sampler2D _DepthTex;                // 540p  | R32_FLOAT 32bpp
+layout (set=0, binding=2) uniform mediump   sampler2D _MotionVectorTex;         // 540p  | RG_16 32bpp
+layout (set=0, binding=3) uniform mediump   sampler2D _HistoryTex;              // 1080p | R11G11B10 32bpp
+layout (set=0, binding=4) uniform lowp      sampler2D _FeedbackTensor;          // 1080p | R8G8B8A8_SNORM 32bpp | Tensor->Texture Alias (Linear)
+layout (set=0, binding=5) uniform highp     sampler2D _DepthTm1Tex;             // 540p  | R32_FLOAT 32bpp
+layout (set=0, binding=6) uniform lowp      sampler2D _LumaDerivTm1Tex;         // 540p  | R8G8_UNORM 16bpp
+layout (set=0, binding=7) uniform lowp      sampler2D _NearestDepthCoordTm1Tex; // 540p  | R8_UNORM 8bpp
+
+// outputs
+layout (set=1, binding=0)       uniform writeonly tensorARM<int8_t, 4> _PreprocessTensor;         // 540p  | 12ch 96bpp 
+layout (set=1, binding=1, rg8)  uniform writeonly lowp  image2D        _PreProcessLumaDerivOut;   // 540p  | R8G8 16bpp
+layout (set=1, binding=3, r8)   uniform writeonly lowp image2D         _NearestDepthCoordOut;     // 540p  | R8 8bpp
+
+// push-constants
+layout(push_constant, std430) uniform PushConstants {
+    // ─────────────── 16-byte aligned ───────────────
+    layout(offset =  0)  float4  _DeviceToViewDepth;   //  16 B
+    layout(offset = 16)  float4  _JitterOffset;        //  16 B (.xy = pixels, .zw = uvs)
+    layout(offset = 32)  float4  _JitterOffsetTm1;     //  16 B (.xy = pixels, .zw = uvs)
+    layout(offset = 48)  float4  _ScaleFactor;         //  16 B (.xy = scale, .zw = inv scale)
+
+    // ───────────────  8-byte aligned ───────────────
+    layout(offset = 64)  int32_t2 _OutputDims;         //   8 B
+    layout(offset = 72)  int32_t2 _InputDims;          //   8 B
+    layout(offset = 80)  float2   _InvOutputDims;      //   8 B
+    layout(offset = 88)  float2   _InvInputDims;       //   8 B
+    layout(offset = 96)  half4    _QuantParams;        //   8 B  (.xy SINT, .zw SNORM)
+    layout(offset = 104) half4    _MotionDisThreshPad; //   8 B  (.xyzw = motion/disocclusion thresholds)
+
+    // ───────────────  4-byte aligned ───────────────
+    layout(offset = 112) half2    _Exposure;           //   4 B  (.x = exposure, .y = 1/exp)
+    layout(offset = 116) half2    _HistoryPad;         //   4 B
+
+    // ─────────────── padding to 16-byte struct size ────
+    layout(offset = 120) int32_t2 _Padding;            //   8 B
+
+                                                       // Total: **128 bytes**
+};
+
+// Convenience mapping for accessing push constants
+#define _Scale              _ScaleFactor.xy
+#define _InvScale           _ScaleFactor.zw
+#define _Exposure           _Exposure.x
+#define _InvExposure        _Exposure.y
+#define _JitterOffsetPix    _JitterOffset.xy
+#define _JitterOffsetUv     _JitterOffset.zw
+#define _JitterOffsetTm1Pix _JitterOffsetTm1.xy
+#define _JitterOffsetTm1Uv  _JitterOffsetTm1.zw
+#define _MotionWarpThresh   _MotionDisThreshPad.x
+#define _MotionDisThresh    _MotionDisThreshPad.y
+#define _DisocclusionScale  _MotionDisThreshPad.z
+#define _NotHistoryReset    _HistoryPad.x
+
+// Quantization Parameters
+// inside: `./parameters.json`
+// these values are embdedded inside the TOSA file and learnt during QAT
+
+#ifndef _InputQuantParams
+    // inputs - x["SINT"]
+    #define _InputQuantParams _QuantParams.xy
+#endif
+#ifndef _FeedbackQuantParams
+    // outputs - activation_post_process_70["SNORM"]
+    #define _FeedbackQuantParams _QuantParams.zw
+#endif
+
+// constants
+
+#ifdef INVERTED_DEPTH
+    #define MAX_DEPTH 0.f
+#else
+    #define MAX_DEPTH 1.f
+#endif
+
+
+// methods
+
+bool IsOnScreen(int32_t2 pos, int32_t2 size)
+{
+    return all(lessThan(uint32_t2(pos), uint32_t2(size)));
+}
+
+
+half2 LoadMotion(int32_t2 pixel)
+{
+    return half2(texelFetch(_MotionVectorTex, pixel, 0).rg);
+}
+
+
+half3 LoadColour(int32_t2 pixel)
+{
+    return Tonemap(SafeColour(half3(texelFetch(_ColourTex, pixel, 0).rgb) * _Exposure));
+}
+
+
+int32_t2 LoadDepthNearestDepthOffsetTm1(int32_t2 pixel)
+{
+    int32_t2 is_oob = int32_t2(IsOnScreen(pixel, _InputDims));
+    pixel = clamp(pixel, int32_t2(0), _InputDims - int32_t2(1));
+
+    half encNorm = half(texelFetch(_NearestDepthCoordTm1Tex, pixel, 0).r);
+    int32_t code = int32_t(encNorm * 255.0 + 0.5);          
+
+    // 3. map back to {-1,0,1}²
+    return DecodeNearestDepthCoord(code) * is_oob;
+}
+
+void GatherReconstructedPreviousDepthRQuad(float2 fUV, inout float4 depthQuad)
+{
+    int32_t2 offset = LoadDepthNearestDepthOffsetTm1(int32_t2(fUV * _InputDims));
+    float2 offset_uv = float2(offset) * _InvInputDims;
+    depthQuad = textureGather(_DepthTm1Tex, fUV + offset_uv, 0).wzxy;
+}
+
+
+half3 WarpHistory(float2 uv)
+{
+    return Tonemap(SafeColour(half3(textureLod(_HistoryTex, uv, 0).rgb) * _Exposure));
+}
+
+
+half4 WarpFeedback(float2 uv)
+{
+    return Dequantize(half4(textureLod(_FeedbackTensor, uv, 0)), _FeedbackQuantParams);
+}
+
+
+half2 WarpLumaDerivative(float2 uv)
+{
+    return half2(textureLod(_LumaDerivTm1Tex, uv, 0).rg);
+}
+
+
+half2 CalculateLumaDerivative(float2 reproj_uv, half3 jittered_colour, half disocclusion_mask)
+{
+    const half  DIS_THRESH  = 0.01HF;
+    const half  DERIV_MIN   = 0.05HF;
+    const half  DERIV_MAX   = 0.3HF;
+    const half  DERIV_POW   = 1.5HF;
+    const half  DERIV_ALPHA = 0.1HF;
+    const half  DERIV_MAX_R = rcp(DERIV_MAX);
+    const half  DERIV_MAX_POW_R = rcp(pow(DERIV_MAX, DERIV_POW));
+
+    //--------------------------------------------------------------------
+    // 1.  Fetch history (luma + derivative)
+    //--------------------------------------------------------------------
+    half2 h = WarpLumaDerivative(reproj_uv);
+    half  luma_tm1        = h.y;
+    half  derivative_tm1  = h.x;
+
+    //--------------------------------------------------------------------
+    // 2.  Current luma & raw derivative
+    //--------------------------------------------------------------------
+    half luma_t       = Luminance(jittered_colour);
+    half derivative_t = abs(luma_t - luma_tm1);
+
+    //--------------------------------------------------------------------
+    // 3.  Soft-clip & normalize
+    //--------------------------------------------------------------------
+    // Clip to `DERIV_MAX` which is ~typical max value,
+    // allows for better precision allocation when normalized
+    half clipped = min(derivative_t, DERIV_MAX);
+
+    // Discard values less than `DERIV_MIN` to reduce ghosting
+    clipped *= step(DERIV_MIN, derivative_t);
+
+    // Normalize with soft-clip
+    // x^1.5  =  x * sqrt(x) | NOTE: only works because `DERIV_POW=1.5`
+    half curved = clipped * sqrt(clipped) * DERIV_MAX_POW_R;
+
+    //--------------------------------------------------------------------
+    // 4.  Temporal accumulation
+    //--------------------------------------------------------------------
+    // Accumulate the new derivative into the history.
+    // We apply an adaptive alpha scaling, to ensure that if a derivative converges to a high value
+    // it becomes more difficult to reset that value, this provides temporally stable convergence
+    half alpha_scale = mix(DERIV_ALPHA,
+                           DERIV_ALPHA * 0.1HF,
+                           clamp(derivative_tm1, 0.HF, DERIV_MAX) * DERIV_MAX_R);
+
+    half derivative = mix(derivative_tm1, curved, alpha_scale);
+
+    //--------------------------------------------------------------------
+    // 5.  Remove disoccluded pixels
+    //--------------------------------------------------------------------
+    derivative *= step(disocclusion_mask, DIS_THRESH);
+
+    // .x -> derivative for current frame, .y -> luma of current frame
+    return half2(derivative, luma_t);
+}
+
+
+void FindNearestDepth(int32_t2 iPxPos, int32_t2 iPxSize, out float fNearestDepth, out int32_t2 fNearestDepthOffset)
+{
+    /*
+        Closely based on:
+        https://github.com/arm/accuracy-super-resolution-generic-library/blob/38697a58a6e7818ec9d28774bc073f537abb9178/
+        include/gpu/fsr2/ffxm_fsr2_reconstruct_dilated_velocity_and_previous_depth.h#L59
+    */
+
+    int32_t iSampleIndex = 0;
+    const int32_t iSampleCount = 9;
+    // x, y
+    const int32_t2 iSampleOffsets[iSampleCount] = {
+        int32_t2(+0, +0).yx,
+        int32_t2(+1, +0).yx,
+        int32_t2(+0, +1).yx,
+        int32_t2(+0, -1).yx,
+        int32_t2(-1, +0).yx,
+        int32_t2(-1, +1).yx,
+        int32_t2(+1, +1).yx,
+        int32_t2(-1, -1).yx,
+        int32_t2(+1, -1).yx,
+    };
+
+    // pull out the depth loads to allow SC to batch them
+    float depth[9];
+    depth[0] = float(texelFetchOffset(_DepthTex, iPxPos, 0, int32_t2(+0, +0).yx).r);
+    depth[1] = float(texelFetchOffset(_DepthTex, iPxPos, 0, int32_t2(+1, +0).yx).r);
+    depth[2] = float(texelFetchOffset(_DepthTex, iPxPos, 0, int32_t2(+0, +1).yx).r);
+    depth[3] = float(texelFetchOffset(_DepthTex, iPxPos, 0, int32_t2(+0, -1).yx).r);
+    depth[4] = float(texelFetchOffset(_DepthTex, iPxPos, 0, int32_t2(-1, +0).yx).r);
+    depth[5] = float(texelFetchOffset(_DepthTex, iPxPos, 0, int32_t2(-1, +1).yx).r);
+    depth[6] = float(texelFetchOffset(_DepthTex, iPxPos, 0, int32_t2(+1, +1).yx).r);
+    depth[7] = float(texelFetchOffset(_DepthTex, iPxPos, 0, int32_t2(-1, -1).yx).r);
+    depth[8] = float(texelFetchOffset(_DepthTex, iPxPos, 0, int32_t2(+1, -1).yx).r);
+
+    // find closest depth
+    fNearestDepth = depth[0];
+    fNearestDepthOffset = iSampleOffsets[0];
+    #pragma unroll
+    for (iSampleIndex = 1; iSampleIndex < iSampleCount; ++iSampleIndex) {
+
+        int32_t2 iPos = iPxPos + iSampleOffsets[iSampleIndex];
+        if (IsOnScreen(iPos, iPxSize)) {
+
+            float fNdDepth = depth[iSampleIndex];
+#ifdef INVERTED_DEPTH
+            if (fNdDepth > fNearestDepth) {
+#else
+            if (fNdDepth < fNearestDepth) {
+#endif
+                fNearestDepth = fNdDepth;
+                fNearestDepthOffset = iSampleOffsets[iSampleIndex];
+            }
+        }
+    }
+}
+
+
+int32_t2 RenderSize()
+{
+    return int32_t2(_InputDims);
+}
+
+
+float2 ComputeNdc(float2 fPxPos, int32_t2 iSize)
+{
+    /*
+        Closely based on:
+        https://github.com/arm/accuracy-super-resolution-generic-library/blob/
+        38697a58a6e7818ec9d28774bc073f537abb9178/include/gpu/fsr2/ffxm_fsr2_common.h#L457
+    */
+
+    return fPxPos.yx / float2(iSize.yx) * float2(2.0f, -2.0f) + float2(-1.0f, 1.0f);
+}
+
+
+float GetViewSpaceDepth(float fDeviceDepth)
+{
+    /*
+        Closely based on:
+        https://github.com/arm/accuracy-super-resolution-generic-library/blob/
+        38697a58a6e7818ec9d28774bc073f537abb9178/include/gpu/fsr2/ffxm_fsr2_common.h#L462
+
+        `fDeviceToViewDepth` / `_DeviceToViewDepth` details found in:
+        https://github.com/arm/accuracy-super-resolution-generic-library/blob/
+        0501f490bd9946a2e1806b5363d7ab8a9a6a5e0a/src/components/fsr2/ffxm_fsr2.cpp#L829
+    */
+
+    const float4 fDeviceToViewDepth = _DeviceToViewDepth;
+
+    return (fDeviceToViewDepth[1] / (fDeviceDepth - fDeviceToViewDepth[0]));
+}
+
+
+float3 GetViewSpacePosition(int32_t2 iViewportPos, int32_t2 iViewportSize, float fDeviceDepth)
+{
+    /*
+        Closely based on:
+        https://github.com/arm/accuracy-super-resolution-generic-library/blob/
+        38697a58a6e7818ec9d28774bc073f537abb9178/include/gpu/fsr2/ffxm_fsr2_common.h#L475
+    */
+
+    const float4 fDeviceToViewDepth = _DeviceToViewDepth;
+
+    const float Z = GetViewSpaceDepth(fDeviceDepth);
+
+    const float2 fNdcPos = ComputeNdc(iViewportPos, iViewportSize);
+    const float X = fDeviceToViewDepth[2] * fNdcPos.x * Z;
+    const float Y = fDeviceToViewDepth[3] * fNdcPos.y * Z;
+
+    return float3(X, Y, Z);
+}
+
+
+struct BilinearSamplingData
+{
+    int32_t2 iOffsets[4];
+    float fWeights[4];
+    int32_t2 iBasePos;
+    float2 fQuadCenterUv;
+};
+
+
+BilinearSamplingData GetBilinearSamplingData(float2 fUv, int32_t2 iSize)
+{
+    /*
+        Closely based on:
+        https://github.com/arm/accuracy-super-resolution-generic-library/blob/
+        38697a58a6e7818ec9d28774bc073f537abb9178/include/gpu/fsr2/ffxm_fsr2_common.h#L548
+    */
+
+    BilinearSamplingData data;
+
+    float2 fPxSample = (fUv * iSize) - float2(0.5f, 0.5f);
+    data.iBasePos = int32_t2(floor(fPxSample));
+    data.fQuadCenterUv = (fPxSample + 0.5f) / float2(iSize);
+    float2 fPxFrac = fract(fPxSample);
+
+    data.iOffsets[0] = int32_t2(0, 0);
+    data.iOffsets[2] = int32_t2(1, 0);
+    data.iOffsets[1] = int32_t2(0, 1);
+    data.iOffsets[3] = int32_t2(1, 1);
+
+    data.fWeights[0] = (1.f - fPxFrac.x) * (1.f - fPxFrac.y);
+    data.fWeights[1] = (fPxFrac.x) * (1.f - fPxFrac.y);
+    data.fWeights[2] = (1.f - fPxFrac.x) * (fPxFrac.y);
+    data.fWeights[3] = (fPxFrac.x) * (fPxFrac.y);
+
+    return data;
+}
+
+
+float ComputeDepthClip(float2 fUvSample, float fCurrentDepthSample)
+{
+    /*
+        Closely based on:
+        https://github.com/arm/accuracy-super-resolution-generic-library/blob/
+        38697a58a6e7818ec9d28774bc073f537abb9178/include/gpu/fsr2/ffxm_fsr2_depth_clip.h#L36
+    */
+
+    const float fReconstructedDepthBilinearWeightThreshold = 0.1f;
+    float fCurrentDepthViewSpace = GetViewSpaceDepth(fCurrentDepthSample);
+    BilinearSamplingData bilinearInfo = GetBilinearSamplingData(fUvSample, RenderSize());
+
+    float fDepth = 0.0f;
+    float fWeightSum = 0.0f;
+
+    float4 fPrevDepthSamples;
+    GatherReconstructedPreviousDepthRQuad(bilinearInfo.fQuadCenterUv, fPrevDepthSamples);
+   
+    
+
+    for (int32_t iSampleIndex = 0; iSampleIndex < 4; iSampleIndex++)
+    {
+        const int32_t2 iOffset = bilinearInfo.iOffsets[iSampleIndex];
+        const int32_t2 iSamplePos = bilinearInfo.iBasePos + iOffset;
+
+        const float fWeight = bilinearInfo.fWeights[iSampleIndex];
+        const bool onscreen = IsOnScreen(iSamplePos, RenderSize());
+        fWeightSum += onscreen ? 0.f : fWeight; 
+        if (onscreen)
+        {
+            if (fWeight > fReconstructedDepthBilinearWeightThreshold)
+            {
+                const float fPrevDepthSample = fPrevDepthSamples[iSampleIndex];
+                const float fPrevNearestDepthViewSpace = GetViewSpaceDepth(fPrevDepthSample);
+                const float fDepthDiff = fCurrentDepthViewSpace - fPrevNearestDepthViewSpace;
+
+                if (fDepthDiff > 0.0f) {
+
+#ifdef INVERTED_DEPTH
+                    const float fPlaneDepth = min(fPrevDepthSample, fCurrentDepthSample);
+#else
+                    const float fPlaneDepth = max(fPrevDepthSample, fCurrentDepthSample);
+#endif
+
+                    const float3 fCenter = GetViewSpacePosition(int32_t2(RenderSize() * 0.5f), RenderSize(), fPlaneDepth);
+                    const float3 fCorner = GetViewSpacePosition(int32_t2(0, 0), RenderSize(), fPlaneDepth);
+
+                    const float fHalfViewportWidth = length(float2(RenderSize()));
+                    const float fDepthThreshold = max(fCurrentDepthViewSpace, fPrevNearestDepthViewSpace);
+
+                    const float Ksep = 1.37e-05f;
+                    const float Kfov = length(fCorner) / length(fCenter);
+                    const float fRequiredDepthSeparation = Ksep * Kfov * fHalfViewportWidth * fDepthThreshold;
+
+                    const float fResolutionFactor = saturate(length(float2(RenderSize())) / length(float2(1920.0f, 1080.0f)));
+                    const float fPower = lerp(1.0f, 3.0f, fResolutionFactor);
+                    fDepth += pow(saturate(float(fRequiredDepthSeparation / fDepthDiff)), fPower) * fWeight;
+                    fWeightSum += fWeight;
+                }
+            }
+        }
+    }
+
+    return (fWeightSum > 0) ? saturate(1.0f - fDepth / fWeightSum) : 0.0f;
+}
+
+
+void WriteLumaDerivative(int32_t2 pixel, half2 derivative)
+{
+    imageStore(_PreProcessLumaDerivOut, pixel, half4(derivative, half2(0.f, 1.f)));
+}
+
+
+void WriteNearestDepthOffset(int32_t2 pixel, uint8_t offset)
+{    
+    half enc_norm = half(offset) / 255.HF;
+    imageStore(_NearestDepthCoordOut, pixel, half4(enc_norm, 0.HF, 0.HF, 1.HF));
+}
+
+
+void WriteToTensor(int32_t2 outputPixel, half3 input_colour, half3 history, half disocclusion_mask, half luma_derivative, half4 temporal_feedback)
+{
+    TensorElement te;
+    te.wh_rgb_col_r = Quantize(half4(history.rgb, input_colour.r), _InputQuantParams);
+    te.col_gb_dm_fback_r = Quantize(half4(input_colour.gb, disocclusion_mask, temporal_feedback.r), _InputQuantParams);
+    te.fback_gba_ld = Quantize(half4(temporal_feedback.gba, luma_derivative), _InputQuantParams);
+   
+    int8_t t0[12] =
+    {
+        te.wh_rgb_col_r.x,
+        te.wh_rgb_col_r.y,
+        te.wh_rgb_col_r.z,
+        te.wh_rgb_col_r.w,
+        te.col_gb_dm_fback_r.x,
+        te.col_gb_dm_fback_r.y,
+        te.col_gb_dm_fback_r.z,
+        te.col_gb_dm_fback_r.w,
+        te.fback_gba_ld.x,
+        te.fback_gba_ld.y,
+        te.fback_gba_ld.z,
+        te.fback_gba_ld.w
+    };
+    tensorWriteARM(_PreprocessTensor, uint[](0, outputPixel.y, outputPixel.x, 0), t0);
+}
+
+
+// entry-point
+layout(local_size_x = 16, local_size_y = 16) in;
+void main()
+{
+    int32_t2 input_pixel = int32_t2(gl_GlobalInvocationID.xy);
+    if (any(greaterThanEqual(input_pixel, _InputDims))) return;
+
+    float2 uv = (float2(input_pixel) + 0.5f) * _InvInputDims;
+
+    //-------------------------------------------------------------------------
+    // 1) Dilate depth, find nearest pixel coordinate
+    //-------------------------------------------------------------------------
+    float depth_dilated = float(0.f);
+    int32_t2 nearest_pixel_offset = int32_t2(0);
+    FindNearestDepth(input_pixel, RenderSize(), depth_dilated, nearest_pixel_offset);
+
+    //-------------------------------------------------------------------------
+    // 2) Load motion vectors
+    //-------------------------------------------------------------------------
+    half2 motion = LoadMotion(input_pixel + nearest_pixel_offset);
+    
+    // Suppress very small motion - no value in resampling here
+    half2  motion_pix = motion * half2(RenderSize());
+    motion *= half(dot(motion_pix, motion_pix) > _MotionWarpThresh);
+
+    // Calculate sample position(s) for everything in `tm1` frame 
+    float2 reproj_uv = uv - float2(motion);
+    float2 unjitter_tm1_uv = reproj_uv - _JitterOffsetTm1Uv;
+
+    //-------------------------------------------------------------------------
+    // 3) Calculate depth-based disocclusion mask
+    //-------------------------------------------------------------------------
+    half disocclusion_mask = half(ComputeDepthClip(unjitter_tm1_uv, depth_dilated));
+
+    // Scale disocclusion mask on static frames to let network know this is happening under
+    // static conditions, reduces jitter differences across frames causing false flags
+    half dm_scale =  dot(motion_pix, motion_pix) > _MotionDisThresh ? half(1.0f) : _DisocclusionScale;
+    disocclusion_mask = disocclusion_mask * dm_scale;
+
+    //-------------------------------------------------------------------------
+    // 4) Downsample + warp history buffer 
+    //-------------------------------------------------------------------------
+    half3 warped_history = WarpHistory(reproj_uv);
+
+    //-------------------------------------------------------------------------
+    // 5) Read current low-res / jittered / aliased colour
+    //-------------------------------------------------------------------------
+    half3 jittered_colour = LoadColour(input_pixel);
+
+    //-------------------------------------------------------------------------
+    // 6) Calculate derivative of `luma` 
+    //    helps identifying high-frequency flicker due to jitter
+    //-------------------------------------------------------------------------
+    half2 luma_derivative = CalculateLumaDerivative(reproj_uv, jittered_colour, disocclusion_mask);
+
+    //-------------------------------------------------------------------------
+    // 7) Warp temporal feedback
+    //-------------------------------------------------------------------------
+    half4 temporal_feedback = WarpFeedback(reproj_uv);
+
+    //-------------------------------------------------------------------------
+    // 8) Convert dilated depth coord to a position offset
+    //-------------------------------------------------------------------------
+    uint8_t enc_depth_offset = EncodeNearestDepthCoord(nearest_pixel_offset);
+
+    //-------------------------------------------------------------------------
+    // 9) Write Outputs
+    //-------------------------------------------------------------------------
+    // Consumed by NE
+    WriteToTensor(
+        input_pixel, 
+        jittered_colour,     // 3ch
+        warped_history,      // 3ch
+        disocclusion_mask,   // 1ch
+        luma_derivative.x,   // 1ch
+        temporal_feedback    // 4ch
+    );                       // total: 12ch
+    
+    // Consumed by post process and frame t+1
+    WriteNearestDepthOffset(input_pixel, enc_depth_offset);
+    
+    // Consumed at frame t+1
+    WriteLumaDerivative(input_pixel, luma_derivative);
+}

scenario/0_pre_process.spv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b03bcb283b73870daa0a540cfb8f1e8ec9c4842b38a711f52d31517569e79b87
+size 29476

scenario/0_pre_process_push_consts.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6319b912dd9ee3e1ce44794067ea57fd9eb01ff0e38b3f8a55ceea7be18e6412
+size 256

scenario/1_nss.vgf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fd2a1bd13f156fcfa7a0cf132220ca39c2c2498f4af2c7c7da10a42ef4e555a7
+size 163860

scenario/2_post_process.comp

@@ -0,0 +1,361 @@
+//
+// -----------------------------------------------------------------------------
+// The proprietary software and information contained in this file is
+// confidential and may only be used by an authorized person under a valid
+// licensing agreement from Arm Limited or its affiliates.
+//
+// Copyright (C) 2025. Arm Limited or its affiliates. All rights reserved.
+//
+// This entire notice must be reproduced on all copies of this file and
+// copies of this file may only be made by an authorized person under a valid
+// licensing agreement from Arm Limited or its affiliates.
+// -----------------------------------------------------------------------------
+//
+#version 460
+#extension GL_EXT_shader_8bit_storage : require
+#extension GL_EXT_shader_16bit_storage : require
+#extension GL_EXT_shader_explicit_arithmetic_types : require
+#extension GL_EXT_shader_explicit_arithmetic_types_int8 : require
+#extension GL_EXT_shader_explicit_arithmetic_types_float16 : require
+#extension GL_EXT_shader_explicit_arithmetic_types_float32 : require
+#extension GL_GOOGLE_include_directive : enable
+
+// defines
+#define SCALE_1_0X 0
+#define SCALE_1_3X 1
+#define SCALE_1_5X 2
+#define SCALE_2_0X 3
+
+// settings
+#define HISTORY_CATMULL
+#define SCALE_MODE SCALE_2_0X
+
+// includes
+#include "typedefs.h"
+#include "common.h"
+#include "kernel_lut.h"
+
+// inputs
+layout (set=0, binding=0) uniform mediump   sampler2D _ColourTex;               // 540p  | R11G11B10 32bpp
+layout (set=0, binding=1) uniform mediump   sampler2D _MotionVectorTex;         // 540p  | RG16_FLOAT 32bpp
+layout (set=0, binding=2) uniform mediump   sampler2D _HistoryTex;              // 1080p | R11G11B10 32bpp
+layout (set=0, binding=3) uniform lowp      sampler2D _K0Tensor;                // 540p  | R8G8B8A8_SNORM 32bpp | Tensor->Texture Alias (Linear)
+layout (set=0, binding=4) uniform lowp      sampler2D _K1Tensor;                // 540p  | R8G8B8A8_SNORM 32bpp | Tensor->Texture Alias (Linear)
+layout (set=0, binding=5) uniform lowp      sampler2D _K2Tensor;                // 540p  | R8G8B8A8_SNORM 32bpp | Tensor->Texture Alias (Linear)
+layout (set=0, binding=6) uniform lowp      sampler2D _K3Tensor;                // 540p  | R8G8B8A8_SNORM 32bpp | Tensor->Texture Alias (Linear)
+layout (set=0, binding=7) uniform lowp      sampler2D _TemporalTensor;          // 540p  | R8G8B8A8_SNORM 32bpp | Tensor->Texture Alias (Linear)
+layout (set=0, binding=8) uniform lowp      sampler2D _NearestDepthCoordTex;    // 540p  | R8_UNORM 8bpp
+
+// outputs
+layout (set=1, binding=0, r11f_g11f_b10f) uniform writeonly mediump image2D _UpsampledColourOut; // 1080p | R11G11B10 32bpp
+
+// push-constants
+layout(push_constant, std430) uniform PushConstants {
+    // ─────────────── 8-byte aligned ───────────────
+    layout(offset =  0) int32_t2 _OutputDims;        //  8 B
+    layout(offset =  8) int32_t2 _InputDims;         //  8 B
+    layout(offset = 16) float2   _InvOutputDims;     //  8 B
+    layout(offset = 24) float2   _InvInputDims;      //  8 B
+    layout(offset = 32) float2   _Scale;             //  8 B
+    layout(offset = 40) float2   _InvScale;          //  8 B
+
+    // ─────────────── 4-byte aligned ───────────────
+    layout(offset = 48) int16_t2 _IndexModulo;       //  4 B
+    layout(offset = 52) half2    _QuantParams;       //  4 B
+    layout(offset = 56) int16_t2 _LutOffset;         //  4 B
+    layout(offset = 60) half2    _ExposurePair;      //  4 B
+    layout(offset = 64) half2    _HistoryPad;        //  4 B
+    layout(offset = 68) half2    _MotionThreshPad;   //  4 B (.x = motion, .y = unused)
+    layout(offset = 72) int32_t  _Padding0;          //  4 B (explicit pad for alignment)
+                                                     // Total: **76 bytes**
+};
+
+// Convenience mapping for accessing push constants
+#define _Exposure        _ExposurePair.x
+#define _InvExposure     _ExposurePair.y
+#define _NotHistoryReset _HistoryPad.x
+#define _MotionThresh    _MotionThreshPad.x
+
+// Quantization Parameters
+// inside: `./parameters.json`
+// these values are embdedded inside the TOSA file and learnt during QAT
+
+#ifndef _K0QuantParams
+    // outputs - activation_post_process_45["SNORM"]
+    #define _K0QuantParams _QuantParams.xy
+#endif
+#ifndef _K1QuantParams
+    // outputs - activation_post_process_50["SNORM"]
+    #define _K1QuantParams _QuantParams.xy
+#endif
+#ifndef _K2QuantParams
+    // outputs - activation_post_process_55["SNORM"]
+    #define _K2QuantParams _QuantParams.xy
+#endif
+#ifndef _K3QuantParams
+    // outputs - activation_post_process_60["SNORM"]
+    #define _K3QuantParams _QuantParams.xy
+#endif
+#ifndef _TemporalQuantParams
+    // outputs - activation_post_process_65["SNORM"]
+    #define _TemporalQuantParams _QuantParams.xy
+#endif
+
+
+// methods
+
+half2 LoadMotion(int32_t2 pixel)
+{
+    return half2(texelFetch(_MotionVectorTex, pixel, 0).rg);
+}
+
+
+half3 LoadHistory(float2 uv)
+{
+    return half3(textureLod(_HistoryTex, uv, 0).rgb);
+}
+
+half3 LoadHistoryCatmull(float2 uv)
+{
+    //------------------------------------------------------------------------------------
+    // 1) Compute Catmull–Rom weights
+    //------------------------------------------------------------------------------------
+    float2 scaledUV = uv * _OutputDims;
+    float2 baseFloor = floor(scaledUV - 0.5) + 0.5;
+
+    half2 f  = half2(scaledUV - baseFloor);
+    half2 f2 = f * f;
+    half2 f3 = f2 * f;
+
+    // Catmull–Rom basis
+    half2 w0 = f2 - 0.5HF * (f3 + f);
+    half2 w1 = 1.5HF * f3 - 2.5HF * f2 + 1.0HF;
+    half2 w3 = 0.5HF * (f3 - f2);
+    half2 w2 = (1.0HF - w0) - w1 - w3; // = 1 - (w0 + w1 + w3)
+
+    // Combine w1 and w2 for center axis
+    half2 w12 = w1 + w2;
+    half wx0  = w0.x, wy0  = w0.y;
+    half wx1  = w12.x, wy1 = w12.y;
+    half wx2  = w3.x, wy2  = w3.y;
+
+    // Final weights for the cross sample layout
+    half wUp     = wx1 * wy0;   // center in X, up in Y
+    half wDown   = wx1 * wy2;   // center in X, down in Y
+    half wLeft   = wx0 * wy1;   // left   in X, center in Y
+    half wRight  = wx2 * wy1;   // right  in X, center in Y
+    half wCenter = wx1 * wy1;   // center in X, center in Y
+
+    // Fractional offsets for the center
+    half dx = w2.x / wx1;
+    half dy = w2.y / wy1;
+
+    //------------------------------------------------------------------------------------
+    // 2) Gather the 5 taps
+    //------------------------------------------------------------------------------------
+    half4 left   = half4(LoadHistory((baseFloor + float2(-1.0, dy))  * _InvOutputDims ), 1.HF);
+    half4 up     = half4(LoadHistory((baseFloor + float2(dx,  -1.0)) * _InvOutputDims ), 1.HF);
+    half4 center = half4(LoadHistory((baseFloor + float2(dx,  dy))   * _InvOutputDims ), 1.HF);
+    half4 right  = half4(LoadHistory((baseFloor + float2(2.0, dy))   * _InvOutputDims ), 1.HF);
+    half4 down   = half4(LoadHistory((baseFloor + float2(dx,  2.0))  * _InvOutputDims ), 1.HF);
+
+    //------------------------------------------------------------------------------------
+    // 3) Accumulate and track min/max
+    //------------------------------------------------------------------------------------
+    half4 accum = up    * wUp     +
+                  left  * wLeft   +
+                  center* wCenter +
+                  right * wRight  +
+                  down  * wDown;
+    half3 cmin3 = min(up.rgb, 
+                  min(left.rgb,
+                  min(center.rgb,
+                  min(right.rgb, down.rgb))));
+    half3 cmax3 = max(up.rgb, 
+                  max(left.rgb,
+                  max(center.rgb,
+                  max(right.rgb, down.rgb))));
+
+    //------------------------------------------------------------------------------------
+    // 4) Final color
+    //------------------------------------------------------------------------------------
+    half3 color = accum.rgb * rcp(accum.w);
+
+    // dering in the case where we have negative values, we don't do this all the time
+    // as it can impose unnecessary blurring on the output
+    return any(lessThan(color, half3(0.HF)))
+         ? clamp(color, cmin3, cmax3)
+         : color;
+}
+
+
+int32_t2 LoadNearestDepthOffset(int32_t2 pixel)
+{
+    half encNorm = half(texelFetch(_NearestDepthCoordTex, pixel, 0).r);
+    int32_t code = int32_t(encNorm * 255.0 + 0.5);          
+
+    // 3. map back to {-1,0,1}²
+    return DecodeNearestDepthCoord(code);
+}
+
+
+half3 LoadWarpedHistory(float2 uv, int32_t2 input_pixel, out half onscreen)
+{
+    // Dilate motion vectors with previously calculated nearest depth coordinate
+    int32_t2 nearest_offset = LoadNearestDepthOffset(input_pixel);
+    half2 motion = LoadMotion(input_pixel + nearest_offset);
+    
+    // Suppress very small motion - no need to resample
+    half2  motion_pix = motion * half2(_OutputDims);
+    motion *= half(dot(motion_pix, motion_pix) > _MotionThresh);
+
+    // UV coordinates in previous frame to resample history
+    float2 reproj_uv = uv - float2(motion);
+
+    // Mask to flag whether the motion vector is resampling from valid location onscreen
+    onscreen = half(
+        all(greaterThanEqual(reproj_uv, float2(0.0))) &&
+        all(lessThan(reproj_uv, float2(1.0)))
+    );
+
+#ifdef HISTORY_CATMULL
+    half3 warped_history = LoadHistoryCatmull(reproj_uv);
+#else
+    half3 warped_history = LoadHistory(reproj_uv);
+#endif
+
+    return SafeColour(warped_history * _Exposure);
+}
+
+#if SCALE_MODE == SCALE_2_0X
+/*
+    Optimised special case pattern for applying 4x4 kernel to 
+    sparse jitter-aware 2x2 upsampled image
+*/
+
+
+half4 LoadKPNWeight(float2 uv, int16_t lut_idx)
+{
+    // Load 4 kernel slices (each with 4 taps)
+    half4 k0 = Dequantize(half4(textureLod(_K0Tensor, uv, 0)), _K0QuantParams);
+    half4 k1 = Dequantize(half4(textureLod(_K1Tensor, uv, 0)), _K1QuantParams);
+    half4 k2 = Dequantize(half4(textureLod(_K2Tensor, uv, 0)), _K2QuantParams);
+    half4 k3 = Dequantize(half4(textureLod(_K3Tensor, uv, 0)), _K3QuantParams);
+
+    // Precomputed swizzle patterns for KernelTile
+    half4 p0 = half4(k0.x, k2.x, k0.z, k2.z);
+    half4 p1 = half4(k1.x, k3.x, k1.z, k3.z);
+    half4 p2 = half4(k0.y, k2.y, k0.w, k2.w);
+    half4 p3 = half4(k1.y, k3.y, k1.w, k3.w);
+
+    // Return the correct pattern for this tile
+    return (lut_idx == 0) ? p0 :
+           (lut_idx == 1) ? p1 :
+           (lut_idx == 2) ? p2 :
+                            p3;
+}
+
+
+half3 LoadAndFilterColour(int32_t2 output_pixel, float2 uv, out half4 col_to_accum)
+{    
+    //-------------------------------------------------------------------
+    // 1. Compute indexes, load correct pattern from LUT for given thread
+    //-------------------------------------------------------------------
+    float2 out_tex = float2(output_pixel) + 0.5f;
+    
+    // Compute the LUT index for this pixel
+    int16_t2 tiled_idx = (int16_t2(output_pixel) + _LutOffset) % int16_t2(_IndexModulo);
+    int16_t lut_idx = tiled_idx.y * int16_t(_IndexModulo) + tiled_idx.x;
+    KernelTile lut = kernelLUT[lut_idx];
+
+    //------------------------------------------------------------------
+    // 2. Apply KPN 
+    //------------------------------------------------------------------
+    // Dequantize the kernel weights
+    half4 kpn_weights = clamp(LoadKPNWeight(uv, lut_idx), half4(EPS), half4(1.HF));
+
+    // Calculate tap locations
+    int16_t4 tap_x = clamp(int16_t4(floor((float4(out_tex.x) + float4(lut.dx)) * _InvScale.x)), int16_t4(0), int16_t4(_InputDims.x - 1));
+    int16_t4 tap_y = clamp(int16_t4(floor((float4(out_tex.y) + float4(lut.dy)) * _InvScale.y)), int16_t4(0), int16_t4(_InputDims.y - 1));
+
+    // Gather taps
+    f16mat4x4 interm;
+    interm[0] = half4(SafeColour(half3(texelFetch(_ColourTex, int16_t2(tap_x[0], tap_y[0]), 0).rgb) * half3(_Exposure)), 1.HF);
+    interm[1] = half4(SafeColour(half3(texelFetch(_ColourTex, int16_t2(tap_x[1], tap_y[1]), 0).rgb) * half3(_Exposure)), 1.HF);
+    interm[2] = half4(SafeColour(half3(texelFetch(_ColourTex, int16_t2(tap_x[2], tap_y[2]), 0).rgb) * half3(_Exposure)), 1.HF);
+    interm[3] = half4(SafeColour(half3(texelFetch(_ColourTex, int16_t2(tap_x[3], tap_y[3]), 0).rgb) * half3(_Exposure)), 1.HF);
+
+    // Special case: grab the accumulation pixel, when it corresponds to current thread
+    half match = half(lut.dx[CENTER_TAP] == 0 && lut.dy[CENTER_TAP] == 0);
+    col_to_accum = interm[CENTER_TAP] * match;
+
+    // Apply filter
+    half4 out_colour = interm * kpn_weights;
+
+    return half3(out_colour.rgb * rcp(out_colour.w));
+}
+#else
+    #error "Unsupported SCALE_MODE"
+#endif // SCALE_MODE == SCALE_2_0X
+
+
+void LoadTemporalParameters(float2 uv, out half theta, out half alpha)
+{
+    half2 tp = Dequantize(half2(textureLod(_TemporalTensor, uv, 0).xy), _TemporalQuantParams);
+    theta = tp.x * _NotHistoryReset; // {0 <= x <= 1}
+    alpha = tp.y * 0.35HF + 0.05HF; // { 0.05 <= x <= 0.4}
+}
+
+
+void WriteUpsampledColour(int32_t2 pixel, half3 colour)
+{
+    half3 to_write = SafeColour(colour);
+    // Write with alpha = 1.0
+    imageStore(_UpsampledColourOut, pixel, half4(to_write, 1.0));
+}
+
+
+// entry-point
+layout(local_size_x = 16, local_size_y = 16) in;
+void main()
+{
+    int32_t2 output_pixel = int32_t2(gl_GlobalInvocationID.xy);
+    if (any(greaterThanEqual(output_pixel, _OutputDims))) return;
+
+    float2 uv = (float2(output_pixel) + 0.5) * _InvOutputDims;
+    int32_t2 input_pixel = int32_t2(uv * _InputDims);
+
+    //-------------------------------------------------------------------------
+    // 1) Warp history
+    //-------------------------------------------------------------------------
+    half  onscreen;
+    half3 history = LoadWarpedHistory(uv, input_pixel, onscreen);
+
+    //-------------------------------------------------------------------------
+    // 2) KPN filter → col
+    //-------------------------------------------------------------------------
+    half4 col_to_accum;
+    half3 colour = LoadAndFilterColour(output_pixel, uv, col_to_accum);
+
+    // -------------------------------------------------------------------------
+    // 3) Load temporal parameters
+    //-------------------------------------------------------------------------
+    half theta, alpha;
+    LoadTemporalParameters(uv, theta, alpha);
+
+    //-------------------------------------------------------------------------
+    // 3) Rectify history, force reset when offscreen
+    //-------------------------------------------------------------------------
+    half3 rectified = lerp(colour, history, theta * onscreen);
+
+    //-------------------------------------------------------------------------
+    // 3) Accumulate new sample
+    //-------------------------------------------------------------------------
+    half3 accumulated = lerp(Tonemap(rectified), Tonemap(col_to_accum.rgb), alpha * col_to_accum.a);
+
+    //-------------------------------------------------------------------------
+    // 4) Inverse tonemap + exposure and write output
+    //-------------------------------------------------------------------------
+    half3 out_linear = InverseTonemap(accumulated) * _InvExposure;
+    WriteUpsampledColour(output_pixel, out_linear);
+}

scenario/2_post_process.spv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d15c811db716f90606bb42710f5093bfd3dcfedb674ab7223b27909d8c3467a5
+size 25780

scenario/2_post_process_push_consts.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4fe5029783bc6bb2adaa1f8bafc9ab8fe73340bb0a3055d18f80ca3e6a99862a
+size 204

scenario/common.h

@@ -0,0 +1,160 @@
+//
+// -----------------------------------------------------------------------------
+// The proprietary software and information contained in this file is
+// confidential and may only be used by an authorized person under a valid
+// licensing agreement from Arm Limited or its affiliates.
+//
+// Copyright (C) 2025. Arm Limited or its affiliates. All rights reserved.
+//
+// This entire notice must be reproduced on all copies of this file and
+// copies of this file may only be made by an authorized person under a valid
+// licensing agreement from Arm Limited or its affiliates.
+// -----------------------------------------------------------------------------
+//
+#ifndef NSS_COMMON
+#define NSS_COMMON
+
+#include "typedefs.h"
+
+#define MAX_FP16 65504.HF
+#define EPS 1e-7HF
+
+
+// Activation Functions
+// ──────────────────────────────────────────────────────────────────────────────────────────
+
+
+half Sigmoid(half x)
+{
+    return rcp(half(1.0) + exp(-x));
+}
+
+
+half2 Sigmoid(half2 x)
+{
+    return rcp(half2(1.0) + exp(-x));
+}
+
+
+half3 Sigmoid(half3 x)
+{
+    return rcp(half3(1.0) + exp(-x));
+}
+
+
+half4 Sigmoid(half4 x)
+{
+    return rcp(half4(1.0) + exp(-x));
+}
+
+
+// Quantize/Dequantize 
+// ──────────────────────────────────────────────────────────────────────────────────────────
+// all expect .x = scale, .y = zero point, quantize methods expect to receive: .x = rcp(scale)
+
+half Dequantize(half i, half2 quant_params)
+{
+    return (i - quant_params.y) * quant_params.x;
+}
+
+
+half2 Dequantize(half2 i, half2 quant_params)
+{
+    return (i - quant_params.y) * quant_params.x;
+}
+
+
+half3 Dequantize(half3 i, half2 quant_params)
+{
+    return (i - quant_params.y) * quant_params.x;
+}
+
+
+half4 Dequantize(half4 i, half2 quant_params)
+{
+    return (i - quant_params.y) * quant_params.x;
+}
+
+
+int8_t Quantize(half f, half2 quant_params)
+{
+    return int8_t(clamp(round(f * quant_params.x + quant_params.y), -128.HF, 127.HF));
+}
+
+
+int8_t2 Quantize(half2 f, half2 quant_params)
+{
+    return int8_t2(clamp(round(f * quant_params.x + quant_params.y), -128.HF, 127.HF));
+}
+
+
+int8_t3 Quantize(half3 f, half2 quant_params)
+{
+    return int8_t3(clamp(round(f * quant_params.x + quant_params.y), -128.HF, 127.HF));
+}
+
+
+int8_t4 Quantize(half4 f, half2 quant_params)
+{
+    return int8_t4(clamp(round(f * quant_params.x + quant_params.y), -128.HF, 127.HF));
+}
+
+
+// Encode/Decode 
+// ──────────────────────────────────────────────────────────────────────────────────────────
+// Note: both encode/decode methods are currently bound to 3x3 windows, they should be 
+//       expandable in future if needed. The most likely to need this would be the jitter
+//       encoding, where 3x3 may not be enough for larger than 3x3 scale factors.
+
+
+uint8_t EncodeNearestDepthCoord(int32_t2 o)
+{
+    // o ∈ {-1, 0, 1}²
+    o  = clamp(o, ivec2(-1), ivec2( 1));
+    return uint8_t((o.y + 1) << 2 | (o.x + 1));  // 0-15
+}
+
+
+int32_t2 DecodeNearestDepthCoord(int32_t code)
+{
+    int32_t x = int32_t( code       & 0x3) - 1;  // bits 0-1
+    int32_t y = int32_t((code >> 2) & 0x3) - 1;  // bits 2-3
+    return int32_t2(x, y);
+}
+
+
+// Image Operations
+// ──────────────────────────────────────────────────────────────────────────────────────────
+
+half Luminance(half3 rgb)
+{
+    // ITU-R BT.709: `0.2126 * R + 0.7152 * G + 0.0722 * B`
+    return dot(rgb, half3(0.2126, 0.7152, 0.0722));
+}
+
+
+half3 Tonemap(half3 x)
+{
+    // Karis tonemapper
+    // http://graphicrants.blogspot.com/2013/12/tone-mapping.html
+    x = max(x, half3(0.HF));
+    return x * rcp(half3(1.HF) + max(max(x.r, x.g), x.b));
+}
+
+
+half3 InverseTonemap(half3 x)
+{
+    // Karis tonemapper inverse
+    // http://graphicrants.blogspot.com/2013/12/tone-mapping.html
+    x = clamp(x, half3(0.HF), Tonemap(half3(MAX_FP16)));
+    return x * rcp(half3(1.HF) - max(max(x.r, x.g), x.b));
+}
+
+
+half3 SafeColour(half3 x)
+{
+    return clamp(x, half3(0.HF), half3(MAX_FP16));
+}
+
+
+#endif // NSS_COMMON

scenario/kernel_lut.h

@@ -0,0 +1,83 @@
+//
+// -----------------------------------------------------------------------------
+// The proprietary software and information contained in this file is
+// confidential and may only be used by an authorized person under a valid
+// licensing agreement from Arm Limited or its affiliates.
+//
+// Copyright (C) 2025. Arm Limited or its affiliates. All rights reserved.
+//
+// This entire notice must be reproduced on all copies of this file and
+// copies of this file may only be made by an authorized person under a valid
+// licensing agreement from Arm Limited or its affiliates.
+// -----------------------------------------------------------------------------
+//
+#ifndef NSS_KERNEL_LUT
+#define NSS_KERNEL_LUT
+#include "typedefs.h"
+
+
+struct KernelTile {
+    int16_t4 dy;
+    int16_t4 dx;
+};
+
+
+// Define actual scale value based on mode
+#if SCALE_MODE == SCALE_2_0X
+
+#define CENTER_TAP 0
+#define NUM_PATTERNS 4
+
+const KernelTile kernelLUT[NUM_PATTERNS] = {
+    {
+        // Pattern 0:
+        // Taps:  0,  2,  8, 10
+        // Grid:
+        //   [●  ·  ●  ·]
+        //   [·  ·  ·  ·]
+        //   [●  ·  ●  ·]
+        //   [·  ·  ·  ·]
+        int16_t4(-1, -1, +1, +1),
+        int16_t4(-1, +1, -1, +1)
+    },
+    {
+        // Pattern 1:
+        // Taps:  4,  6, 12, 14
+        // Grid:
+        //   [·  ·  ·  ·]
+        //   [●  ·  ●  ·]
+        //   [·  ·  ·  ·]
+        //   [●  ·  ●  ·]
+        int16_t4(-1, -1, +1, +1),
+        int16_t4(+0, +2, +0, +2)
+    },
+    {
+        // Pattern 2:
+        // Taps:  1,  3,  9, 11
+        // Grid:
+        //   [·  ●  ·  ●]
+        //   [·  ·  ·  ·]
+        //   [·  ●  ·  ●]
+        //   [·  ·  ·  ·]
+        int16_t4(+0, +0, +2, +2),
+        int16_t4(-1, +1, -1, +1)
+    },
+    {
+        // Pattern 3:
+        // Taps:  5,  7, 13, 15
+        // Grid:
+        //   [·  ·  ·  ·]
+        //   [·  ●  ·  ●]
+        //   [·  ·  ·  ·]
+        //   [·  ●  ·  ●]
+        int16_t4( 0, +0, +2, +2), // center-aligned
+        int16_t4( 0, +2, +0, +2)
+    }
+};
+
+#else
+    #error "Unsupported SCALE_MODE"
+#endif
+
+
+#endif //NSS_KERNEL_LUT

scenario/parameters.json

@@ -0,0 +1,79 @@
+{
+    "inputs": {
+        "x": {
+            "SINT": {
+                "scale": 0.003921568859368563,
+                "zero_point": -128
+            },
+            "SNORM": {
+                "scale": 0.49803924513980746,
+                "zero_point": -1.0078740157480315
+            }
+        }
+    },
+    "outputs": {
+        "activation_post_process_45": {
+            "SINT": {
+                "scale": 0.003937007859349251,
+                "zero_point": -127
+            },
+            "SNORM": {
+                "scale": 0.49999999813735485,
+                "zero_point": -1.0
+            }
+        },
+        "activation_post_process_50": {
+            "SINT": {
+                "scale": 0.003937007859349251,
+                "zero_point": -127
+            },
+            "SNORM": {
+                "scale": 0.49999999813735485,
+                "zero_point": -1.0
+            }
+        },
+        "activation_post_process_55": {
+            "SINT": {
+                "scale": 0.003937007859349251,
+                "zero_point": -127
+            },
+            "SNORM": {
+                "scale": 0.49999999813735485,
+                "zero_point": -1.0
+            }
+        },
+        "activation_post_process_60": {
+            "SINT": {
+                "scale": 0.003937007859349251,
+                "zero_point": -127
+            },
+            "SNORM": {
+                "scale": 0.49999999813735485,
+                "zero_point": -1.0
+            }
+        },
+        "activation_post_process_65": {
+            "SINT": {
+                "scale": 0.003937007859349251,
+                "zero_point": -127
+            },
+            "SNORM": {
+                "scale": 0.49999999813735485,
+                "zero_point": -1.0
+            }
+        },
+        "activation_post_process_70": {
+            "SINT": {
+                "scale": 0.003937007859349251,
+                "zero_point": -127
+            },
+            "SNORM": {
+                "scale": 0.49999999813735485,
+                "zero_point": -1.0
+            }
+        }
+    },
+    "learnt_constants": {
+        "dm_scale": 0.617464542388916
+    }
+}

scenario/scenario.json

@@ -0,0 +1,821 @@
+{
+    "commands": [
+        {
+            "mark_boundary": {
+                "frame_id": "0",
+                "resources": []
+            }
+        },
+        {
+            "dispatch_compute": {
+                "shader_ref": "0_pre_process",
+                "push_data_ref": "push_data_1",
+                "rangeND": [
+                    60,
+                    34,
+                    1
+                ],
+                "implicit_barrier": false,
+                "bindings": [
+                    {
+                        "set": 0,
+                        "id": 2,
+                        "resource_ref": "in_motion"
+                    },
+                    {
+                        "set": 0,
+                        "id": 0,
+                        "resource_ref": "in_colour"
+                    },
+                    {
+                        "set": 0,
+                        "id": 7,
+                        "resource_ref": "in_nearest_offset_tm1"
+                    },
+                    {
+                        "set": 0,
+                        "id": 5,
+                        "resource_ref": "in_depth_tm1"
+                    },
+                    {
+                        "set": 0,
+                        "id": 3,
+                        "resource_ref": "in_history"
+                    },
+                    {
+                        "set": 0,
+                        "id": 4,
+                        "resource_ref": "in_feedback_tm1"
+                    },
+                    {
+                        "set": 0,
+                        "id": 6,
+                        "resource_ref": "in_derivative_tm1"
+                    },
+                    {
+                        "set": 0,
+                        "id": 1,
+                        "resource_ref": "in_depth"
+                    },
+                    {
+                        "set": 1,
+                        "id": 1,
+                        "resource_ref": "out_derivative",
+                        "descriptor_type": "VK_DESCRIPTOR_TYPE_STORAGE_IMAGE"
+                    },
+                    {
+                        "set": 1,
+                        "id": 3,
+                        "resource_ref": "out_nearest_offset",
+                        "descriptor_type": "VK_DESCRIPTOR_TYPE_STORAGE_IMAGE"
+                    },
+                    {
+                        "set": 1,
+                        "id": 0,
+                        "resource_ref": "out_input_tensor"
+                    }
+                ]
+            }
+        },
+        {
+            "dispatch_barrier": {
+                "image_barrier_refs": [],
+                "tensor_barrier_refs": [
+                    "barrier_14"
+                ],
+                "memory_barrier_refs": [],
+                "buffer_barrier_refs": []
+            }
+        },
+        {
+            "dispatch_graph": {
+                "graph_ref": "1_nss",
+                "implicit_barrier": false,
+                "bindings": [
+                    {
+                        "set": 0,
+                        "id": 0,
+                        "resource_ref": "out_input_tensor"
+                    },
+                    {
+                        "set": 0,
+                        "id": 1,
+                        "resource_ref": "out_feedback"
+                    },
+                    {
+                        "set": 0,
+                        "id": 2,
+                        "resource_ref": "out_tp_aliaser"
+                    },
+                    {
+                        "set": 0,
+                        "id": 3,
+                        "resource_ref": "out_k3_aliaser"
+                    },
+                    {
+                        "set": 0,
+                        "id": 4,
+                        "resource_ref": "out_k2_aliaser"
+                    },
+                    {
+                        "set": 0,
+                        "id": 5,
+                        "resource_ref": "out_k1_aliaser"
+                    },
+                    {
+                        "set": 0,
+                        "id": 6,
+                        "resource_ref": "out_k0_aliaser"
+                    }
+                ]
+            }
+        },
+        {
+            "dispatch_barrier": {
+                "image_barrier_refs": [
+                    "barrier_23",
+                    "barrier_25",
+                    "barrier_27",
+                    "barrier_29",
+                    "barrier_31",
+                    "barrier_33"
+                ],
+                "tensor_barrier_refs": [],
+                "memory_barrier_refs": [],
+                "buffer_barrier_refs": []
+            }
+        },
+        {
+            "dispatch_compute": {
+                "shader_ref": "2_post_process",
+                "push_data_ref": "push_data_22",
+                "rangeND": [
+                    120,
+                    68,
+                    1
+                ],
+                "implicit_barrier": false,
+                "bindings": [
+                    {
+                        "set": 0,
+                        "id": 1,
+                        "resource_ref": "in_motion"
+                    },
+                    {
+                        "set": 0,
+                        "id": 2,
+                        "resource_ref": "in_history"
+                    },
+                    {
+                        "set": 0,
+                        "id": 8,
+                        "resource_ref": "out_nearest_offset"
+                    },
+                    {
+                        "set": 0,
+                        "id": 3,
+                        "resource_ref": "out_k0"
+                    },
+                    {
+                        "set": 0,
+                        "id": 4,
+                        "resource_ref": "out_k1"
+                    },
+                    {
+                        "set": 0,
+                        "id": 5,
+                        "resource_ref": "out_k2"
+                    },
+                    {
+                        "set": 0,
+                        "id": 6,
+                        "resource_ref": "out_k3"
+                    },
+                    {
+                        "set": 0,
+                        "id": 0,
+                        "resource_ref": "in_colour"
+                    },
+                    {
+                        "set": 0,
+                        "id": 7,
+                        "resource_ref": "out_tp"
+                    },
+                    {
+                        "set": 1,
+                        "id": 0,
+                        "resource_ref": "out_colour",
+                        "descriptor_type": "VK_DESCRIPTOR_TYPE_STORAGE_IMAGE"
+                    }
+                ]
+            }
+        },
+        {
+            "mark_boundary": {
+                "frame_id": "1",
+                "resources": [
+                    "out_colour"
+                ]
+            }
+        }
+    ],
+    "resources": [
+        {
+            "shader": {
+                "uid": "0_pre_process",
+                "src": "./0_pre_process.spv",
+                "entry": "main",
+                "type": "SPIR-V",
+                "push_constants_size": 128,
+                "specialization_constants": []
+            }
+        },
+        {
+            "raw_data": {
+                "uid": "push_data_1",
+                "src": "./0_pre_process_push_consts.npy"
+            }
+        },
+        {
+            "image": {
+                "uid": "in_motion",
+                "dims": [
+                    1,
+                    960,
+                    544,
+                    1
+                ],
+                "src": "./in_motion.dds",
+                "format": "VK_FORMAT_R16G16_SFLOAT",
+                "shader_access": "readonly",
+                "mips": 1,
+                "min_filter": "LINEAR",
+                "mag_filter": "LINEAR",
+                "mip_filter": "NEAREST",
+                "border_address_mode": "CLAMP_BORDER",
+                "border_color": "FLOAT_TRANSPARENT_BLACK",
+                "tiling": "OPTIMAL"
+            }
+        },
+        {
+            "image": {
+                "uid": "in_colour",
+                "dims": [
+                    1,
+                    960,
+                    544,
+                    1
+                ],
+                "src": "./in_colour.dds",
+                "format": "VK_FORMAT_B10G11R11_UFLOAT_PACK32",
+                "shader_access": "readonly",
+                "mips": 1,
+                "min_filter": "LINEAR",
+                "mag_filter": "LINEAR",
+                "mip_filter": "NEAREST",
+                "border_address_mode": "CLAMP_BORDER",
+                "border_color": "FLOAT_TRANSPARENT_BLACK",
+                "tiling": "OPTIMAL"
+            }
+        },
+        {
+            "image": {
+                "uid": "in_nearest_offset_tm1",
+                "dims": [
+                    1,
+                    960,
+                    544,
+                    1
+                ],
+                "src": "./in_nearest_offset_tm1.dds",
+                "format": "VK_FORMAT_R8_UNORM",
+                "shader_access": "readonly",
+                "mips": 1,
+                "min_filter": "LINEAR",
+                "mag_filter": "LINEAR",
+                "mip_filter": "NEAREST",
+                "border_address_mode": "CLAMP_BORDER",
+                "border_color": "FLOAT_CUSTOM_EXT",
+                "custom_border_color": [
+                    0.0,
+                    0.0,
+                    0.0,
+                    0.0
+                ],
+                "tiling": "OPTIMAL"
+            }
+        },
+        {
+            "image": {
+                "uid": "in_depth_tm1",
+                "dims": [
+                    1,
+                    960,
+                    544,
+                    1
+                ],
+                "src": "./in_depth_tm1.dds",
+                "format": "VK_FORMAT_R32_SFLOAT",
+                "shader_access": "readonly",
+                "mips": 1,
+                "min_filter": "LINEAR",
+                "mag_filter": "LINEAR",
+                "mip_filter": "NEAREST",
+                "border_address_mode": "CLAMP_BORDER",
+                "border_color": "FLOAT_CUSTOM_EXT",
+                "custom_border_color": [
+                    0.0,
+                    0.0,
+                    0.0,
+                    0.0
+                ],
+                "tiling": "OPTIMAL"
+            }
+        },
+        {
+            "image": {
+                "uid": "in_history",
+                "dims": [
+                    1,
+                    1920,
+                    1088,
+                    1
+                ],
+                "src": "./in_history.dds",
+                "format": "VK_FORMAT_B10G11R11_UFLOAT_PACK32",
+                "shader_access": "readonly",
+                "mips": 1,
+                "min_filter": "LINEAR",
+                "mag_filter": "LINEAR",
+                "mip_filter": "NEAREST",
+                "border_address_mode": "CLAMP_EDGE",
+                "tiling": "OPTIMAL"
+            }
+        },
+        {
+            "image": {
+                "uid": "in_feedback_tm1",
+                "dims": [
+                    1,
+                    960,
+                    544,
+                    1
+                ],
+                "src": "./in_feedback_tm1.dds",
+                "format": "VK_FORMAT_R8G8B8A8_SNORM",
+                "shader_access": "readonly",
+                "mips": 1,
+                "min_filter": "LINEAR",
+                "mag_filter": "LINEAR",
+                "mip_filter": "NEAREST",
+                "border_address_mode": "CLAMP_BORDER",
+                "border_color": "FLOAT_CUSTOM_EXT",
+                "custom_border_color": [
+                    -1.0,
+                    -1.0,
+                    -1.0,
+                    -1.0
+                ],
+                "tiling": "OPTIMAL"
+            }
+        },
+        {
+            "image": {
+                "uid": "in_derivative_tm1",
+                "dims": [
+                    1,
+                    960,
+                    544,
+                    1
+                ],
+                "src": "./in_derivative_tm1.dds",
+                "format": "VK_FORMAT_R8G8_UNORM",
+                "shader_access": "readonly",
+                "mips": 1,
+                "min_filter": "LINEAR",
+                "mag_filter": "LINEAR",
+                "mip_filter": "NEAREST",
+                "border_address_mode": "CLAMP_BORDER",
+                "border_color": "FLOAT_TRANSPARENT_BLACK",
+                "tiling": "OPTIMAL"
+            }
+        },
+        {
+            "image": {
+                "uid": "in_depth",
+                "dims": [
+                    1,
+                    960,
+                    544,
+                    1
+                ],
+                "src": "./in_depth.dds",
+                "format": "VK_FORMAT_R32_SFLOAT",
+                "shader_access": "readonly",
+                "mips": 1,
+                "min_filter": "LINEAR",
+                "mag_filter": "LINEAR",
+                "mip_filter": "NEAREST",
+                "border_address_mode": "CLAMP_BORDER",
+                "border_color": "FLOAT_TRANSPARENT_BLACK",
+                "tiling": "OPTIMAL"
+            }
+        },
+        {
+            "image": {
+                "uid": "out_derivative",
+                "dims": [
+                    1,
+                    960,
+                    544,
+                    1
+                ],
+                "dst": "./out_derivative.dds",
+                "format": "VK_FORMAT_R8G8_UNORM",
+                "shader_access": "writeonly",
+                "mips": 1,
+                "tiling": "LINEAR"
+            }
+        },
+        {
+            "image": {
+                "uid": "out_nearest_offset",
+                "dims": [
+                    1,
+                    960,
+                    544,
+                    1
+                ],
+                "dst": "./out_nearest_offset.dds",
+                "format": "VK_FORMAT_R8_UNORM",
+                "shader_access": "readwrite",
+                "mips": 1,
+                "min_filter": "LINEAR",
+                "mag_filter": "LINEAR",
+                "mip_filter": "NEAREST",
+                "border_address_mode": "CLAMP_BORDER",
+                "border_color": "FLOAT_TRANSPARENT_BLACK",
+                "tiling": "LINEAR"
+            }
+        },
+        {
+            "tensor": {
+                "uid": "out_input_tensor",
+                "dims": [
+                    1,
+                    544,
+                    960,
+                    12
+                ],
+                "dst": "./out_input_tensor.npy",
+                "format": "VK_FORMAT_R8_SINT",
+                "shader_access": "readwrite",
+                "tiling": "LINEAR"
+            }
+        },
+        {
+            "graph": {
+                "uid": "1_nss",
+                "src": "./1_nss.vgf"
+            }
+        },
+        {
+            "tensor_barrier": {
+                "uid": "barrier_14",
+                "src_access": "compute_shader_write",
+                "dst_access": "graph_read",
+                "src_stage": [
+                    "compute"
+                ],
+                "dst_stage": [
+                    "graph"
+                ],
+                "tensor_resource": "out_input_tensor"
+            }
+        },
+        {
+            "tensor": {
+                "uid": "out_feedback",
+                "dims": [
+                    1,
+                    544,
+                    960,
+                    4
+                ],
+                "dst": "./out_feedback.npy",
+                "format": "VK_FORMAT_R8_SINT",
+                "shader_access": "writeonly",
+                "tiling": "LINEAR"
+            }
+        },
+        {
+            "image": {
+                "uid": "out_tp",
+                "dims": [
+                    1,
+                    960,
+                    544,
+                    1
+                ],
+                "format": "VK_FORMAT_R8G8B8A8_SNORM",
+                "shader_access": "readonly",
+                "mips": 1,
+                "min_filter": "LINEAR",
+                "mag_filter": "LINEAR",
+                "mip_filter": "NEAREST",
+                "border_address_mode": "CLAMP_BORDER",
+                "border_color": "FLOAT_TRANSPARENT_BLACK",
+                "tiling": "LINEAR"
+            }
+        },
+        {
+            "tensor": {
+                "uid": "out_tp_aliaser",
+                "dims": [
+                    1,
+                    544,
+                    960,
+                    4
+                ],
+                "format": "VK_FORMAT_R8_SINT",
+                "shader_access": "readwrite",
+                "alias_target": {
+                    "resource_ref": "out_tp"
+                },
+                "tiling": "LINEAR"
+            }
+        },
+        {
+            "image": {
+                "uid": "out_k3",
+                "dims": [
+                    1,
+                    960,
+                    544,
+                    1
+                ],
+                "format": "VK_FORMAT_R8G8B8A8_SNORM",
+                "shader_access": "readonly",
+                "mips": 1,
+                "min_filter": "LINEAR",
+                "mag_filter": "LINEAR",
+                "mip_filter": "NEAREST",
+                "border_address_mode": "CLAMP_EDGE",
+                "tiling": "LINEAR"
+            }
+        },
+        {
+            "tensor": {
+                "uid": "out_k3_aliaser",
+                "dims": [
+                    1,
+                    544,
+                    960,
+                    4
+                ],
+                "format": "VK_FORMAT_R8_SINT",
+                "shader_access": "readwrite",
+                "alias_target": {
+                    "resource_ref": "out_k3"
+                },
+                "tiling": "LINEAR"
+            }
+        },
+        {
+            "image": {
+                "uid": "out_k2",
+                "dims": [
+                    1,
+                    960,
+                    544,
+                    1
+                ],
+                "format": "VK_FORMAT_R8G8B8A8_SNORM",
+                "shader_access": "readonly",
+                "mips": 1,
+                "min_filter": "LINEAR",
+                "mag_filter": "LINEAR",
+                "mip_filter": "NEAREST",
+                "border_address_mode": "CLAMP_EDGE",
+                "tiling": "LINEAR"
+            }
+        },
+        {
+            "tensor": {
+                "uid": "out_k2_aliaser",
+                "dims": [
+                    1,
+                    544,
+                    960,
+                    4
+                ],
+                "format": "VK_FORMAT_R8_SINT",
+                "shader_access": "readwrite",
+                "alias_target": {
+                    "resource_ref": "out_k2"
+                },
+                "tiling": "LINEAR"
+            }
+        },
+        {
+            "image": {
+                "uid": "out_k1",
+                "dims": [
+                    1,
+                    960,
+                    544,
+                    1
+                ],
+                "format": "VK_FORMAT_R8G8B8A8_SNORM",
+                "shader_access": "readonly",
+                "mips": 1,
+                "min_filter": "LINEAR",
+                "mag_filter": "LINEAR",
+                "mip_filter": "NEAREST",
+                "border_address_mode": "CLAMP_EDGE",
+                "tiling": "LINEAR"
+            }
+        },
+        {
+            "tensor": {
+                "uid": "out_k1_aliaser",
+                "dims": [
+                    1,
+                    544,
+                    960,
+                    4
+                ],
+                "format": "VK_FORMAT_R8_SINT",
+                "shader_access": "readwrite",
+                "alias_target": {
+                    "resource_ref": "out_k1"
+                },
+                "tiling": "LINEAR"
+            }
+        },
+        {
+            "image": {
+                "uid": "out_k0",
+                "dims": [
+                    1,
+                    960,
+                    544,
+                    1
+                ],
+                "format": "VK_FORMAT_R8G8B8A8_SNORM",
+                "shader_access": "readonly",
+                "mips": 1,
+                "min_filter": "LINEAR",
+                "mag_filter": "LINEAR",
+                "mip_filter": "NEAREST",
+                "border_address_mode": "CLAMP_EDGE",
+                "tiling": "LINEAR"
+            }
+        },
+        {
+            "tensor": {
+                "uid": "out_k0_aliaser",
+                "dims": [
+                    1,
+                    544,
+                    960,
+                    4
+                ],
+                "format": "VK_FORMAT_R8_SINT",
+                "shader_access": "readwrite",
+                "alias_target": {
+                    "resource_ref": "out_k0"
+                },
+                "tiling": "LINEAR"
+            }
+        },
+        {
+            "shader": {
+                "uid": "2_post_process",
+                "src": "./2_post_process.spv",
+                "entry": "main",
+                "type": "SPIR-V",
+                "push_constants_size": 76,
+                "specialization_constants": []
+            }
+        },
+        {
+            "raw_data": {
+                "uid": "push_data_22",
+                "src": "./2_post_process_push_consts.npy"
+            }
+        },
+        {
+            "image_barrier": {
+                "uid": "barrier_23",
+                "src_access": "compute_shader_write",
+                "dst_access": "compute_shader_read",
+                "old_layout": "general",
+                "new_layout": "general",
+                "src_stage": [
+                    "compute"
+                ],
+                "dst_stage": [
+                    "compute"
+                ],
+                "image_resource": "out_nearest_offset"
+            }
+        },
+        {
+            "image_barrier": {
+                "uid": "barrier_25",
+                "src_access": "graph_write",
+                "dst_access": "compute_shader_read",
+                "old_layout": "general",
+                "new_layout": "general",
+                "src_stage": [
+                    "graph"
+                ],
+                "dst_stage": [
+                    "compute"
+                ],
+                "image_resource": "out_k0"
+            }
+        },
+        {
+            "image_barrier": {
+                "uid": "barrier_27",
+                "src_access": "graph_write",
+                "dst_access": "compute_shader_read",
+                "old_layout": "general",
+                "new_layout": "general",
+                "src_stage": [
+                    "graph"
+                ],
+                "dst_stage": [
+                    "compute"
+                ],
+                "image_resource": "out_k1"
+            }
+        },
+        {
+            "image_barrier": {
+                "uid": "barrier_29",
+                "src_access": "graph_write",
+                "dst_access": "compute_shader_read",
+                "old_layout": "general",
+                "new_layout": "general",
+                "src_stage": [
+                    "graph"
+                ],
+                "dst_stage": [
+                    "compute"
+                ],
+                "image_resource": "out_k2"
+            }
+        },
+        {
+            "image_barrier": {
+                "uid": "barrier_31",
+                "src_access": "graph_write",
+                "dst_access": "compute_shader_read",
+                "old_layout": "general",
+                "new_layout": "general",
+                "src_stage": [
+                    "graph"
+                ],
+                "dst_stage": [
+                    "compute"
+                ],
+                "image_resource": "out_k3"
+            }
+        },
+        {
+            "image_barrier": {
+                "uid": "barrier_33",
+                "src_access": "graph_write",
+                "dst_access": "compute_shader_read",
+                "old_layout": "general",
+                "new_layout": "general",
+                "src_stage": [
+                    "graph"
+                ],
+                "dst_stage": [
+                    "compute"
+                ],
+                "image_resource": "out_tp"
+            }
+        },
+        {
+            "image": {
+                "uid": "out_colour",
+                "dims": [
+                    1,
+                    1920,
+                    1088,
+                    1
+                ],
+                "dst": "./out_colour.dds",
+                "format": "VK_FORMAT_B10G11R11_UFLOAT_PACK32",
+                "shader_access": "writeonly",
+                "mips": 1,
+                "tiling": "LINEAR"
+            }
+        }
+    ]
+}

scenario/typedefs.h

@@ -0,0 +1,86 @@
+//
+// -----------------------------------------------------------------------------
+// The proprietary software and information contained in this file is
+// confidential and may only be used by an authorized person under a valid
+// licensing agreement from Arm Limited or its affiliates.
+//
+// Copyright (C) 2025. Arm Limited or its affiliates. All rights reserved.
+//
+// This entire notice must be reproduced on all copies of this file and
+// copies of this file may only be made by an authorized person under a valid
+// licensing agreement from Arm Limited or its affiliates.
+// -----------------------------------------------------------------------------
+//
+#ifndef NSS_TYPEDEFS
+#define NSS_TYPEDEFS
+
+// fp16 types
+#define half  float16_t
+#define half2 f16vec2
+#define half3 f16vec3
+#define half4 f16vec4
+
+// fp32 types
+#define float  float32_t
+#define float2 f32vec2
+#define float3 f32vec3
+#define float4 f32vec4
+
+// int8 types
+#define int8_t int8_t
+#define int8_t2 i8vec2
+#define int8_t3 i8vec3
+#define int8_t4 i8vec4
+
+// int16 types
+#define int16_t  int16_t
+#define int16_t2 i16vec2
+#define int16_t3 i16vec3
+#define int16_t4 i16vec4
+
+// uint16 types
+#define uint16_t  uint16_t
+#define uint16_t2 u16vec2
+#define uint16_t3 u16vec3
+#define uint16_t4 u16vec4
+
+// int32 types
+#define int32_t  int32_t
+#define int32_t2 i32vec2
+#define int32_t3 i32vec3
+#define int32_t4 i32vec4
+
+// uint32 types
+#define uint32_t  uint32_t
+#define uint32_t2 u32vec2
+#define uint32_t3 u32vec3
+#define uint32_t4 u32vec4
+
+// methods
+#define lerp mix
+
+// --- RCP functions for float16 types ---
+half rcp(half x)     { return half( 1.HF) / x; }
+half2 rcp(half2 x)   { return half2(1.HF) / x; }
+half3 rcp(half3 x)   { return half3(1.HF) / x; }
+half4 rcp(half4 x)   { return half4(1.HF) / x; }
+
+// --- RCP functions for float32 types ---
+float rcp(float x)   { return float( 1.0f) / x; }
+float2 rcp(float2 x) { return float2(1.0f) / x; }
+float3 rcp(float3 x) { return float3(1.0f) / x; }
+float4 rcp(float4 x) { return float4(1.0f) / x; }
+
+// --- Saturate functions for float16 types ---
+half   saturate(half x)     { return clamp(x, half( 0.HF), half( 1.HF)); }
+half2  saturate(half2 x)    { return clamp(x, half2(0.HF), half2(1.HF)); }
+half3  saturate(half3 x)    { return clamp(x, half3(0.HF), half3(1.HF)); }
+half4  saturate(half4 x)    { return clamp(x, half4(0.HF), half4(1.HF)); }
+
+// --- Saturate functions for float32 types ---
+float   saturate(float x)     { return clamp(x, 0.f, 1.f); }
+float2  saturate(float2 x)    { return clamp(x, float2(0.f), float2(1.f)); }
+float3  saturate(float3 x)    { return clamp(x, float3(0.f), float3(1.f)); }
+float4  saturate(float4 x)    { return clamp(x, float4(0.f), float4(1.f)); }
+
+#endif  // NSS_TYPEDEFS

third_party_licenses_and_copyright_notices.txt

@@ -0,0 +1,15 @@
+ML SDK Scenario Runner - revision 197a36e
+Source Code: https://github.com/arm/ai-ml-sdk-scenario-runner
+License: Apache-2.0 (https://github.com/arm/ai-ml-sdk-scenario-runner/blob/main/LICENSES/Apache-2.0.txt)
+Copyright Notice: "Copyright 2022-2025 Arm Limited and/or its affiliates <[email protected]>"
+
+ML Emulation Layer for Vulkan® - revision 788ac99
+Source Code: https://github.com/arm/ai-ml-emulation-layer-for-vulkan
+License: Apache-2.0 (https://github.com/arm/ai-ml-emulation-layer-for-vulkan/blob/main/LICENSES/Apache-2.0.txt)
+Copyright Notice: "Copyright 2022-2025 Arm Limited and/or its affiliates <[email protected]>"
+
+Amazon Lumberyard Bistro
+Asset page: http://developer.nvidia.com/orca/amazon-lumberyard-bistro
+Download page: https://casual-effects.com/g3d/data10/research/model/bistro/Exterior.zip
+License: CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/)
+Copyright Notice: "Copyright 2017 Amazon Lumberyard"