Color Management: re-implement OCIO-less build configuration
[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 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