From 80096425836c7c322a5ffb3dd7e96e2247d062d0 Mon Sep 17 00:00:00 2001 From: Akira Kakuto Date: Tue, 22 Sep 2020 01:13:44 +0000 Subject: Simplify font related code. Fix a bug in determinant calculation. (S. Hirata) git-svn-id: svn://tug.org/texlive/trunk@56400 c570f23f-e606-0410-a88d-b1316a301751 --- Build/source/texk/dvipdfm-x/ChangeLog | 13 + Build/source/texk/dvipdfm-x/Makefile.am | 1 - Build/source/texk/dvipdfm-x/Makefile.in | 1 - Build/source/texk/dvipdfm-x/cid.c | 617 ++++++---------- Build/source/texk/dvipdfm-x/cid.h | 53 +- Build/source/texk/dvipdfm-x/cid_p.h | 68 -- Build/source/texk/dvipdfm-x/cidtype0.c | 1072 ++++++++++++++++------------ Build/source/texk/dvipdfm-x/cidtype0.h | 20 +- Build/source/texk/dvipdfm-x/cidtype2.c | 521 +++++++------- Build/source/texk/dvipdfm-x/cidtype2.h | 10 +- Build/source/texk/dvipdfm-x/configure | 22 +- Build/source/texk/dvipdfm-x/configure.ac | 2 +- Build/source/texk/dvipdfm-x/dpxutil.c | 2 + Build/source/texk/dvipdfm-x/pdfdev.c | 71 +- Build/source/texk/dvipdfm-x/pdfdraw.c | 14 +- Build/source/texk/dvipdfm-x/pdfdraw.h | 2 - Build/source/texk/dvipdfm-x/pdffont.c | 1132 +++++++++++++++++------------- Build/source/texk/dvipdfm-x/pdffont.h | 134 +++- Build/source/texk/dvipdfm-x/pkfont.c | 29 +- Build/source/texk/dvipdfm-x/pkfont.h | 2 +- Build/source/texk/dvipdfm-x/truetype.c | 174 ++--- Build/source/texk/dvipdfm-x/truetype.h | 2 +- Build/source/texk/dvipdfm-x/type0.c | 485 ++----------- Build/source/texk/dvipdfm-x/type0.h | 27 +- Build/source/texk/dvipdfm-x/type1.c | 129 ++-- Build/source/texk/dvipdfm-x/type1.h | 2 +- Build/source/texk/dvipdfm-x/type1c.c | 172 ++--- Build/source/texk/dvipdfm-x/type1c.h | 2 +- 28 files changed, 2229 insertions(+), 2550 deletions(-) delete mode 100644 Build/source/texk/dvipdfm-x/cid_p.h diff --git a/Build/source/texk/dvipdfm-x/ChangeLog b/Build/source/texk/dvipdfm-x/ChangeLog index 84997bbc54a..eb545679bcf 100644 --- a/Build/source/texk/dvipdfm-x/ChangeLog +++ b/Build/source/texk/dvipdfm-x/ChangeLog @@ -1,3 +1,16 @@ +2020-09-22 Shunsaku Hirata + + * cid.[ch], cidtype0.[ch], cidtype2.[ch], pdfdev.c, + pdffont.[ch], pkfont.[ch], truetype.[ch], type0.[ch], + type1.[ch], type1c.[ch]: Revise font related code and largely + simplify it. Type0 and CIDFont now use the same struct as + simple fonts. + * Makefile.am, cid_p.h: Remove cid_p.h. + * pdfdraw.[ch]: Fix a bug in calculation of determinant. + Enable few functions for future improvement. + * dpxutil.c: Fix a bug in the roll operation. + * configure.ac: Version 20200922. + 2020-09-07 Shunsaku Hirata * spc_misc.c: Fix a bug that the upper limit of stack id is wrong. diff --git a/Build/source/texk/dvipdfm-x/Makefile.am b/Build/source/texk/dvipdfm-x/Makefile.am index 160a03028e2..c738137d3d0 100644 --- a/Build/source/texk/dvipdfm-x/Makefile.am +++ b/Build/source/texk/dvipdfm-x/Makefile.am @@ -26,7 +26,6 @@ xdvipdfmx_SOURCES = \ cid_basefont.h \ cid.c \ cid.h \ - cid_p.h \ cidtype0.c \ cidtype0.h \ cidtype2.c \ diff --git a/Build/source/texk/dvipdfm-x/Makefile.in b/Build/source/texk/dvipdfm-x/Makefile.in index c86fc81ea0d..d68d9c40961 100644 --- a/Build/source/texk/dvipdfm-x/Makefile.in +++ b/Build/source/texk/dvipdfm-x/Makefile.in @@ -669,7 +669,6 @@ xdvipdfmx_SOURCES = \ cid_basefont.h \ cid.c \ cid.h \ - cid_p.h \ cidtype0.c \ cidtype0.h \ cidtype2.c \ diff --git a/Build/source/texk/dvipdfm-x/cid.c b/Build/source/texk/dvipdfm-x/cid.c index 42554ad3123..bb3fb18604c 100644 --- a/Build/source/texk/dvipdfm-x/cid.c +++ b/Build/source/texk/dvipdfm-x/cid.c @@ -40,14 +40,8 @@ #include "cidtype0.h" #include "cidtype2.h" -#include "cid_p.h" #include "cid.h" -#include "cff.h" - -#define CIDFONT_DEBUG 3 -#define CIDFONT_DEBUG_STR "CIDFont" - #define PDF_CID_SUPPORT_MIN 2 #define PDF_CID_SUPPORT_MAX 6 @@ -104,6 +98,7 @@ CIDSysInfo CSI_UNICODE = { /* * Optional supplement after alias name. */ + static struct { const char *name; int index; @@ -115,275 +110,134 @@ static struct { }; static void release_opt (cid_opt *opt); -static CIDSysInfo *get_cidsysinfo (const char *map_name, fontmap_opt *fmap_opt); - -static int cidoptflags = 0; - -#if 0 -int -CIDFont_require_version (void) -{ - return PDF_CID_SUPPORT_MIN; -} -#endif - -static CIDFont * -CIDFont_new (void) -{ - CIDFont *font = NULL; - - font = NEW(1, struct CIDFont); - - font->name = NULL; - font->fontname = NULL; - font->ident = NULL; - - /* - * CIDFont - */ - font->subtype = -1; - font->flags = FONT_FLAG_NONE; - font->csi = NULL; - font->options = NULL; - (font->parent)[0] = -1; /* Horizontal */ - (font->parent)[1] = -1; /* Vertical */ +static int get_cidsysinfo (CIDSysInfo *csi, const char *map_name, fontmap_opt *fmap_opt); - /* - * PDF Font Resource - */ - font->indirect = NULL; - font->fontdict = NULL; - font->descriptor = NULL; - - return font; -} - -/* It does write PDF objects. */ -static void -CIDFont_flush (CIDFont *font) -{ - if (font) { - if (font->indirect) pdf_release_obj(font->indirect); - font->indirect = NULL; - if (font->fontdict) pdf_release_obj(font->fontdict); - font->fontdict = NULL; - if (font->descriptor) pdf_release_obj(font->descriptor); - font->descriptor = NULL; - } -} - -static void -CIDFont_release (CIDFont *font) -{ - if (font) { - if (font->indirect) - ERROR("%s: Object not flushed.", CIDFONT_DEBUG_STR); - if (font->fontdict) - ERROR("%s: Object not flushed.", CIDFONT_DEBUG_STR); - if (font->descriptor) - ERROR("%s: Object not flushed.", CIDFONT_DEBUG_STR); - - if (font->fontname) RELEASE(font->fontname); - if (font->name) RELEASE(font->name); - if (font->ident) RELEASE(font->ident); - if (font->csi) { - if (font->csi->registry) - RELEASE(font->csi->registry); - if (font->csi->ordering) - RELEASE(font->csi->ordering); - RELEASE(font->csi); - } - if (font->options) - release_opt(font->options); - } -} - -char * -CIDFont_get_fontname (CIDFont *font) -{ - ASSERT(font); - return font->fontname; -} - -char * -CIDFont_get_ident (CIDFont *font) -{ - ASSERT(font); - return font->ident; -} +int opt_flags_cidfont = 0; int -CIDFont_get_opt_index (CIDFont *font) +CIDFont_is_ACCFont (pdf_font *font) { - int opt_index; + int i; + CIDSysInfo *csi; ASSERT(font); - if (font->options) - opt_index = font->options->index; - else { - opt_index = 0; + csi = &font->cid.csi; + for (i = ACC_START; i <= ACC_END ; i++) { + if (!strcmp(csi->registry, CIDFont_stdcc_def[i].registry) && + !strcmp(csi->ordering, CIDFont_stdcc_def[i].ordering)) + return 1; } - return opt_index; -} - -int -CIDFont_get_subtype (CIDFont *font) -{ - ASSERT(font); - return font->subtype; + return 0; } int -CIDFont_get_embedding (CIDFont *font) +CIDFont_is_UCSFont (pdf_font *font) { - ASSERT(font); - return font->options->embed; -} + CIDSysInfo *csi; -CIDSysInfo * -CIDFont_get_CIDSysInfo (CIDFont *font) -{ ASSERT(font); - return font->csi; -} - -/* - * Returns ID of parent Type0 font - * wmode: 0 for horizontal, 1 for vertical - */ -int -CIDFont_get_parent_id (CIDFont *font, int wmode) -{ - ASSERT(font); + csi = &font->cid.csi; - if (wmode < 0 || wmode > 1) - ERROR("%s: Invalid wmode value.", CIDFONT_DEBUG_STR); + if (!strcmp(csi->ordering, "UCS") || + !strcmp(csi->ordering, "UCS2")) + return 1; - return (font->parent)[wmode]; + return 0; } -pdf_obj * -CIDFont_get_resource (CIDFont *font) +char * +CIDFont_get_usedchars (pdf_font *font) { - ASSERT(font); - - if (!font->indirect) - font->indirect = pdf_ref_obj(font->fontdict); + if (!font->usedchars) { + font->usedchars = NEW(8192, char); + memset(font->usedchars, 0, 8192*sizeof(char)); + } - return pdf_link_obj(font->indirect); + return font->usedchars; } -/* - * Set parent Type0 font. - */ -void -CIDFont_attach_parent (CIDFont *font, int parent_id, int wmode) +char * +CIDFont_get_usedchars_v (pdf_font *font) { - ASSERT(font); - - if (wmode < 0 || wmode > 1) - ERROR("%s: Invalid wmode value.", CIDFONT_DEBUG_STR); - - if (font->parent[wmode] >= 0) - WARN("%s: CIDFont already have a parent Type1 font.", CIDFONT_DEBUG_STR); + if (!font->cid.usedchars_v) { + font->cid.usedchars_v = NEW(8192, char); + memset(font->cid.usedchars_v, 0, 8192*sizeof(char)); + } - font->parent[wmode] = parent_id; + return font->cid.usedchars_v; } -int -CIDFont_is_ACCFont (CIDFont *font) + +static int +source_font_type (pdf_font *font) { - int i; + int type = PDF_FONT_FONTTYPE_CIDTYPE0; ASSERT(font); - if (!font->csi) - ERROR("%s: CIDSystemInfo undefined.", CIDFONT_DEBUG_STR); - - for (i = ACC_START; i <= ACC_END ; i++) { - if (!strcmp(font->csi->registry, CIDFont_stdcc_def[i].registry) && - !strcmp(font->csi->ordering, CIDFont_stdcc_def[i].ordering)) - return 1; + if (font->flags & CIDFONT_FLAG_TYPE1) { + type = PDF_FONT_FONTTYPE_TYPE1; + } else if (font->flags & CIDFONT_FLAG_TYPE1C) { + type = PDF_FONT_FONTTYPE_TYPE1C; + } else if (font->flags & CIDFONT_FLAG_TRUETYPE) { + type = PDF_FONT_FONTTYPE_TRUETYPE; } - return 0; -} - -int -CIDFont_is_UCSFont (CIDFont *font) -{ - ASSERT(font); - if (!strcmp(font->csi->ordering, "UCS") || - !strcmp(font->csi->ordering, "UCS2")) - return 1; - return 0; + return type; } -/* FIXME */ -int -CIDFont_get_flag (CIDFont *font, int mask) +void +pdf_font_load_cidfont (pdf_font *font) { - ASSERT(font); - return ((font->flags & mask) ? 1 : 0); -} + int error = 0; -static void -CIDFont_dofont (CIDFont *font) -{ - if (!font || !font->indirect) + if (!font || !font->reference) return; if (dpx_conf.verbose_level > 0) - MESG(":%s", font->ident); + MESG(":%s", font->filename); if (dpx_conf.verbose_level > 1) { if (font->fontname) MESG("[%s]", font->fontname); } switch (font->subtype) { - case CIDFONT_TYPE0: + case PDF_FONT_FONTTYPE_CIDTYPE0: if(dpx_conf.verbose_level > 0) MESG("[CIDFontType0]"); - if (CIDFont_get_flag(font, CIDFONT_FLAG_TYPE1)) - CIDFont_type0_t1dofont(font); - else if (CIDFont_get_flag(font, CIDFONT_FLAG_TYPE1C)) - CIDFont_type0_t1cdofont(font); - else - CIDFont_type0_dofont(font); + switch (source_font_type(font)) { + case PDF_FONT_FONTTYPE_TYPE1: + error = CIDFont_type0_t1dofont(font); + break; + case PDF_FONT_FONTTYPE_TYPE1C: + error = CIDFont_type0_t1cdofont(font); + break; + default: + error = CIDFont_type0_dofont(font); + break; + } break; - case CIDFONT_TYPE2: + case PDF_FONT_FONTTYPE_CIDTYPE2: if(dpx_conf.verbose_level > 0) MESG("[CIDFontType2]"); - CIDFont_type2_dofont(font); - break; - default: - ERROR("%s: Unknown CIDFontType %d.", CIDFONT_DEBUG_STR, font->subtype); + error = CIDFont_type2_dofont(font); break; } -} - -/* - * - */ -int -CIDFont_is_BaseFont (CIDFont *font) -{ - ASSERT(font); - return (font->flags & FONT_FLAG_BASEFONT) ? 1 : 0; + if (error) + ERROR("Error occurred while loading font: %s", font->filename); + + return; } #include "pdfparse.h" #include "cid_basefont.h" -static int CIDFont_base_open (CIDFont *font, - const char *name, CIDSysInfo *cmap_csi, cid_opt *opt); - static int -CIDFont_base_open (CIDFont *font, const char *name, CIDSysInfo *cmap_csi, cid_opt *opt) +CIDFont_base_open (pdf_font *font, const char *name, cid_opt *opt) { pdf_obj *fontdict, *descriptor; char *fontname = NULL; @@ -433,7 +287,7 @@ CIDFont_base_open (CIDFont *font, const char *name, CIDSysInfo *cmap_csi, cid_op } font->fontname = fontname; - font->flags |= FONT_FLAG_BASEFONT; + font->flags |= PDF_FONT_FLAG_BASEFONT; { char *registry, *ordering; int supplement; @@ -446,22 +300,12 @@ CIDFont_base_open (CIDFont *font, const char *name, CIDSysInfo *cmap_csi, cid_op registry = pdf_string_value(pdf_lookup_dict(tmp, "Registry")); ordering = pdf_string_value(pdf_lookup_dict(tmp, "Ordering")); supplement = pdf_number_value(pdf_lookup_dict(tmp, "Supplement")); - if (cmap_csi) { /* NULL for accept any */ - if (strcmp(registry, cmap_csi->registry) || - strcmp(ordering, cmap_csi->ordering)) - ERROR("Inconsistent CMap used for CID-keyed font %s.", - cid_basefont[idx].fontname); - else if (supplement < cmap_csi->supplement) { - WARN("CMap has higher supplement number than CIDFont: %s", fontname); - WARN("Some chracters may not be displayed or printed."); - } - } - font->csi = NEW(1, CIDSysInfo); - font->csi->registry = NEW(strlen(registry)+1, char); - font->csi->ordering = NEW(strlen(ordering)+1, char); - strcpy(font->csi->registry, registry); - strcpy(font->csi->ordering, ordering); - font->csi->supplement = supplement; + + font->cid.csi.registry = NEW(strlen(registry)+1, char); + font->cid.csi.ordering = NEW(strlen(ordering)+1, char); + strcpy(font->cid.csi.registry, registry); + strcpy(font->cid.csi.ordering, ordering); + font->cid.csi.supplement = supplement; } { @@ -473,15 +317,15 @@ CIDFont_base_open (CIDFont *font, const char *name, CIDSysInfo *cmap_csi, cid_op type = pdf_name_value(tmp); if (!strcmp(type, "CIDFontType0")) - font->subtype = CIDFONT_TYPE0; + font->subtype = PDF_FONT_FONTTYPE_CIDTYPE0; else if (!strcmp(type, "CIDFontType2")) - font->subtype = CIDFONT_TYPE2; + font->subtype = PDF_FONT_FONTTYPE_CIDTYPE2; else { ERROR("Unknown CIDFontType \"%s\"", type); } } - if (cidoptflags & CIDFONT_FORCE_FIXEDPITCH) { + if (opt_flags_cidfont & CIDFONT_FORCE_FIXEDPITCH) { if (pdf_lookup_dict(fontdict, "W")) { pdf_remove_dict(fontdict, "W"); } @@ -495,7 +339,7 @@ CIDFont_base_open (CIDFont *font, const char *name, CIDSysInfo *cmap_csi, cid_op pdf_add_dict(descriptor, pdf_new_name("Type"), pdf_new_name("FontDescriptor")); pdf_add_dict(descriptor, pdf_new_name("FontName"), pdf_new_name(fontname)); - font->fontdict = fontdict; + font->resource = fontdict; font->descriptor = descriptor; opt->embed = 0; @@ -503,184 +347,154 @@ CIDFont_base_open (CIDFont *font, const char *name, CIDSysInfo *cmap_csi, cid_op return 0; } - - -#define CACHE_ALLOC_SIZE 16u - -struct FontCache { - int num; - int max; - CIDFont **fonts; -}; - -static struct FontCache *__cache = NULL; - -#define CHECK_ID(n) do {\ - if (! __cache)\ - ERROR("%s: CIDFont cache not initialized.", CIDFONT_DEBUG_STR);\ - if ((n) < 0 || (n) >= __cache->num)\ - ERROR("%s: Invalid ID %d", CIDFONT_DEBUG_STR, (n));\ - } while (0) - -static void -CIDFont_cache_init (void) -{ - if (__cache) - ERROR("%s: Already initialized.", CIDFONT_DEBUG_STR); - - __cache = NEW(1, struct FontCache); - - __cache->max = CACHE_ALLOC_SIZE; - __cache->fonts = NEW(__cache->max, struct CIDFont *); - __cache->num = 0; -} - -CIDFont * -CIDFont_cache_get (int font_id) -{ - CHECK_ID(font_id); - return __cache->fonts[font_id]; -} - -/* - * cmap_csi is NULL if CMap is Identity. - */ int -CIDFont_cache_find (const char *map_name, - CIDSysInfo *cmap_csi, fontmap_opt *fmap_opt) +pdf_font_cidfont_lookup_cache (pdf_font *fonts, int count, const char *map_name, CIDSysInfo *cmap_csi, fontmap_opt *fmap_opt) { - int font_id = -1; - CIDFont *font = NULL; - cid_opt *opt = NULL; - - if (!__cache) - CIDFont_cache_init(); - - opt = NEW(1, cid_opt); - opt->style = fmap_opt->style; - opt->index = fmap_opt->index; - opt->embed = (fmap_opt->flags & FONTMAP_OPT_NOEMBED) ? 0 : 1; - opt->name = NULL; - opt->csi = get_cidsysinfo(map_name, fmap_opt); - opt->stemv = fmap_opt->stemv; - - if (!opt->csi && cmap_csi) { + int font_id = -1; + pdf_font *font = NULL; + cid_opt opt; + int has_csi; + + ASSERT(fonts); + + opt.style = fmap_opt->style; + opt.embed = (fmap_opt->flags & FONTMAP_OPT_NOEMBED) ? 0 : 1; + opt.csi.registry = NULL; + opt.csi.ordering = NULL; + opt.csi.supplement = 0; + has_csi = get_cidsysinfo(&opt.csi, map_name, fmap_opt); + opt.stemv = fmap_opt->stemv; + + if (!has_csi && cmap_csi) { /* * No CIDSystemInfo supplied explicitly. Copy from CMap's one if available. * It is not neccesary for CID-keyed fonts. But TrueType requires them. */ - opt->csi = NEW(1, CIDSysInfo); - opt->csi->registry = NEW(strlen(cmap_csi->registry)+1, char); - strcpy(opt->csi->registry, cmap_csi->registry); - opt->csi->ordering = NEW(strlen(cmap_csi->ordering)+1, char); - strcpy(opt->csi->ordering, cmap_csi->ordering); - opt->csi->supplement = cmap_csi->supplement; + opt.csi.registry = NEW(strlen(cmap_csi->registry)+1, char); + strcpy(opt.csi.registry, cmap_csi->registry); + opt.csi.ordering = NEW(strlen(cmap_csi->ordering)+1, char); + strcpy(opt.csi.ordering, cmap_csi->ordering); + opt.csi.supplement = cmap_csi->supplement; + has_csi = 1; } /* * Here, we do not compare font->ident and map_name because of * implicit CIDSystemInfo supplied by CMap for TrueType. */ - for (font_id = 0; font_id < __cache->num; font_id++) { - font = __cache->fonts[font_id]; - if (!strcmp(font->name, map_name) && - font->options->style == opt->style && - font->options->index == opt->index) { - if (font->options->embed == opt->embed) { + for (font_id = 0; font_id < count; font_id++) { + font = &fonts[font_id]; + if (font->subtype != PDF_FONT_FONTTYPE_CIDTYPE0 && + font->subtype != PDF_FONT_FONTTYPE_CIDTYPE2) + continue; + if (!strcmp(font->filename, map_name) && + font->cid.options.style == opt.style && + font->index == fmap_opt->index) { + if (font->cid.options.embed == opt.embed) { /* * Case 1: CSI not available (Identity CMap) * Font is TrueType --> continue * Font is CIDFont --> break * Case 2: CSI matched --> break */ - if (!opt->csi) { - if (font->subtype == CIDFONT_TYPE2) + if (!has_csi) { + if (font->subtype == PDF_FONT_FONTTYPE_CIDTYPE2) continue; else break; - } else if (!strcmp(font->csi->registry, opt->csi->registry) && - !strcmp(font->csi->ordering, opt->csi->ordering)) { - if (font->subtype == CIDFONT_TYPE2) - font->csi->supplement = - MAX(opt->csi->supplement, font->csi->supplement); + } else if (!strcmp(font->cid.csi.registry, opt.csi.registry) && + !strcmp(font->cid.csi.ordering, opt.csi.ordering)) { + if (font->subtype == PDF_FONT_FONTTYPE_CIDTYPE2) + font->cid.csi.supplement = + MAX(opt.csi.supplement, font->cid.csi.supplement); /* FIXME: font modified */ break; } - } else if (CIDFont_is_BaseFont(font)) { - opt->embed = 0; + } else if (font->flags & PDF_FONT_FLAG_BASEFONT) { break; } } } + release_opt(&opt); - if (font_id < __cache->num && cmap_csi) { - if (strcmp(font->csi->registry, cmap_csi->registry) || - strcmp(font->csi->ordering, cmap_csi->ordering)) - ERROR("%s: Incompatible CMap for CIDFont \"%s\"", - CIDFONT_DEBUG_STR, map_name); - } - - if (font_id == __cache->num) { - font = CIDFont_new(); - if (CIDFont_type0_open(font, map_name, cmap_csi, opt, 0) < 0 && - CIDFont_type2_open(font, map_name, cmap_csi, opt) < 0 && - CIDFont_type0_open(font, map_name, cmap_csi, opt, - CIDFONT_FLAG_TYPE1) < 0 && - CIDFont_type0_open(font, map_name, cmap_csi, opt, - CIDFONT_FLAG_TYPE1C) < 0 && - CIDFont_base_open (font, map_name, cmap_csi, opt) < 0) { - CIDFont_release(font); - release_opt(opt); - return -1; - } else { - if (__cache->num >= __cache->max) { - __cache->max += CACHE_ALLOC_SIZE; - __cache->fonts = RENEW(__cache->fonts, - __cache->max, struct CIDFont *); - } - font->name = NEW(strlen(map_name)+1, char); - strcpy(font->name, map_name); - font->ident = NEW(strlen(map_name)+1, char); - strcpy(font->ident, map_name); - font->options = opt; - __cache->fonts[font_id] = font; - (__cache->num)++; - } - } else if (opt) { - release_opt(opt); - } - - return font_id; + return (font_id < count) ? font_id : -1; } -void -CIDFont_cache_close (void) +int +pdf_font_open_cidfont (pdf_font *font, const char *map_name, CIDSysInfo *cmap_csi, fontmap_opt *fmap_opt) { - int font_id; - - if (__cache) { - for (font_id = 0; - font_id < __cache->num; font_id++) { - CIDFont *font; - - font = __cache->fonts[font_id]; - - if (dpx_conf.verbose_level > 0) - MESG("(CID"); - - CIDFont_dofont (font); - CIDFont_flush (font); - CIDFont_release(font); + cid_opt opt; + int has_csi; + + opt.style = fmap_opt->style; + opt.embed = (fmap_opt->flags & FONTMAP_OPT_NOEMBED) ? 0 : 1; + opt.csi.registry = NULL; + opt.csi.ordering = NULL; + opt.csi.supplement = 0; + has_csi = get_cidsysinfo(&opt.csi, map_name, fmap_opt); + opt.stemv = fmap_opt->stemv; + + if (!has_csi && cmap_csi) { + /* + * No CIDSystemInfo supplied explicitly. Copy from CMap's one if available. + * It is not neccesary for CID-keyed fonts. But TrueType requires them. + */ + opt.csi.registry = NEW(strlen(cmap_csi->registry)+1, char); + strcpy(opt.csi.registry, cmap_csi->registry); + opt.csi.ordering = NEW(strlen(cmap_csi->ordering)+1, char); + strcpy(opt.csi.ordering, cmap_csi->ordering); + opt.csi.supplement = cmap_csi->supplement; + has_csi = 1; + } - RELEASE(font); + if (CIDFont_type0_open(font, map_name, fmap_opt->index, &opt) < 0 && + CIDFont_type2_open(font, map_name, fmap_opt->index, &opt) < 0 && + CIDFont_type0_open_from_t1 (font, map_name, fmap_opt->index, &opt) < 0 && + CIDFont_type0_open_from_t1c(font, map_name, fmap_opt->index, &opt) < 0 && + CIDFont_base_open (font, map_name, &opt) < 0) { + release_opt(&opt); + return -1; + } - if (dpx_conf.verbose_level > 0) - MESG(")"); + font->filename = NEW(strlen(map_name)+1, char); + strcpy(font->filename, map_name); + font->ident = NEW(strlen(map_name)+1, char); + strcpy(font->ident, map_name); + font->index = fmap_opt->index; + font->cid.options = opt; + + if (font->cid.csi.registry && font->cid.csi.ordering) { + if (cmap_csi) { + if (strcmp(font->cid.csi.registry, cmap_csi->registry) || + strcmp(font->cid.csi.ordering, cmap_csi->ordering)) { + WARN("Inconsistent ROS found:\n"); + MESG("\tFont: %s-%s-%d\n", font->cid.csi.registry, font->cid.csi.ordering, font->cid.csi.supplement); + MESG("\tCMap: %s-%s-%d\n", cmap_csi->registry, cmap_csi->ordering, cmap_csi->supplement); + ERROR("Incompatible CMap specified for this font."); + } + if (font->cid.csi.supplement < cmap_csi->supplement) { + font->cid.csi.supplement = cmap_csi->supplement; + } + } + } else { + ASSERT(font->subtype == PDF_FONT_FONTTYPE_CIDTYPE2); + if (cmap_csi) { + font->cid.csi.registry = NEW(strlen(cmap_csi->registry)+1, char); + strcpy(font->cid.csi.registry, cmap_csi->registry); + font->cid.csi.ordering = NEW(strlen(cmap_csi->ordering)+1, char); + strcpy(font->cid.csi.ordering, cmap_csi->ordering); + font->cid.csi.supplement = cmap_csi->supplement; + } else { /* This means font's internal glyph ordering. */ + font->cid.csi.registry = NEW(strlen("Adobe")+1, char); + strcpy(font->cid.csi.registry, "Adobe"); + font->cid.csi.ordering = NEW(strlen("Identity")+1, char); + strcpy(font->cid.csi.ordering, "Identity"); + font->cid.csi.supplement = 0; } - RELEASE(__cache->fonts); - RELEASE(__cache); - __cache = NULL; } + + return 0; } + /******************************* OPTIONS *******************************/ /* @@ -692,20 +506,16 @@ CIDFont_cache_close (void) static void release_opt (cid_opt *opt) { - if (opt->csi) { - if (opt->csi->registry) - RELEASE(opt->csi->registry); - if (opt->csi->ordering) - RELEASE(opt->csi->ordering); - RELEASE(opt->csi); - } - RELEASE(opt); + if (opt->csi.registry) + RELEASE(opt->csi.registry); + if (opt->csi.ordering) + RELEASE(opt->csi.ordering); } -static CIDSysInfo * -get_cidsysinfo (const char *map_name, fontmap_opt *fmap_opt) +static int +get_cidsysinfo (CIDSysInfo *csi, const char *map_name, fontmap_opt *fmap_opt) { - CIDSysInfo *csi = NULL; + int has_csi = 0; int sup_idx; int i, csi_idx = -1, n, m; @@ -713,7 +523,7 @@ get_cidsysinfo (const char *map_name, fontmap_opt *fmap_opt) sup_idx = (sup_idx > SUP_IDX_MAX) ? SUP_IDX_MAX : sup_idx; if (!fmap_opt || !fmap_opt->charcoll) - return NULL; + return 0; /* First try alias for standard one. */ for (i = 0; CIDFont_stdcc_alias[i].name != NULL; i++) { @@ -721,7 +531,6 @@ get_cidsysinfo (const char *map_name, fontmap_opt *fmap_opt) if (!strncmp(fmap_opt->charcoll, CIDFont_stdcc_alias[i].name, n)) { csi_idx = CIDFont_stdcc_alias[i].index; - csi = NEW(1, CIDSysInfo); csi->registry = NEW(strlen(CIDFont_stdcc_def[csi_idx].registry)+1, char); strcpy(csi->registry, CIDFont_stdcc_def[csi_idx].registry); csi->ordering = NEW(strlen(CIDFont_stdcc_def[csi_idx].ordering)+1, char); @@ -731,31 +540,28 @@ get_cidsysinfo (const char *map_name, fontmap_opt *fmap_opt) } else { /* Use heighest supported value for current output PDF version. */ csi->supplement = CIDFont_stdcc_def[csi_idx].supplement[sup_idx]; } + has_csi = 1; break; } } - if (csi == NULL) { + if (!has_csi) { char *p, *q; p = (char *) fmap_opt->charcoll; - csi = NEW(1, CIDSysInfo); /* Full REGISTRY-ORDERING-SUPPLEMENT */ p = strchr(fmap_opt->charcoll, '-'); if (!p || p[1] == '\0') - ERROR("%s: String can't be converted to REGISTRY-ORDERING-SUPPLEMENT: %s", - CIDFONT_DEBUG_STR, fmap_opt->charcoll); + ERROR("String can't be converted to REGISTRY-ORDERING-SUPPLEMENT: %s", fmap_opt->charcoll); p++; q = strchr(p, '-'); if (!q || q[1] == '\0') - ERROR("%s: String can't be converted to REGISTRY-ORDERING-SUPPLEMENT: %s", - CIDFONT_DEBUG_STR, fmap_opt->charcoll); + ERROR("String can't be converted to REGISTRY-ORDERING-SUPPLEMENT: %s", fmap_opt->charcoll); q++; if (!isdigit((unsigned char)q[0])) - ERROR("%s: String can't be converted to REGISTRY-ORDERING-SUPPLEMENT: %s", - CIDFONT_DEBUG_STR, fmap_opt->charcoll); + ERROR("String can't be converted to REGISTRY-ORDERING-SUPPLEMENT: %s", fmap_opt->charcoll); n = strlen(fmap_opt->charcoll) - strlen(p) - 1; csi->registry = NEW(n+1, char); @@ -769,6 +575,8 @@ get_cidsysinfo (const char *map_name, fontmap_opt *fmap_opt) csi->supplement = (int) strtoul(q, NULL, 10); + has_csi = 1; + /* Check for standart character collections. */ for (i = 0; CIDFont_stdcc_def[i].ordering != NULL; i++) { if ((CIDFont_stdcc_def[i].registry && @@ -783,22 +591,19 @@ get_cidsysinfo (const char *map_name, fontmap_opt *fmap_opt) if (csi && csi_idx >= 0) { if (csi->supplement > CIDFont_stdcc_def[csi_idx].supplement[sup_idx] && (fmap_opt->flags & FONTMAP_OPT_NOEMBED)) { - WARN("%s: Heighest supplement number supported in PDF-%d.%d for %s-%s is %d.", - CIDFONT_DEBUG_STR, pdf_get_version_major(), pdf_get_version_minor(), + WARN("Heighest supplement number supported in PDF-%d.%d for %s-%s is %d.", + pdf_get_version_major(), pdf_get_version_minor(), csi->registry, csi->ordering, CIDFont_stdcc_def[csi_idx].supplement[sup_idx]); - WARN("%s: Some character may not shown without embedded font (--> %s).", - CIDFONT_DEBUG_STR, map_name); + WARN("Some character may not shown without embedded font (--> %s).", map_name); } } - return csi; + return has_csi; } void CIDFont_set_flags (int flags) { - CIDFont_type0_set_flags(flags); - CIDFont_type2_set_flags(flags); - cidoptflags |= flags; + opt_flags_cidfont |= flags; } diff --git a/Build/source/texk/dvipdfm-x/cid.h b/Build/source/texk/dvipdfm-x/cid.h index cf713dc3b4a..0e5457e0e54 100644 --- a/Build/source/texk/dvipdfm-x/cid.h +++ b/Build/source/texk/dvipdfm-x/cid.h @@ -21,59 +21,26 @@ #ifndef _CID_H_ #define _CID_H_ -/* CIDFont types */ -#define CIDFONT_TYPE0 1 -#define CIDFONT_TYPE2 2 - -typedef struct { - char *registry; - char *ordering; - int supplement; -} CIDSysInfo; +#include "pdffont.h" extern CIDSysInfo CSI_IDENTITY; extern CIDSysInfo CSI_UNICODE; -typedef struct CIDFont CIDFont; - -#if 0 -extern int CIDFont_require_version (void); -#endif +extern int opt_flags_cidfont; extern void CIDFont_set_flags (int flags); #define CIDFONT_FORCE_FIXEDPITCH (1 << 1) -#include "pdfobj.h" -#include "type0.h" - -/* FIXME */ -/* Converted from Type 1 */ -#define CIDFONT_FLAG_TYPE1 (1 << 8) -#define CIDFONT_FLAG_TYPE1C (1 << 9) -#define CIDFONT_FLAG_TRUETYPE (1 << 10) - -extern char *CIDFont_get_fontname (CIDFont *font); - -extern char *CIDFont_get_ident (CIDFont *font); /* FIXME */ -extern int CIDFont_get_opt_index (CIDFont *font); /* FIXME */ +extern char *CIDFont_get_usedchars (pdf_font *font); +extern char *CIDFont_get_usedchars_v (pdf_font *font); -extern int CIDFont_get_flag (CIDFont *font, int mask); - -extern int CIDFont_get_subtype (CIDFont *font); -extern int CIDFont_get_embedding (CIDFont *font); -extern pdf_obj *CIDFont_get_resource (CIDFont *font); -extern CIDSysInfo *CIDFont_get_CIDSysInfo (CIDFont *font); - -extern void CIDFont_attach_parent (CIDFont *font, int parent_id, int wmode); -extern int CIDFont_get_parent_id (CIDFont *font, int wmode); - -extern int CIDFont_is_BaseFont (CIDFont *font); -extern int CIDFont_is_ACCFont (CIDFont *font); -extern int CIDFont_is_UCSFont (CIDFont *font); +extern int CIDFont_is_ACCFont (pdf_font *font); +extern int CIDFont_is_UCSFont (pdf_font *font); #include "fontmap.h" -extern int CIDFont_cache_find (const char *map_name, CIDSysInfo *cmap_csi, fontmap_opt *fmap_opt); -extern CIDFont *CIDFont_cache_get (int fnt_id); -extern void CIDFont_cache_close (void); +extern int pdf_font_cidfont_lookup_cache (pdf_font *fonts, int count, const char *map_name, CIDSysInfo *cmap_csi, fontmap_opt *fmap_opt); + +extern int pdf_font_open_cidfont (pdf_font *font, const char *map_name, CIDSysInfo *cmap_csi, fontmap_opt *fmap_opt); +extern void pdf_font_load_cidfont (pdf_font *font); #endif /* _CID_H_ */ diff --git a/Build/source/texk/dvipdfm-x/cid_p.h b/Build/source/texk/dvipdfm-x/cid_p.h deleted file mode 100644 index d0701d4893e..00000000000 --- a/Build/source/texk/dvipdfm-x/cid_p.h +++ /dev/null @@ -1,68 +0,0 @@ -/* This is dvipdfmx, an eXtended version of dvipdfm by Mark A. Wicks. - - Copyright (C) 2002-2020 by Jin-Hwan Cho and Shunsaku Hirata, - the dvipdfmx project team. - - Copyright (C) 1998, 1999 by Mark A. Wicks - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, or - (at your option) any later version. - - This program 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 General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. -*/ - -#ifndef _CID_P_H_ -#define _CID_P_H_ - -#define FONT_FLAG_NONE 0 -#define FONT_FLAG_BASEFONT (1 << 0) -#define FONT_FLAG_ACCFONT (1 << 1) -#define FONT_FLAG_UCSFONT (1 << 2) - -#include "fontmap.h" -#define FONT_STYLE_NONE FONTMAP_STYLE_NONE -#define FONT_STYLE_BOLD FONTMAP_STYLE_BOLD -#define FONT_STYLE_ITALIC FONTMAP_STYLE_ITALIC -#define FONT_STYLE_BOLDITALIC FONTMAP_STYLE_BOLDITALIC - -typedef struct -{ - char *name; /* Unused */ - CIDSysInfo *csi; - int index; - int style; - int embed; - int stemv; -} cid_opt; - -struct CIDFont -{ - char *ident; /* Map record entry */ - char *name; /* Fontname or filename */ - char *fontname; /* PostScript font name */ - /* - * CIDFont Specific - */ - int subtype; /* CIDFONT_TYPE0 or CIDFONT_TYPE2 */ - int flags; /* BASEFONT */ - int parent[2]; /* Parent type0 font of this CID-keyed font: H, V */ - CIDSysInfo *csi; /* Character collection */ - cid_opt *options; /* Options from map record */ - /* - * PDF Font Resource - */ - pdf_obj *indirect; /* Indirect reference to CIDFont dictionary */ - pdf_obj *fontdict; /* CIDFont dictionary */ - pdf_obj *descriptor; /* FontDescriptor */ -}; - -#endif /* _CID_P_H_ */ diff --git a/Build/source/texk/dvipdfm-x/cidtype0.c b/Build/source/texk/dvipdfm-x/cidtype0.c index cb47521de8c..d6c10fa1d19 100644 --- a/Build/source/texk/dvipdfm-x/cidtype0.c +++ b/Build/source/texk/dvipdfm-x/cidtype0.c @@ -57,7 +57,6 @@ #include "cmap.h" #include "type0.h" #include "cid.h" -#include "cid_p.h" #include "cidtype0.h" /* Type1 --> CFF CIDFont */ @@ -71,14 +70,6 @@ #include "cmap_write.h" #include "fontmap.h" -static int opt_flags = 0; - -void -CIDFont_type0_set_flags (int flags) -{ - opt_flags = flags; -} - /* * PDF Reference 3rd. ed., p.340, "Glyph Metrics in CID Fonts". */ @@ -87,16 +78,17 @@ CIDFont_type0_set_flags (int flags) #endif static void -add_CIDHMetrics (pdf_obj *fontdict, +add_CIDHMetrics (sfnt *sfont, pdf_obj *fontdict, unsigned char *CIDToGIDMap, unsigned short last_cid, struct tt_maxp_table *maxp, struct tt_head_table *head, struct tt_longMetrics *hmtx) { pdf_obj *w_array, *an_array = NULL; - int cid, start = 0, prev = 0; - double defaultAdvanceWidth; - int empty = 1; + int cid, start = 0, prev = 0; + double defaultAdvanceWidth; + int empty = 1; + (void) sfont; /* unsed */ defaultAdvanceWidth = PDFUNIT(hmtx[0].advance); /* * We alway use format: @@ -164,15 +156,15 @@ add_CIDVMetrics (sfnt *sfont, pdf_obj *fontdict, struct tt_head_table *head, struct tt_longMetrics *hmtx) { pdf_obj *w2_array, *an_array = NULL; - int cid; + int cid; #if 0 - int prev = 0, start = 0; + int prev = 0, start = 0; #endif struct tt_VORG_table *vorg; struct tt_vhea_table *vhea = NULL; struct tt_longMetrics *vmtx = NULL; - double defaultAdvanceHeight, defaultVertOriginY; - int empty = 1; + double defaultAdvanceHeight, defaultVertOriginY; + int empty = 1; /* * No accurate vertical metrics can be obtained by simple way if the @@ -323,7 +315,7 @@ add_CIDMetrics (sfnt *sfont, pdf_obj *fontdict, sfnt_locate_table(sfont, "hmtx"); hmtx = tt_read_longMetrics(sfont, maxp->numGlyphs, hhea->numOfLongHorMetrics, hhea->numOfExSideBearings); - add_CIDHMetrics(fontdict, CIDToGIDMap, last_cid, maxp, head, hmtx); + add_CIDHMetrics(sfont, fontdict, CIDToGIDMap, last_cid, maxp, head, hmtx); if (need_vmetrics) add_CIDVMetrics(sfont, fontdict, CIDToGIDMap, last_cid, maxp, head, hmtx); @@ -339,12 +331,12 @@ add_CIDMetrics (sfnt *sfont, pdf_obj *fontdict, * Create an instance of embeddable font. */ static int -write_fontfile (CIDFont *font, cff_font *cffont) +write_fontfile (pdf_font *font, cff_font *cffont) { - cff_index *topdict, *fdarray, *private; + cff_index *topdict, *fdarray, *private; unsigned char *dest; - int destlen = 0, i, size; - int offset, topdict_offset, fdarray_offset; + int destlen = 0, i, size; + int offset, topdict_offset, fdarray_offset; /* DICT sizes (offset set to long int) */ topdict = cff_new_index(1); @@ -467,130 +459,8 @@ write_fontfile (CIDFont *font, cff_font *cffont) return destlen; } -static char * -CIDFont_type0_get_used_chars(CIDFont *font) { - int parent_id; - char *used_chars; - - if ((parent_id = CIDFont_get_parent_id(font, 0)) < 0 && - (parent_id = CIDFont_get_parent_id(font, 1)) < 0) - ERROR("No parent Type 0 font !"); - - used_chars = Type0Font_get_usedchars(Type0Font_cache_get(parent_id)); - if (!used_chars) - ERROR("Unexpected error: Font not actually used???"); - - return used_chars; -} - -typedef struct -{ - FILE *fp; - sfnt *sfont; - cff_font *cffont; -} CIDType0Info; - -typedef enum { - CID_OPEN_ERROR_NO_ERROR = 0, - CID_OPEN_ERROR_CANNOT_OPEN_FILE = -1, - CID_OPEN_ERROR_NOT_SFNT_FONT = -2, - CID_OPEN_ERROR_NO_CFF_TABLE = -3, - CID_OPEN_ERROR_CANNOT_OPEN_CFF_FONT = -4, - CID_OPEN_ERROR_NOT_CIDFONT = -5, - CID_OPEN_ERROR_IS_CIDFONT = -6, -} CIDType0Error; - -static void -CIDType0Error_Show (CIDType0Error error, const char *name) -{ - switch (error) { - case CID_OPEN_ERROR_CANNOT_OPEN_FILE: - ERROR("Could not open OpenType font file: %s", name); - case CID_OPEN_ERROR_NOT_SFNT_FONT: - ERROR("Could not open SFNT font file: %s", name); - case CID_OPEN_ERROR_NO_CFF_TABLE: - ERROR("Not a CFF/OpenType font: %s", name); - case CID_OPEN_ERROR_CANNOT_OPEN_CFF_FONT: - ERROR("Could not open CFF font: %s", name); - case CID_OPEN_ERROR_NOT_CIDFONT: - ERROR("Not a CIDFont: %s", name); - case CID_OPEN_ERROR_IS_CIDFONT: - ERROR("Should not be a CIDFont: %s", name); - default: - break; - } -} - -static void -CIDFontInfo_init (CIDType0Info *info) -{ - memset(info, 0, sizeof(CIDType0Info)); -} - -static void -CIDFontInfo_close (CIDType0Info *info) -{ - if (info->cffont) - cff_close(info->cffont); - - if (info->sfont) - sfnt_close(info->sfont); - - if (info->fp) - DPXFCLOSE(info->fp); - - CIDFontInfo_init(info); -} - -static CIDType0Error -CIDFont_type0_try_open (const char *name, - int index, - int required_cid, - CIDType0Info *info) -{ - ULONG offset = 0; - int is_cid; - - CIDFontInfo_init(info); - - info->fp = DPXFOPEN(name, DPX_RES_TYPE_OTFONT); - if (!info->fp) { - info->fp = DPXFOPEN(name, DPX_RES_TYPE_TTFONT); - if (!info->fp) - return CID_OPEN_ERROR_CANNOT_OPEN_FILE; - } - - info->sfont = sfnt_open(info->fp); - if (!info->sfont) - return CID_OPEN_ERROR_NOT_SFNT_FONT; - - if (info->sfont->type == SFNT_TYPE_TTC) - offset = ttc_read_offset(info->sfont, index); - - if ((info->sfont->type != SFNT_TYPE_TTC && - info->sfont->type != SFNT_TYPE_POSTSCRIPT) || - sfnt_read_table_directory(info->sfont, offset) < 0 || - (offset = sfnt_find_table_pos(info->sfont, "CFF ")) == 0) { - CIDFontInfo_close(info); - return CID_OPEN_ERROR_NO_CFF_TABLE; - } - - info->cffont = cff_open(info->sfont->stream, offset, 0); - if (!info->cffont) - return CID_OPEN_ERROR_CANNOT_OPEN_CFF_FONT; - - is_cid = info->cffont->flag & FONTTYPE_CIDFONT; - if (required_cid != is_cid) { - CIDFontInfo_close(info); - return required_cid ? CID_OPEN_ERROR_NOT_CIDFONT - : CID_OPEN_ERROR_IS_CIDFONT; - } - - return CID_OPEN_ERROR_NO_ERROR; -} - static void -CIDFont_type0_add_CIDSet(CIDFont *font, char *used_chars, card16 last_cid) { +CIDFont_type0_add_CIDSet (pdf_font *font, char *used_chars, card16 last_cid) { /* * CIDSet: * Length of CIDSet stream is not clear. Must be 8192 bytes long? @@ -604,55 +474,91 @@ CIDFont_type0_add_CIDSet(CIDFont *font, char *used_chars, card16 last_cid) { pdf_release_obj(cidset); } -void -CIDFont_type0_dofont (CIDFont *font) +int +CIDFont_type0_dofont (pdf_font *font) { - cff_font *cffont; - cff_index *charstrings, *idx; - cff_charsets *charset = NULL; - cff_fdselect *fdselect = NULL; - int charstring_len, max_len; - int destlen = 0; - int size, offset = 0; - card8 *data; - card16 num_glyphs = 0, gid; - int cid; - card16 cs_count, last_cid = 0; - int fd, prev_fd; - char *used_chars; + FILE *fp; + sfnt *sfont; + cff_font *cffont; + cff_index *charstrings, *idx; + cff_charsets *charset = NULL; + cff_fdselect *fdselect = NULL; + int charstring_len, max_len; + int destlen = 0; + int size, offset = 0; + card8 *data; + card16 num_glyphs = 0, gid; + int cid; + card16 cs_count, last_cid = 0; + int fd, prev_fd; + char *used_chars; unsigned char *CIDToGIDMap = NULL; - CIDType0Error error; - CIDType0Info info; ASSERT(font); - if (!font->indirect) - return; + if (!font->reference) + return 0; - pdf_add_dict(font->fontdict, + pdf_add_dict(font->resource, pdf_new_name("FontDescriptor"), pdf_ref_obj (font->descriptor)); - if (CIDFont_is_BaseFont(font)) - return; - else if (!CIDFont_get_embedding(font) && - (opt_flags & CIDFONT_FORCE_FIXEDPITCH)) { + if (font->flags & PDF_FONT_FLAG_BASEFONT) { + return 0; + } else if (!font->cid.options.embed && + (opt_flags_cidfont & CIDFONT_FORCE_FIXEDPITCH)) { /* No metrics needed. */ - pdf_add_dict(font->fontdict, + pdf_add_dict(font->resource, pdf_new_name("DW"), pdf_new_number(1000.0)); - return; + return 0; } - used_chars = CIDFont_type0_get_used_chars(font); + used_chars = font->usedchars; - error = CIDFont_type0_try_open(font->ident, CIDFont_get_opt_index(font), - 1, &info); - if (error != CID_OPEN_ERROR_NO_ERROR) { - CIDType0Error_Show(error, font->ident); - return; + fp = DPXFOPEN(font->filename, DPX_RES_TYPE_OTFONT); + if (!fp) { + fp = DPXFOPEN(font->filename, DPX_RES_TYPE_TTFONT); + if (!fp) { + WARN("Could not open file: %s", font->filename); + return -1; + } + } + + sfont = sfnt_open(fp); + if (!sfont) { + WARN("Failed to read font file: %s", font->filename); + DPXFCLOSE(fp); + return -1; + } + + if (sfont->type == SFNT_TYPE_TTC) + offset = ttc_read_offset(sfont, font->index); + + if ((sfont->type != SFNT_TYPE_TTC && + sfont->type != SFNT_TYPE_POSTSCRIPT) || + sfnt_read_table_directory(sfont, offset) < 0 || + (offset = sfnt_find_table_pos(sfont, "CFF ")) == 0) { + WARN("Not a CFF/OpenType font: %s", font->filename); + sfnt_close(sfont); + DPXFCLOSE(fp); + return -1; + } + + cffont = cff_open(sfont->stream, offset, 0); + if (!cffont) { + WARN("Failed to read CFF font data: %s", font->filename); + sfnt_close(sfont); + DPXFCLOSE(fp); + return -1; } - cffont = info.cffont; + if (!(cffont->flag & FONTTYPE_CIDFONT)) { + WARN("Unexpected type (CIDFont expected): %s", font->filename); + cff_close(cffont); + sfnt_close(sfont); + DPXFCLOSE(fp); + return -1; + } cff_read_charsets(cffont); @@ -672,7 +578,7 @@ CIDFont_type0_dofont (CIDFont *font) if (is_used_char2(used_chars, cid)) { gid = cff_charsets_lookup(cffont, (card16)cid); if (cid != 0 && gid == 0) { - WARN("Glyph for CID %u missing in font \"%s\".", (CID) cid, font->ident); + WARN("Glyph for CID %u missing in font \"%s\".", (CID) cid, font->filename); used_chars[cid/8] &= ~(1 << (7 - (cid % 8))); continue; } @@ -688,19 +594,20 @@ CIDFont_type0_dofont (CIDFont *font) * DW, W, DW2 and W2: * Those values are obtained from OpenType table (not TFM). */ - if (opt_flags & CIDFONT_FORCE_FIXEDPITCH) { - pdf_add_dict(font->fontdict, + if (opt_flags_cidfont & CIDFONT_FORCE_FIXEDPITCH) { + pdf_add_dict(font->resource, pdf_new_name("DW"), pdf_new_number(1000.0)); } else { - add_CIDMetrics(info.sfont, font->fontdict, CIDToGIDMap, last_cid, - ((CIDFont_get_parent_id(font, 1) < 0) ? 0 : 1)); + add_CIDMetrics(sfont, font->resource, CIDToGIDMap, last_cid, + font->cid.usedchars_v ? 1 : 0); } - if (!CIDFont_get_embedding(font)) { + if (!font->cid.options.embed) { RELEASE(CIDToGIDMap); - CIDFontInfo_close(&info); - - return; + cff_close(cffont); + sfnt_close(sfont); + DPXFCLOSE(fp); + return 0; } /* @@ -719,7 +626,11 @@ CIDFont_type0_dofont (CIDFont *font) offset = cff_tell(cffont); if ((cs_count = idx->count) < 2) { - ERROR("No valid charstring data found."); + WARN("No valid charstring data found: %s", font->filename); + cff_close(cffont); + sfnt_close(sfont); + DPXFCLOSE(fp); + return -1; } /* New Charsets data */ @@ -753,8 +664,19 @@ CIDFont_type0_dofont (CIDFont *font) gid_org = (CIDToGIDMap[2*cid] << 8)|(CIDToGIDMap[2*cid+1]); if ((size = (idx->offset)[gid_org+1] - (idx->offset)[gid_org]) - > CS_STR_LEN_MAX) - ERROR("Charstring too long: gid=%u", gid_org); + > CS_STR_LEN_MAX) { + WARN("Charstring too long: %s (gid=%u)", font->filename, gid_org); + RELEASE(data); + RELEASE(charstrings); + RELEASE(fdselect); + RELEASE(charset); + cff_release_index(idx); + RELEASE(CIDToGIDMap); + cff_close(cffont); + sfnt_close(sfont); + DPXFCLOSE(fp); + return -1; + } if (charstring_len + CS_STR_LEN_MAX >= max_len) { max_len = charstring_len + 2 * CS_STR_LEN_MAX; charstrings->data = RENEW(charstrings->data, max_len, card8); @@ -779,8 +701,19 @@ CIDFont_type0_dofont (CIDFont *font) } gid++; } - if (gid != num_glyphs) - ERROR("Unexpeced error: ?????"); + if (gid != num_glyphs) { + WARN("Unexpeced error: %s", font->filename); + RELEASE(data); + RELEASE(charstrings); + RELEASE(fdselect); + RELEASE(charset); + cff_release_index(idx); + RELEASE(CIDToGIDMap); + cff_close(cffont); + sfnt_close(sfont); + DPXFCLOSE(fp); + return -1; + } RELEASE(data); cff_release_index(idx); @@ -814,117 +747,158 @@ CIDFont_type0_dofont (CIDFont *font) destlen = write_fontfile(font, cffont); - CIDFontInfo_close(&info); + cff_close(cffont); + sfnt_close(sfont); + DPXFCLOSE(fp); if (dpx_conf.verbose_level > 1) MESG("[%u/%u glyphs][%ld bytes]", num_glyphs, cs_count, destlen); - CIDFont_type0_add_CIDSet(font, used_chars, last_cid); + if (pdf_check_version(2, 0) >= 0) { + CIDFont_type0_add_CIDSet(font, used_chars, last_cid); + } + + return 0; } int -CIDFont_type0_open (CIDFont *font, const char *name, - CIDSysInfo *cmap_csi, cid_opt *opt, - int expected_flag) +CIDFont_type0_open_from_t1 (pdf_font *font, const char *name, int index, cid_opt *opt) { - CIDSysInfo *csi; + CIDSysInfo csi; char *fontname; - sfnt *sfont = NULL; cff_font *cffont; FILE *fp = NULL; - ULONG offset = 0; - int is_cid_font = 0; - int expect_cid_font = expected_flag == 0; - int expect_type1_font = expected_flag & CIDFONT_FLAG_TYPE1; - dpx_res_type expect_file_type = - expect_type1_font ? DPX_RES_TYPE_T1FONT : DPX_RES_TYPE_OTFONT; ASSERT(font); - if (expect_type1_font) { - if (cmap_csi && - (strcmp(cmap_csi->registry, "Adobe") != 0 || - strcmp(cmap_csi->ordering, "Identity") != 0)) { - return -1; - } + fp = DPXFOPEN(name, DPX_RES_TYPE_T1FONT); + if (!fp) + return -1; + + cffont = t1_load_font(NULL, 1, fp); + if (!cffont) { + DPXFCLOSE(fp); + return -1; } - fp = DPXFOPEN(name, expect_file_type); - if (!expect_type1_font) { - if (!fp) { - fp = DPXFOPEN(name, DPX_RES_TYPE_TTFONT); - if (!fp) return -1; - } + { + char *shortname; + int fontname_len = 8; - sfont = sfnt_open(fp); - if (!sfont) { - ERROR("Not a CFF/OpenType font: %s", name); - } + shortname = cff_get_name(cffont); + if (!shortname) { + WARN("No valid FontName found: %s", name); + cff_close(cffont); + DPXFCLOSE(fp); + } + /* + * Mangled name requires more 7 bytes. + */ + fontname = NEW(strlen(shortname) + fontname_len, char); + memset(fontname, 0, strlen(shortname) + fontname_len); + strcpy(fontname, shortname); + RELEASE(shortname); + } - if (sfont->type == SFNT_TYPE_TTC) - offset = ttc_read_offset(sfont, opt->index); + csi.registry = NEW(strlen("Adobe") + 1, char); + strcpy(csi.registry, "Adobe"); + csi.ordering = NEW(strlen("Identity") + 1, char); + strcpy(csi.ordering, "Identity"); + csi.supplement = 0; + if (opt->style != FONT_STYLE_NONE) { + WARN(",Bold, ,Italic, ... not supported for this type of font..."); + opt->style = FONT_STYLE_NONE; + } - if ((sfont->type != SFNT_TYPE_TTC && sfont->type != SFNT_TYPE_POSTSCRIPT) || - sfnt_read_table_directory(sfont, offset) < 0 || - (offset = sfnt_find_table_pos(sfont, "CFF ")) == 0) { - sfnt_close(sfont); - if (fp) - DPXFCLOSE(fp); - return -1; - } + font->fontname = fontname; + font->subtype = PDF_FONT_FONTTYPE_CIDTYPE0; + font->cid.csi = csi; + font->flags |= CIDFONT_FLAG_TYPE1; - cffont = cff_open(sfont->stream, offset, 0); - if (!cffont) { - ERROR("Cannot read CFF font data"); - } + font->resource = pdf_new_dict(); + pdf_add_dict(font->resource, + pdf_new_name("Type"), + pdf_new_name("Font")); + pdf_add_dict(font->resource, + pdf_new_name("Subtype"), + pdf_new_name("CIDFontType0")); - is_cid_font = cffont->flag & FONTTYPE_CIDFONT; - if (expect_cid_font != is_cid_font) { - cff_close(cffont); - sfnt_close(sfont); - if (fp) - DPXFCLOSE(fp); - return -1; - } - } else { - if (!fp) - return -1; + memmove(fontname + 7, fontname, strlen(fontname) + 1); + pdf_font_make_uniqueTag(fontname); + fontname[6] = '+'; - cffont = t1_load_font(NULL, 1, fp); - if (!cffont) { - DPXFCLOSE(fp); - return -1; - } + font->descriptor = pdf_new_dict(); + pdf_add_dict(font->descriptor, + pdf_new_name("FontName"), + pdf_new_name(fontname)); + pdf_add_dict(font->resource, + pdf_new_name("BaseFont"), + pdf_new_name(fontname)); + { + pdf_obj *csi_dict = pdf_new_dict(); + pdf_add_dict(csi_dict, + pdf_new_name("Registry"), + pdf_new_string(csi.registry, strlen(csi.registry))); + pdf_add_dict(csi_dict, + pdf_new_name("Ordering"), + pdf_new_string(csi.ordering, strlen(csi.ordering))); + pdf_add_dict(csi_dict, + pdf_new_name("Supplement"), + pdf_new_number(csi.supplement)); + pdf_add_dict(font->resource, pdf_new_name("CIDSystemInfo"), csi_dict); + } + + return 0; +} + +int +CIDFont_type0_open (pdf_font *font, const char *name, int index, cid_opt *opt) +{ + CIDSysInfo csi; + char *fontname; + sfnt *sfont = NULL; + cff_font *cffont; + FILE *fp = NULL; + ULONG offset = 0; + + ASSERT(font); + + fp = DPXFOPEN(name, DPX_RES_TYPE_OTFONT); + if (!fp) { + fp = DPXFOPEN(name, DPX_RES_TYPE_TTFONT); + if (!fp) return -1; + } + + sfont = sfnt_open(fp); + if (!sfont) { DPXFCLOSE(fp); + return -1; } - csi = NEW(1, CIDSysInfo); - if (is_cid_font) { - csi->registry = - cff_get_string(cffont, (s_SID)cff_dict_get(cffont->topdict, "ROS", 0)); - csi->ordering = - cff_get_string(cffont, (s_SID)cff_dict_get(cffont->topdict, "ROS", 1)); - csi->supplement = (int)cff_dict_get(cffont->topdict, "ROS", 2); - } else { - csi->registry = NEW(strlen("Adobe") + 1, char); - strcpy(csi->registry, "Adobe"); - csi->ordering = NEW(strlen("Identity") + 1, char); - strcpy(csi->ordering, "Identity"); - csi->supplement = 0; - } - - if (!expect_type1_font && cmap_csi) { - if (strcmp(csi->registry, cmap_csi->registry) != 0 || - strcmp(csi->ordering, cmap_csi->ordering) != 0) { - MESG("\nCharacter collection mismatched:\n"); - MESG("\tFont: %s-%s-%d\n", csi->registry, csi->ordering, csi->supplement); - MESG("\tCMap: %s-%s-%d\n", cmap_csi->registry, cmap_csi->ordering, cmap_csi->supplement); - ERROR("Inconsistent CMap specified for this font."); - } - if (csi->supplement < cmap_csi->supplement) { - WARN("CMap have higher supplement number."); - WARN("Some characters may not be displayed or printed."); - } + if (sfont->type == SFNT_TYPE_TTC) + offset = ttc_read_offset(sfont, index); + + if ((sfont->type != SFNT_TYPE_TTC && sfont->type != SFNT_TYPE_POSTSCRIPT) || + sfnt_read_table_directory(sfont, offset) < 0 || + (offset = sfnt_find_table_pos(sfont, "CFF ")) == 0) { + sfnt_close(sfont); + DPXFCLOSE(fp); + return -1; + } + + cffont = cff_open(sfont->stream, offset, 0); + if (!cffont) { + WARN("Cannot read CFF font data"); + sfnt_close(sfont); + DPXFCLOSE(fp); + return -1; + } + + if (!(cffont->flag & FONTTYPE_CIDFONT)) { + cff_close(cffont); + sfnt_close(sfont); + DPXFCLOSE(fp); + return -1; } { @@ -932,26 +906,33 @@ CIDFont_type0_open (CIDFont *font, const char *name, int fontname_len = 8; shortname = cff_get_name(cffont); - if (!shortname) - ERROR("No valid FontName found."); + if (!shortname) { + WARN("No valid FontName found."); + cff_close(cffont); + sfnt_close(sfont); + DPXFCLOSE(fp); + return -1; + } /* * Mangled name requires more 7 bytes. * Style requires more 11 bytes. */ - if (is_cid_font) - fontname_len += 11; + fontname_len += 11; fontname = NEW(strlen(shortname) + fontname_len, char); memset(fontname, 0, strlen(shortname) + fontname_len); strcpy(fontname, shortname); RELEASE(shortname); } + csi.registry = cff_get_string(cffont, (s_SID)cff_dict_get(cffont->topdict, "ROS", 0)); + csi.ordering = cff_get_string(cffont, (s_SID)cff_dict_get(cffont->topdict, "ROS", 1)); + csi.supplement = (int)cff_dict_get(cffont->topdict, "ROS", 2); + cff_close(cffont); - if (is_cid_font) { - if (opt->embed && opt->style != FONT_STYLE_NONE) { - WARN("Embedding disabled due to style option for %s.", name); - opt->embed = 0; - } + if (opt->embed && opt->style != FONT_STYLE_NONE) { + WARN("Embedding disabled due to style option for %s.", name); + opt->embed = 0; + switch (opt->style) { case FONT_STYLE_BOLD: strcat(fontname, ",Bold"); @@ -963,112 +944,282 @@ CIDFont_type0_open (CIDFont *font, const char *name, strcat(fontname, ",BoldItalic"); break; } - } else if (expect_type1_font) { - if (opt->style != FONT_STYLE_NONE) { - WARN(",Bold, ,Italic, ... not supported for this type of font..."); - opt->style = FONT_STYLE_NONE; - } - } else { - opt->embed = 1; + } + + /* getting font info. from TrueType tables */ + font->descriptor = tt_get_fontdesc(sfont, &(opt->embed), opt->stemv, 0, name); + if (!font->descriptor) { + WARN("Could not obtain necessary font info: %s", name); + RELEASE(fontname); + RELEASE(csi.registry); + RELEASE(csi.ordering); + sfnt_close(sfont); + DPXFCLOSE(fp); + return -1; } font->fontname = fontname; - font->subtype = CIDFONT_TYPE0; - font->csi = csi; - font->flags |= expected_flag; + font->subtype = PDF_FONT_FONTTYPE_CIDTYPE0; + font->cid.csi = csi; - font->fontdict = pdf_new_dict(); - pdf_add_dict(font->fontdict, + font->resource = pdf_new_dict(); + pdf_add_dict(font->resource, pdf_new_name("Type"), pdf_new_name("Font")); - pdf_add_dict(font->fontdict, + pdf_add_dict(font->resource, pdf_new_name("Subtype"), pdf_new_name("CIDFontType0")); - if (expect_type1_font || opt->embed) { + if (opt->embed) { memmove(fontname + 7, fontname, strlen(fontname) + 1); pdf_font_make_uniqueTag(fontname); fontname[6] = '+'; } - if (expect_type1_font) { - font->descriptor = pdf_new_dict(); - } else { - /* getting font info. from TrueType tables */ - if ((font->descriptor - = tt_get_fontdesc(sfont, &(opt->embed), opt->stemv, 0, name)) == NULL) - ERROR("Could not obtain necessary font info."); - } - pdf_add_dict(font->descriptor, pdf_new_name("FontName"), pdf_new_name(fontname)); - pdf_add_dict(font->fontdict, + pdf_add_dict(font->resource, pdf_new_name("BaseFont"), pdf_new_name(fontname)); { pdf_obj *csi_dict = pdf_new_dict(); pdf_add_dict(csi_dict, pdf_new_name("Registry"), - pdf_new_string(csi->registry, strlen(csi->registry))); + pdf_new_string(csi.registry, strlen(csi.registry))); pdf_add_dict(csi_dict, pdf_new_name("Ordering"), - pdf_new_string(csi->ordering, strlen(csi->ordering))); + pdf_new_string(csi.ordering, strlen(csi.ordering))); pdf_add_dict(csi_dict, pdf_new_name("Supplement"), - pdf_new_number(csi->supplement)); - pdf_add_dict(font->fontdict, pdf_new_name("CIDSystemInfo"), csi_dict); + pdf_new_number(csi.supplement)); + pdf_add_dict(font->resource, pdf_new_name("CIDSystemInfo"), csi_dict); + } + pdf_add_dict(font->resource, + pdf_new_name("DW"), + pdf_new_number(1000)); /* not sure */ + + sfnt_close(sfont); + DPXFCLOSE(fp); + + return 0; +} + +int +CIDFont_type0_open_from_t1c (pdf_font *font, const char *name, int index, cid_opt *opt) +{ + CIDSysInfo csi; + char *fontname; + sfnt *sfont = NULL; + cff_font *cffont; + FILE *fp = NULL; + ULONG offset = 0; + + ASSERT(font); + + fp = DPXFOPEN(name, DPX_RES_TYPE_OTFONT); + if (!fp) { + fp = DPXFOPEN(name, DPX_RES_TYPE_TTFONT); + if (!fp) return -1; + } + + sfont = sfnt_open(fp); + if (!sfont) { + WARN("Not a CFF/OpenType font: %s", name); + DPXFCLOSE(fp); + } + + if (sfont->type == SFNT_TYPE_TTC) + offset = ttc_read_offset(sfont, index); + + if ((sfont->type != SFNT_TYPE_TTC && sfont->type != SFNT_TYPE_POSTSCRIPT) || + sfnt_read_table_directory(sfont, offset) < 0 || + (offset = sfnt_find_table_pos(sfont, "CFF ")) == 0) { + sfnt_close(sfont); + DPXFCLOSE(fp); + return -1; } - if (is_cid_font) { - pdf_add_dict(font->fontdict, - pdf_new_name("DW"), - pdf_new_number(1000)); /* not sure */ + + cffont = cff_open(sfont->stream, offset, 0); + if (!cffont) { + WARN("Cannot read CFF font data: %s", name); + sfnt_close(sfont); + DPXFCLOSE(fp); + return -1; } - if (!expect_type1_font) { + if (cffont->flag & FONTTYPE_CIDFONT) { + cff_close(cffont); sfnt_close(sfont); - if (fp) + DPXFCLOSE(fp); + return -1; + } + + { + char *shortname; + int fontname_len = 8; + + shortname = cff_get_name(cffont); + if (!shortname) { + WARN("No valid FontName found: %s", name); + cff_close(cffont); + sfnt_close(sfont); DPXFCLOSE(fp); + return -1; + } + /* + * Mangled name requires more 7 bytes. + */ + fontname = NEW(strlen(shortname) + fontname_len, char); + memset(fontname, 0, strlen(shortname) + fontname_len); + strcpy(fontname, shortname); + RELEASE(shortname); + } + csi.registry = NEW(strlen("Adobe") + 1, char); + strcpy(csi.registry, "Adobe"); + csi.ordering = NEW(strlen("Identity") + 1, char); + strcpy(csi.ordering, "Identity"); + csi.supplement = 0; + + cff_close(cffont); + + opt->embed = 1; + /* getting font info. from TrueType tables */ + font->descriptor = tt_get_fontdesc(sfont, &(opt->embed), opt->stemv, 0, name); + if (!font->descriptor) { + WARN("Could not obtain necessary font info: %s", name); + RELEASE(fontname); + RELEASE(csi.registry); + RELEASE(csi.ordering); + sfnt_close(sfont); + DPXFCLOSE(fp); + return -1; + } else if (!opt->embed) { + WARN("Can’t embed font due to font license: %s", name); + RELEASE(fontname); + RELEASE(csi.registry); + RELEASE(csi.ordering); + sfnt_close(sfont); + DPXFCLOSE(fp); + return -1; + } + + font->fontname = fontname; + font->subtype = PDF_FONT_FONTTYPE_CIDTYPE0; + font->cid.csi = csi; + font->flags |= CIDFONT_FLAG_TYPE1C; + + font->resource = pdf_new_dict(); + pdf_add_dict(font->resource, + pdf_new_name("Type"), + pdf_new_name("Font")); + pdf_add_dict(font->resource, + pdf_new_name("Subtype"), + pdf_new_name("CIDFontType0")); + + if (opt->embed) { + memmove(fontname + 7, fontname, strlen(fontname) + 1); + pdf_font_make_uniqueTag(fontname); + fontname[6] = '+'; } + pdf_add_dict(font->descriptor, + pdf_new_name("FontName"), + pdf_new_name(fontname)); + pdf_add_dict(font->resource, + pdf_new_name("BaseFont"), + pdf_new_name(fontname)); + { + pdf_obj *csi_dict = pdf_new_dict(); + pdf_add_dict(csi_dict, + pdf_new_name("Registry"), + pdf_new_string(csi.registry, strlen(csi.registry))); + pdf_add_dict(csi_dict, + pdf_new_name("Ordering"), + pdf_new_string(csi.ordering, strlen(csi.ordering))); + pdf_add_dict(csi_dict, + pdf_new_name("Supplement"), + pdf_new_number(csi.supplement)); + pdf_add_dict(font->resource, pdf_new_name("CIDSystemInfo"), csi_dict); + } + + sfnt_close(sfont); + DPXFCLOSE(fp); + return 0; } -void -CIDFont_type0_t1cdofont (CIDFont *font) +int +CIDFont_type0_t1cdofont (pdf_font *font) { + FILE *fp; + sfnt *sfont; cff_font *cffont; cff_index *charstrings, *idx; - int charstring_len, max_len; - int destlen = 0; - int size, offset = 0; - card8 *data; - card16 num_glyphs, gid, last_cid; - int i, cid; - char *used_chars; - double default_width, nominal_width; - CIDType0Error error; - CIDType0Info info; + int charstring_len, max_len; + int destlen = 0; + int size, offset = 0; + card8 *data; + card16 num_glyphs, gid, last_cid; + int i, cid; + char *used_chars; + double default_width, nominal_width; ASSERT(font); - if (!font->indirect) - return; + if (!font->reference) + return 0; - pdf_add_dict(font->fontdict, + pdf_add_dict(font->resource, pdf_new_name("FontDescriptor"), pdf_ref_obj (font->descriptor)); - used_chars = CIDFont_type0_get_used_chars(font); + used_chars = font->usedchars; - error = CIDFont_type0_try_open(font->ident, CIDFont_get_opt_index(font), - 0, &info); - if (error != CID_OPEN_ERROR_NO_ERROR) { - CIDType0Error_Show(error, font->ident); - return; + fp = DPXFOPEN(font->filename, DPX_RES_TYPE_OTFONT); + if (!fp) { + fp = DPXFOPEN(font->filename, DPX_RES_TYPE_TTFONT); + if (!fp) { + WARN("Could not open file: %s", font->filename); + return -1; + } + } + + sfont = sfnt_open(fp); + if (!sfont) { + WARN("Failed to read font data: %s", font->filename); + DPXFCLOSE(fp); + return -1; + } + + if (sfont->type == SFNT_TYPE_TTC) + offset = ttc_read_offset(sfont, font->index); + + if ((sfont->type != SFNT_TYPE_TTC && + sfont->type != SFNT_TYPE_POSTSCRIPT) || + sfnt_read_table_directory(sfont, offset) < 0 || + (offset = sfnt_find_table_pos(sfont, "CFF ")) == 0) { + WARN("Not a CFF/OpenType font: %s", font->filename); + sfnt_close(sfont); + DPXFCLOSE(fp); + return -1; + } + + cffont = cff_open(sfont->stream, offset, 0); + if (!cffont) { + WARN("Failed to read CFF font data: %s", font->filename); + sfnt_close(sfont); + DPXFCLOSE(fp); + return -1; } - cffont = info.cffont; + if (cffont->flag & FONTTYPE_CIDFONT) { + WARN("Unxpected type (CIDFont) found: %s", font->filename); + cff_close(cffont); + sfnt_close(sfont); + DPXFCLOSE(fp); + return -1; + } cff_read_private(cffont); cff_read_subrs (cffont); @@ -1166,8 +1317,14 @@ CIDFont_type0_t1cdofont (CIDFont *font) /* offset is now absolute offset ... bad */ offset = cff_tell(cffont); - if (idx->count < 2) - ERROR("No valid charstring data found."); + if (idx->count < 2) { + WARN("No valid charstring data found: %s", font->filename); + cff_release_index(idx); + cff_close(cffont); + sfnt_close(sfont); + DPXFCLOSE(fp); + return -1; + } /* New CharStrings INDEX */ charstrings = cff_new_index((card16)(num_glyphs+1)); @@ -1182,8 +1339,16 @@ CIDFont_type0_t1cdofont (CIDFont *font) continue; if ((size = (idx->offset)[cid+1] - (idx->offset)[cid]) - > CS_STR_LEN_MAX) - ERROR("Charstring too long: gid=%u", cid); + > CS_STR_LEN_MAX) { + WARN("Charstring too long:%s (gid=%u)", font->filename, cid); + RELEASE(data); + cff_release_index(charstrings); + cff_release_index(idx); + cff_close(cffont); + sfnt_close(sfont); + DPXFCLOSE(fp); + return -1; + } if (charstring_len + CS_STR_LEN_MAX >= max_len) { max_len = charstring_len + 2 * CS_STR_LEN_MAX; charstrings->data = RENEW(charstrings->data, max_len, card8); @@ -1198,8 +1363,16 @@ CIDFont_type0_t1cdofont (CIDFont *font) default_width, nominal_width, NULL); gid++; } - if (gid != num_glyphs) - ERROR("Unexpeced error: ?????"); + if (gid != num_glyphs) { + WARN("Unexpeced error: %s", font->filename); + RELEASE(data); + cff_release_index(charstrings); + cff_release_index(idx); + cff_close(cffont); + sfnt_close(sfont); + DPXFCLOSE(fp); + return -1; + } RELEASE(data); cff_release_index(idx); @@ -1253,26 +1426,32 @@ CIDFont_type0_t1cdofont (CIDFont *font) CIDToGIDMap[2*cid+1] = cid & 0xff; } } - add_CIDMetrics(info.sfont, font->fontdict, CIDToGIDMap, last_cid, - ((CIDFont_get_parent_id(font, 1) < 0) ? 0 : 1)); + add_CIDMetrics(sfont, font->resource, CIDToGIDMap, last_cid, + font->cid.usedchars_v ? 1 : 0); RELEASE(CIDToGIDMap); } - CIDFontInfo_close(&info); + cff_close(cffont); + sfnt_close(sfont); + DPXFCLOSE(fp); if (dpx_conf.verbose_level > 1) MESG("[%u glyphs][%ld bytes]", num_glyphs, destlen); - CIDFont_type0_add_CIDSet(font, used_chars, last_cid); + if (pdf_check_version(2, 0) >= 0) { + CIDFont_type0_add_CIDSet(font, used_chars, last_cid); + } + + return 0; } static int load_base_CMap (const char *font_name, int wmode, cff_font *cffont) { - int cmap_id = -1; - CMap *cmap; - char *cmap_name; - card16 gid; + int cmap_id = -1; + CMap *cmap; + char *cmap_name; + card16 gid; unsigned char range_min[4] = {0x00, 0x00, 0x00, 0x00}; unsigned char range_max[4] = {0x7f, 0xff, 0xff, 0xff}; @@ -1384,7 +1563,7 @@ t1_load_UnicodeCMap (const char *font_name, cff_close(cffont); if (cmap_id < 0) { - ERROR("Failed to create Unicode charmap for font \"%s\".", font_name); + WARN("Failed to create Unicode charmap for font \"%s\".", font_name); return -1; } @@ -1404,15 +1583,15 @@ static pdf_obj * create_ToUnicode_stream (cff_font *cffont, const char *font_name, const char *used_glyphs) { - pdf_obj *stream = NULL; - CMap *cmap; - CID cid; - card16 gid; - int glyph_count, total_fail_count; - char *cmap_name; + pdf_obj *stream = NULL; + CMap *cmap; + CID cid; + card16 gid; + int glyph_count, total_fail_count; + char *cmap_name; #define WBUF_SIZE 1024 - unsigned char wbuf[WBUF_SIZE]; - unsigned char *p, *endptr; + unsigned char wbuf[WBUF_SIZE]; + unsigned char *p, *endptr; static unsigned char range_min[2] = {0x00, 0x00}; static unsigned char range_max[2] = {0xff, 0xff}; @@ -1438,14 +1617,14 @@ create_ToUnicode_stream (cff_font *cffont, endptr = wbuf + WBUF_SIZE; for (cid = 1; cid < cffont->num_glyphs; cid++) { /* Skip .notdef */ if (is_used_char2(used_glyphs, cid)) { - char *glyph; - int32_t len; - int fail_count; + char *glyph; + int32_t len; + int fail_count; wbuf[0] = (cid >> 8) & 0xff; wbuf[1] = (cid & 0xff); - p = wbuf + 2; + p = wbuf + 2; gid = cff_charsets_lookup_inverse(cffont, cid); if (gid == 0) continue; @@ -1476,6 +1655,36 @@ create_ToUnicode_stream (cff_font *cffont, return stream; } +pdf_obj * +CIDFont_type0_t1create_ToUnicode_stream (const char *filename, const char *fontname, const char *used_chars) +{ + pdf_obj *ref = NULL; + pdf_obj *tounicode; + cff_font *cffont; + FILE *fp; + + ASSERT(filename); + ASSERT(fontname); + ASSERT(used_chars); + + fp = DPXFOPEN(filename, DPX_RES_TYPE_T1FONT); + if (!fp) { + return NULL; + } + + cffont = t1_load_font(NULL, 1, fp); + if (cffont) { + tounicode = create_ToUnicode_stream(cffont, fontname, used_chars); + if (tounicode) { + ref = pdf_ref_obj(tounicode); + pdf_release_obj(tounicode); + } + } + DPXFCLOSE(fp); + + return ref; +} + /* Duplicate from type1.c */ #define TYPE1_NAME_LEN_MAX 127 @@ -1489,9 +1698,8 @@ create_ToUnicode_stream (cff_font *cffont, #define FONT_FLAG_SMALLCAP (1 << 17) /* Small-cap font */ #define FONT_FLAG_FORCEBOLD (1 << 18) /* Force bold at small text sizes */ -/* pdf_font --> CIDFont */ static void -get_font_attr (CIDFont *font, cff_font *cffont) +get_font_attr (pdf_font *font, cff_font *cffont) { double capheight, ascent, descent; double italicangle, stemv; @@ -1630,7 +1838,7 @@ get_font_attr (CIDFont *font, cff_font *cffont) } static void -add_metrics (CIDFont *font, cff_font *cffont, +add_metrics (pdf_font *font, cff_font *cffont, unsigned char *CIDToGIDMap, double *widths, double default_width, CID last_cid) { @@ -1638,7 +1846,7 @@ add_metrics (CIDFont *font, cff_font *cffont, double val; card16 cid, gid; char *used_chars; - int i, parent_id; + int i; /* * The original FontBBox of the font is preserved, instead @@ -1647,23 +1855,17 @@ add_metrics (CIDFont *font, cff_font *cffont, * much as possible. */ if (!cff_dict_known(cffont->topdict, "FontBBox")) { - ERROR("No FontBBox?"); - } - tmp = pdf_new_array(); - for (i = 0; i < 4; i++) { - val = cff_dict_get(cffont->topdict, "FontBBox", i); - pdf_add_array(tmp, pdf_new_number(ROUND(val, 1.0))); + WARN("No FontBBox found: %s", font->filename); + } else { + tmp = pdf_new_array(); + for (i = 0; i < 4; i++) { + val = cff_dict_get(cffont->topdict, "FontBBox", i); + pdf_add_array(tmp, pdf_new_number(ROUND(val, 1.0))); + } + pdf_add_dict(font->descriptor, pdf_new_name("FontBBox"), tmp); } - pdf_add_dict(font->descriptor, pdf_new_name("FontBBox"), tmp); - if ((parent_id = CIDFont_get_parent_id(font, 0)) < 0 && - (parent_id = CIDFont_get_parent_id(font, 1)) < 0) - ERROR("No parent Type 0 font !"); - - used_chars = Type0Font_get_usedchars(Type0Font_cache_get(parent_id)); - if (!used_chars) { - ERROR("Unexpected error: Font not actually used???"); - } + used_chars = font->usedchars; /* FIXME: * This writes "CID CID width". @@ -1681,83 +1883,54 @@ add_metrics (CIDFont *font, cff_font *cffont, } } } - pdf_add_dict(font->fontdict, + pdf_add_dict(font->resource, pdf_new_name("DW"), pdf_new_number(default_width)); if (pdf_array_length(tmp) > 0) { - pdf_add_dict(font->fontdict, pdf_new_name("W"), pdf_ref_obj(tmp)); + pdf_add_dict(font->resource, pdf_new_name("W"), pdf_ref_obj(tmp)); } pdf_release_obj(tmp); } -void -CIDFont_type0_t1dofont (CIDFont *font) +int +CIDFont_type0_t1dofont (pdf_font *font) { - cff_font *cffont; - double defaultwidth, nominalwidth; - int num_glyphs = 0; - FILE *fp; - int i, offset; - char *used_chars = NULL; - card16 last_cid, gid, cid; + cff_font *cffont; + double defaultwidth, nominalwidth; + int num_glyphs = 0; + FILE *fp; + int i, offset; + char *used_chars = NULL; + card16 last_cid, gid, cid; unsigned char *CIDToGIDMap; ASSERT(font); - if (!font->indirect) { - return; + if (!font->reference) { + return 0; } - pdf_add_dict(font->fontdict, + pdf_add_dict(font->resource, pdf_new_name("FontDescriptor"), pdf_ref_obj (font->descriptor)); - fp = DPXFOPEN(font->ident, DPX_RES_TYPE_T1FONT); + fp = DPXFOPEN(font->filename, DPX_RES_TYPE_T1FONT); if (!fp) { - ERROR("Type1: Could not open Type1 font."); + WARN("Type1: Could not open Type1 font."); + return -1; } cffont = t1_load_font(NULL, 0, fp); - if (!cffont) - ERROR("Could not read Type 1 font..."); + if (!cffont) { + WARN("Could not read Type 1 font..."); + DPXFCLOSE(fp); + return -1; + } DPXFCLOSE(fp); - if (!font->fontname) - ERROR("Fontname undefined..."); - - { - Type0Font *hparent, *vparent; - pdf_obj *tounicode; - int vparent_id, hparent_id; - - hparent_id = CIDFont_get_parent_id(font, 0); - vparent_id = CIDFont_get_parent_id(font, 1); - if (hparent_id < 0 && vparent_id < 0) - ERROR("No parent Type 0 font !"); - - /* usedchars is same for h and v */ - if (hparent_id < 0) - hparent = NULL; - else { - hparent = Type0Font_cache_get(hparent_id); - used_chars = Type0Font_get_usedchars(hparent); - } - if (vparent_id < 0) - vparent = NULL; - else { - vparent = Type0Font_cache_get(vparent_id); - used_chars = Type0Font_get_usedchars(vparent); - } - if (!used_chars) - ERROR("Unexpected error: Font not actually used???"); + ASSERT(font->fontname); + ASSERT(font->usedchars); - tounicode = create_ToUnicode_stream(cffont, font->fontname, used_chars); - - if (hparent) - Type0Font_set_ToUnicode(hparent, pdf_ref_obj(tounicode)); - if (vparent) - Type0Font_set_ToUnicode(vparent, pdf_ref_obj(tounicode)); - pdf_release_obj(tounicode); - } + used_chars = font->usedchars; cff_set_name(cffont, font->fontname); @@ -1877,7 +2050,12 @@ CIDFont_type0_t1dofont (CIDFont *font) cffont->subrs[0], defaultwidth, nominalwidth, &gm); cstring->offset[gid+1] = offset + 1; if (gm.use_seac) { - ERROR("This font using the \"seac\" command for accented characters..."); + WARN("The \"seac\" command for an accented character found: %s", font->filename); + RELEASE(widths); + cff_release_index(cstring); + RELEASE(CIDToGIDMap); + cff_close(cffont); + return -1; } widths[gid] = gm.wx; if (gm.wx >= 0.0 && gm.wx <= 1000.0) { @@ -1929,5 +2107,9 @@ CIDFont_type0_t1dofont (CIDFont *font) cff_close(cffont); - CIDFont_type0_add_CIDSet(font, used_chars, last_cid); + if (pdf_check_version(2, 0) >= 0) { + CIDFont_type0_add_CIDSet(font, used_chars, last_cid); + } + + return 0; } diff --git a/Build/source/texk/dvipdfm-x/cidtype0.h b/Build/source/texk/dvipdfm-x/cidtype0.h index 513a90c6013..c4faa24486c 100644 --- a/Build/source/texk/dvipdfm-x/cidtype0.h +++ b/Build/source/texk/dvipdfm-x/cidtype0.h @@ -21,20 +21,18 @@ #ifndef _CIDTYPE0_H_ #define _CIDTYPE0_H_ -#include "cid.h" -#include "cid_p.h" -#include "fontmap.h" +#include "pdffont.h" -extern void CIDFont_type0_set_flags (int flags); - -extern int CIDFont_type0_open (CIDFont *font, const char *name, - CIDSysInfo *cmap_csi, cid_opt *opt, - int expected_flag); -extern void CIDFont_type0_dofont (CIDFont *font); +extern int CIDFont_type0_open (pdf_font *font, const char *name, int index, cid_opt *opt); +extern int CIDFont_type0_dofont (pdf_font *font); /* Type1 --> CFF CIDFont */ extern int t1_load_UnicodeCMap (const char *font_name, const char *otl_tags, int wmode); -extern void CIDFont_type0_t1dofont (CIDFont *font); -extern void CIDFont_type0_t1cdofont (CIDFont *font); +extern int CIDFont_type0_open_from_t1 (pdf_font *font, const char *name, int index, cid_opt *opt); +extern int CIDFont_type0_open_from_t1c (pdf_font *font, const char *name, int index, cid_opt *opt); +extern int CIDFont_type0_t1dofont (pdf_font *font); +extern int CIDFont_type0_t1cdofont (pdf_font *font); + +extern pdf_obj *CIDFont_type0_t1create_ToUnicode_stream (const char *filename, const char *fontname, const char *used_chars); #endif /* _CIDTYPE0_H_ */ diff --git a/Build/source/texk/dvipdfm-x/cidtype2.c b/Build/source/texk/dvipdfm-x/cidtype2.c index 8ee698b3991..f6913d1673f 100644 --- a/Build/source/texk/dvipdfm-x/cidtype2.c +++ b/Build/source/texk/dvipdfm-x/cidtype2.c @@ -55,17 +55,8 @@ #include "cmap.h" #include "type0.h" #include "cid.h" -#include "cid_p.h" #include "cidtype2.h" -static int opt_flags = 0; - -void -CIDFont_type2_set_flags (int32_t flags) -{ - opt_flags = flags; -} - /* * PDF viewer applications use following tables (CIDFontType 2) * @@ -98,7 +89,7 @@ static struct {"prep", 0}, {NULL, 0} }; -static void +static int validate_name (char *fontname, int len) { int i, count; @@ -137,8 +128,11 @@ validate_name (char *fontname, int len) } if (len < 1) { - ERROR("No valid character found in fontname string."); + WARN("No valid character found in fontname string."); + return -1; } + + return 0; } /* @@ -179,12 +173,10 @@ find_tocode_cmap (const char *reg, const char *ord, int select) const char *append; if (!reg || !ord || - select < 0 || select > KNOWN_ENCODINGS_MAX) - ERROR("Character set unknown."); - - if (!strcmp(ord, "UCS") && - select <= WIN_UCS_INDEX_MAX) + select < 0 || select > KNOWN_ENCODINGS_MAX) { + WARN("Character set unknown."); return NULL; + } for (i = 0; cmap_id < 0 && i < 5; i++) { append = known_encodings[select].pdfnames[i]; @@ -205,7 +197,7 @@ find_tocode_cmap (const char *reg, const char *ord, int select) MESG(" %s-%s-%s", reg, ord, append); } WARN("Please check if this file exists."); - ERROR("Cannot continue..."); + return NULL; } return CMap_cache_get(cmap_id); @@ -220,7 +212,7 @@ find_tocode_cmap (const char *reg, const char *ord, int select) static void add_TTCIDHMetrics (pdf_obj *fontdict, struct tt_glyphs *g, - char *used_chars, unsigned char *cidtogidmap, unsigned short last_cid) + char *used_chars, unsigned char *cidtogidmap, unsigned short last_cid) { int cid, start = 0, prev = 0; pdf_obj *w_array, *an_array = NULL; @@ -246,23 +238,23 @@ add_TTCIDHMetrics (pdf_obj *fontdict, struct tt_glyphs *g, width = PDFUNIT((g->gd)[idx].advw); if (width == dw) { if (an_array) { - pdf_add_array(w_array, pdf_new_number(start)); - pdf_add_array(w_array, an_array); - an_array = NULL; - empty = 0; + pdf_add_array(w_array, pdf_new_number(start)); + pdf_add_array(w_array, an_array); + an_array = NULL; + empty = 0; } } else { if (cid != prev + 1) { - if (an_array) { - pdf_add_array(w_array, pdf_new_number(start)); - pdf_add_array(w_array, an_array); - an_array = NULL; - empty = 0; - } + if (an_array) { + pdf_add_array(w_array, pdf_new_number(start)); + pdf_add_array(w_array, an_array); + an_array = NULL; + empty = 0; + } } if (an_array == NULL) { - an_array = pdf_new_array(); - start = cid; + an_array = pdf_new_array(); + start = cid; } pdf_add_array(an_array, pdf_new_number(width)); prev = cid; @@ -275,13 +267,9 @@ add_TTCIDHMetrics (pdf_obj *fontdict, struct tt_glyphs *g, empty = 0; } - pdf_add_dict(fontdict, - pdf_new_name("DW"), - pdf_new_number(dw)); + pdf_add_dict(fontdict, pdf_new_name("DW"), pdf_new_number(dw)); if (!empty) { - pdf_add_dict(fontdict, - pdf_new_name("W"), - pdf_ref_obj(w_array)); + pdf_add_dict(fontdict, pdf_new_name("W"), pdf_ref_obj(w_array)); } pdf_release_obj(w_array); @@ -290,7 +278,7 @@ add_TTCIDHMetrics (pdf_obj *fontdict, struct tt_glyphs *g, static void add_TTCIDVMetrics (pdf_obj *fontdict, struct tt_glyphs *g, - char *used_chars, unsigned short last_cid) + char *used_chars, unsigned short last_cid) { pdf_obj *w2_array, *an_array = NULL; int cid; @@ -484,30 +472,30 @@ cid_to_code (CMap *cmap, CID cid) /* #define NO_GHOSTSCRIPT_BUG 1 */ -void -CIDFont_type2_dofont (CIDFont *font) +int +CIDFont_type2_dofont (pdf_font *font) { - pdf_obj *fontfile; - sfnt *sfont; - char *h_used_chars, *v_used_chars, *used_chars; + pdf_obj *fontfile; + sfnt *sfont; + char *h_used_chars, *v_used_chars, *used_chars; struct tt_glyphs *glyphs; - CMap *cmap = NULL; - tt_cmap *ttcmap = NULL; - ULONG offset = 0; - CID cid, last_cid; - unsigned char *cidtogidmap; - USHORT num_glyphs; - int i, glyph_ordering = 0, unicode_cmap = 0; - FILE *fp = NULL; - - if (!font->indirect) - return; + CMap *cmap = NULL; + tt_cmap *ttcmap = NULL; + ULONG offset = 0; + CID cid, last_cid; + unsigned char *cidtogidmap; + USHORT num_glyphs; + int i, glyph_ordering = 0, unicode_cmap = 0; + FILE *fp = NULL; + + if (!font->reference) + return 0; - pdf_add_dict(font->fontdict, - pdf_new_name("FontDescriptor"), pdf_ref_obj(font->descriptor)); + pdf_add_dict(font->resource, + pdf_new_name("FontDescriptor"), pdf_ref_obj(font->descriptor)); - if (CIDFont_is_BaseFont(font)) - return; + if (font->flags & PDF_FONT_FLAG_BASEFONT) + return 0; /* * CIDSystemInfo comes here since Supplement can be increased. @@ -517,65 +505,84 @@ CIDFont_type2_dofont (CIDFont *font) tmp = pdf_new_dict (); pdf_add_dict(tmp, - pdf_new_name("Registry"), - pdf_new_string(font->csi->registry, strlen(font->csi->registry))); + pdf_new_name("Registry"), + pdf_new_string(font->cid.csi.registry, strlen(font->cid.csi.registry))); pdf_add_dict(tmp, - pdf_new_name("Ordering"), - pdf_new_string(font->csi->ordering, strlen(font->csi->ordering))); + pdf_new_name("Ordering"), + pdf_new_string(font->cid.csi.ordering, strlen(font->cid.csi.ordering))); pdf_add_dict(tmp, - pdf_new_name("Supplement"), - pdf_new_number(font->csi->supplement)); - pdf_add_dict(font->fontdict, pdf_new_name("CIDSystemInfo"), tmp); + pdf_new_name("Supplement"), + pdf_new_number(font->cid.csi.supplement)); + pdf_add_dict(font->resource, pdf_new_name("CIDSystemInfo"), tmp); } /* Quick exit for non-embedded & fixed-pitch font. */ - if (!CIDFont_get_embedding(font) && - (opt_flags & CIDFONT_FORCE_FIXEDPITCH)) { - pdf_add_dict(font->fontdict, - pdf_new_name("DW"), pdf_new_number(1000.0)); - return; + if (!font->cid.options.embed && + (opt_flags_cidfont & CIDFONT_FORCE_FIXEDPITCH)) { + pdf_add_dict(font->resource, pdf_new_name("DW"), pdf_new_number(1000.0)); + return 0; } - fp = DPXFOPEN(font->ident, DPX_RES_TYPE_TTFONT); + fp = DPXFOPEN(font->filename, DPX_RES_TYPE_TTFONT); if (!fp) { - fp = DPXFOPEN(font->ident, DPX_RES_TYPE_DFONT); - if (!fp) ERROR("Could not open TTF/dfont file: %s", font->ident); - sfont = dfont_open(fp, font->options->index); + fp = DPXFOPEN(font->filename, DPX_RES_TYPE_DFONT); + if (!fp) { + WARN("Could not open TTF/dfont file: %s", font->filename); + return -1; + } + sfont = dfont_open(fp, font->index); } else { sfont = sfnt_open(fp); } if (!sfont) { - ERROR("Could not open TTF file: %s", font->ident); + WARN("Could not open TTF file: %s", font->filename); + DPXFCLOSE(fp); + return -1; } switch (sfont->type) { case SFNT_TYPE_TTC: - offset = ttc_read_offset(sfont, font->options->index); - if (offset == 0) - ERROR("Invalid TTC index in %s.", font->ident); + offset = ttc_read_offset(sfont, font->index); + if (offset == 0) { + WARN("Invalid TTC index in %s.", font->filename); + sfnt_close(sfont); + DPXFCLOSE(fp); + return -1; + } break; case SFNT_TYPE_TRUETYPE: - if (font->options->index > 0) - ERROR("Found TrueType font file while expecting TTC file (%s).", font->ident); + if (font->index > 0) { + WARN("Found TrueType font file while expecting TTC file (%s).", font->filename); + sfnt_close(sfont); + DPXFCLOSE(fp); + return -1; + } offset = 0; break; case SFNT_TYPE_DFONT: offset = sfont->offset; break; default: - ERROR("Not a TrueType/TTC font (%s)?", font->ident); + WARN("Not a TrueType/TTC font (%s)?", font->filename); + sfnt_close(sfont); + DPXFCLOSE(fp); + return -1; break; } - if (sfnt_read_table_directory(sfont, offset) < 0) - ERROR("Could not read TrueType table directory (%s).", font->ident); + if (sfnt_read_table_directory(sfont, offset) < 0) { + WARN("Could not read TrueType table directory (%s).", font->filename); + sfnt_close(sfont); + DPXFCLOSE(fp); + return -1; + } /* * Adobe-Identity means font's internal glyph ordering here. */ - if (!strcmp(font->csi->registry, "Adobe") && - !strcmp(font->csi->ordering, "Identity")) { + if (!strcmp(font->cid.csi.registry, "Adobe") && + !strcmp(font->cid.csi.ordering, "Identity")) { glyph_ordering = 1; } else { glyph_ordering = 0; @@ -594,27 +601,35 @@ CIDFont_type2_dofont (CIDFont *font) */ for (i = 0; i <= KNOWN_ENCODINGS_MAX; i++) { ttcmap = tt_cmap_read(sfont, - known_encodings[i].platform, - known_encodings[i].encoding); + known_encodings[i].platform, + known_encodings[i].encoding); if (ttcmap) - break; + break; } if (!ttcmap) { - WARN("No usable TrueType cmap table found for font \"%s\".", font->ident); + WARN("No usable TrueType cmap table found for font \"%s\".", font->filename); WARN("CID character collection for this font is set to \"%s-%s\"", - font->csi->registry, font->csi->ordering); - ERROR("Cannot continue without this..."); + font->cid.csi.registry, font->cid.csi.ordering); + WARN("Cannot continue without this..."); + sfnt_close(sfont); + DPXFCLOSE(fp); + return -1; } else if (i <= WIN_UCS_INDEX_MAX) { unicode_cmap = 1; } else { unicode_cmap = 0; } - /* - * NULL is returned if CMap is Identity CMap. - */ - cmap = find_tocode_cmap(font->csi->registry, - font->csi->ordering, i); + if (!strcmp(font->cid.csi.ordering, "UCS") && i <= WIN_UCS_INDEX_MAX) { + cmap = NULL; + } else { + cmap = find_tocode_cmap(font->cid.csi.registry, font->cid.csi.ordering, i); + if (!cmap) { + sfnt_close(sfont); + DPXFCLOSE(fp); + return -1; + } + } } glyphs = tt_build_init(); @@ -623,19 +638,12 @@ CIDFont_type2_dofont (CIDFont *font) num_glyphs = 1; /* .notdef */ used_chars = h_used_chars = v_used_chars = NULL; { - Type0Font *parent; - int parent_id, c; + int c; - if ((parent_id = CIDFont_get_parent_id(font, 0)) >= 0) { - parent = Type0Font_cache_get(parent_id); - h_used_chars = Type0Font_get_usedchars(parent); - } - if ((parent_id = CIDFont_get_parent_id(font, 1)) >= 0) { - parent = Type0Font_cache_get(parent_id); - v_used_chars = Type0Font_get_usedchars(parent); - } - if (!h_used_chars && !v_used_chars) - ERROR("Unexpected error."); + h_used_chars = font->usedchars; + v_used_chars = font->cid.usedchars_v; + + ASSERT(h_used_chars || v_used_chars); /* * Quick check of max CID. @@ -643,30 +651,28 @@ CIDFont_type2_dofont (CIDFont *font) c = 0; for (i = 8191; i >= 0; i--) { if (h_used_chars && h_used_chars[i] != 0) { - last_cid = i * 8 + 7; - c = h_used_chars[i]; - break; + last_cid = i * 8 + 7; + c = h_used_chars[i]; + break; } } for (i = 8191; i >= 0; i--) { if (v_used_chars && v_used_chars[i] != 0) { - if (i * 8 + 7 >= last_cid) { - c = (i * 8 + 7 > last_cid) ? (v_used_chars[i]) : (c | v_used_chars[i]); - last_cid = i * 8 + 7; - break; - } + if (i * 8 + 7 >= last_cid) { + c = (i * 8 + 7 > last_cid) ? (v_used_chars[i]) : (c | v_used_chars[i]); + last_cid = i * 8 + 7; + break; + } } } if (last_cid > 0) { for (i = 0; i < 8; i++) { - if ((c >> i) & 1) - break; - last_cid--; + if ((c >> i) & 1) + break; + last_cid--; } } - if (last_cid >= 0xFFFFu) { - ERROR("CID count > 65535"); - } + ASSERT(last_cid < 0xFFFFu); } #ifndef NO_GHOSTSCRIPT_BUG @@ -691,32 +697,31 @@ CIDFont_type2_dofont (CIDFont *font) unsigned short gid; if (!is_used_char2(h_used_chars, cid)) - continue; + continue; if (glyph_ordering) { - gid = cid; - code = cid; + gid = cid; + code = cid; } else { - code = cid_to_code(cmap, cid); - gid = tt_cmap_lookup(ttcmap, code); + code = cid_to_code(cmap, cid); + gid = tt_cmap_lookup(ttcmap, code); #ifdef FIX_CJK_UNIOCDE_SYMBOLS - if (gid == 0 && unicode_cmap) { - int alt_code; - - alt_code = fix_CJK_symbols((unsigned short)code); - if (alt_code != code) { - gid = tt_cmap_lookup(ttcmap, alt_code); - if (gid != 0) { - WARN("Unicode char U+%04x replaced with U+%04x.", - code, alt_code); - } - } - } + if (gid == 0 && unicode_cmap) { + int alt_code; + + alt_code = fix_CJK_symbols((unsigned short)code); + if (alt_code != code) { + gid = tt_cmap_lookup(ttcmap, alt_code); + if (gid != 0) { + WARN("Unicode char U+%04x replaced with U+%04x.", code, alt_code); + } + } + } #endif /* FIX_CJK_UNIOCDE_SYMBOLS */ } if (gid == 0) { - WARN("Glyph missing in font. (CID=%u, code=0x%04x)", cid, code); + WARN("Glyph missing in font. (CID=%u, code=0x%04x)", cid, code); } /* TODO: duplicated glyph */ @@ -745,18 +750,16 @@ CIDFont_type2_dofont (CIDFont *font) gsub_list = NULL; } else { gsub_list = otl_gsub_new(); - if (otl_gsub_add_feat(gsub_list, - "*", "*", "vrt2", sfont) < 0) { - if (otl_gsub_add_feat(gsub_list, - "*", "*", "vert", sfont) < 0) { - WARN("GSUB feature vrt2/vert not found."); - otl_gsub_release(gsub_list); - gsub_list = NULL; - } else { - otl_gsub_select(gsub_list, "*", "*", "vert"); - } + if (otl_gsub_add_feat(gsub_list, "*", "*", "vrt2", sfont) < 0) { + if (otl_gsub_add_feat(gsub_list, "*", "*", "vert", sfont) < 0) { + WARN("GSUB feature vrt2/vert not found."); + otl_gsub_release(gsub_list); + gsub_list = NULL; + } else { + otl_gsub_select(gsub_list, "*", "*", "vert"); + } } else { - otl_gsub_select(gsub_list, "*", "*", "vrt2"); + otl_gsub_select(gsub_list, "*", "*", "vrt2"); } } @@ -765,41 +768,40 @@ CIDFont_type2_dofont (CIDFont *font) unsigned short gid; if (!is_used_char2(v_used_chars, cid)) - continue; + continue; /* There may be conflict of horizontal and vertical glyphs * when font is used with /UCS. However, we simply ignore * that... */ if (h_used_chars && is_used_char2(h_used_chars, cid)) { - continue; + continue; } if (glyph_ordering) { - gid = cid; - code = cid; + gid = cid; + code = cid; } else { - code = cid_to_code(cmap, cid); - gid = tt_cmap_lookup(ttcmap, code); + code = cid_to_code(cmap, cid); + gid = tt_cmap_lookup(ttcmap, code); #ifdef FIX_CJK_UNIOCDE_SYMBOLS - if (gid == 0 && unicode_cmap) { - int alt_code; - - alt_code = fix_CJK_symbols((unsigned short)code); - if (alt_code != code) { - gid = tt_cmap_lookup(ttcmap, alt_code); - if (gid != 0) { - WARN("Unicode char U+%04x replaced with U+%04x.", - code, alt_code); - } - } - } + if (gid == 0 && unicode_cmap) { + int alt_code; + + alt_code = fix_CJK_symbols((unsigned short)code); + if (alt_code != code) { + gid = tt_cmap_lookup(ttcmap, alt_code); + if (gid != 0) { + WARN("Unicode char U+%04x replaced with U+%04x.", code, alt_code); + } + } + } #endif /* FIX_CJK_UNIOCDE_SYMBOLS */ } if (gid == 0) { - WARN("Glyph missing in font. (CID=%u, code=0x%04x)", cid, code); + WARN("Glyph missing in font. (CID=%u, code=0x%04x)", cid, code); } else if (gsub_list) { - otl_gsub_apply(gsub_list, &gid); + otl_gsub_apply(gsub_list, &gid); } #ifndef NO_GHOSTSCRIPT_BUG @@ -811,7 +813,7 @@ CIDFont_type2_dofont (CIDFont *font) #endif /* !NO_GHOSTSCRIPT_BUG */ if (used_chars) /* merge vertical used_chars to horizontal */ - add_to_used_chars2(used_chars, cid); + add_to_used_chars2(used_chars, cid); num_glyphs++; } @@ -823,31 +825,41 @@ CIDFont_type2_dofont (CIDFont *font) used_chars = v_used_chars; } - if (!used_chars) - ERROR("Unexpected error."); + ASSERT(used_chars); tt_cmap_release(ttcmap); - if (CIDFont_get_embedding(font)) { - if (tt_build_tables(sfont, glyphs) < 0) - ERROR("Could not created FontFile stream."); + if (font->cid.options.embed) { + if (tt_build_tables(sfont, glyphs) < 0) { + WARN("Could not created FontFile stream."); + if (cidtogidmap) + RELEASE(cidtogidmap); + sfnt_close(sfont); + DPXFCLOSE(fp); + return -1; + } if (dpx_conf.verbose_level > 1) MESG("[%u glyphs (Max CID: %u)]", glyphs->num_glyphs, last_cid); } else { - if (tt_get_metrics(sfont, glyphs) < 0) - ERROR("Reading glyph metrics failed..."); + if (tt_get_metrics(sfont, glyphs) < 0) { + WARN("Reading glyph metrics failed..."); + if (cidtogidmap) + RELEASE(cidtogidmap); + sfnt_close(sfont); + DPXFCLOSE(fp); + return -1; + } } /* * DW, W, DW2, and W2 */ - if (opt_flags & CIDFONT_FORCE_FIXEDPITCH) { - pdf_add_dict(font->fontdict, - pdf_new_name("DW"), pdf_new_number(1000.0)); + if (opt_flags_cidfont & CIDFONT_FORCE_FIXEDPITCH) { + pdf_add_dict(font->resource, pdf_new_name("DW"), pdf_new_number(1000.0)); } else { - add_TTCIDHMetrics(font->fontdict, glyphs, used_chars, cidtogidmap, last_cid); + add_TTCIDHMetrics(font->resource, glyphs, used_chars, cidtogidmap, last_cid); if (v_used_chars) - add_TTCIDVMetrics(font->fontdict, glyphs, used_chars, last_cid); + add_TTCIDVMetrics(font->resource, glyphs, used_chars, last_cid); } /* CIDSet @@ -873,14 +885,13 @@ CIDFont_type2_dofont (CIDFont *font) tt_build_finish(glyphs); /* Finish here if not embedded. */ - if (!CIDFont_get_embedding(font)) { + if (!font->cid.options.embed) { if (cidtogidmap) RELEASE(cidtogidmap); sfnt_close(sfont); - if (fp) - DPXFCLOSE(fp); + DPXFCLOSE(fp); - return; + return 0; } /* Create font file */ @@ -888,7 +899,12 @@ CIDFont_type2_dofont (CIDFont *font) if (sfnt_require_table(sfont, required_table[i].name, required_table[i].must_exist) < 0) { - ERROR("Some required TrueType table (%s) does not exist.", required_table[i].name); + WARN("Some required TrueType table (%s) does not exist.", required_table[i].name); + if (cidtogidmap) + RELEASE(cidtogidmap); + sfnt_close(sfont); + DPXFCLOSE(fp); + return -1; } } @@ -898,19 +914,19 @@ CIDFont_type2_dofont (CIDFont *font) fontfile = sfnt_create_FontFile_stream(sfont); sfnt_close(sfont); - if (fp) - DPXFCLOSE(fp); - - if (!fontfile) - ERROR("Could not created FontFile stream for \"%s\".", font->ident); + DPXFCLOSE(fp); + if (!fontfile) { + WARN("Could not created FontFile stream for \"%s\".", font->filename); + if (cidtogidmap) + RELEASE(cidtogidmap); + return -1; + } if (dpx_conf.verbose_level > 1) { MESG("[%ld bytes]", pdf_stream_length(fontfile)); } - pdf_add_dict(font->descriptor, - pdf_new_name("FontFile2"), - pdf_ref_obj (fontfile)); + pdf_add_dict(font->descriptor, pdf_new_name("FontFile2"), pdf_ref_obj (fontfile)); pdf_release_obj(fontfile); /* @@ -920,32 +936,28 @@ CIDFont_type2_dofont (CIDFont *font) * for Type 2 CIDFonts with embedded font programs. */ if (!cidtogidmap) { - pdf_add_dict(font->fontdict, - pdf_new_name("CIDToGIDMap"), - pdf_new_name("Identity")); + pdf_add_dict(font->resource, pdf_new_name("CIDToGIDMap"), pdf_new_name("Identity")); } else { pdf_obj *c2gmstream; c2gmstream = pdf_new_stream(STREAM_COMPRESS); pdf_add_stream(c2gmstream, cidtogidmap, (last_cid + 1) * 2); - pdf_add_dict(font->fontdict, - pdf_new_name("CIDToGIDMap"), - pdf_ref_obj (c2gmstream)); + pdf_add_dict(font->resource, pdf_new_name("CIDToGIDMap"), pdf_ref_obj (c2gmstream)); pdf_release_obj(c2gmstream); RELEASE(cidtogidmap); } - return; + return 0; } int -CIDFont_type2_open (CIDFont *font, const char *name, - CIDSysInfo *cmap_csi, cid_opt *opt) +CIDFont_type2_open (pdf_font *font, const char *name, int index, cid_opt *opt) { + int error; char *fontname; sfnt *sfont; ULONG offset = 0; - FILE *fp = NULL; + FILE *fp = NULL; ASSERT(font && opt); @@ -953,7 +965,7 @@ CIDFont_type2_open (CIDFont *font, const char *name, if (!fp) { fp = DPXFOPEN(name, DPX_RES_TYPE_DFONT); if (!fp) return -1; - sfont = dfont_open(fp, opt->index); + sfont = dfont_open(fp, index); } else { sfont = sfnt_open(fp); } @@ -965,11 +977,15 @@ CIDFont_type2_open (CIDFont *font, const char *name, switch (sfont->type) { case SFNT_TYPE_TTC: - offset = ttc_read_offset(sfont, opt->index); + offset = ttc_read_offset(sfont, index); break; case SFNT_TYPE_TRUETYPE: - if (opt->index > 0) - ERROR("Invalid TTC index (not TTC font): %s", name); + if (index > 0) { + WARN("Invalid TTC index (not TTC font): %s", name); + sfnt_close(sfont); + DPXFCLOSE(fp); + return -1; + } offset = 0; break; case SFNT_TYPE_DFONT: @@ -977,20 +993,21 @@ CIDFont_type2_open (CIDFont *font, const char *name, break; default: sfnt_close(sfont); - if (fp) - DPXFCLOSE(fp); + DPXFCLOSE(fp); return -1; } if (sfnt_read_table_directory(sfont, offset) < 0) { - ERROR("Reading TrueType table directory failed."); + WARN("Reading TrueType table directory failed: %s", name); + sfnt_close(sfont); + DPXFCLOSE(fp); + return -1; } /* Ignore TrueType Collection with CFF table. */ if (sfont->type == SFNT_TYPE_TTC && sfnt_find_table_pos(sfont, "CFF ")) { sfnt_close(sfont); - if (fp) - DPXFCLOSE(fp); + DPXFCLOSE(fp); return -1; } @@ -1006,7 +1023,13 @@ CIDFont_type2_open (CIDFont *font, const char *name, strncpy(shortname, name, PDF_NAME_LEN_MAX); namelen = strlen(shortname); } - validate_name(shortname, namelen); /* for SJIS, UTF-16, ... string */ + error = validate_name(shortname, namelen); /* for SJIS, UTF-16, ... string */ + if (error) { + RELEASE(shortname); + sfnt_close(sfont); + DPXFCLOSE(fp); + return -1; + } /* * Strlen works, after validate_named string. * Mangled name requires more 7 bytes. @@ -1036,55 +1059,25 @@ CIDFont_type2_open (CIDFont *font, const char *name, * CIDSystemInfo is determined from CMap or from map record option. */ font->fontname = fontname; - font->subtype = CIDFONT_TYPE2; - font->csi = NEW(1, CIDSysInfo); - if (opt->csi) { - if (cmap_csi) { - if (strcmp(opt->csi->registry, cmap_csi->registry) || - strcmp(opt->csi->ordering, cmap_csi->ordering)) { - WARN("CID character collection mismatched:\n"); - MESG("\tFont: %s-%s-%d\n", - opt->csi->registry, opt->csi->ordering, opt->csi->supplement); - MESG("\tCMap: %s-%s-%d\n", - cmap_csi->registry, cmap_csi->ordering, cmap_csi->supplement); - ERROR("Incompatible CMap specified for this font."); - } - if (opt->csi->supplement < cmap_csi->supplement) { - WARN("Supplement value in CIDSystemInfo increased."); - WARN("Some characters may not shown."); - opt->csi->supplement = cmap_csi->supplement; - } - } - font->csi->registry = NEW(strlen(opt->csi->registry)+1, char); - strcpy(font->csi->registry, opt->csi->registry); - font->csi->ordering = NEW(strlen(opt->csi->ordering)+1, char); - strcpy(font->csi->ordering, opt->csi->ordering); - font->csi->supplement = opt->csi->supplement; - } else if (cmap_csi) { - font->csi->registry = NEW(strlen(cmap_csi->registry)+1, char); - strcpy(font->csi->registry, cmap_csi->registry); - font->csi->ordering = NEW(strlen(cmap_csi->ordering)+1, char); - strcpy(font->csi->ordering, cmap_csi->ordering); - font->csi->supplement = cmap_csi->supplement; - } else { /* This means font's internal glyph ordering. */ - font->csi->registry = NEW(strlen("Adobe")+1, char); - strcpy(font->csi->registry, "Adobe"); - font->csi->ordering = NEW(strlen("Identity")+1, char); - strcpy(font->csi->ordering, "Identity"); - font->csi->supplement = 0; + font->subtype = PDF_FONT_FONTTYPE_CIDTYPE2; + if (opt->csi.registry && opt->csi.ordering) { + font->cid.csi.registry = NEW(strlen(opt->csi.registry)+1, char); + strcpy(font->cid.csi.registry, opt->csi.registry); + font->cid.csi.ordering = NEW(strlen(opt->csi.ordering)+1, char); + strcpy(font->cid.csi.ordering, opt->csi.ordering); + font->cid.csi.supplement = opt->csi.supplement; } - font->fontdict = pdf_new_dict(); - pdf_add_dict(font->fontdict, - pdf_new_name("Type"), - pdf_new_name("Font")); - pdf_add_dict(font->fontdict, - pdf_new_name("Subtype"), - pdf_new_name("CIDFontType2")); + font->resource = pdf_new_dict(); + pdf_add_dict(font->resource, pdf_new_name("Type"), pdf_new_name("Font")); + pdf_add_dict(font->resource, pdf_new_name("Subtype"), pdf_new_name("CIDFontType2")); font->descriptor = tt_get_fontdesc(sfont, &(opt->embed), opt->stemv, 0, name); if (!font->descriptor) { - ERROR("Could not obtain necessary font info."); + WARN("Could not obtain necessary font info: %s", name); + sfnt_close(sfont); + DPXFCLOSE(fp); + return -1; } if (opt->embed) { @@ -1093,12 +1086,8 @@ CIDFont_type2_open (CIDFont *font, const char *name, fontname[6] = '+'; } - pdf_add_dict(font->descriptor, - pdf_new_name("FontName"), - pdf_new_name(fontname)); - pdf_add_dict(font->fontdict, - pdf_new_name("BaseFont"), - pdf_new_name(fontname)); + pdf_add_dict(font->descriptor, pdf_new_name("FontName"), pdf_new_name(fontname)); + pdf_add_dict(font->resource, pdf_new_name("BaseFont"), pdf_new_name(fontname)); sfnt_close(sfont); if (fp) diff --git a/Build/source/texk/dvipdfm-x/cidtype2.h b/Build/source/texk/dvipdfm-x/cidtype2.h index 764767127af..70ab71e6d67 100644 --- a/Build/source/texk/dvipdfm-x/cidtype2.h +++ b/Build/source/texk/dvipdfm-x/cidtype2.h @@ -21,13 +21,9 @@ #ifndef _CIDTYPE2_H_ #define _CIDTYPE2_H_ -#include "cid.h" -#include "cid_p.h" +#include "pdffont.h" -extern void CIDFont_type2_set_flags (int flags); - -extern int CIDFont_type2_open (CIDFont *font, const char *name, - CIDSysInfo *cmap_csi, cid_opt *opt); -extern void CIDFont_type2_dofont (CIDFont *font); +extern int CIDFont_type2_open (pdf_font *font, const char *name, int index, cid_opt *opt); +extern int CIDFont_type2_dofont (pdf_font *font); #endif /* _CIDTYPE2_H_ */ diff --git a/Build/source/texk/dvipdfm-x/configure b/Build/source/texk/dvipdfm-x/configure index 96006213388..816697a5ef5 100755 --- a/Build/source/texk/dvipdfm-x/configure +++ b/Build/source/texk/dvipdfm-x/configure @@ -1,6 +1,6 @@ #! /bin/sh # Guess values for system-dependent variables and create Makefiles. -# Generated by GNU Autoconf 2.69 for dvipdfm-x (TeX Live) 20200906. +# Generated by GNU Autoconf 2.69 for dvipdfm-x (TeX Live) 20200922. # # Report bugs to . # @@ -590,8 +590,8 @@ MAKEFLAGS= # Identity of this package. PACKAGE_NAME='dvipdfm-x (TeX Live)' PACKAGE_TARNAME='dvipdfm-x--tex-live-' -PACKAGE_VERSION='20200906' -PACKAGE_STRING='dvipdfm-x (TeX Live) 20200906' +PACKAGE_VERSION='20200922' +PACKAGE_STRING='dvipdfm-x (TeX Live) 20200922' PACKAGE_BUGREPORT='dvipdfmx@tug.org' PACKAGE_URL='' @@ -1350,7 +1350,7 @@ if test "$ac_init_help" = "long"; then # Omit some internal or obsolete options to make the list less imposing. # This message is too long to be a string in the A/UX 3.1 sh. cat <<_ACEOF -\`configure' configures dvipdfm-x (TeX Live) 20200906 to adapt to many kinds of systems. +\`configure' configures dvipdfm-x (TeX Live) 20200922 to adapt to many kinds of systems. Usage: $0 [OPTION]... [VAR=VALUE]... @@ -1421,7 +1421,7 @@ fi if test -n "$ac_init_help"; then case $ac_init_help in - short | recursive ) echo "Configuration of dvipdfm-x (TeX Live) 20200906:";; + short | recursive ) echo "Configuration of dvipdfm-x (TeX Live) 20200922:";; esac cat <<\_ACEOF @@ -1551,7 +1551,7 @@ fi test -n "$ac_init_help" && exit $ac_status if $ac_init_version; then cat <<\_ACEOF -dvipdfm-x (TeX Live) configure 20200906 +dvipdfm-x (TeX Live) configure 20200922 generated by GNU Autoconf 2.69 Copyright (C) 2012 Free Software Foundation, Inc. @@ -2390,7 +2390,7 @@ cat >config.log <<_ACEOF This file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake. -It was created by dvipdfm-x (TeX Live) $as_me 20200906, which was +It was created by dvipdfm-x (TeX Live) $as_me 20200922, which was generated by GNU Autoconf 2.69. Invocation command line was $ $0 $@ @@ -8077,7 +8077,7 @@ fi # Define the identity of the package. PACKAGE='dvipdfm-x--tex-live-' - VERSION='20200906' + VERSION='20200922' cat >>confdefs.h <<_ACEOF @@ -14746,7 +14746,7 @@ Usage: $0 [OPTIONS] Report bugs to ." lt_cl_version="\ -dvipdfm-x (TeX Live) config.lt 20200906 +dvipdfm-x (TeX Live) config.lt 20200922 configured by $0, generated by GNU Autoconf 2.69. Copyright (C) 2011 Free Software Foundation, Inc. @@ -16636,7 +16636,7 @@ cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # report actual input values of CONFIG_FILES etc. instead of their # values after options handling. ac_log=" -This file was extended by dvipdfm-x (TeX Live) $as_me 20200906, which was +This file was extended by dvipdfm-x (TeX Live) $as_me 20200922, which was generated by GNU Autoconf 2.69. Invocation command line was CONFIG_FILES = $CONFIG_FILES @@ -16706,7 +16706,7 @@ _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`" ac_cs_version="\\ -dvipdfm-x (TeX Live) config.status 20200906 +dvipdfm-x (TeX Live) config.status 20200922 configured by $0, generated by GNU Autoconf 2.69, with options \\"\$ac_cs_config\\" diff --git a/Build/source/texk/dvipdfm-x/configure.ac b/Build/source/texk/dvipdfm-x/configure.ac index 38bc50dddc0..b428d0b25c4 100644 --- a/Build/source/texk/dvipdfm-x/configure.ac +++ b/Build/source/texk/dvipdfm-x/configure.ac @@ -8,7 +8,7 @@ dnl This file is free software; the copyright holder dnl gives unlimited permission to copy and/or distribute it, dnl with or without modifications, as long as this notice is preserved. dnl -AC_INIT([dvipdfm-x (TeX Live)], [20200906], [dvipdfmx@tug.org]) +AC_INIT([dvipdfm-x (TeX Live)], [20200922], [dvipdfmx@tug.org]) AC_PREREQ([2.65]) AC_CONFIG_SRCDIR([agl.c]) AC_CONFIG_AUX_DIR([../../build-aux]) diff --git a/Build/source/texk/dvipdfm-x/dpxutil.c b/Build/source/texk/dvipdfm-x/dpxutil.c index 4bcf28ad699..379fb515058 100644 --- a/Build/source/texk/dvipdfm-x/dpxutil.c +++ b/Build/source/texk/dvipdfm-x/dpxutil.c @@ -370,6 +370,8 @@ dpx_stack_roll (dpx_stack *stack, int n, int j) if (n == 1) return; j = j % n; + if (j < 0) + j = n + j; while (j-- > 0) { int m = n; stack_elem *elem, *prev, *top; diff --git a/Build/source/texk/dvipdfm-x/pdfdev.c b/Build/source/texk/dvipdfm-x/pdfdev.c index b3bec533cba..dc56050c3ee 100644 --- a/Build/source/texk/dvipdfm-x/pdfdev.c +++ b/Build/source/texk/dvipdfm-x/pdfdev.c @@ -176,7 +176,7 @@ struct dev_font { /* Needs to be big enough to hold name "Fxxx" * where xxx is number of largest font */ - char short_name[7]; /* Resource name */ + char short_name[16]; /* Resource name */ int used_on_this_page; char *tex_name; /* String identifier of this font */ @@ -196,9 +196,6 @@ struct dev_font { int font_id; int enc_id; - /* if >= 0, index of a dev_font that really has the resource and used_chars */ - int real_font_index; - pdf_obj *resource; char *used_chars; @@ -255,7 +252,6 @@ struct pdf_dev { struct dev_font *fonts; int num_dev_fonts; int max_dev_fonts; - int num_phys_fonts; char format_buffer[FORMAT_BUF_SIZE+1]; }; @@ -856,7 +852,6 @@ static int pdf_dev_set_font (pdf_dev *p, int font_id) { struct dev_font *font; - struct dev_font *real_font; int text_rotate; double font_scale; int len; @@ -870,11 +865,6 @@ pdf_dev_set_font (pdf_dev *p, int font_id) font = GET_FONT(p, font_id); ASSERT(font); /* Caller should check font_id. */ - if (font->real_font_index >= 0) - real_font = GET_FONT(p, font->real_font_index); - else - real_font = font; - p->text_state.is_mb = (font->format == PDF_FONTTYPE_COMPOSITE) ? 1 : 0; vert_font = font->wmode ? 1 : 0; @@ -894,20 +884,20 @@ pdf_dev_set_font (pdf_dev *p, int font_id) p->text_state.matrix.extend = font->extend; p->text_state.matrix.rotate = text_rotate; - if (!real_font->resource) { - real_font->resource = pdf_get_font_reference(real_font->font_id); - real_font->used_chars = pdf_get_font_usedchars(real_font->font_id); + if (!font->resource) { + font->resource = pdf_get_font_reference(font->font_id); + font->used_chars = pdf_get_font_usedchars(font->font_id); } - if (!real_font->used_on_this_page) { + if (!font->used_on_this_page) { pdf_doc_add_page_resource("Font", - real_font->short_name, - pdf_link_obj(real_font->resource)); - real_font->used_on_this_page = 1; + font->short_name, + pdf_link_obj(font->resource)); + font->used_on_this_page = 1; } font_scale = (double) font->sptsize * p->unit.dvi2pts; - len = sprintf(p->format_buffer, " /%s", real_font->short_name); /* space not necessary. */ + len = sprintf(p->format_buffer, " /%s", font->short_name); /* space not necessary. */ p->format_buffer[len++] = ' '; len += p_dtoa(font_scale, MIN(p->unit.precision+1, DEV_PRECISION_MAX), p->format_buffer+len); @@ -1057,7 +1047,6 @@ pdf_dev_set_string (spt_t xpos, spt_t ypos, { pdf_dev *p = current_device(); struct dev_font *font; - struct dev_font *real_font; const unsigned char *str_ptr; /* Pointer to the reencoded string. */ int length, i, len = 0; spt_t kern, delh, delv; @@ -1078,11 +1067,6 @@ pdf_dev_set_string (spt_t xpos, spt_t ypos, return; } - if (font->real_font_index >= 0) - real_font = GET_FONT(p, font->real_font_index); - else - real_font = font; - text_xorigin = p->text_state.ref_x; text_yorigin = p->text_state.ref_y; @@ -1094,16 +1078,16 @@ pdf_dev_set_string (spt_t xpos, spt_t ypos, ERROR("Error in converting input string..."); return; } - if (real_font->used_chars != NULL) { + if (font->used_chars != NULL) { for (i = 0; i < length; i += 2) { unsigned short cid = (str_ptr[i] << 8) | str_ptr[i + 1]; - add_to_used_chars2(real_font->used_chars, cid); + add_to_used_chars2(font->used_chars, cid); } } } else { - if (real_font->used_chars != NULL) { + if (font->used_chars != NULL) { for (i = 0; i < length; i++) - real_font->used_chars[str_ptr[i]] = 1; + font->used_chars[str_ptr[i]] = 1; } } @@ -1408,11 +1392,9 @@ pdf_dev_locate_font (const char *font_name, spt_t ptsize) } for (i = 0; i < p->num_dev_fonts; i++) { - if (strcmp(font_name, p->fonts[i].tex_name) == 0) { - if (ptsize == p->fonts[i].sptsize) - return i; /* found a dev_font that matches the request */ - if (p->fonts[i].format != PDF_FONTTYPE_BITMAP) - break; /* new dev_font will share pdf resource with /i/ */ + if (!strcmp(font_name, p->fonts[i].tex_name) && + ptsize == p->fonts[i].sptsize) { + return i; /* found a dev_font that matches the request */ } } @@ -1433,22 +1415,15 @@ pdf_dev_locate_font (const char *font_name, spt_t ptsize) if (dpx_conf.verbose_level > 1) print_fontmap(font_name, mrec); - font->font_id = pdf_font_findresource(font_name, ptsize * p->unit.dvi2pts, mrec); - if (font->font_id < 0) - return -1; - - /* We found device font here. */ - if (i < p->num_dev_fonts) { - font->real_font_index = i; - strcpy(font->short_name, p->fonts[i].short_name); - } - else { - font->real_font_index = -1; - font->short_name[0] = 'F'; - p_itoa(p->num_phys_fonts + 1, &font->short_name[1]); /* NULL terminated here */ - p->num_phys_fonts++; + font->font_id = pdf_font_findresource(font_name, ptsize * p->unit.dvi2pts); + if (font->font_id < 0) { + font->font_id = pdf_font_load_font(font_name, ptsize * p->unit.dvi2pts, mrec); + if (font->font_id < 0) + return -1; } + pdf_font_resource_name(font->font_id, font->short_name); + font->used_on_this_page = 0; font->tex_name = NEW(strlen(font_name) + 1, char); diff --git a/Build/source/texk/dvipdfm-x/pdfdraw.c b/Build/source/texk/dvipdfm-x/pdfdraw.c index 9fc71638bc0..66549e193b1 100644 --- a/Build/source/texk/dvipdfm-x/pdfdraw.c +++ b/Build/source/texk/dvipdfm-x/pdfdraw.c @@ -63,10 +63,12 @@ inversematrix (pdf_tmatrix *W, const pdf_tmatrix *M) return -1; /* result is undefined. */ } - W->a = (M->d) / det; W->b = -(M->b) / det; - W->c = -(M->c) / det; W->d = (M->a) / det; - W->e = (M->c) * (M->f) - (M->d) * (M->e); - W->f = (M->b) * (M->e) - (M->a) * (M->f); + W->a = (M->d) / det; W->b = -(M->b) / det; + W->c = -(M->c) / det; W->d = (M->a) / det; + W->e = (M->c) * (M->f) - (M->d) * (M->e); + W->f = (M->b) * (M->e) - (M->a) * (M->f); + W->e /= det; + W->f /= det; return 0; } @@ -134,7 +136,6 @@ pdf_coord__transform (pdf_coord *p, const pdf_tmatrix *M) return 0; } -#if 0 static /* __inline__ */ int pdf_coord__itransform (pdf_coord *p, const pdf_tmatrix *M) { @@ -152,7 +153,6 @@ pdf_coord__itransform (pdf_coord *p, const pdf_tmatrix *M) return 0; } -#endif static /* __inline__ */ int pdf_coord__dtransform (pdf_coord *p, const pdf_tmatrix *M) @@ -1759,7 +1759,6 @@ pdf_dev_transform (pdf_coord *p, const pdf_tmatrix *M) return; } -#if 0 void pdf_dev_itransform (pdf_coord *p, const pdf_tmatrix *M) { @@ -1773,7 +1772,6 @@ pdf_dev_itransform (pdf_coord *p, const pdf_tmatrix *M) return; } -#endif int pdf_dev_arc (double c_x , double c_y, double r, diff --git a/Build/source/texk/dvipdfm-x/pdfdraw.h b/Build/source/texk/dvipdfm-x/pdfdraw.h index b2a32b1e722..cf4588cdbd9 100644 --- a/Build/source/texk/dvipdfm-x/pdfdraw.h +++ b/Build/source/texk/dvipdfm-x/pdfdraw.h @@ -115,9 +115,7 @@ extern int pdf_dev_concat (const pdf_tmatrix *M); extern void pdf_dev_dtransform (pdf_coord *p, const pdf_tmatrix *M); extern void pdf_dev_idtransform (pdf_coord *p, const pdf_tmatrix *M); extern void pdf_dev_transform (pdf_coord *p, const pdf_tmatrix *M); -#if 0 extern void pdf_dev_itransform (pdf_coord *p, const pdf_tmatrix *M); -#endif extern int pdf_dev_gsave (void); extern int pdf_dev_grestore (void); diff --git a/Build/source/texk/dvipdfm-x/pdffont.c b/Build/source/texk/dvipdfm-x/pdffont.c index 5e38733d3c8..cc05c2e1ac9 100644 --- a/Build/source/texk/dvipdfm-x/pdffont.c +++ b/Build/source/texk/dvipdfm-x/pdffont.c @@ -47,9 +47,9 @@ #include "pkfont.h" +#include "cidtype0.h" #include "type0.h" #include "tt_cmap.h" -#include "cidtype0.h" #include "pdffont.h" @@ -66,16 +66,6 @@ pdf_font_make_uniqueTag (char *tag) { int i; char ch; - static char first = 1; - - if (first) { - time_t current_time; - current_time = dpx_util_get_unique_time_if_given(); - if (current_time == INVALID_EPOCH_VALUE) - current_time = time(NULL); - srand(current_time); - first = 0; - } for (i = 0; i < 6; i++) { ch = rand() % 26; @@ -84,58 +74,25 @@ pdf_font_make_uniqueTag (char *tag) tag[6] = '\0'; } - -struct pdf_font -{ - char *ident; - int subtype; - - char *map_name; - - int encoding_id; /* encoding or CMap */ - - /* - * If subtype is Type0, it simply points font_id - * of Type0 font. Type0 and simple font is not - * unified yet. - */ - int font_id; - - /* For simple font */ - uint32_t index; - char *fontname; - char uniqueID[7]; - - /* - * PDF font resource objects - */ - pdf_obj *reference; - pdf_obj *resource; - pdf_obj *descriptor; - - /* - * Font format specific data - */ - char *usedchars; - int flags; - - /* PK font */ - double point_size; - double design_size; -}; +static void +init_CIDSysInfo (CIDSysInfo *csi) { + csi->registry = NULL; + csi->ordering = NULL; + csi->supplement = 0; +} static void pdf_init_font_struct (pdf_font *font) { ASSERT(font); - font->ident = NULL; - font->map_name = NULL; - font->subtype = -1; - font->font_id = -1; /* Type0 ID */ - font->fontname = NULL; + font->ident = NULL; + font->filename = NULL; + font->subtype = -1; + font->font_id = -1; + font->fontname = NULL; memset(font->uniqueID, 0, 7); - font->index = 0; + font->index = 0; font->encoding_id = -1; @@ -149,6 +106,16 @@ pdf_init_font_struct (pdf_font *font) font->usedchars = NULL; font->flags = 0; + font->type0.descendant = -1; + font->type0.wmode = 0; + + init_CIDSysInfo(&font->cid.csi); + font->cid.usedchars_v = NULL; + font->cid.options.embed = 0; + font->cid.options.style = FONT_STYLE_NONE; + font->cid.options.stemv = 0; + init_CIDSysInfo(&font->cid.options.csi); + return; } @@ -157,37 +124,39 @@ pdf_flush_font (pdf_font *font) { char *fontname, *uniqueTag; - if (!font) { + if (!font) + return; + if ((font->flags & PDF_FONT_FLAG_IS_ALIAS) || (font->flags & PDF_FONT_FLAG_IS_REENCODE)) { return; } if (font->resource && font->reference) { - if (font->subtype != PDF_FONT_FONTTYPE_TYPE3) { - if (pdf_font_get_flag(font, PDF_FONT_FLAG_NOEMBED)) { - pdf_add_dict(font->resource, - pdf_new_name("BaseFont"), pdf_new_name(font->fontname)); - if (font->descriptor) { - pdf_add_dict(font->descriptor, - pdf_new_name("FontName"), pdf_new_name(font->fontname)); - } + switch (font->subtype) { + case PDF_FONT_FONTTYPE_TYPE3: + case PDF_FONT_FONTTYPE_TYPE0: + break; + case PDF_FONT_FONTTYPE_CIDTYPE0: + case PDF_FONT_FONTTYPE_CIDTYPE2: + break; + default: + if (font->flags & PDF_FONT_FLAG_NOEMBED) { + pdf_add_dict(font->resource, pdf_new_name("BaseFont"), pdf_new_name(font->fontname)); + if (font->descriptor) { + pdf_add_dict(font->descriptor, pdf_new_name("FontName"), pdf_new_name(font->fontname)); + } } else { - if (!font->fontname) { - ERROR("Undefined in fontname... (%s)", font->ident); - } - fontname = NEW(7+strlen(font->fontname)+1, char); - uniqueTag = pdf_font_get_uniqueTag(font); - sprintf(fontname, "%6s+%s", uniqueTag, font->fontname); - pdf_add_dict(font->resource, - pdf_new_name("BaseFont"), pdf_new_name(fontname)); - if (font->descriptor) { - pdf_add_dict(font->descriptor, - pdf_new_name("FontName"), pdf_new_name(fontname)); - } - RELEASE(fontname); + ASSERT(font->fontname); + fontname = NEW(7+strlen(font->fontname)+1, char); + uniqueTag = pdf_font_get_uniqueTag(font); + sprintf(fontname, "%6s+%s", uniqueTag, font->fontname); + pdf_add_dict(font->resource, pdf_new_name("BaseFont"), pdf_new_name(fontname)); + if (font->descriptor) { + pdf_add_dict(font->descriptor, pdf_new_name("FontName"), pdf_new_name(fontname)); + } + RELEASE(fontname); } if (font->descriptor) { - pdf_add_dict(font->resource, - pdf_new_name("FontDescriptor"), pdf_ref_obj(font->descriptor)); + pdf_add_dict(font->resource, pdf_new_name("FontDescriptor"), pdf_ref_obj(font->descriptor)); } } } @@ -209,28 +178,42 @@ pdf_flush_font (pdf_font *font) static void pdf_clean_font_struct (pdf_font *font) { - if (font) { - if (font->ident) - RELEASE(font->ident); - if (font->map_name) - RELEASE(font->map_name); - if (font->fontname) - RELEASE(font->fontname); - if (font->usedchars) - RELEASE(font->usedchars); - - if (font->reference) - ERROR("pdf_font>> Object not flushed."); - if (font->resource) - ERROR("pdf_font> Object not flushed."); - if (font->descriptor) - ERROR("pdf_font>> Object not flushed."); - - font->ident = NULL; - font->map_name = NULL; - font->fontname = NULL; - font->usedchars = NULL; + if (!font) + return; + + if (font->resource) + WARN("font \"%s\" not properly released?", font->ident); + + if (font->ident) + RELEASE(font->ident); + if (font->filename) + RELEASE(font->filename); + if (font->fontname) + RELEASE(font->fontname); + if (font->usedchars) { + if (!(font->flags & PDF_FONT_FLAG_USEDCHAR_SHARED)) + RELEASE(font->usedchars); } + if (font->cid.csi.registry) + RELEASE(font->cid.csi.registry); + if (font->cid.csi.ordering) + RELEASE(font->cid.csi.ordering); + if (font->cid.options.csi.registry) + RELEASE(font->cid.options.csi.registry); + if (font->cid.options.csi.ordering) + RELEASE(font->cid.options.csi.ordering); + if (font->cid.usedchars_v) + RELEASE(font->cid.usedchars_v); + + font->ident = NULL; + font->filename = NULL; + font->fontname = NULL; + font->usedchars = NULL; + font->cid.csi.registry = NULL; + font->cid.csi.ordering = NULL; + font->cid.options.csi.registry = NULL; + font->cid.options.csi.ordering = NULL; + font->cid.usedchars_v = NULL; return; } @@ -255,11 +238,18 @@ pdf_init_fonts (void) CMap_cache_init(); pdf_init_encodings(); - Type0Font_cache_init(); - font_cache.count = 0; font_cache.capacity = CACHE_ALLOC_SIZE; font_cache.fonts = NEW(font_cache.capacity, pdf_font); + + { + time_t current_time; + + current_time = dpx_util_get_unique_time_if_given(); + if (current_time == INVALID_EPOCH_VALUE) + current_time = time(NULL); + srand(current_time); + } } #define CHECK_ID(n) do {\ @@ -267,8 +257,41 @@ pdf_init_fonts (void) ERROR("Invalid font ID: %d", (n));\ }\ } while (0) -#define GET_FONT(n) (&(font_cache.fonts[(n)])) +static pdf_font * +GET_FONT (int font_id) +{ + pdf_font *font = NULL; + + if (font_id >= 0 && font_id < font_cache.count) { + font = &font_cache.fonts[font_id]; + if (font->flags & PDF_FONT_FLAG_IS_ALIAS) { + font = &font_cache.fonts[font->font_id]; + } + } + + return font; +} + +pdf_font * +pdf_get_font_data (int font_id) +{ + CHECK_ID(font_id); + + return &font_cache.fonts[font_id]; +} + +char * +pdf_get_font_ident (int font_id) +{ + pdf_font *font; + + CHECK_ID(font_id); + + font = &font_cache.fonts[font_id]; + + return font->ident; +} pdf_obj * pdf_get_font_reference (int font_id) @@ -278,20 +301,42 @@ pdf_get_font_reference (int font_id) CHECK_ID(font_id); font = GET_FONT(font_id); + if (font->flags & PDF_FONT_FLAG_IS_REENCODE) { + font = GET_FONT(font->font_id); + } + if (!font->reference) { + font->reference = pdf_ref_obj(pdf_font_get_resource(font)); + } if (font->subtype == PDF_FONT_FONTTYPE_TYPE0) { - Type0Font *t0font; + if (!pdf_lookup_dict(font->resource, "DescendantFonts")) { + pdf_obj *array; - t0font = Type0Font_cache_get(font->font_id); - return Type0Font_get_resource(t0font); - } else { - if (!font->reference) { - font->reference = pdf_ref_obj(pdf_font_get_resource(font)); + array = pdf_new_array(); + pdf_add_array(array, pdf_get_font_reference(font->type0.descendant)); + pdf_add_dict(font->resource, pdf_new_name("DescendantFonts"), array); } } return pdf_link_obj(font->reference); } +pdf_obj * +pdf_get_font_resource (int font_id) +{ + pdf_font *font; + + CHECK_ID(font_id); + + font = GET_FONT(font_id); + if (font->flags & PDF_FONT_FLAG_IS_REENCODE) { + font = GET_FONT(font->font_id); + } + if (!font->resource) + font->resource = pdf_new_dict(); + + return font->resource; /* FIXME */ +} + char * pdf_get_font_usedchars (int font_id) { @@ -300,18 +345,17 @@ pdf_get_font_usedchars (int font_id) CHECK_ID(font_id); font = GET_FONT(font_id); - if (font->subtype == PDF_FONT_FONTTYPE_TYPE0) { - Type0Font *t0font; - - t0font = Type0Font_cache_get(font->font_id); - return Type0Font_get_usedchars(t0font); - } else { + if (font->flags & PDF_FONT_FLAG_IS_REENCODE) { + font = GET_FONT(font->font_id); + } + if (font->subtype != PDF_FONT_FONTTYPE_TYPE0) { if (!font->usedchars) { font->usedchars = NEW(256, char); memset(font->usedchars, 0, 256 * sizeof(char)); } - return font->usedchars; } + + return font->usedchars; } int @@ -322,11 +366,11 @@ pdf_get_font_wmode (int font_id) CHECK_ID(font_id); font = GET_FONT(font_id); + if (font->flags & PDF_FONT_FLAG_IS_REENCODE) { + font = GET_FONT(font->font_id); + } if (font->subtype == PDF_FONT_FONTTYPE_TYPE0) { - Type0Font *t0font; - - t0font = Type0Font_cache_get(font->font_id); - return Type0Font_get_wmode(t0font); + return font->type0.wmode; } else { return 0; } @@ -340,13 +384,15 @@ pdf_get_font_subtype (int font_id) CHECK_ID(font_id); font = GET_FONT(font_id); + if (font->flags & PDF_FONT_FLAG_IS_REENCODE) { + font = GET_FONT(font->font_id); + } return font->subtype; } -#if 0 -char * -pdf_get_font_fontname (int font_id) +int +pdf_get_font_encoding (int font_id) { pdf_font *font; @@ -354,20 +400,28 @@ pdf_get_font_fontname (int font_id) font = GET_FONT(font_id); - return font->fontname; + return font->encoding_id; } -#endif /* 0 */ int -pdf_get_font_encoding (int font_id) +pdf_font_resource_name (int font_id, char *buff) { + int len; pdf_font *font; CHECK_ID(font_id); + font = &font_cache.fonts[font_id]; + if (font->flags & PDF_FONT_FLAG_IS_ALIAS) { + font_id = font->font_id; + } font = GET_FONT(font_id); + if (font->flags & PDF_FONT_FLAG_IS_REENCODE) { + font_id = font->font_id; + } + len = sprintf(buff, "F%d", font_id); - return font->encoding_id; + return len; } /* The rule for ToUnicode creation is: @@ -381,10 +435,9 @@ pdf_get_font_encoding (int font_id) static int try_load_ToUnicode_CMap (pdf_font *font) { - pdf_obj *fontdict; pdf_obj *tounicode; const char *cmap_name = NULL; - fontmap_rec *mrec; /* Be sure fontmap is still alive here */ + fontmap_rec *mrec = NULL; /* Be sure fontmap is still alive here */ ASSERT(font); @@ -394,29 +447,32 @@ try_load_ToUnicode_CMap (pdf_font *font) if (font->subtype == PDF_FONT_FONTTYPE_TYPE0) return 0; - ASSERT(font->map_name); + ASSERT(font->ident); - mrec = pdf_lookup_fontmap_record(font->map_name); - if (MREC_HAS_TOUNICODE(mrec)) + mrec = pdf_lookup_fontmap_record(font->ident); + if (MREC_HAS_TOUNICODE(mrec)) { cmap_name = mrec->opt.tounicode; - else { - cmap_name = font->map_name; + } else { + cmap_name = font->ident; } - - fontdict = pdf_font_get_resource(font); tounicode = pdf_load_ToUnicode_stream(cmap_name); - if (!tounicode && MREC_HAS_TOUNICODE(mrec)) - WARN("Failed to read ToUnicode mapping \"%s\"...", mrec->opt.tounicode); - else if (tounicode) { - if (pdf_obj_typeof(tounicode) != PDF_STREAM) + + if (!tounicode) { + if (MREC_HAS_TOUNICODE(mrec)) { + WARN("Failed to read ToUnicode mapping \"%s\"...", mrec->opt.tounicode); + } + } else { + if (pdf_obj_typeof(tounicode) != PDF_STREAM) { ERROR("Object returned by pdf_load_ToUnicode_stream() not stream object! (This must be bug)"); - else if (pdf_stream_length(tounicode) > 0) { + } else if (pdf_stream_length(tounicode) > 0) { + pdf_obj *fontdict = pdf_font_get_resource(font); + pdf_add_dict(fontdict, pdf_new_name("ToUnicode"), pdf_ref_obj (tounicode)); /* _FIXME_ */ if (dpx_conf.verbose_level > 0) MESG("pdf_font>> ToUnicode CMap \"%s\" attached to font id=\"%s\".\n", - cmap_name, font->map_name); + cmap_name, font->ident); } pdf_release_obj(tounicode); } @@ -429,91 +485,133 @@ pdf_close_fonts (void) { int font_id; - for (font_id = 0; - font_id < font_cache.count; font_id++) { + for (font_id = 0; font_id < font_cache.count; font_id++) { pdf_font *font; - font = GET_FONT(font_id); + font = &font_cache.fonts[font_id]; + if ((font->flags & PDF_FONT_FLAG_IS_ALIAS) || + (font->flags & PDF_FONT_FLAG_IS_REENCODE)) { + continue; + } + if (font->subtype == PDF_FONT_FONTTYPE_CIDTYPE0 || + font->subtype == PDF_FONT_FONTTYPE_CIDTYPE2) + continue; if (dpx_conf.verbose_level > 0) { if (font->subtype != PDF_FONT_FONTTYPE_TYPE0) { - MESG("(%s", pdf_font_get_ident(font)); - if (dpx_conf.verbose_level > 2 && - !pdf_font_get_flag(font, PDF_FONT_FLAG_NOEMBED)) { - MESG("[%s+%s]", - pdf_font_get_uniqueTag(font), - pdf_font_get_fontname(font)); - } else if (dpx_conf.verbose_level > 1) { - MESG("[%s]", pdf_font_get_fontname(font)); - } - if (dpx_conf.verbose_level > 1) { - if (pdf_font_get_encoding(font) >= 0) { - MESG("[%s]", pdf_encoding_get_name(pdf_font_get_encoding(font))); - } else { - MESG("[built-in]"); - } - } + MESG("(%s", font->filename); + if (dpx_conf.verbose_level > 2 && + !(font->flags & PDF_FONT_FLAG_NOEMBED)) { + MESG("[%s+%s]", pdf_font_get_uniqueTag(font), font->fontname); + } else if (dpx_conf.verbose_level > 1) { + MESG("[%s]", font->fontname); + } + if (dpx_conf.verbose_level > 1) { + if (font->encoding_id >= 0) { + MESG("[%s]", pdf_encoding_get_name(font->encoding_id)); + } else { + MESG("[built-in]"); + } + } } } /* Must come before load_xxx */ try_load_ToUnicode_CMap(font); - /* Type 0 is handled separately... */ switch (font->subtype) { case PDF_FONT_FONTTYPE_TYPE1: if (dpx_conf.verbose_level > 0) - MESG("[Type1]"); - if (!pdf_font_get_flag(font, PDF_FONT_FLAG_BASEFONT)) - pdf_font_load_type1(font); + MESG("[Type1]"); + if (!(font->flags & PDF_FONT_FLAG_BASEFONT)) + pdf_font_load_type1(font); break; case PDF_FONT_FONTTYPE_TYPE1C: if (dpx_conf.verbose_level > 0) - MESG("[Type1C]"); + MESG("[Type1C]"); pdf_font_load_type1c(font); break; case PDF_FONT_FONTTYPE_TRUETYPE: if (dpx_conf.verbose_level > 0) - MESG("[TrueType]"); + MESG("[TrueType]"); pdf_font_load_truetype(font); break; case PDF_FONT_FONTTYPE_TYPE3: if (dpx_conf.verbose_level > 0) - MESG("[Type3/PK]"); + MESG("[Type3/PK]"); pdf_font_load_pkfont (font); break; case PDF_FONT_FONTTYPE_TYPE0: - break; - default: - ERROR("Unknown font type: %d", font->subtype); + if (dpx_conf.verbose_level > 0) + MESG("[Type0]"); + pdf_font_load_type0(font); break; } - if (font->encoding_id >= 0 && font->subtype != PDF_FONT_FONTTYPE_TYPE0) - pdf_encoding_add_usedchars(font->encoding_id, font->usedchars); + if (font->encoding_id >= 0) { + if (font->subtype != PDF_FONT_FONTTYPE_TYPE0) { + pdf_encoding_add_usedchars(font->encoding_id, font->usedchars); + } + } if (dpx_conf.verbose_level > 0) { - if (font->subtype != PDF_FONT_FONTTYPE_TYPE0) - MESG(")"); + if (font->subtype != PDF_FONT_FONTTYPE_TYPE0) { + MESG(")"); + } } } pdf_encoding_complete(); + /* Order is important... */ + for (font_id = 0; font_id < font_cache.count; font_id++) { + pdf_font *font = &font_cache.fonts[font_id]; + + if ((font->flags & PDF_FONT_FLAG_IS_ALIAS) || + (font->flags & PDF_FONT_FLAG_IS_REENCODE)) { + continue; + } + + switch (font->subtype) { + case PDF_FONT_FONTTYPE_CIDTYPE0: + case PDF_FONT_FONTTYPE_CIDTYPE2: + pdf_font_load_cidfont(font); + break; + } + } for (font_id = 0; font_id < font_cache.count; font_id++) { - pdf_font *font = GET_FONT(font_id); + pdf_font *font; + + font = &font_cache.fonts[font_id]; - if (font->encoding_id >= 0 && font->subtype != PDF_FONT_FONTTYPE_TYPE0) { + if ((font->flags & PDF_FONT_FLAG_IS_ALIAS) || + (font->flags & PDF_FONT_FLAG_IS_REENCODE)) { + pdf_clean_font_struct(font); + continue; + } + + if (font->encoding_id >= 0 && + font->subtype != PDF_FONT_FONTTYPE_TYPE0 && + font->subtype != PDF_FONT_FONTTYPE_CIDTYPE0 && + font->subtype != PDF_FONT_FONTTYPE_CIDTYPE2) { pdf_obj *enc_obj = pdf_get_encoding_obj(font->encoding_id); pdf_obj *tounicode; /* Predefined encodings (and those simplified to them) are embedded - * as direct objects, but this is purely a matter of taste. + * as direct objects, but this is purely a matter of taste. */ - if (enc_obj) - pdf_add_dict(font->resource, - pdf_new_name("Encoding"), - PDF_OBJ_NAMETYPE(enc_obj) ? pdf_link_obj(enc_obj) : pdf_ref_obj(enc_obj)); + if (enc_obj) { + if (font->subtype == PDF_FONT_FONTTYPE_TRUETYPE) { + if (pdf_encoding_is_predefined(font->encoding_id) && PDF_OBJ_NAMETYPE(enc_obj)) { + pdf_add_dict(font->resource, + pdf_new_name("Encoding"), pdf_link_obj(enc_obj)); + } + } else { + pdf_add_dict(font->resource, + pdf_new_name("Encoding"), + PDF_OBJ_NAMETYPE(enc_obj) ? pdf_link_obj(enc_obj) : pdf_ref_obj(enc_obj)); + } + } /* For built-in encoding, each font loader create ToUnicode CMap. */ if (!pdf_lookup_dict(font->resource, "ToUnicode")) { tounicode = pdf_encoding_get_tounicode(font->encoding_id); @@ -529,17 +627,15 @@ pdf_close_fonts (void) pdf_new_name("Encoding"), pdf_new_name("MacRomanEncoding")); } - pdf_flush_font(font); pdf_clean_font_struct(font); } + RELEASE(font_cache.fonts); font_cache.fonts = NULL; font_cache.count = 0; font_cache.capacity = 0; - Type0Font_cache_close(); - CMap_cache_close(); pdf_close_encodings(); @@ -549,19 +645,148 @@ pdf_close_fonts (void) } int -pdf_font_findresource (const char *tex_name, - double font_scale, fontmap_rec *mrec) +pdf_font_findresource (const char *ident, double scale) +{ + int font_id, found = 0; + + for (font_id = 0; font_id < font_cache.count; font_id++) { + pdf_font *font; + + font = &font_cache.fonts[font_id]; + switch (font->subtype) { + case PDF_FONT_FONTTYPE_TYPE1: + case PDF_FONT_FONTTYPE_TYPE1C: + case PDF_FONT_FONTTYPE_TRUETYPE: + case PDF_FONT_FONTTYPE_TYPE0: + if (!strcmp(ident, font->ident)) { + found = 1; + } + break; + case PDF_FONT_FONTTYPE_TYPE3: + /* There shouldn't be any encoding specified for PK font. + * It must be always font's build-in encoding. + * + * TODO: a PK font with two encodings makes no sense. Change? + */ + if (!strcmp(ident, font->ident) && scale == font->point_size) { + found = 1; + } + break; + } + + if (found) { + if (dpx_conf.verbose_level > 0) { + MESG("\npdf_font>> Font \"%s\" (enc_id=%d) found at id=%d.\n", font->ident, font->encoding_id, font_id); + } + break; + } + } + + return found ? font_id : -1; +} + +#if 1 +static void +compat_set_mapchar (int cmap_id, fontmap_rec *mrec) +{ + CMap *cmap; + int cmap_type, minbytes; + + cmap = CMap_cache_get(cmap_id); + cmap_type = CMap_get_type(cmap); + minbytes = CMap_get_profile(cmap, CMAP_PROF_TYPE_INBYTES_MIN); + + if (cmap_type != CMAP_TYPE_IDENTITY && + cmap_type != CMAP_TYPE_CODE_TO_CID && + cmap_type != CMAP_TYPE_TO_UNICODE) { + WARN("Only 16-bit encoding supported for output encoding."); + } + /* Turn on map option. */ + if (minbytes == 2 && mrec->opt.mapc < 0) { + if (dpx_conf.verbose_level > 0) { + MESG("\n"); + MESG("pdf_font>> Input encoding \"%s\" requires at least 2 bytes.\n", CMap_get_name(cmap)); + MESG("pdf_font>> The -m <00> option will be assumed for \"%s\".\n", mrec->font_name); + } + /* FIXME: The following code modifies mrec. */ + mrec->opt.mapc = 0; + } + + return; +} +#endif + +static int +create_font_alias (const char *ident, int font_id) +{ + int this_id; + pdf_font *font, *src; + + if (font_id < 0 || font_id >= font_cache.count) + return -1; + + src = &font_cache.fonts[font_id]; + + this_id = font_cache.count; + if (font_cache.count >= font_cache.capacity) { + font_cache.capacity += CACHE_ALLOC_SIZE; + font_cache.fonts = RENEW(font_cache.fonts, font_cache.capacity, pdf_font); + } + font = &font_cache.fonts[this_id]; + pdf_init_font_struct(font); + + font->ident = NEW(strlen(ident) + 1, char); + strcpy(font->ident, ident); + font->font_id = font_id; + font->subtype = src->subtype; + font->encoding_id = src->encoding_id; + + font->flags |= PDF_FONT_FLAG_IS_ALIAS; + + font_cache.count++; + + return this_id; +} + +static int +create_font_reencoded (const char *ident, int font_id, int cmap_id) +{ + int this_id; + pdf_font *font; + + if (font_cache.count + 1 >= font_cache.capacity) { + font_cache.capacity += CACHE_ALLOC_SIZE; + font_cache.fonts = RENEW(font_cache.fonts, font_cache.capacity, pdf_font); + } + + this_id = font_cache.count; + font = &font_cache.fonts[this_id]; + pdf_init_font_struct(font); + font->ident = NEW(strlen(ident) + 1, char); + strcpy(font->ident, ident); + font->font_id = font_id; + font->subtype = PDF_FONT_FONTTYPE_TYPE0; + font->encoding_id = cmap_id; + font->flags |= PDF_FONT_FLAG_IS_REENCODE; + font->flags |= PDF_FONT_FLAG_USEDCHAR_SHARED; + font_cache.count++; + + return this_id; +} + +int +pdf_font_load_font (const char *ident, double font_scale, fontmap_rec *mrec) { - int font_id = -1; - pdf_font *font; - int encoding_id = -1, cmap_id = -1; - const char *fontname; + int font_id = -1; + pdf_font *font; + int encoding_id = -1, cmap_id = -1; + const char *fontname; /* * Get appropriate info from map file. (PK fonts at two different * point sizes would be looked up twice unecessarily.) */ - fontname = mrec ? mrec->font_name : tex_name; + fontname = mrec ? mrec->font_name : ident; /* XeTeX specific... * First try loading GID-to-CID mapping from CFF CID-keyed OpenType font. * There was a serious bug in xdv support... It was implemented with the wrong @@ -580,253 +805,218 @@ pdf_font_findresource (const char *tex_name, else { WARN("Unexpected encoding specified for xdv: %s", mrec->enc_name); } - /* cmap_id < 0 is returned if ... - * Font is not a CFF font - * GID to CID mapping is identity mapping - * - * TODO: fontmap record still has Identity CMap assigned but actually different CMap - * can be attached to the font here. Should we fix mrec->enc_name here? - */ + /* cmap_id < 0 is returned if ... + * Font is not a CFF font + * GID to CID mapping is identity mapping + * + * TODO: fontmap record still has Identity CMap assigned but actually different CMap + * can be attached to the font here. Should we fix mrec->enc_name here? + */ cmap_id = otf_try_load_GID_to_CID_map(mrec->font_name, mrec->opt.index, wmode); } } + if (cmap_id < 0 && mrec && mrec->enc_name) { -#define MAYBE_CMAP(s) (!strstr((s), ".enc") || strstr((s), ".cmap")) - if (MAYBE_CMAP(mrec->enc_name)) { + if (!strcmp(mrec->enc_name, "unicode")) { + cmap_id = otf_load_Unicode_CMap(mrec->font_name, + mrec->opt.index, mrec->opt.otl_tags, + ((mrec->opt.flags & FONTMAP_OPT_VERT) ? 1 : 0)); + if (cmap_id < 0) { + cmap_id = t1_load_UnicodeCMap(mrec->font_name, mrec->opt.otl_tags, + ((mrec->opt.flags & FONTMAP_OPT_VERT) ? 1 : 0)); + } + } else if (!strstr(mrec->enc_name, ".enc") || strstr(mrec->enc_name, ".cmap")) { cmap_id = CMap_cache_find(mrec->enc_name); +#if 1 if (cmap_id >= 0) { - CMap *cmap; - int cmap_type, minbytes; - - cmap = CMap_cache_get(cmap_id); - cmap_type = CMap_get_type (cmap); - minbytes = CMap_get_profile(cmap, CMAP_PROF_TYPE_INBYTES_MIN); - /* - * Check for output encoding. - */ - if (cmap_type != CMAP_TYPE_IDENTITY && - cmap_type != CMAP_TYPE_CODE_TO_CID && - cmap_type != CMAP_TYPE_TO_UNICODE) { - WARN("Only 16-bit encoding supported for output encoding."); - } - /* - * Turn on map option. - */ - if (minbytes == 2 && mrec->opt.mapc < 0) { - if (dpx_conf.verbose_level > 0) { - MESG("\n"); - MESG("pdf_font>> Input encoding \"%s\" requires at least 2 bytes.\n", - CMap_get_name(cmap)); - MESG("pdf_font>> The -m <00> option will be assumed for \"%s\".\n", mrec->font_name); - } - /* FIXME: The following code modifies mrec. */ - mrec->opt.mapc = 0; - } - } else if (!strcmp(mrec->enc_name, "unicode")) { - cmap_id = otf_load_Unicode_CMap(mrec->font_name, - mrec->opt.index, mrec->opt.otl_tags, - ((mrec->opt.flags & FONTMAP_OPT_VERT) ? 1 : 0)); - if (cmap_id < 0) { - cmap_id = t1_load_UnicodeCMap(mrec->font_name, mrec->opt.otl_tags, - ((mrec->opt.flags & FONTMAP_OPT_VERT) ? 1 : 0)); - } - if (cmap_id < 0) - ERROR("Failed to read UCS2/UCS4 TrueType cmap..."); + compat_set_mapchar(cmap_id, mrec); } +#endif } if (cmap_id < 0) { encoding_id = pdf_encoding_findresource(mrec->enc_name); - if (encoding_id < 0) - ERROR("Could not find encoding file \"%s\".", mrec->enc_name); } } - if (mrec && cmap_id >= 0) { - /* - * Composite Font - */ - int type0_id, found = 0; - type0_id = Type0Font_cache_find(mrec->font_name, cmap_id, &mrec->opt); - if (type0_id < 0) { + if (mrec && mrec->enc_name) { + if (cmap_id < 0 && encoding_id < 0) { + WARN("Could not read encoding file: %s", mrec->enc_name); return -1; } + } - for (font_id = 0; - font_id < font_cache.count; font_id++) { - font = GET_FONT(font_id); - if (font->subtype == PDF_FONT_FONTTYPE_TYPE0 && - font->font_id == type0_id && - font->encoding_id == cmap_id) { - found = 1; - if (dpx_conf.verbose_level > 0) { - MESG("\npdf_font>> Type0 font \"%s\" (cmap_id=%d) found at font_id=%d.\n", - mrec->font_name, cmap_id, font_id); - } - break; + if (mrec && cmap_id >= 0) { + /* Composite font */ + CMap *cmap; + CIDSysInfo *csi; + int wmode, cid_id; + + cmap = CMap_cache_get(cmap_id); + csi = CMap_is_Identity(cmap) ? NULL : CMap_get_CIDSysInfo(cmap); + wmode = CMap_get_wmode(cmap); + + cid_id = pdf_font_cidfont_lookup_cache(font_cache.fonts, font_cache.count, mrec->font_name, csi, &mrec->opt); + if (cid_id >= 0) { + for (font_id = 0; font_id < font_cache.count; font_id++) { + font = &font_cache.fonts[font_id]; + if (font->subtype != PDF_FONT_FONTTYPE_TYPE0) + continue; + if (font->type0.wmode == wmode && font->type0.descendant == cid_id) { + break; + } } - } - - if (!found) { - font_id = font_cache.count; - if (font_cache.count >= font_cache.capacity) { - font_cache.capacity += CACHE_ALLOC_SIZE; - font_cache.fonts = RENEW(font_cache.fonts, font_cache.capacity, pdf_font); + if (font_id >= 0 && font_id < font_cache.count) { + font = &font_cache.fonts[font_id]; + if (font->encoding_id == cmap_id) { + if (dpx_conf.verbose_level > 0) { + MESG("\npdf_font>> Type0 font \"%s\" cmap_id=<%s,%d> found at font_id=<%s,%d>.\n", + mrec->font_name, mrec->enc_name, cmap_id, pdf_get_font_ident(font_id), font_id); + } + if (!strcmp(ident, font->ident)) { + return font_id; + } else { + return create_font_alias(ident, font_id); + } + } else { + if (dpx_conf.verbose_level > 0) { + MESG("\npdf_font>> Type0 font \"%s\" cmap_id=<%s,%d> found at font_id=<%s,%d>. (re-encoded)\n", + mrec->font_name, mrec->enc_name, cmap_id, pdf_get_font_ident(font_id), font_id); + } + return create_font_reencoded(ident, font_id, cmap_id); + } } - font = GET_FONT(font_id); - pdf_init_font_struct(font); + } - font->font_id = type0_id; - font->subtype = PDF_FONT_FONTTYPE_TYPE0; - font->encoding_id = cmap_id; + /* plus one for CIDFont */ + if (font_cache.count + 1 >= font_cache.capacity) { + font_cache.capacity += CACHE_ALLOC_SIZE; + font_cache.fonts = RENEW(font_cache.fonts, font_cache.capacity, pdf_font); + } - font_cache.count++; + if (cid_id < 0) { + pdf_font *cidfont; - if (dpx_conf.verbose_level > 0) { - MESG("\npdf_font>> Type0 font \"%s\"", fontname); - MESG(" cmap_id=<%s,%d>", mrec->enc_name, font->encoding_id); - MESG(" opened at font_id=<%s,%d>.\n", tex_name, font_id); + cid_id = font_cache.count; + cidfont = &font_cache.fonts[cid_id]; + pdf_init_font_struct(cidfont); + if (pdf_font_open_cidfont(cidfont, fontname, csi, &mrec->opt) < 0) { + pdf_clean_font_struct(cidfont); + return -1; } + font_cache.count++; + } + font_id = font_cache.count; + font = &font_cache.fonts[font_id]; + pdf_init_font_struct(font); + if (pdf_font_open_type0(font, cid_id, wmode) < 0) { + pdf_clean_font_struct(font); + return -1; + } + font->ident = NEW(strlen(ident) + 1, char); + strcpy(font->ident, ident); + font->subtype = PDF_FONT_FONTTYPE_TYPE0; + font->encoding_id = cmap_id; + + font_cache.count++; + if (dpx_conf.verbose_level > 0) { + MESG("\n"); + MESG("pdf_font>> Type0 font \"%s\" ", fontname); + MESG("cmap_id=<%s,%d> ", mrec->enc_name, font->encoding_id); + MESG("font_id=<%s,%d>.", ident, font_id); + MESG("\n"); } } else { - /* - * Simple Font - always embed. - */ - int found = 0; - - for (font_id = 0; - font_id < font_cache.count; font_id++) { - font = GET_FONT(font_id); + /* Simple Font - always embed. */ + for (font_id = 0; font_id < font_cache.count; font_id++) { + font = &font_cache.fonts[font_id]; + if (font->flags & PDF_FONT_FLAG_IS_ALIAS) + continue; switch (font->subtype) { case PDF_FONT_FONTTYPE_TYPE1: case PDF_FONT_FONTTYPE_TYPE1C: case PDF_FONT_FONTTYPE_TRUETYPE: - /* fontname here is font file name. - * We must compare both font file name and encoding - * - * TODO: Embed a font only once if it is used - * with two different encodings - */ - if (!strcmp(fontname, font->ident) && - encoding_id == font->encoding_id) { - if (mrec && mrec->opt.index == font->index) - found = 1; - } - break; + /* fontname here is font file name. + * We must compare both font file name and encoding + * + * TODO: Embed a font only once if it is used + * with two different encodings + */ + if (!strcmp(fontname, font->filename) && encoding_id == font->encoding_id && + (!mrec || mrec->opt.index == font->index)) { + if (dpx_conf.verbose_level > 0) { + MESG("\npdf_font>> Simple font \"%s\" (enc_id=%d) found at id=%d.\n", fontname, encoding_id, font_id); + } + if (!strcmp(ident, font->ident)) { + return font_id; + } else { + return create_font_alias(ident, font_id); + } + } + break; case PDF_FONT_FONTTYPE_TYPE3: - /* There shouldn't be any encoding specified for PK font. - * It must be always font's build-in encoding. - * - * TODO: a PK font with two encodings makes no sense. Change? - */ - if (!strcmp(fontname, font->ident) && - font_scale == font->point_size) { - found = 1; - } - break; - case PDF_FONT_FONTTYPE_TYPE0: - break; - default: - ERROR("Unknown font type: %d", font->subtype); - break; - } - - if (found) { - if (dpx_conf.verbose_level > 0) { - MESG("\npdf_font>> Simple font \"%s\" (enc_id=%d) found at id=%d.\n", - fontname, encoding_id, font_id); - } - break; + /* There shouldn't be any encoding specified for PK font. + * It must be always font's build-in encoding. + * + * TODO: a PK font with two encodings makes no sense. Change? + */ + if (!strcmp(fontname, font->filename) && font_scale == font->point_size) { + if (dpx_conf.verbose_level > 0) { + MESG("\npdf_font>> Simple font \"%s\" (enc_id=%d) found at id=%d.\n", fontname, encoding_id, font_id); + } + if (!strcmp(ident, font->ident)) { + return font_id; + } else { + return create_font_alias(ident, font_id); + } + } + break; } } + font_id = font_cache.count; + if (font_cache.count >= font_cache.capacity) { + font_cache.capacity += CACHE_ALLOC_SIZE; + font_cache.fonts = RENEW(font_cache.fonts, font_cache.capacity, pdf_font); + } - if (!found) { - font_id = font_cache.count; - if (font_cache.count >= font_cache.capacity) { - font_cache.capacity += CACHE_ALLOC_SIZE; - font_cache.fonts = RENEW(font_cache.fonts, font_cache.capacity, pdf_font); - } - - font = GET_FONT(font_id); - - pdf_init_font_struct(font); - - font->point_size = font_scale; - font->encoding_id = encoding_id; - font->ident = NEW(strlen(fontname) + 1, char); - strcpy(font->ident, fontname); - font->map_name = NEW(strlen(tex_name) + 1, char); - strcpy(font->map_name, tex_name); - font->index = (mrec && mrec->opt.index) ? mrec->opt.index : 0; - - if (pdf_font_open_type1(font) >= 0) { - font->subtype = PDF_FONT_FONTTYPE_TYPE1; - } else if (pdf_font_open_type1c(font) >= 0) { - font->subtype = PDF_FONT_FONTTYPE_TYPE1C; - } else if (pdf_font_open_truetype(font) >= 0) { - font->subtype = PDF_FONT_FONTTYPE_TRUETYPE; - } else if (pdf_font_open_pkfont(font) >= 0) { - font->subtype = PDF_FONT_FONTTYPE_TYPE3; - } else { - pdf_clean_font_struct(font); - return -1; - } + font = &font_cache.fonts[font_id]; + pdf_init_font_struct(font); + + font->ident = NEW(strlen(ident) + 1, char); + strcpy(font->ident, ident); + font->encoding_id = encoding_id; + font->filename = NEW(strlen(fontname) + 1, char); + strcpy(font->filename, fontname); + font->index = (mrec && mrec->opt.index) ? mrec->opt.index : 0; + font->flags |= (mrec && (mrec->opt.flags & FONTMAP_OPT_NOEMBED)) ? PDF_FONT_FLAG_NOEMBED : 0; + if (pdf_font_open_type1(font, font->filename, font->index, font->encoding_id, (font->flags & PDF_FONT_FLAG_NOEMBED) ? 0 : 1) >= 0) { + font->subtype = PDF_FONT_FONTTYPE_TYPE1; + } else if (pdf_font_open_type1c(font, font->filename, font->index, font->encoding_id, (font->flags & PDF_FONT_FLAG_NOEMBED) ? 0 : 1) >= 0) { + font->subtype = PDF_FONT_FONTTYPE_TYPE1C; + } else if (pdf_font_open_truetype(font, font->filename, font->index, font->encoding_id, (font->flags & PDF_FONT_FLAG_NOEMBED) ? 0 : 1) >= 0) { + font->subtype = PDF_FONT_FONTTYPE_TRUETYPE; + } else if (pdf_font_open_pkfont(font,font->filename, font->index, font->encoding_id, (font->flags & PDF_FONT_FLAG_NOEMBED) ? 0 : 1, font->point_size) >= 0) { + font->subtype = PDF_FONT_FONTTYPE_TYPE3; + } else { + pdf_clean_font_struct(font); + return -1; + } - font_cache.count++; + font_cache.count++; - if (dpx_conf.verbose_level > 0) { - MESG("\npdf_font>> Simple font \"%s\"", fontname); - MESG(" enc_id=<%s,%d>", - (mrec && mrec->enc_name) ? mrec->enc_name : "builtin", font->encoding_id); - MESG(" opened at font_id=<%s,%d>.\n", tex_name, font_id); - } + if (dpx_conf.verbose_level > 0) { + MESG("\n"); + MESG("pdf_font>> Simple font \"%s\" ", fontname); + MESG("enc_id=<%s,%d> ", (mrec && mrec->enc_name) ? mrec->enc_name : "builtin", font->encoding_id); + MESG("font_id=<%s,%d>.", ident, font_id); + MESG("\n"); } } return font_id; } -int -pdf_font_is_in_use (pdf_font *font) -{ - ASSERT(font); - - return ((font->reference) ? 1 : 0); -} - -uint32_t -pdf_font_get_index (pdf_font *font) -{ - ASSERT(font); - - return font->index; -} - -char * -pdf_font_get_ident (pdf_font *font) -{ - ASSERT(font); - - return font->ident; -} - -char * -pdf_font_get_mapname (pdf_font *font) -{ - ASSERT(font); - - return font->map_name; -} - -char * -pdf_font_get_fontname (pdf_font *font) -{ - ASSERT(font); - - return font->fontname; -} - pdf_obj * pdf_font_get_resource (pdf_font *font) { @@ -834,21 +1024,17 @@ pdf_font_get_resource (pdf_font *font) if (!font->resource) { font->resource = pdf_new_dict(); - pdf_add_dict(font->resource, - pdf_new_name("Type"), pdf_new_name("Font")); + pdf_add_dict(font->resource, pdf_new_name("Type"), pdf_new_name("Font")); switch (font->subtype) { case PDF_FONT_FONTTYPE_TYPE1: case PDF_FONT_FONTTYPE_TYPE1C: - pdf_add_dict(font->resource, - pdf_new_name("Subtype"), pdf_new_name("Type1")); + pdf_add_dict(font->resource, pdf_new_name("Subtype"), pdf_new_name("Type1")); break; case PDF_FONT_FONTTYPE_TYPE3: - pdf_add_dict(font->resource, - pdf_new_name("Subtype"), pdf_new_name("Type3")); + pdf_add_dict(font->resource, pdf_new_name("Subtype"), pdf_new_name("Type3")); break; case PDF_FONT_FONTTYPE_TRUETYPE: - pdf_add_dict(font->resource, - pdf_new_name("Subtype"), pdf_new_name("TrueType")); + pdf_add_dict(font->resource, pdf_new_name("Subtype"), pdf_new_name("TrueType")); break; default: break; @@ -863,70 +1049,16 @@ pdf_font_get_descriptor (pdf_font *font) { ASSERT(font); - if (!font->descriptor) { + if (font->subtype == PDF_FONT_FONTTYPE_TYPE0) { + return NULL; + } else if (!font->descriptor) { font->descriptor = pdf_new_dict(); - pdf_add_dict(font->descriptor, - pdf_new_name("Type"), pdf_new_name("FontDescriptor")); + pdf_add_dict(font->descriptor, pdf_new_name("Type"), pdf_new_name("FontDescriptor")); } return font->descriptor; } -char * -pdf_font_get_usedchars (pdf_font *font) -{ - ASSERT(font); - - return font->usedchars; -} - -int -pdf_font_get_encoding (pdf_font *font) -{ - ASSERT(font); - - return font->encoding_id; -} - -int -pdf_font_get_flag (pdf_font *font, int mask) -{ - ASSERT(font); - - return ((font->flags & mask) ? 1 : 0); -} - -#if 0 -int -pdf_font_get_flags (pdf_font *font) -{ - ASSERT(font); - - return font->flags; -} -#endif /* 0 */ - -double -pdf_font_get_param (pdf_font *font, int param_type) -{ - double param = 0.0; - - ASSERT(font); - - switch (param_type) { - case PDF_FONT_PARAM_DESIGN_SIZE: - param = font->design_size; - break; - case PDF_FONT_PARAM_POINT_SIZE: - param = font->point_size; - break; - default: - break; - } - - return param; -} - char * pdf_font_get_uniqueTag (pdf_font *font) { @@ -939,41 +1071,51 @@ pdf_font_get_uniqueTag (pdf_font *font) return font->uniqueID; } -int -pdf_font_set_fontname (pdf_font *font, const char *fontname) -{ - ASSERT(font && fontname); - - if (strlen(fontname) > PDF_NAME_LEN_MAX) { - ERROR("Unexpected error..."); - return -1; - } - if (font->fontname) { - RELEASE(font->fontname); - } - font->fontname = NEW(strlen(fontname)+1, char); - strcpy(font->fontname, fontname); - - return 0; -} - -int -pdf_font_set_subtype (pdf_font *font, int subtype) -{ - ASSERT(font); - - font->subtype = subtype; +/* + * Please don’t use TFM widths for the /Widths + * entry of the font dictionary. + * + * PDF 32000-1:2008 (p.255) + * + * These widths shall be consistent with the + * actual widths given in the font program. + */ - return 0; -} +#include "tfm.h" int -pdf_font_set_flags (pdf_font *font, int flags) +pdf_check_tfm_widths (const char *ident, double *widths, int firstchar, int lastchar, const char *usedchars) { - ASSERT(font); + int error = 0; + int tfm_id, code, count = 0; + double sum = 0.0; + double tolerance = 1.0; + int override = 0; /* Don't set to 1! */ + + tfm_id = tfm_open(ident, 0); + if (tfm_id < 0) + return 0; + for (code = firstchar; code <= lastchar; code++) { + if (usedchars[code]) { + double width, diff; + + width = 1000. * tfm_get_width(tfm_id, code); + diff = widths[code] - width; + diff = diff < 0 ? -diff : diff; + if (override) { + widths[code] = width; + } else if (diff > tolerance) { + if (dpx_conf.verbose_level > 0) { + WARN("Intolerable difference in glyph width: font=%s, char=%d", ident, code); + WARN("font: %g vs. tfm: %g", widths[code], width); + } + sum += diff; + } + count++; + } + } - font->flags |= flags; + error = sum > 0.5 * count * tolerance ? -1 : 0; - return 0; + return override ? 0 : error; } - diff --git a/Build/source/texk/dvipdfm-x/pdffont.h b/Build/source/texk/dvipdfm-x/pdffont.h index 65ba9d6fda0..7d20f39eb1e 100644 --- a/Build/source/texk/dvipdfm-x/pdffont.h +++ b/Build/source/texk/dvipdfm-x/pdffont.h @@ -33,66 +33,132 @@ #define PDF_FONT_FONTTYPE_TRUETYPE 3 #define PDF_FONT_FONTTYPE_TYPE0 4 +#define PDF_FONT_FONTTYPE_CIDTYPE0 5 +#define PDF_FONT_FONTTYPE_CIDTYPE2 6 extern void pdf_font_set_dpi (int font_dpi); -#define PDF_FONT_FLAG_NOEMBED (1 << 0) -#define PDF_FONT_FLAG_COMPOSITE (1 << 1) -#define PDF_FONT_FLAG_BASEFONT (1 << 2) +#define PDF_FONT_FLAG_NOEMBED (1 << 0) +#define PDF_FONT_FLAG_COMPOSITE (1 << 1) +#define PDF_FONT_FLAG_BASEFONT (1 << 2) +#define PDF_FONT_FLAG_USEDCHAR_SHARED (1 << 3) +#define PDF_FONT_FLAG_IS_ALIAS (1 << 4) +#define PDF_FONT_FLAG_IS_REENCODE (1 << 5) +#define PDF_FONT_FLAG_ACCFONT (1 << 6) +#define PDF_FONT_FLAG_UCSFONT (1 << 7) + +/* FIXME */ +/* Converted from Type 1 */ +#define CIDFONT_FLAG_TYPE1 (1 << 8) +#define CIDFONT_FLAG_TYPE1C (1 << 9) +#define CIDFONT_FLAG_TRUETYPE (1 << 10) #define PDF_FONT_PARAM_DESIGN_SIZE 1 #define PDF_FONT_PARAM_POINT_SIZE 2 +#include "fontmap.h" +#define FONT_STYLE_NONE FONTMAP_STYLE_NONE +#define FONT_STYLE_BOLD FONTMAP_STYLE_BOLD +#define FONT_STYLE_ITALIC FONTMAP_STYLE_ITALIC +#define FONT_STYLE_BOLDITALIC FONTMAP_STYLE_BOLDITALIC + +typedef struct { + char *registry; + char *ordering; + int supplement; +} CIDSysInfo; + +typedef struct +{ + CIDSysInfo csi; + int style; + int embed; + int stemv; +} cid_opt; + +struct pdf_font +{ + char *ident; /* map name */ + int font_id; /* ID of this font */ + int subtype; + + char *filename; + + int encoding_id; /* encoding or CMap */ + + uint32_t index; + char *fontname; + char uniqueID[7]; + + /* + * PDF font resource objects + */ + pdf_obj *reference; + pdf_obj *resource; + pdf_obj *descriptor; + + /* + * Font format specific data + */ + char *usedchars; + int flags; + + /* PK font */ + double point_size; + double design_size; + + /* Type0 font */ + struct { + int descendant; /* Only single descendant is allowed. */ + int wmode; + } type0; + + /* CIDFont */ + struct { + CIDSysInfo csi; /* Character collection */ + cid_opt options; /* Options from map record */ + char *usedchars_v; + } cid; +}; + typedef struct pdf_font pdf_font; /* pdf_open_document() call them. */ extern void pdf_init_fonts (void); extern void pdf_close_fonts (void); -/* font_name is used when mrec is NULL. +/* tex_name is used when mrec is NULL. * font_scale (point size) used by PK font. * It might be necessary if dvipdfmx supports font format with * various optical sizes supported in the future. */ -extern int pdf_font_findresource (const char *font_name, - double font_scale, fontmap_rec *mrec); +extern int pdf_font_findresource (const char *tex_name, double font_scale); +extern int pdf_font_load_font (const char *tex_name, double font_scale, fontmap_rec *mrec); -extern int pdf_get_font_subtype (int font_id); -extern pdf_obj *pdf_get_font_reference (int font_id); -extern char *pdf_get_font_usedchars (int font_id); +extern pdf_font *pdf_get_font_data (int font_id); -#if 0 -extern char *pdf_get_font_fontname (int font_id); /* without unique tag */ -#endif /* 0 */ -extern int pdf_get_font_encoding (int font_id); -extern int pdf_get_font_wmode (int font_id); +extern char *pdf_get_font_ident (int font_id); +extern int pdf_get_font_subtype (int font_id); +extern pdf_obj *pdf_get_font_reference (int font_id); +extern pdf_obj *pdf_get_font_resource (int font_id); +extern char *pdf_get_font_usedchars (int font_id); -/* Each font drivers use the followings. */ -extern int pdf_font_is_in_use (pdf_font *font); +extern int pdf_get_font_encoding (int font_id); +extern int pdf_get_font_wmode (int font_id); -extern char *pdf_font_get_ident (pdf_font *font); -extern char *pdf_font_get_mapname (pdf_font *font); -extern char *pdf_font_get_fontname (pdf_font *font); /* without unique tag */ -extern char *pdf_font_get_uniqueTag (pdf_font *font); +extern int pdf_font_resource_name (int font_id, char *buf); -extern pdf_obj *pdf_font_get_resource (pdf_font *font); -extern pdf_obj *pdf_font_get_descriptor (pdf_font *font); -extern char *pdf_font_get_usedchars (pdf_font *font); -extern int pdf_font_get_encoding (pdf_font *font); +extern char *pdf_font_get_uniqueTag (pdf_font *font); -extern int pdf_font_get_flag (pdf_font *font, int mask); -#if 0 -extern int pdf_font_get_flags (pdf_font *font); -#endif /* 0 */ -extern double pdf_font_get_param (pdf_font *font, int type); +extern pdf_obj *pdf_font_get_resource (pdf_font *font); +extern pdf_obj *pdf_font_get_descriptor (pdf_font *font); -extern uint32_t pdf_font_get_index (pdf_font *font); +extern void pdf_font_make_uniqueTag (char *tag); -extern int pdf_font_set_fontname (pdf_font *font, const char *fontname); -extern int pdf_font_set_flags (pdf_font *font, int flags); -extern int pdf_font_set_subtype (pdf_font *font, int subtype); +#define add_to_used_chars2(b,c) {(b)[(c)/8] |= (1 << (7-((c)%8)));} +#define is_used_char2(b,c) (((b)[(c)/8]) & (1 << (7-((c)%8)))) -extern void pdf_font_make_uniqueTag (char *tag); +extern int pdf_check_tfm_widths (const char *ident, double *widths, int firstchar, int lastchar, const char *usedchars); #endif /* _PDFFONT_H_ */ diff --git a/Build/source/texk/dvipdfm-x/pkfont.c b/Build/source/texk/dvipdfm-x/pkfont.c index 9eb00f28c0c..1e4173bd397 100644 --- a/Build/source/texk/dvipdfm-x/pkfont.c +++ b/Build/source/texk/dvipdfm-x/pkfont.c @@ -98,20 +98,19 @@ dpx_open_pk_font_at (const char *ident, unsigned dpi) int -pdf_font_open_pkfont (pdf_font *font) +pdf_font_open_pkfont (pdf_font *font, const char *ident, int index, int encoding_id, int embedding, double point_size) { - char *ident; - double point_size; - int encoding_id; unsigned dpi; FILE *fp; - ident = pdf_font_get_ident(font); - point_size = pdf_font_get_param(font, PDF_FONT_PARAM_POINT_SIZE); - encoding_id = pdf_font_get_encoding(font); - if (!ident || point_size <= 0.0) return -1; + if (!embedding) { + WARN("Ignoring no-embed option for PK font: %s", ident); + } + if (index != 0) { + WARN("Ignoring font index option for PK font: %s", ident); + } dpi = truedpi(ident, point_size, base_dpi); fp = dpx_open_pk_font_at(ident, dpi); @@ -122,7 +121,8 @@ pdf_font_open_pkfont (pdf_font *font) /* Type 3 fonts doesn't have FontName. * FontFamily is recommended for PDF 1.5. */ - pdf_font_set_fontname(font, ident); + font->fontname = NEW(strlen(ident)+1, char); + strcpy(font->fontname, ident); if (encoding_id >= 0) { pdf_encoding_used_by_type3(encoding_id); @@ -502,15 +502,14 @@ pdf_font_load_pkfont (pdf_font *font) #endif /* ENABLE_GLYPHENC */ int error = 0; - if (!pdf_font_is_in_use(font)) { + if (!font->reference) return 0; - } - ident = pdf_font_get_ident(font); - point_size = pdf_font_get_param(font, PDF_FONT_PARAM_POINT_SIZE); - usedchars = pdf_font_get_usedchars(font); + ident = font->filename; + point_size = font->point_size; + usedchars = font->usedchars; #if ENABLE_GLYPHENC - encoding_id = pdf_font_get_encoding(font); + encoding_id = font->encoding_id; if (encoding_id < 0) enc_vec = NULL; else { diff --git a/Build/source/texk/dvipdfm-x/pkfont.h b/Build/source/texk/dvipdfm-x/pkfont.h index c06929c6565..f65fdfa24e4 100644 --- a/Build/source/texk/dvipdfm-x/pkfont.h +++ b/Build/source/texk/dvipdfm-x/pkfont.h @@ -25,7 +25,7 @@ #include "pdffont.h" -extern int pdf_font_open_pkfont (pdf_font *font); +extern int pdf_font_open_pkfont (pdf_font *font, const char *ident, int index, int encoding_id, int embedding, double point_size); extern int pdf_font_load_pkfont (pdf_font *font); extern void PKFont_set_dpi(int dpi); diff --git a/Build/source/texk/dvipdfm-x/truetype.c b/Build/source/texk/dvipdfm-x/truetype.c index dd10bb6be8a..d9ba0ed6325 100644 --- a/Build/source/texk/dvipdfm-x/truetype.c +++ b/Build/source/texk/dvipdfm-x/truetype.c @@ -51,35 +51,27 @@ #include "truetype.h" -#include "tfm.h" - /* Modifying this has no effect :P */ #ifdef ENABLE_NOEMBED # undef ENABLE_NOEMBED #endif int -pdf_font_open_truetype (pdf_font *font) +pdf_font_open_truetype (pdf_font *font, const char *ident, int index, int encoding_id, int embedding) { - char *ident; - int index, encoding_id; pdf_obj *fontdict, *descriptor; sfnt *sfont; - int embedding = 1; /* Must be embedded. */ FILE *fp = NULL; int length, error = 0; - ASSERT( font ); - - ident = pdf_font_get_ident(font); - index = pdf_font_get_index(font); - - ASSERT( ident ); + ASSERT(font); + ASSERT(ident); fp = DPXFOPEN(ident, DPX_RES_TYPE_TTFONT); if (!fp) { fp = DPXFOPEN(ident, DPX_RES_TYPE_DFONT); - if (!fp) return -1; + if (!fp) + return -1; sfont = dfont_open(fp, index); } else { sfont = sfnt_open(fp); @@ -94,13 +86,17 @@ pdf_font_open_truetype (pdf_font *font) if (sfont->type == SFNT_TYPE_TTC) { ULONG offset; + offset = ttc_read_offset(sfont, index); - if (offset == 0) ERROR("Invalid TTC index in %s.", ident); - error = sfnt_read_table_directory(sfont, offset); + if (offset == 0) { + WARN("Invalid TTC index in %s.", ident); + error = -1; + } else { + error = sfnt_read_table_directory(sfont, offset); + } } else { error = sfnt_read_table_directory(sfont, sfont->offset); } - if (error) { sfnt_close(sfont); if (fp) @@ -111,19 +107,22 @@ pdf_font_open_truetype (pdf_font *font) /* Reading fontdict before checking fonttype conflicts with PKFONT * because pdf_font_get_resource() always makes a dictionary. */ - encoding_id = pdf_font_get_encoding(font); - fontdict = pdf_font_get_resource(font); - descriptor = pdf_font_get_descriptor(font); -#ifdef ENABLE_NOEMBED - embedding = pdf_font_get_flag(font, PDF_FONT_FLAG_NOEMBED) ? 0 : 1; + fontdict = pdf_font_get_resource(font); + descriptor = pdf_font_get_descriptor(font); +#ifndef ENABLE_NOEMBED + if (!embedding) { + WARN("No-embed option not supported for TrueType font: %s", ident); + embedding = 1; + font->flags &= ~PDF_FONT_FLAG_NOEMBED; + } #endif /* ENABLE_NOEMBED */ ASSERT( fontdict && descriptor ); { - char fontname[256]; - int n; - pdf_obj *tmp; + char fontname[256]; + int n; + pdf_obj *tmp; memset(fontname, 0, 256); length = tt_get_ps_fontname(sfont, fontname, 255); @@ -137,30 +136,38 @@ pdf_font_open_truetype (pdf_font *font) memmove(fontname + n, fontname + n + 1, length - n - 1); } } - if (strlen(fontname) == 0) - ERROR("Can't find valid fontname for \"%s\".", ident); - pdf_font_set_fontname(font, fontname); - - tmp = tt_get_fontdesc(sfont, &embedding, -1, 1, fontname); - if (!tmp) { - ERROR("Could not obtain necessary font info."); - sfnt_close(sfont); - if (fp) - DPXFCLOSE(fp); - return -1; + if (strlen(fontname) == 0) { + WARN("Can't find valid fontname for \"%s\".", ident); + error = -1; + } else { + font->fontname = NEW(strlen(fontname)+1, char); + strcpy(font->fontname, fontname); + tmp = tt_get_fontdesc(sfont, &embedding, -1, 1, fontname); + if (!tmp) { + WARN("Could not obtain necessary font info: %s", ident); + error = -1; + } else { + ASSERT(pdf_obj_typeof(tmp) == PDF_DICT); + pdf_merge_dict(descriptor, tmp); + pdf_release_obj(tmp); + } } - ASSERT(pdf_obj_typeof(tmp) == PDF_DICT); - - pdf_merge_dict(descriptor, tmp); - pdf_release_obj(tmp); + } + if (error) { + sfnt_close(sfont); + if (fp) + DPXFCLOSE(fp); + return -1; } if (!embedding) { - if (encoding_id >= 0 && - !pdf_encoding_is_predefined(encoding_id)) { - ERROR("Custom encoding not allowed for non-embedded TrueType font."); - sfnt_close(sfont); - return -1; +#ifndef ENABLE_NOEMBED + WARN("Font file=\"%s\" can't be embedded due to liscence restrictions.", ident); + error = -1; +#else + if (encoding_id >= 0 && !pdf_encoding_is_predefined(encoding_id)) { + WARN("Custom encoding not allowed for non-embedded TrueType font: %s", ident); + error = -1; } else { /* There are basically no guarantee for font substitution * can work with "symblic" fonts. At least all glyphs @@ -170,13 +177,10 @@ pdf_font_open_truetype (pdf_font *font) * only to predefined encodings for this reason. Note that * "builtin" encoding means "MacRoman" here. */ - pdf_obj *tmp; - int flags; + pdf_obj *tmp; + int flags; -#ifndef ENABLE_NOEMBED - ERROR("Font file=\"%s\" can't be embedded due to liscence restrictions.", ident); -#endif /* ENABLE_NOEMBED */ - pdf_font_set_flags(font, PDF_FONT_FLAG_NOEMBED); + font->flags |= PDF_FONT_FLAG_NOEMBED; tmp = pdf_lookup_dict(descriptor, "Flags"); if (tmp && pdf_obj_typeof(tmp) == PDF_NUMBER) { flags = (int) pdf_number_value(tmp); @@ -185,18 +189,22 @@ pdf_font_open_truetype (pdf_font *font) pdf_add_dict(descriptor, pdf_new_name("Flags"), pdf_new_number(flags)); } } +#endif /* ENABLE_NOEMBED */ } sfnt_close(sfont); if (fp) DPXFCLOSE(fp); - pdf_add_dict(fontdict, - pdf_new_name("Type"), pdf_new_name("Font")); - pdf_add_dict(fontdict, - pdf_new_name("Subtype"), pdf_new_name("TrueType")); + if (!error) { + pdf_add_dict(fontdict, + pdf_new_name("Type"), pdf_new_name("Font")); + pdf_add_dict(fontdict, + pdf_new_name("Subtype"), pdf_new_name("TrueType")); + font->subtype = PDF_FONT_FONTTYPE_TRUETYPE; + } - return 0; + return error; } /* @@ -226,14 +234,13 @@ static void do_widths (pdf_font *font, double *widths) { pdf_obj *fontdict; - pdf_obj *tmparray; - int code, firstchar, lastchar, tfm_id; + pdf_obj *array; + int code, firstchar, lastchar; char *usedchars; - fontdict = pdf_font_get_resource (font); - usedchars = pdf_font_get_usedchars (font); + fontdict = font->resource; + usedchars = font->usedchars; - tmparray = pdf_new_array(); for (firstchar = 255, lastchar = 0, code = 0; code < 256; code++) { if (usedchars[code]) { if (code < firstchar) firstchar = code; @@ -242,29 +249,23 @@ do_widths (pdf_font *font, double *widths) } if (firstchar > lastchar) { WARN("No glyphs actually used???"); - pdf_release_obj(tmparray); return; } - tfm_id = tfm_open(pdf_font_get_mapname(font), 0); + + pdf_check_tfm_widths(font->ident, widths, firstchar, lastchar, usedchars); + + array = pdf_new_array(); for (code = firstchar; code <= lastchar; code++) { if (usedchars[code]) { - double width; - if (tfm_id < 0) /* tfm is not found */ - width = widths[code]; - else - width = 1000. * tfm_get_width(tfm_id, code); - pdf_add_array(tmparray, - pdf_new_number(ROUND(width, 0.1))); + pdf_add_array(array, pdf_new_number(ROUND(widths[code], 0.1))); } else { - pdf_add_array(tmparray, pdf_new_number(0.0)); + pdf_add_array(array, pdf_new_number(0.0)); } } - - if (pdf_array_length(tmparray) > 0) { - pdf_add_dict(fontdict, - pdf_new_name("Widths"), pdf_ref_obj(tmparray)); + if (pdf_array_length(array) > 0) { + pdf_add_dict(fontdict, pdf_new_name("Widths"), pdf_ref_obj(array)); } - pdf_release_obj(tmparray); + pdf_release_obj(array); pdf_add_dict(fontdict, pdf_new_name("FirstChar"), pdf_new_number(firstchar)); @@ -327,7 +328,7 @@ do_builtin_encoding (pdf_font *font, const char *usedchars, sfnt *sfont) gid = tt_cmap_lookup(ttcm, code); if (gid == 0) { WARN("Glyph for character code=0x%02x missing in font font-file=\"%s\".", - code, pdf_font_get_ident(font)); + code, font->filename); idx = 0; } else { idx = tt_find_glyph(glyphs, gid); @@ -785,8 +786,7 @@ do_custom_encoding (pdf_font *font, error = setup_glyph_mapper(&gm, sfont); if (error) { - WARN("No post table nor Unicode cmap found in font: %s", - pdf_font_get_ident(font)); + WARN("No post table nor Unicode cmap found in font: %s", font->filename); WARN(">> I can't find glyphs without this!"); return -1; } @@ -811,7 +811,7 @@ do_custom_encoding (pdf_font *font, if (!encoding[code] || !strcmp(encoding[code], ".notdef")) { WARN("Character code=\"0x%02X\" mapped to \".notdef\" glyph used in font font-file=\"%s\"", - code, pdf_font_get_ident(font)); + code, font->filename); WARN(">> Maybe incorrect encoding specified?"); idx = 0; } else { @@ -826,7 +826,7 @@ do_custom_encoding (pdf_font *font, */ if (error) { WARN("Glyph \"%s\" not available in font \"%s\".", - encoding[code], pdf_font_get_ident(font)); + encoding[code], font->filename); } else { if (dpx_conf.verbose_level > 1) MESG("truetype>> Glyph glyph-name=\"%s\" found at glyph-id=\"%u\".\n", encoding[code], gid); @@ -871,21 +871,21 @@ do_custom_encoding (pdf_font *font, int pdf_font_load_truetype (pdf_font *font) { - pdf_obj *descriptor = pdf_font_get_descriptor(font); - char *ident = pdf_font_get_ident(font); - int encoding_id = pdf_font_get_encoding(font); - char *usedchars = pdf_font_get_usedchars(font); + pdf_obj *descriptor = font->descriptor; + char *ident = font->filename; + int encoding_id = font->encoding_id; + char *usedchars = font->usedchars; #ifdef ENABLE_NOEMBED - int embedding = pdf_font_get_flag(font, PDF_FONT_FLAG_NOEMBED) ? 0 : 1; + int embedding = font->flags & PDF_FONT_FLAG_NOEMBED ? 0 : 1; #endif /* ENABLE_NOEMBED */ - int index = pdf_font_get_index(font); + int index = font->index; char **enc_vec; pdf_obj *fontfile; FILE *fp = NULL; sfnt *sfont; int i, error = 0; - if (!pdf_font_is_in_use(font)) + if (!font->reference) return 0; fp = DPXFOPEN(ident, DPX_RES_TYPE_TTFONT); diff --git a/Build/source/texk/dvipdfm-x/truetype.h b/Build/source/texk/dvipdfm-x/truetype.h index 525caa5843d..fa5464c1834 100644 --- a/Build/source/texk/dvipdfm-x/truetype.h +++ b/Build/source/texk/dvipdfm-x/truetype.h @@ -25,7 +25,7 @@ #include "pdffont.h" -extern int pdf_font_open_truetype (pdf_font *font); +extern int pdf_font_open_truetype (pdf_font *font, const char *ident, int index, int encoding_id, int embedding); extern int pdf_font_load_truetype (pdf_font *font); #endif /* _TRUETYPE_H_ */ diff --git a/Build/source/texk/dvipdfm-x/type0.c b/Build/source/texk/dvipdfm-x/type0.c index 29c64bbd375..06699112945 100644 --- a/Build/source/texk/dvipdfm-x/type0.c +++ b/Build/source/texk/dvipdfm-x/type0.c @@ -42,103 +42,14 @@ #include "fontmap.h" #include "cmap.h" +#include "cidtype0.h" #include "cid.h" #include "type0.h" -#define TYPE0FONT_DEBUG_STR "Type0" -#define TYPE0FONT_DEBUG 3 - static pdf_obj *pdf_read_ToUnicode_file (const char *cmap_name); -/* - * used_chars: - * - * Single bit is used for each CIDs since used_chars can be reused as a - * stream content of CIDSet by doing so. See, cid.h for add_to_used() and - * is_used(). - */ - -static char * -new_used_chars2(void) -{ - char *used_chars; - - used_chars = NEW(8192, char); - memset(used_chars, 0, 8192); - - return used_chars; -} - -#define FLAG_NONE 0 -#define FLAG_USED_CHARS_SHARED (1 << 0) - -struct Type0Font { - char *fontname; /* BaseFont */ - char *encoding; /* "Identity-H" or "Identity-V" (not ID) */ - char *used_chars; /* Used chars (CIDs) */ - - /* - * Type0 only - */ - CIDFont *descendant; /* Only single descendant is allowed. */ - int flags; - int wmode; - int cmap_id; - - /* - * PDF Font Resource - */ - pdf_obj *indirect; - pdf_obj *fontdict; - pdf_obj *descriptor; /* MUST BE NULL */ -}; - -static void -Type0Font_init_font_struct (Type0Font *font) -{ - ASSERT(font); - - font->fontname = NULL; - font->fontdict = NULL; - font->indirect = NULL; - font->descriptor = NULL; - font->encoding = NULL; - font->used_chars = NULL; - font->descendant = NULL; - font->wmode = -1; - font->cmap_id = -1; - font->flags = FLAG_NONE; - - return; -} - -static void -Type0Font_clean (Type0Font *font) -{ - if (font) { - if (font->fontdict) - ERROR("%s: Object not flushed.", TYPE0FONT_DEBUG_STR); - if (font->indirect) - ERROR("%s: Object not flushed.", TYPE0FONT_DEBUG_STR); - if (font->descriptor) - ERROR("%s: FontDescriptor unexpected for Type0 font.", TYPE0FONT_DEBUG_STR); - if (!(font->flags & FLAG_USED_CHARS_SHARED) && font->used_chars) - RELEASE(font->used_chars); - if (font->encoding) - RELEASE(font->encoding); - if (font->fontname) - RELEASE(font->fontname); - font->fontdict = NULL; - font->indirect = NULL; - font->descriptor = NULL; - font->used_chars = NULL; - font->encoding = NULL; - font->fontname = NULL; - } -} - /* PLEASE FIX THIS */ #include "tt_cmap.h" @@ -147,7 +58,8 @@ Type0Font_clean (Type0Font *font) * CHANGED: CMap here is not always Unicode to CID mapping. Don't use reverse lookup. */ static pdf_obj * -Type0Font_try_load_ToUnicode_stream(Type0Font *font, char *cmap_base) { +try_load_ToUnicode_file (char *cmap_base) +{ pdf_obj *tounicode; char *cmap_name; @@ -160,22 +72,14 @@ Type0Font_try_load_ToUnicode_stream(Type0Font *font, char *cmap_base) { } RELEASE(cmap_name); - if (!tounicode) { - CIDFont *cidfont = font->descendant; - tounicode = otf_create_ToUnicode_stream(CIDFont_get_ident(cidfont), - CIDFont_get_opt_index(cidfont), - CIDFont_get_fontname(cidfont), - Type0Font_get_usedchars(font)); - } - return tounicode; } static void -Type0Font_attach_ToUnicode_stream (Type0Font *font) +Type0Font_attach_ToUnicode_stream (pdf_font *font) { pdf_obj *tounicode; - CIDFont *cidfont; + pdf_font *cidfont = pdf_get_font_data(font->type0.descendant); CIDSysInfo *csi; char *fontname; @@ -187,12 +91,7 @@ Type0Font_attach_ToUnicode_stream (Type0Font *font) * ordering CID-keyed fonts. External resource must be loaded for * others. */ - - cidfont = font->descendant; - if (!cidfont) { - ERROR("%s: No descendant CID-keyed font.", TYPE0FONT_DEBUG_STR); - return; - } + ASSERT(cidfont); if (CIDFont_is_ACCFont(cidfont)) { /* No need to embed ToUnicode */ @@ -201,58 +100,52 @@ Type0Font_attach_ToUnicode_stream (Type0Font *font) /* * Old version of dvipdfmx mistakenly used Adobe-Identity as Unicode. */ + /* ref returned */ tounicode = pdf_read_ToUnicode_file("Adobe-Identity-UCS2"); if (!tounicode) { /* This should work */ - tounicode = pdf_new_name("Identity-H"); + tounicode = pdf_new_name("Identity-H"); } - pdf_add_dict(font->fontdict, pdf_new_name("ToUnicode"), tounicode); + pdf_add_dict(font->resource, pdf_new_name("ToUnicode"), tounicode); return; } tounicode = NULL; - csi = CIDFont_get_CIDSysInfo(cidfont); - fontname = CIDFont_get_fontname(cidfont); - if (CIDFont_get_embedding(cidfont)) { + csi = &cidfont->cid.csi; + fontname = cidfont->fontname; + if (cidfont->cid.options.embed) { fontname += 7; /* FIXME: Skip pseudo unique tag... */ } - if (!strcmp(csi->registry, "Adobe") && !strcmp(csi->ordering, "Identity")) { - switch (CIDFont_get_subtype(cidfont)) { - case CIDFONT_TYPE2: - /* PLEASE FIX THIS */ - { - tounicode = otf_create_ToUnicode_stream(CIDFont_get_ident(cidfont), - CIDFont_get_opt_index(cidfont), - CIDFont_get_fontname(cidfont), - Type0Font_get_usedchars(font)); - } - break; - default: - if (CIDFont_get_flag(cidfont, CIDFONT_FLAG_TYPE1C)) { - tounicode = otf_create_ToUnicode_stream(CIDFont_get_ident(cidfont), - CIDFont_get_opt_index(cidfont), - CIDFont_get_fontname(cidfont), - Type0Font_get_usedchars(font)); - } else if (CIDFont_get_flag(cidfont, CIDFONT_FLAG_TYPE1)) { - /* FIXME: handled on very different timing. - * Font loader will create ToUnicode and set. - */ - return; - } else { - tounicode = Type0Font_try_load_ToUnicode_stream(font, fontname); + switch (cidfont->subtype) { + case PDF_FONT_FONTTYPE_CIDTYPE2: + if (!strcmp(csi->registry, "Adobe") && !strcmp(csi->ordering, "Identity")) { + tounicode = otf_create_ToUnicode_stream(cidfont->ident, cidfont->index, + cidfont->fontname, font->usedchars); + } else { + char *cmap_base = NEW(strlen(csi->registry) + strlen(csi->ordering) + 2, char); + sprintf(cmap_base, "%s-%s", csi->registry, csi->ordering); + tounicode = try_load_ToUnicode_file(cmap_base); + RELEASE(cmap_base); + /* In this case glyphs are re-ordered hance otf_create... won't work */ + } + break; + default: + if (cidfont->flags & CIDFONT_FLAG_TYPE1C) { + tounicode = otf_create_ToUnicode_stream(cidfont->ident, cidfont->index, + cidfont->fontname, font->usedchars); + } else if (cidfont->flags & CIDFONT_FLAG_TYPE1) { + tounicode = CIDFont_type0_t1create_ToUnicode_stream(cidfont->ident, cidfont->fontname, font->usedchars); + } else { + tounicode = try_load_ToUnicode_file(fontname); + if (!tounicode) { + tounicode = otf_create_ToUnicode_stream(cidfont->ident, cidfont->index, + cidfont->fontname, font->usedchars); } - break; } - } else { - char *cmap_base = NEW(strlen(csi->registry) + strlen(csi->ordering) + 2, char); - sprintf(cmap_base, "%s-%s", csi->registry, csi->ordering); - tounicode = Type0Font_try_load_ToUnicode_stream(font, cmap_base); - RELEASE(cmap_base); } if (tounicode) { - pdf_add_dict(font->fontdict, - pdf_new_name("ToUnicode"), tounicode); + pdf_add_dict(font->resource, pdf_new_name("ToUnicode"), tounicode); } else { #if defined(LIBDPX) if (dpx_conf.verbose_level > 0) @@ -266,215 +159,31 @@ Type0Font_attach_ToUnicode_stream (Type0Font *font) } void -Type0Font_set_ToUnicode (Type0Font *font, pdf_obj *cmap_ref) -{ - ASSERT(font); - - pdf_add_dict(font->fontdict, - pdf_new_name("ToUnicode"), cmap_ref); -} - -static void -Type0Font_dofont (Type0Font *font) +pdf_font_load_type0 (pdf_font *font) { - if (!font || !font->indirect) + if (!font || !font->reference) return; /* FIXME: Should move to pdffont.c */ - if (!pdf_lookup_dict(font->fontdict, "ToUnicode")) { + if (!pdf_lookup_dict(font->resource, "ToUnicode")) { Type0Font_attach_ToUnicode_stream(font); } } -static void -Type0Font_flush (Type0Font *font) -{ - if (font) { - if (font->fontdict) - pdf_release_obj(font->fontdict); - font->fontdict = NULL; - if (font->indirect) - pdf_release_obj(font->indirect); - font->indirect = NULL; - if (font->descriptor) - ERROR("%s: FontDescriptor unexpected for Type0 font.", TYPE0FONT_DEBUG_STR); - font->descriptor = NULL; - } -} - int -Type0Font_get_wmode (Type0Font *font) +pdf_font_open_type0 (pdf_font *font, int cid_id, int wmode) { - ASSERT(font); - - return font->wmode; -} - -#if 0 -char * -Type0Font_get_encoding (Type0Font *font) -{ - ASSERT(font); - - return font->encoding; -} -#endif - -char * -Type0Font_get_usedchars (Type0Font *font) -{ - ASSERT(font); - - return font->used_chars; -} - -pdf_obj * -Type0Font_get_resource (Type0Font *font) -{ - ASSERT(font); - - /* - * This looks somewhat strange. - */ - if (!font->indirect) { - pdf_obj *array; - - array = pdf_new_array(); - pdf_add_array(array, CIDFont_get_resource(font->descendant)); - pdf_add_dict(font->fontdict, pdf_new_name("DescendantFonts"), array); - font->indirect = pdf_ref_obj(font->fontdict); - } - - return pdf_link_obj(font->indirect); -} - -/******************************** CACHE ********************************/ - -#define CHECK_ID(n) do {\ - if ((n) < 0 || (n) >= __cache.count)\ - ERROR("%s: Invalid ID %d", TYPE0FONT_DEBUG_STR, (n));\ -} while (0) - -#define CACHE_ALLOC_SIZE 16u - -static struct font_cache { - int count; - int capacity; - Type0Font *fonts; -} __cache = { - 0, 0, NULL -}; - -void -Type0Font_cache_init (void) -{ - if (__cache.fonts) - ERROR("%s: Already initialized.", TYPE0FONT_DEBUG_STR); - __cache.count = 0; - __cache.capacity = 0; - __cache.fonts = NULL; -} - -Type0Font * -Type0Font_cache_get (int id) -{ - CHECK_ID(id); - - return &__cache.fonts[id]; -} - -int -Type0Font_cache_find (const char *map_name, int cmap_id, fontmap_opt *fmap_opt) -{ - int font_id = -1; - Type0Font *font; - CIDFont *cidfont; - CMap *cmap; + pdf_font *cidfont; CIDSysInfo *csi; char *fontname = NULL; - int cid_id = -1, parent_id = -1, wmode = 0; - - if (!map_name || cmap_id < 0 || pdf_check_version(1, 2) < 0) - return -1; - - /* - * Encoding is Identity-H or Identity-V according as thier WMode value. - * - * We do not use match against the map_name since fonts (TrueType) covers - * characters across multiple character collection (eg, Adobe-Japan1 and - * Adobe-Japan2) must be splited into multiple CID-keyed fonts. - */ - - cmap = CMap_cache_get(cmap_id); - csi = (CMap_is_Identity(cmap)) ? NULL : CMap_get_CIDSysInfo(cmap) ; - - cid_id = CIDFont_cache_find(map_name, csi, fmap_opt); if (cid_id < 0) return -1; - /* - * The descendant CID-keyed font has already been registerd. - * If CID-keyed font with ID = cid_id is new font, then create new parent - * Type 0 font. Otherwise, there already exists parent Type 0 font and - * then we find him and return his ID. We must check against their WMode. - */ - - cidfont = CIDFont_cache_get(cid_id); - wmode = CMap_get_wmode(cmap); - - /* Does CID-keyed font already have parent ? */ - parent_id = CIDFont_get_parent_id(cidfont, wmode); - if (parent_id >= 0) - return parent_id; /* If so, we don't need new one. */ - - /* - * CIDFont does not have parent or his parent's WMode does not matched with - * wmode. Create new Type0 font. - */ - - if (__cache.count >= __cache.capacity) { - __cache.capacity += CACHE_ALLOC_SIZE; - __cache.fonts = RENEW(__cache.fonts, __cache.capacity, struct Type0Font); - } - font_id = __cache.count; - font = &__cache.fonts[font_id]; - - Type0Font_init_font_struct(font); - - /* - * All CJK double-byte characters are mapped so that resulting - * character codes coincide with CIDs of given character collection. - * So, the Encoding is always Identity-H for horizontal fonts or - * Identity-V for vertical fonts. - */ - if (wmode) { - font->encoding = NEW(strlen("Identity-V")+1, char); - strcpy(font->encoding, "Identity-V"); - } else { - font->encoding = NEW(strlen("Identity-H")+1, char); - strcpy(font->encoding, "Identity-H"); - } - font->wmode = wmode; - font->cmap_id = cmap_id; + cidfont = pdf_get_font_data(cid_id); - /* - * Now we start font dictionary. - */ - font->fontdict = pdf_new_dict(); - pdf_add_dict(font->fontdict, pdf_new_name ("Type"), pdf_new_name ("Font")); - pdf_add_dict(font->fontdict, pdf_new_name ("Subtype"), pdf_new_name ("Type0")); - - /* - * Type0 font does not have FontDescriptor because it is not a simple font. - * Instead, DescendantFonts appears here. - * - * Up to PDF version 1.5, Type0 font must have single descendant font which - * is a CID-keyed font. Future PDF spec. will allow multiple desecendant - * fonts. - */ - font->descendant = cidfont; - CIDFont_attach_parent(cidfont, font_id, wmode); + font->type0.wmode = wmode; + font->type0.descendant = cid_id; /* * PostScript Font name: @@ -482,96 +191,48 @@ Type0Font_cache_find (const char *map_name, int cmap_id, fontmap_opt *fmap_opt) * Type0 font's fontname is usually descendant CID-keyed font's font name * appended by -ENCODING. */ - fontname = CIDFont_get_fontname(cidfont); + fontname = cidfont->fontname; if (dpx_conf.verbose_level > 0) { - if (CIDFont_get_embedding(cidfont) && strlen(fontname) > 7) + if (cidfont->cid.options.embed && strlen(fontname) > 7) MESG("(CID:%s)", fontname+7); /* skip XXXXXX+ */ else MESG("(CID:%s)", fontname); } - /* - * The difference between CID-keyed font and TrueType font appears here. - * - * Glyph substitution for vertical writing is done in CMap mapping process - * for CID-keyed fonts. But we must rely on OpenType layout table in the - * case of TrueType fonts. So, we must use different used_chars for each - * horizontal and vertical fonts in that case. - * - * In most PDF file, encoding name is not appended to fontname for Type0 - * fonts having CIDFontType 2 font as their descendant. - */ - - font->used_chars = NULL; - font->flags = FLAG_NONE; - - switch (CIDFont_get_subtype(cidfont)) { - case CIDFONT_TYPE0: - font->fontname = NEW(strlen(fontname)+strlen(font->encoding)+2, char); - sprintf(font->fontname, "%s-%s", fontname, font->encoding); - pdf_add_dict(font->fontdict, - pdf_new_name("BaseFont"), pdf_new_name(font->fontname)); - /* - * Need used_chars to write W, W2. + switch (cidfont->subtype) { + case PDF_FONT_FONTTYPE_CIDTYPE0: + font->fontname = NEW(strlen(fontname)+strlen("Identity-V")+2, char); + sprintf(font->fontname, "%s-%s", fontname, wmode ? "Identity-V" : "Identity-H"); + font->usedchars = CIDFont_get_usedchars(cidfont); + font->flags |= PDF_FONT_FLAG_USEDCHAR_SHARED; + break; + case PDF_FONT_FONTTYPE_CIDTYPE2: + font->fontname = NEW(strlen(fontname)+1, char); + strcpy(font->fontname, fontname); + /* Adobe-Identity here means use GID as CID directly. No need to use GSUB for finding + * vertical glyphs hence separate used_chars for H and V instances are not needed. */ - if ((parent_id = CIDFont_get_parent_id(cidfont, wmode ? 0 : 1)) < 0) { - font->used_chars = new_used_chars2(); + csi = &cidfont->cid.csi; + if (!csi || (!strcmp(csi->registry, "Adobe") && !strcmp(csi->ordering, "Identity"))) { + font->usedchars = CIDFont_get_usedchars(cidfont); + font->flags |= PDF_FONT_FLAG_USEDCHAR_SHARED; } else { - /* Don't allocate new one. */ - font->used_chars = Type0Font_get_usedchars(Type0Font_cache_get(parent_id)); - font->flags |= FLAG_USED_CHARS_SHARED; + font->usedchars = wmode ? CIDFont_get_usedchars_v(cidfont) : CIDFont_get_usedchars(cidfont); + font->flags |= PDF_FONT_FLAG_USEDCHAR_SHARED; } break; - case CIDFONT_TYPE2: - /* - * TrueType: - * - * Use different used_chars for H and V. - */ - pdf_add_dict(font->fontdict, - pdf_new_name("BaseFont"), pdf_new_name(fontname)); - font->used_chars = new_used_chars2(); - break; - default: - ERROR("Unrecognized CIDFont Type"); - break; } - pdf_add_dict(font->fontdict, - pdf_new_name("Encoding"), pdf_new_name(font->encoding)); + font->resource = pdf_new_dict(); + pdf_add_dict(font->resource, pdf_new_name ("Type"), pdf_new_name ("Font")); + pdf_add_dict(font->resource, pdf_new_name ("Subtype"), pdf_new_name ("Type0")); + pdf_add_dict(font->resource, + pdf_new_name("BaseFont"), pdf_new_name(font->fontname)); + pdf_add_dict(font->resource, + pdf_new_name("Encoding"), pdf_new_name(wmode ? "Identity-V" : "Identity-H")); - __cache.count++; - - return font_id; -} - -void -Type0Font_cache_close (void) -{ - int font_id; - - /* - * This need to be fixed. - * - * CIDFont_cache_close() before Type0Font_release because of used_chars. - * ToUnicode support want descendant CIDFont's CSI and fontname. - */ - if (__cache.fonts) { - for (font_id = 0; font_id < __cache.count; font_id++) - Type0Font_dofont(&__cache.fonts[font_id]); - } - CIDFont_cache_close(); - if (__cache.fonts) { - for (font_id = 0; font_id < __cache.count; font_id++) { - Type0Font_flush(&__cache.fonts[font_id]); - Type0Font_clean(&__cache.fonts[font_id]); - } - RELEASE(__cache.fonts); - } - __cache.fonts = NULL; - __cache.count = 0; - __cache.capacity = 0; + return 0; } /******************************** COMPAT ********************************/ diff --git a/Build/source/texk/dvipdfm-x/type0.h b/Build/source/texk/dvipdfm-x/type0.h index 34a47d85c40..330ba532d53 100644 --- a/Build/source/texk/dvipdfm-x/type0.h +++ b/Build/source/texk/dvipdfm-x/type0.h @@ -21,30 +21,9 @@ #ifndef _TYPE0_H_ #define _TYPE0_H_ -#include "pdfobj.h" +#include "pdffont.h" -#define add_to_used_chars2(b,c) {(b)[(c)/8] |= (1 << (7-((c)%8)));} -#define is_used_char2(b,c) (((b)[(c)/8]) & (1 << (7-((c)%8)))) - -typedef struct Type0Font Type0Font; - -extern int Type0Font_get_wmode (Type0Font *font); -#if 0 -extern char *Type0Font_get_encoding (Type0Font *font); -#endif -extern char *Type0Font_get_usedchars (Type0Font *font); - -extern pdf_obj *Type0Font_get_resource (Type0Font *font); - -extern void Type0Font_set_ToUnicode (Type0Font *font, pdf_obj *cmap_ref); - -#include "fontmap.h" - -/******************************** CACHE ********************************/ - -extern void Type0Font_cache_init (void); -extern Type0Font *Type0Font_cache_get (int id); -extern int Type0Font_cache_find (const char *map_name, int cmap_id, fontmap_opt *fmap_opt); -extern void Type0Font_cache_close (void); +extern void pdf_font_load_type0 (pdf_font *font); +extern int pdf_font_open_type0 (pdf_font *font, int cid_id, int wmode); #endif /* _TYPE0_H_ */ diff --git a/Build/source/texk/dvipdfm-x/type1.c b/Build/source/texk/dvipdfm-x/type1.c index 277f4c57d31..525f38bb2f9 100644 --- a/Build/source/texk/dvipdfm-x/type1.c +++ b/Build/source/texk/dvipdfm-x/type1.c @@ -56,8 +56,6 @@ #include "type1.h" -#include "tfm.h" - #define FONT_FLAG_FIXEDPITCH (1 << 0) /* Fixed-width font */ #define FONT_FLAG_SERIF (1 << 1) /* Serif font */ #define FONT_FLAG_SYMBOLIC (1 << 2) /* Symbolic font */ @@ -89,34 +87,42 @@ is_basefont (const char *name) } int -pdf_font_open_type1 (pdf_font *font) +pdf_font_open_type1 (pdf_font *font, const char *ident, int index, int encoding_id, int embedding) { - char *ident; FILE *fp; char fontname[PDF_NAME_LEN_MAX+1]; ASSERT(font); + ASSERT(ident); - ident = pdf_font_get_ident(font); + if (index != 0) { + WARN("Ignoring non-zero font index: %s", ident); + } if (is_basefont(ident)) { - pdf_font_set_fontname(font, ident); - pdf_font_set_subtype (font, PDF_FONT_FONTTYPE_TYPE1); - pdf_font_set_flags (font, - (PDF_FONT_FLAG_NOEMBED|PDF_FONT_FLAG_BASEFONT)); + font->fontname = NEW(strlen(ident)+1, char); + strcpy(font->fontname, ident); + font->subtype = PDF_FONT_FONTTYPE_TYPE1; + font->flags |= PDF_FONT_FLAG_NOEMBED; + font->flags |= PDF_FONT_FLAG_BASEFONT; } else { fp = DPXFOPEN(ident, DPX_RES_TYPE_T1FONT); if (!fp) return -1; + if (!embedding) { + WARN("Ignoring no-embed option for Type1 font: %s", ident); + font->flags &= ~PDF_FONT_FLAG_NOEMBED; + } memset(fontname, 0, PDF_NAME_LEN_MAX+1); if (!is_pfb(fp) || t1_get_fontname(fp, fontname) < 0) { ERROR("Failed to read Type 1 font \"%s\".", ident); } DPXFCLOSE(fp); - pdf_font_set_fontname(font, fontname); - pdf_font_set_subtype (font, PDF_FONT_FONTTYPE_TYPE1); + font->fontname = NEW(strlen(fontname)+1, char); + strcpy(font->fontname, fontname); + font->subtype = PDF_FONT_FONTTYPE_TYPE1; } return 0; @@ -242,7 +248,7 @@ get_font_attr (pdf_font *font, cff_font *cffont) flags |= FONT_FLAG_FIXEDPITCH; } - fontname = pdf_font_get_fontname (font); + fontname = font->fontname; descriptor = pdf_font_get_descriptor(font); if (fontname && !strstr(fontname, "Sans")) { @@ -271,16 +277,17 @@ static void add_metrics (pdf_font *font, cff_font *cffont, char **enc_vec, double *widths, int num_glyphs) { pdf_obj *fontdict, *descriptor; - pdf_obj *tmp_array; + pdf_obj *array; int code, firstchar, lastchar; double val; - int i, tfm_id; + int i; char *usedchars; - double scaling; + double scaling = 1.0; + double norm_widths[256]; fontdict = pdf_font_get_resource (font); descriptor = pdf_font_get_descriptor(font); - usedchars = pdf_font_get_usedchars (font); + usedchars = font->usedchars; /* * The original FontBBox of the font is preserved, instead @@ -296,82 +303,56 @@ add_metrics (pdf_font *font, cff_font *cffont, char **enc_vec, double *widths, i * to the default scaling of 1000:1, not relative to the scaling * given by the font matrix. */ - if (cff_dict_known(cffont->topdict, "FontMatrix")) + if (cff_dict_known(cffont->topdict, "FontMatrix")) { scaling = 1000*cff_dict_get(cffont->topdict, "FontMatrix", 0); - else + } else { scaling = 1; + } - tmp_array = pdf_new_array(); + array = pdf_new_array(); for (i = 0; i < 4; i++) { val = cff_dict_get(cffont->topdict, "FontBBox", i); - pdf_add_array(tmp_array, pdf_new_number(ROUND(val, 1.0))); + pdf_add_array(array, pdf_new_number(ROUND(val, 1.0))); } - pdf_add_dict(descriptor, pdf_new_name("FontBBox"), tmp_array); + pdf_add_dict(descriptor, pdf_new_name("FontBBox"), pdf_link_obj(array)); + pdf_release_obj(array); - tmp_array = pdf_new_array(); + array = pdf_new_array(); if (num_glyphs <= 1) { /* This must be an error. */ firstchar = lastchar = 0; - pdf_add_array(tmp_array, pdf_new_number(0.0)); + pdf_add_array(array, pdf_new_number(0.0)); } else { for (firstchar = 255, lastchar = 0, code = 0; code < 256; code++) { if (usedchars[code]) { if (code < firstchar) firstchar = code; if (code > lastchar) lastchar = code; + norm_widths[code] = scaling * widths[cff_glyph_lookup(cffont, enc_vec[code])]; } } if (firstchar > lastchar) { WARN("No glyphs actually used???"); - pdf_release_obj(tmp_array); + pdf_release_obj(array); return; } -#if !defined(LIBDPX) - /* PLEASE FIX THIS - * It's wrong to use TFM width here... We should warn if TFM width - * and actual glyph width are different. - */ -#endif /* !LIBDPX */ - tfm_id = tfm_open(pdf_font_get_mapname(font), 0); + + pdf_check_tfm_widths(font->ident, norm_widths, firstchar, lastchar, usedchars); + for (code = firstchar; code <= lastchar; code++) { if (usedchars[code]) { - double width; - if (tfm_id < 0) /* tfm is not found */ - width = scaling * widths[cff_glyph_lookup(cffont, enc_vec[code])]; -#if defined(LIBDPX) - else -#else - else { - double diff; -#endif /* LIBDPX */ - width = 1000.0 * tfm_get_width(tfm_id, code); -#if !defined(LIBDPX) - diff = width - - scaling * widths[cff_glyph_lookup(cffont, enc_vec[code])]; - if (fabs(diff) > 1.0) { - WARN("Glyph width mismatch for TFM and font (%s)", - pdf_font_get_mapname(font)); - WARN("TFM: %g vs. Type1 font: %g", - width, widths[cff_glyph_lookup(cffont, enc_vec[code])]); - } - } -#endif /* !LIBDPX */ - pdf_add_array(tmp_array, - pdf_new_number(ROUND(width, 0.1))); + pdf_add_array(array, pdf_new_number(ROUND(norm_widths[code], 0.1))); } else { - pdf_add_array(tmp_array, pdf_new_number(0.0)); + pdf_add_array(array, pdf_new_number(0.0)); } } } - if (pdf_array_length(tmp_array) > 0) { - pdf_add_dict(fontdict, - pdf_new_name("Widths"), pdf_ref_obj(tmp_array)); + if (pdf_array_length(array) > 0) { + pdf_add_dict(fontdict, pdf_new_name("Widths"), pdf_ref_obj(array)); } - pdf_release_obj(tmp_array); + pdf_release_obj(array); - pdf_add_dict(fontdict, - pdf_new_name("FirstChar"), pdf_new_number(firstchar)); - pdf_add_dict(fontdict, - pdf_new_name("LastChar"), pdf_new_number(lastchar)); + pdf_add_dict(fontdict, pdf_new_name("FirstChar"), pdf_new_number(firstchar)); + pdf_add_dict(fontdict, pdf_new_name("LastChar"), pdf_new_number(lastchar)); return; } @@ -528,21 +509,19 @@ pdf_font_load_type1 (pdf_font *font) ASSERT(font); - if (!pdf_font_is_in_use(font)) { + if (!font->reference) return 0; - } - encoding_id = pdf_font_get_encoding (font); - fontdict = pdf_font_get_resource (font); + fontdict = pdf_font_get_resource(font); + encoding_id = font->encoding_id; + usedchars = font->usedchars; + ident = font->filename; + fontname = font->fontname; + uniqueTag = pdf_font_get_uniqueTag(font); - pdf_font_get_descriptor(font); - usedchars = pdf_font_get_usedchars (font); - ident = pdf_font_get_ident (font); - fontname = pdf_font_get_fontname (font); - uniqueTag = pdf_font_get_uniqueTag (font); - if (!usedchars || !ident || !fontname) { - ERROR("Type1: Unexpected error."); - } + ASSERT(usedchars); + ASSERT(ident); + ASSERT(fontname); fp = DPXFOPEN(ident, DPX_RES_TYPE_T1FONT); if (!fp) { diff --git a/Build/source/texk/dvipdfm-x/type1.h b/Build/source/texk/dvipdfm-x/type1.h index 9af389fcc77..112eb3b2489 100644 --- a/Build/source/texk/dvipdfm-x/type1.h +++ b/Build/source/texk/dvipdfm-x/type1.h @@ -25,7 +25,7 @@ #include "pdffont.h" -extern int pdf_font_open_type1 (pdf_font *font); +extern int pdf_font_open_type1 (pdf_font *font, const char *ident, int index, int encoding_id, int embedding); extern int pdf_font_load_type1 (pdf_font *font); #endif /* _TYPE1_H_ */ diff --git a/Build/source/texk/dvipdfm-x/type1c.c b/Build/source/texk/dvipdfm-x/type1c.c index d90d43e7d25..692a56be786 100644 --- a/Build/source/texk/dvipdfm-x/type1c.c +++ b/Build/source/texk/dvipdfm-x/type1c.c @@ -62,44 +62,52 @@ #include "type1c.h" -#include "tfm.h" - int -pdf_font_open_type1c (pdf_font *font) +pdf_font_open_type1c (pdf_font *font, const char *ident, int index, int encoding_id, int embedding) { char *fontname; - char *ident; FILE *fp = NULL; sfnt *sfont; cff_font *cffont; pdf_obj *descriptor, *tmp; - unsigned offset = 0; - int encoding_id, embedding; + ULONG offset = 0; ASSERT(font); - - ident = pdf_font_get_ident (font); - encoding_id = pdf_font_get_encoding(font); + ASSERT(ident); fp = DPXFOPEN(ident, DPX_RES_TYPE_OTFONT); + if (!fp) + fp = DPXFOPEN(ident, DPX_RES_TYPE_TTFONT); if (!fp) return -1; sfont = sfnt_open(fp); - if (!sfont || - sfont->type != SFNT_TYPE_POSTSCRIPT || - sfnt_read_table_directory(sfont, 0) < 0) { - ERROR("Not a CFF/OpenType font (9)?"); + if (!sfont) { + if (fp) + DPXFCLOSE(fp); + return -1; } - offset = sfnt_find_table_pos(sfont, "CFF "); - if (offset < 1) { - ERROR("No \"CFF \" table found; not a CFF/OpenType font (or variable font?) (10)?"); + if (sfont->type == SFNT_TYPE_TTC) { + offset = ttc_read_offset(sfont, index); + } + + if ((sfont->type != SFNT_TYPE_TTC && sfont->type != SFNT_TYPE_POSTSCRIPT) || + sfnt_read_table_directory(sfont, offset) < 0 || + (offset = sfnt_find_table_pos(sfont, "CFF ")) == 0) { + sfnt_close(sfont); + if (fp) + DPXFCLOSE(fp); + return -1; } cffont = cff_open(sfont->stream, offset, 0); if (!cffont) { - ERROR("Could not read CFF font data"); + WARN("Could not read CFF font data: %s", ident); + sfnt_close(sfont); + if (fp) + DPXFCLOSE(fp); + return -1; } if (cffont->flag & FONTTYPE_CIDFONT) { @@ -112,13 +120,22 @@ pdf_font_open_type1c (pdf_font *font) fontname = cff_get_name(cffont); if (!fontname) { - ERROR("No valid FontName found in CFF/OpenType font."); + WARN("No valid FontName found in CFF/OpenType font: %s", ident); + cff_close (cffont); + sfnt_close(sfont); + if (fp) + DPXFCLOSE(fp); + return -1; } - pdf_font_set_fontname(font, fontname); - RELEASE(fontname); + font->fontname = fontname; cff_close(cffont); + if (!embedding) { + WARN("Ignoring no-embed option for Type1C font: %s", ident); + embedding = 1; + font->flags &= ~PDF_FONT_FLAG_NOEMBED; + } /* * Font like AdobePiStd does not have meaningful built-in encoding. * Some software generate CFF/OpenType font with incorrect encoding. @@ -129,9 +146,8 @@ pdf_font_open_type1c (pdf_font *font) WARN("If you find text is not encoded properly in the generated PDF file,"); WARN("please specify appropriate \".enc\" file in your fontmap."); } - pdf_font_set_subtype (font, PDF_FONT_FONTTYPE_TYPE1C); + font->subtype = PDF_FONT_FONTTYPE_TYPE1C; - embedding = pdf_font_get_flag(font, PDF_FONT_FLAG_NOEMBED) ? 0 : 1; descriptor = pdf_font_get_descriptor(font); /* * Create font descriptor from OpenType tables. @@ -145,7 +161,11 @@ pdf_font_open_type1c (pdf_font *font) pdf_merge_dict (descriptor, tmp); /* copy */ pdf_release_obj(tmp); if (!embedding) { /* tt_get_fontdesc may have changed this */ - pdf_font_set_flags(font, PDF_FONT_FLAG_NOEMBED); + WARN("Font embedding disallowed for \"%s\"", ident); + sfnt_close(sfont); + if (fp) + DPXFCLOSE(fp); + return -1; } sfnt_close(sfont); @@ -156,79 +176,63 @@ pdf_font_open_type1c (pdf_font *font) } static void -add_SimpleMetrics (pdf_font *font, cff_font *cffont, - double *widths, card16 num_glyphs) +add_SimpleMetrics (pdf_font *font, cff_font *cffont, double *widths, card16 num_glyphs) { pdf_obj *fontdict; - int code, firstchar, lastchar, tfm_id; + int code, firstchar, lastchar; char *usedchars; - pdf_obj *tmp_array; - double scaling; + pdf_obj *array; + double scaling = 1.0; fontdict = pdf_font_get_resource(font); - usedchars = pdf_font_get_usedchars(font); + usedchars = font->usedchars; /* The widhts array in the font dictionary must be given relative * to the default scaling of 1000:1, not relative to the scaling * given by the font matrix. */ - if (cff_dict_known(cffont->topdict, "FontMatrix")) - scaling = 1000*cff_dict_get(cffont->topdict, "FontMatrix", 0); - else - scaling = 1; + if (cff_dict_known(cffont->topdict, "FontMatrix")) { + scaling = 1000.0 * cff_dict_get(cffont->topdict, "FontMatrix", 0); + } else { + scaling = 1.0; + } - tmp_array = pdf_new_array(); + array = pdf_new_array(); if (num_glyphs <= 1) { /* This should be error. */ firstchar = lastchar = 0; - pdf_add_array(tmp_array, pdf_new_number(0.0)); + pdf_add_array(array, pdf_new_number(0.0)); } else { firstchar = 255; lastchar = 0; for (code = 0; code < 256; code++) { if (usedchars[code]) { - if (code < firstchar) firstchar = code; - if (code > lastchar) lastchar = code; + if (code < firstchar) firstchar = code; + if (code > lastchar) lastchar = code; + widths[code] *= scaling; } } if (firstchar > lastchar) { ERROR("No glyphs used at all!"); - pdf_release_obj(tmp_array); return; } - tfm_id = tfm_open(pdf_font_get_mapname(font), 0); + pdf_check_tfm_widths(font->ident, widths, firstchar, lastchar, usedchars); + for (code = firstchar; code <= lastchar; code++) { if (usedchars[code]) { - double width; - if (tfm_id < 0) /* tfm is not found */ - width = scaling * widths[code]; - else { - double diff; - width = 1000. * tfm_get_width(tfm_id, code); - diff = width - scaling * widths[code]; - if (fabs(diff) > 1.) { - WARN("Glyph width mismatch for TFM and font (%s)", - pdf_font_get_mapname(font)); - WARN("TFM: %g vs. CFF font: %g", width, widths[code]); - } - pdf_add_array(tmp_array, - pdf_new_number(ROUND(width, 0.1))); - } + pdf_add_array(array, pdf_new_number(ROUND(widths[code], 0.1))); } else { - pdf_add_array(tmp_array, pdf_new_number(0.0)); + pdf_add_array(array, pdf_new_number(0.0)); } } } - if (pdf_array_length(tmp_array) > 0) { - pdf_add_dict(fontdict, - pdf_new_name("Widths"), pdf_ref_obj(tmp_array)); + if (pdf_array_length(array) > 0) { + pdf_add_dict(fontdict, pdf_new_name("Widths"), pdf_ref_obj(array)); } - pdf_release_obj(tmp_array); + pdf_release_obj(array); - pdf_add_dict(fontdict, - pdf_new_name("FirstChar"), pdf_new_number(firstchar)); - pdf_add_dict(fontdict, - pdf_new_name("LastChar"), pdf_new_number(lastchar)); + pdf_add_dict(fontdict, pdf_new_name("FirstChar"), pdf_new_number(firstchar)); + pdf_add_dict(fontdict, pdf_new_name("LastChar"), pdf_new_number(lastchar)); return; } @@ -261,26 +265,25 @@ pdf_font_load_type1c (pdf_font *font) ASSERT(font); - if (!pdf_font_is_in_use(font)) { + if (!font->reference) return 0; - } - if (pdf_font_get_flag(font, PDF_FONT_FLAG_NOEMBED)) { + if (font->flags & PDF_FONT_FLAG_NOEMBED) { ERROR("Only embedded font supported for CFF/OpenType font."); } - usedchars = pdf_font_get_usedchars (font); - fontname = pdf_font_get_fontname (font); - ident = pdf_font_get_ident (font); + usedchars = font->usedchars; + fontname = font->fontname; + ident = font->filename; uniqueTag = pdf_font_get_uniqueTag (font); - if (!usedchars || - !fontname || !ident) { - ERROR("Unexpected error...."); - } + + ASSERT(usedchars); + ASSERT(fontname); + ASSERT(ident); fontdict = pdf_font_get_resource (font); descriptor = pdf_font_get_descriptor(font); - encoding_id = pdf_font_get_encoding (font); + encoding_id = font->encoding_id; fp = DPXFOPEN(ident, DPX_RES_TYPE_OTFONT); if (!fp) { @@ -341,23 +344,21 @@ pdf_font_load_type1c (pdf_font *font) enc_vec = NEW(256, char *); for (code = 0; code < 256; code++) { if (usedchars[code]) { - card16 gid; - - gid = cff_encoding_lookup(cffont, code); - enc_vec[code] = cff_get_string(cffont, - cff_charsets_lookup_inverse(cffont, gid)); + card16 gid; + + gid = cff_encoding_lookup(cffont, code); + enc_vec[code] = cff_get_string(cffont, cff_charsets_lookup_inverse(cffont, gid)); } else { - enc_vec[code] = NULL; + enc_vec[code] = NULL; } } if (!pdf_lookup_dict(fontdict, "ToUnicode")) { - tounicode = pdf_create_ToUnicode_CMap(fullname, - enc_vec, usedchars); + tounicode = pdf_create_ToUnicode_CMap(fullname, enc_vec, usedchars); if (tounicode) { - pdf_add_dict(fontdict, + pdf_add_dict(fontdict, pdf_new_name("ToUnicode"), pdf_ref_obj (tounicode)); - pdf_release_obj(tounicode); + pdf_release_obj(tounicode); } } } @@ -409,8 +410,7 @@ pdf_font_load_type1c (pdf_font *font) double stemv; stemv = cff_dict_get(cffont->private[0], "StdVW", 0); - pdf_add_dict(descriptor, - pdf_new_name("StemV"), pdf_new_number(stemv)); + pdf_add_dict(descriptor, pdf_new_name("StemV"), pdf_new_number(stemv)); } /* diff --git a/Build/source/texk/dvipdfm-x/type1c.h b/Build/source/texk/dvipdfm-x/type1c.h index dd2ac00f04d..bf81149e7cb 100644 --- a/Build/source/texk/dvipdfm-x/type1c.h +++ b/Build/source/texk/dvipdfm-x/type1c.h @@ -25,7 +25,7 @@ #include "pdffont.h" -extern int pdf_font_open_type1c (pdf_font *font); +extern int pdf_font_open_type1c (pdf_font *font, const char *ident, int index, int encoding_id, int embedding); extern int pdf_font_load_type1c (pdf_font *font); #endif /* _TYPE1C_H_ */ -- cgit v1.2.3