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

//

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

    {

        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

            {

                lx_table[i] = 0;

                ly_table[i] = 0;               

            }

            break;            

        }

        case MIPMAP_LEVELS:

        {

            for(size_t i=0;i

            {

                lx_table[i]= table[i].l;

                ly_table[i] =table[i].l;               

            }

            break;

        }

        case RIPMAP_LEVELS:

        {

            for(size_t i=0;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