sora/epfl-archive
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Disabled external gits

Browse Source
This commit is contained in:
choelzl
2022-04-07 18:46:57 +02:00
parent 88cb3426ad
commit 15e7120d6d
5316 changed files with 4563444 additions and 6 deletions
Download Patch File Download Diff File Expand all files Collapse all files

519
cs440-acg/ext/openexr/OpenEXR/IlmImf/ImfMultiPartOutputFile.cpp Normal file
View File

@@ -0,0 +1,519 @@
///////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2011, 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 "ImfMultiPartOutputFile.h"
#include "ImfBoxAttribute.h"
#include "ImfFloatAttribute.h"
#include "ImfTimeCodeAttribute.h"
#include "ImfChromaticitiesAttribute.h"
#include "ImfOutputPartData.h"
#include "ImfPartType.h"
#include "ImfOutputFile.h"
#include "ImfTiledOutputFile.h"
#include "ImfThreading.h"
#include "IlmThreadMutex.h"
#include "ImfMisc.h"
#include "ImfStdIO.h"
#include "ImfDeepScanLineOutputFile.h"
#include "ImfDeepTiledOutputFile.h"
#include "ImfOutputStreamMutex.h"
#include "ImfNamespace.h"
#include <Iex.h>
#include <set>
OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER
using IMATH_NAMESPACE::Box2i;
using ILMTHREAD_NAMESPACE::Lock;
using std::vector;
using std::map;
using std::set;
struct MultiPartOutputFile::Data: public OutputStreamMutex
{
vector<OutputPartData*> parts; // Contains data to initialize Output files.
bool deleteStream; // If we should delete the stream when destruction.
int numThreads; // The number of threads.
std::map<int, GenericOutputFile*> _outputFiles;
std::vector<Header> _headers;
void headerNameUniquenessCheck (const std::vector<Header> &headers);
void writeHeadersToFile (const std::vector<Header> &headers);
void writeChunkTableOffsets (std::vector<OutputPartData*> &parts);
//-------------------------------------
// ensure that _headers is valid: called by constructors
//-------------------------------------
void do_header_sanity_checks(bool overrideSharedAttributes);
// ------------------------------------------------
// Given a source header, we copy over all the 'shared attributes' to
// the destination header and remove any conflicting ones.
// ------------------------------------------------
void overrideSharedAttributesValues (const Header & src,
Header & dst);
// ------------------------------------------------
// Given a source header, we check the destination header for any
// attributes that are part of the shared attribute set. For attributes
// present in both we check the values. For attribute present in
// destination but absent in source we return false.
// For attributes present in src but missing from dst we return false
// and add the attribute to dst.
// We return false for all other cases.
// If we return true then we also populate the conflictingAttributes
// vector with the names of the attributes that failed the above.
// ------------------------------------------------
bool checkSharedAttributesValues (const Header & src,
const Header & dst,
std::vector<std::string> & conflictingAttributes) const;
Data (bool deleteStream, int numThreads):
OutputStreamMutex(),
deleteStream (deleteStream),
numThreads (numThreads)
{
}
~Data()
{
if (deleteStream) delete os;
for (size_t i = 0; i < parts.size(); i++)
delete parts[i];
}
};
void
MultiPartOutputFile::Data::do_header_sanity_checks(bool overrideSharedAttributes)
{
size_t parts = _headers.size();
if (parts == 0)
throw IEX_NAMESPACE::ArgExc ("Empty header list.");
bool isMultiPart = (parts > 1);
//
// Do part 0 checks first.
//
_headers[0].sanityCheck (_headers[0].hasTileDescription(), isMultiPart);
if (isMultiPart)
{
// multipart files must contain a chunkCount attribute
_headers[0].setChunkCount(getChunkOffsetTableSize(_headers[0],true));
for (size_t i = 1; i < parts; i++)
{
if (_headers[i].hasType() == false)
throw IEX_NAMESPACE::ArgExc ("Every header in a multipart file should have a type");
_headers[i].setChunkCount(getChunkOffsetTableSize(_headers[i],true));
_headers[i].sanityCheck (_headers[i].hasTileDescription(), isMultiPart);
if (overrideSharedAttributes)
overrideSharedAttributesValues(_headers[0],_headers[i]);
else
{
std::vector<std::string> conflictingAttributes;
bool valid =checkSharedAttributesValues (_headers[0],
_headers[i],
conflictingAttributes);
if (valid)
{
string excMsg("Conflicting attributes found for header :: ");
excMsg += _headers[i].name();
for (size_t i=0; i<conflictingAttributes.size(); i++)
excMsg += " '" + conflictingAttributes[i] + "' ";
THROW (IEX_NAMESPACE::ArgExc, excMsg);
}
}
}
headerNameUniquenessCheck(_headers);
}else{
// add chunk count offset to single part data (if not an image)
if (_headers[0].hasType() && isImage(_headers[0].type()) == false)
{
_headers[0].setChunkCount(getChunkOffsetTableSize(_headers[0],true));
}
}
}
MultiPartOutputFile::MultiPartOutputFile (const char fileName[],
const Header * headers,
int parts,
bool overrideSharedAttributes,
int numThreads)
:
_data (new Data (true, numThreads))
{
// grab headers
_data->_headers.resize(parts);
for(int i=0;i<parts;i++)
{
_data->_headers[i]=headers[i];
}
try
{
_data->do_header_sanity_checks(overrideSharedAttributes);
//
// Build parts and write headers and offset tables to file.
//
_data->os = new StdOFStream (fileName);
for (size_t i = 0; i < _data->_headers.size(); i++)
_data->parts.push_back( new OutputPartData(_data, _data->_headers[i], i, numThreads, parts>1 ) );
writeMagicNumberAndVersionField(*_data->os, &_data->_headers[0],_data->_headers.size());
_data->writeHeadersToFile(_data->_headers);
_data->writeChunkTableOffsets(_data->parts);
}
catch (IEX_NAMESPACE::BaseExc &e)
{
delete _data;
REPLACE_EXC (e, "Cannot open image file "
"\"" << fileName << "\". " << e);
throw;
}
catch (...)
{
delete _data;
throw;
}
}
MultiPartOutputFile::MultiPartOutputFile(OStream& os,
const Header* headers,
int parts,
bool overrideSharedAttributes,
int numThreads):
_data(new Data(false,numThreads))
{
// grab headers
_data->_headers.resize(parts);
_data->os=&os;
for(int i=0;i<parts;i++)
{
_data->_headers[i]=headers[i];
}
try
{
_data->do_header_sanity_checks(overrideSharedAttributes);
//
// Build parts and write headers and offset tables to file.
//
for (size_t i = 0; i < _data->_headers.size(); i++)
_data->parts.push_back( new OutputPartData(_data, _data->_headers[i], i, numThreads, parts>1 ) );
writeMagicNumberAndVersionField(*_data->os, &_data->_headers[0],_data->_headers.size());
_data->writeHeadersToFile(_data->_headers);
_data->writeChunkTableOffsets(_data->parts);
}
catch (IEX_NAMESPACE::BaseExc &e)
{
delete _data;
REPLACE_EXC (e, "Cannot open image stream "
"\"" << os.fileName() << "\". " << e);
throw;
}
catch (...)
{
delete _data;
throw;
}
}
const Header &
MultiPartOutputFile::header(int n) const
{
if(n<0 || n>int(_data->_headers.size()))
{
throw IEX_NAMESPACE::ArgExc("MultiPartOutputFile::header called with invalid part number");
}
return _data->_headers[n];
}
int
MultiPartOutputFile::parts() const
{
return _data->_headers.size();
}
MultiPartOutputFile::~MultiPartOutputFile ()
{
for (map<int, GenericOutputFile*>::iterator it = _data->_outputFiles.begin();
it != _data->_outputFiles.end(); it++)
{
delete it->second;
}
delete _data;
}
template <class T>
T*
MultiPartOutputFile::getOutputPart(int partNumber)
{
Lock lock(*_data);
if (_data->_outputFiles.find(partNumber) == _data->_outputFiles.end())
{
T* file = new T(_data->parts[partNumber]);
_data->_outputFiles.insert(std::make_pair(partNumber, (GenericOutputFile*) file));
return file;
}
else return (T*) _data->_outputFiles[partNumber];
}
// instance above function for all four types
template OutputFile* MultiPartOutputFile::getOutputPart<OutputFile>(int);
template TiledOutputFile * MultiPartOutputFile::getOutputPart<TiledOutputFile>(int);
template DeepScanLineOutputFile * MultiPartOutputFile::getOutputPart<DeepScanLineOutputFile> (int);
template DeepTiledOutputFile * MultiPartOutputFile::getOutputPart<DeepTiledOutputFile> (int);
void
MultiPartOutputFile::Data::overrideSharedAttributesValues(const Header & src, Header & dst)
{
//
// Display Window
//
const Box2iAttribute * displayWindow =
src.findTypedAttribute<Box2iAttribute> ("displayWindow");
if (displayWindow)
dst.insert ("displayWindow", *displayWindow);
else
dst.erase ("displayWindow");
//
// Pixel Aspect Ratio
//
const FloatAttribute * pixelAspectRatio =
src.findTypedAttribute<FloatAttribute> ("pixelAspectRatio");
if (pixelAspectRatio)
dst.insert ("pixelAspectRatio", *pixelAspectRatio);
else
dst.erase ("pixelAspectRatio");
//
// Timecode
//
const TimeCodeAttribute * timeCode =
src.findTypedAttribute<TimeCodeAttribute> ("timecode");
if (timeCode)
dst.insert ("timecode", *timeCode);
else
dst.erase ("timecode");
//
// Chromaticities
//
const ChromaticitiesAttribute * chromaticities =
src.findTypedAttribute<ChromaticitiesAttribute> ("chromaticities");
if (chromaticities)
dst.insert ("chromaticities", *chromaticities);
else
dst.erase ("chromaticities");
}
bool
MultiPartOutputFile::Data::checkSharedAttributesValues(const Header & src,
const Header & dst,
vector<string> & conflictingAttributes) const
{
bool conflict = false;
//
// Display Window
//
if (src.displayWindow() != dst.displayWindow())
{
conflict = true;
conflictingAttributes.push_back ("displayWindow");
}
//
// Pixel Aspect Ratio
//
if (src.pixelAspectRatio() != dst.pixelAspectRatio())
{
conflict = true;
conflictingAttributes.push_back ("pixelAspectRatio");
}
//
// Timecode
//
const TimeCodeAttribute * srcTimeCode = src.findTypedAttribute<
TimeCodeAttribute> (TimeCodeAttribute::staticTypeName());
const TimeCodeAttribute * dstTimeCode = dst.findTypedAttribute<
TimeCodeAttribute> (TimeCodeAttribute::staticTypeName());
if (dstTimeCode)
{
if ((srcTimeCode && (srcTimeCode->value() != dstTimeCode->value())) ||
(!srcTimeCode))
{
conflict = true;
conflictingAttributes.push_back (TimeCodeAttribute::staticTypeName());
}
}
//
// Chromaticities
//
const ChromaticitiesAttribute * srcChrom = src.findTypedAttribute<
ChromaticitiesAttribute> (ChromaticitiesAttribute::staticTypeName());
const ChromaticitiesAttribute * dstChrom = dst.findTypedAttribute<
ChromaticitiesAttribute> (ChromaticitiesAttribute::staticTypeName());
if (dstChrom)
{
if ( (srcChrom && (srcChrom->value() != dstChrom->value())) ||
(!srcChrom))
{
conflict = true;
conflictingAttributes.push_back (ChromaticitiesAttribute::staticTypeName());
}
}
return conflict;
}
void
MultiPartOutputFile::Data::headerNameUniquenessCheck (const vector<Header> &headers)
{
set<string> names;
for (size_t i = 0; i < headers.size(); i++)
{
if (names.find(headers[i].name()) != names.end())
throw IEX_NAMESPACE::ArgExc ("Each part should have a unique name.");
names.insert(headers[i].name());
}
}
void
MultiPartOutputFile::Data::writeHeadersToFile (const vector<Header> &headers)
{
for (size_t i = 0; i < headers.size(); i++)
{
// (TODO) consider deep files' preview images here.
if (headers[i].type() == TILEDIMAGE)
parts[i]->previewPosition = headers[i].writeTo(*os, true);
else
parts[i]->previewPosition = headers[i].writeTo(*os, false);
}
//
// If a multipart file, write zero-length attribute name to mark the end of all headers.
//
if (headers.size() !=1)
OPENEXR_IMF_INTERNAL_NAMESPACE::Xdr::write <OPENEXR_IMF_INTERNAL_NAMESPACE::StreamIO> (*os, "");
}
void
MultiPartOutputFile::Data::writeChunkTableOffsets (vector<OutputPartData*> &parts)
{
for (size_t i = 0; i < parts.size(); i++)
{
int chunkTableSize = getChunkOffsetTableSize(parts[i]->header,false);
Int64 pos = os->tellp();
if (pos == -1)
IEX_NAMESPACE::throwErrnoExc ("Cannot determine current file position (%T).");
parts[i]->chunkOffsetTablePosition = os->tellp();
//
// Fill in empty data for now. We'll write actual offsets during destruction.
//
for (int j = 0; j < chunkTableSize; j++)
{
Int64 empty = 0;
OPENEXR_IMF_INTERNAL_NAMESPACE::Xdr::write <OPENEXR_IMF_INTERNAL_NAMESPACE::StreamIO> (*os, empty);
}
}
}
OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT