24#ifdef WITH_OPENIMAGEDENOISE
31#ifndef WITH_OPENIMAGEDENOISE
32 set_error(
"Failed to denoise, build has no OpenImageDenoise support");
34 if (!openimagedenoise_supported()) {
35 set_error(
"OpenImageDenoiser is not supported on this CPU: missing SSE 4.1 support");
40#ifdef WITH_OPENIMAGEDENOISE
41static bool oidn_progress_monitor_function(
void *user_ptr,
double )
51 OIDNPass(
const BufferParams &buffer_params,
55 : name(name), type(type), mode(mode)
68 return name[0] !=
'\0';
74 const char *name =
"";
78 int num_components = -1;
79 bool use_compositing =
false;
80 bool use_denoising_albedo =
true;
92 bool need_scale =
false;
95 bool is_filtered =
false;
98 array<float> scaled_buffer;
101class OIDNDenoiseContext {
102 friend class OIDNDenoiser;
105 OIDNDenoiseContext(OIDNDenoiser *denoiser,
106 const DenoiseParams &denoise_params,
107 const BufferParams &buffer_params,
108 RenderBuffers *render_buffers,
109 const int num_samples,
110 const bool allow_inplace_modification)
111 : denoiser_(denoiser),
112 denoise_params_(denoise_params),
113 buffer_params_(buffer_params),
114 render_buffers_(render_buffers),
115 num_samples_(num_samples),
116 allow_inplace_modification_(allow_inplace_modification),
120 oidn_albedo_pass_ = OIDNPass(buffer_params_,
"albedo", PASS_DENOISING_ALBEDO);
124 oidn_normal_pass_ = OIDNPass(buffer_params_,
"normal", PASS_DENOISING_NORMAL);
128 bool need_denoising()
const
130 if (buffer_params_.width == 0 && buffer_params_.height == 0) {
138 void read_guiding_passes()
140 read_guiding_pass(oidn_albedo_pass_);
141 read_guiding_pass(oidn_normal_pass_);
144 bool denoise_pass(
const PassType pass_type)
146 OIDNPass oidn_color_pass(buffer_params_,
"color", pass_type);
151 if (oidn_color_pass.use_denoising_albedo) {
152 if (albedo_replaced_with_fake_) {
153 LOG_ERROR <<
"Pass which requires albedo is denoised after fake albedo has been set.";
164 OIDNPass oidn_color_access_pass = read_input_pass(oidn_color_pass, oidn_output_pass);
166 if (!denoiser_->base_.oidn_filter_) {
167 denoiser_->set_error(
"OpenImageDenoise filter is not initialized");
171 if (!filter_guiding_pass_if_needed(oidn_albedo_pass_)) {
174 if (!filter_guiding_pass_if_needed(oidn_normal_pass_)) {
178 set_input_pass(denoiser_->base_.oidn_filter_, oidn_color_access_pass);
179 set_guiding_passes(denoiser_->base_.oidn_filter_, oidn_color_pass);
180 set_output_pass(denoiser_->base_.oidn_filter_, oidn_output_pass);
183 oidnSetFilterInt(denoiser_->base_.oidn_filter_,
"cleanAux", clean_aux);
185 if (!denoiser_->commit_and_execute_filter(denoiser_->base_.oidn_filter_)) {
189 postprocess_output(oidn_color_pass, oidn_output_pass);
194 bool filter_guiding_pass_if_needed(OIDNPass &oidn_pass)
197 oidn_pass.is_filtered)
203 denoiser_->base_.albedo_filter_ :
204 denoiser_->base_.normal_filter_;
207 denoiser_->set_error(
"OpenImageDenoise guiding filter is not initialized");
211 set_pass(filter, oidn_pass);
212 set_output_pass(filter, oidn_pass);
214 if (!denoiser_->commit_and_execute_filter(filter)) {
218 oidn_pass.is_filtered =
true;
223 void read_guiding_pass(OIDNPass &oidn_pass)
229 DCHECK(!oidn_pass.use_compositing);
232 !is_pass_scale_needed(oidn_pass))
238 if (allow_inplace_modification_) {
239 scale_pass_in_render_buffers(oidn_pass);
243 read_pass_pixels_into_buffer(oidn_pass);
249 OIDNPass read_input_pass(OIDNPass &oidn_input_pass,
const OIDNPass &oidn_output_pass)
251 const bool use_compositing = oidn_input_pass.use_compositing;
255 if (!use_compositing && !is_pass_scale_needed(oidn_input_pass)) {
256 return oidn_input_pass;
259 float *buffer_data = render_buffers_->buffer.data();
260 float *pass_data = buffer_data + oidn_output_pass.offset;
262 PassAccessor::Destination destination(pass_data, 3);
263 destination.pixel_stride = buffer_params_.pass_stride;
265 read_pass_pixels(oidn_input_pass, destination);
267 OIDNPass oidn_input_pass_at_output = oidn_input_pass;
268 oidn_input_pass_at_output.offset = oidn_output_pass.offset;
270 return oidn_input_pass_at_output;
274 void read_pass_pixels(
const OIDNPass &oidn_pass,
const PassAccessor::Destination &destination)
276 PassAccessor::PassAccessInfo pass_access_info;
277 pass_access_info.
type = oidn_pass.type;
278 pass_access_info.
mode = oidn_pass.mode;
279 pass_access_info.
offset = oidn_pass.offset;
291 const PassAccessorCPU pass_accessor(pass_access_info, 1.0f, num_samples_);
293 BufferParams buffer_params = buffer_params_;
299 pass_accessor.get_render_tile_pixels(render_buffers_, buffer_params, destination);
303 void read_pass_pixels_into_buffer(OIDNPass &oidn_pass)
305 LOG_DEBUG <<
"Allocating temporary buffer for pass " << oidn_pass.name <<
" ("
308 const int64_t width = buffer_params_.width;
309 const int64_t height = buffer_params_.height;
311 array<float> &scaled_buffer = oidn_pass.scaled_buffer;
312 scaled_buffer.
resize(width * height * 3);
314 const PassAccessor::Destination destination(scaled_buffer.
data(), 3);
316 read_pass_pixels(oidn_pass, destination);
321 void set_pass_referenced(OIDNFilter oidn_filter,
const char *name,
const OIDNPass &oidn_pass)
323 const int64_t x = buffer_params_.full_x;
324 const int64_t y = buffer_params_.full_y;
325 const int64_t width = buffer_params_.width;
326 const int64_t height = buffer_params_.height;
327 const int64_t offset = buffer_params_.offset;
328 const int64_t stride = buffer_params_.stride;
329 const int64_t pass_stride = buffer_params_.pass_stride;
331 const int64_t pixel_index = offset +
x +
y * stride;
332 const int64_t buffer_offset = pixel_index * pass_stride;
334 float *buffer_data = render_buffers_->buffer.data();
336 oidnSetSharedFilterImage(oidn_filter,
338 buffer_data + buffer_offset + oidn_pass.offset,
343 pass_stride *
sizeof(
float),
344 stride * pass_stride *
sizeof(
float));
347 void set_pass_from_buffer(OIDNFilter oidn_filter,
const char *name, OIDNPass &oidn_pass)
349 const int64_t width = buffer_params_.width;
350 const int64_t height = buffer_params_.height;
352 oidnSetSharedFilterImage(oidn_filter,
354 oidn_pass.scaled_buffer.data(),
363 void set_pass(OIDNFilter oidn_filter, OIDNPass &oidn_pass)
365 set_pass(oidn_filter, oidn_pass.name, oidn_pass);
367 void set_pass(OIDNFilter oidn_filter,
const char *name, OIDNPass &oidn_pass)
369 if (oidn_pass.scaled_buffer.empty()) {
370 set_pass_referenced(oidn_filter, name, oidn_pass);
373 set_pass_from_buffer(oidn_filter, name, oidn_pass);
377 void set_input_pass(OIDNFilter oidn_filter, OIDNPass &oidn_pass)
379 set_pass_referenced(oidn_filter, oidn_pass.name, oidn_pass);
382 void set_guiding_passes(OIDNFilter oidn_filter, OIDNPass &oidn_pass)
384 if (oidn_albedo_pass_) {
385 if (oidn_pass.use_denoising_albedo) {
386 set_pass(oidn_filter, oidn_albedo_pass_);
391 set_fake_albedo_pass(oidn_filter);
395 if (oidn_normal_pass_) {
396 set_pass(oidn_filter, oidn_normal_pass_);
400 void set_fake_albedo_pass(OIDNFilter oidn_filter)
402 const int64_t width = buffer_params_.width;
403 const int64_t height = buffer_params_.height;
405 if (!albedo_replaced_with_fake_) {
406 const int64_t num_pixel_components = width * height * 3;
407 oidn_albedo_pass_.scaled_buffer.resize(num_pixel_components);
409 for (
int i = 0; i < num_pixel_components; ++i) {
410 oidn_albedo_pass_.scaled_buffer[i] = 0.5f;
413 albedo_replaced_with_fake_ =
true;
416 set_pass(oidn_filter, oidn_albedo_pass_);
419 void set_output_pass(OIDNFilter oidn_filter, OIDNPass &oidn_pass)
421 set_pass(oidn_filter,
"output", oidn_pass);
426 void postprocess_output(
const OIDNPass &oidn_input_pass,
const OIDNPass &oidn_output_pass)
428 kernel_assert(oidn_input_pass.num_components == oidn_output_pass.num_components);
430 const int64_t x = buffer_params_.full_x;
431 const int64_t y = buffer_params_.full_y;
432 const int64_t width = buffer_params_.width;
433 const int64_t height = buffer_params_.height;
434 const int64_t offset = buffer_params_.offset;
435 const int64_t stride = buffer_params_.stride;
436 const int64_t pass_stride = buffer_params_.pass_stride;
437 const int64_t row_stride = stride * pass_stride;
439 const int64_t pixel_offset = offset +
x +
y * stride;
440 const int64_t buffer_offset = (pixel_offset * pass_stride);
442 float *buffer_data = render_buffers_->buffer.data();
444 const bool has_pass_sample_count = (pass_sample_count_ !=
PASS_UNUSED);
445 const bool need_scale = has_pass_sample_count || oidn_input_pass.use_compositing;
447 for (
int y = 0;
y < height; ++
y) {
448 float *buffer_row = buffer_data + buffer_offset +
y * row_stride;
449 for (
int x = 0;
x < width; ++
x) {
450 float *buffer_pixel = buffer_row +
x * pass_stride;
451 float *denoised_pixel = buffer_pixel + oidn_output_pass.offset;
454 const float pixel_scale = has_pass_sample_count ?
458 denoised_pixel[0] = denoised_pixel[0] * pixel_scale;
459 denoised_pixel[1] = denoised_pixel[1] * pixel_scale;
460 denoised_pixel[2] = denoised_pixel[2] * pixel_scale;
463 if (oidn_output_pass.num_components == 3) {
466 else if (!oidn_input_pass.use_compositing) {
470 const float *noisy_pixel = buffer_pixel + oidn_input_pass.offset;
471 denoised_pixel[3] = noisy_pixel[3];
476 denoised_pixel[3] = 0;
482 bool is_pass_scale_needed(OIDNPass &oidn_pass)
const
490 if (!oidn_pass.need_scale) {
494 if (num_samples_ == 1) {
503 void scale_pass_in_render_buffers(OIDNPass &oidn_pass)
505 const int64_t x = buffer_params_.full_x;
506 const int64_t y = buffer_params_.full_y;
507 const int64_t width = buffer_params_.width;
508 const int64_t height = buffer_params_.height;
509 const int64_t offset = buffer_params_.offset;
510 const int64_t stride = buffer_params_.stride;
511 const int64_t pass_stride = buffer_params_.pass_stride;
512 const int64_t row_stride = stride * pass_stride;
514 const int64_t pixel_offset = offset +
x +
y * stride;
515 const int64_t buffer_offset = (pixel_offset * pass_stride);
517 float *buffer_data = render_buffers_->buffer.data();
519 const bool has_pass_sample_count = (pass_sample_count_ !=
PASS_UNUSED);
521 for (
int y = 0;
y < height; ++
y) {
522 float *buffer_row = buffer_data + buffer_offset +
y * row_stride;
523 for (
int x = 0;
x < width; ++
x) {
524 float *buffer_pixel = buffer_row +
x * pass_stride;
525 float *pass_pixel = buffer_pixel + oidn_pass.offset;
527 const float pixel_scale = 1.0f / (has_pass_sample_count ?
531 pass_pixel[0] = pass_pixel[0] * pixel_scale;
532 pass_pixel[1] = pass_pixel[1] * pixel_scale;
533 pass_pixel[2] = pass_pixel[2] * pixel_scale;
538 OIDNDenoiser *denoiser_ =
nullptr;
540 const DenoiseParams &denoise_params_;
541 const BufferParams &buffer_params_;
542 RenderBuffers *render_buffers_ =
nullptr;
543 int num_samples_ = 0;
544 bool allow_inplace_modification_ =
false;
548 OIDNPass oidn_albedo_pass_;
549 OIDNPass oidn_normal_pass_;
554 bool albedo_replaced_with_fake_ =
false;
557bool OIDNDenoiser::commit_and_execute_filter(OIDNFilter filter)
559 const char *error_message =
nullptr;
561 oidnCommitFilter(filter);
562 oidnExecuteFilter(filter);
564 const OIDNError err = oidnGetDeviceError(base_.oidn_device_, &error_message);
565 if (err == OIDN_ERROR_NONE || err == OIDN_ERROR_CANCELLED) {
569 if (error_message ==
nullptr) {
570 error_message =
"Unspecified OIDN error";
573 LOG_ERROR <<
"OIDN error: " << error_message;
578bool OIDNDenoiser::denoise_create_if_needed(
const OIDNDenoiseContext &context)
581 if (!base_.oidn_device_) {
582 base_.oidn_device_ = oidnNewDevice(OIDN_DEVICE_TYPE_CPU);
583 if (!base_.oidn_device_) {
584 set_error(
"Failed to create OIDN CPU device");
587 oidnSetDeviceBool(base_.oidn_device_,
"setAffinity",
false);
588 oidnCommitDevice(base_.oidn_device_);
589 base_.load_custom_weights();
597 const bool recreate_filter = (base_.oidn_filter_ ==
nullptr) ||
598 (base_.use_pass_albedo_ != use_pass_albedo) ||
599 (base_.use_pass_normal_ != use_pass_normal) ||
602 if (!recreate_filter) {
606 if (base_.albedo_filter_) {
607 oidnReleaseFilter(base_.albedo_filter_);
608 base_.albedo_filter_ =
nullptr;
611 if (base_.normal_filter_) {
612 oidnReleaseFilter(base_.normal_filter_);
613 base_.normal_filter_ =
nullptr;
616 if (base_.oidn_filter_) {
617 oidnReleaseFilter(base_.oidn_filter_);
618 base_.oidn_filter_ =
nullptr;
621 if (!base_.create_filters(
params_.
quality, use_pass_albedo, use_pass_normal)) {
625 oidnSetFilterProgressMonitorFunction(base_.oidn_filter_, oidn_progress_monitor_function,
this);
626 if (base_.albedo_filter_) {
627 oidnSetFilterProgressMonitorFunction(
628 base_.albedo_filter_, oidn_progress_monitor_function,
this);
630 if (base_.normal_filter_) {
631 oidnSetFilterProgressMonitorFunction(
632 base_.normal_filter_, oidn_progress_monitor_function,
this);
637bool OIDNDenoiser::denoise_run(OIDNDenoiseContext &context,
const PassType pass_type)
639 return context.denoise_pass(pass_type);
655 queue->copy_from_device(render_buffers->
buffer);
656 queue->synchronize();
667 queue->copy_to_device(render_buffers->
buffer);
668 queue->synchronize();
680 const int num_samples,
681 const bool allow_inplace_modification,
684 DCHECK(openimagedenoise_supported())
685 <<
"OpenImageDenoise is not supported on this platform or build.";
687#ifdef WITH_OPENIMAGEDENOISE
692 copy_render_buffers_from_device(queue, render_buffers);
694 OIDNDenoiseContext context(
695 this,
params_, buffer_params, render_buffers, num_samples, allow_inplace_modification);
697 if (context.need_denoising()) {
698 context.read_guiding_passes();
700 if (!denoise_create_if_needed(context)) {
704 if (!base_.denoise_configure_if_needed(context.buffer_params_.width,
705 context.buffer_params_.height))
710 const std::array<PassType, 3> passes = {
719 for (
const PassType pass_type : passes) {
720 if (!denoise_run(context, pass_type)) {
730 copy_render_buffers_to_device(queue, render_buffers);
734 (void)render_buffers;
736 (void)allow_inplace_modification;
int get_pass_offset(PassType type, PassMode mode=PassMode::NOISY) const
DenoiserPrefilter prefilter
void set_error(const string &error)
Denoiser(Device *denoiser_device, const DenoiseParams ¶ms)
bool is_cancelled() const
virtual unique_ptr< DeviceQueue > gpu_queue_create()
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
OIDNDenoiser(Device *denoiser_device, const DenoiseParams ¶ms)
static thread_mutex mutex_
bool use_approximate_shadow_catcher
bool use_approximate_shadow_catcher_background
PassInfo get_info() const
device_vector< float > buffer
T * resize(const size_t newsize)
@ DENOISER_PREFILTER_FAST
@ DENOISER_PREFILTER_ACCURATE
@ DENOISER_OPENIMAGEDENOISE
#define kernel_assert(cond)
#define CCL_NAMESPACE_END
@ PASS_SHADOW_CATCHER_MATTE
#define DCHECK(expression)
int context(const bContext *C, const char *member, bContextDataResult *result)
DO_INLINE void filter(lfVector *V, fmatrix3x3 *S)
CCL_NAMESPACE_BEGIN const char * pass_type_as_string(const PassType type)
bool use_denoising_albedo
std::unique_lock< std::mutex > thread_scoped_lock