You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
718 lines
21 KiB
718 lines
21 KiB
/*****************************************************************************/
|
|
// Copyright 2006-2008 Adobe Systems Incorporated
|
|
// All Rights Reserved.
|
|
//
|
|
// NOTICE: Adobe permits you to use, modify, and distribute this file in
|
|
// accordance with the terms of the Adobe license agreement accompanying it.
|
|
/*****************************************************************************/
|
|
|
|
/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_pixel_buffer.h#1 $ */
|
|
/* $DateTime: 2012/05/30 13:28:51 $ */
|
|
/* $Change: 832332 $ */
|
|
/* $Author: tknoll $ */
|
|
|
|
/** \file
|
|
* Support for holding buffers of sample data.
|
|
*/
|
|
|
|
/*****************************************************************************/
|
|
|
|
#ifndef __dng_pixel_buffer__
|
|
#define __dng_pixel_buffer__
|
|
|
|
/*****************************************************************************/
|
|
|
|
#include "dng_assertions.h"
|
|
#include "dng_rect.h"
|
|
#include "dng_safe_arithmetic.h"
|
|
#include "dng_tag_types.h"
|
|
|
|
/*****************************************************************************/
|
|
|
|
/// Compute best set of step values for a given source and destination area and stride.
|
|
|
|
void OptimizeOrder (const void *&sPtr,
|
|
void *&dPtr,
|
|
uint32 sPixelSize,
|
|
uint32 dPixelSize,
|
|
uint32 &count0,
|
|
uint32 &count1,
|
|
uint32 &count2,
|
|
int32 &sStep0,
|
|
int32 &sStep1,
|
|
int32 &sStep2,
|
|
int32 &dStep0,
|
|
int32 &dStep1,
|
|
int32 &dStep2);
|
|
|
|
void OptimizeOrder (const void *&sPtr,
|
|
uint32 sPixelSize,
|
|
uint32 &count0,
|
|
uint32 &count1,
|
|
uint32 &count2,
|
|
int32 &sStep0,
|
|
int32 &sStep1,
|
|
int32 &sStep2);
|
|
|
|
void OptimizeOrder (void *&dPtr,
|
|
uint32 dPixelSize,
|
|
uint32 &count0,
|
|
uint32 &count1,
|
|
uint32 &count2,
|
|
int32 &dStep0,
|
|
int32 &dStep1,
|
|
int32 &dStep2);
|
|
|
|
/*****************************************************************************/
|
|
|
|
#define qDebugPixelType 0
|
|
|
|
#if qDebugPixelType
|
|
|
|
#define ASSERT_PIXEL_TYPE(typeVal) CheckPixelType (typeVal)
|
|
|
|
#else
|
|
|
|
#define ASSERT_PIXEL_TYPE(typeVal) DNG_ASSERT (fPixelType == typeVal, "Pixel type access mismatch")
|
|
|
|
#endif
|
|
|
|
/*****************************************************************************/
|
|
|
|
/// \brief Holds a buffer of pixel data with "pixel geometry" metadata.
|
|
///
|
|
/// The pixel geometry describes the layout in terms of how many planes, rows and columns
|
|
/// plus the steps (in bytes) between each column, row and plane.
|
|
|
|
class dng_pixel_buffer
|
|
{
|
|
|
|
public:
|
|
|
|
// Area this buffer holds.
|
|
|
|
dng_rect fArea;
|
|
|
|
// Range of planes this buffer holds.
|
|
|
|
uint32 fPlane;
|
|
uint32 fPlanes;
|
|
|
|
// Steps between pixels.
|
|
|
|
int32 fRowStep;
|
|
int32 fColStep;
|
|
int32 fPlaneStep;
|
|
|
|
// Basic pixel type (TIFF tag type code).
|
|
|
|
uint32 fPixelType;
|
|
|
|
// Size of pixel type in bytes.
|
|
|
|
uint32 fPixelSize;
|
|
|
|
// Pointer to buffer's data.
|
|
|
|
void *fData;
|
|
|
|
// Do we have write-access to this data?
|
|
|
|
bool fDirty;
|
|
|
|
private:
|
|
|
|
void * InternalPixel (int32 row,
|
|
int32 col,
|
|
uint32 plane = 0) const
|
|
{
|
|
|
|
// Ensure pixel to be accessed lies inside valid area.
|
|
if (row < fArea.t || row >= fArea.b ||
|
|
col < fArea.l || col >= fArea.r ||
|
|
plane < fPlane || (plane - fPlane) >= fPlanes)
|
|
{
|
|
ThrowProgramError ("Out-of-range pixel access");
|
|
}
|
|
|
|
// Compute offset of pixel.
|
|
const int64 rowOffset = SafeInt64Mult(fRowStep,
|
|
static_cast<int64> (row) - static_cast<int64> (fArea.t));
|
|
const int64 colOffset = SafeInt64Mult(fColStep,
|
|
static_cast<int64> (col) - static_cast<int64> (fArea.l));
|
|
const int64 planeOffset = SafeInt64Mult(fPlaneStep,
|
|
static_cast<int64> (plane - fPlane));
|
|
const int64 offset = SafeInt64Mult(static_cast<int64>(fPixelSize),
|
|
SafeInt64Add(SafeInt64Add(rowOffset, colOffset), planeOffset));
|
|
|
|
// Add offset to buffer base address.
|
|
return static_cast<void *> (static_cast<uint8 *> (fData) + offset);
|
|
|
|
}
|
|
|
|
#if qDebugPixelType
|
|
|
|
void CheckPixelType (uint32 pixelType) const;
|
|
|
|
#endif
|
|
|
|
public:
|
|
|
|
dng_pixel_buffer ();
|
|
|
|
/// Note: This constructor is for internal use only and should not be
|
|
/// considered part of the DNG SDK API.
|
|
///
|
|
/// Initialize the pixel buffer according to the given parameters (see
|
|
/// below). May throw an error if arithmetic overflow occurs when
|
|
/// computing the row, column or plane step, or if an invalid value was
|
|
/// passed for planarConfiguration.
|
|
///
|
|
/// \param size Area covered by the pixel buffer
|
|
/// \param plane Index of the first plane
|
|
/// \param planes Number of planes
|
|
/// \param pixelType Pixel data type (one of the values defined in
|
|
/// dng_tag_types.h)
|
|
/// \param planarConfiguration Layout of the pixel planes in memory: One
|
|
/// of pcInterleaved, pcPlanar, or pcRowInterleaved (defined in
|
|
/// dng_tag_values.h)
|
|
/// \param data Pointer to the pixel data
|
|
dng_pixel_buffer (const dng_rect &area, uint32 plane, uint32 planes,
|
|
uint32 pixelType, uint32 planarConfiguration,
|
|
void *data);
|
|
|
|
dng_pixel_buffer (const dng_pixel_buffer &buffer);
|
|
|
|
dng_pixel_buffer & operator= (const dng_pixel_buffer &buffer);
|
|
|
|
virtual ~dng_pixel_buffer ();
|
|
|
|
/// Get the range of pixel values.
|
|
/// \retval Range of value a pixel can take. (Meaning [0, max] for unsigned case. Signed case is biased so [-32768, max - 32768].)
|
|
|
|
uint32 PixelRange () const;
|
|
|
|
/// Get extent of pixels in buffer
|
|
/// \retval Rectangle giving valid extent of buffer.
|
|
|
|
const dng_rect & Area () const
|
|
{
|
|
return fArea;
|
|
}
|
|
|
|
/// Number of planes of image data.
|
|
/// \retval Number of planes held in buffer.
|
|
|
|
uint32 Planes () const
|
|
{
|
|
return fPlanes;
|
|
}
|
|
|
|
/// Step, in pixels not bytes, between rows of data in buffer.
|
|
/// \retval row step in pixels. May be negative.
|
|
|
|
int32 RowStep () const
|
|
{
|
|
return fRowStep;
|
|
}
|
|
|
|
/// Step, in pixels not bytes, between planes of data in buffer.
|
|
/// \retval plane step in pixels. May be negative.
|
|
|
|
int32 PlaneStep () const
|
|
{
|
|
return fPlaneStep;
|
|
}
|
|
|
|
/// Get read-only untyped (void *) pointer to pixel data starting at a specific pixel in the buffer.
|
|
/// \param row Start row for buffer pointer.
|
|
/// \param col Start column for buffer pointer.
|
|
/// \param plane Start plane for buffer pointer.
|
|
/// \retval Pointer to pixel data as void *.
|
|
|
|
const void * ConstPixel (int32 row,
|
|
int32 col,
|
|
uint32 plane = 0) const
|
|
{
|
|
|
|
return InternalPixel (row, col, plane);
|
|
|
|
}
|
|
|
|
/// Get a writable untyped (void *) pointer to pixel data starting at a specific pixel in the buffer.
|
|
/// \param row Start row for buffer pointer.
|
|
/// \param col Start column for buffer pointer.
|
|
/// \param plane Start plane for buffer pointer.
|
|
/// \retval Pointer to pixel data as void *.
|
|
|
|
void * DirtyPixel (int32 row,
|
|
int32 col,
|
|
uint32 plane = 0)
|
|
{
|
|
|
|
DNG_ASSERT (fDirty, "Dirty access to const pixel buffer");
|
|
|
|
return InternalPixel (row, col, plane);
|
|
|
|
}
|
|
|
|
/// Get read-only uint8 * to pixel data starting at a specific pixel in the buffer.
|
|
/// \param row Start row for buffer pointer.
|
|
/// \param col Start column for buffer pointer.
|
|
/// \param plane Start plane for buffer pointer.
|
|
/// \retval Pointer to pixel data as uint8 *.
|
|
|
|
const uint8 * ConstPixel_uint8 (int32 row,
|
|
int32 col,
|
|
uint32 plane = 0) const
|
|
{
|
|
|
|
ASSERT_PIXEL_TYPE (ttByte);
|
|
|
|
return (const uint8 *) ConstPixel (row, col, plane);
|
|
|
|
}
|
|
|
|
/// Get a writable uint8 * to pixel data starting at a specific pixel in the buffer.
|
|
/// \param row Start row for buffer pointer.
|
|
/// \param col Start column for buffer pointer.
|
|
/// \param plane Start plane for buffer pointer.
|
|
/// \retval Pointer to pixel data as uint8 *.
|
|
|
|
uint8 * DirtyPixel_uint8 (int32 row,
|
|
int32 col,
|
|
uint32 plane = 0)
|
|
{
|
|
|
|
ASSERT_PIXEL_TYPE (ttByte);
|
|
|
|
return (uint8 *) DirtyPixel (row, col, plane);
|
|
|
|
}
|
|
|
|
/// Get read-only int8 * to pixel data starting at a specific pixel in the buffer.
|
|
/// \param row Start row for buffer pointer.
|
|
/// \param col Start column for buffer pointer.
|
|
/// \param plane Start plane for buffer pointer.
|
|
/// \retval Pointer to pixel data as int8 *.
|
|
|
|
const int8 * ConstPixel_int8 (int32 row,
|
|
int32 col,
|
|
uint32 plane = 0) const
|
|
{
|
|
|
|
ASSERT_PIXEL_TYPE (ttSByte);
|
|
|
|
return (const int8 *) ConstPixel (row, col, plane);
|
|
|
|
}
|
|
|
|
/// Get a writable int8 * to pixel data starting at a specific pixel in the buffer.
|
|
/// \param row Start row for buffer pointer.
|
|
/// \param col Start column for buffer pointer.
|
|
/// \param plane Start plane for buffer pointer.
|
|
/// \retval Pointer to pixel data as int8 *.
|
|
|
|
int8 * DirtyPixel_int8 (int32 row,
|
|
int32 col,
|
|
uint32 plane = 0)
|
|
{
|
|
|
|
ASSERT_PIXEL_TYPE (ttSByte);
|
|
|
|
return (int8 *) DirtyPixel (row, col, plane);
|
|
|
|
}
|
|
|
|
/// Get read-only uint16 * to pixel data starting at a specific pixel in the buffer.
|
|
/// \param row Start row for buffer pointer.
|
|
/// \param col Start column for buffer pointer.
|
|
/// \param plane Start plane for buffer pointer.
|
|
/// \retval Pointer to pixel data as uint16 *.
|
|
|
|
const uint16 * ConstPixel_uint16 (int32 row,
|
|
int32 col,
|
|
uint32 plane = 0) const
|
|
{
|
|
|
|
ASSERT_PIXEL_TYPE (ttShort);
|
|
|
|
return (const uint16 *) ConstPixel (row, col, plane);
|
|
|
|
}
|
|
|
|
/// Get a writable uint16 * to pixel data starting at a specific pixel in the buffer.
|
|
/// \param row Start row for buffer pointer.
|
|
/// \param col Start column for buffer pointer.
|
|
/// \param plane Start plane for buffer pointer.
|
|
/// \retval Pointer to pixel data as uint16 *.
|
|
|
|
uint16 * DirtyPixel_uint16 (int32 row,
|
|
int32 col,
|
|
uint32 plane = 0)
|
|
{
|
|
|
|
ASSERT_PIXEL_TYPE (ttShort);
|
|
|
|
return (uint16 *) DirtyPixel (row, col, plane);
|
|
|
|
}
|
|
|
|
/// Get read-only int16 * to pixel data starting at a specific pixel in the buffer.
|
|
/// \param row Start row for buffer pointer.
|
|
/// \param col Start column for buffer pointer.
|
|
/// \param plane Start plane for buffer pointer.
|
|
/// \retval Pointer to pixel data as int16 *.
|
|
|
|
const int16 * ConstPixel_int16 (int32 row,
|
|
int32 col,
|
|
uint32 plane = 0) const
|
|
{
|
|
|
|
ASSERT_PIXEL_TYPE (ttSShort);
|
|
|
|
return (const int16 *) ConstPixel (row, col, plane);
|
|
|
|
}
|
|
|
|
/// Get a writable int16 * to pixel data starting at a specific pixel in the buffer.
|
|
/// \param row Start row for buffer pointer.
|
|
/// \param col Start column for buffer pointer.
|
|
/// \param plane Start plane for buffer pointer.
|
|
/// \retval Pointer to pixel data as int16 *.
|
|
|
|
int16 * DirtyPixel_int16 (int32 row,
|
|
int32 col,
|
|
uint32 plane = 0)
|
|
{
|
|
|
|
ASSERT_PIXEL_TYPE (ttSShort);
|
|
|
|
return (int16 *) DirtyPixel (row, col, plane);
|
|
|
|
}
|
|
|
|
/// Get read-only uint32 * to pixel data starting at a specific pixel in the buffer.
|
|
/// \param row Start row for buffer pointer.
|
|
/// \param col Start column for buffer pointer.
|
|
/// \param plane Start plane for buffer pointer.
|
|
/// \retval Pointer to pixel data as uint32 *.
|
|
|
|
const uint32 * ConstPixel_uint32 (int32 row,
|
|
int32 col,
|
|
uint32 plane = 0) const
|
|
{
|
|
|
|
ASSERT_PIXEL_TYPE (ttLong);
|
|
|
|
return (const uint32 *) ConstPixel (row, col, plane);
|
|
|
|
}
|
|
|
|
/// Get a writable uint32 * to pixel data starting at a specific pixel in the buffer.
|
|
/// \param row Start row for buffer pointer.
|
|
/// \param col Start column for buffer pointer.
|
|
/// \param plane Start plane for buffer pointer.
|
|
/// \retval Pointer to pixel data as uint32 *.
|
|
|
|
uint32 * DirtyPixel_uint32 (int32 row,
|
|
int32 col,
|
|
uint32 plane = 0)
|
|
{
|
|
|
|
ASSERT_PIXEL_TYPE (ttLong);
|
|
|
|
return (uint32 *) DirtyPixel (row, col, plane);
|
|
|
|
}
|
|
|
|
/// Get read-only int32 * to pixel data starting at a specific pixel in the buffer.
|
|
/// \param row Start row for buffer pointer.
|
|
/// \param col Start column for buffer pointer.
|
|
/// \param plane Start plane for buffer pointer.
|
|
/// \retval Pointer to pixel data as int32 *.
|
|
|
|
const int32 * ConstPixel_int32 (int32 row,
|
|
int32 col,
|
|
uint32 plane = 0) const
|
|
{
|
|
|
|
ASSERT_PIXEL_TYPE (ttSLong);
|
|
|
|
return (const int32 *) ConstPixel (row, col, plane);
|
|
|
|
}
|
|
|
|
/// Get a writable int32 * to pixel data starting at a specific pixel in the buffer.
|
|
/// \param row Start row for buffer pointer.
|
|
/// \param col Start column for buffer pointer.
|
|
/// \param plane Start plane for buffer pointer.
|
|
/// \retval Pointer to pixel data as int32 *.
|
|
|
|
int32 * DirtyPixel_int32 (int32 row,
|
|
int32 col,
|
|
uint32 plane = 0)
|
|
{
|
|
|
|
ASSERT_PIXEL_TYPE (ttSLong);
|
|
|
|
return (int32 *) DirtyPixel (row, col, plane);
|
|
|
|
}
|
|
|
|
/// Get read-only real32 * to pixel data starting at a specific pixel in the buffer.
|
|
/// \param row Start row for buffer pointer.
|
|
/// \param col Start column for buffer pointer.
|
|
/// \param plane Start plane for buffer pointer.
|
|
/// \retval Pointer to pixel data as real32 *.
|
|
|
|
const real32 * ConstPixel_real32 (int32 row,
|
|
int32 col,
|
|
uint32 plane = 0) const
|
|
{
|
|
|
|
ASSERT_PIXEL_TYPE (ttFloat);
|
|
|
|
return (const real32 *) ConstPixel (row, col, plane);
|
|
|
|
}
|
|
|
|
/// Get a writable real32 * to pixel data starting at a specific pixel in the buffer.
|
|
/// \param row Start row for buffer pointer.
|
|
/// \param col Start column for buffer pointer.
|
|
/// \param plane Start plane for buffer pointer.
|
|
/// \retval Pointer to pixel data as real32 *.
|
|
|
|
real32 * DirtyPixel_real32 (int32 row,
|
|
int32 col,
|
|
uint32 plane = 0)
|
|
{
|
|
|
|
ASSERT_PIXEL_TYPE (ttFloat);
|
|
|
|
return (real32 *) DirtyPixel (row, col, plane);
|
|
|
|
}
|
|
|
|
/// Initialize a rectangular area of pixel buffer to a constant.
|
|
/// \param area Rectangle of pixel buffer to set.
|
|
/// \param plane Plane to start filling on.
|
|
/// \param planes Number of planes to fill.
|
|
/// \param value Constant value to set pixels to.
|
|
|
|
void SetConstant (const dng_rect &area,
|
|
uint32 plane,
|
|
uint32 planes,
|
|
uint32 value);
|
|
|
|
/// Initialize a rectangular area of pixel buffer to a constant unsigned 8-bit value.
|
|
/// \param area Rectangle of pixel buffer to set.
|
|
/// \param plane Plane to start filling on.
|
|
/// \param planes Number of planes to fill.
|
|
/// \param value Constant uint8 value to set pixels to.
|
|
|
|
void SetConstant_uint8 (const dng_rect &area,
|
|
uint32 plane,
|
|
uint32 planes,
|
|
uint8 value)
|
|
{
|
|
|
|
DNG_ASSERT (fPixelType == ttByte, "Mismatched pixel type");
|
|
|
|
SetConstant (area, plane, planes, (uint32) value);
|
|
|
|
}
|
|
|
|
/// Initialize a rectangular area of pixel buffer to a constant unsigned 16-bit value.
|
|
/// \param area Rectangle of pixel buffer to set.
|
|
/// \param plane Plane to start filling on.
|
|
/// \param planes Number of planes to fill.
|
|
/// \param value Constant uint16 value to set pixels to.
|
|
|
|
void SetConstant_uint16 (const dng_rect &area,
|
|
uint32 plane,
|
|
uint32 planes,
|
|
uint16 value)
|
|
{
|
|
|
|
DNG_ASSERT (fPixelType == ttShort, "Mismatched pixel type");
|
|
|
|
SetConstant (area, plane, planes, (uint32) value);
|
|
|
|
}
|
|
|
|
/// Initialize a rectangular area of pixel buffer to a constant signed 16-bit value.
|
|
/// \param area Rectangle of pixel buffer to set.
|
|
/// \param plane Plane to start filling on.
|
|
/// \param planes Number of planes to fill.
|
|
/// \param value Constant int16 value to set pixels to.
|
|
|
|
void SetConstant_int16 (const dng_rect &area,
|
|
uint32 plane,
|
|
uint32 planes,
|
|
int16 value)
|
|
{
|
|
|
|
DNG_ASSERT (fPixelType == ttSShort, "Mismatched pixel type");
|
|
|
|
SetConstant (area, plane, planes, (uint32) (uint16) value);
|
|
|
|
}
|
|
|
|
/// Initialize a rectangular area of pixel buffer to a constant unsigned 32-bit value.
|
|
/// \param area Rectangle of pixel buffer to set.
|
|
/// \param plane Plane to start filling on.
|
|
/// \param planes Number of planes to fill.
|
|
/// \param value Constant uint32 value to set pixels to.
|
|
|
|
void SetConstant_uint32 (const dng_rect &area,
|
|
uint32 plane,
|
|
uint32 planes,
|
|
uint32 value)
|
|
{
|
|
|
|
DNG_ASSERT (fPixelType == ttLong, "Mismatched pixel type");
|
|
|
|
SetConstant (area, plane, planes, value);
|
|
|
|
}
|
|
|
|
/// Initialize a rectangular area of pixel buffer to a constant real 32-bit value.
|
|
/// \param area Rectangle of pixel buffer to set.
|
|
/// \param plane Plane to start filling on.
|
|
/// \param planes Number of planes to fill.
|
|
/// \param value Constant real32 value to set pixels to.
|
|
|
|
void SetConstant_real32 (const dng_rect &area,
|
|
uint32 plane,
|
|
uint32 planes,
|
|
real32 value)
|
|
{
|
|
|
|
DNG_ASSERT (fPixelType == ttFloat, "Mismatched pixel type");
|
|
|
|
union
|
|
{
|
|
uint32 i;
|
|
real32 f;
|
|
} x;
|
|
|
|
x.f = value;
|
|
|
|
SetConstant (area, plane, planes, x.i);
|
|
|
|
}
|
|
|
|
/// Initialize a rectangular area of pixel buffer to zeros.
|
|
/// \param area Rectangle of pixel buffer to zero.
|
|
/// \param area Area to zero
|
|
/// \param plane Plane to start filling on.
|
|
/// \param planes Number of planes to fill.
|
|
|
|
void SetZero (const dng_rect &area,
|
|
uint32 plane,
|
|
uint32 planes);
|
|
|
|
/// Copy image data from an area of one pixel buffer to same area of another.
|
|
/// \param src Buffer to copy from.
|
|
/// \param area Rectangle of pixel buffer to copy.
|
|
/// \param srcPlane Plane to start copy in src.
|
|
/// \param dstPlane Plane to start copy in dst.
|
|
/// \param planes Number of planes to copy.
|
|
|
|
void CopyArea (const dng_pixel_buffer &src,
|
|
const dng_rect &area,
|
|
uint32 srcPlane,
|
|
uint32 dstPlane,
|
|
uint32 planes);
|
|
|
|
/// Copy image data from an area of one pixel buffer to same area of another.
|
|
/// \param src Buffer to copy from.
|
|
/// \param area Rectangle of pixel buffer to copy.
|
|
/// \param plane Plane to start copy in src and this.
|
|
/// \param planes Number of planes to copy.
|
|
|
|
void CopyArea (const dng_pixel_buffer &src,
|
|
const dng_rect &area,
|
|
uint32 plane,
|
|
uint32 planes)
|
|
{
|
|
|
|
CopyArea (src, area, plane, plane, planes);
|
|
|
|
}
|
|
|
|
/// Calculate the offset phase of destination rectangle relative to source rectangle.
|
|
/// Phase is based on a 0,0 origin and the notion of repeating srcArea across dstArea.
|
|
/// It is the number of pixels into srcArea to start repeating from when tiling dstArea.
|
|
/// \retval dng_point containing horizontal and vertical phase.
|
|
|
|
static dng_point RepeatPhase (const dng_rect &srcArea,
|
|
const dng_rect &dstArea);
|
|
|
|
/// Repeat the image data in srcArea across dstArea.
|
|
/// (Generally used for padding operations.)
|
|
/// \param srcArea Area to repeat from.
|
|
/// \param dstArea Area to fill with data from srcArea.
|
|
|
|
void RepeatArea (const dng_rect &srcArea,
|
|
const dng_rect &dstArea);
|
|
|
|
/// Replicates a sub-area of a buffer to fill the entire buffer.
|
|
|
|
void RepeatSubArea (const dng_rect subArea,
|
|
uint32 repeatV = 1,
|
|
uint32 repeatH = 1);
|
|
|
|
/// Apply a right shift (C++ oerpator >>) to all pixel values. Only implemented for 16-bit (signed or unsigned) pixel buffers.
|
|
/// \param shift Number of bits by which to right shift each pixel value.
|
|
|
|
void ShiftRight (uint32 shift);
|
|
|
|
/// Change metadata so pixels are iterated in opposite horizontal order.
|
|
/// This operation does not require movement of actual pixel data.
|
|
|
|
void FlipH ();
|
|
|
|
/// Change metadata so pixels are iterated in opposite vertical order.
|
|
/// This operation does not require movement of actual pixel data.
|
|
|
|
void FlipV ();
|
|
|
|
/// Change metadata so pixels are iterated in opposite plane order.
|
|
/// This operation does not require movement of actual pixel data.
|
|
|
|
void FlipZ (); // Flip planes
|
|
|
|
/// Return true if the contents of an area of the pixel buffer area are the same as those of another.
|
|
/// \param rhs Buffer to compare against.
|
|
/// \param area Rectangle of pixel buffer to test.
|
|
/// \param plane Plane to start comparing.
|
|
/// \param planes Number of planes to compare.
|
|
/// \retval bool true if areas are equal, false otherwise.
|
|
|
|
bool EqualArea (const dng_pixel_buffer &rhs,
|
|
const dng_rect &area,
|
|
uint32 plane,
|
|
uint32 planes) const;
|
|
|
|
/// Return the absolute value of the maximum difference between two pixel buffers. Used for comparison testing with tolerance
|
|
/// \param rhs Buffer to compare against.
|
|
/// \param area Rectangle of pixel buffer to test.
|
|
/// \param plane Plane to start comparing.
|
|
/// \param planes Number of planes to compare.
|
|
/// \retval larges absolute value difference between the corresponding pixels each buffer across area.
|
|
|
|
real64 MaximumDifference (const dng_pixel_buffer &rhs,
|
|
const dng_rect &area,
|
|
uint32 plane,
|
|
uint32 planes) const;
|
|
|
|
};
|
|
|
|
/*****************************************************************************/
|
|
|
|
#endif
|
|
|
|
/*****************************************************************************/
|