godot/thirdparty/oidn/include/OpenImageDenoise/oidn.hpp

469 lines
13 KiB
C++
Raw Normal View History

// ======================================================================== //
// Copyright 2009-2019 Intel Corporation //
// //
// 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
#include <algorithm>
#include "oidn.h"
namespace oidn {
// --------------------------------------------------------------------------
// Buffer
// --------------------------------------------------------------------------
// Formats for images and other data stored in buffers
enum class Format
{
Undefined = OIDN_FORMAT_UNDEFINED,
// 32-bit single-precision floating point scalar and vector formats
Float = OIDN_FORMAT_FLOAT,
Float2 = OIDN_FORMAT_FLOAT2,
Float3 = OIDN_FORMAT_FLOAT3,
Float4 = OIDN_FORMAT_FLOAT4,
};
// Access modes for mapping buffers
enum class Access
{
Read = OIDN_ACCESS_READ, // read-only access
Write = OIDN_ACCESS_WRITE, // write-only access
ReadWrite = OIDN_ACCESS_READ_WRITE, // read and write access
WriteDiscard = OIDN_ACCESS_WRITE_DISCARD, // write-only access, previous contents discarded
};
// Buffer object with automatic reference counting
class BufferRef
{
private:
OIDNBuffer handle;
public:
BufferRef() : handle(nullptr) {}
BufferRef(OIDNBuffer handle) : handle(handle) {}
BufferRef(const BufferRef& other) : handle(other.handle)
{
if (handle)
oidnRetainBuffer(handle);
}
BufferRef(BufferRef&& other) : handle(other.handle)
{
other.handle = nullptr;
}
BufferRef& operator =(const BufferRef& other)
{
if (&other != this)
{
if (other.handle)
oidnRetainBuffer(other.handle);
if (handle)
oidnReleaseBuffer(handle);
handle = other.handle;
}
return *this;
}
BufferRef& operator =(BufferRef&& other)
{
std::swap(handle, other.handle);
return *this;
}
BufferRef& operator =(OIDNBuffer other)
{
if (other)
oidnRetainBuffer(other);
if (handle)
oidnReleaseBuffer(handle);
handle = other;
return *this;
}
~BufferRef()
{
if (handle)
oidnReleaseBuffer(handle);
}
OIDNBuffer getHandle() const
{
return handle;
}
operator bool() const
{
return handle != nullptr;
}
// Maps a region of the buffer to host memory.
// If byteSize is 0, the maximum available amount of memory will be mapped.
void* map(Access access = Access::ReadWrite, size_t byteOffset = 0, size_t byteSize = 0)
{
return oidnMapBuffer(handle, (OIDNAccess)access, byteOffset, byteSize);
}
// Unmaps a region of the buffer.
// mappedPtr must be a pointer returned by a previous call to map.
void unmap(void* mappedPtr)
{
oidnUnmapBuffer(handle, mappedPtr);
}
};
// --------------------------------------------------------------------------
// Filter
// --------------------------------------------------------------------------
// Progress monitor callback function
typedef bool (*ProgressMonitorFunction)(void* userPtr, double n);
// Filter object with automatic reference counting
class FilterRef
{
private:
OIDNFilter handle;
public:
FilterRef() : handle(nullptr) {}
FilterRef(OIDNFilter handle) : handle(handle) {}
FilterRef(const FilterRef& other) : handle(other.handle)
{
if (handle)
oidnRetainFilter(handle);
}
FilterRef(FilterRef&& other) : handle(other.handle)
{
other.handle = nullptr;
}
FilterRef& operator =(const FilterRef& other)
{
if (&other != this)
{
if (other.handle)
oidnRetainFilter(other.handle);
if (handle)
oidnReleaseFilter(handle);
handle = other.handle;
}
return *this;
}
FilterRef& operator =(FilterRef&& other)
{
std::swap(handle, other.handle);
return *this;
}
FilterRef& operator =(OIDNFilter other)
{
if (other)
oidnRetainFilter(other);
if (handle)
oidnReleaseFilter(handle);
handle = other;
return *this;
}
~FilterRef()
{
if (handle)
oidnReleaseFilter(handle);
}
OIDNFilter getHandle() const
{
return handle;
}
operator bool() const
{
return handle != nullptr;
}
// Sets an image parameter of the filter (stored in a buffer).
void setImage(const char* name,
const BufferRef& buffer, Format format,
size_t width, size_t height,
size_t byteOffset = 0,
size_t bytePixelStride = 0, size_t byteRowStride = 0)
{
oidnSetFilterImage(handle, name,
buffer.getHandle(), (OIDNFormat)format,
width, height,
byteOffset,
bytePixelStride, byteRowStride);
}
// Sets an image parameter of the filter (owned by the user).
void setImage(const char* name,
void* ptr, Format format,
size_t width, size_t height,
size_t byteOffset = 0,
size_t bytePixelStride = 0, size_t byteRowStride = 0)
{
oidnSetSharedFilterImage(handle, name,
ptr, (OIDNFormat)format,
width, height,
byteOffset,
bytePixelStride, byteRowStride);
}
// Sets a boolean parameter of the filter.
void set(const char* name, bool value)
{
oidnSetFilter1b(handle, name, value);
}
// Sets an integer parameter of the filter.
void set(const char* name, int value)
{
oidnSetFilter1i(handle, name, value);
}
// Sets a float parameter of the filter.
void set(const char* name, float value)
{
oidnSetFilter1f(handle, name, value);
}
// Gets a parameter of the filter.
template<typename T>
T get(const char* name);
// Sets the progress monitor callback function of the filter.
void setProgressMonitorFunction(ProgressMonitorFunction func, void* userPtr = nullptr)
{
oidnSetFilterProgressMonitorFunction(handle, (OIDNProgressMonitorFunction)func, userPtr);
}
// Commits all previous changes to the filter.
void commit()
{
oidnCommitFilter(handle);
}
// Executes the filter.
void execute()
{
oidnExecuteFilter(handle);
}
};
// Gets a boolean parameter of the filter.
template<>
inline bool FilterRef::get(const char* name)
{
return oidnGetFilter1b(handle, name);
}
// Gets an integer parameter of the filter.
template<>
inline int FilterRef::get(const char* name)
{
return oidnGetFilter1i(handle, name);
}
// Gets a float parameter of the filter.
template<>
inline float FilterRef::get(const char* name)
{
return oidnGetFilter1f(handle, name);
}
// --------------------------------------------------------------------------
// Device
// --------------------------------------------------------------------------
// Device types
enum class DeviceType
{
Default = OIDN_DEVICE_TYPE_DEFAULT, // select device automatically
CPU = OIDN_DEVICE_TYPE_CPU, // CPU device
};
// Error codes
enum class Error
{
None = OIDN_ERROR_NONE, // no error occurred
Unknown = OIDN_ERROR_UNKNOWN, // an unknown error occurred
InvalidArgument = OIDN_ERROR_INVALID_ARGUMENT, // an invalid argument was specified
InvalidOperation = OIDN_ERROR_INVALID_OPERATION, // the operation is not allowed
OutOfMemory = OIDN_ERROR_OUT_OF_MEMORY, // not enough memory to execute the operation
UnsupportedHardware = OIDN_ERROR_UNSUPPORTED_HARDWARE, // the hardware (e.g. CPU) is not supported
Cancelled = OIDN_ERROR_CANCELLED, // the operation was cancelled by the user
};
// Error callback function
typedef void (*ErrorFunction)(void* userPtr, Error code, const char* message);
// Device object with automatic reference counting
class DeviceRef
{
private:
OIDNDevice handle;
public:
DeviceRef() : handle(nullptr) {}
DeviceRef(OIDNDevice handle) : handle(handle) {}
DeviceRef(const DeviceRef& other) : handle(other.handle)
{
if (handle)
oidnRetainDevice(handle);
}
DeviceRef(DeviceRef&& other) : handle(other.handle)
{
other.handle = nullptr;
}
DeviceRef& operator =(const DeviceRef& other)
{
if (&other != this)
{
if (other.handle)
oidnRetainDevice(other.handle);
if (handle)
oidnReleaseDevice(handle);
handle = other.handle;
}
return *this;
}
DeviceRef& operator =(DeviceRef&& other)
{
std::swap(handle, other.handle);
return *this;
}
DeviceRef& operator =(OIDNDevice other)
{
if (other)
oidnRetainDevice(other);
if (handle)
oidnReleaseDevice(handle);
handle = other;
return *this;
}
~DeviceRef()
{
if (handle)
oidnReleaseDevice(handle);
}
OIDNDevice getHandle() const
{
return handle;
}
operator bool() const
{
return handle != nullptr;
}
// Sets a boolean parameter of the device.
void set(const char* name, bool value)
{
oidnSetDevice1b(handle, name, value);
}
// Sets an integer parameter of the device.
void set(const char* name, int value)
{
oidnSetDevice1i(handle, name, value);
}
// Gets a parameter of the device.
template<typename T>
T get(const char* name);
// Sets the error callback function of the device.
void setErrorFunction(ErrorFunction func, void* userPtr = nullptr)
{
oidnSetDeviceErrorFunction(handle, (OIDNErrorFunction)func, userPtr);
}
// Returns the first unqueried error code and clears the stored error.
// Can be called for a null device as well to check why a device creation failed.
Error getError()
{
return (Error)oidnGetDeviceError(handle, nullptr);
}
// Returns the first unqueried error code and string message, and clears the stored error.
// Can be called for a null device as well to check why a device creation failed.
Error getError(const char*& outMessage)
{
return (Error)oidnGetDeviceError(handle, &outMessage);
}
// Commits all previous changes to the device.
// Must be called before first using the device (e.g. creating filters).
void commit()
{
oidnCommitDevice(handle);
}
// Creates a new buffer (data allocated and owned by the device).
BufferRef newBuffer(size_t byteSize)
{
return oidnNewBuffer(handle, byteSize);
}
// Creates a new shared buffer (data allocated and owned by the user).
BufferRef newBuffer(void* ptr, size_t byteSize)
{
return oidnNewSharedBuffer(handle, ptr, byteSize);
}
// Creates a new filter of the specified type (e.g. "RT").
FilterRef newFilter(const char* type)
{
return oidnNewFilter(handle, type);
}
};
// Gets a boolean parameter of the device.
template<>
inline bool DeviceRef::get(const char* name)
{
return oidnGetDevice1b(handle, name);
}
// Gets an integer parameter of the device (e.g. "version").
template<>
inline int DeviceRef::get(const char* name)
{
return oidnGetDevice1i(handle, name);
}
// Creates a new device.
inline DeviceRef newDevice(DeviceType type = DeviceType::Default)
{
return DeviceRef(oidnNewDevice((OIDNDeviceType)type));
}
} // namespace oidn