windows-xp/Source/XPSP1/NT/base/ntsetup/mpk/displib/font.c

#include <dos.h>
#include <share.h>
#include <stddef.h>
#include <malloc.h>
#include <string.h>

#include <mytypes.h>
#include <misclib.h>
#include <displib.h>

#include "bootfont.h"

//
// The following structures and constants are used in font files:
// DOS image header
// OS/2 image header
// OS/2 executable resource information structure
// OS/2 executable resource name information structure
//

typedef struct _IMAGE_DOS_HEADER {      // DOS .EXE header
    USHORT e_magic;                     // Magic number
    USHORT e_cblp;                      // Bytes on last page of file
    USHORT e_cp;                        // Pages in file
    USHORT e_crlc;                      // Relocations
    USHORT e_cparhdr;                   // Size of header in paragraphs
    USHORT e_minalloc;                  // Minimum extra paragraphs needed
    USHORT e_maxalloc;                  // Maximum extra paragraphs needed
    USHORT e_ss;                        // Initial (relative) SS value
    USHORT e_sp;                        // Initial SP value
    USHORT e_csum;                      // Checksum
    USHORT e_ip;                        // Initial IP value
    USHORT e_cs;                        // Initial (relative) CS value
    USHORT e_lfarlc;                    // File address of relocation table
    USHORT e_ovno;                      // Overlay number
    USHORT e_res[4];                    // Reserved words
    USHORT e_oemid;                     // OEM identifier (for e_oeminfo)
    USHORT e_oeminfo;                   // OEM information; e_oemid specific
    USHORT e_res2[10];                  // Reserved words
    ULONG  e_lfanew;                    // File address of new exe header
} IMAGE_DOS_HEADER;

#define IMAGE_DOS_SIGNATURE 0x5A4D      // MZ

typedef struct _IMAGE_OS2_HEADER {      // OS/2 .EXE header
    USHORT ne_magic;                    // Magic number
    CHAR   ne_ver;                      // Version number
    CHAR   ne_rev;                      // Revision number
    USHORT ne_enttab;                   // Offset of Entry Table
    USHORT ne_cbenttab;                 // Number of bytes in Entry Table
    long   ne_crc;                      // Checksum of whole file
    USHORT ne_flags;                    // Flag word
    USHORT ne_autodata;                 // Automatic data segment number
    USHORT ne_heap;                     // Initial heap allocation
    USHORT ne_stack;                    // Initial stack allocation
    long   ne_csip;                     // Initial CS:IP setting
    long   ne_sssp;                     // Initial SS:SP setting
    USHORT ne_cseg;                     // Count of file segments
    USHORT ne_cmod;                     // Entries in Module Reference Table
    USHORT ne_cbnrestab;                // Size of non-resident name table
    USHORT ne_segtab;                   // Offset of Segment Table
    USHORT ne_rsrctab;                  // Offset of Resource Table
    USHORT ne_restab;                   // Offset of resident name table
    USHORT ne_modtab;                   // Offset of Module Reference Table
    USHORT ne_imptab;                   // Offset of Imported Names Table
    long   ne_nrestab;                  // Offset of Non-resident Names Table
    USHORT ne_cmovent;                  // Count of movable entries
    USHORT ne_align;                    // Segment alignment shift count
    USHORT ne_cres;                     // Count of resource segments
    UCHAR  ne_exetyp;                   // Target Operating system
    UCHAR  ne_flagsothers;              // Other .EXE flags
    USHORT ne_pretthunks;               // offset to return thunks
    USHORT ne_psegrefbytes;             // offset to segment ref. bytes
    USHORT ne_swaparea;                 // Minimum code swap area size
    USHORT ne_expver;                   // Expected Windows version number
} IMAGE_OS2_HEADER;

#define IMAGE_OS2_SIGNATURE 0x454E      // NE


typedef struct _RESOURCE_TYPE_INFORMATION {
    USHORT Ident;
    USHORT Number;
    long   Proc;
} RESOURCE_TYPE_INFORMATION;

#define FONT_DIRECTORY 0x8007
#define FONT_RESOURCE 0x8008

typedef struct _RESOURCE_NAME_INFORMATION {
    USHORT Offset;
    USHORT Length;
    USHORT Flags;
    USHORT Ident;
    USHORT Handle;
    USHORT Usage;
} RESOURCE_NAME_INFORMATION;

#pragma pack(1)
typedef struct _OEM_FONT_FILE_HEADER {
    USHORT Version;
    ULONG FileSize;
    UCHAR Copyright[60];
    USHORT Type;
    USHORT Points;
    USHORT VerticalResolution;
    USHORT HorizontalResolution;
    USHORT Ascent;
    USHORT InternalLeading;
    USHORT ExternalLeading;
    UCHAR Italic;
    UCHAR Underline;
    UCHAR StrikeOut;
    USHORT Weight;
    UCHAR CharacterSet;
    USHORT PixelWidth;
    USHORT PixelHeight;
    UCHAR Family;
    USHORT AverageWidth;
    USHORT MaximumWidth;
    UCHAR FirstCharacter;
    UCHAR LastCharacter;
    UCHAR DefaultCharacter;
    UCHAR BreakCharacter;
    USHORT WidthInBytes;
    ULONG Device;
    ULONG Face;
    ULONG BitsPointer;
    ULONG BitsOffset;
    UCHAR Filler;
} OEM_FONT_FILE_HEADER;
#pragma pack()

#define OEM_FONT_VERSION 0x200
#define OEM_FONT_TYPE 0
#define OEM_FONT_CHARACTER_SET 255
#define OEM_FONT_FAMILY (3 << 4)
#define FONT_WIDTH 8

typedef struct _FONT_CHAR {
    USHORT Width;
    USHORT Offset;
} FONT_CHAR;


union {
    IMAGE_DOS_HEADER DosHeader;
    IMAGE_OS2_HEADER Os2Header;
    OEM_FONT_FILE_HEADER FontHeader;
    RESOURCE_TYPE_INFORMATION ResourceType;
    RESOURCE_NAME_INFORMATION ResourceName;
    BOOTFONTBIN_HEADER BfbHeader;
} FontHeaders;

FONT_CHAR *FontCharMap;
BYTE *FontCharData;
unsigned FontDataBaseOffset;
BYTE GlyphHeight;

BYTE FontFirstChar,FontLastChar,FontDefaultChar;

BYTE TopPad,BottomPad;

unsigned BootfontFileHandle = (unsigned)(-1);
UCHAR PendingLeadByte;
unsigned SbcsCharCount;
unsigned DbcsCharCount;
ULONG SbcsFileOffset;
ULONG DbcsFileOffset;

#define DBCS_FIRST_LEAD     0x81
#define DBCS_LAST_LEAD      0xfe
#define DBCS_FIRST_TRAIL    0x40
#define DBCS_LAST_TRAIL     0xfe

//
// HACK: the only place this lib is used is with enduser,
// which already has the table of bit values we want.
// Save the 8 bytes and use them.
//
extern BYTE BitValue[8];
BYTE LeadByteTable[128/8];     // 128 bits
unsigned *DbcsCharOrdinalOffsetTable;
unsigned *SbcsCharOrdinalOffsetTable;
unsigned *FontCacheTable;
BYTE *FontCache;
unsigned NextCacheSlot;

#define FONT_CACHE_CAPACITY 750


BOOL
LoadBootfontBin(
    IN unsigned FileHandle,
    IN ULONG    FileSize
    );

VOID
UnloadBootfontBin(
    VOID
    );

VOID
FontWriteBfbChar(
    IN UCHAR  c,
    IN USHORT x,
    IN USHORT y,
    IN BYTE   ForegroundPixelValue,
    IN BYTE   BackgroundPixelValue
    );


BOOL
_far
FontLoadAndInit(
    IN FPCHAR Filename
    )
{
    BOOL b;
    ULONG FileSize;
    unsigned FileHandle;
    unsigned Count;
    int ScaleFactor;
    unsigned Offset,TableEndOffset;
    FONT_CHAR *map;
    unsigned hi,lo;
    FPVOID data;


    b = FALSE;

    //
    // Open the file and determine its size.
    //
    if(_dos_open(Filename,SH_DENYWR,&FileHandle)) {
        goto c0;
    }

    if(((FileSize = DosSeek(FileHandle,0,DOSSEEK_END)) == -1)
    || DosSeek(FileHandle,0,DOSSEEK_START)) {

        goto c1;
    }

    //
    // Read the DOS header.
    //
    if(_dos_read(FileHandle,&FontHeaders.DosHeader,sizeof(IMAGE_DOS_HEADER),&Count)
    || (Count != sizeof(IMAGE_DOS_HEADER))) {

        goto c1;
    }

    //
    // Special check for bootfont.bin-style font.
    //
    if(((BOOTFONTBIN_HEADER *)&FontHeaders.DosHeader)->Signature == BOOTFONTBIN_SIGNATURE) {
        return(LoadBootfontBin(FileHandle,FileSize));
    }

    //
    // Cap file size to something reasonable (and that fits in a
    // 16 bit value).
    //
    if(FileSize > 60000) {
        goto c1;
    }

    //
    // Basic header check.
    //
    if((FontHeaders.DosHeader.e_magic != IMAGE_DOS_SIGNATURE)
    || (FontHeaders.DosHeader.e_lfanew < sizeof(IMAGE_DOS_HEADER))) {

        goto c1;
    }

    //
    // Retrieve some info from the dos header before overwriting it.
    //
    Offset = (unsigned)FontHeaders.DosHeader.e_lfanew;

    //
    // Read the OS/2 header and make sure the resource table exists.
    //
    if((DosSeek(FileHandle,FontHeaders.DosHeader.e_lfanew,DOSSEEK_START) != FontHeaders.DosHeader.e_lfanew)
    || _dos_read(FileHandle,&FontHeaders.Os2Header,sizeof(IMAGE_OS2_HEADER),&Count)
    || (Count != sizeof(IMAGE_OS2_HEADER))
    || (FontHeaders.Os2Header.ne_magic != IMAGE_OS2_SIGNATURE)
    || (FontHeaders.Os2Header.ne_restab > 65535L)
    || (FontHeaders.Os2Header.ne_rsrctab > 65535L)
    || !(FontHeaders.Os2Header.ne_restab - FontHeaders.Os2Header.ne_rsrctab)) {

        goto c1;
    }

    //
    // Search for font resource.
    //
    TableEndOffset = Offset;
    Offset += (unsigned)FontHeaders.Os2Header.ne_rsrctab;
    TableEndOffset += (unsigned)FontHeaders.Os2Header.ne_restab;

    if((DosSeek(FileHandle,Offset,DOSSEEK_START) != Offset)
    || _dos_read(FileHandle,&ScaleFactor,2,&Count)
    || (Count != 2)) {

        goto c1;
    }

    Offset += 2;   // skip scale factor

    FontHeaders.ResourceType.Ident = 0;

    while(Offset < TableEndOffset) {

        if((DosSeek(FileHandle,Offset,DOSSEEK_START) != Offset)
        || _dos_read(FileHandle,&FontHeaders.ResourceType,sizeof(RESOURCE_TYPE_INFORMATION),&Count)
        || (Count != sizeof(RESOURCE_TYPE_INFORMATION))) {
            goto c1;
        }

        if(FontHeaders.ResourceType.Ident == FONT_RESOURCE) {
            break;
        }

        Offset += sizeof(RESOURCE_TYPE_INFORMATION)
                        + (FontHeaders.ResourceType.Number * sizeof(RESOURCE_NAME_INFORMATION));

    }

    if(FontHeaders.ResourceType.Ident != FONT_RESOURCE) {
        goto c1;
    }

    //
    // Get to resource name information.
    //
    Offset += sizeof(RESOURCE_TYPE_INFORMATION);
    if((DosSeek(FileHandle,Offset,DOSSEEK_START) != Offset)
    || _dos_read(FileHandle,&FontHeaders.ResourceName,sizeof(RESOURCE_NAME_INFORMATION),&Count)
    || (Count != sizeof(RESOURCE_NAME_INFORMATION))) {

        goto c1;
    }

    //
    // Read the oem font file header and validate it. We don't read the
    // table map in this part, we read that later.
    //
    Offset = FontHeaders.ResourceName.Offset << ScaleFactor;

    if((DosSeek(FileHandle,Offset,DOSSEEK_START) != Offset)
    || _dos_read(FileHandle,&FontHeaders,sizeof(OEM_FONT_FILE_HEADER),&Count)
    || (Count != sizeof(OEM_FONT_FILE_HEADER))
    || (FontHeaders.FontHeader.Version != OEM_FONT_VERSION)
    || (FontHeaders.FontHeader.Type != OEM_FONT_TYPE)
    || FontHeaders.FontHeader.Italic
    || FontHeaders.FontHeader.Underline
    || FontHeaders.FontHeader.StrikeOut
    || (FontHeaders.FontHeader.CharacterSet != OEM_FONT_CHARACTER_SET)
    || (FontHeaders.FontHeader.Family != OEM_FONT_FAMILY)
    || (FontHeaders.FontHeader.PixelWidth != FONT_WIDTH)
    || (FontHeaders.FontHeader.PixelHeight > 16 )) {

        goto c1;
    }

    //
    // Allocate memory for the mapping table and read it in.
    //
    FileSize = (FontHeaders.FontHeader.LastCharacter - FontHeaders.FontHeader.FirstCharacter) + 1;
    map = malloc((unsigned)FileSize * sizeof(FONT_CHAR));
    if(!map) {
        goto c1;
    }

    if(_dos_read(FileHandle,map,(unsigned)FileSize*sizeof(FONT_CHAR),&Count)
    || (Count != ((unsigned)FileSize*sizeof(FONT_CHAR)))) {
        goto c2;
    }

    //
    // Find the lowest and highest offsets to determine where the file data is.
    //
    hi = 0;
    lo = (unsigned)(-1);

    for(Count=0; Count<(unsigned)FileSize; Count++) {

        if(map[Count].Offset < lo) {
            lo = map[Count].Offset;
        }

        if(map[Count].Offset > hi) {
            hi = map[Count].Offset;
        }
    }

    FileSize = (unsigned)((hi - lo) + FontHeaders.FontHeader.PixelHeight);

    data = malloc((unsigned)FileSize);
    if(!data) {
        goto c2;
    }

    Offset += lo;

    if((DosSeek(FileHandle,Offset,DOSSEEK_START) != Offset)
    || _dos_read(FileHandle,data,(unsigned)FileSize,&Count)
    || (Count != (unsigned)FileSize)) {

        goto c3;
    }

    if(FontCharMap) {
        free(FontCharMap);
    }
    FontCharMap = map;

    if(FontCharData) {
        free(FontCharData);
    }
    FontCharData = data;

    FontDataBaseOffset = lo;

    GlyphHeight = (BYTE)FontHeaders.FontHeader.PixelHeight;
    FontFirstChar = FontHeaders.FontHeader.FirstCharacter;
    FontLastChar = FontHeaders.FontHeader.LastCharacter;
    FontDefaultChar = FontHeaders.FontHeader.DefaultCharacter;

    TopPad = 1;
    BottomPad = 1;

    if(BootfontFileHandle != (unsigned)(-1)) {
        UnloadBootfontBin();
    }

    b = TRUE;

c3:
    if(!b) {
        free(data);
    }
c2:
    if(!b) {
        free(map);
    }
c1:
    _dos_close(FileHandle);
c0:
    return(b);
}


BOOL
LoadBootfontBin(
    IN unsigned FileHandle,
    IN ULONG    FileSize
    )

/*++

Routine Description:

    This routine loads and initializes a font file in NT setup's
    bootfont.bin format.

Arguments:

    FileHandle - supplies DOS file handle of file.

    FileSize - supplies size of file in bytes.

Return Value:

    Boolean value indicating outcome. If TRUE, the file handle
    will be left open. If FALSE the file handle will have been closed.

--*/

{
    BOOL b;
    unsigned Count;
    unsigned i;
    unsigned MaxChars,CharsLeft;
    unsigned BytesPerChar;
    unsigned index;
    unsigned ordinal;
    unsigned nextslot;
    FPBYTE p;
    FPBYTE ScratchBuffer;
    unsigned *Table1,*Table2,*Table3;
    BYTE *cache;
    unsigned CacheOrd;

    b = FALSE;

    //
    // Rewind the file and read the header.
    //
    if(DosSeek(FileHandle,0,DOSSEEK_START)
    || _dos_read(FileHandle,&FontHeaders.BfbHeader,sizeof(BOOTFONTBIN_HEADER),&Count)
    || (Count != sizeof(BOOTFONTBIN_HEADER))) {

        goto c1;
    }

    //
    // Basic checks.
    //
    if((FontHeaders.BfbHeader.CharacterImageSbcsWidth != FONT_WIDTH)
    || (FontHeaders.BfbHeader.CharacterImageDbcsWidth != (2*FONT_WIDTH))) {

        goto c1;
    }

    //
    // Make sure the DBCS table looks good. No ranges can be in ASCII range,
    // the ranges must be legal (ie, end greater than start), and the table
    // must be terminated with a pair of 0s.
    //
    for(Count=0;
        FontHeaders.BfbHeader.DbcsLeadTable[Count]
     && FontHeaders.BfbHeader.DbcsLeadTable[Count+1]
     && (Count < (2*MAX_DBCS_RANGE));
        Count+=2) {

        if((FontHeaders.BfbHeader.DbcsLeadTable[Count] < DBCS_FIRST_LEAD)
        || (FontHeaders.BfbHeader.DbcsLeadTable[Count+1] < DBCS_FIRST_LEAD)
        || (FontHeaders.BfbHeader.DbcsLeadTable[Count] > DBCS_LAST_LEAD)
        || (FontHeaders.BfbHeader.DbcsLeadTable[Count+1] > DBCS_LAST_LEAD)
        || (FontHeaders.BfbHeader.DbcsLeadTable[Count] > FontHeaders.BfbHeader.DbcsLeadTable[Count+1])) {

            goto c1;
        }
    }

    if(FontHeaders.BfbHeader.DbcsLeadTable[Count]
    || FontHeaders.BfbHeader.DbcsLeadTable[Count+1]) {

        goto c1;
    }

    //
    // Now we build a table of characters and offset numbers
    // into the file, indexed by character value. The theoretical
    // maximum number of DBCS chars is when all of 81-fe are leads and
    // each of 40-fe are trails for each lead byte; 7e * bf = 5e02 (24066)
    // separate DBCS characters. (Actually 7f is not a valid trail byte but
    // that only shaves 126 chars off the total, which not worth the headache.)
    // Each character requires 2 bytes for an ordinal number in the font file,
    // which gives a theoretical maximum table size of bc04 bytes. Mercifully
    // this is much less than the malloc max of ffe8 bytes.
    //
    // We do something similar for the SBCS case also.
    //
    #define TABLE1_SIZE (2*(((DBCS_LAST_LEAD-DBCS_FIRST_LEAD)+1) * ((DBCS_LAST_TRAIL-DBCS_FIRST_TRAIL)+1)))
    #define TABLE2_SIZE (2*255)
    #define TABLE3_SIZE (2*(FontHeaders.BfbHeader.NumSbcsChars + FontHeaders.BfbHeader.NumDbcsChars))

    Table1 = malloc(TABLE1_SIZE);
    if(!Table1) {
        goto c1;
    }
    Table2 = malloc(TABLE2_SIZE);
    if(!Table2) {
        goto c2;
    }
    Table3 = malloc(TABLE3_SIZE);
    if(!Table3) {
        goto c3;
    }
    //
    // Each slot in the font cache is a 2 byte header indicating the ordinal
    // value of the character cached in the slot, and then the bits that
    // make up the glyph. Entries are sized for double-byte chars even though
    // this wastes space for the single-byte case.
    //
    cache = malloc(FONT_CACHE_CAPACITY * (FontHeaders.BfbHeader.CharacterImageHeight+2) * 2);
    if(!cache) {
        goto c4;
    }

    memset(Table1,0,TABLE1_SIZE);
    memset(Table2,0,TABLE2_SIZE);
    memset(Table3,0xff,TABLE3_SIZE);

    if(DosSeek(FileHandle,FontHeaders.BfbHeader.DbcsOffset,DOSSEEK_START) != FontHeaders.BfbHeader.DbcsOffset) {
        goto c5;
    }

    #define SCRATCH_SIZE 18000              // exactly 1000 chars in typical case
    ScratchBuffer = malloc(SCRATCH_SIZE);
    if(!ScratchBuffer) {
        goto c5;
    }

    //
    // Build an offset table for sbcs chars.
    // There are a max of 255 SBCS chars (1-255).
    //
    BytesPerChar = (FontHeaders.BfbHeader.CharacterImageHeight)+1;
    if(DosSeek(FileHandle,FontHeaders.BfbHeader.SbcsOffset,DOSSEEK_START) != FontHeaders.BfbHeader.SbcsOffset) {
        free(ScratchBuffer);
        goto c5;
    }

    MaxChars = SCRATCH_SIZE / BytesPerChar;
    CharsLeft = FontHeaders.BfbHeader.NumSbcsChars;
    ordinal = 0;
    CacheOrd = 0;

    while(CharsLeft) {

        Count = CharsLeft;
        if(Count > MaxChars) {
            Count = MaxChars;
        }

        if(_dos_read(FileHandle,ScratchBuffer,Count*BytesPerChar,&i)
        || (i != (Count*BytesPerChar))) {
            free(ScratchBuffer);
            goto c5;
        }

        CharsLeft -= Count;

        for(p=ScratchBuffer,i=0; i<Count; i++,p+=BytesPerChar,ordinal++) {

            if(!p[0]) {
                //
                // Invalid value, skip this character
                //
                continue;
            }

            index = (unsigned)p[0] - 1;

            Table2[index] = ordinal;

            //
            // Cache most chars in the ascii range.
            //
            if((p[0] >= ' ') && (p[0] <= 'z')) {
                *(unsigned *)&cache[2*BytesPerChar*CacheOrd] = ordinal;
                memmove(cache+(2*BytesPerChar*CacheOrd)+2,&p[1],BytesPerChar-1);
                Table3[ordinal] = CacheOrd++;
            }
        }
    }

    nextslot = CacheOrd;

    BytesPerChar = (FontHeaders.BfbHeader.CharacterImageHeight*2)+2;
    MaxChars = SCRATCH_SIZE / BytesPerChar;
    CharsLeft = FontHeaders.BfbHeader.NumDbcsChars;
    ordinal = 0;

    while(CharsLeft) {

        Count = CharsLeft;
        if(Count > MaxChars) {
            Count = MaxChars;
        }

        if(_dos_read(FileHandle,ScratchBuffer,Count*BytesPerChar,&i)
        || (i != (Count*BytesPerChar))) {
            free(ScratchBuffer);
            goto c5;
        }

        CharsLeft -= Count;

        for(p=ScratchBuffer,i=0; i<Count; i++,p+=BytesPerChar,ordinal++) {

            if((p[0] < DBCS_FIRST_LEAD) || (p[0] > DBCS_LAST_LEAD)
            || (p[1] < DBCS_FIRST_TRAIL) || (p[1] > DBCS_LAST_TRAIL)) {
                //
                // Invalid DBCS value, skip this character
                //
                continue;
            }

            index = (unsigned)(p[0] - DBCS_FIRST_LEAD);
            index <<= 8;

            index |= p[1] - DBCS_FIRST_TRAIL;

            index -= (unsigned)(p[0] - DBCS_FIRST_LEAD) * (DBCS_FIRST_TRAIL + (255-DBCS_LAST_TRAIL));

            Table1[index] = ordinal;

            //
            // Cache first n chars that fit in the cache
            //
            if(CacheOrd < FONT_CACHE_CAPACITY) {
                *(unsigned *)&cache[CacheOrd*BytesPerChar] = ordinal+FontHeaders.BfbHeader.NumSbcsChars;
                memmove(cache+(CacheOrd*BytesPerChar)+2,&p[2],BytesPerChar-2);
                Table3[ordinal+FontHeaders.BfbHeader.NumSbcsChars] = CacheOrd++;
            }
        }
    }

    free(ScratchBuffer);

    //
    // Everything looks good. Set up globals.
    //
    memset(LeadByteTable,0,sizeof(LeadByteTable));

    for(Count=0;
            FontHeaders.BfbHeader.DbcsLeadTable[Count]
         && FontHeaders.BfbHeader.DbcsLeadTable[Count+1];
        Count+=2) {

        for(i = FontHeaders.BfbHeader.DbcsLeadTable[Count];
           i <= FontHeaders.BfbHeader.DbcsLeadTable[Count+1];
           i++) {

            LeadByteTable[(i-128)/8] |= BitValue[(i-128)%8];
        }
    }

    SbcsCharCount = FontHeaders.BfbHeader.NumSbcsChars;
    DbcsCharCount = FontHeaders.BfbHeader.NumDbcsChars;

    GlyphHeight = FontHeaders.BfbHeader.CharacterImageHeight;
    TopPad = FontHeaders.BfbHeader.CharacterTopPad;
    BottomPad = FontHeaders.BfbHeader.CharacterBottomPad;

    SbcsFileOffset = FontHeaders.BfbHeader.SbcsOffset;
    DbcsFileOffset = FontHeaders.BfbHeader.DbcsOffset;

    if(BootfontFileHandle != (unsigned)(-1)) {
        UnloadBootfontBin();
    }

    DbcsCharOrdinalOffsetTable = Table1;
    SbcsCharOrdinalOffsetTable = Table2;
    FontCacheTable = Table3;
    FontCache = cache;
    NextCacheSlot = nextslot;

    BootfontFileHandle = FileHandle;

    if(FontCharMap) {
        free(FontCharMap);
        FontCharMap = NULL;
    }

    if(FontCharData) {
        free(FontCharData);
        FontCharData = NULL;
    }

    b = TRUE;

c5:
    if(!b) {
        free(cache);
    }
c4:
    if(!b) {
        free(Table3);
    }
c3:
    if(!b) {
        free(Table2);
    }
c2:
    if(!b) {
        free(Table1);
    }
c1:
    if(!b) {
        _dos_close(FileHandle);
    }
    return(b);
}


VOID
UnloadBootfontBin(
    VOID
    )
{
    _dos_close(BootfontFileHandle);
    BootfontFileHandle = (unsigned)(-1);
    PendingLeadByte = 0;
    free(DbcsCharOrdinalOffsetTable);
    free(SbcsCharOrdinalOffsetTable);
    free(FontCacheTable);
    free(FontCache);
    DbcsCharOrdinalOffsetTable = NULL;
    SbcsCharOrdinalOffsetTable = NULL;
    FontCacheTable = NULL;
    FontCache = NULL;
}


VOID
_far
FontGetInfo(
    OUT FPBYTE Width,
    OUT FPBYTE Height
    )
{
    *Width = FONT_WIDTH;
    *Height = GlyphHeight + TopPad + BottomPad;
}


VOID
_far
FontWriteChar(
    IN UCHAR  c,
    IN USHORT x,
    IN USHORT y,
    IN BYTE   ForegroundPixelValue,
    IN BYTE   BackgroundPixelValue
    )
{
    BYTE PixelMap[2];

    if(BootfontFileHandle != (unsigned)(-1)) {
        //
        // Use bootfont.bin method
        //
        FontWriteBfbChar(c,x,y,ForegroundPixelValue,BackgroundPixelValue);
        return;
    }

    PixelMap[0] = BackgroundPixelValue;
    PixelMap[1] = ForegroundPixelValue;

    if((c < FontFirstChar) || (c > FontLastChar)) {
        c = FontDefaultChar;
    }

    //
    // Pad if necessary by filling in background
    //
    if(BackgroundPixelValue < VGAPIX_TRANSPARENT) {
        if(TopPad) {
            VgaClearRegion(x,y,FONT_WIDTH,TopPad,BackgroundPixelValue);
        }
        if(BottomPad) {
            VgaClearRegion(x,y+TopPad+GlyphHeight,FONT_WIDTH,BottomPad,BackgroundPixelValue);
        }
    }

    VgaBitBlt(
        x,
        y + TopPad,
        FONT_WIDTH,
        GlyphHeight,
        1,
        FALSE,
        PixelMap,
        FontCharData + (FontCharMap[c-FontFirstChar].Offset - FontDataBaseOffset)
        );
}


VOID
_far
FontWriteString(
    IN UCHAR  *String,
    IN USHORT  x,
    IN USHORT  y,
    IN BYTE    ForegroundPixelValue,
    IN BYTE    BackgroundPixelValue
    )
{
    for( ; *String; String++) {
        FontWriteChar(*String,x,y,ForegroundPixelValue,BackgroundPixelValue);
        x += FONT_WIDTH;
    }

    PendingLeadByte = 0;
}


VOID
FontWriteBfbChar(
    IN UCHAR  c,
    IN USHORT x,
    IN USHORT y,
    IN BYTE   ForegroundPixelValue,
    IN BYTE   BackgroundPixelValue
    )
{
    unsigned scale;
    unsigned index;
    unsigned Ordinal;
    unsigned i,read;
    ULONG FileOffset = 0;
    FPBYTE Glyph = NULL;
    BYTE PixelMap[2];
    FPBYTE p;

    if(PendingLeadByte) {
        //
        // Got second half of DBCS character. Render now.
        //
        index = (unsigned)(PendingLeadByte - DBCS_FIRST_LEAD);
        index <<= 8;
        index |= c - DBCS_FIRST_TRAIL;
        index -= (unsigned)(PendingLeadByte - DBCS_FIRST_LEAD) * (DBCS_FIRST_TRAIL + (255-DBCS_LAST_TRAIL));
        PendingLeadByte = 0;

        Ordinal = DbcsCharOrdinalOffsetTable[index];

        //
        // Is this character cached?
        //
        if(FontCacheTable[Ordinal+SbcsCharCount] == (unsigned)(-1)) {
            //
            // No, need to cache it.
            //
            FileOffset = ((ULONG)Ordinal * ((2 * GlyphHeight) + 2)) + DbcsFileOffset + 2;
        } else {
            //
            // Yes, get glyph.
            //
            Glyph = FontCache + (((2 * GlyphHeight) + 2) * FontCacheTable[Ordinal+SbcsCharCount]) + 2;
        }

        Ordinal += SbcsCharCount;
        x -= FONT_WIDTH;
        scale = 2;
    } else {
        //
        // See if DBCS char or a lead byte
        //
        if((c >= DBCS_FIRST_LEAD) && (LeadByteTable[(c-128)/8] & BitValue[(c-128)%8])) {
            PendingLeadByte = c;
            return;
        }

        //
        // SBCS char.
        //
        Ordinal = SbcsCharOrdinalOffsetTable[c-1];

        //
        // Is this character cached?
        //
        if(FontCacheTable[Ordinal] == (unsigned)(-1)) {
            //
            // No, need to cache it.
            //
            FileOffset = ((ULONG)Ordinal * (GlyphHeight + 1)) + SbcsFileOffset + 1;
        } else {
            //
            // Yes, get glyph
            //
            Glyph = FontCache + (((2 * GlyphHeight) + 2) * FontCacheTable[Ordinal]) + 2;
        }

        scale = 1;
    }

    if(FileOffset) {
        //
        // Pull the character in from the file.
        //
        Glyph = NULL;
        if(DosSeek(BootfontFileHandle,FileOffset,DOSSEEK_START) == FileOffset) {

            //
            // Point at the entry in the font cache where we're going
            // to stick the glyph.
            //
            p = FontCache + (NextCacheSlot * ((2 * GlyphHeight) + 2));

            //
            // Invalidate the caching for the character currently
            // cached in the slot we're going to overwrite. If the read
            // fails halfway through, the glyph may be trashed anyway,
            // so we do it before we know if the read succeeds.
            //
            FontCacheTable[*(unsigned *)p] = (unsigned)(-1);

            i = _dos_read(BootfontFileHandle,p+2,scale*GlyphHeight,&read);

            if(!i && (read == (scale * GlyphHeight))) {

                *(unsigned *)p = Ordinal;
                Glyph = p+2;

                FontCacheTable[Ordinal] = NextCacheSlot++;
                if(NextCacheSlot == FONT_CACHE_CAPACITY) {
                    NextCacheSlot = 0;
                }
            }
        }
    }

    if(Glyph) {
        //
        // Pad if necessary by filling in background
        //
        if(BackgroundPixelValue < VGAPIX_TRANSPARENT) {
            if(TopPad) {
                VgaClearRegion(x,y,scale*FONT_WIDTH,TopPad,BackgroundPixelValue);
            }
            if(BottomPad) {
                VgaClearRegion(x,y+TopPad+GlyphHeight,scale*FONT_WIDTH,BottomPad,BackgroundPixelValue);
            }
        }

        PixelMap[0] = BackgroundPixelValue;
        PixelMap[1] = ForegroundPixelValue;

        VgaBitBlt(
            x,
            y + TopPad,
            scale*FONT_WIDTH,
            GlyphHeight,
            scale,
            FALSE,
            PixelMap,
            Glyph
            );

    } else {
        //
        // Put a block up there.
        //
        VgaClearRegion(x,y,scale*FONT_WIDTH,TopPad+BottomPad+GlyphHeight,ForegroundPixelValue);
    }
}