[OTS] Integrate WOFF 2.0 algorithm into OTS

src/ots.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 "ots.h"
 
 #include <sys/types.h>
 #include <zlib.h>
 
 #include <algorithm>
 #include <cstdlib>
 #include <cstring>
 #include <limits>
 #include <map>
 #include <vector>
 
+#include "woff2.h"
+
 // The OpenType Font File
 // http://www.microsoft.com/typography/otspec/cmap.htm
 
 namespace {
 
 bool g_debug_output = true;
+bool g_enable_woff2 = false;
 
 struct OpenTypeTable {
   uint32_t tag;
   uint32_t chksum;
   uint32_t offset;
   uint32_t length;
   uint32_t uncompressed_length;
 };
 
-// Round a value up to the nearest multiple of 4. Don't round the value in the
-// case that rounding up overflows.
-template<typename T> T Round4(T value) {
-  if (std::numeric_limits<T>::max() - value < 3) {
-    return value;
-  }
-  return (value + 3) & ~3;
-}
-
 bool CheckTag(uint32_t tag_value) {
   for (unsigned i = 0; i < 4; ++i) {
     const uint32_t check = tag_value & 0xff;
     if (check < 32 || check > 126) {
       return false;  // non-ASCII character found.
     }
     tag_value >>= 8;
   }
   return true;
 }
@@ skipping 93 matching lines @@
   { "GSUB", ots::ots_gsub_parse, ots::ots_gsub_serialise,
     ots::ots_gsub_should_serialise, ots::ots_gsub_free, false },
   { "vhea", ots::ots_vhea_parse, ots::ots_vhea_serialise,
     ots::ots_vhea_should_serialise, ots::ots_vhea_free, false },
   { "vmtx", ots::ots_vmtx_parse, ots::ots_vmtx_serialise,
     ots::ots_vmtx_should_serialise, ots::ots_vmtx_free, false },
   // TODO(bashi): Support mort, base, and jstf tables.
   { 0, NULL, NULL, NULL, NULL, false },
 };
 
-bool IsValidVersionTag(uint32_t tag) {
-  return tag == Tag("\x00\x01\x00\x00") ||
-         // OpenType fonts with CFF data have 'OTTO' tag.
-         tag == Tag("OTTO") ||
-         // Older Mac fonts might have 'true' or 'typ1' tag.
-         tag == Tag("true") ||
-         tag == Tag("typ1");
-}
-
 bool ProcessGeneric(ots::OpenTypeFile *header,
                     uint32_t signature,
                     ots::OTSStream *output,
                     const uint8_t *data, size_t length,
                     const std::vector<OpenTypeTable>& tables,
                     ots::Buffer& file);
 
 bool ProcessTTF(ots::OpenTypeFile *header,
                 ots::OTSStream *output, const uint8_t *data, size_t length) {
   ots::Buffer file(data, length);
 
   // we disallow all files > 1GB in size for sanity.
   if (length > 1024 * 1024 * 1024) {
     return OTS_FAILURE();
   }
 
   if (!file.ReadTag(&header->version)) {
     return OTS_FAILURE();
   }
-  if (!IsValidVersionTag(header->version)) {
+  if (!ots::IsValidVersionTag(header->version)) {
       return OTS_FAILURE();
   }
 
   if (!file.ReadU16(&header->num_tables) ||
       !file.ReadU16(&header->search_range) ||
       !file.ReadU16(&header->entry_selector) ||
       !file.ReadU16(&header->range_shift)) {
     return OTS_FAILURE();
   }
 
@@ skipping 65 matching lines @@
     return OTS_FAILURE();
   }
 
   if (woff_tag != Tag("wOFF")) {
     return OTS_FAILURE();
   }
 
   if (!file.ReadTag(&header->version)) {
     return OTS_FAILURE();
   }
-  if (!IsValidVersionTag(header->version)) {
+  if (!ots::IsValidVersionTag(header->version)) {
       return OTS_FAILURE();
   }
 
   header->search_range = 0;
   header->entry_selector = 0;
   header->range_shift = 0;
 
   uint32_t reported_length;
   if (!file.ReadU32(&reported_length) || length != reported_length) {
     return OTS_FAILURE();
@@ skipping 57 matching lines @@
   for (unsigned i = 0; i < header->num_tables; ++i) {
     OpenTypeTable table;
     if (!file.ReadTag(&table.tag) ||
         !file.ReadU32(&table.offset) ||
         !file.ReadU32(&table.length) ||
         !file.ReadU32(&table.uncompressed_length) ||
         !file.ReadU32(&table.chksum)) {
       return OTS_FAILURE();
     }
 
-    total_sfnt_size += Round4(table.uncompressed_length);
+    total_sfnt_size += ots::Round4(table.uncompressed_length);
     if (total_sfnt_size > std::numeric_limits<uint32_t>::max()) {
       return OTS_FAILURE();
     }
     tables.push_back(table);
     if (i == 0 || tables[first_index].offset > table.offset)
       first_index = i;
     if (i == 0 || tables[last_index].offset < table.offset)
       last_index = i;
   }
 
   if (reported_total_sfnt_size != total_sfnt_size) {
     return OTS_FAILURE();
   }
 
   // Table data must follow immediately after the header.
-  if (tables[first_index].offset != Round4(file.offset())) {
+  if (tables[first_index].offset != ots::Round4(file.offset())) {
     return OTS_FAILURE();
   }
 
   if (tables[last_index].offset >= length ||
       length - tables[last_index].offset < tables[last_index].length) {
     return OTS_FAILURE();
   }
   // Blocks must follow immediately after the previous block.
   // (Except for padding with a maximum of three null bytes)
-  uint64_t block_end = Round4(
+  uint64_t block_end = ots::Round4(
       static_cast<uint64_t>(tables[last_index].offset) +
       static_cast<uint64_t>(tables[last_index].length));
   if (block_end > std::numeric_limits<uint32_t>::max()) {
     return OTS_FAILURE();
   }
   if (meta_offset) {
     if (block_end != meta_offset) {
       return OTS_FAILURE();
     }
-    block_end = Round4(static_cast<uint64_t>(meta_offset) +
-                       static_cast<uint64_t>(meta_length));
+    block_end = ots::Round4(static_cast<uint64_t>(meta_offset) +
+                            static_cast<uint64_t>(meta_length));
     if (block_end > std::numeric_limits<uint32_t>::max()) {
       return OTS_FAILURE();
     }
   }
   if (priv_offset) {
     if (block_end != priv_offset) {
       return OTS_FAILURE();
     }
-    block_end = Round4(static_cast<uint64_t>(priv_offset) +
-                       static_cast<uint64_t>(priv_length));
+    block_end = ots::Round4(static_cast<uint64_t>(priv_offset) +
+                            static_cast<uint64_t>(priv_length));
     if (block_end > std::numeric_limits<uint32_t>::max()) {
       return OTS_FAILURE();
     }
   }
-  if (block_end != Round4(length)) {
+  if (block_end != ots::Round4(length)) {
     return OTS_FAILURE();
   }
 
   return ProcessGeneric(header, woff_tag, output, data, length, tables, file);
 }
 
+bool ProcessWOFF2(ots::OpenTypeFile *header,
+                  ots::OTSStream *output, const uint8_t *data, size_t length) {
+  size_t decompressed_size = ots::ComputeWOFF2FinalSize(data, length);
+  if (decompressed_size == 0) {
+    return OTS_FAILURE();
+  }
+  // decompressed font must be <= 30MB
+  if (decompressed_size > 30 * 1024 * 1024) {
+    return OTS_FAILURE();
+  }
+
+  std::vector<uint8_t> decompressed_buffer(decompressed_size);
+  if (!ots::ConvertWOFF2ToTTF(&decompressed_buffer[0], decompressed_size,
+                              data, length)) {
+    return OTS_FAILURE();
+  }
+  return ProcessTTF(header, output, &decompressed_buffer[0], decompressed_size);
+}
+
 bool ProcessGeneric(ots::OpenTypeFile *header, uint32_t signature,
                     ots::OTSStream *output,
                     const uint8_t *data, size_t length,
                     const std::vector<OpenTypeTable>& tables,
                     ots::Buffer& file) {
   const size_t data_offset = file.offset();
 
   uint32_t uncompressed_sum = 0;
 
   for (unsigned i = 0; i < header->num_tables; ++i) {
@@ skipping 45 matching lines @@
         return OTS_FAILURE();
       }
 
       uncompressed_sum += tables[i].uncompressed_length;
     }
     // since we required that the file be < 1GB in length, and that the table
     // length is < 1GB, the following addtion doesn't overflow
     uint32_t end_byte = tables[i].offset + tables[i].length;
     // Tables in the WOFF file must be aligned 4-byte boundary.
     if (signature == Tag("wOFF")) {
-        end_byte = Round4(end_byte);
+        end_byte = ots::Round4(end_byte);
     }
     if (!end_byte || end_byte > length) {
       return OTS_FAILURE();
     }
   }
 
   // All decompressed tables uncompressed must be <= 30MB.
   if (uncompressed_sum > 30 * 1024 * 1024) {
     return OTS_FAILURE();
   }
@@ skipping 191 matching lines @@
     return OTS_FAILURE();
   }
 
   return true;
 }
 
 }  // namespace
 
 namespace ots {
 
+bool IsValidVersionTag(uint32_t tag) {
+  return tag == Tag("\x00\x01\x00\x00") ||
+         // OpenType fonts with CFF data have 'OTTO' tag.
+         tag == Tag("OTTO") ||
+         // Older Mac fonts might have 'true' or 'typ1' tag.
+         tag == Tag("true") ||
+         tag == Tag("typ1");
+}
+
 void DisableDebugOutput() {
   g_debug_output = false;
 }
 
+void EnableWOFF2() {
+  g_enable_woff2 = true;
+}
+
 bool Process(OTSStream *output, const uint8_t *data, size_t length) {
   OpenTypeFile header;
   if (length < 4) {
     return OTS_FAILURE();
   }
 
   bool result;
   if (data[0] == 'w' && data[1] == 'O' && data[2] == 'F' && data[3] == 'F') {
     result = ProcessWOFF(&header, output, data, length);
+  } else if (g_enable_woff2 &&
+             data[0] == 'w' && data[1] == 'O' && data[2] == 'F' &&
+             data[3] == '2') {
+    result = ProcessWOFF2(&header, output, data, length);
   } else {
     result = ProcessTTF(&header, output, data, length);
   }
 
   for (unsigned i = 0; ; ++i) {
     if (table_parsers[i].parse == NULL) break;
     table_parsers[i].free(&header);
   }
   return result;
 }
@@ skipping 14 matching lines @@
     va_start(va, format);
     std::vfprintf(stderr, format, va);
     va_end(va);
     std::fprintf(stderr, "\n");
     std::fflush(stderr);
   }
 }
 #endif
 
 }  // namespace ots