[<<] [<] Page 1 of 1 [>] [>>] | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Subject:
Another version of engine/font_pcf.c
From: "Paul Bartholomew" ####@####.#### Date: 29 Jun 2005 22:18:12 +0100 Message-Id: <BAY108-F2426386C32A27D0E940903EFE00@phx.gbl> I discovered that the version of "engine/font_pcf.c" that I sent out yesterday had some bugs (although FLTK "hello" and "fonts" demos worked, microwindows "t1demo" did not). I've fixed the problem, and have attached a new version. Sorry if anyone wasted any time with the 'broken' version. Regards, - Paul Bartholomew /* * PCF font engine for Microwindows * Copyright (c) 2002, 2003 Greg Haerr ####@####.#### * Copyright (c) 2001, 2002 by Century Embedded Technologies * * Supports dynamically loading .pcf and pcf.gz X11 fonts * * Written by Jordan Crouse * Bugfixed by Greg Haerr * * 28.01.2003: * Patch for big-endian-machines by Klaus Fuerth ####@####.#### * 28.06.2005: * Code should now work on both big- and little-endian machines. * Added better support for leftBearing/rightBearing in input fonts. * - Paul Bartholomew ####@####.#### * 29.06.2005: * Fixed code that decides whether/not bits/bytes need to be swapped. * Now, we always put them into the bit buffer as MSB/MSB, and the code * that converts from the PCF input buffer to MWCOREFONT reads a * byte-at-a-time. * - Paul Bartholomew ####@####.#### */ #include <stdio.h> #include <string.h> #include <errno.h> #include <stdlib.h> #include "swap.h" #include "device.h" #include "devfont.h" #include "../drivers/genfont.h" extern MWPIXELVAL gr_background; extern MWBOOL gr_usebg; /* The user hase the option including ZLIB and being able to */ /* directly read compressed .pcf files, or to omit it and save */ /* space. The following defines make life much easier */ #if HAVE_PCFGZ_SUPPORT #include <zlib.h> #define FILEP gzFile #define FOPEN(path, mode) gzopen(path, mode) #define FREAD(file, buffer, size) gzread(file, buffer, size) #define FSEEK(file, offset, whence) gzseek(file, offset, whence) #define FCLOSE(file) gzclose(file) #else #define FILEP FILE * #define FOPEN(path, mode) fopen(path, mode) #define FREAD(file, buffer, size) fread(buffer, 1, size, file) #define FSEEK(file, offset, whence) fseek(file, offset, whence) #define FCLOSE(file) fclose(file) #endif typedef unsigned char (*FP_READ8)(FILEP file); typedef unsigned short (*FP_READ16)(FILEP file); typedef unsigned long (*FP_READ32)(FILEP file); /* Handling routines for PCF fonts, use MWCOREFONT structure */ static void pcf_unloadfont(PMWFONT font); static void get_endian_read_funcs(unsigned long format, FP_READ8 *p_fp_read8, FP_READ16 *p_fp_read16, FP_READ32 *p_fp_read32); static unsigned short readLSB16(FILEP file); static unsigned long readLSB32(FILEP file); static unsigned short readMSB16(FILEP file); static unsigned long readMSB32(FILEP file); /* these procs used when font ASCII indexed*/ static MWFONTPROCS pcf_fontprocs = { MWTF_ASCII, gen_getfontinfo, gen_gettextsize, gen_gettextbits, pcf_unloadfont, corefont_drawtext, NULL, /* setfontsize */ NULL, /* setfontrotation */ NULL, /* setfontattr */ }; /* these procs used when font requires UC16 index*/ static MWFONTPROCS pcf_fontprocs16 = { MWTF_UC16, /* routines expect unicode 16 */ gen_getfontinfo, gen16_gettextsize, gen_gettextbits, pcf_unloadfont, gen16_drawtext, NULL, /* setfontsize */ NULL, /* setfontrotation */ NULL, /* setfontattr */ NULL, /* duplicate not yet implemented */ }; /* These are maintained statically for ease FIXME*/ static struct toc_entry *toc; static unsigned long toc_size; /* Various definitions from the Free86 PCF code */ #define PCF_FILE_VERSION (('p'<<24)|('c'<<16)|('f'<<8)|1) #define PCF_PROPERTIES (1 << 0) #define PCF_ACCELERATORS (1 << 1) #define PCF_METRICS (1 << 2) #define PCF_BITMAPS (1 << 3) #define PCF_INK_METRICS (1 << 4) #define PCF_BDF_ENCODINGS (1 << 5) #define PCF_SWIDTHS (1 << 6) #define PCF_GLYPH_NAMES (1 << 7) #define PCF_BDF_ACCELERATORS (1 << 8) #define PCF_FORMAT_MASK 0xFFFFFF00 #define PCF_DEFAULT_FORMAT 0x00000000 #define PCF_GLYPH_PAD_MASK (3<<0) #define PCF_GLYPH_PAD_SHIFT (0) #define PCF_BYTE_MASK (1<<2) #define PCF_BIT_MASK (1<<3) #define PCF_SCAN_UNIT_MASK (3<<4) #define PCF_SCAN_UNIT_SHIFT (4) #define GLYPHPADOPTIONS 4 #define PCF_LSB_FIRST 0 #define PCF_MSB_FIRST 1 /* A few structures that define the various fields within the file */ struct toc_entry { int type; int format; int size; int offset; }; struct prop_entry { unsigned int name; unsigned char is_string; unsigned int value; }; struct string_table { unsigned char *name; unsigned char *value; }; struct metric_entry { short leftBearing; short rightBearing; short width; short ascent; short descent; short attributes; }; struct encoding_entry { unsigned short min_byte2; /* min_char or min_byte2 */ unsigned short max_byte2; /* max_char or max_byte2 */ unsigned short min_byte1; /* min_byte1 (hi order) */ unsigned short max_byte1; /* max_byte1 (hi order) */ unsigned short defaultchar; unsigned long count; /* count of map entries */ unsigned short *map; /* font index -> glyph index */ }; /* This is used to quickly reverse the bits in a field */ static unsigned char _reverse_byte[0x100] = { 0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0, 0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0, 0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8, 0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8, 0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4, 0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4, 0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec, 0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc, 0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2, 0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2, 0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea, 0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa, 0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6, 0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6, 0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee, 0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe, 0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1, 0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1, 0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9, 0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9, 0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5, 0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5, 0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed, 0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd, 0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3, 0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3, 0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb, 0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb, 0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7, 0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7, 0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef, 0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff }; /* * Invert bit order within each BYTE of an array. */ static void bit_order_invert(unsigned char *buf, int nbytes) { for (; --nbytes >= 0; buf++) *buf = _reverse_byte[*buf]; } /* * Invert byte order within each 16-bits of an array. */ void two_byte_swap(unsigned char *buf, int nbytes) { unsigned char c; for (; nbytes > 0; nbytes -= 2, buf += 2) { c = buf[0]; buf[0] = buf[1]; buf[1] = c; } } /* * Invert byte order within each 32-bits of an array. */ void four_byte_swap(unsigned char *buf, int nbytes) { unsigned char c; for (; nbytes > 0; nbytes -= 4, buf += 4) { c = buf[0]; buf[0] = buf[3]; buf[3] = c; c = buf[1]; buf[1] = buf[2]; buf[2] = c; } } /* read an 8 bit byte*/ static unsigned short readINT8(FILEP file) { unsigned char b; FREAD(file, &b, sizeof(b)); return b; } /* Get the offset of the given field */ static int pcf_get_offset(int item) { int i; for (i = 0; i < toc_size; i++) if (item == toc[i].type) return toc[i].offset; return -1; } #if LATER /* Read the properties from the file */ static int pcf_readprops(FILEP file, struct prop_entry **prop, struct string_table **strings) { long offset; unsigned long format; unsigned long num_props; unsigned long ssize; unsigned long i; struct string_table *s; struct prop_entry *p; unsigned char *string_buffer, *spos; if ((offset = pcf_get_offset(PCF_PROPERTIES)) == -1) return (-1); FSEEK(file, offset, SEEK_SET); format = readLSB32(file); num_props = readLSB32(file); p = *prop = (struct prop_entry *) malloc(num_props * sizeof(struct prop_entry)); for (i = 0; i < num_props; i++) { p[i].name = readLSB32(file); p[i].is_string = readINT8(file); p[i].value = readLSB32(file); } /* Pad to 32 bit multiples */ if (num_props & 3) FSEEK(file, 4 - (num_props & 3), SEEK_CUR); /* Read the entire set of strings into memory */ ssize = readLSB32(file); spos = string_buffer = (unsigned char *) ALLOCA(ssize); FREAD(file, string_buffer, ssize); /* Allocate the group of strings */ s = *strings = (struct string_table *) ALLOCA(num_props * sizeof(struct string_table)); for (i = 0; i < num_props; i++) { s[i].name = (unsigned char *) strdup(spos); spos += strlen(s[i].name) + 1; if (p[i].is_string) { s[i].value = (unsigned char *) strdup(spos); spos += strlen(s[i].value) + 1; } else s[i].value = 0; } FREEA(string_buffer); return num_props; } #endif /* Read the actual bitmaps into memory */ static int pcf_readbitmaps(FILEP file, unsigned char **bits, int *bits_size, unsigned long **offsets) { long offset; unsigned long format; unsigned long num_glyphs; unsigned long pad_index; unsigned int i; int endian_bits; unsigned long *o; unsigned char *b; unsigned long bmsize[GLYPHPADOPTIONS]; FP_READ8 f_read8; FP_READ16 f_read16; FP_READ32 f_read32; int format_bit_endian, format_byte_endian; int desired_bit_endian, desired_byte_endian; int need_bit_reverse, need_byte_reverse; int format_scan_unit, desired_scan_unit; if ((offset = pcf_get_offset(PCF_BITMAPS)) == -1) return -1; FSEEK(file, offset, SEEK_SET); format = readLSB32(file); get_endian_read_funcs(format, &f_read8, &f_read16, &f_read32); format_bit_endian = (format & PCF_BIT_MASK)? PCF_MSB_FIRST: PCF_LSB_FIRST; format_byte_endian = (format & PCF_BYTE_MASK)? PCF_MSB_FIRST: PCF_LSB_FIRST; format_scan_unit = (1 << ((format & PCF_SCAN_UNIT_MASK) >> PCF_SCAN_UNIT_SHIFT)); desired_bit_endian = PCF_MSB_FIRST; desired_byte_endian = PCF_MSB_FIRST; desired_scan_unit = (1 << 0); if (format_bit_endian != desired_bit_endian) { need_bit_reverse = 1; } else { need_bit_reverse = 0; } if ((format_bit_endian == format_byte_endian) != (desired_bit_endian == desired_byte_endian)) { /* If we want byte reverse, set need_byte_reverse to the size (1/2/4) */ need_byte_reverse = (1 << ((desired_bit_endian == desired_byte_endian) ? format_scan_unit : desired_scan_unit)); } else { need_byte_reverse = 0; } endian_bits = (format & PCF_BIT_MASK)? PCF_MSB_FIRST: PCF_LSB_FIRST; num_glyphs = f_read32(file); o = *offsets = (unsigned long *)malloc(num_glyphs * sizeof(unsigned long)); for (i=0; i < num_glyphs; ++i) o[i] = f_read32(file); for (i=0; i < GLYPHPADOPTIONS; ++i) bmsize[i] = f_read32(file); pad_index = ((format & PCF_GLYPH_PAD_MASK) >> PCF_GLYPH_PAD_SHIFT); *bits_size = bmsize[pad_index]? bmsize[pad_index] : 1; /* alloc and read bitmap data*/ b = *bits = (unsigned char *) malloc(*bits_size); FREAD(file, b, *bits_size); /* convert bitmaps*/ if (need_bit_reverse) { bit_order_invert(b, *bits_size); } switch(need_byte_reverse) { default: case 1: break; case 2: two_byte_swap(b, *bits_size); break; case 4: four_byte_swap(b, *bits_size); break; } return num_glyphs; } /* read character metric data*/ static int pcf_readmetrics(FILE * file, struct metric_entry **metrics) { long i, size, offset; unsigned long format; struct metric_entry *m; FP_READ8 f_read8; FP_READ16 f_read16; FP_READ32 f_read32; if ((offset = pcf_get_offset(PCF_METRICS)) == -1) return -1; FSEEK(file, offset, SEEK_SET); format = readLSB32(file); get_endian_read_funcs(format, &f_read8, &f_read16, &f_read32); if ((format & PCF_FORMAT_MASK) == PCF_DEFAULT_FORMAT) { size = f_read32(file); /* 32 bits - Number of metrics*/ m = *metrics = (struct metric_entry *) malloc(size * sizeof(struct metric_entry)); for (i=0; i < size; i++) { m[i].leftBearing = f_read16(file); m[i].rightBearing = f_read16(file); m[i].width = f_read16(file); m[i].ascent = f_read16(file); m[i].descent = f_read16(file); m[i].attributes = f_read16(file); } } else { size = f_read16(file); /* 16 bits - Number of metrics*/ m = *metrics = (struct metric_entry *) malloc(size * sizeof(struct metric_entry)); for (i = 0; i < size; i++) { m[i].leftBearing = f_read8(file) - 0x80; m[i].rightBearing = f_read8(file) - 0x80; m[i].width = f_read8(file) - 0x80; m[i].ascent = f_read8(file) - 0x80; m[i].descent = f_read8(file) - 0x80; } } return size; } /* read encoding table*/ static int pcf_read_encoding(FILE * file, struct encoding_entry **encoding) { long offset, n; unsigned long format; struct encoding_entry *e; FP_READ8 f_read8; FP_READ16 f_read16; FP_READ32 f_read32; if ((offset = pcf_get_offset(PCF_BDF_ENCODINGS)) == -1) return -1; FSEEK(file, offset, SEEK_SET); format = readLSB32(file); get_endian_read_funcs(format, &f_read8, &f_read16, &f_read32); e = *encoding = (struct encoding_entry *) malloc(sizeof(struct encoding_entry)); e->min_byte2 = f_read16(file); e->max_byte2 = f_read16(file); e->min_byte1 = f_read16(file); e->max_byte1 = f_read16(file); e->defaultchar = f_read16(file); e->count = (e->max_byte2 - e->min_byte2 + 1) * (e->max_byte1 - e->min_byte1 + 1); e->map = (unsigned short *) malloc(e->count * sizeof(unsigned short)); DPRINTF("def char %d (%x)\n", e->defaultchar, e->defaultchar); for (n = 0; n < e->count; ++n) { e->map[n] = f_read16(file); /*DPRINTF("ncode %x (%c) %x\n", n, n, e->map[n]);*/ } DPRINTF("size %d byte1 %d,%d byte2 %d,%d\n", e->count, e->min_byte1, e->max_byte1, e->min_byte2, e->max_byte2); return e->count; } static int pcf_read_toc(FILE * file, struct toc_entry **toc, unsigned long *size) { long i; unsigned long version; struct toc_entry *t; FSEEK(file, 0, SEEK_SET); /* Verify the version */ version = readLSB32(file); if (version != PCF_FILE_VERSION) return -1; *size = readLSB32(file); t = *toc = (struct toc_entry *) calloc(sizeof(struct toc_entry), *size); if (!t) return -1; /* Read in the entire table of contents */ for (i=0; i<*size; ++i) { t[i].type = readLSB32(file); t[i].format = readLSB32(file); t[i].size = readLSB32(file); t[i].offset = readLSB32(file); } return 0; } PMWCOREFONT pcf_createfont(const char *name, MWCOORD height, int attr) { FILE *file = 0; MWCOREFONT *pf = 0; int offset; int i; int count; int bsize; int bwidth; int err = 0; struct metric_entry *metrics = 0; struct encoding_entry *encoding = 0; MWIMAGEBITS *output; unsigned char *glyphs = 0; unsigned long *glyphs_offsets = 0; int max_width = 0, max_descent = 0, max_ascent = 0, max_height = 0; int glyph_count; unsigned long *goffset = NULL; unsigned char *gwidth = NULL; int uc16; char fname[256]; int mw_width; // width including leftBearing /* Try to open the file */ file = FOPEN(name, "rb"); if (!file) { strcpy(fname, PCF_FONT_DIR "/"); strcpy(fname + sizeof(PCF_FONT_DIR), name); file = FOPEN(fname, "rb"); } if (!file) return NULL; if (!(pf = (MWCOREFONT *) malloc(sizeof(MWCOREFONT)))) { err = -1; goto leave_func; } if (!(pf->cfont = (PMWCFONT) calloc(sizeof(MWCFONT), 1))) { err = -1; goto leave_func; } /* Read the table of contents */ if (pcf_read_toc(file, &toc, &toc_size) == -1) { err = -1; goto leave_func; } /* Now, read in the bitmaps */ glyph_count = pcf_readbitmaps(file, &glyphs, &bsize, &glyphs_offsets); DPRINTF("glyph_count = %d (%x)\n", glyph_count, glyph_count); if (glyph_count == -1) { err = -1; goto leave_func; } if (pcf_read_encoding(file, &encoding) == -1) { err = -1; goto leave_func; } pf->cfont->firstchar = encoding->min_byte2 * (encoding->min_byte1 + 1); /* Read in the metrics */ count = pcf_readmetrics(file, &metrics); /* Calculate various maximum values */ for (i = 0; i < count; i++) { if (metrics[i].leftBearing >= 0) { mw_width = metrics[i].leftBearing + ((metrics[i].rightBearing - metrics[i].leftBearing)); } else { mw_width = (metrics[i].rightBearing + abs(metrics[i].leftBearing)); } if (mw_width > max_width) max_width = mw_width; if (metrics[i].ascent > max_ascent) max_ascent = metrics[i].ascent; if (metrics[i].descent > max_descent) max_descent = metrics[i].descent; } max_height = max_ascent + max_descent; pf->cfont->maxwidth = max_width; pf->cfont->height = max_height; pf->cfont->ascent = max_ascent; /* Allocate enough room to hold all of the bits and the offsets */ bwidth = (max_width + 15) / 16; pf->cfont->bits = (MWIMAGEBITS *) calloc((max_height * (sizeof(MWIMAGEBITS) * bwidth)), glyph_count); goffset = (unsigned long *) malloc(glyph_count * sizeof(unsigned long)); gwidth = (unsigned char *) malloc(glyph_count * sizeof(unsigned char)); output = (MWIMAGEBITS *) pf->cfont->bits; offset = 0; /* copy and convert from packed BDF format to MWCFONT format*/ for (i = 0; i < glyph_count; i++) { int h, w; int y = max_height; unsigned long *ptr = (unsigned long *) (glyphs + glyphs_offsets[i]); /* # words image width*/ int lwidth; /* # words image width, corrected for bounding box problem*/ int xwidth = (metrics[i].rightBearing - metrics[i].leftBearing + 15) / 16; /* Calculate width of output MW font character */ if (metrics[i].leftBearing >= 0) { gwidth[i] = metrics[i].leftBearing + ((metrics[i].rightBearing - metrics[i].leftBearing)); } else { gwidth[i] = (metrics[i].rightBearing + abs(metrics[i].leftBearing)); } lwidth = (gwidth[i] + 15) / 16; goffset[i] = offset; offset += (lwidth * max_height); for (h = 0; h < (max_ascent - metrics[i].ascent); h++) { for (w = 0; w < lwidth; w++) { *output++ = 0; } y--; } for (h = 0; h < (metrics[i].ascent + metrics[i].descent); h++) { unsigned short *val = (unsigned short *) ptr; int bearing, carry_shift; unsigned short carry = 0; unsigned char *p8; unsigned short val16; /* leftBearing correction*/ bearing = metrics[i].leftBearing; if (bearing < 0) /* negative bearing not handled yet*/ bearing = 0; carry_shift = 16 - bearing; for (w = 0; w < lwidth; w++) { if (w < xwidth) { p8 = (unsigned char *)&(val[w]); val16 = ((((unsigned short)p8[0]) << 8) | p8[1]); } else { val16 = 0; } *output++ = (val16 >> bearing) | carry; carry = val16 << carry_shift; } ptr += (xwidth + 1) / 2; y--; } for (; y > 0; y--) { for (w = 0; w < lwidth; w++) { *output++ = 0; } } } /* reorder offsets and width according to encoding map */ pf->cfont->offset = (unsigned long *) malloc(encoding->count * sizeof(unsigned long)); pf->cfont->width = (unsigned char *) malloc(encoding->count * sizeof(unsigned char)); for (i = 0; i < encoding->count; ++i) { unsigned short n = encoding->map[i]; if (n == 0xffff) /* map non-existent chars to default char */ n = encoding->map[encoding->defaultchar]; ((unsigned long *)pf->cfont->offset)[i] = goffset[n]; ((unsigned char *)pf->cfont->width)[i] = gwidth[n]; } pf->cfont->size = encoding->count; uc16 = pf->cfont->firstchar > 255 || (pf->cfont->firstchar + pf->cfont->size) > 255; pf->fontprocs = uc16? &pcf_fontprocs16: &pcf_fontprocs; pf->fontsize = pf->fontrotation = pf->fontattr = 0; pf->name = "PCF"; leave_func: if (goffset) free(goffset); if (gwidth) free(gwidth); if (encoding) { if (encoding->map) free(encoding->map); free(encoding); } if (metrics) free(metrics); if (glyphs) free(glyphs); if (glyphs_offsets) free(glyphs_offsets); if (toc) free(toc); toc = 0; toc_size = 0; if (file) FCLOSE(file); if (err == 0 && pf) return pf; pcf_unloadfont((PMWFONT)pf); return 0; } void pcf_unloadfont(PMWFONT font) { PMWCOREFONT pf = (PMWCOREFONT) font; PMWCFONT pfc = pf->cfont; if (pfc) { if (pfc->width) free((char *)pf->cfont->width); if (pfc->offset) free((char *)pf->cfont->offset); if (pfc->bits) free((char *)pf->cfont->bits); free(pf->cfont); } free(font); } static void get_endian_read_funcs(unsigned long format, FP_READ8 *p_fp_read8, FP_READ16 *p_fp_read16, FP_READ32 *p_fp_read32) { *p_fp_read8 = (FP_READ8)readINT8; if (format & PCF_BYTE_MASK) { /* MSB byte order */ *p_fp_read16 = readMSB16; *p_fp_read32 = readMSB32; } else { /* LSB byte order */ *p_fp_read16 = readLSB16; *p_fp_read32 = readLSB32; } } static unsigned short readLSB16(FILEP file) { unsigned short ret; unsigned char ch; int i; ret = 0; for (i = 0; i < (16/8); i++) { ch = readINT8(file); ret |= (((unsigned short)ch) << (i * 8)); } return ret; } static unsigned long readLSB32(FILEP file) { unsigned long ret; unsigned char ch; int i; ret = 0; for (i = 0; i < (32/8); i++) { ch = readINT8(file); ret |= (((unsigned long)ch) << (i * 8)); } return ret; } static unsigned short readMSB16(FILEP file) { unsigned short ret; unsigned char ch; int i; ret = 0; for (i = 0; i < (16/8); i++) { ch = readINT8(file); ret <<= 8; ret |= ch; } return ret; } static unsigned long readMSB32(FILEP file) { unsigned long ret; unsigned char ch; int i; ret = 0; for (i = 0; i < (32/8); i++) { ch = readINT8(file); ret <<= 8; ret |= ch; } return ret; } | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
[<<] [<] Page 1 of 1 [>] [>>] |