Mercurial > hgrepos > Python2 > PyMuPDF

comparison mupdf-source/source/pdf/pdf-colorspace.c @ 2:b50eed0cc0ef upstream

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
ADD: MuPDF v1.26.7: the MuPDF source as downloaded by a default build of PyMuPDF 1.26.4. The directory name has changed: no version number in the expanded directory now.
author Franz Glasner <fzglas.hg@dom66.de>
date Mon, 15 Sep 2025 11:43:07 +0200
parents
children
comparison
equal deleted inserted replaced
1:1d09e1dec1d9 2:b50eed0cc0ef
1 // Copyright (C) 2004-2025 Artifex Software, Inc.
2 //
3 // This file is part of MuPDF.
4 //
5 // MuPDF is free software: you can redistribute it and/or modify it under the
6 // terms of the GNU Affero General Public License as published by the Free
7 // Software Foundation, either version 3 of the License, or (at your option)
8 // any later version.
9 //
10 // MuPDF is distributed in the hope that it will be useful, but WITHOUT ANY
11 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
12 // FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
13 // details.
14 //
15 // You should have received a copy of the GNU Affero General Public License
16 // along with MuPDF. If not, see <https://www.gnu.org/licenses/agpl-3.0.en.html>
17 //
18 // Alternative licensing terms are available from the licensor.
19 // For commercial licensing, see <https://www.artifex.com/> or contact
20 // Artifex Software, Inc., 39 Mesa Street, Suite 108A, San Francisco,
21 // CA 94129, USA, for further information.
22
23 #include "mupdf/fitz.h"
24 #include "mupdf/pdf.h"
25
26 #include <string.h>
27
28 static fz_colorspace *pdf_load_colorspace_imp(fz_context *ctx, pdf_obj *obj, pdf_cycle_list *cycle_up);
29
30 /* ICCBased */
31 static fz_colorspace *
32 load_icc_based(fz_context *ctx, pdf_obj *dict, int allow_alt, pdf_cycle_list *cycle_up)
33 {
34 int n = pdf_dict_get_int(ctx, dict, PDF_NAME(N));
35 fz_colorspace *alt = NULL;
36 fz_colorspace *cs = NULL;
37 pdf_obj *obj;
38
39 fz_var(alt);
40 fz_var(cs);
41
42 /* Look at Alternate to detect type (especially Lab). */
43 if (allow_alt)
44 {
45 obj = pdf_dict_get(ctx, dict, PDF_NAME(Alternate));
46 if (obj)
47 {
48 fz_try(ctx)
49 alt = pdf_load_colorspace_imp(ctx, obj, cycle_up);
50 fz_catch(ctx)
51 {
52 fz_rethrow_if(ctx, FZ_ERROR_TRYLATER);
53 fz_rethrow_if(ctx, FZ_ERROR_SYSTEM);
54 fz_report_error(ctx);
55 fz_warn(ctx, "ignoring broken ICC Alternate colorspace");
56 }
57 }
58 }
59
60 #if FZ_ENABLE_ICC
61 {
62 fz_buffer *buf = NULL;
63 fz_var(buf);
64 fz_try(ctx)
65 {
66 buf = pdf_load_stream(ctx, dict);
67 cs = fz_new_icc_colorspace(ctx, alt ? alt->type : FZ_COLORSPACE_NONE, 0, NULL, buf);
68 if (cs->n > n)
69 {
70 fz_warn(ctx, "ICC colorspace N=%d does not match profile N=%d (ignoring profile)", n, cs->n);
71 fz_drop_colorspace(ctx, cs);
72 cs = NULL;
73 }
74 else if (cs->n < n)
75 {
76 fz_warn(ctx, "ICC colorspace N=%d does not match profile N=%d (using profile)", n, cs->n);
77 }
78 }
79 fz_always(ctx)
80 fz_drop_buffer(ctx, buf);
81 fz_catch(ctx)
82 {
83 if (fz_caught(ctx) == FZ_ERROR_TRYLATER || fz_caught(ctx) == FZ_ERROR_SYSTEM)
84 {
85 fz_drop_colorspace(ctx, alt);
86 fz_rethrow(ctx);
87 }
88 fz_report_error(ctx);
89 fz_warn(ctx, "ignoring broken ICC profile");
90 }
91 }
92 #endif
93
94 if (!cs)
95 cs = alt;
96 else
97 fz_drop_colorspace(ctx, alt);
98
99 if (!cs)
100 {
101 if (n == 1) cs = fz_keep_colorspace(ctx, fz_device_gray(ctx));
102 else if (n == 3) cs = fz_keep_colorspace(ctx, fz_device_rgb(ctx));
103 else if (n == 4) cs = fz_keep_colorspace(ctx, fz_device_cmyk(ctx));
104 else fz_throw(ctx, FZ_ERROR_SYNTAX, "invalid ICC colorspace");
105 }
106
107 return cs;
108 }
109
110 static void
111 devicen_eval(fz_context *ctx, void *tint, const float *sv, int sn, float *dv, int dn)
112 {
113 pdf_eval_function(ctx, tint, sv, sn, dv, dn);
114 }
115
116 static void
117 devicen_drop(fz_context *ctx, void *tint)
118 {
119 pdf_drop_function(ctx, tint);
120 }
121
122 static fz_colorspace *
123 load_devicen(fz_context *ctx, pdf_obj *array, int is_devn, pdf_cycle_list *cycle_up)
124 {
125 fz_colorspace *base = NULL;
126 fz_colorspace *cs = NULL;
127 pdf_obj *nameobj = pdf_array_get(ctx, array, 1);
128 pdf_obj *baseobj = pdf_array_get(ctx, array, 2);
129 pdf_obj *tintobj = pdf_array_get(ctx, array, 3);
130 char name[100];
131 int i, n;
132
133 fz_var(cs);
134
135 if (pdf_is_array(ctx, nameobj))
136 {
137 n = pdf_array_len(ctx, nameobj);
138 if (n < 1)
139 fz_throw(ctx, FZ_ERROR_SYNTAX, "too few components in DeviceN colorspace");
140 if (n > FZ_MAX_COLORS)
141 fz_throw(ctx, FZ_ERROR_SYNTAX, "too many components in DeviceN colorspace");
142 }
143 else
144 {
145 n = 1;
146 }
147
148 base = pdf_load_colorspace_imp(ctx, baseobj, cycle_up);
149 fz_try(ctx)
150 {
151 if (is_devn)
152 {
153 fz_snprintf(name, sizeof name, "DeviceN(%d,%s", n, base->name);
154 for (i = 0; i < n; i++) {
155 fz_strlcat(name, ",", sizeof name);
156 fz_strlcat(name, pdf_array_get_name(ctx, nameobj, i), sizeof name);
157 }
158 fz_strlcat(name, ")", sizeof name);
159 }
160 else
161 {
162 fz_snprintf(name, sizeof name, "Separation(%s,%s)", base->name, pdf_to_name(ctx, nameobj));
163 }
164
165 cs = fz_new_colorspace(ctx, FZ_COLORSPACE_SEPARATION, 0, n, name);
166 cs->u.separation.eval = devicen_eval;
167 cs->u.separation.drop = devicen_drop;
168 cs->u.separation.base = fz_keep_colorspace(ctx, base);
169 cs->u.separation.tint = pdf_load_function(ctx, tintobj, n, cs->u.separation.base->n);
170 if (pdf_is_array(ctx, nameobj))
171 for (i = 0; i < n; i++)
172 fz_colorspace_name_colorant(ctx, cs, i, pdf_array_get_name(ctx, nameobj, i));
173 else
174 fz_colorspace_name_colorant(ctx, cs, 0, pdf_to_name(ctx, nameobj));
175 }
176 fz_always(ctx)
177 {
178 fz_drop_colorspace(ctx, base);
179 }
180 fz_catch(ctx)
181 {
182 fz_drop_colorspace(ctx, cs);
183 fz_rethrow(ctx);
184 }
185
186 return cs;
187 }
188
189 int
190 pdf_is_tint_colorspace(fz_context *ctx, fz_colorspace *cs)
191 {
192 return cs && cs->type == FZ_COLORSPACE_SEPARATION;
193 }
194
195 /* Indexed */
196
197 static fz_colorspace *
198 load_indexed(fz_context *ctx, pdf_obj *array, pdf_cycle_list *cycle_up)
199 {
200 pdf_obj *baseobj = pdf_array_get(ctx, array, 1);
201 pdf_obj *highobj = pdf_array_get(ctx, array, 2);
202 pdf_obj *lookupobj = pdf_array_get(ctx, array, 3);
203 fz_colorspace *base = NULL;
204 fz_colorspace *cs;
205 size_t i, n;
206 int high;
207 unsigned char *lookup = NULL;
208
209 fz_var(base);
210 fz_var(lookup);
211
212 fz_try(ctx)
213 {
214 base = pdf_load_colorspace_imp(ctx, baseobj, cycle_up);
215
216 high = pdf_to_int(ctx, highobj);
217 high = fz_clampi(high, 0, 255);
218 n = (size_t)base->n * (high + 1);
219 lookup = Memento_label(fz_malloc(ctx, n), "cs_lookup");
220
221 if (pdf_is_string(ctx, lookupobj))
222 {
223 size_t sn = fz_minz(n, pdf_to_str_len(ctx, lookupobj));
224 unsigned char *buf = (unsigned char *) pdf_to_str_buf(ctx, lookupobj);
225 for (i = 0; i < sn; ++i)
226 lookup[i] = buf[i];
227 for (; i < n; ++i)
228 lookup[i] = 0;
229 }
230 else if (pdf_is_indirect(ctx, lookupobj))
231 {
232 fz_stream *file = NULL;
233
234 fz_var(file);
235
236 fz_try(ctx)
237 {
238 file = pdf_open_stream(ctx, lookupobj);
239 i = fz_read(ctx, file, lookup, n);
240 if (i < n)
241 memset(lookup+i, 0, n-i);
242 }
243 fz_always(ctx)
244 {
245 fz_drop_stream(ctx, file);
246 }
247 fz_catch(ctx)
248 {
249 fz_rethrow(ctx);
250 }
251 }
252 else
253 {
254 fz_throw(ctx, FZ_ERROR_SYNTAX, "cannot parse colorspace lookup table");
255 }
256
257 cs = fz_new_indexed_colorspace(ctx, base, high, lookup);
258 }
259 fz_always(ctx)
260 fz_drop_colorspace(ctx, base);
261 fz_catch(ctx)
262 {
263 fz_free(ctx, lookup);
264 fz_rethrow(ctx);
265 }
266
267 return cs;
268 }
269
270 static void
271 pdf_load_cal_common(fz_context *ctx, pdf_obj *dict, float *wp, float *bp, float *gamma)
272 {
273 pdf_obj *obj;
274 int i;
275
276 obj = pdf_dict_get(ctx, dict, PDF_NAME(WhitePoint));
277 if (pdf_array_len(ctx, obj) != 3)
278 fz_throw(ctx, FZ_ERROR_SYNTAX, "WhitePoint must be a 3-element array");
279
280 for (i = 0; i < 3; i++)
281 {
282 wp[i] = pdf_array_get_real(ctx, obj, i);
283 if (wp[i] < 0)
284 fz_throw(ctx, FZ_ERROR_SYNTAX, "WhitePoint numbers must be positive");
285 }
286 if (wp[1] != 1)
287 fz_throw(ctx, FZ_ERROR_SYNTAX, "WhitePoint Yw must be 1.0");
288
289 obj = pdf_dict_get(ctx, dict, PDF_NAME(BlackPoint));
290 if (pdf_array_len(ctx, obj) == 3)
291 {
292 for (i = 0; i < 3; i++)
293 {
294 bp[i] = pdf_array_get_real(ctx, obj, i);
295 if (bp[i] < 0)
296 fz_throw(ctx, FZ_ERROR_SYNTAX, "BlackPoint numbers must be positive");
297 }
298 }
299
300 obj = pdf_dict_get(ctx, dict, PDF_NAME(Gamma));
301 if (pdf_is_number(ctx, obj))
302 {
303 gamma[0] = pdf_to_real(ctx, obj);
304 gamma[1] = gamma[2];
305 if (gamma[0] <= 0)
306 fz_throw(ctx, FZ_ERROR_SYNTAX, "Gamma must be greater than zero");
307 }
308 else if (pdf_array_len(ctx, obj) == 3)
309 {
310 for (i = 0; i < 3; i++)
311 {
312 gamma[i] = pdf_array_get_real(ctx, obj, i);
313 if (gamma[i] <= 0)
314 fz_throw(ctx, FZ_ERROR_SYNTAX, "Gamma must be greater than zero");
315 }
316 }
317 }
318
319 static fz_colorspace *
320 pdf_load_cal_gray(fz_context *ctx, pdf_obj *dict)
321 {
322 float wp[3];
323 float bp[3] = { 0, 0, 0 };
324 float gamma[3] = { 1, 1, 1 };
325
326 if (dict == NULL)
327 return fz_keep_colorspace(ctx, fz_device_gray(ctx));
328
329 fz_try(ctx)
330 pdf_load_cal_common(ctx, dict, wp, bp, gamma);
331 fz_catch(ctx)
332 return fz_keep_colorspace(ctx, fz_device_gray(ctx));
333 return fz_new_cal_gray_colorspace(ctx, wp, bp, gamma[0]);
334 }
335
336 static fz_colorspace *
337 pdf_load_cal_rgb(fz_context *ctx, pdf_obj *dict)
338 {
339 pdf_obj *obj;
340 float matrix[9] = { 1, 0, 0, 0, 1, 0, 0, 0, 1 };
341 float wp[3];
342 float bp[3] = { 0, 0, 0 };
343 float gamma[3] = { 1, 1, 1 };
344 int i;
345
346 if (dict == NULL)
347 return fz_keep_colorspace(ctx, fz_device_rgb(ctx));
348
349 fz_try(ctx)
350 {
351 pdf_load_cal_common(ctx, dict, wp, bp, gamma);
352 obj = pdf_dict_get(ctx, dict, PDF_NAME(Matrix));
353 if (pdf_array_len(ctx, obj) == 9)
354 {
355 for (i = 0; i < 9; i++)
356 matrix[i] = pdf_array_get_real(ctx, obj, i);
357 }
358 }
359 fz_catch(ctx)
360 return fz_keep_colorspace(ctx, fz_device_rgb(ctx));
361 return fz_new_cal_rgb_colorspace(ctx, wp, bp, gamma, matrix);
362 }
363
364 /* Parse and create colorspace from PDF object */
365
366 static fz_colorspace *
367 pdf_load_colorspace_imp(fz_context *ctx, pdf_obj *obj, pdf_cycle_list *cycle_up)
368 {
369 fz_colorspace *cs = NULL;
370 pdf_cycle_list cycle;
371
372 if (pdf_cycle(ctx, &cycle, cycle_up, obj))
373 fz_throw(ctx, FZ_ERROR_SYNTAX, "recursive colorspace");
374
375 if (pdf_is_name(ctx, obj))
376 {
377 if (pdf_name_eq(ctx, obj, PDF_NAME(Pattern)))
378 return fz_keep_colorspace(ctx, fz_device_gray(ctx));
379 else if (pdf_name_eq(ctx, obj, PDF_NAME(G)))
380 return fz_keep_colorspace(ctx, fz_device_gray(ctx));
381 else if (pdf_name_eq(ctx, obj, PDF_NAME(RGB)))
382 return fz_keep_colorspace(ctx, fz_device_rgb(ctx));
383 else if (pdf_name_eq(ctx, obj, PDF_NAME(CMYK)))
384 return fz_keep_colorspace(ctx, fz_device_cmyk(ctx));
385 else if (pdf_name_eq(ctx, obj, PDF_NAME(DeviceGray)))
386 return fz_keep_colorspace(ctx, fz_device_gray(ctx));
387 else if (pdf_name_eq(ctx, obj, PDF_NAME(DeviceRGB)))
388 return fz_keep_colorspace(ctx, fz_device_rgb(ctx));
389 else if (pdf_name_eq(ctx, obj, PDF_NAME(DeviceCMYK)))
390 return fz_keep_colorspace(ctx, fz_device_cmyk(ctx));
391 else
392 fz_throw(ctx, FZ_ERROR_SYNTAX, "unknown colorspace: %s", pdf_to_name(ctx, obj));
393 }
394
395 else if (pdf_is_array(ctx, obj))
396 {
397 pdf_obj *name = pdf_array_get(ctx, obj, 0);
398
399 if (pdf_is_name(ctx, name))
400 {
401 /* load base colorspace instead */
402 if (pdf_name_eq(ctx, name, PDF_NAME(G)))
403 return fz_keep_colorspace(ctx, fz_device_gray(ctx));
404 else if (pdf_name_eq(ctx, name, PDF_NAME(RGB)))
405 return fz_keep_colorspace(ctx, fz_device_rgb(ctx));
406 else if (pdf_name_eq(ctx, name, PDF_NAME(CMYK)))
407 return fz_keep_colorspace(ctx, fz_device_cmyk(ctx));
408 else if (pdf_name_eq(ctx, name, PDF_NAME(DeviceGray)))
409 return fz_keep_colorspace(ctx, fz_device_gray(ctx));
410 else if (pdf_name_eq(ctx, name, PDF_NAME(DeviceRGB)))
411 return fz_keep_colorspace(ctx, fz_device_rgb(ctx));
412 else if (pdf_name_eq(ctx, name, PDF_NAME(DeviceCMYK)))
413 return fz_keep_colorspace(ctx, fz_device_cmyk(ctx));
414 else if (pdf_name_eq(ctx, name, PDF_NAME(CalCMYK)))
415 return fz_keep_colorspace(ctx, fz_device_cmyk(ctx));
416 else if (pdf_name_eq(ctx, name, PDF_NAME(Lab)))
417 return fz_keep_colorspace(ctx, fz_device_lab(ctx));
418
419 else
420 {
421 if ((cs = pdf_find_item(ctx, fz_drop_colorspace_imp, obj)) != NULL)
422 return cs;
423
424 if (pdf_name_eq(ctx, name, PDF_NAME(ICCBased)))
425 cs = load_icc_based(ctx, pdf_array_get(ctx, obj, 1), 1, &cycle);
426
427 else if (pdf_name_eq(ctx, name, PDF_NAME(CalGray)))
428 cs = pdf_load_cal_gray(ctx, pdf_array_get(ctx, obj, 1));
429 else if (pdf_name_eq(ctx, name, PDF_NAME(CalRGB)))
430 cs = pdf_load_cal_rgb(ctx, pdf_array_get(ctx, obj, 1));
431
432 else if (pdf_name_eq(ctx, name, PDF_NAME(Indexed)))
433 cs = load_indexed(ctx, obj, &cycle);
434 else if (pdf_name_eq(ctx, name, PDF_NAME(I)))
435 cs = load_indexed(ctx, obj, &cycle);
436
437 else if (pdf_name_eq(ctx, name, PDF_NAME(Separation)))
438 cs = load_devicen(ctx, obj, 0, &cycle);
439
440 else if (pdf_name_eq(ctx, name, PDF_NAME(DeviceN)))
441 cs = load_devicen(ctx, obj, 1, &cycle);
442
443 else if (pdf_name_eq(ctx, name, PDF_NAME(Pattern)))
444 {
445 pdf_obj *pobj = pdf_array_get(ctx, obj, 1);
446 if (!pobj)
447 return fz_keep_colorspace(ctx, fz_device_gray(ctx));
448 cs = pdf_load_colorspace_imp(ctx, pobj, &cycle);
449 }
450 else
451 fz_throw(ctx, FZ_ERROR_SYNTAX, "unknown colorspace %s", pdf_to_name(ctx, name));
452
453 pdf_store_item(ctx, obj, cs, 1000);
454 return cs;
455 }
456 }
457 }
458
459 /* We have seen files where /DefaultRGB is specified as 1 0 R,
460 * and 1 0 obj << /Length 3144 /Alternate /DeviceRGB /N 3 >>
461 * stream ...iccprofile... endstream endobj.
462 * This *should* be [ /ICCBased 1 0 R ], but Acrobat seems to
463 * handle it, so do our best. */
464 else if (pdf_is_dict(ctx, obj))
465 {
466 if ((cs = pdf_find_item(ctx, fz_drop_colorspace_imp, obj)) != NULL)
467 return cs;
468 cs = load_icc_based(ctx, obj, 1, &cycle);
469 pdf_store_item(ctx, obj, cs, 1000);
470 return cs;
471 }
472
473 fz_throw(ctx, FZ_ERROR_SYNTAX, "could not parse color space (%d 0 R)", pdf_to_num(ctx, obj));
474 }
475
476 fz_colorspace *
477 pdf_load_colorspace(fz_context *ctx, pdf_obj *obj)
478 {
479 return pdf_load_colorspace_imp(ctx, obj, NULL);
480 }
481
482 #if FZ_ENABLE_ICC
483
484 static fz_colorspace *
485 pdf_load_output_intent(fz_context *ctx, pdf_document *doc)
486 {
487 pdf_obj *root = pdf_dict_get(ctx, pdf_trailer(ctx, doc), PDF_NAME(Root));
488 pdf_obj *intents = pdf_dict_get(ctx, root, PDF_NAME(OutputIntents));
489 pdf_obj *intent_dict;
490 pdf_obj *dest_profile;
491 fz_colorspace *cs = NULL;
492
493 /* An array of intents */
494 if (!intents)
495 return NULL;
496
497 /* For now, always just use the first intent. I have never even seen a file
498 * with multiple intents but it could happen */
499 intent_dict = pdf_array_get(ctx, intents, 0);
500 if (!intent_dict)
501 return NULL;
502 dest_profile = pdf_dict_get(ctx, intent_dict, PDF_NAME(DestOutputProfile));
503 if (!dest_profile)
504 return NULL;
505
506 fz_var(cs);
507
508 fz_try(ctx)
509 cs = load_icc_based(ctx, dest_profile, 0, NULL);
510 fz_catch(ctx)
511 {
512 fz_rethrow_if(ctx, FZ_ERROR_TRYLATER);
513 fz_rethrow_if(ctx, FZ_ERROR_SYSTEM);
514 fz_report_error(ctx);
515 fz_warn(ctx, "Attempt to read Output Intent failed");
516 }
517 return cs;
518 }
519
520 fz_colorspace *
521 pdf_document_output_intent(fz_context *ctx, pdf_document *doc)
522 {
523 if (!doc->oi)
524 doc->oi = pdf_load_output_intent(ctx, doc);
525 return doc->oi;
526 }
527
528 #else
529
530 fz_colorspace *
531 pdf_document_output_intent(fz_context *ctx, pdf_document *doc)
532 {
533 return NULL;
534 }
535
536 #endif
537
538 static pdf_obj *
539 pdf_add_indexed_colorspace(fz_context *ctx, pdf_document *doc, fz_colorspace *cs)
540 {
541 fz_colorspace *basecs;
542 unsigned char *lookup = NULL;
543 int high = 0;
544 int basen;
545 pdf_obj *obj;
546
547 basecs = cs->u.indexed.base;
548 high = cs->u.indexed.high;
549 lookup = cs->u.indexed.lookup;
550 basen = basecs->n;
551
552 if (fz_colorspace_is_indexed(ctx, basecs))
553 fz_throw(ctx, FZ_ERROR_FORMAT, "indexed colorspaces must not have an indexed colorspace as base");
554
555 obj = pdf_add_new_array(ctx, doc, 4);
556 fz_try(ctx)
557 {
558 pdf_array_push(ctx, obj, PDF_NAME(Indexed));
559 pdf_array_push(ctx, obj, pdf_add_colorspace(ctx, doc, basecs));
560 pdf_array_push_int(ctx, obj, high);
561 pdf_array_push_string(ctx, obj, (char *) lookup, (size_t)basen * (high + 1));
562 }
563 fz_catch(ctx)
564 {
565 pdf_drop_obj(ctx, obj);
566 fz_rethrow(ctx);
567 }
568 return obj;
569 }
570
571 static pdf_obj *
572 pdf_add_icc_colorspace(fz_context *ctx, pdf_document *doc, fz_colorspace *cs)
573 {
574 #if FZ_ENABLE_ICC
575 pdf_obj *obj = NULL;
576 pdf_obj *stm = NULL;
577 pdf_obj *base;
578 pdf_obj *ref;
579 pdf_colorspace_resource_key key;
580
581 fz_var(obj);
582 fz_var(stm);
583
584 obj = pdf_find_colorspace_resource(ctx, doc, cs, &key);
585 if (obj)
586 return obj;
587
588 switch (fz_colorspace_type(ctx, cs))
589 {
590 default:
591 fz_throw(ctx, FZ_ERROR_UNSUPPORTED, "only Gray, RGB, and CMYK ICC colorspaces supported");
592 case FZ_COLORSPACE_GRAY:
593 base = PDF_NAME(DeviceGray);
594 break;
595 case FZ_COLORSPACE_RGB:
596 base = PDF_NAME(DeviceRGB);
597 break;
598 case FZ_COLORSPACE_CMYK:
599 base = PDF_NAME(DeviceCMYK);
600 break;
601 case FZ_COLORSPACE_LAB:
602 base = PDF_NAME(Lab);
603 break;
604 }
605
606 fz_try(ctx)
607 {
608 stm = pdf_add_stream(ctx, doc, cs->u.icc.buffer, NULL, 0);
609 pdf_dict_put_int(ctx, stm, PDF_NAME(N), cs->n);
610 pdf_dict_put(ctx, stm, PDF_NAME(Alternate), base);
611
612 obj = pdf_add_new_array(ctx, doc, 2);
613 pdf_array_push(ctx, obj, PDF_NAME(ICCBased));
614 pdf_array_push(ctx, obj, stm);
615
616 ref = pdf_insert_colorspace_resource(ctx, doc, &key, obj);
617 }
618 fz_always(ctx)
619 {
620 pdf_drop_obj(ctx, obj);
621 pdf_drop_obj(ctx, stm);
622 }
623 fz_catch(ctx)
624 fz_rethrow(ctx);
625 return ref;
626 #else
627 fz_throw(ctx, FZ_ERROR_UNSUPPORTED, "ICC support disabled");
628 #endif
629 }
630
631 pdf_obj *
632 pdf_add_colorspace(fz_context *ctx, pdf_document *doc, fz_colorspace *cs)
633 {
634 if (fz_colorspace_is_indexed(ctx, cs))
635 return pdf_add_indexed_colorspace(ctx, doc, cs);
636
637 if (fz_colorspace_is_icc(ctx, cs))
638 return pdf_add_icc_colorspace(ctx, doc, cs);
639
640 switch (fz_colorspace_type(ctx, cs))
641 {
642 case FZ_COLORSPACE_NONE:
643 case FZ_COLORSPACE_GRAY:
644 return PDF_NAME(DeviceGray);
645 case FZ_COLORSPACE_RGB:
646 return PDF_NAME(DeviceRGB);
647 case FZ_COLORSPACE_CMYK:
648 return PDF_NAME(DeviceCMYK);
649 case FZ_COLORSPACE_LAB:
650 return PDF_NAME(Lab);
651 default:
652 fz_throw(ctx, FZ_ERROR_ARGUMENT, "only Gray, RGB, and CMYK colorspaces supported");
653 break;
654 }
655 }