upgrade to xpdf 3.00.
[swftools.git] / pdf2swf / xpdf / GfxState.cc
1 //========================================================================
2 //
3 // GfxState.cc
4 //
5 // Copyright 1996-2003 Glyph & Cog, LLC
6 //
7 //========================================================================
8
9 #include <aconf.h>
10
11 #ifdef USE_GCC_PRAGMAS
12 #pragma implementation
13 #endif
14
15 #include <stddef.h>
16 #include <math.h>
17 #include <string.h> // for memcpy()
18 #include "gmem.h"
19 #include "Error.h"
20 #include "Object.h"
21 #include "Array.h"
22 #include "Page.h"
23 #include "GfxState.h"
24
25 //------------------------------------------------------------------------
26
27 static inline double clip01(double x) {
28   return (x < 0) ? 0 : ((x > 1) ? 1 : x);
29 }
30
31 //------------------------------------------------------------------------
32
33 static char *gfxColorSpaceModeNames[] = {
34   "DeviceGray",
35   "CalGray",
36   "DeviceRGB",
37   "CalRGB",
38   "DeviceCMYK",
39   "Lab",
40   "ICCBased",
41   "Indexed",
42   "Separation",
43   "DeviceN",
44   "Pattern"
45 };
46
47 #define nGfxColorSpaceModes ((sizeof(gfxColorSpaceModeNames) / sizeof(char *)))
48
49 //------------------------------------------------------------------------
50 // GfxColorSpace
51 //------------------------------------------------------------------------
52
53 GfxColorSpace::GfxColorSpace() {
54 }
55
56 GfxColorSpace::~GfxColorSpace() {
57 }
58
59 GfxColorSpace *GfxColorSpace::parse(Object *csObj) {
60   GfxColorSpace *cs;
61   Object obj1;
62
63   cs = NULL;
64   if (csObj->isName()) {
65     if (csObj->isName("DeviceGray") || csObj->isName("G")) {
66       cs = new GfxDeviceGrayColorSpace();
67     } else if (csObj->isName("DeviceRGB") || csObj->isName("RGB")) {
68       cs = new GfxDeviceRGBColorSpace();
69     } else if (csObj->isName("DeviceCMYK") || csObj->isName("CMYK")) {
70       cs = new GfxDeviceCMYKColorSpace();
71     } else if (csObj->isName("Pattern")) {
72       cs = new GfxPatternColorSpace(NULL);
73     } else {
74       error(-1, "Bad color space '%s'", csObj->getName());
75     }
76   } else if (csObj->isArray()) {
77     csObj->arrayGet(0, &obj1);
78     if (obj1.isName("DeviceGray") || obj1.isName("G")) {
79       cs = new GfxDeviceGrayColorSpace();
80     } else if (obj1.isName("DeviceRGB") || obj1.isName("RGB")) {
81       cs = new GfxDeviceRGBColorSpace();
82     } else if (obj1.isName("DeviceCMYK") || obj1.isName("CMYK")) {
83       cs = new GfxDeviceCMYKColorSpace();
84     } else if (obj1.isName("CalGray")) {
85       cs = GfxCalGrayColorSpace::parse(csObj->getArray());
86     } else if (obj1.isName("CalRGB")) {
87       cs = GfxCalRGBColorSpace::parse(csObj->getArray());
88     } else if (obj1.isName("Lab")) {
89       cs = GfxLabColorSpace::parse(csObj->getArray());
90     } else if (obj1.isName("ICCBased")) {
91       cs = GfxICCBasedColorSpace::parse(csObj->getArray());
92     } else if (obj1.isName("Indexed") || obj1.isName("I")) {
93       cs = GfxIndexedColorSpace::parse(csObj->getArray());
94     } else if (obj1.isName("Separation")) {
95       cs = GfxSeparationColorSpace::parse(csObj->getArray());
96     } else if (obj1.isName("DeviceN")) {
97       cs = GfxDeviceNColorSpace::parse(csObj->getArray());
98     } else if (obj1.isName("Pattern")) {
99       cs = GfxPatternColorSpace::parse(csObj->getArray());
100     } else {
101       error(-1, "Bad color space");
102     }
103     obj1.free();
104   } else {
105     error(-1, "Bad color space - expected name or array");
106   }
107   return cs;
108 }
109
110 void GfxColorSpace::getDefaultRanges(double *decodeLow, double *decodeRange,
111                                      int maxImgPixel) {
112   int i;
113
114   for (i = 0; i < getNComps(); ++i) {
115     decodeLow[i] = 0;
116     decodeRange[i] = 1;
117   }
118 }
119
120 int GfxColorSpace::getNumColorSpaceModes() {
121   return nGfxColorSpaceModes;
122 }
123
124 char *GfxColorSpace::getColorSpaceModeName(int idx) {
125   return gfxColorSpaceModeNames[idx];
126 }
127
128 //------------------------------------------------------------------------
129 // GfxDeviceGrayColorSpace
130 //------------------------------------------------------------------------
131
132 GfxDeviceGrayColorSpace::GfxDeviceGrayColorSpace() {
133 }
134
135 GfxDeviceGrayColorSpace::~GfxDeviceGrayColorSpace() {
136 }
137
138 GfxColorSpace *GfxDeviceGrayColorSpace::copy() {
139   return new GfxDeviceGrayColorSpace();
140 }
141
142 void GfxDeviceGrayColorSpace::getGray(GfxColor *color, double *gray) {
143   *gray = clip01(color->c[0]);
144 }
145
146 void GfxDeviceGrayColorSpace::getRGB(GfxColor *color, GfxRGB *rgb) {
147   rgb->r = rgb->g = rgb->b = clip01(color->c[0]);
148 }
149
150 void GfxDeviceGrayColorSpace::getCMYK(GfxColor *color, GfxCMYK *cmyk) {
151   cmyk->c = cmyk->m = cmyk->y = 0;
152   cmyk->k = clip01(1 - color->c[0]);
153 }
154
155 //------------------------------------------------------------------------
156 // GfxCalGrayColorSpace
157 //------------------------------------------------------------------------
158
159 GfxCalGrayColorSpace::GfxCalGrayColorSpace() {
160   whiteX = whiteY = whiteZ = 1;
161   blackX = blackY = blackZ = 0;
162   gamma = 1;
163 }
164
165 GfxCalGrayColorSpace::~GfxCalGrayColorSpace() {
166 }
167
168 GfxColorSpace *GfxCalGrayColorSpace::copy() {
169   GfxCalGrayColorSpace *cs;
170
171   cs = new GfxCalGrayColorSpace();
172   cs->whiteX = whiteX;
173   cs->whiteY = whiteY;
174   cs->whiteZ = whiteZ;
175   cs->blackX = blackX;
176   cs->blackY = blackY;
177   cs->blackZ = blackZ;
178   cs->gamma = gamma;
179   return cs;
180 }
181
182 GfxColorSpace *GfxCalGrayColorSpace::parse(Array *arr) {
183   GfxCalGrayColorSpace *cs;
184   Object obj1, obj2, obj3;
185
186   arr->get(1, &obj1);
187   if (!obj1.isDict()) {
188     error(-1, "Bad CalGray color space");
189     obj1.free();
190     return NULL;
191   }
192   cs = new GfxCalGrayColorSpace();
193   if (obj1.dictLookup("WhitePoint", &obj2)->isArray() &&
194       obj2.arrayGetLength() == 3) {
195     obj2.arrayGet(0, &obj3);
196     cs->whiteX = obj3.getNum();
197     obj3.free();
198     obj2.arrayGet(1, &obj3);
199     cs->whiteY = obj3.getNum();
200     obj3.free();
201     obj2.arrayGet(2, &obj3);
202     cs->whiteZ = obj3.getNum();
203     obj3.free();
204   }
205   obj2.free();
206   if (obj1.dictLookup("BlackPoint", &obj2)->isArray() &&
207       obj2.arrayGetLength() == 3) {
208     obj2.arrayGet(0, &obj3);
209     cs->blackX = obj3.getNum();
210     obj3.free();
211     obj2.arrayGet(1, &obj3);
212     cs->blackY = obj3.getNum();
213     obj3.free();
214     obj2.arrayGet(2, &obj3);
215     cs->blackZ = obj3.getNum();
216     obj3.free();
217   }
218   obj2.free();
219   if (obj1.dictLookup("Gamma", &obj2)->isNum()) {
220     cs->gamma = obj2.getNum();
221   }
222   obj2.free();
223   obj1.free();
224   return cs;
225 }
226
227 void GfxCalGrayColorSpace::getGray(GfxColor *color, double *gray) {
228   *gray = clip01(color->c[0]);
229 }
230
231 void GfxCalGrayColorSpace::getRGB(GfxColor *color, GfxRGB *rgb) {
232   rgb->r = rgb->g = rgb->b = clip01(color->c[0]);
233 }
234
235 void GfxCalGrayColorSpace::getCMYK(GfxColor *color, GfxCMYK *cmyk) {
236   cmyk->c = cmyk->m = cmyk->y = 0;
237   cmyk->k = clip01(1 - color->c[0]);
238 }
239
240 //------------------------------------------------------------------------
241 // GfxDeviceRGBColorSpace
242 //------------------------------------------------------------------------
243
244 GfxDeviceRGBColorSpace::GfxDeviceRGBColorSpace() {
245 }
246
247 GfxDeviceRGBColorSpace::~GfxDeviceRGBColorSpace() {
248 }
249
250 GfxColorSpace *GfxDeviceRGBColorSpace::copy() {
251   return new GfxDeviceRGBColorSpace();
252 }
253
254 void GfxDeviceRGBColorSpace::getGray(GfxColor *color, double *gray) {
255   *gray = clip01(0.299 * color->c[0] +
256                  0.587 * color->c[1] +
257                  0.114 * color->c[2]);
258 }
259
260 void GfxDeviceRGBColorSpace::getRGB(GfxColor *color, GfxRGB *rgb) {
261   rgb->r = clip01(color->c[0]);
262   rgb->g = clip01(color->c[1]);
263   rgb->b = clip01(color->c[2]);
264 }
265
266 void GfxDeviceRGBColorSpace::getCMYK(GfxColor *color, GfxCMYK *cmyk) {
267   double c, m, y, k;
268
269   c = clip01(1 - color->c[0]);
270   m = clip01(1 - color->c[1]);
271   y = clip01(1 - color->c[2]);
272   k = c;
273   if (m < k) {
274     k = m;
275   }
276   if (y < k) {
277     k = y;
278   }
279   cmyk->c = c - k;
280   cmyk->m = m - k;
281   cmyk->y = y - k;
282   cmyk->k = k;
283 }
284
285 //------------------------------------------------------------------------
286 // GfxCalRGBColorSpace
287 //------------------------------------------------------------------------
288
289 GfxCalRGBColorSpace::GfxCalRGBColorSpace() {
290   whiteX = whiteY = whiteZ = 1;
291   blackX = blackY = blackZ = 0;
292   gammaR = gammaG = gammaB = 1;
293   mat[0] = 1; mat[1] = 0; mat[2] = 0;
294   mat[3] = 0; mat[4] = 1; mat[5] = 0;
295   mat[6] = 0; mat[7] = 0; mat[8] = 1;
296 }
297
298 GfxCalRGBColorSpace::~GfxCalRGBColorSpace() {
299 }
300
301 GfxColorSpace *GfxCalRGBColorSpace::copy() {
302   GfxCalRGBColorSpace *cs;
303   int i;
304
305   cs = new GfxCalRGBColorSpace();
306   cs->whiteX = whiteX;
307   cs->whiteY = whiteY;
308   cs->whiteZ = whiteZ;
309   cs->blackX = blackX;
310   cs->blackY = blackY;
311   cs->blackZ = blackZ;
312   cs->gammaR = gammaR;
313   cs->gammaG = gammaG;
314   cs->gammaB = gammaB;
315   for (i = 0; i < 9; ++i) {
316     cs->mat[i] = mat[i];
317   }
318   return cs;
319 }
320
321 GfxColorSpace *GfxCalRGBColorSpace::parse(Array *arr) {
322   GfxCalRGBColorSpace *cs;
323   Object obj1, obj2, obj3;
324   int i;
325
326   arr->get(1, &obj1);
327   if (!obj1.isDict()) {
328     error(-1, "Bad CalRGB color space");
329     obj1.free();
330     return NULL;
331   }
332   cs = new GfxCalRGBColorSpace();
333   if (obj1.dictLookup("WhitePoint", &obj2)->isArray() &&
334       obj2.arrayGetLength() == 3) {
335     obj2.arrayGet(0, &obj3);
336     cs->whiteX = obj3.getNum();
337     obj3.free();
338     obj2.arrayGet(1, &obj3);
339     cs->whiteY = obj3.getNum();
340     obj3.free();
341     obj2.arrayGet(2, &obj3);
342     cs->whiteZ = obj3.getNum();
343     obj3.free();
344   }
345   obj2.free();
346   if (obj1.dictLookup("BlackPoint", &obj2)->isArray() &&
347       obj2.arrayGetLength() == 3) {
348     obj2.arrayGet(0, &obj3);
349     cs->blackX = obj3.getNum();
350     obj3.free();
351     obj2.arrayGet(1, &obj3);
352     cs->blackY = obj3.getNum();
353     obj3.free();
354     obj2.arrayGet(2, &obj3);
355     cs->blackZ = obj3.getNum();
356     obj3.free();
357   }
358   obj2.free();
359   if (obj1.dictLookup("Gamma", &obj2)->isArray() &&
360       obj2.arrayGetLength() == 3) {
361     obj2.arrayGet(0, &obj3);
362     cs->gammaR = obj3.getNum();
363     obj3.free();
364     obj2.arrayGet(1, &obj3);
365     cs->gammaG = obj3.getNum();
366     obj3.free();
367     obj2.arrayGet(2, &obj3);
368     cs->gammaB = obj3.getNum();
369     obj3.free();
370   }
371   obj2.free();
372   if (obj1.dictLookup("Matrix", &obj2)->isArray() &&
373       obj2.arrayGetLength() == 9) {
374     for (i = 0; i < 9; ++i) {
375       obj2.arrayGet(i, &obj3);
376       cs->mat[i] = obj3.getNum();
377       obj3.free();
378     }
379   }
380   obj2.free();
381   obj1.free();
382   return cs;
383 }
384
385 void GfxCalRGBColorSpace::getGray(GfxColor *color, double *gray) {
386   *gray = clip01(0.299 * color->c[0] +
387                  0.587 * color->c[1] +
388                  0.114 * color->c[2]);
389 }
390
391 void GfxCalRGBColorSpace::getRGB(GfxColor *color, GfxRGB *rgb) {
392   rgb->r = clip01(color->c[0]);
393   rgb->g = clip01(color->c[1]);
394   rgb->b = clip01(color->c[2]);
395 }
396
397 void GfxCalRGBColorSpace::getCMYK(GfxColor *color, GfxCMYK *cmyk) {
398   double c, m, y, k;
399
400   c = clip01(1 - color->c[0]);
401   m = clip01(1 - color->c[1]);
402   y = clip01(1 - color->c[2]);
403   k = c;
404   if (m < k) {
405     k = m;
406   }
407   if (y < k) {
408     k = y;
409   }
410   cmyk->c = c - k;
411   cmyk->m = m - k;
412   cmyk->y = y - k;
413   cmyk->k = k;
414 }
415
416 //------------------------------------------------------------------------
417 // GfxDeviceCMYKColorSpace
418 //------------------------------------------------------------------------
419
420 GfxDeviceCMYKColorSpace::GfxDeviceCMYKColorSpace() {
421 }
422
423 GfxDeviceCMYKColorSpace::~GfxDeviceCMYKColorSpace() {
424 }
425
426 GfxColorSpace *GfxDeviceCMYKColorSpace::copy() {
427   return new GfxDeviceCMYKColorSpace();
428 }
429
430 void GfxDeviceCMYKColorSpace::getGray(GfxColor *color, double *gray) {
431   *gray = clip01(1 - color->c[3]
432                  - 0.299 * color->c[0]
433                  - 0.587 * color->c[1]
434                  - 0.114 * color->c[2]);
435 }
436
437 void GfxDeviceCMYKColorSpace::getRGB(GfxColor *color, GfxRGB *rgb) {
438   double c, m, y, aw, ac, am, ay, ar, ag, ab;
439
440   c = clip01(color->c[0] + color->c[3]);
441   m = clip01(color->c[1] + color->c[3]);
442   y = clip01(color->c[2] + color->c[3]);
443   aw = (1-c) * (1-m) * (1-y);
444   ac = c * (1-m) * (1-y);
445   am = (1-c) * m * (1-y);
446   ay = (1-c) * (1-m) * y;
447   ar = (1-c) * m * y;
448   ag = c * (1-m) * y;
449   ab = c * m * (1-y);
450   rgb->r = clip01(aw + 0.9137*am + 0.9961*ay + 0.9882*ar);
451   rgb->g = clip01(aw + 0.6196*ac + ay + 0.5176*ag);
452   rgb->b = clip01(aw + 0.7804*ac + 0.5412*am + 0.0667*ar + 0.2118*ag +
453                   0.4863*ab);
454 }
455
456 void GfxDeviceCMYKColorSpace::getCMYK(GfxColor *color, GfxCMYK *cmyk) {
457   cmyk->c = clip01(color->c[0]);
458   cmyk->m = clip01(color->c[1]);
459   cmyk->y = clip01(color->c[2]);
460   cmyk->k = clip01(color->c[3]);
461 }
462
463 //------------------------------------------------------------------------
464 // GfxLabColorSpace
465 //------------------------------------------------------------------------
466
467 // This is the inverse of MatrixLMN in Example 4.10 from the PostScript
468 // Language Reference, Third Edition.
469 static double xyzrgb[3][3] = {
470   {  3.240449, -1.537136, -0.498531 },
471   { -0.969265,  1.876011,  0.041556 },
472   {  0.055643, -0.204026,  1.057229 }
473 };
474
475 GfxLabColorSpace::GfxLabColorSpace() {
476   whiteX = whiteY = whiteZ = 1;
477   blackX = blackY = blackZ = 0;
478   aMin = bMin = -100;
479   aMax = bMax = 100;
480 }
481
482 GfxLabColorSpace::~GfxLabColorSpace() {
483 }
484
485 GfxColorSpace *GfxLabColorSpace::copy() {
486   GfxLabColorSpace *cs;
487
488   cs = new GfxLabColorSpace();
489   cs->whiteX = whiteX;
490   cs->whiteY = whiteY;
491   cs->whiteZ = whiteZ;
492   cs->blackX = blackX;
493   cs->blackY = blackY;
494   cs->blackZ = blackZ;
495   cs->aMin = aMin;
496   cs->aMax = aMax;
497   cs->bMin = bMin;
498   cs->bMax = bMax;
499   cs->kr = kr;
500   cs->kg = kg;
501   cs->kb = kb;
502   return cs;
503 }
504
505 GfxColorSpace *GfxLabColorSpace::parse(Array *arr) {
506   GfxLabColorSpace *cs;
507   Object obj1, obj2, obj3;
508
509   arr->get(1, &obj1);
510   if (!obj1.isDict()) {
511     error(-1, "Bad Lab color space");
512     obj1.free();
513     return NULL;
514   }
515   cs = new GfxLabColorSpace();
516   if (obj1.dictLookup("WhitePoint", &obj2)->isArray() &&
517       obj2.arrayGetLength() == 3) {
518     obj2.arrayGet(0, &obj3);
519     cs->whiteX = obj3.getNum();
520     obj3.free();
521     obj2.arrayGet(1, &obj3);
522     cs->whiteY = obj3.getNum();
523     obj3.free();
524     obj2.arrayGet(2, &obj3);
525     cs->whiteZ = obj3.getNum();
526     obj3.free();
527   }
528   obj2.free();
529   if (obj1.dictLookup("BlackPoint", &obj2)->isArray() &&
530       obj2.arrayGetLength() == 3) {
531     obj2.arrayGet(0, &obj3);
532     cs->blackX = obj3.getNum();
533     obj3.free();
534     obj2.arrayGet(1, &obj3);
535     cs->blackY = obj3.getNum();
536     obj3.free();
537     obj2.arrayGet(2, &obj3);
538     cs->blackZ = obj3.getNum();
539     obj3.free();
540   }
541   obj2.free();
542   if (obj1.dictLookup("Range", &obj2)->isArray() &&
543       obj2.arrayGetLength() == 4) {
544     obj2.arrayGet(0, &obj3);
545     cs->aMin = obj3.getNum();
546     obj3.free();
547     obj2.arrayGet(1, &obj3);
548     cs->aMax = obj3.getNum();
549     obj3.free();
550     obj2.arrayGet(2, &obj3);
551     cs->bMin = obj3.getNum();
552     obj3.free();
553     obj2.arrayGet(3, &obj3);
554     cs->bMax = obj3.getNum();
555     obj3.free();
556   }
557   obj2.free();
558   obj1.free();
559
560   cs->kr = 1 / (xyzrgb[0][0] * cs->whiteX +
561                 xyzrgb[0][1] * cs->whiteY +
562                 xyzrgb[0][2] * cs->whiteZ);
563   cs->kg = 1 / (xyzrgb[1][0] * cs->whiteX +
564                 xyzrgb[1][1] * cs->whiteY +
565                 xyzrgb[1][2] * cs->whiteZ);
566   cs->kb = 1 / (xyzrgb[2][0] * cs->whiteX +
567                 xyzrgb[2][1] * cs->whiteY +
568                 xyzrgb[2][2] * cs->whiteZ);
569
570   return cs;
571 }
572
573 void GfxLabColorSpace::getGray(GfxColor *color, double *gray) {
574   GfxRGB rgb;
575
576   getRGB(color, &rgb);
577   *gray = clip01(0.299 * rgb.r +
578                  0.587 * rgb.g +
579                  0.114 * rgb.b);
580 }
581
582 void GfxLabColorSpace::getRGB(GfxColor *color, GfxRGB *rgb) {
583   double X, Y, Z;
584   double t1, t2;
585   double r, g, b;
586
587   // convert L*a*b* to CIE 1931 XYZ color space
588   t1 = (color->c[0] + 16) / 116;
589   t2 = t1 + color->c[1] / 500;
590   if (t2 >= (6.0 / 29.0)) {
591     X = t2 * t2 * t2;
592   } else {
593     X = (108.0 / 841.0) * (t2 - (4.0 / 29.0));
594   }
595   X *= whiteX;
596   if (t1 >= (6.0 / 29.0)) {
597     Y = t1 * t1 * t1;
598   } else {
599     Y = (108.0 / 841.0) * (t1 - (4.0 / 29.0));
600   }
601   Y *= whiteY;
602   t2 = t1 - color->c[2] / 200;
603   if (t2 >= (6.0 / 29.0)) {
604     Z = t2 * t2 * t2;
605   } else {
606     Z = (108.0 / 841.0) * (t2 - (4.0 / 29.0));
607   }
608   Z *= whiteZ;
609
610   // convert XYZ to RGB, including gamut mapping and gamma correction
611   r = xyzrgb[0][0] * X + xyzrgb[0][1] * Y + xyzrgb[0][2] * Z;
612   g = xyzrgb[1][0] * X + xyzrgb[1][1] * Y + xyzrgb[1][2] * Z;
613   b = xyzrgb[2][0] * X + xyzrgb[2][1] * Y + xyzrgb[2][2] * Z;
614   rgb->r = pow(clip01(r * kr), 0.5);
615   rgb->g = pow(clip01(g * kg), 0.5);
616   rgb->b = pow(clip01(b * kb), 0.5);
617 }
618
619 void GfxLabColorSpace::getCMYK(GfxColor *color, GfxCMYK *cmyk) {
620   GfxRGB rgb;
621   double c, m, y, k;
622
623   getRGB(color, &rgb);
624   c = clip01(1 - rgb.r);
625   m = clip01(1 - rgb.g);
626   y = clip01(1 - rgb.b);
627   k = c;
628   if (m < k) {
629     k = m;
630   }
631   if (y < k) {
632     k = y;
633   }
634   cmyk->c = c - k;
635   cmyk->m = m - k;
636   cmyk->y = y - k;
637   cmyk->k = k;
638 }
639
640 void GfxLabColorSpace::getDefaultRanges(double *decodeLow, double *decodeRange,
641                                         int maxImgPixel) {
642   decodeLow[0] = 0;
643   decodeRange[0] = 100;
644   decodeLow[1] = aMin;
645   decodeRange[1] = aMax - aMin;
646   decodeLow[2] = bMin;
647   decodeRange[2] = bMax - bMin;
648 }
649
650 //------------------------------------------------------------------------
651 // GfxICCBasedColorSpace
652 //------------------------------------------------------------------------
653
654 GfxICCBasedColorSpace::GfxICCBasedColorSpace(int nCompsA, GfxColorSpace *altA,
655                                              Ref *iccProfileStreamA) {
656   nComps = nCompsA;
657   alt = altA;
658   iccProfileStream = *iccProfileStreamA;
659   rangeMin[0] = rangeMin[1] = rangeMin[2] = rangeMin[3] = 0;
660   rangeMax[0] = rangeMax[1] = rangeMax[2] = rangeMax[3] = 1;
661 }
662
663 GfxICCBasedColorSpace::~GfxICCBasedColorSpace() {
664   delete alt;
665 }
666
667 GfxColorSpace *GfxICCBasedColorSpace::copy() {
668   GfxICCBasedColorSpace *cs;
669   int i;
670
671   cs = new GfxICCBasedColorSpace(nComps, alt->copy(), &iccProfileStream);
672   for (i = 0; i < 4; ++i) {
673     cs->rangeMin[i] = rangeMin[i];
674     cs->rangeMax[i] = rangeMax[i];
675   }
676   return cs;
677 }
678
679 GfxColorSpace *GfxICCBasedColorSpace::parse(Array *arr) {
680   GfxICCBasedColorSpace *cs;
681   Ref iccProfileStreamA;
682   int nCompsA;
683   GfxColorSpace *altA;
684   Dict *dict;
685   Object obj1, obj2, obj3;
686   int i;
687
688   arr->getNF(1, &obj1);
689   if (obj1.isRef()) {
690     iccProfileStreamA = obj1.getRef();
691   } else {
692     iccProfileStreamA.num = 0;
693     iccProfileStreamA.gen = 0;
694   }
695   obj1.free();
696   arr->get(1, &obj1);
697   if (!obj1.isStream()) {
698     error(-1, "Bad ICCBased color space (stream)");
699     obj1.free();
700     return NULL;
701   }
702   dict = obj1.streamGetDict();
703   if (!dict->lookup("N", &obj2)->isInt()) {
704     error(-1, "Bad ICCBased color space (N)");
705     obj2.free();
706     obj1.free();
707     return NULL;
708   }
709   nCompsA = obj2.getInt();
710   obj2.free();
711   if (dict->lookup("Alternate", &obj2)->isNull() ||
712       !(altA = GfxColorSpace::parse(&obj2))) {
713     switch (nCompsA) {
714     case 1:
715       altA = new GfxDeviceGrayColorSpace();
716       break;
717     case 3:
718       altA = new GfxDeviceRGBColorSpace();
719       break;
720     case 4:
721       altA = new GfxDeviceCMYKColorSpace();
722       break;
723     default:
724       error(-1, "Bad ICCBased color space - invalid N");
725       obj2.free();
726       obj1.free();
727       return NULL;
728     }
729   }
730   obj2.free();
731   cs = new GfxICCBasedColorSpace(nCompsA, altA, &iccProfileStreamA);
732   if (dict->lookup("Range", &obj2)->isArray() &&
733       obj2.arrayGetLength() == 2 * nCompsA) {
734     for (i = 0; i < nCompsA; ++i) {
735       obj2.arrayGet(2*i, &obj3);
736       cs->rangeMin[i] = obj3.getNum();
737       obj3.free();
738       obj2.arrayGet(2*i+1, &obj3);
739       cs->rangeMax[i] = obj3.getNum();
740       obj3.free();
741     }
742   }
743   obj2.free();
744   obj1.free();
745   return cs;
746 }
747
748 void GfxICCBasedColorSpace::getGray(GfxColor *color, double *gray) {
749   alt->getGray(color, gray);
750 }
751
752 void GfxICCBasedColorSpace::getRGB(GfxColor *color, GfxRGB *rgb) {
753   alt->getRGB(color, rgb);
754 }
755
756 void GfxICCBasedColorSpace::getCMYK(GfxColor *color, GfxCMYK *cmyk) {
757   alt->getCMYK(color, cmyk);
758 }
759
760 void GfxICCBasedColorSpace::getDefaultRanges(double *decodeLow,
761                                              double *decodeRange,
762                                              int maxImgPixel) {
763   alt->getDefaultRanges(decodeLow, decodeRange, maxImgPixel);
764
765 #if 0
766   // this is nominally correct, but some PDF files don't set the
767   // correct ranges in the ICCBased dict
768   int i;
769
770   for (i = 0; i < nComps; ++i) {
771     decodeLow[i] = rangeMin[i];
772     decodeRange[i] = rangeMax[i] - rangeMin[i];
773   }
774 #endif
775 }
776
777 //------------------------------------------------------------------------
778 // GfxIndexedColorSpace
779 //------------------------------------------------------------------------
780
781 GfxIndexedColorSpace::GfxIndexedColorSpace(GfxColorSpace *baseA,
782                                            int indexHighA) {
783   base = baseA;
784   indexHigh = indexHighA;
785   lookup = (Guchar *)gmalloc((indexHigh + 1) * base->getNComps() *
786                              sizeof(Guchar));
787 }
788
789 GfxIndexedColorSpace::~GfxIndexedColorSpace() {
790   delete base;
791   gfree(lookup);
792 }
793
794 GfxColorSpace *GfxIndexedColorSpace::copy() {
795   GfxIndexedColorSpace *cs;
796
797   cs = new GfxIndexedColorSpace(base->copy(), indexHigh);
798   memcpy(cs->lookup, lookup,
799          (indexHigh + 1) * base->getNComps() * sizeof(Guchar));
800   return cs;
801 }
802
803 GfxColorSpace *GfxIndexedColorSpace::parse(Array *arr) {
804   GfxIndexedColorSpace *cs;
805   GfxColorSpace *baseA;
806   int indexHighA;
807   Object obj1;
808   int x;
809   char *s;
810   int n, i, j;
811
812   if (arr->getLength() != 4) {
813     error(-1, "Bad Indexed color space");
814     goto err1;
815   }
816   arr->get(1, &obj1);
817   if (!(baseA = GfxColorSpace::parse(&obj1))) {
818     error(-1, "Bad Indexed color space (base color space)");
819     goto err2;
820   }
821   obj1.free();
822   if (!arr->get(2, &obj1)->isInt()) {
823     error(-1, "Bad Indexed color space (hival)");
824     delete baseA;
825     goto err2;
826   }
827   indexHighA = obj1.getInt();
828   if (indexHighA < 0 || indexHighA > 255) {
829     // the PDF spec requires indexHigh to be in [0,255] -- allowing
830     // values larger than 255 creates a security hole: if nComps *
831     // indexHigh is greater than 2^31, the loop below may overwrite
832     // past the end of the array
833     error(-1, "Bad Indexed color space (invalid indexHigh value)");
834     delete baseA;
835     goto err2;
836   }
837   obj1.free();
838   cs = new GfxIndexedColorSpace(baseA, indexHighA);
839   arr->get(3, &obj1);
840   n = baseA->getNComps();
841   if (obj1.isStream()) {
842     obj1.streamReset();
843     for (i = 0; i <= indexHighA; ++i) {
844       for (j = 0; j < n; ++j) {
845         if ((x = obj1.streamGetChar()) == EOF) {
846           error(-1, "Bad Indexed color space (lookup table stream too short)");
847           goto err3;
848         }
849         cs->lookup[i*n + j] = (Guchar)x;
850       }
851     }
852     obj1.streamClose();
853   } else if (obj1.isString()) {
854     if (obj1.getString()->getLength() < (indexHighA + 1) * n) {
855       error(-1, "Bad Indexed color space (lookup table string too short)");
856       goto err3;
857     }
858     s = obj1.getString()->getCString();
859     for (i = 0; i <= indexHighA; ++i) {
860       for (j = 0; j < n; ++j) {
861         cs->lookup[i*n + j] = (Guchar)*s++;
862       }
863     }
864   } else {
865     error(-1, "Bad Indexed color space (lookup table)");
866     goto err3;
867   }
868   obj1.free();
869   return cs;
870
871  err3:
872   delete cs;
873  err2:
874   obj1.free();
875  err1:
876   return NULL;
877 }
878
879 GfxColor *GfxIndexedColorSpace::mapColorToBase(GfxColor *color,
880                                                GfxColor *baseColor) {
881   Guchar *p;
882   double low[gfxColorMaxComps], range[gfxColorMaxComps];
883   int n, i;
884
885   n = base->getNComps();
886   base->getDefaultRanges(low, range, indexHigh);
887   p = &lookup[(int)(color->c[0] + 0.5) * n];
888   for (i = 0; i < n; ++i) {
889     baseColor->c[i] = low[i] + (p[i] / 255.0) * range[i];
890   }
891   return baseColor;
892 }
893
894 void GfxIndexedColorSpace::getGray(GfxColor *color, double *gray) {
895   GfxColor color2;
896
897   base->getGray(mapColorToBase(color, &color2), gray);
898 }
899
900 void GfxIndexedColorSpace::getRGB(GfxColor *color, GfxRGB *rgb) {
901   GfxColor color2;
902
903   base->getRGB(mapColorToBase(color, &color2), rgb);
904 }
905
906 void GfxIndexedColorSpace::getCMYK(GfxColor *color, GfxCMYK *cmyk) {
907   GfxColor color2;
908
909   base->getCMYK(mapColorToBase(color, &color2), cmyk);
910 }
911
912 void GfxIndexedColorSpace::getDefaultRanges(double *decodeLow,
913                                             double *decodeRange,
914                                             int maxImgPixel) {
915   decodeLow[0] = 0;
916   decodeRange[0] = maxImgPixel;
917 }
918
919 //------------------------------------------------------------------------
920 // GfxSeparationColorSpace
921 //------------------------------------------------------------------------
922
923 GfxSeparationColorSpace::GfxSeparationColorSpace(GString *nameA,
924                                                  GfxColorSpace *altA,
925                                                  Function *funcA) {
926   name = nameA;
927   alt = altA;
928   func = funcA;
929 }
930
931 GfxSeparationColorSpace::~GfxSeparationColorSpace() {
932   delete name;
933   delete alt;
934   delete func;
935 }
936
937 GfxColorSpace *GfxSeparationColorSpace::copy() {
938   return new GfxSeparationColorSpace(name->copy(), alt->copy(), func->copy());
939 }
940
941 //~ handle the 'All' and 'None' colorants
942 GfxColorSpace *GfxSeparationColorSpace::parse(Array *arr) {
943   GfxSeparationColorSpace *cs;
944   GString *nameA;
945   GfxColorSpace *altA;
946   Function *funcA;
947   Object obj1;
948
949   if (arr->getLength() != 4) {
950     error(-1, "Bad Separation color space");
951     goto err1;
952   }
953   if (!arr->get(1, &obj1)->isName()) {
954     error(-1, "Bad Separation color space (name)");
955     goto err2;
956   }
957   nameA = new GString(obj1.getName());
958   obj1.free();
959   arr->get(2, &obj1);
960   if (!(altA = GfxColorSpace::parse(&obj1))) {
961     error(-1, "Bad Separation color space (alternate color space)");
962     goto err3;
963   }
964   obj1.free();
965   arr->get(3, &obj1);
966   if (!(funcA = Function::parse(&obj1))) {
967     goto err4;
968   }
969   obj1.free();
970   cs = new GfxSeparationColorSpace(nameA, altA, funcA);
971   return cs;
972
973  err4:
974   delete altA;
975  err3:
976   delete nameA;
977  err2:
978   obj1.free();
979  err1:
980   return NULL;
981 }
982
983 void GfxSeparationColorSpace::getGray(GfxColor *color, double *gray) {
984   GfxColor color2;
985
986   func->transform(color->c, color2.c);
987   alt->getGray(&color2, gray);
988 }
989
990 void GfxSeparationColorSpace::getRGB(GfxColor *color, GfxRGB *rgb) {
991   GfxColor color2;
992
993   func->transform(color->c, color2.c);
994   alt->getRGB(&color2, rgb);
995 }
996
997 void GfxSeparationColorSpace::getCMYK(GfxColor *color, GfxCMYK *cmyk) {
998   GfxColor color2;
999
1000   func->transform(color->c, color2.c);
1001   alt->getCMYK(&color2, cmyk);
1002 }
1003
1004 //------------------------------------------------------------------------
1005 // GfxDeviceNColorSpace
1006 //------------------------------------------------------------------------
1007
1008 GfxDeviceNColorSpace::GfxDeviceNColorSpace(int nCompsA,
1009                                            GfxColorSpace *altA,
1010                                            Function *funcA) {
1011   nComps = nCompsA;
1012   alt = altA;
1013   func = funcA;
1014 }
1015
1016 GfxDeviceNColorSpace::~GfxDeviceNColorSpace() {
1017   int i;
1018
1019   for (i = 0; i < nComps; ++i) {
1020     delete names[i];
1021   }
1022   delete alt;
1023   delete func;
1024 }
1025
1026 GfxColorSpace *GfxDeviceNColorSpace::copy() {
1027   GfxDeviceNColorSpace *cs;
1028   int i;
1029
1030   cs = new GfxDeviceNColorSpace(nComps, alt->copy(), func->copy());
1031   for (i = 0; i < nComps; ++i) {
1032     cs->names[i] = names[i]->copy();
1033   }
1034   return cs;
1035 }
1036
1037 //~ handle the 'None' colorant
1038 GfxColorSpace *GfxDeviceNColorSpace::parse(Array *arr) {
1039   GfxDeviceNColorSpace *cs;
1040   int nCompsA;
1041   GString *namesA[gfxColorMaxComps];
1042   GfxColorSpace *altA;
1043   Function *funcA;
1044   Object obj1, obj2;
1045   int i;
1046
1047   if (arr->getLength() != 4 && arr->getLength() != 5) {
1048     error(-1, "Bad DeviceN color space");
1049     goto err1;
1050   }
1051   if (!arr->get(1, &obj1)->isArray()) {
1052     error(-1, "Bad DeviceN color space (names)");
1053     goto err2;
1054   }
1055   nCompsA = obj1.arrayGetLength();
1056   if (nCompsA > gfxColorMaxComps) {
1057     error(-1, "DeviceN color space with more than %d > %d components",
1058           nCompsA, gfxColorMaxComps);
1059     nCompsA = gfxColorMaxComps;
1060   }
1061   for (i = 0; i < nCompsA; ++i) {
1062     if (!obj1.arrayGet(i, &obj2)->isName()) {
1063       error(-1, "Bad DeviceN color space (names)");
1064       obj2.free();
1065       goto err2;
1066     }
1067     namesA[i] = new GString(obj2.getName());
1068     obj2.free();
1069   }
1070   obj1.free();
1071   arr->get(2, &obj1);
1072   if (!(altA = GfxColorSpace::parse(&obj1))) {
1073     error(-1, "Bad DeviceN color space (alternate color space)");
1074     goto err3;
1075   }
1076   obj1.free();
1077   arr->get(3, &obj1);
1078   if (!(funcA = Function::parse(&obj1))) {
1079     goto err4;
1080   }
1081   obj1.free();
1082   cs = new GfxDeviceNColorSpace(nCompsA, altA, funcA);
1083   for (i = 0; i < nCompsA; ++i) {
1084     cs->names[i] = namesA[i];
1085   }
1086   return cs;
1087
1088  err4:
1089   delete altA;
1090  err3:
1091   for (i = 0; i < nCompsA; ++i) {
1092     delete namesA[i];
1093   }
1094  err2:
1095   obj1.free();
1096  err1:
1097   return NULL;
1098 }
1099
1100 void GfxDeviceNColorSpace::getGray(GfxColor *color, double *gray) {
1101   GfxColor color2;
1102
1103   func->transform(color->c, color2.c);
1104   alt->getGray(&color2, gray);
1105 }
1106
1107 void GfxDeviceNColorSpace::getRGB(GfxColor *color, GfxRGB *rgb) {
1108   GfxColor color2;
1109
1110   func->transform(color->c, color2.c);
1111   alt->getRGB(&color2, rgb);
1112 }
1113
1114 void GfxDeviceNColorSpace::getCMYK(GfxColor *color, GfxCMYK *cmyk) {
1115   GfxColor color2;
1116
1117   func->transform(color->c, color2.c);
1118   alt->getCMYK(&color2, cmyk);
1119 }
1120
1121 //------------------------------------------------------------------------
1122 // GfxPatternColorSpace
1123 //------------------------------------------------------------------------
1124
1125 GfxPatternColorSpace::GfxPatternColorSpace(GfxColorSpace *underA) {
1126   under = underA;
1127 }
1128
1129 GfxPatternColorSpace::~GfxPatternColorSpace() {
1130   if (under) {
1131     delete under;
1132   }
1133 }
1134
1135 GfxColorSpace *GfxPatternColorSpace::copy() {
1136   return new GfxPatternColorSpace(under ? under->copy() :
1137                                           (GfxColorSpace *)NULL);
1138 }
1139
1140 GfxColorSpace *GfxPatternColorSpace::parse(Array *arr) {
1141   GfxPatternColorSpace *cs;
1142   GfxColorSpace *underA;
1143   Object obj1;
1144
1145   if (arr->getLength() != 1 && arr->getLength() != 2) {
1146     error(-1, "Bad Pattern color space");
1147     return NULL;
1148   }
1149   underA = NULL;
1150   if (arr->getLength() == 2) {
1151     arr->get(1, &obj1);
1152     if (!(underA = GfxColorSpace::parse(&obj1))) {
1153       error(-1, "Bad Pattern color space (underlying color space)");
1154       obj1.free();
1155       return NULL;
1156     }
1157     obj1.free();
1158   }
1159   cs = new GfxPatternColorSpace(underA);
1160   return cs;
1161 }
1162
1163 void GfxPatternColorSpace::getGray(GfxColor *color, double *gray) {
1164   *gray = 0;
1165 }
1166
1167 void GfxPatternColorSpace::getRGB(GfxColor *color, GfxRGB *rgb) {
1168   rgb->r = rgb->g = rgb->b = 0;
1169 }
1170
1171 void GfxPatternColorSpace::getCMYK(GfxColor *color, GfxCMYK *cmyk) {
1172   cmyk->c = cmyk->m = cmyk->y = 0;
1173   cmyk->k = 1;
1174 }
1175
1176 //------------------------------------------------------------------------
1177 // Pattern
1178 //------------------------------------------------------------------------
1179
1180 GfxPattern::GfxPattern(int typeA) {
1181   type = typeA;
1182 }
1183
1184 GfxPattern::~GfxPattern() {
1185 }
1186
1187 GfxPattern *GfxPattern::parse(Object *obj) {
1188   GfxPattern *pattern;
1189   Object obj1;
1190
1191   if (obj->isDict()) {
1192     obj->dictLookup("PatternType", &obj1);
1193   } else if (obj->isStream()) {
1194     obj->streamGetDict()->lookup("PatternType", &obj1);
1195   } else {
1196     return NULL;
1197   }
1198   pattern = NULL;
1199   if (obj1.isInt() && obj1.getInt() == 1) {
1200     pattern = GfxTilingPattern::parse(obj);
1201   } else if (obj1.isInt() && obj1.getInt() == 2) {
1202     pattern = GfxShadingPattern::parse(obj);
1203   }
1204   obj1.free();
1205   return pattern;
1206 }
1207
1208 //------------------------------------------------------------------------
1209 // GfxTilingPattern
1210 //------------------------------------------------------------------------
1211
1212 GfxTilingPattern *GfxTilingPattern::parse(Object *patObj) {
1213   GfxTilingPattern *pat;
1214   Dict *dict;
1215   int paintTypeA, tilingTypeA;
1216   double bboxA[4], matrixA[6];
1217   double xStepA, yStepA;
1218   Object resDictA;
1219   Object obj1, obj2;
1220   int i;
1221
1222   if (!patObj->isStream()) {
1223     return NULL;
1224   }
1225   dict = patObj->streamGetDict();
1226
1227   if (dict->lookup("PaintType", &obj1)->isInt()) {
1228     paintTypeA = obj1.getInt();
1229   } else {
1230     paintTypeA = 1;
1231     error(-1, "Invalid or missing PaintType in pattern");
1232   }
1233   obj1.free();
1234   if (dict->lookup("TilingType", &obj1)->isInt()) {
1235     tilingTypeA = obj1.getInt();
1236   } else {
1237     tilingTypeA = 1;
1238     error(-1, "Invalid or missing TilingType in pattern");
1239   }
1240   obj1.free();
1241   bboxA[0] = bboxA[1] = 0;
1242   bboxA[2] = bboxA[3] = 1;
1243   if (dict->lookup("BBox", &obj1)->isArray() &&
1244       obj1.arrayGetLength() == 4) {
1245     for (i = 0; i < 4; ++i) {
1246       if (obj1.arrayGet(i, &obj2)->isNum()) {
1247         bboxA[i] = obj2.getNum();
1248       }
1249       obj2.free();
1250     }
1251   } else {
1252     error(-1, "Invalid or missing BBox in pattern");
1253   }
1254   obj1.free();
1255   if (dict->lookup("XStep", &obj1)->isNum()) {
1256     xStepA = obj1.getNum();
1257   } else {
1258     xStepA = 1;
1259     error(-1, "Invalid or missing XStep in pattern");
1260   }
1261   obj1.free();
1262   if (dict->lookup("YStep", &obj1)->isNum()) {
1263     yStepA = obj1.getNum();
1264   } else {
1265     yStepA = 1;
1266     error(-1, "Invalid or missing YStep in pattern");
1267   }
1268   obj1.free();
1269   if (!dict->lookup("Resources", &resDictA)->isDict()) {
1270     resDictA.free();
1271     resDictA.initNull();
1272     error(-1, "Invalid or missing Resources in pattern");
1273   }
1274   matrixA[0] = 1; matrixA[1] = 0;
1275   matrixA[2] = 0; matrixA[3] = 1;
1276   matrixA[4] = 0; matrixA[5] = 0;
1277   if (dict->lookup("Matrix", &obj1)->isArray() &&
1278       obj1.arrayGetLength() == 6) {
1279     for (i = 0; i < 6; ++i) {
1280       if (obj1.arrayGet(i, &obj2)->isNum()) {
1281         matrixA[i] = obj2.getNum();
1282       }
1283       obj2.free();
1284     }
1285   }
1286   obj1.free();
1287
1288   pat = new GfxTilingPattern(paintTypeA, tilingTypeA, bboxA, xStepA, yStepA,
1289                              &resDictA, matrixA, patObj);
1290   resDictA.free();
1291   return pat;
1292 }
1293
1294 GfxTilingPattern::GfxTilingPattern(int paintTypeA, int tilingTypeA,
1295                                    double *bboxA, double xStepA, double yStepA,
1296                                    Object *resDictA, double *matrixA,
1297                                    Object *contentStreamA):
1298   GfxPattern(1)
1299 {
1300   int i;
1301
1302   paintType = paintTypeA;
1303   tilingType = tilingTypeA;
1304   for (i = 0; i < 4; ++i) {
1305     bbox[i] = bboxA[i];
1306   }
1307   xStep = xStepA;
1308   yStep = yStepA;
1309   resDictA->copy(&resDict);
1310   for (i = 0; i < 6; ++i) {
1311     matrix[i] = matrixA[i];
1312   }
1313   contentStreamA->copy(&contentStream);
1314 }
1315
1316 GfxTilingPattern::~GfxTilingPattern() {
1317   resDict.free();
1318   contentStream.free();
1319 }
1320
1321 GfxPattern *GfxTilingPattern::copy() {
1322   return new GfxTilingPattern(paintType, tilingType, bbox, xStep, yStep,
1323                               &resDict, matrix, &contentStream);
1324 }
1325
1326 //------------------------------------------------------------------------
1327 // GfxShadingPattern
1328 //------------------------------------------------------------------------
1329
1330 GfxShadingPattern *GfxShadingPattern::parse(Object *patObj) {
1331   Dict *dict;
1332   GfxShading *shadingA;
1333   double matrixA[6];
1334   Object obj1, obj2;
1335   int i;
1336
1337   if (!patObj->isDict()) {
1338     return NULL;
1339   }
1340   dict = patObj->getDict();
1341
1342   dict->lookup("Shading", &obj1);
1343   shadingA = GfxShading::parse(&obj1);
1344   obj1.free();
1345   if (!shadingA) {
1346     return NULL;
1347   }
1348
1349   matrixA[0] = 1; matrixA[1] = 0;
1350   matrixA[2] = 0; matrixA[3] = 1;
1351   matrixA[4] = 0; matrixA[5] = 0;
1352   if (dict->lookup("Matrix", &obj1)->isArray() &&
1353       obj1.arrayGetLength() == 6) {
1354     for (i = 0; i < 6; ++i) {
1355       if (obj1.arrayGet(i, &obj2)->isNum()) {
1356         matrixA[i] = obj2.getNum();
1357       }
1358       obj2.free();
1359     }
1360   }
1361   obj1.free();
1362
1363   return new GfxShadingPattern(shadingA, matrixA);
1364 }
1365
1366 GfxShadingPattern::GfxShadingPattern(GfxShading *shadingA, double *matrixA):
1367   GfxPattern(2)
1368 {
1369   int i;
1370
1371   shading = shadingA;
1372   for (i = 0; i < 6; ++i) {
1373     matrix[i] = matrixA[i];
1374   }
1375 }
1376
1377 GfxShadingPattern::~GfxShadingPattern() {
1378   delete shading;
1379 }
1380
1381 GfxPattern *GfxShadingPattern::copy() {
1382   return new GfxShadingPattern(shading->copy(), matrix);
1383 }
1384
1385 //------------------------------------------------------------------------
1386 // GfxShading
1387 //------------------------------------------------------------------------
1388
1389 GfxShading::GfxShading(int typeA) {
1390   type = typeA;
1391   colorSpace = NULL;
1392 }
1393
1394 GfxShading::GfxShading(GfxShading *shading) {
1395   int i;
1396
1397   type = shading->type;
1398   colorSpace = shading->colorSpace->copy();
1399   for (i = 0; i < gfxColorMaxComps; ++i) {
1400     background.c[i] = shading->background.c[i];
1401   }
1402   hasBackground = shading->hasBackground;
1403   xMin = shading->xMin;
1404   yMin = shading->yMin;
1405   xMax = shading->xMax;
1406   yMax = shading->yMax;
1407   hasBBox = shading->hasBBox;
1408 }
1409
1410 GfxShading::~GfxShading() {
1411   if (colorSpace) {
1412     delete colorSpace;
1413   }
1414 }
1415
1416 GfxShading *GfxShading::parse(Object *obj) {
1417   GfxShading *shading;
1418   Dict *dict;
1419   int typeA;
1420   Object obj1;
1421
1422   if (obj->isDict()) {
1423     dict = obj->getDict();
1424   } else if (obj->isStream()) {
1425     dict = obj->streamGetDict();
1426   } else {
1427     return NULL;
1428   }
1429
1430   if (!dict->lookup("ShadingType", &obj1)->isInt()) {
1431     error(-1, "Invalid ShadingType in shading dictionary");
1432     obj1.free();
1433     return NULL;
1434   }
1435   typeA = obj1.getInt();
1436   obj1.free();
1437
1438   switch (typeA) {
1439   case 1:
1440     shading = GfxFunctionShading::parse(dict);
1441     break;
1442   case 2:
1443     shading = GfxAxialShading::parse(dict);
1444     break;
1445   case 3:
1446     shading = GfxRadialShading::parse(dict);
1447     break;
1448   default:
1449     error(-1, "Unimplemented shading type %d", typeA);
1450     goto err1;
1451   }
1452
1453   return shading;
1454
1455  err1:
1456   return NULL;
1457 }
1458
1459 GBool GfxShading::init(Dict *dict) {
1460   Object obj1, obj2;
1461   int i;
1462
1463   dict->lookup("ColorSpace", &obj1);
1464   if (!(colorSpace = GfxColorSpace::parse(&obj1))) {
1465     error(-1, "Bad color space in shading dictionary");
1466     obj1.free();
1467     return gFalse;
1468   }
1469   obj1.free();
1470
1471   for (i = 0; i < gfxColorMaxComps; ++i) {
1472     background.c[i] = 0;
1473   }
1474   hasBackground = gFalse;
1475   if (dict->lookup("Background", &obj1)->isArray()) {
1476     if (obj1.arrayGetLength() == colorSpace->getNComps()) {
1477       hasBackground = gTrue;
1478       for (i = 0; i < colorSpace->getNComps(); ++i) {
1479         background.c[i] = obj1.arrayGet(i, &obj2)->getNum();
1480         obj2.free();
1481       }
1482     } else {
1483       error(-1, "Bad Background in shading dictionary");
1484     }
1485   }
1486   obj1.free();
1487
1488   xMin = yMin = xMax = yMax = 0;
1489   hasBBox = gFalse;
1490   if (dict->lookup("BBox", &obj1)->isArray()) {
1491     if (obj1.arrayGetLength() == 4) {
1492       hasBBox = gTrue;
1493       xMin = obj1.arrayGet(0, &obj2)->getNum();
1494       obj2.free();
1495       yMin = obj1.arrayGet(1, &obj2)->getNum();
1496       obj2.free();
1497       xMax = obj1.arrayGet(2, &obj2)->getNum();
1498       obj2.free();
1499       yMax = obj1.arrayGet(3, &obj2)->getNum();
1500       obj2.free();
1501     } else {
1502       error(-1, "Bad BBox in shading dictionary");
1503     }
1504   }
1505   obj1.free();
1506
1507   return gTrue;
1508 }
1509
1510 //------------------------------------------------------------------------
1511 // GfxFunctionShading
1512 //------------------------------------------------------------------------
1513
1514 GfxFunctionShading::GfxFunctionShading(double x0A, double y0A,
1515                                        double x1A, double y1A,
1516                                        double *matrixA,
1517                                        Function **funcsA, int nFuncsA):
1518   GfxShading(1)
1519 {
1520   int i;
1521
1522   x0 = x0A;
1523   y0 = y0A;
1524   x1 = x1A;
1525   y1 = y1A;
1526   for (i = 0; i < 6; ++i) {
1527     matrix[i] = matrixA[i];
1528   }
1529   nFuncs = nFuncsA;
1530   for (i = 0; i < nFuncs; ++i) {
1531     funcs[i] = funcsA[i];
1532   }
1533 }
1534
1535 GfxFunctionShading::GfxFunctionShading(GfxFunctionShading *shading):
1536   GfxShading(shading)
1537 {
1538   int i;
1539
1540   x0 = shading->x0;
1541   y0 = shading->y0;
1542   x1 = shading->x1;
1543   y1 = shading->y1;
1544   for (i = 0; i < 6; ++i) {
1545     matrix[i] = shading->matrix[i];
1546   }
1547   nFuncs = shading->nFuncs;
1548   for (i = 0; i < nFuncs; ++i) {
1549     funcs[i] = shading->funcs[i]->copy();
1550   }
1551 }
1552
1553 GfxFunctionShading::~GfxFunctionShading() {
1554   int i;
1555
1556   for (i = 0; i < nFuncs; ++i) {
1557     delete funcs[i];
1558   }
1559 }
1560
1561 GfxFunctionShading *GfxFunctionShading::parse(Dict *dict) {
1562   GfxFunctionShading *shading;
1563   double x0A, y0A, x1A, y1A;
1564   double matrixA[6];
1565   Function *funcsA[gfxColorMaxComps];
1566   int nFuncsA;
1567   Object obj1, obj2;
1568   int i;
1569
1570   x0A = y0A = 0;
1571   x1A = y1A = 1;
1572   if (dict->lookup("Domain", &obj1)->isArray() &&
1573       obj1.arrayGetLength() == 4) {
1574     x0A = obj1.arrayGet(0, &obj2)->getNum();
1575     obj2.free();
1576     y0A = obj1.arrayGet(1, &obj2)->getNum();
1577     obj2.free();
1578     x1A = obj1.arrayGet(2, &obj2)->getNum();
1579     obj2.free();
1580     y1A = obj1.arrayGet(3, &obj2)->getNum();
1581     obj2.free();
1582   }
1583   obj1.free();
1584
1585   matrixA[0] = 1; matrixA[1] = 0;
1586   matrixA[2] = 0; matrixA[3] = 1;
1587   matrixA[4] = 0; matrixA[5] = 0;
1588   if (dict->lookup("Matrix", &obj1)->isArray() &&
1589       obj1.arrayGetLength() == 6) {
1590     matrixA[0] = obj1.arrayGet(0, &obj2)->getNum();
1591     obj2.free();
1592     matrixA[1] = obj1.arrayGet(1, &obj2)->getNum();
1593     obj2.free();
1594     matrixA[2] = obj1.arrayGet(2, &obj2)->getNum();
1595     obj2.free();
1596     matrixA[3] = obj1.arrayGet(3, &obj2)->getNum();
1597     obj2.free();
1598     matrixA[4] = obj1.arrayGet(4, &obj2)->getNum();
1599     obj2.free();
1600     matrixA[5] = obj1.arrayGet(5, &obj2)->getNum();
1601     obj2.free();
1602   }
1603   obj1.free();
1604
1605   dict->lookup("Function", &obj1);
1606   if (obj1.isArray()) {
1607     nFuncsA = obj1.arrayGetLength();
1608     if (nFuncsA > gfxColorMaxComps) {
1609       error(-1, "Invalid Function array in shading dictionary");
1610       goto err1;
1611     }
1612     for (i = 0; i < nFuncsA; ++i) {
1613       obj1.arrayGet(i, &obj2);
1614       if (!(funcsA[i] = Function::parse(&obj2))) {
1615         goto err2;
1616       }
1617       obj2.free();
1618     }
1619   } else {
1620     nFuncsA = 1;
1621     if (!(funcsA[0] = Function::parse(&obj1))) {
1622       goto err1;
1623     }
1624   }
1625   obj1.free();
1626
1627   shading = new GfxFunctionShading(x0A, y0A, x1A, y1A, matrixA,
1628                                    funcsA, nFuncsA);
1629   if (!shading->init(dict)) {
1630     delete shading;
1631     return NULL;
1632   }
1633   return shading;
1634
1635  err2:
1636   obj2.free();
1637  err1:
1638   obj1.free();
1639   return NULL;
1640 }
1641
1642 GfxShading *GfxFunctionShading::copy() {
1643   return new GfxFunctionShading(this);
1644 }
1645
1646 void GfxFunctionShading::getColor(double x, double y, GfxColor *color) {
1647   double in[2];
1648   int i;
1649
1650   in[0] = x;
1651   in[1] = y;
1652   for (i = 0; i < nFuncs; ++i) {
1653     funcs[i]->transform(in, &color->c[i]);
1654   }
1655 }
1656
1657 //------------------------------------------------------------------------
1658 // GfxAxialShading
1659 //------------------------------------------------------------------------
1660
1661 GfxAxialShading::GfxAxialShading(double x0A, double y0A,
1662                                  double x1A, double y1A,
1663                                  double t0A, double t1A,
1664                                  Function **funcsA, int nFuncsA,
1665                                  GBool extend0A, GBool extend1A):
1666   GfxShading(2)
1667 {
1668   int i;
1669
1670   x0 = x0A;
1671   y0 = y0A;
1672   x1 = x1A;
1673   y1 = y1A;
1674   t0 = t0A;
1675   t1 = t1A;
1676   nFuncs = nFuncsA;
1677   for (i = 0; i < nFuncs; ++i) {
1678     funcs[i] = funcsA[i];
1679   }
1680   extend0 = extend0A;
1681   extend1 = extend1A;
1682 }
1683
1684 GfxAxialShading::GfxAxialShading(GfxAxialShading *shading):
1685   GfxShading(shading)
1686 {
1687   int i;
1688
1689   x0 = shading->x0;
1690   y0 = shading->y0;
1691   x1 = shading->x1;
1692   y1 = shading->y1;
1693   t0 = shading->t0;
1694   y1 = shading->t1;
1695   nFuncs = shading->nFuncs;
1696   for (i = 0; i < nFuncs; ++i) {
1697     funcs[i] = shading->funcs[i]->copy();
1698   }
1699   extend0 = shading->extend0;
1700   extend1 = shading->extend1;
1701 }
1702
1703 GfxAxialShading::~GfxAxialShading() {
1704   int i;
1705
1706   for (i = 0; i < nFuncs; ++i) {
1707     delete funcs[i];
1708   }
1709 }
1710
1711 GfxAxialShading *GfxAxialShading::parse(Dict *dict) {
1712   GfxAxialShading *shading;
1713   double x0A, y0A, x1A, y1A;
1714   double t0A, t1A;
1715   Function *funcsA[gfxColorMaxComps];
1716   int nFuncsA;
1717   GBool extend0A, extend1A;
1718   Object obj1, obj2;
1719   int i;
1720
1721   x0A = y0A = x1A = y1A = 0;
1722   if (dict->lookup("Coords", &obj1)->isArray() &&
1723       obj1.arrayGetLength() == 4) {
1724     x0A = obj1.arrayGet(0, &obj2)->getNum();
1725     obj2.free();
1726     y0A = obj1.arrayGet(1, &obj2)->getNum();
1727     obj2.free();
1728     x1A = obj1.arrayGet(2, &obj2)->getNum();
1729     obj2.free();
1730     y1A = obj1.arrayGet(3, &obj2)->getNum();
1731     obj2.free();
1732   } else {
1733     error(-1, "Missing or invalid Coords in shading dictionary");
1734     goto err1;
1735   }
1736   obj1.free();
1737
1738   t0A = 0;
1739   t1A = 1;
1740   if (dict->lookup("Domain", &obj1)->isArray() &&
1741       obj1.arrayGetLength() == 2) {
1742     t0A = obj1.arrayGet(0, &obj2)->getNum();
1743     obj2.free();
1744     t1A = obj1.arrayGet(1, &obj2)->getNum();
1745     obj2.free();
1746   }
1747   obj1.free();
1748
1749   dict->lookup("Function", &obj1);
1750   if (obj1.isArray()) {
1751     nFuncsA = obj1.arrayGetLength();
1752     if (nFuncsA > gfxColorMaxComps) {
1753       error(-1, "Invalid Function array in shading dictionary");
1754       goto err1;
1755     }
1756     for (i = 0; i < nFuncsA; ++i) {
1757       obj1.arrayGet(i, &obj2);
1758       if (!(funcsA[i] = Function::parse(&obj2))) {
1759         obj1.free();
1760         obj2.free();
1761         goto err1;
1762       }
1763       obj2.free();
1764     }
1765   } else {
1766     nFuncsA = 1;
1767     if (!(funcsA[0] = Function::parse(&obj1))) {
1768       obj1.free();
1769       goto err1;
1770     }
1771   }
1772   obj1.free();
1773
1774   extend0A = extend1A = gFalse;
1775   if (dict->lookup("Extend", &obj1)->isArray() &&
1776       obj1.arrayGetLength() == 2) {
1777     extend0A = obj1.arrayGet(0, &obj2)->getBool();
1778     obj2.free();
1779     extend1A = obj1.arrayGet(1, &obj2)->getBool();
1780     obj2.free();
1781   }
1782   obj1.free();
1783
1784   shading = new GfxAxialShading(x0A, y0A, x1A, y1A, t0A, t1A,
1785                                 funcsA, nFuncsA, extend0A, extend1A);
1786   if (!shading->init(dict)) {
1787     delete shading;
1788     return NULL;
1789   }
1790   return shading;
1791
1792  err1:
1793   return NULL;
1794 }
1795
1796 GfxShading *GfxAxialShading::copy() {
1797   return new GfxAxialShading(this);
1798 }
1799
1800 void GfxAxialShading::getColor(double t, GfxColor *color) {
1801   int i;
1802
1803   // NB: there can be one function with n outputs or n functions with
1804   // one output each (where n = number of color components)
1805   for (i = 0; i < nFuncs; ++i) {
1806     funcs[i]->transform(&t, &color->c[i]);
1807   }
1808 }
1809
1810 //------------------------------------------------------------------------
1811 // GfxRadialShading
1812 //------------------------------------------------------------------------
1813
1814 GfxRadialShading::GfxRadialShading(double x0A, double y0A, double r0A,
1815                                    double x1A, double y1A, double r1A,
1816                                    double t0A, double t1A,
1817                                    Function **funcsA, int nFuncsA,
1818                                    GBool extend0A, GBool extend1A):
1819   GfxShading(3)
1820 {
1821   int i;
1822
1823   x0 = x0A;
1824   y0 = y0A;
1825   r0 = r0A;
1826   x1 = x1A;
1827   y1 = y1A;
1828   r1 = r1A;
1829   t0 = t0A;
1830   t1 = t1A;
1831   nFuncs = nFuncsA;
1832   for (i = 0; i < nFuncs; ++i) {
1833     funcs[i] = funcsA[i];
1834   }
1835   extend0 = extend0A;
1836   extend1 = extend1A;
1837 }
1838
1839 GfxRadialShading::GfxRadialShading(GfxRadialShading *shading):
1840   GfxShading(shading)
1841 {
1842   int i;
1843
1844   x0 = shading->x0;
1845   y0 = shading->y0;
1846   r0 = shading->r0;
1847   x1 = shading->x1;
1848   y1 = shading->y1;
1849   r1 = shading->r1;
1850   t0 = shading->t0;
1851   y1 = shading->t1;
1852   nFuncs = shading->nFuncs;
1853   for (i = 0; i < nFuncs; ++i) {
1854     funcs[i] = shading->funcs[i]->copy();
1855   }
1856   extend0 = shading->extend0;
1857   extend1 = shading->extend1;
1858 }
1859
1860 GfxRadialShading::~GfxRadialShading() {
1861   int i;
1862
1863   for (i = 0; i < nFuncs; ++i) {
1864     delete funcs[i];
1865   }
1866 }
1867
1868 GfxRadialShading *GfxRadialShading::parse(Dict *dict) {
1869   GfxRadialShading *shading;
1870   double x0A, y0A, r0A, x1A, y1A, r1A;
1871   double t0A, t1A;
1872   Function *funcsA[gfxColorMaxComps];
1873   int nFuncsA;
1874   GBool extend0A, extend1A;
1875   Object obj1, obj2;
1876   int i;
1877
1878   x0A = y0A = r0A = x1A = y1A = r1A = 0;
1879   if (dict->lookup("Coords", &obj1)->isArray() &&
1880       obj1.arrayGetLength() == 6) {
1881     x0A = obj1.arrayGet(0, &obj2)->getNum();
1882     obj2.free();
1883     y0A = obj1.arrayGet(1, &obj2)->getNum();
1884     obj2.free();
1885     r0A = obj1.arrayGet(2, &obj2)->getNum();
1886     obj2.free();
1887     x1A = obj1.arrayGet(3, &obj2)->getNum();
1888     obj2.free();
1889     y1A = obj1.arrayGet(4, &obj2)->getNum();
1890     obj2.free();
1891     r1A = obj1.arrayGet(5, &obj2)->getNum();
1892     obj2.free();
1893   } else {
1894     error(-1, "Missing or invalid Coords in shading dictionary");
1895     goto err1;
1896   }
1897   obj1.free();
1898
1899   t0A = 0;
1900   t1A = 1;
1901   if (dict->lookup("Domain", &obj1)->isArray() &&
1902       obj1.arrayGetLength() == 2) {
1903     t0A = obj1.arrayGet(0, &obj2)->getNum();
1904     obj2.free();
1905     t1A = obj1.arrayGet(1, &obj2)->getNum();
1906     obj2.free();
1907   }
1908   obj1.free();
1909
1910   dict->lookup("Function", &obj1);
1911   if (obj1.isArray()) {
1912     nFuncsA = obj1.arrayGetLength();
1913     if (nFuncsA > gfxColorMaxComps) {
1914       error(-1, "Invalid Function array in shading dictionary");
1915       goto err1;
1916     }
1917     for (i = 0; i < nFuncsA; ++i) {
1918       obj1.arrayGet(i, &obj2);
1919       if (!(funcsA[i] = Function::parse(&obj2))) {
1920         obj1.free();
1921         obj2.free();
1922         goto err1;
1923       }
1924       obj2.free();
1925     }
1926   } else {
1927     nFuncsA = 1;
1928     if (!(funcsA[0] = Function::parse(&obj1))) {
1929       obj1.free();
1930       goto err1;
1931     }
1932   }
1933   obj1.free();
1934
1935   extend0A = extend1A = gFalse;
1936   if (dict->lookup("Extend", &obj1)->isArray() &&
1937       obj1.arrayGetLength() == 2) {
1938     extend0A = obj1.arrayGet(0, &obj2)->getBool();
1939     obj2.free();
1940     extend1A = obj1.arrayGet(1, &obj2)->getBool();
1941     obj2.free();
1942   }
1943   obj1.free();
1944
1945   shading = new GfxRadialShading(x0A, y0A, r0A, x1A, y1A, r1A, t0A, t1A,
1946                                  funcsA, nFuncsA, extend0A, extend1A);
1947   if (!shading->init(dict)) {
1948     delete shading;
1949     return NULL;
1950   }
1951   return shading;
1952
1953  err1:
1954   return NULL;
1955 }
1956
1957 GfxShading *GfxRadialShading::copy() {
1958   return new GfxRadialShading(this);
1959 }
1960
1961 void GfxRadialShading::getColor(double t, GfxColor *color) {
1962   int i;
1963
1964   // NB: there can be one function with n outputs or n functions with
1965   // one output each (where n = number of color components)
1966   for (i = 0; i < nFuncs; ++i) {
1967     funcs[i]->transform(&t, &color->c[i]);
1968   }
1969 }
1970
1971 //------------------------------------------------------------------------
1972 // GfxImageColorMap
1973 //------------------------------------------------------------------------
1974
1975 GfxImageColorMap::GfxImageColorMap(int bitsA, Object *decode,
1976                                    GfxColorSpace *colorSpaceA) {
1977   GfxIndexedColorSpace *indexedCS;
1978   GfxSeparationColorSpace *sepCS;
1979   int maxPixel, indexHigh;
1980   Guchar *lookup2;
1981   Function *sepFunc;
1982   Object obj;
1983   double x[gfxColorMaxComps];
1984   double y[gfxColorMaxComps];
1985   int i, j, k;
1986
1987   ok = gTrue;
1988
1989   // bits per component and color space
1990   bits = bitsA;
1991   maxPixel = (1 << bits) - 1;
1992   colorSpace = colorSpaceA;
1993
1994   // get decode map
1995   if (decode->isNull()) {
1996     nComps = colorSpace->getNComps();
1997     colorSpace->getDefaultRanges(decodeLow, decodeRange, maxPixel);
1998   } else if (decode->isArray()) {
1999     nComps = decode->arrayGetLength() / 2;
2000     if (nComps != colorSpace->getNComps()) {
2001       goto err1;
2002     }
2003     for (i = 0; i < nComps; ++i) {
2004       decode->arrayGet(2*i, &obj);
2005       if (!obj.isNum()) {
2006         goto err2;
2007       }
2008       decodeLow[i] = obj.getNum();
2009       obj.free();
2010       decode->arrayGet(2*i+1, &obj);
2011       if (!obj.isNum()) {
2012         goto err2;
2013       }
2014       decodeRange[i] = obj.getNum() - decodeLow[i];
2015       obj.free();
2016     }
2017   } else {
2018     goto err1;
2019   }
2020
2021   // Construct a lookup table -- this stores pre-computed decoded
2022   // values for each component, i.e., the result of applying the
2023   // decode mapping to each possible image pixel component value.
2024   //
2025   // Optimization: for Indexed and Separation color spaces (which have
2026   // only one component), we store color values in the lookup table
2027   // rather than component values.
2028   colorSpace2 = NULL;
2029   nComps2 = 0;
2030   if (colorSpace->getMode() == csIndexed) {
2031     // Note that indexHigh may not be the same as maxPixel --
2032     // Distiller will remove unused palette entries, resulting in
2033     // indexHigh < maxPixel.
2034     indexedCS = (GfxIndexedColorSpace *)colorSpace;
2035     colorSpace2 = indexedCS->getBase();
2036     indexHigh = indexedCS->getIndexHigh();
2037     nComps2 = colorSpace2->getNComps();
2038     lookup = (double *)gmalloc((maxPixel + 1) * nComps2 * sizeof(double));
2039     lookup2 = indexedCS->getLookup();
2040     colorSpace2->getDefaultRanges(x, y, indexHigh);
2041     for (i = 0; i <= maxPixel; ++i) {
2042       j = (int)(decodeLow[0] + (i * decodeRange[0]) / maxPixel + 0.5);
2043       if (j < 0) {
2044         j = 0;
2045       } else if (j > indexHigh) {
2046         j = indexHigh;
2047       }
2048       for (k = 0; k < nComps2; ++k) {
2049         lookup[i*nComps2 + k] = x[k] + (lookup2[j*nComps2 + k] / 255.0) * y[k];
2050       }
2051     }
2052   } else if (colorSpace->getMode() == csSeparation) {
2053     sepCS = (GfxSeparationColorSpace *)colorSpace;
2054     colorSpace2 = sepCS->getAlt();
2055     nComps2 = colorSpace2->getNComps();
2056     lookup = (double *)gmalloc((maxPixel + 1) * nComps2 * sizeof(double));
2057     sepFunc = sepCS->getFunc();
2058     for (i = 0; i <= maxPixel; ++i) {
2059       x[0] = decodeLow[0] + (i * decodeRange[0]) / maxPixel;
2060       sepFunc->transform(x, y);
2061       for (k = 0; k < nComps2; ++k) {
2062         lookup[i*nComps2 + k] = y[k];
2063       }
2064     }
2065   } else {
2066     lookup = (double *)gmalloc((maxPixel + 1) * nComps * sizeof(double));
2067     for (i = 0; i <= maxPixel; ++i) {
2068       for (k = 0; k < nComps; ++k) {
2069         lookup[i*nComps + k] = decodeLow[k] +
2070                                  (i * decodeRange[k]) / maxPixel;
2071       }
2072     }
2073   }
2074
2075   return;
2076
2077  err2:
2078   obj.free();
2079  err1:
2080   ok = gFalse;
2081 }
2082
2083 GfxImageColorMap::GfxImageColorMap(GfxImageColorMap *colorMap) {
2084   int n, i;
2085
2086   colorSpace = colorMap->colorSpace->copy();
2087   bits = colorMap->bits;
2088   nComps = colorMap->nComps;
2089   nComps2 = colorMap->nComps2;
2090   colorSpace2 = NULL;
2091   lookup = NULL;
2092   n = 1 << bits;
2093   if (colorSpace->getMode() == csIndexed) {
2094     colorSpace2 = ((GfxIndexedColorSpace *)colorSpace)->getBase();
2095     n = n * nComps2 * sizeof(double);
2096   } else if (colorSpace->getMode() == csSeparation) {
2097     colorSpace2 = ((GfxSeparationColorSpace *)colorSpace)->getAlt();
2098     n = n * nComps2 * sizeof(double);
2099   } else {
2100     n = n * nComps * sizeof(double);
2101   }
2102   lookup = (double *)gmalloc(n);
2103   memcpy(lookup, colorMap->lookup, n);
2104   for (i = 0; i < nComps; ++i) {
2105     decodeLow[i] = colorMap->decodeLow[i];
2106     decodeRange[i] = colorMap->decodeRange[i];
2107   }
2108   ok = gTrue;
2109 }
2110
2111 GfxImageColorMap::~GfxImageColorMap() {
2112   delete colorSpace;
2113   gfree(lookup);
2114 }
2115
2116 void GfxImageColorMap::getGray(Guchar *x, double *gray) {
2117   GfxColor color;
2118   double *p;
2119   int i;
2120
2121   if (colorSpace2) {
2122     p = &lookup[x[0] * nComps2];
2123     for (i = 0; i < nComps2; ++i) {
2124       color.c[i] = *p++;
2125     }
2126     colorSpace2->getGray(&color, gray);
2127   } else {
2128     for (i = 0; i < nComps; ++i) {
2129       color.c[i] = lookup[x[i] * nComps + i];
2130     }
2131     colorSpace->getGray(&color, gray);
2132   }
2133 }
2134
2135 void GfxImageColorMap::getRGB(Guchar *x, GfxRGB *rgb) {
2136   GfxColor color;
2137   double *p;
2138   int i;
2139
2140   if (colorSpace2) {
2141     p = &lookup[x[0] * nComps2];
2142     for (i = 0; i < nComps2; ++i) {
2143       color.c[i] = *p++;
2144     }
2145     colorSpace2->getRGB(&color, rgb);
2146   } else {
2147     for (i = 0; i < nComps; ++i) {
2148       color.c[i] = lookup[x[i] * nComps + i];
2149     }
2150     colorSpace->getRGB(&color, rgb);
2151   }
2152 }
2153
2154 void GfxImageColorMap::getCMYK(Guchar *x, GfxCMYK *cmyk) {
2155   GfxColor color;
2156   double *p;
2157   int i;
2158
2159   if (colorSpace2) {
2160     p = &lookup[x[0] * nComps2];
2161     for (i = 0; i < nComps2; ++i) {
2162       color.c[i] = *p++;
2163     }
2164     colorSpace2->getCMYK(&color, cmyk);
2165   } else {
2166     for (i = 0; i < nComps; ++i) {
2167       color.c[i] = lookup[x[i] * nComps + i];
2168     }
2169     colorSpace->getCMYK(&color, cmyk);
2170   }
2171 }
2172
2173 void GfxImageColorMap::getColor(Guchar *x, GfxColor *color) {
2174   int maxPixel, i;
2175
2176   maxPixel = (1 << bits) - 1;
2177   for (i = 0; i < nComps; ++i) {
2178     color->c[i] = decodeLow[i] + (x[i] * decodeRange[i]) / maxPixel;
2179   }
2180 }
2181
2182 //------------------------------------------------------------------------
2183 // GfxSubpath and GfxPath
2184 //------------------------------------------------------------------------
2185
2186 GfxSubpath::GfxSubpath(double x1, double y1) {
2187   size = 16;
2188   x = (double *)gmalloc(size * sizeof(double));
2189   y = (double *)gmalloc(size * sizeof(double));
2190   curve = (GBool *)gmalloc(size * sizeof(GBool));
2191   n = 1;
2192   x[0] = x1;
2193   y[0] = y1;
2194   curve[0] = gFalse;
2195   closed = gFalse;
2196 }
2197
2198 GfxSubpath::~GfxSubpath() {
2199   gfree(x);
2200   gfree(y);
2201   gfree(curve);
2202 }
2203
2204 // Used for copy().
2205 GfxSubpath::GfxSubpath(GfxSubpath *subpath) {
2206   size = subpath->size;
2207   n = subpath->n;
2208   x = (double *)gmalloc(size * sizeof(double));
2209   y = (double *)gmalloc(size * sizeof(double));
2210   curve = (GBool *)gmalloc(size * sizeof(GBool));
2211   memcpy(x, subpath->x, n * sizeof(double));
2212   memcpy(y, subpath->y, n * sizeof(double));
2213   memcpy(curve, subpath->curve, n * sizeof(GBool));
2214   closed = subpath->closed;
2215 }
2216
2217 void GfxSubpath::lineTo(double x1, double y1) {
2218   if (n >= size) {
2219     size += 16;
2220     x = (double *)grealloc(x, size * sizeof(double));
2221     y = (double *)grealloc(y, size * sizeof(double));
2222     curve = (GBool *)grealloc(curve, size * sizeof(GBool));
2223   }
2224   x[n] = x1;
2225   y[n] = y1;
2226   curve[n] = gFalse;
2227   ++n;
2228 }
2229
2230 void GfxSubpath::curveTo(double x1, double y1, double x2, double y2,
2231                          double x3, double y3) {
2232   if (n+3 > size) {
2233     size += 16;
2234     x = (double *)grealloc(x, size * sizeof(double));
2235     y = (double *)grealloc(y, size * sizeof(double));
2236     curve = (GBool *)grealloc(curve, size * sizeof(GBool));
2237   }
2238   x[n] = x1;
2239   y[n] = y1;
2240   x[n+1] = x2;
2241   y[n+1] = y2;
2242   x[n+2] = x3;
2243   y[n+2] = y3;
2244   curve[n] = curve[n+1] = gTrue;
2245   curve[n+2] = gFalse;
2246   n += 3;
2247 }
2248
2249 void GfxSubpath::close() {
2250   if (x[n-1] != x[0] || y[n-1] != y[0]) {
2251     lineTo(x[0], y[0]);
2252   }
2253   closed = gTrue;
2254 }
2255
2256 void GfxSubpath::offset(double dx, double dy) {
2257   int i;
2258
2259   for (i = 0; i < n; ++i) {
2260     x[i] += dx;
2261     y[i] += dy;
2262   }
2263 }
2264
2265 GfxPath::GfxPath() {
2266   justMoved = gFalse;
2267   size = 16;
2268   n = 0;
2269   firstX = firstY = 0;
2270   subpaths = (GfxSubpath **)gmalloc(size * sizeof(GfxSubpath *));
2271 }
2272
2273 GfxPath::~GfxPath() {
2274   int i;
2275
2276   for (i = 0; i < n; ++i)
2277     delete subpaths[i];
2278   gfree(subpaths);
2279 }
2280
2281 // Used for copy().
2282 GfxPath::GfxPath(GBool justMoved1, double firstX1, double firstY1,
2283                  GfxSubpath **subpaths1, int n1, int size1) {
2284   int i;
2285
2286   justMoved = justMoved1;
2287   firstX = firstX1;
2288   firstY = firstY1;
2289   size = size1;
2290   n = n1;
2291   subpaths = (GfxSubpath **)gmalloc(size * sizeof(GfxSubpath *));
2292   for (i = 0; i < n; ++i)
2293     subpaths[i] = subpaths1[i]->copy();
2294 }
2295
2296 void GfxPath::moveTo(double x, double y) {
2297   justMoved = gTrue;
2298   firstX = x;
2299   firstY = y;
2300 }
2301
2302 void GfxPath::lineTo(double x, double y) {
2303   if (justMoved) {
2304     if (n >= size) {
2305       size += 16;
2306       subpaths = (GfxSubpath **)
2307                    grealloc(subpaths, size * sizeof(GfxSubpath *));
2308     }
2309     subpaths[n] = new GfxSubpath(firstX, firstY);
2310     ++n;
2311     justMoved = gFalse;
2312   }
2313   subpaths[n-1]->lineTo(x, y);
2314 }
2315
2316 void GfxPath::curveTo(double x1, double y1, double x2, double y2,
2317              double x3, double y3) {
2318   if (justMoved) {
2319     if (n >= size) {
2320       size += 16;
2321       subpaths = (GfxSubpath **)
2322                    grealloc(subpaths, size * sizeof(GfxSubpath *));
2323     }
2324     subpaths[n] = new GfxSubpath(firstX, firstY);
2325     ++n;
2326     justMoved = gFalse;
2327   }
2328   subpaths[n-1]->curveTo(x1, y1, x2, y2, x3, y3);
2329 }
2330
2331 void GfxPath::close() {
2332   // this is necessary to handle the pathological case of
2333   // moveto/closepath/clip, which defines an empty clipping region
2334   if (justMoved) {
2335     if (n >= size) {
2336       size += 16;
2337       subpaths = (GfxSubpath **)
2338                    grealloc(subpaths, size * sizeof(GfxSubpath *));
2339     }
2340     subpaths[n] = new GfxSubpath(firstX, firstY);
2341     ++n;
2342     justMoved = gFalse;
2343   }
2344   subpaths[n-1]->close();
2345 }
2346
2347 void GfxPath::append(GfxPath *path) {
2348   int i;
2349
2350   if (n + path->n > size) {
2351     size = n + path->n;
2352     subpaths = (GfxSubpath **)
2353                  grealloc(subpaths, size * sizeof(GfxSubpath *));
2354   }
2355   for (i = 0; i < path->n; ++i) {
2356     subpaths[n++] = path->subpaths[i]->copy();
2357   }
2358   justMoved = gFalse;
2359 }
2360
2361 void GfxPath::offset(double dx, double dy) {
2362   int i;
2363
2364   for (i = 0; i < n; ++i) {
2365     subpaths[i]->offset(dx, dy);
2366   }
2367 }
2368
2369 //------------------------------------------------------------------------
2370 // GfxState
2371 //------------------------------------------------------------------------
2372
2373 GfxState::GfxState(double hDPI, double vDPI, PDFRectangle *pageBox,
2374                    int rotate, GBool upsideDown) {
2375   double kx, ky;
2376
2377   px1 = pageBox->x1;
2378   py1 = pageBox->y1;
2379   px2 = pageBox->x2;
2380   py2 = pageBox->y2;
2381   kx = hDPI / 72.0;
2382   ky = vDPI / 72.0;
2383   if (rotate == 90) {
2384     ctm[0] = 0;
2385     ctm[1] = upsideDown ? ky : -ky;
2386     ctm[2] = kx;
2387     ctm[3] = 0;
2388     ctm[4] = -kx * py1;
2389     ctm[5] = ky * (upsideDown ? -px1 : px2);
2390     pageWidth = kx * (py2 - py1);
2391     pageHeight = ky * (px2 - px1);
2392   } else if (rotate == 180) {
2393     ctm[0] = -kx;
2394     ctm[1] = 0;
2395     ctm[2] = 0;
2396     ctm[3] = upsideDown ? ky : -ky;
2397     ctm[4] = kx * px2;
2398     ctm[5] = ky * (upsideDown ? -py1 : py2);
2399     pageWidth = kx * (px2 - px1);
2400     pageHeight = ky * (py2 - py1);
2401   } else if (rotate == 270) {
2402     ctm[0] = 0;
2403     ctm[1] = upsideDown ? -ky : ky;
2404     ctm[2] = -kx;
2405     ctm[3] = 0;
2406     ctm[4] = kx * py2;
2407     ctm[5] = ky * (upsideDown ? px2 : -px1);
2408     pageWidth = kx * (py2 - py1);
2409     pageHeight = ky * (px2 - px1);
2410   } else {
2411     ctm[0] = kx;
2412     ctm[1] = 0;
2413     ctm[2] = 0;
2414     ctm[3] = upsideDown ? -ky : ky;
2415     ctm[4] = -kx * px1;
2416     ctm[5] = ky * (upsideDown ? py2 : -py1);
2417     pageWidth = kx * (px2 - px1);
2418     pageHeight = ky * (py2 - py1);
2419   }
2420
2421   fillColorSpace = new GfxDeviceGrayColorSpace();
2422   strokeColorSpace = new GfxDeviceGrayColorSpace();
2423   fillColor.c[0] = 0;
2424   strokeColor.c[0] = 0;
2425   fillPattern = NULL;
2426   strokePattern = NULL;
2427   fillOpacity = 1;
2428   strokeOpacity = 1;
2429
2430   lineWidth = 1;
2431   lineDash = NULL;
2432   lineDashLength = 0;
2433   lineDashStart = 0;
2434   flatness = 1;
2435   lineJoin = 0;
2436   lineCap = 0;
2437   miterLimit = 10;
2438
2439   font = NULL;
2440   fontSize = 0;
2441   textMat[0] = 1; textMat[1] = 0;
2442   textMat[2] = 0; textMat[3] = 1;
2443   textMat[4] = 0; textMat[5] = 0;
2444   charSpace = 0;
2445   wordSpace = 0;
2446   horizScaling = 1;
2447   leading = 0;
2448   rise = 0;
2449   render = 0;
2450
2451   path = new GfxPath();
2452   curX = curY = 0;
2453   lineX = lineY = 0;
2454
2455   clipXMin = 0;
2456   clipYMin = 0;
2457   clipXMax = pageWidth;
2458   clipYMax = pageHeight;
2459
2460   saved = NULL;
2461 }
2462
2463 GfxState::~GfxState() {
2464   if (fillColorSpace) {
2465     delete fillColorSpace;
2466   }
2467   if (strokeColorSpace) {
2468     delete strokeColorSpace;
2469   }
2470   if (fillPattern) {
2471     delete fillPattern;
2472   }
2473   if (strokePattern) {
2474     delete strokePattern;
2475   }
2476   gfree(lineDash);
2477   if (path) {
2478     // this gets set to NULL by restore()
2479     delete path;
2480   }
2481   if (saved) {
2482     delete saved;
2483   }
2484 }
2485
2486 // Used for copy();
2487 GfxState::GfxState(GfxState *state) {
2488   memcpy(this, state, sizeof(GfxState));
2489   if (fillColorSpace) {
2490     fillColorSpace = state->fillColorSpace->copy();
2491   }
2492   if (strokeColorSpace) {
2493     strokeColorSpace = state->strokeColorSpace->copy();
2494   }
2495   if (fillPattern) {
2496     fillPattern = state->fillPattern->copy();
2497   }
2498   if (strokePattern) {
2499     strokePattern = state->strokePattern->copy();
2500   }
2501   if (lineDashLength > 0) {
2502     lineDash = (double *)gmalloc(lineDashLength * sizeof(double));
2503     memcpy(lineDash, state->lineDash, lineDashLength * sizeof(double));
2504   }
2505   saved = NULL;
2506 }
2507
2508 void GfxState::setPath(GfxPath *pathA) {
2509   delete path;
2510   path = pathA;
2511 }
2512
2513 void GfxState::getUserClipBBox(double *xMin, double *yMin,
2514                                double *xMax, double *yMax) {
2515   double ictm[6];
2516   double xMin1, yMin1, xMax1, yMax1, det, tx, ty;
2517
2518   // invert the CTM
2519   det = 1 / (ctm[0] * ctm[3] - ctm[1] * ctm[2]);
2520   ictm[0] = ctm[3] * det;
2521   ictm[1] = -ctm[1] * det;
2522   ictm[2] = -ctm[2] * det;
2523   ictm[3] = ctm[0] * det;
2524   ictm[4] = (ctm[2] * ctm[5] - ctm[3] * ctm[4]) * det;
2525   ictm[5] = (ctm[1] * ctm[4] - ctm[0] * ctm[5]) * det;
2526
2527   // transform all four corners of the clip bbox; find the min and max
2528   // x and y values
2529   xMin1 = xMax1 = clipXMin * ictm[0] + clipYMin * ictm[2] + ictm[4];
2530   yMin1 = yMax1 = clipXMin * ictm[1] + clipYMin * ictm[3] + ictm[5];
2531   tx = clipXMin * ictm[0] + clipYMax * ictm[2] + ictm[4];
2532   ty = clipXMin * ictm[1] + clipYMax * ictm[3] + ictm[5];
2533   if (tx < xMin1) {
2534     xMin1 = tx;
2535   } else if (tx > xMax1) {
2536     xMax1 = tx;
2537   }
2538   if (ty < yMin1) {
2539     yMin1 = ty;
2540   } else if (ty > yMax1) {
2541     yMax1 = ty;
2542   }
2543   tx = clipXMax * ictm[0] + clipYMin * ictm[2] + ictm[4];
2544   ty = clipXMax * ictm[1] + clipYMin * ictm[3] + ictm[5];
2545   if (tx < xMin1) {
2546     xMin1 = tx;
2547   } else if (tx > xMax1) {
2548     xMax1 = tx;
2549   }
2550   if (ty < yMin1) {
2551     yMin1 = ty;
2552   } else if (ty > yMax1) {
2553     yMax1 = ty;
2554   }
2555   tx = clipXMax * ictm[0] + clipYMax * ictm[2] + ictm[4];
2556   ty = clipXMax * ictm[1] + clipYMax * ictm[3] + ictm[5];
2557   if (tx < xMin1) {
2558     xMin1 = tx;
2559   } else if (tx > xMax1) {
2560     xMax1 = tx;
2561   }
2562   if (ty < yMin1) {
2563     yMin1 = ty;
2564   } else if (ty > yMax1) {
2565     yMax1 = ty;
2566   }
2567
2568   *xMin = xMin1;
2569   *yMin = yMin1;
2570   *xMax = xMax1;
2571   *yMax = yMax1;
2572 }
2573
2574 double GfxState::transformWidth(double w) {
2575   double x, y;
2576
2577   x = ctm[0] + ctm[2];
2578   y = ctm[1] + ctm[3];
2579   return w * sqrt(0.5 * (x * x + y * y));
2580 }
2581
2582 double GfxState::getTransformedFontSize() {
2583   double x1, y1, x2, y2;
2584
2585   x1 = textMat[2] * fontSize;
2586   y1 = textMat[3] * fontSize;
2587   x2 = ctm[0] * x1 + ctm[2] * y1;
2588   y2 = ctm[1] * x1 + ctm[3] * y1;
2589   return sqrt(x2 * x2 + y2 * y2);
2590 }
2591
2592 void GfxState::getFontTransMat(double *m11, double *m12,
2593                                double *m21, double *m22) {
2594   *m11 = (textMat[0] * ctm[0] + textMat[1] * ctm[2]) * fontSize;
2595   *m12 = (textMat[0] * ctm[1] + textMat[1] * ctm[3]) * fontSize;
2596   *m21 = (textMat[2] * ctm[0] + textMat[3] * ctm[2]) * fontSize;
2597   *m22 = (textMat[2] * ctm[1] + textMat[3] * ctm[3]) * fontSize;
2598 }
2599
2600 void GfxState::setCTM(double a, double b, double c,
2601                       double d, double e, double f) {
2602   int i;
2603
2604   ctm[0] = a;
2605   ctm[1] = b;
2606   ctm[2] = c;
2607   ctm[3] = d;
2608   ctm[4] = e;
2609   ctm[5] = f;
2610
2611   // avoid FP exceptions on badly messed up PDF files
2612   for (i = 0; i < 6; ++i) {
2613     if (ctm[i] > 1e10) {
2614       ctm[i] = 1e10;
2615     } else if (ctm[i] < -1e10) {
2616       ctm[i] = -1e10;
2617     }
2618   }
2619 }
2620
2621 void GfxState::concatCTM(double a, double b, double c,
2622                          double d, double e, double f) {
2623   double a1 = ctm[0];
2624   double b1 = ctm[1];
2625   double c1 = ctm[2];
2626   double d1 = ctm[3];
2627   int i;
2628
2629   ctm[0] = a * a1 + b * c1;
2630   ctm[1] = a * b1 + b * d1;
2631   ctm[2] = c * a1 + d * c1;
2632   ctm[3] = c * b1 + d * d1;
2633   ctm[4] = e * a1 + f * c1 + ctm[4];
2634   ctm[5] = e * b1 + f * d1 + ctm[5];
2635
2636   // avoid FP exceptions on badly messed up PDF files
2637   for (i = 0; i < 6; ++i) {
2638     if (ctm[i] > 1e10) {
2639       ctm[i] = 1e10;
2640     } else if (ctm[i] < -1e10) {
2641       ctm[i] = -1e10;
2642     }
2643   }
2644 }
2645
2646 void GfxState::setFillColorSpace(GfxColorSpace *colorSpace) {
2647   if (fillColorSpace) {
2648     delete fillColorSpace;
2649   }
2650   fillColorSpace = colorSpace;
2651 }
2652
2653 void GfxState::setStrokeColorSpace(GfxColorSpace *colorSpace) {
2654   if (strokeColorSpace) {
2655     delete strokeColorSpace;
2656   }
2657   strokeColorSpace = colorSpace;
2658 }
2659
2660 void GfxState::setFillPattern(GfxPattern *pattern) {
2661   if (fillPattern) {
2662     delete fillPattern;
2663   }
2664   fillPattern = pattern;
2665 }
2666
2667 void GfxState::setStrokePattern(GfxPattern *pattern) {
2668   if (strokePattern) {
2669     delete strokePattern;
2670   }
2671   strokePattern = pattern;
2672 }
2673
2674 void GfxState::setLineDash(double *dash, int length, double start) {
2675   if (lineDash)
2676     gfree(lineDash);
2677   lineDash = dash;
2678   lineDashLength = length;
2679   lineDashStart = start;
2680 }
2681
2682 void GfxState::clearPath() {
2683   delete path;
2684   path = new GfxPath();
2685 }
2686
2687 void GfxState::clip() {
2688   double xMin, yMin, xMax, yMax, x, y;
2689   GfxSubpath *subpath;
2690   int i, j;
2691
2692   xMin = xMax = yMin = yMax = 0; // make gcc happy
2693   for (i = 0; i < path->getNumSubpaths(); ++i) {
2694     subpath = path->getSubpath(i);
2695     for (j = 0; j < subpath->getNumPoints(); ++j) {
2696       transform(subpath->getX(j), subpath->getY(j), &x, &y);
2697       if (i == 0 && j == 0) {
2698         xMin = xMax = x;
2699         yMin = yMax = y;
2700       } else {
2701         if (x < xMin) {
2702           xMin = x;
2703         } else if (x > xMax) {
2704           xMax = x;
2705         }
2706         if (y < yMin) {
2707           yMin = y;
2708         } else if (y > yMax) {
2709           yMax = y;
2710         }
2711       }
2712     }
2713   }
2714   if (xMin > clipXMin) {
2715     clipXMin = xMin;
2716   }
2717   if (yMin > clipYMin) {
2718     clipYMin = yMin;
2719   }
2720   if (xMax < clipXMax) {
2721     clipXMax = xMax;
2722   }
2723   if (yMax < clipYMax) {
2724     clipYMax = yMax;
2725   }
2726 }
2727
2728 void GfxState::textShift(double tx, double ty) {
2729   double dx, dy;
2730
2731   textTransformDelta(tx, ty, &dx, &dy);
2732   curX += dx;
2733   curY += dy;
2734 }
2735
2736 void GfxState::shift(double dx, double dy) {
2737   curX += dx;
2738   curY += dy;
2739 }
2740
2741 GfxState *GfxState::save() {
2742   GfxState *newState;
2743
2744   newState = copy();
2745   newState->saved = this;
2746   return newState;
2747 }
2748
2749 GfxState *GfxState::restore() {
2750   GfxState *oldState;
2751
2752   if (saved) {
2753     oldState = saved;
2754
2755     // these attributes aren't saved/restored by the q/Q operators
2756     oldState->path = path;
2757     oldState->curX = curX;
2758     oldState->curY = curY;
2759     oldState->lineX = lineX;
2760     oldState->lineY = lineY;
2761
2762     path = NULL;
2763     saved = NULL;
2764     delete this;
2765
2766   } else {
2767     oldState = this;
2768   }
2769
2770   return oldState;
2771 }