void
OpenEXRInput::PartInfo::parse_header (const Imf::Header *header)
{
if (initialized)
return;
ASSERT (header);
spec = ImageSpec();
top_datawindow = header->dataWindow();
top_displaywindow = header->displayWindow();
spec.x = top_datawindow.min.x;
spec.y = top_datawindow.min.y;
spec.z = 0;
spec.width = top_datawindow.max.x - top_datawindow.min.x + 1;
spec.height = top_datawindow.max.y - top_datawindow.min.y + 1;
spec.depth = 1;
topwidth = spec.width; // Save top-level mipmap dimensions
topheight = spec.height;
spec.full_x = top_displaywindow.min.x;
spec.full_y = top_displaywindow.min.y;
spec.full_z = 0;
spec.full_width = top_displaywindow.max.x - top_displaywindow.min.x + 1;
spec.full_height = top_displaywindow.max.y - top_displaywindow.min.y + 1;
spec.full_depth = 1;
spec.tile_depth = 1;
if (header->hasTileDescription()) {
const Imf::TileDescription &td (header->tileDescription());
spec.tile_width = td.xSize;
spec.tile_height = td.ySize;
levelmode = td.mode;
roundingmode = td.roundingMode;
if (levelmode == Imf::MIPMAP_LEVELS)
nmiplevels = numlevels (std::max(topwidth,topheight), roundingmode);
else if (levelmode == Imf::RIPMAP_LEVELS)
nmiplevels = numlevels (std::max(topwidth,topheight), roundingmode);
else
nmiplevels = 1;
} else {
spec.tile_width = 0;
spec.tile_height = 0;
levelmode = Imf::ONE_LEVEL;
nmiplevels = 1;
}
query_channels (header); // also sets format
#ifdef USE_OPENEXR_VERSION2
spec.deep = Strutil::istarts_with (header->type(), "deep");
#endif
// Unless otherwise specified, exr files are assumed to be linear.
spec.attribute ("oiio:ColorSpace", "Linear");
if (levelmode != Imf::ONE_LEVEL)
spec.attribute ("openexr:roundingmode", roundingmode);
const Imf::EnvmapAttribute *envmap;
envmap = header->findTypedAttribute<Imf::EnvmapAttribute>("envmap");
if (envmap) {
cubeface = (envmap->value() == Imf::ENVMAP_CUBE);
spec.attribute ("textureformat", cubeface ? "CubeFace Environment" : "LatLong Environment");
// OpenEXR conventions for env maps
if (! cubeface)
spec.attribute ("oiio:updirection", "y");
spec.attribute ("oiio:sampleborder", 1);
// FIXME - detect CubeFace Shadow?
} else {
cubeface = false;
if (spec.tile_width && levelmode == Imf::MIPMAP_LEVELS)
spec.attribute ("textureformat", "Plain Texture");
// FIXME - detect Shadow
}
const Imf::CompressionAttribute *compressattr;
compressattr = header->findTypedAttribute<Imf::CompressionAttribute>("compression");
if (compressattr) {
const char *comp = NULL;
switch (compressattr->value()) {
case Imf::NO_COMPRESSION : comp = "none"; break;
case Imf::RLE_COMPRESSION : comp = "rle"; break;
case Imf::ZIPS_COMPRESSION : comp = "zips"; break;
case Imf::ZIP_COMPRESSION : comp = "zip"; break;
case Imf::PIZ_COMPRESSION : comp = "piz"; break;
case Imf::PXR24_COMPRESSION : comp = "pxr24"; break;
#ifdef IMF_B44_COMPRESSION
// The enum Imf::B44_COMPRESSION is not defined in older versions
// of OpenEXR, and there are no explicit version numbers in the
// headers. BUT this other related #define is present only in
// the newer version.
case Imf::B44_COMPRESSION : comp = "b44"; break;
case Imf::B44A_COMPRESSION : comp = "b44a"; break;
#endif
#if defined(OPENEXR_VERSION_MAJOR) && \
(OPENEXR_VERSION_MAJOR*10000+OPENEXR_VERSION_MINOR*100+OPENEXR_VERSION_PATCH) >= 20200
case Imf::DWAA_COMPRESSION : comp = "dwaa"; break;
case Imf::DWAB_COMPRESSION : comp = "dwab"; break;
#endif
default:
break;
}
if (comp)
spec.attribute ("compression", comp);
}
for (Imf::Header::ConstIterator hit = header->begin();
hit != header->end(); ++hit) {
const Imf::IntAttribute *iattr;
const Imf::FloatAttribute *fattr;
const Imf::StringAttribute *sattr;
const Imf::M44fAttribute *mattr;
const Imf::V3fAttribute *v3fattr;
const Imf::V3iAttribute *v3iattr;
const Imf::V2fAttribute *v2fattr;
const Imf::V2iAttribute *v2iattr;
const Imf::Box2iAttribute *b2iattr;
const Imf::Box2fAttribute *b2fattr;
const Imf::TimeCodeAttribute *tattr;
const Imf::KeyCodeAttribute *kcattr;
#ifdef USE_OPENEXR_VERSION2
const Imf::StringVectorAttribute *svattr;
#endif
const char *name = hit.name();
std::string oname = exr_tag_to_ooio_std[name];
if (oname.empty()) // Empty string means skip this attrib
continue;
// if (oname == name)
// oname = std::string(format_name()) + "_" + oname;
const Imf::Attribute &attrib = hit.attribute();
std::string type = attrib.typeName();
if (type == "string" &&
(sattr = header->findTypedAttribute<Imf::StringAttribute> (name)))
spec.attribute (oname, sattr->value().c_str());
else if (type == "int" &&
(iattr = header->findTypedAttribute<Imf::IntAttribute> (name)))
spec.attribute (oname, iattr->value());
else if (type == "float" &&
(fattr = header->findTypedAttribute<Imf::FloatAttribute> (name)))
spec.attribute (oname, fattr->value());
else if (type == "m44f" &&
(mattr = header->findTypedAttribute<Imf::M44fAttribute> (name)))
spec.attribute (oname, TypeDesc::TypeMatrix, &(mattr->value()));
else if (type == "v3f" &&
(v3fattr = header->findTypedAttribute<Imf::V3fAttribute> (name)))
spec.attribute (oname, TypeDesc::TypeVector, &(v3fattr->value()));
else if (type == "v3i" &&
(v3iattr = header->findTypedAttribute<Imf::V3iAttribute> (name))) {
TypeDesc v3 (TypeDesc::INT, TypeDesc::VEC3, TypeDesc::VECTOR);
spec.attribute (oname, v3, &(v3iattr->value()));
}
else if (type == "v2f" &&
(v2fattr = header->findTypedAttribute<Imf::V2fAttribute> (name))) {
TypeDesc v2 (TypeDesc::FLOAT,TypeDesc::VEC2);
spec.attribute (oname, v2, &(v2fattr->value()));
}
else if (type == "v2i" &&
(v2iattr = header->findTypedAttribute<Imf::V2iAttribute> (name))) {
TypeDesc v2 (TypeDesc::INT,TypeDesc::VEC2);
spec.attribute (oname, v2, &(v2iattr->value()));
}
#ifdef USE_OPENEXR_VERSION2
else if (type == "stringvector" &&
(svattr = header->findTypedAttribute<Imf::StringVectorAttribute> (name))) {
std::vector<std::string> strvec = svattr->value();
std::vector<ustring> ustrvec (strvec.size());
for (size_t i = 0, e = strvec.size(); i < e; ++i)
ustrvec[i] = strvec[i];
TypeDesc sv (TypeDesc::STRING, ustrvec.size());
spec.attribute(oname, sv, &ustrvec[0]);
}
#endif
else if (type == "box2i" &&
(b2iattr = header->findTypedAttribute<Imf::Box2iAttribute> (name))) {
TypeDesc bx (TypeDesc::INT, TypeDesc::VEC2, 2);
spec.attribute (oname, bx, &b2iattr->value());
}
else if (type == "box2f" &&
(b2fattr = header->findTypedAttribute<Imf::Box2fAttribute> (name))) {
TypeDesc bx (TypeDesc::FLOAT, TypeDesc::VEC2, 2);
spec.attribute (oname, bx, &b2fattr->value());
}
else if (type == "timecode" &&
(tattr = header->findTypedAttribute<Imf::TimeCodeAttribute> (name))) {
unsigned int timecode[2];
timecode[0] = tattr->value().timeAndFlags(Imf::TimeCode::TV60_PACKING); //TV60 returns unchanged _time
timecode[1] = tattr->value().userData();
// Elevate "timeCode" to smpte:TimeCode
if (oname == "timeCode")
oname = "smpte:TimeCode";
spec.attribute(oname, TypeDesc::TypeTimeCode, timecode);
}
else if (type == "keycode" &&
(kcattr = header->findTypedAttribute<Imf::KeyCodeAttribute> (name))) {
const Imf::KeyCode *k = &kcattr->value();
unsigned int keycode[7];
keycode[0] = k->filmMfcCode();
keycode[1] = k->filmType();
keycode[2] = k->prefix();
keycode[3] = k->count();
keycode[4] = k->perfOffset();
keycode[5] = k->perfsPerFrame();
keycode[6] = k->perfsPerCount();
// Elevate "keyCode" to smpte:KeyCode
if (oname == "keyCode")
oname = "smpte:KeyCode";
spec.attribute(oname, TypeDesc::TypeKeyCode, keycode);
}
else {
#if 0
std::cerr << " unknown attribute " << type << ' ' << name << "\n";
#endif
}
}
#ifdef USE_OPENEXR_VERSION2
// EXR "name" also gets passed along as "oiio:subimagename".
if (header->hasName())
spec.attribute ("oiio:subimagename", header->name());
#endif
initialized = true;
}
void
OpenEXRInput::PartInfo::parse_header (const Imf::Header *header)
{
if (initialized)
return;
ASSERT (header);
spec = ImageSpec();
top_datawindow = header->dataWindow();
top_displaywindow = header->displayWindow();
spec.x = top_datawindow.min.x;
spec.y = top_datawindow.min.y;
spec.z = 0;
spec.width = top_datawindow.max.x - top_datawindow.min.x + 1;
spec.height = top_datawindow.max.y - top_datawindow.min.y + 1;
spec.depth = 1;
topwidth = spec.width; // Save top-level mipmap dimensions
topheight = spec.height;
spec.full_x = top_displaywindow.min.x;
spec.full_y = top_displaywindow.min.y;
spec.full_z = 0;
spec.full_width = top_displaywindow.max.x - top_displaywindow.min.x + 1;
spec.full_height = top_displaywindow.max.y - top_displaywindow.min.y + 1;
spec.full_depth = 1;
spec.tile_depth = 1;
if (header->hasTileDescription()) {
const Imf::TileDescription &td (header->tileDescription());
spec.tile_width = td.xSize;
spec.tile_height = td.ySize;
levelmode = td.mode;
roundingmode = td.roundingMode;
if (levelmode == Imf::MIPMAP_LEVELS)
nmiplevels = numlevels (std::max(topwidth,topheight), roundingmode);
else if (levelmode == Imf::RIPMAP_LEVELS)
nmiplevels = numlevels (std::max(topwidth,topheight), roundingmode);
else
nmiplevels = 1;
} else {
spec.tile_width = 0;
spec.tile_height = 0;
levelmode = Imf::ONE_LEVEL;
nmiplevels = 1;
}
query_channels (header); // also sets format
#ifdef USE_OPENEXR_VERSION2
spec.deep = Imf::isDeepData (header->type());
#endif
// Unless otherwise specified, exr files are assumed to be linear.
spec.attribute ("oiio:ColorSpace", "Linear");
if (levelmode != Imf::ONE_LEVEL)
spec.attribute ("openexr:roundingmode", roundingmode);
const Imf::EnvmapAttribute *envmap;
envmap = header->findTypedAttribute<Imf::EnvmapAttribute>("envmap");
if (envmap) {
cubeface = (envmap->value() == Imf::ENVMAP_CUBE);
spec.attribute ("textureformat", cubeface ? "CubeFace Environment" : "LatLong Environment");
// OpenEXR conventions for env maps
if (! cubeface)
spec.attribute ("oiio:updirection", "y");
spec.attribute ("oiio:sampleborder", 1);
// FIXME - detect CubeFace Shadow?
} else {
cubeface = false;
if (spec.tile_width && levelmode == Imf::MIPMAP_LEVELS)
spec.attribute ("textureformat", "Plain Texture");
// FIXME - detect Shadow
}
const Imf::CompressionAttribute *compressattr;
compressattr = header->findTypedAttribute<Imf::CompressionAttribute>("compression");
if (compressattr) {
const char *comp = NULL;
switch (compressattr->value()) {
case Imf::NO_COMPRESSION : comp = "none"; break;
case Imf::RLE_COMPRESSION : comp = "rle"; break;
case Imf::ZIPS_COMPRESSION : comp = "zips"; break;
case Imf::ZIP_COMPRESSION : comp = "zip"; break;
case Imf::PIZ_COMPRESSION : comp = "piz"; break;
case Imf::PXR24_COMPRESSION : comp = "pxr24"; break;
#ifdef IMF_B44_COMPRESSION
// The enum Imf::B44_COMPRESSION is not defined in older versions
// of OpenEXR, and there are no explicit version numbers in the
// headers. BUT this other related #define is present only in
// the newer version.
case Imf::B44_COMPRESSION : comp = "b44"; break;
case Imf::B44A_COMPRESSION : comp = "b44a"; break;
#endif
default:
break;
}
if (comp)
spec.attribute ("compression", comp);
}
for (Imf::Header::ConstIterator hit = header->begin();
hit != header->end(); ++hit) {
const Imf::IntAttribute *iattr;
const Imf::FloatAttribute *fattr;
const Imf::StringAttribute *sattr;
const Imf::M44fAttribute *mattr;
const Imf::V3fAttribute *vattr;
const Imf::V2fAttribute *v2attr;
const char *name = hit.name();
std::string oname = exr_tag_to_ooio_std[name];
if (oname.empty()) // Empty string means skip this attrib
continue;
// if (oname == name)
// oname = std::string(format_name()) + "_" + oname;
const Imf::Attribute &attrib = hit.attribute();
std::string type = attrib.typeName();
if (type == "string" &&
(sattr = header->findTypedAttribute<Imf::StringAttribute> (name)))
spec.attribute (oname, sattr->value().c_str());
else if (type == "int" &&
(iattr = header->findTypedAttribute<Imf::IntAttribute> (name)))
spec.attribute (oname, iattr->value());
else if (type == "float" &&
(fattr = header->findTypedAttribute<Imf::FloatAttribute> (name)))
spec.attribute (oname, fattr->value());
else if (type == "m44f" &&
(mattr = header->findTypedAttribute<Imf::M44fAttribute> (name)))
spec.attribute (oname, TypeDesc::TypeMatrix, &(mattr->value()));
else if (type == "v3f" &&
(vattr = header->findTypedAttribute<Imf::V3fAttribute> (name)))
spec.attribute (oname, TypeDesc::TypeVector, &(vattr->value()));
else if (type == "v2f" &&
(v2attr = header->findTypedAttribute<Imf::V2fAttribute> (name))) {
TypeDesc v2 (TypeDesc::FLOAT,TypeDesc::VEC2);
spec.attribute (oname, v2, &(v2attr->value()));
}
else {
#if 0
std::cerr << " unknown attribute " << type << ' ' << name << "\n";
#endif
}
}
initialized = true;
}
void
OpenEXRInput::PartInfo::parse_header (const Imf::Header *header)
{
if (initialized)
return;
ASSERT (header);
spec = ImageSpec();
top_datawindow = header->dataWindow();
top_displaywindow = header->displayWindow();
spec.x = top_datawindow.min.x;
spec.y = top_datawindow.min.y;
spec.z = 0;
spec.width = top_datawindow.max.x - top_datawindow.min.x + 1;
spec.height = top_datawindow.max.y - top_datawindow.min.y + 1;
spec.depth = 1;
topwidth = spec.width; // Save top-level mipmap dimensions
topheight = spec.height;
spec.full_x = top_displaywindow.min.x;
spec.full_y = top_displaywindow.min.y;
spec.full_z = 0;
spec.full_width = top_displaywindow.max.x - top_displaywindow.min.x + 1;
spec.full_height = top_displaywindow.max.y - top_displaywindow.min.y + 1;
spec.full_depth = 1;
spec.tile_depth = 1;
if (header->hasTileDescription()
&& Strutil::icontains(header->type(), "tile")) {
const Imf::TileDescription &td (header->tileDescription());
spec.tile_width = td.xSize;
spec.tile_height = td.ySize;
levelmode = td.mode;
roundingmode = td.roundingMode;
if (levelmode == Imf::MIPMAP_LEVELS)
nmiplevels = numlevels (std::max(topwidth,topheight), roundingmode);
else if (levelmode == Imf::RIPMAP_LEVELS)
nmiplevels = numlevels (std::max(topwidth,topheight), roundingmode);
else
nmiplevels = 1;
} else {
spec.tile_width = 0;
spec.tile_height = 0;
levelmode = Imf::ONE_LEVEL;
nmiplevels = 1;
}
query_channels (header); // also sets format
spec.deep = Strutil::istarts_with (header->type(), "deep");
// Unless otherwise specified, exr files are assumed to be linear.
spec.attribute ("oiio:ColorSpace", "Linear");
if (levelmode != Imf::ONE_LEVEL)
spec.attribute ("openexr:roundingmode", roundingmode);
const Imf::EnvmapAttribute *envmap;
envmap = header->findTypedAttribute<Imf::EnvmapAttribute>("envmap");
if (envmap) {
cubeface = (envmap->value() == Imf::ENVMAP_CUBE);
spec.attribute ("textureformat", cubeface ? "CubeFace Environment" : "LatLong Environment");
// OpenEXR conventions for env maps
if (! cubeface)
spec.attribute ("oiio:updirection", "y");
spec.attribute ("oiio:sampleborder", 1);
// FIXME - detect CubeFace Shadow?
} else {
cubeface = false;
if (spec.tile_width && levelmode == Imf::MIPMAP_LEVELS)
spec.attribute ("textureformat", "Plain Texture");
// FIXME - detect Shadow
}
const Imf::CompressionAttribute *compressattr;
compressattr = header->findTypedAttribute<Imf::CompressionAttribute>("compression");
if (compressattr) {
const char *comp = NULL;
switch (compressattr->value()) {
case Imf::NO_COMPRESSION : comp = "none"; break;
case Imf::RLE_COMPRESSION : comp = "rle"; break;
case Imf::ZIPS_COMPRESSION : comp = "zips"; break;
case Imf::ZIP_COMPRESSION : comp = "zip"; break;
case Imf::PIZ_COMPRESSION : comp = "piz"; break;
case Imf::PXR24_COMPRESSION : comp = "pxr24"; break;
#ifdef IMF_B44_COMPRESSION
// The enum Imf::B44_COMPRESSION is not defined in older versions
// of OpenEXR, and there are no explicit version numbers in the
// headers. BUT this other related #define is present only in
// the newer version.
case Imf::B44_COMPRESSION : comp = "b44"; break;
case Imf::B44A_COMPRESSION : comp = "b44a"; break;
#endif
#if defined(OPENEXR_VERSION_MAJOR) && \
(OPENEXR_VERSION_MAJOR*10000+OPENEXR_VERSION_MINOR*100+OPENEXR_VERSION_PATCH) >= 20200
case Imf::DWAA_COMPRESSION : comp = "dwaa"; break;
case Imf::DWAB_COMPRESSION : comp = "dwab"; break;
#endif
default:
break;
}
if (comp)
spec.attribute ("compression", comp);
}
for (Imf::Header::ConstIterator hit = header->begin();
hit != header->end(); ++hit) {
const Imf::IntAttribute *iattr;
const Imf::FloatAttribute *fattr;
const Imf::StringAttribute *sattr;
const Imf::M33fAttribute *m33fattr;
const Imf::M44fAttribute *m44fattr;
const Imf::V3fAttribute *v3fattr;
const Imf::V3iAttribute *v3iattr;
const Imf::V2fAttribute *v2fattr;
const Imf::V2iAttribute *v2iattr;
const Imf::Box2iAttribute *b2iattr;
const Imf::Box2fAttribute *b2fattr;
const Imf::TimeCodeAttribute *tattr;
const Imf::KeyCodeAttribute *kcattr;
const Imf::ChromaticitiesAttribute *crattr;
const Imf::RationalAttribute *rattr;
const Imf::StringVectorAttribute *svattr;
const Imf::DoubleAttribute *dattr;
const Imf::V2dAttribute *v2dattr;
const Imf::V3dAttribute *v3dattr;
const Imf::M33dAttribute *m33dattr;
const Imf::M44dAttribute *m44dattr;
const char *name = hit.name();
std::string oname = exr_tag_to_oiio_std[name];
if (oname.empty()) // Empty string means skip this attrib
continue;
// if (oname == name)
// oname = std::string(format_name()) + "_" + oname;
const Imf::Attribute &attrib = hit.attribute();
std::string type = attrib.typeName();
if (type == "string" &&
(sattr = header->findTypedAttribute<Imf::StringAttribute> (name)))
spec.attribute (oname, sattr->value().c_str());
else if (type == "int" &&
(iattr = header->findTypedAttribute<Imf::IntAttribute> (name)))
spec.attribute (oname, iattr->value());
else if (type == "float" &&
(fattr = header->findTypedAttribute<Imf::FloatAttribute> (name)))
spec.attribute (oname, fattr->value());
else if (type == "m33f" &&
(m33fattr = header->findTypedAttribute<Imf::M33fAttribute> (name)))
spec.attribute (oname, TypeMatrix33, &(m33fattr->value()));
else if (type == "m44f" &&
(m44fattr = header->findTypedAttribute<Imf::M44fAttribute> (name)))
spec.attribute (oname, TypeMatrix44, &(m44fattr->value()));
else if (type == "v3f" &&
(v3fattr = header->findTypedAttribute<Imf::V3fAttribute> (name)))
spec.attribute (oname, TypeVector, &(v3fattr->value()));
else if (type == "v3i" &&
(v3iattr = header->findTypedAttribute<Imf::V3iAttribute> (name))) {
TypeDesc v3 (TypeDesc::INT, TypeDesc::VEC3, TypeDesc::VECTOR);
spec.attribute (oname, v3, &(v3iattr->value()));
}
else if (type == "v2f" &&
(v2fattr = header->findTypedAttribute<Imf::V2fAttribute> (name))) {
TypeDesc v2 (TypeDesc::FLOAT,TypeDesc::VEC2);
spec.attribute (oname, v2, &(v2fattr->value()));
}
else if (type == "v2i" &&
(v2iattr = header->findTypedAttribute<Imf::V2iAttribute> (name))) {
TypeDesc v2 (TypeDesc::INT,TypeDesc::VEC2);
spec.attribute (oname, v2, &(v2iattr->value()));
}
else if (type == "stringvector" &&
(svattr = header->findTypedAttribute<Imf::StringVectorAttribute> (name))) {
std::vector<std::string> strvec = svattr->value();
std::vector<ustring> ustrvec (strvec.size());
for (size_t i = 0, e = strvec.size(); i < e; ++i)
ustrvec[i] = strvec[i];
TypeDesc sv (TypeDesc::STRING, ustrvec.size());
spec.attribute(oname, sv, &ustrvec[0]);
}
else if (type == "double" &&
(dattr = header->findTypedAttribute<Imf::DoubleAttribute> (name))) {
TypeDesc d (TypeDesc::DOUBLE);
spec.attribute (oname, d, &(dattr->value()));
}
else if (type == "v2d" &&
(v2dattr = header->findTypedAttribute<Imf::V2dAttribute> (name))) {
TypeDesc v2 (TypeDesc::DOUBLE,TypeDesc::VEC2);
spec.attribute (oname, v2, &(v2dattr->value()));
}
else if (type == "v3d" &&
(v3dattr = header->findTypedAttribute<Imf::V3dAttribute> (name))) {
TypeDesc v3 (TypeDesc::DOUBLE,TypeDesc::VEC3, TypeDesc::VECTOR);
spec.attribute (oname, v3, &(v3dattr->value()));
}
else if (type == "m33d" &&
(m33dattr = header->findTypedAttribute<Imf::M33dAttribute> (name))) {
TypeDesc m33 (TypeDesc::DOUBLE, TypeDesc::MATRIX33);
spec.attribute (oname, m33, &(m33dattr->value()));
}
else if (type == "m44d" &&
(m44dattr = header->findTypedAttribute<Imf::M44dAttribute> (name))) {
TypeDesc m44 (TypeDesc::DOUBLE, TypeDesc::MATRIX44);
spec.attribute (oname, m44, &(m44dattr->value()));
}
else if (type == "box2i" &&
(b2iattr = header->findTypedAttribute<Imf::Box2iAttribute> (name))) {
TypeDesc bx (TypeDesc::INT, TypeDesc::VEC2, 2);
spec.attribute (oname, bx, &b2iattr->value());
}
else if (type == "box2f" &&
(b2fattr = header->findTypedAttribute<Imf::Box2fAttribute> (name))) {
TypeDesc bx (TypeDesc::FLOAT, TypeDesc::VEC2, 2);
spec.attribute (oname, bx, &b2fattr->value());
}
else if (type == "timecode" &&
(tattr = header->findTypedAttribute<Imf::TimeCodeAttribute> (name))) {
unsigned int timecode[2];
timecode[0] = tattr->value().timeAndFlags(Imf::TimeCode::TV60_PACKING); //TV60 returns unchanged _time
timecode[1] = tattr->value().userData();
// Elevate "timeCode" to smpte:TimeCode
if (oname == "timeCode")
oname = "smpte:TimeCode";
spec.attribute(oname, TypeTimeCode, timecode);
}
else if (type == "keycode" &&
(kcattr = header->findTypedAttribute<Imf::KeyCodeAttribute> (name))) {
const Imf::KeyCode *k = &kcattr->value();
unsigned int keycode[7];
keycode[0] = k->filmMfcCode();
keycode[1] = k->filmType();
keycode[2] = k->prefix();
keycode[3] = k->count();
keycode[4] = k->perfOffset();
keycode[5] = k->perfsPerFrame();
keycode[6] = k->perfsPerCount();
// Elevate "keyCode" to smpte:KeyCode
if (oname == "keyCode")
oname = "smpte:KeyCode";
spec.attribute(oname, TypeKeyCode, keycode);
} else if (type == "chromaticities" &&
(crattr = header->findTypedAttribute<Imf::ChromaticitiesAttribute> (name))) {
const Imf::Chromaticities *chroma = &crattr->value();
spec.attribute (oname, TypeDesc(TypeDesc::FLOAT,8),
(const float *)chroma);
}
else if (type == "rational" &&
(rattr = header->findTypedAttribute<Imf::RationalAttribute> (name))) {
const Imf::Rational *rational = &rattr->value();
int n = rational->n;
unsigned int d = rational->d;
if (d < (1UL << 31)) {
int r[2];
r[0] = n;
r[1] = static_cast<int>(d);
spec.attribute (oname, TypeRational, r);
} else if (int f = static_cast<int>(boost::math::gcd<long int>(rational[0], rational[1])) > 1) {
int r[2];
r[0] = n / f;
r[1] = static_cast<int>(d / f);
spec.attribute (oname, TypeRational, r);
} else {
// TODO: find a way to allow the client to accept "close" rational values
OIIO::debug ("Don't know what to do with OpenEXR Rational attribute %s with value %d / %u that we cannot represent exactly", oname, n, d);
}
}
else {
#if 0
std::cerr << " unknown attribute " << type << ' ' << name << "\n";
#endif
}
}
float aspect = spec.get_float_attribute ("PixelAspectRatio", 0.0f);
float xdensity = spec.get_float_attribute ("XResolution", 0.0f);
if (xdensity) {
// If XResolution is found, supply the YResolution and unit.
spec.attribute ("YResolution", xdensity * (aspect ? aspect : 1.0f));
spec.attribute ("ResolutionUnit", "in"); // EXR is always pixels/inch
}
// EXR "name" also gets passed along as "oiio:subimagename".
if (header->hasName())
spec.attribute ("oiio:subimagename", header->name());
// Squash some problematic texture metadata if we suspect it's wrong
pvt::check_texture_metadata_sanity (spec);
initialized = true;
}
int main(int argc, char* argv[]){
struct MemoryStruct chunk;
char url[FAKE_WWW_MAX_URL_LEN];
char *data, *res;
int i, hits, misses, Npts, started;
int min_cache_sz, max_cache_sz, cache_sz;
int num_requests, nlevels, urlcount;
fake_www www;
size_t sz;
if(argc < 3){
fprintf(stderr,"Usage: cache_test [FAKE_WWW] [NUM_REQUESTS] \n");
exit(0);
}
srand(12314);
fake_www_init(&www, argv[1], 0);
num_requests = strtol(argv[2], NULL, 10);
Npts = 20;
/*Setting minimum and maximum cache sizes*/
min_cache_sz = 1 << 20;
max_cache_sz = 1 << 24;
nlevels = numlevels(&www);
for(i = 0; i < Npts; i++){
/*Cache sizes go up on a logarithmic scale*/
cache_sz = (int) (min_cache_sz * pow( 1.0 * max_cache_sz / min_cache_sz, 1.0 * i / (Npts-1)));
gtcache_init(cache_sz, FAKE_WWW_MIN_CACHE_LEN, nlevels);
hits = 0;
misses = 0;
started = 0;
urlcount = 0;
rewind(stdin);
while(hits + misses < num_requests){
res = fgets(url, FAKE_WWW_MAX_URL_LEN, stdin);
if (res == NULL){
if(!feof(stdin)){
/*We should always be able to read from the file*/
fprintf(stderr, "Error parsing the list of requests\n");
exit(EXIT_FAILURE);
}
else{
/*Rewind to the beginning if we've reached the end*/
started = 1;
rewind(stdin);
if( urlcount == 0 ){
fprintf(stderr, "No valid requests in the input file.\n");
exit(EXIT_FAILURE);
}
urlcount = 0;
continue;
}
}
/*Treat lines starting in # as comments*/
if (url[0] == '#')
continue;
/*Stripping url of any trailing whitespace*/
rstrip(url);
if(strlen(url) == 0)
continue;
urlcount++;
data = gtcache_get(url, &sz);
if(data != NULL){
/*Cache hit!*/
hits+= started;
free(data);
}
else{
/*Cache miss!*/
misses+= started;
fake_www_get(&www, url, &chunk);
/*Accounting for cold start. Only once the cache_size is reached do we start counting*/
if( gtcache_memused() + chunk.size + 1> cache_sz)
started = 1;
gtcache_set(url, chunk.memory, chunk.size + 1);
free(chunk.memory);
}
}
gtcache_destroy();
printf("%d\t%f\n", cache_sz, 1.0*hits/(hits + misses));
}
return 0;
}
