/////////////////////////////////////////////////////////////////////////// // // 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 TiledInputFile // //----------------------------------------------------------------------------- #include <ImfTiledInputFile.h> #include <ImfTileDescriptionAttribute.h> #include <ImfChannelList.h> #include <ImfMisc.h> #include <ImfTiledMisc.h> #include <ImfStdIO.h> #include <ImfCompressor.h> #include "ImathBox.h" #include <ImfXdr.h> #include <ImfConvert.h> #include <ImfVersion.h> #include <ImfTileOffsets.h> #include <ImfThreading.h> #include "IlmThreadPool.h" #include "IlmThreadSemaphore.h" #include "IlmThreadMutex.h" #include "ImathVec.h" #include "Iex.h" #include <string> #include <vector> #include <algorithm> #include <assert.h> namespace Imf { using Imath::Box2i; using Imath::V2i; using std::string; using std::vector; using std::min; using std::max; using IlmThread::Mutex; using IlmThread::Lock; using IlmThread::Semaphore; using IlmThread::Task; using IlmThread::TaskGroup; using IlmThread::ThreadPool; namespace { struct TInSliceInfo { PixelType typeInFrameBuffer; PixelType typeInFile; char * base; size_t xStride; size_t yStride; bool fill; bool skip; double fillValue; int xTileCoords; int yTileCoords; TInSliceInfo (PixelType typeInFrameBuffer = HALF, PixelType typeInFile = HALF, char *base = 0, size_t xStride = 0, size_t yStride = 0, bool fill = false, bool skip = false, double fillValue = 0.0, int xTileCoords = 0, int yTileCoords = 0); }; TInSliceInfo::TInSliceInfo (PixelType tifb, PixelType tifl, char *b, size_t xs, size_t ys, bool f, bool s, double fv, int xtc, int ytc) : typeInFrameBuffer (tifb), typeInFile (tifl), base (b), xStride (xs), yStride (ys), fill (f), skip (s), fillValue (fv), xTileCoords (xtc), yTileCoords (ytc) { // empty } struct TileBuffer { const char * uncompressedData; char * buffer; int dataSize; Compressor * compressor; Compressor::Format format; int dx; int dy; int lx; int ly; bool hasException; string exception; TileBuffer (Compressor * const comp); ~TileBuffer (); inline void wait () {_sem.wait();} inline void post () {_sem.post();} protected: Semaphore _sem; }; TileBuffer::TileBuffer (Compressor *comp): uncompressedData (0), dataSize (0), compressor (comp), format (defaultFormat (compressor)), dx (-1), dy (-1), lx (-1), ly (-1), hasException (false), exception (), _sem (1) { // empty } TileBuffer::~TileBuffer () { delete compressor; } } // namespace // // struct TiledInputFile::Data stores things that will be // needed between calls to readTile() // struct TiledInputFile::Data: public Mutex { Header header; // the image header TileDescription tileDesc; // describes the tile layout int version; // file's version FrameBuffer frameBuffer; // framebuffer to write into LineOrder lineOrder; // the file's lineorder int minX; // data window's min x coord int maxX; // data window's max x coord int minY; // data window's min y coord int maxY; // data window's max x coord int numXLevels; // number of x levels int numYLevels; // number of y levels int * numXTiles; // number of x tiles at a level int * numYTiles; // number of y tiles at a level TileOffsets tileOffsets; // stores offsets in file for // each tile bool fileIsComplete; // True if no tiles are missing // in the file Int64 currentPosition; // file offset for current tile, // used to prevent unnecessary // seeking vector<TInSliceInfo> slices; // info about channels in file IStream * is; // file stream to read from bool deleteStream; // should we delete the stream // ourselves? or does someone // else do it? size_t bytesPerPixel; // size of an uncompressed pixel size_t maxBytesPerTileLine; // combined size of a line // over all channels vector<TileBuffer*> tileBuffers; // each holds a single tile size_t tileBufferSize; // size of the tile buffers Data (bool deleteStream, int numThreads); ~Data (); inline TileBuffer * getTileBuffer (int number); // hash function from tile indices // into our vector of tile buffers }; TiledInputFile::Data::Data (bool del, int numThreads): numXTiles (0), numYTiles (0), is (0), deleteStream (del) { // // We need at least one tileBuffer, but if threading is used, // to keep n threads busy we need 2*n tileBuffers // tileBuffers.resize (max (1, 2 * numThreads)); } TiledInputFile::Data::~Data () { delete [] numXTiles; delete [] numYTiles; if (deleteStream) delete is; for (size_t i = 0; i < tileBuffers.size(); i++) delete tileBuffers[i]; } TileBuffer* TiledInputFile::Data::getTileBuffer (int number) { return tileBuffers[number % tileBuffers.size()]; } namespace { void readTileData (TiledInputFile::Data *ifd, int dx, int dy, int lx, int ly, char *&buffer, int &dataSize) { // // Read a single tile block from the file and into the array pointed // to by buffer. If the file is memory-mapped, then we change where // buffer points instead of writing into the array (hence buffer needs // to be a reference to a char *). // // // Look up the location for this tile in the Index and // seek to that position if necessary // Int64 tileOffset = ifd->tileOffsets (dx, dy, lx, ly); if (tileOffset == 0) { THROW (Iex::InputExc, "Tile (" << dx << ", " << dy << ", " << lx << ", " << ly << ") is missing."); } if (ifd->currentPosition != tileOffset) ifd->is->seekg (tileOffset); // // Read the first few bytes of the tile (the header). // Verify that the tile coordinates and the level number // are correct. // int tileXCoord, tileYCoord, levelX, levelY; Xdr::read <StreamIO> (*ifd->is, tileXCoord); Xdr::read <StreamIO> (*ifd->is, tileYCoord); Xdr::read <StreamIO> (*ifd->is, levelX); Xdr::read <StreamIO> (*ifd->is, levelY); Xdr::read <StreamIO> (*ifd->is, dataSize); if (tileXCoord != dx) throw Iex::InputExc ("Unexpected tile x coordinate."); if (tileYCoord != dy) throw Iex::InputExc ("Unexpected tile y coordinate."); if (levelX != lx) throw Iex::InputExc ("Unexpected tile x level number coordinate."); if (levelY != ly) throw Iex::InputExc ("Unexpected tile y level number coordinate."); if (dataSize > (int) ifd->tileBufferSize) throw Iex::InputExc ("Unexpected tile block length."); // // Read the pixel data. // if (ifd->is->isMemoryMapped ()) buffer = ifd->is->readMemoryMapped (dataSize); else ifd->is->read (buffer, dataSize); // // Keep track of which tile is the next one in // the file, so that we can avoid redundant seekg() // operations (seekg() can be fairly expensive). // ifd->currentPosition = tileOffset + 5 * Xdr::size<int>() + dataSize; } void readNextTileData (TiledInputFile::Data *ifd, int &dx, int &dy, int &lx, int &ly, char * & buffer, int &dataSize) { // // Read the next tile block from the file // // // Read the first few bytes of the tile (the header). // Xdr::read <StreamIO> (*ifd->is, dx); Xdr::read <StreamIO> (*ifd->is, dy); Xdr::read <StreamIO> (*ifd->is, lx); Xdr::read <StreamIO> (*ifd->is, ly); Xdr::read <StreamIO> (*ifd->is, dataSize); if (dataSize > (int) ifd->tileBufferSize) throw Iex::InputExc ("Unexpected tile block length."); // // Read the pixel data. // ifd->is->read (buffer, dataSize); // // Keep track of which tile is the next one in // the file, so that we can avoid redundant seekg() // operations (seekg() can be fairly expensive). // ifd->currentPosition += 5 * Xdr::size<int>() + dataSize; } // // A TileBufferTask encapsulates the task of uncompressing // a single tile and copying it into the frame buffer. // class TileBufferTask : public Task { public: TileBufferTask (TaskGroup *group, TiledInputFile::Data *ifd, TileBuffer *tileBuffer); virtual ~TileBufferTask (); virtual void execute (); private: TiledInputFile::Data * _ifd; TileBuffer * _tileBuffer; }; TileBufferTask::TileBufferTask (TaskGroup *group, TiledInputFile::Data *ifd, TileBuffer *tileBuffer) : Task (group), _ifd (ifd), _tileBuffer (tileBuffer) { // empty } TileBufferTask::~TileBufferTask () { // // Signal that the tile buffer is now free // _tileBuffer->post (); } void TileBufferTask::execute () { try { // // Calculate information about the tile // Box2i tileRange = Imf::dataWindowForTile (_ifd->tileDesc, _ifd->minX, _ifd->maxX, _ifd->minY, _ifd->maxY, _tileBuffer->dx, _tileBuffer->dy, _tileBuffer->lx, _tileBuffer->ly); int numPixelsPerScanLine = tileRange.max.x - tileRange.min.x + 1; int numPixelsInTile = numPixelsPerScanLine * (tileRange.max.y - tileRange.min.y + 1); int sizeOfTile = _ifd->bytesPerPixel * numPixelsInTile; // // Uncompress the data, if necessary // if (_tileBuffer->compressor && _tileBuffer->dataSize < sizeOfTile) { _tileBuffer->format = _tileBuffer->compressor->format(); _tileBuffer->dataSize = _tileBuffer->compressor->uncompressTile (_tileBuffer->buffer, _tileBuffer->dataSize, tileRange, _tileBuffer->uncompressedData); } else { // // If the line is uncompressed, it's in XDR format, // regardless of the compressor's output format. // _tileBuffer->format = Compressor::XDR; _tileBuffer->uncompressedData = _tileBuffer->buffer; } // // Convert the tile of pixel data back from the machine-independent // representation, and store the result in the frame buffer. // const char *readPtr = _tileBuffer->uncompressedData; // points to where we // read from in the // tile block // // Iterate over the scan lines in the tile. // for (int y = tileRange.min.y; y <= tileRange.max.y; ++y) { // // Iterate over all image channels. // for (unsigned int i = 0; i < _ifd->slices.size(); ++i) { const TInSliceInfo &slice = _ifd->slices[i]; // // These offsets are used to facilitate both // absolute and tile-relative pixel coordinates. // int xOffset = slice.xTileCoords * tileRange.min.x; int yOffset = slice.yTileCoords * tileRange.min.y; // // Fill the frame buffer with pixel data. // if (slice.skip) { // // The file contains data for this channel, but // the frame buffer contains no slice for this channel. // skipChannel (readPtr, slice.typeInFile, numPixelsPerScanLine); } else { // // The frame buffer contains a slice for this channel. // char *writePtr = slice.base + (y - yOffset) * slice.yStride + (tileRange.min.x - xOffset) * slice.xStride; char *endPtr = writePtr + (numPixelsPerScanLine - 1) * slice.xStride; copyIntoFrameBuffer (readPtr, writePtr, endPtr, slice.xStride, slice.fill, slice.fillValue, _tileBuffer->format, slice.typeInFrameBuffer, slice.typeInFile); } } } } catch (std::exception &e) { if (!_tileBuffer->hasException) { _tileBuffer->exception = e.what (); _tileBuffer->hasException = true; } } catch (...) { if (!_tileBuffer->hasException) { _tileBuffer->exception = "unrecognized exception"; _tileBuffer->hasException = true; } } } TileBufferTask * newTileBufferTask (TaskGroup *group, TiledInputFile::Data *ifd, int number, int dx, int dy, int lx, int ly) { // // Wait for a tile buffer to become available, // fill the buffer with raw data from the file, // and create a new TileBufferTask whose execute() // method will uncompress the tile and copy the // tile's pixels into the frame buffer. // TileBuffer *tileBuffer = ifd->getTileBuffer (number); try { tileBuffer->wait(); tileBuffer->dx = dx; tileBuffer->dy = dy; tileBuffer->lx = lx; tileBuffer->ly = ly; tileBuffer->uncompressedData = 0; readTileData (ifd, dx, dy, lx, ly, tileBuffer->buffer, tileBuffer->dataSize); } catch (...) { // // Reading from the file caused an exception. // Signal that the tile buffer is free, and // re-throw the exception. // tileBuffer->post(); throw; } return new TileBufferTask (group, ifd, tileBuffer); } } // namespace TiledInputFile::TiledInputFile (const char fileName[], int numThreads): _data (new Data (true, numThreads)) { // // This constructor is called when a user // explicitly wants to read a tiled file. // try { _data->is = new StdIFStream (fileName); _data->header.readFrom (*_data->is, _data->version); initialize(); } catch (Iex::BaseExc &e) { delete _data; REPLACE_EXC (e, "Cannot open image file " "\"" << fileName << "\". " << e); throw; } catch (...) { delete _data; throw; } } TiledInputFile::TiledInputFile (IStream &is, int numThreads): _data (new Data (false, numThreads)) { // // This constructor is called when a user // explicitly wants to read a tiled file. // try { _data->is = &is; _data->header.readFrom (*_data->is, _data->version); initialize(); } catch (Iex::BaseExc &e) { delete _data; REPLACE_EXC (e, "Cannot open image file " "\"" << is.fileName() << "\". " << e); throw; } catch (...) { delete _data; throw; } } TiledInputFile::TiledInputFile (const Header &header, IStream *is, int version, int numThreads) : _data (new Data (false, numThreads)) { // // This constructor called by class Imf::InputFile // when a user wants to just read an image file, and // doesn't care or know if the file is tiled. // _data->is = is; _data->header = header; _data->version = version; initialize(); } void TiledInputFile::initialize () { if (!isTiled (_data->version)) throw Iex::ArgExc ("Expected a tiled file but the file is not tiled."); _data->header.sanityCheck (true); _data->tileDesc = _data->header.tileDescription(); _data->lineOrder = _data->header.lineOrder(); // // Save the dataWindow information // const Box2i &dataWindow = _data->header.dataWindow(); _data->minX = dataWindow.min.x; _data->maxX = dataWindow.max.x; _data->minY = dataWindow.min.y; _data->maxY = dataWindow.max.y; // // Precompute level and tile information to speed up utility functions // precalculateTileInfo (_data->tileDesc, _data->minX, _data->maxX, _data->minY, _data->maxY, _data->numXTiles, _data->numYTiles, _data->numXLevels, _data->numYLevels); _data->bytesPerPixel = calculateBytesPerPixel (_data->header); _data->maxBytesPerTileLine = _data->bytesPerPixel * _data->tileDesc.xSize; _data->tileBufferSize = _data->maxBytesPerTileLine * _data->tileDesc.ySize; // // Create all the TileBuffers and allocate their internal buffers // for (size_t i = 0; i < _data->tileBuffers.size(); i++) { _data->tileBuffers[i] = new TileBuffer (newTileCompressor (_data->header.compression(), _data->maxBytesPerTileLine, _data->tileDesc.ySize, _data->header)); if (!_data->is->isMemoryMapped ()) _data->tileBuffers[i]->buffer = new char [_data->tileBufferSize]; } _data->tileOffsets = TileOffsets (_data->tileDesc.mode, _data->numXLevels, _data->numYLevels, _data->numXTiles, _data->numYTiles); _data->tileOffsets.readFrom (*(_data->is), _data->fileIsComplete); _data->currentPosition = _data->is->tellg(); } TiledInputFile::~TiledInputFile () { if (!_data->is->isMemoryMapped()) for (size_t i = 0; i < _data->tileBuffers.size(); i++) delete [] _data->tileBuffers[i]->buffer; delete _data; } const char * TiledInputFile::fileName () const { return _data->is->fileName(); } const Header & TiledInputFile::header () const { return _data->header; } int TiledInputFile::version () const { return _data->version; } void TiledInputFile::setFrameBuffer (const FrameBuffer &frameBuffer) { Lock lock (*_data); // // Set the frame buffer // // // Check if the new frame buffer descriptor is // compatible with the image file header. // const ChannelList &channels = _data->header.channels(); for (FrameBuffer::ConstIterator j = frameBuffer.begin(); j != frameBuffer.end(); ++j) { ChannelList::ConstIterator i = channels.find (j.name()); if (i == channels.end()) continue; if (i.channel().xSampling != j.slice().xSampling || i.channel().ySampling != j.slice().ySampling) THROW (Iex::ArgExc, "X and/or y subsampling factors " "of \"" << i.name() << "\" channel " "of input file \"" << fileName() << "\" are " "not compatible with the frame buffer's " "subsampling factors."); } // // Initialize the slice table for readPixels(). // vector<TInSliceInfo> slices; ChannelList::ConstIterator i = channels.begin(); for (FrameBuffer::ConstIterator j = frameBuffer.begin(); j != frameBuffer.end(); ++j) { while (i != channels.end() && strcmp (i.name(), j.name()) < 0) { // // Channel i is present in the file but not // in the frame buffer; data for channel i // will be skipped during readPixels(). // slices.push_back (TInSliceInfo (i.channel().type, i.channel().type, 0, // base 0, // xStride 0, // yStride false, // fill true, // skip 0.0)); // fillValue ++i; } bool fill = false; if (i == channels.end() || strcmp (i.name(), j.name()) > 0) { // // Channel i is present in the frame buffer, but not in the file. // In the frame buffer, slice j will be filled with a default value. // fill = true; } slices.push_back (TInSliceInfo (j.slice().type, fill? j.slice().type: i.channel().type, j.slice().base, j.slice().xStride, j.slice().yStride, fill, false, // skip j.slice().fillValue, (j.slice().xTileCoords)? 1: 0, (j.slice().yTileCoords)? 1: 0)); if (i != channels.end() && !fill) ++i; } while (i != channels.end()) { // // Channel i is present in the file but not // in the frame buffer; data for channel i // will be skipped during readPixels(). // slices.push_back (TInSliceInfo (i.channel().type, i.channel().type, 0, // base 0, // xStride 0, // yStride false, // fill true, // skip 0.0)); // fillValue ++i; } // // Store the new frame buffer. // _data->frameBuffer = frameBuffer; _data->slices = slices; } const FrameBuffer & TiledInputFile::frameBuffer () const { Lock lock (*_data); return _data->frameBuffer; } bool TiledInputFile::isComplete () const { return _data->fileIsComplete; } void TiledInputFile::readTiles (int dx1, int dx2, int dy1, int dy2, int lx, int ly) { // // Read a range of tiles from the file into the framebuffer // try { Lock lock (*_data); if (_data->slices.size() == 0) throw Iex::ArgExc ("No frame buffer specified " "as pixel data destination."); // // Determine the first and last tile coordinates in both dimensions. // We always attempt to read the range of tiles in the order that // they are stored in the file. // if (dx1 > dx2) std::swap (dx1, dx2); if (dy1 > dy2) std::swap (dy1, dy2); int dyStart = dy1; int dyStop = dy2 + 1; int dY = 1; if (_data->lineOrder == DECREASING_Y) { dyStart = dy2; dyStop = dy1 - 1; dY = -1; } // // Create a task group for all tile buffer tasks. When the // task group goes out of scope, the destructor waits until // all tasks are complete. // { TaskGroup taskGroup; int tileNumber = 0; for (int dy = dyStart; dy != dyStop; dy += dY) { for (int dx = dx1; dx <= dx2; dx++) { if (!isValidTile (dx, dy, lx, ly)) THROW (Iex::ArgExc, "Tile (" << dx << ", " << dy << ", " << lx << "," << ly << ") is not a valid tile."); ThreadPool::addGlobalTask (newTileBufferTask (&taskGroup, _data, tileNumber++, dx, dy, lx, ly)); } } // // finish all tasks // } // // Exeption handling: // // TileBufferTask::execute() may have encountered exceptions, but // those exceptions occurred in another thread, not in the thread // that is executing this call to TiledInputFile::readTiles(). // TileBufferTask::execute() has caught all exceptions and stored // the exceptions' what() strings in the tile buffers. // Now we check if any tile buffer contains a stored exception; if // this is the case then we re-throw the exception in this thread. // (It is possible that multiple tile buffers contain stored // exceptions. We re-throw the first exception we find and // ignore all others.) // const string *exception = 0; for (int i = 0; i < _data->tileBuffers.size(); ++i) { TileBuffer *tileBuffer = _data->tileBuffers[i]; if (tileBuffer->hasException && !exception) exception = &tileBuffer->exception; tileBuffer->hasException = false; } if (exception) throw Iex::IoExc (*exception); } catch (Iex::BaseExc &e) { REPLACE_EXC (e, "Error reading pixel data from image " "file \"" << fileName() << "\". " << e); throw; } } void TiledInputFile::readTiles (int dx1, int dx2, int dy1, int dy2, int l) { readTiles (dx1, dx2, dy1, dy2, l, l); } void TiledInputFile::readTile (int dx, int dy, int lx, int ly) { readTiles (dx, dx, dy, dy, lx, ly); } void TiledInputFile::readTile (int dx, int dy, int l) { readTile (dx, dy, l, l); } void TiledInputFile::rawTileData (int &dx, int &dy, int &lx, int &ly, const char *&pixelData, int &pixelDataSize) { try { Lock lock (*_data); if (!isValidTile (dx, dy, lx, ly)) throw Iex::ArgExc ("Tried to read a tile outside " "the image file's data window."); TileBuffer *tileBuffer = _data->getTileBuffer (0); readNextTileData (_data, dx, dy, lx, ly, tileBuffer->buffer, pixelDataSize); pixelData = tileBuffer->buffer; } catch (Iex::BaseExc &e) { REPLACE_EXC (e, "Error reading pixel data from image " "file \"" << fileName() << "\". " << e); throw; } } unsigned int TiledInputFile::tileXSize () const { return _data->tileDesc.xSize; } unsigned int TiledInputFile::tileYSize () const { return _data->tileDesc.ySize; } LevelMode TiledInputFile::levelMode () const { return _data->tileDesc.mode; } LevelRoundingMode TiledInputFile::levelRoundingMode () const { return _data->tileDesc.roundingMode; } int TiledInputFile::numLevels () const { if (levelMode() == RIPMAP_LEVELS) THROW (Iex::LogicExc, "Error calling numLevels() on image " "file \"" << fileName() << "\" " "(numLevels() is not defined for files " "with RIPMAP level mode)."); return _data->numXLevels; } int TiledInputFile::numXLevels () const { return _data->numXLevels; } int TiledInputFile::numYLevels () const { return _data->numYLevels; } bool TiledInputFile::isValidLevel (int lx, int ly) const { if (lx < 0 || ly < 0) return false; if (levelMode() == MIPMAP_LEVELS && lx != ly) return false; if (lx >= numXLevels() || ly >= numYLevels()) return false; return true; } int TiledInputFile::levelWidth (int lx) const { try { return levelSize (_data->minX, _data->maxX, lx, _data->tileDesc.roundingMode); } catch (Iex::BaseExc &e) { REPLACE_EXC (e, "Error calling levelWidth() on image " "file \"" << fileName() << "\". " << e); throw; } } int TiledInputFile::levelHeight (int ly) const { try { return levelSize (_data->minY, _data->maxY, ly, _data->tileDesc.roundingMode); } catch (Iex::BaseExc &e) { REPLACE_EXC (e, "Error calling levelHeight() on image " "file \"" << fileName() << "\". " << e); throw; } } int TiledInputFile::numXTiles (int lx) const { if (lx < 0 || lx >= _data->numXLevels) { THROW (Iex::ArgExc, "Error calling numXTiles() on image " "file \"" << _data->is->fileName() << "\" " "(Argument is not in valid range)."); } return _data->numXTiles[lx]; } int TiledInputFile::numYTiles (int ly) const { if (ly < 0 || ly >= _data->numYLevels) { THROW (Iex::ArgExc, "Error calling numYTiles() on image " "file \"" << _data->is->fileName() << "\" " "(Argument is not in valid range)."); } return _data->numYTiles[ly]; } Box2i TiledInputFile::dataWindowForLevel (int l) const { return dataWindowForLevel (l, l); } Box2i TiledInputFile::dataWindowForLevel (int lx, int ly) const { try { return Imf::dataWindowForLevel (_data->tileDesc, _data->minX, _data->maxX, _data->minY, _data->maxY, lx, ly); } catch (Iex::BaseExc &e) { REPLACE_EXC (e, "Error calling dataWindowForLevel() on image " "file \"" << fileName() << "\". " << e); throw; } } Box2i TiledInputFile::dataWindowForTile (int dx, int dy, int l) const { return dataWindowForTile (dx, dy, l, l); } Box2i TiledInputFile::dataWindowForTile (int dx, int dy, int lx, int ly) const { try { if (!isValidTile (dx, dy, lx, ly)) throw Iex::ArgExc ("Arguments not in valid range."); return Imf::dataWindowForTile (_data->tileDesc, _data->minX, _data->maxX, _data->minY, _data->maxY, dx, dy, lx, ly); } catch (Iex::BaseExc &e) { REPLACE_EXC (e, "Error calling dataWindowForTile() on image " "file \"" << fileName() << "\". " << e); throw; } } bool TiledInputFile::isValidTile (int dx, int dy, int lx, int ly) const { return ((lx < _data->numXLevels && lx >= 0) && (ly < _data->numYLevels && ly >= 0) && (dx < _data->numXTiles[lx] && dx >= 0) && (dy < _data->numYTiles[ly] && dy >= 0)); } } // namespace Imf