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