-/***************************************************************************/
-/* */
-/* ftbitmap.c */
-/* */
-/* FreeType utility functions for converting 1bpp, 2bpp, 4bpp, and 8bpp */
-/* bitmaps into 8bpp format (body). */
-/* */
-/* Copyright 2004, 2005, 2006, 2007 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 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;
-
- 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 */
+/***************************************************************************/\r
+/* */\r
+/* ftbitmap.c */\r
+/* */\r
+/* FreeType utility functions for converting 1bpp, 2bpp, 4bpp, and 8bpp */\r
+/* bitmaps into 8bpp format (body). */\r
+/* */\r
+/* Copyright 2004, 2005, 2006, 2007 by */\r
+/* David Turner, Robert Wilhelm, and Werner Lemberg. */\r
+/* */\r
+/* This file is part of the FreeType project, and may only be used, */\r
+/* modified, and distributed under the terms of the FreeType project */\r
+/* license, LICENSE.TXT. By continuing to use, modify, or distribute */\r
+/* this file you indicate that you have read the license and */\r
+/* understand and accept it fully. */\r
+/* */\r
+/***************************************************************************/\r
+\r
+\r
+#include <ft2build.h>\r
+#include FT_BITMAP_H\r
+#include FT_INTERNAL_OBJECTS_H\r
+\r
+\r
+ static\r
+ const FT_Bitmap null_bitmap = { 0, 0, 0, 0, 0, 0, 0, 0 };\r
+\r
+\r
+ /* documentation is in ftbitmap.h */\r
+\r
+ FT_EXPORT_DEF( void )\r
+ FT_Bitmap_New( FT_Bitmap *abitmap )\r
+ {\r
+ *abitmap = null_bitmap;\r
+ }\r
+\r
+\r
+ /* documentation is in ftbitmap.h */\r
+\r
+ FT_EXPORT_DEF( FT_Error )\r
+ FT_Bitmap_Copy( FT_Library library,\r
+ const FT_Bitmap *source,\r
+ FT_Bitmap *target)\r
+ {\r
+ FT_Memory memory = library->memory;\r
+ FT_Error error = FT_Err_Ok;\r
+ FT_Int pitch = source->pitch;\r
+ FT_ULong size;\r
+\r
+\r
+ if ( source == target )\r
+ return FT_Err_Ok;\r
+\r
+ if ( source->buffer == NULL )\r
+ {\r
+ *target = *source;\r
+\r
+ return FT_Err_Ok;\r
+ }\r
+\r
+ if ( pitch < 0 )\r
+ pitch = -pitch;\r
+ size = (FT_ULong)( pitch * source->rows );\r
+\r
+ if ( target->buffer )\r
+ {\r
+ FT_Int target_pitch = target->pitch;\r
+ FT_ULong target_size;\r
+\r
+\r
+ if ( target_pitch < 0 )\r
+ target_pitch = -target_pitch;\r
+ target_size = (FT_ULong)( target_pitch * target->rows );\r
+\r
+ if ( target_size != size )\r
+ (void)FT_QREALLOC( target->buffer, target_size, size );\r
+ }\r
+ else\r
+ (void)FT_QALLOC( target->buffer, size );\r
+\r
+ if ( !error )\r
+ {\r
+ unsigned char *p;\r
+\r
+\r
+ p = target->buffer;\r
+ *target = *source;\r
+ target->buffer = p;\r
+\r
+ FT_MEM_COPY( target->buffer, source->buffer, size );\r
+ }\r
+\r
+ return error;\r
+ }\r
+\r
+\r
+ static FT_Error\r
+ ft_bitmap_assure_buffer( FT_Memory memory,\r
+ FT_Bitmap* bitmap,\r
+ FT_UInt xpixels,\r
+ FT_UInt ypixels )\r
+ {\r
+ FT_Error error;\r
+ int pitch;\r
+ int new_pitch;\r
+ FT_UInt bpp;\r
+ FT_Int i, width, height;\r
+ unsigned char* buffer;\r
+\r
+\r
+ width = bitmap->width;\r
+ height = bitmap->rows;\r
+ pitch = bitmap->pitch;\r
+ if ( pitch < 0 )\r
+ pitch = -pitch;\r
+\r
+ switch ( bitmap->pixel_mode )\r
+ {\r
+ case FT_PIXEL_MODE_MONO:\r
+ bpp = 1;\r
+ new_pitch = ( width + xpixels + 7 ) >> 3;\r
+ break;\r
+ case FT_PIXEL_MODE_GRAY2:\r
+ bpp = 2;\r
+ new_pitch = ( width + xpixels + 3 ) >> 2;\r
+ break;\r
+ case FT_PIXEL_MODE_GRAY4:\r
+ bpp = 4;\r
+ new_pitch = ( width + xpixels + 1 ) >> 1;\r
+ break;\r
+ case FT_PIXEL_MODE_GRAY:\r
+ case FT_PIXEL_MODE_LCD:\r
+ case FT_PIXEL_MODE_LCD_V:\r
+ bpp = 8;\r
+ new_pitch = ( width + xpixels );\r
+ break;\r
+ default:\r
+ return FT_Err_Invalid_Glyph_Format;\r
+ }\r
+\r
+ /* if no need to allocate memory */\r
+ if ( ypixels == 0 && new_pitch <= pitch )\r
+ {\r
+ /* zero the padding */\r
+ FT_Int bit_width = pitch * 8;\r
+ FT_Int bit_last = ( width + xpixels ) * bpp;\r
+\r
+\r
+ if ( bit_last < bit_width )\r
+ {\r
+ FT_Byte* line = bitmap->buffer + ( bit_last >> 3 );\r
+ FT_Byte* end = bitmap->buffer + pitch;\r
+ FT_Int shift = bit_last & 7;\r
+ FT_UInt mask = 0xFF00U >> shift;\r
+ FT_Int count = height;\r
+\r
+\r
+ for ( ; count > 0; count--, line += pitch, end += pitch )\r
+ {\r
+ FT_Byte* write = line;\r
+\r
+\r
+ if ( shift > 0 )\r
+ {\r
+ write[0] = (FT_Byte)( write[0] & mask );\r
+ write++;\r
+ }\r
+ if ( write < end )\r
+ FT_MEM_ZERO( write, end-write );\r
+ }\r
+ }\r
+\r
+ return FT_Err_Ok;\r
+ }\r
+\r
+ if ( FT_QALLOC_MULT( buffer, new_pitch, bitmap->rows + ypixels ) )\r
+ return error;\r
+\r
+ if ( bitmap->pitch > 0 )\r
+ {\r
+ FT_Int len = ( width * bpp + 7 ) >> 3;\r
+\r
+\r
+ for ( i = 0; i < bitmap->rows; i++ )\r
+ FT_MEM_COPY( buffer + new_pitch * ( ypixels + i ),\r
+ bitmap->buffer + pitch * i, len );\r
+ }\r
+ else\r
+ {\r
+ FT_Int len = ( width * bpp + 7 ) >> 3;\r
+\r
+\r
+ for ( i = 0; i < bitmap->rows; i++ )\r
+ FT_MEM_COPY( buffer + new_pitch * i,\r
+ bitmap->buffer + pitch * i, len );\r
+ }\r
+\r
+ FT_FREE( bitmap->buffer );\r
+ bitmap->buffer = buffer;\r
+\r
+ if ( bitmap->pitch < 0 )\r
+ new_pitch = -new_pitch;\r
+\r
+ /* set pitch only, width and height are left untouched */\r
+ bitmap->pitch = new_pitch;\r
+\r
+ return FT_Err_Ok;\r
+ }\r
+\r
+\r
+ /* documentation is in ftbitmap.h */\r
+\r
+ FT_EXPORT_DEF( FT_Error )\r
+ FT_Bitmap_Embolden( FT_Library library,\r
+ FT_Bitmap* bitmap,\r
+ FT_Pos xStrength,\r
+ FT_Pos yStrength )\r
+ {\r
+ FT_Error error;\r
+ unsigned char* p;\r
+ FT_Int i, x, y, pitch;\r
+ FT_Int xstr, ystr;\r
+\r
+\r
+ if ( !library )\r
+ return FT_Err_Invalid_Library_Handle;\r
+\r
+ if ( !bitmap || !bitmap->buffer )\r
+ return FT_Err_Invalid_Argument;\r
+\r
+ xstr = FT_PIX_ROUND( xStrength ) >> 6;\r
+ ystr = FT_PIX_ROUND( yStrength ) >> 6;\r
+\r
+ if ( xstr == 0 && ystr == 0 )\r
+ return FT_Err_Ok;\r
+ else if ( xstr < 0 || ystr < 0 )\r
+ return FT_Err_Invalid_Argument;\r
+\r
+ switch ( bitmap->pixel_mode )\r
+ {\r
+ case FT_PIXEL_MODE_GRAY2:\r
+ case FT_PIXEL_MODE_GRAY4:\r
+ {\r
+ FT_Bitmap tmp;\r
+ FT_Int align;\r
+\r
+\r
+ if ( bitmap->pixel_mode == FT_PIXEL_MODE_GRAY2 )\r
+ align = ( bitmap->width + xstr + 3 ) / 4;\r
+ else\r
+ align = ( bitmap->width + xstr + 1 ) / 2;\r
+\r
+ FT_Bitmap_New( &tmp );\r
+\r
+ error = FT_Bitmap_Convert( library, bitmap, &tmp, align );\r
+ if ( error )\r
+ return error;\r
+\r
+ FT_Bitmap_Done( library, bitmap );\r
+ *bitmap = tmp;\r
+ }\r
+ break;\r
+\r
+ case FT_PIXEL_MODE_MONO:\r
+ if ( xstr > 8 )\r
+ xstr = 8;\r
+ break;\r
+\r
+ case FT_PIXEL_MODE_LCD:\r
+ xstr *= 3;\r
+ break;\r
+\r
+ case FT_PIXEL_MODE_LCD_V:\r
+ ystr *= 3;\r
+ break;\r
+ }\r
+\r
+ error = ft_bitmap_assure_buffer( library->memory, bitmap, xstr, ystr );\r
+ if ( error )\r
+ return error;\r
+\r
+ pitch = bitmap->pitch;\r
+ if ( pitch > 0 )\r
+ p = bitmap->buffer + pitch * ystr;\r
+ else\r
+ {\r
+ pitch = -pitch;\r
+ p = bitmap->buffer + pitch * ( bitmap->rows - 1 );\r
+ }\r
+\r
+ /* for each row */\r
+ for ( y = 0; y < bitmap->rows ; y++ )\r
+ {\r
+ /*\r
+ * Horizontally:\r
+ *\r
+ * From the last pixel on, make each pixel or'ed with the\r
+ * `xstr' pixels before it.\r
+ */\r
+ for ( x = pitch - 1; x >= 0; x-- )\r
+ {\r
+ unsigned char tmp;\r
+\r
+\r
+ tmp = p[x];\r
+ for ( i = 1; i <= xstr; i++ )\r
+ {\r
+ if ( bitmap->pixel_mode == FT_PIXEL_MODE_MONO )\r
+ {\r
+ p[x] |= tmp >> i;\r
+\r
+ /* the maximum value of 8 for `xstr' comes from here */\r
+ if ( x > 0 )\r
+ p[x] |= p[x - 1] << ( 8 - i );\r
+\r
+#if 0\r
+ if ( p[x] == 0xff )\r
+ break;\r
+#endif\r
+ }\r
+ else\r
+ {\r
+ if ( x - i >= 0 )\r
+ {\r
+ if ( p[x] + p[x - i] > bitmap->num_grays - 1 )\r
+ {\r
+ p[x] = (unsigned char)(bitmap->num_grays - 1);\r
+ break;\r
+ }\r
+ else\r
+ {\r
+ p[x] = (unsigned char)(p[x] + p[x-i]);\r
+ if ( p[x] == bitmap->num_grays - 1 )\r
+ break;\r
+ }\r
+ }\r
+ else\r
+ break;\r
+ }\r
+ }\r
+ }\r
+\r
+ /*\r
+ * Vertically:\r
+ *\r
+ * Make the above `ystr' rows or'ed with it.\r
+ */\r
+ for ( x = 1; x <= ystr; x++ )\r
+ {\r
+ unsigned char* q;\r
+\r
+\r
+ q = p - bitmap->pitch * x;\r
+ for ( i = 0; i < pitch; i++ )\r
+ q[i] |= p[i];\r
+ }\r
+\r
+ p += bitmap->pitch;\r
+ }\r
+\r
+ bitmap->width += xstr;\r
+ bitmap->rows += ystr;\r
+\r
+ return FT_Err_Ok;\r
+ }\r
+\r
+\r
+ /* documentation is in ftbitmap.h */\r
+\r
+ FT_EXPORT_DEF( FT_Error )\r
+ FT_Bitmap_Convert( FT_Library library,\r
+ const FT_Bitmap *source,\r
+ FT_Bitmap *target,\r
+ FT_Int alignment )\r
+ {\r
+ FT_Error error = FT_Err_Ok;\r
+ FT_Memory memory;\r
+\r
+\r
+ if ( !library )\r
+ return FT_Err_Invalid_Library_Handle;\r
+\r
+ memory = library->memory;\r
+\r
+ switch ( source->pixel_mode )\r
+ {\r
+ case FT_PIXEL_MODE_MONO:\r
+ case FT_PIXEL_MODE_GRAY:\r
+ case FT_PIXEL_MODE_GRAY2:\r
+ case FT_PIXEL_MODE_GRAY4:\r
+ {\r
+ FT_Int pad;\r
+ FT_Long old_size;\r
+\r
+\r
+ old_size = target->rows * target->pitch;\r
+ if ( old_size < 0 )\r
+ old_size = -old_size;\r
+\r
+ target->pixel_mode = FT_PIXEL_MODE_GRAY;\r
+ target->rows = source->rows;\r
+ target->width = source->width;\r
+\r
+ pad = 0;\r
+ if ( alignment > 0 )\r
+ {\r
+ pad = source->width % alignment;\r
+ if ( pad != 0 )\r
+ pad = alignment - pad;\r
+ }\r
+\r
+ target->pitch = source->width + pad;\r
+\r
+ if ( target->rows * target->pitch > old_size &&\r
+ FT_QREALLOC( target->buffer,\r
+ old_size, target->rows * target->pitch ) )\r
+ return error;\r
+ }\r
+ break;\r
+\r
+ default:\r
+ error = FT_Err_Invalid_Argument;\r
+ }\r
+\r
+ switch ( source->pixel_mode )\r
+ {\r
+ case FT_PIXEL_MODE_MONO:\r
+ {\r
+ FT_Byte* s = source->buffer;\r
+ FT_Byte* t = target->buffer;\r
+ FT_Int i;\r
+\r
+\r
+ target->num_grays = 2;\r
+\r
+ for ( i = source->rows; i > 0; i-- )\r
+ {\r
+ FT_Byte* ss = s;\r
+ FT_Byte* tt = t;\r
+ FT_Int j;\r
+\r
+\r
+ /* get the full bytes */\r
+ for ( j = source->width >> 3; j > 0; j-- )\r
+ {\r
+ FT_Int val = ss[0]; /* avoid a byte->int cast on each line */\r
+\r
+\r
+ tt[0] = (FT_Byte)( ( val & 0x80 ) >> 7 );\r
+ tt[1] = (FT_Byte)( ( val & 0x40 ) >> 6 );\r
+ tt[2] = (FT_Byte)( ( val & 0x20 ) >> 5 );\r
+ tt[3] = (FT_Byte)( ( val & 0x10 ) >> 4 );\r
+ tt[4] = (FT_Byte)( ( val & 0x08 ) >> 3 );\r
+ tt[5] = (FT_Byte)( ( val & 0x04 ) >> 2 );\r
+ tt[6] = (FT_Byte)( ( val & 0x02 ) >> 1 );\r
+ tt[7] = (FT_Byte)( val & 0x01 );\r
+\r
+ tt += 8;\r
+ ss += 1;\r
+ }\r
+\r
+ /* get remaining pixels (if any) */\r
+ j = source->width & 7;\r
+ if ( j > 0 )\r
+ {\r
+ FT_Int val = *ss;\r
+\r
+\r
+ for ( ; j > 0; j-- )\r
+ {\r
+ tt[0] = (FT_Byte)( ( val & 0x80 ) >> 7);\r
+ val <<= 1;\r
+ tt += 1;\r
+ }\r
+ }\r
+\r
+ s += source->pitch;\r
+ t += target->pitch;\r
+ }\r
+ }\r
+ break;\r
+\r
+\r
+ case FT_PIXEL_MODE_GRAY:\r
+ {\r
+ FT_Int width = source->width;\r
+ FT_Byte* s = source->buffer;\r
+ FT_Byte* t = target->buffer;\r
+ FT_Int s_pitch = source->pitch;\r
+ FT_Int t_pitch = target->pitch;\r
+ FT_Int i;\r
+\r
+\r
+ target->num_grays = 256;\r
+\r
+ for ( i = source->rows; i > 0; i-- )\r
+ {\r
+ FT_ARRAY_COPY( t, s, width );\r
+\r
+ s += s_pitch;\r
+ t += t_pitch;\r
+ }\r
+ }\r
+ break;\r
+\r
+\r
+ case FT_PIXEL_MODE_GRAY2:\r
+ {\r
+ FT_Byte* s = source->buffer;\r
+ FT_Byte* t = target->buffer;\r
+ FT_Int i;\r
+\r
+\r
+ target->num_grays = 4;\r
+\r
+ for ( i = source->rows; i > 0; i-- )\r
+ {\r
+ FT_Byte* ss = s;\r
+ FT_Byte* tt = t;\r
+ FT_Int j;\r
+\r
+\r
+ /* get the full bytes */\r
+ for ( j = source->width >> 2; j > 0; j-- )\r
+ {\r
+ FT_Int val = ss[0];\r
+\r
+\r
+ tt[0] = (FT_Byte)( ( val & 0xC0 ) >> 6 );\r
+ tt[1] = (FT_Byte)( ( val & 0x30 ) >> 4 );\r
+ tt[2] = (FT_Byte)( ( val & 0x0C ) >> 2 );\r
+ tt[3] = (FT_Byte)( ( val & 0x03 ) );\r
+\r
+ ss += 1;\r
+ tt += 4;\r
+ }\r
+\r
+ j = source->width & 3;\r
+ if ( j > 0 )\r
+ {\r
+ FT_Int val = ss[0];\r
+\r
+\r
+ for ( ; j > 0; j-- )\r
+ {\r
+ tt[0] = (FT_Byte)( ( val & 0xC0 ) >> 6 );\r
+ val <<= 2;\r
+ tt += 1;\r
+ }\r
+ }\r
+\r
+ s += source->pitch;\r
+ t += target->pitch;\r
+ }\r
+ }\r
+ break;\r
+\r
+\r
+ case FT_PIXEL_MODE_GRAY4:\r
+ {\r
+ FT_Byte* s = source->buffer;\r
+ FT_Byte* t = target->buffer;\r
+ FT_Int i;\r
+\r
+\r
+ target->num_grays = 16;\r
+\r
+ for ( i = source->rows; i > 0; i-- )\r
+ {\r
+ FT_Byte* ss = s;\r
+ FT_Byte* tt = t;\r
+ FT_Int j;\r
+\r
+\r
+ /* get the full bytes */\r
+ for ( j = source->width >> 1; j > 0; j-- )\r
+ {\r
+ FT_Int val = ss[0];\r
+\r
+\r
+ tt[0] = (FT_Byte)( ( val & 0xF0 ) >> 4 );\r
+ tt[1] = (FT_Byte)( ( val & 0x0F ) );\r
+\r
+ ss += 1;\r
+ tt += 2;\r
+ }\r
+\r
+ if ( source->width & 1 )\r
+ tt[0] = (FT_Byte)( ( ss[0] & 0xF0 ) >> 4 );\r
+\r
+ s += source->pitch;\r
+ t += target->pitch;\r
+ }\r
+ }\r
+ break;\r
+\r
+\r
+ default:\r
+ ;\r
+ }\r
+\r
+ return error;\r
+ }\r
+\r
+\r
+ /* documentation is in ftbitmap.h */\r
+\r
+ FT_EXPORT_DEF( FT_Error )\r
+ FT_Bitmap_Done( FT_Library library,\r
+ FT_Bitmap *bitmap )\r
+ {\r
+ FT_Memory memory;\r
+\r
+\r
+ if ( !library )\r
+ return FT_Err_Invalid_Library_Handle;\r
+\r
+ if ( !bitmap )\r
+ return FT_Err_Invalid_Argument;\r
+\r
+ memory = library->memory;\r
+\r
+ FT_FREE( bitmap->buffer );\r
+ *bitmap = null_bitmap;\r
+\r
+ return FT_Err_Ok;\r
+ }\r
+\r
+\r
+/* END */\r
projects / reactos.git / blobdiff