1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
/*
* Copyright 2011-2021 Blender Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
/* TODO(sergey): The integrator folder might not be the best. Is easy to move files around if the
* better place is figured out. */
#include "device/device.h"
#include "device/device_denoise.h"
#include "util/util_function.h"
#include "util/util_unique_ptr.h"
CCL_NAMESPACE_BEGIN
class BufferParams;
class Device;
class RenderBuffers;
class Progress;
/* Implementation of a specific denoising algorithm.
*
* This class takes care of breaking down denosiing algorithm into a series of device calls or to
* calls of an external API to denoise given input.
*
* TODO(sergey): Are we better with device or a queue here? */
class Denoiser {
public:
/* Create denoiser for the given path trace device.
*
* Notes:
* - The denoiser must be configured. This means that `params.use` must be true.
* This is checked in debug builds.
* - The device might be MultiDevice. */
static unique_ptr<Denoiser> create(Device *path_trace_device, const DenoiseParams ¶ms);
virtual ~Denoiser() = default;
void set_params(const DenoiseParams ¶ms);
const DenoiseParams &get_params() const;
/* Create devices and load kernels needed for denoising.
* The progress is used to communicate state when kenrels actually needs to be loaded.
*
* NOTE: The `progress` is an optional argument, can be nullptr. */
virtual bool load_kernels(Progress *progress);
/* Denoise the entire buffer.
*
* Buffer parameters denotes an effective parameters used during rendering. It could be
* a lower resolution render into a bigger allocated buffer, which is used in viewport during
* navigation and non-unit pixel size. Use that instead of render_buffers->params.
*
* The buffer might be copming from a "foreign" device from what this denoise is created for.
* This means that in general case the denoiser will make sure the input data is available on
* the denoiser device, perform denoising, and put data back to the device where the buffer
* came from.
*
* The `num_samples` corresponds to the number of samples in the render buffers. It is used
* to scale buffers down to the "final" value in algorithms which don't do automatic exposure,
* or which needs "final" value for data passes.
*
* The `allow_inplace_modification` means that the denoiser is allowed to do in-place
* modification of the input passes (scaling them down i.e.). This will lower the memory
* footprint of the denoiser but will make input passes "invalid" (from path tracer) point of
* view.
*
* Returns true when all passes are denoised. Will return false if there is a denoiser error (for
* example, caused by misconfigured denoiser) or when user requested to cancel rendering. */
virtual bool denoise_buffer(const BufferParams &buffer_params,
RenderBuffers *render_buffers,
const int num_samples,
bool allow_inplace_modification) = 0;
/* Get a device which is used to perform actual denoising.
*
* Notes:
*
* - The device is lazily initialized via `load_kernels()`, so it will be nullptr until then,
*
* - The device can be different from the path tracing device. This happens, for example, when
* using OptiX denoiser and rendering on CPU.
*
* - No threading safety is ensured in this call. This means, that it is up to caller to ensure
* that there is no threadingconflict between denoising task lazily initializing the device and
* access to this device happen. */
Device *get_denoiser_device() const;
function<bool(void)> is_cancelled_cb;
bool is_cancelled() const
{
if (!is_cancelled_cb) {
return false;
}
return is_cancelled_cb();
}
protected:
Denoiser(Device *path_trace_device, const DenoiseParams ¶ms);
/* Make sure denoising device is initialized. */
virtual Device *ensure_denoiser_device(Progress *progress);
/* Get device type mask which is used to filter available devices when new device needs to be
* created. */
virtual uint get_device_type_mask() const = 0;
Device *path_trace_device_;
DenoiseParams params_;
/* Cached pointer to the device on which denoising will happen.
* Used to avoid lookup of a device for every denoising request. */
Device *denoiser_device_ = nullptr;
/* Denoiser device which was created to perform denoising in the case the none of the rendering
* devices are capable of denoising. */
unique_ptr<Device> local_denoiser_device_;
bool device_creation_attempted_ = false;
};
CCL_NAMESPACE_END
|
