| /*****************************************************************************/ |
| // Copyright 2006-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_image.cpp#1 $ */ |
| /* $DateTime: 2012/05/30 13:28:51 $ */ |
| /* $Change: 832332 $ */ |
| /* $Author: tknoll $ */ |
| |
| /*****************************************************************************/ |
| |
| #include "dng_image.h" |
| |
| #include "dng_assertions.h" |
| #include "dng_exceptions.h" |
| #include "dng_orientation.h" |
| #include "dng_pixel_buffer.h" |
| #include "dng_tag_types.h" |
| #include "dng_tile_iterator.h" |
| #include "dng_utils.h" |
| |
| /*****************************************************************************/ |
| |
| dng_tile_buffer::dng_tile_buffer (const dng_image &image, |
| const dng_rect &tile, |
| bool dirty) |
| |
| : fImage (image) |
| , fRefData (NULL) |
| |
| { |
| |
| fImage.AcquireTileBuffer (*this, |
| tile, |
| dirty); |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| dng_tile_buffer::~dng_tile_buffer () |
| { |
| |
| fImage.ReleaseTileBuffer (*this); |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| dng_const_tile_buffer::dng_const_tile_buffer (const dng_image &image, |
| const dng_rect &tile) |
| |
| : dng_tile_buffer (image, tile, false) |
| |
| { |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| dng_const_tile_buffer::~dng_const_tile_buffer () |
| { |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| dng_dirty_tile_buffer::dng_dirty_tile_buffer (dng_image &image, |
| const dng_rect &tile) |
| |
| : dng_tile_buffer (image, tile, true) |
| |
| { |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| dng_dirty_tile_buffer::~dng_dirty_tile_buffer () |
| { |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| dng_image::dng_image (const dng_rect &bounds, |
| uint32 planes, |
| uint32 pixelType) |
| |
| : fBounds (bounds) |
| , fPlanes (planes) |
| , fPixelType (pixelType) |
| |
| { |
| |
| if (bounds.IsEmpty () || planes == 0 || PixelSize () == 0) |
| { |
| |
| #if qDNGValidate |
| |
| ReportError ("Fuzz: Attempt to create zero size image"); |
| |
| #endif |
| |
| ThrowBadFormat (); |
| |
| } |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| dng_image::~dng_image () |
| { |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| dng_image * dng_image::Clone () const |
| { |
| |
| ThrowProgramError ("Clone is not supported by this dng_image subclass"); |
| |
| return NULL; |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_image::SetPixelType (uint32 pixelType) |
| { |
| |
| if (TagTypeSize (pixelType) != PixelSize ()) |
| { |
| |
| ThrowProgramError ("Cannot change pixel size for existing image"); |
| |
| } |
| |
| fPixelType = pixelType; |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| uint32 dng_image::PixelSize () const |
| { |
| |
| return TagTypeSize (PixelType ()); |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| uint32 dng_image::PixelRange () const |
| { |
| |
| switch (fPixelType) |
| { |
| |
| case ttByte: |
| case ttSByte: |
| { |
| return 0x0FF; |
| } |
| |
| case ttShort: |
| case ttSShort: |
| { |
| return 0x0FFFF; |
| } |
| |
| case ttLong: |
| case ttSLong: |
| { |
| return 0xFFFFFFFF; |
| } |
| |
| default: |
| break; |
| |
| } |
| |
| return 0; |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| dng_rect dng_image::RepeatingTile () const |
| { |
| |
| return fBounds; |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_image::AcquireTileBuffer (dng_tile_buffer & /* buffer */, |
| const dng_rect & /* area */, |
| bool /* dirty */) const |
| { |
| |
| ThrowProgramError (); |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_image::ReleaseTileBuffer (dng_tile_buffer & /* buffer */) const |
| { |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_image::DoGet (dng_pixel_buffer &buffer) const |
| { |
| |
| dng_rect tile; |
| |
| dng_tile_iterator iter (*this, buffer.fArea); |
| |
| while (iter.GetOneTile (tile)) |
| { |
| |
| dng_const_tile_buffer tileBuffer (*this, tile); |
| |
| buffer.CopyArea (tileBuffer, |
| tile, |
| buffer.fPlane, |
| buffer.fPlanes); |
| |
| } |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_image::DoPut (const dng_pixel_buffer &buffer) |
| { |
| |
| dng_rect tile; |
| |
| dng_tile_iterator iter (*this, buffer.fArea); |
| |
| while (iter.GetOneTile (tile)) |
| { |
| |
| dng_dirty_tile_buffer tileBuffer (*this, tile); |
| |
| tileBuffer.CopyArea (buffer, |
| tile, |
| buffer.fPlane, |
| buffer.fPlanes); |
| |
| } |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_image::GetRepeat (dng_pixel_buffer &buffer, |
| const dng_rect &srcArea, |
| const dng_rect &dstArea) const |
| { |
| |
| // If we already have the entire srcArea in the |
| // buffer, we can just repeat that. |
| |
| if ((srcArea & buffer.fArea) == srcArea) |
| { |
| |
| buffer.RepeatArea (srcArea, |
| dstArea); |
| |
| } |
| |
| // Else we first need to get the srcArea into the buffer area. |
| |
| else |
| { |
| |
| // Find repeating pattern size. |
| |
| dng_point repeat = srcArea.Size (); |
| |
| // Find pattern phase at top-left corner of destination area. |
| |
| dng_point phase = dng_pixel_buffer::RepeatPhase (srcArea, |
| dstArea); |
| |
| // Find new source area at top-left of dstArea. |
| |
| dng_rect newArea = srcArea + (dstArea.TL () - |
| srcArea.TL ()); |
| |
| // Find quadrant split coordinates. |
| |
| int32 splitV = newArea.t + repeat.v - phase.v; |
| int32 splitH = newArea.l + repeat.h - phase.h; |
| |
| // Top-left quadrant. |
| |
| dng_rect dst1 (dng_rect (newArea.t, |
| newArea.l, |
| splitV, |
| splitH) & dstArea); |
| |
| if (dst1.NotEmpty ()) |
| { |
| |
| dng_pixel_buffer temp (buffer); |
| |
| temp.fArea = dst1 + (srcArea.TL () - |
| dstArea.TL () + |
| dng_point (phase.v, phase.h)); |
| |
| temp.fData = buffer.DirtyPixel (dst1.t, |
| dst1.l, |
| buffer.fPlane); |
| |
| DoGet (temp); |
| |
| } |
| |
| // Top-right quadrant. |
| |
| dng_rect dst2 (dng_rect (newArea.t, |
| splitH, |
| splitV, |
| newArea.r) & dstArea); |
| |
| if (dst2.NotEmpty ()) |
| { |
| |
| dng_pixel_buffer temp (buffer); |
| |
| temp.fArea = dst2 + (srcArea.TL () - |
| dstArea.TL () + |
| dng_point (phase.v, -phase.h)); |
| |
| temp.fData = buffer.DirtyPixel (dst2.t, |
| dst2.l, |
| buffer.fPlane); |
| |
| DoGet (temp); |
| |
| } |
| |
| // Bottom-left quadrant. |
| |
| dng_rect dst3 (dng_rect (splitV, |
| newArea.l, |
| newArea.b, |
| splitH) & dstArea); |
| |
| if (dst3.NotEmpty ()) |
| { |
| |
| dng_pixel_buffer temp (buffer); |
| |
| temp.fArea = dst3 + (srcArea.TL () - |
| dstArea.TL () + |
| dng_point (-phase.v, phase.h)); |
| |
| temp.fData = buffer.DirtyPixel (dst3.t, |
| dst3.l, |
| buffer.fPlane); |
| |
| DoGet (temp); |
| |
| } |
| |
| // Bottom-right quadrant. |
| |
| dng_rect dst4 (dng_rect (splitV, |
| splitH, |
| newArea.b, |
| newArea.r) & dstArea); |
| |
| if (dst4.NotEmpty ()) |
| { |
| |
| dng_pixel_buffer temp (buffer); |
| |
| temp.fArea = dst4 + (srcArea.TL () - |
| dstArea.TL () + |
| dng_point (-phase.v, -phase.h)); |
| |
| temp.fData = buffer.DirtyPixel (dst4.t, |
| dst4.l, |
| buffer.fPlane); |
| |
| DoGet (temp); |
| |
| } |
| |
| // Replicate this new source area. |
| |
| buffer.RepeatArea (newArea, |
| dstArea); |
| |
| } |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_image::GetEdge (dng_pixel_buffer &buffer, |
| edge_option edgeOption, |
| const dng_rect &srcArea, |
| const dng_rect &dstArea) const |
| { |
| |
| switch (edgeOption) |
| { |
| |
| case edge_zero: |
| { |
| |
| buffer.SetZero (dstArea, |
| buffer.fPlane, |
| buffer.fPlanes); |
| |
| break; |
| |
| } |
| |
| case edge_repeat: |
| { |
| |
| GetRepeat (buffer, |
| srcArea, |
| dstArea); |
| |
| break; |
| |
| } |
| |
| case edge_repeat_zero_last: |
| { |
| |
| if (buffer.fPlanes > 1) |
| { |
| |
| dng_pixel_buffer buffer1 (buffer); |
| |
| buffer1.fPlanes--; |
| |
| GetEdge (buffer1, |
| edge_repeat, |
| srcArea, |
| dstArea); |
| |
| } |
| |
| dng_pixel_buffer buffer2 (buffer); |
| |
| buffer2.fPlane = buffer.fPlanes - 1; |
| buffer2.fPlanes = 1; |
| |
| buffer2.fData = buffer.DirtyPixel (buffer2.fArea.t, |
| buffer2.fArea.l, |
| buffer2.fPlane); |
| |
| GetEdge (buffer2, |
| edge_zero, |
| srcArea, |
| dstArea); |
| |
| break; |
| |
| } |
| |
| default: |
| { |
| |
| ThrowProgramError (); |
| |
| } |
| |
| } |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_image::Get (dng_pixel_buffer &buffer, |
| edge_option edgeOption, |
| uint32 repeatV, |
| uint32 repeatH) const |
| { |
| |
| // Find the overlap with the image bounds. |
| |
| dng_rect overlap = buffer.fArea & fBounds; |
| |
| // Move the overlapping pixels. |
| |
| if (overlap.NotEmpty ()) |
| { |
| |
| dng_pixel_buffer temp (buffer); |
| |
| temp.fArea = overlap; |
| |
| temp.fData = buffer.DirtyPixel (overlap.t, |
| overlap.l, |
| buffer.fPlane); |
| |
| DoGet (temp); |
| |
| } |
| |
| // See if we need to pad the edge values. |
| |
| if ((edgeOption != edge_none) && (overlap != buffer.fArea)) |
| { |
| |
| dng_rect areaT (buffer.fArea); |
| dng_rect areaL (buffer.fArea); |
| dng_rect areaB (buffer.fArea); |
| dng_rect areaR (buffer.fArea); |
| |
| areaT.b = Min_int32 (areaT.b, fBounds.t); |
| areaL.r = Min_int32 (areaL.r, fBounds.l); |
| areaB.t = Max_int32 (areaB.t, fBounds.b); |
| areaR.l = Max_int32 (areaR.l, fBounds.r); |
| |
| dng_rect areaH (buffer.fArea); |
| dng_rect areaV (buffer.fArea); |
| |
| areaH.l = Max_int32 (areaH.l, fBounds.l); |
| areaH.r = Min_int32 (areaH.r, fBounds.r); |
| |
| areaV.t = Max_int32 (areaV.t, fBounds.t); |
| areaV.b = Min_int32 (areaV.b, fBounds.b); |
| |
| // Top left. |
| |
| dng_rect areaTL = areaT & areaL; |
| |
| if (areaTL.NotEmpty ()) |
| { |
| |
| GetEdge (buffer, |
| edgeOption, |
| dng_rect (fBounds.t, |
| fBounds.l, |
| fBounds.t + (int32)repeatV, |
| fBounds.l + (int32)repeatH), |
| areaTL); |
| |
| } |
| |
| // Top middle. |
| |
| dng_rect areaTM = areaT & areaH; |
| |
| if (areaTM.NotEmpty ()) |
| { |
| |
| GetEdge (buffer, |
| edgeOption, |
| dng_rect (fBounds.t, |
| areaTM.l, |
| fBounds.t + (int32)repeatV, |
| areaTM.r), |
| areaTM); |
| |
| } |
| |
| // Top right. |
| |
| dng_rect areaTR = areaT & areaR; |
| |
| if (areaTR.NotEmpty ()) |
| { |
| |
| GetEdge (buffer, |
| edgeOption, |
| dng_rect (fBounds.t, |
| fBounds.r - (int32)repeatH, |
| fBounds.t + (int32)repeatV, |
| fBounds.r), |
| areaTR); |
| |
| } |
| |
| // Left middle. |
| |
| dng_rect areaLM = areaL & areaV; |
| |
| if (areaLM.NotEmpty ()) |
| { |
| |
| GetEdge (buffer, |
| edgeOption, |
| dng_rect (areaLM.t, |
| fBounds.l, |
| areaLM.b, |
| fBounds.l + (int32)repeatH), |
| areaLM); |
| |
| } |
| |
| // Right middle. |
| |
| dng_rect areaRM = areaR & areaV; |
| |
| if (areaRM.NotEmpty ()) |
| { |
| |
| GetEdge (buffer, |
| edgeOption, |
| dng_rect (areaRM.t, |
| fBounds.r - (int32)repeatH, |
| areaRM.b, |
| fBounds.r), |
| areaRM); |
| |
| } |
| |
| // Bottom left. |
| |
| dng_rect areaBL = areaB & areaL; |
| |
| if (areaBL.NotEmpty ()) |
| { |
| |
| GetEdge (buffer, |
| edgeOption, |
| dng_rect (fBounds.b - (int32)repeatV, |
| fBounds.l, |
| fBounds.b, |
| fBounds.l + (int32)repeatH), |
| areaBL); |
| |
| } |
| |
| // Bottom middle. |
| |
| dng_rect areaBM = areaB & areaH; |
| |
| if (areaBM.NotEmpty ()) |
| { |
| |
| GetEdge (buffer, |
| edgeOption, |
| dng_rect (fBounds.b - (int32)repeatV, |
| areaBM.l, |
| fBounds.b, |
| areaBM.r), |
| areaBM); |
| |
| } |
| |
| // Bottom right. |
| |
| dng_rect areaBR = areaB & areaR; |
| |
| if (areaBR.NotEmpty ()) |
| { |
| |
| GetEdge (buffer, |
| edgeOption, |
| dng_rect (fBounds.b - (int32)repeatV, |
| fBounds.r - (int32)repeatH, |
| fBounds.b, |
| fBounds.r), |
| areaBR); |
| |
| } |
| |
| } |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_image::Put (const dng_pixel_buffer &buffer) |
| { |
| |
| // Move the overlapping pixels. |
| |
| dng_rect overlap = buffer.fArea & fBounds; |
| |
| if (overlap.NotEmpty ()) |
| { |
| |
| dng_pixel_buffer temp (buffer); |
| |
| temp.fArea = overlap; |
| |
| temp.fData = (void *) buffer.ConstPixel (overlap.t, |
| overlap.l, |
| buffer.fPlane); |
| |
| // Move the overlapping planes. |
| |
| if (temp.fPlane < Planes ()) |
| { |
| |
| temp.fPlanes = Min_uint32 (temp.fPlanes, |
| Planes () - temp.fPlane); |
| |
| DoPut (temp); |
| |
| } |
| |
| } |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_image::Trim (const dng_rect &r) |
| { |
| |
| if (r != Bounds ()) |
| { |
| |
| ThrowProgramError ("Trim is not support by this dng_image subclass"); |
| |
| } |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_image::Rotate (const dng_orientation &orientation) |
| { |
| |
| if (orientation != dng_orientation::Normal ()) |
| { |
| |
| ThrowProgramError ("Rotate is not support by this dng_image subclass"); |
| |
| } |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_image::CopyArea (const dng_image &src, |
| const dng_rect &area, |
| uint32 srcPlane, |
| uint32 dstPlane, |
| uint32 planes) |
| { |
| |
| if (&src == this) |
| return; |
| |
| dng_tile_iterator destIter(*this, area); |
| dng_rect destTileArea; |
| |
| while (destIter.GetOneTile(destTileArea)) |
| { |
| dng_tile_iterator srcIter(src, destTileArea); |
| dng_rect srcTileArea; |
| |
| while (srcIter.GetOneTile(srcTileArea)) |
| { |
| |
| dng_dirty_tile_buffer destTile(*this, srcTileArea); |
| dng_const_tile_buffer srcTile(src, srcTileArea); |
| |
| destTile.CopyArea (srcTile, srcTileArea, srcPlane, dstPlane, planes); |
| |
| } |
| |
| } |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| bool dng_image::EqualArea (const dng_image &src, |
| const dng_rect &area, |
| uint32 plane, |
| uint32 planes) const |
| { |
| |
| if (&src == this) |
| return true; |
| |
| dng_tile_iterator destIter (*this, area); |
| |
| dng_rect destTileArea; |
| |
| while (destIter.GetOneTile (destTileArea)) |
| { |
| |
| dng_tile_iterator srcIter (src, destTileArea); |
| |
| dng_rect srcTileArea; |
| |
| while (srcIter.GetOneTile (srcTileArea)) |
| { |
| |
| dng_const_tile_buffer destTile (*this, srcTileArea); |
| dng_const_tile_buffer srcTile (src , srcTileArea); |
| |
| if (!destTile.EqualArea (srcTile, srcTileArea, plane, planes)) |
| { |
| return false; |
| } |
| |
| } |
| |
| } |
| |
| return true; |
| |
| } |
| |
| /*****************************************************************************/ |
| |
| void dng_image::SetConstant (uint32 value, |
| const dng_rect &area) |
| { |
| |
| dng_tile_iterator iter (*this, area); |
| |
| dng_rect tileArea; |
| |
| while (iter.GetOneTile (tileArea)) |
| { |
| |
| dng_dirty_tile_buffer buffer (*this, tileArea); |
| |
| buffer.SetConstant (tileArea, |
| 0, |
| fPlanes, |
| value); |
| |
| } |
| |
| } |
| |
| /*****************************************************************************/ |
