intern/opencolorio/ocio_capi.cpp

   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): Xavier Thomas
  22  *                 Lukas Toene
  23  *
  24  * ***** END GPL LICENSE BLOCK *****
  25  */
  26
  27 #include <iostream>
  28
  29 #include <OpenColorIO/OpenColorIO.h>
  30
  31
  32 #define OCIO_CAPI_IMPLEMENTATION
  33 #include "ocio_capi.h"
  34
  35 ConstConfigRcPtr* OCIO_getCurrentConfig(void)
  36 {
  37         ConstConfigRcPtr* config =  new ConstConfigRcPtr();
  38         try
  39         {
  40                 *config = GetCurrentConfig();
  41                 if(*config)
  42                         return config;
  43         }
  44         catch(Exception & exception)
  45         {
  46                 std::cerr << "OpenColorIO Error: " << exception.what() << std::endl;
  47         }
  48         return 0;
  49 }
  50
  51 void OCIO_setCurrentConfig(const ConstConfigRcPtr* config)
  52 {
  53         if(config)
  54         {
  55                 try
  56                 {
  57                         SetCurrentConfig(*config);
  58                 }
  59                 catch(Exception & exception)
  60                 {
  61                         std::cerr << "OpenColorIO Error: " << exception.what() << std::endl;
  62                 }
  63         }
  64 }
  65
  66 ConstConfigRcPtr* OCIO_configCreateFromEnv(void)
  67 {
  68         ConstConfigRcPtr* config =  new ConstConfigRcPtr();
  69         try
  70         {
  71                 *config = Config::CreateFromEnv();
  72                 if(*config)
  73                         return config;
  74         }
  75         catch(Exception & exception)
  76         {
  77                 std::cerr << "OpenColorIO Error: " << exception.what() << std::endl;
  78         }
  79         return 0;
  80 }
  81
  82
  83 ConstConfigRcPtr* OCIO_configCreateFromFile(const char* filename)
  84 {
  85         ConstConfigRcPtr* config =  new ConstConfigRcPtr();
  86         try
  87         {
  88                 *config = Config::CreateFromFile(filename);
  89                 if(*config)
  90                         return config;
  91         }
  92         catch(Exception & exception)
  93         {
  94                 std::cerr << "OpenColorIO Error: " << exception.what() << std::endl;
  95         }
  96         return 0;
  97 }
  98
  99 void OCIO_configRelease(ConstConfigRcPtr* config)
 100 {
 101         if(config){
 102                 delete config;
 103                 config =0;
 104         }
 105 }
 106
 107 int OCIO_configGetNumColorSpaces(ConstConfigRcPtr* config)
 108 {
 109         try
 110         {
 111                 return (*config)->getNumColorSpaces();
 112         }
 113         catch(Exception & exception)
 114         {
 115                 std::cerr << "OpenColorIO Error: " << exception.what() << std::endl;
 116         }
 117         return 0;
 118 }
 119
 120 const char* OCIO_configGetColorSpaceNameByIndex(ConstConfigRcPtr* config, int index)
 121 {
 122         try
 123         {
 124                 return (*config)->getColorSpaceNameByIndex(index);
 125         }
 126         catch(Exception & exception)
 127         {
 128                 std::cerr << "OpenColorIO Error: " << exception.what() << std::endl;
 129         }
 130         return 0;
 131 }
 132
 133 ConstColorSpaceRcPtr* OCIO_configGetColorSpace(ConstConfigRcPtr* config, const char* name)
 134 {
 135         ConstColorSpaceRcPtr* cs =  new ConstColorSpaceRcPtr();
 136         try
 137         {
 138                 *cs = (*config)->getColorSpace(name);
 139                 if(*cs)
 140                         return cs;
 141         }
 142         catch(Exception & exception)
 143         {
 144                 std::cerr << "OpenColorIO Error: " << exception.what() << std::endl;
 145                 delete cs;
 146         }
 147         return 0;
 148 }
 149
 150 int OCIO_configGetIndexForColorSpace(ConstConfigRcPtr* config, const char* name)
 151 {
 152         try
 153         {
 154                 return (*config)->getIndexForColorSpace(name);
 155         }
 156         catch(Exception & exception)
 157         {
 158                 std::cerr << "OpenColorIO Error: " << exception.what() << std::endl;
 159         }
 160         return -1;
 161 }
 162
 163 const char* OCIO_configGetDefaultDisplay(ConstConfigRcPtr* config)
 164 {
 165         try
 166         {
 167                 return (*config)->getDefaultDisplay();
 168         }
 169         catch(Exception & exception)
 170         {
 171                 std::cerr << "OpenColorIO Error: " << exception.what() << std::endl;
 172         }
 173         return 0;
 174 }
 175
 176 int OCIO_configGetNumDisplays(ConstConfigRcPtr* config)
 177 {
 178         try
 179         {
 180                 return (*config)->getNumDisplays();
 181         }
 182         catch(Exception & exception)
 183         {
 184                 std::cerr << "OpenColorIO Error: " << exception.what() << std::endl;
 185         }
 186         return 0;
 187 }
 188
 189 const char* OCIO_configGetDisplay(ConstConfigRcPtr* config, int index)
 190 {
 191         try
 192         {
 193                 return (*config)->getDisplay(index);
 194         }
 195         catch(Exception & exception)
 196         {
 197                 std::cerr << "OpenColorIO Error: " << exception.what() << std::endl;
 198         }
 199         return 0;
 200 }
 201
 202 const char* OCIO_configGetDefaultView(ConstConfigRcPtr* config, const char* display)
 203 {
 204         try
 205         {
 206                 return (*config)->getDefaultView(display);
 207         }
 208         catch(Exception & exception)
 209         {
 210                 std::cerr << "OpenColorIO Error: " << exception.what() << std::endl;
 211         }
 212         return 0;
 213 }
 214
 215 int OCIO_configGetNumViews(ConstConfigRcPtr* config, const char* display)
 216 {
 217         try
 218         {
 219                 return (*config)->getNumViews(display);
 220         }
 221         catch(Exception & exception)
 222         {
 223                 std::cerr << "OpenColorIO Error: " << exception.what() << std::endl;
 224         }
 225         return 0;
 226 }
 227
 228 const char* OCIO_configGetView(ConstConfigRcPtr* config, const char* display, int index)
 229 {
 230         try
 231         {
 232                 return (*config)->getView(display, index);
 233         }
 234         catch(Exception & exception)
 235         {
 236                 std::cerr << "OpenColorIO Error: " << exception.what() << std::endl;
 237         }
 238         return 0;
 239 }
 240
 241 const char* OCIO_configGetDisplayColorSpaceName(ConstConfigRcPtr* config, const char* display, const char* view)
 242 {
 243         try
 244         {
 245                 return (*config)->getDisplayColorSpaceName(display, view);
 246         }
 247         catch(Exception & exception)
 248         {
 249                 std::cerr << "OpenColorIO Error: " << exception.what() << std::endl;
 250         }
 251         return 0;
 252 }
 253
 254
 255
 256
 257 void OCIO_colorSpaceRelease(ConstColorSpaceRcPtr* cs)
 258 {
 259         if(cs){
 260                 delete cs;
 261                 cs =0;
 262         }
 263 }
 264
 265
 266
 267
 268
 269 ConstProcessorRcPtr* OCIO_configGetProcessorWithNames(ConstConfigRcPtr* config, const char* srcName, const char* dstName)
 270 {
 271         ConstProcessorRcPtr* p =  new ConstProcessorRcPtr();
 272         try
 273         {
 274                 *p = (*config)->getProcessor(srcName, dstName);
 275                 if(*p)
 276                         return p;
 277         }
 278         catch(Exception & exception)
 279         {
 280                 std::cerr << "OpenColorIO Error: " << exception.what() << std::endl;
 281         }
 282         return 0;
 283 }
 284
 285 extern ConstProcessorRcPtr* OCIO_configGetProcessor(ConstConfigRcPtr* config, ConstTransformRcPtr* transform)
 286 {
 287         ConstProcessorRcPtr* p =  new ConstProcessorRcPtr();
 288         try
 289         {
 290                 *p = (*config)->getProcessor(*transform);
 291                 if(*p)
 292                         return p;
 293         }
 294         catch(Exception & exception)
 295         {
 296                 std::cerr << "OpenColorIO Error: " << exception.what() << std::endl;
 297         }
 298         return 0;
 299 }
 300
 301 void OCIO_processorApply(ConstProcessorRcPtr* processor, PackedImageDesc* img)
 302 {
 303         try
 304         {
 305                 (*processor)->apply(*img);
 306         }
 307         catch(Exception & exception)
 308         {
 309                 std::cerr << "OpenColorIO Error: " << exception.what() << std::endl;
 310         }
 311 }
 312
 313 void OCIO_processorApplyRGB(ConstProcessorRcPtr* processor, float* pixel)
 314 {
 315         (*processor)->applyRGB(pixel);
 316 }
 317
 318 void OCIO_processorApplyRGBA(ConstProcessorRcPtr* processor, float* pixel)
 319 {
 320         (*processor)->applyRGBA(pixel);
 321 }
 322
 323 void OCIO_processorRelease(ConstProcessorRcPtr* p)
 324 {
 325         if(p){
 326                 delete p;
 327                 p = 0;
 328         }
 329 }
 330
 331 const char* OCIO_colorSpaceGetName(ConstColorSpaceRcPtr* cs)
 332 {
 333         return (*cs)->getName();
 334 }
 335
 336 const char* OCIO_colorSpaceGetFamily(ConstColorSpaceRcPtr* cs)
 337 {
 338         return (*cs)->getFamily();
 339 }
 340
 341
 342 extern DisplayTransformRcPtr* OCIO_createDisplayTransform(void)
 343 {
 344         DisplayTransformRcPtr* dt =  new DisplayTransformRcPtr();
 345         *dt = DisplayTransform::Create();
 346         return dt;
 347 }
 348
 349 extern void OCIO_displayTransformSetInputColorSpaceName(DisplayTransformRcPtr* dt, const char * name)
 350 {
 351         (*dt)->setInputColorSpaceName(name);
 352 }
 353
 354 extern void OCIO_displayTransformSetDisplay(DisplayTransformRcPtr* dt, const char * name)
 355 {
 356         (*dt)->setDisplay(name);
 357 }
 358
 359 extern void OCIO_displayTransformSetView(DisplayTransformRcPtr* dt, const char * name)
 360 {
 361         (*dt)->setView(name);
 362 }
 363
 364 extern void OCIO_displayTransformSetDisplayCC(DisplayTransformRcPtr *dt, ConstTransformRcPtr *t)
 365 {
 366         (*dt)->setDisplayCC(*t);
 367 }
 368
 369 extern void OCIO_displayTransformSetLinearCC(DisplayTransformRcPtr *dt, ConstTransformRcPtr *t)
 370 {
 371         (*dt)->setLinearCC(*t);
 372 }
 373
 374 extern void OCIO_displayTransformRelease(DisplayTransformRcPtr* dt)
 375 {
 376         if(dt){
 377                 delete dt;
 378                 dt = 0;
 379         }
 380 }
 381
 382 PackedImageDesc* OCIO_createPackedImageDesc(float * data, long width, long height, long numChannels,
 383                                                                                         long chanStrideBytes, long xStrideBytes, long yStrideBytes)
 384 {
 385         try
 386         {
 387                 PackedImageDesc* id = new PackedImageDesc(data, width, height, numChannels, chanStrideBytes, xStrideBytes, yStrideBytes);
 388                 return id;
 389         }
 390         catch(Exception & exception)
 391         {
 392                 std::cerr << "OpenColorIO Error: " << exception.what() << std::endl;
 393         }
 394         return 0;
 395 }
 396
 397 void OCIO_packedImageDescRelease(PackedImageDesc* id)
 398 {
 399         if(id){
 400                 delete id;
 401                 id = 0;
 402         }
 403 }
 404
 405 ExponentTransformRcPtr *OCIO_createExponentTransform(void)
 406 {
 407         ExponentTransformRcPtr *et =  new ExponentTransformRcPtr();
 408
 409         *et = ExponentTransform::Create();
 410
 411         return et;
 412 }
 413
 414 void OCIO_exponentTransformSetValue(ExponentTransformRcPtr *et, const float *exponent)
 415 {
 416         (*et)->setValue(exponent);
 417 }
 418
 419 void OCIO_exponentTransformRelease(ExponentTransformRcPtr *et)
 420 {
 421         delete et;
 422 }
 423
 424 MatrixTransformRcPtr *OCIO_createMatrixTransform(void)
 425 {
 426         MatrixTransformRcPtr *mt =  new MatrixTransformRcPtr();
 427
 428         *mt = MatrixTransform::Create();
 429
 430         return mt;
 431 }
 432
 433 void OCIO_matrixTransformSetValue(MatrixTransformRcPtr *mt, const float *m44, const float *offset4)
 434 {
 435         (*mt)->setValue(m44, offset4);
 436 }
 437
 438 void OCIO_matrixTransformRelease(MatrixTransformRcPtr *mt)
 439 {
 440         delete mt;
 441 }
 442
 443 void OCIO_matrixTransformScale(float * m44, float * offset4, const float *scale4f)
 444 {
 445         MatrixTransform::Scale(m44, offset4, scale4f);
 446 }