/* Return 0 if present, 1 if absent, or an error code. */
int
param_read_password(gs_param_list * plist, const char *kstr, password * ppass)
{
gs_param_string ps;
long ipass;
int code;
ps.data = (const byte *)ppass->data, ps.size = ppass->size,
ps.persistent = false;
code = param_read_string(plist, kstr, &ps);
switch (code) {
case 0: /* OK */
if (ps.size > MAX_PASSWORD)
return_error(e_limitcheck);
/* Copy the data back. */
memcpy(ppass->data, ps.data, ps.size);
ppass->size = ps.size;
return 0;
case 1: /* key is missing */
return 1;
}
/* We might have gotten a typecheck because */
/* the supplied password was an integer. */
if (code != e_typecheck)
return code;
code = param_read_long(plist, kstr, &ipass);
if (code != 0) /* error or missing */
return code;
sprintf((char *)ppass->data, "%ld", ipass);
ppass->size = strlen((char *)ppass->data);
return 0;
}
static int
mac_put_params(gx_device *dev, gs_param_list *plist)
{
gx_device_macos *mdev = (gx_device_macos *)dev;
int isOpen = mdev->is_open;
int code;
int depth;
gs_param_string outputFile;
// Get the BitsPerPixel Parameter
code = param_read_int(plist, "BitsPerPixel", &depth);
if (!code) {
code = mac_set_colordepth(dev, depth);
if (code)
param_return_error(plist, "BitsPerPixel", gs_error_rangecheck);
}
// Get OutputFile
code = param_read_string(plist, "OutputFile", &outputFile);
if (code < 0) {
param_signal_error(plist, "OutputFile", code);
return code;
} else if (code == 0) {
if (dev->LockSafetyParams &&
bytes_compare(outputFile.data, outputFile.size,
(const byte *)mdev->outputFileName, strlen(mdev->outputFileName))) {
param_signal_error(plist, "OutputFile", gs_error_invalidaccess);
return gs_error_invalidaccess;
}
if (outputFile.size > (gp_file_name_sizeof - 1)) {
param_signal_error(plist, "OutputFile", gs_error_limitcheck);
return gs_error_limitcheck;
}
/* If filename changed, close file. */
if (outputFile.data != 0 &&
bytes_compare(outputFile.data, outputFile.size,
(const byte *)mdev->outputFileName, strlen(mdev->outputFileName))) {
/* Close the file if it's open. */
if (mdev->outputFile != NULL) {
gx_device_close_output_file(dev, mdev->outputFileName, mdev->outputFile);
memcpy(mdev->outputFileName, outputFile.data, outputFile.size);
mdev->outputFileName[outputFile.size] = 0;
gx_device_open_output_file(dev, mdev->outputFileName, true, true, &(mdev->outputFile));
} else {
memcpy(mdev->outputFileName, outputFile.data, outputFile.size);
mdev->outputFileName[outputFile.size] = 0;
}
}
}
// Get the Default Parameters
mdev->is_open = 0;
code = gx_default_put_params( dev, plist );
mdev->is_open = isOpen;
return code;
}
/* We don't attempt to back out if anything fails. */
static int
setparams(i_ctx_t *i_ctx_p, gs_param_list * plist, const param_set * pset)
{
int code;
unsigned int i;
for (i = 0; i < pset->long_count; i++) {
const long_param_def_t *pdef = &pset->long_defs[i];
long val;
if (pdef->set == NULL)
continue;
code = param_read_long(plist, pdef->pname, &val);
switch (code) {
default: /* invalid */
return code;
case 1: /* missing */
break;
case 0:
if (val < pdef->min_value || val > pdef->max_value)
return_error(gs_error_rangecheck);
code = (*pdef->set)(i_ctx_p, val);
if (code < 0)
return code;
}
}
for (i = 0; i < pset->bool_count; i++) {
const bool_param_def_t *pdef = &pset->bool_defs[i];
bool val;
if (pdef->set == NULL)
continue;
code = param_read_bool(plist, pdef->pname, &val);
if (code == 0)
code = (*pdef->set)(i_ctx_p, val);
if (code < 0)
return code;
}
for (i = 0; i < pset->string_count; i++) {
const string_param_def_t *pdef = &pset->string_defs[i];
gs_param_string val;
if (pdef->set == NULL)
continue;
code = param_read_string(plist, pdef->pname, &val);
switch (code) {
default: /* invalid */
return code;
case 1: /* missing */
break;
case 0:
code = (*pdef->set)(i_ctx_p, &val);
if (code < 0)
return code;
}
}
return 0;
}
/* before the device is opened */
int
os2prn_put_params(gx_device * dev, gs_param_list * plist)
{
int ecode = 0, code;
int old_bpp = dev->color_info.depth;
int bpp = old_bpp;
gs_param_string qs;
/* Handle extra parameters */
switch (code = param_read_string(plist, "OS2QUEUE", &qs)) {
case 0:
if (qs.size == strlen(opdev->queue_name) &&
!memcmp(opdev->queue_name, qs.data, qs.size)
) {
qs.data = 0;
break;
}
if (dev->is_open)
ecode = gs_error_rangecheck;
else if (qs.size >= sizeof(opdev->queue_name))
ecode = gs_error_limitcheck;
else
break;
goto qe;
default:
ecode = code;
qe:param_signal_error(plist, "OS2QUEUE", ecode);
case 1:
qs.data = 0;
break;
}
switch (code = param_read_int(plist, "BitsPerPixel", &bpp)) {
case 0:
if (dev->is_open)
ecode = gs_error_rangecheck;
else { /* change dev->color_info is valid before device is opened */
os2prn_set_bpp(dev, bpp);
break;
}
goto bppe;
default:
ecode = code;
bppe:param_signal_error(plist, "BitsPerPixel", ecode);
case 1:
break;
}
if (ecode >= 0)
ecode = gdev_prn_put_params(dev, plist);
if ((ecode >= 0) && (qs.data != 0)) {
memcpy(opdev->queue_name, qs.data, qs.size);
opdev->queue_name[qs.size] = 0;
}
return ecode;
}
static bool
pl_read_device_CRD(gs_cie_render *pcrd, gs_state *pgs)
{
gx_device * pdev = gs_currentdevice(pgs);
gs_c_param_list list;
gs_param_string dstring;
char nbuff[64]; /* ample size */
int code = 0;
/*get the CRDName parameter from the device */
gs_c_param_list_write(&list, gs_state_memory(pgs));
if (param_request((gs_param_list *)&list, "CRDName") < 0)
return false;
if ((code = gs_getdeviceparams(pdev, (gs_param_list *)&list)) >= 0) {
gs_c_param_list_read(&list);
if ( (code = param_read_string( (gs_param_list *)&list,
"CRDName",
&dstring
)) == 0 ) {
if (dstring.size > sizeof(nbuff) - 1)
code = 1;
else {
strncpy(nbuff, (char *)dstring.data, dstring.size);
nbuff[dstring.size] = '\0';
}
}
}
gs_c_param_list_release(&list);
if (code != 0)
return false;
gs_c_param_list_write(&list, gs_state_memory(pgs));
if (param_request((gs_param_list *)&list, nbuff) < 0)
return false;
if ((code = gs_getdeviceparams(pdev, (gs_param_list *)&list)) >= 0) {
gs_param_dict dict;
gs_c_param_list_read(&list);
if ( (code = param_begin_read_dict( (gs_param_list *)&list,
nbuff,
&dict,
false
)) == 0 ) {
code = param_get_cie_render1(pcrd, dict.list, pdev);
param_end_read_dict((gs_param_list *)&list, nbuff, &dict);
if (code > 0)
code = 0;
}
}
gs_c_param_list_release(&list);
return (code == 0);
}
/* Put parameters. */
static int
cgm_put_params(gx_device * dev, gs_param_list * plist)
{
gx_device_cgm *cdev = (gx_device_cgm *) dev;
int ecode = 0;
int code;
const char *param_name;
gs_param_string ofs;
switch (code = param_read_string(plist, (param_name = "OutputFile"), &ofs)) {
case 0:
if (dev->LockSafetyParams &&
bytes_compare(ofs.data, ofs.size,
(const byte *)cdev->fname, strlen(cdev->fname))) {
ecode = gs_note_error(gs_error_invalidaccess);
goto ofe;
}
if (ofs.size >= gp_file_name_sizeof)
ecode = gs_error_limitcheck;
else
break;
goto ofe;
default:
ecode = code;
ofe:param_signal_error(plist, param_name, ecode);
case 1:
ofs.data = 0;
break;
}
if (ecode < 0)
return ecode;
code = gx_default_put_params(dev, plist);
if (code < 0)
return code;
if (ofs.data != 0) { /* Close the file if it's open. */
if (cdev->file != 0) {
fclose(cdev->file);
cdev->file = 0;
}
memcpy(cdev->fname, ofs.data, ofs.size);
cdev->fname[ofs.size] = 0;
cdev->file = fopen(cdev->fname, "wb");
if (cdev->file == 0)
return_error(gs_error_ioerror);
}
return 0;
}
/* Put parameters, implementation */
static int
gdev_pdf_put_params_impl(gx_device * dev, const gx_device_pdf * save_dev, gs_param_list * plist)
{
int ecode, code;
gx_device_pdf *pdev = (gx_device_pdf *) dev;
float cl = (float)pdev->CompatibilityLevel;
bool locked = pdev->params.LockDistillerParams;
gs_param_name param_name;
enum psdf_color_conversion_strategy save_ccs = pdev->params.ColorConversionStrategy;
pdev->pdf_memory = gs_memory_stable(pdev->memory);
/*
* If this is a pseudo-parameter (pdfmark or DSC),
* don't bother checking for any real ones.
*/
{
gs_param_string_array ppa;
code = param_read_string_array(plist, (param_name = "pdfmark"), &ppa);
switch (code) {
case 0:
code = pdf_open_document(pdev);
if (code < 0)
return code;
code = pdfmark_process(pdev, &ppa);
if (code >= 0)
return code;
/* falls through for errors */
default:
param_signal_error(plist, param_name, code);
return code;
case 1:
break;
}
code = param_read_string_array(plist, (param_name = "DSC"), &ppa);
switch (code) {
case 0:
code = pdf_open_document(pdev);
if (code < 0)
return code;
code = pdf_dsc_process(pdev, &ppa);
if (code >= 0)
return code;
/* falls through for errors */
default:
param_signal_error(plist, param_name, code);
return code;
case 1:
break;
}
}
/*
* Check for LockDistillerParams before doing anything else.
* If LockDistillerParams is true and is not being set to false,
* ignore all resettings of PDF-specific parameters. Note that
* LockDistillerParams is read again, and reset if necessary, in
* psdf_put_params.
*/
ecode = code = param_read_bool(plist, "LockDistillerParams", &locked);
if (!(locked && pdev->params.LockDistillerParams)) {
/* General parameters. */
{
int efo = 1;
ecode = param_put_int(plist, (param_name = ".EmbedFontObjects"), &efo, ecode);
if (efo != 1)
param_signal_error(plist, param_name, ecode = gs_error_rangecheck);
}
{
int cdv = CoreDistVersion;
ecode = param_put_int(plist, (param_name = "CoreDistVersion"), &cdv, ecode);
if (cdv != CoreDistVersion)
param_signal_error(plist, param_name, ecode = gs_error_rangecheck);
}
switch (code = param_read_float(plist, (param_name = "CompatibilityLevel"), &cl)) {
default:
ecode = code;
param_signal_error(plist, param_name, ecode);
case 0:
/*
* Must be 1.2, 1.3, 1.4, or 1.5. Per Adobe documentation, substitute
* the nearest achievable value.
*/
if (cl < (float)1.15)
cl = (float)1.1;
else if (cl < (float)1.25)
cl = (float)1.2;
else if (cl < (float)1.35)
cl = (float)1.3;
else if (cl < (float)1.45)
cl = (float)1.4;
else
cl = (float)1.5;
case 1:
break;
}
{ /* HACK : gs_param_list_s::memory is documented in gsparam.h as
"for allocating coerced arrays". Not sure why zputdeviceparams
sets it to the current memory space, while the device
assumes to store them in the device's memory space.
As a hackish workaround we temporary replace it here.
Doing so because we don't want to change the global code now
because we're unable to test it with all devices.
Bug 688531 "Segmentation fault running pdfwrite from 219-01.ps".
This solution to be reconsidered after fixing
the bug 688533 "zputdeviceparams specifies a wrong memory space.".
*/
gs_memory_t *mem = plist->memory;
plist->memory = pdev->pdf_memory;
code = gs_param_read_items(plist, pdev, pdf_param_items);
if (code < 0 ||
(pdev->is_ps2write && (code = param_read_string(plist, "OPDFReadProcsetPath", &pdev->OPDFReadProcsetPath)) < 0) ||
(!pdev->is_ps2write && (code = param_read_bool(plist, "ForOPDFRead", &pdev->ForOPDFRead)) < 0)
);
plist->memory = mem;
}
if (code < 0)
ecode = code;
{
/*
* Setting FirstObjectNumber is only legal if the file
* has just been opened and nothing has been written,
* or if we are setting it to the same value.
*/
long fon = pdev->FirstObjectNumber;
if (fon != save_dev->FirstObjectNumber) {
if (fon <= 0 || fon > 0x7fff0000 ||
(pdev->next_id != 0 &&
pdev->next_id !=
save_dev->FirstObjectNumber + pdf_num_initial_ids)
) {
ecode = gs_error_rangecheck;
param_signal_error(plist, "FirstObjectNumber", ecode);
}
}
}
{
/*
* Set ProcessColorModel now, because gx_default_put_params checks
* it.
*/
static const char *const pcm_names[] = {
"DeviceGray", "DeviceRGB", "DeviceCMYK", "DeviceN", 0
};
int pcm = -1;
ecode = param_put_enum(plist, "ProcessColorModel", &pcm,
pcm_names, ecode);
if (pcm >= 0) {
pdf_set_process_color_model(pdev, pcm);
pdf_set_initial_color(pdev, &pdev->saved_fill_color, &pdev->saved_stroke_color,
&pdev->fill_used_process_color, &pdev->stroke_used_process_color);
}
}
}
if (ecode < 0)
goto fail;
if (pdev->PDFX && pdev->PDFA) {
ecode = gs_note_error(gs_error_rangecheck);
param_signal_error(plist, "PDFA", ecode);
goto fail;
}
if (pdev->PDFX && pdev->ForOPDFRead) {
ecode = gs_note_error(gs_error_rangecheck);
param_signal_error(plist, "PDFX", ecode);
goto fail;
}
if (pdev->PDFA && pdev->ForOPDFRead) {
ecode = gs_note_error(gs_error_rangecheck);
param_signal_error(plist, "PDFA", ecode);
goto fail;
}
if (pdev->PDFA)
pdev->HaveTransparency = false;
/*
* We have to set version to the new value, because the set of
* legal parameter values for psdf_put_params varies according to
* the version.
*/
if (pdev->PDFX)
cl = (float)1.3; /* Instead pdev->CompatibilityLevel = 1.2; - see below. */
if (pdev->PDFA && cl < 1.4)
cl = (float)1.4;
pdev->version = (cl < 1.2 ? psdf_version_level2 : psdf_version_ll3);
if (pdev->ForOPDFRead) {
pdev->ResourcesBeforeUsage = true;
pdev->HaveCFF = false;
pdev->HavePDFWidths = false;
pdev->HaveStrokeColor = false;
cl = (float)1.2; /* Instead pdev->CompatibilityLevel = 1.2; - see below. */
pdev->MaxInlineImageSize = max_long; /* Save printer's RAM from saving temporary image data.
Immediate images doen't need buffering. */
pdev->version = psdf_version_level2;
} else {
pdev->ResourcesBeforeUsage = false;
pdev->HaveCFF = true;
pdev->HavePDFWidths = true;
pdev->HaveStrokeColor = true;
}
pdev->ParamCompatibilityLevel = cl;
ecode = gdev_psdf_put_params(dev, plist);
if (ecode < 0)
goto fail;
if ((pdev->params.ColorConversionStrategy == ccs_CMYK &&
strcmp(pdev->color_info.cm_name, "DeviceCMYK")) ||
(pdev->params.ColorConversionStrategy == ccs_sRGB &&
strcmp(pdev->color_info.cm_name, "DeviceRGB")) ||
(pdev->params.ColorConversionStrategy == ccs_Gray &&
strcmp(pdev->color_info.cm_name, "DeviceGray"))) {
eprintf("ColorConversionStrategy is incompatible to ProcessColorModel.\n");
ecode = gs_note_error(gs_error_rangecheck);
pdev->params.ColorConversionStrategy = save_ccs;
}
if (pdev->params.ColorConversionStrategy == ccs_UseDeviceIndependentColor) {
if (!pdev->UseCIEColor) {
eprintf("Set UseCIEColor for UseDeviceIndependentColor to work properly.\n");
ecode = gs_note_error(gs_error_rangecheck);
pdev->UseCIEColor = true;
}
}
if (pdev->params.ColorConversionStrategy == ccs_UseDeviceIndependentColorForImages) {
if (!pdev->UseCIEColor) {
eprintf("UseDeviceDependentColorForImages is not supported. Use UseDeviceIndependentColor.\n");
pdev->params.ColorConversionStrategy = ccs_UseDeviceIndependentColor;
if (!pdev->UseCIEColor) {
eprintf("Set UseCIEColor for UseDeviceIndependentColor to work properly.\n");
ecode = gs_note_error(gs_error_rangecheck);
pdev->UseCIEColor = true;
}
}
}
if (pdev->params.ColorConversionStrategy == ccs_UseDeviceDependentColor) {
if (!strcmp(pdev->color_info.cm_name, "DeviceCMYK")) {
eprintf("Replacing the deprecated device parameter value UseDeviceDependentColor with CMYK.\n");
pdev->params.ColorConversionStrategy = ccs_CMYK;
} else if (!strcmp(pdev->color_info.cm_name, "DeviceRGB")) {
eprintf("Replacing the deprecated device parameter value UseDeviceDependentColor with sRGB.\n");
pdev->params.ColorConversionStrategy = ccs_sRGB;
} else {
eprintf("Replacing the deprecated device parameter value UseDeviceDependentColor with Gray.\n");
pdev->params.ColorConversionStrategy = ccs_Gray;
}
}
if (cl < 1.5 && pdev->params.ColorImage.Filter != NULL &&
!strcmp(pdev->params.ColorImage.Filter, "JPXEncode")) {
eprintf("JPXEncode requires CompatibilityLevel >= 1.5 .\n");
ecode = gs_note_error(gs_error_rangecheck);
}
if (cl < 1.5 && pdev->params.GrayImage.Filter != NULL &&
!strcmp(pdev->params.GrayImage.Filter, "JPXEncode")) {
eprintf("JPXEncode requires CompatibilityLevel >= 1.5 .\n");
ecode = gs_note_error(gs_error_rangecheck);
}
if (cl < 1.4 && pdev->params.MonoImage.Filter != NULL &&
!strcmp(pdev->params.MonoImage.Filter, "JBIG2Encode")) {
eprintf("JBIG2Encode requires CompatibilityLevel >= 1.4 .\n");
ecode = gs_note_error(gs_error_rangecheck);
}
if (pdev->HaveTrueTypes && pdev->version == psdf_version_level2) {
pdev->version = psdf_version_level2_with_TT ;
}
/*
* Acrobat Reader doesn't handle user-space coordinates larger than
* MAX_USER_COORD. To compensate for this, reduce the resolution so
* that the page size in device space (which we equate to user space) is
* significantly less than MAX_USER_COORD. Note that this still does
* not protect us against input files that use coordinates far outside
* the page boundaries.
*/
#define MAX_EXTENT ((int)(MAX_USER_COORD * 0.9))
/* Changing resolution or page size requires closing the device, */
if (dev->height > MAX_EXTENT || dev->width > MAX_EXTENT) {
double factor =
max(dev->height / (double)MAX_EXTENT,
dev->width / (double)MAX_EXTENT);
gx_device_set_resolution(dev, dev->HWResolution[0] / factor,
dev->HWResolution[1] / factor);
}
#undef MAX_EXTENT
if (pdev->FirstObjectNumber != save_dev->FirstObjectNumber) {
if (pdev->xref.file != 0) {
fseek(pdev->xref.file, 0L, SEEK_SET);
pdf_initialize_ids(pdev);
}
}
/* Handle the float/double mismatch. */
pdev->CompatibilityLevel = (int)(cl * 10 + 0.5) / 10.0;
return 0;
fail:
/* Restore all the parameters to their original state. */
pdev->version = save_dev->version;
pdf_set_process_color_model(pdev, save_dev->pcm_color_info_index);
pdev->saved_fill_color = save_dev->saved_fill_color;
pdev->saved_stroke_color = save_dev->saved_fill_color;
{
const gs_param_item_t *ppi = pdf_param_items;
for (; ppi->key; ++ppi)
memcpy((char *)pdev + ppi->offset,
(char *)save_dev + ppi->offset,
gs_param_type_sizes[ppi->type]);
pdev->ForOPDFRead = save_dev->ForOPDFRead;
pdev->OPDFReadProcsetPath = save_dev->OPDFReadProcsetPath;
}
return ecode;
}
static int
tiff_put_some_params(gx_device * dev, gs_param_list * plist, int which)
{
gx_device_tiff *const tfdev = (gx_device_tiff *)dev;
int ecode = 0;
int code;
const char *param_name;
bool big_endian = tfdev->BigEndian;
uint16 compr = tfdev->Compression;
gs_param_string comprstr;
long downscale = tfdev->DownScaleFactor;
long mss = tfdev->MaxStripSize;
long aw = tfdev->AdjustWidth;
long mfs = tfdev->MinFeatureSize;
/* Read BigEndian option as bool */
switch (code = param_read_bool(plist, (param_name = "BigEndian"), &big_endian)) {
default:
ecode = code;
param_signal_error(plist, param_name, ecode);
case 0:
case 1:
break;
}
/* Read Compression */
switch (code = param_read_string(plist, (param_name = "Compression"), &comprstr)) {
case 0:
if ((ecode = tiff_compression_id(&compr, &comprstr)) < 0 ||
!tiff_compression_allowed(compr, (which & 1 ? 1 : dev->color_info.depth)))
{
errprintf(tfdev->memory,
(ecode < 0 ? "Unknown compression setting\n" :
"Invalid compression setting for this bitdepth\n"));
param_signal_error(plist, param_name, ecode);
}
break;
case 1:
break;
default:
ecode = code;
param_signal_error(plist, param_name, ecode);
}
/* Read Downscale factor */
if (which & 1) {
switch (code = param_read_long(plist,
(param_name = "DownScaleFactor"),
&downscale)) {
case 0:
if (downscale <= 0)
downscale = 1;
break;
case 1:
break;
default:
ecode = code;
param_signal_error(plist, param_name, ecode);
}
}
switch (code = param_read_long(plist, (param_name = "MaxStripSize"), &mss)) {
case 0:
/*
* Strip must be large enough to accommodate a raster line.
* If the max strip size is too small, we still write a single
* line per strip rather than giving an error.
*/
if (mss >= 0)
break;
code = gs_error_rangecheck;
default:
ecode = code;
param_signal_error(plist, param_name, ecode);
case 1:
break;
}
switch (code = param_read_long(plist, (param_name = "AdjustWidth"), &aw)) {
case 0:
if (aw >= 0)
break;
code = gs_error_rangecheck;
default:
ecode = code;
param_signal_error(plist, param_name, ecode);
case 1:
break;
}
switch (code = param_read_long(plist, (param_name = "MinFeatureSize"), &mfs)) {
case 0:
if ((mfs >= 0) && (mfs <= 4))
break;
code = gs_error_rangecheck;
default:
ecode = code;
param_signal_error(plist, param_name, ecode);
case 1:
break;
}
if (ecode < 0)
return ecode;
code = gdev_prn_put_params(dev, plist);
if (code < 0)
return code;
tfdev->BigEndian = big_endian;
tfdev->Compression = compr;
tfdev->MaxStripSize = mss;
tfdev->DownScaleFactor = downscale;
tfdev->AdjustWidth = aw;
tfdev->MinFeatureSize = mfs;
return code;
}
static int
test10(gs_state * pgs, gs_memory_t * mem)
{
gs_c_param_list list;
gs_param_string nstr, OFstr;
gs_param_float_array PSa;
gs_param_float_array HWRa;
gs_param_int_array HWSa;
int HWSize[2];
float HWResolution[2], PageSize[2];
long MaxBitmap;
int code;
gx_device *dev = gs_currentdevice(pgs);
float xlate_x, xlate_y;
gs_rect cliprect;
gs_c_param_list_write(&list, mem);
code = gs_getdeviceparams(dev, (gs_param_list *) & list);
if (code < 0) {
lprintf1("getdeviceparams failed! code = %d\n", code);
gs_abort(mem);
}
gs_c_param_list_read(&list);
code = param_read_string((gs_param_list *) & list, "Name", &nstr);
if (code < 0) {
lprintf1("reading Name failed! code = %d\n", code);
gs_abort(mem);
}
code = param_read_int_array((gs_param_list *) & list,
"HWSize", &HWSa);
if (code < 0) {
lprintf1("reading HWSize failed! code = %d\n", code);
gs_abort(mem);
}
emprintf3(mem, "HWSize[%d] = [ %d, %d ]\n", HWSa.size,
HWSa.data[0], HWSa.data[1]);
code = param_read_float_array((gs_param_list *) & list,
"HWResolution", &HWRa);
if (code < 0) {
lprintf1("reading Resolution failed! code = %d\n", code);
gs_abort(mem);
}
emprintf3(mem, "HWResolution[%d] = [ %f, %f ]\n", HWRa.size,
HWRa.data[0], HWRa.data[1]);
code = param_read_float_array((gs_param_list *) & list,
"PageSize", &PSa);
if (code < 0) {
lprintf1("reading PageSize failed! code = %d\n", code);
gs_abort(mem);
}
emprintf3(mem, "PageSize[%d] = [ %f, %f ]\n", PSa.size,
PSa.data[0], PSa.data[1]);
code = param_read_long((gs_param_list *) & list,
"MaxBitmap", &MaxBitmap);
if (code < 0) {
lprintf1("reading MaxBitmap failed! code = %d\n", code);
gs_abort(mem);
}
emprintf1(mem, "MaxBitmap = %ld\n", MaxBitmap);
/* Switch to param list functions to "write" */
gs_c_param_list_write(&list, mem);
/* Always set the PageSize. */
PageSize[0] = 72.0 * ypage_wid;
PageSize[1] = 72.0 * xpage_len;
PSa.data = PageSize;
code = param_write_float_array((gs_param_list *) & list,
"PageSize", &PSa);
if (nstr.data[0] != 'v') {
/* Set the OutputFile string file name */
OFstr.persistent = false;
OFstr.data = outfile;
OFstr.size = strlen(outfile);
code = param_write_string((gs_param_list *) & list,
"OutputFile", &OFstr);
if (code < 0) {
lprintf1("setting OutputFile name failed, code=%d\n",
code);
gs_abort(mem);
}
if (nstr.data[0] == 'x') {
HWResolution[0] = HWResolution[1] = 72.0;
} else {
HWResolution[0] = HWResolution[1] = 360.0;
}
HWRa.data = HWResolution;
HWSize[0] = (int)(HWResolution[0] * ypage_wid);
HWSize[1] = (int)(HWResolution[1] * xpage_len);
emprintf3(mem, "\tHWSize = [%d,%d], HWResolution = %f dpi\n",
HWSize[0], HWSize[1], HWResolution[0]);
HWSa.data = HWSize;
code = param_write_float_array((gs_param_list *) & list,
"HWResolution", &HWRa);
code = param_write_int_array((gs_param_list *) & list,
"HWSize", &HWSa);
MaxBitmap = 1000000L;
code = param_write_long((gs_param_list *) & list,
"MaxBitmap", &MaxBitmap);
}
gs_c_param_list_read(&list);
code = gs_putdeviceparams(dev, (gs_param_list *) & list);
emprintf1(mem, "putdeviceparams: code=%d\n", code);
gs_c_param_list_release(&list);
/* note: initgraphics no longer resets the color or color space */
gs_erasepage(pgs);
gs_initgraphics(pgs);
{
gs_color_space *cs = gs_cspace_new_DeviceGray(mem);
gs_setcolorspace(pgs, cs);
gs_setcolorspace(pgs, cs);
gs_decrement(cs, "test10 DeviceGray");
}
gs_clippath(pgs);
gs_pathbbox(pgs, &cliprect);
emprintf4(mem, "\tcliprect = [[%g,%g],[%g,%g]]\n",
cliprect.p.x, cliprect.p.y, cliprect.q.x, cliprect.q.y);
gs_newpath(pgs);
switch (((rotate_value + 270) / 90) & 3) {
default:
case 0: /* 0 = 360 degrees in PS == 90 degrees in printer */
xlate_x = cliprect.p.x;
xlate_y = cliprect.p.y;
break;
case 1: /* 90 degrees in PS = 180 degrees printer */
xlate_x = cliprect.q.x;
xlate_y = cliprect.p.y;
break;
case 2: /* 180 degrees in PS == 270 degrees in printer */
xlate_x = cliprect.q.x;
xlate_y = cliprect.q.y;
break;
case 3: /* 270 degrees in PS == 0 degrees in printer */
xlate_x = cliprect.p.x;
xlate_y = cliprect.q.y;
break;
}
emprintf2(mem, "translate origin to [ %f, %f ]\n", xlate_x, xlate_y);
gs_translate(pgs, xlate_x, xlate_y);
/* further move (before rotate) by user requested amount */
gs_translate(pgs, 72.0 * (float)xmove_origin, 72.0 * (float)ymove_origin);
gs_rotate(pgs, (float)rotate_value + 270.0);
gs_scale(pgs, scale_x * 72.0 / 2032.0,
scale_y * 72.0 / 2032.0);
gs_setlinecap(pgs, gs_cap_butt);
gs_setlinejoin(pgs, gs_join_bevel);
gs_setfilladjust(pgs, 0.0, 0.0);
capture_exec(pgs);
return 0;
}
int
main(int argc, const char *argv[])
{
char achar = '0';
gs_memory_t *mem;
gs_state *pgs;
const gx_device *const *list;
gx_device *dev;
gx_device_bbox *bbdev;
int code;
gp_init();
mem = gs_malloc_init();
gs_lib_init1(mem);
if (argc < 2 || (achar = argv[1][0]) < '1' ||
achar > '0' + countof(tests) - 1
) {
lprintf1("Usage: gslib 1..%c\n", '0' + (char)countof(tests) - 1);
gs_abort(mem);
}
gs_debug['@'] = 1;
gs_debug['?'] = 1;
/*gs_debug['B'] = 1; *//****** PATCH ******/
/*gs_debug['L'] = 1; *//****** PATCH ******/
/*
* gs_iodev_init must be called after the rest of the inits, for
* obscure reasons that really should be documented!
*/
gs_iodev_init(mem);
/****** WRONG ******/
gs_lib_device_list(&list, NULL);
gs_copydevice(&dev, list[0], mem);
check_device_separable(dev);
gx_device_fill_in_procs(dev);
bbdev =
gs_alloc_struct_immovable(mem, gx_device_bbox, &st_device_bbox,
"bbox");
gx_device_bbox_init(bbdev, dev, mem);
code = dev_proc(dev, get_profile)(dev, &bbdev->icc_struct);
rc_increment(bbdev->icc_struct);
/* Print out the device name just to test the gsparam.c API. */
{
gs_c_param_list list;
gs_param_string nstr;
gs_c_param_list_write(&list, mem);
code = gs_getdeviceparams(dev, (gs_param_list *) & list);
if (code < 0) {
lprintf1("getdeviceparams failed! code = %d\n", code);
gs_abort(mem);
}
gs_c_param_list_read(&list);
code = param_read_string((gs_param_list *) & list, "Name", &nstr);
if (code < 0) {
lprintf1("reading Name failed! code = %d\n", code);
gs_abort(mem);
}
dputs("Device name = ");
debug_print_string(nstr.data, nstr.size);
dputs("\n");
gs_c_param_list_release(&list);
}
/*
* If this is a device that takes an OutputFile, set the OutputFile
* to "-" in the copy.
*/
{
gs_c_param_list list;
gs_param_string nstr;
gs_c_param_list_write(&list, mem);
param_string_from_string(nstr, "-");
code = param_write_string((gs_param_list *)&list, "OutputFile", &nstr);
if (code < 0) {
lprintf1("writing OutputFile failed! code = %d\n", code);
gs_abort(mem);
}
gs_c_param_list_read(&list);
code = gs_putdeviceparams(dev, (gs_param_list *)&list);
gs_c_param_list_release(&list);
if (code < 0 && code != gs_error_undefined) {
lprintf1("putdeviceparams failed! code = %d\n", code);
gs_abort(mem);
}
}
dev = (gx_device *) bbdev;
pgs = gs_state_alloc(mem);
gs_setdevice_no_erase(pgs, dev); /* can't erase yet */
{
gs_point dpi;
gs_screen_halftone ht;
gs_dtransform(pgs, 72.0, 72.0, &dpi);
ht.frequency = min(fabs(dpi.x), fabs(dpi.y)) / 16.001;
ht.angle = 0;
ht.spot_function = odsf;
gs_setscreen(pgs, &ht);
}
/* gsave and grestore (among other places) assume that */
/* there are at least 2 gstates on the graphics stack. */
/* Ensure that now. */
gs_gsave(pgs);
gs_erasepage(pgs);
code = (*tests[achar - '1']) (pgs, mem);
gs_output_page(pgs, 1, 1);
{
gs_rect bbox;
gx_device_bbox_bbox(bbdev, &bbox);
dprintf4("Bounding box: [%g %g %g %g]\n",
bbox.p.x, bbox.p.y, bbox.q.x, bbox.q.y);
}
if (code)
dprintf1("**** Test returned code = %d.\n", code);
dputs("Done. Press <enter> to exit.");
fgetc(mem->gs_lib_ctx->fstdin);
gs_lib_finit(0, 0, mem);
return 0;
#undef mem
}
static int
tfax_put_params(gx_device * dev, gs_param_list * plist)
{
gx_device_tfax *const tfdev = (gx_device_tfax *)dev;
int ecode = 0;
int code;
long mss = tfdev->MaxStripSize;
int fill_order = tfdev->FillOrder;
const char *param_name;
bool big_endian = tfdev->BigEndian;
uint16 compr = tfdev->Compression;
gs_param_string comprstr;
switch (code = param_read_long(plist, (param_name = "MaxStripSize"), &mss)) {
case 0:
/*
* Strip must be large enough to accommodate a raster line.
* If the max strip size is too small, we still write a single
* line per strip rather than giving an error.
*/
if (mss >= 0)
break;
code = gs_error_rangecheck;
default:
ecode = code;
param_signal_error(plist, param_name, ecode);
case 1:
break;
}
/* Following TIFF spec, FillOrder is integer */
switch (code = param_read_int(plist, (param_name = "FillOrder"), &fill_order)) {
case 0:
if (fill_order == 1 || fill_order == 2)
break;
code = gs_error_rangecheck;
default:
ecode = code;
param_signal_error(plist, param_name, ecode);
case 1:
break;
}
/* Read BigEndian option as bool */
switch (code = param_read_bool(plist, (param_name = "BigEndian"), &big_endian)) {
default:
ecode = code;
param_signal_error(plist, param_name, ecode);
case 0:
case 1:
break;
}
/* Read Compression */
switch (code = param_read_string(plist, (param_name = "Compression"), &comprstr)) {
case 0:
if ((ecode = tiff_compression_id(&compr, &comprstr)) < 0 ||
!tiff_compression_allowed(compr, dev->color_info.depth))
param_signal_error(plist, param_name, ecode);
break;
case 1:
break;
default:
ecode = code;
param_signal_error(plist, param_name, ecode);
}
if (ecode < 0)
return ecode;
code = gdev_fax_put_params(dev, plist);
if (code < 0)
return code;
tfdev->MaxStripSize = mss;
tfdev->FillOrder = fill_order;
tfdev->BigEndian = big_endian;
tfdev->Compression = compr;
return code;
}
/* internal variables. */
static int
win_pr2_read_user_settings(gx_device_win_pr2 * wdev, gs_param_list * plist)
{
gs_param_dict dict;
gs_param_string docn = { 0 };
const char* dict_name = "UserSettings";
const char* param_name = "";
int code = 0;
int ecode = 0;
switch (code = param_begin_read_dict(plist, dict_name, &dict, false)) {
default:
param_signal_error(plist, dict_name, code);
return code;
case 1:
break;
case 0:
{
gs_param_int_array ia;
BEGIN_ARRAY_PARAM(param_read_int_array, "DocumentRange", ia, 2, ia)
if ((ia.data[0] < 0) ||
(ia.data[1] < 0) ||
(ia.data[0] > ia.data[1]))
ecode = gs_note_error(gs_error_rangecheck);
wdev->doc_page_begin = ia.data[0];
wdev->doc_page_end = ia.data[1];
END_ARRAY_PARAM(ia, doc_range_error)
BEGIN_ARRAY_PARAM(param_read_int_array, "SelectedRange", ia, 2, ia)
if ((ia.data[0] < 0) ||
(ia.data[1] < 0) ||
(ia.data[0] > ia.data[1]))
ecode = gs_note_error(gs_error_rangecheck);
wdev->user_page_begin = ia.data[0];
wdev->user_page_end = ia.data[1];
END_ARRAY_PARAM(ia, sel_range_error)
param_read_int(dict.list, "Copies", &wdev->user_copies);
param_read_int(dict.list, "Paper", &wdev->user_paper);
param_read_int(dict.list, "Orientation", &wdev->user_orient);
param_read_int(dict.list, "Color", &wdev->user_color);
param_read_int(dict.list, "MaxResolution", &wdev->max_dpi);
switch (code = param_read_string(dict.list, (param_name = "DocumentName"), &docn)) {
case 0:
if (docn.size < sizeof(wdev->doc_name))
break;
code = gs_error_rangecheck;
/* fall through */
default:
ecode = code;
param_signal_error(plist, param_name, ecode);
/* fall through */
case 1:
docn.data = 0;
break;
}
param_end_read_dict(plist, dict_name, &dict);
if (docn.data) {
memcpy(wdev->doc_name, docn.data, docn.size);
wdev->doc_name[docn.size] = 0;
}
wdev->print_copies = 1;
if (wdev->win32_hdevmode) {
LPDEVMODE devmode = (LPDEVMODE) GlobalLock(wdev->win32_hdevmode);
if (devmode) {
devmode->dmCopies = wdev->user_copies;
devmode->dmPaperSize = wdev->user_paper;
devmode->dmOrientation = wdev->user_orient;
devmode->dmColor = wdev->user_color;
GlobalUnlock(wdev->win32_hdevmode);
}
}
}
break;
}
return code;
}
static int
tfax_put_params(gx_device * dev, gs_param_list * plist)
{
gx_device_tfax *const tfdev = (gx_device_tfax *)dev;
int ecode = 0;
int code;
long mss = tfdev->MaxStripSize;
int fill_order = tfdev->FillOrder;
const char *param_name;
bool big_endian = tfdev->BigEndian;
bool usebigtiff = tfdev->UseBigTIFF;
bool write_datetime = tfdev->write_datetime;
uint16 compr = tfdev->Compression;
gs_param_string comprstr;
switch (code = param_read_long(plist, (param_name = "MaxStripSize"), &mss)) {
case 0:
/*
* Strip must be large enough to accommodate a raster line.
* If the max strip size is too small, we still write a single
* line per strip rather than giving an error.
*/
if (mss >= 0)
break;
code = gs_error_rangecheck;
default:
ecode = code;
param_signal_error(plist, param_name, ecode);
case 1:
break;
}
/* Following TIFF spec, FillOrder is integer */
switch (code = param_read_int(plist, (param_name = "FillOrder"), &fill_order)) {
case 0:
if (fill_order == 1 || fill_order == 2)
break;
code = gs_error_rangecheck;
default:
ecode = code;
param_signal_error(plist, param_name, ecode);
case 1:
break;
}
/* Read BigEndian option as bool */
switch (code = param_read_bool(plist, (param_name = "BigEndian"), &big_endian)) {
default:
ecode = code;
param_signal_error(plist, param_name, ecode);
case 0:
case 1:
break;
}
/* Read UseBigTIFF option as bool */
switch (code = param_read_bool(plist, (param_name = "UseBigTIFF"), &usebigtiff)) {
default:
ecode = code;
param_signal_error(plist, param_name, ecode);
case 0:
case 1:
break;
}
#if !(TIFFLIB_VERSION >= 20111221)
if (usebigtiff)
dmlprintf(dev->memory, "Warning: this version of libtiff does not support BigTIFF, ignoring parameter\n");
usebigtiff = false;
#endif
switch (code = param_read_bool(plist, (param_name = "TIFFDateTime"), &write_datetime)) {
default:
ecode = code;
param_signal_error(plist, param_name, ecode);
case 0:
case 1:
break;
}
/* Read Compression */
switch (code = param_read_string(plist, (param_name = "Compression"), &comprstr)) {
case 0:
if ((ecode = tiff_compression_id(&compr, &comprstr)) < 0 ||
!tiff_compression_allowed(compr, dev->color_info.depth))
param_signal_error(plist, param_name, ecode);
break;
case 1:
break;
default:
ecode = code;
param_signal_error(plist, param_name, ecode);
}
if (ecode < 0)
return ecode;
code = gdev_fax_put_params(dev, plist);
if (code < 0)
return code;
tfdev->MaxStripSize = mss;
tfdev->FillOrder = fill_order;
tfdev->BigEndian = big_endian;
tfdev->UseBigTIFF = usebigtiff;
tfdev->Compression = compr;
return code;
}