Code cleanup: use boolean instead of int for colormanagement

4 files changed, 89 insertions, 86 deletions

diff --git a/source/blender/imbuf/IMB_colormanagement.h b/source/blender/imbuf/IMB_colormanagement.h
index e2def417b95..1f1fdedfa40 100644
--- a/source/blender/imbuf/IMB_colormanagement.h
+++ b/source/blender/imbuf/IMB_colormanagement.h
@@ -31,6 +31,8 @@
 #ifndef __IMB_COLORMANAGEMENT_H__
 #define __IMB_COLORMANAGEMENT_H__
 
+#include "BLI_sys_types.h"
+
 #define BCM_CONFIG_FILE "config.ocio"
 
 struct bContext;
@@ -67,17 +69,17 @@ const char *IMB_colormanagement_get_rect_colorspace(struct ImBuf *ibuf);
 
 /* ** Color space transformation functions ** */
 void IMB_colormanagement_transform(float *buffer, int width, int height, int channels,
-                                   const char *from_colorspace, const char *to_colorspace, int predivide);
+                                   const char *from_colorspace, const char *to_colorspace, bool predivide);
 void IMB_colormanagement_transform_threaded(float *buffer, int width, int height, int channels,
-                                            const char *from_colorspace, const char *to_colorspace, int predivide);
+                                            const char *from_colorspace, const char *to_colorspace, bool predivide);
 void IMB_colormanagement_transform_v4(float pixel[4], const char *from_colorspace, const char *to_colorspace);
 
 void IMB_colormanagement_colorspace_to_scene_linear_v3(float pixel[3], struct ColorSpace *colorspace);
-void IMB_colormanagement_colorspace_to_scene_linear_v4(float pixel[4], int predivide, struct ColorSpace *colorspace);
+void IMB_colormanagement_colorspace_to_scene_linear_v4(float pixel[4], bool predivide, struct ColorSpace *colorspace);
 
 void IMB_colormanagement_scene_linear_to_colorspace_v3(float pixel[3], struct ColorSpace *colorspace);
 
-void IMB_colormanagement_colorspace_to_scene_linear(float *buffer, int width, int height, int channels, struct ColorSpace *colorspace, int predivide);
+void IMB_colormanagement_colorspace_to_scene_linear(float *buffer, int width, int height, int channels, struct ColorSpace *colorspace, bool predivide);
 
 void IMB_colormanagement_scene_linear_to_display_v3(float pixel[3], struct ColorManagedDisplay *display);
 void IMB_colormanagement_display_to_scene_linear_v3(float pixel[3], struct ColorManagedDisplay *display);
@@ -91,7 +93,7 @@ void IMB_colormanagement_pixel_to_display_space_v3(float result[3], const float
 void IMB_colormanagement_imbuf_make_display_space(struct ImBuf *ibuf, const struct ColorManagedViewSettings *view_settings,
                                                   const struct ColorManagedDisplaySettings *display_settings);
 
-struct ImBuf *IMB_colormanagement_imbuf_for_write(struct ImBuf *ibuf, int save_as_render, int allocate_result,
+struct ImBuf *IMB_colormanagement_imbuf_for_write(struct ImBuf *ibuf, bool save_as_render, bool allocate_result,
                                                   const struct ColorManagedViewSettings *view_settings,
                                                   const struct ColorManagedDisplaySettings *display_settings,
                                                   struct ImageFormatData *image_format_data);
@@ -113,7 +115,7 @@ unsigned char *IMB_display_buffer_acquire_ctx(const struct bContext *C, struct I
 
 void IMB_display_buffer_transform_apply(unsigned char *display_buffer, float *linear_buffer, int width, int height,
                                         int channels, const struct ColorManagedViewSettings *view_settings,
-                                        const struct ColorManagedDisplaySettings *display_settings, int predivide);
+                                        const struct ColorManagedDisplaySettings *display_settings, bool predivide);
 
 void IMB_display_buffer_release(void *cache_handle);
 
@@ -145,7 +147,7 @@ void IMB_partial_display_buffer_update(struct ImBuf *ibuf, const float *linear_b
                                        int stride, int offset_x, int offset_y, const struct ColorManagedViewSettings *view_settings,
                                        const struct ColorManagedDisplaySettings *display_settings,
                                        int xmin, int ymin, int xmax, int ymax,
-                                       int update_orig_byte_buffer);
+                                       bool update_orig_byte_buffer);
 
 void IMB_partial_display_buffer_update_delayed(struct ImBuf *ibuf, int xmin, int ymin, int xmax, int ymax);
 
@@ -157,34 +159,34 @@ void IMB_colormanagement_processor_apply_v4(struct ColormanageProcessor *cm_proc
 void IMB_colormanagement_processor_apply_v4_predivide(struct ColormanageProcessor *cm_processor, float pixel[4]);
 void IMB_colormanagement_processor_apply_v3(struct ColormanageProcessor *cm_processor, float pixel[3]);
 void IMB_colormanagement_processor_apply(struct ColormanageProcessor *cm_processor, float *buffer, int width, int height,
-                                         int channels, int predivide);
+                                         int channels, bool predivide);
 void IMB_colormanagement_processor_free(struct ColormanageProcessor *cm_processor);
 
 /* ** OpenGL drawing routines using GLSL for color space transform ** */
 
 /* Test if GLSL drawing is supported for combination of graphics card and this configuration */
-int IMB_colormanagement_support_glsl_draw(const struct ColorManagedViewSettings *view_settings,
-                                          int skip_curves);
+bool IMB_colormanagement_support_glsl_draw(const struct ColorManagedViewSettings *view_settings,
+                                           bool skip_curves);
 /* Configures GLSL shader for conversion from scene linear to display space */
-int IMB_colormanagement_setup_glsl_draw(const struct ColorManagedViewSettings *view_settings,
-                                        const struct ColorManagedDisplaySettings *display_settings,
-                                        int predivide,
-                                        int skip_curves);
+bool IMB_colormanagement_setup_glsl_draw(const struct ColorManagedViewSettings *view_settings,
+                                         const struct ColorManagedDisplaySettings *display_settings,
+                                         bool predivide,
+                                         bool skip_curves);
 /* Same as above, but display space conversion happens from a specified space */
-int IMB_colormanagement_setup_glsl_draw_from_space(const struct ColorManagedViewSettings *view_settings,
-                                                   const struct ColorManagedDisplaySettings *display_settings,
-                                                   struct ColorSpace *colorspace,
-                                                   int predivide,
-                                                   int skip_curves);
+bool IMB_colormanagement_setup_glsl_draw_from_space(const struct ColorManagedViewSettings *view_settings,
+                                                    const struct ColorManagedDisplaySettings *display_settings,
+                                                    struct ColorSpace *colorspace,
+                                                    bool predivide,
+                                                    bool skip_curves);
 /* Same as setup_glsl_draw, but color management settings are guessing from a given context */
-int IMB_colormanagement_setup_glsl_draw_ctx(const struct bContext *C, int predivide);
+bool IMB_colormanagement_setup_glsl_draw_ctx(const struct bContext *C, bool predivide);
 /* Same as setup_glsl_draw_from_space, but color management settings are guessing from a given context */
-int IMB_colormanagement_setup_glsl_draw_from_space_ctx(const struct bContext *C, struct ColorSpace *colorspace, int predivide);
+bool IMB_colormanagement_setup_glsl_draw_from_space_ctx(const struct bContext *C, struct ColorSpace *colorspace, bool predivide);
 /* Finish GLSL-based display space conversion */
 void IMB_colormanagement_finish_glsl_draw(void);
 
 /* Configures GLSL shader for conversion from space defined by role to scene linear space */
-int IMB_colormanagement_setup_transform_from_role_glsl(int role, int predivide);
+bool IMB_colormanagement_setup_transform_from_role_glsl(int role, bool predivide);
 /* Finish GLSL-based color space conversion */
 void IMB_colormanagement_finish_glsl_transform(void);
 
diff --git a/source/blender/imbuf/intern/IMB_colormanagement_intern.h b/source/blender/imbuf/intern/IMB_colormanagement_intern.h
index db9345d2e1e..3e201a2fc28 100644
--- a/source/blender/imbuf/intern/IMB_colormanagement_intern.h
+++ b/source/blender/imbuf/intern/IMB_colormanagement_intern.h
@@ -32,6 +32,7 @@
 #define __IMB_COLORMANAGEMENT_INTERN_H__
 
 #include "DNA_listBase.h"
+#include "BLI_sys_types.h"
 
 struct OCIO_ConstProcessorRcPtr;
 struct ImBuf;
@@ -48,8 +49,8 @@ typedef struct ColorSpace {
 	struct OCIO_ConstProcessorRcPtr *to_scene_linear;
 	struct OCIO_ConstProcessorRcPtr *from_scene_linear;
 
-	int is_invertible;
-	int is_data;
+	bool is_invertible;
+	bool is_data;
 } ColorSpace;
 
 typedef struct ColorManagedDisplay {
@@ -87,7 +88,7 @@ struct ColorManagedView *colormanage_view_add(const char *name);
 struct ColorManagedView *colormanage_view_get_indexed(int index);
 struct ColorManagedView *colormanage_view_get_named(const char *name);
 
-struct ColorSpace *colormanage_colorspace_add(const char *name, const char *description, int is_invertible, int is_data);
+struct ColorSpace *colormanage_colorspace_add(const char *name, const char *description, bool is_invertible, bool is_data);
 struct ColorSpace *colormanage_colorspace_get_named(const char *name);
 struct ColorSpace *colormanage_colorspace_get_roled(int role);
 struct ColorSpace *colormanage_colorspace_get_indexed(int index);
diff --git a/source/blender/imbuf/intern/colormanagement.c b/source/blender/imbuf/intern/colormanagement.c
index 7c3a19a1ff1..a466074d06f 100644
--- a/source/blender/imbuf/intern/colormanagement.c
+++ b/source/blender/imbuf/intern/colormanagement.c
@@ -99,7 +99,7 @@ static pthread_mutex_t processor_lock = BLI_MUTEX_INITIALIZER;
 typedef struct ColormanageProcessor {
 	OCIO_ConstProcessorRcPtr *processor;
 	CurveMapping *curve_mapping;
-	int is_data_result;
+	bool is_data_result;
 } ColormanageProcessor;
 
 static struct global_glsl_state {
@@ -470,7 +470,7 @@ static void colormanage_load_config(OCIO_ConstConfigRcPtr *config)
 	for (index = 0 ; index < tot_colorspace; index++) {
 		OCIO_ConstColorSpaceRcPtr *ocio_colorspace;
 		const char *description;
-		int is_invertible, is_data;
+		bool is_invertible, is_data;
 
 		name = OCIO_configGetColorSpaceNameByIndex(config, index);
 
@@ -923,7 +923,7 @@ void colormanage_imbuf_make_linear(ImBuf *ibuf, const char *from_colorspace)
 			imb_freerectImBuf(ibuf);
 
 		IMB_colormanagement_transform(ibuf->rect_float, ibuf->x, ibuf->y, ibuf->channels,
-		                              from_colorspace, to_colorspace, TRUE);
+		                              from_colorspace, to_colorspace, true);
 	}
 }
 
@@ -1166,7 +1166,7 @@ typedef struct DisplayBufferThread {
 
 	int channels;
 	float dither;
-	int is_data;
+	bool is_data;
 
 	const char *byte_colorspace;
 	const char *float_colorspace;
@@ -1195,7 +1195,7 @@ static void display_buffer_init_handle(void *handle_v, int start_line, int tot_l
 
 	int channels = ibuf->channels;
 	float dither = ibuf->dither;
-	int is_data = ibuf->colormanage_flag & IMB_COLORMANAGE_IS_DATA;
+	bool is_data = (ibuf->colormanage_flag & IMB_COLORMANAGE_IS_DATA) != 0;
 
 	int offset = channels * start_line * ibuf->x;
 	int display_buffer_byte_offset = DISPLAY_BUFFER_CHANNELS * start_line * ibuf->x;
@@ -1239,8 +1239,8 @@ static float *display_buffer_apply_get_linear_buffer(DisplayBufferThread *handle
 
 	int buffer_size = channels * width * height;
 
-	int is_data = handle->is_data;
-	int is_data_display = handle->cm_processor->is_data_result;
+	bool is_data = handle->is_data;
+	bool is_data_display = handle->cm_processor->is_data_result;
 
 	linear_buffer = MEM_callocN(buffer_size * sizeof(float), "color conversion linear buffer");
 
@@ -1273,7 +1273,7 @@ static float *display_buffer_apply_get_linear_buffer(DisplayBufferThread *handle
 		if (!is_data && !is_data_display) {
 			/* convert float buffer to scene linear space */
 			IMB_colormanagement_transform(linear_buffer, width, height, channels,
-			                              from_colorspace, to_colorspace, FALSE);
+			                              from_colorspace, to_colorspace, false);
 		}
 
 		*is_straight_alpha = true;
@@ -1292,7 +1292,7 @@ static float *display_buffer_apply_get_linear_buffer(DisplayBufferThread *handle
 
 		if (!is_data && !is_data_display) {
 			IMB_colormanagement_transform(linear_buffer, width, height, channels,
-			                              from_colorspace, to_colorspace, TRUE);
+			                              from_colorspace, to_colorspace, true);
 		}
 
 		*is_straight_alpha = false;
@@ -1325,7 +1325,7 @@ static void *do_display_buffer_apply_thread(void *handle_v)
 	int width = handle->width;
 	int height = handle->tot_line;
 	float dither = handle->dither;
-	int is_data = handle->is_data;
+	bool is_data = handle->is_data;
 
 	if (cm_processor == NULL) {
 		if (display_buffer_byte) {
@@ -1418,8 +1418,8 @@ static void display_buffer_apply_threaded(ImBuf *ibuf, float *buffer, unsigned c
 	                             display_buffer_init_handle, do_display_buffer_apply_thread);
 }
 
-static int is_ibuf_rect_in_display_space(ImBuf *ibuf, const ColorManagedViewSettings *view_settings,
-                                         const ColorManagedDisplaySettings *display_settings)
+static bool is_ibuf_rect_in_display_space(ImBuf *ibuf, const ColorManagedViewSettings *view_settings,
+                                          const ColorManagedDisplaySettings *display_settings)
 {
 	if ((view_settings->flag & COLORMANAGE_VIEW_USE_CURVES) == 0 &&
 	    view_settings->exposure == 0.0f &&
@@ -1429,10 +1429,10 @@ static int is_ibuf_rect_in_display_space(ImBuf *ibuf, const ColorManagedViewSett
 		const char *to_colorspace = display_transform_get_colorspace_name(view_settings, display_settings);
 
 		if (to_colorspace && !strcmp(from_colorspace, to_colorspace))
-			return TRUE;
+			return true;
 	}
 
-	return FALSE;
+	return false;
 }
 
 static void colormanage_display_buffer_process_ex(ImBuf *ibuf, float *display_buffer, unsigned char *display_buffer_byte,
@@ -1440,7 +1440,7 @@ static void colormanage_display_buffer_process_ex(ImBuf *ibuf, float *display_bu
                                                   const ColorManagedDisplaySettings *display_settings)
 {
 	ColormanageProcessor *cm_processor = NULL;
-	int skip_transform = FALSE;
+	bool skip_transform = false;
 
 	/* if we're going to transform byte buffer, check whether transformation would
 	 * happen to the same color space as byte buffer itself is
@@ -1451,7 +1451,7 @@ static void colormanage_display_buffer_process_ex(ImBuf *ibuf, float *display_bu
 		skip_transform = is_ibuf_rect_in_display_space(ibuf, view_settings, display_settings);
 	}
 
-	if (skip_transform == FALSE)
+	if (skip_transform == false)
 		cm_processor = IMB_colormanagement_display_processor_new(view_settings, display_settings);
 
 	display_buffer_apply_threaded(ibuf, ibuf->rect_float, (unsigned char *) ibuf->rect,
@@ -1477,7 +1477,7 @@ typedef struct ProcessorTransformThread {
 	int start_line;
 	int tot_line;
 	int channels;
-	int predivide;
+	bool predivide;
 } ProcessorTransformThread;
 
 typedef struct ProcessorTransformInit {
@@ -1486,7 +1486,7 @@ typedef struct ProcessorTransformInit {
 	int width;
 	int height;
 	int channels;
-	int predivide;
+	bool predivide;
 } ProcessorTransformInitData;
 
 static void processor_transform_init_handle(void *handle_v, int start_line, int tot_line, void *init_data_v)
@@ -1496,7 +1496,7 @@ static void processor_transform_init_handle(void *handle_v, int start_line, int
 
 	int channels = init_data->channels;
 	int width = init_data->width;
-	int predivide = init_data->predivide;
+	bool predivide = init_data->predivide;
 
 	int offset = channels * start_line * width;
 
@@ -1522,7 +1522,7 @@ static void *do_processor_transform_thread(void *handle_v)
 	int channels = handle->channels;
 	int width = handle->width;
 	int height = handle->tot_line;
-	int predivide = handle->predivide;
+	bool predivide = handle->predivide;
 
 	IMB_colormanagement_processor_apply(handle->cm_processor, buffer, width, height, channels, predivide);
 
@@ -1530,7 +1530,7 @@ static void *do_processor_transform_thread(void *handle_v)
 }
 
 static void processor_transform_apply_threaded(float *buffer, int width, int height, int channels,
-                                               ColormanageProcessor *cm_processor, int predivide)
+                                               ColormanageProcessor *cm_processor, bool predivide)
 {
 	ProcessorTransformInitData init_data;
 
@@ -1549,7 +1549,7 @@ static void processor_transform_apply_threaded(float *buffer, int width, int hei
 
 /* convert the whole buffer from specified by name color space to another - internal implementation */
 static void colormanagement_transform_ex(float *buffer, int width, int height, int channels, const char *from_colorspace,
-                                         const char *to_colorspace, int predivide, int do_threaded)
+                                         const char *to_colorspace, bool predivide, bool do_threaded)
 {
 	ColormanageProcessor *cm_processor;
 
@@ -1576,18 +1576,18 @@ static void colormanagement_transform_ex(float *buffer, int width, int height, i
 
 /* convert the whole buffer from specified by name color space to another */
 void IMB_colormanagement_transform(float *buffer, int width, int height, int channels,
-                                   const char *from_colorspace, const char *to_colorspace, int predivide)
+                                   const char *from_colorspace, const char *to_colorspace, bool predivide)
 {
-	colormanagement_transform_ex(buffer, width, height, channels, from_colorspace, to_colorspace, predivide, FALSE);
+	colormanagement_transform_ex(buffer, width, height, channels, from_colorspace, to_colorspace, predivide, false);
 }
 
 /* convert the whole buffer from specified by name color space to another
  * will do threaded conversion
  */
 void IMB_colormanagement_transform_threaded(float *buffer, int width, int height, int channels,
-                                            const char *from_colorspace, const char *to_colorspace, int predivide)
+                                            const char *from_colorspace, const char *to_colorspace, bool predivide)
 {
-	colormanagement_transform_ex(buffer, width, height, channels, from_colorspace, to_colorspace, predivide, TRUE);
+	colormanagement_transform_ex(buffer, width, height, channels, from_colorspace, to_colorspace, predivide, true);
 }
 
 void IMB_colormanagement_transform_v4(float pixel[4], const char *from_colorspace, const char *to_colorspace)
@@ -1648,7 +1648,7 @@ void IMB_colormanagement_scene_linear_to_colorspace_v3(float pixel[3], ColorSpac
 		OCIO_processorApplyRGB(processor, pixel);
 }
 
-void IMB_colormanagement_colorspace_to_scene_linear_v4(float pixel[4], int predivide, ColorSpace *colorspace)
+void IMB_colormanagement_colorspace_to_scene_linear_v4(float pixel[4], bool predivide, ColorSpace *colorspace)
 {
 	OCIO_ConstProcessorRcPtr *processor;
 
@@ -1668,7 +1668,7 @@ void IMB_colormanagement_colorspace_to_scene_linear_v4(float pixel[4], int predi
 	}
 }
 
-void IMB_colormanagement_colorspace_to_scene_linear(float *buffer, int width, int height, int channels, struct ColorSpace *colorspace, int predivide)
+void IMB_colormanagement_colorspace_to_scene_linear(float *buffer, int width, int height, int channels, struct ColorSpace *colorspace, bool predivide)
 {
 	OCIO_ConstProcessorRcPtr *processor;
 
@@ -1747,7 +1747,7 @@ void IMB_colormanagement_pixel_to_display_space_v3(float result[3], const float
 }
 
 static void colormanagement_imbuf_make_display_space(ImBuf *ibuf, const ColorManagedViewSettings *view_settings,
-                                                     const ColorManagedDisplaySettings *display_settings, int make_byte)
+                                                     const ColorManagedDisplaySettings *display_settings, bool make_byte)
 {
 	if (!ibuf->rect && make_byte)
 		imb_addrectImBuf(ibuf);
@@ -1765,7 +1765,7 @@ static void colormanagement_imbuf_make_display_space(ImBuf *ibuf, const ColorMan
 void IMB_colormanagement_imbuf_make_display_space(ImBuf *ibuf, const ColorManagedViewSettings *view_settings,
                                                   const ColorManagedDisplaySettings *display_settings)
 {
-	colormanagement_imbuf_make_display_space(ibuf, view_settings, display_settings, FALSE);
+	colormanagement_imbuf_make_display_space(ibuf, view_settings, display_settings, false);
 }
 
 /* prepare image buffer to be saved on disk, applying color management if needed
@@ -1779,14 +1779,14 @@ void IMB_colormanagement_imbuf_make_display_space(ImBuf *ibuf, const ColorManage
  * in image format write callback and if float_colorspace is not NULL, no color
  * space transformation should be applied on this buffer.
  */
-ImBuf *IMB_colormanagement_imbuf_for_write(ImBuf *ibuf, int save_as_render, int allocate_result, const ColorManagedViewSettings *view_settings,
+ImBuf *IMB_colormanagement_imbuf_for_write(ImBuf *ibuf, bool save_as_render, bool allocate_result, const ColorManagedViewSettings *view_settings,
                                            const ColorManagedDisplaySettings *display_settings, ImageFormatData *image_format_data)
 {
 	ImBuf *colormanaged_ibuf = ibuf;
-	int do_colormanagement;
+	bool do_colormanagement;
 	bool is_movie = BKE_imtype_is_movie(image_format_data->imtype);
-	int requires_linear_float = BKE_imtype_requires_linear_float(image_format_data->imtype);
-	int do_alpha_under = image_format_data->planes != R_IMF_PLANES_RGBA;
+	bool requires_linear_float = BKE_imtype_requires_linear_float(image_format_data->imtype);
+	bool do_alpha_under = image_format_data->planes != R_IMF_PLANES_RGBA;
 
 	do_colormanagement = save_as_render && (is_movie || !requires_linear_float);
 
@@ -1842,7 +1842,7 @@ ImBuf *IMB_colormanagement_imbuf_for_write(ImBuf *ibuf, int save_as_render, int
 	}
 
 	if (do_colormanagement) {
-		int make_byte = FALSE;
+		bool make_byte = false;
 		ImFileType *type;
 
 		/* for proper check whether byte buffer is required by a format or not
@@ -1858,7 +1858,7 @@ ImBuf *IMB_colormanagement_imbuf_for_write(ImBuf *ibuf, int save_as_render, int
 		for (type = IMB_FILE_TYPES; type->is_a; type++) {
 			if (type->save && type->ftype(type, colormanaged_ibuf)) {
 				if ((type->flag & IM_FTYPE_FLOAT) == 0)
-					make_byte = TRUE;
+					make_byte = true;
 
 				break;
 			}
@@ -1893,7 +1893,7 @@ void IMB_colormanagement_buffer_make_display_space(float *buffer, unsigned char
 	cm_processor = IMB_colormanagement_display_processor_new(view_settings, display_settings);
 
 	processor_transform_apply_threaded(display_buffer_float, width, height, channels,
-	                                   cm_processor, TRUE);
+	                                   cm_processor, true);
 
 	IMB_buffer_byte_from_float(display_buffer, display_buffer_float,
 	                           channels, dither, IB_PROFILE_SRGB, IB_PROFILE_SRGB,
@@ -1979,7 +1979,7 @@ unsigned char *IMB_display_buffer_acquire(ImBuf *ibuf, const ColorManagedViewSet
 				                                  ibuf->x, 0, 0, applied_view_settings, display_settings,
 				                                  ibuf->invalid_rect.xmin, ibuf->invalid_rect.ymin,
 				                                  ibuf->invalid_rect.xmax, ibuf->invalid_rect.ymax,
-				                                  FALSE);
+				                                  false);
 			}
 
 			BLI_rcti_init(&ibuf->invalid_rect, 0, 0, 0, 0);
@@ -2034,7 +2034,7 @@ unsigned char *IMB_display_buffer_acquire_ctx(const bContext *C, ImBuf *ibuf, vo
 
 void IMB_display_buffer_transform_apply(unsigned char *display_buffer, float *linear_buffer, int width, int height,
                                         int channels, const ColorManagedViewSettings *view_settings,
-                                        const ColorManagedDisplaySettings *display_settings, int predivide)
+                                        const ColorManagedDisplaySettings *display_settings, bool predivide)
 {
 	if (global_tot_display == 0 || global_tot_view == 0) {
 		IMB_buffer_byte_from_float(display_buffer, linear_buffer, channels, 0.0f, IB_PROFILE_SRGB, IB_PROFILE_LINEAR_RGB, FALSE,
@@ -2296,7 +2296,7 @@ static void colormanage_description_strip(char *description)
 	}
 }
 
-ColorSpace *colormanage_colorspace_add(const char *name, const char *description, int is_invertible, int is_data)
+ColorSpace *colormanage_colorspace_add(const char *name, const char *description, bool is_invertible, bool is_data)
 {
 	ColorSpace *colorspace, *prev_space;
 	int counter = 1;
@@ -2495,7 +2495,7 @@ static void partial_buffer_update_rect(ImBuf *ibuf, unsigned char *display_buffe
 	float *display_buffer_float = NULL;
 	const int width = xmax - xmin;
 	const int height = ymax - ymin;
-	int is_data = ibuf->colormanage_flag & IMB_COLORMANAGE_IS_DATA;
+	bool is_data = (ibuf->colormanage_flag & IMB_COLORMANAGE_IS_DATA) != 0;
 
 	if (dither != 0.0f) {
 		/* cm_processor is NULL in cases byte_buffer's space matches display
@@ -2576,7 +2576,7 @@ static void partial_buffer_update_rect(ImBuf *ibuf, unsigned char *display_buffe
 void IMB_partial_display_buffer_update(ImBuf *ibuf, const float *linear_buffer, const unsigned char *byte_buffer,
                                        int stride, int offset_x, int offset_y, const ColorManagedViewSettings *view_settings,
                                        const ColorManagedDisplaySettings *display_settings,
-                                       int xmin, int ymin, int xmax, int ymax, int update_orig_byte_buffer)
+                                       int xmin, int ymin, int xmax, int ymax, bool update_orig_byte_buffer)
 {
 	if ((ibuf->rect && ibuf->rect_float) || update_orig_byte_buffer) {
 		/* update byte buffer created by legacy color management */
@@ -2623,7 +2623,7 @@ void IMB_partial_display_buffer_update(ImBuf *ibuf, const float *linear_buffer,
 
 		if (display_buffer) {
 			ColormanageProcessor *cm_processor = NULL;
-			int skip_transform = 0;
+			bool skip_transform = false;
 
 			/* byte buffer is assumed to be in imbuf's rect space, so if byte buffer
 			 * is known we could skip display->linear->display conversion in case
@@ -2688,7 +2688,7 @@ ColormanageProcessor *IMB_colormanagement_display_processor_new(const ColorManag
 
 	if (applied_view_settings->flag & COLORMANAGE_VIEW_USE_CURVES) {
 		cm_processor->curve_mapping = curvemapping_copy(applied_view_settings->curve_mapping);
-		curvemapping_premultiply(cm_processor->curve_mapping, FALSE);
+		curvemapping_premultiply(cm_processor->curve_mapping, false);
 	}
 
 	return cm_processor;
@@ -2737,7 +2737,7 @@ void IMB_colormanagement_processor_apply_v3(ColormanageProcessor *cm_processor,
 }
 
 void IMB_colormanagement_processor_apply(ColormanageProcessor *cm_processor, float *buffer, int width, int height,
-                                         int channels, int predivide)
+                                         int channels, bool predivide)
 {
 	/* apply curve mapping */
 	if (cm_processor->curve_mapping) {
@@ -2822,8 +2822,8 @@ static void update_glsl_display_processor(const ColorManagedViewSettings *view_s
 	}
 }
 
-int IMB_colormanagement_support_glsl_draw(const ColorManagedViewSettings *view_settings,
-                                          int skip_curves)
+bool IMB_colormanagement_support_glsl_draw(const ColorManagedViewSettings *view_settings,
+                                           bool skip_curves)
 {
 	/* curves not supported yet */
 	if (!skip_curves)
@@ -2846,10 +2846,10 @@ int IMB_colormanagement_support_glsl_draw(const ColorManagedViewSettings *view_s
  * This is low-level function, use glaDrawImBuf_glsl_ctx if you
  * only need to display given image buffer
  */
-int IMB_colormanagement_setup_glsl_draw_from_space(const ColorManagedViewSettings *view_settings,
-                                                   const ColorManagedDisplaySettings *display_settings,
-                                                   struct ColorSpace *from_colorspace, int predivide,
-                                                   int skip_curves)
+bool IMB_colormanagement_setup_glsl_draw_from_space(const ColorManagedViewSettings *view_settings,
+                                                    const ColorManagedDisplaySettings *display_settings,
+                                                    struct ColorSpace *from_colorspace, bool predivide,
+                                                    bool skip_curves)
 {
 	ColorManagedViewSettings default_view_settings;
 	const ColorManagedViewSettings *applied_view_settings;
@@ -2869,7 +2869,7 @@ int IMB_colormanagement_setup_glsl_draw_from_space(const ColorManagedViewSetting
 	/* RGB curves mapping is not supported on GPU yet. */
 	if (!skip_curves)
 		if (applied_view_settings->flag & COLORMANAGE_VIEW_USE_CURVES)
-			return FALSE;
+			return false;
 
 	/* Make sure OCIO processor is up-to-date. */
 	update_glsl_display_processor(applied_view_settings, display_settings,
@@ -2879,27 +2879,27 @@ int IMB_colormanagement_setup_glsl_draw_from_space(const ColorManagedViewSetting
 }
 
 /* Configures GLSL shader for conversion from scene linear to display space */
-int IMB_colormanagement_setup_glsl_draw(const ColorManagedViewSettings *view_settings,
-                                        const ColorManagedDisplaySettings *display_settings,
-                                        int predivide, int skip_curves)
+bool IMB_colormanagement_setup_glsl_draw(const ColorManagedViewSettings *view_settings,
+                                         const ColorManagedDisplaySettings *display_settings,
+                                         bool predivide, bool skip_curves)
 {
 	return IMB_colormanagement_setup_glsl_draw_from_space(view_settings, display_settings,
 	                                                      NULL, predivide, skip_curves);
 }
 
 /* Same as setup_glsl_draw_from_space, but color management settings are guessing from a given context */
-int IMB_colormanagement_setup_glsl_draw_from_space_ctx(const struct bContext *C, struct ColorSpace *from_colorspace, int predivide)
+bool IMB_colormanagement_setup_glsl_draw_from_space_ctx(const struct bContext *C, struct ColorSpace *from_colorspace, bool predivide)
 {
 	ColorManagedViewSettings *view_settings;
 	ColorManagedDisplaySettings *display_settings;
 
 	IMB_colormanagement_display_settings_from_ctx(C, &view_settings, &display_settings);
 
-	return IMB_colormanagement_setup_glsl_draw_from_space(view_settings, display_settings, from_colorspace, predivide, FALSE);
+	return IMB_colormanagement_setup_glsl_draw_from_space(view_settings, display_settings, from_colorspace, predivide, false);
 }
 
 /* Same as setup_glsl_draw, but color management settings are guessing from a given context */
-int IMB_colormanagement_setup_glsl_draw_ctx(const bContext *C, int predivide)
+bool IMB_colormanagement_setup_glsl_draw_ctx(const bContext *C, bool predivide)
 {
 	return IMB_colormanagement_setup_glsl_draw_from_space_ctx(C, NULL, predivide);
 }
@@ -2925,7 +2925,7 @@ void IMB_colormanagement_finish_glsl_draw(void)
  * When there's no need to apply transform on 2D textures, use
  * IMB_colormanagement_finish_glsl_transform().
  */
-int IMB_colormanagement_setup_transform_from_role_glsl(int role, int predivide)
+bool IMB_colormanagement_setup_transform_from_role_glsl(int role, bool predivide)
 {
 	OCIO_ConstProcessorRcPtr *processor;
 	ColorSpace *colorspace;
diff --git a/source/blender/imbuf/intern/divers.c b/source/blender/imbuf/intern/divers.c
index 76a5e98da7e..af9f7109106 100644
--- a/source/blender/imbuf/intern/divers.c
+++ b/source/blender/imbuf/intern/divers.c
@@ -565,7 +565,7 @@ void IMB_rect_from_float(ImBuf *ibuf)
 	buffer = MEM_dupallocN(ibuf->rect_float);
 
 	/* first make float buffer in byte space */
-	IMB_colormanagement_transform(buffer, ibuf->x, ibuf->y, ibuf->channels, from_colorspace, ibuf->rect_colorspace->name, TRUE);
+	IMB_colormanagement_transform(buffer, ibuf->x, ibuf->y, ibuf->channels, from_colorspace, ibuf->rect_colorspace->name, true);
 
 	/* convert from float's premul alpha to byte's straight alpha */
 	IMB_unpremultiply_rect_float(buffer, ibuf->planes, ibuf->x, ibuf->y);
@@ -657,7 +657,7 @@ void IMB_float_from_rect(ImBuf *ibuf)
 
 	/* then make float be in linear space */
 	IMB_colormanagement_colorspace_to_scene_linear(rect_float, ibuf->x, ibuf->y, ibuf->channels,
-	                                               ibuf->rect_colorspace, FALSE);
+	                                               ibuf->rect_colorspace, false);
 
 	/* byte buffer is straight alpha, float should always be premul */
 	IMB_premultiply_rect_float(rect_float, ibuf->channels, ibuf->x, ibuf->y);