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

// Copyright 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_bad_pixels.h#3 $ */ 

/* $DateTime: 2012/07/11 10:36:56 $ */

/* $Change: 838485 $ */

/* $Author: tknoll $ */

/** \file

 * Opcodes to fix defective pixels, including individual pixels and regions (such as

 * defective rows and columns).

 */

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

#ifndef __dng_bad_pixels__

#define __dng_bad_pixels__

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

#include "dng_memory.h"

#include "dng_opcodes.h"

#include <vector>

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

/// \brief An opcode to fix individual bad pixels that are marked with a constant

/// value (e.g., 0) in a Bayer image.

class dng_opcode_FixBadPixelsConstant: public dng_filter_opcode

  {

  private:

    uint32 fConstant;

    uint32 fBayerPhase;

  public:

    /// Construct an opcode to fix an individual bad pixels that are marked with

    /// a constant value in a Bayer image.

    /// \param constant The constant value that indicates a bad pixel.

    /// \param bayerPhase The phase of the Bayer mosaic pattern (0, 1, 2, 3).

    dng_opcode_FixBadPixelsConstant (uint32 constant,

                     uint32 bayerPhase);

    dng_opcode_FixBadPixelsConstant (dng_stream &stream);

    virtual void PutData (dng_stream &stream) const;

    virtual dng_point SrcRepeat ();

    virtual dng_rect SrcArea (const dng_rect &dstArea,

                  const dng_rect &imageBounds);

    virtual void Prepare (dng_negative &negative,

                uint32 threadCount,

                const dng_point &tileSize,

                const dng_rect &imageBounds,

                uint32 imagePlanes,

                uint32 bufferPixelType,

                dng_memory_allocator &allocator);

    virtual void ProcessArea (dng_negative &negative,

                  uint32 threadIndex,

                  dng_pixel_buffer &srcBuffer,

                  dng_pixel_buffer &dstBuffer,

                  const dng_rect &dstArea,

                  const dng_rect &imageBounds);

  protected:

#if defined(__clang__) && defined(__has_attribute)

#if __has_attribute(no_sanitize)

__attribute__((no_sanitize("unsigned-integer-overflow")))

#endif

#endif

    bool IsGreen (int32 row, int32 col) const

      {

      return (((uint32) row + (uint32) col + fBayerPhase + (fBayerPhase >> 1)) & 1) == 0;

      }

  };

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

/// \brief A list of bad pixels and rectangles (usually single rows or columns).

class dng_bad_pixel_list

  {

  public:

    enum

      {

      kNoIndex = 0xFFFFFFFF

      };

  private:

    // List of bad single pixels.

    dng_std_vector<dng_point> fBadPoints;

    // List of bad rectangles (usually single rows or columns).

    dng_std_vector<dng_rect> fBadRects;

  public:

    /// Create an empty bad pixel list.

    dng_bad_pixel_list ();

    /// Returns the number of bad single pixels.

    uint32 PointCount () const

      {

      return (uint32) fBadPoints.size ();

      }

    /// Retrieves the bad single pixel coordinate via the specified list index.

    ///

    /// \param index The list index from which to retrieve the bad single pixel

    /// coordinate.

    const dng_point & Point (uint32 index) const

      {

      return fBadPoints [index];

      }

    /// Returns the number of bad rectangles.

    uint32 RectCount () const

      {

      return (uint32) fBadRects.size ();

      }

    /// Retrieves the bad rectangle via the specified list index.

    ///

    /// \param index The list index from which to retrieve the bad rectangle

    /// coordinates.

    const dng_rect & Rect (uint32 index) const

      {

      return fBadRects [index];

      }

    /// Returns true iff there are zero bad single pixels and zero bad

    /// rectangles.

    bool IsEmpty () const

      {

      return PointCount () == 0 &&

           RectCount  () == 0;

      }

    /// Returns true iff there is at least one bad single pixel or at least one

    /// bad rectangle.

    bool NotEmpty () const

      {

      return !IsEmpty ();

      }

    /// Add the specified coordinate to the list of bad single pixels.

    ///

    /// \param pt The bad single pixel to add.

    void AddPoint (const dng_point &pt);

    /// Add the specified rectangle to the list of bad rectangles.

    ///

    /// \param pt The bad rectangle to add.

    void AddRect (const dng_rect &r);

    /// Sort the bad single pixels and bad rectangles by coordinates (top to

    /// bottom, then left to right).

    void Sort ();

    /// Returns true iff the specified bad single pixel is isolated, i.e., there

    /// is no other bad single pixel or bad rectangle that lies within radius

    /// pixels of this bad single pixel.

    ///

    /// \param index The index of the bad single pixel to test.

    /// \param radius The pixel radius to test for isolation.

    bool IsPointIsolated (uint32 index,

                uint32 radius) const;

    /// Returns true iff the specified bad rectangle is isolated, i.e., there

    /// is no other bad single pixel or bad rectangle that lies within radius

    /// pixels of this bad rectangle.

    ///

    /// \param index The index of the bad rectangle to test.

    /// \param radius The pixel radius to test for isolation.

    bool IsRectIsolated (uint32 index,

               uint32 radius) const;

    /// Returns true iff the specified point is valid, i.e., lies within the

    /// specified image bounds, is different from all other bad single pixels,

    /// and is not contained in any bad rectangle. The second and third

    /// conditions are only checked if provided with a starting search index.

    ///

    /// \param pt The point to test for validity.

    /// \param imageBounds The pt must lie within imageBounds to be valid.

    /// \index The search index to use (or kNoIndex, to avoid a search) for

    /// checking for validity.

    bool IsPointValid (const dng_point &pt,

               const dng_rect &imageBounds,

               uint32 index = kNoIndex) const;

  };

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

/// \brief An opcode to fix lists of bad pixels (indicated by position) in a Bayer

/// image.

class dng_opcode_FixBadPixelsList: public dng_filter_opcode

  {

  protected:

    enum

      {

      kBadPointPadding = 2,

      kBadRectPadding  = 4

      };

  private:

    AutoPtr<dng_bad_pixel_list> fList;

    uint32 fBayerPhase;

  public:

    /// Construct an opcode to fix lists of bad pixels (indicated by position) in

    /// a Bayer image.

    /// \param list The list of bad pixels to fix.

    /// \param bayerPhase The phase of the Bayer mosaic pattern (0, 1, 2, 3).

    dng_opcode_FixBadPixelsList (AutoPtr<dng_bad_pixel_list> &list,

                   uint32 bayerPhase);

    dng_opcode_FixBadPixelsList (dng_stream &stream);

    virtual void PutData (dng_stream &stream) const;

    virtual dng_point SrcRepeat ();

    virtual dng_rect SrcArea (const dng_rect &dstArea,

                  const dng_rect &imageBounds);

    virtual void Prepare (dng_negative &negative,

                uint32 threadCount,

                const dng_point &tileSize,

                const dng_rect &imageBounds,

                uint32 imagePlanes,

                uint32 bufferPixelType,

                dng_memory_allocator &allocator);

    virtual void ProcessArea (dng_negative &negative,

                  uint32 threadIndex,

                  dng_pixel_buffer &srcBuffer,

                  dng_pixel_buffer &dstBuffer,

                  const dng_rect &dstArea,

                  const dng_rect &imageBounds);

  protected:

    bool IsGreen (int32 row, int32 col) const

      {

      return ((row + col + fBayerPhase + (fBayerPhase >> 1)) & 1) == 0;

      }

    virtual void FixIsolatedPixel (dng_pixel_buffer &buffer,

                     dng_point &badPoint);

    virtual void FixClusteredPixel (dng_pixel_buffer &buffer,

                        uint32 pointIndex,

                    const dng_rect &imageBounds);

    virtual void FixSingleColumn (dng_pixel_buffer &buffer,

                    const dng_rect &badRect);

    virtual void FixSingleRow (dng_pixel_buffer &buffer,

                   const dng_rect &badRect);

    virtual void FixClusteredRect (dng_pixel_buffer &buffer,

                     const dng_rect &badRect,

                     const dng_rect &imageBounds);

  };

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

#endif

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