Attachment 52055 Details for Bug 29151 – Patch01 of 02 - Subpixel LCD text rendering improvements

[patch] Patch01 of 02 - Subpixel LCD text rendering improvements

0001-Subpixel-LCD-text-rendering-improvements.patch (text/plain), 22.12 KB, created by Tom Callaway on 2011-10-06 13:01:23 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Tom Callaway

Created: 2011-10-06 13:01:23 UTC

Size: 22.12 KB

patch

obsolete

>From 908385ed4282d146ea7103f1ee632daa76c3fa40 Mon Sep 17 00:00:00 2001
>From: "Tom \"spot\" Callaway" <tcallawa@redhat.com>
>Date: Thu, 6 Oct 2011 15:41:10 -0400
>Subject: [PATCH 1/2] Subpixel LCD text rendering improvements
>
>---
> src/xftdpy.c      |   12 +
> src/xftfreetype.c |   15 ++
> src/xftglyphs.c   |  659 +++++++++++++++++++++++++++++++----------------------
> src/xftint.h      |    1 +
> 4 files changed, 415 insertions(+), 272 deletions(-)
>
>diff --git a/src/xftdpy.c b/src/xftdpy.c
>index 8f453b3..73b0bed 100644
>--- a/src/xftdpy.c
>+++ b/src/xftdpy.c
>@@ -369,6 +369,10 @@ _XftDefaultInit (Display *dpy)
> 	goto bail1;
>     if (!_XftDefaultInitInteger (dpy, pat, FC_RGBA))
> 	goto bail1;
>+#ifdef FC_LCD_FILTER
>+    if (!_XftDefaultInitInteger (dpy, pat, FC_LCD_FILTER))
>+	goto bail1;
>+#endif
>     if (!_XftDefaultInitBool (dpy, pat, FC_ANTIALIAS))
> 	goto bail1;
> #ifdef FC_EMBOLDEN
>@@ -521,6 +525,14 @@ XftDefaultSubstitute (Display *dpy, int screen, FcPattern *pattern)
> 			      XftDefaultGetInteger (dpy, FC_RGBA, screen,
> 						    subpixel));
>     }
>+#ifdef FC_LCD_FILTER
>+    if (FcPatternGet (pattern, FC_LCD_FILTER, 0, &v) == FcResultNoMatch)
>+    {
>+	FcPatternAddInteger (pattern, FC_LCD_FILTER,
>+			     XftDefaultGetInteger (dpy, FC_LCD_FILTER, screen,
>+						   FC_LCD_DEFAULT));
>+    }
>+#endif
>     if (FcPatternGet (pattern, FC_MINSPACE, 0, &v) == FcResultNoMatch)
>     {
> 	FcPatternAddBool (pattern, FC_MINSPACE,
>diff --git a/src/xftfreetype.c b/src/xftfreetype.c
>index 3f8dfef..cff954b 100644
>--- a/src/xftfreetype.c
>+++ b/src/xftfreetype.c
>@@ -469,6 +469,21 @@ XftFontInfoFill (Display *dpy, _Xconst FcPattern *pattern, XftFontInfo *fi)
> 	goto bail1;
>     }
> 
>+#ifdef FC_LCD_FILTER 
>+    /*
>+     * Get lcd_filter value
>+     */
>+    switch (FcPatternGetInteger (pattern, FC_LCD_FILTER, 0, &fi->lcd_filter)) {
>+    case FcResultNoMatch:
>+	fi->lcd_filter = FC_LCD_DEFAULT;
>+	break;
>+    case FcResultMatch:
>+	break;
>+    default:
>+	goto bail1;
>+    }
>+#endif
>+
>     /*
>      * Get matrix and transform values
>      */
>diff --git a/src/xftglyphs.c b/src/xftglyphs.c
>index e0cfdea..03d94ed 100644
>--- a/src/xftglyphs.c
>+++ b/src/xftglyphs.c
>@@ -22,27 +22,12 @@
> 
> #include "xftint.h"
> #include <freetype/ftoutln.h>
>+#include <freetype/ftlcdfil.h>
> 
> #if HAVE_FT_GLYPHSLOT_EMBOLDEN
> #include <freetype/ftsynth.h>
> #endif
> 
>-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
>-{    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 },
>-};
>-
> /*
>  * Validate the memory info for a font
>  */
>@@ -69,6 +54,293 @@ _XftFontValidateMemory (Display *dpy, XftFont *public)
> 		font->glyph_memory, glyph_memory);
> }
> 
>+/* 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);
>+
>+	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;
>+		    }
>+		}
>+	    }
>+	    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;
>+		    }
>+		}
>+	    }
>+	    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;
>+		    }
>+		}
>+	    }
>+	    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;
>+
>+			pix = ((unsigned int)src[0]           << 16) |
>+			      ((unsigned int)src[src_pitch]   <<  8) |
>+			      ((unsigned int)src[src_pitch*2]      ) |
>+			      ((unsigned int)src[src_pitch]   << 24) ;
>+
>+			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;
>+		    }
>+		}
>+	    }
>+	}
>+    }
>+}
>+
> _X_EXPORT void
> XftFontLoadGlyphs (Display	    *dpy,
> 		   XftFont	    *pub,
>@@ -87,20 +359,14 @@ XftFontLoadGlyphs (Display	    *dpy,
>     unsigned char   *bufBitmap = bufLocal;
>     int		    bufSize = sizeof (bufLocal);
>     int		    size, pitch;
>-    unsigned char   bufLocalRgba[4096];
>-    unsigned char   *bufBitmapRgba = bufLocalRgba;
>-    int		    bufSizeRgba = sizeof (bufLocalRgba);
>-    int		    sizergba, pitchrgba, widthrgba;
>     int		    width;
>     int		    height;
>     int		    left, right, top, bottom;
>-    int		    hmul = 1;
>-    int		    vmul = 1;
>-    FT_Bitmap	    ftbit;
>-    FT_Matrix	    matrix;
>+    FT_Bitmap*	    ftbit;
>+    FT_Bitmap	    local;
>     FT_Vector	    vector;
>-    Bool	    subpixel = False;
>     FT_Face	    face;
>+    FT_Render_Mode  mode = FT_RENDER_MODE_MONO;
> 
>     if (!info)
> 	return;
>@@ -110,24 +376,19 @@ XftFontLoadGlyphs (Display	    *dpy,
>     if (!face)
> 	return;
> 
>-    matrix.xx = matrix.yy = 0x10000L;
>-    matrix.xy = matrix.yx = 0;
>-
>     if (font->info.antialias)
>     {
> 	switch (font->info.rgba) {
> 	case FC_RGBA_RGB:
> 	case FC_RGBA_BGR:
>-	    matrix.xx *= 3;
>-	    subpixel = True;
>-	    hmul = 3;
>+	    mode = FT_RENDER_MODE_LCD;
> 	    break;
> 	case FC_RGBA_VRGB:
> 	case FC_RGBA_VBGR:
>-	    matrix.yy *= 3;
>-	    vmul = 3;
>-	    subpixel = True;
>+	    mode = FT_RENDER_MODE_LCD_V;
> 	    break;
>+	default:
>+	    mode = FT_RENDER_MODE_NORMAL;
> 	}
>     }
> 
>@@ -148,6 +409,8 @@ XftFontLoadGlyphs (Display	    *dpy,
> 	if (xftg->glyph_memory)
> 	    continue;
> 
>+	FT_Library_SetLcdFilter( _XftFTlibrary, font->info.lcd_filter);
>+
> 	error = FT_Load_Glyph (face, glyphindex, font->info.load_flags);
> 	if (error)
> 	{
>@@ -181,7 +444,7 @@ XftFontLoadGlyphs (Display	    *dpy,
> 	/*
> 	 * Compute glyph metrics from FreeType information
> 	 */
>-	if(font->info.transform && glyphslot->format != ft_glyph_format_bitmap)
>+	if(font->info.transform && glyphslot->format != FT_GLYPH_FORMAT_BITMAP)
> 	{
> 	    /*
> 	     * calculate the true width by transforming all four corners.
>@@ -260,17 +523,14 @@ XftFontLoadGlyphs (Display	    *dpy,
> 	    }
> 	}
> 
>-	if (font->info.antialias)
>-	    pitch = (width * hmul + 3) & ~3;
>-	else
>-	    pitch = ((width + 31) & ~31) >> 3;
>-
>-	size = pitch * height * vmul;
>+	if ( glyphslot->format != FT_GLYPH_FORMAT_BITMAP )
>+	{
>+	    error = FT_Render_Glyph( face->glyph, mode );
>+	    if (error)
>+		continue;
>+	}
> 
>-	xftg->metrics.width = width;
>-	xftg->metrics.height = height;
>-	xftg->metrics.x = -TRUNC(left);
>-	xftg->metrics.y = TRUNC(top);
>+	FT_Library_SetLcdFilter( _XftFTlibrary, FT_LCD_FILTER_NONE );
> 
> 	if (font->info.spacing >= FC_MONO)
> 	{
>@@ -310,103 +570,9 @@ XftFontLoadGlyphs (Display	    *dpy,
> 	    xftg->metrics.yOff = -TRUNC(ROUND(glyphslot->advance.y));
> 	}
> 
>-	/*
>-	 * If the glyph is relatively large (> 1% of server memory),
>-	 * don't send it until necessary
>-	 */
>-	if (!need_bitmaps && size > info->max_glyph_memory / 100)
>-	    continue;
>-
>-	/*
>-	 * Make sure there's enough buffer space for the glyph
>-	 */
>-	if (size > bufSize)
>-	{
>-	    if (bufBitmap != bufLocal)
>-		free (bufBitmap);
>-	    bufBitmap = (unsigned char *) malloc (size);
>-	    if (!bufBitmap)
>-		continue;
>-	    bufSize = size;
>-	}
>-	memset (bufBitmap, 0, size);
>-
>-	/*
>-	 * Rasterize into the local buffer
>-	 */
>-	switch (glyphslot->format) {
>-	case ft_glyph_format_outline:
>-	    ftbit.width      = width * hmul;
>-	    ftbit.rows       = height * vmul;
>-	    ftbit.pitch      = pitch;
>-	    if (font->info.antialias)
>-		ftbit.pixel_mode = ft_pixel_mode_grays;
>-	    else
>-		ftbit.pixel_mode = ft_pixel_mode_mono;
>-
>-	    ftbit.buffer     = bufBitmap;
>-
>-	    if (subpixel)
>-		FT_Outline_Transform (&glyphslot->outline, &matrix);
>-
>-	    FT_Outline_Translate ( &glyphslot->outline, -left*hmul, -bottom*vmul );
>-
>-	    FT_Outline_Get_Bitmap( _XftFTlibrary, &glyphslot->outline, &ftbit );
>-	    break;
>-	case ft_glyph_format_bitmap:
>-	    if (font->info.antialias)
>-	    {
>-		unsigned char	*srcLine, *dstLine;
>-		int		height;
>-		int		x;
>-		int	    h, v;
>-
>-		srcLine = glyphslot->bitmap.buffer;
>-		dstLine = bufBitmap;
>-		height = glyphslot->bitmap.rows;
>-		while (height--)
>-		{
>-		    for (x = 0; x < glyphslot->bitmap.width; x++)
>-		    {
>-			/* always MSB bitmaps */
>-			unsigned char	a = ((srcLine[x >> 3] & (0x80 >> (x & 7))) ?
>-					     0xff : 0x00);
>-			if (subpixel)
>-			{
>-			    for (v = 0; v < vmul; v++)
>-				for (h = 0; h < hmul; h++)
>-				    dstLine[v * pitch + x*hmul + h] = a;
>-			}
>-			else
>-			    dstLine[x] = a;
>-		    }
>-		    dstLine += pitch * vmul;
>-		    srcLine += glyphslot->bitmap.pitch;
>-		}
>-	    }
>-	    else
>-	    {
>-		unsigned char	*srcLine, *dstLine;
>-		int		h, bytes;
>-
>-		srcLine = glyphslot->bitmap.buffer;
>-		dstLine = bufBitmap;
>-		h = glyphslot->bitmap.rows;
>-		bytes = (glyphslot->bitmap.width + 7) >> 3;
>-		while (h--)
>-		{
>-		    memcpy (dstLine, srcLine, bytes);
>-		    dstLine += pitch;
>-		    srcLine += glyphslot->bitmap.pitch;
>-		}
>-	    }
>-	    break;
>-	default:
>-	    if (XftDebug() & XFT_DBG_GLYPH)
>-		printf ("glyph %d is not in a usable format\n",
>-			(int) glyphindex);
>-	    continue;
>-	}
>+	width = ftbit->width;
>+	height = ftbit->rows;
>+	pitch = (width+3) & ~3;
> 
> 	if (XftDebug() & XFT_DBG_GLYPH)
> 	{
>@@ -423,29 +589,72 @@ XftFontLoadGlyphs (Display	    *dpy,
> 		int		x, y;
> 		unsigned char	*line;
> 
>-		line = bufBitmap;
>-		for (y = 0; y < height * vmul; y++)
>+		line = ftbit->buffer;
>+		if (ftbit->pitch < 0)
>+		    line -= ftbit->pitch*(height-1);
>+
>+		for (y = 0; y < height; y++)
> 		{
> 		    if (font->info.antialias)
> 		    {
> 			static const char    den[] = { " .:;=+*#" };
>-			for (x = 0; x < pitch; x++)
>+			for (x = 0; x < width; x++)
> 			    printf ("%c", den[line[x] >> 5]);
> 		    }
> 		    else
> 		    {
>-			for (x = 0; x < pitch * 8; x++)
>+			for (x = 0; x < width * 8; x++)
> 			{
> 			    printf ("%c", line[x>>3] & (1 << (x & 7)) ? '#' : ' ');
> 			}
> 		    }
> 		    printf ("|\n");
>-		    line += pitch;
>+		    line += ftbit->pitch;
> 		}
> 		printf ("\n");
> 	    }
> 	}
> 
>+	size = _compute_xrender_bitmap_size( &local, glyphslot, mode );
>+	if ( size < 0 )
>+	    continue;
>+
>+	xftg->metrics.width  = local.width;
>+	xftg->metrics.height = local.rows;
>+	xftg->metrics.x      = - glyphslot->bitmap_left;
>+	xftg->metrics.y      =   glyphslot->bitmap_top;
>+
>+	/*
>+	 * If the glyph is relatively large (> 1% of server memory),
>+	 * don't send it until necessary.
>+	 */
>+	if (!need_bitmaps && size > info->max_glyph_memory / 100)
>+	    continue;
>+
>+	/*
>+	 * Make sure there is enough buffer space for the glyph.
>+	 */
>+	if (size > bufSize)
>+	{
>+	    if (bufBitmap != bufLocal)
>+		free (bufBitmap);
>+	    bufBitmap = (unsigned char *) malloc (size);
>+	    if (!bufBitmap)
>+		continue;
>+	    bufSize = size;
>+	}
>+	memset (bufBitmap, 0, size);
>+
>+	local.buffer = bufBitmap;
>+
>+	_fill_xrender_bitmap( &local, glyphslot, mode,
>+			      (font->info.rgba == FC_RGBA_BGR ||
>+			       font->info.rgba == FC_RGBA_VBGR ) );
>+
>+	/*
>+	 * Copy or convert into local buffer.
>+	 */
>+
> 	/*
> 	 * Use the glyph index as the wire encoding; it
> 	 * might be more efficient for some locales to map
>@@ -455,146 +664,54 @@ XftFontLoadGlyphs (Display	    *dpy,
> 	 */
> 	glyph = (Glyph) glyphindex;
> 
>-	if (subpixel)
>+	xftg->glyph_memory = size + sizeof (XftGlyph);
>+	if (font->format)
> 	{
>-	    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;
>-
>-	    /*
>-	     * Filter the glyph to soften the color fringes
>-	     */
>-	    widthrgba = width;
>-	    pitchrgba = (widthrgba * 4 + 3) & ~3;
>-	    sizergba = pitchrgba * height;
>-
>-	    os = 1;
>-	    switch (font->info.rgba) {
>-	    case FC_RGBA_VRGB:
>-		os = pitch;
>-	    case FC_RGBA_RGB:
>-	    default:
>-		rf = 0;
>-		gf = 1;
>-		bf = 2;
>-		break;
>-	    case FC_RGBA_VBGR:
>-		os = pitch;
>-	    case FC_RGBA_BGR:
>-		bf = 0;
>-		gf = 1;
>-		rf = 2;
>-		break;
>-	    }
>-	    if (sizergba > bufSizeRgba)
>-	    {
>-		if (bufBitmapRgba != bufLocalRgba)
>-		    free (bufBitmapRgba);
>-		bufBitmapRgba = (unsigned char *) malloc (sizergba);
>-		if (!bufBitmapRgba)
>-		    continue;
>-		bufSizeRgba = sizergba;
>-	    }
>-	    memset (bufBitmapRgba, 0, sizergba);
>-	    in_line = bufBitmap;
>-	    out_line = bufBitmapRgba;
>-	    for (y = 0; y < height; y++)
>+	    if (!font->glyphset)
>+		font->glyphset = XRenderCreateGlyphSet (dpy, font->format);
>+	    if ( mode == FT_RENDER_MODE_MONO )
> 	    {
>-		in = in_line;
>-		out = (unsigned int *) out_line;
>-		in_line += pitch * vmul;
>-		out_line += pitchrgba;
>-		for (x = 0; x < width * hmul; x += hmul)
>+		/* swap bits in each byte */
>+		if (BitmapBitOrder (dpy) != MSBFirst)
> 		{
>-		    red = green = blue = 0;
>-		    o = 0;
>-		    for (s = 0; s < 3; s++)
>+		    unsigned char   *line;
>+		    unsigned char   c;
>+		    int		    i;
>+
>+		    line = (unsigned char *) bufBitmap;
>+		    i = size;
>+		    while (i--)
> 		    {
>-			red += filters[rf][s]*in[x+o];
>-			green += filters[gf][s]*in[x+o];
>-			blue += filters[bf][s]*in[x+o];
>-			o += os;
>+			int c = *line;
>+			c = ((c << 1) & 0xaa) | ((c >> 1) & 0x55);
>+			c = ((c << 2) & 0xcc) | ((c >> 2) & 0x33);
>+			c = ((c << 4) & 0xf0) | ((c >> 4) & 0x0f);
>+			*line++ = c;
> 		    }
>-		    red = red / 65536;
>-		    green = green / 65536;
>-		    blue = blue / 65536;
>-		    *out++ = (green << 24) | (red << 16) | (green << 8) | blue;
> 		}
> 	    }
>-
>-	    xftg->glyph_memory = sizergba + sizeof (XftGlyph);
>-	    if (font->format)
>+	    else if ( mode != FT_RENDER_MODE_NORMAL )
> 	    {
>-		if (!font->glyphset)
>-		    font->glyphset = XRenderCreateGlyphSet (dpy, font->format);
>+		/* invert ARGB <=> BGRA */
> 		if (ImageByteOrder (dpy) != XftNativeByteOrder ())
>-		    XftSwapCARD32 ((CARD32 *) bufBitmapRgba, sizergba >> 2);
>-		XRenderAddGlyphs (dpy, font->glyphset, &glyph,
>-				  &xftg->metrics, 1,
>-				  (char *) bufBitmapRgba, sizergba);
>-	    }
>-	    else
>-	    {
>-		if (sizergba)
>-		{
>-		    xftg->bitmap = malloc (sizergba);
>-		    if (xftg->bitmap)
>-			memcpy (xftg->bitmap, bufBitmapRgba, sizergba);
>-		}
>-		else
>-		    xftg->bitmap = NULL;
>+		    XftSwapCARD32 ((CARD32 *) bufBitmap, size >> 2);
> 	    }
>+	    XRenderAddGlyphs (dpy, font->glyphset, &glyph,
>+			      &xftg->metrics, 1,
>+			      (char *) bufBitmap, size);
> 	}
> 	else
> 	{
>-	    xftg->glyph_memory = size + sizeof (XftGlyph);
>-	    if (font->format)
>+	    if (size)
> 	    {
>-		/*
>-		 * swap bit order around; FreeType is always MSBFirst
>-		 */
>-		if (!font->info.antialias)
>-		{
>-		    if (BitmapBitOrder (dpy) != MSBFirst)
>-		    {
>-			unsigned char   *line;
>-			unsigned char   c;
>-			int		    i;
>-
>-			line = (unsigned char *) bufBitmap;
>-			i = size;
>-			while (i--)
>-			{
>-			    c = *line;
>-			    c = ((c << 1) & 0xaa) | ((c >> 1) & 0x55);
>-			    c = ((c << 2) & 0xcc) | ((c >> 2) & 0x33);
>-			    c = ((c << 4) & 0xf0) | ((c >> 4) & 0x0f);
>-			    *line++ = c;
>-			}
>-		    }
>-		}
>-		if (!font->glyphset)
>-		    font->glyphset = XRenderCreateGlyphSet (dpy, font->format);
>-		XRenderAddGlyphs (dpy, font->glyphset, &glyph,
>-				  &xftg->metrics, 1,
>-				  (char *) bufBitmap, size);
>+		xftg->bitmap = malloc (size);
>+		if (xftg->bitmap)
>+		    memcpy (xftg->bitmap, bufBitmap, size);
> 	    }
> 	    else
>-	    {
>-		if (size)
>-		{
>-		    xftg->bitmap = malloc (size);
>-		    if (xftg->bitmap)
>-			memcpy (xftg->bitmap, bufBitmap, size);
>-		}
>-		else
>-		    xftg->bitmap = NULL;
>-	    }
>+		xftg->bitmap = NULL;
> 	}
>+
> 	font->glyph_memory += xftg->glyph_memory;
> 	info->glyph_memory += xftg->glyph_memory;
> 	if (XftDebug() & XFT_DBG_CACHE)
>@@ -605,8 +722,6 @@ XftFontLoadGlyphs (Display	    *dpy,
>     }
>     if (bufBitmap != bufLocal)
> 	free (bufBitmap);
>-    if (bufBitmapRgba != bufLocalRgba)
>-	free (bufBitmapRgba);
>     XftUnlockFace (&font->public);
> }
> 
>diff --git a/src/xftint.h b/src/xftint.h
>index eb9257e..5cb57ae 100644
>--- a/src/xftint.h
>+++ b/src/xftint.h
>@@ -145,6 +145,7 @@ struct _XftFontInfo {
>     FcBool		antialias;	/* doing antialiasing */
>     FcBool		embolden;	/* force emboldening */
>     int			rgba;		/* subpixel order */
>+    int			lcd_filter;	/* lcd filter */
>     FT_Matrix		matrix;		/* glyph transformation matrix */
>     FcBool		transform;	/* non-identify matrix? */
>     FT_Int		load_flags;	/* glyph load flags */
>-- 
>1.7.6.4
>

Actions: View | Splinter Review

Attachments on bug 29151: 37182 | 52055 | 52056

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.