intern/opencolorio/ocio_capi_stub.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): Brecht van Lommel
  22  *
  23  * ***** END GPL LICENSE BLOCK *****
  24  */
  25
  26 #include <string.h>
  27
  28 #include "MEM_guardedalloc.h"
  29 #include "BLI_math_color.h"
  30
  31 namespace OCIO_NAMESPACE {};
  32
  33 #include "ocio_capi.h"
  34
  35 #define CONFIG_DEFAULT           ((ConstConfigRcPtr*)1)
  36
  37 #define PROCESSOR_LINEAR_TO_SRGB ((ConstProcessorRcPtr*)1)
  38 #define PROCESSOR_SRGB_TO_LINEAR ((ConstProcessorRcPtr*)2)
  39 #define PROCESSOR_UNKNOWN        ((ConstProcessorRcPtr*)3)
  40
  41 #define COLORSPACE_LINEAR        ((ConstColorSpaceRcPtr*)1)
  42 #define COLORSPACE_SRGB          ((ConstColorSpaceRcPtr*)2)
  43
  44 typedef struct PackedImageDescription {
  45         float *data;
  46         long width;
  47         long height;
  48         long numChannels;
  49         long chanStrideBytes;
  50         long xStrideBytes;
  51         long yStrideBytes;
  52 } PackedImageDescription;
  53
  54 ConstConfigRcPtr *OCIO_getCurrentConfig(void)
  55 {
  56         return CONFIG_DEFAULT;
  57 }
  58
  59 void OCIO_setCurrentConfig(const ConstConfigRcPtr *)
  60 {
  61 }
  62
  63 ConstConfigRcPtr *OCIO_configCreateFromEnv(void)
  64 {
  65         return CONFIG_DEFAULT;
  66 }
  67
  68 ConstConfigRcPtr *OCIO_configCreateFromFile(const char *)
  69 {
  70         return CONFIG_DEFAULT;
  71 }
  72
  73 void OCIO_configRelease(ConstConfigRcPtr *)
  74 {
  75 }
  76
  77 int OCIO_configGetNumColorSpaces(ConstConfigRcPtr *)
  78 {
  79         return 2;
  80 }
  81
  82 const char *OCIO_configGetColorSpaceNameByIndex(ConstConfigRcPtr *, int index)
  83 {
  84         if (index == 0)
  85                 return "Linear";
  86         else if (index == 1)
  87                 return "sRGB";
  88
  89         return NULL;
  90 }
  91
  92 ConstColorSpaceRcPtr *OCIO_configGetColorSpace(ConstConfigRcPtr *, const char *name)
  93 {
  94         if (strcmp(name, "scene_linear") == 0)
  95                 return COLORSPACE_LINEAR;
  96         else if (strcmp(name, "color_picking") == 0)
  97                 return COLORSPACE_SRGB;
  98         else if (strcmp(name, "texture_paint") == 0)
  99                 return COLORSPACE_LINEAR;
 100         else if (strcmp(name, "default_byte") == 0)
 101                 return COLORSPACE_SRGB;
 102         else if (strcmp(name, "default_float") == 0)
 103                 return COLORSPACE_LINEAR;
 104         else if (strcmp(name, "default_sequencer") == 0)
 105                 return COLORSPACE_SRGB;
 106         else if (strcmp(name, "Linear") == 0)
 107                 return COLORSPACE_LINEAR;
 108         else if (strcmp(name, "sRGB") == 0)
 109                 return COLORSPACE_SRGB;
 110
 111         return NULL;
 112 }
 113
 114 int OCIO_configGetIndexForColorSpace(ConstConfigRcPtr *config, const char *name)
 115 {
 116         ConstColorSpaceRcPtr *cs = OCIO_configGetColorSpace(config, name);
 117
 118         if (cs == COLORSPACE_LINEAR)
 119                 return 0;
 120         else if (cs == COLORSPACE_SRGB)
 121                 return 1;
 122
 123         return -1;
 124 }
 125
 126 const char *OCIO_configGetDefaultDisplay(ConstConfigRcPtr *)
 127 {
 128         return "sRGB";
 129 }
 130
 131 int OCIO_configGetNumDisplays(ConstConfigRcPtr* config)
 132 {
 133         return 1;
 134 }
 135
 136 const char *OCIO_configGetDisplay(ConstConfigRcPtr *, int index)
 137 {
 138         if (index == 0)
 139                 return "sRGB";
 140
 141         return NULL;
 142 }
 143
 144 const char *OCIO_configGetDefaultView(ConstConfigRcPtr *, const char *)
 145 {
 146         return "Default";
 147 }
 148
 149 int OCIO_configGetNumViews(ConstConfigRcPtr *, const char *)
 150 {
 151         return 1;
 152 }
 153
 154 const char *OCIO_configGetView(ConstConfigRcPtr *, const char *, int index)
 155 {
 156         if (index == 0)
 157                 return "Default";
 158
 159         return NULL;
 160 }
 161
 162 const char *OCIO_configGetDisplayColorSpaceName(ConstConfigRcPtr *, const char *, const char *)
 163 {
 164         return "sRGB";
 165 }
 166
 167 int OCIO_colorSpaceIsInvertible(ConstColorSpaceRcPtr *cs)
 168 {
 169         return 1;
 170 }
 171
 172 void OCIO_colorSpaceRelease(ConstColorSpaceRcPtr *cs)
 173 {
 174 }
 175
 176 ConstProcessorRcPtr *OCIO_configGetProcessorWithNames(ConstConfigRcPtr *config, const char *srcName, const char *dstName)
 177 {
 178         ConstColorSpaceRcPtr *cs_src = OCIO_configGetColorSpace(config, srcName);
 179         ConstColorSpaceRcPtr *cs_dst = OCIO_configGetColorSpace(config, dstName);
 180
 181         if (cs_src == COLORSPACE_LINEAR && cs_dst == COLORSPACE_SRGB)
 182                 return PROCESSOR_LINEAR_TO_SRGB;
 183         else if (cs_src == COLORSPACE_SRGB && cs_dst == COLORSPACE_LINEAR)
 184                 return PROCESSOR_SRGB_TO_LINEAR;
 185
 186         return 0;
 187 }
 188
 189 ConstProcessorRcPtr *OCIO_configGetProcessor(ConstConfigRcPtr *, ConstTransformRcPtr *tfm)
 190 {
 191         return (ConstProcessorRcPtr*)tfm;
 192 }
 193
 194 void OCIO_processorApply(ConstProcessorRcPtr *processor, PackedImageDesc *img)
 195 {
 196         /* OCIO_TODO stride not respected, channels must be 3 or 4 */
 197         PackedImageDescription *desc = (PackedImageDescription*)img;
 198         int channels = desc->numChannels;
 199         float *pixels = desc->data;
 200         int width = desc->width;
 201         int height = desc->height;
 202         int x, y;
 203
 204         for (y = 0; y < height; y++) {
 205                 for (x = 0; x < width; x++) {
 206                         float *pixel = pixels + channels * (y * width + x);
 207
 208                         if (channels == 4)
 209                                 OCIO_processorApplyRGBA(processor, pixel);
 210                         else if (channels == 3)
 211                                 OCIO_processorApplyRGB(processor, pixel);
 212                 }
 213         }
 214 }
 215
 216 void OCIO_processorApply_predivide(ConstProcessorRcPtr *processor, PackedImageDesc *img)
 217 {
 218         /* OCIO_TODO stride not respected, channels must be 3 or 4 */
 219         PackedImageDescription *desc = (PackedImageDescription*)img;
 220         int channels = desc->numChannels;
 221         float *pixels = desc->data;
 222         int width = desc->width;
 223         int height = desc->height;
 224         int x, y;
 225
 226         for (y = 0; y < height; y++) {
 227                 for (x = 0; x < width; x++) {
 228                         float *pixel = pixels + channels * (y * width + x);
 229
 230                         if (channels == 4)
 231                                 OCIO_processorApplyRGBA_predivide(processor, pixel);
 232                         else if (channels == 3)
 233                                 OCIO_processorApplyRGB(processor, pixel);
 234                 }
 235         }
 236 }
 237
 238 void OCIO_processorApplyRGB(ConstProcessorRcPtr *processor, float *pixel)
 239 {
 240         if (processor == PROCESSOR_LINEAR_TO_SRGB)
 241                 linearrgb_to_srgb_v3_v3(pixel, pixel);
 242         else if (processor == PROCESSOR_SRGB_TO_LINEAR)
 243                 srgb_to_linearrgb_v3_v3(pixel, pixel);
 244 }
 245
 246 void OCIO_processorApplyRGBA(ConstProcessorRcPtr *processor, float *pixel)
 247 {
 248         if (processor == PROCESSOR_LINEAR_TO_SRGB)
 249                 linearrgb_to_srgb_v4(pixel, pixel);
 250         else if (processor == PROCESSOR_SRGB_TO_LINEAR)
 251                 srgb_to_linearrgb_v4(pixel, pixel);
 252 }
 253
 254 void OCIO_processorApplyRGBA_predivide(ConstProcessorRcPtr *processor, float *pixel)
 255 {
 256         if (pixel[3] == 1.0f || pixel[3] == 0.0f) {
 257                 OCIO_processorApplyRGBA(processor, pixel);
 258         }
 259         else {
 260                 float alpha, inv_alpha;
 261
 262                 alpha = pixel[3];
 263                 inv_alpha = 1.0f / alpha;
 264
 265                 pixel[0] *= inv_alpha;
 266                 pixel[1] *= inv_alpha;
 267                 pixel[2] *= inv_alpha;
 268
 269                 OCIO_processorApplyRGBA(processor, pixel);
 270
 271                 pixel[0] *= alpha;
 272                 pixel[1] *= alpha;
 273                 pixel[2] *= alpha;
 274         }
 275 }
 276
 277 void OCIO_processorRelease(ConstProcessorRcPtr *)
 278 {
 279 }
 280
 281 const char *OCIO_colorSpaceGetName(ConstColorSpaceRcPtr *cs)
 282 {
 283         if (cs == COLORSPACE_LINEAR)
 284                 return "Linear";
 285         else if (cs == COLORSPACE_SRGB)
 286                 return "sRGB";
 287
 288         return NULL;
 289 }
 290
 291 const char *OCIO_colorSpaceGetDescription(ConstColorSpaceRcPtr *)
 292 {
 293         return "";
 294 }
 295
 296 const char *OCIO_colorSpaceGetFamily(ConstColorSpaceRcPtr *)
 297 {
 298         return "";
 299 }
 300
 301 DisplayTransformRcPtr *OCIO_createDisplayTransform(void)
 302 {
 303         return (DisplayTransformRcPtr*)PROCESSOR_LINEAR_TO_SRGB;
 304 }
 305
 306 void OCIO_displayTransformSetInputColorSpaceName(DisplayTransformRcPtr *, const char *)
 307 {
 308 }
 309
 310 void OCIO_displayTransformSetDisplay(DisplayTransformRcPtr *, const char *)
 311 {
 312 }
 313
 314 void OCIO_displayTransformSetView(DisplayTransformRcPtr *, const char *)
 315 {
 316 }
 317
 318 void OCIO_displayTransformSetDisplayCC(DisplayTransformRcPtr *, ConstTransformRcPtr *)
 319 {
 320 }
 321
 322 void OCIO_displayTransformSetLinearCC(DisplayTransformRcPtr *, ConstTransformRcPtr *)
 323 {
 324 }
 325
 326 void OCIO_displayTransformRelease(DisplayTransformRcPtr *)
 327 {
 328 }
 329
 330 PackedImageDesc *OCIO_createPackedImageDesc(float *data, long width, long height, long numChannels,
 331                                             long chanStrideBytes, long xStrideBytes, long yStrideBytes)
 332 {
 333         PackedImageDescription *desc = (PackedImageDescription*)MEM_callocN(sizeof(PackedImageDescription), "PackedImageDescription");
 334
 335         desc->data = data;
 336         desc->width = width;
 337         desc->height = height;
 338         desc->numChannels = numChannels;
 339         desc->chanStrideBytes = chanStrideBytes;
 340         desc->xStrideBytes = xStrideBytes;
 341         desc->yStrideBytes = yStrideBytes;
 342
 343         return (PackedImageDesc*)desc;
 344 }
 345
 346 void OCIO_packedImageDescRelease(PackedImageDesc* id)
 347 {
 348         MEM_freeN(id);
 349 }
 350
 351 ExponentTransformRcPtr *OCIO_createExponentTransform(void)
 352 {
 353         return (ExponentTransformRcPtr*)PROCESSOR_UNKNOWN;
 354 }
 355
 356 void OCIO_exponentTransformSetValue(ExponentTransformRcPtr *, const float *)
 357 {
 358 }
 359
 360 void OCIO_exponentTransformRelease(ExponentTransformRcPtr *)
 361 {
 362 }
 363
 364 MatrixTransformRcPtr *OCIO_createMatrixTransform(void)
 365 {
 366         return (MatrixTransformRcPtr*)PROCESSOR_UNKNOWN;
 367 }
 368
 369 void OCIO_matrixTransformSetValue(MatrixTransformRcPtr *, const float *, const float *)
 370 {
 371 }
 372
 373 void OCIO_matrixTransformRelease(MatrixTransformRcPtr *)
 374 {
 375 }
 376
 377 void OCIO_matrixTransformScale(float * , float * , const float *)
 378 {
 379 }
 380