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