Cycles: remove prefix from source code file names

Remove prefix of filenames that is the same as the folder name. This used
to help when #includes were using individual files, but now they are always
relative to the cycles root directory and so the prefixes are redundant.

For patches and branches, git merge and rebase should be able to detect the
renames and move over code to the right file.

1 files changed, 1063 insertions, 0 deletions

diff --git a/intern/cycles/blender/python.cpp b/intern/cycles/blender/python.cpp
new file mode 100644
index 00000000000..20bf6385999
--- /dev/null
+++ b/intern/cycles/blender/python.cpp
@@ -0,0 +1,1063 @@
+/*
+ * Copyright 2011-2013 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.
+ */
+
+#include <Python.h>
+
+#include "blender/CCL_api.h"
+
+#include "blender/device.h"
+#include "blender/session.h"
+#include "blender/sync.h"
+#include "blender/util.h"
+
+#include "session/denoising.h"
+#include "session/merge.h"
+
+#include "util/debug.h"
+#include "util/foreach.h"
+#include "util/log.h"
+#include "util/md5.h"
+#include "util/opengl.h"
+#include "util/openimagedenoise.h"
+#include "util/path.h"
+#include "util/string.h"
+#include "util/task.h"
+#include "util/tbb.h"
+#include "util/types.h"
+
+#ifdef WITH_OSL
+#  include "scene/osl.h"
+
+#  include <OSL/oslconfig.h>
+#  include <OSL/oslquery.h>
+#endif
+
+CCL_NAMESPACE_BEGIN
+
+namespace {
+
+/* Flag describing whether debug flags were synchronized from scene. */
+bool debug_flags_set = false;
+
+void *pylong_as_voidptr_typesafe(PyObject *object)
+{
+  if (object == Py_None)
+    return NULL;
+  return PyLong_AsVoidPtr(object);
+}
+
+PyObject *pyunicode_from_string(const char *str)
+{
+  /* Ignore errors if device API returns invalid UTF-8 strings. */
+  return PyUnicode_DecodeUTF8(str, strlen(str), "ignore");
+}
+
+/* Synchronize debug flags from a given Blender scene.
+ * Return truth when device list needs invalidation.
+ */
+static void debug_flags_sync_from_scene(BL::Scene b_scene)
+{
+  DebugFlagsRef flags = DebugFlags();
+  PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles");
+  /* Synchronize shared flags. */
+  flags.viewport_static_bvh = get_enum(cscene, "debug_bvh_type");
+  /* Synchronize CPU flags. */
+  flags.cpu.avx2 = get_boolean(cscene, "debug_use_cpu_avx2");
+  flags.cpu.avx = get_boolean(cscene, "debug_use_cpu_avx");
+  flags.cpu.sse41 = get_boolean(cscene, "debug_use_cpu_sse41");
+  flags.cpu.sse3 = get_boolean(cscene, "debug_use_cpu_sse3");
+  flags.cpu.sse2 = get_boolean(cscene, "debug_use_cpu_sse2");
+  flags.cpu.bvh_layout = (BVHLayout)get_enum(cscene, "debug_bvh_layout");
+  /* Synchronize CUDA flags. */
+  flags.cuda.adaptive_compile = get_boolean(cscene, "debug_use_cuda_adaptive_compile");
+  /* Synchronize OptiX flags. */
+  flags.optix.use_debug = get_boolean(cscene, "debug_use_optix_debug");
+}
+
+/* Reset debug flags to default values.
+ * Return truth when device list needs invalidation.
+ */
+static void debug_flags_reset()
+{
+  DebugFlagsRef flags = DebugFlags();
+  flags.reset();
+}
+
+} /* namespace */
+
+void python_thread_state_save(void **python_thread_state)
+{
+  *python_thread_state = (void *)PyEval_SaveThread();
+}
+
+void python_thread_state_restore(void **python_thread_state)
+{
+  PyEval_RestoreThread((PyThreadState *)*python_thread_state);
+  *python_thread_state = NULL;
+}
+
+static const char *PyC_UnicodeAsByte(PyObject *py_str, PyObject **coerce)
+{
+  const char *result = PyUnicode_AsUTF8(py_str);
+  if (result) {
+    /* 99% of the time this is enough but we better support non unicode
+     * chars since blender doesn't limit this.
+     */
+    return result;
+  }
+  else {
+    PyErr_Clear();
+    if (PyBytes_Check(py_str)) {
+      return PyBytes_AS_STRING(py_str);
+    }
+    else if ((*coerce = PyUnicode_EncodeFSDefault(py_str))) {
+      return PyBytes_AS_STRING(*coerce);
+    }
+    else {
+      /* Clear the error, so Cycles can be at least used without
+       * GPU and OSL support,
+       */
+      PyErr_Clear();
+      return "";
+    }
+  }
+}
+
+static PyObject *init_func(PyObject * /*self*/, PyObject *args)
+{
+  PyObject *path, *user_path, *temp_path;
+  int headless;
+
+  if (!PyArg_ParseTuple(args, "OOOi", &path, &user_path, &temp_path, &headless)) {
+    return nullptr;
+  }
+
+  PyObject *path_coerce = nullptr, *user_path_coerce = nullptr, *temp_path_coerce = nullptr;
+  path_init(PyC_UnicodeAsByte(path, &path_coerce),
+            PyC_UnicodeAsByte(user_path, &user_path_coerce),
+            PyC_UnicodeAsByte(temp_path, &temp_path_coerce));
+  Py_XDECREF(path_coerce);
+  Py_XDECREF(user_path_coerce);
+  Py_XDECREF(temp_path_coerce);
+
+  BlenderSession::headless = headless;
+
+  DebugFlags().running_inside_blender = true;
+
+  VLOG(2) << "Debug flags initialized to:\n" << DebugFlags();
+
+  Py_RETURN_NONE;
+}
+
+static PyObject *exit_func(PyObject * /*self*/, PyObject * /*args*/)
+{
+  ShaderManager::free_memory();
+  TaskScheduler::free_memory();
+  Device::free_memory();
+  Py_RETURN_NONE;
+}
+
+static PyObject *create_func(PyObject * /*self*/, PyObject *args)
+{
+  PyObject *pyengine, *pypreferences, *pydata, *pyscreen, *pyregion, *pyv3d, *pyrv3d;
+  int preview_osl;
+
+  if (!PyArg_ParseTuple(args,
+                        "OOOOOOOi",
+                        &pyengine,
+                        &pypreferences,
+                        &pydata,
+                        &pyscreen,
+                        &pyregion,
+                        &pyv3d,
+                        &pyrv3d,
+                        &preview_osl)) {
+    return NULL;
+  }
+
+  /* RNA */
+  ID *bScreen = (ID *)PyLong_AsVoidPtr(pyscreen);
+
+  PointerRNA engineptr;
+  RNA_pointer_create(NULL, &RNA_RenderEngine, (void *)PyLong_AsVoidPtr(pyengine), &engineptr);
+  BL::RenderEngine engine(engineptr);
+
+  PointerRNA preferencesptr;
+  RNA_pointer_create(
+      NULL, &RNA_Preferences, (void *)PyLong_AsVoidPtr(pypreferences), &preferencesptr);
+  BL::Preferences preferences(preferencesptr);
+
+  PointerRNA dataptr;
+  RNA_main_pointer_create((Main *)PyLong_AsVoidPtr(pydata), &dataptr);
+  BL::BlendData data(dataptr);
+
+  PointerRNA regionptr;
+  RNA_pointer_create(bScreen, &RNA_Region, pylong_as_voidptr_typesafe(pyregion), &regionptr);
+  BL::Region region(regionptr);
+
+  PointerRNA v3dptr;
+  RNA_pointer_create(bScreen, &RNA_SpaceView3D, pylong_as_voidptr_typesafe(pyv3d), &v3dptr);
+  BL::SpaceView3D v3d(v3dptr);
+
+  PointerRNA rv3dptr;
+  RNA_pointer_create(bScreen, &RNA_RegionView3D, pylong_as_voidptr_typesafe(pyrv3d), &rv3dptr);
+  BL::RegionView3D rv3d(rv3dptr);
+
+  /* create session */
+  BlenderSession *session;
+
+  if (rv3d) {
+    /* interactive viewport session */
+    int width = region.width();
+    int height = region.height();
+
+    session = new BlenderSession(engine, preferences, data, v3d, rv3d, width, height);
+  }
+  else {
+    /* offline session or preview render */
+    session = new BlenderSession(engine, preferences, data, preview_osl);
+  }
+
+  return PyLong_FromVoidPtr(session);
+}
+
+static PyObject *free_func(PyObject * /*self*/, PyObject *value)
+{
+  delete (BlenderSession *)PyLong_AsVoidPtr(value);
+
+  Py_RETURN_NONE;
+}
+
+static PyObject *render_func(PyObject * /*self*/, PyObject *args)
+{
+  PyObject *pysession, *pydepsgraph;
+
+  if (!PyArg_ParseTuple(args, "OO", &pysession, &pydepsgraph))
+    return NULL;
+
+  BlenderSession *session = (BlenderSession *)PyLong_AsVoidPtr(pysession);
+
+  PointerRNA depsgraphptr;
+  RNA_pointer_create(NULL, &RNA_Depsgraph, (ID *)PyLong_AsVoidPtr(pydepsgraph), &depsgraphptr);
+  BL::Depsgraph b_depsgraph(depsgraphptr);
+
+  /* Allow Blender to execute other Python scripts. */
+  python_thread_state_save(&session->python_thread_state);
+
+  session->render(b_depsgraph);
+
+  python_thread_state_restore(&session->python_thread_state);
+
+  Py_RETURN_NONE;
+}
+
+static PyObject *render_frame_finish_func(PyObject * /*self*/, PyObject *args)
+{
+  PyObject *pysession;
+
+  if (!PyArg_ParseTuple(args, "O", &pysession)) {
+    return nullptr;
+  }
+
+  BlenderSession *session = (BlenderSession *)PyLong_AsVoidPtr(pysession);
+
+  /* Allow Blender to execute other Python scripts. */
+  python_thread_state_save(&session->python_thread_state);
+
+  session->render_frame_finish();
+
+  python_thread_state_restore(&session->python_thread_state);
+
+  Py_RETURN_NONE;
+}
+
+static PyObject *draw_func(PyObject * /*self*/, PyObject *args)
+{
+  PyObject *py_session, *py_graph, *py_screen, *py_space_image;
+
+  if (!PyArg_ParseTuple(args, "OOOO", &py_session, &py_graph, &py_screen, &py_space_image)) {
+    return nullptr;
+  }
+
+  BlenderSession *session = (BlenderSession *)PyLong_AsVoidPtr(py_session);
+
+  ID *b_screen = (ID *)PyLong_AsVoidPtr(py_screen);
+
+  PointerRNA b_space_image_ptr;
+  RNA_pointer_create(b_screen,
+                     &RNA_SpaceImageEditor,
+                     pylong_as_voidptr_typesafe(py_space_image),
+                     &b_space_image_ptr);
+  BL::SpaceImageEditor b_space_image(b_space_image_ptr);
+
+  session->draw(b_space_image);
+
+  Py_RETURN_NONE;
+}
+
+/* pixel_array and result passed as pointers */
+static PyObject *bake_func(PyObject * /*self*/, PyObject *args)
+{
+  PyObject *pysession, *pydepsgraph, *pyobject;
+  const char *pass_type;
+  int pass_filter, width, height;
+
+  if (!PyArg_ParseTuple(args,
+                        "OOOsiii",
+                        &pysession,
+                        &pydepsgraph,
+                        &pyobject,
+                        &pass_type,
+                        &pass_filter,
+                        &width,
+                        &height))
+    return NULL;
+
+  BlenderSession *session = (BlenderSession *)PyLong_AsVoidPtr(pysession);
+
+  PointerRNA depsgraphptr;
+  RNA_pointer_create(NULL, &RNA_Depsgraph, PyLong_AsVoidPtr(pydepsgraph), &depsgraphptr);
+  BL::Depsgraph b_depsgraph(depsgraphptr);
+
+  PointerRNA objectptr;
+  RNA_id_pointer_create((ID *)PyLong_AsVoidPtr(pyobject), &objectptr);
+  BL::Object b_object(objectptr);
+
+  python_thread_state_save(&session->python_thread_state);
+
+  session->bake(b_depsgraph, b_object, pass_type, pass_filter, width, height);
+
+  python_thread_state_restore(&session->python_thread_state);
+
+  Py_RETURN_NONE;
+}
+
+static PyObject *view_draw_func(PyObject * /*self*/, PyObject *args)
+{
+  PyObject *pysession, *pygraph, *pyv3d, *pyrv3d;
+
+  if (!PyArg_ParseTuple(args, "OOOO", &pysession, &pygraph, &pyv3d, &pyrv3d))
+    return NULL;
+
+  BlenderSession *session = (BlenderSession *)PyLong_AsVoidPtr(pysession);
+
+  if (PyLong_AsVoidPtr(pyrv3d)) {
+    /* 3d view drawing */
+    int viewport[4];
+    glGetIntegerv(GL_VIEWPORT, viewport);
+
+    session->view_draw(viewport[2], viewport[3]);
+  }
+
+  Py_RETURN_NONE;
+}
+
+static PyObject *reset_func(PyObject * /*self*/, PyObject *args)
+{
+  PyObject *pysession, *pydata, *pydepsgraph;
+
+  if (!PyArg_ParseTuple(args, "OOO", &pysession, &pydata, &pydepsgraph))
+    return NULL;
+
+  BlenderSession *session = (BlenderSession *)PyLong_AsVoidPtr(pysession);
+
+  PointerRNA dataptr;
+  RNA_main_pointer_create((Main *)PyLong_AsVoidPtr(pydata), &dataptr);
+  BL::BlendData b_data(dataptr);
+
+  PointerRNA depsgraphptr;
+  RNA_pointer_create(NULL, &RNA_Depsgraph, PyLong_AsVoidPtr(pydepsgraph), &depsgraphptr);
+  BL::Depsgraph b_depsgraph(depsgraphptr);
+
+  python_thread_state_save(&session->python_thread_state);
+
+  session->reset_session(b_data, b_depsgraph);
+
+  python_thread_state_restore(&session->python_thread_state);
+
+  Py_RETURN_NONE;
+}
+
+static PyObject *sync_func(PyObject * /*self*/, PyObject *args)
+{
+  PyObject *pysession, *pydepsgraph;
+
+  if (!PyArg_ParseTuple(args, "OO", &pysession, &pydepsgraph))
+    return NULL;
+
+  BlenderSession *session = (BlenderSession *)PyLong_AsVoidPtr(pysession);
+
+  PointerRNA depsgraphptr;
+  RNA_pointer_create(NULL, &RNA_Depsgraph, PyLong_AsVoidPtr(pydepsgraph), &depsgraphptr);
+  BL::Depsgraph b_depsgraph(depsgraphptr);
+
+  python_thread_state_save(&session->python_thread_state);
+
+  session->synchronize(b_depsgraph);
+
+  python_thread_state_restore(&session->python_thread_state);
+
+  Py_RETURN_NONE;
+}
+
+static PyObject *available_devices_func(PyObject * /*self*/, PyObject *args)
+{
+  const char *type_name;
+  if (!PyArg_ParseTuple(args, "s", &type_name)) {
+    return NULL;
+  }
+
+  DeviceType type = Device::type_from_string(type_name);
+  /* "NONE" is defined by the add-on, see: `CyclesPreferences.get_device_types`. */
+  if ((type == DEVICE_NONE) && (strcmp(type_name, "NONE") != 0)) {
+    PyErr_Format(PyExc_ValueError, "Device \"%s\" not known.", type_name);
+    return NULL;
+  }
+
+  uint mask = (type == DEVICE_NONE) ? DEVICE_MASK_ALL : DEVICE_MASK(type);
+  mask |= DEVICE_MASK_CPU;
+
+  vector<DeviceInfo> devices = Device::available_devices(mask);
+  PyObject *ret = PyTuple_New(devices.size());
+
+  for (size_t i = 0; i < devices.size(); i++) {
+    DeviceInfo &device = devices[i];
+    string type_name = Device::string_from_type(device.type);
+    PyObject *device_tuple = PyTuple_New(4);
+    PyTuple_SET_ITEM(device_tuple, 0, pyunicode_from_string(device.description.c_str()));
+    PyTuple_SET_ITEM(device_tuple, 1, pyunicode_from_string(type_name.c_str()));
+    PyTuple_SET_ITEM(device_tuple, 2, pyunicode_from_string(device.id.c_str()));
+    PyTuple_SET_ITEM(device_tuple, 3, PyBool_FromLong(device.has_peer_memory));
+    PyTuple_SET_ITEM(ret, i, device_tuple);
+  }
+
+  return ret;
+}
+
+#ifdef WITH_OSL
+
+static PyObject *osl_update_node_func(PyObject * /*self*/, PyObject *args)
+{
+  PyObject *pydata, *pynodegroup, *pynode;
+  const char *filepath = NULL;
+
+  if (!PyArg_ParseTuple(args, "OOOs", &pydata, &pynodegroup, &pynode, &filepath))
+    return NULL;
+
+  /* RNA */
+  PointerRNA dataptr;
+  RNA_main_pointer_create((Main *)PyLong_AsVoidPtr(pydata), &dataptr);
+  BL::BlendData b_data(dataptr);
+
+  PointerRNA nodeptr;
+  RNA_pointer_create((ID *)PyLong_AsVoidPtr(pynodegroup),
+                     &RNA_ShaderNodeScript,
+                     (void *)PyLong_AsVoidPtr(pynode),
+                     &nodeptr);
+  BL::ShaderNodeScript b_node(nodeptr);
+
+  /* update bytecode hash */
+  string bytecode = b_node.bytecode();
+
+  if (!bytecode.empty()) {
+    MD5Hash md5;
+    md5.append((const uint8_t *)bytecode.c_str(), bytecode.size());
+    b_node.bytecode_hash(md5.get_hex().c_str());
+  }
+  else
+    b_node.bytecode_hash("");
+
+  /* query from file path */
+  OSL::OSLQuery query;
+
+  if (!OSLShaderManager::osl_query(query, filepath))
+    Py_RETURN_FALSE;
+
+  /* add new sockets from parameters */
+  set<void *> used_sockets;
+
+  for (int i = 0; i < query.nparams(); i++) {
+    const OSL::OSLQuery::Parameter *param = query.getparam(i);
+
+    /* skip unsupported types */
+    if (param->varlenarray || param->isstruct || param->type.arraylen > 1)
+      continue;
+
+    /* Read metadata. */
+    bool is_bool_param = false;
+    ustring param_label = param->name;
+
+    for (const OSL::OSLQuery::Parameter &metadata : param->metadata) {
+      if (metadata.type == TypeDesc::STRING) {
+        if (metadata.name == "widget") {
+          /* Boolean socket. */
+          if (metadata.sdefault[0] == "boolean" || metadata.sdefault[0] == "checkBox") {
+            is_bool_param = true;
+          }
+        }
+        else if (metadata.name == "label") {
+          /* Socket label. */
+          param_label = metadata.sdefault[0];
+        }
+      }
+    }
+    /* determine socket type */
+    string socket_type;
+    BL::NodeSocket::type_enum data_type = BL::NodeSocket::type_VALUE;
+    float4 default_float4 = make_float4(0.0f, 0.0f, 0.0f, 1.0f);
+    float default_float = 0.0f;
+    int default_int = 0;
+    string default_string = "";
+    bool default_boolean = false;
+
+    if (param->isclosure) {
+      socket_type = "NodeSocketShader";
+      data_type = BL::NodeSocket::type_SHADER;
+    }
+    else if (param->type.vecsemantics == TypeDesc::COLOR) {
+      socket_type = "NodeSocketColor";
+      data_type = BL::NodeSocket::type_RGBA;
+
+      if (param->validdefault) {
+        default_float4[0] = param->fdefault[0];
+        default_float4[1] = param->fdefault[1];
+        default_float4[2] = param->fdefault[2];
+      }
+    }
+    else if (param->type.vecsemantics == TypeDesc::POINT ||
+             param->type.vecsemantics == TypeDesc::VECTOR ||
+             param->type.vecsemantics == TypeDesc::NORMAL) {
+      socket_type = "NodeSocketVector";
+      data_type = BL::NodeSocket::type_VECTOR;
+
+      if (param->validdefault) {
+        default_float4[0] = param->fdefault[0];
+        default_float4[1] = param->fdefault[1];
+        default_float4[2] = param->fdefault[2];
+      }
+    }
+    else if (param->type.aggregate == TypeDesc::SCALAR) {
+      if (param->type.basetype == TypeDesc::INT) {
+        if (is_bool_param) {
+          socket_type = "NodeSocketBool";
+          data_type = BL::NodeSocket::type_BOOLEAN;
+          if (param->validdefault) {
+            default_boolean = (bool)param->idefault[0];
+          }
+        }
+        else {
+          socket_type = "NodeSocketInt";
+          data_type = BL::NodeSocket::type_INT;
+          if (param->validdefault)
+            default_int = param->idefault[0];
+        }
+      }
+      else if (param->type.basetype == TypeDesc::FLOAT) {
+        socket_type = "NodeSocketFloat";
+        data_type = BL::NodeSocket::type_VALUE;
+        if (param->validdefault)
+          default_float = param->fdefault[0];
+      }
+      else if (param->type.basetype == TypeDesc::STRING) {
+        socket_type = "NodeSocketString";
+        data_type = BL::NodeSocket::type_STRING;
+        if (param->validdefault)
+          default_string = param->sdefault[0].string();
+      }
+      else
+        continue;
+    }
+    else
+      continue;
+
+    /* Update existing socket. */
+    bool found_existing = false;
+    if (param->isoutput) {
+      for (BL::NodeSocket &b_sock : b_node.outputs) {
+        if (b_sock.identifier() == param->name) {
+          if (b_sock.bl_idname() != socket_type) {
+            /* Remove if type no longer matches. */
+            b_node.outputs.remove(b_data, b_sock);
+          }
+          else {
+            /* Reuse and update label. */
+            if (b_sock.name() != param_label) {
+              b_sock.name(param_label.string());
+            }
+            used_sockets.insert(b_sock.ptr.data);
+            found_existing = true;
+          }
+          break;
+        }
+      }
+    }
+    else {
+      for (BL::NodeSocket &b_sock : b_node.inputs) {
+        if (b_sock.identifier() == param->name) {
+          if (b_sock.bl_idname() != socket_type) {
+            /* Remove if type no longer matches. */
+            b_node.inputs.remove(b_data, b_sock);
+          }
+          else {
+            /* Reuse and update label. */
+            if (b_sock.name() != param_label) {
+              b_sock.name(param_label.string());
+            }
+            used_sockets.insert(b_sock.ptr.data);
+            found_existing = true;
+          }
+          break;
+        }
+      }
+    }
+
+    if (!found_existing) {
+      /* Create new socket. */
+      BL::NodeSocket b_sock = (param->isoutput) ? b_node.outputs.create(b_data,
+                                                                        socket_type.c_str(),
+                                                                        param_label.c_str(),
+                                                                        param->name.c_str()) :
+                                                  b_node.inputs.create(b_data,
+                                                                       socket_type.c_str(),
+                                                                       param_label.c_str(),
+                                                                       param->name.c_str());
+
+      /* set default value */
+      if (data_type == BL::NodeSocket::type_VALUE) {
+        set_float(b_sock.ptr, "default_value", default_float);
+      }
+      else if (data_type == BL::NodeSocket::type_INT) {
+        set_int(b_sock.ptr, "default_value", default_int);
+      }
+      else if (data_type == BL::NodeSocket::type_RGBA) {
+        set_float4(b_sock.ptr, "default_value", default_float4);
+      }
+      else if (data_type == BL::NodeSocket::type_VECTOR) {
+        set_float3(b_sock.ptr, "default_value", float4_to_float3(default_float4));
+      }
+      else if (data_type == BL::NodeSocket::type_STRING) {
+        set_string(b_sock.ptr, "default_value", default_string);
+      }
+      else if (data_type == BL::NodeSocket::type_BOOLEAN) {
+        set_boolean(b_sock.ptr, "default_value", default_boolean);
+      }
+
+      used_sockets.insert(b_sock.ptr.data);
+    }
+  }
+
+  /* remove unused parameters */
+  bool removed;
+
+  do {
+    removed = false;
+
+    for (BL::NodeSocket &b_input : b_node.inputs) {
+      if (used_sockets.find(b_input.ptr.data) == used_sockets.end()) {
+        b_node.inputs.remove(b_data, b_input);
+        removed = true;
+        break;
+      }
+    }
+
+    for (BL::NodeSocket &b_output : b_node.outputs) {
+      if (used_sockets.find(b_output.ptr.data) == used_sockets.end()) {
+        b_node.outputs.remove(b_data, b_output);
+        removed = true;
+        break;
+      }
+    }
+  } while (removed);
+
+  Py_RETURN_TRUE;
+}
+
+static PyObject *osl_compile_func(PyObject * /*self*/, PyObject *args)
+{
+  const char *inputfile = NULL, *outputfile = NULL;
+
+  if (!PyArg_ParseTuple(args, "ss", &inputfile, &outputfile))
+    return NULL;
+
+  /* return */
+  if (!OSLShaderManager::osl_compile(inputfile, outputfile))
+    Py_RETURN_FALSE;
+
+  Py_RETURN_TRUE;
+}
+#endif
+
+static PyObject *system_info_func(PyObject * /*self*/, PyObject * /*value*/)
+{
+  string system_info = Device::device_capabilities();
+  return pyunicode_from_string(system_info.c_str());
+}
+
+static bool image_parse_filepaths(PyObject *pyfilepaths, vector<string> &filepaths)
+{
+  if (PyUnicode_Check(pyfilepaths)) {
+    const char *filepath = PyUnicode_AsUTF8(pyfilepaths);
+    filepaths.push_back(filepath);
+    return true;
+  }
+
+  PyObject *sequence = PySequence_Fast(pyfilepaths,
+                                       "File paths must be a string or sequence of strings");
+  if (sequence == NULL) {
+    return false;
+  }
+
+  for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(sequence); i++) {
+    PyObject *item = PySequence_Fast_GET_ITEM(sequence, i);
+    const char *filepath = PyUnicode_AsUTF8(item);
+    if (filepath == NULL) {
+      PyErr_SetString(PyExc_ValueError, "File paths must be a string or sequence of strings.");
+      Py_DECREF(sequence);
+      return false;
+    }
+    filepaths.push_back(filepath);
+  }
+  Py_DECREF(sequence);
+
+  return true;
+}
+
+static PyObject *denoise_func(PyObject * /*self*/, PyObject *args, PyObject *keywords)
+{
+#if 1
+  (void)args;
+  (void)keywords;
+#else
+  static const char *keyword_list[] = {
+      "preferences", "scene", "view_layer", "input", "output", "tile_size", "samples", NULL};
+  PyObject *pypreferences, *pyscene, *pyviewlayer;
+  PyObject *pyinput, *pyoutput = NULL;
+  int tile_size = 0, samples = 0;
+
+  if (!PyArg_ParseTupleAndKeywords(args,
+                                   keywords,
+                                   "OOOO|Oii",
+                                   (char **)keyword_list,
+                                   &pypreferences,
+                                   &pyscene,
+                                   &pyviewlayer,
+                                   &pyinput,
+                                   &pyoutput,
+                                   &tile_size,
+                                   &samples)) {
+    return NULL;
+  }
+
+  /* Get device specification from preferences and scene. */
+  PointerRNA preferencesptr;
+  RNA_pointer_create(
+      NULL, &RNA_Preferences, (void *)PyLong_AsVoidPtr(pypreferences), &preferencesptr);
+  BL::Preferences b_preferences(preferencesptr);
+
+  PointerRNA sceneptr;
+  RNA_id_pointer_create((ID *)PyLong_AsVoidPtr(pyscene), &sceneptr);
+  BL::Scene b_scene(sceneptr);
+
+  DeviceInfo device = blender_device_info(b_preferences, b_scene, true);
+
+  /* Get denoising parameters from view layer. */
+  PointerRNA viewlayerptr;
+  RNA_pointer_create((ID *)PyLong_AsVoidPtr(pyscene),
+                     &RNA_ViewLayer,
+                     PyLong_AsVoidPtr(pyviewlayer),
+                     &viewlayerptr);
+  PointerRNA cviewlayer = RNA_pointer_get(&viewlayerptr, "cycles");
+
+  DenoiseParams params;
+  params.radius = get_int(cviewlayer, "denoising_radius");
+  params.strength = get_float(cviewlayer, "denoising_strength");
+  params.feature_strength = get_float(cviewlayer, "denoising_feature_strength");
+  params.relative_pca = get_boolean(cviewlayer, "denoising_relative_pca");
+  params.neighbor_frames = get_int(cviewlayer, "denoising_neighbor_frames");
+
+  /* Parse file paths list. */
+  vector<string> input, output;
+
+  if (!image_parse_filepaths(pyinput, input)) {
+    return NULL;
+  }
+
+  if (pyoutput) {
+    if (!image_parse_filepaths(pyoutput, output)) {
+      return NULL;
+    }
+  }
+  else {
+    output = input;
+  }
+
+  if (input.empty()) {
+    PyErr_SetString(PyExc_ValueError, "No input file paths specified.");
+    return NULL;
+  }
+  if (input.size() != output.size()) {
+    PyErr_SetString(PyExc_ValueError, "Number of input and output file paths does not match.");
+    return NULL;
+  }
+
+  /* Create denoiser. */
+  DenoiserPipeline denoiser(device);
+  denoiser.params = params;
+  denoiser.input = input;
+  denoiser.output = output;
+
+  if (tile_size > 0) {
+    denoiser.tile_size = make_int2(tile_size, tile_size);
+  }
+  if (samples > 0) {
+    denoiser.samples_override = samples;
+  }
+
+  /* Run denoiser. */
+  if (!denoiser.run()) {
+    PyErr_SetString(PyExc_ValueError, denoiser.error.c_str());
+    return NULL;
+  }
+#endif
+
+  Py_RETURN_NONE;
+}
+
+static PyObject *merge_func(PyObject * /*self*/, PyObject *args, PyObject *keywords)
+{
+  static const char *keyword_list[] = {"input", "output", NULL};
+  PyObject *pyinput, *pyoutput = NULL;
+
+  if (!PyArg_ParseTupleAndKeywords(
+          args, keywords, "OO", (char **)keyword_list, &pyinput, &pyoutput)) {
+    return NULL;
+  }
+
+  /* Parse input list. */
+  vector<string> input;
+  if (!image_parse_filepaths(pyinput, input)) {
+    return NULL;
+  }
+
+  /* Parse output string. */
+  if (!PyUnicode_Check(pyoutput)) {
+    PyErr_SetString(PyExc_ValueError, "Output must be a string.");
+    return NULL;
+  }
+  string output = PyUnicode_AsUTF8(pyoutput);
+
+  /* Merge. */
+  ImageMerger merger;
+  merger.input = input;
+  merger.output = output;
+
+  if (!merger.run()) {
+    PyErr_SetString(PyExc_ValueError, merger.error.c_str());
+    return NULL;
+  }
+
+  Py_RETURN_NONE;
+}
+
+static PyObject *debug_flags_update_func(PyObject * /*self*/, PyObject *args)
+{
+  PyObject *pyscene;
+  if (!PyArg_ParseTuple(args, "O", &pyscene)) {
+    return NULL;
+  }
+
+  PointerRNA sceneptr;
+  RNA_id_pointer_create((ID *)PyLong_AsVoidPtr(pyscene), &sceneptr);
+  BL::Scene b_scene(sceneptr);
+
+  debug_flags_sync_from_scene(b_scene);
+
+  VLOG(2) << "Debug flags set to:\n" << DebugFlags();
+
+  debug_flags_set = true;
+
+  Py_RETURN_NONE;
+}
+
+static PyObject *debug_flags_reset_func(PyObject * /*self*/, PyObject * /*args*/)
+{
+  debug_flags_reset();
+  if (debug_flags_set) {
+    VLOG(2) << "Debug flags reset to:\n" << DebugFlags();
+    debug_flags_set = false;
+  }
+  Py_RETURN_NONE;
+}
+
+static PyObject *enable_print_stats_func(PyObject * /*self*/, PyObject * /*args*/)
+{
+  BlenderSession::print_render_stats = true;
+  Py_RETURN_NONE;
+}
+
+static PyObject *get_device_types_func(PyObject * /*self*/, PyObject * /*args*/)
+{
+  vector<DeviceType> device_types = Device::available_types();
+  bool has_cuda = false, has_optix = false, has_hip = false;
+  foreach (DeviceType device_type, device_types) {
+    has_cuda |= (device_type == DEVICE_CUDA);
+    has_optix |= (device_type == DEVICE_OPTIX);
+    has_hip |= (device_type == DEVICE_HIP);
+  }
+  PyObject *list = PyTuple_New(3);
+  PyTuple_SET_ITEM(list, 0, PyBool_FromLong(has_cuda));
+  PyTuple_SET_ITEM(list, 1, PyBool_FromLong(has_optix));
+  PyTuple_SET_ITEM(list, 2, PyBool_FromLong(has_hip));
+  return list;
+}
+
+static PyObject *set_device_override_func(PyObject * /*self*/, PyObject *arg)
+{
+  PyObject *override_string = PyObject_Str(arg);
+  string override = PyUnicode_AsUTF8(override_string);
+  Py_DECREF(override_string);
+
+  bool include_cpu = false;
+  const string cpu_suffix = "+CPU";
+  if (string_endswith(override, cpu_suffix)) {
+    include_cpu = true;
+    override = override.substr(0, override.length() - cpu_suffix.length());
+  }
+
+  if (override == "CPU") {
+    BlenderSession::device_override = DEVICE_MASK_CPU;
+  }
+  else if (override == "CUDA") {
+    BlenderSession::device_override = DEVICE_MASK_CUDA;
+  }
+  else if (override == "OPTIX") {
+    BlenderSession::device_override = DEVICE_MASK_OPTIX;
+  }
+  else if (override == "HIP") {
+    BlenderSession::device_override = DEVICE_MASK_HIP;
+  }
+  else {
+    printf("\nError: %s is not a valid Cycles device.\n", override.c_str());
+    Py_RETURN_FALSE;
+  }
+
+  if (include_cpu) {
+    BlenderSession::device_override = (DeviceTypeMask)(BlenderSession::device_override |
+                                                       DEVICE_MASK_CPU);
+  }
+
+  Py_RETURN_TRUE;
+}
+
+static PyMethodDef methods[] = {
+    {"init", init_func, METH_VARARGS, ""},
+    {"exit", exit_func, METH_VARARGS, ""},
+    {"create", create_func, METH_VARARGS, ""},
+    {"free", free_func, METH_O, ""},
+    {"render", render_func, METH_VARARGS, ""},
+    {"render_frame_finish", render_frame_finish_func, METH_VARARGS, ""},
+    {"draw", draw_func, METH_VARARGS, ""},
+    {"bake", bake_func, METH_VARARGS, ""},
+    {"view_draw", view_draw_func, METH_VARARGS, ""},
+    {"sync", sync_func, METH_VARARGS, ""},
+    {"reset", reset_func, METH_VARARGS, ""},
+#ifdef WITH_OSL
+    {"osl_update_node", osl_update_node_func, METH_VARARGS, ""},
+    {"osl_compile", osl_compile_func, METH_VARARGS, ""},
+#endif
+    {"available_devices", available_devices_func, METH_VARARGS, ""},
+    {"system_info", system_info_func, METH_NOARGS, ""},
+
+    /* Standalone denoising */
+    {"denoise", (PyCFunction)denoise_func, METH_VARARGS | METH_KEYWORDS, ""},
+    {"merge", (PyCFunction)merge_func, METH_VARARGS | METH_KEYWORDS, ""},
+
+    /* Debugging routines */
+    {"debug_flags_update", debug_flags_update_func, METH_VARARGS, ""},
+    {"debug_flags_reset", debug_flags_reset_func, METH_NOARGS, ""},
+
+    /* Statistics. */
+    {"enable_print_stats", enable_print_stats_func, METH_NOARGS, ""},
+
+    /* Compute Device selection */
+    {"get_device_types", get_device_types_func, METH_VARARGS, ""},
+    {"set_device_override", set_device_override_func, METH_O, ""},
+
+    {NULL, NULL, 0, NULL},
+};
+
+static struct PyModuleDef module = {
+    PyModuleDef_HEAD_INIT,
+    "_cycles",
+    "Blender cycles render integration",
+    -1,
+    methods,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+};
+
+CCL_NAMESPACE_END
+
+void *CCL_python_module_init()
+{
+  PyObject *mod = PyModule_Create(&ccl::module);
+
+#ifdef WITH_OSL
+  /* TODO(sergey): This gives us library we've been linking against.
+   *               In theory with dynamic OSL library it might not be
+   *               accurate, but there's nothing in OSL API which we
+   *               might use to get version in runtime.
+   */
+  int curversion = OSL_LIBRARY_VERSION_CODE;
+  PyModule_AddObject(mod, "with_osl", Py_True);
+  Py_INCREF(Py_True);
+  PyModule_AddObject(
+      mod,
+      "osl_version",
+      Py_BuildValue("(iii)", curversion / 10000, (curversion / 100) % 100, curversion % 100));
+  PyModule_AddObject(
+      mod,
+      "osl_version_string",
+      PyUnicode_FromFormat(
+          "%2d, %2d, %2d", curversion / 10000, (curversion / 100) % 100, curversion % 100));
+#else
+  PyModule_AddObject(mod, "with_osl", Py_False);
+  Py_INCREF(Py_False);
+  PyModule_AddStringConstant(mod, "osl_version", "unknown");
+  PyModule_AddStringConstant(mod, "osl_version_string", "unknown");
+#endif
+
+#ifdef WITH_EMBREE
+  PyModule_AddObject(mod, "with_embree", Py_True);
+  Py_INCREF(Py_True);
+#else  /* WITH_EMBREE */
+  PyModule_AddObject(mod, "with_embree", Py_False);
+  Py_INCREF(Py_False);
+#endif /* WITH_EMBREE */
+
+  if (ccl::openimagedenoise_supported()) {
+    PyModule_AddObject(mod, "with_openimagedenoise", Py_True);
+    Py_INCREF(Py_True);
+  }
+  else {
+    PyModule_AddObject(mod, "with_openimagedenoise", Py_False);
+    Py_INCREF(Py_False);
+  }
+
+  return (void *)mod;
+}