Outsource OpenEXR.
* Style fixes in EXRTranslator.
This commit is contained in:
Kacper Kasper
@@ -32,10 +32,10 @@ AddHaikuImagePackages [ FFilterByBuildFeatures
|
||||
|
||||
regular_image @{
|
||||
bzip2 ctags diffutils expat ffmpeg findutils gawk glu grep gutenprint
|
||||
gzip jasper jpeg
|
||||
gzip ilmbase jasper jpeg
|
||||
less libicns libpcap libpng16 libwebp
|
||||
mesa mesa_devel mesa_swpipe@!gcc2 mesa_swrast@gcc2
|
||||
netcat
|
||||
netcat openexr
|
||||
sed sharutils
|
||||
tar tcpdump unzip wget which zip
|
||||
}@
|
||||
|
||||
@@ -566,6 +566,48 @@ if [ IsPackageAvailable tiff4_devel ] {
|
||||
}
|
||||
|
||||
|
||||
# openexr
|
||||
if [ IsPackageAvailable openexr_devel ]
|
||||
&& [ IsPackageAvailable ilmbase_devel ] {
|
||||
ExtractBuildFeatureArchives openexr :
|
||||
file: base openexr
|
||||
runtime: lib
|
||||
file: devel openexr_devel
|
||||
depends: base
|
||||
libraries:
|
||||
$(developLibDir)/libIlmImf.so
|
||||
$(developLibDir)/libIlmImfUtil.so
|
||||
headers: $(developHeadersDir) $(developHeadersDir)/OpenEXR
|
||||
;
|
||||
|
||||
EnableBuildFeatures openexr ;
|
||||
} else {
|
||||
Echo "OpenEXR support not available on $(TARGET_PACKAGING_ARCH)" ;
|
||||
}
|
||||
|
||||
|
||||
# ilmbase
|
||||
if [ IsPackageAvailable ilmbase_devel ] {
|
||||
ExtractBuildFeatureArchives ilmbase :
|
||||
file: base ilmbase
|
||||
runtime: lib
|
||||
file: devel ilmbase_devel
|
||||
depends: base
|
||||
libraries:
|
||||
$(developLibDir)/libHalf.so
|
||||
$(developLibDir)/libIex.so
|
||||
$(developLibDir)/libIexMath.so
|
||||
$(developLibDir)/libIlmThread.so
|
||||
$(developLibDir)/libImath.so
|
||||
headers: $(developHeadersDir) $(developHeadersDir)/OpenEXR
|
||||
;
|
||||
|
||||
EnableBuildFeatures ilmbase ;
|
||||
} else {
|
||||
Echo "IlmBase support not available on $(TARGET_PACKAGING_ARCH)" ;
|
||||
}
|
||||
|
||||
|
||||
# libwebp
|
||||
if [ IsPackageAvailable libwebp_devel ] {
|
||||
if $(HAIKU_PACKAGING_ARCH) = x86 && $(TARGET_PACKAGING_ARCH) = x86_gcc2 {
|
||||
|
||||
@@ -90,7 +90,6 @@ rule HaikuImageGetPrivateSystemLibs
|
||||
{
|
||||
return [ MultiArchDefaultGristFiles [ FFilterByBuildFeatures
|
||||
libalm.so
|
||||
libilmimf.so
|
||||
libpackage-add-on-libsolv.so
|
||||
libroot-addon-icu.so
|
||||
] ] ;
|
||||
@@ -124,7 +123,7 @@ SYSTEM_ADD_ONS_ACCELERANTS += [ FFilterByBuildFeatures
|
||||
|
||||
SYSTEM_ADD_ONS_TRANSLATORS += [ FFilterByBuildFeatures
|
||||
BMPTranslator
|
||||
EXRTranslator
|
||||
EXRTranslator@ilmbase,openexr
|
||||
GIFTranslator
|
||||
HVIFTranslator
|
||||
ICOTranslator ICNSTranslator@libicns
|
||||
|
||||
@@ -14,6 +14,8 @@
|
||||
#include <LayoutBuilder.h>
|
||||
#include <StringView.h>
|
||||
|
||||
#include <OpenEXRConfig.h>
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
@@ -41,19 +43,21 @@ ConfigView::ConfigView(uint32 flags)
|
||||
BStringView *copyrightView = new BStringView("copyright",
|
||||
B_UTF8_COPYRIGHT "2008 Haiku Inc.");
|
||||
|
||||
BString openExrInfo = B_TRANSLATE("Based on OpenEXR %version%");
|
||||
openExrInfo.ReplaceAll("%version%", OPENEXR_VERSION_STRING);
|
||||
BStringView *copyrightView2 = new BStringView("copyright2",
|
||||
B_TRANSLATE("Based on OpenEXR (http://www.openexr.com)"));
|
||||
openExrInfo.String());
|
||||
|
||||
BStringView *copyrightView3 = new BStringView("copyright3",
|
||||
B_UTF8_COPYRIGHT "2006, Industrial Light & Magic,");
|
||||
B_UTF8_COPYRIGHT "2002-2014 Industrial Light & Magic,");
|
||||
|
||||
BStringView *copyrightView4 = new BStringView("copyright4",
|
||||
B_TRANSLATE("a division of Lucasfilm Entertainment Company Ltd"));
|
||||
|
||||
// Build the layout
|
||||
BLayoutBuilder::Group<>(this, B_VERTICAL, 0)
|
||||
BLayoutBuilder::Group<>(this, B_VERTICAL, 0)
|
||||
.SetInsets(B_USE_DEFAULT_SPACING)
|
||||
.Add(titleView)
|
||||
.Add(titleView)
|
||||
.Add(versionView)
|
||||
.Add(copyrightView)
|
||||
.AddGlue()
|
||||
|
||||
@@ -1,10 +1,5 @@
|
||||
SubDir HAIKU_TOP src add-ons translators exr ;
|
||||
|
||||
SubDirSysHdrs [ FDirName $(SUBDIR) openexr half ] ;
|
||||
SubDirSysHdrs [ FDirName $(SUBDIR) openexr iex ] ;
|
||||
SubDirSysHdrs [ FDirName $(SUBDIR) openexr ilmimf ] ;
|
||||
SubDirSysHdrs [ FDirName $(SUBDIR) openexr imath ] ;
|
||||
|
||||
SubDirHdrs [ FDirName $(SUBDIR) $(DOTDOT) shared ] ;
|
||||
|
||||
AddResources EXRTranslator : EXRTranslator.rdef ;
|
||||
@@ -12,6 +7,13 @@ AddResources EXRTranslator : EXRTranslator.rdef ;
|
||||
local architectureObject ;
|
||||
for architectureObject in [ MultiArchSubDirSetup ] {
|
||||
on $(architectureObject) {
|
||||
UseBuildFeatureHeaders openexr ;
|
||||
UseBuildFeatureHeaders ilmbase ;
|
||||
Includes [ FGristFiles ConfigView.cpp EXRTranslator.cpp EXRGamma.cpp
|
||||
IStreamWrapper.cpp ]
|
||||
: [ BuildFeatureAttribute openexr : headers ]
|
||||
[ BuildFeatureAttribute ilmbase : headers ] ;
|
||||
|
||||
Translator [ MultiArchDefaultGristFiles EXRTranslator ] :
|
||||
main.cpp
|
||||
ConfigView.cpp
|
||||
@@ -19,7 +21,9 @@ for architectureObject in [ MultiArchSubDirSetup ] {
|
||||
EXRTranslator.cpp
|
||||
IStreamWrapper.cpp
|
||||
: be translation textencoding [ TargetLibstdc++ ]
|
||||
[ MultiArchDefaultGristFiles libtranslatorsutils.a libilmimf.so ]
|
||||
[ MultiArchDefaultGristFiles libtranslatorsutils.a ]
|
||||
[ BuildFeatureAttribute ilmbase : libraries ]
|
||||
[ BuildFeatureAttribute openexr : libraries ]
|
||||
localestub
|
||||
: true
|
||||
;
|
||||
@@ -33,6 +37,3 @@ DoCatalogs EXRTranslator :
|
||||
EXRTranslator.cpp
|
||||
main.cpp
|
||||
;
|
||||
|
||||
SubInclude HAIKU_TOP src add-ons translators exr openexr ;
|
||||
|
||||
|
||||
@@ -1,8 +0,0 @@
|
||||
SubDir HAIKU_TOP src add-ons translators exr openexr ;
|
||||
|
||||
SubInclude HAIKU_TOP src add-ons translators exr openexr half ;
|
||||
SubInclude HAIKU_TOP src add-ons translators exr openexr iex ;
|
||||
SubInclude HAIKU_TOP src add-ons translators exr openexr ilmimf ;
|
||||
SubInclude HAIKU_TOP src add-ons translators exr openexr ilmthread ;
|
||||
SubInclude HAIKU_TOP src add-ons translators exr openexr imath ;
|
||||
|
||||
@@ -1,16 +0,0 @@
|
||||
/* config/IlmBaseConfig.h. Generated by configure. */
|
||||
//
|
||||
// Define and set to 1 if the target system has POSIX thread support
|
||||
// and you want IlmBase to use it for multithreaded file I/O.
|
||||
//
|
||||
|
||||
/* #undef HAVE_PTHREAD */
|
||||
|
||||
//
|
||||
// Define and set to 1 if the target system supports POSIX semaphores
|
||||
// and you want OpenEXR to use them; otherwise, OpenEXR will use its
|
||||
// own semaphore implementation.
|
||||
//
|
||||
|
||||
/* #undef HAVE_POSIX_SEMAPHORES */
|
||||
|
||||
@@ -1,32 +0,0 @@
|
||||
/* config/OpenEXRConfig.h. Generated by configure. */
|
||||
//
|
||||
// Define and set to 1 if the target system supports a proc filesystem
|
||||
// compatible with the Linux kernel's proc filesystem. Note that this
|
||||
// is only used by a program in the IlmImfTest test suite, it's not
|
||||
// used by any OpenEXR library or application code.
|
||||
//
|
||||
|
||||
#define HAVE_LINUX_PROCFS 1
|
||||
|
||||
//
|
||||
// Define and set to 1 if the target system is a Darwin-based system
|
||||
// (e.g., OS X).
|
||||
//
|
||||
|
||||
/* #undef HAVE_DARWIN */
|
||||
|
||||
//
|
||||
// Define and set to 1 if the target system has a complete <iomanip>
|
||||
// implementation, specifically if it supports the std::right
|
||||
// formatter.
|
||||
//
|
||||
|
||||
#define HAVE_COMPLETE_IOMANIP 1
|
||||
|
||||
//
|
||||
// Define and set to 1 if the target system has support for large
|
||||
// stack sizes.
|
||||
//
|
||||
|
||||
#define HAVE_LARGE_STACK 1
|
||||
|
||||
@@ -1,501 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// Utility program to print an image file's header
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include "OpenEXRConfig.h"
|
||||
#include <ImfInputFile.h>
|
||||
#include <ImfBoxAttribute.h>
|
||||
#include <ImfChannelListAttribute.h>
|
||||
#include <ImfChromaticitiesAttribute.h>
|
||||
#include <ImfCompressionAttribute.h>
|
||||
#include <ImfDoubleAttribute.h>
|
||||
#include <ImfEnvmapAttribute.h>
|
||||
#include <ImfFloatAttribute.h>
|
||||
#include <ImfIntAttribute.h>
|
||||
#include <ImfKeyCodeAttribute.h>
|
||||
#include <ImfLineOrderAttribute.h>
|
||||
#include <ImfMatrixAttribute.h>
|
||||
#include <ImfPreviewImageAttribute.h>
|
||||
#include <ImfRationalAttribute.h>
|
||||
#include <ImfStringAttribute.h>
|
||||
#include <ImfTileDescriptionAttribute.h>
|
||||
#include <ImfTimeCodeAttribute.h>
|
||||
#include <ImfVecAttribute.h>
|
||||
#include <ImfVersion.h>
|
||||
#include <iostream>
|
||||
#include <iomanip>
|
||||
|
||||
using namespace Imf;
|
||||
using namespace std;
|
||||
|
||||
|
||||
void
|
||||
printCompression (Compression c)
|
||||
{
|
||||
switch (c)
|
||||
{
|
||||
case NO_COMPRESSION:
|
||||
cout << "none";
|
||||
break;
|
||||
|
||||
case RLE_COMPRESSION:
|
||||
cout << "run-length encoding";
|
||||
break;
|
||||
|
||||
case ZIPS_COMPRESSION:
|
||||
cout << "zip, individual scanlines";
|
||||
break;
|
||||
|
||||
case ZIP_COMPRESSION:
|
||||
cout << "zip, multi-scanline blocks";
|
||||
break;
|
||||
|
||||
case PIZ_COMPRESSION:
|
||||
cout << "piz";
|
||||
break;
|
||||
|
||||
case PXR24_COMPRESSION:
|
||||
cout << "pxr24";
|
||||
break;
|
||||
|
||||
case B44_COMPRESSION:
|
||||
cout << "b44";
|
||||
break;
|
||||
|
||||
case B44A_COMPRESSION:
|
||||
cout << "b44a";
|
||||
break;
|
||||
|
||||
default:
|
||||
cout << int (c);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
printLineOrder (LineOrder lo)
|
||||
{
|
||||
switch (lo)
|
||||
{
|
||||
case INCREASING_Y:
|
||||
cout << "increasing y";
|
||||
break;
|
||||
|
||||
case DECREASING_Y:
|
||||
cout << "decreasing y";
|
||||
break;
|
||||
|
||||
case RANDOM_Y:
|
||||
cout << "random y";
|
||||
break;
|
||||
|
||||
default:
|
||||
cout << int (lo);
|
||||
break;
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
printPixelType (PixelType pt)
|
||||
{
|
||||
switch (pt)
|
||||
{
|
||||
case UINT:
|
||||
cout << "32-bit unsigned integer";
|
||||
break;
|
||||
|
||||
case HALF:
|
||||
cout << "16-bit floating-point";
|
||||
break;
|
||||
|
||||
case FLOAT:
|
||||
cout << "32-bit floating-point";
|
||||
break;
|
||||
|
||||
default:
|
||||
cout << "type " << int (pt);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
printLevelMode (LevelMode lm)
|
||||
{
|
||||
switch (lm)
|
||||
{
|
||||
case ONE_LEVEL:
|
||||
cout << "single level";
|
||||
break;
|
||||
|
||||
case MIPMAP_LEVELS:
|
||||
cout << "mip-map";
|
||||
break;
|
||||
|
||||
case RIPMAP_LEVELS:
|
||||
cout << "rip-map";
|
||||
break;
|
||||
|
||||
default:
|
||||
cout << "level mode " << int (lm);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
printLevelRoundingMode (LevelRoundingMode lm)
|
||||
{
|
||||
switch (lm)
|
||||
{
|
||||
case ROUND_DOWN:
|
||||
cout << "down";
|
||||
break;
|
||||
|
||||
case ROUND_UP:
|
||||
cout << "up";
|
||||
break;
|
||||
|
||||
default:
|
||||
cout << "mode " << int (lm);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
printTimeCode (TimeCode tc)
|
||||
{
|
||||
cout << " "
|
||||
"time " <<
|
||||
setfill ('0') <<
|
||||
#ifndef HAVE_COMPLETE_IOMANIP
|
||||
setw (2) << tc.hours() << ":" <<
|
||||
setw (2) << tc.minutes() << ":" <<
|
||||
setw (2) << tc.seconds() << ":" <<
|
||||
setw (2) << tc.frame() << "\n" <<
|
||||
#else
|
||||
setw (2) << right << tc.hours() << ":" <<
|
||||
setw (2) << right << tc.minutes() << ":" <<
|
||||
setw (2) << right << tc.seconds() << ":" <<
|
||||
setw (2) << right << tc.frame() << "\n" <<
|
||||
#endif
|
||||
setfill (' ') <<
|
||||
" "
|
||||
"drop frame " << tc.dropFrame() << ", "
|
||||
"color frame " << tc.colorFrame() << ", "
|
||||
"field/phase " << tc.fieldPhase() << "\n"
|
||||
" "
|
||||
"bgf0 " << tc.bgf0() << ", "
|
||||
"bgf1 " << tc.bgf1() << ", "
|
||||
"bgf2 " << tc.bgf2() << "\n"
|
||||
" "
|
||||
"user data 0x" << hex << tc.userData() << dec;
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
printEnvmap (Envmap e)
|
||||
{
|
||||
switch (e)
|
||||
{
|
||||
case ENVMAP_LATLONG:
|
||||
cout << "latitude-longitude map";
|
||||
break;
|
||||
|
||||
case ENVMAP_CUBE:
|
||||
cout << "cube-face map";
|
||||
break;
|
||||
|
||||
default:
|
||||
cout << "map type " << int (e);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
printChannelList (const ChannelList &cl)
|
||||
{
|
||||
for (ChannelList::ConstIterator i = cl.begin(); i != cl.end(); ++i)
|
||||
{
|
||||
cout << "\n " << i.name() << ", ";
|
||||
|
||||
printPixelType (i.channel().type);
|
||||
|
||||
cout << ", sampling " <<
|
||||
i.channel().xSampling << " " <<
|
||||
i.channel().ySampling;
|
||||
|
||||
if (i.channel().pLinear)
|
||||
cout << ", plinear";
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
printInfo (const char fileName[])
|
||||
{
|
||||
InputFile in (fileName);
|
||||
const Header &h = in.header();
|
||||
|
||||
cout << "\n" << fileName <<
|
||||
(in.isComplete()? "": " (incomplete file)") <<
|
||||
":\n\n";
|
||||
|
||||
cout << "file format version: " <<
|
||||
getVersion (in.version()) << ", "
|
||||
"flags 0x" <<
|
||||
setbase (16) << getFlags (in.version()) << setbase (10) << "\n";
|
||||
|
||||
for (Header::ConstIterator i = h.begin(); i != h.end(); ++i)
|
||||
{
|
||||
const Attribute *a = &i.attribute();
|
||||
cout << i.name() << " (type " << a->typeName() << ")";
|
||||
|
||||
if (const Box2iAttribute *ta =
|
||||
dynamic_cast <const Box2iAttribute *> (a))
|
||||
{
|
||||
cout << ": " << ta->value().min << " - " << ta->value().max;
|
||||
}
|
||||
else if (const Box2fAttribute *ta =
|
||||
dynamic_cast <const Box2fAttribute *> (a))
|
||||
{
|
||||
cout << ": " << ta->value().min << " - " << ta->value().max;
|
||||
}
|
||||
else if (const ChannelListAttribute *ta =
|
||||
dynamic_cast <const ChannelListAttribute *> (a))
|
||||
{
|
||||
cout << ":";
|
||||
printChannelList (ta->value());
|
||||
}
|
||||
else if (const ChromaticitiesAttribute *ta =
|
||||
dynamic_cast <const ChromaticitiesAttribute *> (a))
|
||||
{
|
||||
cout << ":\n"
|
||||
" red " << ta->value().red << "\n"
|
||||
" green " << ta->value().green << "\n"
|
||||
" blue " << ta->value().blue << "\n"
|
||||
" white " << ta->value().white;
|
||||
}
|
||||
else if (const CompressionAttribute *ta =
|
||||
dynamic_cast <const CompressionAttribute *> (a))
|
||||
{
|
||||
cout << ": ";
|
||||
printCompression (ta->value());
|
||||
}
|
||||
else if (const DoubleAttribute *ta =
|
||||
dynamic_cast <const DoubleAttribute *> (a))
|
||||
{
|
||||
cout << ": " << ta->value();
|
||||
}
|
||||
else if (const EnvmapAttribute *ta =
|
||||
dynamic_cast <const EnvmapAttribute *> (a))
|
||||
{
|
||||
cout << ": ";
|
||||
printEnvmap (ta->value());
|
||||
}
|
||||
else if (const FloatAttribute *ta =
|
||||
dynamic_cast <const FloatAttribute *> (a))
|
||||
{
|
||||
cout << ": " << ta->value();
|
||||
}
|
||||
else if (const IntAttribute *ta =
|
||||
dynamic_cast <const IntAttribute *> (a))
|
||||
{
|
||||
cout << ": " << ta->value();
|
||||
}
|
||||
else if (const KeyCodeAttribute *ta =
|
||||
dynamic_cast <const KeyCodeAttribute *> (a))
|
||||
{
|
||||
cout << ":\n"
|
||||
" film manufacturer code " <<
|
||||
ta->value().filmMfcCode() << "\n"
|
||||
" film type code " <<
|
||||
ta->value().filmType() << "\n"
|
||||
" prefix " <<
|
||||
ta->value().prefix() << "\n"
|
||||
" count " <<
|
||||
ta->value().count() << "\n"
|
||||
" perf offset " <<
|
||||
ta->value().perfOffset() << "\n"
|
||||
" perfs per frame " <<
|
||||
ta->value().perfsPerFrame() << "\n"
|
||||
" perfs per count " <<
|
||||
ta->value().perfsPerCount();
|
||||
}
|
||||
else if (const LineOrderAttribute *ta =
|
||||
dynamic_cast <const LineOrderAttribute *> (a))
|
||||
{
|
||||
cout << ": ";
|
||||
printLineOrder (ta->value());
|
||||
}
|
||||
else if (const M33fAttribute *ta =
|
||||
dynamic_cast <const M33fAttribute *> (a))
|
||||
{
|
||||
cout << ":\n"
|
||||
" (" <<
|
||||
ta->value()[0][0] << " " <<
|
||||
ta->value()[0][1] << " " <<
|
||||
ta->value()[0][2] << "\n " <<
|
||||
ta->value()[1][0] << " " <<
|
||||
ta->value()[1][1] << " " <<
|
||||
ta->value()[1][2] << "\n " <<
|
||||
ta->value()[2][0] << " " <<
|
||||
ta->value()[2][1] << " " <<
|
||||
ta->value()[2][2] << ")";
|
||||
}
|
||||
else if (const M44fAttribute *ta =
|
||||
dynamic_cast <const M44fAttribute *> (a))
|
||||
{
|
||||
cout << ":\n"
|
||||
" (" <<
|
||||
ta->value()[0][0] << " " <<
|
||||
ta->value()[0][1] << " " <<
|
||||
ta->value()[0][2] << " " <<
|
||||
ta->value()[0][3] << "\n " <<
|
||||
ta->value()[1][0] << " " <<
|
||||
ta->value()[1][1] << " " <<
|
||||
ta->value()[1][2] << " " <<
|
||||
ta->value()[1][3] << "\n " <<
|
||||
ta->value()[2][0] << " " <<
|
||||
ta->value()[2][1] << " " <<
|
||||
ta->value()[2][2] << " " <<
|
||||
ta->value()[2][3] << "\n " <<
|
||||
ta->value()[3][0] << " " <<
|
||||
ta->value()[3][1] << " " <<
|
||||
ta->value()[3][2] << " " <<
|
||||
ta->value()[3][3] << ")";
|
||||
}
|
||||
else if (const PreviewImageAttribute *ta =
|
||||
dynamic_cast <const PreviewImageAttribute *> (a))
|
||||
{
|
||||
cout << ": " <<
|
||||
ta->value().width() << " by " <<
|
||||
ta->value().height() << " pixels";
|
||||
}
|
||||
else if (const StringAttribute *ta =
|
||||
dynamic_cast <const StringAttribute *> (a))
|
||||
{
|
||||
cout << ": \"" << ta->value() << "\"";
|
||||
}
|
||||
else if (const RationalAttribute *ta =
|
||||
dynamic_cast <const RationalAttribute *> (a))
|
||||
{
|
||||
cout << ": " << ta->value().n << "/" << ta->value().d <<
|
||||
" (" << double (ta->value()) << ")";
|
||||
}
|
||||
else if (const TileDescriptionAttribute *ta =
|
||||
dynamic_cast <const TileDescriptionAttribute *> (a))
|
||||
{
|
||||
cout << ":\n ";
|
||||
|
||||
printLevelMode (ta->value().mode);
|
||||
|
||||
cout << "\n tile size " <<
|
||||
ta->value().xSize << " by " <<
|
||||
ta->value().ySize << " pixels";
|
||||
|
||||
if (ta->value().mode != ONE_LEVEL)
|
||||
{
|
||||
cout << "\n level sizes rounded ";
|
||||
printLevelRoundingMode (ta->value().roundingMode);
|
||||
}
|
||||
}
|
||||
else if (const TimeCodeAttribute *ta =
|
||||
dynamic_cast <const TimeCodeAttribute *> (a))
|
||||
{
|
||||
cout << ":\n";
|
||||
printTimeCode (ta->value());
|
||||
}
|
||||
else if (const V2iAttribute *ta =
|
||||
dynamic_cast <const V2iAttribute *> (a))
|
||||
{
|
||||
cout << ": " << ta->value();
|
||||
}
|
||||
else if (const V2fAttribute *ta =
|
||||
dynamic_cast <const V2fAttribute *> (a))
|
||||
{
|
||||
cout << ": " << ta->value();
|
||||
}
|
||||
else if (const V3iAttribute *ta =
|
||||
dynamic_cast <const V3iAttribute *> (a))
|
||||
{
|
||||
cout << ": " << ta->value();
|
||||
}
|
||||
else if (const V3fAttribute *ta =
|
||||
dynamic_cast <const V3fAttribute *> (a))
|
||||
{
|
||||
cout << ": " << ta->value();
|
||||
}
|
||||
|
||||
cout << '\n';
|
||||
}
|
||||
|
||||
cout << endl;
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
main(int argc, char **argv)
|
||||
{
|
||||
if (argc < 2)
|
||||
{
|
||||
std::cerr << "usage: " << argv[0] << " imagefile [imagefile ...]\n";
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
try
|
||||
{
|
||||
for (int i = 1; i < argc; ++i)
|
||||
printInfo (argv[i]);
|
||||
|
||||
return 0;
|
||||
}
|
||||
catch (const std::exception &e)
|
||||
{
|
||||
std::cerr << e.what() << std::endl;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,18 +0,0 @@
|
||||
SubDir HAIKU_TOP src add-ons translators exr openexr half ;
|
||||
|
||||
SubDirSysHdrs [ FDirName $(SUBDIR) ] ;
|
||||
|
||||
local architectureObject ;
|
||||
for architectureObject in [ MultiArchSubDirSetup ] {
|
||||
on $(architectureObject) {
|
||||
if $(TARGET_PACKAGING_ARCH) = x86_gcc2 {
|
||||
SubDirC++Flags -Dios_base=ios -ftemplate-depth-24 ;
|
||||
}
|
||||
|
||||
StaticLibrary [ MultiArchDefaultGristFiles libhalf.a ] :
|
||||
eLut.cpp
|
||||
half.cpp
|
||||
toFloat.cpp
|
||||
;
|
||||
}
|
||||
}
|
||||
@@ -1,114 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
#include <iostream>
|
||||
#include <iomanip>
|
||||
|
||||
using namespace std;
|
||||
|
||||
//-----------------------------------------------------
|
||||
// Compute a lookup table for float-to-half conversion.
|
||||
//
|
||||
// When indexed with the combined sign and exponent of
|
||||
// a float, the table either returns the combined sign
|
||||
// and exponent of the corresponding half, or zero if
|
||||
// the corresponding half may not be normalized (zero,
|
||||
// denormalized, overflow).
|
||||
//-----------------------------------------------------
|
||||
|
||||
void
|
||||
initELut (unsigned short eLut[])
|
||||
{
|
||||
for (int i = 0; i < 0x100; i++)
|
||||
{
|
||||
int e = (i & 0x0ff) - (127 - 15);
|
||||
|
||||
if (e <= 0 || e >= 30)
|
||||
{
|
||||
//
|
||||
// Special case
|
||||
//
|
||||
|
||||
eLut[i] = 0;
|
||||
eLut[i | 0x100] = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
//
|
||||
// Common case - normalized half, no exponent overflow possible
|
||||
//
|
||||
|
||||
eLut[i] = (e << 10);
|
||||
eLut[i | 0x100] = ((e << 10) | 0x8000);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//------------------------------------------------------------
|
||||
// Main - prints the sign-and-exponent conversion lookup table
|
||||
//------------------------------------------------------------
|
||||
|
||||
int
|
||||
main ()
|
||||
{
|
||||
const int tableSize = 1 << 9;
|
||||
unsigned short eLut[tableSize];
|
||||
initELut (eLut);
|
||||
|
||||
cout << "//\n"
|
||||
"// This is an automatically generated file.\n"
|
||||
"// Do not edit.\n"
|
||||
"//\n\n";
|
||||
|
||||
cout << "{\n ";
|
||||
|
||||
for (int i = 0; i < tableSize; i++)
|
||||
{
|
||||
cout << setw (5) << eLut[i] << ", ";
|
||||
|
||||
if (i % 8 == 7)
|
||||
{
|
||||
cout << "\n";
|
||||
|
||||
if (i < tableSize - 1)
|
||||
cout << " ";
|
||||
}
|
||||
}
|
||||
|
||||
cout << "};\n";
|
||||
return 0;
|
||||
}
|
||||
@@ -1,71 +0,0 @@
|
||||
//
|
||||
// This is an automatically generated file.
|
||||
// Do not edit.
|
||||
//
|
||||
|
||||
{
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 1024, 2048, 3072, 4096, 5120, 6144, 7168,
|
||||
8192, 9216, 10240, 11264, 12288, 13312, 14336, 15360,
|
||||
16384, 17408, 18432, 19456, 20480, 21504, 22528, 23552,
|
||||
24576, 25600, 26624, 27648, 28672, 29696, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 33792, 34816, 35840, 36864, 37888, 38912, 39936,
|
||||
40960, 41984, 43008, 44032, 45056, 46080, 47104, 48128,
|
||||
49152, 50176, 51200, 52224, 53248, 54272, 55296, 56320,
|
||||
57344, 58368, 59392, 60416, 61440, 62464, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
};
|
||||
@@ -1,317 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// Primary authors:
|
||||
// Florian Kainz <[email protected]>
|
||||
// Rod Bogart <[email protected]>
|
||||
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
//
|
||||
// class half --
|
||||
// implementation of non-inline members
|
||||
//
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
#include <assert.h>
|
||||
#include "half.h"
|
||||
|
||||
using namespace std;
|
||||
|
||||
//-------------------------------------------------------------
|
||||
// Lookup tables for half-to-float and float-to-half conversion
|
||||
//-------------------------------------------------------------
|
||||
|
||||
#if defined (OPENEXR_DLL)
|
||||
__declspec(dllexport) half::uif _toFloat[1 << 16] =
|
||||
#include "toFloat.h"
|
||||
__declspec(dllexport) unsigned short _eLut[1 << 9] =
|
||||
#include "eLut.h"
|
||||
#else
|
||||
const half::uif half::_toFloat[1 << 16] =
|
||||
#include "toFloat.h"
|
||||
const unsigned short half::_eLut[1 << 9] =
|
||||
#include "eLut.h"
|
||||
#endif
|
||||
|
||||
//-----------------------------------------------
|
||||
// Overflow handler for float-to-half conversion;
|
||||
// generates a hardware floating-point overflow,
|
||||
// which may be trapped by the operating system.
|
||||
//-----------------------------------------------
|
||||
|
||||
float
|
||||
half::overflow ()
|
||||
{
|
||||
volatile float f = 1e10;
|
||||
|
||||
for (int i = 0; i < 10; i++)
|
||||
f *= f; // this will overflow before
|
||||
// the forloop terminates
|
||||
return f;
|
||||
}
|
||||
|
||||
|
||||
//-----------------------------------------------------
|
||||
// Float-to-half conversion -- general case, including
|
||||
// zeroes, denormalized numbers and exponent overflows.
|
||||
//-----------------------------------------------------
|
||||
|
||||
short
|
||||
half::convert (int i)
|
||||
{
|
||||
//
|
||||
// Our floating point number, f, is represented by the bit
|
||||
// pattern in integer i. Disassemble that bit pattern into
|
||||
// the sign, s, the exponent, e, and the significand, m.
|
||||
// Shift s into the position where it will go in in the
|
||||
// resulting half number.
|
||||
// Adjust e, accounting for the different exponent bias
|
||||
// of float and half (127 versus 15).
|
||||
//
|
||||
|
||||
register int s = (i >> 16) & 0x00008000;
|
||||
register int e = ((i >> 23) & 0x000000ff) - (127 - 15);
|
||||
register int m = i & 0x007fffff;
|
||||
|
||||
//
|
||||
// Now reassemble s, e and m into a half:
|
||||
//
|
||||
|
||||
if (e <= 0)
|
||||
{
|
||||
if (e < -10)
|
||||
{
|
||||
//
|
||||
// E is less than -10. The absolute value of f is
|
||||
// less than HALF_MIN (f may be a small normalized
|
||||
// float, a denormalized float or a zero).
|
||||
//
|
||||
// We convert f to a half zero with the same sign as f.
|
||||
//
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
//
|
||||
// E is between -10 and 0. F is a normalized float
|
||||
// whose magnitude is less than HALF_NRM_MIN.
|
||||
//
|
||||
// We convert f to a denormalized half.
|
||||
//
|
||||
|
||||
//
|
||||
// Add an explicit leading 1 to the significand.
|
||||
//
|
||||
|
||||
m = m | 0x00800000;
|
||||
|
||||
//
|
||||
// Round to m to the nearest (10+e)-bit value (with e between
|
||||
// -10 and 0); in case of a tie, round to the nearest even value.
|
||||
//
|
||||
// Rounding may cause the significand to overflow and make
|
||||
// our number normalized. Because of the way a half's bits
|
||||
// are laid out, we don't have to treat this case separately;
|
||||
// the code below will handle it correctly.
|
||||
//
|
||||
|
||||
int t = 14 - e;
|
||||
int a = (1 << (t - 1)) - 1;
|
||||
int b = (m >> t) & 1;
|
||||
|
||||
m = (m + a + b) >> t;
|
||||
|
||||
//
|
||||
// Assemble the half from s, e (zero) and m.
|
||||
//
|
||||
|
||||
return s | m;
|
||||
}
|
||||
else if (e == 0xff - (127 - 15))
|
||||
{
|
||||
if (m == 0)
|
||||
{
|
||||
//
|
||||
// F is an infinity; convert f to a half
|
||||
// infinity with the same sign as f.
|
||||
//
|
||||
|
||||
return s | 0x7c00;
|
||||
}
|
||||
else
|
||||
{
|
||||
//
|
||||
// F is a NAN; we produce a half NAN that preserves
|
||||
// the sign bit and the 10 leftmost bits of the
|
||||
// significand of f, with one exception: If the 10
|
||||
// leftmost bits are all zero, the NAN would turn
|
||||
// into an infinity, so we have to set at least one
|
||||
// bit in the significand.
|
||||
//
|
||||
|
||||
m >>= 13;
|
||||
return s | 0x7c00 | m | (m == 0);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
//
|
||||
// E is greater than zero. F is a normalized float.
|
||||
// We try to convert f to a normalized half.
|
||||
//
|
||||
|
||||
//
|
||||
// Round to m to the nearest 10-bit value. In case of
|
||||
// a tie, round to the nearest even value.
|
||||
//
|
||||
|
||||
m = m + 0x00000fff + ((m >> 13) & 1);
|
||||
|
||||
if (m & 0x00800000)
|
||||
{
|
||||
m = 0; // overflow in significand,
|
||||
e += 1; // adjust exponent
|
||||
}
|
||||
|
||||
//
|
||||
// Handle exponent overflow
|
||||
//
|
||||
|
||||
if (e > 30)
|
||||
{
|
||||
overflow (); // Cause a hardware floating point overflow;
|
||||
return s | 0x7c00; // if this returns, the half becomes an
|
||||
} // infinity with the same sign as f.
|
||||
|
||||
//
|
||||
// Assemble the half from s, e and m.
|
||||
//
|
||||
|
||||
return s | (e << 10) | (m >> 13);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//---------------------
|
||||
// Stream I/O operators
|
||||
//---------------------
|
||||
|
||||
ostream &
|
||||
operator << (ostream &os, half h)
|
||||
{
|
||||
os << float (h);
|
||||
return os;
|
||||
}
|
||||
|
||||
|
||||
istream &
|
||||
operator >> (istream &is, half &h)
|
||||
{
|
||||
float f;
|
||||
is >> f;
|
||||
h = half (f);
|
||||
return is;
|
||||
}
|
||||
|
||||
|
||||
//---------------------------------------
|
||||
// Functions to print the bit-layout of
|
||||
// floats and halfs, mostly for debugging
|
||||
//---------------------------------------
|
||||
|
||||
void
|
||||
printBits (ostream &os, half h)
|
||||
{
|
||||
unsigned short b = h.bits();
|
||||
|
||||
for (int i = 15; i >= 0; i--)
|
||||
{
|
||||
os << (((b >> i) & 1)? '1': '0');
|
||||
|
||||
if (i == 15 || i == 10)
|
||||
os << ' ';
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
printBits (ostream &os, float f)
|
||||
{
|
||||
half::uif x;
|
||||
x.f = f;
|
||||
|
||||
for (int i = 31; i >= 0; i--)
|
||||
{
|
||||
os << (((x.i >> i) & 1)? '1': '0');
|
||||
|
||||
if (i == 31 || i == 23)
|
||||
os << ' ';
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
printBits (char c[19], half h)
|
||||
{
|
||||
unsigned short b = h.bits();
|
||||
|
||||
for (int i = 15, j = 0; i >= 0; i--, j++)
|
||||
{
|
||||
c[j] = (((b >> i) & 1)? '1': '0');
|
||||
|
||||
if (i == 15 || i == 10)
|
||||
c[++j] = ' ';
|
||||
}
|
||||
|
||||
c[18] = 0;
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
printBits (char c[35], float f)
|
||||
{
|
||||
half::uif x;
|
||||
x.f = f;
|
||||
|
||||
for (int i = 31, j = 0; i >= 0; i--, j++)
|
||||
{
|
||||
c[j] = (((x.i >> i) & 1)? '1': '0');
|
||||
|
||||
if (i == 31 || i == 23)
|
||||
c[++j] = ' ';
|
||||
}
|
||||
|
||||
c[34] = 0;
|
||||
}
|
||||
@@ -1,776 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// Primary authors:
|
||||
// Florian Kainz <[email protected]>
|
||||
// Rod Bogart <[email protected]>
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
//
|
||||
// half -- a 16-bit floating point number class:
|
||||
//
|
||||
// Type half can represent positive and negative numbers whose
|
||||
// magnitude is between roughly 6.1e-5 and 6.5e+4 with a relative
|
||||
// error of 9.8e-4; numbers smaller than 6.1e-5 can be represented
|
||||
// with an absolute error of 6.0e-8. All integers from -2048 to
|
||||
// +2048 can be represented exactly.
|
||||
//
|
||||
// Type half behaves (almost) like the built-in C++ floating point
|
||||
// types. In arithmetic expressions, half, float and double can be
|
||||
// mixed freely. Here are a few examples:
|
||||
//
|
||||
// half a (3.5);
|
||||
// float b (a + sqrt (a));
|
||||
// a += b;
|
||||
// b += a;
|
||||
// b = a + 7;
|
||||
//
|
||||
// Conversions from half to float are lossless; all half numbers
|
||||
// are exactly representable as floats.
|
||||
//
|
||||
// Conversions from float to half may not preserve the float's
|
||||
// value exactly. If a float is not representable as a half, the
|
||||
// float value is rounded to the nearest representable half. If
|
||||
// a float value is exactly in the middle between the two closest
|
||||
// representable half values, then the float value is rounded to
|
||||
// the half with the greater magnitude.
|
||||
//
|
||||
// Overflows during float-to-half conversions cause arithmetic
|
||||
// exceptions. An overflow occurs when the float value to be
|
||||
// converted is too large to be represented as a half, or if the
|
||||
// float value is an infinity or a NAN.
|
||||
//
|
||||
// The implementation of type half makes the following assumptions
|
||||
// about the implementation of the built-in C++ types:
|
||||
//
|
||||
// float is an IEEE 754 single-precision number
|
||||
// sizeof (float) == 4
|
||||
// sizeof (unsigned int) == sizeof (float)
|
||||
// alignof (unsigned int) == alignof (float)
|
||||
// sizeof (unsigned short) == 2
|
||||
//
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
#ifndef _HALF_H_
|
||||
#define _HALF_H_
|
||||
|
||||
#include <iostream>
|
||||
|
||||
class half
|
||||
{
|
||||
public:
|
||||
|
||||
//-------------
|
||||
// Constructors
|
||||
//-------------
|
||||
|
||||
half (); // no initialization
|
||||
half (float f);
|
||||
|
||||
|
||||
//--------------------
|
||||
// Conversion to float
|
||||
//--------------------
|
||||
|
||||
operator float () const;
|
||||
|
||||
|
||||
//------------
|
||||
// Unary minus
|
||||
//------------
|
||||
|
||||
half operator - () const;
|
||||
|
||||
|
||||
//-----------
|
||||
// Assignment
|
||||
//-----------
|
||||
|
||||
half & operator = (half h);
|
||||
half & operator = (float f);
|
||||
|
||||
half & operator += (half h);
|
||||
half & operator += (float f);
|
||||
|
||||
half & operator -= (half h);
|
||||
half & operator -= (float f);
|
||||
|
||||
half & operator *= (half h);
|
||||
half & operator *= (float f);
|
||||
|
||||
half & operator /= (half h);
|
||||
half & operator /= (float f);
|
||||
|
||||
|
||||
//---------------------------------------------------------
|
||||
// Round to n-bit precision (n should be between 0 and 10).
|
||||
// After rounding, the significand's 10-n least significant
|
||||
// bits will be zero.
|
||||
//---------------------------------------------------------
|
||||
|
||||
half round (unsigned int n) const;
|
||||
|
||||
|
||||
//--------------------------------------------------------------------
|
||||
// Classification:
|
||||
//
|
||||
// h.isFinite() returns true if h is a normalized number,
|
||||
// a denormalized number or zero
|
||||
//
|
||||
// h.isNormalized() returns true if h is a normalized number
|
||||
//
|
||||
// h.isDenormalized() returns true if h is a denormalized number
|
||||
//
|
||||
// h.isZero() returns true if h is zero
|
||||
//
|
||||
// h.isNan() returns true if h is a NAN
|
||||
//
|
||||
// h.isInfinity() returns true if h is a positive
|
||||
// or a negative infinity
|
||||
//
|
||||
// h.isNegative() returns true if the sign bit of h
|
||||
// is set (negative)
|
||||
//--------------------------------------------------------------------
|
||||
|
||||
bool isFinite () const;
|
||||
bool isNormalized () const;
|
||||
bool isDenormalized () const;
|
||||
bool isZero () const;
|
||||
bool isNan () const;
|
||||
bool isInfinity () const;
|
||||
bool isNegative () const;
|
||||
|
||||
|
||||
//--------------------------------------------
|
||||
// Special values
|
||||
//
|
||||
// posInf() returns +infinity
|
||||
//
|
||||
// negInf() returns -infinity
|
||||
//
|
||||
// qNan() returns a NAN with the bit
|
||||
// pattern 0111111111111111
|
||||
//
|
||||
// sNan() returns a NAN with the bit
|
||||
// pattern 0111110111111111
|
||||
//--------------------------------------------
|
||||
|
||||
static half posInf ();
|
||||
static half negInf ();
|
||||
static half qNan ();
|
||||
static half sNan ();
|
||||
|
||||
|
||||
//--------------------------------------
|
||||
// Access to the internal representation
|
||||
//--------------------------------------
|
||||
|
||||
unsigned short bits () const;
|
||||
void setBits (unsigned short bits);
|
||||
|
||||
|
||||
public:
|
||||
|
||||
union uif
|
||||
{
|
||||
unsigned int i;
|
||||
float f;
|
||||
};
|
||||
|
||||
private:
|
||||
|
||||
static short convert (int i);
|
||||
static float overflow ();
|
||||
|
||||
unsigned short _h;
|
||||
|
||||
//---------------------------------------------------
|
||||
// Windows dynamic libraries don't like static
|
||||
// member variables.
|
||||
//---------------------------------------------------
|
||||
#ifndef OPENEXR_DLL
|
||||
static const uif _toFloat[1 << 16];
|
||||
static const unsigned short _eLut[1 << 9];
|
||||
#endif
|
||||
};
|
||||
|
||||
#if defined(OPENEXR_DLL)
|
||||
//--------------------------------------
|
||||
// Lookup tables defined for Windows DLL
|
||||
//--------------------------------------
|
||||
#if defined(HALF_EXPORTS)
|
||||
extern __declspec(dllexport) half::uif _toFloat[1 << 16];
|
||||
extern __declspec(dllexport) unsigned short _eLut[1 << 9];
|
||||
#else
|
||||
extern __declspec(dllimport) half::uif _toFloat[1 << 16];
|
||||
extern __declspec(dllimport) unsigned short _eLut[1 << 9];
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
//-----------
|
||||
// Stream I/O
|
||||
//-----------
|
||||
|
||||
std::ostream & operator << (std::ostream &os, half h);
|
||||
std::istream & operator >> (std::istream &is, half &h);
|
||||
|
||||
|
||||
//----------
|
||||
// Debugging
|
||||
//----------
|
||||
|
||||
void printBits (std::ostream &os, half h);
|
||||
void printBits (std::ostream &os, float f);
|
||||
void printBits (char c[19], half h);
|
||||
void printBits (char c[35], float f);
|
||||
|
||||
|
||||
//-------------------------------------------------------------------------
|
||||
// Limits
|
||||
//
|
||||
// Visual C++ will complain if HALF_MIN, HALF_NRM_MIN etc. are not float
|
||||
// constants, but at least one other compiler (gcc 2.96) produces incorrect
|
||||
// results if they are.
|
||||
//-------------------------------------------------------------------------
|
||||
|
||||
#if (defined _WIN32 || defined _WIN64) && defined _MSC_VER
|
||||
|
||||
#define HALF_MIN 5.96046448e-08f // Smallest positive half
|
||||
|
||||
#define HALF_NRM_MIN 6.10351562e-05f // Smallest positive normalized half
|
||||
|
||||
#define HALF_MAX 65504.0f // Largest positive half
|
||||
|
||||
#define HALF_EPSILON 0.00097656f // Smallest positive e for which
|
||||
// half (1.0 + e) != half (1.0)
|
||||
#else
|
||||
|
||||
#define HALF_MIN 5.96046448e-08 // Smallest positive half
|
||||
|
||||
#define HALF_NRM_MIN 6.10351562e-05 // Smallest positive normalized half
|
||||
|
||||
#define HALF_MAX 65504.0 // Largest positive half
|
||||
|
||||
#define HALF_EPSILON 0.00097656 // Smallest positive e for which
|
||||
// half (1.0 + e) != half (1.0)
|
||||
#endif
|
||||
|
||||
|
||||
#define HALF_MANT_DIG 11 // Number of digits in mantissa
|
||||
// (significand + hidden leading 1)
|
||||
|
||||
#define HALF_DIG 2 // Number of base 10 digits that
|
||||
// can be represented without change
|
||||
|
||||
#define HALF_RADIX 2 // Base of the exponent
|
||||
|
||||
#define HALF_MIN_EXP -13 // Minimum negative integer such that
|
||||
// HALF_RADIX raised to the power of
|
||||
// one less than that integer is a
|
||||
// normalized half
|
||||
|
||||
#define HALF_MAX_EXP 16 // Maximum positive integer such that
|
||||
// HALF_RADIX raised to the power of
|
||||
// one less than that integer is a
|
||||
// normalized half
|
||||
|
||||
#define HALF_MIN_10_EXP -4 // Minimum positive integer such
|
||||
// that 10 raised to that power is
|
||||
// a normalized half
|
||||
|
||||
#define HALF_MAX_10_EXP 4 // Maximum positive integer such
|
||||
// that 10 raised to that power is
|
||||
// a normalized half
|
||||
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
//
|
||||
// Implementation --
|
||||
//
|
||||
// Representation of a float:
|
||||
//
|
||||
// We assume that a float, f, is an IEEE 754 single-precision
|
||||
// floating point number, whose bits are arranged as follows:
|
||||
//
|
||||
// 31 (msb)
|
||||
// |
|
||||
// | 30 23
|
||||
// | | |
|
||||
// | | | 22 0 (lsb)
|
||||
// | | | | |
|
||||
// X XXXXXXXX XXXXXXXXXXXXXXXXXXXXXXX
|
||||
//
|
||||
// s e m
|
||||
//
|
||||
// S is the sign-bit, e is the exponent and m is the significand.
|
||||
//
|
||||
// If e is between 1 and 254, f is a normalized number:
|
||||
//
|
||||
// s e-127
|
||||
// f = (-1) * 2 * 1.m
|
||||
//
|
||||
// If e is 0, and m is not zero, f is a denormalized number:
|
||||
//
|
||||
// s -126
|
||||
// f = (-1) * 2 * 0.m
|
||||
//
|
||||
// If e and m are both zero, f is zero:
|
||||
//
|
||||
// f = 0.0
|
||||
//
|
||||
// If e is 255, f is an "infinity" or "not a number" (NAN),
|
||||
// depending on whether m is zero or not.
|
||||
//
|
||||
// Examples:
|
||||
//
|
||||
// 0 00000000 00000000000000000000000 = 0.0
|
||||
// 0 01111110 00000000000000000000000 = 0.5
|
||||
// 0 01111111 00000000000000000000000 = 1.0
|
||||
// 0 10000000 00000000000000000000000 = 2.0
|
||||
// 0 10000000 10000000000000000000000 = 3.0
|
||||
// 1 10000101 11110000010000000000000 = -124.0625
|
||||
// 0 11111111 00000000000000000000000 = +infinity
|
||||
// 1 11111111 00000000000000000000000 = -infinity
|
||||
// 0 11111111 10000000000000000000000 = NAN
|
||||
// 1 11111111 11111111111111111111111 = NAN
|
||||
//
|
||||
// Representation of a half:
|
||||
//
|
||||
// Here is the bit-layout for a half number, h:
|
||||
//
|
||||
// 15 (msb)
|
||||
// |
|
||||
// | 14 10
|
||||
// | | |
|
||||
// | | | 9 0 (lsb)
|
||||
// | | | | |
|
||||
// X XXXXX XXXXXXXXXX
|
||||
//
|
||||
// s e m
|
||||
//
|
||||
// S is the sign-bit, e is the exponent and m is the significand.
|
||||
//
|
||||
// If e is between 1 and 30, h is a normalized number:
|
||||
//
|
||||
// s e-15
|
||||
// h = (-1) * 2 * 1.m
|
||||
//
|
||||
// If e is 0, and m is not zero, h is a denormalized number:
|
||||
//
|
||||
// S -14
|
||||
// h = (-1) * 2 * 0.m
|
||||
//
|
||||
// If e and m are both zero, h is zero:
|
||||
//
|
||||
// h = 0.0
|
||||
//
|
||||
// If e is 31, h is an "infinity" or "not a number" (NAN),
|
||||
// depending on whether m is zero or not.
|
||||
//
|
||||
// Examples:
|
||||
//
|
||||
// 0 00000 0000000000 = 0.0
|
||||
// 0 01110 0000000000 = 0.5
|
||||
// 0 01111 0000000000 = 1.0
|
||||
// 0 10000 0000000000 = 2.0
|
||||
// 0 10000 1000000000 = 3.0
|
||||
// 1 10101 1111000001 = -124.0625
|
||||
// 0 11111 0000000000 = +infinity
|
||||
// 1 11111 0000000000 = -infinity
|
||||
// 0 11111 1000000000 = NAN
|
||||
// 1 11111 1111111111 = NAN
|
||||
//
|
||||
// Conversion:
|
||||
//
|
||||
// Converting from a float to a half requires some non-trivial bit
|
||||
// manipulations. In some cases, this makes conversion relatively
|
||||
// slow, but the most common case is accelerated via table lookups.
|
||||
//
|
||||
// Converting back from a half to a float is easier because we don't
|
||||
// have to do any rounding. In addition, there are only 65536
|
||||
// different half numbers; we can convert each of those numbers once
|
||||
// and store the results in a table. Later, all conversions can be
|
||||
// done using only simple table lookups.
|
||||
//
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
|
||||
//--------------------
|
||||
// Simple constructors
|
||||
//--------------------
|
||||
|
||||
inline
|
||||
half::half ()
|
||||
{
|
||||
// no initialization
|
||||
}
|
||||
|
||||
|
||||
//----------------------------
|
||||
// Half-from-float constructor
|
||||
//----------------------------
|
||||
|
||||
inline
|
||||
half::half (float f)
|
||||
{
|
||||
uif x;
|
||||
|
||||
x.f = f;
|
||||
|
||||
if (f == 0)
|
||||
{
|
||||
//
|
||||
// Common special case - zero.
|
||||
// Preserve the zero's sign bit.
|
||||
//
|
||||
|
||||
_h = (x.i >> 16);
|
||||
}
|
||||
else
|
||||
{
|
||||
//
|
||||
// We extract the combined sign and exponent, e, from our
|
||||
// floating-point number, f. Then we convert e to the sign
|
||||
// and exponent of the half number via a table lookup.
|
||||
//
|
||||
// For the most common case, where a normalized half is produced,
|
||||
// the table lookup returns a non-zero value; in this case, all
|
||||
// we have to do is round f's significand to 10 bits and combine
|
||||
// the result with e.
|
||||
//
|
||||
// For all other cases (overflow, zeroes, denormalized numbers
|
||||
// resulting from underflow, infinities and NANs), the table
|
||||
// lookup returns zero, and we call a longer, non-inline function
|
||||
// to do the float-to-half conversion.
|
||||
//
|
||||
|
||||
register int e = (x.i >> 23) & 0x000001ff;
|
||||
|
||||
e = _eLut[e];
|
||||
|
||||
if (e)
|
||||
{
|
||||
//
|
||||
// Simple case - round the significand, m, to 10
|
||||
// bits and combine it with the sign and exponent.
|
||||
//
|
||||
|
||||
register int m = x.i & 0x007fffff;
|
||||
_h = e + ((m + 0x00000fff + ((m >> 13) & 1)) >> 13);
|
||||
}
|
||||
else
|
||||
{
|
||||
//
|
||||
// Difficult case - call a function.
|
||||
//
|
||||
|
||||
_h = convert (x.i);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//------------------------------------------
|
||||
// Half-to-float conversion via table lookup
|
||||
//------------------------------------------
|
||||
|
||||
inline
|
||||
half::operator float () const
|
||||
{
|
||||
return _toFloat[_h].f;
|
||||
}
|
||||
|
||||
|
||||
//-------------------------
|
||||
// Round to n-bit precision
|
||||
//-------------------------
|
||||
|
||||
inline half
|
||||
half::round (unsigned int n) const
|
||||
{
|
||||
//
|
||||
// Parameter check.
|
||||
//
|
||||
|
||||
if (n >= 10)
|
||||
return *this;
|
||||
|
||||
//
|
||||
// Disassemble h into the sign, s,
|
||||
// and the combined exponent and significand, e.
|
||||
//
|
||||
|
||||
unsigned short s = _h & 0x8000;
|
||||
unsigned short e = _h & 0x7fff;
|
||||
|
||||
//
|
||||
// Round the exponent and significand to the nearest value
|
||||
// where ones occur only in the (10-n) most significant bits.
|
||||
// Note that the exponent adjusts automatically if rounding
|
||||
// up causes the significand to overflow.
|
||||
//
|
||||
|
||||
e >>= 9 - n;
|
||||
e += e & 1;
|
||||
e <<= 9 - n;
|
||||
|
||||
//
|
||||
// Check for exponent overflow.
|
||||
//
|
||||
|
||||
if (e >= 0x7c00)
|
||||
{
|
||||
//
|
||||
// Overflow occurred -- truncate instead of rounding.
|
||||
//
|
||||
|
||||
e = _h;
|
||||
e >>= 10 - n;
|
||||
e <<= 10 - n;
|
||||
}
|
||||
|
||||
//
|
||||
// Put the original sign bit back.
|
||||
//
|
||||
|
||||
half h;
|
||||
h._h = s | e;
|
||||
|
||||
return h;
|
||||
}
|
||||
|
||||
|
||||
//-----------------------
|
||||
// Other inline functions
|
||||
//-----------------------
|
||||
|
||||
inline half
|
||||
half::operator - () const
|
||||
{
|
||||
half h;
|
||||
h._h = _h ^ 0x8000;
|
||||
return h;
|
||||
}
|
||||
|
||||
|
||||
inline half &
|
||||
half::operator = (half h)
|
||||
{
|
||||
_h = h._h;
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
inline half &
|
||||
half::operator = (float f)
|
||||
{
|
||||
*this = half (f);
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
inline half &
|
||||
half::operator += (half h)
|
||||
{
|
||||
*this = half (float (*this) + float (h));
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
inline half &
|
||||
half::operator += (float f)
|
||||
{
|
||||
*this = half (float (*this) + f);
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
inline half &
|
||||
half::operator -= (half h)
|
||||
{
|
||||
*this = half (float (*this) - float (h));
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
inline half &
|
||||
half::operator -= (float f)
|
||||
{
|
||||
*this = half (float (*this) - f);
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
inline half &
|
||||
half::operator *= (half h)
|
||||
{
|
||||
*this = half (float (*this) * float (h));
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
inline half &
|
||||
half::operator *= (float f)
|
||||
{
|
||||
*this = half (float (*this) * f);
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
inline half &
|
||||
half::operator /= (half h)
|
||||
{
|
||||
*this = half (float (*this) / float (h));
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
inline half &
|
||||
half::operator /= (float f)
|
||||
{
|
||||
*this = half (float (*this) / f);
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
inline bool
|
||||
half::isFinite () const
|
||||
{
|
||||
unsigned short e = (_h >> 10) & 0x001f;
|
||||
return e < 31;
|
||||
}
|
||||
|
||||
|
||||
inline bool
|
||||
half::isNormalized () const
|
||||
{
|
||||
unsigned short e = (_h >> 10) & 0x001f;
|
||||
return e > 0 && e < 31;
|
||||
}
|
||||
|
||||
|
||||
inline bool
|
||||
half::isDenormalized () const
|
||||
{
|
||||
unsigned short e = (_h >> 10) & 0x001f;
|
||||
unsigned short m = _h & 0x3ff;
|
||||
return e == 0 && m != 0;
|
||||
}
|
||||
|
||||
|
||||
inline bool
|
||||
half::isZero () const
|
||||
{
|
||||
return (_h & 0x7fff) == 0;
|
||||
}
|
||||
|
||||
|
||||
inline bool
|
||||
half::isNan () const
|
||||
{
|
||||
unsigned short e = (_h >> 10) & 0x001f;
|
||||
unsigned short m = _h & 0x3ff;
|
||||
return e == 31 && m != 0;
|
||||
}
|
||||
|
||||
|
||||
inline bool
|
||||
half::isInfinity () const
|
||||
{
|
||||
unsigned short e = (_h >> 10) & 0x001f;
|
||||
unsigned short m = _h & 0x3ff;
|
||||
return e == 31 && m == 0;
|
||||
}
|
||||
|
||||
|
||||
inline bool
|
||||
half::isNegative () const
|
||||
{
|
||||
return (_h & 0x8000) != 0;
|
||||
}
|
||||
|
||||
|
||||
inline half
|
||||
half::posInf ()
|
||||
{
|
||||
half h;
|
||||
h._h = 0x7c00;
|
||||
return h;
|
||||
}
|
||||
|
||||
|
||||
inline half
|
||||
half::negInf ()
|
||||
{
|
||||
half h;
|
||||
h._h = 0xfc00;
|
||||
return h;
|
||||
}
|
||||
|
||||
|
||||
inline half
|
||||
half::qNan ()
|
||||
{
|
||||
half h;
|
||||
h._h = 0x7fff;
|
||||
return h;
|
||||
}
|
||||
|
||||
|
||||
inline half
|
||||
half::sNan ()
|
||||
{
|
||||
half h;
|
||||
h._h = 0x7dff;
|
||||
return h;
|
||||
}
|
||||
|
||||
|
||||
inline unsigned short
|
||||
half::bits () const
|
||||
{
|
||||
return _h;
|
||||
}
|
||||
|
||||
|
||||
inline void
|
||||
half::setBits (unsigned short bits)
|
||||
{
|
||||
_h = bits;
|
||||
}
|
||||
|
||||
#undef HALF_EXPORT_CONST
|
||||
|
||||
#endif
|
||||
@@ -1,159 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// Primary authors:
|
||||
// Florian Kainz <[email protected]>
|
||||
// Rod Bogart <[email protected]>
|
||||
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
//
|
||||
// halfFunction<T> -- a class for fast evaluation
|
||||
// of half --> T functions
|
||||
//
|
||||
// The constructor for a halfFunction object,
|
||||
//
|
||||
// halfFunction (function,
|
||||
// domainMin, domainMax,
|
||||
// defaultValue,
|
||||
// posInfValue, negInfValue,
|
||||
// nanValue);
|
||||
//
|
||||
// evaluates the function for all finite half values in the interval
|
||||
// [domainMin, domainMax], and stores the results in a lookup table.
|
||||
// For finite half values that are not in [domainMin, domainMax], the
|
||||
// constructor stores defaultValue in the table. For positive infinity,
|
||||
// negative infinity and NANs, posInfValue, negInfValue and nanValue
|
||||
// are stored in the table.
|
||||
//
|
||||
// The tabulated function can then be evaluated quickly for arbitrary
|
||||
// half values by calling the the halfFunction object's operator()
|
||||
// method.
|
||||
//
|
||||
// Example:
|
||||
//
|
||||
// #include <math.h>
|
||||
// #include <halfFunction.h>
|
||||
//
|
||||
// halfFunction<half> hsin (sin);
|
||||
//
|
||||
// halfFunction<half> hsqrt (sqrt, // function
|
||||
// 0, HALF_MAX, // domain
|
||||
// half::qNan(), // sqrt(x) for x < 0
|
||||
// half::posInf(), // sqrt(+inf)
|
||||
// half::qNan(), // sqrt(-inf)
|
||||
// half::qNan()); // sqrt(nan)
|
||||
//
|
||||
// half x = hsin (1);
|
||||
// half y = hsqrt (3.5);
|
||||
//
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
#ifndef _HALF_FUNCTION_H_
|
||||
#define _HALF_FUNCTION_H_
|
||||
|
||||
#include <float.h>
|
||||
#include "half.h"
|
||||
|
||||
|
||||
template <class T>
|
||||
class halfFunction
|
||||
{
|
||||
public:
|
||||
|
||||
//------------
|
||||
// Constructor
|
||||
//------------
|
||||
|
||||
template <class Function>
|
||||
halfFunction (Function f,
|
||||
half domainMin = -HALF_MAX,
|
||||
half domainMax = HALF_MAX,
|
||||
T defaultValue = 0,
|
||||
T posInfValue = 0,
|
||||
T negInfValue = 0,
|
||||
T nanValue = 0);
|
||||
|
||||
//-----------
|
||||
// Evaluation
|
||||
//-----------
|
||||
|
||||
T operator () (half x) const;
|
||||
|
||||
private:
|
||||
|
||||
T _lut[1 << 16];
|
||||
};
|
||||
|
||||
|
||||
//---------------
|
||||
// Implementation
|
||||
//---------------
|
||||
|
||||
template <class T>
|
||||
template <class Function>
|
||||
halfFunction<T>::halfFunction (Function f,
|
||||
half domainMin,
|
||||
half domainMax,
|
||||
T defaultValue,
|
||||
T posInfValue,
|
||||
T negInfValue,
|
||||
T nanValue)
|
||||
{
|
||||
for (int i = 0; i < (1 << 16); i++)
|
||||
{
|
||||
half x;
|
||||
x.setBits (i);
|
||||
|
||||
if (x.isNan())
|
||||
_lut[i] = nanValue;
|
||||
else if (x.isInfinity())
|
||||
_lut[i] = x.isNegative()? negInfValue: posInfValue;
|
||||
else if (x < domainMin || x > domainMax)
|
||||
_lut[i] = defaultValue;
|
||||
else
|
||||
_lut[i] = f (x);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
inline T
|
||||
halfFunction<T>::operator () (half x) const
|
||||
{
|
||||
return _lut[x.bits()];
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
@@ -1,102 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
// Primary authors:
|
||||
// Florian Kainz <[email protected]>
|
||||
// Rod Bogart <[email protected]>
|
||||
|
||||
|
||||
#ifndef INCLUDED_HALF_LIMITS_H
|
||||
#define INCLUDED_HALF_LIMITS_H
|
||||
|
||||
|
||||
//------------------------------------------------------------------------
|
||||
//
|
||||
// C++ standard library-style numeric_limits for class half
|
||||
//
|
||||
//------------------------------------------------------------------------
|
||||
|
||||
#include <limits>
|
||||
#include "half.h"
|
||||
|
||||
namespace std {
|
||||
|
||||
template <>
|
||||
class numeric_limits <half>
|
||||
{
|
||||
public:
|
||||
|
||||
static const bool is_specialized = true;
|
||||
|
||||
static half min () throw () {return HALF_NRM_MIN;}
|
||||
static half max () throw () {return HALF_MAX;}
|
||||
|
||||
static const int digits = HALF_MANT_DIG;
|
||||
static const int digits10 = HALF_DIG;
|
||||
static const bool is_signed = true;
|
||||
static const bool is_integer = false;
|
||||
static const bool is_exact = false;
|
||||
static const int radix = HALF_RADIX;
|
||||
static half epsilon () throw () {return HALF_EPSILON;}
|
||||
static half round_error () throw () {return HALF_EPSILON / 2;}
|
||||
|
||||
static const int min_exponent = HALF_MIN_EXP;
|
||||
static const int min_exponent10 = HALF_MIN_10_EXP;
|
||||
static const int max_exponent = HALF_MAX_EXP;
|
||||
static const int max_exponent10 = HALF_MAX_10_EXP;
|
||||
|
||||
static const bool has_infinity = true;
|
||||
static const bool has_quiet_NaN = true;
|
||||
static const bool has_signaling_NaN = true;
|
||||
static const float_denorm_style has_denorm = denorm_present;
|
||||
static const bool has_denorm_loss = false;
|
||||
static half infinity () throw () {return half::posInf();}
|
||||
static half quiet_NaN () throw () {return half::qNan();}
|
||||
static half signaling_NaN () throw () {return half::sNan();}
|
||||
static half denorm_min () throw () {return HALF_MIN;}
|
||||
|
||||
static const bool is_iec559 = false;
|
||||
static const bool is_bounded = false;
|
||||
static const bool is_modulo = false;
|
||||
|
||||
static const bool traps = true;
|
||||
static const bool tinyness_before = false;
|
||||
static const float_round_style round_style = round_to_nearest;
|
||||
};
|
||||
|
||||
|
||||
} // namespace std
|
||||
|
||||
#endif
|
||||
@@ -1,164 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
//
|
||||
// toFloat
|
||||
//
|
||||
// A program to generate the lookup table for half-to-float
|
||||
// conversion needed by class half.
|
||||
// The program loops over all 65536 possible half numbers,
|
||||
// converts each of them to a float, and prints the result.
|
||||
//
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
|
||||
#include <iostream>
|
||||
#include <iomanip>
|
||||
|
||||
using namespace std;
|
||||
|
||||
//---------------------------------------------------
|
||||
// Interpret an unsigned short bit pattern as a half,
|
||||
// and convert that half to the corresponding float's
|
||||
// bit pattern.
|
||||
//---------------------------------------------------
|
||||
|
||||
unsigned int
|
||||
halfToFloat (unsigned short y)
|
||||
{
|
||||
|
||||
int s = (y >> 15) & 0x00000001;
|
||||
int e = (y >> 10) & 0x0000001f;
|
||||
int m = y & 0x000003ff;
|
||||
|
||||
if (e == 0)
|
||||
{
|
||||
if (m == 0)
|
||||
{
|
||||
//
|
||||
// Plus or minus zero
|
||||
//
|
||||
|
||||
return s << 31;
|
||||
}
|
||||
else
|
||||
{
|
||||
//
|
||||
// Denormalized number -- renormalize it
|
||||
//
|
||||
|
||||
while (!(m & 0x00000400))
|
||||
{
|
||||
m <<= 1;
|
||||
e -= 1;
|
||||
}
|
||||
|
||||
e += 1;
|
||||
m &= ~0x00000400;
|
||||
}
|
||||
}
|
||||
else if (e == 31)
|
||||
{
|
||||
if (m == 0)
|
||||
{
|
||||
//
|
||||
// Positive or negative infinity
|
||||
//
|
||||
|
||||
return (s << 31) | 0x7f800000;
|
||||
}
|
||||
else
|
||||
{
|
||||
//
|
||||
// Nan -- preserve sign and significand bits
|
||||
//
|
||||
|
||||
return (s << 31) | 0x7f800000 | (m << 13);
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// Normalized number
|
||||
//
|
||||
|
||||
e = e + (127 - 15);
|
||||
m = m << 13;
|
||||
|
||||
//
|
||||
// Assemble s, e and m.
|
||||
//
|
||||
|
||||
return (s << 31) | (e << 23) | m;
|
||||
}
|
||||
|
||||
|
||||
//---------------------------------------------
|
||||
// Main - prints the half-to-float lookup table
|
||||
//---------------------------------------------
|
||||
|
||||
int
|
||||
main ()
|
||||
{
|
||||
cout.precision (9);
|
||||
cout.setf (ios_base::hex, ios_base::basefield);
|
||||
|
||||
cout << "//\n"
|
||||
"// This is an automatically generated file.\n"
|
||||
"// Do not edit.\n"
|
||||
"//\n\n";
|
||||
|
||||
cout << "{\n ";
|
||||
|
||||
const int iMax = (1 << 16);
|
||||
|
||||
for (int i = 0; i < iMax; i++)
|
||||
{
|
||||
cout << "{0x" << setfill ('0') << setw (8) << halfToFloat (i) << "}, ";
|
||||
|
||||
if (i % 4 == 3)
|
||||
{
|
||||
cout << "\n";
|
||||
|
||||
if (i < iMax - 1)
|
||||
cout << " ";
|
||||
}
|
||||
}
|
||||
|
||||
cout << "};\n";
|
||||
return 0;
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,60 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
#ifndef INCLUDED_IEX_H
|
||||
#define INCLUDED_IEX_H
|
||||
|
||||
|
||||
//--------------------------------
|
||||
//
|
||||
// Exception handling
|
||||
//
|
||||
//--------------------------------
|
||||
|
||||
|
||||
#include "IexMacros.h"
|
||||
#include "IexBaseExc.h"
|
||||
#include "IexMathExc.h"
|
||||
#include "IexThrowErrnoExc.h"
|
||||
|
||||
// Note that we do not include file IexErrnoExc.h here. That file
|
||||
// defines over 150 classes and significantly slows down compilation.
|
||||
// If you throw ErrnoExc exceptions using the throwErrnoExc() function,
|
||||
// you don't need IexErrnoExc.h. You have to include IexErrnoExc.h
|
||||
// only if you want to catch specific subclasses of ErrnoExc.
|
||||
|
||||
|
||||
#endif
|
||||
@@ -1,129 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
//
|
||||
// Constructors and destructors for our exception base class.
|
||||
//
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
#include "IexBaseExc.h"
|
||||
|
||||
namespace Iex {
|
||||
namespace {
|
||||
|
||||
|
||||
StackTracer currentStackTracer = 0;
|
||||
|
||||
|
||||
} // namespace
|
||||
|
||||
|
||||
void
|
||||
setStackTracer (StackTracer stackTracer)
|
||||
{
|
||||
currentStackTracer = stackTracer;
|
||||
}
|
||||
|
||||
|
||||
StackTracer
|
||||
stackTracer ()
|
||||
{
|
||||
return currentStackTracer;
|
||||
}
|
||||
|
||||
|
||||
BaseExc::BaseExc (const char* s) throw () :
|
||||
std::string (s? s: ""),
|
||||
_stackTrace (currentStackTracer? currentStackTracer(): "")
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
|
||||
BaseExc::BaseExc (const std::string &s) throw () :
|
||||
std::string (s),
|
||||
_stackTrace (currentStackTracer? currentStackTracer(): "")
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
|
||||
BaseExc::BaseExc (std::stringstream &s) throw () :
|
||||
std::string (s.str()),
|
||||
_stackTrace (currentStackTracer? currentStackTracer(): "")
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
|
||||
BaseExc::BaseExc (const BaseExc &be) throw () :
|
||||
std::string (be),
|
||||
_stackTrace (be._stackTrace)
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
|
||||
BaseExc::~BaseExc () throw ()
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
|
||||
const char *
|
||||
BaseExc::what () const throw ()
|
||||
{
|
||||
return c_str();
|
||||
}
|
||||
|
||||
|
||||
BaseExc &
|
||||
BaseExc::assign (std::stringstream &s)
|
||||
{
|
||||
std::string::assign (s.str());
|
||||
return *this;
|
||||
}
|
||||
|
||||
BaseExc &
|
||||
BaseExc::append (std::stringstream &s)
|
||||
{
|
||||
std::string::append (s.str());
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
} // namespace Iex
|
||||
@@ -1,266 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
#ifndef INCLUDED_IEXBASEEXC_H
|
||||
#define INCLUDED_IEXBASEEXC_H
|
||||
|
||||
|
||||
//----------------------------------------------------------
|
||||
//
|
||||
// A general exception base class, and a few
|
||||
// useful exceptions derived from the base class.
|
||||
//
|
||||
//----------------------------------------------------------
|
||||
|
||||
#include <string>
|
||||
#include <exception>
|
||||
#include <sstream>
|
||||
|
||||
namespace Iex {
|
||||
|
||||
#if (defined _WIN32 || defined _WIN64) && defined _MSC_VER
|
||||
// Tell MS VC++ to suppress exception specification warnings
|
||||
#pragma warning(disable:4290)
|
||||
#endif
|
||||
|
||||
//-------------------------------
|
||||
// Our most basic exception class
|
||||
//-------------------------------
|
||||
|
||||
class BaseExc: public std::string, public std::exception
|
||||
{
|
||||
public:
|
||||
|
||||
//----------------------------
|
||||
// Constructors and destructor
|
||||
//----------------------------
|
||||
|
||||
BaseExc (const char *s = 0) throw(); // std::string (s)
|
||||
BaseExc (const std::string &s) throw(); // std::string (s)
|
||||
BaseExc (std::stringstream &s) throw(); // std::string (s.str())
|
||||
|
||||
BaseExc (const BaseExc &be) throw();
|
||||
virtual ~BaseExc () throw ();
|
||||
|
||||
//--------------------------------------------
|
||||
// what() method -- e.what() returns e.c_str()
|
||||
//--------------------------------------------
|
||||
|
||||
virtual const char * what () const throw ();
|
||||
|
||||
|
||||
//--------------------------------------------------
|
||||
// Convenient methods to change the exception's text
|
||||
//--------------------------------------------------
|
||||
|
||||
BaseExc & assign (std::stringstream &s); // assign (s.str())
|
||||
BaseExc & operator = (std::stringstream &s);
|
||||
|
||||
BaseExc & append (std::stringstream &s); // append (s.str())
|
||||
BaseExc & operator += (std::stringstream &s);
|
||||
|
||||
|
||||
//--------------------------------------------------
|
||||
// These methods from the base class get obscured by
|
||||
// the definitions above.
|
||||
//--------------------------------------------------
|
||||
|
||||
BaseExc & assign (const char *s);
|
||||
BaseExc & operator = (const char *s);
|
||||
|
||||
BaseExc & append (const char *s);
|
||||
BaseExc & operator += (const char *s);
|
||||
|
||||
|
||||
//--------------------------------------------------
|
||||
// Stack trace for the point at which the exception
|
||||
// was thrown. The stack trace will be an empty
|
||||
// string unless a working stack-tracing routine
|
||||
// has been installed (see below, setStackTracer()).
|
||||
//--------------------------------------------------
|
||||
|
||||
const std::string & stackTrace () const;
|
||||
|
||||
private:
|
||||
|
||||
std::string _stackTrace;
|
||||
};
|
||||
|
||||
|
||||
//-----------------------------------------------------
|
||||
// A macro to save typing when declararing an exception
|
||||
// class derived directly or indirectly from BaseExc:
|
||||
//-----------------------------------------------------
|
||||
|
||||
#define DEFINE_EXC(name, base) \
|
||||
class name: public base \
|
||||
{ \
|
||||
public: \
|
||||
name (const char* text=0) throw(): base (text) {} \
|
||||
name (const std::string &text) throw(): base (text) {} \
|
||||
name (std::stringstream &text) throw(): base (text) {} \
|
||||
};
|
||||
|
||||
|
||||
//--------------------------------------------------------
|
||||
// Some exceptions which should be useful in most programs
|
||||
//--------------------------------------------------------
|
||||
|
||||
DEFINE_EXC (ArgExc, BaseExc) // Invalid arguments to a function call
|
||||
|
||||
DEFINE_EXC (LogicExc, BaseExc) // General error in a program's logic,
|
||||
// for example, a function was called
|
||||
// in a context where the call does
|
||||
// not make sense.
|
||||
|
||||
DEFINE_EXC (InputExc, BaseExc) // Invalid input data, e.g. from a file
|
||||
|
||||
DEFINE_EXC (IoExc, BaseExc) // Input or output operation failed
|
||||
|
||||
DEFINE_EXC (MathExc, BaseExc) // Arithmetic exception; more specific
|
||||
// exceptions derived from this class
|
||||
// are defined in ExcMath.h
|
||||
|
||||
DEFINE_EXC (ErrnoExc, BaseExc) // Base class for exceptions corresponding
|
||||
// to errno values (see errno.h); more
|
||||
// specific exceptions derived from this
|
||||
// class are defined in ExcErrno.h
|
||||
|
||||
DEFINE_EXC (NoImplExc, BaseExc) // Missing method exception e.g. from a
|
||||
// call to a method that is only partially
|
||||
// or not at all implemented. A reminder
|
||||
// to lazy software people to get back
|
||||
// to work.
|
||||
|
||||
DEFINE_EXC (NullExc, BaseExc) // A pointer is inappropriately null.
|
||||
|
||||
DEFINE_EXC (TypeExc, BaseExc) // An object is an inappropriate type,
|
||||
// i.e. a dynamnic_cast failed.
|
||||
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
// Stack-tracing support:
|
||||
//
|
||||
// setStackTracer(st)
|
||||
//
|
||||
// installs a stack-tracing routine, st, which will be called from
|
||||
// class BaseExc's constructor every time an exception derived from
|
||||
// BaseExc is thrown. The stack-tracing routine should return a
|
||||
// string that contains a printable representation of the program's
|
||||
// current call stack. This string will be stored in the BaseExc
|
||||
// object; the string is accesible via the BaseExc::stackTrace()
|
||||
// method.
|
||||
//
|
||||
// setStackTracer(0)
|
||||
//
|
||||
// removes the current stack tracing routine. When an exception
|
||||
// derived from BaseExc is thrown, the stack trace string stored
|
||||
// in the BaseExc object will be empty.
|
||||
//
|
||||
// stackTracer()
|
||||
//
|
||||
// returns a pointer to the current stack-tracing routine, or 0
|
||||
// if there is no current stack stack-tracing routine.
|
||||
//
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
typedef std::string (* StackTracer) ();
|
||||
|
||||
void setStackTracer (StackTracer stackTracer);
|
||||
StackTracer stackTracer ();
|
||||
|
||||
|
||||
//-----------------
|
||||
// Inline functions
|
||||
//-----------------
|
||||
|
||||
inline BaseExc &
|
||||
BaseExc::operator = (std::stringstream &s)
|
||||
{
|
||||
return assign (s);
|
||||
}
|
||||
|
||||
|
||||
inline BaseExc &
|
||||
BaseExc::operator += (std::stringstream &s)
|
||||
{
|
||||
return append (s);
|
||||
}
|
||||
|
||||
|
||||
inline BaseExc &
|
||||
BaseExc::assign (const char *s)
|
||||
{
|
||||
std::string::assign(s);
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
inline BaseExc &
|
||||
BaseExc::operator = (const char *s)
|
||||
{
|
||||
return assign(s);
|
||||
}
|
||||
|
||||
|
||||
inline BaseExc &
|
||||
BaseExc::append (const char *s)
|
||||
{
|
||||
std::string::append(s);
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
inline BaseExc &
|
||||
BaseExc::operator += (const char *s)
|
||||
{
|
||||
return append(s);
|
||||
}
|
||||
|
||||
|
||||
inline const std::string &
|
||||
BaseExc::stackTrace () const
|
||||
{
|
||||
return _stackTrace;
|
||||
}
|
||||
|
||||
#if (defined _WIN32 || defined _WIN64) && defined _MSC_VER
|
||||
#pragma warning(default:4290)
|
||||
#endif
|
||||
|
||||
} // namespace Iex
|
||||
|
||||
#endif
|
||||
@@ -1,210 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
#ifndef INCLUDED_IEXERRNOEXC_H
|
||||
#define INCLUDED_IEXERRNOEXC_H
|
||||
|
||||
//----------------------------------------------------------------
|
||||
//
|
||||
// Exceptions which correspond to "errno" error codes.
|
||||
//
|
||||
//----------------------------------------------------------------
|
||||
|
||||
#include "IexBaseExc.h"
|
||||
|
||||
namespace Iex {
|
||||
|
||||
|
||||
DEFINE_EXC (EpermExc, ErrnoExc)
|
||||
DEFINE_EXC (EnoentExc, ErrnoExc)
|
||||
DEFINE_EXC (EsrchExc, ErrnoExc)
|
||||
DEFINE_EXC (EintrExc, ErrnoExc)
|
||||
DEFINE_EXC (EioExc, ErrnoExc)
|
||||
DEFINE_EXC (EnxioExc, ErrnoExc)
|
||||
DEFINE_EXC (E2bigExc, ErrnoExc)
|
||||
DEFINE_EXC (EnoexecExc, ErrnoExc)
|
||||
DEFINE_EXC (EbadfExc, ErrnoExc)
|
||||
DEFINE_EXC (EchildExc, ErrnoExc)
|
||||
DEFINE_EXC (EagainExc, ErrnoExc)
|
||||
DEFINE_EXC (EnomemExc, ErrnoExc)
|
||||
DEFINE_EXC (EaccesExc, ErrnoExc)
|
||||
DEFINE_EXC (EfaultExc, ErrnoExc)
|
||||
DEFINE_EXC (EnotblkExc, ErrnoExc)
|
||||
DEFINE_EXC (EbusyExc, ErrnoExc)
|
||||
DEFINE_EXC (EexistExc, ErrnoExc)
|
||||
DEFINE_EXC (ExdevExc, ErrnoExc)
|
||||
DEFINE_EXC (EnodevExc, ErrnoExc)
|
||||
DEFINE_EXC (EnotdirExc, ErrnoExc)
|
||||
DEFINE_EXC (EisdirExc, ErrnoExc)
|
||||
DEFINE_EXC (EinvalExc, ErrnoExc)
|
||||
DEFINE_EXC (EnfileExc, ErrnoExc)
|
||||
DEFINE_EXC (EmfileExc, ErrnoExc)
|
||||
DEFINE_EXC (EnottyExc, ErrnoExc)
|
||||
DEFINE_EXC (EtxtbsyExc, ErrnoExc)
|
||||
DEFINE_EXC (EfbigExc, ErrnoExc)
|
||||
DEFINE_EXC (EnospcExc, ErrnoExc)
|
||||
DEFINE_EXC (EspipeExc, ErrnoExc)
|
||||
DEFINE_EXC (ErofsExc, ErrnoExc)
|
||||
DEFINE_EXC (EmlinkExc, ErrnoExc)
|
||||
DEFINE_EXC (EpipeExc, ErrnoExc)
|
||||
DEFINE_EXC (EdomExc, ErrnoExc)
|
||||
DEFINE_EXC (ErangeExc, ErrnoExc)
|
||||
DEFINE_EXC (EnomsgExc, ErrnoExc)
|
||||
DEFINE_EXC (EidrmExc, ErrnoExc)
|
||||
DEFINE_EXC (EchrngExc, ErrnoExc)
|
||||
DEFINE_EXC (El2nsyncExc, ErrnoExc)
|
||||
DEFINE_EXC (El3hltExc, ErrnoExc)
|
||||
DEFINE_EXC (El3rstExc, ErrnoExc)
|
||||
DEFINE_EXC (ElnrngExc, ErrnoExc)
|
||||
DEFINE_EXC (EunatchExc, ErrnoExc)
|
||||
DEFINE_EXC (EnocsiExc, ErrnoExc)
|
||||
DEFINE_EXC (El2hltExc, ErrnoExc)
|
||||
DEFINE_EXC (EdeadlkExc, ErrnoExc)
|
||||
DEFINE_EXC (EnolckExc, ErrnoExc)
|
||||
DEFINE_EXC (EbadeExc, ErrnoExc)
|
||||
DEFINE_EXC (EbadrExc, ErrnoExc)
|
||||
DEFINE_EXC (ExfullExc, ErrnoExc)
|
||||
DEFINE_EXC (EnoanoExc, ErrnoExc)
|
||||
DEFINE_EXC (EbadrqcExc, ErrnoExc)
|
||||
DEFINE_EXC (EbadsltExc, ErrnoExc)
|
||||
DEFINE_EXC (EdeadlockExc, ErrnoExc)
|
||||
DEFINE_EXC (EbfontExc, ErrnoExc)
|
||||
DEFINE_EXC (EnostrExc, ErrnoExc)
|
||||
DEFINE_EXC (EnodataExc, ErrnoExc)
|
||||
DEFINE_EXC (EtimeExc, ErrnoExc)
|
||||
DEFINE_EXC (EnosrExc, ErrnoExc)
|
||||
DEFINE_EXC (EnonetExc, ErrnoExc)
|
||||
DEFINE_EXC (EnopkgExc, ErrnoExc)
|
||||
DEFINE_EXC (EremoteExc, ErrnoExc)
|
||||
DEFINE_EXC (EnolinkExc, ErrnoExc)
|
||||
DEFINE_EXC (EadvExc, ErrnoExc)
|
||||
DEFINE_EXC (EsrmntExc, ErrnoExc)
|
||||
DEFINE_EXC (EcommExc, ErrnoExc)
|
||||
DEFINE_EXC (EprotoExc, ErrnoExc)
|
||||
DEFINE_EXC (EmultihopExc, ErrnoExc)
|
||||
DEFINE_EXC (EbadmsgExc, ErrnoExc)
|
||||
DEFINE_EXC (EnametoolongExc, ErrnoExc)
|
||||
DEFINE_EXC (EoverflowExc, ErrnoExc)
|
||||
DEFINE_EXC (EnotuniqExc, ErrnoExc)
|
||||
DEFINE_EXC (EbadfdExc, ErrnoExc)
|
||||
DEFINE_EXC (EremchgExc, ErrnoExc)
|
||||
DEFINE_EXC (ElibaccExc, ErrnoExc)
|
||||
DEFINE_EXC (ElibbadExc, ErrnoExc)
|
||||
DEFINE_EXC (ElibscnExc, ErrnoExc)
|
||||
DEFINE_EXC (ElibmaxExc, ErrnoExc)
|
||||
DEFINE_EXC (ElibexecExc, ErrnoExc)
|
||||
DEFINE_EXC (EilseqExc, ErrnoExc)
|
||||
DEFINE_EXC (EnosysExc, ErrnoExc)
|
||||
DEFINE_EXC (EloopExc, ErrnoExc)
|
||||
DEFINE_EXC (ErestartExc, ErrnoExc)
|
||||
DEFINE_EXC (EstrpipeExc, ErrnoExc)
|
||||
DEFINE_EXC (EnotemptyExc, ErrnoExc)
|
||||
DEFINE_EXC (EusersExc, ErrnoExc)
|
||||
DEFINE_EXC (EnotsockExc, ErrnoExc)
|
||||
DEFINE_EXC (EdestaddrreqExc, ErrnoExc)
|
||||
DEFINE_EXC (EmsgsizeExc, ErrnoExc)
|
||||
DEFINE_EXC (EprototypeExc, ErrnoExc)
|
||||
DEFINE_EXC (EnoprotooptExc, ErrnoExc)
|
||||
DEFINE_EXC (EprotonosupportExc, ErrnoExc)
|
||||
DEFINE_EXC (EsocktnosupportExc, ErrnoExc)
|
||||
DEFINE_EXC (EopnotsuppExc, ErrnoExc)
|
||||
DEFINE_EXC (EpfnosupportExc, ErrnoExc)
|
||||
DEFINE_EXC (EafnosupportExc, ErrnoExc)
|
||||
DEFINE_EXC (EaddrinuseExc, ErrnoExc)
|
||||
DEFINE_EXC (EaddrnotavailExc, ErrnoExc)
|
||||
DEFINE_EXC (EnetdownExc, ErrnoExc)
|
||||
DEFINE_EXC (EnetunreachExc, ErrnoExc)
|
||||
DEFINE_EXC (EnetresetExc, ErrnoExc)
|
||||
DEFINE_EXC (EconnabortedExc, ErrnoExc)
|
||||
DEFINE_EXC (EconnresetExc, ErrnoExc)
|
||||
DEFINE_EXC (EnobufsExc, ErrnoExc)
|
||||
DEFINE_EXC (EisconnExc, ErrnoExc)
|
||||
DEFINE_EXC (EnotconnExc, ErrnoExc)
|
||||
DEFINE_EXC (EshutdownExc, ErrnoExc)
|
||||
DEFINE_EXC (EtoomanyrefsExc, ErrnoExc)
|
||||
DEFINE_EXC (EtimedoutExc, ErrnoExc)
|
||||
DEFINE_EXC (EconnrefusedExc, ErrnoExc)
|
||||
DEFINE_EXC (EhostdownExc, ErrnoExc)
|
||||
DEFINE_EXC (EhostunreachExc, ErrnoExc)
|
||||
DEFINE_EXC (EalreadyExc, ErrnoExc)
|
||||
DEFINE_EXC (EinprogressExc, ErrnoExc)
|
||||
DEFINE_EXC (EstaleExc, ErrnoExc)
|
||||
DEFINE_EXC (EioresidExc, ErrnoExc)
|
||||
DEFINE_EXC (EucleanExc, ErrnoExc)
|
||||
DEFINE_EXC (EnotnamExc, ErrnoExc)
|
||||
DEFINE_EXC (EnavailExc, ErrnoExc)
|
||||
DEFINE_EXC (EisnamExc, ErrnoExc)
|
||||
DEFINE_EXC (EremoteioExc, ErrnoExc)
|
||||
DEFINE_EXC (EinitExc, ErrnoExc)
|
||||
DEFINE_EXC (EremdevExc, ErrnoExc)
|
||||
DEFINE_EXC (EcanceledExc, ErrnoExc)
|
||||
DEFINE_EXC (EnolimfileExc, ErrnoExc)
|
||||
DEFINE_EXC (EproclimExc, ErrnoExc)
|
||||
DEFINE_EXC (EdisjointExc, ErrnoExc)
|
||||
DEFINE_EXC (EnologinExc, ErrnoExc)
|
||||
DEFINE_EXC (EloginlimExc, ErrnoExc)
|
||||
DEFINE_EXC (EgrouploopExc, ErrnoExc)
|
||||
DEFINE_EXC (EnoattachExc, ErrnoExc)
|
||||
DEFINE_EXC (EnotsupExc, ErrnoExc)
|
||||
DEFINE_EXC (EnoattrExc, ErrnoExc)
|
||||
DEFINE_EXC (EdircorruptedExc, ErrnoExc)
|
||||
DEFINE_EXC (EdquotExc, ErrnoExc)
|
||||
DEFINE_EXC (EnfsremoteExc, ErrnoExc)
|
||||
DEFINE_EXC (EcontrollerExc, ErrnoExc)
|
||||
DEFINE_EXC (EnotcontrollerExc, ErrnoExc)
|
||||
DEFINE_EXC (EenqueuedExc, ErrnoExc)
|
||||
DEFINE_EXC (EnotenqueuedExc, ErrnoExc)
|
||||
DEFINE_EXC (EjoinedExc, ErrnoExc)
|
||||
DEFINE_EXC (EnotjoinedExc, ErrnoExc)
|
||||
DEFINE_EXC (EnoprocExc, ErrnoExc)
|
||||
DEFINE_EXC (EmustrunExc, ErrnoExc)
|
||||
DEFINE_EXC (EnotstoppedExc, ErrnoExc)
|
||||
DEFINE_EXC (EclockcpuExc, ErrnoExc)
|
||||
DEFINE_EXC (EinvalstateExc, ErrnoExc)
|
||||
DEFINE_EXC (EnoexistExc, ErrnoExc)
|
||||
DEFINE_EXC (EendofminorExc, ErrnoExc)
|
||||
DEFINE_EXC (EbufsizeExc, ErrnoExc)
|
||||
DEFINE_EXC (EemptyExc, ErrnoExc)
|
||||
DEFINE_EXC (EnointrgroupExc, ErrnoExc)
|
||||
DEFINE_EXC (EinvalmodeExc, ErrnoExc)
|
||||
DEFINE_EXC (EcantextentExc, ErrnoExc)
|
||||
DEFINE_EXC (EinvaltimeExc, ErrnoExc)
|
||||
DEFINE_EXC (EdestroyedExc, ErrnoExc)
|
||||
|
||||
|
||||
} // namespace Iex
|
||||
|
||||
#endif
|
||||
@@ -1,148 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
#ifndef INCLUDED_IEXMACROS_H
|
||||
#define INCLUDED_IEXMACROS_H
|
||||
|
||||
//--------------------------------------------------------------------
|
||||
//
|
||||
// Macros which make throwing exceptions more convenient
|
||||
//
|
||||
//--------------------------------------------------------------------
|
||||
|
||||
#include <sstream>
|
||||
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// A macro to throw exceptions whose text is assembled using stringstreams.
|
||||
//
|
||||
// Example:
|
||||
//
|
||||
// THROW (InputExc, "Syntax error in line " << line ", " << file << ".");
|
||||
//
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
#define THROW(type, text) \
|
||||
do \
|
||||
{ \
|
||||
std::stringstream s; \
|
||||
s << text; \
|
||||
throw type (s); \
|
||||
} \
|
||||
while (0)
|
||||
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// Macros to add to or to replace the text of an exception.
|
||||
// The new text is assembled using stringstreams.
|
||||
//
|
||||
// Examples:
|
||||
//
|
||||
// Append to end of an exception's text:
|
||||
//
|
||||
// catch (BaseExc &e)
|
||||
// {
|
||||
// APPEND_EXC (e, " Directory " << name << " does not exist.");
|
||||
// throw;
|
||||
// }
|
||||
//
|
||||
// Replace an exception's text:
|
||||
//
|
||||
// catch (BaseExc &e)
|
||||
// {
|
||||
// REPLACE_EXC (e, "Directory " << name << " does not exist. " << e);
|
||||
// throw;
|
||||
// }
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
#define APPEND_EXC(exc, text) \
|
||||
do \
|
||||
{ \
|
||||
std::stringstream s; \
|
||||
s << text; \
|
||||
exc.append (s); \
|
||||
} \
|
||||
while (0)
|
||||
|
||||
#define REPLACE_EXC(exc, text) \
|
||||
do \
|
||||
{ \
|
||||
std::stringstream s; \
|
||||
s << text; \
|
||||
exc.assign (s); \
|
||||
} \
|
||||
while (0)
|
||||
|
||||
|
||||
//-------------------------------------------------------------
|
||||
// A macro to throw ErrnoExc exceptions whose text is assembled
|
||||
// using stringstreams:
|
||||
//
|
||||
// Example:
|
||||
//
|
||||
// THROW_ERRNO ("Cannot open file " << name << " (%T).");
|
||||
//
|
||||
//-------------------------------------------------------------
|
||||
|
||||
#define THROW_ERRNO(text) \
|
||||
do \
|
||||
{ \
|
||||
std::stringstream s; \
|
||||
s << text; \
|
||||
::Iex::throwErrnoExc (s.str()); \
|
||||
} \
|
||||
while (0)
|
||||
|
||||
|
||||
//-------------------------------------------------------------
|
||||
// A macro to throw exceptions if an assertion is false.
|
||||
//
|
||||
// Example:
|
||||
//
|
||||
// ASSERT (NullExc, ptr != NULL, "Null pointer" );
|
||||
//
|
||||
//-------------------------------------------------------------
|
||||
|
||||
#define ASSERT(assertion, type, text) \
|
||||
do \
|
||||
{ \
|
||||
if( (assertion) == false ) \
|
||||
THROW( type, text ); \
|
||||
} \
|
||||
while (0)
|
||||
|
||||
|
||||
#endif
|
||||
@@ -1,58 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
#ifndef INCLUDED_IEXMATHEXC_H
|
||||
#define INCLUDED_IEXMATHEXC_H
|
||||
|
||||
#include "IexBaseExc.h"
|
||||
|
||||
namespace Iex {
|
||||
|
||||
//---------------------------------------------------------
|
||||
// Exception classess which correspond to specific floating
|
||||
// point exceptions.
|
||||
//---------------------------------------------------------
|
||||
|
||||
DEFINE_EXC (OverflowExc, MathExc) // Overflow
|
||||
DEFINE_EXC (UnderflowExc, MathExc) // Underflow
|
||||
DEFINE_EXC (DivzeroExc, MathExc) // Division by zero
|
||||
DEFINE_EXC (InexactExc, MathExc) // Inexact result
|
||||
DEFINE_EXC (InvalidFpOpExc, MathExc) // Invalid operation
|
||||
|
||||
|
||||
} // namespace Iex
|
||||
|
||||
#endif
|
||||
@@ -1,859 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
//----------------------------------------------------------------
|
||||
//
|
||||
// Exceptions that correspond to "errno" error codes,
|
||||
// and a function to make throwing those exceptions easy.
|
||||
//
|
||||
//----------------------------------------------------------------
|
||||
|
||||
#include "IexThrowErrnoExc.h"
|
||||
#include "IexErrnoExc.h"
|
||||
#include <string.h>
|
||||
#include <errno.h>
|
||||
|
||||
namespace Iex {
|
||||
|
||||
|
||||
void throwErrnoExc (const std::string &text, int errnum)
|
||||
{
|
||||
const char *entext = strerror (errnum);
|
||||
std::string tmp (text);
|
||||
int pos;
|
||||
|
||||
while (-1 != (pos = tmp.find ("%T")))
|
||||
tmp.replace (pos, 2, entext, strlen (entext));
|
||||
|
||||
switch (errnum)
|
||||
{
|
||||
#if defined (EPERM)
|
||||
case EPERM:
|
||||
throw EpermExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENOENT)
|
||||
case ENOENT:
|
||||
throw EnoentExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ESRCH)
|
||||
case ESRCH:
|
||||
throw EsrchExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EINTR)
|
||||
case EINTR:
|
||||
throw EintrExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EIO)
|
||||
case EIO:
|
||||
throw EioExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENXIO)
|
||||
case ENXIO:
|
||||
throw EnxioExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (E2BIG)
|
||||
case E2BIG:
|
||||
throw E2bigExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENOEXEC)
|
||||
case ENOEXEC:
|
||||
throw EnoexecExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EBADF)
|
||||
case EBADF:
|
||||
throw EbadfExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ECHILD)
|
||||
case ECHILD:
|
||||
throw EchildExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EAGAIN)
|
||||
case EAGAIN:
|
||||
throw EagainExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENOMEM)
|
||||
case ENOMEM:
|
||||
throw EnomemExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EACCES)
|
||||
case EACCES:
|
||||
throw EaccesExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EFAULT)
|
||||
case EFAULT:
|
||||
throw EfaultExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENOTBLK)
|
||||
case ENOTBLK:
|
||||
throw EnotblkExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EBUSY)
|
||||
case EBUSY:
|
||||
throw EbusyExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EEXIST)
|
||||
case EEXIST:
|
||||
throw EexistExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EXDEV)
|
||||
case EXDEV:
|
||||
throw ExdevExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENODEV)
|
||||
case ENODEV:
|
||||
throw EnodevExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENOTDIR)
|
||||
case ENOTDIR:
|
||||
throw EnotdirExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EISDIR)
|
||||
case EISDIR:
|
||||
throw EisdirExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EINVAL)
|
||||
case EINVAL:
|
||||
throw EinvalExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENFILE)
|
||||
case ENFILE:
|
||||
throw EnfileExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EMFILE)
|
||||
case EMFILE:
|
||||
throw EmfileExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENOTTY)
|
||||
case ENOTTY:
|
||||
throw EnottyExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ETXTBSY)
|
||||
case ETXTBSY:
|
||||
throw EtxtbsyExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EFBIG)
|
||||
case EFBIG:
|
||||
throw EfbigExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENOSPC)
|
||||
case ENOSPC:
|
||||
throw EnospcExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ESPIPE)
|
||||
case ESPIPE:
|
||||
throw EspipeExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EROFS)
|
||||
case EROFS:
|
||||
throw ErofsExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EMLINK)
|
||||
case EMLINK:
|
||||
throw EmlinkExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EPIPE)
|
||||
case EPIPE:
|
||||
throw EpipeExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EDOM)
|
||||
case EDOM:
|
||||
throw EdomExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ERANGE)
|
||||
case ERANGE:
|
||||
throw ErangeExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENOMSG)
|
||||
case ENOMSG:
|
||||
throw EnomsgExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EIDRM)
|
||||
case EIDRM:
|
||||
throw EidrmExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ECHRNG)
|
||||
case ECHRNG:
|
||||
throw EchrngExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EL2NSYNC)
|
||||
case EL2NSYNC:
|
||||
throw El2nsyncExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EL3HLT)
|
||||
case EL3HLT:
|
||||
throw El3hltExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EL3RST)
|
||||
case EL3RST:
|
||||
throw El3rstExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ELNRNG)
|
||||
case ELNRNG:
|
||||
throw ElnrngExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EUNATCH)
|
||||
case EUNATCH:
|
||||
throw EunatchExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENOSCI)
|
||||
case ENOCSI:
|
||||
throw EnocsiExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EL2HLT)
|
||||
case EL2HLT:
|
||||
throw El2hltExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EDEADLK)
|
||||
case EDEADLK:
|
||||
throw EdeadlkExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENOLCK)
|
||||
case ENOLCK:
|
||||
throw EnolckExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EBADE)
|
||||
case EBADE:
|
||||
throw EbadeExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EBADR)
|
||||
case EBADR:
|
||||
throw EbadrExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EXFULL)
|
||||
case EXFULL:
|
||||
throw ExfullExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENOANO)
|
||||
case ENOANO:
|
||||
throw EnoanoExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EBADRQC)
|
||||
case EBADRQC:
|
||||
throw EbadrqcExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EBADSLT)
|
||||
case EBADSLT:
|
||||
throw EbadsltExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EDEADLOCK) && defined (EDEADLK)
|
||||
#if EDEADLOCK != EDEADLK
|
||||
case EDEADLOCK:
|
||||
throw EdeadlockExc (tmp);
|
||||
#endif
|
||||
#elif defined (EDEADLOCK)
|
||||
case EDEADLOCK:
|
||||
throw EdeadlockExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EBFONT)
|
||||
case EBFONT:
|
||||
throw EbfontExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENOSTR)
|
||||
case ENOSTR:
|
||||
throw EnostrExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENODATA)
|
||||
case ENODATA:
|
||||
throw EnodataExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ETIME)
|
||||
case ETIME:
|
||||
throw EtimeExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENOSR)
|
||||
case ENOSR:
|
||||
throw EnosrExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENONET)
|
||||
case ENONET:
|
||||
throw EnonetExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENOPKG)
|
||||
case ENOPKG:
|
||||
throw EnopkgExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EREMOTE)
|
||||
case EREMOTE:
|
||||
throw EremoteExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENOLINK)
|
||||
case ENOLINK:
|
||||
throw EnolinkExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EADV)
|
||||
case EADV:
|
||||
throw EadvExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ESRMNT)
|
||||
case ESRMNT:
|
||||
throw EsrmntExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ECOMM)
|
||||
case ECOMM:
|
||||
throw EcommExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EPROTO)
|
||||
case EPROTO:
|
||||
throw EprotoExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EMULTIHOP)
|
||||
case EMULTIHOP:
|
||||
throw EmultihopExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EBADMSG)
|
||||
case EBADMSG:
|
||||
throw EbadmsgExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENAMETOOLONG)
|
||||
case ENAMETOOLONG:
|
||||
throw EnametoolongExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EOVERFLOW)
|
||||
case EOVERFLOW:
|
||||
throw EoverflowExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENOTUNIQ)
|
||||
case ENOTUNIQ:
|
||||
throw EnotuniqExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EBADFD)
|
||||
case EBADFD:
|
||||
throw EbadfdExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EREMCHG)
|
||||
case EREMCHG:
|
||||
throw EremchgExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ELIBACC)
|
||||
case ELIBACC:
|
||||
throw ElibaccExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ELIBBAD)
|
||||
case ELIBBAD:
|
||||
throw ElibbadExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ELIBSCN)
|
||||
case ELIBSCN:
|
||||
throw ElibscnExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ELIBMAX)
|
||||
case ELIBMAX:
|
||||
throw ElibmaxExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ELIBEXEC)
|
||||
case ELIBEXEC:
|
||||
throw ElibexecExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EILSEQ)
|
||||
case EILSEQ:
|
||||
throw EilseqExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENOSYS)
|
||||
case ENOSYS:
|
||||
throw EnosysExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ELOOP)
|
||||
case ELOOP:
|
||||
throw EloopExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ERESTART)
|
||||
case ERESTART:
|
||||
throw ErestartExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ESTRPIPE)
|
||||
case ESTRPIPE:
|
||||
throw EstrpipeExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENOTEMPTY)
|
||||
case ENOTEMPTY:
|
||||
throw EnotemptyExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EUSERS)
|
||||
case EUSERS:
|
||||
throw EusersExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENOTSOCK)
|
||||
case ENOTSOCK:
|
||||
throw EnotsockExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EDESTADDRREQ)
|
||||
case EDESTADDRREQ:
|
||||
throw EdestaddrreqExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EMSGSIZE)
|
||||
case EMSGSIZE:
|
||||
throw EmsgsizeExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EPROTOTYPE)
|
||||
case EPROTOTYPE:
|
||||
throw EprototypeExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENOPROTOOPT)
|
||||
case ENOPROTOOPT:
|
||||
throw EnoprotooptExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EPROTONOSUPPORT)
|
||||
case EPROTONOSUPPORT:
|
||||
throw EprotonosupportExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ESOCKTNOSUPPORT)
|
||||
case ESOCKTNOSUPPORT:
|
||||
throw EsocktnosupportExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EOPNOTSUPP)
|
||||
case EOPNOTSUPP:
|
||||
throw EopnotsuppExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EPFNOSUPPORT)
|
||||
case EPFNOSUPPORT:
|
||||
throw EpfnosupportExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EAFNOSUPPORT)
|
||||
case EAFNOSUPPORT:
|
||||
throw EafnosupportExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EADDRINUSE)
|
||||
case EADDRINUSE:
|
||||
throw EaddrinuseExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EADDRNOTAVAIL)
|
||||
case EADDRNOTAVAIL:
|
||||
throw EaddrnotavailExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENETDOWN)
|
||||
case ENETDOWN:
|
||||
throw EnetdownExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENETUNREACH)
|
||||
case ENETUNREACH:
|
||||
throw EnetunreachExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENETRESET)
|
||||
case ENETRESET:
|
||||
throw EnetresetExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ECONNABORTED)
|
||||
case ECONNABORTED:
|
||||
throw EconnabortedExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ECONNRESET)
|
||||
case ECONNRESET:
|
||||
throw EconnresetExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENOBUFS)
|
||||
case ENOBUFS:
|
||||
throw EnobufsExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EISCONN)
|
||||
case EISCONN:
|
||||
throw EisconnExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENOTCONN)
|
||||
case ENOTCONN:
|
||||
throw EnotconnExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ESHUTDOWN)
|
||||
case ESHUTDOWN:
|
||||
throw EshutdownExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ETOOMANYREFS)
|
||||
case ETOOMANYREFS:
|
||||
throw EtoomanyrefsExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ETIMEDOUT)
|
||||
case ETIMEDOUT:
|
||||
throw EtimedoutExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ECONNREFUSED)
|
||||
case ECONNREFUSED:
|
||||
throw EconnrefusedExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EHOSTDOWN)
|
||||
case EHOSTDOWN:
|
||||
throw EhostdownExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EHOSTUNREACH)
|
||||
case EHOSTUNREACH:
|
||||
throw EhostunreachExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EALREADY)
|
||||
case EALREADY:
|
||||
throw EalreadyExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EINPROGRESS)
|
||||
case EINPROGRESS:
|
||||
throw EinprogressExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ESTALE)
|
||||
case ESTALE:
|
||||
throw EstaleExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EIORESID)
|
||||
case EIORESID:
|
||||
throw EioresidExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EUCLEAN)
|
||||
case EUCLEAN:
|
||||
throw EucleanExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENOTNAM)
|
||||
case ENOTNAM:
|
||||
throw EnotnamExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENAVAIL)
|
||||
case ENAVAIL:
|
||||
throw EnavailExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EISNAM)
|
||||
case EISNAM:
|
||||
throw EisnamExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EREMOTEIO)
|
||||
case EREMOTEIO:
|
||||
throw EremoteioExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EINIT)
|
||||
case EINIT:
|
||||
throw EinitExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EREMDEV)
|
||||
case EREMDEV:
|
||||
throw EremdevExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ECANCELED)
|
||||
case ECANCELED:
|
||||
throw EcanceledExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENOLIMFILE)
|
||||
case ENOLIMFILE:
|
||||
throw EnolimfileExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EPROCLIM)
|
||||
case EPROCLIM:
|
||||
throw EproclimExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EDISJOINT)
|
||||
case EDISJOINT:
|
||||
throw EdisjointExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENOLOGIN)
|
||||
case ENOLOGIN:
|
||||
throw EnologinExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ELOGINLIM)
|
||||
case ELOGINLIM:
|
||||
throw EloginlimExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EGROUPLOOP)
|
||||
case EGROUPLOOP:
|
||||
throw EgrouploopExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENOATTACH)
|
||||
case ENOATTACH:
|
||||
throw EnoattachExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENOTSUP) && defined (EOPNOTSUPP)
|
||||
#if ENOTSUP != EOPNOTSUPP
|
||||
case ENOTSUP:
|
||||
throw EnotsupExc (tmp);
|
||||
#endif
|
||||
#elif defined (ENOTSUP)
|
||||
case ENOTSUP:
|
||||
throw EnotsupExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENOATTR)
|
||||
case ENOATTR:
|
||||
throw EnoattrExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EDIRCORRUPTED)
|
||||
case EDIRCORRUPTED:
|
||||
throw EdircorruptedExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EDQUOT)
|
||||
case EDQUOT:
|
||||
throw EdquotExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENFSREMOTE)
|
||||
case ENFSREMOTE:
|
||||
throw EnfsremoteExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ECONTROLLER)
|
||||
case ECONTROLLER:
|
||||
throw EcontrollerExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENOTCONTROLLER)
|
||||
case ENOTCONTROLLER:
|
||||
throw EnotcontrollerExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EENQUEUED)
|
||||
case EENQUEUED:
|
||||
throw EenqueuedExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENOTENQUEUED)
|
||||
case ENOTENQUEUED:
|
||||
throw EnotenqueuedExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EJOINED)
|
||||
case EJOINED:
|
||||
throw EjoinedExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENOTJOINED)
|
||||
case ENOTJOINED:
|
||||
throw EnotjoinedExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENOPROC)
|
||||
case ENOPROC:
|
||||
throw EnoprocExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EMUSTRUN)
|
||||
case EMUSTRUN:
|
||||
throw EmustrunExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENOTSTOPPED)
|
||||
case ENOTSTOPPED:
|
||||
throw EnotstoppedExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ECLOCKCPU)
|
||||
case ECLOCKCPU:
|
||||
throw EclockcpuExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EINVALSTATE)
|
||||
case EINVALSTATE:
|
||||
throw EinvalstateExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENOEXIST)
|
||||
case ENOEXIST:
|
||||
throw EnoexistExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EENDOFMINOR)
|
||||
case EENDOFMINOR:
|
||||
throw EendofminorExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EBUFSIZE)
|
||||
case EBUFSIZE:
|
||||
throw EbufsizeExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EEMPTY)
|
||||
case EEMPTY:
|
||||
throw EemptyExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ENOINTRGROUP)
|
||||
case ENOINTRGROUP:
|
||||
throw EnointrgroupExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EINVALMODE)
|
||||
case EINVALMODE:
|
||||
throw EinvalmodeExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (ECANTEXTENT)
|
||||
case ECANTEXTENT:
|
||||
throw EcantextentExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EINVALTIME)
|
||||
case EINVALTIME:
|
||||
throw EinvaltimeExc (tmp);
|
||||
#endif
|
||||
|
||||
#if defined (EDESTROYED)
|
||||
case EDESTROYED:
|
||||
throw EdestroyedExc (tmp);
|
||||
#endif
|
||||
}
|
||||
|
||||
throw ErrnoExc (tmp);
|
||||
}
|
||||
|
||||
|
||||
void throwErrnoExc (const std::string &text)
|
||||
{
|
||||
throwErrnoExc (text, errno);
|
||||
}
|
||||
|
||||
|
||||
} // namespace Iex
|
||||
@@ -1,96 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
#ifndef INCLUDED_IEXTHROWERRNOEXC_H
|
||||
#define INCLUDED_IEXTHROWERRNOEXC_H
|
||||
|
||||
//----------------------------------------------------------
|
||||
//
|
||||
// A function which throws ExcErrno exceptions
|
||||
//
|
||||
//----------------------------------------------------------
|
||||
|
||||
#include "IexBaseExc.h"
|
||||
|
||||
namespace Iex {
|
||||
|
||||
|
||||
//--------------------------------------------------------------------------
|
||||
//
|
||||
// Function throwErrnoExc() throws an exception which corresponds to
|
||||
// error code errnum. The exception text is initialized with a copy
|
||||
// of the string passed to throwErrnoExc(), where all occurrences of
|
||||
// "%T" have been replaced with the output of strerror(oserror()).
|
||||
//
|
||||
// Example:
|
||||
//
|
||||
// If opening file /tmp/output failed with an ENOENT error code,
|
||||
// calling
|
||||
//
|
||||
// throwErrnoExc ();
|
||||
//
|
||||
// or
|
||||
//
|
||||
// throwErrnoExc ("%T.");
|
||||
//
|
||||
// will throw an EnoentExc whose text reads
|
||||
//
|
||||
// No such file or directory.
|
||||
//
|
||||
// More detailed messages can be assembled using stringstreams:
|
||||
//
|
||||
// std::stringstream s;
|
||||
// s << "Cannot open file " << name << " (%T).";
|
||||
// throwErrnoExc (s);
|
||||
//
|
||||
// The resulting exception contains the following text:
|
||||
//
|
||||
// Cannot open file /tmp/output (No such file or directory).
|
||||
//
|
||||
// Alternatively, you may want to use the THROW_ERRNO macro defined
|
||||
// in IexMacros.h:
|
||||
//
|
||||
// THROW_ERRNO ("Cannot open file " << name << " (%T).")
|
||||
//
|
||||
//--------------------------------------------------------------------------
|
||||
|
||||
void throwErrnoExc (const std::string &txt, int errnum);
|
||||
void throwErrnoExc (const std::string &txt = "%T." /*, int errnum = oserror() */);
|
||||
|
||||
|
||||
} // namespace Iex
|
||||
|
||||
#endif
|
||||
@@ -1,13 +0,0 @@
|
||||
SubDir HAIKU_TOP src add-ons translators exr openexr iex ;
|
||||
|
||||
SubDirSysHdrs [ FDirName $(SUBDIR) ] ;
|
||||
|
||||
local architectureObject ;
|
||||
for architectureObject in [ MultiArchSubDirSetup ] {
|
||||
on $(architectureObject) {
|
||||
StaticLibrary [ MultiArchDefaultGristFiles libiex.a ] :
|
||||
IexBaseExc.cpp
|
||||
IexThrowErrnoExc.cpp
|
||||
;
|
||||
}
|
||||
}
|
||||
@@ -1,261 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
#ifndef INCLUDED_IMF_ARRAY_H
|
||||
#define INCLUDED_IMF_ARRAY_H
|
||||
|
||||
//-------------------------------------------------------------------------
|
||||
//
|
||||
// class Array
|
||||
// class Array2D
|
||||
//
|
||||
// "Arrays of T" whose sizes are not known at compile time.
|
||||
// When an array goes out of scope, its elements are automatically
|
||||
// deleted.
|
||||
//
|
||||
// Usage example:
|
||||
//
|
||||
// struct C
|
||||
// {
|
||||
// C () {std::cout << "C::C (" << this << ")\n";};
|
||||
// virtual ~C () {std::cout << "C::~C (" << this << ")\n";};
|
||||
// };
|
||||
//
|
||||
// int
|
||||
// main ()
|
||||
// {
|
||||
// Array <C> a(3);
|
||||
//
|
||||
// C &b = a[1];
|
||||
// const C &c = a[1];
|
||||
// C *d = a + 2;
|
||||
// const C *e = a;
|
||||
//
|
||||
// return 0;
|
||||
// }
|
||||
//
|
||||
//-------------------------------------------------------------------------
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
template <class T>
|
||||
class Array
|
||||
{
|
||||
public:
|
||||
|
||||
//-----------------------------
|
||||
// Constructors and destructors
|
||||
//-----------------------------
|
||||
|
||||
Array () {_data = 0;}
|
||||
Array (long size) {_data = new T[size];}
|
||||
~Array () {delete [] _data;}
|
||||
|
||||
|
||||
//-----------------------------
|
||||
// Access to the array elements
|
||||
//-----------------------------
|
||||
|
||||
operator T * () {return _data;}
|
||||
operator const T * () const {return _data;}
|
||||
|
||||
|
||||
//------------------------------------------------------
|
||||
// Resize and clear the array (the contents of the array
|
||||
// are not preserved across the resize operation).
|
||||
//
|
||||
// resizeEraseUnsafe() is more memory efficient than
|
||||
// resizeErase() because it deletes the old memory block
|
||||
// before allocating a new one, but if allocating the
|
||||
// new block throws an exception, resizeEraseUnsafe()
|
||||
// leaves the array in an unusable state.
|
||||
//
|
||||
//------------------------------------------------------
|
||||
|
||||
void resizeErase (long size);
|
||||
void resizeEraseUnsafe (long size);
|
||||
|
||||
|
||||
private:
|
||||
|
||||
Array (const Array &); // Copying and assignment
|
||||
Array & operator = (const Array &); // are not implemented
|
||||
|
||||
T * _data;
|
||||
};
|
||||
|
||||
|
||||
template <class T>
|
||||
class Array2D
|
||||
{
|
||||
public:
|
||||
|
||||
//-----------------------------
|
||||
// Constructors and destructors
|
||||
//-----------------------------
|
||||
|
||||
Array2D (); // empty array, 0 by 0 elements
|
||||
Array2D (long sizeX, long sizeY); // sizeX by sizeY elements
|
||||
~Array2D ();
|
||||
|
||||
|
||||
//-----------------------------
|
||||
// Access to the array elements
|
||||
//-----------------------------
|
||||
|
||||
T * operator [] (long x);
|
||||
const T * operator [] (long x) const;
|
||||
|
||||
|
||||
//------------------------------------------------------
|
||||
// Resize and clear the array (the contents of the array
|
||||
// are not preserved across the resize operation).
|
||||
//
|
||||
// resizeEraseUnsafe() is more memory efficient than
|
||||
// resizeErase() because it deletes the old memory block
|
||||
// before allocating a new one, but if allocating the
|
||||
// new block throws an exception, resizeEraseUnsafe()
|
||||
// leaves the array in an unusable state.
|
||||
//
|
||||
//------------------------------------------------------
|
||||
|
||||
void resizeErase (long sizeX, long sizeY);
|
||||
void resizeEraseUnsafe (long sizeX, long sizeY);
|
||||
|
||||
|
||||
private:
|
||||
|
||||
Array2D (const Array2D &); // Copying and assignment
|
||||
Array2D & operator = (const Array2D &); // are not implemented
|
||||
|
||||
long _sizeY;
|
||||
T * _data;
|
||||
};
|
||||
|
||||
|
||||
//---------------
|
||||
// Implementation
|
||||
//---------------
|
||||
|
||||
template <class T>
|
||||
inline void
|
||||
Array<T>::resizeErase (long size)
|
||||
{
|
||||
T *tmp = new T[size];
|
||||
delete [] _data;
|
||||
_data = tmp;
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
inline void
|
||||
Array<T>::resizeEraseUnsafe (long size)
|
||||
{
|
||||
delete [] _data;
|
||||
_data = 0;
|
||||
_data = new T[size];
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
inline
|
||||
Array2D<T>::Array2D ():
|
||||
_sizeY (0), _data (0)
|
||||
{
|
||||
// emtpy
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
inline
|
||||
Array2D<T>::Array2D (long sizeX, long sizeY):
|
||||
_sizeY (sizeY), _data (new T[sizeX * sizeY])
|
||||
{
|
||||
// emtpy
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
inline
|
||||
Array2D<T>::~Array2D ()
|
||||
{
|
||||
delete [] _data;
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
inline T *
|
||||
Array2D<T>::operator [] (long x)
|
||||
{
|
||||
return _data + x * _sizeY;
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
inline const T *
|
||||
Array2D<T>::operator [] (long x) const
|
||||
{
|
||||
return _data + x * _sizeY;
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
inline void
|
||||
Array2D<T>::resizeErase (long sizeX, long sizeY)
|
||||
{
|
||||
T *tmp = new T[sizeX * sizeY];
|
||||
delete [] _data;
|
||||
_sizeY = sizeY;
|
||||
_data = tmp;
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
inline void
|
||||
Array2D<T>::resizeEraseUnsafe (long sizeX, long sizeY)
|
||||
{
|
||||
delete [] _data;
|
||||
_data = 0;
|
||||
_sizeY = 0;
|
||||
_data = new T[sizeX * sizeY];
|
||||
_sizeY = sizeY;
|
||||
}
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
|
||||
#endif
|
||||
@@ -1,156 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class Attribute
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfAttribute.h>
|
||||
#include "IlmThreadMutex.h"
|
||||
#include "Iex.h"
|
||||
#include <string.h>
|
||||
#include <map>
|
||||
|
||||
|
||||
namespace Imf {
|
||||
|
||||
using IlmThread::Mutex;
|
||||
using IlmThread::Lock;
|
||||
|
||||
|
||||
Attribute::Attribute () {}
|
||||
|
||||
|
||||
Attribute::~Attribute () {}
|
||||
|
||||
|
||||
namespace {
|
||||
|
||||
struct NameCompare: std::binary_function <const char *, const char *, bool>
|
||||
{
|
||||
bool
|
||||
operator () (const char *x, const char *y) const
|
||||
{
|
||||
return strcmp (x, y) < 0;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
typedef Attribute* (*Constructor)();
|
||||
typedef std::map <const char *, Constructor, NameCompare> TypeMap;
|
||||
|
||||
|
||||
class LockedTypeMap: public TypeMap
|
||||
{
|
||||
public:
|
||||
|
||||
Mutex mutex;
|
||||
};
|
||||
|
||||
|
||||
LockedTypeMap &
|
||||
typeMap ()
|
||||
{
|
||||
static Mutex criticalSection;
|
||||
Lock lock (criticalSection);
|
||||
|
||||
static LockedTypeMap* typeMap = 0;
|
||||
|
||||
if (typeMap == 0)
|
||||
typeMap = new LockedTypeMap ();
|
||||
|
||||
return *typeMap;
|
||||
}
|
||||
|
||||
|
||||
} // namespace
|
||||
|
||||
|
||||
bool
|
||||
Attribute::knownType (const char typeName[])
|
||||
{
|
||||
LockedTypeMap& tMap = typeMap();
|
||||
Lock lock (tMap.mutex);
|
||||
|
||||
return tMap.find (typeName) != tMap.end();
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
Attribute::registerAttributeType (const char typeName[],
|
||||
Attribute *(*newAttribute)())
|
||||
{
|
||||
LockedTypeMap& tMap = typeMap();
|
||||
Lock lock (tMap.mutex);
|
||||
|
||||
if (tMap.find (typeName) != tMap.end())
|
||||
THROW (Iex::ArgExc, "Cannot register image file attribute "
|
||||
"type \"" << typeName << "\". "
|
||||
"The type has already been registered.");
|
||||
|
||||
tMap.insert (TypeMap::value_type (typeName, newAttribute));
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
Attribute::unRegisterAttributeType (const char typeName[])
|
||||
{
|
||||
LockedTypeMap& tMap = typeMap();
|
||||
Lock lock (tMap.mutex);
|
||||
|
||||
tMap.erase (typeName);
|
||||
}
|
||||
|
||||
|
||||
Attribute *
|
||||
Attribute::newAttribute (const char typeName[])
|
||||
{
|
||||
LockedTypeMap& tMap = typeMap();
|
||||
Lock lock (tMap.mutex);
|
||||
|
||||
TypeMap::const_iterator i = tMap.find (typeName);
|
||||
|
||||
if (i == tMap.end())
|
||||
THROW (Iex::ArgExc, "Cannot create image file attribute of "
|
||||
"unknown type \"" << typeName << "\".");
|
||||
|
||||
return (i->second)();
|
||||
}
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
@@ -1,422 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
#ifndef INCLUDED_IMF_ATTRIBUTE_H
|
||||
#define INCLUDED_IMF_ATTRIBUTE_H
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class Attribute
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include "IexBaseExc.h"
|
||||
#include <ImfIO.h>
|
||||
#include <ImfXdr.h>
|
||||
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
class Attribute
|
||||
{
|
||||
public:
|
||||
|
||||
//---------------------------
|
||||
// Constructor and destructor
|
||||
//---------------------------
|
||||
|
||||
Attribute ();
|
||||
virtual ~Attribute ();
|
||||
|
||||
|
||||
//-------------------------------
|
||||
// Get this attribute's type name
|
||||
//-------------------------------
|
||||
|
||||
virtual const char * typeName () const = 0;
|
||||
|
||||
|
||||
//------------------------------
|
||||
// Make a copy of this attribute
|
||||
//------------------------------
|
||||
|
||||
virtual Attribute * copy () const = 0;
|
||||
|
||||
|
||||
//----------------------------------------
|
||||
// Type-specific attribute I/O and copying
|
||||
//----------------------------------------
|
||||
|
||||
virtual void writeValueTo (OStream &os,
|
||||
int version) const = 0;
|
||||
|
||||
virtual void readValueFrom (IStream &is,
|
||||
int size,
|
||||
int version) = 0;
|
||||
|
||||
virtual void copyValueFrom (const Attribute &other) = 0;
|
||||
|
||||
|
||||
//------------------
|
||||
// Attribute factory
|
||||
//------------------
|
||||
|
||||
static Attribute * newAttribute (const char typeName[]);
|
||||
|
||||
|
||||
//-----------------------------------------------------------
|
||||
// Test if a given attribute type has already been registered
|
||||
//-----------------------------------------------------------
|
||||
|
||||
static bool knownType (const char typeName[]);
|
||||
|
||||
|
||||
protected:
|
||||
|
||||
//--------------------------------------------------
|
||||
// Register an attribute type so that newAttribute()
|
||||
// knows how to make objects of this type.
|
||||
//--------------------------------------------------
|
||||
|
||||
static void registerAttributeType (const char typeName[],
|
||||
Attribute *(*newAttribute)());
|
||||
|
||||
//------------------------------------------------------
|
||||
// Un-register an attribute type so that newAttribute()
|
||||
// no longer knows how to make objects of this type (for
|
||||
// debugging only).
|
||||
//------------------------------------------------------
|
||||
|
||||
static void unRegisterAttributeType (const char typeName[]);
|
||||
};
|
||||
|
||||
|
||||
//-------------------------------------------------
|
||||
// Class template for attributes of a specific type
|
||||
//-------------------------------------------------
|
||||
|
||||
template <class T>
|
||||
class TypedAttribute: public Attribute
|
||||
{
|
||||
public:
|
||||
|
||||
//----------------------------
|
||||
// Constructors and destructor
|
||||
//------------_---------------
|
||||
|
||||
TypedAttribute ();
|
||||
TypedAttribute (const T &value);
|
||||
TypedAttribute (const TypedAttribute<T> &other);
|
||||
virtual ~TypedAttribute ();
|
||||
|
||||
|
||||
//--------------------------------
|
||||
// Access to the attribute's value
|
||||
//--------------------------------
|
||||
|
||||
T & value ();
|
||||
const T & value () const;
|
||||
|
||||
|
||||
//--------------------------------
|
||||
// Get this attribute's type name.
|
||||
//--------------------------------
|
||||
|
||||
virtual const char * typeName () const;
|
||||
|
||||
|
||||
//---------------------------------------------------------
|
||||
// Static version of typeName()
|
||||
// This function must be specialized for each value type T.
|
||||
//---------------------------------------------------------
|
||||
|
||||
static const char * staticTypeName ();
|
||||
|
||||
|
||||
//---------------------
|
||||
// Make a new attribute
|
||||
//---------------------
|
||||
|
||||
static Attribute * makeNewAttribute ();
|
||||
|
||||
|
||||
//------------------------------
|
||||
// Make a copy of this attribute
|
||||
//------------------------------
|
||||
|
||||
virtual Attribute * copy () const;
|
||||
|
||||
|
||||
//-----------------------------------------------------------------
|
||||
// Type-specific attribute I/O and copying.
|
||||
// Depending on type T, these functions may have to be specialized.
|
||||
//-----------------------------------------------------------------
|
||||
|
||||
virtual void writeValueTo (OStream &os,
|
||||
int version) const;
|
||||
|
||||
virtual void readValueFrom (IStream &is,
|
||||
int size,
|
||||
int version);
|
||||
|
||||
virtual void copyValueFrom (const Attribute &other);
|
||||
|
||||
|
||||
//------------------------------------------------------------
|
||||
// Dynamic casts that throw exceptions instead of returning 0.
|
||||
//------------------------------------------------------------
|
||||
|
||||
static TypedAttribute * cast (Attribute *attribute);
|
||||
static const TypedAttribute * cast (const Attribute *attribute);
|
||||
static TypedAttribute & cast (Attribute &attribute);
|
||||
static const TypedAttribute & cast (const Attribute &attribute);
|
||||
|
||||
|
||||
//---------------------------------------------------------------
|
||||
// Register this attribute type so that Attribute::newAttribute()
|
||||
// knows how to make objects of this type.
|
||||
//
|
||||
// Note that this function is not thread-safe because it modifies
|
||||
// a global variable in the IlmIlm library. A thread in a multi-
|
||||
// threaded program may call registerAttributeType() only when no
|
||||
// other thread is accessing any functions or classes in the
|
||||
// IlmImf library.
|
||||
//
|
||||
//---------------------------------------------------------------
|
||||
|
||||
static void registerAttributeType ();
|
||||
|
||||
|
||||
//-----------------------------------------------------
|
||||
// Un-register this attribute type (for debugging only)
|
||||
//-----------------------------------------------------
|
||||
|
||||
static void unRegisterAttributeType ();
|
||||
|
||||
|
||||
private:
|
||||
|
||||
T _value;
|
||||
};
|
||||
|
||||
|
||||
//------------------------------------
|
||||
// Implementation of TypedAttribute<T>
|
||||
//------------------------------------
|
||||
|
||||
template <class T>
|
||||
TypedAttribute<T>::TypedAttribute (): _value (T())
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
TypedAttribute<T>::TypedAttribute (const T &value): _value (value)
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
TypedAttribute<T>::TypedAttribute (const TypedAttribute<T> &other):
|
||||
_value ()
|
||||
{
|
||||
copyValueFrom (other);
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
TypedAttribute<T>::~TypedAttribute ()
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
inline T &
|
||||
TypedAttribute<T>::value ()
|
||||
{
|
||||
return _value;
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
inline const T &
|
||||
TypedAttribute<T>::value () const
|
||||
{
|
||||
return _value;
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
const char *
|
||||
TypedAttribute<T>::typeName () const
|
||||
{
|
||||
return staticTypeName();
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
Attribute *
|
||||
TypedAttribute<T>::makeNewAttribute ()
|
||||
{
|
||||
return new TypedAttribute<T>();
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
Attribute *
|
||||
TypedAttribute<T>::copy () const
|
||||
{
|
||||
Attribute * attribute = new TypedAttribute<T>();
|
||||
attribute->copyValueFrom (*this);
|
||||
return attribute;
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
void
|
||||
TypedAttribute<T>::writeValueTo (OStream &os, int version) const
|
||||
{
|
||||
Xdr::write <StreamIO> (os, _value);
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
void
|
||||
TypedAttribute<T>::readValueFrom (IStream &is, int size, int version)
|
||||
{
|
||||
Xdr::read <StreamIO> (is, _value);
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
void
|
||||
TypedAttribute<T>::copyValueFrom (const Attribute &other)
|
||||
{
|
||||
_value = cast(other)._value;
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
TypedAttribute<T> *
|
||||
TypedAttribute<T>::cast (Attribute *attribute)
|
||||
{
|
||||
TypedAttribute<T> *t =
|
||||
dynamic_cast <TypedAttribute<T> *> (attribute);
|
||||
|
||||
if (t == 0)
|
||||
throw Iex::TypeExc ("Unexpected attribute type.");
|
||||
|
||||
return t;
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
const TypedAttribute<T> *
|
||||
TypedAttribute<T>::cast (const Attribute *attribute)
|
||||
{
|
||||
const TypedAttribute<T> *t =
|
||||
dynamic_cast <const TypedAttribute<T> *> (attribute);
|
||||
|
||||
if (t == 0)
|
||||
throw Iex::TypeExc ("Unexpected attribute type.");
|
||||
|
||||
return t;
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
inline TypedAttribute<T> &
|
||||
TypedAttribute<T>::cast (Attribute &attribute)
|
||||
{
|
||||
return *cast (&attribute);
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
inline const TypedAttribute<T> &
|
||||
TypedAttribute<T>::cast (const Attribute &attribute)
|
||||
{
|
||||
return *cast (&attribute);
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
inline void
|
||||
TypedAttribute<T>::registerAttributeType ()
|
||||
{
|
||||
Attribute::registerAttributeType (staticTypeName(), makeNewAttribute);
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
inline void
|
||||
TypedAttribute<T>::unRegisterAttributeType ()
|
||||
{
|
||||
Attribute::unRegisterAttributeType (staticTypeName());
|
||||
}
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
|
||||
#if defined(OPENEXR_DLL) && defined(_MSC_VER)
|
||||
// Tell MS VC++ to disable "non dll-interface class used as base
|
||||
// for dll-interface class" and "no suitable definition provided
|
||||
// for explicit template"
|
||||
#pragma warning (disable : 4275 4661)
|
||||
|
||||
#if defined (ILMIMF_EXPORTS)
|
||||
#define IMF_EXPIMP_TEMPLATE
|
||||
#else
|
||||
#define IMF_EXPIMP_TEMPLATE extern
|
||||
#endif
|
||||
|
||||
IMF_EXPIMP_TEMPLATE template class Imf::TypedAttribute<float>;
|
||||
IMF_EXPIMP_TEMPLATE template class Imf::TypedAttribute<double>;
|
||||
|
||||
#pragma warning(default : 4251)
|
||||
#undef EXTERN_TEMPLATE
|
||||
#endif
|
||||
|
||||
// Metrowerks compiler wants the .cpp file inlined, too
|
||||
#ifdef __MWERKS__
|
||||
#include <ImfAttribute.cpp>
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -1,93 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
#ifndef INCLUDED_IMF_AUTO_ARRAY_H
|
||||
#define INCLUDED_IMF_AUTO_ARRAY_H
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class AutoArray -- a workaround for systems with
|
||||
// insufficient stack space for large auto arrays.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include "OpenEXRConfig.h"
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
#if !defined (HAVE_LARGE_STACK)
|
||||
|
||||
|
||||
template <class T, int size>
|
||||
class AutoArray
|
||||
{
|
||||
public:
|
||||
|
||||
AutoArray (): _data (new T [size]) {}
|
||||
~AutoArray () {delete [] _data;}
|
||||
|
||||
operator T * () {return _data;}
|
||||
operator const T * () const {return _data;}
|
||||
|
||||
private:
|
||||
|
||||
T *_data;
|
||||
};
|
||||
|
||||
|
||||
#else
|
||||
|
||||
|
||||
template <class T, int size>
|
||||
class AutoArray
|
||||
{
|
||||
public:
|
||||
|
||||
operator T * () {return _data;}
|
||||
operator const T * () const {return _data;}
|
||||
|
||||
private:
|
||||
|
||||
T _data[size];
|
||||
};
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
} // namespace Imf
|
||||
|
||||
#endif
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,117 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2006, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
#ifndef INCLUDED_IMF_B44_COMPRESSOR_H
|
||||
#define INCLUDED_IMF_B44_COMPRESSOR_H
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class B44Compressor -- lossy compression of 4x4 pixel blocks
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfCompressor.h>
|
||||
|
||||
namespace Imf {
|
||||
|
||||
class ChannelList;
|
||||
|
||||
|
||||
class B44Compressor: public Compressor
|
||||
{
|
||||
public:
|
||||
|
||||
B44Compressor (const Header &hdr,
|
||||
int maxScanLineSize,
|
||||
int numScanLines,
|
||||
bool optFlatFields);
|
||||
|
||||
virtual ~B44Compressor ();
|
||||
|
||||
virtual int numScanLines () const;
|
||||
|
||||
virtual Format format () const;
|
||||
|
||||
virtual int compress (const char *inPtr,
|
||||
int inSize,
|
||||
int minY,
|
||||
const char *&outPtr);
|
||||
|
||||
virtual int compressTile (const char *inPtr,
|
||||
int inSize,
|
||||
Imath::Box2i range,
|
||||
const char *&outPtr);
|
||||
|
||||
virtual int uncompress (const char *inPtr,
|
||||
int inSize,
|
||||
int minY,
|
||||
const char *&outPtr);
|
||||
|
||||
virtual int uncompressTile (const char *inPtr,
|
||||
int inSize,
|
||||
Imath::Box2i range,
|
||||
const char *&outPtr);
|
||||
private:
|
||||
|
||||
struct ChannelData;
|
||||
|
||||
int compress (const char *inPtr,
|
||||
int inSize,
|
||||
Imath::Box2i range,
|
||||
const char *&outPtr);
|
||||
|
||||
int uncompress (const char *inPtr,
|
||||
int inSize,
|
||||
Imath::Box2i range,
|
||||
const char *&outPtr);
|
||||
|
||||
int _maxScanLineSize;
|
||||
bool _optFlatFields;
|
||||
Format _format;
|
||||
int _numScanLines;
|
||||
unsigned short * _tmpBuffer;
|
||||
char * _outBuffer;
|
||||
int _numChans;
|
||||
const ChannelList & _channels;
|
||||
ChannelData * _channelData;
|
||||
int _minX;
|
||||
int _maxX;
|
||||
int _maxY;
|
||||
};
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
|
||||
#endif
|
||||
@@ -1,110 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class Box2iAttribute
|
||||
// class Box2fAttribute
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfBoxAttribute.h>
|
||||
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
template <>
|
||||
const char *
|
||||
Box2iAttribute::staticTypeName ()
|
||||
{
|
||||
return "box2i";
|
||||
}
|
||||
|
||||
|
||||
template <>
|
||||
void
|
||||
Box2iAttribute::writeValueTo (OStream &os, int version) const
|
||||
{
|
||||
Xdr::write <StreamIO> (os, _value.min.x);
|
||||
Xdr::write <StreamIO> (os, _value.min.y);
|
||||
Xdr::write <StreamIO> (os, _value.max.x);
|
||||
Xdr::write <StreamIO> (os, _value.max.y);
|
||||
}
|
||||
|
||||
|
||||
template <>
|
||||
void
|
||||
Box2iAttribute::readValueFrom (IStream &is, int size, int version)
|
||||
{
|
||||
Xdr::read <StreamIO> (is, _value.min.x);
|
||||
Xdr::read <StreamIO> (is, _value.min.y);
|
||||
Xdr::read <StreamIO> (is, _value.max.x);
|
||||
Xdr::read <StreamIO> (is, _value.max.y);
|
||||
}
|
||||
|
||||
|
||||
template <>
|
||||
const char *
|
||||
Box2fAttribute::staticTypeName ()
|
||||
{
|
||||
return "box2f";
|
||||
}
|
||||
|
||||
|
||||
template <>
|
||||
void
|
||||
Box2fAttribute::writeValueTo (OStream &os, int version) const
|
||||
{
|
||||
Xdr::write <StreamIO> (os, _value.min.x);
|
||||
Xdr::write <StreamIO> (os, _value.min.y);
|
||||
Xdr::write <StreamIO> (os, _value.max.x);
|
||||
Xdr::write <StreamIO> (os, _value.max.y);
|
||||
}
|
||||
|
||||
|
||||
template <>
|
||||
void
|
||||
Box2fAttribute::readValueFrom (IStream &is, int size, int version)
|
||||
{
|
||||
Xdr::read <StreamIO> (is, _value.min.x);
|
||||
Xdr::read <StreamIO> (is, _value.min.y);
|
||||
Xdr::read <StreamIO> (is, _value.max.x);
|
||||
Xdr::read <StreamIO> (is, _value.max.y);
|
||||
}
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
@@ -1,73 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
#ifndef INCLUDED_IMF_BOX_ATTRIBUTE_H
|
||||
#define INCLUDED_IMF_BOX_ATTRIBUTE_H
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class Box2iAttribute
|
||||
// class Box2fAttribute
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfAttribute.h>
|
||||
#include "ImathBox.h"
|
||||
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
typedef TypedAttribute<Imath::Box2i> Box2iAttribute;
|
||||
template <> const char *Box2iAttribute::staticTypeName ();
|
||||
template <> void Box2iAttribute::writeValueTo (OStream &, int) const;
|
||||
template <> void Box2iAttribute::readValueFrom (IStream &, int, int);
|
||||
|
||||
|
||||
typedef TypedAttribute<Imath::Box2f> Box2fAttribute;
|
||||
template <> const char *Box2fAttribute::staticTypeName ();
|
||||
template <> void Box2fAttribute::writeValueTo (OStream &, int) const;
|
||||
template <> void Box2fAttribute::readValueFrom (IStream &, int, int);
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
|
||||
// Metrowerks compiler wants the .cpp file inlined, too
|
||||
#ifdef __MWERKS__
|
||||
#include <ImfBoxAttribute.cpp>
|
||||
#endif
|
||||
|
||||
#endif
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,467 +0,0 @@
|
||||
/*
|
||||
|
||||
Copyright (c) 2002, 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.
|
||||
|
||||
*/
|
||||
|
||||
#ifndef INCLUDED_IMF_C_RGBA_FILE_H
|
||||
#define INCLUDED_IMF_C_RGBA_FILE_H
|
||||
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/*
|
||||
** Interpreting unsigned shorts as 16-bit floating point numbers
|
||||
*/
|
||||
|
||||
typedef unsigned short ImfHalf;
|
||||
|
||||
void ImfFloatToHalf (float f,
|
||||
ImfHalf *h);
|
||||
|
||||
void ImfFloatToHalfArray (int n,
|
||||
const float f[/*n*/],
|
||||
ImfHalf h[/*n*/]);
|
||||
|
||||
float ImfHalfToFloat (ImfHalf h);
|
||||
|
||||
void ImfHalfToFloatArray (int n,
|
||||
const ImfHalf h[/*n*/],
|
||||
float f[/*n*/]);
|
||||
|
||||
/*
|
||||
** RGBA pixel; memory layout must be the same as struct Imf::Rgba.
|
||||
*/
|
||||
|
||||
struct ImfRgba
|
||||
{
|
||||
ImfHalf r;
|
||||
ImfHalf g;
|
||||
ImfHalf b;
|
||||
ImfHalf a;
|
||||
};
|
||||
|
||||
typedef struct ImfRgba ImfRgba;
|
||||
|
||||
/*
|
||||
** Magic number; this must be the same as Imf::MAGIC
|
||||
*/
|
||||
|
||||
#define IMF_MAGIC 20000630
|
||||
|
||||
/*
|
||||
** Version number; this must be the same as Imf::EXR_VERSION
|
||||
*/
|
||||
|
||||
#define IMF_VERSION_NUMBER 2
|
||||
|
||||
/*
|
||||
** Line order; values must the the same as in Imf::LineOrder.
|
||||
*/
|
||||
|
||||
#define IMF_INCREASING_Y 0
|
||||
#define IMF_DECREASING_Y 1
|
||||
#define IMF_RAMDOM_Y 2
|
||||
|
||||
|
||||
/*
|
||||
** Compression types; values must be the same as in Imf::Compression.
|
||||
*/
|
||||
|
||||
#define IMF_NO_COMPRESSION 0
|
||||
#define IMF_RLE_COMPRESSION 1
|
||||
#define IMF_ZIPS_COMPRESSION 2
|
||||
#define IMF_ZIP_COMPRESSION 3
|
||||
#define IMF_PIZ_COMPRESSION 4
|
||||
#define IMF_PXR24_COMPRESSION 5
|
||||
#define IMF_B44_COMPRESSION 6
|
||||
#define IMF_B44A_COMPRESSION 7
|
||||
|
||||
|
||||
/*
|
||||
** Channels; values must be the same as in Imf::RgbaChannels.
|
||||
*/
|
||||
|
||||
#define IMF_WRITE_R 0x01
|
||||
#define IMF_WRITE_G 0x02
|
||||
#define IMF_WRITE_B 0x04
|
||||
#define IMF_WRITE_A 0x08
|
||||
#define IMF_WRITE_Y 0x10
|
||||
#define IMF_WRITE_C 0x20
|
||||
#define IMF_WRITE_RGB 0x07
|
||||
#define IMF_WRITE_RGBA 0x0f
|
||||
#define IMF_WRITE_YC 0x30
|
||||
#define IMF_WRITE_YA 0x18
|
||||
#define IMF_WRITE_YCA 0x38
|
||||
|
||||
|
||||
/*
|
||||
** Level modes; values must be the same as in Imf::LevelMode
|
||||
*/
|
||||
|
||||
#define IMF_ONE_LEVEL 0
|
||||
#define IMF_MIPMAP_LEVELS 1
|
||||
#define IMF_RIPMAP_LEVELS 2
|
||||
|
||||
|
||||
/*
|
||||
** Level rounding modes; values must be the same as in Imf::LevelRoundingMode
|
||||
*/
|
||||
|
||||
#define IMF_ROUND_DOWN 0
|
||||
#define IMF_ROUND_UP 1
|
||||
|
||||
|
||||
/*
|
||||
** RGBA file header
|
||||
*/
|
||||
|
||||
struct ImfHeader;
|
||||
typedef struct ImfHeader ImfHeader;
|
||||
|
||||
ImfHeader * ImfNewHeader (void);
|
||||
|
||||
void ImfDeleteHeader (ImfHeader *hdr);
|
||||
|
||||
ImfHeader * ImfCopyHeader (const ImfHeader *hdr);
|
||||
|
||||
void ImfHeaderSetDisplayWindow (ImfHeader *hdr,
|
||||
int xMin, int yMin,
|
||||
int xMax, int yMax);
|
||||
|
||||
void ImfHeaderDisplayWindow (const ImfHeader *hdr,
|
||||
int *xMin, int *yMin,
|
||||
int *xMax, int *yMax);
|
||||
|
||||
void ImfHeaderSetDataWindow (ImfHeader *hdr,
|
||||
int xMin, int yMin,
|
||||
int xMax, int yMax);
|
||||
|
||||
void ImfHeaderDataWindow (const ImfHeader *hdr,
|
||||
int *xMin, int *yMin,
|
||||
int *xMax, int *yMax);
|
||||
|
||||
void ImfHeaderSetPixelAspectRatio (ImfHeader *hdr,
|
||||
float pixelAspectRatio);
|
||||
|
||||
float ImfHeaderPixelAspectRatio (const ImfHeader *hdr);
|
||||
|
||||
void ImfHeaderSetScreenWindowCenter (ImfHeader *hdr,
|
||||
float x, float y);
|
||||
|
||||
void ImfHeaderScreenWindowCenter (const ImfHeader *hdr,
|
||||
float *x, float *y);
|
||||
|
||||
void ImfHeaderSetScreenWindowWidth (ImfHeader *hdr,
|
||||
float width);
|
||||
|
||||
float ImfHeaderScreenWindowWidth (const ImfHeader *hdr);
|
||||
|
||||
void ImfHeaderSetLineOrder (ImfHeader *hdr,
|
||||
int lineOrder);
|
||||
|
||||
int ImfHeaderLineOrder (const ImfHeader *hdr);
|
||||
|
||||
void ImfHeaderSetCompression (ImfHeader *hdr,
|
||||
int compression);
|
||||
|
||||
int ImfHeaderCompression (const ImfHeader *hdr);
|
||||
|
||||
int ImfHeaderSetIntAttribute (ImfHeader *hdr,
|
||||
const char name[],
|
||||
int value);
|
||||
|
||||
int ImfHeaderIntAttribute (const ImfHeader *hdr,
|
||||
const char name[],
|
||||
int *value);
|
||||
|
||||
int ImfHeaderSetFloatAttribute (ImfHeader *hdr,
|
||||
const char name[],
|
||||
float value);
|
||||
|
||||
int ImfHeaderSetDoubleAttribute (ImfHeader *hdr,
|
||||
const char name[],
|
||||
double value);
|
||||
|
||||
int ImfHeaderFloatAttribute (const ImfHeader *hdr,
|
||||
const char name[],
|
||||
float *value);
|
||||
|
||||
int ImfHeaderDoubleAttribute (const ImfHeader *hdr,
|
||||
const char name[],
|
||||
double *value);
|
||||
|
||||
int ImfHeaderSetStringAttribute (ImfHeader *hdr,
|
||||
const char name[],
|
||||
const char value[]);
|
||||
|
||||
int ImfHeaderStringAttribute (const ImfHeader *hdr,
|
||||
const char name[],
|
||||
const char **value);
|
||||
|
||||
int ImfHeaderSetBox2iAttribute (ImfHeader *hdr,
|
||||
const char name[],
|
||||
int xMin, int yMin,
|
||||
int xMax, int yMax);
|
||||
|
||||
int ImfHeaderBox2iAttribute (const ImfHeader *hdr,
|
||||
const char name[],
|
||||
int *xMin, int *yMin,
|
||||
int *xMax, int *yMax);
|
||||
|
||||
int ImfHeaderSetBox2fAttribute (ImfHeader *hdr,
|
||||
const char name[],
|
||||
float xMin, float yMin,
|
||||
float xMax, float yMax);
|
||||
|
||||
int ImfHeaderBox2fAttribute (const ImfHeader *hdr,
|
||||
const char name[],
|
||||
float *xMin, float *yMin,
|
||||
float *xMax, float *yMax);
|
||||
|
||||
int ImfHeaderSetV2iAttribute (ImfHeader *hdr,
|
||||
const char name[],
|
||||
int x, int y);
|
||||
|
||||
int ImfHeaderV2iAttribute (const ImfHeader *hdr,
|
||||
const char name[],
|
||||
int *x, int *y);
|
||||
|
||||
int ImfHeaderSetV2fAttribute (ImfHeader *hdr,
|
||||
const char name[],
|
||||
float x, float y);
|
||||
|
||||
int ImfHeaderV2fAttribute (const ImfHeader *hdr,
|
||||
const char name[],
|
||||
float *x, float *y);
|
||||
|
||||
int ImfHeaderSetV3iAttribute (ImfHeader *hdr,
|
||||
const char name[],
|
||||
int x, int y, int z);
|
||||
|
||||
int ImfHeaderV3iAttribute (const ImfHeader *hdr,
|
||||
const char name[],
|
||||
int *x, int *y, int *z);
|
||||
|
||||
int ImfHeaderSetV3fAttribute (ImfHeader *hdr,
|
||||
const char name[],
|
||||
float x, float y, float z);
|
||||
|
||||
int ImfHeaderV3fAttribute (const ImfHeader *hdr,
|
||||
const char name[],
|
||||
float *x, float *y, float *z);
|
||||
|
||||
int ImfHeaderSetM33fAttribute (ImfHeader *hdr,
|
||||
const char name[],
|
||||
const float m[3][3]);
|
||||
|
||||
int ImfHeaderM33fAttribute (const ImfHeader *hdr,
|
||||
const char name[],
|
||||
float m[3][3]);
|
||||
|
||||
int ImfHeaderSetM44fAttribute (ImfHeader *hdr,
|
||||
const char name[],
|
||||
const float m[4][4]);
|
||||
|
||||
int ImfHeaderM44fAttribute (const ImfHeader *hdr,
|
||||
const char name[],
|
||||
float m[4][4]);
|
||||
|
||||
/*
|
||||
** RGBA output file
|
||||
*/
|
||||
|
||||
struct ImfOutputFile;
|
||||
typedef struct ImfOutputFile ImfOutputFile;
|
||||
|
||||
ImfOutputFile * ImfOpenOutputFile (const char name[],
|
||||
const ImfHeader *hdr,
|
||||
int channels);
|
||||
|
||||
int ImfCloseOutputFile (ImfOutputFile *out);
|
||||
|
||||
int ImfOutputSetFrameBuffer (ImfOutputFile *out,
|
||||
const ImfRgba *base,
|
||||
size_t xStride,
|
||||
size_t yStride);
|
||||
|
||||
int ImfOutputWritePixels (ImfOutputFile *out,
|
||||
int numScanLines);
|
||||
|
||||
int ImfOutputCurrentScanLine (const ImfOutputFile *out);
|
||||
|
||||
const ImfHeader * ImfOutputHeader (const ImfOutputFile *out);
|
||||
|
||||
int ImfOutputChannels (const ImfOutputFile *out);
|
||||
|
||||
|
||||
/*
|
||||
** Tiled RGBA output file
|
||||
*/
|
||||
|
||||
struct ImfTiledOutputFile;
|
||||
typedef struct ImfTiledOutputFile ImfTiledOutputFile;
|
||||
|
||||
ImfTiledOutputFile * ImfOpenTiledOutputFile (const char name[],
|
||||
const ImfHeader *hdr,
|
||||
int channels,
|
||||
int xSize, int ySize,
|
||||
int mode, int rmode);
|
||||
|
||||
int ImfCloseTiledOutputFile (ImfTiledOutputFile *out);
|
||||
|
||||
int ImfTiledOutputSetFrameBuffer (ImfTiledOutputFile *out,
|
||||
const ImfRgba *base,
|
||||
size_t xStride,
|
||||
size_t yStride);
|
||||
|
||||
int ImfTiledOutputWriteTile (ImfTiledOutputFile *out,
|
||||
int dx, int dy,
|
||||
int lx, int ly);
|
||||
|
||||
int ImfTiledOutputWriteTiles (ImfTiledOutputFile *out,
|
||||
int dxMin, int dxMax,
|
||||
int dyMin, int dyMax,
|
||||
int lx, int ly);
|
||||
|
||||
const ImfHeader * ImfTiledOutputHeader (const ImfTiledOutputFile *out);
|
||||
|
||||
int ImfTiledOutputChannels (const ImfTiledOutputFile *out);
|
||||
|
||||
int ImfTiledOutputTileXSize (const ImfTiledOutputFile *out);
|
||||
|
||||
int ImfTiledOutputTileYSize (const ImfTiledOutputFile *out);
|
||||
|
||||
int ImfTiledOutputLevelMode (const ImfTiledOutputFile *out);
|
||||
int ImfTiledOutputLevelRoundingMode
|
||||
(const ImfTiledOutputFile *out);
|
||||
|
||||
|
||||
/*
|
||||
** RGBA input file
|
||||
*/
|
||||
|
||||
struct ImfInputFile;
|
||||
typedef struct ImfInputFile ImfInputFile;
|
||||
|
||||
ImfInputFile * ImfOpenInputFile (const char name[]);
|
||||
|
||||
int ImfCloseInputFile (ImfInputFile *in);
|
||||
|
||||
int ImfInputSetFrameBuffer (ImfInputFile *in,
|
||||
ImfRgba *base,
|
||||
size_t xStride,
|
||||
size_t yStride);
|
||||
|
||||
int ImfInputReadPixels (ImfInputFile *in,
|
||||
int scanLine1,
|
||||
int scanLine2);
|
||||
|
||||
const ImfHeader * ImfInputHeader (const ImfInputFile *in);
|
||||
|
||||
int ImfInputChannels (const ImfInputFile *in);
|
||||
|
||||
const char * ImfInputFileName (const ImfInputFile *in);
|
||||
|
||||
|
||||
/*
|
||||
** Tiled RGBA input file
|
||||
*/
|
||||
|
||||
struct ImfTiledInputFile;
|
||||
typedef struct ImfTiledInputFile ImfTiledInputFile;
|
||||
|
||||
ImfTiledInputFile * ImfOpenTiledInputFile (const char name[]);
|
||||
|
||||
int ImfCloseTiledInputFile (ImfTiledInputFile *in);
|
||||
|
||||
int ImfTiledInputSetFrameBuffer (ImfTiledInputFile *in,
|
||||
ImfRgba *base,
|
||||
size_t xStride,
|
||||
size_t yStride);
|
||||
|
||||
int ImfTiledInputReadTile (ImfTiledInputFile *in,
|
||||
int dx, int dy,
|
||||
int lx, int ly);
|
||||
|
||||
int ImfTiledInputReadTiles (ImfTiledInputFile *in,
|
||||
int dxMin, int dxMax,
|
||||
int dyMin, int dyMax,
|
||||
int lx, int ly);
|
||||
|
||||
const ImfHeader * ImfTiledInputHeader (const ImfTiledInputFile *in);
|
||||
|
||||
int ImfTiledInputChannels (const ImfTiledInputFile *in);
|
||||
|
||||
const char * ImfTiledInputFileName (const ImfTiledInputFile *in);
|
||||
|
||||
int ImfTiledInputTileXSize (const ImfTiledInputFile *in);
|
||||
|
||||
int ImfTiledInputTileYSize (const ImfTiledInputFile *in);
|
||||
|
||||
int ImfTiledInputLevelMode (const ImfTiledInputFile *in);
|
||||
|
||||
int ImfTiledInputLevelRoundingMode
|
||||
(const ImfTiledInputFile *in);
|
||||
|
||||
/*
|
||||
** Lookup tables
|
||||
*/
|
||||
|
||||
struct ImfLut;
|
||||
typedef struct ImfLut ImfLut;
|
||||
|
||||
ImfLut * ImfNewRound12logLut (int channels);
|
||||
|
||||
ImfLut * ImfNewRoundNBitLut (unsigned int n, int channels);
|
||||
|
||||
void ImfDeleteLut (ImfLut *lut);
|
||||
|
||||
void ImfApplyLut (ImfLut *lut,
|
||||
ImfRgba *data,
|
||||
int nData,
|
||||
int stride);
|
||||
/*
|
||||
** Most recent error message
|
||||
*/
|
||||
|
||||
const char * ImfErrorMessage (void);
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -1,254 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class Channel
|
||||
// class ChannelList
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfChannelList.h>
|
||||
#include <Iex.h>
|
||||
|
||||
|
||||
using std::string;
|
||||
using std::set;
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
Channel::Channel (PixelType t, int xs, int ys, bool pl):
|
||||
type (t),
|
||||
xSampling (xs),
|
||||
ySampling (ys),
|
||||
pLinear (pl)
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
|
||||
bool
|
||||
Channel::operator == (const Channel &other) const
|
||||
{
|
||||
return type == other.type &&
|
||||
xSampling == other.xSampling &&
|
||||
ySampling == other.ySampling &&
|
||||
pLinear == other.pLinear;
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
ChannelList::insert (const char name[], const Channel &channel)
|
||||
{
|
||||
if (name[0] == 0)
|
||||
THROW (Iex::ArgExc, "Image channel name cannot be an empty string.");
|
||||
|
||||
_map[name] = channel;
|
||||
}
|
||||
|
||||
|
||||
Channel &
|
||||
ChannelList::operator [] (const char name[])
|
||||
{
|
||||
ChannelMap::iterator i = _map.find (name);
|
||||
|
||||
if (i == _map.end())
|
||||
THROW (Iex::ArgExc, "Cannot find image channel \"" << name << "\".");
|
||||
|
||||
return i->second;
|
||||
}
|
||||
|
||||
|
||||
const Channel &
|
||||
ChannelList::operator [] (const char name[]) const
|
||||
{
|
||||
ChannelMap::const_iterator i = _map.find (name);
|
||||
|
||||
if (i == _map.end())
|
||||
THROW (Iex::ArgExc, "Cannot find image channel \"" << name << "\".");
|
||||
|
||||
return i->second;
|
||||
}
|
||||
|
||||
|
||||
Channel *
|
||||
ChannelList::findChannel (const char name[])
|
||||
{
|
||||
ChannelMap::iterator i = _map.find (name);
|
||||
return (i == _map.end())? 0: &i->second;
|
||||
}
|
||||
|
||||
|
||||
const Channel *
|
||||
ChannelList::findChannel (const char name[]) const
|
||||
{
|
||||
ChannelMap::const_iterator i = _map.find (name);
|
||||
return (i == _map.end())? 0: &i->second;
|
||||
}
|
||||
|
||||
|
||||
ChannelList::Iterator
|
||||
ChannelList::begin ()
|
||||
{
|
||||
return _map.begin();
|
||||
}
|
||||
|
||||
|
||||
ChannelList::ConstIterator
|
||||
ChannelList::begin () const
|
||||
{
|
||||
return _map.begin();
|
||||
}
|
||||
|
||||
|
||||
ChannelList::Iterator
|
||||
ChannelList::end ()
|
||||
{
|
||||
return _map.end();
|
||||
}
|
||||
|
||||
|
||||
ChannelList::ConstIterator
|
||||
ChannelList::end () const
|
||||
{
|
||||
return _map.end();
|
||||
}
|
||||
|
||||
|
||||
ChannelList::Iterator
|
||||
ChannelList::find (const char name[])
|
||||
{
|
||||
return _map.find (name);
|
||||
}
|
||||
|
||||
|
||||
ChannelList::ConstIterator
|
||||
ChannelList::find (const char name[]) const
|
||||
{
|
||||
return _map.find (name);
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
ChannelList::layers (set <string> &layerNames) const
|
||||
{
|
||||
layerNames.clear();
|
||||
|
||||
for (ConstIterator i = begin(); i != end(); ++i)
|
||||
{
|
||||
string layerName = i.name();
|
||||
size_t pos = layerName.rfind ('.');
|
||||
|
||||
if (pos != string::npos && pos != 0 && pos + 1 < layerName.size())
|
||||
{
|
||||
layerName.erase (pos);
|
||||
layerNames.insert (layerName);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
ChannelList::channelsInLayer (const string &layerName,
|
||||
Iterator &first,
|
||||
Iterator &last)
|
||||
{
|
||||
channelsWithPrefix ((layerName + '.').c_str(), first, last);
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
ChannelList::channelsInLayer (const string &layerName,
|
||||
ConstIterator &first,
|
||||
ConstIterator &last) const
|
||||
{
|
||||
channelsWithPrefix ((layerName + '.').c_str(), first, last);
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
ChannelList::channelsWithPrefix (const char prefix[],
|
||||
Iterator &first,
|
||||
Iterator &last)
|
||||
{
|
||||
first = last = _map.lower_bound (prefix);
|
||||
int n = strlen (prefix);
|
||||
|
||||
while (last != Iterator (_map.end()) &&
|
||||
strncmp (last.name(), prefix, n) <= 0)
|
||||
{
|
||||
++last;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
ChannelList::channelsWithPrefix (const char prefix[],
|
||||
ConstIterator &first,
|
||||
ConstIterator &last) const
|
||||
{
|
||||
first = last = _map.lower_bound (prefix);
|
||||
int n = strlen (prefix);
|
||||
|
||||
while (last != ConstIterator (_map.end()) &&
|
||||
strncmp (last.name(), prefix, n) <= 0)
|
||||
{
|
||||
++last;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
bool
|
||||
ChannelList::operator == (const ChannelList &other) const
|
||||
{
|
||||
ConstIterator i = begin();
|
||||
ConstIterator j = other.begin();
|
||||
|
||||
while (i != end() && j != other.end())
|
||||
{
|
||||
if (!(i.channel() == j.channel()))
|
||||
return false;
|
||||
|
||||
++i;
|
||||
++j;
|
||||
}
|
||||
|
||||
return i == end() && j == other.end();
|
||||
}
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
@@ -1,411 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
#ifndef INCLUDED_IMF_CHANNEL_LIST_H
|
||||
#define INCLUDED_IMF_CHANNEL_LIST_H
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class Channel
|
||||
// class ChannelList
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfName.h>
|
||||
#include <ImfPixelType.h>
|
||||
#include <map>
|
||||
#include <set>
|
||||
#include <string>
|
||||
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
struct Channel
|
||||
{
|
||||
//------------------------------
|
||||
// Data type; see ImfPixelType.h
|
||||
//------------------------------
|
||||
|
||||
PixelType type;
|
||||
|
||||
|
||||
//--------------------------------------------
|
||||
// Subsampling: pixel (x, y) is present in the
|
||||
// channel only if
|
||||
//
|
||||
// x % xSampling == 0 && y % ySampling == 0
|
||||
//
|
||||
//--------------------------------------------
|
||||
|
||||
int xSampling;
|
||||
int ySampling;
|
||||
|
||||
|
||||
//--------------------------------------------------------------
|
||||
// Hint to lossy compression methods that indicates whether
|
||||
// human perception of the quantity represented by this channel
|
||||
// is closer to linear or closer to logarithmic. Compression
|
||||
// methods may optimize image quality by adjusting pixel data
|
||||
// quantization acording to this hint.
|
||||
// For example, perception of red, green, blue and luminance is
|
||||
// approximately logarithmic; the difference between 0.1 and 0.2
|
||||
// is perceived to be roughly the same as the difference between
|
||||
// 1.0 and 2.0. Perception of chroma coordinates tends to be
|
||||
// closer to linear than logarithmic; the difference between 0.1
|
||||
// and 0.2 is perceived to be roughly the same as the difference
|
||||
// between 1.0 and 1.1.
|
||||
//--------------------------------------------------------------
|
||||
|
||||
bool pLinear;
|
||||
|
||||
|
||||
//------------
|
||||
// Constructor
|
||||
//------------
|
||||
|
||||
Channel (PixelType type = HALF,
|
||||
int xSampling = 1,
|
||||
int ySampling = 1,
|
||||
bool pLinear = false);
|
||||
|
||||
|
||||
//------------
|
||||
// Operator ==
|
||||
//------------
|
||||
|
||||
bool operator == (const Channel &other) const;
|
||||
};
|
||||
|
||||
|
||||
class ChannelList
|
||||
{
|
||||
public:
|
||||
|
||||
//--------------
|
||||
// Add a channel
|
||||
//--------------
|
||||
|
||||
void insert (const char name[],
|
||||
const Channel &channel);
|
||||
|
||||
//------------------------------------------------------------------
|
||||
// Access to existing channels:
|
||||
//
|
||||
// [n] Returns a reference to the channel with name n.
|
||||
// If no channel with name n exists, an Iex::ArgExc
|
||||
// is thrown.
|
||||
//
|
||||
// findChannel(n) Returns a pointer to the channel with name n,
|
||||
// or 0 if no channel with name n exists.
|
||||
//
|
||||
//------------------------------------------------------------------
|
||||
|
||||
Channel & operator [] (const char name[]);
|
||||
const Channel & operator [] (const char name[]) const;
|
||||
|
||||
Channel * findChannel (const char name[]);
|
||||
const Channel * findChannel (const char name[]) const;
|
||||
|
||||
|
||||
//-------------------------------------------
|
||||
// Iterator-style access to existing channels
|
||||
//-------------------------------------------
|
||||
|
||||
typedef std::map <Name, Channel> ChannelMap;
|
||||
|
||||
class Iterator;
|
||||
class ConstIterator;
|
||||
|
||||
Iterator begin ();
|
||||
ConstIterator begin () const;
|
||||
Iterator end ();
|
||||
ConstIterator end () const;
|
||||
Iterator find (const char name[]);
|
||||
ConstIterator find (const char name[]) const;
|
||||
|
||||
|
||||
//-----------------------------------------------------------------
|
||||
// Support for image layers:
|
||||
//
|
||||
// In an image file with many channels it is sometimes useful to
|
||||
// group the channels into "layers", that is, into sets of channels
|
||||
// that logically belong together. Grouping channels into layers
|
||||
// is done using a naming convention: channel C in layer L is
|
||||
// called "L.C".
|
||||
//
|
||||
// For example, a computer graphic image may contain separate
|
||||
// R, G and B channels for light that originated at each of
|
||||
// several different virtual light sources. The channels in
|
||||
// this image might be called "light1.R", "light1.G", "light1.B",
|
||||
// "light2.R", "light2.G", "light2.B", etc.
|
||||
//
|
||||
// Note that this naming convention allows layers to be nested;
|
||||
// for example, "light1.specular.R" identifies the "R" channel
|
||||
// in the "specular" sub-layer of layer "light1".
|
||||
//
|
||||
// Channel names that don't contain a "." or that contain a
|
||||
// "." only at the beginning or at the end are not considered
|
||||
// to be part of any layer.
|
||||
//
|
||||
// layers(lns) sorts the channels in this ChannelList
|
||||
// into layers and stores the names of
|
||||
// all layers, sorted alphabetically,
|
||||
// into string set lns.
|
||||
//
|
||||
// channelsInLayer(ln,f,l) stores a pair of iterators in f and l
|
||||
// such that the loop
|
||||
//
|
||||
// for (ConstIterator i = f; i != l; ++i)
|
||||
// ...
|
||||
//
|
||||
// iterates over all channels in layer ln.
|
||||
// channelsInLayer (ln, l, p) calls
|
||||
// channelsWithPrefix (ln + ".", l, p).
|
||||
//
|
||||
//-----------------------------------------------------------------
|
||||
|
||||
void layers (std::set <std::string> &layerNames) const;
|
||||
|
||||
void channelsInLayer (const std::string &layerName,
|
||||
Iterator &first,
|
||||
Iterator &last);
|
||||
|
||||
void channelsInLayer (const std::string &layerName,
|
||||
ConstIterator &first,
|
||||
ConstIterator &last) const;
|
||||
|
||||
|
||||
//-------------------------------------------------------------------
|
||||
// Find all channels whose name begins with a given prefix:
|
||||
//
|
||||
// channelsWithPrefix(p,f,l) stores a pair of iterators in f and l
|
||||
// such that the following loop iterates over all channels whose name
|
||||
// begins with string p:
|
||||
//
|
||||
// for (ConstIterator i = f; i != l; ++i)
|
||||
// ...
|
||||
//
|
||||
//-------------------------------------------------------------------
|
||||
|
||||
void channelsWithPrefix (const char prefix[],
|
||||
Iterator &first,
|
||||
Iterator &last);
|
||||
|
||||
void channelsWithPrefix (const char prefix[],
|
||||
ConstIterator &first,
|
||||
ConstIterator &last) const;
|
||||
|
||||
//------------
|
||||
// Operator ==
|
||||
//------------
|
||||
|
||||
bool operator == (const ChannelList &other) const;
|
||||
|
||||
private:
|
||||
|
||||
ChannelMap _map;
|
||||
};
|
||||
|
||||
|
||||
//----------
|
||||
// Iterators
|
||||
//----------
|
||||
|
||||
class ChannelList::Iterator
|
||||
{
|
||||
public:
|
||||
|
||||
Iterator ();
|
||||
Iterator (const ChannelList::ChannelMap::iterator &i);
|
||||
|
||||
Iterator & operator ++ ();
|
||||
Iterator operator ++ (int);
|
||||
|
||||
const char * name () const;
|
||||
Channel & channel () const;
|
||||
|
||||
private:
|
||||
|
||||
friend class ChannelList::ConstIterator;
|
||||
|
||||
ChannelList::ChannelMap::iterator _i;
|
||||
};
|
||||
|
||||
|
||||
class ChannelList::ConstIterator
|
||||
{
|
||||
public:
|
||||
|
||||
ConstIterator ();
|
||||
ConstIterator (const ChannelList::ChannelMap::const_iterator &i);
|
||||
ConstIterator (const ChannelList::Iterator &other);
|
||||
|
||||
ConstIterator & operator ++ ();
|
||||
ConstIterator operator ++ (int);
|
||||
|
||||
const char * name () const;
|
||||
const Channel & channel () const;
|
||||
|
||||
private:
|
||||
|
||||
friend bool operator == (const ConstIterator &, const ConstIterator &);
|
||||
friend bool operator != (const ConstIterator &, const ConstIterator &);
|
||||
|
||||
ChannelList::ChannelMap::const_iterator _i;
|
||||
};
|
||||
|
||||
|
||||
//-----------------
|
||||
// Inline Functions
|
||||
//-----------------
|
||||
|
||||
inline
|
||||
ChannelList::Iterator::Iterator (): _i()
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
|
||||
inline
|
||||
ChannelList::Iterator::Iterator (const ChannelList::ChannelMap::iterator &i):
|
||||
_i (i)
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
|
||||
inline ChannelList::Iterator &
|
||||
ChannelList::Iterator::operator ++ ()
|
||||
{
|
||||
++_i;
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
inline ChannelList::Iterator
|
||||
ChannelList::Iterator::operator ++ (int)
|
||||
{
|
||||
Iterator tmp = *this;
|
||||
++_i;
|
||||
return tmp;
|
||||
}
|
||||
|
||||
|
||||
inline const char *
|
||||
ChannelList::Iterator::name () const
|
||||
{
|
||||
return *_i->first;
|
||||
}
|
||||
|
||||
|
||||
inline Channel &
|
||||
ChannelList::Iterator::channel () const
|
||||
{
|
||||
return _i->second;
|
||||
}
|
||||
|
||||
|
||||
inline
|
||||
ChannelList::ConstIterator::ConstIterator (): _i()
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
inline
|
||||
ChannelList::ConstIterator::ConstIterator
|
||||
(const ChannelList::ChannelMap::const_iterator &i): _i (i)
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
|
||||
inline
|
||||
ChannelList::ConstIterator::ConstIterator (const ChannelList::Iterator &other):
|
||||
_i (other._i)
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
inline ChannelList::ConstIterator &
|
||||
ChannelList::ConstIterator::operator ++ ()
|
||||
{
|
||||
++_i;
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
inline ChannelList::ConstIterator
|
||||
ChannelList::ConstIterator::operator ++ (int)
|
||||
{
|
||||
ConstIterator tmp = *this;
|
||||
++_i;
|
||||
return tmp;
|
||||
}
|
||||
|
||||
|
||||
inline const char *
|
||||
ChannelList::ConstIterator::name () const
|
||||
{
|
||||
return *_i->first;
|
||||
}
|
||||
|
||||
inline const Channel &
|
||||
ChannelList::ConstIterator::channel () const
|
||||
{
|
||||
return _i->second;
|
||||
}
|
||||
|
||||
|
||||
inline bool
|
||||
operator == (const ChannelList::ConstIterator &x,
|
||||
const ChannelList::ConstIterator &y)
|
||||
{
|
||||
return x._i == y._i;
|
||||
}
|
||||
|
||||
|
||||
inline bool
|
||||
operator != (const ChannelList::ConstIterator &x,
|
||||
const ChannelList::ConstIterator &y)
|
||||
{
|
||||
return !(x == y);
|
||||
}
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
|
||||
#endif
|
||||
@@ -1,127 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class ChannelListAttribute
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfChannelListAttribute.h>
|
||||
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
template <>
|
||||
const char *
|
||||
ChannelListAttribute::staticTypeName ()
|
||||
{
|
||||
return "chlist";
|
||||
}
|
||||
|
||||
|
||||
template <>
|
||||
void
|
||||
ChannelListAttribute::writeValueTo (OStream &os, int version) const
|
||||
{
|
||||
for (ChannelList::ConstIterator i = _value.begin();
|
||||
i != _value.end();
|
||||
++i)
|
||||
{
|
||||
//
|
||||
// Write name
|
||||
//
|
||||
|
||||
Xdr::write <StreamIO> (os, i.name());
|
||||
|
||||
//
|
||||
// Write Channel struct
|
||||
//
|
||||
|
||||
Xdr::write <StreamIO> (os, int (i.channel().type));
|
||||
Xdr::write <StreamIO> (os, i.channel().pLinear);
|
||||
Xdr::pad <StreamIO> (os, 3);
|
||||
Xdr::write <StreamIO> (os, i.channel().xSampling);
|
||||
Xdr::write <StreamIO> (os, i.channel().ySampling);
|
||||
}
|
||||
|
||||
//
|
||||
// Write end of list marker
|
||||
//
|
||||
|
||||
Xdr::write <StreamIO> (os, "");
|
||||
}
|
||||
|
||||
|
||||
template <>
|
||||
void
|
||||
ChannelListAttribute::readValueFrom (IStream &is, int size, int version)
|
||||
{
|
||||
while (true)
|
||||
{
|
||||
//
|
||||
// Read name; zero length name means end of channel list
|
||||
//
|
||||
|
||||
char name[Name::SIZE];
|
||||
Xdr::read <StreamIO> (is, sizeof (name), name);
|
||||
|
||||
if (name[0] == 0)
|
||||
break;
|
||||
|
||||
//
|
||||
// Read Channel struct
|
||||
//
|
||||
|
||||
int type;
|
||||
bool pLinear;
|
||||
int xSampling;
|
||||
int ySampling;
|
||||
|
||||
Xdr::read <StreamIO> (is, type);
|
||||
Xdr::read <StreamIO> (is, pLinear);
|
||||
Xdr::skip <StreamIO> (is, 3);
|
||||
Xdr::read <StreamIO> (is, xSampling);
|
||||
Xdr::read <StreamIO> (is, ySampling);
|
||||
|
||||
_value.insert
|
||||
(name, Channel (PixelType (type), xSampling, ySampling, pLinear));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
@@ -1,67 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
#ifndef INCLUDED_IMF_CHANNEL_LIST_ATTRIBUTE_H
|
||||
#define INCLUDED_IMF_CHANNEL_LIST_ATTRIBUTE_H
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class ChannelListAttribute
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfAttribute.h>
|
||||
#include <ImfChannelList.h>
|
||||
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
typedef TypedAttribute<ChannelList> ChannelListAttribute;
|
||||
template <> const char *ChannelListAttribute::staticTypeName ();
|
||||
template <> void ChannelListAttribute::writeValueTo (OStream &, int) const;
|
||||
template <> void ChannelListAttribute::readValueFrom (IStream &, int, int);
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
|
||||
// Metrowerks compiler wants the .cpp file inlined, too
|
||||
#ifdef __MWERKS__
|
||||
#include <ImfChannelListAttribute.cpp>
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,135 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2003, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// CIE (x,y) chromaticities, and conversions between
|
||||
// RGB tiples and CIE XYZ tristimulus values.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfChromaticities.h>
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
Chromaticities::Chromaticities (const Imath::V2f &red,
|
||||
const Imath::V2f &green,
|
||||
const Imath::V2f &blue,
|
||||
const Imath::V2f &white)
|
||||
:
|
||||
red (red),
|
||||
green (green),
|
||||
blue (blue),
|
||||
white (white)
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
|
||||
Imath::M44f
|
||||
RGBtoXYZ (const Chromaticities chroma, float Y)
|
||||
{
|
||||
//
|
||||
// For an explanation of how the color conversion matrix is derived,
|
||||
// see Roy Hall, "Illumination and Color in Computer Generated Imagery",
|
||||
// Springer-Verlag, 1989, chapter 3, "Perceptual Response"; and
|
||||
// Charles A. Poynton, "A Technical Introduction to Digital Video",
|
||||
// John Wiley & Sons, 1996, chapter 7, "Color science for video".
|
||||
//
|
||||
|
||||
//
|
||||
// X and Z values of RGB value (1, 1, 1), or "white"
|
||||
//
|
||||
|
||||
float X = chroma.white.x * Y / chroma.white.y;
|
||||
float Z = (1 - chroma.white.x - chroma.white.y) * Y / chroma.white.y;
|
||||
|
||||
//
|
||||
// Scale factors for matrix rows
|
||||
//
|
||||
|
||||
float d = chroma.red.x * (chroma.blue.y - chroma.green.y) +
|
||||
chroma.blue.x * (chroma.green.y - chroma.red.y) +
|
||||
chroma.green.x * (chroma.red.y - chroma.blue.y);
|
||||
|
||||
float Sr = (X * (chroma.blue.y - chroma.green.y) -
|
||||
chroma.green.x * (Y * (chroma.blue.y - 1) +
|
||||
chroma.blue.y * (X + Z)) +
|
||||
chroma.blue.x * (Y * (chroma.green.y - 1) +
|
||||
chroma.green.y * (X + Z))) / d;
|
||||
|
||||
float Sg = (X * (chroma.red.y - chroma.blue.y) +
|
||||
chroma.red.x * (Y * (chroma.blue.y - 1) +
|
||||
chroma.blue.y * (X + Z)) -
|
||||
chroma.blue.x * (Y * (chroma.red.y - 1) +
|
||||
chroma.red.y * (X + Z))) / d;
|
||||
|
||||
float Sb = (X * (chroma.green.y - chroma.red.y) -
|
||||
chroma.red.x * (Y * (chroma.green.y - 1) +
|
||||
chroma.green.y * (X + Z)) +
|
||||
chroma.green.x * (Y * (chroma.red.y - 1) +
|
||||
chroma.red.y * (X + Z))) / d;
|
||||
|
||||
//
|
||||
// Assemble the matrix
|
||||
//
|
||||
|
||||
Imath::M44f M;
|
||||
|
||||
M[0][0] = Sr * chroma.red.x;
|
||||
M[0][1] = Sr * chroma.red.y;
|
||||
M[0][2] = Sr * (1 - chroma.red.x - chroma.red.y);
|
||||
|
||||
M[1][0] = Sg * chroma.green.x;
|
||||
M[1][1] = Sg * chroma.green.y;
|
||||
M[1][2] = Sg * (1 - chroma.green.x - chroma.green.y);
|
||||
|
||||
M[2][0] = Sb * chroma.blue.x;
|
||||
M[2][1] = Sb * chroma.blue.y;
|
||||
M[2][2] = Sb * (1 - chroma.blue.x - chroma.blue.y);
|
||||
|
||||
return M;
|
||||
}
|
||||
|
||||
|
||||
Imath::M44f
|
||||
XYZtoRGB (const Chromaticities chroma, float Y)
|
||||
{
|
||||
return RGBtoXYZ (chroma, Y).inverse();
|
||||
}
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
@@ -1,120 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2003, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
#ifndef INCLUDED_IMF_CHROMATICITIES_H
|
||||
#define INCLUDED_IMF_CHROMATICITIES_H
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// CIE (x,y) chromaticities, and conversions between
|
||||
// RGB tiples and CIE XYZ tristimulus values.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include "ImathVec.h"
|
||||
#include "ImathMatrix.h"
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
struct Chromaticities
|
||||
{
|
||||
//-----------------------------------------------
|
||||
// The CIE x and y coordinates of the RGB triples
|
||||
// (1,0,0), (0,1,0), (0,0,1) and (1,1,1).
|
||||
//-----------------------------------------------
|
||||
|
||||
Imath::V2f red;
|
||||
Imath::V2f green;
|
||||
Imath::V2f blue;
|
||||
Imath::V2f white;
|
||||
|
||||
//--------------------------------------------
|
||||
// Default constructor produces chromaticities
|
||||
// according to Rec. ITU-R BT.709-3
|
||||
//--------------------------------------------
|
||||
|
||||
Chromaticities (const Imath::V2f &red = Imath::V2f (0.6400f, 0.3300f),
|
||||
const Imath::V2f &green = Imath::V2f (0.3000f, 0.6000f),
|
||||
const Imath::V2f &blue = Imath::V2f (0.1500f, 0.0600f),
|
||||
const Imath::V2f &white = Imath::V2f (0.3127f, 0.3290f));
|
||||
};
|
||||
|
||||
|
||||
//
|
||||
// Conversions between RGB and CIE XYZ
|
||||
//
|
||||
// RGB to XYZ:
|
||||
//
|
||||
// Given a set of chromaticities, c, and the luminance, Y, of the RGB
|
||||
// triple (1,1,1), or "white", RGBtoXYZ(c,Y) computes a matrix, M, so
|
||||
// that multiplying an RGB value, v, with M produces an equivalent
|
||||
// XYZ value, w. (w == v * M)
|
||||
//
|
||||
// If we define that
|
||||
//
|
||||
// (Xr, Yr, Zr) == (1, 0, 0) * M
|
||||
// (Xg, Yg, Zg) == (0, 1, 0) * M
|
||||
// (Xb, Yb, Zb) == (0, 0, 1) * M
|
||||
// (Xw, Yw, Zw) == (1, 1, 1) * M,
|
||||
//
|
||||
// then the following statements are true:
|
||||
//
|
||||
// Xr / (Xr + Yr + Zr) == c.red.x
|
||||
// Yr / (Xr + Yr + Zr) == c.red.y
|
||||
//
|
||||
// Xg / (Xg + Yg + Zg) == c.red.x
|
||||
// Yg / (Xg + Yg + Zg) == c.red.y
|
||||
//
|
||||
// Xb / (Xb + Yb + Zb) == c.red.x
|
||||
// Yb / (Xb + Yb + Zb) == c.red.y
|
||||
//
|
||||
// Xw / (Xw + Yw + Zw) == c.red.x
|
||||
// Yw / (Xw + Yw + Zw) == c.red.y
|
||||
//
|
||||
// Yw == Y.
|
||||
//
|
||||
// XYZ to RGB:
|
||||
//
|
||||
// YYZtoRGB(c,Y) returns RGBtoXYZ(c,Y).inverse().
|
||||
//
|
||||
|
||||
Imath::M44f RGBtoXYZ (const Chromaticities chroma, float Y);
|
||||
Imath::M44f XYZtoRGB (const Chromaticities chroma, float Y);
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
|
||||
#endif
|
||||
@@ -1,86 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2003, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class ChromaticitiesAttribute
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfChromaticitiesAttribute.h>
|
||||
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
template <>
|
||||
const char *
|
||||
ChromaticitiesAttribute::staticTypeName ()
|
||||
{
|
||||
return "chromaticities";
|
||||
}
|
||||
|
||||
|
||||
template <>
|
||||
void
|
||||
ChromaticitiesAttribute::writeValueTo (OStream &os, int version) const
|
||||
{
|
||||
Xdr::write <StreamIO> (os, _value.red.x);
|
||||
Xdr::write <StreamIO> (os, _value.red.y);
|
||||
Xdr::write <StreamIO> (os, _value.green.x);
|
||||
Xdr::write <StreamIO> (os, _value.green.y);
|
||||
Xdr::write <StreamIO> (os, _value.blue.x);
|
||||
Xdr::write <StreamIO> (os, _value.blue.y);
|
||||
Xdr::write <StreamIO> (os, _value.white.x);
|
||||
Xdr::write <StreamIO> (os, _value.white.y);
|
||||
}
|
||||
|
||||
|
||||
template <>
|
||||
void
|
||||
ChromaticitiesAttribute::readValueFrom (IStream &is, int size, int version)
|
||||
{
|
||||
Xdr::read <StreamIO> (is, _value.red.x);
|
||||
Xdr::read <StreamIO> (is, _value.red.y);
|
||||
Xdr::read <StreamIO> (is, _value.green.x);
|
||||
Xdr::read <StreamIO> (is, _value.green.y);
|
||||
Xdr::read <StreamIO> (is, _value.blue.x);
|
||||
Xdr::read <StreamIO> (is, _value.blue.y);
|
||||
Xdr::read <StreamIO> (is, _value.white.x);
|
||||
Xdr::read <StreamIO> (is, _value.white.y);
|
||||
}
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
@@ -1,72 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2003, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
#ifndef INCLUDED_IMF_CHROMATICITIES_ATTRIBUTE_H
|
||||
#define INCLUDED_IMF_CHROMATICITIES_ATTRIBUTE_H
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class ChromaticitiesAttribute
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfAttribute.h>
|
||||
#include <ImfChromaticities.h>
|
||||
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
typedef TypedAttribute<Chromaticities> ChromaticitiesAttribute;
|
||||
|
||||
template <>
|
||||
const char *ChromaticitiesAttribute::staticTypeName ();
|
||||
|
||||
template <>
|
||||
void ChromaticitiesAttribute::writeValueTo (OStream &, int) const;
|
||||
|
||||
template <>
|
||||
void ChromaticitiesAttribute::readValueFrom (IStream &, int, int);
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
|
||||
// Metrowerks compiler wants the .cpp file inlined, too
|
||||
#ifdef __MWERKS__
|
||||
#include <ImfChromaticitiesAttribute.cpp>
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -1,75 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
#ifndef INCLUDED_IMF_COMPRESSION_H
|
||||
#define INCLUDED_IMF_COMPRESSION_H
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// enum Compression
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
enum Compression
|
||||
{
|
||||
NO_COMPRESSION = 0, // no compression
|
||||
|
||||
RLE_COMPRESSION = 1, // run length encoding
|
||||
|
||||
ZIPS_COMPRESSION = 2, // zlib compression, one scan line at a time
|
||||
|
||||
ZIP_COMPRESSION = 3, // zlib compression, in blocks of 16 scan lines
|
||||
|
||||
PIZ_COMPRESSION = 4, // piz-based wavelet compression
|
||||
|
||||
PXR24_COMPRESSION = 5, // lossy 24-bit float compression
|
||||
|
||||
B44_COMPRESSION = 6, // lossy 4-by-4 pixel block compression,
|
||||
// fixed compression rate
|
||||
|
||||
B44A_COMPRESSION = 7, // lossy 4-by-4 pixel block compression,
|
||||
// flat fields are compressed more
|
||||
|
||||
NUM_COMPRESSION_METHODS // number of different compression methods
|
||||
};
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
|
||||
#endif
|
||||
@@ -1,76 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class CompressionAttribute
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfCompressionAttribute.h>
|
||||
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
template <>
|
||||
const char *
|
||||
CompressionAttribute::staticTypeName ()
|
||||
{
|
||||
return "compression";
|
||||
}
|
||||
|
||||
|
||||
template <>
|
||||
void
|
||||
CompressionAttribute::writeValueTo (OStream &os, int version) const
|
||||
{
|
||||
unsigned char tmp = _value;
|
||||
Xdr::write <StreamIO> (os, tmp);
|
||||
}
|
||||
|
||||
|
||||
template <>
|
||||
void
|
||||
CompressionAttribute::readValueFrom (IStream &is, int size, int version)
|
||||
{
|
||||
unsigned char tmp;
|
||||
Xdr::read <StreamIO> (is, tmp);
|
||||
_value = Compression (tmp);
|
||||
}
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
@@ -1,66 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
#ifndef INCLUDED_IMF_COMPRESSION_ATTRIBUTE_H
|
||||
#define INCLUDED_IMF_COMPRESSION_ATTRIBUTE_H
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class CompressionAttribute
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfAttribute.h>
|
||||
#include <ImfCompression.h>
|
||||
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
typedef TypedAttribute<Compression> CompressionAttribute;
|
||||
template <> const char *CompressionAttribute::staticTypeName ();
|
||||
template <> void CompressionAttribute::writeValueTo (OStream &, int) const;
|
||||
template <> void CompressionAttribute::readValueFrom (IStream &, int, int);
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
|
||||
// Metrowerks compiler wants the .cpp file inlined, too
|
||||
#ifdef __MWERKS__
|
||||
#include <ImfCompressionAttribute.cpp>
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -1,191 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class Compressor
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfCompressor.h>
|
||||
#include <ImfRleCompressor.h>
|
||||
#include <ImfZipCompressor.h>
|
||||
#include <ImfPizCompressor.h>
|
||||
#include <ImfPxr24Compressor.h>
|
||||
#include <ImfB44Compressor.h>
|
||||
|
||||
namespace Imf {
|
||||
|
||||
using Imath::Box2i;
|
||||
|
||||
|
||||
Compressor::Compressor (const Header &hdr): _header (hdr) {}
|
||||
|
||||
|
||||
Compressor::~Compressor () {}
|
||||
|
||||
|
||||
Compressor::Format
|
||||
Compressor::format () const
|
||||
{
|
||||
return XDR;
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
Compressor::compressTile (const char *inPtr,
|
||||
int inSize,
|
||||
Box2i range,
|
||||
const char *&outPtr)
|
||||
{
|
||||
return compress (inPtr, inSize, range.min.y, outPtr);
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
Compressor::uncompressTile (const char *inPtr,
|
||||
int inSize,
|
||||
Box2i range,
|
||||
const char *&outPtr)
|
||||
{
|
||||
return uncompress (inPtr, inSize, range.min.y, outPtr);
|
||||
}
|
||||
|
||||
|
||||
bool
|
||||
isValidCompression (Compression c)
|
||||
{
|
||||
switch (c)
|
||||
{
|
||||
case NO_COMPRESSION:
|
||||
case RLE_COMPRESSION:
|
||||
case ZIPS_COMPRESSION:
|
||||
case ZIP_COMPRESSION:
|
||||
case PIZ_COMPRESSION:
|
||||
case PXR24_COMPRESSION:
|
||||
case B44_COMPRESSION:
|
||||
case B44A_COMPRESSION:
|
||||
|
||||
return true;
|
||||
|
||||
default:
|
||||
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Compressor *
|
||||
newCompressor (Compression c, int maxScanLineSize, const Header &hdr)
|
||||
{
|
||||
switch (c)
|
||||
{
|
||||
case RLE_COMPRESSION:
|
||||
|
||||
return new RleCompressor (hdr, maxScanLineSize);
|
||||
|
||||
case ZIPS_COMPRESSION:
|
||||
|
||||
return new ZipCompressor (hdr, maxScanLineSize, 1);
|
||||
|
||||
case ZIP_COMPRESSION:
|
||||
|
||||
return new ZipCompressor (hdr, maxScanLineSize, 16);
|
||||
|
||||
case PIZ_COMPRESSION:
|
||||
|
||||
return new PizCompressor (hdr, maxScanLineSize, 32);
|
||||
|
||||
case PXR24_COMPRESSION:
|
||||
|
||||
return new Pxr24Compressor (hdr, maxScanLineSize, 16);
|
||||
|
||||
case B44_COMPRESSION:
|
||||
|
||||
return new B44Compressor (hdr, maxScanLineSize, 32, false);
|
||||
|
||||
case B44A_COMPRESSION:
|
||||
|
||||
return new B44Compressor (hdr, maxScanLineSize, 32, true);
|
||||
|
||||
default:
|
||||
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Compressor *
|
||||
newTileCompressor (Compression c,
|
||||
int tileLineSize,
|
||||
int numTileLines,
|
||||
const Header &hdr)
|
||||
{
|
||||
switch (c)
|
||||
{
|
||||
case RLE_COMPRESSION:
|
||||
|
||||
return new RleCompressor (hdr, tileLineSize * numTileLines);
|
||||
|
||||
case ZIPS_COMPRESSION:
|
||||
case ZIP_COMPRESSION:
|
||||
|
||||
return new ZipCompressor (hdr, tileLineSize, numTileLines);
|
||||
|
||||
case PIZ_COMPRESSION:
|
||||
|
||||
return new PizCompressor (hdr, tileLineSize, numTileLines);
|
||||
|
||||
case PXR24_COMPRESSION:
|
||||
|
||||
return new Pxr24Compressor (hdr, tileLineSize, numTileLines);
|
||||
|
||||
case B44_COMPRESSION:
|
||||
|
||||
return new B44Compressor (hdr, tileLineSize, numTileLines, false);
|
||||
|
||||
case B44A_COMPRESSION:
|
||||
|
||||
return new B44Compressor (hdr, tileLineSize, numTileLines, true);
|
||||
|
||||
default:
|
||||
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
@@ -1,251 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
#ifndef INCLUDED_IMF_COMPRESSOR_H
|
||||
#define INCLUDED_IMF_COMPRESSOR_H
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class Compressor
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfCompression.h>
|
||||
#include "ImathBox.h"
|
||||
|
||||
namespace Imf {
|
||||
|
||||
class Header;
|
||||
|
||||
|
||||
class Compressor
|
||||
{
|
||||
public:
|
||||
|
||||
//---------------------------------------------
|
||||
// Constructor -- hdr is the header of the file
|
||||
// that will be compressed or uncompressed
|
||||
//---------------------------------------------
|
||||
|
||||
Compressor (const Header &hdr);
|
||||
|
||||
|
||||
//-----------
|
||||
// Destructor
|
||||
//-----------
|
||||
|
||||
virtual ~Compressor ();
|
||||
|
||||
|
||||
//----------------------------------------------
|
||||
// Maximum number of scan lines processed by
|
||||
// a single call to compress() and uncompress().
|
||||
//----------------------------------------------
|
||||
|
||||
virtual int numScanLines () const = 0;
|
||||
|
||||
|
||||
//--------------------------------------------
|
||||
// Format of the pixel data read and written
|
||||
// by the compress() and uncompress() methods.
|
||||
// The default implementation of format()
|
||||
// returns XDR.
|
||||
//--------------------------------------------
|
||||
|
||||
enum Format
|
||||
{
|
||||
NATIVE, // the machine's native format
|
||||
XDR // Xdr format
|
||||
};
|
||||
|
||||
virtual Format format () const;
|
||||
|
||||
|
||||
//----------------------------
|
||||
// Access to the file's header
|
||||
//----------------------------
|
||||
|
||||
const Header & header () const {return _header;}
|
||||
|
||||
|
||||
//-------------------------------------------------------------------------
|
||||
// Compress an array of bytes that represents the contents of up to
|
||||
// numScanLines() scan lines:
|
||||
//
|
||||
// inPtr Input buffer (uncompressed data).
|
||||
//
|
||||
// inSize Number of bytes in the input buffer
|
||||
//
|
||||
// minY Minimum y coordinate of the scan lines to
|
||||
// be compressed
|
||||
//
|
||||
// outPtr Pointer to output buffer
|
||||
//
|
||||
// return value Size of compressed data in output buffer
|
||||
//
|
||||
// Arrangement of uncompressed pixel data in the input buffer:
|
||||
//
|
||||
// Before calling
|
||||
//
|
||||
// compress (buf, size, minY, ...);
|
||||
//
|
||||
// the InputFile::writePixels() method gathers pixel data from the
|
||||
// frame buffer, fb, and places them in buffer buf, like this:
|
||||
//
|
||||
// char *endOfBuf = buf;
|
||||
//
|
||||
// for (int y = minY;
|
||||
// y <= min (minY + numScanLines() - 1, header().dataWindow().max.y);
|
||||
// ++y)
|
||||
// {
|
||||
// for (ChannelList::ConstIterator c = header().channels().begin();
|
||||
// c != header().channels().end();
|
||||
// ++c)
|
||||
// {
|
||||
// if (modp (y, c.channel().ySampling) != 0)
|
||||
// continue;
|
||||
//
|
||||
// for (int x = header().dataWindow().min.x;
|
||||
// x <= header().dataWindow().max.x;
|
||||
// ++x)
|
||||
// {
|
||||
// if (modp (x, c.channel().xSampling) != 0)
|
||||
// continue;
|
||||
//
|
||||
// Xdr::write<CharPtrIO> (endOfBuf, fb.pixel (c, x, y));
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// int size = endOfBuf - buf;
|
||||
//
|
||||
//-------------------------------------------------------------------------
|
||||
|
||||
virtual int compress (const char *inPtr,
|
||||
int inSize,
|
||||
int minY,
|
||||
const char *&outPtr) = 0;
|
||||
|
||||
virtual int compressTile (const char *inPtr,
|
||||
int inSize,
|
||||
Imath::Box2i range,
|
||||
const char *&outPtr);
|
||||
|
||||
//-------------------------------------------------------------------------
|
||||
// Uncompress an array of bytes that has been compressed by compress():
|
||||
//
|
||||
// inPtr Input buffer (compressed data).
|
||||
//
|
||||
// inSize Number of bytes in the input buffer
|
||||
//
|
||||
// minY Minimum y coordinate of the scan lines to
|
||||
// be uncompressed
|
||||
//
|
||||
// outPtr Pointer to output buffer
|
||||
//
|
||||
// return value Size of uncompressed data in output buffer
|
||||
//
|
||||
//-------------------------------------------------------------------------
|
||||
|
||||
virtual int uncompress (const char *inPtr,
|
||||
int inSize,
|
||||
int minY,
|
||||
const char *&outPtr) = 0;
|
||||
|
||||
virtual int uncompressTile (const char *inPtr,
|
||||
int inSize,
|
||||
Imath::Box2i range,
|
||||
const char *&outPtr);
|
||||
|
||||
private:
|
||||
|
||||
const Header & _header;
|
||||
};
|
||||
|
||||
|
||||
//--------------------------------------
|
||||
// Test if c is a valid compression type
|
||||
//--------------------------------------
|
||||
|
||||
bool isValidCompression (Compression c);
|
||||
|
||||
|
||||
//-----------------------------------------------------------------
|
||||
// Construct a Compressor for compression type c:
|
||||
//
|
||||
// maxScanLineSize Maximum number of bytes per uncompressed
|
||||
// scan line.
|
||||
//
|
||||
// header Header of the input or output file whose
|
||||
// pixels will be compressed or uncompressed.
|
||||
//
|
||||
// return value A pointer to a new Compressor object (it
|
||||
// is the caller's responsibility to delete
|
||||
// the object), or 0 (if c is NO_COMPRESSION).
|
||||
//
|
||||
//-----------------------------------------------------------------
|
||||
|
||||
Compressor * newCompressor (Compression c,
|
||||
int maxScanLineSize,
|
||||
const Header &hdr);
|
||||
|
||||
|
||||
//-----------------------------------------------------------------
|
||||
// Construct a Compressor for compression type c for a tiled image:
|
||||
//
|
||||
// tileLineSize Maximum number of bytes per uncompressed
|
||||
// line in a tile.
|
||||
//
|
||||
// numTileLines Maximum number of lines in a tile.
|
||||
//
|
||||
// header Header of the input or output file whose
|
||||
// pixels will be compressed or uncompressed.
|
||||
//
|
||||
// return value A pointer to a new Compressor object (it
|
||||
// is the caller's responsibility to delete
|
||||
// the object), or 0 (if c is NO_COMPRESSION).
|
||||
//
|
||||
//-----------------------------------------------------------------
|
||||
|
||||
Compressor * newTileCompressor (Compression c,
|
||||
int tileLineSize,
|
||||
int numTileLines,
|
||||
const Header &hdr);
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
|
||||
#endif
|
||||
@@ -1,139 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// Routines for converting between pixel data types,
|
||||
// with well-defined behavior for exceptional cases.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfConvert.h>
|
||||
#include <limits.h>
|
||||
|
||||
namespace Imf {
|
||||
namespace {
|
||||
|
||||
inline bool
|
||||
isNegative (float f)
|
||||
{
|
||||
union {float f; int i;} u;
|
||||
u.f = f;
|
||||
return (u.i & 0x80000000) != 0;
|
||||
}
|
||||
|
||||
|
||||
inline bool
|
||||
isNan (float f)
|
||||
{
|
||||
union {float f; int i;} u;
|
||||
u.f = f;
|
||||
return (u.i & 0x7fffffff) > 0x7f800000;
|
||||
}
|
||||
|
||||
|
||||
inline bool
|
||||
isInfinity (float f)
|
||||
{
|
||||
union {float f; int i;} u;
|
||||
u.f = f;
|
||||
return (u.i & 0x7fffffff) == 0x7f800000;
|
||||
}
|
||||
|
||||
|
||||
inline bool
|
||||
isFinite (float f)
|
||||
{
|
||||
union {float f; int i;} u;
|
||||
u.f = f;
|
||||
return (u.i & 0x7f800000) != 0x7f800000;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
|
||||
unsigned int
|
||||
halfToUint (half h)
|
||||
{
|
||||
if (h.isNegative() || h.isNan())
|
||||
return 0;
|
||||
|
||||
if (h.isInfinity())
|
||||
return UINT_MAX;
|
||||
|
||||
return (unsigned int) h;
|
||||
}
|
||||
|
||||
|
||||
unsigned int
|
||||
floatToUint (float f)
|
||||
{
|
||||
if (isNegative (f) || isNan (f))
|
||||
return 0;
|
||||
|
||||
if (isInfinity (f) || f > UINT_MAX)
|
||||
return UINT_MAX;
|
||||
|
||||
return (unsigned int) f;
|
||||
}
|
||||
|
||||
|
||||
half
|
||||
uintToHalf (unsigned int ui)
|
||||
{
|
||||
if (ui > HALF_MAX)
|
||||
return half::posInf();
|
||||
|
||||
return half (ui);
|
||||
}
|
||||
|
||||
|
||||
half
|
||||
floatToHalf (float f)
|
||||
{
|
||||
if (isFinite (f))
|
||||
{
|
||||
if (f > HALF_MAX)
|
||||
return half::posInf();
|
||||
|
||||
if (f < -HALF_MAX)
|
||||
return half::negInf();
|
||||
}
|
||||
|
||||
return half (f);
|
||||
}
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
@@ -1,104 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
#ifndef INCLUDED_IMF_CONVERT_H
|
||||
#define INCLUDED_IMF_CONVERT_H
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// Routines for converting between pixel data types,
|
||||
// with well-defined behavior for exceptional cases,
|
||||
// without depending on how hardware and operating
|
||||
// system handle integer overflows and floating-point
|
||||
// exceptions.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include "half.h"
|
||||
|
||||
|
||||
namespace Imf {
|
||||
|
||||
//---------------------------------------------------------
|
||||
// Conversion from half or float to unsigned int:
|
||||
//
|
||||
// input result
|
||||
// ---------------------------------------------------
|
||||
//
|
||||
// finite, >= 0 input, cast to unsigned int
|
||||
// (rounds towards zero)
|
||||
//
|
||||
// finite, < 0 0
|
||||
//
|
||||
// NaN 0
|
||||
//
|
||||
// +infinity UINT_MAX
|
||||
//
|
||||
// -infinity 0
|
||||
//
|
||||
//---------------------------------------------------------
|
||||
|
||||
unsigned int halfToUint (half h);
|
||||
unsigned int floatToUint (float f);
|
||||
|
||||
|
||||
//---------------------------------------------------------
|
||||
// Conversion from unsigned int or float to half:
|
||||
//
|
||||
// input result
|
||||
// ---------------------------------------------------
|
||||
//
|
||||
// finite, closest possible half
|
||||
// magnitude <= HALF_MAX
|
||||
//
|
||||
// finite, > HALF_MAX +infinity
|
||||
//
|
||||
// finite, < -HALF_MAX -infinity
|
||||
//
|
||||
// NaN NaN
|
||||
//
|
||||
// +infinity +infinity
|
||||
//
|
||||
// -infinity -infinity
|
||||
//
|
||||
//---------------------------------------------------------
|
||||
|
||||
half uintToHalf (unsigned int ui);
|
||||
half floatToHalf (float f);
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
|
||||
#endif
|
||||
@@ -1,57 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class DoubleAttribute
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfDoubleAttribute.h>
|
||||
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
template <>
|
||||
const char *
|
||||
DoubleAttribute::staticTypeName ()
|
||||
{
|
||||
return "double";
|
||||
}
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
@@ -1,63 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
#ifndef INCLUDED_IMF_DOUBLE_ATTRIBUTE_H
|
||||
#define INCLUDED_IMF_DOUBLE_ATTRIBUTE_H
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class DoubleAttribute
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfAttribute.h>
|
||||
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
typedef TypedAttribute<double> DoubleAttribute;
|
||||
template <> const char *DoubleAttribute::staticTypeName ();
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
|
||||
// Metrowerks compiler wants the .cpp file inlined, too
|
||||
#ifdef __MWERKS__
|
||||
#include <ImfDoubleAttribute.cpp>
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -1,328 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// Environment maps
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfEnvmap.h>
|
||||
#include "ImathFun.h"
|
||||
#include <algorithm>
|
||||
#include <math.h>
|
||||
|
||||
using namespace std;
|
||||
using namespace Imath;
|
||||
|
||||
namespace Imf {
|
||||
namespace LatLongMap {
|
||||
|
||||
V2f
|
||||
latLong (const V3f &dir)
|
||||
{
|
||||
float r = sqrt (dir.z * dir.z + dir.x * dir.x);
|
||||
|
||||
float latitude = (r < abs (dir.y))?
|
||||
acos (r / dir.length()) * sign (dir.y):
|
||||
asin (dir.y / dir.length());
|
||||
|
||||
float longitude = (dir.z == 0 && dir.x == 0)? 0: atan2 (dir.x, dir.z);
|
||||
|
||||
return V2f (latitude, longitude);
|
||||
}
|
||||
|
||||
|
||||
V2f
|
||||
latLong (const Box2i &dataWindow, const V2f &pixelPosition)
|
||||
{
|
||||
float latitude, longitude;
|
||||
|
||||
if (dataWindow.max.y > dataWindow.min.y)
|
||||
{
|
||||
latitude = -M_PI *
|
||||
((pixelPosition.y - dataWindow.min.y) /
|
||||
(dataWindow.max.y - dataWindow.min.y) - 0.5f);
|
||||
}
|
||||
else
|
||||
{
|
||||
latitude = 0;
|
||||
}
|
||||
|
||||
if (dataWindow.max.x > dataWindow.min.x)
|
||||
{
|
||||
longitude = -2 * M_PI *
|
||||
((pixelPosition.x - dataWindow.min.x) /
|
||||
(dataWindow.max.x - dataWindow.min.x) - 0.5f);
|
||||
}
|
||||
else
|
||||
{
|
||||
longitude = 0;
|
||||
}
|
||||
|
||||
return V2f (latitude, longitude);
|
||||
}
|
||||
|
||||
|
||||
V2f
|
||||
pixelPosition (const Box2i &dataWindow, const V2f &latLong)
|
||||
{
|
||||
float x = latLong.y / (-2 * M_PI) + 0.5f;
|
||||
float y = latLong.x / -M_PI + 0.5f;
|
||||
|
||||
return V2f (x * (dataWindow.max.x - dataWindow.min.x) + dataWindow.min.x,
|
||||
y * (dataWindow.max.y - dataWindow.min.y) + dataWindow.min.y);
|
||||
}
|
||||
|
||||
|
||||
V2f
|
||||
pixelPosition (const Box2i &dataWindow, const V3f &direction)
|
||||
{
|
||||
return pixelPosition (dataWindow, latLong (direction));
|
||||
}
|
||||
|
||||
|
||||
V3f
|
||||
direction (const Box2i &dataWindow, const V2f &pixelPosition)
|
||||
{
|
||||
V2f ll = latLong (dataWindow, pixelPosition);
|
||||
|
||||
return V3f (sin (ll.y) * cos (ll.x),
|
||||
sin (ll.x),
|
||||
cos (ll.y) * cos (ll.x));
|
||||
}
|
||||
|
||||
} // namespace LatLongMap
|
||||
|
||||
|
||||
namespace CubeMap {
|
||||
|
||||
int
|
||||
sizeOfFace (const Box2i &dataWindow)
|
||||
{
|
||||
return min ((dataWindow.max.x - dataWindow.min.x + 1),
|
||||
(dataWindow.max.y - dataWindow.min.y + 1) / 6);
|
||||
}
|
||||
|
||||
|
||||
Box2i
|
||||
dataWindowForFace (CubeMapFace face, const Box2i &dataWindow)
|
||||
{
|
||||
int sof = sizeOfFace (dataWindow);
|
||||
Box2i dwf;
|
||||
|
||||
dwf.min.x = 0;
|
||||
dwf.min.y = int (face) * sof;
|
||||
|
||||
dwf.max.x = dwf.min.x + sof - 1;
|
||||
dwf.max.y = dwf.min.y + sof - 1;
|
||||
|
||||
return dwf;
|
||||
}
|
||||
|
||||
|
||||
V2f
|
||||
pixelPosition (CubeMapFace face, const Box2i &dataWindow, V2f positionInFace)
|
||||
{
|
||||
Box2i dwf = dataWindowForFace (face, dataWindow);
|
||||
V2f pos (0, 0);
|
||||
|
||||
switch (face)
|
||||
{
|
||||
case CUBEFACE_POS_X:
|
||||
|
||||
pos.x = dwf.min.x + positionInFace.y;
|
||||
pos.y = dwf.max.y - positionInFace.x;
|
||||
break;
|
||||
|
||||
case CUBEFACE_NEG_X:
|
||||
|
||||
pos.x = dwf.max.x - positionInFace.y;
|
||||
pos.y = dwf.max.y - positionInFace.x;
|
||||
break;
|
||||
|
||||
case CUBEFACE_POS_Y:
|
||||
|
||||
pos.x = dwf.min.x + positionInFace.x;
|
||||
pos.y = dwf.max.y - positionInFace.y;
|
||||
break;
|
||||
|
||||
case CUBEFACE_NEG_Y:
|
||||
|
||||
pos.x = dwf.min.x + positionInFace.x;
|
||||
pos.y = dwf.min.y + positionInFace.y;
|
||||
break;
|
||||
|
||||
case CUBEFACE_POS_Z:
|
||||
|
||||
pos.x = dwf.max.x - positionInFace.x;
|
||||
pos.y = dwf.max.y - positionInFace.y;
|
||||
break;
|
||||
|
||||
case CUBEFACE_NEG_Z:
|
||||
|
||||
pos.x = dwf.min.x + positionInFace.x;
|
||||
pos.y = dwf.max.y - positionInFace.y;
|
||||
break;
|
||||
}
|
||||
|
||||
return pos;
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
faceAndPixelPosition (const V3f &direction,
|
||||
const Box2i &dataWindow,
|
||||
CubeMapFace &face,
|
||||
V2f &pif)
|
||||
{
|
||||
int sof = sizeOfFace (dataWindow);
|
||||
float absx = abs (direction.x);
|
||||
float absy = abs (direction.y);
|
||||
float absz = abs (direction.z);
|
||||
|
||||
if (absx >= absy && absx >= absz)
|
||||
{
|
||||
if (absx == 0)
|
||||
{
|
||||
//
|
||||
// Special case - direction is (0, 0, 0)
|
||||
//
|
||||
|
||||
face = CUBEFACE_POS_X;
|
||||
pif = V2f (0, 0);
|
||||
return;
|
||||
}
|
||||
|
||||
pif.x = (direction.y / absx + 1) / 2 * (sof - 1);
|
||||
pif.y = (direction.z / absx + 1) / 2 * (sof - 1);
|
||||
|
||||
if (direction.x > 0)
|
||||
face = CUBEFACE_POS_X;
|
||||
else
|
||||
face = CUBEFACE_NEG_X;
|
||||
}
|
||||
else if (absy >= absz)
|
||||
{
|
||||
pif.x = (direction.x / absy + 1) / 2 * (sof - 1);
|
||||
pif.y = (direction.z / absy + 1) / 2 * (sof - 1);
|
||||
|
||||
if (direction.y > 0)
|
||||
face = CUBEFACE_POS_Y;
|
||||
else
|
||||
face = CUBEFACE_NEG_Y;
|
||||
}
|
||||
else
|
||||
{
|
||||
pif.x = (direction.x / absz + 1) / 2 * (sof - 1);
|
||||
pif.y = (direction.y / absz + 1) / 2 * (sof - 1);
|
||||
|
||||
if (direction.z > 0)
|
||||
face = CUBEFACE_POS_Z;
|
||||
else
|
||||
face = CUBEFACE_NEG_Z;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
V3f
|
||||
direction (CubeMapFace face, const Box2i &dataWindow, const V2f &positionInFace)
|
||||
{
|
||||
int sof = sizeOfFace (dataWindow);
|
||||
|
||||
V2f pos;
|
||||
|
||||
if (sof > 1)
|
||||
{
|
||||
pos = V2f (positionInFace.x / (sof - 1) * 2 - 1,
|
||||
positionInFace.y / (sof - 1) * 2 - 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
pos = V2f (0, 0);
|
||||
}
|
||||
|
||||
V3f dir (1, 0, 0);
|
||||
|
||||
switch (face)
|
||||
{
|
||||
case CUBEFACE_POS_X:
|
||||
|
||||
dir.x = 1;
|
||||
dir.y = pos.x;
|
||||
dir.z = pos.y;
|
||||
break;
|
||||
|
||||
case CUBEFACE_NEG_X:
|
||||
|
||||
dir.x = -1;
|
||||
dir.y = pos.x;
|
||||
dir.z = pos.y;
|
||||
break;
|
||||
|
||||
case CUBEFACE_POS_Y:
|
||||
|
||||
dir.x = pos.x;
|
||||
dir.y = 1;
|
||||
dir.z = pos.y;
|
||||
break;
|
||||
|
||||
case CUBEFACE_NEG_Y:
|
||||
|
||||
dir.x = pos.x;
|
||||
dir.y = -1;
|
||||
dir.z = pos.y;
|
||||
break;
|
||||
|
||||
case CUBEFACE_POS_Z:
|
||||
|
||||
dir.x = pos.x;
|
||||
dir.y = pos.y;
|
||||
dir.z = 1;
|
||||
break;
|
||||
|
||||
case CUBEFACE_NEG_Z:
|
||||
|
||||
dir.x = pos.x;
|
||||
dir.y = pos.y;
|
||||
dir.z = -1;
|
||||
break;
|
||||
}
|
||||
|
||||
return dir;
|
||||
}
|
||||
|
||||
} // namespace CubeMap
|
||||
} // namespace Imf
|
||||
@@ -1,322 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
#ifndef INCLUDED_IMF_ENVMAP_H
|
||||
#define INCLUDED_IMF_ENVMAP_H
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// Environment maps
|
||||
//
|
||||
// Environment maps define a mapping from 3D directions to 2D
|
||||
// pixel space locations. Environment maps are typically used
|
||||
// in 3D rendering, for effects such as quickly approximating
|
||||
// how shiny surfaces reflect their environment.
|
||||
//
|
||||
// Environment maps can be stored in scanline-based or in tiled
|
||||
// OpenEXR files. The fact that an image is an environment map
|
||||
// is indicated by the presence of an EnvmapAttribute whose name
|
||||
// is "envmap". (Convenience functions to access this attribute
|
||||
// are defined in header file ImfStandardAttributes.h.)
|
||||
// The attribute's value defines the mapping from 3D directions
|
||||
// to 2D pixel space locations.
|
||||
//
|
||||
// This header file defines the set of possible EnvmapAttribute
|
||||
// values.
|
||||
//
|
||||
// For each possible EnvmapAttribute value, this header file also
|
||||
// defines a set of convienience functions to convert between 3D
|
||||
// directions and 2D pixel locations.
|
||||
//
|
||||
// Most of the convenience functions defined below require a
|
||||
// dataWindow parameter. For scanline-based images, and for
|
||||
// tiled images with level mode ONE_LEVEL, the dataWindow
|
||||
// parameter should be set to the image's data window, as
|
||||
// defined in the image header. For tiled images with level
|
||||
// mode MIPMAP_LEVELS or RIPMAP_LEVELS, the data window of the
|
||||
// image level that is being accessed should be used instead.
|
||||
// (See the dataWindowForLevel() methods in ImfTiledInputFile.h
|
||||
// and ImfTiledOutputFile.h.)
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include "ImathBox.h"
|
||||
|
||||
namespace Imf {
|
||||
|
||||
//--------------------------------
|
||||
// Supported environment map types
|
||||
//--------------------------------
|
||||
|
||||
enum Envmap
|
||||
{
|
||||
ENVMAP_LATLONG = 0, // Latitude-longitude environment map
|
||||
ENVMAP_CUBE = 1, // Cube map
|
||||
|
||||
NUM_ENVMAPTYPES // Number of different environment map types
|
||||
};
|
||||
|
||||
|
||||
//-------------------------------------------------------------------------
|
||||
// Latitude-Longitude Map:
|
||||
//
|
||||
// The environment is projected onto the image using polar coordinates
|
||||
// (latitude and longitude). A pixel's x coordinate corresponds to
|
||||
// its longitude, and the y coordinate corresponds to its latitude.
|
||||
// Pixel (dataWindow.min.x, dataWindow.min.y) has latitude +pi/2 and
|
||||
// longitude +pi; pixel (dataWindow.max.x, dataWindow.max.y) has
|
||||
// latitude -pi/2 and longitude -pi.
|
||||
//
|
||||
// In 3D space, latitudes -pi/2 and +pi/2 correspond to the negative and
|
||||
// positive y direction. Latitude 0, longitude 0 points into positive
|
||||
// z direction; and latitude 0, longitude pi/2 points into positive x
|
||||
// direction.
|
||||
//
|
||||
// The size of the data window should be 2*N by N pixels (width by height),
|
||||
// where N can be any integer greater than 0.
|
||||
//-------------------------------------------------------------------------
|
||||
|
||||
namespace LatLongMap
|
||||
{
|
||||
//----------------------------------------------------
|
||||
// Convert a 3D direction to a 2D vector whose x and y
|
||||
// components represent the corresponding latitude
|
||||
// and longitude.
|
||||
//----------------------------------------------------
|
||||
|
||||
Imath::V2f latLong (const Imath::V3f &direction);
|
||||
|
||||
|
||||
//--------------------------------------------------------
|
||||
// Convert the position of a pixel to a 2D vector whose
|
||||
// x and y components represent the corresponding latitude
|
||||
// and longitude.
|
||||
//--------------------------------------------------------
|
||||
|
||||
Imath::V2f latLong (const Imath::Box2i &dataWindow,
|
||||
const Imath::V2f &pixelPosition);
|
||||
|
||||
|
||||
//-------------------------------------------------------------
|
||||
// Convert a 2D vector, whose x and y components represent
|
||||
// longitude and latitude, into a corresponding pixel position.
|
||||
//-------------------------------------------------------------
|
||||
|
||||
Imath::V2f pixelPosition (const Imath::Box2i &dataWindow,
|
||||
const Imath::V2f &latLong);
|
||||
|
||||
|
||||
//-----------------------------------------------------
|
||||
// Convert a 3D direction vector into a corresponding
|
||||
// pixel position. pixelPosition(dw,dir) is equivalent
|
||||
// to pixelPosition(dw,latLong(dw,dir)).
|
||||
//-----------------------------------------------------
|
||||
|
||||
Imath::V2f pixelPosition (const Imath::Box2i &dataWindow,
|
||||
const Imath::V3f &direction);
|
||||
|
||||
|
||||
//--------------------------------------------------------
|
||||
// Convert the position of a pixel in a latitude-longitude
|
||||
// map into a corresponding 3D direction.
|
||||
//--------------------------------------------------------
|
||||
|
||||
Imath::V3f direction (const Imath::Box2i &dataWindow,
|
||||
const Imath::V2f &pixelPosition);
|
||||
}
|
||||
|
||||
|
||||
//--------------------------------------------------------------
|
||||
// Cube Map:
|
||||
//
|
||||
// The environment is projected onto the six faces of an
|
||||
// axis-aligned cube. The cube's faces are then arranged
|
||||
// in a 2D image as shown below.
|
||||
//
|
||||
// 2-----------3
|
||||
// / /|
|
||||
// / / | Y
|
||||
// / / | |
|
||||
// 6-----------7 | |
|
||||
// | | | |
|
||||
// | | | |
|
||||
// | 0 | 1 *------- X
|
||||
// | | / /
|
||||
// | | / /
|
||||
// | |/ /
|
||||
// 4-----------5 Z
|
||||
//
|
||||
// dataWindow.min
|
||||
// /
|
||||
// /
|
||||
// +-----------+
|
||||
// |3 Y 7|
|
||||
// | | |
|
||||
// | | |
|
||||
// | ---+---Z | +X face
|
||||
// | | |
|
||||
// | | |
|
||||
// |1 5|
|
||||
// +-----------+
|
||||
// |6 Y 2|
|
||||
// | | |
|
||||
// | | |
|
||||
// | Z---+--- | -X face
|
||||
// | | |
|
||||
// | | |
|
||||
// |4 0|
|
||||
// +-----------+
|
||||
// |6 Z 7|
|
||||
// | | |
|
||||
// | | |
|
||||
// | ---+---X | +Y face
|
||||
// | | |
|
||||
// | | |
|
||||
// |2 3|
|
||||
// +-----------+
|
||||
// |0 1|
|
||||
// | | |
|
||||
// | | |
|
||||
// | ---+---X | -Y face
|
||||
// | | |
|
||||
// | | |
|
||||
// |4 Z 5|
|
||||
// +-----------+
|
||||
// |7 Y 6|
|
||||
// | | |
|
||||
// | | |
|
||||
// | X---+--- | +Z face
|
||||
// | | |
|
||||
// | | |
|
||||
// |5 4|
|
||||
// +-----------+
|
||||
// |2 Y 3|
|
||||
// | | |
|
||||
// | | |
|
||||
// | ---+---X | -Z face
|
||||
// | | |
|
||||
// | | |
|
||||
// |0 1|
|
||||
// +-----------+
|
||||
// /
|
||||
// /
|
||||
// dataWindow.max
|
||||
//
|
||||
// The size of the data window should be N by 6*N pixels
|
||||
// (width by height), where N can be any integer greater
|
||||
// than 0.
|
||||
//
|
||||
//--------------------------------------------------------------
|
||||
|
||||
//------------------------------------
|
||||
// Names for the six faces of the cube
|
||||
//------------------------------------
|
||||
|
||||
enum CubeMapFace
|
||||
{
|
||||
CUBEFACE_POS_X, // +X face
|
||||
CUBEFACE_NEG_X, // -X face
|
||||
CUBEFACE_POS_Y, // +Y face
|
||||
CUBEFACE_NEG_Y, // -Y face
|
||||
CUBEFACE_POS_Z, // +Z face
|
||||
CUBEFACE_NEG_Z // -Z face
|
||||
};
|
||||
|
||||
namespace CubeMap
|
||||
{
|
||||
//---------------------------------------------
|
||||
// Width and height of a cube's face, in pixels
|
||||
//---------------------------------------------
|
||||
|
||||
int sizeOfFace (const Imath::Box2i &dataWindow);
|
||||
|
||||
|
||||
//------------------------------------------
|
||||
// Compute the region in the environment map
|
||||
// that is covered by the specified face.
|
||||
//------------------------------------------
|
||||
|
||||
Imath::Box2i dataWindowForFace (CubeMapFace face,
|
||||
const Imath::Box2i &dataWindow);
|
||||
|
||||
|
||||
//----------------------------------------------------
|
||||
// Convert the coordinates of a pixel within a face
|
||||
// [in the range from (0,0) to (s-1,s-1), where
|
||||
// s == sizeOfFace(dataWindow)] to pixel coordinates
|
||||
// in the environment map.
|
||||
//----------------------------------------------------
|
||||
|
||||
Imath::V2f pixelPosition (CubeMapFace face,
|
||||
const Imath::Box2i &dataWindow,
|
||||
Imath::V2f positionInFace);
|
||||
|
||||
|
||||
//--------------------------------------------------------------
|
||||
// Convert a 3D direction into a cube face, and a pixel position
|
||||
// within that face.
|
||||
//
|
||||
// If you have a 3D direction, dir, the following code fragment
|
||||
// finds the position, pos, of the corresponding pixel in an
|
||||
// environment map with data window dw:
|
||||
//
|
||||
// CubeMapFace f;
|
||||
// V2f pif, pos;
|
||||
//
|
||||
// faceAndPixelPosition (dir, dw, f, pif);
|
||||
// pos = pixelPosition (f, dw, pif);
|
||||
//
|
||||
//--------------------------------------------------------------
|
||||
|
||||
void faceAndPixelPosition (const Imath::V3f &direction,
|
||||
const Imath::Box2i &dataWindow,
|
||||
CubeMapFace &face,
|
||||
Imath::V2f &positionInFace);
|
||||
|
||||
|
||||
// --------------------------------------------------------
|
||||
// Given a cube face and a pixel position within that face,
|
||||
// compute the corresponding 3D direction.
|
||||
// --------------------------------------------------------
|
||||
|
||||
Imath::V3f direction (CubeMapFace face,
|
||||
const Imath::Box2i &dataWindow,
|
||||
const Imath::V2f &positionInFace);
|
||||
}
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
|
||||
#endif
|
||||
@@ -1,75 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class EnvmapAttribute
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfEnvmapAttribute.h>
|
||||
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
template <>
|
||||
const char *
|
||||
EnvmapAttribute::staticTypeName ()
|
||||
{
|
||||
return "envmap";
|
||||
}
|
||||
|
||||
|
||||
template <>
|
||||
void
|
||||
EnvmapAttribute::writeValueTo (OStream &os, int version) const
|
||||
{
|
||||
unsigned char tmp = _value;
|
||||
Xdr::write <StreamIO> (os, tmp);
|
||||
}
|
||||
|
||||
|
||||
template <>
|
||||
void
|
||||
EnvmapAttribute::readValueFrom (IStream &is, int size, int version)
|
||||
{
|
||||
unsigned char tmp;
|
||||
Xdr::read <StreamIO> (is, tmp);
|
||||
_value = Envmap (tmp);
|
||||
}
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
@@ -1,65 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef INCLUDED_IMF_ENVMAP_ATTRIBUTE_H
|
||||
#define INCLUDED_IMF_ENVMAP_ATTRIBUTE_H
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class EnvmapAttribute
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfAttribute.h>
|
||||
#include <ImfEnvmap.h>
|
||||
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
typedef TypedAttribute<Envmap> EnvmapAttribute;
|
||||
template <> const char *EnvmapAttribute::staticTypeName ();
|
||||
template <> void EnvmapAttribute::writeValueTo (OStream &, int) const;
|
||||
template <> void EnvmapAttribute::readValueFrom (IStream &, int, int);
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
|
||||
// Metrowerks compiler wants the .cpp file inlined, too
|
||||
#ifdef __MWERKS__
|
||||
#include <ImfEnvmapAttribute.cpp>
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -1,57 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class FloatAttribute
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfFloatAttribute.h>
|
||||
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
template <>
|
||||
const char *
|
||||
FloatAttribute::staticTypeName ()
|
||||
{
|
||||
return "float";
|
||||
}
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
@@ -1,63 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
#ifndef INCLUDED_IMF_FLOAT_ATTRIBUTE_H
|
||||
#define INCLUDED_IMF_FLOAT_ATTRIBUTE_H
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class FloatAttribute
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfAttribute.h>
|
||||
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
typedef TypedAttribute<float> FloatAttribute;
|
||||
template <> const char *FloatAttribute::staticTypeName ();
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
|
||||
// Metrowerks compiler wants the .cpp file inlined, too
|
||||
#ifdef __MWERKS__
|
||||
#include <ImfFloatAttribute.cpp>
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -1,176 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class Slice
|
||||
// class FrameBuffer
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfFrameBuffer.h>
|
||||
#include "Iex.h"
|
||||
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
Slice::Slice (PixelType t,
|
||||
char *b,
|
||||
size_t xst,
|
||||
size_t yst,
|
||||
int xsm,
|
||||
int ysm,
|
||||
double fv,
|
||||
bool xtc,
|
||||
bool ytc)
|
||||
:
|
||||
type (t),
|
||||
base (b),
|
||||
xStride (xst),
|
||||
yStride (yst),
|
||||
xSampling (xsm),
|
||||
ySampling (ysm),
|
||||
fillValue (fv),
|
||||
xTileCoords (xtc),
|
||||
yTileCoords (ytc)
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
FrameBuffer::insert (const char name[], const Slice &slice)
|
||||
{
|
||||
if (name[0] == 0)
|
||||
{
|
||||
THROW (Iex::ArgExc,
|
||||
"Frame buffer slice name cannot be an empty string.");
|
||||
}
|
||||
|
||||
_map[name] = slice;
|
||||
}
|
||||
|
||||
|
||||
Slice &
|
||||
FrameBuffer::operator [] (const char name[])
|
||||
{
|
||||
SliceMap::iterator i = _map.find (name);
|
||||
|
||||
if (i == _map.end())
|
||||
{
|
||||
THROW (Iex::ArgExc,
|
||||
"Cannot find frame buffer slice \"" << name << "\".");
|
||||
}
|
||||
|
||||
return i->second;
|
||||
}
|
||||
|
||||
|
||||
const Slice &
|
||||
FrameBuffer::operator [] (const char name[]) const
|
||||
{
|
||||
SliceMap::const_iterator i = _map.find (name);
|
||||
|
||||
if (i == _map.end())
|
||||
{
|
||||
THROW (Iex::ArgExc,
|
||||
"Cannot find frame buffer slice \"" << name << "\".");
|
||||
}
|
||||
|
||||
return i->second;
|
||||
}
|
||||
|
||||
|
||||
Slice *
|
||||
FrameBuffer::findSlice (const char name[])
|
||||
{
|
||||
SliceMap::iterator i = _map.find (name);
|
||||
return (i == _map.end())? 0: &i->second;
|
||||
}
|
||||
|
||||
|
||||
const Slice *
|
||||
FrameBuffer::findSlice (const char name[]) const
|
||||
{
|
||||
SliceMap::const_iterator i = _map.find (name);
|
||||
return (i == _map.end())? 0: &i->second;
|
||||
}
|
||||
|
||||
|
||||
FrameBuffer::Iterator
|
||||
FrameBuffer::begin ()
|
||||
{
|
||||
return _map.begin();
|
||||
}
|
||||
|
||||
|
||||
FrameBuffer::ConstIterator
|
||||
FrameBuffer::begin () const
|
||||
{
|
||||
return _map.begin();
|
||||
}
|
||||
|
||||
|
||||
FrameBuffer::Iterator
|
||||
FrameBuffer::end ()
|
||||
{
|
||||
return _map.end();
|
||||
}
|
||||
|
||||
|
||||
FrameBuffer::ConstIterator
|
||||
FrameBuffer::end () const
|
||||
{
|
||||
return _map.end();
|
||||
}
|
||||
|
||||
|
||||
FrameBuffer::Iterator
|
||||
FrameBuffer::find (const char name[])
|
||||
{
|
||||
return _map.find (name);
|
||||
}
|
||||
|
||||
|
||||
FrameBuffer::ConstIterator
|
||||
FrameBuffer::find (const char name[]) const
|
||||
{
|
||||
return _map.find (name);
|
||||
}
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
@@ -1,368 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
#ifndef INCLUDED_IMF_FRAME_BUFFER_H
|
||||
#define INCLUDED_IMF_FRAME_BUFFER_H
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class Slice
|
||||
// class FrameBuffer
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfName.h>
|
||||
#include <ImfPixelType.h>
|
||||
#include <map>
|
||||
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
//-------------------------------------------------------
|
||||
// Description of a single slice of the frame buffer:
|
||||
//
|
||||
// Note -- terminology: as part of a file, a component of
|
||||
// an image (e.g. red, green, blue, depth etc.) is called
|
||||
// a "channel". As part of a frame buffer, an image
|
||||
// component is called a "slice".
|
||||
//-------------------------------------------------------
|
||||
|
||||
struct Slice
|
||||
{
|
||||
//------------------------------
|
||||
// Data type; see ImfPixelType.h
|
||||
//------------------------------
|
||||
|
||||
PixelType type;
|
||||
|
||||
|
||||
//---------------------------------------------------------------------
|
||||
// Memory layout: The address of pixel (x, y) is
|
||||
//
|
||||
// base + (xp / xSampling) * xStride + (yp / ySampling) * yStride
|
||||
//
|
||||
// where xp and yp are computed as follows:
|
||||
//
|
||||
// * If we are reading or writing a scanline-based file:
|
||||
//
|
||||
// xp = x
|
||||
// yp = y
|
||||
//
|
||||
// * If we are reading a tile whose upper left coorner is at (xt, yt):
|
||||
//
|
||||
// if xTileCoords is true then xp = x - xt, else xp = x
|
||||
// if yTileCoords is true then yp = y - yt, else yp = y
|
||||
//
|
||||
//---------------------------------------------------------------------
|
||||
|
||||
char * base;
|
||||
size_t xStride;
|
||||
size_t yStride;
|
||||
|
||||
|
||||
//--------------------------------------------
|
||||
// Subsampling: pixel (x, y) is present in the
|
||||
// slice only if
|
||||
//
|
||||
// x % xSampling == 0 && y % ySampling == 0
|
||||
//
|
||||
//--------------------------------------------
|
||||
|
||||
int xSampling;
|
||||
int ySampling;
|
||||
|
||||
|
||||
//----------------------------------------------------------
|
||||
// Default value, used to fill the slice when a file without
|
||||
// a channel that corresponds to this slice is read.
|
||||
//----------------------------------------------------------
|
||||
|
||||
double fillValue;
|
||||
|
||||
|
||||
//-------------------------------------------------------
|
||||
// For tiled files, the xTileCoords and yTileCoords flags
|
||||
// determine whether pixel addressing is performed using
|
||||
// absolute coordinates or coordinates relative to a
|
||||
// tile's upper left corner. (See the comment on base,
|
||||
// xStride and yStride, above.)
|
||||
//
|
||||
// For scanline-based files these flags have no effect;
|
||||
// pixel addressing is always done using absolute
|
||||
// coordinates.
|
||||
//-------------------------------------------------------
|
||||
|
||||
bool xTileCoords;
|
||||
bool yTileCoords;
|
||||
|
||||
|
||||
//------------
|
||||
// Constructor
|
||||
//------------
|
||||
|
||||
Slice (PixelType type = HALF,
|
||||
char * base = 0,
|
||||
size_t xStride = 0,
|
||||
size_t yStride = 0,
|
||||
int xSampling = 1,
|
||||
int ySampling = 1,
|
||||
double fillValue = 0.0,
|
||||
bool xTileCoords = false,
|
||||
bool yTileCoords = false);
|
||||
};
|
||||
|
||||
|
||||
class FrameBuffer
|
||||
{
|
||||
public:
|
||||
|
||||
//------------
|
||||
// Add a slice
|
||||
//------------
|
||||
|
||||
void insert (const char name[],
|
||||
const Slice &slice);
|
||||
|
||||
//----------------------------------------------------------------
|
||||
// Access to existing slices:
|
||||
//
|
||||
// [n] Returns a reference to the slice with name n.
|
||||
// If no slice with name n exists, an Iex::ArgExc
|
||||
// is thrown.
|
||||
//
|
||||
// findSlice(n) Returns a pointer to the slice with name n,
|
||||
// or 0 if no slice with name n exists.
|
||||
//
|
||||
//----------------------------------------------------------------
|
||||
|
||||
Slice & operator [] (const char name[]);
|
||||
const Slice & operator [] (const char name[]) const;
|
||||
|
||||
Slice * findSlice (const char name[]);
|
||||
const Slice * findSlice (const char name[]) const;
|
||||
|
||||
|
||||
//-----------------------------------------
|
||||
// Iterator-style access to existing slices
|
||||
//-----------------------------------------
|
||||
|
||||
typedef std::map <Name, Slice> SliceMap;
|
||||
|
||||
class Iterator;
|
||||
class ConstIterator;
|
||||
|
||||
Iterator begin ();
|
||||
ConstIterator begin () const;
|
||||
Iterator end ();
|
||||
ConstIterator end () const;
|
||||
Iterator find (const char name[]);
|
||||
ConstIterator find (const char name[]) const;
|
||||
|
||||
private:
|
||||
|
||||
SliceMap _map;
|
||||
};
|
||||
|
||||
|
||||
//----------
|
||||
// Iterators
|
||||
//----------
|
||||
|
||||
class FrameBuffer::Iterator
|
||||
{
|
||||
public:
|
||||
|
||||
Iterator ();
|
||||
Iterator (const FrameBuffer::SliceMap::iterator &i);
|
||||
|
||||
Iterator & operator ++ ();
|
||||
Iterator operator ++ (int);
|
||||
|
||||
const char * name () const;
|
||||
Slice & slice () const;
|
||||
|
||||
private:
|
||||
|
||||
friend class FrameBuffer::ConstIterator;
|
||||
|
||||
FrameBuffer::SliceMap::iterator _i;
|
||||
};
|
||||
|
||||
|
||||
class FrameBuffer::ConstIterator
|
||||
{
|
||||
public:
|
||||
|
||||
ConstIterator ();
|
||||
ConstIterator (const FrameBuffer::SliceMap::const_iterator &i);
|
||||
ConstIterator (const FrameBuffer::Iterator &other);
|
||||
|
||||
ConstIterator & operator ++ ();
|
||||
ConstIterator operator ++ (int);
|
||||
|
||||
const char * name () const;
|
||||
const Slice & slice () const;
|
||||
|
||||
private:
|
||||
|
||||
friend bool operator == (const ConstIterator &, const ConstIterator &);
|
||||
friend bool operator != (const ConstIterator &, const ConstIterator &);
|
||||
|
||||
FrameBuffer::SliceMap::const_iterator _i;
|
||||
};
|
||||
|
||||
|
||||
//-----------------
|
||||
// Inline Functions
|
||||
//-----------------
|
||||
|
||||
inline
|
||||
FrameBuffer::Iterator::Iterator (): _i()
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
|
||||
inline
|
||||
FrameBuffer::Iterator::Iterator (const FrameBuffer::SliceMap::iterator &i):
|
||||
_i (i)
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
|
||||
inline FrameBuffer::Iterator &
|
||||
FrameBuffer::Iterator::operator ++ ()
|
||||
{
|
||||
++_i;
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
inline FrameBuffer::Iterator
|
||||
FrameBuffer::Iterator::operator ++ (int)
|
||||
{
|
||||
Iterator tmp = *this;
|
||||
++_i;
|
||||
return tmp;
|
||||
}
|
||||
|
||||
|
||||
inline const char *
|
||||
FrameBuffer::Iterator::name () const
|
||||
{
|
||||
return *_i->first;
|
||||
}
|
||||
|
||||
|
||||
inline Slice &
|
||||
FrameBuffer::Iterator::slice () const
|
||||
{
|
||||
return _i->second;
|
||||
}
|
||||
|
||||
|
||||
inline
|
||||
FrameBuffer::ConstIterator::ConstIterator (): _i()
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
inline
|
||||
FrameBuffer::ConstIterator::ConstIterator
|
||||
(const FrameBuffer::SliceMap::const_iterator &i): _i (i)
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
|
||||
inline
|
||||
FrameBuffer::ConstIterator::ConstIterator (const FrameBuffer::Iterator &other):
|
||||
_i (other._i)
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
inline FrameBuffer::ConstIterator &
|
||||
FrameBuffer::ConstIterator::operator ++ ()
|
||||
{
|
||||
++_i;
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
inline FrameBuffer::ConstIterator
|
||||
FrameBuffer::ConstIterator::operator ++ (int)
|
||||
{
|
||||
ConstIterator tmp = *this;
|
||||
++_i;
|
||||
return tmp;
|
||||
}
|
||||
|
||||
|
||||
inline const char *
|
||||
FrameBuffer::ConstIterator::name () const
|
||||
{
|
||||
return *_i->first;
|
||||
}
|
||||
|
||||
inline const Slice &
|
||||
FrameBuffer::ConstIterator::slice () const
|
||||
{
|
||||
return _i->second;
|
||||
}
|
||||
|
||||
|
||||
inline bool
|
||||
operator == (const FrameBuffer::ConstIterator &x,
|
||||
const FrameBuffer::ConstIterator &y)
|
||||
{
|
||||
return x._i == y._i;
|
||||
}
|
||||
|
||||
|
||||
inline bool
|
||||
operator != (const FrameBuffer::ConstIterator &x,
|
||||
const FrameBuffer::ConstIterator &y)
|
||||
{
|
||||
return !(x == y);
|
||||
}
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
|
||||
#endif
|
||||
@@ -1,75 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2006, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// Convenience functions related to the framesPerSecond attribute
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfFramesPerSecond.h>
|
||||
#include "ImathFun.h"
|
||||
|
||||
using namespace Imath;
|
||||
|
||||
namespace Imf {
|
||||
|
||||
Rational
|
||||
guessExactFps (double fps)
|
||||
{
|
||||
return guessExactFps (Rational (fps));
|
||||
}
|
||||
|
||||
|
||||
Rational
|
||||
guessExactFps (const Rational &fps)
|
||||
{
|
||||
const double e = 0.002;
|
||||
|
||||
if (abs (double (fps) - double (fps_23_976())) < e)
|
||||
return fps_23_976();
|
||||
|
||||
if (abs (double (fps) - double (fps_29_97())) < e)
|
||||
return fps_29_97();
|
||||
|
||||
if (abs (double (fps) - double (fps_47_952())) < e)
|
||||
return fps_47_952();
|
||||
|
||||
if (abs (double (fps) - double (fps_59_94())) < e)
|
||||
return fps_59_94();
|
||||
|
||||
return fps;
|
||||
}
|
||||
|
||||
} // namespace Imf
|
||||
@@ -1,88 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2006, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
#ifndef INCLUDED_IMF_FRAMES_PER_SECOND_H
|
||||
#define INCLUDED_IMF_FRAMES_PER_SECOND_H
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// Convenience functions related to the framesPerSecond attribute
|
||||
//
|
||||
// Functions that return the exact values for commonly used frame rates:
|
||||
//
|
||||
// name frames per second
|
||||
//
|
||||
// fps_23_976() 23.976023...
|
||||
// fps_24() 24.0 35mm film frames
|
||||
// fps_25() 25.0 PAL video frames
|
||||
// fps_29_97() 29.970029... NTSC video frames
|
||||
// fps_30() 30.0 60Hz HDTV frames
|
||||
// fps_47_952() 47.952047...
|
||||
// fps_48() 48.0
|
||||
// fps_50() 50.0 PAL video fields
|
||||
// fps_59_94() 59.940059... NTSC video fields
|
||||
// fps_60() 60.0 60Hz HDTV fields
|
||||
//
|
||||
// Functions that try to convert inexact frame rates into exact ones:
|
||||
//
|
||||
// Given a frame rate, fps, that is close to one of the pre-defined
|
||||
// frame rates fps_23_976(), fps_29_97(), fps_47_952() or fps_59_94(),
|
||||
// guessExactFps(fps) returns the corresponding pre-defined frame
|
||||
// rate. If fps is not close to one of the pre-defined frame rates,
|
||||
// then guessExactFps(fps) returns Rational(fps).
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfRational.h>
|
||||
|
||||
namespace Imf {
|
||||
|
||||
inline Rational fps_23_976 () {return Rational (24000, 1001);}
|
||||
inline Rational fps_24 () {return Rational (24, 1);}
|
||||
inline Rational fps_25 () {return Rational (25, 1);}
|
||||
inline Rational fps_29_97 () {return Rational (30000, 1001);}
|
||||
inline Rational fps_30 () {return Rational (30, 1);}
|
||||
inline Rational fps_47_952 () {return Rational (48000, 1001);}
|
||||
inline Rational fps_48 () {return Rational (48, 1);}
|
||||
inline Rational fps_50 () {return Rational (50, 1);}
|
||||
inline Rational fps_59_94 () {return Rational (60000, 1001);}
|
||||
inline Rational fps_60 () {return Rational (60, 1);}
|
||||
|
||||
Rational guessExactFps (double fps);
|
||||
Rational guessExactFps (const Rational &fps);
|
||||
|
||||
} // namespace Imf
|
||||
|
||||
#endif
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,577 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
#ifndef INCLUDED_IMF_HEADER_H
|
||||
#define INCLUDED_IMF_HEADER_H
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class Header
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfLineOrder.h>
|
||||
#include <ImfCompression.h>
|
||||
#include <ImfName.h>
|
||||
#include <ImfTileDescription.h>
|
||||
#include <ImfInt64.h>
|
||||
#include "ImathVec.h"
|
||||
#include "ImathBox.h"
|
||||
#include "IexBaseExc.h"
|
||||
#include <map>
|
||||
#include <iosfwd>
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
class Attribute;
|
||||
class ChannelList;
|
||||
class IStream;
|
||||
class OStream;
|
||||
class PreviewImage;
|
||||
|
||||
|
||||
class Header
|
||||
{
|
||||
public:
|
||||
|
||||
//----------------------------------------------------------------
|
||||
// Default constructor -- the display window and the data window
|
||||
// are both set to Box2i (V2i (0, 0), V2i (width-1, height-1).
|
||||
//----------------------------------------------------------------
|
||||
|
||||
Header (int width = 64,
|
||||
int height = 64,
|
||||
float pixelAspectRatio = 1,
|
||||
const Imath::V2f &screenWindowCenter = Imath::V2f (0, 0),
|
||||
float screenWindowWidth = 1,
|
||||
LineOrder lineOrder = INCREASING_Y,
|
||||
Compression = ZIP_COMPRESSION);
|
||||
|
||||
|
||||
//--------------------------------------------------------------------
|
||||
// Constructor -- the data window is specified explicitly; the display
|
||||
// window is set to Box2i (V2i (0, 0), V2i (width-1, height-1).
|
||||
//--------------------------------------------------------------------
|
||||
|
||||
Header (int width,
|
||||
int height,
|
||||
const Imath::Box2i &dataWindow,
|
||||
float pixelAspectRatio = 1,
|
||||
const Imath::V2f &screenWindowCenter = Imath::V2f (0, 0),
|
||||
float screenWindowWidth = 1,
|
||||
LineOrder lineOrder = INCREASING_Y,
|
||||
Compression = ZIP_COMPRESSION);
|
||||
|
||||
|
||||
//----------------------------------------------------------
|
||||
// Constructor -- the display window and the data window are
|
||||
// both specified explicitly.
|
||||
//----------------------------------------------------------
|
||||
|
||||
Header (const Imath::Box2i &displayWindow,
|
||||
const Imath::Box2i &dataWindow,
|
||||
float pixelAspectRatio = 1,
|
||||
const Imath::V2f &screenWindowCenter = Imath::V2f (0, 0),
|
||||
float screenWindowWidth = 1,
|
||||
LineOrder lineOrder = INCREASING_Y,
|
||||
Compression = ZIP_COMPRESSION);
|
||||
|
||||
|
||||
//-----------------
|
||||
// Copy constructor
|
||||
//-----------------
|
||||
|
||||
Header (const Header &other);
|
||||
|
||||
|
||||
//-----------
|
||||
// Destructor
|
||||
//-----------
|
||||
|
||||
~Header ();
|
||||
|
||||
|
||||
//-----------
|
||||
// Assignment
|
||||
//-----------
|
||||
|
||||
Header & operator = (const Header &other);
|
||||
|
||||
|
||||
//---------------------------------------------------------------
|
||||
// Add an attribute:
|
||||
//
|
||||
// insert(n,attr) If no attribute with name n exists, a new
|
||||
// attribute with name n, and the same type as
|
||||
// attr, is added, and the value of attr is
|
||||
// copied into the new attribute.
|
||||
//
|
||||
// If an attribute with name n exists, and its
|
||||
// type is the same as attr, the value of attr
|
||||
// is copied into this attribute.
|
||||
//
|
||||
// If an attribute with name n exists, and its
|
||||
// type is different from attr, an Iex::TypeExc
|
||||
// is thrown.
|
||||
//
|
||||
//---------------------------------------------------------------
|
||||
|
||||
void insert (const char name[],
|
||||
const Attribute &attribute);
|
||||
|
||||
//------------------------------------------------------------------
|
||||
// Access to existing attributes:
|
||||
//
|
||||
// [n] Returns a reference to the attribute
|
||||
// with name n. If no attribute with
|
||||
// name n exists, an Iex::ArgExc is thrown.
|
||||
//
|
||||
// typedAttribute<T>(n) Returns a reference to the attribute
|
||||
// with name n and type T. If no attribute
|
||||
// with name n exists, an Iex::ArgExc is
|
||||
// thrown. If an attribute with name n
|
||||
// exists, but its type is not T, an
|
||||
// Iex::TypeExc is thrown.
|
||||
//
|
||||
// findTypedAttribute<T>(n) Returns a pointer to the attribute with
|
||||
// name n and type T, or 0 if no attribute
|
||||
// with name n and type T exists.
|
||||
//
|
||||
//------------------------------------------------------------------
|
||||
|
||||
Attribute & operator [] (const char name[]);
|
||||
const Attribute & operator [] (const char name[]) const;
|
||||
|
||||
template <class T> T& typedAttribute (const char name[]);
|
||||
template <class T> const T& typedAttribute (const char name[]) const;
|
||||
|
||||
template <class T> T* findTypedAttribute (const char name[]);
|
||||
template <class T> const T* findTypedAttribute (const char name[]) const;
|
||||
|
||||
|
||||
//---------------------------------------------
|
||||
// Iterator-style access to existing attributes
|
||||
//---------------------------------------------
|
||||
|
||||
typedef std::map <Name, Attribute *> AttributeMap;
|
||||
|
||||
class Iterator;
|
||||
class ConstIterator;
|
||||
|
||||
Iterator begin ();
|
||||
ConstIterator begin () const;
|
||||
Iterator end ();
|
||||
ConstIterator end () const;
|
||||
Iterator find (const char name[]);
|
||||
ConstIterator find (const char name[]) const;
|
||||
|
||||
|
||||
//--------------------------------
|
||||
// Access to predefined attributes
|
||||
//--------------------------------
|
||||
|
||||
Imath::Box2i & displayWindow ();
|
||||
const Imath::Box2i & displayWindow () const;
|
||||
|
||||
Imath::Box2i & dataWindow ();
|
||||
const Imath::Box2i & dataWindow () const;
|
||||
|
||||
float & pixelAspectRatio ();
|
||||
const float & pixelAspectRatio () const;
|
||||
|
||||
Imath::V2f & screenWindowCenter ();
|
||||
const Imath::V2f & screenWindowCenter () const;
|
||||
|
||||
float & screenWindowWidth ();
|
||||
const float & screenWindowWidth () const;
|
||||
|
||||
ChannelList & channels ();
|
||||
const ChannelList & channels () const;
|
||||
|
||||
LineOrder & lineOrder ();
|
||||
const LineOrder & lineOrder () const;
|
||||
|
||||
Compression & compression ();
|
||||
const Compression & compression () const;
|
||||
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
// Tile Description:
|
||||
//
|
||||
// The tile description is a TileDescriptionAttribute whose name
|
||||
// is "tiles". The "tiles" attribute must be present in any tiled
|
||||
// image file. When present, it describes various properties of the
|
||||
// tiles that make up the file.
|
||||
//
|
||||
// Convenience functions:
|
||||
//
|
||||
// setTileDescription(td)
|
||||
// calls insert ("tiles", TileDescriptionAttribute (td))
|
||||
//
|
||||
// tileDescription()
|
||||
// returns typedAttribute<TileDescriptionAttribute>("tiles").value()
|
||||
//
|
||||
// hasTileDescription()
|
||||
// return findTypedAttribute<TileDescriptionAttribute>("tiles") != 0
|
||||
//
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
void setTileDescription (const TileDescription & td);
|
||||
|
||||
TileDescription & tileDescription ();
|
||||
const TileDescription & tileDescription () const;
|
||||
|
||||
bool hasTileDescription() const;
|
||||
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
// Preview image:
|
||||
//
|
||||
// The preview image is a PreviewImageAttribute whose name is "preview".
|
||||
// This attribute is special -- while an image file is being written,
|
||||
// the pixels of the preview image can be changed repeatedly by calling
|
||||
// OutputFile::updatePreviewImage().
|
||||
//
|
||||
// Convenience functions:
|
||||
//
|
||||
// setPreviewImage(p)
|
||||
// calls insert ("preview", PreviewImageAttribute (p))
|
||||
//
|
||||
// previewImage()
|
||||
// returns typedAttribute<PreviewImageAttribute>("preview").value()
|
||||
//
|
||||
// hasPreviewImage()
|
||||
// return findTypedAttribute<PreviewImageAttribute>("preview") != 0
|
||||
//
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
void setPreviewImage (const PreviewImage &p);
|
||||
|
||||
PreviewImage & previewImage ();
|
||||
const PreviewImage & previewImage () const;
|
||||
|
||||
bool hasPreviewImage () const;
|
||||
|
||||
|
||||
//-------------------------------------------------------------
|
||||
// Sanity check -- examines the header, and throws an exception
|
||||
// if it finds something wrong (empty display window, negative
|
||||
// pixel aspect ratio, unknown compression sceme etc.)
|
||||
//
|
||||
// set isTiled to true if you are checking a tiled/multi-res
|
||||
// header
|
||||
//-------------------------------------------------------------
|
||||
|
||||
void sanityCheck (bool isTiled = false) const;
|
||||
|
||||
|
||||
//----------------------------------------------------------------
|
||||
// Maximum image size and maximim tile size:
|
||||
//
|
||||
// sanityCheck() will throw an exception if the width or height of
|
||||
// the data window exceeds the maximum image width or height, or
|
||||
// if the size of a tile exceeds the maximum tile width or height.
|
||||
//
|
||||
// At program startup the maximum image and tile width and height
|
||||
// are set to zero, meaning that width and height are unlimited.
|
||||
//
|
||||
// Limiting image and tile width and height limits how much memory
|
||||
// will be allocated when a file is opened. This can help protect
|
||||
// applications from running out of memory while trying to read
|
||||
// a damaged image file.
|
||||
//----------------------------------------------------------------
|
||||
|
||||
static void setMaxImageSize (int maxWidth, int maxHeight);
|
||||
static void setMaxTileSize (int maxWidth, int maxHeight);
|
||||
|
||||
|
||||
//------------------------------------------------------------------
|
||||
// Input and output:
|
||||
//
|
||||
// If the header contains a preview image attribute, then writeTo()
|
||||
// returns the position of that attribute in the output stream; this
|
||||
// information is used by OutputFile::updatePreviewImage().
|
||||
// If the header contains no preview image attribute, then writeTo()
|
||||
// returns 0.
|
||||
//------------------------------------------------------------------
|
||||
|
||||
|
||||
Int64 writeTo (OStream &os,
|
||||
bool isTiled = false) const;
|
||||
|
||||
void readFrom (IStream &is, int &version);
|
||||
|
||||
private:
|
||||
|
||||
AttributeMap _map;
|
||||
};
|
||||
|
||||
|
||||
//----------
|
||||
// Iterators
|
||||
//----------
|
||||
|
||||
class Header::Iterator
|
||||
{
|
||||
public:
|
||||
|
||||
Iterator ();
|
||||
Iterator (const Header::AttributeMap::iterator &i);
|
||||
|
||||
Iterator & operator ++ ();
|
||||
Iterator operator ++ (int);
|
||||
|
||||
const char * name () const;
|
||||
Attribute & attribute () const;
|
||||
|
||||
private:
|
||||
|
||||
friend class Header::ConstIterator;
|
||||
|
||||
Header::AttributeMap::iterator _i;
|
||||
};
|
||||
|
||||
|
||||
class Header::ConstIterator
|
||||
{
|
||||
public:
|
||||
|
||||
ConstIterator ();
|
||||
ConstIterator (const Header::AttributeMap::const_iterator &i);
|
||||
ConstIterator (const Header::Iterator &other);
|
||||
|
||||
ConstIterator & operator ++ ();
|
||||
ConstIterator operator ++ (int);
|
||||
|
||||
const char * name () const;
|
||||
const Attribute & attribute () const;
|
||||
|
||||
private:
|
||||
|
||||
friend bool operator == (const ConstIterator &, const ConstIterator &);
|
||||
friend bool operator != (const ConstIterator &, const ConstIterator &);
|
||||
|
||||
Header::AttributeMap::const_iterator _i;
|
||||
};
|
||||
|
||||
|
||||
//------------------------------------------------------------------------
|
||||
// Library initialization:
|
||||
//
|
||||
// In a multithreaded program, staticInitialize() must be called once
|
||||
// during startup, before the program accesses any other functions or
|
||||
// classes in the IlmImf library. Calling staticInitialize() in this
|
||||
// way avoids races during initialization of the library's global
|
||||
// variables.
|
||||
//
|
||||
// Single-threaded programs are not required to call staticInitialize();
|
||||
// initialization of the library's global variables happens automatically.
|
||||
//
|
||||
//------------------------------------------------------------------------
|
||||
|
||||
void staticInitialize ();
|
||||
|
||||
|
||||
//-----------------
|
||||
// Inline Functions
|
||||
//-----------------
|
||||
|
||||
|
||||
inline
|
||||
Header::Iterator::Iterator (): _i()
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
|
||||
inline
|
||||
Header::Iterator::Iterator (const Header::AttributeMap::iterator &i): _i (i)
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
|
||||
inline Header::Iterator &
|
||||
Header::Iterator::operator ++ ()
|
||||
{
|
||||
++_i;
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
inline Header::Iterator
|
||||
Header::Iterator::operator ++ (int)
|
||||
{
|
||||
Iterator tmp = *this;
|
||||
++_i;
|
||||
return tmp;
|
||||
}
|
||||
|
||||
|
||||
inline const char *
|
||||
Header::Iterator::name () const
|
||||
{
|
||||
return *_i->first;
|
||||
}
|
||||
|
||||
|
||||
inline Attribute &
|
||||
Header::Iterator::attribute () const
|
||||
{
|
||||
return *_i->second;
|
||||
}
|
||||
|
||||
|
||||
inline
|
||||
Header::ConstIterator::ConstIterator (): _i()
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
inline
|
||||
Header::ConstIterator::ConstIterator
|
||||
(const Header::AttributeMap::const_iterator &i): _i (i)
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
|
||||
inline
|
||||
Header::ConstIterator::ConstIterator (const Header::Iterator &other):
|
||||
_i (other._i)
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
inline Header::ConstIterator &
|
||||
Header::ConstIterator::operator ++ ()
|
||||
{
|
||||
++_i;
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
inline Header::ConstIterator
|
||||
Header::ConstIterator::operator ++ (int)
|
||||
{
|
||||
ConstIterator tmp = *this;
|
||||
++_i;
|
||||
return tmp;
|
||||
}
|
||||
|
||||
|
||||
inline const char *
|
||||
Header::ConstIterator::name () const
|
||||
{
|
||||
return *_i->first;
|
||||
}
|
||||
|
||||
|
||||
inline const Attribute &
|
||||
Header::ConstIterator::attribute () const
|
||||
{
|
||||
return *_i->second;
|
||||
}
|
||||
|
||||
|
||||
inline bool
|
||||
operator == (const Header::ConstIterator &x, const Header::ConstIterator &y)
|
||||
{
|
||||
return x._i == y._i;
|
||||
}
|
||||
|
||||
|
||||
inline bool
|
||||
operator != (const Header::ConstIterator &x, const Header::ConstIterator &y)
|
||||
{
|
||||
return !(x == y);
|
||||
}
|
||||
|
||||
|
||||
//---------------------
|
||||
// Template definitions
|
||||
//---------------------
|
||||
|
||||
template <class T>
|
||||
T &
|
||||
Header::typedAttribute (const char name[])
|
||||
{
|
||||
Attribute *attr = &(*this)[name];
|
||||
T *tattr = dynamic_cast <T*> (attr);
|
||||
|
||||
if (tattr == 0)
|
||||
throw Iex::TypeExc ("Unexpected attribute type.");
|
||||
|
||||
return *tattr;
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
const T &
|
||||
Header::typedAttribute (const char name[]) const
|
||||
{
|
||||
const Attribute *attr = &(*this)[name];
|
||||
const T *tattr = dynamic_cast <const T*> (attr);
|
||||
|
||||
if (tattr == 0)
|
||||
throw Iex::TypeExc ("Unexpected attribute type.");
|
||||
|
||||
return *tattr;
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
T *
|
||||
Header::findTypedAttribute (const char name[])
|
||||
{
|
||||
AttributeMap::iterator i = _map.find (name);
|
||||
return (i == _map.end())? 0: dynamic_cast <T*> (i->second);
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
const T *
|
||||
Header::findTypedAttribute (const char name[]) const
|
||||
{
|
||||
AttributeMap::const_iterator i = _map.find (name);
|
||||
return (i == _map.end())? 0: dynamic_cast <const T*> (i->second);
|
||||
}
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
|
||||
#endif
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,79 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
#ifndef INCLUDED_IMF_HUF_H
|
||||
#define INCLUDED_IMF_HUF_H
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// 16-bit Huffman compression and decompression:
|
||||
//
|
||||
// hufCompress (r, nr, c)
|
||||
//
|
||||
// Compresses the contents of array r (of length nr),
|
||||
// stores the compressed data in array c, and returns
|
||||
// the size of the compressed data (in bytes).
|
||||
//
|
||||
// To avoid buffer overflows, the size of array c should
|
||||
// be at least 2 * nr + 65536.
|
||||
//
|
||||
// hufUncompress (c, nc, r, nr)
|
||||
//
|
||||
// Uncompresses the data in array c (with length nc),
|
||||
// and stores the results in array r (with length nr).
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
int
|
||||
hufCompress (const unsigned short raw[/*nRaw*/],
|
||||
int nRaw,
|
||||
char compressed[/*2 * nRaw + 65536*/]);
|
||||
|
||||
|
||||
void
|
||||
hufUncompress (const char compressed[/*nCompressed*/],
|
||||
int nCompressed,
|
||||
unsigned short raw[/*nRaw*/],
|
||||
int nRaw);
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
|
||||
#endif
|
||||
@@ -1,109 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// Low-level file input and output for OpenEXR.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfIO.h>
|
||||
#include "Iex.h"
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
IStream::IStream (const char fileName[]): _fileName (fileName)
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
|
||||
IStream::~IStream ()
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
|
||||
bool
|
||||
IStream::isMemoryMapped () const
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
char *
|
||||
IStream::readMemoryMapped (int n)
|
||||
{
|
||||
throw Iex::InputExc ("Attempt to perform a memory-mapped read "
|
||||
"on a file that is not memory mapped.");
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
IStream::clear ()
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
|
||||
const char *
|
||||
IStream::fileName () const
|
||||
{
|
||||
return _fileName.c_str();
|
||||
}
|
||||
|
||||
|
||||
OStream::OStream (const char fileName[]): _fileName (fileName)
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
|
||||
OStream::~OStream ()
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
|
||||
const char *
|
||||
OStream::fileName () const
|
||||
{
|
||||
return _fileName.c_str();
|
||||
}
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
@@ -1,252 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
#ifndef INCLUDED_IMF_IO_H
|
||||
#define INCLUDED_IMF_IO_H
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// Low-level file input and output for OpenEXR.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfInt64.h>
|
||||
#include <string>
|
||||
|
||||
namespace Imf {
|
||||
|
||||
//-----------------------------------------------------------
|
||||
// class IStream -- an abstract base class for input streams.
|
||||
//-----------------------------------------------------------
|
||||
|
||||
class IStream
|
||||
{
|
||||
public:
|
||||
|
||||
//-----------
|
||||
// Destructor
|
||||
//-----------
|
||||
|
||||
virtual ~IStream ();
|
||||
|
||||
|
||||
//-------------------------------------------------
|
||||
// Does this input stream support memory-mapped IO?
|
||||
//
|
||||
// Memory-mapped streams can avoid an extra copy;
|
||||
// memory-mapped read operations return a pointer
|
||||
// to an internal buffer instead of copying data
|
||||
// into a buffer supplied by the caller.
|
||||
//-------------------------------------------------
|
||||
|
||||
virtual bool isMemoryMapped () const;
|
||||
|
||||
|
||||
//------------------------------------------------------
|
||||
// Read from the stream:
|
||||
//
|
||||
// read(c,n) reads n bytes from the stream, and stores
|
||||
// them in array c. If the stream contains less than n
|
||||
// bytes, or if an I/O error occurs, read(c,n) throws
|
||||
// an exception. If read(c,n) reads the last byte from
|
||||
// the file it returns false, otherwise it returns true.
|
||||
//------------------------------------------------------
|
||||
|
||||
virtual bool read (char c[/*n*/], int n) = 0;
|
||||
|
||||
|
||||
//---------------------------------------------------
|
||||
// Read from a memory-mapped stream:
|
||||
//
|
||||
// readMemoryMapped(n) reads n bytes from the stream
|
||||
// and returns a pointer to the first byte. The
|
||||
// returned pointer remains valid until the stream
|
||||
// is closed. If there are less than n byte left to
|
||||
// read in the stream or if the stream is not memory-
|
||||
// mapped, readMemoryMapped(n) throws an exception.
|
||||
//---------------------------------------------------
|
||||
|
||||
virtual char * readMemoryMapped (int n);
|
||||
|
||||
|
||||
//--------------------------------------------------------
|
||||
// Get the current reading position, in bytes from the
|
||||
// beginning of the file. If the next call to read() will
|
||||
// read the first byte in the file, tellg() returns 0.
|
||||
//--------------------------------------------------------
|
||||
|
||||
virtual Int64 tellg () = 0;
|
||||
|
||||
|
||||
//-------------------------------------------
|
||||
// Set the current reading position.
|
||||
// After calling seekg(i), tellg() returns i.
|
||||
//-------------------------------------------
|
||||
|
||||
virtual void seekg (Int64 pos) = 0;
|
||||
|
||||
|
||||
//------------------------------------------------------
|
||||
// Clear error conditions after an operation has failed.
|
||||
//------------------------------------------------------
|
||||
|
||||
virtual void clear ();
|
||||
|
||||
|
||||
//------------------------------------------------------
|
||||
// Get the name of the file associated with this stream.
|
||||
//------------------------------------------------------
|
||||
|
||||
const char * fileName () const;
|
||||
|
||||
protected:
|
||||
|
||||
IStream (const char fileName[]);
|
||||
|
||||
private:
|
||||
|
||||
IStream (const IStream &); // not implemented
|
||||
IStream & operator = (const IStream &); // not implemented
|
||||
|
||||
std::string _fileName;
|
||||
};
|
||||
|
||||
|
||||
//-----------------------------------------------------------
|
||||
// class OStream -- an abstract base class for output streams
|
||||
//-----------------------------------------------------------
|
||||
|
||||
class OStream
|
||||
{
|
||||
public:
|
||||
|
||||
//-----------
|
||||
// Destructor
|
||||
//-----------
|
||||
|
||||
virtual ~OStream ();
|
||||
|
||||
|
||||
//----------------------------------------------------------
|
||||
// Write to the stream:
|
||||
//
|
||||
// write(c,n) takes n bytes from array c, and stores them
|
||||
// in the stream. If an I/O error occurs, write(c,n) throws
|
||||
// an exception.
|
||||
//----------------------------------------------------------
|
||||
|
||||
virtual void write (const char c[/*n*/], int n) = 0;
|
||||
|
||||
|
||||
//---------------------------------------------------------
|
||||
// Get the current writing position, in bytes from the
|
||||
// beginning of the file. If the next call to write() will
|
||||
// start writing at the beginning of the file, tellp()
|
||||
// returns 0.
|
||||
//---------------------------------------------------------
|
||||
|
||||
virtual Int64 tellp () = 0;
|
||||
|
||||
|
||||
//-------------------------------------------
|
||||
// Set the current writing position.
|
||||
// After calling seekp(i), tellp() returns i.
|
||||
//-------------------------------------------
|
||||
|
||||
virtual void seekp (Int64 pos) = 0;
|
||||
|
||||
|
||||
//------------------------------------------------------
|
||||
// Get the name of the file associated with this stream.
|
||||
//------------------------------------------------------
|
||||
|
||||
const char * fileName () const;
|
||||
|
||||
protected:
|
||||
|
||||
OStream (const char fileName[]);
|
||||
|
||||
private:
|
||||
|
||||
OStream (const OStream &); // not implemented
|
||||
OStream & operator = (const OStream &); // not implemented
|
||||
|
||||
std::string _fileName;
|
||||
};
|
||||
|
||||
|
||||
//-----------------------
|
||||
// Helper classes for Xdr
|
||||
//-----------------------
|
||||
|
||||
struct StreamIO
|
||||
{
|
||||
static void
|
||||
writeChars (OStream &os, const char c[/*n*/], int n)
|
||||
{
|
||||
os.write (c, n);
|
||||
}
|
||||
|
||||
static bool
|
||||
readChars (IStream &is, char c[/*n*/], int n)
|
||||
{
|
||||
return is.read (c, n);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
struct CharPtrIO
|
||||
{
|
||||
static void
|
||||
writeChars (char *&op, const char c[/*n*/], int n)
|
||||
{
|
||||
while (n--)
|
||||
*op++ = *c++;
|
||||
}
|
||||
|
||||
static bool
|
||||
readChars (const char *&ip, char c[/*n*/], int n)
|
||||
{
|
||||
while (n--)
|
||||
*c++ = *ip++;
|
||||
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
|
||||
#endif
|
||||
@@ -1,648 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class InputFile
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfInputFile.h>
|
||||
#include <ImfScanLineInputFile.h>
|
||||
#include <ImfTiledInputFile.h>
|
||||
#include <ImfChannelList.h>
|
||||
#include <ImfMisc.h>
|
||||
#include <ImfStdIO.h>
|
||||
#include <ImfVersion.h>
|
||||
#include "ImathFun.h"
|
||||
#include "IlmThreadMutex.h"
|
||||
#include "Iex.h"
|
||||
#include "half.h"
|
||||
#include <fstream>
|
||||
#include <algorithm>
|
||||
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
using Imath::Box2i;
|
||||
using Imath::divp;
|
||||
using Imath::modp;
|
||||
using IlmThread::Mutex;
|
||||
using IlmThread::Lock;
|
||||
|
||||
|
||||
//
|
||||
// Struct InputFile::Data stores things that will be
|
||||
// needed between calls to readPixels
|
||||
//
|
||||
|
||||
struct InputFile::Data: public Mutex
|
||||
{
|
||||
Header header;
|
||||
int version;
|
||||
IStream * is;
|
||||
bool deleteStream;
|
||||
|
||||
TiledInputFile * tFile;
|
||||
ScanLineInputFile * sFile;
|
||||
|
||||
LineOrder lineOrder; // the file's lineorder
|
||||
int minY; // data window's min y coord
|
||||
int maxY; // data window's max x coord
|
||||
|
||||
FrameBuffer tFileBuffer;
|
||||
FrameBuffer * cachedBuffer;
|
||||
|
||||
int cachedTileY;
|
||||
int offset;
|
||||
|
||||
int numThreads;
|
||||
|
||||
Data (bool del, int numThreads);
|
||||
~Data ();
|
||||
|
||||
void deleteCachedBuffer();
|
||||
};
|
||||
|
||||
|
||||
InputFile::Data::Data (bool del, int numThreads):
|
||||
is (0),
|
||||
deleteStream (del),
|
||||
tFile (0),
|
||||
sFile (0),
|
||||
cachedBuffer (0),
|
||||
cachedTileY (-1),
|
||||
numThreads (numThreads)
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
|
||||
InputFile::Data::~Data ()
|
||||
{
|
||||
delete tFile;
|
||||
delete sFile;
|
||||
|
||||
if (deleteStream)
|
||||
delete is;
|
||||
|
||||
deleteCachedBuffer();
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
InputFile::Data::deleteCachedBuffer()
|
||||
{
|
||||
//
|
||||
// Delete the cached frame buffer, and all memory
|
||||
// allocated for the slices in the cached frameBuffer.
|
||||
//
|
||||
|
||||
if (cachedBuffer)
|
||||
{
|
||||
for (FrameBuffer::Iterator k = cachedBuffer->begin();
|
||||
k != cachedBuffer->end();
|
||||
++k)
|
||||
{
|
||||
Slice &s = k.slice();
|
||||
|
||||
switch (s.type)
|
||||
{
|
||||
case UINT:
|
||||
|
||||
delete [] (((unsigned int *)s.base) + offset);
|
||||
break;
|
||||
|
||||
case HALF:
|
||||
|
||||
delete [] ((half *)s.base + offset);
|
||||
break;
|
||||
|
||||
case FLOAT:
|
||||
|
||||
delete [] (((float *)s.base) + offset);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// delete the cached frame buffer
|
||||
//
|
||||
|
||||
delete cachedBuffer;
|
||||
cachedBuffer = 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
namespace {
|
||||
|
||||
void
|
||||
bufferedReadPixels (InputFile::Data* ifd, int scanLine1, int scanLine2)
|
||||
{
|
||||
//
|
||||
// bufferedReadPixels reads each row of tiles that intersect the
|
||||
// scan-line range (scanLine1 to scanLine2). The previous row of
|
||||
// tiles is cached in order to prevent redundent tile reads when
|
||||
// accessing scanlines sequentially.
|
||||
//
|
||||
|
||||
int minY = std::min (scanLine1, scanLine2);
|
||||
int maxY = std::max (scanLine1, scanLine2);
|
||||
|
||||
if (minY < ifd->minY || maxY > ifd->maxY)
|
||||
{
|
||||
throw Iex::ArgExc ("Tried to read scan line outside "
|
||||
"the image file's data window.");
|
||||
}
|
||||
|
||||
//
|
||||
// The minimum and maximum y tile coordinates that intersect this
|
||||
// scanline range
|
||||
//
|
||||
|
||||
int minDy = (minY - ifd->minY) / ifd->tFile->tileYSize();
|
||||
int maxDy = (maxY - ifd->minY) / ifd->tFile->tileYSize();
|
||||
|
||||
//
|
||||
// Figure out which one is first in the file so we can read without seeking
|
||||
//
|
||||
|
||||
int yStart, yEnd, yStep;
|
||||
|
||||
if (ifd->lineOrder == DECREASING_Y)
|
||||
{
|
||||
yStart = maxDy;
|
||||
yEnd = minDy - 1;
|
||||
yStep = -1;
|
||||
}
|
||||
else
|
||||
{
|
||||
yStart = minDy;
|
||||
yEnd = maxDy + 1;
|
||||
yStep = 1;
|
||||
}
|
||||
|
||||
//
|
||||
// the number of pixels in a row of tiles
|
||||
//
|
||||
|
||||
Box2i levelRange = ifd->tFile->dataWindowForLevel(0);
|
||||
|
||||
//
|
||||
// Read the tiles into our temporary framebuffer and copy them into
|
||||
// the user's buffer
|
||||
//
|
||||
|
||||
for (int j = yStart; j != yEnd; j += yStep)
|
||||
{
|
||||
Box2i tileRange = ifd->tFile->dataWindowForTile (0, j, 0);
|
||||
|
||||
int minYThisRow = std::max (minY, tileRange.min.y);
|
||||
int maxYThisRow = std::min (maxY, tileRange.max.y);
|
||||
|
||||
if (j != ifd->cachedTileY)
|
||||
{
|
||||
//
|
||||
// We don't have any valid buffered info, so we need to read in
|
||||
// from the file.
|
||||
//
|
||||
|
||||
ifd->tFile->readTiles (0, ifd->tFile->numXTiles (0) - 1, j, j);
|
||||
ifd->cachedTileY = j;
|
||||
}
|
||||
|
||||
//
|
||||
// Copy the data from our cached framebuffer into the user's
|
||||
// framebuffer.
|
||||
//
|
||||
|
||||
for (FrameBuffer::ConstIterator k = ifd->cachedBuffer->begin();
|
||||
k != ifd->cachedBuffer->end();
|
||||
++k)
|
||||
{
|
||||
Slice fromSlice = k.slice(); // slice to write from
|
||||
Slice toSlice = ifd->tFileBuffer[k.name()]; // slice to write to
|
||||
|
||||
char *fromPtr, *toPtr;
|
||||
int size = pixelTypeSize (toSlice.type);
|
||||
|
||||
int xStart = levelRange.min.x;
|
||||
int yStart = minYThisRow;
|
||||
|
||||
while (modp (xStart, toSlice.xSampling) != 0)
|
||||
++xStart;
|
||||
|
||||
while (modp (yStart, toSlice.ySampling) != 0)
|
||||
++yStart;
|
||||
|
||||
for (int y = yStart;
|
||||
y <= maxYThisRow;
|
||||
y += toSlice.ySampling)
|
||||
{
|
||||
//
|
||||
// Set the pointers to the start of the y scanline in
|
||||
// this row of tiles
|
||||
//
|
||||
|
||||
fromPtr = fromSlice.base +
|
||||
(y - tileRange.min.y) * fromSlice.yStride +
|
||||
xStart * fromSlice.xStride;
|
||||
|
||||
toPtr = toSlice.base +
|
||||
divp (y, toSlice.ySampling) * toSlice.yStride +
|
||||
divp (xStart, toSlice.xSampling) * toSlice.xStride;
|
||||
|
||||
//
|
||||
// Copy all pixels for the scanline in this row of tiles
|
||||
//
|
||||
|
||||
for (int x = xStart;
|
||||
x <= levelRange.max.x;
|
||||
x += toSlice.xSampling)
|
||||
{
|
||||
for (size_t i = 0; i < size; ++i)
|
||||
toPtr[i] = fromPtr[i];
|
||||
|
||||
fromPtr += fromSlice.xStride * toSlice.xSampling;
|
||||
toPtr += toSlice.xStride;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
|
||||
|
||||
InputFile::InputFile (const char fileName[], int numThreads):
|
||||
_data (new Data (true, numThreads))
|
||||
{
|
||||
try
|
||||
{
|
||||
_data->is = new StdIFStream (fileName);
|
||||
initialize();
|
||||
}
|
||||
catch (Iex::BaseExc &e)
|
||||
{
|
||||
delete _data;
|
||||
|
||||
REPLACE_EXC (e, "Cannot read image file "
|
||||
"\"" << fileName << "\". " << e);
|
||||
throw;
|
||||
}
|
||||
catch (...)
|
||||
{
|
||||
delete _data;
|
||||
throw;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
InputFile::InputFile (IStream &is, int numThreads):
|
||||
_data (new Data (false, numThreads))
|
||||
{
|
||||
try
|
||||
{
|
||||
_data->is = &is;
|
||||
initialize();
|
||||
}
|
||||
catch (Iex::BaseExc &e)
|
||||
{
|
||||
delete _data;
|
||||
|
||||
REPLACE_EXC (e, "Cannot read image file "
|
||||
"\"" << is.fileName() << "\". " << e);
|
||||
throw;
|
||||
}
|
||||
catch (...)
|
||||
{
|
||||
delete _data;
|
||||
throw;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
InputFile::initialize ()
|
||||
{
|
||||
_data->header.readFrom (*_data->is, _data->version);
|
||||
_data->header.sanityCheck (isTiled (_data->version));
|
||||
|
||||
if (isTiled (_data->version))
|
||||
{
|
||||
_data->lineOrder = _data->header.lineOrder();
|
||||
|
||||
//
|
||||
// Save the dataWindow information
|
||||
//
|
||||
|
||||
const Box2i &dataWindow = _data->header.dataWindow();
|
||||
_data->minY = dataWindow.min.y;
|
||||
_data->maxY = dataWindow.max.y;
|
||||
|
||||
_data->tFile = new TiledInputFile (_data->header,
|
||||
_data->is,
|
||||
_data->version,
|
||||
_data->numThreads);
|
||||
}
|
||||
else
|
||||
{
|
||||
_data->sFile = new ScanLineInputFile (_data->header,
|
||||
_data->is,
|
||||
_data->numThreads);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
InputFile::~InputFile ()
|
||||
{
|
||||
delete _data;
|
||||
}
|
||||
|
||||
|
||||
const char *
|
||||
InputFile::fileName () const
|
||||
{
|
||||
return _data->is->fileName();
|
||||
}
|
||||
|
||||
|
||||
const Header &
|
||||
InputFile::header () const
|
||||
{
|
||||
return _data->header;
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
InputFile::version () const
|
||||
{
|
||||
return _data->version;
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
InputFile::setFrameBuffer (const FrameBuffer &frameBuffer)
|
||||
{
|
||||
if (isTiled (_data->version))
|
||||
{
|
||||
Lock lock (*_data);
|
||||
|
||||
//
|
||||
// We must invalidate the cached buffer if the new frame
|
||||
// buffer has a different set of channels than the old
|
||||
// frame buffer, or if the type of a channel has changed.
|
||||
//
|
||||
|
||||
const FrameBuffer &oldFrameBuffer = _data->tFileBuffer;
|
||||
|
||||
FrameBuffer::ConstIterator i = oldFrameBuffer.begin();
|
||||
FrameBuffer::ConstIterator j = frameBuffer.begin();
|
||||
|
||||
while (i != oldFrameBuffer.end())
|
||||
{
|
||||
if (strcmp (i.name(), j.name()) || i.slice().type != j.slice().type)
|
||||
break;
|
||||
|
||||
++i;
|
||||
++j;
|
||||
}
|
||||
|
||||
if (i != oldFrameBuffer.end() || j != frameBuffer.end())
|
||||
{
|
||||
//
|
||||
// Invalidate the cached buffer.
|
||||
//
|
||||
|
||||
_data->deleteCachedBuffer ();
|
||||
_data->cachedTileY = -1;
|
||||
|
||||
//
|
||||
// Create new a cached frame buffer. It can hold a single
|
||||
// row of tiles. The cached buffer can be reused for each
|
||||
// row of tiles because we set the yTileCoords parameter of
|
||||
// each Slice to true.
|
||||
//
|
||||
|
||||
const Box2i &dataWindow = _data->header.dataWindow();
|
||||
_data->cachedBuffer = new FrameBuffer();
|
||||
_data->offset = dataWindow.min.x;
|
||||
|
||||
int tileRowSize = (dataWindow.max.x - dataWindow.min.x + 1) *
|
||||
_data->tFile->tileYSize();
|
||||
|
||||
for (FrameBuffer::ConstIterator k = frameBuffer.begin();
|
||||
k != frameBuffer.end();
|
||||
++k)
|
||||
{
|
||||
Slice s = k.slice();
|
||||
|
||||
switch (s.type)
|
||||
{
|
||||
case UINT:
|
||||
|
||||
_data->cachedBuffer->insert
|
||||
(k.name(),
|
||||
Slice (UINT,
|
||||
(char *)(new unsigned int[tileRowSize] -
|
||||
_data->offset),
|
||||
sizeof (unsigned int),
|
||||
sizeof (unsigned int) *
|
||||
_data->tFile->levelWidth(0),
|
||||
1, 1,
|
||||
s.fillValue,
|
||||
false, true));
|
||||
break;
|
||||
|
||||
case HALF:
|
||||
|
||||
_data->cachedBuffer->insert
|
||||
(k.name(),
|
||||
Slice (HALF,
|
||||
(char *)(new half[tileRowSize] -
|
||||
_data->offset),
|
||||
sizeof (half),
|
||||
sizeof (half) *
|
||||
_data->tFile->levelWidth(0),
|
||||
1, 1,
|
||||
s.fillValue,
|
||||
false, true));
|
||||
break;
|
||||
|
||||
case FLOAT:
|
||||
|
||||
_data->cachedBuffer->insert
|
||||
(k.name(),
|
||||
Slice (FLOAT,
|
||||
(char *)(new float[tileRowSize] -
|
||||
_data->offset),
|
||||
sizeof(float),
|
||||
sizeof(float) *
|
||||
_data->tFile->levelWidth(0),
|
||||
1, 1,
|
||||
s.fillValue,
|
||||
false, true));
|
||||
break;
|
||||
|
||||
default:
|
||||
|
||||
throw Iex::ArgExc ("Unknown pixel data type.");
|
||||
}
|
||||
}
|
||||
|
||||
_data->tFile->setFrameBuffer (*_data->cachedBuffer);
|
||||
}
|
||||
|
||||
_data->tFileBuffer = frameBuffer;
|
||||
}
|
||||
else
|
||||
{
|
||||
_data->sFile->setFrameBuffer (frameBuffer);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
const FrameBuffer &
|
||||
InputFile::frameBuffer () const
|
||||
{
|
||||
if (isTiled (_data->version))
|
||||
{
|
||||
Lock lock (*_data);
|
||||
return _data->tFileBuffer;
|
||||
}
|
||||
else
|
||||
{
|
||||
return _data->sFile->frameBuffer();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
bool
|
||||
InputFile::isComplete () const
|
||||
{
|
||||
if (isTiled (_data->version))
|
||||
return _data->tFile->isComplete();
|
||||
else
|
||||
return _data->sFile->isComplete();
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
InputFile::readPixels (int scanLine1, int scanLine2)
|
||||
{
|
||||
if (isTiled (_data->version))
|
||||
{
|
||||
Lock lock (*_data);
|
||||
bufferedReadPixels (_data, scanLine1, scanLine2);
|
||||
}
|
||||
else
|
||||
{
|
||||
_data->sFile->readPixels (scanLine1, scanLine2);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
InputFile::readPixels (int scanLine)
|
||||
{
|
||||
readPixels (scanLine, scanLine);
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
InputFile::rawPixelData (int firstScanLine,
|
||||
const char *&pixelData,
|
||||
int &pixelDataSize)
|
||||
{
|
||||
try
|
||||
{
|
||||
if (isTiled (_data->version))
|
||||
{
|
||||
throw Iex::ArgExc ("Tried to read a raw scanline "
|
||||
"from a tiled image.");
|
||||
}
|
||||
|
||||
_data->sFile->rawPixelData (firstScanLine, pixelData, pixelDataSize);
|
||||
}
|
||||
catch (Iex::BaseExc &e)
|
||||
{
|
||||
REPLACE_EXC (e, "Error reading pixel data from image "
|
||||
"file \"" << fileName() << "\". " << e);
|
||||
throw;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
InputFile::rawTileData (int &dx, int &dy,
|
||||
int &lx, int &ly,
|
||||
const char *&pixelData,
|
||||
int &pixelDataSize)
|
||||
{
|
||||
try
|
||||
{
|
||||
if (!isTiled (_data->version))
|
||||
{
|
||||
throw Iex::ArgExc ("Tried to read a raw tile "
|
||||
"from a scanline-based image.");
|
||||
}
|
||||
|
||||
_data->tFile->rawTileData (dx, dy, lx, ly, pixelData, pixelDataSize);
|
||||
}
|
||||
catch (Iex::BaseExc &e)
|
||||
{
|
||||
REPLACE_EXC (e, "Error reading tile data from image "
|
||||
"file \"" << fileName() << "\". " << e);
|
||||
throw;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
TiledInputFile*
|
||||
InputFile::tFile()
|
||||
{
|
||||
if (!isTiled (_data->version))
|
||||
{
|
||||
throw Iex::ArgExc ("Cannot get a TiledInputFile pointer "
|
||||
"from an InputFile that is not tiled.");
|
||||
}
|
||||
|
||||
return _data->tFile;
|
||||
}
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
@@ -1,209 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
#ifndef INCLUDED_IMF_INPUT_FILE_H
|
||||
#define INCLUDED_IMF_INPUT_FILE_H
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class InputFile -- a scanline-based interface that can be used
|
||||
// to read both scanline-based and tiled OpenEXR image files.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfHeader.h>
|
||||
#include <ImfFrameBuffer.h>
|
||||
#include <ImfTiledOutputFile.h>
|
||||
#include <string>
|
||||
#include <fstream>
|
||||
#include <ImfThreading.h>
|
||||
|
||||
namespace Imf {
|
||||
|
||||
class TiledInputFile;
|
||||
class ScanLineInputFile;
|
||||
|
||||
|
||||
class InputFile
|
||||
{
|
||||
public:
|
||||
|
||||
//-----------------------------------------------------------
|
||||
// A constructor that opens the file with the specified name.
|
||||
// Destroying the InputFile object will close the file.
|
||||
//
|
||||
// numThreads determines the number of threads that will be
|
||||
// used to read the file (see ImfThreading.h).
|
||||
//-----------------------------------------------------------
|
||||
|
||||
InputFile (const char fileName[], int numThreads = globalThreadCount());
|
||||
|
||||
|
||||
//-------------------------------------------------------------
|
||||
// A constructor that attaches the new InputFile object to a
|
||||
// file that has already been opened. Destroying the InputFile
|
||||
// object will not close the file.
|
||||
//
|
||||
// numThreads determines the number of threads that will be
|
||||
// used to read the file (see ImfThreading.h).
|
||||
//-------------------------------------------------------------
|
||||
|
||||
InputFile (IStream &is, int numThreads = globalThreadCount());
|
||||
|
||||
|
||||
//-----------
|
||||
// Destructor
|
||||
//-----------
|
||||
|
||||
virtual ~InputFile ();
|
||||
|
||||
|
||||
//------------------------
|
||||
// Access to the file name
|
||||
//------------------------
|
||||
|
||||
const char * fileName () const;
|
||||
|
||||
|
||||
//--------------------------
|
||||
// Access to the file header
|
||||
//--------------------------
|
||||
|
||||
const Header & header () const;
|
||||
|
||||
|
||||
//----------------------------------
|
||||
// Access to the file format version
|
||||
//----------------------------------
|
||||
|
||||
int version () const;
|
||||
|
||||
|
||||
//-----------------------------------------------------------
|
||||
// Set the current frame buffer -- copies the FrameBuffer
|
||||
// object into the InputFile object.
|
||||
//
|
||||
// The current frame buffer is the destination for the pixel
|
||||
// data read from the file. The current frame buffer must be
|
||||
// set at least once before readPixels() is called.
|
||||
// The current frame buffer can be changed after each call
|
||||
// to readPixels().
|
||||
//-----------------------------------------------------------
|
||||
|
||||
void setFrameBuffer (const FrameBuffer &frameBuffer);
|
||||
|
||||
|
||||
//-----------------------------------
|
||||
// Access to the current frame buffer
|
||||
//-----------------------------------
|
||||
|
||||
const FrameBuffer & frameBuffer () const;
|
||||
|
||||
|
||||
//---------------------------------------------------------------
|
||||
// Check if the file is complete:
|
||||
//
|
||||
// isComplete() returns true if all pixels in the data window are
|
||||
// present in the input file, or false if any pixels are missing.
|
||||
// (Another program may still be busy writing the file, or file
|
||||
// writing may have been aborted prematurely.)
|
||||
//---------------------------------------------------------------
|
||||
|
||||
bool isComplete () const;
|
||||
|
||||
|
||||
//---------------------------------------------------------------
|
||||
// Read pixel data:
|
||||
//
|
||||
// readPixels(s1,s2) reads all scan lines with y coordinates
|
||||
// in the interval [min (s1, s2), max (s1, s2)] from the file,
|
||||
// and stores them in the current frame buffer.
|
||||
//
|
||||
// Both s1 and s2 must be within the interval
|
||||
// [header().dataWindow().min.y, header().dataWindow().max.y]
|
||||
//
|
||||
// The scan lines can be read from the file in random order, and
|
||||
// individual scan lines may be skipped or read multiple times.
|
||||
// For maximum efficiency, the scan lines should be read in the
|
||||
// order in which they were written to the file.
|
||||
//
|
||||
// readPixels(s) calls readPixels(s,s).
|
||||
//
|
||||
//---------------------------------------------------------------
|
||||
|
||||
void readPixels (int scanLine1, int scanLine2);
|
||||
void readPixels (int scanLine);
|
||||
|
||||
|
||||
//----------------------------------------------
|
||||
// Read a block of raw pixel data from the file,
|
||||
// without uncompressing it (this function is
|
||||
// used to implement OutputFile::copyPixels()).
|
||||
//----------------------------------------------
|
||||
|
||||
void rawPixelData (int firstScanLine,
|
||||
const char *&pixelData,
|
||||
int &pixelDataSize);
|
||||
|
||||
//--------------------------------------------------
|
||||
// Read a tile of raw pixel data from the file,
|
||||
// without uncompressing it (this function is
|
||||
// used to implement TiledOutputFile::copyPixels()).
|
||||
//--------------------------------------------------
|
||||
|
||||
void rawTileData (int &dx, int &dy,
|
||||
int &lx, int &ly,
|
||||
const char *&pixelData,
|
||||
int &pixelDataSize);
|
||||
|
||||
struct Data;
|
||||
|
||||
private:
|
||||
|
||||
InputFile (const InputFile &); // not implemented
|
||||
InputFile & operator = (const InputFile &); // not implemented
|
||||
|
||||
void initialize ();
|
||||
TiledInputFile * tFile ();
|
||||
|
||||
friend void TiledOutputFile::copyPixels (InputFile &);
|
||||
|
||||
Data * _data;
|
||||
};
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
|
||||
#endif
|
||||
@@ -1,52 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2006, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef INCLUDED_IMF_INT64_H
|
||||
#define INCLUDED_IMF_INT64_H
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
//
|
||||
// Int64 -- unsigned 64-bit integers, imported from namespace Imath
|
||||
//
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
#include "ImathInt64.h"
|
||||
|
||||
namespace Imf {
|
||||
|
||||
using Imath::Int64;
|
||||
|
||||
} // namespace Imf
|
||||
|
||||
#endif
|
||||
@@ -1,57 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class IntAttribute
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfIntAttribute.h>
|
||||
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
template <>
|
||||
const char *
|
||||
IntAttribute::staticTypeName ()
|
||||
{
|
||||
return "int";
|
||||
}
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
@@ -1,63 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
#ifndef INCLUDED_IMF_INT_ATTRIBUTE_H
|
||||
#define INCLUDED_IMF_INT_ATTRIBUTE_H
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class IntAttribute
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfAttribute.h>
|
||||
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
typedef TypedAttribute<int> IntAttribute;
|
||||
template <> const char *IntAttribute::staticTypeName ();
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
|
||||
// Metrowerks compiler wants the .cpp file inlined, too
|
||||
#ifdef __MWERKS__
|
||||
#include <ImfIntAttribute.cpp>
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -1,216 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class KeyCode
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfKeyCode.h>
|
||||
#include "Iex.h"
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
KeyCode::KeyCode (int filmMfcCode,
|
||||
int filmType,
|
||||
int prefix,
|
||||
int count,
|
||||
int perfOffset,
|
||||
int perfsPerFrame,
|
||||
int perfsPerCount)
|
||||
{
|
||||
setFilmMfcCode (filmMfcCode);
|
||||
setFilmType (filmType);
|
||||
setPrefix (prefix);
|
||||
setCount (count);
|
||||
setPerfOffset (perfOffset);
|
||||
setPerfsPerFrame (perfsPerFrame);
|
||||
setPerfsPerCount (perfsPerCount);
|
||||
}
|
||||
|
||||
|
||||
KeyCode::KeyCode (const KeyCode &other)
|
||||
{
|
||||
_filmMfcCode = other._filmMfcCode;
|
||||
_filmType = other._filmType;
|
||||
_prefix = other._prefix;
|
||||
_count = other._count;
|
||||
_perfOffset = other._perfOffset;
|
||||
_perfsPerFrame = other._perfsPerFrame;
|
||||
_perfsPerCount = other._perfsPerCount;
|
||||
}
|
||||
|
||||
|
||||
KeyCode &
|
||||
KeyCode::operator = (const KeyCode &other)
|
||||
{
|
||||
_filmMfcCode = other._filmMfcCode;
|
||||
_filmType = other._filmType;
|
||||
_prefix = other._prefix;
|
||||
_count = other._count;
|
||||
_perfOffset = other._perfOffset;
|
||||
_perfsPerFrame = other._perfsPerFrame;
|
||||
_perfsPerCount = other._perfsPerCount;
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
KeyCode::filmMfcCode () const
|
||||
{
|
||||
return _filmMfcCode;
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
KeyCode::setFilmMfcCode (int filmMfcCode)
|
||||
{
|
||||
if (filmMfcCode < 0 || filmMfcCode > 99)
|
||||
throw Iex::ArgExc ("Invalid key code film manufacturer code "
|
||||
"(must be between 0 and 99).");
|
||||
|
||||
_filmMfcCode = filmMfcCode;
|
||||
}
|
||||
|
||||
int
|
||||
KeyCode::filmType () const
|
||||
{
|
||||
return _filmType;
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
KeyCode::setFilmType (int filmType)
|
||||
{
|
||||
if (filmType < 0 || filmType > 99)
|
||||
throw Iex::ArgExc ("Invalid key code film type "
|
||||
"(must be between 0 and 99).");
|
||||
|
||||
_filmType = filmType;
|
||||
}
|
||||
|
||||
int
|
||||
KeyCode::prefix () const
|
||||
{
|
||||
return _prefix;
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
KeyCode::setPrefix (int prefix)
|
||||
{
|
||||
if (prefix < 0 || prefix > 999999)
|
||||
throw Iex::ArgExc ("Invalid key code prefix "
|
||||
"(must be between 0 and 999999).");
|
||||
|
||||
_prefix = prefix;
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
KeyCode::count () const
|
||||
{
|
||||
return _count;
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
KeyCode::setCount (int count)
|
||||
{
|
||||
if (count < 0 || count > 9999)
|
||||
throw Iex::ArgExc ("Invalid key code count "
|
||||
"(must be between 0 and 9999).");
|
||||
|
||||
_count = count;
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
KeyCode::perfOffset () const
|
||||
{
|
||||
return _perfOffset;
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
KeyCode::setPerfOffset (int perfOffset)
|
||||
{
|
||||
if (perfOffset < 0 || perfOffset > 119)
|
||||
throw Iex::ArgExc ("Invalid key code perforation offset "
|
||||
"(must be between 0 and 119).");
|
||||
|
||||
_perfOffset = perfOffset;
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
KeyCode::perfsPerFrame () const
|
||||
{
|
||||
return _perfsPerFrame;
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
KeyCode::setPerfsPerFrame (int perfsPerFrame)
|
||||
{
|
||||
if (perfsPerFrame < 1 || perfsPerFrame > 15)
|
||||
throw Iex::ArgExc ("Invalid key code number of perforations per frame "
|
||||
"(must be between 1 and 15).");
|
||||
|
||||
_perfsPerFrame = perfsPerFrame;
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
KeyCode::perfsPerCount () const
|
||||
{
|
||||
return _perfsPerCount;
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
KeyCode::setPerfsPerCount (int perfsPerCount)
|
||||
{
|
||||
if (perfsPerCount < 20 || perfsPerCount > 120)
|
||||
throw Iex::ArgExc ("Invalid key code number of perforations per count "
|
||||
"(must be between 20 and 120).");
|
||||
|
||||
_perfsPerCount = perfsPerCount;
|
||||
}
|
||||
|
||||
} // namespace Imf
|
||||
@@ -1,161 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
#ifndef INCLUDED_IMF_KEY_CODE_H
|
||||
#define INCLUDED_IMF_KEY_CODE_H
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class KeyCode
|
||||
//
|
||||
// A KeyCode object uniquely identifies a motion picture film frame.
|
||||
// The following fields specifiy film manufacturer, film type, film
|
||||
// roll and the frame's position within the roll:
|
||||
//
|
||||
// filmMfcCode film manufacturer code
|
||||
// range: 0 - 99
|
||||
//
|
||||
// filmType film type code
|
||||
// range: 0 - 99
|
||||
//
|
||||
// prefix prefix to identify film roll
|
||||
// range: 0 - 999999
|
||||
//
|
||||
// count count, increments once every perfsPerCount
|
||||
// perforations (see below)
|
||||
// range: 0 - 9999
|
||||
//
|
||||
// perfOffset offset of frame, in perforations from
|
||||
// zero-frame reference mark
|
||||
// range: 0 - 119
|
||||
//
|
||||
// perfsPerFrame number of perforations per frame
|
||||
// range: 1 - 15
|
||||
//
|
||||
// typical values:
|
||||
//
|
||||
// 1 for 16mm film
|
||||
// 3, 4, or 8 for 35mm film
|
||||
// 5, 8 or 15 for 65mm film
|
||||
//
|
||||
// perfsPerCount number of perforations per count
|
||||
// range: 20 - 120
|
||||
//
|
||||
// typical values:
|
||||
//
|
||||
// 20 for 16mm film
|
||||
// 64 for 35mm film
|
||||
// 80 or 120 for 65mm film
|
||||
//
|
||||
// For more information about the interpretation of those fields see
|
||||
// the following standards and recommended practice publications:
|
||||
//
|
||||
// SMPTE 254 Motion-Picture Film (35-mm) - Manufacturer-Printed
|
||||
// Latent Image Identification Information
|
||||
//
|
||||
// SMPTE 268M File Format for Digital Moving-Picture Exchange (DPX)
|
||||
// (section 6.1)
|
||||
//
|
||||
// SMPTE 270 Motion-Picture Film (65-mm) - Manufacturer- Printed
|
||||
// Latent Image Identification Information
|
||||
//
|
||||
// SMPTE 271 Motion-Picture Film (16-mm) - Manufacturer- Printed
|
||||
// Latent Image Identification Information
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
class KeyCode
|
||||
{
|
||||
public:
|
||||
|
||||
//-------------------------------------
|
||||
// Constructors and assignment operator
|
||||
//-------------------------------------
|
||||
|
||||
KeyCode (int filmMfcCode = 0,
|
||||
int filmType = 0,
|
||||
int prefix = 0,
|
||||
int count = 0,
|
||||
int perfOffset = 0,
|
||||
int perfsPerFrame = 4,
|
||||
int perfsPerCount = 64);
|
||||
|
||||
KeyCode (const KeyCode &other);
|
||||
KeyCode & operator = (const KeyCode &other);
|
||||
|
||||
|
||||
//----------------------------
|
||||
// Access to individual fields
|
||||
//----------------------------
|
||||
|
||||
int filmMfcCode () const;
|
||||
void setFilmMfcCode (int filmMfcCode);
|
||||
|
||||
int filmType () const;
|
||||
void setFilmType (int filmType);
|
||||
|
||||
int prefix () const;
|
||||
void setPrefix (int prefix);
|
||||
|
||||
int count () const;
|
||||
void setCount (int count);
|
||||
|
||||
int perfOffset () const;
|
||||
void setPerfOffset (int perfOffset);
|
||||
|
||||
int perfsPerFrame () const;
|
||||
void setPerfsPerFrame (int perfsPerFrame);
|
||||
|
||||
int perfsPerCount () const;
|
||||
void setPerfsPerCount (int perfsPerCount);
|
||||
|
||||
private:
|
||||
|
||||
int _filmMfcCode;
|
||||
int _filmType;
|
||||
int _prefix;
|
||||
int _count;
|
||||
int _perfOffset;
|
||||
int _perfsPerFrame;
|
||||
int _perfsPerCount;
|
||||
};
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
|
||||
#endif
|
||||
@@ -1,98 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class KeyCodeAttribute
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfKeyCodeAttribute.h>
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
template <>
|
||||
const char *
|
||||
KeyCodeAttribute::staticTypeName ()
|
||||
{
|
||||
return "keycode";
|
||||
}
|
||||
|
||||
|
||||
template <>
|
||||
void
|
||||
KeyCodeAttribute::writeValueTo (OStream &os, int version) const
|
||||
{
|
||||
Xdr::write <StreamIO> (os, _value.filmMfcCode());
|
||||
Xdr::write <StreamIO> (os, _value.filmType());
|
||||
Xdr::write <StreamIO> (os, _value.prefix());
|
||||
Xdr::write <StreamIO> (os, _value.count());
|
||||
Xdr::write <StreamIO> (os, _value.perfOffset());
|
||||
Xdr::write <StreamIO> (os, _value.perfsPerFrame());
|
||||
Xdr::write <StreamIO> (os, _value.perfsPerCount());
|
||||
}
|
||||
|
||||
|
||||
template <>
|
||||
void
|
||||
KeyCodeAttribute::readValueFrom (IStream &is, int size, int version)
|
||||
{
|
||||
int tmp;
|
||||
|
||||
Xdr::read <StreamIO> (is, tmp);
|
||||
_value.setFilmMfcCode (tmp);
|
||||
|
||||
Xdr::read <StreamIO> (is, tmp);
|
||||
_value.setFilmType (tmp);
|
||||
|
||||
Xdr::read <StreamIO> (is, tmp);
|
||||
_value.setPrefix (tmp);
|
||||
|
||||
Xdr::read <StreamIO> (is, tmp);
|
||||
_value.setCount (tmp);
|
||||
|
||||
Xdr::read <StreamIO> (is, tmp);
|
||||
_value.setPerfOffset (tmp);
|
||||
|
||||
Xdr::read <StreamIO> (is, tmp);
|
||||
_value.setPerfsPerFrame (tmp);
|
||||
|
||||
Xdr::read <StreamIO> (is, tmp);
|
||||
_value.setPerfsPerCount (tmp);
|
||||
}
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
@@ -1,72 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
#ifndef INCLUDED_IMF_KEY_CODE_ATTRIBUTE_H
|
||||
#define INCLUDED_IMF_KEY_CODE_ATTRIBUTE_H
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class KeyCodeAttribute
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfAttribute.h>
|
||||
#include <ImfKeyCode.h>
|
||||
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
typedef TypedAttribute<KeyCode> KeyCodeAttribute;
|
||||
|
||||
template <>
|
||||
const char *KeyCodeAttribute::staticTypeName ();
|
||||
|
||||
template <>
|
||||
void KeyCodeAttribute::writeValueTo (OStream &, int) const;
|
||||
|
||||
template <>
|
||||
void KeyCodeAttribute::readValueFrom (IStream &, int, int);
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
|
||||
// Metrowerks compiler wants the .cpp file inlined, too
|
||||
#ifdef __MWERKS__
|
||||
#include <ImfKeyCodeAttribute.cpp>
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -1,64 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
#ifndef INCLUDED_IMF_LINE_ORDER_H
|
||||
#define INCLUDED_IMF_LINE_ORDER_H
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// enum LineOrder
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
enum LineOrder
|
||||
{
|
||||
INCREASING_Y = 0, // first scan line has lowest y coordinate
|
||||
|
||||
DECREASING_Y = 1, // first scan line has highest y coordinate
|
||||
|
||||
RANDOM_Y = 2, // only for tiled files; tiles are written
|
||||
// in random order
|
||||
|
||||
NUM_LINEORDERS // number of different line orders
|
||||
};
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
|
||||
#endif
|
||||
@@ -1,77 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class LineOrderAttribute
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfLineOrderAttribute.h>
|
||||
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
template <>
|
||||
const char *
|
||||
LineOrderAttribute::staticTypeName ()
|
||||
{
|
||||
return "lineOrder";
|
||||
}
|
||||
|
||||
|
||||
template <>
|
||||
void
|
||||
LineOrderAttribute::writeValueTo (OStream &os, int version) const
|
||||
{
|
||||
unsigned char tmp = _value;
|
||||
Xdr::write <StreamIO> (os, tmp);
|
||||
}
|
||||
|
||||
|
||||
template <>
|
||||
void
|
||||
LineOrderAttribute::readValueFrom (IStream &is, int size, int version)
|
||||
{
|
||||
unsigned char tmp;
|
||||
Xdr::read <StreamIO> (is, tmp);
|
||||
_value = LineOrder (tmp);
|
||||
}
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
@@ -1,66 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
#ifndef INCLUDED_IMF_LINE_ORDER_ATTRIBUTE_H
|
||||
#define INCLUDED_IMF_LINE_ORDER_ATTRIBUTE_H
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class LineOrderAttribute
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfAttribute.h>
|
||||
#include <ImfLineOrder.h>
|
||||
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
typedef TypedAttribute<LineOrder> LineOrderAttribute;
|
||||
template <> const char *LineOrderAttribute::staticTypeName ();
|
||||
template <> void LineOrderAttribute::writeValueTo (OStream &, int) const;
|
||||
template <> void LineOrderAttribute::readValueFrom (IStream &, int, int);
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
|
||||
// Metrowerks compiler wants the .cpp file inlined, too
|
||||
#ifdef __MWERKS__
|
||||
#include <ImfLineOrderAttribute.cpp>
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -1,176 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// Lookup tables for efficient application
|
||||
// of half --> half functions to pixel data,
|
||||
// and some commonly applied functions.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfLut.h>
|
||||
#include <math.h>
|
||||
#include <assert.h>
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
void
|
||||
HalfLut::apply (half *data, int nData, int stride) const
|
||||
{
|
||||
while (nData)
|
||||
{
|
||||
*data = _lut (*data);
|
||||
data += stride;
|
||||
nData -= 1;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
HalfLut::apply (const Slice &data, const Imath::Box2i &dataWindow) const
|
||||
{
|
||||
assert (data.type == HALF);
|
||||
assert (dataWindow.min.x % data.xSampling == 0);
|
||||
assert (dataWindow.min.y % data.ySampling == 0);
|
||||
assert ((dataWindow.max.x - dataWindow.min.x + 1) % data.xSampling == 0);
|
||||
assert ((dataWindow.max.y - dataWindow.min.y + 1) % data.ySampling == 0);
|
||||
|
||||
char *base = data.base + data.yStride *
|
||||
(dataWindow.min.y / data.ySampling);
|
||||
|
||||
for (int y = dataWindow.min.y;
|
||||
y <= dataWindow.max.y;
|
||||
y += data.ySampling)
|
||||
{
|
||||
char *pixel = base + data.xStride *
|
||||
(dataWindow.min.x / data.xSampling);
|
||||
|
||||
for (int x = dataWindow.min.x;
|
||||
x <= dataWindow.max.x;
|
||||
x += data.xSampling)
|
||||
{
|
||||
*(half *)pixel = _lut (*(half *)pixel);
|
||||
pixel += data.xStride;
|
||||
}
|
||||
|
||||
base += data.yStride;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
RgbaLut::apply (Rgba *data, int nData, int stride) const
|
||||
{
|
||||
while (nData)
|
||||
{
|
||||
if (_chn & WRITE_R)
|
||||
data->r = _lut (data->r);
|
||||
|
||||
if (_chn & WRITE_G)
|
||||
data->g = _lut (data->g);
|
||||
|
||||
if (_chn & WRITE_B)
|
||||
data->b = _lut (data->b);
|
||||
|
||||
if (_chn & WRITE_A)
|
||||
data->a = _lut (data->a);
|
||||
|
||||
data += stride;
|
||||
nData -= 1;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
RgbaLut::apply (Rgba *base,
|
||||
int xStride, int yStride,
|
||||
const Imath::Box2i &dataWindow) const
|
||||
{
|
||||
base += dataWindow.min.y * yStride;
|
||||
|
||||
for (int y = dataWindow.min.y; y <= dataWindow.max.y; ++y)
|
||||
{
|
||||
Rgba *pixel = base + dataWindow.min.x * xStride;
|
||||
|
||||
for (int x = dataWindow.min.x; x <= dataWindow.max.x; ++x)
|
||||
{
|
||||
if (_chn & WRITE_R)
|
||||
pixel->r = _lut (pixel->r);
|
||||
|
||||
if (_chn & WRITE_G)
|
||||
pixel->g = _lut (pixel->g);
|
||||
|
||||
if (_chn & WRITE_B)
|
||||
pixel->b = _lut (pixel->b);
|
||||
|
||||
if (_chn & WRITE_A)
|
||||
pixel->a = _lut (pixel->a);
|
||||
|
||||
pixel += xStride;
|
||||
}
|
||||
|
||||
base += yStride;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
half
|
||||
round12log (half x)
|
||||
{
|
||||
const float middleval = pow (2.0, -2.5);
|
||||
int int12log;
|
||||
|
||||
if (x <= 0)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
int12log = int (2000.5 + 200.0 * log (x / middleval) / log (2.0));
|
||||
|
||||
if (int12log > 4095)
|
||||
int12log = 4095;
|
||||
|
||||
if (int12log < 1)
|
||||
int12log = 1;
|
||||
}
|
||||
|
||||
return middleval * pow (2.0, (int12log - 2000.0) / 200.0);
|
||||
}
|
||||
|
||||
} // namespace Imf
|
||||
@@ -1,185 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
#ifndef INCLUDED_IMF_LUT_H
|
||||
#define INCLUDED_IMF_LUT_H
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// Lookup tables for efficient application
|
||||
// of half --> half functions to pixel data,
|
||||
// and some commonly applied functions.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfRgbaFile.h>
|
||||
#include <ImfFrameBuffer.h>
|
||||
#include "ImathBox.h"
|
||||
#include "halfFunction.h"
|
||||
|
||||
namespace Imf {
|
||||
|
||||
//
|
||||
// Lookup table for individual half channels.
|
||||
//
|
||||
|
||||
class HalfLut
|
||||
{
|
||||
public:
|
||||
|
||||
//------------
|
||||
// Constructor
|
||||
//------------
|
||||
|
||||
template <class Function>
|
||||
HalfLut (Function f);
|
||||
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
// Apply the table to data[0], data[stride] ... data[(nData-1) * stride]
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
void apply (half *data,
|
||||
int nData,
|
||||
int stride = 1) const;
|
||||
|
||||
|
||||
//---------------------------------------------------------------
|
||||
// Apply the table to a frame buffer slice (see ImfFrameBuffer.h)
|
||||
//---------------------------------------------------------------
|
||||
|
||||
void apply (const Slice &data,
|
||||
const Imath::Box2i &dataWindow) const;
|
||||
|
||||
private:
|
||||
|
||||
halfFunction <half> _lut;
|
||||
};
|
||||
|
||||
|
||||
//
|
||||
// Lookup table for combined RGBA data.
|
||||
//
|
||||
|
||||
class RgbaLut
|
||||
{
|
||||
public:
|
||||
|
||||
//------------
|
||||
// Constructor
|
||||
//------------
|
||||
|
||||
template <class Function>
|
||||
RgbaLut (Function f, RgbaChannels chn = WRITE_RGB);
|
||||
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
// Apply the table to data[0], data[stride] ... data[(nData-1) * stride]
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
void apply (Rgba *data,
|
||||
int nData,
|
||||
int stride = 1) const;
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------
|
||||
// Apply the table to a frame buffer (see RgbaOutpuFile.setFrameBuffer())
|
||||
//-----------------------------------------------------------------------
|
||||
|
||||
void apply (Rgba *base,
|
||||
int xStride,
|
||||
int yStride,
|
||||
const Imath::Box2i &dataWindow) const;
|
||||
|
||||
private:
|
||||
|
||||
halfFunction <half> _lut;
|
||||
RgbaChannels _chn;
|
||||
};
|
||||
|
||||
|
||||
//
|
||||
// 12bit log rounding reduces data to 20 stops with 200 steps per stop.
|
||||
// That makes 4000 numbers. An extra 96 just come along for the ride.
|
||||
// Zero explicitly remains zero. The first non-zero half will map to 1
|
||||
// in the 0-4095 12log space. A nice power of two number is placed at
|
||||
// the center [2000] and that number is near 0.18.
|
||||
//
|
||||
|
||||
half round12log (half x);
|
||||
|
||||
|
||||
//
|
||||
// Round to n-bit precision (n should be between 0 and 10).
|
||||
// After rounding, the significand's 10-n least significant
|
||||
// bits will be zero.
|
||||
//
|
||||
|
||||
struct roundNBit
|
||||
{
|
||||
roundNBit (int n): n(n) {}
|
||||
half operator () (half x) {return x.round(n);}
|
||||
int n;
|
||||
};
|
||||
|
||||
|
||||
//
|
||||
// Template definitions
|
||||
//
|
||||
|
||||
|
||||
template <class Function>
|
||||
HalfLut::HalfLut (Function f):
|
||||
_lut(f, -HALF_MAX, HALF_MAX, half (0),
|
||||
half::posInf(), half::negInf(), half::qNan())
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
|
||||
template <class Function>
|
||||
RgbaLut::RgbaLut (Function f, RgbaChannels chn):
|
||||
_lut(f, -HALF_MAX, HALF_MAX, half (0),
|
||||
half::posInf(), half::negInf(), half::qNan()),
|
||||
_chn(chn)
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
|
||||
#endif
|
||||
@@ -1,154 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class M33fAttribute
|
||||
// class M44fAttribute
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfMatrixAttribute.h>
|
||||
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
template <>
|
||||
const char *
|
||||
M33fAttribute::staticTypeName ()
|
||||
{
|
||||
return "m33f";
|
||||
}
|
||||
|
||||
|
||||
template <>
|
||||
void
|
||||
M33fAttribute::writeValueTo (OStream &os, int version) const
|
||||
{
|
||||
Xdr::write <StreamIO> (os, _value[0][0]);
|
||||
Xdr::write <StreamIO> (os, _value[0][1]);
|
||||
Xdr::write <StreamIO> (os, _value[0][2]);
|
||||
|
||||
Xdr::write <StreamIO> (os, _value[1][0]);
|
||||
Xdr::write <StreamIO> (os, _value[1][1]);
|
||||
Xdr::write <StreamIO> (os, _value[1][2]);
|
||||
|
||||
Xdr::write <StreamIO> (os, _value[2][0]);
|
||||
Xdr::write <StreamIO> (os, _value[2][1]);
|
||||
Xdr::write <StreamIO> (os, _value[2][2]);
|
||||
}
|
||||
|
||||
|
||||
template <>
|
||||
void
|
||||
M33fAttribute::readValueFrom (IStream &is, int size, int version)
|
||||
{
|
||||
Xdr::read <StreamIO> (is, _value[0][0]);
|
||||
Xdr::read <StreamIO> (is, _value[0][1]);
|
||||
Xdr::read <StreamIO> (is, _value[0][2]);
|
||||
|
||||
Xdr::read <StreamIO> (is, _value[1][0]);
|
||||
Xdr::read <StreamIO> (is, _value[1][1]);
|
||||
Xdr::read <StreamIO> (is, _value[1][2]);
|
||||
|
||||
Xdr::read <StreamIO> (is, _value[2][0]);
|
||||
Xdr::read <StreamIO> (is, _value[2][1]);
|
||||
Xdr::read <StreamIO> (is, _value[2][2]);
|
||||
}
|
||||
|
||||
|
||||
template <>
|
||||
const char *
|
||||
M44fAttribute::staticTypeName ()
|
||||
{
|
||||
return "m44f";
|
||||
}
|
||||
|
||||
|
||||
template <>
|
||||
void
|
||||
M44fAttribute::writeValueTo (OStream &os, int version) const
|
||||
{
|
||||
Xdr::write <StreamIO> (os, _value[0][0]);
|
||||
Xdr::write <StreamIO> (os, _value[0][1]);
|
||||
Xdr::write <StreamIO> (os, _value[0][2]);
|
||||
Xdr::write <StreamIO> (os, _value[0][3]);
|
||||
|
||||
Xdr::write <StreamIO> (os, _value[1][0]);
|
||||
Xdr::write <StreamIO> (os, _value[1][1]);
|
||||
Xdr::write <StreamIO> (os, _value[1][2]);
|
||||
Xdr::write <StreamIO> (os, _value[1][3]);
|
||||
|
||||
Xdr::write <StreamIO> (os, _value[2][0]);
|
||||
Xdr::write <StreamIO> (os, _value[2][1]);
|
||||
Xdr::write <StreamIO> (os, _value[2][2]);
|
||||
Xdr::write <StreamIO> (os, _value[2][3]);
|
||||
|
||||
Xdr::write <StreamIO> (os, _value[3][0]);
|
||||
Xdr::write <StreamIO> (os, _value[3][1]);
|
||||
Xdr::write <StreamIO> (os, _value[3][2]);
|
||||
Xdr::write <StreamIO> (os, _value[3][3]);
|
||||
}
|
||||
|
||||
|
||||
template <>
|
||||
void
|
||||
M44fAttribute::readValueFrom (IStream &is, int size, int version)
|
||||
{
|
||||
Xdr::read <StreamIO> (is, _value[0][0]);
|
||||
Xdr::read <StreamIO> (is, _value[0][1]);
|
||||
Xdr::read <StreamIO> (is, _value[0][2]);
|
||||
Xdr::read <StreamIO> (is, _value[0][3]);
|
||||
|
||||
Xdr::read <StreamIO> (is, _value[1][0]);
|
||||
Xdr::read <StreamIO> (is, _value[1][1]);
|
||||
Xdr::read <StreamIO> (is, _value[1][2]);
|
||||
Xdr::read <StreamIO> (is, _value[1][3]);
|
||||
|
||||
Xdr::read <StreamIO> (is, _value[2][0]);
|
||||
Xdr::read <StreamIO> (is, _value[2][1]);
|
||||
Xdr::read <StreamIO> (is, _value[2][2]);
|
||||
Xdr::read <StreamIO> (is, _value[2][3]);
|
||||
|
||||
Xdr::read <StreamIO> (is, _value[3][0]);
|
||||
Xdr::read <StreamIO> (is, _value[3][1]);
|
||||
Xdr::read <StreamIO> (is, _value[3][2]);
|
||||
Xdr::read <StreamIO> (is, _value[3][3]);
|
||||
}
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
@@ -1,73 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
#ifndef INCLUDED_IMF_MATRIX_ATTRIBUTE_H
|
||||
#define INCLUDED_IMF_MATRIX_ATTRIBUTE_H
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class M33fAttribute
|
||||
// class M44fAttribute
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfAttribute.h>
|
||||
#include "ImathMatrix.h"
|
||||
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
typedef TypedAttribute<Imath::M33f> M33fAttribute;
|
||||
template <> const char *M33fAttribute::staticTypeName ();
|
||||
template <> void M33fAttribute::writeValueTo (OStream &, int) const;
|
||||
template <> void M33fAttribute::readValueFrom (IStream &, int, int);
|
||||
|
||||
|
||||
typedef TypedAttribute<Imath::M44f> M44fAttribute;
|
||||
template <> const char *M44fAttribute::staticTypeName ();
|
||||
template <> void M44fAttribute::writeValueTo (OStream &, int) const;
|
||||
template <> void M44fAttribute::readValueFrom (IStream &, int, int);
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
|
||||
// Metrowerks compiler wants the .cpp file inlined, too
|
||||
#ifdef __MWERKS__
|
||||
#include <ImfMatrixAttribute.cpp>
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -1,787 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// Miscellaneous helper functions for OpenEXR image file I/O
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfMisc.h>
|
||||
#include <ImfHeader.h>
|
||||
#include <ImfCompressor.h>
|
||||
#include <ImfChannelList.h>
|
||||
#include <ImfXdr.h>
|
||||
#include <ImathFun.h>
|
||||
#include <Iex.h>
|
||||
#include <ImfStdIO.h>
|
||||
#include <ImfConvert.h>
|
||||
|
||||
namespace Imf {
|
||||
|
||||
using Imath::Box2i;
|
||||
using Imath::divp;
|
||||
using Imath::modp;
|
||||
using std::vector;
|
||||
|
||||
int
|
||||
pixelTypeSize (PixelType type)
|
||||
{
|
||||
int size;
|
||||
|
||||
switch (type)
|
||||
{
|
||||
case UINT:
|
||||
|
||||
size = Xdr::size <unsigned int> ();
|
||||
break;
|
||||
|
||||
case HALF:
|
||||
|
||||
size = Xdr::size <half> ();
|
||||
break;
|
||||
|
||||
case FLOAT:
|
||||
|
||||
size = Xdr::size <float> ();
|
||||
break;
|
||||
|
||||
default:
|
||||
|
||||
throw Iex::ArgExc ("Unknown pixel type.");
|
||||
}
|
||||
|
||||
return size;
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
numSamples (int s, int a, int b)
|
||||
{
|
||||
int a1 = divp (a, s);
|
||||
int b1 = divp (b, s);
|
||||
return b1 - a1 + ((a1 * s < a)? 0: 1);
|
||||
}
|
||||
|
||||
|
||||
size_t
|
||||
bytesPerLineTable (const Header &header,
|
||||
vector<size_t> &bytesPerLine)
|
||||
{
|
||||
const Box2i &dataWindow = header.dataWindow();
|
||||
const ChannelList &channels = header.channels();
|
||||
|
||||
bytesPerLine.resize (dataWindow.max.y - dataWindow.min.y + 1);
|
||||
|
||||
for (ChannelList::ConstIterator c = channels.begin();
|
||||
c != channels.end();
|
||||
++c)
|
||||
{
|
||||
int nBytes = pixelTypeSize (c.channel().type) *
|
||||
(dataWindow.max.x - dataWindow.min.x + 1) /
|
||||
c.channel().xSampling;
|
||||
|
||||
for (int y = dataWindow.min.y, i = 0; y <= dataWindow.max.y; ++y, ++i)
|
||||
if (modp (y, c.channel().ySampling) == 0)
|
||||
bytesPerLine[i] += nBytes;
|
||||
}
|
||||
|
||||
size_t maxBytesPerLine = 0;
|
||||
|
||||
for (int y = dataWindow.min.y, i = 0; y <= dataWindow.max.y; ++y, ++i)
|
||||
if (maxBytesPerLine < bytesPerLine[i])
|
||||
maxBytesPerLine = bytesPerLine[i];
|
||||
|
||||
return maxBytesPerLine;
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
offsetInLineBufferTable (const vector<size_t> &bytesPerLine,
|
||||
int linesInLineBuffer,
|
||||
vector<size_t> &offsetInLineBuffer)
|
||||
{
|
||||
offsetInLineBuffer.resize (bytesPerLine.size());
|
||||
|
||||
size_t offset = 0;
|
||||
|
||||
for (int i = 0; i < bytesPerLine.size(); ++i)
|
||||
{
|
||||
if (i % linesInLineBuffer == 0)
|
||||
offset = 0;
|
||||
|
||||
offsetInLineBuffer[i] = offset;
|
||||
offset += bytesPerLine[i];
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
lineBufferMinY (int y, int minY, int linesInLineBuffer)
|
||||
{
|
||||
return ((y - minY) / linesInLineBuffer) * linesInLineBuffer + minY;
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
lineBufferMaxY (int y, int minY, int linesInLineBuffer)
|
||||
{
|
||||
return lineBufferMinY (y, minY, linesInLineBuffer) + linesInLineBuffer - 1;
|
||||
}
|
||||
|
||||
|
||||
Compressor::Format
|
||||
defaultFormat (Compressor * compressor)
|
||||
{
|
||||
return compressor? compressor->format(): Compressor::XDR;
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
numLinesInBuffer (Compressor * compressor)
|
||||
{
|
||||
return compressor? compressor->numScanLines(): 1;
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
copyIntoFrameBuffer (const char *& readPtr,
|
||||
char * writePtr,
|
||||
char * endPtr,
|
||||
size_t xStride,
|
||||
bool fill,
|
||||
double fillValue,
|
||||
Compressor::Format format,
|
||||
PixelType typeInFrameBuffer,
|
||||
PixelType typeInFile)
|
||||
{
|
||||
//
|
||||
// Copy a horizontal row of pixels from an input
|
||||
// file's line or tile buffer to a frame buffer.
|
||||
//
|
||||
|
||||
if (fill)
|
||||
{
|
||||
//
|
||||
// The file contains no data for this channel.
|
||||
// Store a default value in the frame buffer.
|
||||
//
|
||||
|
||||
switch (typeInFrameBuffer)
|
||||
{
|
||||
case UINT:
|
||||
|
||||
{
|
||||
unsigned int fillVal = (unsigned int) (fillValue);
|
||||
|
||||
while (writePtr <= endPtr)
|
||||
{
|
||||
*(unsigned int *) writePtr = fillVal;
|
||||
writePtr += xStride;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case HALF:
|
||||
|
||||
{
|
||||
half fillVal = half (fillValue);
|
||||
|
||||
while (writePtr <= endPtr)
|
||||
{
|
||||
*(half *) writePtr = fillVal;
|
||||
writePtr += xStride;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case FLOAT:
|
||||
|
||||
{
|
||||
float fillVal = float (fillValue);
|
||||
|
||||
while (writePtr <= endPtr)
|
||||
{
|
||||
*(float *) writePtr = fillVal;
|
||||
writePtr += xStride;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
|
||||
throw Iex::ArgExc ("Unknown pixel data type.");
|
||||
}
|
||||
}
|
||||
else if (format == Compressor::XDR)
|
||||
{
|
||||
//
|
||||
// The the line or tile buffer is in XDR format.
|
||||
//
|
||||
// Convert the pixels from the file's machine-
|
||||
// independent representation, and store the
|
||||
// results in the frame buffer.
|
||||
//
|
||||
|
||||
switch (typeInFrameBuffer)
|
||||
{
|
||||
case UINT:
|
||||
|
||||
switch (typeInFile)
|
||||
{
|
||||
case UINT:
|
||||
|
||||
while (writePtr <= endPtr)
|
||||
{
|
||||
Xdr::read <CharPtrIO> (readPtr, *(unsigned int *) writePtr);
|
||||
writePtr += xStride;
|
||||
}
|
||||
break;
|
||||
|
||||
case HALF:
|
||||
|
||||
while (writePtr <= endPtr)
|
||||
{
|
||||
half h;
|
||||
Xdr::read <CharPtrIO> (readPtr, h);
|
||||
*(unsigned int *) writePtr = halfToUint (h);
|
||||
writePtr += xStride;
|
||||
}
|
||||
break;
|
||||
|
||||
case FLOAT:
|
||||
|
||||
while (writePtr <= endPtr)
|
||||
{
|
||||
float f;
|
||||
Xdr::read <CharPtrIO> (readPtr, f);
|
||||
*(unsigned int *)writePtr = floatToUint (f);
|
||||
writePtr += xStride;
|
||||
}
|
||||
break;
|
||||
}
|
||||
break;
|
||||
|
||||
case HALF:
|
||||
|
||||
switch (typeInFile)
|
||||
{
|
||||
case UINT:
|
||||
|
||||
while (writePtr <= endPtr)
|
||||
{
|
||||
unsigned int ui;
|
||||
Xdr::read <CharPtrIO> (readPtr, ui);
|
||||
*(half *) writePtr = uintToHalf (ui);
|
||||
writePtr += xStride;
|
||||
}
|
||||
break;
|
||||
|
||||
case HALF:
|
||||
|
||||
while (writePtr <= endPtr)
|
||||
{
|
||||
Xdr::read <CharPtrIO> (readPtr, *(half *) writePtr);
|
||||
writePtr += xStride;
|
||||
}
|
||||
break;
|
||||
|
||||
case FLOAT:
|
||||
|
||||
while (writePtr <= endPtr)
|
||||
{
|
||||
float f;
|
||||
Xdr::read <CharPtrIO> (readPtr, f);
|
||||
*(half *) writePtr = floatToHalf (f);
|
||||
writePtr += xStride;
|
||||
}
|
||||
break;
|
||||
}
|
||||
break;
|
||||
|
||||
case FLOAT:
|
||||
|
||||
switch (typeInFile)
|
||||
{
|
||||
case UINT:
|
||||
|
||||
while (writePtr <= endPtr)
|
||||
{
|
||||
unsigned int ui;
|
||||
Xdr::read <CharPtrIO> (readPtr, ui);
|
||||
*(float *) writePtr = float (ui);
|
||||
writePtr += xStride;
|
||||
}
|
||||
break;
|
||||
|
||||
case HALF:
|
||||
|
||||
while (writePtr <= endPtr)
|
||||
{
|
||||
half h;
|
||||
Xdr::read <CharPtrIO> (readPtr, h);
|
||||
*(float *) writePtr = float (h);
|
||||
writePtr += xStride;
|
||||
}
|
||||
break;
|
||||
|
||||
case FLOAT:
|
||||
|
||||
while (writePtr <= endPtr)
|
||||
{
|
||||
Xdr::read <CharPtrIO> (readPtr, *(float *) writePtr);
|
||||
writePtr += xStride;
|
||||
}
|
||||
break;
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
|
||||
throw Iex::ArgExc ("Unknown pixel data type.");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
//
|
||||
// The the line or tile buffer is in NATIVE format.
|
||||
// Copy the results into the frame buffer.
|
||||
//
|
||||
|
||||
switch (typeInFrameBuffer)
|
||||
{
|
||||
case UINT:
|
||||
|
||||
switch (typeInFile)
|
||||
{
|
||||
case UINT:
|
||||
|
||||
while (writePtr <= endPtr)
|
||||
{
|
||||
for (size_t i = 0; i < sizeof (unsigned int); ++i)
|
||||
writePtr[i] = readPtr[i];
|
||||
|
||||
readPtr += sizeof (unsigned int);
|
||||
writePtr += xStride;
|
||||
}
|
||||
break;
|
||||
|
||||
case HALF:
|
||||
|
||||
while (writePtr <= endPtr)
|
||||
{
|
||||
half h = *(half *) readPtr;
|
||||
*(unsigned int *) writePtr = halfToUint (h);
|
||||
readPtr += sizeof (half);
|
||||
writePtr += xStride;
|
||||
}
|
||||
break;
|
||||
|
||||
case FLOAT:
|
||||
|
||||
while (writePtr <= endPtr)
|
||||
{
|
||||
float f;
|
||||
|
||||
for (size_t i = 0; i < sizeof (float); ++i)
|
||||
((char *)&f)[i] = readPtr[i];
|
||||
|
||||
*(unsigned int *)writePtr = floatToUint (f);
|
||||
readPtr += sizeof (float);
|
||||
writePtr += xStride;
|
||||
}
|
||||
break;
|
||||
}
|
||||
break;
|
||||
|
||||
case HALF:
|
||||
|
||||
switch (typeInFile)
|
||||
{
|
||||
case UINT:
|
||||
|
||||
while (writePtr <= endPtr)
|
||||
{
|
||||
unsigned int ui;
|
||||
|
||||
for (size_t i = 0; i < sizeof (unsigned int); ++i)
|
||||
((char *)&ui)[i] = readPtr[i];
|
||||
|
||||
*(half *) writePtr = uintToHalf (ui);
|
||||
readPtr += sizeof (unsigned int);
|
||||
writePtr += xStride;
|
||||
}
|
||||
break;
|
||||
|
||||
case HALF:
|
||||
|
||||
while (writePtr <= endPtr)
|
||||
{
|
||||
*(half *) writePtr = *(half *)readPtr;
|
||||
readPtr += sizeof (half);
|
||||
writePtr += xStride;
|
||||
}
|
||||
break;
|
||||
|
||||
case FLOAT:
|
||||
|
||||
while (writePtr <= endPtr)
|
||||
{
|
||||
float f;
|
||||
|
||||
for (size_t i = 0; i < sizeof (float); ++i)
|
||||
((char *)&f)[i] = readPtr[i];
|
||||
|
||||
*(half *) writePtr = floatToHalf (f);
|
||||
readPtr += sizeof (float);
|
||||
writePtr += xStride;
|
||||
}
|
||||
break;
|
||||
}
|
||||
break;
|
||||
|
||||
case FLOAT:
|
||||
|
||||
switch (typeInFile)
|
||||
{
|
||||
case UINT:
|
||||
|
||||
while (writePtr <= endPtr)
|
||||
{
|
||||
unsigned int ui;
|
||||
|
||||
for (size_t i = 0; i < sizeof (unsigned int); ++i)
|
||||
((char *)&ui)[i] = readPtr[i];
|
||||
|
||||
*(float *) writePtr = float (ui);
|
||||
readPtr += sizeof (unsigned int);
|
||||
writePtr += xStride;
|
||||
}
|
||||
break;
|
||||
|
||||
case HALF:
|
||||
|
||||
while (writePtr <= endPtr)
|
||||
{
|
||||
half h = *(half *) readPtr;
|
||||
*(float *) writePtr = float (h);
|
||||
readPtr += sizeof (half);
|
||||
writePtr += xStride;
|
||||
}
|
||||
break;
|
||||
|
||||
case FLOAT:
|
||||
|
||||
while (writePtr <= endPtr)
|
||||
{
|
||||
for (size_t i = 0; i < sizeof (float); ++i)
|
||||
writePtr[i] = readPtr[i];
|
||||
|
||||
readPtr += sizeof (float);
|
||||
writePtr += xStride;
|
||||
}
|
||||
break;
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
|
||||
throw Iex::ArgExc ("Unknown pixel data type.");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
skipChannel (const char *& readPtr,
|
||||
PixelType typeInFile,
|
||||
size_t xSize)
|
||||
{
|
||||
switch (typeInFile)
|
||||
{
|
||||
case UINT:
|
||||
|
||||
Xdr::skip <CharPtrIO> (readPtr, Xdr::size <unsigned int> () * xSize);
|
||||
break;
|
||||
|
||||
case HALF:
|
||||
|
||||
Xdr::skip <CharPtrIO> (readPtr, Xdr::size <half> () * xSize);
|
||||
break;
|
||||
|
||||
case FLOAT:
|
||||
|
||||
Xdr::skip <CharPtrIO> (readPtr, Xdr::size <float> () * xSize);
|
||||
break;
|
||||
|
||||
default:
|
||||
|
||||
throw Iex::ArgExc ("Unknown pixel data type.");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
convertInPlace (char *& writePtr,
|
||||
const char *& readPtr,
|
||||
PixelType type,
|
||||
size_t numPixels)
|
||||
{
|
||||
switch (type)
|
||||
{
|
||||
case UINT:
|
||||
|
||||
for (int j = 0; j < numPixels; ++j)
|
||||
{
|
||||
Xdr::write <CharPtrIO> (writePtr, *(const unsigned int *) readPtr);
|
||||
readPtr += sizeof(unsigned int);
|
||||
}
|
||||
break;
|
||||
|
||||
case HALF:
|
||||
|
||||
for (int j = 0; j < numPixels; ++j)
|
||||
{
|
||||
Xdr::write <CharPtrIO> (writePtr, *(const half *) readPtr);
|
||||
readPtr += sizeof(half);
|
||||
}
|
||||
break;
|
||||
|
||||
case FLOAT:
|
||||
|
||||
for (int j = 0; j < numPixels; ++j)
|
||||
{
|
||||
Xdr::write <CharPtrIO> (writePtr, *(const float *) readPtr);
|
||||
readPtr += sizeof(float);
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
|
||||
throw Iex::ArgExc ("Unknown pixel data type.");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
copyFromFrameBuffer (char *& writePtr,
|
||||
const char *& readPtr,
|
||||
const char * endPtr,
|
||||
size_t xStride,
|
||||
Compressor::Format format,
|
||||
PixelType type)
|
||||
{
|
||||
//
|
||||
// Copy a horizontal row of pixels from a frame
|
||||
// buffer to an output file's line or tile buffer.
|
||||
//
|
||||
|
||||
if (format == Compressor::XDR)
|
||||
{
|
||||
//
|
||||
// The the line or tile buffer is in XDR format.
|
||||
//
|
||||
|
||||
switch (type)
|
||||
{
|
||||
case UINT:
|
||||
|
||||
while (readPtr <= endPtr)
|
||||
{
|
||||
Xdr::write <CharPtrIO> (writePtr,
|
||||
*(const unsigned int *) readPtr);
|
||||
readPtr += xStride;
|
||||
}
|
||||
break;
|
||||
|
||||
case HALF:
|
||||
|
||||
while (readPtr <= endPtr)
|
||||
{
|
||||
Xdr::write <CharPtrIO> (writePtr, *(const half *) readPtr);
|
||||
readPtr += xStride;
|
||||
}
|
||||
break;
|
||||
|
||||
case FLOAT:
|
||||
|
||||
while (readPtr <= endPtr)
|
||||
{
|
||||
Xdr::write <CharPtrIO> (writePtr, *(const float *) readPtr);
|
||||
readPtr += xStride;
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
|
||||
throw Iex::ArgExc ("Unknown pixel data type.");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
//
|
||||
// The the line or tile buffer is in NATIVE format.
|
||||
//
|
||||
|
||||
switch (type)
|
||||
{
|
||||
case UINT:
|
||||
|
||||
while (readPtr <= endPtr)
|
||||
{
|
||||
for (size_t i = 0; i < sizeof (unsigned int); ++i)
|
||||
*writePtr++ = readPtr[i];
|
||||
|
||||
readPtr += xStride;
|
||||
}
|
||||
break;
|
||||
|
||||
case HALF:
|
||||
|
||||
while (readPtr <= endPtr)
|
||||
{
|
||||
*(half *) writePtr = *(const half *) readPtr;
|
||||
writePtr += sizeof (half);
|
||||
readPtr += xStride;
|
||||
}
|
||||
break;
|
||||
|
||||
case FLOAT:
|
||||
|
||||
while (readPtr <= endPtr)
|
||||
{
|
||||
for (size_t i = 0; i < sizeof (float); ++i)
|
||||
*writePtr++ = readPtr[i];
|
||||
|
||||
readPtr += xStride;
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
|
||||
throw Iex::ArgExc ("Unknown pixel data type.");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
fillChannelWithZeroes (char *& writePtr,
|
||||
Compressor::Format format,
|
||||
PixelType type,
|
||||
size_t xSize)
|
||||
{
|
||||
if (format == Compressor::XDR)
|
||||
{
|
||||
//
|
||||
// Fill with data in XDR format.
|
||||
//
|
||||
|
||||
switch (type)
|
||||
{
|
||||
case UINT:
|
||||
|
||||
for (int j = 0; j < xSize; ++j)
|
||||
Xdr::write <CharPtrIO> (writePtr, (unsigned int) 0);
|
||||
|
||||
break;
|
||||
|
||||
case HALF:
|
||||
|
||||
for (int j = 0; j < xSize; ++j)
|
||||
Xdr::write <CharPtrIO> (writePtr, (half) 0);
|
||||
|
||||
break;
|
||||
|
||||
case FLOAT:
|
||||
|
||||
for (int j = 0; j < xSize; ++j)
|
||||
Xdr::write <CharPtrIO> (writePtr, (float) 0);
|
||||
|
||||
break;
|
||||
|
||||
default:
|
||||
|
||||
throw Iex::ArgExc ("Unknown pixel data type.");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
//
|
||||
// Fill with data in NATIVE format.
|
||||
//
|
||||
|
||||
switch (type)
|
||||
{
|
||||
case UINT:
|
||||
|
||||
for (int j = 0; j < xSize; ++j)
|
||||
{
|
||||
static const unsigned int ui = 0;
|
||||
|
||||
for (size_t i = 0; i < sizeof (ui); ++i)
|
||||
*writePtr++ = ((char *) &ui)[i];
|
||||
}
|
||||
break;
|
||||
|
||||
case HALF:
|
||||
|
||||
for (int j = 0; j < xSize; ++j)
|
||||
{
|
||||
*(half *) writePtr = half (0);
|
||||
writePtr += sizeof (half);
|
||||
}
|
||||
break;
|
||||
|
||||
case FLOAT:
|
||||
|
||||
for (int j = 0; j < xSize; ++j)
|
||||
{
|
||||
static const float f = 0;
|
||||
|
||||
for (size_t i = 0; i < sizeof (f); ++i)
|
||||
*writePtr++ = ((char *) &f)[i];
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
|
||||
throw Iex::ArgExc ("Unknown pixel data type.");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace Imf
|
||||
@@ -1,255 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
#ifndef INCLUDED_IMF_MISC_H
|
||||
#define INCLUDED_IMF_MISC_H
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// Miscellaneous helper functions for OpenEXR image file I/O
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfPixelType.h>
|
||||
#include <vector>
|
||||
#include <ImfCompressor.h>
|
||||
|
||||
namespace Imf {
|
||||
|
||||
class Header;
|
||||
|
||||
//
|
||||
// Return the size of a single value of the indicated type,
|
||||
// in the machine's native format.
|
||||
//
|
||||
|
||||
int pixelTypeSize (PixelType type);
|
||||
|
||||
|
||||
//
|
||||
// Return the number of samples a channel with subsampling rate
|
||||
// s has in the interval [a, b]. For example, a channel with
|
||||
// subsampling rate 2 (and samples at 0, 2, 4, 6, 8, etc.) has
|
||||
// 2 samples in the interval [1, 5] and three samples in the
|
||||
// interval [2, 6].
|
||||
//
|
||||
|
||||
int numSamples (int s, int a, int b);
|
||||
|
||||
|
||||
//
|
||||
// Build a table that lists, for each scanline in a file's
|
||||
// data window, how many bytes are required to store all
|
||||
// pixels in all channels in that scanline (assuming that
|
||||
// the pixel data are tightly packed).
|
||||
//
|
||||
|
||||
size_t bytesPerLineTable (const Header &header,
|
||||
std::vector<size_t> &bytesPerLine);
|
||||
|
||||
//
|
||||
// For scanline-based files, pixels are read or written in
|
||||
// in multi-scanline blocks. Internally, class OutputFile
|
||||
// and class ScanLineInputFile store a block of scan lines
|
||||
// in a "line buffer". Function offsetInLineBufferTable()
|
||||
// builds a table that lists, for each scan line in a file's
|
||||
// data window, the location of the pixel data for the scanline
|
||||
// relative to the beginning of the line buffer.
|
||||
//
|
||||
|
||||
void offsetInLineBufferTable (const std::vector<size_t> &bytesPerLine,
|
||||
int linesInLineBuffer,
|
||||
std::vector<size_t> &offsetInLineBuffer);
|
||||
|
||||
//
|
||||
// For a scanline-based file, compute the range of scanlines
|
||||
// that occupy the same line buffer as a given scanline, y.
|
||||
// (minY is the minimum y coordinate of the file's data window.)
|
||||
//
|
||||
|
||||
int lineBufferMinY (int y, int minY, int linesInLineBuffer);
|
||||
int lineBufferMaxY (int y, int minY, int linesInLineBuffer);
|
||||
|
||||
|
||||
//
|
||||
// Return a compressor's data format (Compressor::NATIVE or Compressor::XDR).
|
||||
// If compressor is 0, return Compressor::XDR.
|
||||
//
|
||||
|
||||
Compressor::Format defaultFormat (Compressor *compressor);
|
||||
|
||||
|
||||
//
|
||||
// Return the number of scan lines a compressor wants to compress
|
||||
// or uncompress at once. If compressor is 0, return 1.
|
||||
//
|
||||
|
||||
int numLinesInBuffer (Compressor *compressor);
|
||||
|
||||
|
||||
//
|
||||
// Copy a single channel of a horizontal row of pixels from an
|
||||
// input file's internal line buffer or tile buffer into a
|
||||
// frame buffer slice. If necessary, perform on-the-fly data
|
||||
// type conversion.
|
||||
//
|
||||
// readPtr initially points to the beginning of the
|
||||
// data in the line or tile buffer. readPtr
|
||||
// is advanced as the pixel data are copied;
|
||||
// when copyIntoFrameBuffer() returns,
|
||||
// readPtr points just past the end of the
|
||||
// copied data.
|
||||
//
|
||||
// writePtr, endPtr point to the lefmost and rightmost pixels
|
||||
// in the frame buffer slice
|
||||
//
|
||||
// xStride the xStride for the frame buffer slice
|
||||
//
|
||||
// format indicates if the line or tile buffer is
|
||||
// in NATIVE or XDR format.
|
||||
//
|
||||
// typeInFrameBuffer the pixel data type of the frame buffer slice
|
||||
//
|
||||
// typeInFile the pixel data type in the input file's channel
|
||||
//
|
||||
|
||||
void copyIntoFrameBuffer (const char *&readPtr,
|
||||
char *writePtr,
|
||||
char *endPtr,
|
||||
size_t xStride,
|
||||
bool fill,
|
||||
double fillValue,
|
||||
Compressor::Format format,
|
||||
PixelType typeInFrameBuffer,
|
||||
PixelType typeInFile);
|
||||
|
||||
//
|
||||
// Given a pointer into a an input file's line buffer or tile buffer,
|
||||
// skip over the data for xSize pixels of type typeInFile.
|
||||
// readPtr initially points to the beginning of the data to be skipped;
|
||||
// when skipChannel() returns, readPtr points just past the end of the
|
||||
// skipped data.
|
||||
//
|
||||
|
||||
void skipChannel (const char *&readPtr,
|
||||
PixelType typeInFile,
|
||||
size_t xSize);
|
||||
|
||||
//
|
||||
// Convert an array of pixel data from the machine's native
|
||||
// representation to XDR format.
|
||||
//
|
||||
// toPtr, fromPtr initially point to the beginning of the input
|
||||
// and output pixel data arrays; when convertInPlace()
|
||||
// returns, toPtr and fromPtr point just past the
|
||||
// end of the input and output arrays.
|
||||
// If the native representation of the data has the
|
||||
// same size as the XDR data, then the conversion
|
||||
// can take in place, without an intermediate
|
||||
// temporary buffer (toPtr and fromPtr can point
|
||||
// to the same location).
|
||||
//
|
||||
// type the pixel data type
|
||||
//
|
||||
// numPixels number of pixels in the input and output arrays
|
||||
//
|
||||
|
||||
void convertInPlace (char *&toPtr,
|
||||
const char *&fromPtr,
|
||||
PixelType type,
|
||||
size_t numPixels);
|
||||
|
||||
//
|
||||
// Copy a single channel of a horizontal row of pixels from a
|
||||
// a frame buffer into an output file's internal line buffer or
|
||||
// tile buffer.
|
||||
//
|
||||
// writePtr initially points to the beginning of the
|
||||
// data in the line or tile buffer. writePtr
|
||||
// is advanced as the pixel data are copied;
|
||||
// when copyFromFrameBuffer() returns,
|
||||
// writePtr points just past the end of the
|
||||
// copied data.
|
||||
//
|
||||
// readPtr, endPtr point to the lefmost and rightmost pixels
|
||||
// in the frame buffer slice
|
||||
//
|
||||
// xStride the xStride for the frame buffer slice
|
||||
//
|
||||
// format indicates if the line or tile buffer is
|
||||
// in NATIVE or XDR format.
|
||||
//
|
||||
// type the pixel data type in the frame buffer
|
||||
// and in the output file's channel (function
|
||||
// copyFromFrameBuffer() doesn't do on-the-fly
|
||||
// data type conversion)
|
||||
//
|
||||
|
||||
void copyFromFrameBuffer (char *&writePtr,
|
||||
const char *&readPtr,
|
||||
const char *endPtr,
|
||||
size_t xStride,
|
||||
Compressor::Format format,
|
||||
PixelType type);
|
||||
|
||||
//
|
||||
// Fill part of an output file's line buffer or tile buffer with
|
||||
// zeroes. This routine is called when an output file contains
|
||||
// a channel for which the frame buffer contains no corresponding
|
||||
// slice.
|
||||
//
|
||||
// writePtr initially points to the beginning of the
|
||||
// data in the line or tile buffer. When
|
||||
// fillChannelWithZeroes() returns, writePtr
|
||||
// points just past the end of the zeroed
|
||||
// data.
|
||||
//
|
||||
// format indicates if the line or tile buffer is
|
||||
// in NATIVE or XDR format.
|
||||
//
|
||||
// type the pixel data type in the line or frame buffer.
|
||||
//
|
||||
// xSize number of pixels to be filled with zeroes.
|
||||
//
|
||||
|
||||
void fillChannelWithZeroes (char *&writePtr,
|
||||
Compressor::Format format,
|
||||
PixelType type,
|
||||
size_t xSize);
|
||||
|
||||
} // namespace Imf
|
||||
|
||||
#endif
|
||||
@@ -1,146 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
#ifndef INCLUDED_IMF_NAME_H
|
||||
#define INCLUDED_IMF_NAME_H
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class ImfName -- a zero-terminated string
|
||||
// with a fixed, small maximum length
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <string.h>
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
class Name
|
||||
{
|
||||
public:
|
||||
|
||||
//-------------
|
||||
// Constructors
|
||||
//-------------
|
||||
|
||||
Name ();
|
||||
Name (const char text[]);
|
||||
|
||||
|
||||
//--------------------
|
||||
// Assignment operator
|
||||
//--------------------
|
||||
|
||||
Name & operator = (const char text[]);
|
||||
|
||||
|
||||
//---------------------
|
||||
// Access to the string
|
||||
//---------------------
|
||||
|
||||
const char * text () const {return _text;}
|
||||
const char * operator * () const {return _text;}
|
||||
|
||||
//---------------
|
||||
// Maximum length
|
||||
//---------------
|
||||
|
||||
static const int SIZE = 32;
|
||||
static const int MAX_LENGTH = SIZE - 1;
|
||||
|
||||
private:
|
||||
|
||||
char _text[SIZE];
|
||||
};
|
||||
|
||||
|
||||
bool operator == (const Name &x, const Name &y);
|
||||
bool operator != (const Name &x, const Name &y);
|
||||
bool operator < (const Name &x, const Name &y);
|
||||
|
||||
|
||||
//-----------------
|
||||
// Inline functions
|
||||
//-----------------
|
||||
|
||||
inline Name &
|
||||
Name::operator = (const char text[])
|
||||
{
|
||||
strncpy (_text, text, MAX_LENGTH);
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
inline
|
||||
Name::Name ()
|
||||
{
|
||||
_text[0] = 0;
|
||||
}
|
||||
|
||||
|
||||
inline
|
||||
Name::Name (const char text[])
|
||||
{
|
||||
*this = text;
|
||||
_text [MAX_LENGTH] = 0;
|
||||
}
|
||||
|
||||
|
||||
inline bool
|
||||
operator == (const Name &x, const Name &y)
|
||||
{
|
||||
return strcmp (*x, *y) == 0;
|
||||
}
|
||||
|
||||
|
||||
inline bool
|
||||
operator != (const Name &x, const Name &y)
|
||||
{
|
||||
return !(x == y);
|
||||
}
|
||||
|
||||
|
||||
inline bool
|
||||
operator < (const Name &x, const Name &y)
|
||||
{
|
||||
return strcmp (*x, *y) < 0;
|
||||
}
|
||||
|
||||
|
||||
} // namespace IMF
|
||||
|
||||
#endif
|
||||
@@ -1,125 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class OpaqueAttribute
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfOpaqueAttribute.h>
|
||||
#include "Iex.h"
|
||||
#include <string.h>
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
OpaqueAttribute::OpaqueAttribute (const char typeName[]):
|
||||
_typeName (strlen (typeName) + 1),
|
||||
_dataSize (0)
|
||||
{
|
||||
strcpy (_typeName, typeName);
|
||||
}
|
||||
|
||||
|
||||
OpaqueAttribute::OpaqueAttribute (const OpaqueAttribute &other):
|
||||
_typeName (strlen (other._typeName) + 1),
|
||||
_dataSize (other._dataSize),
|
||||
_data (other._dataSize)
|
||||
{
|
||||
strcpy (_typeName, other._typeName);
|
||||
_data.resizeErase (other._dataSize);
|
||||
memcpy ((char *) _data, (const char *) other._data, other._dataSize);
|
||||
}
|
||||
|
||||
|
||||
OpaqueAttribute::~OpaqueAttribute ()
|
||||
{
|
||||
// empty
|
||||
}
|
||||
|
||||
|
||||
const char *
|
||||
OpaqueAttribute::typeName () const
|
||||
{
|
||||
return _typeName;
|
||||
}
|
||||
|
||||
|
||||
Attribute *
|
||||
OpaqueAttribute::copy () const
|
||||
{
|
||||
return new OpaqueAttribute (*this);
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
OpaqueAttribute::writeValueTo (OStream &os, int version) const
|
||||
{
|
||||
Xdr::write <StreamIO> (os, _data, _dataSize);
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
OpaqueAttribute::readValueFrom (IStream &is, int size, int version)
|
||||
{
|
||||
_data.resizeErase (size);
|
||||
_dataSize = size;
|
||||
Xdr::read <StreamIO> (is, _data, size);
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
OpaqueAttribute::copyValueFrom (const Attribute &other)
|
||||
{
|
||||
const OpaqueAttribute *oa = dynamic_cast <const OpaqueAttribute *> (&other);
|
||||
|
||||
if (oa == 0 || strcmp (_typeName, oa->_typeName))
|
||||
{
|
||||
THROW (Iex::TypeExc, "Cannot copy the value of an "
|
||||
"image file attribute of type "
|
||||
"\"" << other.typeName() << "\" "
|
||||
"to an attribute of type "
|
||||
"\"" << _typeName << "\".");
|
||||
}
|
||||
|
||||
_data.resizeErase (oa->_dataSize);
|
||||
_dataSize = oa->_dataSize;
|
||||
memcpy ((char *) _data, (const char *) oa->_data, oa->_dataSize);
|
||||
}
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
@@ -1,114 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
#ifndef INCLUDED_IMF_OPAQUE_ATTRIBUTE_H
|
||||
#define INCLUDED_IMF_OPAQUE_ATTRIBUTE_H
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class OpaqueAttribute
|
||||
//
|
||||
// When an image file is read, OpqaqueAttribute objects are used
|
||||
// to hold the values of attributes whose types are not recognized
|
||||
// by the reading program. OpaqueAttribute objects can be read
|
||||
// from an image file, copied, and written back to to another image
|
||||
// file, but their values are inaccessible.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfAttribute.h>
|
||||
#include <ImfArray.h>
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
class OpaqueAttribute: public Attribute
|
||||
{
|
||||
public:
|
||||
|
||||
//----------------------------
|
||||
// Constructors and destructor
|
||||
//----------------------------
|
||||
|
||||
OpaqueAttribute (const char typeName[]);
|
||||
OpaqueAttribute (const OpaqueAttribute &other);
|
||||
virtual ~OpaqueAttribute ();
|
||||
|
||||
|
||||
//-------------------------------
|
||||
// Get this attribute's type name
|
||||
//-------------------------------
|
||||
|
||||
virtual const char * typeName () const;
|
||||
|
||||
|
||||
//------------------------------
|
||||
// Make a copy of this attribute
|
||||
//------------------------------
|
||||
|
||||
virtual Attribute * copy () const;
|
||||
|
||||
|
||||
//----------------
|
||||
// I/O and copying
|
||||
//----------------
|
||||
|
||||
virtual void writeValueTo (OStream &os,
|
||||
int version) const;
|
||||
|
||||
virtual void readValueFrom (IStream &is,
|
||||
int size,
|
||||
int version);
|
||||
|
||||
virtual void copyValueFrom (const Attribute &other);
|
||||
|
||||
|
||||
private:
|
||||
|
||||
Array<char> _typeName;
|
||||
long _dataSize;
|
||||
Array<char> _data;
|
||||
};
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
|
||||
// Metrowerks compiler wants the .cpp file inlined, too
|
||||
#ifdef __MWERKS__
|
||||
#include <ImfOpaqueAttribute.cpp>
|
||||
#endif
|
||||
|
||||
#endif
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,241 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
#ifndef INCLUDED_IMF_OUTPUT_FILE_H
|
||||
#define INCLUDED_IMF_OUTPUT_FILE_H
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class OutputFile
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfHeader.h>
|
||||
#include <ImfFrameBuffer.h>
|
||||
#include <ImfThreading.h>
|
||||
|
||||
namespace Imf {
|
||||
|
||||
class InputFile;
|
||||
struct PreviewRgba;
|
||||
|
||||
|
||||
class OutputFile
|
||||
{
|
||||
public:
|
||||
|
||||
//-----------------------------------------------------------
|
||||
// Constructor -- opens the file and writes the file header.
|
||||
// The file header is also copied into the OutputFile object,
|
||||
// and can later be accessed via the header() method.
|
||||
// Destroying this OutputFile object automatically closes
|
||||
// the file.
|
||||
//
|
||||
// numThreads determines the number of threads that will be
|
||||
// used to write the file (see ImfThreading.h).
|
||||
//-----------------------------------------------------------
|
||||
|
||||
OutputFile (const char fileName[], const Header &header,
|
||||
int numThreads = globalThreadCount());
|
||||
|
||||
|
||||
//------------------------------------------------------------
|
||||
// Constructor -- attaches the new OutputFile object to a file
|
||||
// that has already been opened, and writes the file header.
|
||||
// The file header is also copied into the OutputFile object,
|
||||
// and can later be accessed via the header() method.
|
||||
// Destroying this OutputFile object does not automatically
|
||||
// close the file.
|
||||
//
|
||||
// numThreads determines the number of threads that will be
|
||||
// used to write the file (see ImfThreading.h).
|
||||
//------------------------------------------------------------
|
||||
|
||||
OutputFile (OStream &os, const Header &header,
|
||||
int numThreads = globalThreadCount());
|
||||
|
||||
|
||||
//-------------------------------------------------
|
||||
// Destructor
|
||||
//
|
||||
// Destroying the OutputFile object before writing
|
||||
// all scan lines within the data window results in
|
||||
// an incomplete file.
|
||||
//-------------------------------------------------
|
||||
|
||||
virtual ~OutputFile ();
|
||||
|
||||
|
||||
//------------------------
|
||||
// Access to the file name
|
||||
//------------------------
|
||||
|
||||
const char * fileName () const;
|
||||
|
||||
|
||||
//--------------------------
|
||||
// Access to the file header
|
||||
//--------------------------
|
||||
|
||||
const Header & header () const;
|
||||
|
||||
|
||||
//-------------------------------------------------------
|
||||
// Set the current frame buffer -- copies the FrameBuffer
|
||||
// object into the OutputFile object.
|
||||
//
|
||||
// The current frame buffer is the source of the pixel
|
||||
// data written to the file. The current frame buffer
|
||||
// must be set at least once before writePixels() is
|
||||
// called. The current frame buffer can be changed
|
||||
// after each call to writePixels.
|
||||
//-------------------------------------------------------
|
||||
|
||||
void setFrameBuffer (const FrameBuffer &frameBuffer);
|
||||
|
||||
|
||||
//-----------------------------------
|
||||
// Access to the current frame buffer
|
||||
//-----------------------------------
|
||||
|
||||
const FrameBuffer & frameBuffer () const;
|
||||
|
||||
|
||||
//-------------------------------------------------------------------
|
||||
// Write pixel data:
|
||||
//
|
||||
// writePixels(n) retrieves the next n scan lines worth of data from
|
||||
// the current frame buffer, starting with the scan line indicated by
|
||||
// currentScanLine(), and stores the data in the output file, and
|
||||
// progressing in the direction indicated by header.lineOrder().
|
||||
//
|
||||
// To produce a complete and correct file, exactly m scan lines must
|
||||
// be written, where m is equal to
|
||||
// header().dataWindow().max.y - header().dataWindow().min.y + 1.
|
||||
//-------------------------------------------------------------------
|
||||
|
||||
void writePixels (int numScanLines = 1);
|
||||
|
||||
|
||||
//------------------------------------------------------------------
|
||||
// Access to the current scan line:
|
||||
//
|
||||
// currentScanLine() returns the y coordinate of the first scan line
|
||||
// that will be read from the current frame buffer during the next
|
||||
// call to writePixels().
|
||||
//
|
||||
// If header.lineOrder() == INCREASING_Y:
|
||||
//
|
||||
// The current scan line before the first call to writePixels()
|
||||
// is header().dataWindow().min.y. After writing each scan line,
|
||||
// the current scan line is incremented by 1.
|
||||
//
|
||||
// If header.lineOrder() == DECREASING_Y:
|
||||
//
|
||||
// The current scan line before the first call to writePixels()
|
||||
// is header().dataWindow().max.y. After writing each scan line,
|
||||
// the current scan line is decremented by 1.
|
||||
//
|
||||
//------------------------------------------------------------------
|
||||
|
||||
int currentScanLine () const;
|
||||
|
||||
|
||||
//--------------------------------------------------------------
|
||||
// Shortcut to copy all pixels from an InputFile into this file,
|
||||
// without uncompressing and then recompressing the pixel data.
|
||||
// This file's header must be compatible with the InputFile's
|
||||
// header: The two header's "dataWindow", "compression",
|
||||
// "lineOrder" and "channels" attributes must be the same.
|
||||
//--------------------------------------------------------------
|
||||
|
||||
void copyPixels (InputFile &in);
|
||||
|
||||
|
||||
//--------------------------------------------------------------
|
||||
// Updating the preview image:
|
||||
//
|
||||
// updatePreviewImage() supplies a new set of pixels for the
|
||||
// preview image attribute in the file's header. If the header
|
||||
// does not contain a preview image, updatePreviewImage() throws
|
||||
// an Iex::LogicExc.
|
||||
//
|
||||
// Note: updatePreviewImage() is necessary because images are
|
||||
// often stored in a file incrementally, a few scan lines at a
|
||||
// time, while the image is being generated. Since the preview
|
||||
// image is an attribute in the file's header, it gets stored in
|
||||
// the file as soon as the file is opened, but we may not know
|
||||
// what the preview image should look like until we have written
|
||||
// the last scan line of the main image.
|
||||
//
|
||||
//--------------------------------------------------------------
|
||||
|
||||
void updatePreviewImage (const PreviewRgba newPixels[]);
|
||||
|
||||
|
||||
//---------------------------------------------------------
|
||||
// Break a scan line -- for testing and debugging only:
|
||||
//
|
||||
// breakScanLine(y,p,n,c) introduces an error into the
|
||||
// output file by writing n copies of character c, starting
|
||||
// p bytes from the beginning of the pixel data block that
|
||||
// contains scan line y.
|
||||
//
|
||||
// Warning: Calling this function usually results in a
|
||||
// broken image file. The file or parts of it may not
|
||||
// be readable, or the file may contain bad data.
|
||||
//
|
||||
//---------------------------------------------------------
|
||||
|
||||
void breakScanLine (int y, int offset, int length, char c);
|
||||
|
||||
|
||||
struct Data;
|
||||
|
||||
private:
|
||||
|
||||
OutputFile (const OutputFile &); // not implemented
|
||||
OutputFile & operator = (const OutputFile &); // not implemented
|
||||
|
||||
void initialize (const Header &header);
|
||||
|
||||
Data * _data;
|
||||
};
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
|
||||
#endif
|
||||
@@ -1,61 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2002, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
#ifndef INCLUDED_IMF_PIXEL_TYPE_H
|
||||
#define INCLUDED_IMF_PIXEL_TYPE_H
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// enum PixelType
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
enum PixelType
|
||||
{
|
||||
UINT = 0, // unsigned int (32 bit)
|
||||
HALF = 1, // half (16 bit floating point)
|
||||
FLOAT = 2, // float (32 bit floating point)
|
||||
|
||||
NUM_PIXELTYPES // number of different pixel types
|
||||
};
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
|
||||
#endif
|
||||
@@ -1,656 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class PizCompressor
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfPizCompressor.h>
|
||||
#include <ImfHeader.h>
|
||||
#include <ImfChannelList.h>
|
||||
#include <ImfHuf.h>
|
||||
#include <ImfWav.h>
|
||||
#include <ImfMisc.h>
|
||||
#include <ImathFun.h>
|
||||
#include <ImathBox.h>
|
||||
#include <Iex.h>
|
||||
#include <ImfIO.h>
|
||||
#include <ImfXdr.h>
|
||||
#include <ImfAutoArray.h>
|
||||
#include <string.h>
|
||||
#include <assert.h>
|
||||
|
||||
namespace Imf {
|
||||
|
||||
using Imath::divp;
|
||||
using Imath::modp;
|
||||
using Imath::Box2i;
|
||||
using Imath::V2i;
|
||||
using Iex::InputExc;
|
||||
|
||||
namespace {
|
||||
|
||||
//
|
||||
// Functions to compress the range of values in the pixel data
|
||||
//
|
||||
|
||||
const int USHORT_RANGE = (1 << 16);
|
||||
const int BITMAP_SIZE = (USHORT_RANGE >> 3);
|
||||
|
||||
void
|
||||
bitmapFromData (const unsigned short data[/*nData*/],
|
||||
int nData,
|
||||
unsigned char bitmap[BITMAP_SIZE],
|
||||
unsigned short &minNonZero,
|
||||
unsigned short &maxNonZero)
|
||||
{
|
||||
for (int i = 0; i < BITMAP_SIZE; ++i)
|
||||
bitmap[i] = 0;
|
||||
|
||||
for (int i = 0; i < nData; ++i)
|
||||
bitmap[data[i] >> 3] |= (1 << (data[i] & 7));
|
||||
|
||||
bitmap[0] &= ~1; // zero is not explicitly stored in
|
||||
// the bitmap; we assume that the
|
||||
// data always contain zeroes
|
||||
minNonZero = BITMAP_SIZE - 1;
|
||||
maxNonZero = 0;
|
||||
|
||||
for (int i = 0; i < BITMAP_SIZE; ++i)
|
||||
{
|
||||
if (bitmap[i])
|
||||
{
|
||||
if (minNonZero > i)
|
||||
minNonZero = i;
|
||||
if (maxNonZero < i)
|
||||
maxNonZero = i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
unsigned short
|
||||
forwardLutFromBitmap (const unsigned char bitmap[BITMAP_SIZE],
|
||||
unsigned short lut[USHORT_RANGE])
|
||||
{
|
||||
int k = 0;
|
||||
|
||||
for (int i = 0; i < USHORT_RANGE; ++i)
|
||||
{
|
||||
if ((i == 0) || (bitmap[i >> 3] & (1 << (i & 7))))
|
||||
lut[i] = k++;
|
||||
else
|
||||
lut[i] = 0;
|
||||
}
|
||||
|
||||
return k - 1; // maximum value stored in lut[],
|
||||
} // i.e. number of ones in bitmap minus 1
|
||||
|
||||
|
||||
unsigned short
|
||||
reverseLutFromBitmap (const unsigned char bitmap[BITMAP_SIZE],
|
||||
unsigned short lut[USHORT_RANGE])
|
||||
{
|
||||
int k = 0;
|
||||
|
||||
for (int i = 0; i < USHORT_RANGE; ++i)
|
||||
{
|
||||
if ((i == 0) || (bitmap[i >> 3] & (1 << (i & 7))))
|
||||
lut[k++] = i;
|
||||
}
|
||||
|
||||
int n = k - 1;
|
||||
|
||||
while (k < USHORT_RANGE)
|
||||
lut[k++] = 0;
|
||||
|
||||
return n; // maximum k where lut[k] is non-zero,
|
||||
} // i.e. number of ones in bitmap minus 1
|
||||
|
||||
|
||||
void
|
||||
applyLut (const unsigned short lut[USHORT_RANGE],
|
||||
unsigned short data[/*nData*/],
|
||||
int nData)
|
||||
{
|
||||
for (int i = 0; i < nData; ++i)
|
||||
data[i] = lut[data[i]];
|
||||
}
|
||||
|
||||
|
||||
} // namespace
|
||||
|
||||
|
||||
struct PizCompressor::ChannelData
|
||||
{
|
||||
unsigned short * start;
|
||||
unsigned short * end;
|
||||
int nx;
|
||||
int ny;
|
||||
int ys;
|
||||
int size;
|
||||
};
|
||||
|
||||
|
||||
PizCompressor::PizCompressor
|
||||
(const Header &hdr,
|
||||
int maxScanLineSize,
|
||||
int numScanLines)
|
||||
:
|
||||
Compressor (hdr),
|
||||
_maxScanLineSize (maxScanLineSize),
|
||||
_format (XDR),
|
||||
_numScanLines (numScanLines),
|
||||
_tmpBuffer (0),
|
||||
_outBuffer (0),
|
||||
_numChans (0),
|
||||
_channels (hdr.channels()),
|
||||
_channelData (0)
|
||||
{
|
||||
_tmpBuffer = new unsigned short [maxScanLineSize * numScanLines / 2];
|
||||
_outBuffer = new char [maxScanLineSize * numScanLines + 65536 + 8192];
|
||||
|
||||
const ChannelList &channels = header().channels();
|
||||
bool onlyHalfChannels = true;
|
||||
|
||||
for (ChannelList::ConstIterator c = channels.begin();
|
||||
c != channels.end();
|
||||
++c)
|
||||
{
|
||||
_numChans++;
|
||||
|
||||
assert (pixelTypeSize (c.channel().type) % pixelTypeSize (HALF) == 0);
|
||||
|
||||
if (c.channel().type != HALF)
|
||||
onlyHalfChannels = false;
|
||||
}
|
||||
|
||||
_channelData = new ChannelData[_numChans];
|
||||
|
||||
const Box2i &dataWindow = hdr.dataWindow();
|
||||
|
||||
_minX = dataWindow.min.x;
|
||||
_maxX = dataWindow.max.x;
|
||||
_maxY = dataWindow.max.y;
|
||||
|
||||
//
|
||||
// We can support uncompressed data in the machine's native format
|
||||
// if all image channels are of type HALF, and if the Xdr and the
|
||||
// native represenations of a half have the same size.
|
||||
//
|
||||
|
||||
if (onlyHalfChannels && (sizeof (half) == pixelTypeSize (HALF)))
|
||||
_format = NATIVE;
|
||||
}
|
||||
|
||||
|
||||
PizCompressor::~PizCompressor ()
|
||||
{
|
||||
delete [] _tmpBuffer;
|
||||
delete [] _outBuffer;
|
||||
delete [] _channelData;
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
PizCompressor::numScanLines () const
|
||||
{
|
||||
return _numScanLines;
|
||||
}
|
||||
|
||||
|
||||
Compressor::Format
|
||||
PizCompressor::format () const
|
||||
{
|
||||
return _format;
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
PizCompressor::compress (const char *inPtr,
|
||||
int inSize,
|
||||
int minY,
|
||||
const char *&outPtr)
|
||||
{
|
||||
return compress (inPtr,
|
||||
inSize,
|
||||
Box2i (V2i (_minX, minY),
|
||||
V2i (_maxX, minY + numScanLines() - 1)),
|
||||
outPtr);
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
PizCompressor::compressTile (const char *inPtr,
|
||||
int inSize,
|
||||
Imath::Box2i range,
|
||||
const char *&outPtr)
|
||||
{
|
||||
return compress (inPtr, inSize, range, outPtr);
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
PizCompressor::uncompress (const char *inPtr,
|
||||
int inSize,
|
||||
int minY,
|
||||
const char *&outPtr)
|
||||
{
|
||||
return uncompress (inPtr,
|
||||
inSize,
|
||||
Box2i (V2i (_minX, minY),
|
||||
V2i (_maxX, minY + numScanLines() - 1)),
|
||||
outPtr);
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
PizCompressor::uncompressTile (const char *inPtr,
|
||||
int inSize,
|
||||
Imath::Box2i range,
|
||||
const char *&outPtr)
|
||||
{
|
||||
return uncompress (inPtr, inSize, range, outPtr);
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
PizCompressor::compress (const char *inPtr,
|
||||
int inSize,
|
||||
Imath::Box2i range,
|
||||
const char *&outPtr)
|
||||
{
|
||||
//
|
||||
// This is the compress function which is used by both the tiled and
|
||||
// scanline compression routines.
|
||||
//
|
||||
|
||||
//
|
||||
// Special case - empty input buffer
|
||||
//
|
||||
|
||||
if (inSize == 0)
|
||||
{
|
||||
outPtr = _outBuffer;
|
||||
return 0;
|
||||
}
|
||||
|
||||
//
|
||||
// Rearrange the pixel data so that the wavelet
|
||||
// and Huffman encoders can process them easily.
|
||||
//
|
||||
// The wavelet and Huffman encoders both handle only
|
||||
// 16-bit data, so 32-bit data must be split into smaller
|
||||
// pieces. We treat each 32-bit channel (UINT, FLOAT) as
|
||||
// two interleaved 16-bit channels.
|
||||
//
|
||||
|
||||
int minX = range.min.x;
|
||||
int maxX = range.max.x;
|
||||
int minY = range.min.y;
|
||||
int maxY = range.max.y;
|
||||
|
||||
if (maxY > _maxY)
|
||||
maxY = _maxY;
|
||||
|
||||
if (maxX > _maxX)
|
||||
maxX = _maxX;
|
||||
|
||||
unsigned short *tmpBufferEnd = _tmpBuffer;
|
||||
int i = 0;
|
||||
|
||||
for (ChannelList::ConstIterator c = _channels.begin();
|
||||
c != _channels.end();
|
||||
++c, ++i)
|
||||
{
|
||||
ChannelData &cd = _channelData[i];
|
||||
|
||||
cd.start = tmpBufferEnd;
|
||||
cd.end = cd.start;
|
||||
|
||||
cd.nx = numSamples (c.channel().xSampling, minX, maxX);
|
||||
cd.ny = numSamples (c.channel().ySampling, minY, maxY);
|
||||
cd.ys = c.channel().ySampling;
|
||||
|
||||
cd.size = pixelTypeSize (c.channel().type) / pixelTypeSize (HALF);
|
||||
|
||||
tmpBufferEnd += cd.nx * cd.ny * cd.size;
|
||||
}
|
||||
|
||||
if (_format == XDR)
|
||||
{
|
||||
//
|
||||
// Machine-independent (Xdr) data format
|
||||
//
|
||||
|
||||
for (int y = minY; y <= maxY; ++y)
|
||||
{
|
||||
for (int i = 0; i < _numChans; ++i)
|
||||
{
|
||||
ChannelData &cd = _channelData[i];
|
||||
|
||||
if (modp (y, cd.ys) != 0)
|
||||
continue;
|
||||
|
||||
for (int x = cd.nx * cd.size; x > 0; --x)
|
||||
{
|
||||
Xdr::read <CharPtrIO> (inPtr, *cd.end);
|
||||
++cd.end;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
//
|
||||
// Native, machine-dependent data format
|
||||
//
|
||||
|
||||
for (int y = minY; y <= maxY; ++y)
|
||||
{
|
||||
for (int i = 0; i < _numChans; ++i)
|
||||
{
|
||||
ChannelData &cd = _channelData[i];
|
||||
|
||||
if (modp (y, cd.ys) != 0)
|
||||
continue;
|
||||
|
||||
int n = cd.nx * cd.size;
|
||||
memcpy (cd.end, inPtr, n * sizeof (unsigned short));
|
||||
inPtr += n * sizeof (unsigned short);
|
||||
cd.end += n;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#if defined (DEBUG)
|
||||
|
||||
for (int i = 1; i < _numChans; ++i)
|
||||
assert (_channelData[i-1].end == _channelData[i].start);
|
||||
|
||||
assert (_channelData[_numChans-1].end == tmpBufferEnd);
|
||||
|
||||
#endif
|
||||
|
||||
//
|
||||
// Compress the range of the pixel data
|
||||
//
|
||||
|
||||
AutoArray <unsigned char, BITMAP_SIZE> bitmap;
|
||||
unsigned short minNonZero;
|
||||
unsigned short maxNonZero;
|
||||
|
||||
bitmapFromData (_tmpBuffer,
|
||||
tmpBufferEnd - _tmpBuffer,
|
||||
bitmap,
|
||||
minNonZero, maxNonZero);
|
||||
|
||||
AutoArray <unsigned short, USHORT_RANGE> lut;
|
||||
unsigned short maxValue = forwardLutFromBitmap (bitmap, lut);
|
||||
applyLut (lut, _tmpBuffer, tmpBufferEnd - _tmpBuffer);
|
||||
|
||||
//
|
||||
// Store range compression info in _outBuffer
|
||||
//
|
||||
|
||||
char *buf = _outBuffer;
|
||||
|
||||
Xdr::write <CharPtrIO> (buf, minNonZero);
|
||||
Xdr::write <CharPtrIO> (buf, maxNonZero);
|
||||
|
||||
if (minNonZero <= maxNonZero)
|
||||
{
|
||||
Xdr::write <CharPtrIO> (buf, (char *) &bitmap[0] + minNonZero,
|
||||
maxNonZero - minNonZero + 1);
|
||||
}
|
||||
|
||||
//
|
||||
// Apply wavelet encoding
|
||||
//
|
||||
|
||||
for (int i = 0; i < _numChans; ++i)
|
||||
{
|
||||
ChannelData &cd = _channelData[i];
|
||||
|
||||
for (int j = 0; j < cd.size; ++j)
|
||||
{
|
||||
wav2Encode (cd.start + j,
|
||||
cd.nx, cd.size,
|
||||
cd.ny, cd.nx * cd.size,
|
||||
maxValue);
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// Apply Huffman encoding; append the result to _outBuffer
|
||||
//
|
||||
|
||||
char *lengthPtr = buf;
|
||||
Xdr::write <CharPtrIO> (buf, int(0));
|
||||
|
||||
int length = hufCompress (_tmpBuffer, tmpBufferEnd - _tmpBuffer, buf);
|
||||
Xdr::write <CharPtrIO> (lengthPtr, length);
|
||||
|
||||
outPtr = _outBuffer;
|
||||
return buf - _outBuffer + length;
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
PizCompressor::uncompress (const char *inPtr,
|
||||
int inSize,
|
||||
Imath::Box2i range,
|
||||
const char *&outPtr)
|
||||
{
|
||||
//
|
||||
// This is the cunompress function which is used by both the tiled and
|
||||
// scanline decompression routines.
|
||||
//
|
||||
|
||||
//
|
||||
// Special case - empty input buffer
|
||||
//
|
||||
|
||||
if (inSize == 0)
|
||||
{
|
||||
outPtr = _outBuffer;
|
||||
return 0;
|
||||
}
|
||||
|
||||
//
|
||||
// Determine the layout of the compressed pixel data
|
||||
//
|
||||
|
||||
int minX = range.min.x;
|
||||
int maxX = range.max.x;
|
||||
int minY = range.min.y;
|
||||
int maxY = range.max.y;
|
||||
|
||||
if (maxY > _maxY)
|
||||
maxY = _maxY;
|
||||
|
||||
if (maxX > _maxX)
|
||||
maxX = _maxX;
|
||||
|
||||
unsigned short *tmpBufferEnd = _tmpBuffer;
|
||||
int i = 0;
|
||||
|
||||
for (ChannelList::ConstIterator c = _channels.begin();
|
||||
c != _channels.end();
|
||||
++c, ++i)
|
||||
{
|
||||
ChannelData &cd = _channelData[i];
|
||||
|
||||
cd.start = tmpBufferEnd;
|
||||
cd.end = cd.start;
|
||||
|
||||
cd.nx = numSamples (c.channel().xSampling, minX, maxX);
|
||||
cd.ny = numSamples (c.channel().ySampling, minY, maxY);
|
||||
cd.ys = c.channel().ySampling;
|
||||
|
||||
cd.size = pixelTypeSize (c.channel().type) / pixelTypeSize (HALF);
|
||||
|
||||
tmpBufferEnd += cd.nx * cd.ny * cd.size;
|
||||
}
|
||||
|
||||
//
|
||||
// Read range compression data
|
||||
//
|
||||
|
||||
unsigned short minNonZero;
|
||||
unsigned short maxNonZero;
|
||||
|
||||
AutoArray <unsigned char, BITMAP_SIZE> bitmap;
|
||||
memset (bitmap, 0, sizeof (unsigned char) * BITMAP_SIZE);
|
||||
|
||||
Xdr::read <CharPtrIO> (inPtr, minNonZero);
|
||||
Xdr::read <CharPtrIO> (inPtr, maxNonZero);
|
||||
|
||||
if (maxNonZero >= BITMAP_SIZE)
|
||||
{
|
||||
throw InputExc ("Error in header for PIZ-compressed data "
|
||||
"(invalid bitmap size).");
|
||||
}
|
||||
|
||||
if (minNonZero <= maxNonZero)
|
||||
{
|
||||
Xdr::read <CharPtrIO> (inPtr, (char *) &bitmap[0] + minNonZero,
|
||||
maxNonZero - minNonZero + 1);
|
||||
}
|
||||
|
||||
AutoArray <unsigned short, USHORT_RANGE> lut;
|
||||
unsigned short maxValue = reverseLutFromBitmap (bitmap, lut);
|
||||
|
||||
//
|
||||
// Huffman decoding
|
||||
//
|
||||
|
||||
int length;
|
||||
Xdr::read <CharPtrIO> (inPtr, length);
|
||||
|
||||
hufUncompress (inPtr, length, _tmpBuffer, tmpBufferEnd - _tmpBuffer);
|
||||
|
||||
//
|
||||
// Wavelet decoding
|
||||
//
|
||||
|
||||
for (int i = 0; i < _numChans; ++i)
|
||||
{
|
||||
ChannelData &cd = _channelData[i];
|
||||
|
||||
for (int j = 0; j < cd.size; ++j)
|
||||
{
|
||||
wav2Decode (cd.start + j,
|
||||
cd.nx, cd.size,
|
||||
cd.ny, cd.nx * cd.size,
|
||||
maxValue);
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// Expand the pixel data to their original range
|
||||
//
|
||||
|
||||
applyLut (lut, _tmpBuffer, tmpBufferEnd - _tmpBuffer);
|
||||
|
||||
//
|
||||
// Rearrange the pixel data into the format expected by the caller.
|
||||
//
|
||||
|
||||
char *outEnd = _outBuffer;
|
||||
|
||||
if (_format == XDR)
|
||||
{
|
||||
//
|
||||
// Machine-independent (Xdr) data format
|
||||
//
|
||||
|
||||
for (int y = minY; y <= maxY; ++y)
|
||||
{
|
||||
for (int i = 0; i < _numChans; ++i)
|
||||
{
|
||||
ChannelData &cd = _channelData[i];
|
||||
|
||||
if (modp (y, cd.ys) != 0)
|
||||
continue;
|
||||
|
||||
for (int x = cd.nx * cd.size; x > 0; --x)
|
||||
{
|
||||
Xdr::write <CharPtrIO> (outEnd, *cd.end);
|
||||
++cd.end;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
//
|
||||
// Native, machine-dependent data format
|
||||
//
|
||||
|
||||
for (int y = minY; y <= maxY; ++y)
|
||||
{
|
||||
for (int i = 0; i < _numChans; ++i)
|
||||
{
|
||||
ChannelData &cd = _channelData[i];
|
||||
|
||||
if (modp (y, cd.ys) != 0)
|
||||
continue;
|
||||
|
||||
int n = cd.nx * cd.size;
|
||||
memcpy (outEnd, cd.end, n * sizeof (unsigned short));
|
||||
outEnd += n * sizeof (unsigned short);
|
||||
cd.end += n;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#if defined (DEBUG)
|
||||
|
||||
for (int i = 1; i < _numChans; ++i)
|
||||
assert (_channelData[i-1].end == _channelData[i].start);
|
||||
|
||||
assert (_channelData[_numChans-1].end == tmpBufferEnd);
|
||||
|
||||
#endif
|
||||
|
||||
outPtr = _outBuffer;
|
||||
return outEnd - _outBuffer;
|
||||
}
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
@@ -1,112 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
#ifndef INCLUDED_IMF_PIZ_COMPRESSOR_H
|
||||
#define INCLUDED_IMF_PIZ_COMPRESSOR_H
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class PizCompressor -- uses Wavelet and Huffman encoding.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfCompressor.h>
|
||||
|
||||
namespace Imf {
|
||||
|
||||
class ChannelList;
|
||||
|
||||
|
||||
class PizCompressor: public Compressor
|
||||
{
|
||||
public:
|
||||
|
||||
PizCompressor (const Header &hdr, int maxScanLineSize, int numScanLines);
|
||||
virtual ~PizCompressor ();
|
||||
|
||||
virtual int numScanLines () const;
|
||||
|
||||
virtual Format format () const;
|
||||
|
||||
virtual int compress (const char *inPtr,
|
||||
int inSize,
|
||||
int minY,
|
||||
const char *&outPtr);
|
||||
|
||||
virtual int compressTile (const char *inPtr,
|
||||
int inSize,
|
||||
Imath::Box2i range,
|
||||
const char *&outPtr);
|
||||
|
||||
virtual int uncompress (const char *inPtr,
|
||||
int inSize,
|
||||
int minY,
|
||||
const char *&outPtr);
|
||||
|
||||
virtual int uncompressTile (const char *inPtr,
|
||||
int inSize,
|
||||
Imath::Box2i range,
|
||||
const char *&outPtr);
|
||||
private:
|
||||
|
||||
struct ChannelData;
|
||||
|
||||
int compress (const char *inPtr,
|
||||
int inSize,
|
||||
Imath::Box2i range,
|
||||
const char *&outPtr);
|
||||
|
||||
int uncompress (const char *inPtr,
|
||||
int inSize,
|
||||
Imath::Box2i range,
|
||||
const char *&outPtr);
|
||||
|
||||
int _maxScanLineSize;
|
||||
Format _format;
|
||||
int _numScanLines;
|
||||
unsigned short * _tmpBuffer;
|
||||
char * _outBuffer;
|
||||
int _numChans;
|
||||
const ChannelList & _channels;
|
||||
ChannelData * _channelData;
|
||||
int _minX;
|
||||
int _maxX;
|
||||
int _maxY;
|
||||
};
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
|
||||
#endif
|
||||
@@ -1,101 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2003, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class PreviewImage
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfPreviewImage.h>
|
||||
#include "Iex.h"
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
PreviewImage::PreviewImage (unsigned int width,
|
||||
unsigned int height,
|
||||
const PreviewRgba pixels[])
|
||||
{
|
||||
_width = width;
|
||||
_height = height;
|
||||
_pixels = new PreviewRgba [_width * _height];
|
||||
|
||||
if (pixels)
|
||||
{
|
||||
for (unsigned int i = 0; i < _width * _height; ++i)
|
||||
_pixels[i] = pixels[i];
|
||||
}
|
||||
else
|
||||
{
|
||||
for (unsigned int i = 0; i < _width * _height; ++i)
|
||||
_pixels[i] = PreviewRgba();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
PreviewImage::PreviewImage (const PreviewImage &other):
|
||||
_width (other._width),
|
||||
_height (other._height),
|
||||
_pixels (new PreviewRgba [other._width * other._height])
|
||||
{
|
||||
for (unsigned int i = 0; i < _width * _height; ++i)
|
||||
_pixels[i] = other._pixels[i];
|
||||
}
|
||||
|
||||
|
||||
PreviewImage::~PreviewImage ()
|
||||
{
|
||||
delete [] _pixels;
|
||||
}
|
||||
|
||||
|
||||
PreviewImage &
|
||||
PreviewImage::operator = (const PreviewImage &other)
|
||||
{
|
||||
delete [] _pixels;
|
||||
|
||||
_width = other._width;
|
||||
_height = other._height;
|
||||
_pixels = new PreviewRgba [other._width * other._height];
|
||||
|
||||
for (unsigned int i = 0; i < _width * _height; ++i)
|
||||
_pixels[i] = other._pixels[i];
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
@@ -1,131 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (c) 2003, 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
#ifndef INCLUDED_IMF_PREVIEW_IMAGE_H
|
||||
#define INCLUDED_IMF_PREVIEW_IMAGE_H
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class PreviewImage -- a usually small, low-dynamic range image,
|
||||
// that is intended to be stored in an image file's header.
|
||||
//
|
||||
// struct PreviewRgba -- holds the value of a PreviewImage pixel.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
struct PreviewRgba
|
||||
{
|
||||
unsigned char r; // Red, green and blue components of
|
||||
unsigned char g; // the pixel's color; intensity is
|
||||
unsigned char b; // proportional to pow (x/255, 2.2),
|
||||
// where x is r, g, or b.
|
||||
|
||||
unsigned char a; // The pixel's alpha; 0 == transparent,
|
||||
// 255 == opaque.
|
||||
|
||||
PreviewRgba (unsigned char r = 0,
|
||||
unsigned char g = 0,
|
||||
unsigned char b = 0,
|
||||
unsigned char a = 255)
|
||||
: r(r), g(g), b(b), a(a) {}
|
||||
};
|
||||
|
||||
|
||||
class PreviewImage
|
||||
{
|
||||
public:
|
||||
|
||||
//--------------------------------------------------------------------
|
||||
// Constructor:
|
||||
//
|
||||
// PreviewImage(w,h,p) constructs a preview image with w by h pixels
|
||||
// whose initial values are specified in pixel array p. The x and y
|
||||
// coordinates of the pixels in p go from 0 to w-1, and from 0 to h-1.
|
||||
// The pixel with coordinates (x, y) is at address p + y*w + x.
|
||||
// Pixel (0, 0) is in the upper left corner of the preview image.
|
||||
// If p is zero, the pixels in the preview image are initialized with
|
||||
// (r = 0, b = 0, g = 0, a = 255).
|
||||
//
|
||||
//--------------------------------------------------------------------
|
||||
|
||||
PreviewImage (unsigned int width = 0,
|
||||
unsigned int height = 0,
|
||||
const PreviewRgba pixels[] = 0);
|
||||
|
||||
//-----------------------------------------------------
|
||||
// Copy constructor, destructor and assignment operator
|
||||
//-----------------------------------------------------
|
||||
|
||||
PreviewImage (const PreviewImage &other);
|
||||
~PreviewImage ();
|
||||
|
||||
PreviewImage & operator = (const PreviewImage &other);
|
||||
|
||||
|
||||
//-----------------------------------------------
|
||||
// Access to width, height and to the pixel array
|
||||
//-----------------------------------------------
|
||||
|
||||
unsigned int width () const {return _width;}
|
||||
unsigned int height () const {return _height;}
|
||||
|
||||
PreviewRgba * pixels () {return _pixels;}
|
||||
const PreviewRgba * pixels () const {return _pixels;}
|
||||
|
||||
|
||||
//----------------------------
|
||||
// Access to individual pixels
|
||||
//----------------------------
|
||||
|
||||
PreviewRgba & pixel (unsigned int x, unsigned int y)
|
||||
{return _pixels[y * _width + x];}
|
||||
|
||||
const PreviewRgba & pixel (unsigned int x, unsigned int y) const
|
||||
{return _pixels[y * _width + x];}
|
||||
|
||||
private:
|
||||
|
||||
unsigned int _width;
|
||||
unsigned int _height;
|
||||
PreviewRgba * _pixels;
|
||||
};
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
|
||||
#endif
|
||||
@@ -1,102 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class PreviewImageAttribute
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfPreviewImageAttribute.h>
|
||||
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
template <>
|
||||
const char *
|
||||
PreviewImageAttribute::staticTypeName ()
|
||||
{
|
||||
return "preview";
|
||||
}
|
||||
|
||||
|
||||
template <>
|
||||
void
|
||||
PreviewImageAttribute::writeValueTo (OStream &os, int version) const
|
||||
{
|
||||
Xdr::write <StreamIO> (os, _value.width());
|
||||
Xdr::write <StreamIO> (os, _value.height());
|
||||
|
||||
int numPixels = _value.width() * _value.height();
|
||||
const PreviewRgba *pixels = _value.pixels();
|
||||
|
||||
for (int i = 0; i < numPixels; ++i)
|
||||
{
|
||||
Xdr::write <StreamIO> (os, pixels[i].r);
|
||||
Xdr::write <StreamIO> (os, pixels[i].g);
|
||||
Xdr::write <StreamIO> (os, pixels[i].b);
|
||||
Xdr::write <StreamIO> (os, pixels[i].a);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
template <>
|
||||
void
|
||||
PreviewImageAttribute::readValueFrom (IStream &is, int size, int version)
|
||||
{
|
||||
int width, height;
|
||||
|
||||
Xdr::read <StreamIO> (is, width);
|
||||
Xdr::read <StreamIO> (is, height);
|
||||
|
||||
PreviewImage p (width, height);
|
||||
|
||||
int numPixels = p.width() * p.height();
|
||||
PreviewRgba *pixels = p.pixels();
|
||||
|
||||
for (int i = 0; i < numPixels; ++i)
|
||||
{
|
||||
Xdr::read <StreamIO> (is, pixels[i].r);
|
||||
Xdr::read <StreamIO> (is, pixels[i].g);
|
||||
Xdr::read <StreamIO> (is, pixels[i].b);
|
||||
Xdr::read <StreamIO> (is, pixels[i].a);
|
||||
}
|
||||
|
||||
_value = p;
|
||||
}
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
@@ -1,71 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
#ifndef INCLUDED_IMF_PREVIEW_IMAGE_ATTRIBUTE_H
|
||||
#define INCLUDED_IMF_PREVIEW_IMAGE_ATTRIBUTE_H
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// class PreviewImageAttribute
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include <ImfAttribute.h>
|
||||
#include <ImfPreviewImage.h>
|
||||
|
||||
|
||||
namespace Imf {
|
||||
|
||||
|
||||
typedef TypedAttribute<PreviewImage> PreviewImageAttribute;
|
||||
|
||||
template <>
|
||||
const char *PreviewImageAttribute::staticTypeName ();
|
||||
|
||||
template <>
|
||||
void PreviewImageAttribute::writeValueTo (OStream &, int) const;
|
||||
|
||||
template <>
|
||||
void PreviewImageAttribute::readValueFrom (IStream &, int, int);
|
||||
|
||||
|
||||
} // namespace Imf
|
||||
|
||||
// Metrowerks compiler wants the .cpp file inlined, too
|
||||
#ifdef __MWERKS__
|
||||
#include <ImfPreviewImageAttribute.cpp>
|
||||
#endif
|
||||
|
||||
#endif
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user