// Sets d->version, and certain header fields.
static int detect_bmp_version(deark *c, lctx *d)
{
de_int64 pos;
pos = 0;
d->fsize = de_getui32le(pos+2);
pos += FILEHEADER_SIZE;
d->infohdrsize = de_getui32le(pos);
if(d->infohdrsize<=12) {
d->bitcount = de_getui16le(pos+10);
}
else {
d->bitcount = de_getui16le(pos+14);
}
if(d->infohdrsize==12) {
d->version = DE_BMPVER_OS2V1;
return 1;
}
if(d->infohdrsize<16) {
return 0;
}
if(d->infohdrsize>=20) {
d->compression_field = (de_uint32)de_getui32le(pos+16);
}
if(d->infohdrsize>=16 && d->infohdrsize<=64) {
if(d->fsize==FILEHEADER_SIZE+d->infohdrsize) {
d->version = DE_BMPVER_OS2V2;
return 1;
}
if((d->compression_field==3 && d->bitcount==1) ||
(d->compression_field==4 && d->bitcount==24))
{
d->version = DE_BMPVER_OS2V2;
return 1;
}
if(d->infohdrsize!=40 && d->infohdrsize!=52 && d->infohdrsize!=56) {
d->version = DE_BMPVER_OS2V2;
return 1;
}
}
d->version = DE_BMPVER_WINV345;
return 1;
}
static void do_extract_file(deark *c, lctx *d, de_int64 dir_pos,
de_byte filetype_c64s, de_byte filetype)
{
de_int64 load_addr;
de_int64 end_addr;
de_int64 offset;
dbuf *f = NULL;
de_int64 payload_size; // = file_size-2
de_ucstring *fname = NULL;
de_int64 fname_len;
de_int64 i;
de_int64 fnpos;
de_finfo *fi = NULL;
load_addr = de_getui16le(dir_pos+2);
end_addr = de_getui16le(dir_pos+4);
offset = de_getui32le(dir_pos+8);
de_dbg(c, "load_addr=%d end_addr=%d offset=%d\n", (int)load_addr,
(int)end_addr, (int)offset);
// File name at pos+16
fnpos = dir_pos+16;
// Find the length of the (space-padded) filename.
fname_len = 0;
for(i=15; i>=0; i--) {
if(de_getbyte(fnpos+i)!=' ') {
fname_len = i+1;
break;
}
}
de_dbg2(c, "filename length: %d\n", (int)fname_len);
fname = ucstring_create(c);
dbuf_read_to_ucstring(c->infile, fnpos, fname_len, fname, 0, DE_ENCODING_PETSCII);
de_dbg(c, "filename: \"%s\"\n", ucstring_get_printable_sz(fname));
ucstring_append_sz(fname, ".prg", DE_ENCODING_ASCII);
fi = de_finfo_create(c);
de_finfo_set_name_from_ucstring(c, fi, fname);
fi->original_filename_flag = 1;
payload_size = end_addr - load_addr;
if(payload_size < 0) {
// TODO: Try to support files that don't have end_addr set properly.
de_err(c, "This type of T64 file is not supported.\n");
goto done;
}
f = dbuf_create_output_file(c, NULL, fi, 0);
dbuf_copy(c->infile, dir_pos+2, 2, f);
dbuf_copy(c->infile, offset, payload_size, f);
done:
dbuf_close(f);
de_finfo_destroy(c, fi);
ucstring_destroy(fname);
}
static void do_psf2_header(deark *c, lctx *d)
{
de_int64 pos = 0;
de_dbg(c, "PFXv2 header at %d\n", (int)pos);
de_dbg_indent(c, 1);
d->psf2_version = (de_uint32)de_getui32le(pos+4);
de_dbg(c, "PSFv2 version number: %d\n", (int)d->psf2_version);
if(d->psf2_version!=0) {
de_warn(c, "Unknown PSFv2 version number: %d\n", (int)d->psf2_version);
}
d->headersize = de_getui32le(pos+8);
de_dbg(c, "header size: %d\n", (int)d->headersize);
d->flags = (de_uint32)de_getui32le(pos+12);
de_dbg(c, "flags: 0x%08x\n", (unsigned int)d->flags);
de_dbg_indent(c, 1);
d->has_unicode_table = (d->flags & 0x01) ? 1 : 0;
de_dbg(c, "has Unicode table: %s\n", d->has_unicode_table?"yes":"no");
de_dbg_indent(c, -1);
d->num_glyphs = de_getui32le(pos+16);
de_dbg(c, "number of glyphs: %d\n", (int)d->num_glyphs);
d->bytes_per_glyph = de_getui32le(pos+20);
de_dbg(c, "bytes per glyph: %d\n", (int)d->bytes_per_glyph);
d->glyph_height = de_getui32le(pos+24);
d->glyph_width = de_getui32le(pos+28);
de_dbg(c, "glyph dimensions: %dx%d\n", (int)d->glyph_width, (int)d->glyph_height);
de_dbg_indent(c, -1);
}
static int read_fileheader(deark *c, lctx *d, de_int64 pos)
{
de_dbg(c, "file header at %d\n", (int)pos);
de_dbg_indent(c, 1);
de_dbg(c, "bfSize: %d\n", (int)d->fsize);
d->bits_offset = de_getui32le(pos+10);
de_dbg(c, "bfOffBits: %d\n", (int)d->bits_offset);
de_dbg_indent(c, -1);
return 1;
}
static void do_read_bitfields(deark *c, lctx *d, de_int64 pos, de_int64 len)
{
de_int64 k;
if(len>16) len=16;
for(k=0; 4*k<len; k++) {
d->bitfield[k].mask = (de_uint32)de_getui32le(pos+4*k);
de_dbg(c, "mask[%d]: 0x%08x\n", (int)k, (unsigned int)d->bitfield[k].mask);
}
update_bitfields_info(c, d);
}
static int do_gzip_read_member(deark *c, lctx *d, de_int64 pos1, de_int64 *member_size)
{
de_byte b0, b1;
de_int64 cmpr_code;
de_int64 pos;
de_int64 n;
de_int64 foundpos;
de_int64 string_len;
de_int64 cmpr_data_len;
de_int64 isize;
de_int64 mod_time_unix;
struct de_timestamp mod_time_ts;
de_uint32 crc32_field;
de_ucstring *member_name = NULL;
de_finfo *fi = NULL;
int saved_indent_level;
int ret;
int retval = 0;
mod_time_ts.is_valid = 0;
de_dbg_indent_save(c, &saved_indent_level);
de_dbg(c, "gzip member at %d\n", (int)pos1);
de_dbg_indent(c, 1);
pos = pos1;
b0 = de_getbyte(pos+0);
b1 = de_getbyte(pos+1);
if(b0!=0x1f || b1!=0x8b) {
de_err(c, "Invalid gzip signature at %d. This is not a valid gzip file.\n",
(int)pos1);
goto done;
}
cmpr_code=de_getbyte(pos+2);
if(cmpr_code!=0x08) {
de_err(c, "Unsupported compression type (%d)\n", (int)cmpr_code);
goto done;
}
d->flags = de_getbyte(pos+3);
de_dbg(c, "flags: 0x%02x\n", (unsigned int)d->flags);
pos += 4;
mod_time_unix = de_getui32le(pos);
de_unix_time_to_timestamp(mod_time_unix, &mod_time_ts);
if(mod_time_ts.is_valid) {
char timestamp_buf[64];
de_timestamp_to_string(&mod_time_ts, timestamp_buf, sizeof(timestamp_buf), 1);
de_dbg(c, "mod time: %" INT64_FMT " (%s)\n", mod_time_unix, timestamp_buf);
}
pos += 4;
b0 = de_getbyte(pos++);
de_dbg(c, "extra flags: 0x%02x\n", (unsigned int)b0);
b0 = de_getbyte(pos++);
de_dbg(c, "OS or filesystem: %d (%s)\n", (int)b0, get_os_name(b0));
if(d->flags & GZIPFLAG_FEXTRA) {
n = de_getui16le(pos); // XLEN
// TODO: It might be interesting to dissect these extra fields, but it's
// hard to find even a single file that uses them.
de_dbg(c, "[extra fields at %d, dpos=%d, dlen=%d]\n",
(int)pos, (int)(pos+2), (int)n);
pos += 2;
pos += n;
}
if(d->flags & GZIPFLAG_FNAME) {
ret = dbuf_search_byte(c->infile, 0x00, pos, c->infile->len - pos,
&foundpos);
if(!ret) {
de_err(c, "Invalid NAME field\n");
goto done;
}
string_len = foundpos - pos;
member_name = ucstring_create(c);
dbuf_read_to_ucstring_n(c->infile, pos, string_len, 300, member_name, 0, DE_ENCODING_LATIN1);
de_dbg(c, "file name at %d, len=%d: \"%s\"\n", (int)pos, (int)string_len,
ucstring_get_printable_sz(member_name));
pos = foundpos + 1;
}
if(d->flags & GZIPFLAG_FCOMMENT) {
ret = dbuf_search_byte(c->infile, 0x00, pos, c->infile->len - pos,
&foundpos);
if(!ret) {
de_err(c, "Invalid COMMENT field\n");
goto done;
}
pos = foundpos + 1;
}
if(d->flags & GZIPFLAG_FHCRC) {
pos += 2;
}
de_dbg(c, "compressed blocks at %d\n", (int)pos);
if(!d->output_file) {
fi = de_finfo_create(c);
if(member_name && c->filenames_from_file) {
de_finfo_set_name_from_ucstring(c, fi, member_name);
fi->original_filename_flag = 1;
}
if(mod_time_ts.is_valid) {
fi->mod_time = mod_time_ts;
}
d->output_file = dbuf_create_output_file(c, member_name?NULL:"bin", fi, 0);
}
ret = de_uncompress_deflate(c->infile, pos, c->infile->len - pos, d->output_file, &cmpr_data_len);
if(!ret) goto done;
pos += cmpr_data_len;
crc32_field = (de_uint32)de_getui32le(pos);
de_dbg(c, "crc32: 0x%08x\n", (unsigned int)crc32_field);
pos += 4;
// TODO: Validate CRCs
isize = de_getui32le(pos);
de_dbg(c, "uncompressed size (mod 2^32): %u\n", (unsigned int)isize);
pos += 4;
retval = 1;
done:
if(retval)
*member_size = pos - pos1;
else
*member_size = 0;
ucstring_destroy(member_name);
de_finfo_destroy(c, fi);
de_dbg_indent_restore(c, saved_indent_level);
return retval;
}
static void do_card_index(deark *c, lctx *d, de_int64 cardnum, de_int64 pos)
{
de_int64 datapos;
de_int64 bitmap_len;
de_int64 w, h;
de_int64 src_rowspan;
de_int64 text_len;
de_int64 text_pos;
struct deark_bitmap *img = NULL;
de_finfo *fi_bitmap = NULL;
de_finfo *fi_text = NULL;
const char *cardtype;
de_ucstring *name = NULL;
int saved_indent_level;
de_dbg_indent_save(c, &saved_indent_level);
datapos = de_getui32le(pos+6);
de_dbg(c, "card #%d at %d, dpos=%d\n", (int)cardnum, (int)pos, (int)datapos);
de_dbg_indent(c, 1);
if(datapos>=c->infile->len) goto done;
bitmap_len = de_getui16le(datapos);
de_dbg(c, "bitmap length: %d\n", (int)bitmap_len);
if(bitmap_len==0) {
text_len = de_getui16le(datapos+2);
text_pos = datapos+4;
}
else {
text_len = de_getui16le(datapos + bitmap_len + 10);
text_pos = datapos + bitmap_len + 10;
}
de_dbg(c, "text length: %d\n", (int)text_len);
if(bitmap_len==0 && text_len==0) {
cardtype = "empty";
}
else if(bitmap_len==0) {
cardtype = "text-only";
}
else if(text_len==0) {
cardtype = "graphics-only";
}
else {
cardtype = "graphics+text";
}
de_dbg(c, "card type: %s\n", cardtype);
if(bitmap_len==0 && text_len==0) {
goto done;
}
name = ucstring_create(c);
dbuf_read_to_ucstring(c->infile, pos+11, 40, name, DE_CONVFLAG_STOP_AT_NUL, DE_ENCODING_ASCII);
de_dbg(c, "name: \"%s\"\n", ucstring_get_printable_sz(name));
// Text
if(text_len!=0 && c->extract_level>=2) {
fi_text = de_finfo_create(c);
if(c->filenames_from_file)
de_finfo_set_name_from_ucstring(c, fi_text, name);
do_text_data(c, d, fi_text, text_pos, text_len);
}
// Bitmap
if(bitmap_len==0) goto done;
fi_bitmap = de_finfo_create(c);
if(c->filenames_from_file)
de_finfo_set_name_from_ucstring(c, fi_bitmap, name);
w = de_getui16le(datapos+2);
h = de_getui16le(datapos+4);
de_dbg(c, "bitmap dimensions: %dx%d\n", (int)w, (int)h);
img = de_bitmap_create(c, w, h, 1);
src_rowspan = ((w+15)/16)*2;
de_convert_and_write_image_bilevel(c->infile, datapos+10,
w, h, src_rowspan, 0, fi_bitmap, 0);
done:
ucstring_destroy(name);
de_bitmap_destroy(img);
de_finfo_destroy(c, fi_bitmap);
de_finfo_destroy(c, fi_text);
de_dbg_indent_restore(c, saved_indent_level);
}
// Read any version of BITMAPINFOHEADER.
//
// Note: Some of this BMP parsing code is duplicated in the
// de_fmtutil_get_bmpinfo() library function. The BMP module's needs are
// not quite aligned with what that function is intended for, and it
// would be too messy to try to add the necessary features to it.
static int read_infoheader(deark *c, lctx *d, de_int64 pos)
{
de_int64 height_raw;
de_int64 clr_used_raw;
int cmpr_ok;
int retval = 0;
de_dbg(c, "info header at %d\n", (int)pos);
de_dbg_indent(c, 1);
de_dbg(c, "info header size: %d\n", (int)d->infohdrsize);
if(d->version==DE_BMPVER_OS2V1) {
d->width = de_getui16le(pos+4);
d->height = de_getui16le(pos+6);
}
else {
d->width = dbuf_geti32le(c->infile, pos+4);
height_raw = dbuf_geti32le(c->infile, pos+8);
if(height_raw<0) {
d->top_down = 1;
d->height = -height_raw;
}
else {
d->height = height_raw;
}
}
de_dbg(c, "dimensions: %dx%d\n", (int)d->width, (int)d->height);
if(!de_good_image_dimensions(c, d->width, d->height)) {
goto done;
}
if(d->top_down) {
de_dbg(c, "orientation: top-down\n");
}
// Already read, in detect_bmp_version()
de_dbg(c, "bits/pixel: %d\n", (int)d->bitcount);
if(d->bitcount!=0 && d->bitcount!=1 && d->bitcount!=2 && d->bitcount!=4 &&
d->bitcount!=8 && d->bitcount!=16 && d->bitcount!=24 && d->bitcount!=32)
{
de_err(c, "Bad bits/pixel: %d\n", (int)d->bitcount);
goto done;
}
if(d->version==DE_BMPVER_OS2V1) {
d->bytes_per_pal_entry = 3;
}
else {
// Already read, in detect_bmp_version()
de_dbg(c, "compression (etc.): %d\n", (int)d->compression_field);
d->bytes_per_pal_entry = 4;
}
d->compression_type = CMPR_NONE; // Temporary default
cmpr_ok = 0;
switch(d->compression_field) {
case 0: // BI_RGB
if(d->bitcount==16 || d->bitcount==32) {
d->bitfields_type = BF_DEFAULT;
}
d->compression_type = CMPR_NONE;
cmpr_ok = 1;
break;
case 1: // BI_RLE8
d->compression_type=CMPR_RLE8;
cmpr_ok = 1;
break;
case 2: // BI_RLE4
d->compression_type=CMPR_RLE4;
cmpr_ok = 1;
break;
case 3: // BI_BITFIELDS or Huffman_1D
if(d->version==DE_BMPVER_OS2V2) {
if(d->bitcount==1) {
d->compression_type=CMPR_HUFFMAN1D;
cmpr_ok = 1;
}
}
else if(d->bitcount==16 || d->bitcount==32) {
d->compression_type = CMPR_NONE;
cmpr_ok = 1;
if(d->infohdrsize>=52) {
d->bitfields_type = BF_IN_HEADER;
}
else {
d->bitfields_type = BF_SEGMENT;
d->bitfields_segment_len = 12;
}
}
break;
case 4: // BI_JPEG or RLE24
if(d->version==DE_BMPVER_OS2V2) {
if(d->bitcount==24) {
d->compression_type=CMPR_RLE24;
cmpr_ok = 1;
}
}
else {
d->compression_type=CMPR_JPEG;
cmpr_ok = 1;
}
break;
case 5: // BI_PNG
d->compression_type=CMPR_PNG;
cmpr_ok = 1;
break;
case 6: // BI_ALPHABITFIELDS
if(d->bitcount==16 || d->bitcount==32) {
d->compression_type = CMPR_NONE;
cmpr_ok = 1;
if(d->infohdrsize>=56) {
d->bitfields_type = BF_IN_HEADER;
}
else {
d->bitfields_type = BF_SEGMENT;
d->bitfields_segment_len = 16;
}
}
break;
}
if(!cmpr_ok) {
de_err(c, "Unsupported compression type: %d\n", (int)d->compression_field);
goto done;
}
if(d->infohdrsize>=24) {
d->size_image = de_getui32le(pos+20);
de_dbg(c, "biSizeImage: %d\n", (int)d->size_image);
}
if(d->infohdrsize>=32) {
d->xpelspermeter = dbuf_geti32le(c->infile, pos+24);
d->ypelspermeter = dbuf_geti32le(c->infile, pos+28);
de_dbg(c, "density: %dx%d pixels/meter\n", (int)d->xpelspermeter, (int)d->ypelspermeter);
}
if(d->infohdrsize>=36)
clr_used_raw = de_getui32le(pos+32);
else
clr_used_raw = 0;
if(d->bitcount>=1 && d->bitcount<=8 && clr_used_raw==0) {
d->pal_entries = ((de_int64)1)<<d->bitcount;
}
else {
d->pal_entries = clr_used_raw;
}
de_dbg(c, "number of palette colors: %d\n", (int)d->pal_entries);
// Note that after 40 bytes, WINV345 and OS2V2 header fields are different,
// so we have to pay more attention to the version.
if(d->bitfields_type==BF_IN_HEADER) {
do_read_bitfields(c, d, pos+40, d->infohdrsize>=56 ? 16 : 12);
}
if(d->bitfields_type==BF_DEFAULT) {
set_default_bitfields(c, d);
}
if(d->version==DE_BMPVER_WINV345 && d->infohdrsize>=108) {
dbuf_read_fourcc(c->infile, pos+56, &d->cstype4cc, 1);
de_dbg(c, "CSType: 0x%08x ('%s')\n", (unsigned int)d->cstype4cc.id,
d->cstype4cc.id_printable);
}
if(d->version==DE_BMPVER_WINV345 && d->infohdrsize>=124 &&
(d->cstype4cc.id==CODE_MBED || d->cstype4cc.id==CODE_LINK))
{
d->profile_offset_raw = de_getui32le(pos+112);
de_dbg(c, "profile offset: %d+%d\n", FILEHEADER_SIZE,
(int)d->profile_offset_raw);
d->profile_size = de_getui32le(pos+116);
de_dbg(c, "profile size: %d\n", (int)d->profile_size);
}
retval = 1;
done:
de_dbg_indent(c, -1);
return retval;
}
// create bitmap_font object
static void do_make_image(deark *c, lctx *d)
{
struct de_bitmap_font *font = NULL;
de_int64 i;
de_int64 pos;
font = de_create_bitmap_font(c);
font->has_nonunicode_codepoints = 1;
if(d->encoding!=DE_ENCODING_UNKNOWN)
font->has_unicode_codepoints = 1;
font->prefer_unicode = 0;
font->nominal_width = (int)d->nominal_char_width;
font->nominal_height = (int)d->char_height;
font->num_chars = d->num_chars_stored;
font->char_array = de_malloc(c, font->num_chars * sizeof(struct de_bitmap_font_char));
for(i=0; i<d->num_chars_stored; i++) {
de_int64 char_width;
de_int64 char_offset;
de_int32 char_index;
de_int64 num_tiles;
de_int64 tile;
de_int64 row;
pos = d->hdrsize + d->char_entry_size*i;
char_width = de_getui16le(pos);
if(d->char_entry_size==6)
char_offset = de_getui32le(pos+2);
else
char_offset = de_getui16le(pos+2);
de_dbg2(c, "char[%d] width=%d offset=%d\n", (int)(d->first_char + i), (int)char_width, (int)char_offset);
num_tiles = (char_width+7)/8;
if(i == d->num_chars_stored-1) {
// Arbitrarily put the "absolute space" char at codepoint 256,
// and U+2002 EN SPACE (best I can do).
font->char_array[i].codepoint_nonunicode = 256;
font->char_array[i].codepoint_unicode = 0x2002;
}
else {
char_index = (de_int32)d->first_char + (de_int32)i;
font->char_array[i].codepoint_nonunicode = char_index;
if(font->has_unicode_codepoints) {
if(char_index<32 && d->dfCharSet==0) {
// This kind of font usually doesn't have glyphs below 32.
// If it does, assume that they are VT100 line drawing characters.
font->char_array[i].codepoint_unicode =
de_char_to_unicode(c, 95+char_index, DE_ENCODING_DEC_SPECIAL_GRAPHICS);
}
else {
font->char_array[i].codepoint_unicode =
de_char_to_unicode(c, char_index, d->encoding);
}
}
}
font->char_array[i].width = (int)char_width;
font->char_array[i].height = (int)d->char_height;
font->char_array[i].rowspan = num_tiles;
font->char_array[i].bitmap = de_malloc(c, d->char_height * num_tiles);
for(row=0; row<d->char_height; row++) {
for(tile=0; tile<num_tiles; tile++) {
font->char_array[i].bitmap[row * font->char_array[i].rowspan + tile] =
de_getbyte(char_offset + tile*d->char_height + row);
}
}
}
de_font_bitmap_font_to_image(c, font, d->fi, 0);
if(font) {
if(font->char_array) {
for(i=0; i<font->num_chars; i++) {
de_free(c, font->char_array[i].bitmap);
}
de_free(c, font->char_array);
}
de_destroy_bitmap_font(c, font);
}
}
static int do_read_header(deark *c, lctx *d)
{
de_int64 dfType;
de_int64 dfPixWidth;
de_int64 dfPixHeight;
de_int64 dfMaxWidth;
int is_vector = 0;
int retval = 0;
d->fnt_version = de_getui16le(0);
de_dbg(c, "dfVersion: 0x%04x\n", (int)d->fnt_version);
if(d->fnt_version==0x0300)
d->hdrsize = 148;
else
d->hdrsize = 118;
dfType = de_getui16le(66);
de_dbg(c, "dfType: 0x%04x\n", (int)dfType);
is_vector = (dfType&0x1)?1:0;
de_dbg(c, "Font type: %s\n", is_vector?"vector":"bitmap");
d->dfPoints = de_getui16le(68);
de_dbg(c, "dfPoints: %d\n", (int)d->dfPoints);
dfPixWidth = de_getui16le(86);
de_dbg(c, "dfPixWidth: %d\n", (int)dfPixWidth);
dfPixHeight = de_getui16le(88);
de_dbg(c, "dfPixHeight: %d\n", (int)dfPixHeight);
d->dfCharSet = de_getbyte(85);
de_dbg(c, "charset: 0x%02x\n", (int)d->dfCharSet);
if(d->dfCharSet==0x00) { // "ANSI"
d->encoding = DE_ENCODING_WINDOWS1252; // Guess
}
else if(d->dfCharSet==0xff) { // "OEM"
d->encoding = DE_ENCODING_CP437_G; // Guess
}
else {
d->encoding = DE_ENCODING_UNKNOWN;
}
dfMaxWidth = de_getui16le(93);
de_dbg(c, "dfMaxWidth: %d\n", (int)dfMaxWidth);
if(dfPixWidth!=dfMaxWidth && dfPixWidth!=0) {
de_warn(c, "dfMaxWidth (%d) does not equal dfPixWidth (%d)\n",
(int)dfMaxWidth, (int)dfPixWidth);
}
d->first_char = de_getbyte(95);
d->last_char = de_getbyte(96);
de_dbg(c, "first char: %d, last char: %d\n", (int)d->first_char, (int)d->last_char);
if(is_vector) {
de_err(c, "This is a vector font. Not supported.\n");
goto done;
}
// Apparently, the first 117 bytes (through the dfBitsOffset field) are
// common to all versions
if(d->fnt_version<0x0200) {
de_err(c, "This version of FNT is not supported\n");
goto done;
}
if(d->fnt_version >= 0x0200) {
d->dfFace = de_getui32le(105);
}
// There is an extra character at the end of the table that is an
// "absolute-space" character, and is guaranteed to be blank.
d->num_chars_stored = (de_int64)d->last_char - d->first_char + 1 + 1;
if(d->fnt_version==0x0300) {
d->char_entry_size = 6;
}
else {
d->char_entry_size = 4;
}
d->char_table_size = d->char_entry_size * d->num_chars_stored;
de_dbg(c, "character index at %d, size %d, %d bytes/entry\n", (int)d->hdrsize,
(int)d->char_table_size, (int)d->char_entry_size);
do_prescan_chars(c, d);
if(d->detected_max_width<1) goto done;
d->nominal_char_width = d->detected_max_width;
d->char_height = dfPixHeight;
retval = 1;
done:
return retval;
}
