/*
* <dict> .seticcspace -
*
* Create an ICCBased color space and set it to be the current color space.
*
* The PostScript structure of an ICCBased color space is that same as that
* for a CIEBased* color space:
*
* [ /ICCBased <dictionary> ]
*
* As is the for other .setcie*space operators, the operand dictionary rather
* than the complete color space array is on the stack when this operator
* is inovked.
*
* At the time this procedure is called, the alternative color space for
* the ICCBased color space is expected to be the current color space,
* whether that space was explicitly specified or implied by the number
* of components in the ICCBased color space dictionary. This is consistent
* with the handling of alternative spaces in Separation, DeviceN, and
* Indexed color spaces. Unlike the "zset*space" routines for those spaces,
* however, the current code does not attempt to build the color space
* "in place" in the graphic state.
*
* The procedure that invokes this operator will already have checked that
* the operand is a dictionary, is readable, and defines the key /N
* (number of components).
*/
static int
zseticcspace(i_ctx_t * i_ctx_p)
{
os_ptr op = osp;
int code;
gs_color_space * palt_cs;
ref * pnval;
ref * pstrmval;
stream * s;
int i, ncomps;
float range_buff[8];
static const float dflt_range[8] = { 0, 1, 0, 1, 0, 1, 0, 1 };
code = dict_find_string(op, "N", &pnval);
if (code < 0)
return code;
ncomps = pnval->value.intval;
if (2*ncomps > sizeof(range_buff)/sizeof(range_buff[0]))
return_error(e_rangecheck);
/* verify the DataSource entry */
if (dict_find_string(op, "DataSource", &pstrmval) <= 0)
return_error(e_undefined);
check_read_file(i_ctx_p, s, pstrmval);
/*
* Verify that the current color space can be a alternative color space.
* The check for ICCBased color space is a hack to avoid introducing yet
* another category indicator into the gs_color_space_type structur.
*/
palt_cs = gs_currentcolorspace(igs);
if ( !palt_cs->type->can_be_alt_space ||
gs_color_space_get_index(palt_cs) == gs_color_space_index_ICC )
return_error(e_rangecheck);
/*
* Fetch and verify the Range array.
*
* The PDF documentation is unclear as to the purpose of this array.
* Essentially all that is stated is that "These values must match the
* information in the ICC profile" (PDF Reference, 2nd ed., p. 174).
* If that is the case, why not use the information in the profile?
* The only reason we can think of is range specification is intended
* to be used to limit the range of values passed to the alternate
* color space (the range may be smaller than the native range of values
* provided by that color space).
*
* Because the cms code will perform normalization based on color
* space, we use the range values only to restrict the set of input
* values; they are not used for normalization.
*/
code = dict_floats_param( imemory,
op,
"Range",
2 * ncomps,
range_buff,
dflt_range );
for (i = 0; i < 2 * ncomps && range_buff[i + 1] >= range_buff[i]; i += 2)
;
if (i != 2 * ncomps)
return_error(e_rangecheck);
return seticc(i_ctx_p, ncomps, op, range_buff);
}
static int
zreadstring_at(i_ctx_t *i_ctx_p, os_ptr op, uint start)
{
stream *s;
uint len, rlen;
int status;
check_write_type(*op, t_string);
check_read_file(s, op - 1);
len = r_size(op);
status = sgets(s, op->value.bytes + start, len - start, &rlen);
rlen += start;
switch (status) {
case EOFC:
case 0:
break;
default:
return handle_read_status(i_ctx_p, status, op - 1, &rlen,
zreadstring_continue);
}
/*
* The most recent Adobe specification says that readstring
* must signal a rangecheck if the string length is zero.
* I can't imagine the motivation for this, but we emulate it.
* It's safe to check it here, rather than earlier, because if
* len is zero, sgets will return 0 immediately with rlen = 0.
*/
if (len == 0)
return_error(e_rangecheck);
r_set_size(op, rlen);
op[-1] = *op;
make_bool(op, (rlen == len ? 1 : 0));
return 0;
}
/* <file> read -false- */
static int
zread(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
stream *s;
int ch;
check_read_file(s, op);
/* We 'push' first in case of ostack block overflow and the */
/* usual case is we will need to push anyway. If we get EOF */
/* we will need to 'pop' and decrement the 'op' pointer. */
/* This is required since the 'push' macro might return with*/
/* stackoverflow which will result in another stack block */
/* added on, then the operator being retried. We can't read */
/* (sgetc) prior to having a place on the ostack to return */
/* the character. */
push(1);
ch = sgetc(s);
if (ch >= 0) {
make_int(op - 1, ch);
make_bool(op, 1);
} else {
pop(1); /* Adjust ostack back from preparatory 'pop' */
op--;
if (ch == EOFC)
make_bool(op, 0);
else
return handle_read_status(i_ctx_p, ch, op, NULL, zread);
}
return 0;
}
int
ztokenexec(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
stream *s;
scanner_state state;
check_read_file(i_ctx_p, s, op);
check_estack(1);
gs_scanner_init(&state, op);
return tokenexec_continue(i_ctx_p, &state, true);
}
int
ztoken(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
switch (r_type(op)) {
default:
return_op_typecheck(op);
case t_file: {
stream *s;
scanner_state state;
check_read_file(i_ctx_p, s, op);
check_ostack(1);
gs_scanner_init(&state, op);
return token_continue(i_ctx_p, &state, true);
}
case t_string: {
ref token;
/* -1 is to remove the string operand in case of error. */
int orig_ostack_depth = ref_stack_count(&o_stack) - 1;
int code;
/* Don't pop the operand in case of invalidaccess. */
if (!r_has_attr(op, a_read))
return_error(e_invalidaccess);
code = gs_scan_string_token(i_ctx_p, op, &token);
switch (code) {
case scan_EOF: /* no tokens */
make_false(op);
return 0;
default:
if (code < 0) {
/*
* Clear anything that may have been left on the ostack,
* including the string operand.
*/
if (orig_ostack_depth < ref_stack_count(&o_stack))
pop(ref_stack_count(&o_stack)- orig_ostack_depth);
return code;
}
}
push(2);
op[-1] = token;
make_true(op);
return 0;
}
}
}
/* <file> <int> .unread - */
static int
zunread(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
stream *s;
ulong ch;
check_read_file(s, op - 1);
check_type(*op, t_integer);
ch = op->value.intval;
if (ch > 0xff)
return_error(e_rangecheck);
if (sungetc(s, (byte) ch) < 0)
return_error(e_ioerror);
pop(2);
return 0;
}
/* convenience of reusing procedures that take 1 state parameter */
static int
zreadhexstring_at(i_ctx_t *i_ctx_p, os_ptr op, uint start, int odd)
{
stream *s;
uint len, nread;
byte *str;
int odd_byte = odd;
stream_cursor_write cw;
int status;
check_read_file(s, op - 1);
/*check_write_type(*op, t_string); *//* done by caller */
str = op->value.bytes;
len = r_size(op);
cw.ptr = str + start - 1;
cw.limit = str + len - 1;
for (;;) {
status = s_hex_process(&s->cursor.r, &cw, &odd_byte,
hex_ignore_garbage);
if (status == 1) { /* filled the string */
ref_assign_inline(op - 1, op);
make_true(op);
return 0;
} else if (status != 0) /* error or EOF */
break;
/* Didn't fill, keep going. */
status = spgetc(s);
if (status < 0)
break;
sputback(s);
}
nread = cw.ptr + 1 - str;
if (status != EOFC) { /* Error */
nread |= odd_byte << 24;
return handle_read_status(i_ctx_p, status, op - 1, &nread,
zreadhexstring_continue);
}
/* Reached end-of-file before filling the string. */
/* Return an appropriate substring. */
ref_assign_inline(op - 1, op);
r_set_size(op - 1, nread);
make_false(op);
return 0;
}
/* <file> bytesavailable <int> */
static int
zbytesavailable(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
stream *s;
long avail;
check_read_file(s, op);
switch (savailable(s, &avail)) {
default:
return_error(e_ioerror);
case EOFC:
avail = -1;
case 0:
;
}
make_int(op, avail);
return 0;
}
/* <file> <string> .peekstring <substring> <filled_bool> */
static int
zpeekstring(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
stream *s;
uint len, rlen;
check_read_file(s, op - 1);
check_write_type(*op, t_string);
len = r_size(op);
while ((rlen = sbufavailable(s)) < len) {
int status = s->end_status;
switch (status) {
case EOFC:
break;
case 0:
/*
* The following is a HACK. It should reallocate the buffer to hold
* at least len bytes. However, this raises messy problems about
* which allocator to use and how it should interact with restore.
*/
if (len >= s->bsize)
return_error(e_rangecheck);
s_process_read_buf(s);
continue;
default:
return handle_read_status(i_ctx_p, status, op - 1, NULL,
zpeekstring);
}
break;
}
if (rlen > len)
rlen = len;
/* Don't remove the data from the buffer. */
memcpy(op->value.bytes, sbufptr(s), rlen);
r_set_size(op, rlen);
op[-1] = *op;
make_bool(op, (rlen == len ? 1 : 0));
return 0;
}
/*
* We could handle readline the same way as readstring,
* except for the anomalous situation where we get interrupted
* between the CR and the LF of an end-of-line marker.
* We hack around this in the following way: if we get interrupted
* before we've read any characters, we just restart the readline;
* if we get interrupted at any other time, we use readline_continue;
* we use start=0 (which we have just ruled out as a possible start value
* for readline_continue) to indicate interruption after the CR.
*/
static int
zreadline_at(i_ctx_t *i_ctx_p, os_ptr op, uint count, bool in_eol)
{
stream *s;
int status;
gs_string str;
check_write_type(*op, t_string);
check_read_file(s, op - 1);
str.data = op->value.bytes;
str.size = r_size(op);
status = zreadline_from(s, &str, NULL, &count, &in_eol);
switch (status) {
case 0:
case EOFC:
break;
case 1:
return_error(e_rangecheck);
default:
if (count == 0 && !in_eol)
return handle_read_status(i_ctx_p, status, op - 1, NULL,
zreadline);
else {
if (in_eol) {
r_set_size(op, count);
count = 0;
}
return handle_read_status(i_ctx_p, status, op - 1, &count,
zreadline_continue);
}
}
r_set_size(op, count);
op[-1] = *op;
make_bool(op, status == 0);
return 0;
}
/*
* <dict> .set_outputintent -
*
* Set and use the specified output intent.
*
*/
static int
zset_outputintent(i_ctx_t * i_ctx_p)
{
os_ptr op = osp;
int code = 0;
gx_device *dev = gs_currentdevice(igs);
gs_imager_state *pis = (gs_imager_state *)igs;
cmm_dev_profile_t *dev_profile;
stream * s = 0L;
ref * pnval;
ref * pstrmval;
int ncomps, dev_comps;
cmm_profile_t *picc_profile;
int expected = 0;
gs_color_space_index index;
gsicc_manager_t *icc_manager = pis->icc_manager;
cmm_profile_t *source_profile = NULL;
check_type(*op, t_dictionary);
check_dict_read(*op);
if_debug0m(gs_debug_flag_icc, imemory, "[icc] Using OutputIntent\n");
/* Get the device structure */
code = dev_proc(dev, get_profile)(dev, &dev_profile);
if (dev_profile == NULL) {
code = gsicc_init_device_profile_struct(dev, NULL, 0);
code = dev_proc(dev, get_profile)(dev, &dev_profile);
}
if (dev_profile->oi_profile != NULL) {
return 0; /* Allow only one setting of this object */
}
code = dict_find_string(op, "N", &pnval);
if (code < 0)
return code;
ncomps = pnval->value.intval;
/* verify the DataSource entry. Creat profile from stream */
if (dict_find_string(op, "DataSource", &pstrmval) <= 0)
return_error(e_undefined);
check_read_file(i_ctx_p, s, pstrmval);
picc_profile = gsicc_profile_new(s, gs_state_memory(igs), NULL, 0);
picc_profile->num_comps = ncomps;
picc_profile->profile_handle =
gsicc_get_profile_handle_buffer(picc_profile->buffer,
picc_profile->buffer_size,
gs_state_memory(igs));
if (picc_profile->profile_handle == NULL) {
rc_decrement(picc_profile,"zset_outputintent");
return -1;
}
picc_profile->data_cs = gscms_get_profile_data_space(picc_profile->profile_handle);
switch (picc_profile->data_cs) {
case gsCIEXYZ:
case gsCIELAB:
case gsRGB:
expected = 3;
source_profile = icc_manager->default_rgb;
break;
case gsGRAY:
expected = 1;
source_profile = icc_manager->default_gray;
break;
case gsCMYK:
expected = 4;
source_profile = icc_manager->default_cmyk;
break;
case gsNCHANNEL:
expected = 0;
break;
case gsNAMED:
case gsUNDEFINED:
break;
}
if (expected && ncomps != expected) {
rc_decrement(picc_profile,"zset_outputintent");
return_error(e_rangecheck);
}
gsicc_init_hash_cs(picc_profile, pis);
/* All is well with the profile. Lets set the stuff that needs to be set */
dev_profile->oi_profile = picc_profile;
picc_profile->name = (char *) gs_alloc_bytes(picc_profile->memory,
MAX_DEFAULT_ICC_LENGTH,
"zset_outputintent");
strncpy(picc_profile->name, OI_PROFILE, strlen(OI_PROFILE));
picc_profile->name[strlen(OI_PROFILE)] = 0;
picc_profile->name_length = strlen(OI_PROFILE);
/* Set the range of the profile */
gscms_set_icc_range(&picc_profile);
/* If the output device has a different number of componenets, then we are
going to set the output intent as the proofing profile, unless the
proofing profile has already been set.
If the device has the same number of components (and color model) then as
the profile we will use this as the output profile, unless someone has
explicitly set the output profile.
Finally, we will use the output intent profile for the default profile
of the proper Device profile in the icc manager, again, unless someone
has explicitly set this default profile. */
dev_comps = dev_profile->device_profile[0]->num_comps;
index = gsicc_get_default_type(dev_profile->device_profile[0]);
if (ncomps == dev_comps && index < gs_color_space_index_DevicePixel) {
/* The OI profile is the same type as the profile for the device and a
"default" profile for the device was not externally set. So we go
ahead and use the OI profile as the device profile. Care needs to be
taken here to keep from screwing up any device parameters. We will
use a keyword of OIProfile for the user/device parameter to indicate
its usage. Also, note conflicts if one is setting object dependent
color management */
rc_assign(dev_profile->device_profile[0], picc_profile,
"zset_outputintent");
if_debug0m(gs_debug_flag_icc, imemory, "[icc] OutputIntent used for device profile\n");
} else {
if (dev_profile->proof_profile == NULL) {
/* This means that we should use the OI profile as the proofing
profile. Note that if someone already has specified a
proofing profile it is unclear what they are trying to do
with the output intent. In this case, we will use it
just for the source data below */
dev_profile->proof_profile = picc_profile;
rc_increment(picc_profile);
if_debug0m(gs_debug_flag_icc, imemory, "[icc] OutputIntent used for proof profile\n");
}
}
/* Now the source colors. See which source color space needs to use the
output intent ICC profile */
index = gsicc_get_default_type(source_profile);
if (index < gs_color_space_index_DevicePixel) {
/* source_profile is currently the default. Set it to the OI profile */
switch (picc_profile->data_cs) {
case gsGRAY:
if_debug0m(gs_debug_flag_icc, imemory, "[icc] OutputIntent used source Gray\n");
rc_assign(icc_manager->default_gray, picc_profile,
"zset_outputintent");
break;
case gsRGB:
if_debug0m(gs_debug_flag_icc, imemory, "[icc] OutputIntent used source RGB\n");
rc_assign(icc_manager->default_rgb, picc_profile,
"zset_outputintent");
break;
case gsCMYK:
if_debug0m(gs_debug_flag_icc, imemory, "[icc] OutputIntent used source CMYK\n");
rc_assign(icc_manager->default_cmyk, picc_profile,
"zset_outputintent");
break;
default:
break;
}
}
/* Remove the output intent dict from the stack */
pop(1);
return code;
}
/* <string|name> <font_dict> .buildfont9 <string|name> <font> */
static int
zbuildfont9(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
build_proc_refs build;
int code = build_proc_name_refs(imemory, &build, NULL, "%Type9BuildGlyph");
gs_font_cid_data common;
ref GlyphDirectory, GlyphData, DataSource;
ref *prfda, cfnstr;
ref *pCIDFontName, CIDFontName;
gs_font_type1 **FDArray;
uint FDArray_size;
int FDBytes;
uint CIDMapOffset;
gs_font_base *pfont;
gs_font_cid0 *pfcid;
uint i;
/*
* If the CIDFont's data have been loaded into VM, GlyphData will be
* a string or an array of strings; if they are loaded incrementally
* from a file, GlyphData will be an integer, and DataSource will be
* a (reusable) stream.
*/
if (code < 0 ||
(code = cid_font_data_param(op, &common, &GlyphDirectory)) < 0 ||
(code = dict_find_string(op, "FDArray", &prfda)) < 0 ||
(code = dict_find_string(op, "CIDFontName", &pCIDFontName)) <= 0 ||
(code = dict_int_param(op, "FDBytes", 0, MAX_FDBytes, -1, &FDBytes)) < 0
)
return code;
/*
* Since build_gs_simple_font may resize the dictionary and cause
* pointers to become invalid, save CIDFontName
*/
CIDFontName = *pCIDFontName;
if (r_has_type(&GlyphDirectory, t_null)) {
/* Standard CIDFont, require GlyphData and CIDMapOffset. */
ref *pGlyphData;
if ((code = dict_find_string(op, "GlyphData", &pGlyphData)) < 0 ||
(code = dict_uint_param(op, "CIDMapOffset", 0, max_uint - 1,
max_uint, &CIDMapOffset)) < 0)
return code;
GlyphData = *pGlyphData;
if (r_has_type(&GlyphData, t_integer)) {
ref *pds;
stream *ignore_s;
if ((code = dict_find_string(op, "DataSource", &pds)) < 0)
return code;
check_read_file(i_ctx_p, ignore_s, pds);
DataSource = *pds;
} else {
if (!r_has_type(&GlyphData, t_string) && !r_is_array(&GlyphData))
return_error(e_typecheck);
make_null(&DataSource);
}
} else {
make_null(&GlyphData);
make_null(&DataSource);
CIDMapOffset = 0;
}
if (!r_is_array(prfda))
return_error(e_invalidfont);
FDArray_size = r_size(prfda);
if (FDArray_size == 0)
return_error(e_invalidfont);
FDArray = ialloc_struct_array(FDArray_size, gs_font_type1 *,
&st_gs_font_type1_ptr_element,
"buildfont9(FDarray)");
if (FDArray == 0)
return_error(e_VMerror);
memset(FDArray, 0, sizeof(gs_font_type1 *) * FDArray_size);
for (i = 0; i < FDArray_size; ++i) {
ref rfd;
array_get(imemory, prfda, (long)i, &rfd);
code = fd_array_element(i_ctx_p, &FDArray[i], &rfd);
if (code < 0)
goto fail;
}
code = build_gs_outline_font(i_ctx_p, op, &pfont, ft_CID_encrypted,
&st_gs_font_cid0, &build,
bf_Encoding_optional | bf_UniqueID_ignored,
build_gs_simple_font);
if (code < 0)
goto fail;
if (code == 1) {
/* The font already has a FID, don't need to build it again.
Release FDArray and return normally.
fixme: FDArray fonts are thrown for garbager.
We're not safe to build them after
build_gs_simple_font(..., &pfont, ...),
because a failure in building them would throw
an underbuilt font with unclear consequences.
*/
ifree_object(FDArray, "buildfont9(FDarray)");
return 0;
}
pfont->procs.enumerate_glyph = gs_font_cid0_enumerate_glyph;
pfont->procs.glyph_outline = z9_glyph_outline;
pfont->procs.glyph_info = z9_glyph_info;
pfcid = (gs_font_cid0 *)pfont;
pfcid->cidata.common = common;
pfcid->cidata.CIDMapOffset = CIDMapOffset;
pfcid->cidata.FDArray = FDArray;
pfcid->cidata.FDArray_size = FDArray_size;
pfcid->cidata.FDBytes = FDBytes;
pfcid->cidata.glyph_data = z9_glyph_data;
pfcid->cidata.proc_data = 0; /* for GC */
if (pfcid->font_name.size == 0) {
get_font_name(imemory, &cfnstr, &CIDFontName);
copy_font_name(&pfcid->font_name, &cfnstr);
}
ref_assign(&pfont_data(pfont)->u.cid0.GlyphDirectory, &GlyphDirectory);
ref_assign(&pfont_data(pfont)->u.cid0.GlyphData, &GlyphData);
ref_assign(&pfont_data(pfont)->u.cid0.DataSource, &DataSource);
code = define_gs_font(i_ctx_p, (gs_font *)pfont);
if (code >= 0)
code = gs_notify_register(&pfont->notify_list, notify_remove_font_type9, pfont);
if (code >= 0) {
for (i = 0; i < FDArray_size; ++i) {
FDArray[i]->dir = pfont->dir;
FDArray[i]->data.parent = pfont;
}
return code;
}
fail:
ifree_object(FDArray, "buildfont9(FDarray)");
return code;
}
main()
{
int i;
int hsync;
int ret;
int tmp_v;
ResetCallback();
// initialize CD subsystem
CdInit();
CdSetDebug(0);
// initialize graphics
ResetGraph(0);
// initialize debug display
FntLoad(960, 256);
SetDumpFnt(FntOpen(64, 64, 128, 128, 0, 512));
// initialize display double buffer
SetDefDrawEnv(&db[0].draw, 0, 0, 320, 240);
SetDefDrawEnv(&db[1].draw, 0, 240, 320, 240);
SetDefDispEnv(&db[0].disp, 0, 240, 320, 240);
SetDefDispEnv(&db[1].disp, 0, 0, 320, 240);
db[0].draw.isbg = 1;
setRGB0(&db[0].draw, 0, 0, 0);
db[1].draw.isbg = 1;
setRGB0(&db[1].draw, 0, 0, 0);
setPolyF4(&db[0].prim);
setRGB0(&db[0].prim, 255, 255, 0);
setPolyF4(&db[1].prim);
setRGB0(&db[1].prim, 255, 255, 0);
for (i = 0; i < READ_FILES; i++) {
set_read_file(i, filename[file_order[i]], (void *)0x80100000);
}
file_num = 0;
// set CD subsystem mode
param[0] = CdlModeSpeed; // x2 speed
while (CdControl(CdlSetmode, param, 0) == 0)
;
SetDispMask(1); // enable display
// main loop
while(1) {
cdb = (cdb==db)? db+1: db; // swap double buffer ID
ClearOTag(cdb->ot, OTSIZE);
moving_object();
FntPrint("CD READ TEST 2\n----------------\n");
FntPrint("FILE: %d\n", file_num);
FntPrint("POS: %02x:%02x:%02x\n", fp[file_num].pos.minute,
fp[file_num].pos.second,
fp[file_num].pos.sector);
FntPrint("SECTORS: %d\n", read_remain_sector);
FntPrint("READ V: %d\n", read_v);
if ((ret = check_read_file()) == CD_READ_COMPLETE) {
if (++file_num > READ_FILES-1) {
file_num = 0;
tmp_v = VSync(-1);
read_v = tmp_v - start_v;
start_v = tmp_v;
}
read_remain_sector = READ_SECTORS; // for display
start_read_file(file_num);
}
else if (ret != CD_READ_BUSY) {
start_read_file(0);
start_v = VSync(-1);
}
read_manage();
hsync = VSync(0);
PutDispEnv(&cdb->disp); // update display environment
PutDrawEnv(&cdb->draw); // update drawing environment
DrawOTag(cdb->ot);
print_hsync(hsync);
FntPrint("\nERROR: %d\n", errcnt);
// flush debug strings
FntFlush(-1);
}
}
int seticc(i_ctx_t * i_ctx_p, int ncomps, ref *ICCdict, float *range_buff)
{
os_ptr op = osp;
int edepth = ref_stack_count(&e_stack);
int code, reuse_op = 0;
gs_color_space * pcs;
gs_color_space * palt_cs;
int i;
gs_cie_icc * picc_info;
ref * pstrmval;
stream * s = 0L;
palt_cs = gs_currentcolorspace(igs);
/* verify the DataSource entry */
if (dict_find_string(ICCdict, "DataSource", &pstrmval) <= 0)
return_error(e_undefined);
check_read_file(s, pstrmval);
/* build the color space object */
code = gs_cspace_build_CIEICC(&pcs, NULL, gs_state_memory(igs));
if (code < 0)
return code;
picc_info = pcs->params.icc.picc_info;
picc_info->num_components = ncomps;
picc_info->instrp = s;
picc_info->file_id = (s->read_id | s->write_id);
for (i = 0; i < ncomps; i++) {
picc_info->Range.ranges[i].rmin = range_buff[2 * i];
picc_info->Range.ranges[i].rmax = range_buff[2 * i + 1];
}
/* record the current space as the alternative color space */
pcs->base_space = palt_cs;
rc_increment(palt_cs);
code = gx_load_icc_profile(picc_info);
if (code < 0)
return code;
/* If the input space to this profile is CIELAB, then we need to adjust the limits */
/* See ICC spec ICC.1:2004-10 Section 6.3.4.2 and 6.4 */
if(picc_info->plu->e_inSpace == icSigLabData)
{
picc_info->Range.ranges[0].rmin = 0.0;
picc_info->Range.ranges[0].rmax = 100.0;
picc_info->Range.ranges[1].rmin = -128.0;
picc_info->Range.ranges[1].rmax = 127.0;
picc_info->Range.ranges[2].rmin = -128.0;
picc_info->Range.ranges[2].rmax = 127.0;
}
/* If the input space is icSigXYZData, then we should do the limits based upon the white point of the profile. */
if(picc_info->plu->e_inSpace == icSigXYZData)
{
for (i = 0; i < 3; i++)
{
picc_info->Range.ranges[i].rmin = 0;
}
picc_info->Range.ranges[0].rmax = picc_info->common.points.WhitePoint.u;
picc_info->Range.ranges[1].rmax = picc_info->common.points.WhitePoint.v;
picc_info->Range.ranges[2].rmax = picc_info->common.points.WhitePoint.w;
}
code = cie_cache_joint(i_ctx_p, &istate->colorrendering.procs,
(gs_cie_common *)picc_info, igs);
if (code < 0)
return code;
return cie_set_finish( i_ctx_p,
pcs,
&istate->colorspace.procs.cie,
edepth,
code );
}
/* This opens %statementedit% or %lineedit% and is also the
* continuation proc for callouts.
* Input:
* string is the statement/line buffer,
* int is the write index into string
* bool is true if %statementedit%
* file is stdin
* Output:
* file is a string based stream
* We store the line being read in a PostScript string.
* This limits the size to max_string_size (64k).
* This could be increased by storing the input line in something
* other than a PostScript string.
*/
int
zfilelineedit(i_ctx_t *i_ctx_p)
{
uint count = 0;
bool in_eol = false;
int code;
os_ptr op = osp;
bool statement;
stream *s;
stream *ins;
gs_string str;
uint initial_buf_size;
const char *filename;
/*
* buf exists only for stylistic parallelism: all occurrences of
* buf-> could just as well be str. .
*/
gs_string *const buf = &str;
check_type(*op, t_string); /* line assembled so far */
buf->data = op->value.bytes;
buf->size = op->tas.rsize;
check_type(*(op-1), t_integer); /* index */
count = (op-1)->value.intval;
check_type(*(op-2), t_boolean); /* statementedit/lineedit */
statement = (op-2)->value.boolval;
check_read_file(ins, op - 3); /* %stdin */
/* extend string */
initial_buf_size = statement ? STATEMENTEDIT_BUF_SIZE : LINEEDIT_BUF_SIZE;
if (initial_buf_size > max_string_size)
return_error(e_limitcheck);
if (!buf->data || (buf->size < initial_buf_size)) {
count = 0;
buf->data = gs_alloc_string(imemory_system, initial_buf_size,
"zfilelineedit(buffer)");
if (buf->data == 0)
return_error(e_VMerror);
op->value.bytes = buf->data;
op->tas.rsize = buf->size = initial_buf_size;
}
rd:
code = zreadline_from(ins, buf, imemory_system, &count, &in_eol);
if (buf->size > max_string_size) {
/* zreadline_from reallocated the buffer larger than
* is valid for a PostScript string.
* Return an error, but first realloc the buffer
* back to a legal size.
*/
byte *nbuf = gs_resize_string(imemory_system, buf->data, buf->size,
max_string_size, "zfilelineedit(shrink buffer)");
if (nbuf == 0)
return_error(e_VMerror);
op->value.bytes = buf->data = nbuf;
op->tas.rsize = buf->size = max_string_size;
return_error(e_limitcheck);
}
op->value.bytes = buf->data; /* zreadline_from sometimes resizes the buffer. */
op->tas.rsize = buf->size;
switch (code) {
case EOFC:
code = gs_note_error(e_undefinedfilename);
/* falls through */
case 0:
break;
default:
code = gs_note_error(e_ioerror);
break;
case CALLC:
{
ref rfile;
(op-1)->value.intval = count;
/* callout is for stdin */
make_file(&rfile, a_readonly | avm_system, ins->read_id, ins);
code = s_handle_read_exception(i_ctx_p, code, &rfile,
NULL, 0, zfilelineedit);
}
break;
case 1: /* filled buffer */
{
uint nsize = buf->size;
byte *nbuf;
if (nsize >= max_string_size) {
code = gs_note_error(e_limitcheck);
break;
}
else if (nsize >= max_string_size / 2)
nsize= max_string_size;
else
nsize = buf->size * 2;
nbuf = gs_resize_string(imemory_system, buf->data, buf->size, nsize,
"zfilelineedit(grow buffer)");
if (nbuf == 0) {
code = gs_note_error(e_VMerror);
break;
}
op->value.bytes = buf->data = nbuf;
op->tas.rsize = buf->size = nsize;
goto rd;
}
}
if (code != 0)
return code;
if (statement) {
/* If we don't have a complete token, keep going. */
stream st;
stream *ts = &st;
scanner_state state;
ref ignore_value;
uint depth = ref_stack_count(&o_stack);
int code;
/* Add a terminating EOL. */
if (count + 1 > buf->size) {
uint nsize;
byte *nbuf;
nsize = buf->size + 1;
if (nsize > max_string_size) {
return_error(gs_note_error(e_limitcheck));
}
else {
nbuf = gs_resize_string(imemory_system, buf->data, buf->size, nsize,
"zfilelineedit(grow buffer)");
if (nbuf == 0) {
code = gs_note_error(e_VMerror);
return_error(code);
}
op->value.bytes = buf->data = nbuf;
op->tas.rsize = buf->size = nsize;
}
}
buf->data[count++] = char_EOL;
s_init(ts, NULL);
sread_string(ts, buf->data, count);
sc:
scanner_init_stream_options(&state, ts, SCAN_CHECK_ONLY);
code = scan_token(i_ctx_p, &ignore_value, &state);
ref_stack_pop_to(&o_stack, depth);
if (code < 0)
code = scan_EOF; /* stop on scanner error */
switch (code) {
case 0: /* read a token */
case scan_BOS:
goto sc; /* keep going until we run out of data */
case scan_Refill:
goto rd;
case scan_EOF:
break;
default: /* error */
return code;
}
}
buf->data = gs_resize_string(imemory_system, buf->data, buf->size, count,
"zfilelineedit(resize buffer)");
if (buf->data == 0)
return_error(e_VMerror);
op->value.bytes = buf->data;
op->tas.rsize = buf->size;
s = file_alloc_stream(imemory_system, "zfilelineedit(stream)");
if (s == 0)
return_error(e_VMerror);
sread_string(s, buf->data, count);
s->save_close = s->procs.close;
s->procs.close = file_close_disable;
filename = statement ? gs_iodev_statementedit.dname
: gs_iodev_lineedit.dname;
code = ssetfilename(s, (const byte *)filename, strlen(filename)+1);
if (code < 0) {
sclose(s);
return_error(e_VMerror);
}
pop(3);
make_stream_file(osp, s, "r");
return code;
}
int seticc(i_ctx_t * i_ctx_p, int ncomps, ref *ICCdict, float *range_buff)
{
int code, k;
gs_color_space * pcs;
gs_color_space * palt_cs;
ref * pstrmval;
stream * s = 0L;
cmm_profile_t *picc_profile;
gs_imager_state * pis = (gs_imager_state *)igs;
int i, expected = 0;
ref * pnameval;
static const char *const icc_std_profile_names[] = {
GSICC_STANDARD_PROFILES
};
static const char *const icc_std_profile_keys[] = {
GSICC_STANDARD_PROFILES_KEYS
};
palt_cs = gs_currentcolorspace(igs);
/* verify the DataSource entry */
if (dict_find_string(ICCdict, "DataSource", &pstrmval) <= 0)
return_error(e_undefined);
check_read_file(i_ctx_p, s, pstrmval);
/* build the color space object */
code = gs_cspace_build_ICC(&pcs, NULL, gs_state_memory(igs));
if (code < 0)
return gs_rethrow(code, "building color space object");
/* For now, dump the profile into a buffer
and obtain handle from the buffer when we need it.
We may want to change this later.
This depends to some degree on what the CMS is capable of doing.
I don't want to get bogged down on stream I/O at this point.
Note also, if we are going to be putting these into the clist we will
want to have this buffer. */
/* Check if we have the /Name entry. This is used to associate with
specs that have enumerated types to indicate sRGB sGray etc */
if (dict_find_string(ICCdict, "Name", &pnameval) > 0){
uint size = r_size(pnameval);
char *str = (char *)gs_alloc_bytes(gs_state_memory(igs), size+1, "seticc");
memcpy(str, (const char *)pnameval->value.bytes, size);
str[size] = 0;
/* Compare this to the standard profile names */
picc_profile = NULL;
for (k = 0; k < GSICC_NUMBER_STANDARD_PROFILES; k++) {
if ( strcmp( str, icc_std_profile_keys[k] ) == 0 ) {
picc_profile = gsicc_get_profile_handle_file(icc_std_profile_names[k],
strlen(icc_std_profile_names[k]), gs_state_memory(igs));
break;
}
}
} else {
picc_profile = gsicc_profile_new(s, gs_state_memory(igs), NULL, 0);
}
if (picc_profile == NULL) {
rc_decrement(picc_profile,"seticc");
rc_decrement(pcs,"seticc");
return -1;
}
code = gsicc_set_gscs_profile(pcs, picc_profile, gs_state_memory(igs));
if (code < 0) {
rc_decrement(picc_profile,"seticc");
rc_decrement(pcs,"seticc");
return code;
}
picc_profile->num_comps = ncomps;
/* We have to get the profile handle due to the fact that we need to know
if it has a data space that is CIELAB */
picc_profile->profile_handle =
gsicc_get_profile_handle_buffer(picc_profile->buffer,
picc_profile->buffer_size,
gs_state_memory(igs));
if (picc_profile->profile_handle == NULL) {
/* Free up everything, the profile is not valid. We will end up going
ahead and using a default based upon the number of components */
rc_decrement(picc_profile,"seticc");
rc_decrement(pcs,"seticc");
return -1;
}
picc_profile->data_cs = gscms_get_profile_data_space(picc_profile->profile_handle);
switch( picc_profile->data_cs ) {
case gsCIEXYZ:
case gsCIELAB:
case gsRGB:
expected = 3;
break;
case gsGRAY:
expected = 1;
break;
case gsCMYK:
expected = 4;
break;
case gsNCHANNEL:
case gsNAMED: /* Silence warnings */
case gsUNDEFINED: /* Silence warnings */
break;
}
if (!expected || ncomps != expected) {
rc_decrement(picc_profile,"seticc");
rc_decrement(pcs,"seticc");
return_error(e_rangecheck);
}
/* Lets go ahead and get the hash code and check if we match one of the default spaces */
/* Later we may want to delay this, but for now lets go ahead and do it */
gsicc_init_hash_cs(picc_profile, pis);
/* Set the range according to the data type that is associated with the
ICC input color type. Occasionally, we will run into CIELAB to CIELAB
profiles for spot colors in PDF documents. These spot colors are typically described
as separation colors with tint transforms that go from a tint value
to a linear mapping between the CIELAB white point and the CIELAB tint
color. This results in a CIELAB value that we need to use to fill. We
need to detect this to make sure we do the proper scaling of the data. For
CIELAB images in PDF, the source is always normal 8 or 16 bit encoded data
in the range from 0 to 255 or 0 to 65535. In that case, there should not
be any encoding and decoding to CIELAB. The PDF content will not include
an ICC profile but will set the color space to \Lab. In this case, we use
our seticc_lab operation to install the LAB to LAB profile, but we detect
that we did that through the use of the is_lab flag in the profile descriptor.
When then avoid the CIELAB encode and decode */
if (picc_profile->data_cs == gsCIELAB) {
/* If the input space to this profile is CIELAB, then we need to adjust the limits */
/* See ICC spec ICC.1:2004-10 Section 6.3.4.2 and 6.4. I don't believe we need to
worry about CIEXYZ profiles or any of the other odds ones. Need to check that though
at some point. */
picc_profile->Range.ranges[0].rmin = 0.0;
picc_profile->Range.ranges[0].rmax = 100.0;
picc_profile->Range.ranges[1].rmin = -128.0;
picc_profile->Range.ranges[1].rmax = 127.0;
picc_profile->Range.ranges[2].rmin = -128.0;
picc_profile->Range.ranges[2].rmax = 127.0;
picc_profile->islab = true;
} else {
for (i = 0; i < ncomps; i++) {
picc_profile->Range.ranges[i].rmin = range_buff[2 * i];
picc_profile->Range.ranges[i].rmax = range_buff[2 * i + 1];
}
}
/* Now see if we are in an overide situation. We have to wait until now
in case this is an LAB profile which we will not overide */
if (gs_currentoverrideicc(pis) && picc_profile->data_cs != gsCIELAB) {
/* Free up the profile structure */
switch( picc_profile->data_cs ) {
case gsRGB:
pcs->cmm_icc_profile_data = pis->icc_manager->default_rgb;
break;
case gsGRAY:
pcs->cmm_icc_profile_data = pis->icc_manager->default_gray;
break;
case gsCMYK:
pcs->cmm_icc_profile_data = pis->icc_manager->default_cmyk;
break;
default:
break;
}
/* Have one increment from the color space. Having these tied
together is not really correct. Need to fix that. ToDo. MJV */
rc_adjust(picc_profile, -2, "seticc");
rc_increment(pcs->cmm_icc_profile_data);
}
/* Set the color space. We are done. No joint cache here... */
code = gs_setcolorspace(igs, pcs);
/* The context has taken a reference to the colorspace. We no longer need
* ours, so drop it. */
rc_decrement_only(pcs, "seticc");
/* In this case, we already have a ref count of 2 on the icc profile
one for when it was created and one for when it was set. We really
only want one here so adjust */
rc_decrement(picc_profile,"seticc");
/* Remove the ICC dict from the stack */
pop(1);
return code;
}
static int
zreusablestream(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
os_ptr source_op = op - 1;
long length = max_long;
bool close_source;
int code;
check_type(*op, t_boolean);
close_source = op->value.boolval;
if (r_has_type(source_op, t_string)) {
uint size = r_size(source_op);
check_read(*source_op);
code = make_rss(i_ctx_p, source_op, source_op->value.const_bytes,
size, r_space(source_op), 0L, size, false);
} else if (r_has_type(source_op, t_astruct)) {
uint size = gs_object_size(imemory, source_op->value.pstruct);
if (gs_object_type(imemory, source_op->value.pstruct) != &st_bytes)
return_error(e_rangecheck);
check_read(*source_op);
code = make_rss(i_ctx_p, source_op,
(const byte *)source_op->value.pstruct, size,
r_space(source_op), 0L, size, true);
} else if (r_has_type(source_op, t_array)) { /* no packedarrays */
int i, blk_cnt, blk_sz;
ref *blk_ref;
ulong filelen = 0;
check_read(*source_op);
blk_cnt = r_size(source_op);
blk_ref = source_op->value.refs;
if (blk_cnt > 0) {
blk_sz = r_size(blk_ref);
for (i = 0; i < blk_cnt; i++) {
int len;
check_read_type(blk_ref[i], t_string);
len = r_size(&blk_ref[i]);
if (len > blk_sz || (len < blk_sz && i < blk_cnt - 1))
return_error(e_rangecheck); /* last block can be smaller */
filelen += len;
}
}
if (filelen == 0) {
code = make_rss(i_ctx_p, source_op, (unsigned char *)"", 0,
r_space(source_op), 0, 0, false);
} else {
code = make_aos(i_ctx_p, source_op, blk_sz, r_size(&blk_ref[blk_cnt - 1]), filelen);
}
} else {
long offset = 0;
stream *source;
stream *s;
check_read_file(i_ctx_p, source, source_op);
s = source;
rs:
if (s->cbuf_string.data != 0) { /* string stream */
long pos = stell(s);
long avail = sbufavailable(s) + pos;
offset += pos;
code = make_rss(i_ctx_p, source_op, s->cbuf_string.data,
s->cbuf_string.size,
imemory_space((const gs_ref_memory_t *)s->memory),
offset, min(avail, length), false);
} else if (s->file != 0) { /* file stream */
if (~s->modes & (s_mode_read | s_mode_seek))
return_error(e_ioerror);
code = make_rfs(i_ctx_p, source_op, s, offset + stell(s), length);
} else if (s->state->templat == &s_SFD_template) {
/* SubFileDecode filter */
const stream_SFD_state *const sfd_state =
(const stream_SFD_state *)s->state;
if (sfd_state->eod.size != 0)
return_error(e_rangecheck);
offset += sfd_state->skip_count - sbufavailable(s);
if (sfd_state->count != 0) {
long left = max(sfd_state->count, 0) + sbufavailable(s);
if (left < length)
length = left;
}
s = s->strm;
goto rs;
}
else /* some other kind of stream */
return_error(e_rangecheck);
if (close_source) {
stream *rs = fptr(source_op);
rs->strm = source; /* only for close_source */
rs->close_strm = true;
}
}
if (code >= 0)
pop(1);
return code;
}
/* Collect parameters for a mesh shading. */
static int
build_mesh_shading(i_ctx_t *i_ctx_p, const ref * op,
gs_shading_mesh_params_t * params,
float **pDecode, gs_function_t ** pFunction,
gs_memory_t *mem)
{
int code;
float *data = 0;
ref *pDataSource;
*pDecode = 0;
*pFunction = 0;
if (dict_find_string(op, "DataSource", &pDataSource) <= 0)
return_error(gs_error_rangecheck);
if (r_is_array(pDataSource)) {
uint size = r_size(pDataSource);
data = (float *)gs_alloc_byte_array(mem, size, sizeof(float),
"build_mesh_shading");
if (data == 0)
return_error(gs_error_VMerror);
code = process_float_array(mem, pDataSource, size, data);
if (code < 0) {
gs_free_object(mem, data, "build_mesh_shading");
return code;
}
data_source_init_floats(¶ms->DataSource, data, size);
} else
switch (r_type(pDataSource)) {
case t_file: {
stream *s;
check_read_file(i_ctx_p, s, pDataSource);
data_source_init_stream(¶ms->DataSource, s);
break;
}
case t_string:
check_read(*pDataSource);
data_source_init_string2(¶ms->DataSource,
pDataSource->value.bytes,
r_size(pDataSource));
break;
default:
return_error(gs_error_typecheck);
}
code = build_shading_function(i_ctx_p, op, pFunction, 1, mem, NULL);
if (code < 0) {
gs_free_object(mem, data, "build_mesh_shading");
return code;
}
if (data_source_is_array(params->DataSource)) {
params->BitsPerCoordinate = 0;
params->BitsPerComponent = 0;
} else {
int num_decode = 4 +
(*pFunction != 0 ? 1 :
gs_color_space_num_components(params->ColorSpace)) * 2;
if ((code = dict_int_param(op, "BitsPerCoordinate", 1, 32, 0,
¶ms->BitsPerCoordinate)) >= 0 &&
(code = dict_int_param(op, "BitsPerComponent", 1, 16, 0,
¶ms->BitsPerComponent)) >= 0
) {
*pDecode = (float *)
gs_alloc_byte_array(mem, num_decode, sizeof(float),
"build_mesh_shading");
if (*pDecode == 0)
code = gs_note_error(gs_error_VMerror);
else {
code = dict_floats_param(mem, op, "Decode", num_decode, *pDecode, NULL);
if (code < 0) {
gs_free_object(mem, *pDecode, "build_mesh_shading");
*pDecode = 0;
}
}
}
}
if (code < 0) {
if (*pFunction != 0) {
gs_function_free(*pFunction, true, mem);
*pFunction = 0;
}
gs_free_object(mem, data, "build_mesh_shading");
}
return code;
}
