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

//

// Copyright (c) 2014, 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 FlatImageChannel

//

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

#include "ImfSampleCountChannel.h"

#include "ImfDeepImageLevel.h"

#include "ImfImage.h"

#include <Iex.h>

using namespace IMATH_NAMESPACE;

using namespace IEX_NAMESPACE;

using namespace std;

OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER

namespace {

unsigned int

roundListSizeUp (unsigned int n)

{

    //

    // Calculate the number of samples to be allocated for a sample list

    // with n entries by rounding n up to the next power of two.

    //

    if (n == 0)

        return 0;

    unsigned int s = 1;

    while (s < n)

        s <<= 1;

    return s;

}

size_t

roundBufferSizeUp (size_t n)

{

    //

    // Calculate the number of samples to be allocated for n samples.

    // Leave some extra space for new samples that may be added later.

    //

    return n + n / 2;

}

} // namespace

SampleCountChannel::SampleCountChannel (DeepImageLevel& level):

    ImageChannel (level, 1, 1, false),

    _numSamples (0),

    _base (0),

    _sampleListSizes (0),

    _sampleListPositions (0),

    _totalNumSamples (0),

    _totalSamplesOccupied (0),

    _sampleBufferSize (0)

{

    resize();

}

SampleCountChannel::~SampleCountChannel ()

{

    delete [] _numSamples;

    delete [] _sampleListSizes;

    delete [] _sampleListPositions;

}

PixelType

SampleCountChannel::pixelType () const

{

    return UINT;

}

Slice

SampleCountChannel::slice () const

{

    return Slice (UINT,                                     // type

                  (char *) _base,                           // base

                  sizeof (unsigned int),                    // xStride

                  pixelsPerRow() * sizeof (unsigned int),   // yStride

                  xSampling(),

                  ySampling());

}

DeepImageLevel &

SampleCountChannel::deepLevel ()

{

    return static_cast <DeepImageLevel &> (level());

}

const DeepImageLevel &

SampleCountChannel::deepLevel () const

{

    return static_cast <const DeepImageLevel &> (level());

}

void

SampleCountChannel::set (int x, int y, unsigned int newNumSamples)

{

    //

    // Set the number of samples for pixel (x,y) to newNumSamples.

    // Compute the position of the pixel in the the various

    // arrays that describe it.

    //

    size_t i = (_base + y * pixelsPerRow() + x) - _numSamples;

    if (newNumSamples <= _numSamples[i])

    {

        //

        // The number of samples for the pixel becomes smaller.

        // Save the new number of samples.

        //

        _totalNumSamples -= _numSamples[i] - newNumSamples;

        _numSamples[i] = newNumSamples;

        return;

    }

    if (newNumSamples <= _sampleListSizes[i])

    {

        //

        // The number of samples for the pixel becomes larger, but the new

        // number of samples still fits into the space that has been allocated

        // for the sample list.  Set the new samples at the end of the list to

        // zero.

        //

        deepLevel().setSamplesToZero (i,

                                      _numSamples[i],

                                      newNumSamples);

        _totalNumSamples += newNumSamples - _numSamples[i];

        _numSamples[i] = newNumSamples;

        return;

    }

    int newSampleListSize = roundListSizeUp (newNumSamples);

    if (_totalSamplesOccupied + newSampleListSize <= _sampleBufferSize)

    {

        //

        // The number of samples in the pixel no longer fits into the

        // space that has been allocated for the sample list, but there

        // is space available at the end of the sample buffer.  Allocate

        // space for a new list at the end of the sample buffer, and move

        // the sample list from its old location to its new, larger place.

        //

        deepLevel().moveSampleList

            (i, _numSamples[i], newNumSamples, _totalSamplesOccupied);

        _sampleListPositions[i] = _totalSamplesOccupied;

        _totalSamplesOccupied += newSampleListSize;

        _totalNumSamples += newNumSamples - _numSamples[i];

        _numSamples[i] = newNumSamples;

        return;

    }

    //

    // The new number of samples no longer fits into the space that has

    // been allocated for the sample list, and there is not enough room

    // at the end of the sample buffer for a new, larger sample list.

    // Allocate an entirely new sample buffer, and move all existing

    // sample lists into it.

    //

    unsigned int * oldNumSamples = 0;

    size_t * oldSampleListPositions = 0;

    try

    {

        _totalNumSamples += newNumSamples - _numSamples[i];

        oldNumSamples = _numSamples;

        _numSamples = new unsigned int [numPixels()];

        resetBasePointer();

        oldSampleListPositions = _sampleListPositions;

        _sampleListPositions = new size_t [numPixels()];

        _totalSamplesOccupied = 0;

        for (size_t j = 0; j < numPixels(); ++j)

        {

            if (j == i)

                _numSamples[j] = newNumSamples;

            else

                _numSamples[j] = oldNumSamples[j];

            _sampleListPositions[j] = _totalSamplesOccupied;

            _sampleListSizes[j] = roundListSizeUp (_numSamples[j]);

            _totalSamplesOccupied += _sampleListSizes[j];

        }

        _sampleBufferSize = roundBufferSizeUp (_totalSamplesOccupied);

        deepLevel().moveSamplesToNewBuffer (oldNumSamples,

                                            _numSamples,

                                            _sampleListPositions);

        delete [] oldNumSamples;

        delete [] oldSampleListPositions;

    }

    catch (...)

    {

        delete [] oldNumSamples;

        delete [] oldSampleListPositions;

        level().image().resize (Box2i (V2i (0, 0), V2i (-1, -1)));

        throw;

    }

}

void

SampleCountChannel::set (int r, unsigned int newNumSamples[])

{

    int x = level().dataWindow().min.x;

    int y = r + level().dataWindow().min.x;

    for (int i = 0; i < pixelsPerRow(); ++i, ++x)

        set (x, y, newNumSamples[i]);

}

void

SampleCountChannel::clear ()

{

    try

    {

        for (size_t i = 0; i < numPixels(); ++i)

        {

            _numSamples[i] = 0;

            _sampleListSizes[i] = 0;

            _sampleListPositions[i] = 0;

        }

        _totalNumSamples = 0;

        _totalSamplesOccupied = 0;

        _sampleBufferSize = roundBufferSizeUp (_totalSamplesOccupied);

        deepLevel().initializeSampleLists();

    }

    catch (...)

    {

        level().image().resize (Box2i (V2i (0, 0), V2i (-1, -1)));

        throw;

    }

}

unsigned int *

SampleCountChannel::beginEdit ()

{

    return _numSamples;

}

void

SampleCountChannel::endEdit ()

{

    try

    {

        _totalNumSamples = 0;

        _totalSamplesOccupied = 0;

        for (size_t i = 0; i < numPixels(); ++i)

        {

            _sampleListSizes[i] = roundListSizeUp (_numSamples[i]);

            _sampleListPositions[i] = _totalSamplesOccupied;

            _totalNumSamples += _numSamples[i];

            _totalSamplesOccupied += _sampleListSizes[i];

        }

        _sampleBufferSize = roundBufferSizeUp (_totalSamplesOccupied);

        deepLevel().initializeSampleLists();

    }

    catch (...)

    {

        level().image().resize (Box2i (V2i (0, 0), V2i (-1, -1)));

        throw;

    }

}

void

SampleCountChannel::resize ()

{

    ImageChannel::resize();

    delete [] _numSamples;

    delete [] _sampleListSizes;

    delete [] _sampleListPositions;

    _numSamples = 0;            // set to 0 to prevent double

    _sampleListSizes = 0;       // deletion in case of an exception

    _sampleListPositions = 0;

    _numSamples = new unsigned int [numPixels()];

    _sampleListSizes = new unsigned int [numPixels()];

    _sampleListPositions = new size_t [numPixels()];

    resetBasePointer();

    for (size_t i = 0; i < numPixels(); ++i)

    {

        _numSamples[i] = 0;

        _sampleListSizes[i] = 0;

        _sampleListPositions[i] = 0;

    }

    _totalNumSamples = 0;

    _totalSamplesOccupied = 0;

    _sampleBufferSize = roundBufferSizeUp (_totalSamplesOccupied);

}

void

SampleCountChannel::resetBasePointer ()

{

    _base = _numSamples -

            level().dataWindow().min.y * pixelsPerRow() -

            level().dataWindow().min.x;

}

OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT