The Tor Browser: comparison gfx/ots/src/math.cc

--1:000000000000
+:d11f25a73563
+// Copyright (c) 2014 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.
+// We use an underscore to avoid confusion with the standard math.h library.
+#include "math_.h"
+#include <limits>
+#include <vector>
+#include "layout.h"
+#include "maxp.h"
+// MATH - The MATH Table
+// The specification is not yet public but has been submitted to the MPEG group
+// in response to the 'Call for Proposals for ISO/IEC 14496-22 "Open Font
+// Format" Color Font Technology and MATH layout support'. Meanwhile, you can
+// contact Microsoft's engineer Murray Sargent to obtain a copy.
+#define TABLE_NAME "MATH"
+namespace {
+// The size of MATH header.
+// Version
+// MathConstants
+// MathGlyphInfo
+// MathVariants
+const unsigned kMathHeaderSize = 4 + 3 * 2;
+// The size of the MathGlyphInfo header.
+// MathItalicsCorrectionInfo
+// MathTopAccentAttachment
+// ExtendedShapeCoverage
+// MathKernInfo
+const unsigned kMathGlyphInfoHeaderSize = 4 * 2;
+// The size of the MathValueRecord.
+// Value
+// DeviceTable
+const unsigned kMathValueRecordSize = 2 * 2;
+// The size of the GlyphPartRecord.
+// glyph
+// StartConnectorLength
+// EndConnectorLength
+// FullAdvance
+// PartFlags
+const unsigned kGlyphPartRecordSize = 5 * 2;
+// Shared Table: MathValueRecord
+bool ParseMathValueRecord(const ots::OpenTypeFile *file,
+ots::Buffer* subtable, const uint8_t *data,
+const size_t length) {
+// Check the Value field.
+if (!subtable->Skip(2)) {
+return OTS_FAILURE();
+}
+// Check the offset to device table.
+uint16_t offset = 0;
+if (!subtable->ReadU16(&offset)) {
+return OTS_FAILURE();
+}
+if (offset) {
+if (offset >= length) {
+return OTS_FAILURE();
+}
+if (!ots::ParseDeviceTable(file, data + offset, length - offset)) {
+return OTS_FAILURE();
+}
+}
+return true;
+}
+bool ParseMathConstantsTable(const ots::OpenTypeFile *file,
+const uint8_t *data, size_t length) {
+ots::Buffer subtable(data, length);
+// Part 1: int16 or uint16 constants.
+//  ScriptPercentScaleDown
+//  ScriptScriptPercentScaleDown
+//  DelimitedSubFormulaMinHeight
+//  DisplayOperatorMinHeight
+if (!subtable.Skip(4 * 2)) {
+return OTS_FAILURE();
+}
+// Part 2: MathValueRecord constants.
+// MathLeading
+// AxisHeight
+// AccentBaseHeight
+// FlattenedAccentBaseHeight
+// SubscriptShiftDown
+// SubscriptTopMax
+// SubscriptBaselineDropMin
+// SuperscriptShiftUp
+// SuperscriptShiftUpCramped
+// SuperscriptBottomMin
+//
+// SuperscriptBaselineDropMax
+// SubSuperscriptGapMin
+// SuperscriptBottomMaxWithSubscript
+// SpaceAfterScript
+// UpperLimitGapMin
+// UpperLimitBaselineRiseMin
+// LowerLimitGapMin
+// LowerLimitBaselineDropMin
+// StackTopShiftUp
+// StackTopDisplayStyleShiftUp
+//
+// StackBottomShiftDown
+// StackBottomDisplayStyleShiftDown
+// StackGapMin
+// StackDisplayStyleGapMin
+// StretchStackTopShiftUp
+// StretchStackBottomShiftDown
+// StretchStackGapAboveMin
+// StretchStackGapBelowMin
+// FractionNumeratorShiftUp
+// FractionNumeratorDisplayStyleShiftUp
+//
+// FractionDenominatorShiftDown
+// FractionDenominatorDisplayStyleShiftDown
+// FractionNumeratorGapMin
+// FractionNumDisplayStyleGapMin
+// FractionRuleThickness
+// FractionDenominatorGapMin
+// FractionDenomDisplayStyleGapMin
+// SkewedFractionHorizontalGap
+// SkewedFractionVerticalGap
+// OverbarVerticalGap
+//
+// OverbarRuleThickness
+// OverbarExtraAscender
+// UnderbarVerticalGap
+// UnderbarRuleThickness
+// UnderbarExtraDescender
+// RadicalVerticalGap
+// RadicalDisplayStyleVerticalGap
+// RadicalRuleThickness
+// RadicalExtraAscender
+// RadicalKernBeforeDegree
+//
+// RadicalKernAfterDegree
+for (unsigned i = 0; i < static_cast<unsigned>(51); ++i) {
+if (!ParseMathValueRecord(file, &subtable, data, length)) {
+return OTS_FAILURE();
+}
+}
+// Part 3: uint16 constant
+// RadicalDegreeBottomRaisePercent
+if (!subtable.Skip(2)) {
+return OTS_FAILURE();
+}
+return true;
+}
+bool ParseMathValueRecordSequenceForGlyphs(const ots::OpenTypeFile *file,
+ots::Buffer* subtable,
+const uint8_t *data,
+const size_t length,
+const uint16_t num_glyphs) {
+// Check the header.
+uint16_t offset_coverage = 0;
+uint16_t sequence_count = 0;
+if (!subtable->ReadU16(&offset_coverage) ||
+!subtable->ReadU16(&sequence_count)) {
+return OTS_FAILURE();
+}
+const unsigned sequence_end = static_cast<unsigned>(2 * 2) +
+sequence_count * kMathValueRecordSize;
+if (sequence_end > std::numeric_limits<uint16_t>::max()) {
+return OTS_FAILURE();
+}
+// Check coverage table.
+if (offset_coverage < sequence_end || offset_coverage >= length) {
+return OTS_FAILURE();
+}
+if (!ots::ParseCoverageTable(file, data + offset_coverage,
+length - offset_coverage,
+num_glyphs, sequence_count)) {
+return OTS_FAILURE();
+}
+// Check sequence.
+for (unsigned i = 0; i < sequence_count; ++i) {
+if (!ParseMathValueRecord(file, subtable, data, length)) {
+return OTS_FAILURE();
+}
+}
+return true;
+}
+bool ParseMathItalicsCorrectionInfoTable(const ots::OpenTypeFile *file,
+const uint8_t *data,
+size_t length,
+const uint16_t num_glyphs) {
+ots::Buffer subtable(data, length);
+return ParseMathValueRecordSequenceForGlyphs(file, &subtable, data, length,
+num_glyphs);
+}
+bool ParseMathTopAccentAttachmentTable(const ots::OpenTypeFile *file,
+const uint8_t *data,
+size_t length,
+const uint16_t num_glyphs) {
+ots::Buffer subtable(data, length);
+return ParseMathValueRecordSequenceForGlyphs(file, &subtable, data, length,
+num_glyphs);
+}
+bool ParseMathKernTable(const ots::OpenTypeFile *file,
+const uint8_t *data, size_t length) {
+ots::Buffer subtable(data, length);
+// Check the Height count.
+uint16_t height_count = 0;
+if (!subtable.ReadU16(&height_count)) {
+return OTS_FAILURE();
+}
+// Check the Correction Heights.
+for (unsigned i = 0; i < height_count; ++i) {
+if (!ParseMathValueRecord(file, &subtable, data, length)) {
+return OTS_FAILURE();
+}
+}
+// Check the Kern Values.
+for (unsigned i = 0; i <= height_count; ++i) {
+if (!ParseMathValueRecord(file, &subtable, data, length)) {
+return OTS_FAILURE();
+}
+}
+return true;
+}
+bool ParseMathKernInfoTable(const ots::OpenTypeFile *file,
+const uint8_t *data, size_t length,
+const uint16_t num_glyphs) {
+ots::Buffer subtable(data, length);
+// Check the header.
+uint16_t offset_coverage = 0;
+uint16_t sequence_count = 0;
+if (!subtable.ReadU16(&offset_coverage) ||
+!subtable.ReadU16(&sequence_count)) {
+return OTS_FAILURE();
+}
+const unsigned sequence_end = static_cast<unsigned>(2 * 2) +
+sequence_count * 4 * 2;
+if (sequence_end > std::numeric_limits<uint16_t>::max()) {
+return OTS_FAILURE();
+}
+// Check coverage table.
+if (offset_coverage < sequence_end || offset_coverage >= length) {
+return OTS_FAILURE();
+}
+if (!ots::ParseCoverageTable(file, data + offset_coverage, length - offset_coverage,
+num_glyphs, sequence_count)) {
+return OTS_FAILURE();
+}
+// Check sequence of MathKernInfoRecord
+for (unsigned i = 0; i < sequence_count; ++i) {
+// Check TopRight, TopLeft, BottomRight and BottomLeft Math Kern.
+for (unsigned j = 0; j < 4; ++j) {
+uint16_t offset_math_kern = 0;
+if (!subtable.ReadU16(&offset_math_kern)) {
+return OTS_FAILURE();
+}
+if (offset_math_kern) {
+if (offset_math_kern < sequence_end || offset_math_kern >= length ||
+!ParseMathKernTable(file, data + offset_math_kern,
+length - offset_math_kern)) {
+return OTS_FAILURE();
+}
+}
+}
+}
+return true;
+}
+bool ParseMathGlyphInfoTable(const ots::OpenTypeFile *file,
+const uint8_t *data, size_t length,
+const uint16_t num_glyphs) {
+ots::Buffer subtable(data, length);
+// Check Header.
+uint16_t offset_math_italics_correction_info = 0;
+uint16_t offset_math_top_accent_attachment = 0;
+uint16_t offset_extended_shaped_coverage = 0;
+uint16_t offset_math_kern_info = 0;
+if (!subtable.ReadU16(&offset_math_italics_correction_info) ||
+!subtable.ReadU16(&offset_math_top_accent_attachment) ||
+!subtable.ReadU16(&offset_extended_shaped_coverage) ||
+!subtable.ReadU16(&offset_math_kern_info)) {
+return OTS_FAILURE();
+}
+// Check subtables.
+// The specification does not say whether the offsets for
+// MathItalicsCorrectionInfo, MathTopAccentAttachment and MathKernInfo may
+// be NULL, but that's the case in some fonts (e.g STIX) so we accept that.
+if (offset_math_italics_correction_info) {
+if (offset_math_italics_correction_info >= length ||
+offset_math_italics_correction_info < kMathGlyphInfoHeaderSize ||
+!ParseMathItalicsCorrectionInfoTable(
+file, data + offset_math_italics_correction_info,
+length - offset_math_italics_correction_info,
+num_glyphs)) {
+return OTS_FAILURE();
+}
+}
+if (offset_math_top_accent_attachment) {
+if (offset_math_top_accent_attachment >= length ||
+offset_math_top_accent_attachment < kMathGlyphInfoHeaderSize ||
+!ParseMathTopAccentAttachmentTable(file, data +
+offset_math_top_accent_attachment,
+length -
+offset_math_top_accent_attachment,
+num_glyphs)) {
+return OTS_FAILURE();
+}
+}
+if (offset_extended_shaped_coverage) {
+if (offset_extended_shaped_coverage >= length ||
+offset_extended_shaped_coverage < kMathGlyphInfoHeaderSize ||
+!ots::ParseCoverageTable(file, data + offset_extended_shaped_coverage,
+length - offset_extended_shaped_coverage,
+num_glyphs)) {
+return OTS_FAILURE();
+}
+}
+if (offset_math_kern_info) {
+if (offset_math_kern_info >= length ||
+offset_math_kern_info < kMathGlyphInfoHeaderSize ||
+!ParseMathKernInfoTable(file, data + offset_math_kern_info,
+length - offset_math_kern_info, num_glyphs)) {
+return OTS_FAILURE();
+}
+}
+return true;
+}
+bool ParseGlyphAssemblyTable(const ots::OpenTypeFile *file,
+const uint8_t *data,
+size_t length, const uint16_t num_glyphs) {
+ots::Buffer subtable(data, length);
+// Check the header.
+uint16_t part_count = 0;
+if (!ParseMathValueRecord(file, &subtable, data, length) ||
+!subtable.ReadU16(&part_count)) {
+return OTS_FAILURE();
+}
+const unsigned sequence_end = kMathValueRecordSize +
+static_cast<unsigned>(2) + part_count * kGlyphPartRecordSize;
+if (sequence_end > std::numeric_limits<uint16_t>::max()) {
+return OTS_FAILURE();
+}
+// Check the sequence of GlyphPartRecord.
+for (unsigned i = 0; i < part_count; ++i) {
+uint16_t glyph = 0;
+uint16_t part_flags = 0;
+if (!subtable.ReadU16(&glyph) ||
+!subtable.Skip(2 * 3) ||
+!subtable.ReadU16(&part_flags)) {
+return OTS_FAILURE();
+}
+if (glyph >= num_glyphs) {
+OTS_WARNING("bad glyph ID: %u", glyph);
+return OTS_FAILURE();
+}
+if (part_flags & ~0x00000001) {
+OTS_WARNING("unknown part flag: %u", part_flags);
+return OTS_FAILURE();
+}
+}
+return true;
+}
+bool ParseMathGlyphConstructionTable(const ots::OpenTypeFile *file,
+const uint8_t *data,
+size_t length, const uint16_t num_glyphs) {
+ots::Buffer subtable(data, length);
+// Check the header.
+uint16_t offset_glyph_assembly = 0;
+uint16_t variant_count = 0;
+if (!subtable.ReadU16(&offset_glyph_assembly) ||
+!subtable.ReadU16(&variant_count)) {
+return OTS_FAILURE();
+}
+const unsigned sequence_end = static_cast<unsigned>(2 * 2) +
+variant_count * 2 * 2;
+if (sequence_end > std::numeric_limits<uint16_t>::max()) {
+return OTS_FAILURE();
+}
+// Check the GlyphAssembly offset.
+if (offset_glyph_assembly) {
+if (offset_glyph_assembly >= length ||
+offset_glyph_assembly < sequence_end) {
+return OTS_FAILURE();
+}
+if (!ParseGlyphAssemblyTable(file, data + offset_glyph_assembly,
+length - offset_glyph_assembly, num_glyphs)) {
+return OTS_FAILURE();
+}
+}
+// Check the sequence of MathGlyphVariantRecord.
+for (unsigned i = 0; i < variant_count; ++i) {
+uint16_t glyph = 0;
+if (!subtable.ReadU16(&glyph) ||
+!subtable.Skip(2)) {
+return OTS_FAILURE();
+}
+if (glyph >= num_glyphs) {
+OTS_WARNING("bad glyph ID: %u", glyph);
+return OTS_FAILURE();
+}
+}
+return true;
+}
+bool ParseMathGlyphConstructionSequence(const ots::OpenTypeFile *file,
+ots::Buffer* subtable,
+const uint8_t *data,
+size_t length,
+const uint16_t num_glyphs,
+uint16_t offset_coverage,
+uint16_t glyph_count,
+const unsigned sequence_end) {
+// Check coverage table.
+if (offset_coverage < sequence_end || offset_coverage >= length) {
+return OTS_FAILURE();
+}
+if (!ots::ParseCoverageTable(file, data + offset_coverage,
+length - offset_coverage,
+num_glyphs, glyph_count)) {
+return OTS_FAILURE();
+}
+// Check sequence of MathGlyphConstruction.
+for (unsigned i = 0; i < glyph_count; ++i) {
+uint16_t offset_glyph_construction = 0;
+if (!subtable->ReadU16(&offset_glyph_construction)) {
+return OTS_FAILURE();
+}
+if (offset_glyph_construction < sequence_end ||
+offset_glyph_construction >= length ||
+!ParseMathGlyphConstructionTable(file, data + offset_glyph_construction,
+length - offset_glyph_construction,
+num_glyphs)) {
+return OTS_FAILURE();
+}
+}
+return true;
+}
+bool ParseMathVariantsTable(const ots::OpenTypeFile *file,
+const uint8_t *data,
+size_t length, const uint16_t num_glyphs) {
+ots::Buffer subtable(data, length);
+// Check the header.
+uint16_t offset_vert_glyph_coverage = 0;
+uint16_t offset_horiz_glyph_coverage = 0;
+uint16_t vert_glyph_count = 0;
+uint16_t horiz_glyph_count = 0;
+if (!subtable.Skip(2) ||  // MinConnectorOverlap
+!subtable.ReadU16(&offset_vert_glyph_coverage) ||
+!subtable.ReadU16(&offset_horiz_glyph_coverage) ||
+!subtable.ReadU16(&vert_glyph_count) ||
+!subtable.ReadU16(&horiz_glyph_count)) {
+return OTS_FAILURE();
+}
+const unsigned sequence_end = 5 * 2 + vert_glyph_count * 2 +
+horiz_glyph_count * 2;
+if (sequence_end > std::numeric_limits<uint16_t>::max()) {
+return OTS_FAILURE();
+}
+if (!ParseMathGlyphConstructionSequence(file, &subtable, data, length, num_glyphs,
+offset_vert_glyph_coverage,
+vert_glyph_count,
+sequence_end) ||
+!ParseMathGlyphConstructionSequence(file, &subtable, data, length, num_glyphs,
+offset_horiz_glyph_coverage,
+horiz_glyph_count,
+sequence_end)) {
+return OTS_FAILURE();
+}
+return true;
+}
+}  // namespace
+#define DROP_THIS_TABLE \
+do { file->math->data = 0; file->math->length = 0; } while (0)
+namespace ots {
+bool ots_math_parse(OpenTypeFile *file, const uint8_t *data, size_t length) {
+// Grab the number of glyphs in the file from the maxp table to check
+// GlyphIDs in MATH table.
+if (!file->maxp) {
+return OTS_FAILURE();
+}
+const uint16_t num_glyphs = file->maxp->num_glyphs;
+Buffer table(data, length);
+OpenTypeMATH* math = new OpenTypeMATH;
+file->math = math;
+uint32_t version = 0;
+if (!table.ReadU32(&version)) {
+return OTS_FAILURE();
+}
+if (version != 0x00010000) {
+OTS_WARNING("bad MATH version");
+DROP_THIS_TABLE;
+return true;
+}
+uint16_t offset_math_constants = 0;
+uint16_t offset_math_glyph_info = 0;
+uint16_t offset_math_variants = 0;
+if (!table.ReadU16(&offset_math_constants) ||
+!table.ReadU16(&offset_math_glyph_info) ||
+!table.ReadU16(&offset_math_variants)) {
+return OTS_FAILURE();
+}
+if (offset_math_constants >= length ||
+offset_math_constants < kMathHeaderSize ||
+offset_math_glyph_info >= length ||
+offset_math_glyph_info < kMathHeaderSize ||
+offset_math_variants >= length ||
+offset_math_variants < kMathHeaderSize) {
+OTS_WARNING("bad offset in MATH header");
+DROP_THIS_TABLE;
+return true;
+}
+if (!ParseMathConstantsTable(file, data + offset_math_constants,
+length - offset_math_constants)) {
+DROP_THIS_TABLE;
+return true;
+}
+if (!ParseMathGlyphInfoTable(file, data + offset_math_glyph_info,
+length - offset_math_glyph_info, num_glyphs)) {
+DROP_THIS_TABLE;
+return true;
+}
+if (!ParseMathVariantsTable(file, data + offset_math_variants,
+length - offset_math_variants, num_glyphs)) {
+DROP_THIS_TABLE;
+return true;
+}
+math->data = data;
+math->length = length;
+return true;
+}
+bool ots_math_should_serialise(OpenTypeFile *file) {
+return file->math != NULL && file->math->data != NULL;
+}
+bool ots_math_serialise(OTSStream *out, OpenTypeFile *file) {
+if (!out->Write(file->math->data, file->math->length)) {
+return OTS_FAILURE();
+}
+return true;
+}
+void ots_math_free(OpenTypeFile *file) {
+delete file->math;
+}
+}  // namespace ots

The Tor Browser / file comparison

comparison: gfx/ots/src/math.cc

gfx/ots/src/math.cc