265d20068a
Since commit f07f18231a ('EXA: Allow using
exaCompositeRects also when we can't use a mask in exaGlyphs.') we were
checking the wrong set of coordinates in the buffer where glyphs to be rendered
are accumulated when no mask is used in exaGlyphs.
This fixes occasional glyph corruption which can be corrected with redraws, in
particular with Qt4.
Thanks to Maarten Maathuis for asking the right question: 'where do we protect
against evicting glyphs that are still needed?'
Signed-off-by: Michel Dänzer <daenzer@vmware.com>
835 lines
22 KiB
C
835 lines
22 KiB
C
/*
|
|
* Copyright © 2008 Red Hat, Inc.
|
|
* Partly based on code Copyright © 2000 SuSE, Inc.
|
|
*
|
|
* Permission to use, copy, modify, distribute, and sell this software and its
|
|
* documentation for any purpose is hereby granted without fee, provided that
|
|
* the above copyright notice appear in all copies and that both that
|
|
* copyright notice and this permission notice appear in supporting
|
|
* documentation, and that the name of Red Hat not be used in advertising or
|
|
* publicity pertaining to distribution of the software without specific,
|
|
* written prior permission. Red Hat makes no representations about the
|
|
* suitability of this software for any purpose. It is provided "as is"
|
|
* without express or implied warranty.
|
|
*
|
|
* Red Hat DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL Red Hat
|
|
* BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
|
|
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
|
|
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
*
|
|
* Permission to use, copy, modify, distribute, and sell this software and its
|
|
* documentation for any purpose is hereby granted without fee, provided that
|
|
* the above copyright notice appear in all copies and that both that
|
|
* copyright notice and this permission notice appear in supporting
|
|
* documentation, and that the name of SuSE not be used in advertising or
|
|
* publicity pertaining to distribution of the software without specific,
|
|
* written prior permission. SuSE makes no representations about the
|
|
* suitability of this software for any purpose. It is provided "as is"
|
|
* without express or implied warranty.
|
|
*
|
|
* SuSE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL SuSE
|
|
* BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
|
|
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
|
|
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
*
|
|
* Author: Owen Taylor <otaylor@fishsoup.net>
|
|
* Based on code by: Keith Packard
|
|
*/
|
|
|
|
#ifdef HAVE_DIX_CONFIG_H
|
|
#include <dix-config.h>
|
|
#endif
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include "exa_priv.h"
|
|
|
|
#include "mipict.h"
|
|
|
|
#if DEBUG_GLYPH_CACHE
|
|
#define DBG_GLYPH_CACHE(a) ErrorF a
|
|
#else
|
|
#define DBG_GLYPH_CACHE(a)
|
|
#endif
|
|
|
|
/* Width of the pixmaps we use for the caches; this should be less than
|
|
* max texture size of the driver; this may need to actually come from
|
|
* the driver.
|
|
*/
|
|
#define CACHE_PICTURE_WIDTH 1024
|
|
|
|
/* Maximum number of glyphs we buffer on the stack before flushing
|
|
* rendering to the mask or destination surface.
|
|
*/
|
|
#define GLYPH_BUFFER_SIZE 256
|
|
|
|
typedef struct {
|
|
PicturePtr mask;
|
|
ExaCompositeRectRec rects[GLYPH_BUFFER_SIZE];
|
|
int count;
|
|
} ExaGlyphBuffer, *ExaGlyphBufferPtr;
|
|
|
|
typedef enum {
|
|
ExaGlyphSuccess, /* Glyph added to render buffer */
|
|
ExaGlyphFail, /* out of memory, etc */
|
|
ExaGlyphNeedFlush, /* would evict a glyph already in the buffer */
|
|
} ExaGlyphCacheResult;
|
|
|
|
void
|
|
exaGlyphsInit(ScreenPtr pScreen)
|
|
{
|
|
ExaScreenPriv(pScreen);
|
|
int i = 0;
|
|
|
|
memset(pExaScr->glyphCaches, 0, sizeof(pExaScr->glyphCaches));
|
|
|
|
pExaScr->glyphCaches[i].format = PICT_a8;
|
|
pExaScr->glyphCaches[i].glyphWidth = pExaScr->glyphCaches[i].glyphHeight = 16;
|
|
i++;
|
|
pExaScr->glyphCaches[i].format = PICT_a8;
|
|
pExaScr->glyphCaches[i].glyphWidth = pExaScr->glyphCaches[i].glyphHeight = 32;
|
|
i++;
|
|
pExaScr->glyphCaches[i].format = PICT_a8r8g8b8;
|
|
pExaScr->glyphCaches[i].glyphWidth = pExaScr->glyphCaches[i].glyphHeight = 16;
|
|
i++;
|
|
pExaScr->glyphCaches[i].format = PICT_a8r8g8b8;
|
|
pExaScr->glyphCaches[i].glyphWidth = pExaScr->glyphCaches[i].glyphHeight = 32;
|
|
i++;
|
|
|
|
assert(i == EXA_NUM_GLYPH_CACHES);
|
|
|
|
for (i = 0; i < EXA_NUM_GLYPH_CACHES; i++) {
|
|
pExaScr->glyphCaches[i].columns = CACHE_PICTURE_WIDTH / pExaScr->glyphCaches[i].glyphWidth;
|
|
pExaScr->glyphCaches[i].size = 256;
|
|
pExaScr->glyphCaches[i].hashSize = 557;
|
|
}
|
|
}
|
|
|
|
static void
|
|
exaUnrealizeGlyphCaches(ScreenPtr pScreen,
|
|
unsigned int format)
|
|
{
|
|
ExaScreenPriv(pScreen);
|
|
int i;
|
|
|
|
for (i = 0; i < EXA_NUM_GLYPH_CACHES; i++) {
|
|
ExaGlyphCachePtr cache = &pExaScr->glyphCaches[i];
|
|
|
|
if (cache->format != format)
|
|
continue;
|
|
|
|
if (cache->picture) {
|
|
FreePicture ((pointer) cache->picture, (XID) 0);
|
|
cache->picture = NULL;
|
|
}
|
|
|
|
if (cache->hashEntries) {
|
|
xfree(cache->hashEntries);
|
|
cache->hashEntries = NULL;
|
|
}
|
|
|
|
if (cache->glyphs) {
|
|
xfree(cache->glyphs);
|
|
cache->glyphs = NULL;
|
|
}
|
|
cache->glyphCount = 0;
|
|
}
|
|
}
|
|
|
|
#define NeedsComponent(f) (PICT_FORMAT_A(f) != 0 && PICT_FORMAT_RGB(f) != 0)
|
|
|
|
/* All caches for a single format share a single pixmap for glyph storage,
|
|
* allowing mixing glyphs of different sizes without paying a penalty
|
|
* for switching between mask pixmaps. (Note that for a size of font
|
|
* right at the border between two sizes, we might be switching for almost
|
|
* every glyph.)
|
|
*
|
|
* This function allocates the storage pixmap, and then fills in the
|
|
* rest of the allocated structures for all caches with the given format.
|
|
*/
|
|
static Bool
|
|
exaRealizeGlyphCaches(ScreenPtr pScreen,
|
|
unsigned int format)
|
|
{
|
|
ExaScreenPriv(pScreen);
|
|
|
|
int depth = PIXMAN_FORMAT_DEPTH(format);
|
|
PictFormatPtr pPictFormat;
|
|
PixmapPtr pPixmap;
|
|
PicturePtr pPicture;
|
|
CARD32 component_alpha;
|
|
int height;
|
|
int i;
|
|
int error;
|
|
|
|
pPictFormat = PictureMatchFormat(pScreen, depth, format);
|
|
if (!pPictFormat)
|
|
return FALSE;
|
|
|
|
/* Compute the total vertical size needed for the format */
|
|
|
|
height = 0;
|
|
for (i = 0; i < EXA_NUM_GLYPH_CACHES; i++) {
|
|
ExaGlyphCachePtr cache = &pExaScr->glyphCaches[i];
|
|
int rows;
|
|
|
|
if (cache->format != format)
|
|
continue;
|
|
|
|
cache->yOffset = height;
|
|
|
|
rows = (cache->size + cache->columns - 1) / cache->columns;
|
|
height += rows * cache->glyphHeight;
|
|
}
|
|
|
|
/* Now allocate the pixmap and picture */
|
|
|
|
pPixmap = (*pScreen->CreatePixmap) (pScreen,
|
|
CACHE_PICTURE_WIDTH,
|
|
height, depth, 0);
|
|
if (!pPixmap)
|
|
return FALSE;
|
|
|
|
component_alpha = NeedsComponent(pPictFormat->format);
|
|
pPicture = CreatePicture(0, &pPixmap->drawable, pPictFormat,
|
|
CPComponentAlpha, &component_alpha, serverClient,
|
|
&error);
|
|
|
|
(*pScreen->DestroyPixmap) (pPixmap); /* picture holds a refcount */
|
|
|
|
if (!pPicture)
|
|
return FALSE;
|
|
|
|
/* And store the picture in all the caches for the format */
|
|
|
|
for (i = 0; i < EXA_NUM_GLYPH_CACHES; i++) {
|
|
ExaGlyphCachePtr cache = &pExaScr->glyphCaches[i];
|
|
int j;
|
|
|
|
if (cache->format != format)
|
|
continue;
|
|
|
|
cache->picture = pPicture;
|
|
cache->picture->refcnt++;
|
|
cache->hashEntries = xalloc(sizeof(int) * cache->hashSize);
|
|
cache->glyphs = xalloc(sizeof(ExaCachedGlyphRec) * cache->size);
|
|
cache->glyphCount = 0;
|
|
|
|
if (!cache->hashEntries || !cache->glyphs)
|
|
goto bail;
|
|
|
|
for (j = 0; j < cache->hashSize; j++)
|
|
cache->hashEntries[j] = -1;
|
|
|
|
cache->evictionPosition = rand() % cache->size;
|
|
}
|
|
|
|
/* Each cache references the picture individually */
|
|
FreePicture ((pointer) pPicture, (XID) 0);
|
|
return TRUE;
|
|
|
|
bail:
|
|
exaUnrealizeGlyphCaches(pScreen, format);
|
|
return FALSE;
|
|
}
|
|
|
|
void
|
|
exaGlyphsFini (ScreenPtr pScreen)
|
|
{
|
|
ExaScreenPriv(pScreen);
|
|
int i;
|
|
|
|
for (i = 0; i < EXA_NUM_GLYPH_CACHES; i++) {
|
|
ExaGlyphCachePtr cache = &pExaScr->glyphCaches[i];
|
|
|
|
if (cache->picture)
|
|
exaUnrealizeGlyphCaches(pScreen, cache->format);
|
|
}
|
|
}
|
|
|
|
static int
|
|
exaGlyphCacheHashLookup(ExaGlyphCachePtr cache,
|
|
GlyphPtr pGlyph)
|
|
{
|
|
int slot;
|
|
|
|
slot = (*(CARD32 *) pGlyph->sha1) % cache->hashSize;
|
|
|
|
while (TRUE) { /* hash table can never be full */
|
|
int entryPos = cache->hashEntries[slot];
|
|
if (entryPos == -1)
|
|
return -1;
|
|
|
|
if (memcmp(pGlyph->sha1, cache->glyphs[entryPos].sha1, sizeof(pGlyph->sha1)) == 0){
|
|
return entryPos;
|
|
}
|
|
|
|
slot--;
|
|
if (slot < 0)
|
|
slot = cache->hashSize - 1;
|
|
}
|
|
}
|
|
|
|
static void
|
|
exaGlyphCacheHashInsert(ExaGlyphCachePtr cache,
|
|
GlyphPtr pGlyph,
|
|
int pos)
|
|
{
|
|
int slot;
|
|
|
|
memcpy(cache->glyphs[pos].sha1, pGlyph->sha1, sizeof(pGlyph->sha1));
|
|
|
|
slot = (*(CARD32 *) pGlyph->sha1) % cache->hashSize;
|
|
|
|
while (TRUE) { /* hash table can never be full */
|
|
if (cache->hashEntries[slot] == -1) {
|
|
cache->hashEntries[slot] = pos;
|
|
return;
|
|
}
|
|
|
|
slot--;
|
|
if (slot < 0)
|
|
slot = cache->hashSize - 1;
|
|
}
|
|
}
|
|
|
|
static void
|
|
exaGlyphCacheHashRemove(ExaGlyphCachePtr cache,
|
|
int pos)
|
|
{
|
|
int slot;
|
|
int emptiedSlot = -1;
|
|
|
|
slot = (*(CARD32 *) cache->glyphs[pos].sha1) % cache->hashSize;
|
|
|
|
while (TRUE) { /* hash table can never be full */
|
|
int entryPos = cache->hashEntries[slot];
|
|
|
|
if (entryPos == -1)
|
|
return;
|
|
|
|
if (entryPos == pos) {
|
|
cache->hashEntries[slot] = -1;
|
|
emptiedSlot = slot;
|
|
} else if (emptiedSlot != -1) {
|
|
/* See if we can move this entry into the emptied slot, we can't
|
|
* do that if if entry would have hashed between the current position
|
|
* and the emptied slot. (taking wrapping into account). Bad positions
|
|
* are:
|
|
*
|
|
* | XXXXXXXXXX |
|
|
* i j
|
|
*
|
|
* |XXX XXXX|
|
|
* j i
|
|
*
|
|
* i - slot, j - emptiedSlot
|
|
*
|
|
* (Knuth 6.4R)
|
|
*/
|
|
|
|
int entrySlot = (*(CARD32 *) cache->glyphs[entryPos].sha1) % cache->hashSize;
|
|
|
|
if (!((entrySlot >= slot && entrySlot < emptiedSlot) ||
|
|
(emptiedSlot < slot && (entrySlot < emptiedSlot || entrySlot >= slot))))
|
|
{
|
|
cache->hashEntries[emptiedSlot] = entryPos;
|
|
cache->hashEntries[slot] = -1;
|
|
emptiedSlot = slot;
|
|
}
|
|
}
|
|
|
|
slot--;
|
|
if (slot < 0)
|
|
slot = cache->hashSize - 1;
|
|
}
|
|
}
|
|
|
|
#define CACHE_X(pos) (((pos) % cache->columns) * cache->glyphWidth)
|
|
#define CACHE_Y(pos) (cache->yOffset + ((pos) / cache->columns) * cache->glyphHeight)
|
|
|
|
/* The most efficient thing to way to upload the glyph to the screen
|
|
* is to use the UploadToScreen() driver hook; this allows us to
|
|
* pipeline glyph uploads and to avoid creating offscreen pixmaps for
|
|
* glyphs that we'll never use again.
|
|
*/
|
|
static Bool
|
|
exaGlyphCacheUploadGlyph(ScreenPtr pScreen,
|
|
ExaGlyphCachePtr cache,
|
|
int pos,
|
|
GlyphPtr pGlyph)
|
|
{
|
|
ExaScreenPriv(pScreen);
|
|
PicturePtr pGlyphPicture = GlyphPicture(pGlyph)[pScreen->myNum];
|
|
PixmapPtr pGlyphPixmap = (PixmapPtr)pGlyphPicture->pDrawable;
|
|
ExaPixmapPriv(pGlyphPixmap);
|
|
PixmapPtr pCachePixmap = (PixmapPtr)cache->picture->pDrawable;
|
|
ExaMigrationRec pixmaps[1];
|
|
|
|
if (!pExaScr->info->UploadToScreen || pExaScr->swappedOut || pExaPixmap->accel_blocked)
|
|
return FALSE;
|
|
|
|
/* If the glyph pixmap is already uploaded, no point in doing
|
|
* things this way */
|
|
if (exaPixmapIsOffscreen(pGlyphPixmap))
|
|
return FALSE;
|
|
|
|
/* UploadToScreen only works if bpp match */
|
|
if (pGlyphPixmap->drawable.bitsPerPixel != pCachePixmap->drawable.bitsPerPixel)
|
|
return FALSE;
|
|
|
|
/* cache pixmap must be offscreen. */
|
|
pixmaps[0].as_dst = TRUE;
|
|
pixmaps[0].as_src = FALSE;
|
|
pixmaps[0].pPix = pCachePixmap;
|
|
pixmaps[0].pReg = NULL;
|
|
exaDoMigration (pixmaps, 1, TRUE);
|
|
|
|
if (!exaPixmapIsOffscreen(pCachePixmap))
|
|
return FALSE;
|
|
|
|
/* CACHE_{X,Y} are in pixmap coordinates, no need for cache{X,Y}off */
|
|
if (!pExaScr->info->UploadToScreen(pCachePixmap,
|
|
CACHE_X(pos),
|
|
CACHE_Y(pos),
|
|
pGlyph->info.width,
|
|
pGlyph->info.height,
|
|
(char *)pExaPixmap->sys_ptr,
|
|
pExaPixmap->sys_pitch))
|
|
return FALSE;
|
|
|
|
/* This pixmap should never be bound to a window, so no need to offset coordinates. */
|
|
exaPixmapDirty (pCachePixmap,
|
|
CACHE_X(pos),
|
|
CACHE_Y(pos),
|
|
CACHE_X(pos) + pGlyph->info.width,
|
|
CACHE_Y(pos) + pGlyph->info.height);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static ExaGlyphCacheResult
|
|
exaGlyphCacheBufferGlyph(ScreenPtr pScreen,
|
|
ExaGlyphCachePtr cache,
|
|
ExaGlyphBufferPtr buffer,
|
|
GlyphPtr pGlyph,
|
|
PicturePtr pSrc,
|
|
PicturePtr pDst,
|
|
INT16 xSrc,
|
|
INT16 ySrc,
|
|
INT16 xMask,
|
|
INT16 yMask,
|
|
INT16 xDst,
|
|
INT16 yDst)
|
|
{
|
|
ExaCompositeRectPtr rect;
|
|
int pos;
|
|
|
|
if (buffer->mask && buffer->mask != cache->picture)
|
|
return ExaGlyphNeedFlush;
|
|
|
|
if (!cache->picture) {
|
|
if (!exaRealizeGlyphCaches(pScreen, cache->format))
|
|
return ExaGlyphFail;
|
|
}
|
|
|
|
DBG_GLYPH_CACHE(("(%d,%d,%s): buffering glyph %lx\n",
|
|
cache->glyphWidth, cache->glyphHeight, cache->format == PICT_a8 ? "A" : "ARGB",
|
|
(long)*(CARD32 *) pGlyph->sha1));
|
|
|
|
pos = exaGlyphCacheHashLookup(cache, pGlyph);
|
|
if (pos != -1) {
|
|
DBG_GLYPH_CACHE((" found existing glyph at %d\n", pos));
|
|
} else {
|
|
if (cache->glyphCount < cache->size) {
|
|
/* Space remaining; we fill from the start */
|
|
pos = cache->glyphCount;
|
|
cache->glyphCount++;
|
|
DBG_GLYPH_CACHE((" storing glyph in free space at %d\n", pos));
|
|
|
|
exaGlyphCacheHashInsert(cache, pGlyph, pos);
|
|
|
|
} else {
|
|
/* Need to evict an entry. We have to see if any glyphs
|
|
* already in the output buffer were at this position in
|
|
* the cache
|
|
*/
|
|
|
|
pos = cache->evictionPosition;
|
|
DBG_GLYPH_CACHE((" evicting glyph at %d\n", pos));
|
|
if (buffer->count) {
|
|
int x, y;
|
|
int i;
|
|
|
|
x = CACHE_X(pos);
|
|
y = CACHE_Y(pos);
|
|
|
|
for (i = 0; i < buffer->count; i++) {
|
|
if (pSrc ?
|
|
(buffer->rects[i].xMask == x && buffer->rects[i].yMask == y) :
|
|
(buffer->rects[i].xSrc == x && buffer->rects[i].ySrc == y)) {
|
|
DBG_GLYPH_CACHE((" must flush buffer\n"));
|
|
return ExaGlyphNeedFlush;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* OK, we're all set, swap in the new glyph */
|
|
exaGlyphCacheHashRemove(cache, pos);
|
|
exaGlyphCacheHashInsert(cache, pGlyph, pos);
|
|
|
|
/* And pick a new eviction position */
|
|
cache->evictionPosition = rand() % cache->size;
|
|
}
|
|
|
|
/* Now actually upload the glyph into the cache picture; if
|
|
* we can't do it with UploadToScreen (because the glyph is
|
|
* offscreen, etc), we fall back to CompositePicture.
|
|
*/
|
|
if (!exaGlyphCacheUploadGlyph(pScreen, cache, pos, pGlyph)) {
|
|
CompositePicture (PictOpSrc,
|
|
GlyphPicture(pGlyph)[pScreen->myNum],
|
|
None,
|
|
cache->picture,
|
|
0, 0,
|
|
0, 0,
|
|
CACHE_X(pos),
|
|
CACHE_Y(pos),
|
|
pGlyph->info.width,
|
|
pGlyph->info.height);
|
|
}
|
|
|
|
}
|
|
|
|
buffer->mask = cache->picture;
|
|
|
|
rect = &buffer->rects[buffer->count];
|
|
|
|
if (pSrc)
|
|
{
|
|
rect->xSrc = xSrc;
|
|
rect->ySrc = ySrc;
|
|
rect->xMask = CACHE_X(pos);
|
|
rect->yMask = CACHE_Y(pos);
|
|
}
|
|
else
|
|
{
|
|
rect->xSrc = CACHE_X(pos);
|
|
rect->ySrc = CACHE_Y(pos);
|
|
rect->xMask = 0;
|
|
rect->yMask = 0;
|
|
}
|
|
|
|
rect->pDst = pDst;
|
|
rect->xDst = xDst - pGlyph->info.x;
|
|
rect->yDst = yDst - pGlyph->info.y;
|
|
rect->width = pGlyph->info.width;
|
|
rect->height = pGlyph->info.height;
|
|
|
|
buffer->count++;
|
|
|
|
return ExaGlyphSuccess;
|
|
}
|
|
|
|
#undef CACHE_X
|
|
#undef CACHE_Y
|
|
|
|
static ExaGlyphCacheResult
|
|
exaBufferGlyph(ScreenPtr pScreen,
|
|
ExaGlyphBufferPtr buffer,
|
|
GlyphPtr pGlyph,
|
|
PicturePtr pSrc,
|
|
PicturePtr pDst,
|
|
INT16 xSrc,
|
|
INT16 ySrc,
|
|
INT16 xMask,
|
|
INT16 yMask,
|
|
INT16 xDst,
|
|
INT16 yDst)
|
|
{
|
|
ExaScreenPriv(pScreen);
|
|
unsigned int format = (GlyphPicture(pGlyph)[pScreen->myNum])->format;
|
|
int width = pGlyph->info.width;
|
|
int height = pGlyph->info.height;
|
|
ExaCompositeRectPtr rect;
|
|
PicturePtr mask;
|
|
int i;
|
|
|
|
if (buffer->count == GLYPH_BUFFER_SIZE)
|
|
return ExaGlyphNeedFlush;
|
|
|
|
if (PICT_FORMAT_BPP(format) == 1)
|
|
format = PICT_a8;
|
|
|
|
for (i = 0; i < EXA_NUM_GLYPH_CACHES; i++) {
|
|
ExaGlyphCachePtr cache = &pExaScr->glyphCaches[i];
|
|
|
|
if (format == cache->format &&
|
|
width <= cache->glyphWidth &&
|
|
height <= cache->glyphHeight) {
|
|
ExaGlyphCacheResult result = exaGlyphCacheBufferGlyph(pScreen,
|
|
&pExaScr->glyphCaches[i],
|
|
buffer,
|
|
pGlyph,
|
|
pSrc,
|
|
pDst,
|
|
xSrc, ySrc,
|
|
xMask, yMask,
|
|
xDst, yDst);
|
|
switch (result) {
|
|
case ExaGlyphFail:
|
|
break;
|
|
case ExaGlyphSuccess:
|
|
case ExaGlyphNeedFlush:
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Couldn't find the glyph in the cache, use the glyph picture directly */
|
|
|
|
mask = GlyphPicture(pGlyph)[pScreen->myNum];
|
|
if (buffer->mask && buffer->mask != mask)
|
|
return ExaGlyphNeedFlush;
|
|
|
|
buffer->mask = mask;
|
|
|
|
rect = &buffer->rects[buffer->count];
|
|
rect->xSrc = xSrc;
|
|
rect->ySrc = ySrc;
|
|
rect->xMask = xMask;
|
|
rect->yMask = yMask;
|
|
rect->xDst = xDst - pGlyph->info.x;
|
|
rect->yDst = yDst - pGlyph->info.y;
|
|
rect->width = width;
|
|
rect->height = height;
|
|
|
|
buffer->count++;
|
|
|
|
return ExaGlyphSuccess;
|
|
}
|
|
|
|
static void
|
|
exaGlyphsToMask(PicturePtr pMask,
|
|
ExaGlyphBufferPtr buffer)
|
|
{
|
|
exaCompositeRects(PictOpAdd, buffer->mask, NULL, pMask,
|
|
buffer->count, buffer->rects);
|
|
|
|
buffer->count = 0;
|
|
buffer->mask = NULL;
|
|
}
|
|
|
|
static void
|
|
exaGlyphsToDst(PicturePtr pSrc,
|
|
PicturePtr pDst,
|
|
ExaGlyphBufferPtr buffer)
|
|
{
|
|
exaCompositeRects(PictOpOver, pSrc, buffer->mask, pDst, buffer->count,
|
|
buffer->rects);
|
|
|
|
buffer->count = 0;
|
|
buffer->mask = NULL;
|
|
}
|
|
|
|
/* Cut and paste from render/glyph.c - probably should export it instead */
|
|
static void
|
|
GlyphExtents (int nlist,
|
|
GlyphListPtr list,
|
|
GlyphPtr *glyphs,
|
|
BoxPtr extents)
|
|
{
|
|
int x1, x2, y1, y2;
|
|
int n;
|
|
GlyphPtr glyph;
|
|
int x, y;
|
|
|
|
x = 0;
|
|
y = 0;
|
|
extents->x1 = MAXSHORT;
|
|
extents->x2 = MINSHORT;
|
|
extents->y1 = MAXSHORT;
|
|
extents->y2 = MINSHORT;
|
|
while (nlist--)
|
|
{
|
|
x += list->xOff;
|
|
y += list->yOff;
|
|
n = list->len;
|
|
list++;
|
|
while (n--)
|
|
{
|
|
glyph = *glyphs++;
|
|
x1 = x - glyph->info.x;
|
|
if (x1 < MINSHORT)
|
|
x1 = MINSHORT;
|
|
y1 = y - glyph->info.y;
|
|
if (y1 < MINSHORT)
|
|
y1 = MINSHORT;
|
|
x2 = x1 + glyph->info.width;
|
|
if (x2 > MAXSHORT)
|
|
x2 = MAXSHORT;
|
|
y2 = y1 + glyph->info.height;
|
|
if (y2 > MAXSHORT)
|
|
y2 = MAXSHORT;
|
|
if (x1 < extents->x1)
|
|
extents->x1 = x1;
|
|
if (x2 > extents->x2)
|
|
extents->x2 = x2;
|
|
if (y1 < extents->y1)
|
|
extents->y1 = y1;
|
|
if (y2 > extents->y2)
|
|
extents->y2 = y2;
|
|
x += glyph->info.xOff;
|
|
y += glyph->info.yOff;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
exaGlyphs (CARD8 op,
|
|
PicturePtr pSrc,
|
|
PicturePtr pDst,
|
|
PictFormatPtr maskFormat,
|
|
INT16 xSrc,
|
|
INT16 ySrc,
|
|
int nlist,
|
|
GlyphListPtr list,
|
|
GlyphPtr *glyphs)
|
|
{
|
|
PicturePtr pPicture;
|
|
PixmapPtr pMaskPixmap = 0;
|
|
PicturePtr pMask = NULL;
|
|
ScreenPtr pScreen = pDst->pDrawable->pScreen;
|
|
int width = 0, height = 0;
|
|
int x, y;
|
|
int xDst = list->xOff, yDst = list->yOff;
|
|
int n;
|
|
GlyphPtr glyph;
|
|
int error;
|
|
BoxRec extents = {0, 0, 0, 0};
|
|
CARD32 component_alpha;
|
|
ExaGlyphBuffer buffer;
|
|
|
|
if (maskFormat)
|
|
{
|
|
GCPtr pGC;
|
|
xRectangle rect;
|
|
|
|
GlyphExtents (nlist, list, glyphs, &extents);
|
|
|
|
if (extents.x2 <= extents.x1 || extents.y2 <= extents.y1)
|
|
return;
|
|
width = extents.x2 - extents.x1;
|
|
height = extents.y2 - extents.y1;
|
|
|
|
if (maskFormat->depth == 1) {
|
|
PictFormatPtr a8Format = PictureMatchFormat (pScreen, 8, PICT_a8);
|
|
|
|
if (a8Format)
|
|
maskFormat = a8Format;
|
|
}
|
|
|
|
pMaskPixmap = (*pScreen->CreatePixmap) (pScreen, width, height,
|
|
maskFormat->depth,
|
|
CREATE_PIXMAP_USAGE_SCRATCH);
|
|
if (!pMaskPixmap)
|
|
return;
|
|
component_alpha = NeedsComponent(maskFormat->format);
|
|
pMask = CreatePicture (0, &pMaskPixmap->drawable,
|
|
maskFormat, CPComponentAlpha, &component_alpha,
|
|
serverClient, &error);
|
|
if (!pMask)
|
|
{
|
|
(*pScreen->DestroyPixmap) (pMaskPixmap);
|
|
return;
|
|
}
|
|
pGC = GetScratchGC (pMaskPixmap->drawable.depth, pScreen);
|
|
ValidateGC (&pMaskPixmap->drawable, pGC);
|
|
rect.x = 0;
|
|
rect.y = 0;
|
|
rect.width = width;
|
|
rect.height = height;
|
|
(*pGC->ops->PolyFillRect) (&pMaskPixmap->drawable, pGC, 1, &rect);
|
|
FreeScratchGC (pGC);
|
|
x = -extents.x1;
|
|
y = -extents.y1;
|
|
}
|
|
else
|
|
{
|
|
x = 0;
|
|
y = 0;
|
|
}
|
|
buffer.count = 0;
|
|
buffer.mask = NULL;
|
|
while (nlist--)
|
|
{
|
|
x += list->xOff;
|
|
y += list->yOff;
|
|
n = list->len;
|
|
while (n--)
|
|
{
|
|
glyph = *glyphs++;
|
|
pPicture = GlyphPicture (glyph)[pScreen->myNum];
|
|
|
|
if (glyph->info.width > 0 && glyph->info.height > 0)
|
|
{
|
|
if (maskFormat)
|
|
{
|
|
if (exaBufferGlyph(pScreen, &buffer, glyph, NULL, pMask,
|
|
0, 0, 0, 0, x, y) == ExaGlyphNeedFlush)
|
|
{
|
|
exaGlyphsToMask(pMask, &buffer);
|
|
exaBufferGlyph(pScreen, &buffer, glyph, NULL, pMask,
|
|
0, 0, 0, 0, x, y);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (exaBufferGlyph(pScreen, &buffer, glyph, pSrc, pDst,
|
|
xSrc + x - xDst, ySrc + y - yDst,
|
|
x, y, x + extents.x1, y + extents.y1)
|
|
== ExaGlyphNeedFlush)
|
|
{
|
|
exaGlyphsToDst(pSrc, pDst, &buffer);
|
|
exaBufferGlyph(pScreen, &buffer, glyph, pSrc, pDst,
|
|
xSrc + x - xDst, ySrc + y - yDst,
|
|
x, y, x + extents.x1, y + extents.y1);
|
|
}
|
|
}
|
|
}
|
|
|
|
x += glyph->info.xOff;
|
|
y += glyph->info.yOff;
|
|
}
|
|
list++;
|
|
}
|
|
|
|
if (buffer.count) {
|
|
if (maskFormat)
|
|
exaGlyphsToMask(pMask, &buffer);
|
|
else
|
|
exaGlyphsToDst(pSrc, pDst, &buffer);
|
|
}
|
|
|
|
if (maskFormat)
|
|
{
|
|
x = extents.x1;
|
|
y = extents.y1;
|
|
CompositePicture (op,
|
|
pSrc,
|
|
pMask,
|
|
pDst,
|
|
xSrc + x - xDst,
|
|
ySrc + y - yDst,
|
|
0, 0,
|
|
x, y,
|
|
width, height);
|
|
FreePicture ((pointer) pMask, (XID) 0);
|
|
(*pScreen->DestroyPixmap) (pMaskPixmap);
|
|
}
|
|
}
|