/* * <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; }
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; }
gsicc_link_t* gsicc_get_link_profile(gs_imager_state *pis, gx_device *dev, cmm_profile_t *gs_input_profile, cmm_profile_t *gs_output_profile, gsicc_rendering_param_t *rendering_params, gs_memory_t *memory, bool include_softproof) { gsicc_hashlink_t hash; gsicc_link_t *link, *found_link; gcmmhlink_t link_handle = NULL; void **contextptr = NULL; gsicc_manager_t *icc_manager = pis->icc_manager; gsicc_link_cache_t *icc_link_cache = pis->icc_link_cache; gs_memory_t *cache_mem = pis->icc_link_cache->memory; gcmmhprofile_t *cms_input_profile; gcmmhprofile_t *cms_output_profile; /* First compute the hash code for the incoming case */ /* If the output color space is NULL we will use the device profile for the output color space */ gsicc_compute_linkhash(icc_manager, dev, gs_input_profile, gs_output_profile, rendering_params, &hash); /* Check the cache for a hit. Need to check if softproofing was used */ found_link = gsicc_findcachelink(hash, icc_link_cache, include_softproof); /* Got a hit, return link (ref_count for the link was already bumped */ if (found_link != NULL) return(found_link); /* TO FIX: We are really not going to want to have the members of this object visible outside gsiccmange */ /* If not, then lets create a new one if there is room or return NULL */ /* Caller will need to try later */ /* First see if we can add a link */ /* TODO: this should be based on memory usage, not just num_links */ gx_monitor_enter(icc_link_cache->lock); while (icc_link_cache->num_links >= ICC_CACHE_MAXLINKS) { /* If not, see if there is anything we can remove from cache. */ while ((link = gsicc_find_zeroref_cache(icc_link_cache)) == NULL) { icc_link_cache->num_waiting++; /* safe to unlock since above will make sure semaphore is signalled */ gx_monitor_leave(icc_link_cache->lock); /* we get signalled (released from wait) when a link goes to zero ref */ gx_semaphore_wait(icc_link_cache->wait); /* repeat the findcachelink to see if some other thread has */ /*already started building the link we need */ found_link = gsicc_findcachelink(hash, icc_link_cache, include_softproof); /* Got a hit, return link (ref_count for the link was already bumped */ if (found_link != NULL) return(found_link); /* TO FIX: We are really not going to want to have the members of this object visible outside gsiccmange */ gx_monitor_enter(icc_link_cache->lock); /* restore the lock */ /* we will re-test the num_links above while locked to insure */ /* that some other thread didn't grab the slot and max us out */ } /* Remove the zero ref_count link profile we found. */ /* Even if we remove this link, we may still be maxed out so */ /* the outermost 'while' will check to make sure some other */ /* thread did not grab the one we remove. */ gsicc_remove_link(link, cache_mem); icc_link_cache->num_links--; } /* insert an empty link that we will reserve so we */ /* can unlock while building the link contents */ link = gsicc_alloc_link(cache_mem->stable_memory, hash); link->icc_link_cache = icc_link_cache; link->next = icc_link_cache->head; icc_link_cache->head = link; icc_link_cache->num_links++; gx_monitor_leave(icc_link_cache->lock); /* now that we own this link we can release */ /* the lock since it is not valid */ /* Now compute the link contents */ cms_input_profile = gs_input_profile->profile_handle; if (cms_input_profile == NULL) { if (gs_input_profile->buffer != NULL) { cms_input_profile = gsicc_get_profile_handle_buffer(gs_input_profile->buffer, gs_input_profile->buffer_size); gs_input_profile->profile_handle = cms_input_profile; } else { /* See if we have a clist device pointer. */ if ( gs_input_profile->dev != NULL ) { /* ICC profile should be in clist. This is the first call to it. Note that the profiles are not really shared amongst threads like the links are. Hence the memory is for the local thread's chunk */ cms_input_profile = gsicc_get_profile_handle_clist(gs_input_profile, gs_input_profile->memory); gs_input_profile->profile_handle = cms_input_profile; } else { /* Cant create the link. No profile present, nor any defaults to use for this. Really need to throw an error for this case. */ gsicc_remove_link(link, cache_mem); icc_link_cache->num_links--; return(NULL); } } } cms_output_profile = gs_output_profile->profile_handle; if (cms_output_profile == NULL) { if (gs_output_profile->buffer != NULL) { cms_input_profile = gsicc_get_profile_handle_buffer(gs_input_profile->buffer, gs_input_profile->buffer_size); gs_output_profile->profile_handle = cms_output_profile; } else { /* See if we have a clist device pointer. */ if ( gs_output_profile->dev != NULL ) { /* ICC profile should be in clist. This is the first call to it. */ cms_output_profile = gsicc_get_profile_handle_clist(gs_output_profile, gs_output_profile->memory); gs_output_profile->profile_handle = cms_output_profile; } else { /* Cant create the link. No profile present, nor any defaults to use for this. Really need to throw an error for this case. */ gsicc_remove_link(link, cache_mem); icc_link_cache->num_links--; return(NULL); } } } link_handle = gscms_get_link(cms_input_profile, cms_output_profile, rendering_params); if (link_handle != NULL) { gsicc_set_link_data(link, link_handle, contextptr, hash, icc_link_cache->lock); } else { gsicc_remove_link(link, cache_mem); icc_link_cache->num_links--; return(NULL); } return(link); }