// Check colorspace
static
cmsBool IsProperColorSpace(cmsColorSpaceSignature Check, cmsUInt32Number dwFormat)
{
int Space1 = T_COLORSPACE(dwFormat);
int Space2 = _cmsLCMScolorSpace(Check);
if (Space1 == PT_ANY) return TRUE;
if (Space1 == Space2) return TRUE;
if (Space1 == PT_LabV2 && Space2 == PT_Lab) return TRUE;
if (Space1 == PT_Lab && Space2 == PT_LabV2) return TRUE;
return FALSE;
}
/* Transform an entire buffer */
void
gscms_transform_color_buffer(gsicc_link_t *icclink,
gsicc_bufferdesc_t *input_buff_desc,
gsicc_bufferdesc_t *output_buff_desc,
void *inputbuffer,
void *outputbuffer)
{
cmsHTRANSFORM hTransform = (cmsHTRANSFORM) icclink->link_handle;
DWORD dwInputFormat,dwOutputFormat,curr_input,curr_output;
int planar,numbytes,big_endian,hasalpha,k;
unsigned char *inputpos, *outputpos;
int numchannels;
#if DUMP_CMS_BUFFER
FILE *fid_in, *fid_out;
#endif
/* Although little CMS does make assumptions about data types in its
transformations you can change it after the fact. */
/* Set us to the proper output type */
/* Note, we could speed this up by passing back the encoded data type
to the caller so that we could avoid having to go through this
computation each time if they are doing multiple calls to this
operation */
_LPcmsTRANSFORM p = (_LPcmsTRANSFORM) (LPSTR) hTransform;
curr_input = p->InputFormat;
curr_output = p->OutputFormat;
/* Color space MUST be the same */
dwInputFormat = COLORSPACE_SH(T_COLORSPACE(curr_input));
dwOutputFormat = COLORSPACE_SH(T_COLORSPACE(curr_output));
/* Now set if we have planar, num bytes, endian case, and alpha data to skip */
/* Planar -- pdf14 case for example */
planar = input_buff_desc->is_planar;
dwInputFormat = dwInputFormat | PLANAR_SH(planar);
planar = output_buff_desc->is_planar;
dwOutputFormat = dwOutputFormat | PLANAR_SH(planar);
/* 8 or 16 byte input and output */
numbytes = input_buff_desc->bytes_per_chan;
if (numbytes>2) numbytes = 0; /* littleCMS encodes float with 0 ToDO. */
dwInputFormat = dwInputFormat | BYTES_SH(numbytes);
numbytes = output_buff_desc->bytes_per_chan;
if (numbytes>2) numbytes = 0;
dwOutputFormat = dwOutputFormat | BYTES_SH(numbytes);
/* endian */
big_endian = !input_buff_desc->little_endian;
dwInputFormat = dwInputFormat | ENDIAN16_SH(big_endian);
big_endian = !output_buff_desc->little_endian;
dwOutputFormat = dwOutputFormat | ENDIAN16_SH(big_endian);
/* number of channels */
numchannels = input_buff_desc->num_chan;
dwInputFormat = dwInputFormat | CHANNELS_SH(numchannels);
numchannels = output_buff_desc->num_chan;
dwOutputFormat = dwOutputFormat | CHANNELS_SH(numchannels);
/* alpha, which is passed through unmolested */
/* ToDo: Right now we always must have alpha last */
/* This is really only going to be an issue when we have
interleaved alpha data */
hasalpha = input_buff_desc->has_alpha;
dwInputFormat = dwInputFormat | EXTRA_SH(hasalpha);
dwOutputFormat = dwOutputFormat | EXTRA_SH(hasalpha);
/* Change the formaters */
cmsChangeBuffersFormat(hTransform,dwInputFormat,dwOutputFormat);
/* littleCMS knows nothing about word boundarys. As such, we need to do
this row by row adjusting for our stride. Output buffer must already
be allocated. ToDo: Check issues with plane and row stride and word
boundry */
inputpos = (unsigned char *) inputbuffer;
outputpos = (unsigned char *) outputbuffer;
if(input_buff_desc->is_planar){
/* Do entire buffer. Care must be taken here
with respect to row stride, word boundry and number
of source versus output channels. We may
need to take a closer look at this. */
cmsDoTransform(hTransform,inputpos,outputpos,
input_buff_desc->plane_stride);
} else {
/* Do row by row. */
for(k = 0; k < input_buff_desc->num_rows ; k++){
cmsDoTransform(hTransform,inputpos,outputpos,
input_buff_desc->pixels_per_row);
inputpos += input_buff_desc->row_stride;
outputpos += output_buff_desc->row_stride;
}
}
#if DUMP_CMS_BUFFER
fid_in = fopen("CM_Input.raw","ab");
fid_out = fopen("CM_Output.raw","ab");
fwrite((unsigned char*) inputbuffer,sizeof(unsigned char),
input_buff_desc->row_stride,fid_in);
fwrite((unsigned char*) outputbuffer,sizeof(unsigned char),
output_buff_desc->row_stride,fid_out);
fclose(fid_in);
fclose(fid_out);
#endif
}
static
int TransformImage(char *cDefInpProf, char *cOutProf)
{
cmsHPROFILE hIn, hOut, hProof;
cmsHTRANSFORM xform;
cmsUInt32Number wInput, wOutput;
int OutputColorSpace;
cmsUInt32Number dwFlags = 0;
cmsUInt32Number EmbedLen;
cmsUInt8Number* EmbedBuffer;
cmsSetAdaptationState(ObserverAdaptationState);
if (BlackPointCompensation) {
dwFlags |= cmsFLAGS_BLACKPOINTCOMPENSATION;
}
switch (PrecalcMode) {
case 0: dwFlags |= cmsFLAGS_NOOPTIMIZE; break;
case 2: dwFlags |= cmsFLAGS_HIGHRESPRECALC; break;
case 3: dwFlags |= cmsFLAGS_LOWRESPRECALC; break;
default:;
}
if (GamutCheck) {
dwFlags |= cmsFLAGS_GAMUTCHECK;
cmsSetAlarmCodes(Alarm);
}
// Take input color space
wInput = GetInputPixelType();
if (lIsDeviceLink) {
hIn = cmsOpenProfileFromFile(cDefInpProf, "r");
hOut = NULL;
hProof = NULL;
}
else {
if (!IgnoreEmbedded && read_icc_profile(&Decompressor, &EmbedBuffer, &EmbedLen))
{
hIn = cmsOpenProfileFromMem(EmbedBuffer, EmbedLen);
if (Verbose) {
fprintf(stdout, " (Embedded profile found)\n");
PrintProfileInformation(hIn);
fflush(stdout);
}
if (hIn != NULL && SaveEmbedded != NULL)
SaveMemoryBlock(EmbedBuffer, EmbedLen, SaveEmbedded);
free(EmbedBuffer);
}
else
{
// Default for ITU/Fax
if (cDefInpProf == NULL && T_COLORSPACE(wInput) == PT_Lab)
cDefInpProf = "*Lab";
if (cDefInpProf != NULL && cmsstrcasecmp(cDefInpProf, "*lab") == 0)
hIn = CreateITU2PCS_ICC();
else
hIn = OpenStockProfile(0, cDefInpProf);
}
if (cOutProf != NULL && cmsstrcasecmp(cOutProf, "*lab") == 0)
hOut = CreatePCS2ITU_ICC();
else
hOut = OpenStockProfile(0, cOutProf);
hProof = NULL;
if (cProofing != NULL) {
hProof = OpenStockProfile(0, cProofing);
if (hProof == NULL) {
FatalError("Proofing profile couldn't be read.");
}
dwFlags |= cmsFLAGS_SOFTPROOFING;
}
}
if (!hIn)
FatalError("Input profile couldn't be read.");
if (!hOut)
FatalError("Output profile couldn't be read.");
// Assure both, input profile and input JPEG are on same colorspace
if (cmsGetColorSpace(hIn) != _cmsICCcolorSpace(T_COLORSPACE(wInput)))
FatalError("Input profile is not operating in proper color space");
// Output colorspace is given by output profile
if (lIsDeviceLink) {
OutputColorSpace = GetDevicelinkColorSpace(hIn);
}
else {
OutputColorSpace = GetProfileColorSpace(hOut);
}
jpeg_copy_critical_parameters(&Decompressor, &Compressor);
WriteOutputFields(OutputColorSpace);
wOutput = ComputeOutputFormatDescriptor(wInput, OutputColorSpace);
xform = cmsCreateProofingTransform(hIn, wInput,
hOut, wOutput,
hProof, Intent,
ProofingIntent, dwFlags);
if (xform == NULL)
FatalError("Cannot transform by using the profiles");
DoTransform(xform, OutputColorSpace);
jcopy_markers_execute(&Decompressor, &Compressor);
cmsDeleteTransform(xform);
cmsCloseProfile(hIn);
cmsCloseProfile(hOut);
if (hProof) cmsCloseProfile(hProof);
return 1;
}
static
int TransformImage(TIFF* in, TIFF* out, const char *cDefInpProf, const char *cOutProf)
{
cmsHPROFILE hIn, hOut, hProof, hInkLimit = NULL;
cmsHTRANSFORM xform;
DWORD wInput, wOutput;
int OutputColorSpace;
int bps = (Width16 ? 2 : 1);
DWORD dwFlags = 0;
int nPlanes;
// Observer adaptation state (only meaningful on absolute colorimetric intent)
cmsSetAdaptationState(ObserverAdaptationState);
if (EmbedProfile && cOutProf)
DoEmbedProfile(out, cOutProf);
if (BlackWhiteCompensation)
dwFlags |= cmsFLAGS_WHITEBLACKCOMPENSATION;
if (PreserveBlack) {
dwFlags |= cmsFLAGS_PRESERVEBLACK;
if (PrecalcMode == 0) PrecalcMode = 1;
}
switch (PrecalcMode) {
case 0: dwFlags |= cmsFLAGS_NOTPRECALC; break;
case 2: dwFlags |= cmsFLAGS_HIGHRESPRECALC; break;
case 3: dwFlags |= cmsFLAGS_LOWRESPRECALC; break;
case 1: break;
default: FatalError("Unknown precalculation mode '%d'", PrecalcMode);
}
if (GamutCheck)
dwFlags |= cmsFLAGS_GAMUTCHECK;
hProof = NULL;
hOut = NULL;
if (lIsDeviceLink) {
hIn = cmsOpenProfileFromFile(cDefInpProf, "r");
}
else {
hIn = GetTIFFProfile(in);
if (hIn == NULL)
hIn = OpenStockProfile(cDefInpProf);
hOut = OpenStockProfile(cOutProf);
if (cProofing != NULL) {
hProof = OpenStockProfile(cProofing);
dwFlags |= cmsFLAGS_SOFTPROOFING;
}
}
// Take input color space
wInput = GetInputPixelType(in);
// Assure both, input profile and input TIFF are on same colorspace
if (_cmsLCMScolorSpace(cmsGetColorSpace(hIn)) != (int) T_COLORSPACE(wInput))
FatalError("Input profile is not operating in proper color space");
if (!lIsDeviceLink)
OutputColorSpace = _cmsLCMScolorSpace(cmsGetColorSpace(hOut));
else
OutputColorSpace = _cmsLCMScolorSpace(cmsGetPCS(hIn));
wOutput = ComputeOutputFormatDescriptor(wInput, OutputColorSpace, bps);
WriteOutputTags(out, OutputColorSpace, bps);
CopyOtherTags(in, out);
// Ink limit
if (InkLimit != 400.0 &&
(OutputColorSpace == PT_CMYK || OutputColorSpace == PT_CMY)) {
cmsHPROFILE hProfiles[10];
int nProfiles = 0;
hInkLimit = cmsCreateInkLimitingDeviceLink(cmsGetColorSpace(hOut), InkLimit);
hProfiles[nProfiles++] = hIn;
if (hProof) {
hProfiles[nProfiles++] = hProof;
hProfiles[nProfiles++] = hProof;
}
hProfiles[nProfiles++] = hOut;
hProfiles[nProfiles++] = hInkLimit;
xform = cmsCreateMultiprofileTransform(hProfiles, nProfiles,
wInput, wOutput, Intent, dwFlags);
}
else {
xform = cmsCreateProofingTransform(hIn, wInput,
hOut, wOutput,
hProof, Intent,
ProofingIntent,
dwFlags);
}
// Planar stuff
if (T_PLANAR(wInput))
nPlanes = T_CHANNELS(wInput) + T_EXTRA(wInput);
else
nPlanes = 1;
// TIFF Lab of 8 bits need special handling
if (wInput == TYPE_Lab_8 &&
!InputLabUsingICC &&
cInpProf != NULL &&
stricmp(cInpProf, "*Lab") == 0) {
cmsSetUserFormatters(xform, TYPE_Lab_8, UnrollTIFFLab8, TYPE_Lab_8, NULL);
}
if (wOutput == TYPE_Lab_8 &&
cOutProf != NULL &&
stricmp(cOutProf, "*Lab") == 0) {
cmsSetUserFormatters(xform, TYPE_Lab_8, NULL, TYPE_Lab_8, PackTIFFLab8);
}
// Handle tile by tile or strip by strip
if (TIFFIsTiled(in)) {
TileBasedXform(xform, in, out, nPlanes);
}
else {
StripBasedXform(xform, in, out, nPlanes);
}
cmsDeleteTransform(xform);
cmsCloseProfile(hIn);
cmsCloseProfile(hOut);
if (hInkLimit)
cmsCloseProfile(hInkLimit);
if (hProof)
cmsCloseProfile(hProof);
TIFFWriteDirectory(out);
return 1;
}
static
int TransformImage(char *cDefInpProf, char *cOutProf)
{
cmsHPROFILE hIn, hOut, hProof;
cmsHTRANSFORM xform;
DWORD wInput, wOutput;
int OutputColorSpace;
DWORD dwFlags = 0;
DWORD EmbedLen;
LPBYTE EmbedBuffer;
if (BlackPointCompensation) {
dwFlags |= cmsFLAGS_BLACKPOINTCOMPENSATION;
}
switch (PrecalcMode) {
case 0: dwFlags |= cmsFLAGS_NOTPRECALC; break;
case 2: dwFlags |= cmsFLAGS_HIGHRESPRECALC; break;
case 3: dwFlags |= cmsFLAGS_LOWRESPRECALC; break;
default:;
}
if (GamutCheck)
dwFlags |= cmsFLAGS_GAMUTCHECK;
if (lIsDeviceLink) {
hIn = cmsOpenProfileFromFile(cDefInpProf, "r");
hOut = NULL;
hProof = NULL;
}
else {
if (!IgnoreEmbedded && read_icc_profile(&Decompressor, &EmbedBuffer, &EmbedLen))
{
hIn = cmsOpenProfileFromMem(EmbedBuffer, EmbedLen);
if (Verbose) {
fprintf(stdout, " (Embedded profile found)\n");
fprintf(stdout, "Product name: %s\n", cmsTakeProductName(hIn));
fprintf(stdout, "Description : %s\n", cmsTakeProductDesc(hIn));
fflush(stdout);
}
if (hIn != NULL && SaveEmbedded != NULL)
SaveMemoryBlock(EmbedBuffer, EmbedLen, SaveEmbedded);
free(EmbedBuffer);
}
else
{
hIn = OpenStockProfile(cDefInpProf);
}
hOut = OpenStockProfile(cOutProf);
hProof = NULL;
if (cProofing != NULL) {
hProof = OpenStockProfile(cProofing);
}
}
// Take input color space
wInput = GetInputPixelType();
// Assure both, input profile and input JPEG are on same colorspace
if (cmsGetColorSpace(hIn) != _cmsICCcolorSpace(T_COLORSPACE(wInput)))
FatalError("Input profile is not operating in proper color space");
// Output colorspace is given by output profile
if (lIsDeviceLink) {
OutputColorSpace = T_COLORSPACE(wInput);
}
else {
OutputColorSpace = GetProfileColorSpace(hOut);
}
jpeg_copy_critical_parameters(&Decompressor, &Compressor);
WriteOutputFields(OutputColorSpace);
wOutput = ComputeOutputFormatDescriptor(wInput, OutputColorSpace);
xform = cmsCreateProofingTransform(hIn, wInput,
hOut, wOutput,
hProof, Intent,
ProofingIntent, dwFlags);
// Handle tile by tile or strip by strip strtok
DoTransform(xform);
jcopy_markers_execute(&Decompressor, &Compressor);
cmsDeleteTransform(xform);
cmsCloseProfile(hIn);
cmsCloseProfile(hOut);
if (hProof) cmsCloseProfile(hProof);
return 1;
}
/* Transform an entire buffer */
void
gscms_transform_color_buffer(gx_device *dev, gsicc_link_t *icclink,
gsicc_bufferdesc_t *input_buff_desc,
gsicc_bufferdesc_t *output_buff_desc,
void *inputbuffer,
void *outputbuffer)
{
cmsHTRANSFORM hTransform = (cmsHTRANSFORM)icclink->link_handle;
cmsUInt32Number dwInputFormat, dwOutputFormat, num_src_lcms, num_des_lcms;
int planar,numbytes, big_endian, hasalpha, k;
unsigned char *inputpos, *outputpos;
#if DUMP_CMS_BUFFER
FILE *fid_in, *fid_out;
#endif
/* Although little CMS does make assumptions about data types in its
transformations you can change it after the fact. */
/* Set us to the proper output type */
/* Note, we could speed this up by passing back the encoded data type
to the caller so that we could avoid having to go through this
computation each time if they are doing multiple calls to this
operation */
/* Color space MUST be the same */
dwInputFormat = COLORSPACE_SH(T_COLORSPACE(cmsGetTransformInputFormat(hTransform)));
dwOutputFormat = COLORSPACE_SH(T_COLORSPACE(cmsGetTransformOutputFormat(hTransform)));
/* Now set if we have planar, num bytes, endian case, and alpha data to skip */
/* Planar -- pdf14 case for example */
planar = input_buff_desc->is_planar;
dwInputFormat = dwInputFormat | PLANAR_SH(planar);
planar = output_buff_desc->is_planar;
dwOutputFormat = dwOutputFormat | PLANAR_SH(planar);
/* 8 or 16 byte input and output */
numbytes = input_buff_desc->bytes_per_chan;
if (numbytes>2) numbytes = 0; /* littleCMS encodes float with 0 ToDO. */
dwInputFormat = dwInputFormat | BYTES_SH(numbytes);
numbytes = output_buff_desc->bytes_per_chan;
if (numbytes>2) numbytes = 0;
dwOutputFormat = dwOutputFormat | BYTES_SH(numbytes);
/* endian */
big_endian = !input_buff_desc->little_endian;
dwInputFormat = dwInputFormat | ENDIAN16_SH(big_endian);
big_endian = !output_buff_desc->little_endian;
dwOutputFormat = dwOutputFormat | ENDIAN16_SH(big_endian);
/* number of channels. This should not really be changing! */
num_src_lcms = T_CHANNELS(cmsGetTransformInputFormat(hTransform));
num_des_lcms = T_CHANNELS(cmsGetTransformOutputFormat(hTransform));
if (num_src_lcms != input_buff_desc->num_chan ||
num_des_lcms != output_buff_desc->num_chan) {
/* We can't transform this. Someone is doing something odd */
return;
}
dwInputFormat = dwInputFormat | CHANNELS_SH(num_src_lcms);
dwOutputFormat = dwOutputFormat | CHANNELS_SH(num_des_lcms);
/* alpha, which is passed through unmolested */
/* ToDo: Right now we always must have alpha last */
/* This is really only going to be an issue when we have
interleaved alpha data */
hasalpha = input_buff_desc->has_alpha;
dwInputFormat = dwInputFormat | EXTRA_SH(hasalpha);
dwOutputFormat = dwOutputFormat | EXTRA_SH(hasalpha);
/* Change the formatters */
cmsChangeBuffersFormat(hTransform,dwInputFormat,dwOutputFormat);
/* littleCMS knows nothing about word boundarys. As such, we need to do
this row by row adjusting for our stride. Output buffer must already
be allocated. ToDo: Check issues with plane and row stride and word
boundry */
inputpos = (byte *) inputbuffer;
outputpos = (byte *) outputbuffer;
if(input_buff_desc->is_planar) {
/* Determine if we can do this in one operation or if we have to break
it up. Essentially if the width * height = plane_stride then yes. If
we are doing some subsection of a plane then no. */
if (input_buff_desc->num_rows * input_buff_desc->pixels_per_row ==
input_buff_desc->plane_stride &&
output_buff_desc->num_rows * output_buff_desc->pixels_per_row ==
output_buff_desc->plane_stride) {
/* Do entire buffer.*/
cmsDoTransform(hTransform, inputpos, outputpos,
input_buff_desc->plane_stride);
} else {
/* We have to do this row by row, with memory transfers */
byte *temp_des, *temp_src;
int source_size = input_buff_desc->bytes_per_chan *
input_buff_desc->pixels_per_row;
int des_size = output_buff_desc->bytes_per_chan *
output_buff_desc->pixels_per_row;
int y, i;
temp_src = (byte*) gs_alloc_bytes(icclink->icc_link_cache->memory,
source_size * input_buff_desc->num_chan,
"gscms_transform_color_buffer");
if (temp_src == NULL)
return;
temp_des = (byte*) gs_alloc_bytes(icclink->icc_link_cache->memory,
des_size * output_buff_desc->num_chan,
"gscms_transform_color_buffer");
if (temp_des == NULL)
return;
for (y = 0; y < input_buff_desc->num_rows; y++) {
byte *src_cm = temp_src;
byte *src_buff = inputpos;
byte *des_cm = temp_des;
byte *des_buff = outputpos;
/* Put into planar temp buffer */
for (i = 0; i < input_buff_desc->num_chan; i ++) {
memcpy(src_cm, src_buff, source_size);
src_cm += source_size;
src_buff += input_buff_desc->plane_stride;
}
/* Transform */
cmsDoTransform(hTransform, temp_src, temp_des,
input_buff_desc->pixels_per_row);
/* Get out of temp planar buffer */
for (i = 0; i < output_buff_desc->num_chan; i ++) {
memcpy(des_buff, des_cm, des_size);
des_cm += des_size;
des_buff += output_buff_desc->plane_stride;
}
inputpos += input_buff_desc->row_stride;
outputpos += output_buff_desc->row_stride;
}
gs_free_object(icclink->icc_link_cache->memory, temp_src,
"gscms_transform_color_buffer");
gs_free_object(icclink->icc_link_cache->memory, temp_des,
"gscms_transform_color_buffer");
}
} else {
/* Do row by row. */
for(k = 0; k < input_buff_desc->num_rows ; k++) {
cmsDoTransform(hTransform, inputpos, outputpos,
input_buff_desc->pixels_per_row);
inputpos += input_buff_desc->row_stride;
outputpos += output_buff_desc->row_stride;
}
}
#if DUMP_CMS_BUFFER
fid_in = gp_fopen("CM_Input.raw","ab");
fid_out = gp_fopen("CM_Output.raw","ab");
fwrite((unsigned char*) inputbuffer,sizeof(unsigned char),
input_buff_desc->row_stride,fid_in);
fwrite((unsigned char*) outputbuffer,sizeof(unsigned char),
output_buff_desc->row_stride,fid_out);
fclose(fid_in);
fclose(fid_out);
#endif
}
