add and update samples for CUDA 11.5

2026-10-23 21:28:17 +08:00 · 2021-10-21 16:34:49 +05:30
parent 3342d604fe
commit 1f76a2d110
2796 changed files with 1511725 additions and 827 deletions
--- a/Samples/bilateralFilter/.vscode/c_cpp_properties.json
+++ b/Samples/bilateralFilter/.vscode/c_cpp_properties.json
@@ -0,0 +1,18 @@
+{
+    "configurations": [
+        {
+            "name": "Linux",
+            "includePath": [
+                "${workspaceFolder}/**",
+                "${workspaceFolder}/../../Common"
+            ],
+            "defines": [],
+            "compilerPath": "/usr/local/cuda/bin/nvcc",
+            "cStandard": "gnu17",
+            "cppStandard": "gnu++14",
+            "intelliSenseMode": "linux-gcc-x64",
+            "configurationProvider": "ms-vscode.makefile-tools"
+        }
+    ],
+    "version": 4
+}
--- a/Samples/bilateralFilter/.vscode/extensions.json
+++ b/Samples/bilateralFilter/.vscode/extensions.json
@@ -0,0 +1,7 @@
+{
+    "recommendations": [
+        "nvidia.nsight-vscode-edition",
+        "ms-vscode.cpptools",
+        "ms-vscode.makefile-tools"
+    ]
+}
--- a/Samples/bilateralFilter/.vscode/launch.json
+++ b/Samples/bilateralFilter/.vscode/launch.json
@@ -0,0 +1,10 @@
+{
+    "configurations": [
+        {
+            "name": "CUDA C++: Launch",
+            "type": "cuda-gdb",
+            "request": "launch",
+            "program": "${workspaceFolder}/bilateralFilter"
+        }
+    ]
+}
--- a/Samples/bilateralFilter/.vscode/tasks.json
+++ b/Samples/bilateralFilter/.vscode/tasks.json
@@ -0,0 +1,15 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "sample",
+            "type": "shell",
+            "command": "make dbg=1",
+            "problemMatcher": ["$nvcc"],
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            }
+        }
+    ]
+}
--- a/Samples/bilateralFilter/Makefile
+++ b/Samples/bilateralFilter/Makefile
@@ -0,0 +1,391 @@
+################################################################################
+# Copyright (c) 2019, NVIDIA CORPORATION. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#  * Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+#  * Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in the
+#    documentation and/or other materials provided with the distribution.
+#  * Neither the name of NVIDIA CORPORATION nor the names of its
+#    contributors may be used to endorse or promote products derived
+#    from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+# OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+################################################################################
+#
+# Makefile project only supported on Mac OS X and Linux Platforms)
+#
+################################################################################
+
+# Location of the CUDA Toolkit
+CUDA_PATH ?= /usr/local/cuda
+
+##############################
+# start deprecated interface #
+##############################
+ifeq ($(x86_64),1)
+    $(info WARNING - x86_64 variable has been deprecated)
+    $(info WARNING - please use TARGET_ARCH=x86_64 instead)
+    TARGET_ARCH ?= x86_64
+endif
+ifeq ($(ARMv7),1)
+    $(info WARNING - ARMv7 variable has been deprecated)
+    $(info WARNING - please use TARGET_ARCH=armv7l instead)
+    TARGET_ARCH ?= armv7l
+endif
+ifeq ($(aarch64),1)
+    $(info WARNING - aarch64 variable has been deprecated)
+    $(info WARNING - please use TARGET_ARCH=aarch64 instead)
+    TARGET_ARCH ?= aarch64
+endif
+ifeq ($(ppc64le),1)
+    $(info WARNING - ppc64le variable has been deprecated)
+    $(info WARNING - please use TARGET_ARCH=ppc64le instead)
+    TARGET_ARCH ?= ppc64le
+endif
+ifneq ($(GCC),)
+    $(info WARNING - GCC variable has been deprecated)
+    $(info WARNING - please use HOST_COMPILER=$(GCC) instead)
+    HOST_COMPILER ?= $(GCC)
+endif
+ifneq ($(abi),)
+    $(error ERROR - abi variable has been removed)
+endif
+############################
+# end deprecated interface #
+############################
+
+# architecture
+HOST_ARCH   := $(shell uname -m)
+TARGET_ARCH ?= $(HOST_ARCH)
+ifneq (,$(filter $(TARGET_ARCH),x86_64 aarch64 sbsa ppc64le armv7l))
+    ifneq ($(TARGET_ARCH),$(HOST_ARCH))
+        ifneq (,$(filter $(TARGET_ARCH),x86_64 aarch64 sbsa ppc64le))
+            TARGET_SIZE := 64
+        else ifneq (,$(filter $(TARGET_ARCH),armv7l))
+            TARGET_SIZE := 32
+        endif
+    else
+        TARGET_SIZE := $(shell getconf LONG_BIT)
+    endif
+else
+    $(error ERROR - unsupported value $(TARGET_ARCH) for TARGET_ARCH!)
+endif
+
+# sbsa and aarch64 systems look similar. Need to differentiate them at host level for now.
+ifeq ($(HOST_ARCH),aarch64)
+    ifeq ($(CUDA_PATH)/targets/sbsa-linux,$(shell ls -1d $(CUDA_PATH)/targets/sbsa-linux 2>/dev/null))
+        HOST_ARCH := sbsa
+        TARGET_ARCH := sbsa
+    endif
+endif
+
+ifneq ($(TARGET_ARCH),$(HOST_ARCH))
+    ifeq (,$(filter $(HOST_ARCH)-$(TARGET_ARCH),aarch64-armv7l x86_64-armv7l x86_64-aarch64 x86_64-sbsa x86_64-ppc64le))
+        $(error ERROR - cross compiling from $(HOST_ARCH) to $(TARGET_ARCH) is not supported!)
+    endif
+endif
+
+# When on native aarch64 system with userspace of 32-bit, change TARGET_ARCH to armv7l
+ifeq ($(HOST_ARCH)-$(TARGET_ARCH)-$(TARGET_SIZE),aarch64-aarch64-32)
+    TARGET_ARCH = armv7l
+endif
+
+# operating system
+HOST_OS   := $(shell uname -s 2>/dev/null | tr "[:upper:]" "[:lower:]")
+TARGET_OS ?= $(HOST_OS)
+ifeq (,$(filter $(TARGET_OS),linux darwin qnx android))
+    $(error ERROR - unsupported value $(TARGET_OS) for TARGET_OS!)
+endif
+
+# host compiler
+ifeq ($(TARGET_OS),darwin)
+    ifeq ($(shell expr `xcodebuild -version | grep -i xcode | awk '{print $$2}' | cut -d'.' -f1` \>= 5),1)
+        HOST_COMPILER ?= clang++
+    endif
+else ifneq ($(TARGET_ARCH),$(HOST_ARCH))
+    ifeq ($(HOST_ARCH)-$(TARGET_ARCH),x86_64-armv7l)
+        ifeq ($(TARGET_OS),linux)
+            HOST_COMPILER ?= arm-linux-gnueabihf-g++
+        else ifeq ($(TARGET_OS),qnx)
+            ifeq ($(QNX_HOST),)
+                $(error ERROR - QNX_HOST must be passed to the QNX host toolchain)
+            endif
+            ifeq ($(QNX_TARGET),)
+                $(error ERROR - QNX_TARGET must be passed to the QNX target toolchain)
+            endif
+            export QNX_HOST
+            export QNX_TARGET
+            HOST_COMPILER ?= $(QNX_HOST)/usr/bin/arm-unknown-nto-qnx6.6.0eabi-g++
+        else ifeq ($(TARGET_OS),android)
+            HOST_COMPILER ?= arm-linux-androideabi-g++
+        endif
+    else ifeq ($(TARGET_ARCH),aarch64)
+        ifeq ($(TARGET_OS), linux)
+            HOST_COMPILER ?= aarch64-linux-gnu-g++
+        else ifeq ($(TARGET_OS),qnx)
+            ifeq ($(QNX_HOST),)
+                $(error ERROR - QNX_HOST must be passed to the QNX host toolchain)
+            endif
+            ifeq ($(QNX_TARGET),)
+                $(error ERROR - QNX_TARGET must be passed to the QNX target toolchain)
+            endif
+            export QNX_HOST
+            export QNX_TARGET
+            HOST_COMPILER ?= $(QNX_HOST)/usr/bin/q++
+        else ifeq ($(TARGET_OS), android)
+            HOST_COMPILER ?= aarch64-linux-android-clang++
+        endif
+    else ifeq ($(TARGET_ARCH),sbsa)
+        HOST_COMPILER ?= aarch64-linux-gnu-g++
+    else ifeq ($(TARGET_ARCH),ppc64le)
+        HOST_COMPILER ?= powerpc64le-linux-gnu-g++
+    endif
+endif
+HOST_COMPILER ?= g++
+NVCC          := $(CUDA_PATH)/bin/nvcc -ccbin $(HOST_COMPILER)
+
+# internal flags
+NVCCFLAGS   := -m${TARGET_SIZE}
+CCFLAGS     :=
+LDFLAGS     :=
+
+# build flags
+ifeq ($(TARGET_OS),darwin)
+    LDFLAGS += -rpath $(CUDA_PATH)/lib
+    CCFLAGS += -arch $(HOST_ARCH)
+else ifeq ($(HOST_ARCH)-$(TARGET_ARCH)-$(TARGET_OS),x86_64-armv7l-linux)
+    LDFLAGS += --dynamic-linker=/lib/ld-linux-armhf.so.3
+    CCFLAGS += -mfloat-abi=hard
+else ifeq ($(TARGET_OS),android)
+    LDFLAGS += -pie
+    CCFLAGS += -fpie -fpic -fexceptions
+endif
+
+ifneq ($(TARGET_ARCH),$(HOST_ARCH))
+    ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-linux)
+        ifneq ($(TARGET_FS),)
+            GCCVERSIONLTEQ46 := $(shell expr `$(HOST_COMPILER) -dumpversion` \<= 4.6)
+            ifeq ($(GCCVERSIONLTEQ46),1)
+                CCFLAGS += --sysroot=$(TARGET_FS)
+            endif
+            LDFLAGS += --sysroot=$(TARGET_FS)
+            LDFLAGS += -rpath-link=$(TARGET_FS)/lib
+            LDFLAGS += -rpath-link=$(TARGET_FS)/usr/lib
+            LDFLAGS += -rpath-link=$(TARGET_FS)/usr/lib/arm-linux-gnueabihf
+        endif
+    endif
+    ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-linux)
+        ifneq ($(TARGET_FS),)
+            GCCVERSIONLTEQ46 := $(shell expr `$(HOST_COMPILER) -dumpversion` \<= 4.6)
+            ifeq ($(GCCVERSIONLTEQ46),1)
+                CCFLAGS += --sysroot=$(TARGET_FS)
+            endif
+            LDFLAGS += --sysroot=$(TARGET_FS)
+            LDFLAGS += -rpath-link=$(TARGET_FS)/lib -L$(TARGET_FS)/lib
+            LDFLAGS += -rpath-link=$(TARGET_FS)/lib/aarch64-linux-gnu -L$(TARGET_FS)/lib/aarch64-linux-gnu
+            LDFLAGS += -rpath-link=$(TARGET_FS)/usr/lib -L$(TARGET_FS)/usr/lib
+            LDFLAGS += -rpath-link=$(TARGET_FS)/usr/lib/aarch64-linux-gnu -L$(TARGET_FS)/usr/lib/aarch64-linux-gnu
+            LDFLAGS += --unresolved-symbols=ignore-in-shared-libs
+            CCFLAGS += -isystem=$(TARGET_FS)/usr/include -I$(TARGET_FS)/usr/include -I$(TARGET_FS)/usr/include/libdrm
+            CCFLAGS += -isystem=$(TARGET_FS)/usr/include/aarch64-linux-gnu -I$(TARGET_FS)/usr/include/aarch64-linux-gnu
+        endif
+    endif
+    ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-qnx)
+        NVCCFLAGS += --qpp-config 5.4.0,gcc_ntoaarch64le
+        CCFLAGS += -DWIN_INTERFACE_CUSTOM -I/usr/include/aarch64-qnx-gnu
+        LDFLAGS += -lsocket
+        LDFLAGS += -L/usr/lib/aarch64-qnx-gnu
+        CCFLAGS += "-Wl\,-rpath-link\,/usr/lib/aarch64-qnx-gnu"
+        ifdef TARGET_OVERRIDE
+            LDFLAGS += -lslog2
+        endif
+
+        ifneq ($(TARGET_FS),)
+            LDFLAGS += -L$(TARGET_FS)/usr/lib
+            CCFLAGS += "-Wl\,-rpath-link\,$(TARGET_FS)/usr/lib"
+            LDFLAGS += -L$(TARGET_FS)/usr/libnvidia
+            CCFLAGS += "-Wl\,-rpath-link\,$(TARGET_FS)/usr/libnvidia"
+            CCFLAGS += -I$(TARGET_FS)/../include
+        endif
+    endif
+endif
+
+ifdef TARGET_OVERRIDE # cuda toolkit targets override
+    NVCCFLAGS += -target-dir $(TARGET_OVERRIDE)
+endif
+
+# Install directory of different arch
+CUDA_INSTALL_TARGET_DIR :=
+ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-linux)
+    CUDA_INSTALL_TARGET_DIR = targets/armv7-linux-gnueabihf/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-linux)
+    CUDA_INSTALL_TARGET_DIR = targets/aarch64-linux/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),sbsa-linux)
+    CUDA_INSTALL_TARGET_DIR = targets/sbsa-linux/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-android)
+    CUDA_INSTALL_TARGET_DIR = targets/armv7-linux-androideabi/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-android)
+    CUDA_INSTALL_TARGET_DIR = targets/aarch64-linux-androideabi/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-qnx)
+    CUDA_INSTALL_TARGET_DIR = targets/ARMv7-linux-QNX/
+else ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-qnx)
+    CUDA_INSTALL_TARGET_DIR = targets/aarch64-qnx/
+else ifeq ($(TARGET_ARCH),ppc64le)
+    CUDA_INSTALL_TARGET_DIR = targets/ppc64le-linux/
+endif
+
+# Debug build flags
+ifeq ($(dbg),1)
+      NVCCFLAGS += -g -G
+      BUILD_TYPE := debug
+else
+      BUILD_TYPE := release
+endif
+
+ALL_CCFLAGS :=
+ALL_CCFLAGS += $(NVCCFLAGS)
+ALL_CCFLAGS += $(EXTRA_NVCCFLAGS)
+ALL_CCFLAGS += $(addprefix -Xcompiler ,$(CCFLAGS))
+ALL_CCFLAGS += $(addprefix -Xcompiler ,$(EXTRA_CCFLAGS))
+
+SAMPLE_ENABLED := 1
+
+# This sample is not supported on QNX
+ifeq ($(TARGET_OS),qnx)
+  $(info >>> WARNING - bilateralFilter is not supported on QNX - waiving sample <<<)
+  SAMPLE_ENABLED := 0
+endif
+
+ALL_LDFLAGS :=
+ALL_LDFLAGS += $(ALL_CCFLAGS)
+ALL_LDFLAGS += $(addprefix -Xlinker ,$(LDFLAGS))
+ALL_LDFLAGS += $(addprefix -Xlinker ,$(EXTRA_LDFLAGS))
+
+# Common includes and paths for CUDA
+INCLUDES  := -I../../Common
+LIBRARIES :=
+
+################################################################################
+
+# Makefile include to help find GL Libraries
+include ./findgllib.mk
+
+# OpenGL specific libraries
+ifeq ($(TARGET_OS),darwin)
+ # Mac OSX specific libraries and paths to include
+ LIBRARIES += -L/System/Library/Frameworks/OpenGL.framework/Libraries
+ LIBRARIES += -lGL -lGLU
+ ALL_LDFLAGS += -Xlinker -framework -Xlinker GLUT
+else
+ LIBRARIES += $(GLLINK)
+ LIBRARIES += -lGL -lGLU -lglut
+endif
+
+#Detect if installed version of GCC supports required C++11
+ifeq ($(TARGET_OS),linux)
+    empty :=
+    space := $(empty) $(empty)
+    GCCVERSIONSTRING := $(shell expr `$(HOST_COMPILER) -dumpversion`)
+#Create version number without "."
+    GCCVERSION := $(shell expr `echo $(GCCVERSIONSTRING)` | cut -f1 -d.)
+    GCCVERSION += $(shell expr `echo $(GCCVERSIONSTRING)` | cut -f2 -d.)
+    GCCVERSION += $(shell expr `echo $(GCCVERSIONSTRING)` | cut -f3 -d.)
+# Make sure the version number has at least 3 decimals
+    GCCVERSION += 00
+# Remove spaces from the version number
+    GCCVERSION := $(subst $(space),$(empty),$(GCCVERSION))
+#$(warning $(GCCVERSION))
+
+    IS_MIN_VERSION := $(shell expr `echo $(GCCVERSION)` \>= 51000)
+
+    ifeq ($(IS_MIN_VERSION), 1)
+        $(info >>> GCC Version is greater or equal to 5.1.0 <<<)
+    else
+        $(info >>> Waiving build. Minimum GCC version required is 5.1.0<<<)
+        SAMPLE_ENABLED := 0
+    endif
+endif
+
+# Gencode arguments
+ifeq ($(TARGET_ARCH),$(filter $(TARGET_ARCH),armv7l aarch64))
+SMS ?= 35 37 50 52 60 61 70 72 75 80 86
+else
+SMS ?= 35 37 50 52 60 61 70 75 80 86
+endif
+
+ifeq ($(SMS),)
+$(info >>> WARNING - no SM architectures have been specified - waiving sample <<<)
+SAMPLE_ENABLED := 0
+endif
+
+ifeq ($(GENCODE_FLAGS),)
+# Generate SASS code for each SM architecture listed in $(SMS)
+$(foreach sm,$(SMS),$(eval GENCODE_FLAGS += -gencode arch=compute_$(sm),code=sm_$(sm)))
+
+# Generate PTX code from the highest SM architecture in $(SMS) to guarantee forward-compatibility
+HIGHEST_SM := $(lastword $(sort $(SMS)))
+ifneq ($(HIGHEST_SM),)
+GENCODE_FLAGS += -gencode arch=compute_$(HIGHEST_SM),code=compute_$(HIGHEST_SM)
+endif
+endif
+
+ALL_CCFLAGS += --threads 0 --std=c++11
+
+ifeq ($(SAMPLE_ENABLED),0)
+EXEC ?= @echo "[@]"
+endif
+
+################################################################################
+
+# Target rules
+all: build
+
+build: bilateralFilter
+
+check.deps:
+ifeq ($(SAMPLE_ENABLED),0)
+	@echo "Sample will be waived due to the above missing dependencies"
+else
+	@echo "Sample is ready - all dependencies have been met"
+endif
+
+bilateralFilter.o:bilateralFilter.cpp
+	$(EXEC) $(NVCC) $(INCLUDES) $(ALL_CCFLAGS) $(GENCODE_FLAGS) -o $@ -c $<
+
+bilateralFilter_cpu.o:bilateralFilter_cpu.cpp
+	$(EXEC) $(NVCC) $(INCLUDES) $(ALL_CCFLAGS) $(GENCODE_FLAGS) -o $@ -c $<
+
+bilateral_kernel.o:bilateral_kernel.cu
+	$(EXEC) $(NVCC) $(INCLUDES) $(ALL_CCFLAGS) $(GENCODE_FLAGS) -o $@ -c $<
+
+bmploader.o:bmploader.cpp
+	$(EXEC) $(NVCC) $(INCLUDES) $(ALL_CCFLAGS) $(GENCODE_FLAGS) -o $@ -c $<
+
+bilateralFilter: bilateralFilter.o bilateralFilter_cpu.o bilateral_kernel.o bmploader.o
+	$(EXEC) $(NVCC) $(ALL_LDFLAGS) $(GENCODE_FLAGS) -o $@ $+ $(LIBRARIES)
+	$(EXEC) mkdir -p ../../bin/$(TARGET_ARCH)/$(TARGET_OS)/$(BUILD_TYPE)
+	$(EXEC) cp $@ ../../bin/$(TARGET_ARCH)/$(TARGET_OS)/$(BUILD_TYPE)
+
+run: build
+	$(EXEC) ./bilateralFilter
+
+clean:
+	rm -f bilateralFilter bilateralFilter.o bilateralFilter_cpu.o bilateral_kernel.o bmploader.o
+	rm -rf ../../bin/$(TARGET_ARCH)/$(TARGET_OS)/$(BUILD_TYPE)/bilateralFilter
+
+clobber: clean
--- a/Samples/bilateralFilter/NsightEclipse.xml
+++ b/Samples/bilateralFilter/NsightEclipse.xml
@@ -0,0 +1,101 @@
+<?xml version="1.0" encoding="UTF-8"?> 
+<!DOCTYPE entry SYSTEM "SamplesInfo.dtd">
+<entry>
+  <name>bilateralFilter</name>
+  <cuda_api_list>
+    <toolkit>cudaGraphicsMapResources</toolkit>
+    <toolkit>cudaGraphicsUnmapResources</toolkit>
+    <toolkit>cudaGraphicsResourceGetMappedPointer</toolkit>
+    <toolkit>cudaGraphicsRegisterResource</toolkit>
+    <toolkit>cudaGraphicsGLRegisterBuffer</toolkit>
+    <toolkit>cudaGraphicsUnregisterResource</toolkit>
+  </cuda_api_list>
+  <description><![CDATA[Bilateral filter is an edge-preserving non-linear smoothing filter that is implemented with CUDA with OpenGL rendering. It can be used in image recovery and denoising. Each pixel is weight by considering both the spatial distance and color distance between its neighbors. Reference:"C. Tomasi, R. Manduchi, Bilateral Filtering for Gray and Color Images, proceeding of the ICCV, 1998, http://users.soe.ucsc.edu/~manduchi/Papers/ICCV98.pdf"]]></description>
+  <devicecompilation>whole</devicecompilation>
+  <files>
+    <file>data\nature_monte.bmp</file>
+    <file>data\ref_05.ppm</file>
+    <file>data\ref_06.ppm</file>
+    <file>data\ref_07.ppm</file>
+    <file>data\ref_08.ppm</file>
+  </files>
+  <includepaths>
+    <path>./</path>
+    <path>../</path>
+    <path>../../Common</path>
+  </includepaths>
+  <keyconcepts>
+    <concept level="basic">Graphics Interop</concept>
+    <concept level="basic">Image Processing</concept>
+  </keyconcepts>
+  <keywords>
+    <keyword>GPGPU</keyword>
+    <keyword>CUDA</keyword>
+    <keyword>Image Processing</keyword>
+    <keyword>box filter</keyword>
+    <keyword>opengl</keyword>
+    <keyword>openGL</keyword>
+  </keywords>
+  <libraries>
+    <library>GLU</library>
+    <library>GL</library>
+    <library framework="true" os="macosx">GLUT</library>
+    <library os="linux">GLEW</library>
+    <library os="linux">glut</library>
+    <library os="linux">X11</library>
+  </libraries>
+  <librarypaths>
+    <path arch="x86_64" os="linux">../../common/lib/linux/x86_64</path>
+    <path arch="armv7l" os="linux">../../common/lib/linux/armv7l</path>
+    <path os="macosx">../../common/lib/darwin</path>
+  </librarypaths>
+  <nsight_eclipse>true</nsight_eclipse>
+  <primary_file>bilateralFilter.cpp</primary_file>
+  <qatests>
+    <qatest>-radius=5 -file=ref_05.ppm</qatest>
+    <qatest>-radius=6 -file=ref_06.ppm</qatest>
+    <qatest>-radius=7 -file=ref_07.ppm</qatest>
+    <qatest>-radius=7 -file=ref_08.ppm</qatest>
+  </qatests>
+  <required_dependencies>
+    <dependency>X11</dependency>
+    <dependency>GL</dependency>
+  </required_dependencies>
+  <scopes>
+    <scope>2:Graphics Interop</scope>
+    <scope>2:Image Processing</scope>
+    <scope>2:Computer Vision</scope>
+  </scopes>
+  <sm-arch>sm35</sm-arch>
+  <sm-arch>sm37</sm-arch>
+  <sm-arch>sm50</sm-arch>
+  <sm-arch>sm52</sm-arch>
+  <sm-arch>sm60</sm-arch>
+  <sm-arch>sm61</sm-arch>
+  <sm-arch>sm70</sm-arch>
+  <sm-arch>sm72</sm-arch>
+  <sm-arch>sm75</sm-arch>
+  <sm-arch>sm80</sm-arch>
+  <sm-arch>sm86</sm-arch>
+  <supported_envs>
+    <env>
+      <arch>x86_64</arch>
+      <platform>linux</platform>
+    </env>
+    <env>
+      <platform>windows7</platform>
+    </env>
+    <env>
+      <arch>x86_64</arch>
+      <platform>macosx</platform>
+    </env>
+    <env>
+      <arch>arm</arch>
+    </env>
+  </supported_envs>
+  <supported_sm_architectures>
+    <include>all</include>
+  </supported_sm_architectures>
+  <title>Bilateral Filter</title>
+  <type>exe</type>
+</entry>
--- a/Samples/bilateralFilter/README.md
+++ b/Samples/bilateralFilter/README.md
@@ -0,0 +1,74 @@
+# bilateralFilter - Bilateral Filter
+
+## Description
+
+Bilateral filter is an edge-preserving non-linear smoothing filter that is implemented with CUDA with OpenGL rendering. It can be used in image recovery and denoising. Each pixel is weight by considering both the spatial distance and color distance between its neighbors. Reference:"C. Tomasi, R. Manduchi, Bilateral Filtering for Gray and Color Images, proceeding of the ICCV, 1998, http://users.soe.ucsc.edu/~manduchi/Papers/ICCV98.pdf"
+
+## Key Concepts
+
+Graphics Interop, Image Processing
+
+## Supported SM Architectures
+
+[SM 3.5 ](https://developer.nvidia.com/cuda-gpus)  [SM 3.7 ](https://developer.nvidia.com/cuda-gpus)  [SM 5.0 ](https://developer.nvidia.com/cuda-gpus)  [SM 5.2 ](https://developer.nvidia.com/cuda-gpus)  [SM 6.0 ](https://developer.nvidia.com/cuda-gpus)  [SM 6.1 ](https://developer.nvidia.com/cuda-gpus)  [SM 7.0 ](https://developer.nvidia.com/cuda-gpus)  [SM 7.2 ](https://developer.nvidia.com/cuda-gpus)  [SM 7.5 ](https://developer.nvidia.com/cuda-gpus)  [SM 8.0 ](https://developer.nvidia.com/cuda-gpus)  [SM 8.6 ](https://developer.nvidia.com/cuda-gpus)
+
+## Supported OSes
+
+Linux, Windows
+
+## Supported CPU Architecture
+
+x86_64, armv7l
+
+## CUDA APIs involved
+
+### [CUDA Runtime API](http://docs.nvidia.com/cuda/cuda-runtime-api/index.html)
+cudaGraphicsMapResources, cudaGraphicsUnmapResources, cudaGraphicsResourceGetMappedPointer, cudaGraphicsRegisterResource, cudaGraphicsGLRegisterBuffer, cudaGraphicsUnregisterResource
+
+## Dependencies needed to build/run
+[X11](../../README.md#x11), [GL](../../README.md#gl)
+
+## Prerequisites
+
+Download and install the [CUDA Toolkit 11.5](https://developer.nvidia.com/cuda-downloads) for your corresponding platform.
+Make sure the dependencies mentioned in [Dependencies]() section above are installed.
+
+## Build and Run
+
+### Windows
+The Windows samples are built using the Visual Studio IDE. Solution files (.sln) are provided for each supported version of Visual Studio, using the format:
+```
+*_vs<version>.sln - for Visual Studio <version>
+```
+Each individual sample has its own set of solution files in its directory:
+
+To build/examine all the samples at once, the complete solution files should be used. To build/examine a single sample, the individual sample solution files should be used.
+> **Note:** Some samples require that the Microsoft DirectX SDK (June 2010 or newer) be installed and that the VC++ directory paths are properly set up (**Tools > Options...**). Check DirectX Dependencies section for details."
+
+### Linux
+The Linux samples are built using makefiles. To use the makefiles, change the current directory to the sample directory you wish to build, and run make:
+```
+$ cd <sample_dir>
+$ make
+```
+The samples makefiles can take advantage of certain options:
+*  **TARGET_ARCH=<arch>** - cross-compile targeting a specific architecture. Allowed architectures are x86_64, armv7l.
+    By default, TARGET_ARCH is set to HOST_ARCH. On a x86_64 machine, not setting TARGET_ARCH is the equivalent of setting TARGET_ARCH=x86_64.<br/>
+`$ make TARGET_ARCH=x86_64` <br/> `$ make TARGET_ARCH=armv7l` <br/>
+    See [here](http://docs.nvidia.com/cuda/cuda-samples/index.html#cross-samples) for more details.
+*   **dbg=1** - build with debug symbols
+    ```
+    $ make dbg=1
+    ```
+*   **SMS="A B ..."** - override the SM architectures for which the sample will be built, where `"A B ..."` is a space-delimited list of SM architectures. For example, to generate SASS for SM 50 and SM 60, use `SMS="50 60"`.
+    ```
+    $ make SMS="50 60"
+    ```
+
+*  **HOST_COMPILER=<host_compiler>** - override the default g++ host compiler. See the [Linux Installation Guide](http://docs.nvidia.com/cuda/cuda-installation-guide-linux/index.html#system-requirements) for a list of supported host compilers.
+```
+    $ make HOST_COMPILER=g++
+```
+
+## References (for more details)
+
--- a/Samples/bilateralFilter/bilateralFilter.cpp
+++ b/Samples/bilateralFilter/bilateralFilter.cpp
@@ -0,0 +1,674 @@
+/* Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+  Image bilateral filtering example
+
+  This sample uses CUDA to perform a simple bilateral filter on an image
+  and uses OpenGL to display the results.
+
+  Bilateral filter is an edge-preserving nonlinear smoothing filter. There
+  are three parameters distribute to the filter: gaussian delta, euclidean
+  delta and iterations.
+
+  When the euclidean delta increases, most of the fine texture will be
+  filtered away, yet all contours are as crisp as in the original image.
+  If the euclidean delta approximates to ∞, the filter becomes a normal
+  gaussian filter. Fine texture will blur more with larger gaussian delta.
+  Multiple iterations have the effect of flattening the colors in an
+  image considerably, but without blurring edges, which produces a cartoon
+  effect.
+
+  To learn more details about this filter, please view C. Tomasi's "Bilateral
+  Filtering for Gray and Color Images".
+
+*/
+
+#include <math.h>
+
+// OpenGL Graphics includes
+#include <helper_gl.h>
+#if defined(__APPLE__) || defined(__MACOSX)
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#include <GLUT/glut.h>
+#ifndef glutCloseFunc
+#define glutCloseFunc glutWMCloseFunc
+#endif
+#else
+#include <GL/freeglut.h>
+#endif
+
+// CUDA utilities and system includes
+#include <cuda_runtime.h>
+#include <cuda_gl_interop.h>
+
+#include <helper_cuda.h>  // CUDA device initialization helper functions
+
+// Shared Library Test Functions
+#include <helper_functions.h>  // CUDA SDK Helper functions
+
+#define MAX_EPSILON_ERROR 5.0f
+#define REFRESH_DELAY 10  // ms
+#define MIN_EUCLIDEAN_D 0.01f
+#define MAX_EUCLIDEAN_D 5.f
+#define MAX_FILTER_RADIUS 25
+
+const static char *sSDKsample = "CUDA Bilateral Filter";
+
+const char *image_filename = "nature_monte.bmp";
+int iterations = 1;
+float gaussian_delta = 4;
+float euclidean_delta = 0.1f;
+int filter_radius = 5;
+
+unsigned int width, height;
+unsigned int *hImage = NULL;
+
+GLuint pbo;                                      // OpenGL pixel buffer object
+struct cudaGraphicsResource *cuda_pbo_resource;  // handles OpenGL-CUDA exchange
+GLuint texid;                                    // texture
+GLuint shader;
+
+int *pArgc = NULL;
+char **pArgv = NULL;
+
+StopWatchInterface *timer = NULL;
+StopWatchInterface *kernel_timer = NULL;
+
+// Auto-Verification Code
+const int frameCheckNumber = 4;
+int fpsCount = 0;  // FPS count for averaging
+int fpsLimit = 1;  // FPS limit for sampling
+unsigned int g_TotalErrors = 0;
+bool g_bInteractive = false;
+
+//#define GL_TEXTURE_TYPE GL_TEXTURE_RECTANGLE_ARB
+#define GL_TEXTURE_TYPE GL_TEXTURE_2D
+
+extern "C" void loadImageData(int argc, char **argv);
+
+// These are CUDA functions to handle allocation and launching the kernels
+extern "C" void initTexture(int width, int height, void *pImage);
+extern "C" void freeTextures();
+
+extern "C" double bilateralFilterRGBA(unsigned int *d_dest, int width,
+                                      int height, float e_d, int radius,
+                                      int iterations,
+                                      StopWatchInterface *timer);
+extern "C" void updateGaussian(float delta, int radius);
+extern "C" void updateGaussianGold(float delta, int radius);
+extern "C" void bilateralFilterGold(unsigned int *pSrc, unsigned int *pDest,
+                                    float e_d, int w, int h, int r);
+extern "C" void LoadBMPFile(uchar4 **dst, unsigned int *width,
+                            unsigned int *height, const char *name);
+
+void varyEuclidean() {
+  static float factor = 1.02f;
+
+  if (euclidean_delta > MAX_EUCLIDEAN_D) {
+    factor = 1 / 1.02f;
+  }
+
+  if (euclidean_delta < MIN_EUCLIDEAN_D) {
+    factor = 1.02f;
+  }
+
+  euclidean_delta *= factor;
+}
+
+void computeFPS() {
+  fpsCount++;
+
+  if (fpsCount == fpsLimit) {
+    char fps[256];
+    float ifps = 1.0f / (sdkGetAverageTimerValue(&timer) / 1000.0f);
+    sprintf(fps,
+            "CUDA Bilateral Filter: %3.f fps (radius=%d, iter=%d, "
+            "euclidean=%.2f, gaussian=%.2f)",
+            ifps, filter_radius, iterations, (double)euclidean_delta,
+            (double)gaussian_delta);
+
+    glutSetWindowTitle(fps);
+    fpsCount = 0;
+    fpsLimit = (int)MAX(ifps, 1.0f);
+
+    sdkResetTimer(&timer);
+  }
+
+  if (!g_bInteractive) {
+    varyEuclidean();
+  }
+}
+
+// display results using OpenGL
+void display() {
+  sdkStartTimer(&timer);
+
+  // execute filter, writing results to pbo
+  unsigned int *dResult;
+
+  checkCudaErrors(cudaGraphicsMapResources(1, &cuda_pbo_resource, 0));
+  size_t num_bytes;
+  checkCudaErrors(cudaGraphicsResourceGetMappedPointer(
+      (void **)&dResult, &num_bytes, cuda_pbo_resource));
+  bilateralFilterRGBA(dResult, width, height, euclidean_delta, filter_radius,
+                      iterations, kernel_timer);
+
+  checkCudaErrors(cudaGraphicsUnmapResources(1, &cuda_pbo_resource, 0));
+
+  // Common display code path
+  {
+    glClear(GL_COLOR_BUFFER_BIT);
+
+    // load texture from pbo
+    glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, pbo);
+    glBindTexture(GL_TEXTURE_2D, texid);
+    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, GL_RGBA,
+                    GL_UNSIGNED_BYTE, 0);
+    glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
+
+    // fragment program is required to display floating point texture
+    glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, shader);
+    glEnable(GL_FRAGMENT_PROGRAM_ARB);
+    glDisable(GL_DEPTH_TEST);
+
+    glBegin(GL_QUADS);
+    {
+      glTexCoord2f(0, 0);
+      glVertex2f(0, 0);
+      glTexCoord2f(1, 0);
+      glVertex2f(1, 0);
+      glTexCoord2f(1, 1);
+      glVertex2f(1, 1);
+      glTexCoord2f(0, 1);
+      glVertex2f(0, 1);
+    }
+    glEnd();
+    glBindTexture(GL_TEXTURE_TYPE, 0);
+    glDisable(GL_FRAGMENT_PROGRAM_ARB);
+  }
+
+  glutSwapBuffers();
+  glutReportErrors();
+
+  sdkStopTimer(&timer);
+
+  computeFPS();
+}
+
+/*
+    right arrow to increase the gaussian delta
+    left arrow to decrease the gaussian delta
+    up arrow to increase the euclidean delta
+    down arrow to decrease the euclidean delta
+*/
+void keyboard(unsigned char key, int /*x*/, int /*y*/) {
+  switch (key) {
+    case 27:
+#if defined(__APPLE__) || defined(MACOSX)
+      exit(EXIT_SUCCESS);
+#else
+      glutDestroyWindow(glutGetWindow());
+      return;
+#endif
+      break;
+
+    case 'a':
+    case 'A':
+      g_bInteractive = !g_bInteractive;
+      printf("> Animation is %s\n", !g_bInteractive ? "ON" : "OFF");
+      break;
+
+    case ']':
+      iterations++;
+      break;
+
+    case '[':
+      iterations--;
+
+      if (iterations < 1) {
+        iterations = 1;
+      }
+
+      break;
+
+    case '=':
+    case '+':
+      filter_radius++;
+
+      if (filter_radius > MAX_FILTER_RADIUS) {
+        filter_radius = MAX_FILTER_RADIUS;
+      }
+
+      updateGaussian(gaussian_delta, filter_radius);
+      break;
+
+    case '-':
+      filter_radius--;
+
+      if (filter_radius < 1) {
+        filter_radius = 1;
+      }
+
+      updateGaussian(gaussian_delta, filter_radius);
+      break;
+
+    case 'E':
+      euclidean_delta *= 1.5;
+      break;
+
+    case 'e':
+      euclidean_delta /= 1.5;
+      break;
+
+    case 'g':
+      if (gaussian_delta > 0.1) {
+        gaussian_delta /= 2;
+      }
+
+      // updateGaussianGold(gaussian_delta, filter_radius);
+      updateGaussian(gaussian_delta, filter_radius);
+      break;
+
+    case 'G':
+      gaussian_delta *= 2;
+      // updateGaussianGold(gaussian_delta, filter_radius);
+      updateGaussian(gaussian_delta, filter_radius);
+      break;
+
+    default:
+      break;
+  }
+
+  printf(
+      "filter radius = %d, iterations = %d, gaussian delta = %.2f, euclidean "
+      "delta = %.2f\n",
+      filter_radius, iterations, gaussian_delta, euclidean_delta);
+  glutPostRedisplay();
+}
+
+void timerEvent(int value) {
+  if (glutGetWindow()) {
+    glutPostRedisplay();
+    glutTimerFunc(REFRESH_DELAY, timerEvent, 0);
+  }
+}
+
+void reshape(int x, int y) {
+  glViewport(0, 0, x, y);
+
+  glMatrixMode(GL_MODELVIEW);
+  glLoadIdentity();
+
+  glMatrixMode(GL_PROJECTION);
+  glLoadIdentity();
+  glOrtho(0.0, 1.0, 0.0, 1.0, 0.0, 1.0);
+}
+
+void initCuda() {
+  // initialize gaussian mask
+  updateGaussian(gaussian_delta, filter_radius);
+
+  initTexture(width, height, hImage);
+  sdkCreateTimer(&timer);
+  sdkCreateTimer(&kernel_timer);
+}
+
+void cleanup() {
+  sdkDeleteTimer(&timer);
+  sdkDeleteTimer(&kernel_timer);
+
+  if (hImage) {
+    free(hImage);
+  }
+
+  freeTextures();
+
+  cudaGraphicsUnregisterResource(cuda_pbo_resource);
+
+  glDeleteBuffers(1, &pbo);
+  glDeleteTextures(1, &texid);
+  glDeleteProgramsARB(1, &shader);
+}
+
+// shader for displaying floating-point texture
+static const char *shader_code =
+    "!!ARBfp1.0\n"
+    "TEX result.color, fragment.texcoord, texture[0], 2D; \n"
+    "END";
+
+GLuint compileASMShader(GLenum program_type, const char *code) {
+  GLuint program_id;
+  glGenProgramsARB(1, &program_id);
+  glBindProgramARB(program_type, program_id);
+  glProgramStringARB(program_type, GL_PROGRAM_FORMAT_ASCII_ARB,
+                     (GLsizei)strlen(code), (GLubyte *)code);
+
+  GLint error_pos;
+  glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &error_pos);
+
+  if (error_pos != -1) {
+    const GLubyte *error_string;
+    error_string = glGetString(GL_PROGRAM_ERROR_STRING_ARB);
+    printf("Program error at position: %d\n%s\n", (int)error_pos, error_string);
+    return 0;
+  }
+
+  return program_id;
+}
+
+void initGLResources() {
+  // create pixel buffer object
+  glGenBuffers(1, &pbo);
+  glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, pbo);
+  glBufferData(GL_PIXEL_UNPACK_BUFFER_ARB, width * height * sizeof(GLubyte) * 4,
+               hImage, GL_STREAM_DRAW_ARB);
+
+  glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
+
+  checkCudaErrors(cudaGraphicsGLRegisterBuffer(
+      &cuda_pbo_resource, pbo, cudaGraphicsMapFlagsWriteDiscard));
+
+  // create texture for display
+  glGenTextures(1, &texid);
+  glBindTexture(GL_TEXTURE_2D, texid);
+  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_RGBA,
+               GL_UNSIGNED_BYTE, NULL);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+  glBindTexture(GL_TEXTURE_2D, 0);
+
+  // load shader program
+  shader = compileASMShader(GL_FRAGMENT_PROGRAM_ARB, shader_code);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//! Run a simple benchmark test for CUDA
+////////////////////////////////////////////////////////////////////////////////
+int runBenchmark(int argc, char **argv) {
+  printf("[runBenchmark]: [%s]\n", sSDKsample);
+
+  loadImageData(argc, argv);
+  initCuda();
+
+  unsigned int *dResult;
+  size_t pitch;
+  checkCudaErrors(cudaMallocPitch((void **)&dResult, &pitch,
+                                  width * sizeof(unsigned int), height));
+  sdkStartTimer(&kernel_timer);
+
+  // warm-up
+  bilateralFilterRGBA(dResult, width, height, euclidean_delta, filter_radius,
+                      iterations, kernel_timer);
+  checkCudaErrors(cudaDeviceSynchronize());
+
+  // Start round-trip timer and process iCycles loops on the GPU
+  iterations = 1;  // standard 1-pass filtering
+  const int iCycles = 150;
+  double dProcessingTime = 0.0;
+  printf("\nRunning BilateralFilterGPU for %d cycles...\n\n", iCycles);
+
+  for (int i = 0; i < iCycles; i++) {
+    dProcessingTime +=
+        bilateralFilterRGBA(dResult, width, height, euclidean_delta,
+                            filter_radius, iterations, kernel_timer);
+  }
+
+  // check if kernel execution generated an error and sync host
+  getLastCudaError("Error: bilateralFilterRGBA Kernel execution FAILED");
+  checkCudaErrors(cudaDeviceSynchronize());
+  sdkStopTimer(&kernel_timer);
+
+  // Get average computation time
+  dProcessingTime /= (double)iCycles;
+
+  // log testname, throughput, timing and config info to sample and master logs
+  printf(
+      "bilateralFilter-texture, Throughput = %.4f M RGBA Pixels/s, Time = %.5f "
+      "s, Size = %u RGBA Pixels, NumDevsUsed = %u\n",
+      (1.0e-6 * width * height) / dProcessingTime, dProcessingTime,
+      (width * height), 1);
+  printf("\n");
+
+  return 0;
+}
+
+void initGL(int argc, char **argv) {
+  // initialize GLUT
+  glutInit(&argc, argv);
+  glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
+  glutInitWindowSize(width, height);
+
+  glutCreateWindow("CUDA Bilateral Filter");
+  glutDisplayFunc(display);
+
+  glutKeyboardFunc(keyboard);
+  glutReshapeFunc(reshape);
+  // glutIdleFunc(idle);
+  glutTimerFunc(REFRESH_DELAY, timerEvent, 0);
+
+  if (!isGLVersionSupported(2, 0) ||
+      !areGLExtensionsSupported(
+          "GL_ARB_vertex_buffer_object GL_ARB_pixel_buffer_object")) {
+    printf("Error: failed to get minimal extensions for demo\n");
+    printf("This sample requires:\n");
+    printf("  OpenGL version 2.0\n");
+    printf("  GL_ARB_vertex_buffer_object\n");
+    printf("  GL_ARB_pixel_buffer_object\n");
+    exit(EXIT_FAILURE);
+  }
+}
+
+// This test specifies a single test (where you specify radius and/or
+// iterations)
+int runSingleTest(char *ref_file, char *exec_path) {
+  int nTotalErrors = 0;
+  char dump_file[256];
+
+  printf("[runSingleTest]: [%s]\n", sSDKsample);
+
+  initCuda();
+
+  unsigned int *dResult;
+  unsigned int *hResult =
+      (unsigned int *)malloc(width * height * sizeof(unsigned int));
+  size_t pitch;
+  checkCudaErrors(cudaMallocPitch((void **)&dResult, &pitch,
+                                  width * sizeof(unsigned int), height));
+
+  // run the sample radius
+  {
+    printf("%s (radius=%d) (passes=%d) ", sSDKsample, filter_radius,
+           iterations);
+    bilateralFilterRGBA(dResult, width, height, euclidean_delta, filter_radius,
+                        iterations, kernel_timer);
+
+    // check if kernel execution generated an error
+    getLastCudaError("Error: bilateralFilterRGBA Kernel execution FAILED");
+    checkCudaErrors(cudaDeviceSynchronize());
+
+    // readback the results to system memory
+    cudaMemcpy2D(hResult, sizeof(unsigned int) * width, dResult, pitch,
+                 sizeof(unsigned int) * width, height, cudaMemcpyDeviceToHost);
+
+    sprintf(dump_file, "nature_%02d.ppm", filter_radius);
+
+    sdkSavePPM4ub((const char *)dump_file, (unsigned char *)hResult, width,
+                  height);
+
+    if (!sdkComparePPM(dump_file, sdkFindFilePath(ref_file, exec_path),
+                       MAX_EPSILON_ERROR, 0.15f, false)) {
+      printf("Image is Different ");
+      nTotalErrors++;
+    } else {
+      printf("Image is Matching ");
+    }
+
+    printf(" <%s>\n", ref_file);
+  }
+  printf("\n");
+
+  free(hResult);
+  checkCudaErrors(cudaFree(dResult));
+  freeTextures();
+
+  return nTotalErrors;
+}
+
+void loadImageData(int argc, char **argv) {
+  // load image (needed so we can get the width and height before we create the
+  // window
+  char *image_path = NULL;
+
+  if (argc >= 1) {
+    image_path = sdkFindFilePath(image_filename, argv[0]);
+  }
+
+  if (image_path == NULL) {
+    fprintf(stderr, "Error finding image file '%s'\n", image_filename);
+    exit(EXIT_FAILURE);
+  }
+
+  LoadBMPFile((uchar4 **)&hImage, &width, &height, image_path);
+
+  if (!hImage) {
+    fprintf(stderr, "Error opening file '%s'\n", image_path);
+    exit(EXIT_FAILURE);
+  }
+
+  printf("Loaded '%s', %d x %d pixels\n\n", image_path, width, height);
+}
+
+bool checkCUDAProfile(int dev, int min_runtime, int min_compute) {
+  int runtimeVersion = 0;
+
+  cudaDeviceProp deviceProp;
+  cudaGetDeviceProperties(&deviceProp, dev);
+
+  fprintf(stderr, "\nDevice %d: \"%s\"\n", dev, deviceProp.name);
+  cudaRuntimeGetVersion(&runtimeVersion);
+  fprintf(stderr, "  CUDA Runtime Version     :\t%d.%d\n",
+          runtimeVersion / 1000, (runtimeVersion % 100) / 10);
+  fprintf(stderr, "  CUDA Compute Capability  :\t%d.%d\n", deviceProp.major,
+          deviceProp.minor);
+
+  if (runtimeVersion >= min_runtime &&
+      ((deviceProp.major << 4) + deviceProp.minor) >= min_compute) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+void printHelp() {
+  printf("bilateralFilter usage\n");
+  printf("    -radius=n  (specify the filter radius n to use)\n");
+  printf("    -passes=n  (specify the number of passes n to use)\n");
+  printf("    -file=name (specify reference file for comparison)\n");
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Program main
+////////////////////////////////////////////////////////////////////////////////
+int main(int argc, char **argv) {
+  // start logs
+  int devID;
+  char *ref_file = NULL;
+  printf("%s Starting...\n\n", argv[0]);
+
+#if defined(__linux__)
+  setenv("DISPLAY", ":0", 0);
+#endif
+
+  // use command-line specified CUDA device, otherwise use device with highest
+  // Gflops/s
+  if (argc > 1) {
+    if (checkCmdLineFlag(argc, (const char **)argv, "radius")) {
+      filter_radius =
+          getCmdLineArgumentInt(argc, (const char **)argv, "radius");
+    }
+
+    if (checkCmdLineFlag(argc, (const char **)argv, "passes")) {
+      iterations = getCmdLineArgumentInt(argc, (const char **)argv, "passes");
+    }
+
+    if (checkCmdLineFlag(argc, (const char **)argv, "file")) {
+      getCmdLineArgumentString(argc, (const char **)argv, "file",
+                               (char **)&ref_file);
+    }
+  }
+
+  // load image to process
+  loadImageData(argc, argv);
+  devID = findCudaDevice(argc, (const char **)argv);
+
+  if (checkCmdLineFlag(argc, (const char **)argv, "benchmark")) {
+    // This is a separate mode of the sample, where we are benchmark the kernels
+    // for performance
+    // Running CUDA kernels (bilateralfilter) in Benchmarking mode
+    g_TotalErrors += runBenchmark(argc, argv);
+
+    exit(g_TotalErrors == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
+  } else if (checkCmdLineFlag(argc, (const char **)argv, "radius") ||
+             checkCmdLineFlag(argc, (const char **)argv, "passes")) {
+    // This overrides the default mode.  Users can specify the radius used by
+    // the filter kernel
+    g_TotalErrors += runSingleTest(ref_file, argv[0]);
+
+    exit(g_TotalErrors == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
+  } else {
+    // Default mode running with OpenGL visualization and in automatic mode
+    // the output automatically changes animation
+    printf("\n");
+
+    // First initialize OpenGL context, so we can properly set the GL for CUDA.
+    // This is necessary in order to achieve optimal performance with
+    // OpenGL/CUDA interop.
+    initGL(argc, (char **)argv);
+
+    initCuda();
+    initGLResources();
+
+// sets the callback function so it will call cleanup upon exit
+#if defined(__APPLE__) || defined(MACOSX)
+    atexit(cleanup);
+#else
+    glutCloseFunc(cleanup);
+#endif
+
+    printf("Running Standard Demonstration with GLUT loop...\n\n");
+    printf(
+        "Press '+' and '-' to change filter width\n"
+        "Press ']' and '[' to change number of iterations\n"
+        "Press 'e' and 'E' to change Euclidean delta\n"
+        "Press 'g' and 'G' to change Gaussian delta\n"
+        "Press 'a' or  'A' to change Animation mode ON/OFF\n\n");
+
+    // Main OpenGL loop that will run visualization for every vsync
+    glutMainLoop();
+  }
+}
--- a/Samples/bilateralFilter/bilateralFilter_cpu.cpp
+++ b/Samples/bilateralFilter/bilateralFilter_cpu.cpp
@@ -0,0 +1,153 @@
+/* Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <math.h>
+#include <string.h>
+
+////////////////////////////////////////////////////////////////////////////////
+// export C interface
+#define EPSILON 1e-3
+extern "C" void updateGaussianGold(float delta, int radius);
+extern "C" void bilateralFilterGold(unsigned int *pSrc, unsigned int *pDest,
+                                    float e_d, int w, int h, int r);
+// variables
+float gaussian[50];
+
+struct float4 {
+  float x;
+  float y;
+  float z;
+  float w;
+
+  float4(){};
+  float4(float value) { x = y = z = w = value; }
+};
+
+void updateGaussianGold(float delta, int radius) {
+  for (int i = 0; i < 2 * radius + 1; i++) {
+    int x = i - radius;
+    gaussian[i] = expf(-(x * x) / (2 * delta * delta));
+  }
+}
+
+float heuclideanLen(float4 a, float4 b, float d) {
+  float mod = (b.x - a.x) * (b.x - a.x) + (b.y - a.y) * (b.y - a.y) +
+              (b.z - a.z) * (b.z - a.z) + (b.w - a.w) * (b.w - a.w);
+
+  return expf(-mod / (2 * d * d));
+}
+
+unsigned int hrgbaFloatToInt(float4 rgba) {
+  unsigned int w = (((unsigned int)(fabs(rgba.w) * 255.0f)) & 0xff) << 24;
+  unsigned int z = (((unsigned int)(fabs(rgba.z) * 255.0f)) & 0xff) << 16;
+  unsigned int y = (((unsigned int)(fabs(rgba.y) * 255.0f)) & 0xff) << 8;
+  unsigned int x = ((unsigned int)(fabs(rgba.x) * 255.0f)) & 0xff;
+
+  return (w | z | y | x);
+}
+
+float4 hrgbaIntToFloat(unsigned int c) {
+  float4 rgba;
+  rgba.x = (c & 0xff) * 0.003921568627f;          //  /255.0f;
+  rgba.y = ((c >> 8) & 0xff) * 0.003921568627f;   //  /255.0f;
+  rgba.z = ((c >> 16) & 0xff) * 0.003921568627f;  //  /255.0f;
+  rgba.w = ((c >> 24) & 0xff) * 0.003921568627f;  //  /255.0f;
+  return rgba;
+}
+
+float4 mul(float a, float4 b) {
+  float4 ans;
+  ans.x = a * b.x;
+  ans.y = a * b.y;
+  ans.z = a * b.z;
+  ans.w = a * b.w;
+
+  return ans;
+}
+
+float4 add4(float4 a, float4 b) {
+  float4 ans;
+  ans.x = a.x + b.x;
+  ans.y = a.y + b.y;
+  ans.z = a.z + b.z;
+  ans.w = a.w + b.w;
+
+  return ans;
+}
+
+void bilateralFilterGold(unsigned int *pSrc, unsigned int *pDest, float e_d,
+                         int w, int h, int r) {
+  float4 *hImage = new float4[w * h];
+  float domainDist, colorDist, factor;
+
+  for (int y = 0; y < h; y++) {
+    for (int x = 0; x < w; x++) {
+      hImage[y * w + x] = hrgbaIntToFloat(pSrc[y * w + x]);
+    }
+  }
+
+  for (int y = 0; y < h; y++) {
+    for (int x = 0; x < w; x++) {
+      float4 t(0.0f);
+      float sum = 0.0f;
+
+      for (int i = -r; i <= r; i++) {
+        int neighborY = y + i;
+
+        // clamp the neighbor pixel, prevent overflow
+        if (neighborY < 0) {
+          neighborY = 0;
+        } else if (neighborY >= h) {
+          neighborY = h - 1;
+        }
+
+        for (int j = -r; j <= r; j++) {
+          domainDist = gaussian[r + i] * gaussian[r + j];
+
+          // clamp the neighbor pixel, prevent overflow
+          int neighborX = x + j;
+
+          if (neighborX < 0) {
+            neighborX = 0;
+          } else if (neighborX >= w) {
+            neighborX = w - 1;
+          }
+
+          colorDist = heuclideanLen(hImage[neighborY * w + neighborX],
+                                    hImage[y * w + x], e_d);
+          factor = domainDist * colorDist;
+          sum += factor;
+          t = add4(t, mul(factor, hImage[neighborY * w + neighborX]));
+        }
+      }
+
+      pDest[y * w + x] = hrgbaFloatToInt(mul(1 / sum, t));
+    }
+  }
+
+  delete[] hImage;
+}
--- a/Samples/bilateralFilter/bilateralFilter_vs2017.sln
+++ b/Samples/bilateralFilter/bilateralFilter_vs2017.sln
@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2017
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "bilateralFilter", "bilateralFilter_vs2017.vcxproj", "{997E0757-EA74-4A4E-A0FC-47D8C8831A15}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.ActiveCfg = Debug|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.Build.0 = Debug|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.ActiveCfg = Release|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.Build.0 = Release|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal
--- a/Samples/bilateralFilter/bilateralFilter_vs2017.vcxproj
+++ b/Samples/bilateralFilter/bilateralFilter_vs2017.vcxproj
@@ -0,0 +1,126 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <CUDAPropsPath Condition="'$(CUDAPropsPath)'==''">$(VCTargetsPath)\BuildCustomizations</CUDAPropsPath>
+  </PropertyGroup>
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{997E0757-EA74-4A4E-A0FC-47D8C8831A15}</ProjectGuid>
+    <RootNamespace>bilateralFilter_vs2017</RootNamespace>
+    <ProjectName>bilateralFilter</ProjectName>
+    <CudaToolkitCustomDir />
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(WindowsTargetPlatformVersion)'==''">
+    <LatestTargetPlatformVersion>$([Microsoft.Build.Utilities.ToolLocationHelper]::GetLatestSDKTargetPlatformVersion('Windows', '10.0'))</LatestTargetPlatformVersion>
+    <WindowsTargetPlatformVersion Condition="'$(WindowsTargetPlatformVersion)' == ''">$(LatestTargetPlatformVersion)</WindowsTargetPlatformVersion>
+    <TargetPlatformVersion>$(WindowsTargetPlatformVersion)</TargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup>
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>MultiByte</CharacterSet>
+    <PlatformToolset>v141</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Debug'">
+    <UseDebugLibraries>true</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Release'">
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.5.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <IntDir>$(Platform)/$(Configuration)/</IntDir>
+    <IncludePath>$(IncludePath)</IncludePath>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules />
+    <CodeAnalysisRuleAssemblies />
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Platform)'=='x64'">
+    <OutDir>../../bin/win64/$(Configuration)/</OutDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;_MBCS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>./;$(CudaToolkitDir)/include;../../Common;</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <AdditionalDependencies>cudart_static.lib;freeglut.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(CudaToolkitLibDir);../../Common/lib/$(PlatformName);</AdditionalLibraryDirectories>
+      <OutputFile>$(OutDir)/bilateralFilter.exe</OutputFile>
+    </Link>
+    <CudaCompile>
+      <CodeGeneration>compute_35,sm_35;compute_37,sm_37;compute_50,sm_50;compute_52,sm_52;compute_60,sm_60;compute_61,sm_61;compute_70,sm_70;compute_75,sm_75;compute_80,sm_80;compute_86,sm_86;</CodeGeneration>
+      <AdditionalOptions>-Xcompiler "/wd 4819" %(AdditionalOptions)</AdditionalOptions>
+      <Include>./;../../Common</Include>
+      <Defines>WIN32</Defines>
+      <AdditionalOptions>--threads 0</AdditionalOptions>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
+    <ClCompile>
+      <Optimization>Disabled</Optimization>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MTd</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
+    <ClCompile>
+      <Optimization>MaxSpeed</Optimization>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>false</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MT</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Platform)'=='Win32'">
+    <Link>
+      
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Platform)'=='x64'">
+    <Link>
+      <AdditionalDependencies>glew64.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="bilateralFilter.cpp" />
+    <ClCompile Include="bilateralFilter_cpu.cpp" />
+    <CudaCompile Include="bilateral_kernel.cu" />
+    <ClCompile Include="bmploader.cpp" />
+
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.5.targets" />
+  </ImportGroup>
+</Project>
--- a/Samples/bilateralFilter/bilateralFilter_vs2019.sln
+++ b/Samples/bilateralFilter/bilateralFilter_vs2019.sln
@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2019
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "bilateralFilter", "bilateralFilter_vs2019.vcxproj", "{997E0757-EA74-4A4E-A0FC-47D8C8831A15}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.ActiveCfg = Debug|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.Build.0 = Debug|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.ActiveCfg = Release|x64
+		{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.Build.0 = Release|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal
--- a/Samples/bilateralFilter/bilateralFilter_vs2019.vcxproj
+++ b/Samples/bilateralFilter/bilateralFilter_vs2019.vcxproj
@@ -0,0 +1,122 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <CUDAPropsPath Condition="'$(CUDAPropsPath)'==''">$(VCTargetsPath)\BuildCustomizations</CUDAPropsPath>
+  </PropertyGroup>
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{997E0757-EA74-4A4E-A0FC-47D8C8831A15}</ProjectGuid>
+    <RootNamespace>bilateralFilter_vs2019</RootNamespace>
+    <ProjectName>bilateralFilter</ProjectName>
+    <CudaToolkitCustomDir />
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup>
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>MultiByte</CharacterSet>
+    <PlatformToolset>v142</PlatformToolset>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Debug'">
+    <UseDebugLibraries>true</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Release'">
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.5.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <IntDir>$(Platform)/$(Configuration)/</IntDir>
+    <IncludePath>$(IncludePath)</IncludePath>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules />
+    <CodeAnalysisRuleAssemblies />
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Platform)'=='x64'">
+    <OutDir>../../bin/win64/$(Configuration)/</OutDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;_MBCS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>./;$(CudaToolkitDir)/include;../../Common;</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <AdditionalDependencies>cudart_static.lib;freeglut.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(CudaToolkitLibDir);../../Common/lib/$(PlatformName);</AdditionalLibraryDirectories>
+      <OutputFile>$(OutDir)/bilateralFilter.exe</OutputFile>
+    </Link>
+    <CudaCompile>
+      <CodeGeneration>compute_35,sm_35;compute_37,sm_37;compute_50,sm_50;compute_52,sm_52;compute_60,sm_60;compute_61,sm_61;compute_70,sm_70;compute_75,sm_75;compute_80,sm_80;compute_86,sm_86;</CodeGeneration>
+      <AdditionalOptions>-Xcompiler "/wd 4819" %(AdditionalOptions)</AdditionalOptions>
+      <Include>./;../../Common</Include>
+      <Defines>WIN32</Defines>
+      <AdditionalOptions>--threads 0</AdditionalOptions>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
+    <ClCompile>
+      <Optimization>Disabled</Optimization>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MTd</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
+    <ClCompile>
+      <Optimization>MaxSpeed</Optimization>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>false</GenerateDebugInformation>
+      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
+    </Link>
+    <CudaCompile>
+      <Runtime>MT</Runtime>
+      <TargetMachinePlatform>64</TargetMachinePlatform>
+    </CudaCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Platform)'=='Win32'">
+    <Link>
+      
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Platform)'=='x64'">
+    <Link>
+      <AdditionalDependencies>glew64.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="bilateralFilter.cpp" />
+    <ClCompile Include="bilateralFilter_cpu.cpp" />
+    <CudaCompile Include="bilateral_kernel.cu" />
+    <ClCompile Include="bmploader.cpp" />
+
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="$(CUDAPropsPath)\CUDA 11.5.targets" />
+  </ImportGroup>
+</Project>
--- a/Samples/bilateralFilter/bilateral_kernel.cu
+++ b/Samples/bilateralFilter/bilateral_kernel.cu
@@ -0,0 +1,261 @@
+/* Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <helper_math.h>
+#include <helper_functions.h>
+#include <helper_cuda.h>  // CUDA device initialization helper functions
+
+__constant__ float cGaussian[64];  // gaussian array in device side
+
+cudaTextureObject_t rgbaTexdImage;
+cudaTextureObject_t rgbaTexdTemp;
+
+uint *dImage = NULL;  // original image
+uint *dTemp = NULL;  // temp array for iterations
+size_t pitch;
+
+/*
+    Perform a simple bilateral filter.
+
+    Bilateral filter is a nonlinear filter that is a mixture of range
+    filter and domain filter, the previous one preserves crisp edges and
+    the latter one filters noise. The intensity value at each pixel in
+    an image is replaced by a weighted average of intensity values from
+    nearby pixels.
+
+    The weight factor is calculated by the product of domain filter
+    component(using the gaussian distribution as a spatial distance) as
+    well as range filter component(Euclidean distance between center pixel
+    and the current neighbor pixel). Because this process is nonlinear,
+    the sample just uses a simple pixel by pixel step.
+
+    Texture fetches automatically clamp to edge of image. 1D gaussian array
+    is mapped to a 1D texture instead of using shared memory, which may
+    cause severe bank conflict.
+
+    Threads are y-pass(column-pass), because the output is coalesced.
+
+    Parameters
+    od - pointer to output data in global memory
+    d_f - pointer to the 1D gaussian array
+    e_d - euclidean delta
+    w  - image width
+    h  - image height
+    r  - filter radius
+*/
+
+// Euclidean Distance (x, y, d) = exp((|x - y| / d)^2 / 2)
+__device__ float euclideanLen(float4 a, float4 b, float d) {
+  float mod = (b.x - a.x) * (b.x - a.x) + (b.y - a.y) * (b.y - a.y) +
+              (b.z - a.z) * (b.z - a.z);
+
+  return __expf(-mod / (2.f * d * d));
+}
+
+__device__ uint rgbaFloatToInt(float4 rgba) {
+  rgba.x = __saturatef(fabs(rgba.x));  // clamp to [0.0, 1.0]
+  rgba.y = __saturatef(fabs(rgba.y));
+  rgba.z = __saturatef(fabs(rgba.z));
+  rgba.w = __saturatef(fabs(rgba.w));
+  return (uint(rgba.w * 255.0f) << 24) | (uint(rgba.z * 255.0f) << 16) |
+         (uint(rgba.y * 255.0f) << 8) | uint(rgba.x * 255.0f);
+}
+
+__device__ float4 rgbaIntToFloat(uint c) {
+  float4 rgba;
+  rgba.x = (c & 0xff) * 0.003921568627f;          //  /255.0f;
+  rgba.y = ((c >> 8) & 0xff) * 0.003921568627f;   //  /255.0f;
+  rgba.z = ((c >> 16) & 0xff) * 0.003921568627f;  //  /255.0f;
+  rgba.w = ((c >> 24) & 0xff) * 0.003921568627f;  //  /255.0f;
+  return rgba;
+}
+
+// column pass using coalesced global memory reads
+__global__ void d_bilateral_filter(uint *od, int w, int h, float e_d, int r,
+                                   cudaTextureObject_t rgbaTex) {
+  int x = blockIdx.x * blockDim.x + threadIdx.x;
+  int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+  if (x >= w || y >= h) {
+    return;
+  }
+
+  float sum = 0.0f;
+  float factor;
+  float4 t = {0.f, 0.f, 0.f, 0.f};
+  float4 center = tex2D<float4>(rgbaTex, x, y);
+
+  for (int i = -r; i <= r; i++) {
+    for (int j = -r; j <= r; j++) {
+      float4 curPix = tex2D<float4>(rgbaTex, x + j, y + i);
+      factor = cGaussian[i + r] * cGaussian[j + r] *  // domain factor
+               euclideanLen(curPix, center, e_d);  // range factor
+
+      t += factor * curPix;
+      sum += factor;
+    }
+  }
+
+  od[y * w + x] = rgbaFloatToInt(t / sum);
+}
+
+extern "C" void initTexture(int width, int height, uint *hImage) {
+  // copy image data to array
+  checkCudaErrors(
+      cudaMallocPitch(&dImage, &pitch, sizeof(uint) * width, height));
+  checkCudaErrors(
+      cudaMallocPitch(&dTemp, &pitch, sizeof(uint) * width, height));
+  checkCudaErrors(cudaMemcpy2D(dImage, pitch, hImage, sizeof(uint) * width,
+                               sizeof(uint) * width, height,
+                               cudaMemcpyHostToDevice));
+
+  // texture<uchar4, 2, cudaReadModeNormalizedFloat> rgbaTex;
+  cudaChannelFormatDesc desc = cudaCreateChannelDesc<uchar4>();
+  cudaResourceDesc texRes;
+  memset(&texRes, 0, sizeof(cudaResourceDesc));
+
+  texRes.resType = cudaResourceTypePitch2D;
+  texRes.res.pitch2D.devPtr = dImage;
+  texRes.res.pitch2D.desc = desc;
+  texRes.res.pitch2D.width = width;
+  texRes.res.pitch2D.height = height;
+  texRes.res.pitch2D.pitchInBytes = pitch;
+  cudaTextureDesc texDescr;
+  memset(&texDescr, 0, sizeof(cudaTextureDesc));
+
+  texDescr.normalizedCoords = false;
+  texDescr.filterMode = cudaFilterModePoint;
+  texDescr.addressMode[0] = cudaAddressModeWrap;
+  texDescr.addressMode[1] = cudaAddressModeWrap;
+  texDescr.readMode = cudaReadModeNormalizedFloat;
+
+  checkCudaErrors(
+      cudaCreateTextureObject(&rgbaTexdImage, &texRes, &texDescr, NULL));
+
+  memset(&texRes, 0, sizeof(cudaResourceDesc));
+
+  texRes.resType = cudaResourceTypePitch2D;
+  texRes.res.pitch2D.devPtr = dTemp;
+  texRes.res.pitch2D.desc = desc;
+  texRes.res.pitch2D.width = width;
+  texRes.res.pitch2D.height = height;
+  texRes.res.pitch2D.pitchInBytes = pitch;
+  memset(&texDescr, 0, sizeof(cudaTextureDesc));
+
+  texDescr.normalizedCoords = false;
+  texDescr.filterMode = cudaFilterModeLinear;
+  texDescr.addressMode[0] = cudaAddressModeWrap;
+  texDescr.addressMode[1] = cudaAddressModeWrap;
+  texDescr.readMode = cudaReadModeNormalizedFloat;
+
+  checkCudaErrors(
+      cudaCreateTextureObject(&rgbaTexdTemp, &texRes, &texDescr, NULL));
+}
+
+extern "C" void freeTextures() {
+  checkCudaErrors(cudaDestroyTextureObject(rgbaTexdImage));
+  checkCudaErrors(cudaDestroyTextureObject(rgbaTexdTemp));
+  checkCudaErrors(cudaFree(dImage));
+  checkCudaErrors(cudaFree(dTemp));
+}
+
+/*
+    Because a 2D gaussian mask is symmetry in row and column,
+    here only generate a 1D mask, and use the product by row
+    and column index later.
+
+    1D gaussian distribution :
+        g(x, d) -- C * exp(-x^2/d^2), C is a constant amplifier
+
+    parameters:
+    og - output gaussian array in global memory
+    delta - the 2nd parameter 'd' in the above function
+    radius - half of the filter size
+             (total filter size = 2 * radius + 1)
+*/
+extern "C" void updateGaussian(float delta, int radius) {
+  float fGaussian[64];
+
+  for (int i = 0; i < 2 * radius + 1; ++i) {
+    float x = (float)(i - radius);
+    fGaussian[i] = expf(-(x * x) / (2 * delta * delta));
+  }
+
+  checkCudaErrors(cudaMemcpyToSymbol(cGaussian, fGaussian,
+                                     sizeof(float) * (2 * radius + 1)));
+}
+
+/*
+    Perform 2D bilateral filter on image using CUDA
+
+    Parameters:
+    d_dest - pointer to destination image in device memory
+    width  - image width
+    height - image height
+    e_d    - euclidean delta
+    radius - filter radius
+    iterations - number of iterations
+*/
+
+// RGBA version
+extern "C" double bilateralFilterRGBA(uint *dDest, int width, int height,
+                                      float e_d, int radius, int iterations,
+                                      StopWatchInterface *timer) {
+  // var for kernel computation timing
+  double dKernelTime;
+
+  for (int i = 0; i < iterations; i++) {
+    // sync host and start kernel computation timer
+    dKernelTime = 0.0;
+    checkCudaErrors(cudaDeviceSynchronize());
+    sdkResetTimer(&timer);
+
+    dim3 gridSize((width + 16 - 1) / 16, (height + 16 - 1) / 16);
+    dim3 blockSize(16, 16);
+
+    if (iterations > 1) {
+      d_bilateral_filter<<<gridSize, blockSize>>>(dDest, width, height, e_d,
+                                                  radius, rgbaTexdTemp);
+    } else {
+      d_bilateral_filter<<<gridSize, blockSize>>>(dDest, width, height, e_d,
+                                                  radius, rgbaTexdImage);
+    }
+
+    // sync host and stop computation timer
+    checkCudaErrors(cudaDeviceSynchronize());
+    dKernelTime += sdkGetTimerValue(&timer);
+
+    if (iterations > 1) {
+      // copy result back from global memory to array
+      checkCudaErrors(cudaMemcpy2D(dTemp, pitch, dDest, sizeof(int) * width,
+                                   sizeof(int) * width, height,
+                                   cudaMemcpyDeviceToDevice));
+    }
+  }
+
+  return ((dKernelTime / 1000.) / (double)iterations);
+}
--- a/Samples/bilateralFilter/bmploader.cpp
+++ b/Samples/bilateralFilter/bmploader.cpp
@@ -0,0 +1,132 @@
+/* Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
+#pragma warning(disable : 4996)  // disable deprecated warning
+#endif
+
+#pragma pack(1)
+
+typedef struct {
+  short type;
+  int size;
+  short reserved1;
+  short reserved2;
+  int offset;
+} BMPHeader;
+
+typedef struct {
+  int size;
+  int width;
+  int height;
+  short planes;
+  short bitsPerPixel;
+  unsigned compression;
+  unsigned imageSize;
+  int xPelsPerMeter;
+  int yPelsPerMeter;
+  int clrUsed;
+  int clrImportant;
+} BMPInfoHeader;
+
+// Isolated definition
+typedef struct { unsigned char x, y, z, w; } uchar4;
+
+extern "C" void LoadBMPFile(uchar4 **dst, unsigned int *width,
+                            unsigned int *height, const char *name) {
+  BMPHeader hdr;
+  BMPInfoHeader infoHdr;
+  int x, y;
+
+  FILE *fd;
+
+  printf("Loading %s...\n", name);
+
+  if (sizeof(uchar4) != 4) {
+    printf("***Bad uchar4 size***\n");
+    exit(EXIT_SUCCESS);
+  }
+
+  if (!(fd = fopen(name, "rb"))) {
+    printf("***BMP load error: file access denied***\n");
+    exit(EXIT_SUCCESS);
+  }
+
+  fread(&hdr, sizeof(hdr), 1, fd);
+
+  if (hdr.type != 0x4D42) {
+    printf("***BMP load error: bad file format***\n");
+    exit(EXIT_SUCCESS);
+  }
+
+  fread(&infoHdr, sizeof(infoHdr), 1, fd);
+
+  if (infoHdr.bitsPerPixel != 24) {
+    printf("***BMP load error: invalid color depth***\n");
+    exit(EXIT_SUCCESS);
+  }
+
+  if (infoHdr.compression) {
+    printf("***BMP load error: compressed image***\n");
+    exit(EXIT_SUCCESS);
+  }
+
+  *width = infoHdr.width;
+  *height = infoHdr.height;
+  *dst = (uchar4 *)malloc(*width * *height * 4);
+
+  printf("BMP width: %u\n", infoHdr.width);
+  printf("BMP height: %u\n", infoHdr.height);
+
+  fseek(fd, hdr.offset - sizeof(hdr) - sizeof(infoHdr), SEEK_CUR);
+
+  for (y = 0; y < infoHdr.height; y++) {
+    for (x = 0; x < infoHdr.width; x++) {
+      (*dst)[(y * infoHdr.width + x)].w = 0;
+      (*dst)[(y * infoHdr.width + x)].z = fgetc(fd);
+      (*dst)[(y * infoHdr.width + x)].y = fgetc(fd);
+      (*dst)[(y * infoHdr.width + x)].x = fgetc(fd);
+    }
+
+    for (x = 0; x < (4 - (3 * infoHdr.width) % 4) % 4; x++) {
+      fgetc(fd);
+    }
+  }
+
+  if (ferror(fd)) {
+    printf("***Unknown BMP load error.***\n");
+    free(*dst);
+    exit(EXIT_SUCCESS);
+  } else {
+    printf("BMP file loaded successfully!\n");
+  }
+
+  fclose(fd);
+}
--- a/Samples/bilateralFilter/data/nature_monte.bmp
+++ b/Samples/bilateralFilter/data/nature_monte.bmp
--- a/Samples/bilateralFilter/data/ref_05.ppm
+++ b/Samples/bilateralFilter/data/ref_05.ppm
--- a/Samples/bilateralFilter/data/ref_06.ppm
+++ b/Samples/bilateralFilter/data/ref_06.ppm
--- a/Samples/bilateralFilter/data/ref_07.ppm
+++ b/Samples/bilateralFilter/data/ref_07.ppm
--- a/Samples/bilateralFilter/data/ref_08.ppm
+++ b/Samples/bilateralFilter/data/ref_08.ppm
--- a/Samples/bilateralFilter/findgllib.mk
+++ b/Samples/bilateralFilter/findgllib.mk
@@ -0,0 +1,145 @@
+################################################################################
+# Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#  * Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+#  * Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in the
+#    documentation and/or other materials provided with the distribution.
+#  * Neither the name of NVIDIA CORPORATION nor the names of its
+#    contributors may be used to endorse or promote products derived
+#    from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+# OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+################################################################################
+#
+#  findgllib.mk is used to find the necessary GL Libraries for specific distributions
+#               this is supported on Mac OSX and Linux Platforms
+#
+################################################################################
+
+# Determine OS platform and unix distribution
+ifeq ("$(TARGET_OS)","linux")
+   # first search lsb_release
+   DISTRO  := $(shell lsb_release -i -s 2>/dev/null | tr "[:upper:]" "[:lower:]")
+   ifeq ("$(DISTRO)","")
+     # second search and parse /etc/issue
+     DISTRO := $(shell awk '{print $$1}' /etc/issue | tr -d "[:space:]" | sed -e "/^$$/d" | tr "[:upper:]" "[:lower:]")
+     # ensure data from /etc/issue is valid
+     ifeq (,$(filter $(DISTRO),ubuntu fedora red rhel centos suse))
+       DISTRO := 
+     endif
+     ifeq ("$(DISTRO)","")
+       # third, we can search in /etc/os-release or /etc/{distro}-release
+       DISTRO := $(shell awk '/ID/' /etc/*-release | sed 's/ID=//' | grep -v "VERSION" | grep -v "ID" | grep -v "DISTRIB")
+     endif
+   endif
+endif
+
+ifeq ("$(TARGET_OS)","linux")
+    # $(info) >> findgllib.mk -> LINUX path <<<)
+    # Each set of Linux Distros have different paths for where to find their OpenGL libraries reside
+    UBUNTU = $(shell echo $(DISTRO) | grep -i ubuntu      >/dev/null 2>&1; echo $$?)
+    FEDORA = $(shell echo $(DISTRO) | grep -i fedora      >/dev/null 2>&1; echo $$?)
+    RHEL   = $(shell echo $(DISTRO) | grep -i 'red\|rhel' >/dev/null 2>&1; echo $$?)
+    CENTOS = $(shell echo $(DISTRO) | grep -i centos      >/dev/null 2>&1; echo $$?)
+    SUSE   = $(shell echo $(DISTRO) | grep -i 'suse\|sles' >/dev/null 2>&1; echo $$?)
+    ifeq ("$(UBUNTU)","0")
+      ifeq ($(HOST_ARCH)-$(TARGET_ARCH),x86_64-armv7l)
+        GLPATH := /usr/arm-linux-gnueabihf/lib
+        GLLINK := -L/usr/arm-linux-gnueabihf/lib
+        ifneq ($(TARGET_FS),) 
+          GLPATH += $(TARGET_FS)/usr/lib/arm-linux-gnueabihf
+          GLLINK += -L$(TARGET_FS)/usr/lib/arm-linux-gnueabihf
+        endif 
+      else ifeq ($(HOST_ARCH)-$(TARGET_ARCH),x86_64-aarch64)
+        GLPATH := /usr/aarch64-linux-gnu/lib
+        GLLINK := -L/usr/aarch64-linux-gnu/lib
+        ifneq ($(TARGET_FS),) 
+          GLPATH += $(TARGET_FS)/usr/lib
+          GLPATH += $(TARGET_FS)/usr/lib/aarch64-linux-gnu
+          GLLINK += -L$(TARGET_FS)/usr/lib/aarch64-linux-gnu
+        endif 
+      else ifeq ($(HOST_ARCH)-$(TARGET_ARCH),x86_64-ppc64le)
+        GLPATH := /usr/powerpc64le-linux-gnu/lib
+        GLLINK := -L/usr/powerpc64le-linux-gnu/lib
+      else
+        UBUNTU_PKG_NAME = $(shell which dpkg >/dev/null 2>&1 && dpkg -l 'nvidia-*' | grep '^ii' | awk '{print $$2}' | head -1)
+        ifneq ("$(UBUNTU_PKG_NAME)","")
+          GLPATH    ?= /usr/lib/$(UBUNTU_PKG_NAME)
+          GLLINK    ?= -L/usr/lib/$(UBUNTU_PKG_NAME)
+        endif
+
+        DFLT_PATH ?= /usr/lib
+      endif
+    endif
+    ifeq ("$(SUSE)","0")
+      GLPATH    ?= /usr/X11R6/lib64
+      GLLINK    ?= -L/usr/X11R6/lib64
+      DFLT_PATH ?= /usr/lib64
+    endif
+    ifeq ("$(FEDORA)","0")
+      GLPATH    ?= /usr/lib64/nvidia
+      GLLINK    ?= -L/usr/lib64/nvidia
+      DFLT_PATH ?= /usr/lib64
+    endif
+    ifeq ("$(RHEL)","0")
+      GLPATH    ?= /usr/lib64/nvidia
+      GLLINK    ?= -L/usr/lib64/nvidia
+      DFLT_PATH ?= /usr/lib64
+    endif
+    ifeq ("$(CENTOS)","0")
+      GLPATH    ?= /usr/lib64/nvidia
+      GLLINK    ?= -L/usr/lib64/nvidia
+      DFLT_PATH ?= /usr/lib64
+    endif
+  
+  # find libGL, libGLU 
+  GLLIB  := $(shell find -L $(GLPATH) $(DFLT_PATH) -name libGL.so  -print 2>/dev/null)
+  GLULIB := $(shell find -L $(GLPATH) $(DFLT_PATH) -name libGLU.so -print 2>/dev/null)
+
+  ifeq ("$(GLLIB)","")
+      $(info >>> WARNING - libGL.so not found, refer to CUDA Getting Started Guide for how to find and install them. <<<)
+      SAMPLE_ENABLED := 0
+  endif
+  ifeq ("$(GLULIB)","")
+      $(info >>> WARNING - libGLU.so not found, refer to CUDA Getting Started Guide for how to find and install them. <<<)
+      SAMPLE_ENABLED := 0
+  endif
+
+  HEADER_SEARCH_PATH ?= $(TARGET_FS)/usr/include
+  ifeq ($(HOST_ARCH)-$(TARGET_ARCH)-$(TARGET_OS),x86_64-armv7l-linux)
+      HEADER_SEARCH_PATH += /usr/arm-linux-gnueabihf/include
+  else ifeq ($(HOST_ARCH)-$(TARGET_ARCH)-$(TARGET_OS),x86_64-aarch64-linux)
+      HEADER_SEARCH_PATH += /usr/aarch64-linux-gnu/include
+  endif
+
+  GLHEADER  := $(shell find -L $(HEADER_SEARCH_PATH) -name gl.h -print 2>/dev/null)
+  GLUHEADER := $(shell find -L $(HEADER_SEARCH_PATH) -name glu.h -print 2>/dev/null)
+
+  ifeq ("$(GLHEADER)","")
+      $(info >>> WARNING - gl.h not found, refer to CUDA Getting Started Guide for how to find and install them. <<<)
+      SAMPLE_ENABLED := 0
+  endif
+  ifeq ("$(GLUHEADER)","")
+      $(info >>> WARNING - glu.h not found, refer to CUDA Getting Started Guide for how to find and install them. <<<)
+      SAMPLE_ENABLED := 0
+  endif
+else
+    # This would be the Mac OS X path if we had to do anything special
+endif
+