mirror of https://github.com/JakubMelka/PDF4QT.git
1948 lines
73 KiB
C++
1948 lines
73 KiB
C++
// Copyright (C) 2019-2021 Jakub Melka
|
||
//
|
||
// This file is part of PDF4QT.
|
||
//
|
||
// PDF4QT is free software: you can redistribute it and/or modify
|
||
// it under the terms of the GNU Lesser General Public License as published by
|
||
// the Free Software Foundation, either version 3 of the License, or
|
||
// with the written consent of the copyright owner, any later version.
|
||
//
|
||
// PDF4QT is distributed in the hope that it will be useful,
|
||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
// GNU Lesser General Public License for more details.
|
||
//
|
||
// You should have received a copy of the GNU Lesser General Public License
|
||
// along with PDF4QT. If not, see <https://www.gnu.org/licenses/>.
|
||
|
||
#include "pdfcms.h"
|
||
#include "pdfdocument.h"
|
||
#include "pdfexecutionpolicy.h"
|
||
|
||
#include <QApplication>
|
||
#include <QReadWriteLock>
|
||
|
||
#pragma warning(push)
|
||
#pragma warning(disable:5033)
|
||
#define CMS_NO_REGISTER_KEYWORD
|
||
#include <lcms2.h>
|
||
#include <lcms2_plugin.h>
|
||
#pragma warning(pop)
|
||
|
||
|
||
#ifdef Q_OS_WIN
|
||
#define NOMINMAX
|
||
#include <Windows.h>
|
||
#include <Icm.h>
|
||
#pragma comment(lib, "Mscms")
|
||
#endif
|
||
|
||
#include <unordered_map>
|
||
|
||
namespace pdf
|
||
{
|
||
|
||
class PDFLittleCMS : public PDFCMS
|
||
{
|
||
public:
|
||
explicit PDFLittleCMS(const PDFCMSManager* manager, const PDFCMSSettings& settings);
|
||
virtual ~PDFLittleCMS() override;
|
||
|
||
virtual bool isCompatible(const PDFCMSSettings& settings) const override;
|
||
virtual QColor getPaperColor() const override;
|
||
virtual QColor getColorFromDeviceGray(const PDFColor& color, RenderingIntent intent, PDFRenderErrorReporter* reporter) const override;
|
||
virtual QColor getColorFromDeviceRGB(const PDFColor& color, RenderingIntent intent, PDFRenderErrorReporter* reporter) const override;
|
||
virtual QColor getColorFromDeviceCMYK(const PDFColor& color, RenderingIntent intent, PDFRenderErrorReporter* reporter) const override;
|
||
virtual QColor getColorFromXYZ(const PDFColor3& whitePoint, const PDFColor3& color, RenderingIntent intent, PDFRenderErrorReporter* reporter) const override;
|
||
virtual QColor getColorFromICC(const PDFColor& color, RenderingIntent renderingIntent, const QByteArray& iccID, const QByteArray& iccData, PDFRenderErrorReporter* reporter) const override;
|
||
virtual bool fillRGBBufferFromDeviceGray(const std::vector<float>& colors, RenderingIntent intent, unsigned char* outputBuffer, PDFRenderErrorReporter* reporter) const override;
|
||
virtual bool fillRGBBufferFromDeviceRGB(const std::vector<float>& colors, RenderingIntent intent, unsigned char* outputBuffer, PDFRenderErrorReporter* reporter) const override;
|
||
virtual bool fillRGBBufferFromDeviceCMYK(const std::vector<float>& colors, RenderingIntent intent, unsigned char* outputBuffer, PDFRenderErrorReporter* reporter) const override;
|
||
virtual bool fillRGBBufferFromXYZ(const PDFColor3& whitePoint, const std::vector<float>& colors, RenderingIntent intent, unsigned char* outputBuffer, PDFRenderErrorReporter* reporter) const override;
|
||
virtual bool fillRGBBufferFromICC(const std::vector<float>& colors, RenderingIntent renderingIntent, unsigned char* outputBuffer, const QByteArray& iccID, const QByteArray& iccData, PDFRenderErrorReporter* reporter) const override;
|
||
virtual bool transformColorSpace(const ColorSpaceTransformParams& params) const override;
|
||
|
||
private:
|
||
void init();
|
||
|
||
static int installCmsPlugins();
|
||
|
||
static cmsBool optimizePipeline(cmsPipeline** Lut,
|
||
cmsUInt32Number Intent,
|
||
cmsUInt32Number* InputFormat,
|
||
cmsUInt32Number* OutputFormat,
|
||
cmsUInt32Number* dwFlags);
|
||
|
||
enum Profile
|
||
{
|
||
Output,
|
||
Gray,
|
||
RGB,
|
||
CMYK,
|
||
XYZ,
|
||
SoftProofing,
|
||
ProfileCount
|
||
};
|
||
|
||
/// Returns true, if we are doing soft-proofing
|
||
bool isSoftProofing() const;
|
||
|
||
/// Creates a profile using provided id and a list of profile descriptors.
|
||
/// If profile can't be created, then null handle is returned. If \p preferOutputProfile
|
||
/// is set to true, and given profile is not output profile, then first output profile
|
||
/// is being selected.
|
||
/// \param id Id of color profile
|
||
/// \param profileDescriptors Profile descriptor list
|
||
/// \param preferOutputProfile
|
||
cmsHPROFILE createProfile(const QString& id, const PDFColorProfileIdentifiers& profileDescriptors, bool preferOutputProfile) const;
|
||
|
||
/// Gets transform from cache. If transform doesn't exist, then it is created.
|
||
/// \param profile Color profile
|
||
/// \param intent Rendering intent
|
||
/// \param isRGB888Buffer If true, 8-bit RGB output buffer is used, otherwise FLOAT RGB output buffer is used
|
||
cmsHTRANSFORM getTransform(Profile profile, RenderingIntent intent, bool isRGB888Buffer) const;
|
||
|
||
/// Gets transform for ICC profile from cache. If transform doesn't exist, then it is created.
|
||
/// \param iccData Data of icc profile
|
||
/// \param iccID Icc profile id
|
||
/// \param renderingIntent Rendering intent
|
||
/// \param isRGB888Buffer If true, 8-bit RGB output buffer is used, otherwise FLOAT RGB output buffer is used
|
||
cmsHTRANSFORM getTransformFromICCProfile(const QByteArray& iccData, const QByteArray& iccID, RenderingIntent renderingIntent, bool isRGB888Buffer) const;
|
||
|
||
/// Returns transformation flags according to the current settings
|
||
cmsUInt32Number getTransformationFlags() const;
|
||
|
||
/// Calculates effective rendering intent. If rendering intent is auto,
|
||
/// then \p intent is used, otherwise intent is overriden.
|
||
RenderingIntent getEffectiveRenderingIntent(RenderingIntent intent) const;
|
||
|
||
/// Gets transform from cache key.
|
||
/// \param profile Color profile
|
||
/// \param intent Rendering intent
|
||
/// \param isRGB888Buffer If true, 8-bit RGB output buffer is used, otherwise FLOAT RGB output buffer is used
|
||
static constexpr int getCacheKey(Profile profile, RenderingIntent intent, bool isRGB888Buffer) { return ((int(intent) * ProfileCount + profile) << 1) + (isRGB888Buffer ? 1 : 0); }
|
||
|
||
/// Returns little CMS rendering intent
|
||
/// \param intent Rendering intent
|
||
static cmsUInt32Number getLittleCMSRenderingIntent(RenderingIntent intent);
|
||
|
||
/// Returns little CMS data format for profile
|
||
/// \param profile Color profile handle
|
||
static cmsUInt32Number getProfileDataFormat(cmsHPROFILE profile);
|
||
|
||
/// Returns color from output color. Clamps invalid rgb output values to range [0.0, 1.0].
|
||
/// \param color01 Rgb color (range 0-1 is assumed).
|
||
static QColor getColorFromOutputColor(std::array<float, 3> color01);
|
||
|
||
/// Returns transform key for transformation between various color spaces
|
||
static QByteArray getTransformColorSpaceKey(const ColorSpaceTransformParams& params);
|
||
|
||
cmsHTRANSFORM getTransformBetweenColorSpaces(const ColorSpaceTransformParams& params) const;
|
||
|
||
const PDFCMSManager* m_manager;
|
||
PDFCMSSettings m_settings;
|
||
QColor m_paperColor;
|
||
std::array<cmsHPROFILE, ProfileCount> m_profiles;
|
||
|
||
mutable QReadWriteLock m_transformationCacheLock;
|
||
mutable std::unordered_map<int, cmsHTRANSFORM> m_transformationCache;
|
||
|
||
mutable QReadWriteLock m_customIccProfileCacheLock;
|
||
mutable std::map<std::pair<QByteArray, RenderingIntent>, cmsHTRANSFORM> m_customIccProfileCache;
|
||
|
||
mutable QReadWriteLock m_transformColorSpaceCacheLock;
|
||
mutable std::map<QByteArray, cmsHTRANSFORM> m_transformColorSpaceCache;
|
||
};
|
||
|
||
bool PDFLittleCMS::fillRGBBufferFromDeviceGray(const std::vector<float>& colors,
|
||
RenderingIntent intent,
|
||
unsigned char* outputBuffer,
|
||
PDFRenderErrorReporter* reporter) const
|
||
{
|
||
cmsHTRANSFORM transform = getTransform(Gray, getEffectiveRenderingIntent(intent), true);
|
||
|
||
if (!transform)
|
||
{
|
||
reporter->reportRenderErrorOnce(RenderErrorType::Error, PDFTranslationContext::tr("Conversion from gray to output device using CMS failed."));
|
||
return false;
|
||
}
|
||
|
||
if (cmsGetTransformInputFormat(transform) == TYPE_GRAY_FLT)
|
||
{
|
||
Q_ASSERT(cmsGetTransformOutputFormat(transform) == TYPE_RGB_8);
|
||
cmsDoTransform(transform, colors.data(), outputBuffer, static_cast<cmsUInt32Number>(colors.size()));
|
||
return true;
|
||
}
|
||
else
|
||
{
|
||
reporter->reportRenderErrorOnce(RenderErrorType::Error, PDFTranslationContext::tr("Conversion from gray to output device using CMS failed - invalid data format."));
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
bool PDFLittleCMS::fillRGBBufferFromDeviceRGB(const std::vector<float>& colors, RenderingIntent intent, unsigned char* outputBuffer, PDFRenderErrorReporter* reporter) const
|
||
{
|
||
cmsHTRANSFORM transform = getTransform(RGB, getEffectiveRenderingIntent(intent), true);
|
||
|
||
if (!transform)
|
||
{
|
||
reporter->reportRenderErrorOnce(RenderErrorType::Error, PDFTranslationContext::tr("Conversion from RGB to output device using CMS failed."));
|
||
return false;
|
||
}
|
||
|
||
const cmsUInt32Number inputFormat = cmsGetTransformInputFormat(transform);
|
||
if (inputFormat == TYPE_RGB_FLT && (colors.size()) % T_CHANNELS(inputFormat) == 0)
|
||
{
|
||
Q_ASSERT(cmsGetTransformOutputFormat(transform) == TYPE_RGB_8);
|
||
cmsDoTransform(transform, colors.data(), outputBuffer, static_cast<cmsUInt32Number>(colors.size()) / T_CHANNELS(inputFormat));
|
||
return true;
|
||
}
|
||
else
|
||
{
|
||
reporter->reportRenderErrorOnce(RenderErrorType::Error, PDFTranslationContext::tr("Conversion from RGB to output device using CMS failed - invalid data format."));
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
bool PDFLittleCMS::fillRGBBufferFromDeviceCMYK(const std::vector<float>& colors, RenderingIntent intent, unsigned char* outputBuffer, PDFRenderErrorReporter* reporter) const
|
||
{
|
||
cmsHTRANSFORM transform = getTransform(CMYK, getEffectiveRenderingIntent(intent), true);
|
||
|
||
if (!transform)
|
||
{
|
||
reporter->reportRenderErrorOnce(RenderErrorType::Error, PDFTranslationContext::tr("Conversion from CMYK to output device using CMS failed."));
|
||
return false;
|
||
}
|
||
|
||
const cmsUInt32Number inputFormat = cmsGetTransformInputFormat(transform);
|
||
if (inputFormat == TYPE_CMYK_FLT && (colors.size()) % T_CHANNELS(inputFormat) == 0)
|
||
{
|
||
Q_ASSERT(cmsGetTransformOutputFormat(transform) == TYPE_RGB_8);
|
||
std::vector<float> fixedColors = colors;
|
||
for (size_t i = 0, count = fixedColors.size(); i < count; ++i)
|
||
{
|
||
fixedColors[i] = fixedColors[i] * 100.0f;
|
||
}
|
||
cmsDoTransform(transform, fixedColors.data(), outputBuffer, static_cast<cmsUInt32Number>(colors.size()) / T_CHANNELS(inputFormat));
|
||
return true;
|
||
}
|
||
else
|
||
{
|
||
reporter->reportRenderErrorOnce(RenderErrorType::Error, PDFTranslationContext::tr("Conversion from CMYK to output device using CMS failed - invalid data format."));
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
bool PDFLittleCMS::fillRGBBufferFromXYZ(const PDFColor3& whitePoint, const std::vector<float>& colors, RenderingIntent intent, unsigned char* outputBuffer, PDFRenderErrorReporter* reporter) const
|
||
{
|
||
cmsHTRANSFORM transform = getTransform(XYZ, getEffectiveRenderingIntent(intent), true);
|
||
|
||
if (!transform)
|
||
{
|
||
reporter->reportRenderErrorOnce(RenderErrorType::Error, PDFTranslationContext::tr("Conversion from XYZ to output device using CMS failed."));
|
||
return false;
|
||
}
|
||
|
||
const cmsUInt32Number inputFormat = cmsGetTransformInputFormat(transform);
|
||
if (inputFormat == TYPE_XYZ_FLT && (colors.size()) % T_CHANNELS(inputFormat) == 0)
|
||
{
|
||
Q_ASSERT(cmsGetTransformOutputFormat(transform) == TYPE_RGB_8);
|
||
|
||
PDFColorComponentMatrix_3x3 adaptationMatrix = PDFChromaticAdaptationXYZ::createWhitepointChromaticAdaptation(getDefaultXYZWhitepoint(), whitePoint, m_settings.colorAdaptationXYZ);
|
||
std::vector<float> fixedColors = colors;
|
||
|
||
const size_t count = fixedColors.size() / 3;
|
||
for (size_t i = 0; i < count; ++i)
|
||
{
|
||
const size_t indexX = i * 3;
|
||
const size_t indexY = i * 3 + 1;
|
||
const size_t indexZ = i * 3 + 2;
|
||
const PDFColor3 sourceXYZ = { fixedColors[indexX], fixedColors[indexY], fixedColors[indexZ] };
|
||
const PDFColor3 adaptedXYZ = adaptationMatrix * sourceXYZ;
|
||
fixedColors[indexX] = adaptedXYZ[0];
|
||
fixedColors[indexY] = adaptedXYZ[1];
|
||
fixedColors[indexZ] = adaptedXYZ[2];
|
||
}
|
||
|
||
cmsDoTransform(transform, fixedColors.data(), outputBuffer, static_cast<cmsUInt32Number>(colors.size()) / T_CHANNELS(inputFormat));
|
||
return true;
|
||
}
|
||
else
|
||
{
|
||
reporter->reportRenderErrorOnce(RenderErrorType::Error, PDFTranslationContext::tr("Conversion from XYZ to output device using CMS failed - invalid data format."));
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
bool PDFLittleCMS::fillRGBBufferFromICC(const std::vector<float>& colors, RenderingIntent renderingIntent, unsigned char* outputBuffer, const QByteArray& iccID, const QByteArray& iccData, PDFRenderErrorReporter* reporter) const
|
||
{
|
||
cmsHTRANSFORM transform = getTransformFromICCProfile(iccData, iccID, renderingIntent, true);
|
||
|
||
if (!transform)
|
||
{
|
||
reporter->reportRenderErrorOnce(RenderErrorType::Error, PDFTranslationContext::tr("Conversion from icc profile space to output device using CMS failed."));
|
||
return false;
|
||
}
|
||
|
||
const cmsUInt32Number format = cmsGetTransformInputFormat(transform);
|
||
const cmsUInt32Number channels = T_CHANNELS(format);
|
||
const cmsUInt32Number colorSpace = T_COLORSPACE(format);
|
||
const bool isCMYK = colorSpace == PT_CMYK;
|
||
const float* inputColors = colors.data();
|
||
std::vector<float> cmykColors;
|
||
|
||
if (isCMYK)
|
||
{
|
||
cmykColors = colors;
|
||
for (size_t i = 0; i < cmykColors.size(); ++i)
|
||
{
|
||
cmykColors[i] = cmykColors[i] * 100.0f;
|
||
}
|
||
inputColors = cmykColors.data();
|
||
}
|
||
|
||
if (colors.size() % channels == 0)
|
||
{
|
||
const cmsUInt32Number pixels = static_cast<cmsUInt32Number>(colors.size()) / channels;
|
||
cmsDoTransform(transform, inputColors, outputBuffer, pixels);
|
||
return true;
|
||
}
|
||
else
|
||
{
|
||
reporter->reportRenderErrorOnce(RenderErrorType::Error, PDFTranslationContext::tr("Conversion from icc profile space to output device using CMS failed - invalid data format."));
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
bool PDFLittleCMS::transformColorSpace(const PDFCMS::ColorSpaceTransformParams& params) const
|
||
{
|
||
PDFCMS::ColorSpaceTransformParams transformedParams = params;
|
||
transformedParams.intent = getEffectiveRenderingIntent(transformedParams.intent);
|
||
|
||
cmsHTRANSFORM transform = getTransformBetweenColorSpaces(transformedParams);
|
||
if (!transform)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
const cmsUInt32Number inputProfileFormat = cmsGetTransformInputFormat(transform);
|
||
const cmsUInt32Number inputChannels = T_CHANNELS(inputProfileFormat);
|
||
const cmsUInt32Number inputColorSpace = T_COLORSPACE(inputProfileFormat);
|
||
const bool isInputCMYK = inputColorSpace == PT_CMYK;
|
||
const float* inputColors = params.input.begin();
|
||
std::vector<float> cmykColors;
|
||
|
||
const cmsUInt32Number outputProfileFormat = cmsGetTransformOutputFormat(transform);
|
||
const cmsUInt32Number outputChannels = T_CHANNELS(outputProfileFormat);
|
||
const cmsUInt32Number outputColorSpace = T_COLORSPACE(outputProfileFormat);
|
||
const bool isOutputCMYK = outputColorSpace == PT_CMYK;
|
||
|
||
if (isInputCMYK)
|
||
{
|
||
cmykColors = std::vector<float>(params.input.cbegin(), params.input.cend());
|
||
for (size_t i = 0; i < cmykColors.size(); ++i)
|
||
{
|
||
cmykColors[i] = cmykColors[i] * 100.0f;
|
||
}
|
||
inputColors = cmykColors.data();
|
||
}
|
||
|
||
const cmsUInt32Number inputPixelCount = static_cast<cmsUInt32Number>(params.input.size()) / inputChannels;
|
||
const cmsUInt32Number outputPixelCount = static_cast<cmsUInt32Number>(params.output.size()) / outputChannels;
|
||
|
||
if (params.input.size() % inputChannels == 0 &&
|
||
params.output.size() % outputChannels == 0 &&
|
||
inputPixelCount == outputPixelCount)
|
||
{
|
||
PDFColorBuffer outputBuffer = params.output;
|
||
|
||
if (inputPixelCount > params.multithreadingThreshold)
|
||
{
|
||
struct TransformInfo
|
||
{
|
||
inline TransformInfo(const float* source, float* target, cmsUInt32Number pixelCount) :
|
||
source(source),
|
||
target(target),
|
||
pixelCount(pixelCount)
|
||
{
|
||
|
||
}
|
||
|
||
const float* source = nullptr;
|
||
float* target = nullptr;
|
||
cmsUInt32Number pixelCount = 0;
|
||
};
|
||
|
||
const cmsUInt32Number blockSize = 4096;
|
||
std::vector<TransformInfo> infos;
|
||
infos.reserve(inputPixelCount / blockSize + 1);
|
||
|
||
const float* sourcePointer = inputColors;
|
||
float* targetPointer = outputBuffer.begin();
|
||
|
||
cmsUInt32Number remainingPixelCount = inputPixelCount;
|
||
while (remainingPixelCount > 0)
|
||
{
|
||
const cmsUInt32Number currentPixelCount = qMin(blockSize, remainingPixelCount);
|
||
infos.emplace_back(sourcePointer, targetPointer, currentPixelCount);
|
||
sourcePointer += currentPixelCount * inputChannels;
|
||
targetPointer += currentPixelCount * outputChannels;
|
||
remainingPixelCount -= currentPixelCount;
|
||
}
|
||
|
||
auto processEntry = [transform](const TransformInfo& info)
|
||
{
|
||
cmsDoTransform(transform, info.source, info.target, info.pixelCount);
|
||
};
|
||
PDFExecutionPolicy::execute(PDFExecutionPolicy::Scope::Content, infos.begin(), infos.end(), processEntry);
|
||
}
|
||
else
|
||
{
|
||
// Single-threaded transform
|
||
cmsDoTransform(transform, inputColors, outputBuffer.begin(), inputPixelCount);
|
||
}
|
||
|
||
if (isOutputCMYK)
|
||
{
|
||
const PDFColorComponent colorQuotient = 1.0f / 100.0f;
|
||
for (PDFColorComponent& color : outputBuffer)
|
||
{
|
||
color *= colorQuotient;
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
else
|
||
{
|
||
return false;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
PDFLittleCMS::PDFLittleCMS(const PDFCMSManager* manager, const PDFCMSSettings& settings) :
|
||
m_manager(manager),
|
||
m_settings(settings),
|
||
m_paperColor(Qt::white),
|
||
m_profiles()
|
||
{
|
||
static const int installed = installCmsPlugins();
|
||
Q_UNUSED(installed);
|
||
|
||
init();
|
||
}
|
||
|
||
PDFLittleCMS::~PDFLittleCMS()
|
||
{
|
||
for (const auto& transformItem : m_transformationCache)
|
||
{
|
||
cmsHTRANSFORM transform = transformItem.second;
|
||
if (transform)
|
||
{
|
||
cmsDeleteTransform(transform);
|
||
}
|
||
}
|
||
|
||
for (const auto& transformItem : m_customIccProfileCache)
|
||
{
|
||
cmsHTRANSFORM transform = transformItem.second;
|
||
if (transform)
|
||
{
|
||
cmsDeleteTransform(transform);
|
||
}
|
||
}
|
||
|
||
for (const auto& transformItem : m_transformColorSpaceCache)
|
||
{
|
||
cmsHTRANSFORM transform = transformItem.second;
|
||
if (transform)
|
||
{
|
||
cmsDeleteTransform(transform);
|
||
}
|
||
}
|
||
|
||
for (cmsHPROFILE profile : m_profiles)
|
||
{
|
||
if (profile)
|
||
{
|
||
cmsCloseProfile(profile);
|
||
}
|
||
}
|
||
}
|
||
|
||
bool PDFLittleCMS::isCompatible(const PDFCMSSettings& settings) const
|
||
{
|
||
return m_settings == settings;
|
||
}
|
||
|
||
QColor PDFLittleCMS::getPaperColor() const
|
||
{
|
||
return m_paperColor;
|
||
}
|
||
|
||
QColor PDFLittleCMS::getColorFromDeviceGray(const PDFColor& color, RenderingIntent intent, PDFRenderErrorReporter* reporter) const
|
||
{
|
||
cmsHTRANSFORM transform = getTransform(Gray, getEffectiveRenderingIntent(intent), false);
|
||
|
||
if (!transform)
|
||
{
|
||
reporter->reportRenderErrorOnce(RenderErrorType::Error, PDFTranslationContext::tr("Conversion from gray to output device using CMS failed."));
|
||
return QColor();
|
||
}
|
||
|
||
if (cmsGetTransformInputFormat(transform) == TYPE_GRAY_FLT && color.size() == 1)
|
||
{
|
||
Q_ASSERT(cmsGetTransformOutputFormat(transform) == TYPE_RGB_FLT);
|
||
|
||
const float grayColor = color[0];
|
||
std::array<float, 3> rgbOutputColor = { };
|
||
cmsDoTransform(transform, &grayColor, rgbOutputColor.data(), 1);
|
||
return getColorFromOutputColor(rgbOutputColor);
|
||
}
|
||
else
|
||
{
|
||
reporter->reportRenderErrorOnce(RenderErrorType::Error, PDFTranslationContext::tr("Conversion from gray to output device using CMS failed - invalid data format."));
|
||
}
|
||
|
||
return QColor();
|
||
}
|
||
|
||
QColor PDFLittleCMS::getColorFromDeviceRGB(const PDFColor& color, RenderingIntent intent, PDFRenderErrorReporter* reporter) const
|
||
{
|
||
cmsHTRANSFORM transform = getTransform(RGB, getEffectiveRenderingIntent(intent), false);
|
||
|
||
if (!transform)
|
||
{
|
||
reporter->reportRenderErrorOnce(RenderErrorType::Error, PDFTranslationContext::tr("Conversion from RGB to output device using CMS failed."));
|
||
return QColor();
|
||
}
|
||
|
||
if (cmsGetTransformInputFormat(transform) == TYPE_RGB_FLT && color.size() == 3)
|
||
{
|
||
Q_ASSERT(cmsGetTransformOutputFormat(transform) == TYPE_RGB_FLT);
|
||
|
||
std::array<float, 3> rgbInputColor = { color[0], color[1], color[2] };
|
||
std::array<float, 3> rgbOutputColor = { };
|
||
cmsDoTransform(transform, rgbInputColor.data(), rgbOutputColor.data(), 1);
|
||
return getColorFromOutputColor(rgbOutputColor);
|
||
}
|
||
else
|
||
{
|
||
reporter->reportRenderErrorOnce(RenderErrorType::Error, PDFTranslationContext::tr("Conversion from RGB to output device using CMS failed - invalid data format."));
|
||
}
|
||
|
||
return QColor();
|
||
}
|
||
|
||
QColor PDFLittleCMS::getColorFromDeviceCMYK(const PDFColor& color, RenderingIntent intent, PDFRenderErrorReporter* reporter) const
|
||
{
|
||
cmsHTRANSFORM transform = getTransform(CMYK, getEffectiveRenderingIntent(intent), false);
|
||
|
||
if (!transform)
|
||
{
|
||
reporter->reportRenderErrorOnce(RenderErrorType::Error, PDFTranslationContext::tr("Conversion from CMYK to output device using CMS failed."));
|
||
return QColor();
|
||
}
|
||
|
||
if (cmsGetTransformInputFormat(transform) == TYPE_CMYK_FLT && color.size() == 4)
|
||
{
|
||
Q_ASSERT(cmsGetTransformOutputFormat(transform) == TYPE_RGB_FLT);
|
||
|
||
std::array<float, 4> cmykInputColor = { color[0] * 100.0f, color[1] * 100.0f, color[2] * 100.0f, color[3] * 100.0f };
|
||
std::array<float, 3> rgbOutputColor = { };
|
||
cmsDoTransform(transform, cmykInputColor.data(), rgbOutputColor.data(), 1);
|
||
return getColorFromOutputColor(rgbOutputColor);
|
||
}
|
||
else
|
||
{
|
||
reporter->reportRenderErrorOnce(RenderErrorType::Error, PDFTranslationContext::tr("Conversion from CMYK to output device using CMS failed - invalid data format."));
|
||
}
|
||
|
||
return QColor();
|
||
}
|
||
|
||
QColor PDFLittleCMS::getColorFromXYZ(const PDFColor3& whitePoint, const PDFColor3& color, RenderingIntent intent, PDFRenderErrorReporter* reporter) const
|
||
{
|
||
cmsHTRANSFORM transform = getTransform(XYZ, getEffectiveRenderingIntent(intent), false);
|
||
|
||
if (!transform)
|
||
{
|
||
reporter->reportRenderErrorOnce(RenderErrorType::Error, PDFTranslationContext::tr("Conversion from XYZ to output device using CMS failed."));
|
||
return QColor();
|
||
}
|
||
|
||
if (cmsGetTransformInputFormat(transform) == TYPE_XYZ_FLT && color.size() == 3)
|
||
{
|
||
Q_ASSERT(cmsGetTransformOutputFormat(transform) == TYPE_RGB_FLT);
|
||
|
||
const PDFColorComponentMatrix_3x3 adaptationMatrix = PDFChromaticAdaptationXYZ::createWhitepointChromaticAdaptation(getDefaultXYZWhitepoint(), whitePoint, m_settings.colorAdaptationXYZ);
|
||
const PDFColor3 xyzInputColor = adaptationMatrix * color;
|
||
std::array<float, 3> rgbOutputColor = { };
|
||
cmsDoTransform(transform, xyzInputColor.data(), rgbOutputColor.data(), 1);
|
||
return getColorFromOutputColor(rgbOutputColor);
|
||
}
|
||
else
|
||
{
|
||
reporter->reportRenderErrorOnce(RenderErrorType::Error, PDFTranslationContext::tr("Conversion from XYZ to output device using CMS failed - invalid data format."));
|
||
}
|
||
|
||
return QColor();
|
||
}
|
||
|
||
cmsHTRANSFORM PDFLittleCMS::getTransformFromICCProfile(const QByteArray& iccData, const QByteArray& iccID, RenderingIntent renderingIntent, bool isRGB888Buffer) const
|
||
{
|
||
RenderingIntent effectiveRenderingIntent = getEffectiveRenderingIntent(renderingIntent);
|
||
const auto key = std::make_pair(iccID + (isRGB888Buffer ? "RGB_888" : "FLT"), effectiveRenderingIntent);
|
||
QReadLocker lock(&m_customIccProfileCacheLock);
|
||
auto it = m_customIccProfileCache.find(key);
|
||
if (it == m_customIccProfileCache.cend())
|
||
{
|
||
lock.unlock();
|
||
QWriteLocker writeLock(&m_customIccProfileCacheLock);
|
||
|
||
// Now, we have locked cache for writing. We must find out,
|
||
// if some other thread doesn't created the transformation already.
|
||
it = m_customIccProfileCache.find(key);
|
||
if (it == m_customIccProfileCache.cend())
|
||
{
|
||
cmsHTRANSFORM transform = cmsHTRANSFORM();
|
||
cmsHPROFILE profile = cmsOpenProfileFromMem(iccData.data(), iccData.size());
|
||
if (profile)
|
||
{
|
||
if (const cmsUInt32Number inputDataFormat = getProfileDataFormat(profile))
|
||
{
|
||
cmsUInt32Number lcmsIntent = getLittleCMSRenderingIntent(effectiveRenderingIntent);
|
||
|
||
if (isSoftProofing())
|
||
{
|
||
cmsHPROFILE proofingProfile = m_profiles[SoftProofing];
|
||
RenderingIntent proofingIntent = m_settings.proofingIntent;
|
||
if (m_settings.proofingIntent == RenderingIntent::Auto)
|
||
{
|
||
proofingIntent = effectiveRenderingIntent;
|
||
}
|
||
|
||
transform = cmsCreateProofingTransform(profile, inputDataFormat, m_profiles[Output], isRGB888Buffer ? TYPE_RGB_8 : TYPE_RGB_FLT, proofingProfile,
|
||
lcmsIntent, getLittleCMSRenderingIntent(proofingIntent), getTransformationFlags());
|
||
}
|
||
else
|
||
{
|
||
transform = cmsCreateTransform(profile, inputDataFormat, m_profiles[Output], isRGB888Buffer ? TYPE_RGB_8 : TYPE_RGB_FLT, lcmsIntent, getTransformationFlags());
|
||
}
|
||
}
|
||
cmsCloseProfile(profile);
|
||
}
|
||
|
||
it = m_customIccProfileCache.insert(std::make_pair(key, transform)).first;
|
||
}
|
||
|
||
return it->second;
|
||
}
|
||
else
|
||
{
|
||
return it->second;
|
||
}
|
||
|
||
return cmsHTRANSFORM();
|
||
}
|
||
|
||
QColor PDFLittleCMS::getColorFromICC(const PDFColor& color, RenderingIntent renderingIntent, const QByteArray& iccID, const QByteArray& iccData, PDFRenderErrorReporter* reporter) const
|
||
{
|
||
cmsHTRANSFORM transform = getTransformFromICCProfile(iccData, iccID, renderingIntent, false);
|
||
|
||
if (!transform)
|
||
{
|
||
reporter->reportRenderErrorOnce(RenderErrorType::Error, PDFTranslationContext::tr("Conversion from icc profile space to output device using CMS failed."));
|
||
return QColor();
|
||
}
|
||
|
||
std::array<float, 4> inputBuffer = { };
|
||
const cmsUInt32Number format = cmsGetTransformInputFormat(transform);
|
||
const cmsUInt32Number channels = T_CHANNELS(format);
|
||
const cmsUInt32Number colorSpace = T_COLORSPACE(format);
|
||
const bool isCMYK = colorSpace == PT_CMYK;
|
||
if (channels == color.size() && channels <= inputBuffer.size())
|
||
{
|
||
for (size_t i = 0; i < color.size(); ++i)
|
||
{
|
||
inputBuffer[i] = isCMYK ? color[i] * 100.0f : color[i];
|
||
}
|
||
|
||
std::array<float, 3> rgbOutputColor = { };
|
||
cmsDoTransform(transform, inputBuffer.data(), rgbOutputColor.data(), 1);
|
||
return getColorFromOutputColor(rgbOutputColor);
|
||
}
|
||
else
|
||
{
|
||
reporter->reportRenderErrorOnce(RenderErrorType::Error, PDFTranslationContext::tr("Conversion from icc profile space to output device using CMS failed - invalid data format."));
|
||
}
|
||
|
||
return QColor();
|
||
}
|
||
|
||
void PDFLittleCMS::init()
|
||
{
|
||
// Jakub Melka: initialize all color profiles
|
||
m_profiles[Output] = createProfile(m_settings.outputCS, m_manager->getOutputProfiles(), false);
|
||
m_profiles[Gray] = createProfile(m_settings.deviceGray, m_manager->getGrayProfiles(), m_settings.isConsiderOutputIntent);
|
||
m_profiles[RGB] = createProfile(m_settings.deviceRGB, m_manager->getRGBProfiles(), m_settings.isConsiderOutputIntent);
|
||
m_profiles[CMYK] = createProfile(m_settings.deviceCMYK, m_manager->getCMYKProfiles(), m_settings.isConsiderOutputIntent);
|
||
m_profiles[SoftProofing] = createProfile(m_settings.softProofingProfile, m_manager->getCMYKProfiles(), false);
|
||
m_profiles[XYZ] = cmsCreateXYZProfile();
|
||
|
||
cmsUInt16Number outOfGamutR = m_settings.outOfGamutColor.redF() * 0xFFFF;
|
||
cmsUInt16Number outOfGamutG = m_settings.outOfGamutColor.greenF() * 0xFFFF;
|
||
cmsUInt16Number outOfGamutB = m_settings.outOfGamutColor.blueF() * 0xFFFF;
|
||
|
||
cmsUInt16Number alarmCodes[cmsMAXCHANNELS] = { outOfGamutR, outOfGamutG, outOfGamutB };
|
||
cmsSetAlarmCodes(alarmCodes);
|
||
|
||
if (m_settings.isWhitePaperColorTransformed)
|
||
{
|
||
m_paperColor = getColorFromDeviceRGB(PDFColor(1.0f, 1.0f, 1.0f), RenderingIntent::AbsoluteColorimetric, nullptr);
|
||
|
||
// We must check color of the paper, it can be invalid, if error occurs...
|
||
if (!m_paperColor.isValid())
|
||
{
|
||
m_paperColor = QColor(Qt::white);
|
||
}
|
||
}
|
||
|
||
// 64 should be enough, because we can have 4 input color spaces (gray, RGB, CMYK and XYZ),
|
||
// and 4 rendering intents. We have 4 * 4 = 16 input tables, so 64 will suffice enough
|
||
// (because we then have 25% load factor).
|
||
m_transformationCache.reserve(64);
|
||
}
|
||
|
||
int PDFLittleCMS::installCmsPlugins()
|
||
{
|
||
static cmsPluginOptimization optimizationPlugin = { };
|
||
optimizationPlugin.base.Magic = cmsPluginMagicNumber;
|
||
optimizationPlugin.base.Type = cmsPluginOptimizationSig;
|
||
optimizationPlugin.base.Next = nullptr;
|
||
optimizationPlugin.base.ExpectedVersion = LCMS_VERSION;
|
||
optimizationPlugin.OptimizePtr = &PDFLittleCMS::optimizePipeline;
|
||
|
||
cmsPlugin(&optimizationPlugin);
|
||
|
||
return 0;
|
||
}
|
||
|
||
cmsBool PDFLittleCMS::optimizePipeline(cmsPipeline** Lut, cmsUInt32Number Intent, cmsUInt32Number* InputFormat, cmsUInt32Number* OutputFormat, cmsUInt32Number* dwFlags)
|
||
{
|
||
if (!(*dwFlags & cmsFLAGS_LOWRESPRECALC))
|
||
{
|
||
// Optimize only on low resolution precalculation
|
||
return FALSE;
|
||
}
|
||
|
||
Q_UNUSED(Intent);
|
||
|
||
// We will find, if we can optimize...
|
||
bool shouldOptimize = false;
|
||
for (auto stage = cmsPipelineGetPtrToFirstStage(*Lut); stage; stage = cmsStageNext(stage))
|
||
{
|
||
if (cmsStageType(stage) == cmsSigCurveSetElemType)
|
||
{
|
||
_cmsStageToneCurvesData* data = reinterpret_cast<_cmsStageToneCurvesData*>(cmsStageData(stage));
|
||
for (cmsUInt32Number i = 0; i < data->nCurves; ++i)
|
||
{
|
||
const cmsToneCurve* curve = data->TheCurves[i];
|
||
const cmsInt32Number type = cmsGetToneCurveParametricType(curve);
|
||
|
||
if (type != 0 && !cmsIsToneCurveMultisegment(curve))
|
||
{
|
||
shouldOptimize = true;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (shouldOptimize)
|
||
{
|
||
cmsContext contextId = cmsGetPipelineContextID(*Lut);
|
||
cmsPipeline* pipeline = cmsPipelineAlloc(contextId, T_CHANNELS(*InputFormat), T_CHANNELS(*OutputFormat));
|
||
if (!pipeline)
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
for (auto stage = cmsPipelineGetPtrToFirstStage(*Lut); stage; stage = cmsStageNext(stage))
|
||
{
|
||
if (cmsStageType(stage) == cmsSigCurveSetElemType)
|
||
{
|
||
_cmsStageToneCurvesData* data = reinterpret_cast<_cmsStageToneCurvesData*>(cmsStageData(stage));
|
||
std::vector<cmsToneCurve*> curves(data->nCurves, nullptr);
|
||
|
||
for (cmsUInt32Number i = 0; i < data->nCurves; ++i)
|
||
{
|
||
const cmsToneCurve* curve = data->TheCurves[i];
|
||
const cmsInt32Number type = cmsGetToneCurveParametricType(curve);
|
||
|
||
if (type != 0 && !cmsIsToneCurveMultisegment(curve))
|
||
{
|
||
std::array<cmsCurveSegment, 3> segments = { };
|
||
|
||
const cmsFloat64Number* params = cmsGetToneCurveParams(curve);
|
||
|
||
cmsCurveSegment& s1 = segments[0];
|
||
cmsCurveSegment& s2 = segments[1];
|
||
cmsCurveSegment& s3 = segments[2];
|
||
|
||
const cmsFloat32Number eps = cmsFloat32Number(1e-5);
|
||
const cmsFloat32Number low = 0.0f - eps;
|
||
const cmsFloat32Number high = 1.0f + eps;
|
||
|
||
s1.Type = type;
|
||
s1.nGridPoints = 0;
|
||
s1.SampledPoints = nullptr;
|
||
std::copy(params, params + (sizeof(s1.Params) / sizeof(*s1.Params)), s1.Params);
|
||
s1.x0 = std::numeric_limits<cmsFloat32Number>::min();
|
||
s1.x1 = low;
|
||
|
||
const cmsUInt32Number gridPoints = 1024;
|
||
const cmsFloat32Number factor = 1.0f / cmsFloat32Number(gridPoints - 1);
|
||
|
||
s2.Type = 0;
|
||
s2.nGridPoints = gridPoints;
|
||
s2.SampledPoints = static_cast<cmsFloat32Number*>(_cmsCalloc(contextId, gridPoints, sizeof(*s2.SampledPoints)));
|
||
std::copy(params, params + (sizeof(s2.Params) / sizeof(*s2.Params)), s2.Params);
|
||
s2.x0 = low;
|
||
s2.x1 = high;
|
||
|
||
for (cmsUInt32Number i = 0; i < gridPoints; ++i)
|
||
{
|
||
const cmsFloat32Number x = i * factor;
|
||
s2.SampledPoints[i] = cmsEvalToneCurveFloat(curve, interpolate(x, 0.0, 1.0, low, high));
|
||
}
|
||
|
||
s3.Type = type;
|
||
s3.nGridPoints = 0;
|
||
s3.SampledPoints = nullptr;
|
||
std::copy(params, params + (sizeof(s3.Params) / sizeof(*s3.Params)), s3.Params);
|
||
s3.x0 = high;
|
||
s3.x1 = std::numeric_limits<cmsFloat32Number>::max();
|
||
|
||
curves[i] = cmsBuildSegmentedToneCurve(contextId, cmsUInt32Number(segments.size()), segments.data());
|
||
|
||
_cmsFree(contextId, s2.SampledPoints);
|
||
}
|
||
else
|
||
{
|
||
curves[i] = cmsDupToneCurve(curve);
|
||
}
|
||
}
|
||
|
||
cmsStageAllocToneCurves(contextId, cmsFloat32Number(curves.size()), curves.data());
|
||
|
||
for (cmsToneCurve* curve : curves)
|
||
{
|
||
cmsFreeToneCurve(curve);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
cmsPipelineInsertStage(pipeline, cmsAT_END, cmsStageDup(stage));
|
||
}
|
||
}
|
||
|
||
cmsPipelineFree(*Lut);
|
||
*Lut = pipeline;
|
||
}
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
bool PDFLittleCMS::isSoftProofing() const
|
||
{
|
||
return (m_settings.isSoftProofing || m_settings.isGamutChecking) && m_profiles[SoftProofing];
|
||
}
|
||
|
||
cmsHPROFILE PDFLittleCMS::createProfile(const QString& id, const PDFColorProfileIdentifiers& profileDescriptors, bool preferOutputProfile) const
|
||
{
|
||
auto it = std::find_if(profileDescriptors.cbegin(), profileDescriptors.cend(), [&id](const PDFColorProfileIdentifier& identifier) { return identifier.id == id; });
|
||
if (preferOutputProfile && it != profileDescriptors.end())
|
||
{
|
||
const PDFColorProfileIdentifier& identifier = *it;
|
||
if (!identifier.isOutputIntentProfile)
|
||
{
|
||
// Find first output intent color profile
|
||
auto itOutputIntentColorProfile = std::find_if(profileDescriptors.cbegin(), profileDescriptors.cend(), [](const PDFColorProfileIdentifier& identifier) { return identifier.isOutputIntentProfile; });
|
||
if (itOutputIntentColorProfile != profileDescriptors.end())
|
||
{
|
||
it = itOutputIntentColorProfile;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (it != profileDescriptors.cend())
|
||
{
|
||
const PDFColorProfileIdentifier& identifier = *it;
|
||
switch (identifier.type)
|
||
{
|
||
case PDFColorProfileIdentifier::Type::Gray:
|
||
{
|
||
cmsCIExyY whitePoint{ };
|
||
if (cmsWhitePointFromTemp(&whitePoint, identifier.temperature))
|
||
{
|
||
cmsToneCurve* gammaCurve = cmsBuildGamma(cmsContext(), identifier.gamma);
|
||
cmsHPROFILE profile = cmsCreateGrayProfile(&whitePoint, gammaCurve);
|
||
cmsFreeToneCurve(gammaCurve);
|
||
return profile;
|
||
}
|
||
break;
|
||
}
|
||
|
||
case PDFColorProfileIdentifier::Type::sRGB:
|
||
return cmsCreate_sRGBProfile();
|
||
|
||
case PDFColorProfileIdentifier::Type::RGB:
|
||
{
|
||
cmsCIExyY whitePoint{ };
|
||
if (cmsWhitePointFromTemp(&whitePoint, identifier.temperature))
|
||
{
|
||
cmsCIExyYTRIPLE primaries;
|
||
primaries.Red = { identifier.primaryR.x(), identifier.primaryR.y(), 1.0 };
|
||
primaries.Green = { identifier.primaryG.x(), identifier.primaryG.y(), 1.0 };
|
||
primaries.Blue = { identifier.primaryB.x(), identifier.primaryB.y(), 1.0 };
|
||
cmsToneCurve* gammaCurve = cmsBuildGamma(cmsContext(), identifier.gamma);
|
||
cmsToneCurve* toneCurves[3] = { gammaCurve, cmsDupToneCurve(gammaCurve), cmsDupToneCurve(gammaCurve) };
|
||
cmsHPROFILE profile = cmsCreateRGBProfile(&whitePoint, &primaries, toneCurves);
|
||
cmsFreeToneCurveTriple(toneCurves);
|
||
return profile;
|
||
}
|
||
break;
|
||
}
|
||
case PDFColorProfileIdentifier::Type::FileGray:
|
||
case PDFColorProfileIdentifier::Type::FileRGB:
|
||
case PDFColorProfileIdentifier::Type::FileCMYK:
|
||
{
|
||
QFile file(identifier.id);
|
||
if (file.open(QFile::ReadOnly))
|
||
{
|
||
QByteArray fileContent = file.readAll();
|
||
file.close();
|
||
|
||
return cmsOpenProfileFromMem(fileContent.data(), fileContent.size());
|
||
}
|
||
|
||
break;
|
||
}
|
||
|
||
case PDFColorProfileIdentifier::Type::MemoryGray:
|
||
case PDFColorProfileIdentifier::Type::MemoryRGB:
|
||
case PDFColorProfileIdentifier::Type::MemoryCMYK:
|
||
return cmsOpenProfileFromMem(identifier.profileMemoryData.data(), identifier.profileMemoryData.size());
|
||
|
||
default:
|
||
Q_ASSERT(false);
|
||
break;
|
||
}
|
||
}
|
||
|
||
return cmsHPROFILE();
|
||
}
|
||
|
||
cmsHTRANSFORM PDFLittleCMS::getTransform(Profile profile, RenderingIntent intent, bool isRGB888Buffer) const
|
||
{
|
||
const int key = getCacheKey(profile, intent, isRGB888Buffer);
|
||
|
||
QReadLocker lock(&m_transformationCacheLock);
|
||
auto it = m_transformationCache.find(key);
|
||
if (it == m_transformationCache.cend())
|
||
{
|
||
lock.unlock();
|
||
QWriteLocker writeLock(&m_transformationCacheLock);
|
||
|
||
// Now, we have locked cache for writing. We must find out,
|
||
// if some other thread doesn't created the transformation already.
|
||
it = m_transformationCache.find(key);
|
||
if (it == m_transformationCache.cend())
|
||
{
|
||
cmsHTRANSFORM transform = cmsHTRANSFORM();
|
||
cmsHPROFILE input = m_profiles[profile];
|
||
cmsHPROFILE output = m_profiles[Output];
|
||
|
||
if (input && output)
|
||
{
|
||
if (isSoftProofing())
|
||
{
|
||
cmsHPROFILE proofingProfile = m_profiles[SoftProofing];
|
||
RenderingIntent proofingIntent = m_settings.proofingIntent;
|
||
if (m_settings.proofingIntent == RenderingIntent::Auto)
|
||
{
|
||
proofingIntent = intent;
|
||
}
|
||
|
||
transform = cmsCreateProofingTransform(input, getProfileDataFormat(input), output, isRGB888Buffer ? TYPE_RGB_8 : TYPE_RGB_FLT, proofingProfile,
|
||
getLittleCMSRenderingIntent(intent), getLittleCMSRenderingIntent(proofingIntent), getTransformationFlags());
|
||
}
|
||
else
|
||
{
|
||
transform = cmsCreateTransform(input, getProfileDataFormat(input), output, isRGB888Buffer ? TYPE_RGB_8 : TYPE_RGB_FLT, getLittleCMSRenderingIntent(intent), getTransformationFlags());
|
||
}
|
||
}
|
||
|
||
it = m_transformationCache.insert(std::make_pair(key, transform)).first;
|
||
}
|
||
|
||
// We must return it here to avoid race condition (after current block,
|
||
// lock is not locked, because we unlocked lock for reading).
|
||
return it->second;
|
||
}
|
||
|
||
return it->second;
|
||
}
|
||
|
||
cmsUInt32Number PDFLittleCMS::getTransformationFlags() const
|
||
{
|
||
// Flag cmsFLAGS_NONEGATIVES is used here to avoid invalid transformation
|
||
// between CMYK color space and RGB color space in the Ghent output suite examples.
|
||
cmsUInt32Number flags = cmsFLAGS_NOCACHE | cmsFLAGS_NONEGATIVES;
|
||
|
||
if (m_settings.isBlackPointCompensationActive)
|
||
{
|
||
flags |= cmsFLAGS_BLACKPOINTCOMPENSATION;
|
||
}
|
||
|
||
switch (m_settings.accuracy)
|
||
{
|
||
case PDFCMSSettings::Accuracy::Low:
|
||
flags |= cmsFLAGS_LOWRESPRECALC;
|
||
break;
|
||
|
||
case PDFCMSSettings::Accuracy::Medium:
|
||
break;
|
||
|
||
case PDFCMSSettings::Accuracy::High:
|
||
flags |= cmsFLAGS_HIGHRESPRECALC;
|
||
break;
|
||
|
||
default:
|
||
Q_ASSERT(false);
|
||
break;
|
||
}
|
||
|
||
if (m_settings.isGamutChecking)
|
||
{
|
||
flags |= cmsFLAGS_GAMUTCHECK;
|
||
}
|
||
|
||
if (m_settings.isSoftProofing)
|
||
{
|
||
flags |= cmsFLAGS_SOFTPROOFING;
|
||
}
|
||
|
||
return flags;
|
||
}
|
||
|
||
RenderingIntent PDFLittleCMS::getEffectiveRenderingIntent(RenderingIntent intent) const
|
||
{
|
||
if (m_settings.intent != RenderingIntent::Auto)
|
||
{
|
||
return m_settings.intent;
|
||
}
|
||
|
||
return intent;
|
||
}
|
||
|
||
cmsUInt32Number PDFLittleCMS::getLittleCMSRenderingIntent(RenderingIntent intent)
|
||
{
|
||
switch (intent)
|
||
{
|
||
case RenderingIntent::Perceptual:
|
||
return INTENT_PERCEPTUAL;
|
||
|
||
case RenderingIntent::AbsoluteColorimetric:
|
||
return INTENT_ABSOLUTE_COLORIMETRIC;
|
||
|
||
case RenderingIntent::RelativeColorimetric:
|
||
return INTENT_RELATIVE_COLORIMETRIC;
|
||
|
||
case RenderingIntent::Saturation:
|
||
return INTENT_SATURATION;
|
||
|
||
default:
|
||
Q_ASSERT(false);
|
||
break;
|
||
}
|
||
|
||
return INTENT_PERCEPTUAL;
|
||
}
|
||
|
||
cmsUInt32Number PDFLittleCMS::getProfileDataFormat(cmsHPROFILE profile)
|
||
{
|
||
cmsColorSpaceSignature signature = cmsGetColorSpace(profile);
|
||
switch (signature)
|
||
{
|
||
case cmsSigGrayData:
|
||
return TYPE_GRAY_FLT;
|
||
|
||
case cmsSigRgbData:
|
||
return TYPE_RGB_FLT;
|
||
|
||
case cmsSigCmykData:
|
||
return TYPE_CMYK_FLT;
|
||
|
||
case cmsSigXYZData:
|
||
return TYPE_XYZ_FLT;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
QColor PDFLittleCMS::getColorFromOutputColor(std::array<float, 3> color01)
|
||
{
|
||
QColor color(QColor::Rgb);
|
||
color.setRgbF(qBound(0.0f, color01[0], 1.0f), qBound(0.0f, color01[1], 1.0f), qBound(0.0f, color01[2], 1.0f));
|
||
return color;
|
||
}
|
||
|
||
QByteArray PDFLittleCMS::getTransformColorSpaceKey(const PDFCMS::ColorSpaceTransformParams& params)
|
||
{
|
||
QByteArray key;
|
||
|
||
QBuffer buffer(&key);
|
||
buffer.open(QBuffer::WriteOnly);
|
||
|
||
QDataStream stream(&buffer);
|
||
stream << params.sourceType;
|
||
stream << params.sourceIccId;
|
||
stream << params.targetType;
|
||
stream << params.targetIccId;
|
||
stream << params.intent;
|
||
|
||
buffer.close();
|
||
|
||
return key;
|
||
}
|
||
|
||
cmsHTRANSFORM PDFLittleCMS::getTransformBetweenColorSpaces(const PDFCMS::ColorSpaceTransformParams& params) const
|
||
{
|
||
QByteArray key = getTransformColorSpaceKey(params);
|
||
QReadLocker lock(&m_transformColorSpaceCacheLock);
|
||
auto it = m_transformColorSpaceCache.find(key);
|
||
if (it == m_transformColorSpaceCache.cend())
|
||
{
|
||
lock.unlock();
|
||
QWriteLocker writeLock(&m_transformColorSpaceCacheLock);
|
||
|
||
// Now, we have locked cache for writing. We must find out,
|
||
// if some other thread doesn't created the transformation already.
|
||
it = m_transformColorSpaceCache.find(key);
|
||
if (it == m_transformColorSpaceCache.cend())
|
||
{
|
||
cmsHPROFILE inputProfile = cmsHPROFILE();
|
||
cmsHPROFILE outputProfile = cmsHPROFILE();
|
||
cmsHTRANSFORM transform = cmsHTRANSFORM();
|
||
|
||
switch (params.sourceType)
|
||
{
|
||
case ColorSpaceType::DeviceGray:
|
||
inputProfile = m_profiles[Gray];
|
||
break;
|
||
|
||
case ColorSpaceType::DeviceRGB:
|
||
inputProfile = m_profiles[RGB];
|
||
break;
|
||
|
||
case ColorSpaceType::DeviceCMYK:
|
||
inputProfile = m_profiles[CMYK];
|
||
break;
|
||
|
||
case ColorSpaceType::XYZ:
|
||
inputProfile = m_profiles[XYZ];
|
||
break;
|
||
|
||
case ColorSpaceType::ICC:
|
||
inputProfile = cmsOpenProfileFromMem(params.sourceIccData.data(), params.sourceIccData.size());
|
||
break;
|
||
|
||
default:
|
||
Q_ASSERT(false);
|
||
break;
|
||
}
|
||
|
||
switch (params.targetType)
|
||
{
|
||
case ColorSpaceType::DeviceGray:
|
||
outputProfile = m_profiles[Gray];
|
||
break;
|
||
|
||
case ColorSpaceType::DeviceRGB:
|
||
outputProfile = m_profiles[RGB];
|
||
break;
|
||
|
||
case ColorSpaceType::DeviceCMYK:
|
||
outputProfile = m_profiles[CMYK];
|
||
break;
|
||
|
||
case ColorSpaceType::XYZ:
|
||
outputProfile = m_profiles[XYZ];
|
||
break;
|
||
|
||
case ColorSpaceType::ICC:
|
||
outputProfile = cmsOpenProfileFromMem(params.targetIccData.data(), params.targetIccData.size());
|
||
break;
|
||
|
||
default:
|
||
Q_ASSERT(false);
|
||
break;
|
||
}
|
||
|
||
if (inputProfile && outputProfile)
|
||
{
|
||
transform = cmsCreateTransform(inputProfile, getProfileDataFormat(inputProfile), outputProfile, getProfileDataFormat(outputProfile), getLittleCMSRenderingIntent(params.intent), getTransformationFlags());
|
||
}
|
||
|
||
if (params.sourceType == ColorSpaceType::ICC)
|
||
{
|
||
cmsCloseProfile(inputProfile);
|
||
}
|
||
|
||
if (params.targetType == ColorSpaceType::ICC)
|
||
{
|
||
cmsCloseProfile(outputProfile);
|
||
}
|
||
|
||
it = m_transformColorSpaceCache.insert(std::make_pair(key, transform)).first;
|
||
}
|
||
|
||
return it->second;
|
||
}
|
||
else
|
||
{
|
||
return it->second;
|
||
}
|
||
|
||
return cmsHTRANSFORM();
|
||
}
|
||
|
||
QString getInfoFromProfile(cmsHPROFILE profile, cmsInfoType infoType)
|
||
{
|
||
QLocale locale;
|
||
QString country = QLocale::countryToString(locale.country());
|
||
QString language = QLocale::languageToString(locale.language());
|
||
|
||
char countryCode[3] = { };
|
||
char languageCode[3] = { };
|
||
if (country.size() == 2)
|
||
{
|
||
countryCode[0] = country[0].toLatin1();
|
||
countryCode[1] = country[1].toLatin1();
|
||
}
|
||
if (language.size() == 2)
|
||
{
|
||
languageCode[0] = language[0].toLatin1();
|
||
languageCode[1] = language[1].toLatin1();
|
||
}
|
||
|
||
// Jakub Melka: try to get profile info from current language/country.
|
||
// If it fails, then pick any language/any country.
|
||
cmsUInt32Number bufferSize = cmsGetProfileInfo(profile, infoType, languageCode, countryCode, nullptr, 0);
|
||
if (bufferSize)
|
||
{
|
||
std::vector<wchar_t> buffer(bufferSize, 0);
|
||
cmsGetProfileInfo(profile, infoType, languageCode, countryCode, buffer.data(), static_cast<cmsUInt32Number>(buffer.size()));
|
||
return QString::fromWCharArray(buffer.data());
|
||
}
|
||
|
||
bufferSize = cmsGetProfileInfo(profile, infoType, cmsNoLanguage, cmsNoCountry, nullptr, 0);
|
||
if (bufferSize)
|
||
{
|
||
std::vector<wchar_t> buffer(bufferSize, 0);
|
||
cmsGetProfileInfo(profile, infoType, cmsNoLanguage, cmsNoCountry, buffer.data(), static_cast<cmsUInt32Number>(buffer.size()));
|
||
return QString::fromWCharArray(buffer.data());
|
||
}
|
||
|
||
return QString();
|
||
}
|
||
|
||
bool PDFCMSGeneric::isCompatible(const PDFCMSSettings& settings) const
|
||
{
|
||
return settings.system == PDFCMSSettings::System::Generic;
|
||
}
|
||
|
||
QColor PDFCMSGeneric::getPaperColor() const
|
||
{
|
||
return QColor(Qt::white);
|
||
}
|
||
|
||
QColor PDFCMSGeneric::getColorFromDeviceGray(const PDFColor& color, RenderingIntent intent, PDFRenderErrorReporter* reporter) const
|
||
{
|
||
Q_UNUSED(color);
|
||
Q_UNUSED(intent);
|
||
Q_UNUSED(reporter);
|
||
return QColor();
|
||
}
|
||
|
||
QColor PDFCMSGeneric::getColorFromDeviceRGB(const PDFColor& color, RenderingIntent intent, PDFRenderErrorReporter* reporter) const
|
||
{
|
||
Q_UNUSED(color);
|
||
Q_UNUSED(intent);
|
||
Q_UNUSED(reporter);
|
||
return QColor();
|
||
}
|
||
|
||
QColor PDFCMSGeneric::getColorFromDeviceCMYK(const PDFColor& color, RenderingIntent intent, PDFRenderErrorReporter* reporter) const
|
||
{
|
||
Q_UNUSED(color);
|
||
Q_UNUSED(intent);
|
||
Q_UNUSED(reporter);
|
||
return QColor();
|
||
}
|
||
|
||
QColor PDFCMSGeneric::getColorFromXYZ(const PDFColor3& whitePoint, const PDFColor3& color, RenderingIntent intent, PDFRenderErrorReporter* reporter) const
|
||
{
|
||
Q_UNUSED(color);
|
||
Q_UNUSED(intent);
|
||
Q_UNUSED(reporter);
|
||
Q_UNUSED(whitePoint);
|
||
return QColor();
|
||
}
|
||
|
||
QColor PDFCMSGeneric::getColorFromICC(const PDFColor& color,
|
||
RenderingIntent renderingIntent,
|
||
const QByteArray& iccID,
|
||
const QByteArray& iccData,
|
||
PDFRenderErrorReporter* reporter) const
|
||
{
|
||
Q_UNUSED(color);
|
||
Q_UNUSED(renderingIntent);
|
||
Q_UNUSED(iccID);
|
||
Q_UNUSED(iccData);
|
||
Q_UNUSED(reporter);
|
||
return QColor();
|
||
}
|
||
|
||
bool PDFCMSGeneric::fillRGBBufferFromDeviceGray(const std::vector<float>& colors, RenderingIntent intent, unsigned char* outputBuffer, PDFRenderErrorReporter* reporter) const
|
||
{
|
||
Q_UNUSED(colors);
|
||
Q_UNUSED(intent);
|
||
Q_UNUSED(outputBuffer);
|
||
Q_UNUSED(reporter);
|
||
return false;
|
||
}
|
||
|
||
bool PDFCMSGeneric::fillRGBBufferFromDeviceRGB(const std::vector<float>& colors, RenderingIntent intent, unsigned char* outputBuffer, PDFRenderErrorReporter* reporter) const
|
||
{
|
||
Q_UNUSED(colors);
|
||
Q_UNUSED(intent);
|
||
Q_UNUSED(outputBuffer);
|
||
Q_UNUSED(reporter);
|
||
return false;
|
||
}
|
||
|
||
bool PDFCMSGeneric::fillRGBBufferFromDeviceCMYK(const std::vector<float>& colors, RenderingIntent intent, unsigned char* outputBuffer, PDFRenderErrorReporter* reporter) const
|
||
{
|
||
Q_UNUSED(colors);
|
||
Q_UNUSED(intent);
|
||
Q_UNUSED(outputBuffer);
|
||
Q_UNUSED(reporter);
|
||
return false;
|
||
}
|
||
|
||
bool PDFCMSGeneric::fillRGBBufferFromXYZ(const PDFColor3& whitePoint, const std::vector<float>& colors, RenderingIntent intent, unsigned char* outputBuffer, PDFRenderErrorReporter* reporter) const
|
||
{
|
||
Q_UNUSED(whitePoint);
|
||
Q_UNUSED(colors);
|
||
Q_UNUSED(intent);
|
||
Q_UNUSED(outputBuffer);
|
||
Q_UNUSED(reporter);
|
||
return false;
|
||
}
|
||
|
||
bool PDFCMSGeneric::fillRGBBufferFromICC(const std::vector<float>& colors, RenderingIntent renderingIntent, unsigned char* outputBuffer, const QByteArray& iccID, const QByteArray& iccData, PDFRenderErrorReporter* reporter) const
|
||
{
|
||
Q_UNUSED(colors);
|
||
Q_UNUSED(renderingIntent);
|
||
Q_UNUSED(outputBuffer);
|
||
Q_UNUSED(iccID);
|
||
Q_UNUSED(iccData);
|
||
Q_UNUSED(reporter);
|
||
return false;
|
||
}
|
||
|
||
bool PDFCMSGeneric::transformColorSpace(const PDFCMS::ColorSpaceTransformParams& params) const
|
||
{
|
||
Q_UNUSED(params);
|
||
return false;
|
||
}
|
||
|
||
PDFCMSManager::PDFCMSManager(QObject* parent) :
|
||
BaseClass(parent),
|
||
m_document(nullptr),
|
||
m_mutex(QMutex::Recursive)
|
||
{
|
||
|
||
}
|
||
|
||
PDFCMSPointer PDFCMSManager::getCurrentCMS() const
|
||
{
|
||
QMutexLocker lock(&m_mutex);
|
||
return m_CMS.get(this, &PDFCMSManager::getCurrentCMSImpl);
|
||
}
|
||
|
||
void PDFCMSManager::setSettings(const PDFCMSSettings& settings)
|
||
{
|
||
if (m_settings != settings)
|
||
{
|
||
// We must ensure, that mutex is not locked, while we are
|
||
// sending signal about CMS change.
|
||
{
|
||
QMutexLocker lock(&m_mutex);
|
||
m_settings = settings;
|
||
clearCache();
|
||
}
|
||
|
||
emit colorManagementSystemChanged();
|
||
}
|
||
}
|
||
|
||
const PDFColorProfileIdentifiers& PDFCMSManager::getOutputProfiles() const
|
||
{
|
||
QMutexLocker lock(&m_mutex);
|
||
return m_outputProfiles.get(this, &PDFCMSManager::getOutputProfilesImpl);
|
||
}
|
||
|
||
const PDFColorProfileIdentifiers& PDFCMSManager::getGrayProfiles() const
|
||
{
|
||
QMutexLocker lock(&m_mutex);
|
||
return m_grayProfiles.get(this, &PDFCMSManager::getGrayProfilesImpl);
|
||
}
|
||
|
||
const PDFColorProfileIdentifiers& PDFCMSManager::getRGBProfiles() const
|
||
{
|
||
QMutexLocker lock(&m_mutex);
|
||
return m_RGBProfiles.get(this, &PDFCMSManager::getRGBProfilesImpl);
|
||
}
|
||
|
||
const PDFColorProfileIdentifiers& PDFCMSManager::getCMYKProfiles() const
|
||
{
|
||
QMutexLocker lock(&m_mutex);
|
||
return m_CMYKProfiles.get(this, &PDFCMSManager::getCMYKProfilesImpl);
|
||
}
|
||
|
||
const PDFColorProfileIdentifiers& PDFCMSManager::getExternalProfiles() const
|
||
{
|
||
// Jakub Melka: do not protect this by mutex, this function is private
|
||
// and must be called only from mutex-protected code.
|
||
return m_externalProfiles.get(this, &PDFCMSManager::getExternalProfilesImpl);
|
||
}
|
||
|
||
PDFCMSSettings PDFCMSManager::getDefaultSettings() const
|
||
{
|
||
PDFCMSSettings settings;
|
||
|
||
auto getFirstProfileId = [](const PDFColorProfileIdentifiers& identifiers)
|
||
{
|
||
if (!identifiers.empty())
|
||
{
|
||
return identifiers.front().id;
|
||
}
|
||
return QString();
|
||
};
|
||
|
||
settings.system = PDFCMSSettings::System::LittleCMS2;
|
||
settings.outputCS = getFirstProfileId(getOutputProfiles());
|
||
settings.deviceGray = getFirstProfileId(getGrayProfiles());
|
||
settings.deviceRGB = getFirstProfileId(getRGBProfiles());
|
||
settings.deviceCMYK = getFirstProfileId(getCMYKProfiles());
|
||
|
||
return settings;
|
||
}
|
||
|
||
void PDFCMSManager::setDocument(const PDFDocument* document)
|
||
{
|
||
std::optional<QMutexLocker> lock;
|
||
lock.emplace(&m_mutex);
|
||
|
||
if (m_document == document)
|
||
{
|
||
return;
|
||
}
|
||
|
||
m_document = document;
|
||
|
||
int i = 0;
|
||
PDFColorProfileIdentifiers outputIntentProfiles;
|
||
|
||
if (m_document)
|
||
{
|
||
for (const PDFOutputIntent& outputIntent : m_document->getCatalog()->getOutputIntents())
|
||
{
|
||
QByteArray content;
|
||
|
||
try
|
||
{
|
||
// Try to read the profile from the output intent stream. If it fails, then do nothing.
|
||
PDFObject outputProfileObject = m_document->getObject(outputIntent.getOutputProfile());
|
||
if (outputProfileObject.isStream())
|
||
{
|
||
content = m_document->getDecodedStream(outputProfileObject.getStream());
|
||
}
|
||
}
|
||
catch (PDFException)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (content.isEmpty())
|
||
{
|
||
// Decoding of output profile failed. Continue
|
||
// with next output profile.
|
||
continue;
|
||
}
|
||
|
||
cmsHPROFILE profile = cmsOpenProfileFromMem(content.data(), content.size());
|
||
if (profile)
|
||
{
|
||
PDFColorProfileIdentifier::Type csiType = PDFColorProfileIdentifier::Type::Invalid;
|
||
const cmsColorSpaceSignature colorSpace = cmsGetColorSpace(profile);
|
||
switch (colorSpace)
|
||
{
|
||
case cmsSigGrayData:
|
||
csiType = PDFColorProfileIdentifier::Type::MemoryGray;
|
||
break;
|
||
|
||
case cmsSigRgbData:
|
||
csiType = PDFColorProfileIdentifier::Type::MemoryRGB;
|
||
break;
|
||
|
||
case cmsSigCmykData:
|
||
csiType = PDFColorProfileIdentifier::Type::MemoryCMYK;
|
||
break;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
|
||
QString description = getInfoFromProfile(profile, cmsInfoDescription);
|
||
cmsCloseProfile(profile);
|
||
|
||
// If we have a valid profile, then add it
|
||
if (csiType != PDFColorProfileIdentifier::Type::Invalid)
|
||
{
|
||
outputIntentProfiles.emplace_back(PDFColorProfileIdentifier::createOutputIntent(csiType, qMove(description), QString("@@OUTPUT_INTENT_PROFILE_%1").arg(++i), qMove(content)));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
bool outputIntentProfilesChanged = false;
|
||
if (m_outputIntentProfiles != outputIntentProfiles)
|
||
{
|
||
m_outputIntentProfiles = qMove(outputIntentProfiles);
|
||
clearCache();
|
||
outputIntentProfilesChanged = true;
|
||
}
|
||
|
||
if (outputIntentProfilesChanged)
|
||
{
|
||
lock = std::nullopt;
|
||
emit colorManagementSystemChanged();
|
||
}
|
||
}
|
||
|
||
QString PDFCMSManager::getSystemName(PDFCMSSettings::System system)
|
||
{
|
||
switch (system)
|
||
{
|
||
case PDFCMSSettings::System::Generic:
|
||
return tr("Generic");
|
||
|
||
case PDFCMSSettings::System::LittleCMS2:
|
||
{
|
||
const int major = LCMS_VERSION / 1000;
|
||
const int minor = (LCMS_VERSION % 1000) / 10;
|
||
return tr("Little CMS %1.%2").arg(major).arg(minor);
|
||
}
|
||
|
||
default:
|
||
{
|
||
Q_ASSERT(false);
|
||
break;
|
||
}
|
||
}
|
||
|
||
return QString();
|
||
}
|
||
|
||
PDFCMSPointer PDFCMSManager::getCurrentCMSImpl() const
|
||
{
|
||
switch (m_settings.system)
|
||
{
|
||
case PDFCMSSettings::System::Generic:
|
||
return PDFCMSPointer(new PDFCMSGeneric());
|
||
|
||
case PDFCMSSettings::System::LittleCMS2:
|
||
return PDFCMSPointer(new PDFLittleCMS(this, m_settings));
|
||
|
||
default:
|
||
Q_ASSERT(false);
|
||
break;
|
||
}
|
||
|
||
return PDFCMSPointer(new PDFCMSGeneric());
|
||
}
|
||
|
||
void PDFCMSManager::clearCache()
|
||
{
|
||
QMutexLocker lock(&m_mutex);
|
||
m_CMS.dirty();
|
||
m_outputProfiles.dirty();
|
||
m_grayProfiles.dirty();
|
||
m_RGBProfiles.dirty();
|
||
m_CMYKProfiles.dirty();
|
||
m_externalProfiles.dirty();
|
||
}
|
||
|
||
PDFColorProfileIdentifiers PDFCMSManager::getOutputProfilesImpl() const
|
||
{
|
||
// Currently, we only support sRGB output color profile.
|
||
return { PDFColorProfileIdentifier::createSRGB() };
|
||
}
|
||
|
||
PDFColorProfileIdentifiers PDFCMSManager::getGrayProfilesImpl() const
|
||
{
|
||
// Jakub Melka: We create gray profiles for temperature 5000K, 6500K and 9300K.
|
||
// We also use linear gamma and gamma value 2.2.
|
||
PDFColorProfileIdentifiers result =
|
||
{
|
||
PDFColorProfileIdentifier::createGray(tr("Gray D65, γ = 2.2"), "@GENERIC_Gray_D65_g22", 6500.0, 2.2),
|
||
PDFColorProfileIdentifier::createGray(tr("Gray D50, γ = 2.2"), "@GENERIC_Gray_D50_g22", 5000.0, 2.2),
|
||
PDFColorProfileIdentifier::createGray(tr("Gray D93, γ = 2.2"), "@GENERIC_Gray_D93_g22", 9300.0, 2.2),
|
||
PDFColorProfileIdentifier::createGray(tr("Gray D65, γ = 1.0 (linear)"), "@GENERIC_Gray_D65_g10", 6500.0, 1.0),
|
||
PDFColorProfileIdentifier::createGray(tr("Gray D50, γ = 1.0 (linear)"), "@GENERIC_Gray_D50_g10", 5000.0, 1.0),
|
||
PDFColorProfileIdentifier::createGray(tr("Gray D93, γ = 1.0 (linear)"), "@GENERIC_Gray_D93_g10", 9300.0, 1.0)
|
||
};
|
||
|
||
PDFColorProfileIdentifiers externalGrayProfiles = getFilteredExternalProfiles(PDFColorProfileIdentifier::Type::FileGray);
|
||
result.insert(result.end(), std::make_move_iterator(externalGrayProfiles.begin()), std::make_move_iterator(externalGrayProfiles.end()));
|
||
PDFColorProfileIdentifiers outputIntentRGBProfiles = getFilteredOutputIntentProfiles(PDFColorProfileIdentifier::Type::MemoryGray);
|
||
result.insert(result.end(), std::make_move_iterator(outputIntentRGBProfiles.begin()), std::make_move_iterator(outputIntentRGBProfiles.end()));
|
||
return result;
|
||
}
|
||
|
||
PDFColorProfileIdentifiers PDFCMSManager::getRGBProfilesImpl() const
|
||
{
|
||
// Jakub Melka: We create RGB profiles for common standards and also for
|
||
// default standard sRGB. See https://en.wikipedia.org/wiki/Color_spaces_with_RGB_primaries.
|
||
PDFColorProfileIdentifiers result =
|
||
{
|
||
PDFColorProfileIdentifier::createSRGB(),
|
||
PDFColorProfileIdentifier::createRGB(tr("HDTV (ITU-R BT.709)"), "@GENERIC_RGB_HDTV", 6500, QPointF(0.64, 0.33), QPointF(0.30, 0.60), QPointF(0.15, 0.06), 20.0 / 9.0),
|
||
PDFColorProfileIdentifier::createRGB(tr("Adobe RGB 1998"), "@GENERIC_RGB_Adobe1998", 6500, QPointF(0.64, 0.33), QPointF(0.30, 0.60), QPointF(0.15, 0.06), 563.0 / 256.0),
|
||
PDFColorProfileIdentifier::createRGB(tr("PAL / SECAM"), "@GENERIC_RGB_PalSecam", 6500, QPointF(0.64, 0.33), QPointF(0.29, 0.60), QPointF(0.15, 0.06), 14.0 / 5.0),
|
||
PDFColorProfileIdentifier::createRGB(tr("NTSC"), "@GENERIC_RGB_NTSC", 6500, QPointF(0.64, 0.34), QPointF(0.31, 0.595), QPointF(0.155, 0.07), 20.0 / 9.0),
|
||
PDFColorProfileIdentifier::createRGB(tr("Adobe Wide Gamut RGB"), "@GENERIC_RGB_AdobeWideGamut", 5000, QPointF(0.735, 0.265), QPointF(0.115, 0.826), QPointF(0.157, 0.018), 563.0 / 256.0),
|
||
PDFColorProfileIdentifier::createRGB(tr("ProPhoto RGB"), "@GENERIC_RGB_ProPhoto", 5000, QPointF(0.7347, 0.2653), QPointF(0.1596, 0.8404), QPointF(0.0366, 0.0001), 9.0 / 5.0)
|
||
};
|
||
|
||
PDFColorProfileIdentifiers externalRGBProfiles = getFilteredExternalProfiles(PDFColorProfileIdentifier::Type::FileRGB);
|
||
result.insert(result.end(), externalRGBProfiles.begin(), externalRGBProfiles.end());
|
||
PDFColorProfileIdentifiers outputIntentRGBProfiles = getFilteredOutputIntentProfiles(PDFColorProfileIdentifier::Type::MemoryRGB);
|
||
result.insert(result.end(), std::make_move_iterator(outputIntentRGBProfiles.begin()), std::make_move_iterator(outputIntentRGBProfiles.end()));
|
||
return result;
|
||
}
|
||
|
||
PDFColorProfileIdentifiers PDFCMSManager::getCMYKProfilesImpl() const
|
||
{
|
||
PDFColorProfileIdentifiers result;
|
||
|
||
PDFColorProfileIdentifiers externalCMYKProfiles = getFilteredExternalProfiles(PDFColorProfileIdentifier::Type::FileCMYK);
|
||
result.insert(result.end(), externalCMYKProfiles.begin(), externalCMYKProfiles.end());
|
||
PDFColorProfileIdentifiers outputIntentCMYKProfiles = getFilteredOutputIntentProfiles(PDFColorProfileIdentifier::Type::MemoryCMYK);
|
||
result.insert(result.end(), std::make_move_iterator(outputIntentCMYKProfiles.begin()), std::make_move_iterator(outputIntentCMYKProfiles.end()));
|
||
|
||
return result;
|
||
}
|
||
|
||
PDFColorProfileIdentifiers PDFCMSManager::getExternalColorProfiles(QString profileDirectory) const
|
||
{
|
||
PDFColorProfileIdentifiers result;
|
||
|
||
QDir directory(profileDirectory);
|
||
QDir applicationDirectory(QApplication::applicationDirPath());
|
||
if (!profileDirectory.isEmpty() && directory.exists())
|
||
{
|
||
QStringList iccProfiles = directory.entryList({ "*.icc" }, QDir::Files | QDir::Readable | QDir::NoDotAndDotDot, QDir::NoSort);
|
||
for (const QString& fileName : iccProfiles)
|
||
{
|
||
QString filePath = QDir::cleanPath(applicationDirectory.relativeFilePath(directory.absoluteFilePath(fileName)));
|
||
|
||
// Try to read the profile from the file. If it fails, then do nothing.
|
||
QFile file(filePath);
|
||
if (file.open(QFile::ReadOnly))
|
||
{
|
||
QByteArray content = file.readAll();
|
||
file.close();
|
||
|
||
cmsHPROFILE profile = cmsOpenProfileFromMem(content.data(), content.size());
|
||
if (profile)
|
||
{
|
||
PDFColorProfileIdentifier::Type csiType = PDFColorProfileIdentifier::Type::Invalid;
|
||
const cmsColorSpaceSignature colorSpace = cmsGetColorSpace(profile);
|
||
switch (colorSpace)
|
||
{
|
||
case cmsSigGrayData:
|
||
csiType = PDFColorProfileIdentifier::Type::FileGray;
|
||
break;
|
||
|
||
case cmsSigRgbData:
|
||
csiType = PDFColorProfileIdentifier::Type::FileRGB;
|
||
break;
|
||
|
||
case cmsSigCmykData:
|
||
csiType = PDFColorProfileIdentifier::Type::FileCMYK;
|
||
break;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
|
||
QString description = getInfoFromProfile(profile, cmsInfoDescription);
|
||
cmsCloseProfile(profile);
|
||
|
||
// If we have a valid profile, then add it
|
||
if (csiType != PDFColorProfileIdentifier::Type::Invalid)
|
||
{
|
||
result.emplace_back(PDFColorProfileIdentifier::createFile(csiType, qMove(description), filePath));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
PDFColorProfileIdentifiers PDFCMSManager::getExternalProfilesImpl() const
|
||
{
|
||
PDFColorProfileIdentifiers result;
|
||
|
||
QStringList directories(m_settings.profileDirectory);
|
||
|
||
#ifdef Q_OS_WIN
|
||
std::array<WCHAR, _MAX_PATH> buffer = { };
|
||
DWORD bufferSize = DWORD(buffer.size() * sizeof(WCHAR));
|
||
if (GetColorDirectoryW(NULL, buffer.data(), &bufferSize))
|
||
{
|
||
const DWORD charactersWithNull = bufferSize / sizeof(WCHAR);
|
||
const DWORD charactersWithoutNull = bufferSize > 0 ? charactersWithNull - 1 : 0;
|
||
|
||
QString directory = QString::fromWCharArray(buffer.data(), int(charactersWithoutNull));
|
||
directories << QDir::fromNativeSeparators(directory);
|
||
}
|
||
#endif
|
||
|
||
for (const QString& directory : directories)
|
||
{
|
||
PDFColorProfileIdentifiers externalProfiles = getExternalColorProfiles(directory);
|
||
result.insert(result.end(), externalProfiles.begin(), externalProfiles.end());
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
PDFColorProfileIdentifiers PDFCMSManager::getFilteredExternalProfiles(PDFColorProfileIdentifier::Type type) const
|
||
{
|
||
PDFColorProfileIdentifiers result;
|
||
const PDFColorProfileIdentifiers& externalProfiles = getExternalProfiles();
|
||
std::copy_if(externalProfiles.cbegin(), externalProfiles.cend(), std::back_inserter(result), [type](const PDFColorProfileIdentifier& identifier) { return identifier.type == type; });
|
||
return result;
|
||
}
|
||
|
||
PDFColorProfileIdentifiers PDFCMSManager::getFilteredOutputIntentProfiles(PDFColorProfileIdentifier::Type type) const
|
||
{
|
||
PDFColorProfileIdentifiers result;
|
||
std::copy_if(m_outputIntentProfiles.cbegin(), m_outputIntentProfiles.cend(), std::back_inserter(result), [type](const PDFColorProfileIdentifier& identifier) { return identifier.type == type; });
|
||
return result;
|
||
}
|
||
|
||
PDFColorProfileIdentifier PDFColorProfileIdentifier::createGray(QString name, QString id, PDFReal temperature, PDFReal gamma)
|
||
{
|
||
PDFColorProfileIdentifier result;
|
||
result.type = Type::Gray;
|
||
result.name = qMove(name);
|
||
result.id = qMove(id);
|
||
result.temperature = temperature;
|
||
result.gamma = gamma;
|
||
return result;
|
||
}
|
||
|
||
PDFColorProfileIdentifier PDFColorProfileIdentifier::createSRGB()
|
||
{
|
||
PDFColorProfileIdentifier result;
|
||
result.type = Type::sRGB;
|
||
result.name = PDFCMSManager::tr("sRGB");
|
||
result.id = "@GENERIC_sRGB";
|
||
return result;
|
||
}
|
||
|
||
PDFColorProfileIdentifier PDFColorProfileIdentifier::createRGB(QString name, QString id, PDFReal temperature, QPointF primaryR, QPointF primaryG, QPointF primaryB, PDFReal gamma)
|
||
{
|
||
PDFColorProfileIdentifier result;
|
||
result.type = Type::RGB;
|
||
result.name = qMove(name);
|
||
result.id = qMove(id);
|
||
result.temperature = temperature;
|
||
result.primaryR = primaryR;
|
||
result.primaryG = primaryG;
|
||
result.primaryB = primaryB;
|
||
result.gamma = gamma;
|
||
return result;
|
||
}
|
||
|
||
PDFColorProfileIdentifier PDFColorProfileIdentifier::createFile(Type type, QString name, QString id)
|
||
{
|
||
PDFColorProfileIdentifier result;
|
||
result.type = type;
|
||
result.name = qMove(name);
|
||
result.id = qMove(id);
|
||
return result;
|
||
}
|
||
|
||
PDFColorProfileIdentifier PDFColorProfileIdentifier::createOutputIntent(PDFColorProfileIdentifier::Type type, QString name, QString id, QByteArray profileData)
|
||
{
|
||
PDFColorProfileIdentifier result;
|
||
result.type = type;
|
||
result.name = qMove(name);
|
||
result.id = qMove(id);
|
||
result.profileMemoryData = qMove(profileData);
|
||
result.isOutputIntentProfile = true;
|
||
return result;
|
||
}
|
||
|
||
PDFColor3 PDFCMS::getDefaultXYZWhitepoint()
|
||
{
|
||
const cmsCIEXYZ* whitePoint = cmsD50_XYZ();
|
||
return PDFColor3{ PDFColorComponent(whitePoint->X), PDFColorComponent(whitePoint->Y), PDFColorComponent(whitePoint->Z) };
|
||
}
|
||
|
||
PDFColorComponentMatrix_3x3 PDFChromaticAdaptationXYZ::createWhitepointChromaticAdaptation(const PDFColor3& targetWhitePoint,
|
||
const PDFColor3& sourceWhitePoint,
|
||
PDFCMSSettings::ColorAdaptationXYZ method)
|
||
{
|
||
PDFColorComponentMatrix_3x3 matrix;
|
||
matrix.makeIdentity();
|
||
|
||
switch (method)
|
||
{
|
||
case pdf::PDFCMSSettings::ColorAdaptationXYZ::None:
|
||
// No scaling performed, just return identity matrix
|
||
break;
|
||
|
||
case pdf::PDFCMSSettings::ColorAdaptationXYZ::XYZScaling:
|
||
matrix.makeDiagonal(std::array{ targetWhitePoint[0] / sourceWhitePoint[0],
|
||
targetWhitePoint[1] / sourceWhitePoint[1],
|
||
targetWhitePoint[2] / sourceWhitePoint[2]
|
||
});
|
||
break;
|
||
|
||
case pdf::PDFCMSSettings::ColorAdaptationXYZ::CAT97:
|
||
{
|
||
// CAT97 matrix, as defined in https://en.wikipedia.org/wiki/LMS_color_space
|
||
constexpr PDFColorComponentMatrix_3x3 cat97Matrix(
|
||
0.8562f, 0.3372f, -0.1934f,
|
||
-0.8360f, 1.8327f, 0.0033f,
|
||
0.0357f, -0.0469f, 1.0112f);
|
||
|
||
// Inverse of CAT97 matrix (using wxMaxima to compute it)
|
||
constexpr PDFColorComponentMatrix_3x3 inverseCat97Matrix(
|
||
0.9873999149199271f, -0.1768250198556842f, 0.1894251049357571f,
|
||
0.4504351090445315f, 0.464932897752711f, 0.08463199320275755f,
|
||
-0.01396832510725165f, 0.027806572501434f, 0.9861617526058175f);
|
||
|
||
PDFColor3 adaptedTargetWhitePoint = cat97Matrix * targetWhitePoint;
|
||
PDFColor3 adaptedSourceWhitePoint = cat97Matrix * sourceWhitePoint;
|
||
PDFColor3 gain = {
|
||
adaptedTargetWhitePoint[0] / adaptedSourceWhitePoint[0],
|
||
adaptedTargetWhitePoint[1] / adaptedSourceWhitePoint[1],
|
||
adaptedTargetWhitePoint[2] / adaptedSourceWhitePoint[2]
|
||
};
|
||
|
||
PDFColorComponentMatrix_3x3 gainMatrix;
|
||
gainMatrix.makeDiagonal(gain);
|
||
|
||
matrix = inverseCat97Matrix * gainMatrix * cat97Matrix;
|
||
break;
|
||
}
|
||
|
||
case pdf::PDFCMSSettings::ColorAdaptationXYZ::CAT02:
|
||
{
|
||
// CAT02 matrix, as defined in https://en.wikipedia.org/wiki/LMS_color_space
|
||
constexpr PDFColorComponentMatrix_3x3 cat02Matrix(
|
||
0.7328f, 0.4296f, -0.1624f,
|
||
-0.7036f, 1.6975f, 0.0061f,
|
||
0.0030f, 0.0136f, 0.9834f);
|
||
|
||
// Inverse of CAT02 matrix (using wxMaxima to compute it)
|
||
constexpr PDFColorComponentMatrix_3x3 inverseCat02Matrix(
|
||
1.096123820835514f, -0.2788690002182872f, 0.182745179382773f,
|
||
0.4543690419753592f, 0.4735331543074117f, 0.0720978037172291f,
|
||
-0.009627608738429352f, -0.005698031216113419f, 1.015325639954543f);
|
||
|
||
PDFColor3 adaptedTargetWhitePoint = cat02Matrix * targetWhitePoint;
|
||
PDFColor3 adaptedSourceWhitePoint = cat02Matrix * sourceWhitePoint;
|
||
PDFColor3 gain = {
|
||
adaptedTargetWhitePoint[0] / adaptedSourceWhitePoint[0],
|
||
adaptedTargetWhitePoint[1] / adaptedSourceWhitePoint[1],
|
||
adaptedTargetWhitePoint[2] / adaptedSourceWhitePoint[2]
|
||
};
|
||
|
||
PDFColorComponentMatrix_3x3 gainMatrix;
|
||
gainMatrix.makeDiagonal(gain);
|
||
|
||
matrix = inverseCat02Matrix * gainMatrix * cat02Matrix;
|
||
break;
|
||
}
|
||
|
||
case pdf::PDFCMSSettings::ColorAdaptationXYZ::Bradford:
|
||
{
|
||
// Bradford matrix, as defined in https://en.wikipedia.org/wiki/LMS_color_space
|
||
constexpr PDFColorComponentMatrix_3x3 bradfordMatrix(
|
||
0.8951f, 0.2264f, -0.1614f,
|
||
-0.7502f, 1.7135f, 0.0367f,
|
||
0.0389f, -0.0685f, 1.0296f);
|
||
|
||
// Inverse of bradford matrix (using wxMaxima to compute it)
|
||
constexpr PDFColorComponentMatrix_3x3 inverseBradfordMatrix(
|
||
1.004360519274085f, -0.1262294327613208f, 0.1619428982062721f,
|
||
0.4399123264001572f, 0.527481594455384f, 0.05015858096782513f,
|
||
-0.008678739162151443f, 0.03986287311053728f, 0.9684695843590444f);
|
||
|
||
PDFColor3 adaptedTargetWhitePoint = bradfordMatrix * targetWhitePoint;
|
||
PDFColor3 adaptedSourceWhitePoint = bradfordMatrix * sourceWhitePoint;
|
||
PDFColor3 gain = {
|
||
adaptedTargetWhitePoint[0] / adaptedSourceWhitePoint[0],
|
||
adaptedTargetWhitePoint[1] / adaptedSourceWhitePoint[1],
|
||
adaptedTargetWhitePoint[2] / adaptedSourceWhitePoint[2]
|
||
};
|
||
|
||
PDFColorComponentMatrix_3x3 gainMatrix;
|
||
gainMatrix.makeDiagonal(gain);
|
||
|
||
matrix = inverseBradfordMatrix * gainMatrix * bradfordMatrix;
|
||
break;
|
||
}
|
||
|
||
default:
|
||
Q_ASSERT(false);
|
||
break;
|
||
}
|
||
|
||
return matrix;
|
||
}
|
||
|
||
} // namespace pdf
|