intern/opencolorio/fallback_impl.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): 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 #include "ocio_impl.h"
  32
  33 #define CONFIG_DEFAULT           ((OCIO_ConstConfigRcPtr*)1)
  34
  35 #define PROCESSOR_LINEAR_TO_SRGB ((OCIO_ConstProcessorRcPtr*)1)
  36 #define PROCESSOR_SRGB_TO_LINEAR ((OCIO_ConstProcessorRcPtr*)2)
  37 #define PROCESSOR_UNKNOWN        ((OCIO_ConstProcessorRcPtr*)3)
  38
  39 #define COLORSPACE_LINEAR        ((OCIO_ConstColorSpaceRcPtr*)1)
  40 #define COLORSPACE_SRGB          ((OCIO_ConstColorSpaceRcPtr*)2)
  41
  42 typedef struct OCIO_PackedImageDescription {
  43         float *data;
  44         long width;
  45         long height;
  46         long numChannels;
  47         long chanStrideBytes;
  48         long xStrideBytes;
  49         long yStrideBytes;
  50 } OCIO_PackedImageDescription;
  51
  52 OCIO_ConstConfigRcPtr *FallbackImpl::getCurrentConfig(void)
  53 {
  54         return CONFIG_DEFAULT;
  55 }
  56
  57 void FallbackImpl::setCurrentConfig(const OCIO_ConstConfigRcPtr *)
  58 {
  59 }
  60
  61 OCIO_ConstConfigRcPtr *FallbackImpl::configCreateFromEnv(void)
  62 {
  63         return CONFIG_DEFAULT;
  64 }
  65
  66 OCIO_ConstConfigRcPtr *FallbackImpl::configCreateFromFile(const char *)
  67 {
  68         return CONFIG_DEFAULT;
  69 }
  70
  71 void FallbackImpl::configRelease(OCIO_ConstConfigRcPtr *)
  72 {
  73 }
  74
  75 int FallbackImpl::configGetNumColorSpaces(OCIO_ConstConfigRcPtr *)
  76 {
  77         return 2;
  78 }
  79
  80 const char *FallbackImpl::configGetColorSpaceNameByIndex(OCIO_ConstConfigRcPtr *, int index)
  81 {
  82         if (index == 0)
  83                 return "Linear";
  84         else if (index == 1)
  85                 return "sRGB";
  86
  87         return NULL;
  88 }
  89
  90 OCIO_ConstColorSpaceRcPtr *FallbackImpl::configGetColorSpace(OCIO_ConstConfigRcPtr *, const char *name)
  91 {
  92         if (strcmp(name, "scene_linear") == 0)
  93                 return COLORSPACE_LINEAR;
  94         else if (strcmp(name, "color_picking") == 0)
  95                 return COLORSPACE_SRGB;
  96         else if (strcmp(name, "texture_paint") == 0)
  97                 return COLORSPACE_LINEAR;
  98         else if (strcmp(name, "default_byte") == 0)
  99                 return COLORSPACE_SRGB;
 100         else if (strcmp(name, "default_float") == 0)
 101                 return COLORSPACE_LINEAR;
 102         else if (strcmp(name, "default_sequencer") == 0)
 103                 return COLORSPACE_SRGB;
 104         else if (strcmp(name, "Linear") == 0)
 105                 return COLORSPACE_LINEAR;
 106         else if (strcmp(name, "sRGB") == 0)
 107                 return COLORSPACE_SRGB;
 108
 109         return NULL;
 110 }
 111
 112 int FallbackImpl::configGetIndexForColorSpace(OCIO_ConstConfigRcPtr *config, const char *name)
 113 {
 114         OCIO_ConstColorSpaceRcPtr *cs = configGetColorSpace(config, name);
 115
 116         if (cs == COLORSPACE_LINEAR)
 117                 return 0;
 118         else if (cs == COLORSPACE_SRGB)
 119                 return 1;
 120
 121         return -1;
 122 }
 123
 124 const char *FallbackImpl::configGetDefaultDisplay(OCIO_ConstConfigRcPtr *)
 125 {
 126         return "sRGB";
 127 }
 128
 129 int FallbackImpl::configGetNumDisplays(OCIO_ConstConfigRcPtr* config)
 130 {
 131         return 1;
 132 }
 133
 134 const char *FallbackImpl::configGetDisplay(OCIO_ConstConfigRcPtr *, int index)
 135 {
 136         if (index == 0)
 137                 return "sRGB";
 138
 139         return NULL;
 140 }
 141
 142 const char *FallbackImpl::configGetDefaultView(OCIO_ConstConfigRcPtr *, const char *)
 143 {
 144         return "Default";
 145 }
 146
 147 int FallbackImpl::configGetNumViews(OCIO_ConstConfigRcPtr *, const char *)
 148 {
 149         return 1;
 150 }
 151
 152 const char *FallbackImpl::configGetView(OCIO_ConstConfigRcPtr *, const char *, int index)
 153 {
 154         if (index == 0)
 155                 return "Default";
 156
 157         return NULL;
 158 }
 159
 160 const char *FallbackImpl::configGetDisplayColorSpaceName(OCIO_ConstConfigRcPtr *, const char *, const char *)
 161 {
 162         return "sRGB";
 163 }
 164
 165 int FallbackImpl::colorSpaceIsInvertible(OCIO_ConstColorSpaceRcPtr *cs)
 166 {
 167         return 1;
 168 }
 169
 170 int FallbackImpl::colorSpaceIsData(OCIO_ConstColorSpaceRcPtr *cs)
 171 {
 172         return 0;
 173 }
 174
 175 void FallbackImpl::colorSpaceRelease(OCIO_ConstColorSpaceRcPtr *cs)
 176 {
 177 }
 178
 179 OCIO_ConstProcessorRcPtr *FallbackImpl::configGetProcessorWithNames(OCIO_ConstConfigRcPtr *config, const char *srcName, const char *dstName)
 180 {
 181         OCIO_ConstColorSpaceRcPtr *cs_src = configGetColorSpace(config, srcName);
 182         OCIO_ConstColorSpaceRcPtr *cs_dst = configGetColorSpace(config, dstName);
 183
 184         if (cs_src == COLORSPACE_LINEAR && cs_dst == COLORSPACE_SRGB)
 185                 return PROCESSOR_LINEAR_TO_SRGB;
 186         else if (cs_src == COLORSPACE_SRGB && cs_dst == COLORSPACE_LINEAR)
 187                 return PROCESSOR_SRGB_TO_LINEAR;
 188
 189         return 0;
 190 }
 191
 192 OCIO_ConstProcessorRcPtr *FallbackImpl::configGetProcessor(OCIO_ConstConfigRcPtr *, OCIO_ConstTransformRcPtr *tfm)
 193 {
 194         return (OCIO_ConstProcessorRcPtr*)tfm;
 195 }
 196
 197 void FallbackImpl::processorApply(OCIO_ConstProcessorRcPtr *processor, OCIO_PackedImageDesc *img)
 198 {
 199         /* OCIO_TODO stride not respected, channels must be 3 or 4 */
 200         OCIO_PackedImageDescription *desc = (OCIO_PackedImageDescription*)img;
 201         int channels = desc->numChannels;
 202         float *pixels = desc->data;
 203         int width = desc->width;
 204         int height = desc->height;
 205         int x, y;
 206
 207         for (y = 0; y < height; y++) {
 208                 for (x = 0; x < width; x++) {
 209                         float *pixel = pixels + channels * (y * width + x);
 210
 211                         if (channels == 4)
 212                                 processorApplyRGBA(processor, pixel);
 213                         else if (channels == 3)
 214                                 processorApplyRGB(processor, pixel);
 215                 }
 216         }
 217 }
 218
 219 void FallbackImpl::processorApply_predivide(OCIO_ConstProcessorRcPtr *processor, OCIO_PackedImageDesc *img)
 220 {
 221         /* OCIO_TODO stride not respected, channels must be 3 or 4 */
 222         OCIO_PackedImageDescription *desc = (OCIO_PackedImageDescription*)img;
 223         int channels = desc->numChannels;
 224         float *pixels = desc->data;
 225         int width = desc->width;
 226         int height = desc->height;
 227         int x, y;
 228
 229         for (y = 0; y < height; y++) {
 230                 for (x = 0; x < width; x++) {
 231                         float *pixel = pixels + channels * (y * width + x);
 232
 233                         if (channels == 4)
 234                                 processorApplyRGBA_predivide(processor, pixel);
 235                         else if (channels == 3)
 236                                 processorApplyRGB(processor, pixel);
 237                 }
 238         }
 239 }
 240
 241 void FallbackImpl::processorApplyRGB(OCIO_ConstProcessorRcPtr *processor, float *pixel)
 242 {
 243         if (processor == PROCESSOR_LINEAR_TO_SRGB)
 244                 linearrgb_to_srgb_v3_v3(pixel, pixel);
 245         else if (processor == PROCESSOR_SRGB_TO_LINEAR)
 246                 srgb_to_linearrgb_v3_v3(pixel, pixel);
 247 }
 248
 249 void FallbackImpl::processorApplyRGBA(OCIO_ConstProcessorRcPtr *processor, float *pixel)
 250 {
 251         if (processor == PROCESSOR_LINEAR_TO_SRGB)
 252                 linearrgb_to_srgb_v4(pixel, pixel);
 253         else if (processor == PROCESSOR_SRGB_TO_LINEAR)
 254                 srgb_to_linearrgb_v4(pixel, pixel);
 255 }
 256
 257 void FallbackImpl::processorApplyRGBA_predivide(OCIO_ConstProcessorRcPtr *processor, float *pixel)
 258 {
 259         if (pixel[3] == 1.0f || pixel[3] == 0.0f) {
 260                 processorApplyRGBA(processor, pixel);
 261         }
 262         else {
 263                 float alpha, inv_alpha;
 264
 265                 alpha = pixel[3];
 266                 inv_alpha = 1.0f / alpha;
 267
 268                 pixel[0] *= inv_alpha;
 269                 pixel[1] *= inv_alpha;
 270                 pixel[2] *= inv_alpha;
 271
 272                 processorApplyRGBA(processor, pixel);
 273
 274                 pixel[0] *= alpha;
 275                 pixel[1] *= alpha;
 276                 pixel[2] *= alpha;
 277         }
 278 }
 279
 280 void FallbackImpl::processorRelease(OCIO_ConstProcessorRcPtr *)
 281 {
 282 }
 283
 284 const char *FallbackImpl::colorSpaceGetName(OCIO_ConstColorSpaceRcPtr *cs)
 285 {
 286         if (cs == COLORSPACE_LINEAR)
 287                 return "Linear";
 288         else if (cs == COLORSPACE_SRGB)
 289                 return "sRGB";
 290
 291         return NULL;
 292 }
 293
 294 const char *FallbackImpl::colorSpaceGetDescription(OCIO_ConstColorSpaceRcPtr *)
 295 {
 296         return "";
 297 }
 298
 299 const char *FallbackImpl::colorSpaceGetFamily(OCIO_ConstColorSpaceRcPtr *)
 300 {
 301         return "";
 302 }
 303
 304 OCIO_DisplayTransformRcPtr *FallbackImpl::createDisplayTransform(void)
 305 {
 306         return (OCIO_DisplayTransformRcPtr*)PROCESSOR_LINEAR_TO_SRGB;
 307 }
 308
 309 void FallbackImpl::displayTransformSetInputColorSpaceName(OCIO_DisplayTransformRcPtr *, const char *)
 310 {
 311 }
 312
 313 void FallbackImpl::displayTransformSetDisplay(OCIO_DisplayTransformRcPtr *, const char *)
 314 {
 315 }
 316
 317 void FallbackImpl::displayTransformSetView(OCIO_DisplayTransformRcPtr *, const char *)
 318 {
 319 }
 320
 321 void FallbackImpl::displayTransformSetDisplayCC(OCIO_DisplayTransformRcPtr *, OCIO_ConstTransformRcPtr *)
 322 {
 323 }
 324
 325 void FallbackImpl::displayTransformSetLinearCC(OCIO_DisplayTransformRcPtr *, OCIO_ConstTransformRcPtr *)
 326 {
 327 }
 328
 329 void FallbackImpl::displayTransformRelease(OCIO_DisplayTransformRcPtr *)
 330 {
 331 }
 332
 333 OCIO_PackedImageDesc *FallbackImpl::createOCIO_PackedImageDesc(float *data, long width, long height, long numChannels,
 334                                                                long chanStrideBytes, long xStrideBytes, long yStrideBytes)
 335 {
 336         OCIO_PackedImageDescription *desc = (OCIO_PackedImageDescription*)MEM_callocN(sizeof(OCIO_PackedImageDescription), "OCIO_PackedImageDescription");
 337
 338         desc->data = data;
 339         desc->width = width;
 340         desc->height = height;
 341         desc->numChannels = numChannels;
 342         desc->chanStrideBytes = chanStrideBytes;
 343         desc->xStrideBytes = xStrideBytes;
 344         desc->yStrideBytes = yStrideBytes;
 345
 346         return (OCIO_PackedImageDesc*)desc;
 347 }
 348
 349 void FallbackImpl::OCIO_PackedImageDescRelease(OCIO_PackedImageDesc* id)
 350 {
 351         MEM_freeN(id);
 352 }
 353
 354 OCIO_ExponentTransformRcPtr *FallbackImpl::createExponentTransform(void)
 355 {
 356         return (OCIO_ExponentTransformRcPtr*)PROCESSOR_UNKNOWN;
 357 }
 358
 359 void FallbackImpl::exponentTransformSetValue(OCIO_ExponentTransformRcPtr *, const float *)
 360 {
 361 }
 362
 363 void FallbackImpl::exponentTransformRelease(OCIO_ExponentTransformRcPtr *)
 364 {
 365 }
 366
 367 OCIO_MatrixTransformRcPtr *FallbackImpl::createMatrixTransform(void)
 368 {
 369         return (OCIO_MatrixTransformRcPtr*)PROCESSOR_UNKNOWN;
 370 }
 371
 372 void FallbackImpl::matrixTransformSetValue(OCIO_MatrixTransformRcPtr *, const float *, const float *)
 373 {
 374 }
 375
 376 void FallbackImpl::matrixTransformRelease(OCIO_MatrixTransformRcPtr *)
 377 {
 378 }
 379
 380 void FallbackImpl::matrixTransformScale(float * , float * , const float *)
 381 {
 382 }