forked from minhngoc25a/freetype2
617 lines
14 KiB
C
617 lines
14 KiB
C
/***************************************************************************/
|
|
/* */
|
|
/* ftbitmap.c */
|
|
/* */
|
|
/* FreeType utility functions for converting 1bpp, 2bpp, 4bpp, and 8bpp */
|
|
/* bitmaps into 8bpp format (body). */
|
|
/* */
|
|
/* Copyright 2004, 2005, 2006 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_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 ppb;
|
|
FT_Int i;
|
|
unsigned char* buffer;
|
|
|
|
|
|
pitch = bitmap->pitch;
|
|
if ( pitch < 0 )
|
|
pitch = -pitch;
|
|
|
|
switch ( bitmap->pixel_mode )
|
|
{
|
|
case FT_PIXEL_MODE_MONO:
|
|
ppb = 8;
|
|
break;
|
|
case FT_PIXEL_MODE_GRAY2:
|
|
ppb = 4;
|
|
break;
|
|
case FT_PIXEL_MODE_GRAY4:
|
|
ppb = 2;
|
|
break;
|
|
case FT_PIXEL_MODE_GRAY:
|
|
case FT_PIXEL_MODE_LCD:
|
|
case FT_PIXEL_MODE_LCD_V:
|
|
ppb = 1;
|
|
break;
|
|
default:
|
|
return FT_Err_Invalid_Glyph_Format;
|
|
}
|
|
|
|
/* if no need to allocate memory */
|
|
if ( ypixels == 0 && pitch * ppb >= bitmap->width + xpixels )
|
|
{
|
|
/* zero the padding */
|
|
for ( i = 0; i < bitmap->rows; i++ )
|
|
{
|
|
unsigned char* last_byte;
|
|
int bits = xpixels * ( 8 / ppb );
|
|
int mask = 0;
|
|
|
|
|
|
last_byte = bitmap->buffer + i * pitch + ( bitmap->width - 1 ) / ppb;
|
|
|
|
if ( bits >= 8 )
|
|
{
|
|
FT_MEM_ZERO( last_byte + 1, bits / 8 );
|
|
bits %= 8;
|
|
}
|
|
|
|
if ( bits > 0 )
|
|
{
|
|
while ( bits-- > 0 )
|
|
mask |= 1 << bits;
|
|
|
|
*last_byte &= ~mask;
|
|
}
|
|
}
|
|
|
|
return FT_Err_Ok;
|
|
}
|
|
|
|
new_pitch = ( bitmap->width + xpixels + ppb - 1 ) / ppb;
|
|
|
|
if ( FT_ALLOC( buffer, new_pitch * ( bitmap->rows + ypixels ) ) )
|
|
return error;
|
|
|
|
if ( bitmap->pitch > 0 )
|
|
{
|
|
for ( i = 0; i < bitmap->rows; i++ )
|
|
FT_MEM_COPY( buffer + new_pitch * ( ypixels + i ),
|
|
bitmap->buffer + pitch * i, pitch );
|
|
}
|
|
else
|
|
{
|
|
for ( i = 0; i < bitmap->rows; i++ )
|
|
FT_MEM_COPY( buffer + new_pitch * i,
|
|
bitmap->buffer + pitch * i, pitch );
|
|
}
|
|
|
|
FT_FREE( bitmap->buffer );
|
|
bitmap->buffer = buffer;
|
|
|
|
if ( bitmap->pitch < 0 )
|
|
new_pitch = -new_pitch;
|
|
|
|
/* set pitch only */
|
|
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;
|
|
|
|
xstr = FT_PIX_ROUND( xStrength ) >> 6;
|
|
ystr = 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:
|
|
{
|
|
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:
|
|
{
|
|
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_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 */
|