intern/opencolorio/ocio_capi.cc

   1 /*
   2  * ***** BEGIN GPL LICENSE BLOCK *****
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software Foundation,
  16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17  *
  18  * The Original Code is Copyright (C) 2012 Blender Foundation.
  19  * All rights reserved.
  20  *
  21  * Contributor(s): Sergey Sharybin
  22  *
  23  * ***** END GPL LICENSE BLOCK *****
  24  */
  25
  26 #include "MEM_guardedalloc.h"
  27
  28 #include "ocio_impl.h"
  29
  30 static IOCIOImpl *impl = NULL;
  31
  32 void OCIO_init(void)
  33 {
  34 #ifdef WITH_OCIO
  35         impl = new OCIOImpl();
  36 #else
  37         impl = new FallbackImpl();
  38 #endif
  39 }
  40
  41 void OCIO_exit(void)
  42 {
  43         delete impl;
  44         impl = NULL;
  45 }
  46
  47 OCIO_ConstConfigRcPtr *OCIO_getCurrentConfig(void)
  48 {
  49         return impl->getCurrentConfig();
  50 }
  51
  52 OCIO_ConstConfigRcPtr *OCIO_configCreateFallback(void)
  53 {
  54         delete impl;
  55         impl = new FallbackImpl();
  56
  57         return impl->getCurrentConfig();
  58 }
  59
  60 void OCIO_setCurrentConfig(const OCIO_ConstConfigRcPtr *config)
  61 {
  62         impl->setCurrentConfig(config);
  63 }
  64
  65 OCIO_ConstConfigRcPtr *OCIO_configCreateFromEnv(void)
  66 {
  67         return impl->configCreateFromEnv();
  68 }
  69
  70 OCIO_ConstConfigRcPtr *OCIO_configCreateFromFile(const char *filename)
  71 {
  72         return impl->configCreateFromFile(filename);
  73 }
  74
  75 void OCIO_configRelease(OCIO_ConstConfigRcPtr *config)
  76 {
  77         impl->configRelease(config);
  78 }
  79
  80 int OCIO_configGetNumColorSpaces(OCIO_ConstConfigRcPtr *config)
  81 {
  82         return impl->configGetNumColorSpaces(config);
  83 }
  84
  85 const char *OCIO_configGetColorSpaceNameByIndex(OCIO_ConstConfigRcPtr *config, int index)
  86 {
  87         return impl->configGetColorSpaceNameByIndex(config, index);
  88 }
  89
  90 OCIO_ConstColorSpaceRcPtr *OCIO_configGetColorSpace(OCIO_ConstConfigRcPtr *config, const char *name)
  91 {
  92         return impl->configGetColorSpace(config, name);
  93 }
  94
  95 int OCIO_configGetIndexForColorSpace(OCIO_ConstConfigRcPtr *config, const char *name)
  96 {
  97         return impl->configGetIndexForColorSpace(config, name);
  98 }
  99
 100 const char *OCIO_configGetDefaultDisplay(OCIO_ConstConfigRcPtr *config)
 101 {
 102         return impl->configGetDefaultDisplay(config);
 103 }
 104
 105 int OCIO_configGetNumDisplays(OCIO_ConstConfigRcPtr* config)
 106 {
 107         return impl->configGetNumDisplays(config);
 108 }
 109
 110 const char *OCIO_configGetDisplay(OCIO_ConstConfigRcPtr *config, int index)
 111 {
 112         return impl->configGetDisplay(config, index);
 113 }
 114
 115 const char *OCIO_configGetDefaultView(OCIO_ConstConfigRcPtr *config, const char *display)
 116 {
 117         return impl->configGetDefaultView(config, display);
 118 }
 119
 120 int OCIO_configGetNumViews(OCIO_ConstConfigRcPtr *config, const char *display)
 121 {
 122         return impl->configGetNumViews(config, display);
 123 }
 124
 125 const char *OCIO_configGetView(OCIO_ConstConfigRcPtr *config, const char *display, int index)
 126 {
 127         return impl->configGetView(config, display, index);
 128 }
 129
 130 const char *OCIO_configGetDisplayColorSpaceName(OCIO_ConstConfigRcPtr *config, const char *display, const char *view)
 131 {
 132         return impl->configGetDisplayColorSpaceName(config, display, view);
 133 }
 134
 135 int OCIO_colorSpaceIsInvertible(OCIO_ConstColorSpaceRcPtr *cs)
 136 {
 137         return impl->colorSpaceIsInvertible(cs);
 138 }
 139
 140 int OCIO_colorSpaceIsData(OCIO_ConstColorSpaceRcPtr *cs)
 141 {
 142         return impl->colorSpaceIsData(cs);
 143 }
 144
 145 void OCIO_colorSpaceRelease(OCIO_ConstColorSpaceRcPtr *cs)
 146 {
 147         impl->colorSpaceRelease(cs);
 148 }
 149
 150 OCIO_ConstProcessorRcPtr *OCIO_configGetProcessorWithNames(OCIO_ConstConfigRcPtr *config, const char *srcName, const char *dstName)
 151 {
 152         return impl->configGetProcessorWithNames(config, srcName, dstName);
 153 }
 154
 155 OCIO_ConstProcessorRcPtr *OCIO_configGetProcessor(OCIO_ConstConfigRcPtr *config, OCIO_ConstTransformRcPtr *transform)
 156 {
 157         return impl->configGetProcessor(config, transform);
 158 }
 159
 160 void OCIO_processorApply(OCIO_ConstProcessorRcPtr *processor, OCIO_PackedImageDesc *img)
 161 {
 162         impl->processorApply(processor, img);
 163 }
 164
 165 void OCIO_processorApply_predivide(OCIO_ConstProcessorRcPtr *processor, OCIO_PackedImageDesc *img)
 166 {
 167         impl->processorApply_predivide(processor, img);
 168 }
 169
 170 void OCIO_processorApplyRGB(OCIO_ConstProcessorRcPtr *processor, float *pixel)
 171 {
 172         impl->processorApplyRGB(processor, pixel);
 173 }
 174
 175 void OCIO_processorApplyRGBA(OCIO_ConstProcessorRcPtr *processor, float *pixel)
 176 {
 177         impl->processorApplyRGBA(processor, pixel);
 178 }
 179
 180 void OCIO_processorApplyRGBA_predivide(OCIO_ConstProcessorRcPtr *processor, float *pixel)
 181 {
 182         impl->processorApplyRGBA_predivide(processor, pixel);
 183 }
 184
 185 void OCIO_processorRelease(OCIO_ConstProcessorRcPtr *p)
 186 {
 187         impl->processorRelease(p);
 188 }
 189
 190 const char *OCIO_colorSpaceGetName(OCIO_ConstColorSpaceRcPtr *cs)
 191 {
 192         return impl->colorSpaceGetName(cs);
 193 }
 194
 195 const char *OCIO_colorSpaceGetDescription(OCIO_ConstColorSpaceRcPtr *cs)
 196 {
 197         return impl->colorSpaceGetDescription(cs);
 198 }
 199
 200 const char *OCIO_colorSpaceGetFamily(OCIO_ConstColorSpaceRcPtr *cs)
 201 {
 202         return impl->colorSpaceGetFamily(cs);
 203 }
 204
 205 OCIO_DisplayTransformRcPtr *OCIO_createDisplayTransform(void)
 206 {
 207         return impl->createDisplayTransform();
 208 }
 209
 210 void OCIO_displayTransformSetInputColorSpaceName(OCIO_DisplayTransformRcPtr *dt, const char *name)
 211 {
 212         impl->displayTransformSetInputColorSpaceName(dt, name);
 213 }
 214
 215 void OCIO_displayTransformSetDisplay(OCIO_DisplayTransformRcPtr *dt, const char *name)
 216 {
 217         impl->displayTransformSetDisplay(dt, name);
 218 }
 219
 220 void OCIO_displayTransformSetView(OCIO_DisplayTransformRcPtr *dt, const char *name)
 221 {
 222         impl->displayTransformSetView(dt, name);
 223 }
 224
 225 void OCIO_displayTransformSetDisplayCC(OCIO_DisplayTransformRcPtr *dt, OCIO_ConstTransformRcPtr *t)
 226 {
 227         impl->displayTransformSetDisplayCC(dt, t);
 228 }
 229
 230 void OCIO_displayTransformSetLinearCC(OCIO_DisplayTransformRcPtr *dt, OCIO_ConstTransformRcPtr *t)
 231 {
 232         impl->displayTransformSetLinearCC(dt, t);
 233 }
 234
 235 void OCIO_displayTransformRelease(OCIO_DisplayTransformRcPtr *dt)
 236 {
 237         impl->displayTransformRelease(dt);
 238 }
 239
 240 OCIO_PackedImageDesc *OCIO_createOCIO_PackedImageDesc(float *data, long width, long height, long numChannels,
 241                                                       long chanStrideBytes, long xStrideBytes, long yStrideBytes)
 242 {
 243         return impl->createOCIO_PackedImageDesc(data, width, height, numChannels, chanStrideBytes, xStrideBytes, yStrideBytes);
 244 }
 245
 246 void OCIO_PackedImageDescRelease(OCIO_PackedImageDesc* id)
 247 {
 248         impl->OCIO_PackedImageDescRelease(id);
 249 }
 250
 251 OCIO_ExponentTransformRcPtr *OCIO_createExponentTransform(void)
 252 {
 253         return impl->createExponentTransform();
 254 }
 255
 256 void OCIO_exponentTransformSetValue(OCIO_ExponentTransformRcPtr *et, const float *exponent)
 257 {
 258         impl->exponentTransformSetValue(et, exponent);
 259 }
 260
 261 void OCIO_exponentTransformRelease(OCIO_ExponentTransformRcPtr *et)
 262 {
 263         impl->exponentTransformRelease(et);
 264 }
 265
 266 OCIO_MatrixTransformRcPtr *OCIO_createMatrixTransform(void)
 267 {
 268         return impl->createMatrixTransform();
 269 }
 270
 271 void OCIO_matrixTransformSetValue(OCIO_MatrixTransformRcPtr *mt, const float *m44, const float *offset4)
 272 {
 273         impl->matrixTransformSetValue(mt, m44, offset4);
 274 }
 275
 276 void OCIO_matrixTransformRelease(OCIO_MatrixTransformRcPtr *mt)
 277 {
 278         impl->matrixTransformRelease(mt);
 279 }
 280
 281 void OCIO_matrixTransformScale(float * m44, float * offset4, const float *scale4f)
 282 {
 283         impl->matrixTransformScale(m44, offset4, scale4f);
 284 }