static cmsHTRANSFORM
_buildProofTransform(cmsHPROFILE hInputProfile, cmsHPROFILE hOutputProfile, cmsHPROFILE hProofProfile, char *sInMode, char *sOutMode, int iRenderingIntent, int iProofIntent, DWORD cmsFLAGS)
{
cmsHTRANSFORM hTransform;
cmsErrorAction(LCMS_ERROR_IGNORE);
Py_BEGIN_ALLOW_THREADS
/* create the transform */
hTransform = cmsCreateProofingTransform(hInputProfile,
findLCMStype(sInMode),
hOutputProfile,
findLCMStype(sOutMode),
hProofProfile,
iRenderingIntent,
iProofIntent,
cmsFLAGS);
Py_END_ALLOW_THREADS
if (!hTransform)
PyErr_SetString(PyExc_ValueError, "cannot build proof transform");
return hTransform; /* if NULL, an exception is set */
}
/* Get the link from the CMS, but include proofing.
We need to note that as an option in the rendering params. If we are doing
transparency, that would only occur at the top of the stack
TODO: Add error checking */
gcmmhlink_t
gscms_get_link_proof(gcmmhprofile_t lcms_srchandle,
gcmmhprofile_t lcms_deshandle, gcmmhprofile_t lcms_proofhandle,
gsicc_rendering_param_t *rendering_params)
{
DWORD src_data_type,des_data_type;
icColorSpaceSignature src_color_space,des_color_space;
int src_nChannels,des_nChannels;
/* Get the data types */
src_color_space = cmsGetColorSpace(lcms_srchandle);
des_color_space = cmsGetColorSpace(lcms_deshandle);
src_nChannels = _cmsChannelsOf(src_color_space);
des_nChannels = _cmsChannelsOf(des_color_space);
/* For now, just do single byte data, interleaved. We can change this when we
use the transformation. */
src_data_type= (CHANNELS_SH(src_nChannels)|BYTES_SH(1));
des_data_type= (CHANNELS_SH(des_nChannels)|BYTES_SH(1));
/* Create the link. Note the gamut check alarm */
return(cmsCreateProofingTransform(lcms_srchandle, src_data_type,
lcms_deshandle, des_data_type,
lcms_proofhandle,
rendering_params->rendering_intent,
INTENT_ABSOLUTE_COLORIMETRIC,
cmsFLAGS_GAMUTCHECK | cmsFLAGS_SOFTPROOFING ));
}
JNIEXPORT jlong JNICALL Java_com_lightcrafts_utils_LCMS_cmsCreateProofingTransform
(JNIEnv *env, jclass clazz, jlong inputProfile, jint inputFormat,
jlong outputProfile, jint outputFormat, jlong proofingProfile,
jint intent, jint proofingIntent, jint flags)
{
return (jlong)(intptr_t) cmsCreateProofingTransform((cmsHPROFILE)(intptr_t) inputProfile, inputFormat,
(cmsHPROFILE)(intptr_t) outputProfile, outputFormat,
(cmsHPROFILE)(intptr_t) proofingProfile,
intent, proofingIntent, flags);
}
/******************************************************************************
* CreateColorTransformW [MSCMS.@]
*
* Create a color transform.
*
* PARAMS
* space [I] Input color space.
* dest [I] Color profile of destination device.
* target [I] Color profile of target device.
* flags [I] Flags.
*
* RETURNS
* Success: Handle to a transform.
* Failure: NULL
*/
HTRANSFORM WINAPI CreateColorTransformW( LPLOGCOLORSPACEW space, HPROFILE dest,
HPROFILE target, DWORD flags )
{
HTRANSFORM ret = NULL;
#ifdef HAVE_LCMS2
struct transform transform;
struct profile *dst, *tgt = NULL;
cmsHPROFILE cmsinput, cmsoutput, cmstarget = NULL;
DWORD proofing = 0;
int intent;
TRACE( "( %p, %p, %p, 0x%08x )\n", space, dest, target, flags );
if (!space || !(dst = grab_profile( dest ))) return FALSE;
if (target && !(tgt = grab_profile( target )))
{
release_profile( dst );
return FALSE;
}
intent = space->lcsIntent > 3 ? INTENT_PERCEPTUAL : space->lcsIntent;
TRACE( "lcsIntent: %x\n", space->lcsIntent );
TRACE( "lcsCSType: %s\n", dbgstr_tag( space->lcsCSType ) );
TRACE( "lcsFilename: %s\n", debugstr_w( space->lcsFilename ) );
cmsinput = cmsCreate_sRGBProfile(); /* FIXME: create from supplied color space */
if (target)
{
proofing = cmsFLAGS_SOFTPROOFING;
cmstarget = tgt->cmsprofile;
}
cmsoutput = dst->cmsprofile;
transform.cmstransform = cmsCreateProofingTransform(cmsinput, 0, cmsoutput, 0, cmstarget,
intent, INTENT_ABSOLUTE_COLORIMETRIC,
proofing);
if (!transform.cmstransform)
{
if (tgt) release_profile( tgt );
release_profile( dst );
return FALSE;
}
ret = create_transform( &transform );
if (tgt) release_profile( tgt );
release_profile( dst );
#endif /* HAVE_LCMS2 */
return ret;
}
cmsHTRANSFORM dkCmsCreateProofingTransform(cmsHPROFILE Input,
DWORD InputFormat,
cmsHPROFILE Output,
DWORD OutputFormat,
cmsHPROFILE Proofing,
int Intent,
int ProofingIntent,
DWORD dwFlags)
{
return cmsCreateProofingTransform(Input,
static_cast<cmsUInt32Number>( InputFormat ),
static_cast<cmsHPROFILE>( Output ),
static_cast<cmsUInt32Number>( OutputFormat ),
Proofing,
static_cast<cmsUInt32Number>( Intent ),
static_cast<cmsUInt32Number>( ProofingIntent ),
static_cast<cmsUInt32Number>( dwFlags ));
}
/* Create a link to return device values inside the named color profile or link
it with a destination profile and potentially a proofing profile. If the
output_colorspace and the proof_color space are NULL, then we will be
returning the device values that are contained in the named color profile.
i.e. in namedcolor_information. Note that an ICC named color profile
need NOT contain the device values but must contain the CIELAB values. */
void
gscms_get_name2device_link(gsicc_link_t *icclink, gcmmhprofile_t lcms_srchandle,
gcmmhprofile_t lcms_deshandle, gcmmhprofile_t lcms_proofhandle,
gsicc_rendering_param_t *rendering_params)
{
cmsHPROFILE hTransform;
_LPcmsTRANSFORM p;
DWORD dwOutputFormat;
DWORD lcms_proof_flag;
int number_colors;
/* NOTE: We need to add a test here to check that we even HAVE
device values in here and NOT just CIELAB values */
if ( lcms_proofhandle != NULL ){
lcms_proof_flag = cmsFLAGS_GAMUTCHECK | cmsFLAGS_SOFTPROOFING;
} else {
lcms_proof_flag = 0;
}
/* Create the transform */
/* ToDo: Adjust rendering intent */
hTransform = cmsCreateProofingTransform(lcms_srchandle, TYPE_NAMED_COLOR_INDEX,
lcms_deshandle, TYPE_CMYK_8,
lcms_proofhandle,INTENT_PERCEPTUAL,
INTENT_ABSOLUTE_COLORIMETRIC,
lcms_proof_flag);
/* In littleCMS there is no easy way to find out the size of the device
space returned by the named color profile until after the transform is made.
Hence we adjust our output format after creating the transform. It is
set to CMYK8 initially. */
p = (_LPcmsTRANSFORM) hTransform;
number_colors = p->NamedColorList->ColorantCount;
/* NOTE: Output size of gx_color_value with no color space type check */
dwOutputFormat = (CHANNELS_SH(number_colors)|BYTES_SH(sizeof(gx_color_value)));
/* Change the formaters */
cmsChangeBuffersFormat(hTransform,TYPE_NAMED_COLOR_INDEX,dwOutputFormat);
icclink->link_handle = hTransform;
cmsCloseProfile(lcms_srchandle);
if(lcms_deshandle) cmsCloseProfile(lcms_deshandle);
if(lcms_proofhandle) cmsCloseProfile(lcms_proofhandle);
return;
}
static void
cdisplay_proof_changed (GimpColorDisplay *display)
{
CdisplayProof *proof = CDISPLAY_PROOF (display);
cmsHPROFILE rgbProfile;
cmsHPROFILE proofProfile;
if (proof->transform)
{
cmsDeleteTransform (proof->transform);
proof->transform = NULL;
}
if (! proof->profile)
return;
rgbProfile = cmsCreate_sRGBProfile ();
proofProfile = cmsOpenProfileFromFile (proof->profile, "r");
if (proofProfile)
{
DWORD flags = cmsFLAGS_SOFTPROOFING;
if (proof->bpc)
flags |= cmsFLAGS_BLACKPOINTCOMPENSATION;
proof->transform = cmsCreateProofingTransform (rgbProfile,
TYPE_RGB_8,
rgbProfile, TYPE_RGB_8,
proofProfile,
proof->intent,
proof->intent,
flags);
cmsCloseProfile (proofProfile);
}
cmsCloseProfile (rgbProfile);
}
static PyObject *
pycms_BuildProofingTransform (PyObject *self, PyObject *args) {
char *inMode;
char *outMode;
int renderingIntent;
int proofingIntent;
int inFlags;
DWORD flags;
void *inputProfile;
void *outputProfile;
void *proofingProfile;
cmsHPROFILE hInputProfile, hOutputProfile, hProofingProfile;
cmsHTRANSFORM hTransform;
if (!PyArg_ParseTuple(args, "OsOsOiii", &inputProfile, &inMode, &outputProfile, &outMode,
&proofingProfile, &renderingIntent, &proofingIntent, &inFlags)) {
return NULL;
}
cmsErrorAction(LCMS_ERROR_IGNORE);
hInputProfile = (cmsHPROFILE) PyCObject_AsVoidPtr(inputProfile);
hOutputProfile = (cmsHPROFILE) PyCObject_AsVoidPtr(outputProfile);
hProofingProfile = (cmsHPROFILE) PyCObject_AsVoidPtr(proofingProfile);
flags = (DWORD) inFlags;
hTransform = cmsCreateProofingTransform(hInputProfile, getLCMStype(inMode),
hOutputProfile, getLCMStype(outMode), hProofingProfile, renderingIntent, proofingIntent, flags);
if(hTransform==NULL) {
Py_INCREF(Py_None);
return Py_None;
}
return Py_BuildValue("O", PyCObject_FromVoidPtr((void *)hTransform, (void *)cmsDeleteTransform));
}
static
void OpenTransforms(void)
{
DWORD dwIn, dwOut, dwFlags;
dwFlags = 0;
if (lIsDeviceLink) {
hInput = cmsOpenProfileFromFile(cInProf, "r");
hOutput = NULL;
InputColorSpace = cmsGetColorSpace(hInput);
OutputColorSpace = cmsGetPCS(hInput);
}
else {
hInput = OpenStockProfile(cInProf);
hOutput = OpenStockProfile(cOutProf);
hProof = NULL;
if (cProofing != NULL) {
hProof = OpenStockProfile(cProofing);
dwFlags |= cmsFLAGS_SOFTPROOFING;
}
InputColorSpace = cmsGetColorSpace(hInput);
OutputColorSpace = cmsGetColorSpace(hOutput);
if (cmsGetDeviceClass(hInput) == icSigLinkClass ||
cmsGetDeviceClass(hOutput) == icSigLinkClass)
FatalError("Use %cl flag for devicelink profiles!\n", SW);
}
hXYZ = cmsCreateXYZProfile();
hLab = cmsCreateLabProfile(NULL);
if (Verbose) {
printf("From: %s\n", cmsTakeProductName(hInput));
printf("Desc: %s\n", cmsTakeProductDesc(hInput));
if (hOutput) printf("To : %s\n\n", cmsTakeProductName(hOutput));
}
dwIn = BYTES_SH(2) | CHANNELS_SH(_cmsChannelsOf(InputColorSpace));
dwOut = BYTES_SH(2) | CHANNELS_SH(_cmsChannelsOf(OutputColorSpace));
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 (BlackPointCompensation)
dwFlags |= cmsFLAGS_BLACKPOINTCOMPENSATION;
if (GamutCheck) {
if (hProof == NULL)
FatalError("I need proofing profile -p for gamut checking!");
cmsSetAlarmCodes(0xFF, 0xFF, 0xFF);
dwFlags |= cmsFLAGS_GAMUTCHECK;
}
if (cmsGetDeviceClass(hInput) == icSigNamedColorClass) {
dwIn = TYPE_NAMED_COLOR_INDEX;
}
hTrans = cmsCreateProofingTransform(hInput, dwIn,
hOutput, dwOut,
hProof,
Intent, ProofingIntent, dwFlags);
hTransXYZ = NULL; hTransLab = NULL;
if (hOutput && Verbose) {
hTransXYZ = cmsCreateTransform(hInput, dwIn,
hXYZ, TYPE_XYZ_16,
Intent, cmsFLAGS_NOTPRECALC);
hTransLab = cmsCreateTransform(hInput, dwIn,
hLab, TYPE_Lab_16,
Intent, cmsFLAGS_NOTPRECALC);
}
}
/**
* gimp_color_transform_new_proofing:
* @src_profile:
* @src_format:
* @desr_profile:
* @dest_format:
* @proof_profile:
* @proof_intent:
* @display_intent:
* @flags:
*
* This function creates a simulation / proofing color transform.
*
* Return value: the #GimpColorTransform, or %NULL.
*
* Since: 2.10
**/
GimpColorTransform *
gimp_color_transform_new_proofing (GimpColorProfile *src_profile,
const Babl *src_format,
GimpColorProfile *dest_profile,
const Babl *dest_format,
GimpColorProfile *proof_profile,
GimpColorRenderingIntent proof_intent,
GimpColorRenderingIntent display_intent,
GimpColorTransformFlags flags)
{
GimpColorTransform *transform;
GimpColorTransformPrivate *priv;
cmsHPROFILE src_lcms;
cmsHPROFILE dest_lcms;
cmsHPROFILE proof_lcms;
cmsUInt32Number lcms_src_format;
cmsUInt32Number lcms_dest_format;
g_return_val_if_fail (GIMP_IS_COLOR_PROFILE (src_profile), NULL);
g_return_val_if_fail (src_format != NULL, NULL);
g_return_val_if_fail (GIMP_IS_COLOR_PROFILE (dest_profile), NULL);
g_return_val_if_fail (dest_format != NULL, NULL);
g_return_val_if_fail (GIMP_IS_COLOR_PROFILE (proof_profile), NULL);
transform = g_object_new (GIMP_TYPE_COLOR_TRANSFORM, NULL);
priv = transform->priv;
src_lcms = gimp_color_profile_get_lcms_profile (src_profile);
dest_lcms = gimp_color_profile_get_lcms_profile (dest_profile);
proof_lcms = gimp_color_profile_get_lcms_profile (proof_profile);
priv->src_format = gimp_color_profile_get_format (src_format,
&lcms_src_format);
priv->dest_format = gimp_color_profile_get_format (dest_format,
&lcms_dest_format);
lcms_error_clear ();
priv->transform = cmsCreateProofingTransform (src_lcms, lcms_src_format,
dest_lcms, lcms_dest_format,
proof_lcms,
proof_intent,
display_intent,
flags | cmsFLAGS_SOFTPROOFING);
if (lcms_last_error)
{
if (priv->transform)
{
cmsDeleteTransform (priv->transform);
priv->transform = NULL;
}
g_printerr ("%s\n", lcms_last_error);
}
if (! priv->transform)
{
g_object_unref (transform);
transform = NULL;
}
return transform;
}
GimpColorTransform
gimp_widget_get_color_transform (GtkWidget *widget,
GimpColorConfig *config,
GimpColorProfile *src_profile,
const Babl **src_format,
const Babl **dest_format)
{
GimpColorTransform transform = NULL;
GimpColorProfile *dest_profile = NULL;
GimpColorProfile *proof_profile = NULL;
cmsHPROFILE src_lcms;
cmsHPROFILE dest_lcms;
cmsUInt32Number lcms_src_format;
cmsUInt32Number lcms_dest_format;
cmsUInt16Number alarmCodes[cmsMAXCHANNELS] = { 0, };
g_return_val_if_fail (widget == NULL || GTK_IS_WIDGET (widget), NULL);
g_return_val_if_fail (GIMP_IS_COLOR_PROFILE (src_profile), NULL);
g_return_val_if_fail (GIMP_IS_COLOR_CONFIG (config), NULL);
g_return_val_if_fail (src_format != NULL, NULL);
g_return_val_if_fail (dest_format != NULL, NULL);
switch (config->mode)
{
case GIMP_COLOR_MANAGEMENT_OFF:
return NULL;
case GIMP_COLOR_MANAGEMENT_SOFTPROOF:
proof_profile = gimp_color_config_get_printer_color_profile (config, NULL);
/* fallthru */
case GIMP_COLOR_MANAGEMENT_DISPLAY:
dest_profile = get_display_profile (widget, config);
break;
}
src_lcms = gimp_color_profile_get_lcms_profile (src_profile);
dest_lcms = gimp_color_profile_get_lcms_profile (dest_profile);
*src_format = gimp_color_profile_get_format (*src_format, &lcms_src_format);
*dest_format = gimp_color_profile_get_format (*dest_format, &lcms_dest_format);
if (proof_profile)
{
cmsHPROFILE proof_lcms;
cmsUInt32Number softproof_flags = cmsFLAGS_SOFTPROOFING;
proof_lcms = gimp_color_profile_get_lcms_profile (proof_profile);
if (config->simulation_use_black_point_compensation)
{
softproof_flags |= cmsFLAGS_BLACKPOINTCOMPENSATION;
}
if (config->simulation_gamut_check)
{
guchar r, g, b;
softproof_flags |= cmsFLAGS_GAMUTCHECK;
gimp_rgb_get_uchar (&config->out_of_gamut_color, &r, &g, &b);
alarmCodes[0] = (cmsUInt16Number) r * 256;
alarmCodes[1] = (cmsUInt16Number) g * 256;
alarmCodes[2] = (cmsUInt16Number) b * 256;
cmsSetAlarmCodes (alarmCodes);
}
transform = cmsCreateProofingTransform (src_lcms, lcms_src_format,
dest_lcms, lcms_dest_format,
proof_lcms,
config->simulation_intent,
config->display_intent,
softproof_flags);
g_object_unref (proof_profile);
}
else if (! gimp_color_profile_is_equal (src_profile, dest_profile))
{
cmsUInt32Number display_flags = 0;
if (config->display_use_black_point_compensation)
{
display_flags |= cmsFLAGS_BLACKPOINTCOMPENSATION;
}
transform = cmsCreateTransform (src_lcms, lcms_src_format,
dest_lcms, lcms_dest_format,
config->display_intent,
display_flags);
}
g_object_unref (dest_profile);
return transform;
}
ScColorTransform ScLcmsColorMgmtEngineImpl::createProofingTransform(ScColorMgmtEngine& engine,
const ScColorProfile& inputProfile , eColorFormat inputFormat,
const ScColorProfile& outputProfile, eColorFormat outputFormat,
const ScColorProfile& proofProfile , eRenderIntent renderIntent,
eRenderIntent proofingIntent, long transformFlags)
{
ScColorTransform transform(NULL);
if (inputProfile.isNull() || outputProfile.isNull())
return transform;
int inputProfEngineID = inputProfile.engine().engineID();
int outputProfEngineID = outputProfile.engine().engineID();
int proofProfEngineID = proofProfile.engine().engineID();
if ((engine.engineID() != m_engineID) || (inputProfEngineID != m_engineID) ||
(outputProfEngineID != m_engineID) || (proofProfEngineID != m_engineID))
return transform;
const ScLcmsColorProfileImpl* lcmsInputProf = dynamic_cast<const ScLcmsColorProfileImpl*>(inputProfile.data());
const ScLcmsColorProfileImpl* lcmsOutputProf = dynamic_cast<const ScLcmsColorProfileImpl*>(outputProfile.data());
const ScLcmsColorProfileImpl* lcmsProofingProf = dynamic_cast<const ScLcmsColorProfileImpl*>(proofProfile.data());
if (!lcmsInputProf || !lcmsOutputProf || !lcmsProofingProf)
return transform;
long strategyFlags = 0;
if (m_strategy.useBlackPointCompensation)
strategyFlags |= Ctf_BlackPointCompensation;
if (m_strategy.useBlackPreservation)
strategyFlags |= Ctf_BlackPreservation;
ScColorTransformInfo transInfo;
transInfo.inputProfile = inputProfile.productDescription();
transInfo.outputProfile = outputProfile.productDescription();
transInfo.proofingProfile = proofProfile.productDescription();
transInfo.inputFormat = inputFormat;
transInfo.outputFormat = outputFormat;
transInfo.renderIntent = renderIntent;
transInfo.proofingIntent = proofingIntent;
transInfo.flags = transformFlags | strategyFlags;
DWORD lcmsFlags = translateFlagsToLcmsFlags(transformFlags | strategyFlags);
DWORD lcmsInputFmt = translateFormatToLcmsFormat(inputFormat);
DWORD lcmsOutputFmt = translateFormatToLcmsFormat(outputFormat);
int lcmsIntent = translateIntentToLcmsIntent(renderIntent);
int lcmsPrfIntent = translateIntentToLcmsIntent(proofingIntent);
if (transInfo.inputProfile != transInfo.proofingProfile)
{
if (transInfo.proofingProfile == transInfo.outputProfile)
{
transInfo.proofingIntent = Intent_Relative_Colorimetric;
lcmsPrfIntent = translateIntentToLcmsIntent(Intent_Relative_Colorimetric);
}
transform = m_transformPool->findTransform(transInfo);
if (transform.isNull())
{
cmsSetErrorHandler(&cmsErrorHandler);
cmsHTRANSFORM hTransform = NULL;
try
{
hTransform = cmsCreateProofingTransform(lcmsInputProf->m_profileHandle , lcmsInputFmt,
lcmsOutputProf->m_profileHandle, lcmsOutputFmt,
lcmsProofingProf->m_profileHandle, lcmsIntent,
lcmsPrfIntent, lcmsFlags | cmsFLAGS_SOFTPROOFING);
if (hTransform)
{
ScLcmsColorTransformImpl* newTrans = new ScLcmsColorTransformImpl(engine, hTransform);
newTrans->setTransformInfo(transInfo);
transform = ScColorTransform(dynamic_cast<ScColorTransformData*>(newTrans));
m_transformPool->addTransform(transform, true);
}
}
catch (lcmsException& e)
{
std::cerr << e.what() << std::endl;
// #9922 : no idea why that crash in release mode
/*if (transform.isNull() && hTransform)
cmsDeleteTransform(hTransform);*/
transform = ScColorTransform();
}
cmsSetErrorHandler(NULL);
}
}
else
{
transformFlags &= (~Ctf_Softproofing);
transformFlags &= (~Ctf_GamutCheck);
lcmsFlags = translateFlagsToLcmsFlags(transformFlags | strategyFlags);
transInfo.flags = transformFlags | strategyFlags;
transInfo.renderIntent = proofingIntent;
transInfo.proofingIntent = (eRenderIntent) 0;
if (transInfo.inputProfile == transInfo.outputProfile)
{
lcmsFlags |= cmsFLAGS_NULLTRANSFORM;
transInfo.inputProfile = QString();
transInfo.outputProfile = QString();
transInfo.proofingProfile = QString();
transInfo.renderIntent = (eRenderIntent) 0;
transInfo.proofingIntent = (eRenderIntent) 0;
transInfo.flags = 0;
}
transform = m_transformPool->findTransform(transInfo);
if (transform.isNull())
{
cmsSetErrorHandler(&cmsErrorHandler);
cmsHTRANSFORM hTransform = NULL;
try
{
hTransform = cmsCreateTransform(lcmsInputProf->m_profileHandle , lcmsInputFmt,
lcmsOutputProf->m_profileHandle, lcmsOutputFmt,
lcmsPrfIntent, lcmsFlags | cmsFLAGS_LOWRESPRECALC);
if (hTransform)
{
ScLcmsColorTransformImpl* newTrans = new ScLcmsColorTransformImpl(engine, hTransform);
newTrans->setTransformInfo(transInfo);
transform = ScColorTransform(dynamic_cast<ScColorTransformData*>(newTrans));
m_transformPool->addTransform(transform, true);
}
}
catch (lcmsException& e)
{
std::cerr << e.what() << std::endl;
// #9922 : no idea why that crash in release mode
/*if (transform.isNull() && hTransform)
cmsDeleteTransform(hTransform);*/
transform = ScColorTransform();
}
cmsSetErrorHandler(NULL);
}
}
return transform;
}
void commit_params (struct dt_iop_module_t *self, dt_iop_params_t *p1, dt_dev_pixelpipe_t *pipe, dt_dev_pixelpipe_iop_t *piece)
{
dt_iop_colorout_params_t *p = (dt_iop_colorout_params_t *)p1;
dt_iop_colorout_data_t *d = (dt_iop_colorout_data_t *)piece->data;
gchar *overprofile = dt_conf_get_string("plugins/lighttable/export/iccprofile");
const int overintent = dt_conf_get_int("plugins/lighttable/export/iccintent");
const int high_quality_processing = dt_conf_get_bool("plugins/lighttable/export/force_lcms2");
gchar *outprofile=NULL;
int outintent = 0;
/* cleanup profiles */
if (d->output)
dt_colorspaces_cleanup_profile(d->output);
d->output = NULL;
if (d->softproof_enabled)
dt_colorspaces_cleanup_profile(d->softproof);
d->softproof = NULL;
d->softproof_enabled = p->softproof_enabled;
if(self->dev->gui_attached && self->gui_data != NULL)
{
dt_iop_colorout_gui_data_t *g = (dt_iop_colorout_gui_data_t *)self->gui_data;
g->softproof_enabled = p->softproof_enabled;
}
if (d->xform)
{
cmsDeleteTransform(d->xform);
d->xform = 0;
}
d->cmatrix[0] = NAN;
d->lut[0][0] = -1.0f;
d->lut[1][0] = -1.0f;
d->lut[2][0] = -1.0f;
piece->process_cl_ready = 1;
/* if we are exporting then check and set usage of override profile */
if (pipe->type == DT_DEV_PIXELPIPE_EXPORT)
{
if (overprofile && strcmp(overprofile, "image"))
snprintf(p->iccprofile, DT_IOP_COLOR_ICC_LEN, "%s", overprofile);
if (overintent >= 0)
p->intent = overintent;
outprofile = p->iccprofile;
outintent = p->intent;
}
else
{
/* we are not exporting, using display profile as output */
outprofile = p->displayprofile;
outintent = p->displayintent;
}
/*
* Setup transform flags
*/
uint32_t transformFlags = 0;
/* creating output profile */
d->output = _create_profile(outprofile);
/* creating softproof profile if softproof is enabled */
if (d->softproof_enabled && pipe->type == DT_DEV_PIXELPIPE_FULL)
{
d->softproof = _create_profile(p->softproofprofile);
/* TODO: the use of bpc should be userconfigurable either from module or preference pane */
/* softproof flag and black point compensation */
transformFlags |= cmsFLAGS_SOFTPROOFING|cmsFLAGS_NOCACHE|cmsFLAGS_BLACKPOINTCOMPENSATION;
if(d->softproof_enabled == DT_SOFTPROOF_GAMUTCHECK)
transformFlags |= cmsFLAGS_GAMUTCHECK;
}
/* get matrix from profile, if softproofing or high quality exporting always go xform codepath */
if (d->softproof_enabled || (pipe->type == DT_DEV_PIXELPIPE_EXPORT && high_quality_processing) ||
dt_colorspaces_get_matrix_from_output_profile (d->output, d->cmatrix, d->lut[0], d->lut[1], d->lut[2], LUT_SAMPLES))
{
d->cmatrix[0] = NAN;
piece->process_cl_ready = 0;
d->xform = cmsCreateProofingTransform(d->Lab,
TYPE_Lab_FLT,
d->output,
TYPE_RGB_FLT,
d->softproof,
outintent,
INTENT_RELATIVE_COLORIMETRIC,
transformFlags);
}
// user selected a non-supported output profile, check that:
if (!d->xform && isnan(d->cmatrix[0]))
{
dt_control_log(_("unsupported output profile has been replaced by sRGB!"));
if (d->output)
dt_colorspaces_cleanup_profile(d->output);
d->output = dt_colorspaces_create_srgb_profile();
if (d->softproof_enabled || dt_colorspaces_get_matrix_from_output_profile (d->output, d->cmatrix, d->lut[0], d->lut[1], d->lut[2], LUT_SAMPLES))
{
d->cmatrix[0] = NAN;
piece->process_cl_ready = 0;
d->xform = cmsCreateProofingTransform(d->Lab,
TYPE_Lab_FLT,
d->output,
TYPE_RGB_FLT,
d->softproof,
outintent,
INTENT_RELATIVE_COLORIMETRIC,
transformFlags);
}
}
// now try to initialize unbounded mode:
// we do extrapolation for input values above 1.0f.
// unfortunately we can only do this if we got the computation
// in our hands, i.e. for the fast builtin-dt-matrix-profile path.
for(int k=0; k<3; k++)
{
// omit luts marked as linear (negative as marker)
if(d->lut[k][0] >= 0.0f)
{
const float x[4] = {0.7f, 0.8f, 0.9f, 1.0f};
const float y[4] = {lerp_lut(d->lut[k], x[0]),
lerp_lut(d->lut[k], x[1]),
lerp_lut(d->lut[k], x[2]),
lerp_lut(d->lut[k], x[3])
};
dt_iop_estimate_exp(x, y, 4, d->unbounded_coeffs[k]);
}
else d->unbounded_coeffs[k][0] = -1.0f;
}
//fprintf(stderr, " Output profile %s, softproof %s%s%s\n", outprofile, d->softproof_enabled?"enabled ":"disabled",d->softproof_enabled?"using profile ":"",d->softproof_enabled?p->softproofprofile:"");
g_free(overprofile);
}
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;
}
// Creates all needed color transforms
static
cmsBool OpenTransforms(void)
{
cmsHPROFILE hInput, hOutput, hProof;
cmsUInt32Number dwIn, dwOut, dwFlags;
cmsNAMEDCOLORLIST* List;
int i;
// We don't need cache
dwFlags = cmsFLAGS_NOCACHE;
if (lIsDeviceLink) {
hInput = OpenStockProfile(0, cInProf);
if (hInput == NULL) return FALSE;
hOutput = NULL;
hProof = NULL;
if (cmsGetDeviceClass(hInput) == cmsSigNamedColorClass) {
OutputColorSpace = cmsGetColorSpace(hInput);
InputColorSpace = cmsGetPCS(hInput);
}
else {
InputColorSpace = cmsGetColorSpace(hInput);
OutputColorSpace = cmsGetPCS(hInput);
}
// Read colorant tables if present
if (cmsIsTag(hInput, cmsSigColorantTableTag)) {
List = cmsReadTag(hInput, cmsSigColorantTableTag);
InputColorant = cmsDupNamedColorList(List);
InputRange = 1;
}
else InputColorant = ComponentNames(InputColorSpace, TRUE);
if (cmsIsTag(hInput, cmsSigColorantTableOutTag)){
List = cmsReadTag(hInput, cmsSigColorantTableOutTag);
OutputColorant = cmsDupNamedColorList(List);
OutputRange = 1;
}
else OutputColorant = ComponentNames(OutputColorSpace, FALSE);
}
else {
hInput = OpenStockProfile(0, cInProf);
if (hInput == NULL) return FALSE;
hOutput = OpenStockProfile(0, cOutProf);
if (hOutput == NULL) return FALSE;
hProof = NULL;
if (cmsGetDeviceClass(hInput) == cmsSigLinkClass ||
cmsGetDeviceClass(hOutput) == cmsSigLinkClass)
FatalError("Use %cl flag for devicelink profiles!\n", SW);
InputColorSpace = cmsGetColorSpace(hInput);
OutputColorSpace = cmsGetColorSpace(hOutput);
// Read colorant tables if present
if (cmsIsTag(hInput, cmsSigColorantTableTag)) {
List = cmsReadTag(hInput, cmsSigColorantTableTag);
InputColorant = cmsDupNamedColorList(List);
if (cmsNamedColorCount(InputColorant) <= 3)
SetRange(255, TRUE);
else
SetRange(1, TRUE); // Inks are already divided by 100 in the formatter
}
else InputColorant = ComponentNames(InputColorSpace, TRUE);
if (cmsIsTag(hOutput, cmsSigColorantTableTag)){
List = cmsReadTag(hOutput, cmsSigColorantTableTag);
OutputColorant = cmsDupNamedColorList(List);
if (cmsNamedColorCount(OutputColorant) <= 3)
SetRange(255, FALSE);
else
SetRange(1, FALSE); // Inks are already divided by 100 in the formatter
}
else OutputColorant = ComponentNames(OutputColorSpace, FALSE);
if (cProofing != NULL) {
hProof = OpenStockProfile(0, cProofing);
if (hProof == NULL) return FALSE;
dwFlags |= cmsFLAGS_SOFTPROOFING;
}
}
// Print information on profiles
if (Verbose > 2) {
printf("Profile:\n");
PrintProfileInformation(hInput);
if (hOutput) {
printf("Output profile:\n");
PrintProfileInformation(hOutput);
}
if (hProof != NULL) {
printf("Proofing profile:\n");
PrintProfileInformation(hProof);
}
}
// Input is always in floating point
dwIn = cmsFormatterForColorspaceOfProfile(hInput, 0, TRUE);
if (lIsDeviceLink) {
dwOut = cmsFormatterForPCSOfProfile(hInput, lIsFloat ? 0 : 2, lIsFloat);
}
else {
// 16 bits or floating point (only on output)
dwOut = cmsFormatterForColorspaceOfProfile(hOutput, lIsFloat ? 0 : 2, lIsFloat);
}
// For named color, there is a specialized formatter
if (cmsGetDeviceClass(hInput) == cmsSigNamedColorClass) {
dwIn = TYPE_NAMED_COLOR_INDEX;
InputNamedColor = TRUE;
}
// Precision mode
switch (PrecalcMode) {
case 0: dwFlags |= cmsFLAGS_NOOPTIMIZE; break;
case 2: dwFlags |= cmsFLAGS_HIGHRESPRECALC; break;
case 3: dwFlags |= cmsFLAGS_LOWRESPRECALC; break;
case 1: break;
default:
FatalError("Unknown precalculation mode '%d'", PrecalcMode);
}
if (BlackPointCompensation)
dwFlags |= cmsFLAGS_BLACKPOINTCOMPENSATION;
if (GamutCheck) {
cmsUInt16Number Alarm[cmsMAXCHANNELS];
if (hProof == NULL)
FatalError("I need proofing profile -p for gamut checking!");
for (i=0; i < cmsMAXCHANNELS; i++)
Alarm[i] = 0xFFFF;
cmsSetAlarmCodes(Alarm);
dwFlags |= cmsFLAGS_GAMUTCHECK;
}
// The main transform
hTrans = cmsCreateProofingTransform(hInput, dwIn, hOutput, dwOut, hProof, Intent, ProofingIntent, dwFlags);
if (hProof) cmsCloseProfile(hProof);
if (hTrans == NULL) return FALSE;
// PCS Dump if requested
hTransXYZ = NULL; hTransLab = NULL;
if (hOutput && Verbose > 1) {
cmsHPROFILE hXYZ = cmsCreateXYZProfile();
cmsHPROFILE hLab = cmsCreateLab4Profile(NULL);
hTransXYZ = cmsCreateTransform(hInput, dwIn, hXYZ, lIsFloat ? TYPE_XYZ_DBL : TYPE_XYZ_16, Intent, cmsFLAGS_NOCACHE);
if (hTransXYZ == NULL) return FALSE;
hTransLab = cmsCreateTransform(hInput, dwIn, hLab, lIsFloat? TYPE_Lab_DBL : TYPE_Lab_16, Intent, cmsFLAGS_NOCACHE);
if (hTransLab == NULL) return FALSE;
cmsCloseProfile(hXYZ);
cmsCloseProfile(hLab);
}
if (hInput) cmsCloseProfile(hInput);
if (hOutput) cmsCloseProfile(hOutput);
return TRUE;
}
static void
cdisplay_lcms_changed (GimpColorDisplay *display)
{
CdisplayLcms *lcms = CDISPLAY_LCMS (display);
GimpColorConfig *config = gimp_color_display_get_config (display);
cmsHPROFILE src_profile = NULL;
cmsHPROFILE dest_profile = NULL;
cmsHPROFILE proof_profile = NULL;
cmsUInt16Number alarmCodes[cmsMAXCHANNELS] = { 0, };
if (lcms->transform)
{
cmsDeleteTransform (lcms->transform);
lcms->transform = NULL;
}
if (! config)
return;
switch (config->mode)
{
case GIMP_COLOR_MANAGEMENT_OFF:
return;
case GIMP_COLOR_MANAGEMENT_SOFTPROOF:
proof_profile = cdisplay_lcms_get_printer_profile (lcms);
/* fallthru */
case GIMP_COLOR_MANAGEMENT_DISPLAY:
src_profile = cdisplay_lcms_get_rgb_profile (lcms);
dest_profile = cdisplay_lcms_get_display_profile (lcms);
break;
}
if (proof_profile)
{
cmsUInt32Number softproof_flags = 0;
if (! src_profile)
src_profile = gimp_lcms_create_srgb_profile ();
if (! dest_profile)
dest_profile = gimp_lcms_create_srgb_profile ();
softproof_flags |= cmsFLAGS_SOFTPROOFING;
if (config->simulation_use_black_point_compensation)
{
softproof_flags |= cmsFLAGS_BLACKPOINTCOMPENSATION;
}
if (config->simulation_gamut_check)
{
guchar r, g, b;
softproof_flags |= cmsFLAGS_GAMUTCHECK;
gimp_rgb_get_uchar (&config->out_of_gamut_color, &r, &g, &b);
alarmCodes[0] = (cmsUInt16Number) r * 256;
alarmCodes[1] = (cmsUInt16Number) g * 256;
alarmCodes[2] = (cmsUInt16Number) b * 256;
cmsSetAlarmCodes (alarmCodes);
}
lcms->transform = cmsCreateProofingTransform (src_profile, TYPE_RGBA_FLT,
dest_profile, TYPE_RGBA_FLT,
proof_profile,
config->simulation_intent,
config->display_intent,
softproof_flags);
cmsCloseProfile (proof_profile);
}
else if (src_profile || dest_profile)
{
cmsUInt32Number display_flags = 0;
if (! src_profile)
src_profile = gimp_lcms_create_srgb_profile ();
if (! dest_profile)
dest_profile = gimp_lcms_create_srgb_profile ();
if (config->display_use_black_point_compensation)
{
display_flags |= cmsFLAGS_BLACKPOINTCOMPENSATION;
}
lcms->transform = cmsCreateTransform (src_profile, TYPE_RGBA_FLT,
dest_profile, TYPE_RGBA_FLT,
config->display_intent,
display_flags);
}
if (dest_profile)
cmsCloseProfile (dest_profile);
if (src_profile)
cmsCloseProfile (src_profile);
}
static
void OpenTransforms(int argc, char *argv[])
{
DWORD dwIn, dwOut, dwFlags;
if (lMultiProfileChain) {
int i;
cmsHTRANSFORM hTmp;
nProfiles = argc - xoptind;
for (i=0; i < nProfiles; i++) {
hProfiles[i] = OpenProfile(argv[i+xoptind]);
}
// Create a temporary devicelink
hTmp = cmsCreateMultiprofileTransform(hProfiles, nProfiles,
0, 0, Intent, GetFlags());
hInput = cmsTransform2DeviceLink(hTmp, 0);
hOutput = NULL;
cmsDeleteTransform(hTmp);
InputColorSpace = cmsGetColorSpace(hInput);
OutputColorSpace = cmsGetPCS(hInput);
lIsDeviceLink = TRUE;
}
else
if (lIsDeviceLink) {
hInput = cmsOpenProfileFromFile(cInProf, "r");
hOutput = NULL;
InputColorSpace = cmsGetColorSpace(hInput);
OutputColorSpace = cmsGetPCS(hInput);
}
else {
hInput = OpenProfile(cInProf);
hOutput = OpenProfile(cOutProf);
InputColorSpace = cmsGetColorSpace(hInput);
OutputColorSpace = cmsGetColorSpace(hOutput);
if (cmsGetDeviceClass(hInput) == icSigLinkClass ||
cmsGetDeviceClass(hOutput) == icSigLinkClass)
FatalError("Use %cl flag for devicelink profiles!\n", SW);
}
if (Verbose) {
mexPrintf("From: %s\n", cmsTakeProductName(hInput));
if (hOutput) mexPrintf("To : %s\n\n", cmsTakeProductName(hOutput));
}
OutputChannels = _cmsChannelsOf(OutputColorSpace);
InputChannels = _cmsChannelsOf(InputColorSpace);
dwIn = MakeFormatDescriptor(InputColorSpace, nBytesDepth);
dwOut = MakeFormatDescriptor(OutputColorSpace, nBytesDepth);
dwFlags = GetFlags();
if (cProofing != NULL) {
hProof = OpenProfile(cProofing);
dwFlags |= cmsFLAGS_SOFTPROOFING;
}
hColorTransform = cmsCreateProofingTransform(hInput, dwIn,
hOutput, dwOut,
hProof, Intent,
ProofingIntent,
dwFlags);
}
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;
}
void commit_params(struct dt_iop_module_t *self, dt_iop_params_t *p1, dt_dev_pixelpipe_t *pipe,
dt_dev_pixelpipe_iop_t *piece)
{
dt_iop_colorout_params_t *p = (dt_iop_colorout_params_t *)p1;
dt_iop_colorout_data_t *d = (dt_iop_colorout_data_t *)piece->data;
const dt_colorspaces_color_profile_type_t over_type = dt_conf_get_int("plugins/lighttable/export/icctype");
gchar *over_filename = dt_conf_get_string("plugins/lighttable/export/iccprofile");
const dt_iop_color_intent_t over_intent = dt_conf_get_int("plugins/lighttable/export/iccintent");
const int force_lcms2 = dt_conf_get_bool("plugins/lighttable/export/force_lcms2");
dt_colorspaces_color_profile_type_t out_type = DT_COLORSPACE_SRGB;
gchar *out_filename = NULL;
dt_iop_color_intent_t out_intent = DT_INTENT_PERCEPTUAL;
const cmsHPROFILE Lab = dt_colorspaces_get_profile(DT_COLORSPACE_LAB, "", DT_PROFILE_DIRECTION_ANY)->profile;
cmsHPROFILE output = NULL;
cmsHPROFILE softproof = NULL;
d->mode = pipe->type == DT_DEV_PIXELPIPE_FULL ? darktable.color_profiles->mode : DT_PROFILE_NORMAL;
if(d->xform)
{
cmsDeleteTransform(d->xform);
d->xform = NULL;
}
d->cmatrix[0] = NAN;
d->lut[0][0] = -1.0f;
d->lut[1][0] = -1.0f;
d->lut[2][0] = -1.0f;
piece->process_cl_ready = 1;
/* if we are exporting then check and set usage of override profile */
if(pipe->type == DT_DEV_PIXELPIPE_EXPORT)
{
if(over_type != DT_COLORSPACE_NONE)
{
p->type = over_type;
g_strlcpy(p->filename, over_filename, sizeof(p->filename));
}
if((unsigned int)over_intent < DT_INTENT_LAST) p->intent = over_intent;
out_type = p->type;
out_filename = p->filename;
out_intent = p->intent;
}
else if(pipe->type == DT_DEV_PIXELPIPE_THUMBNAIL)
{
out_type = dt_mipmap_cache_get_colorspace();
out_filename = (out_type == DT_COLORSPACE_DISPLAY ? darktable.color_profiles->display_filename : "");
out_intent = darktable.color_profiles->display_intent;
}
else
{
/* we are not exporting, using display profile as output */
out_type = darktable.color_profiles->display_type;
out_filename = darktable.color_profiles->display_filename;
out_intent = darktable.color_profiles->display_intent;
}
/*
* Setup transform flags
*/
uint32_t transformFlags = 0;
/* creating output profile */
if(out_type == DT_COLORSPACE_DISPLAY) pthread_rwlock_rdlock(&darktable.color_profiles->xprofile_lock);
const dt_colorspaces_color_profile_t *out_profile
= dt_colorspaces_get_profile(out_type, out_filename, DT_PROFILE_DIRECTION_OUT | DT_PROFILE_DIRECTION_DISPLAY);
output = out_profile->profile;
/* creating softproof profile if softproof is enabled */
if(d->mode != DT_PROFILE_NORMAL && pipe->type == DT_DEV_PIXELPIPE_FULL)
{
softproof = dt_colorspaces_get_profile(darktable.color_profiles->softproof_type,
darktable.color_profiles->softproof_filename,
DT_PROFILE_DIRECTION_OUT | DT_PROFILE_DIRECTION_DISPLAY)->profile;
/* TODO: the use of bpc should be userconfigurable either from module or preference pane */
/* softproof flag and black point compensation */
transformFlags |= cmsFLAGS_SOFTPROOFING | cmsFLAGS_NOCACHE | cmsFLAGS_BLACKPOINTCOMPENSATION;
if(d->mode == DT_PROFILE_GAMUTCHECK) transformFlags |= cmsFLAGS_GAMUTCHECK;
}
/*
* NOTE: theoretically, we should be passing
* UsedDirection = LCMS_USED_AS_PROOF into
* dt_colorspaces_get_matrix_from_output_profile() so that
* dt_colorspaces_get_matrix_from_profile() knows it, but since we do not try
* to use our matrix codepath when softproof is enabled, this seemed redundant.
*/
/* get matrix from profile, if softproofing or high quality exporting always go xform codepath */
if(d->mode != DT_PROFILE_NORMAL || force_lcms2
|| dt_colorspaces_get_matrix_from_output_profile(output, d->cmatrix, d->lut[0], d->lut[1], d->lut[2],
LUT_SAMPLES, out_intent))
{
d->cmatrix[0] = NAN;
piece->process_cl_ready = 0;
d->xform = cmsCreateProofingTransform(Lab, TYPE_LabA_FLT, output, TYPE_RGBA_FLT, softproof,
out_intent, INTENT_RELATIVE_COLORIMETRIC, transformFlags);
}
// user selected a non-supported output profile, check that:
if(!d->xform && isnan(d->cmatrix[0]))
{
dt_control_log(_("unsupported output profile has been replaced by sRGB!"));
fprintf(stderr, "unsupported output profile `%s' has been replaced by sRGB!\n", out_profile->name);
output = dt_colorspaces_get_profile(DT_COLORSPACE_SRGB, "", DT_PROFILE_DIRECTION_OUT)->profile;
if(d->mode != DT_PROFILE_NORMAL
|| dt_colorspaces_get_matrix_from_output_profile(output, d->cmatrix, d->lut[0], d->lut[1],
d->lut[2], LUT_SAMPLES, out_intent))
{
d->cmatrix[0] = NAN;
piece->process_cl_ready = 0;
d->xform = cmsCreateProofingTransform(Lab, TYPE_LabA_FLT, output, TYPE_RGBA_FLT, softproof,
out_intent, INTENT_RELATIVE_COLORIMETRIC, transformFlags);
}
}
if(out_type == DT_COLORSPACE_DISPLAY) pthread_rwlock_unlock(&darktable.color_profiles->xprofile_lock);
// now try to initialize unbounded mode:
// we do extrapolation for input values above 1.0f.
// unfortunately we can only do this if we got the computation
// in our hands, i.e. for the fast builtin-dt-matrix-profile path.
for(int k = 0; k < 3; k++)
{
// omit luts marked as linear (negative as marker)
if(d->lut[k][0] >= 0.0f)
{
const float x[4] = { 0.7f, 0.8f, 0.9f, 1.0f };
const float y[4] = { lerp_lut(d->lut[k], x[0]), lerp_lut(d->lut[k], x[1]), lerp_lut(d->lut[k], x[2]),
lerp_lut(d->lut[k], x[3]) };
dt_iop_estimate_exp(x, y, 4, d->unbounded_coeffs[k]);
}
else
d->unbounded_coeffs[k][0] = -1.0f;
}
g_free(over_filename);
}
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;
}
