static void
xps_load_sfnt_cmap(xps_font_t *font)
{
byte *cmapdata;
int offset, length;
int nsubtables;
offset = xps_find_sfnt_table(font, "cmap", &length);
if (offset < 0 || length < 4)
{
gs_warn("cannot find cmap table");
return;
}
cmapdata = font->data + offset;
nsubtables = u16(cmapdata + 2);
if (nsubtables < 0 || length < 4 + nsubtables * 8)
{
gs_warn("cannot find cmap sub-tables");
return;
}
font->cmaptable = offset;
font->cmapsubcount = nsubtables;
font->cmapsubtable = 0;
}
static int
gx_concretize_ICC(
const gs_client_color * pcc,
const gs_color_space * pcs,
frac * pconc,
const gs_gstate * pgs,
gx_device *dev)
{
gsicc_link_t *icc_link;
gsicc_rendering_param_t rendering_params;
unsigned short psrc[GS_CLIENT_COLOR_MAX_COMPONENTS], psrc_cm[GS_CLIENT_COLOR_MAX_COMPONENTS];
int k;
unsigned short *psrc_temp;
int num_des_comps;
int code;
cmm_dev_profile_t *dev_profile;
code = dev_proc(dev, get_profile)(dev, &dev_profile);
if (code < 0)
return code;
num_des_comps = gsicc_get_device_profile_comps(dev_profile);
/* Define the rendering intents. */
rendering_params.black_point_comp = pgs->blackptcomp;
rendering_params.graphics_type_tag = dev->graphics_type_tag;
rendering_params.override_icc = false;
rendering_params.preserve_black = gsBKPRESNOTSPECIFIED;
rendering_params.rendering_intent = pgs->renderingintent;
rendering_params.cmm = gsCMM_DEFAULT;
for (k = 0; k < pcs->cmm_icc_profile_data->num_comps; k++) {
psrc[k] = (unsigned short) (pcc->paint.values[k]*65535.0);
}
/* Get a link from the cache, or create if it is not there. Get 16 bit profile */
icc_link = gsicc_get_link(pgs, dev, pcs, NULL, &rendering_params, pgs->memory);
if (icc_link == NULL) {
#ifdef DEBUG
gs_warn("Could not create ICC link: Check profiles");
#endif
return -1;
}
/* Transform the color */
if (icc_link->is_identity) {
psrc_temp = &(psrc[0]);
} else {
/* Transform the color */
psrc_temp = &(psrc_cm[0]);
(icc_link->procs.map_color)(dev, icc_link, psrc, psrc_temp, 2);
}
/* This needs to be optimized */
for (k = 0; k < num_des_comps; k++){
pconc[k] = float2frac(((float) psrc_temp[k])/65535.0);
}
/* Release the link */
gsicc_release_link(icc_link);
return 0;
}
void
xps_bounds_in_user_space(xps_context_t *ctx, gs_rect *ubox)
{
gx_clip_path *clip_path;
gs_rect dbox;
int code;
code = gx_effective_clip_path(ctx->pgs, &clip_path);
if (code < 0)
gs_warn("gx_effective_clip_path failed");
dbox.p.x = fixed2float(clip_path->outer_box.p.x);
dbox.p.y = fixed2float(clip_path->outer_box.p.y);
dbox.q.x = fixed2float(clip_path->outer_box.q.x);
dbox.q.y = fixed2float(clip_path->outer_box.q.y);
gs_bbox_transform_inverse(&dbox, &ctm_only(ctx->pgs), ubox);
}
int
xps_find_sfnt_table(xps_font_t *font, const char *name, int *lengthp)
{
int offset;
int ntables;
int i;
if (font->length < 12)
return -1;
if (!memcmp(font->data, "ttcf", 4))
{
int nfonts = u32(font->data + 8);
if (font->subfontid < 0 || font->subfontid >= nfonts)
{
gs_warn("Invalid subfont ID");
return -1;
}
offset = u32(font->data + 12 + font->subfontid * 4);
}
else
{
offset = 0;
}
ntables = u16(font->data + offset + 4);
if (font->length < offset + 12 + ntables * 16)
return -1;
for (i = 0; i < ntables; i++)
{
byte *entry = font->data + offset + 12 + i * 16;
if (!memcmp(entry, name, 4))
{
if (lengthp)
*lengthp = u32(entry + 12);
return u32(entry + 8);
}
}
return -1;
}
/*
* Custom Paper Width/Length
* from Windows Driver "HP Universal Printing PCL 5" (.GPD files) and
* http://www.office.xerox.com/support/dctips/dc10cc0471.pdf
*
* ESC & f <decipoints> I
*
*/
static int
set_paper_width(pcl_args_t * pargs, pcl_state_t * pcs)
{
uint decipoints = uint_arg(pargs);
bool found = false;
int i;
pcl_paper_size_t *psize;
for (i = 0; i < pcl_paper_type_count; i++) {
if (101 == PAPER_SIZES[i].tag) {
psize = &(PAPER_SIZES[i].psize);
found = true;
break;
}
}
if (found)
psize->width = decipoints * 10L;
else
gs_warn("Page table does not contain a custom entry");
return 0;
}
void
xps_measure_font_glyph(xps_context_t *ctx, xps_font_t *font, int gid, xps_glyph_metrics_t *mtx)
{
int head, format, loca, glyf;
int ofs, len;
int idx, i, n;
int hadv, vadv, vorg;
int vtop, ymax, desc;
int scale;
/* some insane defaults */
scale = 1000; /* units-per-em */
hadv = 500;
vadv = -1000;
vorg = 1000;
/*
* Horizontal metrics are easy.
*/
ofs = xps_find_sfnt_table(font, "hhea", &len);
if (ofs < 0 || len < 2 * 18)
{
gs_warn("hhea table is too short");
return;
}
vorg = s16(font->data + ofs + 4); /* ascender is default vorg */
desc = s16(font->data + ofs + 6); /* descender */
if (desc < 0)
desc = -desc;
n = u16(font->data + ofs + 17 * 2);
ofs = xps_find_sfnt_table(font, "hmtx", &len);
if (ofs < 0)
{
gs_warn("cannot find hmtx table");
return;
}
idx = gid;
if (idx > n - 1)
idx = n - 1;
hadv = u16(font->data + ofs + idx * 4);
vadv = 0;
/*
* Vertical metrics are hairy (with missing tables).
*/
head = xps_find_sfnt_table(font, "head", &len);
if (head > 0)
{
scale = u16(font->data + head + 18); /* units per em */
}
ofs = xps_find_sfnt_table(font, "OS/2", &len);
if (ofs > 0 && len > 70)
{
vorg = s16(font->data + ofs + 68); /* sTypoAscender */
desc = s16(font->data + ofs + 70); /* sTypoDescender */
if (desc < 0)
desc = -desc;
}
ofs = xps_find_sfnt_table(font, "vhea", &len);
if (ofs > 0 && len >= 2 * 18)
{
n = u16(font->data + ofs + 17 * 2);
ofs = xps_find_sfnt_table(font, "vmtx", &len);
if (ofs < 0)
{
gs_warn("cannot find vmtx table");
return;
}
idx = gid;
if (idx > n - 1)
idx = n - 1;
vadv = u16(font->data + ofs + idx * 4);
vtop = u16(font->data + ofs + idx * 4 + 2);
glyf = xps_find_sfnt_table(font, "glyf", &len);
loca = xps_find_sfnt_table(font, "loca", &len);
if (head > 0 && glyf > 0 && loca > 0)
{
format = u16(font->data + head + 50); /* indexToLocaFormat */
if (format == 0)
ofs = u16(font->data + loca + gid * 2) * 2;
else
ofs = u32(font->data + loca + gid * 4);
ymax = u16(font->data + glyf + ofs + 8); /* yMax */
vorg = ymax + vtop;
}
}
ofs = xps_find_sfnt_table(font, "VORG", &len);
if (ofs > 0)
{
vorg = u16(font->data + ofs + 6);
n = u16(font->data + ofs + 6);
for (i = 0; i < n; i++)
{
if (u16(font->data + ofs + 8 + 4 * i) == gid)
{
vorg = s16(font->data + ofs + 8 + 4 * i + 2);
break;
}
}
}
if (vadv == 0)
vadv = vorg + desc;
mtx->hadv = hadv / (float) scale;
mtx->vadv = vadv / (float) scale;
mtx->vorg = vorg / (float) scale;
}
/*
* Get the windows truetype font file name - position 4 in the name table.
*/
void
xps_load_sfnt_name(xps_font_t *font, char *namep)
{
byte *namedata;
int offset, length;
int format, count, stringoffset;
int found;
int i, k;
found = 0;
strcpy(namep, "Unknown");
offset = xps_find_sfnt_table(font, "name", &length);
if (offset < 0 || length < 6)
{
gs_warn("cannot find name table");
return;
}
namedata = font->data + offset;
format = u16(namedata + 0);
count = u16(namedata + 2);
stringoffset = u16(namedata + 4);
if (length < 6 + (count * 12))
{
gs_warn("name table too short");
return;
}
for (i = 0; i < count; i++)
{
byte *record = namedata + 6 + i * 12;
int pid = u16(record + 0);
int eid = u16(record + 2);
int langid = u16(record + 4);
int nameid = u16(record + 6);
length = u16(record + 8);
offset = u16(record + 10);
/* Full font name or postscript name */
if (nameid == 4 || nameid == 6)
{
if (pid == 1 && eid == 0 && langid == 0) /* mac roman, english */
{
if (found < 3)
{
memcpy(namep, namedata + stringoffset + offset, length);
namep[length] = 0;
found = 3;
}
}
if (pid == 3 && eid == 1 && langid == 0x409) /* windows unicode ucs-2, US */
{
if (found < 2)
{
unsigned char *s = namedata + stringoffset + offset;
int n = length / 2;
for (k = 0; k < n; k ++)
{
int c = u16(s + k * 2);
namep[k] = isprint(c) ? c : '?';
}
namep[k] = 0;
found = 2;
}
}
if (pid == 3 && eid == 10 && langid == 0x409) /* windows unicode ucs-4, US */
{
if (found < 1)
{
unsigned char *s = namedata + stringoffset + offset;
int n = length / 4;
for (k = 0; k < n; k ++)
{
int c = u32(s + k * 4);
namep[k] = isprint(c) ? c : '?';
}
namep[k] = 0;
found = 1;
}
}
}
}
}
/* This only determines if we have an alpha value */
int
xps_png_has_alpha(xps_context_t *ctx, byte *rbuf, int rlen)
{
png_structp png;
png_infop info;
struct xps_png_io_s io;
int has_alpha;
/*
* Set up PNG structs and input source
*/
io.ptr = rbuf;
io.lim = rbuf + rlen;
png = png_create_read_struct_2(PNG_LIBPNG_VER_STRING,
NULL, NULL, NULL,
ctx->memory, xps_png_malloc, xps_png_free);
if (!png) {
gs_warn("png_create_read_struct");
return 0;
}
info = png_create_info_struct(png);
if (!info) {
gs_warn("png_create_info_struct");
return 0;
}
png_set_read_fn(png, &io, xps_png_read);
png_set_crc_action(png, PNG_CRC_WARN_USE, PNG_CRC_WARN_USE);
/*
* Jump to here on errors.
*/
if (setjmp(png_jmpbuf(png)))
{
png_destroy_read_struct(&png, &info, NULL);
gs_warn("png reading failed");
return 0;
}
/*
* Read PNG header
*/
png_read_info(png, info);
switch (png_get_color_type(png, info))
{
case PNG_COLOR_TYPE_PALETTE:
case PNG_COLOR_TYPE_GRAY:
case PNG_COLOR_TYPE_RGB:
has_alpha = 0;
break;
case PNG_COLOR_TYPE_GRAY_ALPHA:
case PNG_COLOR_TYPE_RGB_ALPHA:
has_alpha = 1;
break;
default:
gs_warn("cannot handle this png color type");
has_alpha = 0;
break;
}
/*
* Clean up memory.
*/
png_destroy_read_struct(&png, &info, NULL);
return has_alpha;
}
/*
* Same as above, but there is no rescale of CIELAB colors. This is needed
since the rescale is not needed when the source data is image based.
The DeviceN image rendering case uses the remap proc vs. the ICC based method
which handles the remapping itself.
*/
int
gx_remap_ICC_imagelab(const gs_client_color * pcc, const gs_color_space * pcs,
gx_device_color * pdc, const gs_gstate * pgs, gx_device * dev,
gs_color_select_t select)
{
gsicc_link_t *icc_link;
gsicc_rendering_param_t rendering_params;
unsigned short psrc[GS_CLIENT_COLOR_MAX_COMPONENTS], psrc_cm[GS_CLIENT_COLOR_MAX_COMPONENTS];
unsigned short *psrc_temp;
frac conc[GS_CLIENT_COLOR_MAX_COMPONENTS];
int k,i;
int num_des_comps;
int code;
cmm_dev_profile_t *dev_profile;
code = dev_proc(dev, get_profile)(dev, &dev_profile);
if (code < 0)
return code;
num_des_comps = gsicc_get_device_profile_comps(dev_profile);
rendering_params.black_point_comp = pgs->blackptcomp;
rendering_params.graphics_type_tag = dev->graphics_type_tag;
rendering_params.override_icc = false;
rendering_params.preserve_black = gsBKPRESNOTSPECIFIED;
rendering_params.rendering_intent = pgs->renderingintent;
rendering_params.cmm = gsCMM_DEFAULT;
/* Need to clear out psrc_cm in case we have separation bands that are
not color managed */
memset(psrc_cm, 0, sizeof(unsigned short)*GS_CLIENT_COLOR_MAX_COMPONENTS);
for (k = 0; k < pcs->cmm_icc_profile_data->num_comps; k++)
psrc[k] = (unsigned short) (pcc->paint.values[k]*65535.0);
/* Get a link from the cache, or create if it is not there. Need to get 16 bit profile */
icc_link = gsicc_get_link(pgs, dev, pcs, NULL, &rendering_params, pgs->memory);
if (icc_link == NULL) {
#ifdef DEBUG
gs_warn("Could not create ICC link: Check profiles");
#endif
return -1;
}
if (icc_link->is_identity) {
psrc_temp = &(psrc[0]);
} else {
/* Transform the color */
psrc_temp = &(psrc_cm[0]);
(icc_link->procs.map_color)(dev, icc_link, psrc, psrc_temp, 2);
}
/* Release the link */
gsicc_release_link(icc_link);
/* Now do the remap for ICC which amounts to the alpha application
the transfer function and potentially the halftoning */
/* Right now we need to go from unsigned short to frac. I really
would like to avoid this sort of stuff. That will come. */
for ( k = 0; k < num_des_comps; k++){
conc[k] = ushort2frac(psrc_temp[k]);
}
gx_remap_concrete_ICC(conc, pcs, pdc, pgs, dev, select);
/* Save original color space and color info into dev color */
i = pcs->cmm_icc_profile_data->num_comps;
for (i--; i >= 0; i--)
pdc->ccolor.paint.values[i] = pcc->paint.values[i];
pdc->ccolor_valid = true;
return 0;
}
static xps_item_t *
xps_process_compatibility(xps_context_t *ctx, xps_item_t *root)
{
gs_warn("XPS document uses markup compatibility tags");
return root;
}
int
xps_parse_tiling_brush(xps_context_t *ctx, char *base_uri, xps_resource_t *dict, xps_item_t *root,
int (*func)(xps_context_t*, char*, xps_resource_t*, xps_item_t*, void*), void *user)
{
xps_item_t *node;
int code;
char *opacity_att;
char *transform_att;
char *viewbox_att;
char *viewport_att;
char *tile_mode_att;
/*char *viewbox_units_att;*/
/*char *viewport_units_att;*/
xps_item_t *transform_tag = NULL;
gs_matrix transform;
gs_rect viewbox;
gs_rect viewport;
float scalex, scaley;
int tile_mode;
opacity_att = xps_att(root, "Opacity");
transform_att = xps_att(root, "Transform");
viewbox_att = xps_att(root, "Viewbox");
viewport_att = xps_att(root, "Viewport");
tile_mode_att = xps_att(root, "TileMode");
/*viewbox_units_att = xps_att(root, "ViewboxUnits");*/
/*viewport_units_att = xps_att(root, "ViewportUnits");*/
for (node = xps_down(root); node; node = xps_next(node))
{
if (!strcmp(xps_tag(node), "ImageBrush.Transform"))
transform_tag = xps_down(node);
if (!strcmp(xps_tag(node), "VisualBrush.Transform"))
transform_tag = xps_down(node);
}
xps_resolve_resource_reference(ctx, dict, &transform_att, &transform_tag, NULL);
gs_make_identity(&transform);
if (transform_att)
xps_parse_render_transform(ctx, transform_att, &transform);
if (transform_tag)
xps_parse_matrix_transform(ctx, transform_tag, &transform);
viewbox.p.x = 0.0; viewbox.p.y = 0.0;
viewbox.q.x = 1.0; viewbox.q.y = 1.0;
if (viewbox_att)
xps_parse_rectangle(ctx, viewbox_att, &viewbox);
viewport.p.x = 0.0; viewport.p.y = 0.0;
viewport.q.x = 1.0; viewport.q.y = 1.0;
if (viewport_att)
xps_parse_rectangle(ctx, viewport_att, &viewport);
/* some sanity checks on the viewport/viewbox size */
if (fabs(viewport.q.x - viewport.p.x) < 0.01) { gs_warn("skipping tile with zero width view port"); return 0; }
if (fabs(viewport.q.y - viewport.p.y) < 0.01) { gs_warn("skipping tile with zero height view port"); return 0; }
if (fabs(viewbox.q.x - viewbox.p.x) < 0.01) { gs_warn("skipping tile with zero width view box"); return 0; }
if (fabs(viewbox.q.y - viewbox.p.y) < 0.01) { gs_warn("skipping tile with zero height view box"); return 0; }
scalex = (viewport.q.x - viewport.p.x) / (viewbox.q.x - viewbox.p.x);
scaley = (viewport.q.y - viewport.p.y) / (viewbox.q.y - viewbox.p.y);
tile_mode = TILE_NONE;
if (tile_mode_att)
{
if (!strcmp(tile_mode_att, "None"))
tile_mode = TILE_NONE;
if (!strcmp(tile_mode_att, "Tile"))
tile_mode = TILE_TILE;
if (!strcmp(tile_mode_att, "FlipX"))
tile_mode = TILE_FLIP_X;
if (!strcmp(tile_mode_att, "FlipY"))
tile_mode = TILE_FLIP_Y;
if (!strcmp(tile_mode_att, "FlipXY"))
tile_mode = TILE_FLIP_X_Y;
}
gs_gsave(ctx->pgs);
code = xps_begin_opacity(ctx, base_uri, dict, opacity_att, NULL, false, false);
if (code)
{
gs_grestore(ctx->pgs);
return gs_rethrow(code, "cannot create transparency group");
}
/* TODO(tor): check viewport and tiling to see if we can set it to TILE_NONE */
if (tile_mode != TILE_NONE)
{
struct tile_closure_s closure;
gs_client_pattern gspat;
gs_client_color gscolor;
gs_color_space *cs;
bool sa;
closure.ctx = ctx;
closure.base_uri = base_uri;
closure.dict = dict;
closure.tag = root;
closure.tile_mode = tile_mode;
closure.user = user;
closure.func = func;
closure.viewbox.p.x = viewbox.p.x;
closure.viewbox.p.y = viewbox.p.y;
closure.viewbox.q.x = viewbox.q.x;
closure.viewbox.q.y = viewbox.q.y;
gs_pattern1_init(&gspat);
uid_set_UniqueID(&gspat.uid, gs_next_ids(ctx->memory, 1));
gspat.PaintType = 1;
gspat.TilingType = 2;
gspat.PaintProc = xps_remap_pattern;
gspat.client_data = &closure;
/* We need to know if this tiling brush includes transparency.
We could do a proper scan, but for now we'll be lazy and just look
at the flag from scanning the page. */
gspat.uses_transparency = ctx->has_transparency;
gspat.XStep = viewbox.q.x - viewbox.p.x;
gspat.YStep = viewbox.q.y - viewbox.p.y;
gspat.BBox.p.x = viewbox.p.x;
gspat.BBox.p.y = viewbox.p.y;
gspat.BBox.q.x = viewbox.q.x;
gspat.BBox.q.y = viewbox.q.y;
if (tile_mode == TILE_FLIP_X || tile_mode == TILE_FLIP_X_Y)
{
gspat.BBox.q.x += gspat.XStep;
gspat.XStep *= 2;
}
if (tile_mode == TILE_FLIP_Y || tile_mode == TILE_FLIP_X_Y)
{
gspat.BBox.q.y += gspat.YStep;
gspat.YStep *= 2;
}
gs_matrix_translate(&transform, viewport.p.x, viewport.p.y, &transform);
gs_matrix_scale(&transform, scalex, scaley, &transform);
gs_matrix_translate(&transform, -viewbox.p.x, -viewbox.p.y, &transform);
cs = ctx->srgb;
gs_setcolorspace(ctx->pgs, cs);
gsicc_profile_reference(cs->cmm_icc_profile_data, 1);
sa = gs_currentstrokeadjust(ctx->pgs);
gs_setstrokeadjust(ctx->pgs, false);
gs_makepattern(&gscolor, &gspat, &transform, ctx->pgs, NULL);
gs_setpattern(ctx->pgs, &gscolor);
xps_fill(ctx);
gs_setstrokeadjust(ctx->pgs, sa);
gsicc_profile_reference(cs->cmm_icc_profile_data, -1);
/* gs_makepattern increments the pattern count stored in the color
* structure. We will discard the color struct (its on the stack)
* so we need to decrement the reference before we throw away
* the structure.
*/
gs_pattern_reference(&gscolor, -1);
}
else
{
xps_clip(ctx);
gs_concat(ctx->pgs, &transform);
gs_translate(ctx->pgs, viewport.p.x, viewport.p.y);
gs_scale(ctx->pgs, scalex, scaley);
gs_translate(ctx->pgs, -viewbox.p.x, -viewbox.p.y);
gs_moveto(ctx->pgs, viewbox.p.x, viewbox.p.y);
gs_lineto(ctx->pgs, viewbox.p.x, viewbox.q.y);
gs_lineto(ctx->pgs, viewbox.q.x, viewbox.q.y);
gs_lineto(ctx->pgs, viewbox.q.x, viewbox.p.y);
gs_closepath(ctx->pgs);
gs_clip(ctx->pgs);
gs_newpath(ctx->pgs);
code = func(ctx, base_uri, dict, root, user);
if (code < 0)
{
xps_end_opacity(ctx, base_uri, dict, opacity_att, NULL);
gs_grestore(ctx->pgs);
return gs_rethrow(code, "cannot draw tile");
}
}
xps_end_opacity(ctx, base_uri, dict, opacity_att, NULL);
gs_grestore(ctx->pgs);
return 0;
}
