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

//

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

//

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

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

//

//	Miscellaneous helper functions for OpenEXR image file I/O

//

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

#include <ImfMisc.h>

#include <ImfHeader.h>

#include <ImfAttribute.h>

#include <ImfCompressor.h>

#include <ImfChannelList.h>

#include <ImfXdr.h>

#include <ImathFun.h>

#include <Iex.h>

#include <ImfStdIO.h>

#include <ImfConvert.h>

#include <ImfPartType.h>

#include <ImfTileDescription.h>

#include "ImfNamespace.h"

OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER

using IMATH_NAMESPACE::Box2i;

using IMATH_NAMESPACE::divp;

using IMATH_NAMESPACE::modp;

using std::vector;

int

pixelTypeSize (PixelType type)

{

    int size;

    switch (type)

    {

      case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT:

	size = Xdr::size <unsigned int> ();

	break;

      case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF:

	size = Xdr::size <half> ();

	break;

      case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT:

	size = Xdr::size <float> ();

	break;

      default:

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

    }

    return size;

}

int

numSamples (int s, int a, int b)

{

    int a1 = divp (a, s);

    int b1 = divp (b, s);

    return  b1 - a1 + ((a1 * s < a)? 0: 1);

}

size_t

bytesPerLineTable (const Header &header,

		   vector<size_t> &bytesPerLine)

{

    const Box2i &dataWindow = header.dataWindow();

    const ChannelList &channels = header.channels();

    bytesPerLine.resize (dataWindow.max.y - dataWindow.min.y + 1);

    for (ChannelList::ConstIterator c = channels.begin();

	 c != channels.end();

	 ++c)

    {

	int nBytes = pixelTypeSize (c.channel().type) *

		     (dataWindow.max.x - dataWindow.min.x + 1) /

		     c.channel().xSampling;

	for (int y = dataWindow.min.y, i = 0; y <= dataWindow.max.y; ++y, ++i)

	    if (modp (y, c.channel().ySampling) == 0)

		bytesPerLine[i] += nBytes;

    }

    size_t maxBytesPerLine = 0;

    for (int y = dataWindow.min.y, i = 0; y <= dataWindow.max.y; ++y, ++i)

	if (maxBytesPerLine < bytesPerLine[i])

	    maxBytesPerLine = bytesPerLine[i];

    return maxBytesPerLine;

}

const int&

sampleCount(const char* base, int xStride, int yStride, int x, int y)

{

    const char* ptr = base + y * yStride + x * xStride;

    int* intPtr = (int*) ptr;

    return *intPtr;

}

int&

sampleCount(char* base, int xStride, int yStride, int x, int y)

{

    char* ptr = base + y * yStride + x * xStride;

    int* intPtr = (int*) ptr;

    return *intPtr;

}

size_t

bytesPerDeepLineTable (const Header &header,

                       int minY, int maxY,

                       const char* base,

                       int xStride,

                       int yStride,

                       vector<size_t> &bytesPerLine)

{

    const Box2i &dataWindow = header.dataWindow();

    const ChannelList &channels = header.channels();

    for (ChannelList::ConstIterator c = channels.begin();

         c != channels.end();

         ++c)

    {

        for (int y = minY; y <= maxY; ++y)

            if (modp (y, c.channel().ySampling) == 0)

            {

                int nBytes = 0;

                for (int x = dataWindow.min.x; x <= dataWindow.max.x; x++)

                {

                    if (modp (x, c.channel().xSampling) == 0)

                        nBytes += pixelTypeSize (c.channel().type) *

                                  sampleCount(base, xStride, yStride, x, y);

                }

                bytesPerLine[y - dataWindow.min.y] += nBytes;

            }

    }

    size_t maxBytesPerLine = 0;

    for (int y = minY; y <= maxY; ++y)

        if (maxBytesPerLine < bytesPerLine[y - dataWindow.min.y])

            maxBytesPerLine = bytesPerLine[y - dataWindow.min.y];

    return maxBytesPerLine;

}

size_t

bytesPerDeepLineTable (const Header &header,

                       char* base,

                       int xStride,

                       int yStride,

                       vector<size_t> &bytesPerLine)

{

    return bytesPerDeepLineTable(header,

                                 header.dataWindow().min.y,

                                 header.dataWindow().max.y,

                                 base,

                                 xStride,

                                 yStride,

                                 bytesPerLine);

}

void

offsetInLineBufferTable (const vector<size_t> &bytesPerLine,

                         int scanline1, int scanline2,

                         int linesInLineBuffer,

                         vector<size_t> &offsetInLineBuffer)

{

    offsetInLineBuffer.resize (bytesPerLine.size());

    size_t offset = 0;

    for (int i = scanline1; i <= scanline2; ++i)

    {

        if (i % linesInLineBuffer == 0)

            offset = 0;

        offsetInLineBuffer[i] = offset;

        offset += bytesPerLine[i];

    }

}

void

offsetInLineBufferTable (const vector<size_t> &bytesPerLine,

			 int linesInLineBuffer,

			 vector<size_t> &offsetInLineBuffer)

{

    offsetInLineBufferTable (bytesPerLine,

                             0, bytesPerLine.size() - 1,

                             linesInLineBuffer,

                             offsetInLineBuffer);

}

int

lineBufferMinY (int y, int minY, int linesInLineBuffer)

{

    return ((y - minY) / linesInLineBuffer) * linesInLineBuffer + minY;

}

int

lineBufferMaxY (int y, int minY, int linesInLineBuffer)

{

    return lineBufferMinY (y, minY, linesInLineBuffer) + linesInLineBuffer - 1;

}

Compressor::Format

defaultFormat (Compressor * compressor)

{

    return compressor? compressor->format(): Compressor::XDR;

}

int

numLinesInBuffer (Compressor * compressor)

{

    return compressor? compressor->numScanLines(): 1;

}

void

copyIntoFrameBuffer (const char *& readPtr,

		     char * writePtr,

		     char * endPtr,

                     size_t xStride,

		     bool fill,

		     double fillValue,

                     Compressor::Format format,

                     PixelType typeInFrameBuffer,

                     PixelType typeInFile)

{

    //

    // Copy a horizontal row of pixels from an input

    // file's line or tile buffer to a frame buffer.

    //

    if (fill)

    {

        //

        // The file contains no data for this channel.

        // Store a default value in the frame buffer.

        //

        switch (typeInFrameBuffer)

        {

	  case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT:

            {

                unsigned int fillVal = (unsigned int) (fillValue);

                while (writePtr <= endPtr)

                {

                    *(unsigned int *) writePtr = fillVal;

                    writePtr += xStride;

                }

            }

            break;

          case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF:

            {

                half fillVal = half (fillValue);

                while (writePtr <= endPtr)

                {

                    *(half *) writePtr = fillVal;

                    writePtr += xStride;

                }

            }

            break;

          case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT:

            {

                float fillVal = float (fillValue);

                while (writePtr <= endPtr)

                {

                    *(float *) writePtr = fillVal;

                    writePtr += xStride;

                }

            }

            break;

          default:

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

        }

    }

    else if (format == Compressor::XDR)

    {

        //

        // The the line or tile buffer is in XDR format.

        //

        // Convert the pixels from the file's machine-

        // independent representation, and store the

        // results in the frame buffer.

        //

        switch (typeInFrameBuffer)

        {

          case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT:

            switch (typeInFile)

            {

              case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT:

                while (writePtr <= endPtr)

                {

                    Xdr::read <CharPtrIO> (readPtr, *(unsigned int *) writePtr);

                    writePtr += xStride;

                }

                break;

              case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF:

                while (writePtr <= endPtr)

                {

                    half h;

                    Xdr::read <CharPtrIO> (readPtr, h);

                    *(unsigned int *) writePtr = halfToUint (h);

                    writePtr += xStride;

                }

                break;

              case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT:

                while (writePtr <= endPtr)

                {

                    float f;

                    Xdr::read <CharPtrIO> (readPtr, f);

                    *(unsigned int *)writePtr = floatToUint (f);

                    writePtr += xStride;

                }

                break;

              default:                  

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

            }

            break;

          case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF:

            switch (typeInFile)

            {

              case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT:

                while (writePtr <= endPtr)

                {

                    unsigned int ui;

                    Xdr::read <CharPtrIO> (readPtr, ui);

                    *(half *) writePtr = uintToHalf (ui);

                    writePtr += xStride;

                }

                break;

              case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF:

                while (writePtr <= endPtr)

                {

                    Xdr::read <CharPtrIO> (readPtr, *(half *) writePtr);

                    writePtr += xStride;

                }

                break;

              case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT:

                while (writePtr <= endPtr)

                {

                    float f;

                    Xdr::read <CharPtrIO> (readPtr, f);

                    *(half *) writePtr = floatToHalf (f);

                    writePtr += xStride;

                }

                break;

              default:

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

            }

            break;

          case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT:

            switch (typeInFile)

            {

              case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT:

                while (writePtr <= endPtr)

                {

                    unsigned int ui;

                    Xdr::read <CharPtrIO> (readPtr, ui);

                    *(float *) writePtr = float (ui);

                    writePtr += xStride;

                }

                break;

              case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF:

                while (writePtr <= endPtr)

                {

                    half h;

                    Xdr::read <CharPtrIO> (readPtr, h);

                    *(float *) writePtr = float (h);

                    writePtr += xStride;

                }

                break;

              case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT:

                while (writePtr <= endPtr)

                {

                    Xdr::read <CharPtrIO> (readPtr, *(float *) writePtr);

                    writePtr += xStride;

                }

                break;

              default:

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

            }

            break;

          default:

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

        }

    }

    else

    {

        //

        // The the line or tile buffer is in NATIVE format.

        // Copy the results into the frame buffer.

        //

        switch (typeInFrameBuffer)

        {

          case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT:

            switch (typeInFile)

            {

              case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT:

                while (writePtr <= endPtr)

                {

                    for (size_t i = 0; i < sizeof (unsigned int); ++i)

                        writePtr[i] = readPtr[i];

                    readPtr += sizeof (unsigned int);

                    writePtr += xStride;

                }

                break;

              case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF:

                while (writePtr <= endPtr)

                {

                    half h = *(half *) readPtr;

                    *(unsigned int *) writePtr = halfToUint (h);

                    readPtr += sizeof (half);

                    writePtr += xStride;

                }

                break;

              case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT:

                while (writePtr <= endPtr)

                {

                    float f;

                    for (size_t i = 0; i < sizeof (float); ++i)

                        ((char *)&f)[i] = readPtr[i];

                    *(unsigned int *)writePtr = floatToUint (f);

                    readPtr += sizeof (float);

                    writePtr += xStride;

                }

                break;

              default:

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

            }

            break;

          case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF:

            switch (typeInFile)

            {

              case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT:

                while (writePtr <= endPtr)

                {

                    unsigned int ui;

                    for (size_t i = 0; i < sizeof (unsigned int); ++i)

                        ((char *)&ui)[i] = readPtr[i];

                    *(half *) writePtr = uintToHalf (ui);

                    readPtr += sizeof (unsigned int);

                    writePtr += xStride;

                }

                break;

              case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF:

                // If we're tightly packed, just memcpy

                if (xStride == sizeof(half)) {

                    int numBytes = endPtr-writePtr+sizeof(half);

                    memcpy(writePtr, readPtr, numBytes);

                    readPtr  += numBytes;

                    writePtr += numBytes;                    

                } else {

                    while (writePtr <= endPtr)

                    {

                        *(half *) writePtr = *(half *)readPtr;

                        readPtr += sizeof (half);

                        writePtr += xStride;

                    }

                }

                break;

              case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT:

                while (writePtr <= endPtr)

                {

                    float f;

                    for (size_t i = 0; i < sizeof (float); ++i)

                        ((char *)&f)[i] = readPtr[i];

                    *(half *) writePtr = floatToHalf (f);

                    readPtr += sizeof (float);

                    writePtr += xStride;

                }

                break;

              default:

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

            }

            break;

          case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT:

            switch (typeInFile)

            {

              case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT:

                while (writePtr <= endPtr)

                {

                    unsigned int ui;

                    for (size_t i = 0; i < sizeof (unsigned int); ++i)

                        ((char *)&ui)[i] = readPtr[i];

                    *(float *) writePtr = float (ui);

                    readPtr += sizeof (unsigned int);

                    writePtr += xStride;

                }

                break;

              case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF:

                while (writePtr <= endPtr)

                {

                    half h = *(half *) readPtr;

                    *(float *) writePtr = float (h);

                    readPtr += sizeof (half);

                    writePtr += xStride;

                }

                break;

              case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT:

                while (writePtr <= endPtr)

                {

                    for (size_t i = 0; i < sizeof (float); ++i)

                        writePtr[i] = readPtr[i];

                    readPtr += sizeof (float);

                    writePtr += xStride;

                }

                break;

              default:

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

            }

            break;

          default:

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

        }

    }

}

void

copyIntoDeepFrameBuffer (const char *& readPtr,

                         char * base,

                         const char* sampleCountBase,

                         ptrdiff_t sampleCountXStride,

                         ptrdiff_t sampleCountYStride,

                         int y, int minX, int maxX,

                         int xOffsetForSampleCount,

                         int yOffsetForSampleCount,

                         int xOffsetForData,

                         int yOffsetForData,

                         ptrdiff_t sampleStride,

                         ptrdiff_t xPointerStride,

                         ptrdiff_t yPointerStride,

                         bool fill,

                         double fillValue,

                         Compressor::Format format,

                         PixelType typeInFrameBuffer,

                         PixelType typeInFile)

{

    //

    // Copy a horizontal row of pixels from an input

    // file's line or tile buffer to a frame buffer.

    //

    if (fill)

    {

        //

        // The file contains no data for this channel.

        // Store a default value in the frame buffer.

        //

        switch (typeInFrameBuffer)

        {

          case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT:

            {

                unsigned int fillVal = (unsigned int) (fillValue);

                for (int x = minX; x <= maxX; x++)

                {

                    char* writePtr = *(char **)(base+(y-yOffsetForData)*yPointerStride + (x-xOffsetForData)*xPointerStride);

                    if(writePtr)

                    {

                        int count = sampleCount(sampleCountBase,

                                                sampleCountXStride,

                                                sampleCountYStride,

                                                x - xOffsetForSampleCount,

                                                y - yOffsetForSampleCount);

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

                        {

                            *(unsigned int *) writePtr = fillVal;

                            writePtr += sampleStride;

                        }

                    }

                }

            }

            break;

          case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF:

            {

                half fillVal = half (fillValue);

                for (int x = minX; x <= maxX; x++)

                {

                    char* writePtr = *(char **)(base+(y-yOffsetForData)*yPointerStride + (x-xOffsetForData)*xPointerStride);

                    if(writePtr)

                    {                            

                        int count = sampleCount(sampleCountBase,

                                                sampleCountXStride,

                                                sampleCountYStride,

                                                x - xOffsetForSampleCount,

                                                y - yOffsetForSampleCount);

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

                        {

                            *(half *) writePtr = fillVal;

                           writePtr += sampleStride;

                       }

                    }

                }

            }

            break;

          case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT:

            {

                float fillVal = float (fillValue);

                for (int x = minX; x <= maxX; x++)

                {

                    char* writePtr = *(char **)(base+(y-yOffsetForData)*yPointerStride + (x-xOffsetForData)*xPointerStride);

                    if(writePtr)

                    {

                        int count = sampleCount(sampleCountBase,

                                                sampleCountXStride,

                                                sampleCountYStride,

                                                x - xOffsetForSampleCount,

                                                y - yOffsetForSampleCount);

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

                        {

                            *(float *) writePtr = fillVal;

                            writePtr += sampleStride;

                        }

                    }

                }

            }

            break;

          default:

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

        }

    }

    else if (format == Compressor::XDR)

    {

        //

        // The the line or tile buffer is in XDR format.

        //

        // Convert the pixels from the file's machine-

        // independent representation, and store the

        // results in the frame buffer.

        //

        switch (typeInFrameBuffer)

        {

          case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT:

            switch (typeInFile)

            {

              case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT:

                for (int x = minX; x <= maxX; x++)

                {

                    char* writePtr = *(char **)(base+(y-yOffsetForData)*yPointerStride + (x-xOffsetForData)*xPointerStride);

                    int count = sampleCount(sampleCountBase,

                                            sampleCountXStride,

                                            sampleCountYStride,

                                            x - xOffsetForSampleCount,

                                            y - yOffsetForSampleCount);

                    if(writePtr)

                    {

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

                        {

                            Xdr::read <CharPtrIO> (readPtr, *(unsigned int *) writePtr);

                            writePtr += sampleStride;

                        }

                    }else{

                        Xdr::skip <CharPtrIO> (readPtr,count*Xdr::size<unsigned int>());

                    }

                }

                break;

              case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF:

                for (int x = minX; x <= maxX; x++)

                {

                    char* writePtr = *(char **)(base+(y-yOffsetForData)*yPointerStride + (x-xOffsetForData)*xPointerStride);

                    int count = sampleCount(sampleCountBase,

                                            sampleCountXStride,

                                            sampleCountYStride,

                                            x - xOffsetForSampleCount,

                                            y - yOffsetForSampleCount);

                    if(writePtr)

                    {

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

                        {

                            half h;

                            Xdr::read <CharPtrIO> (readPtr, h);

                           *(unsigned int *) writePtr = halfToUint (h);

                           writePtr += sampleStride;

                       }

                    }else{

                       Xdr::skip <CharPtrIO> (readPtr,count*Xdr::size<half>());

                    }

                }

                break;

              case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT:

                for (int x = minX; x <= maxX; x++)

                {

                    char* writePtr = *(char **)(base+(y-yOffsetForData)*yPointerStride + (x-xOffsetForData)*xPointerStride);

                    int count = sampleCount(sampleCountBase,

                                            sampleCountXStride,

                                            sampleCountYStride,

                                            x - xOffsetForSampleCount,

                                            y - yOffsetForSampleCount);

                    if(writePtr)

                    {

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

                        {

                            float f;

                            Xdr::read <CharPtrIO> (readPtr, f);

                            *(unsigned int *)writePtr = floatToUint (f);

                            writePtr += sampleStride;

                        } 

                     }else{

                       Xdr::skip <CharPtrIO> (readPtr,count*Xdr::size<float>());

                     }

                }

                break;

              default:

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

            }

            break;

          case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF:

            switch (typeInFile)

            {

              case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT:

                for (int x = minX; x <= maxX; x++)

                {

                    char* writePtr = *(char **)(base+(y-yOffsetForData)*yPointerStride + (x-xOffsetForData)*xPointerStride);

                    int count = sampleCount(sampleCountBase,

                                            sampleCountXStride,

                                            sampleCountYStride,

                                            x - xOffsetForSampleCount,

                                            y - yOffsetForSampleCount);

                    if(writePtr)

                    {

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