kannonier8/blender
1
0
Fork 0
forked from bartvdbraak/blender
Code Pull Requests Activity

Fixed compilation error on widows

Browse Source 
Was caused by mixing up own C-API typedefs with OCIO's
This commit is contained in:
Sergey Sharybin 2012-10-05 10:05:26 +00:00
parent 862decfc82
commit 4c3620c69d
8 changed files with 466 additions and 471 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
intern/opencolorio/CMakeLists.txt
View File

@ -62,4 +62,3 @@ endif()
blender_add_lib(bf_intern_opencolorio "${SRC}" "${INC}" "${INC_SYS}")

130
intern/opencolorio/fallback_impl.cc
View File

@ -28,20 +28,18 @@
#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 *)
{
}

98
intern/opencolorio/ocio_capi.cc
View 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);
}

125
intern/opencolorio/ocio_capi.h
View File

@ -29,96 +29,93 @@
#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"
#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
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);

195
intern/opencolorio/ocio_impl.cc
View File

@ -30,9 +30,10 @@
#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)

270
intern/opencolorio/ocio_impl.h
View 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);
};

10
source/blender/imbuf/intern/IMB_colormanagement_intern.h
View 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 {

108
source/blender/imbuf/intern/colormanagement.c
View 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);
}
}