Remove all lcd_filter code.

We reverted the public API for setting lcd_filter font options
back in 1b42bc8033bc , but we had left the implementation which
would examine fontconfig and Xft properties for the option, and
which would call into freetype for subpixel glyph rasterization.

However, I recently realized, (and the test suite had been trying
to tell me for a while), that this approach would cause a
regression for users who were previously using sub-pixel text,
but without sub-pixel rendering built directly into freetype.
That's not acceptable, so all the code is coming out for now.

1 files changed, 189 insertions, 483 deletions

diff --git a/src/cairo-ft-font.c b/src/cairo-ft-font.c
index 1ad714534..ebd419b99 100644
--- a/src/cairo-ft-font.c
+++ b/src/cairo-ft-font.c
@@ -57,30 +57,6 @@
 #include FT_SYNTHESIS_H
 #endif
 
-#if HAVE_FT_LIBRARY_SETLCDFILTER
-#include FT_LCD_FILTER_H
-#endif
-
-/* Fontconfig version older than 2.6 didn't have these options */
-#ifndef FC_LCD_FILTER
-#define FC_LCD_FILTER	"lcdfilter"
-#endif
-/* Some Ubuntu versions defined FC_LCD_FILTER without defining the following */
-#ifndef FC_LCD_NONE
-#define FC_LCD_NONE	0
-#define FC_LCD_DEFAULT	1
-#define FC_LCD_LIGHT	2
-#define FC_LCD_LEGACY	3
-#endif
-
-/* FreeType version older than 2.3.5(?) didn't have these options */
-#ifndef FT_LCD_FILTER_NONE
-#define FT_LCD_FILTER_NONE	0
-#define FT_LCD_FILTER_DEFAULT	1
-#define FT_LCD_FILTER_LIGHT	2
-#define FT_LCD_FILTER_LEGACY	16
-#endif
-
 #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))
@@ -761,286 +737,23 @@ _cairo_ft_unscaled_font_set_scale (cairo_ft_unscaled_font_t *unscaled,
     return CAIRO_STATUS_SUCCESS;
 }
 
-/* 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) ;
+/* 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 },
 #endif
-		    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;
-		}
-	    }
-	}
-    }
-}
-
+    {    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 },
+};
 
 /* Fills in val->image with an image surface created from @bitmap
  */
@@ -1053,7 +766,7 @@ _get_bitmap_surface (FT_Bitmap		     *bitmap,
     int width, height, stride;
     unsigned char *data;
     int format = CAIRO_FORMAT_A8;
-    cairo_image_surface_t *image;
+    cairo_bool_t subpixel = FALSE;
 
     width = bitmap->width;
     height = bitmap->rows;
@@ -1110,7 +823,11 @@ _get_bitmap_surface (FT_Bitmap		     *bitmap,
     case FT_PIXEL_MODE_LCD:
     case FT_PIXEL_MODE_LCD_V:
     case FT_PIXEL_MODE_GRAY:
-        if (font_options->antialias != CAIRO_ANTIALIAS_SUBPIXEL) {
+	switch (font_options->antialias) {
+	case CAIRO_ANTIALIAS_DEFAULT:
+	case CAIRO_ANTIALIAS_GRAY:
+	case CAIRO_ANTIALIAS_NONE:
+	default:
 	    stride = bitmap->pitch;
 	    if (own_buffer) {
 		data = bitmap->buffer;
@@ -1122,16 +839,104 @@ _get_bitmap_surface (FT_Bitmap		     *bitmap,
 		memcpy (data, bitmap->buffer, stride * height);
 	    }
 	    format = CAIRO_FORMAT_A8;
-	} else {
-	    /* if we get there, the  data from the source bitmap
-	     * really comes from _fill_xrender_bitmap, and is
-	     * made of 32-bit ARGB or ABGR values */
-	    assert (own_buffer != 0);
-	    assert (bitmap->pixel_mode != FT_PIXEL_MODE_GRAY);
-
-	    data = bitmap->buffer;
+	    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;
 	    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:
@@ -1143,20 +948,19 @@ _get_bitmap_surface (FT_Bitmap		     *bitmap,
 	return _cairo_error (CAIRO_STATUS_NO_MEMORY);
     }
 
-    /* XXX */
-    *surface = image = (cairo_image_surface_t *)
+    *surface = (cairo_image_surface_t *)
 	cairo_image_surface_create_for_data (data,
 					     format,
 					     width, height, stride);
-    if (image->base.status) {
+    if ((*surface)->base.status) {
 	free (data);
 	return (*surface)->base.status;
     }
 
-    if (font_options->antialias == CAIRO_ANTIALIAS_SUBPIXEL)
-	pixman_image_set_component_alpha (image->pixman_image, TRUE);
+    if (subpixel)
+	pixman_image_set_component_alpha ((*surface)->pixman_image, TRUE);
 
-    _cairo_image_surface_assume_ownership_of_data (image);
+    _cairo_image_surface_assume_ownership_of_data ((*surface));
 
     return CAIRO_STATUS_SUCCESS;
 }
@@ -1181,59 +985,16 @@ _render_glyph_outline (FT_Face                    face,
 		       cairo_font_options_t	 *font_options,
 		       cairo_image_surface_t	**surface)
 {
-    int rgba = FC_RGBA_UNKNOWN;
-    int lcd_filter = FT_LCD_FILTER_LEGACY;
     FT_GlyphSlot glyphslot = face->glyph;
     FT_Outline *outline = &glyphslot->outline;
     FT_Bitmap bitmap;
     FT_BBox cbox;
-    unsigned int width, height;
+    FT_Matrix matrix;
+    int hmul = 1;
+    int vmul = 1;
+    unsigned int width, height, stride;
+    cairo_bool_t subpixel = FALSE;
     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;
-	}
-
-	switch (font_options->lcd_filter) {
-	case CAIRO_LCD_FILTER_NONE:
-	    lcd_filter = FT_LCD_FILTER_NONE;
-	    break;
-	case CAIRO_LCD_FILTER_DEFAULT:
-	case CAIRO_LCD_FILTER_INTRA_PIXEL:
-	    lcd_filter = FT_LCD_FILTER_LEGACY;
-	    break;
-	case CAIRO_LCD_FILTER_FIR3:
-	    lcd_filter = FT_LCD_FILTER_LIGHT;
-	    break;
-	case CAIRO_LCD_FILTER_FIR5:
-	    lcd_filter = FT_LCD_FILTER_DEFAULT;
-	    break;
-	}
-
-	break;
-
-    case CAIRO_ANTIALIAS_DEFAULT:
-    case CAIRO_ANTIALIAS_GRAY:
-	render_mode = FT_RENDER_MODE_NORMAL;
-    }
 
     FT_Outline_Get_CBox (outline, &cbox);
 
@@ -1244,21 +1005,20 @@ _render_glyph_outline (FT_Face                    face,
 
     width = (unsigned int) ((cbox.xMax - cbox.xMin) >> 6);
     height = (unsigned int) ((cbox.yMax - cbox.yMin) >> 6);
+    stride = (width * hmul + 3) & ~3;
 
     if (width * height == 0) {
 	cairo_format_t format;
 	/* Looks like fb handles zero-sized images just fine */
-	switch (render_mode) {
-	case FT_RENDER_MODE_MONO:
+	switch (font_options->antialias) {
+	case CAIRO_ANTIALIAS_NONE:
 	    format = CAIRO_FORMAT_A1;
 	    break;
-	case FT_RENDER_MODE_LCD:
-	case FT_RENDER_MODE_LCD_V:
+	case CAIRO_ANTIALIAS_SUBPIXEL:
 	    format= CAIRO_FORMAT_ARGB32;
 	    break;
-	case FT_RENDER_MODE_LIGHT:
-	case FT_RENDER_MODE_NORMAL:
-	case FT_RENDER_MODE_MAX:
+	case CAIRO_ANTIALIAS_DEFAULT:
+	case CAIRO_ANTIALIAS_GRAY:
 	default:
 	    format = CAIRO_FORMAT_A8;
 	    break;
@@ -1270,74 +1030,74 @@ _render_glyph_outline (FT_Face                    face,
 	    return (*surface)->base.status;
     } else  {
 
-	int bitmap_size;
+	matrix.xx = matrix.yy = 0x10000L;
+	matrix.xy = matrix.yx = 0;
 
-	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;
-	    }
+	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 FT_RENDER_MODE_LCD_V:
-	    if (font_options->subpixel_order == CAIRO_SUBPIXEL_ORDER_VBGR) {
-		rgba = FC_RGBA_VBGR;
-	    } else {
-		rgba = FC_RGBA_VRGB;
-	    }
-	    break;
-	case FT_RENDER_MODE_MONO:
-	case FT_RENDER_MODE_LIGHT:
-	case FT_RENDER_MODE_NORMAL:
-	case FT_RENDER_MODE_MAX:
-	default:
+	case CAIRO_ANTIALIAS_DEFAULT:
+	case CAIRO_ANTIALIAS_GRAY:
+	    bitmap.pixel_mode = FT_PIXEL_MODE_GRAY;
+	    bitmap.num_grays  = 256;
+	    stride = (width + 3) & -4;
 	    break;
-	}
-
-#if HAVE_FT_LIBRARY_SETLCDFILTER
-	FT_Library_SetLcdFilter (library, lcd_filter);
-#endif
-
-	fterror = FT_Render_Glyph (face->glyph, render_mode);
+	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;
+	    }
+	    FT_Outline_Transform (outline, &matrix);
 
-#if HAVE_FT_LIBRARY_SETLCDFILTER
-	FT_Library_SetLcdFilter (library, FT_LCD_FILTER_NONE);
-#endif
+	    bitmap.pixel_mode = FT_PIXEL_MODE_GRAY;
+	    bitmap.num_grays  = 256;
+	    stride = (width * hmul + 3) & -4;
+	}
 
-	if (fterror != 0)
+	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);
 
-	bitmap_size = _compute_xrender_bitmap_size (&bitmap,
-						    face->glyph,
-						    render_mode);
-	if (bitmap_size < 0)
-	    return _cairo_error (CAIRO_STATUS_NO_MEMORY);
+	FT_Outline_Translate (outline, -cbox.xMin*hmul, -cbox.yMin*vmul);
 
-	bitmap.buffer = calloc (1, bitmap_size);
-	if (bitmap.buffer == NULL)
+	if (FT_Outline_Get_Bitmap (glyphslot->library, outline, &bitmap) != 0) {
+	    free (bitmap.buffer);
 	    return _cairo_error (CAIRO_STATUS_NO_MEMORY);
+	}
 
-	_fill_xrender_bitmap (&bitmap, face->glyph, render_mode,
-			      (rgba == FC_RGBA_BGR || rgba == FC_RGBA_VBGR));
-
-	/* Note:
-	 * _get_bitmap_surface will free bitmap.buffer if there is an error
-	 */
 	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.
-	 */
-	cairo_surface_set_device_offset (&(*surface)->base,
-					 (double)-glyphslot->bitmap_left,
-					 (double)+glyphslot->bitmap_top);
     }
 
+    /*
+     * 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.
+     */
+    cairo_surface_set_device_offset (&(*surface)->base,
+				     floor (-(double) cbox.xMin / 64.0),
+				     floor (+(double) cbox.yMax / 64.0));
+
     return CAIRO_STATUS_SUCCESS;
 }
 
@@ -1556,7 +1316,6 @@ _get_pattern_ft_options (FcPattern *pattern, cairo_ft_options_t *ret)
     
     if (antialias) {
 	cairo_subpixel_order_t subpixel_order;
-	int lcd_filter;
 
 	/* disable hinting if requested */
 	if (FcPatternGetBool (pattern,
@@ -1592,25 +1351,6 @@ _get_pattern_ft_options (FcPattern *pattern, cairo_ft_options_t *ret)
 	    ft_options.base.antialias = CAIRO_ANTIALIAS_SUBPIXEL;
 	}
 
-	if (FcPatternGetInteger (pattern,
-				 FC_LCD_FILTER, 0, &lcd_filter) == FcResultMatch)
-	{
-	    switch (lcd_filter) {
-	    case FC_LCD_NONE:
-		ft_options.base.lcd_filter = CAIRO_LCD_FILTER_NONE;
-		break;
-	    case FC_LCD_DEFAULT:
-		ft_options.base.lcd_filter = CAIRO_LCD_FILTER_FIR5;
-		break;
-	    case FC_LCD_LIGHT:
-		ft_options.base.lcd_filter = CAIRO_LCD_FILTER_FIR3;
-		break;
-	    case FC_LCD_LEGACY:
-		ft_options.base.lcd_filter = CAIRO_LCD_FILTER_INTRA_PIXEL;
-		break;
-	    }
-	}
-
 #ifdef FC_HINT_STYLE    
 	if (FcPatternGetInteger (pattern, 
 				 FC_HINT_STYLE, 0, &hintstyle) != FcResultMatch)
@@ -1711,12 +1451,6 @@ _cairo_ft_options_merge (cairo_ft_options_t *options,
     if (other->base.hint_style == CAIRO_HINT_STYLE_NONE)
 	options->base.hint_style = CAIRO_HINT_STYLE_NONE;
 
-    if (options->base.lcd_filter == CAIRO_LCD_FILTER_DEFAULT)
-	options->base.lcd_filter = other->base.lcd_filter;
-
-    if (other->base.lcd_filter == CAIRO_LCD_FILTER_NONE)
-	options->base.lcd_filter = CAIRO_LCD_FILTER_NONE;
-
     if (options->base.antialias == CAIRO_ANTIALIAS_NONE) {
 	if (options->base.hint_style == CAIRO_HINT_STYLE_NONE)
 	    load_flags |= FT_LOAD_NO_HINTING;
@@ -1740,11 +1474,11 @@ _cairo_ft_options_merge (cairo_ft_options_t *options,
 		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;
 		}
 	    }
@@ -2687,34 +2421,6 @@ _cairo_ft_font_options_substitute (const cairo_font_options_t *options,
 	}
     }
 
-    if (options->lcd_filter != CAIRO_LCD_FILTER_DEFAULT)
-    {
-	if (FcPatternGet (pattern, FC_LCD_FILTER, 0, &v) == FcResultNoMatch)
-	{
-	    int lcd_filter;
-
-	    switch (options->lcd_filter) {
-	    case CAIRO_LCD_FILTER_NONE:
-		lcd_filter = FT_LCD_FILTER_NONE;
-		break;
-	    case CAIRO_LCD_FILTER_DEFAULT:
-	    case CAIRO_LCD_FILTER_INTRA_PIXEL:
-		lcd_filter = FT_LCD_FILTER_LEGACY;
-		break;
-	    case CAIRO_LCD_FILTER_FIR3:
-		lcd_filter = FT_LCD_FILTER_LIGHT;
-		break;
-	    default:
-	    case CAIRO_LCD_FILTER_FIR5:
-		lcd_filter = FT_LCD_FILTER_DEFAULT;
-		break;
-	    }
-
-	    if (! FcPatternAddInteger (pattern, FC_LCD_FILTER, lcd_filter))
-		return _cairo_error (CAIRO_STATUS_NO_MEMORY);
-	}
-    }
-
     if (options->hint_style != CAIRO_HINT_STYLE_DEFAULT)
     {
 	if (FcPatternGet (pattern, FC_HINTING, 0, &v) == FcResultNoMatch)