From 6bf0a5cb5034a7e684dcc3500e841785237ce2dd Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 19:32:43 +0200 Subject: Adding upstream version 1:115.7.0. Signed-off-by: Daniel Baumann --- gfx/ots/src/post.cc | 177 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 177 insertions(+) create mode 100644 gfx/ots/src/post.cc (limited to 'gfx/ots/src/post.cc') diff --git a/gfx/ots/src/post.cc b/gfx/ots/src/post.cc new file mode 100644 index 0000000000..2fb897250d --- /dev/null +++ b/gfx/ots/src/post.cc @@ -0,0 +1,177 @@ +// Copyright (c) 2009-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. + +#include "post.h" + +#include "maxp.h" + +// post - PostScript +// http://www.microsoft.com/typography/otspec/post.htm + +namespace ots { + +bool OpenTypePOST::Parse(const uint8_t *data, size_t length) { + Buffer table(data, length); + + if (!table.ReadU32(&this->version)) { + return Error("Failed to read table version"); + } + + if (this->version != 0x00010000 && + this->version != 0x00020000 && + this->version != 0x00030000) { + // 0x00025000 is deprecated. We don't accept it. + return Error("Unsupported table version 0x%x", this->version); + } + + if (!table.ReadU32(&this->italic_angle) || + !table.ReadS16(&this->underline) || + !table.ReadS16(&this->underline_thickness) || + !table.ReadU32(&this->is_fixed_pitch) || + // We don't care about the memory usage fields. We'll set all these to + // zero when serialising + !table.Skip(16)) { + return Error("Failed to read table header"); + } + + if (this->underline_thickness < 0) { + this->underline_thickness = 1; + } + + if (this->version == 0x00010000 || this->version == 0x00030000) { + return true; + } + + // We have a version 2 table with a list of Pascal strings at the end + + uint16_t num_glyphs = 0; + if (!table.ReadU16(&num_glyphs)) { + return Error("Failed to read numberOfGlyphs"); + } + + OpenTypeMAXP* maxp = static_cast + (GetFont()->GetTable(OTS_TAG_MAXP)); + if (!maxp) { + return Error("Missing required maxp table"); + } + + if (num_glyphs == 0) { + if (maxp->num_glyphs > 258) { + return Error("Can't have no glyphs in the post table if there are more " + "than 258 glyphs in the font"); + } + // workaround for fonts in http://www.fontsquirrel.com/fontface + // (e.g., yataghan.ttf). + this->version = 0x00010000; + return Warning("Table version is 1, but no glyph names are found"); + } + + if (num_glyphs != maxp->num_glyphs) { + // Note: Fixedsys500c.ttf seems to have inconsistent num_glyphs values. + return Error("Bad number of glyphs: %d", num_glyphs); + } + + this->glyph_name_index.resize(num_glyphs); + for (unsigned i = 0; i < num_glyphs; ++i) { + if (!table.ReadU16(&this->glyph_name_index[i])) { + return Error("Failed to read glyph name %d", i); + } + // Note: A strict interpretation of the specification requires name indexes + // are less than 32768. This, however, excludes fonts like unifont.ttf + // which cover all of unicode. + } + + // Now we have an array of Pascal strings. We have to check that they are all + // valid and read them in. + const size_t strings_offset = table.offset(); + const uint8_t *strings = data + strings_offset; + const uint8_t *strings_end = data + length; + + for (;;) { + if (strings == strings_end) break; + const unsigned string_length = *strings; + if (strings + 1 + string_length > strings_end) { + return Error("Bad string length %d", string_length); + } + if (std::memchr(strings + 1, '\0', string_length)) { + return Error("Bad string of length %d", string_length); + } + this->names.push_back( + std::string(reinterpret_cast(strings + 1), string_length)); + strings += 1 + string_length; + } + const unsigned num_strings = this->names.size(); + + // check that all the references are within bounds + for (unsigned i = 0; i < num_glyphs; ++i) { + unsigned offset = this->glyph_name_index[i]; + if (offset < 258) { + continue; + } + + offset -= 258; + if (offset >= num_strings) { + return Error("Bad string index %d", offset); + } + } + + return true; +} + +bool OpenTypePOST::Serialize(OTSStream *out) { + // OpenType with CFF glyphs must have v3 post table. + if (GetFont()->GetTable(OTS_TAG_CFF) && this->version != 0x00030000) { + Warning("Only version supported for fonts with CFF table is 0x00030000" + " not 0x%x", this->version); + this->version = 0x00030000; + } + + if (!out->WriteU32(this->version) || + !out->WriteU32(this->italic_angle) || + !out->WriteS16(this->underline) || + !out->WriteS16(this->underline_thickness) || + !out->WriteU32(this->is_fixed_pitch) || + !out->WriteU32(0) || + !out->WriteU32(0) || + !out->WriteU32(0) || + !out->WriteU32(0)) { + return Error("Failed to write post header"); + } + + if (this->version != 0x00020000) { + return true; // v1.0 and v3.0 does not have glyph names. + } + + const uint16_t num_indexes = + static_cast(this->glyph_name_index.size()); + if (num_indexes != this->glyph_name_index.size() || + !out->WriteU16(num_indexes)) { + return Error("Failed to write number of indices"); + } + + for (uint16_t i = 0; i < num_indexes; ++i) { + if (!out->WriteU16(this->glyph_name_index[i])) { + return Error("Failed to write name index %d", i); + } + } + + // Now we just have to write out the strings in the correct order + for (unsigned i = 0; i < this->names.size(); ++i) { + const std::string& s = this->names[i]; + const uint8_t string_length = static_cast(s.size()); + if (string_length != s.size() || + !out->Write(&string_length, 1)) { + return Error("Failed to write string %d", i); + } + // Some ttf fonts (e.g., frank.ttf on Windows Vista) have zero-length name. + // We allow them. + if (string_length > 0 && !out->Write(s.data(), string_length)) { + return Error("Failed to write string length for string %d", i); + } + } + + return true; +} + +} // namespace ots -- cgit v1.2.3