fontconv.c

Go to the documentation of this file.

/* This code is (C) AllegroGL contributors, and double licensed under
 * the GPL and zlib licenses. See gpl.txt or zlib.txt for details.
 */
#include <math.h>
#include <string.h>
#include <stdio.h>

#include <allegro.h>
#include <allegro/internal/aintern.h>

#include "alleggl.h"
#include "allglint.h"

#ifdef ALLEGRO_MACOSX
#include <OpenGL/glu.h>
#else
#include <GL/glu.h>
#endif

#if defined ALLEGRO_WITH_XWINDOWS && !defined ALLEGROGL_GENERIC_DRIVER
#include <xalleg.h>
#include <GL/glx.h>
#endif

#define PREFIX_I                "agl-font INFO: "
#define PREFIX_W                "agl-font WARNING: "
#define PREFIX_E                "agl-font ERROR: "


/* Number of pixels between characters in a textured font.
 */
#define FONT_CHARACTER_SPACING 2

/* Uncomment to have the font generator dump screenshots of the textures it
 * generates.
 */
/* #define SAVE_FONT_SCREENSHOT */


static int agl_get_font_height(AL_CONST FONT *f);
static int agl_char_length(const FONT *f, int ch);
static int agl_text_length(const FONT *f, const char *str);

static int agl_get_font_ranges(FONT *f);
static int agl_get_font_range_begin(FONT *f, int range);
static int agl_get_font_range_end(FONT *f, int range);
static FONT *agl_extract_font_range(FONT *f, int start, int end);
static FONT *agl_merge_fonts(FONT *f1, FONT *f2);

#if GET_ALLEGRO_VERSION() >= MAKE_VER(4, 2, 0)
static int agl_transpose_font(FONT *f, int drange);
#endif


FONT_VTABLE _agl_font_vtable = {
    agl_get_font_height,
    agl_char_length,
    agl_text_length,
    NULL, /* render_char */
    NULL, /* render */
    allegro_gl_destroy_font,
    agl_get_font_ranges,
    agl_get_font_range_begin,
    agl_get_font_range_end,
    agl_extract_font_range,
    agl_merge_fonts,
#if GET_ALLEGRO_VERSION() >= MAKE_VER(4, 2, 0)
    agl_transpose_font
#endif
};


FONT_VTABLE *font_vtable_agl = &_agl_font_vtable;

static void aglf_convert_allegro_font_to_bitmap(FONT_AGL_DATA *dest, FONT *f,
                                                void *src, int *height);
static void aglf_convert_allegro_font_to_texture(FONT_AGL_DATA **dest, FONT *f,
                             void *src, int *height, float scale, GLint format);
static GLuint aglf_upload_texture(BITMAP *bmp, GLint format, int has_alpha);
static int aglf_check_texture(BITMAP *bmp, GLint format, int has_alpha);
static BITMAP* look_for_texture(int beg, int end, AGL_GLYPH *glyphs,
                                int max_w, int max_h, int total_area,
                                GLint format, int has_alpha);



union mixed_ptr {
    FONT_MONO_DATA* mf;
    FONT_COLOR_DATA* cf;
    void *ptr;
};


/* Stores info about a texture size */
typedef struct texture_size {
    int w, h;
} texture_size;



static int agl_get_font_height(AL_CONST FONT *f) {
    return f->height;
}


/* iroundf:
 * Round float to nearest integer, away from zero.
 */
static int iroundf(float v) {
    float f = floor(v);
    float c = ceil(v);

    if (v >= 0) {
        /* distance to ceil smaller than distance to floor */
        if ((c - v) < (v - f))
            return (int)c;
        else
            return (int)f;
    }
    else {
        /* distance to ceil smaller than distance to floor */
        if ((c - v) < (v - f)) 
            return (int)f;
        else
            return (int)c;
    }
}



/* agl_char_length_fractional:
 * Returns the width, in fractional pixels of the given character.
 */
static float agl_char_length_fractional(const FONT *f, int ch) {
    FONT_AGL_DATA *fad = f->data;

    if (fad->type == AGL_FONT_TYPE_TEXTURED) {
        while (fad) {
            if (ch >= fad->start && ch < fad->end) {
                AGL_GLYPH *coords = &(fad->glyph_coords[ch - fad->start]);
                return (coords->offset_x + coords->w + coords->offset_w)
                       / fabs(fad->scale);
            }

            fad = fad->next;
        }
    }
    else if (fad->type == AGL_FONT_TYPE_BITMAP) {
        while (fad) {
            if (ch >= fad->start && ch < fad->end) {
                FONT_GLYPH **gl = fad->data;
                return gl[ch - fad->start]->w;
            }

            fad = fad->next;
        }
    }

    /* if we don't find the character, then search for the missing
     * glyph, but don't get stuck in a loop. */
    if (ch != allegro_404_char)
        return agl_char_length_fractional(f, allegro_404_char);

    return 0;
}



/* agl_char_length:
 * font vtable entry
 * Returns the width, in pixels of the given character.
 */
static int agl_char_length(const FONT *f, int ch) {
    return iroundf(agl_char_length_fractional(f, ch));
}



/* agl_text_length:
 * font vtable entry
 * Returns the length, in pixels, of a string as rendered in a font.
 */
static int agl_text_length(const FONT *f, const char *str) {
    int ch = 0;
    float l = 0;
    const char *p = str;
    ASSERT(f);
    ASSERT(str);

    while ( (ch = ugetxc(&p)) ) {
        l += agl_char_length_fractional(f, ch);
    }

    return iroundf(l);
}



/* agl_get_font_ranges:
 * font vtable entry
 * Returns the number of character ranges in a font, or -1 if that information
 *   is not available.
 */
static int agl_get_font_ranges(FONT *f) {
    FONT_AGL_DATA *fad;
    int ranges = 0;

    if (!f)
        return 0;

    fad = (FONT_AGL_DATA*)(f->data);

    while (fad) {
        FONT_AGL_DATA *next = fad->next;

        ranges++;
        if (!next)
            return ranges;
        fad = next;
    }

    return -1;
}



/* agl_get_font_range_begin:
 * font vtable entry
 * Get first character for font.
 */
static int agl_get_font_range_begin(FONT *f, int range) {
    FONT_AGL_DATA *fad;
    int n = 0;

    if (!f || !f->data)
        return -1;

    if (range < 0)
        range = 0;

    fad = (FONT_AGL_DATA*)(f->data);
    while (fad && n <= range) {
        FONT_AGL_DATA *next = fad->next;

        if (!next || range == n)
            return fad->start;
        fad = next;
        n++;
    }

    return -1;
}



/* agl_get_font_range_end:
 * font vtable entry
 * Get last character for font range.
 */
static int agl_get_font_range_end(FONT *f, int range) {
    FONT_AGL_DATA* fad = 0;
    int n = 0;

    if (!f || !f->data)
        return -1;

    fad = (FONT_AGL_DATA*)(f->data);

    while (fad && (n <= range || range == -1)) {
        FONT_AGL_DATA *next = fad->next;
        if (!next || range == n)
            return fad->end - 1;
        fad = next;
        n++;
    }
    
    return -1;
}



/* Creates a call lists from given glyph coords. Returns list base.*/
static int create_textured_font_call_lists(AGL_GLYPH *coords, int max, BITMAP *bmp,
                                                    float scale, int *height) {
    GLuint list;
    int i;

    int rev = scale < 0 ? 1 : 0;
    scale = fabs(scale);

    list = glGenLists(max);
        
    for (i = 0; i < max; i++) {
        /* Coords of glyph in texture (texture coords) */
        float tx = (float)coords[i].x / bmp->w;
        float ty = 1.0 - (float)coords[i].y / bmp->h;
        /* Size of glyph in texture (texture coords) */
        float dtx = (float)(coords[i].w) / bmp->w;
        float dty = (float)(coords[i].h) / bmp->h;

        /* Offset to apply to glyph (output coords) */
        float xoffs = (float)coords[i].offset_x / scale;
        float yoffs = (float)coords[i].offset_y / scale;
        /* Size of rendered glyph (output coords) */
        float woffs = (float)coords[i].w / scale;
        float hoffs = (float)coords[i].h / scale;

        /* Size of overall screen character including dead space */
        float sizew = (float)(coords[i].offset_x + coords[i].w
                    + coords[i].offset_w) / scale;
        int sizeh = iroundf((coords[i].offset_y + coords[i].h
                    + coords[i].offset_h) / scale);

        if ((*height) < sizeh)
            *height = sizeh;

        if (rev) {
            hoffs = -hoffs;
            yoffs = -yoffs;
        }

        glNewList(list + i, GL_COMPILE);
            
        glBegin(GL_QUADS);
            glTexCoord2f(tx, ty);
            glVertex2f(xoffs, -yoffs);

            glTexCoord2f(tx + dtx, ty);
            glVertex2f(xoffs + woffs, -yoffs);

            glTexCoord2f(tx + dtx, ty - dty);
            glVertex2f(xoffs + woffs, -yoffs - hoffs);

            glTexCoord2f(tx, ty - dty);
            glVertex2f(xoffs, -yoffs - hoffs);
        glEnd();

        glTranslatef(sizew, 0, 0);

        glEndList();
    }

    return list;
}



/* copy_glyph_range:
 * Copies part of glyph range.
 */
static FONT_AGL_DATA* copy_glyph_range(FONT_AGL_DATA *fad, int start, int end,
                                                                int *height) {
    int i, count, w = 0, h = 0;
    AGL_GLYPH *coords;
    BITMAP *bmp, *srcbmp;
    FONT_AGL_DATA *newfad = NULL;

    if (fad->type != AGL_FONT_TYPE_TEXTURED)
        return NULL;

    count = end - start;

    coords = malloc(count * sizeof (AGL_GLYPH));
        
    /* for now, just copy glyph coords of the range */
    for (i = 0; i < count; i++) {
        coords[i] = fad->glyph_coords[start - fad->start + i];
        coords[i].glyph_num = i;
    }
            
    /* calculate the width of the glyphs and find the max height */ 
    for (i = 0; i < count; i++) {
        int hh = coords[i].h + coords[i].offset_y + coords[i].offset_h;
        if (h < hh)
            h = hh;
        w += coords[i].w + coords[i].offset_w + coords[i].offset_x;
    }

    srcbmp = (BITMAP*)fad->data;

    /* allocate a new bitmap to hold new glyphs */
    w = __allegro_gl_make_power_of_2(w);
    h = __allegro_gl_make_power_of_2(h);
    bmp = create_bitmap_ex(bitmap_color_depth(srcbmp), w, h);
    if (!bmp) {
        TRACE(PREFIX_E "copy_glyph_range: Unable to create bitmap of size"
                "%ix%i pixels!\n", w, h);
        free(coords);
        return NULL;
    }

    if (__allegro_gl_get_num_channels(fad->format) == 4) {
        clear_to_color(bmp, bitmap_mask_color(bmp));
    }
    else {
        clear_bitmap(bmp);
    }

    /* blit every glyph from the range to the new bitmap */
    w = 0;
    for (i = 0; i < count; i++) {
        int ch = start - fad->start + i;
        int ww = coords[i].w + coords[i].offset_w + coords[i].offset_x;
        blit(srcbmp, bmp, fad->glyph_coords[ch].x, 0, w, 0, ww, bmp->h);
        /* fix new glyphs coords while here */
        coords[i].x = w;
        w += ww;
    }

    newfad = malloc(sizeof(struct FONT_AGL_DATA));

    newfad->type = AGL_FONT_TYPE_TEXTURED;
    newfad->is_free_chunk = 0;
    newfad->scale = fad->scale;
    newfad->format = fad->format;
    newfad->has_alpha = fad->has_alpha;
    newfad->start = start;
    newfad->end = end;
    newfad->data = bmp;
    newfad->glyph_coords = coords;
    newfad->next = NULL;
    newfad->list_base = create_textured_font_call_lists(coords, count, bmp,
                                                    newfad->scale, height);
    newfad->texture = aglf_upload_texture(bmp, newfad->format, newfad->has_alpha);

    return newfad;
}



/* agl_extract_font_range:
 * font vtable entry
 * Extracts a glyph range from a given font and makes a new font of it.
 */
static FONT *agl_extract_font_range(FONT *f, int start, int end) {
    FONT *retval = NULL;
    FONT_AGL_DATA *fad, *next, *newfad = NULL;
    int count;

    if (!f)
        return NULL;

    /* check if range boundaries make sense */
    if (start == -1 && end == -1) {
    }
    else if (start == -1 && end > agl_get_font_range_begin(f, -1)) {
    }
    else if (end == -1 && start <= agl_get_font_range_end(f, -1)) {
    }
    else if (start <= end && start != -1 && end != -1) {
    }
    else
        return NULL;

    fad = (FONT_AGL_DATA*)f->data;

    /* only textured fonts are supported */
    if (fad->type != AGL_FONT_TYPE_TEXTURED)
        return NULL;

    /* anticipate invalid range values */
    start = MAX(start, agl_get_font_range_begin(f, -1));
    if (end > -1) {
        end = MIN(end, agl_get_font_range_end(f, -1));
    }
    else {
        end = agl_get_font_range_end(f, -1);
    }
    end++;

    retval = malloc(sizeof (struct FONT));
    retval->height = 0;
    retval->vtable = font_vtable_agl;

    next = fad;
    count = end - start;

    while (next) {
        /* find the range that is covered by the requested range
         * check if the requested and processed ranges at least overlap
         *    or if the requested range wraps processed range.
         */
        if ((start >= next->start && start < next->end)
         || (end   <= next->end   && end   > next->start)
         || (start <  next->start && end   > next->end)) {
            int local_start, local_end;

            /* extract the overlapping range */
            local_start = MAX(next->start, start);
            local_end = MIN(next->end, end);

            if (newfad) {
                newfad->next = copy_glyph_range(next, local_start, local_end,
                                                            &(retval->height));
                newfad = newfad->next;
                newfad->is_free_chunk = TRUE;
            }
            else {
                newfad = copy_glyph_range(next, local_start, local_end,
                                                            &(retval->height));
                retval->data = newfad;
            }
        }
            
        next = next->next;
    }

    return retval;
}



/* agl_merge_fonts:
 * font vtable entry
 * Merges f2 with f1 and returns a new font.
 */
static FONT *agl_merge_fonts(FONT *f1, FONT *f2) {
    FONT *retval;
    FONT_AGL_DATA *fad1, *fad2, *fad = NULL;
    int phony = 0;

    if (!f1 || !f2)
        return NULL;

    fad1 = (FONT_AGL_DATA*)f1->data;
    fad2 = (FONT_AGL_DATA*)f2->data;

    /* fonts must be textured and of the same format */
    if (fad1->type != AGL_FONT_TYPE_TEXTURED ||
        fad2->type != AGL_FONT_TYPE_TEXTURED)
        return NULL;

    if (fad1->format != fad2->format)
        return NULL;

    /* alloc output font */
    retval = malloc(sizeof(struct FONT));
    retval->vtable = font_vtable_agl;
    retval->height = MAX(f1->height, f2->height);

    while (fad1 || fad2) {
        if (fad1 && (!fad2 || fad1->start < fad2->start)) {
            if (fad) {
                fad->next = copy_glyph_range(fad1, fad1->start, fad1->end,
                                                                        &phony);
                fad = fad->next;
                fad->is_free_chunk = TRUE;
            }
            else {
                fad = copy_glyph_range(fad1, fad1->start, fad1->end, &phony);
                retval->data = fad;
            }
            fad1 = fad1->next;
        }
        else {
            if (fad) {
                fad->next = copy_glyph_range(fad2, fad2->start, fad2->end,
                                                                    &phony);
                fad = fad->next;
                fad->is_free_chunk = TRUE;
            }
            else {
                fad = copy_glyph_range(fad2, fad2->start, fad2->end, &phony);
                retval->data = fad;
            }
            fad2 = fad2->next;
        }
    }

    return retval;
}



#if GET_ALLEGRO_VERSION() >= MAKE_VER(4, 2, 0)
/* agl_transpose_font:
 * font vtable entry
 * Transposes characters in a font.
 */
static int agl_transpose_font(FONT *f, int drange) {
    FONT_AGL_DATA* fad = 0;

    if (!f)
        return -1;

    fad = (FONT_AGL_DATA*)(f->data);

    while(fad) {
        FONT_AGL_DATA* next = fad->next;
        fad->start += drange;
        fad->end += drange;
        fad = next;
    }

    return 0;
}
#endif



/* allegro_gl_convert_allegro_font_ex(FONT *f, int type, float scale, GLint format) */
FONT *allegro_gl_convert_allegro_font(FONT *f, int type, float scale) {
    GLint format = allegro_gl_get_texture_format(NULL);
    return allegro_gl_convert_allegro_font_ex(f, type, scale, format);
}



/* allegro_gl_convert_allegro_font_ex(FONT *f, int type, float scale, GLint format) */
FONT *allegro_gl_convert_allegro_font_ex(FONT *f, int type, float scale,
                                         GLint format) {
    int max = 0, height = 0;
    int i;
    FONT *dest;
    FONT_AGL_DATA *destdata;
    int has_alpha = 0;

    union {
        FONT_MONO_DATA* mf;
        FONT_COLOR_DATA* cf;
        void *ptr;
    } dat;
    
    if (!__allegro_gl_valid_context) {
        return NULL;
    }

    if (!f) {
        TRACE(PREFIX_E "convert_allegro_font: Null source\n");
        return NULL;
    }

    /* Make sure it's an Allegro font - we don't want any surprises */
#if GET_ALLEGRO_VERSION() >= MAKE_VER(4, 2, 1)
    if (f->vtable != font_vtable_mono && f->vtable != font_vtable_color && f->vtable != font_vtable_trans) {
#else
    if (f->vtable != font_vtable_mono && f->vtable != font_vtable_color) {
#endif
        TRACE(PREFIX_I "convert_allegro_font: Source font is not "
              "in Allegro format\n");
        return NULL;
    }

    /* No vector fonts allowed as destination */
    if (type == AGL_FONT_TYPE_OUTLINE) {
        /* Can't convert bitmap to vector font */
        TRACE(PREFIX_I "convert_allegro_font: Unable to convert a "
              "pixmap font to a vector font.\n");
        return NULL;
    }

    /* Make sure the scaling factor is appropreate */
    if (fabs(scale) < 0.001) {
        TRACE(PREFIX_W "convert_allegro_font: Scaling factor might be "
              "too small: %f\n", scale);
    }

    /* Count number of ranges */
    max = get_font_ranges(f);

    /* There should really be an API for this */
    dest = (FONT*)malloc(sizeof(FONT));
    if (!dest) {
        TRACE(PREFIX_E "convert_allegro_font: Ran out of memory "
              "while allocating %i bytes\n", (int)sizeof(FONT));
        return NULL;
    }
    destdata = (FONT_AGL_DATA*)malloc(sizeof(FONT_AGL_DATA) * max);
    if (!destdata) {
        TRACE(PREFIX_E "convert_allegro_font: Ran out of memory "
              "while allocating %i bytes\n", (int)sizeof(FONT_AGL_DATA) * max);
        return NULL;
    }
    memset(destdata, 0, sizeof(FONT_AGL_DATA) * max);
    
    /* Construct the linked list */
    for (i = 0; i < max - 1; i++) {
        destdata[i].next = &destdata[i + 1];
    }
    destdata[max - 1].next = NULL;
    
    /* Set up the font */
    dest->data = destdata;
    dest->vtable = font_vtable_agl;
    dest->height = 0;

    destdata->type = type;

    if (type == AGL_FONT_TYPE_DONT_CARE) {
        destdata->type = AGL_FONT_TYPE_TEXTURED;
    }

#if GET_ALLEGRO_VERSION() >= MAKE_VER(4, 2, 1)
    has_alpha = (f->vtable == font_vtable_trans);
#endif

    /* Convert each range */
    dat.ptr = f->data;

    while (dat.ptr) {

        destdata->has_alpha = has_alpha;

        if (type == AGL_FONT_TYPE_BITMAP) {
            aglf_convert_allegro_font_to_bitmap(destdata, f, dat.ptr, &height);
        }
        else if (type == AGL_FONT_TYPE_TEXTURED) {
            aglf_convert_allegro_font_to_texture(&destdata, f, dat.ptr, &height,
                                                 scale, format);
        }
            
        if (height > dest->height) {
            dest->height = height;
        }
            
        dat.ptr = (is_mono_font(f) ? (void*)dat.mf->next : (void*)dat.cf->next);
        
        destdata = destdata->next;
    }

    return dest;
}



/* QSort helper for sorting glyphs according to width,
 * then height - largest first.
 */
static int sort_glyphs(const void *c1, const void *c2) {
    AGL_GLYPH *g1 = (AGL_GLYPH*)c1;
    AGL_GLYPH *g2 = (AGL_GLYPH*)c2;
    
    if (g1->w < g2->w) {
        return 1;
    }
    else if (g1->w == g2->w) {
        return -g1->h + g2->h;
    }
    else {
        return -1;
    }
}



/* QSort helper for unsorting glyphs.
 */
static int unsort_glyphs(const void *c1, const void *c2) {
    AGL_GLYPH *g1 = (AGL_GLYPH*)c1;
    AGL_GLYPH *g2 = (AGL_GLYPH*)c2;
    
    return g1->glyph_num - g2->glyph_num;
}



/* QSort helper for sorting textures by area.
 */
static int sort_textures(const void *c1, const void *c2) {
    texture_size *t1 = (texture_size*)c1;
    texture_size *t2 = (texture_size*)c2;
    
    return t1->w * t1->h - t2->w * t2->h;
}



#ifdef SAVE_FONT_SCREENSHOT
static void save_shot(BITMAP *bmp) {

    int i;
    char name[128];

    for (i = 0; i < 1000; i++) {
        /* TGA, in case it is a truecolor font with alpha */
        sprintf(name, "fonttest_%02i.tga", i);
        if (!exists(name)) {
            save_tga(name, bmp, NULL);
            break;
        }
    }
}
#endif



/* Helper function. This will try to place all the glyphs in the bitmap the
 * best way it can
 */
static int aglf_sort_out_glyphs(BITMAP *bmp, AGL_GLYPH *glyphs, const int beg,
                                const int end) {

    int i, j;
    int last_line = 0;
    int last_x = 0;

    /* We now try to make all the glyphs fit on the bitmap */
    for (i = 0; i < end - beg; i++) {
        int collide = FALSE;
    
        /* Place glyphs on last_line */
        glyphs[i].x = last_x;
        glyphs[i].y = last_line;
        
        /* Check for collision */
        
        for (j = 0; j < i; j++) {
            if ((glyphs[i].x >= glyphs[j].x + glyphs[j].w)
                    || (glyphs[i].y >= glyphs[j].y + glyphs[j].h)
                    || (glyphs[j].x >= glyphs[i].x + glyphs[i].w)
                    || (glyphs[j].y >= glyphs[i].y + glyphs[i].h)) {
                continue;
            }
            last_x = glyphs[j].x + glyphs[j].w;
            glyphs[i].x = last_x;
            j = 0;
        }
        
        if ((last_x + glyphs[i].w > bmp->w)
         || (last_line + glyphs[i].h > bmp->h)) {
            collide = TRUE;
        }

        if (collide) {
            /* If there was a collision, we need to find the sprite with
             * the smallest height that is still grater than last_line.
             * We also need to redo this glyph.
             */
            int min_line = bmp->h + 1;
            int min_glyph = -1;

            for (j = 0; j < i; j++) {
                if ( glyphs[j].y + glyphs[j].h < min_line
                  && glyphs[j].y + glyphs[j].h
                  > last_line - FONT_CHARACTER_SPACING) {

                    min_line = glyphs[j].y + glyphs[j].h
                             + FONT_CHARACTER_SPACING;
                    min_glyph = j;
                }
            }
            /* If it can't possibly all fit, failure */
            if (min_glyph == -1) {
                TRACE(PREFIX_I "sort_out_glyphs: Unable to fit all glyphs into "
                      "the texture.\n");
                return FALSE;
            }
            /* Otherwise, start over at the top of that glyph */
            last_x = glyphs[min_glyph].x;
            last_line = min_line;

            /* Redo this glyph */
            i--;
        }
        else {
            last_x += glyphs[i].w + FONT_CHARACTER_SPACING;
        }
    }

    /* All ok */
    return TRUE;
}



static int split_font(FONT *f, void *source, void **dest1, void **dest2) {

    union mixed_ptr range1, range2, src;
    int colored;
    int i;
    
    (*dest1) = NULL;
    (*dest2) = NULL;
    src.ptr = source;
    
    colored = (is_mono_font(f) ? FALSE : TRUE);

    /* Allocate the ranges that we need */
    range1.ptr = malloc(colored ? sizeof(FONT_COLOR_DATA)
                                : sizeof(FONT_MONO_DATA));
    if (!range1.ptr) {
        TRACE(PREFIX_E "split_font() - Ran out of memory while "
              "trying ot allocate %i bytes.\n",
              colored ? (int)sizeof(FONT_COLOR_DATA)
              : (int)sizeof(FONT_MONO_DATA));
        return FALSE;
    }
    
    range2.ptr = malloc(colored ? sizeof(FONT_COLOR_DATA)
                                : sizeof(FONT_MONO_DATA));
    if (!range2.ptr) {
        TRACE(PREFIX_E "split_font() - Ran out of memory while "
              "trying to allocate %i bytes.\n",
              colored ? (int)sizeof(FONT_COLOR_DATA)
                      : (int)sizeof(FONT_MONO_DATA));
        free(range1.ptr);
        return FALSE;
    }
    
    (*dest1) = range1.ptr;
    (*dest2) = range2.ptr;
    
    /* Now we split up the range */
    if (colored) {
        /* Half the range */
        int mid = src.cf->begin + (src.cf->end - src.cf->begin) / 2;
        
        range1.cf->begin = src.cf->begin;
        range1.cf->end = mid;
        range2.cf->begin = mid;
        range2.cf->end = src.cf->end;
        
        range1.cf->next = NULL;
        range2.cf->next = NULL;
        
        /* Split up the bitmaps */
        range1.cf->bitmaps = malloc(sizeof(BITMAP*)
                                        * (range1.cf->end - range1.cf->begin));
        if (!range1.cf->bitmaps) {
            TRACE(PREFIX_E "split_font() - Ran out of memory "
                  "while trying to allocate %i bytes.\n",
                  (int)sizeof(BITMAP*) * (range1.cf->end - range1.cf->begin));
            free(range1.ptr);
            free(range2.ptr);
            return FALSE;
        }

        range2.cf->bitmaps = malloc(sizeof(BITMAP*)
                                         * (range2.cf->end - range2.cf->begin));
        if (!range2.cf->bitmaps) {
            TRACE(PREFIX_E "split_font() - Ran out of memory "
                  "while trying to allocate %i bytes.\n",
                  (int)sizeof(BITMAP*) * (range2.cf->end - range2.cf->begin));
            free(range1.cf->bitmaps);
            free(range1.ptr);
            free(range2.ptr);
            return FALSE;
        }

        
        for (i = 0; i < (range1.cf->end - range1.cf->begin); i++) {
            range1.cf->bitmaps[i] = src.cf->bitmaps[i];
        }
        for (i = 0; i < (range2.cf->end - range2.cf->begin); i++) {
            range2.cf->bitmaps[i] =
                       src.cf->bitmaps[i + range2.cf->begin - range1.cf->begin];
        }
    }
    else {
        /* Half the range */
        int mid = src.mf->begin + (src.mf->end - src.mf->begin) / 2;
        
        range1.mf->begin = src.mf->begin;
        range1.mf->end = mid;
        range2.mf->begin = mid;
        range2.mf->end = src.mf->end;
        
        range1.mf->next = NULL;
        range2.mf->next = NULL;
        
        /* Split up the bitmaps */
        range1.mf->glyphs = malloc(sizeof(FONT_GLYPH*)
                                         * (range1.mf->end - range1.mf->begin));
        if (!range1.mf->glyphs) {
            TRACE(PREFIX_E "split_font() - Ran out of memory "
                  "while trying to allocate %i bytes.\n",
                (int)sizeof(FONT_GLYPH*) * (range1.mf->end - range1.mf->begin));
            free(range1.ptr);
            free(range2.ptr);
            return FALSE;
        }

        range2.mf->glyphs = malloc(sizeof(FONT_GLYPH*)
                                         * (range2.mf->end - range2.mf->begin));
        if (!range2.mf->glyphs) {
            TRACE(PREFIX_E "split_font() - Ran out of memory "
                  "while trying to allocate %i bytes.\n",
                (int)sizeof(FONT_GLYPH*) * (range2.mf->end - range2.mf->begin));
            free(range1.mf->glyphs);
            free(range1.ptr);
            free(range2.ptr);
            return FALSE;
        }
        
        for (i = 0; i < (range1.mf->end - range1.mf->begin); i++) {
            range1.mf->glyphs[i] = src.mf->glyphs[i];
        }
        for (i = 0; i < (range2.mf->end - range2.mf->begin); i++) {
            range2.mf->glyphs[i] =
                        src.mf->glyphs[i + range2.mf->begin - range1.mf->begin];
        }
    }
    
    return TRUE;
}



/* Destroys a split font */
static void destroy_split_font(FONT *f, union mixed_ptr range1,
                                        union mixed_ptr range2) {
    
    if (!is_mono_font(f)) {
        free(range1.cf->bitmaps);
        free(range2.cf->bitmaps);
    }
    else {
        free(range1.mf->glyphs);
        free(range2.mf->glyphs);
    }
    
    free(range1.ptr);
    free(range2.ptr);
    
    return;
}



static int do_crop_font_range(FONT *f, AGL_GLYPH *glyphs, int beg, int end) {

    int i, j, k;
    int max = end - beg;
    char buf[32];

    /* Allocate a temp bitmap to work with */
    BITMAP *temp = create_bitmap(32, 32);

    if (!temp) {
        TRACE(PREFIX_E "crop_font_range - Unable to create "
              "bitmap of size: %ix%i!\n", 32, 32);
        goto error;
    }
    
    /* Crop glyphs */
    for (i = 0; i < max; i++) {
        int used = 0;

        if (glyphs[i].w > temp->w || glyphs[i].h > temp->h) {
            int old_w = temp->w, old_h = temp->h;
            destroy_bitmap(temp);
            temp = create_bitmap(old_w * 2, old_h * 2);
            if (!temp) {
                TRACE(PREFIX_E "crop_font_range - Unable to "
                      "create bitmap of size: %ix%i!\n", old_w * 2, old_h * 2);
                goto error;
            }
        }
        clear(temp);

        usetc(buf + usetc(buf, glyphs[i].glyph_num + beg), 0);

        textout_ex(temp, f, buf, 0, 0,
                    makecol_depth(bitmap_color_depth(temp), 255, 255, 255), 0);

        /* Crop top */
        for (j = 0; j < glyphs[i].h; j++) {
            used = 0;

            for (k = 0; k < glyphs[i].w; k++) {
                if (getpixel(temp, k, j)) {
                    used = 1;
                    glyphs[i].offset_y += j;
                    glyphs[i].h -= j;
                    break;
                }
            }
            if (used)
                break;
        }

        /* If just the top crop killed our glyph, then skip it entirely */
        if (!used) {
            TRACE(PREFIX_I "crop_font_range: skipping glyph %i\n", i);
            glyphs[i].offset_y = 0;
            glyphs[i].offset_h = glyphs[i].h - 1;
            glyphs[i].offset_w = glyphs[i].w - 2;
            glyphs[i].h = 1;
            glyphs[i].w = 1;
            continue;
        }
        
        /* Crop bottom */
        j = glyphs[i].h + glyphs[i].offset_y - 1;
        for ( /* above */; j >= glyphs[i].offset_y; j--) {
            used = 0;

            for (k = 0; k < glyphs[i].w; k++) {
                if (getpixel(temp, k, j)) {
                    used = 1;
                    glyphs[i].offset_h +=
                                       glyphs[i].h + glyphs[i].offset_y - j - 2;
                    glyphs[i].h -= glyphs[i].h + glyphs[i].offset_y - j - 1;
                    break;
                }
            }
            if (used)
                break;
        }

        /* Crop Left */
        for (j = 0; j < glyphs[i].w; j++) {
            used = 0;

            k = MAX(glyphs[i].offset_y - 1, 0);
            for (/* above */; k < glyphs[i].offset_y + glyphs[i].h + 1; k++) {
                if (getpixel(temp, j, k)) {
                    used = 1;
                    glyphs[i].offset_x += j;
                    glyphs[i].w -= j;
                    break;
                }
            }
            if (used)
                break;
        }

        /* Crop Right */
        j = glyphs[i].w + glyphs[i].offset_x - 1;
        for (/* above */; j >= glyphs[i].offset_x; j--) {
            used = 0;

            k = MAX(glyphs[i].offset_y - 1, 0);
            for (/* above */; k < glyphs[i].offset_y + glyphs[i].h + 1; k++) {
                if (getpixel(temp, j, k)) {
                    used = 1;
                    glyphs[i].offset_w +=
                                       glyphs[i].w + glyphs[i].offset_x - 1 - j;
                    glyphs[i].w -= glyphs[i].w + glyphs[i].offset_x - j - 1;
                    break;
                }
            }
            if (used)
                break;
        }
#ifdef LOGLEVEL
        TRACE(PREFIX_I "crop_font_range: Glyph %i (%c) offs: x: %i  y: %i, "
              "w: %i  h: %i,  offs: w: %i  h: %i\n", i, i + beg,
              glyphs[i].offset_x, glyphs[i].offset_y, glyphs[i].w, glyphs[i].h,
              glyphs[i].offset_w, glyphs[i].offset_h);
#endif
    }
    
    destroy_bitmap(temp);

    return TRUE;

error:
    if (temp) {
        destroy_bitmap(temp);
    }

    return FALSE;   
}



/* Crops a font over a particular range */
static int crop_font_range(FONT *f, void *src, int beg, int end,
                           AGL_GLYPH *glyphs,
                           int *net_area, int *gross_area,
                           int *max_w, int *max_h) {

    int i;
    int crop = 1;
    int max = end - beg;
    int ret = TRUE;

    union mixed_ptr dat;
    dat.ptr = src;

    /* Disable cropping for trucolor fonts. */
    if (is_color_font(f)) {
        FONT_COLOR_DATA *fcd = f->data;
        if (bitmap_color_depth(fcd->bitmaps[0]) != 8) {
            crop = 0;
        }
    }

    /* Load default sizes */
    for (i = 0; i < max; i++) {
        glyphs[i].glyph_num = i;

        if (is_mono_font(f)) {
            glyphs[i].w = dat.mf->glyphs[i]->w + 1;
            glyphs[i].h = dat.mf->glyphs[i]->h + 1;
        } else {
            glyphs[i].w = dat.cf->bitmaps[i]->w + 1;
            glyphs[i].h = dat.cf->bitmaps[i]->h + 1;
        }
        glyphs[i].offset_w = -1;
        glyphs[i].offset_h = -1;

        /* Not placed yet */
        glyphs[i].x = -1;
    }
    
    if (crop) {
        ret = do_crop_font_range(f, glyphs, beg, end);
    }

    (*gross_area) = 0;
    (*net_area) = 0;
    (*max_w) = 0;
    (*max_h) = 0;

    /* Find max w and h, total area covered by the bitmaps, and number of
     * glyphs
     */
    for (i = 0; i < max; i++) {
        if (glyphs[i].w > *max_w) (*max_w) = glyphs[i].w;
        if (glyphs[i].h > *max_h) (*max_h) = glyphs[i].h;
        (*net_area) += glyphs[i].w * glyphs[i].h;
        (*gross_area) += (glyphs[i].w + FONT_CHARACTER_SPACING)
                       * (glyphs[i].h + FONT_CHARACTER_SPACING);
    }
    return ret;

}



/* Tries to find a texture that will fit the font
 */
static BITMAP* look_for_texture(int beg, int end, AGL_GLYPH *glyphs,
            int max_w, int max_h, int total_area, GLint format, int has_alpha) {

    BITMAP *bmp = NULL;
    int i, j;

    /* Max texture size (1 << n) */
    /* XXX <rohannessian> We should use ARB_np2 if we can
     *
     * Other note: w*h shouldn't exceed 31 bits; otherwise, we get funny
     * behavior on 32-bit architectures. Limit texture sizes to 32k*32k
     * (30 bits).
     */
#define MIN_TEXTURE_SIZE 2
#define NUM_TEXTURE_SIZE 13
    texture_size texture_sizes[NUM_TEXTURE_SIZE * NUM_TEXTURE_SIZE];

    /* Set up texture sizes */
    for (i = 0; i < NUM_TEXTURE_SIZE; i++) {
        for (j = 0; j < NUM_TEXTURE_SIZE; j++) {
            texture_sizes[j + i * NUM_TEXTURE_SIZE].w =
                                                    1 << (j + MIN_TEXTURE_SIZE);
            texture_sizes[j + i * NUM_TEXTURE_SIZE].h =
                                                    1 << (i + MIN_TEXTURE_SIZE);
        }
    }

    /* Sort texture sizes by area */
    qsort(texture_sizes, NUM_TEXTURE_SIZE * NUM_TEXTURE_SIZE,
                                          sizeof(texture_size), &sort_textures);

    for (i = 0; i < NUM_TEXTURE_SIZE * NUM_TEXTURE_SIZE; i++) {
        int num_channels;
        
        /* Check the area - it must be larger than
         * all the glyphs
         */
        texture_size *t = &texture_sizes[i];
        int area = t->w * t->h;
        int depth = 24;

        if (area < total_area) {
            continue;
        }
            
        /* Check against max values */
        if ((t->h < max_h) || (t->w < max_w)) {
            continue;
        }

        TRACE(PREFIX_I "look_for_texture: candidate size: %ix%i\n", t->w, t->h);

        /* Check that the texture can, in fact, be created */
        num_channels = __allegro_gl_get_num_channels(format);
        if (num_channels == 1) {
            depth = 8;
        }
        else if (num_channels == 4) {
            depth = 32;
        }
        else {
            depth = 24;
        }
        bmp = create_bitmap_ex(depth, t->w, t->h);

        if (!bmp) {
            TRACE(PREFIX_W "look_for_texture: Out of memory while "
                  "creating bitmap\n");
            continue;
        }

        if (!aglf_check_texture(bmp, format, has_alpha)) {
            TRACE(PREFIX_I "look_for_texture: Texture rejected by driver\n");
            destroy_bitmap(bmp);
            bmp = NULL;
            continue;
        }

        /* Sort out the glyphs */
        TRACE(PREFIX_I "look_for_texture: Sorting on bmp: %p, beg: %i, "
              "end: %i\n", bmp, beg, end);

        if (aglf_sort_out_glyphs(bmp, glyphs, beg, end) == TRUE) {
            /* Success? */
            return bmp;
        }

        /* Failure? Try something else */
        TRACE(PREFIX_I "look_for_texture: Conversion failed\n");
        destroy_bitmap(bmp);
        bmp = NULL;
    }
    
    return NULL;
}



#if GET_ALLEGRO_VERSION() >= MAKE_VER(4, 2, 1)
/* This is only used to render chars from an Allegro font which has the
 * font_vtable_trans vtable. If the target is an 8-bit bitmap, only the alpha
 * channel is used. Otherwise, blit is used, to preserve the alpha channel.
 */
static int dummy_render_char(AL_CONST FONT* f, int ch, int fg, int bg,
    BITMAP* bmp, int x, int y)
{
    FONT_COLOR_DATA* cf = (FONT_COLOR_DATA*)(f->data);
    BITMAP *glyph = NULL;

    while(cf) {
        if(ch >= cf->begin && ch < cf->end) {
            glyph = cf->bitmaps[ch - cf->begin];
            break;
        }
        cf = cf->next;
    }

    if (glyph)
    {
        if (bitmap_color_depth(bmp) == 8) {
            int gx, gy;
            for (gy = 0; gy < bmp->h; gy++) {
                for (gx = 0; gx < bmp->w; gx++) {
                    int c = getpixel(glyph, gx, gy);
                    int a = geta(c);
                    putpixel(bmp, x + gx, y + gy, a);
                }
            }
        }
        else
            blit(glyph, bmp, 0, 0, x, y, glyph->w, glyph->h);
        return bmp->w;
    }
    return 0;
}
#endif



/* Function to draw a character in a bitmap for conversion */
static int draw_glyphs(BITMAP *bmp, FONT *f, GLint format, int beg, int end,
                       AGL_GLYPH *glyphs) {
    char buf[32];
    int i, j;

#if GET_ALLEGRO_VERSION() >= MAKE_VER(4, 2, 1)
    if (bitmap_color_depth(bmp) == 8 && f->vtable != font_vtable_trans) {
#else
    if (bitmap_color_depth(bmp) == 8) {
#endif
        /* Generate an alpha font */
        BITMAP *rgbbmp = create_bitmap_ex(24, bmp->w, bmp->h);
        
        if (!rgbbmp) {
            TRACE(PREFIX_E "convert_allegro_font_to_texture: "
                  "Ran out of memory while creating %ix%ix%i bitmap!\n",
                  bmp->w, bmp->h, 24);
            return FALSE;
        }

        clear_bitmap(rgbbmp);
        
        for (i = 0; i < end - beg; i++) {
            usetc(buf + usetc(buf, glyphs[i].glyph_num + beg), 0);
            
            textout_ex(rgbbmp, f, buf, glyphs[i].x - glyphs[i].offset_x,
                                      glyphs[i].y - glyphs[i].offset_y, -1, -1);
        }

        /* Convert back to 8bpp */
        for (j = 0; j < bmp->h; j++) {
            for (i = 0; i < bmp->w; i++) {
                int pix = _getpixel24(rgbbmp, i, j);
                int r = getr24(pix);
                int g = getg24(pix);
                int b = getb24(pix);
                int gray = (r * 77 + g * 150 + b * 28 + 255) >> 8;
                _putpixel(bmp, i, j, MID(0, gray, 255));
            }
        }
        destroy_bitmap(rgbbmp);
    }
    else {
#if GET_ALLEGRO_VERSION() >= MAKE_VER(4, 2, 1)
        int (*borrowed_color_vtable)(AL_CONST FONT*, int, int, int, BITMAP*, int, int) = NULL;

        //In order to keep the alpha channel in textout_ex we borrow
        //the color font vtable which uses maked_blit() instead of
        //draw_trans_sprite() to draw glyphs.
        if (f->vtable == font_vtable_trans) {
            borrowed_color_vtable = f->vtable->render_char;
            f->vtable->render_char = dummy_render_char;
        }
#endif

        if (__allegro_gl_get_num_channels(format) == 4) {
            clear_to_color(bmp, bitmap_mask_color(bmp));
        }
        else {
            clear_bitmap(bmp);
        }

        for (i = 0; i < end - beg; i++) {
            usetc(buf + usetc(buf, glyphs[i].glyph_num + beg), 0);
            textout_ex(bmp, f, buf, glyphs[i].x - glyphs[i].offset_x,
                     glyphs[i].y - glyphs[i].offset_y, -1, -1);
        }

#if GET_ALLEGRO_VERSION() >= MAKE_VER(4, 2, 1)
        if (borrowed_color_vtable) {
            f->vtable->render_char = borrowed_color_vtable;
        }
#endif
    }

    return TRUE;
}



/* Converts a single font range to a texture.
 * dest - Receives the result.
 * f - The original font.
 * src - The original font data.
 */
static void aglf_convert_allegro_font_to_texture(FONT_AGL_DATA **dest, FONT *f,
                            void *src, int *height, float scale, GLint format) {

    int max = 0;
    BITMAP *bmp = NULL;
    int beg = 0, end = 0;
    int max_w, max_h;
    int total_area, gross_area;
    
    AGL_GLYPH *glyph_coords;

    union mixed_ptr dat;
    dat.ptr = src;

    if (is_mono_font(f)) {
        beg = dat.mf->begin;
        end = dat.mf->end;
        max = dat.mf->end - dat.mf->begin;
        if (format == -1) {
            format = GL_INTENSITY4;
        }
    }
    else if (is_color_font(f)) {
        beg = dat.cf->begin;
        end = dat.cf->end;
        max = dat.cf->end - dat.cf->begin;
        if (format == -1) {
#if GET_ALLEGRO_VERSION() >= MAKE_VER(4, 2, 1)
            format = (f->vtable == font_vtable_trans ? GL_RGBA8 : GL_RGB8);
#else
            format = GL_RGB8;
#endif
        }
    }

    /* Allocate glyph sizes */
    glyph_coords = malloc(max * sizeof(AGL_GLYPH));
    memset(glyph_coords, 0, max * sizeof(AGL_GLYPH));

    if (crop_font_range(f, dat.ptr, beg, end, glyph_coords,
                          &total_area, &gross_area, &max_w, &max_h) == FALSE) {
        TRACE(PREFIX_I "convert_allegro_font_to_texture: Unable to crop font "
              "range\n");
        free(glyph_coords);
        return;
    }

    TRACE(PREFIX_I "convert_allegro_font_to_texture: Total area of glyphs: "
          "%i pixels (%i pixels gross) - max_w: %i, max_h: %i\n",
          total_area, gross_area, max_w, max_h);

    /* Sort glyphs by width, then height */
    qsort(glyph_coords, end - beg, sizeof(AGL_GLYPH), &sort_glyphs);


    /* Now, we look for the appropriate texture size */
    bmp = look_for_texture(beg, end, glyph_coords, max_w, max_h,
                           total_area, format, (*dest)->has_alpha);

    /* No texture sizes were found - we should split the font up */
    if (!bmp) {
        int height1;
        union mixed_ptr f1, f2;
        FONT_AGL_DATA *dest1, *dest2;

        free(glyph_coords);

        dest1 = *(dest);
        dest2 = malloc(sizeof(FONT_AGL_DATA));

        if (!dest2) {
            TRACE(PREFIX_E "convert_allegro_font_to_texture: "
                  "Out of memory while trying to allocate %i bytes.\n",
                  (int)sizeof(FONT_AGL_DATA));
            return;
        }

        memset(dest2, 0, sizeof(FONT_AGL_DATA));

        dest2->next = dest1->next;
        dest1->next = dest2;
        dest2->is_free_chunk = TRUE;
        dest2->format = dest1->format;
        dest2->has_alpha = dest1->has_alpha;
        
        if (split_font(f, dat.ptr, &f1.ptr, &f2.ptr) == FALSE) {
            TRACE(PREFIX_E "convert_allegro_font_to_texture: Unable "
                  "to split font!\n");
            dest1->next = dest2->next;
            free(dest2);
            return;
        }
        
        aglf_convert_allegro_font_to_texture(&dest1, f, f1.ptr, height, scale,
                                             format);
        height1 = (*height);
        aglf_convert_allegro_font_to_texture(&dest2, f, f2.ptr, height, scale,
                                             format);
        destroy_split_font(f, f1, f2);

        if (height1 > (*height))
            (*height) = height1;
        (*dest) = dest2;
        
        return;
    }

    TRACE(PREFIX_I "convert_allegro_font_to_texture: Using texture "
          "%ix%ix%i for font conversion.\n", bmp->w, bmp->h,
          bitmap_color_depth(bmp));

    /* Now that all the glyphs are in place, we draw them into the bitmap */
    if (draw_glyphs(bmp, f, format, beg, end, glyph_coords) == FALSE) {
        destroy_bitmap(bmp);
        free(glyph_coords);
        return;
    }

    /* Un-Sort glyphs  */
    qsort(glyph_coords, end - beg, sizeof(AGL_GLYPH), &unsort_glyphs);

#if (defined SAVE_FONT_SCREENSHOT)
        save_shot(bmp);
#endif

    (*dest)->list_base =
             create_textured_font_call_lists(glyph_coords, max, bmp,
                                             scale, height);

    (*dest)->texture = aglf_upload_texture(bmp, format, (*dest)->has_alpha);
    (*dest)->type = AGL_FONT_TYPE_TEXTURED;
    (*dest)->format = format;
    (*dest)->scale = scale;
    (*dest)->start = beg;
    (*dest)->end = end;
    (*dest)->data = bmp;
    (*dest)->glyph_coords = glyph_coords;

    return;
}



static void aglf_convert_allegro_font_to_bitmap(FONT_AGL_DATA *dest, FONT *f,
                                                       void *src, int *height) {

    int max = 0;
    int i, j, k;
    int beg = 0, end = 0;
    int mask;
    FONT_GLYPH **glyph;

    union {
        FONT_MONO_DATA* mf;
        FONT_COLOR_DATA* cf;
        void *ptr;
    } dat;

    dat.ptr = src;

    if (is_mono_font(f))
        max = dat.mf->end - dat.mf->begin;
    else if (is_color_font(f))
        max = dat.cf->end - dat.cf->begin;
    else
        return;

    glyph = malloc(sizeof(FONT_GLYPH*) * max);

    if (!glyph) {
        TRACE(PREFIX_E "convert_allegro_font_to_bitmap: Ran out of "
              "memory while allocating %i bytes\n", (int)sizeof(FONT_GLYPH));
        return;
    }
    
    *height = f->height;
        
    if (is_mono_font(f)) {      
    
        /* for each glyph */
        for (i = 0; i < max; i++) {     
            FONT_GLYPH *oldgl = dat.mf->glyphs[i];
    
            int size = sizeof(FONT_GLYPH) + ((oldgl->w + 31) / 32) * 4
                                                                     * oldgl->h;
    
            /* create new glyph */
            FONT_GLYPH *newgl = (FONT_GLYPH*)malloc(size);
    
            if (!newgl)
                break;
    
            memset(newgl, 0, size);
    
            newgl->w = oldgl->w;
            newgl->h = oldgl->h;

            /* update the data */
            for (j = 0; j < oldgl->h; j++) {
                for (k = 0; k < ((oldgl->w + 7) / 8); k++) {
                    int addr = (oldgl->h - j - 1) * ((oldgl->w + 31) / 32) * 4
                               + k;
                    newgl->dat[addr] = oldgl->dat[j * ((oldgl->w + 7) / 8) + k];
                }
            }

            glyph[i] = newgl;
        }
    }
    /* Reduce to 1 bit */
    else if (is_color_font(f)) {
        /* for each glyph */
        for (i = 0; i < max; i++) {

            int size;
            BITMAP *oldgl = dat.cf->bitmaps[i];
            FONT_GLYPH *newgl;

            mask = bitmap_mask_color(oldgl);

            size = sizeof(FONT_GLYPH) + ((oldgl->w + 31) / 32) * 4 * oldgl->h;

            /* create new glyph */
            newgl = (FONT_GLYPH*)malloc(size);

            if (!newgl)
                break;

            memset(newgl, 0, size);

            newgl->w = oldgl->w;
            newgl->h = oldgl->h;

            /* update the data */
            for (j = 0; j < oldgl->h; j++) {
                for (k = 0; k < oldgl->w; k++) {
                    int addr = (oldgl->h - j - 1) * ((oldgl->w + 31) / 32) * 4
                             + (k / 8);
                    newgl->dat[addr] |= (getpixel(oldgl, k, j) == mask)
                                     ? 0 : (1 << (k & 7));
                }
            }

            glyph[i] = newgl;
        }
    }
    /* Create call lists */
    {
        GLuint list = glGenLists(max);

        for (i = 0; i < max; i++) {
            glNewList(list + i, GL_COMPILE);

            glBitmap(glyph[i]->w, glyph[i]->h, 0, 0, glyph[i]->w, 0,
                     glyph[i]->dat);

            glEndList();
        }
        dest->list_base = list;
    }
        
    dest->is_free_chunk = 0;
    dest->type = AGL_FONT_TYPE_BITMAP;
    dest->start = beg;
    dest->end = end;
    dest->data = glyph;

    return;
}



static int aglf_check_texture(BITMAP *bmp, GLint format, int has_alpha) {

    int flags = AGL_TEXTURE_FLIP | AGL_TEXTURE_MIPMAP;

    if (format == GL_ALPHA4 || format == GL_ALPHA8 || format == GL_ALPHA
     || format == GL_INTENSITY4 || format == GL_INTENSITY8
     || format == GL_INTENSITY
     || format == GL_LUMINANCE4 || format == GL_LUMINANCE8
     || format == GL_LUMINANCE
     || format == 1) {
        flags |= AGL_TEXTURE_ALPHA_ONLY;
    }
    else if (format == GL_RGBA8) {
        if (has_alpha) {
            flags |= AGL_TEXTURE_HAS_ALPHA;
        }
        else {
            flags |= AGL_TEXTURE_MASKED;
        }
    }

    return allegro_gl_check_texture_ex(flags, bmp, format);
}



static GLuint aglf_upload_texture(BITMAP *bmp, GLint format, int has_alpha) {

    int flags = AGL_TEXTURE_FLIP | AGL_TEXTURE_MIPMAP;
    GLuint texture;

    if (format == GL_ALPHA4 || format == GL_ALPHA8 || format == GL_ALPHA
     || format == GL_INTENSITY4 || format == GL_INTENSITY8
     || format == GL_INTENSITY
     || format == GL_LUMINANCE4 || format == GL_LUMINANCE8
     || format == GL_LUMINANCE
     || format == 1) {
        flags |= AGL_TEXTURE_ALPHA_ONLY;
    }
    else if (__allegro_gl_get_num_channels(format) == 4) {
        if (has_alpha) {
            flags |= AGL_TEXTURE_HAS_ALPHA;
        }
        else {
            flags |= AGL_TEXTURE_MASKED;
        }
    }

    TRACE(PREFIX_I "Want texture format: %s\n",
        __allegro_gl_get_format_description(format));
    texture = allegro_gl_make_texture_ex(flags, bmp, format);
    TRACE(PREFIX_I "Texture ID is: %u\n", texture);

    return texture;
}

---