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

/*                                                                         */

/*  ftbitmap.c                                                             */

/*                                                                         */

/*    FreeType utility functions for bitmaps (body).                       */

/*                                                                         */

/*  Copyright 2004, 2005, 2006, 2007, 2008, 2009 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_BITMAP_H

#include FT_IMAGE_H

#include FT_INTERNAL_OBJECTS_H





  static

  const FT_Bitmap  null_bitmap = { 0, 0, 0, 0, 0, 0, 0, 0 };





  /* documentation is in ftbitmap.h */



  FT_EXPORT_DEF( void )

  FT_Bitmap_New( FT_Bitmap  *abitmap )

  {

    *abitmap = null_bitmap;

  }





  /* documentation is in ftbitmap.h */



  FT_EXPORT_DEF( FT_Error )

  FT_Bitmap_Copy( FT_Library        library,

                  const FT_Bitmap  *source,

                  FT_Bitmap        *target)

  {

    FT_Memory  memory = library->memory;

    FT_Error   error  = FT_Err_Ok;

    FT_Int     pitch  = source->pitch;

    FT_ULong   size;





    if ( source == target )

      return FT_Err_Ok;



    if ( source->buffer == NULL )

    {

      *target = *source;



      return FT_Err_Ok;

    }



    if ( pitch < 0 )

      pitch = -pitch;

    size = (FT_ULong)( pitch * source->rows );



    if ( target->buffer )

    {

      FT_Int    target_pitch = target->pitch;

      FT_ULong  target_size;





      if ( target_pitch < 0  )

        target_pitch = -target_pitch;

      target_size = (FT_ULong)( target_pitch * target->rows );



      if ( target_size != size )

        (void)FT_QREALLOC( target->buffer, target_size, size );

    }

    else

      (void)FT_QALLOC( target->buffer, size );



    if ( !error )

    {

      unsigned char *p;





      p = target->buffer;

      *target = *source;

      target->buffer = p;



      FT_MEM_COPY( target->buffer, source->buffer, size );

    }



    return error;

  }





  static FT_Error

  ft_bitmap_assure_buffer( FT_Memory   memory,

                           FT_Bitmap*  bitmap,

                           FT_UInt     xpixels,

                           FT_UInt     ypixels )

  {

    FT_Error        error;

    int             pitch;

    int             new_pitch;

    FT_UInt         bpp;

    FT_Int          i, width, height;

    unsigned char*  buffer;





    width  = bitmap->width;

    height = bitmap->rows;

    pitch  = bitmap->pitch;

    if ( pitch < 0 )

      pitch = -pitch;



    switch ( bitmap->pixel_mode )

    {

    case FT_PIXEL_MODE_MONO:

      bpp       = 1;

      new_pitch = ( width + xpixels + 7 ) >> 3;

      break;

    case FT_PIXEL_MODE_GRAY2:

      bpp       = 2;

      new_pitch = ( width + xpixels + 3 ) >> 2;

      break;

    case FT_PIXEL_MODE_GRAY4:

      bpp       = 4;

      new_pitch = ( width + xpixels + 1 ) >> 1;

      break;

    case FT_PIXEL_MODE_GRAY:

    case FT_PIXEL_MODE_LCD:

    case FT_PIXEL_MODE_LCD_V:

      bpp       = 8;

      new_pitch = ( width + xpixels );

      break;

    default:

      return FT_Err_Invalid_Glyph_Format;

    }



    /* if no need to allocate memory */

    if ( ypixels == 0 && new_pitch <= pitch )

    {

      /* zero the padding */

      FT_Int  bit_width = pitch * 8;

      FT_Int  bit_last  = ( width + xpixels ) * bpp;





      if ( bit_last < bit_width )

      {

        FT_Byte*  line  = bitmap->buffer + ( bit_last >> 3 );

        FT_Byte*  end   = bitmap->buffer + pitch;

        FT_Int    shift = bit_last & 7;

        FT_UInt   mask  = 0xFF00U >> shift;

        FT_Int    count = height;





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

        {

          FT_Byte*  write = line;





          if ( shift > 0 )

          {

            write[0] = (FT_Byte)( write[0] & mask );

            write++;

          }

          if ( write < end )

            FT_MEM_ZERO( write, end-write );

        }

      }



      return FT_Err_Ok;

    }



    if ( FT_QALLOC_MULT( buffer, new_pitch, bitmap->rows + ypixels ) )

      return error;



    if ( bitmap->pitch > 0 )

    {

      FT_Int  len = ( width * bpp + 7 ) >> 3;





      for ( i = 0; i < bitmap->rows; i++ )

        FT_MEM_COPY( buffer + new_pitch * ( ypixels + i ),

                     bitmap->buffer + pitch * i, len );

    }

    else

    {

      FT_Int  len = ( width * bpp + 7 ) >> 3;





      for ( i = 0; i < bitmap->rows; i++ )

        FT_MEM_COPY( buffer + new_pitch * i,

                     bitmap->buffer + pitch * i, len );

    }



    FT_FREE( bitmap->buffer );

    bitmap->buffer = buffer;



    if ( bitmap->pitch < 0 )

      new_pitch = -new_pitch;



    /* set pitch only, width and height are left untouched */

    bitmap->pitch = new_pitch;



    return FT_Err_Ok;

  }





  /* documentation is in ftbitmap.h */



  FT_EXPORT_DEF( FT_Error )

  FT_Bitmap_Embolden( FT_Library  library,

                      FT_Bitmap*  bitmap,

                      FT_Pos      xStrength,

                      FT_Pos      yStrength )

  {

    FT_Error        error;

    unsigned char*  p;

    FT_Int          i, x, y, pitch;

    FT_Int          xstr, ystr;





    if ( !library )

      return FT_Err_Invalid_Library_Handle;



    if ( !bitmap || !bitmap->buffer )

      return FT_Err_Invalid_Argument;



    if ( ( ( FT_PIX_ROUND( xStrength ) >> 6 ) > FT_INT_MAX ) ||

         ( ( FT_PIX_ROUND( yStrength ) >> 6 ) > FT_INT_MAX ) )

      return FT_Err_Invalid_Argument;

       

    xstr = (FT_Int)FT_PIX_ROUND( xStrength ) >> 6;

    ystr = (FT_Int)FT_PIX_ROUND( yStrength ) >> 6;



    if ( xstr == 0 && ystr == 0 )

      return FT_Err_Ok;

    else if ( xstr < 0 || ystr < 0 )

      return FT_Err_Invalid_Argument;



    switch ( bitmap->pixel_mode )

    {

    case FT_PIXEL_MODE_GRAY2:

    case FT_PIXEL_MODE_GRAY4:

      {

        FT_Bitmap  tmp;

        FT_Int     align;





        if ( bitmap->pixel_mode == FT_PIXEL_MODE_GRAY2 )

          align = ( bitmap->width + xstr + 3 ) / 4;

        else

          align = ( bitmap->width + xstr + 1 ) / 2;



        FT_Bitmap_New( &tmp );



        error = FT_Bitmap_Convert( library, bitmap, &tmp, align );

        if ( error )

          return error;



        FT_Bitmap_Done( library, bitmap );

        *bitmap = tmp;

      }

      break;



    case FT_PIXEL_MODE_MONO:

      if ( xstr > 8 )

        xstr = 8;

      break;



    case FT_PIXEL_MODE_LCD:

      xstr *= 3;

      break;



    case FT_PIXEL_MODE_LCD_V:

      ystr *= 3;

      break;

    }



    error = ft_bitmap_assure_buffer( library->memory, bitmap, xstr, ystr );

    if ( error )

      return error;



    pitch = bitmap->pitch;

    if ( pitch > 0 )

      p = bitmap->buffer + pitch * ystr;

    else

    {

      pitch = -pitch;

      p = bitmap->buffer + pitch * ( bitmap->rows - 1 );

    }



    /* for each row */

    for ( y = 0; y < bitmap->rows ; y++ )

    {

      /*

       * Horizontally:

       *

       * From the last pixel on, make each pixel or'ed with the

       * `xstr' pixels before it.

       */

      for ( x = pitch - 1; x >= 0; x-- )

      {

        unsigned char tmp;





        tmp = p[x];

        for ( i = 1; i <= xstr; i++ )

        {

          if ( bitmap->pixel_mode == FT_PIXEL_MODE_MONO )

          {

            p[x] |= tmp >> i;



            /* the maximum value of 8 for `xstr' comes from here */

            if ( x > 0 )

              p[x] |= p[x - 1] << ( 8 - i );



#if 0

            if ( p[x] == 0xff )

              break;

#endif

          }

          else

          {

            if ( x - i >= 0 )

            {

              if ( p[x] + p[x - i] > bitmap->num_grays - 1 )

              {

                p[x] = (unsigned char)(bitmap->num_grays - 1);

                break;

              }

              else

              {

                p[x] = (unsigned char)(p[x] + p[x-i]);

                if ( p[x] == bitmap->num_grays - 1 )

                  break;

              }

            }

            else

              break;

          }

        }

      }



      /*

       * Vertically:

       *

       * Make the above `ystr' rows or'ed with it.

       */

      for ( x = 1; x <= ystr; x++ )

      {

        unsigned char*  q;





        q = p - bitmap->pitch * x;

        for ( i = 0; i < pitch; i++ )

          q[i] |= p[i];

      }



      p += bitmap->pitch;

    }



    bitmap->width += xstr;

    bitmap->rows += ystr;



    return FT_Err_Ok;

  }





  /* documentation is in ftbitmap.h */



  FT_EXPORT_DEF( FT_Error )

  FT_Bitmap_Convert( FT_Library        library,

                     const FT_Bitmap  *source,

                     FT_Bitmap        *target,

                     FT_Int            alignment )

  {

    FT_Error   error = FT_Err_Ok;

    FT_Memory  memory;





    if ( !library )

      return FT_Err_Invalid_Library_Handle;



    memory = library->memory;



    switch ( source->pixel_mode )

    {

    case FT_PIXEL_MODE_MONO:

    case FT_PIXEL_MODE_GRAY:

    case FT_PIXEL_MODE_GRAY2:

    case FT_PIXEL_MODE_GRAY4:

    case FT_PIXEL_MODE_LCD:

    case FT_PIXEL_MODE_LCD_V:

      {

        FT_Int   pad;

        FT_Long  old_size;





        old_size = target->rows * target->pitch;

        if ( old_size < 0 )

          old_size = -old_size;



        target->pixel_mode = FT_PIXEL_MODE_GRAY;

        target->rows       = source->rows;

        target->width      = source->width;



        pad = 0;

        if ( alignment > 0 )

        {

          pad = source->width % alignment;

          if ( pad != 0 )

            pad = alignment - pad;

        }



        target->pitch = source->width + pad;



        if ( target->rows * target->pitch > old_size             &&

             FT_QREALLOC( target->buffer,

                          old_size, target->rows * target->pitch ) )

          return error;

      }

      break;



    default:

      error = FT_Err_Invalid_Argument;

    }



    switch ( source->pixel_mode )

    {

    case FT_PIXEL_MODE_MONO:

      {

        FT_Byte*  s = source->buffer;

        FT_Byte*  t = target->buffer;

        FT_Int    i;





        target->num_grays = 2;



        for ( i = source->rows; i > 0; i-- )

        {

          FT_Byte*  ss = s;

          FT_Byte*  tt = t;

          FT_Int    j;





          /* get the full bytes */

          for ( j = source->width >> 3; j > 0; j-- )

          {

            FT_Int  val = ss[0]; /* avoid a byte->int cast on each line */





            tt[0] = (FT_Byte)( ( val & 0x80 ) >> 7 );

            tt[1] = (FT_Byte)( ( val & 0x40 ) >> 6 );

            tt[2] = (FT_Byte)( ( val & 0x20 ) >> 5 );

            tt[3] = (FT_Byte)( ( val & 0x10 ) >> 4 );

            tt[4] = (FT_Byte)( ( val & 0x08 ) >> 3 );

            tt[5] = (FT_Byte)( ( val & 0x04 ) >> 2 );

            tt[6] = (FT_Byte)( ( val & 0x02 ) >> 1 );

            tt[7] = (FT_Byte)(   val & 0x01 );



            tt += 8;

            ss += 1;

          }



          /* get remaining pixels (if any) */

          j = source->width & 7;

          if ( j > 0 )

          {

            FT_Int  val = *ss;





            for ( ; j > 0; j-- )

            {

              tt[0] = (FT_Byte)( ( val & 0x80 ) >> 7);

              val <<= 1;

              tt   += 1;

            }

          }



          s += source->pitch;

          t += target->pitch;

        }

      }

      break;





    case FT_PIXEL_MODE_GRAY:

    case FT_PIXEL_MODE_LCD:

    case FT_PIXEL_MODE_LCD_V:

      {

        FT_Int    width   = source->width;

        FT_Byte*  s       = source->buffer;

        FT_Byte*  t       = target->buffer;

        FT_Int    s_pitch = source->pitch;

        FT_Int    t_pitch = target->pitch;

        FT_Int    i;





        target->num_grays = 256;



        for ( i = source->rows; i > 0; i-- )

        {

          FT_ARRAY_COPY( t, s, width );



          s += s_pitch;

          t += t_pitch;

        }

      }

      break;





    case FT_PIXEL_MODE_GRAY2:

      {

        FT_Byte*  s = source->buffer;

        FT_Byte*  t = target->buffer;

        FT_Int    i;





        target->num_grays = 4;



        for ( i = source->rows; i > 0; i-- )

        {

          FT_Byte*  ss = s;

          FT_Byte*  tt = t;

          FT_Int    j;





          /* get the full bytes */

          for ( j = source->width >> 2; j > 0; j-- )

          {

            FT_Int  val = ss[0];





            tt[0] = (FT_Byte)( ( val & 0xC0 ) >> 6 );

            tt[1] = (FT_Byte)( ( val & 0x30 ) >> 4 );

            tt[2] = (FT_Byte)( ( val & 0x0C ) >> 2 );

            tt[3] = (FT_Byte)( ( val & 0x03 ) );



            ss += 1;

            tt += 4;

          }



          j = source->width & 3;

          if ( j > 0 )

          {

            FT_Int  val = ss[0];





            for ( ; j > 0; j-- )

            {

              tt[0]  = (FT_Byte)( ( val & 0xC0 ) >> 6 );

              val  <<= 2;

              tt    += 1;

            }

          }



          s += source->pitch;

          t += target->pitch;

        }

      }

      break;





    case FT_PIXEL_MODE_GRAY4:

      {

        FT_Byte*  s = source->buffer;

        FT_Byte*  t = target->buffer;

        FT_Int    i;





        target->num_grays = 16;



        for ( i = source->rows; i > 0; i-- )

        {

          FT_Byte*  ss = s;

          FT_Byte*  tt = t;

          FT_Int    j;





          /* get the full bytes */

          for ( j = source->width >> 1; j > 0; j-- )

          {

            FT_Int  val = ss[0];





            tt[0] = (FT_Byte)( ( val & 0xF0 ) >> 4 );

            tt[1] = (FT_Byte)( ( val & 0x0F ) );



            ss += 1;

            tt += 2;

          }



          if ( source->width & 1 )

            tt[0] = (FT_Byte)( ( ss[0] & 0xF0 ) >> 4 );



          s += source->pitch;

          t += target->pitch;

        }

      }

      break;





    default:

      ;

    }



    return error;

  }





  /* documentation is in ftbitmap.h */



  FT_EXPORT_DEF( FT_Error )

  FT_GlyphSlot_Own_Bitmap( FT_GlyphSlot  slot )

  {

    if ( slot && slot->format == FT_GLYPH_FORMAT_BITMAP   &&

         !( slot->internal->flags & FT_GLYPH_OWN_BITMAP ) )

    {

      FT_Bitmap  bitmap;

      FT_Error   error;





      FT_Bitmap_New( &bitmap );

      error = FT_Bitmap_Copy( slot->library, &slot->bitmap, &bitmap );

      if ( error )

        return error;



      slot->bitmap = bitmap;

      slot->internal->flags |= FT_GLYPH_OWN_BITMAP;

    }



    return FT_Err_Ok;

  }





  /* documentation is in ftbitmap.h */



  FT_EXPORT_DEF( FT_Error )

  FT_Bitmap_Done( FT_Library  library,

                  FT_Bitmap  *bitmap )

  {

    FT_Memory  memory;





    if ( !library )

      return FT_Err_Invalid_Library_Handle;



    if ( !bitmap )

      return FT_Err_Invalid_Argument;



    memory = library->memory;



    FT_FREE( bitmap->buffer );

    *bitmap = null_bitmap;



    return FT_Err_Ok;

  }





/* END */

