modules/lcms/src/cmsps2.c

   1 //
   2 //  Little cms
   3 //  Copyright (C) 1998-2007 Marti Maria
   4 //
   5 // Permission is hereby granted, free of charge, to any person obtaining
   6 // a copy of this software and associated documentation files (the "Software"),
   7 // to deal in the Software without restriction, including without limitation
   8 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9 // and/or sell copies of the Software, and to permit persons to whom the Software
  10 // is furnished to do so, subject to the following conditions:
  11 //
  12 // The above copyright notice and this permission notice shall be included in
  13 // all copies or substantial portions of the Software.
  14 //
  15 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  16 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
  17 // THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  18 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  19 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  20 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  21 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  22
  23
  24 // Postscript level 2 operators
  25
  26
  27
  28 #include "lcms.h"
  29 #include <time.h>
  30 #include <stdarg.h>
  31
  32 // PostScript ColorRenderingDictionary and ColorSpaceArray
  33
  34 LCMSAPI DWORD LCMSEXPORT cmsGetPostScriptCSA(cmsHPROFILE hProfile, int Intent, LPVOID Buffer, DWORD dwBufferLen);
  35 LCMSAPI DWORD LCMSEXPORT cmsGetPostScriptCRD(cmsHPROFILE hProfile, int Intent, LPVOID Buffer, DWORD dwBufferLen);
  36 LCMSAPI DWORD LCMSEXPORT cmsGetPostScriptCRDEx(cmsHPROFILE hProfile, int Intent, DWORD dwFlags, LPVOID Buffer, DWORD dwBufferLen);
  37 // -------------------------------------------------------------------- Implementation
  38
  39 #define MAXPSCOLS   60      // Columns on tables
  40
  41 /*
  42     Implementation
  43     --------------
  44
  45   PostScript does use XYZ as its internal PCS. But since PostScript
  46   interpolation tables are limited to 8 bits, I use Lab as a way to
  47   improve the accuracy, favoring perceptual results. So, for the creation
  48   of each CRD, CSA the profiles are converted to Lab via a device
  49   link between  profile -> Lab or Lab -> profile. The PS code necessary to
  50   convert Lab <-> XYZ is also included.
  51
  52
  53
  54   Color Space Arrays (CSA)
  55   ==================================================================================
  56
  57   In order to obtain precission, code chooses between three ways to implement
  58   the device -> XYZ transform. These cases identifies monochrome profiles (often
  59   implemented as a set of curves), matrix-shaper and LUT-based.
  60
  61   Monochrome
  62   -----------
  63
  64   This is implemented as /CIEBasedA CSA. The prelinearization curve is
  65   placed into /DecodeA section, and matrix equals to D50. Since here is
  66   no interpolation tables, I do the conversion directly to XYZ
  67
  68   NOTE: CLUT-based monochrome profiles are NOT supported. So, cmsFLAGS_MATRIXINPUT
  69   flag is forced on such profiles.
  70
  71     [ /CIEBasedA
  72       <<
  73             /DecodeA { transfer function } bind
  74             /MatrixA [D50]
  75             /RangeLMN [ 0.0 D50X 0.0 D50Y 0.0 D50Z ]
  76             /WhitePoint [D50]
  77             /BlackPoint [BP]
  78             /RenderingIntent (intent)
  79       >>
  80     ]
  81
  82    On simpler profiles, the PCS is already XYZ, so no conversion is required.
  83
  84
  85    Matrix-shaper based
  86    -------------------
  87
  88    This is implemented both with /CIEBasedABC or /CIEBasedDEF on dependig
  89    of profile implementation. Since here is no interpolation tables, I do
  90    the conversion directly to XYZ
  91
  92
  93
  94     [ /CIEBasedABC
  95             <<
  96                 /DecodeABC [ {transfer1} {transfer2} {transfer3} ]
  97                 /MatrixABC [Matrix]
  98                 /RangeLMN [ 0.0 D50X 0.0 D50Y 0.0 D50Z ]
  99                 /DecodeLMN [ { / 2} dup dup ]
 100                 /WhitePoint [D50]
 101                 /BlackPoint [BP]
 102                 /RenderingIntent (intent)
 103             >>
 104     ]
 105
 106
 107     CLUT based
 108     ----------
 109
 110      Lab is used in such cases.
 111
 112     [ /CIEBasedDEF
 113             <<
 114             /DecodeDEF [ <prelinearization> ]
 115             /Table [ p p p [<...>]]
 116             /RangeABC [ 0 1 0 1 0 1]
 117             /DecodeABC[ <postlinearization> ]
 118             /RangeLMN [ -0.236 1.254 0 1 -0.635 1.640 ]
 119                % -128/500 1+127/500 0 1  -127/200 1+128/200
 120             /MatrixABC [ 1 1 1 1 0 0 0 0 -1]
 121             /WhitePoint [D50]
 122             /BlackPoint [BP]
 123             /RenderingIntent (intent)
 124     ]
 125
 126
 127   Color Rendering Dictionaries (CRD)
 128   ==================================
 129   These are always implemented as CLUT, and always are using Lab. Since CRD are expected to
 130   be used as resources, the code adds the definition as well.
 131
 132   <<
 133     /ColorRenderingType 1
 134     /WhitePoint [ D50 ]
 135     /BlackPoint [BP]
 136     /MatrixPQR [ Bradford ]
 137     /RangePQR [-0.125 1.375 -0.125 1.375 -0.125 1.375 ]
 138     /TransformPQR [
 139     {4 index 3 get div 2 index 3 get mul exch pop exch pop exch pop exch pop } bind
 140     {4 index 4 get div 2 index 4 get mul exch pop exch pop exch pop exch pop } bind
 141     {4 index 5 get div 2 index 5 get mul exch pop exch pop exch pop exch pop } bind
 142     ]
 143     /MatrixABC <...>
 144     /EncodeABC <...>
 145     /RangeABC  <.. used for  XYZ -> Lab>
 146     /EncodeLMN
 147     /RenderTable [ p p p [<...>]]
 148
 149     /RenderingIntent (Perceptual)
 150   >>
 151   /Current exch /ColorRendering defineresource pop
 152
 153
 154   The following stages are used to convert from XYZ to Lab
 155   --------------------------------------------------------
 156
 157   Input is given at LMN stage on X, Y, Z
 158
 159   Encode LMN gives us f(X/Xn), f(Y/Yn), f(Z/Zn)
 160
 161   /EncodeLMN [
 162
 163     { 0.964200  div dup 0.008856 le {7.787 mul 16 116 div add}{1 3 div exp} ifelse } bind
 164     { 1.000000  div dup 0.008856 le {7.787 mul 16 116 div add}{1 3 div exp} ifelse } bind
 165     { 0.824900  div dup 0.008856 le {7.787 mul 16 116 div add}{1 3 div exp} ifelse } bind
 166
 167     ]
 168
 169
 170   MatrixABC is used to compute f(Y/Yn), f(X/Xn) - f(Y/Yn), f(Y/Yn) - f(Z/Zn)
 171
 172   | 0  1  0|
 173   | 1 -1  0|
 174   | 0  1 -1|
 175
 176   /MatrixABC [ 0 1 0 1 -1 1 0 0 -1 ]
 177
 178  EncodeABC finally gives Lab values.
 179
 180   /EncodeABC [
 181     { 116 mul  16 sub 100 div  } bind
 182     { 500 mul 128 add 255 div  } bind
 183     { 200 mul 128 add 255 div  } bind
 184     ]
 185
 186   The following stages are used to convert Lab to XYZ
 187   ----------------------------------------------------
 188
 189     /RangeABC [ 0 1 0 1 0 1]
 190     /DecodeABC [ { 100 mul 16 add 116 div } bind
 191                  { 255 mul 128 sub 500 div } bind
 192                  { 255 mul 128 sub 200 div } bind
 193                ]
 194
 195     /MatrixABC [ 1 1 1 1 0 0 0 0 -1]
 196     /DecodeLMN [
 197                 {dup 6 29 div ge {dup dup mul mul} {4 29 div sub 108 841 div mul} ifelse 0.964200 mul} bind
 198                 {dup 6 29 div ge {dup dup mul mul} {4 29 div sub 108 841 div mul} ifelse } bind
 199                 {dup 6 29 div ge {dup dup mul mul} {4 29 div sub 108 841 div mul} ifelse 0.824900 mul} bind
 200                 ]
 201
 202
 203 */
 204
 205 /*
 206
 207  PostScript algorithms discussion.
 208  =========================================================================================================
 209
 210   1D interpolation algorithm
 211
 212
 213   1D interpolation (float)
 214   ------------------------
 215
 216     val2 = Domain * Value;
 217
 218     cell0 = (int) floor(val2);
 219     cell1 = (int) ceil(val2);
 220
 221     rest = val2 - cell0;
 222
 223     y0 = LutTable[cell0] ;
 224     y1 = LutTable[cell1] ;
 225
 226     y = y0 + (y1 - y0) * rest;
 227
 228
 229
 230   PostScript code                   Stack
 231   ================================================
 232
 233   {                                 % v
 234     <check 0..1.0>
 235     [array]                         % v tab
 236     dup                             % v tab tab
 237     length 1 sub                    % v tab dom
 238
 239     3 -1 roll                       % tab dom v
 240
 241     mul                             % tab val2
 242     dup                             % tab val2 val2
 243     dup                             % tab val2 val2 val2
 244     floor cvi                       % tab val2 val2 cell0
 245     exch                            % tab val2 cell0 val2
 246     ceiling cvi                     % tab val2 cell0 cell1
 247
 248     3 index                         % tab val2 cell0 cell1 tab
 249     exch                            % tab val2 cell0 tab cell1
 250     get                             % tab val2 cell0 y1
 251
 252     4 -1 roll                       % val2 cell0 y1 tab
 253     3 -1 roll                       % val2 y1 tab cell0
 254     get                             % val2 y1 y0
 255
 256     dup                             % val2 y1 y0 y0
 257     3 1 roll                        % val2 y0 y1 y0
 258
 259     sub                             % val2 y0 (y1-y0)
 260     3 -1 roll                       % y0 (y1-y0) val2
 261     dup                             % y0 (y1-y0) val2 val2
 262     floor cvi                       % y0 (y1-y0) val2 floor(val2)
 263     sub                             % y0 (y1-y0) rest
 264     mul                             % y0 t1
 265     add                             % y
 266     65535 div                       % result
 267
 268   } bind
 269
 270
 271 */
 272
 273 static icTagSignature Device2PCSTab[] = {icSigAToB0Tag,       // Perceptual
 274                                          icSigAToB1Tag,       // Relative colorimetric
 275                                          icSigAToB2Tag,       // Saturation
 276                                          icSigAToB1Tag };     // Absolute colorimetric
 277                                                            // (Relative/WhitePoint)
 278
 279
 280 // --------------------------------------------------------------- Memory Stream
 281 //
 282 // This struct holds the memory block currently being write
 283 //
 284
 285 typedef struct {
 286                 LPBYTE Block;
 287                 LPBYTE Ptr;
 288                 DWORD  dwMax;
 289                 DWORD  dwUsed;
 290                 int    MaxCols;
 291                 int    Col;
 292                 int    HasError;
 293
 294             } MEMSTREAM, FAR* LPMEMSTREAM;
 295
 296
 297 typedef struct {
 298                 LPLUT Lut;
 299                 LPMEMSTREAM m;
 300
 301                 int FirstComponent;
 302                 int SecondComponent;
 303
 304                 int   bps;
 305                 const char* PreMaj;
 306                 const char* PostMaj;
 307                 const char* PreMin;
 308                 const char* PostMin;
 309
 310                 int  lIsInput;    // Handle L* encoding
 311                 int  FixWhite;    // Force mapping of pure white
 312
 313                 icColorSpaceSignature  ColorSpace;  // ColorSpace of profile
 314
 315
 316             } SAMPLERCARGO, FAR* LPSAMPLERCARGO;
 317
 318
 319 // Creates a ready to use memory stream
 320 static
 321 LPMEMSTREAM CreateMemStream(LPBYTE Buffer, DWORD dwMax, int MaxCols)
 322 {
 323     LPMEMSTREAM m = (LPMEMSTREAM) _cmsMalloc(sizeof(MEMSTREAM));
 324     if (m == NULL) return NULL;
 325
 326     ZeroMemory(m, sizeof(MEMSTREAM));
 327
 328     m -> Block   = m -> Ptr = Buffer;
 329     m -> dwMax   = dwMax;
 330     m -> dwUsed  = 0;
 331     m -> MaxCols = MaxCols;
 332     m -> Col     = 0;
 333     m -> HasError = 0;
 334
 335     return m;
 336 }
 337
 338
 339
 340 // Convert to byte
 341 static
 342 BYTE Word2Byte(WORD w)
 343 {
 344     return (BYTE) floor((double) w / 257.0 + 0.5);
 345 }
 346
 347
 348 // Convert to byte (using ICC2 notation)
 349
 350 static
 351 BYTE L2Byte(WORD w)
 352 {
 353         int ww = w + 0x0080;
 354
 355         if (ww > 0xFFFF) return 0xFF;
 356
 357     return (BYTE) ((WORD) (ww >> 8) & 0xFF);
 358 }
 359
 360 // Write a raw, uncooked byte. Check for space
 361 static
 362 void WriteRawByte(LPMEMSTREAM m, BYTE b)
 363 {
 364     if (m -> dwUsed + 1 > m -> dwMax) {
 365         m -> HasError = 1;
 366     }
 367
 368     if (!m ->HasError && m ->Block) {
 369         *m ->Ptr++ = b;
 370     }
 371
 372     m -> dwUsed++;
 373 }
 374
 375 // Write a cooked byte
 376 static
 377 void WriteByte(LPMEMSTREAM m, BYTE b)
 378 {
 379     static const BYTE Hex[] = "0123456789ABCDEF";
 380     BYTE c;
 381
 382         c = Hex[(b >> 4) & 0x0f];
 383         WriteRawByte(m, c);
 384
 385         c = Hex[b & 0x0f];
 386         WriteRawByte(m, c);
 387
 388         m -> Col += 2;
 389
 390         if (m -> Col > m -> MaxCols) {
 391
 392             WriteRawByte(m, '\n');
 393             m -> Col = 0;
 394         }
 395
 396 }
 397
 398 // Does write a formatted string. Guaranteed to be 2048 bytes at most.
 399 static
 400 void Writef(LPMEMSTREAM m, const char *frm, ...)
 401 {
 402         va_list args;
 403         LPBYTE pt;
 404         BYTE Buffer[2048];
 405
 406         va_start(args, frm);
 407
 408         vsnprintf((char*) Buffer, 2048, frm, args);
 409
 410         for (pt = Buffer; *pt; pt++)  {
 411
 412             WriteRawByte(m, *pt);
 413         }
 414
 415         va_end(args);
 416 }
 417
 418
 419
 420 // ----------------------------------------------------------------- PostScript generation
 421
 422
 423 // Removes offending Carriage returns
 424 static
 425 char* RemoveCR(const char* txt)
 426 {
 427     static char Buffer[2048];
 428     char* pt;
 429
 430     strncpy(Buffer, txt, 2047);
 431     Buffer[2047] = 0;
 432     for (pt = Buffer; *pt; pt++)
 433             if (*pt == '\n' || *pt == '\r') *pt = ' ';
 434
 435     return Buffer;
 436
 437 }
 438
 439 static
 440 void EmitHeader(LPMEMSTREAM m, const char* Title, cmsHPROFILE hProfile)
 441 {
 442
 443     time_t timer;
 444
 445     time(&timer);
 446
 447     Writef(m, "%%!PS-Adobe-3.0\n");
 448     Writef(m, "%%\n");
 449     Writef(m, "%% %s\n", Title);
 450     Writef(m, "%% Source: %s\n", RemoveCR(cmsTakeProductName(hProfile)));
 451     Writef(m, "%% Description: %s\n", RemoveCR(cmsTakeProductDesc(hProfile)));
 452     Writef(m, "%% Created: %s", ctime(&timer)); // ctime appends a \n!!!
 453     Writef(m, "%%\n");
 454     Writef(m, "%%%%BeginResource\n");
 455
 456 }
 457
 458
 459 // Emits White & Black point. White point is always D50, Black point is the device
 460 // Black point adapted to D50.
 461
 462 static
 463 void EmitWhiteBlackD50(LPMEMSTREAM m, LPcmsCIEXYZ BlackPoint)
 464 {
 465
 466     Writef(m, "/BlackPoint [%f %f %f]\n", BlackPoint -> X,
 467                                           BlackPoint -> Y,
 468                                           BlackPoint -> Z);
 469
 470     Writef(m, "/WhitePoint [%f %f %f]\n", cmsD50_XYZ()->X,
 471                                           cmsD50_XYZ()->Y,
 472                                           cmsD50_XYZ()->Z);
 473 }
 474
 475
 476 static
 477 void EmitRangeCheck(LPMEMSTREAM m)
 478 {
 479     Writef(m, "dup 0.0 lt { pop 0.0 } if "
 480               "dup 1.0 gt { pop 1.0 } if ");
 481
 482 }
 483
 484 // Does write the intent
 485
 486 static
 487 void EmitIntent(LPMEMSTREAM m, int RenderingIntent)
 488 {
 489     const char *intent;
 490
 491     switch (RenderingIntent) {
 492
 493         case INTENT_PERCEPTUAL:            intent = "Perceptual"; break;
 494         case INTENT_RELATIVE_COLORIMETRIC: intent = "RelativeColorimetric"; break;
 495         case INTENT_ABSOLUTE_COLORIMETRIC: intent = "AbsoluteColorimetric"; break;
 496         case INTENT_SATURATION:            intent = "Saturation"; break;
 497
 498         default: intent = "Undefined"; break;
 499     }
 500
 501     Writef(m, "/RenderingIntent (%s)\n", intent );
 502 }
 503
 504 //
 505 //  Convert L* to Y
 506 //
 507 //      Y = Yn*[ (L* + 16) / 116] ^ 3   if (L*) >= 6 / 29
 508 //        = Yn*( L* / 116) / 7.787      if (L*) < 6 / 29
 509 //
 510
 511 /*
 512 static
 513 void EmitL2Y(LPMEMSTREAM m)
 514 {
 515     Writef(m,
 516             "{ "
 517                 "100 mul 16 add 116 div "               // (L * 100 + 16) / 116
 518                  "dup 6 29 div ge "                     // >= 6 / 29 ?
 519                  "{ dup dup mul mul } "                 // yes, ^3 and done
 520                  "{ 4 29 div sub 108 841 div mul } "    // no, slope limiting
 521             "ifelse } bind ");
 522 }
 523 */
 524
 525
 526 // Lab -> XYZ, see the discussion above
 527
 528 static
 529 void EmitLab2XYZ(LPMEMSTREAM m)
 530 {
 531     Writef(m, "/RangeABC [ 0 1 0 1 0 1]\n");
 532     Writef(m, "/DecodeABC [\n");
 533     Writef(m, "{100 mul  16 add 116 div } bind\n");
 534     Writef(m, "{255 mul 128 sub 500 div } bind\n");
 535     Writef(m, "{255 mul 128 sub 200 div } bind\n");
 536     Writef(m, "]\n");
 537     Writef(m, "/MatrixABC [ 1 1 1 1 0 0 0 0 -1]\n");
 538         Writef(m, "/RangeLMN [ -0.236 1.254 0 1 -0.635 1.640 ]\n");
 539     Writef(m, "/DecodeLMN [\n");
 540     Writef(m, "{dup 6 29 div ge {dup dup mul mul} {4 29 div sub 108 841 div mul} ifelse 0.964200 mul} bind\n");
 541     Writef(m, "{dup 6 29 div ge {dup dup mul mul} {4 29 div sub 108 841 div mul} ifelse } bind\n");
 542     Writef(m, "{dup 6 29 div ge {dup dup mul mul} {4 29 div sub 108 841 div mul} ifelse 0.824900 mul} bind\n");
 543     Writef(m, "]\n");
 544 }
 545
 546
 547
 548 // Outputs a table of words. It does use 16 bits
 549
 550 static
 551 void Emit1Gamma(LPMEMSTREAM m, LPWORD Table, int nEntries)
 552 {
 553     int i;
 554     double gamma;
 555
 556
 557     if (nEntries <= 0) return;  // Empty table
 558
 559     // Suppress whole if identity
 560     if (cmsIsLinear(Table, nEntries)) return;
 561
 562     // Check if is really an exponential. If so, emit "exp"
 563      gamma = cmsEstimateGammaEx(Table, nEntries, 0.001);
 564      if (gamma > 0) {
 565             Writef(m, "{ %g exp } bind ", gamma);
 566             return;
 567      }
 568
 569     Writef(m, "{ ");
 570
 571     // Bounds check
 572     EmitRangeCheck(m);
 573
 574     // Emit intepolation code
 575
 576     // PostScript code                      Stack
 577     // ===============                      ========================
 578                                             // v
 579     Writef(m, " [");
 580
 581     // TODO: Check for endianess!!!
 582
 583     for (i=0; i < nEntries; i++) {
 584             Writef(m, "%d ", Table[i]);
 585     }
 586
 587     Writef(m, "] ");                        // v tab
 588
 589     Writef(m, "dup ");                      // v tab tab
 590     Writef(m, "length 1 sub ");             // v tab dom
 591     Writef(m, "3 -1 roll ");                // tab dom v
 592     Writef(m, "mul ");                      // tab val2
 593     Writef(m, "dup ");                      // tab val2 val2
 594     Writef(m, "dup ");                      // tab val2 val2 val2
 595     Writef(m, "floor cvi ");                // tab val2 val2 cell0
 596     Writef(m, "exch ");                     // tab val2 cell0 val2
 597     Writef(m, "ceiling cvi ");              // tab val2 cell0 cell1
 598     Writef(m, "3 index ");                  // tab val2 cell0 cell1 tab
 599     Writef(m, "exch ");                     // tab val2 cell0 tab cell1
 600     Writef(m, "get ");                      // tab val2 cell0 y1
 601     Writef(m, "4 -1 roll ");                // val2 cell0 y1 tab
 602     Writef(m, "3 -1 roll ");                // val2 y1 tab cell0
 603     Writef(m, "get ");                      // val2 y1 y0
 604     Writef(m, "dup ");                      // val2 y1 y0 y0
 605     Writef(m, "3 1 roll ");                 // val2 y0 y1 y0
 606     Writef(m, "sub ");                      // val2 y0 (y1-y0)
 607     Writef(m, "3 -1 roll ");                // y0 (y1-y0) val2
 608     Writef(m, "dup ");                      // y0 (y1-y0) val2 val2
 609     Writef(m, "floor cvi ");                // y0 (y1-y0) val2 floor(val2)
 610     Writef(m, "sub ");                      // y0 (y1-y0) rest
 611     Writef(m, "mul ");                      // y0 t1
 612     Writef(m, "add ");                      // y
 613     Writef(m, "65535 div ");                // result
 614
 615     Writef(m, " } bind ");
 616 }
 617
 618
 619 // Compare gamma table
 620
 621 static
 622 LCMSBOOL GammaTableEquals(LPWORD g1, LPWORD g2, int nEntries)
 623 {
 624     return memcmp(g1, g2, nEntries* sizeof(WORD)) == 0;
 625 }
 626
 627
 628 // Does write a set of gamma curves
 629
 630 static
 631 void EmitNGamma(LPMEMSTREAM m, int n, LPWORD g[], int nEntries)
 632 {
 633     int i;
 634
 635     for( i=0; i < n; i++ )
 636     {
 637         if (i > 0 && GammaTableEquals(g[i-1], g[i], nEntries)) {
 638
 639             Writef(m, "dup ");
 640         }
 641         else {
 642             Emit1Gamma(m, g[i], nEntries);
 643         }
 644     }
 645
 646 }
 647
 648
 649 // Check whatever a profile has CLUT tables (only on input)
 650
 651 static
 652 LCMSBOOL IsLUTbased(cmsHPROFILE hProfile, int Intent)
 653 {
 654     icTagSignature Tag;
 655
 656     // Check if adequate tag is present
 657     Tag = Device2PCSTab[Intent];
 658
 659     if (cmsIsTag(hProfile, Tag)) return 1;
 660
 661     // If not present, revert to default (perceptual)
 662     Tag = icSigAToB0Tag;
 663
 664     // If no tag present, try matrix-shaper
 665     return cmsIsTag(hProfile, Tag);
 666 }
 667
 668
 669
 670 // Following code dumps a LUT onto memory stream
 671
 672
 673 // This is the sampler. Intended to work in SAMPLER_INSPECT mode,
 674 // that is, the callback will be called for each knot with
 675 //
 676 //          In[]  The grid location coordinates, normalized to 0..ffff
 677 //          Out[] The LUT values, normalized to 0..ffff
 678 //
 679 //  Returning a value other than 0 does terminate the sampling process
 680 //
 681 //  Each row contains LUT values for all but first component. So, I
 682 //  detect row changing by keeping a copy of last value of first
 683 //  component. -1 is used to mark begining of whole block.
 684
 685 static
 686 int OutputValueSampler(register WORD In[], register WORD Out[], register LPVOID Cargo)
 687 {
 688     LPSAMPLERCARGO sc = (LPSAMPLERCARGO) Cargo;
 689     unsigned int i;
 690
 691
 692     if (sc -> FixWhite) {
 693
 694         if (In[0] == 0xFFFF) {  // Only in L* = 100, ab = [-8..8]
 695
 696             if ((In[1] >= 0x7800 && In[1] <= 0x8800) &&
 697                 (In[2] >= 0x7800 && In[2] <= 0x8800)) {
 698
 699                 WORD* Black;
 700                 WORD* White;
 701                 int nOutputs;
 702
 703                 if (!_cmsEndPointsBySpace(sc ->ColorSpace, &White, &Black, &nOutputs))
 704                         return 0;
 705
 706                 for (i=0; i < (unsigned int) nOutputs; i++)
 707                         Out[i] = White[i];
 708             }
 709
 710
 711         }
 712     }
 713
 714
 715     // Hadle the parenthesis on rows
 716
 717     if (In[0] != sc ->FirstComponent) {
 718
 719             if (sc ->FirstComponent != -1) {
 720
 721                     Writef(sc ->m, sc ->PostMin);
 722                     sc ->SecondComponent = -1;
 723                     Writef(sc ->m, sc ->PostMaj);
 724             }
 725
 726             // Begin block
 727             sc->m->Col = 0;
 728
 729             Writef(sc ->m, sc ->PreMaj);
 730             sc ->FirstComponent = In[0];
 731     }
 732
 733
 734       if (In[1] != sc ->SecondComponent) {
 735
 736             if (sc ->SecondComponent != -1) {
 737
 738                     Writef(sc ->m, sc ->PostMin);
 739             }
 740
 741             Writef(sc ->m, sc ->PreMin);
 742             sc ->SecondComponent = In[1];
 743     }
 744
 745
 746
 747     // Dump table. Could be Word or byte based on
 748     // depending on bps member (16 bps mode is not currently
 749     // being used at all, but is here for future ampliations)
 750
 751     for (i=0; i < sc -> Lut ->OutputChan; i++) {
 752
 753         WORD wWordOut = Out[i];
 754
 755         if (sc ->bps == 8) {
 756
 757             // Value as byte
 758             BYTE wByteOut;
 759
 760             // If is input, convert from Lab2 to Lab4 (just divide by 256)
 761
 762             if (sc ->lIsInput) {
 763
 764
 765                 wByteOut = L2Byte(wWordOut);
 766             }
 767             else
 768                 wByteOut = Word2Byte(wWordOut);
 769
 770             WriteByte(sc -> m, wByteOut);
 771         }
 772         else {
 773
 774             // Value as word
 775             WriteByte(sc -> m, (BYTE) (wWordOut & 0xFF));
 776             WriteByte(sc -> m, (BYTE) ((wWordOut >> 8) & 0xFF));
 777         }
 778      }
 779
 780     return 1;
 781 }
 782
 783 // Writes a LUT on memstream. Could be 8 or 16 bits based
 784
 785 static
 786 void WriteCLUT(LPMEMSTREAM m, LPLUT Lut, int bps, const char* PreMaj,
 787                                                   const char* PostMaj,
 788                                                   const char* PreMin,
 789                                                   const char* PostMin,
 790                                                   int lIsInput,
 791                                                   int FixWhite,
 792                                                   icColorSpaceSignature ColorSpace)
 793 {
 794     unsigned int i;
 795     SAMPLERCARGO sc;
 796
 797     sc.FirstComponent = -1;
 798     sc.SecondComponent = -1;
 799     sc.Lut = Lut;
 800     sc.m   = m;
 801     sc.bps = bps;
 802     sc.PreMaj = PreMaj;
 803     sc.PostMaj= PostMaj;
 804
 805     sc.PreMin   = PreMin;
 806     sc.PostMin  = PostMin;
 807     sc.lIsInput = lIsInput;
 808     sc.FixWhite = FixWhite;
 809     sc.ColorSpace = ColorSpace;
 810
 811     Writef(m, "[");
 812
 813     for (i=0; i < Lut ->InputChan; i++)
 814             Writef(m, " %d ", Lut ->cLutPoints);
 815
 816     Writef(m, " [\n");
 817
 818
 819
 820     cmsSample3DGrid(Lut, OutputValueSampler, (LPVOID) &sc, SAMPLER_INSPECT);
 821
 822
 823     Writef(m, PostMin);
 824     Writef(m, PostMaj);
 825     Writef(m, "] ");
 826
 827
 828
 829 }
 830
 831
 832 // Dumps CIEBasedA Color Space Array
 833
 834 static
 835 int EmitCIEBasedA(LPMEMSTREAM m, LPWORD Tab, int nEntries, LPcmsCIEXYZ BlackPoint)
 836 {
 837
 838         Writef(m, "[ /CIEBasedA\n");
 839         Writef(m, "  <<\n");
 840
 841         Writef(m, "/DecodeA ");
 842
 843         Emit1Gamma(m,Tab, nEntries);
 844
 845         Writef(m, " \n");
 846
 847         Writef(m, "/MatrixA [ 0.9642 1.0000 0.8249 ]\n");
 848         Writef(m, "/RangeLMN [ 0.0 0.9642 0.0 1.0000 0.0 0.8249 ]\n");
 849
 850         EmitWhiteBlackD50(m, BlackPoint);
 851         EmitIntent(m, INTENT_PERCEPTUAL);
 852
 853         Writef(m, ">>\n");
 854         Writef(m, "]\n");
 855
 856         return 1;
 857 }
 858
 859
 860 // Dumps CIEBasedABC Color Space Array
 861
 862 static
 863 int EmitCIEBasedABC(LPMEMSTREAM m, LPWORD L[], int nEntries, LPWMAT3 Matrix, LPcmsCIEXYZ BlackPoint)
 864 {
 865     int i;
 866
 867         Writef(m, "[ /CIEBasedABC\n");
 868         Writef(m, "<<\n");
 869         Writef(m, "/DecodeABC [ ");
 870
 871         EmitNGamma(m, 3, L, nEntries);
 872
 873         Writef(m, "]\n");
 874
 875         Writef(m, "/MatrixABC [ " );
 876
 877         for( i=0; i < 3; i++ ) {
 878
 879             Writef(m, "%.6f %.6f %.6f ",
 880                         FIXED_TO_DOUBLE(Matrix->v[0].n[i]),
 881                         FIXED_TO_DOUBLE(Matrix->v[1].n[i]),
 882                         FIXED_TO_DOUBLE(Matrix->v[2].n[i]));
 883         }
 884
 885
 886         Writef(m, "]\n");
 887
 888         Writef(m, "/RangeLMN [ 0.0 0.9642 0.0 1.0000 0.0 0.8249 ]\n");
 889
 890         EmitWhiteBlackD50(m, BlackPoint);
 891         EmitIntent(m, INTENT_PERCEPTUAL);
 892
 893         Writef(m, ">>\n");
 894         Writef(m, "]\n");
 895
 896
 897         return 1;
 898 }
 899
 900
 901 static
 902 int EmitCIEBasedDEF(LPMEMSTREAM m, LPLUT Lut, int Intent, LPcmsCIEXYZ BlackPoint)
 903 {
 904     const char* PreMaj;
 905     const char* PostMaj;
 906     const char* PreMin, *PostMin;
 907
 908     switch (Lut ->InputChan) {
 909     case 3:
 910
 911             Writef(m, "[ /CIEBasedDEF\n");
 912             PreMaj ="<";
 913             PostMaj= ">\n";
 914             PreMin = PostMin = "";
 915             break;
 916     case 4:
 917             Writef(m, "[ /CIEBasedDEFG\n");
 918             PreMaj = "[";
 919             PostMaj = "]\n";
 920             PreMin = "<";
 921             PostMin = ">\n";
 922             break;
 923     default:
 924             return 0;
 925
 926     }
 927
 928     Writef(m, "<<\n");
 929
 930     if (Lut ->wFlags & LUT_HASTL1) {
 931
 932         Writef(m, "/DecodeDEF [ ");
 933         EmitNGamma(m, Lut ->InputChan, Lut ->L1, Lut ->CLut16params.nSamples);
 934         Writef(m, "]\n");
 935     }
 936
 937
 938
 939     if (Lut ->wFlags & LUT_HAS3DGRID) {
 940
 941             Writef(m, "/Table ");
 942             WriteCLUT(m, Lut, 8, PreMaj, PostMaj, PreMin, PostMin, TRUE, FALSE, (icColorSpaceSignature) 0);
 943             Writef(m, "]\n");
 944     }
 945
 946     EmitLab2XYZ(m);
 947     EmitWhiteBlackD50(m, BlackPoint);
 948     EmitIntent(m, Intent);
 949
 950     Writef(m, "   >>\n");
 951     Writef(m, "]\n");
 952
 953
 954     return 1;
 955 }
 956
 957 // Generates a curve from a gray profile
 958
 959 static
 960 LPGAMMATABLE ExtractGray2Y(cmsHPROFILE hProfile, int Intent)
 961 {
 962     LPGAMMATABLE Out = cmsAllocGamma(256);
 963     cmsHPROFILE hXYZ = cmsCreateXYZProfile();
 964     cmsHTRANSFORM xform = cmsCreateTransform(hProfile, TYPE_GRAY_8, hXYZ, TYPE_XYZ_DBL, Intent, cmsFLAGS_NOTPRECALC);
 965     int i;
 966
 967     for (i=0; i < 256; i++) {
 968
 969       BYTE Gray = (BYTE) i;
 970       cmsCIEXYZ XYZ;
 971
 972         cmsDoTransform(xform, &Gray, &XYZ, 1);
 973
 974         Out ->GammaTable[i] =_cmsClampWord((int) floor(XYZ.Y * 65535.0 + 0.5));
 975     }
 976
 977     cmsDeleteTransform(xform);
 978     cmsCloseProfile(hXYZ);
 979     return Out;
 980 }
 981
 982
 983
 984 // Because PostScrip has only 8 bits in /Table, we should use
 985 // a more perceptually uniform space... I do choose Lab.
 986
 987 static
 988 int WriteInputLUT(LPMEMSTREAM m, cmsHPROFILE hProfile, int Intent)
 989 {
 990     cmsHPROFILE hLab;
 991     cmsHTRANSFORM xform;
 992     icColorSpaceSignature ColorSpace;
 993     int nChannels;
 994     DWORD InputFormat;
 995     int rc;
 996     cmsHPROFILE Profiles[2];
 997     cmsCIEXYZ BlackPointAdaptedToD50;
 998
 999     // Does create a device-link based transform.
1000     // The DeviceLink is next dumped as working CSA.
1001
1002     hLab        = cmsCreateLabProfile(NULL);
1003     ColorSpace  =  cmsGetColorSpace(hProfile);
1004     nChannels   = _cmsChannelsOf(ColorSpace);
1005     InputFormat = CHANNELS_SH(nChannels) | BYTES_SH(2);
1006
1007     cmsDetectBlackPoint(&BlackPointAdaptedToD50, hProfile, Intent,LCMS_BPFLAGS_D50_ADAPTED);
1008
1009     // Is a devicelink profile?
1010     if (cmsGetDeviceClass(hProfile) == icSigLinkClass) {
1011
1012         // if devicelink output already Lab, use it directly
1013
1014         if (cmsGetPCS(hProfile) == icSigLabData) {
1015
1016             xform = cmsCreateTransform(hProfile, InputFormat, NULL,
1017                             TYPE_Lab_DBL, Intent, 0);
1018         }
1019         else {
1020
1021             // Nope, adjust output to Lab if possible
1022
1023             Profiles[0] = hProfile;
1024             Profiles[1] = hLab;
1025
1026             xform = cmsCreateMultiprofileTransform(Profiles, 2,  InputFormat,
1027                                     TYPE_Lab_DBL, Intent, 0);
1028         }
1029
1030
1031     }
1032     else {
1033
1034         // This is a normal profile
1035         xform = cmsCreateTransform(hProfile, InputFormat, hLab,
1036                             TYPE_Lab_DBL, Intent, 0);
1037     }
1038
1039
1040
1041     if (xform == NULL) {
1042
1043             cmsSignalError(LCMS_ERRC_ABORTED, "Cannot create transform Profile -> Lab");
1044             return 0;
1045     }
1046
1047     // Only 1, 3 and 4 channels are allowed
1048
1049     switch (nChannels) {
1050
1051     case 1: {
1052             LPGAMMATABLE Gray2Y = ExtractGray2Y(hProfile, Intent);
1053             EmitCIEBasedA(m, Gray2Y->GammaTable, Gray2Y ->nEntries, &BlackPointAdaptedToD50);
1054             cmsFreeGamma(Gray2Y);
1055             }
1056             break;
1057
1058     case 3:
1059     case 4: {
1060             LPLUT DeviceLink;
1061             _LPcmsTRANSFORM v = (_LPcmsTRANSFORM) xform;
1062
1063             if (v ->DeviceLink)
1064                 rc = EmitCIEBasedDEF(m, v->DeviceLink, Intent, &BlackPointAdaptedToD50);
1065             else {
1066                 DeviceLink = _cmsPrecalculateDeviceLink(xform, 0);
1067                 rc = EmitCIEBasedDEF(m, DeviceLink, Intent, &BlackPointAdaptedToD50);
1068                 cmsFreeLUT(DeviceLink);
1069             }
1070             }
1071             break;
1072
1073     default:
1074
1075             cmsSignalError(LCMS_ERRC_ABORTED, "Only 3, 4 channels supported for CSA. This profile has %d channels.", nChannels);
1076             return 0;
1077     }
1078
1079
1080     cmsDeleteTransform(xform);
1081     cmsCloseProfile(hLab);
1082     return 1;
1083 }
1084
1085
1086
1087 // Does create CSA based on matrix-shaper. Allowed types are gray and RGB based
1088
1089 static
1090 int WriteInputMatrixShaper(LPMEMSTREAM m, cmsHPROFILE hProfile)
1091 {
1092     icColorSpaceSignature ColorSpace;
1093     LPMATSHAPER MatShaper;
1094     int rc;
1095     cmsCIEXYZ BlackPointAdaptedToD50;
1096
1097
1098     ColorSpace = cmsGetColorSpace(hProfile);
1099     MatShaper  = cmsBuildInputMatrixShaper(hProfile);
1100
1101     cmsDetectBlackPoint(&BlackPointAdaptedToD50, hProfile, INTENT_RELATIVE_COLORIMETRIC, LCMS_BPFLAGS_D50_ADAPTED);
1102
1103     if (MatShaper == NULL) {
1104
1105                 cmsSignalError(LCMS_ERRC_ABORTED, "This profile is not suitable for input");
1106                 return 0;
1107     }
1108
1109     if (ColorSpace == icSigGrayData) {
1110
1111             rc = EmitCIEBasedA(m, MatShaper ->L[0],
1112                                   MatShaper ->p16.nSamples,
1113                                   &BlackPointAdaptedToD50);
1114
1115     }
1116     else
1117         if (ColorSpace == icSigRgbData) {
1118
1119
1120             rc = EmitCIEBasedABC(m, MatShaper->L,
1121                                         MatShaper ->p16.nSamples,
1122                                         &MatShaper ->Matrix,
1123                                         &BlackPointAdaptedToD50);
1124         }
1125         else  {
1126
1127             cmsSignalError(LCMS_ERRC_ABORTED, "Profile is not suitable for CSA. Unsupported colorspace.");
1128             return 0;
1129         }
1130
1131     cmsFreeMatShaper(MatShaper);
1132     return rc;
1133 }
1134
1135
1136
1137 // Creates a PostScript color list from a named profile data.
1138 // This is a HP extension, and it works in Lab instead of XYZ
1139
1140 static
1141 int WriteNamedColorCSA(LPMEMSTREAM m, cmsHPROFILE hNamedColor, int Intent)
1142 {
1143     cmsHTRANSFORM xform;
1144     cmsHPROFILE   hLab;
1145     int i, nColors;
1146     char ColorName[32];
1147
1148
1149     hLab  = cmsCreateLabProfile(NULL);
1150     xform = cmsCreateTransform(hNamedColor, TYPE_NAMED_COLOR_INDEX,
1151                         hLab, TYPE_Lab_DBL, Intent, cmsFLAGS_NOTPRECALC);
1152     if (xform == NULL) return 0;
1153
1154
1155     Writef(m, "<<\n");
1156     Writef(m, "(colorlistcomment) (%s)\n", "Named color CSA");
1157     Writef(m, "(Prefix) [ (Pantone ) (PANTONE ) ]\n");
1158     Writef(m, "(Suffix) [ ( CV) ( CVC) ( C) ]\n");
1159
1160     nColors   = cmsNamedColorCount(xform);
1161
1162
1163     for (i=0; i < nColors; i++) {
1164
1165         WORD In[1];
1166         cmsCIELab Lab;
1167
1168         In[0] = (WORD) i;
1169
1170         if (!cmsNamedColorInfo(xform, i, ColorName, NULL, NULL))
1171                 continue;
1172
1173         cmsDoTransform(xform, In, &Lab, 1);
1174         Writef(m, "  (%s) [ %.3f %.3f %.3f ]\n", ColorName, Lab.L, Lab.a, Lab.b);
1175     }
1176
1177
1178
1179     Writef(m, ">>\n");
1180
1181     cmsDeleteTransform(xform);
1182     cmsCloseProfile(hLab);
1183     return 1;
1184 }
1185
1186
1187 // Does create a Color Space Array on XYZ colorspace for PostScript usage
1188
1189 DWORD LCMSEXPORT cmsGetPostScriptCSA(cmsHPROFILE hProfile,
1190                               int Intent,
1191                               LPVOID Buffer, DWORD dwBufferLen)
1192 {
1193
1194     LPMEMSTREAM mem;
1195     DWORD dwBytesUsed;
1196
1197     // Set up the serialization engine
1198     mem = CreateMemStream((LPBYTE) Buffer, dwBufferLen, MAXPSCOLS);
1199     if (!mem) return 0;
1200
1201
1202     // Is a named color profile?
1203     if (cmsGetDeviceClass(hProfile) == icSigNamedColorClass) {
1204
1205         if (!WriteNamedColorCSA(mem, hProfile, Intent)) {
1206
1207                     _cmsFree((void*) mem);
1208                     return 0;
1209         }
1210     }
1211     else {
1212
1213
1214     // Any profile class are allowed (including devicelink), but
1215     // output (PCS) colorspace must be XYZ or Lab
1216     icColorSpaceSignature ColorSpace = cmsGetPCS(hProfile);
1217
1218     if (ColorSpace != icSigXYZData &&
1219         ColorSpace != icSigLabData) {
1220
1221             cmsSignalError(LCMS_ERRC_ABORTED, "Invalid output color space");
1222             _cmsFree((void*) mem);
1223             return 0;
1224     }
1225
1226     // Is there any CLUT?
1227     if (IsLUTbased(hProfile, Intent)) {
1228
1229         // Yes, so handle as LUT-based
1230         if (!WriteInputLUT(mem, hProfile, Intent)) {
1231
1232                     _cmsFree((void*) mem);
1233                     return 0;
1234         }
1235     }
1236     else {
1237
1238         // No, try Matrix-shaper (this only works on XYZ)
1239
1240         if (!WriteInputMatrixShaper(mem, hProfile)) {
1241
1242                     _cmsFree((void*) mem);  // Something went wrong
1243                     return 0;
1244         }
1245     }
1246     }
1247
1248
1249     // Done, keep memory usage
1250     dwBytesUsed = mem ->dwUsed;
1251
1252     // Get rid of memory stream
1253     _cmsFree((void*) mem);
1254
1255     // Finally, return used byte count
1256     return dwBytesUsed;
1257 }
1258
1259 // ------------------------------------------------------ Color Rendering Dictionary (CRD)
1260
1261
1262
1263 /*
1264
1265   Black point compensation plus chromatic adaptation:
1266
1267   Step 1 - Chromatic adaptation
1268   =============================
1269
1270           WPout
1271     X = ------- PQR
1272           Wpin
1273
1274   Step 2 - Black point compensation
1275   =================================
1276
1277           (WPout - BPout)*X - WPout*(BPin - BPout)
1278     out = ---------------------------------------
1279                         WPout - BPin
1280
1281
1282   Algorithm discussion
1283   ====================
1284
1285   TransformPQR(WPin, BPin, WPout, BPout, PQR)
1286
1287   Wpin,etc= { Xws Yws Zws Pws Qws Rws }
1288
1289
1290   Algorithm             Stack 0...n
1291   ===========================================================
1292                         PQR BPout WPout BPin WPin
1293   4 index 3 get         WPin PQR BPout WPout BPin WPin
1294   div                   (PQR/WPin) BPout WPout BPin WPin
1295   2 index 3 get         WPout (PQR/WPin) BPout WPout BPin WPin
1296   mult                  WPout*(PQR/WPin) BPout WPout BPin WPin
1297
1298   2 index 3 get         WPout WPout*(PQR/WPin) BPout WPout BPin WPin
1299   2 index 3 get         BPout WPout WPout*(PQR/WPin) BPout WPout BPin WPin
1300   sub                   (WPout-BPout) WPout*(PQR/WPin) BPout WPout BPin WPin
1301   mult                  (WPout-BPout)* WPout*(PQR/WPin) BPout WPout BPin WPin
1302
1303   2 index 3 get         WPout (BPout-WPout)* WPout*(PQR/WPin) BPout WPout BPin WPin
1304   4 index 3 get         BPin WPout (BPout-WPout)* WPout*(PQR/WPin) BPout WPout BPin WPin
1305   3 index 3 get         BPout BPin WPout (BPout-WPout)* WPout*(PQR/WPin) BPout WPout BPin WPin
1306
1307   sub                   (BPin-BPout) WPout (BPout-WPout)* WPout*(PQR/WPin) BPout WPout BPin WPin
1308   mult                  (BPin-BPout)*WPout (BPout-WPout)* WPout*(PQR/WPin) BPout WPout BPin WPin
1309   sub                   (BPout-WPout)* WPout*(PQR/WPin)-(BPin-BPout)*WPout BPout WPout BPin WPin
1310
1311   3 index 3 get         BPin (BPout-WPout)* WPout*(PQR/WPin)-(BPin-BPout)*WPout BPout WPout BPin WPin
1312   3 index 3 get         WPout BPin (BPout-WPout)* WPout*(PQR/WPin)-(BPin-BPout)*WPout BPout WPout BPin WPin
1313   exch
1314   sub                   (WPout-BPin) (BPout-WPout)* WPout*(PQR/WPin)-(BPin-BPout)*WPout BPout WPout BPin WPin
1315   div
1316
1317   exch pop
1318   exch pop
1319   exch pop
1320   exch pop
1321
1322 */
1323
1324
1325 static
1326 void EmitPQRStage(LPMEMSTREAM m, cmsHPROFILE hProfile, int DoBPC, int lIsAbsolute)
1327 {
1328
1329
1330         if (lIsAbsolute) {
1331
1332             // For absolute colorimetric intent, encode back to relative
1333                         // and generate a relative LUT
1334
1335                         // Relative encoding is obtained across XYZpcs*(D50/WhitePoint)
1336
1337                         cmsCIEXYZ White;
1338
1339                         cmsTakeMediaWhitePoint(&White, hProfile);
1340
1341                         Writef(m,"/MatrixPQR [1 0 0 0 1 0 0 0 1 ]\n");
1342             Writef(m,"/RangePQR [ -0.5 2 -0.5 2 -0.5 2 ]\n");
1343
1344             Writef(m, "%% Absolute colorimetric -- encode to relative to maximize LUT usage\n"
1345                       "/TransformPQR [\n"
1346                       "{0.9642 mul %g div exch pop exch pop exch pop exch pop} bind\n"
1347                       "{1.0000 mul %g div exch pop exch pop exch pop exch pop} bind\n"
1348                       "{0.8249 mul %g div exch pop exch pop exch pop exch pop} bind\n]\n",
1349                                           White.X, White.Y, White.Z);
1350             return;
1351         }
1352
1353
1354         Writef(m,"%% Bradford Cone Space\n"
1355                  "/MatrixPQR [0.8951 -0.7502 0.0389 0.2664 1.7135 -0.0685 -0.1614 0.0367 1.0296 ] \n");
1356
1357         Writef(m, "/RangePQR [ -0.5 2 -0.5 2 -0.5 2 ]\n");
1358
1359
1360         // No BPC
1361
1362         if (!DoBPC) {
1363
1364             Writef(m, "%% VonKries-like transform in Bradford Cone Space\n"
1365                       "/TransformPQR [\n"
1366                       "{exch pop exch 3 get mul exch pop exch 3 get div} bind\n"
1367                       "{exch pop exch 4 get mul exch pop exch 4 get div} bind\n"
1368                       "{exch pop exch 5 get mul exch pop exch 5 get div} bind\n]\n");
1369         } else {
1370
1371             // BPC
1372
1373             Writef(m, "%% VonKries-like transform in Bradford Cone Space plus BPC\n"
1374                       "/TransformPQR [\n");
1375
1376             Writef(m, "{4 index 3 get div 2 index 3 get mul "
1377                     "2 index 3 get 2 index 3 get sub mul "
1378                     "2 index 3 get 4 index 3 get 3 index 3 get sub mul sub "
1379                     "3 index 3 get 3 index 3 get exch sub div "
1380                     "exch pop exch pop exch pop exch pop } bind\n");
1381
1382             Writef(m, "{4 index 4 get div 2 index 4 get mul "
1383                     "2 index 4 get 2 index 4 get sub mul "
1384                     "2 index 4 get 4 index 4 get 3 index 4 get sub mul sub "
1385                     "3 index 4 get 3 index 4 get exch sub div "
1386                     "exch pop exch pop exch pop exch pop } bind\n");
1387
1388             Writef(m, "{4 index 5 get div 2 index 5 get mul "
1389                     "2 index 5 get 2 index 5 get sub mul "
1390                     "2 index 5 get 4 index 5 get 3 index 5 get sub mul sub "
1391                     "3 index 5 get 3 index 5 get exch sub div "
1392                     "exch pop exch pop exch pop exch pop } bind\n]\n");
1393
1394         }
1395
1396
1397 }
1398
1399
1400 static
1401 void EmitXYZ2Lab(LPMEMSTREAM m)
1402 {
1403     Writef(m, "/RangeLMN [ -0.635 2.0 0 2 -0.635 2.0 ]\n");
1404     Writef(m, "/EncodeLMN [\n");
1405     Writef(m, "{ 0.964200  div dup 0.008856 le {7.787 mul 16 116 div add}{1 3 div exp} ifelse } bind\n");
1406     Writef(m, "{ 1.000000  div dup 0.008856 le {7.787 mul 16 116 div add}{1 3 div exp} ifelse } bind\n");
1407     Writef(m, "{ 0.824900  div dup 0.008856 le {7.787 mul 16 116 div add}{1 3 div exp} ifelse } bind\n");
1408     Writef(m, "]\n");
1409     Writef(m, "/MatrixABC [ 0 1 0 1 -1 1 0 0 -1 ]\n");
1410     Writef(m, "/EncodeABC [\n");
1411
1412
1413     Writef(m, "{ 116 mul  16 sub 100 div  } bind\n");
1414     Writef(m, "{ 500 mul 128 add 256 div  } bind\n");
1415     Writef(m, "{ 200 mul 128 add 256 div  } bind\n");
1416
1417
1418     Writef(m, "]\n");
1419
1420
1421 }
1422
1423 // Due to impedance mismatch between XYZ and almost all RGB and CMYK spaces
1424 // I choose to dump LUTS in Lab instead of XYZ. There is still a lot of wasted
1425 // space on 3D CLUT, but since space seems not to be a problem here, 33 points
1426 // would give a reasonable accurancy. Note also that CRD tables must operate in
1427 // 8 bits.
1428
1429 static
1430 int WriteOutputLUT(LPMEMSTREAM m, cmsHPROFILE hProfile, int Intent, DWORD dwFlags)
1431 {
1432     cmsHPROFILE hLab;
1433     cmsHTRANSFORM xform;
1434     icColorSpaceSignature ColorSpace;
1435     int i, nChannels;
1436     DWORD OutputFormat;
1437     _LPcmsTRANSFORM v;
1438     LPLUT DeviceLink;
1439     cmsHPROFILE Profiles[3];
1440     cmsCIEXYZ BlackPointAdaptedToD50;
1441     LCMSBOOL lFreeDeviceLink = FALSE;
1442     LCMSBOOL lDoBPC = (dwFlags & cmsFLAGS_BLACKPOINTCOMPENSATION);
1443     LCMSBOOL lFixWhite = !(dwFlags & cmsFLAGS_NOWHITEONWHITEFIXUP);
1444         int RelativeEncodingIntent;
1445
1446
1447
1448     hLab = cmsCreateLabProfile(NULL);
1449
1450     ColorSpace  =  cmsGetColorSpace(hProfile);
1451     nChannels   = _cmsChannelsOf(ColorSpace);
1452     OutputFormat = CHANNELS_SH(nChannels) | BYTES_SH(2);
1453
1454         // For absolute colorimetric, the LUT is encoded as relative
1455         // in order to preserve precission.
1456
1457     RelativeEncodingIntent = Intent;
1458         if (RelativeEncodingIntent == INTENT_ABSOLUTE_COLORIMETRIC)
1459                 RelativeEncodingIntent = INTENT_RELATIVE_COLORIMETRIC;
1460
1461
1462     // Is a devicelink profile?
1463     if (cmsGetDeviceClass(hProfile) == icSigLinkClass) {
1464
1465         // if devicelink input already in Lab
1466
1467         if (ColorSpace == icSigLabData) {
1468
1469               // adjust input to Lab to our v4
1470
1471             Profiles[0] = hLab;
1472             Profiles[1] = hProfile;
1473
1474             xform = cmsCreateMultiprofileTransform(Profiles, 2, TYPE_Lab_DBL,
1475                                                         OutputFormat, RelativeEncodingIntent,
1476                                                                                                                 dwFlags|cmsFLAGS_NOWHITEONWHITEFIXUP|cmsFLAGS_NOPRELINEARIZATION);
1477
1478         }
1479         else {
1480           cmsSignalError(LCMS_ERRC_ABORTED, "Cannot use devicelink profile for CRD creation");
1481           return 0;
1482         }
1483
1484
1485     }
1486     else {
1487
1488         // This is a normal profile
1489         xform = cmsCreateTransform(hLab, TYPE_Lab_DBL, hProfile,
1490                             OutputFormat, RelativeEncodingIntent, dwFlags|cmsFLAGS_NOWHITEONWHITEFIXUP|cmsFLAGS_NOPRELINEARIZATION);
1491     }
1492
1493     if (xform == NULL) {
1494
1495             cmsSignalError(LCMS_ERRC_ABORTED, "Cannot create transform Lab -> Profile in CRD creation");
1496             return 0;
1497     }
1498
1499     // Get the internal precalculated devicelink
1500
1501     v = (_LPcmsTRANSFORM) xform;
1502     DeviceLink = v ->DeviceLink;
1503
1504     if (!DeviceLink) {
1505
1506         DeviceLink = _cmsPrecalculateDeviceLink(xform, cmsFLAGS_NOPRELINEARIZATION);
1507         lFreeDeviceLink = TRUE;
1508     }
1509
1510     Writef(m, "<<\n");
1511     Writef(m, "/ColorRenderingType 1\n");
1512
1513
1514     cmsDetectBlackPoint(&BlackPointAdaptedToD50, hProfile, Intent, LCMS_BPFLAGS_D50_ADAPTED);
1515
1516     // Emit headers, etc.
1517     EmitWhiteBlackD50(m, &BlackPointAdaptedToD50);
1518     EmitPQRStage(m, hProfile, lDoBPC, Intent == INTENT_ABSOLUTE_COLORIMETRIC);
1519     EmitXYZ2Lab(m);
1520
1521     if (DeviceLink ->wFlags & LUT_HASTL1) {
1522
1523         // Shouldn't happen
1524         cmsSignalError(LCMS_ERRC_ABORTED, "Internal error (prelinearization on CRD)");
1525         return 0;
1526     }
1527
1528
1529     // FIXUP: map Lab (100, 0, 0) to perfect white, because the particular encoding for Lab
1530     // does map a=b=0 not falling into any specific node. Since range a,b goes -128..127,
1531     // zero is slightly moved towards right, so assure next node (in L=100 slice) is mapped to
1532     // zero. This would sacrifice a bit of highlights, but failure to do so would cause
1533     // scum dot. Ouch.
1534
1535     if (Intent == INTENT_ABSOLUTE_COLORIMETRIC)
1536             lFixWhite = FALSE;
1537
1538     Writef(m, "/RenderTable ");
1539
1540     WriteCLUT(m, DeviceLink, 8, "<", ">\n", "", "", FALSE,
1541                 lFixWhite, ColorSpace);
1542
1543     Writef(m, " %d {} bind ", nChannels);
1544
1545     for (i=1; i < nChannels; i++)
1546             Writef(m, "dup ");
1547
1548     Writef(m, "]\n");
1549
1550
1551     EmitIntent(m, Intent);
1552
1553     Writef(m, ">>\n");
1554
1555     if (!(dwFlags & cmsFLAGS_NODEFAULTRESOURCEDEF)) {
1556
1557         Writef(m, "/Current exch /ColorRendering defineresource pop\n");
1558     }
1559
1560     if (lFreeDeviceLink) cmsFreeLUT(DeviceLink);
1561     cmsDeleteTransform(xform);
1562     cmsCloseProfile(hLab);
1563
1564     return 1;
1565 }
1566
1567
1568 // Builds a ASCII string containing colorant list in 0..1.0 range
1569 static
1570 void BuildColorantList(char *Colorant, int nColorant, WORD Out[])
1571 {
1572     char Buff[32];
1573     int j;
1574
1575     Colorant[0] = 0;
1576     if (nColorant > MAXCHANNELS)
1577         nColorant = MAXCHANNELS;
1578
1579     for (j=0; j < nColorant; j++) {
1580
1581                 sprintf(Buff, "%.3f", Out[j] / 65535.0);
1582                 strcat(Colorant, Buff);
1583                 if (j < nColorant -1)
1584                         strcat(Colorant, " ");
1585
1586         }
1587 }
1588
1589
1590 // Creates a PostScript color list from a named profile data.
1591 // This is a HP extension.
1592
1593 static
1594 int WriteNamedColorCRD(LPMEMSTREAM m, cmsHPROFILE hNamedColor, int Intent, DWORD dwFlags)
1595 {
1596     cmsHTRANSFORM xform;
1597     int i, nColors, nColorant;
1598     DWORD OutputFormat;
1599     char ColorName[32];
1600     char Colorant[128];
1601
1602     nColorant = _cmsChannelsOf(cmsGetColorSpace(hNamedColor));
1603     OutputFormat = CHANNELS_SH(nColorant) | BYTES_SH(2);
1604
1605     xform = cmsCreateTransform(hNamedColor, TYPE_NAMED_COLOR_INDEX,
1606                         NULL, OutputFormat, Intent, cmsFLAGS_NOTPRECALC);
1607     if (xform == NULL) return 0;
1608
1609
1610     Writef(m, "<<\n");
1611     Writef(m, "(colorlistcomment) (%s) \n", "Named profile");
1612     Writef(m, "(Prefix) [ (Pantone ) (PANTONE ) ]\n");
1613     Writef(m, "(Suffix) [ ( CV) ( CVC) ( C) ]\n");
1614
1615     nColors   = cmsNamedColorCount(xform);
1616
1617
1618     for (i=0; i < nColors; i++) {
1619
1620         WORD In[1];
1621         WORD Out[MAXCHANNELS];
1622
1623         In[0] = (WORD) i;
1624
1625         if (!cmsNamedColorInfo(xform, i, ColorName, NULL, NULL))
1626                 continue;
1627
1628         cmsDoTransform(xform, In, Out, 1);
1629         BuildColorantList(Colorant, nColorant, Out);
1630         Writef(m, "  (%s) [ %s ]\n", ColorName, Colorant);
1631     }
1632
1633     Writef(m, "   >>");
1634
1635     if (!(dwFlags & cmsFLAGS_NODEFAULTRESOURCEDEF)) {
1636
1637     Writef(m, " /Current exch /HPSpotTable defineresource pop\n");
1638     }
1639
1640     cmsDeleteTransform(xform);
1641     return 1;
1642 }
1643
1644
1645
1646 // This one does create a Color Rendering Dictionary.
1647 // CRD are always LUT-Based, no matter if profile is
1648 // implemented as matrix-shaper.
1649
1650 DWORD LCMSEXPORT cmsGetPostScriptCRDEx(cmsHPROFILE hProfile,
1651                               int Intent, DWORD dwFlags,
1652                               LPVOID Buffer, DWORD dwBufferLen)
1653 {
1654
1655     LPMEMSTREAM mem;
1656     DWORD dwBytesUsed;
1657
1658     // Set up the serialization artifact
1659     mem = CreateMemStream((LPBYTE) Buffer, dwBufferLen, MAXPSCOLS);
1660     if (!mem) return 0;
1661
1662
1663     if (!(dwFlags & cmsFLAGS_NODEFAULTRESOURCEDEF)) {
1664
1665     EmitHeader(mem, "Color Rendering Dictionary (CRD)", hProfile);
1666     }
1667
1668
1669     // Is a named color profile?
1670     if (cmsGetDeviceClass(hProfile) == icSigNamedColorClass) {
1671
1672         if (!WriteNamedColorCRD(mem, hProfile, Intent, dwFlags)) {
1673
1674                     _cmsFree((void*) mem);
1675                     return 0;
1676         }
1677     }
1678     else {
1679
1680     // CRD are always implemented as LUT.
1681
1682
1683     if (!WriteOutputLUT(mem, hProfile, Intent, dwFlags)) {
1684         _cmsFree((void*) mem);
1685         return 0;
1686     }
1687     }
1688
1689     if (!(dwFlags & cmsFLAGS_NODEFAULTRESOURCEDEF)) {
1690
1691     Writef(mem, "%%%%EndResource\n");
1692     Writef(mem, "\n%% CRD End\n");
1693     }
1694
1695     // Done, keep memory usage
1696     dwBytesUsed = mem ->dwUsed;
1697
1698     // Get rid of memory stream
1699     _cmsFree((void*) mem);
1700
1701     // Finally, return used byte count
1702     return dwBytesUsed;
1703 }
1704
1705
1706 // For compatibility with previous versions
1707
1708 DWORD LCMSEXPORT cmsGetPostScriptCRD(cmsHPROFILE hProfile,
1709                               int Intent,
1710                               LPVOID Buffer, DWORD dwBufferLen)
1711 {
1712     return cmsGetPostScriptCRDEx(hProfile, Intent, 0, Buffer, dwBufferLen);
1713 }