1 /* cairo - a vector graphics library with display and print output
3 * Copyright © 2006 Red Hat, Inc
5 * This library is free software; you can redistribute it and/or
6 * modify it either under the terms of the GNU Lesser General Public
7 * License version 2.1 as published by the Free Software Foundation
8 * (the "LGPL") or, at your option, under the terms of the Mozilla
9 * Public License Version 1.1 (the "MPL"). If you do not alter this
10 * notice, a recipient may use your version of this file under either
11 * the MPL or the LGPL.
13 * You should have received a copy of the LGPL along with this library
14 * in the file COPYING-LGPL-2.1; if not, write to the Free Software
15 * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA
16 * You should have received a copy of the MPL along with this library
17 * in the file COPYING-MPL-1.1
19 * The contents of this file are subject to the Mozilla Public License
20 * Version 1.1 (the "License"); you may not use this file except in
21 * compliance with the License. You may obtain a copy of the License at
22 * http://www.mozilla.org/MPL/
24 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
25 * OF ANY KIND, either express or implied. See the LGPL or the MPL for
26 * the specific language governing rights and limitations.
28 * The Original Code is the cairo graphics library.
30 * The Initial Developer of the Original Code is Red Hat, Inc.
33 * Adrian Johnson <ajohnson@redneon.com>
36 #define _BSD_SOURCE /* for snprintf(), strdup() */
39 #include "cairo-array-private.h"
40 #include "cairo-error-private.h"
42 #if CAIRO_HAS_FONT_SUBSET
44 #include "cairo-type1-private.h"
45 #include "cairo-scaled-font-subsets-private.h"
46 #include "cairo-path-fixed-private.h"
47 #include "cairo-output-stream-private.h"
50 CAIRO_CHARSTRING_TYPE1,
51 CAIRO_CHARSTRING_TYPE2
52 } cairo_charstring_type_t;
54 typedef struct _cairo_type1_font {
57 cairo_scaled_font_subset_t *scaled_font_subset;
58 cairo_scaled_font_t *type1_scaled_font;
60 cairo_array_t contents;
62 double x_min, y_min, x_max, y_max;
65 unsigned long header_size;
66 unsigned long data_size;
67 unsigned long trailer_size;
71 cairo_output_stream_t *output;
73 unsigned short eexec_key;
74 cairo_bool_t hex_encode;
79 cairo_type1_font_create (cairo_scaled_font_subset_t *scaled_font_subset,
80 cairo_type1_font_t **subset_return,
81 cairo_bool_t hex_encode)
83 cairo_type1_font_t *font;
84 cairo_font_face_t *font_face;
85 cairo_matrix_t font_matrix;
87 cairo_font_options_t font_options;
88 cairo_status_t status;
90 font = calloc (1, sizeof (cairo_type1_font_t));
91 if (unlikely (font == NULL))
92 return _cairo_error (CAIRO_STATUS_NO_MEMORY);
94 font->widths = calloc (scaled_font_subset->num_glyphs, sizeof (int));
95 if (unlikely (font->widths == NULL)) {
97 return _cairo_error (CAIRO_STATUS_NO_MEMORY);
100 font->scaled_font_subset = scaled_font_subset;
101 font->hex_encode = hex_encode;
103 font_face = cairo_scaled_font_get_font_face (scaled_font_subset->scaled_font);
105 cairo_matrix_init_scale (&font_matrix, 1000, -1000);
106 cairo_matrix_init_identity (&ctm);
108 _cairo_font_options_init_default (&font_options);
109 cairo_font_options_set_hint_style (&font_options, CAIRO_HINT_STYLE_NONE);
110 cairo_font_options_set_hint_metrics (&font_options, CAIRO_HINT_METRICS_OFF);
112 font->type1_scaled_font = cairo_scaled_font_create (font_face,
116 status = font->type1_scaled_font->status;
117 if (unlikely (status))
120 _cairo_array_init (&font->contents, sizeof (unsigned char));
123 *subset_return = font;
125 return CAIRO_STATUS_SUCCESS;
134 /* Charstring commands. If the high byte is 0 the command is encoded
135 * with a single byte. */
136 #define CHARSTRING_sbw 0x0c07
137 #define CHARSTRING_rmoveto 0x0015
138 #define CHARSTRING_rlineto 0x0005
139 #define CHARSTRING_rcurveto 0x0008
140 #define CHARSTRING_closepath 0x0009
141 #define CHARSTRING_endchar 0x000e
143 /* Before calling this function, the caller must allocate sufficient
144 * space in data (see _cairo_array_grow_by). The maximum number of
145 * bytes that will be used is 2.
148 charstring_encode_command (cairo_array_t *data, int command)
150 cairo_status_t status;
151 unsigned int orig_size;
152 unsigned char buf[5];
153 unsigned char *p = buf;
155 if (command & 0xff00)
157 *p++ = command & 0x00ff;
159 /* Ensure the array doesn't grow, which allows this function to
160 * have no possibility of failure. */
161 orig_size = _cairo_array_size (data);
162 status = _cairo_array_append_multiple (data, buf, p - buf);
164 assert (status == CAIRO_STATUS_SUCCESS);
165 assert (_cairo_array_size (data) == orig_size);
168 /* Before calling this function, the caller must allocate sufficient
169 * space in data (see _cairo_array_grow_by). The maximum number of
170 * bytes that will be used is 5.
173 charstring_encode_integer (cairo_array_t *data,
175 cairo_charstring_type_t type)
177 cairo_status_t status;
178 unsigned int orig_size;
179 unsigned char buf[10];
180 unsigned char *p = buf;
182 if (i >= -107 && i <= 107) {
184 } else if (i >= 108 && i <= 1131) {
186 *p++ = (i >> 8)+ 247;
188 } else if (i >= -1131 && i <= -108) {
190 *p++ = (i >> 8)+ 251;
193 if (type == CAIRO_CHARSTRING_TYPE1) {
196 *p++ = (i >> 16) & 0xff;
197 *p++ = (i >> 8) & 0xff;
201 *p++ = (i >> 8) & 0xff;
208 /* Ensure the array doesn't grow, which allows this function to
209 * have no possibility of failure. */
210 orig_size = _cairo_array_size (data);
211 status = _cairo_array_append_multiple (data, buf, p - buf);
213 assert (status == CAIRO_STATUS_SUCCESS);
214 assert (_cairo_array_size (data) == orig_size);
217 typedef struct _ps_path_info {
219 int current_x, current_y;
220 cairo_charstring_type_t type;
223 static cairo_status_t
224 _charstring_move_to (void *closure,
225 const cairo_point_t *point)
227 t1_path_info_t *path_info = (t1_path_info_t *) closure;
229 cairo_status_t status;
231 status = _cairo_array_grow_by (path_info->data, 12);
232 if (unlikely (status))
235 dx = _cairo_fixed_integer_part (point->x) - path_info->current_x;
236 dy = _cairo_fixed_integer_part (point->y) - path_info->current_y;
237 charstring_encode_integer (path_info->data, dx, path_info->type);
238 charstring_encode_integer (path_info->data, dy, path_info->type);
239 path_info->current_x += dx;
240 path_info->current_y += dy;
242 charstring_encode_command (path_info->data, CHARSTRING_rmoveto);
244 return CAIRO_STATUS_SUCCESS;
247 static cairo_status_t
248 _charstring_line_to (void *closure,
249 const cairo_point_t *point)
251 t1_path_info_t *path_info = (t1_path_info_t *) closure;
253 cairo_status_t status;
255 status = _cairo_array_grow_by (path_info->data, 12);
256 if (unlikely (status))
259 dx = _cairo_fixed_integer_part (point->x) - path_info->current_x;
260 dy = _cairo_fixed_integer_part (point->y) - path_info->current_y;
261 charstring_encode_integer (path_info->data, dx, path_info->type);
262 charstring_encode_integer (path_info->data, dy, path_info->type);
263 path_info->current_x += dx;
264 path_info->current_y += dy;
266 charstring_encode_command (path_info->data, CHARSTRING_rlineto);
268 return CAIRO_STATUS_SUCCESS;
271 static cairo_status_t
272 _charstring_curve_to (void *closure,
273 const cairo_point_t *point1,
274 const cairo_point_t *point2,
275 const cairo_point_t *point3)
277 t1_path_info_t *path_info = (t1_path_info_t *) closure;
278 int dx1, dy1, dx2, dy2, dx3, dy3;
279 cairo_status_t status;
281 status = _cairo_array_grow_by (path_info->data, 32);
282 if (unlikely (status))
285 dx1 = _cairo_fixed_integer_part (point1->x) - path_info->current_x;
286 dy1 = _cairo_fixed_integer_part (point1->y) - path_info->current_y;
287 dx2 = _cairo_fixed_integer_part (point2->x) - path_info->current_x - dx1;
288 dy2 = _cairo_fixed_integer_part (point2->y) - path_info->current_y - dy1;
289 dx3 = _cairo_fixed_integer_part (point3->x) - path_info->current_x - dx1 - dx2;
290 dy3 = _cairo_fixed_integer_part (point3->y) - path_info->current_y - dy1 - dy2;
291 charstring_encode_integer (path_info->data, dx1, path_info->type);
292 charstring_encode_integer (path_info->data, dy1, path_info->type);
293 charstring_encode_integer (path_info->data, dx2, path_info->type);
294 charstring_encode_integer (path_info->data, dy2, path_info->type);
295 charstring_encode_integer (path_info->data, dx3, path_info->type);
296 charstring_encode_integer (path_info->data, dy3, path_info->type);
297 path_info->current_x += dx1 + dx2 + dx3;
298 path_info->current_y += dy1 + dy2 + dy3;
299 charstring_encode_command (path_info->data, CHARSTRING_rcurveto);
301 return CAIRO_STATUS_SUCCESS;
304 static cairo_status_t
305 _charstring_close_path (void *closure)
307 cairo_status_t status;
308 t1_path_info_t *path_info = (t1_path_info_t *) closure;
310 if (path_info->type == CAIRO_CHARSTRING_TYPE2)
311 return CAIRO_STATUS_SUCCESS;
313 status = _cairo_array_grow_by (path_info->data, 2);
314 if (unlikely (status))
317 charstring_encode_command (path_info->data, CHARSTRING_closepath);
319 return CAIRO_STATUS_SUCCESS;
323 charstring_encrypt (cairo_array_t *data)
325 unsigned char *d, *end;
328 r = CAIRO_TYPE1_CHARSTRING_KEY;
329 d = (unsigned char *) _cairo_array_index (data, 0);
333 end = d + _cairo_array_num_elements (data);
337 r = (c + r) * CAIRO_TYPE1_ENCRYPT_C1 + CAIRO_TYPE1_ENCRYPT_C2;
342 static cairo_int_status_t
343 cairo_type1_font_create_charstring (cairo_type1_font_t *font,
346 cairo_charstring_type_t type,
349 cairo_int_status_t status;
350 cairo_scaled_glyph_t *scaled_glyph;
351 t1_path_info_t path_info;
352 cairo_text_extents_t *metrics;
353 cairo_bool_t emit_path = TRUE;
355 /* This call may return CAIRO_INT_STATUS_UNSUPPORTED for bitmap fonts. */
356 status = _cairo_scaled_glyph_lookup (font->type1_scaled_font,
358 CAIRO_SCALED_GLYPH_INFO_METRICS|
359 CAIRO_SCALED_GLYPH_INFO_PATH,
362 /* It is ok for the .notdef glyph to not have a path available. We
363 * just need the metrics to emit an empty glyph. */
364 if (glyph_index == 0 && status == CAIRO_INT_STATUS_UNSUPPORTED) {
366 status = _cairo_scaled_glyph_lookup (font->type1_scaled_font,
368 CAIRO_SCALED_GLYPH_INFO_METRICS,
371 if (unlikely (status))
374 metrics = &scaled_glyph->metrics;
375 if (subset_index == 0) {
376 font->x_min = metrics->x_bearing;
377 font->y_min = metrics->y_bearing;
378 font->x_max = metrics->x_bearing + metrics->width;
379 font->y_max = metrics->y_bearing + metrics->height;
381 if (metrics->x_bearing < font->x_min)
382 font->x_min = metrics->x_bearing;
383 if (metrics->y_bearing < font->y_min)
384 font->y_min = metrics->y_bearing;
385 if (metrics->x_bearing + metrics->width > font->x_max)
386 font->x_max = metrics->x_bearing + metrics->width;
387 if (metrics->y_bearing + metrics->height > font->y_max)
388 font->y_max = metrics->y_bearing + metrics->height;
390 font->widths[subset_index] = metrics->x_advance;
392 status = _cairo_array_grow_by (data, 30);
393 if (unlikely (status))
396 if (type == CAIRO_CHARSTRING_TYPE1) {
397 charstring_encode_integer (data, (int) scaled_glyph->metrics.x_bearing, type);
398 charstring_encode_integer (data, (int) scaled_glyph->metrics.y_bearing, type);
399 charstring_encode_integer (data, (int) scaled_glyph->metrics.x_advance, type);
400 charstring_encode_integer (data, (int) scaled_glyph->metrics.y_advance, type);
401 charstring_encode_command (data, CHARSTRING_sbw);
403 path_info.current_x = (int) scaled_glyph->metrics.x_bearing;
404 path_info.current_y = (int) scaled_glyph->metrics.y_bearing;
406 charstring_encode_integer (data, (int) scaled_glyph->metrics.x_advance, type);
408 path_info.current_x = 0;
409 path_info.current_y = 0;
411 path_info.data = data;
412 path_info.type = type;
414 status = _cairo_path_fixed_interpret (scaled_glyph->path,
417 _charstring_curve_to,
418 _charstring_close_path,
420 if (unlikely (status))
424 status = _cairo_array_grow_by (data, 1);
425 if (unlikely (status))
427 charstring_encode_command (path_info.data, CHARSTRING_endchar);
429 return CAIRO_STATUS_SUCCESS;
432 static cairo_int_status_t
433 cairo_type1_font_write_charstrings (cairo_type1_font_t *font,
434 cairo_output_stream_t *encrypted_output)
436 cairo_status_t status;
437 unsigned char zeros[] = { 0, 0, 0, 0 };
442 _cairo_array_init (&data, sizeof (unsigned char));
443 status = _cairo_array_grow_by (&data, 1024);
444 if (unlikely (status))
447 _cairo_output_stream_printf (encrypted_output,
448 "2 index /CharStrings %d dict dup begin\n",
449 font->scaled_font_subset->num_glyphs + 1);
451 _cairo_scaled_font_freeze_cache (font->type1_scaled_font);
452 for (i = 0; i < font->scaled_font_subset->num_glyphs; i++) {
453 _cairo_array_truncate (&data, 0);
454 /* four "random" bytes required by encryption algorithm */
455 status = _cairo_array_append_multiple (&data, zeros, 4);
456 if (unlikely (status))
459 status = cairo_type1_font_create_charstring (font, i,
460 font->scaled_font_subset->glyphs[i],
461 CAIRO_CHARSTRING_TYPE1,
463 if (unlikely (status))
466 charstring_encrypt (&data);
467 length = _cairo_array_num_elements (&data);
468 if (font->scaled_font_subset->glyph_names != NULL) {
469 _cairo_output_stream_printf (encrypted_output, "/%s %d RD ",
470 font->scaled_font_subset->glyph_names[i],
473 _cairo_output_stream_printf (encrypted_output, "/.notdef %d RD ", length);
475 _cairo_output_stream_printf (encrypted_output, "/g%d %d RD ", i, length);
477 _cairo_output_stream_write (encrypted_output,
478 _cairo_array_index (&data, 0),
480 _cairo_output_stream_printf (encrypted_output, " ND\n");
482 _cairo_scaled_font_thaw_cache (font->type1_scaled_font);
485 _cairo_array_fini (&data);
490 cairo_type1_font_write_header (cairo_type1_font_t *font,
494 const char spaces[50] = " ";
496 _cairo_output_stream_printf (font->output,
497 "%%!FontType1-1.1 %s 1.0\n"
499 "/FontName /%s def\n"
502 "/FontMatrix [0.001 0 0 0.001 0 0] readonly def\n",
506 /* We don't know the bbox values until after the charstrings have
507 * been generated. Reserve some space and fill in the bbox
510 /* Worst case for four signed ints with spaces between each number */
511 font->bbox_max_chars = 50;
513 _cairo_output_stream_printf (font->output, "/FontBBox {");
514 font->bbox_position = _cairo_output_stream_get_position (font->output);
515 _cairo_output_stream_write (font->output, spaces, font->bbox_max_chars);
517 _cairo_output_stream_printf (font->output,
519 "/Encoding 256 array\n"
520 "0 1 255 {1 index exch /.notdef put} for\n");
521 if (font->scaled_font_subset->is_latin) {
522 for (i = 1; i < 256; i++) {
523 int subset_glyph = font->scaled_font_subset->latin_to_subset_glyph_index[i];
525 if (subset_glyph > 0) {
526 if (font->scaled_font_subset->glyph_names != NULL) {
527 _cairo_output_stream_printf (font->output, "dup %d /%s put\n",
528 i, font->scaled_font_subset->glyph_names[subset_glyph]);
530 _cairo_output_stream_printf (font->output, "dup %d /g%d put\n", i, subset_glyph);
535 for (i = 1; i < font->scaled_font_subset->num_glyphs; i++) {
536 if (font->scaled_font_subset->glyph_names != NULL) {
537 _cairo_output_stream_printf (font->output, "dup %d /%s put\n",
538 i, font->scaled_font_subset->glyph_names[i]);
540 _cairo_output_stream_printf (font->output, "dup %d /g%d put\n", i, i);
544 _cairo_output_stream_printf (font->output,
547 "currentfile eexec\n");
550 static cairo_status_t
551 cairo_type1_write_stream_encrypted (void *closure,
552 const unsigned char *data,
555 const unsigned char *in, *end;
557 static const char hex_digits[16] = "0123456789abcdef";
559 cairo_type1_font_t *font = closure;
561 in = (const unsigned char *) data;
562 end = (const unsigned char *) data + length;
565 c = p ^ (font->eexec_key >> 8);
566 font->eexec_key = (c + font->eexec_key) * CAIRO_TYPE1_ENCRYPT_C1 + CAIRO_TYPE1_ENCRYPT_C2;
568 if (font->hex_encode) {
569 digits[0] = hex_digits[c >> 4];
570 digits[1] = hex_digits[c & 0x0f];
572 font->hex_column += 2;
574 if (font->hex_column == 78) {
575 _cairo_output_stream_write (font->output, digits, 3);
576 font->hex_column = 0;
578 _cairo_output_stream_write (font->output, digits, 2);
582 _cairo_output_stream_write (font->output, digits, 1);
586 return CAIRO_STATUS_SUCCESS;
589 static cairo_int_status_t
590 cairo_type1_font_write_private_dict (cairo_type1_font_t *font,
593 cairo_int_status_t status;
594 cairo_status_t status2;
595 cairo_output_stream_t *encrypted_output;
597 font->eexec_key = CAIRO_TYPE1_PRIVATE_DICT_KEY;
598 font->hex_column = 0;
599 encrypted_output = _cairo_output_stream_create (
600 cairo_type1_write_stream_encrypted,
603 if (_cairo_output_stream_get_status (encrypted_output))
604 return _cairo_output_stream_destroy (encrypted_output);
606 /* Note: the first four spaces at the start of this private dict
607 * are the four "random" bytes of plaintext required by the
608 * encryption algorithm */
609 _cairo_output_stream_printf (encrypted_output,
610 " dup /Private 9 dict dup begin\n"
611 "/RD {string currentfile exch readstring pop}"
612 " bind executeonly def\n"
613 "/ND {noaccess def} executeonly def\n"
614 "/NP {noaccess put} executeonly def\n"
615 "/BlueValues [] def\n"
616 "/MinFeature {16 16} def\n"
618 "/password 5839 def\n");
620 status = cairo_type1_font_write_charstrings (font, encrypted_output);
621 if (unlikely (status))
624 _cairo_output_stream_printf (encrypted_output,
629 "dup /FontName get exch definefont pop\n"
630 "mark currentfile closefile\n");
633 status2 = _cairo_output_stream_destroy (encrypted_output);
634 if (status == CAIRO_INT_STATUS_SUCCESS)
641 cairo_type1_font_write_trailer(cairo_type1_font_t *font)
644 static const char zeros[65] =
645 "0000000000000000000000000000000000000000000000000000000000000000\n";
647 for (i = 0; i < 8; i++)
648 _cairo_output_stream_write (font->output, zeros, sizeof zeros);
650 _cairo_output_stream_printf (font->output, "cleartomark\n");
653 static cairo_status_t
654 cairo_type1_write_stream (void *closure,
655 const unsigned char *data,
658 cairo_type1_font_t *font = closure;
660 return _cairo_array_append_multiple (&font->contents, data, length);
663 static cairo_int_status_t
664 cairo_type1_font_write (cairo_type1_font_t *font,
667 cairo_int_status_t status;
669 cairo_type1_font_write_header (font, name);
670 font->header_size = _cairo_output_stream_get_position (font->output);
672 status = cairo_type1_font_write_private_dict (font, name);
673 if (unlikely (status))
676 font->data_size = _cairo_output_stream_get_position (font->output) -
679 cairo_type1_font_write_trailer (font);
681 _cairo_output_stream_get_position (font->output) -
682 font->header_size - font->data_size;
684 return CAIRO_STATUS_SUCCESS;
687 static cairo_int_status_t
688 cairo_type1_font_generate (cairo_type1_font_t *font, const char *name)
690 cairo_int_status_t status;
692 status = _cairo_array_grow_by (&font->contents, 4096);
693 if (unlikely (status))
696 font->output = _cairo_output_stream_create (cairo_type1_write_stream, NULL, font);
697 if (_cairo_output_stream_get_status (font->output))
698 return _cairo_output_stream_destroy (font->output);
700 status = cairo_type1_font_write (font, name);
701 if (unlikely (status))
704 font->data = _cairo_array_index (&font->contents, 0);
706 return CAIRO_STATUS_SUCCESS;
709 static cairo_status_t
710 cairo_type1_font_destroy (cairo_type1_font_t *font)
712 cairo_status_t status = CAIRO_STATUS_SUCCESS;
715 cairo_scaled_font_destroy (font->type1_scaled_font);
716 _cairo_array_fini (&font->contents);
718 status = _cairo_output_stream_destroy (font->output);
724 static cairo_status_t
725 _cairo_type1_fallback_init_internal (cairo_type1_subset_t *type1_subset,
727 cairo_scaled_font_subset_t *scaled_font_subset,
728 cairo_bool_t hex_encode)
730 cairo_type1_font_t *font;
731 cairo_status_t status;
732 unsigned long length;
735 status = cairo_type1_font_create (scaled_font_subset, &font, hex_encode);
736 if (unlikely (status))
739 status = cairo_type1_font_generate (font, name);
740 if (unlikely (status))
743 type1_subset->base_font = strdup (name);
744 if (unlikely (type1_subset->base_font == NULL)) {
745 status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
749 type1_subset->widths = calloc (sizeof (double), font->scaled_font_subset->num_glyphs);
750 if (unlikely (type1_subset->widths == NULL)) {
751 status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
754 for (i = 0; i < font->scaled_font_subset->num_glyphs; i++)
755 type1_subset->widths[i] = (double)font->widths[i]/1000;
757 type1_subset->x_min = (double)font->x_min/1000;
758 type1_subset->y_min = (double)font->y_min/1000;
759 type1_subset->x_max = (double)font->x_max/1000;
760 type1_subset->y_max = (double)font->y_max/1000;
761 type1_subset->ascent = (double)font->y_max/1000;
762 type1_subset->descent = (double)font->y_min/1000;
764 length = font->header_size + font->data_size +
766 type1_subset->data = malloc (length);
767 if (unlikely (type1_subset->data == NULL)) {
768 status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
771 memcpy (type1_subset->data,
772 _cairo_array_index (&font->contents, 0), length);
774 len = snprintf(type1_subset->data + font->bbox_position,
775 font->bbox_max_chars,
781 type1_subset->data[font->bbox_position + len] = ' ';
783 type1_subset->header_length = font->header_size;
784 type1_subset->data_length = font->data_size;
785 type1_subset->trailer_length = font->trailer_size;
787 return cairo_type1_font_destroy (font);
790 free (type1_subset->widths);
792 free (type1_subset->base_font);
794 /* status is already set, ignore further errors */
795 cairo_type1_font_destroy (font);
801 _cairo_type1_fallback_init_binary (cairo_type1_subset_t *type1_subset,
803 cairo_scaled_font_subset_t *scaled_font_subset)
805 return _cairo_type1_fallback_init_internal (type1_subset,
807 scaled_font_subset, FALSE);
811 _cairo_type1_fallback_init_hex (cairo_type1_subset_t *type1_subset,
813 cairo_scaled_font_subset_t *scaled_font_subset)
815 return _cairo_type1_fallback_init_internal (type1_subset,
817 scaled_font_subset, TRUE);
821 _cairo_type1_fallback_fini (cairo_type1_subset_t *subset)
823 free (subset->base_font);
824 free (subset->widths);
829 _cairo_type2_charstrings_init (cairo_type2_charstrings_t *type2_subset,
830 cairo_scaled_font_subset_t *scaled_font_subset)
832 cairo_type1_font_t *font;
833 cairo_status_t status;
835 cairo_array_t charstring;
837 status = cairo_type1_font_create (scaled_font_subset, &font, FALSE);
838 if (unlikely (status))
841 _cairo_array_init (&type2_subset->charstrings, sizeof (cairo_array_t));
843 type2_subset->widths = calloc (sizeof (int), font->scaled_font_subset->num_glyphs);
844 if (unlikely (type2_subset->widths == NULL)) {
845 status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
849 _cairo_scaled_font_freeze_cache (font->type1_scaled_font);
850 for (i = 0; i < font->scaled_font_subset->num_glyphs; i++) {
851 _cairo_array_init (&charstring, sizeof (unsigned char));
852 status = _cairo_array_grow_by (&charstring, 32);
853 if (unlikely (status))
856 status = cairo_type1_font_create_charstring (font, i,
857 font->scaled_font_subset->glyphs[i],
858 CAIRO_CHARSTRING_TYPE2,
860 if (unlikely (status))
863 status = _cairo_array_append (&type2_subset->charstrings, &charstring);
864 if (unlikely (status))
867 _cairo_scaled_font_thaw_cache (font->type1_scaled_font);
869 for (i = 0; i < font->scaled_font_subset->num_glyphs; i++)
870 type2_subset->widths[i] = font->widths[i];
872 type2_subset->x_min = (int) font->x_min;
873 type2_subset->y_min = (int) font->y_min;
874 type2_subset->x_max = (int) font->x_max;
875 type2_subset->y_max = (int) font->y_max;
876 type2_subset->ascent = (int) font->y_max;
877 type2_subset->descent = (int) font->y_min;
879 return cairo_type1_font_destroy (font);
882 _cairo_scaled_font_thaw_cache (font->type1_scaled_font);
883 _cairo_array_fini (&charstring);
884 _cairo_type2_charstrings_fini (type2_subset);
886 cairo_type1_font_destroy (font);
891 _cairo_type2_charstrings_fini (cairo_type2_charstrings_t *type2_subset)
893 unsigned int i, num_charstrings;
894 cairo_array_t *charstring;
896 num_charstrings = _cairo_array_num_elements (&type2_subset->charstrings);
897 for (i = 0; i < num_charstrings; i++) {
898 charstring = _cairo_array_index (&type2_subset->charstrings, i);
900 _cairo_array_fini (charstring);
902 _cairo_array_fini (&type2_subset->charstrings);
904 free (type2_subset->widths);
907 #endif /* CAIRO_HAS_FONT_SUBSET */