Edit

kc3-lang/freetype/src/base/ftbitmap.c

Branch :

  • Show log

    Commit

  • Author : Werner Lemberg
    Date : 2004-12-28 07:31:35
    Hash : 0f2a4157
    Message : * src/base/ftbitmap.c (FT_Bitmap_Convert): Fix compiler warning.

  • src/base/ftbitmap.c
  • /***************************************************************************/
    /*                                                                         */
    /*  ftbitmap.c                                                             */
    /*                                                                         */
    /*    FreeType utility functions for converting 1bpp, 2bpp, 4bpp, and 8bpp */
    /*    bitmaps into 8bpp format (body).                                     */
    /*                                                                         */
    /*  Copyright 2004 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_FREETYPE_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_Convert( FT_Library        library,
                         const FT_Bitmap  *source,
                         FT_Bitmap        *target,
                         FT_Int            alignment )
      {
        FT_Error   error = FT_Err_Ok;
        FT_Memory  memory;
        FT_Int     i, j, old_size;
        FT_Byte    *s, *ss, *t, *tt;
    
    
        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:
          old_size = target->rows * target->pitch;
    
          target->pixel_mode = FT_PIXEL_MODE_GRAY;
          target->rows       = source->rows;
          target->width      = source->width;
          target->pitch      = ( source->width + alignment - 1 )
                                 / alignment * alignment;
    
          if ( target->rows * target->pitch > old_size )
            if ( FT_QREALLOC( target->buffer,
                              old_size, target->rows * target->pitch ) )
              return error;
    
          break;
    
        default:
          error = FT_Err_Invalid_Argument;
        }
    
        s = source->buffer;
        t = target->buffer;
    
        switch ( source->pixel_mode )
        {
        case FT_PIXEL_MODE_MONO:
          target->num_grays = 2;
    
          for ( i = 0; i < source->rows; i++ )
          {
            ss = s;
            tt = t;
    
            /* get the full bytes */
            for ( j = 0; j < ( source->width >> 3 ); j++ )
            {
              *(tt++) = (FT_Byte)( ( *ss & 0x80 ) >> 7 );
              *(tt++) = (FT_Byte)( ( *ss & 0x40 ) >> 6 );
              *(tt++) = (FT_Byte)( ( *ss & 0x20 ) >> 5 );
              *(tt++) = (FT_Byte)( ( *ss & 0x10 ) >> 4 );
              *(tt++) = (FT_Byte)( ( *ss & 0x08 ) >> 3 );
              *(tt++) = (FT_Byte)( ( *ss & 0x04 ) >> 2 );
              *(tt++) = (FT_Byte)( ( *ss & 0x02 ) >> 1 );
              *(tt++) = (FT_Byte)(   *ss & 0x01 );
    
              ss++;
            }
    
            /* get remaining pixels (if any) */
            switch ( source->width & 7 )
            {
            case 7:
              *(tt++) = (FT_Byte)( ( *ss & 0x80 ) >> 7 );
              /* fall through */
            case 6:
              *(tt++) = (FT_Byte)( ( *ss & 0x40 ) >> 6 );
              /* fall through */
            case 5:
              *(tt++) = (FT_Byte)( ( *ss & 0x20 ) >> 5 );
              /* fall through */
            case 4:
              *(tt++) = (FT_Byte)( ( *ss & 0x10 ) >> 4 );
              /* fall through */
            case 3:
              *(tt++) = (FT_Byte)( ( *ss & 0x08 ) >> 3 );
              /* fall through */
            case 2:
              *(tt++) = (FT_Byte)( ( *ss & 0x04 ) >> 2 );
              /* fall through */
            case 1:
              *(tt++) = (FT_Byte)( ( *ss & 0x02 ) >> 1 );
              /* fall through */
            case 0:
              break;
            }
    
            s += source->pitch;
            t += target->pitch;
          }
          break;
    
        case FT_PIXEL_MODE_GRAY:
          target->num_grays = 256;
    
          for ( i = 0; i < source->rows; i++ )
          {
            ss = s;
            tt = t;
    
            for ( j = 0; j < source->width; j++ )
              *(tt++) = *(ss++);
    
            s += source->pitch;
            t += target->pitch;
          }
          break;
    
        case FT_PIXEL_MODE_GRAY2:
          target->num_grays = 4;
    
          for ( i = 0; i < source->rows; i++ )
          {
            ss = s;
            tt = t;
    
            /* get the full bytes */
            for ( j = 0; j < ( source->width >> 2 ); j++ )
            {
              *(tt++) = (FT_Byte)( ( *ss & 0xC0 ) >> 6 );
              *(tt++) = (FT_Byte)( ( *ss & 0x30 ) >> 4 );
              *(tt++) = (FT_Byte)( ( *ss & 0x0C ) >> 2 );
              *(tt++) = (FT_Byte)(   *ss & 0x03 );
    
              ss++;
            }
    
            /* get remaining pixels (if any) */
            switch ( source->width & 3 )
            {
            case 3:
              *(tt++) = (FT_Byte)( ( *ss & 0xC0 ) >> 6 );
              /* fall through */
            case 2:
              *(tt++) = (FT_Byte)( ( *ss & 0x30 ) >> 4 );
              /* fall through */
            case 1:
              *(tt++) = (FT_Byte)( ( *ss & 0x0C ) >> 2 );
              /* fall through */
            case 0:
              break;
            }
    
            s += source->pitch;
            t += target->pitch;
          }
          break;
    
        case FT_PIXEL_MODE_GRAY4:
          target->num_grays = 16;
    
          for ( i = 0; i < source->rows; i++ )
          {
            ss = s;
            tt = t;
    
            /* get the full bytes */
            for ( j = 0; j < ( source->width >> 1 ); j++ )
            {
              *(tt++) = (FT_Byte)( ( *ss & 0xF0 ) >> 4 );
              *(tt++) = (FT_Byte)(   *ss & 0x0F );
    
              ss++;
            }
    
            /* get remaining pixels (if any) */
            switch ( source->width & 1 )
            {
            case 1:
              *(tt++) = (FT_Byte)( ( *ss & 0xF0 ) >> 4 );
              /* fall through */
            case 0:
              break;
            }
    
            s += source->pitch;
            t += target->pitch;
          }
          break;
    
        }
    
        return error;
      }
    
    
      /* 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 */