/*****************************************************************************/
// 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_image.h#1 $ */
/* $DateTime: 2012/05/30 13:28:51 $ */
/* $Change: 832332 $ */
/* $Author: tknoll $ */
/** \file
* Support for working with image data in DNG SDK.
*/
/*****************************************************************************/
#ifndef __dng_image__
#define __dng_image__
/*****************************************************************************/
#include "dng_assertions.h"
#include "dng_classes.h"
#include "dng_pixel_buffer.h"
#include "dng_point.h"
#include "dng_rect.h"
#include "dng_tag_types.h"
#include "dng_types.h"
/*****************************************************************************/
/// \brief Class to get resource acquisition is instantiation behavior for tile
/// buffers. Can be dirty or constant tile access.
class dng_tile_buffer: public dng_pixel_buffer
{
protected:
const dng_image &fImage;
void *fRefData;
protected:
/// Obtain a tile from an image.
/// \param image Image tile will come from.
/// \param tile Rectangle denoting extent of tile.
/// \param dirty Flag indicating whether this is read-only or read-write acesss.
dng_tile_buffer (const dng_image &image,
const dng_rect &tile,
bool dirty);
virtual ~dng_tile_buffer ();
public:
void SetRefData (void *refData)
{
fRefData = refData;
}
void * GetRefData () const
{
return fRefData;
}
private:
// Hidden copy constructor and assignment operator.
dng_tile_buffer (const dng_tile_buffer &buffer);
dng_tile_buffer & operator= (const dng_tile_buffer &buffer);
};
/*****************************************************************************/
/// \brief Class to get resource acquisition is instantiation behavior for
/// constant (read-only) tile buffers.
class dng_const_tile_buffer: public dng_tile_buffer
{
public:
/// Obtain a read-only tile from an image.
/// \param image Image tile will come from.
/// \param tile Rectangle denoting extent of tile.
dng_const_tile_buffer (const dng_image &image,
const dng_rect &tile);
virtual ~dng_const_tile_buffer ();
};
/*****************************************************************************/
/// \brief Class to get resource acquisition is instantiation behavior for
/// dirty (writable) tile buffers.
class dng_dirty_tile_buffer: public dng_tile_buffer
{
public:
/// Obtain a writable tile from an image.
/// \param image Image tile will come from.
/// \param tile Rectangle denoting extent of tile.
dng_dirty_tile_buffer (dng_image &image,
const dng_rect &tile);
virtual ~dng_dirty_tile_buffer ();
};
/*****************************************************************************/
/// \brief Base class for holding image data in DNG SDK. See dng_simple_image
/// for derived class most often used in DNG SDK.
class dng_image
{
friend class dng_tile_buffer;
protected:
// Bounds for this image.
dng_rect fBounds;
// Number of image planes.
uint32 fPlanes;
// Basic pixel type (TIFF tag type code).
uint32 fPixelType;
public:
/// How to handle requests to get image areas outside the image bounds.
enum edge_option
{
/// Leave edge pixels unchanged.
edge_none,
/// Pad with zeros.
edge_zero,
/// Repeat edge pixels.
edge_repeat,
/// Repeat edge pixels, except for last plane which is zero padded.
edge_repeat_zero_last
};
protected:
dng_image (const dng_rect &bounds,
uint32 planes,
uint32 pixelType);
public:
virtual ~dng_image ();
virtual dng_image * Clone () const;
/// Getter method for bounds of an image.
const dng_rect & Bounds () const
{
return fBounds;
}
/// Getter method for size of an image.
dng_point Size () const
{
return Bounds ().Size ();
}
/// Getter method for width of an image.
uint32 Width () const
{
return Bounds ().W ();
}
/// Getter method for height of an image.
uint32 Height () const
{
return Bounds ().H ();
}
/// Getter method for number of planes in an image.
uint32 Planes () const
{
return fPlanes;
}
/// Getter for pixel type.
/// \retval See dng_tagtypes.h . Valid values are ttByte, ttShort, ttSShort,
/// ttLong, ttFloat .
uint32 PixelType () const
{
return fPixelType;
}
/// Setter for pixel type.
/// \param pixelType The new pixel type .
virtual void SetPixelType (uint32 pixelType);
/// Getter for pixel size.
/// \retval Size, in bytes, of pixel type for this image .
uint32 PixelSize () const;
/// Getter for pixel range.
/// For unsigned types, range is 0 to return value.
/// For signed types, range is return value - 0x8000U.
/// For ttFloat type, pixel range is 0.0 to 1.0 and this routine returns 1.
uint32 PixelRange () const;
/// Getter for best "tile stride" for accessing image.
virtual dng_rect RepeatingTile () const;
/// Get a pixel buffer of data on image with proper edge padding.
/// \param buffer Receives resulting pixel buffer.
/// \param edgeOption edge_option describing how to pad edges.
/// \param repeatV Amount of repeated padding needed in vertical for
/// edge_repeat and edge_repeat_zero_last edgeOption cases.
/// \param repeatH Amount of repeated padding needed in horizontal for
/// edge_repeat and edge_repeat_zero_last edgeOption cases.
void Get (dng_pixel_buffer &buffer,
edge_option edgeOption = edge_none,
uint32 repeatV = 1,
uint32 repeatH = 1) const;
/// Put a pixel buffer into image.
/// \param buffer Pixel buffer to copy from.
void Put (const dng_pixel_buffer &buffer);
/// Shrink bounds of image to given rectangle.
/// \param r Rectangle to crop to.
virtual void Trim (const dng_rect &r);
/// Rotate image to reflect given orientation change.
/// \param orientation Directive to rotate image in a certain way.
virtual void Rotate (const dng_orientation &orientation);
/// Copy image data from an area of one image to same area of another.
/// \param src Image to copy from.
/// \param area Rectangle of images to copy.
/// \param srcPlane Plane to start copying in src.
/// \param dstPlane Plane to start copying in this.
/// \param planes Number of planes to copy.
void CopyArea (const dng_image &src,
const dng_rect &area,
uint32 srcPlane,
uint32 dstPlane,
uint32 planes);
/// Copy image data from an area of one image to same area of another.
/// \param src Image to copy from.
/// \param area Rectangle of images to copy.
/// \param plane Plane to start copying in src and this.
/// \param planes Number of planes to copy.
void CopyArea (const dng_image &src,
const dng_rect &area,
uint32 plane,
uint32 planes)
{
CopyArea (src, area, plane, plane, planes);
}
/// Return true if the contents of an area of the image are the same as those of another.
/// \param rhs Image to compare against.
/// \param area Rectangle of image to test.
/// \param plane Plane to start comparing.
/// \param planes Number of planes to compare.
bool EqualArea (const dng_image &rhs,
const dng_rect &area,
uint32 plane,
uint32 planes) const;
// Routines to set the entire image to a constant value.
void SetConstant_uint8 (uint8 value,
const dng_rect &area)
{
DNG_ASSERT (fPixelType == ttByte, "Mismatched pixel type");
SetConstant ((uint32) value, area);
}
void SetConstant_uint8 (uint8 value)
{
SetConstant (value, Bounds ());
}
void SetConstant_uint16 (uint16 value,
const dng_rect &area)
{
DNG_ASSERT (fPixelType == ttShort, "Mismatched pixel type");
SetConstant ((uint32) value, area);
}
void SetConstant_uint16 (uint16 value)
{
SetConstant_uint16 (value, Bounds ());
}
void SetConstant_int16 (int16 value,
const dng_rect &area)
{
DNG_ASSERT (fPixelType == ttSShort, "Mismatched pixel type");
SetConstant ((uint32) (uint16) value, area);
}
void SetConstant_int16 (int16 value)
{
SetConstant_int16 (value, Bounds ());
}
void SetConstant_uint32 (uint32 value,
const dng_rect &area)
{
DNG_ASSERT (fPixelType == ttLong, "Mismatched pixel type");
SetConstant (value, area);
}
void SetConstant_uint32 (uint32 value)
{
SetConstant_uint32 (value, Bounds ());
}
void SetConstant_real32 (real32 value,
const dng_rect &area)
{
DNG_ASSERT (fPixelType == ttFloat, "Mismatched pixel type");
union
{
uint32 i;
real32 f;
} x;
x.f = value;
SetConstant (x.i, area);
}
void SetConstant_real32 (real32 value)
{
SetConstant_real32 (value, Bounds ());
}
virtual void GetRepeat (dng_pixel_buffer &buffer,
const dng_rect &srcArea,
const dng_rect &dstArea) const;
protected:
virtual void AcquireTileBuffer (dng_tile_buffer &buffer,
const dng_rect &area,
bool dirty) const;
virtual void ReleaseTileBuffer (dng_tile_buffer &buffer) const;
virtual void DoGet (dng_pixel_buffer &buffer) const;
virtual void DoPut (const dng_pixel_buffer &buffer);
void GetEdge (dng_pixel_buffer &buffer,
edge_option edgeOption,
const dng_rect &srcArea,
const dng_rect &dstArea) const;
virtual void SetConstant (uint32 value,
const dng_rect &area);
};
/*****************************************************************************/
#endif
/*****************************************************************************/