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