CUDA Image Processing Library: Architecture and Modules

Updated: August 27, 2026

Fastvideo CUDA image processing library is a set of independent C++/CUDA modules, one per stage of the camera image pipeline, that chain together in GPU memory — a frame enters the GPU once, passes through as many stages as your task requires, and leaves once. This page focuses on the architecture, the design choices behind it, and how to evaluate the library on your own hardware; the complete catalog of modules, licensing terms, and the product roadmap live on the Fastvideo SDK page.

The library is linkable: you link it into your own C++/CUDA application and call the modules directly, with images kept in GPU memory across the pipeline — a ready camera ISP, not a set of primitives to assemble.

CUDA image processing library architecture

How the Library Is Organized

Every stage of the pipeline — from raw frame unpacking to compression — is a separate module with a uniform data model: input and output buffers reside in GPU memory, so any sequence of modules composes without intermediate transfers to the CPU. The PCIe bus is crossed exactly twice per frame, on the way in and on the way out, which is the architectural reason for the library's performance: at multi-gigapixel-per-second module speeds, an extra host round trip would cost more than the computation itself. Multi-threaded applications are served by the stream-per-thread option (and CUDA MPS on Linux), and every module has built-in time measurement, so profiling a pipeline is a matter of reading the numbers rather than instrumenting the code.

Quality-First Algorithms, Not Just Primitives

Primitive libraries give you building blocks — a convolution, a transform, a basic interpolation — and leave image quality to whatever you assemble from them. This library takes the opposite approach: each module implements a specific, quality-critical stage of the camera pipeline with an algorithm chosen for its output quality, then optimized for the GPU. Demosaicing is not bilinear interpolation but the MG, DFPD, and L7 algorithms; denoising is NLM, bilateral, and wavelet with float workflow; resize is Lanczos; and the codecs — JPEG, JPEG2000, and the Raw Bayer codec — are complete standard-compliant implementations rather than wrappers. For a direct comparison of this approach with NVIDIA's primitive library, see our benchmark article Fastvideo SDK vs NVIDIA NPP.

We wrote these algorithms ourselves

Image processing has always been a trade-off between quality and speed. The methods that give a good result take minutes per frame; the fast ones leave halos and artifacts. The reason is the compute budget: on a CPU there was never enough of it, so algorithms were simplified — and much of the industry still runs on simplifications accepted decades ago.

Fastvideo’s codecs and ISP modules are neither ports of that legacy nor wrappers around third-party code. We designed — and in many cases invented — the algorithms behind our demosaicing, denoising, tone mapping and JPEG/JPEG2000 codecs, and wrote them for CUDA from the start, on top of image-processing expertise built since 2009. An algorithm moved to the GPU still carries the compromises it was simplified for; ours were never made under that constraint. On a modern GPU the budget is large enough that, for practical workloads, the choice between quality and speed no longer has to be made.

That is why you get a complete, tuned imaging solution rather than a bag of GPU primitives — and why, when your pipeline needs something specific, we can change the algorithm itself, not just call it.

Module Groups at a Glance

RAW domain: unpacking, linearization, dark frame subtraction, flat-field correction, bad pixel removal, white balance, raw denoising
Demosaicing: L7, DFPD, and MG algorithms with a 16-bit pipeline
Color and tone: color correction, color space transforms, 1D and 3D LUTs, gamma, tone mapping
Enhancement: denoising, sharpening (USM), defringe
Geometry: crop, resize, rotate, flip, remap and undistortion
Analysis and output: histograms, RGB parade, OpenGL display
Codecs: JPEG (8/12-bit), JPEG2000, Raw Bayer codec; MJPEG via FFmpeg
Infrastructure: stream-per-thread, CUDA MPS, per-module timing, trace and multiplexor modules

Each group above is one line here and a full section on the SDK page, with the dedicated product pages linked for the major modules.

Evaluating the Library on Your Hardware

The library ships with sample C++ applications with source code (MS Visual Studio 2022 projects on Windows), covering the individual modules and a complete camera application that assembles the full pipeline from acquisition to compressed output. Several modules are also available as freeware demo applications for a quick first test: JPEG codec, JPEG2000 codec, Debayer, and Resizer. The demo version of the full library, with documentation, is available upon request — run it on your GPU and your images, and let the built-in timing do the arguing.

Compatibility

OS: Windows 10/11, Linux Ubuntu, Linux4Tegra (L4T)
CUDA 12.6; MSVS 2022 on Windows
NVIDIA GPUs: Pascal, Volta, Turing, Ampere, and Ada generations; support for the latest GPU generations is in progress
NVIDIA Jetson: Nano, Xavier NX/AGX, Orin NX/AGX
MJPEG integration with FFmpeg (reader/writer); FFmpeg is under LGPL v2.1

Frequently asked questions

Can I link the library into my own C++ application?

Yes. It is a linkable C++/CUDA library: you link it into your application and call the modules directly, and the images stay in GPU memory across the pipeline, so it drops into an existing CUDA workflow.

How is it different from NVIDIA CUDA libraries such as NPP or CV-CUDA?

Those are platform building blocks — primitives you combine yourself. This library is a ready, camera-oriented imaging pipeline: quality-first ISP stages plus standard-compliant codecs that you link and call as a whole. For a direct comparison with NVIDIA's primitive library, see Fastvideo SDK vs NVIDIA NPP.

Integration, Custom Development, and Licensing

We offer integration services to connect the library with your existing software, and we develop custom CUDA image processing modules to an agreed specification when your pipeline includes a stage the library does not yet cover — our projects in development page shows what is currently being built. The library and its components are licensed to software developers, camera manufacturers, system integrators, and resellers, and are used in a wide range of imaging applications.

About the author

Fyodor Serzhenko, PhD, is the founder and CEO of Fastvideo. He earned his PhD at the Moscow Institute of Physics and Technology (MIPT) in 1993. Since 2009 he has led the development of Fastvideo’s GPU-accelerated image codecs and ISP modules, including the Fastvideo SDK. Connect on LinkedIn.

Why you can trust these results

Fastvideo has built GPU-accelerated image processing software since 2009. Our codecs comply with the standards they implement — JPEG (ITU-T T.81 / ISO IEC 10918) and JPEG2000 (ITU-T T.800 / ISO IEC 15444) — and our tools are open source on GitHub. Every performance figure we publish is reproducible: see our benchmark methodology, download the Fastvideo SDK benchmark report (PDF), and measure it on your own GPU.