///////////////////////////////////////////////////////////////////////////

//

// 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 "ImfXdr.h"

#include "ImfConvert.h"

#include "ImfVersion.h"

#include "ImfTileOffsets.h"

#include "ImfThreading.h"

#include "ImfPartType.h"

#include "ImfMultiPartInputFile.h"

#include "ImfInputStreamMutex.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>

#include "ImfInputPartData.h"

#include "ImfNamespace.h"

OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER

using IMATH_NAMESPACE::Box2i;

using IMATH_NAMESPACE::V2i;

using std::string;

using std::vector;

using std::min;

using std::max;

using ILMTHREAD_NAMESPACE::Mutex;

using ILMTHREAD_NAMESPACE::Lock;

using ILMTHREAD_NAMESPACE::Semaphore;

using ILMTHREAD_NAMESPACE::Task;

using ILMTHREAD_NAMESPACE::TaskGroup;

using ILMTHREAD_NAMESPACE::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),

    buffer (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

class MultiPartInputFile;

//

// 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

    vector<TInSliceInfo> slices;              // info about channels in file

    size_t      bytesPerPixel;                  // size of an uncompressed pixel

    size_t      maxBytesPerTileLine;            // combined size of a line

                                                    // over all channels

    int             partNumber;                     // part number

    bool            multiPartBackwardSupport;       // if we are reading a multipart file

                                                    // using OpenEXR 1.7 API

    int             numThreads;                     // number of threads

    MultiPartInputFile* multiPartFile;              // the MultiPartInputFile used to

                                                    // support backward compatibility

    vector<TileBuffer*> tileBuffers;                // each holds a single tile

    size_t          tileBufferSize;             // size of the tile buffers

    bool            memoryMapped;                   // if the stream is memory mapped

    InputStreamMutex * _streamData;

    bool                _deleteStream;

     Data (int numThreads);

    ~Data ();

    inline TileBuffer * getTileBuffer (int number);

              // hash function from tile indices

              // into our vector of tile buffers

};

TiledInputFile::Data::Data (int numThreads):

    numXTiles (0),

    numYTiles (0),

    partNumber (-1),

    multiPartBackwardSupport(false),

    numThreads(numThreads),

    memoryMapped(false),

    _streamData(NULL),

    _deleteStream(false)

{

    //

    // 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;

    for (size_t i = 0; i < tileBuffers.size(); i++)

        delete tileBuffers[i];

    if (multiPartBackwardSupport)

        delete multiPartFile;

}

TileBuffer*

TiledInputFile::Data::getTileBuffer (int number)

{

    return tileBuffers[number % tileBuffers.size()];

}

namespace {

void

readTileData (InputStreamMutex *streamData,

              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_NAMESPACE::InputExc, "Tile (" << dx << ", " << dy << ", " <<

            lx << ", " << ly << ") is missing.");

    }

    //

    // In a multi-part file, the next chunk does not need to

    // belong to the same part, so we have to compare the

    // offset here.

    //

    if (!isMultiPart(ifd->version))

    {

        if (streamData->currentPosition != tileOffset)

            streamData->is->seekg (tileOffset);

    }

    else

    {

        //

        // In a multi-part file, the file pointer may be moved by other

        // parts, so we have to ask tellg() where we are.

        //

        if (streamData->is->tellg() != tileOffset)

            streamData->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;

    if (isMultiPart(ifd->version))

    {

        int partNumber;

        Xdr::read <StreamIO> (*streamData->is, partNumber);

        if (partNumber != ifd->partNumber)

        {

            THROW (IEX_NAMESPACE::ArgExc, "Unexpected part number " << partNumber

                   << ", should be " << ifd->partNumber << ".");

        }

    }

    OPENEXR_IMF_INTERNAL_NAMESPACE::Xdr::read <OPENEXR_IMF_INTERNAL_NAMESPACE::StreamIO> (*streamData->is, tileXCoord);

    OPENEXR_IMF_INTERNAL_NAMESPACE::Xdr::read <OPENEXR_IMF_INTERNAL_NAMESPACE::StreamIO> (*streamData->is, tileYCoord);

    OPENEXR_IMF_INTERNAL_NAMESPACE::Xdr::read <OPENEXR_IMF_INTERNAL_NAMESPACE::StreamIO> (*streamData->is, levelX);

    OPENEXR_IMF_INTERNAL_NAMESPACE::Xdr::read <OPENEXR_IMF_INTERNAL_NAMESPACE::StreamIO> (*streamData->is, levelY);

    OPENEXR_IMF_INTERNAL_NAMESPACE::Xdr::read <OPENEXR_IMF_INTERNAL_NAMESPACE::StreamIO> (*streamData->is, dataSize);

    if (tileXCoord != dx)

        throw IEX_NAMESPACE::InputExc ("Unexpected tile x coordinate.");

    if (tileYCoord != dy)

        throw IEX_NAMESPACE::InputExc ("Unexpected tile y coordinate.");

    if (levelX != lx)

        throw IEX_NAMESPACE::InputExc ("Unexpected tile x level number coordinate.");

    if (levelY != ly)

        throw IEX_NAMESPACE::InputExc ("Unexpected tile y level number coordinate.");

    if (dataSize > (int) ifd->tileBufferSize)

        throw IEX_NAMESPACE::InputExc ("Unexpected tile block length.");

    //

    // Read the pixel data.

    //

    if (streamData->is->isMemoryMapped ())

        buffer = streamData->is->readMemoryMapped (dataSize);

    else

        streamData->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).

    //

    streamData->currentPosition = tileOffset + 5 * Xdr::size<int>() + dataSize;

}

void

readNextTileData (InputStreamMutex *streamData,

                  TiledInputFile::Data *ifd,

      int &dx, int &dy,

      int &lx, int &ly,

                  char * & buffer,

      int &dataSize)

{

    //

    // Read the next tile block from the file

    //

    if(isMultiPart(ifd->version))

    {

        int part;

        Xdr::read <StreamIO> (*streamData->is, part);

        if(part!=ifd->partNumber)

        {

           throw IEX_NAMESPACE::InputExc("Unexpected part number in readNextTileData");

        }

    }

    //

    // Read the first few bytes of the tile (the header).

    //

    Xdr::read <StreamIO> (*streamData->is, dx);

    Xdr::read <StreamIO> (*streamData->is, dy);

    Xdr::read <StreamIO> (*streamData->is, lx);

    Xdr::read <StreamIO> (*streamData->is, ly);

    Xdr::read <StreamIO> (*streamData->is, dataSize);

    if (dataSize > (int) ifd->tileBufferSize)

        throw IEX_NAMESPACE::InputExc ("Unexpected tile block length.");

    //

    // Read the pixel data.

    //

    streamData->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).

    //

    streamData->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 =  OPENEXR_IMF_INTERNAL_NAMESPACE::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,

     InputStreamMutex *streamData,

     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 (streamData, 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 (numThreads))

{

    _data->_streamData=NULL;

    _data->_deleteStream=true;

    //

    // This constructor is called when a user

    // explicitly wants to read a tiled file.

    //

    IStream* is = 0;

    try

    {

        is = new StdIFStream (fileName);

  readMagicNumberAndVersionField(*is, _data->version);

  //

        // Backward compatibility to read multpart file.

        //

  if (isMultiPart(_data->version))

  {

      compatibilityInitialize(*is);

      return;

  }

  _data->_streamData = new InputStreamMutex();

  _data->_streamData->is = is;

  _data->header.readFrom (*_data->_streamData->is, _data->version);

  initialize();

        //read tile offsets - we are not multipart or deep

        _data->tileOffsets.readFrom (*(_data->_streamData->is), _data->fileIsComplete,false,false);

  _data->_streamData->currentPosition = _data->_streamData->is->tellg();

    }

    catch (IEX_NAMESPACE::BaseExc &e)

    {

        if (_data->_streamData != 0)

        {

            if (_data->_streamData->is != 0)

            {

                delete _data->_streamData->is;

                _data->_streamData->is = is = 0;

            }

            delete _data->_streamData;

        }

        if (is != 0)

            delete is;

  REPLACE_EXC (e, "Cannot open image file "

      "\"" << fileName << "\". " << e);

  throw;

    }

    catch (...)

    {

        if ( _data->_streamData != 0)

        {

            if ( _data->_streamData->is != 0)

            {

                delete _data->_streamData->is;

                _data->_streamData->is = is = 0;

            }

            delete _data->_streamData;

        }

        if (is != 0)

            delete is;

        throw;

    }

}

TiledInputFile::TiledInputFile (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &is, int numThreads):

    _data (new Data (numThreads))

{

    _data->_deleteStream=false;

    //

    // This constructor is called when a user

    // explicitly wants to read a tiled file.

    //

    bool streamDataCreated = false;

    try

    {

  readMagicNumberAndVersionField(is, _data->version);

  //

  // Backward compatibility to read multpart file.

  //

  if (isMultiPart(_data->version))

        {

      compatibilityInitialize(is);

            return;

        }

  streamDataCreated = true;

  _data->_streamData = new InputStreamMutex();

  _data->_streamData->is = &is;

  _data->header.readFrom (*_data->_streamData->is, _data->version);

  initialize();

        // file is guaranteed to be single part, regular image

        _data->tileOffsets.readFrom (*(_data->_streamData->is), _data->fileIsComplete,false,false);

  _data->memoryMapped = _data->_streamData->is->isMemoryMapped();

  _data->_streamData->currentPosition = _data->_streamData->is->tellg();

    }

    catch (IEX_NAMESPACE::BaseExc &e)

    {

        if (streamDataCreated) delete _data->_streamData;

  delete _data;

  REPLACE_EXC (e, "Cannot open image file "

      "\"" << is.fileName() << "\". " << e);

  throw;

    }

    catch (...)

    {

        if (streamDataCreated) delete _data->_streamData;

  delete _data;

        throw;

    }

}

TiledInputFile::TiledInputFile (const Header &header,

                                OPENEXR_IMF_INTERNAL_NAMESPACE::IStream *is,

                                int version,

                                int numThreads) :

    _data (new Data (numThreads))

{

    _data->_deleteStream=false;

    _data->_streamData = new InputStreamMutex();

    //

    // 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.

    // No need to have backward compatibility here, because

    // we have somehow got the header.

    //

    _data->_streamData->is = is;

    _data->header = header;

    _data->version = version;

    initialize();

    _data->tileOffsets.readFrom (*(_data->_streamData->is),_data->fileIsComplete,false,false);

    _data->memoryMapped = is->isMemoryMapped();

    _data->_streamData->currentPosition = _data->_streamData->is->tellg();

}

TiledInputFile::TiledInputFile (InputPartData* part) 

{

    _data = new Data (part->numThreads);

    _data->_deleteStream=false;

    multiPartInitialize(part);

}

void

TiledInputFile::compatibilityInitialize(OPENEXR_IMF_INTERNAL_NAMESPACE::IStream& is)

{

    is.seekg(0);

    //

    // Construct a MultiPartInputFile, initialize TiledInputFile

    // with the part 0 data.

    // (TODO) maybe change the third parameter of the constructor of MultiPartInputFile later.

    //

    _data->multiPartBackwardSupport = true;

    _data->multiPartFile = new MultiPartInputFile(is, _data->numThreads);

    InputPartData* part = _data->multiPartFile->getPart(0);

    multiPartInitialize(part);

}

void

TiledInputFile::multiPartInitialize(InputPartData* part)

{

    if (part->header.type() != TILEDIMAGE)

        throw IEX_NAMESPACE::ArgExc("Can't build a TiledInputFile from a type-mismatched part.");

    _data->_streamData = part->mutex;

    _data->header = part->header;

    _data->version = part->version;

    _data->partNumber = part->partNumber;

    _data->memoryMapped = _data->_streamData->is->isMemoryMapped();

    initialize();

    _data->tileOffsets.readFrom(part->chunkOffsets,_data->fileIsComplete);

    _data->_streamData->currentPosition = _data->_streamData->is->tellg();

}

void

TiledInputFile::initialize ()

{

    // fix bad types in header (arises when a tool built against an older version of

    // OpenEXR converts a scanline image to tiled)

    // only applies when file is a single part, regular image, tiled file

    //

    if(!isMultiPart(_data->version) &&

       !isNonImage(_data->version) && 

       isTiled(_data->version) && 

       _data->header.hasType() )

    {

        _data->header.setType(TILEDIMAGE);

    }

    if (_data->partNumber == -1)

    {

        if (!isTiled (_data->version))

            throw IEX_NAMESPACE::ArgExc ("Expected a tiled file but the file is not tiled.");

    }

    else

    {

        if(_data->header.hasType() && _data->header.type()!=TILEDIMAGE)

        {

            throw IEX_NAMESPACE::ArgExc ("TiledInputFile used for non-tiledimage part.");

        }

    }

    _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->_streamData->is->isMemoryMapped ())

            _data->tileBuffers[i]->buffer = new char [_data->tileBufferSize];

    }

    _data->tileOffsets = TileOffsets (_data->tileDesc.mode,

              _data->numXLevels,

              _data->numYLevels,

              _data->numXTiles,

              _data->numYTiles);

}

TiledInputFile::~TiledInputFile ()

{

    if (!_data->memoryMapped)

        for (size_t i = 0; i < _data->tileBuffers.size(); i++)

            delete [] _data->tileBuffers[i]->buffer;

    if (_data->_deleteStream)

        delete _data->_streamData->is;

    if (_data->partNumber == -1)

        delete _data->_streamData;

    delete _data;

}

const char *

TiledInputFile::fileName () const

{

    return _data->_streamData->is->fileName();