Home | History | Annotate | Download | only in base
      1 /***************************************************************************/
      2 /*                                                                         */
      3 /*  ftbitmap.c                                                             */
      4 /*                                                                         */
      5 /*    FreeType utility functions for bitmaps (body).                       */
      6 /*                                                                         */
      7 /*  Copyright 2004, 2005, 2006, 2007, 2008, 2009 by                        */
      8 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
      9 /*                                                                         */
     10 /*  This file is part of the FreeType project, and may only be used,       */
     11 /*  modified, and distributed under the terms of the FreeType project      */
     12 /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
     13 /*  this file you indicate that you have read the license and              */
     14 /*  understand and accept it fully.                                        */
     15 /*                                                                         */
     16 /***************************************************************************/
     17 
     18 
     19 #include <ft2build.h>
     20 #include FT_BITMAP_H
     21 #include FT_IMAGE_H
     22 #include FT_INTERNAL_OBJECTS_H
     23 
     24 
     25   static
     26   const FT_Bitmap  null_bitmap = { 0, 0, 0, 0, 0, 0, 0, 0 };
     27 
     28 
     29   /* documentation is in ftbitmap.h */
     30 
     31   FT_EXPORT_DEF( void )
     32   FT_Bitmap_New( FT_Bitmap  *abitmap )
     33   {
     34     *abitmap = null_bitmap;
     35   }
     36 
     37 
     38   /* documentation is in ftbitmap.h */
     39 
     40   FT_EXPORT_DEF( FT_Error )
     41   FT_Bitmap_Copy( FT_Library        library,
     42                   const FT_Bitmap  *source,
     43                   FT_Bitmap        *target)
     44   {
     45     FT_Memory  memory = library->memory;
     46     FT_Error   error  = FT_Err_Ok;
     47     FT_Int     pitch  = source->pitch;
     48     FT_ULong   size;
     49 
     50 
     51     if ( source == target )
     52       return FT_Err_Ok;
     53 
     54     if ( source->buffer == NULL )
     55     {
     56       *target = *source;
     57 
     58       return FT_Err_Ok;
     59     }
     60 
     61     if ( pitch < 0 )
     62       pitch = -pitch;
     63     size = (FT_ULong)( pitch * source->rows );
     64 
     65     if ( target->buffer )
     66     {
     67       FT_Int    target_pitch = target->pitch;
     68       FT_ULong  target_size;
     69 
     70 
     71       if ( target_pitch < 0  )
     72         target_pitch = -target_pitch;
     73       target_size = (FT_ULong)( target_pitch * target->rows );
     74 
     75       if ( target_size != size )
     76         (void)FT_QREALLOC( target->buffer, target_size, size );
     77     }
     78     else
     79       (void)FT_QALLOC( target->buffer, size );
     80 
     81     if ( !error )
     82     {
     83       unsigned char *p;
     84 
     85 
     86       p = target->buffer;
     87       *target = *source;
     88       target->buffer = p;
     89 
     90       FT_MEM_COPY( target->buffer, source->buffer, size );
     91     }
     92 
     93     return error;
     94   }
     95 
     96 
     97   static FT_Error
     98   ft_bitmap_assure_buffer( FT_Memory   memory,
     99                            FT_Bitmap*  bitmap,
    100                            FT_UInt     xpixels,
    101                            FT_UInt     ypixels )
    102   {
    103     FT_Error        error;
    104     int             pitch;
    105     int             new_pitch;
    106     FT_UInt         bpp;
    107     FT_Int          i, width, height;
    108     unsigned char*  buffer = NULL;
    109 
    110 
    111     width  = bitmap->width;
    112     height = bitmap->rows;
    113     pitch  = bitmap->pitch;
    114     if ( pitch < 0 )
    115       pitch = -pitch;
    116 
    117     switch ( bitmap->pixel_mode )
    118     {
    119     case FT_PIXEL_MODE_MONO:
    120       bpp       = 1;
    121       new_pitch = ( width + xpixels + 7 ) >> 3;
    122       break;
    123     case FT_PIXEL_MODE_GRAY2:
    124       bpp       = 2;
    125       new_pitch = ( width + xpixels + 3 ) >> 2;
    126       break;
    127     case FT_PIXEL_MODE_GRAY4:
    128       bpp       = 4;
    129       new_pitch = ( width + xpixels + 1 ) >> 1;
    130       break;
    131     case FT_PIXEL_MODE_GRAY:
    132     case FT_PIXEL_MODE_LCD:
    133     case FT_PIXEL_MODE_LCD_V:
    134       bpp       = 8;
    135       new_pitch = ( width + xpixels );
    136       break;
    137     default:
    138       return FT_Err_Invalid_Glyph_Format;
    139     }
    140 
    141     /* if no need to allocate memory */
    142     if ( ypixels == 0 && new_pitch <= pitch )
    143     {
    144       /* zero the padding */
    145       FT_Int  bit_width = pitch * 8;
    146       FT_Int  bit_last  = ( width + xpixels ) * bpp;
    147 
    148 
    149       if ( bit_last < bit_width )
    150       {
    151         FT_Byte*  line  = bitmap->buffer + ( bit_last >> 3 );
    152         FT_Byte*  end   = bitmap->buffer + pitch;
    153         FT_Int    shift = bit_last & 7;
    154         FT_UInt   mask  = 0xFF00U >> shift;
    155         FT_Int    count = height;
    156 
    157 
    158         for ( ; count > 0; count--, line += pitch, end += pitch )
    159         {
    160           FT_Byte*  write = line;
    161 
    162 
    163           if ( shift > 0 )
    164           {
    165             write[0] = (FT_Byte)( write[0] & mask );
    166             write++;
    167           }
    168           if ( write < end )
    169             FT_MEM_ZERO( write, end-write );
    170         }
    171       }
    172 
    173       return FT_Err_Ok;
    174     }
    175 
    176     if ( FT_QALLOC_MULT( buffer, new_pitch, bitmap->rows + ypixels ) )
    177       return error;
    178 
    179     if ( bitmap->pitch > 0 )
    180     {
    181       FT_Int  len = ( width * bpp + 7 ) >> 3;
    182 
    183 
    184       for ( i = 0; i < bitmap->rows; i++ )
    185         FT_MEM_COPY( buffer + new_pitch * ( ypixels + i ),
    186                      bitmap->buffer + pitch * i, len );
    187     }
    188     else
    189     {
    190       FT_Int  len = ( width * bpp + 7 ) >> 3;
    191 
    192 
    193       for ( i = 0; i < bitmap->rows; i++ )
    194         FT_MEM_COPY( buffer + new_pitch * i,
    195                      bitmap->buffer + pitch * i, len );
    196     }
    197 
    198     FT_FREE( bitmap->buffer );
    199     bitmap->buffer = buffer;
    200 
    201     if ( bitmap->pitch < 0 )
    202       new_pitch = -new_pitch;
    203 
    204     /* set pitch only, width and height are left untouched */
    205     bitmap->pitch = new_pitch;
    206 
    207     return FT_Err_Ok;
    208   }
    209 
    210 
    211   /* documentation is in ftbitmap.h */
    212 
    213   FT_EXPORT_DEF( FT_Error )
    214   FT_Bitmap_Embolden( FT_Library  library,
    215                       FT_Bitmap*  bitmap,
    216                       FT_Pos      xStrength,
    217                       FT_Pos      yStrength )
    218   {
    219     FT_Error        error;
    220     unsigned char*  p;
    221     FT_Int          i, x, y, pitch;
    222     FT_Int          xstr, ystr;
    223 
    224 
    225     if ( !library )
    226       return FT_Err_Invalid_Library_Handle;
    227 
    228     if ( !bitmap || !bitmap->buffer )
    229       return FT_Err_Invalid_Argument;
    230 
    231     if ( ( ( FT_PIX_ROUND( xStrength ) >> 6 ) > FT_INT_MAX ) ||
    232          ( ( FT_PIX_ROUND( yStrength ) >> 6 ) > FT_INT_MAX ) )
    233       return FT_Err_Invalid_Argument;
    234 
    235     xstr = (FT_Int)FT_PIX_ROUND( xStrength ) >> 6;
    236     ystr = (FT_Int)FT_PIX_ROUND( yStrength ) >> 6;
    237 
    238     if ( xstr == 0 && ystr == 0 )
    239       return FT_Err_Ok;
    240     else if ( xstr < 0 || ystr < 0 )
    241       return FT_Err_Invalid_Argument;
    242 
    243     switch ( bitmap->pixel_mode )
    244     {
    245     case FT_PIXEL_MODE_GRAY2:
    246     case FT_PIXEL_MODE_GRAY4:
    247       {
    248         FT_Bitmap  tmp;
    249         FT_Int     align;
    250 
    251 
    252         if ( bitmap->pixel_mode == FT_PIXEL_MODE_GRAY2 )
    253           align = ( bitmap->width + xstr + 3 ) / 4;
    254         else
    255           align = ( bitmap->width + xstr + 1 ) / 2;
    256 
    257         FT_Bitmap_New( &tmp );
    258 
    259         error = FT_Bitmap_Convert( library, bitmap, &tmp, align );
    260         if ( error )
    261           return error;
    262 
    263         FT_Bitmap_Done( library, bitmap );
    264         *bitmap = tmp;
    265       }
    266       break;
    267 
    268     case FT_PIXEL_MODE_MONO:
    269       if ( xstr > 8 )
    270         xstr = 8;
    271       break;
    272 
    273     case FT_PIXEL_MODE_LCD:
    274       xstr *= 3;
    275       break;
    276 
    277     case FT_PIXEL_MODE_LCD_V:
    278       ystr *= 3;
    279       break;
    280     }
    281 
    282     error = ft_bitmap_assure_buffer( library->memory, bitmap, xstr, ystr );
    283     if ( error )
    284       return error;
    285 
    286     pitch = bitmap->pitch;
    287     if ( pitch > 0 )
    288       p = bitmap->buffer + pitch * ystr;
    289     else
    290     {
    291       pitch = -pitch;
    292       p = bitmap->buffer + pitch * ( bitmap->rows - 1 );
    293     }
    294 
    295     /* for each row */
    296     for ( y = 0; y < bitmap->rows ; y++ )
    297     {
    298       /*
    299        * Horizontally:
    300        *
    301        * From the last pixel on, make each pixel or'ed with the
    302        * `xstr' pixels before it.
    303        */
    304       for ( x = pitch - 1; x >= 0; x-- )
    305       {
    306         unsigned char tmp;
    307 
    308 
    309         tmp = p[x];
    310         for ( i = 1; i <= xstr; i++ )
    311         {
    312           if ( bitmap->pixel_mode == FT_PIXEL_MODE_MONO )
    313           {
    314             p[x] |= tmp >> i;
    315 
    316             /* the maximum value of 8 for `xstr' comes from here */
    317             if ( x > 0 )
    318               p[x] |= p[x - 1] << ( 8 - i );
    319 
    320 #if 0
    321             if ( p[x] == 0xff )
    322               break;
    323 #endif
    324           }
    325           else
    326           {
    327             if ( x - i >= 0 )
    328             {
    329               if ( p[x] + p[x - i] > bitmap->num_grays - 1 )
    330               {
    331                 p[x] = (unsigned char)(bitmap->num_grays - 1);
    332                 break;
    333               }
    334               else
    335               {
    336                 p[x] = (unsigned char)(p[x] + p[x-i]);
    337                 if ( p[x] == bitmap->num_grays - 1 )
    338                   break;
    339               }
    340             }
    341             else
    342               break;
    343           }
    344         }
    345       }
    346 
    347       /*
    348        * Vertically:
    349        *
    350        * Make the above `ystr' rows or'ed with it.
    351        */
    352       for ( x = 1; x <= ystr; x++ )
    353       {
    354         unsigned char*  q;
    355 
    356 
    357         q = p - bitmap->pitch * x;
    358         for ( i = 0; i < pitch; i++ )
    359           q[i] |= p[i];
    360       }
    361 
    362       p += bitmap->pitch;
    363     }
    364 
    365     bitmap->width += xstr;
    366     bitmap->rows += ystr;
    367 
    368     return FT_Err_Ok;
    369   }
    370 
    371 
    372   /* documentation is in ftbitmap.h */
    373 
    374   FT_EXPORT_DEF( FT_Error )
    375   FT_Bitmap_Convert( FT_Library        library,
    376                      const FT_Bitmap  *source,
    377                      FT_Bitmap        *target,
    378                      FT_Int            alignment )
    379   {
    380     FT_Error   error = FT_Err_Ok;
    381     FT_Memory  memory;
    382 
    383 
    384     if ( !library )
    385       return FT_Err_Invalid_Library_Handle;
    386 
    387     memory = library->memory;
    388 
    389     switch ( source->pixel_mode )
    390     {
    391     case FT_PIXEL_MODE_MONO:
    392     case FT_PIXEL_MODE_GRAY:
    393     case FT_PIXEL_MODE_GRAY2:
    394     case FT_PIXEL_MODE_GRAY4:
    395     case FT_PIXEL_MODE_LCD:
    396     case FT_PIXEL_MODE_LCD_V:
    397       {
    398         FT_Int   pad;
    399         FT_Long  old_size;
    400 
    401 
    402         old_size = target->rows * target->pitch;
    403         if ( old_size < 0 )
    404           old_size = -old_size;
    405 
    406         target->pixel_mode = FT_PIXEL_MODE_GRAY;
    407         target->rows       = source->rows;
    408         target->width      = source->width;
    409 
    410         pad = 0;
    411         if ( alignment > 0 )
    412         {
    413           pad = source->width % alignment;
    414           if ( pad != 0 )
    415             pad = alignment - pad;
    416         }
    417 
    418         target->pitch = source->width + pad;
    419 
    420         if ( target->rows * target->pitch > old_size             &&
    421              FT_QREALLOC( target->buffer,
    422                           old_size, target->rows * target->pitch ) )
    423           return error;
    424       }
    425       break;
    426 
    427     default:
    428       error = FT_Err_Invalid_Argument;
    429     }
    430 
    431     switch ( source->pixel_mode )
    432     {
    433     case FT_PIXEL_MODE_MONO:
    434       {
    435         FT_Byte*  s = source->buffer;
    436         FT_Byte*  t = target->buffer;
    437         FT_Int    i;
    438 
    439 
    440         target->num_grays = 2;
    441 
    442         for ( i = source->rows; i > 0; i-- )
    443         {
    444           FT_Byte*  ss = s;
    445           FT_Byte*  tt = t;
    446           FT_Int    j;
    447 
    448 
    449           /* get the full bytes */
    450           for ( j = source->width >> 3; j > 0; j-- )
    451           {
    452             FT_Int  val = ss[0]; /* avoid a byte->int cast on each line */
    453 
    454 
    455             tt[0] = (FT_Byte)( ( val & 0x80 ) >> 7 );
    456             tt[1] = (FT_Byte)( ( val & 0x40 ) >> 6 );
    457             tt[2] = (FT_Byte)( ( val & 0x20 ) >> 5 );
    458             tt[3] = (FT_Byte)( ( val & 0x10 ) >> 4 );
    459             tt[4] = (FT_Byte)( ( val & 0x08 ) >> 3 );
    460             tt[5] = (FT_Byte)( ( val & 0x04 ) >> 2 );
    461             tt[6] = (FT_Byte)( ( val & 0x02 ) >> 1 );
    462             tt[7] = (FT_Byte)(   val & 0x01 );
    463 
    464             tt += 8;
    465             ss += 1;
    466           }
    467 
    468           /* get remaining pixels (if any) */
    469           j = source->width & 7;
    470           if ( j > 0 )
    471           {
    472             FT_Int  val = *ss;
    473 
    474 
    475             for ( ; j > 0; j-- )
    476             {
    477               tt[0] = (FT_Byte)( ( val & 0x80 ) >> 7);
    478               val <<= 1;
    479               tt   += 1;
    480             }
    481           }
    482 
    483           s += source->pitch;
    484           t += target->pitch;
    485         }
    486       }
    487       break;
    488 
    489 
    490     case FT_PIXEL_MODE_GRAY:
    491     case FT_PIXEL_MODE_LCD:
    492     case FT_PIXEL_MODE_LCD_V:
    493       {
    494         FT_Int    width   = source->width;
    495         FT_Byte*  s       = source->buffer;
    496         FT_Byte*  t       = target->buffer;
    497         FT_Int    s_pitch = source->pitch;
    498         FT_Int    t_pitch = target->pitch;
    499         FT_Int    i;
    500 
    501 
    502         target->num_grays = 256;
    503 
    504         for ( i = source->rows; i > 0; i-- )
    505         {
    506           FT_ARRAY_COPY( t, s, width );
    507 
    508           s += s_pitch;
    509           t += t_pitch;
    510         }
    511       }
    512       break;
    513 
    514 
    515     case FT_PIXEL_MODE_GRAY2:
    516       {
    517         FT_Byte*  s = source->buffer;
    518         FT_Byte*  t = target->buffer;
    519         FT_Int    i;
    520 
    521 
    522         target->num_grays = 4;
    523 
    524         for ( i = source->rows; i > 0; i-- )
    525         {
    526           FT_Byte*  ss = s;
    527           FT_Byte*  tt = t;
    528           FT_Int    j;
    529 
    530 
    531           /* get the full bytes */
    532           for ( j = source->width >> 2; j > 0; j-- )
    533           {
    534             FT_Int  val = ss[0];
    535 
    536 
    537             tt[0] = (FT_Byte)( ( val & 0xC0 ) >> 6 );
    538             tt[1] = (FT_Byte)( ( val & 0x30 ) >> 4 );
    539             tt[2] = (FT_Byte)( ( val & 0x0C ) >> 2 );
    540             tt[3] = (FT_Byte)( ( val & 0x03 ) );
    541 
    542             ss += 1;
    543             tt += 4;
    544           }
    545 
    546           j = source->width & 3;
    547           if ( j > 0 )
    548           {
    549             FT_Int  val = ss[0];
    550 
    551 
    552             for ( ; j > 0; j-- )
    553             {
    554               tt[0]  = (FT_Byte)( ( val & 0xC0 ) >> 6 );
    555               val  <<= 2;
    556               tt    += 1;
    557             }
    558           }
    559 
    560           s += source->pitch;
    561           t += target->pitch;
    562         }
    563       }
    564       break;
    565 
    566 
    567     case FT_PIXEL_MODE_GRAY4:
    568       {
    569         FT_Byte*  s = source->buffer;
    570         FT_Byte*  t = target->buffer;
    571         FT_Int    i;
    572 
    573 
    574         target->num_grays = 16;
    575 
    576         for ( i = source->rows; i > 0; i-- )
    577         {
    578           FT_Byte*  ss = s;
    579           FT_Byte*  tt = t;
    580           FT_Int    j;
    581 
    582 
    583           /* get the full bytes */
    584           for ( j = source->width >> 1; j > 0; j-- )
    585           {
    586             FT_Int  val = ss[0];
    587 
    588 
    589             tt[0] = (FT_Byte)( ( val & 0xF0 ) >> 4 );
    590             tt[1] = (FT_Byte)( ( val & 0x0F ) );
    591 
    592             ss += 1;
    593             tt += 2;
    594           }
    595 
    596           if ( source->width & 1 )
    597             tt[0] = (FT_Byte)( ( ss[0] & 0xF0 ) >> 4 );
    598 
    599           s += source->pitch;
    600           t += target->pitch;
    601         }
    602       }
    603       break;
    604 
    605 
    606     default:
    607       ;
    608     }
    609 
    610     return error;
    611   }
    612 
    613 
    614   /* documentation is in ftbitmap.h */
    615 
    616   FT_EXPORT_DEF( FT_Error )
    617   FT_GlyphSlot_Own_Bitmap( FT_GlyphSlot  slot )
    618   {
    619     if ( slot && slot->format == FT_GLYPH_FORMAT_BITMAP   &&
    620          !( slot->internal->flags & FT_GLYPH_OWN_BITMAP ) )
    621     {
    622       FT_Bitmap  bitmap;
    623       FT_Error   error;
    624 
    625 
    626       FT_Bitmap_New( &bitmap );
    627       error = FT_Bitmap_Copy( slot->library, &slot->bitmap, &bitmap );
    628       if ( error )
    629         return error;
    630 
    631       slot->bitmap = bitmap;
    632       slot->internal->flags |= FT_GLYPH_OWN_BITMAP;
    633     }
    634 
    635     return FT_Err_Ok;
    636   }
    637 
    638 
    639   /* documentation is in ftbitmap.h */
    640 
    641   FT_EXPORT_DEF( FT_Error )
    642   FT_Bitmap_Done( FT_Library  library,
    643                   FT_Bitmap  *bitmap )
    644   {
    645     FT_Memory  memory;
    646 
    647 
    648     if ( !library )
    649       return FT_Err_Invalid_Library_Handle;
    650 
    651     if ( !bitmap )
    652       return FT_Err_Invalid_Argument;
    653 
    654     memory = library->memory;
    655 
    656     FT_FREE( bitmap->buffer );
    657     *bitmap = null_bitmap;
    658 
    659     return FT_Err_Ok;
    660   }
    661 
    662 
    663 /* END */
    664