/*****************************************************************************/

// 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_read_image.cpp#7 $ */ 

/* $DateTime: 2012/07/31 22:04:34 $ */

/* $Change: 840853 $ */

/* $Author: tknoll $ */

/*****************************************************************************/

#include "dng_read_image.h"

#include "dng_abort_sniffer.h"

#include "dng_area_task.h"

#include "dng_bottlenecks.h"

#include "dng_exceptions.h"

#include "dng_flags.h"

#include "dng_host.h"

#include "dng_image.h"

#include "dng_ifd.h"

#include "dng_jpeg_image.h"

#include "dng_lossless_jpeg.h"

#include "dng_mutex.h"

#include "dng_memory.h"

#include "dng_pixel_buffer.h"

#include "dng_safe_arithmetic.h"

#include "dng_tag_types.h"

#include "dng_tag_values.h"

#include "dng_utils.h"

#include "zlib.h"

#if qDNGUseLibJPEG

#include "dng_jpeg_memory_source.h"

#include "dng_jpeglib.h"

#endif

#include <limits>

/******************************************************************************/

static void DecodeDelta8 (uint8 *dPtr,

              uint32 rows,

              uint32 cols,

              uint32 channels)

  {

  const uint32 dRowStep = cols * channels;

  for (uint32 row = 0; row < rows; row++)

    {

    for (uint32 col = 1; col < cols; col++)

      {

      for (uint32 channel = 0; channel < channels; channel++)

        {

        dPtr [col * channels + channel] += dPtr [(col - 1) * channels + channel];

        }

      }

    dPtr += dRowStep;

    }

  }

/******************************************************************************/

static void DecodeDelta16 (uint16 *dPtr,

               uint32 rows,

               uint32 cols,

               uint32 channels)

  {

  const uint32 dRowStep = cols * channels;

  for (uint32 row = 0; row < rows; row++)

    {

    for (uint32 col = 1; col < cols; col++)

      {

      for (uint32 channel = 0; channel < channels; channel++)

        {

        dPtr [col * channels + channel] += dPtr [(col - 1) * channels + channel];

        }

      }

    dPtr += dRowStep;

    }

  }

/******************************************************************************/

static void DecodeDelta32 (uint32 *dPtr,

               uint32 rows,

               uint32 cols,

               uint32 channels)

  {

  const uint32 dRowStep = cols * channels;

  for (uint32 row = 0; row < rows; row++)

    {

    for (uint32 col = 1; col < cols; col++)

      {

      for (uint32 channel = 0; channel < channels; channel++)

        {

        dPtr [col * channels + channel] += dPtr [(col - 1) * channels + channel];

        }

      }

    dPtr += dRowStep;

    }

  }

/*****************************************************************************/

inline void DecodeDeltaBytes (uint8 *bytePtr, int32 cols, int32 channels)

  {

  if (channels == 1)

    {

    uint8 b0 = bytePtr [0];

    bytePtr += 1;

    for (int32 col = 1; col < cols; ++col)

      {

      b0 += bytePtr [0];

      bytePtr [0] = b0;

      bytePtr += 1;

      }

    }

  else if (channels == 3)

    {

    uint8 b0 = bytePtr [0];

    uint8 b1 = bytePtr [1];

    uint8 b2 = bytePtr [2];

    bytePtr += 3;

    for (int32 col = 1; col < cols; ++col)

      {

      b0 += bytePtr [0];

      b1 += bytePtr [1];

      b2 += bytePtr [2];

      bytePtr [0] = b0;

      bytePtr [1] = b1;

      bytePtr [2] = b2;

      bytePtr += 3;

      }

    }

  else if (channels == 4)

    {

    uint8 b0 = bytePtr [0];

    uint8 b1 = bytePtr [1];

    uint8 b2 = bytePtr [2];

    uint8 b3 = bytePtr [3];

    bytePtr += 4;

    for (int32 col = 1; col < cols; ++col)

      {

      b0 += bytePtr [0];

      b1 += bytePtr [1];

      b2 += bytePtr [2];

      b3 += bytePtr [3];

      bytePtr [0] = b0;

      bytePtr [1] = b1;

      bytePtr [2] = b2;

      bytePtr [3] = b3;

      bytePtr += 4;

      }

    }

  else

    {

    for (int32 col = 1; col < cols; ++col)

      {

      for (int32 chan = 0; chan < channels; ++chan)

        {

        bytePtr [chan + channels] += bytePtr [chan];

        }

      bytePtr += channels;

      }

    }

  }

/*****************************************************************************/

static void DecodeFPDelta (uint8 *input,

               uint8 *output,

               int32 cols,

               int32 channels,

               int32 bytesPerSample)

  {

  DecodeDeltaBytes (input, cols * bytesPerSample, channels);

  int32 rowIncrement = cols * channels;

  if (bytesPerSample == 2)

    {

    #if qDNGBigEndian

    const uint8 *input0 = input;

    const uint8 *input1 = input + rowIncrement;

    #else

    const uint8 *input1 = input;

    const uint8 *input0 = input + rowIncrement;

    #endif

    for (int32 col = 0; col < rowIncrement; ++col)

      {

      output [0] = input0 [col];

      output [1] = input1 [col];

      output += 2;

      }

    }

  else if (bytesPerSample == 3)

    {

    const uint8 *input0 = input;

    const uint8 *input1 = input + rowIncrement;

    const uint8 *input2 = input + rowIncrement * 2;

    for (int32 col = 0; col < rowIncrement; ++col)

      {

      output [0] = input0 [col];

      output [1] = input1 [col];

      output [2] = input2 [col];

      output += 3;

      }

    }

  else

    {

    #if qDNGBigEndian

    const uint8 *input0 = input;

    const uint8 *input1 = input + rowIncrement;

    const uint8 *input2 = input + rowIncrement * 2;

    const uint8 *input3 = input + rowIncrement * 3;

    #else

    const uint8 *input3 = input;

    const uint8 *input2 = input + rowIncrement;

    const uint8 *input1 = input + rowIncrement * 2;

    const uint8 *input0 = input + rowIncrement * 3;

    #endif

    for (int32 col = 0; col < rowIncrement; ++col)

      {

      output [0] = input0 [col];

      output [1] = input1 [col];

      output [2] = input2 [col];

      output [3] = input3 [col];

      output += 4;

      }

    }

  }  

/*****************************************************************************/

bool DecodePackBits (dng_stream &stream,

           uint8 *dPtr,

           int32 dstCount)

  {

  while (dstCount > 0)

    {

    int32 runCount = (int8) stream.Get_uint8 ();

    if (runCount >= 0)

      {

      ++runCount;

      dstCount -= runCount;

      if (dstCount < 0)

        return false;

      stream.Get (dPtr, runCount);

      dPtr += runCount;

      }

    else

      {

      runCount = -runCount + 1;

      dstCount -= runCount;

      if (dstCount < 0)

        return false;

      uint8 x = stream.Get_uint8 ();

      while (runCount--)

        {

        *(dPtr++) = x;

        }

      }

    }

  return true;

  }

/******************************************************************************/

class dng_lzw_expander

  {

  private:

    enum

      {

      kResetCode = 256,

      kEndCode   = 257,

      kTableSize = 4096

      };

    struct LZWExpanderNode

      {

      int16 prefix;

      int16 final;

      int16 depth;

      int16 fake_for_padding;

      };

    dng_memory_data fBuffer;

    LZWExpanderNode *fTable;

    const uint8 *fSrcPtr;

    int32 fSrcCount;

    int32 fByteOffset;

    uint32 fBitBuffer;

    int32 fBitBufferCount;

    int32 fNextCode;

    int32 fCodeSize;

  public:

    dng_lzw_expander ();

    bool Expand (const uint8 *sPtr,

           uint8 *dPtr,

           int32 sCount,

           int32 dCount);

  private:

    void InitTable ();

    void AddTable (int32 w, int32 k);

    bool GetCodeWord (int32 &code);

    // Hidden copy constructor and assignment operator.

    dng_lzw_expander (const dng_lzw_expander &expander);

    dng_lzw_expander & operator= (const dng_lzw_expander &expander);

  };

/******************************************************************************/

dng_lzw_expander::dng_lzw_expander ()

  : fBuffer      ()

  , fTable       (NULL)

  , fSrcPtr      (NULL)

  , fSrcCount    (0)

  , fByteOffset    (0)

  , fBitBuffer     (0)

  , fBitBufferCount  (0)

  , fNextCode    (0)

  , fCodeSize    (0)

  {

  fBuffer.Allocate (kTableSize * sizeof (LZWExpanderNode));

  fTable = (LZWExpanderNode *) fBuffer.Buffer ();

  }

/******************************************************************************/

void dng_lzw_expander::InitTable ()

  {

  fCodeSize = 9;

  fNextCode = 258;

  LZWExpanderNode *node = &fTable [0];

  for (int32 code = 0; code < 256; code++)

    {

    node->prefix  = -1;

    node->final   = (int16) code;

    node->depth   = 1;

    node++;

    }

  }

/******************************************************************************/

void dng_lzw_expander::AddTable (int32 w, int32 k)

  {

  DNG_ASSERT ((w >= 0) && (w <= kTableSize),

        "bad w value in dng_lzw_expander::AddTable");

  LZWExpanderNode *parentNode = &fTable [w];

  int32 nextCode = fNextCode;

  fNextCode++;

  DNG_ASSERT ((nextCode >= 0) && (nextCode <= kTableSize),

        "bad fNextCode value in dng_lzw_expander::AddTable");

  LZWExpanderNode *node = &fTable [nextCode];

  node->prefix  = (int16) w;

  node->final   = (int16) k;

  node->depth   = 1 + parentNode->depth;

  if (nextCode + 1 == (1 << fCodeSize) - 1)

    {

    if (fCodeSize != 12)

      fCodeSize++;

    }

  }

/******************************************************************************/

bool dng_lzw_expander::GetCodeWord (int32 &code)

  {

  // The bit buffer has the current code in the most significant bits,

  // so shift off the low orders.

  int32 codeSize = fCodeSize;

  code = fBitBuffer >> (32 - codeSize);

  if (fBitBufferCount >= codeSize)

    {

    // Typical case; get the code from the bit buffer.

    fBitBuffer     <<= codeSize;

    fBitBufferCount -= codeSize;

    }

  else

    {

    // The buffer needs to be refreshed.

    const int32 bitsSoFar = fBitBufferCount;

    if (fByteOffset >= fSrcCount)

      return false;

    // Buffer a long word

    const uint8 *ptr = fSrcPtr + fByteOffset;

    #if qDNGBigEndian

    fBitBuffer = *((const uint32 *) ptr);

    #else

      {

      uint32 b0 = ptr [0];

      uint32 b1 = ptr [1];

      uint32 b2 = ptr [2];

      uint32 b3 = ptr [3];

      fBitBuffer = (((((b0 << 8) | b1) << 8) | b2) << 8) | b3;

      }

    #endif

    fBitBufferCount = 32;

    fByteOffset += 4;

    // Number of additional bits we need

    const int32 bitsUsed = codeSize - bitsSoFar;

    // Number of low order bits in the current buffer we don't care about

    const int32 bitsNotUsed = 32 - bitsUsed;

    code |= fBitBuffer >> bitsNotUsed;

    fBitBuffer     <<= bitsUsed;

    fBitBufferCount -= bitsUsed;

    }

  return true;

  }

/******************************************************************************/

bool dng_lzw_expander::Expand (const uint8 *sPtr,

                   uint8 *dPtr,

                   int32 sCount,

                   int32 dCount)

  {

  void *dStartPtr = dPtr;

  fSrcPtr = sPtr;

  fSrcCount = sCount;

  fByteOffset = 0;

  /* the master decode loop */

  while (true)

    {

    InitTable ();

    int32 code;

    do

      {

      if (!GetCodeWord (code)) 

        return false;

      DNG_ASSERT (code <= fNextCode,

            "Unexpected LZW code in dng_lzw_expander::Expand");

      }

    while (code == kResetCode);

    if (code == kEndCode) 

      return true;

    if (code > kEndCode) 

      return false;

    int32 oldCode = code;

    int32 inChar  = code;

    *(dPtr++) = (uint8) code;

    if (--dCount == 0) 

      return true;

    while (true)

      {

      if (!GetCodeWord (code)) 

        return false;

      if (code == kResetCode) 

        break;

      if (code == kEndCode) 

        return true;

      const int32 inCode = code;

      bool repeatLastPixel = false;

      if (code >= fNextCode)

        {

        // This is either a bad file or our code table is not big enough; we

        // are going to repeat the last code seen and attempt to muddle thru.

        code = oldCode; 

        repeatLastPixel = true;

        }

      // this can only happen if we hit 2 bad codes in a row

      if (code > fNextCode)

        return false;

      const int32 depth = fTable [code].depth;

      if (depth < dCount)

        {

        dCount -= depth;

        dPtr += depth;

        uint8 *ptr = dPtr;

        // give the compiler an extra hint to optimize these as registers

        const LZWExpanderNode *localTable = fTable;

        int32 localCode = code;

        // this is usually the hottest loop in LZW expansion

        while (localCode >= kResetCode)

          {

          if (ptr <= dStartPtr)

            return false;   // about to trash memory

          const LZWExpanderNode &node = localTable [localCode];

          uint8 tempFinal = (uint8) node.final;

          localCode = node.prefix;

          // Check for bogus table entry

          if (localCode < 0 || localCode > kTableSize)

            return false;

          *(--ptr) = tempFinal;

          }

        code = localCode;

        inChar = localCode;

        if (ptr <= dStartPtr)

          return false;   // about to trash memory

        *(--ptr) = (uint8) inChar;

        }

      else

        {

        // There might not be enough room for the full code

        // so skip the end of it.

        const int32 skip = depth - dCount;

        for (int32 i = 0; i < skip ; i++)

          {

          const LZWExpanderNode &node = fTable [code];

          code = node.prefix;

          }

        int32 depthUsed = depth - skip;

        dCount -= depthUsed;

        dPtr += depthUsed;

        uint8 *ptr = dPtr;

        while (code >= 0)

          {

          if (ptr <= dStartPtr)

            return false;   // about to trash memory

          const LZWExpanderNode &node = fTable [code];

          *(--ptr) = (uint8) node.final;

          code = node.prefix;

          // Check for bogus table entry

          if (code > kTableSize)

            return false;

          }

        return true;

        }

      if (repeatLastPixel)

        {

        *(dPtr++) = (uint8) inChar;

        if (--dCount == 0)

          return true;

        }

      if (fNextCode < kTableSize)

        {

        AddTable (oldCode, code);

        }

      oldCode = inCode;

      }

    } 

  return false;

  }

/*****************************************************************************/

dng_row_interleaved_image::dng_row_interleaved_image (dng_image &image,

                            uint32 factor)

  : dng_image (image.Bounds    (),

           image.Planes    (),

           image.PixelType ())

  , fImage  (image )

  , fFactor (factor)

  {

  }

/*****************************************************************************/

int32 dng_row_interleaved_image::MapRow (int32 row) const

  {

  uint32 rows = Height ();

  int32 top = Bounds ().t;

  uint32 fieldRow = row - top;

  for (uint32 field = 0; true; field++)

    {

    uint32 fieldRows = (rows - field + fFactor - 1) / fFactor;

    if (fieldRow < fieldRows)

      {

      return fieldRow * fFactor + field + top;

      }

    fieldRow -= fieldRows;

    }

  ThrowProgramError ();

  return 0;

  }

/*****************************************************************************/

void dng_row_interleaved_image::DoGet (dng_pixel_buffer &buffer) const

  {

  dng_pixel_buffer tempBuffer (buffer);

  for (int32 row = buffer.fArea.t; row < buffer.fArea.b; row++)

    {

    tempBuffer.fArea.t = MapRow (row);

    tempBuffer.fArea.b = tempBuffer.fArea.t + 1;

    tempBuffer.fData = (void *) buffer.DirtyPixel (row,

                             buffer.fArea.l,

                             buffer.fPlane);

    fImage.Get (tempBuffer);

    }

  }

/*****************************************************************************/

void dng_row_interleaved_image::DoPut (const dng_pixel_buffer &buffer)

  {

  dng_pixel_buffer tempBuffer (buffer);

  for (int32 row = buffer.fArea.t; row < buffer.fArea.b; row++)

    {

    tempBuffer.fArea.t = MapRow (row);

    tempBuffer.fArea.b = tempBuffer.fArea.t + 1;

    tempBuffer.fData = (void *) buffer.ConstPixel (row,

                             buffer.fArea.l,

                             buffer.fPlane);

    fImage.Put (tempBuffer);

    }

  }

/*****************************************************************************/

static void ReorderSubTileBlocks (dng_host &host,

                  const dng_ifd &ifd,

                  dng_pixel_buffer &buffer,

                  AutoPtr<dng_memory_block> &tempBuffer)

  {

  uint32 tempBufferSize = ComputeBufferSize(buffer.fPixelType,

                        buffer.fArea.Size(),

                        buffer.fPlanes, padNone);

  if (!tempBuffer.Get () || tempBuffer->LogicalSize () < tempBufferSize)

    {

    tempBuffer.Reset (host.Allocate (tempBufferSize));

    }

  uint32 blockRows = ifd.fSubTileBlockRows;

  uint32 blockCols = ifd.fSubTileBlockCols;

  uint32 rowBlocks = buffer.fArea.H () / blockRows;

  uint32 colBlocks = buffer.fArea.W () / blockCols;

  int32 rowStep = buffer.fRowStep * buffer.fPixelSize;

  int32 colStep = buffer.fColStep * buffer.fPixelSize;

  int32 rowBlockStep = rowStep * blockRows;

  int32 colBlockStep = colStep * blockCols;

  uint32 blockColBytes = blockCols * buffer.fPlanes * buffer.fPixelSize;

  const uint8 *s0 = (const uint8 *) buffer.fData;

        uint8 *d0 = tempBuffer->Buffer_uint8 ();

  for (uint32 rowBlock = 0; rowBlock < rowBlocks; rowBlock++)

    {

    uint8 *d1 = d0;

    for (uint32 colBlock = 0; colBlock < colBlocks; colBlock++)

      {

      uint8 *d2 = d1;

      for (uint32 blockRow = 0; blockRow < blockRows; blockRow++)

        {

        for (uint32 j = 0; j < blockColBytes; j++)

          {

          d2 [j] = s0 [j];

          }

        s0 += blockColBytes;

        d2 += rowStep;

        }

      d1 += colBlockStep;