Fix build error on Windows 32 bit.
[blender-staging.git] / intern / opencolorio / ocio_capi.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): Sergey Sharybin
22  *
23  * ***** END GPL LICENSE BLOCK *****
24  */
25
26 #include "MEM_guardedalloc.h"
27
28 #include "ocio_impl.h"
29
30 static IOCIOImpl *impl = NULL;
31
32 void OCIO_init(void)
33 {
34 #ifdef WITH_OCIO
35         impl = new OCIOImpl();
36 #else
37         impl = new FallbackImpl();
38 #endif
39 }
40
41 void OCIO_exit(void)
42 {
43         delete impl;
44         impl = NULL;
45 }
46
47 OCIO_ConstConfigRcPtr *OCIO_getCurrentConfig(void)
48 {
49         return impl->getCurrentConfig();
50 }
51
52 OCIO_ConstConfigRcPtr *OCIO_configCreateFallback(void)
53 {
54         delete impl;
55         impl = new FallbackImpl();
56
57         return impl->getCurrentConfig();
58 }
59
60 void OCIO_setCurrentConfig(const OCIO_ConstConfigRcPtr *config)
61 {
62         impl->setCurrentConfig(config);
63 }
64
65 OCIO_ConstConfigRcPtr *OCIO_configCreateFromEnv(void)
66 {
67         return impl->configCreateFromEnv();
68 }
69
70 OCIO_ConstConfigRcPtr *OCIO_configCreateFromFile(const char *filename)
71 {
72         return impl->configCreateFromFile(filename);
73 }
74
75 void OCIO_configRelease(OCIO_ConstConfigRcPtr *config)
76 {
77         impl->configRelease(config);
78 }
79
80 int OCIO_configGetNumColorSpaces(OCIO_ConstConfigRcPtr *config)
81 {
82         return impl->configGetNumColorSpaces(config);
83 }
84
85 const char *OCIO_configGetColorSpaceNameByIndex(OCIO_ConstConfigRcPtr *config, int index)
86 {
87         return impl->configGetColorSpaceNameByIndex(config, index);
88 }
89
90 OCIO_ConstColorSpaceRcPtr *OCIO_configGetColorSpace(OCIO_ConstConfigRcPtr *config, const char *name)
91 {
92         return impl->configGetColorSpace(config, name);
93 }
94
95 int OCIO_configGetIndexForColorSpace(OCIO_ConstConfigRcPtr *config, const char *name)
96 {
97         return impl->configGetIndexForColorSpace(config, name);
98 }
99
100 const char *OCIO_configGetDefaultDisplay(OCIO_ConstConfigRcPtr *config)
101 {
102         return impl->configGetDefaultDisplay(config);
103 }
104
105 int OCIO_configGetNumDisplays(OCIO_ConstConfigRcPtr* config)
106 {
107         return impl->configGetNumDisplays(config);
108 }
109
110 const char *OCIO_configGetDisplay(OCIO_ConstConfigRcPtr *config, int index)
111 {
112         return impl->configGetDisplay(config, index);
113 }
114
115 const char *OCIO_configGetDefaultView(OCIO_ConstConfigRcPtr *config, const char *display)
116 {
117         return impl->configGetDefaultView(config, display);
118 }
119
120 int OCIO_configGetNumViews(OCIO_ConstConfigRcPtr *config, const char *display)
121 {
122         return impl->configGetNumViews(config, display);
123 }
124
125 const char *OCIO_configGetView(OCIO_ConstConfigRcPtr *config, const char *display, int index)
126 {
127         return impl->configGetView(config, display, index);
128 }
129
130 const char *OCIO_configGetDisplayColorSpaceName(OCIO_ConstConfigRcPtr *config, const char *display, const char *view)
131 {
132         return impl->configGetDisplayColorSpaceName(config, display, view);
133 }
134
135 void OCIO_configGetDefaultLumaCoefs(OCIO_ConstConfigRcPtr *config, float *rgb)
136 {
137         impl->configGetDefaultLumaCoefs(config, rgb);
138 }
139
140 int OCIO_configGetNumLooks(OCIO_ConstConfigRcPtr *config)
141 {
142         return impl->configGetNumLooks(config);
143 }
144
145 const char *OCIO_configGetLookNameByIndex(OCIO_ConstConfigRcPtr *config, int index)
146 {
147         return impl->configGetLookNameByIndex(config, index);
148 }
149
150 OCIO_ConstLookRcPtr *OCIO_configGetLook(OCIO_ConstConfigRcPtr *config, const char *name)
151 {
152         return impl->configGetLook(config, name);
153 }
154
155 const char *OCIO_lookGetProcessSpace(OCIO_ConstLookRcPtr *look)
156 {
157         return impl->lookGetProcessSpace(look);
158 }
159
160 void OCIO_lookRelease(OCIO_ConstLookRcPtr *look)
161 {
162         impl->lookRelease(look);
163 }
164
165 int OCIO_colorSpaceIsInvertible(OCIO_ConstColorSpaceRcPtr *cs)
166 {
167         return impl->colorSpaceIsInvertible(cs);
168 }
169
170 int OCIO_colorSpaceIsData(OCIO_ConstColorSpaceRcPtr *cs)
171 {
172         return impl->colorSpaceIsData(cs);
173 }
174
175 void OCIO_colorSpaceRelease(OCIO_ConstColorSpaceRcPtr *cs)
176 {
177         impl->colorSpaceRelease(cs);
178 }
179
180 OCIO_ConstProcessorRcPtr *OCIO_configGetProcessorWithNames(OCIO_ConstConfigRcPtr *config, const char *srcName, const char *dstName)
181 {
182         return impl->configGetProcessorWithNames(config, srcName, dstName);
183 }
184
185 OCIO_ConstProcessorRcPtr *OCIO_configGetProcessor(OCIO_ConstConfigRcPtr *config, OCIO_ConstTransformRcPtr *transform)
186 {
187         return impl->configGetProcessor(config, transform);
188 }
189
190 void OCIO_processorApply(OCIO_ConstProcessorRcPtr *processor, OCIO_PackedImageDesc *img)
191 {
192         impl->processorApply(processor, img);
193 }
194
195 void OCIO_processorApply_predivide(OCIO_ConstProcessorRcPtr *processor, OCIO_PackedImageDesc *img)
196 {
197         impl->processorApply_predivide(processor, img);
198 }
199
200 void OCIO_processorApplyRGB(OCIO_ConstProcessorRcPtr *processor, float *pixel)
201 {
202         impl->processorApplyRGB(processor, pixel);
203 }
204
205 void OCIO_processorApplyRGBA(OCIO_ConstProcessorRcPtr *processor, float *pixel)
206 {
207         impl->processorApplyRGBA(processor, pixel);
208 }
209
210 void OCIO_processorApplyRGBA_predivide(OCIO_ConstProcessorRcPtr *processor, float *pixel)
211 {
212         impl->processorApplyRGBA_predivide(processor, pixel);
213 }
214
215 void OCIO_processorRelease(OCIO_ConstProcessorRcPtr *p)
216 {
217         impl->processorRelease(p);
218 }
219
220 const char *OCIO_colorSpaceGetName(OCIO_ConstColorSpaceRcPtr *cs)
221 {
222         return impl->colorSpaceGetName(cs);
223 }
224
225 const char *OCIO_colorSpaceGetDescription(OCIO_ConstColorSpaceRcPtr *cs)
226 {
227         return impl->colorSpaceGetDescription(cs);
228 }
229
230 const char *OCIO_colorSpaceGetFamily(OCIO_ConstColorSpaceRcPtr *cs)
231 {
232         return impl->colorSpaceGetFamily(cs);
233 }
234
235 OCIO_DisplayTransformRcPtr *OCIO_createDisplayTransform(void)
236 {
237         return impl->createDisplayTransform();
238 }
239
240 void OCIO_displayTransformSetInputColorSpaceName(OCIO_DisplayTransformRcPtr *dt, const char *name)
241 {
242         impl->displayTransformSetInputColorSpaceName(dt, name);
243 }
244
245 void OCIO_displayTransformSetDisplay(OCIO_DisplayTransformRcPtr *dt, const char *name)
246 {
247         impl->displayTransformSetDisplay(dt, name);
248 }
249
250 void OCIO_displayTransformSetView(OCIO_DisplayTransformRcPtr *dt, const char *name)
251 {
252         impl->displayTransformSetView(dt, name);
253 }
254
255 void OCIO_displayTransformSetDisplayCC(OCIO_DisplayTransformRcPtr *dt, OCIO_ConstTransformRcPtr *t)
256 {
257         impl->displayTransformSetDisplayCC(dt, t);
258 }
259
260 void OCIO_displayTransformSetLinearCC(OCIO_DisplayTransformRcPtr *dt, OCIO_ConstTransformRcPtr *t)
261 {
262         impl->displayTransformSetLinearCC(dt, t);
263 }
264
265 void OCIO_displayTransformSetLooksOverride(OCIO_DisplayTransformRcPtr *dt, const char *looks)
266 {
267         impl->displayTransformSetLooksOverride(dt, looks);
268 }
269
270 void OCIO_displayTransformSetLooksOverrideEnabled(OCIO_DisplayTransformRcPtr *dt, bool enabled)
271 {
272         impl->displayTransformSetLooksOverrideEnabled(dt, enabled);
273 }
274
275 void OCIO_displayTransformRelease(OCIO_DisplayTransformRcPtr *dt)
276 {
277         impl->displayTransformRelease(dt);
278 }
279
280 OCIO_PackedImageDesc *OCIO_createOCIO_PackedImageDesc(float *data, long width, long height, long numChannels,
281                                                       long chanStrideBytes, long xStrideBytes, long yStrideBytes)
282 {
283         return impl->createOCIO_PackedImageDesc(data, width, height, numChannels, chanStrideBytes, xStrideBytes, yStrideBytes);
284 }
285
286 void OCIO_PackedImageDescRelease(OCIO_PackedImageDesc* id)
287 {
288         impl->OCIO_PackedImageDescRelease(id);
289 }
290
291 OCIO_ExponentTransformRcPtr *OCIO_createExponentTransform(void)
292 {
293         return impl->createExponentTransform();
294 }
295
296 void OCIO_exponentTransformSetValue(OCIO_ExponentTransformRcPtr *et, const float *exponent)
297 {
298         impl->exponentTransformSetValue(et, exponent);
299 }
300
301 void OCIO_exponentTransformRelease(OCIO_ExponentTransformRcPtr *et)
302 {
303         impl->exponentTransformRelease(et);
304 }
305
306 OCIO_MatrixTransformRcPtr *OCIO_createMatrixTransform(void)
307 {
308         return impl->createMatrixTransform();
309 }
310
311 void OCIO_matrixTransformSetValue(OCIO_MatrixTransformRcPtr *mt, const float *m44, const float *offset4)
312 {
313         impl->matrixTransformSetValue(mt, m44, offset4);
314 }
315
316 void OCIO_matrixTransformRelease(OCIO_MatrixTransformRcPtr *mt)
317 {
318         impl->matrixTransformRelease(mt);
319 }
320
321 void OCIO_matrixTransformScale(float *m44, float *offset4, const float *scale4f)
322 {
323         impl->matrixTransformScale(m44, offset4, scale4f);
324 }
325
326 int OCIO_supportGLSLDraw(void)
327 {
328         return (int) impl->supportGLSLDraw();
329 }
330
331 int OCIO_setupGLSLDraw(struct OCIO_GLSLDrawState **state_r, OCIO_ConstProcessorRcPtr *processor,
332                        OCIO_CurveMappingSettings *curve_mapping_settings, float dither, bool predivide)
333 {
334         return (int) impl->setupGLSLDraw(state_r, processor, curve_mapping_settings, dither, predivide);
335 }
336
337 void OCIO_finishGLSLDraw(struct OCIO_GLSLDrawState *state)
338 {
339         impl->finishGLSLDraw(state);
340 }
341
342 void OCIO_freeOGLState(struct OCIO_GLSLDrawState *state)
343 {
344         impl->freeGLState(state);
345 }
346
347 const char *OCIO_getVersionString(void)
348 {
349         return impl->getVersionString();
350 }
351
352 int OCIO_getVersionHex(void)
353 {
354         return impl->getVersionHex();
355 }