1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
|
// Copyright (c) 2009-2017 The OTS Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "post.h"
#include "maxp.h"
// post - PostScript
// http://www.microsoft.com/typography/otspec/post.htm
namespace ots {
bool OpenTypePOST::Parse(const uint8_t *data, size_t length) {
Buffer table(data, length);
if (!table.ReadU32(&this->version)) {
return Error("Failed to read table version");
}
if (this->version != 0x00010000 &&
this->version != 0x00020000 &&
this->version != 0x00030000) {
// 0x00025000 is deprecated. We don't accept it.
return Error("Unsupported table version 0x%x", this->version);
}
if (!table.ReadU32(&this->italic_angle) ||
!table.ReadS16(&this->underline) ||
!table.ReadS16(&this->underline_thickness) ||
!table.ReadU32(&this->is_fixed_pitch) ||
// We don't care about the memory usage fields. We'll set all these to
// zero when serialising
!table.Skip(16)) {
return Error("Failed to read table header");
}
if (this->underline_thickness < 0) {
this->underline_thickness = 1;
}
if (this->version == 0x00010000 || this->version == 0x00030000) {
return true;
}
// We have a version 2 table with a list of Pascal strings at the end
uint16_t num_glyphs = 0;
if (!table.ReadU16(&num_glyphs)) {
return Error("Failed to read numberOfGlyphs");
}
OpenTypeMAXP* maxp = static_cast<OpenTypeMAXP*>
(GetFont()->GetTable(OTS_TAG_MAXP));
if (!maxp) {
return Error("Missing required maxp table");
}
if (num_glyphs == 0) {
if (maxp->num_glyphs > 258) {
return Error("Can't have no glyphs in the post table if there are more "
"than 258 glyphs in the font");
}
// workaround for fonts in http://www.fontsquirrel.com/fontface
// (e.g., yataghan.ttf).
this->version = 0x00010000;
return Warning("Table version is 1, but no glyph names are found");
}
if (num_glyphs != maxp->num_glyphs) {
// Note: Fixedsys500c.ttf seems to have inconsistent num_glyphs values.
return Error("Bad number of glyphs: %d", num_glyphs);
}
this->glyph_name_index.resize(num_glyphs);
for (unsigned i = 0; i < num_glyphs; ++i) {
if (!table.ReadU16(&this->glyph_name_index[i])) {
return Error("Failed to read glyph name %d", i);
}
// Note: A strict interpretation of the specification requires name indexes
// are less than 32768. This, however, excludes fonts like unifont.ttf
// which cover all of unicode.
}
// Now we have an array of Pascal strings. We have to check that they are all
// valid and read them in.
const size_t strings_offset = table.offset();
const uint8_t *strings = data + strings_offset;
const uint8_t *strings_end = data + length;
for (;;) {
if (strings == strings_end) break;
const unsigned string_length = *strings;
if (strings + 1 + string_length > strings_end) {
return Error("Bad string length %d", string_length);
}
if (std::memchr(strings + 1, '\0', string_length)) {
return Error("Bad string of length %d", string_length);
}
this->names.push_back(
std::string(reinterpret_cast<const char*>(strings + 1), string_length));
strings += 1 + string_length;
}
const unsigned num_strings = this->names.size();
// check that all the references are within bounds
for (unsigned i = 0; i < num_glyphs; ++i) {
unsigned offset = this->glyph_name_index[i];
if (offset < 258) {
continue;
}
offset -= 258;
if (offset >= num_strings) {
return Error("Bad string index %d", offset);
}
}
return true;
}
bool OpenTypePOST::Serialize(OTSStream *out) {
// OpenType with CFF glyphs must have v3 post table.
if (GetFont()->GetTable(OTS_TAG_CFF) && this->version != 0x00030000) {
return Error("Only version supported for fonts with CFF table is 0x00030000"
" not 0x%x", this->version);
}
if (!out->WriteU32(this->version) ||
!out->WriteU32(this->italic_angle) ||
!out->WriteS16(this->underline) ||
!out->WriteS16(this->underline_thickness) ||
!out->WriteU32(this->is_fixed_pitch) ||
!out->WriteU32(0) ||
!out->WriteU32(0) ||
!out->WriteU32(0) ||
!out->WriteU32(0)) {
return Error("Failed to write post header");
}
if (this->version != 0x00020000) {
return true; // v1.0 and v3.0 does not have glyph names.
}
const uint16_t num_indexes =
static_cast<uint16_t>(this->glyph_name_index.size());
if (num_indexes != this->glyph_name_index.size() ||
!out->WriteU16(num_indexes)) {
return Error("Failed to write number of indices");
}
for (uint16_t i = 0; i < num_indexes; ++i) {
if (!out->WriteU16(this->glyph_name_index[i])) {
return Error("Failed to write name index %d", i);
}
}
// Now we just have to write out the strings in the correct order
for (unsigned i = 0; i < this->names.size(); ++i) {
const std::string& s = this->names[i];
const uint8_t string_length = static_cast<uint8_t>(s.size());
if (string_length != s.size() ||
!out->Write(&string_length, 1)) {
return Error("Failed to write string %d", i);
}
// Some ttf fonts (e.g., frank.ttf on Windows Vista) have zero-length name.
// We allow them.
if (string_length > 0 && !out->Write(s.data(), string_length)) {
return Error("Failed to write string length for string %d", i);
}
}
return true;
}
} // namespace ots
|
