• 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 "metrics.h"
6 
7 #include "head.h"
8 #include "maxp.h"
9 
10 // OpenType horizontal and vertical common header format
11 // http://www.microsoft.com/opentype/otspec/hhea.htm
12 // http://www.microsoft.com/opentype/otspec/vhea.htm
13 
14 namespace ots {
15 
ParseMetricsHeader(OpenTypeFile * file,Buffer * table,OpenTypeMetricsHeader * header)16 bool ParseMetricsHeader(OpenTypeFile *file, Buffer *table,
17                         OpenTypeMetricsHeader *header) {
18   if (!table->ReadS16(&header->ascent) ||
19       !table->ReadS16(&header->descent) ||
20       !table->ReadS16(&header->linegap) ||
21       !table->ReadU16(&header->adv_width_max) ||
22       !table->ReadS16(&header->min_sb1) ||
23       !table->ReadS16(&header->min_sb2) ||
24       !table->ReadS16(&header->max_extent) ||
25       !table->ReadS16(&header->caret_slope_rise) ||
26       !table->ReadS16(&header->caret_slope_run) ||
27       !table->ReadS16(&header->caret_offset)) {
28     return OTS_FAILURE();
29   }
30 
31   if (header->ascent < 0) {
32     OTS_WARNING("bad ascent: %d", header->ascent);
33     header->ascent = 0;
34   }
35   if (header->linegap < 0) {
36     OTS_WARNING("bad linegap: %d", header->linegap);
37     header->linegap = 0;
38   }
39 
40   if (!file->head) {
41     return OTS_FAILURE();
42   }
43 
44   // if the font is non-slanted, caret_offset should be zero.
45   if (!(file->head->mac_style & 2) &&
46       (header->caret_offset != 0)) {
47     OTS_WARNING("bad caret offset: %d", header->caret_offset);
48     header->caret_offset = 0;
49   }
50 
51   // skip the reserved bytes
52   if (!table->Skip(8)) {
53     return OTS_FAILURE();
54   }
55 
56   int16_t data_format;
57   if (!table->ReadS16(&data_format)) {
58     return OTS_FAILURE();
59   }
60   if (data_format) {
61     return OTS_FAILURE();
62   }
63 
64   if (!table->ReadU16(&header->num_metrics)) {
65     return OTS_FAILURE();
66   }
67 
68   if (!file->maxp) {
69     return OTS_FAILURE();
70   }
71 
72   if (header->num_metrics > file->maxp->num_glyphs) {
73     return OTS_FAILURE();
74   }
75 
76   return true;
77 }
78 
SerialiseMetricsHeader(OTSStream * out,const OpenTypeMetricsHeader * header)79 bool SerialiseMetricsHeader(OTSStream *out,
80                             const OpenTypeMetricsHeader *header) {
81   if (!out->WriteU32(header->version) ||
82       !out->WriteS16(header->ascent) ||
83       !out->WriteS16(header->descent) ||
84       !out->WriteS16(header->linegap) ||
85       !out->WriteU16(header->adv_width_max) ||
86       !out->WriteS16(header->min_sb1) ||
87       !out->WriteS16(header->min_sb2) ||
88       !out->WriteS16(header->max_extent) ||
89       !out->WriteS16(header->caret_slope_rise) ||
90       !out->WriteS16(header->caret_slope_run) ||
91       !out->WriteS16(header->caret_offset) ||
92       !out->WriteR64(0) ||  // reserved
93       !out->WriteS16(0) ||  // metric data format
94       !out->WriteU16(header->num_metrics)) {
95     return OTS_FAILURE();
96   }
97 
98   return true;
99 }
100 
ParseMetricsTable(Buffer * table,const uint16_t num_glyphs,const OpenTypeMetricsHeader * header,OpenTypeMetricsTable * metrics)101 bool ParseMetricsTable(Buffer *table,
102                        const uint16_t num_glyphs,
103                        const OpenTypeMetricsHeader *header,
104                        OpenTypeMetricsTable *metrics) {
105   // |num_metrics| is a uint16_t, so it's bounded < 65536. This limits that
106   // amount of memory that we'll allocate for this to a sane amount.
107   const unsigned num_metrics = header->num_metrics;
108 
109   if (num_metrics > num_glyphs) {
110     return OTS_FAILURE();
111   }
112   if (!num_metrics) {
113     return OTS_FAILURE();
114   }
115   const unsigned num_sbs = num_glyphs - num_metrics;
116 
117   metrics->entries.reserve(num_metrics);
118   for (unsigned i = 0; i < num_metrics; ++i) {
119     uint16_t adv = 0;
120     int16_t sb = 0;
121     if (!table->ReadU16(&adv) || !table->ReadS16(&sb)) {
122       return OTS_FAILURE();
123     }
124 
125     // Since so many fonts don't have proper value on |adv| and |sb|,
126     // we should not call ots_failure() here. For example, about 20% of fonts
127     // in http://www.princexml.com/fonts/ (200+ fonts) fails these tests.
128     if (adv > header->adv_width_max) {
129       OTS_WARNING("bad adv: %u > %u", adv, header->adv_width_max);
130       adv = header->adv_width_max;
131     }
132 
133     if (sb < header->min_sb1) {
134       OTS_WARNING("bad sb: %d < %d", sb, header->min_sb1);
135       sb = header->min_sb1;
136     }
137 
138     metrics->entries.push_back(std::make_pair(adv, sb));
139   }
140 
141   metrics->sbs.reserve(num_sbs);
142   for (unsigned i = 0; i < num_sbs; ++i) {
143     int16_t sb;
144     if (!table->ReadS16(&sb)) {
145       // Some Japanese fonts (e.g., mona.ttf) fail this test.
146       return OTS_FAILURE();
147     }
148 
149     if (sb < header->min_sb1) {
150       // The same as above. Three fonts in http://www.fontsquirrel.com/fontface
151       // (e.g., Notice2Std.otf) have weird lsb values.
152       OTS_WARNING("bad lsb: %d < %d", sb, header->min_sb1);
153       sb = header->min_sb1;
154     }
155 
156     metrics->sbs.push_back(sb);
157   }
158 
159   return true;
160 }
161 
SerialiseMetricsTable(OTSStream * out,const OpenTypeMetricsTable * metrics)162 bool SerialiseMetricsTable(OTSStream *out,
163                            const OpenTypeMetricsTable *metrics) {
164   for (unsigned i = 0; i < metrics->entries.size(); ++i) {
165     if (!out->WriteU16(metrics->entries[i].first) ||
166         !out->WriteS16(metrics->entries[i].second)) {
167       return OTS_FAILURE();
168     }
169   }
170 
171   for (unsigned i = 0; i < metrics->sbs.size(); ++i) {
172     if (!out->WriteS16(metrics->sbs[i])) {
173       return OTS_FAILURE();
174     }
175   }
176 
177   return true;
178 }
179 
180 }  // namespace ots
181 
182