1 ///////////////////////////////////////////////////////////////////////////
2 //
3 // Copyright (c) 2004, Industrial Light & Magic, a division of Lucas
4 // Digital Ltd. LLC
5 //
6 // All rights reserved.
7 //
8 // Redistribution and use in source and binary forms, with or without
9 // modification, are permitted provided that the following conditions are
10 // met:
11 // * Redistributions of source code must retain the above copyright
12 // notice, this list of conditions and the following disclaimer.
13 // * Redistributions in binary form must reproduce the above
14 // copyright notice, this list of conditions and the following disclaimer
15 // in the documentation and/or other materials provided with the
16 // distribution.
17 // * Neither the name of Industrial Light & Magic nor the names of
18 // its contributors may be used to endorse or promote products derived
19 // from this software without specific prior written permission.
20 //
21 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 //
33 ///////////////////////////////////////////////////////////////////////////
34
35
36 //-----------------------------------------------------------------------------
37 //
38 // C interface to C++ classes Imf::RgbaOutputFile and Imf::RgbaInputFile
39 //
40 //-----------------------------------------------------------------------------
41
42
43 #include <ImfCRgbaFile.h>
44 #include <ImfRgbaFile.h>
45 #include <ImfTiledRgbaFile.h>
46 #include <ImfIntAttribute.h>
47 #include <ImfFloatAttribute.h>
48 #include <ImfDoubleAttribute.h>
49 #include <ImfStringAttribute.h>
50 #include <ImfBoxAttribute.h>
51 #include <ImfVecAttribute.h>
52 #include <ImfMatrixAttribute.h>
53 #include <ImfChannelList.h>
54 #include <ImfLut.h>
55 #include "half.h"
56 #include "ImfNamespace.h"
57 #include "ImathForward.h"
58
59 #include <string.h>
60
61
62 using IMATH_NAMESPACE::Box2i;
63 using IMATH_NAMESPACE::Box2f;
64 using IMATH_NAMESPACE::V2i;
65 using IMATH_NAMESPACE::V2f;
66 using IMATH_NAMESPACE::V3i;
67 using IMATH_NAMESPACE::V3f;
68 using IMATH_NAMESPACE::M33f;
69 using IMATH_NAMESPACE::M44f;
70
71
72 namespace {
73
74
75 const int MAX_ERR_LENGTH = 1024;
76 char errorMessage[MAX_ERR_LENGTH];
77
78
79 void
setErrorMessage(const std::exception & e)80 setErrorMessage (const std::exception &e)
81 {
82 strncpy (errorMessage, e.what(), MAX_ERR_LENGTH - 1);
83 errorMessage[MAX_ERR_LENGTH - 1] = 0;
84 }
85
86
87 inline OPENEXR_IMF_INTERNAL_NAMESPACE::Header *
header(ImfHeader * hdr)88 header (ImfHeader *hdr)
89 {
90 return (OPENEXR_IMF_INTERNAL_NAMESPACE::Header *)(hdr);
91 }
92
93
94 inline const OPENEXR_IMF_INTERNAL_NAMESPACE::Header *
header(const ImfHeader * hdr)95 header (const ImfHeader *hdr)
96 {
97 return (const OPENEXR_IMF_INTERNAL_NAMESPACE::Header *)(hdr);
98 }
99
100
101 inline OPENEXR_IMF_INTERNAL_NAMESPACE::RgbaOutputFile *
outfile(ImfOutputFile * out)102 outfile (ImfOutputFile *out)
103 {
104 return (OPENEXR_IMF_INTERNAL_NAMESPACE::RgbaOutputFile *) out;
105 }
106
107
108 inline const OPENEXR_IMF_INTERNAL_NAMESPACE::RgbaOutputFile *
outfile(const ImfOutputFile * out)109 outfile (const ImfOutputFile *out)
110 {
111 return (const OPENEXR_IMF_INTERNAL_NAMESPACE::RgbaOutputFile *) out;
112 }
113
114
115 inline OPENEXR_IMF_INTERNAL_NAMESPACE::TiledRgbaOutputFile *
outfile(ImfTiledOutputFile * out)116 outfile (ImfTiledOutputFile *out)
117 {
118 return (OPENEXR_IMF_INTERNAL_NAMESPACE::TiledRgbaOutputFile *) out;
119 }
120
121
122 inline const OPENEXR_IMF_INTERNAL_NAMESPACE::TiledRgbaOutputFile *
outfile(const ImfTiledOutputFile * out)123 outfile (const ImfTiledOutputFile *out)
124 {
125 return (const OPENEXR_IMF_INTERNAL_NAMESPACE::TiledRgbaOutputFile *) out;
126 }
127
128
129 inline OPENEXR_IMF_INTERNAL_NAMESPACE::RgbaInputFile *
infile(ImfInputFile * in)130 infile (ImfInputFile *in)
131 {
132 return (OPENEXR_IMF_INTERNAL_NAMESPACE::RgbaInputFile *) in;
133 }
134
135
136 inline const OPENEXR_IMF_INTERNAL_NAMESPACE::RgbaInputFile *
infile(const ImfInputFile * in)137 infile (const ImfInputFile *in)
138 {
139 return (const OPENEXR_IMF_INTERNAL_NAMESPACE::RgbaInputFile *) in;
140 }
141
142
143 inline OPENEXR_IMF_INTERNAL_NAMESPACE::TiledRgbaInputFile *
infile(ImfTiledInputFile * in)144 infile (ImfTiledInputFile *in)
145 {
146 return (OPENEXR_IMF_INTERNAL_NAMESPACE::TiledRgbaInputFile *) in;
147 }
148
149
150 inline const OPENEXR_IMF_INTERNAL_NAMESPACE::TiledRgbaInputFile *
infile(const ImfTiledInputFile * in)151 infile (const ImfTiledInputFile *in)
152 {
153 return (const OPENEXR_IMF_INTERNAL_NAMESPACE::TiledRgbaInputFile *) in;
154 }
155
156
157 } // namespace
158
159
160 void
ImfFloatToHalf(float f,ImfHalf * h)161 ImfFloatToHalf (float f, ImfHalf *h)
162 {
163 *h = half(f).bits();
164 }
165
166
167 void
ImfFloatToHalfArray(int n,const float f[],ImfHalf h[])168 ImfFloatToHalfArray (int n, const float f[/*n*/], ImfHalf h[/*n*/])
169 {
170 for (int i = 0; i < n; ++i)
171 h[i] = half(f[i]).bits();
172 }
173
174
175 float
ImfHalfToFloat(ImfHalf h)176 ImfHalfToFloat (ImfHalf h)
177 {
178 return float (*((half *)&h));
179 }
180
181
182 void
ImfHalfToFloatArray(int n,const ImfHalf h[],float f[])183 ImfHalfToFloatArray (int n, const ImfHalf h[/*n*/], float f[/*n*/])
184 {
185 for (int i = 0; i < n; ++i)
186 f[i] = float (*((half *)(h + i)));
187 }
188
189
190 ImfHeader *
ImfNewHeader(void)191 ImfNewHeader (void)
192 {
193 try
194 {
195 return (ImfHeader *) new OPENEXR_IMF_INTERNAL_NAMESPACE::Header;
196 }
197 catch (const std::exception &e)
198 {
199 setErrorMessage (e);
200 return 0;
201 }
202 }
203
204
205 void
ImfDeleteHeader(ImfHeader * hdr)206 ImfDeleteHeader (ImfHeader *hdr)
207 {
208 delete header (hdr);
209 }
210
211
212 ImfHeader *
ImfCopyHeader(const ImfHeader * hdr)213 ImfCopyHeader (const ImfHeader *hdr)
214 {
215 try
216 {
217 return (ImfHeader *) new OPENEXR_IMF_INTERNAL_NAMESPACE::Header (*header (hdr));
218 }
219 catch (const std::exception &e)
220 {
221 setErrorMessage (e);
222 return 0;
223 }
224 }
225
226
227 void
ImfHeaderSetDisplayWindow(ImfHeader * hdr,int xMin,int yMin,int xMax,int yMax)228 ImfHeaderSetDisplayWindow (ImfHeader *hdr,
229 int xMin, int yMin,
230 int xMax, int yMax)
231 {
232 header(hdr)->displayWindow() = Box2i (V2i (xMin, yMin), V2i (xMax, yMax));
233 }
234
235
236 void
ImfHeaderDisplayWindow(const ImfHeader * hdr,int * xMin,int * yMin,int * xMax,int * yMax)237 ImfHeaderDisplayWindow (const ImfHeader *hdr,
238 int *xMin, int *yMin,
239 int *xMax, int *yMax)
240 {
241 const Box2i dw = header(hdr)->displayWindow();
242 *xMin = dw.min.x;
243 *yMin = dw.min.y;
244 *xMax = dw.max.x;
245 *yMax = dw.max.y;
246 }
247
248
249 void
ImfHeaderSetDataWindow(ImfHeader * hdr,int xMin,int yMin,int xMax,int yMax)250 ImfHeaderSetDataWindow (ImfHeader *hdr,
251 int xMin, int yMin,
252 int xMax, int yMax)
253 {
254 header(hdr)->dataWindow() = Box2i (V2i (xMin, yMin), V2i (xMax, yMax));
255 }
256
257
258 void
ImfHeaderDataWindow(const ImfHeader * hdr,int * xMin,int * yMin,int * xMax,int * yMax)259 ImfHeaderDataWindow (const ImfHeader *hdr,
260 int *xMin, int *yMin,
261 int *xMax, int *yMax)
262 {
263 const Box2i dw = header(hdr)->dataWindow();
264 *xMin = dw.min.x;
265 *yMin = dw.min.y;
266 *xMax = dw.max.x;
267 *yMax = dw.max.y;
268 }
269
270
271 void
ImfHeaderSetPixelAspectRatio(ImfHeader * hdr,float pixelAspectRatio)272 ImfHeaderSetPixelAspectRatio (ImfHeader *hdr, float pixelAspectRatio)
273 {
274 header(hdr)->pixelAspectRatio() = pixelAspectRatio;
275 }
276
277
278 float
ImfHeaderPixelAspectRatio(const ImfHeader * hdr)279 ImfHeaderPixelAspectRatio (const ImfHeader *hdr)
280 {
281 return header(hdr)->pixelAspectRatio();
282 }
283
284
285 void
ImfHeaderSetScreenWindowCenter(ImfHeader * hdr,float x,float y)286 ImfHeaderSetScreenWindowCenter (ImfHeader *hdr, float x, float y)
287 {
288 header(hdr)->screenWindowCenter() = V2f (x, y);
289 }
290
291
292 void
ImfHeaderScreenWindowCenter(const ImfHeader * hdr,float * x,float * y)293 ImfHeaderScreenWindowCenter (const ImfHeader *hdr, float *x, float *y)
294 {
295 const V2i &swc = header(hdr)->screenWindowCenter();
296 *x = (float) swc.x;
297 *y = (float) swc.y;
298 }
299
300
301 void
ImfHeaderSetScreenWindowWidth(ImfHeader * hdr,float width)302 ImfHeaderSetScreenWindowWidth (ImfHeader *hdr, float width)
303 {
304 header(hdr)->screenWindowWidth() = width;
305 }
306
307
308 float
ImfHeaderScreenWindowWidth(const ImfHeader * hdr)309 ImfHeaderScreenWindowWidth (const ImfHeader *hdr)
310 {
311 return header(hdr)->screenWindowWidth();
312 }
313
314
315 void
ImfHeaderSetLineOrder(ImfHeader * hdr,int lineOrder)316 ImfHeaderSetLineOrder (ImfHeader *hdr, int lineOrder)
317 {
318 header(hdr)->lineOrder() = OPENEXR_IMF_INTERNAL_NAMESPACE::LineOrder (lineOrder);
319 }
320
321
322 int
ImfHeaderLineOrder(const ImfHeader * hdr)323 ImfHeaderLineOrder (const ImfHeader *hdr)
324 {
325 return header(hdr)->lineOrder();
326 }
327
328
329 void
ImfHeaderSetCompression(ImfHeader * hdr,int compression)330 ImfHeaderSetCompression (ImfHeader *hdr, int compression)
331 {
332 header(hdr)->compression() = OPENEXR_IMF_INTERNAL_NAMESPACE::Compression (compression);
333 }
334
335
336 int
ImfHeaderCompression(const ImfHeader * hdr)337 ImfHeaderCompression (const ImfHeader *hdr)
338 {
339 return header(hdr)->compression();
340 }
341
342
343 int
ImfHeaderSetIntAttribute(ImfHeader * hdr,const char name[],int value)344 ImfHeaderSetIntAttribute (ImfHeader *hdr, const char name[], int value)
345 {
346 try
347 {
348 if (header(hdr)->find(name) == header(hdr)->end())
349 {
350 header(hdr)->insert (name, OPENEXR_IMF_INTERNAL_NAMESPACE::IntAttribute (value));
351 }
352 else
353 {
354 header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::IntAttribute>(name).value() =
355 value;
356 }
357
358 return 1;
359 }
360 catch (const std::exception &e)
361 {
362 setErrorMessage (e);
363 return 0;
364 }
365 }
366
367
368 int
ImfHeaderIntAttribute(const ImfHeader * hdr,const char name[],int * value)369 ImfHeaderIntAttribute (const ImfHeader *hdr, const char name[], int *value)
370 {
371 try
372 {
373 *value = header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::IntAttribute>(name).value();
374 return 1;
375 }
376 catch (const std::exception &e)
377 {
378 setErrorMessage (e);
379 return 0;
380 }
381 }
382
383
384 int
ImfHeaderSetFloatAttribute(ImfHeader * hdr,const char name[],float value)385 ImfHeaderSetFloatAttribute (ImfHeader *hdr, const char name[], float value)
386 {
387 try
388 {
389 if (header(hdr)->find(name) == header(hdr)->end())
390 {
391 header(hdr)->insert (name, OPENEXR_IMF_INTERNAL_NAMESPACE::FloatAttribute (value));
392 }
393 else
394 {
395 header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::FloatAttribute>(name).value() =
396 value;
397 }
398
399 return 1;
400 }
401 catch (const std::exception &e)
402 {
403 setErrorMessage (e);
404 return 0;
405 }
406 }
407
408
409 int
ImfHeaderSetDoubleAttribute(ImfHeader * hdr,const char name[],double value)410 ImfHeaderSetDoubleAttribute (ImfHeader *hdr, const char name[], double value)
411 {
412 try
413 {
414 if (header(hdr)->find(name) == header(hdr)->end())
415 {
416 header(hdr)->insert (name, OPENEXR_IMF_INTERNAL_NAMESPACE::DoubleAttribute (value));
417 }
418 else
419 {
420 header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::DoubleAttribute>(name).value() =
421 value;
422 }
423
424 return 1;
425 }
426 catch (const std::exception &e)
427 {
428 setErrorMessage (e);
429 return 0;
430 }
431 }
432
433
434 int
ImfHeaderFloatAttribute(const ImfHeader * hdr,const char name[],float * value)435 ImfHeaderFloatAttribute (const ImfHeader *hdr, const char name[], float *value)
436 {
437 try
438 {
439 *value = header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::FloatAttribute>(name).value();
440 return 1;
441 }
442 catch (const std::exception &e)
443 {
444 setErrorMessage (e);
445 return 0;
446 }
447 }
448
449
450 int
ImfHeaderDoubleAttribute(const ImfHeader * hdr,const char name[],double * value)451 ImfHeaderDoubleAttribute (const ImfHeader *hdr,
452 const char name[],
453 double *value)
454 {
455 try
456 {
457 *value = header(hdr)->
458 typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::DoubleAttribute>(name).value();
459
460 return 1;
461 }
462 catch (const std::exception &e)
463 {
464 setErrorMessage (e);
465 return 0;
466 }
467 }
468
469
470 int
ImfHeaderSetStringAttribute(ImfHeader * hdr,const char name[],const char value[])471 ImfHeaderSetStringAttribute (ImfHeader *hdr,
472 const char name[],
473 const char value[])
474 {
475 try
476 {
477 if (header(hdr)->find(name) == header(hdr)->end())
478 {
479 header(hdr)->insert (name, OPENEXR_IMF_INTERNAL_NAMESPACE::StringAttribute (value));
480 }
481 else
482 {
483 header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::StringAttribute>(name).value() =
484 value;
485 }
486
487 return 1;
488 }
489 catch (const std::exception &e)
490 {
491 setErrorMessage (e);
492 return 0;
493 }
494 }
495
496
497 int
ImfHeaderStringAttribute(const ImfHeader * hdr,const char name[],const char ** value)498 ImfHeaderStringAttribute (const ImfHeader *hdr,
499 const char name[],
500 const char **value)
501 {
502 try
503 {
504 *value = header(hdr)->
505 typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::StringAttribute>(name).value().c_str();
506
507 return 1;
508 }
509 catch (const std::exception &e)
510 {
511 setErrorMessage (e);
512 return 0;
513 }
514 }
515
516
517 int
ImfHeaderSetBox2iAttribute(ImfHeader * hdr,const char name[],int xMin,int yMin,int xMax,int yMax)518 ImfHeaderSetBox2iAttribute (ImfHeader *hdr,
519 const char name[],
520 int xMin, int yMin,
521 int xMax, int yMax)
522 {
523 try
524 {
525 Box2i box (V2i (xMin, yMin), V2i (xMax, yMax));
526
527 if (header(hdr)->find(name) == header(hdr)->end())
528 {
529 header(hdr)->insert (name, OPENEXR_IMF_INTERNAL_NAMESPACE::Box2iAttribute (box));
530 }
531 else
532 {
533 header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::Box2iAttribute>(name).value() =
534 box;
535 }
536
537 return 1;
538 }
539 catch (const std::exception &e)
540 {
541 setErrorMessage (e);
542 return 0;
543 }
544 }
545
546
547 int
ImfHeaderBox2iAttribute(const ImfHeader * hdr,const char name[],int * xMin,int * yMin,int * xMax,int * yMax)548 ImfHeaderBox2iAttribute (const ImfHeader *hdr,
549 const char name[],
550 int *xMin, int *yMin,
551 int *xMax, int *yMax)
552 {
553 try
554 {
555 const Box2i &box =
556 header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::Box2iAttribute>(name).value();
557
558 *xMin = box.min.x;
559 *yMin = box.min.y;
560 *xMax = box.max.x;
561 *yMax = box.max.y;
562
563 return 1;
564 }
565 catch (const std::exception &e)
566 {
567 setErrorMessage (e);
568 return 0;
569 }
570 }
571
572
573 int
ImfHeaderSetBox2fAttribute(ImfHeader * hdr,const char name[],float xMin,float yMin,float xMax,float yMax)574 ImfHeaderSetBox2fAttribute (ImfHeader *hdr,
575 const char name[],
576 float xMin, float yMin,
577 float xMax, float yMax)
578 {
579 try
580 {
581 Box2f box (V2f (xMin, yMin), V2f (xMax, yMax));
582
583 if (header(hdr)->find(name) == header(hdr)->end())
584 {
585 header(hdr)->insert (name, OPENEXR_IMF_INTERNAL_NAMESPACE::Box2fAttribute (box));
586 }
587 else
588 {
589 header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::Box2fAttribute>(name).value() =
590 box;
591 }
592
593 return 1;
594 }
595 catch (const std::exception &e)
596 {
597 setErrorMessage (e);
598 return 0;
599 }
600 }
601
602
603 int
ImfHeaderBox2fAttribute(const ImfHeader * hdr,const char name[],float * xMin,float * yMin,float * xMax,float * yMax)604 ImfHeaderBox2fAttribute (const ImfHeader *hdr,
605 const char name[],
606 float *xMin, float *yMin,
607 float *xMax, float *yMax)
608 {
609 try
610 {
611 const Box2f &box =
612 header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::Box2fAttribute>(name).value();
613
614 *xMin = box.min.x;
615 *yMin = box.min.y;
616 *xMax = box.max.x;
617 *yMax = box.max.y;
618
619 return 1;
620 }
621 catch (const std::exception &e)
622 {
623 setErrorMessage (e);
624 return 0;
625 }
626 }
627
628
629 int
ImfHeaderSetV2iAttribute(ImfHeader * hdr,const char name[],int x,int y)630 ImfHeaderSetV2iAttribute (ImfHeader *hdr,
631 const char name[],
632 int x, int y)
633 {
634 try
635 {
636 V2i v (x, y);
637
638 if (header(hdr)->find(name) == header(hdr)->end())
639 header(hdr)->insert (name, OPENEXR_IMF_INTERNAL_NAMESPACE::V2iAttribute (v));
640 else
641 header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::V2iAttribute>(name).value() = v;
642
643 return 1;
644 }
645 catch (const std::exception &e)
646 {
647 setErrorMessage (e);
648 return 0;
649 }
650 }
651
652
653 int
ImfHeaderV2iAttribute(const ImfHeader * hdr,const char name[],int * x,int * y)654 ImfHeaderV2iAttribute (const ImfHeader *hdr,
655 const char name[],
656 int *x, int *y)
657 {
658 try
659 {
660 const V2i &v =
661 header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::V2iAttribute>(name).value();
662
663 *x = v.x;
664 *y = v.y;
665
666 return 1;
667 }
668 catch (const std::exception &e)
669 {
670 setErrorMessage (e);
671 return 0;
672 }
673 }
674
675
676 int
ImfHeaderSetV2fAttribute(ImfHeader * hdr,const char name[],float x,float y)677 ImfHeaderSetV2fAttribute (ImfHeader *hdr,
678 const char name[],
679 float x, float y)
680 {
681 try
682 {
683 V2f v (x, y);
684
685 if (header(hdr)->find(name) == header(hdr)->end())
686 header(hdr)->insert (name, OPENEXR_IMF_INTERNAL_NAMESPACE::V2fAttribute (v));
687 else
688 header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::V2fAttribute>(name).value() = v;
689
690 return 1;
691 }
692 catch (const std::exception &e)
693 {
694 setErrorMessage (e);
695 return 0;
696 }
697 }
698
699
700 int
ImfHeaderV2fAttribute(const ImfHeader * hdr,const char name[],float * x,float * y)701 ImfHeaderV2fAttribute (const ImfHeader *hdr,
702 const char name[],
703 float *x, float *y)
704 {
705 try
706 {
707 const V2f &v =
708 header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::V2fAttribute>(name).value();
709
710 *x = v.x;
711 *y = v.y;
712
713 return 1;
714 }
715 catch (const std::exception &e)
716 {
717 setErrorMessage (e);
718 return 0;
719 }
720 }
721
722
723 int
ImfHeaderSetV3iAttribute(ImfHeader * hdr,const char name[],int x,int y,int z)724 ImfHeaderSetV3iAttribute (ImfHeader *hdr,
725 const char name[],
726 int x, int y, int z)
727 {
728 try
729 {
730 V3i v (x, y, z);
731
732 if (header(hdr)->find(name) == header(hdr)->end())
733 header(hdr)->insert (name, OPENEXR_IMF_INTERNAL_NAMESPACE::V3iAttribute (v));
734 else
735 header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::V3iAttribute>(name).value() = v;
736
737 return 1;
738 }
739 catch (const std::exception &e)
740 {
741 setErrorMessage (e);
742 return 0;
743 }
744 }
745
746
747 int
ImfHeaderV3iAttribute(const ImfHeader * hdr,const char name[],int * x,int * y,int * z)748 ImfHeaderV3iAttribute (const ImfHeader *hdr,
749 const char name[],
750 int *x, int *y, int *z)
751 {
752 try
753 {
754 const V3i &v =
755 header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::V3iAttribute>(name).value();
756
757 *x = v.x;
758 *y = v.y;
759 *z = v.z;
760
761 return 1;
762 }
763 catch (const std::exception &e)
764 {
765 setErrorMessage (e);
766 return 0;
767 }
768 }
769
770
771 int
ImfHeaderSetV3fAttribute(ImfHeader * hdr,const char name[],float x,float y,float z)772 ImfHeaderSetV3fAttribute (ImfHeader *hdr,
773 const char name[],
774 float x, float y, float z)
775 {
776 try
777 {
778 V3f v (x, y, z);
779
780 if (header(hdr)->find(name) == header(hdr)->end())
781 header(hdr)->insert (name, OPENEXR_IMF_INTERNAL_NAMESPACE::V3fAttribute (v));
782 else
783 header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::V3fAttribute>(name).value() = v;
784
785 return 1;
786 }
787 catch (const std::exception &e)
788 {
789 setErrorMessage (e);
790 return 0;
791 }
792 }
793
794
795 int
ImfHeaderV3fAttribute(const ImfHeader * hdr,const char name[],float * x,float * y,float * z)796 ImfHeaderV3fAttribute (const ImfHeader *hdr,
797 const char name[],
798 float *x, float *y, float *z)
799 {
800 try
801 {
802 const V3f &v =
803 header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::V3fAttribute>(name).value();
804
805 *x = v.x;
806 *y = v.y;
807 *z = v.z;
808
809 return 1;
810 }
811 catch (const std::exception &e)
812 {
813 setErrorMessage (e);
814 return 0;
815 }
816 }
817
818
819 int
ImfHeaderSetM33fAttribute(ImfHeader * hdr,const char name[],const float m[3][3])820 ImfHeaderSetM33fAttribute (ImfHeader *hdr,
821 const char name[],
822 const float m[3][3])
823 {
824 try
825 {
826 M33f m3 (m);
827
828 if (header(hdr)->find(name) == header(hdr)->end())
829 header(hdr)->insert (name, OPENEXR_IMF_INTERNAL_NAMESPACE::M33fAttribute (m3));
830 else
831 header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::M33fAttribute>(name).value() = m3;
832
833 return 1;
834 }
835 catch (const std::exception &e)
836 {
837 setErrorMessage (e);
838 return 0;
839 }
840 }
841
842
843 int
ImfHeaderM33fAttribute(const ImfHeader * hdr,const char name[],float m[3][3])844 ImfHeaderM33fAttribute (const ImfHeader *hdr,
845 const char name[],
846 float m[3][3])
847 {
848 try
849 {
850 const M33f &m3 =
851 header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::M33fAttribute>(name).value();
852
853 m[0][0] = m3[0][0];
854 m[0][1] = m3[0][1];
855 m[0][2] = m3[0][2];
856
857 m[1][0] = m3[1][0];
858 m[1][1] = m3[1][1];
859 m[1][2] = m3[1][2];
860
861 m[2][0] = m3[2][0];
862 m[2][1] = m3[2][1];
863 m[2][2] = m3[2][2];
864
865 return 1;
866 }
867 catch (const std::exception &e)
868 {
869 setErrorMessage (e);
870 return 0;
871 }
872 }
873
874
875 int
ImfHeaderSetM44fAttribute(ImfHeader * hdr,const char name[],const float m[4][4])876 ImfHeaderSetM44fAttribute (ImfHeader *hdr,
877 const char name[],
878 const float m[4][4])
879 {
880 try
881 {
882 M44f m4 (m);
883
884 if (header(hdr)->find(name) == header(hdr)->end())
885 header(hdr)->insert (name, OPENEXR_IMF_INTERNAL_NAMESPACE::M44fAttribute (m4));
886 else
887 header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::M44fAttribute>(name).value() = m4;
888
889 return 1;
890 }
891 catch (const std::exception &e)
892 {
893 setErrorMessage (e);
894 return 0;
895 }
896 }
897
898
899 int
ImfHeaderM44fAttribute(const ImfHeader * hdr,const char name[],float m[4][4])900 ImfHeaderM44fAttribute (const ImfHeader *hdr,
901 const char name[],
902 float m[4][4])
903 {
904 try
905 {
906 const M44f &m4 =
907 header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::M44fAttribute>(name).value();
908
909 m[0][0] = m4[0][0];
910 m[0][1] = m4[0][1];
911 m[0][2] = m4[0][2];
912 m[0][3] = m4[0][3];
913
914 m[1][0] = m4[1][0];
915 m[1][1] = m4[1][1];
916 m[1][2] = m4[1][2];
917 m[1][3] = m4[1][3];
918
919 m[2][0] = m4[2][0];
920 m[2][1] = m4[2][1];
921 m[2][2] = m4[2][2];
922 m[2][3] = m4[2][3];
923
924 m[3][0] = m4[3][0];
925 m[3][1] = m4[3][1];
926 m[3][2] = m4[3][2];
927 m[3][3] = m4[3][3];
928
929 return 1;
930 }
931 catch (const std::exception &e)
932 {
933 setErrorMessage (e);
934 return 0;
935 }
936 }
937
938
939 ImfOutputFile *
ImfOpenOutputFile(const char name[],const ImfHeader * hdr,int channels)940 ImfOpenOutputFile (const char name[], const ImfHeader *hdr, int channels)
941 {
942 try
943 {
944 return (ImfOutputFile *) new OPENEXR_IMF_INTERNAL_NAMESPACE::RgbaOutputFile
945 (name, *header(hdr), OPENEXR_IMF_INTERNAL_NAMESPACE::RgbaChannels (channels));
946 }
947 catch (const std::exception &e)
948 {
949 setErrorMessage (e);
950 return 0;
951 }
952 }
953
954
955 int
ImfCloseOutputFile(ImfOutputFile * out)956 ImfCloseOutputFile (ImfOutputFile *out)
957 {
958 try
959 {
960 delete outfile (out);
961 return 1;
962 }
963 catch (const std::exception &e)
964 {
965 setErrorMessage (e);
966 return 0;
967 }
968 }
969
970
971 int
ImfOutputSetFrameBuffer(ImfOutputFile * out,const ImfRgba * base,size_t xStride,size_t yStride)972 ImfOutputSetFrameBuffer (ImfOutputFile *out,
973 const ImfRgba *base,
974 size_t xStride,
975 size_t yStride)
976 {
977 try
978 {
979 outfile(out)->setFrameBuffer ((OPENEXR_IMF_INTERNAL_NAMESPACE::Rgba *)base, xStride, yStride);
980 return 1;
981 }
982 catch (const std::exception &e)
983 {
984 setErrorMessage (e);
985 return 0;
986 }
987 }
988
989
990 int
ImfOutputWritePixels(ImfOutputFile * out,int numScanLines)991 ImfOutputWritePixels (ImfOutputFile *out, int numScanLines)
992 {
993 try
994 {
995 outfile(out)->writePixels (numScanLines);
996 return 1;
997 }
998 catch (const std::exception &e)
999 {
1000 setErrorMessage (e);
1001 return 0;
1002 }
1003 }
1004
1005
1006 int
ImfOutputCurrentScanLine(const ImfOutputFile * out)1007 ImfOutputCurrentScanLine (const ImfOutputFile *out)
1008 {
1009 return outfile(out)->currentScanLine();
1010 }
1011
1012
1013 const ImfHeader *
ImfOutputHeader(const ImfOutputFile * out)1014 ImfOutputHeader (const ImfOutputFile *out)
1015 {
1016 return (const ImfHeader *) &outfile(out)->header();
1017 }
1018
1019
1020 int
ImfOutputChannels(const ImfOutputFile * out)1021 ImfOutputChannels (const ImfOutputFile *out)
1022 {
1023 return outfile(out)->channels();
1024 }
1025
1026
1027 ImfTiledOutputFile *
ImfOpenTiledOutputFile(const char name[],const ImfHeader * hdr,int channels,int xSize,int ySize,int mode,int rmode)1028 ImfOpenTiledOutputFile (const char name[],
1029 const ImfHeader *hdr,
1030 int channels,
1031 int xSize, int ySize,
1032 int mode, int rmode)
1033 {
1034 try
1035 {
1036 return (ImfTiledOutputFile *) new OPENEXR_IMF_INTERNAL_NAMESPACE::TiledRgbaOutputFile
1037 (name, *header(hdr),
1038 OPENEXR_IMF_INTERNAL_NAMESPACE::RgbaChannels (channels),
1039 xSize, ySize,
1040 OPENEXR_IMF_INTERNAL_NAMESPACE::LevelMode (mode),
1041 OPENEXR_IMF_INTERNAL_NAMESPACE::LevelRoundingMode (rmode));
1042 }
1043 catch (const std::exception &e)
1044 {
1045 setErrorMessage (e);
1046 return 0;
1047 }
1048 }
1049
1050
1051 int
ImfCloseTiledOutputFile(ImfTiledOutputFile * out)1052 ImfCloseTiledOutputFile (ImfTiledOutputFile *out)
1053 {
1054 try
1055 {
1056 delete outfile (out);
1057 return 1;
1058 }
1059 catch (const std::exception &e)
1060 {
1061 setErrorMessage (e);
1062 return 0;
1063 }
1064 }
1065
1066
1067 int
ImfTiledOutputSetFrameBuffer(ImfTiledOutputFile * out,const ImfRgba * base,size_t xStride,size_t yStride)1068 ImfTiledOutputSetFrameBuffer (ImfTiledOutputFile *out,
1069 const ImfRgba *base,
1070 size_t xStride,
1071 size_t yStride)
1072 {
1073 try
1074 {
1075 outfile(out)->setFrameBuffer ((OPENEXR_IMF_INTERNAL_NAMESPACE::Rgba *)base, xStride, yStride);
1076 return 1;
1077 }
1078 catch (const std::exception &e)
1079 {
1080 setErrorMessage (e);
1081 return 0;
1082 }
1083 }
1084
1085
1086 int
ImfTiledOutputWriteTile(ImfTiledOutputFile * out,int dx,int dy,int lx,int ly)1087 ImfTiledOutputWriteTile (ImfTiledOutputFile *out,
1088 int dx, int dy,
1089 int lx, int ly)
1090 {
1091 try
1092 {
1093 outfile(out)->writeTile (dx, dy, lx, ly);
1094 return 1;
1095 }
1096 catch (const std::exception &e)
1097 {
1098 setErrorMessage (e);
1099 return 0;
1100 }
1101 }
1102
1103
1104 int
ImfTiledOutputWriteTiles(ImfTiledOutputFile * out,int dxMin,int dxMax,int dyMin,int dyMax,int lx,int ly)1105 ImfTiledOutputWriteTiles (ImfTiledOutputFile *out,
1106 int dxMin, int dxMax,
1107 int dyMin, int dyMax,
1108 int lx, int ly)
1109 {
1110 try
1111 {
1112 outfile(out)->writeTiles (dxMin, dxMax, dyMin, dyMax, lx, ly);
1113 return 1;
1114 }
1115 catch (const std::exception &e)
1116 {
1117 setErrorMessage (e);
1118 return 0;
1119 }
1120 }
1121
1122
1123 const ImfHeader *
ImfTiledOutputHeader(const ImfTiledOutputFile * out)1124 ImfTiledOutputHeader (const ImfTiledOutputFile *out)
1125 {
1126 return (const ImfHeader *) &outfile(out)->header();
1127 }
1128
1129
1130 int
ImfTiledOutputChannels(const ImfTiledOutputFile * out)1131 ImfTiledOutputChannels (const ImfTiledOutputFile *out)
1132 {
1133 return outfile(out)->channels();
1134 }
1135
1136
1137 int
ImfTiledOutputTileXSize(const ImfTiledOutputFile * out)1138 ImfTiledOutputTileXSize (const ImfTiledOutputFile *out)
1139 {
1140 return outfile(out)->tileXSize();
1141 }
1142
1143
1144 int
ImfTiledOutputTileYSize(const ImfTiledOutputFile * out)1145 ImfTiledOutputTileYSize (const ImfTiledOutputFile *out)
1146 {
1147 return outfile(out)->tileYSize();
1148 }
1149
1150
1151 int
ImfTiledOutputLevelMode(const ImfTiledOutputFile * out)1152 ImfTiledOutputLevelMode (const ImfTiledOutputFile *out)
1153 {
1154 return outfile(out)->levelMode();
1155 }
1156
1157
1158 int
ImfTiledOutputLevelRoundingMode(const ImfTiledOutputFile * out)1159 ImfTiledOutputLevelRoundingMode (const ImfTiledOutputFile *out)
1160 {
1161 return outfile(out)->levelRoundingMode();
1162 }
1163
1164
1165 ImfInputFile *
ImfOpenInputFile(const char name[])1166 ImfOpenInputFile (const char name[])
1167 {
1168 try
1169 {
1170 return (ImfInputFile *) new OPENEXR_IMF_INTERNAL_NAMESPACE::RgbaInputFile (name);
1171 }
1172 catch (const std::exception &e)
1173 {
1174 setErrorMessage (e);
1175 return 0;
1176 }
1177 }
1178
1179
1180 int
ImfCloseInputFile(ImfInputFile * in)1181 ImfCloseInputFile (ImfInputFile *in)
1182 {
1183 try
1184 {
1185 delete infile (in);
1186 return 1;
1187 }
1188 catch (const std::exception &e)
1189 {
1190 setErrorMessage (e);
1191 return 0;
1192 }
1193 }
1194
1195
1196 int
ImfInputSetFrameBuffer(ImfInputFile * in,ImfRgba * base,size_t xStride,size_t yStride)1197 ImfInputSetFrameBuffer (ImfInputFile *in,
1198 ImfRgba *base,
1199 size_t xStride,
1200 size_t yStride)
1201 {
1202 try
1203 {
1204 infile(in)->setFrameBuffer ((OPENEXR_IMF_INTERNAL_NAMESPACE::Rgba *) base, xStride, yStride);
1205 return 1;
1206 }
1207 catch (const std::exception &e)
1208 {
1209 setErrorMessage (e);
1210 return 0;
1211 }
1212 }
1213
1214
1215 int
ImfInputReadPixels(ImfInputFile * in,int scanLine1,int scanLine2)1216 ImfInputReadPixels (ImfInputFile *in, int scanLine1, int scanLine2)
1217 {
1218 try
1219 {
1220 infile(in)->readPixels (scanLine1, scanLine2);
1221 return 1;
1222 }
1223 catch (const std::exception &e)
1224 {
1225 setErrorMessage (e);
1226 return 0;
1227 }
1228 }
1229
1230
1231 const ImfHeader *
ImfInputHeader(const ImfInputFile * in)1232 ImfInputHeader (const ImfInputFile *in)
1233 {
1234 return (const ImfHeader *) &infile(in)->header();
1235 }
1236
1237
1238 int
ImfInputChannels(const ImfInputFile * in)1239 ImfInputChannels (const ImfInputFile *in)
1240 {
1241 return infile(in)->channels();
1242 }
1243
1244
1245 const char *
ImfInputFileName(const ImfInputFile * in)1246 ImfInputFileName (const ImfInputFile *in)
1247 {
1248 return infile(in)->fileName();
1249 }
1250
1251
1252 ImfTiledInputFile *
ImfOpenTiledInputFile(const char name[])1253 ImfOpenTiledInputFile (const char name[])
1254 {
1255 try
1256 {
1257 return (ImfTiledInputFile *) new OPENEXR_IMF_INTERNAL_NAMESPACE::TiledRgbaInputFile (name);
1258 }
1259 catch (const std::exception &e)
1260 {
1261 setErrorMessage (e);
1262 return 0;
1263 }
1264 }
1265
1266
1267 int
ImfCloseTiledInputFile(ImfTiledInputFile * in)1268 ImfCloseTiledInputFile (ImfTiledInputFile *in)
1269 {
1270 try
1271 {
1272 delete infile (in);
1273 return 1;
1274 }
1275 catch (const std::exception &e)
1276 {
1277 setErrorMessage (e);
1278 return 0;
1279 }
1280 }
1281
1282
1283 int
ImfTiledInputSetFrameBuffer(ImfTiledInputFile * in,ImfRgba * base,size_t xStride,size_t yStride)1284 ImfTiledInputSetFrameBuffer (ImfTiledInputFile *in,
1285 ImfRgba *base,
1286 size_t xStride,
1287 size_t yStride)
1288 {
1289 try
1290 {
1291 infile(in)->setFrameBuffer ((OPENEXR_IMF_INTERNAL_NAMESPACE::Rgba *) base, xStride, yStride);
1292 return 1;
1293 }
1294 catch (const std::exception &e)
1295 {
1296 setErrorMessage (e);
1297 return 0;
1298 }
1299 }
1300
1301
1302 int
ImfTiledInputReadTile(ImfTiledInputFile * in,int dx,int dy,int lx,int ly)1303 ImfTiledInputReadTile (ImfTiledInputFile *in,
1304 int dx, int dy,
1305 int lx, int ly)
1306 {
1307 try
1308 {
1309 infile(in)->readTile (dx, dy, lx, ly);
1310 return 1;
1311 }
1312 catch (const std::exception &e)
1313 {
1314 setErrorMessage (e);
1315 return 0;
1316 }
1317 }
1318
1319
1320 int
ImfTiledInputReadTiles(ImfTiledInputFile * in,int dxMin,int dxMax,int dyMin,int dyMax,int lx,int ly)1321 ImfTiledInputReadTiles (ImfTiledInputFile *in,
1322 int dxMin, int dxMax,
1323 int dyMin, int dyMax,
1324 int lx, int ly)
1325 {
1326 try
1327 {
1328 infile(in)->readTiles (dxMin, dxMax, dyMin, dyMax, lx, ly);
1329 return 1;
1330 }
1331 catch (const std::exception &e)
1332 {
1333 setErrorMessage (e);
1334 return 0;
1335 }
1336 }
1337
1338
1339 const ImfHeader *
ImfTiledInputHeader(const ImfTiledInputFile * in)1340 ImfTiledInputHeader (const ImfTiledInputFile *in)
1341 {
1342 return (const ImfHeader *) &infile(in)->header();
1343 }
1344
1345
1346 int
ImfTiledInputChannels(const ImfTiledInputFile * in)1347 ImfTiledInputChannels (const ImfTiledInputFile *in)
1348 {
1349 return infile(in)->channels();
1350 }
1351
1352
1353 const char *
ImfTiledInputFileName(const ImfTiledInputFile * in)1354 ImfTiledInputFileName (const ImfTiledInputFile *in)
1355 {
1356 return infile(in)->fileName();
1357 }
1358
1359
1360 int
ImfTiledInputTileXSize(const ImfTiledInputFile * in)1361 ImfTiledInputTileXSize (const ImfTiledInputFile *in)
1362 {
1363 return infile(in)->tileXSize();
1364 }
1365
1366
1367 int
ImfTiledInputTileYSize(const ImfTiledInputFile * in)1368 ImfTiledInputTileYSize (const ImfTiledInputFile *in)
1369 {
1370 return infile(in)->tileYSize();
1371 }
1372
1373
1374 int
ImfTiledInputLevelMode(const ImfTiledInputFile * in)1375 ImfTiledInputLevelMode (const ImfTiledInputFile *in)
1376 {
1377 return infile(in)->levelMode();
1378 }
1379
1380
1381 int
ImfTiledInputLevelRoundingMode(const ImfTiledInputFile * in)1382 ImfTiledInputLevelRoundingMode (const ImfTiledInputFile *in)
1383 {
1384 return infile(in)->levelRoundingMode();
1385 }
1386
1387
1388 ImfLut *
ImfNewRound12logLut(int channels)1389 ImfNewRound12logLut (int channels)
1390 {
1391 try
1392 {
1393 return (ImfLut *) new OPENEXR_IMF_INTERNAL_NAMESPACE::RgbaLut
1394 (OPENEXR_IMF_INTERNAL_NAMESPACE::round12log, OPENEXR_IMF_INTERNAL_NAMESPACE::RgbaChannels (channels));
1395 }
1396 catch (const std::exception &e)
1397 {
1398 setErrorMessage (e);
1399 return 0;
1400 }
1401 }
1402
1403
1404 ImfLut *
ImfNewRoundNBitLut(unsigned int n,int channels)1405 ImfNewRoundNBitLut (unsigned int n, int channels)
1406 {
1407 try
1408 {
1409 return (ImfLut *) new OPENEXR_IMF_INTERNAL_NAMESPACE::RgbaLut
1410 (OPENEXR_IMF_INTERNAL_NAMESPACE::roundNBit (n), OPENEXR_IMF_INTERNAL_NAMESPACE::RgbaChannels (channels));
1411 }
1412 catch (const std::exception &e)
1413 {
1414 setErrorMessage (e);
1415 return 0;
1416 }
1417 }
1418
1419
1420 void
ImfDeleteLut(ImfLut * lut)1421 ImfDeleteLut (ImfLut *lut)
1422 {
1423 delete (OPENEXR_IMF_INTERNAL_NAMESPACE::RgbaLut *) lut;
1424 }
1425
1426
1427 void
ImfApplyLut(ImfLut * lut,ImfRgba * data,int nData,int stride)1428 ImfApplyLut (ImfLut *lut, ImfRgba *data, int nData, int stride)
1429 {
1430 ((OPENEXR_IMF_INTERNAL_NAMESPACE::RgbaLut *)lut)->apply ((OPENEXR_IMF_INTERNAL_NAMESPACE::Rgba *)data, nData, stride);
1431 }
1432
1433
1434 const char *
ImfErrorMessage()1435 ImfErrorMessage ()
1436 {
1437 return errorMessage;
1438 }
1439