diff options
Diffstat (limited to 'gfx/ots/src/gdef.cc')
| -rw-r--r-- | gfx/ots/src/gdef.cc | 269 |
1 files changed, 130 insertions, 139 deletions
diff --git a/gfx/ots/src/gdef.cc b/gfx/ots/src/gdef.cc index 71c6fc592..71e1075e3 100644 --- a/gfx/ots/src/gdef.cc +++ b/gfx/ots/src/gdef.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2011 The Chromium Authors. All rights reserved. +// Copyright (c) 2011-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. @@ -11,68 +11,60 @@ #include "gsub.h" #include "layout.h" #include "maxp.h" +#include "variations.h" // GDEF - The Glyph Definition Table // http://www.microsoft.com/typography/otspec/gdef.htm -#define TABLE_NAME "GDEF" - namespace { -// The maximum class value in class definition tables. -const uint16_t kMaxClassDefValue = 0xFFFF; // The maximum class value in the glyph class definision table. const uint16_t kMaxGlyphClassDefValue = 4; // The maximum format number of caret value tables. -// We don't support format 3 for now. See the comment in -// ParseLigCaretListTable() for the reason. -const uint16_t kMaxCaretValueFormat = 2; - -bool ParseGlyphClassDefTable(ots::Font *font, const uint8_t *data, - size_t length, const uint16_t num_glyphs) { - return ots::ParseClassDefTable(font, data, length, num_glyphs, - kMaxGlyphClassDefValue); -} +const uint16_t kMaxCaretValueFormat = 3; + +} // namespace -bool ParseAttachListTable(ots::Font *font, const uint8_t *data, - size_t length, const uint16_t num_glyphs) { +namespace ots { + +bool OpenTypeGDEF::ParseAttachListTable(const uint8_t *data, size_t length) { ots::Buffer subtable(data, length); uint16_t offset_coverage = 0; uint16_t glyph_count = 0; if (!subtable.ReadU16(&offset_coverage) || !subtable.ReadU16(&glyph_count)) { - return OTS_FAILURE_MSG("Failed to read gdef header"); + return Error("Failed to read gdef header"); } const unsigned attach_points_end = 2 * static_cast<unsigned>(glyph_count) + 4; if (attach_points_end > std::numeric_limits<uint16_t>::max()) { - return OTS_FAILURE_MSG("Bad glyph count in gdef"); + return Error("Bad glyph count in gdef"); } if (offset_coverage == 0 || offset_coverage >= length || offset_coverage < attach_points_end) { - return OTS_FAILURE_MSG("Bad coverage offset %d", offset_coverage); + return Error("Bad coverage offset %d", offset_coverage); } - if (glyph_count > num_glyphs) { - return OTS_FAILURE_MSG("Bad glyph count %u", glyph_count); + if (glyph_count > this->m_num_glyphs) { + return Error("Bad glyph count %u", glyph_count); } std::vector<uint16_t> attach_points; attach_points.resize(glyph_count); for (unsigned i = 0; i < glyph_count; ++i) { if (!subtable.ReadU16(&attach_points[i])) { - return OTS_FAILURE_MSG("Can't read attachment point %d", i); + return Error("Can't read attachment point %d", i); } if (attach_points[i] >= length || attach_points[i] < attach_points_end) { - return OTS_FAILURE_MSG("Bad attachment point %d of %d", i, attach_points[i]); + return Error("Bad attachment point %d of %d", i, attach_points[i]); } } // Parse coverage table - if (!ots::ParseCoverageTable(font, data + offset_coverage, - length - offset_coverage, num_glyphs)) { - return OTS_FAILURE_MSG("Bad coverage table"); + if (!ots::ParseCoverageTable(GetFont(), data + offset_coverage, + length - offset_coverage, this->m_num_glyphs)) { + return Error("Bad coverage table"); } // Parse attach point table @@ -80,20 +72,20 @@ bool ParseAttachListTable(ots::Font *font, const uint8_t *data, subtable.set_offset(attach_points[i]); uint16_t point_count = 0; if (!subtable.ReadU16(&point_count)) { - return OTS_FAILURE_MSG("Can't read point count %d", i); + return Error("Can't read point count %d", i); } if (point_count == 0) { - return OTS_FAILURE_MSG("zero point count %d", i); + return Error("zero point count %d", i); } uint16_t last_point_index = 0; uint16_t point_index = 0; for (unsigned j = 0; j < point_count; ++j) { if (!subtable.ReadU16(&point_index)) { - return OTS_FAILURE_MSG("Can't read point index %d in point %d", j, i); + return Error("Can't read point index %d in point %d", j, i); } // Contour point indeces are in increasing numerical order if (last_point_index != 0 && last_point_index >= point_index) { - return OTS_FAILURE_MSG("bad contour indeces: %u >= %u", + return Error("bad contour indeces: %u >= %u", last_point_index, point_index); } last_point_index = point_index; @@ -102,43 +94,42 @@ bool ParseAttachListTable(ots::Font *font, const uint8_t *data, return true; } -bool ParseLigCaretListTable(ots::Font *font, const uint8_t *data, - size_t length, const uint16_t num_glyphs) { +bool OpenTypeGDEF::ParseLigCaretListTable(const uint8_t *data, size_t length) { ots::Buffer subtable(data, length); uint16_t offset_coverage = 0; uint16_t lig_glyph_count = 0; if (!subtable.ReadU16(&offset_coverage) || !subtable.ReadU16(&lig_glyph_count)) { - return OTS_FAILURE_MSG("Can't read caret structure"); + return Error("Can't read caret structure"); } const unsigned lig_glyphs_end = 2 * static_cast<unsigned>(lig_glyph_count) + 4; if (lig_glyphs_end > std::numeric_limits<uint16_t>::max()) { - return OTS_FAILURE_MSG("Bad caret structure"); + return Error("Bad caret structure"); } if (offset_coverage == 0 || offset_coverage >= length || offset_coverage < lig_glyphs_end) { - return OTS_FAILURE_MSG("Bad caret coverate offset %d", offset_coverage); + return Error("Bad caret coverate offset %d", offset_coverage); } - if (lig_glyph_count > num_glyphs) { - return OTS_FAILURE_MSG("bad ligature glyph count: %u", lig_glyph_count); + if (lig_glyph_count > this->m_num_glyphs) { + return Error("bad ligature glyph count: %u", lig_glyph_count); } std::vector<uint16_t> lig_glyphs; lig_glyphs.resize(lig_glyph_count); for (unsigned i = 0; i < lig_glyph_count; ++i) { if (!subtable.ReadU16(&lig_glyphs[i])) { - return OTS_FAILURE_MSG("Can't read ligature glyph location %d", i); + return Error("Can't read ligature glyph location %d", i); } if (lig_glyphs[i] >= length || lig_glyphs[i] < lig_glyphs_end) { - return OTS_FAILURE_MSG("Bad ligature glyph location %d in glyph %d", lig_glyphs[i], i); + return Error("Bad ligature glyph location %d in glyph %d", lig_glyphs[i], i); } } // Parse coverage table - if (!ots::ParseCoverageTable(font, data + offset_coverage, - length - offset_coverage, num_glyphs)) { - return OTS_FAILURE_MSG("Can't parse caret coverage table"); + if (!ots::ParseCoverageTable(GetFont(), data + offset_coverage, + length - offset_coverage, this->m_num_glyphs)) { + return Error("Can't parse caret coverage table"); } // Parse ligature glyph table @@ -146,10 +137,10 @@ bool ParseLigCaretListTable(ots::Font *font, const uint8_t *data, subtable.set_offset(lig_glyphs[i]); uint16_t caret_count = 0; if (!subtable.ReadU16(&caret_count)) { - return OTS_FAILURE_MSG("Can't read caret count for glyph %d", i); + return Error("Can't read caret count for glyph %d", i); } if (caret_count == 0) { - return OTS_FAILURE_MSG("bad caret value count: %u", caret_count); + return Error("bad caret value count: %u", caret_count); } std::vector<uint16_t> caret_value_offsets; @@ -157,10 +148,10 @@ bool ParseLigCaretListTable(ots::Font *font, const uint8_t *data, unsigned caret_value_offsets_end = 2 * static_cast<unsigned>(caret_count) + 2; for (unsigned j = 0; j < caret_count; ++j) { if (!subtable.ReadU16(&caret_value_offsets[j])) { - return OTS_FAILURE_MSG("Can't read caret offset %d for glyph %d", j, i); + return Error("Can't read caret offset %d for glyph %d", j, i); } if (caret_value_offsets[j] >= length || caret_value_offsets[j] < caret_value_offsets_end) { - return OTS_FAILURE_MSG("Bad caret offset %d for caret %d glyph %d", caret_value_offsets[j], j, i); + return Error("Bad caret offset %d for caret %d glyph %d", caret_value_offsets[j], j, i); } } @@ -169,91 +160,93 @@ bool ParseLigCaretListTable(ots::Font *font, const uint8_t *data, subtable.set_offset(lig_glyphs[i] + caret_value_offsets[j]); uint16_t caret_format = 0; if (!subtable.ReadU16(&caret_format)) { - return OTS_FAILURE_MSG("Can't read caret values table %d in glyph %d", j, i); + return Error("Can't read caret values table %d in glyph %d", j, i); } - // TODO(bashi): We only support caret value format 1 and 2 for now - // because there are no fonts which contain caret value format 3 - // as far as we investigated. if (caret_format == 0 || caret_format > kMaxCaretValueFormat) { - return OTS_FAILURE_MSG("bad caret value format: %u", caret_format); + return Error("bad caret value format: %u", caret_format); } // CaretValueFormats contain a 2-byte field which could be // arbitrary value. if (!subtable.Skip(2)) { - return OTS_FAILURE_MSG("Bad caret value table structure %d in glyph %d", j, i); + return Error("Bad caret value table structure %d in glyph %d", j, i); + } + if (caret_format == 3) { + uint16_t offset_device = 0; + if (!subtable.ReadU16(&offset_device)) { + return Error("Can't read device offset for caret value %d " + "in glyph %d", j, i); + } + uint16_t absolute_offset = lig_glyphs[i] + caret_value_offsets[j] + + offset_device; + if (offset_device == 0 || absolute_offset >= length) { + return Error("Bad device offset for caret value %d in glyph %d: %d", + j, i, offset_device); + } + if (!ots::ParseDeviceTable(GetFont(), data + absolute_offset, + length - absolute_offset)) { + return Error("Bad device table for caret value %d in glyph %d", + j, i, offset_device); + } } } } return true; } -bool ParseMarkAttachClassDefTable(ots::Font *font, const uint8_t *data, - size_t length, const uint16_t num_glyphs) { - return ots::ParseClassDefTable(font, data, length, num_glyphs, kMaxClassDefValue); -} - -bool ParseMarkGlyphSetsDefTable(ots::Font *font, const uint8_t *data, - size_t length, const uint16_t num_glyphs) { +bool OpenTypeGDEF::ParseMarkGlyphSetsDefTable(const uint8_t *data, size_t length) { ots::Buffer subtable(data, length); uint16_t format = 0; uint16_t mark_set_count = 0; if (!subtable.ReadU16(&format) || !subtable.ReadU16(&mark_set_count)) { - return OTS_FAILURE_MSG("Can' read mark glyph table structure"); + return Error("Can' read mark glyph table structure"); } if (format != 1) { - return OTS_FAILURE_MSG("bad mark glyph set table format: %u", format); + return Error("bad mark glyph set table format: %u", format); } const unsigned mark_sets_end = 2 * static_cast<unsigned>(mark_set_count) + 4; if (mark_sets_end > std::numeric_limits<uint16_t>::max()) { - return OTS_FAILURE_MSG("Bad mark_set %d", mark_sets_end); + return Error("Bad mark_set %d", mark_sets_end); } for (unsigned i = 0; i < mark_set_count; ++i) { uint32_t offset_coverage = 0; if (!subtable.ReadU32(&offset_coverage)) { - return OTS_FAILURE_MSG("Can't read covrage location for mark set %d", i); + return Error("Can't read covrage location for mark set %d", i); } if (offset_coverage >= length || offset_coverage < mark_sets_end) { - return OTS_FAILURE_MSG("Bad coverage location %d for mark set %d", offset_coverage, i); + return Error("Bad coverage location %d for mark set %d", offset_coverage, i); } - if (!ots::ParseCoverageTable(font, data + offset_coverage, - length - offset_coverage, num_glyphs)) { - return OTS_FAILURE_MSG("Failed to parse coverage table for mark set %d", i); + if (!ots::ParseCoverageTable(GetFont(), data + offset_coverage, + length - offset_coverage, this->m_num_glyphs)) { + return Error("Failed to parse coverage table for mark set %d", i); } } - font->gdef->num_mark_glyph_sets = mark_set_count; + this->num_mark_glyph_sets = mark_set_count; return true; } -} // namespace +bool OpenTypeGDEF::Parse(const uint8_t *data, size_t length) { + OpenTypeMAXP *maxp = static_cast<OpenTypeMAXP*>( + GetFont()->GetTypedTable(OTS_TAG_MAXP)); -namespace ots { - -bool ots_gdef_parse(Font *font, const uint8_t *data, size_t length) { // Grab the number of glyphs in the font from the maxp table to check // GlyphIDs in GDEF table. - if (!font->maxp) { - return OTS_FAILURE_MSG("No maxp table in font, needed by GDEF"); + if (!maxp) { + return Error("No maxp table in font, needed by GDEF"); } - const uint16_t num_glyphs = font->maxp->num_glyphs; + this->m_num_glyphs = maxp->num_glyphs; Buffer table(data, length); - OpenTypeGDEF *gdef = new OpenTypeGDEF; - font->gdef = gdef; - - uint32_t version = 0; - if (!table.ReadU32(&version)) { - return OTS_FAILURE_MSG("Incomplete table"); + uint16_t version_major = 0, version_minor = 0; + if (!table.ReadU16(&version_major) || + !table.ReadU16(&version_minor)) { + return Error("Incomplete table"); } - if (version < 0x00010000 || version == 0x00010001) { - return OTS_FAILURE_MSG("Bad version"); - } - - if (version >= 0x00010002) { - gdef->version_2 = true; + if (version_major != 1 || version_minor == 1) { // there is no v1.1 + return Error("Bad version"); } uint16_t offset_glyph_class_def = 0; @@ -264,110 +257,108 @@ bool ots_gdef_parse(Font *font, const uint8_t *data, size_t length) { !table.ReadU16(&offset_attach_list) || !table.ReadU16(&offset_lig_caret_list) || !table.ReadU16(&offset_mark_attach_class_def)) { - return OTS_FAILURE_MSG("Incomplete table"); + return Error("Incomplete table"); } uint16_t offset_mark_glyph_sets_def = 0; - if (gdef->version_2) { + if (version_minor >= 2) { if (!table.ReadU16(&offset_mark_glyph_sets_def)) { - return OTS_FAILURE_MSG("Incomplete table"); + return Error("Incomplete table"); + } + } + uint32_t item_var_store_offset = 0; + if (version_minor >= 3) { + if (!table.ReadU32(&item_var_store_offset)) { + return Error("Incomplete table"); } } unsigned gdef_header_end = 4 + 4 * 2; - if (gdef->version_2) + if (version_minor >= 2) gdef_header_end += 2; + if (version_minor >= 3) + gdef_header_end += 4; // Parse subtables if (offset_glyph_class_def) { if (offset_glyph_class_def >= length || offset_glyph_class_def < gdef_header_end) { - return OTS_FAILURE_MSG("Invalid offset to glyph classes"); + return Error("Invalid offset to glyph classes"); } - if (!ParseGlyphClassDefTable(font, data + offset_glyph_class_def, + if (!ots::ParseClassDefTable(GetFont(), data + offset_glyph_class_def, length - offset_glyph_class_def, - num_glyphs)) { - return OTS_FAILURE_MSG("Invalid glyph classes"); + this->m_num_glyphs, kMaxGlyphClassDefValue)) { + return Error("Invalid glyph classes"); } - gdef->has_glyph_class_def = true; } if (offset_attach_list) { if (offset_attach_list >= length || offset_attach_list < gdef_header_end) { - return OTS_FAILURE_MSG("Invalid offset to attachment list"); + return Error("Invalid offset to attachment list"); } - if (!ParseAttachListTable(font, data + offset_attach_list, - length - offset_attach_list, - num_glyphs)) { - return OTS_FAILURE_MSG("Invalid attachment list"); + if (!ParseAttachListTable(data + offset_attach_list, + length - offset_attach_list)) { + return Error("Invalid attachment list"); } } if (offset_lig_caret_list) { if (offset_lig_caret_list >= length || offset_lig_caret_list < gdef_header_end) { - return OTS_FAILURE_MSG("Invalid offset to ligature caret list"); + return Error("Invalid offset to ligature caret list"); } - if (!ParseLigCaretListTable(font, data + offset_lig_caret_list, - length - offset_lig_caret_list, - num_glyphs)) { - return OTS_FAILURE_MSG("Invalid ligature caret list"); + if (!ParseLigCaretListTable(data + offset_lig_caret_list, + length - offset_lig_caret_list)) { + return Error("Invalid ligature caret list"); } } if (offset_mark_attach_class_def) { if (offset_mark_attach_class_def >= length || offset_mark_attach_class_def < gdef_header_end) { - return OTS_FAILURE_MSG("Invalid offset to mark attachment list"); + return Error("Invalid offset to mark attachment list"); } - if (!ParseMarkAttachClassDefTable(font, - data + offset_mark_attach_class_def, - length - offset_mark_attach_class_def, - num_glyphs)) { - return OTS_FAILURE_MSG("Invalid mark attachment list"); + if (!ots::ParseClassDefTable(GetFont(), + data + offset_mark_attach_class_def, + length - offset_mark_attach_class_def, + this->m_num_glyphs, kMaxClassDefValue)) { + return Error("Invalid mark attachment list"); } - gdef->has_mark_attachment_class_def = true; } if (offset_mark_glyph_sets_def) { if (offset_mark_glyph_sets_def >= length || offset_mark_glyph_sets_def < gdef_header_end) { - return OTS_FAILURE_MSG("invalid offset to mark glyph sets"); + return Error("invalid offset to mark glyph sets"); } - if (!ParseMarkGlyphSetsDefTable(font, - data + offset_mark_glyph_sets_def, - length - offset_mark_glyph_sets_def, - num_glyphs)) { - return OTS_FAILURE_MSG("Invalid mark glyph sets"); + if (!ParseMarkGlyphSetsDefTable(data + offset_mark_glyph_sets_def, + length - offset_mark_glyph_sets_def)) { + return Error("Invalid mark glyph sets"); } - gdef->has_mark_glyph_sets_def = true; } - gdef->data = data; - gdef->length = length; - return true; -} - -bool ots_gdef_should_serialise(Font *font) { - return font->gdef != NULL && font->gdef->data != NULL; -} -bool ots_gdef_serialise(OTSStream *out, Font *font) { - if (!out->Write(font->gdef->data, font->gdef->length)) { - return OTS_FAILURE_MSG("Failed to write GDEF table"); + if (item_var_store_offset) { + if (item_var_store_offset >= length || + item_var_store_offset < gdef_header_end) { + return Error("invalid offset to item variation store"); + } + if (!ParseItemVariationStore(GetFont(), data + item_var_store_offset, + length - item_var_store_offset)) { + return Error("Invalid item variation store"); + } } + this->m_data = data; + this->m_length = length; return true; } -void ots_gdef_reuse(Font *font, Font *other) { - font->gdef = other->gdef; - font->gdef_reused = true; -} +bool OpenTypeGDEF::Serialize(OTSStream *out) { + if (!out->Write(this->m_data, this->m_length)) { + return Error("Failed to write table"); + } -void ots_gdef_free(Font *font) { - delete font->gdef; + return true; } } // namespace ots - -#undef TABLE_NAME |