Fixed compilation error on widows
authorSergey Sharybin <sergey.vfx@gmail.com>
Fri, 5 Oct 2012 10:05:26 +0000 (10:05 +0000)
committerSergey Sharybin <sergey.vfx@gmail.com>
Fri, 5 Oct 2012 10:05:26 +0000 (10:05 +0000)
Was caused by mixing up own C-API typedefs with OCIO's

intern/opencolorio/CMakeLists.txt
intern/opencolorio/fallback_impl.cc
intern/opencolorio/ocio_capi.cc
intern/opencolorio/ocio_capi.h
intern/opencolorio/ocio_impl.cc
intern/opencolorio/ocio_impl.h
source/blender/imbuf/intern/IMB_colormanagement_intern.h
source/blender/imbuf/intern/colormanagement.c

index fb74d5e3f4e42684fe9078243aedf07faf63c28d..d46b09cf76a1d9c710a6875b20c84a7d855ba582 100644 (file)
@@ -62,4 +62,3 @@ endif()
 
 
 blender_add_lib(bf_intern_opencolorio "${SRC}" "${INC}" "${INC_SYS}")
-
index 4badcc54ebd8ba96ec657fad50eb438ee3ea5f7b..44c02d1442b7e6530cf8c05500c7d559fab53dde 100644 (file)
 #include "MEM_guardedalloc.h"
 #include "BLI_math_color.h"
 
-namespace OCIO_NAMESPACE {};
-
 #include "ocio_impl.h"
 
-#define CONFIG_DEFAULT           ((ConstConfigRcPtr*)1)
+#define CONFIG_DEFAULT           ((OCIO_ConstConfigRcPtr*)1)
 
-#define PROCESSOR_LINEAR_TO_SRGB ((ConstProcessorRcPtr*)1)
-#define PROCESSOR_SRGB_TO_LINEAR ((ConstProcessorRcPtr*)2)
-#define PROCESSOR_UNKNOWN        ((ConstProcessorRcPtr*)3)
+#define PROCESSOR_LINEAR_TO_SRGB ((OCIO_ConstProcessorRcPtr*)1)
+#define PROCESSOR_SRGB_TO_LINEAR ((OCIO_ConstProcessorRcPtr*)2)
+#define PROCESSOR_UNKNOWN        ((OCIO_ConstProcessorRcPtr*)3)
 
-#define COLORSPACE_LINEAR        ((ConstColorSpaceRcPtr*)1)
-#define COLORSPACE_SRGB          ((ConstColorSpaceRcPtr*)2)
+#define COLORSPACE_LINEAR        ((OCIO_ConstColorSpaceRcPtr*)1)
+#define COLORSPACE_SRGB          ((OCIO_ConstColorSpaceRcPtr*)2)
 
-typedef struct PackedImageDescription {
+typedef struct OCIO_PackedImageDescription {
        float *data;
        long width;
        long height;
@@ -49,37 +47,37 @@ typedef struct PackedImageDescription {
        long chanStrideBytes;
        long xStrideBytes;
        long yStrideBytes;
-} PackedImageDescription;
+} OCIO_PackedImageDescription;
 
-ConstConfigRcPtr *FallbackImpl::getCurrentConfig(void)
+OCIO_ConstConfigRcPtr *FallbackImpl::getCurrentConfig(void)
 {
        return CONFIG_DEFAULT;
 }
 
-void FallbackImpl::setCurrentConfig(const ConstConfigRcPtr *)
+void FallbackImpl::setCurrentConfig(const OCIO_ConstConfigRcPtr *)
 {
 }
 
-ConstConfigRcPtr *FallbackImpl::configCreateFromEnv(void)
+OCIO_ConstConfigRcPtr *FallbackImpl::configCreateFromEnv(void)
 {
        return CONFIG_DEFAULT;
 }
 
-ConstConfigRcPtr *FallbackImpl::configCreateFromFile(const char *)
+OCIO_ConstConfigRcPtr *FallbackImpl::configCreateFromFile(const char *)
 {
        return CONFIG_DEFAULT;
 }
 
-void FallbackImpl::configRelease(ConstConfigRcPtr *)
+void FallbackImpl::configRelease(OCIO_ConstConfigRcPtr *)
 {
 }
 
-int FallbackImpl::configGetNumColorSpaces(ConstConfigRcPtr *)
+int FallbackImpl::configGetNumColorSpaces(OCIO_ConstConfigRcPtr *)
 {
        return 2;
 }
 
-const char *FallbackImpl::configGetColorSpaceNameByIndex(ConstConfigRcPtr *, int index)
+const char *FallbackImpl::configGetColorSpaceNameByIndex(OCIO_ConstConfigRcPtr *, int index)
 {
        if (index == 0)
                return "Linear";
@@ -89,7 +87,7 @@ const char *FallbackImpl::configGetColorSpaceNameByIndex(ConstConfigRcPtr *, int
        return NULL;
 }
 
-ConstColorSpaceRcPtr *FallbackImpl::configGetColorSpace(ConstConfigRcPtr *, const char *name)
+OCIO_ConstColorSpaceRcPtr *FallbackImpl::configGetColorSpace(OCIO_ConstConfigRcPtr *, const char *name)
 {
        if (strcmp(name, "scene_linear") == 0)
                return COLORSPACE_LINEAR;
@@ -111,9 +109,9 @@ ConstColorSpaceRcPtr *FallbackImpl::configGetColorSpace(ConstConfigRcPtr *, cons
        return NULL;
 }
 
-int FallbackImpl::configGetIndexForColorSpace(ConstConfigRcPtr *config, const char *name)
+int FallbackImpl::configGetIndexForColorSpace(OCIO_ConstConfigRcPtr *config, const char *name)
 {
-       ConstColorSpaceRcPtr *cs = configGetColorSpace(config, name);
+       OCIO_ConstColorSpaceRcPtr *cs = configGetColorSpace(config, name);
 
        if (cs == COLORSPACE_LINEAR)
                return 0;
@@ -123,17 +121,17 @@ int FallbackImpl::configGetIndexForColorSpace(ConstConfigRcPtr *config, const ch
        return -1;
 }
 
-const char *FallbackImpl::configGetDefaultDisplay(ConstConfigRcPtr *)
+const char *FallbackImpl::configGetDefaultDisplay(OCIO_ConstConfigRcPtr *)
 {
        return "sRGB";
 }
 
-int FallbackImpl::configGetNumDisplays(ConstConfigRcPtr* config)
+int FallbackImpl::configGetNumDisplays(OCIO_ConstConfigRcPtr* config)
 {
        return 1;
 }
 
-const char *FallbackImpl::configGetDisplay(ConstConfigRcPtr *, int index)
+const char *FallbackImpl::configGetDisplay(OCIO_ConstConfigRcPtr *, int index)
 {
        if (index == 0)
                return "sRGB";
@@ -141,17 +139,17 @@ const char *FallbackImpl::configGetDisplay(ConstConfigRcPtr *, int index)
        return NULL;
 }
 
-const char *FallbackImpl::configGetDefaultView(ConstConfigRcPtr *, const char *)
+const char *FallbackImpl::configGetDefaultView(OCIO_ConstConfigRcPtr *, const char *)
 {
        return "Default";
 }
 
-int FallbackImpl::configGetNumViews(ConstConfigRcPtr *, const char *)
+int FallbackImpl::configGetNumViews(OCIO_ConstConfigRcPtr *, const char *)
 {
        return 1;
 }
 
-const char *FallbackImpl::configGetView(ConstConfigRcPtr *, const char *, int index)
+const char *FallbackImpl::configGetView(OCIO_ConstConfigRcPtr *, const char *, int index)
 {
        if (index == 0)
                return "Default";
@@ -159,29 +157,29 @@ const char *FallbackImpl::configGetView(ConstConfigRcPtr *, const char *, int in
        return NULL;
 }
 
-const char *FallbackImpl::configGetDisplayColorSpaceName(ConstConfigRcPtr *, const char *, const char *)
+const char *FallbackImpl::configGetDisplayColorSpaceName(OCIO_ConstConfigRcPtr *, const char *, const char *)
 {
        return "sRGB";
 }
 
-int FallbackImpl::colorSpaceIsInvertible(ConstColorSpaceRcPtr *cs)
+int FallbackImpl::colorSpaceIsInvertible(OCIO_ConstColorSpaceRcPtr *cs)
 {
        return 1;
 }
 
-int FallbackImpl::colorSpaceIsData(ConstColorSpaceRcPtr *cs)
+int FallbackImpl::colorSpaceIsData(OCIO_ConstColorSpaceRcPtr *cs)
 {
        return 0;
 }
 
-void FallbackImpl::colorSpaceRelease(ConstColorSpaceRcPtr *cs)
+void FallbackImpl::colorSpaceRelease(OCIO_ConstColorSpaceRcPtr *cs)
 {
 }
 
-ConstProcessorRcPtr *FallbackImpl::configGetProcessorWithNames(ConstConfigRcPtr *config, const char *srcName, const char *dstName)
+OCIO_ConstProcessorRcPtr *FallbackImpl::configGetProcessorWithNames(OCIO_ConstConfigRcPtr *config, const char *srcName, const char *dstName)
 {
-       ConstColorSpaceRcPtr *cs_src = configGetColorSpace(config, srcName);
-       ConstColorSpaceRcPtr *cs_dst = configGetColorSpace(config, dstName);
+       OCIO_ConstColorSpaceRcPtr *cs_src = configGetColorSpace(config, srcName);
+       OCIO_ConstColorSpaceRcPtr *cs_dst = configGetColorSpace(config, dstName);
 
        if (cs_src == COLORSPACE_LINEAR && cs_dst == COLORSPACE_SRGB)
                return PROCESSOR_LINEAR_TO_SRGB;
@@ -191,15 +189,15 @@ ConstProcessorRcPtr *FallbackImpl::configGetProcessorWithNames(ConstConfigRcPtr
        return 0;
 }
 
-ConstProcessorRcPtr *FallbackImpl::configGetProcessor(ConstConfigRcPtr *, ConstTransformRcPtr *tfm)
+OCIO_ConstProcessorRcPtr *FallbackImpl::configGetProcessor(OCIO_ConstConfigRcPtr *, OCIO_ConstTransformRcPtr *tfm)
 {
-       return (ConstProcessorRcPtr*)tfm;
+       return (OCIO_ConstProcessorRcPtr*)tfm;
 }
 
-void FallbackImpl::processorApply(ConstProcessorRcPtr *processor, PackedImageDesc *img)
+void FallbackImpl::processorApply(OCIO_ConstProcessorRcPtr *processor, OCIO_PackedImageDesc *img)
 {
        /* OCIO_TODO stride not respected, channels must be 3 or 4 */
-       PackedImageDescription *desc = (PackedImageDescription*)img;
+       OCIO_PackedImageDescription *desc = (OCIO_PackedImageDescription*)img;
        int channels = desc->numChannels;
        float *pixels = desc->data;
        int width = desc->width;
@@ -218,10 +216,10 @@ void FallbackImpl::processorApply(ConstProcessorRcPtr *processor, PackedImageDes
        }
 }
 
-void FallbackImpl::processorApply_predivide(ConstProcessorRcPtr *processor, PackedImageDesc *img)
+void FallbackImpl::processorApply_predivide(OCIO_ConstProcessorRcPtr *processor, OCIO_PackedImageDesc *img)
 {
        /* OCIO_TODO stride not respected, channels must be 3 or 4 */
-       PackedImageDescription *desc = (PackedImageDescription*)img;
+       OCIO_PackedImageDescription *desc = (OCIO_PackedImageDescription*)img;
        int channels = desc->numChannels;
        float *pixels = desc->data;
        int width = desc->width;
@@ -240,7 +238,7 @@ void FallbackImpl::processorApply_predivide(ConstProcessorRcPtr *processor, Pack
        }
 }
 
-void FallbackImpl::processorApplyRGB(ConstProcessorRcPtr *processor, float *pixel)
+void FallbackImpl::processorApplyRGB(OCIO_ConstProcessorRcPtr *processor, float *pixel)
 {
        if (processor == PROCESSOR_LINEAR_TO_SRGB)
                linearrgb_to_srgb_v3_v3(pixel, pixel);
@@ -248,7 +246,7 @@ void FallbackImpl::processorApplyRGB(ConstProcessorRcPtr *processor, float *pixe
                srgb_to_linearrgb_v3_v3(pixel, pixel);
 }
 
-void FallbackImpl::processorApplyRGBA(ConstProcessorRcPtr *processor, float *pixel)
+void FallbackImpl::processorApplyRGBA(OCIO_ConstProcessorRcPtr *processor, float *pixel)
 {
        if (processor == PROCESSOR_LINEAR_TO_SRGB)
                linearrgb_to_srgb_v4(pixel, pixel);
@@ -256,7 +254,7 @@ void FallbackImpl::processorApplyRGBA(ConstProcessorRcPtr *processor, float *pix
                srgb_to_linearrgb_v4(pixel, pixel);
 }
 
-void FallbackImpl::processorApplyRGBA_predivide(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);
@@ -279,11 +277,11 @@ void FallbackImpl::processorApplyRGBA_predivide(ConstProcessorRcPtr *processor,
        }
 }
 
-void FallbackImpl::processorRelease(ConstProcessorRcPtr *)
+void FallbackImpl::processorRelease(OCIO_ConstProcessorRcPtr *)
 {
 }
 
-const char *FallbackImpl::colorSpaceGetName(ConstColorSpaceRcPtr *cs)
+const char *FallbackImpl::colorSpaceGetName(OCIO_ConstColorSpaceRcPtr *cs)
 {
        if (cs == COLORSPACE_LINEAR)
                return "Linear";
@@ -293,49 +291,49 @@ const char *FallbackImpl::colorSpaceGetName(ConstColorSpaceRcPtr *cs)
        return NULL;
 }
 
-const char *FallbackImpl::colorSpaceGetDescription(ConstColorSpaceRcPtr *)
+const char *FallbackImpl::colorSpaceGetDescription(OCIO_ConstColorSpaceRcPtr *)
 {
        return "";
 }
 
-const char *FallbackImpl::colorSpaceGetFamily(ConstColorSpaceRcPtr *)
+const char *FallbackImpl::colorSpaceGetFamily(OCIO_ConstColorSpaceRcPtr *)
 {
        return "";
 }
 
-DisplayTransformRcPtr *FallbackImpl::createDisplayTransform(void)
+OCIO_DisplayTransformRcPtr *FallbackImpl::createDisplayTransform(void)
 {
-       return (DisplayTransformRcPtr*)PROCESSOR_LINEAR_TO_SRGB;
+       return (OCIO_DisplayTransformRcPtr*)PROCESSOR_LINEAR_TO_SRGB;
 }
 
-void FallbackImpl::displayTransformSetInputColorSpaceName(DisplayTransformRcPtr *, const char *)
+void FallbackImpl::displayTransformSetInputColorSpaceName(OCIO_DisplayTransformRcPtr *, const char *)
 {
 }
 
-void FallbackImpl::displayTransformSetDisplay(DisplayTransformRcPtr *, const char *)
+void FallbackImpl::displayTransformSetDisplay(OCIO_DisplayTransformRcPtr *, const char *)
 {
 }
 
-void FallbackImpl::displayTransformSetView(DisplayTransformRcPtr *, const char *)
+void FallbackImpl::displayTransformSetView(OCIO_DisplayTransformRcPtr *, const char *)
 {
 }
 
-void FallbackImpl::displayTransformSetDisplayCC(DisplayTransformRcPtr *, ConstTransformRcPtr *)
+void FallbackImpl::displayTransformSetDisplayCC(OCIO_DisplayTransformRcPtr *, OCIO_ConstTransformRcPtr *)
 {
 }
 
-void FallbackImpl::displayTransformSetLinearCC(DisplayTransformRcPtr *, ConstTransformRcPtr *)
+void FallbackImpl::displayTransformSetLinearCC(OCIO_DisplayTransformRcPtr *, OCIO_ConstTransformRcPtr *)
 {
 }
 
-void FallbackImpl::displayTransformRelease(DisplayTransformRcPtr *)
+void FallbackImpl::displayTransformRelease(OCIO_DisplayTransformRcPtr *)
 {
 }
 
-PackedImageDesc *FallbackImpl::createPackedImageDesc(float *data, long width, long height, long numChannels,
+OCIO_PackedImageDesc *FallbackImpl::createOCIO_PackedImageDesc(float *data, long width, long height, long numChannels,
                                                      long chanStrideBytes, long xStrideBytes, long yStrideBytes)
 {
-       PackedImageDescription *desc = (PackedImageDescription*)MEM_callocN(sizeof(PackedImageDescription), "PackedImageDescription");
+       OCIO_PackedImageDescription *desc = (OCIO_PackedImageDescription*)MEM_callocN(sizeof(OCIO_PackedImageDescription), "OCIO_PackedImageDescription");
 
        desc->data = data;
        desc->width = width;
@@ -345,37 +343,37 @@ PackedImageDesc *FallbackImpl::createPackedImageDesc(float *data, long width, lo
        desc->xStrideBytes = xStrideBytes;
        desc->yStrideBytes = yStrideBytes;
 
-       return (PackedImageDesc*)desc;
+       return (OCIO_PackedImageDesc*)desc;
 }
 
-void FallbackImpl::packedImageDescRelease(PackedImageDesc* id)
+void FallbackImpl::OCIO_PackedImageDescRelease(OCIO_PackedImageDesc* id)
 {
        MEM_freeN(id);
 }
 
-ExponentTransformRcPtr *FallbackImpl::createExponentTransform(void)
+OCIO_ExponentTransformRcPtr *FallbackImpl::createExponentTransform(void)
 {
-       return (ExponentTransformRcPtr*)PROCESSOR_UNKNOWN;
+       return (OCIO_ExponentTransformRcPtr*)PROCESSOR_UNKNOWN;
 }
 
-void FallbackImpl::exponentTransformSetValue(ExponentTransformRcPtr *, const float *)
+void FallbackImpl::exponentTransformSetValue(OCIO_ExponentTransformRcPtr *, const float *)
 {
 }
 
-void FallbackImpl::exponentTransformRelease(ExponentTransformRcPtr *)
+void FallbackImpl::exponentTransformRelease(OCIO_ExponentTransformRcPtr *)
 {
 }
 
-MatrixTransformRcPtr *FallbackImpl::createMatrixTransform(void)
+OCIO_MatrixTransformRcPtr *FallbackImpl::createMatrixTransform(void)
 {
-       return (MatrixTransformRcPtr*)PROCESSOR_UNKNOWN;
+       return (OCIO_MatrixTransformRcPtr*)PROCESSOR_UNKNOWN;
 }
 
-void FallbackImpl::matrixTransformSetValue(MatrixTransformRcPtr *, const float *, const float *)
+void FallbackImpl::matrixTransformSetValue(OCIO_MatrixTransformRcPtr *, const float *, const float *)
 {
 }
 
-void FallbackImpl::matrixTransformRelease(MatrixTransformRcPtr *)
+void FallbackImpl::matrixTransformRelease(OCIO_MatrixTransformRcPtr *)
 {
 }
 
index 20e7cc23daa6f3d3a051e3c119fd38a2e08d4203..18fa4b7cb1bf8f64eb4e9002e89d8023028d5cbb 100644 (file)
@@ -25,8 +25,6 @@
 
 #include "MEM_guardedalloc.h"
 
-namespace OCIO_NAMESPACE {};
-
 #include "ocio_impl.h"
 
 static IOCIOImpl *impl = NULL;
@@ -46,12 +44,12 @@ void OCIO_exit(void)
        impl = NULL;
 }
 
-ConstConfigRcPtr *OCIO_getCurrentConfig(void)
+OCIO_ConstConfigRcPtr *OCIO_getCurrentConfig(void)
 {
        return impl->getCurrentConfig();
 }
 
-ConstConfigRcPtr *OCIO_configCreateFallback(void)
+OCIO_ConstConfigRcPtr *OCIO_configCreateFallback(void)
 {
        delete impl;
        impl = new FallbackImpl();
@@ -59,223 +57,223 @@ ConstConfigRcPtr *OCIO_configCreateFallback(void)
        return impl->getCurrentConfig();
 }
 
-void OCIO_setCurrentConfig(const ConstConfigRcPtr *config)
+void OCIO_setCurrentConfig(const OCIO_ConstConfigRcPtr *config)
 {
        impl->setCurrentConfig(config);
 }
 
-ConstConfigRcPtr *OCIO_configCreateFromEnv(void)
+OCIO_ConstConfigRcPtr *OCIO_configCreateFromEnv(void)
 {
        return impl->configCreateFromEnv();
 }
 
-ConstConfigRcPtr *OCIO_configCreateFromFile(const char *filename)
+OCIO_ConstConfigRcPtr *OCIO_configCreateFromFile(const char *filename)
 {
        return impl->configCreateFromFile(filename);
 }
 
-void OCIO_configRelease(ConstConfigRcPtr *config)
+void OCIO_configRelease(OCIO_ConstConfigRcPtr *config)
 {
        impl->configRelease(config);
 }
 
-int OCIO_configGetNumColorSpaces(ConstConfigRcPtr *config)
+int OCIO_configGetNumColorSpaces(OCIO_ConstConfigRcPtr *config)
 {
        return impl->configGetNumColorSpaces(config);
 }
 
-const char *OCIO_configGetColorSpaceNameByIndex(ConstConfigRcPtr *config, int index)
+const char *OCIO_configGetColorSpaceNameByIndex(OCIO_ConstConfigRcPtr *config, int index)
 {
        return impl->configGetColorSpaceNameByIndex(config, index);
 }
 
-ConstColorSpaceRcPtr *OCIO_configGetColorSpace(ConstConfigRcPtr *config, const char *name)
+OCIO_ConstColorSpaceRcPtr *OCIO_configGetColorSpace(OCIO_ConstConfigRcPtr *config, const char *name)
 {
        return impl->configGetColorSpace(config, name);
 }
 
-int OCIO_configGetIndexForColorSpace(ConstConfigRcPtr *config, const char *name)
+int OCIO_configGetIndexForColorSpace(OCIO_ConstConfigRcPtr *config, const char *name)
 {
        return impl->configGetIndexForColorSpace(config, name);
 }
 
-const char *OCIO_configGetDefaultDisplay(ConstConfigRcPtr *config)
+const char *OCIO_configGetDefaultDisplay(OCIO_ConstConfigRcPtr *config)
 {
        return impl->configGetDefaultDisplay(config);
 }
 
-int OCIO_configGetNumDisplays(ConstConfigRcPtr* config)
+int OCIO_configGetNumDisplays(OCIO_ConstConfigRcPtr* config)
 {
        return impl->configGetNumDisplays(config);
 }
 
-const char *OCIO_configGetDisplay(ConstConfigRcPtr *config, int index)
+const char *OCIO_configGetDisplay(OCIO_ConstConfigRcPtr *config, int index)
 {
        return impl->configGetDisplay(config, index);
 }
 
-const char *OCIO_configGetDefaultView(ConstConfigRcPtr *config, const char *display)
+const char *OCIO_configGetDefaultView(OCIO_ConstConfigRcPtr *config, const char *display)
 {
        return impl->configGetDefaultView(config, display);
 }
 
-int OCIO_configGetNumViews(ConstConfigRcPtr *config, const char *display)
+int OCIO_configGetNumViews(OCIO_ConstConfigRcPtr *config, const char *display)
 {
        return impl->configGetNumViews(config, display);
 }
 
-const char *OCIO_configGetView(ConstConfigRcPtr *config, const char *display, int index)
+const char *OCIO_configGetView(OCIO_ConstConfigRcPtr *config, const char *display, int index)
 {
        return impl->configGetView(config, display, index);
 }
 
-const char *OCIO_configGetDisplayColorSpaceName(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);
 }
 
-int OCIO_colorSpaceIsInvertible(ConstColorSpaceRcPtr *cs)
+int OCIO_colorSpaceIsInvertible(OCIO_ConstColorSpaceRcPtr *cs)
 {
        return impl->colorSpaceIsInvertible(cs);
 }
 
-int OCIO_colorSpaceIsData(ConstColorSpaceRcPtr *cs)
+int OCIO_colorSpaceIsData(OCIO_ConstColorSpaceRcPtr *cs)
 {
        return impl->colorSpaceIsData(cs);
 }
 
-void OCIO_colorSpaceRelease(ConstColorSpaceRcPtr *cs)
+void OCIO_colorSpaceRelease(OCIO_ConstColorSpaceRcPtr *cs)
 {
        impl->colorSpaceRelease(cs);
 }
 
-ConstProcessorRcPtr *OCIO_configGetProcessorWithNames(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);
 }
 
-ConstProcessorRcPtr *OCIO_configGetProcessor(ConstConfigRcPtr *config, ConstTransformRcPtr *transform)
+OCIO_ConstProcessorRcPtr *OCIO_configGetProcessor(OCIO_ConstConfigRcPtr *config, OCIO_ConstTransformRcPtr *transform)
 {
        return impl->configGetProcessor(config, transform);
 }
 
-void OCIO_processorApply(ConstProcessorRcPtr *processor, PackedImageDesc *img)
+void OCIO_processorApply(OCIO_ConstProcessorRcPtr *processor, OCIO_PackedImageDesc *img)
 {
        impl->processorApply(processor, img);
 }
 
-void OCIO_processorApply_predivide(ConstProcessorRcPtr *processor, PackedImageDesc *img)
+void OCIO_processorApply_predivide(OCIO_ConstProcessorRcPtr *processor, OCIO_PackedImageDesc *img)
 {
        impl->processorApply_predivide(processor, img);
 }
 
-void OCIO_processorApplyRGB(ConstProcessorRcPtr *processor, float *pixel)
+void OCIO_processorApplyRGB(OCIO_ConstProcessorRcPtr *processor, float *pixel)
 {
        impl->processorApplyRGB(processor, pixel);
 }
 
-void OCIO_processorApplyRGBA(ConstProcessorRcPtr *processor, float *pixel)
+void OCIO_processorApplyRGBA(OCIO_ConstProcessorRcPtr *processor, float *pixel)
 {
        impl->processorApplyRGBA(processor, pixel);
 }
 
-void OCIO_processorApplyRGBA_predivide(ConstProcessorRcPtr *processor, float *pixel)
+void OCIO_processorApplyRGBA_predivide(OCIO_ConstProcessorRcPtr *processor, float *pixel)
 {
        impl->processorApplyRGBA_predivide(processor, pixel);
 }
 
-void OCIO_processorRelease(ConstProcessorRcPtr *p)
+void OCIO_processorRelease(OCIO_ConstProcessorRcPtr *p)
 {
        impl->processorRelease(p);
 }
 
-const char *OCIO_colorSpaceGetName(ConstColorSpaceRcPtr *cs)
+const char *OCIO_colorSpaceGetName(OCIO_ConstColorSpaceRcPtr *cs)
 {
        return impl->colorSpaceGetName(cs);
 }
 
-const char *OCIO_colorSpaceGetDescription(ConstColorSpaceRcPtr *cs)
+const char *OCIO_colorSpaceGetDescription(OCIO_ConstColorSpaceRcPtr *cs)
 {
        return impl->colorSpaceGetDescription(cs);
 }
 
-const char *OCIO_colorSpaceGetFamily(ConstColorSpaceRcPtr *cs)
+const char *OCIO_colorSpaceGetFamily(OCIO_ConstColorSpaceRcPtr *cs)
 {
        return impl->colorSpaceGetFamily(cs);
 }
 
-DisplayTransformRcPtr *OCIO_createDisplayTransform(void)
+OCIO_DisplayTransformRcPtr *OCIO_createDisplayTransform(void)
 {
        return impl->createDisplayTransform();
 }
 
-void OCIO_displayTransformSetInputColorSpaceName(DisplayTransformRcPtr *dt, const char *name)
+void OCIO_displayTransformSetInputColorSpaceName(OCIO_DisplayTransformRcPtr *dt, const char *name)
 {
        impl->displayTransformSetInputColorSpaceName(dt, name);
 }
 
-void OCIO_displayTransformSetDisplay(DisplayTransformRcPtr *dt, const char *name)
+void OCIO_displayTransformSetDisplay(OCIO_DisplayTransformRcPtr *dt, const char *name)
 {
        impl->displayTransformSetDisplay(dt, name);
 }
 
-void OCIO_displayTransformSetView(DisplayTransformRcPtr *dt, const char *name)
+void OCIO_displayTransformSetView(OCIO_DisplayTransformRcPtr *dt, const char *name)
 {
        impl->displayTransformSetView(dt, name);
 }
 
-void OCIO_displayTransformSetDisplayCC(DisplayTransformRcPtr *dt, ConstTransformRcPtr *t)
+void OCIO_displayTransformSetDisplayCC(OCIO_DisplayTransformRcPtr *dt, OCIO_ConstTransformRcPtr *t)
 {
        impl->displayTransformSetDisplayCC(dt, t);
 }
 
-void OCIO_displayTransformSetLinearCC(DisplayTransformRcPtr *dt, ConstTransformRcPtr *t)
+void OCIO_displayTransformSetLinearCC(OCIO_DisplayTransformRcPtr *dt, OCIO_ConstTransformRcPtr *t)
 {
        impl->displayTransformSetLinearCC(dt, t);
 }
 
-void OCIO_displayTransformRelease(DisplayTransformRcPtr *dt)
+void OCIO_displayTransformRelease(OCIO_DisplayTransformRcPtr *dt)
 {
        impl->displayTransformRelease(dt);
 }
 
-PackedImageDesc *OCIO_createPackedImageDesc(float *data, long width, long height, long numChannels,
+OCIO_PackedImageDesc *OCIO_createOCIO_PackedImageDesc(float *data, long width, long height, long numChannels,
                                             long chanStrideBytes, long xStrideBytes, long yStrideBytes)
 {
-       return impl->createPackedImageDesc(data, width, height, numChannels, chanStrideBytes, xStrideBytes, yStrideBytes);
+       return impl->createOCIO_PackedImageDesc(data, width, height, numChannels, chanStrideBytes, xStrideBytes, yStrideBytes);
 }
 
-void OCIO_packedImageDescRelease(PackedImageDesc* id)
+void OCIO_OCIO_PackedImageDescRelease(OCIO_PackedImageDesc* id)
 {
-       impl->packedImageDescRelease(id);
+       impl->OCIO_PackedImageDescRelease(id);
 }
 
-ExponentTransformRcPtr *OCIO_createExponentTransform(void)
+OCIO_ExponentTransformRcPtr *OCIO_createExponentTransform(void)
 {
        return impl->createExponentTransform();
 }
 
-void OCIO_exponentTransformSetValue(ExponentTransformRcPtr *et, const float *exponent)
+void OCIO_exponentTransformSetValue(OCIO_ExponentTransformRcPtr *et, const float *exponent)
 {
        impl->exponentTransformSetValue(et, exponent);
 }
 
-void OCIO_exponentTransformRelease(ExponentTransformRcPtr *et)
+void OCIO_exponentTransformRelease(OCIO_ExponentTransformRcPtr *et)
 {
        impl->exponentTransformRelease(et);
 }
 
-MatrixTransformRcPtr *OCIO_createMatrixTransform(void)
+OCIO_MatrixTransformRcPtr *OCIO_createMatrixTransform(void)
 {
        return impl->createMatrixTransform();
 }
 
-void OCIO_matrixTransformSetValue(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);
 }
 
-void OCIO_matrixTransformRelease(MatrixTransformRcPtr *mt)
+void OCIO_matrixTransformRelease(OCIO_MatrixTransformRcPtr *mt)
 {
        impl->matrixTransformRelease(mt);
 }
index f924bffb8e078eb10b9b9cb3d44435d6d6bc3433..0ce5f8a145685bb224e731a290a6785d0aa9940d 100644 (file)
 #define __OCIO_CAPI_H__
 
 #ifdef __cplusplus
-using namespace OCIO_NAMESPACE;
 extern "C" {
 #endif
 
 #define OCIO_DECLARE_HANDLE(name) typedef struct name##__ { int unused; } *name
 
-#ifndef OCIO_CAPI_IMPLEMENTATION
-       #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(ConstConfigRcPtr);
-       OCIO_DECLARE_HANDLE(ConstColorSpaceRcPtr);
-       OCIO_DECLARE_HANDLE(ConstProcessorRcPtr);
-       OCIO_DECLARE_HANDLE(ConstContextRcPtr);
-       OCIO_DECLARE_HANDLE(PackedImageDesc);
-       OCIO_DECLARE_HANDLE(DisplayTransformRcPtr);
-       OCIO_DECLARE_HANDLE(ConstTransformRcPtr);
-       OCIO_DECLARE_HANDLE(ExponentTransformRcPtr);
-       OCIO_DECLARE_HANDLE(MatrixTransformRcPtr);
-#endif
+#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);
+OCIO_DECLARE_HANDLE(OCIO_ConstProcessorRcPtr);
+OCIO_DECLARE_HANDLE(OCIO_ConstContextRcPtr);
+OCIO_DECLARE_HANDLE(OCIO_PackedImageDesc);
+OCIO_DECLARE_HANDLE(OCIO_DisplayTransformRcPtr);
+OCIO_DECLARE_HANDLE(OCIO_ConstTransformRcPtr);
+OCIO_DECLARE_HANDLE(OCIO_ExponentTransformRcPtr);
+OCIO_DECLARE_HANDLE(OCIO_MatrixTransformRcPtr);
 
 void OCIO_init(void);
 void OCIO_exit(void);
 
-ConstConfigRcPtr *OCIO_getCurrentConfig(void);
-void OCIO_setCurrentConfig(const ConstConfigRcPtr *config);
+OCIO_ConstConfigRcPtr *OCIO_getCurrentConfig(void);
+void OCIO_setCurrentConfig(const OCIO_ConstConfigRcPtr *config);
 
-ConstConfigRcPtr *OCIO_configCreateFromEnv(void);
-ConstConfigRcPtr *OCIO_configCreateFromFile(const char* filename);
-ConstConfigRcPtr *OCIO_configCreateFallback(void);
+OCIO_ConstConfigRcPtr *OCIO_configCreateFromEnv(void);
+OCIO_ConstConfigRcPtr *OCIO_configCreateFromFile(const char* filename);
+OCIO_ConstConfigRcPtr *OCIO_configCreateFallback(void);
 
-void OCIO_configRelease(ConstConfigRcPtr *config);
+void OCIO_configRelease(OCIO_ConstConfigRcPtr *config);
 
-int OCIO_configGetNumColorSpaces(ConstConfigRcPtr *config);
-const char *OCIO_configGetColorSpaceNameByIndex(ConstConfigRcPtr *config, int index);
-ConstColorSpaceRcPtr *OCIO_configGetColorSpace(ConstConfigRcPtr *config, const char *name);
-int OCIO_configGetIndexForColorSpace(ConstConfigRcPtr *config, const char *name);
+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);
+int OCIO_configGetIndexForColorSpace(OCIO_ConstConfigRcPtr *config, const char *name);
 
-int OCIO_colorSpaceIsInvertible(ConstColorSpaceRcPtr *cs);
-int OCIO_colorSpaceIsData(ConstColorSpaceRcPtr *cs);
+int OCIO_colorSpaceIsInvertible(OCIO_ConstColorSpaceRcPtr *cs);
+int OCIO_colorSpaceIsData(OCIO_ConstColorSpaceRcPtr *cs);
 
-void OCIO_colorSpaceRelease(ConstColorSpaceRcPtr *cs);
+void OCIO_colorSpaceRelease(OCIO_ConstColorSpaceRcPtr *cs);
 
-const char *OCIO_configGetDefaultDisplay(ConstConfigRcPtr *config);
-int         OCIO_configGetNumDisplays(ConstConfigRcPtr *config);
-const char *OCIO_configGetDisplay(ConstConfigRcPtr *config, int index);
-const char *OCIO_configGetDefaultView(ConstConfigRcPtr *config, const char *display);
-int         OCIO_configGetNumViews(ConstConfigRcPtr *config, const char *display);
-const char *OCIO_configGetView(ConstConfigRcPtr *config, const char *display, int index);
-const char *OCIO_configGetDisplayColorSpaceName(ConstConfigRcPtr *config, const char *display, const char *view);
+const char *OCIO_configGetDefaultDisplay(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);
+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);
 
-ConstProcessorRcPtr *OCIO_configGetProcessorWithNames(ConstConfigRcPtr *config, const char *srcName, const char *dstName);
-ConstProcessorRcPtr *OCIO_configGetProcessor(ConstConfigRcPtr *config, 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(ConstProcessorRcPtr *processor, PackedImageDesc *img);
-void OCIO_processorApply_predivide(ConstProcessorRcPtr *processor, PackedImageDesc *img);
-void OCIO_processorApplyRGB(ConstProcessorRcPtr *processor, float *pixel);
-void OCIO_processorApplyRGBA(ConstProcessorRcPtr *processor, float *pixel);
-void OCIO_processorApplyRGBA_predivide(ConstProcessorRcPtr *processor, float *pixel);
+void OCIO_processorApply(OCIO_ConstProcessorRcPtr *processor, OCIO_PackedImageDesc *img);
+void OCIO_processorApply_predivide(OCIO_ConstProcessorRcPtr *processor, OCIO_PackedImageDesc *img);
+void OCIO_processorApplyRGB(OCIO_ConstProcessorRcPtr *processor, float *pixel);
+void OCIO_processorApplyRGBA(OCIO_ConstProcessorRcPtr *processor, float *pixel);
+void OCIO_processorApplyRGBA_predivide(OCIO_ConstProcessorRcPtr *processor, float *pixel);
 
-void OCIO_processorRelease(ConstProcessorRcPtr *p);
+void OCIO_processorRelease(OCIO_ConstProcessorRcPtr *p);
 
-const char *OCIO_colorSpaceGetName(ConstColorSpaceRcPtr *cs);
-const char *OCIO_colorSpaceGetDescription(ConstColorSpaceRcPtr *cs);
-const char *OCIO_colorSpaceGetFamily(ConstColorSpaceRcPtr *cs);
+const char *OCIO_colorSpaceGetName(OCIO_ConstColorSpaceRcPtr *cs);
+const char *OCIO_colorSpaceGetDescription(OCIO_ConstColorSpaceRcPtr *cs);
+const char *OCIO_colorSpaceGetFamily(OCIO_ConstColorSpaceRcPtr *cs);
 
-DisplayTransformRcPtr *OCIO_createDisplayTransform(void);
-void OCIO_displayTransformSetInputColorSpaceName(DisplayTransformRcPtr *dt, const char *name);
-void OCIO_displayTransformSetDisplay(DisplayTransformRcPtr *dt, const char *name);
-void OCIO_displayTransformSetView(DisplayTransformRcPtr *dt, const char *name);
-void OCIO_displayTransformSetDisplayCC(DisplayTransformRcPtr *dt, ConstTransformRcPtr *et);
-void OCIO_displayTransformSetLinearCC(DisplayTransformRcPtr *dt, ConstTransformRcPtr *et);
-void OCIO_displayTransformRelease(DisplayTransformRcPtr *dt);
+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_displayTransformRelease(OCIO_DisplayTransformRcPtr *dt);
 
-PackedImageDesc *OCIO_createPackedImageDesc(float *data, long width, long height, long numChannels,
+OCIO_PackedImageDesc *OCIO_createOCIO_PackedImageDesc(float *data, long width, long height, long numChannels,
                                             long chanStrideBytes, long xStrideBytes, long yStrideBytes);
 
-void OCIO_packedImageDescRelease(PackedImageDesc *p);
+void OCIO_OCIO_PackedImageDescRelease(OCIO_PackedImageDesc *p);
 
-ExponentTransformRcPtr *OCIO_createExponentTransform(void);
-void OCIO_exponentTransformSetValue(ExponentTransformRcPtr *et, const float *exponent);
-void OCIO_exponentTransformRelease(ExponentTransformRcPtr *et);
+OCIO_ExponentTransformRcPtr *OCIO_createExponentTransform(void);
+void OCIO_exponentTransformSetValue(OCIO_ExponentTransformRcPtr *et, const float *exponent);
+void OCIO_exponentTransformRelease(OCIO_ExponentTransformRcPtr *et);
 
-MatrixTransformRcPtr *OCIO_createMatrixTransform(void);
-void OCIO_matrixTransformSetValue(MatrixTransformRcPtr *et, const float *m44, const float *offset4);
-void OCIO_matrixTransformRelease(MatrixTransformRcPtr *mt);
+OCIO_MatrixTransformRcPtr *OCIO_createMatrixTransform(void);
+void OCIO_matrixTransformSetValue(OCIO_MatrixTransformRcPtr *et, const float *m44, const float *offset4);
+void OCIO_matrixTransformRelease(OCIO_MatrixTransformRcPtr *mt);
 
 void OCIO_matrixTransformScale(float * m44, float * offset4, const float * scale4);
 
index 5d5c66cd356fe1314812de58c9ee893878e8c826..49fc44d1e12cc39865a72d211d7a87e63ce2f448 100644 (file)
 
 #include <OpenColorIO/OpenColorIO.h>
 
+using namespace OCIO_NAMESPACE;
+
 #include "MEM_guardedalloc.h"
 
-#define OCIO_CAPI_IMPLEMENTATION
 #include "ocio_impl.h"
 
 #if !defined(WITH_ASSERT_ABORT)
@@ -47,7 +48,7 @@
 #endif
 
 #define MEM_NEW(type) new(MEM_mallocN(sizeof(type), __func__)) type()
-#define MEM_DELETE(what, type) if(what) { what->~type(); MEM_freeN(what); } (void)0
+#define MEM_DELETE(what, type) if(what) { (what)->~type(); MEM_freeN(what); } (void)0
 
 static void OCIO_reportError(const char *err)
 {
@@ -61,15 +62,15 @@ static void OCIO_reportException(Exception &exception)
        OCIO_reportError(exception.what());
 }
 
-ConstConfigRcPtr *OCIOImpl::getCurrentConfig(void)
+OCIO_ConstConfigRcPtr *OCIOImpl::getCurrentConfig(void)
 {
        ConstConfigRcPtr *config = MEM_NEW(ConstConfigRcPtr);
 
        try {
                *config = GetCurrentConfig();
 
-               if(*config)
-                       return config;
+               if (*config)
+                       return (OCIO_ConstConfigRcPtr *) config;
        }
        catch (Exception &exception) {
                OCIO_reportException(exception);
@@ -80,17 +81,17 @@ ConstConfigRcPtr *OCIOImpl::getCurrentConfig(void)
        return NULL;
 }
 
-void OCIOImpl::setCurrentConfig(const ConstConfigRcPtr *config)
+void OCIOImpl::setCurrentConfig(const OCIO_ConstConfigRcPtr *config)
 {
        try {
-               SetCurrentConfig(*config);
+               SetCurrentConfig(*(ConstConfigRcPtr *) config);
        }
        catch (Exception &exception) {
                OCIO_reportException(exception);
        }
 }
 
-ConstConfigRcPtr *OCIOImpl::configCreateFromEnv(void)
+OCIO_ConstConfigRcPtr *OCIOImpl::configCreateFromEnv(void)
 {
        ConstConfigRcPtr *config = MEM_NEW(ConstConfigRcPtr);
 
@@ -98,7 +99,7 @@ ConstConfigRcPtr *OCIOImpl::configCreateFromEnv(void)
                *config = Config::CreateFromEnv();
 
                if (*config)
-                       return config;
+                       return (OCIO_ConstConfigRcPtr *) config;
        }
        catch (Exception &exception) {
                OCIO_reportException(exception);
@@ -110,7 +111,7 @@ ConstConfigRcPtr *OCIOImpl::configCreateFromEnv(void)
 }
 
 
-ConstConfigRcPtr *OCIOImpl::configCreateFromFile(const char *filename)
+OCIO_ConstConfigRcPtr *OCIOImpl::configCreateFromFile(const char *filename)
 {
        ConstConfigRcPtr *config = MEM_NEW(ConstConfigRcPtr);
 
@@ -118,7 +119,7 @@ ConstConfigRcPtr *OCIOImpl::configCreateFromFile(const char *filename)
                *config = Config::CreateFromFile(filename);
 
                if (*config)
-                       return config;
+                       return (OCIO_ConstConfigRcPtr *) config;
        }
        catch (Exception &exception) {
                OCIO_reportException(exception);
@@ -129,15 +130,15 @@ ConstConfigRcPtr *OCIOImpl::configCreateFromFile(const char *filename)
        return NULL;
 }
 
-void OCIOImpl::configRelease(ConstConfigRcPtr *config)
+void OCIOImpl::configRelease(OCIO_ConstConfigRcPtr *config)
 {
-       MEM_DELETE(config, ConstConfigRcPtr);
+       MEM_DELETE((ConstConfigRcPtr *) config, ConstConfigRcPtr);
 }
 
-int OCIOImpl::configGetNumColorSpaces(ConstConfigRcPtr *config)
+int OCIOImpl::configGetNumColorSpaces(OCIO_ConstConfigRcPtr *config)
 {
        try {
-               return (*config)->getNumColorSpaces();
+               return (*(ConstConfigRcPtr *) config)->getNumColorSpaces();
        }
        catch (Exception &exception) {
                OCIO_reportException(exception);
@@ -146,10 +147,10 @@ int OCIOImpl::configGetNumColorSpaces(ConstConfigRcPtr *config)
        return 0;
 }
 
-const char *OCIOImpl::configGetColorSpaceNameByIndex(ConstConfigRcPtr *config, int index)
+const char *OCIOImpl::configGetColorSpaceNameByIndex(OCIO_ConstConfigRcPtr *config, int index)
 {
        try {
-               return (*config)->getColorSpaceNameByIndex(index);
+               return (*(ConstConfigRcPtr *) config)->getColorSpaceNameByIndex(index);
        }
        catch (Exception &exception) {
                OCIO_reportException(exception);
@@ -158,15 +159,15 @@ const char *OCIOImpl::configGetColorSpaceNameByIndex(ConstConfigRcPtr *config, i
        return NULL;
 }
 
-ConstColorSpaceRcPtr *OCIOImpl::configGetColorSpace(ConstConfigRcPtr *config, const char *name)
+OCIO_ConstColorSpaceRcPtr *OCIOImpl::configGetColorSpace(OCIO_ConstConfigRcPtr *config, const char *name)
 {
        ConstColorSpaceRcPtr *cs = MEM_NEW(ConstColorSpaceRcPtr);
 
        try {
-               *cs = (*config)->getColorSpace(name);
+               *cs = (*(ConstConfigRcPtr *) config)->getColorSpace(name);
 
                if (*cs)
-                       return cs;
+                       return (OCIO_ConstColorSpaceRcPtr *) cs;
        }
        catch (Exception &exception) {
                OCIO_reportException(exception);
@@ -177,10 +178,10 @@ ConstColorSpaceRcPtr *OCIOImpl::configGetColorSpace(ConstConfigRcPtr *config, co
        return NULL;
 }
 
-int OCIOImpl::configGetIndexForColorSpace(ConstConfigRcPtr *config, const char *name)
+int OCIOImpl::configGetIndexForColorSpace(OCIO_ConstConfigRcPtr *config, const char *name)
 {
        try {
-               return (*config)->getIndexForColorSpace(name);
+               return (*(ConstConfigRcPtr *) config)->getIndexForColorSpace(name);
        }
        catch (Exception &exception) {
                OCIO_reportException(exception);
@@ -189,10 +190,10 @@ int OCIOImpl::configGetIndexForColorSpace(ConstConfigRcPtr *config, const char *
        return -1;
 }
 
-const char *OCIOImpl::configGetDefaultDisplay(ConstConfigRcPtr *config)
+const char *OCIOImpl::configGetDefaultDisplay(OCIO_ConstConfigRcPtr *config)
 {
        try {
-               return (*config)->getDefaultDisplay();
+               return (*(ConstConfigRcPtr *) config)->getDefaultDisplay();
        }
        catch (Exception &exception) {
                OCIO_reportException(exception);
@@ -201,10 +202,10 @@ const char *OCIOImpl::configGetDefaultDisplay(ConstConfigRcPtr *config)
        return NULL;
 }
 
-int OCIOImpl::configGetNumDisplays(ConstConfigRcPtr* config)
+int OCIOImpl::configGetNumDisplays(OCIO_ConstConfigRcPtr* config)
 {
        try {
-               return (*config)->getNumDisplays();
+               return (*(ConstConfigRcPtr *) config)->getNumDisplays();
        }
        catch (Exception &exception) {
                OCIO_reportException(exception);
@@ -213,10 +214,10 @@ int OCIOImpl::configGetNumDisplays(ConstConfigRcPtr* config)
        return 0;
 }
 
-const char *OCIOImpl::configGetDisplay(ConstConfigRcPtr *config, int index)
+const char *OCIOImpl::configGetDisplay(OCIO_ConstConfigRcPtr *config, int index)
 {
        try {
-               return (*config)->getDisplay(index);
+               return (*(ConstConfigRcPtr *) config)->getDisplay(index);
        }
        catch (Exception &exception) {
                OCIO_reportException(exception);
@@ -225,10 +226,10 @@ const char *OCIOImpl::configGetDisplay(ConstConfigRcPtr *config, int index)
        return NULL;
 }
 
-const char *OCIOImpl::configGetDefaultView(ConstConfigRcPtr *config, const char *display)
+const char *OCIOImpl::configGetDefaultView(OCIO_ConstConfigRcPtr *config, const char *display)
 {
        try {
-               return (*config)->getDefaultView(display);
+               return (*(ConstConfigRcPtr *) config)->getDefaultView(display);
        }
        catch (Exception &exception) {
                OCIO_reportException(exception);
@@ -237,10 +238,10 @@ const char *OCIOImpl::configGetDefaultView(ConstConfigRcPtr *config, const char
        return NULL;
 }
 
-int OCIOImpl::configGetNumViews(ConstConfigRcPtr *config, const char *display)
+int OCIOImpl::configGetNumViews(OCIO_ConstConfigRcPtr *config, const char *display)
 {
        try {
-               return (*config)->getNumViews(display);
+               return (*(ConstConfigRcPtr *) config)->getNumViews(display);
        }
        catch (Exception &exception) {
                OCIO_reportException(exception);
@@ -249,10 +250,10 @@ int OCIOImpl::configGetNumViews(ConstConfigRcPtr *config, const char *display)
        return 0;
 }
 
-const char *OCIOImpl::configGetView(ConstConfigRcPtr *config, const char *display, int index)
+const char *OCIOImpl::configGetView(OCIO_ConstConfigRcPtr *config, const char *display, int index)
 {
        try {
-               return (*config)->getView(display, index);
+               return (*(ConstConfigRcPtr *) config)->getView(display, index);
        }
        catch (Exception &exception) {
                OCIO_reportException(exception);
@@ -261,10 +262,10 @@ const char *OCIOImpl::configGetView(ConstConfigRcPtr *config, const char *displa
        return NULL;
 }
 
-const char *OCIOImpl::configGetDisplayColorSpaceName(ConstConfigRcPtr *config, const char *display, const char *view)
+const char *OCIOImpl::configGetDisplayColorSpaceName(OCIO_ConstConfigRcPtr *config, const char *display, const char *view)
 {
        try {
-               return (*config)->getDisplayColorSpaceName(display, view);
+               return (*(ConstConfigRcPtr *) config)->getDisplayColorSpaceName(display, view);
        }
        catch (Exception &exception) {
                OCIO_reportException(exception);
@@ -273,8 +274,9 @@ const char *OCIOImpl::configGetDisplayColorSpaceName(ConstConfigRcPtr *config, c
        return NULL;
 }
 
-int OCIOImpl::colorSpaceIsInvertible(ConstColorSpaceRcPtr *cs)
+int OCIOImpl::colorSpaceIsInvertible(OCIO_ConstColorSpaceRcPtr *cs_)
 {
+       ConstColorSpaceRcPtr *cs = (ConstColorSpaceRcPtr *) cs_;
        const char *family = (*cs)->getFamily();
 
        if (!strcmp(family, "rrt") || !strcmp(family, "display")) {
@@ -297,25 +299,25 @@ int OCIOImpl::colorSpaceIsInvertible(ConstColorSpaceRcPtr *cs)
        return true;
 }
 
-int OCIOImpl::colorSpaceIsData(ConstColorSpaceRcPtr *cs)
+int OCIOImpl::colorSpaceIsData(OCIO_ConstColorSpaceRcPtr *cs)
 {
-       return ((*cs)->isData());
+       return (*(ConstColorSpaceRcPtr *) cs)->isData();
 }
 
-void OCIOImpl::colorSpaceRelease(ConstColorSpaceRcPtr *cs)
+void OCIOImpl::colorSpaceRelease(OCIO_ConstColorSpaceRcPtr *cs)
 {
-       MEM_DELETE(cs, ConstColorSpaceRcPtr);
+       MEM_DELETE((ConstColorSpaceRcPtr *) cs, ConstColorSpaceRcPtr);
 }
 
-ConstProcessorRcPtr *OCIOImpl::configGetProcessorWithNames(ConstConfigRcPtr *config, const char *srcName, const char *dstName)
+OCIO_ConstProcessorRcPtr *OCIOImpl::configGetProcessorWithNames(OCIO_ConstConfigRcPtr *config, const char *srcName, const char *dstName)
 {
        ConstProcessorRcPtr *p = MEM_NEW(ConstProcessorRcPtr);
 
        try {
-               *p = (*config)->getProcessor(srcName, dstName);
+               *p = (*(ConstConfigRcPtr *) config)->getProcessor(srcName, dstName);
 
                if (*p)
-                       return p;
+                       return (OCIO_ConstProcessorRcPtr *) p;
        }
        catch (Exception &exception) {
                OCIO_reportException(exception);
@@ -326,15 +328,15 @@ ConstProcessorRcPtr *OCIOImpl::configGetProcessorWithNames(ConstConfigRcPtr *con
        return 0;
 }
 
-ConstProcessorRcPtr *OCIOImpl::configGetProcessor(ConstConfigRcPtr *config, ConstTransformRcPtr *transform)
+OCIO_ConstProcessorRcPtr *OCIOImpl::configGetProcessor(OCIO_ConstConfigRcPtr *config, OCIO_ConstTransformRcPtr *transform)
 {
        ConstProcessorRcPtr *p = MEM_NEW(ConstProcessorRcPtr);
 
        try {
-               *p = (*config)->getProcessor(*transform);
+               *p = (*(ConstConfigRcPtr *) config)->getProcessor(*(ConstTransformRcPtr *) transform);
 
                if (*p)
-                       return p;
+                       return (OCIO_ConstProcessorRcPtr *) p;
        }
        catch (Exception &exception) {
                OCIO_reportException(exception);
@@ -345,19 +347,20 @@ ConstProcessorRcPtr *OCIOImpl::configGetProcessor(ConstConfigRcPtr *config, Cons
        return NULL;
 }
 
-void OCIOImpl::processorApply(ConstProcessorRcPtr *processor, PackedImageDesc *img)
+void OCIOImpl::processorApply(OCIO_ConstProcessorRcPtr *processor, OCIO_PackedImageDesc *img)
 {
        try {
-               (*processor)->apply(*img);
+               (*(ConstProcessorRcPtr *) processor)->apply(*(PackedImageDesc *) img);
        }
        catch (Exception &exception) {
                OCIO_reportException(exception);
        }
 }
 
-void OCIOImpl::processorApply_predivide(ConstProcessorRcPtr *processor, PackedImageDesc *img)
+void OCIOImpl::processorApply_predivide(OCIO_ConstProcessorRcPtr *processor, OCIO_PackedImageDesc *img_)
 {
        try {
+               PackedImageDesc *img = (PackedImageDesc *) img_;
                int channels = img->getNumChannels();
 
                if (channels == 4) {
@@ -375,7 +378,7 @@ void OCIOImpl::processorApply_predivide(ConstProcessorRcPtr *processor, PackedIm
                        }
                }
                else {
-                       (*processor)->apply(*img);
+                       (*(ConstProcessorRcPtr *) processor)->apply(*img);
                }
        }
        catch (Exception &exception) {
@@ -383,20 +386,20 @@ void OCIOImpl::processorApply_predivide(ConstProcessorRcPtr *processor, PackedIm
        }
 }
 
-void OCIOImpl::processorApplyRGB(ConstProcessorRcPtr *processor, float *pixel)
+void OCIOImpl::processorApplyRGB(OCIO_ConstProcessorRcPtr *processor, float *pixel)
 {
-       (*processor)->applyRGB(pixel);
+       (*(ConstProcessorRcPtr *) processor)->applyRGB(pixel);
 }
 
-void OCIOImpl::processorApplyRGBA(ConstProcessorRcPtr *processor, float *pixel)
+void OCIOImpl::processorApplyRGBA(OCIO_ConstProcessorRcPtr *processor, float *pixel)
 {
-       (*processor)->applyRGBA(pixel);
+       (*(ConstProcessorRcPtr *) processor)->applyRGBA(pixel);
 }
 
-void OCIOImpl::processorApplyRGBA_predivide(ConstProcessorRcPtr *processor, float *pixel)
+void OCIOImpl::processorApplyRGBA_predivide(OCIO_ConstProcessorRcPtr *processor, float *pixel)
 {
        if (pixel[3] == 1.0f || pixel[3] == 0.0f) {
-               (*processor)->applyRGBA(pixel);
+               (*(ConstProcessorRcPtr *) processor)->applyRGBA(pixel);
        }
        else {
                float alpha, inv_alpha;
@@ -408,7 +411,7 @@ void OCIOImpl::processorApplyRGBA_predivide(ConstProcessorRcPtr *processor, floa
                pixel[1] *= inv_alpha;
                pixel[2] *= inv_alpha;
 
-               (*processor)->applyRGBA(pixel);
+               (*(ConstProcessorRcPtr *) processor)->applyRGBA(pixel);
 
                pixel[0] *= alpha;
                pixel[1] *= alpha;
@@ -416,74 +419,74 @@ void OCIOImpl::processorApplyRGBA_predivide(ConstProcessorRcPtr *processor, floa
        }
 }
 
-void OCIOImpl::processorRelease(ConstProcessorRcPtr *p)
+void OCIOImpl::processorRelease(OCIO_ConstProcessorRcPtr *p)
 {
-       p->~ConstProcessorRcPtr();
+       p->~OCIO_ConstProcessorRcPtr();
        MEM_freeN(p);
 }
 
-const char *OCIOImpl::colorSpaceGetName(ConstColorSpaceRcPtr *cs)
+const char *OCIOImpl::colorSpaceGetName(OCIO_ConstColorSpaceRcPtr *cs)
 {
-       return (*cs)->getName();
+       return (*(ConstColorSpaceRcPtr *) cs)->getName();
 }
 
-const char *OCIOImpl::colorSpaceGetDescription(ConstColorSpaceRcPtr *cs)
+const char *OCIOImpl::colorSpaceGetDescription(OCIO_ConstColorSpaceRcPtr *cs)
 {
-       return (*cs)->getDescription();
+       return (*(ConstColorSpaceRcPtr *) cs)->getDescription();
 }
 
-const char *OCIOImpl::colorSpaceGetFamily(ConstColorSpaceRcPtr *cs)
+const char *OCIOImpl::colorSpaceGetFamily(OCIO_ConstColorSpaceRcPtr *cs)
 {
-       return (*cs)->getFamily();
+       return (*(ConstColorSpaceRcPtr *)cs)->getFamily();
 }
 
-DisplayTransformRcPtr *OCIOImpl::createDisplayTransform(void)
+OCIO_DisplayTransformRcPtr *OCIOImpl::createDisplayTransform(void)
 {
        DisplayTransformRcPtr *dt = MEM_NEW(DisplayTransformRcPtr);
 
        *dt = DisplayTransform::Create();
 
-       return dt;
+       return (OCIO_DisplayTransformRcPtr *) dt;
 }
 
-void OCIOImpl::displayTransformSetInputColorSpaceName(DisplayTransformRcPtr *dt, const char *name)
+void OCIOImpl::displayTransformSetInputColorSpaceName(OCIO_DisplayTransformRcPtr *dt, const char *name)
 {
-       (*dt)->setInputColorSpaceName(name);
+       (*(DisplayTransformRcPtr *) dt)->setInputColorSpaceName(name);
 }
 
-void OCIOImpl::displayTransformSetDisplay(DisplayTransformRcPtr *dt, const char *name)
+void OCIOImpl::displayTransformSetDisplay(OCIO_DisplayTransformRcPtr *dt, const char *name)
 {
-       (*dt)->setDisplay(name);
+       (*(DisplayTransformRcPtr *) dt)->setDisplay(name);
 }
 
-void OCIOImpl::displayTransformSetView(DisplayTransformRcPtr *dt, const char *name)
+void OCIOImpl::displayTransformSetView(OCIO_DisplayTransformRcPtr *dt, const char *name)
 {
-       (*dt)->setView(name);
+       (*(DisplayTransformRcPtr *) dt)->setView(name);
 }
 
-void OCIOImpl::displayTransformSetDisplayCC(DisplayTransformRcPtr *dt, ConstTransformRcPtr *t)
+void OCIOImpl::displayTransformSetDisplayCC(OCIO_DisplayTransformRcPtr *dt, OCIO_ConstTransformRcPtr *t)
 {
-       (*dt)->setDisplayCC(*t);
+       (*(DisplayTransformRcPtr *) dt)->setDisplayCC(* (ConstTransformRcPtr *) t);
 }
 
-void OCIOImpl::displayTransformSetLinearCC(DisplayTransformRcPtr *dt, ConstTransformRcPtr *t)
+void OCIOImpl::displayTransformSetLinearCC(OCIO_DisplayTransformRcPtr *dt, OCIO_ConstTransformRcPtr *t)
 {
-       (*dt)->setLinearCC(*t);
+       (*(DisplayTransformRcPtr *) dt)->setLinearCC(*(ConstTransformRcPtr *) t);
 }
 
-void OCIOImpl::displayTransformRelease(DisplayTransformRcPtr *dt)
+void OCIOImpl::displayTransformRelease(OCIO_DisplayTransformRcPtr *dt)
 {
-       MEM_DELETE(dt, DisplayTransformRcPtr);
+       MEM_DELETE((DisplayTransformRcPtr *) dt, DisplayTransformRcPtr);
 }
 
-PackedImageDesc *OCIOImpl::createPackedImageDesc(float *data, long width, long height, long numChannels,
+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);
 
-               return id;
+               return (OCIO_PackedImageDesc *) id;
        }
        catch (Exception &exception) {
                OCIO_reportException(exception);
@@ -492,47 +495,47 @@ PackedImageDesc *OCIOImpl::createPackedImageDesc(float *data, long width, long h
        return NULL;
 }
 
-void OCIOImpl::packedImageDescRelease(PackedImageDesc* id)
+void OCIOImpl::OCIO_PackedImageDescRelease(OCIO_PackedImageDesc* id)
 {
-       MEM_DELETE(id, PackedImageDesc);
+       MEM_DELETE((PackedImageDesc *) id, PackedImageDesc);
 }
 
-ExponentTransformRcPtr *OCIOImpl::createExponentTransform(void)
+OCIO_ExponentTransformRcPtr *OCIOImpl::createExponentTransform(void)
 {
        ExponentTransformRcPtr *et = MEM_NEW(ExponentTransformRcPtr);
 
        *et = ExponentTransform::Create();
 
-       return et;
+       return (OCIO_ExponentTransformRcPtr *) et;
 }
 
-void OCIOImpl::exponentTransformSetValue(ExponentTransformRcPtr *et, const float *exponent)
+void OCIOImpl::exponentTransformSetValue(OCIO_ExponentTransformRcPtr *et, const float *exponent)
 {
-       (*et)->setValue(exponent);
+       (*(ExponentTransformRcPtr *) et)->setValue(exponent);
 }
 
-void OCIOImpl::exponentTransformRelease(ExponentTransformRcPtr *et)
+void OCIOImpl::exponentTransformRelease(OCIO_ExponentTransformRcPtr *et)
 {
-       MEM_DELETE(et, ExponentTransformRcPtr);
+       MEM_DELETE((ExponentTransformRcPtr *) et, ExponentTransformRcPtr);
 }
 
-MatrixTransformRcPtr *OCIOImpl::createMatrixTransform(void)
+OCIO_MatrixTransformRcPtr *OCIOImpl::createMatrixTransform(void)
 {
        MatrixTransformRcPtr *mt = MEM_NEW(MatrixTransformRcPtr);
 
        *mt = MatrixTransform::Create();
 
-       return mt;
+       return (OCIO_MatrixTransformRcPtr *) mt;
 }
 
-void OCIOImpl::matrixTransformSetValue(MatrixTransformRcPtr *mt, const float *m44, const float *offset4)
+void OCIOImpl::matrixTransformSetValue(OCIO_MatrixTransformRcPtr *mt, const float *m44, const float *offset4)
 {
-       (*mt)->setValue(m44, offset4);
+       (*(MatrixTransformRcPtr *) mt)->setValue(m44, offset4);
 }
 
-void OCIOImpl::matrixTransformRelease(MatrixTransformRcPtr *mt)
+void OCIOImpl::matrixTransformRelease(OCIO_MatrixTransformRcPtr *mt)
 {
-       MEM_DELETE(mt, MatrixTransformRcPtr);
+       MEM_DELETE((MatrixTransformRcPtr *) mt, MatrixTransformRcPtr);
 }
 
 void OCIOImpl::matrixTransformScale(float * m44, float * offset4, const float *scale4f)
index e05b35648b910c0b9a77316e6948d87f3960371d..64cf5ec332234861c2a8c53ea370eca16d2583f5 100644 (file)
@@ -32,67 +32,67 @@ class IOCIOImpl {
 public:
        virtual ~IOCIOImpl() {};
 
-       virtual ConstConfigRcPtr *getCurrentConfig(void) = 0;
-       virtual void setCurrentConfig(const ConstConfigRcPtr *config) = 0;
+       virtual OCIO_ConstConfigRcPtr *getCurrentConfig(void) = 0;
+       virtual void setCurrentConfig(const OCIO_ConstConfigRcPtr *config) = 0;
 
-       virtual ConstConfigRcPtr *configCreateFromEnv(void) = 0;
-       virtual ConstConfigRcPtr *configCreateFromFile(const char* filename) = 0;
+       virtual OCIO_ConstConfigRcPtr *configCreateFromEnv(void) = 0;
+       virtual OCIO_ConstConfigRcPtr *configCreateFromFile(const char* filename) = 0;
 
-       virtual void configRelease(ConstConfigRcPtr *config) = 0;
+       virtual void configRelease(OCIO_ConstConfigRcPtr *config) = 0;
 
-       virtual int configGetNumColorSpaces(ConstConfigRcPtr *config) = 0;
-       virtual const char *configGetColorSpaceNameByIndex(ConstConfigRcPtr *config, int index) = 0;
-       virtual ConstColorSpaceRcPtr *configGetColorSpace(ConstConfigRcPtr *config, const char *name) = 0;
-       virtual int configGetIndexForColorSpace(ConstConfigRcPtr *config, const char *name) = 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(ConstColorSpaceRcPtr *cs) = 0;
-       virtual int colorSpaceIsData(ConstColorSpaceRcPtr *cs) = 0;
+       virtual int colorSpaceIsInvertible(OCIO_ConstColorSpaceRcPtr *cs) = 0;
+       virtual int colorSpaceIsData(OCIO_ConstColorSpaceRcPtr *cs) = 0;
 
-       virtual void colorSpaceRelease(ConstColorSpaceRcPtr *cs) = 0;
+       virtual void colorSpaceRelease(OCIO_ConstColorSpaceRcPtr *cs) = 0;
 
-       virtual const char *configGetDefaultDisplay(ConstConfigRcPtr *config) = 0;
-       virtual int         configGetNumDisplays(ConstConfigRcPtr *config) = 0;
-       virtual const char *configGetDisplay(ConstConfigRcPtr *config, int index) = 0;
-       virtual const char *configGetDefaultView(ConstConfigRcPtr *config, const char *display) = 0;
-       virtual int         configGetNumViews(ConstConfigRcPtr *config, const char *display) = 0;
-       virtual const char *configGetView(ConstConfigRcPtr *config, const char *display, int index) = 0;
-       virtual const char *configGetDisplayColorSpaceName(ConstConfigRcPtr *config, const char *display, const char *view) = 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 ConstProcessorRcPtr *configGetProcessorWithNames(ConstConfigRcPtr *config, const char *srcName, const char *dstName) = 0;
-       virtual ConstProcessorRcPtr *configGetProcessor(ConstConfigRcPtr *config, ConstTransformRcPtr *transform) = 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(ConstProcessorRcPtr *processor, PackedImageDesc *img) = 0;
-       virtual void processorApply_predivide(ConstProcessorRcPtr *processor, PackedImageDesc *img) = 0;
-       virtual void processorApplyRGB(ConstProcessorRcPtr *processor, float *pixel) = 0;
-       virtual void processorApplyRGBA(ConstProcessorRcPtr *processor, float *pixel) = 0;
-       virtual void processorApplyRGBA_predivide(ConstProcessorRcPtr *processor, float *pixel) = 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(ConstProcessorRcPtr *p) = 0;
+       virtual void processorRelease(OCIO_ConstProcessorRcPtr *p) = 0;
 
-       virtual const char *colorSpaceGetName(ConstColorSpaceRcPtr *cs) = 0;
-       virtual const char *colorSpaceGetDescription(ConstColorSpaceRcPtr *cs) = 0;
-       virtual const char *colorSpaceGetFamily(ConstColorSpaceRcPtr *cs) = 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 DisplayTransformRcPtr *createDisplayTransform(void) = 0;
-       virtual void displayTransformSetInputColorSpaceName(DisplayTransformRcPtr *dt, const char *name) = 0;
-       virtual void displayTransformSetDisplay(DisplayTransformRcPtr *dt, const char *name) = 0;
-       virtual void displayTransformSetView(DisplayTransformRcPtr *dt, const char *name) = 0;
-       virtual void displayTransformSetDisplayCC(DisplayTransformRcPtr *dt, ConstTransformRcPtr *et) = 0;
-       virtual void displayTransformSetLinearCC(DisplayTransformRcPtr *dt, ConstTransformRcPtr *et) = 0;
-       virtual void displayTransformRelease(DisplayTransformRcPtr *dt) = 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 displayTransformRelease(OCIO_DisplayTransformRcPtr *dt) = 0;
 
-       virtual PackedImageDesc *createPackedImageDesc(float *data, long width, long height, long numChannels,
+       virtual OCIO_PackedImageDesc *createOCIO_PackedImageDesc(float *data, long width, long height, long numChannels,
                                                       long chanStrideBytes, long xStrideBytes, long yStrideBytes) = 0;
 
-       virtual void packedImageDescRelease(PackedImageDesc *p) = 0;
+       virtual void OCIO_PackedImageDescRelease(OCIO_PackedImageDesc *p) = 0;
 
-       virtual ExponentTransformRcPtr *createExponentTransform(void) = 0;
-       virtual void exponentTransformSetValue(ExponentTransformRcPtr *et, const float *exponent) = 0;
-       virtual void exponentTransformRelease(ExponentTransformRcPtr *et) = 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 MatrixTransformRcPtr *createMatrixTransform(void) = 0;
-       virtual void matrixTransformSetValue(MatrixTransformRcPtr *et, const float *m44, const float *offset4) = 0;
-       virtual void matrixTransformRelease(MatrixTransformRcPtr *mt) = 0;
+       virtual OCIO_MatrixTransformRcPtr *createMatrixTransform(void) = 0;
+       virtual void matrixTransformSetValue(OCIO_MatrixTransformRcPtr *et, 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;
 };
@@ -101,67 +101,67 @@ class FallbackImpl : public IOCIOImpl {
 public:
        FallbackImpl() {};
 
-       ConstConfigRcPtr *getCurrentConfig(void);
-       void setCurrentConfig(const ConstConfigRcPtr *config);
+       OCIO_ConstConfigRcPtr *getCurrentConfig(void);
+       void setCurrentConfig(const OCIO_ConstConfigRcPtr *config);
 
-       ConstConfigRcPtr *configCreateFromEnv(void);
-       ConstConfigRcPtr *configCreateFromFile(const char* filename);
+       OCIO_ConstConfigRcPtr *configCreateFromEnv(void);
+       OCIO_ConstConfigRcPtr *configCreateFromFile(const char* filename);
 
-       void configRelease(ConstConfigRcPtr *config);
+       void configRelease(OCIO_ConstConfigRcPtr *config);
 
-       int configGetNumColorSpaces(ConstConfigRcPtr *config);
-       const char *configGetColorSpaceNameByIndex(ConstConfigRcPtr *config, int index);
-       ConstColorSpaceRcPtr *configGetColorSpace(ConstConfigRcPtr *config, const char *name);
-       int configGetIndexForColorSpace(ConstConfigRcPtr *config, const char *name);
+       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(ConstColorSpaceRcPtr *cs);
-       int colorSpaceIsData(ConstColorSpaceRcPtr *cs);
+       int colorSpaceIsInvertible(OCIO_ConstColorSpaceRcPtr *cs);
+       int colorSpaceIsData(OCIO_ConstColorSpaceRcPtr *cs);
 
-       void colorSpaceRelease(ConstColorSpaceRcPtr *cs);
+       void colorSpaceRelease(OCIO_ConstColorSpaceRcPtr *cs);
 
-       const char *configGetDefaultDisplay(ConstConfigRcPtr *config);
-       int         configGetNumDisplays(ConstConfigRcPtr *config);
-       const char *configGetDisplay(ConstConfigRcPtr *config, int index);
-       const char *configGetDefaultView(ConstConfigRcPtr *config, const char *display);
-       int         configGetNumViews(ConstConfigRcPtr *config, const char *display);
-       const char *configGetView(ConstConfigRcPtr *config, const char *display, int index);
-       const char *configGetDisplayColorSpaceName(ConstConfigRcPtr *config, const char *display, const char *view);
+       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);
 
-       ConstProcessorRcPtr *configGetProcessorWithNames(ConstConfigRcPtr *config, const char *srcName, const char *dstName);
-       ConstProcessorRcPtr *configGetProcessor(ConstConfigRcPtr *config, ConstTransformRcPtr *transform);
+       OCIO_ConstProcessorRcPtr *configGetProcessorWithNames(OCIO_ConstConfigRcPtr *config, const char *srcName, const char *dstName);
+       OCIO_ConstProcessorRcPtr *configGetProcessor(OCIO_ConstConfigRcPtr *config, OCIO_ConstTransformRcPtr *transform);
 
-       void processorApply(ConstProcessorRcPtr *processor, PackedImageDesc *img);
-       void processorApply_predivide(ConstProcessorRcPtr *processor, PackedImageDesc *img);
-       void processorApplyRGB(ConstProcessorRcPtr *processor, float *pixel);
-       void processorApplyRGBA(ConstProcessorRcPtr *processor, float *pixel);
-       void processorApplyRGBA_predivide(ConstProcessorRcPtr *processor, float *pixel);
+       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(ConstProcessorRcPtr *p);
+       void processorRelease(OCIO_ConstProcessorRcPtr *p);
 
-       const char *colorSpaceGetName(ConstColorSpaceRcPtr *cs);
-       const char *colorSpaceGetDescription(ConstColorSpaceRcPtr *cs);
-       const char *colorSpaceGetFamily(ConstColorSpaceRcPtr *cs);
+       const char *colorSpaceGetName(OCIO_ConstColorSpaceRcPtr *cs);
+       const char *colorSpaceGetDescription(OCIO_ConstColorSpaceRcPtr *cs);
+       const char *colorSpaceGetFamily(OCIO_ConstColorSpaceRcPtr *cs);
 
-       DisplayTransformRcPtr *createDisplayTransform(void);
-       void displayTransformSetInputColorSpaceName(DisplayTransformRcPtr *dt, const char *name);
-       void displayTransformSetDisplay(DisplayTransformRcPtr *dt, const char *name);
-       void displayTransformSetView(DisplayTransformRcPtr *dt, const char *name);
-       void displayTransformSetDisplayCC(DisplayTransformRcPtr *dt, ConstTransformRcPtr *et);
-       void displayTransformSetLinearCC(DisplayTransformRcPtr *dt, ConstTransformRcPtr *et);
-       void displayTransformRelease(DisplayTransformRcPtr *dt);
+       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 displayTransformRelease(OCIO_DisplayTransformRcPtr *dt);
 
-       PackedImageDesc *createPackedImageDesc(float *data, long width, long height, long numChannels,
+       OCIO_PackedImageDesc *createOCIO_PackedImageDesc(float *data, long width, long height, long numChannels,
                                               long chanStrideBytes, long xStrideBytes, long yStrideBytes);
 
-       void packedImageDescRelease(PackedImageDesc *p);
+       void OCIO_PackedImageDescRelease(OCIO_PackedImageDesc *p);
 
-       ExponentTransformRcPtr *createExponentTransform(void);
-       void exponentTransformSetValue(ExponentTransformRcPtr *et, const float *exponent);
-       void exponentTransformRelease(ExponentTransformRcPtr *et);
+       OCIO_ExponentTransformRcPtr *createExponentTransform(void);
+       void exponentTransformSetValue(OCIO_ExponentTransformRcPtr *et, const float *exponent);
+       void exponentTransformRelease(OCIO_ExponentTransformRcPtr *et);
 
-       MatrixTransformRcPtr *createMatrixTransform(void);
-       void matrixTransformSetValue(MatrixTransformRcPtr *et, const float *m44, const float *offset4);
-       void matrixTransformRelease(MatrixTransformRcPtr *mt);
+       OCIO_MatrixTransformRcPtr *createMatrixTransform(void);
+       void matrixTransformSetValue(OCIO_MatrixTransformRcPtr *et, const float *m44, const float *offset4);
+       void matrixTransformRelease(OCIO_MatrixTransformRcPtr *mt);
 
        void matrixTransformScale(float * m44, float * offset4, const float * scale4);
 };
@@ -171,67 +171,67 @@ class OCIOImpl : public IOCIOImpl {
 public:
        OCIOImpl() {};
 
-       ConstConfigRcPtr *getCurrentConfig(void);
-       void setCurrentConfig(const ConstConfigRcPtr *config);
+       OCIO_ConstConfigRcPtr *getCurrentConfig(void);
+       void setCurrentConfig(const OCIO_ConstConfigRcPtr *config);
 
-       ConstConfigRcPtr *configCreateFromEnv(void);
-       ConstConfigRcPtr *configCreateFromFile(const char* filename);
+       OCIO_ConstConfigRcPtr *configCreateFromEnv(void);
+       OCIO_ConstConfigRcPtr *configCreateFromFile(const char* filename);
 
-       void configRelease(ConstConfigRcPtr *config);
+       void configRelease(OCIO_ConstConfigRcPtr *config);
 
-       int configGetNumColorSpaces(ConstConfigRcPtr *config);
-       const char *configGetColorSpaceNameByIndex(ConstConfigRcPtr *config, int index);
-       ConstColorSpaceRcPtr *configGetColorSpace(ConstConfigRcPtr *config, const char *name);
-       int configGetIndexForColorSpace(ConstConfigRcPtr *config, const char *name);
+       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(ConstColorSpaceRcPtr *cs);
-       int colorSpaceIsData(ConstColorSpaceRcPtr *cs);
+       int colorSpaceIsInvertible(OCIO_ConstColorSpaceRcPtr *cs);
+       int colorSpaceIsData(OCIO_ConstColorSpaceRcPtr *cs);
 
-       void colorSpaceRelease(ConstColorSpaceRcPtr *cs);
+       void colorSpaceRelease(OCIO_ConstColorSpaceRcPtr *cs);
 
-       const char *configGetDefaultDisplay(ConstConfigRcPtr *config);
-       int         configGetNumDisplays(ConstConfigRcPtr *config);
-       const char *configGetDisplay(ConstConfigRcPtr *config, int index);
-       const char *configGetDefaultView(ConstConfigRcPtr *config, const char *display);
-       int         configGetNumViews(ConstConfigRcPtr *config, const char *display);
-       const char *configGetView(ConstConfigRcPtr *config, const char *display, int index);
-       const char *configGetDisplayColorSpaceName(ConstConfigRcPtr *config, const char *display, const char *view);
+       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);
 
-       ConstProcessorRcPtr *configGetProcessorWithNames(ConstConfigRcPtr *config, const char *srcName, const char *dstName);
-       ConstProcessorRcPtr *configGetProcessor(ConstConfigRcPtr *config, ConstTransformRcPtr *transform);
+       OCIO_ConstProcessorRcPtr *configGetProcessorWithNames(OCIO_ConstConfigRcPtr *config, const char *srcName, const char *dstName);
+       OCIO_ConstProcessorRcPtr *configGetProcessor(OCIO_ConstConfigRcPtr *config, OCIO_ConstTransformRcPtr *transform);
 
-       void processorApply(ConstProcessorRcPtr *processor, PackedImageDesc *img);
-       void processorApply_predivide(ConstProcessorRcPtr *processor, PackedImageDesc *img);
-       void processorApplyRGB(ConstProcessorRcPtr *processor, float *pixel);
-       void processorApplyRGBA(ConstProcessorRcPtr *processor, float *pixel);
-       void processorApplyRGBA_predivide(ConstProcessorRcPtr *processor, float *pixel);
+       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(ConstProcessorRcPtr *p);
+       void processorRelease(OCIO_ConstProcessorRcPtr *p);
 
-       const char *colorSpaceGetName(ConstColorSpaceRcPtr *cs);
-       const char *colorSpaceGetDescription(ConstColorSpaceRcPtr *cs);
-       const char *colorSpaceGetFamily(ConstColorSpaceRcPtr *cs);
+       const char *colorSpaceGetName(OCIO_ConstColorSpaceRcPtr *cs);
+       const char *colorSpaceGetDescription(OCIO_ConstColorSpaceRcPtr *cs);
+       const char *colorSpaceGetFamily(OCIO_ConstColorSpaceRcPtr *cs);
 
-       DisplayTransformRcPtr *createDisplayTransform(void);
-       void displayTransformSetInputColorSpaceName(DisplayTransformRcPtr *dt, const char *name);
-       void displayTransformSetDisplay(DisplayTransformRcPtr *dt, const char *name);
-       void displayTransformSetView(DisplayTransformRcPtr *dt, const char *name);
-       void displayTransformSetDisplayCC(DisplayTransformRcPtr *dt, ConstTransformRcPtr *et);
-       void displayTransformSetLinearCC(DisplayTransformRcPtr *dt, ConstTransformRcPtr *et);
-       void displayTransformRelease(DisplayTransformRcPtr *dt);
+       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 displayTransformRelease(OCIO_DisplayTransformRcPtr *dt);
 
-       PackedImageDesc *createPackedImageDesc(float *data, long width, long height, long numChannels,
+       OCIO_PackedImageDesc *createOCIO_PackedImageDesc(float *data, long width, long height, long numChannels,
                                               long chanStrideBytes, long xStrideBytes, long yStrideBytes);
 
-       void packedImageDescRelease(PackedImageDesc *p);
+       void OCIO_PackedImageDescRelease(OCIO_PackedImageDesc *p);
 
-       ExponentTransformRcPtr *createExponentTransform(void);
-       void exponentTransformSetValue(ExponentTransformRcPtr *et, const float *exponent);
-       void exponentTransformRelease(ExponentTransformRcPtr *et);
+       OCIO_ExponentTransformRcPtr *createExponentTransform(void);
+       void exponentTransformSetValue(OCIO_ExponentTransformRcPtr *et, const float *exponent);
+       void exponentTransformRelease(OCIO_ExponentTransformRcPtr *et);
 
-       MatrixTransformRcPtr *createMatrixTransform(void);
-       void matrixTransformSetValue(MatrixTransformRcPtr *et, const float *m44, const float *offset4);
-       void matrixTransformRelease(MatrixTransformRcPtr *mt);
+       OCIO_MatrixTransformRcPtr *createMatrixTransform(void);
+       void matrixTransformSetValue(OCIO_MatrixTransformRcPtr *et, const float *m44, const float *offset4);
+       void matrixTransformRelease(OCIO_MatrixTransformRcPtr *mt);
 
        void matrixTransformScale(float * m44, float * offset4, const float * scale4);
 };
index 35a6ea9b207d99fd8f9f7d6b60bab3818e649225..ba9e20ac4116a22baa329f689e4ede81cd70a800 100644 (file)
@@ -35,7 +35,7 @@
 
 #define BCM_CONFIG_FILE "config.ocio"
 
-struct ConstProcessorRcPtr;
+struct OCIO_ConstProcessorRcPtr;
 struct ImBuf;
 
 typedef struct ColorSpace {
@@ -44,8 +44,8 @@ typedef struct ColorSpace {
        char name[64];
        char description[64];
 
-       struct ConstProcessorRcPtr *to_scene_linear;
-       struct ConstProcessorRcPtr *from_scene_linear;
+       struct OCIO_ConstProcessorRcPtr *to_scene_linear;
+       struct OCIO_ConstProcessorRcPtr *from_scene_linear;
 
        int is_invertible;
        int is_data;
@@ -57,8 +57,8 @@ typedef struct ColorManagedDisplay {
        char name[64];
        ListBase views;
 
-       struct ConstProcessorRcPtr *to_scene_linear;
-       struct ConstProcessorRcPtr *from_scene_linear;
+       struct OCIO_ConstProcessorRcPtr *to_scene_linear;
+       struct OCIO_ConstProcessorRcPtr *from_scene_linear;
 } ColorManagedDisplay;
 
 typedef struct ColorManagedView {
index 50000b9eeea2ea1478da6c48668e259e905a0877..c7bdd532bb991ef994ceaacfbb34a89166934ffb 100644 (file)
@@ -96,7 +96,7 @@ static int global_tot_view = 0;
 static pthread_mutex_t processor_lock = BLI_MUTEX_INITIALIZER;
 
 typedef struct ColormanageProcessor {
-       ConstProcessorRcPtr *processor;
+       OCIO_ConstProcessorRcPtr *processor;
        CurveMapping *curve_mapping;
 } ColormanageProcessor;
 
@@ -419,9 +419,9 @@ static void colormanage_cache_handle_release(void *cache_handle)
 
 /*********************** Initialization / De-initialization *************************/
 
-static void colormanage_role_color_space_name_get(ConstConfigRcPtr *config, char *colorspace_name, const char *role, const char *backup_role)
+static void colormanage_role_color_space_name_get(OCIO_ConstConfigRcPtr *config, char *colorspace_name, const char *role, const char *backup_role)
 {
-       ConstColorSpaceRcPtr *ociocs;
+       OCIO_ConstColorSpaceRcPtr *ociocs;
 
        ociocs = OCIO_configGetColorSpace(config, role);
 
@@ -440,7 +440,7 @@ static void colormanage_role_color_space_name_get(ConstConfigRcPtr *config, char
        }
 }
 
-static void colormanage_load_config(ConstConfigRcPtr *config)
+static void colormanage_load_config(OCIO_ConstConfigRcPtr *config)
 {
        int tot_colorspace, tot_display, tot_display_view, index, viewindex, viewindex2;
        const char *name;
@@ -456,7 +456,7 @@ static void colormanage_load_config(ConstConfigRcPtr *config)
        /* load colorspaces */
        tot_colorspace = OCIO_configGetNumColorSpaces(config);
        for (index = 0 ; index < tot_colorspace; index++) {
-               ConstColorSpaceRcPtr *ocio_colorspace;
+               OCIO_ConstColorSpaceRcPtr *ocio_colorspace;
                const char *description;
                int is_invertible, is_data;
 
@@ -521,10 +521,10 @@ static void colormanage_free_config(void)
 
                /* free precomputer processors */
                if (colorspace->to_scene_linear)
-                       OCIO_processorRelease((ConstProcessorRcPtr *) colorspace->to_scene_linear);
+                       OCIO_processorRelease((OCIO_ConstProcessorRcPtr *) colorspace->to_scene_linear);
 
                if (colorspace->from_scene_linear)
-                       OCIO_processorRelease((ConstProcessorRcPtr *) colorspace->from_scene_linear);
+                       OCIO_processorRelease((OCIO_ConstProcessorRcPtr *) colorspace->from_scene_linear);
 
                /* free color space itself */
                MEM_freeN(colorspace);
@@ -539,10 +539,10 @@ static void colormanage_free_config(void)
 
                /* free precomputer processors */
                if (display->to_scene_linear)
-                       OCIO_processorRelease((ConstProcessorRcPtr *) display->to_scene_linear);
+                       OCIO_processorRelease((OCIO_ConstProcessorRcPtr *) display->to_scene_linear);
 
                if (display->from_scene_linear)
-                       OCIO_processorRelease((ConstProcessorRcPtr *) display->from_scene_linear);
+                       OCIO_processorRelease((OCIO_ConstProcessorRcPtr *) display->from_scene_linear);
 
                /* free list of views */
                BLI_freelistN(&display->views);
@@ -562,7 +562,7 @@ void colormanagement_init(void)
        const char *ocio_env;
        const char *configdir;
        char configfile[FILE_MAX];
-       ConstConfigRcPtr *config = NULL;
+       OCIO_ConstConfigRcPtr *config = NULL;
 
        OCIO_init();
 
@@ -649,7 +649,7 @@ static void display_transform_get_from_ctx(const bContext *C, ColorManagedViewSe
 static const char *display_transform_get_colorspace_name(const ColorManagedViewSettings *view_settings,
                                                          const ColorManagedDisplaySettings *display_settings)
 {
-       ConstConfigRcPtr *config = OCIO_getCurrentConfig();
+       OCIO_ConstConfigRcPtr *config = OCIO_getCurrentConfig();
 
        const char *display = display_settings->display_device;
        const char *view = view_settings->view_transform;
@@ -673,12 +673,12 @@ static ColorSpace *display_transform_get_colorspace(const ColorManagedViewSettin
        return NULL;
 }
 
-static ConstProcessorRcPtr *create_display_buffer_processor(const char *view_transform, const char *display,
+static OCIO_ConstProcessorRcPtr *create_display_buffer_processor(const char *view_transform, const char *display,
                                                             float exposure, float gamma)
 {
-       ConstConfigRcPtr *config = OCIO_getCurrentConfig();
-       DisplayTransformRcPtr *dt;
-       ConstProcessorRcPtr *processor;
+       OCIO_ConstConfigRcPtr *config = OCIO_getCurrentConfig();
+       OCIO_DisplayTransformRcPtr *dt;
+       OCIO_ConstProcessorRcPtr *processor;
 
        dt = OCIO_createDisplayTransform();
 
@@ -689,7 +689,7 @@ static ConstProcessorRcPtr *create_display_buffer_processor(const char *view_tra
 
        /* fstop exposure control */
        if (exposure != 0.0f) {
-               MatrixTransformRcPtr *mt;
+               OCIO_MatrixTransformRcPtr *mt;
                float gain = powf(2.0f, exposure);
                const float scale4f[] = {gain, gain, gain, gain};
                float m44[16], offset4[4];
@@ -697,25 +697,25 @@ static ConstProcessorRcPtr *create_display_buffer_processor(const char *view_tra
                OCIO_matrixTransformScale(m44, offset4, scale4f);
                mt = OCIO_createMatrixTransform();
                OCIO_matrixTransformSetValue(mt, m44, offset4);
-               OCIO_displayTransformSetLinearCC(dt, (ConstTransformRcPtr *) mt);
+               OCIO_displayTransformSetLinearCC(dt, (OCIO_ConstTransformRcPtr *) mt);
 
                OCIO_matrixTransformRelease(mt);
        }
 
        /* post-display gamma transform */
        if (gamma != 1.0f) {
-               ExponentTransformRcPtr *et;
+               OCIO_ExponentTransformRcPtr *et;
                float exponent = 1.0f / MAX2(FLT_EPSILON, gamma);
                const float exponent4f[] = {exponent, exponent, exponent, exponent};
 
                et = OCIO_createExponentTransform();
                OCIO_exponentTransformSetValue(et, exponent4f);
-               OCIO_displayTransformSetDisplayCC(dt, (ConstTransformRcPtr *) et);
+               OCIO_displayTransformSetDisplayCC(dt, (OCIO_ConstTransformRcPtr *) et);
 
                OCIO_exponentTransformRelease(et);
        }
 
-       processor = OCIO_configGetProcessor(config, (ConstTransformRcPtr *) dt);
+       processor = OCIO_configGetProcessor(config, (OCIO_ConstTransformRcPtr *) dt);
 
        OCIO_displayTransformRelease(dt);
        OCIO_configRelease(config);
@@ -723,11 +723,11 @@ static ConstProcessorRcPtr *create_display_buffer_processor(const char *view_tra
        return processor;
 }
 
-static ConstProcessorRcPtr *create_colorspace_transform_processor(const char *from_colorspace,
+static OCIO_ConstProcessorRcPtr *create_colorspace_transform_processor(const char *from_colorspace,
                                                                   const char *to_colorspace)
 {
-       ConstConfigRcPtr *config = OCIO_getCurrentConfig();
-       ConstProcessorRcPtr *processor;
+       OCIO_ConstConfigRcPtr *config = OCIO_getCurrentConfig();
+       OCIO_ConstProcessorRcPtr *processor;
 
        processor = OCIO_configGetProcessorWithNames(config, from_colorspace, to_colorspace);
 
@@ -736,49 +736,49 @@ static ConstProcessorRcPtr *create_colorspace_transform_processor(const char *fr
        return processor;
 }
 
-static ConstProcessorRcPtr *colorspace_to_scene_linear_processor(ColorSpace *colorspace)
+static OCIO_ConstProcessorRcPtr *colorspace_to_scene_linear_processor(ColorSpace *colorspace)
 {
        if (colorspace->to_scene_linear == NULL) {
                BLI_mutex_lock(&processor_lock);
 
                if (colorspace->to_scene_linear == NULL) {
-                       ConstProcessorRcPtr *to_scene_linear;
+                       OCIO_ConstProcessorRcPtr *to_scene_linear;
                        to_scene_linear = create_colorspace_transform_processor(colorspace->name, global_role_scene_linear);
-                       colorspace->to_scene_linear = (struct ConstProcessorRcPtr *) to_scene_linear;
+                       colorspace->to_scene_linear = (struct OCIO_ConstProcessorRcPtr *) to_scene_linear;
                }
 
                BLI_mutex_unlock(&processor_lock);
        }
 
-       return (ConstProcessorRcPtr *) colorspace->to_scene_linear;
+       return (OCIO_ConstProcessorRcPtr *) colorspace->to_scene_linear;
 }
 
-static ConstProcessorRcPtr *colorspace_from_scene_linear_processor(ColorSpace *colorspace)
+static OCIO_ConstProcessorRcPtr *colorspace_from_scene_linear_processor(ColorSpace *colorspace)
 {
        if (colorspace->from_scene_linear == NULL) {
                BLI_mutex_lock(&processor_lock);
 
                if (colorspace->from_scene_linear == NULL) {
-                       ConstProcessorRcPtr *from_scene_linear;
+                       OCIO_ConstProcessorRcPtr *from_scene_linear;
                        from_scene_linear = create_colorspace_transform_processor(global_role_scene_linear, colorspace->name);
-                       colorspace->from_scene_linear = (struct ConstProcessorRcPtr *) from_scene_linear;
+                       colorspace->from_scene_linear = (struct OCIO_ConstProcessorRcPtr *) from_scene_linear;
                }
 
                BLI_mutex_unlock(&processor_lock);
        }
 
-       return (ConstProcessorRcPtr *) colorspace->from_scene_linear;
+       return (OCIO_ConstProcessorRcPtr *) colorspace->from_scene_linear;
 }
 
-static ConstProcessorRcPtr *display_from_scene_linear_processor(ColorManagedDisplay *display)
+static OCIO_ConstProcessorRcPtr *display_from_scene_linear_processor(ColorManagedDisplay *display)
 {
        if (display->from_scene_linear == NULL) {
                BLI_mutex_lock(&processor_lock);
 
                if (display->from_scene_linear == NULL) {
                        const char *view_name = colormanage_view_get_default_name(display);
-                       ConstConfigRcPtr *config = OCIO_getCurrentConfig();
-                       ConstProcessorRcPtr *processor = NULL;
+                       OCIO_ConstConfigRcPtr *config = OCIO_getCurrentConfig();
+                       OCIO_ConstProcessorRcPtr *processor = NULL;
 
                        if (view_name && config) {
                                const char *view_colorspace = OCIO_configGetDisplayColorSpaceName(config, display->name, view_name);
@@ -787,24 +787,24 @@ static ConstProcessorRcPtr *display_from_scene_linear_processor(ColorManagedDisp
                                OCIO_configRelease(config);
                        }
 
-                       display->from_scene_linear = (struct ConstProcessorRcPtr *) processor;
+                       display->from_scene_linear = (struct OCIO_ConstProcessorRcPtr *) processor;
                }
 
                BLI_mutex_unlock(&processor_lock);
        }
 
-       return (ConstProcessorRcPtr *) display->from_scene_linear;
+       return (OCIO_ConstProcessorRcPtr *) display->from_scene_linear;
 }
 
-static ConstProcessorRcPtr *display_to_scene_linear_processor(ColorManagedDisplay *display)
+static OCIO_ConstProcessorRcPtr *display_to_scene_linear_processor(ColorManagedDisplay *display)
 {
        if (display->to_scene_linear == NULL) {
                BLI_mutex_lock(&processor_lock);
 
                if (display->to_scene_linear == NULL) {
                        const char *view_name = colormanage_view_get_default_name(display);
-                       ConstConfigRcPtr *config = OCIO_getCurrentConfig();
-                       ConstProcessorRcPtr *processor = NULL;
+                       OCIO_ConstConfigRcPtr *config = OCIO_getCurrentConfig();
+                       OCIO_ConstProcessorRcPtr *processor = NULL;
 
                        if (view_name && config) {
                                const char *view_colorspace = OCIO_configGetDisplayColorSpaceName(config, display->name, view_name);
@@ -813,13 +813,13 @@ static ConstProcessorRcPtr *display_to_scene_linear_processor(ColorManagedDispla
                                OCIO_configRelease(config);
                        }
 
-                       display->to_scene_linear = (struct ConstProcessorRcPtr *) processor;
+                       display->to_scene_linear = (struct OCIO_ConstProcessorRcPtr *) processor;
                }
 
                BLI_mutex_unlock(&processor_lock);
        }
 
-       return (ConstProcessorRcPtr *) display->to_scene_linear;
+       return (OCIO_ConstProcessorRcPtr *) display->to_scene_linear;
 }
 
 static void init_default_view_settings(const ColorManagedDisplaySettings *display_settings,
@@ -1533,7 +1533,7 @@ void IMB_colormanagement_transform_v4(float pixel[4], const char *from_colorspac
  */
 void IMB_colormanagement_colorspace_to_scene_linear_v3(float pixel[3], ColorSpace *colorspace)
 {
-       ConstProcessorRcPtr *processor;
+       OCIO_ConstProcessorRcPtr *processor;
 
        if (!colorspace) {
                /* should never happen */
@@ -1550,7 +1550,7 @@ void IMB_colormanagement_colorspace_to_scene_linear_v3(float pixel[3], ColorSpac
 /* same as above, but converts colors in opposite direction */
 void IMB_colormanagement_scene_linear_to_colorspace_v3(float pixel[3], ColorSpace *colorspace)
 {
-       ConstProcessorRcPtr *processor;
+       OCIO_ConstProcessorRcPtr *processor;
 
        if (!colorspace) {
                /* should never happen */
@@ -1566,7 +1566,7 @@ void IMB_colormanagement_scene_linear_to_colorspace_v3(float pixel[3], ColorSpac
 
 void IMB_colormanagement_colorspace_to_scene_linear(float *buffer, int width, int height, int channels, struct ColorSpace *colorspace, int predivide)
 {
-       ConstProcessorRcPtr *processor;
+       OCIO_ConstProcessorRcPtr *processor;
 
        if (!colorspace) {
                /* should never happen */
@@ -1577,9 +1577,9 @@ void IMB_colormanagement_colorspace_to_scene_linear(float *buffer, int width, in
        processor = colorspace_to_scene_linear_processor(colorspace);
 
        if (processor) {
-               PackedImageDesc *img;
+               OCIO_PackedImageDesc *img;
 
-               img = OCIO_createPackedImageDesc(buffer, width, height, channels, sizeof(float),
+               img = OCIO_createOCIO_PackedImageDesc(buffer, width, height, channels, sizeof(float),
                                                 channels * sizeof(float), channels * sizeof(float) * width);
 
                if (predivide)
@@ -1587,7 +1587,7 @@ void IMB_colormanagement_colorspace_to_scene_linear(float *buffer, int width, in
                else
                        OCIO_processorApply(processor, img);
 
-               OCIO_packedImageDescRelease(img);
+               OCIO_OCIO_PackedImageDescRelease(img);
        }
 }
 
@@ -1597,7 +1597,7 @@ void IMB_colormanagement_colorspace_to_scene_linear(float *buffer, int width, in
  */
 void IMB_colormanagement_scene_linear_to_display_v3(float pixel[3], ColorManagedDisplay *display)
 {
-       ConstProcessorRcPtr *processor;
+       OCIO_ConstProcessorRcPtr *processor;
 
        processor = display_from_scene_linear_processor(display);
 
@@ -1608,7 +1608,7 @@ void IMB_colormanagement_scene_linear_to_display_v3(float pixel[3], ColorManaged
 /* same as above, but converts color in opposite direction */
 void IMB_colormanagement_display_to_scene_linear_v3(float pixel[3], ColorManagedDisplay *display)
 {
-       ConstProcessorRcPtr *processor;
+       OCIO_ConstProcessorRcPtr *processor;
 
        processor = display_to_scene_linear_processor(display);
 
@@ -1892,7 +1892,7 @@ void IMB_display_buffer_release(void *cache_handle)
 
 const char *colormanage_display_get_default_name(void)
 {
-       ConstConfigRcPtr *config = OCIO_getCurrentConfig();
+       OCIO_ConstConfigRcPtr *config = OCIO_getCurrentConfig();
        const char *display_name;
 
        display_name = OCIO_configGetDefaultDisplay(config);
@@ -2003,7 +2003,7 @@ const char *IMB_colormanagement_display_get_none_name(void)
 
 const char *colormanage_view_get_default_name(const ColorManagedDisplay *display)
 {
-       ConstConfigRcPtr *config = OCIO_getCurrentConfig();
+       OCIO_ConstConfigRcPtr *config = OCIO_getCurrentConfig();
        const char *name;
 
        name = OCIO_configGetDefaultView(config, display->name);
@@ -2511,10 +2511,10 @@ void IMB_colormanagement_processor_apply(ColormanageProcessor *cm_processor, flo
        }
 
        if (cm_processor->processor && channels >= 3) {
-               PackedImageDesc *img;
+               OCIO_PackedImageDesc *img;
 
                /* apply OCIO processor */
-               img = OCIO_createPackedImageDesc(buffer, width, height, channels, sizeof(float),
+               img = OCIO_createOCIO_PackedImageDesc(buffer, width, height, channels, sizeof(float),
                                                 channels * sizeof(float), channels * sizeof(float) * width);
 
                if (predivide)
@@ -2522,7 +2522,7 @@ void IMB_colormanagement_processor_apply(ColormanageProcessor *cm_processor, flo
                else
                        OCIO_processorApply(cm_processor->processor, img);
 
-               OCIO_packedImageDescRelease(img);
+               OCIO_OCIO_PackedImageDescRelease(img);
        }
 }