imfcrgbafile.cpp

image converter source code

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, Imf::V3iAttribute (v));
	else
	    header(hdr)->typedAttribute<Imf::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<Imf::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, Imf::V3fAttribute (v));
	else
	    header(hdr)->typedAttribute<Imf::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<Imf::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, Imf::M33fAttribute (m3));
	else
	    header(hdr)->typedAttribute<Imf::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<Imf::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, Imf::M44fAttribute (m4));
	else
	    header(hdr)->typedAttribute<Imf::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<Imf::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 Imf::RgbaOutputFile
	    (name, *header(hdr), Imf::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 ((Imf::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 Imf::TiledRgbaOutputFile
		    (name, *header(hdr),
		     Imf::RgbaChannels (channels),
		     xSize, ySize,
		     Imf::LevelMode (mode),
		     Imf::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 ((Imf::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 Imf::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 ((Imf::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 Imf::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 ((Imf::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 Imf::RgbaLut
	    (Imf::round12log, Imf::RgbaChannels (channels));
    }
    catch (const std::exception &e)
    {
	setErrorMessage (e);
	return 0;
    }
}


ImfLut *
ImfNewRoundNBitLut (unsigned int n, int channels)
{
    try
    {
	return (ImfLut *) new Imf::RgbaLut
	    (Imf::roundNBit (n), Imf::RgbaChannels (channels));
    }
    catch (const std::exception &e)
    {
	setErrorMessage (e);
	return 0;
    }
}


void
ImfDeleteLut (ImfLut *lut)
{
    delete (Imf::RgbaLut *) lut;
}


void
ImfApplyLut (ImfLut *lut, ImfRgba *data, int nData, int stride)
{
    ((Imf::RgbaLut *)lut)->apply ((Imf::Rgba *)data, nData, stride);
}


const char *	
ImfErrorMessage ()
{
    return errorMessage;
}