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

/*                                                                         */

/*  ftlcdfil.c                                                             */

/*                                                                         */

/*    FreeType API for color filtering of subpixel bitmap glyphs (body).   */

/*                                                                         */

/*  Copyright 2006, 2008, 2009, 2010 by                                    */

/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */

/*                                                                         */

/*  This file is part of the FreeType project, and may only be used,       */

/*  modified, and distributed under the terms of the FreeType project      */

/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */

/*  this file you indicate that you have read the license and              */

/*  understand and accept it fully.                                        */

/*                                                                         */

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

#include <ft2build.h>

#include FT_LCD_FILTER_H

#include FT_IMAGE_H

#include FT_INTERNAL_OBJECTS_H

#ifdef FT_CONFIG_OPTION_SUBPIXEL_RENDERING

/* define USE_LEGACY to implement the legacy filter */

#define  USE_LEGACY

  /* FIR filter used by the default and light filters */

  static void

  _ft_lcd_filter_fir( FT_Bitmap*      bitmap,

                      FT_Render_Mode  mode,

                      FT_Library      library )

  {

    FT_Byte*  weights = library->lcd_weights;

    FT_UInt   width   = (FT_UInt)bitmap->width;

    FT_UInt   height  = (FT_UInt)bitmap->rows;

    /* horizontal in-place FIR filter */

    if ( mode == FT_RENDER_MODE_LCD && width >= 4 )

    {

      FT_Byte*  line = bitmap->buffer;

      for ( ; height > 0; height--, line += bitmap->pitch )

      {

        FT_UInt  fir[5];

        FT_UInt  val1, xx;

        val1   = line[0];

        fir[0] = weights[2] * val1;

        fir[1] = weights[3] * val1;

        fir[2] = weights[4] * val1;

        fir[3] = 0;

        fir[4] = 0;

        val1    = line[1];

        fir[0] += weights[1] * val1;

        fir[1] += weights[2] * val1;

        fir[2] += weights[3] * val1;

        fir[3] += weights[4] * val1;

        for ( xx = 2; xx < width; xx++ )

        {

          FT_UInt  val, pix;

          val    = line[xx];

          pix    = fir[0] + weights[0] * val;

          fir[0] = fir[1] + weights[1] * val;

          fir[1] = fir[2] + weights[2] * val;

          fir[2] = fir[3] + weights[3] * val;

          fir[3] =          weights[4] * val;

          pix        >>= 8;

          pix         |= -( pix >> 8 );

          line[xx - 2] = (FT_Byte)pix;

        }

        {

          FT_UInt  pix;

          pix          = fir[0] >> 8;

          pix         |= -( pix >> 8 );

          line[xx - 2] = (FT_Byte)pix;

          pix          = fir[1] >> 8;

          pix         |= -( pix >> 8 );

          line[xx - 1] = (FT_Byte)pix;

        }

      }

    }

    /* vertical in-place FIR filter */

    else if ( mode == FT_RENDER_MODE_LCD_V && height >= 4 )

    {

      FT_Byte*  column = bitmap->buffer;

      FT_Int    pitch  = bitmap->pitch;

      for ( ; width > 0; width--, column++ )

      {

        FT_Byte*  col = column;

        FT_UInt   fir[5];

        FT_UInt   val1, yy;

        val1   = col[0];

        fir[0] = weights[2] * val1;

        fir[1] = weights[3] * val1;

        fir[2] = weights[4] * val1;

        fir[3] = 0;

        fir[4] = 0;

        col   += pitch;

        val1    = col[0];

        fir[0] += weights[1] * val1;

        fir[1] += weights[2] * val1;

        fir[2] += weights[3] * val1;

        fir[3] += weights[4] * val1;

        col    += pitch;

        for ( yy = 2; yy < height; yy++ )

        {

          FT_UInt  val, pix;

          val    = col[0];

          pix    = fir[0] + weights[0] * val;

          fir[0] = fir[1] + weights[1] * val;

          fir[1] = fir[2] + weights[2] * val;

          fir[2] = fir[3] + weights[3] * val;

          fir[3] =          weights[4] * val;

          pix           >>= 8;

          pix            |= -( pix >> 8 );

          col[-2 * pitch] = (FT_Byte)pix;

          col            += pitch;

        }

        {

          FT_UInt  pix;

          pix             = fir[0] >> 8;

          pix            |= -( pix >> 8 );

          col[-2 * pitch] = (FT_Byte)pix;

          pix         = fir[1] >> 8;

          pix        |= -( pix >> 8 );

          col[-pitch] = (FT_Byte)pix;

        }

      }

    }

  }

#ifdef USE_LEGACY

  /* intra-pixel filter used by the legacy filter */

  static void

  _ft_lcd_filter_legacy( FT_Bitmap*      bitmap,

                         FT_Render_Mode  mode,

                         FT_Library      library )

  {

    FT_UInt  width  = (FT_UInt)bitmap->width;

    FT_UInt  height = (FT_UInt)bitmap->rows;

    FT_Int   pitch  = bitmap->pitch;

    static const int  filters[3][3] =

    {

      { 65538 * 9/13, 65538 * 1/6, 65538 * 1/13 },

      { 65538 * 3/13, 65538 * 4/6, 65538 * 3/13 },

      { 65538 * 1/13, 65538 * 1/6, 65538 * 9/13 }

    };

    FT_UNUSED( library );

    /* horizontal in-place intra-pixel filter */

    if ( mode == FT_RENDER_MODE_LCD && width >= 3 )

    {

      FT_Byte*  line = bitmap->buffer;

      for ( ; height > 0; height--, line += pitch )

      {

        FT_UInt  xx;

        for ( xx = 0; xx < width; xx += 3 )

        {

          FT_UInt  r = 0;

          FT_UInt  g = 0;

          FT_UInt  b = 0;

          FT_UInt  p;

          p  = line[xx];

          r += filters[0][0] * p;

          g += filters[0][1] * p;

          b += filters[0][2] * p;

          p  = line[xx + 1];

          r += filters[1][0] * p;

          g += filters[1][1] * p;

          b += filters[1][2] * p;

          p  = line[xx + 2];

          r += filters[2][0] * p;

          g += filters[2][1] * p;

          b += filters[2][2] * p;

          line[xx]     = (FT_Byte)( r / 65536 );

          line[xx + 1] = (FT_Byte)( g / 65536 );

          line[xx + 2] = (FT_Byte)( b / 65536 );

        }

      }

    }

    else if ( mode == FT_RENDER_MODE_LCD_V && height >= 3 )

    {

      FT_Byte*  column = bitmap->buffer;

      for ( ; width > 0; width--, column++ )

      {

        FT_Byte*  col     = column;

        FT_Byte*  col_end = col + height * pitch;

        for ( ; col < col_end; col += 3 * pitch )

        {

          FT_UInt  r = 0;

          FT_UInt  g = 0;

          FT_UInt  b = 0;

          FT_UInt  p;

          p  = col[0];

          r += filters[0][0] * p;

          g += filters[0][1] * p;

          b += filters[0][2] * p;

          p  = col[pitch];

          r += filters[1][0] * p;

          g += filters[1][1] * p;

          b += filters[1][2] * p;

          p  = col[pitch * 2];

          r += filters[2][0] * p;

          g += filters[2][1] * p;

          b += filters[2][2] * p;

          col[0]         = (FT_Byte)( r / 65536 );

          col[pitch]     = (FT_Byte)( g / 65536 );

          col[2 * pitch] = (FT_Byte)( b / 65536 );

        }

      }

    }

  }

#endif /* USE_LEGACY */

  FT_EXPORT_DEF( FT_Error )

  FT_Library_SetLcdFilterWeights( FT_Library      library,

                                  unsigned char  *weights )

  {

    if ( !library || !weights )

      return FT_Err_Invalid_Argument;

    ft_memcpy( library->lcd_weights, weights, 5 );

    return FT_Err_Ok;

  }

  FT_EXPORT_DEF( FT_Error )

  FT_Library_SetLcdFilter( FT_Library    library,

                           FT_LcdFilter  filter )

  {

    static const FT_Byte  light_filter[5] =

                            { 0x00, 0x55, 0x56, 0x55, 0x00 };

    /* the values here sum up to a value larger than 256, */

    /* providing a cheap gamma correction                 */

    static const FT_Byte  default_filter[5] =

                            { 0x10, 0x40, 0x70, 0x40, 0x10 };

    if ( !library )

      return FT_Err_Invalid_Argument;

    switch ( filter )

    {

    case FT_LCD_FILTER_NONE:

      library->lcd_filter_func = NULL;

      library->lcd_extra       = 0;

      break;

    case FT_LCD_FILTER_DEFAULT:

#if defined( FT_FORCE_LEGACY_LCD_FILTER )

      library->lcd_filter_func = _ft_lcd_filter_legacy;

      library->lcd_extra       = 0;

#elif defined( FT_FORCE_LIGHT_LCD_FILTER )

      ft_memcpy( library->lcd_weights, light_filter, 5 );

      library->lcd_filter_func = _ft_lcd_filter_fir;

      library->lcd_extra       = 2;

#else

      ft_memcpy( library->lcd_weights, default_filter, 5 );

      library->lcd_filter_func = _ft_lcd_filter_fir;

      library->lcd_extra       = 2;

#endif

      break;

    case FT_LCD_FILTER_LIGHT:

      ft_memcpy( library->lcd_weights, light_filter, 5 );

      library->lcd_filter_func = _ft_lcd_filter_fir;

      library->lcd_extra       = 2;

      break;

#ifdef USE_LEGACY

    case FT_LCD_FILTER_LEGACY:

      library->lcd_filter_func = _ft_lcd_filter_legacy;

      library->lcd_extra       = 0;

      break;

#endif

    default:

      return FT_Err_Invalid_Argument;

    }

    library->lcd_filter = filter;

    return FT_Err_Ok;

  }

#else /* !FT_CONFIG_OPTION_SUBPIXEL_RENDERING */

  FT_EXPORT_DEF( FT_Error )

  FT_Library_SetLcdFilterWeights( FT_Library      library,

                                  unsigned char  *weights )

  {

    FT_UNUSED( library );

    FT_UNUSED( weights );

    return FT_Err_Unimplemented_Feature;

  }

  FT_EXPORT_DEF( FT_Error )

  FT_Library_SetLcdFilter( FT_Library    library,

                           FT_LcdFilter  filter )

  {

    FT_UNUSED( library );

    FT_UNUSED( filter );

    return FT_Err_Unimplemented_Feature;

  }

#endif /* !FT_CONFIG_OPTION_SUBPIXEL_RENDERING */

/* END */