blob: 0c770f1cad2367565ca3c9fecab09c827dd03495 [file] [log] [blame]
//========================================================================
//
// GfxState.cc
//
// Copyright 1996-2003 Glyph & Cog, LLC
//
//========================================================================
//========================================================================
//
// Modified under the Poppler project - http://poppler.freedesktop.org
//
// All changes made under the Poppler project to this file are licensed
// under GPL version 2 or later
//
// Copyright (C) 2005 Kristian Høgsberg <krh@redhat.com>
// Copyright (C) 2006, 2007 Jeff Muizelaar <jeff@infidigm.net>
// Copyright (C) 2006, 2010 Carlos Garcia Campos <carlosgc@gnome.org>
// Copyright (C) 2006-2022 Albert Astals Cid <aacid@kde.org>
// Copyright (C) 2009, 2012 Koji Otani <sho@bbr.jp>
// Copyright (C) 2009, 2011-2016, 2020, 2023 Thomas Freitag <Thomas.Freitag@alfa.de>
// Copyright (C) 2009, 2019 Christian Persch <chpe@gnome.org>
// Copyright (C) 2010 Paweł Wiejacha <pawel.wiejacha@gmail.com>
// Copyright (C) 2010 Christian Feuersänger <cfeuersaenger@googlemail.com>
// Copyright (C) 2011 Andrea Canciani <ranma42@gmail.com>
// Copyright (C) 2012, 2020 William Bader <williambader@hotmail.com>
// Copyright (C) 2013 Lu Wang <coolwanglu@gmail.com>
// Copyright (C) 2013 Hib Eris <hib@hiberis.nl>
// Copyright (C) 2013 Fabio D'Urso <fabiodurso@hotmail.it>
// Copyright (C) 2015, 2020 Adrian Johnson <ajohnson@redneon.com>
// Copyright (C) 2016 Marek Kasik <mkasik@redhat.com>
// Copyright (C) 2017, 2019, 2022 Oliver Sander <oliver.sander@tu-dresden.de>
// Copyright (C) 2018 Klarälvdalens Datakonsult AB, a KDAB Group company, <info@kdab.com>. Work sponsored by the LiMux project of the city of Munich
// Copyright (C) 2018 Volker Krause <vkrause@kde.org>
// Copyright (C) 2018, 2019 Adam Reichold <adam.reichold@t-online.de>
// Copyright (C) 2019 LE GARREC Vincent <legarrec.vincent@gmail.com>
// Copyright (C) 2020, 2021 Philipp Knechtges <philipp-dev@knechtges.com>
// Copyright (C) 2020 Lluís Batlle i Rossell <viric@viric.name>
//
// To see a description of the changes please see the Changelog file that
// came with your tarball or type make ChangeLog if you are building from git
//
//========================================================================
#include <config.h>
#include <algorithm>
#include <memory>
#include <cstddef>
#include <cmath>
#include <cstring>
#include "goo/gfile.h"
#include "goo/gmem.h"
#include "Error.h"
#include "Object.h"
#include "Array.h"
#include "Page.h"
#include "Gfx.h"
#include "GfxState.h"
#include "GfxState_helpers.h"
#include "GfxFont.h"
#include "GlobalParams.h"
#include "PopplerCache.h"
#include "OutputDev.h"
#include "splash/SplashTypes.h"
//------------------------------------------------------------------------
// Max depth of nested color spaces. This is used to catch infinite
// loops in the color space object structure.
#define colorSpaceRecursionLimit 8
//------------------------------------------------------------------------
bool Matrix::invertTo(Matrix *other) const
{
const double det_denominator = determinant();
if (unlikely(det_denominator == 0)) {
*other = { 1, 0, 0, 1, 0, 0 };
return false;
}
const double det = 1 / det_denominator;
other->m[0] = m[3] * det;
other->m[1] = -m[1] * det;
other->m[2] = -m[2] * det;
other->m[3] = m[0] * det;
other->m[4] = (m[2] * m[5] - m[3] * m[4]) * det;
other->m[5] = (m[1] * m[4] - m[0] * m[5]) * det;
return true;
}
void Matrix::translate(double tx, double ty)
{
double x0 = tx * m[0] + ty * m[2] + m[4];
double y0 = tx * m[1] + ty * m[3] + m[5];
m[4] = x0;
m[5] = y0;
}
void Matrix::scale(double sx, double sy)
{
m[0] *= sx;
m[1] *= sx;
m[2] *= sy;
m[3] *= sy;
}
void Matrix::transform(double x, double y, double *tx, double *ty) const
{
double temp_x, temp_y;
temp_x = m[0] * x + m[2] * y + m[4];
temp_y = m[1] * x + m[3] * y + m[5];
*tx = temp_x;
*ty = temp_y;
}
// Matrix norm, taken from _cairo_matrix_transformed_circle_major_axis
double Matrix::norm() const
{
double f, g, h, i, j;
i = m[0] * m[0] + m[1] * m[1];
j = m[2] * m[2] + m[3] * m[3];
f = 0.5 * (i + j);
g = 0.5 * (i - j);
h = m[0] * m[2] + m[1] * m[3];
return sqrt(f + hypot(g, h));
}
//------------------------------------------------------------------------
struct GfxBlendModeInfo
{
const char *name;
GfxBlendMode mode;
};
static const GfxBlendModeInfo gfxBlendModeNames[] = { { "Normal", gfxBlendNormal }, { "Compatible", gfxBlendNormal },
{ "Multiply", gfxBlendMultiply }, { "Screen", gfxBlendScreen },
{ "Overlay", gfxBlendOverlay }, { "Darken", gfxBlendDarken },
{ "Lighten", gfxBlendLighten }, { "ColorDodge", gfxBlendColorDodge },
{ "ColorBurn", gfxBlendColorBurn }, { "HardLight", gfxBlendHardLight },
{ "SoftLight", gfxBlendSoftLight }, { "Difference", gfxBlendDifference },
{ "Exclusion", gfxBlendExclusion }, { "Hue", gfxBlendHue },
{ "Saturation", gfxBlendSaturation }, { "Color", gfxBlendColor },
{ "Luminosity", gfxBlendLuminosity } };
#define nGfxBlendModeNames ((int)((sizeof(gfxBlendModeNames) / sizeof(GfxBlendModeInfo))))
//------------------------------------------------------------------------
//
// NB: This must match the GfxColorSpaceMode enum defined in
// GfxState.h
static const char *gfxColorSpaceModeNames[] = { "DeviceGray", "CalGray", "DeviceRGB", "CalRGB", "DeviceCMYK", "Lab", "ICCBased", "Indexed", "Separation", "DeviceN", "Pattern" };
#define nGfxColorSpaceModes ((sizeof(gfxColorSpaceModeNames) / sizeof(char *)))
#ifdef USE_CMS
static const std::map<unsigned int, unsigned int>::size_type CMSCACHE_LIMIT = 2048;
# include <lcms2.h>
# define LCMS_FLAGS cmsFLAGS_NOOPTIMIZE | cmsFLAGS_BLACKPOINTCOMPENSATION
static void lcmsprofiledeleter(void *profile)
{
cmsCloseProfile(profile);
}
GfxLCMSProfilePtr make_GfxLCMSProfilePtr(void *profile)
{
if (profile == nullptr) {
return GfxLCMSProfilePtr();
}
return GfxLCMSProfilePtr(profile, lcmsprofiledeleter);
}
void GfxColorTransform::doTransform(void *in, void *out, unsigned int size)
{
cmsDoTransform(transform, in, out, size);
}
// transformA should be a cmsHTRANSFORM
GfxColorTransform::GfxColorTransform(void *transformA, int cmsIntentA, unsigned int inputPixelTypeA, unsigned int transformPixelTypeA)
{
transform = transformA;
cmsIntent = cmsIntentA;
inputPixelType = inputPixelTypeA;
transformPixelType = transformPixelTypeA;
}
GfxColorTransform::~GfxColorTransform()
{
cmsDeleteTransform(transform);
}
// convert color space signature to cmsColor type
static unsigned int getCMSColorSpaceType(cmsColorSpaceSignature cs);
static unsigned int getCMSNChannels(cmsColorSpaceSignature cs);
#endif
//------------------------------------------------------------------------
// GfxColorSpace
//------------------------------------------------------------------------
GfxColorSpace::GfxColorSpace()
{
overprintMask = 0x0f;
mapping = nullptr;
}
GfxColorSpace::~GfxColorSpace() { }
GfxColorSpace *GfxColorSpace::parse(GfxResources *res, Object *csObj, OutputDev *out, GfxState *state, int recursion)
{
GfxColorSpace *cs;
Object obj1;
if (recursion > colorSpaceRecursionLimit) {
error(errSyntaxError, -1, "Loop detected in color space objects");
return nullptr;
}
cs = nullptr;
if (csObj->isName()) {
if (csObj->isName("DeviceGray") || csObj->isName("G")) {
if (res != nullptr) {
Object objCS = res->lookupColorSpace("DefaultGray");
if (objCS.isNull()) {
cs = state->copyDefaultGrayColorSpace();
} else {
cs = GfxColorSpace::parse(nullptr, &objCS, out, state);
}
} else {
cs = state->copyDefaultGrayColorSpace();
}
} else if (csObj->isName("DeviceRGB") || csObj->isName("RGB")) {
if (res != nullptr) {
Object objCS = res->lookupColorSpace("DefaultRGB");
if (objCS.isNull()) {
cs = state->copyDefaultRGBColorSpace();
} else {
cs = GfxColorSpace::parse(nullptr, &objCS, out, state);
}
} else {
cs = state->copyDefaultRGBColorSpace();
}
} else if (csObj->isName("DeviceCMYK") || csObj->isName("CMYK")) {
if (res != nullptr) {
Object objCS = res->lookupColorSpace("DefaultCMYK");
if (objCS.isNull()) {
cs = state->copyDefaultCMYKColorSpace();
} else {
cs = GfxColorSpace::parse(nullptr, &objCS, out, state);
}
} else {
cs = state->copyDefaultCMYKColorSpace();
}
} else if (csObj->isName("Pattern")) {
cs = new GfxPatternColorSpace(nullptr);
} else {
error(errSyntaxWarning, -1, "Bad color space '{0:s}'", csObj->getName());
}
} else if (csObj->isArray() && csObj->arrayGetLength() > 0) {
obj1 = csObj->arrayGet(0);
if (obj1.isName("DeviceGray") || obj1.isName("G")) {
if (res != nullptr) {
Object objCS = res->lookupColorSpace("DefaultGray");
if (objCS.isNull()) {
cs = state->copyDefaultGrayColorSpace();
} else {
cs = GfxColorSpace::parse(nullptr, &objCS, out, state);
}
} else {
cs = state->copyDefaultGrayColorSpace();
}
} else if (obj1.isName("DeviceRGB") || obj1.isName("RGB")) {
if (res != nullptr) {
Object objCS = res->lookupColorSpace("DefaultRGB");
if (objCS.isNull()) {
cs = state->copyDefaultRGBColorSpace();
} else {
cs = GfxColorSpace::parse(nullptr, &objCS, out, state);
}
} else {
cs = state->copyDefaultRGBColorSpace();
}
} else if (obj1.isName("DeviceCMYK") || obj1.isName("CMYK")) {
if (res != nullptr) {
Object objCS = res->lookupColorSpace("DefaultCMYK");
if (objCS.isNull()) {
cs = state->copyDefaultCMYKColorSpace();
} else {
cs = GfxColorSpace::parse(nullptr, &objCS, out, state);
}
} else {
cs = state->copyDefaultCMYKColorSpace();
}
} else if (obj1.isName("CalGray")) {
cs = GfxCalGrayColorSpace::parse(csObj->getArray(), state);
} else if (obj1.isName("CalRGB")) {
cs = GfxCalRGBColorSpace::parse(csObj->getArray(), state);
} else if (obj1.isName("Lab")) {
cs = GfxLabColorSpace::parse(csObj->getArray(), state);
} else if (obj1.isName("ICCBased")) {
cs = GfxICCBasedColorSpace::parse(csObj->getArray(), out, state, recursion);
} else if (obj1.isName("Indexed") || obj1.isName("I")) {
cs = GfxIndexedColorSpace::parse(res, csObj->getArray(), out, state, recursion);
} else if (obj1.isName("Separation")) {
cs = GfxSeparationColorSpace::parse(res, csObj->getArray(), out, state, recursion);
} else if (obj1.isName("DeviceN")) {
cs = GfxDeviceNColorSpace::parse(res, csObj->getArray(), out, state, recursion);
} else if (obj1.isName("Pattern")) {
cs = GfxPatternColorSpace::parse(res, csObj->getArray(), out, state, recursion);
} else {
error(errSyntaxWarning, -1, "Bad color space");
}
} else if (csObj->isDict()) {
obj1 = csObj->dictLookup("ColorSpace");
if (obj1.isName("DeviceGray")) {
if (res != nullptr) {
Object objCS = res->lookupColorSpace("DefaultGray");
if (objCS.isNull()) {
cs = state->copyDefaultGrayColorSpace();
} else {
cs = GfxColorSpace::parse(nullptr, &objCS, out, state);
}
} else {
cs = state->copyDefaultGrayColorSpace();
}
} else if (obj1.isName("DeviceRGB")) {
if (res != nullptr) {
Object objCS = res->lookupColorSpace("DefaultRGB");
if (objCS.isNull()) {
cs = state->copyDefaultRGBColorSpace();
} else {
cs = GfxColorSpace::parse(nullptr, &objCS, out, state);
}
} else {
cs = state->copyDefaultRGBColorSpace();
}
} else if (obj1.isName("DeviceCMYK")) {
if (res != nullptr) {
Object objCS = res->lookupColorSpace("DefaultCMYK");
if (objCS.isNull()) {
cs = state->copyDefaultCMYKColorSpace();
} else {
cs = GfxColorSpace::parse(nullptr, &objCS, out, state);
}
} else {
cs = state->copyDefaultCMYKColorSpace();
}
} else {
error(errSyntaxWarning, -1, "Bad color space dict'");
}
} else {
error(errSyntaxWarning, -1, "Bad color space - expected name or array or dict");
}
return cs;
}
void GfxColorSpace::createMapping(std::vector<GfxSeparationColorSpace *> *separationList, int maxSepComps)
{
return;
}
void GfxColorSpace::getDefaultRanges(double *decodeLow, double *decodeRange, int maxImgPixel) const
{
int i;
for (i = 0; i < getNComps(); ++i) {
decodeLow[i] = 0;
decodeRange[i] = 1;
}
}
int GfxColorSpace::getNumColorSpaceModes()
{
return nGfxColorSpaceModes;
}
const char *GfxColorSpace::getColorSpaceModeName(int idx)
{
return gfxColorSpaceModeNames[idx];
}
#ifdef USE_CMS
static void CMSError(cmsContext /*contextId*/, cmsUInt32Number /*ecode*/, const char *text)
{
error(errSyntaxWarning, -1, "{0:s}", text);
}
unsigned int getCMSColorSpaceType(cmsColorSpaceSignature cs)
{
switch (cs) {
case cmsSigXYZData:
return PT_XYZ;
break;
case cmsSigLabData:
return PT_Lab;
break;
case cmsSigLuvData:
return PT_YUV;
break;
case cmsSigYCbCrData:
return PT_YCbCr;
break;
case cmsSigYxyData:
return PT_Yxy;
break;
case cmsSigRgbData:
return PT_RGB;
break;
case cmsSigGrayData:
return PT_GRAY;
break;
case cmsSigHsvData:
return PT_HSV;
break;
case cmsSigHlsData:
return PT_HLS;
break;
case cmsSigCmykData:
return PT_CMYK;
break;
case cmsSigCmyData:
return PT_CMY;
break;
case cmsSig2colorData:
case cmsSig3colorData:
case cmsSig4colorData:
case cmsSig5colorData:
case cmsSig6colorData:
case cmsSig7colorData:
case cmsSig8colorData:
case cmsSig9colorData:
case cmsSig10colorData:
case cmsSig11colorData:
case cmsSig12colorData:
case cmsSig13colorData:
case cmsSig14colorData:
case cmsSig15colorData:
default:
break;
}
return PT_RGB;
}
unsigned int getCMSNChannels(cmsColorSpaceSignature cs)
{
switch (cs) {
case cmsSigXYZData:
case cmsSigLuvData:
case cmsSigLabData:
case cmsSigYCbCrData:
case cmsSigYxyData:
case cmsSigRgbData:
case cmsSigHsvData:
case cmsSigHlsData:
case cmsSigCmyData:
case cmsSig3colorData:
return 3;
break;
case cmsSigGrayData:
return 1;
break;
case cmsSigCmykData:
case cmsSig4colorData:
return 4;
break;
case cmsSig2colorData:
return 2;
break;
case cmsSig5colorData:
return 5;
break;
case cmsSig6colorData:
return 6;
break;
case cmsSig7colorData:
return 7;
break;
case cmsSig8colorData:
return 8;
break;
case cmsSig9colorData:
return 9;
break;
case cmsSig10colorData:
return 10;
break;
case cmsSig11colorData:
return 11;
break;
case cmsSig12colorData:
return 12;
break;
case cmsSig13colorData:
return 13;
break;
case cmsSig14colorData:
return 14;
break;
case cmsSig15colorData:
return 15;
default:
break;
}
return 3;
}
#endif
//------------------------------------------------------------------------
// GfxDeviceGrayColorSpace
//------------------------------------------------------------------------
GfxDeviceGrayColorSpace::GfxDeviceGrayColorSpace() { }
GfxDeviceGrayColorSpace::~GfxDeviceGrayColorSpace() { }
GfxColorSpace *GfxDeviceGrayColorSpace::copy() const
{
return new GfxDeviceGrayColorSpace();
}
void GfxDeviceGrayColorSpace::getGray(const GfxColor *color, GfxGray *gray) const
{
*gray = clip01(color->c[0]);
}
void GfxDeviceGrayColorSpace::getGrayLine(unsigned char *in, unsigned char *out, int length)
{
memcpy(out, in, length);
}
void GfxDeviceGrayColorSpace::getRGB(const GfxColor *color, GfxRGB *rgb) const
{
rgb->r = rgb->g = rgb->b = clip01(color->c[0]);
}
void GfxDeviceGrayColorSpace::getRGBLine(unsigned char *in, unsigned int *out, int length)
{
int i;
for (i = 0; i < length; i++) {
out[i] = (in[i] << 16) | (in[i] << 8) | (in[i] << 0);
}
}
void GfxDeviceGrayColorSpace::getRGBLine(unsigned char *in, unsigned char *out, int length)
{
for (int i = 0; i < length; i++) {
*out++ = in[i];
*out++ = in[i];
*out++ = in[i];
}
}
void GfxDeviceGrayColorSpace::getRGBXLine(unsigned char *in, unsigned char *out, int length)
{
for (int i = 0; i < length; i++) {
*out++ = in[i];
*out++ = in[i];
*out++ = in[i];
*out++ = 255;
}
}
void GfxDeviceGrayColorSpace::getCMYKLine(unsigned char *in, unsigned char *out, int length)
{
for (int i = 0; i < length; i++) {
*out++ = 0;
*out++ = 0;
*out++ = 0;
*out++ = in[i];
}
}
void GfxDeviceGrayColorSpace::getDeviceNLine(unsigned char *in, unsigned char *out, int length)
{
for (int i = 0; i < length; i++) {
for (int j = 0; j < SPOT_NCOMPS + 4; j++) {
out[j] = 0;
}
out[4] = in[i];
out += (SPOT_NCOMPS + 4);
}
}
void GfxDeviceGrayColorSpace::getCMYK(const GfxColor *color, GfxCMYK *cmyk) const
{
cmyk->c = cmyk->m = cmyk->y = 0;
cmyk->k = clip01(gfxColorComp1 - color->c[0]);
}
void GfxDeviceGrayColorSpace::getDeviceN(const GfxColor *color, GfxColor *deviceN) const
{
clearGfxColor(deviceN);
deviceN->c[3] = clip01(gfxColorComp1 - color->c[0]);
}
void GfxDeviceGrayColorSpace::getDefaultColor(GfxColor *color) const
{
color->c[0] = 0;
}
//------------------------------------------------------------------------
// GfxCalGrayColorSpace
//------------------------------------------------------------------------
GfxCalGrayColorSpace::GfxCalGrayColorSpace()
{
whiteX = whiteY = whiteZ = 1;
blackX = blackY = blackZ = 0;
gamma = 1;
}
GfxCalGrayColorSpace::~GfxCalGrayColorSpace() { }
GfxColorSpace *GfxCalGrayColorSpace::copy() const
{
GfxCalGrayColorSpace *cs;
cs = new GfxCalGrayColorSpace();
cs->whiteX = whiteX;
cs->whiteY = whiteY;
cs->whiteZ = whiteZ;
cs->blackX = blackX;
cs->blackY = blackY;
cs->blackZ = blackZ;
cs->gamma = gamma;
#ifdef USE_CMS
cs->transform = transform;
#endif
return cs;
}
// This is the inverse of MatrixLMN in Example 4.10 from the PostScript
// Language Reference, Third Edition.
static const double xyzrgb[3][3] = { { 3.240449, -1.537136, -0.498531 }, { -0.969265, 1.876011, 0.041556 }, { 0.055643, -0.204026, 1.057229 } };
// From the same reference as above, the inverse of the DecodeLMN function.
// This is essentially the gamma function of the sRGB profile.
static double srgb_gamma_function(double x)
{
// 0.04045 is what lcms2 uses, but the PS Reference Example 4.10 specifies 0.03928???
// if (x <= 0.04045 / 12.92321) {
if (x <= 0.03928 / 12.92321) {
return x * 12.92321;
}
return 1.055 * pow(x, 1.0 / 2.4) - 0.055;
}
// D65 is the white point of the sRGB profile as it is specified above in the xyzrgb array
static const double white_d65_X = 0.9505;
static const double white_d65_Y = 1.0;
static const double white_d65_Z = 1.0890;
#ifdef USE_CMS
// D50 is the default white point as used in ICC profiles and in the lcms2 library
static const double white_d50_X = 0.96422;
static const double white_d50_Y = 1.0;
static const double white_d50_Z = 0.82521;
static void inline bradford_transform_to_d50(double &X, double &Y, double &Z, const double source_whiteX, const double source_whiteY, const double source_whiteZ)
{
if (source_whiteX == white_d50_X && source_whiteY == white_d50_Y && source_whiteZ == white_d50_Z) {
// early exit if noop
return;
}
// at first apply Bradford matrix
double rho_in = 0.8951000 * X + 0.2664000 * Y - 0.1614000 * Z;
double gamma_in = -0.7502000 * X + 1.7135000 * Y + 0.0367000 * Z;
double beta_in = 0.0389000 * X - 0.0685000 * Y + 1.0296000 * Z;
// apply a diagonal matrix with the diagonal entries being the inverse bradford-transformed white point
rho_in /= 0.8951000 * source_whiteX + 0.2664000 * source_whiteY - 0.1614000 * source_whiteZ;
gamma_in /= -0.7502000 * source_whiteX + 1.7135000 * source_whiteY + 0.0367000 * source_whiteZ;
beta_in /= 0.0389000 * source_whiteX - 0.0685000 * source_whiteY + 1.0296000 * source_whiteZ;
// now revert the two steps above, but substituting the source white point by the device white point (D50)
// Since the white point is known a priori this has been combined into a single operation.
X = 0.98332566 * rho_in - 0.15005819 * gamma_in + 0.13095252 * beta_in;
Y = 0.43069901 * rho_in + 0.52894900 * gamma_in + 0.04035199 * beta_in;
Z = 0.00849698 * rho_in + 0.04086079 * gamma_in + 0.79284618 * beta_in;
}
#endif
static void inline bradford_transform_to_d65(double &X, double &Y, double &Z, const double source_whiteX, const double source_whiteY, const double source_whiteZ)
{
if (source_whiteX == white_d65_X && source_whiteY == white_d65_Y && source_whiteZ == white_d65_Z) {
// early exit if noop
return;
}
// at first apply Bradford matrix
double rho_in = 0.8951000 * X + 0.2664000 * Y - 0.1614000 * Z;
double gamma_in = -0.7502000 * X + 1.7135000 * Y + 0.0367000 * Z;
double beta_in = 0.0389000 * X - 0.0685000 * Y + 1.0296000 * Z;
// apply a diagonal matrix with the diagonal entries being the inverse bradford-transformed white point
rho_in /= 0.8951000 * source_whiteX + 0.2664000 * source_whiteY - 0.1614000 * source_whiteZ;
gamma_in /= -0.7502000 * source_whiteX + 1.7135000 * source_whiteY + 0.0367000 * source_whiteZ;
beta_in /= 0.0389000 * source_whiteX - 0.0685000 * source_whiteY + 1.0296000 * source_whiteZ;
// now revert the two steps above, but substituting the source white point by the device white point (D65)
// Since the white point is known a priori this has been combined into a single operation.
X = 0.92918329 * rho_in - 0.15299782 * gamma_in + 0.17428453 * beta_in;
Y = 0.40698452 * rho_in + 0.53931108 * gamma_in + 0.05370440 * beta_in;
Z = -0.00802913 * rho_in + 0.04166125 * gamma_in + 1.05519788 * beta_in;
}
GfxColorSpace *GfxCalGrayColorSpace::parse(Array *arr, GfxState *state)
{
GfxCalGrayColorSpace *cs;
Object obj1, obj2;
obj1 = arr->get(1);
if (!obj1.isDict()) {
error(errSyntaxWarning, -1, "Bad CalGray color space");
return nullptr;
}
cs = new GfxCalGrayColorSpace();
obj2 = obj1.dictLookup("WhitePoint");
if (obj2.isArray() && obj2.arrayGetLength() == 3) {
cs->whiteX = obj2.arrayGet(0).getNumWithDefaultValue(1);
cs->whiteY = obj2.arrayGet(1).getNumWithDefaultValue(1);
cs->whiteZ = obj2.arrayGet(2).getNumWithDefaultValue(1);
}
obj2 = obj1.dictLookup("BlackPoint");
if (obj2.isArray() && obj2.arrayGetLength() == 3) {
cs->blackX = obj2.arrayGet(0).getNumWithDefaultValue(0);
cs->blackY = obj2.arrayGet(1).getNumWithDefaultValue(0);
cs->blackZ = obj2.arrayGet(2).getNumWithDefaultValue(0);
}
cs->gamma = obj1.dictLookup("Gamma").getNumWithDefaultValue(1);
#ifdef USE_CMS
cs->transform = (state != nullptr) ? state->getXYZ2DisplayTransform() : nullptr;
#endif
return cs;
}
// convert CalGray to media XYZ color space
// (not multiply by the white point)
void GfxCalGrayColorSpace::getXYZ(const GfxColor *color, double *pX, double *pY, double *pZ) const
{
const double A = colToDbl(color->c[0]);
const double xyzColor = pow(A, gamma);
*pX = xyzColor;
*pY = xyzColor;
*pZ = xyzColor;
}
void GfxCalGrayColorSpace::getGray(const GfxColor *color, GfxGray *gray) const
{
GfxRGB rgb;
#ifdef USE_CMS
if (transform && transform->getTransformPixelType() == PT_GRAY) {
unsigned char out[gfxColorMaxComps];
double in[gfxColorMaxComps];
double X, Y, Z;
getXYZ(color, &X, &Y, &Z);
bradford_transform_to_d50(X, Y, Z, whiteX, whiteY, whiteZ);
in[0] = X;
in[1] = Y;
in[2] = Z;
transform->doTransform(in, out, 1);
*gray = byteToCol(out[0]);
return;
}
#endif
getRGB(color, &rgb);
*gray = clip01((GfxColorComp)(0.299 * rgb.r + 0.587 * rgb.g + 0.114 * rgb.b + 0.5));
}
void GfxCalGrayColorSpace::getRGB(const GfxColor *color, GfxRGB *rgb) const
{
double X, Y, Z;
double r, g, b;
getXYZ(color, &X, &Y, &Z);
#ifdef USE_CMS
if (transform && transform->getTransformPixelType() == PT_RGB) {
unsigned char out[gfxColorMaxComps];
double in[gfxColorMaxComps];
bradford_transform_to_d50(X, Y, Z, whiteX, whiteY, whiteZ);
in[0] = X;
in[1] = Y;
in[2] = Z;
transform->doTransform(in, out, 1);
rgb->r = byteToCol(out[0]);
rgb->g = byteToCol(out[1]);
rgb->b = byteToCol(out[2]);
return;
}
#endif
bradford_transform_to_d65(X, Y, Z, whiteX, whiteY, whiteZ);
// convert XYZ to RGB, including gamut mapping and gamma correction
r = xyzrgb[0][0] * X + xyzrgb[0][1] * Y + xyzrgb[0][2] * Z;
g = xyzrgb[1][0] * X + xyzrgb[1][1] * Y + xyzrgb[1][2] * Z;
b = xyzrgb[2][0] * X + xyzrgb[2][1] * Y + xyzrgb[2][2] * Z;
rgb->r = dblToCol(srgb_gamma_function(clip01(r)));
rgb->g = dblToCol(srgb_gamma_function(clip01(g)));
rgb->b = dblToCol(srgb_gamma_function(clip01(b)));
}
void GfxCalGrayColorSpace::getCMYK(const GfxColor *color, GfxCMYK *cmyk) const
{
GfxRGB rgb;
GfxColorComp c, m, y, k;
#ifdef USE_CMS
if (transform && transform->getTransformPixelType() == PT_CMYK) {
double in[gfxColorMaxComps];
unsigned char out[gfxColorMaxComps];
double X, Y, Z;
getXYZ(color, &X, &Y, &Z);
bradford_transform_to_d50(X, Y, Z, whiteX, whiteY, whiteZ);
in[0] = X;
in[1] = Y;
in[2] = Z;
transform->doTransform(in, out, 1);
cmyk->c = byteToCol(out[0]);
cmyk->m = byteToCol(out[1]);
cmyk->y = byteToCol(out[2]);
cmyk->k = byteToCol(out[3]);
return;
}
#endif
getRGB(color, &rgb);
c = clip01(gfxColorComp1 - rgb.r);
m = clip01(gfxColorComp1 - rgb.g);
y = clip01(gfxColorComp1 - rgb.b);
k = c;
if (m < k) {
k = m;
}
if (y < k) {
k = y;
}
cmyk->c = c - k;
cmyk->m = m - k;
cmyk->y = y - k;
cmyk->k = k;
}
void GfxCalGrayColorSpace::getDeviceN(const GfxColor *color, GfxColor *deviceN) const
{
GfxCMYK cmyk;
clearGfxColor(deviceN);
getCMYK(color, &cmyk);
deviceN->c[0] = cmyk.c;
deviceN->c[1] = cmyk.m;
deviceN->c[2] = cmyk.y;
deviceN->c[3] = cmyk.k;
}
void GfxCalGrayColorSpace::getDefaultColor(GfxColor *color) const
{
color->c[0] = 0;
}
//------------------------------------------------------------------------
// GfxDeviceRGBColorSpace
//------------------------------------------------------------------------
GfxDeviceRGBColorSpace::GfxDeviceRGBColorSpace() { }
GfxDeviceRGBColorSpace::~GfxDeviceRGBColorSpace() { }
GfxColorSpace *GfxDeviceRGBColorSpace::copy() const
{
return new GfxDeviceRGBColorSpace();
}
void GfxDeviceRGBColorSpace::getGray(const GfxColor *color, GfxGray *gray) const
{
*gray = clip01((GfxColorComp)(0.3 * color->c[0] + 0.59 * color->c[1] + 0.11 * color->c[2] + 0.5));
}
void GfxDeviceRGBColorSpace::getGrayLine(unsigned char *in, unsigned char *out, int length)
{
int i;
for (i = 0; i < length; i++) {
out[i] = (in[i * 3 + 0] * 19595 + in[i * 3 + 1] * 38469 + in[i * 3 + 2] * 7472) / 65536;
}
}
void GfxDeviceRGBColorSpace::getRGB(const GfxColor *color, GfxRGB *rgb) const
{
rgb->r = clip01(color->c[0]);
rgb->g = clip01(color->c[1]);
rgb->b = clip01(color->c[2]);
}
void GfxDeviceRGBColorSpace::getRGBLine(unsigned char *in, unsigned int *out, int length)
{
unsigned char *p;
int i;
for (i = 0, p = in; i < length; i++, p += 3) {
out[i] = (p[0] << 16) | (p[1] << 8) | (p[2] << 0);
}
}
void GfxDeviceRGBColorSpace::getRGBLine(unsigned char *in, unsigned char *out, int length)
{
for (int i = 0; i < length; i++) {
*out++ = *in++;
*out++ = *in++;
*out++ = *in++;
}
}
void GfxDeviceRGBColorSpace::getRGBXLine(unsigned char *in, unsigned char *out, int length)
{
for (int i = 0; i < length; i++) {
*out++ = *in++;
*out++ = *in++;
*out++ = *in++;
*out++ = 255;
}
}
void GfxDeviceRGBColorSpace::getCMYKLine(unsigned char *in, unsigned char *out, int length)
{
GfxColorComp c, m, y, k;
for (int i = 0; i < length; i++) {
c = byteToCol(255 - *in++);
m = byteToCol(255 - *in++);
y = byteToCol(255 - *in++);
k = c;
if (m < k) {
k = m;
}
if (y < k) {
k = y;
}
*out++ = colToByte(c - k);
*out++ = colToByte(m - k);
*out++ = colToByte(y - k);
*out++ = colToByte(k);
}
}
void GfxDeviceRGBColorSpace::getDeviceNLine(unsigned char *in, unsigned char *out, int length)
{
GfxColorComp c, m, y, k;
for (int i = 0; i < length; i++) {
for (int j = 0; j < SPOT_NCOMPS + 4; j++) {
out[j] = 0;
}
c = byteToCol(255 - *in++);
m = byteToCol(255 - *in++);
y = byteToCol(255 - *in++);
k = c;
if (m < k) {
k = m;
}
if (y < k) {
k = y;
}
out[0] = colToByte(c - k);
out[1] = colToByte(m - k);
out[2] = colToByte(y - k);
out[3] = colToByte(k);
out += (SPOT_NCOMPS + 4);
}
}
void GfxDeviceRGBColorSpace::getCMYK(const GfxColor *color, GfxCMYK *cmyk) const
{
GfxColorComp c, m, y, k;
c = clip01(gfxColorComp1 - color->c[0]);
m = clip01(gfxColorComp1 - color->c[1]);
y = clip01(gfxColorComp1 - color->c[2]);
k = c;
if (m < k) {
k = m;
}
if (y < k) {
k = y;
}
cmyk->c = c - k;
cmyk->m = m - k;
cmyk->y = y - k;
cmyk->k = k;
}
void GfxDeviceRGBColorSpace::getDeviceN(const GfxColor *color, GfxColor *deviceN) const
{
GfxCMYK cmyk;
clearGfxColor(deviceN);
getCMYK(color, &cmyk);
deviceN->c[0] = cmyk.c;
deviceN->c[1] = cmyk.m;
deviceN->c[2] = cmyk.y;
deviceN->c[3] = cmyk.k;
}
void GfxDeviceRGBColorSpace::getDefaultColor(GfxColor *color) const
{
color->c[0] = 0;
color->c[1] = 0;
color->c[2] = 0;
}
//------------------------------------------------------------------------
// GfxCalRGBColorSpace
//------------------------------------------------------------------------
GfxCalRGBColorSpace::GfxCalRGBColorSpace()
{
whiteX = whiteY = whiteZ = 1;
blackX = blackY = blackZ = 0;
gammaR = gammaG = gammaB = 1;
mat[0] = 1;
mat[1] = 0;
mat[2] = 0;
mat[3] = 0;
mat[4] = 1;
mat[5] = 0;
mat[6] = 0;
mat[7] = 0;
mat[8] = 1;
}
GfxCalRGBColorSpace::~GfxCalRGBColorSpace() { }
GfxColorSpace *GfxCalRGBColorSpace::copy() const
{
GfxCalRGBColorSpace *cs;
int i;
cs = new GfxCalRGBColorSpace();
cs->whiteX = whiteX;
cs->whiteY = whiteY;
cs->whiteZ = whiteZ;
cs->blackX = blackX;
cs->blackY = blackY;
cs->blackZ = blackZ;
cs->gammaR = gammaR;
cs->gammaG = gammaG;
cs->gammaB = gammaB;
for (i = 0; i < 9; ++i) {
cs->mat[i] = mat[i];
}
#ifdef USE_CMS
cs->transform = transform;
#endif
return cs;
}
GfxColorSpace *GfxCalRGBColorSpace::parse(Array *arr, GfxState *state)
{
GfxCalRGBColorSpace *cs;
Object obj1, obj2;
int i;
obj1 = arr->get(1);
if (!obj1.isDict()) {
error(errSyntaxWarning, -1, "Bad CalRGB color space");
return nullptr;
}
cs = new GfxCalRGBColorSpace();
obj2 = obj1.dictLookup("WhitePoint");
if (obj2.isArray() && obj2.arrayGetLength() == 3) {
cs->whiteX = obj2.arrayGet(0).getNumWithDefaultValue(1);
cs->whiteY = obj2.arrayGet(1).getNumWithDefaultValue(1);
cs->whiteZ = obj2.arrayGet(2).getNumWithDefaultValue(1);
}
obj2 = obj1.dictLookup("BlackPoint");
if (obj2.isArray() && obj2.arrayGetLength() == 3) {
cs->blackX = obj2.arrayGet(0).getNumWithDefaultValue(0);
cs->blackY = obj2.arrayGet(1).getNumWithDefaultValue(0);
cs->blackZ = obj2.arrayGet(2).getNumWithDefaultValue(0);
}
obj2 = obj1.dictLookup("Gamma");
if (obj2.isArray() && obj2.arrayGetLength() == 3) {
cs->gammaR = obj2.arrayGet(0).getNumWithDefaultValue(1);
cs->gammaG = obj2.arrayGet(1).getNumWithDefaultValue(1);
cs->gammaB = obj2.arrayGet(2).getNumWithDefaultValue(1);
}
obj2 = obj1.dictLookup("Matrix");
if (obj2.isArray() && obj2.arrayGetLength() == 9) {
for (i = 0; i < 9; ++i) {
Object obj3 = obj2.arrayGet(i);
if (likely(obj3.isNum())) {
cs->mat[i] = obj3.getNum();
}
}
}
#ifdef USE_CMS
cs->transform = (state != nullptr) ? state->getXYZ2DisplayTransform() : nullptr;
#endif
return cs;
}
// convert CalRGB to XYZ color space
void GfxCalRGBColorSpace::getXYZ(const GfxColor *color, double *pX, double *pY, double *pZ) const
{
double A, B, C;
A = pow(colToDbl(color->c[0]), gammaR);
B = pow(colToDbl(color->c[1]), gammaG);
C = pow(colToDbl(color->c[2]), gammaB);
*pX = mat[0] * A + mat[3] * B + mat[6] * C;
*pY = mat[1] * A + mat[4] * B + mat[7] * C;
*pZ = mat[2] * A + mat[5] * B + mat[8] * C;
}
void GfxCalRGBColorSpace::getGray(const GfxColor *color, GfxGray *gray) const
{
GfxRGB rgb;
#ifdef USE_CMS
if (transform != nullptr && transform->getTransformPixelType() == PT_GRAY) {
unsigned char out[gfxColorMaxComps];
double in[gfxColorMaxComps];
double X, Y, Z;
getXYZ(color, &X, &Y, &Z);
bradford_transform_to_d50(X, Y, Z, whiteX, whiteY, whiteZ);
in[0] = X;
in[1] = Y;
in[2] = Z;
transform->doTransform(in, out, 1);
*gray = byteToCol(out[0]);
return;
}
#endif
getRGB(color, &rgb);
*gray = clip01((GfxColorComp)(0.299 * rgb.r + 0.587 * rgb.g + 0.114 * rgb.b + 0.5));
}
void GfxCalRGBColorSpace::getRGB(const GfxColor *color, GfxRGB *rgb) const
{
double X, Y, Z;
double r, g, b;
getXYZ(color, &X, &Y, &Z);
#ifdef USE_CMS
if (transform != nullptr && transform->getTransformPixelType() == PT_RGB) {
unsigned char out[gfxColorMaxComps];
double in[gfxColorMaxComps];
bradford_transform_to_d50(X, Y, Z, whiteX, whiteY, whiteZ);
in[0] = X;
in[1] = Y;
in[2] = Z;
transform->doTransform(in, out, 1);
rgb->r = byteToCol(out[0]);
rgb->g = byteToCol(out[1]);
rgb->b = byteToCol(out[2]);
return;
}
#endif
bradford_transform_to_d65(X, Y, Z, whiteX, whiteY, whiteZ);
// convert XYZ to RGB, including gamut mapping and gamma correction
r = xyzrgb[0][0] * X + xyzrgb[0][1] * Y + xyzrgb[0][2] * Z;
g = xyzrgb[1][0] * X + xyzrgb[1][1] * Y + xyzrgb[1][2] * Z;
b = xyzrgb[2][0] * X + xyzrgb[2][1] * Y + xyzrgb[2][2] * Z;
rgb->r = dblToCol(srgb_gamma_function(clip01(r)));
rgb->g = dblToCol(srgb_gamma_function(clip01(g)));
rgb->b = dblToCol(srgb_gamma_function(clip01(b)));
}
void GfxCalRGBColorSpace::getCMYK(const GfxColor *color, GfxCMYK *cmyk) const
{
GfxRGB rgb;
GfxColorComp c, m, y, k;
#ifdef USE_CMS
if (transform != nullptr && transform->getTransformPixelType() == PT_CMYK) {
double in[gfxColorMaxComps];
unsigned char out[gfxColorMaxComps];
double X, Y, Z;
getXYZ(color, &X, &Y, &Z);
bradford_transform_to_d50(X, Y, Z, whiteX, whiteY, whiteZ);
in[0] = X;
in[1] = Y;
in[2] = Z;
transform->doTransform(in, out, 1);
cmyk->c = byteToCol(out[0]);
cmyk->m = byteToCol(out[1]);
cmyk->y = byteToCol(out[2]);
cmyk->k = byteToCol(out[3]);
return;
}
#endif
getRGB(color, &rgb);
c = clip01(gfxColorComp1 - rgb.r);
m = clip01(gfxColorComp1 - rgb.g);
y = clip01(gfxColorComp1 - rgb.b);
k = c;
if (m < k) {
k = m;
}
if (y < k) {
k = y;
}
cmyk->c = c - k;
cmyk->m = m - k;
cmyk->y = y - k;
cmyk->k = k;
}
void GfxCalRGBColorSpace::getDeviceN(const GfxColor *color, GfxColor *deviceN) const
{
GfxCMYK cmyk;
clearGfxColor(deviceN);
getCMYK(color, &cmyk);
deviceN->c[0] = cmyk.c;
deviceN->c[1] = cmyk.m;
deviceN->c[2] = cmyk.y;
deviceN->c[3] = cmyk.k;
}
void GfxCalRGBColorSpace::getDefaultColor(GfxColor *color) const
{
color->c[0] = 0;
color->c[1] = 0;
color->c[2] = 0;
}
//------------------------------------------------------------------------
// GfxDeviceCMYKColorSpace
//------------------------------------------------------------------------
GfxDeviceCMYKColorSpace::GfxDeviceCMYKColorSpace() { }
GfxDeviceCMYKColorSpace::~GfxDeviceCMYKColorSpace() { }
GfxColorSpace *GfxDeviceCMYKColorSpace::copy() const
{
return new GfxDeviceCMYKColorSpace();
}
void GfxDeviceCMYKColorSpace::getGray(const GfxColor *color, GfxGray *gray) const
{
*gray = clip01((GfxColorComp)(gfxColorComp1 - color->c[3] - 0.3 * color->c[0] - 0.59 * color->c[1] - 0.11 * color->c[2] + 0.5));
}
void GfxDeviceCMYKColorSpace::getRGB(const GfxColor *color, GfxRGB *rgb) const
{
double c, m, y, k, c1, m1, y1, k1, r, g, b;
c = colToDbl(color->c[0]);
m = colToDbl(color->c[1]);
y = colToDbl(color->c[2]);
k = colToDbl(color->c[3]);
c1 = 1 - c;
m1 = 1 - m;
y1 = 1 - y;
k1 = 1 - k;
cmykToRGBMatrixMultiplication(c, m, y, k, c1, m1, y1, k1, r, g, b);
rgb->r = clip01(dblToCol(r));
rgb->g = clip01(dblToCol(g));
rgb->b = clip01(dblToCol(b));
}
static inline void GfxDeviceCMYKColorSpacegetRGBLineHelper(unsigned char *&in, double &r, double &g, double &b)
{
double c, m, y, k, c1, m1, y1, k1;
c = byteToDbl(*in++);
m = byteToDbl(*in++);
y = byteToDbl(*in++);
k = byteToDbl(*in++);
c1 = 1 - c;
m1 = 1 - m;
y1 = 1 - y;
k1 = 1 - k;
cmykToRGBMatrixMultiplication(c, m, y, k, c1, m1, y1, k1, r, g, b);
}
void GfxDeviceCMYKColorSpace::getRGBLine(unsigned char *in, unsigned int *out, int length)
{
double r, g, b;
for (int i = 0; i < length; i++) {
GfxDeviceCMYKColorSpacegetRGBLineHelper(in, r, g, b);
*out++ = (dblToByte(clip01(r)) << 16) | (dblToByte(clip01(g)) << 8) | dblToByte(clip01(b));
}
}
void GfxDeviceCMYKColorSpace::getRGBLine(unsigned char *in, unsigned char *out, int length)
{
double r, g, b;
for (int i = 0; i < length; i++) {
GfxDeviceCMYKColorSpacegetRGBLineHelper(in, r, g, b);
*out++ = dblToByte(clip01(r));
*out++ = dblToByte(clip01(g));
*out++ = dblToByte(clip01(b));
}
}
void GfxDeviceCMYKColorSpace::getRGBXLine(unsigned char *in, unsigned char *out, int length)
{
double r, g, b;
for (int i = 0; i < length; i++) {
GfxDeviceCMYKColorSpacegetRGBLineHelper(in, r, g, b);
*out++ = dblToByte(clip01(r));
*out++ = dblToByte(clip01(g));
*out++ = dblToByte(clip01(b));
*out++ = 255;
}
}
void GfxDeviceCMYKColorSpace::getCMYKLine(unsigned char *in, unsigned char *out, int length)
{
for (int i = 0; i < length; i++) {
*out++ = *in++;
*out++ = *in++;
*out++ = *in++;
*out++ = *in++;
}
}
void GfxDeviceCMYKColorSpace::getDeviceNLine(unsigned char *in, unsigned char *out, int length)
{
for (int i = 0; i < length; i++) {
for (int j = 0; j < SPOT_NCOMPS + 4; j++) {
out[j] = 0;
}
out[0] = *in++;
out[1] = *in++;
out[2] = *in++;
out[3] = *in++;
out += (SPOT_NCOMPS + 4);
}
}
void GfxDeviceCMYKColorSpace::getCMYK(const GfxColor *color, GfxCMYK *cmyk) const
{
cmyk->c = clip01(color->c[0]);
cmyk->m = clip01(color->c[1]);
cmyk->y = clip01(color->c[2]);
cmyk->k = clip01(color->c[3]);
}
void GfxDeviceCMYKColorSpace::getDeviceN(const GfxColor *color, GfxColor *deviceN) const
{
clearGfxColor(deviceN);
deviceN->c[0] = clip01(color->c[0]);
deviceN->c[1] = clip01(color->c[1]);
deviceN->c[2] = clip01(color->c[2]);
deviceN->c[3] = clip01(color->c[3]);
}
void GfxDeviceCMYKColorSpace::getDefaultColor(GfxColor *color) const
{
color->c[0] = 0;
color->c[1] = 0;
color->c[2] = 0;
color->c[3] = gfxColorComp1;
}
//------------------------------------------------------------------------
// GfxLabColorSpace
//------------------------------------------------------------------------
GfxLabColorSpace::GfxLabColorSpace()
{
whiteX = whiteY = whiteZ = 1;
blackX = blackY = blackZ = 0;
aMin = bMin = -100;
aMax = bMax = 100;
}
GfxLabColorSpace::~GfxLabColorSpace() { }
GfxColorSpace *GfxLabColorSpace::copy() const
{
GfxLabColorSpace *cs;
cs = new GfxLabColorSpace();
cs->whiteX = whiteX;
cs->whiteY = whiteY;
cs->whiteZ = whiteZ;
cs->blackX = blackX;
cs->blackY = blackY;
cs->blackZ = blackZ;
cs->aMin = aMin;
cs->aMax = aMax;
cs->bMin = bMin;
cs->bMax = bMax;
#ifdef USE_CMS
cs->transform = transform;
#endif
return cs;
}
GfxColorSpace *GfxLabColorSpace::parse(Array *arr, GfxState *state)
{
GfxLabColorSpace *cs;
Object obj1, obj2;
obj1 = arr->get(1);
if (!obj1.isDict()) {
error(errSyntaxWarning, -1, "Bad Lab color space");
return nullptr;
}
cs = new GfxLabColorSpace();
bool ok = true;
obj2 = obj1.dictLookup("WhitePoint");
if (obj2.isArray() && obj2.arrayGetLength() == 3) {
cs->whiteX = obj2.arrayGet(0).getNum(&ok);
cs->whiteY = obj2.arrayGet(1).getNum(&ok);
cs->whiteZ = obj2.arrayGet(2).getNum(&ok);
}
obj2 = obj1.dictLookup("BlackPoint");
if (obj2.isArray() && obj2.arrayGetLength() == 3) {
cs->blackX = obj2.arrayGet(0).getNum(&ok);
cs->blackY = obj2.arrayGet(1).getNum(&ok);
cs->blackZ = obj2.arrayGet(2).getNum(&ok);
}
obj2 = obj1.dictLookup("Range");
if (obj2.isArray() && obj2.arrayGetLength() == 4) {
cs->aMin = obj2.arrayGet(0).getNum(&ok);
cs->aMax = obj2.arrayGet(1).getNum(&ok);
cs->bMin = obj2.arrayGet(2).getNum(&ok);
cs->bMax = obj2.arrayGet(3).getNum(&ok);
}
if (!ok) {
error(errSyntaxWarning, -1, "Bad Lab color space");
#ifdef USE_CMS
cs->transform = nullptr;
#endif
delete cs;
return nullptr;
}
#ifdef USE_CMS
cs->transform = (state != nullptr) ? state->getXYZ2DisplayTransform() : nullptr;
#endif
return cs;
}
void GfxLabColorSpace::getGray(const GfxColor *color, GfxGray *gray) const
{
GfxRGB rgb;
#ifdef USE_CMS
if (transform != nullptr && transform->getTransformPixelType() == PT_GRAY) {
unsigned char out[gfxColorMaxComps];
double in[gfxColorMaxComps];
getXYZ(color, &in[0], &in[1], &in[2]);
bradford_transform_to_d50(in[0], in[1], in[2], whiteX, whiteY, whiteZ);
transform->doTransform(in, out, 1);
*gray = byteToCol(out[0]);
return;
}
#endif
getRGB(color, &rgb);
*gray = clip01((GfxColorComp)(0.299 * rgb.r + 0.587 * rgb.g + 0.114 * rgb.b + 0.5));
}
// convert L*a*b* to media XYZ color space
// (not multiply by the white point)
void GfxLabColorSpace::getXYZ(const GfxColor *color, double *pX, double *pY, double *pZ) const
{
double X, Y, Z;
double t1, t2;
t1 = (colToDbl(color->c[0]) + 16) / 116;
t2 = t1 + colToDbl(color->c[1]) / 500;
if (t2 >= (6.0 / 29.0)) {
X = t2 * t2 * t2;
} else {
X = (108.0 / 841.0) * (t2 - (4.0 / 29.0));
}
if (t1 >= (6.0 / 29.0)) {
Y = t1 * t1 * t1;
} else {
Y = (108.0 / 841.0) * (t1 - (4.0 / 29.0));
}
t2 = t1 - colToDbl(color->c[2]) / 200;
if (t2 >= (6.0 / 29.0)) {
Z = t2 * t2 * t2;
} else {
Z = (108.0 / 841.0) * (t2 - (4.0 / 29.0));
}
*pX = X;
*pY = Y;
*pZ = Z;
}
void GfxLabColorSpace::getRGB(const GfxColor *color, GfxRGB *rgb) const
{
double X, Y, Z;
getXYZ(color, &X, &Y, &Z);
X *= whiteX;
Y *= whiteY;
Z *= whiteZ;
#ifdef USE_CMS
if (transform != nullptr && transform->getTransformPixelType() == PT_RGB) {
unsigned char out[gfxColorMaxComps];
double in[gfxColorMaxComps];
bradford_transform_to_d50(X, Y, Z, whiteX, whiteY, whiteZ);
in[0] = X;
in[1] = Y;
in[2] = Z;
transform->doTransform(in, out, 1);
rgb->r = byteToCol(out[0]);
rgb->g = byteToCol(out[1]);
rgb->b = byteToCol(out[2]);
return;
} else if (transform != nullptr && transform->getTransformPixelType() == PT_CMYK) {
unsigned char out[gfxColorMaxComps];
double in[gfxColorMaxComps];
double c, m, y, k, c1, m1, y1, k1, r, g, b;
bradford_transform_to_d50(X, Y, Z, whiteX, whiteY, whiteZ);
in[0] = X;
in[1] = Y;
in[2] = Z;
transform->doTransform(in, out, 1);
c = byteToDbl(out[0]);
m = byteToDbl(out[1]);
y = byteToDbl(out[2]);
k = byteToDbl(out[3]);
c1 = 1 - c;
m1 = 1 - m;
y1 = 1 - y;
k1 = 1 - k;
cmykToRGBMatrixMultiplication(c, m, y, k, c1, m1, y1, k1, r, g, b);
rgb->r = clip01(dblToCol(r));
rgb->g = clip01(dblToCol(g));
rgb->b = clip01(dblToCol(b));
return;
}
#endif
bradford_transform_to_d65(X, Y, Z, whiteX, whiteY, whiteZ);
// convert XYZ to RGB, including gamut mapping and gamma correction
const double r = xyzrgb[0][0] * X + xyzrgb[0][1] * Y + xyzrgb[0][2] * Z;
const double g = xyzrgb[1][0] * X + xyzrgb[1][1] * Y + xyzrgb[1][2] * Z;
const double b = xyzrgb[2][0] * X + xyzrgb[2][1] * Y + xyzrgb[2][2] * Z;
rgb->r = dblToCol(srgb_gamma_function(clip01(r)));
rgb->g = dblToCol(srgb_gamma_function(clip01(g)));
rgb->b = dblToCol(srgb_gamma_function(clip01(b)));
}
void GfxLabColorSpace::getCMYK(const GfxColor *color, GfxCMYK *cmyk) const
{
GfxRGB rgb;
GfxColorComp c, m, y, k;
#ifdef USE_CMS
if (transform != nullptr && transform->getTransformPixelType() == PT_CMYK) {
double in[gfxColorMaxComps];
unsigned char out[gfxColorMaxComps];
getXYZ(color, &in[0], &in[1], &in[2]);
bradford_transform_to_d50(in[0], in[1], in[2], whiteX, whiteY, whiteZ);
transform->doTransform(in, out, 1);
cmyk->c = byteToCol(out[0]);
cmyk->m = byteToCol(out[1]);
cmyk->y = byteToCol(out[2]);
cmyk->k = byteToCol(out[3]);
return;
}
#endif
getRGB(color, &rgb);
c = clip01(gfxColorComp1 - rgb.r);
m = clip01(gfxColorComp1 - rgb.g);
y = clip01(gfxColorComp1 - rgb.b);
k = c;
if (m < k) {
k = m;
}
if (y < k) {
k = y;
}
cmyk->c = c - k;
cmyk->m = m - k;
cmyk->y = y - k;
cmyk->k = k;
}
void GfxLabColorSpace::getDeviceN(const GfxColor *color, GfxColor *deviceN) const
{
GfxCMYK cmyk;
clearGfxColor(deviceN);
getCMYK(color, &cmyk);
deviceN->c[0] = cmyk.c;
deviceN->c[1] = cmyk.m;
deviceN->c[2] = cmyk.y;
deviceN->c[3] = cmyk.k;
}
void GfxLabColorSpace::getDefaultColor(GfxColor *color) const
{
color->c[0] = 0;
if (aMin > 0) {
color->c[1] = dblToCol(aMin);
} else if (aMax < 0) {
color->c[1] = dblToCol(aMax);
} else {
color->c[1] = 0;
}
if (bMin > 0) {
color->c[2] = dblToCol(bMin);
} else if (bMax < 0) {
color->c[2] = dblToCol(bMax);
} else {
color->c[2] = 0;
}
}
void GfxLabColorSpace::getDefaultRanges(double *decodeLow, double *decodeRange, int maxImgPixel) const
{
decodeLow[0] = 0;
decodeRange[0] = 100;
decodeLow[1] = aMin;
decodeRange[1] = aMax - aMin;
decodeLow[2] = bMin;
decodeRange[2] = bMax - bMin;
}
//------------------------------------------------------------------------
// GfxICCBasedColorSpace
//------------------------------------------------------------------------
GfxICCBasedColorSpace::GfxICCBasedColorSpace(int nCompsA, GfxColorSpace *altA, const Ref *iccProfileStreamA)
{
nComps = nCompsA;
alt = altA;
iccProfileStream = *iccProfileStreamA;
rangeMin[0] = rangeMin[1] = rangeMin[2] = rangeMin[3] = 0;
rangeMax[0] = rangeMax[1] = rangeMax[2] = rangeMax[3] = 1;
#ifdef USE_CMS
transform = nullptr;
lineTransform = nullptr;
psCSA = nullptr;
#endif
}
GfxICCBasedColorSpace::~GfxICCBasedColorSpace()
{
delete alt;
#ifdef USE_CMS
if (psCSA) {
gfree(psCSA);
}
#endif
}
GfxColorSpace *GfxICCBasedColorSpace::copy() const
{
GfxICCBasedColorSpace *cs;
int i;
cs = new GfxICCBasedColorSpace(nComps, alt->copy(), &iccProfileStream);
for (i = 0; i < 4; ++i) {
cs->rangeMin[i] = rangeMin[i];
cs->rangeMax[i] = rangeMax[i];
}
#ifdef USE_CMS
cs->profile = profile;
cs->transform = transform;
cs->lineTransform = lineTransform;
#endif
return cs;
}
GfxColorSpace *GfxICCBasedColorSpace::parse(Array *arr, OutputDev *out, GfxState *state, int recursion)
{
GfxICCBasedColorSpace *cs;
int nCompsA;
GfxColorSpace *altA;
Dict *dict;
Object obj1, obj2;
int i;
if (arr->getLength() < 2) {
error(errSyntaxError, -1, "Bad ICCBased color space");
return nullptr;
}
const Object &obj1Ref = arr->getNF(1);
const Ref iccProfileStreamA = obj1Ref.isRef() ? obj1Ref.getRef() : Ref::INVALID();
#ifdef USE_CMS
// check cache
if (out && iccProfileStreamA != Ref::INVALID()) {
if (auto *item = out->getIccColorSpaceCache()->lookup(iccProfileStreamA)) {
cs = static_cast<GfxICCBasedColorSpace *>(item->copy());
int transformIntent = cs->getIntent();
int cmsIntent = INTENT_RELATIVE_COLORIMETRIC;
if (state != nullptr) {
cmsIntent = state->getCmsRenderingIntent();
}
if (transformIntent == cmsIntent) {
return cs;
}
delete cs;
}
}
#endif
obj1 = arr->get(1);
if (!obj1.isStream()) {
error(errSyntaxWarning, -1, "Bad ICCBased color space (stream)");
return nullptr;
}
dict = obj1.streamGetDict();
obj2 = dict->lookup("N");
if (!obj2.isInt()) {
error(errSyntaxWarning, -1, "Bad ICCBased color space (N)");
return nullptr;
}
nCompsA = obj2.getInt();
if (nCompsA > 4) {
error(errSyntaxError, -1, "ICCBased color space with too many ({0:d} > 4) components", nCompsA);
nCompsA = 4;
}
obj2 = dict->lookup("Alternate");
if (obj2.isNull() || !(altA = GfxColorSpace::parse(nullptr, &obj2, out, state, recursion + 1))) {
switch (nCompsA) {
case 1:
altA = new GfxDeviceGrayColorSpace();
break;
case 3:
altA = new GfxDeviceRGBColorSpace();
break;
case 4:
altA = new GfxDeviceCMYKColorSpace();
break;
default:
error(errSyntaxWarning, -1, "Bad ICCBased color space - invalid N");
return nullptr;
}
}
if (altA->getNComps() != nCompsA) {
error(errSyntaxWarning, -1, "Bad ICCBased color space - N doesn't match alt color space");
delete altA;
return nullptr;
}
cs = new GfxICCBasedColorSpace(nCompsA, altA, &iccProfileStreamA);
obj2 = dict->lookup("Range");
if (obj2.isArray() && obj2.arrayGetLength() == 2 * nCompsA) {
for (i = 0; i < nCompsA; ++i) {
cs->rangeMin[i] = obj2.arrayGet(2 * i).getNumWithDefaultValue(0);
cs->rangeMax[i] = obj2.arrayGet(2 * i + 1).getNumWithDefaultValue(1);
}
}
#ifdef USE_CMS
obj1 = arr->get(1);
if (!obj1.isStream()) {
error(errSyntaxWarning, -1, "Bad ICCBased color space (stream)");
delete cs;
return nullptr;
}
Stream *iccStream = obj1.getStream();
const std::vector<unsigned char> profBuf = iccStream->toUnsignedChars(65536, 65536);
auto hp = make_GfxLCMSProfilePtr(cmsOpenProfileFromMem(profBuf.data(), profBuf.size()));
cs->profile = hp;
if (!hp) {
error(errSyntaxWarning, -1, "read ICCBased color space profile error");
} else {
cs->buildTransforms(state);
}
// put this colorSpace into cache
if (out && iccProfileStreamA != Ref::INVALID()) {
out->getIccColorSpaceCache()->put(iccProfileStreamA, static_cast<GfxICCBasedColorSpace *>(cs->copy()));
}
#endif
return cs;
}
#ifdef USE_CMS
void GfxICCBasedColorSpace::buildTransforms(GfxState *state)
{
auto dhp = (state != nullptr && state->getDisplayProfile() != nullptr) ? state->getDisplayProfile() : nullptr;
if (!dhp) {
dhp = GfxState::sRGBProfile;
}
unsigned int cst = getCMSColorSpaceType(cmsGetColorSpace(profile.get()));
unsigned int dNChannels = getCMSNChannels(cmsGetColorSpace(dhp.get()));
unsigned int dcst = getCMSColorSpaceType(cmsGetColorSpace(dhp.get()));
cmsHTRANSFORM transformA;
int cmsIntent = INTENT_RELATIVE_COLORIMETRIC;
if (state != nullptr) {
cmsIntent = state->getCmsRenderingIntent();
}
if ((transformA = cmsCreateTransform(profile.get(), COLORSPACE_SH(cst) | CHANNELS_SH(nComps) | BYTES_SH(1), dhp.get(), COLORSPACE_SH(dcst) | CHANNELS_SH(dNChannels) | BYTES_SH(1), cmsIntent, LCMS_FLAGS)) == nullptr) {
error(errSyntaxWarning, -1, "Can't create transform");
transform = nullptr;
} else {
transform = std::make_shared<GfxColorTransform>(transformA, cmsIntent, cst, dcst);
}
if (dcst == PT_RGB || dcst == PT_CMYK) {
// create line transform only when the display is RGB type color space
if ((transformA = cmsCreateTransform(profile.get(), CHANNELS_SH(nComps) | BYTES_SH(1), dhp.get(), (dcst == PT_RGB) ? TYPE_RGB_8 : TYPE_CMYK_8, cmsIntent, LCMS_FLAGS)) == nullptr) {
error(errSyntaxWarning, -1, "Can't create transform");
lineTransform = nullptr;
} else {
lineTransform = std::make_shared<GfxColorTransform>(transformA, cmsIntent, cst, dcst);
}
}
}
#endif
void GfxICCBasedColorSpace::getGray(const GfxColor *color, GfxGray *gray) const
{
#ifdef USE_CMS
if (transform != nullptr && transform->getTransformPixelType() == PT_GRAY) {
unsigned char in[gfxColorMaxComps];
unsigned char out[gfxColorMaxComps];
if (nComps == 3 && transform->getInputPixelType() == PT_Lab) {
in[0] = colToByte(dblToCol(colToDbl(color->c[0]) / 100.0));
in[1] = colToByte(dblToCol((colToDbl(color->c[1]) + 128.0) / 255.0));
in[2] = colToByte(dblToCol((colToDbl(color->c[2]) + 128.0) / 255.0));
} else {
for (int i = 0; i < nComps; i++) {
in[i] = colToByte(color->c[i]);
}
}
if (nComps <= 4) {
unsigned int key = 0;
for (int j = 0; j < nComps; j++) {
key = (key << 8) + in[j];
}
std::map<unsigned int, unsigned int>::iterator it = cmsCache.find(key);
if (it != cmsCache.end()) {
unsigned int value = it->second;
*gray = byteToCol(value & 0xff);
return;
}
}
transform->doTransform(in, out, 1);
*gray = byteToCol(out[0]);
if (nComps <= 4 && cmsCache.size() <= CMSCACHE_LIMIT) {
unsigned int key = 0;
for (int j = 0; j < nComps; j++) {
key = (key << 8) + in[j];
}
unsigned int value = out[0];
cmsCache.insert(std::pair<unsigned int, unsigned int>(key, value));
}
} else {
GfxRGB rgb;
getRGB(color, &rgb);
*gray = clip01((GfxColorComp)(0.3 * rgb.r + 0.59 * rgb.g + 0.11 * rgb.b + 0.5));
}
#else
alt->getGray(color, gray);
#endif
}
void GfxICCBasedColorSpace::getRGB(const GfxColor *color, GfxRGB *rgb) const
{
#ifdef USE_CMS
if (transform != nullptr && transform->getTransformPixelType() == PT_RGB) {
unsigned char in[gfxColorMaxComps];
unsigned char out[gfxColorMaxComps];
if (nComps == 3 && transform->getInputPixelType() == PT_Lab) {
in[0] = colToByte(dblToCol(colToDbl(color->c[0]) / 100.0));
in[1] = colToByte(dblToCol((colToDbl(color->c[1]) + 128.0) / 255.0));
in[2] = colToByte(dblToCol((colToDbl(color->c[2]) + 128.0) / 255.0));
} else {
for (int i = 0; i < nComps; i++) {
in[i] = colToByte(color->c[i]);
}
}
if (nComps <= 4) {
unsigned int key = 0;
for (int j = 0; j < nComps; j++) {
key = (key << 8) + in[j];
}
std::map<unsigned int, unsigned int>::iterator it = cmsCache.find(key);
if (it != cmsCache.end()) {
unsigned int value = it->second;
rgb->r = byteToCol(value >> 16);
rgb->g = byteToCol((value >> 8) & 0xff);
rgb->b = byteToCol(value & 0xff);
return;
}
}
transform->doTransform(in, out, 1);
rgb->r = byteToCol(out[0]);
rgb->g = byteToCol(out[1]);
rgb->b = byteToCol(out[2]);
if (nComps <= 4 && cmsCache.size() <= CMSCACHE_LIMIT) {
unsigned int key = 0;
for (int j = 0; j < nComps; j++) {
key = (key << 8) + in[j];
}
unsigned int value = (out[0] << 16) + (out[1] << 8) + out[2];
cmsCache.insert(std::pair<unsigned int, unsigned int>(key, value));
}
} else if (transform != nullptr && transform->getTransformPixelType() == PT_CMYK) {
unsigned char in[gfxColorMaxComps];
unsigned char out[gfxColorMaxComps];
double c, m, y, k, c1, m1, y1, k1, r, g, b;
if (nComps == 3 && transform->getInputPixelType() == PT_Lab) {
in[0] = colToByte(dblToCol(colToDbl(color->c[0]) / 100.0));
in[1] = colToByte(dblToCol((colToDbl(color->c[1]) + 128.0) / 255.0));
in[2] = colToByte(dblToCol((colToDbl(color->c[2]) + 128.0) / 255.0));
} else {
for (int i = 0; i < nComps; i++) {
in[i] = colToByte(color->c[i]);
}
}
if (nComps <= 4) {
unsigned int key = 0;
for (int j = 0; j < nComps; j++) {
key = (key << 8) + in[j];
}
std::map<unsigned int, unsigned int>::iterator it = cmsCache.find(key);
if (it != cmsCache.end()) {
unsigned int value = it->second;
rgb->r = byteToCol(value >> 16);
rgb->g = byteToCol((value >> 8) & 0xff);
rgb->b = byteToCol(value & 0xff);
return;
}
}
transform->doTransform(in, out, 1);
c = byteToDbl(out[0]);
m = byteToDbl(out[1]);
y = byteToDbl(out[2]);
k = byteToDbl(out[3]);
c1 = 1 - c;
m1 = 1 - m;
y1 = 1 - y;
k1 = 1 - k;
cmykToRGBMatrixMultiplication(c, m, y, k, c1, m1, y1, k1, r, g, b);
rgb->r = clip01(dblToCol(r));
rgb->g = clip01(dblToCol(g));
rgb->b = clip01(dblToCol(b));
if (nComps <= 4 && cmsCache.size() <= CMSCACHE_LIMIT) {
unsigned int key = 0;
for (int j = 0; j < nComps; j++) {
key = (key << 8) + in[j];
}
unsigned int value = (dblToByte(r) << 16) + (dblToByte(g) << 8) + dblToByte(b);
cmsCache.insert(std::pair<unsigned int, unsigned int>(key, value));
}
} else {
alt->getRGB(color, rgb);
}
#else
alt->getRGB(color, rgb);
#endif
}
void GfxICCBasedColorSpace::getRGBLine(unsigned char *in, unsigned int *out, int length)
{
#ifdef USE_CMS
if (lineTransform != nullptr && lineTransform->getTransformPixelType() == PT_RGB) {
unsigned char *tmp = (unsigned char *)gmallocn(3 * length, sizeof(unsigned char));
lineTransform->doTransform(in, tmp, length);
for (int i = 0; i < length; ++i) {
unsigned char *current = tmp + (i * 3);
out[i] = (current[0] << 16) | (current[1] << 8) | current[2];
}
gfree(tmp);
} else {
alt->getRGBLine(in, out, length);
}
#else
alt->getRGBLine(in, out, length);
#endif
}
void GfxICCBasedColorSpace::getRGBLine(unsigned char *in, unsigned char *out, int length)
{
#ifdef USE_CMS
if (lineTransform != nullptr && lineTransform->getTransformPixelType() == PT_RGB) {
unsigned char *tmp = (unsigned char *)gmallocn(3 * length, sizeof(unsigned char));
lineTransform->doTransform(in, tmp, length);
unsigned char *current = tmp;
for (int i = 0; i < length; ++i) {
*out++ = *current++;
*out++ = *current++;
*out++ = *current++;
}
gfree(tmp);
} else if (lineTransform != nullptr && lineTransform->getTransformPixelType() == PT_CMYK) {
unsigned char *tmp = (unsigned char *)gmallocn(4 * length, sizeof(unsigned char));
lineTransform->doTransform(in, tmp, length);
unsigned char *current = tmp;
double c, m, y, k, c1, m1, y1, k1, r, g, b;
for (int i = 0; i < length; ++i) {
c = byteToDbl(*current++);
m = byteToDbl(*current++);
y = byteToDbl(*current++);
k = byteToDbl(*current++);
c1 = 1 - c;
m1 = 1 - m;
y1 = 1 - y;
k1 = 1 - k;
cmykToRGBMatrixMultiplication(c, m, y, k, c1, m1, y1, k1, r, g, b);
*out++ = dblToByte(r);
*out++ = dblToByte(g);
*out++ = dblToByte(b);
}
gfree(tmp);
} else {
alt->getRGBLine(in, out, length);
}
#else
alt->getRGBLine(in, out, length);
#endif
}
void GfxICCBasedColorSpace::getRGBXLine(unsigned char *in, unsigned char *out, int length)
{
#ifdef USE_CMS
if (lineTransform != nullptr && lineTransform->getTransformPixelType() == PT_RGB) {
unsigned char *tmp = (unsigned char *)gmallocn(3 * length, sizeof(unsigned char));
lineTransform->doTransform(in, tmp, length);
unsigned char *current = tmp;
for (int i = 0; i < length; ++i) {
*out++ = *current++;
*out++ = *current++;
*out++ = *current++;
*out++ = 255;
}
gfree(tmp);
} else {
alt->getRGBXLine(in, out, length);
}
#else
alt->getRGBXLine(in, out, length);
#endif
}
void GfxICCBasedColorSpace::getCMYKLine(unsigned char *in, unsigned char *out, int length)
{
#ifdef USE_CMS
if (lineTransform != nullptr && lineTransform->getTransformPixelType() == PT_CMYK) {
transform->doTransform(in, out, length);
} else if (lineTransform != nullptr && nComps != 4) {
GfxColorComp c, m, y, k;
unsigned char *tmp = (unsigned char *)gmallocn(3 * length, sizeof(unsigned char));
getRGBLine(in, tmp, length);
unsigned char *p = tmp;
for (int i = 0; i < length; i++) {
c = byteToCol(255 - *p++);
m = byteToCol(255 - *p++);
y = byteToCol(255 - *p++);
k = c;
if (m < k) {
k = m;
}
if (y < k) {
k = y;
}
*out++ = colToByte(c - k);
*out++ = colToByte(m - k);
*out++ = colToByte(y - k);
*out++ = colToByte(k);
}
gfree(tmp);
} else {
alt->getCMYKLine(in, out, length);
}
#else
alt->getCMYKLine(in, out, length);
#endif
}
void GfxICCBasedColorSpace::getDeviceNLine(unsigned char *in, unsigned char *out, int length)
{
#ifdef USE_CMS
if (lineTransform != nullptr && lineTransform->getTransformPixelType() == PT_CMYK) {
unsigned char *tmp = (unsigned char *)gmallocn(4 * length, sizeof(unsigned char));
transform->doTransform(in, tmp, length);
unsigned char *p = tmp;
for (int i = 0; i < length; i++) {
for (int j = 0; j < 4; j++) {
*out++ = *p++;
}
for (int j = 4; j < SPOT_NCOMPS + 4; j++) {
*out++ = 0;
}
}
gfree(tmp);
} else if (lineTransform != nullptr && nComps != 4) {
GfxColorComp c, m, y, k;
unsigned char *tmp = (unsigned char *)gmallocn(3 * length, sizeof(unsigned char));
getRGBLine(in, tmp, length);
unsigned char *p = tmp;
for (int i = 0; i < length; i++) {
for (int j = 0; j < SPOT_NCOMPS + 4; j++) {
out[j] = 0;
}
c = byteToCol(255 - *p++);
m = byteToCol(255 - *p++);
y = byteToCol(255 - *p++);
k = c;
if (m < k) {
k = m;
}
if (y < k) {
k = y;
}
out[0] = colToByte(c - k);
out[1] = colToByte(m - k);
out[2] = colToByte(y - k);
out[3] = colToByte(k);
out += (SPOT_NCOMPS + 4);
}
gfree(tmp);
} else {
alt->getDeviceNLine(in, out, length);
}
#else
alt->getDeviceNLine(in, out, length);
#endif
}
void GfxICCBasedColorSpace::getCMYK(const GfxColor *color, GfxCMYK *cmyk) const
{
#ifdef USE_CMS
if (transform != nullptr && transform->getTransformPixelType() == PT_CMYK) {
unsigned char in[gfxColorMaxComps];
unsigned char out[gfxColorMaxComps];
if (nComps == 3 && transform->getInputPixelType() == PT_Lab) {
in[0] = colToByte(dblToCol(colToDbl(color->c[0]) / 100.0));
in[1] = colToByte(dblToCol((colToDbl(color->c[1]) + 128.0) / 255.0));
in[2] = colToByte(dblToCol((colToDbl(color->c[2]) + 128.0) / 255.0));
} else {
for (int i = 0; i < nComps; i++) {
in[i] = colToByte(color->c[i]);
}
}
if (nComps <= 4) {
unsigned int key = 0;
for (int j = 0; j < nComps; j++) {
key = (key << 8) + in[j];
}
std::map<unsigned int, unsigned int>::iterator it = cmsCache.find(key);
if (it != cmsCache.end()) {
unsigned int value = it->second;
cmyk->c = byteToCol(value >> 24);
cmyk->m = byteToCol((value >> 16) & 0xff);
cmyk->y = byteToCol((value >> 8) & 0xff);
cmyk->k = byteToCol(value & 0xff);
return;
}
}
transform->doTransform(in, out, 1);
cmyk->c = byteToCol(out[0]);
cmyk->m = byteToCol(out[1]);
cmyk->y = byteToCol(out[2]);
cmyk->k = byteToCol(out[3]);
if (nComps <= 4 && cmsCache.size() <= CMSCACHE_LIMIT) {
unsigned int key = 0;
for (int j = 0; j < nComps; j++) {
key = (key << 8) + in[j];
}
unsigned int value = (out[0] << 24) + (out[1] << 16) + (out[2] << 8) + out[3];
cmsCache.insert(std::pair<unsigned int, unsigned int>(key, value));
}
} else if (nComps != 4 && transform != nullptr && transform->getTransformPixelType() == PT_RGB) {
GfxRGB rgb;
GfxColorComp c, m, y, k;
getRGB(color, &rgb);
c = clip01(gfxColorComp1 - rgb.r);
m = clip01(gfxColorComp1 - rgb.g);
y = clip01(gfxColorComp1 - rgb.b);
k = c;
if (m < k) {
k = m;
}
if (y < k) {
k = y;
}
cmyk->c = c - k;
cmyk->m = m - k;
cmyk->y = y - k;
cmyk->k = k;
} else {
alt->getCMYK(color, cmyk);
}
#else
alt->getCMYK(color, cmyk);
#endif
}
bool GfxICCBasedColorSpace::useGetRGBLine() const
{
#ifdef USE_CMS
return lineTransform != nullptr || alt->useGetRGBLine();
#else
return alt->useGetRGBLine();
#endif
}
bool GfxICCBasedColorSpace::useGetCMYKLine() const
{
#ifdef USE_CMS
return lineTransform != nullptr || alt->useGetCMYKLine();
#else
return alt->useGetCMYKLine();
#endif
}
bool GfxICCBasedColorSpace::useGetDeviceNLine() const
{
#ifdef USE_CMS
return lineTransform != nullptr || alt->useGetDeviceNLine();
#else
return alt->useGetDeviceNLine();
#endif
}
void GfxICCBasedColorSpace::getDeviceN(const GfxColor *color, GfxColor *deviceN) const
{
GfxCMYK cmyk;
clearGfxColor(deviceN);
getCMYK(color, &cmyk);
deviceN->c[0] = cmyk.c;
deviceN->c[1] = cmyk.m;
deviceN->c[2] = cmyk.y;
deviceN->c[3] = cmyk.k;
}
void GfxICCBasedColorSpace::getDefaultColor(GfxColor *color) const
{
int i;
for (i = 0; i < nComps; ++i) {
if (rangeMin[i] > 0) {
color->c[i] = dblToCol(rangeMin[i]);
} else if (rangeMax[i] < 0) {
color->c[i] = dblToCol(rangeMax[i]);
} else {
color->c[i] = 0;
}
}
}
void GfxICCBasedColorSpace::getDefaultRanges(double *decodeLow, double *decodeRange, int maxImgPixel) const
{
alt->getDefaultRanges(decodeLow, decodeRange, maxImgPixel);
#if 0
// this is nominally correct, but some PDF files don't set the
// correct ranges in the ICCBased dict
int i;
for (i = 0; i < nComps; ++i) {
decodeLow[i] = rangeMin[i];
decodeRange[i] = rangeMax[i] - rangeMin[i];
}
#endif
}
#ifdef USE_CMS
char *GfxICCBasedColorSpace::getPostScriptCSA()
{
# if LCMS_VERSION >= 2070
// The runtime version check of lcms2 is only available from release 2.7 upwards.
// The generation of the CSA code only works reliably for version 2.10 and upwards.
// Cf. the explanation in the corresponding lcms2 merge request [1], and the original mail thread [2].
// [1] https://github.com/mm2/Little-CMS/pull/214
// [2] https://sourceforge.net/p/lcms/mailman/message/33182987/
if (cmsGetEncodedCMMversion() < 2100) {
return nullptr;
}
int size;
if (psCSA) {
return psCSA;
}
if (!profile) {
error(errSyntaxWarning, -1, "profile is nullptr");
return nullptr;
}
void *rawprofile = profile.get();
size = cmsGetPostScriptCSA(cmsGetProfileContextID(rawprofile), rawprofile, getIntent(), 0, nullptr, 0);
if (size == 0) {
error(errSyntaxWarning, -1, "PostScript CSA is nullptr");
return nullptr;
}
psCSA = (char *)gmalloc(size + 1);
cmsGetPostScriptCSA(cmsGetProfileContextID(rawprofile), rawprofile, getIntent(), 0, psCSA, size);
psCSA[size] = 0;
// TODO REMOVE-ME-IN-THE-FUTURE
// until we can depend on https://github.com/mm2/Little-CMS/issues/223 being fixed
// lcms returns ps code with , instead of . for some locales. The lcms author says
// that there's no room for any , in the rest of the ps code, so replacing all the , with .
// is an "acceptable" workaround
for (int i = 0; i < size; ++i) {
if (psCSA[i] == ',') {
psCSA[i] = '.';
}
}
return psCSA;
# else
return nullptr;
# endif
}
#endif
//------------------------------------------------------------------------
// GfxIndexedColorSpace
//------------------------------------------------------------------------
GfxIndexedColorSpace::GfxIndexedColorSpace(GfxColorSpace *baseA, int indexHighA)
{
base = baseA;
indexHigh = indexHighA;
lookup = (unsigned char *)gmallocn((indexHigh + 1) * base->getNComps(), sizeof(unsigned char));
overprintMask = base->getOverprintMask();
}
GfxIndexedColorSpace::~GfxIndexedColorSpace()
{
delete base;
gfree(lookup);
}
GfxColorSpace *GfxIndexedColorSpace::copy() const
{
GfxIndexedColorSpace *cs;
cs = new GfxIndexedColorSpace(base->copy(), indexHigh);
memcpy(cs->lookup, lookup, (indexHigh + 1) * base->getNComps() * sizeof(unsigned char));
return cs;
}
GfxColorSpace *GfxIndexedColorSpace::parse(GfxResources *res, Array *arr, OutputDev *out, GfxState *state, int recursion)
{
GfxColorSpace *baseA;
int indexHighA;
Object obj1;
const char *s;
int i, j;
if (arr->getLength() != 4) {
error(errSyntaxWarning, -1, "Bad Indexed color space");
return nullptr;
}
obj1 = arr->get(1);
if (!(baseA = GfxColorSpace::parse(res, &obj1, out, state, recursion + 1))) {
error(errSyntaxWarning, -1, "Bad Indexed color space (base color space)");
return nullptr;
}
obj1 = arr->get(2);
if (!obj1.isInt()) {
error(errSyntaxWarning, -1, "Bad Indexed color space (hival)");
delete baseA;
return nullptr;
}
indexHighA = obj1.getInt();
if (indexHighA < 0 || indexHighA > 255) {
// the PDF spec requires indexHigh to be in [0,255] -- allowing
// values larger than 255 creates a security hole: if nComps *
// indexHigh is greater than 2^31, the loop below may overwrite
// past the end of the array
int previousValue = indexHighA;
if (indexHighA < 0) {
indexHighA = 0;
} else {
indexHighA = 255;
}
error(errSyntaxWarning, -1, "Bad Indexed color space (invalid indexHigh value, was {0:d} using {1:d} to try to recover)", previousValue, indexHighA);
}
GfxIndexedColorSpace *cs = new GfxIndexedColorSpace(baseA, indexHighA);
obj1 = arr->get(3);
const int n = baseA->getNComps();
if (obj1.isStream()) {
obj1.streamReset();
for (i = 0; i <= indexHighA; ++i) {
const int readChars = obj1.streamGetChars(n, &cs->lookup[i * n]);
for (j = readChars; j < n; ++j) {
error(errSyntaxWarning, -1, "Bad Indexed color space (lookup table stream too short) padding with zeroes");
cs->lookup[i * n + j] = 0;
}
}
obj1.streamClose();
} else if (obj1.isString()) {
if (obj1.getString()->getLength() < (indexHighA + 1) * n) {
error(errSyntaxWarning, -1, "Bad Indexed color space (lookup table string too short)");
goto err3;
}
s = obj1.getString()->c_str();
for (i = 0; i <= indexHighA; ++i) {
for (j = 0; j < n; ++j) {
cs->lookup[i * n + j] = (unsigned char)*s++;
}
}
} else {
error(errSyntaxWarning, -1, "Bad Indexed color space (lookup table)");
goto err3;
}
return cs;
err3:
delete cs;
return nullptr;
}
GfxColor *GfxIndexedColorSpace::mapColorToBase(const GfxColor *color, GfxColor *baseColor) const
{
unsigned char *p;
double low[gfxColorMaxComps], range[gfxColorMaxComps];
int n, i;
n = base->getNComps();
base->getDefaultRanges(low, range, indexHigh);
const int idx = (int)(colToDbl(color->c[0]) + 0.5) * n;
if (likely((idx + n - 1 < (indexHigh + 1) * base->getNComps()) && idx >= 0)) {
p = &lookup[idx];
for (i = 0; i < n; ++i) {
baseColor->c[i] = dblToCol(low[i] + (p[i] / 255.0) * range[i]);
}
} else {
for (i = 0; i < n; ++i) {
baseColor->c[i] = 0;
}
}
return baseColor;
}
void GfxIndexedColorSpace::getGray(const GfxColor *color, GfxGray *gray) const
{
GfxColor color2;
base->getGray(mapColorToBase(color, &color2), gray);
}
void GfxIndexedColorSpace::getRGB(const GfxColor *color, GfxRGB *rgb) const
{
GfxColor color2;
base->getRGB(mapColorToBase(color, &color2), rgb);
}
void GfxIndexedColorSpace::getRGBLine(unsigned char *in, unsigned int *out, int length)
{
unsigned char *line;
int i, j, n;
n = base->getNComps();
line = (unsigned char *)gmallocn(length, n);
for (i = 0; i < length; i++) {
for (j = 0; j < n; j++) {
line[i * n + j] = lookup[in[i] * n + j];
}
}
base->getRGBLine(line, out, length);
gfree(line);
}
void GfxIndexedColorSpace::getRGBLine(unsigned char *in, unsigned char *out, int length)
{
unsigned char *line;
int i, j, n;
n = base->getNComps();
line = (unsigned char *)gmallocn(length, n);
for (i = 0; i < length; i++) {
for (j = 0; j < n; j++) {
line[i * n + j] = lookup[in[i] * n + j];
}
}
base->getRGBLine(line, out, length);
gfree(line);
}
void GfxIndexedColorSpace::getRGBXLine(unsigned char *in, unsigned char *out, int length)
{
unsigned char *line;
int i, j, n;
n = base->getNComps();
line = (unsigned char *)gmallocn(length, n);
for (i = 0; i < length; i++) {
for (j = 0; j < n; j++) {
line[i * n + j] = lookup[in[i] * n + j];