Remove denoise module and thirdparty OIDN.

This is replaced by a much lighter weight and faster JNLM denoiser. OIDN is still much more accurate, and may be provided as an optional backend in the future, but the JNLM denoiser seems good enough for most use cases and removing OIDN reduces the build system complexity, binary size, and build times very significantly.

1 files changed, 0 insertions, 436 deletions

diff --git a/thirdparty/oidn/core/network.cpp b/thirdparty/oidn/core/network.cpp
deleted file mode 100644
index ed8328c954..0000000000
--- a/thirdparty/oidn/core/network.cpp
+++ /dev/null
@@ -1,436 +0,0 @@
-// ======================================================================== //
-// 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.                                           //
-// ======================================================================== //
-
-#include "upsample.h"
-#include "weights_reorder.h"
-#include "network.h"
-// -- GODOT start -- 
-#include <cstring>
-// -- GODOT end --
-
-namespace oidn {
-
-  template<int K>
-  Network<K>::Network(const Ref<Device>& device, const std::map<std::string, Tensor>& weightMap)
-    : device(device),
-      eng(engine::cpu, 0),
-      sm(eng),
-      weightMap(weightMap)
-  {
-  }
-
-  template<int K>
-  void Network<K>::execute(const Progress& progress, int taskIndex)
-  {
-    if (progress.func)
-    {
-      const double value = double(taskIndex) / double(progress.taskCount);
-      if (!progress.func(progress.userPtr, value))
-        throw Exception(Error::Cancelled, "execution was cancelled");
-    }
-
-    for (size_t i = 0; i < nodes.size(); ++i)
-    {
-      nodes[i]->execute(sm);
-
-      if (progress.func)
-      {
-        const double value = (double(taskIndex) + double(i+1) / double(nodes.size())) / double(progress.taskCount);
-        if (!progress.func(progress.userPtr, value))
-          throw Exception(Error::Cancelled, "execution was cancelled");
-      }
-    }
-  }
-
-  template<int K>
-  std::shared_ptr<memory> Network<K>::allocTensor(const memory::dims& dims,
-                                                  memory::format_tag format,
-                                                  void* data)
-  {
-    if (format == memory::format_tag::any)
-    {
-      if (dims.size() == 4)
-        format = BlockedFormat<K>::nChwKc;
-      else if (dims.size() == 1)
-        format = memory::format_tag::x;
-      else
-        assert(0);
-    }
-    memory::desc desc(dims, memory::data_type::f32, format);
-    if (data == nullptr)
-    {
-      const size_t bytes = getTensorSize(dims) * sizeof(float);
-      if (format == BlockedFormat<K>::nChwKc)
-        activationAllocBytes += bytes;
-      totalAllocBytes += bytes;
-
-      return std::make_shared<memory>(desc, eng);
-    }
-    else
-    {
-      return std::make_shared<memory>(desc, eng, data);
-    }
-  }
-
-  template<int K>
-  std::shared_ptr<memory> Network<K>::castTensor(const memory::dims& dims,
-                                                 const std::shared_ptr<memory>& src,
-                                                 size_t srcOffset,
-                                                 memory::format_tag format)
-  {
-    const mkldnn_memory_desc_t& srcDesc = src->get_desc().data;
-    MAYBE_UNUSED(srcDesc);
-    assert(srcDesc.data_type == memory::data_type::f32);
-    assert(getTensorSize(src) >= srcOffset + getTensorSize(dims));
-
-    if (format == memory::format_tag::any)
-    {
-      if (dims.size() == 4)
-        format = BlockedFormat<K>::nChwKc;
-      else if (dims.size() == 1)
-        format = memory::format_tag::x;
-      else
-        assert(0);
-    }
-    memory::desc desc(dims, memory::data_type::f32, format);
-    float* srcPtr = (float*)src->get_data_handle() + srcOffset;
-    return std::make_shared<memory>(desc, eng, srcPtr);
-  }
-
-  template<int K>
-  std::shared_ptr<memory> Network<K>::castTensor(const memory::dims& dims,
-                                                 const std::shared_ptr<memory>& src,
-                                                 const memory::dims& srcOffset)
-  {
-    return castTensor(dims, src, getTensorSize(srcOffset));
-  }
-
-  template<int K>
-  void Network<K>::zeroTensor(const std::shared_ptr<memory>& dst)
-  {
-    assert(getTensorType(dst) == memory::data_type::f32);
-    memset(dst->get_data_handle(), 0, getTensorSize(dst)*sizeof(float));
-  }
-
-  template<int K>
-  memory::dims Network<K>::getInputReorderDims(const memory::dims& srcDims, int alignment)
-  {
-    memory::dims dstDims = srcDims;
-    dstDims[1] = getPadded<K>(srcDims[1]); // round up C
-    dstDims[2] = roundUp(srcDims[2], memory::dim(alignment)); // round up H
-    dstDims[3] = roundUp(srcDims[3], memory::dim(alignment)); // round up W
-    return dstDims;
-  }
-
-  template<int K>
-  std::shared_ptr<Node> Network<K>::addInputReorder(const Image& color,
-                                                    const Image& albedo,
-                                                    const Image& normal,
-                                                    const std::shared_ptr<TransferFunction>& transferFunc,
-                                                    int alignment,
-                                                    const std::shared_ptr<memory>& userDst)
-  {
-    assert(color);
-    int inputC = 3;
-    if (albedo) inputC += 3;
-    if (normal) inputC += 3;
-
-    memory::dims srcDims = {1, inputC, color.height, color.width};
-    memory::dims dstDims = getInputReorderDims(srcDims, alignment);
-
-    // Allocate padded memory
-    auto dst = userDst;
-    if (!dst)
-      dst = allocTensor(dstDims);
-
-    // Push node
-    std::shared_ptr<Node> node;
-
-    if (auto tf = std::dynamic_pointer_cast<LinearTransferFunction>(transferFunc))
-      node = std::make_shared<InputReorderNode<K, LinearTransferFunction>>(color, albedo, normal, dst, tf);
-    else if (auto tf = std::dynamic_pointer_cast<GammaTransferFunction>(transferFunc))
-      node = std::make_shared<InputReorderNode<K, GammaTransferFunction>>(color, albedo, normal, dst, tf);
-    else if (auto tf = std::dynamic_pointer_cast<LogTransferFunction>(transferFunc))
-      node = std::make_shared<InputReorderNode<K, LogTransferFunction>>(color, albedo, normal, dst, tf);
-    else if (auto tf = std::dynamic_pointer_cast<PQXTransferFunction>(transferFunc))
-      node = std::make_shared<InputReorderNode<K, PQXTransferFunction>>(color, albedo, normal, dst, tf);
-    else
-      assert(0);
-
-    nodes.push_back(node);
-    return node;
-  }
-
-  template<int K>
-  std::shared_ptr<Node> Network<K>::addOutputReorder(const std::shared_ptr<memory>& src,
-                                                     const std::shared_ptr<TransferFunction>& transferFunc,
-                                                     const Image& output)
-  {
-    memory::dims srcDims = getTensorDims(src);
-    assert(srcDims[1] == K);
-
-    // Push node
-    std::shared_ptr<Node> node;
-
-    if (auto tf = std::dynamic_pointer_cast<LinearTransferFunction>(transferFunc))
-      node = std::make_shared<OutputReorderNode<K, LinearTransferFunction>>(src, output, tf);
-    else if (auto tf = std::dynamic_pointer_cast<GammaTransferFunction>(transferFunc))
-      node = std::make_shared<OutputReorderNode<K, GammaTransferFunction>>(src, output, tf);
-    else if (auto tf = std::dynamic_pointer_cast<LogTransferFunction>(transferFunc))
-      node = std::make_shared<OutputReorderNode<K, LogTransferFunction>>(src, output, tf);
-    else if (auto tf = std::dynamic_pointer_cast<PQXTransferFunction>(transferFunc))
-      node = std::make_shared<OutputReorderNode<K, PQXTransferFunction>>(src, output, tf);
-    else
-      assert(0);
-
-    nodes.push_back(node);
-    return node;
-  }
-
-  template<int K>
-  memory::dims Network<K>::getConvDims(const std::string& name, const memory::dims& srcDims)
-  {
-    auto b = weightMap[name + "/b"];
-    memory::dims dstDims = srcDims;
-    dstDims[1] = getPadded<K>(b.dims[0]); // dstDims[C] = getPadded(OC)
-    return dstDims;
-  }
-
-  template<int K>
-  std::shared_ptr<Node> Network<K>::addConv(const std::string& name,
-                                            const std::shared_ptr<memory>& src,
-                                            const std::shared_ptr<memory>& userDst,
-                                            bool relu)
-  {
-    const memory::dims strides = {1, 1};
-    const memory::dims padding = {1, 1};
-
-    memory::dims srcDims = getTensorDims(src);
-
-    // Get the weights
-    const auto& W = weightMap[name + "/W"];
-    if (W.ndims() != 4 || W.format != "oihw")
-      throw Exception(Error::InvalidOperation, "invalid convolution weights");
-    memory::dims weightsDims = W.dims;
-    auto userWeights = allocTensor(weightsDims, memory::format_tag::oihw, W.data);
-
-    // Pad the weights
-    memory::dims weightsPadDims = weightsDims;
-    weightsPadDims[1] = getPadded<K>(weightsDims[1]); // IC
-    weightsPadDims[0] = getPadded<K>(weightsDims[0]); // OC
-    assert(srcDims[1] == weightsPadDims[1]); // srcDims[C] == weightsPadDims[IC]
-    auto weightsPad = allocTensor(weightsPadDims, memory::format_tag::oihw);
-    WeightsReorderNode<K>(userWeights, weightsPad).execute(sm);
-
-    // Get the biases
-    const auto& b = weightMap[name + "/b"];
-    if (b.ndims() != 1)
-      throw Exception(Error::InvalidOperation, "invalid convolution biases");
-    memory::dims biasDims = b.dims;
-
-    // Copy/pad the biases
-    memory::dims biasPadDims = {getPadded<K>(biasDims[0])};
-    auto bias = allocTensor(biasPadDims);
-    if (biasDims[0] != biasPadDims[0])
-      memset(bias->get_data_handle(), 0, biasPadDims[0]*sizeof(float));
-    memcpy(bias->get_data_handle(), b.data, biasDims[0]*sizeof(float));
-
-    // Allocate memory for destination
-    memory::dims dstDims = srcDims;
-    dstDims[1] = weightsPadDims[0]; // dstDims[C] = weightsPadDims[OC]
-
-    std::shared_ptr<memory> dst;
-    if (!userDst)
-      dst = allocTensor(dstDims);
-    else if (getTensorDims(userDst) == dstDims)
-      dst = userDst;
-    else
-      dst = castTensor(dstDims, userDst);
-
-    // Create a convolution
-    // Let the convolution primitive choose the weights format
-    auto weightsDesc = memory::desc({ weightsPadDims }, memory::data_type::f32, memory::format_tag::any);
-
-    auto convAlgo = (K == 16) ? convolution_winograd : convolution_direct;
-    auto convDesc = convolution_forward::desc(
-      prop_kind::forward_inference, convAlgo,
-      src->get_desc(),
-      weightsDesc,
-      bias->get_desc(),
-      dst->get_desc(),
-      strides, padding, padding, padding_kind::zero);
-
-    // Incorporate relu
-    mkldnn::primitive_attr convAttr;
-    if (relu)
-    {
-      mkldnn::post_ops ops;
-      ops.append_eltwise(
-        1.f,   // scale factor, not used
-        algorithm::eltwise_relu,
-        0.f,   // max with
-        0.f    // unused
-      );
-      convAttr.set_post_ops(ops);
-    }
-    convAttr.set_scratchpad_mode(scratchpad_mode_user);
-
-    auto convPrimDesc = convolution_forward::primitive_desc(convDesc, convAttr, eng);
-
-    // Reorder the weights to the final format, if necessary
-    auto weights = weightsPad;
-    if (convPrimDesc.weights_desc() != weightsPad->get_desc())
-    {
-      weights = std::make_shared<memory>(convPrimDesc.weights_desc(), eng);
-      ReorderNode(weightsPad, weights).execute(sm);
-    }
-
-    // Create convolution node and add it to the net
-    auto node = std::make_shared<ConvNode>(convPrimDesc, src, weights, bias, dst);
-    nodes.push_back(node);
-    return node;
-  }
-
-  template<int K>
-  memory::dims Network<K>::getPoolDims(const memory::dims& srcDims)
-  {
-    memory::dims dstDims = srcDims;
-    dstDims[2] /= 2; // H/2
-    dstDims[3] /= 2; // W/2
-    return dstDims;
-  }
-
-  template<int K>
-  std::shared_ptr<Node> Network<K>::addPool(const std::shared_ptr<memory>& src,
-                                            const std::shared_ptr<memory>& userDst)
-  {
-    const memory::dims kernel  = {2, 2};
-    const memory::dims strides = {2, 2};
-    const memory::dims padding = {0, 0};
-
-    memory::dims srcDims = getTensorDims(src);
-    memory::dims dstDims = getPoolDims(srcDims);
-
-    std::shared_ptr<memory> dst;
-    if (!userDst)
-      dst = allocTensor(dstDims);
-    else if (getTensorDims(userDst) == dstDims)
-      dst = userDst;
-    else
-      dst = castTensor(dstDims, userDst);
-
-    auto poolDesc = pooling_forward::desc(
-      prop_kind::forward_inference, pooling_max,
-      src->get_desc(),
-      dst->get_desc(),
-      strides, kernel, padding, padding, padding_kind::zero);
-
-    mkldnn::primitive_attr poolAttr;
-    poolAttr.set_scratchpad_mode(scratchpad_mode_user);
-
-    auto poolPrimDesc = pooling_forward::primitive_desc(poolDesc, poolAttr, eng);
-
-    auto node = std::make_shared<PoolNode>(poolPrimDesc, src, dst);
-    nodes.push_back(node);
-    return node;
-  }
-
-  template<int K>
-  memory::dims Network<K>::getUpsampleDims(const memory::dims& srcDims)
-  {
-    memory::dims dstDims = srcDims;
-    dstDims[2] *= 2; // H*2
-    dstDims[3] *= 2; // W*2
-    return dstDims;
-  }
-
-  template<int K>
-  std::shared_ptr<Node> Network<K>::addUpsample(const std::shared_ptr<memory>& src,
-                                                const std::shared_ptr<memory>& userDst)
-  {
-    memory::dims srcDims = getTensorDims(src);
-    memory::dims dstDims = getUpsampleDims(srcDims);
-
-    std::shared_ptr<memory> dst;
-    if (!userDst)
-      dst = allocTensor(dstDims);
-    else if (getTensorDims(userDst) == dstDims)
-      dst = userDst;
-    else
-      dst = castTensor(dstDims, userDst);
-
-    // Create upsampling node and add it to net
-    auto node = std::make_shared<UpsampleNode<K>>(src, dst);
-    nodes.push_back(node);
-    return node;
-  }
-
-  template<int K>
-  memory::dims Network<K>::getConcatDims(const memory::dims& src1Dims, const memory::dims& src2Dims)
-  {
-    assert(src1Dims[0] == src2Dims[0]); // N
-    assert(src1Dims[2] == src2Dims[2]); // H
-    assert(src1Dims[3] == src2Dims[3]); // W
-
-    memory::dims dstDims = src1Dims;
-    dstDims[1] += src2Dims[1]; // C
-    return dstDims;
-  }
-
-  template<int K>
-  std::shared_ptr<Node> Network<K>::addAutoexposure(const Image& color,
-                                                    const std::shared_ptr<HDRTransferFunction>& transferFunc)
-  {
-    auto node = std::make_shared<AutoexposureNode>(color, transferFunc);
-    nodes.push_back(node);
-    return node;
-  }
-
-  template <int K>
-  void Network<K>::finalize()
-  {
-    // Compute the size of the scratchpad
-    size_t scratchpadSize = 0;
-    for (const auto& node : nodes)
-      scratchpadSize = max(scratchpadSize, node->getScratchpadSize());
-
-    // Allocate the scratchpad
-    memory::dims scratchpadDims = { memory::dim(scratchpadSize) };
-    memory::desc scratchpadDesc(scratchpadDims, memory::data_type::u8, memory::format_tag::x);
-    auto scratchpad = std::make_shared<memory>(scratchpadDesc, eng);
-    activationAllocBytes += scratchpadSize;
-    totalAllocBytes += scratchpadSize;
-
-    // Set the scratchpad for the nodes
-    for (auto& node : nodes)
-      node->setScratchpad(scratchpad);
-
-    // Free the weights
-    weightMap.clear();
-
-    // Print statistics
-    if (device->isVerbose(2))
-    {
-      std::cout << "Activation bytes: " << activationAllocBytes << std::endl;
-      std::cout << "Scratchpad bytes: " << scratchpadSize << std::endl;
-      std::cout << "Total bytes     : " << totalAllocBytes << std::endl;
-    }
-  }
-
-  template class Network<8>;
-  template class Network<16>;
-
-} // namespace oidn