static int
pdf_make_group_dict(gx_device_pdf * pdev, const gs_pdf14trans_params_t * pparams,
const gs_imager_state * pis, cos_dict_t **pdict)
{
pdf_resource_t *pres_group;
cos_dict_t *group_dict;
int code;
const gs_state *gstate = gx_hld_get_gstate_ptr(pis);
cos_value_t cs_value;
code = pdf_alloc_resource(pdev, resourceGroup, gs_no_id, &pres_group, -1);
if (code < 0)
return code;
cos_become(pres_group->object, cos_type_dict);
group_dict = (cos_dict_t *)pres_group->object;
code = cos_dict_put_c_key_string(group_dict, "/Type", (const byte *)"/Group", 6);
if (code < 0)
return code;
code = cos_dict_put_c_key_string(group_dict, "/S", (const byte *)"/Transparency", 13);
if (code < 0)
return code;
if (pparams->Isolated) {
code = cos_dict_put_c_key_bool(group_dict, "/I", true);
if (code < 0)
return code;
}
if (pparams->Knockout) {
code = cos_dict_put_c_key_bool(group_dict, "/K", true);
if (code < 0)
return code;
}
if (gstate != NULL) {
const gs_color_space *cs = gstate->color_space;
code = pdf_color_space_named(pdev, &cs_value, NULL, cs,
&pdf_color_space_names, false, NULL, 0);
if (code < 0)
return code;
code = cos_dict_put_c_key(group_dict, "/CS", &cs_value);
if (code < 0)
return code;
}
group_dict = NULL; /* The next line invalidates it. */
code = pdf_substitute_resource(pdev, &pres_group, resourceGroup, NULL, false);
if (code < 0)
return code;
*pdict = (cos_dict_t *)pres_group->object;
return 0;
}
static int
pdf_end_transparency_mask(gs_imager_state * pis, gx_device_pdf * pdev,
const gs_pdf14trans_params_t * pparams)
{
if (pdev->image_mask_skip)
pdev->image_mask_skip = false;
else {
pdf_resource_t *pres = pdev->accumulating_substream_resource;
int code;
char buf[20];
code = pdf_exit_substream(pdev);
if (code < 0)
return code;
code = pdf_substitute_resource(pdev, &pres, resourceXObject, NULL, false);
if (code < 0)
return 0;
/* We need to update the 'where_used' field, in case we substituted a resource */
pres->where_used |= pdev->used_mask;
sprintf(buf, "%ld 0 R", pdf_resource_id(pres));
code = cos_dict_put_c_key_string((cos_dict_t *)pdev->pres_soft_mask_dict->object,
"/G", (const byte *)buf, strlen(buf));
if (code < 0)
return code;
code = pdf_substitute_resource(pdev, &pdev->pres_soft_mask_dict,
resourceSoftMaskDict, NULL, false);
if (code < 0)
return code;
pis->soft_mask_id = pdev->pres_soft_mask_dict->object->id;
pdev->pres_soft_mask_dict = NULL;
}
return 0;
}
static int
pdf_make_soft_mask_dict(gx_device_pdf * pdev, const gs_pdf14trans_params_t * pparams)
{
pdf_resource_t *pres_soft_mask_dict = 0;
cos_dict_t *soft_mask_dict;
int code;
/* Fixme : merge redundant objects. */
code = pdf_alloc_resource(pdev, resourceSoftMaskDict, gs_no_id, &pres_soft_mask_dict, -1);
if (code < 0)
return code;
cos_become(pres_soft_mask_dict->object, cos_type_dict);
pdev->pres_soft_mask_dict = pres_soft_mask_dict;
soft_mask_dict = (cos_dict_t *)pres_soft_mask_dict->object;
code = cos_dict_put_c_key_string(soft_mask_dict, "/S",
pparams->subtype == TRANSPARENCY_MASK_Alpha ? (byte *)"/Alpha" : (byte *)"/Luminosity",
pparams->subtype == TRANSPARENCY_MASK_Alpha ? 6 : 11);
if (code < 0)
return code;
if (pparams->Background_components) {
cos_array_t *Background;
Background = cos_array_from_floats(pdev, pparams->Background,
pparams->Background_components, "pdf_write_soft_mask_dict");
if (Background == NULL)
return_error(gs_error_VMerror);
code = cos_dict_put_c_key_object(soft_mask_dict, "/BC", (cos_object_t *)Background);
if (code < 0)
return code;
}
if (pparams->transfer_function != NULL) {
long id;
char buf[20];
code = pdf_write_function(pdev, pparams->transfer_function, &id);
if (code < 0)
return code;
sprintf(buf, " %ld 0 R", id);
code = cos_dict_put_c_key_string(soft_mask_dict, "/TR", (const byte *)buf, strlen(buf));
if (code < 0)
return code;
}
return 0;
}
static int
pdf_make_form_dict(gx_device_pdf * pdev, const gs_pdf14trans_params_t * pparams,
const gs_imager_state * pis,
const cos_dict_t *group_dict, cos_dict_t *form_dict)
{
cos_array_t *bbox_array;
float bbox[4];
gs_rect bbox_rect;
int code;
code = gs_bbox_transform(&pparams->bbox, &ctm_only(pis), &bbox_rect);
if (code < 0)
return code;
bbox[0] = bbox_rect.p.x;
bbox[1] = bbox_rect.p.y;
bbox[2] = bbox_rect.q.x;
bbox[3] = bbox_rect.q.y;
code = cos_dict_put_c_key_string(form_dict, "/Type", (const byte *)"/XObject", 8);
if (code < 0)
return code;
code = cos_dict_put_c_key_string(form_dict, "/Subtype", (const byte *)"/Form", 5);
if (code < 0)
return code;
code = cos_dict_put_c_key_int(form_dict, "/FormType", 1);
if (code < 0)
return code;
code = cos_dict_put_c_key_string(form_dict, "/Matrix", (const byte *)"[1 0 0 1 0 0]", 13);
if (code < 0)
return code;
bbox_array = cos_array_from_floats(pdev, bbox, 4, "pdf_begin_transparency_group");
if (bbox_array == NULL)
return_error(gs_error_VMerror);
code = cos_dict_put_c_key_object(form_dict, "/BBox", (cos_object_t *)bbox_array);
if (code < 0)
return code;
return cos_dict_put_c_key_object(form_dict, "/Group", (cos_object_t *)group_dict);
}
static int
pdf_dsc_process(gx_device_pdf * pdev, const gs_param_string_array * pma)
{
/*
* The Adobe "Distiller Parameters" documentation says that Distiller
* looks at DSC comments, but it doesn't say which ones. We look at
* the ones that we see how to map directly to obvious PDF constructs.
*/
int code = 0;
uint i;
/*
* If ParseDSCComments is false, all DSC comments are ignored, even if
* ParseDSCComentsForDocInfo or PreserveEPSInfo is true.
*/
if (!pdev->ParseDSCComments)
return 0;
for (i = 0; i + 1 < pma->size && code >= 0; i += 2) {
const gs_param_string *pkey = &pma->data[i];
const gs_param_string *pvalue = &pma->data[i + 1];
const char *key;
int code;
/*
* %%For, %%Creator, and %%Title are recognized only if either
* ParseDSCCommentsForDocInfo or PreserveEPSInfo is true.
* The other DSC comments are always recognized.
*
* Acrobat Distiller sets CreationDate and ModDate to the current
* time, not the value of %%CreationDate. We think this is wrong,
* but we do the same -- we ignore %%CreationDate here.
*/
if (pdf_key_eq(pkey, "Creator"))
key = "/Creator";
else if (pdf_key_eq(pkey, "Title"))
key = "/Title";
else if (pdf_key_eq(pkey, "For"))
key = "/Author";
else {
pdf_page_dsc_info_t *ppdi;
char scan_buf[200]; /* arbitrary */
if ((ppdi = &pdev->doc_dsc_info,
pdf_key_eq(pkey, "Orientation")) ||
(ppdi = &pdev->page_dsc_info,
pdf_key_eq(pkey, "PageOrientation"))
) {
if (pvalue->size == 1 && pvalue->data[0] >= '0' &&
pvalue->data[0] <= '3'
)
ppdi->orientation = pvalue->data[0] - '0';
else
ppdi->orientation = -1;
} else if ((ppdi = &pdev->doc_dsc_info,
pdf_key_eq(pkey, "ViewingOrientation")) ||
(ppdi = &pdev->page_dsc_info,
pdf_key_eq(pkey, "PageViewingOrientation"))
) {
gs_matrix mat;
int orient;
if(pvalue->size >= sizeof(scan_buf) - 1)
continue; /* error */
memcpy(scan_buf, pvalue->data, pvalue->size);
scan_buf[pvalue->size] = 0;
if (sscanf(scan_buf, "[%g %g %g %g]",
&mat.xx, &mat.xy, &mat.yx, &mat.yy) != 4
)
continue; /* error */
for (orient = 0; orient < 4; ++orient) {
if (mat.xx == 1 && mat.xy == 0 && mat.yx == 0 && mat.yy == 1)
break;
gs_matrix_rotate(&mat, -90.0, &mat);
}
if (orient == 4) /* error */
orient = -1;
ppdi->viewing_orientation = orient;
} else {
gs_rect box;
if (pdf_key_eq(pkey, "EPSF")) {
pdev->is_EPS = (pvalue->size >= 1 && pvalue->data[0] != '0');
continue;
}
/*
* We only parse the BoundingBox for the sake of
* AutoPositionEPSFiles.
*/
if (pdf_key_eq(pkey, "BoundingBox"))
ppdi = &pdev->doc_dsc_info;
else if (pdf_key_eq(pkey, "PageBoundingBox"))
ppdi = &pdev->page_dsc_info;
else
continue;
if(pvalue->size >= sizeof(scan_buf) - 1)
continue; /* error */
memcpy(scan_buf, pvalue->data, pvalue->size);
scan_buf[pvalue->size] = 0;
if (sscanf(scan_buf, "[%lg %lg %lg %lg]",
&box.p.x, &box.p.y, &box.q.x, &box.q.y) != 4
)
continue; /* error */
ppdi->bounding_box = box;
}
continue;
}
if (pdev->ParseDSCCommentsForDocInfo || pdev->PreserveEPSInfo)
code = cos_dict_put_c_key_string(pdev->Info, key,
pvalue->data, pvalue->size);
}
return code;
}
