/* * PostScript driver Type42 font functions * * Copyright 2002 Huw D M Davies for CodeWeavers * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #include "config.h" #include "wine/port.h" #include <string.h> #include <stdlib.h> #include <stdarg.h> #include <stdio.h> #include <assert.h> #include <locale.h> #include "windef.h" #include "winbase.h" #include "wingdi.h" #include "psdrv.h" #include "wine/debug.h" WINE_DEFAULT_DEBUG_CHANNEL(psdrv); #define GET_BE_WORD(ptr) MAKEWORD( ((BYTE *)(ptr))[1], ((BYTE *)(ptr))[0] ) #define GET_BE_DWORD(ptr) ((DWORD)MAKELONG( GET_BE_WORD(&((WORD *)(ptr))[1]), \ GET_BE_WORD(&((WORD *)(ptr))[0]) )) #define MS_MAKE_TAG( _x1, _x2, _x3, _x4 ) \ ( ( (DWORD)_x4 << 24 ) | \ ( (DWORD)_x3 << 16 ) | \ ( (DWORD)_x2 << 8 ) | \ (DWORD)_x1 ) typedef struct { DWORD MS_tag; DWORD len, check; BYTE *data; BOOL write; } OTTable; static const OTTable tables_templ[] = { { MS_MAKE_TAG('c','v','t',' '), 0, 0, NULL, TRUE }, { MS_MAKE_TAG('f','p','g','m'), 0, 0, NULL, TRUE }, { MS_MAKE_TAG('g','d','i','r'), 0, 0, NULL, TRUE }, { MS_MAKE_TAG('g','l','y','f'), 0, 0, NULL, FALSE }, { MS_MAKE_TAG('h','e','a','d'), 0, 0, NULL, TRUE }, { MS_MAKE_TAG('h','h','e','a'), 0, 0, NULL, TRUE }, { MS_MAKE_TAG('h','m','t','x'), 0, 0, NULL, TRUE }, { MS_MAKE_TAG('l','o','c','a'), 0, 0, NULL, TRUE }, { MS_MAKE_TAG('m','a','x','p'), 0, 0, NULL, TRUE }, { MS_MAKE_TAG('p','r','e','p'), 0, 0, NULL, TRUE }, { 0, 0, 0, NULL, 0 } }; struct tagTYPE42 { OTTable tables[sizeof(tables_templ)/sizeof(tables_templ[0])]; int glyf_tab, loca_tab, head_tab; /* indices of glyf, loca and head tables */ int hmtx_tab, maxp_tab; int num_of_written_tables; DWORD glyph_sent_size; BOOL *glyph_sent; DWORD emsize; DWORD *glyf_blocks; }; #define GLYPH_SENT_INC 128 #define FLIP_ORDER(x) \ ( ( ((x) & 0xff) << 24) | \ ( ((x) & 0xff00) << 8) | \ ( ((x) & 0xff0000) >> 8) | \ ( ((x) & 0xff000000) >> 24) ) /* Some flags for composite glyphs. See glyf table in OT spec */ #define ARG_1_AND_2_ARE_WORDS (1L << 0) #define WE_HAVE_A_SCALE (1L << 3) #define MORE_COMPONENTS (1L << 5) #define WE_HAVE_AN_X_AND_Y_SCALE (1L << 6) #define WE_HAVE_A_TWO_BY_TWO (1L << 7) static BOOL LoadTable(HDC hdc, OTTable *table) { unsigned int i; if(table->MS_tag == MS_MAKE_TAG('g','d','i','r')) return TRUE; table->len = GetFontData(hdc, table->MS_tag, 0, NULL, 0); table->data = HeapAlloc(GetProcessHeap(), 0, (table->len + 3) & ~3 ); memset(table->data + ((table->len - 1) & ~3), 0, sizeof(DWORD)); GetFontData(hdc, table->MS_tag, 0, table->data, table->len); table->check = 0; for(i = 0; i < (table->len + 3) / 4; i++) table->check += FLIP_ORDER(*((DWORD*)(table->data) + i)); return TRUE; } static BOOL get_glyf_pos(TYPE42 *t42, DWORD index, DWORD *start, DWORD *end) { WORD loca_format = GET_BE_WORD(t42->tables[t42->head_tab].data + 50); TRACE("loca_format = %d\n", loca_format); switch(loca_format) { case 0: *start = GET_BE_WORD(((WORD*)t42->tables[t42->loca_tab].data) + index); *start <<= 1; *end = GET_BE_WORD(((WORD*)t42->tables[t42->loca_tab].data) + index + 1); *end <<= 1; break; case 1: *start = GET_BE_DWORD(((DWORD*)t42->tables[t42->loca_tab].data) + index); *end = GET_BE_DWORD(((DWORD*)t42->tables[t42->loca_tab].data) + index + 1); break; default: ERR("Unknown loca_format %d\n", loca_format); return FALSE; } return TRUE; } TYPE42 *T42_download_header(PHYSDEV dev, char *ps_name, RECT *bbox, UINT emsize) { DWORD i, j, tablepos, nb_blocks, glyf_off = 0, loca_off = 0, cur_off; WORD num_of_tables = sizeof(tables_templ) / sizeof(tables_templ[0]) - 1; char *buf; TYPE42 *t42; static const char start[] = /* name, fontbbox */ "25 dict begin\n" " /FontName /%s def\n" " /Encoding 256 array 0 1 255{1 index exch /.notdef put} for\n" " def\n" " /PaintType 0 def\n" " /FontMatrix [1 0 0 1 0 0] def\n" " /FontBBox [%f %f %f %f] def\n" " /FontType 42 def\n" " /CharStrings 256 dict begin\n" " /.notdef 0 def\n" " currentdict end def\n" " /sfnts [\n"; static const char TT_offset_table[] = "<00010000%04x%04x%04x%04x\n"; static const char TT_table_dir_entry[] = "%08x%08x%08x%08x\n"; static const char storage[] ="]\nhavetype42gdir{pop}{{string} forall}ifelse\n"; static const char end[] = "] def\n" "havetype42gdir{/GlyphDirectory 256 dict def\n" " sfnts 0 get dup\n" " %d <6c6f6378000000000000000000000000> putinterval\n" /* replace loca entry with dummy locx */ " %d <676c6678000000000000000000000000> putinterval\n" /* replace glyf entry with dummy glfx */ " }if\n" "currentdict end dup /FontName get exch definefont pop\n"; t42 = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*t42)); memcpy(t42->tables, tables_templ, sizeof(tables_templ)); t42->loca_tab = t42->glyf_tab = t42->head_tab = t42->hmtx_tab = -1; t42->emsize = emsize; t42->num_of_written_tables = 0; for(i = 0; i < num_of_tables; i++) { LoadTable(dev->hdc, t42->tables + i); if(t42->tables[i].len > 0xffff && t42->tables[i].write) break; if(t42->tables[i].write) t42->num_of_written_tables++; if(t42->tables[i].MS_tag == MS_MAKE_TAG('l','o','c','a')) t42->loca_tab = i; else if(t42->tables[i].MS_tag == MS_MAKE_TAG('g','l','y','f')) t42->glyf_tab = i; else if(t42->tables[i].MS_tag == MS_MAKE_TAG('h','e','a','d')) t42->head_tab = i; else if(t42->tables[i].MS_tag == MS_MAKE_TAG('h','m','t','x')) t42->hmtx_tab = i; else if(t42->tables[i].MS_tag == MS_MAKE_TAG('m','a','x','p')) t42->maxp_tab = i; } if(i < num_of_tables) { TRACE("Table %d has length %d. Will use Type 1 font instead.\n", i, t42->tables[i].len); T42_free(t42); return NULL; } t42->glyph_sent_size = GLYPH_SENT_INC; t42->glyph_sent = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, t42->glyph_sent_size * sizeof(*(t42->glyph_sent))); buf = HeapAlloc(GetProcessHeap(), 0, sizeof(start) + strlen(ps_name) + 100); push_lc_numeric("C"); sprintf(buf, start, ps_name, (float)bbox->left / emsize, (float)bbox->bottom / emsize, (float)bbox->right / emsize, (float)bbox->top / emsize); pop_lc_numeric(); PSDRV_WriteSpool(dev, buf, strlen(buf)); t42->num_of_written_tables++; /* explicitly add glyf */ sprintf(buf, TT_offset_table, t42->num_of_written_tables, t42->num_of_written_tables, t42->num_of_written_tables, t42->num_of_written_tables); PSDRV_WriteSpool(dev, buf, strlen(buf)); tablepos = 12 + t42->num_of_written_tables * 16; cur_off = 12; for(i = 0; i < num_of_tables; i++) { if(!t42->tables[i].write) continue; sprintf(buf, TT_table_dir_entry, FLIP_ORDER(t42->tables[i].MS_tag), t42->tables[i].check, t42->tables[i].len ? tablepos : 0, t42->tables[i].len); PSDRV_WriteSpool(dev, buf, strlen(buf)); tablepos += ((t42->tables[i].len + 3) & ~3); if(t42->tables[i].MS_tag == MS_MAKE_TAG('l','o','c','a')) loca_off = cur_off; cur_off += 16; } sprintf(buf, TT_table_dir_entry, FLIP_ORDER(t42->tables[t42->glyf_tab].MS_tag), t42->tables[t42->glyf_tab].check, tablepos, t42->tables[t42->glyf_tab].len); PSDRV_WriteSpool(dev, buf, strlen(buf)); PSDRV_WriteSpool(dev, "00>\n", 4); /* add an extra byte for old PostScript rips */ glyf_off = cur_off; for(i = 0; i < num_of_tables; i++) { if(t42->tables[i].len == 0 || !t42->tables[i].write) continue; PSDRV_WriteSpool(dev, "<", 1); for(j = 0; j < ((t42->tables[i].len + 3) & ~3); j++) { sprintf(buf, "%02x", t42->tables[i].data[j]); PSDRV_WriteSpool(dev, buf, strlen(buf)); if(j % 16 == 15) PSDRV_WriteSpool(dev, "\n", 1); } PSDRV_WriteSpool(dev, "00>\n", 4); /* add an extra byte for old PostScript rips */ } /* glyf_blocks is a 0 terminated list, holding the start offset of each block. For simplicity glyf_blocks[0] is 0 */ nb_blocks = 2; t42->glyf_blocks = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (nb_blocks + 1) * sizeof(DWORD)); for(i = 0; i < GET_BE_WORD(t42->tables[t42->maxp_tab].data + 4); i++) { DWORD start, end, size; get_glyf_pos(t42, i, &start, &end); size = end - t42->glyf_blocks[nb_blocks-2]; if(size > 0x2000 && t42->glyf_blocks[nb_blocks-1] % 4 == 0) { nb_blocks++; t42->glyf_blocks = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, t42->glyf_blocks, (nb_blocks + 1) * sizeof(DWORD)); } t42->glyf_blocks[nb_blocks-1] = end; } PSDRV_WriteSpool(dev, "[ ", 2); for(i = 1; t42->glyf_blocks[i]; i++) { sprintf(buf,"%d ", t42->glyf_blocks[i] - t42->glyf_blocks[i-1] + 1); /* again add one byte for old PostScript rips */ PSDRV_WriteSpool(dev, buf, strlen(buf)); if(i % 8 == 0) PSDRV_WriteSpool(dev, "\n", 1); } PSDRV_WriteSpool(dev, storage, sizeof(storage) - 1); sprintf(buf, end, loca_off, glyf_off); PSDRV_WriteSpool(dev, buf, strlen(buf)); HeapFree(GetProcessHeap(), 0, buf); return t42; } BOOL T42_download_glyph(PHYSDEV dev, DOWNLOAD *pdl, DWORD index, char *glyph_name) { DWORD start, end, i; char *buf; TYPE42 *t42; const char glyph_def[] = "/%s findfont exch 1 index\n" "havetype42gdir\n" "{/GlyphDirectory get begin %d exch def end}\n" "{/sfnts get 4 index get 3 index 2 index putinterval pop}\n" "ifelse\n" "/CharStrings get\n" "begin\n" " /%s %d def\n" "end\n" "pop pop\n"; TRACE("%d %s\n", index, glyph_name); assert(pdl->type == Type42); t42 = pdl->typeinfo.Type42; if(index < t42->glyph_sent_size) { if(t42->glyph_sent[index]) return TRUE; } else { t42->glyph_sent_size = (index / GLYPH_SENT_INC + 1) * GLYPH_SENT_INC; t42->glyph_sent = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, t42->glyph_sent, t42->glyph_sent_size * sizeof(*(t42->glyph_sent))); } if(!get_glyf_pos(t42, index, &start, &end)) return FALSE; TRACE("start = %x end = %x\n", start, end); if(GET_BE_WORD(t42->tables[t42->glyf_tab].data + start) == 0xffff) { /* Composite glyph */ BYTE *sg_start = t42->tables[t42->glyf_tab].data + start + 10; DWORD sg_flags, sg_index; char sg_name[MAX_G_NAME + 1]; do { sg_flags = GET_BE_WORD(sg_start); sg_index = GET_BE_WORD(sg_start + 2); TRACE("Sending subglyph %04x for glyph %04x\n", sg_index, index); get_glyph_name(dev->hdc, sg_index, sg_name); T42_download_glyph(dev, pdl, sg_index, sg_name); sg_start += 4; if(sg_flags & ARG_1_AND_2_ARE_WORDS) sg_start += 4; else sg_start += 2; if(sg_flags & WE_HAVE_A_SCALE) sg_start += 2; else if(sg_flags & WE_HAVE_AN_X_AND_Y_SCALE) sg_start += 4; else if(sg_flags & WE_HAVE_A_TWO_BY_TWO) sg_start += 8; } while(sg_flags & MORE_COMPONENTS); } for(i = 1; t42->glyf_blocks[i]; i++) if(start < t42->glyf_blocks[i]) break; buf = HeapAlloc(GetProcessHeap(), 0, sizeof(glyph_def) + strlen(pdl->ps_name) + 100); /* we don't have a string for the gdir and glyf tables, but we do have a string for the TT header. So the offset we need is tables - 2 */ sprintf(buf, "%d %d\n", t42->num_of_written_tables - 2 + i, start - t42->glyf_blocks[i-1]); PSDRV_WriteSpool(dev, buf, strlen(buf)); PSDRV_WriteSpool(dev, "<", 1); for(i = start; i < end; i++) { sprintf(buf, "%02x", *(t42->tables[t42->glyf_tab].data + i)); PSDRV_WriteSpool(dev, buf, strlen(buf)); if((i - start) % 16 == 15) PSDRV_WriteSpool(dev, "\n", 1); } PSDRV_WriteSpool(dev, ">\n", 2); sprintf(buf, glyph_def, pdl->ps_name, index, glyph_name, index); PSDRV_WriteSpool(dev, buf, strlen(buf)); t42->glyph_sent[index] = TRUE; HeapFree(GetProcessHeap(), 0, buf); return TRUE; } void T42_free(TYPE42 *t42) { OTTable *table; for(table = t42->tables; table->MS_tag; table++) HeapFree(GetProcessHeap(), 0, table->data); HeapFree(GetProcessHeap(), 0, t42->glyph_sent); HeapFree(GetProcessHeap(), 0, t42->glyf_blocks); HeapFree(GetProcessHeap(), 0, t42); return; }