/////////////////////////////////////////////////////////////////////////// // // 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 TileOffsets // //----------------------------------------------------------------------------- #include <ImfTileOffsets.h> #include <ImfXdr.h> #include <ImfIO.h> #include "Iex.h" #include "ImfNamespace.h" #include <algorithm> OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER TileOffsets::TileOffsets (LevelMode mode, int numXLevels, int numYLevels, const int *numXTiles, const int *numYTiles) : _mode (mode), _numXLevels (numXLevels), _numYLevels (numYLevels) { switch (_mode) { case ONE_LEVEL: case MIPMAP_LEVELS: _offsets.resize (_numXLevels); for (unsigned int l = 0; l < _offsets.size(); ++l) { _offsets[l].resize (numYTiles[l]); for (unsigned int dy = 0; dy < _offsets[l].size(); ++dy) { _offsets[l][dy].resize (numXTiles[l]); } } break; case RIPMAP_LEVELS: _offsets.resize (_numXLevels * _numYLevels); for (int ly = 0; ly < _numYLevels; ++ly) { for (int lx = 0; lx < _numXLevels; ++lx) { int l = ly * _numXLevels + lx; _offsets[l].resize (numYTiles[ly]); for (size_t dy = 0; dy < _offsets[l].size(); ++dy) { _offsets[l][dy].resize (numXTiles[lx]); } } } break; case NUM_LEVELMODES : throw IEX_NAMESPACE::ArgExc("Bad initialisation of TileOffsets object"); } } bool TileOffsets::anyOffsetsAreInvalid () const { for (unsigned int l = 0; l < _offsets.size(); ++l) for (unsigned int dy = 0; dy < _offsets[l].size(); ++dy) for (unsigned int dx = 0; dx < _offsets[l][dy].size(); ++dx) if (_offsets[l][dy][dx] <= 0) return true; return false; } void TileOffsets::findTiles (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &is, bool isMultiPartFile, bool isDeep, bool skipOnly) { for (unsigned int l = 0; l < _offsets.size(); ++l) { for (unsigned int dy = 0; dy < _offsets[l].size(); ++dy) { for (unsigned int dx = 0; dx < _offsets[l][dy].size(); ++dx) { Int64 tileOffset = is.tellg(); if (isMultiPartFile) { int partNumber; OPENEXR_IMF_INTERNAL_NAMESPACE::Xdr::read <OPENEXR_IMF_INTERNAL_NAMESPACE::StreamIO> (is, partNumber); } int tileX; OPENEXR_IMF_INTERNAL_NAMESPACE::Xdr::read <OPENEXR_IMF_INTERNAL_NAMESPACE::StreamIO> (is, tileX); int tileY; OPENEXR_IMF_INTERNAL_NAMESPACE::Xdr::read <OPENEXR_IMF_INTERNAL_NAMESPACE::StreamIO> (is, tileY); int levelX; OPENEXR_IMF_INTERNAL_NAMESPACE::Xdr::read <OPENEXR_IMF_INTERNAL_NAMESPACE::StreamIO> (is, levelX); int levelY; OPENEXR_IMF_INTERNAL_NAMESPACE::Xdr::read <OPENEXR_IMF_INTERNAL_NAMESPACE::StreamIO> (is, levelY); if(isDeep) { Int64 packed_offset_table_size; Int64 packed_sample_size; OPENEXR_IMF_INTERNAL_NAMESPACE::Xdr::read <OPENEXR_IMF_INTERNAL_NAMESPACE::StreamIO> (is, packed_offset_table_size); OPENEXR_IMF_INTERNAL_NAMESPACE::Xdr::read <OPENEXR_IMF_INTERNAL_NAMESPACE::StreamIO> (is, packed_sample_size); // next Int64 is unpacked sample size - skip that too Xdr::skip <StreamIO> (is, packed_offset_table_size+packed_sample_size+8); }else{ int dataSize; OPENEXR_IMF_INTERNAL_NAMESPACE::Xdr::read <OPENEXR_IMF_INTERNAL_NAMESPACE::StreamIO> (is, dataSize); Xdr::skip <StreamIO> (is, dataSize); } if (skipOnly) continue; if (!isValidTile(tileX, tileY, levelX, levelY)) return; operator () (tileX, tileY, levelX, levelY) = tileOffset; } } } } void TileOffsets::reconstructFromFile (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &is,bool isMultiPart,bool isDeep) { // // Try to reconstruct a missing tile offset table by sequentially // scanning through the file, and recording the offsets in the file // of the tiles we find. // Int64 position = is.tellg(); try { findTiles (is,isMultiPart,isDeep,false); } catch (...) { // // Suppress all exceptions. This function is called only to // reconstruct the tile offset table for incomplete files, // and exceptions are likely. // } is.clear(); is.seekg (position); } void TileOffsets::readFrom (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &is, bool &complete,bool isMultiPartFile, bool isDeep) { // // Read in the tile offsets from the file's tile offset table // for (unsigned int l = 0; l < _offsets.size(); ++l) for (unsigned int dy = 0; dy < _offsets[l].size(); ++dy) for (unsigned int dx = 0; dx < _offsets[l][dy].size(); ++dx) OPENEXR_IMF_INTERNAL_NAMESPACE::Xdr::read <OPENEXR_IMF_INTERNAL_NAMESPACE::StreamIO> (is, _offsets[l][dy][dx]); // // Check if any tile offsets are invalid. // // Invalid offsets mean that the file is probably incomplete // (the offset table is the last thing written to the file). // Either some process is still busy writing the file, or // writing the file was aborted. // // We should still be able to read the existing parts of the // file. In order to do this, we have to make a sequential // scan over the scan tile to reconstruct the tile offset // table. // if (anyOffsetsAreInvalid()) { complete = false; reconstructFromFile (is,isMultiPartFile,isDeep); } else { complete = true; } } void TileOffsets::readFrom (std::vector<Int64> chunkOffsets,bool &complete) { size_t totalSize = 0; for (unsigned int l = 0; l < _offsets.size(); ++l) for (unsigned int dy = 0; dy < _offsets[l].size(); ++dy) totalSize += _offsets[l][dy].size(); if (chunkOffsets.size() != totalSize) throw IEX_NAMESPACE::ArgExc ("Wrong offset count, not able to read from this array"); int pos = 0; for (size_t l = 0; l < _offsets.size(); ++l) for (size_t dy = 0; dy < _offsets[l].size(); ++dy) for (size_t dx = 0; dx < _offsets[l][dy].size(); ++dx) { _offsets[l][dy][dx] = chunkOffsets[pos]; pos++; } complete = !anyOffsetsAreInvalid(); } Int64 TileOffsets::writeTo (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &os) const { // // Write the tile offset table to the file, and // return the position of the start of the table // in the file. // Int64 pos = os.tellp(); if (pos == -1) IEX_NAMESPACE::throwErrnoExc ("Cannot determine current file position (%T)."); for (unsigned int l = 0; l < _offsets.size(); ++l) for (unsigned int dy = 0; dy < _offsets[l].size(); ++dy) for (unsigned int dx = 0; dx < _offsets[l][dy].size(); ++dx) OPENEXR_IMF_INTERNAL_NAMESPACE::Xdr::write <OPENEXR_IMF_INTERNAL_NAMESPACE::StreamIO> (os, _offsets[l][dy][dx]); return pos; } namespace { struct tilepos{ Int64 filePos; int dx; int dy; int l; bool operator <(const tilepos & other) const { return filePos < other.filePos; } }; } //------------------------------------- // fill array with tile coordinates in the order they appear in the file // // each input array must be of size (totalTiles) // // // if the tile order is not RANDOM_Y, it is more efficient to compute the // tile ordering rather than using this function // //------------------------------------- void TileOffsets::getTileOrder(int dx_table[],int dy_table[],int lx_table[],int ly_table[]) const { // // helper class // // how many entries? size_t entries=0; for (unsigned int l = 0; l < _offsets.size(); ++l) for (unsigned int dy = 0; dy < _offsets[l].size(); ++dy) entries+=_offsets[l][dy].size(); std::vector<struct tilepos> table(entries); size_t i = 0; for (unsigned int l = 0; l < _offsets.size(); ++l) for (unsigned int dy = 0; dy < _offsets[l].size(); ++dy) for (unsigned int dx = 0; dx < _offsets[l][dy].size(); ++dx) { table[i].filePos = _offsets[l][dy][dx]; table[i].dx = dx; table[i].dy = dy; table[i].l = l; ++i; } std::sort(table.begin(),table.end()); // // write out the values // // pass 1: write out dx and dy, since these are independent of level mode for(size_t i=0;i<entries;i++) { dx_table[i] = table[i].dx; dy_table[i] = table[i].dy; } // now write out the levels, which depend on the level mode switch (_mode) { case ONE_LEVEL: { for(size_t i=0;i<entries;i++) { lx_table[i] = 0; ly_table[i] = 0; } break; } case MIPMAP_LEVELS: { for(size_t i=0;i<entries;i++) { lx_table[i]= table[i].l; ly_table[i] =table[i].l; } break; } case RIPMAP_LEVELS: { for(size_t i=0;i<entries;i++) { lx_table[i]= table[i].l % _numXLevels; ly_table[i] = table[i].l / _numXLevels; } break; } case NUM_LEVELMODES : throw IEX_NAMESPACE::LogicExc("Bad level mode getting tile order"); } } bool TileOffsets::isEmpty () const { for (unsigned int l = 0; l < _offsets.size(); ++l) for (unsigned int dy = 0; dy < _offsets[l].size(); ++dy) for (unsigned int dx = 0; dx < _offsets[l][dy].size(); ++dx) if (_offsets[l][dy][dx] != 0) return false; return true; } bool TileOffsets::isValidTile (int dx, int dy, int lx, int ly) const { if(lx<0 || ly < 0 || dx<0 || dy < 0) return false; switch (_mode) { case ONE_LEVEL: if (lx == 0 && ly == 0 && _offsets.size() > 0 && int(_offsets[0].size()) > dy && int(_offsets[0][dy].size()) > dx) { return true; } break; case MIPMAP_LEVELS: if (lx < _numXLevels && ly < _numYLevels && int(_offsets.size()) > lx && int(_offsets[lx].size()) > dy && int(_offsets[lx][dy].size()) > dx) { return true; } break; case RIPMAP_LEVELS: if (lx < _numXLevels && ly < _numYLevels && (_offsets.size() > (size_t) lx+ ly * (size_t) _numXLevels) && int(_offsets[lx + ly * _numXLevels].size()) > dy && int(_offsets[lx + ly * _numXLevels][dy].size()) > dx) { return true; } break; default: return false; } return false; } Int64 & TileOffsets::operator () (int dx, int dy, int lx, int ly) { // // Looks up the value of the tile with tile coordinate (dx, dy) // and level number (lx, ly) in the _offsets array, and returns // the cooresponding offset. // switch (_mode) { case ONE_LEVEL: return _offsets[0][dy][dx]; break; case MIPMAP_LEVELS: return _offsets[lx][dy][dx]; break; case RIPMAP_LEVELS: return _offsets[lx + ly * _numXLevels][dy][dx]; break; default: throw IEX_NAMESPACE::ArgExc ("Unknown LevelMode format."); } } Int64 & TileOffsets::operator () (int dx, int dy, int l) { return operator () (dx, dy, l, l); } const Int64 & TileOffsets::operator () (int dx, int dy, int lx, int ly) const { // // Looks up the value of the tile with tile coordinate (dx, dy) // and level number (lx, ly) in the _offsets array, and returns // the cooresponding offset. // switch (_mode) { case ONE_LEVEL: return _offsets[0][dy][dx]; break; case MIPMAP_LEVELS: return _offsets[lx][dy][dx]; break; case RIPMAP_LEVELS: return _offsets[lx + ly * _numXLevels][dy][dx]; break; default: throw IEX_NAMESPACE::ArgExc ("Unknown LevelMode format."); } } const Int64 & TileOffsets::operator () (int dx, int dy, int l) const { return operator () (dx, dy, l, l); } const std::vector<std::vector<std::vector <Int64> > >& TileOffsets::getOffsets() const { return _offsets; } OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT