| /*****************************************************************************/ |
| // Copyright 2006 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_filter_task.h#2 $ */ |
| /* $DateTime: 2012/07/11 10:36:56 $ */ |
| /* $Change: 838485 $ */ |
| /* $Author: tknoll $ */ |
| |
| /** \file |
| * Specialization of dng_area_task for processing an area from one dng_image to an |
| * area of another. |
| */ |
| |
| /*****************************************************************************/ |
| |
| #ifndef __dng_filter_task__ |
| #define __dng_filter_task__ |
| |
| /*****************************************************************************/ |
| |
| #include "dng_area_task.h" |
| #include "dng_auto_ptr.h" |
| #include "dng_point.h" |
| #include "dng_rect.h" |
| #include "dng_sdk_limits.h" |
| |
| /*****************************************************************************/ |
| |
| /// \brief Represents a task which filters an area of a source dng_image to an area |
| /// of a destination dng_image. |
| |
| class dng_filter_task: public dng_area_task |
| { |
| |
| protected: |
| |
| const dng_image &fSrcImage; |
| |
| dng_image &fDstImage; |
| |
| uint32 fSrcPlane; |
| uint32 fSrcPlanes; |
| uint32 fSrcPixelType; |
| |
| uint32 fDstPlane; |
| uint32 fDstPlanes; |
| uint32 fDstPixelType; |
| |
| dng_point fSrcRepeat; |
| dng_point fSrcTileSize; |
| |
| AutoPtr<dng_memory_block> fSrcBuffer [kMaxMPThreads]; |
| AutoPtr<dng_memory_block> fDstBuffer [kMaxMPThreads]; |
| |
| public: |
| |
| /// Construct a filter task given a source and destination images. |
| /// \param srcImage Image from which source pixels are read. |
| /// \param dstImage Image to which result pixels are written. |
| |
| dng_filter_task (const dng_image &srcImage, |
| dng_image &dstImage); |
| |
| virtual ~dng_filter_task (); |
| |
| /// Compute the source area needed for a given destination area. Default |
| /// implementation assumes destination area is equal to source area for all |
| /// cases. |
| /// |
| /// \param dstArea Area to for which pixels will be computed. |
| /// |
| /// \retval The source area needed as input to calculate the requested |
| /// destination area. |
| |
| virtual dng_rect SrcArea (const dng_rect &dstArea) |
| { |
| 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. |
| /// |
| /// \retval The source tile size needed to compute a tile of the destination |
| /// size. |
| |
| virtual dng_point SrcTileSize (const dng_point &dstTileSize) |
| { |
| return SrcArea (dng_rect (dstTileSize)).Size (); |
| } |
| |
| /// 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 threadIndex The thread on which this routine is being called, |
| /// between 0 and threadCount - 1 for the threadCount passed to Start method. |
| /// |
| /// \param srcBuffer Input area and source pixels. |
| /// |
| /// \param dstBuffer Output area and destination pixels. |
| |
| virtual void ProcessArea (uint32 threadIndex, |
| dng_pixel_buffer &srcBuffer, |
| dng_pixel_buffer &dstBuffer) = 0; |
| |
| /// Called prior to processing on specific threads. Can be used to allocate |
| /// per-thread memory buffers, etc. |
| /// |
| /// \param threadCount Total number of threads that will be used for |
| /// processing. Less than or equal to MaxThreads of dng_area_task. |
| /// |
| /// \param tileSize Size of source tiles which will be processed. (Not all |
| /// tiles will be this size due to edge conditions.) |
| /// |
| /// \param allocator dng_memory_allocator to use for allocating temporary |
| /// buffers, etc. |
| /// |
| /// \param sniffer Sniffer to test for user cancellation and to set up |
| /// progress. |
| |
| virtual void Start (uint32 threadCount, |
| const dng_point &tileSize, |
| dng_memory_allocator *allocator, |
| dng_abort_sniffer *sniffer); |
| |
| /// Process one tile or partitioned area. Should not be overridden. Instead, |
| /// override ProcessArea, which is where to implement filter processing for a |
| /// specific type of dng_filter_task. There is no allocator parameter as all |
| /// allocation should be done in Start. |
| /// |
| /// \param threadIndex 0 to threadCount - 1 index indicating which thread |
| /// this is. (Can be used to get a thread-specific buffer allocated in the |
| /// Start method.) |
| /// |
| /// \param area Size of tiles to be used for sizing buffers, etc. (Edges of |
| /// processing can be smaller.) |
| /// |
| /// \param sniffer dng_abort_sniffer to use to check for user cancellation |
| /// and progress updates. |
| |
| virtual void Process (uint32 threadIndex, |
| const dng_rect &area, |
| dng_abort_sniffer *sniffer); |
| |
| }; |
| |
| /*****************************************************************************/ |
| |
| #endif |
| |
| /*****************************************************************************/ |