0,0 → 1,1433 |
/* cairo - a vector graphics library with display and print output |
* |
* Copyright © 2004 Red Hat, Inc |
* |
* This library is free software; you can redistribute it and/or |
* modify it either under the terms of the GNU Lesser General Public |
* License version 2.1 as published by the Free Software Foundation |
* (the "LGPL") or, at your option, under the terms of the Mozilla |
* Public License Version 1.1 (the "MPL"). If you do not alter this |
* notice, a recipient may use your version of this file under either |
* the MPL or the LGPL. |
* |
* You should have received a copy of the LGPL along with this library |
* in the file COPYING-LGPL-2.1; if not, write to the Free Software |
* Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA |
* You should have received a copy of the MPL along with this library |
* in the file COPYING-MPL-1.1 |
* |
* The contents of this file are subject to the Mozilla Public License |
* Version 1.1 (the "License"); you may not use this file except in |
* compliance with the License. You may obtain a copy of the License at |
* http://www.mozilla.org/MPL/ |
* |
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY |
* OF ANY KIND, either express or implied. See the LGPL or the MPL for |
* the specific language governing rights and limitations. |
* |
* The Original Code is the cairo graphics library. |
* |
* The Initial Developer of the Original Code is Red Hat, Inc. |
* |
* Contributor(s): |
* Kristian Høgsberg <krh@redhat.com> |
* Adrian Johnson <ajohnson@redneon.com> |
*/ |
|
/* |
* Useful links: |
* http://developer.apple.com/textfonts/TTRefMan/RM06/Chap6.html |
* http://www.microsoft.com/typography/specs/default.htm |
*/ |
|
#define _BSD_SOURCE /* for snprintf(), strdup() */ |
#include "cairoint.h" |
#include "cairo-error-private.h" |
|
#if CAIRO_HAS_FONT_SUBSET |
|
#include "cairo-scaled-font-subsets-private.h" |
#include "cairo-truetype-subset-private.h" |
|
|
typedef struct subset_glyph subset_glyph_t; |
struct subset_glyph { |
int parent_index; |
unsigned long location; |
}; |
|
typedef struct _cairo_truetype_font cairo_truetype_font_t; |
|
typedef struct table table_t; |
struct table { |
unsigned long tag; |
cairo_status_t (*write) (cairo_truetype_font_t *font, unsigned long tag); |
int pos; /* position in the font directory */ |
}; |
|
struct _cairo_truetype_font { |
|
cairo_scaled_font_subset_t *scaled_font_subset; |
|
table_t truetype_tables[10]; |
int num_tables; |
|
struct { |
char *font_name; |
char *ps_name; |
unsigned int num_glyphs; |
int *widths; |
long x_min, y_min, x_max, y_max; |
long ascent, descent; |
int units_per_em; |
} base; |
|
subset_glyph_t *glyphs; |
const cairo_scaled_font_backend_t *backend; |
int num_glyphs_in_face; |
int checksum_index; |
cairo_array_t output; |
cairo_array_t string_offsets; |
unsigned long last_offset; |
unsigned long last_boundary; |
int *parent_to_subset; |
cairo_status_t status; |
|
}; |
|
/* |
* Test that the structs we define for TrueType tables have the |
* correct size, ie. they are not padded. |
*/ |
#define check(T, S) COMPILE_TIME_ASSERT (sizeof (T) == (S)) |
check (tt_head_t, 54); |
check (tt_hhea_t, 36); |
check (tt_maxp_t, 32); |
check (tt_name_record_t, 12); |
check (tt_name_t, 18); |
check (tt_name_t, 18); |
check (tt_composite_glyph_t, 16); |
check (tt_glyph_data_t, 26); |
#undef check |
|
static cairo_status_t |
cairo_truetype_font_use_glyph (cairo_truetype_font_t *font, |
unsigned short glyph, |
unsigned short *out); |
|
#define SFNT_VERSION 0x00010000 |
#define SFNT_STRING_MAX_LENGTH 65535 |
|
static cairo_status_t |
_cairo_truetype_font_set_error (cairo_truetype_font_t *font, |
cairo_status_t status) |
{ |
if (status == CAIRO_STATUS_SUCCESS || status == CAIRO_INT_STATUS_UNSUPPORTED) |
return status; |
|
_cairo_status_set_error (&font->status, status); |
|
return _cairo_error (status); |
} |
|
static cairo_status_t |
_cairo_truetype_font_create (cairo_scaled_font_subset_t *scaled_font_subset, |
cairo_truetype_font_t **font_return) |
{ |
cairo_status_t status; |
cairo_truetype_font_t *font; |
const cairo_scaled_font_backend_t *backend; |
tt_head_t head; |
tt_hhea_t hhea; |
tt_maxp_t maxp; |
unsigned long size; |
|
backend = scaled_font_subset->scaled_font->backend; |
if (!backend->load_truetype_table) |
return CAIRO_INT_STATUS_UNSUPPORTED; |
|
/* FIXME: We should either support subsetting vertical fonts, or fail on |
* vertical. Currently font_options_t doesn't have vertical flag, but |
* it should be added in the future. For now, the freetype backend |
* returns UNSUPPORTED in load_truetype_table if the font is vertical. |
* |
* if (cairo_font_options_get_vertical_layout (scaled_font_subset->scaled_font)) |
* return CAIRO_INT_STATUS_UNSUPPORTED; |
*/ |
|
size = sizeof (tt_head_t); |
status = backend->load_truetype_table (scaled_font_subset->scaled_font, |
TT_TAG_head, 0, |
(unsigned char *) &head, |
&size); |
if (unlikely (status)) |
return status; |
|
size = sizeof (tt_maxp_t); |
status = backend->load_truetype_table (scaled_font_subset->scaled_font, |
TT_TAG_maxp, 0, |
(unsigned char *) &maxp, |
&size); |
if (unlikely (status)) |
return status; |
|
size = sizeof (tt_hhea_t); |
status = backend->load_truetype_table (scaled_font_subset->scaled_font, |
TT_TAG_hhea, 0, |
(unsigned char *) &hhea, |
&size); |
if (unlikely (status)) |
return status; |
|
font = malloc (sizeof (cairo_truetype_font_t)); |
if (unlikely (font == NULL)) |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
|
font->backend = backend; |
font->num_glyphs_in_face = be16_to_cpu (maxp.num_glyphs); |
font->scaled_font_subset = scaled_font_subset; |
|
font->last_offset = 0; |
font->last_boundary = 0; |
_cairo_array_init (&font->output, sizeof (char)); |
status = _cairo_array_grow_by (&font->output, 4096); |
if (unlikely (status)) |
goto fail1; |
|
font->glyphs = calloc (font->num_glyphs_in_face + 1, sizeof (subset_glyph_t)); |
if (unlikely (font->glyphs == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail1; |
} |
|
font->parent_to_subset = calloc (font->num_glyphs_in_face, sizeof (int)); |
if (unlikely (font->parent_to_subset == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail2; |
} |
|
font->base.num_glyphs = 0; |
font->base.x_min = (int16_t) be16_to_cpu (head.x_min); |
font->base.y_min = (int16_t) be16_to_cpu (head.y_min); |
font->base.x_max = (int16_t) be16_to_cpu (head.x_max); |
font->base.y_max = (int16_t) be16_to_cpu (head.y_max); |
font->base.ascent = (int16_t) be16_to_cpu (hhea.ascender); |
font->base.descent = (int16_t) be16_to_cpu (hhea.descender); |
font->base.units_per_em = (int16_t) be16_to_cpu (head.units_per_em); |
if (font->base.units_per_em == 0) |
font->base.units_per_em = 2048; |
|
font->base.ps_name = NULL; |
font->base.font_name = NULL; |
status = _cairo_truetype_read_font_name (scaled_font_subset->scaled_font, |
&font->base.ps_name, |
&font->base.font_name); |
if (_cairo_status_is_error (status)) |
goto fail3; |
|
/* If the PS name is not found, create a CairoFont-x-y name. */ |
if (font->base.ps_name == NULL) { |
font->base.ps_name = malloc (30); |
if (unlikely (font->base.ps_name == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail3; |
} |
|
snprintf(font->base.ps_name, 30, "CairoFont-%u-%u", |
scaled_font_subset->font_id, |
scaled_font_subset->subset_id); |
} |
|
font->base.widths = calloc (font->num_glyphs_in_face, sizeof (int)); |
if (unlikely (font->base.widths == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail4; |
} |
|
_cairo_array_init (&font->string_offsets, sizeof (unsigned long)); |
status = _cairo_array_grow_by (&font->string_offsets, 10); |
if (unlikely (status)) |
goto fail5; |
|
font->status = CAIRO_STATUS_SUCCESS; |
|
*font_return = font; |
|
return CAIRO_STATUS_SUCCESS; |
|
fail5: |
_cairo_array_fini (&font->string_offsets); |
free (font->base.widths); |
fail4: |
free (font->base.ps_name); |
fail3: |
free (font->parent_to_subset); |
if (font->base.font_name) |
free (font->base.font_name); |
fail2: |
free (font->glyphs); |
fail1: |
_cairo_array_fini (&font->output); |
free (font); |
|
return status; |
} |
|
static void |
cairo_truetype_font_destroy (cairo_truetype_font_t *font) |
{ |
_cairo_array_fini (&font->string_offsets); |
free (font->base.widths); |
free (font->base.ps_name); |
if (font->base.font_name) |
free (font->base.font_name); |
free (font->parent_to_subset); |
free (font->glyphs); |
_cairo_array_fini (&font->output); |
free (font); |
} |
|
static cairo_status_t |
cairo_truetype_font_allocate_write_buffer (cairo_truetype_font_t *font, |
size_t length, |
unsigned char **buffer) |
{ |
cairo_status_t status; |
|
if (font->status) |
return font->status; |
|
status = _cairo_array_allocate (&font->output, length, (void **) buffer); |
if (unlikely (status)) |
return _cairo_truetype_font_set_error (font, status); |
|
return CAIRO_STATUS_SUCCESS; |
} |
|
static void |
cairo_truetype_font_write (cairo_truetype_font_t *font, |
const void *data, |
size_t length) |
{ |
cairo_status_t status; |
|
if (font->status) |
return; |
|
status = _cairo_array_append_multiple (&font->output, data, length); |
if (unlikely (status)) |
status = _cairo_truetype_font_set_error (font, status); |
} |
|
static void |
cairo_truetype_font_write_be16 (cairo_truetype_font_t *font, |
uint16_t value) |
{ |
uint16_t be16_value; |
|
if (font->status) |
return; |
|
be16_value = cpu_to_be16 (value); |
cairo_truetype_font_write (font, &be16_value, sizeof be16_value); |
} |
|
static void |
cairo_truetype_font_write_be32 (cairo_truetype_font_t *font, |
uint32_t value) |
{ |
uint32_t be32_value; |
|
if (font->status) |
return; |
|
be32_value = cpu_to_be32 (value); |
cairo_truetype_font_write (font, &be32_value, sizeof be32_value); |
} |
|
static cairo_status_t |
cairo_truetype_font_align_output (cairo_truetype_font_t *font, |
unsigned long *aligned) |
{ |
int length, pad; |
unsigned char *padding; |
|
length = _cairo_array_num_elements (&font->output); |
*aligned = (length + 3) & ~3; |
pad = *aligned - length; |
|
if (pad) { |
cairo_status_t status; |
|
status = cairo_truetype_font_allocate_write_buffer (font, pad, |
&padding); |
if (unlikely (status)) |
return status; |
|
memset (padding, 0, pad); |
} |
|
return CAIRO_STATUS_SUCCESS; |
} |
|
static cairo_status_t |
cairo_truetype_font_check_boundary (cairo_truetype_font_t *font, |
unsigned long boundary) |
{ |
cairo_status_t status; |
|
if (font->status) |
return font->status; |
|
if (boundary - font->last_offset > SFNT_STRING_MAX_LENGTH) |
{ |
status = _cairo_array_append (&font->string_offsets, |
&font->last_boundary); |
if (unlikely (status)) |
return _cairo_truetype_font_set_error (font, status); |
|
font->last_offset = font->last_boundary; |
} |
font->last_boundary = boundary; |
|
return CAIRO_STATUS_SUCCESS; |
} |
|
static cairo_status_t |
cairo_truetype_font_write_cmap_table (cairo_truetype_font_t *font, |
unsigned long tag) |
{ |
unsigned int i; |
|
cairo_truetype_font_write_be16 (font, 0); /* Table version */ |
cairo_truetype_font_write_be16 (font, 2); /* Num tables */ |
|
cairo_truetype_font_write_be16 (font, 3); /* Platform */ |
cairo_truetype_font_write_be16 (font, 0); /* Encoding */ |
cairo_truetype_font_write_be32 (font, 20); /* Offset to start of table */ |
|
cairo_truetype_font_write_be16 (font, 1); /* Platform */ |
cairo_truetype_font_write_be16 (font, 0); /* Encoding */ |
cairo_truetype_font_write_be32 (font, 52); /* Offset to start of table */ |
|
/* Output a format 4 encoding table. */ |
|
cairo_truetype_font_write_be16 (font, 4); /* Format */ |
cairo_truetype_font_write_be16 (font, 32); /* Length */ |
cairo_truetype_font_write_be16 (font, 0); /* Version */ |
cairo_truetype_font_write_be16 (font, 4); /* 2*segcount */ |
cairo_truetype_font_write_be16 (font, 4); /* searchrange */ |
cairo_truetype_font_write_be16 (font, 1); /* entry selector */ |
cairo_truetype_font_write_be16 (font, 0); /* rangeshift */ |
cairo_truetype_font_write_be16 (font, 0xf000 + font->base.num_glyphs - 1); /* end count[0] */ |
cairo_truetype_font_write_be16 (font, 0xffff); /* end count[1] */ |
cairo_truetype_font_write_be16 (font, 0); /* reserved */ |
cairo_truetype_font_write_be16 (font, 0xf000); /* startCode[0] */ |
cairo_truetype_font_write_be16 (font, 0xffff); /* startCode[1] */ |
cairo_truetype_font_write_be16 (font, 0x1000); /* delta[0] */ |
cairo_truetype_font_write_be16 (font, 1); /* delta[1] */ |
cairo_truetype_font_write_be16 (font, 0); /* rangeOffset[0] */ |
cairo_truetype_font_write_be16 (font, 0); /* rangeOffset[1] */ |
|
/* Output a format 6 encoding table. */ |
|
cairo_truetype_font_write_be16 (font, 6); |
cairo_truetype_font_write_be16 (font, 10 + 2 * font->base.num_glyphs); |
cairo_truetype_font_write_be16 (font, 0); |
cairo_truetype_font_write_be16 (font, 0); /* First character */ |
cairo_truetype_font_write_be16 (font, font->base.num_glyphs); |
for (i = 0; i < font->base.num_glyphs; i++) |
cairo_truetype_font_write_be16 (font, i); |
|
return font->status; |
} |
|
static cairo_status_t |
cairo_truetype_font_write_generic_table (cairo_truetype_font_t *font, |
unsigned long tag) |
{ |
cairo_status_t status; |
unsigned char *buffer; |
unsigned long size; |
|
if (font->status) |
return font->status; |
|
size = 0; |
status = font->backend->load_truetype_table(font->scaled_font_subset->scaled_font, |
tag, 0, NULL, &size); |
if (unlikely (status)) |
return _cairo_truetype_font_set_error (font, status); |
|
status = cairo_truetype_font_allocate_write_buffer (font, size, &buffer); |
if (unlikely (status)) |
return _cairo_truetype_font_set_error (font, status); |
|
status = font->backend->load_truetype_table (font->scaled_font_subset->scaled_font, |
tag, 0, buffer, &size); |
if (unlikely (status)) |
return _cairo_truetype_font_set_error (font, status); |
|
return CAIRO_STATUS_SUCCESS; |
} |
|
static cairo_status_t |
cairo_truetype_font_remap_composite_glyph (cairo_truetype_font_t *font, |
unsigned char *buffer, |
unsigned long size) |
{ |
tt_glyph_data_t *glyph_data; |
tt_composite_glyph_t *composite_glyph; |
int num_args; |
int has_more_components; |
unsigned short flags; |
unsigned short index; |
cairo_status_t status; |
unsigned char *end = buffer + size; |
|
if (font->status) |
return font->status; |
|
glyph_data = (tt_glyph_data_t *) buffer; |
if ((unsigned char *)(&glyph_data->data) >= end) |
return CAIRO_INT_STATUS_UNSUPPORTED; |
|
if ((int16_t)be16_to_cpu (glyph_data->num_contours) >= 0) |
return CAIRO_STATUS_SUCCESS; |
|
composite_glyph = &glyph_data->glyph; |
do { |
if ((unsigned char *)(&composite_glyph->args[1]) > end) |
return CAIRO_INT_STATUS_UNSUPPORTED; |
|
flags = be16_to_cpu (composite_glyph->flags); |
has_more_components = flags & TT_MORE_COMPONENTS; |
status = cairo_truetype_font_use_glyph (font, be16_to_cpu (composite_glyph->index), &index); |
if (unlikely (status)) |
return status; |
|
composite_glyph->index = cpu_to_be16 (index); |
num_args = 1; |
if (flags & TT_ARG_1_AND_2_ARE_WORDS) |
num_args += 1; |
|
if (flags & TT_WE_HAVE_A_SCALE) |
num_args += 1; |
else if (flags & TT_WE_HAVE_AN_X_AND_Y_SCALE) |
num_args += 2; |
else if (flags & TT_WE_HAVE_A_TWO_BY_TWO) |
num_args += 4; |
|
composite_glyph = (tt_composite_glyph_t *) &(composite_glyph->args[num_args]); |
} while (has_more_components); |
|
return CAIRO_STATUS_SUCCESS; |
} |
|
static cairo_status_t |
cairo_truetype_font_write_glyf_table (cairo_truetype_font_t *font, |
unsigned long tag) |
{ |
unsigned long start_offset, index, size, next; |
tt_head_t header; |
unsigned long begin, end; |
unsigned char *buffer; |
unsigned int i; |
union { |
unsigned char *bytes; |
uint16_t *short_offsets; |
uint32_t *long_offsets; |
} u; |
cairo_status_t status; |
|
if (font->status) |
return font->status; |
|
size = sizeof (tt_head_t); |
status = font->backend->load_truetype_table (font->scaled_font_subset->scaled_font, |
TT_TAG_head, 0, |
(unsigned char*) &header, &size); |
if (unlikely (status)) |
return _cairo_truetype_font_set_error (font, status); |
|
if (be16_to_cpu (header.index_to_loc_format) == 0) |
size = sizeof (int16_t) * (font->num_glyphs_in_face + 1); |
else |
size = sizeof (int32_t) * (font->num_glyphs_in_face + 1); |
|
u.bytes = malloc (size); |
if (unlikely (u.bytes == NULL)) |
return _cairo_truetype_font_set_error (font, CAIRO_STATUS_NO_MEMORY); |
|
status = font->backend->load_truetype_table (font->scaled_font_subset->scaled_font, |
TT_TAG_loca, 0, u.bytes, &size); |
if (unlikely (status)) |
return _cairo_truetype_font_set_error (font, status); |
|
start_offset = _cairo_array_num_elements (&font->output); |
for (i = 0; i < font->base.num_glyphs; i++) { |
index = font->glyphs[i].parent_index; |
if (be16_to_cpu (header.index_to_loc_format) == 0) { |
begin = be16_to_cpu (u.short_offsets[index]) * 2; |
end = be16_to_cpu (u.short_offsets[index + 1]) * 2; |
} |
else { |
begin = be32_to_cpu (u.long_offsets[index]); |
end = be32_to_cpu (u.long_offsets[index + 1]); |
} |
|
/* quick sanity check... */ |
if (end < begin) { |
status = CAIRO_INT_STATUS_UNSUPPORTED; |
goto FAIL; |
} |
|
size = end - begin; |
status = cairo_truetype_font_align_output (font, &next); |
if (unlikely (status)) |
goto FAIL; |
|
status = cairo_truetype_font_check_boundary (font, next); |
if (unlikely (status)) |
goto FAIL; |
|
font->glyphs[i].location = next - start_offset; |
|
status = cairo_truetype_font_allocate_write_buffer (font, size, &buffer); |
if (unlikely (status)) |
goto FAIL; |
|
if (size != 0) { |
status = font->backend->load_truetype_table (font->scaled_font_subset->scaled_font, |
TT_TAG_glyf, begin, buffer, &size); |
if (unlikely (status)) |
goto FAIL; |
|
status = cairo_truetype_font_remap_composite_glyph (font, buffer, size); |
if (unlikely (status)) |
goto FAIL; |
} |
} |
|
status = cairo_truetype_font_align_output (font, &next); |
if (unlikely (status)) |
goto FAIL; |
|
font->glyphs[i].location = next - start_offset; |
|
status = font->status; |
FAIL: |
free (u.bytes); |
|
return _cairo_truetype_font_set_error (font, status); |
} |
|
static cairo_status_t |
cairo_truetype_font_write_head_table (cairo_truetype_font_t *font, |
unsigned long tag) |
{ |
unsigned char *buffer; |
unsigned long size; |
cairo_status_t status; |
|
if (font->status) |
return font->status; |
|
size = 0; |
status = font->backend->load_truetype_table (font->scaled_font_subset->scaled_font, |
tag, 0, NULL, &size); |
if (unlikely (status)) |
return _cairo_truetype_font_set_error (font, status); |
|
font->checksum_index = _cairo_array_num_elements (&font->output) + 8; |
status = cairo_truetype_font_allocate_write_buffer (font, size, &buffer); |
if (unlikely (status)) |
return _cairo_truetype_font_set_error (font, status); |
|
status = font->backend->load_truetype_table (font->scaled_font_subset->scaled_font, |
tag, 0, buffer, &size); |
if (unlikely (status)) |
return _cairo_truetype_font_set_error (font, status); |
|
/* set checkSumAdjustment to 0 for table checksum calculation */ |
*(uint32_t *)(buffer + 8) = 0; |
|
return CAIRO_STATUS_SUCCESS; |
} |
|
static cairo_status_t |
cairo_truetype_font_write_hhea_table (cairo_truetype_font_t *font, unsigned long tag) |
{ |
tt_hhea_t *hhea; |
unsigned long size; |
cairo_status_t status; |
|
if (font->status) |
return font->status; |
|
size = sizeof (tt_hhea_t); |
status = cairo_truetype_font_allocate_write_buffer (font, size, (unsigned char **) &hhea); |
if (unlikely (status)) |
return _cairo_truetype_font_set_error (font, status); |
|
status = font->backend->load_truetype_table (font->scaled_font_subset->scaled_font, |
tag, 0, (unsigned char *) hhea, &size); |
if (unlikely (status)) |
return _cairo_truetype_font_set_error (font, status); |
|
hhea->num_hmetrics = cpu_to_be16 ((uint16_t)(font->base.num_glyphs)); |
|
return CAIRO_STATUS_SUCCESS; |
} |
|
static cairo_status_t |
cairo_truetype_font_write_hmtx_table (cairo_truetype_font_t *font, |
unsigned long tag) |
{ |
unsigned long size; |
unsigned long long_entry_size; |
unsigned long short_entry_size; |
short *p; |
unsigned int i; |
tt_hhea_t hhea; |
int num_hmetrics; |
cairo_status_t status; |
|
if (font->status) |
return font->status; |
|
size = sizeof (tt_hhea_t); |
status = font->backend->load_truetype_table (font->scaled_font_subset->scaled_font, |
TT_TAG_hhea, 0, |
(unsigned char*) &hhea, &size); |
if (unlikely (status)) |
return _cairo_truetype_font_set_error (font, status); |
|
num_hmetrics = be16_to_cpu(hhea.num_hmetrics); |
|
for (i = 0; i < font->base.num_glyphs; i++) { |
long_entry_size = 2 * sizeof (int16_t); |
short_entry_size = sizeof (int16_t); |
status = cairo_truetype_font_allocate_write_buffer (font, |
long_entry_size, |
(unsigned char **) &p); |
if (unlikely (status)) |
return _cairo_truetype_font_set_error (font, status); |
|
if (font->glyphs[i].parent_index < num_hmetrics) { |
status = font->backend->load_truetype_table (font->scaled_font_subset->scaled_font, |
TT_TAG_hmtx, |
font->glyphs[i].parent_index * long_entry_size, |
(unsigned char *) p, &long_entry_size); |
if (unlikely (status)) |
return _cairo_truetype_font_set_error (font, status); |
} |
else |
{ |
status = font->backend->load_truetype_table (font->scaled_font_subset->scaled_font, |
TT_TAG_hmtx, |
(num_hmetrics - 1) * long_entry_size, |
(unsigned char *) p, &short_entry_size); |
if (unlikely (status)) |
return _cairo_truetype_font_set_error (font, status); |
|
status = font->backend->load_truetype_table (font->scaled_font_subset->scaled_font, |
TT_TAG_hmtx, |
num_hmetrics * long_entry_size + |
(font->glyphs[i].parent_index - num_hmetrics) * short_entry_size, |
(unsigned char *) (p + 1), &short_entry_size); |
if (unlikely (status)) |
return _cairo_truetype_font_set_error (font, status); |
} |
font->base.widths[i] = be16_to_cpu (p[0]); |
} |
|
return CAIRO_STATUS_SUCCESS; |
} |
|
static cairo_status_t |
cairo_truetype_font_write_loca_table (cairo_truetype_font_t *font, |
unsigned long tag) |
{ |
unsigned int i; |
tt_head_t header; |
unsigned long size; |
cairo_status_t status; |
|
if (font->status) |
return font->status; |
|
size = sizeof(tt_head_t); |
status = font->backend->load_truetype_table (font->scaled_font_subset->scaled_font, |
TT_TAG_head, 0, |
(unsigned char*) &header, &size); |
if (unlikely (status)) |
return _cairo_truetype_font_set_error (font, status); |
|
if (be16_to_cpu (header.index_to_loc_format) == 0) |
{ |
for (i = 0; i < font->base.num_glyphs + 1; i++) |
cairo_truetype_font_write_be16 (font, font->glyphs[i].location / 2); |
} else { |
for (i = 0; i < font->base.num_glyphs + 1; i++) |
cairo_truetype_font_write_be32 (font, font->glyphs[i].location); |
} |
|
return font->status; |
} |
|
static cairo_status_t |
cairo_truetype_font_write_maxp_table (cairo_truetype_font_t *font, |
unsigned long tag) |
{ |
tt_maxp_t *maxp; |
unsigned long size; |
cairo_status_t status; |
|
if (font->status) |
return font->status; |
|
size = sizeof (tt_maxp_t); |
status = cairo_truetype_font_allocate_write_buffer (font, size, (unsigned char **) &maxp); |
if (unlikely (status)) |
return _cairo_truetype_font_set_error (font, status); |
|
status = font->backend->load_truetype_table (font->scaled_font_subset->scaled_font, |
tag, 0, (unsigned char *) maxp, &size); |
if (unlikely (status)) |
return _cairo_truetype_font_set_error (font, status); |
|
maxp->num_glyphs = cpu_to_be16 (font->base.num_glyphs); |
|
return CAIRO_STATUS_SUCCESS; |
} |
|
static cairo_status_t |
cairo_truetype_font_write_offset_table (cairo_truetype_font_t *font) |
{ |
cairo_status_t status; |
unsigned char *table_buffer; |
size_t table_buffer_length; |
unsigned short search_range, entry_selector, range_shift; |
|
if (font->status) |
return font->status; |
|
search_range = 1; |
entry_selector = 0; |
while (search_range * 2 <= font->num_tables) { |
search_range *= 2; |
entry_selector++; |
} |
search_range *= 16; |
range_shift = font->num_tables * 16 - search_range; |
|
cairo_truetype_font_write_be32 (font, SFNT_VERSION); |
cairo_truetype_font_write_be16 (font, font->num_tables); |
cairo_truetype_font_write_be16 (font, search_range); |
cairo_truetype_font_write_be16 (font, entry_selector); |
cairo_truetype_font_write_be16 (font, range_shift); |
|
/* Allocate space for the table directory. Each directory entry |
* will be filled in by cairo_truetype_font_update_entry() after |
* the table is written. */ |
table_buffer_length = font->num_tables * 16; |
status = cairo_truetype_font_allocate_write_buffer (font, table_buffer_length, |
&table_buffer); |
if (unlikely (status)) |
return _cairo_truetype_font_set_error (font, status); |
|
return CAIRO_STATUS_SUCCESS; |
} |
|
static uint32_t |
cairo_truetype_font_calculate_checksum (cairo_truetype_font_t *font, |
unsigned long start, |
unsigned long end) |
{ |
uint32_t *padded_end; |
uint32_t *p; |
uint32_t checksum; |
char *data; |
|
checksum = 0; |
data = _cairo_array_index (&font->output, 0); |
p = (uint32_t *) (data + start); |
padded_end = (uint32_t *) (data + ((end + 3) & ~3)); |
while (p < padded_end) |
checksum += be32_to_cpu(*p++); |
|
return checksum; |
} |
|
static void |
cairo_truetype_font_update_entry (cairo_truetype_font_t *font, |
int index, |
unsigned long tag, |
unsigned long start, |
unsigned long end) |
{ |
uint32_t *entry; |
|
entry = _cairo_array_index (&font->output, 12 + 16 * index); |
entry[0] = cpu_to_be32 ((uint32_t)tag); |
entry[1] = cpu_to_be32 (cairo_truetype_font_calculate_checksum (font, start, end)); |
entry[2] = cpu_to_be32 ((uint32_t)start); |
entry[3] = cpu_to_be32 ((uint32_t)(end - start)); |
} |
|
static cairo_status_t |
cairo_truetype_font_generate (cairo_truetype_font_t *font, |
const char **data, |
unsigned long *length, |
const unsigned long **string_offsets, |
unsigned long *num_strings) |
{ |
cairo_status_t status; |
unsigned long start, end, next; |
uint32_t checksum, *checksum_location; |
int i; |
|
if (font->status) |
return font->status; |
|
status = cairo_truetype_font_write_offset_table (font); |
if (unlikely (status)) |
goto FAIL; |
|
status = cairo_truetype_font_align_output (font, &start); |
if (unlikely (status)) |
goto FAIL; |
|
end = 0; |
for (i = 0; i < font->num_tables; i++) { |
status = font->truetype_tables[i].write (font, font->truetype_tables[i].tag); |
if (unlikely (status)) |
goto FAIL; |
|
end = _cairo_array_num_elements (&font->output); |
status = cairo_truetype_font_align_output (font, &next); |
if (unlikely (status)) |
goto FAIL; |
|
cairo_truetype_font_update_entry (font, font->truetype_tables[i].pos, |
font->truetype_tables[i].tag, start, end); |
status = cairo_truetype_font_check_boundary (font, next); |
if (unlikely (status)) |
goto FAIL; |
|
start = next; |
} |
|
checksum = |
0xb1b0afba - cairo_truetype_font_calculate_checksum (font, 0, end); |
checksum_location = _cairo_array_index (&font->output, font->checksum_index); |
*checksum_location = cpu_to_be32 (checksum); |
|
*data = _cairo_array_index (&font->output, 0); |
*length = _cairo_array_num_elements (&font->output); |
*num_strings = _cairo_array_num_elements (&font->string_offsets); |
if (*num_strings != 0) |
*string_offsets = _cairo_array_index (&font->string_offsets, 0); |
else |
*string_offsets = NULL; |
|
FAIL: |
return _cairo_truetype_font_set_error (font, status); |
} |
|
static cairo_status_t |
cairo_truetype_font_use_glyph (cairo_truetype_font_t *font, |
unsigned short glyph, |
unsigned short *out) |
{ |
if (glyph >= font->num_glyphs_in_face) |
return CAIRO_INT_STATUS_UNSUPPORTED; |
|
if (font->parent_to_subset[glyph] == 0) { |
font->parent_to_subset[glyph] = font->base.num_glyphs; |
font->glyphs[font->base.num_glyphs].parent_index = glyph; |
font->base.num_glyphs++; |
} |
|
*out = font->parent_to_subset[glyph]; |
return CAIRO_STATUS_SUCCESS; |
} |
|
static void |
cairo_truetype_font_add_truetype_table (cairo_truetype_font_t *font, |
unsigned long tag, |
cairo_status_t (*write) (cairo_truetype_font_t *font, unsigned long tag), |
int pos) |
{ |
font->truetype_tables[font->num_tables].tag = tag; |
font->truetype_tables[font->num_tables].write = write; |
font->truetype_tables[font->num_tables].pos = pos; |
font->num_tables++; |
} |
|
/* cairo_truetype_font_create_truetype_table_list() builds the list of |
* truetype tables to be embedded in the subsetted font. Each call to |
* cairo_truetype_font_add_truetype_table() adds a table, the callback |
* for generating the table, and the position in the table directory |
* to the truetype_tables array. |
* |
* As we write out the glyf table we remap composite glyphs. |
* Remapping composite glyphs will reference the sub glyphs the |
* composite glyph is made up of. The "glyf" table callback needs to |
* be called first so we have all the glyphs in the subset before |
* going further. |
* |
* The order in which tables are added to the truetype_table array |
* using cairo_truetype_font_add_truetype_table() specifies the order |
* in which the callback functions will be called. |
* |
* The tables in the table directory must be listed in alphabetical |
* order. The "cvt", "fpgm", and "prep" are optional tables. They |
* will only be embedded in the subset if they exist in the source |
* font. The pos parameter of cairo_truetype_font_add_truetype_table() |
* specifies the position of the table in the table directory. |
*/ |
static void |
cairo_truetype_font_create_truetype_table_list (cairo_truetype_font_t *font) |
{ |
cairo_bool_t has_cvt = FALSE; |
cairo_bool_t has_fpgm = FALSE; |
cairo_bool_t has_prep = FALSE; |
unsigned long size; |
int pos; |
|
size = 0; |
if (font->backend->load_truetype_table (font->scaled_font_subset->scaled_font, |
TT_TAG_cvt, 0, NULL, |
&size) == CAIRO_STATUS_SUCCESS) |
has_cvt = TRUE; |
|
size = 0; |
if (font->backend->load_truetype_table (font->scaled_font_subset->scaled_font, |
TT_TAG_fpgm, 0, NULL, |
&size) == CAIRO_STATUS_SUCCESS) |
has_fpgm = TRUE; |
|
size = 0; |
if (font->backend->load_truetype_table (font->scaled_font_subset->scaled_font, |
TT_TAG_prep, 0, NULL, |
&size) == CAIRO_STATUS_SUCCESS) |
has_prep = TRUE; |
|
font->num_tables = 0; |
pos = 1; |
if (has_cvt) |
pos++; |
if (has_fpgm) |
pos++; |
cairo_truetype_font_add_truetype_table (font, TT_TAG_glyf, cairo_truetype_font_write_glyf_table, pos); |
|
pos = 0; |
cairo_truetype_font_add_truetype_table (font, TT_TAG_cmap, cairo_truetype_font_write_cmap_table, pos++); |
if (has_cvt) |
cairo_truetype_font_add_truetype_table (font, TT_TAG_cvt, cairo_truetype_font_write_generic_table, pos++); |
if (has_fpgm) |
cairo_truetype_font_add_truetype_table (font, TT_TAG_fpgm, cairo_truetype_font_write_generic_table, pos++); |
pos++; |
cairo_truetype_font_add_truetype_table (font, TT_TAG_head, cairo_truetype_font_write_head_table, pos++); |
cairo_truetype_font_add_truetype_table (font, TT_TAG_hhea, cairo_truetype_font_write_hhea_table, pos++); |
cairo_truetype_font_add_truetype_table (font, TT_TAG_hmtx, cairo_truetype_font_write_hmtx_table, pos++); |
cairo_truetype_font_add_truetype_table (font, TT_TAG_loca, cairo_truetype_font_write_loca_table, pos++); |
cairo_truetype_font_add_truetype_table (font, TT_TAG_maxp, cairo_truetype_font_write_maxp_table, pos++); |
if (has_prep) |
cairo_truetype_font_add_truetype_table (font, TT_TAG_prep, cairo_truetype_font_write_generic_table, pos); |
} |
|
cairo_status_t |
_cairo_truetype_subset_init (cairo_truetype_subset_t *truetype_subset, |
cairo_scaled_font_subset_t *font_subset) |
{ |
cairo_truetype_font_t *font = NULL; |
cairo_status_t status; |
const char *data = NULL; /* squelch bogus compiler warning */ |
unsigned long length = 0; /* squelch bogus compiler warning */ |
unsigned long offsets_length; |
unsigned int i; |
const unsigned long *string_offsets = NULL; |
unsigned long num_strings = 0; |
|
status = _cairo_truetype_font_create (font_subset, &font); |
if (unlikely (status)) |
return status; |
|
for (i = 0; i < font->scaled_font_subset->num_glyphs; i++) { |
unsigned short parent_glyph = font->scaled_font_subset->glyphs[i]; |
status = cairo_truetype_font_use_glyph (font, parent_glyph, &parent_glyph); |
if (unlikely (status)) |
goto fail1; |
} |
|
cairo_truetype_font_create_truetype_table_list (font); |
status = cairo_truetype_font_generate (font, &data, &length, |
&string_offsets, &num_strings); |
if (unlikely (status)) |
goto fail1; |
|
truetype_subset->ps_name = strdup (font->base.ps_name); |
if (unlikely (truetype_subset->ps_name == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail1; |
} |
|
if (font->base.font_name != NULL) { |
truetype_subset->font_name = strdup (font->base.font_name); |
if (unlikely (truetype_subset->font_name == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail2; |
} |
} else { |
truetype_subset->font_name = NULL; |
} |
|
/* The widths array returned must contain only widths for the |
* glyphs in font_subset. Any subglyphs appended after |
* font_subset->num_glyphs are omitted. */ |
truetype_subset->widths = calloc (sizeof (double), |
font->scaled_font_subset->num_glyphs); |
if (unlikely (truetype_subset->widths == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail3; |
} |
for (i = 0; i < font->scaled_font_subset->num_glyphs; i++) |
truetype_subset->widths[i] = (double)font->base.widths[i]/font->base.units_per_em; |
|
truetype_subset->x_min = (double)font->base.x_min/font->base.units_per_em; |
truetype_subset->y_min = (double)font->base.y_min/font->base.units_per_em; |
truetype_subset->x_max = (double)font->base.x_max/font->base.units_per_em; |
truetype_subset->y_max = (double)font->base.y_max/font->base.units_per_em; |
truetype_subset->ascent = (double)font->base.ascent/font->base.units_per_em; |
truetype_subset->descent = (double)font->base.descent/font->base.units_per_em; |
|
if (length) { |
truetype_subset->data = malloc (length); |
if (unlikely (truetype_subset->data == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail4; |
} |
|
memcpy (truetype_subset->data, data, length); |
} else |
truetype_subset->data = NULL; |
truetype_subset->data_length = length; |
|
if (num_strings) { |
offsets_length = num_strings * sizeof (unsigned long); |
truetype_subset->string_offsets = malloc (offsets_length); |
if (unlikely (truetype_subset->string_offsets == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail5; |
} |
|
memcpy (truetype_subset->string_offsets, string_offsets, offsets_length); |
truetype_subset->num_string_offsets = num_strings; |
} else { |
truetype_subset->string_offsets = NULL; |
truetype_subset->num_string_offsets = 0; |
} |
|
cairo_truetype_font_destroy (font); |
|
return CAIRO_STATUS_SUCCESS; |
|
fail5: |
free (truetype_subset->data); |
fail4: |
free (truetype_subset->widths); |
fail3: |
if (truetype_subset->font_name) |
free (truetype_subset->font_name); |
fail2: |
free (truetype_subset->ps_name); |
fail1: |
cairo_truetype_font_destroy (font); |
|
return status; |
} |
|
void |
_cairo_truetype_subset_fini (cairo_truetype_subset_t *subset) |
{ |
free (subset->ps_name); |
if (subset->font_name) |
free (subset->font_name); |
free (subset->widths); |
free (subset->data); |
free (subset->string_offsets); |
} |
|
static cairo_int_status_t |
_cairo_truetype_reverse_cmap (cairo_scaled_font_t *scaled_font, |
unsigned long table_offset, |
unsigned long index, |
uint32_t *ucs4) |
{ |
cairo_status_t status; |
const cairo_scaled_font_backend_t *backend; |
tt_segment_map_t *map; |
char buf[4]; |
unsigned int num_segments, i; |
unsigned long size; |
uint16_t *start_code; |
uint16_t *end_code; |
uint16_t *delta; |
uint16_t *range_offset; |
uint16_t *glyph_array; |
uint16_t c; |
|
backend = scaled_font->backend; |
size = 4; |
status = backend->load_truetype_table (scaled_font, |
TT_TAG_cmap, table_offset, |
(unsigned char *) &buf, |
&size); |
if (unlikely (status)) |
return status; |
|
/* All table formats have the same first two words */ |
map = (tt_segment_map_t *) buf; |
if (be16_to_cpu (map->format) != 4) |
return CAIRO_INT_STATUS_UNSUPPORTED; |
|
size = be16_to_cpu (map->length); |
map = malloc (size); |
if (unlikely (map == NULL)) |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
|
status = backend->load_truetype_table (scaled_font, |
TT_TAG_cmap, table_offset, |
(unsigned char *) map, |
&size); |
if (unlikely (status)) |
goto fail; |
|
num_segments = be16_to_cpu (map->segCountX2)/2; |
|
/* A Format 4 cmap contains 8 uint16_t numbers and 4 arrays of |
* uint16_t each num_segments long. */ |
if (size < (8 + 4*num_segments)*sizeof(uint16_t)) |
return CAIRO_INT_STATUS_UNSUPPORTED; |
|
end_code = map->endCount; |
start_code = &(end_code[num_segments + 1]); |
delta = &(start_code[num_segments]); |
range_offset = &(delta[num_segments]); |
glyph_array = &(range_offset[num_segments]); |
|
/* search for glyph in segments with rangeOffset=0 */ |
for (i = 0; i < num_segments; i++) { |
c = index - be16_to_cpu (delta[i]); |
if (range_offset[i] == 0 && |
c >= be16_to_cpu (start_code[i]) && |
c <= be16_to_cpu (end_code[i])) |
{ |
*ucs4 = c; |
goto found; |
} |
} |
|
/* search for glyph in segments with rangeOffset=1 */ |
for (i = 0; i < num_segments; i++) { |
if (range_offset[i] != 0) { |
uint16_t *glyph_ids = &range_offset[i] + be16_to_cpu (range_offset[i])/2; |
int range_size = be16_to_cpu (end_code[i]) - be16_to_cpu (start_code[i]) + 1; |
uint16_t g_id_be = cpu_to_be16 (index); |
int j; |
|
if (range_size > 0) { |
if ((char*)glyph_ids + 2*range_size > (char*)map + size) |
return CAIRO_INT_STATUS_UNSUPPORTED; |
|
for (j = 0; j < range_size; j++) { |
if (glyph_ids[j] == g_id_be) { |
*ucs4 = be16_to_cpu (start_code[i]) + j; |
goto found; |
} |
} |
} |
} |
} |
|
/* glyph not found */ |
*ucs4 = -1; |
|
found: |
status = CAIRO_STATUS_SUCCESS; |
|
fail: |
free (map); |
|
return status; |
} |
|
cairo_int_status_t |
_cairo_truetype_index_to_ucs4 (cairo_scaled_font_t *scaled_font, |
unsigned long index, |
uint32_t *ucs4) |
{ |
cairo_status_t status = CAIRO_INT_STATUS_UNSUPPORTED; |
const cairo_scaled_font_backend_t *backend; |
tt_cmap_t *cmap; |
char buf[4]; |
int num_tables, i; |
unsigned long size; |
|
backend = scaled_font->backend; |
if (!backend->load_truetype_table) |
return CAIRO_INT_STATUS_UNSUPPORTED; |
|
size = 4; |
status = backend->load_truetype_table (scaled_font, |
TT_TAG_cmap, 0, |
(unsigned char *) &buf, |
&size); |
if (unlikely (status)) |
return status; |
|
cmap = (tt_cmap_t *) buf; |
num_tables = be16_to_cpu (cmap->num_tables); |
size = 4 + num_tables*sizeof(tt_cmap_index_t); |
cmap = _cairo_malloc_ab_plus_c (num_tables, sizeof (tt_cmap_index_t), 4); |
if (unlikely (cmap == NULL)) |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
|
status = backend->load_truetype_table (scaled_font, |
TT_TAG_cmap, 0, |
(unsigned char *) cmap, |
&size); |
if (unlikely (status)) |
goto cleanup; |
|
/* Find a table with Unicode mapping */ |
for (i = 0; i < num_tables; i++) { |
if (be16_to_cpu (cmap->index[i].platform) == 3 && |
be16_to_cpu (cmap->index[i].encoding) == 1) { |
status = _cairo_truetype_reverse_cmap (scaled_font, |
be32_to_cpu (cmap->index[i].offset), |
index, |
ucs4); |
if (status != CAIRO_INT_STATUS_UNSUPPORTED) |
break; |
} |
} |
|
cleanup: |
free (cmap); |
|
return status; |
} |
|
cairo_int_status_t |
_cairo_truetype_read_font_name (cairo_scaled_font_t *scaled_font, |
char **ps_name_out, |
char **font_name_out) |
{ |
cairo_status_t status; |
const cairo_scaled_font_backend_t *backend; |
tt_name_t *name; |
tt_name_record_t *record; |
unsigned long size; |
int i, j; |
char *ps_name = NULL; |
char *font_name = NULL; |
|
backend = scaled_font->backend; |
if (!backend->load_truetype_table) |
return CAIRO_INT_STATUS_UNSUPPORTED; |
|
size = 0; |
status = backend->load_truetype_table (scaled_font, |
TT_TAG_name, 0, |
NULL, |
&size); |
if (status) |
return status; |
|
name = malloc (size); |
if (name == NULL) |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
|
status = backend->load_truetype_table (scaled_font, |
TT_TAG_name, 0, |
(unsigned char *) name, |
&size); |
if (status) |
goto fail; |
|
/* Extract the font name and PS name from the name table. At |
* present this just looks for the Mac platform/Roman encoded font |
* name. It should be extended to use any suitable font name in |
* the name table. |
*/ |
for (i = 0; i < be16_to_cpu(name->num_records); i++) { |
record = &(name->records[i]); |
if ((be16_to_cpu (record->platform) == 1) && |
(be16_to_cpu (record->encoding) == 0)) { |
|
if (be16_to_cpu (record->name) == 4) { |
font_name = malloc (be16_to_cpu(record->length) + 1); |
if (font_name == NULL) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail; |
} |
strncpy(font_name, |
((char*)name) + be16_to_cpu (name->strings_offset) + be16_to_cpu (record->offset), |
be16_to_cpu (record->length)); |
font_name[be16_to_cpu (record->length)] = 0; |
} |
|
if (be16_to_cpu (record->name) == 6) { |
ps_name = malloc (be16_to_cpu(record->length) + 1); |
if (ps_name == NULL) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail; |
} |
strncpy(ps_name, |
((char*)name) + be16_to_cpu (name->strings_offset) + be16_to_cpu (record->offset), |
be16_to_cpu (record->length)); |
ps_name[be16_to_cpu (record->length)] = 0; |
} |
|
if (font_name && ps_name) |
break; |
} |
} |
|
free (name); |
|
/* Ensure PS name does not contain any spaces */ |
if (ps_name) { |
for (i = 0, j = 0; ps_name[j]; j++) { |
if (ps_name[j] == ' ') |
continue; |
ps_name[i++] = ps_name[j]; |
} |
ps_name[i] = '\0'; |
} |
|
*ps_name_out = ps_name; |
*font_name_out = font_name; |
|
return CAIRO_STATUS_SUCCESS; |
|
fail: |
free (name); |
|
if (ps_name != NULL) |
free (ps_name); |
|
if (font_name != NULL) |
free (font_name); |
|
*ps_name_out = NULL; |
*font_name_out = NULL; |
|
return status; |
} |
|
#endif /* CAIRO_HAS_FONT_SUBSET */ |