?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
beta-0.89.2
[luatex.git] / source / libs / cairo / cairo-src / src / cairo-cff-subset.c
blob3ffe6f663f71a254d15b1f18a329301b92e114f9
1 /* -*- Mode: c; tab-width: 8; c-basic-offset: 4; indent-tabs-mode: t; -*- */
2 /* cairo - a vector graphics library with display and print output
3 *
4 * Copyright © 2006 Adrian Johnson
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it either under the terms of the GNU Lesser General Public
8 * License version 2.1 as published by the Free Software Foundation
9 * (the "LGPL") or, at your option, under the terms of the Mozilla
10 * Public License Version 1.1 (the "MPL"). If you do not alter this
11 * notice, a recipient may use your version of this file under either
12 * the MPL or the LGPL.
13 *
14 * You should have received a copy of the LGPL along with this library
15 * in the file COPYING-LGPL-2.1; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA
17 * You should have received a copy of the MPL along with this library
18 * in the file COPYING-MPL-1.1
19 *
20 * The contents of this file are subject to the Mozilla Public License
21 * Version 1.1 (the "License"); you may not use this file except in
22 * compliance with the License. You may obtain a copy of the License at
23 * http://www.mozilla.org/MPL/
24 *
25 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
26 * OF ANY KIND, either express or implied. See the LGPL or the MPL for
27 * the specific language governing rights and limitations.
28 *
29 * The Original Code is the cairo graphics library.
30 *
31 * The Initial Developer of the Original Code is Adrian Johnson.
32 *
33 * Contributor(s):
34 * Adrian Johnson <ajohnson@redneon.com>
35 * Eugeniy Meshcheryakov <eugen@debian.org>
36 */
37
38 /*
39 * Useful links:
40 * http://www.adobe.com/content/dam/Adobe/en/devnet/font/pdfs/5176.CFF.pdf
41 * http://www.adobe.com/content/dam/Adobe/en/devnet/font/pdfs/5177.Type2.pdf
42 */
43
44 #define _BSD_SOURCE /* for snprintf(), strdup() */
45 #include "cairoint.h"
46
47 #include "cairo-array-private.h"
48 #include "cairo-error-private.h"
49
50 #if CAIRO_HAS_FONT_SUBSET
51
52 #include "cairo-scaled-font-subsets-private.h"
53 #include "cairo-truetype-subset-private.h"
54 #include <string.h>
55 #include <locale.h>
56
57 /* CFF Dict Operators. If the high byte is 0 the command is encoded
58 * with a single byte. */
59 #define BASEFONTNAME_OP 0x0c16
60 #define CIDCOUNT_OP 0x0c22
61 #define CHARSET_OP 0x000f
62 #define CHARSTRINGS_OP 0x0011
63 #define COPYRIGHT_OP 0x0c00
64 #define DEFAULTWIDTH_OP 0x0014
65 #define ENCODING_OP 0x0010
66 #define FAMILYNAME_OP 0x0003
67 #define FDARRAY_OP 0x0c24
68 #define FDSELECT_OP 0x0c25
69 #define FONTBBOX_OP 0x0005
70 #define FONTMATRIX_OP 0x0c07
71 #define FONTNAME_OP 0x0c26
72 #define FULLNAME_OP 0x0002
73 #define LOCAL_SUB_OP 0x0013
74 #define NOMINALWIDTH_OP 0x0015
75 #define NOTICE_OP 0x0001
76 #define POSTSCRIPT_OP 0x0c15
77 #define PRIVATE_OP 0x0012
78 #define ROS_OP 0x0c1e
79 #define UNIQUEID_OP 0x000d
80 #define VERSION_OP 0x0000
81 #define WEIGHT_OP 0x0004
82 #define XUID_OP 0x000e
83
84 #define NUM_STD_STRINGS 391
85
86 /* Type 2 Charstring operators */
87 #define TYPE2_hstem 0x0001
88 #define TYPE2_vstem 0x0003
89 #define TYPE2_callsubr 0x000a
90
91 #define TYPE2_return 0x000b
92 #define TYPE2_endchar 0x000e
93
94 #define TYPE2_hstemhm 0x0012
95 #define TYPE2_hintmask 0x0013
96 #define TYPE2_cntrmask 0x0014
97 #define TYPE2_vstemhm 0x0017
98 #define TYPE2_callgsubr 0x001d
99
100 #define TYPE2_rmoveto 0x0015
101 #define TYPE2_hmoveto 0x0016
102 #define TYPE2_vmoveto 0x0004
103
104
105 #define MAX_SUBROUTINE_NESTING 10 /* From Type2 Charstring spec */
106
107
108 typedef struct _cff_header {
109 uint8_t major;
110 uint8_t minor;
111 uint8_t header_size;
112 uint8_t offset_size;
113 } cff_header_t;
114
115 typedef struct _cff_index_element {
116 cairo_bool_t is_copy;
117 unsigned char *data;
118 int length;
119 } cff_index_element_t;
120
121 typedef struct _cff_dict_operator {
122 cairo_hash_entry_t base;
123
124 unsigned short operator;
125 unsigned char *operand;
126 int operand_length;
127 int operand_offset;
128 } cff_dict_operator_t;
129
130 typedef struct _cairo_cff_font {
131
132 cairo_scaled_font_subset_t *scaled_font_subset;
133 const cairo_scaled_font_backend_t *backend;
134
135 /* Font Data */
136 unsigned char *data;
137 unsigned long data_length;
138 unsigned char *current_ptr;
139 unsigned char *data_end;
140 cff_header_t *header;
141 char *font_name;
142 char *ps_name;
143 cairo_hash_table_t *top_dict;
144 cairo_hash_table_t *private_dict;
145 cairo_array_t strings_index;
146 cairo_array_t charstrings_index;
147 cairo_array_t global_sub_index;
148 cairo_array_t local_sub_index;
149 unsigned char *charset;
150 int num_glyphs;
151 cairo_bool_t is_cid;
152 cairo_bool_t is_opentype;
153 int units_per_em;
154 int global_sub_bias;
155 int local_sub_bias;
156 double default_width;
157 double nominal_width;
158
159 /* CID Font Data */
160 int *fdselect;
161 unsigned int num_fontdicts;
162 cairo_hash_table_t **fd_dict;
163 cairo_hash_table_t **fd_private_dict;
164 cairo_array_t *fd_local_sub_index;
165 int *fd_local_sub_bias;
166 double *fd_default_width;
167 double *fd_nominal_width;
168
169 /* Subsetted Font Data */
170 char *subset_font_name;
171 cairo_array_t charstrings_subset_index;
172 cairo_array_t strings_subset_index;
173 int euro_sid;
174 int *fdselect_subset;
175 unsigned int num_subset_fontdicts;
176 int *fd_subset_map;
177 int *private_dict_offset;
178 cairo_bool_t subset_subroutines;
179 cairo_bool_t *global_subs_used;
180 cairo_bool_t *local_subs_used;
181 cairo_bool_t **fd_local_subs_used;
182 cairo_array_t output;
183
184 /* Subset Metrics */
185 int *widths;
186 int x_min, y_min, x_max, y_max;
187 int ascent, descent;
188
189 /* Type 2 charstring data */
190 int type2_stack_size;
191 int type2_stack_top_value;
192 cairo_bool_t type2_stack_top_is_int;
193 int type2_num_hints;
194 int type2_hintmask_bytes;
195 int type2_nesting_level;
196 cairo_bool_t type2_seen_first_int;
197 cairo_bool_t type2_find_width;
198 cairo_bool_t type2_found_width;
199 int type2_width;
200 cairo_bool_t type2_has_path;
201
202 } cairo_cff_font_t;
203
204 /* Encoded integer using maximum sized encoding. This is required for
205 * operands that are later modified after encoding. */
206 static unsigned char *
207 encode_integer_max (unsigned char *p, int i)
208 {
209 *p++ = 29;
210 *p++ = i >> 24;
211 *p++ = (i >> 16) & 0xff;
212 *p++ = (i >> 8) & 0xff;
213 *p++ = i & 0xff;
214 return p;
215 }
216
217 static unsigned char *
218 encode_integer (unsigned char *p, int i)
219 {
220 if (i >= -107 && i <= 107) {
221 *p++ = i + 139;
222 } else if (i >= 108 && i <= 1131) {
223 i -= 108;
224 *p++ = (i >> 8)+ 247;
225 *p++ = i & 0xff;
226 } else if (i >= -1131 && i <= -108) {
227 i = -i - 108;
228 *p++ = (i >> 8)+ 251;
229 *p++ = i & 0xff;
230 } else if (i >= -32768 && i <= 32767) {
231 *p++ = 28;
232 *p++ = (i >> 8) & 0xff;
233 *p++ = i & 0xff;
234 } else {
235 p = encode_integer_max (p, i);
236 }
237 return p;
238 }
239
240 static unsigned char *
241 decode_integer (unsigned char *p, int *integer)
242 {
243 if (*p == 28) {
244 *integer = (int)(p[1]<<8 | p[2]);
245 p += 3;
246 } else if (*p == 29) {
247 *integer = (int)((p[1] << 24) | (p[2] << 16) | (p[3] << 8) | p[4]);
248 p += 5;
249 } else if (*p >= 32 && *p <= 246) {
250 *integer = *p++ - 139;
251 } else if (*p <= 250) {
252 *integer = (p[0] - 247) * 256 + p[1] + 108;
253 p += 2;
254 } else if (*p <= 254) {
255 *integer = -(p[0] - 251) * 256 - p[1] - 108;
256 p += 2;
257 } else {
258 *integer = 0;
259 p += 1;
260 }
261 return p;
262 }
263
264 static char *
265 decode_nibble (int n, char *buf)
266 {
267 switch (n)
268 {
269 case 0xa:
270 *buf++ = '.';
271 break;
272 case 0xb:
273 *buf++ = 'E';
274 break;
275 case 0xc:
276 *buf++ = 'E';
277 *buf++ = '-';
278 break;
279 case 0xd:
280 *buf++ = '-';
281 break;
282 case 0xe:
283 *buf++ = '-';
284 break;
285 case 0xf:
286 break;
287 default:
288 *buf++ = '0' + n;
289 break;
290 }
291
292 return buf;
293 }
294
295 static unsigned char *
296 decode_real (unsigned char *p, double *real)
297 {
298 const char *decimal_point;
299 int decimal_point_len;
300 int n;
301 char buffer[100];
302 char buffer2[200];
303 char *q;
304 char *buf = buffer;
305 char *buf_end = buffer + sizeof (buffer);
306
307 decimal_point = cairo_get_locale_decimal_point ();
308 decimal_point_len = strlen (decimal_point);
309
310 assert (decimal_point_len != 0);
311 assert (sizeof(buffer) + decimal_point_len < sizeof(buffer2));
312
313 p++;
314 while (buf + 2 < buf_end) {
315 n = *p >> 4;
316 buf = decode_nibble (n, buf);
317 n = *p & 0x0f;
318 buf = decode_nibble (n, buf);
319 if ((*p & 0x0f) == 0x0f) {
320 p++;
321 break;
322 }
323 p++;
324 };
325 *buf = 0;
326
327 buf = buffer;
328 if (strchr (buffer, '.')) {
329 q = strchr (buffer, '.');
330 strncpy (buffer2, buffer, q - buffer);
331 buf = buffer2 + (q - buffer);
332 strncpy (buf, decimal_point, decimal_point_len);
333 buf += decimal_point_len;
334 strcpy (buf, q + 1);
335 buf = buffer2;
336 }
337
338 if (sscanf(buf, "%lf", real) != 1)
339 *real = 0.0;
340
341 return p;
342 }
343
344 static unsigned char *
345 decode_number (unsigned char *p, double *number)
346 {
347 if (*p == 30) {
348 p = decode_real (p, number);
349 } else {
350 int i;
351 p = decode_integer (p, &i);
352 *number = i;
353 }
354 return p;
355 }
356
357 static unsigned char *
358 decode_operator (unsigned char *p, unsigned short *operator)
359 {
360 unsigned short op = 0;
361
362 op = *p++;
363 if (op == 12) {
364 op <<= 8;
365 op |= *p++;
366 }
367 *operator = op;
368 return p;
369 }
370
371 /* return 0 if not an operand */
372 static int
373 operand_length (unsigned char *p)
374 {
375 unsigned char *begin = p;
376
377 if (*p == 28)
378 return 3;
379
380 if (*p == 29)
381 return 5;
382
383 if (*p >= 32 && *p <= 246)
384 return 1;
385
386 if (*p >= 247 && *p <= 254)
387 return 2;
388
389 if (*p == 30) {
390 while ((*p & 0x0f) != 0x0f)
391 p++;
392 return p - begin + 1;
393 }
394
395 return 0;
396 }
397
398 static unsigned char *
399 encode_index_offset (unsigned char *p, int offset_size, unsigned long offset)
400 {
401 while (--offset_size >= 0) {
402 p[offset_size] = (unsigned char) (offset & 0xff);
403 offset >>= 8;
404 }
405 return p + offset_size;
406 }
407
408 static unsigned long
409 decode_index_offset(unsigned char *p, int off_size)
410 {
411 unsigned long offset = 0;
412
413 while (off_size-- > 0)
414 offset = offset*256 + *p++;
415 return offset;
416 }
417
418 static void
419 cff_index_init (cairo_array_t *index)
420 {
421 _cairo_array_init (index, sizeof (cff_index_element_t));
422 }
423
424 static cairo_int_status_t
425 cff_index_read (cairo_array_t *index, unsigned char **ptr, unsigned char *end_ptr)
426 {
427 cff_index_element_t element;
428 unsigned char *data, *p;
429 cairo_status_t status;
430 int offset_size, count, start, i;
431 int end = 0;
432
433 p = *ptr;
434 if (p + 2 > end_ptr)
435 return CAIRO_INT_STATUS_UNSUPPORTED;
436 count = get_unaligned_be16 (p);
437 p += 2;
438 if (count > 0) {
439 offset_size = *p++;
440 if (p + (count + 1)*offset_size > end_ptr)
441 return CAIRO_INT_STATUS_UNSUPPORTED;
442 data = p + offset_size*(count + 1) - 1;
443 start = decode_index_offset (p, offset_size);
444 p += offset_size;
445 for (i = 0; i < count; i++) {
446 end = decode_index_offset (p, offset_size);
447 p += offset_size;
448 if (p > end_ptr)
449 return CAIRO_INT_STATUS_UNSUPPORTED;
450 element.length = end - start;
451 element.is_copy = FALSE;
452 element.data = data + start;
453 status = _cairo_array_append (index, &element);
454 if (unlikely (status))
455 return status;
456 start = end;
457 }
458 p = data + end;
459 }
460 *ptr = p;
461
462 return CAIRO_STATUS_SUCCESS;
463 }
464
465 static cairo_status_t
466 cff_index_write (cairo_array_t *index, cairo_array_t *output)
467 {
468 int offset_size;
469 int offset;
470 int num_elem;
471 int i;
472 cff_index_element_t *element;
473 uint16_t count;
474 unsigned char buf[5];
475 cairo_status_t status;
476
477 num_elem = _cairo_array_num_elements (index);
478 count = cpu_to_be16 ((uint16_t) num_elem);
479 status = _cairo_array_append_multiple (output, &count, 2);
480 if (unlikely (status))
481 return status;
482
483 if (num_elem == 0)
484 return CAIRO_STATUS_SUCCESS;
485
486 /* Find maximum offset to determine offset size */
487 offset = 1;
488 for (i = 0; i < num_elem; i++) {
489 element = _cairo_array_index (index, i);
490 offset += element->length;
491 }
492 if (offset < 0x100)
493 offset_size = 1;
494 else if (offset < 0x10000)
495 offset_size = 2;
496 else if (offset < 0x1000000)
497 offset_size = 3;
498 else
499 offset_size = 4;
500
501 buf[0] = (unsigned char) offset_size;
502 status = _cairo_array_append (output, buf);
503 if (unlikely (status))
504 return status;
505
506 offset = 1;
507 encode_index_offset (buf, offset_size, offset);
508 status = _cairo_array_append_multiple (output, buf, offset_size);
509 if (unlikely (status))
510 return status;
511
512 for (i = 0; i < num_elem; i++) {
513 element = _cairo_array_index (index, i);
514 offset += element->length;
515 encode_index_offset (buf, offset_size, offset);
516 status = _cairo_array_append_multiple (output, buf, offset_size);
517 if (unlikely (status))
518 return status;
519 }
520
521 for (i = 0; i < num_elem; i++) {
522 element = _cairo_array_index (index, i);
523 if (element->length > 0) {
524 status = _cairo_array_append_multiple (output,
525 element->data,
526 element->length);
527 }
528 if (unlikely (status))
529 return status;
530 }
531 return CAIRO_STATUS_SUCCESS;
532 }
533
534 static void
535 cff_index_set_object (cairo_array_t *index, int obj_index,
536 unsigned char *object , int length)
537 {
538 cff_index_element_t *element;
539
540 element = _cairo_array_index (index, obj_index);
541 if (element->is_copy)
542 free (element->data);
543
544 element->data = object;
545 element->length = length;
546 element->is_copy = FALSE;
547 }
548
549 static cairo_status_t
550 cff_index_append (cairo_array_t *index, unsigned char *object , int length)
551 {
552 cff_index_element_t element;
553
554 element.length = length;
555 element.is_copy = FALSE;
556 element.data = object;
557
558 return _cairo_array_append (index, &element);
559 }
560
561 static cairo_status_t
562 cff_index_append_copy (cairo_array_t *index,
563 const unsigned char *object,
564 unsigned int length)
565 {
566 cff_index_element_t element;
567 cairo_status_t status;
568
569 element.length = length;
570 element.is_copy = TRUE;
571 element.data = malloc (element.length);
572 if (unlikely (element.data == NULL))
573 return _cairo_error (CAIRO_STATUS_NO_MEMORY);
574
575 memcpy (element.data, object, element.length);
576
577 status = _cairo_array_append (index, &element);
578 if (unlikely (status)) {
579 free (element.data);
580 return status;
581 }
582
583 return CAIRO_STATUS_SUCCESS;
584 }
585
586 static void
587 cff_index_fini (cairo_array_t *index)
588 {
589 cff_index_element_t *element;
590 unsigned int i;
591
592 for (i = 0; i < _cairo_array_num_elements (index); i++) {
593 element = _cairo_array_index (index, i);
594 if (element->is_copy && element->data)
595 free (element->data);
596 }
597 _cairo_array_fini (index);
598 }
599
600 static cairo_bool_t
601 _cairo_cff_dict_equal (const void *key_a, const void *key_b)
602 {
603 const cff_dict_operator_t *op_a = key_a;
604 const cff_dict_operator_t *op_b = key_b;
605
606 return op_a->operator == op_b->operator;
607 }
608
609 static cairo_status_t
610 cff_dict_init (cairo_hash_table_t **dict)
611 {
612 *dict = _cairo_hash_table_create (_cairo_cff_dict_equal);
613 if (unlikely (*dict == NULL))
614 return _cairo_error (CAIRO_STATUS_NO_MEMORY);
615
616 return CAIRO_STATUS_SUCCESS;
617 }
618
619 static void
620 _cairo_dict_init_key (cff_dict_operator_t *key, int operator)
621 {
622 key->base.hash = (unsigned long) operator;
623 key->operator = operator;
624 }
625
626 static cairo_status_t
627 cff_dict_create_operator (int operator,
628 unsigned char *operand,
629 int size,
630 cff_dict_operator_t **out)
631 {
632 cff_dict_operator_t *op;
633
634 op = malloc (sizeof (cff_dict_operator_t));
635 if (unlikely (op == NULL))
636 return _cairo_error (CAIRO_STATUS_NO_MEMORY);
637
638 _cairo_dict_init_key (op, operator);
639 op->operand = malloc (size);
640 if (unlikely (op->operand == NULL)) {
641 free (op);
642 return _cairo_error (CAIRO_STATUS_NO_MEMORY);
643 }
644
645 memcpy (op->operand, operand, size);
646 op->operand_length = size;
647 op->operand_offset = -1;
648
649 *out = op;
650 return CAIRO_STATUS_SUCCESS;
651 }
652
653 static cairo_status_t
654 cff_dict_read (cairo_hash_table_t *dict, unsigned char *p, int dict_size)
655 {
656 unsigned char *end;
657 cairo_array_t operands;
658 cff_dict_operator_t *op;
659 unsigned short operator;
660 cairo_status_t status = CAIRO_STATUS_SUCCESS;
661 int size;
662
663 end = p + dict_size;
664 _cairo_array_init (&operands, 1);
665 while (p < end) {
666 size = operand_length (p);
667 if (size != 0) {
668 status = _cairo_array_append_multiple (&operands, p, size);
669 if (unlikely (status))
670 goto fail;
671
672 p += size;
673 } else {
674 p = decode_operator (p, &operator);
675 status = cff_dict_create_operator (operator,
676 _cairo_array_index (&operands, 0),
677 _cairo_array_num_elements (&operands),
678 &op);
679 if (unlikely (status))
680 goto fail;
681
682 status = _cairo_hash_table_insert (dict, &op->base);
683 if (unlikely (status))
684 goto fail;
685
686 _cairo_array_truncate (&operands, 0);
687 }
688 }
689
690 fail:
691 _cairo_array_fini (&operands);
692
693 return status;
694 }
695
696 static void
697 cff_dict_remove (cairo_hash_table_t *dict, unsigned short operator)
698 {
699 cff_dict_operator_t key, *op;
700
701 _cairo_dict_init_key (&key, operator);
702 op = _cairo_hash_table_lookup (dict, &key.base);
703 if (op != NULL) {
704 free (op->operand);
705 _cairo_hash_table_remove (dict, (cairo_hash_entry_t *) op);
706 free (op);
707 }
708 }
709
710 static unsigned char *
711 cff_dict_get_operands (cairo_hash_table_t *dict,
712 unsigned short operator,
713 int *size)
714 {
715 cff_dict_operator_t key, *op;
716
717 _cairo_dict_init_key (&key, operator);
718 op = _cairo_hash_table_lookup (dict, &key.base);
719 if (op != NULL) {
720 *size = op->operand_length;
721 return op->operand;
722 }
723
724 return NULL;
725 }
726
727 static cairo_status_t
728 cff_dict_set_operands (cairo_hash_table_t *dict,
729 unsigned short operator,
730 unsigned char *operand,
731 int size)
732 {
733 cff_dict_operator_t key, *op;
734 cairo_status_t status;
735
736 _cairo_dict_init_key (&key, operator);
737 op = _cairo_hash_table_lookup (dict, &key.base);
738 if (op != NULL) {
739 free (op->operand);
740 op->operand = malloc (size);
741 if (unlikely (op->operand == NULL))
742 return _cairo_error (CAIRO_STATUS_NO_MEMORY);
743
744 memcpy (op->operand, operand, size);
745 op->operand_length = size;
746 }
747 else
748 {
749 status = cff_dict_create_operator (operator, operand, size, &op);
750 if (unlikely (status))
751 return status;
752
753 status = _cairo_hash_table_insert (dict, &op->base);
754 if (unlikely (status))
755 return status;
756 }
757
758 return CAIRO_STATUS_SUCCESS;
759 }
760
761 static int
762 cff_dict_get_location (cairo_hash_table_t *dict,
763 unsigned short operator,
764 int *size)
765 {
766 cff_dict_operator_t key, *op;
767
768 _cairo_dict_init_key (&key, operator);
769 op = _cairo_hash_table_lookup (dict, &key.base);
770 if (op != NULL) {
771 *size = op->operand_length;
772 return op->operand_offset;
773 }
774
775 return -1;
776 }
777
778 typedef struct _dict_write_info {
779 cairo_array_t *output;
780 cairo_status_t status;
781 } dict_write_info_t;
782
783 static void
784 cairo_dict_write_operator (cff_dict_operator_t *op, dict_write_info_t *write_info)
785 {
786 unsigned char data;
787
788 op->operand_offset = _cairo_array_num_elements (write_info->output);
789 write_info->status = _cairo_array_append_multiple (write_info->output, op->operand, op->operand_length);
790 if (write_info->status)
791 return;
792
793 if (op->operator & 0xff00) {
794 data = op->operator >> 8;
795 write_info->status = _cairo_array_append (write_info->output, &data);
796 if (write_info->status)
797 return;
798 }
799 data = op->operator & 0xff;
800 write_info->status = _cairo_array_append (write_info->output, &data);
801 }
802
803 static void
804 _cairo_dict_collect (void *entry, void *closure)
805 {
806 dict_write_info_t *write_info = closure;
807 cff_dict_operator_t *op = entry;
808
809 if (write_info->status)
810 return;
811
812 /* The ROS operator is handled separately in cff_dict_write() */
813 if (op->operator != ROS_OP)
814 cairo_dict_write_operator (op, write_info);
815 }
816
817 static cairo_status_t
818 cff_dict_write (cairo_hash_table_t *dict, cairo_array_t *output)
819 {
820 dict_write_info_t write_info;
821 cff_dict_operator_t key, *op;
822
823 write_info.output = output;
824 write_info.status = CAIRO_STATUS_SUCCESS;
825
826 /* The CFF specification requires that the Top Dict of CID fonts
827 * begin with the ROS operator. */
828 _cairo_dict_init_key (&key, ROS_OP);
829 op = _cairo_hash_table_lookup (dict, &key.base);
830 if (op != NULL)
831 cairo_dict_write_operator (op, &write_info);
832
833 _cairo_hash_table_foreach (dict, _cairo_dict_collect, &write_info);
834
835 return write_info.status;
836 }
837
838 static void
839 _cff_dict_entry_pluck (void *_entry, void *dict)
840 {
841 cff_dict_operator_t *entry = _entry;
842
843 _cairo_hash_table_remove (dict, &entry->base);
844 free (entry->operand);
845 free (entry);
846 }
847
848 static void
849 cff_dict_fini (cairo_hash_table_t *dict)
850 {
851 _cairo_hash_table_foreach (dict, _cff_dict_entry_pluck, dict);
852 _cairo_hash_table_destroy (dict);
853 }
854
855 static cairo_int_status_t
856 cairo_cff_font_read_header (cairo_cff_font_t *font)
857 {
858 if (font->data_length < sizeof (cff_header_t))
859 return CAIRO_INT_STATUS_UNSUPPORTED;
860
861
862 font->header = (cff_header_t *) font->data;
863 font->current_ptr = font->data + font->header->header_size;
864
865 return CAIRO_STATUS_SUCCESS;
866 }
867
868 static cairo_int_status_t
869 cairo_cff_font_read_name (cairo_cff_font_t *font)
870 {
871 cairo_array_t index;
872 cairo_int_status_t status;
873 cff_index_element_t *element;
874 unsigned char *p;
875 int i, len;
876
877 cff_index_init (&index);
878 status = cff_index_read (&index, &font->current_ptr, font->data_end);
879 if (!font->is_opentype) {
880 element = _cairo_array_index (&index, 0);
881 p = element->data;
882 len = element->length;
883
884 /* If font name is prefixed with a subset tag, strip it off. */
885 if (len > 7 && p[6] == '+') {
886 for (i = 0; i < 6; i++)
887 if (p[i] < 'A' || p[i] > 'Z')
888 break;
889 if (i == 6) {
890 p += 7;
891 len -= 7;
892 }
893 }
894 font->ps_name = malloc (len + 1);
895 if (unlikely (font->ps_name == NULL))
896 return _cairo_error (CAIRO_STATUS_NO_MEMORY);
897
898 memcpy (font->ps_name, p, len);
899 font->ps_name[len] = 0;
900
901 status = _cairo_escape_ps_name (&font->ps_name);
902 }
903 cff_index_fini (&index);
904
905 return status;
906 }
907
908 static cairo_int_status_t
909 cairo_cff_font_read_private_dict (cairo_cff_font_t *font,
910 cairo_hash_table_t *private_dict,
911 cairo_array_t *local_sub_index,
912 int *local_sub_bias,
913 cairo_bool_t **local_subs_used,
914 double *default_width,
915 double *nominal_width,
916 unsigned char *ptr,
917 int size)
918 {
919 cairo_int_status_t status;
920 unsigned char buf[10];
921 unsigned char *end_buf;
922 int offset;
923 int i;
924 unsigned char *operand;
925 unsigned char *p;
926 int num_subs;
927
928 status = cff_dict_read (private_dict, ptr, size);
929 if (unlikely (status))
930 return status;
931
932 operand = cff_dict_get_operands (private_dict, LOCAL_SUB_OP, &i);
933 if (operand) {
934 decode_integer (operand, &offset);
935 p = ptr + offset;
936 status = cff_index_read (local_sub_index, &p, font->data_end);
937 if (unlikely (status))
938 return status;
939
940 /* Use maximum sized encoding to reserve space for later modification. */
941 end_buf = encode_integer_max (buf, 0);
942 status = cff_dict_set_operands (private_dict, LOCAL_SUB_OP, buf, end_buf - buf);
943 if (unlikely (status))
944 return status;
945 }
946
947 *default_width = 0;
948 operand = cff_dict_get_operands (private_dict, DEFAULTWIDTH_OP, &i);
949 if (operand)
950 decode_number (operand, default_width);
951
952 *nominal_width = 0;
953 operand = cff_dict_get_operands (private_dict, NOMINALWIDTH_OP, &i);
954 if (operand)
955 decode_number (operand, nominal_width);
956
957 num_subs = _cairo_array_num_elements (local_sub_index);
958 *local_subs_used = calloc (num_subs, sizeof (cairo_bool_t));
959 if (unlikely (*local_subs_used == NULL))
960 return _cairo_error (CAIRO_STATUS_NO_MEMORY);
961
962 if (num_subs < 1240)
963 *local_sub_bias = 107;
964 else if (num_subs < 33900)
965 *local_sub_bias = 1131;
966 else
967 *local_sub_bias = 32768;
968
969 return CAIRO_STATUS_SUCCESS;
970 }
971
972 static cairo_int_status_t
973 cairo_cff_font_read_fdselect (cairo_cff_font_t *font, unsigned char *p)
974 {
975 int type, num_ranges, first, last, fd, i, j;
976
977 font->fdselect = calloc (font->num_glyphs, sizeof (int));
978 if (unlikely (font->fdselect == NULL))
979 return _cairo_error (CAIRO_STATUS_NO_MEMORY);
980
981 type = *p++;
982 if (type == 0)
983 {
984 for (i = 0; i < font->num_glyphs; i++)
985 font->fdselect[i] = *p++;
986 } else if (type == 3) {
987 num_ranges = get_unaligned_be16 (p);
988 p += 2;
989 for (i = 0; i < num_ranges; i++)
990 {
991 first = get_unaligned_be16 (p);
992 p += 2;
993 fd = *p++;
994 last = get_unaligned_be16 (p);
995 for (j = first; j < last; j++)
996 font->fdselect[j] = fd;
997 }
998 } else {
999 return CAIRO_INT_STATUS_UNSUPPORTED;
1000 }
1001
1002 return CAIRO_STATUS_SUCCESS;
1003 }
1004
1005 static cairo_int_status_t
1006 cairo_cff_font_read_cid_fontdict (cairo_cff_font_t *font, unsigned char *ptr)
1007 {
1008 cairo_array_t index;
1009 cff_index_element_t *element;
1010 unsigned int i;
1011 int size;
1012 unsigned char *operand;
1013 int offset;
1014 cairo_int_status_t status;
1015 unsigned char buf[100];
1016 unsigned char *end_buf;
1017
1018 cff_index_init (&index);
1019 status = cff_index_read (&index, &ptr, font->data_end);
1020 if (unlikely (status))
1021 goto fail;
1022
1023 font->num_fontdicts = _cairo_array_num_elements (&index);
1024
1025 font->fd_dict = calloc (sizeof (cairo_hash_table_t *), font->num_fontdicts);
1026 if (unlikely (font->fd_dict == NULL)) {
1027 status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
1028 goto fail;
1029 }
1030
1031 font->fd_private_dict = calloc (sizeof (cairo_hash_table_t *), font->num_fontdicts);
1032 if (unlikely (font->fd_private_dict == NULL)) {
1033 status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
1034 goto fail;
1035 }
1036
1037 font->fd_local_sub_index = calloc (sizeof (cairo_array_t), font->num_fontdicts);
1038 if (unlikely (font->fd_local_sub_index == NULL)) {
1039 status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
1040 goto fail;
1041 }
1042
1043 font->fd_local_sub_bias = calloc (sizeof (int), font->num_fontdicts);
1044 if (unlikely (font->fd_local_sub_bias == NULL)) {
1045 status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
1046 goto fail;
1047 }
1048
1049 font->fd_local_subs_used = calloc (sizeof (cairo_bool_t *), font->num_fontdicts);
1050 if (unlikely (font->fd_local_subs_used == NULL)) {
1051 status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
1052 goto fail;
1053 }
1054
1055 font->fd_default_width = calloc (font->num_fontdicts, sizeof (double));
1056 if (unlikely (font->fd_default_width == NULL)) {
1057 status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
1058 goto fail;
1059 }
1060
1061 font->fd_nominal_width = calloc (font->num_fontdicts, sizeof (double));
1062 if (unlikely (font->fd_nominal_width == NULL)) {
1063 status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
1064 goto fail;
1065 }
1066
1067 for (i = 0; i < font->num_fontdicts; i++) {
1068 status = cff_dict_init (&font->fd_dict[i]);
1069 if (unlikely (status))
1070 goto fail;
1071
1072 element = _cairo_array_index (&index, i);
1073 status = cff_dict_read (font->fd_dict[i], element->data, element->length);
1074 if (unlikely (status))
1075 goto fail;
1076
1077 operand = cff_dict_get_operands (font->fd_dict[i], PRIVATE_OP, &size);
1078 if (operand == NULL) {
1079 status = CAIRO_INT_STATUS_UNSUPPORTED;
1080 goto fail;
1081 }
1082 operand = decode_integer (operand, &size);
1083 decode_integer (operand, &offset);
1084 status = cff_dict_init (&font->fd_private_dict[i]);
1085 if (unlikely (status))
1086 goto fail;
1087
1088 cff_index_init (&font->fd_local_sub_index[i]);
1089 status = cairo_cff_font_read_private_dict (font,
1090 font->fd_private_dict[i],
1091 &font->fd_local_sub_index[i],
1092 &font->fd_local_sub_bias[i],
1093 &font->fd_local_subs_used[i],
1094 &font->fd_default_width[i],
1095 &font->fd_nominal_width[i],
1096 font->data + offset,
1097 size);
1098 if (unlikely (status))
1099 goto fail;
1100
1101 /* Set integer operand to max value to use max size encoding to reserve
1102 * space for any value later */
1103 end_buf = encode_integer_max (buf, 0);
1104 end_buf = encode_integer_max (end_buf, 0);
1105 status = cff_dict_set_operands (font->fd_dict[i], PRIVATE_OP, buf, end_buf - buf);
1106 if (unlikely (status))
1107 goto fail;
1108 }
1109
1110 return CAIRO_STATUS_SUCCESS;
1111
1112 fail:
1113 cff_index_fini (&index);
1114
1115 return status;
1116 }
1117
1118 static void
1119 cairo_cff_font_read_font_metrics (cairo_cff_font_t *font, cairo_hash_table_t *top_dict)
1120 {
1121 unsigned char *p;
1122 unsigned char *end;
1123 int size;
1124 double x_min, y_min, x_max, y_max;
1125 double xx, yx, xy, yy;
1126
1127 x_min = 0.0;
1128 y_min = 0.0;
1129 x_max = 0.0;
1130 y_max = 0.0;
1131 p = cff_dict_get_operands (font->top_dict, FONTBBOX_OP, &size);
1132 if (p) {
1133 end = p + size;
1134 if (p < end)
1135 p = decode_number (p, &x_min);
1136 if (p < end)
1137 p = decode_number (p, &y_min);
1138 if (p < end)
1139 p = decode_number (p, &x_max);
1140 if (p < end)
1141 p = decode_number (p, &y_max);
1142 }
1143 font->x_min = floor (x_min);
1144 font->y_min = floor (y_min);
1145 font->x_max = floor (x_max);
1146 font->y_max = floor (y_max);
1147 font->ascent = font->y_max;
1148 font->descent = font->y_min;
1149
1150 xx = 0.001;
1151 yx = 0.0;
1152 xy = 0.0;
1153 yy = 0.001;
1154 p = cff_dict_get_operands (font->top_dict, FONTMATRIX_OP, &size);
1155 if (p) {
1156 end = p + size;
1157 if (p < end)
1158 p = decode_number (p, &xx);
1159 if (p < end)
1160 p = decode_number (p, &yx);
1161 if (p < end)
1162 p = decode_number (p, &xy);
1163 if (p < end)
1164 p = decode_number (p, &yy);
1165 }
1166 /* Freetype uses 1/abs(yy) to get units per EM */
1167 font->units_per_em = _cairo_round(1.0/fabs(yy));
1168 }
1169
1170 static cairo_int_status_t
1171 cairo_cff_font_read_top_dict (cairo_cff_font_t *font)
1172 {
1173 cairo_array_t index;
1174 cff_index_element_t *element;
1175 unsigned char buf[20];
1176 unsigned char *end_buf;
1177 unsigned char *operand;
1178 cairo_int_status_t status;
1179 unsigned char *p;
1180 int size;
1181 int offset;
1182
1183 cff_index_init (&index);
1184 status = cff_index_read (&index, &font->current_ptr, font->data_end);
1185 if (unlikely (status))
1186 goto fail;
1187
1188 element = _cairo_array_index (&index, 0);
1189 status = cff_dict_read (font->top_dict, element->data, element->length);
1190 if (unlikely (status))
1191 goto fail;
1192
1193 if (cff_dict_get_operands (font->top_dict, ROS_OP, &size) != NULL)
1194 font->is_cid = TRUE;
1195 else
1196 font->is_cid = FALSE;
1197
1198 operand = cff_dict_get_operands (font->top_dict, CHARSTRINGS_OP, &size);
1199 decode_integer (operand, &offset);
1200 p = font->data + offset;
1201 status = cff_index_read (&font->charstrings_index, &p, font->data_end);
1202 if (unlikely (status))
1203 goto fail;
1204 font->num_glyphs = _cairo_array_num_elements (&font->charstrings_index);
1205
1206 if (font->is_cid) {
1207 operand = cff_dict_get_operands (font->top_dict, CHARSET_OP, &size);
1208 if (!operand)
1209 return CAIRO_INT_STATUS_UNSUPPORTED;
1210
1211 decode_integer (operand, &offset);
1212 font->charset = font->data + offset;
1213 if (font->charset >= font->data_end)
1214 return CAIRO_INT_STATUS_UNSUPPORTED;
1215 }
1216
1217 if (!font->is_opentype)
1218 cairo_cff_font_read_font_metrics (font, font->top_dict);
1219
1220 if (font->is_cid) {
1221 operand = cff_dict_get_operands (font->top_dict, FDSELECT_OP, &size);
1222 decode_integer (operand, &offset);
1223 status = cairo_cff_font_read_fdselect (font, font->data + offset);
1224 if (unlikely (status))
1225 goto fail;
1226
1227 operand = cff_dict_get_operands (font->top_dict, FDARRAY_OP, &size);
1228 decode_integer (operand, &offset);
1229 status = cairo_cff_font_read_cid_fontdict (font, font->data + offset);
1230 if (unlikely (status))
1231 goto fail;
1232 } else {
1233 operand = cff_dict_get_operands (font->top_dict, PRIVATE_OP, &size);
1234 operand = decode_integer (operand, &size);
1235 decode_integer (operand, &offset);
1236 status = cairo_cff_font_read_private_dict (font,
1237 font->private_dict,
1238 &font->local_sub_index,
1239 &font->local_sub_bias,
1240 &font->local_subs_used,
1241 &font->default_width,
1242 &font->nominal_width,
1243 font->data + offset,
1244 size);
1245 if (unlikely (status))
1246 goto fail;
1247 }
1248
1249 /* Use maximum sized encoding to reserve space for later modification. */
1250 end_buf = encode_integer_max (buf, 0);
1251 status = cff_dict_set_operands (font->top_dict,
1252 CHARSTRINGS_OP, buf, end_buf - buf);
1253 if (unlikely (status))
1254 goto fail;
1255
1256 status = cff_dict_set_operands (font->top_dict,
1257 CHARSET_OP, buf, end_buf - buf);
1258 if (unlikely (status))
1259 goto fail;
1260
1261 if (font->scaled_font_subset->is_latin) {
1262 status = cff_dict_set_operands (font->top_dict,
1263 ENCODING_OP, buf, end_buf - buf);
1264 if (unlikely (status))
1265 goto fail;
1266
1267 /* Private has two operands - size and offset */
1268 end_buf = encode_integer_max (end_buf, 0);
1269 cff_dict_set_operands (font->top_dict, PRIVATE_OP, buf, end_buf - buf);
1270 if (unlikely (status))
1271 goto fail;
1272
1273 } else {
1274 status = cff_dict_set_operands (font->top_dict,
1275 FDSELECT_OP, buf, end_buf - buf);
1276 if (unlikely (status))
1277 goto fail;
1278
1279 status = cff_dict_set_operands (font->top_dict,
1280 FDARRAY_OP, buf, end_buf - buf);
1281 if (unlikely (status))
1282 goto fail;
1283
1284 cff_dict_remove (font->top_dict, ENCODING_OP);
1285 cff_dict_remove (font->top_dict, PRIVATE_OP);
1286 }
1287
1288 /* Remove the unique identifier operators as the subsetted font is
1289 * not the same is the original font. */
1290 cff_dict_remove (font->top_dict, UNIQUEID_OP);
1291 cff_dict_remove (font->top_dict, XUID_OP);
1292
1293 fail:
1294 cff_index_fini (&index);
1295
1296 return status;
1297 }
1298
1299 static cairo_int_status_t
1300 cairo_cff_font_read_strings (cairo_cff_font_t *font)
1301 {
1302 return cff_index_read (&font->strings_index, &font->current_ptr, font->data_end);
1303 }
1304
1305 static cairo_int_status_t
1306 cairo_cff_font_read_global_subroutines (cairo_cff_font_t *font)
1307 {
1308 cairo_int_status_t status;
1309 int num_subs;
1310
1311 status = cff_index_read (&font->global_sub_index, &font->current_ptr, font->data_end);
1312 if (unlikely (status))
1313 return status;
1314
1315 num_subs = _cairo_array_num_elements (&font->global_sub_index);
1316 font->global_subs_used = calloc (num_subs, sizeof(cairo_bool_t));
1317 if (unlikely (font->global_subs_used == NULL))
1318 return _cairo_error (CAIRO_STATUS_NO_MEMORY);
1319
1320 if (num_subs < 1240)
1321 font->global_sub_bias = 107;
1322 else if (num_subs < 33900)
1323 font->global_sub_bias = 1131;
1324 else
1325 font->global_sub_bias = 32768;
1326
1327 return CAIRO_STATUS_SUCCESS;
1328 }
1329
1330 typedef cairo_int_status_t
1331 (*font_read_t) (cairo_cff_font_t *font);
1332
1333 static const font_read_t font_read_funcs[] = {
1334 cairo_cff_font_read_header,
1335 cairo_cff_font_read_name,
1336 cairo_cff_font_read_top_dict,
1337 cairo_cff_font_read_strings,
1338 cairo_cff_font_read_global_subroutines,
1339 };
1340
1341 static cairo_int_status_t
1342 cairo_cff_font_read_font (cairo_cff_font_t *font)
1343 {
1344 cairo_int_status_t status;
1345 unsigned int i;
1346
1347 for (i = 0; i < ARRAY_LENGTH (font_read_funcs); i++) {
1348 status = font_read_funcs[i] (font);
1349 if (unlikely (status))
1350 return status;
1351 }
1352
1353 return CAIRO_STATUS_SUCCESS;
1354 }
1355
1356 static cairo_status_t
1357 cairo_cff_font_set_ros_strings (cairo_cff_font_t *font)
1358 {
1359 cairo_status_t status;
1360 unsigned char buf[30];
1361 unsigned char *p;
1362 int sid1, sid2;
1363 const char *registry = "Adobe";
1364 const char *ordering = "Identity";
1365
1366 sid1 = NUM_STD_STRINGS + _cairo_array_num_elements (&font->strings_subset_index);
1367 status = cff_index_append_copy (&font->strings_subset_index,
1368 (unsigned char *)registry,
1369 strlen(registry));
1370 if (unlikely (status))
1371 return status;
1372
1373 sid2 = NUM_STD_STRINGS + _cairo_array_num_elements (&font->strings_subset_index);
1374 status = cff_index_append_copy (&font->strings_subset_index,
1375 (unsigned char *)ordering,
1376 strlen(ordering));
1377 if (unlikely (status))
1378 return status;
1379
1380 p = encode_integer (buf, sid1);
1381 p = encode_integer (p, sid2);
1382 p = encode_integer (p, 0);
1383 status = cff_dict_set_operands (font->top_dict, ROS_OP, buf, p - buf);
1384 if (unlikely (status))
1385 return status;
1386
1387 p = encode_integer (buf, font->scaled_font_subset->num_glyphs);
1388 status = cff_dict_set_operands (font->top_dict, CIDCOUNT_OP, buf, p - buf);
1389 if (unlikely (status))
1390 return status;
1391
1392 return CAIRO_STATUS_SUCCESS;
1393 }
1394
1395 static cairo_status_t
1396 cairo_cff_font_subset_dict_string(cairo_cff_font_t *font,
1397 cairo_hash_table_t *dict,
1398 int operator)
1399 {
1400 int size;
1401 unsigned char *p;
1402 int sid;
1403 unsigned char buf[100];
1404 cff_index_element_t *element;
1405 cairo_status_t status;
1406
1407 p = cff_dict_get_operands (dict, operator, &size);
1408 if (!p)
1409 return CAIRO_STATUS_SUCCESS;
1410
1411 decode_integer (p, &sid);
1412 if (sid < NUM_STD_STRINGS)
1413 return CAIRO_STATUS_SUCCESS;
1414
1415 element = _cairo_array_index (&font->strings_index, sid - NUM_STD_STRINGS);
1416 sid = NUM_STD_STRINGS + _cairo_array_num_elements (&font->strings_subset_index);
1417 status = cff_index_append (&font->strings_subset_index, element->data, element->length);
1418 if (unlikely (status))
1419 return status;
1420
1421 p = encode_integer (buf, sid);
1422 status = cff_dict_set_operands (dict, operator, buf, p - buf);
1423 if (unlikely (status))
1424 return status;
1425
1426 return CAIRO_STATUS_SUCCESS;
1427 }
1428
1429 static const int dict_strings[] = {
1430 VERSION_OP,
1431 NOTICE_OP,
1432 COPYRIGHT_OP,
1433 FULLNAME_OP,
1434 FAMILYNAME_OP,
1435 WEIGHT_OP,
1436 POSTSCRIPT_OP,
1437 BASEFONTNAME_OP,
1438 FONTNAME_OP,
1439 };
1440
1441 static cairo_status_t
1442 cairo_cff_font_subset_dict_strings (cairo_cff_font_t *font,
1443 cairo_hash_table_t *dict)
1444 {
1445 cairo_status_t status;
1446 unsigned int i;
1447
1448 for (i = 0; i < ARRAY_LENGTH (dict_strings); i++) {
1449 status = cairo_cff_font_subset_dict_string (font, dict, dict_strings[i]);
1450 if (unlikely (status))
1451 return status;
1452 }
1453
1454 return CAIRO_STATUS_SUCCESS;
1455 }
1456
1457 static unsigned char *
1458 type2_decode_integer (unsigned char *p, int *integer)
1459 {
1460 if (*p == 28) {
1461 *integer = p[1] << 8 | p[2];
1462 p += 3;
1463 } else if (*p <= 246) {
1464 *integer = *p++ - 139;
1465 } else if (*p <= 250) {
1466 *integer = (p[0] - 247) * 256 + p[1] + 108;
1467 p += 2;
1468 } else if (*p <= 254) {
1469 *integer = -(p[0] - 251) * 256 - p[1] - 108;
1470 p += 2;
1471 } else { /* *p == 255 */
1472 /* 16.16 fixed-point number. The fraction is ignored. */
1473 *integer = (int16_t)((p[1] << 8) | p[2]);
1474 p += 5;
1475 }
1476 return p;
1477 }
1478
1479 /* Type 2 charstring parser for finding calls to local or global
1480 * subroutines. For non Opentype CFF fonts it also gets the glyph
1481 * widths.
1482 *
1483 * When we find a subroutine operator, the subroutine is marked as in
1484 * use and recursively followed. The subroutine number is the value on
1485 * the top of the stack when the subroutine operator is executed. In
1486 * most fonts the subroutine number is encoded in an integer
1487 * immediately preceding the subroutine operator. However it is
1488 * possible for the subroutine number on the stack to be the result of
1489 * a computation (in which case there will be an operator preceding
1490 * the subroutine operator). If this occurs, subroutine subsetting is
1491 * disabled since we can't easily determine which subroutines are
1492 * used.
1493 *
1494 * The width, if present, is the first integer in the charstring. The
1495 * only way to confirm if the integer at the start of the charstring is
1496 * the width is when the first stack clearing operator is parsed,
1497 * check if there is an extra integer left over on the stack.
1498 *
1499 * When the first stack clearing operator is encountered
1500 * type2_find_width is set to FALSE and type2_found_width is set to
1501 * TRUE if an extra argument is found, otherwise FALSE.
1502 */
1503 static cairo_status_t
1504 cairo_cff_parse_charstring (cairo_cff_font_t *font,
1505 unsigned char *charstring, int length,
1506 int glyph_id,
1507 cairo_bool_t need_width)
1508 {
1509 unsigned char *p = charstring;
1510 unsigned char *end = charstring + length;
1511 int integer;
1512 int hint_bytes;
1513 int sub_num;
1514 cff_index_element_t *element;
1515 int fd;
1516
1517 while (p < end) {
1518 if (*p == 28 || *p >= 32) {
1519 /* Integer value */
1520 p = type2_decode_integer (p, &integer);
1521 font->type2_stack_size++;
1522 font->type2_stack_top_value = integer;
1523 font->type2_stack_top_is_int = TRUE;
1524 if (!font->type2_seen_first_int) {
1525 font->type2_width = integer;
1526 font->type2_seen_first_int = TRUE;
1527 }
1528 } else if (*p == TYPE2_hstem || *p == TYPE2_vstem ||
1529 *p == TYPE2_hstemhm || *p == TYPE2_vstemhm) {
1530 /* Hint operator. The number of hints declared by the
1531 * operator depends on the size of the stack. */
1532 font->type2_stack_top_is_int = FALSE;
1533 font->type2_num_hints += font->type2_stack_size/2;
1534 if (font->type2_find_width && font->type2_stack_size % 2)
1535 font->type2_found_width = TRUE;
1536
1537 font->type2_stack_size = 0;
1538 font->type2_find_width = FALSE;
1539 p++;
1540 } else if (*p == TYPE2_hintmask || *p == TYPE2_cntrmask) {
1541 /* Hintmask operator. These operators are followed by a
1542 * variable length mask where the length depends on the
1543 * number of hints declared. The first time this is called
1544 * it is also an implicit vstem if there are arguments on
1545 * the stack. */
1546 if (font->type2_hintmask_bytes == 0) {
1547 font->type2_stack_top_is_int = FALSE;
1548 font->type2_num_hints += font->type2_stack_size/2;
1549 if (font->type2_find_width && font->type2_stack_size % 2)
1550 font->type2_found_width = TRUE;
1551
1552 font->type2_stack_size = 0;
1553 font->type2_find_width = FALSE;
1554 font->type2_hintmask_bytes = (font->type2_num_hints+7)/8;
1555 }
1556
1557 hint_bytes = font->type2_hintmask_bytes;
1558 p++;
1559 p += hint_bytes;
1560 } else if (*p == TYPE2_rmoveto) {
1561 if (font->type2_find_width && font->type2_stack_size > 2)
1562 font->type2_found_width = TRUE;
1563
1564 font->type2_stack_size = 0;
1565 font->type2_find_width = FALSE;
1566 font->type2_has_path = TRUE;
1567 p++;
1568 } else if (*p == TYPE2_hmoveto || *p == TYPE2_vmoveto) {
1569 if (font->type2_find_width && font->type2_stack_size > 1)
1570 font->type2_found_width = TRUE;
1571
1572 font->type2_stack_size = 0;
1573 font->type2_find_width = FALSE;
1574 font->type2_has_path = TRUE;
1575 p++;
1576 } else if (*p == TYPE2_endchar) {
1577 if (!font->type2_has_path && font->type2_stack_size > 3)
1578 return CAIRO_INT_STATUS_UNSUPPORTED; /* seac (Ref Appendix C of Type 2 Charstring Format */
1579
1580 if (font->type2_find_width && font->type2_stack_size > 0)
1581 font->type2_found_width = TRUE;
1582
1583 return CAIRO_STATUS_SUCCESS;
1584 } else if (*p == TYPE2_callsubr) {
1585 /* call to local subroutine */
1586 if (! font->type2_stack_top_is_int)
1587 return CAIRO_INT_STATUS_UNSUPPORTED;
1588
1589 if (++font->type2_nesting_level > MAX_SUBROUTINE_NESTING)
1590 return CAIRO_INT_STATUS_UNSUPPORTED;
1591
1592 p++;
1593 font->type2_stack_top_is_int = FALSE;
1594 font->type2_stack_size--;
1595 if (font->type2_find_width && font->type2_stack_size == 0)
1596 font->type2_seen_first_int = FALSE;
1597
1598 if (font->is_cid) {
1599 fd = font->fdselect[glyph_id];
1600 sub_num = font->type2_stack_top_value + font->fd_local_sub_bias[fd];
1601 element = _cairo_array_index (&font->fd_local_sub_index[fd], sub_num);
1602 if (! font->fd_local_subs_used[fd][sub_num]) {
1603 font->fd_local_subs_used[fd][sub_num] = TRUE;
1604 cairo_cff_parse_charstring (font, element->data, element->length, glyph_id, need_width);
1605 }
1606 } else {
1607 sub_num = font->type2_stack_top_value + font->local_sub_bias;
1608 element = _cairo_array_index (&font->local_sub_index, sub_num);
1609 if (! font->local_subs_used[sub_num] ||
1610 (need_width && !font->type2_found_width))
1611 {
1612 font->local_subs_used[sub_num] = TRUE;
1613 cairo_cff_parse_charstring (font, element->data, element->length, glyph_id, need_width);
1614 }
1615 }
1616 font->type2_nesting_level--;
1617 } else if (*p == TYPE2_callgsubr) {
1618 /* call to global subroutine */
1619 if (! font->type2_stack_top_is_int)
1620 return CAIRO_INT_STATUS_UNSUPPORTED;
1621
1622 if (++font->type2_nesting_level > MAX_SUBROUTINE_NESTING)
1623 return CAIRO_INT_STATUS_UNSUPPORTED;
1624
1625 p++;
1626 font->type2_stack_size--;
1627 font->type2_stack_top_is_int = FALSE;
1628 if (font->type2_find_width && font->type2_stack_size == 0)
1629 font->type2_seen_first_int = FALSE;
1630
1631 sub_num = font->type2_stack_top_value + font->global_sub_bias;
1632 element = _cairo_array_index (&font->global_sub_index, sub_num);
1633 if (! font->global_subs_used[sub_num] ||
1634 (need_width && !font->type2_found_width))
1635 {
1636 font->global_subs_used[sub_num] = TRUE;
1637 cairo_cff_parse_charstring (font, element->data, element->length, glyph_id, need_width);
1638 }
1639 font->type2_nesting_level--;
1640 } else if (*p == 12) {
1641 /* 2 byte instruction */
1642
1643 /* All the 2 byte operators are either not valid before a
1644 * stack clearing operator or they are one of the
1645 * arithmetic, storage, or conditional operators. */
1646 if (need_width && font->type2_find_width)
1647 return CAIRO_INT_STATUS_UNSUPPORTED;
1648
1649 p += 2;
1650 font->type2_stack_top_is_int = FALSE;
1651 } else {
1652 /* 1 byte instruction */
1653 p++;
1654 font->type2_stack_top_is_int = FALSE;
1655 }
1656 }
1657
1658 return CAIRO_STATUS_SUCCESS;
1659 }
1660
1661 static cairo_status_t
1662 cairo_cff_find_width_and_subroutines_used (cairo_cff_font_t *font,
1663 unsigned char *charstring, int length,
1664 int glyph_id, int subset_id)
1665 {
1666 cairo_status_t status;
1667 int width;
1668 int fd;
1669
1670 font->type2_stack_size = 0;
1671 font->type2_stack_top_value = 0;;
1672 font->type2_stack_top_is_int = FALSE;
1673 font->type2_num_hints = 0;
1674 font->type2_hintmask_bytes = 0;
1675 font->type2_nesting_level = 0;
1676 font->type2_seen_first_int = FALSE;
1677 font->type2_find_width = TRUE;
1678 font->type2_found_width = FALSE;
1679 font->type2_width = 0;
1680 font->type2_has_path = FALSE;
1681
1682 status = cairo_cff_parse_charstring (font, charstring, length, glyph_id, TRUE);
1683 if (status)
1684 return status;
1685
1686 if (!font->is_opentype) {
1687 if (font->is_cid) {
1688 fd = font->fdselect[glyph_id];
1689 if (font->type2_found_width)
1690 width = font->fd_nominal_width[fd] + font->type2_width;
1691 else
1692 width = font->fd_default_width[fd];
1693 } else {
1694 if (font->type2_found_width)
1695 width = font->nominal_width + font->type2_width;
1696 else
1697 width = font->default_width;
1698 }
1699 font->widths[subset_id] = width;
1700 }
1701
1702 return CAIRO_STATUS_SUCCESS;
1703 }
1704
1705 static cairo_int_status_t
1706 cairo_cff_font_get_gid_for_cid (cairo_cff_font_t *font, unsigned long cid, unsigned long *gid)
1707 {
1708 unsigned char *p;
1709 unsigned long first_gid;
1710 unsigned long first_cid;
1711 int num_left;
1712 unsigned long c, g;
1713
1714 if (cid == 0) {
1715 *gid = 0;
1716 return CAIRO_STATUS_SUCCESS;
1717 }
1718
1719 switch (font->charset[0]) {
1720 /* Format 0 */
1721 case 0:
1722 p = font->charset + 1;
1723 g = 1;
1724 while (g <= (unsigned)font->num_glyphs && p < font->data_end) {
1725 c = get_unaligned_be16 (p);
1726 if (c == cid) {
1727 *gid = g;
1728 return CAIRO_STATUS_SUCCESS;
1729 }
1730 g++;
1731 p += 2;
1732 }
1733 break;
1734
1735 /* Format 1 */
1736 case 1:
1737 first_gid = 1;
1738 p = font->charset + 1;
1739 while (first_gid <= (unsigned)font->num_glyphs && p + 2 < font->data_end) {
1740 first_cid = get_unaligned_be16 (p);
1741 num_left = p[2];
1742 if (cid >= first_cid && cid <= first_cid + num_left) {
1743 *gid = first_gid + cid - first_cid;
1744 return CAIRO_STATUS_SUCCESS;
1745 }
1746 first_gid += num_left + 1;
1747 p += 3;
1748 }
1749 break;
1750
1751 /* Format 2 */
1752 case 2:
1753 first_gid = 1;
1754 p = font->charset + 1;
1755 while (first_gid <= (unsigned)font->num_glyphs && p + 3 < font->data_end) {
1756 first_cid = get_unaligned_be16 (p);
1757 num_left = get_unaligned_be16 (p+2);
1758 if (cid >= first_cid && cid <= first_cid + num_left) {
1759 *gid = first_gid + cid - first_cid;
1760 return CAIRO_STATUS_SUCCESS;
1761 }
1762 first_gid += num_left + 1;
1763 p += 4;
1764 }
1765 break;
1766
1767 default:
1768 break;
1769 }
1770 return CAIRO_INT_STATUS_UNSUPPORTED;
1771 }
1772
1773 static cairo_int_status_t
1774 cairo_cff_font_subset_charstrings_and_subroutines (cairo_cff_font_t *font)
1775 {
1776 cff_index_element_t *element;
1777 unsigned int i;
1778 cairo_int_status_t status;
1779 unsigned long glyph, cid;
1780
1781 font->subset_subroutines = TRUE;
1782 for (i = 0; i < font->scaled_font_subset->num_glyphs; i++) {
1783 if (font->is_cid) {
1784 cid = font->scaled_font_subset->glyphs[i];
1785 status = cairo_cff_font_get_gid_for_cid (font, cid, &glyph);
1786 if (unlikely (status))
1787 return status;
1788 } else {
1789 glyph = font->scaled_font_subset->glyphs[i];
1790 }
1791 element = _cairo_array_index (&font->charstrings_index, glyph);
1792 status = cff_index_append (&font->charstrings_subset_index,
1793 element->data,
1794 element->length);
1795 if (unlikely (status))
1796 return status;
1797
1798 if (font->subset_subroutines) {
1799 status = cairo_cff_find_width_and_subroutines_used (font,
1800 element->data, element->length,
1801 glyph, i);
1802 if (status == CAIRO_INT_STATUS_UNSUPPORTED) {
1803 /* If parsing the charstrings fails we embed all the
1804 * subroutines. But if the font is not opentype we
1805 * need to successfully parse all charstrings to get
1806 * the widths. */
1807 font->subset_subroutines = FALSE;
1808 if (!font->is_opentype)
1809 return status;
1810 } else if (unlikely (status)) {
1811 return status;
1812 }
1813 }
1814 }
1815
1816 return CAIRO_STATUS_SUCCESS;
1817 }
1818
1819 static cairo_status_t
1820 cairo_cff_font_subset_fontdict (cairo_cff_font_t *font)
1821 {
1822 unsigned int i;
1823 int fd;
1824 int *reverse_map;
1825 unsigned long cid, gid;
1826 cairo_int_status_t status;
1827
1828 font->fdselect_subset = calloc (font->scaled_font_subset->num_glyphs,
1829 sizeof (int));
1830 if (unlikely (font->fdselect_subset == NULL))
1831 return _cairo_error (CAIRO_STATUS_NO_MEMORY);
1832
1833 font->fd_subset_map = calloc (font->num_fontdicts, sizeof (int));
1834 if (unlikely (font->fd_subset_map == NULL))
1835 return _cairo_error (CAIRO_STATUS_NO_MEMORY);
1836
1837 font->private_dict_offset = calloc (font->num_fontdicts, sizeof (int));
1838 if (unlikely (font->private_dict_offset == NULL))
1839 return _cairo_error (CAIRO_STATUS_NO_MEMORY);
1840
1841 reverse_map = calloc (font->num_fontdicts, sizeof (int));
1842 if (unlikely (reverse_map == NULL))
1843 return _cairo_error (CAIRO_STATUS_NO_MEMORY);
1844
1845 for (i = 0; i < font->num_fontdicts; i++)
1846 reverse_map[i] = -1;
1847
1848 font->num_subset_fontdicts = 0;
1849 for (i = 0; i < font->scaled_font_subset->num_glyphs; i++) {
1850 cid = font->scaled_font_subset->glyphs[i];
1851 status = cairo_cff_font_get_gid_for_cid (font, cid, &gid);
1852 if (unlikely (status)) {
1853 free (reverse_map);
1854 return status;
1855 }
1856
1857 fd = font->fdselect[gid];
1858 if (reverse_map[fd] < 0) {
1859 font->fd_subset_map[font->num_subset_fontdicts] = fd;
1860 reverse_map[fd] = font->num_subset_fontdicts++;
1861 }
1862 font->fdselect_subset[i] = reverse_map[fd];
1863 }
1864
1865 free (reverse_map);
1866
1867 return CAIRO_STATUS_SUCCESS;
1868 }
1869
1870 static cairo_status_t
1871 cairo_cff_font_create_cid_fontdict (cairo_cff_font_t *font)
1872 {
1873 unsigned char buf[100];
1874 unsigned char *end_buf;
1875 cairo_status_t status;
1876
1877 font->num_fontdicts = 1;
1878 font->fd_dict = malloc (sizeof (cairo_hash_table_t *));
1879 if (unlikely (font->fd_dict == NULL))
1880 return _cairo_error (CAIRO_STATUS_NO_MEMORY);
1881
1882 if (cff_dict_init (&font->fd_dict[0])) {
1883 free (font->fd_dict);
1884 font->fd_dict = NULL;
1885 font->num_fontdicts = 0;
1886 return _cairo_error (CAIRO_STATUS_NO_MEMORY);
1887 }
1888
1889 font->fd_subset_map = malloc (sizeof (int));
1890 if (unlikely (font->fd_subset_map == NULL))
1891 return _cairo_error (CAIRO_STATUS_NO_MEMORY);
1892
1893 font->private_dict_offset = malloc (sizeof (int));
1894 if (unlikely (font->private_dict_offset == NULL))
1895 return _cairo_error (CAIRO_STATUS_NO_MEMORY);
1896
1897 font->fd_subset_map[0] = 0;
1898 font->num_subset_fontdicts = 1;
1899
1900 /* Set integer operand to max value to use max size encoding to reserve
1901 * space for any value later */
1902 end_buf = encode_integer_max (buf, 0);
1903 end_buf = encode_integer_max (end_buf, 0);
1904 status = cff_dict_set_operands (font->fd_dict[0], PRIVATE_OP, buf, end_buf - buf);
1905 if (unlikely (status))
1906 return status;
1907
1908 return CAIRO_STATUS_SUCCESS;
1909 }
1910
1911 static cairo_status_t
1912 cairo_cff_font_subset_strings (cairo_cff_font_t *font)
1913 {
1914 cairo_status_t status;
1915 unsigned int i;
1916
1917 status = cairo_cff_font_subset_dict_strings (font, font->top_dict);
1918 if (unlikely (status))
1919 return status;
1920
1921 if (font->is_cid) {
1922 for (i = 0; i < font->num_subset_fontdicts; i++) {
1923 status = cairo_cff_font_subset_dict_strings (font, font->fd_dict[font->fd_subset_map[i]]);
1924 if (unlikely (status))
1925 return status;
1926
1927 status = cairo_cff_font_subset_dict_strings (font, font->fd_private_dict[font->fd_subset_map[i]]);
1928 if (unlikely (status))
1929 return status;
1930 }
1931 } else {
1932 status = cairo_cff_font_subset_dict_strings (font, font->private_dict);
1933 }
1934
1935 return status;
1936 }
1937
1938 /* The Euro is the only the only character in the winansi encoding
1939 * with a glyph name that is not a CFF standard string. As the strings
1940 * are written before the charset, we need to check during the
1941 * subsetting phase if the Euro glyph is required and add the
1942 * glyphname to the list of strings to write out.
1943 */
1944 static cairo_status_t
1945 cairo_cff_font_add_euro_charset_string (cairo_cff_font_t *font)
1946 {
1947 cairo_status_t status;
1948 unsigned int i;
1949 int ch;
1950 const char *euro = "Euro";
1951
1952 for (i = 1; i < font->scaled_font_subset->num_glyphs; i++) {
1953 ch = font->scaled_font_subset->to_latin_char[i];
1954 if (ch == 128) {
1955 font->euro_sid = NUM_STD_STRINGS + _cairo_array_num_elements (&font->strings_subset_index);
1956 status = cff_index_append_copy (&font->strings_subset_index,
1957 (unsigned char *)euro, strlen(euro));
1958 return status;
1959 }
1960 }
1961
1962 return CAIRO_STATUS_SUCCESS;
1963 }
1964
1965 static cairo_status_t
1966 cairo_cff_font_subset_font (cairo_cff_font_t *font)
1967 {
1968 cairo_status_t status;
1969
1970 if (!font->scaled_font_subset->is_latin) {
1971 status = cairo_cff_font_set_ros_strings (font);
1972 if (unlikely (status))
1973 return status;
1974 }
1975
1976 status = cairo_cff_font_subset_charstrings_and_subroutines (font);
1977 if (unlikely (status))
1978 return status;
1979
1980 if (!font->scaled_font_subset->is_latin) {
1981 if (font->is_cid)
1982 status = cairo_cff_font_subset_fontdict (font);
1983 else
1984 status = cairo_cff_font_create_cid_fontdict (font);
1985 if (unlikely (status))
1986 return status;
1987 } else {
1988 font->private_dict_offset = malloc (sizeof (int));
1989 if (unlikely (font->private_dict_offset == NULL))
1990 return _cairo_error (CAIRO_STATUS_NO_MEMORY);
1991 }
1992
1993 status = cairo_cff_font_subset_strings (font);
1994 if (unlikely (status))
1995 return status;
1996
1997 if (font->scaled_font_subset->is_latin)
1998 status = cairo_cff_font_add_euro_charset_string (font);
1999
2000 return status;
2001 }
2002
2003 /* Set the operand of the specified operator in the (already written)
2004 * top dict to point to the current position in the output
2005 * array. Operands updated with this function must have previously
2006 * been encoded with the 5-byte (max) integer encoding. */
2007 static void
2008 cairo_cff_font_set_topdict_operator_to_cur_pos (cairo_cff_font_t *font,
2009 int operator)
2010 {
2011 int cur_pos;
2012 int offset;
2013 int size;
2014 unsigned char buf[10];
2015 unsigned char *buf_end;
2016 unsigned char *op_ptr;
2017
2018 cur_pos = _cairo_array_num_elements (&font->output);
2019 buf_end = encode_integer_max (buf, cur_pos);
2020 offset = cff_dict_get_location (font->top_dict, operator, &size);
2021 assert (offset > 0);
2022 op_ptr = _cairo_array_index (&font->output, offset);
2023 memcpy (op_ptr, buf, buf_end - buf);
2024 }
2025
2026 static cairo_status_t
2027 cairo_cff_font_write_header (cairo_cff_font_t *font)
2028 {
2029 return _cairo_array_append_multiple (&font->output,
2030 font->header,
2031 font->header->header_size);
2032 }
2033
2034 static cairo_status_t
2035 cairo_cff_font_write_name (cairo_cff_font_t *font)
2036 {
2037 cairo_status_t status = CAIRO_STATUS_SUCCESS;
2038 cairo_array_t index;
2039
2040 cff_index_init (&index);
2041
2042 status = cff_index_append_copy (&index,
2043 (unsigned char *) font->ps_name,
2044 strlen(font->ps_name));
2045 if (unlikely (status))
2046 goto FAIL;
2047
2048 status = cff_index_write (&index, &font->output);
2049 if (unlikely (status))
2050 goto FAIL;
2051
2052 FAIL:
2053 cff_index_fini (&index);
2054
2055 return status;
2056 }
2057
2058 static cairo_status_t
2059 cairo_cff_font_write_top_dict (cairo_cff_font_t *font)
2060 {
2061 uint16_t count;
2062 unsigned char buf[10];
2063 unsigned char *p;
2064 int offset_index;
2065 int dict_start, dict_size;
2066 int offset_size = 4;
2067 cairo_status_t status;
2068
2069 /* Write an index containing the top dict */
2070
2071 count = cpu_to_be16 (1);
2072 status = _cairo_array_append_multiple (&font->output, &count, 2);
2073 if (unlikely (status))
2074 return status;
2075 buf[0] = offset_size;
2076 status = _cairo_array_append (&font->output, buf);
2077 if (unlikely (status))
2078 return status;
2079 encode_index_offset (buf, offset_size, 1);
2080 status = _cairo_array_append_multiple (&font->output, buf, offset_size);
2081 if (unlikely (status))
2082 return status;
2083
2084 /* Reserve space for last element of offset array and update after
2085 * dict is written */
2086 offset_index = _cairo_array_num_elements (&font->output);
2087 status = _cairo_array_append_multiple (&font->output, buf, offset_size);
2088 if (unlikely (status))
2089 return status;
2090
2091 dict_start = _cairo_array_num_elements (&font->output);
2092 status = cff_dict_write (font->top_dict, &font->output);
2093 if (unlikely (status))
2094 return status;
2095 dict_size = _cairo_array_num_elements (&font->output) - dict_start;
2096
2097 encode_index_offset (buf, offset_size, dict_size + 1);
2098 p = _cairo_array_index (&font->output, offset_index);
2099 memcpy (p, buf, offset_size);
2100
2101 return CAIRO_STATUS_SUCCESS;
2102 }
2103
2104 static cairo_status_t
2105 cairo_cff_font_write_strings (cairo_cff_font_t *font)
2106 {
2107 return cff_index_write (&font->strings_subset_index, &font->output);
2108 }
2109
2110 static cairo_status_t
2111 cairo_cff_font_write_global_subrs (cairo_cff_font_t *font)
2112 {
2113 unsigned int i;
2114 unsigned char return_op = TYPE2_return;
2115
2116 /* poppler and fontforge don't like zero length subroutines so we
2117 * replace unused subroutines with a 'return' instruction. */
2118 if (font->subset_subroutines) {
2119 for (i = 0; i < _cairo_array_num_elements (&font->global_sub_index); i++) {
2120 if (! font->global_subs_used[i])
2121 cff_index_set_object (&font->global_sub_index, i, &return_op, 1);
2122 }
2123 }
2124
2125 return cff_index_write (&font->global_sub_index, &font->output);
2126 }
2127
2128 static cairo_status_t
2129 cairo_cff_font_write_encoding (cairo_cff_font_t *font)
2130 {
2131 unsigned char buf[2];
2132 cairo_status_t status;
2133 unsigned int i;
2134
2135 cairo_cff_font_set_topdict_operator_to_cur_pos (font, ENCODING_OP);
2136 buf[0] = 0; /* Format 0 */
2137 buf[1] = font->scaled_font_subset->num_glyphs - 1;
2138 status = _cairo_array_append_multiple (&font->output, buf, 2);
2139 if (unlikely (status))
2140 return status;
2141
2142 for (i = 1; i < font->scaled_font_subset->num_glyphs; i++) {
2143 unsigned char ch = font->scaled_font_subset->to_latin_char[i];
2144 status = _cairo_array_append (&font->output, &ch);
2145 if (unlikely (status))
2146 return status;
2147 }
2148
2149 return CAIRO_STATUS_SUCCESS;
2150 }
2151
2152 static cairo_status_t
2153 cairo_cff_font_write_fdselect (cairo_cff_font_t *font)
2154 {
2155 unsigned char data;
2156 unsigned int i;
2157 cairo_int_status_t status;
2158
2159 cairo_cff_font_set_topdict_operator_to_cur_pos (font, FDSELECT_OP);
2160
2161 if (font->is_cid) {
2162 data = 0;
2163 status = _cairo_array_append (&font->output, &data);
2164 if (unlikely (status))
2165 return status;
2166
2167 for (i = 0; i < font->scaled_font_subset->num_glyphs; i++) {
2168 data = font->fdselect_subset[i];
2169 status = _cairo_array_append (&font->output, &data);
2170 if (unlikely (status))
2171 return status;
2172 }
2173 } else {
2174 unsigned char byte;
2175 uint16_t word;
2176
2177 status = _cairo_array_grow_by (&font->output, 9);
2178 if (unlikely (status))
2179 return status;
2180
2181 byte = 3;
2182 status = _cairo_array_append (&font->output, &byte);
2183 assert (status == CAIRO_INT_STATUS_SUCCESS);
2184
2185 word = cpu_to_be16 (1);
2186 status = _cairo_array_append_multiple (&font->output, &word, 2);
2187 assert (status == CAIRO_INT_STATUS_SUCCESS);
2188
2189 word = cpu_to_be16 (0);
2190 status = _cairo_array_append_multiple (&font->output, &word, 2);
2191 assert (status == CAIRO_INT_STATUS_SUCCESS);
2192
2193 byte = 0;
2194 status = _cairo_array_append (&font->output, &byte);
2195 assert (status == CAIRO_INT_STATUS_SUCCESS);
2196
2197 word = cpu_to_be16 (font->scaled_font_subset->num_glyphs);
2198 status = _cairo_array_append_multiple (&font->output, &word, 2);
2199 assert (status == CAIRO_INT_STATUS_SUCCESS);
2200 }
2201
2202 return CAIRO_STATUS_SUCCESS;
2203 }
2204
2205 /* Winansi to CFF standard strings mapping for characters 128 to 255 */
2206 static const int winansi_to_cff_std_string[] = {
2207 /* 128 */
2208 0, 0, 117, 101, 118, 121, 112, 113,
2209 126, 122, 192, 107, 142, 0, 199, 0,
2210 /* 144 */
2211 0, 65, 8, 105, 119, 116, 111, 137,
2212 127, 153, 221, 108, 148, 0, 228, 198,
2213 /* 160 */
2214 0, 96, 97, 98, 103, 100, 160, 102,
2215 131, 170, 139, 106, 151, 0, 165, 128,
2216 /* 176 */
2217 161, 156, 164, 169, 125, 152, 115, 114,
2218 133, 150, 143, 120, 158, 155, 163, 123,
2219 /* 192 */
2220 174, 171, 172, 176, 173, 175, 138, 177,
2221 181, 178, 179, 180, 185, 182, 183, 184,
2222 /* 208 */
2223 154, 186, 190, 187, 188, 191, 189, 168,
2224 141, 196, 193, 194, 195, 197, 157, 149,
2225 /* 224 */
2226 203, 200, 201, 205, 202, 204, 144, 206,
2227 210, 207, 208, 209, 214, 211, 212, 213,
2228 /* 240 */
2229 167, 215, 219, 216, 217, 220, 218, 159,
2230 147, 225, 222, 223, 224, 226, 162, 227,
2231 };
2232
2233 static int
2234 cairo_cff_font_get_sid_for_winansi_char (cairo_cff_font_t *font, int ch)
2235 {
2236 int sid;
2237
2238 if (ch == 39) {
2239 sid = 104;
2240
2241 } else if (ch == 96) {
2242 sid = 124;
2243
2244 } else if (ch >= 32 && ch <= 126) {
2245 sid = ch - 31;
2246
2247 } else if (ch == 128) {
2248 assert (font->euro_sid >= NUM_STD_STRINGS);
2249 sid = font->euro_sid;
2250
2251 } else if (ch >= 128 && ch <= 255) {
2252 sid = winansi_to_cff_std_string[ch - 128];
2253
2254 } else {
2255 sid = 0;
2256 }
2257
2258 return sid;
2259 }
2260
2261 static cairo_status_t
2262 cairo_cff_font_write_type1_charset (cairo_cff_font_t *font)
2263 {
2264 unsigned char format = 0;
2265 unsigned int i;
2266 int ch, sid;
2267 cairo_status_t status;
2268 uint16_t sid_be16;
2269
2270 cairo_cff_font_set_topdict_operator_to_cur_pos (font, CHARSET_OP);
2271 status = _cairo_array_append (&font->output, &format);
2272 if (unlikely (status))
2273 return status;
2274
2275 for (i = 1; i < font->scaled_font_subset->num_glyphs; i++) {
2276 ch = font->scaled_font_subset->to_latin_char[i];
2277 sid = cairo_cff_font_get_sid_for_winansi_char (font, ch);
2278 if (unlikely (status))
2279 return status;
2280
2281 sid_be16 = cpu_to_be16(sid);
2282 status = _cairo_array_append_multiple (&font->output, &sid_be16, sizeof(sid_be16));
2283 if (unlikely (status))
2284 return status;
2285 }
2286
2287 return CAIRO_STATUS_SUCCESS;
2288 }
2289
2290 static cairo_status_t
2291 cairo_cff_font_write_cid_charset (cairo_cff_font_t *font)
2292 {
2293 unsigned char byte;
2294 uint16_t word;
2295 cairo_status_t status;
2296
2297 cairo_cff_font_set_topdict_operator_to_cur_pos (font, CHARSET_OP);
2298 status = _cairo_array_grow_by (&font->output, 5);
2299 if (unlikely (status))
2300 return status;
2301
2302 byte = 2;
2303 status = _cairo_array_append (&font->output, &byte);
2304 assert (status == CAIRO_STATUS_SUCCESS);
2305
2306 word = cpu_to_be16 (1);
2307 status = _cairo_array_append_multiple (&font->output, &word, 2);
2308 assert (status == CAIRO_STATUS_SUCCESS);
2309
2310 word = cpu_to_be16 (font->scaled_font_subset->num_glyphs - 2);
2311 status = _cairo_array_append_multiple (&font->output, &word, 2);
2312 assert (status == CAIRO_STATUS_SUCCESS);
2313
2314 return CAIRO_STATUS_SUCCESS;
2315 }
2316
2317 static cairo_status_t
2318 cairo_cff_font_write_charstrings (cairo_cff_font_t *font)
2319 {
2320 cairo_cff_font_set_topdict_operator_to_cur_pos (font, CHARSTRINGS_OP);
2321
2322 return cff_index_write (&font->charstrings_subset_index, &font->output);
2323 }
2324
2325 static cairo_status_t
2326 cairo_cff_font_write_cid_fontdict (cairo_cff_font_t *font)
2327 {
2328 unsigned int i;
2329 cairo_int_status_t status;
2330 unsigned int offset_array;
2331 unsigned char *offset_array_ptr;
2332 int offset_base;
2333 uint16_t count;
2334 uint8_t offset_size = 4;
2335
2336 cairo_cff_font_set_topdict_operator_to_cur_pos (font, FDARRAY_OP);
2337 count = cpu_to_be16 (font->num_subset_fontdicts);
2338 status = _cairo_array_append_multiple (&font->output, &count, sizeof (uint16_t));
2339 if (unlikely (status))
2340 return status;
2341 status = _cairo_array_append (&font->output, &offset_size);
2342 if (unlikely (status))
2343 return status;
2344
2345 offset_array = _cairo_array_num_elements (&font->output);
2346 status = _cairo_array_allocate (&font->output,
2347 (font->num_subset_fontdicts + 1)*offset_size,
2348 (void **) &offset_array_ptr);
2349 if (unlikely (status))
2350 return status;
2351 offset_base = _cairo_array_num_elements (&font->output) - 1;
2352 put_unaligned_be32(1, offset_array_ptr);
2353 offset_array += sizeof(uint32_t);
2354 for (i = 0; i < font->num_subset_fontdicts; i++) {
2355 status = cff_dict_write (font->fd_dict[font->fd_subset_map[i]],
2356 &font->output);
2357 if (unlikely (status))
2358 return status;
2359
2360 offset_array_ptr = _cairo_array_index (&font->output, offset_array);
2361 put_unaligned_be32 (_cairo_array_num_elements (&font->output) - offset_base,
2362 offset_array_ptr);
2363 offset_array += sizeof(uint32_t);
2364 }
2365
2366 return CAIRO_STATUS_SUCCESS;
2367 }
2368
2369 static cairo_status_t
2370 cairo_cff_font_write_private_dict (cairo_cff_font_t *font,
2371 int dict_num,
2372 cairo_hash_table_t *parent_dict,
2373 cairo_hash_table_t *private_dict)
2374 {
2375 int offset;
2376 int size;
2377 unsigned char buf[10];
2378 unsigned char *buf_end;
2379 unsigned char *p;
2380 cairo_status_t status;
2381
2382 /* Write private dict and update offset and size in top dict */
2383 font->private_dict_offset[dict_num] = _cairo_array_num_elements (&font->output);
2384 status = cff_dict_write (private_dict, &font->output);
2385 if (unlikely (status))
2386 return status;
2387
2388 size = _cairo_array_num_elements (&font->output) - font->private_dict_offset[dict_num];
2389 /* private entry has two operands - size and offset */
2390 buf_end = encode_integer_max (buf, size);
2391 buf_end = encode_integer_max (buf_end, font->private_dict_offset[dict_num]);
2392 offset = cff_dict_get_location (parent_dict, PRIVATE_OP, &size);
2393 assert (offset > 0);
2394 p = _cairo_array_index (&font->output, offset);
2395 memcpy (p, buf, buf_end - buf);
2396
2397 return CAIRO_STATUS_SUCCESS;
2398 }
2399
2400 static cairo_status_t
2401 cairo_cff_font_write_local_sub (cairo_cff_font_t *font,
2402 int dict_num,
2403 cairo_hash_table_t *private_dict,
2404 cairo_array_t *local_sub_index,
2405 cairo_bool_t *local_subs_used)
2406 {
2407 int offset;
2408 int size;
2409 unsigned char buf[10];
2410 unsigned char *buf_end;
2411 unsigned char *p;
2412 cairo_status_t status;
2413 unsigned int i;
2414 unsigned char return_op = TYPE2_return;
2415
2416 if (_cairo_array_num_elements (local_sub_index) > 0) {
2417 /* Write local subroutines and update offset in private
2418 * dict. Local subroutines offset is relative to start of
2419 * private dict */
2420 offset = _cairo_array_num_elements (&font->output) - font->private_dict_offset[dict_num];
2421 buf_end = encode_integer_max (buf, offset);
2422 offset = cff_dict_get_location (private_dict, LOCAL_SUB_OP, &size);
2423 assert (offset > 0);
2424 p = _cairo_array_index (&font->output, offset);
2425 memcpy (p, buf, buf_end - buf);
2426
2427 /* poppler and fontforge don't like zero length subroutines so
2428 * we replace unused subroutines with a 'return' instruction.
2429 */
2430 if (font->subset_subroutines) {
2431 for (i = 0; i < _cairo_array_num_elements (local_sub_index); i++) {
2432 if (! local_subs_used[i])
2433 cff_index_set_object (local_sub_index, i, &return_op, 1);
2434 }
2435 }
2436 status = cff_index_write (local_sub_index, &font->output);
2437 if (unlikely (status))
2438 return status;
2439 }
2440
2441 return CAIRO_STATUS_SUCCESS;
2442 }
2443
2444
2445 static cairo_status_t
2446 cairo_cff_font_write_cid_private_dict_and_local_sub (cairo_cff_font_t *font)
2447 {
2448 unsigned int i;
2449 cairo_int_status_t status;
2450
2451 if (font->is_cid) {
2452 for (i = 0; i < font->num_subset_fontdicts; i++) {
2453 status = cairo_cff_font_write_private_dict (
2454 font,
2455 i,
2456 font->fd_dict[font->fd_subset_map[i]],
2457 font->fd_private_dict[font->fd_subset_map[i]]);
2458 if (unlikely (status))
2459 return status;
2460 }
2461
2462 for (i = 0; i < font->num_subset_fontdicts; i++) {
2463 status = cairo_cff_font_write_local_sub (
2464 font,
2465 i,
2466 font->fd_private_dict[font->fd_subset_map[i]],
2467 &font->fd_local_sub_index[font->fd_subset_map[i]],
2468 font->fd_local_subs_used[font->fd_subset_map[i]]);
2469 if (unlikely (status))
2470 return status;
2471 }
2472 } else {
2473 status = cairo_cff_font_write_private_dict (font,
2474 0,
2475 font->fd_dict[0],
2476 font->private_dict);
2477 if (unlikely (status))
2478 return status;
2479
2480 status = cairo_cff_font_write_local_sub (font,
2481 0,
2482 font->private_dict,
2483 &font->local_sub_index,
2484 font->local_subs_used);
2485 if (unlikely (status))
2486 return status;
2487 }
2488
2489 return CAIRO_STATUS_SUCCESS;
2490 }
2491
2492 static cairo_status_t
2493 cairo_cff_font_write_type1_private_dict_and_local_sub (cairo_cff_font_t *font)
2494 {
2495 cairo_int_status_t status;
2496
2497 status = cairo_cff_font_write_private_dict (font,
2498 0,
2499 font->top_dict,
2500 font->private_dict);
2501 if (unlikely (status))
2502 return status;
2503
2504 status = cairo_cff_font_write_local_sub (font,
2505 0,
2506 font->private_dict,
2507 &font->local_sub_index,
2508 font->local_subs_used);
2509 if (unlikely (status))
2510 return status;
2511
2512 return CAIRO_STATUS_SUCCESS;
2513 }
2514
2515
2516 typedef cairo_status_t
2517 (*font_write_t) (cairo_cff_font_t *font);
2518
2519 static const font_write_t font_write_cid_funcs[] = {
2520 cairo_cff_font_write_header,
2521 cairo_cff_font_write_name,
2522 cairo_cff_font_write_top_dict,
2523 cairo_cff_font_write_strings,
2524 cairo_cff_font_write_global_subrs,
2525 cairo_cff_font_write_cid_charset,
2526 cairo_cff_font_write_fdselect,
2527 cairo_cff_font_write_charstrings,
2528 cairo_cff_font_write_cid_fontdict,
2529 cairo_cff_font_write_cid_private_dict_and_local_sub,
2530 };
2531
2532 static const font_write_t font_write_type1_funcs[] = {
2533 cairo_cff_font_write_header,
2534 cairo_cff_font_write_name,
2535 cairo_cff_font_write_top_dict,
2536 cairo_cff_font_write_strings,
2537 cairo_cff_font_write_global_subrs,
2538 cairo_cff_font_write_encoding,
2539 cairo_cff_font_write_type1_charset,
2540 cairo_cff_font_write_charstrings,
2541 cairo_cff_font_write_type1_private_dict_and_local_sub,
2542 };
2543
2544 static cairo_status_t
2545 cairo_cff_font_write_subset (cairo_cff_font_t *font)
2546 {
2547 cairo_int_status_t status;
2548 unsigned int i;
2549
2550 if (font->scaled_font_subset->is_latin) {
2551 for (i = 0; i < ARRAY_LENGTH (font_write_type1_funcs); i++) {
2552 status = font_write_type1_funcs[i] (font);
2553 if (unlikely (status))
2554 return status;
2555 }
2556 } else {
2557 for (i = 0; i < ARRAY_LENGTH (font_write_cid_funcs); i++) {
2558 status = font_write_cid_funcs[i] (font);
2559 if (unlikely (status))
2560 return status;
2561 }
2562 }
2563
2564 return CAIRO_STATUS_SUCCESS;
2565 }
2566
2567 static cairo_int_status_t
2568 cairo_cff_font_generate (cairo_cff_font_t *font,
2569 const char **data,
2570 unsigned long *length)
2571 {
2572 cairo_int_status_t status;
2573
2574 status = cairo_cff_font_read_font (font);
2575 if (unlikely (status))
2576 return status;
2577
2578 /* If the PS name is not found, create a CairoFont-x-y name. */
2579 if (font->ps_name == NULL) {
2580 font->ps_name = malloc (30);
2581 if (unlikely (font->ps_name == NULL))
2582 return _cairo_error (CAIRO_STATUS_NO_MEMORY);
2583
2584 snprintf(font->ps_name, 30, "CairoFont-%u-%u",
2585 font->scaled_font_subset->font_id,
2586 font->scaled_font_subset->subset_id);
2587 }
2588
2589 status = cairo_cff_font_subset_font (font);
2590 if (unlikely (status))
2591 return status;
2592
2593 status = cairo_cff_font_write_subset (font);
2594 if (unlikely (status))
2595 return status;
2596
2597
2598 *data = _cairo_array_index (&font->output, 0);
2599 *length = _cairo_array_num_elements (&font->output);
2600
2601 return CAIRO_STATUS_SUCCESS;
2602 }
2603
2604 static cairo_int_status_t
2605 cairo_cff_font_create_set_widths (cairo_cff_font_t *font)
2606 {
2607 unsigned long size;
2608 unsigned long long_entry_size;
2609 unsigned long short_entry_size;
2610 unsigned int i;
2611 tt_hhea_t hhea;
2612 int num_hmetrics;
2613 uint16_t short_entry;
2614 int glyph_index;
2615 cairo_int_status_t status;
2616
2617 size = sizeof (tt_hhea_t);
2618 status = font->backend->load_truetype_table (font->scaled_font_subset->scaled_font,
2619 TT_TAG_hhea, 0,
2620 (unsigned char*) &hhea, &size);
2621 if (unlikely (status))
2622 return status;
2623 num_hmetrics = be16_to_cpu (hhea.num_hmetrics);
2624
2625 for (i = 0; i < font->scaled_font_subset->num_glyphs; i++) {
2626 glyph_index = font->scaled_font_subset->glyphs[i];
2627 long_entry_size = 2 * sizeof (int16_t);
2628 short_entry_size = sizeof (int16_t);
2629 if (glyph_index < num_hmetrics) {
2630 status = font->backend->load_truetype_table (font->scaled_font_subset->scaled_font,
2631 TT_TAG_hmtx,
2632 glyph_index * long_entry_size,
2633 (unsigned char *) &short_entry,
2634 &short_entry_size);
2635 if (unlikely (status))
2636 return status;
2637 }
2638 else
2639 {
2640 status = font->backend->load_truetype_table (font->scaled_font_subset->scaled_font,
2641 TT_TAG_hmtx,
2642 (num_hmetrics - 1) * long_entry_size,
2643 (unsigned char *) &short_entry,
2644 &short_entry_size);
2645 if (unlikely (status))
2646 return status;
2647 }
2648 font->widths[i] = be16_to_cpu (short_entry);
2649 }
2650
2651 return CAIRO_STATUS_SUCCESS;
2652 }
2653
2654 static cairo_bool_t
2655 check_fontdata_is_cff (const unsigned char *data, long length)
2656 {
2657 cff_header_t *header;
2658
2659 if (length < (long)sizeof (cff_header_t))
2660 return FALSE;
2661
2662 header = (cff_header_t *) data;
2663 if (header->major == 1 &&
2664 header->minor == 0 &&
2665 header->header_size == 4)
2666 {
2667 return TRUE;
2668 }
2669
2670 return FALSE;
2671 }
2672
2673 static cairo_int_status_t
2674 _cairo_cff_font_load_opentype_cff (cairo_cff_font_t *font)
2675 {
2676 const cairo_scaled_font_backend_t *backend = font->backend;
2677 cairo_status_t status;
2678 tt_head_t head;
2679 tt_hhea_t hhea;
2680 unsigned long size, data_length;
2681
2682 if (!backend->load_truetype_table)
2683 return CAIRO_INT_STATUS_UNSUPPORTED;
2684
2685 data_length = 0;
2686 status = backend->load_truetype_table (font->scaled_font_subset->scaled_font,
2687 TT_TAG_CFF, 0, NULL, &data_length);
2688 if (status)
2689 return status;
2690
2691 size = sizeof (tt_head_t);
2692 status = backend->load_truetype_table (font->scaled_font_subset->scaled_font,
2693 TT_TAG_head, 0,
2694 (unsigned char *) &head, &size);
2695 if (unlikely (status))
2696 return status;
2697
2698 size = sizeof (tt_hhea_t);
2699 status = backend->load_truetype_table (font->scaled_font_subset->scaled_font,
2700 TT_TAG_hhea, 0,
2701 (unsigned char *) &hhea, &size);
2702 if (unlikely (status))
2703 return status;
2704
2705 size = 0;
2706 status = backend->load_truetype_table (font->scaled_font_subset->scaled_font,
2707 TT_TAG_hmtx, 0, NULL, &size);
2708 if (unlikely (status))
2709 return status;
2710
2711 font->x_min = (int16_t) be16_to_cpu (head.x_min);
2712 font->y_min = (int16_t) be16_to_cpu (head.y_min);
2713 font->x_max = (int16_t) be16_to_cpu (head.x_max);
2714 font->y_max = (int16_t) be16_to_cpu (head.y_max);
2715 font->ascent = (int16_t) be16_to_cpu (hhea.ascender);
2716 font->descent = (int16_t) be16_to_cpu (hhea.descender);
2717 font->units_per_em = (int16_t) be16_to_cpu (head.units_per_em);
2718 if (font->units_per_em == 0)
2719 font->units_per_em = 1000;
2720
2721 font->font_name = NULL;
2722 status = _cairo_truetype_read_font_name (font->scaled_font_subset->scaled_font,
2723 &font->ps_name,
2724 &font->font_name);
2725 if (_cairo_status_is_error (status))
2726 return status;
2727
2728 font->is_opentype = TRUE;
2729 font->data_length = data_length;
2730 font->data = malloc (data_length);
2731 if (unlikely (font->data == NULL))
2732 return _cairo_error (CAIRO_STATUS_NO_MEMORY);
2733
2734 status = font->backend->load_truetype_table (font->scaled_font_subset->scaled_font,
2735 TT_TAG_CFF, 0, font->data,
2736 &font->data_length);
2737 if (unlikely (status))
2738 return status;
2739
2740 if (!check_fontdata_is_cff (font->data, data_length))
2741 return CAIRO_INT_STATUS_UNSUPPORTED;
2742
2743 return CAIRO_STATUS_SUCCESS;
2744 }
2745
2746 static cairo_int_status_t
2747 _cairo_cff_font_load_cff (cairo_cff_font_t *font)
2748 {
2749 const cairo_scaled_font_backend_t *backend = font->backend;
2750 cairo_status_t status;
2751 unsigned long data_length;
2752
2753 if (!backend->load_type1_data)
2754 return CAIRO_INT_STATUS_UNSUPPORTED;
2755
2756 data_length = 0;
2757 status = backend->load_type1_data (font->scaled_font_subset->scaled_font,
2758 0, NULL, &data_length);
2759 if (unlikely (status))
2760 return status;
2761
2762 font->font_name = NULL;
2763 font->is_opentype = FALSE;
2764 font->data_length = data_length;
2765 font->data = malloc (data_length);
2766 if (unlikely (font->data == NULL))
2767 return _cairo_error (CAIRO_STATUS_NO_MEMORY);
2768
2769 status = font->backend->load_type1_data (font->scaled_font_subset->scaled_font,
2770 0, font->data, &font->data_length);
2771 if (unlikely (status))
2772 return status;
2773
2774 if (!check_fontdata_is_cff (font->data, data_length))
2775 return CAIRO_INT_STATUS_UNSUPPORTED;
2776
2777 return CAIRO_STATUS_SUCCESS;
2778 }
2779
2780 static cairo_int_status_t
2781 _cairo_cff_font_create (cairo_scaled_font_subset_t *scaled_font_subset,
2782 cairo_cff_font_t **font_return,
2783 const char *subset_name)
2784 {
2785 const cairo_scaled_font_backend_t *backend;
2786 cairo_int_status_t status;
2787 cairo_cff_font_t *font;
2788
2789 backend = scaled_font_subset->scaled_font->backend;
2790
2791 /* We need to use a fallback font generated from the synthesized outlines. */
2792 if (backend->is_synthetic && backend->is_synthetic (scaled_font_subset->scaled_font))
2793 return CAIRO_INT_STATUS_UNSUPPORTED;
2794
2795 font = calloc (1, sizeof (cairo_cff_font_t));
2796 if (unlikely (font == NULL))
2797 return _cairo_error (CAIRO_STATUS_NO_MEMORY);
2798
2799 font->backend = backend;
2800 font->scaled_font_subset = scaled_font_subset;
2801
2802 status = _cairo_cff_font_load_opentype_cff (font);
2803 if (status == CAIRO_INT_STATUS_UNSUPPORTED)
2804 status = _cairo_cff_font_load_cff (font);
2805 if (status)
2806 goto fail1;
2807
2808 font->data_end = font->data + font->data_length;
2809 _cairo_array_init (&font->output, sizeof (char));
2810 status = _cairo_array_grow_by (&font->output, 4096);
2811 if (unlikely (status))
2812 goto fail2;
2813
2814 font->subset_font_name = strdup (subset_name);
2815 if (unlikely (font->subset_font_name == NULL)) {
2816 status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
2817 goto fail2;
2818 }
2819
2820 font->widths = calloc (font->scaled_font_subset->num_glyphs, sizeof (int));
2821 if (unlikely (font->widths == NULL)) {
2822 status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
2823 goto fail3;
2824 }
2825
2826 if (font->is_opentype) {
2827 status = cairo_cff_font_create_set_widths (font);
2828 if (unlikely (status))
2829 goto fail4;
2830 }
2831
2832 status = cff_dict_init (&font->top_dict);
2833 if (unlikely (status))
2834 goto fail4;
2835
2836 status = cff_dict_init (&font->private_dict);
2837 if (unlikely (status))
2838 goto fail5;
2839
2840 cff_index_init (&font->strings_index);
2841 cff_index_init (&font->charstrings_index);
2842 cff_index_init (&font->global_sub_index);
2843 cff_index_init (&font->local_sub_index);
2844 cff_index_init (&font->charstrings_subset_index);
2845 cff_index_init (&font->strings_subset_index);
2846 font->euro_sid = 0;
2847 font->fdselect = NULL;
2848 font->fd_dict = NULL;
2849 font->fd_private_dict = NULL;
2850 font->fd_local_sub_index = NULL;
2851 font->fd_local_sub_bias = NULL;
2852 font->fdselect_subset = NULL;
2853 font->fd_subset_map = NULL;
2854 font->private_dict_offset = NULL;
2855 font->global_subs_used = NULL;
2856 font->local_subs_used = NULL;
2857 font->fd_local_subs_used = NULL;
2858
2859 *font_return = font;
2860
2861 return CAIRO_STATUS_SUCCESS;
2862
2863 fail5:
2864 _cairo_hash_table_destroy (font->top_dict);
2865 fail4:
2866 free (font->widths);
2867 fail3:
2868 free (font->subset_font_name);
2869 fail2:
2870 free (font->ps_name);
2871 _cairo_array_fini (&font->output);
2872 fail1:
2873 free (font->data);
2874 free (font->font_name);
2875 free (font);
2876
2877 return status;
2878 }
2879
2880 static void
2881 cairo_cff_font_destroy (cairo_cff_font_t *font)
2882 {
2883 unsigned int i;
2884
2885 free (font->widths);
2886 free (font->font_name);
2887 free (font->ps_name);
2888 free (font->subset_font_name);
2889 _cairo_array_fini (&font->output);
2890 cff_dict_fini (font->top_dict);
2891 cff_dict_fini (font->private_dict);
2892 cff_index_fini (&font->strings_index);
2893 cff_index_fini (&font->charstrings_index);
2894 cff_index_fini (&font->global_sub_index);
2895 cff_index_fini (&font->local_sub_index);
2896 cff_index_fini (&font->charstrings_subset_index);
2897 cff_index_fini (&font->strings_subset_index);
2898
2899 /* If we bailed out early as a result of an error some of the
2900 * following cairo_cff_font_t members may still be NULL */
2901 if (font->fd_dict) {
2902 for (i = 0; i < font->num_fontdicts; i++) {
2903 if (font->fd_dict[i])
2904 cff_dict_fini (font->fd_dict[i]);
2905 }
2906 free (font->fd_dict);
2907 }
2908 free (font->global_subs_used);
2909 free (font->local_subs_used);
2910 free (font->fd_subset_map);
2911 free (font->private_dict_offset);
2912
2913 if (font->is_cid) {
2914 free (font->fdselect);
2915 free (font->fdselect_subset);
2916 if (font->fd_private_dict) {
2917 for (i = 0; i < font->num_fontdicts; i++) {
2918 if (font->fd_private_dict[i])
2919 cff_dict_fini (font->fd_private_dict[i]);
2920 }
2921 free (font->fd_private_dict);
2922 }
2923 if (font->fd_local_sub_index) {
2924 for (i = 0; i < font->num_fontdicts; i++)
2925 cff_index_fini (&font->fd_local_sub_index[i]);
2926 free (font->fd_local_sub_index);
2927 }
2928 free (font->fd_local_sub_bias);
2929 if (font->fd_local_subs_used) {
2930 for (i = 0; i < font->num_fontdicts; i++) {
2931 free (font->fd_local_subs_used[i]);
2932 }
2933 free (font->fd_local_subs_used);
2934 }
2935 free (font->fd_default_width);
2936 free (font->fd_nominal_width);
2937 }
2938
2939 free (font->data);
2940
2941 free (font);
2942 }
2943
2944 cairo_status_t
2945 _cairo_cff_subset_init (cairo_cff_subset_t *cff_subset,
2946 const char *subset_name,
2947 cairo_scaled_font_subset_t *font_subset)
2948 {
2949 cairo_cff_font_t *font = NULL; /* squelch bogus compiler warning */
2950 cairo_status_t status;
2951 const char *data = NULL; /* squelch bogus compiler warning */
2952 unsigned long length = 0; /* squelch bogus compiler warning */
2953 unsigned int i;
2954
2955 status = _cairo_cff_font_create (font_subset, &font, subset_name);
2956 if (unlikely (status))
2957 return status;
2958
2959 status = cairo_cff_font_generate (font, &data, &length);
2960 if (unlikely (status))
2961 goto fail1;
2962
2963 cff_subset->ps_name = strdup (font->ps_name);
2964 if (unlikely (cff_subset->ps_name == NULL)) {
2965 status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
2966 goto fail1;
2967 }
2968
2969 if (font->font_name) {
2970 cff_subset->family_name_utf8 = strdup (font->font_name);
2971 if (cff_subset->family_name_utf8 == NULL) {
2972 status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
2973 goto fail2;
2974 }
2975 } else {
2976 cff_subset->family_name_utf8 = NULL;
2977 }
2978
2979 cff_subset->widths = calloc (sizeof (double), font->scaled_font_subset->num_glyphs);
2980 if (unlikely (cff_subset->widths == NULL)) {
2981 status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
2982 goto fail3;
2983 }
2984 for (i = 0; i < font->scaled_font_subset->num_glyphs; i++)
2985 cff_subset->widths[i] = (double)font->widths[i]/font->units_per_em;
2986
2987 cff_subset->x_min = (double)font->x_min/font->units_per_em;
2988 cff_subset->y_min = (double)font->y_min/font->units_per_em;
2989 cff_subset->x_max = (double)font->x_max/font->units_per_em;
2990 cff_subset->y_max = (double)font->y_max/font->units_per_em;
2991 cff_subset->ascent = (double)font->ascent/font->units_per_em;
2992 cff_subset->descent = (double)font->descent/font->units_per_em;
2993
2994 cff_subset->data = malloc (length);
2995 if (unlikely (cff_subset->data == NULL)) {
2996 status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
2997 goto fail4;
2998 }
2999
3000 memcpy (cff_subset->data, data, length);
3001 cff_subset->data_length = length;
3002
3003 cairo_cff_font_destroy (font);
3004
3005 return CAIRO_STATUS_SUCCESS;
3006
3007 fail4:
3008 free (cff_subset->widths);
3009 fail3:
3010 free (cff_subset->family_name_utf8);
3011 fail2:
3012 free (cff_subset->ps_name);
3013 fail1:
3014 cairo_cff_font_destroy (font);
3015
3016 return status;
3017 }
3018
3019 void
3020 _cairo_cff_subset_fini (cairo_cff_subset_t *subset)
3021 {
3022 free (subset->ps_name);
3023 free (subset->family_name_utf8);
3024 free (subset->widths);
3025 free (subset->data);
3026 }
3027
3028 cairo_bool_t
3029 _cairo_cff_scaled_font_is_cid_cff (cairo_scaled_font_t *scaled_font)
3030 {
3031 const cairo_scaled_font_backend_t *backend;
3032 cairo_int_status_t status;
3033 unsigned char *data;
3034 unsigned long data_length;
3035 unsigned char *current_ptr;
3036 unsigned char *data_end;
3037 cff_header_t *header;
3038 cff_index_element_t *element;
3039 cairo_hash_table_t *top_dict;
3040 cairo_array_t index;
3041 int size;
3042 cairo_bool_t is_cid = FALSE;
3043
3044 backend = scaled_font->backend;
3045 data = NULL;
3046 data_length = 0;
3047 status = CAIRO_INT_STATUS_UNSUPPORTED;
3048 /* Try to load an OpenType/CFF font */
3049 if (backend->load_truetype_table &&
3050 (status = backend->load_truetype_table (scaled_font, TT_TAG_CFF,
3051 0, NULL, &data_length)) == CAIRO_INT_STATUS_SUCCESS)
3052 {
3053 data = malloc (data_length);
3054 if (unlikely (data == NULL)) {
3055 status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
3056 return FALSE;
3057 }
3058
3059 status = backend->load_truetype_table (scaled_font, TT_TAG_CFF,
3060 0, data, &data_length);
3061 if (unlikely (status))
3062 goto fail1;
3063 }
3064 /* Try to load a CFF font */
3065 if (status == CAIRO_INT_STATUS_UNSUPPORTED &&
3066 backend->load_type1_data &&
3067 (status = backend->load_type1_data (scaled_font,
3068 0, NULL, &data_length)) == CAIRO_INT_STATUS_SUCCESS)
3069 {
3070 data = malloc (data_length);
3071 if (unlikely (data == NULL)) {
3072 status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
3073 return FALSE;
3074 }
3075
3076 status = backend->load_type1_data (scaled_font, 0, data, &data_length);
3077 if (unlikely (status))
3078 goto fail1;
3079 }
3080 if (status)
3081 goto fail1;
3082
3083 /* Check if it looks like a CFF font */
3084 if (!check_fontdata_is_cff (data, data_length))
3085 goto fail1;
3086
3087 data_end = data + data_length;
3088
3089 /* skip header */
3090 if (data_length < sizeof (cff_header_t))
3091 goto fail1;
3092
3093 header = (cff_header_t *) data;
3094 current_ptr = data + header->header_size;
3095
3096 /* skip name */
3097 cff_index_init (&index);
3098 status = cff_index_read (&index, &current_ptr, data_end);
3099 cff_index_fini (&index);
3100
3101 if (status)
3102 goto fail1;
3103
3104 /* read top dict */
3105 cff_index_init (&index);
3106 status = cff_index_read (&index, &current_ptr, data_end);
3107 if (unlikely (status))
3108 goto fail2;
3109
3110 status = cff_dict_init (&top_dict);
3111 if (unlikely (status))
3112 goto fail2;
3113
3114 element = _cairo_array_index (&index, 0);
3115 status = cff_dict_read (top_dict, element->data, element->length);
3116 if (unlikely (status))
3117 goto fail3;
3118
3119 /* check for ROS operator indicating a CID font */
3120 if (cff_dict_get_operands (top_dict, ROS_OP, &size) != NULL)
3121 is_cid = TRUE;
3122
3123 fail3:
3124 cff_dict_fini (top_dict);
3125
3126 fail2:
3127 cff_index_fini (&index);
3128
3129 fail1:
3130 free (data);
3131
3132 return is_cid;
3133 }
3134
3135 static cairo_int_status_t
3136 _cairo_cff_font_fallback_create (cairo_scaled_font_subset_t *scaled_font_subset,
3137 cairo_cff_font_t **font_return,
3138 const char *subset_name)
3139 {
3140 cairo_status_t status;
3141 cairo_cff_font_t *font;
3142
3143 font = malloc (sizeof (cairo_cff_font_t));
3144 if (unlikely (font == NULL))
3145 return _cairo_error (CAIRO_STATUS_NO_MEMORY);
3146
3147 font->backend = NULL;
3148 font->scaled_font_subset = scaled_font_subset;
3149
3150 _cairo_array_init (&font->output, sizeof (char));
3151 status = _cairo_array_grow_by (&font->output, 4096);
3152 if (unlikely (status))
3153 goto fail1;
3154
3155 font->subset_font_name = strdup (subset_name);
3156 if (unlikely (font->subset_font_name == NULL)) {
3157 status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
3158 goto fail1;
3159 }
3160
3161 font->ps_name = strdup (subset_name);
3162 if (unlikely (font->ps_name == NULL)) {
3163 status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
3164 goto fail2;
3165 }
3166 font->font_name = NULL;
3167
3168 font->x_min = 0;
3169 font->y_min = 0;
3170 font->x_max = 0;
3171 font->y_max = 0;
3172 font->ascent = 0;
3173 font->descent = 0;
3174
3175 font->widths = calloc (font->scaled_font_subset->num_glyphs, sizeof (int));
3176 if (unlikely (font->widths == NULL)) {
3177 status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
3178 goto fail3;
3179 }
3180
3181 font->data_length = 0;
3182 font->data = NULL;
3183 font->data_end = NULL;
3184
3185 status = cff_dict_init (&font->top_dict);
3186 if (unlikely (status))
3187 goto fail4;
3188
3189 status = cff_dict_init (&font->private_dict);
3190 if (unlikely (status))
3191 goto fail5;
3192
3193 cff_index_init (&font->strings_index);
3194 cff_index_init (&font->charstrings_index);
3195 cff_index_init (&font->global_sub_index);
3196 cff_index_init (&font->local_sub_index);
3197 cff_index_init (&font->charstrings_subset_index);
3198 cff_index_init (&font->strings_subset_index);
3199 font->global_subs_used = NULL;
3200 font->local_subs_used = NULL;
3201 font->subset_subroutines = FALSE;
3202 font->fdselect = NULL;
3203 font->fd_dict = NULL;
3204 font->fd_private_dict = NULL;
3205 font->fd_local_sub_index = NULL;
3206 font->fdselect_subset = NULL;
3207 font->fd_subset_map = NULL;
3208 font->private_dict_offset = NULL;
3209
3210 *font_return = font;
3211
3212 return CAIRO_STATUS_SUCCESS;
3213
3214 fail5:
3215 _cairo_hash_table_destroy (font->top_dict);
3216 fail4:
3217 free (font->widths);
3218 fail3:
3219 free (font->font_name);
3220 free (font->ps_name);
3221 fail2:
3222 free (font->subset_font_name);
3223 fail1:
3224 _cairo_array_fini (&font->output);
3225 free (font);
3226 return status;
3227 }
3228
3229 static cairo_int_status_t
3230 cairo_cff_font_fallback_generate (cairo_cff_font_t *font,
3231 cairo_type2_charstrings_t *type2_subset,
3232 const char **data,
3233 unsigned long *length)
3234 {
3235 cairo_int_status_t status;
3236 cff_header_t header;
3237 cairo_array_t *charstring;
3238 unsigned char buf[40];
3239 unsigned char *end_buf, *end_buf2;
3240 unsigned int i;
3241 int sid;
3242
3243 /* Create header */
3244 header.major = 1;
3245 header.minor = 0;
3246 header.header_size = 4;
3247 header.offset_size = 4;
3248 font->header = &header;
3249
3250 /* Create Top Dict */
3251 font->is_cid = FALSE;
3252
3253 snprintf((char*)buf, sizeof(buf), "CairoFont-%u-%u",
3254 font->scaled_font_subset->font_id,
3255 font->scaled_font_subset->subset_id);
3256 sid = NUM_STD_STRINGS + _cairo_array_num_elements (&font->strings_subset_index);
3257 status = cff_index_append_copy (&font->strings_subset_index,
3258 (unsigned char *)buf,
3259 strlen((char*)buf));
3260 if (unlikely (status))
3261 return status;
3262
3263 end_buf = encode_integer (buf, sid);
3264 status = cff_dict_set_operands (font->top_dict, FULLNAME_OP,
3265 buf, end_buf - buf);
3266 if (unlikely (status))
3267 return status;
3268
3269 status = cff_dict_set_operands (font->top_dict, FAMILYNAME_OP,
3270 buf, end_buf - buf);
3271 if (unlikely (status))
3272 return status;
3273
3274 end_buf = encode_integer (buf, type2_subset->x_min);
3275 end_buf = encode_integer (end_buf, type2_subset->y_min);
3276 end_buf = encode_integer (end_buf, type2_subset->x_max);
3277 end_buf = encode_integer (end_buf, type2_subset->y_max);
3278 status = cff_dict_set_operands (font->top_dict,
3279 FONTBBOX_OP, buf, end_buf - buf);
3280 if (unlikely (status))
3281 return status;
3282
3283 end_buf = encode_integer_max (buf, 0);
3284 status = cff_dict_set_operands (font->top_dict,
3285 CHARSTRINGS_OP, buf, end_buf - buf);
3286 if (unlikely (status))
3287 return status;
3288
3289
3290 if (font->scaled_font_subset->is_latin) {
3291 status = cff_dict_set_operands (font->top_dict,
3292 ENCODING_OP, buf, end_buf - buf);
3293 if (unlikely (status))
3294 return status;
3295
3296 /* Private has two operands - size and offset */
3297 end_buf2 = encode_integer_max (end_buf, 0);
3298 cff_dict_set_operands (font->top_dict, PRIVATE_OP, buf, end_buf2 - buf);
3299 if (unlikely (status))
3300 return status;
3301
3302 } else {
3303 status = cff_dict_set_operands (font->top_dict,
3304 FDSELECT_OP, buf, end_buf - buf);
3305 if (unlikely (status))
3306 return status;
3307
3308 status = cff_dict_set_operands (font->top_dict,
3309 FDARRAY_OP, buf, end_buf - buf);
3310 if (unlikely (status))
3311 return status;
3312 }
3313
3314 status = cff_dict_set_operands (font->top_dict,
3315 CHARSET_OP, buf, end_buf - buf);
3316 if (unlikely (status))
3317 return status;
3318
3319 if (!font->scaled_font_subset->is_latin) {
3320 status = cairo_cff_font_set_ros_strings (font);
3321 if (unlikely (status))
3322 return status;
3323
3324 /* Create CID FD dictionary */
3325 status = cairo_cff_font_create_cid_fontdict (font);
3326 if (unlikely (status))
3327 return status;
3328 } else {
3329 font->private_dict_offset = malloc (sizeof (int));
3330 if (unlikely (font->private_dict_offset == NULL))
3331 return _cairo_error (CAIRO_STATUS_NO_MEMORY);
3332 }
3333
3334 /* Create charstrings */
3335 for (i = 0; i < font->scaled_font_subset->num_glyphs; i++) {
3336 charstring = _cairo_array_index(&type2_subset->charstrings, i);
3337
3338 status = cff_index_append (&font->charstrings_subset_index,
3339 _cairo_array_index (charstring, 0),
3340 _cairo_array_num_elements (charstring));
3341
3342 if (unlikely (status))
3343 return status;
3344 }
3345
3346 if (font->scaled_font_subset->is_latin)
3347 status = cairo_cff_font_add_euro_charset_string (font);
3348
3349 status = cairo_cff_font_write_subset (font);
3350 if (unlikely (status))
3351 return status;
3352
3353 *data = _cairo_array_index (&font->output, 0);
3354 *length = _cairo_array_num_elements (&font->output);
3355
3356 return CAIRO_STATUS_SUCCESS;
3357 }
3358
3359 cairo_status_t
3360 _cairo_cff_fallback_init (cairo_cff_subset_t *cff_subset,
3361 const char *subset_name,
3362 cairo_scaled_font_subset_t *font_subset)
3363 {
3364 cairo_cff_font_t *font = NULL; /* squelch bogus compiler warning */
3365 cairo_status_t status;
3366 const char *data = NULL; /* squelch bogus compiler warning */
3367 unsigned long length = 0; /* squelch bogus compiler warning */
3368 unsigned int i;
3369 cairo_type2_charstrings_t type2_subset;
3370
3371 status = _cairo_cff_font_fallback_create (font_subset, &font, subset_name);
3372 if (unlikely (status))
3373 return status;
3374
3375 status = _cairo_type2_charstrings_init (&type2_subset, font_subset);
3376 if (unlikely (status))
3377 goto fail1;
3378
3379 status = cairo_cff_font_fallback_generate (font, &type2_subset, &data, &length);
3380 if (unlikely (status))
3381 goto fail2;
3382
3383 cff_subset->family_name_utf8 = NULL;
3384 cff_subset->ps_name = strdup (font->ps_name);
3385 if (unlikely (cff_subset->ps_name == NULL)) {
3386 status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
3387 goto fail2;
3388 }
3389
3390 cff_subset->widths = calloc (sizeof (double), font->scaled_font_subset->num_glyphs);
3391 if (unlikely (cff_subset->widths == NULL)) {
3392 status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
3393 goto fail3;
3394 }
3395
3396 for (i = 0; i < font->scaled_font_subset->num_glyphs; i++)
3397 cff_subset->widths[i] = (double)type2_subset.widths[i]/1000;
3398
3399 cff_subset->x_min = (double)type2_subset.x_min/1000;
3400 cff_subset->y_min = (double)type2_subset.y_min/1000;
3401 cff_subset->x_max = (double)type2_subset.x_max/1000;
3402 cff_subset->y_max = (double)type2_subset.y_max/1000;
3403 cff_subset->ascent = (double)type2_subset.y_max/1000;
3404 cff_subset->descent = (double)type2_subset.y_min/1000;
3405
3406 cff_subset->data = malloc (length);
3407 if (unlikely (cff_subset->data == NULL)) {
3408 status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
3409 goto fail4;
3410 }
3411
3412 memcpy (cff_subset->data, data, length);
3413 cff_subset->data_length = length;
3414
3415 _cairo_type2_charstrings_fini (&type2_subset);
3416 cairo_cff_font_destroy (font);
3417
3418 return CAIRO_STATUS_SUCCESS;
3419
3420 fail4:
3421 free (cff_subset->widths);
3422 fail3:
3423 free (cff_subset->ps_name);
3424 fail2:
3425 _cairo_type2_charstrings_fini (&type2_subset);
3426 fail1:
3427 cairo_cff_font_destroy (font);
3428
3429 return status;
3430 }
3431
3432 void
3433 _cairo_cff_fallback_fini (cairo_cff_subset_t *subset)
3434 {
3435 free (subset->ps_name);
3436 free (subset->widths);
3437 free (subset->data);
3438 }
3439
3440 #endif /* CAIRO_HAS_FONT_SUBSET */
LuaTeX git mirror