Blender V5.3
denoiser_gpu.cpp
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
2 *
3 * SPDX-License-Identifier: Apache-2.0 */
4
6
7#include "device/denoise.h"
8#include "device/device.h"
9#include "device/memory.h"
10#include "device/queue.h"
11
13
14#include "session/buffers.h"
15
16#include "util/log.h"
17
19
20DenoiserGPU::DenoiserGPU(Device *denoiser_device, const DenoiseParams &params)
21 : Denoiser(denoiser_device, params)
22{
23 denoiser_queue_ = denoiser_device->gpu_queue_create();
25}
26
28{
29 /* Explicit implementation, to allow forward declaration of Device in the header. */
30}
31
32bool DenoiserGPU::denoise_buffer(const BufferParams &buffer_params,
33 const BufferParams &denoised_buffer_params,
34 RenderBuffers *render_buffers,
35 const int num_samples,
36 const bool allow_inplace_modification,
37 const float2 pixel_jitter)
38{
39 Device *denoiser_device = get_denoiser_device();
40 if (!denoiser_device) {
41 return false;
42 }
43
44 RenderBuffers local_render_buffers(denoiser_device);
45 bool local_buffer_used = false;
46
47 if (denoiser_device == render_buffers->buffer.device) {
48 /* The device can access an existing buffer pointer. */
49 local_buffer_used = false;
50 }
51 else {
52 LOG_DEBUG << "Creating temporary buffer on denoiser device.";
53
54 /* Create buffer which is available by the device used by denoiser. */
55
56 /* TODO(sergey): Optimize data transfers. For example, only copy denoising related passes,
57 * ignoring other light ad data passes. */
58
59 local_buffer_used = true;
60
61 render_buffers->copy_from_device();
62
63 local_render_buffers.reset(denoised_buffer_params);
64
65 /* NOTE: The local buffer is allocated for an exact size of the effective render size, while
66 * the input render buffer is allocated for the lowest resolution divider possible. So it is
67 * important to only copy actually needed part of the input buffer. */
68 memcpy(local_render_buffers.buffer.data(),
69 render_buffers->buffer.data(),
70 sizeof(float) * local_render_buffers.buffer.size());
71
72 denoiser_queue_->copy_to_device(local_render_buffers.buffer);
73 }
74
75 {
76 DenoiseContext context(denoiser_device,
77 params_,
78 buffer_params,
79 denoised_buffer_params,
80 local_buffer_used ? &local_render_buffers : render_buffers,
81 num_samples,
82 local_buffer_used || allow_inplace_modification,
83 pixel_jitter);
84
85 if (!denoise_ensure(context)) {
86 return false;
87 }
88
90 LOG_ERROR << "Error preprocessing guiding passes.";
91 return false;
92 }
93
94 /* Passes which will use real albedo when it is available. */
95 if (!denoise_pass(context, PASS_COMBINED)) {
96 return false;
97 }
99 return false;
100 }
101
102 /* Passes which do not need albedo and hence if real is present it needs to become fake. */
103 if (!denoise_pass(context, PASS_SHADOW_CATCHER)) {
104 return false;
105 }
106 }
107
108 if (local_buffer_used) {
109 local_render_buffers.copy_from_device();
110
112 denoised_buffer_params,
113 &local_render_buffers,
114 local_render_buffers.params);
115
116 render_buffers->copy_to_device();
117 }
118
119 return true;
120}
121
123{
124 if (!denoise_create_if_needed(context)) {
125 LOG_ERROR << "GPU denoiser creation has failed.";
126 return false;
127 }
128
129 if (!denoise_configure_if_needed(context)) {
130 LOG_ERROR << "GPU denoiser configuration has failed.";
131 return false;
132 }
133
134 return true;
135}
136
138{
139 const BufferParams &buffer_params = context.buffer_params;
140
141 /* Delay the allocation of the guiding buffer to first use, in case it's not actually needed
142 * (e.g. with the DLSS denoiser, which overrides this implementation). */
143 if (context.use_guiding_passes && !context.guiding_params.device_pointer) {
144 context.guiding_buffer.alloc_to_device(buffer_params.width * buffer_params.height *
145 context.guiding_params.pass_stride);
146 context.guiding_params.device_pointer = context.guiding_buffer.device_pointer;
147 }
148
149 const int work_size = buffer_params.width * buffer_params.height;
150
151 const DeviceKernelArguments args(&context.guiding_params.device_pointer,
152 &context.guiding_params.pass_stride,
153 &context.guiding_params.pass_albedo,
154 &context.guiding_params.pass_normal,
155 &context.guiding_params.pass_flow,
156 &context.render_buffers->buffer.device_pointer,
157 &buffer_params.offset,
158 &buffer_params.stride,
159 &buffer_params.pass_stride,
160 &context.pass_sample_count,
161 &context.pass_denoising_albedo,
162 &context.pass_denoising_normal,
163 &context.pass_motion,
164 &buffer_params.full_x,
165 &buffer_params.full_y,
166 &buffer_params.width,
167 &buffer_params.height,
168 &context.num_samples);
169
172}
173
175 const DenoiseParams &params,
179 const int num_samples,
180 const bool allow_inplace_modification,
181 const float2 pixel_jitter)
182 : denoise_params(params),
186 guiding_buffer(device, "denoiser guiding passes buffer", true),
187 use_guiding_passes(params.passes != DENOISER_PASS_NONE),
190{
193
194 if (params.passes & DENOISER_PASS_ALBEDO) {
195 pass_denoising_albedo = buffer_params.get_pass_offset(PASS_DENOISING_ALBEDO);
196 }
197 if (params.passes & DENOISER_PASS_NORMAL) {
198 pass_denoising_normal = buffer_params.get_pass_offset(PASS_DENOISING_NORMAL);
199 }
200
201 if (params.temporally_stable) {
202 prev_output.device_pointer = render_buffers->buffer.device_pointer;
203
204 prev_output.offset = buffer_params.get_pass_offset(PASS_DENOISING_PREVIOUS);
205
206 prev_output.stride = buffer_params.stride;
207 prev_output.pass_stride = buffer_params.pass_stride;
208 }
209
211 if (allow_inplace_modification) {
213
216 guiding_params.pass_flow = pass_motion;
217
220 }
221 else {
222 guiding_params.pass_stride = 0;
223 if (params.passes & DENOISER_PASS_ALBEDO) {
224 guiding_params.pass_albedo = guiding_params.pass_stride;
225 guiding_params.pass_stride += 3;
226 }
227 if (params.passes & DENOISER_PASS_NORMAL) {
228 guiding_params.pass_normal = guiding_params.pass_stride;
229 guiding_params.pass_stride += 3;
230 }
231 if (pass_motion != PASS_UNUSED) {
232 guiding_params.pass_flow = guiding_params.pass_stride;
233 guiding_params.pass_stride += 2;
234 }
235
237 }
238 }
239}
240
242 const DenoisePass &pass)
243{
244 if (!denoise_filter_color_flip_y(context, context.denoised_buffer_params, pass)) {
245 return false;
246 }
247
248 const BufferParams &buffer_params = context.denoised_buffer_params;
249
250 const int work_size = buffer_params.width * buffer_params.height;
251
252 const DeviceKernelArguments args(&context.render_buffers->buffer.device_pointer,
253 &buffer_params.full_x,
254 &buffer_params.full_y,
255 &buffer_params.width,
256 &buffer_params.height,
257 &buffer_params.offset,
258 &buffer_params.stride,
259 &buffer_params.pass_stride,
260 &context.num_samples,
261 &pass.noisy_offset,
262 &pass.denoised_offset,
263 &context.pass_sample_count,
264 &pass.num_components,
266
268}
269
271 const DenoisePass &pass)
272{
273 if (context.denoise_params.type != DENOISER_OPTIX) {
274 /* Pass preprocessing is used to clamp values for the OptiX denoiser.
275 * Clamping is not necessary for other denoisers, so just skip this preprocess step. */
276 return true;
277 }
278
279 if (!denoise_filter_color_flip_y(context, context.buffer_params, pass)) {
280 return false;
281 }
282
283 const BufferParams &buffer_params = context.buffer_params;
284
285 const int work_size = buffer_params.width * buffer_params.height;
286
287 const DeviceKernelArguments args(&context.render_buffers->buffer.device_pointer,
288 &buffer_params.full_x,
289 &buffer_params.full_y,
290 &buffer_params.width,
291 &buffer_params.height,
292 &buffer_params.offset,
293 &buffer_params.stride,
294 &buffer_params.pass_stride,
295 &pass.denoised_offset);
296
298}
299
301 const BufferParams &buffer_params,
302 const DenoisePass &pass)
303{
304 if (context.denoise_params.type != DENOISER_OPTIX || context.denoise_params.temporally_stable) {
305 /* Flipping the image is used to improve result quality with the OptiX denoiser.
306 * It is not necessary for other denoisers, so just skip this preprocess step. */
307 return true;
308 }
309
310 const int work_size = buffer_params.width * buffer_params.height / 2;
311
312 const DeviceKernelArguments args(&context.render_buffers->buffer.device_pointer,
313 &buffer_params.full_x,
314 &buffer_params.full_y,
315 &buffer_params.width,
316 &buffer_params.height,
317 &buffer_params.offset,
318 &buffer_params.stride,
319 &buffer_params.pass_stride,
320 &pass.denoised_offset,
321 &pass.num_components);
322
324}
325
327{
328 if (context.denoise_params.type != DENOISER_OPTIX || context.denoise_params.temporally_stable) {
329 /* Flipping the image is used to improve result quality with the OptiX denoiser.
330 * It is not necessary for other denoisers, so just skip this preprocess step. */
331 return true;
332 }
333
334 const BufferParams &buffer_params = context.buffer_params;
335
336 const int guiding_offset = 0;
337 const int num_components = 3;
338
339 const int work_size = buffer_params.width * buffer_params.height / 2;
340
341 const int guiding_passes[] = {context.guiding_params.pass_albedo,
342 context.guiding_params.pass_normal};
343 for (const int guiding_pass : guiding_passes) {
344 if (guiding_pass == PASS_UNUSED) {
345 continue;
346 }
347
348 const DeviceKernelArguments args(&context.guiding_params.device_pointer,
349 &guiding_offset,
350 &guiding_offset,
351 &buffer_params.width,
352 &buffer_params.height,
353 &guiding_offset,
354 &context.guiding_params.stride,
355 &context.guiding_params.pass_stride,
356 &guiding_pass,
357 &num_components);
358
360 return false;
361 }
362 }
363 return true;
364}
365
367{
368 const BufferParams &buffer_params = context.buffer_params;
369
370 if (context.use_guiding_passes && !context.guiding_params.device_pointer) {
371 context.guiding_buffer.alloc_to_device(buffer_params.width * buffer_params.height *
372 context.guiding_params.pass_stride);
373 context.guiding_params.device_pointer = context.guiding_buffer.device_pointer;
374 }
375
376 const int work_size = buffer_params.width * buffer_params.height;
377
378 const DeviceKernelArguments args(&context.guiding_params.device_pointer,
379 &context.guiding_params.pass_stride,
380 &context.guiding_params.pass_albedo,
381 &buffer_params.width,
382 &buffer_params.height);
383
385}
386
388{
389 PassAccessor::PassAccessInfo pass_access_info;
390 pass_access_info.type = pass.type;
391 pass_access_info.mode = PassMode::NOISY;
392 pass_access_info.offset = pass.noisy_offset;
393
394 /* Denoiser operates on passes which are used to calculate the approximation, and is never used
395 * on the approximation. The latter is not even possible because OptiX does not support
396 * denoising of semi-transparent pixels. */
397 pass_access_info.use_approximate_shadow_catcher = false;
398 pass_access_info.use_approximate_shadow_catcher_background = false;
399 pass_access_info.show_active_pixels = false;
400
401 /* TODO(sergey): Consider adding support of actual exposure, to avoid clamping in extreme cases.
402 */
403 const PassAccessorGPU pass_accessor(
404 denoiser_queue_.get(), pass_access_info, 1.0f, context.num_samples);
405
406 PassAccessor::Destination destination(pass_access_info.type, pass_access_info.mode);
407 destination.d_pixels = context.render_buffers->buffer.device_pointer;
408 destination.num_components = pass.num_components;
409 destination.pixel_offset = pass.denoised_offset;
410 destination.pixel_stride = context.buffer_params.pass_stride;
411
412 BufferParams buffer_params = context.buffer_params;
413 buffer_params.window_x = 0;
414 buffer_params.window_y = 0;
415 buffer_params.window_width = buffer_params.width;
416 buffer_params.window_height = buffer_params.height;
417
418 pass_accessor.get_render_tile_pixels(context.render_buffers, buffer_params, destination);
419}
420
422{
423 const BufferParams &buffer_params = context.buffer_params;
424
425 const DenoisePass pass(pass_type, buffer_params);
426
427 if (pass.noisy_offset == PASS_UNUSED) {
428 return true;
429 }
430 if (pass.denoised_offset == PASS_UNUSED) {
431 LOG_DFATAL << "Missing denoised pass " << pass_type_as_string(pass_type);
432 return false;
433 }
434
435 if (pass.use_denoising_albedo) {
436 if (context.albedo_replaced_with_fake) {
437 LOG_ERROR << "Pass which requires albedo is denoised after fake albedo has been set.";
438 return false;
439 }
440 }
441 else if (context.use_guiding_passes && !context.albedo_replaced_with_fake) {
442 context.albedo_replaced_with_fake = true;
444 LOG_ERROR << "Error replacing real albedo with the fake one.";
445 return false;
446 }
447 }
448
449 /* Read and preprocess noisy color input pass. */
450 denoise_color_read(context, pass);
451 if (!denoise_filter_color_preprocess(context, pass)) {
452 LOG_ERROR << "Error converting denoising passes to RGB buffer.";
453 return false;
454 }
455
456 if (!denoise_run(context, pass)) {
457 LOG_ERROR << "Error running denoiser.";
458 return false;
459 }
460
461 /* Store result in the combined pass of the render buffer.
462 *
463 * This will scale the denoiser result up to match the number of, possibly per-pixel, samples. */
464 if (!denoise_filter_color_postprocess(context, pass)) {
465 LOG_ERROR << "Error copying denoiser result to the denoised pass.";
466 return false;
467 }
468
469 return denoiser_queue_->synchronize();
470}
471
void render_buffers_host_copy_denoised(RenderBuffers *dst, const BufferParams &dst_params, const RenderBuffers *src, const BufferParams &src_params, const size_t src_offset)
Definition buffers.cpp:304
int pass_stride
Definition buffers.h:92
int get_pass_offset(PassType type, PassMode mode=PassMode::NOISY) const
Definition buffers.cpp:164
int window_y
Definition buffers.h:78
int window_height
Definition buffers.h:80
int window_width
Definition buffers.h:79
NODE_DECLARE int width
Definition buffers.h:70
int window_x
Definition buffers.h:77
float upscale_factor
Definition denoise.h:90
bool temporally_stable
Definition denoise.h:82
DenoiserPassMask passes
Definition denoise.h:79
const BufferParams & buffer_params
DenoiseContext(Device *device, const DenoiseParams &params, const BufferParams &buffer_params, const BufferParams &denoised_buffer_params, RenderBuffers *render_buffers, int num_samples, bool allow_inplace_modification, float2 pixel_jitter)
struct DenoiserGPU::DenoiseContext::@054256012063023057250165003331300343343046235202 guiding_params
const DenoiseParams & denoise_params
const BufferParams & denoised_buffer_params
device_only_memory< float > guiding_buffer
RenderBuffers * render_buffers
virtual bool denoise_run(const DenoiseContext &context, const DenoisePass &pass)=0
DenoiserGPU(Device *denoiser_device, const DenoiseParams &params)
bool denoise_filter_guiding_set_fake_albedo(DenoiseContext &context)
virtual bool denoise_filter_guiding_preprocess(DenoiseContext &context)
virtual bool denoise_ensure(DenoiseContext &context)
bool denoise_buffer(const BufferParams &buffer_params, const BufferParams &denoised_buffer_params, RenderBuffers *render_buffers, int num_samples, bool allow_inplace_modification, float2 pixel_jitter) override
bool denoise_filter_color_flip_y(const DenoiseContext &context, const BufferParams &buffer_params, const DenoisePass &pass)
virtual bool denoise_filter_color_postprocess(const DenoiseContext &context, const DenoisePass &pass)
~DenoiserGPU() override
virtual bool denoise_filter_color_preprocess(const DenoiseContext &context, const DenoisePass &pass)
virtual bool denoise_create_if_needed(DenoiseContext &context)=0
unique_ptr< DeviceQueue > denoiser_queue_
bool denoise_filter_guiding_flip_y(const DenoiseContext &context)
bool denoise_pass(DenoiseContext &context, PassType pass_type)
void denoise_color_read(const DenoiseContext &context, const DenoisePass &pass)
virtual bool denoise_configure_if_needed(DenoiseContext &context)=0
DenoiseParams params_
Definition denoiser.h:135
Denoiser(Device *denoiser_device, const DenoiseParams &params)
Definition denoiser.cpp:252
Device * get_denoiser_device() const
Definition denoiser.cpp:309
virtual unique_ptr< DeviceQueue > gpu_queue_create()
bool get_render_tile_pixels(const RenderBuffers *render_buffers, const Destination &destination) const
device_vector< float > buffer
Definition buffers.h:158
BufferParams params
Definition buffers.h:155
bool copy_from_device()
Definition buffers.cpp:286
void copy_to_device()
Definition buffers.cpp:299
void reset(const BufferParams &params)
Definition buffers.cpp:271
size_t size() const
@ DENOISER_PASS_NONE
Definition denoise.h:27
@ DENOISER_PASS_NORMAL
Definition denoise.h:30
@ DENOISER_PASS_ALBEDO
Definition denoise.h:28
@ DENOISER_OPTIX
Definition denoise.h:12
#define PASS_UNUSED
#define CCL_NAMESPACE_END
ccl_gpu_kernel_postfix const ccl_global int ccl_global float const int work_size
if(state< num_states)
PassType
@ PASS_SHADOW_CATCHER_MATTE
@ PASS_SHADOW_CATCHER
@ PASS_MOTION
@ PASS_COMBINED
@ PASS_SAMPLE_COUNT
@ DEVICE_KERNEL_FILTER_COLOR_PREPROCESS
@ DEVICE_KERNEL_FILTER_GUIDING_SET_FAKE_ALBEDO
@ DEVICE_KERNEL_FILTER_COLOR_FLIP_Y
@ DEVICE_KERNEL_FILTER_COLOR_POSTPROCESS
@ DEVICE_KERNEL_FILTER_GUIDING_PREPROCESS
#define DCHECK(expression)
Definition log.h:135
#define LOG_DFATAL
Definition log.h:100
#define LOG_DEBUG
Definition log.h:107
#define LOG_ERROR
Definition log.h:101
CCL_NAMESPACE_BEGIN const char * pass_type_as_string(const PassType type)
Definition pass.cpp:12
@ NOISY
Definition pass.h:21