walkero
/
openjpeg
1
0
Fork 0
Code Issues Pull Requests Projects Releases 1 Wiki Activity
openjpeg/thirdparty/liblcms2/src/cmsopt.c

1632 lines
53 KiB
C
Raw Normal View History

Removed the libs directory containing win32 compiled versions of libpng, libtiff and liblcms. Added a thirdparty directory to include main source files of libtiff, libpng, libz and liblcms to enable support of these formats in the codec executables. CMake will try to statically build these libraries if they are not found on the system. Note that these third party libraries are not required to build libopenjpeg (which has no dependencies).
2011-03-20 23:45:24 +01:00
//---------------------------------------------------------------------------------
//
// Little Color Management System
// Copyright (c) 1998-2010 Marti Maria Saguer
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the Software
// is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//---------------------------------------------------------------------------------
//
#include "lcms2_internal.h"
//----------------------------------------------------------------------------------
// Optimization for 8 bits, Shaper-CLUT (3 inputs only)
typedef struct {
cmsContext ContextID;
const cmsInterpParams* p; // Tetrahedrical interpolation parameters. This is a not-owned pointer.
cmsUInt16Number rx[256], ry[256], rz[256];
cmsUInt32Number X0[256], Y0[256], Z0[256]; // Precomputed nodes and offsets for 8-bit input data
} Prelin8Data;
// Generic optimization for 16 bits Shaper-CLUT-Shaper (any inputs)
typedef struct {
cmsContext ContextID;
// Number of channels
int nInputs;
int nOutputs;
// Since there is no limitation of the output number of channels, this buffer holding the connexion CLUT-shaper
// has to be dynamically allocated. This is not the case of first step shaper-CLUT, which is limited to max inputs
cmsUInt16Number* StageDEF;
_cmsInterpFn16 EvalCurveIn16[MAX_INPUT_DIMENSIONS]; // The maximum number of input channels is known in advance
cmsInterpParams* ParamsCurveIn16[MAX_INPUT_DIMENSIONS];
_cmsInterpFn16 EvalCLUT; // The evaluator for 3D grid
const cmsInterpParams* CLUTparams; // (not-owned pointer)
_cmsInterpFn16* EvalCurveOut16; // Points to an array of curve evaluators in 16 bits (not-owned pointer)
cmsInterpParams** ParamsCurveOut16; // Points to an array of references to interpolation params (not-owned pointer)
} Prelin16Data;
// Optimization for matrix-shaper in 8 bits. Numbers are operated in n.14 signed, tables are stored in 1.14 fixed
typedef cmsInt32Number cmsS1Fixed14Number; // Note that this may hold more than 16 bits!
#define DOUBLE_TO_1FIXED14(x) ((cmsS1Fixed14Number) floor((x) * 16384.0 + 0.5))
typedef struct {
cmsContext ContextID;
cmsS1Fixed14Number Shaper1R[256]; // from 0..255 to 1.14 (0.0...1.0)
cmsS1Fixed14Number Shaper1G[256];
cmsS1Fixed14Number Shaper1B[256];
cmsS1Fixed14Number Mat[3][3]; // n.14 to n.14 (needs a saturation after that)
cmsS1Fixed14Number Off[3];
cmsUInt16Number Shaper2R[16385]; // 1.14 to 0..255
cmsUInt16Number Shaper2G[16385];
cmsUInt16Number Shaper2B[16385];
} MatShaper8Data;
// Curves, optimization is shared between 8 and 16 bits
typedef struct {
cmsContext ContextID;
int nCurves; // Number of curves
int nElements; // Elements in curves
cmsUInt16Number** Curves; // Points to a dynamically allocated array
} Curves16Data;
// Simple optimizations ----------------------------------------------------------------------------------------------------------
// Remove an element in linked chain
static
void _RemoveElement(cmsStage** head)
{
cmsStage* mpe = *head;
cmsStage* next = mpe ->Next;
*head = next;
cmsStageFree(mpe);
}
// Remove all identities in chain. Note that pt actually is a double pointer to the element that holds the pointer.
static
cmsBool _Remove1Op(cmsPipeline* Lut, cmsStageSignature UnaryOp)
{
cmsStage** pt = &Lut ->Elements;
cmsBool AnyOpt = FALSE;
while (*pt != NULL) {
if ((*pt) ->Implements == UnaryOp) {
_RemoveElement(pt);
AnyOpt = TRUE;
}
else
pt = &((*pt) -> Next);
}
return AnyOpt;
}
// Same, but only if two adjacent elements are found
static
cmsBool _Remove2Op(cmsPipeline* Lut, cmsStageSignature Op1, cmsStageSignature Op2)
{
cmsStage** pt1;
cmsStage** pt2;
cmsBool AnyOpt = FALSE;
pt1 = &Lut ->Elements;
if (*pt1 == NULL) return AnyOpt;
while (*pt1 != NULL) {
pt2 = &((*pt1) -> Next);
if (*pt2 == NULL) return AnyOpt;
if ((*pt1) ->Implements == Op1 && (*pt2) ->Implements == Op2) {
_RemoveElement(pt2);
_RemoveElement(pt1);
AnyOpt = TRUE;
}
else
pt1 = &((*pt1) -> Next);
}
return AnyOpt;
}
// Preoptimize just gets rif of no-ops coming paired. Conversion from v2 to v4 followed
// by a v4 to v2 and vice-versa. The elements are then discarded.
static
cmsBool PreOptimize(cmsPipeline* Lut)
{
cmsBool AnyOpt = FALSE, Opt;
AnyOpt = FALSE;
do {
Opt = FALSE;
// Remove all identities
Opt |= _Remove1Op(Lut, cmsSigIdentityElemType);
// Remove XYZ2Lab followed by Lab2XYZ
Opt |= _Remove2Op(Lut, cmsSigXYZ2LabElemType, cmsSigLab2XYZElemType);
// Remove Lab2XYZ followed by XYZ2Lab
Opt |= _Remove2Op(Lut, cmsSigLab2XYZElemType, cmsSigXYZ2LabElemType);
// Remove V4 to V2 followed by V2 to V4
Opt |= _Remove2Op(Lut, cmsSigLabV4toV2, cmsSigLabV2toV4);
// Remove V2 to V4 followed by V4 to V2
Opt |= _Remove2Op(Lut, cmsSigLabV2toV4, cmsSigLabV4toV2);
if (Opt) AnyOpt = TRUE;
} while (Opt);
return AnyOpt;
}
static
void Eval16nop1D(register const cmsUInt16Number Input[],
register cmsUInt16Number Output[],
register const struct _cms_interp_struc* p)
{
Output[0] = Input[0];
cmsUNUSED_PARAMETER(p);
}
static
void PrelinEval16(register const cmsUInt16Number Input[],
register cmsUInt16Number Output[],
register const void* D)
{
Prelin16Data* p16 = (Prelin16Data*) D;
cmsUInt16Number StageABC[MAX_INPUT_DIMENSIONS];
int i;
for (i=0; i < p16 ->nInputs; i++) {
p16 ->EvalCurveIn16[i](&Input[i], &StageABC[i], p16 ->ParamsCurveIn16[i]);
}
p16 ->EvalCLUT(StageABC, p16 ->StageDEF, p16 ->CLUTparams);
for (i=0; i < p16 ->nOutputs; i++) {
p16 ->EvalCurveOut16[i](&p16->StageDEF[i], &Output[i], p16 ->ParamsCurveOut16[i]);
}
}
static
void PrelinOpt16free(cmsContext ContextID, void* ptr)
{
Prelin16Data* p16 = (Prelin16Data*) ptr;
_cmsFree(ContextID, p16 ->StageDEF);
_cmsFree(ContextID, p16 ->EvalCurveOut16);
_cmsFree(ContextID, p16 ->ParamsCurveOut16);
_cmsFree(ContextID, p16);
}
static
void* Prelin16dup(cmsContext ContextID, const void* ptr)
{
Prelin16Data* p16 = (Prelin16Data*) ptr;
Prelin16Data* Duped = _cmsDupMem(ContextID, p16, sizeof(Prelin16Data));
if (Duped == NULL) return NULL;
Duped ->StageDEF = _cmsCalloc(ContextID, p16 ->nOutputs, sizeof(cmsUInt16Number));
Duped ->EvalCurveOut16 = _cmsDupMem(ContextID, p16 ->EvalCurveOut16, p16 ->nOutputs * sizeof(_cmsInterpFn16));
Duped ->ParamsCurveOut16 = _cmsDupMem(ContextID, p16 ->ParamsCurveOut16, p16 ->nOutputs * sizeof(cmsInterpParams* ));
return Duped;
}
static
Prelin16Data* PrelinOpt16alloc(cmsContext ContextID,
const cmsInterpParams* ColorMap,
int nInputs, cmsToneCurve** In,
int nOutputs, cmsToneCurve** Out )
{
int i;
Prelin16Data* p16 = (Prelin16Data*) _cmsMallocZero(ContextID, sizeof(Prelin16Data));
if (p16 == NULL) return NULL;
p16 ->nInputs = nInputs;
p16 -> nOutputs = nOutputs;
for (i=0; i < nInputs; i++) {
if (In == NULL) {
p16 -> ParamsCurveIn16[i] = NULL;
p16 -> EvalCurveIn16[i] = Eval16nop1D;
}
else {
p16 -> ParamsCurveIn16[i] = In[i] ->InterpParams;
p16 -> EvalCurveIn16[i] = p16 ->ParamsCurveIn16[i]->Interpolation.Lerp16;
}
}
p16 ->CLUTparams = ColorMap;
p16 ->EvalCLUT = ColorMap ->Interpolation.Lerp16;
p16 -> StageDEF = _cmsCalloc(ContextID, p16 ->nOutputs, sizeof(cmsUInt16Number));
p16 -> EvalCurveOut16 = (_cmsInterpFn16*) _cmsCalloc(ContextID, nOutputs, sizeof(_cmsInterpFn16));
p16 -> ParamsCurveOut16 = (cmsInterpParams**) _cmsCalloc(ContextID, nOutputs, sizeof(cmsInterpParams* ));
for (i=0; i < nOutputs; i++) {
if (Out == NULL) {
p16 ->ParamsCurveOut16[i] = NULL;
p16 -> EvalCurveOut16[i] = Eval16nop1D;
}
else {
p16 ->ParamsCurveOut16[i] = Out[i] ->InterpParams;
p16 -> EvalCurveOut16[i] = p16 ->ParamsCurveOut16[i]->Interpolation.Lerp16;
}
}
return p16;
}
// Resampling ---------------------------------------------------------------------------------
#define PRELINEARIZATION_POINTS 4096
// Sampler implemented by another LUT. This is a clean way to precalculate the devicelink 3D CLUT for
// almost any transform. We use floating point precision and then convert from floating point to 16 bits.
static
int XFormSampler16(register const cmsUInt16Number In[], register cmsUInt16Number Out[], register void* Cargo)
{
cmsPipeline* Lut = (cmsPipeline*) Cargo;
cmsFloat32Number InFloat[cmsMAXCHANNELS], OutFloat[cmsMAXCHANNELS];
cmsUInt32Number i;
_cmsAssert(Lut -> InputChannels < cmsMAXCHANNELS);
_cmsAssert(Lut -> OutputChannels < cmsMAXCHANNELS);
// From 16 bit to floating point
for (i=0; i < Lut ->InputChannels; i++)
InFloat[i] = (cmsFloat32Number) (In[i] / 65535.0);
// Evaluate in floating point
cmsPipelineEvalFloat(InFloat, OutFloat, Lut);
// Back to 16 bits representation
for (i=0; i < Lut ->OutputChannels; i++)
Out[i] = _cmsQuickSaturateWord(OutFloat[i] * 65535.0);
// Always succeed
return TRUE;
}
// Try to see if the curves of a given MPE are linear
static
cmsBool AllCurvesAreLinear(cmsStage* mpe)
{
cmsToneCurve** Curves;
cmsUInt32Number i, n;
Curves = _cmsStageGetPtrToCurveSet(mpe);
if (Curves == NULL) return FALSE;
n = cmsStageOutputChannels(mpe);
for (i=0; i < n; i++) {
if (!cmsIsToneCurveLinear(Curves[i])) return FALSE;
}
return TRUE;
}
// This function replaces a specific node placed in "At" by the "Value" numbers. Its purpose
// is to fix scum dot on broken profiles/transforms. Works on 1, 3 and 4 channels
static
cmsBool PatchLUT(cmsStage* CLUT, cmsUInt16Number At[], cmsUInt16Number Value[],
int nChannelsOut, int nChannelsIn)
{
_cmsStageCLutData* Grid = (_cmsStageCLutData*) CLUT ->Data;
cmsInterpParams* p16 = Grid ->Params;
cmsFloat64Number px, py, pz, pw;
int x0, y0, z0, w0;
int i, index;
if (CLUT -> Type != cmsSigCLutElemType) {
cmsSignalError(CLUT->ContextID, cmsERROR_INTERNAL, "(internal) Attempt to PatchLUT on non-lut MPE");
return FALSE;
}
px = ((cmsFloat64Number) At[0] * (p16->Domain[0])) / 65535.0;
py = ((cmsFloat64Number) At[1] * (p16->Domain[1])) / 65535.0;
pz = ((cmsFloat64Number) At[2] * (p16->Domain[2])) / 65535.0;
pw = ((cmsFloat64Number) At[3] * (p16->Domain[3])) / 65535.0;
x0 = (int) floor(px);
y0 = (int) floor(py);
z0 = (int) floor(pz);
w0 = (int) floor(pw);
if (nChannelsIn == 4) {
if (((px - x0) != 0) ||
((py - y0) != 0) ||
((pz - z0) != 0) ||
((pw - w0) != 0)) return FALSE; // Not on exact node
index = p16 -> opta[3] * x0 +
p16 -> opta[2] * y0 +
p16 -> opta[1] * z0 +
p16 -> opta[0] * w0;
}
else
if (nChannelsIn == 3) {
if (((px - x0) != 0) ||
((py - y0) != 0) ||
((pz - z0) != 0)) return FALSE; // Not on exact node
index = p16 -> opta[2] * x0 +
p16 -> opta[1] * y0 +
p16 -> opta[0] * z0;
}
else
if (nChannelsIn == 1) {
if (((px - x0) != 0)) return FALSE; // Not on exact node
index = p16 -> opta[0] * x0;
}
else {
cmsSignalError(CLUT->ContextID, cmsERROR_INTERNAL, "(internal) %d Channels are not supported on PatchLUT", nChannelsIn);
return FALSE;
}
for (i=0; i < nChannelsOut; i++)
Grid -> Tab.T[index + i] = Value[i];
return TRUE;
}
// Auxiliar, to see if two values are equal.
static
cmsBool WhitesAreEqual(int n, cmsUInt16Number White1[], cmsUInt16Number White2[] )
{
int i;
for (i=0; i < n; i++) {
if (White1[i] != White2[i]) return FALSE;
}
return TRUE;
}
// Locate the node for the white point and fix it to pure white in order to avoid scum dot.
static
cmsBool FixWhiteMisalignment(cmsPipeline* Lut, cmsColorSpaceSignature EntryColorSpace, cmsColorSpaceSignature ExitColorSpace)
{
cmsUInt16Number *WhitePointIn, *WhitePointOut;
cmsUInt16Number WhiteIn[cmsMAXCHANNELS], WhiteOut[cmsMAXCHANNELS], ObtainedOut[cmsMAXCHANNELS];
cmsUInt32Number i, nOuts, nIns;
cmsStage *PreLin = NULL, *CLUT = NULL, *PostLin = NULL;
if (!_cmsEndPointsBySpace(EntryColorSpace,
&WhitePointIn, NULL, &nIns)) return FALSE;
if (!_cmsEndPointsBySpace(ExitColorSpace,
&WhitePointOut, NULL, &nOuts)) return FALSE;
// It needs to be fixed?
cmsPipelineEval16(WhitePointIn, ObtainedOut, Lut);
if (WhitesAreEqual(nOuts, WhitePointOut, ObtainedOut)) return TRUE; // whites already match
// Check if the LUT comes as Prelin, CLUT or Postlin. We allow all combinations
if (!cmsPipelineCheckAndRetreiveStages(Lut, 3, cmsSigCurveSetElemType, cmsSigCLutElemType, cmsSigCurveSetElemType, &PreLin, &CLUT, &PostLin))
if (!cmsPipelineCheckAndRetreiveStages(Lut, 2, cmsSigCurveSetElemType, cmsSigCLutElemType, &PreLin, &CLUT))
if (!cmsPipelineCheckAndRetreiveStages(Lut, 2, cmsSigCLutElemType, cmsSigCurveSetElemType, &CLUT, &PostLin))
if (!cmsPipelineCheckAndRetreiveStages(Lut, 1, cmsSigCLutElemType, &CLUT))
return FALSE;
// We need to interpolate white points of both, pre and post curves
if (PreLin) {
cmsToneCurve** Curves = _cmsStageGetPtrToCurveSet(PreLin);
for (i=0; i < nIns; i++) {
WhiteIn[i] = cmsEvalToneCurve16(Curves[i], WhitePointIn[i]);
}
}
else {
for (i=0; i < nIns; i++)
WhiteIn[i] = WhitePointIn[i];
}
// If any post-linearization, we need to find how is represented white before the curve, do
// a reverse interpolation in this case.
if (PostLin) {
cmsToneCurve** Curves = _cmsStageGetPtrToCurveSet(PostLin);
for (i=0; i < nOuts; i++) {
cmsToneCurve* InversePostLin = cmsReverseToneCurve(Curves[i]);
WhiteOut[i] = cmsEvalToneCurve16(InversePostLin, WhitePointOut[i]);
cmsFreeToneCurve(InversePostLin);
}
}
else {
for (i=0; i < nOuts; i++)
WhiteOut[i] = WhitePointOut[i];
}
// Ok, proceed with patching. May fail and we don't care if it fails
PatchLUT(CLUT, WhiteIn, WhiteOut, nOuts, nIns);
return TRUE;
}
// -----------------------------------------------------------------------------------------------------------------------------------------------
// This function creates simple LUT from complex ones. The generated LUT has an optional set of
// prelinearization curves, a CLUT of nGridPoints and optional postlinearization tables.
// These curves have to exist in the original LUT in order to be used in the simplified output.
// Caller may also use the flags to allow this feature.
// LUTS with all curves will be simplified to a single curve. Parametric curves are lost.
// This function should be used on 16-bits LUTS only, as floating point losses precision when simplified
// -----------------------------------------------------------------------------------------------------------------------------------------------
static
cmsBool OptimizeByResampling(cmsPipeline** Lut, cmsUInt32Number Intent, cmsUInt32Number* InputFormat, cmsUInt32Number* OutputFormat, cmsUInt32Number* dwFlags)
{
cmsPipeline* Src;
cmsPipeline* Dest;
cmsStage* CLUT;
cmsStage *KeepPreLin = NULL, *KeepPostLin = NULL;
int nGridPoints;
cmsColorSpaceSignature ColorSpace, OutputColorSpace;
cmsStage *NewPreLin = NULL;
cmsStage *NewPostLin = NULL;
_cmsStageCLutData* DataCLUT;
cmsToneCurve** DataSetIn;
cmsToneCurve** DataSetOut;
Prelin16Data* p16;
// This is a loosy optimization! does not apply in floating-point cases
if (_cmsFormatterIsFloat(*InputFormat) || _cmsFormatterIsFloat(*OutputFormat)) return FALSE;
ColorSpace = _cmsICCcolorSpace(T_COLORSPACE(*InputFormat));
OutputColorSpace = _cmsICCcolorSpace(T_COLORSPACE(*OutputFormat));
nGridPoints = _cmsReasonableGridpointsByColorspace(ColorSpace, *dwFlags);
// For empty LUTs, 2 points are enough
if (cmsPipelineStageCount(*Lut) == 0)
nGridPoints = 2;
Src = *Lut;
// Allocate an empty LUT
Dest = cmsPipelineAlloc(Src ->ContextID, Src ->InputChannels, Src ->OutputChannels);
if (!Dest) return FALSE;
// Prelinearization tables are kept unless indicated by flags
if (*dwFlags & cmsFLAGS_CLUT_PRE_LINEARIZATION) {
// Get a pointer to the prelinearization element
cmsStage* PreLin = cmsPipelineGetPtrToFirstStage(Src);
// Check if suitable
if (PreLin ->Type == cmsSigCurveSetElemType) {
// Maybe this is a linear tram, so we can avoid the whole stuff
if (!AllCurvesAreLinear(PreLin)) {
// All seems ok, proceed.
NewPreLin = cmsStageDup(PreLin);
cmsPipelineInsertStage(Dest, cmsAT_BEGIN, NewPreLin);
// Remove prelinearization. Since we have duplicated the curve
// in destination LUT, the sampling shoud be applied after this stage.
cmsPipelineUnlinkStage(Src, cmsAT_BEGIN, &KeepPreLin);
}
}
}
// Allocate the CLUT
CLUT = cmsStageAllocCLut16bit(Src ->ContextID, nGridPoints, Src ->InputChannels, Src->OutputChannels, NULL);
if (CLUT == NULL) return FALSE;
// Add the CLUT to the destination LUT
cmsPipelineInsertStage(Dest, cmsAT_END, CLUT);
// Postlinearization tables are kept unless indicated by flags
if (*dwFlags & cmsFLAGS_CLUT_POST_LINEARIZATION) {
// Get a pointer to the postlinearization if present
cmsStage* PostLin = cmsPipelineGetPtrToLastStage(Src);
// Check if suitable
if (cmsStageType(PostLin) == cmsSigCurveSetElemType) {
// Maybe this is a linear tram, so we can avoid the whole stuff
if (!AllCurvesAreLinear(PostLin)) {
// All seems ok, proceed.
NewPostLin = cmsStageDup(PostLin);
cmsPipelineInsertStage(Dest, cmsAT_END, NewPostLin);
// In destination LUT, the sampling shoud be applied after this stage.
cmsPipelineUnlinkStage(Src, cmsAT_END, &KeepPostLin);
}
}
}
// Now its time to do the sampling. We have to ignore pre/post linearization
// The source LUT whithout pre/post curves is passed as parameter.
if (!cmsStageSampleCLut16bit(CLUT, XFormSampler16, (void*) Src, 0)) {
// Ops, something went wrong, Restore stages
if (KeepPreLin != NULL) cmsPipelineInsertStage(Src, cmsAT_BEGIN, KeepPreLin);
if (KeepPostLin != NULL) cmsPipelineInsertStage(Src, cmsAT_END, KeepPostLin);
cmsPipelineFree(Dest);
return FALSE;
}
// Done.
if (KeepPreLin != NULL) cmsStageFree(KeepPreLin);
if (KeepPostLin != NULL) cmsStageFree(KeepPostLin);
cmsPipelineFree(Src);
DataCLUT = (_cmsStageCLutData*) CLUT ->Data;
if (NewPreLin == NULL) DataSetIn = NULL;
else DataSetIn = ((_cmsStageToneCurvesData*) NewPreLin ->Data) ->TheCurves;
if (NewPostLin == NULL) DataSetOut = NULL;
else DataSetOut = ((_cmsStageToneCurvesData*) NewPostLin ->Data) ->TheCurves;
if (DataSetIn == NULL && DataSetOut == NULL) {
_cmsPipelineSetOptimizationParameters(Dest, (_cmsOPTeval16Fn) DataCLUT->Params->Interpolation.Lerp16, DataCLUT->Params, NULL, NULL);
}
else {
p16 = PrelinOpt16alloc(Dest ->ContextID,
DataCLUT ->Params,
Dest ->InputChannels,
DataSetIn,
Dest ->OutputChannels,
DataSetOut);
_cmsPipelineSetOptimizationParameters(Dest, PrelinEval16, (void*) p16, PrelinOpt16free, Prelin16dup);
}
// Don't fix white on absolute colorimetric
if (Intent == INTENT_ABSOLUTE_COLORIMETRIC)
*dwFlags |= cmsFLAGS_NOWHITEONWHITEFIXUP;
if (!(*dwFlags & cmsFLAGS_NOWHITEONWHITEFIXUP)) {
FixWhiteMisalignment(Dest, ColorSpace, OutputColorSpace);
}
*Lut = Dest;
return TRUE;
cmsUNUSED_PARAMETER(Intent);
}
// -----------------------------------------------------------------------------------------------------------------------------------------------
// Fixes the gamma balancing of transform. This is described in my paper "Prelinearization Stages on
// Color-Management Application-Specific Integrated Circuits (ASICs)" presented at NIP24. It only works
// for RGB transforms. See the paper for more details
// -----------------------------------------------------------------------------------------------------------------------------------------------
// Normalize endpoints by slope limiting max and min. This assures endpoints as well.
// Descending curves are handled as well.
static
void SlopeLimiting(cmsToneCurve* g)
{
int BeginVal, EndVal;
int AtBegin = (int) floor((cmsFloat64Number) g ->nEntries * 0.02 + 0.5); // Cutoff at 2%
int AtEnd = g ->nEntries - AtBegin - 1; // And 98%
cmsFloat64Number Val, Slope, beta;
int i;
if (cmsIsToneCurveDescending(g)) {
BeginVal = 0xffff; EndVal = 0;
}
else {
BeginVal = 0; EndVal = 0xffff;
}
// Compute slope and offset for begin of curve
Val = g ->Table16[AtBegin];
Slope = (Val - BeginVal) / AtBegin;
beta = Val - Slope * AtBegin;
for (i=0; i < AtBegin; i++)
g ->Table16[i] = _cmsQuickSaturateWord(i * Slope + beta);
// Compute slope and offset for the end
Val = g ->Table16[AtEnd];
Slope = (EndVal - Val) / AtBegin; // AtBegin holds the X interval, which is same in both cases
beta = Val - Slope * AtEnd;
for (i = AtEnd; i < (int) g ->nEntries; i++)
g ->Table16[i] = _cmsQuickSaturateWord(i * Slope + beta);
}
// Precomputes tables for 8-bit on input devicelink.
static
Prelin8Data* PrelinOpt8alloc(cmsContext ContextID, const cmsInterpParams* p, cmsToneCurve* G[3])
{
int i;
cmsUInt16Number Input[3];
cmsS15Fixed16Number v1, v2, v3;
Prelin8Data* p8;
p8 = _cmsMallocZero(ContextID, sizeof(Prelin8Data));
if (p8 == NULL) return NULL;
// Since this only works for 8 bit input, values comes always as x * 257,
// we can safely take msb byte (x << 8 + x)
for (i=0; i < 256; i++) {
if (G != NULL) {
// Get 16-bit representation
Input[0] = cmsEvalToneCurve16(G[0], FROM_8_TO_16(i));
Input[1] = cmsEvalToneCurve16(G[1], FROM_8_TO_16(i));
Input[2] = cmsEvalToneCurve16(G[2], FROM_8_TO_16(i));
}
else {
Input[0] = FROM_8_TO_16(i);
Input[1] = FROM_8_TO_16(i);
Input[2] = FROM_8_TO_16(i);
}
// Move to 0..1.0 in fixed domain
v1 = _cmsToFixedDomain(Input[0] * p -> Domain[0]);
v2 = _cmsToFixedDomain(Input[1] * p -> Domain[1]);
v3 = _cmsToFixedDomain(Input[2] * p -> Domain[2]);
// Store the precalculated table of nodes
p8 ->X0[i] = (p->opta[2] * FIXED_TO_INT(v1));
p8 ->Y0[i] = (p->opta[1] * FIXED_TO_INT(v2));
p8 ->Z0[i] = (p->opta[0] * FIXED_TO_INT(v3));
// Store the precalculated table of offsets
p8 ->rx[i] = (cmsUInt16Number) FIXED_REST_TO_INT(v1);
p8 ->ry[i] = (cmsUInt16Number) FIXED_REST_TO_INT(v2);
p8 ->rz[i] = (cmsUInt16Number) FIXED_REST_TO_INT(v3);
}
p8 ->ContextID = ContextID;
p8 ->p = p;
return p8;
}
static
void Prelin8free(cmsContext ContextID, void* ptr)
{
_cmsFree(ContextID, ptr);
}
static
void* Prelin8dup(cmsContext ContextID, const void* ptr)
{
return _cmsDupMem(ContextID, ptr, sizeof(Prelin8Data));
}
// A optimized interpolation for 8-bit input.
#define DENS(i,j,k) (LutTable[(i)+(j)+(k)+OutChan])
static
void PrelinEval8(register const cmsUInt16Number Input[],
register cmsUInt16Number Output[],
register const void* D)
{
cmsUInt8Number r, g, b;
cmsS15Fixed16Number rx, ry, rz;
cmsS15Fixed16Number c0, c1, c2, c3, Rest;
int OutChan;
register cmsS15Fixed16Number X0, X1, Y0, Y1, Z0, Z1;
Prelin8Data* p8 = (Prelin8Data*) D;
register const cmsInterpParams* p = p8 ->p;
int TotalOut = p -> nOutputs;
const cmsUInt16Number* LutTable = p -> Table;
r = Input[0] >> 8;
g = Input[1] >> 8;
b = Input[2] >> 8;
X0 = X1 = p8->X0[r];
Y0 = Y1 = p8->Y0[g];
Z0 = Z1 = p8->Z0[b];
rx = p8 ->rx[r];
ry = p8 ->ry[g];
rz = p8 ->rz[b];
X1 = X0 + ((rx == 0) ? 0 : p ->opta[2]);
Y1 = Y0 + ((ry == 0) ? 0 : p ->opta[1]);
Z1 = Z0 + ((rz == 0) ? 0 : p ->opta[0]);
// These are the 6 Tetrahedral
for (OutChan=0; OutChan < TotalOut; OutChan++) {
c0 = DENS(X0, Y0, Z0);
if (rx >= ry && ry >= rz)
{
c1 = DENS(X1, Y0, Z0) - c0;
c2 = DENS(X1, Y1, Z0) - DENS(X1, Y0, Z0);
c3 = DENS(X1, Y1, Z1) - DENS(X1, Y1, Z0);
}
else
if (rx >= rz && rz >= ry)
{
c1 = DENS(X1, Y0, Z0) - c0;
c2 = DENS(X1, Y1, Z1) - DENS(X1, Y0, Z1);
c3 = DENS(X1, Y0, Z1) - DENS(X1, Y0, Z0);
}
else
if (rz >= rx && rx >= ry)
{
c1 = DENS(X1, Y0, Z1) - DENS(X0, Y0, Z1);
c2 = DENS(X1, Y1, Z1) - DENS(X1, Y0, Z1);
c3 = DENS(X0, Y0, Z1) - c0;
}
else
if (ry >= rx && rx >= rz)
{
c1 = DENS(X1, Y1, Z0) - DENS(X0, Y1, Z0);
c2 = DENS(X0, Y1, Z0) - c0;
c3 = DENS(X1, Y1, Z1) - DENS(X1, Y1, Z0);
}
else
if (ry >= rz && rz >= rx)
{
c1 = DENS(X1, Y1, Z1) - DENS(X0, Y1, Z1);
c2 = DENS(X0, Y1, Z0) - c0;
c3 = DENS(X0, Y1, Z1) - DENS(X0, Y1, Z0);
}
else
if (rz >= ry && ry >= rx)
{
c1 = DENS(X1, Y1, Z1) - DENS(X0, Y1, Z1);
c2 = DENS(X0, Y1, Z1) - DENS(X0, Y0, Z1);
c3 = DENS(X0, Y0, Z1) - c0;
}
else {
c1 = c2 = c3 = 0;
}
Rest = c1 * rx + c2 * ry + c3 * rz;
Output[OutChan] = (cmsUInt16Number)c0 + ROUND_FIXED_TO_INT(_cmsToFixedDomain(Rest));
}
}
#undef DENS
// --------------------------------------------------------------------------------------------------------------
// We need xput over here
static
cmsBool OptimizeByComputingLinearization(cmsPipeline** Lut, cmsUInt32Number Intent, cmsUInt32Number* InputFormat, cmsUInt32Number* OutputFormat, cmsUInt32Number* dwFlags)
{
cmsPipeline* OriginalLut;
int nGridPoints;
cmsToneCurve *Trans[cmsMAXCHANNELS], *TransReverse[cmsMAXCHANNELS];
cmsUInt32Number t, i;
cmsFloat32Number v, In[cmsMAXCHANNELS], Out[cmsMAXCHANNELS];
cmsBool lIsSuitable, lIsLinear;
cmsPipeline* OptimizedLUT = NULL, *LutPlusCurves = NULL;
cmsStage* OptimizedCLUTmpe;
cmsColorSpaceSignature ColorSpace, OutputColorSpace;
cmsStage* OptimizedPrelinMpe;
cmsToneCurve** OptimizedPrelinCurves;
_cmsStageCLutData* OptimizedPrelinCLUT;
// This is a loosy optimization! does not apply in floating-point cases
if (_cmsFormatterIsFloat(*InputFormat) || _cmsFormatterIsFloat(*OutputFormat)) return FALSE;
// Only on RGB
if (T_COLORSPACE(*InputFormat) != PT_RGB) return FALSE;
if (T_COLORSPACE(*OutputFormat) != PT_RGB) return FALSE;
// On 16 bits, user has to specify the feature
if (!_cmsFormatterIs8bit(*InputFormat)) {
if (!(*dwFlags & cmsFLAGS_CLUT_PRE_LINEARIZATION)) return FALSE;
}
OriginalLut = *Lut;
ColorSpace = _cmsICCcolorSpace(T_COLORSPACE(*InputFormat));
OutputColorSpace = _cmsICCcolorSpace(T_COLORSPACE(*OutputFormat));
nGridPoints = _cmsReasonableGridpointsByColorspace(ColorSpace, *dwFlags);
// Empty gamma containers
memset(Trans, 0, sizeof(Trans));
memset(TransReverse, 0, sizeof(TransReverse));
for (t = 0; t < OriginalLut ->InputChannels; t++) {
Trans[t] = cmsBuildTabulatedToneCurve16(OriginalLut ->ContextID, PRELINEARIZATION_POINTS, NULL);
if (Trans[t] == NULL) goto Error;
}
// Populate the curves
for (i=0; i < PRELINEARIZATION_POINTS; i++) {
v = (cmsFloat32Number) ((cmsFloat64Number) i / (PRELINEARIZATION_POINTS - 1));
// Feed input with a gray ramp
for (t=0; t < OriginalLut ->InputChannels; t++)
In[t] = v;
// Evaluate the gray value
cmsPipelineEvalFloat(In, Out, OriginalLut);
// Store result in curve
for (t=0; t < OriginalLut ->InputChannels; t++)
Trans[t] ->Table16[i] = _cmsQuickSaturateWord(Out[t] * 65535.0);
}
// Slope-limit the obtained curves
for (t = 0; t < OriginalLut ->InputChannels; t++)
SlopeLimiting(Trans[t]);
// Check for validity
lIsSuitable = TRUE;
lIsLinear = TRUE;
for (t=0; (lIsSuitable && (t < OriginalLut ->InputChannels)); t++) {
// Exclude if already linear
if (!cmsIsToneCurveLinear(Trans[t]))
lIsLinear = FALSE;
// Exclude if non-monotonic
if (!cmsIsToneCurveMonotonic(Trans[t]))
lIsSuitable = FALSE;
}
// If it is not suitable, just quit
if (!lIsSuitable) goto Error;
// Invert curves if possible
for (t = 0; t < OriginalLut ->InputChannels; t++) {
TransReverse[t] = cmsReverseToneCurveEx(PRELINEARIZATION_POINTS, Trans[t]);
if (TransReverse[t] == NULL) goto Error;
}
// Now inset the reversed curves at the begin of transform
LutPlusCurves = cmsPipelineDup(OriginalLut);
if (LutPlusCurves == NULL) goto Error;
cmsPipelineInsertStage(LutPlusCurves, cmsAT_BEGIN, cmsStageAllocToneCurves(OriginalLut ->ContextID, OriginalLut ->InputChannels, TransReverse));
// Create the result LUT
OptimizedLUT = cmsPipelineAlloc(OriginalLut ->ContextID, OriginalLut ->InputChannels, OriginalLut ->OutputChannels);
if (OptimizedLUT == NULL) goto Error;
OptimizedPrelinMpe = cmsStageAllocToneCurves(OriginalLut ->ContextID, OriginalLut ->InputChannels, Trans);
// Create and insert the curves at the beginning
cmsPipelineInsertStage(OptimizedLUT, cmsAT_BEGIN, OptimizedPrelinMpe);
// Allocate the CLUT for result
OptimizedCLUTmpe = cmsStageAllocCLut16bit(OriginalLut ->ContextID, nGridPoints, OriginalLut ->InputChannels, OriginalLut ->OutputChannels, NULL);
// Add the CLUT to the destination LUT
cmsPipelineInsertStage(OptimizedLUT, cmsAT_END, OptimizedCLUTmpe);
// Resample the LUT
if (!cmsStageSampleCLut16bit(OptimizedCLUTmpe, XFormSampler16, (void*) LutPlusCurves, 0)) goto Error;
// Free resources
for (t = 0; t < OriginalLut ->InputChannels; t++) {
if (Trans[t]) cmsFreeToneCurve(Trans[t]);
if (TransReverse[t]) cmsFreeToneCurve(TransReverse[t]);
}
cmsPipelineFree(LutPlusCurves);
OptimizedPrelinCurves = _cmsStageGetPtrToCurveSet(OptimizedPrelinMpe);
OptimizedPrelinCLUT = (_cmsStageCLutData*) OptimizedCLUTmpe ->Data;
// Set the evaluator if 8-bit
if (_cmsFormatterIs8bit(*InputFormat)) {
Prelin8Data* p8 = PrelinOpt8alloc(OptimizedLUT ->ContextID,
OptimizedPrelinCLUT ->Params,
OptimizedPrelinCurves);
if (p8 == NULL) return FALSE;
_cmsPipelineSetOptimizationParameters(OptimizedLUT, PrelinEval8, (void*) p8, Prelin8free, Prelin8dup);
}
else
{
Prelin16Data* p16 = PrelinOpt16alloc(OptimizedLUT ->ContextID,
OptimizedPrelinCLUT ->Params,
3, OptimizedPrelinCurves, 3, NULL);
if (p16 == NULL) return FALSE;
_cmsPipelineSetOptimizationParameters(OptimizedLUT, PrelinEval16, (void*) p16, PrelinOpt16free, Prelin16dup);
}
// Don't fix white on absolute colorimetric
if (Intent == INTENT_ABSOLUTE_COLORIMETRIC)
*dwFlags |= cmsFLAGS_NOWHITEONWHITEFIXUP;
if (!(*dwFlags & cmsFLAGS_NOWHITEONWHITEFIXUP)) {
if (!FixWhiteMisalignment(OptimizedLUT, ColorSpace, OutputColorSpace)) {
return FALSE;
}
}
// And return the obtained LUT
cmsPipelineFree(OriginalLut);
*Lut = OptimizedLUT;
return TRUE;
Error:
for (t = 0; t < OriginalLut ->InputChannels; t++) {
if (Trans[t]) cmsFreeToneCurve(Trans[t]);
if (TransReverse[t]) cmsFreeToneCurve(TransReverse[t]);
}
if (LutPlusCurves != NULL) cmsPipelineFree(LutPlusCurves);
if (OptimizedLUT != NULL) cmsPipelineFree(OptimizedLUT);
return FALSE;
cmsUNUSED_PARAMETER(Intent);
}
// Curves optimizer ------------------------------------------------------------------------------------------------------------------
static
void CurvesFree(cmsContext ContextID, void* ptr)
{
Curves16Data* Data = (Curves16Data*) ptr;
int i;
for (i=0; i < Data -> nCurves; i++) {
_cmsFree(ContextID, Data ->Curves[i]);
}
_cmsFree(ContextID, Data ->Curves);
_cmsFree(ContextID, ptr);
}
static
void* CurvesDup(cmsContext ContextID, const void* ptr)
{
Curves16Data* Data = _cmsDupMem(ContextID, ptr, sizeof(Curves16Data));
int i;
if (Data == NULL) return NULL;
Data ->Curves = _cmsDupMem(ContextID, Data ->Curves, Data ->nCurves * sizeof(cmsUInt16Number*));
for (i=0; i < Data -> nCurves; i++) {
Data ->Curves[i] = _cmsDupMem(ContextID, Data ->Curves[i], Data -> nElements * sizeof(cmsUInt16Number));
}
return (void*) Data;
}
// Precomputes tables for 8-bit on input devicelink.
static
Curves16Data* CurvesAlloc(cmsContext ContextID, int nCurves, int nElements, cmsToneCurve** G)
{
int i, j;
Curves16Data* c16;
c16 = _cmsMallocZero(ContextID, sizeof(Curves16Data));
if (c16 == NULL) return NULL;
c16 ->nCurves = nCurves;
c16 ->nElements = nElements;
c16 ->Curves = _cmsCalloc(ContextID, nCurves, sizeof(cmsUInt16Number*));
if (c16 ->Curves == NULL) return NULL;
for (i=0; i < nCurves; i++) {
c16->Curves[i] = _cmsCalloc(ContextID, nElements, sizeof(cmsUInt16Number));
if (nElements == 256) {
for (j=0; j < nElements; j++) {
c16 ->Curves[i][j] = cmsEvalToneCurve16(G[i], FROM_8_TO_16(j));
}
}
else {
for (j=0; j < nElements; j++) {
c16 ->Curves[i][j] = cmsEvalToneCurve16(G[i], (cmsUInt16Number) j);
}
}
}
return c16;
}
static
void FastEvaluateCurves8(register const cmsUInt16Number In[],
register cmsUInt16Number Out[],
register const void* D)
{
Curves16Data* Data = (Curves16Data*) D;
cmsUInt8Number x;
int i;
for (i=0; i < Data ->nCurves; i++) {
x = (In[i] >> 8);
Out[i] = Data -> Curves[i][x];
}
}
static
void FastEvaluateCurves16(register const cmsUInt16Number In[],
register cmsUInt16Number Out[],
register const void* D)
{
Curves16Data* Data = (Curves16Data*) D;
int i;
for (i=0; i < Data ->nCurves; i++) {
Out[i] = Data -> Curves[i][In[i]];
}
}
static
void FastIdentity16(register const cmsUInt16Number In[],
register cmsUInt16Number Out[],
register const void* D)
{
cmsPipeline* Lut = (cmsPipeline*) D;
cmsUInt32Number i;
for (i=0; i < Lut ->InputChannels; i++) {
Out[i] = In[i];
}
}
// If the target LUT holds only curves, the optimization procedure is to join all those
// curves together. That only works on curves and does not work on matrices.
static
cmsBool OptimizeByJoiningCurves(cmsPipeline** Lut, cmsUInt32Number Intent, cmsUInt32Number* InputFormat, cmsUInt32Number* OutputFormat, cmsUInt32Number* dwFlags)
{
cmsToneCurve** GammaTables = NULL;
cmsFloat32Number InFloat[cmsMAXCHANNELS], OutFloat[cmsMAXCHANNELS];
cmsUInt32Number i, j;
cmsPipeline* Src = *Lut;
cmsPipeline* Dest = NULL;
cmsStage* mpe;
cmsStage* ObtainedCurves = NULL;
// This is a loosy optimization! does not apply in floating-point cases
if (_cmsFormatterIsFloat(*InputFormat) || _cmsFormatterIsFloat(*OutputFormat)) return FALSE;
// Only curves in this LUT?
for (mpe = cmsPipelineGetPtrToFirstStage(Src);
mpe != NULL;
mpe = cmsStageNext(mpe)) {
if (cmsStageType(mpe) != cmsSigCurveSetElemType) return FALSE;
}
// Allocate an empty LUT
Dest = cmsPipelineAlloc(Src ->ContextID, Src ->InputChannels, Src ->OutputChannels);
if (Dest == NULL) return FALSE;
// Create target curves
GammaTables = (cmsToneCurve**) _cmsCalloc(Src ->ContextID, Src ->InputChannels, sizeof(cmsToneCurve*));
if (GammaTables == NULL) goto Error;
for (i=0; i < Src ->InputChannels; i++) {
GammaTables[i] = cmsBuildTabulatedToneCurve16(Src ->ContextID, PRELINEARIZATION_POINTS, NULL);
if (GammaTables[i] == NULL) goto Error;
}
// Compute 16 bit result by using floating point
for (i=0; i < PRELINEARIZATION_POINTS; i++) {
for (j=0; j < Src ->InputChannels; j++)
InFloat[j] = (cmsFloat32Number) ((cmsFloat64Number) i / (PRELINEARIZATION_POINTS - 1));
cmsPipelineEvalFloat(InFloat, OutFloat, Src);
for (j=0; j < Src ->InputChannels; j++)
GammaTables[j] -> Table16[i] = _cmsQuickSaturateWord(OutFloat[j] * 65535.0);
}
ObtainedCurves = cmsStageAllocToneCurves(Src ->ContextID, Src ->InputChannels, GammaTables);
if (ObtainedCurves == NULL) goto Error;
for (i=0; i < Src ->InputChannels; i++) {
cmsFreeToneCurve(GammaTables[i]);
GammaTables[i] = NULL;
}
if (GammaTables != NULL) _cmsFree(Src ->ContextID, GammaTables);
// Maybe the curves are linear at the end
if (!AllCurvesAreLinear(ObtainedCurves)) {
cmsPipelineInsertStage(Dest, cmsAT_BEGIN, ObtainedCurves);
// If the curves are to be applied in 8 bits, we can save memory
if (_cmsFormatterIs8bit(*InputFormat)) {
_cmsStageToneCurvesData* Data = (_cmsStageToneCurvesData*) ObtainedCurves ->Data;
Curves16Data* c16 = CurvesAlloc(Dest ->ContextID, Data ->nCurves, 256, Data ->TheCurves);
*dwFlags |= cmsFLAGS_NOCACHE;
_cmsPipelineSetOptimizationParameters(Dest, FastEvaluateCurves8, c16, CurvesFree, CurvesDup);
}
else {
_cmsStageToneCurvesData* Data = (_cmsStageToneCurvesData*) cmsStageData(ObtainedCurves);
Curves16Data* c16 = CurvesAlloc(Dest ->ContextID, Data ->nCurves, 65536, Data ->TheCurves);
*dwFlags |= cmsFLAGS_NOCACHE;
_cmsPipelineSetOptimizationParameters(Dest, FastEvaluateCurves16, c16, CurvesFree, CurvesDup);
}
}
else {
// LUT optimizes to nothing. Set the identity LUT
cmsStageFree(ObtainedCurves);
cmsPipelineInsertStage(Dest, cmsAT_BEGIN, cmsStageAllocIdentity(Dest ->ContextID, Src ->InputChannels));
*dwFlags |= cmsFLAGS_NOCACHE;
_cmsPipelineSetOptimizationParameters(Dest, FastIdentity16, (void*) Dest, NULL, NULL);
}
// We are done.
cmsPipelineFree(Src);
*Lut = Dest;
return TRUE;
Error:
if (ObtainedCurves != NULL) cmsStageFree(ObtainedCurves);
if (GammaTables != NULL) {
for (i=0; i < Src ->InputChannels; i++) {
if (GammaTables[i] != NULL) cmsFreeToneCurve(GammaTables[i]);
}
_cmsFree(Src ->ContextID, GammaTables);
}
if (Dest != NULL) cmsPipelineFree(Dest);
return FALSE;
cmsUNUSED_PARAMETER(Intent);
cmsUNUSED_PARAMETER(InputFormat);
cmsUNUSED_PARAMETER(OutputFormat);
cmsUNUSED_PARAMETER(dwFlags);
}
// -------------------------------------------------------------------------------------------------------------------------------------
// LUT is Shaper - Matrix - Matrix - Shaper, which is very frequent when combining two matrix-shaper profiles
static
void FreeMatShaper(cmsContext ContextID, void* Data)
{
if (Data != NULL) _cmsFree(ContextID, Data);
}
static
void* DupMatShaper(cmsContext ContextID, const void* Data)
{
return _cmsDupMem(ContextID, Data, sizeof(MatShaper8Data));
}
// A fast matrix-shaper evaluator for 8 bits. This is a bit ticky since I'm using 1.14 signed fixed point
// to accomplish some performance. Actually it takes 256x3 16 bits tables and 16385 x 3 tables of 8 bits,
// in total about 50K, and the performance boost is huge!
static
void MatShaperEval16(register const cmsUInt16Number In[],
register cmsUInt16Number Out[],
register const void* D)
{
MatShaper8Data* p = (MatShaper8Data*) D;
cmsS1Fixed14Number l1, l2, l3, r, g, b;
cmsUInt32Number ri, gi, bi;
// In this case (and only in this case!) we can use this simplification since
// In[] is assured to come from a 8 bit number. (a << 8 | a)
ri = In[0] & 0xFF;
gi = In[1] & 0xFF;
bi = In[2] & 0xFF;
// Across first shaper, which also converts to 1.14 fixed point
r = p->Shaper1R[ri];
g = p->Shaper1G[gi];
b = p->Shaper1B[bi];
// Evaluate the matrix in 1.14 fixed point
l1 = (p->Mat[0][0] * r + p->Mat[0][1] * g + p->Mat[0][2] * b + p->Off[0] + 0x2000) >> 14;
l2 = (p->Mat[1][0] * r + p->Mat[1][1] * g + p->Mat[1][2] * b + p->Off[1] + 0x2000) >> 14;
l3 = (p->Mat[2][0] * r + p->Mat[2][1] * g + p->Mat[2][2] * b + p->Off[2] + 0x2000) >> 14;
// Now we have to clip to 0..1.0 range
ri = (l1 < 0) ? 0 : ((l1 > 16384) ? 16384 : l1);
gi = (l2 < 0) ? 0 : ((l2 > 16384) ? 16384 : l2);
bi = (l3 < 0) ? 0 : ((l3 > 16384) ? 16384 : l3);
// And across second shaper,
Out[0] = p->Shaper2R[ri];
Out[1] = p->Shaper2G[gi];
Out[2] = p->Shaper2B[bi];
}
// This table converts from 8 bits to 1.14 after applying the curve
static
void FillFirstShaper(cmsS1Fixed14Number* Table, cmsToneCurve* Curve)
{
int i;
cmsFloat32Number R, y;
for (i=0; i < 256; i++) {
R = (cmsFloat32Number) (i / 255.0);
y = cmsEvalToneCurveFloat(Curve, R);
Table[i] = DOUBLE_TO_1FIXED14(y);
}
}
// This table converts form 1.14 (being 0x4000 the last entry) to 8 bits after applying the curve
static
void FillSecondShaper(cmsUInt16Number* Table, cmsToneCurve* Curve, cmsBool Is8BitsOutput)
{
int i;
cmsFloat32Number R, Val;
for (i=0; i < 16385; i++) {
R = (cmsFloat32Number) (i / 16384.0);
Val = cmsEvalToneCurveFloat(Curve, R); // Val comes 0..1.0
if (Is8BitsOutput) {
// If 8 bits output, we can optimize further by computing the / 257 part.
// first we compute the resulting byte and then we store the byte times
// 257. This quantization allows to round very quick by doing a >> 8, but
// since the low byte is always equal to msb, we can do a & 0xff and this works!
cmsUInt16Number w = _cmsQuickSaturateWord(Val * 65535.0 + 0.5);
cmsUInt8Number b = FROM_16_TO_8(w);
Table[i] = FROM_8_TO_16(b);
}
else Table[i] = _cmsQuickSaturateWord(Val * 65535.0 + 0.5);
}
}
// Compute the matrix-shaper structure
static
cmsBool SetMatShaper(cmsPipeline* Dest, cmsToneCurve* Curve1[3], cmsMAT3* Mat, cmsVEC3* Off, cmsToneCurve* Curve2[3], cmsUInt32Number* OutputFormat)
{
MatShaper8Data* p;
int i, j;
cmsBool Is8Bits = _cmsFormatterIs8bit(*OutputFormat);
// Allocate a big chuck of memory to store precomputed tables
p = (MatShaper8Data*) _cmsMalloc(Dest ->ContextID, sizeof(MatShaper8Data));
if (p == NULL) return FALSE;
p -> ContextID = Dest -> ContextID;
// Precompute tables
FillFirstShaper(p ->Shaper1R, Curve1[0]);
FillFirstShaper(p ->Shaper1G, Curve1[1]);
FillFirstShaper(p ->Shaper1B, Curve1[2]);
FillSecondShaper(p ->Shaper2R, Curve2[0], Is8Bits);
FillSecondShaper(p ->Shaper2G, Curve2[1], Is8Bits);
FillSecondShaper(p ->Shaper2B, Curve2[2], Is8Bits);
// Convert matrix to nFixed14. Note that those values may take more than 16 bits as
for (i=0; i < 3; i++) {
for (j=0; j < 3; j++) {
p ->Mat[i][j] = DOUBLE_TO_1FIXED14(Mat->v[i].n[j]);
}
}
for (i=0; i < 3; i++) {
if (Off == NULL) {
p ->Off[i] = 0;
}
else {
p ->Off[i] = DOUBLE_TO_1FIXED14(Off->n[i]);
}
}
// Mark as optimized for faster formatter
if (Is8Bits)
*OutputFormat |= OPTIMIZED_SH(1);
// Fill function pointers
_cmsPipelineSetOptimizationParameters(Dest, MatShaperEval16, (void*) p, FreeMatShaper, DupMatShaper);
return TRUE;
}
// 8 bits on input allows matrix-shaper boot up to 25 Mpixels per second on RGB. That's fast!
// TODO: Allow a third matrix for abs. colorimetric
static
cmsBool OptimizeMatrixShaper(cmsPipeline** Lut, cmsUInt32Number Intent, cmsUInt32Number* InputFormat, cmsUInt32Number* OutputFormat, cmsUInt32Number* dwFlags)
{
cmsStage* Curve1, *Curve2;
cmsStage* Matrix1, *Matrix2;
_cmsStageMatrixData* Data1;
_cmsStageMatrixData* Data2;
cmsMAT3 res;
cmsBool IdentityMat;
cmsPipeline* Dest, *Src;
// Only works on RGB to RGB
if (T_CHANNELS(*InputFormat) != 3 || T_CHANNELS(*OutputFormat) != 3) return FALSE;
// Only works on 8 bit input
if (!_cmsFormatterIs8bit(*InputFormat)) return FALSE;
// Seems suitable, proceed
Src = *Lut;
// Check for shaper-matrix-matrix-shaper structure, that is what this optimizer stands for
if (!cmsPipelineCheckAndRetreiveStages(Src, 4,
cmsSigCurveSetElemType, cmsSigMatrixElemType, cmsSigMatrixElemType, cmsSigCurveSetElemType,
&Curve1, &Matrix1, &Matrix2, &Curve2)) return FALSE;
// Get both matrices
Data1 = (_cmsStageMatrixData*) cmsStageData(Matrix1);
Data2 = (_cmsStageMatrixData*) cmsStageData(Matrix2);
// Input offset should be zero
if (Data1 ->Offset != NULL) return FALSE;
// Multiply both matrices to get the result
_cmsMAT3per(&res, (cmsMAT3*) Data2 ->Double, (cmsMAT3*) Data1 ->Double);
// Now the result is in res + Data2 -> Offset. Maybe is a plain identity?
IdentityMat = FALSE;
if (_cmsMAT3isIdentity(&res) && Data2 ->Offset == NULL) {
// We can get rid of full matrix
IdentityMat = TRUE;
}
// Allocate an empty LUT
Dest = cmsPipelineAlloc(Src ->ContextID, Src ->InputChannels, Src ->OutputChannels);
if (!Dest) return FALSE;
// Assamble the new LUT
cmsPipelineInsertStage(Dest, cmsAT_BEGIN, cmsStageDup(Curve1));
if (!IdentityMat)
cmsPipelineInsertStage(Dest, cmsAT_END, cmsStageAllocMatrix(Dest ->ContextID, 3, 3, (const cmsFloat64Number*) &res, Data2 ->Offset));
cmsPipelineInsertStage(Dest, cmsAT_END, cmsStageDup(Curve2));
// If identity on matrix, we can further optimize the curves, so call the join curves routine
if (IdentityMat) {
OptimizeByJoiningCurves(&Dest, Intent, InputFormat, OutputFormat, dwFlags);
}
else {
_cmsStageToneCurvesData* mpeC1 = (_cmsStageToneCurvesData*) cmsStageData(Curve1);
_cmsStageToneCurvesData* mpeC2 = (_cmsStageToneCurvesData*) cmsStageData(Curve2);
// In this particular optimization, cach<63> does not help as it takes more time to deal with
// the cach<63> that with the pixel handling
*dwFlags |= cmsFLAGS_NOCACHE;
// Setup the optimizarion routines
SetMatShaper(Dest, mpeC1 ->TheCurves, &res, (cmsVEC3*) Data2 ->Offset, mpeC2->TheCurves, OutputFormat);
}
cmsPipelineFree(Src);
*Lut = Dest;
return TRUE;
}
// -------------------------------------------------------------------------------------------------------------------------------------
// Optimization plug-ins
// List of optimizations
typedef struct _cmsOptimizationCollection_st {
_cmsOPToptimizeFn OptimizePtr;
struct _cmsOptimizationCollection_st *Next;
} _cmsOptimizationCollection;
// The built-in list. We currently implement 4 types of optimizations. Joining of curves, matrix-shaper, linearization and resampling
static _cmsOptimizationCollection DefaultOptimization[] = {
{ OptimizeByJoiningCurves, &DefaultOptimization[1] },
{ OptimizeMatrixShaper, &DefaultOptimization[2] },
{ OptimizeByComputingLinearization, &DefaultOptimization[3] },
{ OptimizeByResampling, NULL }
};
// The linked list head
static _cmsOptimizationCollection* OptimizationCollection = DefaultOptimization;
// Register new ways to optimize
cmsBool _cmsRegisterOptimizationPlugin(cmsPluginBase* Data)
{
cmsPluginOptimization* Plugin = (cmsPluginOptimization*) Data;
_cmsOptimizationCollection* fl;
if (Data == NULL) {
OptimizationCollection = DefaultOptimization;
return TRUE;
}
// Optimizer callback is required
if (Plugin ->OptimizePtr == NULL) return FALSE;
fl = (_cmsOptimizationCollection*) _cmsPluginMalloc(sizeof(_cmsOptimizationCollection));
if (fl == NULL) return FALSE;
// Copy the parameters
fl ->OptimizePtr = Plugin ->OptimizePtr;
// Keep linked list
fl ->Next = OptimizationCollection;
OptimizationCollection = fl;
// All is ok
return TRUE;
}
// The entry point for LUT optimization
cmsBool _cmsOptimizePipeline(cmsPipeline** PtrLut,
int Intent,
cmsUInt32Number* InputFormat,
cmsUInt32Number* OutputFormat,
cmsUInt32Number* dwFlags)
{
_cmsOptimizationCollection* Opts;
cmsBool AnySuccess = FALSE;
// A CLUT is being asked, so force this specific optimization
if (*dwFlags & cmsFLAGS_FORCE_CLUT) {
PreOptimize(*PtrLut);
return OptimizeByResampling(PtrLut, Intent, InputFormat, OutputFormat, dwFlags);
}
// Anything to optimize?
if ((*PtrLut) ->Elements == NULL) {
_cmsPipelineSetOptimizationParameters(*PtrLut, FastIdentity16, (void*) *PtrLut, NULL, NULL);
return TRUE;
}
// Try to get rid of identities and trivial conversions.
AnySuccess = PreOptimize(*PtrLut);
// After removal do we end with an identity?
if ((*PtrLut) ->Elements == NULL) {
_cmsPipelineSetOptimizationParameters(*PtrLut, FastIdentity16, (void*) *PtrLut, NULL, NULL);
return TRUE;
}
// Do not optimize, keep all precision
if (*dwFlags & cmsFLAGS_NOOPTIMIZE)
return FALSE;
// Try built-in optimizations and plug-in
for (Opts = OptimizationCollection;
Opts != NULL;
Opts = Opts ->Next) {
// If one schema succeeded, we are done
if (Opts ->OptimizePtr(PtrLut, Intent, InputFormat, OutputFormat, dwFlags)) {
return TRUE; // Optimized!
}
}
// Only simple optimizations succeeded
return AnySuccess;
}