Update OTS to revision a7a3b94

third_party/ots/src/glyf.cc

 // 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::OpenTypeFile *file,
+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");
   }
@@ skipping 36 matching lines @@
   }
 
   *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::OpenTypeFile *file, const uint8_t *data,
+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 = file->glyf;
+  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 ((file->maxp->version_1) &&
-      (file->maxp->max_size_glyf_instructions < 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(file,
+    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);
     }
   }
 
@@ skipping 16 matching lines @@
   *new_size
       = gly_header_length + flags_count_physical + xy_coordinates_length + bytecode_length;
 
   return true;
 }
 
 }  // namespace
 
 namespace ots {
 
-bool ots_glyf_parse(OpenTypeFile *file, const uint8_t *data, size_t length) {
+bool ots_glyf_parse(Font *font, const uint8_t *data, size_t length) {
   Buffer table(data, length);
 
-  if (!file->maxp || !file->loca || !file->head) {
+  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;
-  file->glyf = glyf;
+  font->glyf = glyf;
 
-  const unsigned num_glyphs = file->maxp->num_glyphs;
-  std::vector<uint32_t> &offsets = file->loca->offsets;
+  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];
@@ skipping 41 matching lines @@
       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(file, data, &table,
+      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)) &&
-      (file->head->index_to_loc_format != 1)) {
+      (font->head->index_to_loc_format != 1)) {
     OTS_WARNING("2-bytes indexing is not possible (due to the padding above)");
-    file->head->index_to_loc_format = 1;
+    font->head->index_to_loc_format = 1;
   }
 
-  file->loca->offsets = resulting_offsets;
+  font->loca->offsets = resulting_offsets;
   return true;
 }
 
-bool ots_glyf_should_serialise(OpenTypeFile *file) {
-  return file->glyf != NULL;
+bool ots_glyf_should_serialise(Font *font) {
+  return font->glyf != NULL;
 }
 
-bool ots_glyf_serialise(OTSStream *out, OpenTypeFile *file) {
-  const OpenTypeGLYF *glyf = file->glyf;
+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_free(OpenTypeFile *file) {
-  delete file->glyf;
+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