Attachment #220463 for bug #306053




static const cairo_font_options_t _cairo_font_options_nil = {
    CAIRO_ANTIALIAS_DEFAULT,
    CAIRO_SUBPIXEL_ORDER_DEFAULT,
    CAIRO_LCD_FILTER_DEFAULT,
    CAIRO_HINT_STYLE_DEFAULT,
    CAIRO_HINT_METRICS_DEFAULT
};

{
    options->antialias = CAIRO_ANTIALIAS_DEFAULT;
    options->subpixel_order = CAIRO_SUBPIXEL_ORDER_DEFAULT;
    options->lcd_filter = CAIRO_LCD_FILTER_DEFAULT;
    options->hint_style = CAIRO_HINT_STYLE_DEFAULT;
    options->hint_metrics = CAIRO_HINT_METRICS_DEFAULT;
}

{
    options->antialias = other->antialias;
    options->subpixel_order = other->subpixel_order;
    options->lcd_filter = other->lcd_filter;
    options->hint_style = other->hint_style;
    options->hint_metrics = other->hint_metrics;
}

	options->antialias = other->antialias;
    if (other->subpixel_order != CAIRO_SUBPIXEL_ORDER_DEFAULT)
	options->subpixel_order = other->subpixel_order;
    if (other->lcd_filter != CAIRO_LCD_FILTER_DEFAULT)
	options->lcd_filter = other->lcd_filter;
    if (other->hint_style != CAIRO_HINT_STYLE_DEFAULT)
	options->hint_style = other->hint_style;
    if (other->hint_metrics != CAIRO_HINT_METRICS_DEFAULT)


    return (options->antialias == other->antialias &&
	    options->subpixel_order == other->subpixel_order &&
	    options->lcd_filter == other->lcd_filter &&
	    options->hint_style == other->hint_style &&
	    options->hint_metrics == other->hint_metrics);
}


    return ((options->antialias) |
	    (options->subpixel_order << 4) |
	    (options->lcd_filter << 8) |
	    (options->hint_style << 12) |
	    (options->hint_metrics << 16));
}
slim_hidden_def (cairo_font_options_hash);

}

/**
 * _cairo_font_options_set_lcd_filter:
 * @options: a #cairo_font_options_t
 * @lcd_filter: the new LCD filter
 *
 * Sets the LCD filter for the font options object. The LCD filter
 * specifies how pixels are filtered when rendered with an antialiasing
 * mode of %CAIRO_ANTIALIAS_SUBPIXEL. See the documentation for
 * #cairo_lcd_filter_t for full details.
 *
 * Since: 1.8
 **/
void
_cairo_font_options_set_lcd_filter (cairo_font_options_t *options,
				    cairo_lcd_filter_t    lcd_filter)
{
    if (cairo_font_options_status (options))
	return;

    options->lcd_filter = lcd_filter;
}

/**
 * _cairo_font_options_get_lcd_filter:
 * @options: a #cairo_font_options_t
 *
 * Gets the LCD filter for the font options object.
 * See the documentation for #cairo_lcd_filter_t for full details.
 *
 * Return value: the LCD filter for the font options object
 *
 * Since: 1.8
 **/
cairo_lcd_filter_t
_cairo_font_options_get_lcd_filter (const cairo_font_options_t *options)
{
    if (cairo_font_options_status ((cairo_font_options_t *) options))
	return CAIRO_LCD_FILTER_DEFAULT;

    return options->lcd_filter;
}

/**
 * cairo_font_options_set_hint_style:
 * @options: a #cairo_font_options_t
 * @hint_style: the new hint style




#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))

    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) ;
#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;
		}
	    }
	}
    }
}


/* Fills in val->image with an image surface created from @bitmap
 */

    int width, height, stride;
    unsigned char *data;
    int format = CAIRO_FORMAT_A8;
    cairo_image_surface_t *image;

    width = bitmap->width;
    height = bitmap->rows;

    case FT_PIXEL_MODE_LCD:
    case FT_PIXEL_MODE_LCD_V:
    case FT_PIXEL_MODE_GRAY:
        if (font_options->antialias != CAIRO_ANTIALIAS_SUBPIXEL) {
	case CAIRO_ANTIALIAS_DEFAULT:
	case CAIRO_ANTIALIAS_GRAY:
	case CAIRO_ANTIALIAS_NONE:
	default:
	    stride = bitmap->pitch;
	    if (own_buffer) {
		data = bitmap->buffer;

		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);
	    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;

	    data = bitmap->buffer;
	    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:

	return _cairo_error (CAIRO_STATUS_NO_MEMORY);
    }

    /* XXX */
    *surface = image = (cairo_image_surface_t *)
	cairo_image_surface_create_for_data (data,
					     format,
					     width, height, stride);
    if (image->base.status) {
	free (data);
	return (*surface)->base.status;
    }

    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;
}

		       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;
    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);



    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:
	    format = CAIRO_FORMAT_A1;
	    break;
	case FT_RENDER_MODE_LCD:
	case FT_RENDER_MODE_LCD_V:
	    format= CAIRO_FORMAT_ARGB32;
	    break;
	case FT_RENDER_MODE_LIGHT:
	case FT_RENDER_MODE_NORMAL:
	case FT_RENDER_MODE_MAX:
	default:
	    format = CAIRO_FORMAT_A8;
	    break;

	    return (*surface)->base.status;
    } else  {

	int bitmap_size;
	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;
	    }
	case CAIRO_ANTIALIAS_GRAY:
	    bitmap.pixel_mode = FT_PIXEL_MODE_GRAY;
	    bitmap.num_grays  = 256;
	    stride = (width + 3) & -4;
	    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;
	    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;
	    }
	    break;
	case FT_RENDER_MODE_MONO:
	case FT_RENDER_MODE_LIGHT:
	case FT_RENDER_MODE_NORMAL:
	case FT_RENDER_MODE_MAX:
	default:
	    break;
	}

#if HAVE_FT_LIBRARY_SETLCDFILTER
	FT_Library_SetLcdFilter (library, lcd_filter);
#endif

	fterror = FT_Render_Glyph (face->glyph, render_mode);

#if HAVE_FT_LIBRARY_SETLCDFILTER
	FT_Library_SetLcdFilter (library, FT_LCD_FILTER_NONE);
#endif

	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)
	    return _cairo_error (CAIRO_STATUS_NO_MEMORY);

	bitmap.buffer = calloc (1, bitmap_size);
	if (bitmap.buffer == NULL)
	    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);
    }

    return CAIRO_STATUS_SUCCESS;
}

    
    if (antialias) {
	cairo_subpixel_order_t subpixel_order;
	int lcd_filter;

	/* disable hinting if requested */
	if (FcPatternGetBool (pattern,

	    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)

    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;

		case CAIRO_SUBPIXEL_ORDER_DEFAULT:
		case CAIRO_SUBPIXEL_ORDER_RGB:
		case CAIRO_SUBPIXEL_ORDER_BGR:
		    load_target = FT_LOAD_TARGET_LCD;
		    break;
		case CAIRO_SUBPIXEL_ORDER_VRGB:
		case CAIRO_SUBPIXEL_ORDER_VBGR:
		    load_target = FT_LOAD_TARGET_LCD_V;
		break;
		}
	    }

	}
    }

    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)

Lines 73-78 Link Here

(-)cairo-1.8.0~/src/cairo-surface.c (+1 lines)
73	FALSE, /* has_font_options */ \	73	FALSE, /* has_font_options */ \
74	{ CAIRO_ANTIALIAS_DEFAULT, /* antialias */ \	74	{ CAIRO_ANTIALIAS_DEFAULT, /* antialias */ \
75	CAIRO_SUBPIXEL_ORDER_DEFAULT, /* subpixel_order */ \	75	CAIRO_SUBPIXEL_ORDER_DEFAULT, /* subpixel_order */ \
		76	CAIRO_LCD_FILTER_DEFAULT, /* lcd_filter */ \
76	CAIRO_HINT_STYLE_DEFAULT, /* hint_style */ \	77	CAIRO_HINT_STYLE_DEFAULT, /* hint_style */ \
77	CAIRO_HINT_METRICS_DEFAULT /* hint_metrics */ \	78	CAIRO_HINT_METRICS_DEFAULT /* hint_metrics */ \
78	} /* font_options */ \	79	} /* font_options */ \




    cairo_bool_t is_snapshot;
};


/**
 * cairo_lcd_filter_t:
 * @CAIRO_LCD_FILTER_DEFAULT: Use the default LCD filter for
 *   font backend and target device
 * @CAIRO_LCD_FILTER_NONE: Do not perform LCD filtering
 * @CAIRO_LCD_FILTER_INTRA_PIXEL: Intra-pixel filter
 * @CAIRO_LCD_FILTER_FIR3: FIR filter with a 3x3 kernel
 * @CAIRO_LCD_FILTER_FIR5: FIR filter with a 5x5 kernel
 *
 * The LCD filter specifies the low-pass filter applied to LCD-optimized
 * bitmaps generated with an antialiasing mode of %CAIRO_ANTIALIAS_SUBPIXEL.
 *
 * Note: This API was temporarily made available in the public
 * interface during the 1.7.x development series, but was made private
 * before 1.8.
 **/
typedef enum _cairo_lcd_filter {
    CAIRO_LCD_FILTER_DEFAULT,
    CAIRO_LCD_FILTER_NONE,
    CAIRO_LCD_FILTER_INTRA_PIXEL,
    CAIRO_LCD_FILTER_FIR3,
    CAIRO_LCD_FILTER_FIR5
} cairo_lcd_filter_t;

struct _cairo_font_options {
    cairo_antialias_t antialias;
    cairo_subpixel_order_t subpixel_order;
    cairo_lcd_filter_t lcd_filter;
    cairo_hint_style_t hint_style;
    cairo_hint_metrics_t hint_metrics;
};




    cairo_bool_t xft_antialias;
    int xft_hintstyle;
    int xft_rgba;
    int xft_lcdfilter;
    cairo_antialias_t antialias;
    cairo_subpixel_order_t subpixel_order;
    cairo_lcd_filter_t lcd_filter;
    cairo_hint_style_t hint_style;

    if (!get_boolean_default (dpy, "antialias", &xft_antialias))
	xft_antialias = TRUE;

    if (!get_integer_default (dpy, "lcdfilter", &xft_lcdfilter)) {
	/* -1 is an non-existant Fontconfig constant used to differentiate
	 * the case when no lcdfilter property is available.
	 */
	xft_lcdfilter = -1;
    }

    if (!get_boolean_default (dpy, "hinting", &xft_hinting))
	xft_hinting = TRUE;


	subpixel_order = CAIRO_SUBPIXEL_ORDER_DEFAULT;
    }

    switch (xft_lcdfilter) {
    case FC_LCD_NONE:
	lcd_filter = CAIRO_LCD_FILTER_NONE;
	break;
    case FC_LCD_DEFAULT:
	lcd_filter = CAIRO_LCD_FILTER_FIR5;
	break;
    case FC_LCD_LIGHT:
	lcd_filter = CAIRO_LCD_FILTER_FIR3;
	break;
    case FC_LCD_LEGACY:
	lcd_filter = CAIRO_LCD_FILTER_INTRA_PIXEL;
	break;
    default:
	lcd_filter = CAIRO_LCD_FILTER_DEFAULT;
	break;
    }

    if (xft_antialias) {
	if (subpixel_order == CAIRO_SUBPIXEL_ORDER_DEFAULT)
	    antialias = CAIRO_ANTIALIAS_GRAY;

    cairo_font_options_set_hint_style (&info->font_options, hint_style);
    cairo_font_options_set_antialias (&info->font_options, antialias);
    cairo_font_options_set_subpixel_order (&info->font_options, subpixel_order);
    _cairo_font_options_set_lcd_filter (&info->font_options, lcd_filter);
    cairo_font_options_set_hint_metrics (&info->font_options, CAIRO_HINT_METRICS_ON);
}


Lines 1336-1341 Link Here

(-)cairo-1.8.0~/src/cairoint.h (+7 lines)
1336	_cairo_font_options_init_copy (cairo_font_options_t *options,	1336	_cairo_font_options_init_copy (cairo_font_options_t *options,
1337	const cairo_font_options_t *other);	1337	const cairo_font_options_t *other);
1338		1338
		1339	cairo_private void
		1340	_cairo_font_options_set_lcd_filter (cairo_font_options_t *options,
		1341	cairo_lcd_filter_t lcd_filter);
		1342
		1343	cairo_private cairo_lcd_filter_t
		1344	_cairo_font_options_get_lcd_filter (const cairo_font_options_t *options);
		1345
1339	/* cairo-hull.c */	1346	/* cairo-hull.c */
1340	cairo_private cairo_status_t	1347	cairo_private cairo_status_t
1341	_cairo_hull_compute (cairo_pen_vertex_t vertices, int num_vertices);	1348	_cairo_hull_compute (cairo_pen_vertex_t vertices, int num_vertices);

Return to bug 306053

Lines 113-121 Link Here

(-)cairo-1.8.0~/src/cairo-types-private.h (+26 lines)
113	cairo_bool_t is_snapshot;	113	cairo_bool_t is_snapshot;
114	};	114	};
115		115
		116
		117	/**
		118	* cairo_lcd_filter_t:
		119	* @CAIRO_LCD_FILTER_DEFAULT: Use the default LCD filter for
		120	* font backend and target device
		121	* @CAIRO_LCD_FILTER_NONE: Do not perform LCD filtering
		122	* @CAIRO_LCD_FILTER_INTRA_PIXEL: Intra-pixel filter
		123	* @CAIRO_LCD_FILTER_FIR3: FIR filter with a 3x3 kernel
		124	* @CAIRO_LCD_FILTER_FIR5: FIR filter with a 5x5 kernel
		125	*
		126	* The LCD filter specifies the low-pass filter applied to LCD-optimized
		127	* bitmaps generated with an antialiasing mode of %CAIRO_ANTIALIAS_SUBPIXEL.
		128	*
		129	* Note: This API was temporarily made available in the public
		130	* interface during the 1.7.x development series, but was made private
		131	* before 1.8.
		132	**/
		133	typedef enum _cairo_lcd_filter {
		134	CAIRO_LCD_FILTER_DEFAULT,
		135	CAIRO_LCD_FILTER_NONE,
		136	CAIRO_LCD_FILTER_INTRA_PIXEL,
		137	CAIRO_LCD_FILTER_FIR3,
		138	CAIRO_LCD_FILTER_FIR5
		139	} cairo_lcd_filter_t;
		140
116	struct _cairo_font_options {	141	struct _cairo_font_options {
117	cairo_antialias_t antialias;	142	cairo_antialias_t antialias;
118	cairo_subpixel_order_t subpixel_order;	143	cairo_subpixel_order_t subpixel_order;
		144	cairo_lcd_filter_t lcd_filter;
119	cairo_hint_style_t hint_style;	145	cairo_hint_style_t hint_style;
120	cairo_hint_metrics_t hint_metrics;	146	cairo_hint_metrics_t hint_metrics;
121	};	147	};

Lines 150-162 Link Here

(-)cairo-1.8.0~/src/cairo-xlib-screen.c (+28 lines)
150	cairo_bool_t xft_antialias;	150	cairo_bool_t xft_antialias;
151	int xft_hintstyle;	151	int xft_hintstyle;
152	int xft_rgba;	152	int xft_rgba;
		153	int xft_lcdfilter;
153	cairo_antialias_t antialias;	154	cairo_antialias_t antialias;
154	cairo_subpixel_order_t subpixel_order;	155	cairo_subpixel_order_t subpixel_order;
		156	cairo_lcd_filter_t lcd_filter;
155	cairo_hint_style_t hint_style;	157	cairo_hint_style_t hint_style;
156		158
157	if (!get_boolean_default (dpy, "antialias", &xft_antialias))	159	if (!get_boolean_default (dpy, "antialias", &xft_antialias))
158	xft_antialias = TRUE;	160	xft_antialias = TRUE;
159		161
		162	if (!get_integer_default (dpy, "lcdfilter", &xft_lcdfilter)) {
		163	/* -1 is an non-existant Fontconfig constant used to differentiate
		164	* the case when no lcdfilter property is available.
		165	*/
		166	xft_lcdfilter = -1;
		167	}
		168
160	if (!get_boolean_default (dpy, "hinting", &xft_hinting))	169	if (!get_boolean_default (dpy, "hinting", &xft_hinting))
161	xft_hinting = TRUE;	170	xft_hinting = TRUE;
162		171
Lines 239-244 Link Here
239	subpixel_order = CAIRO_SUBPIXEL_ORDER_DEFAULT;	248	subpixel_order = CAIRO_SUBPIXEL_ORDER_DEFAULT;
240	}	249	}
241		250
		251	switch (xft_lcdfilter) {
		252	case FC_LCD_NONE:
		253	lcd_filter = CAIRO_LCD_FILTER_NONE;
		254	break;
		255	case FC_LCD_DEFAULT:
		256	lcd_filter = CAIRO_LCD_FILTER_FIR5;
		257	break;
		258	case FC_LCD_LIGHT:
		259	lcd_filter = CAIRO_LCD_FILTER_FIR3;
		260	break;
		261	case FC_LCD_LEGACY:
		262	lcd_filter = CAIRO_LCD_FILTER_INTRA_PIXEL;
		263	break;
		264	default:
		265	lcd_filter = CAIRO_LCD_FILTER_DEFAULT;
		266	break;
		267	}
		268
242	if (xft_antialias) {	269	if (xft_antialias) {
243	if (subpixel_order == CAIRO_SUBPIXEL_ORDER_DEFAULT)	270	if (subpixel_order == CAIRO_SUBPIXEL_ORDER_DEFAULT)
244	antialias = CAIRO_ANTIALIAS_GRAY;	271	antialias = CAIRO_ANTIALIAS_GRAY;
Lines 251-256 Link Here
251	cairo_font_options_set_hint_style (&info->font_options, hint_style);	278	cairo_font_options_set_hint_style (&info->font_options, hint_style);
252	cairo_font_options_set_antialias (&info->font_options, antialias);	279	cairo_font_options_set_antialias (&info->font_options, antialias);
253	cairo_font_options_set_subpixel_order (&info->font_options, subpixel_order);	280	cairo_font_options_set_subpixel_order (&info->font_options, subpixel_order);
		281	_cairo_font_options_set_lcd_filter (&info->font_options, lcd_filter);
254	cairo_font_options_set_hint_metrics (&info->font_options, CAIRO_HINT_METRICS_ON);	282	cairo_font_options_set_hint_metrics (&info->font_options, CAIRO_HINT_METRICS_ON);
255	}	283	}
256		284

Lines 39-44 Link Here

(-)cairo-1.8.0~/src/cairo-font-options.c (-1 / +50 lines)
39	static const cairo_font_options_t _cairo_font_options_nil = {	39	static const cairo_font_options_t _cairo_font_options_nil = {
40	CAIRO_ANTIALIAS_DEFAULT,	40	CAIRO_ANTIALIAS_DEFAULT,
41	CAIRO_SUBPIXEL_ORDER_DEFAULT,	41	CAIRO_SUBPIXEL_ORDER_DEFAULT,
		42	CAIRO_LCD_FILTER_DEFAULT,
42	CAIRO_HINT_STYLE_DEFAULT,	43	CAIRO_HINT_STYLE_DEFAULT,
43	CAIRO_HINT_METRICS_DEFAULT	44	CAIRO_HINT_METRICS_DEFAULT
44	};	45	};
Lines 54-59 Link Here
54	{	55	{
55	options->antialias = CAIRO_ANTIALIAS_DEFAULT;	56	options->antialias = CAIRO_ANTIALIAS_DEFAULT;
56	options->subpixel_order = CAIRO_SUBPIXEL_ORDER_DEFAULT;	57	options->subpixel_order = CAIRO_SUBPIXEL_ORDER_DEFAULT;
		58	options->lcd_filter = CAIRO_LCD_FILTER_DEFAULT;
57	options->hint_style = CAIRO_HINT_STYLE_DEFAULT;	59	options->hint_style = CAIRO_HINT_STYLE_DEFAULT;
58	options->hint_metrics = CAIRO_HINT_METRICS_DEFAULT;	60	options->hint_metrics = CAIRO_HINT_METRICS_DEFAULT;
59	}	61	}
Lines 64-69 Link Here
64	{	66	{
65	options->antialias = other->antialias;	67	options->antialias = other->antialias;
66	options->subpixel_order = other->subpixel_order;	68	options->subpixel_order = other->subpixel_order;
		69	options->lcd_filter = other->lcd_filter;
67	options->hint_style = other->hint_style;	70	options->hint_style = other->hint_style;
68	options->hint_metrics = other->hint_metrics;	71	options->hint_metrics = other->hint_metrics;
69	}	72	}
Lines 189-194 Link Here
189	options->antialias = other->antialias;	192	options->antialias = other->antialias;
190	if (other->subpixel_order != CAIRO_SUBPIXEL_ORDER_DEFAULT)	193	if (other->subpixel_order != CAIRO_SUBPIXEL_ORDER_DEFAULT)
191	options->subpixel_order = other->subpixel_order;	194	options->subpixel_order = other->subpixel_order;
		195	if (other->lcd_filter != CAIRO_LCD_FILTER_DEFAULT)
		196	options->lcd_filter = other->lcd_filter;
192	if (other->hint_style != CAIRO_HINT_STYLE_DEFAULT)	197	if (other->hint_style != CAIRO_HINT_STYLE_DEFAULT)
193	options->hint_style = other->hint_style;	198	options->hint_style = other->hint_style;
194	if (other->hint_metrics != CAIRO_HINT_METRICS_DEFAULT)	199	if (other->hint_metrics != CAIRO_HINT_METRICS_DEFAULT)
Lines 221-226 Link Here
221		226
222	return (options->antialias == other->antialias &&	227	return (options->antialias == other->antialias &&
223	options->subpixel_order == other->subpixel_order &&	228	options->subpixel_order == other->subpixel_order &&
		229	options->lcd_filter == other->lcd_filter &&
224	options->hint_style == other->hint_style &&	230	options->hint_style == other->hint_style &&
225	options->hint_metrics == other->hint_metrics);	231	options->hint_metrics == other->hint_metrics);
226	}	232	}
Lines 246-252 Link Here
246		252
247	return ((options->antialias) \|	253	return ((options->antialias) \|
248	(options->subpixel_order << 4) \|	254	(options->subpixel_order << 4) \|
249	(options->hint_style << 8) \|	255	(options->lcd_filter << 8) \|
		256	(options->hint_style << 12) \|
250	(options->hint_metrics << 16));	257	(options->hint_metrics << 16));
251	}	258	}
252	slim_hidden_def (cairo_font_options_hash);	259	slim_hidden_def (cairo_font_options_hash);
Lines 328-333 Link Here
328	}	335	}
329		336
330	/**	337	/**
		338	* _cairo_font_options_set_lcd_filter:
		339	* @options: a #cairo_font_options_t
		340	* @lcd_filter: the new LCD filter
		341	*
		342	* Sets the LCD filter for the font options object. The LCD filter
		343	* specifies how pixels are filtered when rendered with an antialiasing
		344	* mode of %CAIRO_ANTIALIAS_SUBPIXEL. See the documentation for
		345	* #cairo_lcd_filter_t for full details.
		346	*
		347	* Since: 1.8
		348	**/
		349	void
		350	_cairo_font_options_set_lcd_filter (cairo_font_options_t *options,
		351	cairo_lcd_filter_t lcd_filter)
		352	{
		353	if (cairo_font_options_status (options))
		354	return;
		355
		356	options->lcd_filter = lcd_filter;
		357	}
		358
		359	/**
		360	* _cairo_font_options_get_lcd_filter:
		361	* @options: a #cairo_font_options_t
		362	*
		363	* Gets the LCD filter for the font options object.
		364	* See the documentation for #cairo_lcd_filter_t for full details.
		365	*
		366	* Return value: the LCD filter for the font options object
		367	*
		368	* Since: 1.8
		369	**/
		370	cairo_lcd_filter_t
		371	_cairo_font_options_get_lcd_filter (const cairo_font_options_t *options)
		372	{
		373	if (cairo_font_options_status ((cairo_font_options_t *) options))
		374	return CAIRO_LCD_FILTER_DEFAULT;
		375
		376	return options->lcd_filter;
		377	}
		378
		379	/**
331	* cairo_font_options_set_hint_style:	380	* cairo_font_options_set_hint_style:
332	* @options: a #cairo_font_options_t	381	* @options: a #cairo_font_options_t
333	* @hint_style: the new hint style	382	* @hint_style: the new hint style