xenocara/xserver/hw/xfree86/xaa/xaaTEGlyph.c

#ifdef HAVE_XORG_CONFIG_H
#include <xorg-config.h>
#endif

#include "xaa.h"
#include "xaalocal.h"
#include "xaacexp.h"
#include "xf86.h"

/* scanline function for TRIPLE_BITS_24BPP */
static CARD32 *DrawTextScanline3(CARD32 *base, CARD32 *mem, int width);

/* Loop unrolled functions for common font widths */
static CARD32 *DrawTETextScanlineGeneric(CARD32 *base, unsigned int **glyphp,
                                         int line, int width, int glyphwidth);
static CARD32 *DrawTETextScanlineWidth7(CARD32 *base, unsigned int **glyphp,
                                        int line, int width, int glyphwidth);
static CARD32 *DrawTETextScanlineWidth10(CARD32 *base, unsigned int **glyphp,
                                         int line, int width, int glyphwidth);
static CARD32 *DrawTETextScanlineWidth12(CARD32 *base, unsigned int **glyphp,
                                         int line, int width, int glyphwidth);
static CARD32 *DrawTETextScanlineWidth14(CARD32 *base, unsigned int **glyphp,
                                         int line, int width, int glyphwidth);
static CARD32 *DrawTETextScanlineWidth16(CARD32 *base, unsigned int **glyphp,
                                         int line, int width, int glyphwidth);
static CARD32 *DrawTETextScanlineWidth18(CARD32 *base, unsigned int **glyphp,
                                         int line, int width, int glyphwidth);
static CARD32 *DrawTETextScanlineWidth24(CARD32 *base, unsigned int **glyphp,
                                         int line, int width, int glyphwidth);

#ifdef USEASSEMBLER
#ifdef FIXEDBASE
#ifdef MSBFIRST
CARD32 *DrawTETextScanlineWidth6PMSBFirstFixedBase(CARD32 *base,
                                                   unsigned int **glyphp,
                                                   int line, int width,
                                                   int glyphwidth);
CARD32 *DrawTETextScanlineWidth8PMSBFirstFixedBase(CARD32 *base,
                                                   unsigned int **glyphp,
                                                   int line, int width,
                                                   int glyphwidth);
CARD32 *DrawTETextScanlineWidth9PMSBFirstFixedBase(CARD32 *base,
                                                   unsigned int **glyphp,
                                                   int line, int width,
                                                   int glyphwidth);
#else
CARD32 *DrawTETextScanlineWidth6PLSBFirstFixedBase(CARD32 *base,
                                                   unsigned int **glyphp,
                                                   int line, int width,
                                                   int glyphwidth);
CARD32 *DrawTETextScanlineWidth8PLSBFirstFixedBase(CARD32 *base,
                                                   unsigned int **glyphp,
                                                   int line, int width,
                                                   int glyphwidth);
CARD32 *DrawTETextScanlineWidth9PLSBFirstFixedBase(CARD32 *base,
                                                   unsigned int **glyphp,
                                                   int line, int width,
                                                   int glyphwidth);
#endif
#else
#ifdef MSBFIRST
CARD32 *DrawTETextScanlineWidth6PMSBFirst(CARD32 *base, unsigned int **glyphp,
                                          int line, int width, int glyphwidth);
CARD32 *DrawTETextScanlineWidth8PMSBFirst(CARD32 *base, unsigned int **glyphp,
                                          int line, int width, int glyphwidth);
CARD32 *DrawTETextScanlineWidth9PMSBFirst(CARD32 *base, unsigned int **glyphp,
                                          int line, int width, int glyphwidth);
#else
CARD32 *DrawTETextScanlineWidth6PLSBFirst(CARD32 *base, unsigned int **glyphp,
                                          int line, int width, int glyphwidth);
CARD32 *DrawTETextScanlineWidth8PLSBFirst(CARD32 *base, unsigned int **glyphp,
                                          int line, int width, int glyphwidth);
CARD32 *DrawTETextScanlineWidth9PLSBFirst(CARD32 *base, unsigned int **glyphp,
                                          int line, int width, int glyphwidth);
#endif
#endif
#else
static CARD32 *DrawTETextScanlineWidth6(CARD32 *base, unsigned int **glyphp,
                                        int line, int width, int glyphwidth);
static CARD32 *DrawTETextScanlineWidth8(CARD32 *base, unsigned int **glyphp,
                                        int line, int width, int glyphwidth);
static CARD32 *DrawTETextScanlineWidth9(CARD32 *base, unsigned int **glyphp,
                                        int line, int width, int glyphwidth);
#endif

#define glyph_scanline_func EXPNAME(XAAGlyphScanlineFunc)
#define glyph_get_scanline_func EXPNAME(XAAGetGlyphScanlineFunc)

GlyphScanlineFuncPtr glyph_scanline_func[32] = {
    DrawTETextScanlineGeneric, DrawTETextScanlineGeneric,
    DrawTETextScanlineGeneric, DrawTETextScanlineGeneric,
    DrawTETextScanlineGeneric,
#ifdef USEASSEMBLER
#ifdef FIXEDBASE
#ifdef MSBFIRST
    DrawTETextScanlineWidth6PMSBFirstFixedBase,
    DrawTETextScanlineWidth7,
    DrawTETextScanlineWidth8PMSBFirstFixedBase,
    DrawTETextScanlineWidth9PMSBFirstFixedBase,
#else
    DrawTETextScanlineWidth6PLSBFirstFixedBase,
    DrawTETextScanlineWidth7,
    DrawTETextScanlineWidth8PLSBFirstFixedBase,
    DrawTETextScanlineWidth9PLSBFirstFixedBase,
#endif
#else
#ifdef MSBFIRST
    DrawTETextScanlineWidth6PMSBFirst,
    DrawTETextScanlineWidth7,
    DrawTETextScanlineWidth8PMSBFirst,
    DrawTETextScanlineWidth9PMSBFirst,
#else
    DrawTETextScanlineWidth6PLSBFirst,
    DrawTETextScanlineWidth7,
    DrawTETextScanlineWidth8PLSBFirst,
    DrawTETextScanlineWidth9PLSBFirst,
#endif
#endif
#else
    DrawTETextScanlineWidth6, DrawTETextScanlineWidth7,
    DrawTETextScanlineWidth8, DrawTETextScanlineWidth9,
#endif
    DrawTETextScanlineWidth10,
    DrawTETextScanlineGeneric, DrawTETextScanlineWidth12,
    DrawTETextScanlineGeneric, DrawTETextScanlineWidth14,
    DrawTETextScanlineGeneric, DrawTETextScanlineWidth16,
    DrawTETextScanlineGeneric, DrawTETextScanlineWidth18,
    DrawTETextScanlineGeneric, DrawTETextScanlineGeneric,
    DrawTETextScanlineGeneric, DrawTETextScanlineGeneric,
    DrawTETextScanlineGeneric, DrawTETextScanlineWidth24,
    DrawTETextScanlineGeneric, DrawTETextScanlineGeneric,
    DrawTETextScanlineGeneric, DrawTETextScanlineGeneric,
    DrawTETextScanlineGeneric, DrawTETextScanlineGeneric,
    DrawTETextScanlineGeneric, DrawTETextScanlineGeneric
};

GlyphScanlineFuncPtr *
glyph_get_scanline_func(void)
{
    return glyph_scanline_func;
}

/********************************************************************

   Here we have TEGlyphRenders for a bunch of different color
   expansion types.  The driver may provide its own renderer, but
   this is the default one which renders using lower-level primitives
   exported by the chipset driver.

********************************************************************/

/* This gets built for MSBFIRST or LSBFIRST with FIXEDBASE or not.
	A total of 4 versions */

void

EXPNAME(XAATEGlyphRenderer) (ScrnInfoPtr pScrn,
                             int x, int y, int w, int h, int skipleft,
                             int startline, unsigned int **glyphs,
                             int glyphWidth, int fg, int bg, int rop,
                             unsigned planemask) {
    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
    CARD32 *base;
    GlyphScanlineFuncPtr GlyphFunc = glyph_scanline_func[glyphWidth - 1];
    int dwords = 0;

    if ((bg != -1) && (infoRec->TEGlyphRendererFlags & TRANSPARENCY_ONLY)) {
        (*infoRec->SetupForSolidFill) (pScrn, bg, rop, planemask);
        (*infoRec->SubsequentSolidFillRect) (pScrn, x, y, w, h);
        bg = -1;
    }

    (*infoRec->SetupForCPUToScreenColorExpandFill) (pScrn, fg, bg, rop,
                                                    planemask);

    if (skipleft &&
        (!(infoRec->TEGlyphRendererFlags & LEFT_EDGE_CLIPPING) ||
         (!(infoRec->TEGlyphRendererFlags & LEFT_EDGE_CLIPPING_NEGATIVE_X) &&
          (skipleft > x)))) {
        /* draw the first character only */

        int count = h, line = startline;
        int width = glyphWidth - skipleft;

        if (width > w)
            width = w;

        (*infoRec->SubsequentCPUToScreenColorExpandFill) (pScrn, x, y, width, h,
                                                          0);

        base = (CARD32 *) infoRec->ColorExpandBase;

        while (count--) {
            register CARD32 tmp = SHIFT_R(glyphs[0][line++], skipleft);

            WRITE_BITS(tmp);
        }

        w -= width;
        if ((infoRec->TEGlyphRendererFlags & CPU_TRANSFER_PAD_QWORD) &&
            ((((width + 31) >> 5) * h) & 1)) {
            base = (CARD32 *) infoRec->ColorExpandBase;
            base[0] = 0x00000000;
        }
        if (!w)
            goto THE_END;
        glyphs++;
        x += width;
        skipleft = 0;           /* nicely aligned again */
    }

    w += skipleft;
    x -= skipleft;
    dwords = ((w + 31) >> 5) * h;

    (*infoRec->SubsequentCPUToScreenColorExpandFill) (pScrn, x, y, w, h,
                                                      skipleft);

    base = (CARD32 *) infoRec->ColorExpandBase;

#ifndef FIXEDBASE
    if ((((w + 31) >> 5) * h) <= infoRec->ColorExpandRange)
        while (h--) {
            base = (*GlyphFunc) (base, glyphs, startline++, w, glyphWidth);
        }
    else
#endif
        while (h--) {
            (*GlyphFunc) (base, glyphs, startline++, w, glyphWidth);
        }

    if ((infoRec->TEGlyphRendererFlags & CPU_TRANSFER_PAD_QWORD) &&
        (dwords & 1)) {
        base = (CARD32 *) infoRec->ColorExpandBase;
        base[0] = 0x00000000;
    }

 THE_END:

    if (infoRec->TEGlyphRendererFlags & SYNC_AFTER_COLOR_EXPAND)
        (*infoRec->Sync) (pScrn);
    else
        SET_SYNC_FLAG(infoRec);
}

/********************************************************************
 
   This is the GlyphRenderer for TRIPLE_BITS_24BPP. It renders to a buffer
   with the non FIXEDBASE LSB_FIRST code before tripling, and possibly
   reversing the bits and sending them to the screen

********************************************************************/

void

EXPNAME(XAATEGlyphRenderer3) (ScrnInfoPtr pScrn,
                              int x, int y, int w, int h, int skipleft,
                              int startline, unsigned int **glyphs,
                              int glyphWidth, int fg, int bg, int rop,
                              unsigned planemask) {
    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
    CARD32 *base, *mem;
    GlyphScanlineFuncPtr GlyphFunc =
        XAAGlyphScanlineFuncLSBFirst[glyphWidth - 1];
    int dwords = 0;

    if ((bg != -1) &&
        ((infoRec->TEGlyphRendererFlags & TRANSPARENCY_ONLY) ||
         ((infoRec->TEGlyphRendererFlags & RGB_EQUAL) &&
          (!CHECK_RGB_EQUAL(bg))))) {
        (*infoRec->SetupForSolidFill) (pScrn, bg, rop, planemask);
        (*infoRec->SubsequentSolidFillRect) (pScrn, x, y, w, h);
        bg = -1;
    }

    (*infoRec->SetupForCPUToScreenColorExpandFill) (pScrn, fg, bg, rop,
                                                    planemask);

    if (skipleft) {
        /* draw the first character only */

        int count = h, line = startline;
        int width = glyphWidth - skipleft;
        CARD32 bits;

        if (width > w)
            width = w;
        (*infoRec->SubsequentCPUToScreenColorExpandFill) (pScrn, x, y, width, h,
                                                          0);

        base = (CARD32 *) infoRec->ColorExpandBase;

        while (count--) {
            bits = SHIFT_R(glyphs[0][line++], skipleft);
            if (width >= 22) {
                WRITE_BITS3(bits);
            }
            else if (width >= 11) {
                WRITE_BITS2(bits);
            }
            else {
                WRITE_BITS1(bits);
            }
        }

        w -= width;
        if ((infoRec->TEGlyphRendererFlags & CPU_TRANSFER_PAD_QWORD) &&
            ((((3 * width + 31) >> 5) * h) & 1)) {
            base = (CARD32 *) infoRec->ColorExpandBase;
            base[0] = 0x00000000;
        }
        if (!w)
            goto THE_END;
        glyphs++;
        x += width;
        skipleft = 0;           /* nicely aligned again */
    }

    dwords = ((3 * w + 31) >> 5) * h;
    mem = (CARD32 *) malloc(((w + 31) >> 3) * sizeof(char));
    if (!mem)
        return;

    (*infoRec->SubsequentCPUToScreenColorExpandFill) (pScrn, x, y, w, h, 0);

    base = (CARD32 *) infoRec->ColorExpandBase;

#ifndef FIXEDBASE
    if ((((3 * w + 31) >> 5) * h) <= infoRec->ColorExpandRange)
        while (h--) {
            (*GlyphFunc) (mem, glyphs, startline++, w, glyphWidth);
            base = DrawTextScanline3(base, mem, w);
        }
    else
#endif
        while (h--) {
            (*GlyphFunc) (mem, glyphs, startline++, w, glyphWidth);
            DrawTextScanline3(base, mem, w);
        }

    free(mem);

    if ((infoRec->TEGlyphRendererFlags & CPU_TRANSFER_PAD_QWORD) &&
        (dwords & 1)) {
        base = (CARD32 *) infoRec->ColorExpandBase;
        base[0] = 0x00000000;
    }

 THE_END:

    if (infoRec->TEGlyphRendererFlags & SYNC_AFTER_COLOR_EXPAND)
        (*infoRec->Sync) (pScrn);
    else
        SET_SYNC_FLAG(infoRec);
}

#ifndef FIXEDBASE
/*  Scanline version of above gets built for LSBFIRST and MSBFIRST */

void

EXPNAME(XAATEGlyphRendererScanline) (ScrnInfoPtr pScrn,
                                     int x, int y, int w, int h, int skipleft,
                                     int startline, unsigned int **glyphs,
                                     int glyphWidth, int fg, int bg, int rop,
                                     unsigned planemask) {
    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
    int bufferNo;
    CARD32 *base;
    GlyphScanlineFuncPtr GlyphFunc = glyph_scanline_func[glyphWidth - 1];

    if ((bg != -1) && (infoRec->TEGlyphRendererFlags & TRANSPARENCY_ONLY)) {
        (*infoRec->SetupForSolidFill) (pScrn, bg, rop, planemask);
        (*infoRec->SubsequentSolidFillRect) (pScrn, x, y, w, h);
        bg = -1;
    }

    (*infoRec->SetupForScanlineCPUToScreenColorExpandFill) (pScrn, fg, bg, rop,
                                                            planemask);

    if (skipleft &&
        (!(infoRec->TEGlyphRendererFlags & LEFT_EDGE_CLIPPING) ||
         (!(infoRec->TEGlyphRendererFlags & LEFT_EDGE_CLIPPING_NEGATIVE_X) &&
          (skipleft > x)))) {
        /* draw the first character only */

        int count = h, line = startline;
        int width = glyphWidth - skipleft;

        if (width > w)
            width = w;

        (*infoRec->SubsequentScanlineCPUToScreenColorExpandFill) (pScrn, x, y,
                                                                  width, h, 0);

        bufferNo = 0;

        while (count--) {
            register CARD32 tmp = SHIFT_R(glyphs[0][line++], skipleft);

            base = (CARD32 *) infoRec->ScanlineColorExpandBuffers[bufferNo];
            WRITE_BITS(tmp);
            (*infoRec->SubsequentColorExpandScanline) (pScrn, bufferNo++);
            if (bufferNo >= infoRec->NumScanlineColorExpandBuffers)
                bufferNo = 0;
        }

        w -= width;
        if (!w)
            goto THE_END;
        glyphs++;
        x += width;
        skipleft = 0;           /* nicely aligned again */
    }

    w += skipleft;
    x -= skipleft;

    (*infoRec->SubsequentScanlineCPUToScreenColorExpandFill) (pScrn, x, y, w, h,
                                                              skipleft);

    bufferNo = 0;

    while (h--) {
        base = (CARD32 *) infoRec->ScanlineColorExpandBuffers[bufferNo];
        (*GlyphFunc) (base, glyphs, startline++, w, glyphWidth);
        (*infoRec->SubsequentColorExpandScanline) (pScrn, bufferNo++);
        if (bufferNo >= infoRec->NumScanlineColorExpandBuffers)
            bufferNo = 0;
    }

 THE_END:

    SET_SYNC_FLAG(infoRec);
}

void

EXPNAME(XAATEGlyphRendererScanline3) (ScrnInfoPtr pScrn,
                                      int x, int y, int w, int h, int skipleft,
                                      int startline, unsigned int **glyphs,
                                      int glyphWidth, int fg, int bg, int rop,
                                      unsigned planemask) {
    XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
    int bufferNo;
    CARD32 *base, *mem;
    GlyphScanlineFuncPtr GlyphFunc =
        XAAGlyphScanlineFuncLSBFirst[glyphWidth - 1];

    if ((bg != -1) &&
        ((infoRec->TEGlyphRendererFlags & TRANSPARENCY_ONLY) ||
         ((infoRec->TEGlyphRendererFlags & RGB_EQUAL) &&
          (!CHECK_RGB_EQUAL(bg))))) {
        (*infoRec->SetupForSolidFill) (pScrn, bg, rop, planemask);
        (*infoRec->SubsequentSolidFillRect) (pScrn, x, y, w, h);
        bg = -1;
    }

    (*infoRec->SetupForScanlineCPUToScreenColorExpandFill) (pScrn, fg, bg, rop,
                                                            planemask);

    if (skipleft) {
        /* draw the first character only */

        int count = h, line = startline;
        int width = glyphWidth - skipleft;
        CARD32 bits;

        if (width > w)
            width = w;

        (*infoRec->SubsequentScanlineCPUToScreenColorExpandFill) (pScrn, x, y,
                                                                  width, h, 0);

        bufferNo = 0;

        while (count--) {
            base = (CARD32 *) infoRec->ScanlineColorExpandBuffers[bufferNo];
            bits = SHIFT_R(glyphs[0][line++], skipleft);
            if (width >= 22) {
                WRITE_BITS3(bits);
            }
            else if (width >= 11) {
                WRITE_BITS2(bits);
            }
            else {
                WRITE_BITS1(bits);
            }
            (*infoRec->SubsequentColorExpandScanline) (pScrn, bufferNo++);
            if (bufferNo >= infoRec->NumScanlineColorExpandBuffers)
                bufferNo = 0;
        }

        w -= width;
        if (!w)
            goto THE_END;
        glyphs++;
        x += width;
        skipleft = 0;           /* nicely aligned again */
    }

    w += skipleft;
    x -= skipleft;
    mem = (CARD32 *) malloc(((w + 31) >> 3) * sizeof(char));
    if (!mem)
        return;

    (*infoRec->SubsequentScanlineCPUToScreenColorExpandFill) (pScrn, x, y, w, h,
                                                              skipleft);

    bufferNo = 0;

    while (h--) {
        base = (CARD32 *) infoRec->ScanlineColorExpandBuffers[bufferNo];
        (*GlyphFunc) (mem, glyphs, startline++, w, glyphWidth);
        DrawTextScanline3(base, mem, w);
        (*infoRec->SubsequentColorExpandScanline) (pScrn, bufferNo++);
        if (bufferNo >= infoRec->NumScanlineColorExpandBuffers)
            bufferNo = 0;
    }

    free(mem);

 THE_END:

    SET_SYNC_FLAG(infoRec);
}

#endif

/********************************************************************

   TRIPLE_BITS_24BPP scanline rendering code.

********************************************************************/

static CARD32 *
DrawTextScanline3(CARD32 *base, CARD32 *mem, int width)
{

    while (width > 32) {
        WRITE_BITS3(*mem);
        mem++;
        width -= 32;
    }
    if (width) {
        if (width >= 22) {
            WRITE_BITS3(*mem);
        }
        else if (width >= 11) {
            WRITE_BITS2(*mem);
        }
        else {
            WRITE_BITS1(*mem);
        }
    }

    return base;
}

/********************************************************************

   Generic TE scanline rendering code.

********************************************************************/

static CARD32 *
DrawTETextScanlineGeneric(CARD32 *base,
                          unsigned int **glyphp,
                          int line, int width, int glyphwidth)
{
    CARD32 bits = (*glyphp)[line];
    int shift = glyphwidth;

    while (width > 32) {
        while (shift < 32) {
            glyphp++;
            bits |= SHIFT_L((*glyphp)[line], shift);
            shift += glyphwidth;
        }
        WRITE_BITS(bits);
        shift &= 31;
        if (shift)
            bits = SHIFT_R((*glyphp)[line], (glyphwidth - shift));
        else
            bits = 0;
        width -= 32;
    }

    if (width) {
        width -= shift;
        while (width > 0) {
            glyphp++;
            bits |= SHIFT_L((*glyphp)[line], shift);
            shift += glyphwidth;
            width -= glyphwidth;
        }
        WRITE_BITS(bits);
    }

    return base;
}

/********************************************************************

   Loop unrolled TE font scanline rendering code

********************************************************************/

#ifndef USEASSEMBLER
static CARD32 *
DrawTETextScanlineWidth6(CARD32 *base,
                         unsigned int **glyphp,
                         int line, int width, int glyphwidth)
{
    while (1) {
        unsigned int bits;

        bits = glyphp[0][line];
        bits |= SHIFT_L(glyphp[1][line], 6);
        bits |= SHIFT_L(glyphp[2][line], 12);
        bits |= SHIFT_L(glyphp[3][line], 18);
        bits |= SHIFT_L(glyphp[4][line], 24);
        bits |= SHIFT_L(glyphp[5][line], 30);
        WRITE_IN_BITORDER(base, 0, bits);
        CHECKRETURN(1);
        bits = SHIFT_R(glyphp[5][line], 2);
        bits |= SHIFT_L(glyphp[6][line], 4);
        bits |= SHIFT_L(glyphp[7][line], 10);
        bits |= SHIFT_L(glyphp[8][line], 16);
        bits |= SHIFT_L(glyphp[9][line], 22);
        bits |= SHIFT_L(glyphp[10][line], 28);
        WRITE_IN_BITORDER(base, 1, bits);
        CHECKRETURN(2);
        bits = SHIFT_R(glyphp[10][line], 4);
        bits |= SHIFT_L(glyphp[11][line], 2);
        bits |= SHIFT_L(glyphp[12][line], 8);
        bits |= SHIFT_L(glyphp[13][line], 14);
        bits |= SHIFT_L(glyphp[14][line], 20);
        bits |= SHIFT_L(glyphp[15][line], 26);
        WRITE_IN_BITORDER(base, 2, bits);
        CHECKRETURN(3);
#ifndef FIXEDBASE
        base += 3;
#endif
        width -= 96;
        glyphp += 16;
    }
    return base;
}
#endif

static CARD32 *
DrawTETextScanlineWidth7(CARD32 *base,
                         unsigned int **glyphp,
                         int line, int width, int glyphwidth)
{
    while (1) {
        unsigned int bits;

        bits = glyphp[0][line];
        bits |= SHIFT_L(glyphp[1][line], 7);
        bits |= SHIFT_L(glyphp[2][line], 14);
        bits |= SHIFT_L(glyphp[3][line], 21);
        bits |= SHIFT_L(glyphp[4][line], 28);
        WRITE_IN_BITORDER(base, 0, bits);
        CHECKRETURN(1);
        bits = SHIFT_R(glyphp[4][line], 4);
        bits |= SHIFT_L(glyphp[5][line], 3);
        bits |= SHIFT_L(glyphp[6][line], 10);
        bits |= SHIFT_L(glyphp[7][line], 17);
        bits |= SHIFT_L(glyphp[8][line], 24);
        bits |= SHIFT_L(glyphp[9][line], 31);
        WRITE_IN_BITORDER(base, 1, bits);
        CHECKRETURN(2);
        bits = SHIFT_R(glyphp[9][line], 1);
        bits |= SHIFT_L(glyphp[10][line], 6);
        bits |= SHIFT_L(glyphp[11][line], 13);
        bits |= SHIFT_L(glyphp[12][line], 20);
        bits |= SHIFT_L(glyphp[13][line], 27);
        WRITE_IN_BITORDER(base, 2, bits);
        CHECKRETURN(3);
        bits = SHIFT_R(glyphp[13][line], 5);
        bits |= SHIFT_L(glyphp[14][line], 2);
        bits |= SHIFT_L(glyphp[15][line], 9);
        bits |= SHIFT_L(glyphp[16][line], 16);
        bits |= SHIFT_L(glyphp[17][line], 23);
        bits |= SHIFT_L(glyphp[18][line], 30);
        WRITE_IN_BITORDER(base, 3, bits);
        CHECKRETURN(4);
        bits = SHIFT_R(glyphp[18][line], 2);
        bits |= SHIFT_L(glyphp[19][line], 5);
        bits |= SHIFT_L(glyphp[20][line], 12);
        bits |= SHIFT_L(glyphp[21][line], 19);
        bits |= SHIFT_L(glyphp[22][line], 26);
        WRITE_IN_BITORDER(base, 4, bits);
        CHECKRETURN(5);
        bits = SHIFT_R(glyphp[22][line], 6);
        bits |= SHIFT_L(glyphp[23][line], 1);
        bits |= SHIFT_L(glyphp[24][line], 8);
        bits |= SHIFT_L(glyphp[25][line], 15);
        bits |= SHIFT_L(glyphp[26][line], 22);
        bits |= SHIFT_L(glyphp[27][line], 29);
        WRITE_IN_BITORDER(base, 5, bits);
        CHECKRETURN(6);
        bits = SHIFT_R(glyphp[27][line], 3);
        bits |= SHIFT_L(glyphp[28][line], 4);
        bits |= SHIFT_L(glyphp[29][line], 11);
        bits |= SHIFT_L(glyphp[30][line], 18);
        bits |= SHIFT_L(glyphp[31][line], 25);
        WRITE_IN_BITORDER(base, 6, bits);
        CHECKRETURN(7);
#ifndef FIXEDBASE
        base += 7;
#endif
        width -= 224;
        glyphp += 32;
    }
    return base;
}

#ifndef USEASSEMBLER
static CARD32 *
DrawTETextScanlineWidth8(CARD32 *base,
                         unsigned int **glyphp,
                         int line, int width, int glyphwidth)
{
    while (1) {
        unsigned int bits;

        bits = glyphp[0][line];
        bits |= SHIFT_L(glyphp[1][line], 8);
        bits |= SHIFT_L(glyphp[2][line], 16);
        bits |= SHIFT_L(glyphp[3][line], 24);
        WRITE_IN_BITORDER(base, 0, bits);
        CHECKRETURN(1);
        bits = glyphp[4][line];
        bits |= SHIFT_L(glyphp[5][line], 8);
        bits |= SHIFT_L(glyphp[6][line], 16);
        bits |= SHIFT_L(glyphp[7][line], 24);
        WRITE_IN_BITORDER(base, 1, bits);
        CHECKRETURN(2);
#ifndef FIXEDBASE
        base += 2;
#endif
        width -= 64;
        glyphp += 8;
    }
    return base;
}
#endif

#ifndef USEASSEMBLER
static CARD32 *
DrawTETextScanlineWidth9(CARD32 *base,
                         unsigned int **glyphp,
                         int line, int width, int glyphwidth)
{
    while (1) {
        unsigned int bits;

        bits = glyphp[0][line];
        bits |= SHIFT_L(glyphp[1][line], 9);
        bits |= SHIFT_L(glyphp[2][line], 18);
        bits |= SHIFT_L(glyphp[3][line], 27);
        WRITE_IN_BITORDER(base, 0, bits);
        CHECKRETURN(1);
        bits = SHIFT_R(glyphp[3][line], 5);
        bits |= SHIFT_L(glyphp[4][line], 4);
        bits |= SHIFT_L(glyphp[5][line], 13);
        bits |= SHIFT_L(glyphp[6][line], 22);
        bits |= SHIFT_L(glyphp[7][line], 31);
        WRITE_IN_BITORDER(base, 1, bits);
        CHECKRETURN(2);
        bits = SHIFT_R(glyphp[7][line], 1);
        bits |= SHIFT_L(glyphp[8][line], 8);
        bits |= SHIFT_L(glyphp[9][line], 17);
        bits |= SHIFT_L(glyphp[10][line], 26);
        WRITE_IN_BITORDER(base, 2, bits);
        CHECKRETURN(3);
        bits = SHIFT_R(glyphp[10][line], 6);
        bits |= SHIFT_L(glyphp[11][line], 3);
        bits |= SHIFT_L(glyphp[12][line], 12);
        bits |= SHIFT_L(glyphp[13][line], 21);
        bits |= SHIFT_L(glyphp[14][line], 30);
        WRITE_IN_BITORDER(base, 3, bits);
        CHECKRETURN(4);
        bits = SHIFT_R(glyphp[14][line], 2);
        bits |= SHIFT_L(glyphp[15][line], 7);
        bits |= SHIFT_L(glyphp[16][line], 16);
        bits |= SHIFT_L(glyphp[17][line], 25);
        WRITE_IN_BITORDER(base, 4, bits);
        CHECKRETURN(5);
        bits = SHIFT_R(glyphp[17][line], 7);
        bits |= SHIFT_L(glyphp[18][line], 2);
        bits |= SHIFT_L(glyphp[19][line], 11);
        bits |= SHIFT_L(glyphp[20][line], 20);
        bits |= SHIFT_L(glyphp[21][line], 29);
        WRITE_IN_BITORDER(base, 5, bits);
        CHECKRETURN(6);
        bits = SHIFT_R(glyphp[21][line], 3);
        bits |= SHIFT_L(glyphp[22][line], 6);
        bits |= SHIFT_L(glyphp[23][line], 15);
        bits |= SHIFT_L(glyphp[24][line], 24);
        WRITE_IN_BITORDER(base, 6, bits);
        CHECKRETURN(7);
        bits = SHIFT_R(glyphp[24][line], 8);
        bits |= SHIFT_L(glyphp[25][line], 1);
        bits |= SHIFT_L(glyphp[26][line], 10);
        bits |= SHIFT_L(glyphp[27][line], 19);
        bits |= SHIFT_L(glyphp[28][line], 28);
        WRITE_IN_BITORDER(base, 7, bits);
        CHECKRETURN(8);
        bits = SHIFT_R(glyphp[28][line], 4);
        bits |= SHIFT_L(glyphp[29][line], 5);
        bits |= SHIFT_L(glyphp[30][line], 14);
        bits |= SHIFT_L(glyphp[31][line], 23);
        WRITE_IN_BITORDER(base, 8, bits);
        CHECKRETURN(9);
#ifndef FIXEDBASE
        base += 9;
#endif
        width -= 288;
        glyphp += 32;
    }
    return base;
}
#endif

static CARD32 *
DrawTETextScanlineWidth10(CARD32 *base,
                          unsigned int **glyphp,
                          int line, int width, int glyphwidth)
{
    while (1) {
        unsigned int bits;

        bits = glyphp[0][line];
        bits |= SHIFT_L(glyphp[1][line], 10);
        bits |= SHIFT_L(glyphp[2][line], 20);
        bits |= SHIFT_L(glyphp[3][line], 30);
        WRITE_IN_BITORDER(base, 0, bits);
        CHECKRETURN(1);
        bits = SHIFT_R(glyphp[3][line], 2);
        bits |= SHIFT_L(glyphp[4][line], 8);
        bits |= SHIFT_L(glyphp[5][line], 18);
        bits |= SHIFT_L(glyphp[6][line], 28);
        WRITE_IN_BITORDER(base, 1, bits);
        CHECKRETURN(2);
        bits = SHIFT_R(glyphp[6][line], 4);
        bits |= SHIFT_L(glyphp[7][line], 6);
        bits |= SHIFT_L(glyphp[8][line], 16);
        bits |= SHIFT_L(glyphp[9][line], 26);
        WRITE_IN_BITORDER(base, 2, bits);
        CHECKRETURN(3);
        bits = SHIFT_R(glyphp[9][line], 6);
        bits |= SHIFT_L(glyphp[10][line], 4);
        bits |= SHIFT_L(glyphp[11][line], 14);
        bits |= SHIFT_L(glyphp[12][line], 24);
        WRITE_IN_BITORDER(base, 3, bits);
        CHECKRETURN(4);
        bits = SHIFT_R(glyphp[12][line], 8);
        bits |= SHIFT_L(glyphp[13][line], 2);
        bits |= SHIFT_L(glyphp[14][line], 12);
        bits |= SHIFT_L(glyphp[15][line], 22);
        WRITE_IN_BITORDER(base, 4, bits);
        CHECKRETURN(5);
#ifndef FIXEDBASE
        base += 5;
#endif
        width -= 160;
        glyphp += 16;
    }
    return base;
}

static CARD32 *
DrawTETextScanlineWidth12(CARD32 *base,
                          unsigned int **glyphp,
                          int line, int width, int glyphwidth)
{
    while (1) {
        unsigned int bits;

        bits = glyphp[0][line];
        bits |= SHIFT_L(glyphp[1][line], 12);
        bits |= SHIFT_L(glyphp[2][line], 24);
        WRITE_IN_BITORDER(base, 0, bits);
        CHECKRETURN(1);
        bits = SHIFT_R(glyphp[2][line], 8);
        bits |= SHIFT_L(glyphp[3][line], 4);
        bits |= SHIFT_L(glyphp[4][line], 16);
        bits |= SHIFT_L(glyphp[5][line], 28);
        WRITE_IN_BITORDER(base, 1, bits);
        CHECKRETURN(2);
        bits = SHIFT_R(glyphp[5][line], 4);
        bits |= SHIFT_L(glyphp[6][line], 8);
        bits |= SHIFT_L(glyphp[7][line], 20);
        WRITE_IN_BITORDER(base, 2, bits);
        CHECKRETURN(3);
#ifndef FIXEDBASE
        base += 3;
#endif
        width -= 96;
        glyphp += 8;
    }
    return base;
}

static CARD32 *
DrawTETextScanlineWidth14(CARD32 *base,
                          unsigned int **glyphp,
                          int line, int width, int glyphwidth)
{
    while (1) {
        unsigned int bits;

        bits = glyphp[0][line];
        bits |= SHIFT_L(glyphp[1][line], 14);
        bits |= SHIFT_L(glyphp[2][line], 28);
        WRITE_IN_BITORDER(base, 0, bits);
        CHECKRETURN(1);
        bits = SHIFT_R(glyphp[2][line], 4);
        bits |= SHIFT_L(glyphp[3][line], 10);
        bits |= SHIFT_L(glyphp[4][line], 24);
        WRITE_IN_BITORDER(base, 1, bits);
        CHECKRETURN(2);
        bits = SHIFT_R(glyphp[4][line], 8);
        bits |= SHIFT_L(glyphp[5][line], 6);
        bits |= SHIFT_L(glyphp[6][line], 20);
        WRITE_IN_BITORDER(base, 2, bits);
        CHECKRETURN(3);
        bits = SHIFT_R(glyphp[6][line], 12);
        bits |= SHIFT_L(glyphp[7][line], 2);
        bits |= SHIFT_L(glyphp[8][line], 16);
        bits |= SHIFT_L(glyphp[9][line], 30);
        WRITE_IN_BITORDER(base, 3, bits);
        CHECKRETURN(4);
        bits = SHIFT_R(glyphp[9][line], 2);
        bits |= SHIFT_L(glyphp[10][line], 12);
        bits |= SHIFT_L(glyphp[11][line], 26);
        WRITE_IN_BITORDER(base, 4, bits);
        CHECKRETURN(5);
        bits = SHIFT_R(glyphp[11][line], 6);
        bits |= SHIFT_L(glyphp[12][line], 8);
        bits |= SHIFT_L(glyphp[13][line], 22);
        WRITE_IN_BITORDER(base, 5, bits);
        CHECKRETURN(6);
        bits = SHIFT_R(glyphp[13][line], 10);
        bits |= SHIFT_L(glyphp[14][line], 4);
        bits |= SHIFT_L(glyphp[15][line], 18);
        WRITE_IN_BITORDER(base, 6, bits);
        CHECKRETURN(7);
#ifndef FIXEDBASE
        base += 7;
#endif
        width -= 224;
        glyphp += 16;
    }
    return base;
}

static CARD32 *
DrawTETextScanlineWidth16(CARD32 *base,
                          unsigned int **glyphp,
                          int line, int width, int glyphwidth)
{
    while (1) {
        unsigned int bits;

        bits = glyphp[0][line];
        bits |= SHIFT_L(glyphp[1][line], 16);
        WRITE_IN_BITORDER(base, 0, bits);
        CHECKRETURN(1);
        bits = glyphp[2][line];
        bits |= SHIFT_L(glyphp[3][line], 16);
        WRITE_IN_BITORDER(base, 1, bits);
        CHECKRETURN(2);
        bits = glyphp[4][line];
        bits |= SHIFT_L(glyphp[5][line], 16);
        WRITE_IN_BITORDER(base, 2, bits);
        CHECKRETURN(3);
        bits = glyphp[6][line];
        bits |= SHIFT_L(glyphp[7][line], 16);
        WRITE_IN_BITORDER(base, 3, bits);
        CHECKRETURN(4);
#ifndef FIXEDBASE
        base += 4;
#endif
        width -= 128;
        glyphp += 8;
    }
    return base;
}

static CARD32 *
DrawTETextScanlineWidth18(CARD32 *base,
                          unsigned int **glyphp,
                          int line, int width, int glyphwidth)
{
    while (1) {
        unsigned int bits;

        bits = glyphp[0][line];
        bits |= SHIFT_L(glyphp[1][line], 18);
        WRITE_IN_BITORDER(base, 0, bits);
        CHECKRETURN(1);
        bits = SHIFT_R(glyphp[1][line], 14);
        bits |= SHIFT_L(glyphp[2][line], 4);
        bits |= SHIFT_L(glyphp[3][line], 22);
        WRITE_IN_BITORDER(base, 1, bits);
        CHECKRETURN(2);
        bits = SHIFT_R(glyphp[3][line], 10);
        bits |= SHIFT_L(glyphp[4][line], 8);
        bits |= SHIFT_L(glyphp[5][line], 26);
        WRITE_IN_BITORDER(base, 2, bits);
        CHECKRETURN(3);
        bits = SHIFT_R(glyphp[5][line], 6);
        bits |= SHIFT_L(glyphp[6][line], 12);
        bits |= SHIFT_L(glyphp[7][line], 30);
        WRITE_IN_BITORDER(base, 3, bits);
        CHECKRETURN(4);
        bits = SHIFT_R(glyphp[7][line], 2);
        bits |= SHIFT_L(glyphp[8][line], 16);
        WRITE_IN_BITORDER(base, 4, bits);
        CHECKRETURN(5);
        bits = SHIFT_R(glyphp[8][line], 16);
        bits |= SHIFT_L(glyphp[9][line], 2);
        bits |= SHIFT_L(glyphp[10][line], 20);
        WRITE_IN_BITORDER(base, 5, bits);
        CHECKRETURN(6);
        bits = SHIFT_R(glyphp[10][line], 12);
        bits |= SHIFT_L(glyphp[11][line], 6);
        bits |= SHIFT_L(glyphp[12][line], 24);
        WRITE_IN_BITORDER(base, 6, bits);
        CHECKRETURN(7);
        bits = SHIFT_R(glyphp[12][line], 8);
        bits |= SHIFT_L(glyphp[13][line], 10);
        bits |= SHIFT_L(glyphp[14][line], 28);
        WRITE_IN_BITORDER(base, 7, bits);
        CHECKRETURN(8);
        bits = SHIFT_R(glyphp[14][line], 4);
        bits |= SHIFT_L(glyphp[15][line], 14);
        WRITE_IN_BITORDER(base, 8, bits);
        CHECKRETURN(9);
#ifndef FIXEDBASE
        base += 9;
#endif
        width -= 288;
        glyphp += 16;
    }
    return base;
}

static CARD32 *
DrawTETextScanlineWidth24(CARD32 *base,
                          unsigned int **glyphp,
                          int line, int width, int glyphwidth)
{
    while (1) {
        unsigned int bits;

        bits = glyphp[0][line];
        bits |= SHIFT_L(glyphp[1][line], 24);
        WRITE_IN_BITORDER(base, 0, bits);
        CHECKRETURN(1);
        bits = SHIFT_R(glyphp[1][line], 8);
        bits |= SHIFT_L(glyphp[2][line], 16);
        WRITE_IN_BITORDER(base, 1, bits);
        CHECKRETURN(2);
        bits = SHIFT_R(glyphp[2][line], 16);
        bits |= SHIFT_L(glyphp[3][line], 8);
        WRITE_IN_BITORDER(base, 2, bits);
        CHECKRETURN(3);
#ifndef FIXEDBASE
        base += 3;
#endif
        width -= 96;
        glyphp += 4;
    }
    return base;
}