5#if defined(WITH_OPENIMAGEDENOISE)
17# if OIDN_VERSION_MAJOR < 2
18# define oidnSetFilterBool oidnSetFilter1b
19# define oidnSetFilterInt oidnSetFilter1i
20# define oidnExecuteFilterAsync oidnExecuteFilter
25# if OIDN_VERSION < 20300
26static const char *oidn_device_type_to_string(
const OIDNDeviceType type)
29 case OIDN_DEVICE_TYPE_DEFAULT:
31 case OIDN_DEVICE_TYPE_CPU:
35# if OIDN_VERSION_MAJOR >= 2
36 case OIDN_DEVICE_TYPE_SYCL:
38 case OIDN_DEVICE_TYPE_CUDA:
40 case OIDN_DEVICE_TYPE_HIP:
45# if (OIDN_VERSION_MAJOR > 2) || ((OIDN_VERSION_MAJOR == 2) && (OIDN_VERSION_MINOR >= 2))
46 case OIDN_DEVICE_TYPE_METAL:
54bool OIDNDenoiserGPU::is_device_supported(
const DeviceInfo &device)
56# if OIDN_VERSION >= 20300
71 if (multi_device.
type !=
DEVICE_CPU && is_device_supported(multi_device)) {
80 <<
") for OIDN GPU support";
82 int device_type = OIDN_DEVICE_TYPE_DEFAULT;
83 switch (device.
type) {
84# ifdef OIDN_DEVICE_SYCL
86 device_type = OIDN_DEVICE_TYPE_SYCL;
89# ifdef OIDN_DEVICE_HIP
91 device_type = OIDN_DEVICE_TYPE_HIP;
94# ifdef OIDN_DEVICE_CUDA
97 device_type = OIDN_DEVICE_TYPE_CUDA;
100# ifdef OIDN_DEVICE_METAL
102 const int num_devices = oidnGetNumPhysicalDevices();
103 LOG_TRACE <<
"Found " << num_devices <<
" OIDN device(s)";
104 for (
int i = 0; i < num_devices; i++) {
105 const int type = oidnGetPhysicalDeviceInt(i,
"type");
106 const char *name = oidnGetPhysicalDeviceString(i,
"name");
107 LOG_TRACE <<
"OIDN device " << i <<
": name=\"" << name
108 <<
"\", type=" << oidn_device_type_to_string(OIDNDeviceType(type));
109 if (type == OIDN_DEVICE_TYPE_METAL) {
110 if (device.
id.find(name) != std::string::npos) {
111 LOG_TRACE <<
"OIDN device name matches the Cycles device name";
116 LOG_TRACE <<
"No matched OIDN device found";
128 const int num_devices = oidnGetNumPhysicalDevices();
129 LOG_TRACE <<
"Found " << num_devices <<
" OIDN device(s)";
130 for (
int i = 0; i < num_devices; i++) {
131 const int type = oidnGetPhysicalDeviceInt(i,
"type");
132 const char *name = oidnGetPhysicalDeviceString(i,
"name");
133 LOG_TRACE <<
"OIDN device " << i <<
": name=\"" << name
134 <<
"\" type=" << oidn_device_type_to_string(OIDNDeviceType(type));
135 if (type == device_type) {
136 if (oidnGetPhysicalDeviceBool(i,
"pciAddressSupported")) {
137 unsigned int pci_domain = oidnGetPhysicalDeviceInt(i,
"pciDomain");
138 unsigned int pci_bus = oidnGetPhysicalDeviceInt(i,
"pciBus");
139 unsigned int pci_device = oidnGetPhysicalDeviceInt(i,
"pciDevice");
140 string pci_id =
string_printf(
"%04x:%02x:%02x", pci_domain, pci_bus, pci_device);
141 LOG_INFO <<
"OIDN device PCI-e identifier: " << pci_id;
142 if (device.
id.find(pci_id) != string::npos) {
143 LOG_TRACE <<
"OIDN device PCI-e identifier matches the Cycles device ID";
148 LOG_TRACE <<
"Device does not support pciAddressSupported";
152 LOG_TRACE <<
"No matched OIDN device found";
158 :
DenoiserGPU(denoiser_device, params), base_(this)
163bool OIDNDenoiserGPU::commit_and_execute_filter(OIDNFilter filter, ExecMode mode)
165 const char *error_message =
nullptr;
166 OIDNError err = OIDN_ERROR_NONE;
169 oidnCommitFilter(filter);
170 if (mode == ExecMode::ASYNC) {
171 oidnExecuteFilterAsync(filter);
174 oidnExecuteFilter(filter);
178 err = oidnGetDeviceError(base_.oidn_device_, &error_message);
179 if (err != OIDN_ERROR_OUT_OF_MEMORY || max_mem_ < 200) {
182 max_mem_ = max_mem_ / 2;
183 oidnSetFilterInt(filter,
"maxMemoryMB", max_mem_);
186 if (err != OIDN_ERROR_NONE) {
187 if (error_message ==
nullptr) {
188 error_message =
"Unspecified OIDN error";
190 LOG_ERROR <<
"OIDN error: " << error_message;
191 set_error(error_message);
197bool OIDNDenoiserGPU::denoise_create_if_needed(DenoiseContext &context)
202 const bool recreate_denoiser = (base_.oidn_device_ ==
nullptr) ||
203 (base_.oidn_filter_ ==
nullptr) ||
204 (base_.use_pass_albedo_ != use_pass_albedo) ||
205 (base_.use_pass_normal_ != use_pass_normal) ||
206 (base_.quality_ != params_.quality);
207 if (!recreate_denoiser) {
212 base_.release_all_resources();
214 switch (denoiser_device_->info.type) {
215# if defined(OIDN_DEVICE_SYCL) && defined(WITH_ONEAPI)
217 base_.oidn_device_ = oidnNewSYCLDevice(
218 (
const sycl::queue *)
reinterpret_cast<OneapiDevice *
>(denoiser_device_)->sycl_queue(),
222# if defined(OIDN_DEVICE_METAL) && defined(WITH_METAL)
224 denoiser_queue_->init_execution();
225 const MTLCommandQueue_id queue = (
const MTLCommandQueue_id)denoiser_queue_->native_queue();
226 base_.oidn_device_ = oidnNewMetalDevice(&queue, 1);
229# if defined(OIDN_DEVICE_CUDA) && defined(WITH_CUDA)
233 cudaStream_t stream =
nullptr;
234 base_.oidn_device_ = oidnNewCUDADevice(&denoiser_device_->info.num, &stream, 1);
238# if defined(OIDN_DEVICE_HIP) && defined(WITH_HIP)
240 hipStream_t stream =
nullptr;
241 base_.oidn_device_ = oidnNewHIPDevice(&denoiser_device_->info.num, &stream, 1);
249 if (!base_.oidn_device_) {
250 set_error(
"Failed to create OIDN device");
254 if (denoiser_queue_) {
255 denoiser_queue_->init_execution();
258 oidnCommitDevice(base_.oidn_device_);
259 base_.load_custom_weights();
260 return base_.create_filters(params_.quality, use_pass_albedo, use_pass_normal);
263bool OIDNDenoiserGPU::denoise_configure_if_needed(DenoiseContext &context)
266 return base_.denoise_configure_if_needed(
context.buffer_params.width,
270bool OIDNDenoiserGPU::denoise_run(
const DenoiseContext &context,
const DenoisePass &pass)
275 set_filter_pass(base_.oidn_filter_,
277 context.render_buffers->buffer.device_pointer,
281 pass.denoised_offset *
sizeof(
float),
282 pass_stride_in_bytes,
283 pass_stride_in_bytes *
context.buffer_params.stride);
285 set_filter_pass(base_.oidn_filter_,
287 context.render_buffers->buffer.device_pointer,
291 pass.denoised_offset *
sizeof(
float),
292 pass_stride_in_bytes,
293 pass_stride_in_bytes *
context.buffer_params.stride);
298 const int64_t row_stride_in_bytes =
context.guiding_params.stride * pixel_stride_in_bytes;
300 if (base_.use_pass_albedo_) {
301 set_filter_pass(base_.oidn_filter_,
307 context.guiding_params.pass_albedo *
sizeof(
float),
308 pixel_stride_in_bytes,
309 row_stride_in_bytes);
312 set_filter_pass(base_.albedo_filter_,
318 context.guiding_params.pass_albedo *
sizeof(
float),
319 pixel_stride_in_bytes,
320 row_stride_in_bytes);
322 set_filter_pass(base_.albedo_filter_,
328 context.guiding_params.pass_albedo *
sizeof(
float),
329 pixel_stride_in_bytes,
330 row_stride_in_bytes);
332 if (!commit_and_execute_filter(base_.albedo_filter_, ExecMode::ASYNC)) {
338 if (base_.use_pass_normal_) {
339 set_filter_pass(base_.oidn_filter_,
345 context.guiding_params.pass_normal *
sizeof(
float),
346 pixel_stride_in_bytes,
347 row_stride_in_bytes);
350 set_filter_pass(base_.normal_filter_,
356 context.guiding_params.pass_normal *
sizeof(
float),
357 pixel_stride_in_bytes,
358 row_stride_in_bytes);
360 set_filter_pass(base_.normal_filter_,
366 context.guiding_params.pass_normal *
sizeof(
float),
367 pixel_stride_in_bytes,
368 row_stride_in_bytes);
370 if (!commit_and_execute_filter(base_.normal_filter_, ExecMode::ASYNC)) {
377 return commit_and_execute_filter(base_.oidn_filter_);
380void OIDNDenoiserGPU::set_filter_pass(OIDNFilter filter,
386 const size_t offset_in_bytes,
387 const size_t pixel_stride_in_bytes,
388 const size_t row_stride_in_bytes)
390# if defined(OIDN_DEVICE_METAL) && defined(WITH_METAL)
392 void *mtl_buffer = denoiser_device_->get_native_buffer(ptr);
393 OIDNBuffer oidn_buffer = oidnNewSharedBufferFromMetal(base_.oidn_device_, mtl_buffer);
395 oidnSetFilterImage(filter,
402 pixel_stride_in_bytes,
403 row_stride_in_bytes);
405 oidnReleaseBuffer(oidn_buffer);
410 oidnSetSharedFilterImage(filter,
417 pixel_stride_in_bytes,
418 row_stride_in_bytes);
vector< DeviceInfo > multi_devices
DenoiserTypeMask denoisers
@ DENOISER_PREFILTER_FAST
@ DENOISER_PREFILTER_ACCURATE
@ DENOISER_OPENIMAGEDENOISE
#define CCL_NAMESPACE_END
#define assert(assertion)
int context(const bContext *C, const char *member, bContextDataResult *result)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
CCL_NAMESPACE_BEGIN string string_printf(const char *format,...)