path: root/glamor/glamor_glyphs.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
 */

#include <stdlib.h>

#include "glamor_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.
 */

/* Maximum number of glyphs we buffer on the stack before flushing
 * rendering to the mask or destination surface.
 */
#define GLYPH_BUFFER_SIZE 1024

#define CACHE_PICTURE_SIZE 1024
#define GLYPH_MIN_SIZE 8
#define GLYPH_MAX_SIZE	64
#define GLYPH_CACHE_SIZE ((CACHE_PICTURE_SIZE) * CACHE_PICTURE_SIZE / (GLYPH_MIN_SIZE * GLYPH_MIN_SIZE))
#define MASK_CACHE_MAX_SIZE 32
#define MASK_CACHE_WIDTH (CACHE_PICTURE_SIZE / MASK_CACHE_MAX_SIZE)
#define MASK_CACHE_MASK ((1LL << (MASK_CACHE_WIDTH)) - 1)

typedef struct {
    PicturePtr source;
    glamor_composite_rect_t rects[GLYPH_BUFFER_SIZE + 4];
    int count;
} glamor_glyph_buffer_t;

struct glamor_glyph {
    glamor_glyph_cache_t *cache;
    uint16_t x, y;
    uint16_t size, pos;
    unsigned long long left_x1_map, left_x2_map;
    unsigned long long right_x1_map, right_x2_map;      /* Use to check real intersect or not. */
    Bool has_edge_map;
    Bool cached;
};

typedef enum {
    GLAMOR_GLYPH_SUCCESS,       /* Glyph added to render buffer */
    GLAMOR_GLYPH_FAIL,          /* out of memory, etc */
    GLAMOR_GLYPH_NEED_FLUSH,    /* would evict a glyph already in the buffer */
} glamor_glyph_cache_result_t;

#define NeedsComponent(f) (PICT_FORMAT_A(f) != 0 && PICT_FORMAT_RGB(f) != 0)
static DevPrivateKeyRec glamor_glyph_key;

static inline struct glamor_glyph *
glamor_glyph_get_private(GlyphPtr glyph)
{
    return (struct glamor_glyph *) glyph->devPrivates;
}

/*
 * Mask cache is located at the corresponding cache picture's last row.
 * and is deadicated for the mask picture when do the glyphs_via_mask.
 *
 * As we split the glyphs list according to its overlapped or non-overlapped,
 * we can reduce the length of glyphs to do the glyphs_via_mask to 2 or 3
 * glyphs one time for most cases. Thus it give us a case to allocate a
 * small portion of the corresponding cache directly as the mask picture.
 * Then we can rendering the glyphs to this mask picture, and latter we
 * can accumulate the second steps, composite the mask to the dest with
 * the other non-overlapped glyphs's rendering process.
 * Another major benefit is we now only need to clear a relatively small mask
 * region then before. It also make us implement a bunch mask picture clearing
 * algorithm to avoid too frequently small region clearing.
 *
 * If there is no any overlapping, this method will not get performance gain.
 * If there is some overlapping, then this algorithm can get about 15% performance
 * gain.
 */

struct glamor_glyph_mask_cache_entry {
    int idx;
    int width;
    int height;
    int x;
    int y;
};

static struct glamor_glyph_mask_cache {
    PixmapPtr pixmap;
    struct glamor_glyph_mask_cache_entry mcache[MASK_CACHE_WIDTH];
    unsigned int free_bitmap;
    unsigned int cleared_bitmap;
} *mask_cache[GLAMOR_NUM_GLYPH_CACHE_FORMATS] = {
NULL};

static void
clear_mask_cache_bitmap(struct glamor_glyph_mask_cache *maskcache,
                        unsigned int clear_mask_bits)
{
    unsigned int i = 0;
    BoxRec box[MASK_CACHE_WIDTH];
    int box_cnt = 0;

    assert((clear_mask_bits & ~MASK_CACHE_MASK) == 0);
    for (i = 0; i < MASK_CACHE_WIDTH; i++) {
        if (clear_mask_bits & (1 << i)) {
            box[box_cnt].x1 = maskcache->mcache[i].x;
            box[box_cnt].x2 = maskcache->mcache[i].x + MASK_CACHE_MAX_SIZE;
            box[box_cnt].y1 = maskcache->mcache[i].y;
            box[box_cnt].y2 = maskcache->mcache[i].y + MASK_CACHE_MAX_SIZE;
            box_cnt++;
        }
    }
    glamor_solid_boxes(maskcache->pixmap, box, box_cnt, 0);
    maskcache->cleared_bitmap |= clear_mask_bits;
}

static void
clear_mask_cache(struct glamor_glyph_mask_cache *maskcache)
{
    int x = 0;
    int cnt = MASK_CACHE_WIDTH;
    unsigned int i = 0;
    struct glamor_glyph_mask_cache_entry *mce;

    glamor_solid(maskcache->pixmap, 0, CACHE_PICTURE_SIZE, CACHE_PICTURE_SIZE,
                 MASK_CACHE_MAX_SIZE, GXcopy, 0xFFFFFFFF, 0);
    mce = &maskcache->mcache[0];
    while (cnt--) {
        mce->width = 0;
        mce->height = 0;
        mce->x = x;
        mce->y = CACHE_PICTURE_SIZE;
        mce->idx = i++;
        x += MASK_CACHE_MAX_SIZE;
        mce++;
    }
    maskcache->free_bitmap = MASK_CACHE_MASK;
    maskcache->cleared_bitmap = MASK_CACHE_MASK;
}

static int
find_continuous_bits(unsigned int bits, int bits_cnt, unsigned int *pbits_mask)
{
    int idx = 0;
    unsigned int bits_mask;

    bits_mask = ((1LL << bits_cnt) - 1);

    if (_X_UNLIKELY(bits_cnt > 56)) {
        while (bits) {
            if ((bits & bits_mask) == bits_mask) {
                *pbits_mask = bits_mask << idx;
                return idx;
            }
            bits >>= 1;
            idx++;
        }
    }
    else {
        idx = __fls(bits);
        while (bits) {
            unsigned int temp_bits;

            temp_bits = bits_mask << (idx - bits_cnt + 1);
            if ((bits & temp_bits) == temp_bits) {
                *pbits_mask = temp_bits;
                return (idx - bits_cnt + 1);
            }
            /* Find first zero. And clear the tested bit. */
            bits &= ~(1LL << idx);
            idx = __fls(~bits);
            bits &= ~((1LL << idx) - 1);
            idx--;
        }
    }
    return -1;
}

static struct glamor_glyph_mask_cache_entry *
get_mask_cache(struct glamor_glyph_mask_cache *maskcache, int blocks)
{
    int free_cleared_bit, idx = -1;
    int retry_cnt = 0;
    unsigned int bits_mask = 0;

    if (maskcache->free_bitmap == 0)
        return NULL;
 retry:
    free_cleared_bit = maskcache->free_bitmap & maskcache->cleared_bitmap;
    if (free_cleared_bit && blocks == 1) {
        idx = __fls(free_cleared_bit);
        bits_mask = 1 << idx;
    }
    else if (free_cleared_bit && blocks > 1) {
        idx = find_continuous_bits(free_cleared_bit, blocks, &bits_mask);
    }

    if (idx < 0) {
        clear_mask_cache_bitmap(maskcache, maskcache->free_bitmap);
        if (retry_cnt++ > 2)
            return NULL;
        goto retry;
    }

    maskcache->cleared_bitmap &= ~bits_mask;
    maskcache->free_bitmap &= ~bits_mask;
    DEBUGF("get idx %d free %x clear %x \n",
           idx, maskcache->free_bitmap, maskcache->cleared_bitmap);
    return &maskcache->mcache[idx];
}

static void
put_mask_cache_bitmap(struct glamor_glyph_mask_cache *maskcache,
                      unsigned int bitmap)
{
    maskcache->free_bitmap |= bitmap;
    DEBUGF("put bitmap %x free %x clear %x \n",
           bitmap, maskcache->free_bitmap, maskcache->cleared_bitmap);
}

static void
glamor_unrealize_glyph_caches(ScreenPtr pScreen)
{
    glamor_screen_private *glamor = glamor_get_screen_private(pScreen);
    int i;

    if (!glamor->glyph_cache_initialized)
        return;

    for (i = 0; i < GLAMOR_NUM_GLYPH_CACHE_FORMATS; i++) {
        glamor_glyph_cache_t *cache = &glamor->glyphCaches[i];

        if (cache->picture)
            FreePicture(cache->picture, 0);

        if (cache->glyphs)
            free(cache->glyphs);

        if (mask_cache[i])
            free(mask_cache[i]);
    }
    glamor->glyph_cache_initialized = FALSE;
}

void
glamor_glyphs_fini(ScreenPtr pScreen)
{
    glamor_unrealize_glyph_caches(pScreen);
}

/* 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 source 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.
 */

Bool
glamor_realize_glyph_caches(ScreenPtr pScreen)
{
    glamor_screen_private *glamor = glamor_get_screen_private(pScreen);

    unsigned int formats[] = {
        PIXMAN_a8,
        PIXMAN_a8r8g8b8,
    };
    int i;

    memset(glamor->glyphCaches, 0, sizeof(glamor->glyphCaches));

    for (i = 0; i < sizeof(formats) / sizeof(formats[0]); i++) {
        glamor_glyph_cache_t *cache = &glamor->glyphCaches[i];
        PixmapPtr pixmap;
        PicturePtr picture;
        XID component_alpha;
        int depth = PIXMAN_FORMAT_DEPTH(formats[i]);
        int error;
        PictFormatPtr pPictFormat =
            PictureMatchFormat(pScreen, depth, formats[i]);
        if (!pPictFormat)
            goto bail;

        /* Now allocate the pixmap and picture */
        pixmap = pScreen->CreatePixmap(pScreen,
                                       CACHE_PICTURE_SIZE,
                                       CACHE_PICTURE_SIZE + MASK_CACHE_MAX_SIZE,
                                       depth, 0);
        if (!pixmap)
            goto bail;

        component_alpha = NeedsComponent(pPictFormat->format);
        picture = CreatePicture(0, &pixmap->drawable, pPictFormat,
                                CPComponentAlpha, &component_alpha,
                                serverClient, &error);

        pScreen->DestroyPixmap(pixmap);
        if (!picture)
            goto bail;

        ValidatePicture(picture);

        cache->picture = picture;
        cache->glyphs = calloc(sizeof(GlyphPtr), GLYPH_CACHE_SIZE);
        if (!cache->glyphs)
            goto bail;

        cache->evict = rand() % GLYPH_CACHE_SIZE;
        mask_cache[i] = calloc(1, sizeof(*mask_cache[i]));
        mask_cache[i]->pixmap = pixmap;
        clear_mask_cache(mask_cache[i]);
    }
    assert(i == GLAMOR_NUM_GLYPH_CACHE_FORMATS);

    return TRUE;

 bail:
    glamor_unrealize_glyph_caches(pScreen);
    return FALSE;
}

/**
 * Called by glamor_create_screen_resources() to set up the glyph cache.
 *
 * This was previously required to be called by the drivers, but not
 * as of the xserver 1.16 ABI.
 */
Bool
glamor_glyphs_init(ScreenPtr pScreen)
{
    glamor_screen_private *glamor = glamor_get_screen_private(pScreen);

    if (glamor->glyph_cache_initialized)
        return TRUE;

    if (!dixRegisterPrivateKey(&glamor_glyph_key,
                               PRIVATE_GLYPH, sizeof(struct glamor_glyph)))
        return FALSE;

    glamor->glyph_cache_initialized = TRUE;

    return TRUE;
}

/* The most efficient thing to way to upload the glyph to the screen
 * is to use CopyArea; glamor pixmaps are always offscreen.
 */
static void
glamor_glyph_cache_upload_glyph(ScreenPtr screen,
                                glamor_glyph_cache_t *cache,
                                GlyphPtr glyph, int x, int y)
{
    PicturePtr pGlyphPicture = GlyphPicture(glyph)[screen->myNum];
    PixmapPtr pGlyphPixmap = (PixmapPtr) pGlyphPicture->pDrawable;
    PixmapPtr pCachePixmap = (PixmapPtr) cache->picture->pDrawable;
    PixmapPtr scratch;
    BoxRec box;
    GCPtr gc;

    gc = GetScratchGC(pCachePixmap->drawable.depth, screen);
    if (!gc)
        return;

    ValidateGC(&pCachePixmap->drawable, gc);

    scratch = pGlyphPixmap;
    if (pGlyphPixmap->drawable.depth != pCachePixmap->drawable.depth) {

        scratch = glamor_create_pixmap(screen,
                                       glyph->info.width,
                                       glyph->info.height,
                                       pCachePixmap->drawable.depth, 0);
        if (scratch) {
            PicturePtr picture;
            int error;

            picture =
                CreatePicture(0,
                              &scratch->drawable,
                              PictureMatchFormat
                              (screen,
                               pCachePixmap->drawable.depth,
                               cache->picture->format),
                              0, NULL, serverClient, &error);
            if (picture) {
                ValidatePicture(picture);
                glamor_composite(PictOpSrc,
                                 pGlyphPicture,
                                 NULL, picture,
                                 0, 0, 0, 0, 0,
                                 0, glyph->info.width, glyph->info.height);
                FreePicture(picture, 0);
            }
        }
        else {
            scratch = pGlyphPixmap;
        }
    }

    box.x1 = x;
    box.y1 = y;
    box.x2 = x + glyph->info.width;
    box.y2 = y + glyph->info.height;
    glamor_copy_n_to_n_nf(&scratch->drawable,
                          &pCachePixmap->drawable, NULL,
                          &box, 1, -x, -y, FALSE, FALSE, 0, NULL);
    if (scratch != pGlyphPixmap)
        screen->DestroyPixmap(scratch);

    FreeScratchGC(gc);
}

void
glamor_glyph_unrealize(ScreenPtr screen, GlyphPtr glyph)
{
    struct glamor_glyph *priv;

    /* Use Lookup in case we have not attached to this glyph. */
    priv = glamor_glyph_get_private(glyph);

    if (priv->cached)
        priv->cache->glyphs[priv->pos] = NULL;
}

/* Cut and paste from render/glyph.c - probably should export it instead */
static void
glamor_glyph_extents(int nlist,
                     GlyphListPtr list, GlyphPtr *glyphs, BoxPtr extents)
{
    int x1, x2, y1, y2;
    int x, y, n;

    x1 = y1 = MAXSHORT;
    x2 = y2 = MINSHORT;
    x = y = 0;
    while (nlist--) {
        x += list->xOff;
        y += list->yOff;
        n = list->len;
        list++;
        while (n--) {
            GlyphPtr glyph = *glyphs++;
            int v;

            v = x - glyph->info.x;
            if (v < x1)
                x1 = v;
            v += glyph->info.width;
            if (v > x2)
                x2 = v;

            v = y - glyph->info.y;
            if (v < y1)
                y1 = v;
            v += glyph->info.height;
            if (v > y2)
                y2 = v;

            x += glyph->info.xOff;
            y += glyph->info.yOff;
        }
    }

    extents->x1 = x1 < MINSHORT ? MINSHORT : x1;
    extents->x2 = x2 > MAXSHORT ? MAXSHORT : x2;
    extents->y1 = y1 < MINSHORT ? MINSHORT : y1;
    extents->y2 = y2 > MAXSHORT ? MAXSHORT : y2;
}

static void
glamor_glyph_priv_get_edge_map(GlyphPtr glyph, struct glamor_glyph *priv,
                               PicturePtr glyph_picture)
{
    PixmapPtr glyph_pixmap = (PixmapPtr) glyph_picture->pDrawable;
    int j;
    unsigned long long left_x1_map = 0, left_x2_map = 0;
    unsigned long long right_x1_map = 0, right_x2_map = 0;
    int bitsPerPixel;
    int stride;
    void *bits;
    int width;
    unsigned int left_x1_data = 0, left_x2_data = 0;
    unsigned int right_x1_data = 0, right_x2_data = 0;

    bitsPerPixel = glyph_pixmap->drawable.bitsPerPixel;
    stride = glyph_pixmap->devKind;
    bits = glyph_pixmap->devPrivate.ptr;
    width = glyph->info.width;

    if (glyph_pixmap->drawable.width < 2
        || !(glyph_pixmap->drawable.depth == 8
             || glyph_pixmap->drawable.depth == 1
             || glyph_pixmap->drawable.depth == 32)) {
        priv->has_edge_map = FALSE;
        return;
    }

    left_x1_map = left_x2_map = 0;
    right_x1_map = right_x2_map = 0;

    for (j = 0; j < glyph_pixmap->drawable.height; j++) {
        if (bitsPerPixel == 8) {
            unsigned char *data;

            data = (unsigned char *) ((unsigned char *) bits + stride * j);
            left_x1_data = *data++;
            left_x2_data = *data;
            data =
                (unsigned char *) ((unsigned char *) bits + stride * j + width -
                                   2);
            right_x1_data = *data++;
            right_x2_data = *data;
        }
        else if (bitsPerPixel == 32) {
            left_x1_data = *((unsigned int *) bits + stride / 4 * j);
            left_x2_data = *((unsigned int *) bits + stride / 4 * j + 1);
            right_x1_data =
                *((unsigned int *) bits + stride / 4 * j + width - 2);
            right_x2_data =
                *((unsigned int *) bits + stride / 4 * j + width - 1);
        }
        else if (bitsPerPixel == 1) {
            unsigned char temp;

            temp = *((unsigned char *) glyph_pixmap->devPrivate.ptr
                     + glyph_pixmap->devKind * j) & 0x3;
            left_x1_data = temp & 0x1;
            left_x2_data = temp & 0x2;

            temp = *((unsigned char *) glyph_pixmap->devPrivate.ptr
                     + glyph_pixmap->devKind * j
                     + (glyph_pixmap->drawable.width - 2) / 8);
            right_x1_data = temp
                & (1 << ((glyph_pixmap->drawable.width - 2) % 8));
            temp = *((unsigned char *) glyph_pixmap->devPrivate.ptr
                     + glyph_pixmap->devKind * j
                     + (glyph_pixmap->drawable.width - 1) / 8);
            right_x2_data = temp
                & (1 << ((glyph_pixmap->drawable.width - 1) % 8));
        }
        left_x1_map |= (left_x1_data != 0) << j;
        left_x2_map |= (left_x2_data != 0) << j;
        right_x1_map |= (right_x1_data != 0) << j;
        right_x2_map |= (right_x2_data != 0) << j;
    }

    priv->left_x1_map = left_x1_map;
    priv->left_x2_map = left_x2_map;
    priv->right_x1_map = right_x1_map;
    priv->right_x2_map = right_x2_map;
    priv->has_edge_map = TRUE;
    return;
}

/**
 * Returns TRUE if the glyphs in the lists intersect.  Only checks based on
 * bounding box, which appears to be good enough to catch most cases at least.
 */

#define INTERSECTED_TYPE_MASK 1
#define NON_INTERSECTED 0
#define INTERSECTED 1

struct glamor_glyph_list {
    int nlist;
    GlyphListPtr list;
    GlyphPtr *glyphs;
    int type;
};

static Bool
glyph_new_fixed_list(struct glamor_glyph_list *fixed_list,
                     GlyphPtr *cur_glyphs,
                     GlyphPtr ** head_glyphs,
                     GlyphListPtr cur_list,
                     int cur_pos, int cur_x, int cur_y,
                     int x1, int y1, int x2, int y2,
                     GlyphListPtr *head_list,
                     int *head_pos,
                     int *head_x,
                     int *head_y, int *fixed_cnt, int type, BoxPtr prev_extents)
{
    int x_off = 0;
    int y_off = 0;
    int n_off = 0;
    int list_cnt;

    if (type == NON_INTERSECTED) {
        if (x1 < prev_extents->x2 && x2 > prev_extents->x1
            && y1 < prev_extents->y2 && y2 > prev_extents->y1)
            return FALSE;
        x_off = (*(cur_glyphs - 1))->info.xOff;
        y_off = (*(cur_glyphs - 1))->info.yOff;
        n_off = 1;
    }

    list_cnt = cur_list - *head_list + 1;
    if (cur_pos <= n_off) {
        DEBUGF("break at %d n_off %d\n", cur_pos, n_off);
        list_cnt--;
        if (cur_pos < n_off) {
            /* we overlap with previous list's last glyph. */
            x_off += cur_list->xOff;
            y_off += cur_list->yOff;
            cur_list--;
            cur_pos = cur_list->len;
            if (cur_pos <= n_off) {
                list_cnt--;
            }
        }
    }
    DEBUGF("got %d lists\n", list_cnt);
    if (list_cnt != 0) {
        fixed_list->list = malloc(list_cnt * sizeof(*cur_list));
        memcpy(fixed_list->list, *head_list, list_cnt * sizeof(*cur_list));
        fixed_list->list[0].xOff = *head_x;
        fixed_list->list[0].yOff = *head_y;
        fixed_list->glyphs = *head_glyphs;
        fixed_list->type = type & INTERSECTED_TYPE_MASK;
        fixed_list->nlist = list_cnt;
        if (cur_list != *head_list) {
            fixed_list->list[0].len = (*head_list)->len - *head_pos;
            if (cur_pos != n_off)
                fixed_list->list[list_cnt - 1].len = cur_pos - n_off;
        }
        else
            fixed_list->list[0].len = cur_pos - *head_pos - n_off;
        (*fixed_cnt)++;
    }

    if (type <= INTERSECTED) {
        *head_list = cur_list;
        *head_pos = cur_pos - n_off;
        *head_x = cur_x - x_off;
        *head_y = cur_y - y_off;
        *head_glyphs = cur_glyphs - n_off;
    }
    return TRUE;
}

/*
 * This function detects glyph lists's overlapping.
 *
 * If check_fake_overlap is set, then it will check the glyph's left
 * and right small boxes's real overlapping pixels. And if there is
 * no real pixel overlapping, then it will not be treated as overlapped
 * case. And we also can configured it to ignore less than 2 pixels
 * overlappig.
 *
 * This function analyzes all the lists and split the list to multiple
 * lists which are pure overlapped glyph lists or pure non-overlapped
 * list if the overlapping only ocurr on the two adjacent glyphs.
 * Otherwise, it return -1.
 *
 **/

static int
glamor_glyphs_intersect(int nlist, GlyphListPtr list, GlyphPtr *glyphs,
                        PictFormatShort mask_format,
                        ScreenPtr screen, Bool check_fake_overlap,
                        struct glamor_glyph_list *fixed_list, int fixed_size)
{
    int x1, x2, y1, y2;
    int n;
    int x, y;
    BoxPtr extents;
    BoxRec prev_extents;
    Bool first = TRUE, first_list = TRUE;
    Bool need_free_list_region = FALSE;
    Bool need_free_fixed_list = FALSE;
    struct glamor_glyph *priv = NULL;
    Bool in_non_intersected_list = -1;
    GlyphListPtr head_list;
    int head_x, head_y, head_pos;
    int fixed_cnt = 0;
    GlyphPtr *head_glyphs;
    GlyphListPtr cur_list = list;
    RegionRec list_region;
    RegionRec current_region;
    BoxRec current_box;

    if (nlist > 1) {
        pixman_region_init(&list_region);
        need_free_list_region = TRUE;
    }

    pixman_region_init(&current_region);

    extents = pixman_region_extents(&current_region);

    x = 0;
    y = 0;
    x1 = x2 = y1 = y2 = 0;
    n = 0;
    extents->x1 = 0;
    extents->y1 = 0;
    extents->x2 = 0;
    extents->y2 = 0;

    head_list = list;
    DEBUGF("has %d lists.\n", nlist);
    while (nlist--) {
        BoxRec left_box, right_box = { 0 };
        Bool has_left_edge_box = FALSE, has_right_edge_box = FALSE;
        Bool left_to_right;
        struct glamor_glyph *left_priv = NULL, *right_priv = NULL;

        x += list->xOff;
        y += list->yOff;
        n = list->len;
        left_to_right = TRUE;
        cur_list = list++;

        if (_X_UNLIKELY(!first_list)) {
            pixman_region_init_with_extents(&current_region, extents);
            pixman_region_union(&list_region, &list_region, &current_region);
            first = TRUE;
        }
        else {
            head_list = cur_list;
            head_pos = cur_list->len - n;
            head_x = x;
            head_y = y;
            head_glyphs = glyphs;
        }

        DEBUGF("current list %p has %d glyphs\n", cur_list, n);
        while (n--) {
            GlyphPtr glyph = *glyphs++;

            DEBUGF("the %dth glyph\n", cur_list->len - n - 1);
            if (glyph->info.width == 0 || glyph->info.height == 0) {
                x += glyph->info.xOff;
                y += glyph->info.yOff;
                continue;
            }
            if (mask_format
                && mask_format != GlyphPicture(glyph)[screen->myNum]->format) {
                need_free_fixed_list = TRUE;
                goto done;
            }

            x1 = x - glyph->info.x;
            if (x1 < MINSHORT)
                x1 = MINSHORT;
            y1 = y - glyph->info.y;
            if (y1 < MINSHORT)
                y1 = MINSHORT;
            if (check_fake_overlap)
                priv = glamor_glyph_get_private(glyph);

            x2 = x1 + glyph->info.width;
            y2 = y1 + glyph->info.height;

            if (x2 > MAXSHORT)
                x2 = MAXSHORT;
            if (y2 > MAXSHORT)
                y2 = MAXSHORT;

            if (first) {
                extents->x1 = x1;
                extents->y1 = y1;
                extents->x2 = x2;
                extents->y2 = y2;

                prev_extents = *extents;

                first = FALSE;
                if (check_fake_overlap && priv
                    && priv->has_edge_map && glyph->info.yOff == 0) {
                    left_box.x1 = x1;
                    left_box.x2 = x1 + 1;
                    left_box.y1 = y1;

                    right_box.x1 = x2 - 2;
                    right_box.x2 = x2 - 1;
                    right_box.y1 = y1;
                    left_priv = right_priv = priv;
                    has_left_edge_box = TRUE;
                    has_right_edge_box = TRUE;
                }
            }
            else {
                if (_X_UNLIKELY(!first_list)) {
                    current_box.x1 = x1;
                    current_box.y1 = y1;
                    current_box.x2 = x2;
                    current_box.y2 = y2;
                    if (pixman_region_contains_rectangle
                        (&list_region, &current_box) != PIXMAN_REGION_OUT) {
                        need_free_fixed_list = TRUE;
                        goto done;
                    }
                }

                if (x1 < extents->x2 && x2 > extents->x1
                    && y1 < extents->y2 && y2 > extents->y1) {

                    if (check_fake_overlap &&
                        (has_left_edge_box || has_right_edge_box)
                        && priv->has_edge_map && glyph->info.yOff == 0) {
                        int left_dx, right_dx;
                        unsigned long long intersected;

                        left_dx = has_left_edge_box ? 1 : 0;
                        right_dx = has_right_edge_box ? 1 : 0;
                        if (x1 + 1 < extents->x2 - right_dx &&
                            x2 - 1 > extents->x1 + left_dx)
                            goto real_intersected;

                        if (left_to_right && has_right_edge_box) {
                            if (x1 == right_box.x1) {
                                intersected =
                                    ((priv->left_x1_map & right_priv->
                                      right_x1_map)
                                     | (priv->left_x2_map & right_priv->
                                        right_x2_map));
                                if (intersected)
                                    goto real_intersected;
                            }
                            else if (x1 == right_box.x2) {
                                intersected =
                                    (priv->left_x1_map & right_priv->
                                     right_x2_map);
                                if (intersected) {
#ifdef  GLYPHS_EDEGE_OVERLAP_LOOSE_CHECK
                                    /* tolerate with two pixels overlap. */
                                    intersected &= ~(1 << __fls(intersected));
                                    if ((intersected & (intersected - 1)))
#endif
                                        goto real_intersected;
                                }
                            }
                        }
                        else if (!left_to_right && has_left_edge_box) {
                            if (x2 - 1 == left_box.x1) {
                                intersected =
                                    (priv->right_x2_map & left_priv->
                                     left_x1_map);
                                if (intersected) {
#ifdef  GLYPHS_EDEGE_OVERLAP_LOOSE_CHECK
                                    /* tolerate with two pixels overlap. */
                                    intersected &= ~(1 << __fls(intersected));
                                    if ((intersected & (intersected - 1)))
#endif
                                        goto real_intersected;
                                }
                            }
                            else if (x2 - 1 == right_box.x2) {
                                if ((priv->right_x1_map & left_priv->
                                     left_x1_map)
                                    || (priv->right_x2_map & left_priv->
                                        left_x2_map))
                                    goto real_intersected;
                            }
                        }
                        else {
                            if (x1 < extents->x2 && x1 + 2 > extents->x1)
                                goto real_intersected;
                        }
                        goto non_intersected;
                    }
                    else {
 real_intersected:
                        DEBUGF("overlap with previous glyph.\n");
                        if (in_non_intersected_list == 1) {
                            if (fixed_cnt >= fixed_size) {
                                need_free_fixed_list = TRUE;
                                goto done;
                            }
                            if (!glyph_new_fixed_list(&fixed_list[fixed_cnt],
                                                      glyphs - 1,
                                                      &head_glyphs,
                                                      cur_list,
                                                      cur_list->len - (n + 1),
                                                      x, y, x1, y1, x2, y2,
                                                      &head_list, &head_pos,
                                                      &head_x, &head_y,
                                                      &fixed_cnt,
                                                      NON_INTERSECTED,
                                                      &prev_extents)) {
                                need_free_fixed_list = TRUE;
                                goto done;
                            }
                        }

                        in_non_intersected_list = 0;

                    }
                }
                else {
 non_intersected:
                    DEBUGF("doesn't overlap with previous glyph.\n");
                    if (in_non_intersected_list == 0) {
                        if (fixed_cnt >= fixed_size) {
                            need_free_fixed_list = TRUE;
                            goto done;
                        }
                        if (!glyph_new_fixed_list(&fixed_list[fixed_cnt],
                                                  glyphs - 1,
                                                  &head_glyphs,
                                                  cur_list,
                                                  cur_list->len - (n + 1), x, y,
                                                  x1, y1, x2, y2,
                                                  &head_list,
                                                  &head_pos,
                                                  &head_x,
                                                  &head_y, &fixed_cnt,
                                                  INTERSECTED, &prev_extents)) {
                            need_free_fixed_list = TRUE;
                            goto done;
                        }
                    }
                    in_non_intersected_list = 1;
                }
                prev_extents = *extents;
            }

            if (check_fake_overlap && priv
                && priv->has_edge_map && glyph->info.yOff == 0) {
                if (!has_left_edge_box || x1 < extents->x1) {
                    left_box.x1 = x1;
                    left_box.x2 = x1 + 1;
                    left_box.y1 = y1;
                    has_left_edge_box = TRUE;
                    left_priv = priv;
                }

                if (!has_right_edge_box || x2 > extents->x2) {
                    right_box.x1 = x2 - 2;
                    right_box.x2 = x2 - 1;
                    right_box.y1 = y1;
                    has_right_edge_box = TRUE;
                    right_priv = priv;
                }
            }

            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;
        }
        first_list = FALSE;
    }

    if (in_non_intersected_list == 0 && fixed_cnt == 0) {
        fixed_cnt = -1;
        goto done;
    }

    if ((in_non_intersected_list != -1 || head_pos != n) && (fixed_cnt > 0)) {
        if (fixed_cnt >= fixed_size) {
            need_free_fixed_list = TRUE;
            goto done;
        }
        if (!glyph_new_fixed_list(&fixed_list[fixed_cnt],
                                  glyphs - 1,
                                  &head_glyphs,
                                  cur_list,
                                  cur_list->len - (n + 1), x, y,
                                  x1, y1, x2, y2,
                                  &head_list,
                                  &head_pos,
                                  &head_x,
                                  &head_y, &fixed_cnt,
                                  (!in_non_intersected_list) | 0x80,
                                  &prev_extents)) {
            need_free_fixed_list = TRUE;
            goto done;
        }
    }

 done:
    if (need_free_list_region)
        pixman_region_fini(&list_region);
    pixman_region_fini(&current_region);

    if (need_free_fixed_list && fixed_cnt >= 0) {
        while (fixed_cnt--) {
            free(fixed_list[fixed_cnt].list);
        }
    }

    DEBUGF("Got %d fixed list \n", fixed_cnt);
    return fixed_cnt;
}

static inline unsigned int
glamor_glyph_size_to_count(int size)
{
    size /= GLYPH_MIN_SIZE;
    return size * size;
}

static inline unsigned int
glamor_glyph_count_to_mask(int count)
{
    return ~(count - 1);
}

static inline unsigned int
glamor_glyph_size_to_mask(int size)
{
    return glamor_glyph_count_to_mask(glamor_glyph_size_to_count(size));
}

static PicturePtr
glamor_glyph_cache(glamor_screen_private *glamor, GlyphPtr glyph, int *out_x,
                   int *out_y)
{
    ScreenPtr screen = glamor->screen;
    PicturePtr glyph_picture = GlyphPicture(glyph)[screen->myNum];
    glamor_glyph_cache_t *cache =
        &glamor->glyphCaches[PICT_FORMAT_RGB(glyph_picture->format) != 0];
    struct glamor_glyph *priv = NULL, *evicted_priv = NULL;
    int size, mask, pos, s;

    if (glyph->info.width > GLYPH_MAX_SIZE
        || glyph->info.height > GLYPH_MAX_SIZE)
        return NULL;

    for (size = GLYPH_MIN_SIZE; size <= GLYPH_MAX_SIZE; size *= 2)
        if (glyph->info.width <= size && glyph->info.height <= size)
            break;

    s = glamor_glyph_size_to_count(size);
    mask = glamor_glyph_count_to_mask(s);
    pos = (cache->count + s - 1) & mask;

    priv = glamor_glyph_get_private(glyph);
    if (pos < GLYPH_CACHE_SIZE) {
        cache->count = pos + s;
    }
    else {
        for (s = size; s <= GLYPH_MAX_SIZE; s *= 2) {
            int i = cache->evict & glamor_glyph_size_to_mask(s);
            GlyphPtr evicted = cache->glyphs[i];

            if (evicted == NULL)
                continue;

            evicted_priv = glamor_glyph_get_private(evicted);
            assert(evicted_priv->pos == i);
            if (evicted_priv->size >= s) {
                cache->glyphs[i] = NULL;
                evicted_priv->cached = FALSE;
                pos = cache->evict & glamor_glyph_size_to_mask(size);
            }
            else
                evicted_priv = NULL;
            break;
        }
        if (evicted_priv == NULL) {
            int count = glamor_glyph_size_to_count(size);

            mask = glamor_glyph_count_to_mask(count);
            pos = cache->evict & mask;
            for (s = 0; s < count; s++) {
                GlyphPtr evicted = cache->glyphs[pos + s];

                if (evicted != NULL) {

                    evicted_priv = glamor_glyph_get_private(evicted);

                    assert(evicted_priv->pos == pos + s);
                    evicted_priv->cached = FALSE;
                    cache->glyphs[pos + s] = NULL;
                }
            }

        }
        /* And pick a new eviction position */
        cache->evict = rand() % GLYPH_CACHE_SIZE;
    }

    cache->glyphs[pos] = glyph;

    priv->cache = cache;
    priv->size = size;
    priv->pos = pos;
    s = pos / ((GLYPH_MAX_SIZE / GLYPH_MIN_SIZE) *
               (GLYPH_MAX_SIZE / GLYPH_MIN_SIZE));
    priv->x = s % (CACHE_PICTURE_SIZE / GLYPH_MAX_SIZE) * GLYPH_MAX_SIZE;
    priv->y = (s / (CACHE_PICTURE_SIZE / GLYPH_MAX_SIZE)) * GLYPH_MAX_SIZE;
    for (s = GLYPH_MIN_SIZE; s < GLYPH_MAX_SIZE; s *= 2) {
        if (pos & 1)
            priv->x += s;
        if (pos & 2)
            priv->y += s;
        pos >>= 2;
    }

    glamor_glyph_cache_upload_glyph(screen, cache, glyph, priv->x, priv->y);
#ifndef GLYPHS_NO_EDEGEMAP_OVERLAP_CHECK
    if (priv->has_edge_map == FALSE && glyph->info.width >= 2)
        glamor_glyph_priv_get_edge_map(glyph, priv, glyph_picture);
#endif
    priv->cached = TRUE;

    *out_x = priv->x;
    *out_y = priv->y;
    return cache->picture;
}

typedef void (*glyphs_flush_func) (void *arg);
struct glyphs_flush_dst_arg {
    CARD8 op;
    PicturePtr src;
    PicturePtr dst;
    glamor_glyph_buffer_t *buffer;
    int x_src, y_src;
    int x_dst, y_dst;
};

static struct glyphs_flush_dst_arg dst_arg;
static struct glyphs_flush_mask_arg mask_arg;
static glamor_glyph_buffer_t dst_buffer;
static glamor_glyph_buffer_t mask_buffer;
unsigned long long mask_glyphs_cnt = 0;
unsigned long long dst_glyphs_cnt = 0;

#define GLYPHS_DST_MODE_VIA_MASK		0
#define GLYPHS_DST_MODE_VIA_MASK_CACHE		1
#define GLYPHS_DST_MODE_TO_DST			2
#define GLYPHS_DST_MODE_MASK_TO_DST		3

struct glyphs_flush_mask_arg {
    PicturePtr mask;
    glamor_glyph_buffer_t *buffer;
    struct glamor_glyph_mask_cache *maskcache;
    unsigned int used_bitmap;
};

static void
glamor_glyphs_flush_mask(struct glyphs_flush_mask_arg *arg)
{
    if (arg->buffer->count > 0) {
#ifdef RENDER
        glamor_composite_glyph_rects(PictOpAdd, arg->buffer->source,
                                     NULL, arg->mask,
                                     arg->buffer->count, arg->buffer->rects);
#endif
    }
    arg->buffer->count = 0;
    arg->buffer->source = NULL;

}

static void
glamor_glyphs_flush_dst(struct glyphs_flush_dst_arg *arg)
{
    if (!arg->buffer)
        return;

    if (mask_buffer.count > 0) {
        glamor_glyphs_flush_mask(&mask_arg);
    }
    if (mask_arg.used_bitmap) {
        put_mask_cache_bitmap(mask_arg.maskcache, mask_arg.used_bitmap);
        mask_arg.used_bitmap = 0;
    }

    if (arg->buffer->count > 0) {
        glamor_composite_glyph_rects(arg->op, arg->src,
                                     arg->buffer->source, arg->dst,
                                     arg->buffer->count,
                                     &arg->buffer->rects[0]);
        arg->buffer->count = 0;
        arg->buffer->source = NULL;
    }
}

static glamor_glyph_cache_result_t
glamor_buffer_glyph(glamor_screen_private *glamor_priv,
                    glamor_glyph_buffer_t *buffer,
                    PictFormatShort format,
                    GlyphPtr glyph, struct glamor_glyph *priv,
                    int x_glyph, int y_glyph,
                    int dx, int dy, int w, int h,
                    int glyphs_dst_mode,
                    glyphs_flush_func glyphs_flush, void *flush_arg)
{
    ScreenPtr screen = glamor_priv->screen;
    glamor_composite_rect_t *rect;
    PicturePtr source;
    int x, y;
    glamor_glyph_cache_t *cache;

    if (glyphs_dst_mode != GLYPHS_DST_MODE_MASK_TO_DST)
        priv = glamor_glyph_get_private(glyph);

    if (PICT_FORMAT_BPP(format) == 1)
        format = PICT_a8;

    cache = &glamor_priv->glyphCaches[PICT_FORMAT_RGB(format) != 0];

    if (buffer->source && buffer->source != cache->picture && glyphs_flush) {
        (*glyphs_flush) (flush_arg);
        glyphs_flush = NULL;
    }

    if (buffer->count == GLYPH_BUFFER_SIZE && glyphs_flush) {
        (*glyphs_flush) (flush_arg);
        glyphs_flush = NULL;
    }

    if (priv && priv->cached) {
        rect = &buffer->rects[buffer->count++];
        rect->x_src = priv->x + dx;
        rect->y_src = priv->y + dy;
        if (buffer->source == NULL)
            buffer->source = priv->cache->picture;
        if (glyphs_dst_mode <= GLYPHS_DST_MODE_VIA_MASK_CACHE)
            assert(priv->cache->glyphs[priv->pos] == glyph);
    }
    else {
        assert(glyphs_dst_mode != GLYPHS_DST_MODE_MASK_TO_DST);
        if (glyphs_flush)
            (*glyphs_flush) (flush_arg);
        source = glamor_glyph_cache(glamor_priv, glyph, &x, &y);

        if (source != NULL) {
            rect = &buffer->rects[buffer->count++];
            rect->x_src = x + dx;
            rect->y_src = y + dy;
            if (buffer->source == NULL)
                buffer->source = source;
            if (glyphs_dst_mode == GLYPHS_DST_MODE_VIA_MASK_CACHE) {
                /* mode 1 means we are using global mask cache,
                 * thus we have to composite from the cache picture
                 * to the cache picture, we need a flush here to make
                 * sure latter we get the corret glyphs data.*/
                glamor_get_context(glamor_priv);
                glFlush();
                glamor_put_context(glamor_priv);
            }
        }
        else {
            /* Couldn't find the glyph in the cache, use the glyph picture directly */
            source = GlyphPicture(glyph)[screen->myNum];
            if (buffer->source && buffer->source != source && glyphs_flush)
                (*glyphs_flush) (flush_arg);
            buffer->source = source;

            rect = &buffer->rects[buffer->count++];
            rect->x_src = 0 + dx;
            rect->y_src = 0 + dy;
        }
        priv = glamor_glyph_get_private(glyph);
    }

    rect->x_dst = x_glyph;
    rect->y_dst = y_glyph;
    if (glyphs_dst_mode != GLYPHS_DST_MODE_MASK_TO_DST) {
        rect->x_dst -= glyph->info.x;
        rect->y_dst -= glyph->info.y;
    }
    rect->width = w;
    rect->height = h;
    if (glyphs_dst_mode > GLYPHS_DST_MODE_VIA_MASK_CACHE) {
        rect->x_mask = rect->x_src;
        rect->y_mask = rect->y_src;
        rect->x_src = dst_arg.x_src + rect->x_dst - dst_arg.x_dst;
        rect->y_src = dst_arg.y_src + rect->y_dst - dst_arg.y_dst;
    }

    return GLAMOR_GLYPH_SUCCESS;
}

static void
glamor_buffer_glyph_clip(glamor_screen_private *glamor_priv,
                         BoxPtr rects,
                         int nrect, PictFormatShort format,
                         GlyphPtr glyph, struct glamor_glyph *priv,
                         int glyph_x, int glyph_y,
                         int glyph_dx, int glyph_dy,
                         int width, int height,
                         int glyphs_mode,
                         glyphs_flush_func flush_func, void *arg)
{
    int i;

    for (i = 0; i < nrect; i++) {
        int dst_x, dst_y;
        int dx, dy;
        int x2, y2;

        dst_x = glyph_x - glyph_dx;
        dst_y = glyph_y - glyph_dy;
        x2 = dst_x + width;
        y2 = dst_y + height;
        dx = dy = 0;
        if (rects[i].y1 >= y2)
            break;

        if (dst_x < rects[i].x1)
            dx = rects[i].x1 - dst_x, dst_x = rects[i].x1;
        if (x2 > rects[i].x2)
            x2 = rects[i].x2;
        if (dst_y < rects[i].y1)
            dy = rects[i].y1 - dst_y, dst_y = rects[i].y1;
        if (y2 > rects[i].y2)
            y2 = rects[i].y2;
        if (dst_x < x2 && dst_y < y2) {

            glamor_buffer_glyph(glamor_priv,
                                &dst_buffer,
                                format,
                                glyph, priv,
                                dst_x + glyph_dx,
                                dst_y + glyph_dy,
                                dx, dy,
                                x2 - dst_x, y2 - dst_y,
                                glyphs_mode, flush_func, arg);
        }
    }
}

static void
glamor_glyphs_via_mask(CARD8 op,
                       PicturePtr src,
                       PicturePtr dst,
                       PictFormatPtr mask_format,
                       INT16 x_src,
                       INT16 y_src,
                       int nlist, GlyphListPtr list, GlyphPtr *glyphs,
                       Bool use_mask_cache)
{
    PixmapPtr mask_pixmap = 0;
    PicturePtr mask;
    ScreenPtr screen = dst->pDrawable->pScreen;
    int width = 0, height = 0;
    int x, y;
    int x_dst = list->xOff, y_dst = list->yOff;
    int n;
    GlyphPtr glyph;
    int error;
    BoxRec extents = { 0, 0, 0, 0 };
    XID component_alpha;
    glamor_screen_private *glamor_priv;
    int need_free_mask = FALSE;
    glamor_glyph_buffer_t buffer;
    struct glyphs_flush_mask_arg arg;
    glamor_glyph_buffer_t *pmask_buffer;
    struct glyphs_flush_mask_arg *pmask_arg;
    struct glamor_glyph_mask_cache_entry *mce = NULL;
    struct glamor_glyph_mask_cache *maskcache;
    glamor_glyph_cache_t *cache;
    int glyphs_dst_mode;

    glamor_glyph_extents(nlist, list, glyphs, &extents);

    if (extents.x2 <= extents.x1 || extents.y2 <= extents.y1)
        return;
    glamor_priv = glamor_get_screen_private(screen);
    width = extents.x2 - extents.x1;
    height = extents.y2 - extents.y1;

    if (mask_format->depth == 1) {
        PictFormatPtr a8Format = PictureMatchFormat(screen, 8, PICT_a8);

        if (a8Format)
            mask_format = a8Format;
    }

    cache = &glamor_priv->glyphCaches
        [PICT_FORMAT_RGB(mask_format->format) != 0];
    maskcache = mask_cache[PICT_FORMAT_RGB(mask_format->format) != 0];

    x = -extents.x1;
    y = -extents.y1;
    if (!use_mask_cache || width > (CACHE_PICTURE_SIZE / 4)
        || height > MASK_CACHE_MAX_SIZE) {
 new_mask_pixmap:
        mask_pixmap = glamor_create_pixmap(screen, width, height,
                                           mask_format->depth,
                                           CREATE_PIXMAP_USAGE_SCRATCH);
        if (!mask_pixmap) {
            glamor_destroy_pixmap(mask_pixmap);
            return;
        }
        glamor_solid(mask_pixmap, 0, 0, width, height, GXcopy, 0xFFFFFFFF, 0);
        component_alpha = NeedsComponent(mask_format->format);
        mask = CreatePicture(0, &mask_pixmap->drawable,
                             mask_format, CPComponentAlpha,
                             &component_alpha, serverClient, &error);
        if (!mask)
            return;
        need_free_mask = TRUE;
        pmask_arg = &arg;
        pmask_buffer = &buffer;
        pmask_buffer->count = 0;
        pmask_buffer->source = NULL;
        pmask_arg->used_bitmap = 0;
        glyphs_dst_mode = GLYPHS_DST_MODE_VIA_MASK;
    }
    else {
        int retry_cnt = 0;

 retry:
        mce = get_mask_cache(maskcache,
                             (width + MASK_CACHE_MAX_SIZE -
                              1) / MASK_CACHE_MAX_SIZE);

        if (mce == NULL) {
            glamor_glyphs_flush_dst(&dst_arg);
            retry_cnt++;
            if (retry_cnt > 2) {
                assert(0);
                goto new_mask_pixmap;
            }
            goto retry;
        }

        mask = cache->picture;
        x += mce->x;
        y += mce->y;
        mce->width = (width + MASK_CACHE_MAX_SIZE - 1) / MASK_CACHE_MAX_SIZE;
        mce->height = 1;
        if (mask_arg.mask && mask_arg.mask != mask && mask_buffer.count != 0)
            glamor_glyphs_flush_dst(&dst_arg);
        pmask_arg = &mask_arg;
        pmask_buffer = &mask_buffer;
        pmask_arg->maskcache = maskcache;
        glyphs_dst_mode = GLYPHS_DST_MODE_VIA_MASK_CACHE;
    }
    pmask_arg->mask = mask;
    pmask_arg->buffer = pmask_buffer;
    while (nlist--) {
        x += list->xOff;
        y += list->yOff;
        n = list->len;
        mask_glyphs_cnt += n;
        while (n--) {
            glyph = *glyphs++;
            if (glyph->info.width > 0 && glyph->info.height > 0) {
                glyphs_flush_func flush_func;
                void *temp_arg;

                if (need_free_mask) {
                    if (pmask_buffer->count)
                        flush_func =
                            (glyphs_flush_func) glamor_glyphs_flush_mask;
                    else
                        flush_func = NULL;
                    temp_arg = pmask_arg;
                }
                else {
                    /* If we are using global mask cache, then we need to
                     * flush dst instead of mask. As some dst depends on the
                     * previous mask result. Just flush mask can't get all previous's
                     * overlapped glyphs.*/
                    if (dst_buffer.count || mask_buffer.count)
                        flush_func =
                            (glyphs_flush_func) glamor_glyphs_flush_dst;
                    else
                        flush_func = NULL;
                    temp_arg = &dst_arg;
                }
                glamor_buffer_glyph(glamor_priv, pmask_buffer,
                                    mask_format->format,
                                    glyph, NULL, x, y,
                                    0, 0,
                                    glyph->info.width, glyph->info.height,
                                    glyphs_dst_mode,
                                    flush_func, (void *) temp_arg);
            }
            x += glyph->info.xOff;
            y += glyph->info.yOff;
        }
        list++;
    }

    x = extents.x1;
    y = extents.y1;
    if (need_free_mask) {
        glamor_glyphs_flush_mask(pmask_arg);
        CompositePicture(op,
                         src,
                         mask,
                         dst,
                         x_src + x - x_dst,
                         y_src + y - y_dst, 0, 0, x, y, width, height);
        FreePicture(mask, 0);
        glamor_destroy_pixmap(mask_pixmap);
    }
    else {
        struct glamor_glyph priv;
        glyphs_flush_func flush_func;
        BoxPtr rects;
        int nrect;

        priv.cache = cache;
        priv.x = mce->x;
        priv.y = mce->y;
        priv.cached = TRUE;
        rects = REGION_RECTS(dst->pCompositeClip);
        nrect = REGION_NUM_RECTS(dst->pCompositeClip);

        pmask_arg->used_bitmap |= ((1 << mce->width) - 1) << mce->idx;
        dst_arg.op = op;
        dst_arg.src = src;
        dst_arg.dst = dst;
        dst_arg.buffer = &dst_buffer;
        dst_arg.x_src = x_src;
        dst_arg.y_src = y_src;
        dst_arg.x_dst = x_dst;
        dst_arg.y_dst = y_dst;

        if (dst_buffer.source == NULL) {
            dst_buffer.source = cache->picture;
        }
        else if (dst_buffer.source != cache->picture) {
            glamor_glyphs_flush_dst(&dst_arg);
            dst_buffer.source = cache->picture;
        }

        x += dst->pDrawable->x;
        y += dst->pDrawable->y;

        if (dst_buffer.count || mask_buffer.count)
            flush_func = (glyphs_flush_func) glamor_glyphs_flush_dst;
        else
            flush_func = NULL;

        glamor_buffer_glyph_clip(glamor_priv,
                                 rects, nrect,
                                 mask_format->format,
                                 NULL, &priv,
                                 x, y,
                                 0, 0,
                                 width, height,
                                 GLYPHS_DST_MODE_MASK_TO_DST,
                                 flush_func, (void *) &dst_arg);
    }
}

static void
glamor_glyphs_to_dst(CARD8 op,
                     PicturePtr src,
                     PicturePtr dst,
                     INT16 x_src,
                     INT16 y_src,
                     int nlist, GlyphListPtr list, GlyphPtr *glyphs)
{
    ScreenPtr screen = dst->pDrawable->pScreen;
    int x = 0, y = 0;
    int x_dst = list->xOff, y_dst = list->yOff;
    int n;
    GlyphPtr glyph;
    BoxPtr rects;
    int nrect;
    glamor_screen_private *glamor_priv;

    rects = REGION_RECTS(dst->pCompositeClip);
    nrect = REGION_NUM_RECTS(dst->pCompositeClip);

    glamor_priv = glamor_get_screen_private(screen);

    dst_arg.op = op;
    dst_arg.src = src;
    dst_arg.dst = dst;
    dst_arg.buffer = &dst_buffer;
    dst_arg.x_src = x_src;
    dst_arg.y_src = y_src;
    dst_arg.x_dst = x_dst;
    dst_arg.y_dst = y_dst;

    x = dst->pDrawable->x;
    y = dst->pDrawable->y;

    while (nlist--) {
        x += list->xOff;
        y += list->yOff;
        n = list->len;
        dst_glyphs_cnt += n;
        while (n--) {
            glyph = *glyphs++;

            if (glyph->info.width > 0 && glyph->info.height > 0) {
                glyphs_flush_func flush_func;

                if (dst_buffer.count || mask_buffer.count)
                    flush_func = (glyphs_flush_func) glamor_glyphs_flush_dst;
                else
                    flush_func = NULL;
                glamor_buffer_glyph_clip(glamor_priv,
                                         rects, nrect,
                                         (GlyphPicture(glyph)[screen->myNum])->
                                         format, glyph, NULL, x, y,
                                         glyph->info.x, glyph->info.y,
                                         glyph->info.width, glyph->info.height,
                                         GLYPHS_DST_MODE_TO_DST, flush_func,
                                         (void *) &dst_arg);
            }

            x += glyph->info.xOff;
            y += glyph->info.yOff;
        }
        list++;
    }
}

#define MAX_FIXED_SIZE
static void
glamor_glyphs_reset_buffer(glamor_glyph_buffer_t *buffer)
{
    buffer->count = 0;
    buffer->source = NULL;
}

static Bool
_glamor_glyphs(CARD8 op,
               PicturePtr src,
               PicturePtr dst,
               PictFormatPtr mask_format,
               INT16 x_src,
               INT16 y_src, int nlist, GlyphListPtr list,
               GlyphPtr *glyphs, Bool fallback)
{
    PictFormatShort format;
    int fixed_size, fixed_cnt = 0;
    struct glamor_glyph_list *fixed_list = NULL;
    Bool need_free_list = FALSE;

#ifndef GLYPHS_NO_EDEGEMAP_OVERLAP_CHECK
    Bool check_fake_overlap = TRUE;

    if (!(op == PictOpOver || op == PictOpAdd || op == PictOpXor)) {
        /* C = (0,0,0,0) D = glyphs , SRC = A, DEST = B (faked overlapped glyphs, overlapped with (0,0,0,0)).
         * For those op, (A IN (C ADD D)) OP B !=  (A IN D) OP ((A IN C) OP B)
         *              or (A IN (D ADD C)) OP B != (A IN C) OP ((A IN D) OP B)
         * We need to split the faked regions to three or two, and composite the disoverlapped small
         * boxes one by one. For other Ops, it's safe to composite the whole box.  */
        check_fake_overlap = FALSE;
    }
#else
    Bool check_fake_overlap = FALSE;
#endif
    if (mask_format)
        format = mask_format->depth << 24 | mask_format->format;
    else
        format = 0;

    fixed_size = 32;
    glamor_glyphs_reset_buffer(&dst_buffer);

    if (!mask_format || (((nlist == 1 && list->len == 1) || op == PictOpAdd)
                         && (dst->format ==
                             ((mask_format->depth << 24) | mask_format->
                              format)))) {
        glamor_glyphs_to_dst(op, src, dst, x_src, y_src, nlist, list, glyphs);
        goto last_flush;
    }

    glamor_glyphs_reset_buffer(&mask_buffer);

    /* We have mask_format. Need to check the real overlap or not. */
    format = mask_format->depth << 24 | mask_format->format;

    fixed_list = calloc(fixed_size, sizeof(*fixed_list));
    if (_X_UNLIKELY(fixed_list == NULL))
        fixed_size = 0;
    fixed_cnt = glamor_glyphs_intersect(nlist, list, glyphs,
                                        format, dst->pDrawable->pScreen,
                                        check_fake_overlap,
                                        fixed_list, fixed_size);
    if (fixed_cnt == 0)
        mask_format = NULL;
    need_free_list = TRUE;

    if (fixed_cnt <= 0) {
        if (mask_format == NULL) {
            glamor_glyphs_to_dst(op, src, dst, x_src, y_src, nlist,
                                 list, glyphs);
            goto last_flush;
        }
        else {
            glamor_glyphs_via_mask(op, src, dst, mask_format,
                                   x_src, y_src, nlist, list, glyphs, FALSE);
            goto free_fixed_list;
        }
    }
    else {

        /* We have splitted the original list to serval list, some are overlapped
         * and some are non-overlapped. For the non-overlapped, we render it to
         * dst directly. For the overlapped, we render it to mask picture firstly,
         * then render the mask to dst. If we can use mask cache which is in the
         * glyphs cache's last row, we can accumulate the rendering of mask to dst
         * with the other dst_buffer's rendering operations thus can reduce the call
         * of glDrawElements.
         *
         * */
        struct glamor_glyph_list *saved_list;

        saved_list = fixed_list;
        mask_arg.used_bitmap = 0;
        while (fixed_cnt--) {
            if (fixed_list->type == NON_INTERSECTED) {
                glamor_glyphs_to_dst(op, src, dst,
                                     x_src, y_src,
                                     fixed_list->nlist,
                                     fixed_list->list, fixed_list->glyphs);
            }
            else
                glamor_glyphs_via_mask(op, src, dst,
                                       mask_format, x_src, y_src,
                                       fixed_list->nlist,
                                       fixed_list->list,
                                       fixed_list->glyphs, TRUE);

            free(fixed_list->list);
            fixed_list++;
        }
        free(saved_list);
        need_free_list = FALSE;
    }

 last_flush:
    if (dst_buffer.count || mask_buffer.count)
        glamor_glyphs_flush_dst(&dst_arg);
 free_fixed_list:
    if (need_free_list) {
        assert(fixed_cnt <= 0);
        free(fixed_list);
    }
    return TRUE;
}

void
glamor_glyphs(CARD8 op,
              PicturePtr src,
              PicturePtr dst,
              PictFormatPtr mask_format,
              INT16 x_src,
              INT16 y_src, int nlist, GlyphListPtr list, GlyphPtr *glyphs)
{
    _glamor_glyphs(op, src, dst, mask_format, x_src,
                   y_src, nlist, list, glyphs, TRUE);
}

Bool
glamor_glyphs_nf(CARD8 op,
                 PicturePtr src,
                 PicturePtr dst,
                 PictFormatPtr mask_format,
                 INT16 x_src,
                 INT16 y_src, int nlist, GlyphListPtr list, GlyphPtr *glyphs)
{
    return _glamor_glyphs(op, src, dst, mask_format, x_src,
                          y_src, nlist, list, glyphs, FALSE);
}