summaryrefslogtreecommitdiffstats
path: root/modules/woff2/src/normalize.cc
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /modules/woff2/src/normalize.cc
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'modules/woff2/src/normalize.cc')
-rw-r--r--modules/woff2/src/normalize.cc322
1 files changed, 322 insertions, 0 deletions
diff --git a/modules/woff2/src/normalize.cc b/modules/woff2/src/normalize.cc
new file mode 100644
index 000000000..b538b91a8
--- /dev/null
+++ b/modules/woff2/src/normalize.cc
@@ -0,0 +1,322 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Glyph normalization
+
+#include "./normalize.h"
+
+#include <inttypes.h>
+#include <stddef.h>
+
+#include "./buffer.h"
+#include "./port.h"
+#include "./font.h"
+#include "./glyph.h"
+#include "./round.h"
+#include "./store_bytes.h"
+#include "./table_tags.h"
+#include "./woff2_common.h"
+
+namespace woff2 {
+
+namespace {
+
+void StoreLoca(int index_fmt, uint32_t value, size_t* offset, uint8_t* dst) {
+ if (index_fmt == 0) {
+ Store16(value >> 1, offset, dst);
+ } else {
+ StoreU32(value, offset, dst);
+ }
+}
+
+} // namespace
+
+namespace {
+
+bool WriteNormalizedLoca(int index_fmt, int num_glyphs, Font* font) {
+ Font::Table* glyf_table = font->FindTable(kGlyfTableTag);
+ Font::Table* loca_table = font->FindTable(kLocaTableTag);
+
+ int glyph_sz = index_fmt == 0 ? 2 : 4;
+ loca_table->buffer.resize(Round4(num_glyphs + 1) * glyph_sz);
+ loca_table->length = (num_glyphs + 1) * glyph_sz;
+
+ uint8_t* glyf_dst = &glyf_table->buffer[0];
+ uint8_t* loca_dst = &loca_table->buffer[0];
+ uint32_t glyf_offset = 0;
+ size_t loca_offset = 0;
+
+ for (int i = 0; i < num_glyphs; ++i) {
+ StoreLoca(index_fmt, glyf_offset, &loca_offset, loca_dst);
+ Glyph glyph;
+ const uint8_t* glyph_data;
+ size_t glyph_size;
+ if (!GetGlyphData(*font, i, &glyph_data, &glyph_size) ||
+ (glyph_size > 0 && !ReadGlyph(glyph_data, glyph_size, &glyph))) {
+ return FONT_COMPRESSION_FAILURE();
+ }
+ size_t glyf_dst_size = glyf_table->buffer.size() - glyf_offset;
+ if (!StoreGlyph(glyph, glyf_dst + glyf_offset, &glyf_dst_size)) {
+ return FONT_COMPRESSION_FAILURE();
+ }
+ glyf_dst_size = Round4(glyf_dst_size);
+ if (glyf_dst_size > std::numeric_limits<uint32_t>::max() ||
+ glyf_offset + static_cast<uint32_t>(glyf_dst_size) < glyf_offset ||
+ (index_fmt == 0 && glyf_offset + glyf_dst_size >= (1UL << 17))) {
+ return FONT_COMPRESSION_FAILURE();
+ }
+ glyf_offset += glyf_dst_size;
+ }
+ if (glyf_offset == 0) {
+ return false;
+ }
+
+ StoreLoca(index_fmt, glyf_offset, &loca_offset, loca_dst);
+
+ glyf_table->buffer.resize(glyf_offset);
+ glyf_table->data = &glyf_table->buffer[0];
+ glyf_table->length = glyf_offset;
+ loca_table->data = &loca_table->buffer[0];
+
+ return true;
+}
+
+} // namespace
+
+namespace {
+
+bool MakeEditableBuffer(Font* font, int tableTag) {
+ Font::Table* table = font->FindTable(tableTag);
+ if (table == NULL) {
+ return FONT_COMPRESSION_FAILURE();
+ }
+ if (table->IsReused()) {
+ return true;
+ }
+ int sz = Round4(table->length);
+ table->buffer.resize(sz);
+ uint8_t* buf = &table->buffer[0];
+ memcpy(buf, table->data, sz);
+ table->data = buf;
+ return true;
+}
+
+} // namespace
+
+bool NormalizeGlyphs(Font* font) {
+ Font::Table* head_table = font->FindTable(kHeadTableTag);
+ Font::Table* glyf_table = font->FindTable(kGlyfTableTag);
+ Font::Table* loca_table = font->FindTable(kLocaTableTag);
+ if (head_table == NULL) {
+ return FONT_COMPRESSION_FAILURE();
+ }
+ // If you don't have glyf/loca this transform isn't very interesting
+ if (loca_table == NULL && glyf_table == NULL) {
+ return true;
+ }
+ // It would be best if you didn't have just one of glyf/loca
+ if ((glyf_table == NULL) != (loca_table == NULL)) {
+ return FONT_COMPRESSION_FAILURE();
+ }
+ // Must share neither or both loca & glyf
+ if (loca_table->IsReused() != glyf_table->IsReused()) {
+ return FONT_COMPRESSION_FAILURE();
+ }
+ if (loca_table->IsReused()) {
+ return true;
+ }
+
+ int index_fmt = head_table->data[51];
+ int num_glyphs = NumGlyphs(*font);
+
+ // We need to allocate a bit more than its original length for the normalized
+ // glyf table, since it can happen that the glyphs in the original table are
+ // 2-byte aligned, while in the normalized table they are 4-byte aligned.
+ // That gives a maximum of 2 bytes increase per glyph. However, there is no
+ // theoretical guarantee that the total size of the flags plus the coordinates
+ // is the smallest possible in the normalized version, so we have to allow
+ // some general overhead.
+ // TODO(user) Figure out some more precise upper bound on the size of
+ // the overhead.
+ size_t max_normalized_glyf_size = 1.1 * glyf_table->length + 2 * num_glyphs;
+
+ glyf_table->buffer.resize(max_normalized_glyf_size);
+
+ // if we can't write a loca using short's (index_fmt 0)
+ // try again using longs (index_fmt 1)
+ if (!WriteNormalizedLoca(index_fmt, num_glyphs, font)) {
+ if (index_fmt != 0) {
+ return FONT_COMPRESSION_FAILURE();
+ }
+
+ // Rewrite loca with 4-byte entries & update head to match
+ index_fmt = 1;
+ if (!WriteNormalizedLoca(index_fmt, num_glyphs, font)) {
+ return FONT_COMPRESSION_FAILURE();
+ }
+ head_table->buffer[51] = 1;
+ }
+
+ return true;
+}
+
+bool NormalizeOffsets(Font* font) {
+ uint32_t offset = 12 + 16 * font->num_tables;
+ for (auto tag : font->OutputOrderedTags()) {
+ auto& table = font->tables[tag];
+ table.offset = offset;
+ offset += Round4(table.length);
+ }
+ return true;
+}
+
+namespace {
+
+uint32_t ComputeHeaderChecksum(const Font& font) {
+ uint32_t checksum = font.flavor;
+ uint16_t max_pow2 = font.num_tables ? Log2Floor(font.num_tables) : 0;
+ uint16_t search_range = max_pow2 ? 1 << (max_pow2 + 4) : 0;
+ uint16_t range_shift = (font.num_tables << 4) - search_range;
+ checksum += (font.num_tables << 16 | search_range);
+ checksum += (max_pow2 << 16 | range_shift);
+ for (const auto& i : font.tables) {
+ const Font::Table* table = &i.second;
+ if (table->IsReused()) {
+ table = table->reuse_of;
+ }
+ checksum += table->tag;
+ checksum += table->checksum;
+ checksum += table->offset;
+ checksum += table->length;
+ }
+ return checksum;
+}
+
+} // namespace
+
+bool FixChecksums(Font* font) {
+ Font::Table* head_table = font->FindTable(kHeadTableTag);
+ if (head_table == NULL) {
+ return FONT_COMPRESSION_FAILURE();
+ }
+ if (head_table->reuse_of != NULL) {
+ head_table = head_table->reuse_of;
+ }
+ if (head_table->length < 12) {
+ return FONT_COMPRESSION_FAILURE();
+ }
+
+ uint8_t* head_buf = &head_table->buffer[0];
+ size_t offset = 8;
+ StoreU32(0, &offset, head_buf);
+ uint32_t file_checksum = 0;
+ uint32_t head_checksum = 0;
+ for (auto& i : font->tables) {
+ Font::Table* table = &i.second;
+ if (table->IsReused()) {
+ table = table->reuse_of;
+ }
+ table->checksum = ComputeULongSum(table->data, table->length);
+ file_checksum += table->checksum;
+
+ if (table->tag == kHeadTableTag) {
+ head_checksum = table->checksum;
+ }
+ }
+
+ file_checksum += ComputeHeaderChecksum(*font);
+ offset = 8;
+ StoreU32(0xb1b0afba - file_checksum, &offset, head_buf);
+
+ return true;
+}
+
+namespace {
+bool MarkTransformed(Font* font) {
+ Font::Table* head_table = font->FindTable(kHeadTableTag);
+ if (head_table == NULL) {
+ return FONT_COMPRESSION_FAILURE();
+ }
+ if (head_table->reuse_of != NULL) {
+ head_table = head_table->reuse_of;
+ }
+ if (head_table->length < 17) {
+ return FONT_COMPRESSION_FAILURE();
+ }
+ // set bit 11 of head table 'flags' to indicate that font has undergone
+ // lossless modifying transform
+ int head_flags = head_table->data[16];
+ head_table->buffer[16] = head_flags | 0x08;
+ return true;
+}
+} // namespace
+
+
+bool NormalizeWithoutFixingChecksums(Font* font) {
+ return (MakeEditableBuffer(font, kHeadTableTag) &&
+ RemoveDigitalSignature(font) &&
+ MarkTransformed(font) &&
+ NormalizeGlyphs(font) &&
+ NormalizeOffsets(font));
+}
+
+bool NormalizeFont(Font* font) {
+ return (NormalizeWithoutFixingChecksums(font) &&
+ FixChecksums(font));
+}
+
+bool NormalizeFontCollection(FontCollection* font_collection) {
+ if (font_collection->fonts.size() == 1) {
+ return NormalizeFont(&font_collection->fonts[0]);
+ }
+
+ uint32_t offset = CollectionHeaderSize(font_collection->header_version,
+ font_collection->fonts.size());
+ for (auto& font : font_collection->fonts) {
+ if (!NormalizeWithoutFixingChecksums(&font)) {
+#ifdef FONT_COMPRESSION_BIN
+ fprintf(stderr, "Font normalization failed.\n");
+#endif
+ return FONT_COMPRESSION_FAILURE();
+ }
+ offset += kSfntHeaderSize + kSfntEntrySize * font.num_tables;
+ }
+
+ // Start table offsets after TTC Header and Sfnt Headers
+ for (auto& font : font_collection->fonts) {
+ for (auto tag : font.OutputOrderedTags()) {
+ Font::Table& table = font.tables[tag];
+ if (table.IsReused()) {
+ table.offset = table.reuse_of->offset;
+ } else {
+ table.offset = offset;
+ offset += Round4(table.length);
+ }
+ }
+ }
+
+ // Now we can fix the checksums
+ for (auto& font : font_collection->fonts) {
+ if (!FixChecksums(&font)) {
+#ifdef FONT_COMPRESSION_BIN
+ fprintf(stderr, "Failed to fix checksums\n");
+#endif
+ return FONT_COMPRESSION_FAILURE();
+ }
+ }
+
+ return true;
+}
+
+} // namespace woff2