Color management: abort execution when error happens in debug mode
[blender.git] / intern / opencolorio / ocio_capi.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): Xavier Thomas
22  *                 Lukas Toene
23  *
24  * ***** END GPL LICENSE BLOCK *****
25  */
26
27 #include <iostream>
28
29 #include <OpenColorIO/OpenColorIO.h>
30
31
32 #define OCIO_CAPI_IMPLEMENTATION
33 #include "ocio_capi.h"
34
35 #ifdef NDEBUG
36 #  define OCIO_abort()
37 #else
38 #  include <stdlib.h>
39 #  define OCIO_abort() abort()
40 #endif
41
42 static void OCIO_reportError(const char *err)
43 {
44         std::cerr << "OpenColorIO Error: " << err << std::endl;
45
46         OCIO_abort();
47 }
48
49 static void OCIO_reportException(Exception &exception)
50 {
51         OCIO_reportError(exception.what());
52 }
53
54 ConstConfigRcPtr *OCIO_getCurrentConfig(void)
55 {
56         ConstConfigRcPtr *config =  new ConstConfigRcPtr();
57         try {
58                 *config = GetCurrentConfig();
59
60                 if(*config)
61                         return config;
62         }
63         catch (Exception &exception) {
64                 OCIO_reportException(exception);
65         }
66
67         return NULL;
68 }
69
70 void OCIO_setCurrentConfig(const ConstConfigRcPtr *config)
71 {
72         try {
73                 SetCurrentConfig(*config);
74         }
75         catch (Exception &exception) {
76                 OCIO_reportException(exception);
77         }
78 }
79
80 ConstConfigRcPtr *OCIO_configCreateFromEnv(void)
81 {
82         ConstConfigRcPtr *config =  new ConstConfigRcPtr();
83
84         try {
85                 *config = Config::CreateFromEnv();
86
87                 if (*config)
88                         return config;
89         }
90         catch (Exception &exception) {
91                 OCIO_reportException(exception);
92         }
93
94         return NULL;
95 }
96
97
98 ConstConfigRcPtr *OCIO_configCreateFromFile(const char *filename)
99 {
100         ConstConfigRcPtr *config =  new ConstConfigRcPtr();
101
102         try {
103                 *config = Config::CreateFromFile(filename);
104
105                 if (*config)
106                         return config;
107         }
108         catch (Exception &exception) {
109                 OCIO_reportException(exception);
110         }
111
112         return NULL;
113 }
114
115 void OCIO_configRelease(ConstConfigRcPtr *config)
116 {
117         delete config;
118 }
119
120 int OCIO_configGetNumColorSpaces(ConstConfigRcPtr *config)
121 {
122         try {
123                 return (*config)->getNumColorSpaces();
124         }
125         catch (Exception &exception) {
126                 OCIO_reportException(exception);
127         }
128
129         return 0;
130 }
131
132 const char *OCIO_configGetColorSpaceNameByIndex(ConstConfigRcPtr *config, int index)
133 {
134         try {
135                 return (*config)->getColorSpaceNameByIndex(index);
136         }
137         catch (Exception &exception) {
138                 OCIO_reportException(exception);
139         }
140
141         return NULL;
142 }
143
144 ConstColorSpaceRcPtr *OCIO_configGetColorSpace(ConstConfigRcPtr *config, const char *name)
145 {
146         ConstColorSpaceRcPtr *cs =  new ConstColorSpaceRcPtr();
147
148         try {
149                 *cs = (*config)->getColorSpace(name);
150
151                 if (*cs)
152                         return cs;
153         }
154         catch (Exception &exception) {
155                 OCIO_reportException(exception);
156                 delete cs;
157         }
158
159         return NULL;
160 }
161
162 int OCIO_configGetIndexForColorSpace(ConstConfigRcPtr *config, const char *name)
163 {
164         try {
165                 return (*config)->getIndexForColorSpace(name);
166         }
167         catch (Exception &exception) {
168                 OCIO_reportException(exception);
169         }
170
171         return -1;
172 }
173
174 const char *OCIO_configGetDefaultDisplay(ConstConfigRcPtr *config)
175 {
176         try {
177                 return (*config)->getDefaultDisplay();
178         }
179         catch (Exception &exception) {
180                 OCIO_reportException(exception);
181         }
182
183         return NULL;
184 }
185
186 int OCIO_configGetNumDisplays(ConstConfigRcPtr* config)
187 {
188         try {
189                 return (*config)->getNumDisplays();
190         }
191         catch (Exception &exception) {
192                 OCIO_reportException(exception);
193         }
194
195         return 0;
196 }
197
198 const char *OCIO_configGetDisplay(ConstConfigRcPtr *config, int index)
199 {
200         try {
201                 return (*config)->getDisplay(index);
202         }
203         catch (Exception &exception) {
204                 OCIO_reportException(exception);
205         }
206
207         return NULL;
208 }
209
210 const char *OCIO_configGetDefaultView(ConstConfigRcPtr *config, const char *display)
211 {
212         try {
213                 return (*config)->getDefaultView(display);
214         }
215         catch (Exception &exception) {
216                 OCIO_reportException(exception);
217         }
218
219         return NULL;
220 }
221
222 int OCIO_configGetNumViews(ConstConfigRcPtr *config, const char *display)
223 {
224         try {
225                 return (*config)->getNumViews(display);
226         }
227         catch (Exception &exception) {
228                 OCIO_reportException(exception);
229         }
230
231         return 0;
232 }
233
234 const char *OCIO_configGetView(ConstConfigRcPtr *config, const char *display, int index)
235 {
236         try {
237                 return (*config)->getView(display, index);
238         }
239         catch (Exception &exception) {
240                 OCIO_reportException(exception);
241         }
242
243         return NULL;
244 }
245
246 const char *OCIO_configGetDisplayColorSpaceName(ConstConfigRcPtr *config, const char *display, const char *view)
247 {
248         try {
249                 return (*config)->getDisplayColorSpaceName(display, view);
250         }
251         catch (Exception &exception) {
252                 OCIO_reportException(exception);
253         }
254
255         return NULL;
256 }
257
258 void OCIO_colorSpaceRelease(ConstColorSpaceRcPtr *cs)
259 {
260         delete cs;
261 }
262
263 ConstProcessorRcPtr *OCIO_configGetProcessorWithNames(ConstConfigRcPtr *config, const char *srcName, const char *dstName)
264 {
265         ConstProcessorRcPtr *p =  new ConstProcessorRcPtr();
266
267         try {
268                 *p = (*config)->getProcessor(srcName, dstName);
269
270                 if (*p)
271                         return p;
272         }
273         catch (Exception &exception) {
274                 OCIO_reportException(exception);
275         }
276
277         return 0;
278 }
279
280 ConstProcessorRcPtr *OCIO_configGetProcessor(ConstConfigRcPtr *config, ConstTransformRcPtr *transform)
281 {
282         ConstProcessorRcPtr *p =  new ConstProcessorRcPtr();
283
284         try {
285                 *p = (*config)->getProcessor(*transform);
286
287                 if (*p)
288                         return p;
289         }
290         catch (Exception &exception) {
291                 OCIO_reportException(exception);
292         }
293
294         return NULL;
295 }
296
297 void OCIO_processorApply(ConstProcessorRcPtr *processor, PackedImageDesc *img)
298 {
299         try {
300                 (*processor)->apply(*img);
301         }
302         catch (Exception &exception) {
303                 OCIO_reportException(exception);
304         }
305 }
306
307 void OCIO_processorApplyRGB(ConstProcessorRcPtr *processor, float *pixel)
308 {
309         (*processor)->applyRGB(pixel);
310 }
311
312 void OCIO_processorApplyRGBA(ConstProcessorRcPtr *processor, float *pixel)
313 {
314         (*processor)->applyRGBA(pixel);
315 }
316
317 void OCIO_processorRelease(ConstProcessorRcPtr *p)
318 {
319         delete p;
320 }
321
322 const char *OCIO_colorSpaceGetName(ConstColorSpaceRcPtr *cs)
323 {
324         return (*cs)->getName();
325 }
326
327 const char *OCIO_colorSpaceGetDescription(ConstColorSpaceRcPtr *cs)
328 {
329         return (*cs)->getDescription();
330 }
331
332 const char *OCIO_colorSpaceGetFamily(ConstColorSpaceRcPtr *cs)
333 {
334         return (*cs)->getFamily();
335 }
336
337 DisplayTransformRcPtr *OCIO_createDisplayTransform(void)
338 {
339         DisplayTransformRcPtr *dt =  new DisplayTransformRcPtr();
340
341         *dt = DisplayTransform::Create();
342
343         return dt;
344 }
345
346 void OCIO_displayTransformSetInputColorSpaceName(DisplayTransformRcPtr *dt, const char *name)
347 {
348         (*dt)->setInputColorSpaceName(name);
349 }
350
351 void OCIO_displayTransformSetDisplay(DisplayTransformRcPtr *dt, const char *name)
352 {
353         (*dt)->setDisplay(name);
354 }
355
356 void OCIO_displayTransformSetView(DisplayTransformRcPtr *dt, const char *name)
357 {
358         (*dt)->setView(name);
359 }
360
361 void OCIO_displayTransformSetDisplayCC(DisplayTransformRcPtr *dt, ConstTransformRcPtr *t)
362 {
363         (*dt)->setDisplayCC(*t);
364 }
365
366 void OCIO_displayTransformSetLinearCC(DisplayTransformRcPtr *dt, ConstTransformRcPtr *t)
367 {
368         (*dt)->setLinearCC(*t);
369 }
370
371 void OCIO_displayTransformRelease(DisplayTransformRcPtr *dt)
372 {
373         delete dt;
374         dt = NULL;
375 }
376
377 PackedImageDesc *OCIO_createPackedImageDesc(float *data, long width, long height, long numChannels,
378                                                                                         long chanStrideBytes, long xStrideBytes, long yStrideBytes)
379 {
380         try {
381                 PackedImageDesc *id = new PackedImageDesc(data, width, height, numChannels, chanStrideBytes, xStrideBytes, yStrideBytes);
382
383                 return id;
384         }
385         catch (Exception &exception) {
386                 OCIO_reportException(exception);
387         }
388
389         return NULL;
390 }
391
392 void OCIO_packedImageDescRelease(PackedImageDesc* id)
393 {
394         delete id;
395         id = NULL;
396 }
397
398 ExponentTransformRcPtr *OCIO_createExponentTransform(void)
399 {
400         ExponentTransformRcPtr *et =  new ExponentTransformRcPtr();
401
402         *et = ExponentTransform::Create();
403
404         return et;
405 }
406
407 void OCIO_exponentTransformSetValue(ExponentTransformRcPtr *et, const float *exponent)
408 {
409         (*et)->setValue(exponent);
410 }
411
412 void OCIO_exponentTransformRelease(ExponentTransformRcPtr *et)
413 {
414         delete et;
415 }
416
417 MatrixTransformRcPtr *OCIO_createMatrixTransform(void)
418 {
419         MatrixTransformRcPtr *mt = new MatrixTransformRcPtr();
420
421         *mt = MatrixTransform::Create();
422
423         return mt;
424 }
425
426 void OCIO_matrixTransformSetValue(MatrixTransformRcPtr *mt, const float *m44, const float *offset4)
427 {
428         (*mt)->setValue(m44, offset4);
429 }
430
431 void OCIO_matrixTransformRelease(MatrixTransformRcPtr *mt)
432 {
433         delete mt;
434 }
435
436 void OCIO_matrixTransformScale(float * m44, float * offset4, const float *scale4f)
437 {
438         MatrixTransform::Scale(m44, offset4, scale4f);
439 }