summaryrefslogtreecommitdiffstats
path: root/gfx/ots/src/glyf.cc
diff options
context:
space:
mode:
Diffstat (limited to 'gfx/ots/src/glyf.cc')
-rw-r--r--gfx/ots/src/glyf.cc303
1 files changed, 303 insertions, 0 deletions
diff --git a/gfx/ots/src/glyf.cc b/gfx/ots/src/glyf.cc
new file mode 100644
index 000000000..311916dc0
--- /dev/null
+++ b/gfx/ots/src/glyf.cc
@@ -0,0 +1,303 @@
+// Copyright (c) 2009 The Chromium 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 "glyf.h"
+
+#include <algorithm>
+#include <limits>
+
+#include "head.h"
+#include "loca.h"
+#include "maxp.h"
+
+// glyf - Glyph Data
+// http://www.microsoft.com/typography/otspec/glyf.htm
+
+#define TABLE_NAME "glyf"
+
+namespace {
+
+bool ParseFlagsForSimpleGlyph(ots::Font *font,
+ ots::Buffer *table,
+ uint32_t gly_length,
+ uint32_t num_flags,
+ uint32_t *flags_count_logical,
+ uint32_t *flags_count_physical,
+ uint32_t *xy_coordinates_length) {
+ uint8_t flag = 0;
+ if (!table->ReadU8(&flag)) {
+ return OTS_FAILURE_MSG("Can't read flag");
+ }
+
+ uint32_t delta = 0;
+ if (flag & (1u << 1)) { // x-Short
+ ++delta;
+ } else if (!(flag & (1u << 4))) {
+ delta += 2;
+ }
+
+ if (flag & (1u << 2)) { // y-Short
+ ++delta;
+ } else if (!(flag & (1u << 5))) {
+ delta += 2;
+ }
+
+ if (flag & (1u << 3)) { // repeat
+ if (*flags_count_logical + 1 >= num_flags) {
+ return OTS_FAILURE_MSG("Count too high (%d + 1 >= %d)", *flags_count_logical, num_flags);
+ }
+ uint8_t repeat = 0;
+ if (!table->ReadU8(&repeat)) {
+ return OTS_FAILURE_MSG("Can't read repeat value");
+ }
+ if (repeat == 0) {
+ return OTS_FAILURE_MSG("Zero repeat");
+ }
+ delta += (delta * repeat);
+
+ *flags_count_logical += repeat;
+ if (*flags_count_logical >= num_flags) {
+ return OTS_FAILURE_MSG("Count too high (%d >= %d)", *flags_count_logical, num_flags);
+ }
+ ++(*flags_count_physical);
+ }
+
+ if ((flag & (1u << 6)) || (flag & (1u << 7))) { // reserved flags
+ return OTS_FAILURE_MSG("Bad glyph flag value (%d), reserved flags must be set to zero", flag);
+ }
+
+ *xy_coordinates_length += delta;
+ if (gly_length < *xy_coordinates_length) {
+ return OTS_FAILURE_MSG("Glyph coordinates length too low (%d < %d)", gly_length, *xy_coordinates_length);
+ }
+
+ return true;
+}
+
+bool ParseSimpleGlyph(ots::Font *font, const uint8_t *data,
+ ots::Buffer *table, int16_t num_contours,
+ uint32_t gly_offset, uint32_t gly_length,
+ uint32_t *new_size) {
+ ots::OpenTypeGLYF *glyf = font->glyf;
+
+ // read the end-points array
+ uint16_t num_flags = 0;
+ for (int i = 0; i < num_contours; ++i) {
+ uint16_t tmp_index = 0;
+ if (!table->ReadU16(&tmp_index)) {
+ return OTS_FAILURE_MSG("Can't read contour index %d", i);
+ }
+ if (tmp_index == 0xffffu) {
+ return OTS_FAILURE_MSG("Bad contour index %d", i);
+ }
+ // check if the indices are monotonically increasing
+ if (i && (tmp_index + 1 <= num_flags)) {
+ return OTS_FAILURE_MSG("Decreasing contour index %d + 1 <= %d", tmp_index, num_flags);
+ }
+ num_flags = tmp_index + 1;
+ }
+
+ uint16_t bytecode_length = 0;
+ if (!table->ReadU16(&bytecode_length)) {
+ return OTS_FAILURE_MSG("Can't read bytecode length");
+ }
+ if ((font->maxp->version_1) &&
+ (font->maxp->max_size_glyf_instructions < bytecode_length)) {
+ return OTS_FAILURE_MSG("Bytecode length too high %d", bytecode_length);
+ }
+
+ const uint32_t gly_header_length = 10 + num_contours * 2 + 2;
+ if (gly_length < (gly_header_length + bytecode_length)) {
+ return OTS_FAILURE_MSG("Glyph header length too high %d", gly_header_length);
+ }
+
+ glyf->iov.push_back(std::make_pair(
+ data + gly_offset,
+ static_cast<size_t>(gly_header_length + bytecode_length)));
+
+ if (!table->Skip(bytecode_length)) {
+ return OTS_FAILURE_MSG("Can't skip bytecode of length %d", bytecode_length);
+ }
+
+ uint32_t flags_count_physical = 0; // on memory
+ uint32_t xy_coordinates_length = 0;
+ for (uint32_t flags_count_logical = 0;
+ flags_count_logical < num_flags;
+ ++flags_count_logical, ++flags_count_physical) {
+ if (!ParseFlagsForSimpleGlyph(font,
+ table,
+ gly_length,
+ num_flags,
+ &flags_count_logical,
+ &flags_count_physical,
+ &xy_coordinates_length)) {
+ return OTS_FAILURE_MSG("Failed to parse glyph flags %d", flags_count_logical);
+ }
+ }
+
+ if (gly_length < (gly_header_length + bytecode_length +
+ flags_count_physical + xy_coordinates_length)) {
+ return OTS_FAILURE_MSG("Glyph too short %d", gly_length);
+ }
+
+ if (gly_length - (gly_header_length + bytecode_length +
+ flags_count_physical + xy_coordinates_length) > 3) {
+ // We allow 0-3 bytes difference since gly_length is 4-bytes aligned,
+ // zero-padded length.
+ return OTS_FAILURE_MSG("Invalid glyph length %d", gly_length);
+ }
+
+ glyf->iov.push_back(std::make_pair(
+ data + gly_offset + gly_header_length + bytecode_length,
+ static_cast<size_t>(flags_count_physical + xy_coordinates_length)));
+
+ *new_size
+ = gly_header_length + flags_count_physical + xy_coordinates_length + bytecode_length;
+
+ return true;
+}
+
+} // namespace
+
+namespace ots {
+
+bool ots_glyf_parse(Font *font, const uint8_t *data, size_t length) {
+ Buffer table(data, length);
+
+ if (!font->maxp || !font->loca || !font->head) {
+ return OTS_FAILURE_MSG("Missing maxp or loca or head table needed by glyf table");
+ }
+
+ OpenTypeGLYF *glyf = new OpenTypeGLYF;
+ font->glyf = glyf;
+
+ const unsigned num_glyphs = font->maxp->num_glyphs;
+ std::vector<uint32_t> &offsets = font->loca->offsets;
+
+ if (offsets.size() != num_glyphs + 1) {
+ return OTS_FAILURE_MSG("Invalide glyph offsets size %ld != %d", offsets.size(), num_glyphs + 1);
+ }
+
+ std::vector<uint32_t> resulting_offsets(num_glyphs + 1);
+ uint32_t current_offset = 0;
+
+ for (unsigned i = 0; i < num_glyphs; ++i) {
+ const unsigned gly_offset = offsets[i];
+ // The LOCA parser checks that these values are monotonic
+ const unsigned gly_length = offsets[i + 1] - offsets[i];
+ if (!gly_length) {
+ // this glyph has no outline (e.g. the space charactor)
+ resulting_offsets[i] = current_offset;
+ continue;
+ }
+
+ if (gly_offset >= length) {
+ return OTS_FAILURE_MSG("Glyph %d offset %d too high %ld", i, gly_offset, length);
+ }
+ // Since these are unsigned types, the compiler is not allowed to assume
+ // that they never overflow.
+ if (gly_offset + gly_length < gly_offset) {
+ return OTS_FAILURE_MSG("Glyph %d length (%d < 0)!", i, gly_length);
+ }
+ if (gly_offset + gly_length > length) {
+ return OTS_FAILURE_MSG("Glyph %d length %d too high", i, gly_length);
+ }
+
+ table.set_offset(gly_offset);
+ int16_t num_contours, xmin, ymin, xmax, ymax;
+ if (!table.ReadS16(&num_contours) ||
+ !table.ReadS16(&xmin) ||
+ !table.ReadS16(&ymin) ||
+ !table.ReadS16(&xmax) ||
+ !table.ReadS16(&ymax)) {
+ return OTS_FAILURE_MSG("Can't read glyph %d header", i);
+ }
+
+ if (num_contours <= -2) {
+ // -2, -3, -4, ... are reserved for future use.
+ return OTS_FAILURE_MSG("Bad number of contours %d in glyph %d", num_contours, i);
+ }
+
+ // workaround for fonts in http://www.princexml.com/fonts/
+ if ((xmin == 32767) &&
+ (xmax == -32767) &&
+ (ymin == 32767) &&
+ (ymax == -32767)) {
+ OTS_WARNING("bad xmin/xmax/ymin/ymax values");
+ xmin = xmax = ymin = ymax = 0;
+ }
+
+ if (xmin > xmax || ymin > ymax) {
+ return OTS_FAILURE_MSG("Bad bounding box values bl=(%d, %d), tr=(%d, %d) in glyph %d", xmin, ymin, xmax, ymax, i);
+ }
+
+ unsigned new_size = 0;
+ if (num_contours >= 0) {
+ // this is a simple glyph and might contain bytecode
+ if (!ParseSimpleGlyph(font, data, &table,
+ num_contours, gly_offset, gly_length, &new_size)) {
+ return OTS_FAILURE_MSG("Failed to parse glyph %d", i);
+ }
+ } else {
+ // it's a composite glyph without any bytecode. Enqueue the whole thing
+ glyf->iov.push_back(std::make_pair(data + gly_offset,
+ static_cast<size_t>(gly_length)));
+ new_size = gly_length;
+ }
+
+ resulting_offsets[i] = current_offset;
+ // glyphs must be four byte aligned
+ // TODO(yusukes): investigate whether this padding is really necessary.
+ // Which part of the spec requires this?
+ const unsigned padding = (4 - (new_size & 3)) % 4;
+ if (padding) {
+ glyf->iov.push_back(std::make_pair(
+ reinterpret_cast<const uint8_t*>("\x00\x00\x00\x00"),
+ static_cast<size_t>(padding)));
+ new_size += padding;
+ }
+ current_offset += new_size;
+ }
+ resulting_offsets[num_glyphs] = current_offset;
+
+ const uint16_t max16 = std::numeric_limits<uint16_t>::max();
+ if ((*std::max_element(resulting_offsets.begin(),
+ resulting_offsets.end()) >= (max16 * 2u)) &&
+ (font->head->index_to_loc_format != 1)) {
+ OTS_WARNING("2-bytes indexing is not possible (due to the padding above)");
+ font->head->index_to_loc_format = 1;
+ }
+
+ font->loca->offsets = resulting_offsets;
+ return true;
+}
+
+bool ots_glyf_should_serialise(Font *font) {
+ return font->glyf != NULL;
+}
+
+bool ots_glyf_serialise(OTSStream *out, Font *font) {
+ const OpenTypeGLYF *glyf = font->glyf;
+
+ for (unsigned i = 0; i < glyf->iov.size(); ++i) {
+ if (!out->Write(glyf->iov[i].first, glyf->iov[i].second)) {
+ return OTS_FAILURE_MSG("Falied to write glyph %d", i);
+ }
+ }
+
+ return true;
+}
+
+void ots_glyf_reuse(Font *font, Font *other) {
+ font->glyf = other->glyf;
+ font->glyf_reused = true;
+}
+
+void ots_glyf_free(Font *font) {
+ delete font->glyf;
+}
+
+} // namespace ots
+
+#undef TABLE_NAME