Film response curves implemented as a looks

This commit implement's OCIO's Looks idea which
is about applying some color correction on the
buffer before it get's affected by a display
transform.

This is mainly used to modify images in an
artistics way.

Currently we've got looks generated from film
response curves for all sorts of cameras.

Patch by both of me and Brecht.

intern/opencolorio/fallback_impl.cc

@@ -162,6 +162,30 @@ const char *FallbackImpl::configGetDisplayColorSpaceName(OCIO_ConstConfigRcPtr *
 	return "sRGB";
 }
 
+int FallbackImpl::configGetNumLooks(OCIO_ConstConfigRcPtr * /*config*/)
+{
+	return 0;
+}
+
+const char *FallbackImpl::configGetLookNameByIndex(OCIO_ConstConfigRcPtr * /*config*/, int /*index*/)
+{
+	return "";
+}
+
+OCIO_ConstLookRcPtr *FallbackImpl::configGetLook(OCIO_ConstConfigRcPtr * /*config*/, const char * /*name*/)
+{
+	return NULL;
+}
+
+const char *FallbackImpl::lookGetProcessSpace(OCIO_ConstLookRcPtr *look)
+{
+	return NULL;
+}
+
+void FallbackImpl::lookRelease(OCIO_ConstLookRcPtr * /*look*/)
+{
+}
+
 int FallbackImpl::colorSpaceIsInvertible(OCIO_ConstColorSpaceRcPtr * /*cs*/)
 {
 	return 1;
@@ -326,6 +350,14 @@ void FallbackImpl::displayTransformSetLinearCC(OCIO_DisplayTransformRcPtr * /*dt
 {
 }
 
+void FallbackImpl::displayTransformSetLooksOverride(OCIO_DisplayTransformRcPtr * /*dt*/, const char * /*looks*/)
+{
+}
+
+void FallbackImpl::displayTransformSetLooksOverrideEnabled(OCIO_DisplayTransformRcPtr * /*dt*/, bool /*enabled*/)
+{
+}
+
 void FallbackImpl::displayTransformRelease(OCIO_DisplayTransformRcPtr * /*dt*/)
 {
 }

intern/opencolorio/ocio_capi.cc

@@ -132,6 +132,31 @@ const char *OCIO_configGetDisplayColorSpaceName(OCIO_ConstConfigRcPtr *config, c
 	return impl->configGetDisplayColorSpaceName(config, display, view);
 }
 
+int OCIO_configGetNumLooks(OCIO_ConstConfigRcPtr *config)
+{
+	return impl->configGetNumLooks(config);
+}
+
+const char *OCIO_configGetLookNameByIndex(OCIO_ConstConfigRcPtr *config, int index)
+{
+	return impl->configGetLookNameByIndex(config, index);
+}
+
+OCIO_ConstLookRcPtr *OCIO_configGetLook(OCIO_ConstConfigRcPtr *config, const char *name)
+{
+	return impl->configGetLook(config, name);
+}
+
+const char *OCIO_lookGetProcessSpace(OCIO_ConstLookRcPtr *look)
+{
+	return impl->lookGetProcessSpace(look);
+}
+
+void OCIO_lookRelease(OCIO_ConstLookRcPtr *look)
+{
+	impl->lookRelease(look);
+}
+
 int OCIO_colorSpaceIsInvertible(OCIO_ConstColorSpaceRcPtr *cs)
 {
 	return impl->colorSpaceIsInvertible(cs);
@@ -232,6 +257,16 @@ void OCIO_displayTransformSetLinearCC(OCIO_DisplayTransformRcPtr *dt, OCIO_Const
 	impl->displayTransformSetLinearCC(dt, t);
 }
 
+void OCIO_displayTransformSetLooksOverride(OCIO_DisplayTransformRcPtr *dt, const char *looks)
+{
+	impl->displayTransformSetLooksOverride(dt, looks);
+}
+
+void OCIO_displayTransformSetLooksOverrideEnabled(OCIO_DisplayTransformRcPtr *dt, bool enabled)
+{
+	impl->displayTransformSetLooksOverrideEnabled(dt, enabled);
+}
+
 void OCIO_displayTransformRelease(OCIO_DisplayTransformRcPtr *dt)
 {
 	impl->displayTransformRelease(dt);

intern/opencolorio/ocio_capi.h

@@ -52,6 +52,7 @@ OCIO_DECLARE_HANDLE(OCIO_DisplayTransformRcPtr);
 OCIO_DECLARE_HANDLE(OCIO_ConstTransformRcPtr);
 OCIO_DECLARE_HANDLE(OCIO_ExponentTransformRcPtr);
 OCIO_DECLARE_HANDLE(OCIO_MatrixTransformRcPtr);
+OCIO_DECLARE_HANDLE(OCIO_ConstLookRcPtr);
 
 void OCIO_init(void);
 void OCIO_exit(void);
@@ -83,6 +84,13 @@ int         OCIO_configGetNumViews(OCIO_ConstConfigRcPtr *config, const char *di
 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);
 
+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);
 
@@ -104,6 +112,8 @@ void OCIO_displayTransformSetDisplay(OCIO_DisplayTransformRcPtr *dt, const char
 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_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,

intern/opencolorio/ocio_impl.cc

@@ -282,6 +282,59 @@ const char *OCIOImpl::configGetDisplayColorSpaceName(OCIO_ConstConfigRcPtr *conf
 	return NULL;
 }
 
+int OCIOImpl::configGetNumLooks(OCIO_ConstConfigRcPtr *config)
+{
+	try {
+		return (*(ConstConfigRcPtr *) config)->getNumLooks();
+	}
+	catch (Exception &exception) {
+		OCIO_reportException(exception);
+	}
+
+	return 0;
+}
+
+const char *OCIOImpl::configGetLookNameByIndex(OCIO_ConstConfigRcPtr *config, int index)
+{
+	try {
+		return (*(ConstConfigRcPtr *) config)->getLookNameByIndex(index);
+	}
+	catch (Exception &exception) {
+		OCIO_reportException(exception);
+	}
+
+	return NULL;
+}
+
+OCIO_ConstLookRcPtr *OCIOImpl::configGetLook(OCIO_ConstConfigRcPtr *config, const char *name)
+{
+	ConstLookRcPtr *look = MEM_NEW(ConstLookRcPtr);
+
+	try {
+		*look = (*(ConstConfigRcPtr *) config)->getLook(name);
+
+		if (*look)
+			return (OCIO_ConstLookRcPtr *) look;
+	}
+	catch (Exception &exception) {
+		OCIO_reportException(exception);
+	}
+
+	MEM_DELETE(look, ConstLookRcPtr);
+
+	return NULL;
+}
+
+const char *OCIOImpl::lookGetProcessSpace(OCIO_ConstLookRcPtr *look)
+{
+	return (*(ConstLookRcPtr *) look)->getProcessSpace();
+}
+
+void OCIOImpl::lookRelease(OCIO_ConstLookRcPtr *look)
+{
+	MEM_DELETE((ConstLookRcPtr *) look, ConstLookRcPtr);
+}
+
 int OCIOImpl::colorSpaceIsInvertible(OCIO_ConstColorSpaceRcPtr *cs_)
 {
 	ConstColorSpaceRcPtr *cs = (ConstColorSpaceRcPtr *) cs_;
@@ -481,6 +534,16 @@ void OCIOImpl::displayTransformSetLinearCC(OCIO_DisplayTransformRcPtr *dt, OCIO_
 	(*(DisplayTransformRcPtr *) dt)->setLinearCC(*(ConstTransformRcPtr *) t);
 }
 
+void OCIOImpl::displayTransformSetLooksOverride(OCIO_DisplayTransformRcPtr *dt, const char *looks)
+{
+	(*(DisplayTransformRcPtr *) dt)->setLooksOverride(looks);
+}
+
+void OCIOImpl::displayTransformSetLooksOverrideEnabled(OCIO_DisplayTransformRcPtr *dt, bool enabled)
+{
+	(*(DisplayTransformRcPtr *) dt)->setLooksOverrideEnabled(enabled);
+}
+
 void OCIOImpl::displayTransformRelease(OCIO_DisplayTransformRcPtr *dt)
 {
 	MEM_DELETE((DisplayTransformRcPtr *) dt, DisplayTransformRcPtr);

intern/opencolorio/ocio_impl.h

@@ -58,6 +58,13 @@ public:
 	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 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;
 
@@ -79,6 +86,8 @@ public:
 	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,
@@ -132,6 +141,13 @@ public:
 	const char *configGetView(OCIO_ConstConfigRcPtr *config, const char *display, int index);
 	const char *configGetDisplayColorSpaceName(OCIO_ConstConfigRcPtr *config, const char *display, const char *view);
 
+	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);
 
@@ -153,6 +169,8 @@ public:
 	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,
@@ -207,6 +225,13 @@ public:
 	const char *configGetView(OCIO_ConstConfigRcPtr *config, const char *display, int index);
 	const char *configGetDisplayColorSpaceName(OCIO_ConstConfigRcPtr *config, const char *display, const char *view);
 
+	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);
 
@@ -228,6 +253,8 @@ public:
 	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,

release/datafiles/colormanagement/config.ocio

@@ -283,3 +283,540 @@ colorspaces:
       children:
         - !<ColorSpaceTransform> {src: Linear, dst: lg10}
         - !<FileTransform> {src: colorworks_filmlg_to_p3.3dl, interpolation: linear}
+
+looks:
+  - !<Look>
+    name: Agfa Agfacolor Futura 100
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/agfa_agfacolor_futura_100.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Agfa Agfacolor Futura 200
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/agfa_agfacolor_futura_200.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Agfa Agfacolor Futura 400
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/agfa_agfacolor_futura_400.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Agfa Agfacolor Futura II 100
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/agfa_agfacolor_futura_ii_100.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Agfa Agfacolor Futura II 200
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/agfa_agfacolor_futura_ii_200.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Agfa Agfacolor Futura II 400
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/agfa_agfacolor_futura_ii_400.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Agfa Agfacolor HDC 100 plus
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/agfa_agfacolor_hdc_100_plus.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Agfa Agfacolor HDC 400 plus
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/agfa_agfacolor_hdc_400_plus.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Agfa Agfacolor HDC 200 plus
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/agfa_agfacolor_hdc_200_plus.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Agfa Agfacolor Optima II 100
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/agfa_agfacolor_optima_ii_100.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Agfa Agfacolor Optima II 200
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/agfa_agfacolor_optima_ii_200.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Agfa Agfacolor Ultra 050
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/agfa_agfacolor_ultra_050.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Agfa Agfacolor Vista 100
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/agfa_agfacolor_vista_100.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Agfa Agfacolor Vista 200
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/agfa_agfacolor_vista_200.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Agfa Agfacolor Vista 400
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/agfa_agfacolor_vista_400.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Agfa Agfacolor Vista 800
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/agfa_agfacolor_vista_800.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Agfa Agfachrome CT Precisa 100
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/agfa_agfachrome_ct_precisa_100.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Agfa Agfachrome CT Precisa 200
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/agfa_agfachrome_ct_precisa_200.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Agfa Agfachrome RSX2 050
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/agfa_agfachrome_rsx2_050.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Agfa Agfachrome RSX2 100
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/agfa_agfachrome_rsx2_100.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Agfa Agfachrome RSX2 200
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/agfa_agfachrome_rsx2_200.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Agfa Advantix 100
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/agfa_advantix_100.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Agfa Advantix 200
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/agfa_advantix_200.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Agfa Advantix 400
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/agfa_advantix_400.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Kodak Gold 100
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/kodak_gold_100.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Kodak Gold 200
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/kodak_gold_200.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Kodak Max Zoom 800
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/kodak_max_zoom_800.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Kodak Portra 100T
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/kodak_portra_100t.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Kodak Portra 160NC
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/kodak_portra_160nc.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Kodak Portra 160VC
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/kodak_portra_160vc.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Kodak Portra 800
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/kodak_portra_800.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Kodak Portra 400VC
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/kodak_portra_400vc.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Kodak Portra 400NC
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/kodak_portra_400nc.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Kodak Ektachrome 100 plus
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/kodak_ektachrome_100_plus.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Kodak Ektachrome 320T
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/kodak_ektachrome_320t.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Kodak Ektachrome 400X
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/kodak_ektachrome_400x.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Kodak Ektachrome 64
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/kodak_ektachrome_64.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Kodak Ektachrome 64T
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/kodak_ektachrome_64t.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Kodak Ektachrome E100S
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/kodak_ektachrome_e100s.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Kodak Ektachrome 100
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/kodak_ektachrome_100.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Kodak Kodachrome 200
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/kodak_kodachrome_200.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Kodak Kodachrome 25
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/kodak_kodachrome_25.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Kodak Kodachrome 64
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/kodak_kodachrome_64.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Fujifilm F-125
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/fujifilm_f-125.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Fujifilm F-250
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/fujifilm_f-250.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Fujifilm F-400
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/fujifilm_f-400.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Fujifilm FCI
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/fujifilm_fci.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Kodak DSCS 3151
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/kodak_dscs_3151.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Kodak DSCS 3152
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/kodak_dscs_3152.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Kodak DSCS 3153
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/kodak_dscs_3153.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Kodak DSCS 3154
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/kodak_dscs_3154.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Kodak DSCS 3155
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/kodak_dscs_3155.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Kodak DSCS 3156
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/kodak_dscs_3156.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Fujifilm FP2900Z
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/fujifilm_fp2900z.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Eastman Double X Neg 12min
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/eastman_double_x_neg_12min.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Eastman Double X Neg 6min
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/eastman_double_x_neg_6min.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Eastman Double X Neg 5min
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/eastman_double_x_neg_5min.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Eastman Double X Neg 4min
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/eastman_double_x_neg_4min.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Kodak KAI-0311
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/kodak_kai-0311.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Kodak KAF-2001
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/kodak_kaf-2001.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Kodak KAF-3000
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/kodak_kaf-3000.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Kodak KAI-0372
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/kodak_kai-0372.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Kodak KAI-1010
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/kodak_kai-1010.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Canon Optura 981111
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/canon_optura_981111.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Canon Optura 981113
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/canon_optura_981113.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Canon Optura 981114
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/canon_optura_981114.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}
+
+  - !<Look>
+    name: Canon Optura 981111.SLRR
+    process_space: linear
+    transform: !<GroupTransform>
+      children:
+        - !<FileTransform> {src: camera_response/canon_optura_981111.slrr.spi1d, interpolation: linear}
+        - !<FileTransform> {src: srgb.spi1d, interpolation: linear}

source/blender/blenkernel/intern/colortools.c

@@ -1260,6 +1260,7 @@ void BKE_color_managed_view_settings_init(ColorManagedViewSettings *settings)
 	 *            for now use NONE to be compatible with all current files
 	 */
 	BLI_strncpy(settings->view_transform, "Default", sizeof(settings->view_transform));
+	BLI_strncpy(settings->look, "NONE", sizeof(settings->look));
 
 	settings->gamma = 1.0f;
 	settings->exposure = 0.0f;
@@ -1268,6 +1269,7 @@ void BKE_color_managed_view_settings_init(ColorManagedViewSettings *settings)
 void BKE_color_managed_view_settings_copy(ColorManagedViewSettings *new_settings,
                                           const ColorManagedViewSettings *settings)
 {
+	BLI_strncpy(new_settings->look, settings->look, sizeof(new_settings->look));
 	BLI_strncpy(new_settings->view_transform, settings->view_transform, sizeof(new_settings->view_transform));
 
 	new_settings->flag = settings->flag;

source/blender/editors/interface/interface_templates.c

@@ -3434,6 +3434,8 @@ void uiTemplateColormanagedViewSettings(uiLayout *layout, bContext *UNUSED(C), P
 
 	col = uiLayoutColumn(layout, FALSE);
 
+	uiItemR(col, &view_transform_ptr, "look", 0, IFACE_("Look"), ICON_NONE);
+
 	row = uiLayoutRow(col, FALSE);
 	uiItemR(row, &view_transform_ptr, "view_transform", UI_ITEM_R_EXPAND, IFACE_("View"), ICON_NONE);
 

source/blender/imbuf/IMB_colormanagement.h

@@ -130,6 +130,10 @@ const char *IMB_colormanagement_display_get_none_name(void);
 int IMB_colormanagement_view_get_named_index(const char *name);
 const char *IMB_colormanagement_view_get_indexed_name(int index);
 
+/* ** Look funcrions ** */
+int IMB_colormanagement_look_get_named_index(const char *name);
+const char *IMB_colormanagement_look_get_indexed_name(int index);
+
 /* ** Color space functions ** */
 int IMB_colormanagement_colorspace_get_named_index(const char *name);
 const char *IMB_colormanagement_colorspace_get_indexed_name(int index);
@@ -140,6 +144,7 @@ void IMB_colormanagment_colorspace_from_ibuf_ftype(struct ColorManagedColorspace
 /* ** RNA helper functions ** */
 void IMB_colormanagement_display_items_add(struct EnumPropertyItem **items, int *totitem);
 void IMB_colormanagement_view_items_add(struct EnumPropertyItem **items, int *totitem, const char *display_name);
+void IMB_colormanagement_look_items_add(struct EnumPropertyItem **items, int *totitem);
 void IMB_colormanagement_colorspace_items_add(struct EnumPropertyItem **items, int *totitem);
 
 /* ** Tile-based buffer management ** */

source/blender/imbuf/intern/IMB_colormanagement_intern.h

@@ -69,6 +69,14 @@ typedef struct ColorManagedView {
 	char name[MAX_COLORSPACE_NAME];
 } ColorManagedView;
 
+typedef struct ColorManagedLook {
+	struct ColorManagedLook *next, *prev;
+	int index;
+	char name[MAX_COLORSPACE_NAME];
+	char process_space[MAX_COLORSPACE_NAME];
+	bool is_noop;
+} ColorManagedLook;
+
 /* ** Initialization / De-initialization ** */
 
 void colormanagement_init(void);
@@ -93,6 +101,10 @@ 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);
 
+struct ColorManagedLook *colormanage_look_add(const char *name, const char *process_space, bool is_noop);
+struct ColorManagedLook *colormanage_look_get_named(const char *name);
+struct ColorManagedLook *colormanage_look_get_indexed(int index);
+
 void colorspace_set_default_role(char *colorspace, int size, int role);
 
 void colormanage_imbuf_set_default_spaces(struct ImBuf *ibuf);

source/blender/imbuf/intern/colormanagement.c

@@ -81,13 +81,15 @@ static char global_role_default_byte[MAX_COLORSPACE_NAME];
 static char global_role_default_float[MAX_COLORSPACE_NAME];
 static char global_role_default_sequencer[MAX_COLORSPACE_NAME];
 
-static ListBase global_colorspaces = {NULL};
-static ListBase global_displays = {NULL};
-static ListBase global_views = {NULL};
+static ListBase global_colorspaces = {NULL, NULL};
+static ListBase global_displays = {NULL, NULL};
+static ListBase global_views = {NULL, NULL};
+static ListBase global_looks = {NULL, NULL};
 
 static int global_tot_colorspace = 0;
 static int global_tot_display = 0;
 static int global_tot_view = 0;
+static int global_tot_looks = 0;
 
 /* lock used by pre-cached processors getters, so processor wouldn't
  * be created several times
@@ -107,6 +109,7 @@ static struct global_glsl_state {
 	OCIO_ConstProcessorRcPtr *processor;
 
 	/* Settings of processor for comparison. */
+	char look[MAX_COLORSPACE_NAME];
 	char view[MAX_COLORSPACE_NAME];
 	char display[MAX_COLORSPACE_NAME];
 	char input[MAX_COLORSPACE_NAME];
@@ -185,6 +188,7 @@ static struct global_glsl_state {
  */
 typedef struct ColormanageCacheViewSettings {
 	int flag;
+	int look;
 	int view;
 	float exposure;
 	float gamma;
@@ -202,6 +206,7 @@ typedef struct ColormanageCacheKey {
 
 typedef struct ColormnaageCacheData {
 	int flag;        /* view flags of cached buffer */
+	int look;        /* Additional artistics transform */
 	float exposure;  /* exposure value cached buffer is calculated with */
 	float gamma;     /* gamma value cached buffer is calculated with */
 	CurveMapping *curve_mapping;  /* curve mapping used for cached buffer */
@@ -285,8 +290,10 @@ static void colormanage_cachedata_set(ImBuf *ibuf, ColormnaageCacheData *data)
 static void colormanage_view_settings_to_cache(ColormanageCacheViewSettings *cache_view_settings,
                                                const ColorManagedViewSettings *view_settings)
 {
+	int look = IMB_colormanagement_look_get_named_index(view_settings->look);
 	int view = IMB_colormanagement_view_get_named_index(view_settings->view_transform);
 
+	cache_view_settings->look = look;
 	cache_view_settings->view = view;
 	cache_view_settings->exposure = view_settings->exposure;
 	cache_view_settings->gamma = view_settings->gamma;
@@ -364,7 +371,8 @@ static unsigned char *colormanage_cache_get(ImBuf *ibuf, const ColormanageCacheV
 		 */
 		cache_data = colormanage_cachedata_get(cache_ibuf);
 
-		if (cache_data->exposure != view_settings->exposure ||
+		if (cache_data->look != view_settings->look ||
+		    cache_data->exposure != view_settings->exposure ||
 		    cache_data->gamma != view_settings->gamma ||
 		    cache_data->flag != view_settings->flag ||
 		    cache_data->curve_mapping != curve_mapping ||
@@ -409,6 +417,7 @@ static void colormanage_cache_put(ImBuf *ibuf, const ColormanageCacheViewSetting
 
 	/* store data which is needed to check whether cached buffer could be used for color managed display settings */
 	cache_data = MEM_callocN(sizeof(ColormnaageCacheData), "color manage cache imbuf data");
+	cache_data->look = view_settings->look;
 	cache_data->exposure = view_settings->exposure;
 	cache_data->gamma = view_settings->gamma;
 	cache_data->flag = view_settings->flag;
@@ -454,7 +463,8 @@ static void colormanage_role_color_space_name_get(OCIO_ConstConfigRcPtr *config,
 
 static void colormanage_load_config(OCIO_ConstConfigRcPtr *config)
 {
-	int tot_colorspace, tot_display, tot_display_view, index, viewindex, viewindex2;
+	int tot_colorspace, tot_display, tot_display_view, tot_looks;
+	int index, viewindex, viewindex2;
 	const char *name;
 
 	/* get roles */
@@ -519,6 +529,21 @@ static void colormanage_load_config(OCIO_ConstConfigRcPtr *config)
 	}
 
 	global_tot_display = tot_display;
+
+	/* load looks */
+	tot_looks = OCIO_configGetNumLooks(config);
+	colormanage_look_add("None", "", true);
+	for (index = 0; index < tot_looks; index++) {
+		OCIO_ConstLookRcPtr *ocio_look;
+		const char *process_space;
+
+		name = OCIO_configGetLookNameByIndex(config, index);
+		ocio_look = OCIO_configGetLook(config, name);
+		process_space = OCIO_lookGetProcessSpace(ocio_look);
+		OCIO_lookRelease(ocio_look);
+
+		colormanage_look_add(name, process_space, false);
+	}
 }
 
 static void colormanage_free_config(void)
@@ -566,6 +591,9 @@ static void colormanage_free_config(void)
 	/* free views */
 	BLI_freelistN(&global_views);
 
+	/* free looks */
+	BLI_freelistN(&global_looks);
+
 	OCIO_exit();
 }
 
@@ -705,7 +733,8 @@ static ColorSpace *display_transform_get_colorspace(const ColorManagedViewSettin
 	return NULL;
 }
 
-static OCIO_ConstProcessorRcPtr *create_display_buffer_processor(const char *view_transform,
+static OCIO_ConstProcessorRcPtr *create_display_buffer_processor(const char *look,
+                                                                 const char *view_transform,
                                                                  const char *display,
                                                                  float exposure, float gamma,
                                                                  const char *from_colorspace)
@@ -713,6 +742,7 @@ static OCIO_ConstProcessorRcPtr *create_display_buffer_processor(const char *vie
 	OCIO_ConstConfigRcPtr *config = OCIO_getCurrentConfig();
 	OCIO_DisplayTransformRcPtr *dt;
 	OCIO_ConstProcessorRcPtr *processor;
+	ColorManagedLook *look_descr = colormanage_look_get_named(look);
 
 	dt = OCIO_createDisplayTransform();
 
@@ -720,6 +750,11 @@ static OCIO_ConstProcessorRcPtr *create_display_buffer_processor(const char *vie
 	OCIO_displayTransformSetView(dt, view_transform);
 	OCIO_displayTransformSetDisplay(dt, display);
 
+	if (look_descr->is_noop == false) {
+		OCIO_displayTransformSetLooksOverrideEnabled(dt, true);
+		OCIO_displayTransformSetLooksOverride(dt, look);
+	}
+
 	/* fstop exposure control */
 	if (exposure != 0.0f) {
 		OCIO_MatrixTransformRcPtr *mt;
@@ -965,6 +1000,7 @@ static void colormanage_check_view_settings(ColorManagedDisplaySettings *display
 	}
 	else {
 		ColorManagedView *view = colormanage_view_get_named(view_settings->view_transform);
+		ColorManagedLook *look;
 
 		if (!view) {
 			display = colormanage_display_get_named(display_settings->display_device);
@@ -979,6 +1015,19 @@ static void colormanage_check_view_settings(ColorManagedDisplaySettings *display
 				BLI_strncpy(view_settings->view_transform, default_view->name, sizeof(view_settings->view_transform));
 			}
 		}
+
+		look = colormanage_look_get_named(view_settings->look);
+		if (!look) {
+			ColorManagedLook *default_look = (ColorManagedLook *) global_looks.first;
+
+			/* Prevent paranoid printf when opening files stored prior looks implementation. */
+			if (view_settings->look[0]) {
+				printf("Color management: %s look \"%s\" not found, setting default \"%s\".\n",
+				       what, view_settings->look, default_look->name);
+			}
+
+			BLI_strncpy(view_settings->look, default_look->name, sizeof(view_settings->look));
+		}
 	}
 
 	/* OCIO_TODO: move to do_versions() */
@@ -2357,7 +2406,7 @@ ColorSpace *colormanage_colorspace_get_roled(int role)
 
 ColorSpace *colormanage_colorspace_get_indexed(int index)
 {
-	/* display indices are 1-based */
+	/* color space indices are 1-based */
 	return BLI_findlink(&global_colorspaces, index - 1);
 }
 
@@ -2402,6 +2451,71 @@ void IMB_colormanagment_colorspace_from_ibuf_ftype(ColorManagedColorspaceSetting
 	}
 }
 
+/*********************** Looks functions *************************/
+
+ColorManagedLook *colormanage_look_add(const char *name, const char *process_space, bool is_noop)
+{
+	ColorManagedLook *look;
+	int index = global_tot_looks;
+
+	look = MEM_callocN(sizeof(ColorManagedLook), "ColorManagedLook");
+	look->index = index + 1;
+	BLI_strncpy(look->name, name, sizeof(look->name));
+	BLI_strncpy(look->process_space, process_space, sizeof(look->process_space));
+	look->is_noop = is_noop;
+
+	BLI_addtail(&global_looks, look);
+
+	global_tot_looks++;
+
+	return look;
+}
+
+ColorManagedLook *colormanage_look_get_named(const char *name)
+{
+	ColorManagedLook *look;
+
+	for (look = global_looks.first; look; look = look->next) {
+		if (!strcmp(look->name, name)) {
+			return look;
+		}
+	}
+
+	return NULL;
+}
+
+ColorManagedLook *colormanage_look_get_indexed(int index)
+{
+	/* look indices are 1-based */
+	return BLI_findlink(&global_looks, index - 1);
+}
+
+int IMB_colormanagement_look_get_named_index(const char *name)
+{
+	ColorManagedLook *look;
+
+	look = colormanage_look_get_named(name);
+
+	if (look) {
+		return look->index;
+	}
+
+	return 0;
+}
+
+const char *IMB_colormanagement_look_get_indexed_name(int index)
+{
+	ColorManagedLook *look;
+
+	look = colormanage_look_get_indexed(index);
+
+	if (look) {
+		return look->name;
+	}
+
+	return NULL;
+}
+
 /*********************** RNA helper functions *************************/
 
 void IMB_colormanagement_display_items_add(EnumPropertyItem **items, int *totitem)
@@ -2450,6 +2564,23 @@ void IMB_colormanagement_view_items_add(EnumPropertyItem **items, int *totitem,
 	}
 }
 
+void IMB_colormanagement_look_items_add(struct EnumPropertyItem **items, int *totitem)
+{
+	ColorManagedLook *look;
+
+	for (look = global_looks.first; look; look = look->next) {
+		EnumPropertyItem item;
+
+		item.value = look->index;
+		item.name = look->name;
+		item.identifier = look->name;
+		item.icon = 0;
+		item.description = "";
+
+		RNA_enum_item_add(items, totitem, &item);
+	}
+}
+
 void IMB_colormanagement_colorspace_items_add(EnumPropertyItem **items, int *totitem)
 {
 	ColorSpace *colorspace;
@@ -2682,8 +2813,11 @@ ColormanageProcessor *IMB_colormanagement_display_processor_new(const ColorManag
 	if (display_space)
 		cm_processor->is_data_result = display_space->is_data;
 
-	cm_processor->processor = create_display_buffer_processor(applied_view_settings->view_transform, display_settings->display_device,
-	                                                          applied_view_settings->exposure, applied_view_settings->gamma,
+	cm_processor->processor = create_display_buffer_processor(applied_view_settings->look,
+	                                                          applied_view_settings->view_transform,
+	                                                          display_settings->display_device,
+	                                                          applied_view_settings->exposure,
+	                                                          applied_view_settings->gamma,
 	                                                          global_role_scene_linear);
 
 	if (applied_view_settings->flag & COLORMANAGE_VIEW_USE_CURVES) {
@@ -2786,6 +2920,7 @@ static bool check_glsl_display_processor_changed(const ColorManagedViewSettings
 {
 	return !(global_glsl_state.exposure == view_settings->exposure &&
 	         global_glsl_state.gamma == view_settings->gamma &&
+	         STREQ(global_glsl_state.look, view_settings->look) &&
 	         STREQ(global_glsl_state.view, view_settings->view_transform) &&
 	         STREQ(global_glsl_state.display, display_settings->display_device) &&
 	         STREQ(global_glsl_state.input, from_colorspace));
@@ -2802,6 +2937,7 @@ static void update_glsl_display_processor(const ColorManagedViewSettings *view_s
 	    check_glsl_display_processor_changed(view_settings, display_settings, from_colorspace))
 	{
 		/* Store settings of processor for further comparison. */
+		BLI_strncpy(global_glsl_state.look, view_settings->look, MAX_COLORSPACE_NAME);
 		BLI_strncpy(global_glsl_state.view, view_settings->view_transform, MAX_COLORSPACE_NAME);
 		BLI_strncpy(global_glsl_state.display, display_settings->display_device, MAX_COLORSPACE_NAME);
 		BLI_strncpy(global_glsl_state.input, from_colorspace, MAX_COLORSPACE_NAME);
@@ -2814,7 +2950,8 @@ static void update_glsl_display_processor(const ColorManagedViewSettings *view_s
 
 		/* We're using display OCIO processor, no RGB curves yet. */
 		global_glsl_state.processor =
-			create_display_buffer_processor(global_glsl_state.view,
+			create_display_buffer_processor(global_glsl_state.look,
+			                                global_glsl_state.view,
 			                                global_glsl_state.display,
 			                                global_glsl_state.exposure,
 			                                global_glsl_state.gamma,

source/blender/makesdna/DNA_color_types.h

@@ -162,6 +162,7 @@ typedef struct Scopes {
 
 typedef struct ColorManagedViewSettings {
 	int flag, pad;
+	char look[64];   /* look which is being applied when displaying buffer on the screen (prior to view transform) */
 	char view_transform[64];   /* view transform which is being applied when displaying buffer on the screen */
 	float exposure;            /* fstop exposure */
 	float gamma;               /* post-display gamma transform */

source/blender/makesrna/intern/rna_color.c

@@ -470,6 +470,37 @@ static EnumPropertyItem *rna_ColorManagedViewSettings_view_transform_itemf(bCont
 	return items;
 }
 
+static int rna_ColorManagedViewSettings_look_get(PointerRNA *ptr)
+{
+	ColorManagedViewSettings *view = (ColorManagedViewSettings *) ptr->data;
+
+	return IMB_colormanagement_look_get_named_index(view->look);
+}
+
+static void rna_ColorManagedViewSettings_look_set(PointerRNA *ptr, int value)
+{
+	ColorManagedViewSettings *view = (ColorManagedViewSettings *) ptr->data;
+
+	const char *name = IMB_colormanagement_look_get_indexed_name(value);
+
+	if (name) {
+		BLI_strncpy(view->look, name, sizeof(view->look));
+	}
+}
+
+static EnumPropertyItem *rna_ColorManagedViewSettings_look_itemf(bContext *C, PointerRNA *ptr,
+                                                                 PropertyRNA *UNUSED(prop), int *free)
+{
+	EnumPropertyItem *items = NULL;
+	int totitem = 0;
+
+	IMB_colormanagement_look_items_add(&items, &totitem);
+	RNA_enum_item_end(&items, &totitem);
+
+	*free = TRUE;
+	return items;
+}
+
 static void rna_ColorManagedViewSettings_use_curves_set(PointerRNA *ptr, int value)
 {
 	ColorManagedViewSettings *view_settings = (ColorManagedViewSettings *) ptr->data;
@@ -947,6 +978,11 @@ static void rna_def_colormanage(BlenderRNA *brna)
 		{0, NULL, 0, NULL, NULL}
 	};
 
+	static EnumPropertyItem look_items[] = {
+		{0, "NONE", 0, "None", "Do not modify image in an artistics manner"},
+		{0, NULL, 0, NULL, NULL}
+	};
+
 	static EnumPropertyItem view_transform_items[] = {
 		{0, "NONE", 0, "None", "Do not perform any color transform on display, use old non-color managed technique for display"},
 		{0, NULL, 0, NULL, NULL}
@@ -973,12 +1009,20 @@ static void rna_def_colormanage(BlenderRNA *brna)
 	srna = RNA_def_struct(brna, "ColorManagedViewSettings", NULL);
 	RNA_def_struct_ui_text(srna, "ColorManagedViewSettings", "Color management settings used for displaying images on the display");
 
+	prop = RNA_def_property(srna, "look", PROP_ENUM, PROP_NONE);
+	RNA_def_property_enum_items(prop, look_items);
+	RNA_def_property_enum_funcs(prop, "rna_ColorManagedViewSettings_look_get",
+	                                  "rna_ColorManagedViewSettings_look_set",
+	                                  "rna_ColorManagedViewSettings_look_itemf");
+	RNA_def_property_ui_text(prop, "Look", "Additional tarnsform applyed before view transform for an artistics needs");
+	RNA_def_property_update(prop, NC_WINDOW, "rna_ColorManagement_update");
+
 	prop = RNA_def_property(srna, "view_transform", PROP_ENUM, PROP_NONE);
 	RNA_def_property_enum_items(prop, view_transform_items);
 	RNA_def_property_enum_funcs(prop, "rna_ColorManagedViewSettings_view_transform_get",
 	                                  "rna_ColorManagedViewSettings_view_transform_set",
 	                                  "rna_ColorManagedViewSettings_view_transform_itemf");
-	RNA_def_property_ui_text(prop, "View Transform", "View used ");
+	RNA_def_property_ui_text(prop, "View Transform", "View used when converting image to a display space");
 	RNA_def_property_update(prop, NC_WINDOW, "rna_ColorManagement_update");
 
 	prop = RNA_def_property(srna, "exposure", PROP_FLOAT, PROP_FACTOR);