rendered paste bodydiff -Naurp cairo-1.5.10/src/cairo-ft-font.c cairo-1.5.10-newspr/src/cairo-ft-font.c--- cairo-1.5.10/src/cairo-ft-font.c 2008-02-19 02:27:51.000000000 +0100+++ cairo-1.5.10-newspr/src/cairo-ft-font.c 2008-02-23 14:33:19.000000000 +0100@@ -55,6 +55,8 @@ #include FT_SYNTHESIS_H #endif +#include FT_LCD_FILTER_H+ #define DOUBLE_TO_26_6(d) ((FT_F26Dot6)((d) * 64.0)) #define DOUBLE_FROM_26_6(t) ((double)(t) / 64.0) #define DOUBLE_TO_16_16(d) ((FT_Fixed)((d) * 65536.0))@@ -715,23 +717,300 @@ _cairo_ft_unscaled_font_set_scale (cairo return CAIRO_STATUS_SUCCESS; } -/* Empirically-derived subpixel filtering values thanks to Keith- * Packard and libXft. */-static const int filters[3][3] = {- /* red */-#if 0- { 65538*4/7,65538*2/7,65538*1/7 },- /* green */- { 65536*1/4, 65536*2/4, 65537*1/4 },- /* blue */- { 65538*1/7,65538*2/7,65538*4/7 },+/* we sometimes need to convert the glyph bitmap in a FT_GlyphSlot+ * into a different format. For example, we want to convert a+ * FT_PIXEL_MODE_LCD or FT_PIXEL_MODE_LCD_V bitmap into a 32-bit+ * ARGB or ABGR bitmap.+ *+ * this function prepares a target descriptor for this operation.+ *+ * input :: target bitmap descriptor. The function will set its+ * 'width', 'rows' and 'pitch' fields, and only these+ *+ * slot :: the glyph slot containing the source bitmap. this+ * function assumes that slot->format == FT_GLYPH_FORMAT_BITMAP+ *+ * mode :: the requested final rendering mode. supported values are+ * MONO, NORMAL (i.e. gray), LCD and LCD_V+ *+ * the function returns the size in bytes of the corresponding buffer,+ * it's up to the caller to allocate the corresponding memory block+ * before calling _fill_xrender_bitmap+ *+ * it also returns -1 in case of error (e.g. incompatible arguments,+ * like trying to convert a gray bitmap into a monochrome one)+ */+static int+_compute_xrender_bitmap_size( FT_Bitmap* target,+ FT_GlyphSlot slot,+ FT_Render_Mode mode )+{+ FT_Bitmap* ftbit;+ int width, height, pitch;++ if ( slot->format != FT_GLYPH_FORMAT_BITMAP )+ return -1;++ // compute the size of the final bitmap+ ftbit = &slot->bitmap;++ width = ftbit->width;+ height = ftbit->rows;+ pitch = (width+3) & ~3;++ switch ( ftbit->pixel_mode )+ {+ case FT_PIXEL_MODE_MONO:+ if ( mode == FT_RENDER_MODE_MONO )+ {+ pitch = (((width+31) & ~31) >> 3);+ break;+ }+ /* fall-through */++ case FT_PIXEL_MODE_GRAY:+ if ( mode == FT_RENDER_MODE_LCD ||+ mode == FT_RENDER_MODE_LCD_V )+ {+ /* each pixel is replicated into a 32-bit ARGB value */+ pitch = width*4;+ }+ break;++ case FT_PIXEL_MODE_LCD:+ if ( mode != FT_RENDER_MODE_LCD )+ return -1;++ /* horz pixel triplets are packed into 32-bit ARGB values */+ width /= 3;+ pitch = width*4;+ break;++ case FT_PIXEL_MODE_LCD_V:+ if ( mode != FT_RENDER_MODE_LCD_V )+ return -1;++ /* vert pixel triplets are packed into 32-bit ARGB values */+ height /= 3;+ pitch = width*4;+ break;++ default: /* unsupported source format */+ return -1;+ }++ target->width = width;+ target->rows = height;+ target->pitch = pitch;+ target->buffer = NULL;++ return pitch * height;+}++/* this functions converts the glyph bitmap found in a FT_GlyphSlot+ * into a different format (see _compute_xrender_bitmap_size)+ *+ * you should call this function after _compute_xrender_bitmap_size+ *+ * target :: target bitmap descriptor. Note that its 'buffer' pointer+ * must point to memory allocated by the caller+ *+ * slot :: the glyph slot containing the source bitmap+ *+ * mode :: the requested final rendering mode+ *+ * bgr :: boolean, set if BGR or VBGR pixel ordering is needed+ */+static void+_fill_xrender_bitmap( FT_Bitmap* target,+ FT_GlyphSlot slot,+ FT_Render_Mode mode,+ int bgr )+{+ FT_Bitmap* ftbit = &slot->bitmap;+ unsigned char* srcLine = ftbit->buffer;+ unsigned char* dstLine = target->buffer;+ int src_pitch = ftbit->pitch;+ int width = target->width;+ int height = target->rows;+ int pitch = target->pitch;+ int subpixel;+ int h;++ subpixel = ( mode == FT_RENDER_MODE_LCD ||+ mode == FT_RENDER_MODE_LCD_V );++ if ( src_pitch < 0 )+ srcLine -= src_pitch*(ftbit->rows-1);++ target->pixel_mode = ftbit->pixel_mode;++ switch ( ftbit->pixel_mode )+ {+ case FT_PIXEL_MODE_MONO:+ if ( subpixel ) /* convert mono to ARGB32 values */+ {+ for ( h = height; h > 0; h--, srcLine += src_pitch, dstLine += pitch )+ {+ int x;++ for ( x = 0; x < width; x++ )+ {+ if ( srcLine[(x >> 3)] & (0x80 >> (x & 7)) )+ ((unsigned int*)dstLine)[x] = 0xffffffffU;+ }+ }+ target->pixel_mode = FT_PIXEL_MODE_LCD;+ }+ else if ( mode == FT_RENDER_MODE_NORMAL ) /* convert mono to 8-bit gray */+ {+ for ( h = height; h > 0; h--, srcLine += src_pitch, dstLine += pitch )+ {+ int x;++ for ( x = 0; x < width; x++ )+ {+ if ( srcLine[(x >> 3)] & (0x80 >> (x & 7)) )+ dstLine[x] = 0xff;+ }+ }+ target->pixel_mode = FT_PIXEL_MODE_GRAY;+ }+ else /* copy mono to mono */+ {+ int bytes = (width+7) >> 3;++ for ( h = height; h > 0; h--, srcLine += src_pitch, dstLine += pitch )+ memcpy( dstLine, srcLine, bytes );+ }+ break;++ case FT_PIXEL_MODE_GRAY:+ if ( subpixel ) /* convert gray to ARGB32 values */+ {+ for ( h = height; h > 0; h--, srcLine += src_pitch, dstLine += pitch )+ {+ int x;+ unsigned int* dst = (unsigned int*)dstLine;++ for ( x = 0; x < width; x++ )+ {+ unsigned int pix = srcLine[x];++ pix |= (pix << 8);+ pix |= (pix << 16);++ dst[x] = pix;+ }+ }+ target->pixel_mode = FT_PIXEL_MODE_LCD;+ }+ else /* copy gray into gray */+ {+ for ( h = height; h > 0; h--, srcLine += src_pitch, dstLine += pitch )+ memcpy( dstLine, srcLine, width );+ }+ break;++ case FT_PIXEL_MODE_LCD:+ if ( !bgr )+ {+ /* convert horizontal RGB into ARGB32 */+ for ( h = height; h > 0; h--, srcLine += src_pitch, dstLine += pitch )+ {+ int x;+ unsigned char* src = srcLine;+ unsigned int* dst = (unsigned int*)dstLine;++ for ( x = 0; x < width; x++, src += 3 )+ {+ unsigned int pix;++ pix = ((unsigned int)src[0] << 16) |+ ((unsigned int)src[1] << 8) |+ ((unsigned int)src[2] ) |+ ((unsigned int)src[1] << 24) ;++ dst[x] = pix;+ }+ }+ }+ else+ {+ /* convert horizontal BGR into ARGB32 */+ for ( h = height; h > 0; h--, srcLine += src_pitch, dstLine += pitch )+ {+ int x;+ unsigned char* src = srcLine;+ unsigned int* dst = (unsigned int*)dstLine;++ for ( x = 0; x < width; x++, src += 3 )+ {+ unsigned int pix;++ pix = ((unsigned int)src[2] << 16) |+ ((unsigned int)src[1] << 8) |+ ((unsigned int)src[0] ) |+ ((unsigned int)src[1] << 24) ;++ dst[x] = pix;+ }+ }+ }+ break;++ default: /* FT_PIXEL_MODE_LCD_V */+ /* convert vertical RGB into ARGB32 */+ if ( !bgr )+ {+ for ( h = height; h > 0; h--, srcLine += 3*src_pitch, dstLine += pitch )+ {+ int x;+ unsigned char* src = srcLine;+ unsigned int* dst = (unsigned int*)dstLine;++ for ( x = 0; x < width; x++, src += 1 )+ {+ unsigned int pix;+#if 1+ pix = ((unsigned int)src[0] << 16) |+ ((unsigned int)src[src_pitch] << 8) |+ ((unsigned int)src[src_pitch*2] ) |+ 0xFF000000 ;+#else+ pix = ((unsigned int)src[0] << 16) |+ ((unsigned int)src[src_pitch] << 8) |+ ((unsigned int)src[src_pitch*2] ) |+ ((unsigned int)src[src_pitch] << 24) ; #endif- { 65538*9/13,65538*3/13,65538*1/13 },- /* green */- { 65538*1/6, 65538*4/6, 65538*1/6 },- /* blue */- { 65538*1/13,65538*3/13,65538*9/13 },-};+ dst[x] = pix;+ }+ }+ }+ else+ {+ for ( h = height; h > 0; h--, srcLine += 3*src_pitch, dstLine += pitch )+ {+ int x;+ unsigned char* src = srcLine;+ unsigned int* dst = (unsigned int*)dstLine;++ for ( x = 0; x < width; x++, src += 1 )+ {+ unsigned int pix;++ pix = ((unsigned int)src[src_pitch*2] << 16) |+ ((unsigned int)src[src_pitch] << 8) |+ ((unsigned int)src[0] ) |+ ((unsigned int)src[src_pitch] << 24) ;++ dst[x] = pix;+ }+ }+ }+ }+}+ /* Fills in val->image with an image surface created from @bitmap */@@ -744,7 +1023,7 @@ _get_bitmap_surface (FT_Bitmap *bi int width, height, stride; unsigned char *data; int format = CAIRO_FORMAT_A8;- cairo_bool_t subpixel = FALSE;+ cairo_image_surface_t *image; width = bitmap->width; height = bitmap->rows;@@ -755,7 +1034,9 @@ _get_bitmap_surface (FT_Bitmap *bi return (*surface)->base.status; } - switch (bitmap->pixel_mode) {+ {+ switch (bitmap->pixel_mode)+ { case FT_PIXEL_MODE_MONO: stride = (((width + 31) & ~31) >> 3); if (own_buffer) {@@ -783,7 +1064,6 @@ _get_bitmap_surface (FT_Bitmap *bi } } }- #ifndef WORDS_BIGENDIAN { unsigned char *d = data;@@ -795,17 +1075,15 @@ _get_bitmap_surface (FT_Bitmap *bi } } #endif+ format = CAIRO_FORMAT_A1; break; case FT_PIXEL_MODE_LCD: case FT_PIXEL_MODE_LCD_V: case FT_PIXEL_MODE_GRAY:- switch (font_options->antialias) {- case CAIRO_ANTIALIAS_DEFAULT:- case CAIRO_ANTIALIAS_GRAY:- case CAIRO_ANTIALIAS_NONE:- default:+ if (font_options->antialias != CAIRO_ANTIALIAS_SUBPIXEL)+ { stride = bitmap->pitch; if (own_buffer) { data = bitmap->buffer;@@ -817,104 +1095,10 @@ _get_bitmap_surface (FT_Bitmap *bi memcpy (data, bitmap->buffer, stride * height); } format = CAIRO_FORMAT_A8;- break;- case CAIRO_ANTIALIAS_SUBPIXEL: {- int x, y;- unsigned char *in_line, *out_line, *in;- unsigned int *out;- unsigned int red, green, blue;- int rf, gf, bf;- int s;- int o, os;- unsigned char *data_rgba;- unsigned int width_rgba, stride_rgba;- int vmul = 1;- int hmul = 1;-- switch (font_options->subpixel_order) {- case CAIRO_SUBPIXEL_ORDER_DEFAULT:- case CAIRO_SUBPIXEL_ORDER_RGB:- case CAIRO_SUBPIXEL_ORDER_BGR:- default:- width /= 3;- hmul = 3;- break;- case CAIRO_SUBPIXEL_ORDER_VRGB:- case CAIRO_SUBPIXEL_ORDER_VBGR:- vmul = 3;- height /= 3;- break;- }- /*- * Filter the glyph to soften the color fringes- */- width_rgba = width;+ } else {+ data = bitmap->buffer; stride = bitmap->pitch;- stride_rgba = (width_rgba * 4 + 3) & ~3;- data_rgba = calloc (stride_rgba, height);- if (data_rgba == NULL) {- if (own_buffer)- free (bitmap->buffer);- return _cairo_error (CAIRO_STATUS_NO_MEMORY);- }-- os = 1;- switch (font_options->subpixel_order) {- case CAIRO_SUBPIXEL_ORDER_VRGB:- os = stride;- case CAIRO_SUBPIXEL_ORDER_DEFAULT:- case CAIRO_SUBPIXEL_ORDER_RGB:- default:- rf = 0;- gf = 1;- bf = 2;- break;- case CAIRO_SUBPIXEL_ORDER_VBGR:- os = stride;- case CAIRO_SUBPIXEL_ORDER_BGR:- bf = 0;- gf = 1;- rf = 2;- break;- }- in_line = bitmap->buffer;- out_line = data_rgba;- for (y = 0; y < height; y++)- {- in = in_line;- out = (unsigned int *) out_line;- in_line += stride * vmul;- out_line += stride_rgba;- for (x = 0; x < width * hmul; x += hmul)- {- red = green = blue = 0;- o = 0;- for (s = 0; s < 3; s++)- {- red += filters[rf][s]*in[x+o];- green += filters[gf][s]*in[x+o];- blue += filters[bf][s]*in[x+o];- o += os;- }- red = red / 65536;- green = green / 65536;- blue = blue / 65536;- *out++ = (green << 24) | (red << 16) | (green << 8) | blue;- }- }-- /* Images here are stored in native format. The- * backend must convert to its own format as needed- */-- if (own_buffer)- free (bitmap->buffer);- data = data_rgba;- stride = stride_rgba; format = CAIRO_FORMAT_ARGB32;- subpixel = TRUE;- break;- } } break; case FT_PIXEL_MODE_GRAY2:@@ -926,20 +1110,19 @@ _get_bitmap_surface (FT_Bitmap *bi return _cairo_error (CAIRO_STATUS_NO_MEMORY); } - *surface = (cairo_image_surface_t *)+ *surface = image = (cairo_image_surface_t *) cairo_image_surface_create_for_data (data, format, width, height, stride);- if ((*surface)->base.status) {+ if (image->base.status) { free (data); return (*surface)->base.status; } - if (subpixel)- pixman_image_set_component_alpha ((*surface)->pixman_image, TRUE);-- _cairo_image_surface_assume_ownership_of_data ((*surface));-+ if (font_options->antialias == CAIRO_ANTIALIAS_SUBPIXEL)+ pixman_image_set_component_alpha (image->pixman_image, TRUE);+ _cairo_image_surface_assume_ownership_of_data (image);+ } return CAIRO_STATUS_SUCCESS; } @@ -963,16 +1146,44 @@ _render_glyph_outline (FT_Face cairo_font_options_t *font_options, cairo_image_surface_t **surface) {+ int rgba = FC_RGBA_UNKNOWN; FT_GlyphSlot glyphslot = face->glyph; FT_Outline *outline = &glyphslot->outline; FT_Bitmap bitmap; FT_BBox cbox;- FT_Matrix matrix;- int hmul = 1;- int vmul = 1; unsigned int width, height, stride;- cairo_bool_t subpixel = FALSE;+ cairo_format_t format; cairo_status_t status;+ FT_Error fterror;+ FT_Library library = glyphslot->library;+ FT_Render_Mode render_mode = FT_RENDER_MODE_NORMAL;++ switch (font_options->antialias)+ {+ case CAIRO_ANTIALIAS_NONE:+ render_mode = FT_RENDER_MODE_MONO;+ break;++ case CAIRO_ANTIALIAS_SUBPIXEL:+ switch (font_options->subpixel_order)+ {+ case CAIRO_SUBPIXEL_ORDER_DEFAULT:+ case CAIRO_SUBPIXEL_ORDER_RGB:+ case CAIRO_SUBPIXEL_ORDER_BGR:+ render_mode = FT_RENDER_MODE_LCD;+ break;++ case CAIRO_SUBPIXEL_ORDER_VRGB:+ case CAIRO_SUBPIXEL_ORDER_VBGR:+ render_mode = FT_RENDER_MODE_LCD_V;+ break;+ }+ break;++ case CAIRO_ANTIALIAS_DEFAULT:+ case CAIRO_ANTIALIAS_GRAY:+ render_mode = FT_RENDER_MODE_NORMAL;+ } FT_Outline_Get_CBox (outline, &cbox); @@ -983,20 +1194,18 @@ _render_glyph_outline (FT_Face width = (unsigned int) ((cbox.xMax - cbox.xMin) >> 6); height = (unsigned int) ((cbox.yMax - cbox.yMin) >> 6);- stride = (width * hmul + 3) & ~3;+ stride = (width + 3) & ~3; if (width * height == 0) {- cairo_format_t format; /* Looks like fb handles zero-sized images just fine */- switch (font_options->antialias) {- case CAIRO_ANTIALIAS_NONE:+ switch (render_mode) {+ case FT_RENDER_MODE_MONO: format = CAIRO_FORMAT_A1; break;- case CAIRO_ANTIALIAS_SUBPIXEL:+ case FT_RENDER_MODE_LCD:+ case FT_RENDER_MODE_LCD_V: format= CAIRO_FORMAT_ARGB32; break;- case CAIRO_ANTIALIAS_DEFAULT:- case CAIRO_ANTIALIAS_GRAY: default: format = CAIRO_FORMAT_A8; break;@@ -1007,74 +1216,60 @@ _render_glyph_outline (FT_Face if ((*surface)->base.status) return (*surface)->base.status; } else {+ int bitmap_size; - matrix.xx = matrix.yy = 0x10000L;- matrix.xy = matrix.yx = 0;-- switch (font_options->antialias) {- case CAIRO_ANTIALIAS_NONE:- bitmap.pixel_mode = FT_PIXEL_MODE_MONO;- bitmap.num_grays = 1;- stride = ((width + 31) & -32) >> 3;- break;- case CAIRO_ANTIALIAS_DEFAULT:- case CAIRO_ANTIALIAS_GRAY:- bitmap.pixel_mode = FT_PIXEL_MODE_GRAY;- bitmap.num_grays = 256;- stride = (width + 3) & -4;+ switch (render_mode) {+ case FT_RENDER_MODE_LCD:+ if(font_options->subpixel_order == CAIRO_SUBPIXEL_ORDER_BGR) {+ rgba = FC_RGBA_BGR;+ } else {+ rgba = FC_RGBA_RGB;+ } break;- case CAIRO_ANTIALIAS_SUBPIXEL:- switch (font_options->subpixel_order) {- case CAIRO_SUBPIXEL_ORDER_RGB:- case CAIRO_SUBPIXEL_ORDER_BGR:- case CAIRO_SUBPIXEL_ORDER_DEFAULT:- default:- matrix.xx *= 3;- hmul = 3;- subpixel = TRUE;- break;- case CAIRO_SUBPIXEL_ORDER_VRGB:- case CAIRO_SUBPIXEL_ORDER_VBGR:- matrix.yy *= 3;- vmul = 3;- subpixel = TRUE;- break;+ case FT_RENDER_MODE_LCD_V:+ if(font_options->subpixel_order == CAIRO_SUBPIXEL_ORDER_BGR) {+ rgba = FC_RGBA_VBGR;+ } else {+ rgba = FC_RGBA_VRGB; }- FT_Outline_Transform (outline, &matrix);-- bitmap.pixel_mode = FT_PIXEL_MODE_GRAY;- bitmap.num_grays = 256;- stride = (width * hmul + 3) & -4;+ break;+ default:+ break; } - bitmap.pitch = stride;- bitmap.width = width * hmul;- bitmap.rows = height * vmul;- bitmap.buffer = calloc (stride, bitmap.rows);- if (bitmap.buffer == NULL)- return _cairo_error (CAIRO_STATUS_NO_MEMORY);-- FT_Outline_Translate (outline, -cbox.xMin*hmul, -cbox.yMin*vmul);-- if (FT_Outline_Get_Bitmap (glyphslot->library, outline, &bitmap) != 0) {- free (bitmap.buffer);+ FT_Library_SetLcdFilter (library, FT_LCD_FILTER_DEFAULT);+ fterror = FT_Render_Glyph (face->glyph, render_mode);+ FT_Library_SetLcdFilter (library, FT_LCD_FILTER_NONE);+ if (fterror != 0) { return _cairo_error (CAIRO_STATUS_NO_MEMORY); } + bitmap_size = _compute_xrender_bitmap_size (&bitmap,+ face->glyph,+ render_mode);+ if(bitmap_size < 0) {+ _cairo_error (CAIRO_STATUS_NO_MEMORY);+ return CAIRO_STATUS_NO_MEMORY;+ }+ bitmap.buffer = calloc (1, bitmap_size);+ _fill_xrender_bitmap (&bitmap, face->glyph, render_mode,+ (rgba == FC_RGBA_BGR || rgba == FC_RGBA_VBGR)); status = _get_bitmap_surface (&bitmap, TRUE, font_options, surface); if (status) return status;- } /* * Note: the font's coordinate system is upside down from ours, so the * Y coordinate of the control box needs to be negated. Moreover, device * offsets are position of glyph origin relative to top left while xMin * and yMax are offsets of top left relative to origin. Another negation.+ * XXX: No, wait. In 1.5.2 it seems to be the other way around: x negated,+ * XXX: y literal. What the fuck?.. */ cairo_surface_set_device_offset (&(*surface)->base,- floor (-(double) cbox.xMin / 64.0),- floor (+(double) cbox.yMax / 64.0));+ (double)-glyphslot->bitmap_left,+ (double)glyphslot->bitmap_top);+ } return CAIRO_STATUS_SUCCESS; }@@ -1452,11 +1647,11 @@ _cairo_ft_options_merge (cairo_ft_option case CAIRO_SUBPIXEL_ORDER_DEFAULT: case CAIRO_SUBPIXEL_ORDER_RGB: case CAIRO_SUBPIXEL_ORDER_BGR:- load_target |= FT_LOAD_TARGET_LCD;+ load_target = FT_LOAD_TARGET_LCD; break; case CAIRO_SUBPIXEL_ORDER_VRGB: case CAIRO_SUBPIXEL_ORDER_VBGR:- load_target |= FT_LOAD_TARGET_LCD_V;+ load_target = FT_LOAD_TARGET_LCD_V; break; } }