From e12c08e8d170b7ca40f204a5b0423c23a9fbc2c1 Mon Sep 17 00:00:00 2001 From: Campbell Barton Date: Wed, 17 Apr 2019 06:17:24 +0200 Subject: 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 --- intern/opencolorio/CMakeLists.txt | 62 +- intern/opencolorio/fallback_impl.cc | 718 +++++++++-------- .../opencolorio/gpu_shader_display_transform.glsl | 183 ++--- .../gpu_shader_display_transform_vertex.glsl | 4 +- intern/opencolorio/ocio_capi.cc | 175 +++-- intern/opencolorio/ocio_capi.h | 179 +++-- intern/opencolorio/ocio_impl.cc | 847 +++++++++++---------- intern/opencolorio/ocio_impl.h | 581 +++++++------- intern/opencolorio/ocio_impl_glsl.cc | 801 +++++++++---------- 9 files changed, 1840 insertions(+), 1710 deletions(-) (limited to 'intern/opencolorio') 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 # include # include -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* 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 *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 default_display_views; - static std::mutex mutex; - mutex.lock(); - /* Check if the view is already known. */ - map::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 active_views; - splitStringEnvStyle(&active_views, active_views_encoded); - /* Get all views supported by tge display. */ - set 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 default_display_views; + static std::mutex mutex; + mutex.lock(); + /* Check if the view is already known. */ + map::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 active_views; + splitStringEnvStyle(&active_views, active_views_encoded); + /* Get all views supported by tge display. */ + set 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::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::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); } -- cgit v1.2.3