Subversion Repositories Scribus

Rev

Rev 15135 | Go to most recent revision | Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
15127 jghali 1
/*
2
For general Scribus (>=1.3.2) copyright and licensing information please refer
3
to the COPYING file provided with the program. Following this notice may exist
4
a copyright and/or license notice that predates the release of Scribus 1.3.2
5
for which a new license (GPL+exception) is in place.
6
*/
7
 
8
#include <iostream>
9
#include <string>
10
#include <QDir>
11
#include <QFile>
12
 
13
#include "sclcms2colormgmtengineimpl.h"
14
#include "sclcms2colorprofileimpl.h"
15
#include "sclcms2colortransformimpl.h"
16
 
17
#ifndef cmsFLAGS_PRESERVEBLACK
18
#define cmsFLAGS_PRESERVEBLACK 0x8000
19
#endif
20
 
21
QSharedPointer<ScColorProfileCache>  ScLcms2ColorMgmtEngineImpl::m_profileCache;
22
QSharedPointer<ScColorTransformPool> ScLcms2ColorMgmtEngineImpl::m_transformPool;
23
 
24
ScLcms2ColorMgmtEngineImpl::ScLcms2ColorMgmtEngineImpl()
25
                         : ScColorMgmtEngineData("Littlecms v2", 1)
26
{
27
        if (!m_profileCache)
28
                m_profileCache = QSharedPointer<ScColorProfileCache>(new ScColorProfileCache());
29
        if (!m_transformPool)
30
                m_transformPool = QSharedPointer<ScColorTransformPool>(new ScColorTransformPool(0));
31
        cmsUInt16Number alarmCodes[cmsMAXCHANNELS] = { 0 };
32
        alarmCodes[1] = 0xFFFF;
33
        cmsSetAlarmCodes(alarmCodes);
34
        cmsSetLogErrorHandler(&cmsErrorHandler);
35
}
36
 
37
void ScLcms2ColorMgmtEngineImpl::setStrategy(const ScColorMgmtStrategy& strategy)
38
{
39
        m_strategy = strategy;
40
}
41
 
42
QList<ScColorProfileInfo> ScLcms2ColorMgmtEngineImpl::getAvailableProfileInfo(const QString& directory, bool recursive)
43
{
44
        QList<ScColorProfileInfo> profileInfos;
45
 
46
        QDir d(directory, "*", QDir::Name, QDir::Files | QDir::Readable | QDir::Dirs | QDir::NoSymLinks);
47
        if ((!d.exists()) || (d.count() == 0))
48
                return profileInfos;
49
 
50
        QString nam = "";
51
        cmsHPROFILE hIn = NULL;
52
 
53
        for (uint dc = 0; dc < d.count(); ++dc)
54
        {
55
                QString file = d[dc];
56
                if (file == "." ||  file == "..")
57
                        continue;
58
                QFileInfo fi(directory + "/" + file);
59
                if (fi.isDir() && !recursive)
60
                        continue;
61
                else if (fi.isDir() && !file.startsWith('.'))
62
                {
63
                        QList<ScColorProfileInfo> profileInfos2 = getAvailableProfileInfo(fi.filePath()+"/", true);
64
                        profileInfos.append(profileInfos2);
65
                        continue;
66
                }
67
 
68
                ScColorProfileInfo profileInfo;
69
                profileInfo.file = fi.filePath();
70
 
71
                QFile f(fi.filePath());
72
                QByteArray bb(40, ' ');
73
                if (!f.open(QIODevice::ReadOnly)) {
74
                        profileInfo.debug = QString("couldn't open %1 as color profile").arg(fi.filePath());
75
                        profileInfos.append(profileInfo);
76
                        continue;
77
                }
78
                int len = f.read(bb.data(), 40);
79
                f.close();
80
                if (len == 40 && bb[36] == 'a' && bb[37] == 'c' && bb[38] == 's' && bb[39] == 'p')
81
                {
82
                        const QByteArray profilePath( QString(directory + "/" + file).toLocal8Bit() );
83
                        hIn = cmsOpenProfileFromFile(profilePath.data(), "r");
84
                        if (hIn == NULL)
85
                                continue;
86
                        cmsUInt32Number descSize = cmsGetProfileInfo(hIn, cmsInfoDescription, "en", "US", NULL, 0);
87
                        if (descSize > 0)
88
                        {
89
                                wchar_t* descData = (wchar_t*) malloc(descSize + sizeof(wchar_t));
90
                                descSize = cmsGetProfileInfo(hIn, cmsInfoDescription, "en", "US", descData, descSize);
91
                                if (descSize > 0)
92
                                {
93
                                        if (sizeof(wchar_t) == sizeof(QChar)) {
94
                                                profileInfo.description = QString::fromUtf16((ushort *) descData, descSize / sizeof(wchar_t));
95
                                        } else {
96
                                                profileInfo.description = QString::fromUcs4((uint *) descData, descSize / sizeof(wchar_t));
97
                                        }
98
                                        free(descData);
99
                                }
100
                        }
101
                        if (profileInfo.description.isEmpty())
102
                        {
103
                                cmsCloseProfile(hIn);
104
                                profileInfo.debug = QString("Color profile %1 is broken : no valid description").arg(fi.filePath());
105
                                profileInfos.append(profileInfo);
106
                                continue;
107
                        }
108
                        profileInfo.colorSpace  = translateLcmsColorSpaceType( cmsGetColorSpace(hIn) );
109
                        profileInfo.deviceClass = translateLcmsProfileClass( cmsGetDeviceClass(hIn) );
110
                        profileInfos.append(profileInfo);
111
                        cmsCloseProfile(hIn);
112
                        hIn = NULL;
113
                }
114
        }
115
 
116
        return profileInfos;
117
}
118
 
119
ScColorProfile ScLcms2ColorMgmtEngineImpl::openProfileFromFile(ScColorMgmtEngine& engine, const QString& filePath)
120
{
121
        // Search profile in profile cache first
122
        ScColorProfile profile = m_profileCache->profile(filePath);
123
        if (!profile.isNull())
124
                return profile;
125
        cmsHPROFILE lcmsProf = NULL;
126
        QFile file(filePath);
127
        if (file.open(QFile::ReadOnly))
128
        {
129
                // We do not use lcms cmsOpenProfileFromFile() to avoid limitations
130
                // of I/O on 8bit filenames on Windows
131
                QByteArray data = file.readAll();
132
                if (!data.isEmpty())
133
                {
134
                        lcmsProf = cmsOpenProfileFromMem(data.data(), data.size());
135
                        if (lcmsProf)
136
                        {
137
                                ScLcms2ColorProfileImpl* profData = new ScLcms2ColorProfileImpl(engine, lcmsProf);
138
                                profData->m_profileData = data;
139
                                profData->m_profilePath = filePath;
140
                                profile = ScColorProfile(dynamic_cast<ScColorProfileData*>(profData));
141
                                m_profileCache->addProfile(profile);
142
                        }
143
                        if (profile.isNull() && lcmsProf)
144
                        {
145
                                cmsCloseProfile(lcmsProf);
146
                                lcmsProf = NULL;
147
                        }
148
                }
149
                file.close();
150
        }
151
        return profile;
152
}
153
 
154
ScColorProfile ScLcms2ColorMgmtEngineImpl::openProfileFromMem(ScColorMgmtEngine& engine, const QByteArray& data)
155
{
156
        ScColorProfile profile;
157
        cmsHPROFILE     lcmsProf = cmsOpenProfileFromMem((const void *) data.data(), data.size());
158
        if (lcmsProf)
159
        {
160
                ScLcms2ColorProfileImpl* profData = new ScLcms2ColorProfileImpl(engine, lcmsProf);
161
                QString desc = profData->productDescription();
162
                if (!desc.isEmpty())
163
                        profData->m_profilePath = QString("memprofile://%1").arg(desc);
164
                profData->m_profileData = data;
165
                profile = ScColorProfile(dynamic_cast<ScColorProfileData*>(profData));
166
        }
167
        if (profile.isNull() && lcmsProf)
168
        {
169
                cmsCloseProfile(lcmsProf);
170
                lcmsProf = NULL;
171
        }
172
        return profile;
173
}
174
 
175
ScColorProfile ScLcms2ColorMgmtEngineImpl::createProfile_sRGB(ScColorMgmtEngine& engine)
176
{
177
        QString internalProfilePath("memprofile://Internal sRGB profile");
178
        ScColorProfile profile = m_profileCache->profile(internalProfilePath);
179
        if (!profile.isNull())
180
                return profile;
181
 
182
        cmsHPROFILE lcmsProf = cmsCreate_sRGBProfile();
183
        if (lcmsProf)
184
        {
185
                ScLcms2ColorProfileImpl* profData = new ScLcms2ColorProfileImpl(engine, lcmsProf);
186
                profData->m_profilePath = internalProfilePath;
187
                profile = ScColorProfile(dynamic_cast<ScColorProfileData*>(profData));
188
                m_profileCache->addProfile(profile);
189
        }
190
        if (profile.isNull() && lcmsProf)
191
        {
192
                cmsCloseProfile(lcmsProf);
193
                lcmsProf = NULL;
194
        }
195
        return profile;
196
}
197
 
198
ScColorProfile ScLcms2ColorMgmtEngineImpl::createProfile_Lab(ScColorMgmtEngine& engine)
199
{
200
        QString internalProfilePath("memprofile://Internal Lab profile");
201
        ScColorProfile profile = m_profileCache->profile(internalProfilePath);
202
        if (!profile.isNull())
203
                return profile;
204
 
205
        cmsHPROFILE lcmsProf = cmsCreateLab2Profile(NULL);
206
        if (lcmsProf)
207
        {
208
                ScLcms2ColorProfileImpl* profData = new ScLcms2ColorProfileImpl(engine, lcmsProf);
209
                profData->m_profilePath = internalProfilePath;
210
                profile = ScColorProfile(dynamic_cast<ScColorProfileData*>(profData));
211
                m_profileCache->addProfile(profile);
212
        }
213
        if (profile.isNull() && lcmsProf)
214
        {
215
                cmsCloseProfile(lcmsProf);
216
                lcmsProf = NULL;
217
        }
218
        return profile;
219
}
220
 
221
ScColorTransform ScLcms2ColorMgmtEngineImpl::createTransform(ScColorMgmtEngine& engine,
222
                                 const ScColorProfile& inputProfile , eColorFormat inputFormat,
223
                                     const ScColorProfile& outputProfile, eColorFormat outputFormat,
224
                                 eRenderIntent renderIntent, long transformFlags)
225
{
226
        ScColorTransform transform(NULL);
227
        if (inputProfile.isNull() || outputProfile.isNull())
228
                return transform;
229
        int inputProfEngineID  = inputProfile.engine().engineID();
230
        int outputProfEngineID = outputProfile.engine().engineID();
231
        if ((engine.engineID() != m_engineID) || (inputProfEngineID != m_engineID) || (outputProfEngineID != m_engineID))
232
                return transform;
233
        const ScLcms2ColorProfileImpl* lcmsInputProf  = dynamic_cast<const ScLcms2ColorProfileImpl*>(inputProfile.data());
234
        const ScLcms2ColorProfileImpl* lcmsOutputProf = dynamic_cast<const ScLcms2ColorProfileImpl*>(outputProfile.data());
235
        if (!lcmsInputProf || !lcmsOutputProf)
236
                return transform;
237
 
238
        transformFlags &= (~Ctf_Softproofing);
239
        transformFlags &= (~Ctf_GamutCheck);
240
        long strategyFlags = 0;
241
        if (m_strategy.useBlackPointCompensation)
242
                strategyFlags |= Ctf_BlackPointCompensation;
243
        if (m_strategy.useBlackPreservation)
244
                strategyFlags |= Ctf_BlackPreservation;
245
 
246
        ScColorTransformInfo transInfo;
247
        transInfo.inputProfile  = inputProfile.productDescription();
248
        transInfo.outputProfile = outputProfile.productDescription();
249
        transInfo.proofingProfile = QString();
250
        transInfo.inputFormat   = inputFormat;
251
        transInfo.outputFormat  = outputFormat;
252
        transInfo.renderIntent  = renderIntent;
253
        transInfo.proofingIntent = (eRenderIntent) 0;
254
        transInfo.flags = transformFlags | strategyFlags;
255
 
256
        bool nullTransform = false;
257
        if (transInfo.inputProfile == transInfo.outputProfile)
258
        {
259
                // This is a null transform
260
                transInfo.inputProfile    = QString();
261
                transInfo.outputProfile   = QString();
262
                transInfo.proofingProfile = QString();
263
                transInfo.renderIntent    = (eRenderIntent) 0;
264
                transInfo.proofingIntent  = (eRenderIntent) 0;
265
                transInfo.flags = 0;
266
                nullTransform = true;
267
        }
268
 
269
        transform = m_transformPool->findTransform(transInfo);
270
        if (transform.isNull())
271
        {
272
                cmsUInt32Number lcmsFlags     = translateFlagsToLcmsFlags(transformFlags | strategyFlags);
273
                cmsUInt32Number lcmsInputFmt  = translateFormatToLcmsFormat(inputFormat);
274
                cmsUInt32Number lcmsOutputFmt = translateFormatToLcmsFormat(outputFormat);
275
                int   lcmsIntent    = translateIntentToLcmsIntent(renderIntent);
276
                if (nullTransform)
277
                        lcmsFlags |= cmsFLAGS_NULLTRANSFORM;
278
                cmsHTRANSFORM hTransform = NULL;
279
                hTransform = cmsCreateTransform(lcmsInputProf->m_profileHandle , lcmsInputFmt,
280
                                                                                lcmsOutputProf->m_profileHandle, lcmsOutputFmt,
281
                                                                                lcmsIntent, lcmsFlags | cmsFLAGS_LOWRESPRECALC);
282
                if (hTransform)
283
                {
284
                        ScLcms2ColorTransformImpl* newTrans = new ScLcms2ColorTransformImpl(engine, hTransform);
285
                        newTrans->setTransformInfo(transInfo);
286
                        transform = ScColorTransform(dynamic_cast<ScColorTransformData*>(newTrans));
287
                        m_transformPool->addTransform(transform, true);
288
                }
289
        }
290
        return transform;
291
}
292
 
293
ScColorTransform ScLcms2ColorMgmtEngineImpl::createProofingTransform(ScColorMgmtEngine& engine,
294
                                             const ScColorProfile& inputProfile , eColorFormat inputFormat,
295
                                                 const ScColorProfile& outputProfile, eColorFormat outputFormat,
296
                                             const ScColorProfile& proofProfile , eRenderIntent renderIntent,
297
                                             eRenderIntent proofingIntent, long transformFlags)
298
{
299
        ScColorTransform transform(NULL);
300
        if (inputProfile.isNull() || outputProfile.isNull())
301
                return transform;
302
        int inputProfEngineID  = inputProfile.engine().engineID();
303
        int outputProfEngineID = outputProfile.engine().engineID();
304
        int proofProfEngineID  = proofProfile.engine().engineID();
305
        if ((engine.engineID()  != m_engineID) || (inputProfEngineID != m_engineID) ||
306
                (outputProfEngineID != m_engineID) || (proofProfEngineID != m_engineID))
307
                return transform;
308
        const ScLcms2ColorProfileImpl* lcmsInputProf    = dynamic_cast<const ScLcms2ColorProfileImpl*>(inputProfile.data());
309
        const ScLcms2ColorProfileImpl* lcmsOutputProf   = dynamic_cast<const ScLcms2ColorProfileImpl*>(outputProfile.data());
310
        const ScLcms2ColorProfileImpl* lcmsProofingProf = dynamic_cast<const ScLcms2ColorProfileImpl*>(proofProfile.data());
311
        if (!lcmsInputProf || !lcmsOutputProf || !lcmsProofingProf)
312
                return transform;
313
 
314
        long strategyFlags = 0;
315
        if (m_strategy.useBlackPointCompensation)
316
                strategyFlags |= Ctf_BlackPointCompensation;
317
        if (m_strategy.useBlackPreservation)
318
                strategyFlags |= Ctf_BlackPreservation;
319
 
320
        ScColorTransformInfo transInfo;
321
        transInfo.inputProfile    = inputProfile.productDescription();
322
        transInfo.outputProfile   = outputProfile.productDescription();
323
        transInfo.proofingProfile = proofProfile.productDescription();
324
        transInfo.inputFormat     = inputFormat;
325
        transInfo.outputFormat    = outputFormat;
326
        transInfo.renderIntent    = renderIntent;
327
        transInfo.proofingIntent  = proofingIntent;
328
        transInfo.flags = transformFlags | strategyFlags;
329
 
330
        cmsUInt32Number lcmsFlags     = translateFlagsToLcmsFlags(transformFlags | strategyFlags);
331
        cmsUInt32Number lcmsInputFmt  = translateFormatToLcmsFormat(inputFormat);
332
        cmsUInt32Number lcmsOutputFmt = translateFormatToLcmsFormat(outputFormat);
333
        int   lcmsIntent    = translateIntentToLcmsIntent(renderIntent);
334
        int   lcmsPrfIntent = translateIntentToLcmsIntent(proofingIntent);
335
 
336
        if (transInfo.inputProfile != transInfo.proofingProfile)
337
        {
338
                if (transInfo.proofingProfile == transInfo.outputProfile)
339
                {
340
                        transInfo.proofingIntent = Intent_Relative_Colorimetric;
341
                        lcmsPrfIntent = translateIntentToLcmsIntent(Intent_Relative_Colorimetric);
342
                }
343
                transform = m_transformPool->findTransform(transInfo);
344
                if (transform.isNull())
345
                {
346
                        cmsHTRANSFORM hTransform = NULL;
347
                        hTransform = cmsCreateProofingTransform(lcmsInputProf->m_profileHandle , lcmsInputFmt,
348
                                                                                                        lcmsOutputProf->m_profileHandle, lcmsOutputFmt,
349
                                                                                                        lcmsProofingProf->m_profileHandle, lcmsIntent,
350
                                                                                                        lcmsPrfIntent, lcmsFlags | cmsFLAGS_SOFTPROOFING);
351
                        if (hTransform)
352
                        {
353
                                ScLcms2ColorTransformImpl* newTrans = new ScLcms2ColorTransformImpl(engine, hTransform);
354
                                newTrans->setTransformInfo(transInfo);
355
                                transform = ScColorTransform(dynamic_cast<ScColorTransformData*>(newTrans));
356
                                m_transformPool->addTransform(transform, true);
357
                        }
358
                }
359
        }
360
        else
361
        {
362
                transformFlags  &= (~Ctf_Softproofing);
363
                transformFlags  &= (~Ctf_GamutCheck);
364
                lcmsFlags        = translateFlagsToLcmsFlags(transformFlags | strategyFlags);
365
                transInfo.flags  = transformFlags | strategyFlags;
366
                transInfo.renderIntent   = proofingIntent;
367
                transInfo.proofingIntent = (eRenderIntent) 0;
368
                if (transInfo.inputProfile == transInfo.outputProfile)
369
                {
370
                        lcmsFlags |= cmsFLAGS_NULLTRANSFORM;
371
                        transInfo.inputProfile    = QString();
372
                        transInfo.outputProfile   = QString();
373
                        transInfo.proofingProfile = QString();
374
                        transInfo.renderIntent    = (eRenderIntent) 0;
375
                        transInfo.proofingIntent  = (eRenderIntent) 0;
376
                        transInfo.flags = 0;
377
                }
378
                transform = m_transformPool->findTransform(transInfo);
379
                if (transform.isNull())
380
                {
381
                        cmsHTRANSFORM hTransform = NULL;
382
                        hTransform  = cmsCreateTransform(lcmsInputProf->m_profileHandle , lcmsInputFmt,
383
                                                                                     lcmsOutputProf->m_profileHandle, lcmsOutputFmt,
384
                                                                                         lcmsPrfIntent, lcmsFlags | cmsFLAGS_LOWRESPRECALC);
385
                        if (hTransform)
386
                        {
387
                                ScLcms2ColorTransformImpl* newTrans = new ScLcms2ColorTransformImpl(engine, hTransform);
388
                                newTrans->setTransformInfo(transInfo);
389
                                transform = ScColorTransform(dynamic_cast<ScColorTransformData*>(newTrans));
390
                                m_transformPool->addTransform(transform, true);
391
                        }
392
                }
393
        }
394
        return transform;
395
}
396
 
397
cmsUInt32Number ScLcms2ColorMgmtEngineImpl::translateFlagsToLcmsFlags(long flags)
398
{
399
        cmsUInt32Number lFlags = 0;
400
        if (flags & Ctf_BlackPointCompensation)
401
                lFlags |= cmsFLAGS_BLACKPOINTCOMPENSATION;
402
        if (flags & Ctf_BlackPreservation)
403
                lFlags |= cmsFLAGS_PRESERVEBLACK;
404
        if (flags & Ctf_Softproofing)
405
                lFlags |= cmsFLAGS_SOFTPROOFING;
406
        if (flags & Ctf_GamutCheck)
407
                lFlags |= cmsFLAGS_GAMUTCHECK;
408
        return lFlags;
409
}
410
 
411
cmsUInt32Number ScLcms2ColorMgmtEngineImpl::translateFormatToLcmsFormat(eColorFormat format)
412
{
413
        cmsUInt32Number lFormat = 0;
414
        if (format == Format_RGB_8)
415
                lFormat = TYPE_RGB_8;
416
        if (format == Format_RGB_16)
417
                lFormat = TYPE_RGB_16;
418
        if (format == Format_RGBA_8)
419
                lFormat = TYPE_RGBA_8;
420
        if (format == Format_RGBA_16)
421
                lFormat = TYPE_RGBA_16;
422
        if (format == Format_ARGB_8)
423
                lFormat = TYPE_ARGB_8;
424
        if (format == Format_ARGB_16)
425
                lFormat = TYPE_ARGB_16;
426
        if (format == Format_BGRA_8)
427
                lFormat = TYPE_BGRA_8;
428
        if (format == Format_BGRA_16)
429
                lFormat = TYPE_BGRA_16;
430
        if (format == Format_CMYK_8)
431
                lFormat = TYPE_CMYK_8;
432
        if (format == Format_CMYK_16)
433
                lFormat = TYPE_CMYK_16;
434
        if (format == Format_CMYKA_8)
435
                lFormat = (COLORSPACE_SH(PT_CMYK)|EXTRA_SH(1)|CHANNELS_SH(4)|BYTES_SH(1));
436
        if (format == Format_CMYKA_16)
437
                lFormat = (COLORSPACE_SH(PT_CMYK)|EXTRA_SH(1)|CHANNELS_SH(4)|BYTES_SH(2));
438
        if (format == Format_YMCK_8)
439
                lFormat = (COLORSPACE_SH(PT_CMYK)|CHANNELS_SH(4)|BYTES_SH(1)|DOSWAP_SH(1)|SWAPFIRST_SH(1));
440
        if (format == Format_YMCK_16)
441
                lFormat = (COLORSPACE_SH(PT_CMYK)|CHANNELS_SH(4)|BYTES_SH(2)|DOSWAP_SH(1)|SWAPFIRST_SH(1));
442
        if (format == Format_GRAY_8)
443
                lFormat = TYPE_GRAY_8;
444
        if (format == Format_GRAY_16)
445
                lFormat = TYPE_GRAY_16;
446
        if (format == Format_LabA_8)
447
                lFormat = COLORSPACE_SH(PT_Lab)|CHANNELS_SH(3)|BYTES_SH(1)|EXTRA_SH(1);
448
        return lFormat;
449
}
450
 
451
int ScLcms2ColorMgmtEngineImpl::translateIntentToLcmsIntent(eRenderIntent intent, eRenderIntent defIntent)
452
{
453
        int lIntent = defIntent;
454
        if (intent == Intent_Perceptual)
455
                lIntent = INTENT_PERCEPTUAL;
456
        if (intent == Intent_Relative_Colorimetric)
457
                lIntent = INTENT_RELATIVE_COLORIMETRIC;
458
        if (intent == Intent_Saturation)
459
                lIntent = INTENT_SATURATION;
460
        if (intent == Intent_Absolute_Colorimetric)
461
                lIntent = INTENT_ABSOLUTE_COLORIMETRIC;
462
        return lIntent;
463
}
464
 
465
eColorSpaceType ScLcms2ColorMgmtEngineImpl::translateLcmsColorSpaceType(cmsColorSpaceSignature signature)
466
{
467
        eColorSpaceType colorSpaceType = ColorSpace_Unknown;
468
    if (signature == cmsSigXYZData)
469
                colorSpaceType = ColorSpace_XYZ;
470
    if (signature == cmsSigLabData)
471
                colorSpaceType = ColorSpace_Lab;
472
    if (signature == cmsSigLuvData)
473
                colorSpaceType = ColorSpace_Luv;
474
    if (signature == cmsSigYCbCrData)
475
                colorSpaceType = ColorSpace_YCbCr;
476
    if (signature == cmsSigYxyData)
477
                colorSpaceType = ColorSpace_Yxy;
478
    if (signature == cmsSigRgbData)
479
                colorSpaceType = ColorSpace_Rgb;
480
    if (signature == cmsSigGrayData)
481
                colorSpaceType = ColorSpace_Gray;
482
    if (signature == cmsSigHsvData)
483
                colorSpaceType = ColorSpace_Hsv;
484
    if (signature == cmsSigHlsData)
485
                colorSpaceType = ColorSpace_Hls;
486
    if (signature == cmsSigCmykData)
487
                colorSpaceType = ColorSpace_Cmyk;
488
    if (signature == cmsSigCmyData)
489
                colorSpaceType = ColorSpace_Cmy;
490
        return colorSpaceType;
491
}
492
 
493
eProfileClass ScLcms2ColorMgmtEngineImpl::translateLcmsProfileClass(cmsProfileClassSignature signature)
494
{
495
        eProfileClass profileClass = Class_Unknown;
496
        if (signature == cmsSigInputClass)
497
                profileClass = Class_Input;
498
    if (signature == cmsSigDisplayClass)
499
                profileClass = Class_Display;
500
    if (signature == cmsSigOutputClass)
501
                profileClass = Class_Output;
502
    if (signature == cmsSigLinkClass)
503
                profileClass = Class_Link;
504
    if (signature == cmsSigAbstractClass)
505
                profileClass = Class_Abstract;
506
    if (signature == cmsSigColorSpaceClass)
507
                profileClass = Class_ColorSpace;
508
    if (signature == cmsSigNamedColorClass)
509
                profileClass = Class_NamedColor;
510
        return profileClass;
511
}
512
 
513
void ScLcms2ColorMgmtEngineImpl::cmsErrorHandler(cmsContext contextID, cmsUInt32Number /*ErrorCode*/,
514
                                                                                                 const char *ErrorText)
515
{
516
        std::string msg = std::string("Littlecms : ") + ErrorText;
517
        std::cerr << ErrorText << std::endl;
518
}