static int
concat_stream (pdf_obj *dst, pdf_obj *src)
{
const char *stream_data;
long stream_length;
pdf_obj *stream_dict;
pdf_obj *filter;
if (!PDF_OBJ_STREAMTYPE(dst) || !PDF_OBJ_STREAMTYPE(src))
ERROR("Invalid type.");
stream_data = pdf_stream_dataptr(src);
stream_length = pdf_stream_length (src);
stream_dict = pdf_stream_dict (src);
if (pdf_lookup_dict(stream_dict, "DecodeParms")) {
WARN("DecodeParams not supported.");
return -1;
}
filter = pdf_lookup_dict(stream_dict, "Filter");
if (!filter) {
pdf_add_stream(dst, stream_data, stream_length);
return 0;
#if HAVE_ZLIB
} else {
char *filter_name;
if (PDF_OBJ_NAMETYPE(filter)) {
filter_name = pdf_name_value(filter);
if (filter_name && !strcmp(filter_name, "FlateDecode"))
return add_stream_flate(dst, stream_data, stream_length);
else {
WARN("DecodeFilter \"%s\" not supported.", filter_name);
return -1;
}
} else if (PDF_OBJ_ARRAYTYPE(filter)) {
if (pdf_array_length(filter) > 1) {
WARN("Multiple DecodeFilter not supported.");
return -1;
} else {
filter_name = pdf_name_value(pdf_get_array(filter, 0));
if (filter_name && !strcmp(filter_name, "FlateDecode"))
return add_stream_flate(dst, stream_data, stream_length);
else {
WARN("DecodeFilter \"%s\" not supported.", filter_name);
return -1;
}
}
} else
ERROR("Broken PDF file?");
#endif /* HAVE_ZLIB */
}
return -1;
}
static int
CIDFont_base_open (CIDFont *font, const char *name, CIDSysInfo *cmap_csi, cid_opt *opt)
{
pdf_obj *fontdict, *descriptor;
char *fontname = NULL;
int idx;
ASSERT(font);
for (idx = 0; cid_basefont[idx].fontname != NULL; idx++) {
if (!strcmp(name, cid_basefont[idx].fontname) ||
(strlen(name) == strlen(cid_basefont[idx].fontname) - strlen("-Acro") &&
!strncmp(name, cid_basefont[idx].fontname,
strlen(cid_basefont[idx].fontname)-strlen("-Acro")))
)
break;
}
if (cid_basefont[idx].fontname == NULL)
return -1;
fontname = NEW(strlen(name)+12, char);
memset(fontname, 0, strlen(name)+12);
strcpy(fontname, name);
switch (opt->style) {
case FONT_STYLE_BOLD:
strcat(fontname, ",Bold");
break;
case FONT_STYLE_ITALIC:
strcat(fontname, ",Italic");
break;
case FONT_STYLE_BOLDITALIC:
strcat(fontname, ",BoldItalic");
break;
}
{
const char *start;
const char *end;
start = cid_basefont[idx].fontdict;
end = start + strlen(start);
fontdict = parse_pdf_dict(&start, end, NULL);
start = cid_basefont[idx].descriptor;
end = start + strlen(start);
descriptor = parse_pdf_dict(&start, end, NULL);
ASSERT(fontdict && descriptor);
}
font->fontname = fontname;
font->flags |= FONT_FLAG_BASEFONT;
{
char *registry, *ordering;
int supplement;
pdf_obj *tmp;
tmp = pdf_lookup_dict(fontdict, "CIDSystemInfo");
ASSERT( tmp && pdf_obj_typeof(tmp) == PDF_DICT );
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;
}
{
pdf_obj *tmp;
char *type;
tmp = pdf_lookup_dict(fontdict, "Subtype");
ASSERT( tmp != NULL && pdf_obj_typeof(tmp) == PDF_NAME );
type = pdf_name_value(tmp);
if (!strcmp(type, "CIDFontType0"))
font->subtype = CIDFONT_TYPE0;
else if (!strcmp(type, "CIDFontType2"))
font->subtype = CIDFONT_TYPE2;
else {
ERROR("Unknown CIDFontType \"%s\"", type);
}
}
if (cidoptflags & CIDFONT_FORCE_FIXEDPITCH) {
if (pdf_lookup_dict(fontdict, "W")) {
pdf_remove_dict(fontdict, "W");
}
if (pdf_lookup_dict(fontdict, "W2")) {
pdf_remove_dict(fontdict, "W2");
}
}
pdf_add_dict(fontdict, pdf_new_name("Type"), pdf_new_name("Font"));
pdf_add_dict(fontdict, pdf_new_name("BaseFont"), pdf_new_name(fontname));
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->descriptor = descriptor;
opt->embed = 0;
return 0;
}
static int
load_encoding_file (const char *filename)
{
FILE *fp;
pdf_obj *enc_name = NULL;
pdf_obj *encoding_array = NULL;
char *wbuf;
const char *p, *endptr;
const char *enc_vec[256];
int code, fsize, enc_id;
if (!filename)
return -1;
if (dpx_conf.verbose_level > 0) {
MESG("(Encoding:%s", filename);
}
fp = DPXFOPEN(filename, DPX_RES_TYPE_ENC);
if (!fp)
return -1;
/*
* file_size do seek_end witout saving current position and
* do rewind.
*/
fsize = file_size(fp);
wbuf = NEW(fsize + 1, char);
wbuf[fsize] = '\0';
fread(wbuf, sizeof(char), fsize, fp);
DPXFCLOSE(fp);
p = wbuf;
endptr = wbuf + fsize;
skip_white(&p, endptr);
/*
* Skip comment lines.
*/
while (p < endptr && p[0] == '%') {
pdfparse_skip_line (&p, endptr);
skip_white(&p, endptr);
}
if (p[0] == '/')
enc_name = parse_pdf_name(&p, endptr);
skip_white(&p, endptr);
encoding_array = parse_pdf_array(&p, endptr, NULL);
RELEASE(wbuf);
if (!encoding_array) {
if (enc_name)
pdf_release_obj(enc_name);
return -1;
}
for (code = 0; code < 256; code++) {
enc_vec[code] = pdf_name_value(pdf_get_array(encoding_array, code));
}
enc_id = pdf_encoding_new_encoding(enc_name ? pdf_name_value(enc_name) : NULL,
filename, enc_vec, NULL, 0);
if (enc_name) {
if (dpx_conf.verbose_level > 1)
MESG("[%s]", pdf_name_value(enc_name));
pdf_release_obj(enc_name);
}
pdf_release_obj(encoding_array);
if (dpx_conf.verbose_level > 0) MESG(")");
return enc_id;
}
