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

//

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

//

//-----------------------------------------------------------------------------

#include "ImfInputFile.h"

#include "ImfScanLineInputFile.h"

#include "ImfTiledInputFile.h"

#include "ImfChannelList.h"

#include "ImfMisc.h"

#include "ImfStdIO.h"

#include "ImfVersion.h"

#include "ImfPartType.h"

#include "ImfInputPartData.h"

#include "ImfMultiPartInputFile.h"

#include <ImfCompositeDeepScanLine.h>

#include <ImfDeepScanLineInputFile.h>

#include "ImathFun.h"

#include "IlmThreadMutex.h"

#include "Iex.h"

#include "half.h"

#include <fstream>

#include <algorithm>

#include "ImfNamespace.h"

OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER

using IMATH_NAMESPACE::Box2i;

using IMATH_NAMESPACE::divp;

using IMATH_NAMESPACE::modp;

using ILMTHREAD_NAMESPACE::Mutex;

using ILMTHREAD_NAMESPACE::Lock;

//

// Struct InputFile::Data stores things that will be

// needed between calls to readPixels

//

struct InputFile::Data : public Mutex

{

    Header              header;

    int                 version;

    bool                isTiled;

    TiledInputFile *	tFile;

    ScanLineInputFile *	sFile;

    DeepScanLineInputFile * dsFile;

    LineOrder		lineOrder;      // the file's lineorder

    int			minY;           // data window's min y coord

    int			maxY;           // data window's max x coord

    FrameBuffer		tFileBuffer; 

    FrameBuffer *	cachedBuffer;

    CompositeDeepScanLine * compositor; // for loading deep files

    int			cachedTileY;

    int                 offset;

    int                 numThreads;

    int                 partNumber;

    InputPartData*      part;

    bool                multiPartBackwardSupport;

    MultiPartInputFile* multiPartFile;

    InputStreamMutex    * _streamData;

    bool                _deleteStream;

     Data (int numThreads);

    ~Data ();

    void		deleteCachedBuffer();

};

InputFile::Data::Data (int numThreads):

    isTiled (false),

    tFile (0),

    sFile (0),

    dsFile(0),

    cachedBuffer (0),

    compositor(0),

    cachedTileY (-1),

    numThreads (numThreads),

    partNumber (-1),

    part(NULL),

    multiPartBackwardSupport (false),

    multiPartFile (0),

    _streamData(0),

    _deleteStream(false)

{

    // empty

}

InputFile::Data::~Data ()

{

    if (tFile)

        delete tFile;

    if (sFile)

        delete sFile;

    if (dsFile)

        delete dsFile;

    if (compositor)

        delete compositor;

    deleteCachedBuffer();

    if (multiPartBackwardSupport && multiPartFile)

        delete multiPartFile;

}

void	

InputFile::Data::deleteCachedBuffer()

{

    //

    // Delete the cached frame buffer, and all memory

    // allocated for the slices in the cached frameBuffer.

    //

    if (cachedBuffer)

    {

	for (FrameBuffer::Iterator k = cachedBuffer->begin();

	     k != cachedBuffer->end();

	     ++k)

	{

	    Slice &s = k.slice();

	    switch (s.type)

	    {

	      case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT:

		delete [] (((unsigned int *)s.base) + offset);

		break;

	      case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF:

		delete [] ((half *)s.base + offset);

		break;

	      case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT:

		delete [] (((float *)s.base) + offset);

		break;

              case NUM_PIXELTYPES :

                  throw(IEX_NAMESPACE::ArgExc("Invalid pixel type"));

	    }                

	}

	//

	// delete the cached frame buffer

	//

	delete cachedBuffer;

	cachedBuffer = 0;

    }

}

namespace {

void

bufferedReadPixels (InputFile::Data* ifd, int scanLine1, int scanLine2)

{

    //

    // bufferedReadPixels reads each row of tiles that intersect the

    // scan-line range (scanLine1 to scanLine2). The previous row of

    // tiles is cached in order to prevent redundent tile reads when

    // accessing scanlines sequentially.

    //

    int minY = std::min (scanLine1, scanLine2);

    int maxY = std::max (scanLine1, scanLine2);

    if (minY < ifd->minY || maxY >  ifd->maxY)

    {

        throw IEX_NAMESPACE::ArgExc ("Tried to read scan line outside "

			   "the image file's data window.");

    }

    //

    // The minimum and maximum y tile coordinates that intersect this

    // scanline range

    //

    int minDy = (minY - ifd->minY) / ifd->tFile->tileYSize();

    int maxDy = (maxY - ifd->minY) / ifd->tFile->tileYSize();

    //

    // Figure out which one is first in the file so we can read without seeking

    //

    int yStart, yEnd, yStep;

    if (ifd->lineOrder == DECREASING_Y)

    {

        yStart = maxDy;

        yEnd = minDy - 1;

        yStep = -1;

    }

    else

    {

        yStart = minDy;

        yEnd = maxDy + 1;

        yStep = 1;

    }

    //

    // the number of pixels in a row of tiles

    //

    Box2i levelRange = ifd->tFile->dataWindowForLevel(0);

    //

    // Read the tiles into our temporary framebuffer and copy them into

    // the user's buffer

    //

    for (int j = yStart; j != yEnd; j += yStep)

    {

        Box2i tileRange = ifd->tFile->dataWindowForTile (0, j, 0);

        int minYThisRow = std::max (minY, tileRange.min.y);

        int maxYThisRow = std::min (maxY, tileRange.max.y);

        if (j != ifd->cachedTileY)

        {

            //

            // We don't have any valid buffered info, so we need to read in

            // from the file.

            //

            ifd->tFile->readTiles (0, ifd->tFile->numXTiles (0) - 1, j, j);

            ifd->cachedTileY = j;

        }

        //

        // Copy the data from our cached framebuffer into the user's

        // framebuffer.

        //

        for (FrameBuffer::ConstIterator k = ifd->cachedBuffer->begin();

             k != ifd->cachedBuffer->end();

             ++k)

        {

            Slice fromSlice = k.slice();		// slice to write from

            Slice toSlice = ifd->tFileBuffer[k.name()];	// slice to write to

            char *fromPtr, *toPtr;

            int size = pixelTypeSize (toSlice.type);

	    int xStart = levelRange.min.x;

	    int yStart = minYThisRow;

	    while (modp (xStart, toSlice.xSampling) != 0)

		++xStart;

	    while (modp (yStart, toSlice.ySampling) != 0)

		++yStart;

            for (int y = yStart;

		 y <= maxYThisRow;

		 y += toSlice.ySampling)

            {

		//

                // Set the pointers to the start of the y scanline in

                // this row of tiles

		//

                fromPtr = fromSlice.base +

                          (y - tileRange.min.y) * fromSlice.yStride +

                          xStart * fromSlice.xStride;

                toPtr = toSlice.base +

                        divp (y, toSlice.ySampling) * toSlice.yStride +

                        divp (xStart, toSlice.xSampling) * toSlice.xStride;

		//

                // Copy all pixels for the scanline in this row of tiles

		//

                for (int x = xStart;

		     x <= levelRange.max.x;

		     x += toSlice.xSampling)

                {

		    for (int i = 0; i < size; ++i)

			toPtr[i] = fromPtr[i];

		    fromPtr += fromSlice.xStride * toSlice.xSampling;

		    toPtr += toSlice.xStride;

                }

            }

        }

    }

}

} // namespace

InputFile::InputFile (const char fileName[], int numThreads):

    _data (new Data (numThreads))

{

    _data->_streamData = NULL;

    _data->_deleteStream=true;

    OPENEXR_IMF_INTERNAL_NAMESPACE::IStream* is = 0;

    try

    {

        is = new StdIFStream (fileName);

        readMagicNumberAndVersionField(*is, _data->version);

        //

        // compatibility to read multipart file.

        //

        if (isMultiPart(_data->version))

        {

            compatibilityInitialize(*is);

        }

        else

        {

            _data->_streamData = new InputStreamMutex();

            _data->_streamData->is = is;

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

            // fix type attribute in single part regular image types

            // (may be wrong if an old version of OpenEXR converts

            // a tiled image to scanline or vice versa)

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

               !isMultiPart(_data->version) && 

               _data->header.hasType())

            {

                _data->header.setType(isTiled(_data->version) ? TILEDIMAGE : SCANLINEIMAGE);

            }

            _data->header.sanityCheck (isTiled (_data->version));

            initialize();

        }

    }

    catch (IEX_NAMESPACE::BaseExc &e)

    {

        if (is)          delete is;

        if ( _data && !_data->multiPartBackwardSupport  && _data->_streamData)

        {

            delete _data->_streamData;

            _data->_streamData=NULL;

        }

        if (_data)       delete _data;

        _data=NULL;

        REPLACE_EXC (e, "Cannot read image file "

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

        throw;

    }

    catch (...)

    {

        if (is)          delete is;

        if (_data && !_data->multiPartBackwardSupport && _data->_streamData)

        {

            delete _data->_streamData;

        }

        if (_data)       delete _data;

        throw;

    }

}

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

    _data (new Data (numThreads))

{

    _data->_streamData=NULL;

    _data->_deleteStream=false;

    try

    {

        readMagicNumberAndVersionField(is, _data->version);

        //

        // Backward compatibility to read multpart file.

        //

        if (isMultiPart(_data->version))

        {

            compatibilityInitialize(is);

        }

        else

        {

            _data->_streamData = new InputStreamMutex();

            _data->_streamData->is = &is;

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

            // fix type attribute in single part regular image types

            // (may be wrong if an old version of OpenEXR converts

            // a tiled image to scanline or vice versa)

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

               !isMultiPart(_data->version) &&  

               _data->header.hasType())

            {

                _data->header.setType(isTiled(_data->version) ? TILEDIMAGE : SCANLINEIMAGE);

            }

            _data->header.sanityCheck (isTiled (_data->version));

            initialize();

        }

    }

    catch (IEX_NAMESPACE::BaseExc &e)

    {

        if (_data && !_data->multiPartBackwardSupport && _data->_streamData) delete _data->_streamData;

        if (_data)       delete _data;

        _data=NULL; 

        REPLACE_EXC (e, "Cannot read image file "

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

        throw;

    }

    catch (...)

    {

        if (_data &&  !_data->multiPartBackwardSupport  && _data->_streamData) delete _data->_streamData;

        if (_data)       delete _data;

        _data=NULL;

        throw;

    }

}

InputFile::InputFile (InputPartData* part) :

    _data (new Data (part->numThreads))

{

    _data->_deleteStream=false;

    multiPartInitialize (part);

}

void

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

{

    is.seekg(0);

    //

    // Construct a MultiPartInputFile, initialize InputFile

    // with the part 0 data.

    // (TODO) may want to have a way to set the reconstruction flag.

    //

    _data->multiPartBackwardSupport = true;

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

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

    multiPartInitialize (part);

}

void

InputFile::multiPartInitialize (InputPartData* part)

{

    _data->_streamData = part->mutex;

    _data->version = part->version;

    _data->header = part->header;

    _data->partNumber = part->partNumber;

    _data->part = part;

    initialize();

}

void

InputFile::initialize ()

{

    if (!_data->part)

    {

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

        {

            _data->isTiled=false;

            const Box2i &dataWindow = _data->header.dataWindow();

            _data->minY = dataWindow.min.y;

            _data->maxY = dataWindow.max.y;

            _data->dsFile = new DeepScanLineInputFile (_data->header,

                                               _data->_streamData->is,

                                               _data->version,

                                               _data->numThreads);

            _data->compositor = new CompositeDeepScanLine;

            _data->compositor->addSource(_data->dsFile);

        }

        else if (isTiled (_data->version))

        {

            _data->isTiled = true;

            _data->lineOrder = _data->header.lineOrder();

            //

            // Save the dataWindow information

            //

            const Box2i &dataWindow = _data->header.dataWindow();

            _data->minY = dataWindow.min.y;

            _data->maxY = dataWindow.max.y;

            _data->tFile = new TiledInputFile (_data->header,

                                               _data->_streamData->is,

                                               _data->version,

                                               _data->numThreads);

        }

        else if(!_data->header.hasType() || _data->header.type()==SCANLINEIMAGE)

        {

            _data->sFile = new ScanLineInputFile (_data->header,

                                                  _data->_streamData->is,

                                                  _data->numThreads);

        }else{

            // type set but not recognised

            THROW(IEX_NAMESPACE::ArgExc, "InputFile cannot handle parts of type " << _data->header.type());

        }

    }

    else

    {

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

        {

            _data->isTiled=false;

            const Box2i &dataWindow = _data->header.dataWindow();

            _data->minY = dataWindow.min.y;

            _data->maxY = dataWindow.max.y;

            _data->dsFile = new DeepScanLineInputFile (_data->part);

            _data->compositor = new CompositeDeepScanLine;

            _data->compositor->addSource(_data->dsFile);

        }

        else if (isTiled (_data->header.type()))

        {

            _data->isTiled = true;

            _data->lineOrder = _data->header.lineOrder();

            //

            // Save the dataWindow information

            //

            const Box2i &dataWindow = _data->header.dataWindow();

            _data->minY = dataWindow.min.y;

            _data->maxY = dataWindow.max.y;

            _data->tFile = new TiledInputFile (_data->part);

        }

        else if(!_data->header.hasType() || _data->header.type()==SCANLINEIMAGE)

        {

            _data->sFile = new ScanLineInputFile (_data->part);

        }else{

            THROW(IEX_NAMESPACE::ArgExc, "InputFile cannot handle parts of type " << _data->header.type());

        }

    }

}

#include <iostream>

InputFile::~InputFile ()

{

    if (_data->_deleteStream)

        delete _data->_streamData->is;

    // unless this file was opened via the multipart API,

    // delete the streamData object too

    if (_data->partNumber==-1 && _data->_streamData)

        delete _data->_streamData;

    if (_data)  delete _data;

}

const char *

InputFile::fileName () const

{

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

}

const Header &

InputFile::header () const

{

    return _data->header;

}

int

InputFile::version () const

{

    return _data->version;

}

void

InputFile::setFrameBuffer (const FrameBuffer &frameBuffer)

{

    if (_data->isTiled)

    {

	Lock lock (*_data);

	//

        // We must invalidate the cached buffer if the new frame

	// buffer has a different set of channels than the old

	// frame buffer, or if the type of a channel has changed.

	//

	const FrameBuffer &oldFrameBuffer = _data->tFileBuffer;

	FrameBuffer::ConstIterator i = oldFrameBuffer.begin();

	FrameBuffer::ConstIterator j = frameBuffer.begin();

	while (i != oldFrameBuffer.end() && j != frameBuffer.end())

	{

	    if (strcmp (i.name(), j.name()) || i.slice().type != j.slice().type)

		break;

	    ++i;

	    ++j;

	}

	if (i != oldFrameBuffer.end() || j != frameBuffer.end())

        {

	    //

	    // Invalidate the cached buffer.

	    //

            _data->deleteCachedBuffer ();

	    _data->cachedTileY = -1;

	    //

	    // Create new a cached frame buffer.  It can hold a single

	    // row of tiles.  The cached buffer can be reused for each

	    // row of tiles because we set the yTileCoords parameter of

	    // each Slice to true.

	    //

	    const Box2i &dataWindow = _data->header.dataWindow();

	    _data->cachedBuffer = new FrameBuffer();

	    _data->offset = dataWindow.min.x;

	    int tileRowSize = (dataWindow.max.x - dataWindow.min.x + 1) *

			      _data->tFile->tileYSize();

	    for (FrameBuffer::ConstIterator k = frameBuffer.begin();

		 k != frameBuffer.end();

		 ++k)

	    {

		Slice s = k.slice();

		switch (s.type)

		{

		  case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT:

		    _data->cachedBuffer->insert

			(k.name(),

			 Slice (UINT,

				(char *)(new unsigned int[tileRowSize] - 

					_data->offset),

				sizeof (unsigned int),

				sizeof (unsigned int) *

				    _data->tFile->levelWidth(0),

				1, 1,

				s.fillValue,

				false, true));

		    break;

		  case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF:

		    _data->cachedBuffer->insert

			(k.name(),

			 Slice (HALF,

				(char *)(new half[tileRowSize] - 

					_data->offset),

				sizeof (half),

				sizeof (half) *

				    _data->tFile->levelWidth(0),

				1, 1,

				s.fillValue,

				false, true));

		    break;

		  case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT:

		    _data->cachedBuffer->insert

			(k.name(),

			 Slice (OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT,

				(char *)(new float[tileRowSize] - 

					_data->offset),

				sizeof(float),

				sizeof(float) *

				    _data->tFile->levelWidth(0),

				1, 1,

				s.fillValue,

				false, true));

		    break;

		  default:

		    throw IEX_NAMESPACE::ArgExc ("Unknown pixel data type.");

		}

	    }

	    _data->tFile->setFrameBuffer (*_data->cachedBuffer);

        }

	_data->tFileBuffer = frameBuffer;

    }

    else if(_data->compositor)

    {

        _data->compositor->setFrameBuffer(frameBuffer);

    }else {

        _data->sFile->setFrameBuffer(frameBuffer);

        _data->tFileBuffer = frameBuffer;

    }

}

const FrameBuffer &

InputFile::frameBuffer () const

{

    if(_data->compositor)

    {

        return _data->compositor->frameBuffer();

    }

    else if(_data->isTiled)

    {

	Lock lock (*_data);

	return _data->tFileBuffer;

    }

    else

    {

	return _data->sFile->frameBuffer();

    }

}

bool

InputFile::isComplete () const

{

    if (_data->dsFile)

        return _data->dsFile->isComplete();

    else if (_data->isTiled)

	return _data->tFile->isComplete();

    else

	return _data->sFile->isComplete();

}

bool

InputFile::isOptimizationEnabled() const

{

   if(_data->sFile)

   {

       return _data->sFile->isOptimizationEnabled();

   }else{

       return false;

   }

}

void

InputFile::readPixels (int scanLine1, int scanLine2)

{

    if (_data->compositor)

    {

        _data->compositor->readPixels(scanLine1,scanLine2);

    }

    else if (_data->isTiled)

    {

	Lock lock (*_data);

        bufferedReadPixels (_data, scanLine1, scanLine2);

    }

    else

    {

        _data->sFile->readPixels (scanLine1, scanLine2);

    }

}

void

InputFile::readPixels (int scanLine)

{

    readPixels (scanLine, scanLine);

}

void

InputFile::rawPixelData (int firstScanLine,

			 const char *&pixelData,

			 int &pixelDataSize)

{

    try

    {

        if (_data->dsFile)

        {

            throw IEX_NAMESPACE::ArgExc ("Tried to read a raw scanline "

            "from a deep image.");

        }

	else if (_data->isTiled)

	{

	    throw IEX_NAMESPACE::ArgExc ("Tried to read a raw scanline "

			       "from a tiled image.");

	}

        _data->sFile->rawPixelData (firstScanLine, pixelData, pixelDataSize);

    }

    catch (IEX_NAMESPACE::BaseExc &e)

    {

	REPLACE_EXC (e, "Error reading pixel data from image "

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

	throw;

    }

}

void

InputFile::rawTileData (int &dx, int &dy,

			int &lx, int &ly,

			const char *&pixelData,

			int &pixelDataSize)

{

    try

    {

	if (!_data->isTiled)

	{

	    throw IEX_NAMESPACE::ArgExc ("Tried to read a raw tile "

			       "from a scanline-based image.");

	}

        _data->tFile->rawTileData (dx, dy, lx, ly, pixelData, pixelDataSize);

    }

    catch (IEX_NAMESPACE::BaseExc &e)

    {

	REPLACE_EXC (e, "Error reading tile data from image "

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

	throw;

    }

}