diff options
Diffstat (limited to 'gpr/source/lib/dng_sdk/dng_opcodes.cpp')
| -rw-r--r-- | gpr/source/lib/dng_sdk/dng_opcodes.cpp | 572 |
1 files changed, 572 insertions, 0 deletions
diff --git a/gpr/source/lib/dng_sdk/dng_opcodes.cpp b/gpr/source/lib/dng_sdk/dng_opcodes.cpp new file mode 100644 index 0000000..dedf097 --- /dev/null +++ b/gpr/source/lib/dng_sdk/dng_opcodes.cpp @@ -0,0 +1,572 @@ +/*****************************************************************************/
+// 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 pixelSize = TagTypeSize (fPixelType);
+
+ uint32 bufferSize = tileSize.v *
+ RoundUpForPixelSize (tileSize.h, pixelSize) *
+ pixelSize *
+ fImage.Planes ();
+
+ 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;
+
+ buffer.fArea = tile;
+
+ buffer.fPlane = 0;
+ buffer.fPlanes = fImage.Planes ();
+
+ buffer.fPixelType = fPixelType;
+ buffer.fPixelSize = TagTypeSize (fPixelType);
+
+ buffer.fPlaneStep = RoundUpForPixelSize (tile.W (),
+ buffer.fPixelSize);
+
+ buffer.fRowStep = buffer.fPlaneStep *
+ buffer.fPlanes;
+
+ buffer.fData = 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);
+
+ }
+
+ }
+
+/*****************************************************************************/
|