| /*****************************************************************************/ |
| // 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.cpp#1 $ */ |
| /* $DateTime: 2012/05/30 13:28:51 $ */ |
| /* $Change: 832332 $ */ |
| /* $Author: tknoll $ */ |
| |
| /*****************************************************************************/ |
| |
| #include "dng_opcodes.h" |
| |
| #include "dng_bottlenecks.h" |
| #include "dng_exceptions.h" |
| #include "dng_filter_task.h" |
| #include "dng_globals.h" |
| #include "dng_host.h" |
| #include "dng_image.h" |
| #include "dng_negative.h" |
| #include "dng_parse_utils.h" |
| #include "dng_stream.h" |
| #include "dng_tag_values.h" |
| |
| /*****************************************************************************/ |
| |
| dng_opcode::dng_opcode (uint32 opcodeID, |
| uint32 minVersion, |
| uint32 flags) |
| |
| : fOpcodeID (opcodeID) |
| , fMinVersion (minVersion) |
| , fFlags (flags) |
| , fWasReadFromStream (false) |
| , fStage (0) |
| |
| { |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| dng_opcode::dng_opcode (uint32 opcodeID, |
| dng_stream &stream, |
| const char *name) |
| |
| : fOpcodeID (opcodeID) |
| , fMinVersion (0) |
| , fFlags (0) |
| , fWasReadFromStream (true) |
| , fStage (0) |
| |
| { |
| |
| fMinVersion = stream.Get_uint32 (); |
| fFlags = stream.Get_uint32 (); |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| printf ("\nOpcode: "); |
| |
| if (name) |
| { |
| printf ("%s", name); |
| } |
| else |
| { |
| printf ("Unknown (%u)", (unsigned) opcodeID); |
| } |
| |
| printf (", minVersion = %u.%u.%u.%u", |
| (unsigned) ((fMinVersion >> 24) & 0x0FF), |
| (unsigned) ((fMinVersion >> 16) & 0x0FF), |
| (unsigned) ((fMinVersion >> 8) & 0x0FF), |
| (unsigned) ((fMinVersion ) & 0x0FF)); |
| |
| printf (", flags = %u\n", (unsigned) fFlags); |
| |
| } |
| |
| #else |
| |
| (void) name; |
| |
| #endif |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| dng_opcode::~dng_opcode () |
| { |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_opcode::PutData (dng_stream &stream) const |
| { |
| |
| // No data by default |
| |
| stream.Put_uint32 (0); |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| bool dng_opcode::AboutToApply (dng_host &host, |
| dng_negative &negative) |
| { |
| |
| if (SkipIfPreview () && host.ForPreview ()) |
| { |
| |
| negative.SetIsPreview (true); |
| |
| } |
| |
| else if (MinVersion () > dngVersion_Current && |
| WasReadFromStream ()) |
| { |
| |
| if (!Optional ()) |
| { |
| |
| // Somebody screwed up computing the DNGBackwardVersion... |
| |
| ThrowBadFormat (); |
| |
| } |
| |
| } |
| |
| else if (!IsValidForNegative (negative)) |
| { |
| |
| ThrowBadFormat (); |
| |
| } |
| |
| else if (!IsNOP ()) |
| { |
| |
| return true; |
| |
| } |
| |
| return false; |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| dng_opcode_Unknown::dng_opcode_Unknown (dng_host &host, |
| uint32 opcodeID, |
| dng_stream &stream) |
| |
| : dng_opcode (opcodeID, |
| stream, |
| NULL) |
| |
| , fData () |
| |
| { |
| |
| uint32 size = stream.Get_uint32 (); |
| |
| if (size) |
| { |
| |
| fData.Reset (host.Allocate (size)); |
| |
| stream.Get (fData->Buffer (), |
| fData->LogicalSize ()); |
| |
| #if qDNGValidate |
| |
| if (gVerbose) |
| { |
| |
| DumpHexAscii (fData->Buffer_uint8 (), |
| fData->LogicalSize ()); |
| |
| } |
| |
| #endif |
| |
| } |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_opcode_Unknown::PutData (dng_stream &stream) const |
| { |
| |
| if (fData.Get ()) |
| { |
| |
| stream.Put_uint32 (fData->LogicalSize ()); |
| |
| stream.Put (fData->Buffer (), |
| fData->LogicalSize ()); |
| |
| } |
| |
| else |
| { |
| |
| stream.Put_uint32 (0); |
| |
| } |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_opcode_Unknown::Apply (dng_host & /* host */, |
| dng_negative & /* negative */, |
| AutoPtr<dng_image> & /* image */) |
| { |
| |
| // We should never need to apply an unknown opcode. |
| |
| if (!Optional ()) |
| { |
| |
| ThrowBadFormat (); |
| |
| } |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| class dng_filter_opcode_task: public dng_filter_task |
| { |
| |
| private: |
| |
| dng_filter_opcode &fOpcode; |
| |
| dng_negative &fNegative; |
| |
| public: |
| |
| dng_filter_opcode_task (dng_filter_opcode &opcode, |
| dng_negative &negative, |
| const dng_image &srcImage, |
| dng_image &dstImage) |
| |
| : dng_filter_task (srcImage, |
| dstImage) |
| |
| , fOpcode (opcode) |
| , fNegative (negative) |
| |
| { |
| |
| fSrcPixelType = fOpcode.BufferPixelType (srcImage.PixelType ()); |
| |
| fDstPixelType = fSrcPixelType; |
| |
| fSrcRepeat = opcode.SrcRepeat (); |
| |
| } |
| |
| virtual dng_rect SrcArea (const dng_rect &dstArea) |
| { |
| |
| return fOpcode.SrcArea (dstArea, |
| fDstImage.Bounds ()); |
| |
| } |
| |
| virtual dng_point SrcTileSize (const dng_point &dstTileSize) |
| { |
| |
| return fOpcode.SrcTileSize (dstTileSize, |
| fDstImage.Bounds ()); |
| |
| } |
| |
| virtual void ProcessArea (uint32 threadIndex, |
| dng_pixel_buffer &srcBuffer, |
| dng_pixel_buffer &dstBuffer) |
| { |
| |
| fOpcode.ProcessArea (fNegative, |
| threadIndex, |
| srcBuffer, |
| dstBuffer, |
| dstBuffer.Area (), |
| fDstImage.Bounds ()); |
| |
| } |
| |
| virtual void Start (uint32 threadCount, |
| const dng_point &tileSize, |
| dng_memory_allocator *allocator, |
| dng_abort_sniffer *sniffer) |
| { |
| |
| dng_filter_task::Start (threadCount, |
| tileSize, |
| allocator, |
| sniffer); |
| |
| fOpcode.Prepare (fNegative, |
| threadCount, |
| tileSize, |
| fDstImage.Bounds (), |
| fDstImage.Planes (), |
| fDstPixelType, |
| *allocator); |
| |
| } |
| |
| }; |
| |
| /*****************************************************************************/ |
| |
| dng_filter_opcode::dng_filter_opcode (uint32 opcodeID, |
| uint32 minVersion, |
| uint32 flags) |
| |
| : dng_opcode (opcodeID, |
| minVersion, |
| flags) |
| |
| { |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| dng_filter_opcode::dng_filter_opcode (uint32 opcodeID, |
| dng_stream &stream, |
| const char *name) |
| |
| : dng_opcode (opcodeID, |
| stream, |
| name) |
| |
| { |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_filter_opcode::Apply (dng_host &host, |
| dng_negative &negative, |
| AutoPtr<dng_image> &image) |
| { |
| |
| dng_rect modifiedBounds = ModifiedBounds (image->Bounds ()); |
| |
| if (modifiedBounds.NotEmpty ()) |
| { |
| |
| // Allocate destination image. |
| |
| AutoPtr<dng_image> dstImage; |
| |
| // If we are processing the entire image, allocate an |
| // undefined image. |
| |
| if (modifiedBounds == image->Bounds ()) |
| { |
| |
| dstImage.Reset (host.Make_dng_image (image->Bounds (), |
| image->Planes (), |
| image->PixelType ())); |
| |
| } |
| |
| // Else start with a clone of the existing image. |
| |
| else |
| { |
| |
| dstImage.Reset (image->Clone ()); |
| |
| } |
| |
| // Filter the image. |
| |
| dng_filter_opcode_task task (*this, |
| negative, |
| *image, |
| *dstImage); |
| |
| host.PerformAreaTask (task, |
| modifiedBounds); |
| |
| // Return the new image. |
| |
| image.Reset (dstImage.Release ()); |
| |
| } |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| class dng_inplace_opcode_task: public dng_area_task |
| { |
| |
| private: |
| |
| dng_inplace_opcode &fOpcode; |
| |
| dng_negative &fNegative; |
| |
| dng_image &fImage; |
| |
| uint32 fPixelType; |
| |
| AutoPtr<dng_memory_block> fBuffer [kMaxMPThreads]; |
| |
| public: |
| |
| dng_inplace_opcode_task (dng_inplace_opcode &opcode, |
| dng_negative &negative, |
| dng_image &image) |
| |
| : dng_area_task () |
| |
| , fOpcode (opcode) |
| , fNegative (negative) |
| , fImage (image) |
| , fPixelType (opcode.BufferPixelType (image.PixelType ())) |
| |
| { |
| |
| } |
| |
| virtual void Start (uint32 threadCount, |
| const dng_point &tileSize, |
| dng_memory_allocator *allocator, |
| dng_abort_sniffer * /* sniffer */) |
| { |
| |
| uint32 bufferSize = ComputeBufferSize(fPixelType, tileSize, |
| fImage.Planes(), pad16Bytes); |
| |
| for (uint32 threadIndex = 0; threadIndex < threadCount; threadIndex++) |
| { |
| |
| fBuffer [threadIndex] . Reset (allocator->Allocate (bufferSize)); |
| |
| } |
| |
| fOpcode.Prepare (fNegative, |
| threadCount, |
| tileSize, |
| fImage.Bounds (), |
| fImage.Planes (), |
| fPixelType, |
| *allocator); |
| |
| } |
| |
| virtual void Process (uint32 threadIndex, |
| const dng_rect &tile, |
| dng_abort_sniffer * /* sniffer */) |
| { |
| |
| // Setup buffer. |
| |
| dng_pixel_buffer buffer(tile, 0, fImage.Planes (), fPixelType, |
| pcRowInterleavedAlign16, |
| fBuffer [threadIndex]->Buffer ()); |
| |
| // Get source pixels. |
| |
| fImage.Get (buffer); |
| |
| // Process area. |
| |
| fOpcode.ProcessArea (fNegative, |
| threadIndex, |
| buffer, |
| tile, |
| fImage.Bounds ()); |
| |
| // Save result pixels. |
| |
| fImage.Put (buffer); |
| |
| } |
| |
| }; |
| |
| /*****************************************************************************/ |
| |
| dng_inplace_opcode::dng_inplace_opcode (uint32 opcodeID, |
| uint32 minVersion, |
| uint32 flags) |
| |
| : dng_opcode (opcodeID, |
| minVersion, |
| flags) |
| |
| { |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| dng_inplace_opcode::dng_inplace_opcode (uint32 opcodeID, |
| dng_stream &stream, |
| const char *name) |
| |
| : dng_opcode (opcodeID, |
| stream, |
| name) |
| |
| { |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_inplace_opcode::Apply (dng_host &host, |
| dng_negative &negative, |
| AutoPtr<dng_image> &image) |
| { |
| |
| dng_rect modifiedBounds = ModifiedBounds (image->Bounds ()); |
| |
| if (modifiedBounds.NotEmpty ()) |
| { |
| |
| dng_inplace_opcode_task task (*this, |
| negative, |
| *image); |
| |
| host.PerformAreaTask (task, |
| modifiedBounds); |
| |
| } |
| |
| } |
| |
| /*****************************************************************************/ |
