| /*****************************************************************************/ |
| // Copyright 2006-2012 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_host.cpp#2 $ */ |
| /* $DateTime: 2012/06/14 20:24:41 $ */ |
| /* $Change: 835078 $ */ |
| /* $Author: tknoll $ */ |
| |
| /*****************************************************************************/ |
| |
| #include "dng_host.h" |
| |
| #include "dng_abort_sniffer.h" |
| #include "dng_area_task.h" |
| #include "dng_bad_pixels.h" |
| #include "dng_exceptions.h" |
| #include "dng_exif.h" |
| #include "dng_gain_map.h" |
| #include "dng_ifd.h" |
| #include "dng_lens_correction.h" |
| #include "dng_memory.h" |
| #include "dng_misc_opcodes.h" |
| #include "dng_negative.h" |
| #include "dng_resample.h" |
| #include "dng_shared.h" |
| #include "dng_simple_image.h" |
| |
| #if qDNGUseXMP |
| #include "dng_xmp.h" |
| #endif |
| |
| /*****************************************************************************/ |
| |
| dng_host::dng_host (dng_memory_allocator *allocator, |
| dng_abort_sniffer *sniffer) |
| |
| : fAllocator (allocator) |
| , fSniffer (sniffer) |
| |
| , fNeedsMeta (true) |
| , fNeedsImage (true) |
| , fForPreview (false) |
| , fMinimumSize (0) |
| , fPreferredSize (0) |
| , fMaximumSize (0) |
| , fCropFactor (1.0) |
| , fSaveDNGVersion (dngVersion_None) |
| , fSaveLinearDNG (false) |
| , fKeepOriginalFile (false) |
| |
| { |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| dng_host::~dng_host () |
| { |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| dng_memory_allocator & dng_host::Allocator () |
| { |
| |
| if (fAllocator) |
| { |
| |
| return *fAllocator; |
| |
| } |
| |
| else |
| { |
| |
| return gDefaultDNGMemoryAllocator; |
| |
| } |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| dng_memory_block * dng_host::Allocate (uint32 logicalSize) |
| { |
| |
| return Allocator ().Allocate (logicalSize); |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_host::SniffForAbort () |
| { |
| |
| dng_abort_sniffer::SniffForAbort (Sniffer ()); |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_host::ValidateSizes () |
| { |
| |
| // The maximum size limits the other two sizes. |
| |
| if (MaximumSize ()) |
| { |
| SetMinimumSize (Min_uint32 (MinimumSize (), MaximumSize ())); |
| SetPreferredSize (Min_uint32 (PreferredSize (), MaximumSize ())); |
| } |
| |
| // If we have a preferred size, it limits the minimum size. |
| |
| if (PreferredSize ()) |
| { |
| SetMinimumSize (Min_uint32 (MinimumSize (), PreferredSize ())); |
| } |
| |
| // Else find default value for preferred size. |
| |
| else |
| { |
| |
| // If preferred size is zero, then we want the maximim |
| // size image. |
| |
| if (MaximumSize ()) |
| { |
| SetPreferredSize (MaximumSize ()); |
| } |
| |
| } |
| |
| // If we don't have a minimum size, find default. |
| |
| if (!MinimumSize ()) |
| { |
| |
| // A common size for embedded thumbnails is 120 by 160 pixels, |
| // So allow 120 by 160 pixels to be used for thumbnails when the |
| // preferred size is 256 pixel. |
| |
| if (PreferredSize () >= 160 && PreferredSize () <= 256) |
| { |
| SetMinimumSize (160); |
| } |
| |
| // Many sensors are near a multiple of 1024 pixels in size, but after |
| // the default crop, they are a just under. We can get an extra factor |
| // of size reduction if we allow a slight undershoot in the final size |
| // when computing large previews. |
| |
| else if (PreferredSize () >= 490 && PreferredSize () <= 512) |
| { |
| SetMinimumSize (490); |
| } |
| |
| else if (PreferredSize () >= 980 && PreferredSize () <= 1024) |
| { |
| SetMinimumSize (980); |
| } |
| |
| else if (PreferredSize () >= 1470 && PreferredSize () <= 1536) |
| { |
| SetMinimumSize (1470); |
| } |
| |
| else if (PreferredSize () >= 1960 && PreferredSize () <= 2048) |
| { |
| SetMinimumSize (1960); |
| } |
| |
| // Else minimum size is same as preferred size. |
| |
| else |
| { |
| SetMinimumSize (PreferredSize ()); |
| } |
| |
| } |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| uint32 dng_host::SaveDNGVersion () const |
| { |
| |
| return fSaveDNGVersion; |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| bool dng_host::SaveLinearDNG (const dng_negative & /* negative */) const |
| { |
| |
| return fSaveLinearDNG; |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| bool dng_host::IsTransientError (dng_error_code code) |
| { |
| |
| switch (code) |
| { |
| |
| case dng_error_memory: |
| case dng_error_user_canceled: |
| { |
| return true; |
| } |
| |
| default: |
| break; |
| |
| } |
| |
| return false; |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_host::PerformAreaTask (dng_area_task &task, |
| const dng_rect &area) |
| { |
| |
| dng_area_task::Perform (task, |
| area, |
| &Allocator (), |
| Sniffer ()); |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| uint32 dng_host::PerformAreaTaskThreads () |
| { |
| |
| return 1; |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| dng_exif * dng_host::Make_dng_exif () |
| { |
| |
| dng_exif *result = new dng_exif (); |
| |
| if (!result) |
| { |
| |
| ThrowMemoryFull (); |
| |
| } |
| |
| return result; |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| #if qDNGUseXMP |
| |
| dng_xmp * dng_host::Make_dng_xmp () |
| { |
| |
| dng_xmp *result = new dng_xmp (Allocator ()); |
| |
| if (!result) |
| { |
| |
| ThrowMemoryFull (); |
| |
| } |
| |
| return result; |
| |
| } |
| |
| #endif |
| |
| /*****************************************************************************/ |
| |
| dng_shared * dng_host::Make_dng_shared () |
| { |
| |
| dng_shared *result = new dng_shared (); |
| |
| if (!result) |
| { |
| |
| ThrowMemoryFull (); |
| |
| } |
| |
| return result; |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| dng_ifd * dng_host::Make_dng_ifd () |
| { |
| |
| dng_ifd *result = new dng_ifd (); |
| |
| if (!result) |
| { |
| |
| ThrowMemoryFull (); |
| |
| } |
| |
| return result; |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| dng_negative * dng_host::Make_dng_negative () |
| { |
| |
| return dng_negative::Make (*this); |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| dng_image * dng_host::Make_dng_image (const dng_rect &bounds, |
| uint32 planes, |
| uint32 pixelType) |
| { |
| |
| dng_image *result = new dng_simple_image (bounds, |
| planes, |
| pixelType, |
| Allocator ()); |
| |
| if (!result) |
| { |
| |
| ThrowMemoryFull (); |
| |
| } |
| |
| return result; |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| dng_opcode * dng_host::Make_dng_opcode (uint32 opcodeID, |
| dng_stream &stream) |
| { |
| |
| dng_opcode *result = NULL; |
| |
| switch (opcodeID) |
| { |
| |
| case dngOpcode_WarpRectilinear: |
| { |
| |
| result = new dng_opcode_WarpRectilinear (stream); |
| |
| break; |
| |
| } |
| |
| case dngOpcode_WarpFisheye: |
| { |
| |
| result = new dng_opcode_WarpFisheye (stream); |
| |
| break; |
| |
| } |
| |
| case dngOpcode_FixVignetteRadial: |
| { |
| |
| result = new dng_opcode_FixVignetteRadial (stream); |
| |
| break; |
| |
| } |
| |
| case dngOpcode_FixBadPixelsConstant: |
| { |
| |
| result = new dng_opcode_FixBadPixelsConstant (stream); |
| |
| break; |
| |
| } |
| |
| case dngOpcode_FixBadPixelsList: |
| { |
| |
| result = new dng_opcode_FixBadPixelsList (stream); |
| |
| break; |
| |
| } |
| |
| case dngOpcode_TrimBounds: |
| { |
| |
| result = new dng_opcode_TrimBounds (stream); |
| |
| break; |
| |
| } |
| |
| case dngOpcode_MapTable: |
| { |
| |
| result = new dng_opcode_MapTable (*this, |
| stream); |
| |
| break; |
| |
| } |
| |
| case dngOpcode_MapPolynomial: |
| { |
| |
| result = new dng_opcode_MapPolynomial (stream); |
| |
| break; |
| |
| } |
| |
| case dngOpcode_GainMap: |
| { |
| |
| result = new dng_opcode_GainMap (*this, |
| stream); |
| |
| break; |
| |
| } |
| |
| case dngOpcode_DeltaPerRow: |
| { |
| |
| result = new dng_opcode_DeltaPerRow (*this, |
| stream); |
| |
| break; |
| |
| } |
| |
| case dngOpcode_DeltaPerColumn: |
| { |
| |
| result = new dng_opcode_DeltaPerColumn (*this, |
| stream); |
| |
| break; |
| |
| } |
| |
| case dngOpcode_ScalePerRow: |
| { |
| |
| result = new dng_opcode_ScalePerRow (*this, |
| stream); |
| |
| break; |
| |
| } |
| |
| case dngOpcode_ScalePerColumn: |
| { |
| |
| result = new dng_opcode_ScalePerColumn (*this, |
| stream); |
| |
| break; |
| |
| } |
| |
| default: |
| { |
| |
| result = new dng_opcode_Unknown (*this, |
| opcodeID, |
| stream); |
| |
| } |
| |
| } |
| |
| if (!result) |
| { |
| |
| ThrowMemoryFull (); |
| |
| } |
| |
| return result; |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_host::ApplyOpcodeList (dng_opcode_list &list, |
| dng_negative &negative, |
| AutoPtr<dng_image> &image) |
| { |
| |
| list.Apply (*this, |
| negative, |
| image); |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_host::ResampleImage (const dng_image &srcImage, |
| dng_image &dstImage) |
| { |
| |
| ::ResampleImage (*this, |
| srcImage, |
| dstImage, |
| srcImage.Bounds (), |
| dstImage.Bounds (), |
| dng_resample_bicubic::Get ()); |
| |
| } |
| |
| /*****************************************************************************/ |
