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.
508 lines
13 KiB
508 lines
13 KiB
/*****************************************************************************/
|
|
// Copyright 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_opcodes.h#2 $ */
|
|
/* $DateTime: 2012/08/02 06:09:06 $ */
|
|
/* $Change: 841096 $ */
|
|
/* $Author: erichan $ */
|
|
|
|
/** \file
|
|
* Base class and common data structures for opcodes (introduced in DNG 1.3).
|
|
*/
|
|
|
|
/*****************************************************************************/
|
|
|
|
#ifndef __dng_opcodes__
|
|
#define __dng_opcodes__
|
|
|
|
/*****************************************************************************/
|
|
|
|
#include "dng_auto_ptr.h"
|
|
#include "dng_classes.h"
|
|
#include "dng_rect.h"
|
|
#include "dng_types.h"
|
|
|
|
/*****************************************************************************/
|
|
|
|
/// \brief List of supported opcodes (by ID).
|
|
|
|
enum dng_opcode_id
|
|
{
|
|
|
|
// Internal use only opcode. Never written to DNGs.
|
|
|
|
dngOpcode_Private = 0,
|
|
|
|
// Warp image to correct distortion and lateral chromatic aberration for
|
|
// rectilinear lenses.
|
|
|
|
dngOpcode_WarpRectilinear = 1,
|
|
|
|
// Warp image to correction distortion for fisheye lenses (i.e., map the
|
|
// fisheye projection to a perspective projection).
|
|
|
|
dngOpcode_WarpFisheye = 2,
|
|
|
|
// Radial vignette correction.
|
|
|
|
dngOpcode_FixVignetteRadial = 3,
|
|
|
|
// Patch bad Bayer pixels which are marked with a special value in the image.
|
|
|
|
dngOpcode_FixBadPixelsConstant = 4,
|
|
|
|
// Patch bad Bayer pixels/rectangles at a list of specified coordinates.
|
|
|
|
dngOpcode_FixBadPixelsList = 5,
|
|
|
|
// Trim image to specified bounds.
|
|
|
|
dngOpcode_TrimBounds = 6,
|
|
|
|
// Map an area through a 16-bit LUT.
|
|
|
|
dngOpcode_MapTable = 7,
|
|
|
|
// Map an area using a polynomial function.
|
|
|
|
dngOpcode_MapPolynomial = 8,
|
|
|
|
// Apply a gain map to an area.
|
|
|
|
dngOpcode_GainMap = 9,
|
|
|
|
// Apply a per-row delta to an area.
|
|
|
|
dngOpcode_DeltaPerRow = 10,
|
|
|
|
// Apply a per-column delta to an area.
|
|
|
|
dngOpcode_DeltaPerColumn = 11,
|
|
|
|
// Apply a per-row scale to an area.
|
|
|
|
dngOpcode_ScalePerRow = 12,
|
|
|
|
// Apply a per-column scale to an area.
|
|
|
|
dngOpcode_ScalePerColumn = 13
|
|
|
|
};
|
|
|
|
/*****************************************************************************/
|
|
|
|
/// \brief Virtual base class for opcode.
|
|
|
|
class dng_opcode
|
|
{
|
|
|
|
public:
|
|
|
|
/// Opcode flags.
|
|
|
|
enum
|
|
{
|
|
kFlag_None = 0, //!< No flag.
|
|
kFlag_Optional = 1, //!< This opcode is optional.
|
|
kFlag_SkipIfPreview = 2 //!< May skip opcode for preview images.
|
|
};
|
|
|
|
private:
|
|
|
|
uint32 fOpcodeID;
|
|
|
|
uint32 fMinVersion;
|
|
|
|
uint32 fFlags;
|
|
|
|
bool fWasReadFromStream;
|
|
|
|
uint32 fStage;
|
|
|
|
protected:
|
|
|
|
dng_opcode (uint32 opcodeID,
|
|
uint32 minVersion,
|
|
uint32 flags);
|
|
|
|
dng_opcode (uint32 opcodeID,
|
|
dng_stream &stream,
|
|
const char *name);
|
|
|
|
public:
|
|
|
|
virtual ~dng_opcode ();
|
|
|
|
/// The ID of this opcode.
|
|
|
|
uint32 OpcodeID () const
|
|
{
|
|
return fOpcodeID;
|
|
}
|
|
|
|
/// The first DNG version that supports this opcode.
|
|
|
|
uint32 MinVersion () const
|
|
{
|
|
return fMinVersion;
|
|
}
|
|
|
|
/// The flags for this opcode.
|
|
|
|
uint32 Flags () const
|
|
{
|
|
return fFlags;
|
|
}
|
|
|
|
/// Is this opcode optional?
|
|
|
|
bool Optional () const
|
|
{
|
|
return (Flags () & kFlag_Optional) != 0;
|
|
}
|
|
|
|
/// Should the opcode be skipped when rendering preview images?
|
|
|
|
bool SkipIfPreview () const
|
|
{
|
|
return (Flags () & kFlag_SkipIfPreview) != 0;
|
|
}
|
|
|
|
/// Was this opcode read from a data stream?
|
|
|
|
bool WasReadFromStream () const
|
|
{
|
|
return fWasReadFromStream;
|
|
}
|
|
|
|
/// Which image processing stage (1, 2, 3) is associated with this
|
|
/// opcode?
|
|
|
|
uint32 Stage () const
|
|
{
|
|
return fStage;
|
|
}
|
|
|
|
/// Set the image processing stage (1, 2, 3) for this opcode. Stage 1 is
|
|
/// the original image data, including masked areas. Stage 2 is
|
|
/// linearized image data and trimmed to the active area. Stage 3 is
|
|
/// demosaiced and trimmed to the active area.
|
|
|
|
void SetStage (uint32 stage)
|
|
{
|
|
fStage = stage;
|
|
}
|
|
|
|
/// Is the opcode a NOP (i.e., does nothing)? An opcode could be a NOP
|
|
/// for some specific parameters.
|
|
|
|
virtual bool IsNOP () const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/// Is this opcode valid for the specified negative?
|
|
|
|
virtual bool IsValidForNegative (const dng_negative & /* negative */) const
|
|
{
|
|
return true;
|
|
}
|
|
|
|
/// Write opcode to a stream.
|
|
/// \param stream The stream to which to write the opcode data.
|
|
|
|
virtual void PutData (dng_stream &stream) const;
|
|
|
|
/// Perform error checking prior to applying this opcode to the
|
|
/// specified negative. Returns true if this opcode should be applied to
|
|
/// the negative, false otherwise.
|
|
|
|
bool AboutToApply (dng_host &host,
|
|
dng_negative &negative);
|
|
|
|
/// Apply this opcode to the specified image with associated negative.
|
|
|
|
virtual void Apply (dng_host &host,
|
|
dng_negative &negative,
|
|
AutoPtr<dng_image> &image) = 0;
|
|
|
|
};
|
|
|
|
/*****************************************************************************/
|
|
|
|
/// \brief Class to represent unknown opcodes (e.g, opcodes defined in future
|
|
/// DNG versions).
|
|
|
|
class dng_opcode_Unknown: public dng_opcode
|
|
{
|
|
|
|
private:
|
|
|
|
AutoPtr<dng_memory_block> fData;
|
|
|
|
public:
|
|
|
|
dng_opcode_Unknown (dng_host &host,
|
|
uint32 opcodeID,
|
|
dng_stream &stream);
|
|
|
|
virtual void PutData (dng_stream &stream) const;
|
|
|
|
virtual void Apply (dng_host &host,
|
|
dng_negative &negative,
|
|
AutoPtr<dng_image> &image);
|
|
|
|
};
|
|
|
|
/*****************************************************************************/
|
|
|
|
/// \brief Class to represent a filter opcode, such as a convolution.
|
|
|
|
class dng_filter_opcode: public dng_opcode
|
|
{
|
|
|
|
protected:
|
|
|
|
dng_filter_opcode (uint32 opcodeID,
|
|
uint32 minVersion,
|
|
uint32 flags);
|
|
|
|
dng_filter_opcode (uint32 opcodeID,
|
|
dng_stream &stream,
|
|
const char *name);
|
|
|
|
public:
|
|
|
|
/// The pixel data type of this opcode.
|
|
|
|
virtual uint32 BufferPixelType (uint32 imagePixelType)
|
|
{
|
|
return imagePixelType;
|
|
}
|
|
|
|
/// The adjusted bounds (processing area) of this opcode. It is limited to
|
|
/// the intersection of the specified image area and the GainMap area.
|
|
|
|
virtual dng_rect ModifiedBounds (const dng_rect &imageBounds)
|
|
{
|
|
return imageBounds;
|
|
}
|
|
|
|
/// Returns the width and height (in pixels) of the repeating mosaic pattern.
|
|
|
|
virtual dng_point SrcRepeat ()
|
|
{
|
|
return dng_point (1, 1);
|
|
}
|
|
|
|
/// Returns the source pixel area needed to process a destination pixel area
|
|
/// that lies within the specified bounds.
|
|
/// \param dstArea The destination pixel area to be computed.
|
|
/// \param imageBounds The overall image area (dstArea will lie within these
|
|
/// bounds).
|
|
/// \retval The source pixel area needed to process the specified dstArea.
|
|
|
|
virtual dng_rect SrcArea (const dng_rect &dstArea,
|
|
const dng_rect & /* imageBounds */)
|
|
{
|
|
return dstArea;
|
|
}
|
|
|
|
/// Given a destination tile size, calculate input tile size. Simlar to
|
|
/// SrcArea, and should seldom be overridden.
|
|
///
|
|
/// \param dstTileSize The destination tile size that is targeted for output.
|
|
///
|
|
/// \param imageBounds The image bounds (the destination tile will
|
|
/// always lie within these bounds).
|
|
///
|
|
/// \retval The source tile size needed to compute a tile of the destination
|
|
/// size.
|
|
|
|
virtual dng_point SrcTileSize (const dng_point &dstTileSize,
|
|
const dng_rect &imageBounds)
|
|
{
|
|
return SrcArea (dng_rect (dstTileSize),
|
|
imageBounds).Size ();
|
|
}
|
|
|
|
/// Startup method called before any processing is performed on pixel areas.
|
|
/// It can be used to allocate (per-thread) memory and setup tasks.
|
|
///
|
|
/// \param negative The negative object to be processed.
|
|
///
|
|
/// \param threadCount The number of threads to be used to perform the
|
|
/// processing.
|
|
///
|
|
/// \param threadCount Total number of threads that will be used for
|
|
/// processing. Less than or equal to MaxThreads.
|
|
///
|
|
/// \param tileSize Size of source tiles which will be processed. (Not all
|
|
/// tiles will be this size due to edge conditions.)
|
|
///
|
|
/// \param imageBounds Total size of image to be processed.
|
|
///
|
|
/// \param imagePlanes Number of planes in the image. Less than or equal to
|
|
/// kMaxColorPlanes.
|
|
///
|
|
/// \param bufferPixelType Pixel type of image buffer (see dng_tag_types.h).
|
|
///
|
|
/// \param allocator dng_memory_allocator to use for allocating temporary
|
|
/// buffers, etc.
|
|
|
|
virtual void Prepare (dng_negative & /* negative */,
|
|
uint32 /* threadCount */,
|
|
const dng_point & /* tileSize */,
|
|
const dng_rect & /* imageBounds */,
|
|
uint32 /* imagePlanes */,
|
|
uint32 /* bufferPixelType */,
|
|
dng_memory_allocator & /* allocator */)
|
|
{
|
|
}
|
|
|
|
/// Implements filtering operation from one buffer to another. Source
|
|
/// and destination pixels are set up in member fields of this class.
|
|
/// Ideally, no allocation should be done in this routine.
|
|
///
|
|
/// \param negative The negative associated with the pixels to be
|
|
/// processed.
|
|
///
|
|
/// \param threadIndex The thread on which this routine is being called,
|
|
/// between 0 and threadCount - 1 for the threadCount passed to Prepare
|
|
/// method.
|
|
///
|
|
/// \param srcBuffer Input area and source pixels.
|
|
///
|
|
/// \param dstBuffer Destination pixels.
|
|
///
|
|
/// \param dstArea Destination pixel processing area.
|
|
///
|
|
/// \param imageBounds Total image area to be processed; dstArea will
|
|
/// always lie within these bounds.
|
|
|
|
virtual void ProcessArea (dng_negative &negative,
|
|
uint32 threadIndex,
|
|
dng_pixel_buffer &srcBuffer,
|
|
dng_pixel_buffer &dstBuffer,
|
|
const dng_rect &dstArea,
|
|
const dng_rect &imageBounds) = 0;
|
|
|
|
virtual void Apply (dng_host &host,
|
|
dng_negative &negative,
|
|
AutoPtr<dng_image> &image);
|
|
|
|
};
|
|
|
|
/*****************************************************************************/
|
|
|
|
/// \brief Class to represent an in-place (i.e., pointwise, per-pixel) opcode,
|
|
/// such as a global tone curve.
|
|
|
|
class dng_inplace_opcode: public dng_opcode
|
|
{
|
|
|
|
protected:
|
|
|
|
dng_inplace_opcode (uint32 opcodeID,
|
|
uint32 minVersion,
|
|
uint32 flags);
|
|
|
|
dng_inplace_opcode (uint32 opcodeID,
|
|
dng_stream &stream,
|
|
const char *name);
|
|
|
|
public:
|
|
|
|
/// The pixel data type of this opcode.
|
|
|
|
virtual uint32 BufferPixelType (uint32 imagePixelType)
|
|
{
|
|
return imagePixelType;
|
|
}
|
|
|
|
/// The adjusted bounds (processing area) of this opcode. It is limited to
|
|
/// the intersection of the specified image area and the GainMap area.
|
|
|
|
virtual dng_rect ModifiedBounds (const dng_rect &imageBounds)
|
|
{
|
|
return imageBounds;
|
|
}
|
|
|
|
/// Startup method called before any processing is performed on pixel areas.
|
|
/// It can be used to allocate (per-thread) memory and setup tasks.
|
|
///
|
|
/// \param negative The negative object to be processed.
|
|
///
|
|
/// \param threadCount The number of threads to be used to perform the
|
|
/// processing.
|
|
///
|
|
/// \param threadCount Total number of threads that will be used for
|
|
/// processing. Less than or equal to MaxThreads.
|
|
///
|
|
/// \param tileSize Size of source tiles which will be processed. (Not all
|
|
/// tiles will be this size due to edge conditions.)
|
|
///
|
|
/// \param imageBounds Total size of image to be processed.
|
|
///
|
|
/// \param imagePlanes Number of planes in the image. Less than or equal to
|
|
/// kMaxColorPlanes.
|
|
///
|
|
/// \param bufferPixelType Pixel type of image buffer (see dng_tag_types.h).
|
|
///
|
|
/// \param allocator dng_memory_allocator to use for allocating temporary
|
|
/// buffers, etc.
|
|
|
|
virtual void Prepare (dng_negative & /* negative */,
|
|
uint32 /* threadCount */,
|
|
const dng_point & /* tileSize */,
|
|
const dng_rect & /* imageBounds */,
|
|
uint32 /* imagePlanes */,
|
|
uint32 /* bufferPixelType */,
|
|
dng_memory_allocator & /* allocator */)
|
|
{
|
|
}
|
|
|
|
/// Implements image processing operation in a single buffer. The source
|
|
/// pixels are provided as input to the buffer, and this routine
|
|
/// calculates and writes the destination pixels to the same buffer.
|
|
/// Ideally, no allocation should be done in this routine.
|
|
///
|
|
/// \param negative The negative associated with the pixels to be
|
|
/// processed.
|
|
///
|
|
/// \param threadIndex The thread on which this routine is being called,
|
|
/// between 0 and threadCount - 1 for the threadCount passed to Prepare
|
|
/// method.
|
|
///
|
|
/// \param srcBuffer Input area and source pixels.
|
|
///
|
|
/// \param dstBuffer Destination pixels.
|
|
///
|
|
/// \param dstArea Destination pixel processing area.
|
|
///
|
|
/// \param imageBounds Total image area to be processed; dstArea will
|
|
/// always lie within these bounds.
|
|
|
|
virtual void ProcessArea (dng_negative &negative,
|
|
uint32 threadIndex,
|
|
dng_pixel_buffer &buffer,
|
|
const dng_rect &dstArea,
|
|
const dng_rect &imageBounds) = 0;
|
|
|
|
virtual void Apply (dng_host &host,
|
|
dng_negative &negative,
|
|
AutoPtr<dng_image> &image);
|
|
|
|
};
|
|
|
|
/*****************************************************************************/
|
|
|
|
#endif
|
|
|
|
/*****************************************************************************/
|