OpenColorIO: address review commentstmp-ocio-v2

6 files changed, 225 insertions, 238 deletions

diff --git a/intern/opencolorio/fallback_impl.cc b/intern/opencolorio/fallback_impl.cc
index 7c11d0baef4..9bbc9843e9d 100644
--- a/intern/opencolorio/fallback_impl.cc
+++ b/intern/opencolorio/fallback_impl.cc
@@ -104,31 +104,21 @@ struct FallbackTransform {
 };
 
 struct FallbackProcessor {
-  FallbackProcessor(FallbackTransform *transform) : transform(transform)
+  FallbackProcessor(const FallbackTransform &transform) : transform(transform)
   {
   }
 
-  FallbackProcessor(const FallbackProcessor &other)
-  {
-    transform = new FallbackTransform(*other.transform);
-  }
-
-  ~FallbackProcessor()
-  {
-    delete transform;
-  }
-
   void applyRGB(float *pixel)
   {
-    transform->applyRGB(pixel);
+    transform.applyRGB(pixel);
   }
 
   void applyRGBA(float *pixel)
   {
-    transform->applyRGBA(pixel);
+    transform.applyRGBA(pixel);
   }
 
-  FallbackTransform *transform;
+  FallbackTransform transform;
 
   MEM_CXX_CLASS_ALLOC_FUNCS("FallbackProcessor");
 };
@@ -338,27 +328,35 @@ OCIO_ConstProcessorRcPtr *FallbackImpl::configGetProcessorWithNames(OCIO_ConstCo
 {
   OCIO_ConstColorSpaceRcPtr *cs_src = configGetColorSpace(config, srcName);
   OCIO_ConstColorSpaceRcPtr *cs_dst = configGetColorSpace(config, dstName);
-  FallbackTransform *transform = new FallbackTransform();
+  FallbackTransform transform;
   if (cs_src == COLORSPACE_LINEAR && cs_dst == COLORSPACE_SRGB) {
-    transform->type = TRANSFORM_LINEAR_TO_SRGB;
+    transform.type = TRANSFORM_LINEAR_TO_SRGB;
   }
   else if (cs_src == COLORSPACE_SRGB && cs_dst == COLORSPACE_LINEAR) {
-    transform->type = TRANSFORM_SRGB_TO_LINEAR;
+    transform.type = TRANSFORM_SRGB_TO_LINEAR;
   }
   else {
-    transform->type = TRANSFORM_UNKNOWN;
+    transform.type = TRANSFORM_UNKNOWN;
   }
   return (OCIO_ConstProcessorRcPtr *)new FallbackProcessor(transform);
 }
 
-OCIO_ConstCPUProcessorRcPtr *FallbackImpl::processorGetCPUProcessor(OCIO_ConstProcessorRcPtr *p)
+OCIO_ConstCPUProcessorRcPtr *FallbackImpl::processorGetCPUProcessor(
+    OCIO_ConstProcessorRcPtr *processor)
 {
-  FallbackProcessor *processor = (FallbackProcessor *)p;
-  return (OCIO_ConstCPUProcessorRcPtr *)new FallbackProcessor(*processor);
+  /* Just make a copy of the processor so that we are compatible with OCIO
+   * which does need it as a separate object. */
+  FallbackProcessor *fallback_processor = (FallbackProcessor *)processor;
+  return (OCIO_ConstCPUProcessorRcPtr *)new FallbackProcessor(*fallback_processor);
 }
 
-void FallbackImpl::processorApply(OCIO_ConstCPUProcessorRcPtr *processor,
-                                  OCIO_PackedImageDesc *img)
+void FallbackImpl::processorRelease(OCIO_ConstProcessorRcPtr *processor)
+{
+  delete (FallbackProcessor *)(processor);
+}
+
+void FallbackImpl::cpuProcessorApply(OCIO_ConstCPUProcessorRcPtr *cpu_processor,
+                                     OCIO_PackedImageDesc *img)
 {
   /* OCIO_TODO stride not respected, channels must be 3 or 4 */
   OCIO_PackedImageDescription *desc = (OCIO_PackedImageDescription *)img;
@@ -373,15 +371,15 @@ void FallbackImpl::processorApply(OCIO_ConstCPUProcessorRcPtr *processor,
       float *pixel = pixels + channels * (y * width + x);
 
       if (channels == 4)
-        processorApplyRGBA(processor, pixel);
+        cpuProcessorApplyRGBA(cpu_processor, pixel);
       else if (channels == 3)
-        processorApplyRGB(processor, pixel);
+        cpuProcessorApplyRGB(cpu_processor, pixel);
     }
   }
 }
 
-void FallbackImpl::processorApply_predivide(OCIO_ConstCPUProcessorRcPtr *processor,
-                                            OCIO_PackedImageDesc *img)
+void FallbackImpl::cpuProcessorApply_predivide(OCIO_ConstCPUProcessorRcPtr *cpu_processor,
+                                               OCIO_PackedImageDesc *img)
 {
   /* OCIO_TODO stride not respected, channels must be 3 or 4 */
   OCIO_PackedImageDescription *desc = (OCIO_PackedImageDescription *)img;
@@ -396,28 +394,28 @@ void FallbackImpl::processorApply_predivide(OCIO_ConstCPUProcessorRcPtr *process
       float *pixel = pixels + channels * (y * width + x);
 
       if (channels == 4)
-        processorApplyRGBA_predivide(processor, pixel);
+        cpuProcessorApplyRGBA_predivide(cpu_processor, pixel);
       else if (channels == 3)
-        processorApplyRGB(processor, pixel);
+        cpuProcessorApplyRGB(cpu_processor, pixel);
     }
   }
 }
 
-void FallbackImpl::processorApplyRGB(OCIO_ConstCPUProcessorRcPtr *processor, float *pixel)
+void FallbackImpl::cpuProcessorApplyRGB(OCIO_ConstCPUProcessorRcPtr *cpu_processor, float *pixel)
 {
-  ((FallbackProcessor *)processor)->applyRGB(pixel);
+  ((FallbackProcessor *)cpu_processor)->applyRGB(pixel);
 }
 
-void FallbackImpl::processorApplyRGBA(OCIO_ConstCPUProcessorRcPtr *processor, float *pixel)
+void FallbackImpl::cpuProcessorApplyRGBA(OCIO_ConstCPUProcessorRcPtr *cpu_processor, float *pixel)
 {
-  ((FallbackProcessor *)processor)->applyRGBA(pixel);
+  ((FallbackProcessor *)cpu_processor)->applyRGBA(pixel);
 }
 
-void FallbackImpl::processorApplyRGBA_predivide(OCIO_ConstCPUProcessorRcPtr *processor,
-                                                float *pixel)
+void FallbackImpl::cpuProcessorApplyRGBA_predivide(OCIO_ConstCPUProcessorRcPtr *cpu_processor,
+                                                   float *pixel)
 {
   if (pixel[3] == 1.0f || pixel[3] == 0.0f) {
-    processorApplyRGBA(processor, pixel);
+    cpuProcessorApplyRGBA(cpu_processor, pixel);
   }
   else {
     float alpha, inv_alpha;
@@ -429,7 +427,7 @@ void FallbackImpl::processorApplyRGBA_predivide(OCIO_ConstCPUProcessorRcPtr *pro
     pixel[1] *= inv_alpha;
     pixel[2] *= inv_alpha;
 
-    processorApplyRGBA(processor, pixel);
+    cpuProcessorApplyRGBA(cpu_processor, pixel);
 
     pixel[0] *= alpha;
     pixel[1] *= alpha;
@@ -437,14 +435,9 @@ void FallbackImpl::processorApplyRGBA_predivide(OCIO_ConstCPUProcessorRcPtr *pro
   }
 }
 
-void FallbackImpl::processorRelease(OCIO_ConstProcessorRcPtr *processor)
-{
-  delete (FallbackProcessor *)(processor);
-}
-
-void FallbackImpl::cpuProcessorRelease(OCIO_ConstCPUProcessorRcPtr *processor)
+void FallbackImpl::cpuProcessorRelease(OCIO_ConstCPUProcessorRcPtr *cpu_processor)
 {
-  delete (FallbackProcessor *)(processor);
+  delete (FallbackProcessor *)(cpu_processor);
 }
 
 const char *FallbackImpl::colorSpaceGetName(OCIO_ConstColorSpaceRcPtr *cs)
@@ -468,19 +461,18 @@ const char *FallbackImpl::colorSpaceGetFamily(OCIO_ConstColorSpaceRcPtr * /*cs*/
   return "";
 }
 
-OCIO_ConstProcessorRcPtr *FallbackImpl::createDisplayProcessor(
-    OCIO_ConstConfigRcPtr * /* config */,
-    const char * /* input */,
-    const char * /* view */,
-    const char * /* display */,
-    const char * /* look */,
-    const float scale,
-    const float exponent)
+OCIO_ConstProcessorRcPtr *FallbackImpl::createDisplayProcessor(OCIO_ConstConfigRcPtr * /*config*/,
+                                                               const char * /*input*/,
+                                                               const char * /*view*/,
+                                                               const char * /*display*/,
+                                                               const char * /*look*/,
+                                                               const float scale,
+                                                               const float exponent)
 {
-  FallbackTransform *transform = new FallbackTransform();
-  transform->type = TRANSFORM_LINEAR_TO_SRGB;
-  transform->scale = scale;
-  transform->exponent = exponent;
+  FallbackTransform transform;
+  transform.type = TRANSFORM_LINEAR_TO_SRGB;
+  transform.scale = scale;
+  transform.exponent = exponent;
 
   return (OCIO_ConstProcessorRcPtr *)new FallbackProcessor(transform);
 }
diff --git a/intern/opencolorio/ocio_capi.cc b/intern/opencolorio/ocio_capi.cc
index 6904ce207dd..a7416f82b91 100644
--- a/intern/opencolorio/ocio_capi.cc
+++ b/intern/opencolorio/ocio_capi.cc
@@ -194,45 +194,45 @@ OCIO_ConstProcessorRcPtr *OCIO_configGetProcessorWithNames(OCIO_ConstConfigRcPtr
   return impl->configGetProcessorWithNames(config, srcName, dstName);
 }
 
-OCIO_ConstCPUProcessorRcPtr *OCIO_processorGetCPUProcessor(OCIO_ConstProcessorRcPtr *p)
+void OCIO_processorRelease(OCIO_ConstProcessorRcPtr *processor)
 {
-  return impl->processorGetCPUProcessor(p);
+  impl->processorRelease(processor);
 }
 
-void OCIO_processorApply(OCIO_ConstCPUProcessorRcPtr *processor, OCIO_PackedImageDesc *img)
+OCIO_ConstCPUProcessorRcPtr *OCIO_processorGetCPUProcessor(OCIO_ConstProcessorRcPtr *processor)
 {
-  impl->processorApply(processor, img);
+  return impl->processorGetCPUProcessor(processor);
 }
 
-void OCIO_processorApply_predivide(OCIO_ConstCPUProcessorRcPtr *processor,
-                                   OCIO_PackedImageDesc *img)
+void OCIO_cpuProcessorApply(OCIO_ConstCPUProcessorRcPtr *cpu_processor, OCIO_PackedImageDesc *img)
 {
-  impl->processorApply_predivide(processor, img);
+  impl->cpuProcessorApply(cpu_processor, img);
 }
 
-void OCIO_processorApplyRGB(OCIO_ConstCPUProcessorRcPtr *processor, float *pixel)
+void OCIO_cpuProcessorApply_predivide(OCIO_ConstCPUProcessorRcPtr *cpu_processor,
+                                   OCIO_PackedImageDesc *img)
 {
-  impl->processorApplyRGB(processor, pixel);
+  impl->cpuProcessorApply_predivide(cpu_processor, img);
 }
 
-void OCIO_processorApplyRGBA(OCIO_ConstCPUProcessorRcPtr *processor, float *pixel)
+void OCIO_cpuProcessorApplyRGB(OCIO_ConstCPUProcessorRcPtr *cpu_processor, float *pixel)
 {
-  impl->processorApplyRGBA(processor, pixel);
+  impl->cpuProcessorApplyRGB(cpu_processor, pixel);
 }
 
-void OCIO_processorApplyRGBA_predivide(OCIO_ConstCPUProcessorRcPtr *processor, float *pixel)
+void OCIO_cpuProcessorApplyRGBA(OCIO_ConstCPUProcessorRcPtr *cpu_processor, float *pixel)
 {
-  impl->processorApplyRGBA_predivide(processor, pixel);
+  impl->cpuProcessorApplyRGBA(cpu_processor, pixel);
 }
 
-void OCIO_processorRelease(OCIO_ConstProcessorRcPtr *p)
+void OCIO_cpuProcessorApplyRGBA_predivide(OCIO_ConstCPUProcessorRcPtr *processor, float *pixel)
 {
-  impl->processorRelease(p);
+  impl->cpuProcessorApplyRGBA_predivide(processor, pixel);
 }
 
-void OCIO_cpuProcessorRelease(OCIO_ConstCPUProcessorRcPtr *p)
+void OCIO_cpuProcessorRelease(OCIO_ConstCPUProcessorRcPtr *cpu_processor)
 {
-  impl->cpuProcessorRelease(p);
+  impl->cpuProcessorRelease(cpu_processor);
 }
 
 const char *OCIO_colorSpaceGetName(OCIO_ConstColorSpaceRcPtr *cs)
diff --git a/intern/opencolorio/ocio_capi.h b/intern/opencolorio/ocio_capi.h
index d93200c8181..8b319d4ed68 100644
--- a/intern/opencolorio/ocio_capi.h
+++ b/intern/opencolorio/ocio_capi.h
@@ -158,17 +158,16 @@ void OCIO_lookRelease(OCIO_ConstLookRcPtr *look);
 OCIO_ConstProcessorRcPtr *OCIO_configGetProcessorWithNames(OCIO_ConstConfigRcPtr *config,
                                                            const char *srcName,
                                                            const char *dstName);
+void OCIO_processorRelease(OCIO_ConstProcessorRcPtr *cpu_processor);
 
-OCIO_ConstCPUProcessorRcPtr *OCIO_processorGetCPUProcessor(OCIO_ConstProcessorRcPtr *p);
-void OCIO_processorApply(OCIO_ConstCPUProcessorRcPtr *processor, OCIO_PackedImageDesc *img);
-void OCIO_processorApply_predivide(OCIO_ConstCPUProcessorRcPtr *processor,
+OCIO_ConstCPUProcessorRcPtr *OCIO_processorGetCPUProcessor(OCIO_ConstProcessorRcPtr *processor);
+void OCIO_cpuProcessorApply(OCIO_ConstCPUProcessorRcPtr *cpu_processor, OCIO_PackedImageDesc *img);
+void OCIO_cpuProcessorApply_predivide(OCIO_ConstCPUProcessorRcPtr *cpu_processor,
                                    OCIO_PackedImageDesc *img);
-void OCIO_processorApplyRGB(OCIO_ConstCPUProcessorRcPtr *processor, float *pixel);
-void OCIO_processorApplyRGBA(OCIO_ConstCPUProcessorRcPtr *processor, float *pixel);
-void OCIO_processorApplyRGBA_predivide(OCIO_ConstCPUProcessorRcPtr *processor, float *pixel);
-
-void OCIO_processorRelease(OCIO_ConstProcessorRcPtr *p);
-void OCIO_cpuProcessorRelease(OCIO_ConstCPUProcessorRcPtr *p);
+void OCIO_cpuProcessorApplyRGB(OCIO_ConstCPUProcessorRcPtr *cpu_processor, float *pixel);
+void OCIO_cpuProcessorApplyRGBA(OCIO_ConstCPUProcessorRcPtr *cpu_processor, float *pixel);
+void OCIO_cpuProcessorApplyRGBA_predivide(OCIO_ConstCPUProcessorRcPtr *cpu_processor, float *pixel);
+void OCIO_cpuProcessorRelease(OCIO_ConstCPUProcessorRcPtr *processor);
 
 const char *OCIO_colorSpaceGetName(OCIO_ConstColorSpaceRcPtr *cs);
 const char *OCIO_colorSpaceGetDescription(OCIO_ConstColorSpaceRcPtr *cs);
diff --git a/intern/opencolorio/ocio_impl.cc b/intern/opencolorio/ocio_impl.cc
index e73f41cae6d..69a8d8b17af 100644
--- a/intern/opencolorio/ocio_impl.cc
+++ b/intern/opencolorio/ocio_impl.cc
@@ -284,9 +284,9 @@ void OCIOImpl::configGetDefaultLumaCoefs(OCIO_ConstConfigRcPtr *config, float *r
   try {
     double rgb_double[3];
     (*(ConstConfigRcPtr *)config)->getDefaultLumaCoefs(rgb_double);
-    rgb[0] = (float)rgb_double[0];
-    rgb[1] = (float)rgb_double[1];
-    rgb[2] = (float)rgb_double[2];
+    rgb[0] = rgb_double[0];
+    rgb[1] = rgb_double[1];
+    rgb[2] = rgb_double[2];
   }
   catch (Exception &exception) {
     OCIO_reportException(exception);
@@ -310,23 +310,15 @@ static bool to_scene_linear_matrix(ConstConfigRcPtr &config,
     return false;
   }
 
-  ConstCPUProcessorRcPtr device_processor = processor->getDefaultCPUProcessor();
-  if (!device_processor) {
+  ConstCPUProcessorRcPtr cpu_processor = processor->getDefaultCPUProcessor();
+  if (!cpu_processor) {
     return false;
   }
 
-  to_scene_linear[0][0] = 1.0f;
-  to_scene_linear[0][1] = 0.0f;
-  to_scene_linear[0][2] = 0.0f;
-  to_scene_linear[1][0] = 0.0f;
-  to_scene_linear[1][1] = 1.0f;
-  to_scene_linear[1][2] = 0.0f;
-  to_scene_linear[2][0] = 0.0f;
-  to_scene_linear[2][1] = 0.0f;
-  to_scene_linear[2][2] = 1.0f;
-  device_processor->applyRGB(to_scene_linear[0]);
-  device_processor->applyRGB(to_scene_linear[1]);
-  device_processor->applyRGB(to_scene_linear[2]);
+  unit_m3(to_scene_linear);
+  cpu_processor->applyRGB(to_scene_linear[0]);
+  cpu_processor->applyRGB(to_scene_linear[1]);
+  cpu_processor->applyRGB(to_scene_linear[2]);
   return true;
 }
 
@@ -354,7 +346,7 @@ void OCIOImpl::configGetXYZtoRGB(OCIO_ConstConfigRcPtr *config_, float xyz_to_rg
   }
   else if (config->hasRole("XYZ")) {
     /* Custom role used before the standard existed. */
-    to_scene_linear_matrix(config, "XXYZ", xyz_to_rgb);
+    to_scene_linear_matrix(config, "XYZ", xyz_to_rgb);
   }
 }
 
@@ -476,7 +468,7 @@ void OCIOImpl::colorSpaceIsBuiltin(OCIO_ConstConfigRcPtr *config_,
     return;
   }
 
-  ConstCPUProcessorRcPtr device_processor = processor->getDefaultCPUProcessor();
+  ConstCPUProcessorRcPtr cpu_processor = processor->getDefaultCPUProcessor();
 
   is_scene_linear = true;
   is_srgb = true;
@@ -487,10 +479,10 @@ void OCIOImpl::colorSpaceIsBuiltin(OCIO_ConstConfigRcPtr *config_,
     float cG[3] = {0, v, 0};
     float cB[3] = {0, 0, v};
     float cW[3] = {v, v, v};
-    device_processor->applyRGB(cR);
-    device_processor->applyRGB(cG);
-    device_processor->applyRGB(cB);
-    device_processor->applyRGB(cW);
+    cpu_processor->applyRGB(cR);
+    cpu_processor->applyRGB(cG);
+    cpu_processor->applyRGB(cB);
+    cpu_processor->applyRGB(cW);
 
     /* Make sure that there is no channel crosstalk. */
     if (fabsf(cR[1]) > 1e-5f || fabsf(cR[2]) > 1e-5f || fabsf(cG[0]) > 1e-5f ||
@@ -532,43 +524,49 @@ OCIO_ConstProcessorRcPtr *OCIOImpl::configGetProcessorWithNames(OCIO_ConstConfig
                                                                 const char *srcName,
                                                                 const char *dstName)
 {
-  ConstProcessorRcPtr *p = OBJECT_GUARDED_NEW(ConstProcessorRcPtr);
+  ConstProcessorRcPtr *processor = OBJECT_GUARDED_NEW(ConstProcessorRcPtr);
 
   try {
-    *p = (*(ConstConfigRcPtr *)config)->getProcessor(srcName, dstName);
+    *processor = (*(ConstConfigRcPtr *)config)->getProcessor(srcName, dstName);
 
-    if (*p)
-      return (OCIO_ConstProcessorRcPtr *)p;
+    if (*processor)
+      return (OCIO_ConstProcessorRcPtr *)processor;
   }
   catch (Exception &exception) {
     OCIO_reportException(exception);
   }
 
-  OBJECT_GUARDED_DELETE(p, ConstProcessorRcPtr);
+  OBJECT_GUARDED_DELETE(processor, ConstProcessorRcPtr);
 
   return 0;
 }
 
+void OCIOImpl::processorRelease(OCIO_ConstProcessorRcPtr *processor)
+{
+  OBJECT_GUARDED_DELETE(processor, ConstProcessorRcPtr);
+}
+
 OCIO_ConstCPUProcessorRcPtr *OCIOImpl::processorGetCPUProcessor(
     OCIO_ConstProcessorRcPtr *processor)
 {
-  ConstCPUProcessorRcPtr *p = OBJECT_GUARDED_NEW(ConstCPUProcessorRcPtr);
-  *p = (*(ConstProcessorRcPtr *)processor)->getDefaultCPUProcessor();
-  return (OCIO_ConstCPUProcessorRcPtr *)p;
+  ConstCPUProcessorRcPtr *cpu_processor = OBJECT_GUARDED_NEW(ConstCPUProcessorRcPtr);
+  *cpu_processor = (*(ConstProcessorRcPtr *)processor)->getDefaultCPUProcessor();
+  return (OCIO_ConstCPUProcessorRcPtr *)cpu_processor;
 }
 
-void OCIOImpl::processorApply(OCIO_ConstCPUProcessorRcPtr *processor, OCIO_PackedImageDesc *img)
+void OCIOImpl::cpuProcessorApply(OCIO_ConstCPUProcessorRcPtr *cpu_processor,
+                                 OCIO_PackedImageDesc *img)
 {
   try {
-    (*(ConstCPUProcessorRcPtr *)processor)->apply(*(PackedImageDesc *)img);
+    (*(ConstCPUProcessorRcPtr *)cpu_processor)->apply(*(PackedImageDesc *)img);
   }
   catch (Exception &exception) {
     OCIO_reportException(exception);
   }
 }
 
-void OCIOImpl::processorApply_predivide(OCIO_ConstCPUProcessorRcPtr *processor,
-                                        OCIO_PackedImageDesc *img_)
+void OCIOImpl::cpuProcessorApply_predivide(OCIO_ConstCPUProcessorRcPtr *cpu_processor,
+                                           OCIO_PackedImageDesc *img_)
 {
   try {
     PackedImageDesc *img = (PackedImageDesc *)img_;
@@ -585,12 +583,12 @@ void OCIOImpl::processorApply_predivide(OCIO_ConstCPUProcessorRcPtr *processor,
         for (int x = 0; x < width; x++) {
           float *pixel = pixels + 4 * (y * width + x);
 
-          processorApplyRGBA_predivide(processor, pixel);
+          cpuProcessorApplyRGBA_predivide(cpu_processor, pixel);
         }
       }
     }
     else {
-      (*(ConstCPUProcessorRcPtr *)processor)->apply(*img);
+      (*(ConstCPUProcessorRcPtr *)cpu_processor)->apply(*img);
     }
   }
   catch (Exception &exception) {
@@ -598,20 +596,21 @@ void OCIOImpl::processorApply_predivide(OCIO_ConstCPUProcessorRcPtr *processor,
   }
 }
 
-void OCIOImpl::processorApplyRGB(OCIO_ConstCPUProcessorRcPtr *processor, float *pixel)
+void OCIOImpl::cpuProcessorApplyRGB(OCIO_ConstCPUProcessorRcPtr *cpu_processor, float *pixel)
 {
-  (*(ConstCPUProcessorRcPtr *)processor)->applyRGB(pixel);
+  (*(ConstCPUProcessorRcPtr *)cpu_processor)->applyRGB(pixel);
 }
 
-void OCIOImpl::processorApplyRGBA(OCIO_ConstCPUProcessorRcPtr *processor, float *pixel)
+void OCIOImpl::cpuProcessorApplyRGBA(OCIO_ConstCPUProcessorRcPtr *cpu_processor, float *pixel)
 {
-  (*(ConstCPUProcessorRcPtr *)processor)->applyRGBA(pixel);
+  (*(ConstCPUProcessorRcPtr *)cpu_processor)->applyRGBA(pixel);
 }
 
-void OCIOImpl::processorApplyRGBA_predivide(OCIO_ConstCPUProcessorRcPtr *processor, float *pixel)
+void OCIOImpl::cpuProcessorApplyRGBA_predivide(OCIO_ConstCPUProcessorRcPtr *cpu_processor,
+                                               float *pixel)
 {
   if (pixel[3] == 1.0f || pixel[3] == 0.0f) {
-    (*(ConstCPUProcessorRcPtr *)processor)->applyRGBA(pixel);
+    (*(ConstCPUProcessorRcPtr *)cpu_processor)->applyRGBA(pixel);
   }
   else {
     float alpha, inv_alpha;
@@ -623,7 +622,7 @@ void OCIOImpl::processorApplyRGBA_predivide(OCIO_ConstCPUProcessorRcPtr *process
     pixel[1] *= inv_alpha;
     pixel[2] *= inv_alpha;
 
-    (*(ConstCPUProcessorRcPtr *)processor)->applyRGBA(pixel);
+    (*(ConstCPUProcessorRcPtr *)cpu_processor)->applyRGBA(pixel);
 
     pixel[0] *= alpha;
     pixel[1] *= alpha;
@@ -631,14 +630,9 @@ void OCIOImpl::processorApplyRGBA_predivide(OCIO_ConstCPUProcessorRcPtr *process
   }
 }
 
-void OCIOImpl::processorRelease(OCIO_ConstProcessorRcPtr *p)
-{
-  OBJECT_GUARDED_DELETE(p, ConstProcessorRcPtr);
-}
-
-void OCIOImpl::cpuProcessorRelease(OCIO_ConstCPUProcessorRcPtr *p)
+void OCIOImpl::cpuProcessorRelease(OCIO_ConstCPUProcessorRcPtr *cpu_processor)
 {
-  OBJECT_GUARDED_DELETE(p, ConstCPUProcessorRcPtr);
+  OBJECT_GUARDED_DELETE(cpu_processor, ConstCPUProcessorRcPtr);
 }
 
 const char *OCIOImpl::colorSpaceGetName(OCIO_ConstColorSpaceRcPtr *cs)
@@ -669,7 +663,7 @@ OCIO_ConstProcessorRcPtr *OCIOImpl::createDisplayProcessor(OCIO_ConstConfigRcPtr
   GroupTransformRcPtr group = GroupTransform::Create();
 
   /* Exposure. */
-  if (scale != 1.0) {
+  if (scale != 1.0f) {
     /* Always apply exposure in scene linear. */
     ColorSpaceTransformRcPtr ct = ColorSpaceTransform::Create();
     ct->setSrc(input);
@@ -688,7 +682,8 @@ OCIO_ConstProcessorRcPtr *OCIOImpl::createDisplayProcessor(OCIO_ConstConfigRcPtr
   }
 
   /* Add look transform. */
-  if (strlen(look)) {
+  const bool use_look = (strlen(look) != 0);
+  if (use_look) {
     const char *look_output = LookTransform::GetLooksResultColorSpace(
         config, config->getCurrentContext(), look);
 
@@ -705,20 +700,21 @@ OCIO_ConstProcessorRcPtr *OCIOImpl::createDisplayProcessor(OCIO_ConstConfigRcPtr
   /* Add view and display transform. */
   DisplayViewTransformRcPtr dvt = DisplayViewTransform::Create();
   dvt->setSrc(input);
-  dvt->setLooksBypass(look != NULL);
+  dvt->setLooksBypass(use_look);
   dvt->setView(view);
   dvt->setDisplay(display);
   group->appendTransform(dvt);
 
   /* Gamma. */
-  if (exponent != 1.0) {
+  if (exponent != 1.0f) {
     ExponentTransformRcPtr et = ExponentTransform::Create();
     const double value[4] = {exponent, exponent, exponent, 1.0};
     et->setValue(value);
     group->appendTransform(et);
   }
 
-  /* Create processor from transform. */
+  /* Create processor from transform. This is the moment were OCIO validates
+   * the entire transform, no need to check for the validity of inputs above. */
   ConstProcessorRcPtr *p = OBJECT_GUARDED_NEW(ConstProcessorRcPtr);
 
   try {
diff --git a/intern/opencolorio/ocio_impl.h b/intern/opencolorio/ocio_impl.h
index 870432cf367..0c759a35e15 100644
--- a/intern/opencolorio/ocio_impl.h
+++ b/intern/opencolorio/ocio_impl.h
@@ -76,19 +76,18 @@ class IOCIOImpl {
   virtual OCIO_ConstProcessorRcPtr *configGetProcessorWithNames(OCIO_ConstConfigRcPtr *config,
                                                                 const char *srcName,
                                                                 const char *dstName) = 0;
-  virtual OCIO_ConstCPUProcessorRcPtr *processorGetCPUProcessor(OCIO_ConstProcessorRcPtr *p) = 0;
-
-  virtual void processorApply(OCIO_ConstCPUProcessorRcPtr *processor,
-                              OCIO_PackedImageDesc *img) = 0;
-  virtual void processorApply_predivide(OCIO_ConstCPUProcessorRcPtr *processor,
-                                        OCIO_PackedImageDesc *img) = 0;
-  virtual void processorApplyRGB(OCIO_ConstCPUProcessorRcPtr *processor, float *pixel) = 0;
-  virtual void processorApplyRGBA(OCIO_ConstCPUProcessorRcPtr *processor, float *pixel) = 0;
-  virtual void processorApplyRGBA_predivide(OCIO_ConstCPUProcessorRcPtr *processor,
-                                            float *pixel) = 0;
+  virtual void processorRelease(OCIO_ConstProcessorRcPtr *processor) = 0;
 
-  virtual void processorRelease(OCIO_ConstProcessorRcPtr *p) = 0;
-  virtual void cpuProcessorRelease(OCIO_ConstCPUProcessorRcPtr *p) = 0;
+  virtual OCIO_ConstCPUProcessorRcPtr *processorGetCPUProcessor(OCIO_ConstProcessorRcPtr *p) = 0;
+  virtual void cpuProcessorApply(OCIO_ConstCPUProcessorRcPtr *cpu_processor,
+                                 OCIO_PackedImageDesc *img) = 0;
+  virtual void cpuProcessorApply_predivide(OCIO_ConstCPUProcessorRcPtr *cpu_processor,
+                                           OCIO_PackedImageDesc *img) = 0;
+  virtual void cpuProcessorApplyRGB(OCIO_ConstCPUProcessorRcPtr *cpu_processor, float *pixel) = 0;
+  virtual void cpuProcessorApplyRGBA(OCIO_ConstCPUProcessorRcPtr *cpu_processor, float *pixel) = 0;
+  virtual void cpuProcessorApplyRGBA_predivide(OCIO_ConstCPUProcessorRcPtr *cpu_processor,
+                                               float *pixel) = 0;
+  virtual void cpuProcessorRelease(OCIO_ConstCPUProcessorRcPtr *cpu_processor) = 0;
 
   virtual const char *colorSpaceGetName(OCIO_ConstColorSpaceRcPtr *cs) = 0;
   virtual const char *colorSpaceGetDescription(OCIO_ConstColorSpaceRcPtr *cs) = 0;
@@ -117,17 +116,17 @@ class IOCIOImpl {
   {
     return false;
   }
-  virtual bool gpuDisplayShaderBind(OCIO_ConstConfigRcPtr * /* config */,
-                                    const char * /* input */,
-                                    const char * /* view */,
-                                    const char * /* display */,
-                                    const char * /* look */,
-                                    OCIO_CurveMappingSettings * /* curve_mapping_settings */,
-                                    const float /* scale */,
-                                    const float /* exponent */,
-                                    const float /* dither */,
-                                    const bool /* use_predivide */,
-                                    const bool /* use_overlay */)
+  virtual bool gpuDisplayShaderBind(OCIO_ConstConfigRcPtr * /*config*/,
+                                    const char * /*input*/,
+                                    const char * /*view*/,
+                                    const char * /*display*/,
+                                    const char * /*look*/,
+                                    OCIO_CurveMappingSettings * /*curve_mapping_settings*/,
+                                    const float /*scale*/,
+                                    const float /*exponent*/,
+                                    const float /*dither*/,
+                                    const bool /*use_predivide*/,
+                                    const bool /*use_overlay*/)
   {
     return false;
   }
@@ -193,16 +192,16 @@ class FallbackImpl : public IOCIOImpl {
   OCIO_ConstProcessorRcPtr *configGetProcessorWithNames(OCIO_ConstConfigRcPtr *config,
                                                         const char *srcName,
                                                         const char *dstName);
-  OCIO_ConstCPUProcessorRcPtr *processorGetCPUProcessor(OCIO_ConstProcessorRcPtr *p);
+  void processorRelease(OCIO_ConstProcessorRcPtr *processor);
 
-  void processorApply(OCIO_ConstCPUProcessorRcPtr *processor, OCIO_PackedImageDesc *img);
-  void processorApply_predivide(OCIO_ConstCPUProcessorRcPtr *processor, OCIO_PackedImageDesc *img);
-  void processorApplyRGB(OCIO_ConstCPUProcessorRcPtr *processor, float *pixel);
-  void processorApplyRGBA(OCIO_ConstCPUProcessorRcPtr *processor, float *pixel);
-  void processorApplyRGBA_predivide(OCIO_ConstCPUProcessorRcPtr *processor, float *pixel);
-
-  void processorRelease(OCIO_ConstProcessorRcPtr *p);
-  void cpuProcessorRelease(OCIO_ConstCPUProcessorRcPtr *p);
+  OCIO_ConstCPUProcessorRcPtr *processorGetCPUProcessor(OCIO_ConstProcessorRcPtr *processor);
+  void cpuProcessorApply(OCIO_ConstCPUProcessorRcPtr *cpu_processor, OCIO_PackedImageDesc *img);
+  void cpuProcessorApply_predivide(OCIO_ConstCPUProcessorRcPtr *cpu_processor,
+                                   OCIO_PackedImageDesc *img);
+  void cpuProcessorApplyRGB(OCIO_ConstCPUProcessorRcPtr *cpu_processor, float *pixel);
+  void cpuProcessorApplyRGBA(OCIO_ConstCPUProcessorRcPtr *cpu_processor, float *pixel);
+  void cpuProcessorApplyRGBA_predivide(OCIO_ConstCPUProcessorRcPtr *cpu_processor, float *pixel);
+  void cpuProcessorRelease(OCIO_ConstCPUProcessorRcPtr *cpu_processor);
 
   const char *colorSpaceGetName(OCIO_ConstColorSpaceRcPtr *cs);
   const char *colorSpaceGetDescription(OCIO_ConstColorSpaceRcPtr *cs);
@@ -280,16 +279,16 @@ class OCIOImpl : public IOCIOImpl {
   OCIO_ConstProcessorRcPtr *configGetProcessorWithNames(OCIO_ConstConfigRcPtr *config,
                                                         const char *srcName,
                                                         const char *dstName);
-  OCIO_ConstCPUProcessorRcPtr *processorGetCPUProcessor(OCIO_ConstProcessorRcPtr *p);
-
-  void processorApply(OCIO_ConstCPUProcessorRcPtr *processor, OCIO_PackedImageDesc *img);
-  void processorApply_predivide(OCIO_ConstCPUProcessorRcPtr *processor, OCIO_PackedImageDesc *img);
-  void processorApplyRGB(OCIO_ConstCPUProcessorRcPtr *processor, float *pixel);
-  void processorApplyRGBA(OCIO_ConstCPUProcessorRcPtr *processor, float *pixel);
-  void processorApplyRGBA_predivide(OCIO_ConstCPUProcessorRcPtr *processor, float *pixel);
-
-  void processorRelease(OCIO_ConstProcessorRcPtr *p);
-  void cpuProcessorRelease(OCIO_ConstCPUProcessorRcPtr *p);
+  void processorRelease(OCIO_ConstProcessorRcPtr *processor);
+
+  OCIO_ConstCPUProcessorRcPtr *processorGetCPUProcessor(OCIO_ConstProcessorRcPtr *processor);
+  void cpuProcessorApply(OCIO_ConstCPUProcessorRcPtr *cpu_processor, OCIO_PackedImageDesc *img);
+  void cpuProcessorApply_predivide(OCIO_ConstCPUProcessorRcPtr *cpu_processor,
+                                   OCIO_PackedImageDesc *img);
+  void cpuProcessorApplyRGB(OCIO_ConstCPUProcessorRcPtr *cpu_processor, float *pixel);
+  void cpuProcessorApplyRGBA(OCIO_ConstCPUProcessorRcPtr *cpu_processor, float *pixel);
+  void cpuProcessorApplyRGBA_predivide(OCIO_ConstCPUProcessorRcPtr *cpu_processor, float *pixel);
+  void cpuProcessorRelease(OCIO_ConstCPUProcessorRcPtr *cpu_processor);
 
   const char *colorSpaceGetName(OCIO_ConstColorSpaceRcPtr *cs);
   const char *colorSpaceGetDescription(OCIO_ConstColorSpaceRcPtr *cs);
diff --git a/source/blender/imbuf/intern/colormanagement.c b/source/blender/imbuf/intern/colormanagement.c
index f0db3ff3f1f..630e2e8c3fb 100644
--- a/source/blender/imbuf/intern/colormanagement.c
+++ b/source/blender/imbuf/intern/colormanagement.c
@@ -101,7 +101,7 @@ static float imbuf_linear_srgb_to_xyz[3][3] = {{0.0f}};
 static pthread_mutex_t processor_lock = BLI_MUTEX_INITIALIZER;
 
 typedef struct ColormanageProcessor {
-  OCIO_ConstCPUProcessorRcPtr *processor;
+  OCIO_ConstCPUProcessorRcPtr *cpu_processor;
   CurveMapping *curve_mapping;
   bool is_data_result;
 } ColormanageProcessor;
@@ -119,8 +119,8 @@ static struct global_gpu_state {
 
 static struct global_color_picking_state {
   /* Cached processor for color picking conversion. */
-  OCIO_ConstCPUProcessorRcPtr *processor_to;
-  OCIO_ConstCPUProcessorRcPtr *processor_from;
+  OCIO_ConstCPUProcessorRcPtr *cpu_processor_to;
+  OCIO_ConstCPUProcessorRcPtr *cpu_processor_from;
   bool failed;
 } global_color_picking_state = {NULL};
 
@@ -721,12 +721,12 @@ void colormanagement_exit(void)
     MEM_freeN(global_gpu_state.curve_mapping_settings.lut);
   }
 
-  if (global_color_picking_state.processor_to) {
-    OCIO_cpuProcessorRelease(global_color_picking_state.processor_to);
+  if (global_color_picking_state.cpu_processor_to) {
+    OCIO_cpuProcessorRelease(global_color_picking_state.cpu_processor_to);
   }
 
-  if (global_color_picking_state.processor_from) {
-    OCIO_cpuProcessorRelease(global_color_picking_state.processor_from);
+  if (global_color_picking_state.cpu_processor_from) {
+    OCIO_cpuProcessorRelease(global_color_picking_state.cpu_processor_from);
   }
 
   memset(&global_gpu_state, 0, sizeof(global_gpu_state));
@@ -882,7 +882,7 @@ static OCIO_ConstCPUProcessorRcPtr *colorspace_to_scene_linear_cpu_processor(
       OCIO_ConstProcessorRcPtr *processor = create_colorspace_transform_processor(
           colorspace->name, global_role_scene_linear);
 
-      if (processor) {
+      if (processor != NULL) {
         colorspace->to_scene_linear = (struct OCIO_ConstCPUProcessorRcPtr *)
             OCIO_processorGetCPUProcessor(processor);
         OCIO_processorRelease(processor);
@@ -905,7 +905,7 @@ static OCIO_ConstCPUProcessorRcPtr *colorspace_from_scene_linear_cpu_processor(
       OCIO_ConstProcessorRcPtr *processor = create_colorspace_transform_processor(
           global_role_scene_linear, colorspace->name);
 
-      if (processor) {
+      if (processor != NULL) {
         colorspace->from_scene_linear = (struct OCIO_ConstCPUProcessorRcPtr *)
             OCIO_processorGetCPUProcessor(processor);
         OCIO_processorRelease(processor);
@@ -938,7 +938,7 @@ static OCIO_ConstCPUProcessorRcPtr *display_from_scene_linear_processor(
         OCIO_configRelease(config);
       }
 
-      if (processor) {
+      if (processor != NULL) {
         display->from_scene_linear = (struct OCIO_ConstCPUProcessorRcPtr *)
             OCIO_processorGetCPUProcessor(processor);
         OCIO_processorRelease(processor);
@@ -970,7 +970,7 @@ static OCIO_ConstCPUProcessorRcPtr *display_to_scene_linear_processor(ColorManag
         OCIO_configRelease(config);
       }
 
-      if (processor) {
+      if (processor != NULL) {
         display->to_scene_linear = (struct OCIO_ConstCPUProcessorRcPtr *)
             OCIO_processorGetCPUProcessor(processor);
         OCIO_processorRelease(processor);
@@ -2113,8 +2113,8 @@ void IMB_colormanagement_colorspace_to_scene_linear_v3(float pixel[3], ColorSpac
 
   processor = colorspace_to_scene_linear_cpu_processor(colorspace);
 
-  if (processor) {
-    OCIO_processorApplyRGB(processor, pixel);
+  if (processor != NULL) {
+    OCIO_cpuProcessorApplyRGB(processor, pixel);
   }
 }
 
@@ -2131,8 +2131,8 @@ void IMB_colormanagement_scene_linear_to_colorspace_v3(float pixel[3], ColorSpac
 
   processor = colorspace_from_scene_linear_cpu_processor(colorspace);
 
-  if (processor) {
-    OCIO_processorApplyRGB(processor, pixel);
+  if (processor != NULL) {
+    OCIO_cpuProcessorApplyRGB(processor, pixel);
   }
 }
 
@@ -2150,12 +2150,12 @@ void IMB_colormanagement_colorspace_to_scene_linear_v4(float pixel[4],
 
   processor = colorspace_to_scene_linear_cpu_processor(colorspace);
 
-  if (processor) {
+  if (processor != NULL) {
     if (predivide) {
-      OCIO_processorApplyRGBA_predivide(processor, pixel);
+      OCIO_cpuProcessorApplyRGBA_predivide(processor, pixel);
     }
     else {
-      OCIO_processorApplyRGBA(processor, pixel);
+      OCIO_cpuProcessorApplyRGBA(processor, pixel);
     }
   }
 }
@@ -2177,7 +2177,7 @@ void IMB_colormanagement_colorspace_to_scene_linear(float *buffer,
 
   processor = colorspace_to_scene_linear_cpu_processor(colorspace);
 
-  if (processor) {
+  if (processor != NULL) {
     OCIO_PackedImageDesc *img;
 
     img = OCIO_createOCIO_PackedImageDesc(buffer,
@@ -2189,10 +2189,10 @@ void IMB_colormanagement_colorspace_to_scene_linear(float *buffer,
                                           (size_t)channels * sizeof(float) * width);
 
     if (predivide) {
-      OCIO_processorApply_predivide(processor, img);
+      OCIO_cpuProcessorApply_predivide(processor, img);
     }
     else {
-      OCIO_processorApply(processor, img);
+      OCIO_cpuProcessorApply(processor, img);
     }
 
     OCIO_PackedImageDescRelease(img);
@@ -2229,12 +2229,12 @@ void IMB_colormanagement_imbuf_to_byte_texture(unsigned char *out_buffer,
     const unsigned char *in = in_buffer + in_offset * 4;
     unsigned char *out = out_buffer + out_offset * 4;
 
-    if (processor) {
+    if (processor != NULL) {
       /* Convert to scene linear, to sRGB and premultiply. */
       for (int x = 0; x < width; x++, in += 4, out += 4) {
         float pixel[4];
         rgba_uchar_to_float(pixel, in);
-        OCIO_processorApplyRGB(processor, pixel);
+        OCIO_cpuProcessorApplyRGB(processor, pixel);
         linearrgb_to_srgb_v3_v3(pixel, pixel);
         if (use_premultiply) {
           mul_v3_fl(pixel, pixel[3]);
@@ -2325,16 +2325,16 @@ void IMB_colormanagement_imbuf_to_float_texture(float *out_buffer,
  */
 void IMB_colormanagement_scene_linear_to_color_picking_v3(float pixel[3])
 {
-  if (!global_color_picking_state.processor_to && !global_color_picking_state.failed) {
+  if (!global_color_picking_state.cpu_processor_to && !global_color_picking_state.failed) {
     /* Create processor if none exists. */
     BLI_mutex_lock(&processor_lock);
 
-    if (!global_color_picking_state.processor_to && !global_color_picking_state.failed) {
+    if (!global_color_picking_state.cpu_processor_to && !global_color_picking_state.failed) {
       OCIO_ConstProcessorRcPtr *processor = create_colorspace_transform_processor(
           global_role_scene_linear, global_role_color_picking);
 
-      if (processor) {
-        global_color_picking_state.processor_to = OCIO_processorGetCPUProcessor(processor);
+      if (processor != NULL) {
+        global_color_picking_state.cpu_processor_to = OCIO_processorGetCPUProcessor(processor);
         OCIO_processorRelease(processor);
       }
       else {
@@ -2345,23 +2345,23 @@ void IMB_colormanagement_scene_linear_to_color_picking_v3(float pixel[3])
     BLI_mutex_unlock(&processor_lock);
   }
 
-  if (global_color_picking_state.processor_to) {
-    OCIO_processorApplyRGB(global_color_picking_state.processor_to, pixel);
+  if (global_color_picking_state.cpu_processor_to) {
+    OCIO_cpuProcessorApplyRGB(global_color_picking_state.cpu_processor_to, pixel);
   }
 }
 
 void IMB_colormanagement_color_picking_to_scene_linear_v3(float pixel[3])
 {
-  if (!global_color_picking_state.processor_from && !global_color_picking_state.failed) {
+  if (!global_color_picking_state.cpu_processor_from && !global_color_picking_state.failed) {
     /* Create processor if none exists. */
     BLI_mutex_lock(&processor_lock);
 
-    if (!global_color_picking_state.processor_from && !global_color_picking_state.failed) {
+    if (!global_color_picking_state.cpu_processor_from && !global_color_picking_state.failed) {
       OCIO_ConstProcessorRcPtr *processor = create_colorspace_transform_processor(
           global_role_color_picking, global_role_scene_linear);
 
-      if (processor) {
-        global_color_picking_state.processor_from = OCIO_processorGetCPUProcessor(processor);
+      if (processor != NULL) {
+        global_color_picking_state.cpu_processor_from = OCIO_processorGetCPUProcessor(processor);
         OCIO_processorRelease(processor);
       }
       else {
@@ -2372,8 +2372,8 @@ void IMB_colormanagement_color_picking_to_scene_linear_v3(float pixel[3])
     BLI_mutex_unlock(&processor_lock);
   }
 
-  if (global_color_picking_state.processor_from) {
-    OCIO_processorApplyRGB(global_color_picking_state.processor_from, pixel);
+  if (global_color_picking_state.cpu_processor_from) {
+    OCIO_cpuProcessorApplyRGB(global_color_picking_state.cpu_processor_from, pixel);
   }
 }
 
@@ -2401,8 +2401,8 @@ void IMB_colormanagement_scene_linear_to_display_v3(float pixel[3], ColorManaged
 {
   OCIO_ConstCPUProcessorRcPtr *processor = display_from_scene_linear_processor(display);
 
-  if (processor) {
-    OCIO_processorApplyRGB(processor, pixel);
+  if (processor != NULL) {
+    OCIO_cpuProcessorApplyRGB(processor, pixel);
   }
 }
 
@@ -2411,8 +2411,8 @@ void IMB_colormanagement_display_to_scene_linear_v3(float pixel[3], ColorManaged
 {
   OCIO_ConstCPUProcessorRcPtr *processor = display_to_scene_linear_processor(display);
 
-  if (processor) {
-    OCIO_processorApplyRGB(processor, pixel);
+  if (processor != NULL) {
+    OCIO_cpuProcessorApplyRGB(processor, pixel);
   }
 }
 
@@ -3772,12 +3772,13 @@ ColormanageProcessor *IMB_colormanagement_display_processor_new(
     cm_processor->is_data_result = display_space->is_data;
   }
 
-  cm_processor->processor = create_display_buffer_processor(applied_view_settings->look,
-                                                            applied_view_settings->view_transform,
-                                                            display_settings->display_device,
-                                                            applied_view_settings->exposure,
-                                                            applied_view_settings->gamma,
-                                                            global_role_scene_linear);
+  cm_processor->cpu_processor = create_display_buffer_processor(
+      applied_view_settings->look,
+      applied_view_settings->view_transform,
+      display_settings->display_device,
+      applied_view_settings->exposure,
+      applied_view_settings->gamma,
+      global_role_scene_linear);
 
   if (applied_view_settings->flag & COLORMANAGE_VIEW_USE_CURVES) {
     cm_processor->curve_mapping = BKE_curvemapping_copy(applied_view_settings->curve_mapping);
@@ -3800,8 +3801,8 @@ ColormanageProcessor *IMB_colormanagement_colorspace_processor_new(const char *f
 
   OCIO_ConstProcessorRcPtr *processor = create_colorspace_transform_processor(from_colorspace,
                                                                               to_colorspace);
-  if (processor) {
-    cm_processor->processor = OCIO_processorGetCPUProcessor(processor);
+  if (processor != NULL) {
+    cm_processor->cpu_processor = OCIO_processorGetCPUProcessor(processor);
   }
   OCIO_processorRelease(processor);
 
@@ -3814,8 +3815,8 @@ void IMB_colormanagement_processor_apply_v4(ColormanageProcessor *cm_processor,
     BKE_curvemapping_evaluate_premulRGBF(cm_processor->curve_mapping, pixel, pixel);
   }
 
-  if (cm_processor->processor) {
-    OCIO_processorApplyRGBA(cm_processor->processor, pixel);
+  if (cm_processor->cpu_processor) {
+    OCIO_cpuProcessorApplyRGBA(cm_processor->cpu_processor, pixel);
   }
 }
 
@@ -3826,8 +3827,8 @@ void IMB_colormanagement_processor_apply_v4_predivide(ColormanageProcessor *cm_p
     BKE_curvemapping_evaluate_premulRGBF(cm_processor->curve_mapping, pixel, pixel);
   }
 
-  if (cm_processor->processor) {
-    OCIO_processorApplyRGBA_predivide(cm_processor->processor, pixel);
+  if (cm_processor->cpu_processor) {
+    OCIO_cpuProcessorApplyRGBA_predivide(cm_processor->cpu_processor, pixel);
   }
 }
 
@@ -3837,8 +3838,8 @@ void IMB_colormanagement_processor_apply_v3(ColormanageProcessor *cm_processor,
     BKE_curvemapping_evaluate_premulRGBF(cm_processor->curve_mapping, pixel, pixel);
   }
 
-  if (cm_processor->processor) {
-    OCIO_processorApplyRGB(cm_processor->processor, pixel);
+  if (cm_processor->cpu_processor) {
+    OCIO_cpuProcessorApplyRGB(cm_processor->cpu_processor, pixel);
   }
 }
 
@@ -3883,7 +3884,7 @@ void IMB_colormanagement_processor_apply(ColormanageProcessor *cm_processor,
     }
   }
 
-  if (cm_processor->processor && channels >= 3) {
+  if (cm_processor->cpu_processor && channels >= 3) {
     OCIO_PackedImageDesc *img;
 
     /* apply OCIO processor */
@@ -3896,10 +3897,10 @@ void IMB_colormanagement_processor_apply(ColormanageProcessor *cm_processor,
                                           (size_t)channels * sizeof(float) * width);
 
     if (predivide) {
-      OCIO_processorApply_predivide(cm_processor->processor, img);
+      OCIO_cpuProcessorApply_predivide(cm_processor->cpu_processor, img);
     }
     else {
-      OCIO_processorApply(cm_processor->processor, img);
+      OCIO_cpuProcessorApply(cm_processor->cpu_processor, img);
     }
 
     OCIO_PackedImageDescRelease(img);
@@ -3929,8 +3930,8 @@ void IMB_colormanagement_processor_free(ColormanageProcessor *cm_processor)
   if (cm_processor->curve_mapping) {
     BKE_curvemapping_free(cm_processor->curve_mapping);
   }
-  if (cm_processor->processor) {
-    OCIO_cpuProcessorRelease(cm_processor->processor);
+  if (cm_processor->cpu_processor) {
+    OCIO_cpuProcessorRelease(cm_processor->cpu_processor);
   }
 
   MEM_freeN(cm_processor);