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

// Copyright 2008-2009 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_misc_opcodes.cpp#1 $ */ 

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

/* $Change: 832332 $ */

/* $Author: tknoll $ */

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

#include "dng_misc_opcodes.h"

#include "dng_bottlenecks.h"

#include "dng_exceptions.h"

#include "dng_globals.h"

#include "dng_host.h"

#include "dng_image.h"

#include "dng_rect.h"

#include "dng_safe_arithmetic.h"

#include "dng_stream.h"

#include "dng_tag_values.h"

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

dng_opcode_TrimBounds::dng_opcode_TrimBounds (const dng_rect &bounds)

  : dng_opcode (dngOpcode_TrimBounds,

          dngVersion_1_3_0_0,

          kFlag_None)

  , fBounds (bounds)

  {

  }

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

dng_opcode_TrimBounds::dng_opcode_TrimBounds (dng_stream &stream)

  : dng_opcode (dngOpcode_TrimBounds,

          stream,

          "TrimBounds")

  , fBounds ()

  {

  if (stream.Get_uint32 () != 16)

    {

    ThrowBadFormat ();

    }

  fBounds.t = stream.Get_int32 ();

  fBounds.l = stream.Get_int32 ();

  fBounds.b = stream.Get_int32 ();

  fBounds.r = stream.Get_int32 ();

  if (fBounds.IsEmpty ())

    {

    ThrowBadFormat ();

    }

  #if qDNGValidate

  if (gVerbose)

    {

    printf ("Bounds: t=%d, l=%d, b=%d, r=%d\n",

        (int) fBounds.t,

        (int) fBounds.l,

        (int) fBounds.b,

        (int) fBounds.r);

    }

  #endif

  }

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

void dng_opcode_TrimBounds::PutData (dng_stream &stream) const

  {

  stream.Put_uint32 (16);

  stream.Put_int32 (fBounds.t);

  stream.Put_int32 (fBounds.l);

  stream.Put_int32 (fBounds.b);

  stream.Put_int32 (fBounds.r);

  }

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

void dng_opcode_TrimBounds::Apply (dng_host & /* host */,

                   dng_negative & /* negative */,

                   AutoPtr<dng_image> &image)

  {

  if (fBounds.IsEmpty () || (fBounds & image->Bounds ()) != fBounds)

    {

    ThrowBadFormat ();

    }

  image->Trim (fBounds);

  }

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

void dng_area_spec::GetData (dng_stream &stream)

  {

  fArea.t = stream.Get_int32 ();

  fArea.l = stream.Get_int32 ();

  fArea.b = stream.Get_int32 ();

  fArea.r = stream.Get_int32 ();

  fPlane  = stream.Get_uint32 ();

  fPlanes = stream.Get_uint32 ();

  fRowPitch = stream.Get_uint32 ();

  fColPitch = stream.Get_uint32 ();

  if (fPlanes < 1)

    {

    ThrowBadFormat ();

    }

  if (fRowPitch < 1 || fColPitch < 1)

    {

    ThrowBadFormat ();

    }

  if (fArea.IsEmpty ())

    {

    if (fRowPitch != 1 || fColPitch != 1)

      {

      ThrowBadFormat ();

      }

    }

  else

    {

    int32 width = 0;

    int32 height = 0;

    if (!SafeInt32Sub (fArea.b, fArea.t, &height) ||

       !SafeInt32Sub (fArea.r, fArea.l, &width) ||

       fRowPitch > static_cast<uint32>(height) ||

       fColPitch > static_cast<uint32>(width))

      {

      ThrowBadFormat();

      }

    }

  #if qDNGValidate

  if (gVerbose)

    {

    printf ("AreaSpec: t=%d, l=%d, b=%d, r=%d, p=%u:%u, rp=%u, cp=%u\n",

        (int) fArea.t,

        (int) fArea.l,

        (int) fArea.b,

        (int) fArea.r,

        (unsigned) fPlane,

        (unsigned) fPlanes,

        (unsigned) fRowPitch,

        (unsigned) fColPitch);

    }

  #endif

  }

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

void dng_area_spec::PutData (dng_stream &stream) const

  {

  stream.Put_int32 (fArea.t);

  stream.Put_int32 (fArea.l);

  stream.Put_int32 (fArea.b);

  stream.Put_int32 (fArea.r);

  stream.Put_uint32 (fPlane);

  stream.Put_uint32 (fPlanes);

  stream.Put_uint32 (fRowPitch);

  stream.Put_uint32 (fColPitch);

  }

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

dng_rect dng_area_spec::Overlap (const dng_rect &tile) const

  {

  // Special case - if the fArea is empty, then dng_area_spec covers

  // the entire image, no matter how large it is.

  if (fArea.IsEmpty ())

    {

    return tile;

    }

  dng_rect overlap = fArea & tile;

  if (overlap.NotEmpty ())

    {

    overlap.t = fArea.t + ConvertUint32ToInt32(

      RoundUpUint32ToMultiple(static_cast<uint32>(overlap.t - fArea.t),

                  fRowPitch));

    overlap.l = fArea.l + ConvertUint32ToInt32(

      RoundUpUint32ToMultiple(static_cast<uint32>(overlap.l - fArea.l),

                  fColPitch));

    if (overlap.NotEmpty ())

      {

      overlap.b = overlap.t + ((overlap.H () - 1) / fRowPitch) * fRowPitch + 1;

      overlap.r = overlap.l + ((overlap.W () - 1) / fColPitch) * fColPitch + 1;

      return overlap;

      }

    }

  return dng_rect ();

  }

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

dng_opcode_MapTable::dng_opcode_MapTable (dng_host &host,

                      const dng_area_spec &areaSpec,

                      const uint16 *table,

                      uint32 count)

  : dng_inplace_opcode (dngOpcode_MapTable,

              dngVersion_1_3_0_0,

              kFlag_None)

  , fAreaSpec (areaSpec)

  , fTable    ()

  , fCount    (count)

  {

  if (count == 0 || count > 0x10000)

    {

    ThrowProgramError ();

    }

  fTable.Reset (host.Allocate (0x10000 * sizeof (uint16)));

  DoCopyBytes (table,

         fTable->Buffer (),

         count * (uint32) sizeof (uint16));

  ReplicateLastEntry ();

  }

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

dng_opcode_MapTable::dng_opcode_MapTable (dng_host &host,

                      dng_stream &stream)

  : dng_inplace_opcode (dngOpcode_MapTable,

              stream,

              "MapTable")

  , fAreaSpec ()

  , fTable    ()

  , fCount    (0)

  {

  uint32 dataSize = stream.Get_uint32 ();

  fAreaSpec.GetData (stream);

  fCount = stream.Get_uint32 ();

  uint32 requiredSize = SafeUint32Mult(fCount, 2);

  requiredSize = SafeUint32Add(requiredSize, dng_area_spec::kDataSize);

  requiredSize = SafeUint32Add(requiredSize, 4);

  if (dataSize != requiredSize)

    {

    ThrowBadFormat ();

    }

  if (fCount == 0 || fCount > 0x10000)

    {

    ThrowBadFormat ();

    }

  fTable.Reset (host.Allocate (0x10000 * sizeof (uint16)));

  uint16 *table = fTable->Buffer_uint16 ();

  for (uint32 index = 0; index < fCount; index++)

    {

    table [index] = stream.Get_uint16 ();

    }

  ReplicateLastEntry ();

  #if qDNGValidate

  if (gVerbose)

    {

    printf ("Count: %u\n", (unsigned) fCount);

    for (uint32 j = 0; j < fCount && j < gDumpLineLimit; j++)

      {

      printf ("    Table [%5u] = %5u\n", (unsigned) j, (unsigned) table [j]);

      }

    if (fCount > gDumpLineLimit)

      {

      printf ("    ... %u table entries skipped\n", (unsigned) (fCount - gDumpLineLimit));

      }

    }

  #endif

  }

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

void dng_opcode_MapTable::ReplicateLastEntry ()

  {

  uint16 *table = fTable->Buffer_uint16 ();

  uint16 lastEntry = table [fCount];

  for (uint32 index = fCount; index < 0x10000; index++)

    {

    table [index] = lastEntry;

    }

  }

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

void dng_opcode_MapTable::PutData (dng_stream &stream) const

  {

  stream.Put_uint32 (dng_area_spec::kDataSize + 4 + fCount * 2);

  fAreaSpec.PutData (stream);

  stream.Put_uint32 (fCount);

  uint16 *table = fTable->Buffer_uint16 ();

  for (uint32 index = 0; index < fCount; index++)

    {

    stream.Put_uint16 (table [index]);

    }

  }

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

uint32 dng_opcode_MapTable::BufferPixelType (uint32 /* imagePixelType */)

  {

  return ttShort;

  }

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

dng_rect dng_opcode_MapTable::ModifiedBounds (const dng_rect &imageBounds)

  {

  return fAreaSpec.Overlap (imageBounds);

  }

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

void dng_opcode_MapTable::ProcessArea (dng_negative & /* negative */,

                     uint32 /* threadIndex */,

                     dng_pixel_buffer &buffer,

                     const dng_rect &dstArea,

                     const dng_rect & /* imageBounds */)

  {

  dng_rect overlap = fAreaSpec.Overlap (dstArea);

  if (overlap.NotEmpty ())

    {

    for (uint32 plane = fAreaSpec.Plane ();

       plane < fAreaSpec.Plane () + fAreaSpec.Planes () &&

       plane < buffer.Planes ();

       plane++)

      {

      DoMapArea16 (buffer.DirtyPixel_uint16 (overlap.t, overlap.l, plane),

             1,

             (overlap.H () + fAreaSpec.RowPitch () - 1) / fAreaSpec.RowPitch (),

             (overlap.W () + fAreaSpec.ColPitch () - 1) / fAreaSpec.ColPitch (),

             0,

             fAreaSpec.RowPitch () * buffer.RowStep (),

             fAreaSpec.ColPitch (),

             fTable->Buffer_uint16 ());

      }

    }

  }

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

dng_opcode_MapPolynomial::dng_opcode_MapPolynomial (const dng_area_spec &areaSpec,

                          uint32 degree,

                          const real64 *coefficient)

  : dng_inplace_opcode (dngOpcode_MapPolynomial,

              dngVersion_1_3_0_0,

              kFlag_None)

  , fAreaSpec (areaSpec)

  , fDegree   (degree)

  {

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

    {

    if (j <= fDegree)

      {

      fCoefficient [j] = coefficient [j];

      }

    else

      {

      fCoefficient [j] = 0.0;

      }

    }

  // Reduce degree if possible.

  while (fDegree > 0 && fCoefficient [fDegree] == 0.0)

    {

    fDegree--;

    }

  }

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

dng_opcode_MapPolynomial::dng_opcode_MapPolynomial (dng_stream &stream)

  : dng_inplace_opcode (dngOpcode_MapPolynomial,

              stream,

              "MapPolynomial")

  , fAreaSpec ()

  , fDegree   (0)

  {

  uint32 dataSize = stream.Get_uint32 ();

  fAreaSpec.GetData (stream);

  fDegree = stream.Get_uint32 ();

  if (fDegree > kMaxDegree)

    {

    ThrowBadFormat ();

    }

  if (dataSize != dng_area_spec::kDataSize + 4 + (fDegree + 1) * 8)

    {

    ThrowBadFormat ();

    }

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

    {

    if (j <= fDegree)

      {

      fCoefficient [j] = stream.Get_real64 ();

      }

    else

      {

      fCoefficient [j] = 0.0;

      }

    }

  #if qDNGValidate

  if (gVerbose)

    {

    for (uint32 k = 0; k <= fDegree; k++)

      {

      printf ("    Coefficient [%u] = %f\n", (unsigned) k, fCoefficient [k]);

      }

    }

  #endif

  }

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

void dng_opcode_MapPolynomial::PutData (dng_stream &stream) const

  {

  stream.Put_uint32 (dng_area_spec::kDataSize + 4 + (fDegree + 1) * 8);

  fAreaSpec.PutData (stream);

  stream.Put_uint32 (fDegree);

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

    {

    stream.Put_real64 (fCoefficient [j]);

    }

  }

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

uint32 dng_opcode_MapPolynomial::BufferPixelType (uint32 imagePixelType)

  {

  // If we are operating on the stage 1 image, then we need

  // to adjust the coefficients to convert from the image

  // values to the 32-bit floating point values that this

  // opcode operates on.

  // If we are operating on the stage 2 or 3 image, the logical

  // range of the image is already 0.0 to 1.0, so we don't

  // need to adjust the values.

  real64 scale32 = 1.0;

  if (Stage () == 1)

    {

    switch (imagePixelType)

      {

      case ttFloat:

        break;

      case ttShort:

        {

        scale32 = (real64) 0xFFFF;

        break;

        }

      case ttLong:

        {

        scale32 = (real64) 0xFFFFFFFF;

        break;

        }

      default:

        ThrowBadFormat ();

      }

    }

  real64 factor32 = 1.0 / scale32;

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

    {

    fCoefficient32 [j] = ConvertDoubleToFloat(fCoefficient [j] * factor32);

    factor32 *= scale32;

    }

  return ttFloat;

  }

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

dng_rect dng_opcode_MapPolynomial::ModifiedBounds (const dng_rect &imageBounds)

  {

  return fAreaSpec.Overlap (imageBounds);

  }

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

void dng_opcode_MapPolynomial::ProcessArea (dng_negative & /* negative */,

                      uint32 /* threadIndex */,

                      dng_pixel_buffer &buffer,

                      const dng_rect &dstArea,

                      const dng_rect & /* imageBounds */)

  {

  dng_rect overlap = fAreaSpec.Overlap (dstArea);

  if (overlap.NotEmpty ())

    {

    uint32 cols = overlap.W ();

    uint32 colPitch = fAreaSpec.ColPitch ();

    for (uint32 plane = fAreaSpec.Plane ();

       plane < fAreaSpec.Plane () + fAreaSpec.Planes () &&

       plane < buffer.Planes ();

       plane++)

      {

      for (int32 row = overlap.t; row < overlap.b; row += fAreaSpec.RowPitch ())

        {

        real32 *dPtr = buffer.DirtyPixel_real32 (row, overlap.l, plane);

        switch (fDegree)

          {

          case 0:

            {

            real32 y = Pin_real32 (0.0f,

                         fCoefficient32 [0],

                         1.0f);

            for (uint32 col = 0; col < cols; col += colPitch)

              {

              dPtr [col] = y;

              }

            break;

            }

          case 1:

            {

            real32 c0 = fCoefficient32 [0];

            real32 c1 = fCoefficient32 [1];

            if (c0 == 0.0f)

              {

              if (c1 > 0.0f)

                {

                for (uint32 col = 0; col < cols; col += colPitch)

                  {

                  real32 x = dPtr [col];

                  real32 y = c1 * x;

                  dPtr [col] = Min_real32 (y, 1.0f);

                  }

                }

              else

                {

                for (uint32 col = 0; col < cols; col += colPitch)

                  {

                  dPtr [col] = 0.0f;

                  }

                }

              }

            else

              {

              for (uint32 col = 0; col < cols; col += colPitch)

                {

                real32 x = dPtr [col];

                real32 y = c0 +

                       c1 * x;

                dPtr [col] = Pin_real32 (0.0f, y, 1.0f);

                }

              }

            break;

            }

          case 2:

            {

            for (uint32 col = 0; col < cols; col += colPitch)

              {

              real32 x = dPtr [col];

              real32 y =  fCoefficient32 [0] + x *

                     (fCoefficient32 [1] + x *

                     (fCoefficient32 [2]));

              dPtr [col] = Pin_real32 (0.0f, y, 1.0f);

              }

            break;

            }

          case 3:

            {

            for (uint32 col = 0; col < cols; col += colPitch)

              {

              real32 x = dPtr [col];

              real32 y =  fCoefficient32 [0] + x *

                     (fCoefficient32 [1] + x *

                     (fCoefficient32 [2] + x *

                     (fCoefficient32 [3])));

              dPtr [col] = Pin_real32 (0.0f, y, 1.0f);

              }

            break;

            }

          case 4:

            {

            for (uint32 col = 0; col < cols; col += colPitch)

              {

              real32 x = dPtr [col];

              real32 y =  fCoefficient32 [0] + x *

                     (fCoefficient32 [1] + x *

                     (fCoefficient32 [2] + x *

                     (fCoefficient32 [3] + x *

                     (fCoefficient32 [4]))));

              dPtr [col] = Pin_real32 (0.0f, y, 1.0f);

              }

            break;

            }

          default:

            {

            for (uint32 col = 0; col < cols; col += colPitch)

              {

              real32 x = dPtr [col];

              real32 y = fCoefficient32 [0];

              real32 xx = x;

              for (uint32 j = 1; j <= fDegree; j++)

                {

                y += fCoefficient32 [j] * xx;

                xx *= x;

                }

              dPtr [col] = Pin_real32 (0.0f, y, 1.0f);

              }

            }

          }

        }

      }

    }

  }

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

dng_opcode_DeltaPerRow::dng_opcode_DeltaPerRow (const dng_area_spec &areaSpec,

                        AutoPtr<dng_memory_block> &table)

  : dng_inplace_opcode (dngOpcode_DeltaPerRow,

              dngVersion_1_3_0_0,

              kFlag_None)

  , fAreaSpec (areaSpec)

  , fTable    ()

  , fScale    (1.0f)

  {

  fTable.Reset (table.Release ());

  }

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

dng_opcode_DeltaPerRow::dng_opcode_DeltaPerRow (dng_host &host,

                        dng_stream &stream)

  : dng_inplace_opcode (dngOpcode_DeltaPerRow,

              stream,

              "DeltaPerRow")

  , fAreaSpec ()

  , fTable    ()

  , fScale    (1.0f)

  {

  uint32 dataSize = stream.Get_uint32 ();

  fAreaSpec.GetData (stream);

  uint32 deltas = SafeUint32DivideUp (fAreaSpec.Area ().H (),

                    fAreaSpec.RowPitch ());

  if (deltas != stream.Get_uint32 ())

    {

    ThrowBadFormat ();

    }

  if (dataSize != dng_area_spec::kDataSize + 4 + deltas * 4)

    {

    ThrowBadFormat ();

    }

  fTable.Reset (host.Allocate (SafeUint32Mult (deltas,

    static_cast<uint32> (sizeof (real32)))));

  real32 *table = fTable->Buffer_real32 ();

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

    {

    table [j] = stream.Get_real32 ();

    }

  #if qDNGValidate

  if (gVerbose)

    {

    printf ("Count: %u\n", (unsigned) deltas);

    for (uint32 k = 0; k < deltas && k < gDumpLineLimit; k++)

      {

      printf ("    Delta [%u] = %f\n", (unsigned) k, table [k]);

      }

    if (deltas > gDumpLineLimit)

      {

      printf ("    ... %u deltas skipped\n", (unsigned) (deltas - gDumpLineLimit));

      }

    }

  #endif

  }

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

void dng_opcode_DeltaPerRow::PutData (dng_stream &stream) const

  {

  uint32 deltas = SafeUint32DivideUp (fAreaSpec.Area ().H (),

                    fAreaSpec.RowPitch ());

  stream.Put_uint32 (dng_area_spec::kDataSize + 4 + deltas * 4);

  fAreaSpec.PutData (stream);

  stream.Put_uint32 (deltas);

  real32 *table = fTable->Buffer_real32 ();

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

    {

    stream.Put_real32 (table [j]);

    }

  }

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

uint32 dng_opcode_DeltaPerRow::BufferPixelType (uint32 imagePixelType)

  {

  real64 scale32 = 1.0;

  switch (imagePixelType)

    {

    case ttFloat:

      break;

    case ttShort:

      {

      scale32 = (real64) 0xFFFF;

      break;

      }

    case ttLong:

      {

      scale32 = (real64) 0xFFFFFFFF;

      break;

      }