ClangFormat: apply to source, most of intern

Apply clang format as proposed in T53211.

For details on usage and instructions for migrating branches
without conflicts, see:

https://wiki.blender.org/wiki/Tools/ClangFormat

9 files changed, 1840 insertions, 1710 deletions

diff --git a/intern/opencolorio/CMakeLists.txt b/intern/opencolorio/CMakeLists.txt
index 48d619d8d71..da0956cee86 100644
--- a/intern/opencolorio/CMakeLists.txt
+++ b/intern/opencolorio/CMakeLists.txt
@@ -19,11 +19,11 @@
 # ***** END GPL LICENSE BLOCK *****
 
 set(INC
-	.
-	../glew-mx
-	../guardedalloc
-	../../source/blender/blenlib
-	../../source/blender/gpu
+  .
+  ../glew-mx
+  ../guardedalloc
+  ../../source/blender/blenlib
+  ../../source/blender/gpu
 )
 
 set(INC_SYS
@@ -31,44 +31,44 @@ set(INC_SYS
 )
 
 set(SRC
-	ocio_capi.cc
-	fallback_impl.cc
+  ocio_capi.cc
+  fallback_impl.cc
 
-	ocio_capi.h
-	ocio_impl.h
+  ocio_capi.h
+  ocio_impl.h
 )
 
 set(LIB
 )
 
 if(WITH_OPENCOLORIO)
-	add_definitions(
-		-DWITH_OCIO
-	)
+  add_definitions(
+    -DWITH_OCIO
+  )
 
-	add_definitions(${GL_DEFINITIONS})
+  add_definitions(${GL_DEFINITIONS})
 
-	list(APPEND INC_SYS
-		${OPENCOLORIO_INCLUDE_DIRS}
-		${GLEW_INCLUDE_PATH}
-	)
+  list(APPEND INC_SYS
+    ${OPENCOLORIO_INCLUDE_DIRS}
+    ${GLEW_INCLUDE_PATH}
+  )
 
-	list(APPEND SRC
-		ocio_impl.cc
-		ocio_impl_glsl.cc
-	)
+  list(APPEND SRC
+    ocio_impl.cc
+    ocio_impl_glsl.cc
+  )
 
-	if(WIN32)
-		list(APPEND INC_SYS
-			${BOOST_INCLUDE_DIR}
-		)
-		add_definitions(
-			-DOpenColorIO_STATIC
-		)
-	endif()
+  if(WIN32)
+    list(APPEND INC_SYS
+      ${BOOST_INCLUDE_DIR}
+    )
+    add_definitions(
+      -DOpenColorIO_STATIC
+    )
+  endif()
 
-	data_to_c_simple(gpu_shader_display_transform.glsl SRC)
-	data_to_c_simple(gpu_shader_display_transform_vertex.glsl SRC)
+  data_to_c_simple(gpu_shader_display_transform.glsl SRC)
+  data_to_c_simple(gpu_shader_display_transform_vertex.glsl SRC)
 endif()
 
 
diff --git a/intern/opencolorio/fallback_impl.cc b/intern/opencolorio/fallback_impl.cc
index 33e7e4f46e3..91f009b3b57 100644
--- a/intern/opencolorio/fallback_impl.cc
+++ b/intern/opencolorio/fallback_impl.cc
@@ -28,171 +28,168 @@
 
 using std::max;
 
-#define CONFIG_DEFAULT           ((OCIO_ConstConfigRcPtr*)1)
+#define CONFIG_DEFAULT ((OCIO_ConstConfigRcPtr *)1)
 
 enum TransformType {
-	TRANSFORM_LINEAR_TO_SRGB,
-	TRANSFORM_SRGB_TO_LINEAR,
-	TRANSFORM_MATRIX,
-	TRANSFORM_EXPONENT,
-	TRANSFORM_UNKNOWN,
+  TRANSFORM_LINEAR_TO_SRGB,
+  TRANSFORM_SRGB_TO_LINEAR,
+  TRANSFORM_MATRIX,
+  TRANSFORM_EXPONENT,
+  TRANSFORM_UNKNOWN,
 };
 
-#define COLORSPACE_LINEAR        ((OCIO_ConstColorSpaceRcPtr*)1)
-#define COLORSPACE_SRGB          ((OCIO_ConstColorSpaceRcPtr*)2)
+#define COLORSPACE_LINEAR ((OCIO_ConstColorSpaceRcPtr *)1)
+#define COLORSPACE_SRGB ((OCIO_ConstColorSpaceRcPtr *)2)
 
 typedef struct OCIO_PackedImageDescription {
-	float *data;
-	long width;
-	long height;
-	long numChannels;
-	long chanStrideBytes;
-	long xStrideBytes;
-	long yStrideBytes;
+  float *data;
+  long width;
+  long height;
+  long numChannels;
+  long chanStrideBytes;
+  long xStrideBytes;
+  long yStrideBytes;
 } OCIO_PackedImageDescription;
 
 struct FallbackTransform {
-	FallbackTransform()
-		: type(TRANSFORM_UNKNOWN),
-		  linear_transform(NULL),
-		  display_transform(NULL)
-	{
-	}
-
-	~FallbackTransform()
-	{
-		delete linear_transform;
-		delete display_transform;
-	}
-
-	void applyRGB(float *pixel)
-	{
-		if (type == TRANSFORM_LINEAR_TO_SRGB) {
-			applyLinearRGB(pixel);
-			linearrgb_to_srgb_v3_v3(pixel, pixel);
-			applyDisplayRGB(pixel);
-		}
-		else if (type == TRANSFORM_SRGB_TO_LINEAR) {
-			srgb_to_linearrgb_v3_v3(pixel, pixel);
-		}
-		else if (type == TRANSFORM_EXPONENT) {
-			pixel[0] = powf(max(0.0f, pixel[0]), exponent[0]);
-			pixel[1] = powf(max(0.0f, pixel[1]), exponent[1]);
-			pixel[2] = powf(max(0.0f, pixel[2]), exponent[2]);
-		}
-		else if (type == TRANSFORM_MATRIX) {
-			float r = pixel[0];
-			float g = pixel[1];
-			float b = pixel[2];
-			pixel[0] = r*matrix[0] + g*matrix[1] + b*matrix[2];
-			pixel[1] = r*matrix[4] + g*matrix[5] + b*matrix[6];
-			pixel[2] = r*matrix[8] + g*matrix[9] + b*matrix[10];
-			pixel[0] += offset[0];
-			pixel[1] += offset[1];
-			pixel[2] += offset[2];
-		}
-	}
-
-	void applyRGBA(float *pixel)
-	{
-		if (type == TRANSFORM_LINEAR_TO_SRGB) {
-			applyLinearRGBA(pixel);
-			linearrgb_to_srgb_v4(pixel, pixel);
-			applyDisplayRGBA(pixel);
-		}
-		else if (type == TRANSFORM_SRGB_TO_LINEAR) {
-			srgb_to_linearrgb_v4(pixel, pixel);
-		}
-		else if (type == TRANSFORM_EXPONENT) {
-			pixel[0] = powf(max(0.0f, pixel[0]), exponent[0]);
-			pixel[1] = powf(max(0.0f, pixel[1]), exponent[1]);
-			pixel[2] = powf(max(0.0f, pixel[2]), exponent[2]);
-			pixel[3] = powf(max(0.0f, pixel[3]), exponent[3]);
-		}
-		else if (type == TRANSFORM_MATRIX) {
-			float r = pixel[0];
-			float g = pixel[1];
-			float b = pixel[2];
-			float a = pixel[3];
-			pixel[0] = r*matrix[0] + g*matrix[1] + b*matrix[2] + a*matrix[3];
-			pixel[1] = r*matrix[4] + g*matrix[5] + b*matrix[6] + a*matrix[7];
-			pixel[2] = r*matrix[8] + g*matrix[9] + b*matrix[10] + a*matrix[11];
-			pixel[3] = r*matrix[12] + g*matrix[13] + b*matrix[14] + a*matrix[15];
-			pixel[0] += offset[0];
-			pixel[1] += offset[1];
-			pixel[2] += offset[2];
-			pixel[3] += offset[3];
-		}
-	}
-
-	void applyLinearRGB(float *pixel)
-	{
-		if (linear_transform != NULL) {
-			linear_transform->applyRGB(pixel);
-		}
-	}
-
-	void applyLinearRGBA(float *pixel)
-	{
-		if (linear_transform != NULL) {
-			linear_transform->applyRGBA(pixel);
-		}
-	}
-
-	void applyDisplayRGB(float *pixel)
-	{
-		if (display_transform != NULL) {
-			display_transform->applyRGB(pixel);
-		}
-	}
-
-	void applyDisplayRGBA(float *pixel)
-	{
-		if (display_transform != NULL) {
-			display_transform->applyRGBA(pixel);
-		}
-	}
-
-	TransformType type;
-	FallbackTransform *linear_transform;
-	FallbackTransform *display_transform;
-	/* Exponent transform. */
-	float exponent[4];
-	/* Matrix transform. */
-	float matrix[16];
-	float offset[4];
-
-	MEM_CXX_CLASS_ALLOC_FUNCS("FallbackProcessor");
+  FallbackTransform() : type(TRANSFORM_UNKNOWN), linear_transform(NULL), display_transform(NULL)
+  {
+  }
+
+  ~FallbackTransform()
+  {
+    delete linear_transform;
+    delete display_transform;
+  }
+
+  void applyRGB(float *pixel)
+  {
+    if (type == TRANSFORM_LINEAR_TO_SRGB) {
+      applyLinearRGB(pixel);
+      linearrgb_to_srgb_v3_v3(pixel, pixel);
+      applyDisplayRGB(pixel);
+    }
+    else if (type == TRANSFORM_SRGB_TO_LINEAR) {
+      srgb_to_linearrgb_v3_v3(pixel, pixel);
+    }
+    else if (type == TRANSFORM_EXPONENT) {
+      pixel[0] = powf(max(0.0f, pixel[0]), exponent[0]);
+      pixel[1] = powf(max(0.0f, pixel[1]), exponent[1]);
+      pixel[2] = powf(max(0.0f, pixel[2]), exponent[2]);
+    }
+    else if (type == TRANSFORM_MATRIX) {
+      float r = pixel[0];
+      float g = pixel[1];
+      float b = pixel[2];
+      pixel[0] = r * matrix[0] + g * matrix[1] + b * matrix[2];
+      pixel[1] = r * matrix[4] + g * matrix[5] + b * matrix[6];
+      pixel[2] = r * matrix[8] + g * matrix[9] + b * matrix[10];
+      pixel[0] += offset[0];
+      pixel[1] += offset[1];
+      pixel[2] += offset[2];
+    }
+  }
+
+  void applyRGBA(float *pixel)
+  {
+    if (type == TRANSFORM_LINEAR_TO_SRGB) {
+      applyLinearRGBA(pixel);
+      linearrgb_to_srgb_v4(pixel, pixel);
+      applyDisplayRGBA(pixel);
+    }
+    else if (type == TRANSFORM_SRGB_TO_LINEAR) {
+      srgb_to_linearrgb_v4(pixel, pixel);
+    }
+    else if (type == TRANSFORM_EXPONENT) {
+      pixel[0] = powf(max(0.0f, pixel[0]), exponent[0]);
+      pixel[1] = powf(max(0.0f, pixel[1]), exponent[1]);
+      pixel[2] = powf(max(0.0f, pixel[2]), exponent[2]);
+      pixel[3] = powf(max(0.0f, pixel[3]), exponent[3]);
+    }
+    else if (type == TRANSFORM_MATRIX) {
+      float r = pixel[0];
+      float g = pixel[1];
+      float b = pixel[2];
+      float a = pixel[3];
+      pixel[0] = r * matrix[0] + g * matrix[1] + b * matrix[2] + a * matrix[3];
+      pixel[1] = r * matrix[4] + g * matrix[5] + b * matrix[6] + a * matrix[7];
+      pixel[2] = r * matrix[8] + g * matrix[9] + b * matrix[10] + a * matrix[11];
+      pixel[3] = r * matrix[12] + g * matrix[13] + b * matrix[14] + a * matrix[15];
+      pixel[0] += offset[0];
+      pixel[1] += offset[1];
+      pixel[2] += offset[2];
+      pixel[3] += offset[3];
+    }
+  }
+
+  void applyLinearRGB(float *pixel)
+  {
+    if (linear_transform != NULL) {
+      linear_transform->applyRGB(pixel);
+    }
+  }
+
+  void applyLinearRGBA(float *pixel)
+  {
+    if (linear_transform != NULL) {
+      linear_transform->applyRGBA(pixel);
+    }
+  }
+
+  void applyDisplayRGB(float *pixel)
+  {
+    if (display_transform != NULL) {
+      display_transform->applyRGB(pixel);
+    }
+  }
+
+  void applyDisplayRGBA(float *pixel)
+  {
+    if (display_transform != NULL) {
+      display_transform->applyRGBA(pixel);
+    }
+  }
+
+  TransformType type;
+  FallbackTransform *linear_transform;
+  FallbackTransform *display_transform;
+  /* Exponent transform. */
+  float exponent[4];
+  /* Matrix transform. */
+  float matrix[16];
+  float offset[4];
+
+  MEM_CXX_CLASS_ALLOC_FUNCS("FallbackProcessor");
 };
 
 struct FallbackProcessor {
-	FallbackProcessor()
-		: transform(NULL)
-	{
-	}
+  FallbackProcessor() : transform(NULL)
+  {
+  }
 
-	~FallbackProcessor() {
-		delete transform;
-	}
+  ~FallbackProcessor()
+  {
+    delete transform;
+  }
 
-	void applyRGB(float *pixel)
-	{
-		transform->applyRGB(pixel);
-	}
+  void applyRGB(float *pixel)
+  {
+    transform->applyRGB(pixel);
+  }
 
-	void applyRGBA(float *pixel)
-	{
-		transform->applyRGBA(pixel);
-	}
+  void applyRGBA(float *pixel)
+  {
+    transform->applyRGBA(pixel);
+  }
 
-	FallbackTransform *transform;
+  FallbackTransform *transform;
 
-	MEM_CXX_CLASS_ALLOC_FUNCS("FallbackProcessor");
+  MEM_CXX_CLASS_ALLOC_FUNCS("FallbackProcessor");
 };
 
 OCIO_ConstConfigRcPtr *FallbackImpl::getCurrentConfig(void)
 {
-	return CONFIG_DEFAULT;
+  return CONFIG_DEFAULT;
 }
 
 void FallbackImpl::setCurrentConfig(const OCIO_ConstConfigRcPtr * /*config*/)
@@ -201,12 +198,12 @@ void FallbackImpl::setCurrentConfig(const OCIO_ConstConfigRcPtr * /*config*/)
 
 OCIO_ConstConfigRcPtr *FallbackImpl::configCreateFromEnv(void)
 {
-	return NULL;
+  return NULL;
 }
 
 OCIO_ConstConfigRcPtr *FallbackImpl::configCreateFromFile(const char * /*filename*/)
 {
-	return CONFIG_DEFAULT;
+  return CONFIG_DEFAULT;
 }
 
 void FallbackImpl::configRelease(OCIO_ConstConfigRcPtr * /*config*/)
@@ -215,145 +212,141 @@ void FallbackImpl::configRelease(OCIO_ConstConfigRcPtr * /*config*/)
 
 int FallbackImpl::configGetNumColorSpaces(OCIO_ConstConfigRcPtr * /*config*/)
 {
-	return 2;
+  return 2;
 }
 
 const char *FallbackImpl::configGetColorSpaceNameByIndex(OCIO_ConstConfigRcPtr * /*config*/,
                                                          int index)
 {
-	if (index == 0)
-		return "Linear";
-	else if (index == 1)
-		return "sRGB";
-	
-	return NULL;
+  if (index == 0)
+    return "Linear";
+  else if (index == 1)
+    return "sRGB";
+
+  return NULL;
 }
 
 OCIO_ConstColorSpaceRcPtr *FallbackImpl::configGetColorSpace(OCIO_ConstConfigRcPtr * /*config*/,
                                                              const char *name)
 {
-	if (strcmp(name, "scene_linear") == 0)
-		return COLORSPACE_LINEAR;
-	else if (strcmp(name, "color_picking") == 0)
-		return COLORSPACE_SRGB;
-	else if (strcmp(name, "texture_paint") == 0)
-		return COLORSPACE_LINEAR;
-	else if (strcmp(name, "default_byte") == 0)
-		return COLORSPACE_SRGB;
-	else if (strcmp(name, "default_float") == 0)
-		return COLORSPACE_LINEAR;
-	else if (strcmp(name, "default_sequencer") == 0)
-		return COLORSPACE_SRGB;
-	else if (strcmp(name, "Linear") == 0)
-		return COLORSPACE_LINEAR;
-	else if (strcmp(name, "sRGB") == 0)
-		return COLORSPACE_SRGB;
+  if (strcmp(name, "scene_linear") == 0)
+    return COLORSPACE_LINEAR;
+  else if (strcmp(name, "color_picking") == 0)
+    return COLORSPACE_SRGB;
+  else if (strcmp(name, "texture_paint") == 0)
+    return COLORSPACE_LINEAR;
+  else if (strcmp(name, "default_byte") == 0)
+    return COLORSPACE_SRGB;
+  else if (strcmp(name, "default_float") == 0)
+    return COLORSPACE_LINEAR;
+  else if (strcmp(name, "default_sequencer") == 0)
+    return COLORSPACE_SRGB;
+  else if (strcmp(name, "Linear") == 0)
+    return COLORSPACE_LINEAR;
+  else if (strcmp(name, "sRGB") == 0)
+    return COLORSPACE_SRGB;
 
-	return NULL;
+  return NULL;
 }
 
-int FallbackImpl::configGetIndexForColorSpace(OCIO_ConstConfigRcPtr *config,
-                                              const char *name)
+int FallbackImpl::configGetIndexForColorSpace(OCIO_ConstConfigRcPtr *config, const char *name)
 {
-	OCIO_ConstColorSpaceRcPtr *cs = configGetColorSpace(config, name);
+  OCIO_ConstColorSpaceRcPtr *cs = configGetColorSpace(config, name);
 
-	if (cs == COLORSPACE_LINEAR) {
-		return 0;
-	}
-	else if (cs == COLORSPACE_SRGB) {
-		return 1;
-	}
-	return -1;
+  if (cs == COLORSPACE_LINEAR) {
+    return 0;
+  }
+  else if (cs == COLORSPACE_SRGB) {
+    return 1;
+  }
+  return -1;
 }
 
 const char *FallbackImpl::configGetDefaultDisplay(OCIO_ConstConfigRcPtr * /*config*/)
 {
-	return "sRGB";
+  return "sRGB";
 }
 
 int FallbackImpl::configGetNumDisplays(OCIO_ConstConfigRcPtr * /*config*/)
 {
-	return 1;
+  return 1;
 }
 
-const char *FallbackImpl::configGetDisplay(OCIO_ConstConfigRcPtr * /*config*/,
-                                           int index)
+const char *FallbackImpl::configGetDisplay(OCIO_ConstConfigRcPtr * /*config*/, int index)
 {
-	if (index == 0) {
-		return "sRGB";
-	}
-	return NULL;
+  if (index == 0) {
+    return "sRGB";
+  }
+  return NULL;
 }
 
 const char *FallbackImpl::configGetDefaultView(OCIO_ConstConfigRcPtr * /*config*/,
                                                const char * /*display*/)
 {
-	return "Default";
+  return "Default";
 }
 
-int FallbackImpl::configGetNumViews(OCIO_ConstConfigRcPtr * /*config*/,
-                                    const char * /*display*/)
+int FallbackImpl::configGetNumViews(OCIO_ConstConfigRcPtr * /*config*/, const char * /*display*/)
 {
-	return 1;
+  return 1;
 }
 
 const char *FallbackImpl::configGetView(OCIO_ConstConfigRcPtr * /*config*/,
-                                        const char * /*display*/, int index)
+                                        const char * /*display*/,
+                                        int index)
 {
-	if (index == 0) {
-		return "Default";
-	}
-	return NULL;
+  if (index == 0) {
+    return "Default";
+  }
+  return NULL;
 }
 
 const char *FallbackImpl::configGetDisplayColorSpaceName(OCIO_ConstConfigRcPtr * /*config*/,
                                                          const char * /*display*/,
                                                          const char * /*view*/)
 {
-	return "sRGB";
+  return "sRGB";
 }
 
-void FallbackImpl::configGetDefaultLumaCoefs(OCIO_ConstConfigRcPtr * /*config*/,
-                                             float *rgb)
+void FallbackImpl::configGetDefaultLumaCoefs(OCIO_ConstConfigRcPtr * /*config*/, float *rgb)
 {
-	/* Here we simply use the older Blender assumed primaries of
-	 * ITU-BT.709 / sRGB, or 0.2126729 0.7151522 0.0721750. Brute
-	 * force stupid, but only plausible option given no color management
-	 * system in place.
-	 */
+  /* Here we simply use the older Blender assumed primaries of
+   * ITU-BT.709 / sRGB, or 0.2126729 0.7151522 0.0721750. Brute
+   * force stupid, but only plausible option given no color management
+   * system in place.
+   */
 
-	rgb[0] = 0.2126f;
-	rgb[1] = 0.7152f;
-	rgb[2] = 0.0722f;
+  rgb[0] = 0.2126f;
+  rgb[1] = 0.7152f;
+  rgb[2] = 0.0722f;
 }
 
-void FallbackImpl::configGetXYZtoRGB(OCIO_ConstConfigRcPtr * /*config*/,
-                                     float xyz_to_rgb[3][3])
+void FallbackImpl::configGetXYZtoRGB(OCIO_ConstConfigRcPtr * /*config*/, float xyz_to_rgb[3][3])
 {
-	/* Default to ITU-BT.709. */
-	memcpy(xyz_to_rgb, OCIO_XYZ_TO_LINEAR_SRGB, sizeof(OCIO_XYZ_TO_LINEAR_SRGB));
+  /* Default to ITU-BT.709. */
+  memcpy(xyz_to_rgb, OCIO_XYZ_TO_LINEAR_SRGB, sizeof(OCIO_XYZ_TO_LINEAR_SRGB));
 }
 
 int FallbackImpl::configGetNumLooks(OCIO_ConstConfigRcPtr * /*config*/)
 {
-	return 0;
+  return 0;
 }
 
 const char *FallbackImpl::configGetLookNameByIndex(OCIO_ConstConfigRcPtr * /*config*/,
                                                    int /*index*/)
 {
-	return "";
+  return "";
 }
 
 OCIO_ConstLookRcPtr *FallbackImpl::configGetLook(OCIO_ConstConfigRcPtr * /*config*/,
                                                  const char * /*name*/)
 {
-	return NULL;
+  return NULL;
 }
 
 const char *FallbackImpl::lookGetProcessSpace(OCIO_ConstLookRcPtr * /*look*/)
 {
-	return NULL;
+  return NULL;
 }
 
 void FallbackImpl::lookRelease(OCIO_ConstLookRcPtr * /*look*/)
@@ -362,161 +355,156 @@ void FallbackImpl::lookRelease(OCIO_ConstLookRcPtr * /*look*/)
 
 int FallbackImpl::colorSpaceIsInvertible(OCIO_ConstColorSpaceRcPtr * /*cs*/)
 {
-	return 1;
+  return 1;
 }
 
 int FallbackImpl::colorSpaceIsData(OCIO_ConstColorSpaceRcPtr * /*cs*/)
 {
-	return 0;
+  return 0;
 }
 
 void FallbackImpl::colorSpaceRelease(OCIO_ConstColorSpaceRcPtr * /*cs*/)
 {
 }
 
-OCIO_ConstProcessorRcPtr *FallbackImpl::configGetProcessorWithNames(
-        OCIO_ConstConfigRcPtr *config,
-        const char *srcName,
-        const char *dstName)
+OCIO_ConstProcessorRcPtr *FallbackImpl::configGetProcessorWithNames(OCIO_ConstConfigRcPtr *config,
+                                                                    const char *srcName,
+                                                                    const char *dstName)
 {
-	OCIO_ConstColorSpaceRcPtr *cs_src = configGetColorSpace(config, srcName);
-	OCIO_ConstColorSpaceRcPtr *cs_dst = configGetColorSpace(config, dstName);
-	FallbackTransform *transform = new FallbackTransform();
-	if (cs_src == COLORSPACE_LINEAR && cs_dst == COLORSPACE_SRGB) {
-		transform->type = TRANSFORM_LINEAR_TO_SRGB;
-	}
-	else if (cs_src == COLORSPACE_SRGB && cs_dst == COLORSPACE_LINEAR) {
-		transform->type = TRANSFORM_SRGB_TO_LINEAR;
-	}
-	else {
-		transform->type = TRANSFORM_UNKNOWN;
-	}
-	FallbackProcessor *processor = new FallbackProcessor();
-	processor->transform = transform;
-	return (OCIO_ConstProcessorRcPtr *)processor;
+  OCIO_ConstColorSpaceRcPtr *cs_src = configGetColorSpace(config, srcName);
+  OCIO_ConstColorSpaceRcPtr *cs_dst = configGetColorSpace(config, dstName);
+  FallbackTransform *transform = new FallbackTransform();
+  if (cs_src == COLORSPACE_LINEAR && cs_dst == COLORSPACE_SRGB) {
+    transform->type = TRANSFORM_LINEAR_TO_SRGB;
+  }
+  else if (cs_src == COLORSPACE_SRGB && cs_dst == COLORSPACE_LINEAR) {
+    transform->type = TRANSFORM_SRGB_TO_LINEAR;
+  }
+  else {
+    transform->type = TRANSFORM_UNKNOWN;
+  }
+  FallbackProcessor *processor = new FallbackProcessor();
+  processor->transform = transform;
+  return (OCIO_ConstProcessorRcPtr *)processor;
 }
 
 OCIO_ConstProcessorRcPtr *FallbackImpl::configGetProcessor(OCIO_ConstConfigRcPtr * /*config*/,
                                                            OCIO_ConstTransformRcPtr *transform)
 {
-	FallbackProcessor *processor = new FallbackProcessor();
-	processor->transform = (FallbackTransform *)transform;
-	return (OCIO_ConstProcessorRcPtr *)processor;
+  FallbackProcessor *processor = new FallbackProcessor();
+  processor->transform = (FallbackTransform *)transform;
+  return (OCIO_ConstProcessorRcPtr *)processor;
 }
 
-void FallbackImpl::processorApply(OCIO_ConstProcessorRcPtr *processor,
-                                  OCIO_PackedImageDesc *img)
+void FallbackImpl::processorApply(OCIO_ConstProcessorRcPtr *processor, OCIO_PackedImageDesc *img)
 {
-	/* OCIO_TODO stride not respected, channels must be 3 or 4 */
-	OCIO_PackedImageDescription *desc = (OCIO_PackedImageDescription*)img;
-	int channels = desc->numChannels;
-	float *pixels = desc->data;
-	int width = desc->width;
-	int height = desc->height;
-	int x, y;
+  /* OCIO_TODO stride not respected, channels must be 3 or 4 */
+  OCIO_PackedImageDescription *desc = (OCIO_PackedImageDescription *)img;
+  int channels = desc->numChannels;
+  float *pixels = desc->data;
+  int width = desc->width;
+  int height = desc->height;
+  int x, y;
 
-	for (y = 0; y < height; y++) {
-		for (x = 0; x < width; x++) {
-			float *pixel = pixels + channels * (y * width + x);
+  for (y = 0; y < height; y++) {
+    for (x = 0; x < width; x++) {
+      float *pixel = pixels + channels * (y * width + x);
 
-			if (channels == 4)
-				processorApplyRGBA(processor, pixel);
-			else if (channels == 3)
-				processorApplyRGB(processor, pixel);
-		}
-	}
+      if (channels == 4)
+        processorApplyRGBA(processor, pixel);
+      else if (channels == 3)
+        processorApplyRGB(processor, pixel);
+    }
+  }
 }
 
 void FallbackImpl::processorApply_predivide(OCIO_ConstProcessorRcPtr *processor,
                                             OCIO_PackedImageDesc *img)
 {
-	/* OCIO_TODO stride not respected, channels must be 3 or 4 */
-	OCIO_PackedImageDescription *desc = (OCIO_PackedImageDescription*)img;
-	int channels = desc->numChannels;
-	float *pixels = desc->data;
-	int width = desc->width;
-	int height = desc->height;
-	int x, y;
+  /* OCIO_TODO stride not respected, channels must be 3 or 4 */
+  OCIO_PackedImageDescription *desc = (OCIO_PackedImageDescription *)img;
+  int channels = desc->numChannels;
+  float *pixels = desc->data;
+  int width = desc->width;
+  int height = desc->height;
+  int x, y;
 
-	for (y = 0; y < height; y++) {
-		for (x = 0; x < width; x++) {
-			float *pixel = pixels + channels * (y * width + x);
+  for (y = 0; y < height; y++) {
+    for (x = 0; x < width; x++) {
+      float *pixel = pixels + channels * (y * width + x);
 
-			if (channels == 4)
-				processorApplyRGBA_predivide(processor, pixel);
-			else if (channels == 3)
-				processorApplyRGB(processor, pixel);
-		}
-	}
+      if (channels == 4)
+        processorApplyRGBA_predivide(processor, pixel);
+      else if (channels == 3)
+        processorApplyRGB(processor, pixel);
+    }
+  }
 }
 
-void FallbackImpl::processorApplyRGB(OCIO_ConstProcessorRcPtr *processor,
-                                     float *pixel)
+void FallbackImpl::processorApplyRGB(OCIO_ConstProcessorRcPtr *processor, float *pixel)
 {
-	((FallbackProcessor *)processor)->applyRGB(pixel);
+  ((FallbackProcessor *)processor)->applyRGB(pixel);
 }
 
-void FallbackImpl::processorApplyRGBA(OCIO_ConstProcessorRcPtr *processor,
-                                      float *pixel)
+void FallbackImpl::processorApplyRGBA(OCIO_ConstProcessorRcPtr *processor, float *pixel)
 {
-	((FallbackProcessor *)processor)->applyRGBA(pixel);
+  ((FallbackProcessor *)processor)->applyRGBA(pixel);
 }
 
-void FallbackImpl::processorApplyRGBA_predivide(OCIO_ConstProcessorRcPtr *processor,
-                                                float *pixel)
+void FallbackImpl::processorApplyRGBA_predivide(OCIO_ConstProcessorRcPtr *processor, float *pixel)
 {
-	if (pixel[3] == 1.0f || pixel[3] == 0.0f) {
-		processorApplyRGBA(processor, pixel);
-	}
-	else {
-		float alpha, inv_alpha;
+  if (pixel[3] == 1.0f || pixel[3] == 0.0f) {
+    processorApplyRGBA(processor, pixel);
+  }
+  else {
+    float alpha, inv_alpha;
 
-		alpha = pixel[3];
-		inv_alpha = 1.0f / alpha;
+    alpha = pixel[3];
+    inv_alpha = 1.0f / alpha;
 
-		pixel[0] *= inv_alpha;
-		pixel[1] *= inv_alpha;
-		pixel[2] *= inv_alpha;
+    pixel[0] *= inv_alpha;
+    pixel[1] *= inv_alpha;
+    pixel[2] *= inv_alpha;
 
-		processorApplyRGBA(processor, pixel);
+    processorApplyRGBA(processor, pixel);
 
-		pixel[0] *= alpha;
-		pixel[1] *= alpha;
-		pixel[2] *= alpha;
-	}
+    pixel[0] *= alpha;
+    pixel[1] *= alpha;
+    pixel[2] *= alpha;
+  }
 }
 
 void FallbackImpl::processorRelease(OCIO_ConstProcessorRcPtr *processor)
 {
-	delete (FallbackProcessor*)(processor);
+  delete (FallbackProcessor *)(processor);
 }
 
 const char *FallbackImpl::colorSpaceGetName(OCIO_ConstColorSpaceRcPtr *cs)
 {
-	if (cs == COLORSPACE_LINEAR) {
-		return "Linear";
-	}
-	else if (cs == COLORSPACE_SRGB) {
-		return "sRGB";
-	}
-	return NULL;
+  if (cs == COLORSPACE_LINEAR) {
+    return "Linear";
+  }
+  else if (cs == COLORSPACE_SRGB) {
+    return "sRGB";
+  }
+  return NULL;
 }
 
 const char *FallbackImpl::colorSpaceGetDescription(OCIO_ConstColorSpaceRcPtr * /*cs*/)
 {
-	return "";
+  return "";
 }
 
 const char *FallbackImpl::colorSpaceGetFamily(OCIO_ConstColorSpaceRcPtr * /*cs*/)
 {
-	return "";
+  return "";
 }
 
 OCIO_DisplayTransformRcPtr *FallbackImpl::createDisplayTransform(void)
 {
-	FallbackTransform *transform = new FallbackTransform();
-	transform->type = TRANSFORM_LINEAR_TO_SRGB;
-	return (OCIO_DisplayTransformRcPtr*)transform;
+  FallbackTransform *transform = new FallbackTransform();
+  transform->type = TRANSFORM_LINEAR_TO_SRGB;
+  return (OCIO_DisplayTransformRcPtr *)transform;
 }
 
 void FallbackImpl::displayTransformSetInputColorSpaceName(OCIO_DisplayTransformRcPtr * /*dt*/,
@@ -537,15 +525,15 @@ void FallbackImpl::displayTransformSetView(OCIO_DisplayTransformRcPtr * /*dt*/,
 void FallbackImpl::displayTransformSetDisplayCC(OCIO_DisplayTransformRcPtr *dt,
                                                 OCIO_ConstTransformRcPtr *et)
 {
-	FallbackTransform *transform = (FallbackTransform *)dt;
-	transform->display_transform = (FallbackTransform *)et;
+  FallbackTransform *transform = (FallbackTransform *)dt;
+  transform->display_transform = (FallbackTransform *)et;
 }
 
 void FallbackImpl::displayTransformSetLinearCC(OCIO_DisplayTransformRcPtr *dt,
                                                OCIO_ConstTransformRcPtr *et)
 {
-	FallbackTransform *transform = (FallbackTransform *)dt;
-	transform->linear_transform = (FallbackTransform *)et;
+  FallbackTransform *transform = (FallbackTransform *)dt;
+  transform->linear_transform = (FallbackTransform *)et;
 }
 
 void FallbackImpl::displayTransformSetLooksOverride(OCIO_DisplayTransformRcPtr * /*dt*/,
@@ -562,41 +550,43 @@ void FallbackImpl::displayTransformRelease(OCIO_DisplayTransformRcPtr * /*dt*/)
 {
 }
 
-OCIO_PackedImageDesc *FallbackImpl::createOCIO_PackedImageDesc(
-        float *data,
-        long width, long height, long numChannels,
-        long chanStrideBytes, long xStrideBytes, long yStrideBytes)
+OCIO_PackedImageDesc *FallbackImpl::createOCIO_PackedImageDesc(float *data,
+                                                               long width,
+                                                               long height,
+                                                               long numChannels,
+                                                               long chanStrideBytes,
+                                                               long xStrideBytes,
+                                                               long yStrideBytes)
 {
-	OCIO_PackedImageDescription *desc =
-	        (OCIO_PackedImageDescription*)MEM_callocN(sizeof(OCIO_PackedImageDescription),
-	                                                  "OCIO_PackedImageDescription");
-	desc->data = data;
-	desc->width = width;
-	desc->height = height;
-	desc->numChannels = numChannels;
-	desc->chanStrideBytes = chanStrideBytes;
-	desc->xStrideBytes = xStrideBytes;
-	desc->yStrideBytes = yStrideBytes;
-	return (OCIO_PackedImageDesc*)desc;
+  OCIO_PackedImageDescription *desc = (OCIO_PackedImageDescription *)MEM_callocN(
+      sizeof(OCIO_PackedImageDescription), "OCIO_PackedImageDescription");
+  desc->data = data;
+  desc->width = width;
+  desc->height = height;
+  desc->numChannels = numChannels;
+  desc->chanStrideBytes = chanStrideBytes;
+  desc->xStrideBytes = xStrideBytes;
+  desc->yStrideBytes = yStrideBytes;
+  return (OCIO_PackedImageDesc *)desc;
 }
 
-void FallbackImpl::OCIO_PackedImageDescRelease(OCIO_PackedImageDesc* id)
+void FallbackImpl::OCIO_PackedImageDescRelease(OCIO_PackedImageDesc *id)
 {
-	MEM_freeN(id);
+  MEM_freeN(id);
 }
 
 OCIO_ExponentTransformRcPtr *FallbackImpl::createExponentTransform(void)
 {
-	FallbackTransform *transform = new FallbackTransform();
-	transform->type = TRANSFORM_EXPONENT;
-	return (OCIO_ExponentTransformRcPtr *)transform;
+  FallbackTransform *transform = new FallbackTransform();
+  transform->type = TRANSFORM_EXPONENT;
+  return (OCIO_ExponentTransformRcPtr *)transform;
 }
 
 void FallbackImpl::exponentTransformSetValue(OCIO_ExponentTransformRcPtr *et,
                                              const float *exponent)
 {
-	FallbackTransform *transform = (FallbackTransform *)et;
-	copy_v4_v4(transform->exponent, exponent);
+  FallbackTransform *transform = (FallbackTransform *)et;
+  copy_v4_v4(transform->exponent, exponent);
 }
 
 void FallbackImpl::exponentTransformRelease(OCIO_ExponentTransformRcPtr * /*et*/)
@@ -605,49 +595,47 @@ void FallbackImpl::exponentTransformRelease(OCIO_ExponentTransformRcPtr * /*et*/
 
 OCIO_MatrixTransformRcPtr *FallbackImpl::createMatrixTransform(void)
 {
-	FallbackTransform *transform = new FallbackTransform();
-	transform->type = TRANSFORM_MATRIX;
-	return (OCIO_MatrixTransformRcPtr *)transform;
+  FallbackTransform *transform = new FallbackTransform();
+  transform->type = TRANSFORM_MATRIX;
+  return (OCIO_MatrixTransformRcPtr *)transform;
 }
 
 void FallbackImpl::matrixTransformSetValue(OCIO_MatrixTransformRcPtr *mt,
                                            const float *m44,
                                            const float *offset4)
 {
-	FallbackTransform *transform = (FallbackTransform *)mt;
-	copy_m4_m4((float (*)[4])transform->matrix, (float (*)[4])m44);
-	copy_v4_v4(transform->offset, offset4);
+  FallbackTransform *transform = (FallbackTransform *)mt;
+  copy_m4_m4((float(*)[4])transform->matrix, (float(*)[4])m44);
+  copy_v4_v4(transform->offset, offset4);
 }
 
 void FallbackImpl::matrixTransformRelease(OCIO_MatrixTransformRcPtr * /*mt*/)
 {
 }
 
-void FallbackImpl::matrixTransformScale(float *m44,
-                                        float *offset4,
-                                        const float *scale4)
+void FallbackImpl::matrixTransformScale(float *m44, float *offset4, const float *scale4)
 {
-	if (scale4 == NULL) {
-		return;
-	}
-	if (m44 != NULL) {
-		memset(m44, 0, 16*sizeof(float));
-		m44[0] = scale4[0];
-		m44[5] = scale4[1];
-		m44[10] = scale4[2];
-		m44[15] = scale4[3];
-	}
-	if (offset4 != NULL) {
-		offset4[0] = 0.0f;
-		offset4[1] = 0.0f;
-		offset4[2] = 0.0f;
-		offset4[3] = 0.0f;
-	}
+  if (scale4 == NULL) {
+    return;
+  }
+  if (m44 != NULL) {
+    memset(m44, 0, 16 * sizeof(float));
+    m44[0] = scale4[0];
+    m44[5] = scale4[1];
+    m44[10] = scale4[2];
+    m44[15] = scale4[3];
+  }
+  if (offset4 != NULL) {
+    offset4[0] = 0.0f;
+    offset4[1] = 0.0f;
+    offset4[2] = 0.0f;
+    offset4[3] = 0.0f;
+  }
 }
 
 bool FallbackImpl::supportGLSLDraw(void)
 {
-	return false;
+  return false;
 }
 
 bool FallbackImpl::setupGLSLDraw(struct OCIO_GLSLDrawState ** /*state_r*/,
@@ -656,7 +644,7 @@ bool FallbackImpl::setupGLSLDraw(struct OCIO_GLSLDrawState ** /*state_r*/,
                                  float /*dither*/,
                                  bool /*predivide*/)
 {
-	return false;
+  return false;
 }
 
 void FallbackImpl::finishGLSLDraw(OCIO_GLSLDrawState * /*state*/)
@@ -669,10 +657,10 @@ void FallbackImpl::freeGLState(struct OCIO_GLSLDrawState * /*state_r*/)
 
 const char *FallbackImpl::getVersionString(void)
 {
-	return "fallback";
+  return "fallback";
 }
 
 int FallbackImpl::getVersionHex(void)
 {
-	return 0;
+  return 0;
 }
diff --git a/intern/opencolorio/gpu_shader_display_transform.glsl b/intern/opencolorio/gpu_shader_display_transform.glsl
index f1dca04b823..04e96e8ed3c 100644
--- a/intern/opencolorio/gpu_shader_display_transform.glsl
+++ b/intern/opencolorio/gpu_shader_display_transform.glsl
@@ -32,135 +32,140 @@ uniform vec3 curve_mapping_bwmul;
 
 float read_curve_mapping(int table, int index)
 {
-	/* TODO(sergey): Without -1 here image is getting darken after applying unite curve.
-	 *               But is it actually correct to subtract 1 here?
-	 */
-	float texture_index = float(index) / float(curve_mapping_lut_size  - 1);
-	return texture(curve_mapping_texture, texture_index)[table];
+  /* TODO(sergey): Without -1 here image is getting darken after applying unite curve.
+   *               But is it actually correct to subtract 1 here?
+   */
+  float texture_index = float(index) / float(curve_mapping_lut_size - 1);
+  return texture(curve_mapping_texture, texture_index)[table];
 }
 
 float curvemap_calc_extend(int table, float x, vec2 first, vec2 last)
 {
-	if (x <= first[0]) {
-		if (use_curve_mapping_extend_extrapolate[table] == 0) {
-			/* no extrapolate */
-			return first[1];
-		}
-		else {
-			if (curve_mapping_ext_in_x[table] == 0.0)
-				return first[1] + curve_mapping_ext_in_y[table] * 10000.0;
-			else
-				return first[1] + curve_mapping_ext_in_y[table] * (x - first[0]) / curve_mapping_ext_in_x[table];
-		}
-	}
-	else if (x >= last[0]) {
-		if (use_curve_mapping_extend_extrapolate[table] == 0) {
-			/* no extrapolate */
-			return last[1];
-		}
-		else {
-			if (curve_mapping_ext_out_x[table] == 0.0)
-				return last[1] - curve_mapping_ext_out_y[table] * 10000.0;
-			else
-				return last[1] + curve_mapping_ext_out_y[table] * (x - last[0]) / curve_mapping_ext_out_x[table];
-		}
-	}
-	return 0.0;
+  if (x <= first[0]) {
+    if (use_curve_mapping_extend_extrapolate[table] == 0) {
+      /* no extrapolate */
+      return first[1];
+    }
+    else {
+      if (curve_mapping_ext_in_x[table] == 0.0)
+        return first[1] + curve_mapping_ext_in_y[table] * 10000.0;
+      else
+        return first[1] +
+               curve_mapping_ext_in_y[table] * (x - first[0]) / curve_mapping_ext_in_x[table];
+    }
+  }
+  else if (x >= last[0]) {
+    if (use_curve_mapping_extend_extrapolate[table] == 0) {
+      /* no extrapolate */
+      return last[1];
+    }
+    else {
+      if (curve_mapping_ext_out_x[table] == 0.0)
+        return last[1] - curve_mapping_ext_out_y[table] * 10000.0;
+      else
+        return last[1] +
+               curve_mapping_ext_out_y[table] * (x - last[0]) / curve_mapping_ext_out_x[table];
+    }
+  }
+  return 0.0;
 }
 
 float curvemap_evaluateF(int table, float value)
 {
-	float mintable_ = curve_mapping_mintable[table];
-	float range = curve_mapping_range[table];
-	float mintable = 0.0;
-	int CM_TABLE = curve_mapping_lut_size - 1;
-
-	float fi;
-	int i;
-
-	/* index in table */
-	fi = (value - mintable) * range;
-	i = int(fi);
-
-	/* fi is table float index and should check against table range i.e. [0.0 CM_TABLE] */
-	if (fi < 0.0 || fi > float(CM_TABLE)) {
-		return curvemap_calc_extend(table, value,
-		                            vec2(curve_mapping_first_x[table], curve_mapping_first_y[table]),
-		                            vec2(curve_mapping_last_x[table], curve_mapping_last_y[table]));
-	}
-	else {
-		if (i < 0) return read_curve_mapping(table, 0);
-		if (i >= CM_TABLE) return read_curve_mapping(table, CM_TABLE);
-
-		fi = fi - float(i);
-		return (1.0 - fi) * read_curve_mapping(table, i) + fi * read_curve_mapping(table, i + 1);
-	}
+  float mintable_ = curve_mapping_mintable[table];
+  float range = curve_mapping_range[table];
+  float mintable = 0.0;
+  int CM_TABLE = curve_mapping_lut_size - 1;
+
+  float fi;
+  int i;
+
+  /* index in table */
+  fi = (value - mintable) * range;
+  i = int(fi);
+
+  /* fi is table float index and should check against table range i.e. [0.0 CM_TABLE] */
+  if (fi < 0.0 || fi > float(CM_TABLE)) {
+    return curvemap_calc_extend(table,
+                                value,
+                                vec2(curve_mapping_first_x[table], curve_mapping_first_y[table]),
+                                vec2(curve_mapping_last_x[table], curve_mapping_last_y[table]));
+  }
+  else {
+    if (i < 0)
+      return read_curve_mapping(table, 0);
+    if (i >= CM_TABLE)
+      return read_curve_mapping(table, CM_TABLE);
+
+    fi = fi - float(i);
+    return (1.0 - fi) * read_curve_mapping(table, i) + fi * read_curve_mapping(table, i + 1);
+  }
 }
 
 vec4 curvemapping_evaluate_premulRGBF(vec4 col)
 {
-	vec4 result = col;
-	result[0] = curvemap_evaluateF(0, (col[0] - curve_mapping_black[0]) * curve_mapping_bwmul[0]);
-	result[1] = curvemap_evaluateF(1, (col[1] - curve_mapping_black[1]) * curve_mapping_bwmul[1]);
-	result[2] = curvemap_evaluateF(2, (col[2] - curve_mapping_black[2]) * curve_mapping_bwmul[2]);
-	result[3] = col[3];
-	return result;
+  vec4 result = col;
+  result[0] = curvemap_evaluateF(0, (col[0] - curve_mapping_black[0]) * curve_mapping_bwmul[0]);
+  result[1] = curvemap_evaluateF(1, (col[1] - curve_mapping_black[1]) * curve_mapping_bwmul[1]);
+  result[2] = curvemap_evaluateF(2, (col[2] - curve_mapping_black[2]) * curve_mapping_bwmul[2]);
+  result[3] = col[3];
+  return result;
 }
 #endif
 
 #ifdef USE_DITHER
 float dither_random_value(vec2 co)
 {
-	return fract(sin(dot(co.xy, vec2(12.9898, 78.233))) * 43758.5453) * 0.005 * dither;
+  return fract(sin(dot(co.xy, vec2(12.9898, 78.233))) * 43758.5453) * 0.005 * dither;
 }
 
 vec2 round_to_pixel(vec2 st)
 {
-	vec2 result;
-	vec2 size = textureSize(image_texture, 0);
-	result.x = float(int(st.x * size.x)) / size.x;
-	result.y = float(int(st.y * size.y)) / size.y;
-	return result;
+  vec2 result;
+  vec2 size = textureSize(image_texture, 0);
+  result.x = float(int(st.x * size.x)) / size.x;
+  result.y = float(int(st.y * size.y)) / size.y;
+  return result;
 }
 
 vec4 apply_dither(vec2 st, vec4 col)
 {
-	vec4 result;
-	float random_value = dither_random_value(round_to_pixel(st));
-	result.r = col.r + random_value;
-	result.g = col.g + random_value;
-	result.b = col.b + random_value;
-	result.a = col.a;
-	return result;
+  vec4 result;
+  float random_value = dither_random_value(round_to_pixel(st));
+  result.r = col.r + random_value;
+  result.g = col.g + random_value;
+  result.b = col.b + random_value;
+  result.a = col.a;
+  return result;
 }
 #endif
 
 void main()
 {
-	vec4 col = texture(image_texture, texCoord_interp.st);
+  vec4 col = texture(image_texture, texCoord_interp.st);
 #ifdef USE_CURVE_MAPPING
-	col = curvemapping_evaluate_premulRGBF(col);
+  col = curvemapping_evaluate_premulRGBF(col);
 #endif
 
 #ifdef USE_PREDIVIDE
-	if (col[3] > 0.0 && col[3] < 1.0) {
-		float inv_alpha = 1.0 / col[3];
-		col[0] *= inv_alpha;
-		col[1] *= inv_alpha;
-		col[2] *= inv_alpha;
-	}
+  if (col[3] > 0.0 && col[3] < 1.0) {
+    float inv_alpha = 1.0 / col[3];
+    col[0] *= inv_alpha;
+    col[1] *= inv_alpha;
+    col[2] *= inv_alpha;
+  }
 #endif
 
-	/* NOTE: This is true we only do de-premul here and NO premul
-	 *       and the reason is simple -- opengl is always configured
-	 *       for straight alpha at this moment
-	 */
+  /* NOTE: This is true we only do de-premul here and NO premul
+   *       and the reason is simple -- opengl is always configured
+   *       for straight alpha at this moment
+   */
 
-	vec4 result = OCIODisplay(col, lut3d_texture);
+  vec4 result = OCIODisplay(col, lut3d_texture);
 
 #ifdef USE_DITHER
-	result = apply_dither(texCoord_interp.st, result);
+  result = apply_dither(texCoord_interp.st, result);
 #endif
 
-	fragColor = result;
+  fragColor = result;
 }
diff --git a/intern/opencolorio/gpu_shader_display_transform_vertex.glsl b/intern/opencolorio/gpu_shader_display_transform_vertex.glsl
index 054f7f3ec91..8cf9628b06b 100644
--- a/intern/opencolorio/gpu_shader_display_transform_vertex.glsl
+++ b/intern/opencolorio/gpu_shader_display_transform_vertex.glsl
@@ -7,6 +7,6 @@ out vec2 texCoord_interp;
 
 void main()
 {
-	gl_Position = ModelViewProjectionMatrix * vec4(pos.xy, 0.0f, 1.0f);
-	texCoord_interp = texCoord;
+  gl_Position = ModelViewProjectionMatrix * vec4(pos.xy, 0.0f, 1.0f);
+  texCoord_interp = texCoord;
 }
diff --git a/intern/opencolorio/ocio_capi.cc b/intern/opencolorio/ocio_capi.cc
index bec452db260..530d1fb8a27 100644
--- a/intern/opencolorio/ocio_capi.cc
+++ b/intern/opencolorio/ocio_capi.cc
@@ -26,329 +26,346 @@ static IOCIOImpl *impl = NULL;
 void OCIO_init(void)
 {
 #ifdef WITH_OCIO
-	impl = new OCIOImpl();
+  impl = new OCIOImpl();
 #else
-	impl = new FallbackImpl();
+  impl = new FallbackImpl();
 #endif
 }
 
 void OCIO_exit(void)
 {
-	delete impl;
-	impl = NULL;
+  delete impl;
+  impl = NULL;
 }
 
 OCIO_ConstConfigRcPtr *OCIO_getCurrentConfig(void)
 {
-	return impl->getCurrentConfig();
+  return impl->getCurrentConfig();
 }
 
 OCIO_ConstConfigRcPtr *OCIO_configCreateFallback(void)
 {
-	delete impl;
-	impl = new FallbackImpl();
+  delete impl;
+  impl = new FallbackImpl();
 
-	return impl->getCurrentConfig();
+  return impl->getCurrentConfig();
 }
 
 void OCIO_setCurrentConfig(const OCIO_ConstConfigRcPtr *config)
 {
-	impl->setCurrentConfig(config);
+  impl->setCurrentConfig(config);
 }
 
 OCIO_ConstConfigRcPtr *OCIO_configCreateFromEnv(void)
 {
-	return impl->configCreateFromEnv();
+  return impl->configCreateFromEnv();
 }
 
 OCIO_ConstConfigRcPtr *OCIO_configCreateFromFile(const char *filename)
 {
-	return impl->configCreateFromFile(filename);
+  return impl->configCreateFromFile(filename);
 }
 
 void OCIO_configRelease(OCIO_ConstConfigRcPtr *config)
 {
-	impl->configRelease(config);
+  impl->configRelease(config);
 }
 
 int OCIO_configGetNumColorSpaces(OCIO_ConstConfigRcPtr *config)
 {
-	return impl->configGetNumColorSpaces(config);
+  return impl->configGetNumColorSpaces(config);
 }
 
 const char *OCIO_configGetColorSpaceNameByIndex(OCIO_ConstConfigRcPtr *config, int index)
 {
-	return impl->configGetColorSpaceNameByIndex(config, index);
+  return impl->configGetColorSpaceNameByIndex(config, index);
 }
 
-OCIO_ConstColorSpaceRcPtr *OCIO_configGetColorSpace(OCIO_ConstConfigRcPtr *config, const char *name)
+OCIO_ConstColorSpaceRcPtr *OCIO_configGetColorSpace(OCIO_ConstConfigRcPtr *config,
+                                                    const char *name)
 {
-	return impl->configGetColorSpace(config, name);
+  return impl->configGetColorSpace(config, name);
 }
 
 int OCIO_configGetIndexForColorSpace(OCIO_ConstConfigRcPtr *config, const char *name)
 {
-	return impl->configGetIndexForColorSpace(config, name);
+  return impl->configGetIndexForColorSpace(config, name);
 }
 
 const char *OCIO_configGetDefaultDisplay(OCIO_ConstConfigRcPtr *config)
 {
-	return impl->configGetDefaultDisplay(config);
+  return impl->configGetDefaultDisplay(config);
 }
 
-int OCIO_configGetNumDisplays(OCIO_ConstConfigRcPtr* config)
+int OCIO_configGetNumDisplays(OCIO_ConstConfigRcPtr *config)
 {
-	return impl->configGetNumDisplays(config);
+  return impl->configGetNumDisplays(config);
 }
 
 const char *OCIO_configGetDisplay(OCIO_ConstConfigRcPtr *config, int index)
 {
-	return impl->configGetDisplay(config, index);
+  return impl->configGetDisplay(config, index);
 }
 
 const char *OCIO_configGetDefaultView(OCIO_ConstConfigRcPtr *config, const char *display)
 {
-	return impl->configGetDefaultView(config, display);
+  return impl->configGetDefaultView(config, display);
 }
 
 int OCIO_configGetNumViews(OCIO_ConstConfigRcPtr *config, const char *display)
 {
-	return impl->configGetNumViews(config, display);
+  return impl->configGetNumViews(config, display);
 }
 
 const char *OCIO_configGetView(OCIO_ConstConfigRcPtr *config, const char *display, int index)
 {
-	return impl->configGetView(config, display, index);
+  return impl->configGetView(config, display, index);
 }
 
-const char *OCIO_configGetDisplayColorSpaceName(OCIO_ConstConfigRcPtr *config, const char *display, const char *view)
+const char *OCIO_configGetDisplayColorSpaceName(OCIO_ConstConfigRcPtr *config,
+                                                const char *display,
+                                                const char *view)
 {
-	return impl->configGetDisplayColorSpaceName(config, display, view);
+  return impl->configGetDisplayColorSpaceName(config, display, view);
 }
 
 void OCIO_configGetDefaultLumaCoefs(OCIO_ConstConfigRcPtr *config, float *rgb)
 {
-	impl->configGetDefaultLumaCoefs(config, rgb);
+  impl->configGetDefaultLumaCoefs(config, rgb);
 }
 
 void OCIO_configGetXYZtoRGB(OCIO_ConstConfigRcPtr *config, float xyz_to_rgb[3][3])
 {
-	impl->configGetXYZtoRGB(config, xyz_to_rgb);
+  impl->configGetXYZtoRGB(config, xyz_to_rgb);
 }
 
 int OCIO_configGetNumLooks(OCIO_ConstConfigRcPtr *config)
 {
-	return impl->configGetNumLooks(config);
+  return impl->configGetNumLooks(config);
 }
 
 const char *OCIO_configGetLookNameByIndex(OCIO_ConstConfigRcPtr *config, int index)
 {
-	return impl->configGetLookNameByIndex(config, index);
+  return impl->configGetLookNameByIndex(config, index);
 }
 
 OCIO_ConstLookRcPtr *OCIO_configGetLook(OCIO_ConstConfigRcPtr *config, const char *name)
 {
-	return impl->configGetLook(config, name);
+  return impl->configGetLook(config, name);
 }
 
 const char *OCIO_lookGetProcessSpace(OCIO_ConstLookRcPtr *look)
 {
-	return impl->lookGetProcessSpace(look);
+  return impl->lookGetProcessSpace(look);
 }
 
 void OCIO_lookRelease(OCIO_ConstLookRcPtr *look)
 {
-	impl->lookRelease(look);
+  impl->lookRelease(look);
 }
 
 int OCIO_colorSpaceIsInvertible(OCIO_ConstColorSpaceRcPtr *cs)
 {
-	return impl->colorSpaceIsInvertible(cs);
+  return impl->colorSpaceIsInvertible(cs);
 }
 
 int OCIO_colorSpaceIsData(OCIO_ConstColorSpaceRcPtr *cs)
 {
-	return impl->colorSpaceIsData(cs);
+  return impl->colorSpaceIsData(cs);
 }
 
 void OCIO_colorSpaceRelease(OCIO_ConstColorSpaceRcPtr *cs)
 {
-	impl->colorSpaceRelease(cs);
+  impl->colorSpaceRelease(cs);
 }
 
-OCIO_ConstProcessorRcPtr *OCIO_configGetProcessorWithNames(OCIO_ConstConfigRcPtr *config, const char *srcName, const char *dstName)
+OCIO_ConstProcessorRcPtr *OCIO_configGetProcessorWithNames(OCIO_ConstConfigRcPtr *config,
+                                                           const char *srcName,
+                                                           const char *dstName)
 {
-	return impl->configGetProcessorWithNames(config, srcName, dstName);
+  return impl->configGetProcessorWithNames(config, srcName, dstName);
 }
 
-OCIO_ConstProcessorRcPtr *OCIO_configGetProcessor(OCIO_ConstConfigRcPtr *config, OCIO_ConstTransformRcPtr *transform)
+OCIO_ConstProcessorRcPtr *OCIO_configGetProcessor(OCIO_ConstConfigRcPtr *config,
+                                                  OCIO_ConstTransformRcPtr *transform)
 {
-	return impl->configGetProcessor(config, transform);
+  return impl->configGetProcessor(config, transform);
 }
 
 void OCIO_processorApply(OCIO_ConstProcessorRcPtr *processor, OCIO_PackedImageDesc *img)
 {
-	impl->processorApply(processor, img);
+  impl->processorApply(processor, img);
 }
 
 void OCIO_processorApply_predivide(OCIO_ConstProcessorRcPtr *processor, OCIO_PackedImageDesc *img)
 {
-	impl->processorApply_predivide(processor, img);
+  impl->processorApply_predivide(processor, img);
 }
 
 void OCIO_processorApplyRGB(OCIO_ConstProcessorRcPtr *processor, float *pixel)
 {
-	impl->processorApplyRGB(processor, pixel);
+  impl->processorApplyRGB(processor, pixel);
 }
 
 void OCIO_processorApplyRGBA(OCIO_ConstProcessorRcPtr *processor, float *pixel)
 {
-	impl->processorApplyRGBA(processor, pixel);
+  impl->processorApplyRGBA(processor, pixel);
 }
 
 void OCIO_processorApplyRGBA_predivide(OCIO_ConstProcessorRcPtr *processor, float *pixel)
 {
-	impl->processorApplyRGBA_predivide(processor, pixel);
+  impl->processorApplyRGBA_predivide(processor, pixel);
 }
 
 void OCIO_processorRelease(OCIO_ConstProcessorRcPtr *p)
 {
-	impl->processorRelease(p);
+  impl->processorRelease(p);
 }
 
 const char *OCIO_colorSpaceGetName(OCIO_ConstColorSpaceRcPtr *cs)
 {
-	return impl->colorSpaceGetName(cs);
+  return impl->colorSpaceGetName(cs);
 }
 
 const char *OCIO_colorSpaceGetDescription(OCIO_ConstColorSpaceRcPtr *cs)
 {
-	return impl->colorSpaceGetDescription(cs);
+  return impl->colorSpaceGetDescription(cs);
 }
 
 const char *OCIO_colorSpaceGetFamily(OCIO_ConstColorSpaceRcPtr *cs)
 {
-	return impl->colorSpaceGetFamily(cs);
+  return impl->colorSpaceGetFamily(cs);
 }
 
 OCIO_DisplayTransformRcPtr *OCIO_createDisplayTransform(void)
 {
-	return impl->createDisplayTransform();
+  return impl->createDisplayTransform();
 }
 
 void OCIO_displayTransformSetInputColorSpaceName(OCIO_DisplayTransformRcPtr *dt, const char *name)
 {
-	impl->displayTransformSetInputColorSpaceName(dt, name);
+  impl->displayTransformSetInputColorSpaceName(dt, name);
 }
 
 void OCIO_displayTransformSetDisplay(OCIO_DisplayTransformRcPtr *dt, const char *name)
 {
-	impl->displayTransformSetDisplay(dt, name);
+  impl->displayTransformSetDisplay(dt, name);
 }
 
 void OCIO_displayTransformSetView(OCIO_DisplayTransformRcPtr *dt, const char *name)
 {
-	impl->displayTransformSetView(dt, name);
+  impl->displayTransformSetView(dt, name);
 }
 
 void OCIO_displayTransformSetDisplayCC(OCIO_DisplayTransformRcPtr *dt, OCIO_ConstTransformRcPtr *t)
 {
-	impl->displayTransformSetDisplayCC(dt, t);
+  impl->displayTransformSetDisplayCC(dt, t);
 }
 
 void OCIO_displayTransformSetLinearCC(OCIO_DisplayTransformRcPtr *dt, OCIO_ConstTransformRcPtr *t)
 {
-	impl->displayTransformSetLinearCC(dt, t);
+  impl->displayTransformSetLinearCC(dt, t);
 }
 
 void OCIO_displayTransformSetLooksOverride(OCIO_DisplayTransformRcPtr *dt, const char *looks)
 {
-	impl->displayTransformSetLooksOverride(dt, looks);
+  impl->displayTransformSetLooksOverride(dt, looks);
 }
 
 void OCIO_displayTransformSetLooksOverrideEnabled(OCIO_DisplayTransformRcPtr *dt, bool enabled)
 {
-	impl->displayTransformSetLooksOverrideEnabled(dt, enabled);
+  impl->displayTransformSetLooksOverrideEnabled(dt, enabled);
 }
 
 void OCIO_displayTransformRelease(OCIO_DisplayTransformRcPtr *dt)
 {
-	impl->displayTransformRelease(dt);
+  impl->displayTransformRelease(dt);
 }
 
-OCIO_PackedImageDesc *OCIO_createOCIO_PackedImageDesc(float *data, long width, long height, long numChannels,
-                                                      long chanStrideBytes, long xStrideBytes, long yStrideBytes)
+OCIO_PackedImageDesc *OCIO_createOCIO_PackedImageDesc(float *data,
+                                                      long width,
+                                                      long height,
+                                                      long numChannels,
+                                                      long chanStrideBytes,
+                                                      long xStrideBytes,
+                                                      long yStrideBytes)
 {
-	return impl->createOCIO_PackedImageDesc(data, width, height, numChannels, chanStrideBytes, xStrideBytes, yStrideBytes);
+  return impl->createOCIO_PackedImageDesc(
+      data, width, height, numChannels, chanStrideBytes, xStrideBytes, yStrideBytes);
 }
 
-void OCIO_PackedImageDescRelease(OCIO_PackedImageDesc* id)
+void OCIO_PackedImageDescRelease(OCIO_PackedImageDesc *id)
 {
-	impl->OCIO_PackedImageDescRelease(id);
+  impl->OCIO_PackedImageDescRelease(id);
 }
 
 OCIO_ExponentTransformRcPtr *OCIO_createExponentTransform(void)
 {
-	return impl->createExponentTransform();
+  return impl->createExponentTransform();
 }
 
 void OCIO_exponentTransformSetValue(OCIO_ExponentTransformRcPtr *et, const float *exponent)
 {
-	impl->exponentTransformSetValue(et, exponent);
+  impl->exponentTransformSetValue(et, exponent);
 }
 
 void OCIO_exponentTransformRelease(OCIO_ExponentTransformRcPtr *et)
 {
-	impl->exponentTransformRelease(et);
+  impl->exponentTransformRelease(et);
 }
 
 OCIO_MatrixTransformRcPtr *OCIO_createMatrixTransform(void)
 {
-	return impl->createMatrixTransform();
+  return impl->createMatrixTransform();
 }
 
-void OCIO_matrixTransformSetValue(OCIO_MatrixTransformRcPtr *mt, const float *m44, const float *offset4)
+void OCIO_matrixTransformSetValue(OCIO_MatrixTransformRcPtr *mt,
+                                  const float *m44,
+                                  const float *offset4)
 {
-	impl->matrixTransformSetValue(mt, m44, offset4);
+  impl->matrixTransformSetValue(mt, m44, offset4);
 }
 
 void OCIO_matrixTransformRelease(OCIO_MatrixTransformRcPtr *mt)
 {
-	impl->matrixTransformRelease(mt);
+  impl->matrixTransformRelease(mt);
 }
 
 void OCIO_matrixTransformScale(float *m44, float *offset4, const float *scale4f)
 {
-	impl->matrixTransformScale(m44, offset4, scale4f);
+  impl->matrixTransformScale(m44, offset4, scale4f);
 }
 
 int OCIO_supportGLSLDraw(void)
 {
-	return (int) impl->supportGLSLDraw();
+  return (int)impl->supportGLSLDraw();
 }
 
-int OCIO_setupGLSLDraw(struct OCIO_GLSLDrawState **state_r, OCIO_ConstProcessorRcPtr *processor,
-                       OCIO_CurveMappingSettings *curve_mapping_settings, float dither, bool predivide)
+int OCIO_setupGLSLDraw(struct OCIO_GLSLDrawState **state_r,
+                       OCIO_ConstProcessorRcPtr *processor,
+                       OCIO_CurveMappingSettings *curve_mapping_settings,
+                       float dither,
+                       bool predivide)
 {
-	return (int) impl->setupGLSLDraw(state_r, processor, curve_mapping_settings, dither, predivide);
+  return (int)impl->setupGLSLDraw(state_r, processor, curve_mapping_settings, dither, predivide);
 }
 
 void OCIO_finishGLSLDraw(struct OCIO_GLSLDrawState *state)
 {
-	impl->finishGLSLDraw(state);
+  impl->finishGLSLDraw(state);
 }
 
 void OCIO_freeOGLState(struct OCIO_GLSLDrawState *state)
 {
-	impl->freeGLState(state);
+  impl->freeGLState(state);
 }
 
 const char *OCIO_getVersionString(void)
 {
-	return impl->getVersionString();
+  return impl->getVersionString();
 }
 
 int OCIO_getVersionHex(void)
 {
-	return impl->getVersionHex();
+  return impl->getVersionHex();
 }
diff --git a/intern/opencolorio/ocio_capi.h b/intern/opencolorio/ocio_capi.h
index bc1667398fb..9af302647a3 100644
--- a/intern/opencolorio/ocio_capi.h
+++ b/intern/opencolorio/ocio_capi.h
@@ -26,14 +26,17 @@ extern "C" {
 
 struct OCIO_GLSLDrawState;
 
-#define OCIO_DECLARE_HANDLE(name) typedef struct name##__ { int unused; } *name
-
-#define OCIO_ROLE_SCENE_LINEAR       "scene_linear"
-#define OCIO_ROLE_COLOR_PICKING      "color_picking"
-#define OCIO_ROLE_TEXTURE_PAINT      "texture_paint"
-#define OCIO_ROLE_DEFAULT_BYTE       "default_byte"
-#define OCIO_ROLE_DEFAULT_FLOAT      "default_float"
-#define OCIO_ROLE_DEFAULT_SEQUENCER  "default_sequencer"
+#define OCIO_DECLARE_HANDLE(name) \
+  typedef struct name##__ { \
+    int unused; \
+  } * name
+
+#define OCIO_ROLE_SCENE_LINEAR "scene_linear"
+#define OCIO_ROLE_COLOR_PICKING "color_picking"
+#define OCIO_ROLE_TEXTURE_PAINT "texture_paint"
+#define OCIO_ROLE_DEFAULT_BYTE "default_byte"
+#define OCIO_ROLE_DEFAULT_FLOAT "default_float"
+#define OCIO_ROLE_DEFAULT_SEQUENCER "default_sequencer"
 
 OCIO_DECLARE_HANDLE(OCIO_ConstConfigRcPtr);
 OCIO_DECLARE_HANDLE(OCIO_ConstColorSpaceRcPtr);
@@ -47,66 +50,64 @@ OCIO_DECLARE_HANDLE(OCIO_MatrixTransformRcPtr);
 OCIO_DECLARE_HANDLE(OCIO_ConstLookRcPtr);
 
 /* Standard XYZ to linear sRGB transform, for fallback. */
-static const float OCIO_XYZ_TO_LINEAR_SRGB[3][3] = {
-	{3.2404542f, -0.9692660f, 0.0556434f},
-	{-1.5371385f, 1.8760108f, -0.2040259f},
-	{-0.4985314f, 0.0415560f, 1.0572252f}};
-
+static const float OCIO_XYZ_TO_LINEAR_SRGB[3][3] = {{3.2404542f, -0.9692660f, 0.0556434f},
+                                                    {-1.5371385f, 1.8760108f, -0.2040259f},
+                                                    {-0.4985314f, 0.0415560f, 1.0572252f}};
 
 /* This structure is used to pass curve mapping settings from
  * blender's DNA structure stored in view transform settings
  * to a generic OpenColorIO C-API.
  */
 typedef struct OCIO_CurveMappingSettings {
-	/* This is a LUT which contain values for all 4 curve mapping tables
-	 * (combined, R, G and B).
-	 *
-	 * Element I for table T is stored at I * 4 + T element of this LUT.
-	 *
-	 * This array is usually returned by curvemapping_table_RGBA().
-	 */
-	float *lut;
-
-	/* Size of single curve mapping table, 1/4 size of lut array. */
-	int lut_size;
-
-	/* Extend extrapolation flags for all the tables.
-	 * if use_extend_extrapolate[T] != 0 means extrapolation for
-	 * table T is needed.
-	 */
-	int use_extend_extrapolate[4];
-
-	/* Minimal X value of the curve mapping tables. */
-	float mintable[4];
-
-	/* Per curve mapping table range. */
-	float range[4];
-
-	/* Lower extension value, stored as per-component arrays. */
-	float ext_in_x[4], ext_in_y[4];
-
-	/* Higher extension value, stored as per-component arrays. */
-	float ext_out_x[4], ext_out_y[4];
-
-	/* First points of the tables, both X and Y values.
-	 * Needed for easier and faster access when extrapolating.
-	 */
-	float first_x[4], first_y[4];
-
-	/* Last points of the tables, both X and Y values.
-	 * Needed for easier and faster access when extrapolating.
-	 */
-	float last_x[4], last_y[4];
-
-	/* Premultiplication settings: black level and scale to match
-	 * with white level.
-	 */
-	float black[3], bwmul[3];
-
-	/* Cache id of the original curve mapping, used to detect when
-	 * upload of new settings to GPU is needed.
-	 */
-	size_t cache_id;
+  /* This is a LUT which contain values for all 4 curve mapping tables
+   * (combined, R, G and B).
+   *
+   * Element I for table T is stored at I * 4 + T element of this LUT.
+   *
+   * This array is usually returned by curvemapping_table_RGBA().
+   */
+  float *lut;
+
+  /* Size of single curve mapping table, 1/4 size of lut array. */
+  int lut_size;
+
+  /* Extend extrapolation flags for all the tables.
+   * if use_extend_extrapolate[T] != 0 means extrapolation for
+   * table T is needed.
+   */
+  int use_extend_extrapolate[4];
+
+  /* Minimal X value of the curve mapping tables. */
+  float mintable[4];
+
+  /* Per curve mapping table range. */
+  float range[4];
+
+  /* Lower extension value, stored as per-component arrays. */
+  float ext_in_x[4], ext_in_y[4];
+
+  /* Higher extension value, stored as per-component arrays. */
+  float ext_out_x[4], ext_out_y[4];
+
+  /* First points of the tables, both X and Y values.
+   * Needed for easier and faster access when extrapolating.
+   */
+  float first_x[4], first_y[4];
+
+  /* Last points of the tables, both X and Y values.
+   * Needed for easier and faster access when extrapolating.
+   */
+  float last_x[4], last_y[4];
+
+  /* Premultiplication settings: black level and scale to match
+   * with white level.
+   */
+  float black[3], bwmul[3];
+
+  /* Cache id of the original curve mapping, used to detect when
+   * upload of new settings to GPU is needed.
+   */
+  size_t cache_id;
 } OCIO_CurveMappingSettings;
 
 void OCIO_init(void);
@@ -116,14 +117,15 @@ OCIO_ConstConfigRcPtr *OCIO_getCurrentConfig(void);
 void OCIO_setCurrentConfig(const OCIO_ConstConfigRcPtr *config);
 
 OCIO_ConstConfigRcPtr *OCIO_configCreateFromEnv(void);
-OCIO_ConstConfigRcPtr *OCIO_configCreateFromFile(const char* filename);
+OCIO_ConstConfigRcPtr *OCIO_configCreateFromFile(const char *filename);
 OCIO_ConstConfigRcPtr *OCIO_configCreateFallback(void);
 
 void OCIO_configRelease(OCIO_ConstConfigRcPtr *config);
 
 int OCIO_configGetNumColorSpaces(OCIO_ConstConfigRcPtr *config);
 const char *OCIO_configGetColorSpaceNameByIndex(OCIO_ConstConfigRcPtr *config, int index);
-OCIO_ConstColorSpaceRcPtr *OCIO_configGetColorSpace(OCIO_ConstConfigRcPtr *config, const char *name);
+OCIO_ConstColorSpaceRcPtr *OCIO_configGetColorSpace(OCIO_ConstConfigRcPtr *config,
+                                                    const char *name);
 int OCIO_configGetIndexForColorSpace(OCIO_ConstConfigRcPtr *config, const char *name);
 
 int OCIO_colorSpaceIsInvertible(OCIO_ConstColorSpaceRcPtr *cs);
@@ -132,25 +134,30 @@ int OCIO_colorSpaceIsData(OCIO_ConstColorSpaceRcPtr *cs);
 void OCIO_colorSpaceRelease(OCIO_ConstColorSpaceRcPtr *cs);
 
 const char *OCIO_configGetDefaultDisplay(OCIO_ConstConfigRcPtr *config);
-int         OCIO_configGetNumDisplays(OCIO_ConstConfigRcPtr *config);
+int OCIO_configGetNumDisplays(OCIO_ConstConfigRcPtr *config);
 const char *OCIO_configGetDisplay(OCIO_ConstConfigRcPtr *config, int index);
 const char *OCIO_configGetDefaultView(OCIO_ConstConfigRcPtr *config, const char *display);
-int         OCIO_configGetNumViews(OCIO_ConstConfigRcPtr *config, const char *display);
+int OCIO_configGetNumViews(OCIO_ConstConfigRcPtr *config, const char *display);
 const char *OCIO_configGetView(OCIO_ConstConfigRcPtr *config, const char *display, int index);
-const char *OCIO_configGetDisplayColorSpaceName(OCIO_ConstConfigRcPtr *config, const char *display, const char *view);
+const char *OCIO_configGetDisplayColorSpaceName(OCIO_ConstConfigRcPtr *config,
+                                                const char *display,
+                                                const char *view);
 
-void        OCIO_configGetDefaultLumaCoefs(OCIO_ConstConfigRcPtr *config, float *rgb);
-void        OCIO_configGetXYZtoRGB(OCIO_ConstConfigRcPtr *config, float xyz_to_rgb[3][3]);
+void OCIO_configGetDefaultLumaCoefs(OCIO_ConstConfigRcPtr *config, float *rgb);
+void OCIO_configGetXYZtoRGB(OCIO_ConstConfigRcPtr *config, float xyz_to_rgb[3][3]);
 
-int                  OCIO_configGetNumLooks(OCIO_ConstConfigRcPtr *config);
-const char          *OCIO_configGetLookNameByIndex(OCIO_ConstConfigRcPtr *config, int index);
+int OCIO_configGetNumLooks(OCIO_ConstConfigRcPtr *config);
+const char *OCIO_configGetLookNameByIndex(OCIO_ConstConfigRcPtr *config, int index);
 OCIO_ConstLookRcPtr *OCIO_configGetLook(OCIO_ConstConfigRcPtr *config, const char *name);
 
 const char *OCIO_lookGetProcessSpace(OCIO_ConstLookRcPtr *look);
 void OCIO_lookRelease(OCIO_ConstLookRcPtr *look);
 
-OCIO_ConstProcessorRcPtr *OCIO_configGetProcessorWithNames(OCIO_ConstConfigRcPtr *config, const char *srcName, const char *dstName);
-OCIO_ConstProcessorRcPtr *OCIO_configGetProcessor(OCIO_ConstConfigRcPtr *config, OCIO_ConstTransformRcPtr *transform);
+OCIO_ConstProcessorRcPtr *OCIO_configGetProcessorWithNames(OCIO_ConstConfigRcPtr *config,
+                                                           const char *srcName,
+                                                           const char *dstName);
+OCIO_ConstProcessorRcPtr *OCIO_configGetProcessor(OCIO_ConstConfigRcPtr *config,
+                                                  OCIO_ConstTransformRcPtr *transform);
 
 void OCIO_processorApply(OCIO_ConstProcessorRcPtr *processor, OCIO_PackedImageDesc *img);
 void OCIO_processorApply_predivide(OCIO_ConstProcessorRcPtr *processor, OCIO_PackedImageDesc *img);
@@ -168,14 +175,21 @@ OCIO_DisplayTransformRcPtr *OCIO_createDisplayTransform(void);
 void OCIO_displayTransformSetInputColorSpaceName(OCIO_DisplayTransformRcPtr *dt, const char *name);
 void OCIO_displayTransformSetDisplay(OCIO_DisplayTransformRcPtr *dt, const char *name);
 void OCIO_displayTransformSetView(OCIO_DisplayTransformRcPtr *dt, const char *name);
-void OCIO_displayTransformSetDisplayCC(OCIO_DisplayTransformRcPtr *dt, OCIO_ConstTransformRcPtr *et);
-void OCIO_displayTransformSetLinearCC(OCIO_DisplayTransformRcPtr *dt, OCIO_ConstTransformRcPtr *et);
+void OCIO_displayTransformSetDisplayCC(OCIO_DisplayTransformRcPtr *dt,
+                                       OCIO_ConstTransformRcPtr *et);
+void OCIO_displayTransformSetLinearCC(OCIO_DisplayTransformRcPtr *dt,
+                                      OCIO_ConstTransformRcPtr *et);
 void OCIO_displayTransformSetLooksOverride(OCIO_DisplayTransformRcPtr *dt, const char *looks);
 void OCIO_displayTransformSetLooksOverrideEnabled(OCIO_DisplayTransformRcPtr *dt, bool enabled);
 void OCIO_displayTransformRelease(OCIO_DisplayTransformRcPtr *dt);
 
-OCIO_PackedImageDesc *OCIO_createOCIO_PackedImageDesc(float *data, long width, long height, long numChannels,
-                                                      long chanStrideBytes, long xStrideBytes, long yStrideBytes);
+OCIO_PackedImageDesc *OCIO_createOCIO_PackedImageDesc(float *data,
+                                                      long width,
+                                                      long height,
+                                                      long numChannels,
+                                                      long chanStrideBytes,
+                                                      long xStrideBytes,
+                                                      long yStrideBytes);
 
 void OCIO_PackedImageDescRelease(OCIO_PackedImageDesc *p);
 
@@ -184,14 +198,19 @@ void OCIO_exponentTransformSetValue(OCIO_ExponentTransformRcPtr *et, const float
 void OCIO_exponentTransformRelease(OCIO_ExponentTransformRcPtr *et);
 
 OCIO_MatrixTransformRcPtr *OCIO_createMatrixTransform(void);
-void OCIO_matrixTransformSetValue(OCIO_MatrixTransformRcPtr *mt, const float *m44, const float *offset4);
+void OCIO_matrixTransformSetValue(OCIO_MatrixTransformRcPtr *mt,
+                                  const float *m44,
+                                  const float *offset4);
 void OCIO_matrixTransformRelease(OCIO_MatrixTransformRcPtr *mt);
 
 void OCIO_matrixTransformScale(float *m44, float *offset4, const float *scale4);
 
 int OCIO_supportGLSLDraw(void);
-int OCIO_setupGLSLDraw(struct OCIO_GLSLDrawState **state_r, OCIO_ConstProcessorRcPtr *processor,
-                       OCIO_CurveMappingSettings *curve_mapping_settings, float dither, bool predivide);
+int OCIO_setupGLSLDraw(struct OCIO_GLSLDrawState **state_r,
+                       OCIO_ConstProcessorRcPtr *processor,
+                       OCIO_CurveMappingSettings *curve_mapping_settings,
+                       float dither,
+                       bool predivide);
 void OCIO_finishGLSLDraw(struct OCIO_GLSLDrawState *state);
 void OCIO_freeOGLState(struct OCIO_GLSLDrawState *state);
 
diff --git a/intern/opencolorio/ocio_impl.cc b/intern/opencolorio/ocio_impl.cc
index 729f6fa3f90..3917ed234c7 100644
--- a/intern/opencolorio/ocio_impl.cc
+++ b/intern/opencolorio/ocio_impl.cc
@@ -62,248 +62,249 @@ using namespace OCIO_NAMESPACE;
 #  include <vector>
 #  include <string>
 #  include <set>
-using std::vector;
+using std::map;
 using std::set;
 using std::string;
-using std::map;
+using std::vector;
 #endif
 
 static void OCIO_reportError(const char *err)
 {
-	std::cerr << "OpenColorIO Error: " << err << std::endl;
+  std::cerr << "OpenColorIO Error: " << err << std::endl;
 
-	OCIO_abort();
+  OCIO_abort();
 }
 
 static void OCIO_reportException(Exception &exception)
 {
-	OCIO_reportError(exception.what());
+  OCIO_reportError(exception.what());
 }
 
 OCIO_ConstConfigRcPtr *OCIOImpl::getCurrentConfig(void)
 {
-	ConstConfigRcPtr *config = OBJECT_GUARDED_NEW(ConstConfigRcPtr);
+  ConstConfigRcPtr *config = OBJECT_GUARDED_NEW(ConstConfigRcPtr);
 
-	try {
-		*config = GetCurrentConfig();
+  try {
+    *config = GetCurrentConfig();
 
-		if (*config)
-			return (OCIO_ConstConfigRcPtr *) config;
-	}
-	catch (Exception &exception) {
-		OCIO_reportException(exception);
-	}
+    if (*config)
+      return (OCIO_ConstConfigRcPtr *)config;
+  }
+  catch (Exception &exception) {
+    OCIO_reportException(exception);
+  }
 
-	OBJECT_GUARDED_DELETE(config, ConstConfigRcPtr);
+  OBJECT_GUARDED_DELETE(config, ConstConfigRcPtr);
 
-	return NULL;
+  return NULL;
 }
 
 void OCIOImpl::setCurrentConfig(const OCIO_ConstConfigRcPtr *config)
 {
-	try {
-		SetCurrentConfig(*(ConstConfigRcPtr *) config);
-	}
-	catch (Exception &exception) {
-		OCIO_reportException(exception);
-	}
+  try {
+    SetCurrentConfig(*(ConstConfigRcPtr *)config);
+  }
+  catch (Exception &exception) {
+    OCIO_reportException(exception);
+  }
 }
 
 OCIO_ConstConfigRcPtr *OCIOImpl::configCreateFromEnv(void)
 {
-	ConstConfigRcPtr *config = OBJECT_GUARDED_NEW(ConstConfigRcPtr);
+  ConstConfigRcPtr *config = OBJECT_GUARDED_NEW(ConstConfigRcPtr);
 
-	try {
-		*config = Config::CreateFromEnv();
+  try {
+    *config = Config::CreateFromEnv();
 
-		if (*config)
-			return (OCIO_ConstConfigRcPtr *) config;
-	}
-	catch (Exception &exception) {
-		OCIO_reportException(exception);
-	}
+    if (*config)
+      return (OCIO_ConstConfigRcPtr *)config;
+  }
+  catch (Exception &exception) {
+    OCIO_reportException(exception);
+  }
 
-	OBJECT_GUARDED_DELETE(config, ConstConfigRcPtr);
+  OBJECT_GUARDED_DELETE(config, ConstConfigRcPtr);
 
-	return NULL;
+  return NULL;
 }
 
-
 OCIO_ConstConfigRcPtr *OCIOImpl::configCreateFromFile(const char *filename)
 {
-	ConstConfigRcPtr *config = OBJECT_GUARDED_NEW(ConstConfigRcPtr);
+  ConstConfigRcPtr *config = OBJECT_GUARDED_NEW(ConstConfigRcPtr);
 
-	try {
-		*config = Config::CreateFromFile(filename);
+  try {
+    *config = Config::CreateFromFile(filename);
 
-		if (*config)
-			return (OCIO_ConstConfigRcPtr *) config;
-	}
-	catch (Exception &exception) {
-		OCIO_reportException(exception);
-	}
+    if (*config)
+      return (OCIO_ConstConfigRcPtr *)config;
+  }
+  catch (Exception &exception) {
+    OCIO_reportException(exception);
+  }
 
-	OBJECT_GUARDED_DELETE(config, ConstConfigRcPtr);
+  OBJECT_GUARDED_DELETE(config, ConstConfigRcPtr);
 
-	return NULL;
+  return NULL;
 }
 
 void OCIOImpl::configRelease(OCIO_ConstConfigRcPtr *config)
 {
-	OBJECT_GUARDED_DELETE((ConstConfigRcPtr *) config, ConstConfigRcPtr);
+  OBJECT_GUARDED_DELETE((ConstConfigRcPtr *)config, ConstConfigRcPtr);
 }
 
 int OCIOImpl::configGetNumColorSpaces(OCIO_ConstConfigRcPtr *config)
 {
-	try {
-		return (*(ConstConfigRcPtr *) config)->getNumColorSpaces();
-	}
-	catch (Exception &exception) {
-		OCIO_reportException(exception);
-	}
+  try {
+    return (*(ConstConfigRcPtr *)config)->getNumColorSpaces();
+  }
+  catch (Exception &exception) {
+    OCIO_reportException(exception);
+  }
 
-	return 0;
+  return 0;
 }
 
 const char *OCIOImpl::configGetColorSpaceNameByIndex(OCIO_ConstConfigRcPtr *config, int index)
 {
-	try {
-		return (*(ConstConfigRcPtr *) config)->getColorSpaceNameByIndex(index);
-	}
-	catch (Exception &exception) {
-		OCIO_reportException(exception);
-	}
+  try {
+    return (*(ConstConfigRcPtr *)config)->getColorSpaceNameByIndex(index);
+  }
+  catch (Exception &exception) {
+    OCIO_reportException(exception);
+  }
 
-	return NULL;
+  return NULL;
 }
 
-OCIO_ConstColorSpaceRcPtr *OCIOImpl::configGetColorSpace(OCIO_ConstConfigRcPtr *config, const char *name)
+OCIO_ConstColorSpaceRcPtr *OCIOImpl::configGetColorSpace(OCIO_ConstConfigRcPtr *config,
+                                                         const char *name)
 {
-	ConstColorSpaceRcPtr *cs = OBJECT_GUARDED_NEW(ConstColorSpaceRcPtr);
+  ConstColorSpaceRcPtr *cs = OBJECT_GUARDED_NEW(ConstColorSpaceRcPtr);
 
-	try {
-		*cs = (*(ConstConfigRcPtr *) config)->getColorSpace(name);
+  try {
+    *cs = (*(ConstConfigRcPtr *)config)->getColorSpace(name);
 
-		if (*cs)
-			return (OCIO_ConstColorSpaceRcPtr *) cs;
-	}
-	catch (Exception &exception) {
-		OCIO_reportException(exception);
-	}
+    if (*cs)
+      return (OCIO_ConstColorSpaceRcPtr *)cs;
+  }
+  catch (Exception &exception) {
+    OCIO_reportException(exception);
+  }
 
-	OBJECT_GUARDED_DELETE(cs, ConstColorSpaceRcPtr);
+  OBJECT_GUARDED_DELETE(cs, ConstColorSpaceRcPtr);
 
-	return NULL;
+  return NULL;
 }
 
 int OCIOImpl::configGetIndexForColorSpace(OCIO_ConstConfigRcPtr *config, const char *name)
 {
-	try {
-		return (*(ConstConfigRcPtr *) config)->getIndexForColorSpace(name);
-	}
-	catch (Exception &exception) {
-		OCIO_reportException(exception);
-	}
+  try {
+    return (*(ConstConfigRcPtr *)config)->getIndexForColorSpace(name);
+  }
+  catch (Exception &exception) {
+    OCIO_reportException(exception);
+  }
 
-	return -1;
+  return -1;
 }
 
 const char *OCIOImpl::configGetDefaultDisplay(OCIO_ConstConfigRcPtr *config)
 {
 #ifdef DEFAULT_DISPLAY_WORKAROUND
-	if (getenv("OCIO_ACTIVE_DISPLAYS") == NULL) {
-		const char *active_displays =
-		        (*(ConstConfigRcPtr *) config)->getActiveDisplays();
-		if (active_displays[0] != '\0') {
-			const char *separator_pos = strchr(active_displays, ',');
-			if (separator_pos == NULL) {
-				return active_displays;
-			}
-			static std::string active_display;
-			/* NOTE: Configuration is shared and is never changed during
-			 * runtime, so we only guarantee two threads don't initialize at the
-			 * same. */
-			static std::mutex mutex;
-			mutex.lock();
-			if (active_display.empty()) {
-				active_display = active_displays;
-				active_display[separator_pos - active_displays] = '\0';
-			}
-			mutex.unlock();
-			return active_display.c_str();
-		}
-	}
+  if (getenv("OCIO_ACTIVE_DISPLAYS") == NULL) {
+    const char *active_displays = (*(ConstConfigRcPtr *)config)->getActiveDisplays();
+    if (active_displays[0] != '\0') {
+      const char *separator_pos = strchr(active_displays, ',');
+      if (separator_pos == NULL) {
+        return active_displays;
+      }
+      static std::string active_display;
+      /* NOTE: Configuration is shared and is never changed during
+       * runtime, so we only guarantee two threads don't initialize at the
+       * same. */
+      static std::mutex mutex;
+      mutex.lock();
+      if (active_display.empty()) {
+        active_display = active_displays;
+        active_display[separator_pos - active_displays] = '\0';
+      }
+      mutex.unlock();
+      return active_display.c_str();
+    }
+  }
 #endif
 
-	try {
-		return (*(ConstConfigRcPtr *) config)->getDefaultDisplay();
-	}
-	catch (Exception &exception) {
-		OCIO_reportException(exception);
-	}
+  try {
+    return (*(ConstConfigRcPtr *)config)->getDefaultDisplay();
+  }
+  catch (Exception &exception) {
+    OCIO_reportException(exception);
+  }
 
-	return NULL;
+  return NULL;
 }
 
-int OCIOImpl::configGetNumDisplays(OCIO_ConstConfigRcPtr* config)
+int OCIOImpl::configGetNumDisplays(OCIO_ConstConfigRcPtr *config)
 {
-	try {
-		return (*(ConstConfigRcPtr *) config)->getNumDisplays();
-	}
-	catch (Exception &exception) {
-		OCIO_reportException(exception);
-	}
+  try {
+    return (*(ConstConfigRcPtr *)config)->getNumDisplays();
+  }
+  catch (Exception &exception) {
+    OCIO_reportException(exception);
+  }
 
-	return 0;
+  return 0;
 }
 
 const char *OCIOImpl::configGetDisplay(OCIO_ConstConfigRcPtr *config, int index)
 {
-	try {
-		return (*(ConstConfigRcPtr *) config)->getDisplay(index);
-	}
-	catch (Exception &exception) {
-		OCIO_reportException(exception);
-	}
+  try {
+    return (*(ConstConfigRcPtr *)config)->getDisplay(index);
+  }
+  catch (Exception &exception) {
+    OCIO_reportException(exception);
+  }
 
-	return NULL;
+  return NULL;
 }
 
 #ifdef DEFAULT_DISPLAY_WORKAROUND
 namespace {
 
-void splitStringEnvStyle(vector<string>* tokens, const string& str)
-{
-	tokens->clear();
-	const int len = str.length();
-	int token_start = 0, token_length = 0;
-	for (int i = 0; i < len; ++i) {
-		const char ch = str[i];
-		if (ch != ',' && ch != ':') {
-			/* Append non-separator char to a token. */
-			++token_length;
-		} else {
-			/* Append current token to the list (if any). */
-			if (token_length > 0) {
-				string token = str.substr(token_start, token_length);
-				tokens->push_back(token);
-			}
-			/* Re-set token pointers. */
-			token_start = i + 1;
-			token_length = 0;
-		}
-	}
-	/* Append token which might be at the end of the string. */
-	if (token_length != 0) {
-		string token = str.substr(token_start, token_length);
-		tokens->push_back(token);
-	}
-}
-
-string stringToLower(const string& str) {
-	string lower = str;
-	std::transform(lower.begin(), lower.end(), lower.begin(), tolower);
-	return lower;
+void splitStringEnvStyle(vector<string> *tokens, const string &str)
+{
+  tokens->clear();
+  const int len = str.length();
+  int token_start = 0, token_length = 0;
+  for (int i = 0; i < len; ++i) {
+    const char ch = str[i];
+    if (ch != ',' && ch != ':') {
+      /* Append non-separator char to a token. */
+      ++token_length;
+    }
+    else {
+      /* Append current token to the list (if any). */
+      if (token_length > 0) {
+        string token = str.substr(token_start, token_length);
+        tokens->push_back(token);
+      }
+      /* Re-set token pointers. */
+      token_start = i + 1;
+      token_length = 0;
+    }
+  }
+  /* Append token which might be at the end of the string. */
+  if (token_length != 0) {
+    string token = str.substr(token_start, token_length);
+    tokens->push_back(token);
+  }
+}
+
+string stringToLower(const string &str)
+{
+  string lower = str;
+  std::transform(lower.begin(), lower.end(), lower.begin(), tolower);
+  return lower;
 }
 
 }  // namespace
@@ -312,469 +313,483 @@ string stringToLower(const string& str) {
 const char *OCIOImpl::configGetDefaultView(OCIO_ConstConfigRcPtr *config, const char *display)
 {
 #ifdef DEFAULT_DISPLAY_WORKAROUND
-	/* NOTE: We assume that first active view always exists for a default
-	 * display. */
-	if (getenv("OCIO_ACTIVE_VIEWS") == NULL) {
-		ConstConfigRcPtr config_ptr = *((ConstConfigRcPtr *) config);
-		const char *active_views_encoded = config_ptr->getActiveViews();
-		if (active_views_encoded[0] != '\0') {
-			const string display_lower = stringToLower(display);
-			static map<string, string> default_display_views;
-			static std::mutex mutex;
-			mutex.lock();
-			/* Check if the view is already known. */
-			map<string, string>::const_iterator it =
-			        default_display_views.find(display_lower);
-			if (it != default_display_views.end()) {
-				mutex.unlock();
-				return it->second.c_str();
-			}
-			/* Active views. */
-			vector<string> active_views;
-			splitStringEnvStyle(&active_views, active_views_encoded);
-			/* Get all views supported by tge display. */
-			set<string> display_views;
-			const int num_display_views = config_ptr->getNumViews(display);
-			for (int view_index = 0;
-			     view_index < num_display_views;
-			     ++view_index)
-			{
-				const char *view = config_ptr->getView(display, view_index);
-				display_views.insert(stringToLower(view));
-			}
-			/* Get first view which is supported by tge display. */
-			for (const string& view : active_views) {
-				const string view_lower = stringToLower(view);
-				if (display_views.find(view_lower) != display_views.end()) {
-					default_display_views[display_lower] = view;
-					mutex.unlock();
-					return default_display_views[display_lower].c_str();
-				}
-			}
-			mutex.unlock();
-		}
-	}
+  /* NOTE: We assume that first active view always exists for a default
+   * display. */
+  if (getenv("OCIO_ACTIVE_VIEWS") == NULL) {
+    ConstConfigRcPtr config_ptr = *((ConstConfigRcPtr *)config);
+    const char *active_views_encoded = config_ptr->getActiveViews();
+    if (active_views_encoded[0] != '\0') {
+      const string display_lower = stringToLower(display);
+      static map<string, string> default_display_views;
+      static std::mutex mutex;
+      mutex.lock();
+      /* Check if the view is already known. */
+      map<string, string>::const_iterator it = default_display_views.find(display_lower);
+      if (it != default_display_views.end()) {
+        mutex.unlock();
+        return it->second.c_str();
+      }
+      /* Active views. */
+      vector<string> active_views;
+      splitStringEnvStyle(&active_views, active_views_encoded);
+      /* Get all views supported by tge display. */
+      set<string> display_views;
+      const int num_display_views = config_ptr->getNumViews(display);
+      for (int view_index = 0; view_index < num_display_views; ++view_index) {
+        const char *view = config_ptr->getView(display, view_index);
+        display_views.insert(stringToLower(view));
+      }
+      /* Get first view which is supported by tge display. */
+      for (const string &view : active_views) {
+        const string view_lower = stringToLower(view);
+        if (display_views.find(view_lower) != display_views.end()) {
+          default_display_views[display_lower] = view;
+          mutex.unlock();
+          return default_display_views[display_lower].c_str();
+        }
+      }
+      mutex.unlock();
+    }
+  }
 #endif
-	try {
-		return (*(ConstConfigRcPtr *) config)->getDefaultView(display);
-	}
-	catch (Exception &exception) {
-		OCIO_reportException(exception);
-	}
+  try {
+    return (*(ConstConfigRcPtr *)config)->getDefaultView(display);
+  }
+  catch (Exception &exception) {
+    OCIO_reportException(exception);
+  }
 
-	return NULL;
+  return NULL;
 }
 
 int OCIOImpl::configGetNumViews(OCIO_ConstConfigRcPtr *config, const char *display)
 {
-	try {
-		return (*(ConstConfigRcPtr *) config)->getNumViews(display);
-	}
-	catch (Exception &exception) {
-		OCIO_reportException(exception);
-	}
+  try {
+    return (*(ConstConfigRcPtr *)config)->getNumViews(display);
+  }
+  catch (Exception &exception) {
+    OCIO_reportException(exception);
+  }
 
-	return 0;
+  return 0;
 }
 
 const char *OCIOImpl::configGetView(OCIO_ConstConfigRcPtr *config, const char *display, int index)
 {
-	try {
-		return (*(ConstConfigRcPtr *) config)->getView(display, index);
-	}
-	catch (Exception &exception) {
-		OCIO_reportException(exception);
-	}
+  try {
+    return (*(ConstConfigRcPtr *)config)->getView(display, index);
+  }
+  catch (Exception &exception) {
+    OCIO_reportException(exception);
+  }
 
-	return NULL;
+  return NULL;
 }
 
-const char *OCIOImpl::configGetDisplayColorSpaceName(OCIO_ConstConfigRcPtr *config, const char *display, const char *view)
+const char *OCIOImpl::configGetDisplayColorSpaceName(OCIO_ConstConfigRcPtr *config,
+                                                     const char *display,
+                                                     const char *view)
 {
-	try {
-		return (*(ConstConfigRcPtr *) config)->getDisplayColorSpaceName(display, view);
-	}
-	catch (Exception &exception) {
-		OCIO_reportException(exception);
-	}
+  try {
+    return (*(ConstConfigRcPtr *)config)->getDisplayColorSpaceName(display, view);
+  }
+  catch (Exception &exception) {
+    OCIO_reportException(exception);
+  }
 
-	return NULL;
+  return NULL;
 }
 
 void OCIOImpl::configGetDefaultLumaCoefs(OCIO_ConstConfigRcPtr *config, float *rgb)
 {
-	try {
-		(*(ConstConfigRcPtr *) config)->getDefaultLumaCoefs(rgb);
-	}
-	catch (Exception &exception) {
-		OCIO_reportException(exception);
-	}
+  try {
+    (*(ConstConfigRcPtr *)config)->getDefaultLumaCoefs(rgb);
+  }
+  catch (Exception &exception) {
+    OCIO_reportException(exception);
+  }
 }
 
 void OCIOImpl::configGetXYZtoRGB(OCIO_ConstConfigRcPtr *config_, float xyz_to_rgb[3][3])
 {
-	ConstConfigRcPtr config = (*(ConstConfigRcPtr *) config_);
-
-	/* Default to ITU-BT.709 in case no appropriate transform found. */
-	memcpy(xyz_to_rgb, OCIO_XYZ_TO_LINEAR_SRGB, sizeof(OCIO_XYZ_TO_LINEAR_SRGB));
-
-	/* Auto estimate from XYZ and scene_linear roles, assumed to be a linear transform. */
-	if(config->hasRole("XYZ") && config->hasRole("scene_linear")) {
-		ConstProcessorRcPtr to_rgb_processor = config->getProcessor("XYZ", "scene_linear");
-		if(to_rgb_processor) {
-			xyz_to_rgb[0][0] = 1.0f;
-			xyz_to_rgb[0][1] = 0.0f;
-			xyz_to_rgb[0][2] = 0.0f;
-			xyz_to_rgb[1][0] = 0.0f;
-			xyz_to_rgb[1][1] = 1.0f;
-			xyz_to_rgb[1][2] = 0.0f;
-			xyz_to_rgb[2][0] = 0.0f;
-			xyz_to_rgb[2][1] = 0.0f;
-			xyz_to_rgb[2][2] = 1.0f;
-			to_rgb_processor->applyRGB(xyz_to_rgb[0]);
-			to_rgb_processor->applyRGB(xyz_to_rgb[1]);
-			to_rgb_processor->applyRGB(xyz_to_rgb[2]);
-		}
-	}
+  ConstConfigRcPtr config = (*(ConstConfigRcPtr *)config_);
+
+  /* Default to ITU-BT.709 in case no appropriate transform found. */
+  memcpy(xyz_to_rgb, OCIO_XYZ_TO_LINEAR_SRGB, sizeof(OCIO_XYZ_TO_LINEAR_SRGB));
+
+  /* Auto estimate from XYZ and scene_linear roles, assumed to be a linear transform. */
+  if (config->hasRole("XYZ") && config->hasRole("scene_linear")) {
+    ConstProcessorRcPtr to_rgb_processor = config->getProcessor("XYZ", "scene_linear");
+    if (to_rgb_processor) {
+      xyz_to_rgb[0][0] = 1.0f;
+      xyz_to_rgb[0][1] = 0.0f;
+      xyz_to_rgb[0][2] = 0.0f;
+      xyz_to_rgb[1][0] = 0.0f;
+      xyz_to_rgb[1][1] = 1.0f;
+      xyz_to_rgb[1][2] = 0.0f;
+      xyz_to_rgb[2][0] = 0.0f;
+      xyz_to_rgb[2][1] = 0.0f;
+      xyz_to_rgb[2][2] = 1.0f;
+      to_rgb_processor->applyRGB(xyz_to_rgb[0]);
+      to_rgb_processor->applyRGB(xyz_to_rgb[1]);
+      to_rgb_processor->applyRGB(xyz_to_rgb[2]);
+    }
+  }
 }
 
 int OCIOImpl::configGetNumLooks(OCIO_ConstConfigRcPtr *config)
 {
-	try {
-		return (*(ConstConfigRcPtr *) config)->getNumLooks();
-	}
-	catch (Exception &exception) {
-		OCIO_reportException(exception);
-	}
+  try {
+    return (*(ConstConfigRcPtr *)config)->getNumLooks();
+  }
+  catch (Exception &exception) {
+    OCIO_reportException(exception);
+  }
 
-	return 0;
+  return 0;
 }
 
 const char *OCIOImpl::configGetLookNameByIndex(OCIO_ConstConfigRcPtr *config, int index)
 {
-	try {
-		return (*(ConstConfigRcPtr *) config)->getLookNameByIndex(index);
-	}
-	catch (Exception &exception) {
-		OCIO_reportException(exception);
-	}
+  try {
+    return (*(ConstConfigRcPtr *)config)->getLookNameByIndex(index);
+  }
+  catch (Exception &exception) {
+    OCIO_reportException(exception);
+  }
 
-	return NULL;
+  return NULL;
 }
 
 OCIO_ConstLookRcPtr *OCIOImpl::configGetLook(OCIO_ConstConfigRcPtr *config, const char *name)
 {
-	ConstLookRcPtr *look = OBJECT_GUARDED_NEW(ConstLookRcPtr);
+  ConstLookRcPtr *look = OBJECT_GUARDED_NEW(ConstLookRcPtr);
 
-	try {
-		*look = (*(ConstConfigRcPtr *) config)->getLook(name);
+  try {
+    *look = (*(ConstConfigRcPtr *)config)->getLook(name);
 
-		if (*look)
-			return (OCIO_ConstLookRcPtr *) look;
-	}
-	catch (Exception &exception) {
-		OCIO_reportException(exception);
-	}
+    if (*look)
+      return (OCIO_ConstLookRcPtr *)look;
+  }
+  catch (Exception &exception) {
+    OCIO_reportException(exception);
+  }
 
-	OBJECT_GUARDED_DELETE(look, ConstLookRcPtr);
+  OBJECT_GUARDED_DELETE(look, ConstLookRcPtr);
 
-	return NULL;
+  return NULL;
 }
 
 const char *OCIOImpl::lookGetProcessSpace(OCIO_ConstLookRcPtr *look)
 {
-	return (*(ConstLookRcPtr *) look)->getProcessSpace();
+  return (*(ConstLookRcPtr *)look)->getProcessSpace();
 }
 
 void OCIOImpl::lookRelease(OCIO_ConstLookRcPtr *look)
 {
-	OBJECT_GUARDED_DELETE((ConstLookRcPtr *) look, ConstLookRcPtr);
+  OBJECT_GUARDED_DELETE((ConstLookRcPtr *)look, ConstLookRcPtr);
 }
 
 int OCIOImpl::colorSpaceIsInvertible(OCIO_ConstColorSpaceRcPtr *cs_)
 {
-	ConstColorSpaceRcPtr *cs = (ConstColorSpaceRcPtr *) cs_;
-	const char *family = (*cs)->getFamily();
+  ConstColorSpaceRcPtr *cs = (ConstColorSpaceRcPtr *)cs_;
+  const char *family = (*cs)->getFamily();
 
-	if (!strcmp(family, "rrt") || !strcmp(family, "display")) {
-		/* assume display and rrt transformations are not invertible
-		 * in fact some of them could be, but it doesn't make much sense to allow use them as invertible
-		 */
-		return false;
-	}
+  if (!strcmp(family, "rrt") || !strcmp(family, "display")) {
+    /* assume display and rrt transformations are not invertible
+     * in fact some of them could be, but it doesn't make much sense to allow use them as invertible
+     */
+    return false;
+  }
 
-	if ((*cs)->isData()) {
-		/* data color spaces don't have transformation at all */
-		return true;
-	}
+  if ((*cs)->isData()) {
+    /* data color spaces don't have transformation at all */
+    return true;
+  }
 
-	if ((*cs)->getTransform(COLORSPACE_DIR_TO_REFERENCE)) {
-		/* if there's defined transform to reference space, color space could be converted to scene linear */
-		return true;
-	}
+  if ((*cs)->getTransform(COLORSPACE_DIR_TO_REFERENCE)) {
+    /* if there's defined transform to reference space, color space could be converted to scene linear */
+    return true;
+  }
 
-	return true;
+  return true;
 }
 
 int OCIOImpl::colorSpaceIsData(OCIO_ConstColorSpaceRcPtr *cs)
 {
-	return (*(ConstColorSpaceRcPtr *) cs)->isData();
+  return (*(ConstColorSpaceRcPtr *)cs)->isData();
 }
 
 void OCIOImpl::colorSpaceRelease(OCIO_ConstColorSpaceRcPtr *cs)
 {
-	OBJECT_GUARDED_DELETE((ConstColorSpaceRcPtr *) cs, ConstColorSpaceRcPtr);
+  OBJECT_GUARDED_DELETE((ConstColorSpaceRcPtr *)cs, ConstColorSpaceRcPtr);
 }
 
-OCIO_ConstProcessorRcPtr *OCIOImpl::configGetProcessorWithNames(OCIO_ConstConfigRcPtr *config, const char *srcName, const char *dstName)
+OCIO_ConstProcessorRcPtr *OCIOImpl::configGetProcessorWithNames(OCIO_ConstConfigRcPtr *config,
+                                                                const char *srcName,
+                                                                const char *dstName)
 {
-	ConstProcessorRcPtr *p = OBJECT_GUARDED_NEW(ConstProcessorRcPtr);
+  ConstProcessorRcPtr *p = OBJECT_GUARDED_NEW(ConstProcessorRcPtr);
 
-	try {
-		*p = (*(ConstConfigRcPtr *) config)->getProcessor(srcName, dstName);
+  try {
+    *p = (*(ConstConfigRcPtr *)config)->getProcessor(srcName, dstName);
 
-		if (*p)
-			return (OCIO_ConstProcessorRcPtr *) p;
-	}
-	catch (Exception &exception) {
-		OCIO_reportException(exception);
-	}
+    if (*p)
+      return (OCIO_ConstProcessorRcPtr *)p;
+  }
+  catch (Exception &exception) {
+    OCIO_reportException(exception);
+  }
 
-	OBJECT_GUARDED_DELETE(p, ConstProcessorRcPtr);
+  OBJECT_GUARDED_DELETE(p, ConstProcessorRcPtr);
 
-	return 0;
+  return 0;
 }
 
-OCIO_ConstProcessorRcPtr *OCIOImpl::configGetProcessor(OCIO_ConstConfigRcPtr *config, OCIO_ConstTransformRcPtr *transform)
+OCIO_ConstProcessorRcPtr *OCIOImpl::configGetProcessor(OCIO_ConstConfigRcPtr *config,
+                                                       OCIO_ConstTransformRcPtr *transform)
 {
-	ConstProcessorRcPtr *p = OBJECT_GUARDED_NEW(ConstProcessorRcPtr);
+  ConstProcessorRcPtr *p = OBJECT_GUARDED_NEW(ConstProcessorRcPtr);
 
-	try {
-		*p = (*(ConstConfigRcPtr *) config)->getProcessor(*(ConstTransformRcPtr *) transform);
+  try {
+    *p = (*(ConstConfigRcPtr *)config)->getProcessor(*(ConstTransformRcPtr *)transform);
 
-		if (*p)
-			return (OCIO_ConstProcessorRcPtr *) p;
-	}
-	catch (Exception &exception) {
-		OCIO_reportException(exception);
-	}
+    if (*p)
+      return (OCIO_ConstProcessorRcPtr *)p;
+  }
+  catch (Exception &exception) {
+    OCIO_reportException(exception);
+  }
 
-	OBJECT_GUARDED_DELETE(p, ConstProcessorRcPtr);
+  OBJECT_GUARDED_DELETE(p, ConstProcessorRcPtr);
 
-	return NULL;
+  return NULL;
 }
 
 void OCIOImpl::processorApply(OCIO_ConstProcessorRcPtr *processor, OCIO_PackedImageDesc *img)
 {
-	try {
-		(*(ConstProcessorRcPtr *) processor)->apply(*(PackedImageDesc *) img);
-	}
-	catch (Exception &exception) {
-		OCIO_reportException(exception);
-	}
+  try {
+    (*(ConstProcessorRcPtr *)processor)->apply(*(PackedImageDesc *)img);
+  }
+  catch (Exception &exception) {
+    OCIO_reportException(exception);
+  }
 }
 
-void OCIOImpl::processorApply_predivide(OCIO_ConstProcessorRcPtr *processor, OCIO_PackedImageDesc *img_)
+void OCIOImpl::processorApply_predivide(OCIO_ConstProcessorRcPtr *processor,
+                                        OCIO_PackedImageDesc *img_)
 {
-	try {
-		PackedImageDesc *img = (PackedImageDesc *) img_;
-		int channels = img->getNumChannels();
+  try {
+    PackedImageDesc *img = (PackedImageDesc *)img_;
+    int channels = img->getNumChannels();
 
-		if (channels == 4) {
-			float *pixels = img->getData();
+    if (channels == 4) {
+      float *pixels = img->getData();
 
-			int width = img->getWidth();
-			int height = img->getHeight();
+      int width = img->getWidth();
+      int height = img->getHeight();
 
-			for (int y = 0; y < height; y++) {
-				for (int x = 0; x < width; x++) {
-					float *pixel = pixels + 4 * (y * width + x);
+      for (int y = 0; y < height; y++) {
+        for (int x = 0; x < width; x++) {
+          float *pixel = pixels + 4 * (y * width + x);
 
-					processorApplyRGBA_predivide(processor, pixel);
-				}
-			}
-		}
-		else {
-			(*(ConstProcessorRcPtr *) processor)->apply(*img);
-		}
-	}
-	catch (Exception &exception) {
-		OCIO_reportException(exception);
-	}
+          processorApplyRGBA_predivide(processor, pixel);
+        }
+      }
+    }
+    else {
+      (*(ConstProcessorRcPtr *)processor)->apply(*img);
+    }
+  }
+  catch (Exception &exception) {
+    OCIO_reportException(exception);
+  }
 }
 
 void OCIOImpl::processorApplyRGB(OCIO_ConstProcessorRcPtr *processor, float *pixel)
 {
-	(*(ConstProcessorRcPtr *) processor)->applyRGB(pixel);
+  (*(ConstProcessorRcPtr *)processor)->applyRGB(pixel);
 }
 
 void OCIOImpl::processorApplyRGBA(OCIO_ConstProcessorRcPtr *processor, float *pixel)
 {
-	(*(ConstProcessorRcPtr *) processor)->applyRGBA(pixel);
+  (*(ConstProcessorRcPtr *)processor)->applyRGBA(pixel);
 }
 
 void OCIOImpl::processorApplyRGBA_predivide(OCIO_ConstProcessorRcPtr *processor, float *pixel)
 {
-	if (pixel[3] == 1.0f || pixel[3] == 0.0f) {
-		(*(ConstProcessorRcPtr *) processor)->applyRGBA(pixel);
-	}
-	else {
-		float alpha, inv_alpha;
+  if (pixel[3] == 1.0f || pixel[3] == 0.0f) {
+    (*(ConstProcessorRcPtr *)processor)->applyRGBA(pixel);
+  }
+  else {
+    float alpha, inv_alpha;
 
-		alpha = pixel[3];
-		inv_alpha = 1.0f / alpha;
+    alpha = pixel[3];
+    inv_alpha = 1.0f / alpha;
 
-		pixel[0] *= inv_alpha;
-		pixel[1] *= inv_alpha;
-		pixel[2] *= inv_alpha;
+    pixel[0] *= inv_alpha;
+    pixel[1] *= inv_alpha;
+    pixel[2] *= inv_alpha;
 
-		(*(ConstProcessorRcPtr *) processor)->applyRGBA(pixel);
+    (*(ConstProcessorRcPtr *)processor)->applyRGBA(pixel);
 
-		pixel[0] *= alpha;
-		pixel[1] *= alpha;
-		pixel[2] *= alpha;
-	}
+    pixel[0] *= alpha;
+    pixel[1] *= alpha;
+    pixel[2] *= alpha;
+  }
 }
 
 void OCIOImpl::processorRelease(OCIO_ConstProcessorRcPtr *p)
 {
-	OBJECT_GUARDED_DELETE(p, ConstProcessorRcPtr);
+  OBJECT_GUARDED_DELETE(p, ConstProcessorRcPtr);
 }
 
 const char *OCIOImpl::colorSpaceGetName(OCIO_ConstColorSpaceRcPtr *cs)
 {
-	return (*(ConstColorSpaceRcPtr *) cs)->getName();
+  return (*(ConstColorSpaceRcPtr *)cs)->getName();
 }
 
 const char *OCIOImpl::colorSpaceGetDescription(OCIO_ConstColorSpaceRcPtr *cs)
 {
-	return (*(ConstColorSpaceRcPtr *) cs)->getDescription();
+  return (*(ConstColorSpaceRcPtr *)cs)->getDescription();
 }
 
 const char *OCIOImpl::colorSpaceGetFamily(OCIO_ConstColorSpaceRcPtr *cs)
 {
-	return (*(ConstColorSpaceRcPtr *)cs)->getFamily();
+  return (*(ConstColorSpaceRcPtr *)cs)->getFamily();
 }
 
 OCIO_DisplayTransformRcPtr *OCIOImpl::createDisplayTransform(void)
 {
-	DisplayTransformRcPtr *dt = OBJECT_GUARDED_NEW(DisplayTransformRcPtr);
+  DisplayTransformRcPtr *dt = OBJECT_GUARDED_NEW(DisplayTransformRcPtr);
 
-	*dt = DisplayTransform::Create();
+  *dt = DisplayTransform::Create();
 
-	return (OCIO_DisplayTransformRcPtr *) dt;
+  return (OCIO_DisplayTransformRcPtr *)dt;
 }
 
-void OCIOImpl::displayTransformSetInputColorSpaceName(OCIO_DisplayTransformRcPtr *dt, const char *name)
+void OCIOImpl::displayTransformSetInputColorSpaceName(OCIO_DisplayTransformRcPtr *dt,
+                                                      const char *name)
 {
-	(*(DisplayTransformRcPtr *) dt)->setInputColorSpaceName(name);
+  (*(DisplayTransformRcPtr *)dt)->setInputColorSpaceName(name);
 }
 
 void OCIOImpl::displayTransformSetDisplay(OCIO_DisplayTransformRcPtr *dt, const char *name)
 {
-	(*(DisplayTransformRcPtr *) dt)->setDisplay(name);
+  (*(DisplayTransformRcPtr *)dt)->setDisplay(name);
 }
 
 void OCIOImpl::displayTransformSetView(OCIO_DisplayTransformRcPtr *dt, const char *name)
 {
-	(*(DisplayTransformRcPtr *) dt)->setView(name);
+  (*(DisplayTransformRcPtr *)dt)->setView(name);
 }
 
-void OCIOImpl::displayTransformSetDisplayCC(OCIO_DisplayTransformRcPtr *dt, OCIO_ConstTransformRcPtr *t)
+void OCIOImpl::displayTransformSetDisplayCC(OCIO_DisplayTransformRcPtr *dt,
+                                            OCIO_ConstTransformRcPtr *t)
 {
-	(*(DisplayTransformRcPtr *) dt)->setDisplayCC(* (ConstTransformRcPtr *) t);
+  (*(DisplayTransformRcPtr *)dt)->setDisplayCC(*(ConstTransformRcPtr *)t);
 }
 
-void OCIOImpl::displayTransformSetLinearCC(OCIO_DisplayTransformRcPtr *dt, OCIO_ConstTransformRcPtr *t)
+void OCIOImpl::displayTransformSetLinearCC(OCIO_DisplayTransformRcPtr *dt,
+                                           OCIO_ConstTransformRcPtr *t)
 {
-	(*(DisplayTransformRcPtr *) dt)->setLinearCC(*(ConstTransformRcPtr *) t);
+  (*(DisplayTransformRcPtr *)dt)->setLinearCC(*(ConstTransformRcPtr *)t);
 }
 
 void OCIOImpl::displayTransformSetLooksOverride(OCIO_DisplayTransformRcPtr *dt, const char *looks)
 {
-	(*(DisplayTransformRcPtr *) dt)->setLooksOverride(looks);
+  (*(DisplayTransformRcPtr *)dt)->setLooksOverride(looks);
 }
 
-void OCIOImpl::displayTransformSetLooksOverrideEnabled(OCIO_DisplayTransformRcPtr *dt, bool enabled)
+void OCIOImpl::displayTransformSetLooksOverrideEnabled(OCIO_DisplayTransformRcPtr *dt,
+                                                       bool enabled)
 {
-	(*(DisplayTransformRcPtr *) dt)->setLooksOverrideEnabled(enabled);
+  (*(DisplayTransformRcPtr *)dt)->setLooksOverrideEnabled(enabled);
 }
 
 void OCIOImpl::displayTransformRelease(OCIO_DisplayTransformRcPtr *dt)
 {
-	OBJECT_GUARDED_DELETE((DisplayTransformRcPtr *) dt, DisplayTransformRcPtr);
+  OBJECT_GUARDED_DELETE((DisplayTransformRcPtr *)dt, DisplayTransformRcPtr);
 }
 
-OCIO_PackedImageDesc *OCIOImpl::createOCIO_PackedImageDesc(float *data, long width, long height, long numChannels,
-                                                           long chanStrideBytes, long xStrideBytes, long yStrideBytes)
+OCIO_PackedImageDesc *OCIOImpl::createOCIO_PackedImageDesc(float *data,
+                                                           long width,
+                                                           long height,
+                                                           long numChannels,
+                                                           long chanStrideBytes,
+                                                           long xStrideBytes,
+                                                           long yStrideBytes)
 {
-	try {
-		void *mem = MEM_mallocN(sizeof(PackedImageDesc), __func__);
-		PackedImageDesc *id = new(mem) PackedImageDesc(data, width, height, numChannels, chanStrideBytes, xStrideBytes, yStrideBytes);
+  try {
+    void *mem = MEM_mallocN(sizeof(PackedImageDesc), __func__);
+    PackedImageDesc *id = new (mem) PackedImageDesc(
+        data, width, height, numChannels, chanStrideBytes, xStrideBytes, yStrideBytes);
 
-		return (OCIO_PackedImageDesc *) id;
-	}
-	catch (Exception &exception) {
-		OCIO_reportException(exception);
-	}
+    return (OCIO_PackedImageDesc *)id;
+  }
+  catch (Exception &exception) {
+    OCIO_reportException(exception);
+  }
 
-	return NULL;
+  return NULL;
 }
 
-void OCIOImpl::OCIO_PackedImageDescRelease(OCIO_PackedImageDesc* id)
+void OCIOImpl::OCIO_PackedImageDescRelease(OCIO_PackedImageDesc *id)
 {
-	OBJECT_GUARDED_DELETE((PackedImageDesc *) id, PackedImageDesc);
+  OBJECT_GUARDED_DELETE((PackedImageDesc *)id, PackedImageDesc);
 }
 
 OCIO_ExponentTransformRcPtr *OCIOImpl::createExponentTransform(void)
 {
-	ExponentTransformRcPtr *et = OBJECT_GUARDED_NEW(ExponentTransformRcPtr);
+  ExponentTransformRcPtr *et = OBJECT_GUARDED_NEW(ExponentTransformRcPtr);
 
-	*et = ExponentTransform::Create();
+  *et = ExponentTransform::Create();
 
-	return (OCIO_ExponentTransformRcPtr *) et;
+  return (OCIO_ExponentTransformRcPtr *)et;
 }
 
 void OCIOImpl::exponentTransformSetValue(OCIO_ExponentTransformRcPtr *et, const float *exponent)
 {
-	(*(ExponentTransformRcPtr *) et)->setValue(exponent);
+  (*(ExponentTransformRcPtr *)et)->setValue(exponent);
 }
 
 void OCIOImpl::exponentTransformRelease(OCIO_ExponentTransformRcPtr *et)
 {
-	OBJECT_GUARDED_DELETE((ExponentTransformRcPtr *) et, ExponentTransformRcPtr);
+  OBJECT_GUARDED_DELETE((ExponentTransformRcPtr *)et, ExponentTransformRcPtr);
 }
 
 OCIO_MatrixTransformRcPtr *OCIOImpl::createMatrixTransform(void)
 {
-	MatrixTransformRcPtr *mt = OBJECT_GUARDED_NEW(MatrixTransformRcPtr);
+  MatrixTransformRcPtr *mt = OBJECT_GUARDED_NEW(MatrixTransformRcPtr);
 
-	*mt = MatrixTransform::Create();
+  *mt = MatrixTransform::Create();
 
-	return (OCIO_MatrixTransformRcPtr *) mt;
+  return (OCIO_MatrixTransformRcPtr *)mt;
 }
 
-void OCIOImpl::matrixTransformSetValue(OCIO_MatrixTransformRcPtr *mt, const float *m44, const float *offset4)
+void OCIOImpl::matrixTransformSetValue(OCIO_MatrixTransformRcPtr *mt,
+                                       const float *m44,
+                                       const float *offset4)
 {
-	(*(MatrixTransformRcPtr *) mt)->setValue(m44, offset4);
+  (*(MatrixTransformRcPtr *)mt)->setValue(m44, offset4);
 }
 
 void OCIOImpl::matrixTransformRelease(OCIO_MatrixTransformRcPtr *mt)
 {
-	OBJECT_GUARDED_DELETE((MatrixTransformRcPtr *) mt, MatrixTransformRcPtr);
+  OBJECT_GUARDED_DELETE((MatrixTransformRcPtr *)mt, MatrixTransformRcPtr);
 }
 
 void OCIOImpl::matrixTransformScale(float *m44, float *offset4, const float *scale4f)
 {
-	MatrixTransform::Scale(m44, offset4, scale4f);
+  MatrixTransform::Scale(m44, offset4, scale4f);
 }
 
 const char *OCIOImpl::getVersionString(void)
 {
-	return GetVersion();
+  return GetVersion();
 }
 
 int OCIOImpl::getVersionHex(void)
 {
-	return GetVersionHex();
+  return GetVersionHex();
 }
diff --git a/intern/opencolorio/ocio_impl.h b/intern/opencolorio/ocio_impl.h
index 991e65cc892..0952e7e16d0 100644
--- a/intern/opencolorio/ocio_impl.h
+++ b/intern/opencolorio/ocio_impl.h
@@ -23,274 +23,333 @@
 #include "ocio_capi.h"
 
 class IOCIOImpl {
-public:
-	virtual ~IOCIOImpl() {}
-
-	virtual OCIO_ConstConfigRcPtr *getCurrentConfig(void) = 0;
-	virtual void setCurrentConfig(const OCIO_ConstConfigRcPtr *config) = 0;
-
-	virtual OCIO_ConstConfigRcPtr *configCreateFromEnv(void) = 0;
-	virtual OCIO_ConstConfigRcPtr *configCreateFromFile(const char* filename) = 0;
-
-	virtual void configRelease(OCIO_ConstConfigRcPtr *config) = 0;
-
-	virtual int configGetNumColorSpaces(OCIO_ConstConfigRcPtr *config) = 0;
-	virtual const char *configGetColorSpaceNameByIndex(OCIO_ConstConfigRcPtr *config, int index) = 0;
-	virtual OCIO_ConstColorSpaceRcPtr *configGetColorSpace(OCIO_ConstConfigRcPtr *config, const char *name) = 0;
-	virtual int configGetIndexForColorSpace(OCIO_ConstConfigRcPtr *config, const char *name) = 0;
-
-	virtual int colorSpaceIsInvertible(OCIO_ConstColorSpaceRcPtr *cs) = 0;
-	virtual int colorSpaceIsData(OCIO_ConstColorSpaceRcPtr *cs) = 0;
-
-	virtual void colorSpaceRelease(OCIO_ConstColorSpaceRcPtr *cs) = 0;
-
-	virtual const char *configGetDefaultDisplay(OCIO_ConstConfigRcPtr *config) = 0;
-	virtual int         configGetNumDisplays(OCIO_ConstConfigRcPtr *config) = 0;
-	virtual const char *configGetDisplay(OCIO_ConstConfigRcPtr *config, int index) = 0;
-	virtual const char *configGetDefaultView(OCIO_ConstConfigRcPtr *config, const char *display) = 0;
-	virtual int         configGetNumViews(OCIO_ConstConfigRcPtr *config, const char *display) = 0;
-	virtual const char *configGetView(OCIO_ConstConfigRcPtr *config, const char *display, int index) = 0;
-	virtual const char *configGetDisplayColorSpaceName(OCIO_ConstConfigRcPtr *config, const char *display, const char *view) = 0;
-
-	virtual void configGetDefaultLumaCoefs(OCIO_ConstConfigRcPtr *config, float *rgb) = 0;
-	virtual void configGetXYZtoRGB(OCIO_ConstConfigRcPtr *config, float xyz_to_rgb[3][3]) = 0;
-
-	virtual int                  configGetNumLooks(OCIO_ConstConfigRcPtr *config) = 0;
-	virtual const char          *configGetLookNameByIndex(OCIO_ConstConfigRcPtr *config, int index) = 0;
-	virtual OCIO_ConstLookRcPtr *configGetLook(OCIO_ConstConfigRcPtr *config, const char *name) = 0;
-
-	virtual const char *lookGetProcessSpace(OCIO_ConstLookRcPtr *look) = 0;
-	virtual void        lookRelease(OCIO_ConstLookRcPtr *look) = 0;
-
-	virtual OCIO_ConstProcessorRcPtr *configGetProcessorWithNames(OCIO_ConstConfigRcPtr *config, const char *srcName, const char *dstName) = 0;
-	virtual OCIO_ConstProcessorRcPtr *configGetProcessor(OCIO_ConstConfigRcPtr *config, OCIO_ConstTransformRcPtr *transform) = 0;
-
-	virtual void processorApply(OCIO_ConstProcessorRcPtr *processor, OCIO_PackedImageDesc *img) = 0;
-	virtual void processorApply_predivide(OCIO_ConstProcessorRcPtr *processor, OCIO_PackedImageDesc *img) = 0;
-	virtual void processorApplyRGB(OCIO_ConstProcessorRcPtr *processor, float *pixel) = 0;
-	virtual void processorApplyRGBA(OCIO_ConstProcessorRcPtr *processor, float *pixel) = 0;
-	virtual void processorApplyRGBA_predivide(OCIO_ConstProcessorRcPtr *processor, float *pixel) = 0;
-
-	virtual void processorRelease(OCIO_ConstProcessorRcPtr *p) = 0;
-
-	virtual const char *colorSpaceGetName(OCIO_ConstColorSpaceRcPtr *cs) = 0;
-	virtual const char *colorSpaceGetDescription(OCIO_ConstColorSpaceRcPtr *cs) = 0;
-	virtual const char *colorSpaceGetFamily(OCIO_ConstColorSpaceRcPtr *cs) = 0;
-
-	virtual OCIO_DisplayTransformRcPtr *createDisplayTransform(void) = 0;
-	virtual void displayTransformSetInputColorSpaceName(OCIO_DisplayTransformRcPtr *dt, const char *name) = 0;
-	virtual void displayTransformSetDisplay(OCIO_DisplayTransformRcPtr *dt, const char *name) = 0;
-	virtual void displayTransformSetView(OCIO_DisplayTransformRcPtr *dt, const char *name) = 0;
-	virtual void displayTransformSetDisplayCC(OCIO_DisplayTransformRcPtr *dt, OCIO_ConstTransformRcPtr *et) = 0;
-	virtual void displayTransformSetLinearCC(OCIO_DisplayTransformRcPtr *dt, OCIO_ConstTransformRcPtr *et) = 0;
-	virtual void displayTransformSetLooksOverride(OCIO_DisplayTransformRcPtr *dt, const char *looks) = 0;
-	virtual void displayTransformSetLooksOverrideEnabled(OCIO_DisplayTransformRcPtr *dt, bool enabled) = 0;
-	virtual void displayTransformRelease(OCIO_DisplayTransformRcPtr *dt) = 0;
-
-	virtual OCIO_PackedImageDesc *createOCIO_PackedImageDesc(float *data, long width, long height, long numChannels,
-	                                               long chanStrideBytes, long xStrideBytes, long yStrideBytes) = 0;
-
-	virtual void OCIO_PackedImageDescRelease(OCIO_PackedImageDesc *p) = 0;
-
-	virtual OCIO_ExponentTransformRcPtr *createExponentTransform(void) = 0;
-	virtual void exponentTransformSetValue(OCIO_ExponentTransformRcPtr *et, const float *exponent) = 0;
-	virtual void exponentTransformRelease(OCIO_ExponentTransformRcPtr *et) = 0;
-
-	virtual OCIO_MatrixTransformRcPtr *createMatrixTransform(void) = 0;
-	virtual void matrixTransformSetValue(OCIO_MatrixTransformRcPtr *mt, const float *m44, const float *offset4) = 0;
-	virtual void matrixTransformRelease(OCIO_MatrixTransformRcPtr *mt) = 0;
-
-	virtual void matrixTransformScale(float * m44, float * offset4, const float * scale4) = 0;
-
-	virtual bool supportGLSLDraw(void) = 0;
-	virtual bool setupGLSLDraw(struct OCIO_GLSLDrawState **state_r, OCIO_ConstProcessorRcPtr *processor,
-	                           OCIO_CurveMappingSettings *curve_mapping_settings, float dither, bool predivide) = 0;
-	virtual void finishGLSLDraw(struct OCIO_GLSLDrawState *state) = 0;
-	virtual void freeGLState(struct OCIO_GLSLDrawState *state_r) = 0;
-
-	virtual const char *getVersionString(void) = 0;
-	virtual int getVersionHex(void) = 0;
+ public:
+  virtual ~IOCIOImpl()
+  {
+  }
+
+  virtual OCIO_ConstConfigRcPtr *getCurrentConfig(void) = 0;
+  virtual void setCurrentConfig(const OCIO_ConstConfigRcPtr *config) = 0;
+
+  virtual OCIO_ConstConfigRcPtr *configCreateFromEnv(void) = 0;
+  virtual OCIO_ConstConfigRcPtr *configCreateFromFile(const char *filename) = 0;
+
+  virtual void configRelease(OCIO_ConstConfigRcPtr *config) = 0;
+
+  virtual int configGetNumColorSpaces(OCIO_ConstConfigRcPtr *config) = 0;
+  virtual const char *configGetColorSpaceNameByIndex(OCIO_ConstConfigRcPtr *config, int index) = 0;
+  virtual OCIO_ConstColorSpaceRcPtr *configGetColorSpace(OCIO_ConstConfigRcPtr *config,
+                                                         const char *name) = 0;
+  virtual int configGetIndexForColorSpace(OCIO_ConstConfigRcPtr *config, const char *name) = 0;
+
+  virtual int colorSpaceIsInvertible(OCIO_ConstColorSpaceRcPtr *cs) = 0;
+  virtual int colorSpaceIsData(OCIO_ConstColorSpaceRcPtr *cs) = 0;
+
+  virtual void colorSpaceRelease(OCIO_ConstColorSpaceRcPtr *cs) = 0;
+
+  virtual const char *configGetDefaultDisplay(OCIO_ConstConfigRcPtr *config) = 0;
+  virtual int configGetNumDisplays(OCIO_ConstConfigRcPtr *config) = 0;
+  virtual const char *configGetDisplay(OCIO_ConstConfigRcPtr *config, int index) = 0;
+  virtual const char *configGetDefaultView(OCIO_ConstConfigRcPtr *config, const char *display) = 0;
+  virtual int configGetNumViews(OCIO_ConstConfigRcPtr *config, const char *display) = 0;
+  virtual const char *configGetView(OCIO_ConstConfigRcPtr *config,
+                                    const char *display,
+                                    int index) = 0;
+  virtual const char *configGetDisplayColorSpaceName(OCIO_ConstConfigRcPtr *config,
+                                                     const char *display,
+                                                     const char *view) = 0;
+
+  virtual void configGetDefaultLumaCoefs(OCIO_ConstConfigRcPtr *config, float *rgb) = 0;
+  virtual void configGetXYZtoRGB(OCIO_ConstConfigRcPtr *config, float xyz_to_rgb[3][3]) = 0;
+
+  virtual int configGetNumLooks(OCIO_ConstConfigRcPtr *config) = 0;
+  virtual const char *configGetLookNameByIndex(OCIO_ConstConfigRcPtr *config, int index) = 0;
+  virtual OCIO_ConstLookRcPtr *configGetLook(OCIO_ConstConfigRcPtr *config, const char *name) = 0;
+
+  virtual const char *lookGetProcessSpace(OCIO_ConstLookRcPtr *look) = 0;
+  virtual void lookRelease(OCIO_ConstLookRcPtr *look) = 0;
+
+  virtual OCIO_ConstProcessorRcPtr *configGetProcessorWithNames(OCIO_ConstConfigRcPtr *config,
+                                                                const char *srcName,
+                                                                const char *dstName) = 0;
+  virtual OCIO_ConstProcessorRcPtr *configGetProcessor(OCIO_ConstConfigRcPtr *config,
+                                                       OCIO_ConstTransformRcPtr *transform) = 0;
+
+  virtual void processorApply(OCIO_ConstProcessorRcPtr *processor, OCIO_PackedImageDesc *img) = 0;
+  virtual void processorApply_predivide(OCIO_ConstProcessorRcPtr *processor,
+                                        OCIO_PackedImageDesc *img) = 0;
+  virtual void processorApplyRGB(OCIO_ConstProcessorRcPtr *processor, float *pixel) = 0;
+  virtual void processorApplyRGBA(OCIO_ConstProcessorRcPtr *processor, float *pixel) = 0;
+  virtual void processorApplyRGBA_predivide(OCIO_ConstProcessorRcPtr *processor, float *pixel) = 0;
+
+  virtual void processorRelease(OCIO_ConstProcessorRcPtr *p) = 0;
+
+  virtual const char *colorSpaceGetName(OCIO_ConstColorSpaceRcPtr *cs) = 0;
+  virtual const char *colorSpaceGetDescription(OCIO_ConstColorSpaceRcPtr *cs) = 0;
+  virtual const char *colorSpaceGetFamily(OCIO_ConstColorSpaceRcPtr *cs) = 0;
+
+  virtual OCIO_DisplayTransformRcPtr *createDisplayTransform(void) = 0;
+  virtual void displayTransformSetInputColorSpaceName(OCIO_DisplayTransformRcPtr *dt,
+                                                      const char *name) = 0;
+  virtual void displayTransformSetDisplay(OCIO_DisplayTransformRcPtr *dt, const char *name) = 0;
+  virtual void displayTransformSetView(OCIO_DisplayTransformRcPtr *dt, const char *name) = 0;
+  virtual void displayTransformSetDisplayCC(OCIO_DisplayTransformRcPtr *dt,
+                                            OCIO_ConstTransformRcPtr *et) = 0;
+  virtual void displayTransformSetLinearCC(OCIO_DisplayTransformRcPtr *dt,
+                                           OCIO_ConstTransformRcPtr *et) = 0;
+  virtual void displayTransformSetLooksOverride(OCIO_DisplayTransformRcPtr *dt,
+                                                const char *looks) = 0;
+  virtual void displayTransformSetLooksOverrideEnabled(OCIO_DisplayTransformRcPtr *dt,
+                                                       bool enabled) = 0;
+  virtual void displayTransformRelease(OCIO_DisplayTransformRcPtr *dt) = 0;
+
+  virtual OCIO_PackedImageDesc *createOCIO_PackedImageDesc(float *data,
+                                                           long width,
+                                                           long height,
+                                                           long numChannels,
+                                                           long chanStrideBytes,
+                                                           long xStrideBytes,
+                                                           long yStrideBytes) = 0;
+
+  virtual void OCIO_PackedImageDescRelease(OCIO_PackedImageDesc *p) = 0;
+
+  virtual OCIO_ExponentTransformRcPtr *createExponentTransform(void) = 0;
+  virtual void exponentTransformSetValue(OCIO_ExponentTransformRcPtr *et,
+                                         const float *exponent) = 0;
+  virtual void exponentTransformRelease(OCIO_ExponentTransformRcPtr *et) = 0;
+
+  virtual OCIO_MatrixTransformRcPtr *createMatrixTransform(void) = 0;
+  virtual void matrixTransformSetValue(OCIO_MatrixTransformRcPtr *mt,
+                                       const float *m44,
+                                       const float *offset4) = 0;
+  virtual void matrixTransformRelease(OCIO_MatrixTransformRcPtr *mt) = 0;
+
+  virtual void matrixTransformScale(float *m44, float *offset4, const float *scale4) = 0;
+
+  virtual bool supportGLSLDraw(void) = 0;
+  virtual bool setupGLSLDraw(struct OCIO_GLSLDrawState **state_r,
+                             OCIO_ConstProcessorRcPtr *processor,
+                             OCIO_CurveMappingSettings *curve_mapping_settings,
+                             float dither,
+                             bool predivide) = 0;
+  virtual void finishGLSLDraw(struct OCIO_GLSLDrawState *state) = 0;
+  virtual void freeGLState(struct OCIO_GLSLDrawState *state_r) = 0;
+
+  virtual const char *getVersionString(void) = 0;
+  virtual int getVersionHex(void) = 0;
 };
 
 class FallbackImpl : public IOCIOImpl {
-public:
-	FallbackImpl() {}
-
-	OCIO_ConstConfigRcPtr *getCurrentConfig(void);
-	void setCurrentConfig(const OCIO_ConstConfigRcPtr *config);
-
-	OCIO_ConstConfigRcPtr *configCreateFromEnv(void);
-	OCIO_ConstConfigRcPtr *configCreateFromFile(const char* filename);
-
-	void configRelease(OCIO_ConstConfigRcPtr *config);
-
-	int configGetNumColorSpaces(OCIO_ConstConfigRcPtr *config);
-	const char *configGetColorSpaceNameByIndex(OCIO_ConstConfigRcPtr *config, int index);
-	OCIO_ConstColorSpaceRcPtr *configGetColorSpace(OCIO_ConstConfigRcPtr *config, const char *name);
-	int configGetIndexForColorSpace(OCIO_ConstConfigRcPtr *config, const char *name);
-
-	int colorSpaceIsInvertible(OCIO_ConstColorSpaceRcPtr *cs);
-	int colorSpaceIsData(OCIO_ConstColorSpaceRcPtr *cs);
-
-	void colorSpaceRelease(OCIO_ConstColorSpaceRcPtr *cs);
-
-	const char *configGetDefaultDisplay(OCIO_ConstConfigRcPtr *config);
-	int         configGetNumDisplays(OCIO_ConstConfigRcPtr *config);
-	const char *configGetDisplay(OCIO_ConstConfigRcPtr *config, int index);
-	const char *configGetDefaultView(OCIO_ConstConfigRcPtr *config, const char *display);
-	int         configGetNumViews(OCIO_ConstConfigRcPtr *config, const char *display);
-	const char *configGetView(OCIO_ConstConfigRcPtr *config, const char *display, int index);
-	const char *configGetDisplayColorSpaceName(OCIO_ConstConfigRcPtr *config, const char *display, const char *view);
-
-	void configGetDefaultLumaCoefs(OCIO_ConstConfigRcPtr *config, float *rgb);
-	void configGetXYZtoRGB(OCIO_ConstConfigRcPtr *config, float xyz_to_rgb[3][3]);
-
-	int                  configGetNumLooks(OCIO_ConstConfigRcPtr *config);
-	const char          *configGetLookNameByIndex(OCIO_ConstConfigRcPtr *config, int index);
-	OCIO_ConstLookRcPtr *configGetLook(OCIO_ConstConfigRcPtr *config, const char *name);
-
-	const char *lookGetProcessSpace(OCIO_ConstLookRcPtr *look);
-	void        lookRelease(OCIO_ConstLookRcPtr *look);
-
-	OCIO_ConstProcessorRcPtr *configGetProcessorWithNames(OCIO_ConstConfigRcPtr *config, const char *srcName, const char *dstName);
-	OCIO_ConstProcessorRcPtr *configGetProcessor(OCIO_ConstConfigRcPtr *config, OCIO_ConstTransformRcPtr *transform);
-
-	void processorApply(OCIO_ConstProcessorRcPtr *processor, OCIO_PackedImageDesc *img);
-	void processorApply_predivide(OCIO_ConstProcessorRcPtr *processor, OCIO_PackedImageDesc *img);
-	void processorApplyRGB(OCIO_ConstProcessorRcPtr *processor, float *pixel);
-	void processorApplyRGBA(OCIO_ConstProcessorRcPtr *processor, float *pixel);
-	void processorApplyRGBA_predivide(OCIO_ConstProcessorRcPtr *processor, float *pixel);
-
-	void processorRelease(OCIO_ConstProcessorRcPtr *p);
-
-	const char *colorSpaceGetName(OCIO_ConstColorSpaceRcPtr *cs);
-	const char *colorSpaceGetDescription(OCIO_ConstColorSpaceRcPtr *cs);
-	const char *colorSpaceGetFamily(OCIO_ConstColorSpaceRcPtr *cs);
-
-	OCIO_DisplayTransformRcPtr *createDisplayTransform(void);
-	void displayTransformSetInputColorSpaceName(OCIO_DisplayTransformRcPtr *dt, const char *name);
-	void displayTransformSetDisplay(OCIO_DisplayTransformRcPtr *dt, const char *name);
-	void displayTransformSetView(OCIO_DisplayTransformRcPtr *dt, const char *name);
-	void displayTransformSetDisplayCC(OCIO_DisplayTransformRcPtr *dt, OCIO_ConstTransformRcPtr *et);
-	void displayTransformSetLinearCC(OCIO_DisplayTransformRcPtr *dt, OCIO_ConstTransformRcPtr *et);
-	void displayTransformSetLooksOverride(OCIO_DisplayTransformRcPtr *dt, const char *looks);
-	void displayTransformSetLooksOverrideEnabled(OCIO_DisplayTransformRcPtr *dt, bool enabled);
-	void displayTransformRelease(OCIO_DisplayTransformRcPtr *dt);
-
-	OCIO_PackedImageDesc *createOCIO_PackedImageDesc(float *data, long width, long height, long numChannels,
-	                                       long chanStrideBytes, long xStrideBytes, long yStrideBytes);
-
-	void OCIO_PackedImageDescRelease(OCIO_PackedImageDesc *p);
-
-	OCIO_ExponentTransformRcPtr *createExponentTransform(void);
-	void exponentTransformSetValue(OCIO_ExponentTransformRcPtr *et, const float *exponent);
-	void exponentTransformRelease(OCIO_ExponentTransformRcPtr *et);
-
-	OCIO_MatrixTransformRcPtr *createMatrixTransform(void);
-	void matrixTransformSetValue(OCIO_MatrixTransformRcPtr *mt, const float *m44, const float *offset4);
-	void matrixTransformRelease(OCIO_MatrixTransformRcPtr *mt);
-
-	void matrixTransformScale(float *m44, float *offset4, const float *scale4);
-
-	bool supportGLSLDraw(void);
-	bool setupGLSLDraw(struct OCIO_GLSLDrawState **state_r, OCIO_ConstProcessorRcPtr *processor,
-	                   OCIO_CurveMappingSettings *curve_mapping_settings, float dither, bool predivide);
-	void finishGLSLDraw(struct OCIO_GLSLDrawState *state);
-	void freeGLState(struct OCIO_GLSLDrawState *state_r);
-
-	const char *getVersionString(void);
-	int getVersionHex(void);
+ public:
+  FallbackImpl()
+  {
+  }
+
+  OCIO_ConstConfigRcPtr *getCurrentConfig(void);
+  void setCurrentConfig(const OCIO_ConstConfigRcPtr *config);
+
+  OCIO_ConstConfigRcPtr *configCreateFromEnv(void);
+  OCIO_ConstConfigRcPtr *configCreateFromFile(const char *filename);
+
+  void configRelease(OCIO_ConstConfigRcPtr *config);
+
+  int configGetNumColorSpaces(OCIO_ConstConfigRcPtr *config);
+  const char *configGetColorSpaceNameByIndex(OCIO_ConstConfigRcPtr *config, int index);
+  OCIO_ConstColorSpaceRcPtr *configGetColorSpace(OCIO_ConstConfigRcPtr *config, const char *name);
+  int configGetIndexForColorSpace(OCIO_ConstConfigRcPtr *config, const char *name);
+
+  int colorSpaceIsInvertible(OCIO_ConstColorSpaceRcPtr *cs);
+  int colorSpaceIsData(OCIO_ConstColorSpaceRcPtr *cs);
+
+  void colorSpaceRelease(OCIO_ConstColorSpaceRcPtr *cs);
+
+  const char *configGetDefaultDisplay(OCIO_ConstConfigRcPtr *config);
+  int configGetNumDisplays(OCIO_ConstConfigRcPtr *config);
+  const char *configGetDisplay(OCIO_ConstConfigRcPtr *config, int index);
+  const char *configGetDefaultView(OCIO_ConstConfigRcPtr *config, const char *display);
+  int configGetNumViews(OCIO_ConstConfigRcPtr *config, const char *display);
+  const char *configGetView(OCIO_ConstConfigRcPtr *config, const char *display, int index);
+  const char *configGetDisplayColorSpaceName(OCIO_ConstConfigRcPtr *config,
+                                             const char *display,
+                                             const char *view);
+
+  void configGetDefaultLumaCoefs(OCIO_ConstConfigRcPtr *config, float *rgb);
+  void configGetXYZtoRGB(OCIO_ConstConfigRcPtr *config, float xyz_to_rgb[3][3]);
+
+  int configGetNumLooks(OCIO_ConstConfigRcPtr *config);
+  const char *configGetLookNameByIndex(OCIO_ConstConfigRcPtr *config, int index);
+  OCIO_ConstLookRcPtr *configGetLook(OCIO_ConstConfigRcPtr *config, const char *name);
+
+  const char *lookGetProcessSpace(OCIO_ConstLookRcPtr *look);
+  void lookRelease(OCIO_ConstLookRcPtr *look);
+
+  OCIO_ConstProcessorRcPtr *configGetProcessorWithNames(OCIO_ConstConfigRcPtr *config,
+                                                        const char *srcName,
+                                                        const char *dstName);
+  OCIO_ConstProcessorRcPtr *configGetProcessor(OCIO_ConstConfigRcPtr *config,
+                                               OCIO_ConstTransformRcPtr *transform);
+
+  void processorApply(OCIO_ConstProcessorRcPtr *processor, OCIO_PackedImageDesc *img);
+  void processorApply_predivide(OCIO_ConstProcessorRcPtr *processor, OCIO_PackedImageDesc *img);
+  void processorApplyRGB(OCIO_ConstProcessorRcPtr *processor, float *pixel);
+  void processorApplyRGBA(OCIO_ConstProcessorRcPtr *processor, float *pixel);
+  void processorApplyRGBA_predivide(OCIO_ConstProcessorRcPtr *processor, float *pixel);
+
+  void processorRelease(OCIO_ConstProcessorRcPtr *p);
+
+  const char *colorSpaceGetName(OCIO_ConstColorSpaceRcPtr *cs);
+  const char *colorSpaceGetDescription(OCIO_ConstColorSpaceRcPtr *cs);
+  const char *colorSpaceGetFamily(OCIO_ConstColorSpaceRcPtr *cs);
+
+  OCIO_DisplayTransformRcPtr *createDisplayTransform(void);
+  void displayTransformSetInputColorSpaceName(OCIO_DisplayTransformRcPtr *dt, const char *name);
+  void displayTransformSetDisplay(OCIO_DisplayTransformRcPtr *dt, const char *name);
+  void displayTransformSetView(OCIO_DisplayTransformRcPtr *dt, const char *name);
+  void displayTransformSetDisplayCC(OCIO_DisplayTransformRcPtr *dt, OCIO_ConstTransformRcPtr *et);
+  void displayTransformSetLinearCC(OCIO_DisplayTransformRcPtr *dt, OCIO_ConstTransformRcPtr *et);
+  void displayTransformSetLooksOverride(OCIO_DisplayTransformRcPtr *dt, const char *looks);
+  void displayTransformSetLooksOverrideEnabled(OCIO_DisplayTransformRcPtr *dt, bool enabled);
+  void displayTransformRelease(OCIO_DisplayTransformRcPtr *dt);
+
+  OCIO_PackedImageDesc *createOCIO_PackedImageDesc(float *data,
+                                                   long width,
+                                                   long height,
+                                                   long numChannels,
+                                                   long chanStrideBytes,
+                                                   long xStrideBytes,
+                                                   long yStrideBytes);
+
+  void OCIO_PackedImageDescRelease(OCIO_PackedImageDesc *p);
+
+  OCIO_ExponentTransformRcPtr *createExponentTransform(void);
+  void exponentTransformSetValue(OCIO_ExponentTransformRcPtr *et, const float *exponent);
+  void exponentTransformRelease(OCIO_ExponentTransformRcPtr *et);
+
+  OCIO_MatrixTransformRcPtr *createMatrixTransform(void);
+  void matrixTransformSetValue(OCIO_MatrixTransformRcPtr *mt,
+                               const float *m44,
+                               const float *offset4);
+  void matrixTransformRelease(OCIO_MatrixTransformRcPtr *mt);
+
+  void matrixTransformScale(float *m44, float *offset4, const float *scale4);
+
+  bool supportGLSLDraw(void);
+  bool setupGLSLDraw(struct OCIO_GLSLDrawState **state_r,
+                     OCIO_ConstProcessorRcPtr *processor,
+                     OCIO_CurveMappingSettings *curve_mapping_settings,
+                     float dither,
+                     bool predivide);
+  void finishGLSLDraw(struct OCIO_GLSLDrawState *state);
+  void freeGLState(struct OCIO_GLSLDrawState *state_r);
+
+  const char *getVersionString(void);
+  int getVersionHex(void);
 };
 
 #ifdef WITH_OCIO
 class OCIOImpl : public IOCIOImpl {
-public:
-	OCIOImpl() {};
-
-	OCIO_ConstConfigRcPtr *getCurrentConfig(void);
-	void setCurrentConfig(const OCIO_ConstConfigRcPtr *config);
-
-	OCIO_ConstConfigRcPtr *configCreateFromEnv(void);
-	OCIO_ConstConfigRcPtr *configCreateFromFile(const char* filename);
-
-	void configRelease(OCIO_ConstConfigRcPtr *config);
-
-	int configGetNumColorSpaces(OCIO_ConstConfigRcPtr *config);
-	const char *configGetColorSpaceNameByIndex(OCIO_ConstConfigRcPtr *config, int index);
-	OCIO_ConstColorSpaceRcPtr *configGetColorSpace(OCIO_ConstConfigRcPtr *config, const char *name);
-	int configGetIndexForColorSpace(OCIO_ConstConfigRcPtr *config, const char *name);
-
-	int colorSpaceIsInvertible(OCIO_ConstColorSpaceRcPtr *cs);
-	int colorSpaceIsData(OCIO_ConstColorSpaceRcPtr *cs);
-
-	void colorSpaceRelease(OCIO_ConstColorSpaceRcPtr *cs);
-
-	const char *configGetDefaultDisplay(OCIO_ConstConfigRcPtr *config);
-	int         configGetNumDisplays(OCIO_ConstConfigRcPtr *config);
-	const char *configGetDisplay(OCIO_ConstConfigRcPtr *config, int index);
-	const char *configGetDefaultView(OCIO_ConstConfigRcPtr *config, const char *display);
-	int         configGetNumViews(OCIO_ConstConfigRcPtr *config, const char *display);
-	const char *configGetView(OCIO_ConstConfigRcPtr *config, const char *display, int index);
-	const char *configGetDisplayColorSpaceName(OCIO_ConstConfigRcPtr *config, const char *display, const char *view);
-
-	void configGetDefaultLumaCoefs(OCIO_ConstConfigRcPtr *config, float *rgb);
-	void configGetXYZtoRGB(OCIO_ConstConfigRcPtr *config, float xyz_to_rgb[3][3]);
-
-	int                  configGetNumLooks(OCIO_ConstConfigRcPtr *config);
-	const char          *configGetLookNameByIndex(OCIO_ConstConfigRcPtr *config, int index);
-	OCIO_ConstLookRcPtr *configGetLook(OCIO_ConstConfigRcPtr *config, const char *name);
-
-	const char *lookGetProcessSpace(OCIO_ConstLookRcPtr *look);
-	void        lookRelease(OCIO_ConstLookRcPtr *look);
-
-	OCIO_ConstProcessorRcPtr *configGetProcessorWithNames(OCIO_ConstConfigRcPtr *config, const char *srcName, const char *dstName);
-	OCIO_ConstProcessorRcPtr *configGetProcessor(OCIO_ConstConfigRcPtr *config, OCIO_ConstTransformRcPtr *transform);
-
-	void processorApply(OCIO_ConstProcessorRcPtr *processor, OCIO_PackedImageDesc *img);
-	void processorApply_predivide(OCIO_ConstProcessorRcPtr *processor, OCIO_PackedImageDesc *img);
-	void processorApplyRGB(OCIO_ConstProcessorRcPtr *processor, float *pixel);
-	void processorApplyRGBA(OCIO_ConstProcessorRcPtr *processor, float *pixel);
-	void processorApplyRGBA_predivide(OCIO_ConstProcessorRcPtr *processor, float *pixel);
-
-	void processorRelease(OCIO_ConstProcessorRcPtr *p);
-
-	const char *colorSpaceGetName(OCIO_ConstColorSpaceRcPtr *cs);
-	const char *colorSpaceGetDescription(OCIO_ConstColorSpaceRcPtr *cs);
-	const char *colorSpaceGetFamily(OCIO_ConstColorSpaceRcPtr *cs);
-
-	OCIO_DisplayTransformRcPtr *createDisplayTransform(void);
-	void displayTransformSetInputColorSpaceName(OCIO_DisplayTransformRcPtr *dt, const char *name);
-	void displayTransformSetDisplay(OCIO_DisplayTransformRcPtr *dt, const char *name);
-	void displayTransformSetView(OCIO_DisplayTransformRcPtr *dt, const char *name);
-	void displayTransformSetDisplayCC(OCIO_DisplayTransformRcPtr *dt, OCIO_ConstTransformRcPtr *et);
-	void displayTransformSetLinearCC(OCIO_DisplayTransformRcPtr *dt, OCIO_ConstTransformRcPtr *et);
-	void displayTransformSetLooksOverride(OCIO_DisplayTransformRcPtr *dt, const char *looks);
-	void displayTransformSetLooksOverrideEnabled(OCIO_DisplayTransformRcPtr *dt, bool enabled);
-	void displayTransformRelease(OCIO_DisplayTransformRcPtr *dt);
-
-	OCIO_PackedImageDesc *createOCIO_PackedImageDesc(float *data, long width, long height, long numChannels,
-	                                       long chanStrideBytes, long xStrideBytes, long yStrideBytes);
-
-	void OCIO_PackedImageDescRelease(OCIO_PackedImageDesc *p);
-
-	OCIO_ExponentTransformRcPtr *createExponentTransform(void);
-	void exponentTransformSetValue(OCIO_ExponentTransformRcPtr *et, const float *exponent);
-	void exponentTransformRelease(OCIO_ExponentTransformRcPtr *et);
-
-	OCIO_MatrixTransformRcPtr *createMatrixTransform(void);
-	void matrixTransformSetValue(OCIO_MatrixTransformRcPtr *mt, const float *m44, const float *offset4);
-	void matrixTransformRelease(OCIO_MatrixTransformRcPtr *mt);
-
-	void matrixTransformScale(float * m44, float * offset4, const float * scale4);
-
-	bool supportGLSLDraw(void);
-	bool setupGLSLDraw(struct OCIO_GLSLDrawState **state_r, OCIO_ConstProcessorRcPtr *processor,
-	                   OCIO_CurveMappingSettings *curve_mapping_settings, float dither, bool predivide);
-	void finishGLSLDraw(struct OCIO_GLSLDrawState *state);
-	void freeGLState(struct OCIO_GLSLDrawState *state_r);
-
-	const char *getVersionString(void);
-	int getVersionHex(void);
+ public:
+  OCIOImpl(){};
+
+  OCIO_ConstConfigRcPtr *getCurrentConfig(void);
+  void setCurrentConfig(const OCIO_ConstConfigRcPtr *config);
+
+  OCIO_ConstConfigRcPtr *configCreateFromEnv(void);
+  OCIO_ConstConfigRcPtr *configCreateFromFile(const char *filename);
+
+  void configRelease(OCIO_ConstConfigRcPtr *config);
+
+  int configGetNumColorSpaces(OCIO_ConstConfigRcPtr *config);
+  const char *configGetColorSpaceNameByIndex(OCIO_ConstConfigRcPtr *config, int index);
+  OCIO_ConstColorSpaceRcPtr *configGetColorSpace(OCIO_ConstConfigRcPtr *config, const char *name);
+  int configGetIndexForColorSpace(OCIO_ConstConfigRcPtr *config, const char *name);
+
+  int colorSpaceIsInvertible(OCIO_ConstColorSpaceRcPtr *cs);
+  int colorSpaceIsData(OCIO_ConstColorSpaceRcPtr *cs);
+
+  void colorSpaceRelease(OCIO_ConstColorSpaceRcPtr *cs);
+
+  const char *configGetDefaultDisplay(OCIO_ConstConfigRcPtr *config);
+  int configGetNumDisplays(OCIO_ConstConfigRcPtr *config);
+  const char *configGetDisplay(OCIO_ConstConfigRcPtr *config, int index);
+  const char *configGetDefaultView(OCIO_ConstConfigRcPtr *config, const char *display);
+  int configGetNumViews(OCIO_ConstConfigRcPtr *config, const char *display);
+  const char *configGetView(OCIO_ConstConfigRcPtr *config, const char *display, int index);
+  const char *configGetDisplayColorSpaceName(OCIO_ConstConfigRcPtr *config,
+                                             const char *display,
+                                             const char *view);
+
+  void configGetDefaultLumaCoefs(OCIO_ConstConfigRcPtr *config, float *rgb);
+  void configGetXYZtoRGB(OCIO_ConstConfigRcPtr *config, float xyz_to_rgb[3][3]);
+
+  int configGetNumLooks(OCIO_ConstConfigRcPtr *config);
+  const char *configGetLookNameByIndex(OCIO_ConstConfigRcPtr *config, int index);
+  OCIO_ConstLookRcPtr *configGetLook(OCIO_ConstConfigRcPtr *config, const char *name);
+
+  const char *lookGetProcessSpace(OCIO_ConstLookRcPtr *look);
+  void lookRelease(OCIO_ConstLookRcPtr *look);
+
+  OCIO_ConstProcessorRcPtr *configGetProcessorWithNames(OCIO_ConstConfigRcPtr *config,
+                                                        const char *srcName,
+                                                        const char *dstName);
+  OCIO_ConstProcessorRcPtr *configGetProcessor(OCIO_ConstConfigRcPtr *config,
+                                               OCIO_ConstTransformRcPtr *transform);
+
+  void processorApply(OCIO_ConstProcessorRcPtr *processor, OCIO_PackedImageDesc *img);
+  void processorApply_predivide(OCIO_ConstProcessorRcPtr *processor, OCIO_PackedImageDesc *img);
+  void processorApplyRGB(OCIO_ConstProcessorRcPtr *processor, float *pixel);
+  void processorApplyRGBA(OCIO_ConstProcessorRcPtr *processor, float *pixel);
+  void processorApplyRGBA_predivide(OCIO_ConstProcessorRcPtr *processor, float *pixel);
+
+  void processorRelease(OCIO_ConstProcessorRcPtr *p);
+
+  const char *colorSpaceGetName(OCIO_ConstColorSpaceRcPtr *cs);
+  const char *colorSpaceGetDescription(OCIO_ConstColorSpaceRcPtr *cs);
+  const char *colorSpaceGetFamily(OCIO_ConstColorSpaceRcPtr *cs);
+
+  OCIO_DisplayTransformRcPtr *createDisplayTransform(void);
+  void displayTransformSetInputColorSpaceName(OCIO_DisplayTransformRcPtr *dt, const char *name);
+  void displayTransformSetDisplay(OCIO_DisplayTransformRcPtr *dt, const char *name);
+  void displayTransformSetView(OCIO_DisplayTransformRcPtr *dt, const char *name);
+  void displayTransformSetDisplayCC(OCIO_DisplayTransformRcPtr *dt, OCIO_ConstTransformRcPtr *et);
+  void displayTransformSetLinearCC(OCIO_DisplayTransformRcPtr *dt, OCIO_ConstTransformRcPtr *et);
+  void displayTransformSetLooksOverride(OCIO_DisplayTransformRcPtr *dt, const char *looks);
+  void displayTransformSetLooksOverrideEnabled(OCIO_DisplayTransformRcPtr *dt, bool enabled);
+  void displayTransformRelease(OCIO_DisplayTransformRcPtr *dt);
+
+  OCIO_PackedImageDesc *createOCIO_PackedImageDesc(float *data,
+                                                   long width,
+                                                   long height,
+                                                   long numChannels,
+                                                   long chanStrideBytes,
+                                                   long xStrideBytes,
+                                                   long yStrideBytes);
+
+  void OCIO_PackedImageDescRelease(OCIO_PackedImageDesc *p);
+
+  OCIO_ExponentTransformRcPtr *createExponentTransform(void);
+  void exponentTransformSetValue(OCIO_ExponentTransformRcPtr *et, const float *exponent);
+  void exponentTransformRelease(OCIO_ExponentTransformRcPtr *et);
+
+  OCIO_MatrixTransformRcPtr *createMatrixTransform(void);
+  void matrixTransformSetValue(OCIO_MatrixTransformRcPtr *mt,
+                               const float *m44,
+                               const float *offset4);
+  void matrixTransformRelease(OCIO_MatrixTransformRcPtr *mt);
+
+  void matrixTransformScale(float *m44, float *offset4, const float *scale4);
+
+  bool supportGLSLDraw(void);
+  bool setupGLSLDraw(struct OCIO_GLSLDrawState **state_r,
+                     OCIO_ConstProcessorRcPtr *processor,
+                     OCIO_CurveMappingSettings *curve_mapping_settings,
+                     float dither,
+                     bool predivide);
+  void finishGLSLDraw(struct OCIO_GLSLDrawState *state);
+  void freeGLState(struct OCIO_GLSLDrawState *state_r);
+
+  const char *getVersionString(void);
+  int getVersionHex(void);
 };
 #endif
 
diff --git a/intern/opencolorio/ocio_impl_glsl.cc b/intern/opencolorio/ocio_impl_glsl.cc
index cf41d0a4983..4d0908eafd5 100644
--- a/intern/opencolorio/ocio_impl_glsl.cc
+++ b/intern/opencolorio/ocio_impl_glsl.cc
@@ -64,211 +64,224 @@ extern "C" char datatoc_gpu_shader_display_transform_vertex_glsl[];
 /* **** OpenGL drawing routines using GLSL for color space transform ***** */
 
 typedef struct OCIO_GLSLShader {
-	/* Cache ID */
-	std::string lut3dCacheID;
-	std::string shaderCacheID;
-
-	/* LUT */
-	bool lut3d_texture_allocated;  /* boolean flag indicating whether
-	                                * lut texture is allocated
-	                                */
-	bool lut3d_texture_valid;
-
-	GLuint lut3d_texture;  /* OGL texture ID for 3D LUT */
-
-	float *lut3d;  /* 3D LUT table */
-
-	/* Dither */
-	bool use_dither;
-
-	/* Curve Mapping */
-	bool use_curve_mapping;
-	bool curve_mapping_texture_allocated;
-	bool curve_mapping_texture_valid;
-	GLuint curve_mapping_texture;
-	size_t curve_mapping_cache_id;
-
-	/* Alpha Predivide */
-	bool use_predivide;
-
-	/* GLSL stuff */
-	GLuint ocio_shader;
-	GLuint vert_shader;
-	GLuint program;
-	GPUShaderInterface *shader_interface;
+  /* Cache ID */
+  std::string lut3dCacheID;
+  std::string shaderCacheID;
+
+  /* LUT */
+  bool lut3d_texture_allocated; /* boolean flag indicating whether
+                                  * lut texture is allocated
+                                  */
+  bool lut3d_texture_valid;
+
+  GLuint lut3d_texture; /* OGL texture ID for 3D LUT */
+
+  float *lut3d; /* 3D LUT table */
+
+  /* Dither */
+  bool use_dither;
+
+  /* Curve Mapping */
+  bool use_curve_mapping;
+  bool curve_mapping_texture_allocated;
+  bool curve_mapping_texture_valid;
+  GLuint curve_mapping_texture;
+  size_t curve_mapping_cache_id;
+
+  /* Alpha Predivide */
+  bool use_predivide;
+
+  /* GLSL stuff */
+  GLuint ocio_shader;
+  GLuint vert_shader;
+  GLuint program;
+  GPUShaderInterface *shader_interface;
 } GLSLDrawState;
 
 typedef struct OCIO_GLSLDrawState {
-	/* Shader Cache */
-	OCIO_GLSLShader *shader_cache[SHADER_CACHE_SIZE];
+  /* Shader Cache */
+  OCIO_GLSLShader *shader_cache[SHADER_CACHE_SIZE];
 
-	/* Previous OpenGL state. */
-	GLint last_texture, last_texture_unit;
+  /* Previous OpenGL state. */
+  GLint last_texture, last_texture_unit;
 } OCIO_GLSLDrawState;
 
 static GLuint compileShaderText(GLenum shaderType, const char *text)
 {
-	GLuint shader;
-	GLint stat;
-
-	shader = glCreateShader(shaderType);
-	glShaderSource(shader, 1, (const GLchar **) &text, NULL);
-	glCompileShader(shader);
-	glGetShaderiv(shader, GL_COMPILE_STATUS, &stat);
-
-	if (!stat) {
-		GLchar log[1000];
-		GLsizei len;
-		glGetShaderInfoLog(shader, 1000, &len, log);
-		fprintf(stderr, "Shader compile error:\n%s\n", log);
-		return 0;
-	}
-
-	return shader;
+  GLuint shader;
+  GLint stat;
+
+  shader = glCreateShader(shaderType);
+  glShaderSource(shader, 1, (const GLchar **)&text, NULL);
+  glCompileShader(shader);
+  glGetShaderiv(shader, GL_COMPILE_STATUS, &stat);
+
+  if (!stat) {
+    GLchar log[1000];
+    GLsizei len;
+    glGetShaderInfoLog(shader, 1000, &len, log);
+    fprintf(stderr, "Shader compile error:\n%s\n", log);
+    return 0;
+  }
+
+  return shader;
 }
 
 static GLuint linkShaders(GLuint ocio_shader, GLuint vert_shader)
 {
-	if (!ocio_shader || !vert_shader)
-		return 0;
-
-	GLuint program = glCreateProgram();
-
-	glAttachShader(program, ocio_shader);
-	glAttachShader(program, vert_shader);
-
-	glLinkProgram(program);
-
-	/* check link */
-	{
-		GLint stat;
-		glGetProgramiv(program, GL_LINK_STATUS, &stat);
-		if (!stat) {
-			GLchar log[1000];
-			GLsizei len;
-			glGetProgramInfoLog(program, 1000, &len, log);
-			fprintf(stderr, "Shader link error:\n%s\n", log);
-			return 0;
-		}
-	}
-
-	return program;
+  if (!ocio_shader || !vert_shader)
+    return 0;
+
+  GLuint program = glCreateProgram();
+
+  glAttachShader(program, ocio_shader);
+  glAttachShader(program, vert_shader);
+
+  glLinkProgram(program);
+
+  /* check link */
+  {
+    GLint stat;
+    glGetProgramiv(program, GL_LINK_STATUS, &stat);
+    if (!stat) {
+      GLchar log[1000];
+      GLsizei len;
+      glGetProgramInfoLog(program, 1000, &len, log);
+      fprintf(stderr, "Shader link error:\n%s\n", log);
+      return 0;
+    }
+  }
+
+  return program;
 }
 
 static OCIO_GLSLDrawState *allocateOpenGLState(void)
 {
-	return (OCIO_GLSLDrawState *) MEM_callocN(sizeof(OCIO_GLSLDrawState),
-	                                          "OCIO OpenGL State struct");
+  return (OCIO_GLSLDrawState *)MEM_callocN(sizeof(OCIO_GLSLDrawState), "OCIO OpenGL State struct");
 }
 
 /* Ensure LUT texture and array are allocated */
 static bool ensureLUT3DAllocated(OCIO_GLSLShader *shader)
 {
-	int num_3d_entries = 3 * LUT3D_EDGE_SIZE * LUT3D_EDGE_SIZE * LUT3D_EDGE_SIZE;
-
-	if (shader->lut3d_texture_allocated)
-		return shader->lut3d_texture_valid;
-
-	glGenTextures(1, &shader->lut3d_texture);
-
-	shader->lut3d = (float *) MEM_callocN(sizeof(float) * num_3d_entries, "OCIO GPU 3D LUT");
-
-	glActiveTexture(GL_TEXTURE1);
-	glBindTexture(GL_TEXTURE_3D, shader->lut3d_texture);
-	glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-	glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-	glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-	glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-	glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
-
-	/* clean glError buffer */
-	while (glGetError() != GL_NO_ERROR) {}
-
-	glTexImage3D(GL_TEXTURE_3D, 0, GL_RGB16F_ARB,
-	             LUT3D_EDGE_SIZE, LUT3D_EDGE_SIZE, LUT3D_EDGE_SIZE,
-	             0, GL_RGB, GL_FLOAT, shader->lut3d);
-
-	shader->lut3d_texture_allocated = true;
-
-	/* GL_RGB16F_ARB could be not supported at some drivers
-	 * in this case we could not use GLSL display
-	 */
-	shader->lut3d_texture_valid = glGetError() == GL_NO_ERROR;
-
-	return shader->lut3d_texture_valid;
+  int num_3d_entries = 3 * LUT3D_EDGE_SIZE * LUT3D_EDGE_SIZE * LUT3D_EDGE_SIZE;
+
+  if (shader->lut3d_texture_allocated)
+    return shader->lut3d_texture_valid;
+
+  glGenTextures(1, &shader->lut3d_texture);
+
+  shader->lut3d = (float *)MEM_callocN(sizeof(float) * num_3d_entries, "OCIO GPU 3D LUT");
+
+  glActiveTexture(GL_TEXTURE1);
+  glBindTexture(GL_TEXTURE_3D, shader->lut3d_texture);
+  glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+  glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+  glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+  glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+  glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
+
+  /* clean glError buffer */
+  while (glGetError() != GL_NO_ERROR) {
+  }
+
+  glTexImage3D(GL_TEXTURE_3D,
+               0,
+               GL_RGB16F_ARB,
+               LUT3D_EDGE_SIZE,
+               LUT3D_EDGE_SIZE,
+               LUT3D_EDGE_SIZE,
+               0,
+               GL_RGB,
+               GL_FLOAT,
+               shader->lut3d);
+
+  shader->lut3d_texture_allocated = true;
+
+  /* GL_RGB16F_ARB could be not supported at some drivers
+   * in this case we could not use GLSL display
+   */
+  shader->lut3d_texture_valid = glGetError() == GL_NO_ERROR;
+
+  return shader->lut3d_texture_valid;
 }
 
-static bool ensureCurveMappingAllocated(OCIO_GLSLShader *shader, OCIO_CurveMappingSettings *curve_mapping_settings)
+static bool ensureCurveMappingAllocated(OCIO_GLSLShader *shader,
+                                        OCIO_CurveMappingSettings *curve_mapping_settings)
 {
-	if (shader->curve_mapping_texture_allocated)
-		return shader->curve_mapping_texture_valid;
-
-	glGenTextures(1, &shader->curve_mapping_texture);
-
-	glActiveTexture(GL_TEXTURE2);
-	glBindTexture(GL_TEXTURE_1D, shader->curve_mapping_texture);
-	glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-	glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-	glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-	glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-	glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
-
-	/* clean glError buffer */
-	while (glGetError() != GL_NO_ERROR) {}
-
-	glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA16F, curve_mapping_settings->lut_size,
-	             0, GL_RGBA, GL_FLOAT, curve_mapping_settings->lut);
-
-	shader->curve_mapping_texture_allocated = true;
-
-	/* GL_RGB16F_ARB could be not supported at some drivers
-	 * in this case we could not use GLSL display
-	 */
-	shader->curve_mapping_texture_valid = glGetError() == GL_NO_ERROR;
-
-	return shader->curve_mapping_texture_valid;
+  if (shader->curve_mapping_texture_allocated)
+    return shader->curve_mapping_texture_valid;
+
+  glGenTextures(1, &shader->curve_mapping_texture);
+
+  glActiveTexture(GL_TEXTURE2);
+  glBindTexture(GL_TEXTURE_1D, shader->curve_mapping_texture);
+  glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+  glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+  glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
+
+  /* clean glError buffer */
+  while (glGetError() != GL_NO_ERROR) {
+  }
+
+  glTexImage1D(GL_TEXTURE_1D,
+               0,
+               GL_RGBA16F,
+               curve_mapping_settings->lut_size,
+               0,
+               GL_RGBA,
+               GL_FLOAT,
+               curve_mapping_settings->lut);
+
+  shader->curve_mapping_texture_allocated = true;
+
+  /* GL_RGB16F_ARB could be not supported at some drivers
+   * in this case we could not use GLSL display
+   */
+  shader->curve_mapping_texture_valid = glGetError() == GL_NO_ERROR;
+
+  return shader->curve_mapping_texture_valid;
 }
 
 static void freeGLSLShader(OCIO_GLSLShader *shader)
 {
-	if (shader->curve_mapping_texture_allocated) {
-		glDeleteTextures(1, &shader->curve_mapping_texture);
-	}
+  if (shader->curve_mapping_texture_allocated) {
+    glDeleteTextures(1, &shader->curve_mapping_texture);
+  }
 
-	if (shader->lut3d_texture_allocated) {
-		glDeleteTextures(1, &shader->lut3d_texture);
-	}
+  if (shader->lut3d_texture_allocated) {
+    glDeleteTextures(1, &shader->lut3d_texture);
+  }
 
-	if (shader->lut3d) {
-		MEM_freeN(shader->lut3d);
-	}
+  if (shader->lut3d) {
+    MEM_freeN(shader->lut3d);
+  }
 
-	if (shader->program) {
-		glDeleteProgram(shader->program);
-	}
+  if (shader->program) {
+    glDeleteProgram(shader->program);
+  }
 
-	if (shader->shader_interface) {
-		GPU_shaderinterface_discard(shader->shader_interface);
-	}
+  if (shader->shader_interface) {
+    GPU_shaderinterface_discard(shader->shader_interface);
+  }
 
-	if (shader->ocio_shader) {
-		glDeleteShader(shader->ocio_shader);
-	}
+  if (shader->ocio_shader) {
+    glDeleteShader(shader->ocio_shader);
+  }
 
-	using std::string;
-	shader->lut3dCacheID.~string();
-	shader->shaderCacheID.~string();
+  using std::string;
+  shader->lut3dCacheID.~string();
+  shader->shaderCacheID.~string();
 
-	MEM_freeN(shader);
+  MEM_freeN(shader);
 }
 
-
-
 /* Detect if we can support GLSL drawing */
 bool OCIOImpl::supportGLSLDraw()
 {
-	/* uses GL_RGB16F_ARB */
-	return GLEW_VERSION_3_0 || GLEW_ARB_texture_float;
+  /* uses GL_RGB16F_ARB */
+  return GLEW_VERSION_3_0 || GLEW_ARB_texture_float;
 }
 
 /**
@@ -281,237 +294,251 @@ bool OCIOImpl::supportGLSLDraw()
  * When all drawing is finished, finishGLSLDraw shall be called to
  * restore OpenGL context to it's pre-GLSL draw state.
  */
-bool OCIOImpl::setupGLSLDraw(OCIO_GLSLDrawState **state_r, OCIO_ConstProcessorRcPtr *processor,
+bool OCIOImpl::setupGLSLDraw(OCIO_GLSLDrawState **state_r,
+                             OCIO_ConstProcessorRcPtr *processor,
                              OCIO_CurveMappingSettings *curve_mapping_settings,
-                             float dither, bool use_predivide)
+                             float dither,
+                             bool use_predivide)
 {
-	ConstProcessorRcPtr ocio_processor = *(ConstProcessorRcPtr *) processor;
-	bool use_curve_mapping = curve_mapping_settings != NULL;
-	bool use_dither = dither > std::numeric_limits<float>::epsilon();
-
-	/* Create state if needed. */
-	OCIO_GLSLDrawState *state;
-	if (!*state_r)
-		*state_r = allocateOpenGLState();
-	state = *state_r;
-
-	glGetIntegerv(GL_TEXTURE_BINDING_2D, &state->last_texture);
-	glGetIntegerv(GL_ACTIVE_TEXTURE, &state->last_texture_unit);
-
-	/* Compute cache IDs. */
-	GpuShaderDesc shaderDesc;
-	shaderDesc.setLanguage(GPU_LANGUAGE_GLSL_1_3);
-	shaderDesc.setFunctionName("OCIODisplay");
-	shaderDesc.setLut3DEdgeLen(LUT3D_EDGE_SIZE);
-
-	std::string lut3dCacheID = ocio_processor->getGpuLut3DCacheID(shaderDesc);
-	std::string shaderCacheID = ocio_processor->getGpuShaderTextCacheID(shaderDesc);
-
-	/* Find matching cached shader. */
-	OCIO_GLSLShader *shader = NULL;
-	for (int i = 0; i < SHADER_CACHE_SIZE; i++) {
-		OCIO_GLSLShader *cached_shader = state->shader_cache[i];
-		if (cached_shader == NULL) {
-			continue;
-		}
-
-		if (cached_shader->lut3dCacheID == lut3dCacheID &&
-		    cached_shader->shaderCacheID == shaderCacheID &&
-		    cached_shader->use_predivide == use_predivide &&
-		    cached_shader->use_curve_mapping == use_curve_mapping &&
-		    cached_shader->use_dither == use_dither)
-		{
-			/* LRU cache, so move to front. */
-			for (int j = i; j > 0; j--) {
-				state->shader_cache[j] = state->shader_cache[j - 1];
-			}
-			state->shader_cache[0] = cached_shader;
-
-			shader = cached_shader;
-			break;
-		}
-	}
-
-	if (shader == NULL) {
-		/* LRU cache, shift other items back so we can insert at the front. */
-		OCIO_GLSLShader *last_shader = state->shader_cache[SHADER_CACHE_SIZE - 1];
-		if (last_shader) {
-			freeGLSLShader(last_shader);
-		}
-		for (int j = SHADER_CACHE_SIZE - 1; j > 0; j--) {
-			state->shader_cache[j] = state->shader_cache[j - 1];
-		}
-
-		/* Allocate memory for shader. */
-		shader = (OCIO_GLSLShader *) MEM_callocN(sizeof(OCIO_GLSLShader),
-		                                         "OCIO GLSL Shader");
-		state->shader_cache[0] = shader;
-
-		new (&shader->lut3dCacheID) std::string();
-		new (&shader->shaderCacheID) std::string();
-
-        shader->lut3dCacheID = lut3dCacheID;
-        shader->shaderCacheID = shaderCacheID;
-		shader->use_curve_mapping = use_curve_mapping;
-		shader->use_dither = use_dither;
-		shader->use_predivide = use_predivide;
-
-		bool valid = true;
-
-		/* Compute 3D LUT. */
-		if (valid && ensureLUT3DAllocated(shader)) {
-		    ocio_processor->getGpuLut3D(shader->lut3d, shaderDesc);
-
-		    glActiveTexture(GL_TEXTURE1);
-		    glBindTexture(GL_TEXTURE_3D, shader->lut3d_texture);
-		    glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0,
-		                    LUT3D_EDGE_SIZE, LUT3D_EDGE_SIZE, LUT3D_EDGE_SIZE,
-		                    GL_RGB, GL_FLOAT, shader->lut3d);
-		}
-		else {
-			valid = false;
-		}
-
-		/* Allocate curve mapping texture. */
-		if (valid && use_curve_mapping) {
-			if (!ensureCurveMappingAllocated(shader, curve_mapping_settings)) {
-				valid = false;
-			}
-		}
-
-		if (valid) {
-			/* Vertex shader */
-			std::ostringstream osv;
-
-			osv << "#version 330\n";
-			osv << datatoc_gpu_shader_display_transform_vertex_glsl;
-
-			shader->vert_shader = compileShaderText(GL_VERTEX_SHADER, osv.str().c_str());
-
-			/* Fragment shader */
-			std::ostringstream os;
-
-			os << "#version 330\n";
-
-			/* Work around OpenColorIO not supporting latest GLSL yet. */
-			os << "#define texture2D texture\n";
-			os << "#define texture3D texture\n";
-
-			if (use_predivide) {
-				os << "#define USE_PREDIVIDE\n";
-			}
-
-			if (use_dither) {
-				os << "#define USE_DITHER\n";
-			}
-
-			if (use_curve_mapping) {
-				os << "#define USE_CURVE_MAPPING\n";
-			}
-
-			os << ocio_processor->getGpuShaderText(shaderDesc) << "\n";
-			os << datatoc_gpu_shader_display_transform_glsl;
-
-			shader->ocio_shader = compileShaderText(GL_FRAGMENT_SHADER, os.str().c_str());
-
-			/* Program */
-			if (shader->ocio_shader && shader->vert_shader) {
-				shader->program = linkShaders(shader->ocio_shader, shader->vert_shader);
-			}
-
-			if (shader->program) {
-				if (shader->shader_interface) {
-					GPU_shaderinterface_discard(shader->shader_interface);
-				}
-				shader->shader_interface = GPU_shaderinterface_create(shader->program);
-			}
-		}
-	}
-
-	/* Update curve mapping texture. */
-	if (use_curve_mapping && shader->curve_mapping_texture_allocated) {
-		if (shader->curve_mapping_cache_id != curve_mapping_settings->cache_id) {
-			glActiveTexture(GL_TEXTURE2);
-			glBindTexture(GL_TEXTURE_1D, shader->curve_mapping_texture);
-			glTexSubImage1D(GL_TEXTURE_1D, 0, 0, curve_mapping_settings->lut_size,
-			                GL_RGBA, GL_FLOAT, curve_mapping_settings->lut);
-		}
-	}
-
-	/* Bind Shader. */
-	if (shader->program) {
-		glActiveTexture(GL_TEXTURE1);
-		glBindTexture(GL_TEXTURE_3D, shader->lut3d_texture);
-
-		if (use_curve_mapping) {
-			glActiveTexture(GL_TEXTURE2);
-			glBindTexture(GL_TEXTURE_1D, shader->curve_mapping_texture);
-		}
-
-		glActiveTexture(GL_TEXTURE0);
-
-		/* IMM needs vertex format even if we don't draw with it.
-		 *
-		 * NOTE: The only reason why it's here is because of Cycles viewport.
-		 * All other areas are managing their own vertex formats.
-		 * Doing it here is probably harmless, but kind of stupid.
-		 *
-		 * TODO(sergey): Look into some nicer solution.
-		 */
-		GPUVertFormat *format = immVertexFormat();
-		GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
-		GPU_vertformat_attr_add(format, "texCoord", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
-		immBindProgram(shader->program, shader->shader_interface);
-
-		immUniform1i("image_texture", 0);
-		immUniform1i("lut3d_texture", 1);
-
-		if (use_dither) {
-			immUniform1f("dither", dither);
-		}
-
-		if (use_curve_mapping) {
-			immUniform1i("curve_mapping_texture", 2);
-			immUniform1i("curve_mapping_lut_size", curve_mapping_settings->lut_size);
-			immUniform4iv("use_curve_mapping_extend_extrapolate", curve_mapping_settings->use_extend_extrapolate);
-			immUniform4fv("curve_mapping_mintable", curve_mapping_settings->mintable);
-			immUniform4fv("curve_mapping_range", curve_mapping_settings->range);
-			immUniform4fv("curve_mapping_ext_in_x", curve_mapping_settings->ext_in_x);
-			immUniform4fv("curve_mapping_ext_in_y", curve_mapping_settings->ext_in_y);
-			immUniform4fv("curve_mapping_ext_out_x", curve_mapping_settings->ext_out_x);
-			immUniform4fv("curve_mapping_ext_out_y", curve_mapping_settings->ext_out_y);
-			immUniform4fv("curve_mapping_first_x", curve_mapping_settings->first_x);
-			immUniform4fv("curve_mapping_first_y", curve_mapping_settings->first_y);
-			immUniform4fv("curve_mapping_last_x", curve_mapping_settings->last_x);
-			immUniform4fv("curve_mapping_last_y", curve_mapping_settings->last_y);
-			immUniform3fv("curve_mapping_black", curve_mapping_settings->black);
-			immUniform3fv("curve_mapping_bwmul", curve_mapping_settings->bwmul);
-		}
-
-		return true;
-	}
-	else {
-		glActiveTexture(state->last_texture_unit);
-		glBindTexture(GL_TEXTURE_2D, state->last_texture);
-
-		return false;
-	}
+  ConstProcessorRcPtr ocio_processor = *(ConstProcessorRcPtr *)processor;
+  bool use_curve_mapping = curve_mapping_settings != NULL;
+  bool use_dither = dither > std::numeric_limits<float>::epsilon();
+
+  /* Create state if needed. */
+  OCIO_GLSLDrawState *state;
+  if (!*state_r)
+    *state_r = allocateOpenGLState();
+  state = *state_r;
+
+  glGetIntegerv(GL_TEXTURE_BINDING_2D, &state->last_texture);
+  glGetIntegerv(GL_ACTIVE_TEXTURE, &state->last_texture_unit);
+
+  /* Compute cache IDs. */
+  GpuShaderDesc shaderDesc;
+  shaderDesc.setLanguage(GPU_LANGUAGE_GLSL_1_3);
+  shaderDesc.setFunctionName("OCIODisplay");
+  shaderDesc.setLut3DEdgeLen(LUT3D_EDGE_SIZE);
+
+  std::string lut3dCacheID = ocio_processor->getGpuLut3DCacheID(shaderDesc);
+  std::string shaderCacheID = ocio_processor->getGpuShaderTextCacheID(shaderDesc);
+
+  /* Find matching cached shader. */
+  OCIO_GLSLShader *shader = NULL;
+  for (int i = 0; i < SHADER_CACHE_SIZE; i++) {
+    OCIO_GLSLShader *cached_shader = state->shader_cache[i];
+    if (cached_shader == NULL) {
+      continue;
+    }
+
+    if (cached_shader->lut3dCacheID == lut3dCacheID &&
+        cached_shader->shaderCacheID == shaderCacheID &&
+        cached_shader->use_predivide == use_predivide &&
+        cached_shader->use_curve_mapping == use_curve_mapping &&
+        cached_shader->use_dither == use_dither) {
+      /* LRU cache, so move to front. */
+      for (int j = i; j > 0; j--) {
+        state->shader_cache[j] = state->shader_cache[j - 1];
+      }
+      state->shader_cache[0] = cached_shader;
+
+      shader = cached_shader;
+      break;
+    }
+  }
+
+  if (shader == NULL) {
+    /* LRU cache, shift other items back so we can insert at the front. */
+    OCIO_GLSLShader *last_shader = state->shader_cache[SHADER_CACHE_SIZE - 1];
+    if (last_shader) {
+      freeGLSLShader(last_shader);
+    }
+    for (int j = SHADER_CACHE_SIZE - 1; j > 0; j--) {
+      state->shader_cache[j] = state->shader_cache[j - 1];
+    }
+
+    /* Allocate memory for shader. */
+    shader = (OCIO_GLSLShader *)MEM_callocN(sizeof(OCIO_GLSLShader), "OCIO GLSL Shader");
+    state->shader_cache[0] = shader;
+
+    new (&shader->lut3dCacheID) std::string();
+    new (&shader->shaderCacheID) std::string();
+
+    shader->lut3dCacheID = lut3dCacheID;
+    shader->shaderCacheID = shaderCacheID;
+    shader->use_curve_mapping = use_curve_mapping;
+    shader->use_dither = use_dither;
+    shader->use_predivide = use_predivide;
+
+    bool valid = true;
+
+    /* Compute 3D LUT. */
+    if (valid && ensureLUT3DAllocated(shader)) {
+      ocio_processor->getGpuLut3D(shader->lut3d, shaderDesc);
+
+      glActiveTexture(GL_TEXTURE1);
+      glBindTexture(GL_TEXTURE_3D, shader->lut3d_texture);
+      glTexSubImage3D(GL_TEXTURE_3D,
+                      0,
+                      0,
+                      0,
+                      0,
+                      LUT3D_EDGE_SIZE,
+                      LUT3D_EDGE_SIZE,
+                      LUT3D_EDGE_SIZE,
+                      GL_RGB,
+                      GL_FLOAT,
+                      shader->lut3d);
+    }
+    else {
+      valid = false;
+    }
+
+    /* Allocate curve mapping texture. */
+    if (valid && use_curve_mapping) {
+      if (!ensureCurveMappingAllocated(shader, curve_mapping_settings)) {
+        valid = false;
+      }
+    }
+
+    if (valid) {
+      /* Vertex shader */
+      std::ostringstream osv;
+
+      osv << "#version 330\n";
+      osv << datatoc_gpu_shader_display_transform_vertex_glsl;
+
+      shader->vert_shader = compileShaderText(GL_VERTEX_SHADER, osv.str().c_str());
+
+      /* Fragment shader */
+      std::ostringstream os;
+
+      os << "#version 330\n";
+
+      /* Work around OpenColorIO not supporting latest GLSL yet. */
+      os << "#define texture2D texture\n";
+      os << "#define texture3D texture\n";
+
+      if (use_predivide) {
+        os << "#define USE_PREDIVIDE\n";
+      }
+
+      if (use_dither) {
+        os << "#define USE_DITHER\n";
+      }
+
+      if (use_curve_mapping) {
+        os << "#define USE_CURVE_MAPPING\n";
+      }
+
+      os << ocio_processor->getGpuShaderText(shaderDesc) << "\n";
+      os << datatoc_gpu_shader_display_transform_glsl;
+
+      shader->ocio_shader = compileShaderText(GL_FRAGMENT_SHADER, os.str().c_str());
+
+      /* Program */
+      if (shader->ocio_shader && shader->vert_shader) {
+        shader->program = linkShaders(shader->ocio_shader, shader->vert_shader);
+      }
+
+      if (shader->program) {
+        if (shader->shader_interface) {
+          GPU_shaderinterface_discard(shader->shader_interface);
+        }
+        shader->shader_interface = GPU_shaderinterface_create(shader->program);
+      }
+    }
+  }
+
+  /* Update curve mapping texture. */
+  if (use_curve_mapping && shader->curve_mapping_texture_allocated) {
+    if (shader->curve_mapping_cache_id != curve_mapping_settings->cache_id) {
+      glActiveTexture(GL_TEXTURE2);
+      glBindTexture(GL_TEXTURE_1D, shader->curve_mapping_texture);
+      glTexSubImage1D(GL_TEXTURE_1D,
+                      0,
+                      0,
+                      curve_mapping_settings->lut_size,
+                      GL_RGBA,
+                      GL_FLOAT,
+                      curve_mapping_settings->lut);
+    }
+  }
+
+  /* Bind Shader. */
+  if (shader->program) {
+    glActiveTexture(GL_TEXTURE1);
+    glBindTexture(GL_TEXTURE_3D, shader->lut3d_texture);
+
+    if (use_curve_mapping) {
+      glActiveTexture(GL_TEXTURE2);
+      glBindTexture(GL_TEXTURE_1D, shader->curve_mapping_texture);
+    }
+
+    glActiveTexture(GL_TEXTURE0);
+
+    /* IMM needs vertex format even if we don't draw with it.
+     *
+     * NOTE: The only reason why it's here is because of Cycles viewport.
+     * All other areas are managing their own vertex formats.
+     * Doing it here is probably harmless, but kind of stupid.
+     *
+     * TODO(sergey): Look into some nicer solution.
+     */
+    GPUVertFormat *format = immVertexFormat();
+    GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
+    GPU_vertformat_attr_add(format, "texCoord", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
+    immBindProgram(shader->program, shader->shader_interface);
+
+    immUniform1i("image_texture", 0);
+    immUniform1i("lut3d_texture", 1);
+
+    if (use_dither) {
+      immUniform1f("dither", dither);
+    }
+
+    if (use_curve_mapping) {
+      immUniform1i("curve_mapping_texture", 2);
+      immUniform1i("curve_mapping_lut_size", curve_mapping_settings->lut_size);
+      immUniform4iv("use_curve_mapping_extend_extrapolate",
+                    curve_mapping_settings->use_extend_extrapolate);
+      immUniform4fv("curve_mapping_mintable", curve_mapping_settings->mintable);
+      immUniform4fv("curve_mapping_range", curve_mapping_settings->range);
+      immUniform4fv("curve_mapping_ext_in_x", curve_mapping_settings->ext_in_x);
+      immUniform4fv("curve_mapping_ext_in_y", curve_mapping_settings->ext_in_y);
+      immUniform4fv("curve_mapping_ext_out_x", curve_mapping_settings->ext_out_x);
+      immUniform4fv("curve_mapping_ext_out_y", curve_mapping_settings->ext_out_y);
+      immUniform4fv("curve_mapping_first_x", curve_mapping_settings->first_x);
+      immUniform4fv("curve_mapping_first_y", curve_mapping_settings->first_y);
+      immUniform4fv("curve_mapping_last_x", curve_mapping_settings->last_x);
+      immUniform4fv("curve_mapping_last_y", curve_mapping_settings->last_y);
+      immUniform3fv("curve_mapping_black", curve_mapping_settings->black);
+      immUniform3fv("curve_mapping_bwmul", curve_mapping_settings->bwmul);
+    }
+
+    return true;
+  }
+  else {
+    glActiveTexture(state->last_texture_unit);
+    glBindTexture(GL_TEXTURE_2D, state->last_texture);
+
+    return false;
+  }
 }
 
 void OCIOImpl::finishGLSLDraw(OCIO_GLSLDrawState *state)
 {
-	glActiveTexture(state->last_texture_unit);
-	glBindTexture(GL_TEXTURE_2D, state->last_texture);
-	immUnbindProgram();
+  glActiveTexture(state->last_texture_unit);
+  glBindTexture(GL_TEXTURE_2D, state->last_texture);
+  immUnbindProgram();
 }
 
 void OCIOImpl::freeGLState(OCIO_GLSLDrawState *state)
 {
-	for (int i = 0; i < SHADER_CACHE_SIZE; i++) {
-		if (state->shader_cache[i]) {
-			freeGLSLShader(state->shader_cache[i]);
-		}
-	}
+  for (int i = 0; i < SHADER_CACHE_SIZE; i++) {
+    if (state->shader_cache[i]) {
+      freeGLSLShader(state->shader_cache[i]);
+    }
+  }
 
-	MEM_freeN(state);
+  MEM_freeN(state);
 }