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