Denoiser C++ library

v3.0.0

Table of contents

• Overview
• Versions
• Library files
• Denoiser class description
  • Denoiser class declaration
  • getVersion method
  • initVFilter method
  • setParam method
  • getParam method
  • getParams method
  • executeCommand method
  • processFrame method
  • setMask method
  • encodeSetParamCommand method of VFilter class
  • encodeCommand method of VFilter class
  • decodeCommand method of VFilter class
  • decodeAndExecuteCommand method
• Data structures
  • VFilterCommand enum
  • VFilterParam enum
• VFilterParams class description
  • VFilterParams class declaration
  • Serialize VFilter params
  • Deserialize VFilter params
  • Read params from JSON file and write to JSON file
• Build and connect to your project
• Example
• Test application

Overview

The Denoiser C++ library provides two noise cancellation backends behind a single interface: a software bilateral filter (a recursive, O(1)-per-pixel form of it, not the sliding-window one the article describes) and a software wrapper over the temporal noise reduction (TNR) of NVIDIA® Vision Programming Interface (VPI). The library is suitable for various types of cameras (daylight, SWIR, MWIR and LWIR) and provides a simple programming interface. Each instance of the Denoiser C++ class object performs frame-by-frame processing of a video data stream. The software backend processes each video frame independently. The VPI backend is temporal: it denoises the current frame against the previous one, so its output depends on the frames that came before it and a break in the stream should be signaled with the RESET command. The Denoiser library currently supports only the YUV24 and GRAY (software implementation only) pixel formats. The library depends on the VFilter library (provides the video filter interface, source code included, Apache 2.0 license). The library software backend has no other external dependencies: one implementation serves every platform and returns the same output on all of them. The filter passes are parallelized with OpenMP, which is an optional build dependency - without it the library still compiles and the filter runs serially. The size of the thread team is selected by the CUSTOM_2 parameter and is capped at 4 threads, because the filter is memory-bound and stops scaling past that point. The library VPI backend depends on VPI 3.x or 4.x and runs the temporal noise reduction on the VIC or the CUDA backend of VPI, selected by the CUSTOM_1 parameter. It repacks the YUV24 frame into the format that backend takes - NV12 (4:2:0) for CUDA, YUYV (4:2:2) for VIC - and back, so the chroma of the output frame is subsampled. In addition, the test application depends on the OpenCV library (provides the user interface, version >= 4.5, linked, Apache 2.0 license). The software backend is compatible with Linux and Windows. The VPI backend is Linux only, because VPI itself is distributed for Linux alone (x86_64 and Jetson). The library uses the C++17 standard.

Versions

Table 1 - Library versions.

Version	Release date	What’s new
1.0.0	19.03.2024	First version of the library.
1.0.1	21.05.2024	- VFilter interface class updated. - Documentation updated.
1.0.2	23.07.2024	- CMake structure updated.
2.0.0	09.03.2025	- External dependencies have been removed. - File structure has been changed. - Bilateral noise reduction filter has been implemented.
2.0.1	27.03.2026	- Performance improved by 20-30% on average. - Platform-specific filter core: fixed-point arithmetic on ARM, float on x86. - Compiler optimizations scoped to library target only.
2.1.0	08.04.2026	- Added denoising via the Intel IPP bilateral filter.
3.0.0	02.09.2026	- Intel IPP dependency removed entirely: a single implementation for every platform. - Performance improved. - Added support of Jetson VPI.

Library files

The library is supplied as source code only. The user is provided with a set of files in the form of a CMake project (repository). The repository structure is shown below:

CMakeLists.txt ------------ Main CMake file of the library.
3rdparty ------------------ Folder with third-party libraries.
    CMakeLists.txt -------- CMake file to include third-party libraries.
    VFilter --------------- Folder with VFilter library source code.
src ----------------------- Folder with source code of the library.
    impl ------------------ Folder with filter implementation files.
        DenoiserImpl.h ---- Header file with filter implementation.
        DenoiserImpl.cpp -- C++ implementation file. 
    vpiImpl --------------- Folder with VPI filter implementation.
        DenoiserImpl.h ---- Header file with VPI filter implementation.
        DenoiserImpl.cpp -- C++ implementation file. 
    CMakeLists.txt -------- CMake file of the library.
    Denoiser.cpp ---------- C++ implementation file.
    Denoiser.h ------------ Header file with the Denoiser class declaration.
    DenoiserVersion.h ----- Header file with the library version.
    DenoiserVersion.h.in -- CMake service file to generate the version file.
test ---------------------- Folder for test application.
    CMakeLists.txt -------- CMake file for test application.
    main.cpp -------------- Source code file of test application.

Denoiser class description

Exactly one backend is compiled into the library - the software one or the VPI one, selected at build time (see Build and connect to your project). There is no run-time switching between them, so the parameters and commands below are marked with the backend that owns them.

Denoiser class declaration

The Denoiser class is declared in the Denoiser.h file. Class declaration:

namespace cr
{
namespace video
{
class Denoiser : public VFilter
{
public:

    /// Class constructor.
    Denoiser();

    /// Class destructor.
    ~Denoiser() override;

    /// Get the version of the Denoiser class.
    static std::string getVersion();

    /// Initialize denoiser.
    bool initVFilter(VFilterParams& params) override;

    /// Set VFilter parameter.
    bool setParam(VFilterParam id, float value) override;

    /// Get the value of a specific VFilter parameter.
    float getParam(VFilterParam id) override;

    /// Get the structure containing all VFilter parameters.
    void getParams(VFilterParams& params) override;

    /// Execute a VFilter action command.
    bool executeCommand(VFilterCommand id) override;

    /// Process frame.
    bool processFrame(cr::video::Frame& frame) override;

    /// Set mask for filter.
    bool setMask(cr::video::Frame mask) override;

    /// Decode and execute command.
    bool decodeAndExecuteCommand(uint8_t* data, int size) override;
};
}
}

getVersion method

The getVersion() static method returns a string with the current class version. Method declaration:

static std::string getVersion();

The method can be used without a Denoiser class instance:

std::cout << "Denoiser version: " << cr::video::Denoiser::getVersion();

Console output:

Denoiser version: 3.0.0

initVFilter method

The initVFilter(…) method initializes the denoiser. Method declaration:

bool initVFilter(VFilterParams& params) override;

Parameter	Value
params	VFilterParams class object. The method uses the mode and level fields in any build, plus the fields of the compiled backend: custom2 in a software build, type and custom1 in a VPI build. The fields of the other backend are ignored.

Returns: TRUE if the params were accepted or FALSE if any of them was rejected.

Note: the method only validates and stores the params. Both backends size their buffers from the frame, so the buffers - and, in a VPI build, the VPI stream, images and TNR payload - are created on the first processFrame(…) call. A failure to create them is reported by processFrame(…) returning FALSE, not by this method.

setParam method

The setParam(…) method sets a new parameter value. The library provides a thread-safe setParam(…) method call. This means that the setParam(…) method can be safely called from any thread. Method declaration:

bool setParam(VFilterParam id, float value) override;

Parameter	Description
id	Parameter ID according to the VFilterParam enum. The method supports MODE and LEVEL in any build, plus the parameters of the compiled backend: CUSTOM_2 in a software build, TYPE and CUSTOM_1 in a VPI build. Any other parameter is rejected and the method returns FALSE.
value	Parameter value. Value depends on parameter ID.

Returns: TRUE if the parameter was set or FALSE if not.

getParam method

The getParam(…) method returns a parameter value. The library provides a thread-safe getParam(…) method call. This means that the getParam(…) method can be safely called from any thread. Method declaration:

float getParam(VFilterParam id) override;

Parameter	Description
id	Parameter ID according to the VFilterParam enum. The method supports MODE, LEVEL and PROCESSING_TIME_MCSEC in any build, plus the parameters of the compiled backend: CUSTOM_2 in a software build, TYPE and CUSTOM_1 in a VPI build. For any other parameter the method will return -1.

Returns: the parameter value or -1 if the parameter does not exist (is not supported by a particular implementation).

getParams method

The getParams(…) method is designed to obtain all denoiser params. The library provides a thread-safe getParams(…) method call. This means that the getParams(…) method can be safely called from any thread. Method declaration:

void getParams(VFilterParams& params) override;

Parameter	Description
params	Reference to a VFilterParams object to store params. The method always fills in mode, level and processingTimeMcSec. A software build also fills in custom2; a VPI build also fills in type and custom1. Every field the compiled backend does not own is set to -1.

executeCommand method

The executeCommand(…) method executes a video filter (denoiser) action command. The library provides a thread-safe executeCommand(…) method call. This means that the executeCommand(…) method can be safely called from any thread. Method declaration:

bool executeCommand(VFilterCommand id) override;

Parameter	Description
id	Command ID according to the VFilterCommand enum. The method supports ON and OFF in any build, and RESET in a VPI build only - in a software build RESET returns FALSE.

Returns: TRUE if the command was executed or FALSE if not.

processFrame method

The processFrame(…) method is designed to process a frame (noise cancellation). If the mode is set to 0 (disabled), the method will skip the frame and return TRUE. The YUV24 format is supported by both the software and the VPI implementations; the GRAY format is supported by the software implementation only. Method declaration:

bool processFrame(cr::video::Frame& frame) override;

Parameter	Description
frame	Reference to Frame object. Only the YUV24 and GRAY (software implementation only) formats are supported.

Returns: TRUE if the frame was processed (noise cancellation) or FALSE if not. If the filter is disabled, the method will return TRUE without processing the video frame.

setMask method

The setMask(…) method is designed to set a video filter mask. Masks are not supported by the Denoiser class. Method declaration:

bool setMask(cr::video::Frame mask) override;

Parameter	Description
mask	Filter mask in the form of a Frame object with the GRAY pixel format. Masks are not supported by the Denoiser class.

Returns: TRUE in any case.

encodeSetParamCommand method of VFilter class

The encodeSetParamCommand(…) static method encodes a command to change any VFilter parameter value. To control any video filter remotely, the developer has to design their own protocol and, according to it, encode the command and deliver it over the communication channel. To simplify this, the VFilter class contains static methods for encoding the control command. The VFilter class provides two types of commands: a parameter change command (SET_PARAM) and an action command (COMMAND). encodeSetParamCommand(…) is designed to encode the SET_PARAM command. Method declaration:

static void encodeSetParamCommand(uint8_t* data, int& size, VFilterParam id, float value);

Parameter	Description
data	Pointer to data buffer for encoded command. Must have size >= 11.
size	Size of encoded data. Will be 11 bytes.
id	Parameter ID according to VFilterParam enum.
value	Parameter value.

encodeSetParamCommand(…) is static and is used without a VFilter class instance. This method is used on the client side (control system). Command encoding example:

// Buffer for encoded data.
uint8_t data[11];
// Size of encoded data.
int size = 0;
// Random parameter value.
float outValue = static_cast<float>(rand() % 20);
// Encode command.
VFilter::encodeSetParamCommand(data, size, VFilterParam::LEVEL, outValue);

encodeCommand method of VFilter class

The encodeCommand(…) static method encodes a command for VFilter remote control. To control any video filter remotely, the developer has to design their own protocol and, according to it, encode the command and deliver it over the communication channel. To simplify this, the VFilter class contains static methods for encoding the control command. The VFilter class provides two types of commands: a parameter change command (SET_PARAM) and an action command (COMMAND). encodeCommand(…) is designed to encode the COMMAND (action command). Method declaration:

static void encodeCommand(uint8_t* data, int& size, VFilterCommand id);

Parameter	Description
data	Pointer to data buffer for encoded command. Must have size >= 7.
size	Size of encoded data. Will be 7 bytes.
id	Command ID according to VFilterCommand enum.

encodeCommand(…) is static and is used without a VFilter class instance. This method is used on the client side (control system). Command encoding example:

// Buffer for encoded data.
uint8_t data[7];
// Size of encoded data.
int size = 0;
// Encode command.
VFilter::encodeCommand(data, size, VFilterCommand::RESET);

decodeCommand method of VFilter class

The decodeCommand(…) static method decodes a command on the video filter side. Method declaration:

static int decodeCommand(uint8_t* data, int size, VFilterParam& paramId, VFilterCommand& commandId, float& value);

Parameter	Description
data	Pointer to input command.
size	Size of command. Must be 11 bytes for SET_PARAM and 7 bytes for COMMAND.
paramId	VFilter parameter ID according to VFilterParam enum. After decoding a SET_PARAM command, the method will return the parameter ID.
commandId	VFilter command ID according to VFilterCommand enum. After decoding a COMMAND, the method will return the command ID.
value	VFilter parameter value (after decoding SET_PARAM command).

Returns: 0 if a COMMAND was decoded, 1 if a SET_PARAM command was decoded, or -1 in case of errors.

decodeAndExecuteCommand method

The decodeAndExecuteCommand(…) method decodes and executes a command encoded by the encodeSetParamCommand(…) and encodeCommand(…) methods on the video filter side. The library provides a thread-safe decodeAndExecuteCommand(…) method call. This means that the decodeAndExecuteCommand(…) method can be safely called from any thread. Method declaration:

bool decodeAndExecuteCommand(uint8_t* data, int size) override;

Parameter	Description
data	Pointer to input command.
size	Size of command. Must be 11 bytes for SET_PARAM or 7 bytes for COMMAND.

Returns: TRUE if the command was decoded (SET_PARAM or COMMAND) and executed (action command or set param command).

Data structures

VFilterCommand enum

Enum declaration:

enum class VFilterCommand
{
    /// Reset video filter algorithm.
    RESET = 1,
    /// Enable filter.
    ON,
    /// Disable filter.
    OFF
};

Table 2 - Action commands description.

Command	Description
RESET	Resets denoiser: drops the temporal history and reinitializes it on the next frame. Supported only by VPI.
ON	Enable the denoiser.
OFF	Disable the denoiser.

VFilterParam enum

Enum declaration:

enum class VFilterParam
{
	/// Filter mode: 0 - off, 1 - on. Depends on implementation.
	MODE = 1,
	/// Enhancement level for particular filter, as a percentage from 
	/// 0% to 100%. May have another meaning depends on implementation.
	LEVEL,
	/// Processing time in microseconds. Read only parameter.
	PROCESSING_TIME_MCSEC,
	/// Type of the filter. Depends on the implementation.
	TYPE,
	/// VFilter custom parameter. Custom parameters used when particular image 
	/// filter has specific unusual parameter.
	CUSTOM_1,
	/// VFilter custom parameter. Custom parameters used when particular image 
	/// filter has specific unusual parameter.
	CUSTOM_2,
	/// VFilter custom parameter. Custom parameters used when particular image 
	/// filter has specific unusual parameter.
	CUSTOM_3
};

Table 3 - Params description.

Parameter	Access	Description
MODE	read / write	Denoiser mode: 0 - disabled, 1 - enabled.
LEVEL	read / write	Denoiser level as a percentage. Valid values from 0.0 to 100.0. The level sets how far apart two pixels may be in brightness and in distance and still be averaged together: at 0 the filter only merges pixels within a few grey levels of each other, at 100 within about twenty. Higher levels remove more noise and soften more detail, so the useful setting follows the amount of noise in the source rather than being as high as possible.
PROCESSING_TIME_MCSEC	read only	Processing time in microseconds. Read only parameter. Used to check the performance of the denoiser.
TYPE	read / write	Scene preset of the VPI temporal noise reduction. VPI builds only: a software build rejects the parameter and reads back -1. Values: 0 - Default 1 - Outdoor low light 2 - Outdoor medium light 3 - Outdoor high light 4 - Indoor low light 5 - Indoor medium light 6 - Indoor high light
CUSTOM_1	read / write	VPI backend. VPI builds only: a software build rejects the parameter and reads back -1. Values: 0 - VIC, 1 - CUDA.
CUSTOM_2	read / write	Size of the software filter thread team. Software builds only: a VPI build rejects the parameter and reads back -1. 0 or less selects automatic sizing: one thread per CPU core, minus one. Automatic or explicit, the value is clamped to 1 - 4; 1 runs the filter serially. The filter output does not depend on this parameter.
CUSTOM_3	read / write	Not supported by the Denoiser class.

VFilterParams class description

VFilterParams class declaration

The VFilterParams class provides the video filter parameters structure. It also provides the ability to read params from JSON files and write them to JSON files (the JSON_READABLE macro), as well as methods to encode and decode params. The VFilterParams interface class is declared in the VFilter.h file. Class declaration:

class VFilterParams
{
public:
    /// Filter mode: 0 - off, 1 - on. Depends on implementation.
    int mode{ 1 };
    /// Enhancement level for particular filter, as a percentage from 
    /// 0% to 100%. May have another meaning depends on implementation.
    float level{ 0.0f };
    /// Processing time in microseconds. Read only parameter.
    int processingTimeMcSec{ 0 };
    /// Type of the filter. Depends on the implementation.
    int type{ 0 };
    /// VFilter custom parameter. Custom parameters used when particular image 
    /// filter has specific unusual parameter.
    float custom1{ 0.0f };
    /// VFilter custom parameter. Custom parameters used when particular image 
    /// filter has specific unusual parameter.
    float custom2{ 0.0f };
    /// VFilter custom parameter. Custom parameters used when particular image 
    /// filter has specific unusual parameter.
    float custom3{ 0.0f };

    /// Macro from ConfigReader to make params readable/writable from JSON.
    JSON_READABLE(VFilterParams, mode, level, type, custom1, custom2, custom3)

    /// operator =
    VFilterParams& operator= (const VFilterParams& src);

    // Encode (serialize) params.
    bool encode(uint8_t* data, int bufferSize, int& size,
                                             VFilterParamsMask* mask = nullptr);
	// Decode (deserialize) params.
    bool decode(uint8_t* data, int dataSize);
};

Table 4 - VFilterParams class field descriptions, related to the VFilterParam enum description.

Field	type	Description
mode	int	Denoiser mode: 0 - disabled, 1 - enabled.
level	float	Denoiser level as a percentage. Valid values from 0.0 to 100.0.
processingTimeMcSec	int	Processing time in microseconds. Read only parameter. Used to check the performance of the denoiser.
type	int	Scene preset of the VPI temporal noise reduction. VPI builds only: a software build reads back -1. Values: 0 - Default 1 - Outdoor low light 2 - Outdoor medium light 3 - Outdoor high light 4 - Indoor low light 5 - Indoor medium light 6 - Indoor high light
custom1	float	VPI backend. VPI builds only: a software build reads back -1. Values: 0 - VIC, 1 - CUDA.
custom2	float	Size of the software filter thread team. Software builds only: a VPI build reads back -1. 0 or less selects automatic sizing: one thread per CPU core, minus one. Automatic or explicit, the value is clamped to 1 - 4; 1 runs the filter serially. The filter output does not depend on this field.
custom3	float	Not supported by the Denoiser class.

Note: The VFilterParams class fields listed in Table 4 have to reflect the params set and read by the setParam(…) and getParam(…) methods.

Serialize VFilter params

The VFilterParams class provides the encode(…) method to serialize VFilter params. Serialization of VFilterParams is needed when the image filter parameters have to be sent over a communication channel. The method provides an option to exclude particular parameters from serialization. To do this, the method inserts a binary mask (1 byte) in which each bit represents a particular parameter, and the decode(…) method recognizes it. Method declaration:

bool encode(uint8_t* data, int bufferSize, int& size, VFilterParamsMask* mask = nullptr);

Parameter	Value
data	Pointer to data buffer. Buffer size must be >= 32 bytes.
bufferSize	Data buffer size. Buffer size must be >= 32 bytes.
size	Size of encoded data.
mask	Parameters mask - pointer to VFilterParamsMask structure. VFilterParamsMask (declared in VFilter.h file) determines flags for each field (parameter) declared in VFilterParams class. If the user wants to exclude any parameters from serialization, they can pass a pointer to the mask. If the user wants to exclude a particular parameter from serialization, they should set the corresponding flag in the VFilterParamsMask structure.

Returns: TRUE if the params were encoded (serialized) or FALSE if not.

VFilterParamsMask structure declaration:

struct VFilterParamsMask
{
    bool mode{ true };
    bool level{ true };
    bool processingTimeMcSec{ true };
    bool type{ true };
    bool custom1{ true };
    bool custom2{ true };
    bool custom3{ true };
};

Example without parameters mask:

// Prepare parameters.
cr::video::VFilterParams params;
params.level = 80.0f;

// Encode (serialize) params.
int bufferSize = 128;
uint8_t buffer[128];
int size = 0;
params.encode(buffer, bufferSize, size);

Example with parameters mask:

// Prepare parameters.
cr::video::VFilterParams params;
params.level = 80.0;

// Prepare mask.
cr::video::VFilterParamsMask mask;
// Exclude level.
mask.level = false;

// Encode (serialize) params.
int bufferSize = 128;
uint8_t buffer[128];
int size = 0;
params.encode(buffer, bufferSize, size, &mask);

Deserialize VFilter params

The VFilterParams class provides the decode(…) method to deserialize params. Deserialization of VFilterParams is needed when params are received over a communication channel. The method automatically recognizes which parameters were serialized by the encode(…) method. Method declaration:

bool decode(uint8_t* data, int dataSize);

Parameter	Value
data	Pointer to data buffer with serialized params.
dataSize	Size of the serialized data.

Returns: TRUE if the params were decoded (deserialized) or FALSE if not.

Example:

// Prepare parameters.
cr::video::VFilterParams params1;
params1.level = 80;

// Encode (serialize) params.
int bufferSize = 128;
uint8_t buffer[128];
int size = 0;
params1.encode(buffer, bufferSize, size);

// Decode (deserialize) params.
cr::video::VFilterParams params2;
params2.decode(buffer, size);

Read params from JSON file and write to JSON file

VFilter depends on the open-source ConfigReader library, which provides methods to read params from a JSON file and to write params to a JSON file. Example of writing params to a JSON file and reading them back:

// Write params to file.
cr::utils::ConfigReader inConfig;
cr::video::VFilterParams in;
inConfig.set(in, "vFilterParams");
inConfig.writeToFile("VFilterParams.json");

// Read params from file.
cr::utils::ConfigReader outConfig;
if(!outConfig.readFromFile("VFilterParams.json"))
{
    cout << "Can't open config file" << endl;
    return false;
}

VFilterParams.json will look as follows:

{
    "vFilterParams":
    {
        "level": 50,
        "mode": 1,
        "type": 1,
        "custom1": 1.0,
        "custom2": 4.0,
        "custom3": 0.0
    }
}

Build and connect to your project

Typical commands to build Denoiser with the software backend on Linux:

cd Denoiser
mkdir build
cd build
cmake .. -DDENOISER_USE_VPI=OFF
make

The build looks for OpenMP and links it when present, which is what makes the CUSTOM_2 thread team effective. OpenMP is optional: without it the library compiles and the filter runs serially, and CUSTOM_2 is still accepted but has no effect.

Typical commands to build Denoiser with the VPI backend on Linux:

cd Denoiser
mkdir build
cd build
cmake .. -DDENOISER_USE_VPI=ON
make

If you want to connect Denoiser to your CMake project as source code, you can do the following. For example, if your repository has the following structure:

CMakeLists.txt
src
    CMakeLists.txt
    yourLib.h
    yourLib.cpp

Create a 3rdparty folder in your repository and copy the Denoiser repository folder there. The new structure of your repository:

CMakeLists.txt
src
    CMakeLists.txt
    yourLib.h
    yourLib.cpp
3rdparty
    Denoiser

Create a CMakeLists.txt file in the 3rdparty folder. It should contain:

cmake_minimum_required(VERSION 3.13)

################################################################################
## 3RD-PARTY
## dependencies for the project
################################################################################
project(3rdparty LANGUAGES CXX)

################################################################################
## SETTINGS
## basic 3rd-party settings before use
################################################################################
# To inherit the top-level architecture when the project is used as a submodule.
SET(PARENT ${PARENT}_YOUR_PROJECT_3RDPARTY)
# Disable self-overwriting of parameters inside included subdirectories.
SET(${PARENT}_SUBMODULE_CACHE_OVERWRITE OFF CACHE BOOL "" FORCE)

################################################################################
## INCLUDING SUBDIRECTORIES
## Adding subdirectories according to the 3rd-party configuration
################################################################################
add_subdirectory(Denoiser)

The 3rdparty/CMakeLists.txt file adds the Denoiser folder to your project and excludes the test application from the build (by default, the test application and the examples are excluded from the build if Denoiser is included as a sub-repository). The new structure of your repository:

CMakeLists.txt
src
    CMakeLists.txt
    yourLib.h
    yourLib.cpp
3rdparty
    CMakeLists.txt
    Denoiser

Next, you need to include the 3rdparty folder in the main CMakeLists.txt file of your repository. Add the following line at the end of your main CMakeLists.txt:

add_subdirectory(3rdparty)

Next, you have to link the Denoiser library in your src/CMakeLists.txt file:

target_link_libraries(${PROJECT_NAME} Denoiser)

Done!

Example

This section demonstrates how to use the Denoiser with a straightforward example.

#include <iostream>
#include <cstdint>
#include <string.h>
#include "Denoiser.h"

int main(void)
{
    std::cout << "Denoiser v" <<
	cr::video::Denoiser::getVersion() << std::endl;

    // Init filter.
	cr::video::Denoiser denoiser;
    cr::video::VFilterParams params;
    params.mode = 1; // Enable the filter.
    params.level = 80; // 80% filter strength.
    denoiser.initVFilter(params);

	// Process frame.
	cr::video::Frame frame(512, 512, cr::video::Fourcc::YUV24);

	while(true)
	{
        // Prepare YUV24 frame...

        // Apply filter.
		denoiser.processFrame(frame);
	}
    return 1;
}

Test application

The Denoiser C++ library includes a test application located in the /test folder. This application is designed to help users evaluate the Denoiser’s capabilities. It provides options to adjust parameters such as LEVEL and MODE, and it displays the processing time in milliseconds. Since the application uses a synthetic image for testing, there’s no need to supply an actual image. The test application is independent of the operating system, meaning that it works the same way on both Linux and Windows. To start the test application on Windows, run the DenoiserTest.exe file. On Linux, use the commands below.

sudo chmod +x DenoiserTest
./DenoiserTest

After the start, the user will see a dialog for setting the resolution and the display mode (enable / disable the video display):

Denoiser v3.0.0

Set frame width: 1280
Set frame height: 720
Display frame ? (y/n): y

Once the application is successfully launched, it will display a noisy image in a window. Users can adjust the denoiser’s strength from the keyboard: key 2 decreases the strength and key 3 increases it. Key 1 toggles the denoiser on and off. The window will appear as follows:

---

Table of contents