You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
547 lines
9.3 KiB
547 lines
9.3 KiB
/*****************************************************************************/
|
|
// 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 ());
|
|
|
|
}
|
|
|
|
/*****************************************************************************/
|