• Home
  • History
  • Annotate
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 #include "gdef.h"
6 
7 #include <limits>
8 #include <vector>
9 
10 #include "gpos.h"
11 #include "gsub.h"
12 #include "layout.h"
13 #include "maxp.h"
14 
15 // GDEF - The Glyph Definition Table
16 // http://www.microsoft.com/typography/otspec/gdef.htm
17 
18 namespace {
19 
20 // The maximum class value in class definition tables.
21 const uint16_t kMaxClassDefValue = 0xFFFF;
22 // The maximum class value in the glyph class definision table.
23 const uint16_t kMaxGlyphClassDefValue = 4;
24 // The maximum format number of caret value tables.
25 // We don't support format 3 for now. See the comment in
26 // ParseLigCaretListTable() for the reason.
27 const uint16_t kMaxCaretValueFormat = 2;
28 
ParseGlyphClassDefTable(ots::OpenTypeFile * file,const uint8_t * data,size_t length,const uint16_t num_glyphs)29 bool ParseGlyphClassDefTable(ots::OpenTypeFile *file, const uint8_t *data,
30                              size_t length, const uint16_t num_glyphs) {
31   return ots::ParseClassDefTable(data, length, num_glyphs,
32                                  kMaxGlyphClassDefValue);
33 }
34 
ParseAttachListTable(ots::OpenTypeFile * file,const uint8_t * data,size_t length,const uint16_t num_glyphs)35 bool ParseAttachListTable(ots::OpenTypeFile *file, const uint8_t *data,
36                           size_t length, const uint16_t num_glyphs) {
37   ots::Buffer subtable(data, length);
38 
39   uint16_t offset_coverage = 0;
40   uint16_t glyph_count = 0;
41   if (!subtable.ReadU16(&offset_coverage) ||
42       !subtable.ReadU16(&glyph_count)) {
43     return OTS_FAILURE();
44   }
45   const unsigned attach_points_end =
46       2 * static_cast<unsigned>(glyph_count) + 4;
47   if (attach_points_end > std::numeric_limits<uint16_t>::max()) {
48     return OTS_FAILURE();
49   }
50   if (offset_coverage == 0 || offset_coverage >= length ||
51       offset_coverage < attach_points_end) {
52     return OTS_FAILURE();
53   }
54   if (glyph_count > num_glyphs) {
55     OTS_WARNING("bad glyph count: %u", glyph_count);
56     return OTS_FAILURE();
57   }
58 
59   std::vector<uint16_t> attach_points;
60   attach_points.resize(glyph_count);
61   for (unsigned i = 0; i < glyph_count; ++i) {
62     if (!subtable.ReadU16(&attach_points[i])) {
63       return OTS_FAILURE();
64     }
65     if (attach_points[i] >= length ||
66         attach_points[i] < attach_points_end) {
67       return OTS_FAILURE();
68     }
69   }
70 
71   // Parse coverage table
72   if (!ots::ParseCoverageTable(data + offset_coverage,
73                                length - offset_coverage, num_glyphs)) {
74     return OTS_FAILURE();
75   }
76 
77   // Parse attach point table
78   for (unsigned i = 0; i < attach_points.size(); ++i) {
79     subtable.set_offset(attach_points[i]);
80     uint16_t point_count = 0;
81     if (!subtable.ReadU16(&point_count)) {
82       return OTS_FAILURE();
83     }
84     if (point_count == 0) {
85       return OTS_FAILURE();
86     }
87     uint16_t last_point_index = 0;
88     uint16_t point_index = 0;
89     for (unsigned j = 0; j < point_count; ++j) {
90       if (!subtable.ReadU16(&point_index)) {
91         return OTS_FAILURE();
92       }
93       // Contour point indeces are in increasing numerical order
94       if (last_point_index != 0 && last_point_index >= point_index) {
95         OTS_WARNING("bad contour indeces: %u >= %u",
96                     last_point_index, point_index);
97         return OTS_FAILURE();
98       }
99       last_point_index = point_index;
100     }
101   }
102   return true;
103 }
104 
ParseLigCaretListTable(ots::OpenTypeFile * file,const uint8_t * data,size_t length,const uint16_t num_glyphs)105 bool ParseLigCaretListTable(ots::OpenTypeFile *file, const uint8_t *data,
106                             size_t length, const uint16_t num_glyphs) {
107   ots::Buffer subtable(data, length);
108   uint16_t offset_coverage = 0;
109   uint16_t lig_glyph_count = 0;
110   if (!subtable.ReadU16(&offset_coverage) ||
111       !subtable.ReadU16(&lig_glyph_count)) {
112     return OTS_FAILURE();
113   }
114   const unsigned lig_glyphs_end =
115       2 * static_cast<unsigned>(lig_glyph_count) + 4;
116   if (lig_glyphs_end > std::numeric_limits<uint16_t>::max()) {
117     return OTS_FAILURE();
118   }
119   if (offset_coverage == 0 || offset_coverage >= length ||
120       offset_coverage < lig_glyphs_end) {
121     return OTS_FAILURE();
122   }
123   if (lig_glyph_count > num_glyphs) {
124     OTS_WARNING("bad ligature glyph count: %u", lig_glyph_count);
125     return OTS_FAILURE();
126   }
127 
128   std::vector<uint16_t> lig_glyphs;
129   lig_glyphs.resize(lig_glyph_count);
130   for (unsigned i = 0; i < lig_glyph_count; ++i) {
131     if (!subtable.ReadU16(&lig_glyphs[i])) {
132       return OTS_FAILURE();
133     }
134     if (lig_glyphs[i] >= length || lig_glyphs[i] < lig_glyphs_end) {
135       return OTS_FAILURE();
136     }
137   }
138 
139   // Parse coverage table
140   if (!ots::ParseCoverageTable(data + offset_coverage,
141                                length - offset_coverage, num_glyphs)) {
142     return OTS_FAILURE();
143   }
144 
145   // Parse ligature glyph table
146   for (unsigned i = 0; i < lig_glyphs.size(); ++i) {
147     subtable.set_offset(lig_glyphs[i]);
148     uint16_t caret_count = 0;
149     if (!subtable.ReadU16(&caret_count)) {
150       return OTS_FAILURE();
151     }
152     if (caret_count == 0) {
153       OTS_WARNING("bad caret value count: %u", caret_count);
154       return OTS_FAILURE();
155     }
156 
157     std::vector<uint16_t> caret_values;
158     caret_values.resize(caret_count);
159     uint16_t last_offset_caret = 0;
160     unsigned caret_values_end = 2 * static_cast<unsigned>(caret_count) + 2;
161     for (unsigned j = 0; j < caret_count; ++j) {
162       if (!subtable.ReadU16(&caret_values[j])) {
163         return OTS_FAILURE();
164       }
165       if (caret_values[j] >= length || caret_values[j] < caret_values_end) {
166         return OTS_FAILURE();
167       }
168       // Caret offsets are in increasing coordinate order
169       if (last_offset_caret != 0 && last_offset_caret >= caret_values[j]) {
170         OTS_WARNING("offset isn't in increasing coordinate order: %u >= %u",
171                     last_offset_caret, caret_values[j]);
172         return OTS_FAILURE();
173       }
174       last_offset_caret = caret_values[j];
175     }
176 
177     // Parse caret values table
178     for (unsigned j = 0; j < caret_count; ++j) {
179       subtable.set_offset(lig_glyphs[i] + caret_values[j]);
180       uint16_t caret_format = 0;
181       if (!subtable.ReadU16(&caret_format)) {
182         return OTS_FAILURE();
183       }
184       // TODO(bashi): We only support caret value format 1 and 2 for now
185       // because there are no fonts which contain caret value format 3
186       // as far as we investigated.
187       if (caret_format == 0 || caret_format > kMaxCaretValueFormat) {
188         OTS_WARNING("bad caret value format: %u", caret_format);
189         return OTS_FAILURE();
190       }
191       // CaretValueFormats contain a 2-byte field which could be
192       // arbitrary value.
193       if (!subtable.Skip(2)) {
194         return OTS_FAILURE();
195       }
196     }
197   }
198   return true;
199 }
200 
ParseMarkAttachClassDefTable(ots::OpenTypeFile * file,const uint8_t * data,size_t length,const uint16_t num_glyphs)201 bool ParseMarkAttachClassDefTable(ots::OpenTypeFile *file, const uint8_t *data,
202                                   size_t length, const uint16_t num_glyphs) {
203   return ots::ParseClassDefTable(data, length, num_glyphs, kMaxClassDefValue);
204 }
205 
ParseMarkGlyphSetsDefTable(ots::OpenTypeFile * file,const uint8_t * data,size_t length,const uint16_t num_glyphs)206 bool ParseMarkGlyphSetsDefTable(ots::OpenTypeFile *file, const uint8_t *data,
207                                 size_t length, const uint16_t num_glyphs) {
208   ots::Buffer subtable(data, length);
209   uint16_t format = 0;
210   uint16_t mark_set_count = 0;
211   if (!subtable.ReadU16(&format) ||
212       !subtable.ReadU16(&mark_set_count)) {
213     return OTS_FAILURE();
214   }
215   if (format != 1) {
216     OTS_WARNING("bad mark glyph set table format: %u", format);
217     return OTS_FAILURE();
218   }
219 
220   const unsigned mark_sets_end = 2 * static_cast<unsigned>(mark_set_count) + 4;
221   if (mark_sets_end > std::numeric_limits<uint16_t>::max()) {
222     return OTS_FAILURE();
223   }
224   for (unsigned i = 0; i < mark_set_count; ++i) {
225     uint32_t offset_coverage = 0;
226     if (!subtable.ReadU32(&offset_coverage)) {
227       return OTS_FAILURE();
228     }
229     if (offset_coverage >= length ||
230         offset_coverage < mark_sets_end) {
231       return OTS_FAILURE();
232     }
233     if (!ots::ParseCoverageTable(data + offset_coverage,
234                                  length - offset_coverage, num_glyphs)) {
235       return OTS_FAILURE();
236     }
237   }
238   file->gdef->num_mark_glyph_sets = mark_set_count;
239   return true;
240 }
241 
242 }  // namespace
243 
244 #define DROP_THIS_TABLE \
245   do { file->gdef->data = 0; file->gdef->length = 0; } while (0)
246 
247 namespace ots {
248 
ots_gdef_parse(OpenTypeFile * file,const uint8_t * data,size_t length)249 bool ots_gdef_parse(OpenTypeFile *file, const uint8_t *data, size_t length) {
250   // Grab the number of glyphs in the file from the maxp table to check
251   // GlyphIDs in GDEF table.
252   if (!file->maxp) {
253     return OTS_FAILURE();
254   }
255   const uint16_t num_glyphs = file->maxp->num_glyphs;
256 
257   Buffer table(data, length);
258 
259   OpenTypeGDEF *gdef = new OpenTypeGDEF;
260   file->gdef = gdef;
261 
262   uint32_t version = 0;
263   if (!table.ReadU32(&version)) {
264     return OTS_FAILURE();
265   }
266   if (version < 0x00010000 || version == 0x00010001) {
267     OTS_WARNING("bad GDEF version");
268     DROP_THIS_TABLE;
269     return true;
270   }
271 
272   if (version >= 0x00010002) {
273     gdef->version_2 = true;
274   }
275 
276   uint16_t offset_glyph_class_def = 0;
277   uint16_t offset_attach_list = 0;
278   uint16_t offset_lig_caret_list = 0;
279   uint16_t offset_mark_attach_class_def = 0;
280   if (!table.ReadU16(&offset_glyph_class_def) ||
281       !table.ReadU16(&offset_attach_list) ||
282       !table.ReadU16(&offset_lig_caret_list) ||
283       !table.ReadU16(&offset_mark_attach_class_def)) {
284     return OTS_FAILURE();
285   }
286   uint16_t offset_mark_glyph_sets_def = 0;
287   if (gdef->version_2) {
288     if (!table.ReadU16(&offset_mark_glyph_sets_def)) {
289       return OTS_FAILURE();
290     }
291   }
292 
293   unsigned gdef_header_end = 4 + 4 * 2;
294   if (gdef->version_2)
295     gdef_header_end += 2;
296 
297   // Parse subtables
298   if (offset_glyph_class_def) {
299     if (offset_glyph_class_def >= length ||
300         offset_glyph_class_def < gdef_header_end) {
301       return OTS_FAILURE();
302     }
303     if (!ParseGlyphClassDefTable(file, data + offset_glyph_class_def,
304                                  length - offset_glyph_class_def,
305                                  num_glyphs)) {
306       DROP_THIS_TABLE;
307       return true;
308     }
309     gdef->has_glyph_class_def = true;
310   }
311 
312   if (offset_attach_list) {
313     if (offset_attach_list >= length ||
314         offset_attach_list < gdef_header_end) {
315       return OTS_FAILURE();
316     }
317     if (!ParseAttachListTable(file, data + offset_attach_list,
318                               length - offset_attach_list,
319                               num_glyphs)) {
320       DROP_THIS_TABLE;
321       return true;
322     }
323   }
324 
325   if (offset_lig_caret_list) {
326     if (offset_lig_caret_list >= length ||
327         offset_lig_caret_list < gdef_header_end) {
328       return OTS_FAILURE();
329     }
330     if (!ParseLigCaretListTable(file, data + offset_lig_caret_list,
331                               length - offset_lig_caret_list,
332                               num_glyphs)) {
333       DROP_THIS_TABLE;
334       return true;
335     }
336   }
337 
338   if (offset_mark_attach_class_def) {
339     if (offset_mark_attach_class_def >= length ||
340         offset_mark_attach_class_def < gdef_header_end) {
341       return OTS_FAILURE();
342     }
343     if (!ParseMarkAttachClassDefTable(file,
344                                       data + offset_mark_attach_class_def,
345                                       length - offset_mark_attach_class_def,
346                                       num_glyphs)) {
347       DROP_THIS_TABLE;
348       return true;
349     }
350     gdef->has_mark_attachment_class_def = true;
351   }
352 
353   if (offset_mark_glyph_sets_def) {
354     if (offset_mark_glyph_sets_def >= length ||
355         offset_mark_glyph_sets_def < gdef_header_end) {
356       return OTS_FAILURE();
357     }
358     if (!ParseMarkGlyphSetsDefTable(file,
359                                     data + offset_mark_glyph_sets_def,
360                                     length - offset_mark_glyph_sets_def,
361                                     num_glyphs)) {
362       DROP_THIS_TABLE;
363       return true;
364     }
365     gdef->has_mark_glyph_sets_def = true;
366   }
367   gdef->data = data;
368   gdef->length = length;
369   return true;
370 }
371 
ots_gdef_should_serialise(OpenTypeFile * file)372 bool ots_gdef_should_serialise(OpenTypeFile *file) {
373   const bool needed_tables_dropped =
374       (file->gsub && file->gsub->data == NULL) ||
375       (file->gpos && file->gpos->data == NULL);
376   return file->gdef != NULL && file->gdef->data != NULL &&
377       !needed_tables_dropped;
378 }
379 
ots_gdef_serialise(OTSStream * out,OpenTypeFile * file)380 bool ots_gdef_serialise(OTSStream *out, OpenTypeFile *file) {
381   if (!out->Write(file->gdef->data, file->gdef->length)) {
382     return OTS_FAILURE();
383   }
384 
385   return true;
386 }
387 
ots_gdef_free(OpenTypeFile * file)388 void ots_gdef_free(OpenTypeFile *file) {
389   delete file->gdef;
390 }
391 
392 }  // namespace ots
393 
394