diff --git a/woff2/buffer.h b/woff2/buffer.h
index 5111c65..3595e84 100644
--- a/woff2/buffer.h
+++ b/woff2/buffer.h
@@ -37,6 +37,7 @@
 #include <stdint.h>
 #endif
 
+#include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <limits>
@@ -49,8 +50,8 @@
 #define FONT_COMPRESSION_FAILURE() \
   util::compression::font::Failure(__FILE__, __LINE__, __PRETTY_FUNCTION__)
 inline bool Failure(const char *f, int l, const char *fn) {
-  std::fprintf(stderr, "ERROR at %s:%d (%s)\n", f, l, fn);
-  std::fflush(stderr);
+  fprintf(stderr, "ERROR at %s:%d (%s)\n", f, l, fn);
+  fflush(stderr);
   return false;
 }
 #endif
diff --git a/woff2/font.cc b/woff2/font.cc
index c0fb206..a7e5607 100644
--- a/woff2/font.cc
+++ b/woff2/font.cc
@@ -130,8 +130,17 @@
   if (head_table == NULL || loca_table == NULL || head_table->length < 52) {
     return 0;
   }
-  int index_fmt = head_table->data[51];
-  return (loca_table->length / (index_fmt == 0 ? 2 : 4)) - 1;
+  int index_fmt = IndexFormat(font);
+  int num_glyphs = (loca_table->length / (index_fmt == 0 ? 2 : 4)) - 1;
+  return num_glyphs;
+}
+
+int IndexFormat(const Font& font) {
+  const Font::Table* head_table = font.FindTable(kHeadTableTag);
+  if (head_table == NULL) {
+    return 0;
+  }
+  return head_table->data[51];
 }
 
 bool GetGlyphData(const Font& font, int glyph_index,
@@ -146,7 +155,9 @@
       head_table->length < 52) {
     return FONT_COMPRESSION_FAILURE();
   }
-  int index_fmt = head_table->data[51];
+
+  int index_fmt = IndexFormat(font);
+
   Buffer loca_buf(loca_table->data, loca_table->length);
   if (index_fmt == 0) {
     uint16_t offset1, offset2;
diff --git a/woff2/font.h b/woff2/font.h
index 01da720..08c414c 100644
--- a/woff2/font.h
+++ b/woff2/font.h
@@ -66,6 +66,9 @@
 // zero for CFF-flavored fonts.
 int NumGlyphs(const Font& font);
 
+// Returns the index format of the font
+int IndexFormat(const Font& font);
+
 // Sets *glyph_data and *glyph_size to point to the location of the glyph data
 // with the given index. Returns false if the glyph is not found.
 bool GetGlyphData(const Font& font, int glyph_index,
diff --git a/woff2/normalize.cc b/woff2/normalize.cc
index 0812b00..a816feb 100644
--- a/woff2/normalize.cc
+++ b/woff2/normalize.cc
@@ -63,29 +63,16 @@
 
 }  // namespace
 
-bool NormalizeGlyphs(Font* font) {
-  Font::Table* head_table = font->FindTable(kHeadTableTag);
+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);
-  if (head_table == NULL || loca_table == NULL || glyf_table == NULL) {
-    return FONT_COMPRESSION_FAILURE();
-  }
-  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;
+  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;
 
-  glyf_table->buffer.resize(max_normalized_glyf_size);
-  loca_table->buffer.resize(Round4(loca_table->length));
   uint8_t* glyf_dst = &glyf_table->buffer[0];
   uint8_t* loca_dst = &loca_table->buffer[0];
   uint32_t glyf_offset = 0;
@@ -113,6 +100,10 @@
     }
     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);
@@ -123,6 +114,74 @@
   return true;
 }
 
+}  // namespace
+
+namespace {
+
+bool MakeEditableBuffer(Font* font, int tableTag) {
+  Font::Table* table = font->FindTable(tableTag);
+  if (table == NULL) {
+    return FONT_COMPRESSION_FAILURE();
+  }
+  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* cff_table = font->FindTable(kCffTableTag);
+  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();
+  }
+  // CFF, no loca, no glyf is OK for CFF. If so, don't normalize.
+  if (cff_table != NULL && loca_table == NULL && glyf_table == NULL) {
+    return true;
+  }
+  if (loca_table == NULL || glyf_table == NULL) {
+    return FONT_COMPRESSION_FAILURE();
+  }
+  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& i : font->tables) {
@@ -168,10 +227,7 @@
   if (head_table == NULL || head_table->length < 12) {
     return FONT_COMPRESSION_FAILURE();
   }
-  head_table->buffer.resize(Round4(head_table->length));
   uint8_t* head_buf = &head_table->buffer[0];
-  memcpy(head_buf, head_table->data, Round4(head_table->length));
-  head_table->data = head_buf;
   size_t offset = 8;
   StoreU32(0, &offset, head_buf);
   uint32_t file_checksum = 0;
@@ -187,7 +243,8 @@
 }
 
 bool NormalizeFont(Font* font) {
-  return (RemoveDigitalSignature(font) &&
+  return (MakeEditableBuffer(font, kHeadTableTag) &&
+          RemoveDigitalSignature(font) &&
           NormalizeGlyphs(font) &&
           NormalizeOffsets(font) &&
           FixChecksums(font));
diff --git a/woff2/round.h b/woff2/round.h
index cd6e5aa..8fd0f47 100644
--- a/woff2/round.h
+++ b/woff2/round.h
@@ -17,6 +17,8 @@
 #ifndef WOFF2_ROUND_H_
 #define WOFF2_ROUND_H_
 
+#include <limits.h>
+
 namespace woff2 {
 
 // Round a value up to the nearest multiple of 4. Don't round the value in the
diff --git a/woff2/table_tags.h b/woff2/table_tags.h
index f1b219c..c9b09bb 100644
--- a/woff2/table_tags.h
+++ b/woff2/table_tags.h
@@ -26,6 +26,7 @@
 static const uint32_t kHeadTableTag = 0x68656164;
 static const uint32_t kLocaTableTag = 0x6c6f6361;
 static const uint32_t kDsigTableTag = 0x44534947;
+static const uint32_t kCffTableTag = 0x43464620;
 
 extern const uint32_t kKnownTags[];
 
diff --git a/woff2/transform.cc b/woff2/transform.cc
index bb3a27a..44a4781 100644
--- a/woff2/transform.cc
+++ b/woff2/transform.cc
@@ -227,6 +227,12 @@
 }  // namespace
 
 bool TransformGlyfAndLocaTables(Font* font) {
+  // no transform for CFF
+  if (font->FindTable(kCffTableTag) != NULL
+      && font->FindTable(kGlyfTableTag) == NULL
+      && font->FindTable(kLocaTableTag) == NULL) {
+    return true;
+  }
   Font::Table* transformed_glyf = &font->tables[kGlyfTableTag ^ 0x80808080];
   Font::Table* transformed_loca = &font->tables[kLocaTableTag ^ 0x80808080];
 
diff --git a/woff2/woff2_enc.cc b/woff2/woff2_enc.cc
index b8afd92..6150935 100644
--- a/woff2/woff2_enc.cc
+++ b/woff2/woff2_enc.cc
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 //
-// Library for converting WOFF2 format font files to their TTF versions.
+// Library for converting TTF format font files to their WOFF2 versions.
 
 #include "./woff2_enc.h"
 
@@ -53,7 +53,7 @@
 void StoreBase128(size_t len, size_t* offset, uint8_t* dst) {
   size_t size = Base128Size(len);
   for (int i = 0; i < size; ++i) {
-    int b = (int)(len >> (7 * (size - i - 1))) & 0x7f;
+    int b = static_cast<int>((len >> (7 * (size - i - 1))) & 0x7f);
     if (i < size - 1) {
       b |= 0x80;
     }
@@ -96,6 +96,9 @@
 void StoreTableEntry(const Table& table, size_t* offset, uint8_t* dst) {
   uint8_t flag_byte = 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);
   }
@@ -106,7 +109,8 @@
 }
 
 size_t TableEntrySize(const Table& table) {
-  size_t size = KnownTableIndex(table.tag) < 31 ? 1 : 5;
+  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);
@@ -114,7 +118,8 @@
   return size;
 }
 
-size_t ComputeWoff2Length(const std::vector<Table>& tables) {
+size_t ComputeWoff2Length(const std::vector<Table>& tables,
+                          size_t extended_metadata_length) {
   size_t size = kWoff2HeaderSize;
   for (const auto& table : tables) {
     size += TableEntrySize(table);
@@ -123,6 +128,7 @@
     size += table.dst_length;
     size = Round4(size);
   }
+  size += extended_metadata_length;
   return size;
 }
 
@@ -150,15 +156,30 @@
 }  // namespace
 
 size_t MaxWOFF2CompressedSize(const uint8_t* data, size_t length) {
+  return MaxWOFF2CompressedSize(data, length, "");
+}
+
+size_t MaxWOFF2CompressedSize(const uint8_t* data, size_t length,
+    const string& extended_metadata) {
   // Except for the header size, which is 32 bytes larger in woff2 format,
   // all other parts should be smaller (table header in short format,
   // transformations and compression). Just to be sure, we will give some
   // headroom anyway.
-  return length + 1024;
+  return length + 1024 + extended_metadata.length();
+}
+
+uint32_t CompressedBufferSize(uint32_t original_size) {
+  return 1.2 * original_size + 10240;
 }
 
 bool ConvertTTFToWOFF2(const uint8_t *data, size_t length,
                        uint8_t *result, size_t *result_length) {
+  return ConvertTTFToWOFF2(data, length, result, result_length, "");
+}
+
+bool ConvertTTFToWOFF2(const uint8_t *data, size_t length,
+                       uint8_t *result, size_t *result_length,
+                       const string& extended_metadata) {
   Font font;
   if (!ReadFont(data, length, &font)) {
     fprintf(stderr, "Parsing of the input font failed.\n");
@@ -187,7 +208,7 @@
   // the size. If the compressor overflows this, it should return false and
   // then this function will also return false.
   size_t total_transform_length = ComputeTotalTransformLength(font);
-  size_t compression_buffer_size = 1.2 * total_transform_length + 10240;
+  size_t compression_buffer_size = CompressedBufferSize(total_transform_length);
   std::vector<uint8_t> compression_buf(compression_buffer_size);
   uint32_t total_compressed_length = compression_buffer_size;
 
@@ -209,6 +230,23 @@
     return false;
   }
 
+  // Compress the extended metadata
+  uint32_t compressed_metadata_buf_length =
+    CompressedBufferSize(extended_metadata.length());
+  std::vector<uint8_t> compressed_metadata_buf(compressed_metadata_buf_length);
+
+  if (extended_metadata.length() > 0) {
+    if (!Woff2Compress((const uint8_t*)extended_metadata.data(),
+                       extended_metadata.length(),
+                       compressed_metadata_buf.data(),
+                       &compressed_metadata_buf_length)) {
+      fprintf(stderr, "Compression of extended metadata failed.\n");
+      return false;
+    }
+  } else {
+    compressed_metadata_buf_length = 0;
+  }
+
   std::vector<Table> tables;
   for (const auto& i : font.tables) {
     const Font::Table& src_table = i.second;
@@ -241,7 +279,8 @@
     tables.push_back(table);
   }
 
-  size_t woff2_length = ComputeWoff2Length(tables);
+  size_t woff2_length =
+    ComputeWoff2Length(tables, compressed_metadata_buf_length);
   if (woff2_length > *result_length) {
     fprintf(stderr, "Result allocation was too small (%zd vs %zd bytes).\n",
            *result_length, woff2_length);
@@ -258,9 +297,16 @@
   StoreU32(ComputeTTFLength(tables), &offset, result);
   StoreU32(total_compressed_length, &offset, result);
   StoreBytes(head_table->data + 4, 4, &offset, result);  // font revision
-  StoreU32(0, &offset, result);  // metaOffset
-  StoreU32(0, &offset, result);  // metaLength
-  StoreU32(0, &offset, result);  // metaOrigLength
+  if (compressed_metadata_buf_length > 0) {
+    StoreU32(woff2_length - compressed_metadata_buf_length,
+             &offset, result);  // metaOffset
+    StoreU32(compressed_metadata_buf_length, &offset, result);  // metaLength
+    StoreU32(extended_metadata.length(), &offset, result);  // metaOrigLength
+  } else {
+    StoreU32(0, &offset, result);  // metaOffset
+    StoreU32(0, &offset, result);  // metaLength
+    StoreU32(0, &offset, result);  // metaOrigLength
+  }
   StoreU32(0, &offset, result);  // privOffset
   StoreU32(0, &offset, result);  // privLength
   for (const auto& table : tables) {
@@ -270,6 +316,9 @@
     StoreBytes(table.dst_data, table.dst_length, &offset, result);
     offset = Round4(offset);
   }
+  StoreBytes(compressed_metadata_buf.data(), compressed_metadata_buf_length,
+             &offset, result);
+
   if (*result_length != offset) {
     fprintf(stderr, "Mismatch between computed and actual length "
             "(%zd vs %zd)\n", *result_length, offset);
diff --git a/woff2/woff2_enc.h b/woff2/woff2_enc.h
index 18adc0c..d6eb4db 100644
--- a/woff2/woff2_enc.h
+++ b/woff2/woff2_enc.h
@@ -19,11 +19,17 @@
 
 #include <stddef.h>
 #include <inttypes.h>
+#include <string>
+
+using std::string;
+
 
 namespace woff2 {
 
 // Returns an upper bound on the size of the compressed file.
 size_t MaxWOFF2CompressedSize(const uint8_t* data, size_t length);
+size_t MaxWOFF2CompressedSize(const uint8_t* data, size_t length,
+                              const string& extended_metadata);
 
 // Compresses the font into the target buffer. *result_length should be at least
 // the value returned by MaxWOFF2CompressedSize(), upon return, it is set to the
@@ -31,6 +37,10 @@
 bool ConvertTTFToWOFF2(const uint8_t *data, size_t length,
                        uint8_t *result, size_t *result_length);
 
+bool ConvertTTFToWOFF2(const uint8_t *data, size_t length,
+                       uint8_t *result, size_t *result_length,
+                       const string& extended_metadata);
+
 } // namespace woff2
 
 #endif  // WOFF2_WOFF2_ENC_H_