static
int ComputeTables(LPGAMMATABLE Table[3], LPWORD Out[3], LPL16PARAMS p16)
{
int i, AllLinear;
cmsCalcL16Params(Table[0] -> nEntries, p16);
AllLinear = 0;
for (i=0; i < 3; i++)
{
LPWORD PtrW;
PtrW = (LPWORD) _cmsMalloc(sizeof(WORD) * p16 -> nSamples);
if (PtrW == NULL) return -1; // Signal error
CopyMemory(PtrW, Table[i] -> GammaTable, sizeof(WORD) * Table[i] -> nEntries);
Out[i] = PtrW; // Set table pointer
// Linear after all?
AllLinear += cmsIsLinear(PtrW, p16 -> nSamples);
}
// If is all linear, then supress table interpolation (this
// will speed greately some trivial operations.
// Return 1 if present, 0 if all linear
if (AllLinear != 3) return 1;
return 0;
}
LPMATSHAPER cmsAllocMatShaper(LPMAT3 Matrix, LPGAMMATABLE Tables[], DWORD Behaviour)
{
LPMATSHAPER NewMatShaper;
int i, AllLinear;
NewMatShaper = (LPMATSHAPER) _cmsMalloc(sizeof(MATSHAPER));
if (NewMatShaper)
ZeroMemory(NewMatShaper, sizeof(MATSHAPER));
NewMatShaper->dwFlags = Behaviour & (MATSHAPER_ALLSMELTED);
// Fill matrix part
MAT3toFix(&NewMatShaper -> Matrix, Matrix);
// Reality check
if (!MAT3isIdentity(&NewMatShaper -> Matrix, 0.00001))
NewMatShaper -> dwFlags |= MATSHAPER_HASMATRIX;
// Now, on the table characteristics
cmsCalcL16Params(Tables[0] -> nEntries, &NewMatShaper -> p16);
// Copy tables
AllLinear = 0;
for (i=0; i < 3; i++)
{
LPWORD PtrW;
PtrW = (LPWORD) _cmsMalloc(sizeof(WORD) * NewMatShaper -> p16.nSamples);
if (PtrW == NULL) {
cmsFreeMatShaper(NewMatShaper);
return NULL;
}
CopyMemory(PtrW, Tables[i] -> GammaTable,
sizeof(WORD) * Tables[i] -> nEntries);
NewMatShaper -> L[i] = PtrW; // Set table pointer
// Linear after all?
AllLinear += cmsIsLinear(PtrW, NewMatShaper -> p16.nSamples);
}
// If is all linear, then supress table interpolation (this
// will speed greately some trivial operations
if (AllLinear != 3)
NewMatShaper -> dwFlags |= MATSHAPER_HASSHAPER;
return NewMatShaper;
}
void cmsCalcCLUT16ParamsEx(int nSamples, int InputChan, int OutputChan,
LCMSBOOL lUseTetrahedral, LPL16PARAMS p)
{
int clutPoints;
cmsCalcL16Params(nSamples, p);
p -> nInputs = InputChan;
p -> nOutputs = OutputChan;
clutPoints = p -> Domain + 1;
p -> opta1 = p -> nOutputs; // Z
p -> opta2 = p -> opta1 * clutPoints; // Y
p -> opta3 = p -> opta2 * clutPoints; // X
p -> opta4 = p -> opta3 * clutPoints; // Used only in 4 inputs LUT
p -> opta5 = p -> opta4 * clutPoints; // Used only in 5 inputs LUT
p -> opta6 = p -> opta5 * clutPoints; // Used only on 6 inputs LUT
p -> opta7 = p -> opta6 * clutPoints; // Used only on 7 inputs LUT
p -> opta8 = p -> opta7 * clutPoints; // Used only on 8 inputs LUT
switch (InputChan) {
case 1: // Gray LUT
p ->Interp3D = Eval1Input;
break;
case 3: // RGB et al
if (lUseTetrahedral) {
p ->Interp3D = cmsTetrahedralInterp16;
}
else
p ->Interp3D = cmsTrilinearInterp16;
break;
case 4: // CMYK LUT
p ->Interp3D = Eval4Inputs;
break;
case 5: // 5 Inks
p ->Interp3D = Eval5Inputs;
break;
case 6: // 6 Inks
p -> Interp3D = Eval6Inputs;
break;
case 7: // 7 inks
p ->Interp3D = Eval7Inputs;
break;
case 8: // 8 inks
p ->Interp3D = Eval8Inputs;
break;
default:
cmsSignalError(LCMS_ERRC_ABORTED, "Unsupported restoration (%d channels)", InputChan);
}
}
LPLUT LCMSEXPORT cmsAllocLinearTable(LPLUT NewLUT, LPGAMMATABLE Tables[], int nTable)
{
unsigned int i;
LPWORD PtrW;
switch (nTable) {
case 1: NewLUT -> wFlags |= LUT_HASTL1;
cmsCalcL16Params(Tables[0] -> nEntries, &NewLUT -> In16params);
NewLUT -> InputEntries = Tables[0] -> nEntries;
for (i=0; i < NewLUT -> InputChan; i++) {
PtrW = (LPWORD) malloc(sizeof(WORD) * NewLUT -> InputEntries);
NewLUT -> L1[i] = PtrW;
CopyMemory(PtrW, Tables[i]->GammaTable, sizeof(WORD) * NewLUT -> InputEntries);
CopyMemory(&NewLUT -> LCurvesSeed[0][i], &Tables[i] -> Seed, sizeof(LCMSGAMMAPARAMS));
}
break;
case 2: NewLUT -> wFlags |= LUT_HASTL2;
cmsCalcL16Params(Tables[0] -> nEntries, &NewLUT -> Out16params);
NewLUT -> OutputEntries = Tables[0] -> nEntries;
for (i=0; i < NewLUT -> OutputChan; i++) {
PtrW = (LPWORD) malloc(sizeof(WORD) * NewLUT -> OutputEntries);
NewLUT -> L2[i] = PtrW;
CopyMemory(PtrW, Tables[i]->GammaTable, sizeof(WORD) * NewLUT -> OutputEntries);
CopyMemory(&NewLUT -> LCurvesSeed[1][i], &Tables[i] -> Seed, sizeof(LCMSGAMMAPARAMS));
}
break;
// 3 & 4 according ICC 4.0 spec
case 3:
NewLUT -> wFlags |= LUT_HASTL3;
cmsCalcL16Params(Tables[0] -> nEntries, &NewLUT -> L3params);
NewLUT -> L3Entries = Tables[0] -> nEntries;
for (i=0; i < NewLUT -> InputChan; i++) {
PtrW = (LPWORD) malloc(sizeof(WORD) * NewLUT -> L3Entries);
NewLUT -> L3[i] = PtrW;
CopyMemory(PtrW, Tables[i]->GammaTable, sizeof(WORD) * NewLUT -> L3Entries);
CopyMemory(&NewLUT -> LCurvesSeed[2][i], &Tables[i] -> Seed, sizeof(LCMSGAMMAPARAMS));
}
break;
case 4:
NewLUT -> wFlags |= LUT_HASTL4;
cmsCalcL16Params(Tables[0] -> nEntries, &NewLUT -> L4params);
NewLUT -> L4Entries = Tables[0] -> nEntries;
for (i=0; i < NewLUT -> OutputChan; i++) {
PtrW = (LPWORD) malloc(sizeof(WORD) * NewLUT -> L4Entries);
NewLUT -> L4[i] = PtrW;
CopyMemory(PtrW, Tables[i]->GammaTable, sizeof(WORD) * NewLUT -> L4Entries);
CopyMemory(&NewLUT -> LCurvesSeed[3][i], &Tables[i] -> Seed, sizeof(LCMSGAMMAPARAMS));
}
break;
default:;
}
return NewLUT;
}
