Update woff2 to 4e698b8

third_party/woff2/src/woff2_enc.cc

 // Copyright 2014 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.
 //
 // Library for converting TTF format font files to their WOFF2 versions.
 
 #include "./woff2_enc.h"
 
 #include <stdlib.h>
 #include <complex>
 #include <cstring>
 #include <limits>
 #include <string>
 #include <vector>
 
+#include "./encode.h"
 #include "./buffer.h"
-#include "./encode.h"
 #include "./font.h"
 #include "./normalize.h"
 #include "./round.h"
 #include "./store_bytes.h"
 #include "./table_tags.h"
 #include "./transform.h"
 #include "./variable_length.h"
 #include "./woff2_common.h"
 
+
 namespace woff2 {
 
 namespace {
 
+
 using std::string;
 using std::vector;
 
 
 const size_t kWoff2HeaderSize = 48;
 const size_t kWoff2EntrySize = 20;
 
+
 bool Compress(const uint8_t* data, const size_t len,
               uint8_t* result, uint32_t* result_len,
               brotli::BrotliParams::Mode mode, int quality) {
   size_t compressed_len = *result_len;
   brotli::BrotliParams params;
   params.mode = mode;
   params.quality = quality;
   if (brotli::BrotliCompressBuffer(params, len, data, &compressed_len, result)
       == 0) {
     return false;
@@ skipping 17 matching lines @@
 }
 
 int KnownTableIndex(uint32_t tag) {
   for (int i = 0; i < 63; ++i) {
     if (tag == kKnownTags[i]) return i;
   }
   return 63;
 }
 
 void StoreTableEntry(const Table& table, size_t* offset, uint8_t* dst) {
-  uint8_t flag_byte = KnownTableIndex(table.tag);
+  uint8_t flag_byte = (table.flags & 0xC0) | KnownTableIndex(table.tag);
   dst[(*offset)++] = flag_byte;
   // The index here is treated as a set of flag bytes because
   // bits 6 and 7 of the byte are reserved for future use as flags.
   // 0x3f or 63 means an arbitrary table tag.
   if ((flag_byte & 0x3f) == 0x3f) {
     StoreU32(table.tag, offset, dst);
   }
   StoreBase128(table.src_length, offset, dst);
   if ((table.flags & kWoff2FlagsTransform) != 0) {
     StoreBase128(table.transform_length, offset, dst);
   }
 }
 
 size_t TableEntrySize(const Table& table) {
   uint8_t flag_byte = KnownTableIndex(table.tag);
   size_t size = ((flag_byte & 0x3f) != 0x3f) ? 1 : 5;
   size += Base128Size(table.src_length);
   if ((table.flags & kWoff2FlagsTransform) != 0) {
      size += Base128Size(table.transform_length);
   }
   return size;
 }
 
 size_t ComputeWoff2Length(const FontCollection& font_collection,
                           const std::vector<Table>& tables,
                           std::map<uint32_t, uint16_t> index_by_offset,
+                          size_t compressed_data_length,
                           size_t extended_metadata_length) {
   size_t size = kWoff2HeaderSize;
 
   for (const auto& table : tables) {
     size += TableEntrySize(table);
   }
 
   // for collections only, collection tables
   if (font_collection.fonts.size() > 1) {
     size += 4;  // UInt32 Version of TTC Header
     size += Size255UShort(font_collection.fonts.size());  // 255UInt16 numFonts
 
     size += 4 * font_collection.fonts.size();  // UInt32 flavor for each
 
     for (const auto& font : font_collection.fonts) {
       size += Size255UShort(font.tables.size());  // 255UInt16 numTables
       for (const auto& entry : font.tables) {
         const Font::Table& table = entry.second;
         // no collection entry for xform table
         if (table.tag & 0x80808080) continue;
 
         uint16_t table_index = index_by_offset[table.offset];
         size += Size255UShort(table_index);  // 255UInt16 index entry
       }
     }
   }
 
   // compressed data
-  for (const auto& table : tables) {
-    size += table.dst_length;
-    size = Round4(size);
-  }
+  size += compressed_data_length;
+  size = Round4(size);
 
   size += extended_metadata_length;
   return size;
 }
 
 size_t ComputeTTFLength(const std::vector<Table>& tables) {
   size_t size = 12 + 16 * tables.size();  // sfnt header
   for (const auto& table : tables) {
     size += Round4(table.src_length);
   }
@@ skipping 56 matching lines @@
 }
 
 uint32_t CompressedBufferSize(uint32_t original_size) {
   return 1.2 * original_size + 10240;
 }
 
 bool TransformFontCollection(FontCollection* font_collection) {
   for (auto& font : font_collection->fonts) {
     if (!TransformGlyfAndLocaTables(&font)) {
 #ifdef FONT_COMPRESSION_BIN
-      fprintf(stderr, "Font transformation failed.\n");
+      fprintf(stderr, "glyf/loca transformation failed.\n");
 #endif
       return FONT_COMPRESSION_FAILURE();
     }
   }
 
   return true;
 }
 
 bool ConvertTTFToWOFF2(const uint8_t *data, size_t length,
                        uint8_t *result, size_t *result_length) {
@@ skipping 10 matching lines @@
 #ifdef FONT_COMPRESSION_BIN
     fprintf(stderr, "Parsing of the input font failed.\n");
 #endif
     return FONT_COMPRESSION_FAILURE();
   }
 
   if (!NormalizeFontCollection(&font_collection)) {
     return FONT_COMPRESSION_FAILURE();
   }
 
-  if (!TransformFontCollection(&font_collection)) {
+  if (params.allow_transforms && !TransformFontCollection(&font_collection)) {
     return FONT_COMPRESSION_FAILURE();
+  } else {
+    // glyf/loca use 11 to flag "not transformed"
+    for (auto& font : font_collection.fonts) {
+      Font::Table* glyf_table = font.FindTable(kGlyfTableTag);
+      Font::Table* loca_table = font.FindTable(kLocaTableTag);
+      if (glyf_table) {
+        glyf_table->flag_byte |= 0xc0;
+      }
+      if (loca_table) {
+        loca_table->flag_byte |= 0xc0;
+      }
+    }
   }
 
   // Although the compressed size of each table in the final woff2 file won't
   // be larger than its transform_length, we have to allocate a large enough
   // buffer for the compressor, since the compressor can potentially increase
   // the size. If the compressor overflows this, it should return false and
   // then this function will also return false.
 
   size_t total_transform_length = 0;
   for (const auto& font : font_collection.fonts) {
@@ skipping 21 matching lines @@
   if (!Woff2Compress(transform_buf.data(), total_transform_length,
                      &compression_buf[0],
                      &total_compressed_length,
                      params.brotli_quality)) {
 #ifdef FONT_COMPRESSION_BIN
     fprintf(stderr, "Compression of combined table failed.\n");
 #endif
     return FONT_COMPRESSION_FAILURE();
   }
 
+#ifdef FONT_COMPRESSION_BIN
+  fprintf(stderr, "Compressed %zu to %u.\n", total_transform_length,
+          total_compressed_length);
+#endif
+
   // Compress the extended metadata
   // TODO(user): how does this apply to collections
   uint32_t compressed_metadata_buf_length =
     CompressedBufferSize(params.extended_metadata.length());
   std::vector<uint8_t> compressed_metadata_buf(compressed_metadata_buf_length);
 
   if (params.extended_metadata.length() > 0) {
     if (!TextCompress((const uint8_t*)params.extended_metadata.data(),
                       params.extended_metadata.length(),
                       compressed_metadata_buf.data(),
@@ skipping 20 matching lines @@
       }
 
       if (index_by_offset.find(src_table.offset) == index_by_offset.end()) {
         index_by_offset[src_table.offset] = tables.size();
       } else {
         return false;
       }
 
       Table table;
       table.tag = src_table.tag;
-      table.flags = 0;
+      table.flags = src_table.flag_byte;
       table.src_length = src_table.length;
       table.transform_length = src_table.length;
       const uint8_t* transformed_data = src_table.data;
       const Font::Table* transformed_table =
           font.FindTable(src_table.tag ^ 0x80808080);
       if (transformed_table != NULL) {
+        table.flags = transformed_table->flag_byte;
         table.flags |= kWoff2FlagsTransform;
         table.transform_length = transformed_table->length;
         transformed_data = transformed_table->data;
-      }
-      if (tables.empty()) {
-        table.dst_length = total_compressed_length;
-        table.dst_data = &compression_buf[0];
-      } else {
-        table.dst_length = 0;
-        table.dst_data = NULL;
+
       }
       tables.push_back(table);
     }
   }
 
   size_t woff2_length = ComputeWoff2Length(font_collection, tables,
-      index_by_offset, compressed_metadata_buf_length);
+      index_by_offset, total_compressed_length, compressed_metadata_buf_length);
   if (woff2_length > *result_length) {
 #ifdef FONT_COMPRESSION_BIN
     fprintf(stderr, "Result allocation was too small (%zd vs %zd bytes).\n",
            *result_length, woff2_length);
 #endif
     return FONT_COMPRESSION_FAILURE();
   }
   *result_length = woff2_length;
 
   const Font& first_font = font_collection.fonts[0];
@@ skipping 69 matching lines @@
         }
         uint16_t index = index_by_offset[table_offset];
         Store255UShort(index, &offset, result);
 
       }
 
     }
   }
 
   // compressed data format (http://www.w3.org/TR/WOFF2/#table_format)
-  for (const auto& table : tables) {
-    StoreBytes(table.dst_data, table.dst_length, &offset, result);
-    offset = Round4(offset);
-  }
+
+  StoreBytes(&compression_buf[0], total_compressed_length, &offset, result);
+  offset = Round4(offset);
+
   StoreBytes(compressed_metadata_buf.data(), compressed_metadata_buf_length,
              &offset, result);
 
   if (*result_length != offset) {
 #ifdef FONT_COMPRESSION_BIN
     fprintf(stderr, "Mismatch between computed and actual length "
             "(%zd vs %zd)\n", *result_length, offset);
 #endif
     return FONT_COMPRESSION_FAILURE();
   }
   return true;
 }
 
 } // namespace woff2