From 6325bac21cc1bd0e0866e885933be94097aa49a03b79f66c1701634675381785 Mon Sep 17 00:00:00 2001 From: Stefan Dirsch Date: Thu, 9 Feb 2012 13:18:18 +0000 Subject: [PATCH] Accepting request 103564 from home:jengelh:branches:X11:XOrg Split xorg-x11-libs OBS-URL: https://build.opensuse.org/request/show/103564 OBS-URL: https://build.opensuse.org/package/show/X11:XOrg/libXft?expand=0&rev=1 --- .gitattributes | 23 + .gitignore | 1 + baselibs.conf | 4 + libXft-2.1.7-lcd-filter-2.patch | 791 ++++++++++++++++++++++++++++++++ libXft-2.2.0.tar.bz2 | 3 + libXft.changes | 4 + libXft.spec | 88 ++++ 7 files changed, 914 insertions(+) create mode 100644 .gitattributes create mode 100644 .gitignore create mode 100644 baselibs.conf create mode 100644 libXft-2.1.7-lcd-filter-2.patch create mode 100644 libXft-2.2.0.tar.bz2 create mode 100644 libXft.changes create mode 100644 libXft.spec diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..9b03811 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,23 @@ +## Default LFS +*.7z filter=lfs diff=lfs merge=lfs -text +*.bsp filter=lfs diff=lfs merge=lfs -text +*.bz2 filter=lfs diff=lfs merge=lfs -text +*.gem filter=lfs diff=lfs merge=lfs -text +*.gz filter=lfs diff=lfs merge=lfs -text +*.jar filter=lfs diff=lfs merge=lfs -text +*.lz filter=lfs diff=lfs merge=lfs -text +*.lzma filter=lfs diff=lfs merge=lfs -text +*.obscpio filter=lfs diff=lfs merge=lfs -text +*.oxt filter=lfs diff=lfs merge=lfs -text +*.pdf filter=lfs diff=lfs merge=lfs -text +*.png filter=lfs diff=lfs merge=lfs -text +*.rpm filter=lfs diff=lfs merge=lfs -text +*.tbz filter=lfs diff=lfs merge=lfs -text +*.tbz2 filter=lfs diff=lfs merge=lfs -text +*.tgz filter=lfs diff=lfs merge=lfs -text +*.ttf filter=lfs diff=lfs merge=lfs -text +*.txz filter=lfs diff=lfs merge=lfs -text +*.whl filter=lfs diff=lfs merge=lfs -text +*.xz filter=lfs diff=lfs merge=lfs -text +*.zip filter=lfs diff=lfs merge=lfs -text +*.zst filter=lfs diff=lfs merge=lfs -text diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..57affb6 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +.osc diff --git a/baselibs.conf b/baselibs.conf new file mode 100644 index 0000000..20f9a08 --- /dev/null +++ b/baselibs.conf @@ -0,0 +1,4 @@ +libXft2 +libXft-devel + requires -libXft- + requires "libXft2- = " diff --git a/libXft-2.1.7-lcd-filter-2.patch b/libXft-2.1.7-lcd-filter-2.patch new file mode 100644 index 0000000..5a3d2f0 --- /dev/null +++ b/libXft-2.1.7-lcd-filter-2.patch @@ -0,0 +1,791 @@ +--- src/xftglyphs.c.orig 2009-01-30 00:19:09.000000000 +0100 ++++ src/xftglyphs.c 2010-04-05 00:23:18.000000000 +0200 +@@ -21,27 +21,18 @@ + */ + + #include "xftint.h" +-#include + + #if HAVE_FT_GLYPHSLOT_EMBOLDEN + #include + #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 }, ++#if FREETYPE_MAJOR*10000 + FREETYPE_MINOR*100 + FREETYPE_PATCH < 20202 ++# error "FreeType 2.2.2 or later required to compile this version of libXft" + #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 }, +-}; ++ ++#include FT_OUTLINE_H ++#include FT_LCD_FILTER_H ++#include FT_SYNTHESIS_H + + /* + * Validate the memory info for a font +@@ -69,6 +60,295 @@ _XftFontValidateMemory (Display *dpy, Xf + 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 +367,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 +384,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,7 +417,10 @@ XftFontLoadGlyphs (Display *dpy, + if (xftg->glyph_memory) + continue; + ++ FT_Library_SetLcdFilter( _XftFTlibrary, FT_LCD_FILTER_DEFAULT ); ++ + error = FT_Load_Glyph (face, glyphindex, font->info.load_flags); ++ + if (error) + { + /* +@@ -181,7 +453,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 +532,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 +579,13 @@ 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 ); ++ // compute the size of the final bitmap ++ ftbit = &glyphslot->bitmap; + +- 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 +602,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 char den[] = { " .:;=+*#" }; +- for (x = 0; x < pitch; x++) ++ static const char den[] = { " .:;=+*#" }; ++ 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'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); ++ ++ 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,130 +677,33 @@ XftFontLoadGlyphs (Display *dpy, + */ + glyph = (Glyph) glyphindex; + +- if (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; +- +- /* +- * 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++) +- { +- in = in_line; +- out = (unsigned int *) out_line; +- in_line += pitch * vmul; +- out_line += pitchrgba; +- 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; ++ xftg->glyph_memory = size + sizeof (XftGlyph); ++ ++ if (font->format) { ++ if (!font->glyphset) ++ font->glyphset = XRenderCreateGlyphSet (dpy, font->format); ++ ++ if ( mode == FT_RENDER_MODE_MONO ) { ++ /* swap bits in each byte */ ++ if (BitmapBitOrder (dpy) != MSBFirst) { ++ unsigned char *line = (unsigned char*)bufBitmap; ++ int i = size; ++ ++ while (i--) { ++ 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) +- { +- if (!font->glyphset) +- font->glyphset = XRenderCreateGlyphSet (dpy, font->format); +- 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; + } +- } +- else +- { +- xftg->glyph_memory = size + sizeof (XftGlyph); +- if (font->format) +- { +- /* +- * 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); ++ else if ( mode != FT_RENDER_MODE_NORMAL ) ++ { ++ /* invert ARGB <=> BGRA */ ++ if (ImageByteOrder (dpy) != XftNativeByteOrder ()) ++ XftSwapCARD32 ((CARD32 *) bufBitmap, size >> 2); ++ } + XRenderAddGlyphs (dpy, font->glyphset, &glyph, + &xftg->metrics, 1, + (char *) bufBitmap, size); +@@ -594,7 +719,7 @@ XftFontLoadGlyphs (Display *dpy, + else + xftg->bitmap = NULL; + } +- } ++ + font->glyph_memory += xftg->glyph_memory; + info->glyph_memory += xftg->glyph_memory; + if (XftDebug() & XFT_DBG_CACHE) +@@ -605,8 +730,6 @@ XftFontLoadGlyphs (Display *dpy, + } + if (bufBitmap != bufLocal) + free (bufBitmap); +- if (bufBitmapRgba != bufLocalRgba) +- free (bufBitmapRgba); + XftUnlockFace (&font->public); + } + diff --git a/libXft-2.2.0.tar.bz2 b/libXft-2.2.0.tar.bz2 new file mode 100644 index 0000000..04f7916 --- /dev/null +++ b/libXft-2.2.0.tar.bz2 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c8685ae56da0c1dcc2bc1e34607e7d76ae98b86a1a71baba3a6b76dbcf5ff9b2 +size 290451 diff --git a/libXft.changes b/libXft.changes new file mode 100644 index 0000000..61dba6b --- /dev/null +++ b/libXft.changes @@ -0,0 +1,4 @@ +------------------------------------------------------------------- +Tue Feb 7 22:17:49 UTC 2012 - jengelh@medozas.de + +- Split xorg-x11-libs into separate packages diff --git a/libXft.spec b/libXft.spec new file mode 100644 index 0000000..5556ac9 --- /dev/null +++ b/libXft.spec @@ -0,0 +1,88 @@ +# +# spec file for package libXft +# +# Copyright (c) 2012 SUSE LINUX Products GmbH, Nuernberg, Germany. +# +# All modifications and additions to the file contributed by third parties +# remain the property of their copyright owners, unless otherwise agreed +# upon. The license for this file, and modifications and additions to the +# file, is the same license as for the pristine package itself (unless the +# license for the pristine package is not an Open Source License, in which +# case the license is the MIT License). An "Open Source License" is a +# license that conforms to the Open Source Definition (Version 1.9) +# published by the Open Source Initiative. + +# Please submit bugfixes or comments via http://bugs.opensuse.org/ +# +Name: libXft +%define lname libXft2 +Version: 2.2.0 +Release: 0 +Summary: X FreeType library +License: MIT +Group: Development/Libraries/C and C++ +Url: http://cgit.freedesktop.org/xorg/lib/libXft/ + +#Git-Clone: git://anongit.freedesktop.org/xorg/lib/libXft +Source: %name-%version.tar.bz2 +Patch1: libXft-2.1.7-lcd-filter-2.patch +#git#BuildRequires: autoconf >= 2.60, automake, libtool +BuildRequires: pkgconfig, pkgconfig(xorg-macros) >= 1.8 +BuildRequires: pkgconfig(xrender) >= 0.8.2, pkgconfig(freetype2) +BuildRequires: pkgconfig(fontconfig) >= 2.2 + +%description +Xft is a library that connects X applications with the FreeType font +rasterization library. Xft uses fontconfig to locate fonts so it has +no configuration files. + +%package -n %lname +Summary: X FreeType library +Group: System/Libraries + +%description -n %lname +Xft is a library that connects X applications with the FreeType font +rasterization library. Xft uses fontconfig to locate fonts so it has +no configuration files. + +%package devel +Summary: Development files for the X FreeType library +Group: Development/Libraries/C and C++ +Requires: %lname = %version + +%description devel +Xft is a library that connects X applications with the FreeType font +rasterization library. Xft uses fontconfig to locate fonts so it has +no configuration files. + +This package contains the development headers for the library found +in %lname. + +%prep +%setup -q +%patch -P 1 -p0 + +%build +%configure --disable-static +make %{?_smp_mflags} + +%install +%makeinstall +rm -f "%buildroot/%_libdir"/*.la + +%post -n %lname -p /sbin/ldconfig + +%postun -n %lname -p /sbin/ldconfig + +%files -n %lname +%defattr(-,root,root) +%_libdir/libXft.so.2* + +%files devel +%defattr(-,root,root) +%_includedir/X11/Xft +%_libdir/libXft.so +%_libdir/pkgconfig/xft.pc +%_mandir/man3/* + +%changelog