PageRenderTime 85ms CodeModel.GetById 14ms app.highlight 65ms RepoModel.GetById 1ms app.codeStats 0ms

/src/FreeImage/Source/OpenEXR/IlmImf/ImfCRgbaFile.cpp

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