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

// Copyright 2006-2011 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_linearization_info.cpp#1 $ */ 

/* $DateTime: 2012/05/30 13:28:51 $ */

/* $Change: 832332 $ */

/* $Author: tknoll $ */

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

#include "dng_linearization_info.h"

#include "dng_area_task.h"

#include "dng_exceptions.h"

#include "dng_host.h"

#include "dng_image.h"

#include "dng_info.h"

#include "dng_negative.h"

#include "dng_pixel_buffer.h"

#include "dng_safe_arithmetic.h"

#include "dng_tag_types.h"

#include "dng_tile_iterator.h"

#include "dng_utils.h"

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

class dng_linearize_plane

  {

  private:

    const dng_image & fSrcImage;

          dng_image & fDstImage;

    uint32 fPlane;

    dng_rect fActiveArea;

    uint32 fSrcPixelType;

    uint32 fDstPixelType;

    bool fReal32;

    real32 fScale;

    AutoPtr<dng_memory_block> fScale_buffer;

    uint32 fBlack_2D_rows;

    uint32 fBlack_2D_cols;

    AutoPtr<dng_memory_block> fBlack_2D_buffer;

    uint32 fBlack_1D_rows;

    AutoPtr<dng_memory_block> fBlack_1D_buffer;

  public:

    dng_linearize_plane (dng_host &host,

               dng_linearization_info &info,

               const dng_image &srcImage,

               dng_image &dstImage,

               uint32 plane);

    ~dng_linearize_plane ();

    void Process (const dng_rect &tile);

  };

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

dng_linearize_plane::dng_linearize_plane (dng_host &host,

                      dng_linearization_info &info,

                      const dng_image &srcImage,

                      dng_image &dstImage,

                      uint32 plane)

  : fSrcImage (srcImage)

  , fDstImage (dstImage)

  , fPlane (plane)

  , fActiveArea (info.fActiveArea)

  , fSrcPixelType (srcImage.PixelType ())

  , fDstPixelType (dstImage.PixelType ())

  , fReal32 (false)

  , fScale (0.0f)

  , fScale_buffer ()

  , fBlack_2D_rows (0)

  , fBlack_2D_cols (0)

  , fBlack_2D_buffer ()

  , fBlack_1D_rows (0)

  , fBlack_1D_buffer ()

  {

  uint32 j;

  uint32 k;

  // Make sure the source pixel type is supported.

  if (fSrcPixelType != ttByte  &&

    fSrcPixelType != ttShort &&

    fSrcPixelType != ttLong  &&

    fSrcPixelType != ttFloat)

    {

    DNG_REPORT ("Unsupported source pixel type");

    ThrowProgramError ();

    }

  if (fDstPixelType != ttShort &&

    fDstPixelType != ttFloat)

    {

    DNG_REPORT ("Unsupported destination pixel type");

    ThrowProgramError ();

    }

  if (fSrcPixelType == ttFloat &&

    fDstPixelType != ttFloat)

    {

    DNG_REPORT ("Cannot convert floating point stage1 to non-floating stage2");

    ThrowProgramError ();

    }

  // Are we using floating point math?

  fReal32 = (fSrcPixelType == ttLong ||

         fDstPixelType == ttFloat);

  // Find the scale for this plane.

  real64 maxBlack = info.MaxBlackLevel (plane);

  real64 minRange = info.fWhiteLevel [plane] - maxBlack;

  if (minRange <= 0.0)

    {

    ThrowBadFormat ();

    }

  real64 scale = 1.0 / minRange;

  fScale = (real32) scale;

  // Calculate two-dimensional black pattern, if any.

  if (info.fBlackDeltaH.Get ())

    {

    fBlack_2D_rows = info.fBlackLevelRepeatRows;

    fBlack_2D_cols = info.fActiveArea.W ();

    }

  else if (info.fBlackLevelRepeatCols > 1)

    {

    fBlack_2D_rows = info.fBlackLevelRepeatRows;

    fBlack_2D_cols = info.fBlackLevelRepeatCols;

    }

  if (fBlack_2D_rows)

    {

    fBlack_2D_buffer.Reset (host.Allocate (

      SafeUint32Mult (fBlack_2D_rows, fBlack_2D_cols, 4)));

    for (j = 0; j < fBlack_2D_rows; j++)

      {

      for (k = 0;  k < fBlack_2D_cols; k++)

        {

        real64 x = info.fBlackLevel [j]

                      [k % info.fBlackLevelRepeatCols]

                      [plane];

        if (info.fBlackDeltaH.Get ())

          {

          x += info.fBlackDeltaH->Buffer_real64 () [k];

          }

        x *= scale;

        uint32 index = j * fBlack_2D_cols + k;

        if (fReal32)

          {

          fBlack_2D_buffer->Buffer_real32 () [index] = (real32) x;

          }

        else

          {

          x *= 0x0FFFF * 256.0;

          int32 y = Round_int32 (x);

          fBlack_2D_buffer->Buffer_int32 () [index] = y;

          }

        }

      }

    }

  // Calculate one-dimensional (per row) black pattern, if any.

  if (info.fBlackDeltaV.Get ())

    {

    fBlack_1D_rows = info.fActiveArea.H ();

    }

  else if (fBlack_2D_rows == 0 &&

       (info.fBlackLevelRepeatRows > 1 || fSrcPixelType != ttShort))

    {

    fBlack_1D_rows = info.fBlackLevelRepeatRows;

    }

  if (fBlack_1D_rows)

    {

    fBlack_1D_buffer.Reset (host.Allocate (

      SafeUint32Mult(fBlack_1D_rows, 4)));

    bool allZero = true;

    for (j = 0; j < fBlack_1D_rows; j++)

      {

      real64 x = 0.0;

      if (fBlack_2D_rows == 0)

        {

        x = info.fBlackLevel [j % info.fBlackLevelRepeatRows] 

                   [0] 

                   [plane];

        }

      if (info.fBlackDeltaV.Get ())

        {

        x += info.fBlackDeltaV->Buffer_real64 () [j];

        }

      allZero = allZero && (x == 0.0);

      x *= scale;

      if (fReal32)

        {

        fBlack_1D_buffer->Buffer_real32 () [j] = (real32) x;

        }

      else

        {

        x *= 0x0FFFF * 256.0;

        int32 y = Round_int32 (x);

        fBlack_1D_buffer->Buffer_int32 () [j] = y;

        }

      }

    if (allZero)

      {

      fBlack_1D_rows = 0;

      fBlack_1D_buffer.Reset ();

      }

    }

  // Calculate scale table, if any.

  if (fSrcPixelType != ttLong &&

    fSrcPixelType != ttFloat)

    {

    // Find linearization table, if any.

    uint16 *lut = NULL;

    uint32 lutEntries = 0;

    if (info.fLinearizationTable.Get ())

      {

      lut = info.fLinearizationTable->Buffer_uint16 ();

      lutEntries = info.fLinearizationTable->LogicalSize () >> 1;

      }

    // If the black level does not vary from pixel to pixel, then

    // the entire process can be a single LUT.

    if (fBlack_1D_rows == 0 &&

        fBlack_2D_rows == 0)

      {

      fScale_buffer.Reset (host.Allocate (0x10000 *

                          TagTypeSize (fDstPixelType)));

      for (j = 0; j < 0x10000; j++)

        {

        uint32 x = j;

        // Apply linearization table, if any.

        if (lut)

          {

          x = Min_uint32 (x, lutEntries - 1);

          x = lut [x];

          }

        // Subtract constant black level.

        real64 y = x - info.fBlackLevel [0] [0] [plane];

        // Apply scale.

        y *= scale;

        // We can burn in the clipping also.

        y = Pin_real64 (0.0, y, 1.0);

        // Store output value in table.

        if (fDstPixelType == ttShort)

          {

          uint16 z = (uint16) Round_uint32 (y * 0x0FFFF);

          fScale_buffer->Buffer_uint16 () [j] = z;

          }

        else

          {

          fScale_buffer->Buffer_real32 () [j] = (real32) y;

          }

        }

      }

    // Else we only do the scaling operation in the scale table.

    else

      {

      fScale_buffer.Reset (host.Allocate (0x10000 * 4));

      for (j = 0; j < 0x10000; j++)

        {

        uint32 x = j;

        // Apply linearization table, if any.

        if (lut)

          {

          x = Min_uint32 (x, lutEntries - 1);

          x = lut [x];

          }

        // Apply scale.

        real64 y = x * scale;

        // Store output value in table.

        if (fReal32)

          {

          fScale_buffer->Buffer_real32 () [j] = (real32) y;

          }

        else

          {

          int32 z = Round_int32 (y * 0x0FFFF * 256.0);

          fScale_buffer->Buffer_int32 () [j] = z;

          }

        }

      }

    }

  }

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

dng_linearize_plane::~dng_linearize_plane ()

  {

  }

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

void dng_linearize_plane::Process (const dng_rect &srcTile)

  {

  // Process tile.

  dng_rect dstTile = srcTile - fActiveArea.TL ();

  dng_const_tile_buffer srcBuffer (fSrcImage, srcTile);

  dng_dirty_tile_buffer dstBuffer (fDstImage, dstTile);

  int32 sStep = srcBuffer.fColStep;

  int32 dStep = dstBuffer.fColStep;

  uint32 count = srcTile.W ();

  uint32 dstCol = dstTile.l;

  uint32 rows = srcTile.H ();

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

    {

    uint32 dstRow = dstTile.t + row;

    const void *sPtr = srcBuffer.ConstPixel (srcTile.t + row,

                           srcTile.l,

                           fPlane);

    void *dPtr = dstBuffer.DirtyPixel (dstRow,

                       dstCol,

                       fPlane);

    // Floating point source case.

    if (fSrcPixelType == ttFloat)

      {

      real32 scale = fScale;

      const real32 *srcPtr = (const real32 *) sPtr;

      real32 *dstPtr = (real32 *) dPtr;

      // Optimize scale only case, which is the most common.

      if (fBlack_1D_rows == 0 &&

        fBlack_2D_cols == 0)

        {

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

          {

          *dstPtr = (*srcPtr) * scale;

          srcPtr += sStep;

          dstPtr += dStep;

          }

        }

      else

        {

        real32 b1 = 0.0f;

        if (fBlack_1D_rows)

          {

          b1 = fBlack_1D_buffer->Buffer_real32 () [dstRow % fBlack_1D_rows];

          }

        const real32 *b2 = NULL;

        uint32 b2_count = fBlack_2D_cols;

        uint32 b2_phase = 0;

        if (b2_count)

          {

          b2 = fBlack_2D_buffer->Buffer_real32 () +

             b2_count * (dstRow % fBlack_2D_rows);

          b2_phase = dstCol % b2_count;

          }

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

          {

          real32 x = (*srcPtr) * scale - b1;

          if (b2_count)

            {

            x -= b2 [b2_phase];

            if (++b2_phase == b2_count)

              {

              b2_phase = 0;

              }

            }

          *dstPtr = x;

          srcPtr += sStep;

          dstPtr += dStep;

          }

        }

      }

    // Simple LUT case.

    else if (fBlack_1D_rows == 0 &&

         fBlack_2D_rows == 0 && fSrcPixelType != ttLong)

      {

      if (fDstPixelType == ttShort)

        {

        const uint16 *lut = fScale_buffer->Buffer_uint16 ();

        uint16 *dstPtr = (uint16 *) dPtr;

        if (fSrcPixelType == ttByte)

          {

          const uint8 *srcPtr = (const uint8 *) sPtr;

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

            {

            *dstPtr = lut [*srcPtr];

            srcPtr += sStep;

            dstPtr += dStep;

            }

          }

        else

          {

          const uint16 *srcPtr = (const uint16 *) sPtr;

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

            {

            *dstPtr = lut [*srcPtr];

            srcPtr += sStep;

            dstPtr += dStep;

            }

          }

        }

      else

        {

        const real32 *lut = fScale_buffer->Buffer_real32 ();

        real32 *dstPtr = (real32 *) dPtr;

        if (fSrcPixelType == ttByte)

          {

          const uint8 *srcPtr = (const uint8 *) sPtr;

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

            {

            *dstPtr = lut [*srcPtr];

            srcPtr += sStep;

            dstPtr += dStep;

            }

          }

        else

          {

          const uint16 *srcPtr = (const uint16 *) sPtr;

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

            {

            *dstPtr = lut [*srcPtr];

            srcPtr += sStep;

            dstPtr += dStep;

            }

          }

        }

      }

    // Integer math case.

    else if (!fReal32)

      {

      const int32 *lut = fScale_buffer->Buffer_int32 ();

      int32 b1 = 0;

      if (fBlack_1D_rows)

        {

        b1 = fBlack_1D_buffer->Buffer_int32 () [dstRow % fBlack_1D_rows];

        }

      const int32 *b2 = NULL;

      uint32 b2_count = fBlack_2D_cols;

      uint32 b2_phase = 0;

      if (b2_count)

        {

        b2 = fBlack_2D_buffer->Buffer_int32 () +

           b2_count * (dstRow % fBlack_2D_rows);

        b2_phase = dstCol % b2_count;

        }

      uint16 *dstPtr = (uint16 *) dPtr;

      b1 -= 128;    // Rounding for 8 bit shift

      if (fSrcPixelType == ttByte)

        {

        const uint8 *srcPtr = (const uint8 *) sPtr;

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

          {

          int32 x = lut [*srcPtr] - b1;

          if (b2_count)

            {

            x -= b2 [b2_phase];

            if (++b2_phase == b2_count)

              {

              b2_phase = 0;

              }

            }

          x >>= 8;

          *dstPtr = Pin_uint16 (x);

          srcPtr += sStep;

          dstPtr += dStep;

          }

        }

      else

        {

        const uint16 *srcPtr = (const uint16 *) sPtr;

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

          {

          int32 x = lut [*srcPtr] - b1;

          if (b2_count)

            {

            x -= b2 [b2_phase];

            if (++b2_phase == b2_count)

              {

              b2_phase = 0;

              }

            }

          x >>= 8;

          *dstPtr = Pin_uint16 (x);

          srcPtr += sStep;

          dstPtr += dStep;

          }

        }

      }

    // Floating point math cases.

    else

      {

      real32 b1 = 0.0f;

      if (fBlack_1D_rows)

        {

        b1 = fBlack_1D_buffer->Buffer_real32 () [dstRow % fBlack_1D_rows];

        }

      const real32 *b2 = NULL;

      uint32 b2_count = fBlack_2D_cols;

      uint32 b2_phase = 0;

      if (b2_count)

        {

        b2 = fBlack_2D_buffer->Buffer_real32 () +

           b2_count * (dstRow % fBlack_2D_rows);

        b2_phase = dstCol % b2_count;

        }

      // Case 1: uint8/uint16 -> real32

      if (fSrcPixelType != ttLong)

        {

        const real32 *lut = fScale_buffer->Buffer_real32 ();

        real32 *dstPtr = (real32 *) dPtr;

        if (fSrcPixelType == ttByte)

          {

          const uint8 *srcPtr = (const uint8 *) sPtr;

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

            {

            real32 x = lut [*srcPtr] - b1;

            if (b2_count)

              {

              x -= b2 [b2_phase];

              if (++b2_phase == b2_count)

                {

                b2_phase = 0;

                }

              }

            x = Pin_real32 (0.0f, x, 1.0f);

            *dstPtr = x;

            srcPtr += sStep;

            dstPtr += dStep;

            }

          }

        else

          {

          const uint16 *srcPtr = (const uint16 *) sPtr;

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

            {

            real32 x = lut [*srcPtr] - b1;

            if (b2_count)

              {

              x -= b2 [b2_phase];

              if (++b2_phase == b2_count)

                {

                b2_phase = 0;

                }

              }

            x = Pin_real32 (0.0f, x, 1.0f);

            *dstPtr = x;

            srcPtr += sStep;

            dstPtr += dStep;

            }

          }

        }

      // Otherwise source is uint32

      else

        {

        real32 scale = fScale;

        const uint32 *srcPtr = (const uint32 *) sPtr;

        // Case 2: uint32 -> real32

        if (fDstPixelType == ttFloat)

          {

          real32 *dstPtr = (real32 *) dPtr;

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

            {

            real32 x = ((real32) *srcPtr) * scale - b1;

            if (b2_count)

              {

              x -= b2 [b2_phase];

              if (++b2_phase == b2_count)

                {

                b2_phase = 0;

                }

              }

            x = Pin_real32 (0.0f, x, 1.0f);

            *dstPtr = x;

            srcPtr += sStep;

            dstPtr += dStep;

            }

          }

        // Case 3: uint32 -> uint16

        else

          {

          uint16 *dstPtr = (uint16 *) dPtr;

          real32 dstScale = (real32) 0x0FFFF;

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

            {

            real32 x = ((real32) *srcPtr) * scale - b1;

            if (b2_count)

              {

              x -= b2 [b2_phase];

              if (++b2_phase == b2_count)

                {

                b2_phase = 0;

                }

              }

            x = Pin_real32 (0.0f, x, 1.0f);

            *dstPtr = (uint16) (x * dstScale + 0.5f);

            srcPtr += sStep;

            dstPtr += dStep;

            }

          }

        }

      }

    }

  }

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

class dng_linearize_image: public dng_area_task

  {

  private:

    const dng_image & fSrcImage;

          dng_image & fDstImage;

    dng_rect fActiveArea;

    AutoPtr<dng_linearize_plane> fPlaneTask [kMaxColorPlanes];

  public:

    dng_linearize_image (dng_host &host,

               dng_linearization_info &info,

               const dng_image &srcImage,

               dng_image &dstImage);

    virtual ~dng_linearize_image ();

    virtual dng_rect RepeatingTile1 () const;

    virtual dng_rect RepeatingTile2 () const;

    virtual void Process (uint32 threadIndex,

                const dng_rect &tile,

                dng_abort_sniffer *sniffer);

  };

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

dng_linearize_image::dng_linearize_image (dng_host &host,

                      dng_linearization_info &info,

                      const dng_image &srcImage,

                      dng_image &dstImage)

  : fSrcImage   (srcImage)

  , fDstImage   (dstImage)

  , fActiveArea (info.fActiveArea)

  {

  // Build linearization table for each plane.

  for (uint32 plane = 0; plane < srcImage.Planes (); plane++)

    {

    fPlaneTask [plane].Reset (new dng_linearize_plane (host,

                               info,

                               srcImage,

                               dstImage,

                               plane));

    }

  // Adjust maximum tile size.

  fMaxTileSize = dng_point (1024, 1024);

  }

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

dng_linearize_image::~dng_linearize_image ()

  {

  }

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

dng_rect dng_linearize_image::RepeatingTile1 () const

  {

  return fSrcImage.RepeatingTile ();

  }

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