///////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2004, Industrial Light & Magic, a division of Lucas
// Digital Ltd. LLC
//
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Industrial Light & Magic nor the names of
// its contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
///////////////////////////////////////////////////////////////////////////
//-----------------------------------------------------------------------------
//
// C interface to C++ classes Imf::RgbaOutputFile and Imf::RgbaInputFile
//
//-----------------------------------------------------------------------------
#include <ImfCRgbaFile.h>
#include <ImfRgbaFile.h>
#include <ImfTiledRgbaFile.h>
#include <ImfIntAttribute.h>
#include <ImfFloatAttribute.h>
#include <ImfDoubleAttribute.h>
#include <ImfStringAttribute.h>
#include <ImfBoxAttribute.h>
#include <ImfVecAttribute.h>
#include <ImfMatrixAttribute.h>
#include <ImfChannelList.h>
#include <ImfLut.h>
#include "half.h"
#include "ImfNamespace.h"
#include "ImathForward.h"
#include <string.h>
using IMATH_NAMESPACE::Box2i;
using IMATH_NAMESPACE::Box2f;
using IMATH_NAMESPACE::V2i;
using IMATH_NAMESPACE::V2f;
using IMATH_NAMESPACE::V3i;
using IMATH_NAMESPACE::V3f;
using IMATH_NAMESPACE::M33f;
using IMATH_NAMESPACE::M44f;
namespace {
const int MAX_ERR_LENGTH = 1024;
char errorMessage[MAX_ERR_LENGTH];
void
setErrorMessage (const std::exception &e)
{
strncpy (errorMessage, e.what(), MAX_ERR_LENGTH - 1);
errorMessage[MAX_ERR_LENGTH - 1] = 0;
}
inline OPENEXR_IMF_INTERNAL_NAMESPACE::Header *
header (ImfHeader *hdr)
{
return (OPENEXR_IMF_INTERNAL_NAMESPACE::Header *)(hdr);
}
inline const OPENEXR_IMF_INTERNAL_NAMESPACE::Header *
header (const ImfHeader *hdr)
{
return (const OPENEXR_IMF_INTERNAL_NAMESPACE::Header *)(hdr);
}
inline OPENEXR_IMF_INTERNAL_NAMESPACE::RgbaOutputFile *
outfile (ImfOutputFile *out)
{
return (OPENEXR_IMF_INTERNAL_NAMESPACE::RgbaOutputFile *) out;
}
inline const OPENEXR_IMF_INTERNAL_NAMESPACE::RgbaOutputFile *
outfile (const ImfOutputFile *out)
{
return (const OPENEXR_IMF_INTERNAL_NAMESPACE::RgbaOutputFile *) out;
}
inline OPENEXR_IMF_INTERNAL_NAMESPACE::TiledRgbaOutputFile *
outfile (ImfTiledOutputFile *out)
{
return (OPENEXR_IMF_INTERNAL_NAMESPACE::TiledRgbaOutputFile *) out;
}
inline const OPENEXR_IMF_INTERNAL_NAMESPACE::TiledRgbaOutputFile *
outfile (const ImfTiledOutputFile *out)
{
return (const OPENEXR_IMF_INTERNAL_NAMESPACE::TiledRgbaOutputFile *) out;
}
inline OPENEXR_IMF_INTERNAL_NAMESPACE::RgbaInputFile *
infile (ImfInputFile *in)
{
return (OPENEXR_IMF_INTERNAL_NAMESPACE::RgbaInputFile *) in;
}
inline const OPENEXR_IMF_INTERNAL_NAMESPACE::RgbaInputFile *
infile (const ImfInputFile *in)
{
return (const OPENEXR_IMF_INTERNAL_NAMESPACE::RgbaInputFile *) in;
}
inline OPENEXR_IMF_INTERNAL_NAMESPACE::TiledRgbaInputFile *
infile (ImfTiledInputFile *in)
{
return (OPENEXR_IMF_INTERNAL_NAMESPACE::TiledRgbaInputFile *) in;
}
inline const OPENEXR_IMF_INTERNAL_NAMESPACE::TiledRgbaInputFile *
infile (const ImfTiledInputFile *in)
{
return (const OPENEXR_IMF_INTERNAL_NAMESPACE::TiledRgbaInputFile *) in;
}
} // namespace
void
ImfFloatToHalf (float f, ImfHalf *h)
{
*h = half(f).bits();
}
void
ImfFloatToHalfArray (int n, const float f[/*n*/], ImfHalf h[/*n*/])
{
for (int i = 0; i < n; ++i)
h[i] = half(f[i]).bits();
}
float
ImfHalfToFloat (ImfHalf h)
{
return float (*((half *)&h));
}
void
ImfHalfToFloatArray (int n, const ImfHalf h[/*n*/], float f[/*n*/])
{
for (int i = 0; i < n; ++i)
f[i] = float (*((half *)(h + i)));
}
ImfHeader *
ImfNewHeader (void)
{
try
{
return (ImfHeader *) new OPENEXR_IMF_INTERNAL_NAMESPACE::Header;
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
void
ImfDeleteHeader (ImfHeader *hdr)
{
delete header (hdr);
}
ImfHeader *
ImfCopyHeader (const ImfHeader *hdr)
{
try
{
return (ImfHeader *) new OPENEXR_IMF_INTERNAL_NAMESPACE::Header (*header (hdr));
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
void
ImfHeaderSetDisplayWindow (ImfHeader *hdr,
int xMin, int yMin,
int xMax, int yMax)
{
header(hdr)->displayWindow() = Box2i (V2i (xMin, yMin), V2i (xMax, yMax));
}
void
ImfHeaderDisplayWindow (const ImfHeader *hdr,
int *xMin, int *yMin,
int *xMax, int *yMax)
{
const Box2i dw = header(hdr)->displayWindow();
*xMin = dw.min.x;
*yMin = dw.min.y;
*xMax = dw.max.x;
*yMax = dw.max.y;
}
void
ImfHeaderSetDataWindow (ImfHeader *hdr,
int xMin, int yMin,
int xMax, int yMax)
{
header(hdr)->dataWindow() = Box2i (V2i (xMin, yMin), V2i (xMax, yMax));
}
void
ImfHeaderDataWindow (const ImfHeader *hdr,
int *xMin, int *yMin,
int *xMax, int *yMax)
{
const Box2i dw = header(hdr)->dataWindow();
*xMin = dw.min.x;
*yMin = dw.min.y;
*xMax = dw.max.x;
*yMax = dw.max.y;
}
void
ImfHeaderSetPixelAspectRatio (ImfHeader *hdr, float pixelAspectRatio)
{
header(hdr)->pixelAspectRatio() = pixelAspectRatio;
}
float
ImfHeaderPixelAspectRatio (const ImfHeader *hdr)
{
return header(hdr)->pixelAspectRatio();
}
void
ImfHeaderSetScreenWindowCenter (ImfHeader *hdr, float x, float y)
{
header(hdr)->screenWindowCenter() = V2f (x, y);
}
void
ImfHeaderScreenWindowCenter (const ImfHeader *hdr, float *x, float *y)
{
const V2i &swc = header(hdr)->screenWindowCenter();
*x = (float) swc.x;
*y = (float) swc.y;
}
void
ImfHeaderSetScreenWindowWidth (ImfHeader *hdr, float width)
{
header(hdr)->screenWindowWidth() = width;
}
float
ImfHeaderScreenWindowWidth (const ImfHeader *hdr)
{
return header(hdr)->screenWindowWidth();
}
void
ImfHeaderSetLineOrder (ImfHeader *hdr, int lineOrder)
{
header(hdr)->lineOrder() = OPENEXR_IMF_INTERNAL_NAMESPACE::LineOrder (lineOrder);
}
int
ImfHeaderLineOrder (const ImfHeader *hdr)
{
return header(hdr)->lineOrder();
}
void
ImfHeaderSetCompression (ImfHeader *hdr, int compression)
{
header(hdr)->compression() = OPENEXR_IMF_INTERNAL_NAMESPACE::Compression (compression);
}
int
ImfHeaderCompression (const ImfHeader *hdr)
{
return header(hdr)->compression();
}
int
ImfHeaderSetIntAttribute (ImfHeader *hdr, const char name[], int value)
{
try
{
if (header(hdr)->find(name) == header(hdr)->end())
{
header(hdr)->insert (name, OPENEXR_IMF_INTERNAL_NAMESPACE::IntAttribute (value));
}
else
{
header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::IntAttribute>(name).value() =
value;
}
return 1;
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
int
ImfHeaderIntAttribute (const ImfHeader *hdr, const char name[], int *value)
{
try
{
*value = header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::IntAttribute>(name).value();
return 1;
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
int
ImfHeaderSetFloatAttribute (ImfHeader *hdr, const char name[], float value)
{
try
{
if (header(hdr)->find(name) == header(hdr)->end())
{
header(hdr)->insert (name, OPENEXR_IMF_INTERNAL_NAMESPACE::FloatAttribute (value));
}
else
{
header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::FloatAttribute>(name).value() =
value;
}
return 1;
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
int
ImfHeaderSetDoubleAttribute (ImfHeader *hdr, const char name[], double value)
{
try
{
if (header(hdr)->find(name) == header(hdr)->end())
{
header(hdr)->insert (name, OPENEXR_IMF_INTERNAL_NAMESPACE::DoubleAttribute (value));
}
else
{
header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::DoubleAttribute>(name).value() =
value;
}
return 1;
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
int
ImfHeaderFloatAttribute (const ImfHeader *hdr, const char name[], float *value)
{
try
{
*value = header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::FloatAttribute>(name).value();
return 1;
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
int
ImfHeaderDoubleAttribute (const ImfHeader *hdr,
const char name[],
double *value)
{
try
{
*value = header(hdr)->
typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::DoubleAttribute>(name).value();
return 1;
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
int
ImfHeaderSetStringAttribute (ImfHeader *hdr,
const char name[],
const char value[])
{
try
{
if (header(hdr)->find(name) == header(hdr)->end())
{
header(hdr)->insert (name, OPENEXR_IMF_INTERNAL_NAMESPACE::StringAttribute (value));
}
else
{
header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::StringAttribute>(name).value() =
value;
}
return 1;
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
int
ImfHeaderStringAttribute (const ImfHeader *hdr,
const char name[],
const char **value)
{
try
{
*value = header(hdr)->
typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::StringAttribute>(name).value().c_str();
return 1;
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
int
ImfHeaderSetBox2iAttribute (ImfHeader *hdr,
const char name[],
int xMin, int yMin,
int xMax, int yMax)
{
try
{
Box2i box (V2i (xMin, yMin), V2i (xMax, yMax));
if (header(hdr)->find(name) == header(hdr)->end())
{
header(hdr)->insert (name, OPENEXR_IMF_INTERNAL_NAMESPACE::Box2iAttribute (box));
}
else
{
header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::Box2iAttribute>(name).value() =
box;
}
return 1;
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
int
ImfHeaderBox2iAttribute (const ImfHeader *hdr,
const char name[],
int *xMin, int *yMin,
int *xMax, int *yMax)
{
try
{
const Box2i &box =
header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::Box2iAttribute>(name).value();
*xMin = box.min.x;
*yMin = box.min.y;
*xMax = box.max.x;
*yMax = box.max.y;
return 1;
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
int
ImfHeaderSetBox2fAttribute (ImfHeader *hdr,
const char name[],
float xMin, float yMin,
float xMax, float yMax)
{
try
{
Box2f box (V2f (xMin, yMin), V2f (xMax, yMax));
if (header(hdr)->find(name) == header(hdr)->end())
{
header(hdr)->insert (name, OPENEXR_IMF_INTERNAL_NAMESPACE::Box2fAttribute (box));
}
else
{
header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::Box2fAttribute>(name).value() =
box;
}
return 1;
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
int
ImfHeaderBox2fAttribute (const ImfHeader *hdr,
const char name[],
float *xMin, float *yMin,
float *xMax, float *yMax)
{
try
{
const Box2f &box =
header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::Box2fAttribute>(name).value();
*xMin = box.min.x;
*yMin = box.min.y;
*xMax = box.max.x;
*yMax = box.max.y;
return 1;
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
int
ImfHeaderSetV2iAttribute (ImfHeader *hdr,
const char name[],
int x, int y)
{
try
{
V2i v (x, y);
if (header(hdr)->find(name) == header(hdr)->end())
header(hdr)->insert (name, OPENEXR_IMF_INTERNAL_NAMESPACE::V2iAttribute (v));
else
header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::V2iAttribute>(name).value() = v;
return 1;
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
int
ImfHeaderV2iAttribute (const ImfHeader *hdr,
const char name[],
int *x, int *y)
{
try
{
const V2i &v =
header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::V2iAttribute>(name).value();
*x = v.x;
*y = v.y;
return 1;
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
int
ImfHeaderSetV2fAttribute (ImfHeader *hdr,
const char name[],
float x, float y)
{
try
{
V2f v (x, y);
if (header(hdr)->find(name) == header(hdr)->end())
header(hdr)->insert (name, OPENEXR_IMF_INTERNAL_NAMESPACE::V2fAttribute (v));
else
header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::V2fAttribute>(name).value() = v;
return 1;
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
int
ImfHeaderV2fAttribute (const ImfHeader *hdr,
const char name[],
float *x, float *y)
{
try
{
const V2f &v =
header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::V2fAttribute>(name).value();
*x = v.x;
*y = v.y;
return 1;
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
int
ImfHeaderSetV3iAttribute (ImfHeader *hdr,
const char name[],
int x, int y, int z)
{
try
{
V3i v (x, y, z);
if (header(hdr)->find(name) == header(hdr)->end())
header(hdr)->insert (name, OPENEXR_IMF_INTERNAL_NAMESPACE::V3iAttribute (v));
else
header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::V3iAttribute>(name).value() = v;
return 1;
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
int
ImfHeaderV3iAttribute (const ImfHeader *hdr,
const char name[],
int *x, int *y, int *z)
{
try
{
const V3i &v =
header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::V3iAttribute>(name).value();
*x = v.x;
*y = v.y;
*z = v.z;
return 1;
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
int
ImfHeaderSetV3fAttribute (ImfHeader *hdr,
const char name[],
float x, float y, float z)
{
try
{
V3f v (x, y, z);
if (header(hdr)->find(name) == header(hdr)->end())
header(hdr)->insert (name, OPENEXR_IMF_INTERNAL_NAMESPACE::V3fAttribute (v));
else
header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::V3fAttribute>(name).value() = v;
return 1;
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
int
ImfHeaderV3fAttribute (const ImfHeader *hdr,
const char name[],
float *x, float *y, float *z)
{
try
{
const V3f &v =
header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::V3fAttribute>(name).value();
*x = v.x;
*y = v.y;
*z = v.z;
return 1;
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
int
ImfHeaderSetM33fAttribute (ImfHeader *hdr,
const char name[],
const float m[3][3])
{
try
{
M33f m3 (m);
if (header(hdr)->find(name) == header(hdr)->end())
header(hdr)->insert (name, OPENEXR_IMF_INTERNAL_NAMESPACE::M33fAttribute (m3));
else
header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::M33fAttribute>(name).value() = m3;
return 1;
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
int
ImfHeaderM33fAttribute (const ImfHeader *hdr,
const char name[],
float m[3][3])
{
try
{
const M33f &m3 =
header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::M33fAttribute>(name).value();
m[0][0] = m3[0][0];
m[0][1] = m3[0][1];
m[0][2] = m3[0][2];
m[1][0] = m3[1][0];
m[1][1] = m3[1][1];
m[1][2] = m3[1][2];
m[2][0] = m3[2][0];
m[2][1] = m3[2][1];
m[2][2] = m3[2][2];
return 1;
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
int
ImfHeaderSetM44fAttribute (ImfHeader *hdr,
const char name[],
const float m[4][4])
{
try
{
M44f m4 (m);
if (header(hdr)->find(name) == header(hdr)->end())
header(hdr)->insert (name, OPENEXR_IMF_INTERNAL_NAMESPACE::M44fAttribute (m4));
else
header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::M44fAttribute>(name).value() = m4;
return 1;
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
int
ImfHeaderM44fAttribute (const ImfHeader *hdr,
const char name[],
float m[4][4])
{
try
{
const M44f &m4 =
header(hdr)->typedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::M44fAttribute>(name).value();
m[0][0] = m4[0][0];
m[0][1] = m4[0][1];
m[0][2] = m4[0][2];
m[0][3] = m4[0][3];
m[1][0] = m4[1][0];
m[1][1] = m4[1][1];
m[1][2] = m4[1][2];
m[1][3] = m4[1][3];
m[2][0] = m4[2][0];
m[2][1] = m4[2][1];
m[2][2] = m4[2][2];
m[2][3] = m4[2][3];
m[3][0] = m4[3][0];
m[3][1] = m4[3][1];
m[3][2] = m4[3][2];
m[3][3] = m4[3][3];
return 1;
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
ImfOutputFile *
ImfOpenOutputFile (const char name[], const ImfHeader *hdr, int channels)
{
try
{
return (ImfOutputFile *) new OPENEXR_IMF_INTERNAL_NAMESPACE::RgbaOutputFile
(name, *header(hdr), OPENEXR_IMF_INTERNAL_NAMESPACE::RgbaChannels (channels));
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
int
ImfCloseOutputFile (ImfOutputFile *out)
{
try
{
delete outfile (out);
return 1;
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
int
ImfOutputSetFrameBuffer (ImfOutputFile *out,
const ImfRgba *base,
size_t xStride,
size_t yStride)
{
try
{
outfile(out)->setFrameBuffer ((OPENEXR_IMF_INTERNAL_NAMESPACE::Rgba *)base, xStride, yStride);
return 1;
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
int
ImfOutputWritePixels (ImfOutputFile *out, int numScanLines)
{
try
{
outfile(out)->writePixels (numScanLines);
return 1;
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
int
ImfOutputCurrentScanLine (const ImfOutputFile *out)
{
return outfile(out)->currentScanLine();
}
const ImfHeader *
ImfOutputHeader (const ImfOutputFile *out)
{
return (const ImfHeader *) &outfile(out)->header();
}
int
ImfOutputChannels (const ImfOutputFile *out)
{
return outfile(out)->channels();
}
ImfTiledOutputFile *
ImfOpenTiledOutputFile (const char name[],
const ImfHeader *hdr,
int channels,
int xSize, int ySize,
int mode, int rmode)
{
try
{
return (ImfTiledOutputFile *) new OPENEXR_IMF_INTERNAL_NAMESPACE::TiledRgbaOutputFile
(name, *header(hdr),
OPENEXR_IMF_INTERNAL_NAMESPACE::RgbaChannels (channels),
xSize, ySize,
OPENEXR_IMF_INTERNAL_NAMESPACE::LevelMode (mode),
OPENEXR_IMF_INTERNAL_NAMESPACE::LevelRoundingMode (rmode));
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
int
ImfCloseTiledOutputFile (ImfTiledOutputFile *out)
{
try
{
delete outfile (out);
return 1;
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
int
ImfTiledOutputSetFrameBuffer (ImfTiledOutputFile *out,
const ImfRgba *base,
size_t xStride,
size_t yStride)
{
try
{
outfile(out)->setFrameBuffer ((OPENEXR_IMF_INTERNAL_NAMESPACE::Rgba *)base, xStride, yStride);
return 1;
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
int
ImfTiledOutputWriteTile (ImfTiledOutputFile *out,
int dx, int dy,
int lx, int ly)
{
try
{
outfile(out)->writeTile (dx, dy, lx, ly);
return 1;
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
int
ImfTiledOutputWriteTiles (ImfTiledOutputFile *out,
int dxMin, int dxMax,
int dyMin, int dyMax,
int lx, int ly)
{
try
{
outfile(out)->writeTiles (dxMin, dxMax, dyMin, dyMax, lx, ly);
return 1;
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
const ImfHeader *
ImfTiledOutputHeader (const ImfTiledOutputFile *out)
{
return (const ImfHeader *) &outfile(out)->header();
}
int
ImfTiledOutputChannels (const ImfTiledOutputFile *out)
{
return outfile(out)->channels();
}
int
ImfTiledOutputTileXSize (const ImfTiledOutputFile *out)
{
return outfile(out)->tileXSize();
}
int
ImfTiledOutputTileYSize (const ImfTiledOutputFile *out)
{
return outfile(out)->tileYSize();
}
int
ImfTiledOutputLevelMode (const ImfTiledOutputFile *out)
{
return outfile(out)->levelMode();
}
int
ImfTiledOutputLevelRoundingMode (const ImfTiledOutputFile *out)
{
return outfile(out)->levelRoundingMode();
}
ImfInputFile *
ImfOpenInputFile (const char name[])
{
try
{
return (ImfInputFile *) new OPENEXR_IMF_INTERNAL_NAMESPACE::RgbaInputFile (name);
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
int
ImfCloseInputFile (ImfInputFile *in)
{
try
{
delete infile (in);
return 1;
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
int
ImfInputSetFrameBuffer (ImfInputFile *in,
ImfRgba *base,
size_t xStride,
size_t yStride)
{
try
{
infile(in)->setFrameBuffer ((OPENEXR_IMF_INTERNAL_NAMESPACE::Rgba *) base, xStride, yStride);
return 1;
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
int
ImfInputReadPixels (ImfInputFile *in, int scanLine1, int scanLine2)
{
try
{
infile(in)->readPixels (scanLine1, scanLine2);
return 1;
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
const ImfHeader *
ImfInputHeader (const ImfInputFile *in)
{
return (const ImfHeader *) &infile(in)->header();
}
int
ImfInputChannels (const ImfInputFile *in)
{
return infile(in)->channels();
}
const char *
ImfInputFileName (const ImfInputFile *in)
{
return infile(in)->fileName();
}
ImfTiledInputFile *
ImfOpenTiledInputFile (const char name[])
{
try
{
return (ImfTiledInputFile *) new OPENEXR_IMF_INTERNAL_NAMESPACE::TiledRgbaInputFile (name);
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
int
ImfCloseTiledInputFile (ImfTiledInputFile *in)
{
try
{
delete infile (in);
return 1;
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
int
ImfTiledInputSetFrameBuffer (ImfTiledInputFile *in,
ImfRgba *base,
size_t xStride,
size_t yStride)
{
try
{
infile(in)->setFrameBuffer ((OPENEXR_IMF_INTERNAL_NAMESPACE::Rgba *) base, xStride, yStride);
return 1;
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
int
ImfTiledInputReadTile (ImfTiledInputFile *in,
int dx, int dy,
int lx, int ly)
{
try
{
infile(in)->readTile (dx, dy, lx, ly);
return 1;
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
int
ImfTiledInputReadTiles (ImfTiledInputFile *in,
int dxMin, int dxMax,
int dyMin, int dyMax,
int lx, int ly)
{
try
{
infile(in)->readTiles (dxMin, dxMax, dyMin, dyMax, lx, ly);
return 1;
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
const ImfHeader *
ImfTiledInputHeader (const ImfTiledInputFile *in)
{
return (const ImfHeader *) &infile(in)->header();
}
int
ImfTiledInputChannels (const ImfTiledInputFile *in)
{
return infile(in)->channels();
}
const char *
ImfTiledInputFileName (const ImfTiledInputFile *in)
{
return infile(in)->fileName();
}
int
ImfTiledInputTileXSize (const ImfTiledInputFile *in)
{
return infile(in)->tileXSize();
}
int
ImfTiledInputTileYSize (const ImfTiledInputFile *in)
{
return infile(in)->tileYSize();
}
int
ImfTiledInputLevelMode (const ImfTiledInputFile *in)
{
return infile(in)->levelMode();
}
int
ImfTiledInputLevelRoundingMode (const ImfTiledInputFile *in)
{
return infile(in)->levelRoundingMode();
}
ImfLut *
ImfNewRound12logLut (int channels)
{
try
{
return (ImfLut *) new OPENEXR_IMF_INTERNAL_NAMESPACE::RgbaLut
(OPENEXR_IMF_INTERNAL_NAMESPACE::round12log, OPENEXR_IMF_INTERNAL_NAMESPACE::RgbaChannels (channels));
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
ImfLut *
ImfNewRoundNBitLut (unsigned int n, int channels)
{
try
{
return (ImfLut *) new OPENEXR_IMF_INTERNAL_NAMESPACE::RgbaLut
(OPENEXR_IMF_INTERNAL_NAMESPACE::roundNBit (n), OPENEXR_IMF_INTERNAL_NAMESPACE::RgbaChannels (channels));
}
catch (const std::exception &e)
{
setErrorMessage (e);
return 0;
}
}
void
ImfDeleteLut (ImfLut *lut)
{
delete (OPENEXR_IMF_INTERNAL_NAMESPACE::RgbaLut *) lut;
}
void
ImfApplyLut (ImfLut *lut, ImfRgba *data, int nData, int stride)
{
((OPENEXR_IMF_INTERNAL_NAMESPACE::RgbaLut *)lut)->apply ((OPENEXR_IMF_INTERNAL_NAMESPACE::Rgba *)data, nData, stride);
}
const char *
ImfErrorMessage ()
{
return errorMessage;
}