Fixed compilation error on widows
[blender.git] / 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 }