diff options
| author | Matt A. Tobin <email@mattatobin.com> | 2019-11-14 21:08:43 -0500 |
|---|---|---|
| committer | Matt A. Tobin <email@mattatobin.com> | 2019-11-14 21:08:43 -0500 |
| commit | 1d30f6fa8413746ddc408f93710d701493af273d (patch) | |
| tree | abe84e83d704e13c60c90db7ac4b9e363d8a81fc /gfx/ots | |
| parent | 9308ec68e863e4c6e650680370a5d7baa9f0d1f3 (diff) | |
| parent | 00573571a226a0c59dd744da67483864a22911aa (diff) | |
| download | UXP-1d30f6fa8413746ddc408f93710d701493af273d.tar UXP-1d30f6fa8413746ddc408f93710d701493af273d.tar.gz UXP-1d30f6fa8413746ddc408f93710d701493af273d.tar.lz UXP-1d30f6fa8413746ddc408f93710d701493af273d.tar.xz UXP-1d30f6fa8413746ddc408f93710d701493af273d.zip | |
Merge branch 'master' into mailnews-work
Diffstat (limited to 'gfx/ots')
101 files changed, 10961 insertions, 3290 deletions
diff --git a/gfx/ots/LICENSE b/gfx/ots/LICENSE index a7531cf7c..d5e3bff5a 100644 --- a/gfx/ots/LICENSE +++ b/gfx/ots/LICENSE @@ -1,27 +1,27 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +Copyright (c) 2009-2017 The OTS Authors. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/gfx/ots/README.mozilla b/gfx/ots/README.mozilla index b96826735..0353a99c5 100644 --- a/gfx/ots/README.mozilla +++ b/gfx/ots/README.mozilla @@ -2,10 +2,11 @@ This is the Sanitiser for OpenType project, from http://code.google.com/p/ots/. Our reference repository is https://github.com/khaledhosny/ots/. -Current revision: ba8417620956a920ed1f05a2f666fb6317fb10cb +Current revision: 8bba749d9d5401726a7d7609ab914fdb5e92bfbe (8.0.0) -Upstream files included: LICENSE, src/, include/ +Upstream files included: LICENSE, src/, include/, tests/*.cc Additional files: README.mozilla, src/moz.build Additional patch: ots-visibility.patch (bug 711079). +Additional patch: ots-lz4.patch diff --git a/gfx/ots/include/opentype-sanitiser.h b/gfx/ots/include/opentype-sanitiser.h index 87d0f3d28..52cbd3aee 100644 --- a/gfx/ots/include/opentype-sanitiser.h +++ b/gfx/ots/include/opentype-sanitiser.h @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -35,13 +35,17 @@ typedef int int32_t; typedef unsigned int uint32_t; typedef __int64 int64_t; typedef unsigned __int64 uint64_t; -#define ntohl(x) _byteswap_ulong (x) -#define ntohs(x) _byteswap_ushort (x) -#define htonl(x) _byteswap_ulong (x) -#define htons(x) _byteswap_ushort (x) +#define ots_ntohl(x) _byteswap_ulong (x) +#define ots_ntohs(x) _byteswap_ushort (x) +#define ots_htonl(x) _byteswap_ulong (x) +#define ots_htons(x) _byteswap_ushort (x) #else #include <arpa/inet.h> #include <stdint.h> +#define ots_ntohl(x) ntohl (x) +#define ots_ntohs(x) ntohs (x) +#define ots_htonl(x) htonl (x) +#define ots_htons(x) htons (x) #endif #include <sys/types.h> @@ -52,7 +56,7 @@ typedef unsigned __int64 uint64_t; #include <cstring> #define OTS_TAG(c1,c2,c3,c4) ((uint32_t)((((uint8_t)(c1))<<24)|(((uint8_t)(c2))<<16)|(((uint8_t)(c3))<<8)|((uint8_t)(c4)))) -#define OTS_UNTAG(tag) ((uint8_t)((tag)>>24)), ((uint8_t)((tag)>>16)), ((uint8_t)((tag)>>8)), ((uint8_t)(tag)) +#define OTS_UNTAG(tag) ((char)((tag)>>24)), ((char)((tag)>>16)), ((char)((tag)>>8)), ((char)(tag)) namespace ots { @@ -80,7 +84,7 @@ class OTSStream { const size_t l = std::min(length, static_cast<size_t>(4) - chksum_offset); uint32_t tmp = 0; std::memcpy(reinterpret_cast<uint8_t *>(&tmp) + chksum_offset, data, l); - chksum_ += ntohl(tmp); + chksum_ += ots_ntohl(tmp); length -= l; offset += l; } @@ -89,7 +93,7 @@ class OTSStream { uint32_t tmp; std::memcpy(&tmp, reinterpret_cast<const uint8_t *>(data) + offset, sizeof(uint32_t)); - chksum_ += ntohl(tmp); + chksum_ += ots_ntohl(tmp); length -= 4; offset += 4; } @@ -99,7 +103,7 @@ class OTSStream { uint32_t tmp = 0; std::memcpy(&tmp, reinterpret_cast<const uint8_t*>(data) + offset, length); - chksum_ += ntohl(tmp); + chksum_ += ots_ntohl(tmp); } return WriteRaw(data, orig_length); @@ -127,27 +131,27 @@ class OTSStream { } bool WriteU16(uint16_t v) { - v = htons(v); + v = ots_htons(v); return Write(&v, sizeof(v)); } bool WriteS16(int16_t v) { - v = htons(v); + v = ots_htons(v); return Write(&v, sizeof(v)); } bool WriteU24(uint32_t v) { - v = htonl(v); + v = ots_htonl(v); return Write(reinterpret_cast<uint8_t*>(&v)+1, 3); } bool WriteU32(uint32_t v) { - v = htonl(v); + v = ots_htonl(v); return Write(&v, sizeof(v)); } bool WriteS32(int32_t v) { - v = htonl(v); + v = ots_htonl(v); return Write(&v, sizeof(v)); } @@ -176,7 +180,7 @@ class OTSStream { enum TableAction { TABLE_ACTION_DEFAULT, // Use OTS's default action for that table - TABLE_ACTION_SANITIZE, // Sanitize the table, potentially droping it + TABLE_ACTION_SANITIZE, // Sanitize the table, potentially dropping it TABLE_ACTION_PASSTHRU, // Serialize the table unchanged TABLE_ACTION_DROP // Drop the table }; @@ -186,7 +190,7 @@ class OTS_API OTSContext { OTSContext() {} virtual ~OTSContext() {} - // Process a given OpenType file and write out a sanitised version + // Process a given OpenType file and write out a sanitized version // output: a pointer to an object implementing the OTSStream interface. The // sanitisied output will be written to this. In the even of a failure, // partial output may have been written. diff --git a/gfx/ots/include/ots-memory-stream.h b/gfx/ots/include/ots-memory-stream.h index 579da616f..cd5b089fa 100644 --- a/gfx/ots/include/ots-memory-stream.h +++ b/gfx/ots/include/ots-memory-stream.h @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. diff --git a/gfx/ots/ots-lz4.patch b/gfx/ots/ots-lz4.patch new file mode 100644 index 000000000..4251e72d6 --- /dev/null +++ b/gfx/ots/ots-lz4.patch @@ -0,0 +1,74 @@ +diff --git a/gfx/ots/src/glat.cc b/gfx/ots/src/glat.cc +--- a/gfx/ots/src/glat.cc ++++ b/gfx/ots/src/glat.cc +@@ -4,9 +4,9 @@ + + #include "glat.h" + + #include "gloc.h" +-#include "lz4.h" ++#include "mozilla/Compression.h" + #include <list> + + namespace ots { + +@@ -212,16 +212,17 @@ bool OpenTypeGLAT_v3::Parse(const uint8_ + return DropGraphite("Decompressed size exceeds 30MB: %gMB", + decompressed_size / (1024.0 * 1024.0)); + } + std::vector<uint8_t> decompressed(decompressed_size); +- int ret = LZ4_decompress_safe_partial( ++ size_t outputSize = 0; ++ bool ret = mozilla::Compression::LZ4::decompressPartial( + reinterpret_cast<const char*>(data + table.offset()), +- reinterpret_cast<char*>(decompressed.data()), + table.remaining(), // input buffer size (input size + padding) ++ reinterpret_cast<char*>(decompressed.data()), + decompressed.size(), // target output size +- decompressed.size()); // output buffer size +- if (ret < 0 || unsigned(ret) != decompressed.size()) { +- return DropGraphite("Decompression failed with error code %d", ret); ++ &outputSize); // return output size ++ if (!ret || outputSize != decompressed.size()) { ++ return DropGraphite("Decompression failed"); + } + return this->Parse(decompressed.data(), decompressed.size(), true); + } + default: +diff --git a/gfx/ots/src/silf.cc b/gfx/ots/src/silf.cc +--- a/gfx/ots/src/silf.cc ++++ b/gfx/ots/src/silf.cc +@@ -4,9 +4,9 @@ + + #include "silf.h" + + #include "name.h" +-#include "lz4.h" ++#include "mozilla/Compression.h" + #include <cmath> + + namespace ots { + +@@ -50,16 +50,17 @@ bool OpenTypeSILF::Parse(const uint8_t* + return DropGraphite("Decompressed size exceeds 30MB: %gMB", + decompressed_size / (1024.0 * 1024.0)); + } + std::vector<uint8_t> decompressed(decompressed_size); +- int ret = LZ4_decompress_safe_partial( ++ size_t outputSize = 0; ++ bool ret = mozilla::Compression::LZ4::decompressPartial( + reinterpret_cast<const char*>(data + table.offset()), +- reinterpret_cast<char*>(decompressed.data()), + table.remaining(), // input buffer size (input size + padding) ++ reinterpret_cast<char*>(decompressed.data()), + decompressed.size(), // target output size +- decompressed.size()); // output buffer size +- if (ret < 0 || unsigned(ret) != decompressed.size()) { +- return DropGraphite("Decompression failed with error code %d", ret); ++ &outputSize); // return output size ++ if (!ret || outputSize != decompressed.size()) { ++ return DropGraphite("Decompression failed"); + } + return this->Parse(decompressed.data(), decompressed.size(), true); + } + default: diff --git a/gfx/ots/ots-visibility.patch b/gfx/ots/ots-visibility.patch index aeac81c4d..c1265472b 100644 --- a/gfx/ots/ots-visibility.patch +++ b/gfx/ots/ots-visibility.patch @@ -1,10 +1,7 @@ diff --git a/gfx/ots/include/opentype-sanitiser.h b/gfx/ots/include/opentype-sanitiser.h --- a/gfx/ots/include/opentype-sanitiser.h +++ b/gfx/ots/include/opentype-sanitiser.h -@@ -1,15 +1,35 @@ - // 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. +@@ -4,8 +4,28 @@ #ifndef OPENTYPE_SANITISER_H_ #define OPENTYPE_SANITISER_H_ @@ -33,15 +30,7 @@ diff --git a/gfx/ots/include/opentype-sanitiser.h b/gfx/ots/include/opentype-san #include <stdlib.h> typedef signed char int8_t; typedef unsigned char uint8_t; - typedef short int16_t; - typedef unsigned short uint16_t; - typedef int int32_t; - typedef unsigned int uint32_t; -@@ -187,17 +207,17 @@ class OTSStream { - - enum TableAction { - TABLE_ACTION_DEFAULT, // Use OTS's default action for that table - TABLE_ACTION_SANITIZE, // Sanitize the table, potentially droping it +@@ -164,9 +184,9 @@ enum TableAction { TABLE_ACTION_PASSTHRU, // Serialize the table unchanged TABLE_ACTION_DROP // Drop the table }; @@ -52,7 +41,3 @@ diff --git a/gfx/ots/include/opentype-sanitiser.h b/gfx/ots/include/opentype-san OTSContext() {} virtual ~OTSContext() {} - // Process a given OpenType file and write out a sanitised version - // output: a pointer to an object implementing the OTSStream interface. The - // sanitisied output will be written to this. In the even of a failure, - // partial output may have been written. diff --git a/gfx/ots/src/avar.cc b/gfx/ots/src/avar.cc new file mode 100644 index 000000000..2a431b1c2 --- /dev/null +++ b/gfx/ots/src/avar.cc @@ -0,0 +1,109 @@ +// Copyright (c) 2018 The OTS 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 "avar.h" + +#include "fvar.h" + +namespace ots { + +// ----------------------------------------------------------------------------- +// OpenTypeAVAR +// ----------------------------------------------------------------------------- + +bool OpenTypeAVAR::Parse(const uint8_t* data, size_t length) { + Buffer table(data, length); + if (!table.ReadU16(&this->majorVersion) || + !table.ReadU16(&this->minorVersion) || + !table.ReadU16(&this->reserved) || + !table.ReadU16(&this->axisCount)) { + return Drop("Failed to read table header"); + } + if (this->majorVersion != 1) { + return Drop("Unknown table version"); + } + if (this->minorVersion > 0) { + // we only know how to serialize version 1.0 + Warning("Downgrading minor version to 0"); + this->minorVersion = 0; + } + if (this->reserved != 0) { + Warning("Expected reserved=0"); + this->reserved = 0; + } + + OpenTypeFVAR* fvar = static_cast<OpenTypeFVAR*>( + GetFont()->GetTypedTable(OTS_TAG_FVAR)); + if (!fvar) { + return DropVariations("Required fvar table is missing"); + } + if (axisCount != fvar->AxisCount()) { + return Drop("Axis count mismatch"); + } + + for (size_t i = 0; i < this->axisCount; i++) { + this->axisSegmentMaps.emplace_back(); + uint16_t positionMapCount; + if (!table.ReadU16(&positionMapCount)) { + return Drop("Failed to read position map count"); + } + int foundRequiredMappings = 0; + for (size_t j = 0; j < positionMapCount; j++) { + AxisValueMap map; + if (!table.ReadS16(&map.fromCoordinate) || + !table.ReadS16(&map.toCoordinate)) { + return Drop("Failed to read axis value map"); + } + if (map.fromCoordinate < -0x4000 || + map.fromCoordinate > 0x4000 || + map.toCoordinate < -0x4000 || + map.toCoordinate > 0x4000) { + return Drop("Axis value map coordinate out of range"); + } + if (j > 0) { + if (map.fromCoordinate <= this->axisSegmentMaps[i].back().fromCoordinate || + map.toCoordinate < this->axisSegmentMaps[i].back().toCoordinate) { + return Drop("Axis value map out of order"); + } + } + if ((map.fromCoordinate == -0x4000 && map.toCoordinate == -0x4000) || + (map.fromCoordinate == 0 && map.toCoordinate == 0) || + (map.fromCoordinate == 0x4000 && map.toCoordinate == 0x4000)) { + ++foundRequiredMappings; + } + this->axisSegmentMaps[i].push_back(map); + } + if (positionMapCount > 0 && foundRequiredMappings != 3) { + return Drop("A required mapping (for -1, 0 or 1) is missing"); + } + } + + return true; +} + +bool OpenTypeAVAR::Serialize(OTSStream* out) { + if (!out->WriteU16(this->majorVersion) || + !out->WriteU16(this->minorVersion) || + !out->WriteU16(this->reserved) || + !out->WriteU16(this->axisCount)) { + return Error("Failed to write table"); + } + + for (size_t i = 0; i < this->axisCount; i++) { + const auto& axisValueMap = this->axisSegmentMaps[i]; + if (!out->WriteU16(axisValueMap.size())) { + return Error("Failed to write table"); + } + for (size_t j = 0; j < axisValueMap.size(); j++) { + if (!out->WriteS16(axisValueMap[j].fromCoordinate) || + !out->WriteS16(axisValueMap[j].toCoordinate)) { + return Error("Failed to write table"); + } + } + } + + return true; +} + +} // namespace ots diff --git a/gfx/ots/src/avar.h b/gfx/ots/src/avar.h new file mode 100644 index 000000000..756651c04 --- /dev/null +++ b/gfx/ots/src/avar.h @@ -0,0 +1,42 @@ +// Copyright (c) 2018 The OTS Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef OTS_AVAR_H_ +#define OTS_AVAR_H_ + +#include "ots.h" + +#include <vector> + +namespace ots { + +// ----------------------------------------------------------------------------- +// OpenTypeAVAR Interface +// ----------------------------------------------------------------------------- + +class OpenTypeAVAR : public Table { + public: + explicit OpenTypeAVAR(Font* font, uint32_t tag) + : Table(font, tag, tag) { } + + bool Parse(const uint8_t* data, size_t length); + bool Serialize(OTSStream* out); + + private: + uint16_t majorVersion; + uint16_t minorVersion; + uint16_t reserved; + uint16_t axisCount; + + struct AxisValueMap { + int16_t fromCoordinate; + int16_t toCoordinate; + }; + + std::vector<std::vector<AxisValueMap>> axisSegmentMaps; +}; + +} // namespace ots + +#endif // OTS_AVAR_H_ diff --git a/gfx/ots/src/cff.cc b/gfx/ots/src/cff.cc index 23b6dadac..b0affd510 100644 --- a/gfx/ots/src/cff.cc +++ b/gfx/ots/src/cff.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Copyright (c) 2012-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -9,7 +9,8 @@ #include <vector> #include "maxp.h" -#include "cff_type2_charstring.h" +#include "cff_charstring.h" +#include "variations.h" // CFF - PostScript font program (Compact Font Format) table // http://www.microsoft.com/typography/otspec/cff.htm @@ -28,6 +29,7 @@ enum DICT_OPERAND_TYPE { enum DICT_DATA_TYPE { DICT_DATA_TOPLEVEL, DICT_DATA_FDARRAY, + DICT_DATA_PRIVATE, }; enum FONT_FORMAT { @@ -39,7 +41,9 @@ enum FONT_FORMAT { // see Appendix. A const size_t kNStdString = 390; -bool ReadOffset(ots::Buffer *table, uint8_t off_size, uint32_t *offset) { +typedef std::pair<uint32_t, DICT_OPERAND_TYPE> Operand; + +bool ReadOffset(ots::Buffer &table, uint8_t off_size, uint32_t *offset) { if (off_size > 4) { return OTS_FAILURE(); } @@ -47,7 +51,7 @@ bool ReadOffset(ots::Buffer *table, uint8_t off_size, uint32_t *offset) { uint32_t tmp32 = 0; for (unsigned i = 0; i < off_size; ++i) { uint8_t tmp8 = 0; - if (!table->ReadU8(&tmp8)) { + if (!table.ReadU8(&tmp8)) { return OTS_FAILURE(); } tmp32 <<= 8; @@ -57,39 +61,47 @@ bool ReadOffset(ots::Buffer *table, uint8_t off_size, uint32_t *offset) { return true; } -bool ParseIndex(ots::Buffer *table, ots::CFFIndex *index) { - index->off_size = 0; - index->offsets.clear(); +bool ParseIndex(ots::Buffer &table, ots::CFFIndex &index, bool cff2 = false) { + index.off_size = 0; + index.offsets.clear(); - if (!table->ReadU16(&(index->count))) { - return OTS_FAILURE(); + if (cff2) { + if (!table.ReadU32(&(index.count))) { + return OTS_FAILURE(); + } + } else { + uint16_t count; + if (!table.ReadU16(&count)) { + return OTS_FAILURE(); + } + index.count = count; } - if (index->count == 0) { + + if (index.count == 0) { // An empty INDEX. - index->offset_to_next = table->offset(); + index.offset_to_next = table.offset(); return true; } - if (!table->ReadU8(&(index->off_size))) { + if (!table.ReadU8(&(index.off_size))) { return OTS_FAILURE(); } - if ((index->off_size == 0) || - (index->off_size > 4)) { + if (index.off_size < 1 || index.off_size > 4) { return OTS_FAILURE(); } - const size_t array_size = (index->count + 1) * index->off_size; + const size_t array_size = (index.count + 1) * index.off_size; // less than ((64k + 1) * 4), thus does not overflow. - const size_t object_data_offset = table->offset() + array_size; + const size_t object_data_offset = table.offset() + array_size; // does not overflow too, since offset() <= 1GB. - if (object_data_offset >= table->length()) { + if (object_data_offset >= table.length()) { return OTS_FAILURE(); } - for (unsigned i = 0; i <= index->count; ++i) { // '<=' is not a typo. + for (unsigned i = 0; i <= index.count; ++i) { // '<=' is not a typo. uint32_t rel_offset = 0; - if (!ReadOffset(table, index->off_size, &rel_offset)) { + if (!ReadOffset(table, index.off_size, &rel_offset)) { return OTS_FAILURE(); } if (rel_offset < 1) { @@ -99,60 +111,56 @@ bool ParseIndex(ots::Buffer *table, ots::CFFIndex *index) { return OTS_FAILURE(); } - if (rel_offset > table->length()) { + if (rel_offset > table.length()) { return OTS_FAILURE(); } // does not underflow. - if (object_data_offset > table->length() - (rel_offset - 1)) { + if (object_data_offset > table.length() - (rel_offset - 1)) { return OTS_FAILURE(); } - index->offsets.push_back( + index.offsets.push_back( object_data_offset + (rel_offset - 1)); // less than length(), 1GB. } - for (unsigned i = 1; i < index->offsets.size(); ++i) { + for (unsigned i = 1; i < index.offsets.size(); ++i) { // We allow consecutive identical offsets here for zero-length strings. // See http://crbug.com/69341 for more details. - if (index->offsets[i] < index->offsets[i - 1]) { + if (index.offsets[i] < index.offsets[i - 1]) { return OTS_FAILURE(); } } - index->offset_to_next = index->offsets.back(); + index.offset_to_next = index.offsets.back(); return true; } bool ParseNameData( ots::Buffer *table, const ots::CFFIndex &index, std::string* out_name) { uint8_t name[256] = {0}; - if (index.offsets.size() == 0) { // just in case. + + const size_t length = index.offsets[1] - index.offsets[0]; + // font names should be no longer than 127 characters. + if (length > 127) { return OTS_FAILURE(); } - for (unsigned i = 1; i < index.offsets.size(); ++i) { - const size_t length = index.offsets[i] - index.offsets[i - 1]; - // font names should be no longer than 127 characters. - if (length > 127) { - return OTS_FAILURE(); - } - table->set_offset(index.offsets[i - 1]); - if (!table->Read(name, length)) { + table->set_offset(index.offsets[0]); + if (!table->Read(name, length)) { + return OTS_FAILURE(); + } + + for (size_t i = 0; i < length; ++i) { + // setting the first byte to NUL is allowed. + if (i == 0 && name[i] == 0) continue; + // non-ASCII characters are not recommended (except the first character). + if (name[i] < 33 || name[i] > 126) { return OTS_FAILURE(); } - - for (size_t j = 0; j < length; ++j) { - // setting the first byte to NUL is allowed. - if (j == 0 && name[j] == 0) continue; - // non-ASCII characters are not recommended (except the first character). - if (name[j] < 33 || name[j] > 126) { - return OTS_FAILURE(); - } - // [, ], ... are not allowed. - if (std::strchr("[](){}<>/% ", name[j])) { - return OTS_FAILURE(); - } + // [, ], ... are not allowed. + if (std::strchr("[](){}<>/% ", name[i])) { + return OTS_FAILURE(); } } @@ -160,8 +168,7 @@ bool ParseNameData( return true; } -bool CheckOffset(const std::pair<uint32_t, DICT_OPERAND_TYPE>& operand, - size_t table_length) { +bool CheckOffset(const Operand& operand, size_t table_length) { if (operand.second != DICT_OPERAND_INTEGER) { return OTS_FAILURE(); } @@ -171,8 +178,7 @@ bool CheckOffset(const std::pair<uint32_t, DICT_OPERAND_TYPE>& operand, return true; } -bool CheckSid(const std::pair<uint32_t, DICT_OPERAND_TYPE>& operand, - size_t sid_max) { +bool CheckSid(const Operand& operand, size_t sid_max) { if (operand.second != DICT_OPERAND_INTEGER) { return OTS_FAILURE(); } @@ -182,30 +188,28 @@ bool CheckSid(const std::pair<uint32_t, DICT_OPERAND_TYPE>& operand, return true; } -bool ParseDictDataBcd( - ots::Buffer *table, - std::vector<std::pair<uint32_t, DICT_OPERAND_TYPE> > *operands) { +bool ParseDictDataBcd(ots::Buffer &table, std::vector<Operand> &operands) { bool read_decimal_point = false; bool read_e = false; uint8_t nibble = 0; size_t count = 0; while (true) { - if (!table->ReadU8(&nibble)) { + if (!table.ReadU8(&nibble)) { return OTS_FAILURE(); } if ((nibble & 0xf0) == 0xf0) { if ((nibble & 0xf) == 0xf) { // TODO(yusukes): would be better to store actual double value, // rather than the dummy integer. - operands->push_back(std::make_pair(static_cast<uint32_t>(0), + operands.push_back(std::make_pair(static_cast<uint32_t>(0), DICT_OPERAND_REAL)); return true; } return OTS_FAILURE(); } if ((nibble & 0x0f) == 0x0f) { - operands->push_back(std::make_pair(static_cast<uint32_t>(0), + operands.push_back(std::make_pair(static_cast<uint32_t>(0), DICT_OPERAND_REAL)); return true; } @@ -242,18 +246,17 @@ bool ParseDictDataBcd( } } -bool ParseDictDataEscapedOperator( - ots::Buffer *table, - std::vector<std::pair<uint32_t, DICT_OPERAND_TYPE> > *operands) { +bool ParseDictDataEscapedOperator(ots::Buffer &table, + std::vector<Operand> &operands) { uint8_t op = 0; - if (!table->ReadU8(&op)) { + if (!table.ReadU8(&op)) { return OTS_FAILURE(); } if ((op <= 14) || (op >= 17 && op <= 23) || (op >= 30 && op <= 38)) { - operands->push_back(std::make_pair((12U << 8) + op, DICT_OPERATOR)); + operands.push_back(std::make_pair((12U << 8) + op, DICT_OPERATOR)); return true; } @@ -261,9 +264,8 @@ bool ParseDictDataEscapedOperator( return OTS_FAILURE(); } -bool ParseDictDataNumber( - ots::Buffer *table, uint8_t b0, - std::vector<std::pair<uint32_t, DICT_OPERAND_TYPE> > *operands) { +bool ParseDictDataNumber(ots::Buffer &table, uint8_t b0, + std::vector<Operand> &operands) { uint8_t b1 = 0; uint8_t b2 = 0; uint8_t b3 = 0; @@ -271,22 +273,22 @@ bool ParseDictDataNumber( switch (b0) { case 28: // shortint - if (!table->ReadU8(&b1) || - !table->ReadU8(&b2)) { + if (!table.ReadU8(&b1) || + !table.ReadU8(&b2)) { return OTS_FAILURE(); } - operands->push_back(std::make_pair( + operands.push_back(std::make_pair( static_cast<uint32_t>((b1 << 8) + b2), DICT_OPERAND_INTEGER)); return true; case 29: // longint - if (!table->ReadU8(&b1) || - !table->ReadU8(&b2) || - !table->ReadU8(&b3) || - !table->ReadU8(&b4)) { + if (!table.ReadU8(&b1) || + !table.ReadU8(&b2) || + !table.ReadU8(&b3) || + !table.ReadU8(&b4)) { return OTS_FAILURE(); } - operands->push_back(std::make_pair( + operands.push_back(std::make_pair( static_cast<uint32_t>((b1 << 24) + (b2 << 16) + (b3 << 8) + b4), DICT_OPERAND_INTEGER)); return true; @@ -302,12 +304,12 @@ bool ParseDictDataNumber( if (b0 >=32 && b0 <=246) { result = b0 - 139; } else if (b0 >=247 && b0 <= 250) { - if (!table->ReadU8(&b1)) { + if (!table.ReadU8(&b1)) { return OTS_FAILURE(); } result = (b0 - 247) * 256 + b1 + 108; } else if (b0 >= 251 && b0 <= 254) { - if (!table->ReadU8(&b1)) { + if (!table.ReadU8(&b1)) { return OTS_FAILURE(); } result = -(b0 - 251) * 256 + b1 - 108; @@ -315,22 +317,21 @@ bool ParseDictDataNumber( return OTS_FAILURE(); } - operands->push_back(std::make_pair(result, DICT_OPERAND_INTEGER)); + operands.push_back(std::make_pair(result, DICT_OPERAND_INTEGER)); return true; } -bool ParseDictDataReadNext( - ots::Buffer *table, - std::vector<std::pair<uint32_t, DICT_OPERAND_TYPE> > *operands) { +bool ParseDictDataReadNext(ots::Buffer &table, + std::vector<Operand> &operands) { uint8_t op = 0; - if (!table->ReadU8(&op)) { + if (!table.ReadU8(&op)) { return OTS_FAILURE(); } - if (op <= 21) { + if (op <= 24) { if (op == 12) { return ParseDictDataEscapedOperator(table, operands); } - operands->push_back(std::make_pair( + operands.push_back(std::make_pair( static_cast<uint32_t>(op), DICT_OPERATOR)); return true; } else if (op <= 27 || op == 31 || op == 255) { @@ -341,12 +342,69 @@ bool ParseDictDataReadNext( return ParseDictDataNumber(table, op, operands); } +bool OperandsOverflow(std::vector<Operand>& operands, bool cff2) { + // An operator may be preceded by up to a maximum of 48 operands in CFF1 and + // 513 operands in CFF2. + if ((cff2 && operands.size() > ots::kMaxCFF2ArgumentStack) || + (!cff2 && operands.size() > ots::kMaxCFF1ArgumentStack)) { + return true; + } + return false; +} + +bool ParseDictDataReadOperands(ots::Buffer& dict, + std::vector<Operand>& operands, + bool cff2) { + if (!ParseDictDataReadNext(dict, operands)) { + return OTS_FAILURE(); + } + if (operands.empty()) { + return OTS_FAILURE(); + } + if (OperandsOverflow(operands, cff2)) { + return OTS_FAILURE(); + } + return true; +} + +bool ValidCFF2DictOp(uint32_t op, DICT_DATA_TYPE type) { + if (type == DICT_DATA_TOPLEVEL) { + switch (op) { + case (12U << 8) + 7: // FontMatrix + case 17: // CharStrings + case (12U << 8) + 36: // FDArray + case (12U << 8) + 37: // FDSelect + case 24: // vstore + return true; + default: + return false; + } + } else if (type == DICT_DATA_FDARRAY) { + if (op == 18) // Private DICT + return true; + } else if (type == DICT_DATA_PRIVATE) { + switch (op) { + case (12U << 8) + 14: // ForceBold + case (12U << 8) + 19: // initialRandomSeed + case 20: // defaultWidthX + case 21: // nominalWidthX + return false; + default: + return true; + } + } + + return false; +} + bool ParsePrivateDictData( - const uint8_t *data, - size_t table_length, size_t offset, size_t dict_length, + ots::Buffer &table, size_t offset, size_t dict_length, DICT_DATA_TYPE type, ots::OpenTypeCFF *out_cff) { - ots::Buffer table(data + offset, dict_length); - std::vector<std::pair<uint32_t, DICT_OPERAND_TYPE> > operands; + ots::Buffer dict(table.buffer() + offset, dict_length); + std::vector<Operand> operands; + bool cff2 = (out_cff->major == 2); + bool blend_seen = false; + uint32_t vsindex = 0; // Since a Private DICT for FDArray might not have a Local Subr (e.g. Hiragino // Kaku Gothic Std W8), we create an empty Local Subr here to match the size @@ -355,15 +413,8 @@ bool ParsePrivateDictData( out_cff->local_subrs_per_font.push_back(new ots::CFFIndex); } - while (table.offset() < dict_length) { - if (!ParseDictDataReadNext(&table, &operands)) { - return OTS_FAILURE(); - } - if (operands.empty()) { - return OTS_FAILURE(); - } - if (operands.size() > 48) { - // An operator may be preceded by up to a maximum of 48 operands. + while (dict.offset() < dict.length()) { + if (!ParseDictDataReadOperands(dict, operands, cff2)) { return OTS_FAILURE(); } if (operands.back().second != DICT_OPERATOR) { @@ -374,13 +425,18 @@ bool ParsePrivateDictData( const uint32_t op = operands.back().first; operands.pop_back(); + if (cff2 && !ValidCFF2DictOp(op, DICT_DATA_PRIVATE)) { + return OTS_FAILURE(); + } + + bool clear_operands = true; switch (op) { // hints case 6: // BlueValues case 7: // OtherBlues case 8: // FamilyBlues case 9: // FamilyOtherBlues - if (operands.empty() || (operands.size() % 2) != 0) { + if ((operands.size() % 2) != 0) { return OTS_FAILURE(); } break; @@ -420,12 +476,11 @@ bool ParsePrivateDictData( if (operands.back().first >= 1024 * 1024 * 1024) { return OTS_FAILURE(); } - if (operands.back().first + offset >= table_length) { + if (operands.back().first + offset >= table.length()) { return OTS_FAILURE(); } // parse "16. Local Subrs INDEX" - ots::Buffer cff_table(data, table_length); - cff_table.set_offset(operands.back().first + offset); + table.set_offset(operands.back().first + offset); ots::CFFIndex *local_subrs_index = NULL; if (type == DICT_DATA_FDARRAY) { if (out_cff->local_subrs_per_font.empty()) { @@ -439,7 +494,7 @@ bool ParsePrivateDictData( local_subrs_index = new ots::CFFIndex; out_cff->local_subrs = local_subrs_index; } - if (!ParseIndex(&cff_table, local_subrs_index)) { + if (!ParseIndex(table, *local_subrs_index, cff2)) { return OTS_FAILURE(); } break; @@ -458,42 +513,125 @@ bool ParsePrivateDictData( } break; + case 22: { // vsindex + if (!cff2) { + return OTS_FAILURE(); + } + if (operands.size() != 1) { + return OTS_FAILURE(); + } + if (operands.back().second != DICT_OPERAND_INTEGER) { + return OTS_FAILURE(); + } + if (blend_seen) { + return OTS_FAILURE(); + } + vsindex = operands.back().first; + if (vsindex >= out_cff->region_index_count.size()) { + return OTS_FAILURE(); + } + break; + } + + case 23: { // blend + if (!cff2) { + return OTS_FAILURE(); + } + if (operands.size() < 1) { + return OTS_FAILURE(); + } + if (vsindex >= out_cff->region_index_count.size()) { + return OTS_FAILURE(); + } + uint16_t k = out_cff->region_index_count.at(vsindex); + uint16_t n = operands.back().first; + if (operands.size() < n * (k + 1) + 1) { + return OTS_FAILURE(); + } + size_t operands_size = operands.size(); + // Keep the 1st n operands on the stack for the next operator to use + // and pop the rest. There can be multiple consecutive blend operator, + // so this makes sure the operands of all of them are kept on the + // stack. + while (operands.size() > operands_size - ((n * k) + 1)) + operands.pop_back(); + clear_operands = false; + blend_seen = true; + break; + } + default: return OTS_FAILURE(); } - operands.clear(); + if (clear_operands) { + operands.clear(); + } } return true; } -bool ParseDictData(const uint8_t *data, size_t table_length, - const ots::CFFIndex &index, uint16_t glyphs, - size_t sid_max, DICT_DATA_TYPE type, +bool ParseVariationStore(ots::OpenTypeCFF& out_cff, ots::Buffer& table) { + uint16_t length; + + if (!table.ReadU16(&length)) { + return OTS_FAILURE(); + } + + // Empty VariationStore is allowed. + if (!length) { + return true; + } + + if (length > table.remaining()) { + return OTS_FAILURE(); + } + + if (!ParseItemVariationStore(out_cff.GetFont(), + table.buffer() + table.offset(), length, + &(out_cff.region_index_count))) { + return OTS_FAILURE(); + } + + return true; +} + +bool ParseDictData(ots::Buffer& table, ots::Buffer& dict, + uint16_t glyphs, size_t sid_max, DICT_DATA_TYPE type, + ots::OpenTypeCFF *out_cff); + +bool ParseDictData(ots::Buffer& table, const ots::CFFIndex &index, + uint16_t glyphs, size_t sid_max, DICT_DATA_TYPE type, ots::OpenTypeCFF *out_cff) { for (unsigned i = 1; i < index.offsets.size(); ++i) { - if (type == DICT_DATA_TOPLEVEL) { - out_cff->char_strings_array.push_back(new ots::CFFIndex); - } size_t dict_length = index.offsets[i] - index.offsets[i - 1]; - ots::Buffer table(data + index.offsets[i - 1], dict_length); - - std::vector<std::pair<uint32_t, DICT_OPERAND_TYPE> > operands; + ots::Buffer dict(table.buffer() + index.offsets[i - 1], dict_length); - FONT_FORMAT font_format = FORMAT_UNKNOWN; - bool have_ros = false; - uint16_t charstring_glyphs = 0; - size_t charset_offset = 0; + if (!ParseDictData(table, dict, glyphs, sid_max, type, out_cff)) { + return OTS_FAILURE(); + } + } + return true; +} - while (table.offset() < dict_length) { - if (!ParseDictDataReadNext(&table, &operands)) { - return OTS_FAILURE(); - } - if (operands.empty()) { - return OTS_FAILURE(); - } - if (operands.size() > 48) { - // An operator may be preceded by up to a maximum of 48 operands. +bool ParseDictData(ots::Buffer& table, ots::Buffer& dict, + uint16_t glyphs, size_t sid_max, DICT_DATA_TYPE type, + ots::OpenTypeCFF *out_cff) { + bool cff2 = (out_cff->major == 2); + std::vector<Operand> operands; + + FONT_FORMAT font_format = FORMAT_UNKNOWN; + bool have_ros = false; + bool have_charstrings = false; + bool have_vstore = false; + size_t charset_offset = 0; + + if (cff2) { + // Parse VariationStore first, since it might be referenced in other places + // (e.g. FDArray) that might be parsed after it. + size_t dict_offset = dict.offset(); + while (dict.offset() < dict.length()) { + if (!ParseDictDataReadOperands(dict, operands, cff2)) { return OTS_FAILURE(); } if (operands.back().second != DICT_OPERATOR) continue; @@ -502,399 +640,503 @@ bool ParseDictData(const uint8_t *data, size_t table_length, const uint32_t op = operands.back().first; operands.pop_back(); - switch (op) { - // SID - case 0: // version - case 1: // Notice - case 2: // Copyright - case 3: // FullName - case 4: // FamilyName - case (12U << 8) + 0: // Copyright - case (12U << 8) + 21: // PostScript - case (12U << 8) + 22: // BaseFontName - case (12U << 8) + 38: // FontName - if (operands.size() != 1) { - return OTS_FAILURE(); - } - if (!CheckSid(operands.back(), sid_max)) { - return OTS_FAILURE(); - } - break; + if (op == 24) { // vstore + if (type != DICT_DATA_TOPLEVEL) { + return OTS_FAILURE(); + } + if (operands.size() != 1) { + return OTS_FAILURE(); + } + if (!CheckOffset(operands.back(), table.length())) { + return OTS_FAILURE(); + } + // parse "VariationStore Data Contents" + table.set_offset(operands.back().first); + if (!ParseVariationStore(*out_cff, table)) { + return OTS_FAILURE(); + } + break; + } + operands.clear(); + } + operands.clear(); + dict.set_offset(dict_offset); + } - // array - case 5: // FontBBox - case 14: // XUID - case (12U << 8) + 7: // FontMatrix - case (12U << 8) + 23: // BaseFontBlend (delta) - if (operands.empty()) { - return OTS_FAILURE(); - } - break; + while (dict.offset() < dict.length()) { + if (!ParseDictDataReadOperands(dict, operands, cff2)) { + return OTS_FAILURE(); + } + if (operands.back().second != DICT_OPERATOR) continue; - // number - case 13: // UniqueID - case (12U << 8) + 2: // ItalicAngle - case (12U << 8) + 3: // UnderlinePosition - case (12U << 8) + 4: // UnderlineThickness - case (12U << 8) + 5: // PaintType - case (12U << 8) + 8: // StrokeWidth - case (12U << 8) + 20: // SyntheticBase - if (operands.size() != 1) { - return OTS_FAILURE(); - } - break; - case (12U << 8) + 31: // CIDFontVersion - case (12U << 8) + 32: // CIDFontRevision - case (12U << 8) + 33: // CIDFontType - case (12U << 8) + 34: // CIDCount - case (12U << 8) + 35: // UIDBase - if (operands.size() != 1) { - return OTS_FAILURE(); - } - if (font_format != FORMAT_CID_KEYED) { - return OTS_FAILURE(); - } - break; - case (12U << 8) + 6: // CharstringType - if (operands.size() != 1) { - return OTS_FAILURE(); - } - if(operands.back().second != DICT_OPERAND_INTEGER) { - return OTS_FAILURE(); - } - if (operands.back().first != 2) { - // We only support the "Type 2 Charstring Format." - // TODO(yusukes): Support Type 1 format? Is that still in use? - return OTS_FAILURE(); - } - break; + // got operator + const uint32_t op = operands.back().first; + operands.pop_back(); - // boolean - case (12U << 8) + 1: // isFixedPitch - if (operands.size() != 1) { - return OTS_FAILURE(); - } - if (operands.back().second != DICT_OPERAND_INTEGER) { - return OTS_FAILURE(); - } - if (operands.back().first >= 2) { - return OTS_FAILURE(); - } - break; + if (cff2 && !ValidCFF2DictOp(op, type)) { + return OTS_FAILURE(); + } - // offset(0) - case 15: // charset - if (operands.size() != 1) { - return OTS_FAILURE(); - } - if (operands.back().first <= 2) { - // predefined charset, ISOAdobe, Expert or ExpertSubset, is used. - break; - } - if (!CheckOffset(operands.back(), table_length)) { - return OTS_FAILURE(); - } - if (charset_offset) { - return OTS_FAILURE(); // multiple charset tables? - } - charset_offset = operands.back().first; - break; + switch (op) { + // SID + case 0: // version + case 1: // Notice + case 2: // Copyright + case 3: // FullName + case 4: // FamilyName + case (12U << 8) + 0: // Copyright + case (12U << 8) + 21: // PostScript + case (12U << 8) + 22: // BaseFontName + case (12U << 8) + 38: // FontName + if (operands.size() != 1) { + return OTS_FAILURE(); + } + if (!CheckSid(operands.back(), sid_max)) { + return OTS_FAILURE(); + } + break; - case 16: { // Encoding - if (operands.size() != 1) { - return OTS_FAILURE(); - } - if (operands.back().first <= 1) { - break; // predefined encoding, "Standard" or "Expert", is used. - } - if (!CheckOffset(operands.back(), table_length)) { - return OTS_FAILURE(); - } + // array + case 5: // FontBBox + case 14: // XUID + case (12U << 8) + 7: // FontMatrix + case (12U << 8) + 23: // BaseFontBlend (delta) + if (operands.empty()) { + return OTS_FAILURE(); + } + break; - // parse sub dictionary INDEX. - ots::Buffer cff_table(data, table_length); - cff_table.set_offset(operands.back().first); - uint8_t format = 0; - if (!cff_table.ReadU8(&format)) { - return OTS_FAILURE(); - } - if (format & 0x80) { - // supplemental encoding is not supported at the moment. - return OTS_FAILURE(); - } - // TODO(yusukes): support & parse supplemental encoding tables. - break; + // number + case 13: // UniqueID + case (12U << 8) + 2: // ItalicAngle + case (12U << 8) + 3: // UnderlinePosition + case (12U << 8) + 4: // UnderlineThickness + case (12U << 8) + 5: // PaintType + case (12U << 8) + 8: // StrokeWidth + case (12U << 8) + 20: // SyntheticBase + if (operands.size() != 1) { + return OTS_FAILURE(); + } + break; + case (12U << 8) + 31: // CIDFontVersion + case (12U << 8) + 32: // CIDFontRevision + case (12U << 8) + 33: // CIDFontType + case (12U << 8) + 34: // CIDCount + case (12U << 8) + 35: // UIDBase + if (operands.size() != 1) { + return OTS_FAILURE(); + } + if (font_format != FORMAT_CID_KEYED) { + return OTS_FAILURE(); + } + break; + case (12U << 8) + 6: // CharstringType + if (operands.size() != 1) { + return OTS_FAILURE(); + } + if(operands.back().second != DICT_OPERAND_INTEGER) { + return OTS_FAILURE(); + } + if (operands.back().first != 2) { + // We only support the "Type 2 Charstring Format." + // TODO(yusukes): Support Type 1 format? Is that still in use? + return OTS_FAILURE(); } + break; - case 17: { // CharStrings - if (type != DICT_DATA_TOPLEVEL) { - return OTS_FAILURE(); - } - if (operands.size() != 1) { - return OTS_FAILURE(); - } - if (!CheckOffset(operands.back(), table_length)) { - return OTS_FAILURE(); - } - // parse "14. CharStrings INDEX" - ots::Buffer cff_table(data, table_length); - cff_table.set_offset(operands.back().first); - ots::CFFIndex *charstring_index = out_cff->char_strings_array.back(); - if (!ParseIndex(&cff_table, charstring_index)) { - return OTS_FAILURE(); - } - if (charstring_index->count < 2) { - return OTS_FAILURE(); - } - if (charstring_glyphs) { - return OTS_FAILURE(); // multiple charstring tables? - } - charstring_glyphs = charstring_index->count; - if (charstring_glyphs != glyphs) { - return OTS_FAILURE(); // CFF and maxp have different number of glyphs? - } + // boolean + case (12U << 8) + 1: // isFixedPitch + if (operands.size() != 1) { + return OTS_FAILURE(); + } + if (operands.back().second != DICT_OPERAND_INTEGER) { + return OTS_FAILURE(); + } + if (operands.back().first >= 2) { + return OTS_FAILURE(); + } + break; + + // offset(0) + case 15: // charset + if (operands.size() != 1) { + return OTS_FAILURE(); + } + if (operands.back().first <= 2) { + // predefined charset, ISOAdobe, Expert or ExpertSubset, is used. break; } + if (!CheckOffset(operands.back(), table.length())) { + return OTS_FAILURE(); + } + if (charset_offset) { + return OTS_FAILURE(); // multiple charset tables? + } + charset_offset = operands.back().first; + break; - case (12U << 8) + 36: { // FDArray - if (type != DICT_DATA_TOPLEVEL) { - return OTS_FAILURE(); - } - if (operands.size() != 1) { - return OTS_FAILURE(); - } - if (!CheckOffset(operands.back(), table_length)) { - return OTS_FAILURE(); - } + case 16: { // Encoding + if (operands.size() != 1) { + return OTS_FAILURE(); + } + if (operands.back().first <= 1) { + break; // predefined encoding, "Standard" or "Expert", is used. + } + if (!CheckOffset(operands.back(), table.length())) { + return OTS_FAILURE(); + } - // parse sub dictionary INDEX. - ots::Buffer cff_table(data, table_length); - cff_table.set_offset(operands.back().first); - ots::CFFIndex sub_dict_index; - if (!ParseIndex(&cff_table, &sub_dict_index)) { - return OTS_FAILURE(); - } - if (!ParseDictData(data, table_length, - sub_dict_index, - glyphs, sid_max, DICT_DATA_FDARRAY, - out_cff)) { - return OTS_FAILURE(); - } - if (out_cff->font_dict_length != 0) { - return OTS_FAILURE(); // two or more FDArray found. - } - out_cff->font_dict_length = sub_dict_index.count; - break; + table.set_offset(operands.back().first); + uint8_t format = 0; + if (!table.ReadU8(&format)) { + return OTS_FAILURE(); } + if (format & 0x80) { + // supplemental encoding is not supported at the moment. + return OTS_FAILURE(); + } + // TODO(yusukes): support & parse supplemental encoding tables. + break; + } - case (12U << 8) + 37: { // FDSelect - if (type != DICT_DATA_TOPLEVEL) { - return OTS_FAILURE(); + case 17: { // CharStrings + if (type != DICT_DATA_TOPLEVEL) { + return OTS_FAILURE(); + } + if (operands.size() != 1) { + return OTS_FAILURE(); + } + if (!CheckOffset(operands.back(), table.length())) { + return OTS_FAILURE(); + } + // parse "14. CharStrings INDEX" + table.set_offset(operands.back().first); + ots::CFFIndex *charstring_index = out_cff->charstrings_index; + if (!ParseIndex(table, *charstring_index, cff2)) { + return OTS_FAILURE(); + } + if (charstring_index->count < 2) { + return OTS_FAILURE(); + } + if (have_charstrings) { + return OTS_FAILURE(); // multiple charstring tables? + } + have_charstrings = true; + if (charstring_index->count != glyphs) { + return OTS_FAILURE(); // CFF and maxp have different number of glyphs? + } + break; + } + + case 24: { // vstore + if (!cff2) { + return OTS_FAILURE(); + } + if (have_vstore) { + return OTS_FAILURE(); // multiple vstore tables? + } + have_vstore = true; + // parsed above. + break; + } + + case (12U << 8) + 36: { // FDArray + if (type != DICT_DATA_TOPLEVEL) { + return OTS_FAILURE(); + } + if (operands.size() != 1) { + return OTS_FAILURE(); + } + if (!CheckOffset(operands.back(), table.length())) { + return OTS_FAILURE(); + } + + // parse Font DICT INDEX. + table.set_offset(operands.back().first); + ots::CFFIndex sub_dict_index; + if (!ParseIndex(table, sub_dict_index, cff2)) { + return OTS_FAILURE(); + } + if (!ParseDictData(table, sub_dict_index, + glyphs, sid_max, DICT_DATA_FDARRAY, + out_cff)) { + return OTS_FAILURE(); + } + if (out_cff->font_dict_length != 0) { + return OTS_FAILURE(); // two or more FDArray found. + } + out_cff->font_dict_length = sub_dict_index.count; + break; + } + + case (12U << 8) + 37: { // FDSelect + if (type != DICT_DATA_TOPLEVEL) { + return OTS_FAILURE(); + } + if (operands.size() != 1) { + return OTS_FAILURE(); + } + if (!CheckOffset(operands.back(), table.length())) { + return OTS_FAILURE(); + } + + // parse FDSelect data structure + table.set_offset(operands.back().first); + uint8_t format = 0; + if (!table.ReadU8(&format)) { + return OTS_FAILURE(); + } + if (format == 0) { + for (uint16_t j = 0; j < glyphs; ++j) { + uint8_t fd_index = 0; + if (!table.ReadU8(&fd_index)) { + return OTS_FAILURE(); + } + (out_cff->fd_select)[j] = fd_index; } - if (operands.size() != 1) { + } else if (format == 3) { + uint16_t n_ranges = 0; + if (!table.ReadU16(&n_ranges)) { return OTS_FAILURE(); } - if (!CheckOffset(operands.back(), table_length)) { + if (n_ranges == 0) { return OTS_FAILURE(); } - // parse FDSelect data structure - ots::Buffer cff_table(data, table_length); - cff_table.set_offset(operands.back().first); - uint8_t format = 0; - if (!cff_table.ReadU8(&format)) { - return OTS_FAILURE(); - } - if (format == 0) { - for (uint16_t j = 0; j < glyphs; ++j) { - uint8_t fd_index = 0; - if (!cff_table.ReadU8(&fd_index)) { - return OTS_FAILURE(); - } - (out_cff->fd_select)[j] = fd_index; - } - } else if (format == 3) { - uint16_t n_ranges = 0; - if (!cff_table.ReadU16(&n_ranges)) { + uint16_t last_gid = 0; + uint8_t fd_index = 0; + for (unsigned j = 0; j < n_ranges; ++j) { + uint16_t first = 0; // GID + if (!table.ReadU16(&first)) { return OTS_FAILURE(); } - if (n_ranges == 0) { + + // Sanity checks. + if ((j == 0) && (first != 0)) { return OTS_FAILURE(); } + if ((j != 0) && (last_gid >= first)) { + return OTS_FAILURE(); // not increasing order. + } + if (first >= glyphs) { + return OTS_FAILURE(); // invalid gid. + } - uint16_t last_gid = 0; - uint8_t fd_index = 0; - for (unsigned j = 0; j < n_ranges; ++j) { - uint16_t first = 0; // GID - if (!cff_table.ReadU16(&first)) { - return OTS_FAILURE(); - } - - // Sanity checks. - if ((j == 0) && (first != 0)) { - return OTS_FAILURE(); - } - if ((j != 0) && (last_gid >= first)) { - return OTS_FAILURE(); // not increasing order. - } - - // Copy the mapping to |out_cff->fd_select|. - if (j != 0) { - for (uint16_t k = last_gid; k < first; ++k) { - if (!out_cff->fd_select.insert( - std::make_pair(k, fd_index)).second) { - return OTS_FAILURE(); - } + // Copy the mapping to |out_cff->fd_select|. + if (j != 0) { + for (auto k = last_gid; k < first; ++k) { + if (!out_cff->fd_select.insert( + std::make_pair(k, fd_index)).second) { + return OTS_FAILURE(); } } - - if (!cff_table.ReadU8(&fd_index)) { - return OTS_FAILURE(); - } - last_gid = first; - // TODO(yusukes): check GID? - } - uint16_t sentinel = 0; - if (!cff_table.ReadU16(&sentinel)) { - return OTS_FAILURE(); } - if (last_gid >= sentinel) { + + if (!table.ReadU8(&fd_index)) { return OTS_FAILURE(); } - for (uint16_t k = last_gid; k < sentinel; ++k) { - if (!out_cff->fd_select.insert( - std::make_pair(k, fd_index)).second) { - return OTS_FAILURE(); - } - } - } else { - // unknown format - return OTS_FAILURE(); - } - break; - } - - // Private DICT (2 * number) - case 18: { - if (operands.size() != 2) { - return OTS_FAILURE(); + last_gid = first; } - if (operands.back().second != DICT_OPERAND_INTEGER) { + uint16_t sentinel = 0; + if (!table.ReadU16(&sentinel)) { return OTS_FAILURE(); } - const uint32_t private_offset = operands.back().first; - operands.pop_back(); - if (operands.back().second != DICT_OPERAND_INTEGER) { + if (last_gid >= sentinel) { return OTS_FAILURE(); } - const uint32_t private_length = operands.back().first; - if (private_offset > table_length) { - return OTS_FAILURE(); + if (sentinel > glyphs) { + return OTS_FAILURE(); // invalid gid. } - if (private_length >= table_length) { - return OTS_FAILURE(); + for (auto k = last_gid; k < sentinel; ++k) { + if (!out_cff->fd_select.insert( + std::make_pair(k, fd_index)).second) { + return OTS_FAILURE(); + } } - if (private_length + private_offset > table_length) { + } else if (cff2 && format == 4) { + uint32_t n_ranges = 0; + if (!table.ReadU32(&n_ranges)) { return OTS_FAILURE(); } - // parse "15. Private DICT Data" - if (!ParsePrivateDictData(data, table_length, - private_offset, private_length, - type, out_cff)) { + if (n_ranges == 0) { return OTS_FAILURE(); } - break; - } - // ROS - case (12U << 8) + 30: - if (font_format != FORMAT_UNKNOWN) { - return OTS_FAILURE(); + uint32_t last_gid = 0; + uint16_t fd_index = 0; + for (unsigned j = 0; j < n_ranges; ++j) { + uint32_t first = 0; // GID + if (!table.ReadU32(&first)) { + return OTS_FAILURE(); + } + + // Sanity checks. + if ((j == 0) && (first != 0)) { + return OTS_FAILURE(); + } + if ((j != 0) && (last_gid >= first)) { + return OTS_FAILURE(); // not increasing order. + } + if (first >= glyphs) { + return OTS_FAILURE(); // invalid gid. + } + + // Copy the mapping to |out_cff->fd_select|. + if (j != 0) { + for (auto k = last_gid; k < first; ++k) { + if (!out_cff->fd_select.insert( + std::make_pair(k, fd_index)).second) { + return OTS_FAILURE(); + } + } + } + + if (!table.ReadU16(&fd_index)) { + return OTS_FAILURE(); + } + last_gid = first; } - font_format = FORMAT_CID_KEYED; - if (operands.size() != 3) { + uint32_t sentinel = 0; + if (!table.ReadU32(&sentinel)) { return OTS_FAILURE(); } - // check SIDs - operands.pop_back(); // ignore the first number. - if (!CheckSid(operands.back(), sid_max)) { + if (last_gid >= sentinel) { return OTS_FAILURE(); } - operands.pop_back(); - if (!CheckSid(operands.back(), sid_max)) { - return OTS_FAILURE(); + if (sentinel > glyphs) { + return OTS_FAILURE(); // invalid gid. } - if (have_ros) { - return OTS_FAILURE(); // multiple ROS tables? + for (auto k = last_gid; k < sentinel; ++k) { + if (!out_cff->fd_select.insert( + std::make_pair(k, fd_index)).second) { + return OTS_FAILURE(); + } } - have_ros = true; - break; - - default: + } else { + // unknown format return OTS_FAILURE(); + } + break; } - operands.clear(); - if (font_format == FORMAT_UNKNOWN) { - font_format = FORMAT_OTHER; + // Private DICT (2 * number) + case 18: { + if (operands.size() != 2) { + return OTS_FAILURE(); + } + if (operands.back().second != DICT_OPERAND_INTEGER) { + return OTS_FAILURE(); + } + const uint32_t private_offset = operands.back().first; + operands.pop_back(); + if (operands.back().second != DICT_OPERAND_INTEGER) { + return OTS_FAILURE(); + } + const uint32_t private_length = operands.back().first; + if (private_offset > table.length()) { + return OTS_FAILURE(); + } + if (private_length >= table.length()) { + return OTS_FAILURE(); + } + if (private_length + private_offset > table.length()) { + return OTS_FAILURE(); + } + // parse "15. Private DICT data" + if (!ParsePrivateDictData(table, private_offset, private_length, + type, out_cff)) { + return OTS_FAILURE(); + } + break; } - } - // parse "13. Charsets" - if (charset_offset) { - ots::Buffer cff_table(data, table_length); - cff_table.set_offset(charset_offset); - uint8_t format = 0; - if (!cff_table.ReadU8(&format)) { + // ROS + case (12U << 8) + 30: + if (font_format != FORMAT_UNKNOWN) { + return OTS_FAILURE(); + } + font_format = FORMAT_CID_KEYED; + if (operands.size() != 3) { + return OTS_FAILURE(); + } + // check SIDs + operands.pop_back(); // ignore the first number. + if (!CheckSid(operands.back(), sid_max)) { + return OTS_FAILURE(); + } + operands.pop_back(); + if (!CheckSid(operands.back(), sid_max)) { + return OTS_FAILURE(); + } + if (have_ros) { + return OTS_FAILURE(); // multiple ROS tables? + } + have_ros = true; + break; + + default: return OTS_FAILURE(); - } - switch (format) { - case 0: - for (uint16_t j = 1 /* .notdef is omitted */; j < glyphs; ++j) { - uint16_t sid = 0; - if (!cff_table.ReadU16(&sid)) { - return OTS_FAILURE(); - } - if (!have_ros && (sid > sid_max)) { - return OTS_FAILURE(); - } - // TODO(yusukes): check CIDs when have_ros is true. + } + operands.clear(); + + if (font_format == FORMAT_UNKNOWN) { + font_format = FORMAT_OTHER; + } + } + + // parse "13. Charsets" + if (charset_offset) { + table.set_offset(charset_offset); + uint8_t format = 0; + if (!table.ReadU8(&format)) { + return OTS_FAILURE(); + } + switch (format) { + case 0: + for (uint16_t j = 1 /* .notdef is omitted */; j < glyphs; ++j) { + uint16_t sid = 0; + if (!table.ReadU16(&sid)) { + return OTS_FAILURE(); } - break; + if (!have_ros && (sid > sid_max)) { + return OTS_FAILURE(); + } + // TODO(yusukes): check CIDs when have_ros is true. + } + break; + + case 1: + case 2: { + uint32_t total = 1; // .notdef is omitted. + while (total < glyphs) { + uint16_t sid = 0; + if (!table.ReadU16(&sid)) { + return OTS_FAILURE(); + } + if (!have_ros && (sid > sid_max)) { + return OTS_FAILURE(); + } + // TODO(yusukes): check CIDs when have_ros is true. - case 1: - case 2: { - uint32_t total = 1; // .notdef is omitted. - while (total < glyphs) { - uint16_t sid = 0; - if (!cff_table.ReadU16(&sid)) { + if (format == 1) { + uint8_t left = 0; + if (!table.ReadU8(&left)) { return OTS_FAILURE(); } - if (!have_ros && (sid > sid_max)) { + total += (left + 1); + } else { + uint16_t left = 0; + if (!table.ReadU16(&left)) { return OTS_FAILURE(); } - // TODO(yusukes): check CIDs when have_ros is true. - - if (format == 1) { - uint8_t left = 0; - if (!cff_table.ReadU8(&left)) { - return OTS_FAILURE(); - } - total += (left + 1); - } else { - uint16_t left = 0; - if (!cff_table.ReadU16(&left)) { - return OTS_FAILURE(); - } - total += (left + 1); - } + total += (left + 1); } - break; } - - default: - return OTS_FAILURE(); + break; } + + default: + return OTS_FAILURE(); } } return true; @@ -904,147 +1146,218 @@ bool ParseDictData(const uint8_t *data, size_t table_length, namespace ots { -bool ots_cff_parse(Font *font, const uint8_t *data, size_t length) { +bool OpenTypeCFF::ValidateFDSelect(uint16_t num_glyphs) { + for (const auto& fd_select : this->fd_select) { + if (fd_select.first >= num_glyphs) { + return Error("Invalid glyph index in FDSelect: %d >= %d\n", + fd_select.first, num_glyphs); + } + if (fd_select.second >= this->font_dict_length) { + return Error("Invalid FD index: %d >= %d\n", + fd_select.second, this->font_dict_length); + } + } + return true; +} + +bool OpenTypeCFF::Parse(const uint8_t *data, size_t length) { Buffer table(data, length); - font->cff = new OpenTypeCFF; - font->cff->data = data; - font->cff->length = length; - font->cff->font_dict_length = 0; - font->cff->local_subrs = NULL; + Font *font = GetFont(); + + this->m_data = data; + this->m_length = length; // parse "6. Header" in the Adobe Compact Font Format Specification uint8_t major = 0; uint8_t minor = 0; uint8_t hdr_size = 0; uint8_t off_size = 0; - if (!table.ReadU8(&major)) { - return OTS_FAILURE(); + if (!table.ReadU8(&major) || + !table.ReadU8(&minor) || + !table.ReadU8(&hdr_size) || + !table.ReadU8(&off_size)) { + return Error("Failed to read table header"); } - if (!table.ReadU8(&minor)) { - return OTS_FAILURE(); - } - if (!table.ReadU8(&hdr_size)) { - return OTS_FAILURE(); - } - if (!table.ReadU8(&off_size)) { - return OTS_FAILURE(); - } - if ((off_size == 0) || (off_size > 4)) { - return OTS_FAILURE(); + + if (off_size < 1 || off_size > 4) { + return Error("Bad offSize: %d", off_size); } - if ((major != 1) || - (minor != 0) || - (hdr_size != 4)) { - return OTS_FAILURE(); + if (major != 1 || minor != 0) { + return Error("Unsupported table version: %d.%d", major, minor); } - if (hdr_size >= length) { - return OTS_FAILURE(); + + this->major = major; + + if (hdr_size != 4 || hdr_size >= length) { + return Error("Bad hdrSize: %d", hdr_size); } // parse "7. Name INDEX" table.set_offset(hdr_size); CFFIndex name_index; - if (!ParseIndex(&table, &name_index)) { - return OTS_FAILURE(); + if (!ParseIndex(table, name_index)) { + return Error("Failed to parse Name INDEX"); } - if (!ParseNameData(&table, name_index, &(font->cff->name))) { - return OTS_FAILURE(); + if (name_index.count != 1 || name_index.offsets.size() != 2) { + return Error("Name INDEX must contain only one entry, not %d", + name_index.count); + } + if (!ParseNameData(&table, name_index, &(this->name))) { + return Error("Failed to parse Name INDEX data"); } // parse "8. Top DICT INDEX" table.set_offset(name_index.offset_to_next); CFFIndex top_dict_index; - if (!ParseIndex(&table, &top_dict_index)) { - return OTS_FAILURE(); + if (!ParseIndex(table, top_dict_index)) { + return Error("Failed to parse Top DICT INDEX"); } - if (name_index.count != top_dict_index.count) { - return OTS_FAILURE(); + if (top_dict_index.count != 1) { + return Error("Top DICT INDEX must contain only one entry, not %d", + top_dict_index.count); } // parse "10. String INDEX" table.set_offset(top_dict_index.offset_to_next); CFFIndex string_index; - if (!ParseIndex(&table, &string_index)) { - return OTS_FAILURE(); + if (!ParseIndex(table, string_index)) { + return Error("Failed to parse String INDEX"); } if (string_index.count >= 65000 - kNStdString) { - return OTS_FAILURE(); + return Error("Too many entries in String INDEX: %d", string_index.count); } - const uint16_t num_glyphs = font->maxp->num_glyphs; + OpenTypeMAXP *maxp = static_cast<OpenTypeMAXP*>( + font->GetTypedTable(OTS_TAG_MAXP)); + if (!maxp) { + return Error("Required maxp table missing"); + } + const uint16_t num_glyphs = maxp->num_glyphs; const size_t sid_max = string_index.count + kNStdString; // string_index.count == 0 is allowed. // parse "9. Top DICT Data" - if (!ParseDictData(data, length, top_dict_index, + this->charstrings_index = new ots::CFFIndex; + if (!ParseDictData(table, top_dict_index, num_glyphs, sid_max, - DICT_DATA_TOPLEVEL, font->cff)) { - return OTS_FAILURE(); + DICT_DATA_TOPLEVEL, this)) { + return Error("Failed to parse Top DICT Data"); } // parse "16. Global Subrs INDEX" table.set_offset(string_index.offset_to_next); CFFIndex global_subrs_index; - if (!ParseIndex(&table, &global_subrs_index)) { - return OTS_FAILURE(); + if (!ParseIndex(table, global_subrs_index)) { + return Error("Failed to parse Global Subrs INDEX"); } - // Check if all fd_index in FDSelect are valid. - std::map<uint16_t, uint8_t>::const_iterator iter; - std::map<uint16_t, uint8_t>::const_iterator end = font->cff->fd_select.end(); - for (iter = font->cff->fd_select.begin(); iter != end; ++iter) { - if (iter->second >= font->cff->font_dict_length) { - return OTS_FAILURE(); - } + // Check if all fd and glyph indices in FDSelect are valid. + if (!ValidateFDSelect(num_glyphs)) { + return Error("Failed to validate FDSelect"); } // Check if all charstrings (font hinting code for each glyph) are valid. - for (size_t i = 0; i < font->cff->char_strings_array.size(); ++i) { - if (!ValidateType2CharStringIndex(font, - *(font->cff->char_strings_array.at(i)), - global_subrs_index, - font->cff->fd_select, - font->cff->local_subrs_per_font, - font->cff->local_subrs, - &table)) { - return OTS_FAILURE_MSG("Failed validating charstring set %d", (int) i); - } + if (!ValidateCFFCharStrings(*this, global_subrs_index, &table)) { + return Error("Failed validating CharStrings INDEX"); } return true; } -bool ots_cff_should_serialise(Font *font) { - return font->cff != NULL; +bool OpenTypeCFF::Serialize(OTSStream *out) { + if (!out->Write(this->m_data, this->m_length)) { + return Error("Failed to write table"); + } + return true; } -bool ots_cff_serialise(OTSStream *out, Font *font) { - // TODO(yusukes): would be better to transcode the data, - // rather than simple memcpy. - if (!out->Write(font->cff->data, font->cff->length)) { - return OTS_FAILURE(); +OpenTypeCFF::~OpenTypeCFF() { + for (size_t i = 0; i < this->local_subrs_per_font.size(); ++i) { + delete (this->local_subrs_per_font)[i]; } - return true; + delete this->charstrings_index; + delete this->local_subrs; } -void ots_cff_reuse(Font *font, Font *other) { - font->cff = other->cff; - font->cff_reused = true; +bool OpenTypeCFF2::Parse(const uint8_t *data, size_t length) { + Buffer table(data, length); + + Font *font = GetFont(); + + this->m_data = data; + this->m_length = length; + + // parse "6. Header" + uint8_t major = 0; + uint8_t minor = 0; + uint8_t hdr_size = 0; + uint16_t top_dict_size = 0; + if (!table.ReadU8(&major) || + !table.ReadU8(&minor) || + !table.ReadU8(&hdr_size) || + !table.ReadU16(&top_dict_size)) { + return Error("Failed to read table header"); + } + + if (major != 2 || minor != 0) { + return Error("Unsupported table version: %d.%d", major, minor); + } + + this->major = major; + + if (hdr_size >= length) { + return Error("Bad hdrSize: %d", hdr_size); + } + + if (top_dict_size == 0 || hdr_size + top_dict_size > length) { + return Error("Bad topDictLength: %d", top_dict_size); + } + + OpenTypeMAXP *maxp = static_cast<OpenTypeMAXP*>( + font->GetTypedTable(OTS_TAG_MAXP)); + if (!maxp) { + return Error("Required maxp table missing"); + } + const uint16_t num_glyphs = maxp->num_glyphs; + const size_t sid_max = kNStdString; + + // parse "7. Top DICT Data" + ots::Buffer top_dict(data + hdr_size, top_dict_size); + table.set_offset(hdr_size); + this->charstrings_index = new ots::CFFIndex; + if (!ParseDictData(table, top_dict, + num_glyphs, sid_max, + DICT_DATA_TOPLEVEL, this)) { + return Error("Failed to parse Top DICT Data"); + } + + // parse "9. Global Subrs INDEX" + table.set_offset(hdr_size + top_dict_size); + CFFIndex global_subrs_index; + if (!ParseIndex(table, global_subrs_index, true)) { + return Error("Failed to parse Global Subrs INDEX"); + } + + // Check if all fd and glyph indices in FDSelect are valid. + if (!ValidateFDSelect(num_glyphs)) { + return Error("Failed to validate FDSelect"); + } + + // Check if all charstrings (font hinting code for each glyph) are valid. + if (!ValidateCFFCharStrings(*this, global_subrs_index, &table)) { + return Error("Failed validating CharStrings INDEX"); + } + + return true; } -void ots_cff_free(Font *font) { - if (font->cff) { - for (size_t i = 0; i < font->cff->char_strings_array.size(); ++i) { - delete (font->cff->char_strings_array)[i]; - } - for (size_t i = 0; i < font->cff->local_subrs_per_font.size(); ++i) { - delete (font->cff->local_subrs_per_font)[i]; - } - delete font->cff->local_subrs; - delete font->cff; +bool OpenTypeCFF2::Serialize(OTSStream *out) { + if (!out->Write(this->m_data, this->m_length)) { + return Error("Failed to write table"); } + return true; } } // namespace ots diff --git a/gfx/ots/src/cff.h b/gfx/ots/src/cff.h index 5584acc62..cfce9ab91 100644 --- a/gfx/ots/src/cff.h +++ b/gfx/ots/src/cff.h @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -11,34 +11,81 @@ #include <string> #include <vector> +#undef major // glibc defines major! + namespace ots { struct CFFIndex { CFFIndex() : count(0), off_size(0), offset_to_next(0) {} - uint16_t count; + uint32_t count; uint8_t off_size; std::vector<uint32_t> offsets; uint32_t offset_to_next; }; -struct OpenTypeCFF { - const uint8_t *data; - size_t length; +typedef std::map<uint32_t, uint16_t> CFFFDSelect; + +class OpenTypeCFF : public Table { + public: + explicit OpenTypeCFF(Font *font, uint32_t tag) + : Table(font, tag, tag), + major(0), + font_dict_length(0), + charstrings_index(NULL), + local_subrs(NULL), + m_data(NULL), + m_length(0) { + } + + ~OpenTypeCFF(); + + bool Parse(const uint8_t *data, size_t length); + bool Serialize(OTSStream *out); + + // Major version number. + uint8_t major; + // Name INDEX. This name is used in name.cc as a postscript font name. std::string name; // The number of fonts the file has. size_t font_dict_length; // A map from glyph # to font #. - std::map<uint16_t, uint8_t> fd_select; + CFFFDSelect fd_select; // A list of char strings. - std::vector<CFFIndex *> char_strings_array; + CFFIndex* charstrings_index; // A list of Local Subrs associated with FDArrays. Can be empty. std::vector<CFFIndex *> local_subrs_per_font; // A Local Subrs associated with Top DICT. Can be NULL. CFFIndex *local_subrs; + + // CFF2 VariationStore regionIndexCount. + std::vector<uint16_t> region_index_count; + + protected: + bool ValidateFDSelect(uint16_t num_glyphs); + + private: + const uint8_t *m_data; + size_t m_length; +}; + +class OpenTypeCFF2 : public OpenTypeCFF { + public: + explicit OpenTypeCFF2(Font *font, uint32_t tag) + : OpenTypeCFF(font, tag), + m_data(NULL), + m_length(0) { + } + + bool Parse(const uint8_t *data, size_t length); + bool Serialize(OTSStream *out); + + private: + const uint8_t *m_data; + size_t m_length; }; } // namespace ots diff --git a/gfx/ots/src/cff_type2_charstring.cc b/gfx/ots/src/cff_charstring.cc index 8c5544b2e..23c17d183 100644 --- a/gfx/ots/src/cff_type2_charstring.cc +++ b/gfx/ots/src/cff_charstring.cc @@ -1,11 +1,11 @@ -// Copyright (c) 2010 The Chromium Authors. All rights reserved. +// Copyright (c) 2010-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. // A parser for the Type 2 Charstring Format. // http://www.adobe.com/devnet/font/pdfs/5177.Type2.pdf -#include "cff_type2_charstring.h" +#include "cff_charstring.h" #include <climits> #include <cstdio> @@ -22,7 +22,6 @@ namespace { // Note #5177. const int32_t kMaxSubrsCount = 65536; const size_t kMaxCharStringLength = 65535; -const size_t kMaxArgumentStack = 48; const size_t kMaxNumberOfStemHints = 96; const size_t kMaxSubrNesting = 10; @@ -30,117 +29,130 @@ const size_t kMaxSubrNesting = 10; // will fail with the dummy value. const int32_t dummy_result = INT_MAX; -bool ExecuteType2CharString(ots::Font *font, - size_t call_depth, - const ots::CFFIndex& global_subrs_index, - const ots::CFFIndex& local_subrs_index, - ots::Buffer *cff_table, - ots::Buffer *char_string, - std::stack<int32_t> *argument_stack, - bool *out_found_endchar, - bool *out_found_width, - size_t *in_out_num_stems); +bool ExecuteCharString(ots::OpenTypeCFF& cff, + size_t call_depth, + const ots::CFFIndex& global_subrs_index, + const ots::CFFIndex& local_subrs_index, + ots::Buffer *cff_table, + ots::Buffer *char_string, + std::stack<int32_t> *argument_stack, + bool *out_found_endchar, + bool *out_found_width, + size_t *in_out_num_stems, + bool cff2); + +bool ArgumentStackOverflows(std::stack<int32_t> *argument_stack, bool cff2) { + if ((cff2 && argument_stack->size() > ots::kMaxCFF2ArgumentStack) || + (!cff2 && argument_stack->size() > ots::kMaxCFF1ArgumentStack)) { + return true; + } + return false; +} #ifdef DUMP_T2CHARSTRING // Converts |op| to a string and returns it. -const char *Type2CharStringOperatorToString(ots::Type2CharStringOperator op) { +const char *CharStringOperatorToString(ots::CharStringOperator op) { switch (op) { case ots::kHStem: - return "HStem"; + return "hstem"; case ots::kVStem: - return "VStem"; + return "vstem"; case ots::kVMoveTo: - return "VMoveTo"; + return "vmoveto"; case ots::kRLineTo: - return "RLineTo"; + return "rlineto"; case ots::kHLineTo: - return "HLineTo"; + return "hlineto"; case ots::kVLineTo: - return "VLineTo"; + return "vlineto"; case ots::kRRCurveTo: - return "RRCurveTo"; + return "rrcurveto"; case ots::kCallSubr: - return "CallSubr"; + return "callsubr"; case ots::kReturn: - return "Return"; + return "return"; case ots::kEndChar: - return "EndChar"; + return "endchar"; + case ots::kVSIndex: + return "vsindex"; + case ots::kBlend: + return "blend"; case ots::kHStemHm: - return "HStemHm"; + return "hstemhm"; case ots::kHintMask: - return "HintMask"; + return "hintmask"; case ots::kCntrMask: - return "CntrMask"; + return "cntrmask"; case ots::kRMoveTo: - return "RMoveTo"; + return "rmoveto"; case ots::kHMoveTo: - return "HMoveTo"; + return "hmoveto"; case ots::kVStemHm: - return "VStemHm"; + return "vstemhm"; case ots::kRCurveLine: - return "RCurveLine"; + return "rcurveline"; case ots::kRLineCurve: - return "RLineCurve"; + return "rlinecurve"; case ots::kVVCurveTo: return "VVCurveTo"; case ots::kHHCurveTo: - return "HHCurveTo"; + return "hhcurveto"; case ots::kCallGSubr: - return "CallGSubr"; + return "callgsubr"; case ots::kVHCurveTo: - return "VHCurveTo"; + return "vhcurveto"; case ots::kHVCurveTo: return "HVCurveTo"; case ots::kDotSection: - return "DotSection"; + return "dotsection"; case ots::kAnd: - return "And"; + return "and"; case ots::kOr: - return "Or"; + return "or"; case ots::kNot: - return "Not"; + return "not"; case ots::kAbs: - return "Abs"; + return "abs"; case ots::kAdd: - return "Add"; + return "add"; case ots::kSub: - return "Sub"; + return "sub"; case ots::kDiv: - return "Div"; + return "div"; case ots::kNeg: - return "Neg"; + return "neg"; case ots::kEq: - return "Eq"; + return "eq"; case ots::kDrop: - return "Drop"; + return "drop"; case ots::kPut: - return "Put"; + return "put"; case ots::kGet: - return "Get"; + return "get"; case ots::kIfElse: - return "IfElse"; + return "ifelse"; case ots::kRandom: - return "Random"; + return "random"; case ots::kMul: - return "Mul"; + return "mul"; case ots::kSqrt: - return "Sqrt"; + return "sqrt"; case ots::kDup: - return "Dup"; + return "dup"; case ots::kExch: - return "Exch"; + return "exch"; case ots::kIndex: - return "Index"; + return "index"; case ots::kRoll: - return "Roll"; + return "roll"; case ots::kHFlex: - return "HFlex"; + return "hflex"; case ots::kFlex: - return "Flex"; + return "flex"; case ots::kHFlex1: - return "HFlex1"; + return "hflex1"; case ots::kFlex1: - return "Flex1"; + return "flex1"; } return "UNKNOWN"; @@ -150,9 +162,9 @@ const char *Type2CharStringOperatorToString(ots::Type2CharStringOperator op) { // Read one or more bytes from the |char_string| buffer and stores the number // read on |out_number|. If the number read is an operator (ex 'vstem'), sets // true on |out_is_operator|. Returns true if the function read a number. -bool ReadNextNumberFromType2CharString(ots::Buffer *char_string, - int32_t *out_number, - bool *out_is_operator) { +bool ReadNextNumberFromCharString(ots::Buffer *char_string, + int32_t *out_number, + bool *out_is_operator) { uint8_t v = 0; if (!char_string->ReadU8(&v)) { return OTS_FAILURE(); @@ -174,7 +186,7 @@ bool ReadNextNumberFromType2CharString(ots::Buffer *char_string, *out_is_operator = true; } else if (v <= 27) { // Special handling for v==19 and v==20 are implemented in - // ExecuteType2CharStringOperator(). + // ExecuteCharStringOperator(). *out_number = v; *out_is_operator = true; } else if (v == 28) { @@ -221,23 +233,63 @@ bool ReadNextNumberFromType2CharString(ots::Buffer *char_string, return true; } +bool ValidCFF2Operator(int32_t op) { + switch (op) { + case ots::kReturn: + case ots::kEndChar: + case ots::kAbs: + case ots::kAdd: + case ots::kSub: + case ots::kDiv: + case ots::kNeg: + case ots::kRandom: + case ots::kMul: + case ots::kSqrt: + case ots::kDrop: + case ots::kExch: + case ots::kIndex: + case ots::kRoll: + case ots::kDup: + case ots::kPut: + case ots::kGet: + case ots::kDotSection: + case ots::kAnd: + case ots::kOr: + case ots::kNot: + case ots::kEq: + case ots::kIfElse: + return false; + } + + return true; +} + // Executes |op| and updates |argument_stack|. Returns true if the execution // succeeds. If the |op| is kCallSubr or kCallGSubr, the function recursively -// calls ExecuteType2CharString() function. The arguments other than |op| and +// calls ExecuteCharString() function. The arguments other than |op| and // |argument_stack| are passed for that reason. -bool ExecuteType2CharStringOperator(ots::Font *font, - int32_t op, - size_t call_depth, - const ots::CFFIndex& global_subrs_index, - const ots::CFFIndex& local_subrs_index, - ots::Buffer *cff_table, - ots::Buffer *char_string, - std::stack<int32_t> *argument_stack, - bool *out_found_endchar, - bool *in_out_found_width, - size_t *in_out_num_stems) { +bool ExecuteCharStringOperator(ots::OpenTypeCFF& cff, + int32_t op, + size_t call_depth, + const ots::CFFIndex& global_subrs_index, + const ots::CFFIndex& local_subrs_index, + ots::Buffer *cff_table, + ots::Buffer *char_string, + std::stack<int32_t> *argument_stack, + bool *out_found_endchar, + bool *in_out_found_width, + size_t *in_out_num_stems, + bool *in_out_have_blend, + bool *in_out_have_visindex, + int32_t *in_out_vsindex, + bool cff2) { + ots::Font* font = cff.GetFont(); const size_t stack_size = argument_stack->size(); + if (cff2 && !ValidCFF2Operator(op)) { + return OTS_FAILURE(); + } + switch (op) { case ots::kCallSubr: case ots::kCallGSubr: { @@ -290,16 +342,17 @@ bool ExecuteType2CharStringOperator(ots::Font *font, } ots::Buffer char_string_to_jump(cff_table->buffer() + offset, length); - return ExecuteType2CharString(font, - call_depth + 1, - global_subrs_index, - local_subrs_index, - cff_table, - &char_string_to_jump, - argument_stack, - out_found_endchar, - in_out_found_width, - in_out_num_stems); + return ExecuteCharString(cff, + call_depth + 1, + global_subrs_index, + local_subrs_index, + cff_table, + &char_string_to_jump, + argument_stack, + out_found_endchar, + in_out_found_width, + in_out_num_stems, + cff2); } case ots::kReturn: @@ -310,6 +363,51 @@ bool ExecuteType2CharStringOperator(ots::Font *font, *in_out_found_width = true; // just in case. return true; + case ots::kVSIndex: { + if (!cff2) { + return OTS_FAILURE(); + } + if (stack_size != 1) { + return OTS_FAILURE(); + } + if (*in_out_have_blend || *in_out_have_visindex) { + return OTS_FAILURE(); + } + if (argument_stack->top() >= cff.region_index_count.size()) { + return OTS_FAILURE(); + } + *in_out_have_visindex = true; + *in_out_vsindex = argument_stack->top(); + while (!argument_stack->empty()) + argument_stack->pop(); + return true; + } + + case ots::kBlend: { + if (!cff2) { + return OTS_FAILURE(); + } + if (stack_size < 1) { + return OTS_FAILURE(); + } + if (*in_out_vsindex >= cff.region_index_count.size()) { + return OTS_FAILURE(); + } + uint16_t k = cff.region_index_count.at(*in_out_vsindex); + uint16_t n = argument_stack->top(); + if (stack_size < n * (k + 1) + 1) { + return OTS_FAILURE(); + } + + // Keep the 1st n operands on the stack for the next operator to use and + // pop the rest. There can be multiple consecutive blend operator, so this + // makes sure the operands of all of them are kept on the stack. + while (argument_stack->size() > stack_size - ((n * k) + 1)) + argument_stack->pop(); + *in_out_have_blend = true; + return true; + } + case ots::kHStem: case ots::kVStem: case ots::kHStemHm: @@ -649,7 +747,7 @@ bool ExecuteType2CharStringOperator(ots::Font *font, argument_stack->pop(); argument_stack->push(dummy_result); argument_stack->push(dummy_result); - if (argument_stack->size() > kMaxArgumentStack) { + if (ArgumentStackOverflows(argument_stack, cff2)) { return OTS_FAILURE(); } // TODO(yusukes): Implement this. We should push a real value for all @@ -729,26 +827,29 @@ bool ExecuteType2CharStringOperator(ots::Font *font, // in_out_found_width: true is set if |char_string| contains 'width' byte (which // is 0 or 1 byte.) // in_out_num_stems: total number of hstems and vstems processed so far. -bool ExecuteType2CharString(ots::Font *font, - size_t call_depth, - const ots::CFFIndex& global_subrs_index, - const ots::CFFIndex& local_subrs_index, - ots::Buffer *cff_table, - ots::Buffer *char_string, - std::stack<int32_t> *argument_stack, - bool *out_found_endchar, - bool *in_out_found_width, - size_t *in_out_num_stems) { +bool ExecuteCharString(ots::OpenTypeCFF& cff, + size_t call_depth, + const ots::CFFIndex& global_subrs_index, + const ots::CFFIndex& local_subrs_index, + ots::Buffer *cff_table, + ots::Buffer *char_string, + std::stack<int32_t> *argument_stack, + bool *out_found_endchar, + bool *in_out_found_width, + size_t *in_out_num_stems, + bool cff2) { if (call_depth > kMaxSubrNesting) { return OTS_FAILURE(); } *out_found_endchar = false; + bool in_out_have_blend = false, in_out_have_visindex = false; + int32_t in_out_vsindex = 0; const size_t length = char_string->length(); while (char_string->offset() < length) { int32_t operator_or_operand = 0; bool is_operator = false; - if (!ReadNextNumberFromType2CharString(char_string, + if (!ReadNextNumberFromCharString(char_string, &operator_or_operand, &is_operator)) { return OTS_FAILURE(); @@ -761,35 +862,39 @@ bool ExecuteType2CharString(ots::Font *font, */ if (!is_operator) { - std::fprintf(stderr, "#%d# ", operator_or_operand); + std::fprintf(stderr, "%d ", operator_or_operand); } else { - std::fprintf(stderr, "#%s#\n", - Type2CharStringOperatorToString( - ots::Type2CharStringOperator(operator_or_operand)) + std::fprintf(stderr, "%s\n", + CharStringOperatorToString( + ots::CharStringOperator(operator_or_operand)) ); } #endif if (!is_operator) { argument_stack->push(operator_or_operand); - if (argument_stack->size() > kMaxArgumentStack) { + if (ArgumentStackOverflows(argument_stack, cff2)) { return OTS_FAILURE(); } continue; } // An operator is found. Execute it. - if (!ExecuteType2CharStringOperator(font, - operator_or_operand, - call_depth, - global_subrs_index, - local_subrs_index, - cff_table, - char_string, - argument_stack, - out_found_endchar, - in_out_found_width, - in_out_num_stems)) { + if (!ExecuteCharStringOperator(cff, + operator_or_operand, + call_depth, + global_subrs_index, + local_subrs_index, + cff_table, + char_string, + argument_stack, + out_found_endchar, + in_out_found_width, + in_out_num_stems, + &in_out_have_blend, + &in_out_have_visindex, + &in_out_vsindex, + cff2)) { return OTS_FAILURE(); } if (*out_found_endchar) { @@ -801,37 +906,39 @@ bool ExecuteType2CharString(ots::Font *font, } // No endchar operator is found. + if (cff2) + return true; return OTS_FAILURE(); } // Selects a set of subroutings for |glyph_index| from |cff| and sets it on // |out_local_subrs_to_use|. Returns true on success. -bool SelectLocalSubr(const std::map<uint16_t, uint8_t> &fd_select, - const std::vector<ots::CFFIndex *> &local_subrs_per_font, - const ots::CFFIndex *local_subrs, +bool SelectLocalSubr(const ots::OpenTypeCFF& cff, uint16_t glyph_index, // 0-origin const ots::CFFIndex **out_local_subrs_to_use) { + bool cff2 = (cff.major == 2); *out_local_subrs_to_use = NULL; // First, find local subrs from |local_subrs_per_font|. - if ((fd_select.size() > 0) && - (!local_subrs_per_font.empty())) { + if ((cff.fd_select.size() > 0) && + (!cff.local_subrs_per_font.empty())) { // Look up FDArray index for the glyph. - std::map<uint16_t, uint8_t>::const_iterator iter = - fd_select.find(glyph_index); - if (iter == fd_select.end()) { + const auto& iter = cff.fd_select.find(glyph_index); + if (iter == cff.fd_select.end()) { return OTS_FAILURE(); } - const uint8_t fd_index = iter->second; - if (fd_index >= local_subrs_per_font.size()) { + const auto fd_index = iter->second; + if (fd_index >= cff.local_subrs_per_font.size()) { return OTS_FAILURE(); } - *out_local_subrs_to_use = local_subrs_per_font.at(fd_index); - } else if (local_subrs) { + *out_local_subrs_to_use = cff.local_subrs_per_font.at(fd_index); + } else if (cff.local_subrs) { // Second, try to use |local_subrs|. Most Latin fonts don't have FDSelect // entries. If The font has a local subrs index associated with the Top // DICT (not FDArrays), use it. - *out_local_subrs_to_use = local_subrs; + *out_local_subrs_to_use = cff.local_subrs; + } else if (cff2 && cff.local_subrs_per_font.size() == 1) { + *out_local_subrs_to_use = cff.local_subrs_per_font.at(0); } else { // Just return NULL. *out_local_subrs_to_use = NULL; @@ -844,18 +951,16 @@ bool SelectLocalSubr(const std::map<uint16_t, uint8_t> &fd_select, namespace ots { -bool ValidateType2CharStringIndex( - ots::Font *font, - const CFFIndex& char_strings_index, +bool ValidateCFFCharStrings( + ots::OpenTypeCFF& cff, const CFFIndex& global_subrs_index, - const std::map<uint16_t, uint8_t> &fd_select, - const std::vector<CFFIndex *> &local_subrs_per_font, - const CFFIndex *local_subrs, Buffer* cff_table) { + const CFFIndex& char_strings_index = *(cff.charstrings_index); if (char_strings_index.offsets.size() == 0) { return OTS_FAILURE(); // no charstring. } + bool cff2 = (cff.major == 2); // For each glyph, validate the corresponding charstring. for (unsigned i = 1; i < char_strings_index.offsets.size(); ++i) { // Prepare a Buffer object, |char_string|, which contains the charstring @@ -875,9 +980,7 @@ bool ValidateType2CharStringIndex( // Get a local subrs for the glyph. const unsigned glyph_index = i - 1; // index in the map is 0-origin. const CFFIndex *local_subrs_to_use = NULL; - if (!SelectLocalSubr(fd_select, - local_subrs_per_font, - local_subrs, + if (!SelectLocalSubr(cff, glyph_index, &local_subrs_to_use)) { return OTS_FAILURE(); @@ -891,16 +994,19 @@ bool ValidateType2CharStringIndex( // Check a charstring for the |i|-th glyph. std::stack<int32_t> argument_stack; bool found_endchar = false; - bool found_width = false; + // CFF2 CharString has no value for width, so we start with true here to + // error out if width is found. + bool found_width = cff2; size_t num_stems = 0; - if (!ExecuteType2CharString(font, - 0 /* initial call_depth is zero */, - global_subrs_index, *local_subrs_to_use, - cff_table, &char_string, &argument_stack, - &found_endchar, &found_width, &num_stems)) { + if (!ExecuteCharString(cff, + 0 /* initial call_depth is zero */, + global_subrs_index, *local_subrs_to_use, + cff_table, &char_string, &argument_stack, + &found_endchar, &found_width, &num_stems, + cff2)) { return OTS_FAILURE(); } - if (!found_endchar) { + if (!cff2 && !found_endchar) { return OTS_FAILURE(); } } diff --git a/gfx/ots/src/cff_type2_charstring.h b/gfx/ots/src/cff_charstring.h index be44bc72c..5a2fa9ff2 100644 --- a/gfx/ots/src/cff_type2_charstring.h +++ b/gfx/ots/src/cff_charstring.h @@ -1,4 +1,4 @@ -// Copyright (c) 2010 The Chromium Authors. All rights reserved. +// Copyright (c) 2010-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -13,6 +13,9 @@ namespace ots { +const size_t kMaxCFF1ArgumentStack = 48; +const size_t kMaxCFF2ArgumentStack = 513; + // Validates all charstrings in |char_strings_index|. Charstring is a small // language for font hinting defined in Adobe Technical Note #5177. // http://www.adobe.com/devnet/font/pdfs/5177.Type2.pdf @@ -34,17 +37,14 @@ namespace ots { // local_subrs: A Local Subrs associated with Top DICT. Can be NULL. // cff_table: A buffer which contains actual byte code of charstring, global // subroutines and local subroutines. -bool ValidateType2CharStringIndex( - Font *font, - const CFFIndex &char_strings_index, +bool ValidateCFFCharStrings( + OpenTypeCFF& cff, const CFFIndex &global_subrs_index, - const std::map<uint16_t, uint8_t> &fd_select, - const std::vector<CFFIndex *> &local_subrs_per_font, - const CFFIndex *local_subrs, Buffer *cff_table); // The list of Operators. See Appendix. A in Adobe Technical Note #5177. -enum Type2CharStringOperator { +// and https://docs.microsoft.com/en-us/typography/opentype/spec/cff2charstr +enum CharStringOperator { kHStem = 1, kVStem = 3, kVMoveTo = 4, @@ -55,6 +55,8 @@ enum Type2CharStringOperator { kCallSubr = 10, kReturn = 11, kEndChar = 14, + kVSIndex = 15, + kBlend = 16, kHStemHm = 18, kHintMask = 19, kCntrMask = 20, diff --git a/gfx/ots/src/cmap.cc b/gfx/ots/src/cmap.cc index 325f8e0d1..72c2a20fc 100644 --- a/gfx/ots/src/cmap.cc +++ b/gfx/ots/src/cmap.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -15,8 +15,6 @@ // cmap - Character To Glyph Index Mapping Table // http://www.microsoft.com/typography/otspec/cmap.htm -#define TABLE_NAME "cmap" - namespace { struct CMAPSubtableHeader { @@ -56,8 +54,12 @@ const uint32_t kIVSStart = 0xE0100; const uint32_t kIVSEnd = 0xE01EF; const uint32_t kUVSUpperLimit = 0xFFFFFF; +} // namespace + +namespace ots { + // Parses Format 4 tables -bool ParseFormat4(ots::Font *font, int platform, int encoding, +bool OpenTypeCMAP::ParseFormat4(int platform, int encoding, const uint8_t *data, size_t length, uint16_t num_glyphs) { ots::Buffer subtable(data, length); @@ -65,20 +67,22 @@ bool ParseFormat4(ots::Font *font, int platform, int encoding, // whole thing and recompacting it, we validate it and include it verbatim // in the output. - if (!font->os2) { - return OTS_FAILURE_MSG("Required OS/2 table missing"); + OpenTypeOS2 *os2 = static_cast<OpenTypeOS2*>( + GetFont()->GetTypedTable(OTS_TAG_OS2)); + if (!os2) { + return Error("Required OS/2 table missing"); } if (!subtable.Skip(4)) { - return OTS_FAILURE_MSG("Can't read 4 bytes at start of cmap format 4 subtable"); + return Error("Can't read 4 bytes at start of cmap format 4 subtable"); } uint16_t language = 0; if (!subtable.ReadU16(&language)) { - return OTS_FAILURE_MSG("Can't read language"); + return Error("Can't read language"); } if (language) { // Platform ID 3 (windows) subtables should have language '0'. - return OTS_FAILURE_MSG("Languages should be 0 (%d)", language); + return Error("Languages should be 0 (%d)", language); } uint16_t segcountx2, search_range, entry_selector, range_shift; @@ -87,16 +91,16 @@ bool ParseFormat4(ots::Font *font, int platform, int encoding, !subtable.ReadU16(&search_range) || !subtable.ReadU16(&entry_selector) || !subtable.ReadU16(&range_shift)) { - return OTS_FAILURE_MSG("Failed to read subcmap structure"); + return Error("Failed to read subcmap structure"); } if (segcountx2 & 1 || search_range & 1) { - return OTS_FAILURE_MSG("Bad subcmap structure"); + return Error("Bad subcmap structure"); } const uint16_t segcount = segcountx2 >> 1; // There must be at least one segment according the spec. if (segcount < 1) { - return OTS_FAILURE_MSG("Segcount < 1 (%d)", segcount); + return Error("Segcount < 1 (%d)", segcount); } // log2segcount is the maximal x s.t. 2^x < segcount @@ -107,48 +111,48 @@ bool ParseFormat4(ots::Font *font, int platform, int encoding, const uint16_t expected_search_range = 2 * 1u << log2segcount; if (expected_search_range != search_range) { - return OTS_FAILURE_MSG("expected search range != search range (%d != %d)", expected_search_range, search_range); + return Error("expected search range != search range (%d != %d)", expected_search_range, search_range); } if (entry_selector != log2segcount) { - return OTS_FAILURE_MSG("entry selector != log2(segement count) (%d != %d)", entry_selector, log2segcount); + return Error("entry selector != log2(segement count) (%d != %d)", entry_selector, log2segcount); } const uint16_t expected_range_shift = segcountx2 - search_range; if (range_shift != expected_range_shift) { - return OTS_FAILURE_MSG("unexpected range shift (%d != %d)", range_shift, expected_range_shift); + return Error("unexpected range shift (%d != %d)", range_shift, expected_range_shift); } std::vector<Subtable314Range> ranges(segcount); for (unsigned i = 0; i < segcount; ++i) { if (!subtable.ReadU16(&ranges[i].end_range)) { - return OTS_FAILURE_MSG("Failed to read segment %d", i); + return Error("Failed to read segment %d", i); } } uint16_t padding; if (!subtable.ReadU16(&padding)) { - return OTS_FAILURE_MSG("Failed to read cmap subtable segment padding"); + return Error("Failed to read cmap subtable segment padding"); } if (padding) { - return OTS_FAILURE_MSG("Non zero cmap subtable segment padding (%d)", padding); + return Error("Non zero cmap subtable segment padding (%d)", padding); } for (unsigned i = 0; i < segcount; ++i) { if (!subtable.ReadU16(&ranges[i].start_range)) { - return OTS_FAILURE_MSG("Failed to read segment start range %d", i); + return Error("Failed to read segment start range %d", i); } } for (unsigned i = 0; i < segcount; ++i) { if (!subtable.ReadS16(&ranges[i].id_delta)) { - return OTS_FAILURE_MSG("Failed to read segment delta %d", i); + return Error("Failed to read segment delta %d", i); } } for (unsigned i = 0; i < segcount; ++i) { ranges[i].id_range_offset_offset = subtable.offset(); if (!subtable.ReadU16(&ranges[i].id_range_offset)) { - return OTS_FAILURE_MSG("Failed to read segment range offset %d", i); + return Error("Failed to read segment range offset %d", i); } if (ranges[i].id_range_offset & 1) { @@ -156,12 +160,12 @@ bool ParseFormat4(ots::Font *font, int platform, int encoding, // for 0xFFFF-0xFFFF range. // (e.g., many fonts in http://www.princexml.com/fonts/) if (i == segcount - 1u) { - OTS_WARNING("bad id_range_offset"); + Warning("bad id_range_offset"); ranges[i].id_range_offset = 0; // The id_range_offset value in the transcoded font will not change // since this table is not actually "transcoded" yet. } else { - return OTS_FAILURE_MSG("Bad segment offset (%d)", ranges[i].id_range_offset); + return Error("Bad segment offset (%d)", ranges[i].id_range_offset); } } } @@ -176,36 +180,36 @@ bool ParseFormat4(ots::Font *font, int platform, int encoding, (ranges[i].end_range == 0xffff)) { // Some fonts (e.g., Germania.ttf) have multiple 0xffff terminators. // We'll accept them as an exception. - OTS_WARNING("multiple 0xffff terminators found"); + Warning("multiple 0xffff terminators found"); continue; } // Note: some Linux fonts (e.g., LucidaSansOblique.ttf, bsmi00lp.ttf) have // unsorted table... if (ranges[i].end_range <= ranges[i - 1].end_range) { - return OTS_FAILURE_MSG("Out of order end range (%d <= %d)", ranges[i].end_range, ranges[i-1].end_range); + return Error("Out of order end range (%d <= %d)", ranges[i].end_range, ranges[i-1].end_range); } if (ranges[i].start_range <= ranges[i - 1].end_range) { - return OTS_FAILURE_MSG("out of order start range (%d <= %d)", ranges[i].start_range, ranges[i-1].end_range); + return Error("out of order start range (%d <= %d)", ranges[i].start_range, ranges[i-1].end_range); } // On many fonts, the value of {first, last}_char_index are incorrect. // Fix them. - if (font->os2->first_char_index != 0xFFFF && + if (os2->table.first_char_index != 0xFFFF && ranges[i].start_range != 0xFFFF && - font->os2->first_char_index > ranges[i].start_range) { - font->os2->first_char_index = ranges[i].start_range; + os2->table.first_char_index > ranges[i].start_range) { + os2->table.first_char_index = ranges[i].start_range; } - if (font->os2->last_char_index != 0xFFFF && + if (os2->table.last_char_index != 0xFFFF && ranges[i].end_range != 0xFFFF && - font->os2->last_char_index < ranges[i].end_range) { - font->os2->last_char_index = ranges[i].end_range; + os2->table.last_char_index < ranges[i].end_range) { + os2->table.last_char_index = ranges[i].end_range; } } // The last range must end at 0xffff if (ranges[segcount - 1].start_range != 0xffff || ranges[segcount - 1].end_range != 0xffff) { - return OTS_FAILURE_MSG("Final segment start and end must be 0xFFFF (0x%04X-0x%04X)", + return Error("Final segment start and end must be 0xFFFF (0x%04X-0x%04X)", ranges[segcount - 1].start_range, ranges[segcount - 1].end_range); } @@ -219,7 +223,7 @@ bool ParseFormat4(ots::Font *font, int platform, int encoding, // this is explictly allowed to overflow in the spec const uint16_t glyph = code_point + ranges[i].id_delta; if (glyph >= num_glyphs) { - return OTS_FAILURE_MSG("Range glyph reference too high (%d > %d)", glyph, num_glyphs - 1); + return Error("Range glyph reference too high (%d > %d)", glyph, num_glyphs - 1); } } else { const uint16_t range_delta = code_point - ranges[i].start_range; @@ -230,13 +234,13 @@ bool ParseFormat4(ots::Font *font, int platform, int encoding, range_delta * 2; // We need to be able to access a 16-bit value from this offset if (glyph_id_offset + 1 >= length) { - return OTS_FAILURE_MSG("bad glyph id offset (%d > %ld)", glyph_id_offset, length); + return Error("bad glyph id offset (%d > %ld)", glyph_id_offset, length); } uint16_t glyph; std::memcpy(&glyph, data + glyph_id_offset, 2); - glyph = ntohs(glyph); + glyph = ots_ntohs(glyph); if (glyph >= num_glyphs) { - return OTS_FAILURE_MSG("Range glyph reference too high (%d > %d)", glyph, num_glyphs - 1); + return Error("Range glyph reference too high (%d > %d)", glyph, num_glyphs - 1); } } } @@ -245,85 +249,85 @@ bool ParseFormat4(ots::Font *font, int platform, int encoding, // We accept the table. // TODO(yusukes): transcode the subtable. if (platform == 3 && encoding == 0) { - font->cmap->subtable_3_0_4_data = data; - font->cmap->subtable_3_0_4_length = length; + this->subtable_3_0_4_data = data; + this->subtable_3_0_4_length = length; } else if (platform == 3 && encoding == 1) { - font->cmap->subtable_3_1_4_data = data; - font->cmap->subtable_3_1_4_length = length; + this->subtable_3_1_4_data = data; + this->subtable_3_1_4_length = length; } else if (platform == 0 && encoding == 3) { - font->cmap->subtable_0_3_4_data = data; - font->cmap->subtable_0_3_4_length = length; + this->subtable_0_3_4_data = data; + this->subtable_0_3_4_length = length; } else { - return OTS_FAILURE_MSG("Unknown cmap subtable type (platform=%d, encoding=%d)", platform, encoding); + return Error("Unknown cmap subtable type (platform=%d, encoding=%d)", platform, encoding); } return true; } -bool Parse31012(ots::Font *font, - const uint8_t *data, size_t length, uint16_t num_glyphs) { +bool OpenTypeCMAP::Parse31012(const uint8_t *data, size_t length, + uint16_t num_glyphs) { ots::Buffer subtable(data, length); // Format 12 tables are simple. We parse these and fully serialise them // later. if (!subtable.Skip(8)) { - return OTS_FAILURE_MSG("failed to skip the first 8 bytes of format 12 subtable"); + return Error("failed to skip the first 8 bytes of format 12 subtable"); } uint32_t language = 0; if (!subtable.ReadU32(&language)) { - return OTS_FAILURE_MSG("can't read format 12 subtable language"); + return Error("can't read format 12 subtable language"); } if (language) { - return OTS_FAILURE_MSG("format 12 subtable language should be zero (%d)", language); + return Error("format 12 subtable language should be zero (%d)", language); } uint32_t num_groups = 0; if (!subtable.ReadU32(&num_groups)) { - return OTS_FAILURE_MSG("can't read number of format 12 subtable groups"); + return Error("can't read number of format 12 subtable groups"); } if (num_groups == 0 || subtable.remaining() / 12 < num_groups) { - return OTS_FAILURE_MSG("Bad format 12 subtable group count %d", num_groups); + return Error("Bad format 12 subtable group count %d", num_groups); } std::vector<ots::OpenTypeCMAPSubtableRange> &groups - = font->cmap->subtable_3_10_12; + = this->subtable_3_10_12; groups.resize(num_groups); for (unsigned i = 0; i < num_groups; ++i) { if (!subtable.ReadU32(&groups[i].start_range) || !subtable.ReadU32(&groups[i].end_range) || !subtable.ReadU32(&groups[i].start_glyph_id)) { - return OTS_FAILURE_MSG("can't read format 12 subtable group"); + return Error("can't read format 12 subtable group"); } if (groups[i].start_range > kUnicodeUpperLimit || groups[i].end_range > kUnicodeUpperLimit || groups[i].start_glyph_id > 0xFFFF) { - return OTS_FAILURE_MSG("bad format 12 subtable group (startCharCode=0x%4X, endCharCode=0x%4X, startGlyphID=%d)", + return Error("bad format 12 subtable group (startCharCode=0x%4X, endCharCode=0x%4X, startGlyphID=%d)", groups[i].start_range, groups[i].end_range, groups[i].start_glyph_id); } // We assert that the glyph value is within range. Because of the range // limits, above, we don't need to worry about overflow. if (groups[i].end_range < groups[i].start_range) { - return OTS_FAILURE_MSG("format 12 subtable group endCharCode before startCharCode (0x%4X < 0x%4X)", + return Error("format 12 subtable group endCharCode before startCharCode (0x%4X < 0x%4X)", groups[i].end_range, groups[i].start_range); } if ((groups[i].end_range - groups[i].start_range) + groups[i].start_glyph_id > num_glyphs) { - return OTS_FAILURE_MSG("bad format 12 subtable group startGlyphID (%d)", groups[i].start_glyph_id); + return Error("bad format 12 subtable group startGlyphID (%d)", groups[i].start_glyph_id); } } // the groups must be sorted by start code and may not overlap for (unsigned i = 1; i < num_groups; ++i) { if (groups[i].start_range <= groups[i - 1].start_range) { - return OTS_FAILURE_MSG("out of order format 12 subtable group (startCharCode=0x%4X <= startCharCode=0x%4X of previous group)", + return Error("out of order format 12 subtable group (startCharCode=0x%4X <= startCharCode=0x%4X of previous group)", groups[i].start_range, groups[i-1].start_range); } if (groups[i].start_range <= groups[i - 1].end_range) { - return OTS_FAILURE_MSG("overlapping format 12 subtable groups (startCharCode=0x%4X <= endCharCode=0x%4X of previous group)", + return Error("overlapping format 12 subtable groups (startCharCode=0x%4X <= endCharCode=0x%4X of previous group)", groups[i].start_range, groups[i-1].end_range); } } @@ -331,44 +335,43 @@ bool Parse31012(ots::Font *font, return true; } -bool Parse31013(ots::Font *font, - const uint8_t *data, size_t length, uint16_t num_glyphs) { +bool OpenTypeCMAP::Parse31013(const uint8_t *data, size_t length, + uint16_t num_glyphs) { ots::Buffer subtable(data, length); // Format 13 tables are simple. We parse these and fully serialise them // later. if (!subtable.Skip(8)) { - return OTS_FAILURE_MSG("Bad cmap subtable length"); + return Error("Bad cmap subtable length"); } uint32_t language = 0; if (!subtable.ReadU32(&language)) { - return OTS_FAILURE_MSG("Can't read cmap subtable language"); + return Error("Can't read cmap subtable language"); } if (language) { - return OTS_FAILURE_MSG("Cmap subtable language should be zero but is %d", language); + return Error("Cmap subtable language should be zero but is %d", language); } uint32_t num_groups = 0; if (!subtable.ReadU32(&num_groups)) { - return OTS_FAILURE_MSG("Can't read number of groups in a cmap subtable"); + return Error("Can't read number of groups in a cmap subtable"); } // We limit the number of groups in the same way as in 3.10.12 tables. See // the comment there in if (num_groups == 0 || subtable.remaining() / 12 < num_groups) { - return OTS_FAILURE_MSG("Bad format 13 subtable group count %d", num_groups); + return Error("Bad format 13 subtable group count %d", num_groups); } - std::vector<ots::OpenTypeCMAPSubtableRange> &groups - = font->cmap->subtable_3_10_13; + std::vector<ots::OpenTypeCMAPSubtableRange> &groups = this->subtable_3_10_13; groups.resize(num_groups); for (unsigned i = 0; i < num_groups; ++i) { if (!subtable.ReadU32(&groups[i].start_range) || !subtable.ReadU32(&groups[i].end_range) || !subtable.ReadU32(&groups[i].start_glyph_id)) { - return OTS_FAILURE_MSG("Can't read subrange structure in a cmap subtable"); + return Error("Can't read subrange structure in a cmap subtable"); } // We conservatively limit all of the values to protect some parsers from @@ -376,29 +379,29 @@ bool Parse31013(ots::Font *font, if (groups[i].start_range > kUnicodeUpperLimit || groups[i].end_range > kUnicodeUpperLimit || groups[i].start_glyph_id > 0xFFFF) { - return OTS_FAILURE_MSG("Bad subrange with start_range=%d, end_range=%d, start_glyph_id=%d", groups[i].start_range, groups[i].end_range, groups[i].start_glyph_id); + return Error("Bad subrange with start_range=%d, end_range=%d, start_glyph_id=%d", groups[i].start_range, groups[i].end_range, groups[i].start_glyph_id); } if (groups[i].start_glyph_id >= num_glyphs) { - return OTS_FAILURE_MSG("Subrange starting glyph id too high (%d > %d)", groups[i].start_glyph_id, num_glyphs); + return Error("Subrange starting glyph id too high (%d > %d)", groups[i].start_glyph_id, num_glyphs); } } // the groups must be sorted by start code and may not overlap for (unsigned i = 1; i < num_groups; ++i) { if (groups[i].start_range <= groups[i - 1].start_range) { - return OTS_FAILURE_MSG("Overlapping subrange starts (%d >= %d)", groups[i]. start_range, groups[i-1].start_range); + return Error("Overlapping subrange starts (%d >= %d)", groups[i]. start_range, groups[i-1].start_range); } if (groups[i].start_range <= groups[i - 1].end_range) { - return OTS_FAILURE_MSG("Overlapping subranges (%d <= %d)", groups[i].start_range, groups[i-1].end_range); + return Error("Overlapping subranges (%d <= %d)", groups[i].start_range, groups[i-1].end_range); } } return true; } -bool Parse0514(ots::Font *font, - const uint8_t *data, size_t length, uint16_t num_glyphs) { +bool OpenTypeCMAP::Parse0514(const uint8_t *data, size_t length, + uint16_t num_glyphs) { // Unicode Variation Selector table ots::Buffer subtable(data, length); @@ -407,26 +410,26 @@ bool Parse0514(ots::Font *font, // Skip format (USHORT) and length (ULONG) if (!subtable.Skip(6)) { - return OTS_FAILURE_MSG("Can't read start of cmap subtable"); + return Error("Can't read start of cmap subtable"); } uint32_t num_records = 0; if (!subtable.ReadU32(&num_records)) { - return OTS_FAILURE_MSG("Can't read number of records in cmap subtable"); + return Error("Can't read number of records in cmap subtable"); } if (num_records == 0 || num_records > kMaxCMAPSelectorRecords) { - return OTS_FAILURE_MSG("Bad format 14 subtable records count %d", num_records); + return Error("Bad format 14 subtable records count %d", num_records); } std::vector<ots::OpenTypeCMAPSubtableVSRecord>& records - = font->cmap->subtable_0_5_14; + = this->subtable_0_5_14; records.resize(num_records); for (unsigned i = 0; i < num_records; ++i) { if (!subtable.ReadU24(&records[i].var_selector) || !subtable.ReadU32(&records[i].default_offset) || !subtable.ReadU32(&records[i].non_default_offset)) { - return OTS_FAILURE_MSG("Can't read record structure of record %d in cmap subtale", i); + return Error("Can't read record structure of record %d in cmap subtale", i); } // Checks the value of variation selector if (!((records[i].var_selector >= kMongolianVSStart && @@ -435,24 +438,24 @@ bool Parse0514(ots::Font *font, records[i].var_selector <= kVSEnd) || (records[i].var_selector >= kIVSStart && records[i].var_selector <= kIVSEnd))) { - return OTS_FAILURE_MSG("Bad record variation selector (%04X) in record %i", records[i].var_selector, i); + return Error("Bad record variation selector (%04X) in record %i", records[i].var_selector, i); } if (i > 0 && records[i-1].var_selector >= records[i].var_selector) { - return OTS_FAILURE_MSG("Out of order variation selector (%04X >= %04X) in record %d", records[i-1].var_selector, records[i].var_selector, i); + return Error("Out of order variation selector (%04X >= %04X) in record %d", records[i-1].var_selector, records[i].var_selector, i); } // Checks offsets if (!records[i].default_offset && !records[i].non_default_offset) { - return OTS_FAILURE_MSG("No default aoffset in variation selector record %d", i); + return Error("No default aoffset in variation selector record %d", i); } if (records[i].default_offset && records[i].default_offset >= length) { - return OTS_FAILURE_MSG("Default offset too high (%d >= %ld) in record %d", records[i].default_offset, length, i); + return Error("Default offset too high (%d >= %ld) in record %d", records[i].default_offset, length, i); } if (records[i].non_default_offset && records[i].non_default_offset >= length) { - return OTS_FAILURE_MSG("Non default offset too high (%d >= %ld) in record %d", records[i].non_default_offset, length, i); + return Error("Non default offset too high (%d >= %ld) in record %d", records[i].non_default_offset, length, i); } } @@ -462,10 +465,10 @@ bool Parse0514(ots::Font *font, subtable.set_offset(records[i].default_offset); uint32_t num_ranges = 0; if (!subtable.ReadU32(&num_ranges)) { - return OTS_FAILURE_MSG("Can't read number of ranges in record %d", i); + return Error("Can't read number of ranges in record %d", i); } if (num_ranges == 0 || subtable.remaining() / 4 < num_ranges) { - return OTS_FAILURE_MSG("Bad number of ranges (%d) in record %d", num_ranges, i); + return Error("Bad number of ranges (%d) in record %d", num_ranges, i); } uint32_t last_unicode_value = 0; @@ -476,7 +479,7 @@ bool Parse0514(ots::Font *font, for (unsigned j = 0; j < num_ranges; ++j) { if (!subtable.ReadU24(&ranges[j].unicode_value) || !subtable.ReadU8(&ranges[j].additional_count)) { - return OTS_FAILURE_MSG("Can't read range info in variation selector record %d", i); + return Error("Can't read range info in variation selector record %d", i); } const uint32_t check_value = ranges[j].unicode_value + ranges[j].additional_count; @@ -485,7 +488,7 @@ bool Parse0514(ots::Font *font, check_value > kUVSUpperLimit || (last_unicode_value && ranges[j].unicode_value <= last_unicode_value)) { - return OTS_FAILURE_MSG("Bad Unicode value *%04X) in variation selector range %d record %d", ranges[j].unicode_value, j, i); + return Error("Bad Unicode value *%04X) in variation selector range %d record %d", ranges[j].unicode_value, j, i); } last_unicode_value = check_value; } @@ -496,10 +499,10 @@ bool Parse0514(ots::Font *font, subtable.set_offset(records[i].non_default_offset); uint32_t num_mappings = 0; if (!subtable.ReadU32(&num_mappings)) { - return OTS_FAILURE_MSG("Can't read number of mappings in variation selector record %d", i); + return Error("Can't read number of mappings in variation selector record %d", i); } if (num_mappings == 0 || subtable.remaining() / 5 < num_mappings) { - return OTS_FAILURE_MSG("Bad number of mappings (%d) in variation selector record %d", num_mappings, i); + return Error("Bad number of mappings (%d) in variation selector record %d", num_mappings, i); } uint32_t last_unicode_value = 0; @@ -510,14 +513,14 @@ bool Parse0514(ots::Font *font, for (unsigned j = 0; j < num_mappings; ++j) { if (!subtable.ReadU24(&mappings[j].unicode_value) || !subtable.ReadU16(&mappings[j].glyph_id)) { - return OTS_FAILURE_MSG("Can't read mapping %d in variation selector record %d", j, i); + return Error("Can't read mapping %d in variation selector record %d", j, i); } if (mappings[j].glyph_id == 0 || mappings[j].unicode_value == 0 || mappings[j].unicode_value > kUnicodeUpperLimit || (last_unicode_value && mappings[j].unicode_value <= last_unicode_value)) { - return OTS_FAILURE_MSG("Bad mapping (%04X -> %d) in mapping %d of variation selector %d", mappings[j].unicode_value, mappings[j].glyph_id, j, i); + return Error("Bad mapping (%04X -> %d) in mapping %d of variation selector %d", mappings[j].unicode_value, mappings[j].glyph_id, j, i); } last_unicode_value = mappings[j].unicode_value; } @@ -525,60 +528,55 @@ bool Parse0514(ots::Font *font, } if (subtable.offset() != length) { - return OTS_FAILURE_MSG("Bad subtable offset (%ld != %ld)", subtable.offset(), length); + return Error("Bad subtable offset (%ld != %ld)", subtable.offset(), length); } - font->cmap->subtable_0_5_14_length = subtable.offset(); + this->subtable_0_5_14_length = subtable.offset(); return true; } -bool Parse100(ots::Font *font, const uint8_t *data, size_t length) { +bool OpenTypeCMAP::Parse100(const uint8_t *data, size_t length) { // Mac Roman table ots::Buffer subtable(data, length); if (!subtable.Skip(4)) { - return OTS_FAILURE_MSG("Bad cmap subtable"); + return Error("Bad cmap subtable"); } uint16_t language = 0; if (!subtable.ReadU16(&language)) { - return OTS_FAILURE_MSG("Can't read language in cmap subtable"); + return Error("Can't read language in cmap subtable"); } if (language) { // simsun.ttf has non-zero language id. - OTS_WARNING("language id should be zero: %u", language); + Warning("language id should be zero: %u", language); } - font->cmap->subtable_1_0_0.reserve(kFormat0ArraySize); + this->subtable_1_0_0.reserve(kFormat0ArraySize); for (size_t i = 0; i < kFormat0ArraySize; ++i) { uint8_t glyph_id = 0; if (!subtable.ReadU8(&glyph_id)) { - return OTS_FAILURE_MSG("Can't read glyph id at array[%ld] in cmap subtable", i); + return Error("Can't read glyph id at array[%ld] in cmap subtable", i); } - font->cmap->subtable_1_0_0.push_back(glyph_id); + this->subtable_1_0_0.push_back(glyph_id); } return true; } -} // namespace - -namespace ots { - -bool ots_cmap_parse(Font *font, const uint8_t *data, size_t length) { +bool OpenTypeCMAP::Parse(const uint8_t *data, size_t length) { Buffer table(data, length); - font->cmap = new OpenTypeCMAP; uint16_t version = 0; uint16_t num_tables = 0; if (!table.ReadU16(&version) || !table.ReadU16(&num_tables)) { - return OTS_FAILURE_MSG("Can't read structure of cmap"); + return Error("Can't read structure of cmap"); } if (version != 0) { - return OTS_FAILURE_MSG("Non zero cmap version (%d)", version); + return Error("Non zero cmap version (%d)", version); } if (!num_tables) { - return OTS_FAILURE_MSG("No subtables in cmap!"); + return Error("No subtables in cmap!"); } std::vector<CMAPSubtableHeader> subtable_headers; @@ -591,7 +589,7 @@ bool ots_cmap_parse(Font *font, const uint8_t *data, size_t length) { if (!table.ReadU16(&subt.platform) || !table.ReadU16(&subt.encoding) || !table.ReadU32(&subt.offset)) { - return OTS_FAILURE_MSG("Can't read subtable information cmap subtable %d", i); + return Error("Can't read subtable information cmap subtable %d", i); } subtable_headers.push_back(subt); @@ -602,11 +600,11 @@ bool ots_cmap_parse(Font *font, const uint8_t *data, size_t length) { // make sure that all the offsets are valid. for (unsigned i = 0; i < num_tables; ++i) { if (subtable_headers[i].offset > 1024 * 1024 * 1024) { - return OTS_FAILURE_MSG("Bad subtable offset in cmap subtable %d", i); + return Error("Bad subtable offset in cmap subtable %d", i); } if (subtable_headers[i].offset < data_offset || subtable_headers[i].offset >= length) { - return OTS_FAILURE_MSG("Bad subtable offset (%d) in cmap subtable %d", subtable_headers[i].offset, i); + return Error("Bad subtable offset (%d) in cmap subtable %d", subtable_headers[i].offset, i); } } @@ -615,7 +613,7 @@ bool ots_cmap_parse(Font *font, const uint8_t *data, size_t length) { for (unsigned i = 0; i < num_tables; ++i) { table.set_offset(subtable_headers[i].offset); if (!table.ReadU16(&subtable_headers[i].format)) { - return OTS_FAILURE_MSG("Can't read cmap subtable header format %d", i); + return Error("Can't read cmap subtable header format %d", i); } uint16_t len = 0; @@ -624,10 +622,10 @@ bool ots_cmap_parse(Font *font, const uint8_t *data, size_t length) { case 0: case 4: if (!table.ReadU16(&len)) { - return OTS_FAILURE_MSG("Can't read cmap subtable %d length", i); + return Error("Can't read cmap subtable %d length", i); } if (!table.ReadU16(&lang)) { - return OTS_FAILURE_MSG("Can't read cmap subtable %d language", i); + return Error("Can't read cmap subtable %d language", i); } subtable_headers[i].length = len; subtable_headers[i].language = lang; @@ -635,18 +633,18 @@ bool ots_cmap_parse(Font *font, const uint8_t *data, size_t length) { case 12: case 13: if (!table.Skip(2)) { - return OTS_FAILURE_MSG("Bad cmap subtable %d structure", i); + return Error("Bad cmap subtable %d structure", i); } if (!table.ReadU32(&subtable_headers[i].length)) { - return OTS_FAILURE_MSG("Can read cmap subtable %d length", i); + return Error("Can read cmap subtable %d length", i); } if (!table.ReadU32(&subtable_headers[i].language)) { - return OTS_FAILURE_MSG("Can't read cmap subtable %d language", i); + return Error("Can't read cmap subtable %d language", i); } break; case 14: if (!table.ReadU32(&subtable_headers[i].length)) { - return OTS_FAILURE_MSG("Can't read cmap subtable %d length", i); + return Error("Can't read cmap subtable %d length", i); } subtable_headers[i].language = 0; break; @@ -664,7 +662,7 @@ bool ots_cmap_parse(Font *font, const uint8_t *data, size_t length) { (subtable_headers[i - 1].encoding > subtable_headers[i].encoding || (subtable_headers[i - 1].encoding == subtable_headers[i].encoding && subtable_headers[i - 1].language > subtable_headers[i].language)))) - OTS_WARNING("subtable %d with platform ID %d, encoding ID %d, language ID %d " + Warning("subtable %d with platform ID %d, encoding ID %d, language ID %d " "following subtable with platform ID %d, encoding ID %d, language ID %d", i, subtable_headers[i].platform, @@ -679,14 +677,14 @@ bool ots_cmap_parse(Font *font, const uint8_t *data, size_t length) { for (unsigned i = 0; i < num_tables; ++i) { if (!subtable_headers[i].length) continue; if (subtable_headers[i].length > 1024 * 1024 * 1024) { - return OTS_FAILURE_MSG("Bad cmap subtable %d length", i); + return Error("Bad cmap subtable %d length", i); } // We know that both the offset and length are < 1GB, so the following // addition doesn't overflow const uint32_t end_byte = subtable_headers[i].offset + subtable_headers[i].length; if (end_byte > length) { - return OTS_FAILURE_MSG("Over long cmap subtable %d @ %d for %d", i, subtable_headers[i].offset, subtable_headers[i].length); + return Error("Over long cmap subtable %d @ %d for %d", i, subtable_headers[i].offset, subtable_headers[i].length); } } @@ -714,16 +712,18 @@ bool ots_cmap_parse(Font *font, const uint8_t *data, size_t length) { for (unsigned i = 0; i < overlap_checker.size(); ++i) { overlap_count += (overlap_checker[i].second ? 1 : -1); if (overlap_count > 1) { - return OTS_FAILURE_MSG("Excessive overlap count %d", overlap_count); + return Error("Excessive overlap count %d", overlap_count); } } // we grab the number of glyphs in the file from the maxp table to make sure // that the character map isn't referencing anything beyound this range. - if (!font->maxp) { - return OTS_FAILURE_MSG("No maxp table in font! Needed by cmap."); + OpenTypeMAXP *maxp = static_cast<OpenTypeMAXP*>( + GetFont()->GetTypedTable(OTS_TAG_MAXP)); + if (!maxp) { + return Error("No maxp table in font! Needed by cmap."); } - const uint16_t num_glyphs = font->maxp->num_glyphs; + const uint16_t num_glyphs = maxp->num_glyphs; // We only support a subset of the possible character map tables. Microsoft // 'strongly recommends' that everyone supports the Unicode BMP table with @@ -760,29 +760,30 @@ bool ots_cmap_parse(Font *font, const uint8_t *data, size_t length) { // table actually points to MS symbol data and thus should be parsed as // 3-0-4 table (e.g., marqueem.ttf and quixotic.ttf). This error will be // recovered in ots_cmap_serialise(). - if (!ParseFormat4(font, 3, 1, data + subtable_headers[i].offset, + if (!ParseFormat4(3, 1, data + subtable_headers[i].offset, subtable_headers[i].length, num_glyphs)) { - return OTS_FAILURE_MSG("Failed to parse format 4 cmap subtable %d", i); + return Error("Failed to parse format 4 cmap subtable %d", i); } } else if ((subtable_headers[i].encoding == 3) && (subtable_headers[i].format == 4)) { // parse and output the 0-3-4 table as 0-3-4 table. - if (!ParseFormat4(font, 0, 3, data + subtable_headers[i].offset, + if (!ParseFormat4(0, 3, data + subtable_headers[i].offset, subtable_headers[i].length, num_glyphs)) { - return OTS_FAILURE_MSG("Failed to parse format 4 cmap subtable %d", i); + return Error("Failed to parse format 4 cmap subtable %d", i); } - } else if ((subtable_headers[i].encoding == 3) && + } else if ((subtable_headers[i].encoding == 3 || + subtable_headers[i].encoding == 4) && (subtable_headers[i].format == 12)) { - // parse and output the 0-3-12 table as 3-10-12 table. - if (!Parse31012(font, data + subtable_headers[i].offset, + // parse and output the 0-3-12 or 0-4-12 tables as 3-10-12 table. + if (!Parse31012(data + subtable_headers[i].offset, subtable_headers[i].length, num_glyphs)) { - return OTS_FAILURE_MSG("Failed to parse format 12 cmap subtable %d", i); + return Error("Failed to parse format 12 cmap subtable %d", i); } } else if ((subtable_headers[i].encoding == 5) && (subtable_headers[i].format == 14)) { - if (!Parse0514(font, data + subtable_headers[i].offset, + if (!Parse0514(data + subtable_headers[i].offset, subtable_headers[i].length, num_glyphs)) { - return OTS_FAILURE_MSG("Failed to parse format 14 cmap subtable %d", i); + return Error("Failed to parse format 14 cmap subtable %d", i); } } } else if (subtable_headers[i].platform == 1) { @@ -791,7 +792,7 @@ bool ots_cmap_parse(Font *font, const uint8_t *data, size_t length) { if ((subtable_headers[i].encoding == 0) && (subtable_headers[i].format == 0)) { // parse and output the 1-0-0 table. - if (!Parse100(font, data + subtable_headers[i].offset, + if (!Parse100(data + subtable_headers[i].offset, subtable_headers[i].length)) { return OTS_FAILURE(); } @@ -804,7 +805,7 @@ bool ots_cmap_parse(Font *font, const uint8_t *data, size_t length) { case 1: if (subtable_headers[i].format == 4) { // parse 3-0-4 or 3-1-4 table. - if (!ParseFormat4(font, subtable_headers[i].platform, + if (!ParseFormat4(subtable_headers[i].platform, subtable_headers[i].encoding, data + subtable_headers[i].offset, subtable_headers[i].length, num_glyphs)) { @@ -814,14 +815,14 @@ bool ots_cmap_parse(Font *font, const uint8_t *data, size_t length) { break; case 10: if (subtable_headers[i].format == 12) { - font->cmap->subtable_3_10_12.clear(); - if (!Parse31012(font, data + subtable_headers[i].offset, + this->subtable_3_10_12.clear(); + if (!Parse31012(data + subtable_headers[i].offset, subtable_headers[i].length, num_glyphs)) { return OTS_FAILURE(); } } else if (subtable_headers[i].format == 13) { - font->cmap->subtable_3_10_13.clear(); - if (!Parse31013(font, data + subtable_headers[i].offset, + this->subtable_3_10_13.clear(); + if (!Parse31013(data + subtable_headers[i].offset, subtable_headers[i].length, num_glyphs)) { return OTS_FAILURE(); } @@ -834,20 +835,16 @@ bool ots_cmap_parse(Font *font, const uint8_t *data, size_t length) { return true; } -bool ots_cmap_should_serialise(Font *font) { - return font->cmap != NULL; -} - -bool ots_cmap_serialise(OTSStream *out, Font *font) { - const bool have_034 = font->cmap->subtable_0_3_4_data != NULL; - const bool have_0514 = font->cmap->subtable_0_5_14.size() != 0; - const bool have_100 = font->cmap->subtable_1_0_0.size() != 0; - const bool have_304 = font->cmap->subtable_3_0_4_data != NULL; +bool OpenTypeCMAP::Serialize(OTSStream *out) { + const bool have_034 = this->subtable_0_3_4_data != NULL; + const bool have_0514 = this->subtable_0_5_14.size() != 0; + const bool have_100 = this->subtable_1_0_0.size() != 0; + const bool have_304 = this->subtable_3_0_4_data != NULL; // MS Symbol and MS Unicode tables should not co-exist. // See the comment above in 0-0-4 parser. - const bool have_314 = (!have_304) && font->cmap->subtable_3_1_4_data; - const bool have_31012 = font->cmap->subtable_3_10_12.size() != 0; - const bool have_31013 = font->cmap->subtable_3_10_13.size() != 0; + const bool have_314 = (!have_304) && this->subtable_3_1_4_data; + const bool have_31012 = this->subtable_3_10_12.size() != 0; + const bool have_31013 = this->subtable_3_10_13.size() != 0; const uint16_t num_subtables = static_cast<uint16_t>(have_034) + static_cast<uint16_t>(have_0514) + static_cast<uint16_t>(have_100) + @@ -860,7 +857,7 @@ bool ots_cmap_serialise(OTSStream *out, Font *font) { // Some fonts don't have 3-0-4 MS Symbol nor 3-1-4 Unicode BMP tables // (e.g., old fonts for Mac). We don't support them. if (!have_304 && !have_314 && !have_034 && !have_31012 && !have_31013) { - return OTS_FAILURE_MSG("no supported subtables were found"); + return Error("no supported subtables were found"); } if (!out->WriteU16(0) || @@ -875,8 +872,8 @@ bool ots_cmap_serialise(OTSStream *out, Font *font) { const off_t offset_034 = out->Tell(); if (have_034) { - if (!out->Write(font->cmap->subtable_0_3_4_data, - font->cmap->subtable_0_3_4_length)) { + if (!out->Write(this->subtable_0_3_4_data, + this->subtable_0_3_4_length)) { return OTS_FAILURE(); } } @@ -884,10 +881,10 @@ bool ots_cmap_serialise(OTSStream *out, Font *font) { const off_t offset_0514 = out->Tell(); if (have_0514) { const std::vector<ots::OpenTypeCMAPSubtableVSRecord> &records - = font->cmap->subtable_0_5_14; + = this->subtable_0_5_14; const unsigned num_records = records.size(); if (!out->WriteU16(14) || - !out->WriteU32(font->cmap->subtable_0_5_14_length) || + !out->WriteU32(this->subtable_0_5_14_length) || !out->WriteU32(num_records)) { return OTS_FAILURE(); } @@ -939,23 +936,23 @@ bool ots_cmap_serialise(OTSStream *out, Font *font) { !out->WriteU16(0)) { // language return OTS_FAILURE(); } - if (!out->Write(&(font->cmap->subtable_1_0_0[0]), kFormat0ArraySize)) { + if (!out->Write(&(this->subtable_1_0_0[0]), kFormat0ArraySize)) { return OTS_FAILURE(); } } const off_t offset_304 = out->Tell(); if (have_304) { - if (!out->Write(font->cmap->subtable_3_0_4_data, - font->cmap->subtable_3_0_4_length)) { + if (!out->Write(this->subtable_3_0_4_data, + this->subtable_3_0_4_length)) { return OTS_FAILURE(); } } const off_t offset_314 = out->Tell(); if (have_314) { - if (!out->Write(font->cmap->subtable_3_1_4_data, - font->cmap->subtable_3_1_4_length)) { + if (!out->Write(this->subtable_3_1_4_data, + this->subtable_3_1_4_length)) { return OTS_FAILURE(); } } @@ -963,7 +960,7 @@ bool ots_cmap_serialise(OTSStream *out, Font *font) { const off_t offset_31012 = out->Tell(); if (have_31012) { std::vector<OpenTypeCMAPSubtableRange> &groups - = font->cmap->subtable_3_10_12; + = this->subtable_3_10_12; const unsigned num_groups = groups.size(); if (!out->WriteU16(12) || !out->WriteU16(0) || @@ -985,7 +982,7 @@ bool ots_cmap_serialise(OTSStream *out, Font *font) { const off_t offset_31013 = out->Tell(); if (have_31013) { std::vector<OpenTypeCMAPSubtableRange> &groups - = font->cmap->subtable_3_10_13; + = this->subtable_3_10_13; const unsigned num_groups = groups.size(); if (!out->WriteU16(13) || !out->WriteU16(0) || @@ -1074,15 +1071,4 @@ bool ots_cmap_serialise(OTSStream *out, Font *font) { return true; } -void ots_cmap_reuse(Font *font, Font *other) { - font->cmap = other->cmap; - font->cmap_reused = true; -} - -void ots_cmap_free(Font *font) { - delete font->cmap; -} - } // namespace ots - -#undef TABLE_NAME diff --git a/gfx/ots/src/cmap.h b/gfx/ots/src/cmap.h index 5b09556b7..feddbc696 100644 --- a/gfx/ots/src/cmap.h +++ b/gfx/ots/src/cmap.h @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -35,9 +35,11 @@ struct OpenTypeCMAPSubtableVSRecord { std::vector<OpenTypeCMAPSubtableVSMapping> mappings; }; -struct OpenTypeCMAP { - OpenTypeCMAP() - : subtable_0_3_4_data(NULL), +class OpenTypeCMAP : public Table { + public: + explicit OpenTypeCMAP(Font *font, uint32_t tag) + : Table(font, tag, tag), + subtable_0_3_4_data(NULL), subtable_0_3_4_length(0), subtable_0_5_14_length(0), subtable_3_0_4_data(NULL), @@ -46,6 +48,10 @@ struct OpenTypeCMAP { subtable_3_1_4_length(0) { } + bool Parse(const uint8_t *data, size_t length); + bool Serialize(OTSStream *out); + + private: // Platform 0, Encoding 3, Format 4, Unicode BMP table. const uint8_t *subtable_0_3_4_data; size_t subtable_0_3_4_length; @@ -67,6 +73,13 @@ struct OpenTypeCMAP { std::vector<OpenTypeCMAPSubtableRange> subtable_3_10_13; // Platform 1, Encoding 0, Format 0, Mac Roman table. std::vector<uint8_t> subtable_1_0_0; + + bool ParseFormat4(int platform, int encoding, const uint8_t *data, + size_t length, uint16_t num_glyphs); + bool Parse31012(const uint8_t *data, size_t length, uint16_t num_glyphs); + bool Parse31013(const uint8_t *data, size_t length, uint16_t num_glyphs); + bool Parse0514(const uint8_t *data, size_t length, uint16_t num_glyphs); + bool Parse100(const uint8_t *data, size_t length); }; } // namespace ots diff --git a/gfx/ots/src/cvar.cc b/gfx/ots/src/cvar.cc new file mode 100644 index 000000000..a2bad7a15 --- /dev/null +++ b/gfx/ots/src/cvar.cc @@ -0,0 +1,56 @@ +// Copyright (c) 2018 The OTS 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 "cvar.h" + +#include "fvar.h" +#include "variations.h" + +namespace ots { + +// ----------------------------------------------------------------------------- +// OpenTypeCVAR +// ----------------------------------------------------------------------------- + +bool OpenTypeCVAR::Parse(const uint8_t* data, size_t length) { + Buffer table(data, length); + + uint16_t majorVersion; + uint16_t minorVersion; + + if (!table.ReadU16(&majorVersion) || + !table.ReadU16(&minorVersion)) { + return Drop("Failed to read table header"); + } + + if (majorVersion != 1) { + return Drop("Unknown table version"); + } + + OpenTypeFVAR* fvar = static_cast<OpenTypeFVAR*>( + GetFont()->GetTypedTable(OTS_TAG_FVAR)); + if (!fvar) { + return DropVariations("Required fvar table is missing"); + } + + if (!ParseVariationData(GetFont(), data + table.offset(), length - table.offset(), + fvar->AxisCount(), 0)) { + return Drop("Failed to parse variation data"); + } + + this->m_data = data; + this->m_length = length; + + return true; +} + +bool OpenTypeCVAR::Serialize(OTSStream* out) { + if (!out->Write(this->m_data, this->m_length)) { + return Error("Failed to write cvar table"); + } + + return true; +} + +} // namespace ots diff --git a/gfx/ots/src/cvar.h b/gfx/ots/src/cvar.h new file mode 100644 index 000000000..8f31e98cd --- /dev/null +++ b/gfx/ots/src/cvar.h @@ -0,0 +1,31 @@ +// Copyright (c) 2018 The OTS Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef OTS_CVAR_H_ +#define OTS_CVAR_H_ + +#include "ots.h" + +namespace ots { + +// ----------------------------------------------------------------------------- +// OpenTypeCVAR Interface +// ----------------------------------------------------------------------------- + +class OpenTypeCVAR : public Table { + public: + explicit OpenTypeCVAR(Font* font, uint32_t tag) + : Table(font, tag, tag) { } + + bool Parse(const uint8_t* data, size_t length); + bool Serialize(OTSStream* out); + + private: + const uint8_t *m_data; + size_t m_length; +}; + +} // namespace ots + +#endif // OTS_CVAR_H_ diff --git a/gfx/ots/src/cvt.cc b/gfx/ots/src/cvt.cc index 1402e7c06..2e0257889 100644 --- a/gfx/ots/src/cvt.cc +++ b/gfx/ots/src/cvt.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -7,59 +7,40 @@ // cvt - Control Value Table // http://www.microsoft.com/typography/otspec/cvt.htm -#define TABLE_NAME "cvt" - namespace ots { -bool ots_cvt_parse(Font *font, const uint8_t *data, size_t length) { +bool OpenTypeCVT::Parse(const uint8_t *data, size_t length) { Buffer table(data, length); - OpenTypeCVT *cvt = new OpenTypeCVT; - font->cvt = cvt; - if (length >= 128 * 1024u) { - return OTS_FAILURE_MSG("Length (%d) > 120K"); // almost all cvt tables are less than 4k bytes. + return Error("Length (%d) > 120K"); // almost all cvt tables are less than 4k bytes. } if (length % 2 != 0) { - return OTS_FAILURE_MSG("Uneven cvt length (%d)", length); + return Error("Uneven table length (%d)", length); } if (!table.Skip(length)) { - return OTS_FAILURE_MSG("Length too high"); + return Error("Table length too high"); } - cvt->data = data; - cvt->length = length; + this->data = data; + this->length = length; return true; } -bool ots_cvt_should_serialise(Font *font) { - if (!font->glyf) { - return false; // this table is not for CFF fonts. - } - return font->cvt != NULL; -} - -bool ots_cvt_serialise(OTSStream *out, Font *font) { - const OpenTypeCVT *cvt = font->cvt; - - if (!out->Write(cvt->data, cvt->length)) { - return OTS_FAILURE_MSG("Failed to write CVT table"); +bool OpenTypeCVT::Serialize(OTSStream *out) { + if (!out->Write(this->data, this->length)) { + return Error("Failed to write cvt table"); } return true; } -void ots_cvt_reuse(Font *font, Font *other) { - font->cvt = other->cvt; - font->cvt_reused = true; -} - -void ots_cvt_free(Font *font) { - delete font->cvt; +bool OpenTypeCVT::ShouldSerialize() { + return Table::ShouldSerialize() && + // this table is not for CFF fonts. + GetFont()->GetTable(OTS_TAG_GLYF) != NULL; } } // namespace ots - -#undef TABLE_NAME diff --git a/gfx/ots/src/cvt.h b/gfx/ots/src/cvt.h index 3c25f06f6..88a96ca20 100644 --- a/gfx/ots/src/cvt.h +++ b/gfx/ots/src/cvt.h @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -9,7 +9,16 @@ namespace ots { -struct OpenTypeCVT { +class OpenTypeCVT : public Table { + public: + explicit OpenTypeCVT(Font *font, uint32_t tag) + : Table(font, tag, tag) { } + + bool Parse(const uint8_t *data, size_t length); + bool Serialize(OTSStream *out); + bool ShouldSerialize(); + + private: const uint8_t *data; uint32_t length; }; diff --git a/gfx/ots/src/feat.cc b/gfx/ots/src/feat.cc new file mode 100644 index 000000000..374a7ae9f --- /dev/null +++ b/gfx/ots/src/feat.cc @@ -0,0 +1,193 @@ +// Copyright (c) 2009-2017 The OTS 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 "feat.h" + +#include "name.h" + +namespace ots { + +bool OpenTypeFEAT::Parse(const uint8_t* data, size_t length) { + if (GetFont()->dropped_graphite) { + return Drop("Skipping Graphite table"); + } + Buffer table(data, length); + + if (!table.ReadU32(&this->version)) { + return DropGraphite("Failed to read version"); + } + if (this->version >> 16 != 1 && this->version >> 16 != 2) { + return DropGraphite("Unsupported table version: %u", this->version >> 16); + } + if (!table.ReadU16(&this->numFeat)) { + return DropGraphite("Failed to read numFeat"); + } + if (!table.ReadU16(&this->reserved)) { + return DropGraphite("Failed to read reserved"); + } + if (this->reserved != 0) { + Warning("Nonzero reserved"); + } + if (!table.ReadU32(&this->reserved2)) { + return DropGraphite("Failed to read valid reserved2"); + } + if (this->reserved2 != 0) { + Warning("Nonzero reserved2"); + } + + std::unordered_set<size_t> unverified; + //this->features.resize(this->numFeat, this); + for (unsigned i = 0; i < this->numFeat; ++i) { + this->features.emplace_back(this); + FeatureDefn& feature = this->features[i]; + if (!feature.ParsePart(table)) { + return DropGraphite("Failed to read features[%u]", i); + } + this->feature_ids.insert(feature.id); + for (unsigned j = 0; j < feature.numSettings; ++j) { + size_t offset = feature.offset + j * 4; + if (offset < feature.offset || offset > length) { + return DropGraphite("Invalid FeatSettingDefn offset %zu/%zu", + offset, length); + } + unverified.insert(offset); + // need to verify that this FeatureDefn points to valid + // FeatureSettingDefn + } + } + + while (table.remaining()) { + bool used = unverified.erase(table.offset()); + FeatureSettingDefn featSetting(this); + if (!featSetting.ParsePart(table, used)) { + return DropGraphite("Failed to read a FeatureSettingDefn"); + } + featSettings.push_back(featSetting); + } + + if (!unverified.empty()) { + return DropGraphite("%zu incorrect offsets into featSettings", + unverified.size()); + } + if (table.remaining()) { + return Warning("%zu bytes unparsed", table.remaining()); + } + return true; +} + +bool OpenTypeFEAT::Serialize(OTSStream* out) { + if (!out->WriteU32(this->version) || + !out->WriteU16(this->numFeat) || + !out->WriteU16(this->reserved) || + !out->WriteU32(this->reserved2) || + !SerializeParts(this->features, out) || + !SerializeParts(this->featSettings, out)) { + return Error("Failed to write table"); + } + return true; +} + +bool OpenTypeFEAT::IsValidFeatureId(uint32_t id) const { + return feature_ids.count(id); +} + +bool OpenTypeFEAT::FeatureDefn::ParsePart(Buffer& table) { + OpenTypeNAME* name = static_cast<OpenTypeNAME*>( + parent->GetFont()->GetTypedTable(OTS_TAG_NAME)); + if (!name) { + return parent->Error("FeatureDefn: Required name table is missing"); + } + + if (parent->version >> 16 >= 2 && !table.ReadU32(&this->id)) { + return parent->Error("FeatureDefn: Failed to read id"); + } + if (parent->version >> 16 == 1) { + uint16_t id; + if (!table.ReadU16(&id)) { + return parent->Error("FeatureDefn: Failed to read id"); + } + this->id = id; + } + if (!table.ReadU16(&this->numSettings)) { + return parent->Error("FeatureDefn: Failed to read numSettings"); + } + if (parent->version >> 16 >= 2) { + if (!table.ReadU16(&this->reserved)) { + return parent->Error("FeatureDefn: Failed to read reserved"); + } + if (this->reserved != 0) { + parent->Warning("FeatureDefn: Nonzero reserved"); + } + } + if (!table.ReadU32(&this->offset)) { + return parent->Error("FeatureDefn: Failed to read offset"); + } // validity of offset verified in OpenTypeFEAT::Parse + if (!table.ReadU16(&this->flags)) { + return parent->Error("FeatureDefn: Failed to read flags"); + } + if ((this->flags & RESERVED) != 0) { + this->flags &= ~RESERVED; + parent->Warning("FeatureDefn: Nonzero (flags & 0x%x) repaired", RESERVED); + } + if (this->flags & HAS_DEFAULT_SETTING && + (this->flags & DEFAULT_SETTING) >= this->numSettings) { + return parent->Error("FeatureDefn: (flags & 0x%x) is set but (flags & 0x%x " + "is not a valid setting index", HAS_DEFAULT_SETTING, + DEFAULT_SETTING); + } + if (!table.ReadU16(&this->label)) { + return parent->Error("FeatureDefn: Failed to read label"); + } + if (!name->IsValidNameId(this->label)) { + if (this->id == 1 && name->IsValidNameId(this->label, true)) { + parent->Warning("FeatureDefn: Missing NameRecord repaired for feature" + " with id=%u, label=%u", this->id, this->label); + } + else { + return parent->Error("FeatureDefn: Invalid label"); + } + } + return true; +} + +bool OpenTypeFEAT::FeatureDefn::SerializePart(OTSStream* out) const { + if ((parent->version >> 16 >= 2 && !out->WriteU32(this->id)) || + (parent->version >> 16 == 1 && + !out->WriteU16(static_cast<uint16_t>(this->id))) || + !out->WriteU16(this->numSettings) || + (parent->version >> 16 >= 2 && !out->WriteU16(this->reserved)) || + !out->WriteU32(this->offset) || + !out->WriteU16(this->flags) || + !out->WriteU16(this->label)) { + return parent->Error("FeatureDefn: Failed to write"); + } + return true; +} + +bool OpenTypeFEAT::FeatureSettingDefn::ParsePart(Buffer& table, bool used) { + OpenTypeNAME* name = static_cast<OpenTypeNAME*>( + parent->GetFont()->GetTypedTable(OTS_TAG_NAME)); + if (!name) { + return parent->Error("FeatureSettingDefn: Required name table is missing"); + } + + if (!table.ReadS16(&this->value)) { + return parent->Error("FeatureSettingDefn: Failed to read value"); + } + if (!table.ReadU16(&this->label) || + (used && !name->IsValidNameId(this->label))) { + return parent->Error("FeatureSettingDefn: Failed to read valid label"); + } + return true; +} + +bool OpenTypeFEAT::FeatureSettingDefn::SerializePart(OTSStream* out) const { + if (!out->WriteS16(this->value) || + !out->WriteU16(this->label)) { + return parent->Error("FeatureSettingDefn: Failed to write"); + } + return true; +} + +} // namespace ots diff --git a/gfx/ots/src/feat.h b/gfx/ots/src/feat.h new file mode 100644 index 000000000..29c2656ff --- /dev/null +++ b/gfx/ots/src/feat.h @@ -0,0 +1,61 @@ +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef OTS_FEAT_H_ +#define OTS_FEAT_H_ + +#include <vector> +#include <unordered_set> + +#include "ots.h" +#include "graphite.h" + +namespace ots { + +class OpenTypeFEAT : public Table { + public: + explicit OpenTypeFEAT(Font* font, uint32_t tag) + : Table(font, tag, tag) { } + + bool Parse(const uint8_t* data, size_t length); + bool Serialize(OTSStream* out); + bool IsValidFeatureId(uint32_t id) const; + + private: + struct FeatureDefn : public TablePart<OpenTypeFEAT> { + explicit FeatureDefn(OpenTypeFEAT* parent) + : TablePart<OpenTypeFEAT>(parent) { } + bool ParsePart(Buffer& table); + bool SerializePart(OTSStream* out) const; + uint32_t id; + uint16_t numSettings; + uint16_t reserved; + uint32_t offset; + uint16_t flags; + static const uint16_t HAS_DEFAULT_SETTING = 0x4000; + static const uint16_t RESERVED = 0x3F00; + static const uint16_t DEFAULT_SETTING = 0x00FF; + uint16_t label; + }; + struct FeatureSettingDefn : public TablePart<OpenTypeFEAT> { + explicit FeatureSettingDefn(OpenTypeFEAT* parent) + : TablePart<OpenTypeFEAT>(parent) { } + bool ParsePart(Buffer& table) { return ParsePart(table, true); } + bool ParsePart(Buffer& table, bool used); + bool SerializePart(OTSStream* out) const; + int16_t value; + uint16_t label; + }; + uint32_t version; + uint16_t numFeat; + uint16_t reserved; + uint32_t reserved2; + std::vector<FeatureDefn> features; + std::vector<FeatureSettingDefn> featSettings; + std::unordered_set<uint32_t> feature_ids; +}; + +} // namespace ots + +#endif // OTS_FEAT_H_ diff --git a/gfx/ots/src/fpgm.cc b/gfx/ots/src/fpgm.cc index faa9a2392..bb52b367f 100644 --- a/gfx/ots/src/fpgm.cc +++ b/gfx/ots/src/fpgm.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -7,53 +7,36 @@ // fpgm - Font Program // http://www.microsoft.com/typography/otspec/fpgm.htm -#define TABLE_NAME "fpgm" - namespace ots { -bool ots_fpgm_parse(Font *font, const uint8_t *data, size_t length) { +bool OpenTypeFPGM::Parse(const uint8_t *data, size_t length) { Buffer table(data, length); - OpenTypeFPGM *fpgm = new OpenTypeFPGM; - font->fpgm = fpgm; - if (length >= 128 * 1024u) { - return OTS_FAILURE_MSG("length (%ld) > 120", length); // almost all fpgm tables are less than 5k bytes. + return Error("length (%ld) > 120", length); // almost all fpgm tables are less than 5k bytes. } if (!table.Skip(length)) { - return OTS_FAILURE_MSG("Bad fpgm length"); + return Error("Bad table length"); } - fpgm->data = data; - fpgm->length = length; + this->data = data; + this->length = length; return true; } -bool ots_fpgm_should_serialise(Font *font) { - if (!font->glyf) return false; // this table is not for CFF fonts. - return font->fpgm != NULL; -} - -bool ots_fpgm_serialise(OTSStream *out, Font *font) { - const OpenTypeFPGM *fpgm = font->fpgm; - - if (!out->Write(fpgm->data, fpgm->length)) { - return OTS_FAILURE_MSG("Failed to write fpgm"); +bool OpenTypeFPGM::Serialize(OTSStream *out) { + if (!out->Write(this->data, this->length)) { + return Error("Failed to write fpgm table"); } return true; } -void ots_fpgm_reuse(Font *font, Font *other) { - font->fpgm = other->fpgm; - font->fpgm_reused = true; -} - -void ots_fpgm_free(Font *font) { - delete font->fpgm; +bool OpenTypeFPGM::ShouldSerialize() { + return Table::ShouldSerialize() && + // this table is not for CFF fonts. + GetFont()->GetTable(OTS_TAG_GLYF) != NULL; } } // namespace ots - -#undef TABLE_NAME diff --git a/gfx/ots/src/fpgm.h b/gfx/ots/src/fpgm.h index 8fabac36d..9ed6b34bf 100644 --- a/gfx/ots/src/fpgm.h +++ b/gfx/ots/src/fpgm.h @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -9,7 +9,16 @@ namespace ots { -struct OpenTypeFPGM { +class OpenTypeFPGM : public Table { + public: + explicit OpenTypeFPGM(Font *font, uint32_t tag) + : Table(font, tag, tag) { } + + bool Parse(const uint8_t *data, size_t length); + bool Serialize(OTSStream *out); + bool ShouldSerialize(); + + private: const uint8_t *data; uint32_t length; }; diff --git a/gfx/ots/src/fvar.cc b/gfx/ots/src/fvar.cc new file mode 100644 index 000000000..6f9b4d6eb --- /dev/null +++ b/gfx/ots/src/fvar.cc @@ -0,0 +1,164 @@ +// Copyright (c) 2018 The OTS 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 "fvar.h" + +namespace ots { + +// ----------------------------------------------------------------------------- +// OpenTypeFVAR +// ----------------------------------------------------------------------------- + +bool OpenTypeFVAR::Parse(const uint8_t* data, size_t length) { + Buffer table(data, length); + if (!table.ReadU16(&this->majorVersion) || + !table.ReadU16(&this->minorVersion) || + !table.ReadU16(&this->axesArrayOffset) || + !table.ReadU16(&this->reserved) || + !table.ReadU16(&this->axisCount) || + !table.ReadU16(&this->axisSize) || + !table.ReadU16(&this->instanceCount) || + !table.ReadU16(&this->instanceSize)) { + return DropVariations("Failed to read table header"); + } + if (this->majorVersion != 1) { + return DropVariations("Unknown table version"); + } + if (this->minorVersion > 0) { + Warning("Downgrading minor version to 0"); + this->minorVersion = 0; + } + if (this->axesArrayOffset > length || this->axesArrayOffset < table.offset()) { + return DropVariations("Bad axesArrayOffset"); + } + if (this->reserved != 2) { + Warning("Expected reserved=2"); + this->reserved = 2; + } + if (this->axisCount == 0) { + return DropVariations("No variation axes"); + } + if (this->axisSize != 20) { + return DropVariations("Invalid axisSize"); + } + // instanceCount is not validated + if (this->instanceSize == this->axisCount * sizeof(Fixed) + 6) { + this->instancesHavePostScriptNameID = true; + } else if (this->instanceSize == this->axisCount * sizeof(Fixed) + 4) { + this->instancesHavePostScriptNameID = false; + } else { + return DropVariations("Invalid instanceSize"); + } + + // When we serialize, the axes array will go here, even if it was + // originally at a different offset. So we update the axesArrayOffset + // field for the header. + uint32_t origAxesArrayOffset = this->axesArrayOffset; + this->axesArrayOffset = table.offset(); + + table.set_offset(origAxesArrayOffset); + for (unsigned i = 0; i < this->axisCount; i++) { + this->axes.emplace_back(); + auto& axis = this->axes[i]; + if (!table.ReadU32(&axis.axisTag) || + !table.ReadS32(&axis.minValue) || + !table.ReadS32(&axis.defaultValue) || + !table.ReadS32(&axis.maxValue) || + !table.ReadU16(&axis.flags) || + !table.ReadU16(&axis.axisNameID)) { + return DropVariations("Failed to read axis record"); + } + if (!CheckTag(axis.axisTag)) { + return DropVariations("Bad axis tag"); + } + if (!(axis.minValue <= axis.defaultValue && axis.defaultValue <= axis.maxValue)) { + return DropVariations("Bad axis value range"); + } + if ((axis.flags & 0xFFFEu) != 0) { + Warning("Discarding unknown axis flags"); + axis.flags &= ~0xFFFEu; + } + if (axis.axisNameID <= 255 || axis.axisNameID >= 32768) { + Warning("Axis nameID out of range"); + // We don't check that the name actually exists -- assume the client can handle + // a missing name when it tries to read the table. + } + } + + for (unsigned i = 0; i < this->instanceCount; i++) { + this->instances.emplace_back(); + auto& inst = this->instances[i]; + if (!table.ReadU16(&inst.subfamilyNameID) || + !table.ReadU16(&inst.flags)) { + return DropVariations("Failed to read instance record"); + } + inst.coordinates.reserve(this->axisCount); + for (unsigned j = 0; j < this->axisCount; j++) { + inst.coordinates.emplace_back(); + auto& coord = inst.coordinates[j]; + if (!table.ReadS32(&coord)) { + return DropVariations("Failed to read instance coordinates"); + } + } + if (this->instancesHavePostScriptNameID) { + if (!table.ReadU16(&inst.postScriptNameID)) { + return DropVariations("Failed to read instance psname ID"); + } + } + } + + if (table.remaining()) { + return Warning("%zu bytes unparsed", table.remaining()); + } + + return true; +} + +bool OpenTypeFVAR::Serialize(OTSStream* out) { + if (!out->WriteU16(this->majorVersion) || + !out->WriteU16(this->minorVersion) || + !out->WriteU16(this->axesArrayOffset) || + !out->WriteU16(this->reserved) || + !out->WriteU16(this->axisCount) || + !out->WriteU16(this->axisSize) || + !out->WriteU16(this->instanceCount) || + !out->WriteU16(this->instanceSize)) { + return Error("Failed to write table"); + } + + for (unsigned i = 0; i < this->axisCount; i++) { + const auto& axis = this->axes[i]; + if (!out->WriteU32(axis.axisTag) || + !out->WriteS32(axis.minValue) || + !out->WriteS32(axis.defaultValue) || + !out->WriteS32(axis.maxValue) || + !out->WriteU16(axis.flags) || + !out->WriteU16(axis.axisNameID)) { + return Error("Failed to write table"); + } + } + + for (unsigned i = 0; i < this->instanceCount; i++) { + const auto& inst = this->instances[i]; + if (!out->WriteU16(inst.subfamilyNameID) || + !out->WriteU16(inst.flags)) { + return Error("Failed to write table"); + } + for (unsigned j = 0; j < this->axisCount; j++) { + const auto& coord = inst.coordinates[j]; + if (!out->WriteS32(coord)) { + return Error("Failed to write table"); + } + } + if (this->instancesHavePostScriptNameID) { + if (!out->WriteU16(inst.postScriptNameID)) { + return Error("Failed to write table"); + } + } + } + + return true; +} + +} // namespace ots diff --git a/gfx/ots/src/fvar.h b/gfx/ots/src/fvar.h new file mode 100644 index 000000000..a469c8cdd --- /dev/null +++ b/gfx/ots/src/fvar.h @@ -0,0 +1,63 @@ +// Copyright (c) 2018 The OTS Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef OTS_FVAR_H_ +#define OTS_FVAR_H_ + +#include <vector> + +#include "ots.h" + +namespace ots { + +// ----------------------------------------------------------------------------- +// OpenTypeFVAR Interface +// ----------------------------------------------------------------------------- + +class OpenTypeFVAR : public Table { + public: + explicit OpenTypeFVAR(Font* font, uint32_t tag) + : Table(font, tag, tag) { } + + bool Parse(const uint8_t* data, size_t length); + bool Serialize(OTSStream* out); + + uint16_t AxisCount() const { return axisCount; } + + private: + uint16_t majorVersion; + uint16_t minorVersion; + uint16_t axesArrayOffset; + uint16_t reserved; + uint16_t axisCount; + uint16_t axisSize; + uint16_t instanceCount; + uint16_t instanceSize; + + typedef int32_t Fixed; /* 16.16 fixed-point value */ + + struct VariationAxisRecord { + uint32_t axisTag; + Fixed minValue; + Fixed defaultValue; + Fixed maxValue; + uint16_t flags; + uint16_t axisNameID; + }; + std::vector<VariationAxisRecord> axes; + + struct InstanceRecord { + uint16_t subfamilyNameID; + uint16_t flags; + std::vector<Fixed> coordinates; + uint16_t postScriptNameID; // optional + }; + std::vector<InstanceRecord> instances; + + bool instancesHavePostScriptNameID; +}; + +} // namespace ots + +#endif // OTS_FVAR_H_ diff --git a/gfx/ots/src/gasp.cc b/gfx/ots/src/gasp.cc index 5ebf5d84b..2a03c831f 100644 --- a/gfx/ots/src/gasp.cc +++ b/gfx/ots/src/gasp.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -7,113 +7,78 @@ // gasp - Grid-fitting And Scan-conversion Procedure // http://www.microsoft.com/typography/otspec/gasp.htm -#define TABLE_NAME "gasp" - -#define DROP_THIS_TABLE(...) \ - do { \ - OTS_FAILURE_MSG_(font->file, TABLE_NAME ": " __VA_ARGS__); \ - OTS_FAILURE_MSG("Table discarded"); \ - delete font->gasp; \ - font->gasp = 0; \ - } while (0) - namespace ots { -bool ots_gasp_parse(Font *font, const uint8_t *data, size_t length) { +bool OpenTypeGASP::Parse(const uint8_t *data, size_t length) { Buffer table(data, length); - OpenTypeGASP *gasp = new OpenTypeGASP; - font->gasp = gasp; - uint16_t num_ranges = 0; - if (!table.ReadU16(&gasp->version) || + if (!table.ReadU16(&this->version) || !table.ReadU16(&num_ranges)) { - return OTS_FAILURE_MSG("Failed to read table header"); + return Error("Failed to read table header"); } - if (gasp->version > 1) { + if (this->version > 1) { // Lots of Linux fonts have bad version numbers... - DROP_THIS_TABLE("bad version: %u", gasp->version); - return true; + return Drop("Unsupported version: %u", this->version); } if (num_ranges == 0) { - DROP_THIS_TABLE("num_ranges is zero"); - return true; + return Drop("numRanges is zero"); } - gasp->gasp_ranges.reserve(num_ranges); + this->gasp_ranges.reserve(num_ranges); for (unsigned i = 0; i < num_ranges; ++i) { uint16_t max_ppem = 0; uint16_t behavior = 0; if (!table.ReadU16(&max_ppem) || !table.ReadU16(&behavior)) { - return OTS_FAILURE_MSG("Failed to read subrange %d", i); + return Error("Failed to read GASPRANGE %d", i); } - if ((i > 0) && (gasp->gasp_ranges[i - 1].first >= max_ppem)) { + if ((i > 0) && (this->gasp_ranges[i - 1].first >= max_ppem)) { // The records in the gaspRange[] array must be sorted in order of // increasing rangeMaxPPEM value. - DROP_THIS_TABLE("ranges are not sorted"); - return true; + return Drop("Ranges are not sorted"); } if ((i == num_ranges - 1u) && // never underflow. (max_ppem != 0xffffu)) { - DROP_THIS_TABLE("The last record should be 0xFFFF as a sentinel value " + return Drop("The last record should be 0xFFFF as a sentinel value " "for rangeMaxPPEM"); - return true; } if (behavior >> 8) { - OTS_WARNING("undefined bits are used: %x", behavior); + Warning("Undefined bits are used: %x", behavior); // mask undefined bits. behavior &= 0x000fu; } - if (gasp->version == 0 && (behavior >> 2) != 0) { - OTS_WARNING("changed the version number to 1"); - gasp->version = 1; + if (this->version == 0 && (behavior >> 2) != 0) { + Warning("Changed the version number to 1"); + this->version = 1; } - gasp->gasp_ranges.push_back(std::make_pair(max_ppem, behavior)); + this->gasp_ranges.push_back(std::make_pair(max_ppem, behavior)); } return true; } -bool ots_gasp_should_serialise(Font *font) { - return font->gasp != NULL; -} - -bool ots_gasp_serialise(OTSStream *out, Font *font) { - const OpenTypeGASP *gasp = font->gasp; - - const uint16_t num_ranges = static_cast<uint16_t>(gasp->gasp_ranges.size()); - if (num_ranges != gasp->gasp_ranges.size() || - !out->WriteU16(gasp->version) || +bool OpenTypeGASP::Serialize(OTSStream *out) { + const uint16_t num_ranges = static_cast<uint16_t>(this->gasp_ranges.size()); + if (num_ranges != this->gasp_ranges.size() || + !out->WriteU16(this->version) || !out->WriteU16(num_ranges)) { - return OTS_FAILURE_MSG("failed to write gasp header"); + return Error("Failed to write table header"); } for (uint16_t i = 0; i < num_ranges; ++i) { - if (!out->WriteU16(gasp->gasp_ranges[i].first) || - !out->WriteU16(gasp->gasp_ranges[i].second)) { - return OTS_FAILURE_MSG("Failed to write gasp subtable %d", i); + if (!out->WriteU16(this->gasp_ranges[i].first) || + !out->WriteU16(this->gasp_ranges[i].second)) { + return Error("Failed to write GASPRANGE %d", i); } } return true; } -void ots_gasp_reuse(Font *font, Font *other) { - font->gasp = other->gasp; - font->gasp_reused = true; -} - -void ots_gasp_free(Font *font) { - delete font->gasp; -} - } // namespace ots - -#undef TABLE_NAME -#undef DROP_THIS_TABLE diff --git a/gfx/ots/src/gasp.h b/gfx/ots/src/gasp.h index 48d7e7c16..ce9e987aa 100644 --- a/gfx/ots/src/gasp.h +++ b/gfx/ots/src/gasp.h @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -13,7 +13,15 @@ namespace ots { -struct OpenTypeGASP { +class OpenTypeGASP : public Table { + public: + explicit OpenTypeGASP(Font *font, uint32_t tag) + : Table(font, tag, tag) { } + + bool Parse(const uint8_t *data, size_t length); + bool Serialize(OTSStream *out); + + private: uint16_t version; // A array of (max PPEM, GASP behavior) pairs. std::vector<std::pair<uint16_t, uint16_t> > gasp_ranges; diff --git a/gfx/ots/src/gdef.cc b/gfx/ots/src/gdef.cc index 71c6fc592..71e1075e3 100644 --- a/gfx/ots/src/gdef.cc +++ b/gfx/ots/src/gdef.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2011 The Chromium Authors. All rights reserved. +// Copyright (c) 2011-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -11,68 +11,60 @@ #include "gsub.h" #include "layout.h" #include "maxp.h" +#include "variations.h" // GDEF - The Glyph Definition Table // http://www.microsoft.com/typography/otspec/gdef.htm -#define TABLE_NAME "GDEF" - namespace { -// The maximum class value in class definition tables. -const uint16_t kMaxClassDefValue = 0xFFFF; // The maximum class value in the glyph class definision table. const uint16_t kMaxGlyphClassDefValue = 4; // The maximum format number of caret value tables. -// We don't support format 3 for now. See the comment in -// ParseLigCaretListTable() for the reason. -const uint16_t kMaxCaretValueFormat = 2; - -bool ParseGlyphClassDefTable(ots::Font *font, const uint8_t *data, - size_t length, const uint16_t num_glyphs) { - return ots::ParseClassDefTable(font, data, length, num_glyphs, - kMaxGlyphClassDefValue); -} +const uint16_t kMaxCaretValueFormat = 3; + +} // namespace -bool ParseAttachListTable(ots::Font *font, const uint8_t *data, - size_t length, const uint16_t num_glyphs) { +namespace ots { + +bool OpenTypeGDEF::ParseAttachListTable(const uint8_t *data, size_t length) { ots::Buffer subtable(data, length); uint16_t offset_coverage = 0; uint16_t glyph_count = 0; if (!subtable.ReadU16(&offset_coverage) || !subtable.ReadU16(&glyph_count)) { - return OTS_FAILURE_MSG("Failed to read gdef header"); + return Error("Failed to read gdef header"); } const unsigned attach_points_end = 2 * static_cast<unsigned>(glyph_count) + 4; if (attach_points_end > std::numeric_limits<uint16_t>::max()) { - return OTS_FAILURE_MSG("Bad glyph count in gdef"); + return Error("Bad glyph count in gdef"); } if (offset_coverage == 0 || offset_coverage >= length || offset_coverage < attach_points_end) { - return OTS_FAILURE_MSG("Bad coverage offset %d", offset_coverage); + return Error("Bad coverage offset %d", offset_coverage); } - if (glyph_count > num_glyphs) { - return OTS_FAILURE_MSG("Bad glyph count %u", glyph_count); + if (glyph_count > this->m_num_glyphs) { + return Error("Bad glyph count %u", glyph_count); } std::vector<uint16_t> attach_points; attach_points.resize(glyph_count); for (unsigned i = 0; i < glyph_count; ++i) { if (!subtable.ReadU16(&attach_points[i])) { - return OTS_FAILURE_MSG("Can't read attachment point %d", i); + return Error("Can't read attachment point %d", i); } if (attach_points[i] >= length || attach_points[i] < attach_points_end) { - return OTS_FAILURE_MSG("Bad attachment point %d of %d", i, attach_points[i]); + return Error("Bad attachment point %d of %d", i, attach_points[i]); } } // Parse coverage table - if (!ots::ParseCoverageTable(font, data + offset_coverage, - length - offset_coverage, num_glyphs)) { - return OTS_FAILURE_MSG("Bad coverage table"); + if (!ots::ParseCoverageTable(GetFont(), data + offset_coverage, + length - offset_coverage, this->m_num_glyphs)) { + return Error("Bad coverage table"); } // Parse attach point table @@ -80,20 +72,20 @@ bool ParseAttachListTable(ots::Font *font, const uint8_t *data, subtable.set_offset(attach_points[i]); uint16_t point_count = 0; if (!subtable.ReadU16(&point_count)) { - return OTS_FAILURE_MSG("Can't read point count %d", i); + return Error("Can't read point count %d", i); } if (point_count == 0) { - return OTS_FAILURE_MSG("zero point count %d", i); + return Error("zero point count %d", i); } uint16_t last_point_index = 0; uint16_t point_index = 0; for (unsigned j = 0; j < point_count; ++j) { if (!subtable.ReadU16(&point_index)) { - return OTS_FAILURE_MSG("Can't read point index %d in point %d", j, i); + return Error("Can't read point index %d in point %d", j, i); } // Contour point indeces are in increasing numerical order if (last_point_index != 0 && last_point_index >= point_index) { - return OTS_FAILURE_MSG("bad contour indeces: %u >= %u", + return Error("bad contour indeces: %u >= %u", last_point_index, point_index); } last_point_index = point_index; @@ -102,43 +94,42 @@ bool ParseAttachListTable(ots::Font *font, const uint8_t *data, return true; } -bool ParseLigCaretListTable(ots::Font *font, const uint8_t *data, - size_t length, const uint16_t num_glyphs) { +bool OpenTypeGDEF::ParseLigCaretListTable(const uint8_t *data, size_t length) { ots::Buffer subtable(data, length); uint16_t offset_coverage = 0; uint16_t lig_glyph_count = 0; if (!subtable.ReadU16(&offset_coverage) || !subtable.ReadU16(&lig_glyph_count)) { - return OTS_FAILURE_MSG("Can't read caret structure"); + return Error("Can't read caret structure"); } const unsigned lig_glyphs_end = 2 * static_cast<unsigned>(lig_glyph_count) + 4; if (lig_glyphs_end > std::numeric_limits<uint16_t>::max()) { - return OTS_FAILURE_MSG("Bad caret structure"); + return Error("Bad caret structure"); } if (offset_coverage == 0 || offset_coverage >= length || offset_coverage < lig_glyphs_end) { - return OTS_FAILURE_MSG("Bad caret coverate offset %d", offset_coverage); + return Error("Bad caret coverate offset %d", offset_coverage); } - if (lig_glyph_count > num_glyphs) { - return OTS_FAILURE_MSG("bad ligature glyph count: %u", lig_glyph_count); + if (lig_glyph_count > this->m_num_glyphs) { + return Error("bad ligature glyph count: %u", lig_glyph_count); } std::vector<uint16_t> lig_glyphs; lig_glyphs.resize(lig_glyph_count); for (unsigned i = 0; i < lig_glyph_count; ++i) { if (!subtable.ReadU16(&lig_glyphs[i])) { - return OTS_FAILURE_MSG("Can't read ligature glyph location %d", i); + return Error("Can't read ligature glyph location %d", i); } if (lig_glyphs[i] >= length || lig_glyphs[i] < lig_glyphs_end) { - return OTS_FAILURE_MSG("Bad ligature glyph location %d in glyph %d", lig_glyphs[i], i); + return Error("Bad ligature glyph location %d in glyph %d", lig_glyphs[i], i); } } // Parse coverage table - if (!ots::ParseCoverageTable(font, data + offset_coverage, - length - offset_coverage, num_glyphs)) { - return OTS_FAILURE_MSG("Can't parse caret coverage table"); + if (!ots::ParseCoverageTable(GetFont(), data + offset_coverage, + length - offset_coverage, this->m_num_glyphs)) { + return Error("Can't parse caret coverage table"); } // Parse ligature glyph table @@ -146,10 +137,10 @@ bool ParseLigCaretListTable(ots::Font *font, const uint8_t *data, subtable.set_offset(lig_glyphs[i]); uint16_t caret_count = 0; if (!subtable.ReadU16(&caret_count)) { - return OTS_FAILURE_MSG("Can't read caret count for glyph %d", i); + return Error("Can't read caret count for glyph %d", i); } if (caret_count == 0) { - return OTS_FAILURE_MSG("bad caret value count: %u", caret_count); + return Error("bad caret value count: %u", caret_count); } std::vector<uint16_t> caret_value_offsets; @@ -157,10 +148,10 @@ bool ParseLigCaretListTable(ots::Font *font, const uint8_t *data, unsigned caret_value_offsets_end = 2 * static_cast<unsigned>(caret_count) + 2; for (unsigned j = 0; j < caret_count; ++j) { if (!subtable.ReadU16(&caret_value_offsets[j])) { - return OTS_FAILURE_MSG("Can't read caret offset %d for glyph %d", j, i); + return Error("Can't read caret offset %d for glyph %d", j, i); } if (caret_value_offsets[j] >= length || caret_value_offsets[j] < caret_value_offsets_end) { - return OTS_FAILURE_MSG("Bad caret offset %d for caret %d glyph %d", caret_value_offsets[j], j, i); + return Error("Bad caret offset %d for caret %d glyph %d", caret_value_offsets[j], j, i); } } @@ -169,91 +160,93 @@ bool ParseLigCaretListTable(ots::Font *font, const uint8_t *data, subtable.set_offset(lig_glyphs[i] + caret_value_offsets[j]); uint16_t caret_format = 0; if (!subtable.ReadU16(&caret_format)) { - return OTS_FAILURE_MSG("Can't read caret values table %d in glyph %d", j, i); + return Error("Can't read caret values table %d in glyph %d", j, i); } - // TODO(bashi): We only support caret value format 1 and 2 for now - // because there are no fonts which contain caret value format 3 - // as far as we investigated. if (caret_format == 0 || caret_format > kMaxCaretValueFormat) { - return OTS_FAILURE_MSG("bad caret value format: %u", caret_format); + return Error("bad caret value format: %u", caret_format); } // CaretValueFormats contain a 2-byte field which could be // arbitrary value. if (!subtable.Skip(2)) { - return OTS_FAILURE_MSG("Bad caret value table structure %d in glyph %d", j, i); + return Error("Bad caret value table structure %d in glyph %d", j, i); + } + if (caret_format == 3) { + uint16_t offset_device = 0; + if (!subtable.ReadU16(&offset_device)) { + return Error("Can't read device offset for caret value %d " + "in glyph %d", j, i); + } + uint16_t absolute_offset = lig_glyphs[i] + caret_value_offsets[j] + + offset_device; + if (offset_device == 0 || absolute_offset >= length) { + return Error("Bad device offset for caret value %d in glyph %d: %d", + j, i, offset_device); + } + if (!ots::ParseDeviceTable(GetFont(), data + absolute_offset, + length - absolute_offset)) { + return Error("Bad device table for caret value %d in glyph %d", + j, i, offset_device); + } } } } return true; } -bool ParseMarkAttachClassDefTable(ots::Font *font, const uint8_t *data, - size_t length, const uint16_t num_glyphs) { - return ots::ParseClassDefTable(font, data, length, num_glyphs, kMaxClassDefValue); -} - -bool ParseMarkGlyphSetsDefTable(ots::Font *font, const uint8_t *data, - size_t length, const uint16_t num_glyphs) { +bool OpenTypeGDEF::ParseMarkGlyphSetsDefTable(const uint8_t *data, size_t length) { ots::Buffer subtable(data, length); uint16_t format = 0; uint16_t mark_set_count = 0; if (!subtable.ReadU16(&format) || !subtable.ReadU16(&mark_set_count)) { - return OTS_FAILURE_MSG("Can' read mark glyph table structure"); + return Error("Can' read mark glyph table structure"); } if (format != 1) { - return OTS_FAILURE_MSG("bad mark glyph set table format: %u", format); + return Error("bad mark glyph set table format: %u", format); } const unsigned mark_sets_end = 2 * static_cast<unsigned>(mark_set_count) + 4; if (mark_sets_end > std::numeric_limits<uint16_t>::max()) { - return OTS_FAILURE_MSG("Bad mark_set %d", mark_sets_end); + return Error("Bad mark_set %d", mark_sets_end); } for (unsigned i = 0; i < mark_set_count; ++i) { uint32_t offset_coverage = 0; if (!subtable.ReadU32(&offset_coverage)) { - return OTS_FAILURE_MSG("Can't read covrage location for mark set %d", i); + return Error("Can't read covrage location for mark set %d", i); } if (offset_coverage >= length || offset_coverage < mark_sets_end) { - return OTS_FAILURE_MSG("Bad coverage location %d for mark set %d", offset_coverage, i); + return Error("Bad coverage location %d for mark set %d", offset_coverage, i); } - if (!ots::ParseCoverageTable(font, data + offset_coverage, - length - offset_coverage, num_glyphs)) { - return OTS_FAILURE_MSG("Failed to parse coverage table for mark set %d", i); + if (!ots::ParseCoverageTable(GetFont(), data + offset_coverage, + length - offset_coverage, this->m_num_glyphs)) { + return Error("Failed to parse coverage table for mark set %d", i); } } - font->gdef->num_mark_glyph_sets = mark_set_count; + this->num_mark_glyph_sets = mark_set_count; return true; } -} // namespace +bool OpenTypeGDEF::Parse(const uint8_t *data, size_t length) { + OpenTypeMAXP *maxp = static_cast<OpenTypeMAXP*>( + GetFont()->GetTypedTable(OTS_TAG_MAXP)); -namespace ots { - -bool ots_gdef_parse(Font *font, const uint8_t *data, size_t length) { // Grab the number of glyphs in the font from the maxp table to check // GlyphIDs in GDEF table. - if (!font->maxp) { - return OTS_FAILURE_MSG("No maxp table in font, needed by GDEF"); + if (!maxp) { + return Error("No maxp table in font, needed by GDEF"); } - const uint16_t num_glyphs = font->maxp->num_glyphs; + this->m_num_glyphs = maxp->num_glyphs; Buffer table(data, length); - OpenTypeGDEF *gdef = new OpenTypeGDEF; - font->gdef = gdef; - - uint32_t version = 0; - if (!table.ReadU32(&version)) { - return OTS_FAILURE_MSG("Incomplete table"); + uint16_t version_major = 0, version_minor = 0; + if (!table.ReadU16(&version_major) || + !table.ReadU16(&version_minor)) { + return Error("Incomplete table"); } - if (version < 0x00010000 || version == 0x00010001) { - return OTS_FAILURE_MSG("Bad version"); - } - - if (version >= 0x00010002) { - gdef->version_2 = true; + if (version_major != 1 || version_minor == 1) { // there is no v1.1 + return Error("Bad version"); } uint16_t offset_glyph_class_def = 0; @@ -264,110 +257,108 @@ bool ots_gdef_parse(Font *font, const uint8_t *data, size_t length) { !table.ReadU16(&offset_attach_list) || !table.ReadU16(&offset_lig_caret_list) || !table.ReadU16(&offset_mark_attach_class_def)) { - return OTS_FAILURE_MSG("Incomplete table"); + return Error("Incomplete table"); } uint16_t offset_mark_glyph_sets_def = 0; - if (gdef->version_2) { + if (version_minor >= 2) { if (!table.ReadU16(&offset_mark_glyph_sets_def)) { - return OTS_FAILURE_MSG("Incomplete table"); + return Error("Incomplete table"); + } + } + uint32_t item_var_store_offset = 0; + if (version_minor >= 3) { + if (!table.ReadU32(&item_var_store_offset)) { + return Error("Incomplete table"); } } unsigned gdef_header_end = 4 + 4 * 2; - if (gdef->version_2) + if (version_minor >= 2) gdef_header_end += 2; + if (version_minor >= 3) + gdef_header_end += 4; // Parse subtables if (offset_glyph_class_def) { if (offset_glyph_class_def >= length || offset_glyph_class_def < gdef_header_end) { - return OTS_FAILURE_MSG("Invalid offset to glyph classes"); + return Error("Invalid offset to glyph classes"); } - if (!ParseGlyphClassDefTable(font, data + offset_glyph_class_def, + if (!ots::ParseClassDefTable(GetFont(), data + offset_glyph_class_def, length - offset_glyph_class_def, - num_glyphs)) { - return OTS_FAILURE_MSG("Invalid glyph classes"); + this->m_num_glyphs, kMaxGlyphClassDefValue)) { + return Error("Invalid glyph classes"); } - gdef->has_glyph_class_def = true; } if (offset_attach_list) { if (offset_attach_list >= length || offset_attach_list < gdef_header_end) { - return OTS_FAILURE_MSG("Invalid offset to attachment list"); + return Error("Invalid offset to attachment list"); } - if (!ParseAttachListTable(font, data + offset_attach_list, - length - offset_attach_list, - num_glyphs)) { - return OTS_FAILURE_MSG("Invalid attachment list"); + if (!ParseAttachListTable(data + offset_attach_list, + length - offset_attach_list)) { + return Error("Invalid attachment list"); } } if (offset_lig_caret_list) { if (offset_lig_caret_list >= length || offset_lig_caret_list < gdef_header_end) { - return OTS_FAILURE_MSG("Invalid offset to ligature caret list"); + return Error("Invalid offset to ligature caret list"); } - if (!ParseLigCaretListTable(font, data + offset_lig_caret_list, - length - offset_lig_caret_list, - num_glyphs)) { - return OTS_FAILURE_MSG("Invalid ligature caret list"); + if (!ParseLigCaretListTable(data + offset_lig_caret_list, + length - offset_lig_caret_list)) { + return Error("Invalid ligature caret list"); } } if (offset_mark_attach_class_def) { if (offset_mark_attach_class_def >= length || offset_mark_attach_class_def < gdef_header_end) { - return OTS_FAILURE_MSG("Invalid offset to mark attachment list"); + return Error("Invalid offset to mark attachment list"); } - if (!ParseMarkAttachClassDefTable(font, - data + offset_mark_attach_class_def, - length - offset_mark_attach_class_def, - num_glyphs)) { - return OTS_FAILURE_MSG("Invalid mark attachment list"); + if (!ots::ParseClassDefTable(GetFont(), + data + offset_mark_attach_class_def, + length - offset_mark_attach_class_def, + this->m_num_glyphs, kMaxClassDefValue)) { + return Error("Invalid mark attachment list"); } - gdef->has_mark_attachment_class_def = true; } if (offset_mark_glyph_sets_def) { if (offset_mark_glyph_sets_def >= length || offset_mark_glyph_sets_def < gdef_header_end) { - return OTS_FAILURE_MSG("invalid offset to mark glyph sets"); + return Error("invalid offset to mark glyph sets"); } - if (!ParseMarkGlyphSetsDefTable(font, - data + offset_mark_glyph_sets_def, - length - offset_mark_glyph_sets_def, - num_glyphs)) { - return OTS_FAILURE_MSG("Invalid mark glyph sets"); + if (!ParseMarkGlyphSetsDefTable(data + offset_mark_glyph_sets_def, + length - offset_mark_glyph_sets_def)) { + return Error("Invalid mark glyph sets"); } - gdef->has_mark_glyph_sets_def = true; } - gdef->data = data; - gdef->length = length; - return true; -} - -bool ots_gdef_should_serialise(Font *font) { - return font->gdef != NULL && font->gdef->data != NULL; -} -bool ots_gdef_serialise(OTSStream *out, Font *font) { - if (!out->Write(font->gdef->data, font->gdef->length)) { - return OTS_FAILURE_MSG("Failed to write GDEF table"); + if (item_var_store_offset) { + if (item_var_store_offset >= length || + item_var_store_offset < gdef_header_end) { + return Error("invalid offset to item variation store"); + } + if (!ParseItemVariationStore(GetFont(), data + item_var_store_offset, + length - item_var_store_offset)) { + return Error("Invalid item variation store"); + } } + this->m_data = data; + this->m_length = length; return true; } -void ots_gdef_reuse(Font *font, Font *other) { - font->gdef = other->gdef; - font->gdef_reused = true; -} +bool OpenTypeGDEF::Serialize(OTSStream *out) { + if (!out->Write(this->m_data, this->m_length)) { + return Error("Failed to write table"); + } -void ots_gdef_free(Font *font) { - delete font->gdef; + return true; } } // namespace ots - -#undef TABLE_NAME diff --git a/gfx/ots/src/gdef.h b/gfx/ots/src/gdef.h index f46f419c7..7c7cc0ce5 100644 --- a/gfx/ots/src/gdef.h +++ b/gfx/ots/src/gdef.h @@ -1,4 +1,4 @@ -// Copyright (c) 2011 The Chromium Authors. All rights reserved. +// Copyright (c) 2011-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -9,25 +9,29 @@ namespace ots { -struct OpenTypeGDEF { - OpenTypeGDEF() - : version_2(false), - has_glyph_class_def(false), - has_mark_attachment_class_def(false), - has_mark_glyph_sets_def(false), +class OpenTypeGDEF : public Table { + public: + explicit OpenTypeGDEF(Font *font, uint32_t tag) + : Table(font, tag, tag), num_mark_glyph_sets(0), - data(NULL), - length(0) { + m_data(NULL), + m_length(0), + m_num_glyphs(0) { } - bool version_2; - bool has_glyph_class_def; - bool has_mark_attachment_class_def; - bool has_mark_glyph_sets_def; + bool Parse(const uint8_t *data, size_t length); + bool Serialize(OTSStream *out); + uint16_t num_mark_glyph_sets; - const uint8_t *data; - size_t length; + private: + bool ParseAttachListTable(const uint8_t *data, size_t length); + bool ParseLigCaretListTable(const uint8_t *data, size_t length); + bool ParseMarkGlyphSetsDefTable(const uint8_t *data, size_t length); + + const uint8_t *m_data; + size_t m_length; + uint16_t m_num_glyphs; }; } // namespace ots diff --git a/gfx/ots/src/glat.cc b/gfx/ots/src/glat.cc new file mode 100644 index 000000000..23f7dfd9a --- /dev/null +++ b/gfx/ots/src/glat.cc @@ -0,0 +1,459 @@ +// Copyright (c) 2009-2017 The OTS 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 "glat.h" + +#include "gloc.h" +#include "mozilla/Compression.h" +#include <list> + +namespace ots { + +// ----------------------------------------------------------------------------- +// OpenTypeGLAT_v1 +// ----------------------------------------------------------------------------- + +bool OpenTypeGLAT_v1::Parse(const uint8_t* data, size_t length) { + Buffer table(data, length); + OpenTypeGLOC* gloc = static_cast<OpenTypeGLOC*>( + GetFont()->GetTypedTable(OTS_TAG_GLOC)); + if (!gloc) { + return DropGraphite("Required Gloc table is missing"); + } + + if (!table.ReadU32(&this->version) || this->version >> 16 != 1) { + return DropGraphite("Failed to read version"); + } + + const std::vector<uint32_t>& locations = gloc->GetLocations(); + if (locations.empty()) { + return DropGraphite("No locations from Gloc table"); + } + std::list<uint32_t> unverified(locations.begin(), locations.end()); + while (table.remaining()) { + GlatEntry entry(this); + if (table.offset() > unverified.front()) { + return DropGraphite("Offset check failed for a GlatEntry"); + } + if (table.offset() == unverified.front()) { + unverified.pop_front(); + } + if (unverified.empty()) { + return DropGraphite("Expected more locations"); + } + if (!entry.ParsePart(table)) { + return DropGraphite("Failed to read a GlatEntry"); + } + this->entries.push_back(entry); + } + + if (unverified.size() != 1 || unverified.front() != table.offset()) { + return DropGraphite("%zu location(s) could not be verified", unverified.size()); + } + if (table.remaining()) { + return Warning("%zu bytes unparsed", table.remaining()); + } + return true; +} + +bool OpenTypeGLAT_v1::Serialize(OTSStream* out) { + if (!out->WriteU32(this->version) || + !SerializeParts(this->entries, out)) { + return Error("Failed to write table"); + } + return true; +} + +bool OpenTypeGLAT_v1::GlatEntry::ParsePart(Buffer& table) { + if (!table.ReadU8(&this->attNum)) { + return parent->Error("GlatEntry: Failed to read attNum"); + } + if (!table.ReadU8(&this->num)) { + return parent->Error("GlatEntry: Failed to read num"); + } + + //this->attributes.resize(this->num); + for (int i = 0; i < this->num; ++i) { + this->attributes.emplace_back(); + if (!table.ReadS16(&this->attributes[i])) { + return parent->Error("GlatEntry: Failed to read attribute %u", i); + } + } + return true; +} + +bool OpenTypeGLAT_v1::GlatEntry::SerializePart(OTSStream* out) const { + if (!out->WriteU8(this->attNum) || + !out->WriteU8(this->num) || + !SerializeParts(this->attributes, out)) { + return parent->Error("GlatEntry: Failed to write"); + } + return true; +} + +// ----------------------------------------------------------------------------- +// OpenTypeGLAT_v2 +// ----------------------------------------------------------------------------- + +bool OpenTypeGLAT_v2::Parse(const uint8_t* data, size_t length) { + Buffer table(data, length); + OpenTypeGLOC* gloc = static_cast<OpenTypeGLOC*>( + GetFont()->GetTypedTable(OTS_TAG_GLOC)); + if (!gloc) { + return DropGraphite("Required Gloc table is missing"); + } + + if (!table.ReadU32(&this->version) || this->version >> 16 != 1) { + return DropGraphite("Failed to read version"); + } + + const std::vector<uint32_t>& locations = gloc->GetLocations(); + if (locations.empty()) { + return DropGraphite("No locations from Gloc table"); + } + std::list<uint32_t> unverified(locations.begin(), locations.end()); + while (table.remaining()) { + GlatEntry entry(this); + if (table.offset() > unverified.front()) { + return DropGraphite("Offset check failed for a GlatEntry"); + } + if (table.offset() == unverified.front()) { + unverified.pop_front(); + } + if (unverified.empty()) { + return DropGraphite("Expected more locations"); + } + if (!entry.ParsePart(table)) { + return DropGraphite("Failed to read a GlatEntry"); + } + this->entries.push_back(entry); + } + + if (unverified.size() != 1 || unverified.front() != table.offset()) { + return DropGraphite("%zu location(s) could not be verified", unverified.size()); + } + if (table.remaining()) { + return Warning("%zu bytes unparsed", table.remaining()); + } + return true; +} + +bool OpenTypeGLAT_v2::Serialize(OTSStream* out) { + if (!out->WriteU32(this->version) || + !SerializeParts(this->entries, out)) { + return Error("Failed to write table"); + } + return true; +} + +bool OpenTypeGLAT_v2::GlatEntry::ParsePart(Buffer& table) { + if (!table.ReadS16(&this->attNum)) { + return parent->Error("GlatEntry: Failed to read attNum"); + } + if (!table.ReadS16(&this->num) || this->num < 0) { + return parent->Error("GlatEntry: Failed to read valid num"); + } + + //this->attributes.resize(this->num); + for (int i = 0; i < this->num; ++i) { + this->attributes.emplace_back(); + if (!table.ReadS16(&this->attributes[i])) { + return parent->Error("GlatEntry: Failed to read attribute %u", i); + } + } + return true; +} + +bool OpenTypeGLAT_v2::GlatEntry::SerializePart(OTSStream* out) const { + if (!out->WriteS16(this->attNum) || + !out->WriteS16(this->num) || + !SerializeParts(this->attributes, out)) { + return parent->Error("GlatEntry: Failed to write"); + } + return true; +} + +// ----------------------------------------------------------------------------- +// OpenTypeGLAT_v3 +// ----------------------------------------------------------------------------- + +bool OpenTypeGLAT_v3::Parse(const uint8_t* data, size_t length, + bool prevent_decompression) { + Buffer table(data, length); + OpenTypeGLOC* gloc = static_cast<OpenTypeGLOC*>( + GetFont()->GetTypedTable(OTS_TAG_GLOC)); + if (!gloc) { + return DropGraphite("Required Gloc table is missing"); + } + + if (!table.ReadU32(&this->version) || this->version >> 16 != 3) { + return DropGraphite("Failed to read version"); + } + if (!table.ReadU32(&this->compHead)) { + return DropGraphite("Failed to read compression header"); + } + switch ((this->compHead & SCHEME) >> 27) { + case 0: // uncompressed + break; + case 1: { // lz4 + if (prevent_decompression) { + return DropGraphite("Illegal nested compression"); + } + size_t decompressed_size = this->compHead & FULL_SIZE; + if (decompressed_size < length) { + return DropGraphite("Decompressed size is less than compressed size"); + } + if (decompressed_size == 0) { + return DropGraphite("Decompressed size is set to 0"); + } + // decompressed table must be <= 30MB + if (decompressed_size > 30 * 1024 * 1024) { + return DropGraphite("Decompressed size exceeds 30MB: %gMB", + decompressed_size / (1024.0 * 1024.0)); + } + std::vector<uint8_t> decompressed(decompressed_size); + size_t outputSize = 0; + bool ret = mozilla::Compression::LZ4::decompressPartial( + reinterpret_cast<const char*>(data + table.offset()), + table.remaining(), // input buffer size (input size + padding) + reinterpret_cast<char*>(decompressed.data()), + decompressed.size(), // target output size + &outputSize); // return output size + if (!ret || outputSize != decompressed.size()) { + return DropGraphite("Decompression failed"); + } + return this->Parse(decompressed.data(), decompressed.size(), true); + } + default: + return DropGraphite("Unknown compression scheme"); + } + if (this->compHead & RESERVED) { + Warning("Nonzero reserved"); + } + + const std::vector<uint32_t>& locations = gloc->GetLocations(); + if (locations.empty()) { + return DropGraphite("No locations from Gloc table"); + } + std::list<uint32_t> unverified(locations.begin(), locations.end()); + //this->entries.resize(locations.size() - 1, this); + for (size_t i = 0; i < locations.size() - 1; ++i) { + this->entries.emplace_back(this); + if (table.offset() != unverified.front()) { + return DropGraphite("Offset check failed for a GlyphAttrs"); + } + unverified.pop_front(); + if (!this->entries[i].ParsePart(table, + unverified.front() - table.offset())) { + // unverified.front() is guaranteed to exist because of the number of + // iterations of this loop + return DropGraphite("Failed to read a GlyphAttrs"); + } + } + + if (unverified.size() != 1 || unverified.front() != table.offset()) { + return DropGraphite("%zu location(s) could not be verified", unverified.size()); + } + if (table.remaining()) { + return Warning("%zu bytes unparsed", table.remaining()); + } + return true; +} + +bool OpenTypeGLAT_v3::Serialize(OTSStream* out) { + if (!out->WriteU32(this->version) || + !out->WriteU32(this->compHead) || + !SerializeParts(this->entries, out)) { + return Error("Failed to write table"); + } + return true; +} + +bool OpenTypeGLAT_v3::GlyphAttrs::ParsePart(Buffer& table, const size_t size) { + size_t init_offset = table.offset(); + if (parent->compHead & OCTABOXES && !octabox.ParsePart(table)) { + // parent->flags & 0b1: octaboxes are present flag + return parent->Error("GlyphAttrs: Failed to read octabox"); + } + + while (table.offset() < init_offset + size) { + GlatEntry entry(parent); + if (!entry.ParsePart(table)) { + return parent->Error("GlyphAttrs: Failed to read a GlatEntry"); + } + this->entries.push_back(entry); + } + return true; +} + +bool OpenTypeGLAT_v3::GlyphAttrs::SerializePart(OTSStream* out) const { + if ((parent->compHead & OCTABOXES && !octabox.SerializePart(out)) || + !SerializeParts(this->entries, out)) { + return parent->Error("GlyphAttrs: Failed to write"); + } + return true; +} + +bool OpenTypeGLAT_v3::GlyphAttrs:: +OctaboxMetrics::ParsePart(Buffer& table) { + if (!table.ReadU16(&this->subbox_bitmap)) { + return parent->Error("OctaboxMetrics: Failed to read subbox_bitmap"); + } + if (!table.ReadU8(&this->diag_neg_min)) { + return parent->Error("OctaboxMetrics: Failed to read diag_neg_min"); + } + if (!table.ReadU8(&this->diag_neg_max) || + this->diag_neg_max < this->diag_neg_min) { + return parent->Error("OctaboxMetrics: Failed to read valid diag_neg_max"); + } + if (!table.ReadU8(&this->diag_pos_min)) { + return parent->Error("OctaboxMetrics: Failed to read diag_pos_min"); + } + if (!table.ReadU8(&this->diag_pos_max) || + this->diag_pos_max < this->diag_pos_min) { + return parent->Error("OctaboxMetrics: Failed to read valid diag_pos_max"); + } + + unsigned subboxes_len = 0; // count of 1's in this->subbox_bitmap + for (uint16_t i = this->subbox_bitmap; i; i >>= 1) { + if (i & 0b1) { + ++subboxes_len; + } + } + //this->subboxes.resize(subboxes_len, parent); + for (unsigned i = 0; i < subboxes_len; i++) { + this->subboxes.emplace_back(parent); + if (!this->subboxes[i].ParsePart(table)) { + return parent->Error("OctaboxMetrics: Failed to read subbox[%u]", i); + } + } + return true; +} + +bool OpenTypeGLAT_v3::GlyphAttrs:: +OctaboxMetrics::SerializePart(OTSStream* out) const { + if (!out->WriteU16(this->subbox_bitmap) || + !out->WriteU8(this->diag_neg_min) || + !out->WriteU8(this->diag_neg_max) || + !out->WriteU8(this->diag_pos_min) || + !out->WriteU8(this->diag_pos_max) || + !SerializeParts(this->subboxes, out)) { + return parent->Error("OctaboxMetrics: Failed to write"); + } + return true; +} + +bool OpenTypeGLAT_v3::GlyphAttrs::OctaboxMetrics:: +SubboxEntry::ParsePart(Buffer& table) { + if (!table.ReadU8(&this->left)) { + return parent->Error("SubboxEntry: Failed to read left"); + } + if (!table.ReadU8(&this->right) || this->right < this->left) { + return parent->Error("SubboxEntry: Failed to read valid right"); + } + if (!table.ReadU8(&this->bottom)) { + return parent->Error("SubboxEntry: Failed to read bottom"); + } + if (!table.ReadU8(&this->top) || this->top < this->bottom) { + return parent->Error("SubboxEntry: Failed to read valid top"); + } + if (!table.ReadU8(&this->diag_pos_min)) { + return parent->Error("SubboxEntry: Failed to read diag_pos_min"); + } + if (!table.ReadU8(&this->diag_pos_max) || + this->diag_pos_max < this->diag_pos_min) { + return parent->Error("SubboxEntry: Failed to read valid diag_pos_max"); + } + if (!table.ReadU8(&this->diag_neg_min)) { + return parent->Error("SubboxEntry: Failed to read diag_neg_min"); + } + if (!table.ReadU8(&this->diag_neg_max) || + this->diag_neg_max < this->diag_neg_min) { + return parent->Error("SubboxEntry: Failed to read valid diag_neg_max"); + } + return true; +} + +bool OpenTypeGLAT_v3::GlyphAttrs::OctaboxMetrics:: +SubboxEntry::SerializePart(OTSStream* out) const { + if (!out->WriteU8(this->left) || + !out->WriteU8(this->right) || + !out->WriteU8(this->bottom) || + !out->WriteU8(this->top) || + !out->WriteU8(this->diag_pos_min) || + !out->WriteU8(this->diag_pos_max) || + !out->WriteU8(this->diag_neg_min) || + !out->WriteU8(this->diag_neg_max)) { + return parent->Error("SubboxEntry: Failed to write"); + } + return true; +} + +bool OpenTypeGLAT_v3::GlyphAttrs:: +GlatEntry::ParsePart(Buffer& table) { + if (!table.ReadS16(&this->attNum)) { + return parent->Error("GlatEntry: Failed to read attNum"); + } + if (!table.ReadS16(&this->num) || this->num < 0) { + return parent->Error("GlatEntry: Failed to read valid num"); + } + + //this->attributes.resize(this->num); + for (int i = 0; i < this->num; ++i) { + this->attributes.emplace_back(); + if (!table.ReadS16(&this->attributes[i])) { + return parent->Error("GlatEntry: Failed to read attribute %u", i); + } + } + return true; +} + +bool OpenTypeGLAT_v3::GlyphAttrs:: +GlatEntry::SerializePart(OTSStream* out) const { + if (!out->WriteS16(this->attNum) || + !out->WriteS16(this->num) || + !SerializeParts(this->attributes, out)) { + return parent->Error("GlatEntry: Failed to write"); + } + return true; +} + +// ----------------------------------------------------------------------------- +// OpenTypeGLAT +// ----------------------------------------------------------------------------- + +bool OpenTypeGLAT::Parse(const uint8_t* data, size_t length) { + if (GetFont()->dropped_graphite) { + return Drop("Skipping Graphite table"); + } + Buffer table(data, length); + uint32_t version; + if (!table.ReadU32(&version)) { + return DropGraphite("Failed to read version"); + } + switch (version >> 16) { + case 1: + this->handler = new OpenTypeGLAT_v1(this->font, this->tag); + break; + case 2: + this->handler = new OpenTypeGLAT_v2(this->font, this->tag); + break; + case 3: { + this->handler = new OpenTypeGLAT_v3(this->font, this->tag); + break; + } + default: + return DropGraphite("Unsupported table version: %u", version >> 16); + } + return this->handler->Parse(data, length); +} + +bool OpenTypeGLAT::Serialize(OTSStream* out) { + if (!this->handler) { + return Error("No Glat table parsed"); + } + return this->handler->Serialize(out); +} + +} // namespace ots diff --git a/gfx/ots/src/glat.h b/gfx/ots/src/glat.h new file mode 100644 index 000000000..04c9c1cce --- /dev/null +++ b/gfx/ots/src/glat.h @@ -0,0 +1,172 @@ +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef OTS_GLAT_H_ +#define OTS_GLAT_H_ + +#include <vector> + +#include "ots.h" +#include "graphite.h" + +namespace ots { + +// ----------------------------------------------------------------------------- +// OpenTypeGLAT_Basic Interface +// ----------------------------------------------------------------------------- + +class OpenTypeGLAT_Basic : public Table { + public: + explicit OpenTypeGLAT_Basic(Font* font, uint32_t tag) + : Table(font, tag, tag) { } + + virtual bool Parse(const uint8_t* data, size_t length) = 0; + virtual bool Serialize(OTSStream* out) = 0; +}; + +// ----------------------------------------------------------------------------- +// OpenTypeGLAT_v1 +// ----------------------------------------------------------------------------- + +class OpenTypeGLAT_v1 : public OpenTypeGLAT_Basic { + public: + explicit OpenTypeGLAT_v1(Font* font, uint32_t tag) + : OpenTypeGLAT_Basic(font, tag) { } + + bool Parse(const uint8_t* data, size_t length); + bool Serialize(OTSStream* out); + + private: + struct GlatEntry : public TablePart<OpenTypeGLAT_v1> { + explicit GlatEntry(OpenTypeGLAT_v1* parent) + : TablePart<OpenTypeGLAT_v1>(parent) { } + bool ParsePart(Buffer& table); + bool SerializePart(OTSStream* out) const; + uint8_t attNum; + uint8_t num; + std::vector<int16_t> attributes; + }; + uint32_t version; + std::vector<GlatEntry> entries; +}; + +// ----------------------------------------------------------------------------- +// OpenTypeGLAT_v2 +// ----------------------------------------------------------------------------- + +class OpenTypeGLAT_v2 : public OpenTypeGLAT_Basic { + public: + explicit OpenTypeGLAT_v2(Font* font, uint32_t tag) + : OpenTypeGLAT_Basic(font, tag) { } + + bool Parse(const uint8_t* data, size_t length); + bool Serialize(OTSStream* out); + + private: + struct GlatEntry : public TablePart<OpenTypeGLAT_v2> { + explicit GlatEntry(OpenTypeGLAT_v2* parent) + : TablePart<OpenTypeGLAT_v2>(parent) { } + bool ParsePart(Buffer& table); + bool SerializePart(OTSStream* out) const; + int16_t attNum; + int16_t num; + std::vector<int16_t> attributes; + }; + uint32_t version; + std::vector<GlatEntry> entries; +}; + +// ----------------------------------------------------------------------------- +// OpenTypeGLAT_v3 +// ----------------------------------------------------------------------------- + +class OpenTypeGLAT_v3 : public OpenTypeGLAT_Basic { + public: + explicit OpenTypeGLAT_v3(Font* font, uint32_t tag) + : OpenTypeGLAT_Basic(font, tag) { } + + bool Parse(const uint8_t* data, size_t length) { + return this->Parse(data, length, false); + } + bool Serialize(OTSStream* out); + + private: + bool Parse(const uint8_t* data, size_t length, bool prevent_decompression); + struct GlyphAttrs : public TablePart<OpenTypeGLAT_v3> { + explicit GlyphAttrs(OpenTypeGLAT_v3* parent) + : TablePart<OpenTypeGLAT_v3>(parent), octabox(parent) { } + bool ParsePart(Buffer& table) { return false; } + bool ParsePart(Buffer& table, const size_t size); + bool SerializePart(OTSStream* out) const; + struct OctaboxMetrics : public TablePart<OpenTypeGLAT_v3> { + explicit OctaboxMetrics(OpenTypeGLAT_v3* parent) + : TablePart<OpenTypeGLAT_v3>(parent) { } + bool ParsePart(Buffer& table); + bool SerializePart(OTSStream* out) const; + struct SubboxEntry : public TablePart<OpenTypeGLAT_v3> { + explicit SubboxEntry(OpenTypeGLAT_v3* parent) + : TablePart<OpenTypeGLAT_v3>(parent) { } + bool ParsePart(Buffer& table); + bool SerializePart(OTSStream* out) const; + uint8_t left; + uint8_t right; + uint8_t bottom; + uint8_t top; + uint8_t diag_pos_min; + uint8_t diag_pos_max; + uint8_t diag_neg_min; + uint8_t diag_neg_max; + }; + uint16_t subbox_bitmap; + uint8_t diag_neg_min; + uint8_t diag_neg_max; + uint8_t diag_pos_min; + uint8_t diag_pos_max; + std::vector<SubboxEntry> subboxes; + }; + struct GlatEntry : public TablePart<OpenTypeGLAT_v3> { + explicit GlatEntry(OpenTypeGLAT_v3* parent) + : TablePart<OpenTypeGLAT_v3>(parent) { } + bool ParsePart(Buffer& table); + bool SerializePart(OTSStream* out) const; + int16_t attNum; + int16_t num; + std::vector<int16_t> attributes; + }; + OctaboxMetrics octabox; + std::vector<GlatEntry> entries; + }; + uint32_t version; + uint32_t compHead; // compression header + static const uint32_t SCHEME = 0xF8000000; + static const uint32_t FULL_SIZE = 0x07FFFFFF; + static const uint32_t RESERVED = 0x07FFFFFE; + static const uint32_t OCTABOXES = 0x00000001; + std::vector<GlyphAttrs> entries; +}; + +// ----------------------------------------------------------------------------- +// OpenTypeGLAT +// ----------------------------------------------------------------------------- + +class OpenTypeGLAT : public Table { + public: + explicit OpenTypeGLAT(Font* font, uint32_t tag) + : Table(font, tag, tag), font(font), tag(tag) { } + OpenTypeGLAT(const OpenTypeGLAT& other) = delete; + OpenTypeGLAT& operator=(const OpenTypeGLAT& other) = delete; + ~OpenTypeGLAT() { delete handler; } + + bool Parse(const uint8_t* data, size_t length); + bool Serialize(OTSStream* out); + + private: + Font* font; + uint32_t tag; + OpenTypeGLAT_Basic* handler = nullptr; +}; + +} // namespace ots + +#endif // OTS_GLAT_H_ diff --git a/gfx/ots/src/gloc.cc b/gfx/ots/src/gloc.cc new file mode 100644 index 000000000..9c5ee3bdf --- /dev/null +++ b/gfx/ots/src/gloc.cc @@ -0,0 +1,108 @@ +// Copyright (c) 2009-2017 The OTS 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 "gloc.h" + +#include "name.h" + +namespace ots { + +bool OpenTypeGLOC::Parse(const uint8_t* data, size_t length) { + if (GetFont()->dropped_graphite) { + return Drop("Skipping Graphite table"); + } + Buffer table(data, length); + OpenTypeNAME* name = static_cast<OpenTypeNAME*>( + GetFont()->GetTypedTable(OTS_TAG_NAME)); + if (!name) { + return DropGraphite("Required name table is missing"); + } + + if (!table.ReadU32(&this->version)) { + return DropGraphite("Failed to read version"); + } + if (this->version >> 16 != 1) { + return DropGraphite("Unsupported table version: %u", this->version >> 16); + } + if (!table.ReadU16(&this->flags) || this->flags > 0b11) { + return DropGraphite("Failed to read valid flags"); + } + if (!table.ReadU16(&this->numAttribs)) { + return DropGraphite("Failed to read numAttribs"); + } + + if (this->flags & ATTRIB_IDS && this->numAttribs * sizeof(uint16_t) > + table.remaining()) { + return DropGraphite("Failed to calulate length of locations"); + } + size_t locations_len = (table.remaining() - + (this->flags & ATTRIB_IDS ? this->numAttribs * sizeof(uint16_t) : 0)) / + (this->flags & LONG_FORMAT ? sizeof(uint32_t) : sizeof(uint16_t)); + //this->locations.resize(locations_len); + if (this->flags & LONG_FORMAT) { + unsigned long last_location = 0; + for (size_t i = 0; i < locations_len; ++i) { + this->locations.emplace_back(); + uint32_t& location = this->locations[i]; + if (!table.ReadU32(&location) || location < last_location) { + return DropGraphite("Failed to read valid locations[%lu]", i); + } + last_location = location; + } + } else { // short (16-bit) offsets + unsigned last_location = 0; + for (size_t i = 0; i < locations_len; ++i) { + uint16_t location; + if (!table.ReadU16(&location) || location < last_location) { + return DropGraphite("Failed to read valid locations[%lu]", i); + } + last_location = location; + this->locations.push_back(static_cast<uint32_t>(location)); + } + } + if (this->locations.empty()) { + return DropGraphite("No locations"); + } + + if (this->flags & ATTRIB_IDS) { // attribIds array present + //this->attribIds.resize(numAttribs); + for (unsigned i = 0; i < this->numAttribs; ++i) { + this->attribIds.emplace_back(); + if (!table.ReadU16(&this->attribIds[i]) || + !name->IsValidNameId(this->attribIds[i])) { + return DropGraphite("Failed to read valid attribIds[%u]", i); + } + } + } + + if (table.remaining()) { + return Warning("%zu bytes unparsed", table.remaining()); + } + return true; +} + +bool OpenTypeGLOC::Serialize(OTSStream* out) { + if (!out->WriteU32(this->version) || + !out->WriteU16(this->flags) || + !out->WriteU16(this->numAttribs) || + (this->flags & LONG_FORMAT ? !SerializeParts(this->locations, out) : + ![&] { + for (uint32_t location : this->locations) { + if (!out->WriteU16(static_cast<uint16_t>(location))) { + return false; + } + } + return true; + }()) || + (this->flags & ATTRIB_IDS && !SerializeParts(this->attribIds, out))) { + return Error("Failed to write table"); + } + return true; +} + +const std::vector<uint32_t>& OpenTypeGLOC::GetLocations() { + return this->locations; +} + +} // namespace ots diff --git a/gfx/ots/src/gloc.h b/gfx/ots/src/gloc.h new file mode 100644 index 000000000..60184ffb9 --- /dev/null +++ b/gfx/ots/src/gloc.h @@ -0,0 +1,36 @@ +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef OTS_GLOC_H_ +#define OTS_GLOC_H_ + +#include <vector> + +#include "ots.h" +#include "graphite.h" + +namespace ots { + +class OpenTypeGLOC : public Table { + public: + explicit OpenTypeGLOC(Font* font, uint32_t tag) + : Table(font, tag, tag) { } + + bool Parse(const uint8_t* data, size_t length); + bool Serialize(OTSStream* out); + const std::vector<uint32_t>& GetLocations(); + + private: + uint32_t version; + uint16_t flags; + static const uint16_t LONG_FORMAT = 0b1; + static const uint16_t ATTRIB_IDS = 0b10; + uint16_t numAttribs; + std::vector<uint32_t> locations; + std::vector<uint16_t> attribIds; +}; + +} // namespace ots + +#endif // OTS_GLOC_H_ diff --git a/gfx/ots/src/glyf.cc b/gfx/ots/src/glyf.cc index 311916dc0..0c19d6d7b 100644 --- a/gfx/ots/src/glyf.cc +++ b/gfx/ots/src/glyf.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -14,20 +14,15 @@ // glyf - Glyph Data // http://www.microsoft.com/typography/otspec/glyf.htm -#define TABLE_NAME "glyf" - -namespace { +namespace ots { -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) { +bool OpenTypeGLYF::ParseFlagsForSimpleGlyph(Buffer &glyph, + uint32_t num_flags, + uint32_t *flag_index, + uint32_t *coordinates_length) { uint8_t flag = 0; - if (!table->ReadU8(&flag)) { - return OTS_FAILURE_MSG("Can't read flag"); + if (!glyph.ReadU8(&flag)) { + return Error("Can't read flag"); } uint32_t delta = 0; @@ -43,140 +38,205 @@ bool ParseFlagsForSimpleGlyph(ots::Font *font, delta += 2; } + /* MS and Apple specs say this bit is reserved and must be set to zero, but + * Apple spec then contradicts itself and says it should be set on the first + * contour flag for simple glyphs with overlapping contours: + * https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6AATIntro.html + * (“Overlapping contours” section) */ + if (flag & (1u << 6) && *flag_index != 0) { + return Error("Bad glyph flag (%d), " + "bit 6 must be set to zero for flag %d", flag, *flag_index); + } + if (flag & (1u << 3)) { // repeat - if (*flags_count_logical + 1 >= num_flags) { - return OTS_FAILURE_MSG("Count too high (%d + 1 >= %d)", *flags_count_logical, num_flags); + if (*flag_index + 1 >= num_flags) { + return Error("Count too high (%d + 1 >= %d)", *flag_index, num_flags); } uint8_t repeat = 0; - if (!table->ReadU8(&repeat)) { - return OTS_FAILURE_MSG("Can't read repeat value"); + if (!glyph.ReadU8(&repeat)) { + return Error("Can't read repeat value"); } if (repeat == 0) { - return OTS_FAILURE_MSG("Zero repeat"); + return Error("Zero repeat"); } delta += (delta * repeat); - *flags_count_logical += repeat; - if (*flags_count_logical >= num_flags) { - return OTS_FAILURE_MSG("Count too high (%d >= %d)", *flags_count_logical, num_flags); + *flag_index += repeat; + if (*flag_index >= num_flags) { + return Error("Count too high (%d >= %d)", *flag_index, num_flags); } - ++(*flags_count_physical); } - if ((flag & (1u << 6)) || (flag & (1u << 7))) { // reserved flags - return OTS_FAILURE_MSG("Bad glyph flag value (%d), reserved flags must be set to zero", flag); + if (flag & (1u << 7)) { // reserved flag + return Error("Bad glyph flag (%d), reserved bit 7 must be set to zero", flag); } - *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); + *coordinates_length += delta; + if (glyph.length() < *coordinates_length) { + return Error("Glyph coordinates length bigger than glyph length (%d > %d)", + *coordinates_length, glyph.length()); } return true; } -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 = font->glyf; - +bool OpenTypeGLYF::ParseSimpleGlyph(Buffer &glyph, + int16_t num_contours) { // 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 (!glyph.ReadU16(&tmp_index)) { + return Error("Can't read contour index %d", i); } if (tmp_index == 0xffffu) { - return OTS_FAILURE_MSG("Bad contour index %d", i); + return Error("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); + return Error("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 ((font->maxp->version_1) && - (font->maxp->max_size_glyf_instructions < bytecode_length)) { - return OTS_FAILURE_MSG("Bytecode length too high %d", bytecode_length); + if (!glyph.ReadU16(&bytecode_length)) { + return Error("Can't read 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); + if (this->maxp->version_1 && + this->maxp->max_size_glyf_instructions < bytecode_length) { + this->maxp->max_size_glyf_instructions = bytecode_length; + Warning("Bytecode length is bigger than maxp.maxSizeOfInstructions %d: %d", + this->maxp->max_size_glyf_instructions, bytecode_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); + if (!glyph.Skip(bytecode_length)) { + return Error("Can't read 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(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); + uint32_t coordinates_length = 0; + for (uint32_t i = 0; i < num_flags; ++i) { + if (!ParseFlagsForSimpleGlyph(glyph, num_flags, &i, &coordinates_length)) { + return Error("Failed to parse glyph flags %d", i); } } - if (gly_length < (gly_header_length + bytecode_length + - flags_count_physical + xy_coordinates_length)) { - return OTS_FAILURE_MSG("Glyph too short %d", gly_length); + if (!glyph.Skip(coordinates_length)) { + return Error("Glyph too short %d", glyph.length()); } - if (gly_length - (gly_header_length + bytecode_length + - flags_count_physical + xy_coordinates_length) > 3) { + if (glyph.remaining() > 3) { // We allow 0-3 bytes difference since gly_length is 4-bytes aligned, // zero-padded length. - return OTS_FAILURE_MSG("Invalid glyph length %d", gly_length); + Warning("Extra bytes at end of the glyph: %d", glyph.remaining()); } - glyf->iov.push_back(std::make_pair( - data + gly_offset + gly_header_length + bytecode_length, - static_cast<size_t>(flags_count_physical + xy_coordinates_length))); - - *new_size - = gly_header_length + flags_count_physical + xy_coordinates_length + bytecode_length; + this->iov.push_back(std::make_pair(glyph.buffer(), glyph.offset())); return true; } -} // namespace +#define ARG_1_AND_2_ARE_WORDS (1u << 0) +#define WE_HAVE_A_SCALE (1u << 3) +#define MORE_COMPONENTS (1u << 5) +#define WE_HAVE_AN_X_AND_Y_SCALE (1u << 6) +#define WE_HAVE_A_TWO_BY_TWO (1u << 7) +#define WE_HAVE_INSTRUCTIONS (1u << 8) + +bool OpenTypeGLYF::ParseCompositeGlyph(Buffer &glyph) { + uint16_t flags = 0; + uint16_t gid = 0; + do { + if (!glyph.ReadU16(&flags) || !glyph.ReadU16(&gid)) { + return Error("Can't read composite glyph flags or glyphIndex"); + } -namespace ots { + if (gid >= this->maxp->num_glyphs) { + return Error("Invalid glyph id used in composite glyph: %d", gid); + } + + if (flags & ARG_1_AND_2_ARE_WORDS) { + int16_t argument1; + int16_t argument2; + if (!glyph.ReadS16(&argument1) || !glyph.ReadS16(&argument2)) { + return Error("Can't read argument1 or argument2"); + } + } else { + uint8_t argument1; + uint8_t argument2; + if (!glyph.ReadU8(&argument1) || !glyph.ReadU8(&argument2)) { + return Error("Can't read argument1 or argument2"); + } + } + + if (flags & WE_HAVE_A_SCALE) { + int16_t scale; + if (!glyph.ReadS16(&scale)) { + return Error("Can't read scale"); + } + } else if (flags & WE_HAVE_AN_X_AND_Y_SCALE) { + int16_t xscale; + int16_t yscale; + if (!glyph.ReadS16(&xscale) || !glyph.ReadS16(&yscale)) { + return Error("Can't read xscale or yscale"); + } + } else if (flags & WE_HAVE_A_TWO_BY_TWO) { + int16_t xscale; + int16_t scale01; + int16_t scale10; + int16_t yscale; + if (!glyph.ReadS16(&xscale) || + !glyph.ReadS16(&scale01) || + !glyph.ReadS16(&scale10) || + !glyph.ReadS16(&yscale)) { + return Error("Can't read transform"); + } + } + } while (flags & MORE_COMPONENTS); + + if (flags & WE_HAVE_INSTRUCTIONS) { + uint16_t bytecode_length; + if (!glyph.ReadU16(&bytecode_length)) { + return Error("Can't read instructions size"); + } -bool ots_glyf_parse(Font *font, const uint8_t *data, size_t length) { - Buffer table(data, length); + if (this->maxp->version_1 && + this->maxp->max_size_glyf_instructions < bytecode_length) { + this->maxp->max_size_glyf_instructions = bytecode_length; + Warning("Bytecode length is bigger than maxp.maxSizeOfInstructions " + "%d: %d", + this->maxp->max_size_glyf_instructions, bytecode_length); + } - if (!font->maxp || !font->loca || !font->head) { - return OTS_FAILURE_MSG("Missing maxp or loca or head table needed by glyf table"); + if (!glyph.Skip(bytecode_length)) { + return Error("Can't read bytecode of length %d", bytecode_length); + } } - OpenTypeGLYF *glyf = new OpenTypeGLYF; - font->glyf = glyf; + this->iov.push_back(std::make_pair(glyph.buffer(), glyph.offset())); - const unsigned num_glyphs = font->maxp->num_glyphs; - std::vector<uint32_t> &offsets = font->loca->offsets; + return true; +} + +bool OpenTypeGLYF::Parse(const uint8_t *data, size_t length) { + OpenTypeMAXP *maxp = static_cast<OpenTypeMAXP*>( + GetFont()->GetTypedTable(OTS_TAG_MAXP)); + OpenTypeLOCA *loca = static_cast<OpenTypeLOCA*>( + GetFont()->GetTypedTable(OTS_TAG_LOCA)); + OpenTypeHEAD *head = static_cast<OpenTypeHEAD*>( + GetFont()->GetTypedTable(OTS_TAG_HEAD)); + if (!maxp || !loca || !head) { + return Error("Missing maxp or loca or head table needed by glyf table"); + } + + this->maxp = maxp; + + const unsigned num_glyphs = maxp->num_glyphs; + std::vector<uint32_t> &offsets = loca->offsets; if (offsets.size() != num_glyphs + 1) { - return OTS_FAILURE_MSG("Invalide glyph offsets size %ld != %d", offsets.size(), num_glyphs + 1); + return Error("Invalide glyph offsets size %ld != %d", offsets.size(), num_glyphs + 1); } std::vector<uint32_t> resulting_offsets(num_glyphs + 1); @@ -193,30 +253,31 @@ bool ots_glyf_parse(Font *font, const uint8_t *data, size_t length) { } if (gly_offset >= length) { - return OTS_FAILURE_MSG("Glyph %d offset %d too high %ld", i, gly_offset, length); + return Error("Glyph %d offset %d too high %ld", i, gly_offset, length); } // Since these are unsigned types, the compiler is not allowed to assume // that they never overflow. if (gly_offset + gly_length < gly_offset) { - return OTS_FAILURE_MSG("Glyph %d length (%d < 0)!", i, gly_length); + return Error("Glyph %d length (%d < 0)!", i, gly_length); } if (gly_offset + gly_length > length) { - return OTS_FAILURE_MSG("Glyph %d length %d too high", i, gly_length); + return Error("Glyph %d length %d too high", i, gly_length); } - table.set_offset(gly_offset); + Buffer glyph(data + gly_offset, gly_length); + int16_t num_contours, xmin, ymin, xmax, ymax; - if (!table.ReadS16(&num_contours) || - !table.ReadS16(&xmin) || - !table.ReadS16(&ymin) || - !table.ReadS16(&xmax) || - !table.ReadS16(&ymax)) { - return OTS_FAILURE_MSG("Can't read glyph %d header", i); + if (!glyph.ReadS16(&num_contours) || + !glyph.ReadS16(&xmin) || + !glyph.ReadS16(&ymin) || + !glyph.ReadS16(&xmax) || + !glyph.ReadS16(&ymax)) { + return Error("Can't read glyph %d header", i); } if (num_contours <= -2) { // -2, -3, -4, ... are reserved for future use. - return OTS_FAILURE_MSG("Bad number of contours %d in glyph %d", num_contours, i); + return Error("Bad number of contours %d in glyph %d", num_contours, i); } // workaround for fonts in http://www.princexml.com/fonts/ @@ -224,35 +285,36 @@ bool ots_glyf_parse(Font *font, const uint8_t *data, size_t length) { (xmax == -32767) && (ymin == 32767) && (ymax == -32767)) { - OTS_WARNING("bad xmin/xmax/ymin/ymax values"); + Warning("bad xmin/xmax/ymin/ymax values"); 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); + return Error("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(font, data, &table, - num_contours, gly_offset, gly_length, &new_size)) { - return OTS_FAILURE_MSG("Failed to parse glyph %d", i); + if (num_contours == 0) { + // This is an empty glyph and shouldn’t have any glyph data, but if it + // does we will simply ignore it. + glyph.set_offset(0); + } else if (num_contours > 0) { + if (!ParseSimpleGlyph(glyph, num_contours)) { + return Error("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; + if (!ParseCompositeGlyph(glyph)) { + return Error("Failed to parse glyph %d", i); + } } + size_t new_size = glyph.offset(); 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( + this->iov.push_back(std::make_pair( reinterpret_cast<const uint8_t*>("\x00\x00\x00\x00"), static_cast<size_t>(padding))); new_size += padding; @@ -264,40 +326,32 @@ bool ots_glyf_parse(Font *font, const uint8_t *data, size_t length) { const uint16_t max16 = std::numeric_limits<uint16_t>::max(); if ((*std::max_element(resulting_offsets.begin(), resulting_offsets.end()) >= (max16 * 2u)) && - (font->head->index_to_loc_format != 1)) { - OTS_WARNING("2-bytes indexing is not possible (due to the padding above)"); - font->head->index_to_loc_format = 1; + (head->index_to_loc_format != 1)) { + head->index_to_loc_format = 1; } - font->loca->offsets = resulting_offsets; - return true; -} - -bool ots_glyf_should_serialise(Font *font) { - return font->glyf != NULL; -} - -bool ots_glyf_serialise(OTSStream *out, Font *font) { - const OpenTypeGLYF *glyf = font->glyf; + loca->offsets = resulting_offsets; - 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); - } + if (this->iov.empty()) { + // As a special case when all glyph in the font are empty, add a zero byte + // to the table, so that we don’t reject it down the way, and to make the + // table work on Windows as well. + // See https://github.com/khaledhosny/ots/issues/52 + static const uint8_t kZero = 0; + this->iov.push_back(std::make_pair(&kZero, 1)); } return true; } -void ots_glyf_reuse(Font *font, Font *other) { - font->glyf = other->glyf; - font->glyf_reused = true; -} +bool OpenTypeGLYF::Serialize(OTSStream *out) { + for (unsigned i = 0; i < this->iov.size(); ++i) { + if (!out->Write(this->iov[i].first, this->iov[i].second)) { + return Error("Falied to write glyph %d", i); + } + } -void ots_glyf_free(Font *font) { - delete font->glyf; + return true; } } // namespace ots - -#undef TABLE_NAME diff --git a/gfx/ots/src/glyf.h b/gfx/ots/src/glyf.h index 9a8baf5ec..1da94e4b9 100644 --- a/gfx/ots/src/glyf.h +++ b/gfx/ots/src/glyf.h @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -12,8 +12,26 @@ #include "ots.h" namespace ots { +class OpenTypeMAXP; + +class OpenTypeGLYF : public Table { + public: + explicit OpenTypeGLYF(Font *font, uint32_t tag) + : Table(font, tag, tag), maxp(NULL) { } + + bool Parse(const uint8_t *data, size_t length); + bool Serialize(OTSStream *out); + + private: + bool ParseFlagsForSimpleGlyph(Buffer &glyph, + uint32_t num_flags, + uint32_t *flag_index, + uint32_t *coordinates_length); + bool ParseSimpleGlyph(Buffer &glyph, int16_t num_contours); + bool ParseCompositeGlyph(Buffer &glyph); + + OpenTypeMAXP* maxp; -struct OpenTypeGLYF { std::vector<std::pair<const uint8_t*, size_t> > iov; }; diff --git a/gfx/ots/src/gpos.cc b/gfx/ots/src/gpos.cc index 83d9ab053..034f9799d 100644 --- a/gfx/ots/src/gpos.cc +++ b/gfx/ots/src/gpos.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2011 The Chromium Authors. All rights reserved. +// Copyright (c) 2011-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -30,12 +30,12 @@ enum GPOS_TYPE { GPOS_TYPE_RESERVED = 10 }; -// The size of gpos header. -const unsigned kGposHeaderSize = 10; +// The size of gpos header, version 1.0. +const unsigned kGposHeaderSize_1_0 = 10; +// The size of gpos header, version 1.1. +const unsigned kGposHeaderSize_1_1 = 14; // The maximum format number for anchor tables. const uint16_t kMaxAnchorFormat = 3; -// The maximum number of class value. -const uint16_t kMaxClassDefValue = 0xFFFF; // Lookup type parsers. bool ParseSingleAdjustment(const ots::Font *font, @@ -76,9 +76,23 @@ const ots::LookupSubtableParser kGposLookupSubtableParser = { // Shared Tables: ValueRecord, Anchor Table, and MarkArray +size_t CalcValueRecordSize(const uint16_t value_format) { + size_t size = 0; + for (unsigned i = 0; i < 8; ++i) { + if ((value_format >> i) & 0x1) { + size += 2; + } + } + + return size; +} + bool ParseValueRecord(const ots::Font *font, - ots::Buffer* subtable, const uint8_t *data, - const size_t length, const uint16_t value_format) { + ots::Buffer* subtable, + const uint16_t value_format) { + const uint8_t *data = subtable->buffer(); + const size_t length = subtable->length(); + // Check existence of adjustment fields. for (unsigned i = 0; i < 4; ++i) { if ((value_format >> i) & 0x1) { @@ -207,6 +221,12 @@ bool ParseSingleAdjustment(const ots::Font *font, const uint8_t *data, const size_t length) { ots::Buffer subtable(data, length); + ots::OpenTypeMAXP *maxp = static_cast<ots::OpenTypeMAXP*>( + font->GetTypedTable(OTS_TAG_MAXP)); + if (!maxp) { + return OTS_FAILURE_MSG("Required maxp table missing"); + } + uint16_t format = 0; uint16_t offset_coverage = 0; uint16_t value_format = 0; @@ -218,7 +238,7 @@ bool ParseSingleAdjustment(const ots::Font *font, const uint8_t *data, if (format == 1) { // Format 1 exactly one value record. - if (!ParseValueRecord(font, &subtable, data, length, value_format)) { + if (!ParseValueRecord(font, &subtable, value_format)) { return OTS_FAILURE_MSG("Failed to parse format 1 single adjustment table"); } } else if (format == 2) { @@ -227,7 +247,7 @@ bool ParseSingleAdjustment(const ots::Font *font, const uint8_t *data, return OTS_FAILURE_MSG("Failed to parse format 2 single adjustment table"); } for (unsigned i = 0; i < value_count; ++i) { - if (!ParseValueRecord(font, &subtable, data, length, value_format)) { + if (!ParseValueRecord(font, &subtable, value_format)) { return OTS_FAILURE_MSG("Failed to parse value record %d in format 2 single adjustment table", i); } } @@ -241,7 +261,7 @@ bool ParseSingleAdjustment(const ots::Font *font, const uint8_t *data, if (!ots::ParseCoverageTable(font, data + offset_coverage, length - offset_coverage, - font->maxp->num_glyphs)) { + maxp->num_glyphs)) { return OTS_FAILURE_MSG("Failed to parse coverage table in single adjustment table"); } @@ -268,10 +288,10 @@ bool ParsePairSetTable(const ots::Font *font, if (glyph_id >= num_glyphs) { return OTS_FAILURE_MSG("glyph id %d too high >= %d", glyph_id, num_glyphs); } - if (!ParseValueRecord(font, &subtable, data, length, value_format1)) { + if (!ParseValueRecord(font, &subtable, value_format1)) { return OTS_FAILURE_MSG("Failed to parse value record in format 1 pair set table"); } - if (!ParseValueRecord(font, &subtable, data, length, value_format2)) { + if (!ParseValueRecord(font, &subtable, value_format2)) { return OTS_FAILURE_MSG("Failed to parse value record in format 2 pair set table"); } } @@ -341,34 +361,44 @@ bool ParsePairPosFormat2(const ots::Font *font, return OTS_FAILURE_MSG("Failed to read pair pos format 2 data"); } + size_t value_record1_size = CalcValueRecordSize(value_format1); + size_t value_record2_size = CalcValueRecordSize(value_format2); + size_t value_records_size = size_t(class1_count) * size_t(class2_count) * + (value_record1_size + value_record2_size); + + // Check the validity of class definition offsets. + if (offset_class_def1 < subtable.offset() + value_records_size || + offset_class_def2 < subtable.offset() + value_records_size || + offset_class_def1 >= length || offset_class_def2 >= length) { + return OTS_FAILURE_MSG("Bad ParsePairPosFormat2 class definition offsets %d or %d", offset_class_def1, offset_class_def2); + } + // Check class 1 records. - for (unsigned i = 0; i < class1_count; ++i) { - // Check class 2 records. - for (unsigned j = 0; j < class2_count; ++j) { - if (value_format1 && !ParseValueRecord(font, &subtable, data, length, - value_format1)) { - return OTS_FAILURE_MSG("Failed to parse value record 1 %d and %d", j, i); - } - if (value_format2 && !ParseValueRecord(font, &subtable, data, length, - value_format2)) { - return OTS_FAILURE_MSG("Falied to parse value record 2 %d and %d", j, i); + if (value_record1_size || value_record2_size) { + for (unsigned i = 0; i < class1_count; ++i) { + // Check class 2 records. + for (unsigned j = 0; j < class2_count; ++j) { + if (value_format1 && value_record2_size && + !ParseValueRecord(font, &subtable, value_format1)) { + return OTS_FAILURE_MSG("Failed to parse value record 1 %d and %d", j, i); + } + if (value_format2 && value_record2_size && + !ParseValueRecord(font, &subtable, value_format2)) { + return OTS_FAILURE_MSG("Falied to parse value record 2 %d and %d", j, i); + } } } } // Check class definition tables. - if (offset_class_def1 < subtable.offset() || offset_class_def1 >= length || - offset_class_def2 < subtable.offset() || offset_class_def2 >= length) { - return OTS_FAILURE_MSG("Bad class definition table offsets %d or %d", offset_class_def1, offset_class_def2); - } if (!ots::ParseClassDefTable(font, data + offset_class_def1, length - offset_class_def1, - num_glyphs, kMaxClassDefValue)) { + num_glyphs, ots::kMaxClassDefValue)) { return OTS_FAILURE_MSG("Failed to parse class definition table 1"); } if (!ots::ParseClassDefTable(font, data + offset_class_def2, length - offset_class_def2, - num_glyphs, kMaxClassDefValue)) { + num_glyphs, ots::kMaxClassDefValue)) { return OTS_FAILURE_MSG("Failed to parse class definition table 2"); } @@ -381,6 +411,12 @@ bool ParsePairAdjustment(const ots::Font *font, const uint8_t *data, const size_t length) { ots::Buffer subtable(data, length); + ots::OpenTypeMAXP *maxp = static_cast<ots::OpenTypeMAXP*>( + font->GetTypedTable(OTS_TAG_MAXP)); + if (!maxp) { + return OTS_FAILURE_MSG("Required maxp table missing"); + } + uint16_t format = 0; uint16_t offset_coverage = 0; uint16_t value_format1 = 0; @@ -394,12 +430,12 @@ bool ParsePairAdjustment(const ots::Font *font, const uint8_t *data, if (format == 1) { if (!ParsePairPosFormat1(font, data, length, value_format1, value_format2, - font->maxp->num_glyphs)) { + maxp->num_glyphs)) { return OTS_FAILURE_MSG("Failed to parse pair pos format 1"); } } else if (format == 2) { if (!ParsePairPosFormat2(font, data, length, value_format1, value_format2, - font->maxp->num_glyphs)) { + maxp->num_glyphs)) { return OTS_FAILURE_MSG("Failed to parse pair format 2"); } } else { @@ -411,7 +447,7 @@ bool ParsePairAdjustment(const ots::Font *font, const uint8_t *data, } if (!ots::ParseCoverageTable(font, data + offset_coverage, length - offset_coverage, - font->maxp->num_glyphs)) { + maxp->num_glyphs)) { return OTS_FAILURE_MSG("Failed to parse coverage table"); } @@ -424,6 +460,12 @@ bool ParseCursiveAttachment(const ots::Font *font, const uint8_t *data, const size_t length) { ots::Buffer subtable(data, length); + ots::OpenTypeMAXP *maxp = static_cast<ots::OpenTypeMAXP*>( + font->GetTypedTable(OTS_TAG_MAXP)); + if (!maxp) { + return OTS_FAILURE_MSG("Required maxp table missing"); + } + uint16_t format = 0; uint16_t offset_coverage = 0; uint16_t entry_exit_count = 0; @@ -478,7 +520,7 @@ bool ParseCursiveAttachment(const ots::Font *font, const uint8_t *data, } if (!ots::ParseCoverageTable(font, data + offset_coverage, length - offset_coverage, - font->maxp->num_glyphs)) { + maxp->num_glyphs)) { return OTS_FAILURE_MSG("Failed to parse coverage table in cursive attachment"); } @@ -552,6 +594,12 @@ bool ParseMarkToAttachmentSubtables(const ots::Font *font, const GPOS_TYPE type) { ots::Buffer subtable(data, length); + ots::OpenTypeMAXP *maxp = static_cast<ots::OpenTypeMAXP*>( + font->GetTypedTable(OTS_TAG_MAXP)); + if (!maxp) { + return OTS_FAILURE_MSG("Required maxp table missing"); + } + uint16_t format = 0; uint16_t offset_coverage1 = 0; uint16_t offset_coverage2 = 0; @@ -580,7 +628,7 @@ bool ParseMarkToAttachmentSubtables(const ots::Font *font, } if (!ots::ParseCoverageTable(font, data + offset_coverage1, length - offset_coverage1, - font->maxp->num_glyphs)) { + maxp->num_glyphs)) { return OTS_FAILURE_MSG("Failed to parse converge 1 table"); } if (offset_coverage2 < header_end || offset_coverage2 >= length) { @@ -588,7 +636,7 @@ bool ParseMarkToAttachmentSubtables(const ots::Font *font, } if (!ots::ParseCoverageTable(font, data + offset_coverage2, length - offset_coverage2, - font->maxp->num_glyphs)) { + maxp->num_glyphs)) { return OTS_FAILURE_MSG("Failed to parse coverage table 2"); } @@ -652,17 +700,37 @@ bool ParseMarkToMarkAttachment(const ots::Font *font, // Contextual Positioning Subtables bool ParseContextPositioning(const ots::Font *font, const uint8_t *data, const size_t length) { - return ots::ParseContextSubtable(font, data, length, font->maxp->num_glyphs, - font->gpos->num_lookups); + ots::OpenTypeMAXP *maxp = static_cast<ots::OpenTypeMAXP*>( + font->GetTypedTable(OTS_TAG_MAXP)); + if (!maxp) { + return OTS_FAILURE_MSG("Required maxp table missing"); + } + ots::OpenTypeGPOS *gpos = static_cast<ots::OpenTypeGPOS*>( + font->GetTypedTable(OTS_TAG_GPOS)); + if (!gpos) { + return OTS_FAILURE_MSG("Internal error!"); + } + return ots::ParseContextSubtable(font, data, length, maxp->num_glyphs, + gpos->num_lookups); } // Lookup Type 8: // Chaining Contexual Positioning Subtable bool ParseChainedContextPositioning(const ots::Font *font, const uint8_t *data, const size_t length) { + ots::OpenTypeMAXP *maxp = static_cast<ots::OpenTypeMAXP*>( + font->GetTypedTable(OTS_TAG_MAXP)); + if (!maxp) { + return OTS_FAILURE_MSG("Required maxp table missing"); + } + ots::OpenTypeGPOS *gpos = static_cast<ots::OpenTypeGPOS*>( + font->GetTypedTable(OTS_TAG_GPOS)); + if (!gpos) { + return OTS_FAILURE_MSG("Internal error!"); + } return ots::ParseChainingContextSubtable(font, data, length, - font->maxp->num_glyphs, - font->gpos->num_lookups); + maxp->num_glyphs, + gpos->num_lookups); } // Lookup Type 9: @@ -677,139 +745,96 @@ bool ParseExtensionPositioning(const ots::Font *font, namespace ots { -// As far as I checked, following fonts contain invalid GPOS table and -// OTS will drop their GPOS table. -// -// # invalid delta format in device table -// samanata.ttf -// -// # bad size range in device table -// Sarai_07.ttf -// -// # bad offset to PairSetTable -// chandas1-2.ttf -// -// # bad offset to FeatureTable -// glrso12.ttf -// gllr12.ttf -// glbo12.ttf -// glb12.ttf -// glro12.ttf -// glbso12.ttf -// glrc12.ttf -// glrsc12.ttf -// glbs12.ttf -// glrs12.ttf -// glr12.ttf -// -// # ScriptRecords aren't sorted by tag -// Garogier_unhinted.otf -// -// # bad start coverage index in CoverageFormat2 -// AndBasR.ttf -// CharisSILB.ttf -// CharisSILBI.ttf -// CharisSILI.ttf -// CharisSILR.ttf -// DoulosSILR.ttf -// GenBasBI.ttf -// GenBasI.ttf -// GenBkBasI.ttf -// GenBkBasB.ttf -// GenBkBasR.ttf -// Padauk-Bold.ttf -// Padauk.ttf -// -// # Contour point indexes aren't sorted -// Arial Unicode.ttf - -bool ots_gpos_parse(Font *font, const uint8_t *data, size_t length) { - // Parsing GPOS table requires num_glyphs which is contained in maxp table. - if (!font->maxp) { - return OTS_FAILURE_MSG("missing maxp table needed in GPOS"); - } - +bool OpenTypeGPOS::Parse(const uint8_t *data, size_t length) { + Font *font = GetFont(); Buffer table(data, length); - OpenTypeGPOS *gpos = new OpenTypeGPOS; - font->gpos = gpos; - - uint32_t version = 0; + uint16_t version_major = 0, version_minor = 0; uint16_t offset_script_list = 0; uint16_t offset_feature_list = 0; uint16_t offset_lookup_list = 0; - if (!table.ReadU32(&version) || + uint32_t offset_feature_variations = 0; + if (!table.ReadU16(&version_major) || + !table.ReadU16(&version_minor) || !table.ReadU16(&offset_script_list) || !table.ReadU16(&offset_feature_list) || !table.ReadU16(&offset_lookup_list)) { - return OTS_FAILURE_MSG("Incomplete table"); + return Error("Incomplete table"); } - if (version != 0x00010000) { - return OTS_FAILURE_MSG("Bad version"); + if (version_major != 1 || version_minor > 1) { + return Error("Bad version"); + } + + if (version_minor > 0) { + if (!table.ReadU32(&offset_feature_variations)) { + return Error("Incomplete table"); + } } + const size_t header_size = + (version_minor == 0) ? kGposHeaderSize_1_0 : kGposHeaderSize_1_1; + if (offset_lookup_list) { - if (offset_lookup_list < kGposHeaderSize || offset_lookup_list >= length) { - return OTS_FAILURE_MSG("Bad lookup list offset in table header"); + if (offset_lookup_list < header_size || offset_lookup_list >= length) { + return Error("Bad lookup list offset in table header"); } if (!ParseLookupListTable(font, data + offset_lookup_list, length - offset_lookup_list, &kGposLookupSubtableParser, - &gpos->num_lookups)) { - return OTS_FAILURE_MSG("Failed to parse lookup list table"); + &this->num_lookups)) { + return Error("Failed to parse lookup list table"); } } uint16_t num_features = 0; if (offset_feature_list) { - if (offset_feature_list < kGposHeaderSize || offset_feature_list >= length) { - return OTS_FAILURE_MSG("Bad feature list offset in table header"); + if (offset_feature_list < header_size || offset_feature_list >= length) { + return Error("Bad feature list offset in table header"); } if (!ParseFeatureListTable(font, data + offset_feature_list, - length - offset_feature_list, gpos->num_lookups, + length - offset_feature_list, this->num_lookups, &num_features)) { - return OTS_FAILURE_MSG("Failed to parse feature list table"); + return Error("Failed to parse feature list table"); } } if (offset_script_list) { - if (offset_script_list < kGposHeaderSize || offset_script_list >= length) { - return OTS_FAILURE_MSG("Bad script list offset in table header"); + if (offset_script_list < header_size || offset_script_list >= length) { + return Error("Bad script list offset in table header"); } if (!ParseScriptListTable(font, data + offset_script_list, length - offset_script_list, num_features)) { - return OTS_FAILURE_MSG("Failed to parse script list table"); + return Error("Failed to parse script list table"); } } - gpos->data = data; - gpos->length = length; - return true; -} - -bool ots_gpos_should_serialise(Font *font) { - return font->gpos != NULL && font->gpos->data != NULL; -} + if (offset_feature_variations) { + if (offset_feature_variations < header_size || offset_feature_variations >= length) { + return Error("Bad feature variations offset in table header"); + } -bool ots_gpos_serialise(OTSStream *out, Font *font) { - if (!out->Write(font->gpos->data, font->gpos->length)) { - return OTS_FAILURE_MSG("Failed to write GPOS table"); + if (!ParseFeatureVariationsTable(font, data + offset_feature_variations, + length - offset_feature_variations, + this->num_lookups)) { + return Error("Failed to parse feature variations table"); + } } + this->m_data = data; + this->m_length = length; return true; } -void ots_gpos_reuse(Font *font, Font *other) { - font->gpos = other->gpos; - font->gpos_reused = true; -} +bool OpenTypeGPOS::Serialize(OTSStream *out) { + if (!out->Write(this->m_data, this->m_length)) { + return Error("Failed to write GPOS table"); + } -void ots_gpos_free(Font *font) { - delete font->gpos; + return true; } } // namespace ots diff --git a/gfx/ots/src/gpos.h b/gfx/ots/src/gpos.h index 3a4034f6f..423c8ae83 100644 --- a/gfx/ots/src/gpos.h +++ b/gfx/ots/src/gpos.h @@ -1,4 +1,4 @@ -// Copyright (c) 2011 The Chromium Authors. All rights reserved. +// Copyright (c) 2011-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -9,18 +9,24 @@ namespace ots { -struct OpenTypeGPOS { - OpenTypeGPOS() - : num_lookups(0), - data(NULL), - length(0) { +class OpenTypeGPOS : public Table { + public: + explicit OpenTypeGPOS(Font *font, uint32_t tag) + : Table(font, tag, tag), + num_lookups(0), + m_data(NULL), + m_length(0) { } + bool Parse(const uint8_t *data, size_t length); + bool Serialize(OTSStream *out); + // Number of lookups in GPOS table uint16_t num_lookups; - const uint8_t *data; - size_t length; + private: + const uint8_t *m_data; + size_t m_length; }; } // namespace ots diff --git a/gfx/ots/src/graphite.h b/gfx/ots/src/graphite.h new file mode 100644 index 000000000..452cb26a8 --- /dev/null +++ b/gfx/ots/src/graphite.h @@ -0,0 +1,96 @@ +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef OTS_GRAPHITE_H_ +#define OTS_GRAPHITE_H_ + +#include <vector> +#include <type_traits> + +namespace ots { + +template<typename ParentType> +class TablePart { + public: + TablePart(ParentType* parent) : parent(parent) { } + virtual ~TablePart() { } + virtual bool ParsePart(Buffer& table) = 0; + virtual bool SerializePart(OTSStream* out) const = 0; + protected: + ParentType* parent; +}; + +template<typename T> +bool SerializeParts(const std::vector<T>& vec, OTSStream* out) { + for (const T& part : vec) { + if (!part.SerializePart(out)) { + return false; + } + } + return true; +} + +template<typename T> +bool SerializeParts(const std::vector<std::vector<T>>& vec, OTSStream* out) { + for (const std::vector<T>& part : vec) { + if (!SerializeParts(part, out)) { + return false; + } + } + return true; +} + +inline bool SerializeParts(const std::vector<uint8_t>& vec, OTSStream* out) { + for (uint8_t part : vec) { + if (!out->WriteU8(part)) { + return false; + } + } + return true; +} + +inline bool SerializeParts(const std::vector<uint16_t>& vec, OTSStream* out) { + for (uint16_t part : vec) { + if (!out->WriteU16(part)) { + return false; + } + } + return true; +} + +inline bool SerializeParts(const std::vector<int16_t>& vec, OTSStream* out) { + for (int16_t part : vec) { + if (!out->WriteS16(part)) { + return false; + } + } + return true; +} + +inline bool SerializeParts(const std::vector<uint32_t>& vec, OTSStream* out) { + for (uint32_t part : vec) { + if (!out->WriteU32(part)) { + return false; + } + } + return true; +} + +inline bool SerializeParts(const std::vector<int32_t>& vec, OTSStream* out) { + for (int32_t part : vec) { + if (!out->WriteS32(part)) { + return false; + } + } + return true; +} + +template<typename T> +size_t datasize(std::vector<T> vec) { + return sizeof(T) * vec.size(); +} + +} // namespace ots + +#endif // OTS_GRAPHITE_H_ diff --git a/gfx/ots/src/gsub.cc b/gfx/ots/src/gsub.cc index 9baf2e88b..c90fb48f3 100644 --- a/gfx/ots/src/gsub.cc +++ b/gfx/ots/src/gsub.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2011 The Chromium Authors. All rights reserved. +// Copyright (c) 2011-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -17,8 +17,10 @@ namespace { -// The GSUB header size -const size_t kGsubHeaderSize = 4 + 3 * 2; +// The GSUB header size for table version 1.0 +const size_t kGsubHeaderSize_1_0 = 4 + 3 * 2; +// GSUB header size v1.1 +const size_t kGsubHeaderSize_1_1 = 4 + 3 * 2 + 4; enum GSUB_TYPE { GSUB_TYPE_SINGLE = 1, @@ -82,7 +84,12 @@ bool ParseSingleSubstitution(const ots::Font *font, return OTS_FAILURE_MSG("Failed to read single subst table header"); } - const uint16_t num_glyphs = font->maxp->num_glyphs; + ots::OpenTypeMAXP *maxp = static_cast<ots::OpenTypeMAXP*>( + font->GetTypedTable(OTS_TAG_MAXP)); + if (!maxp) { + return OTS_FAILURE_MSG("Required maxp table missing"); + } + const uint16_t num_glyphs = maxp->num_glyphs; if (format == 1) { // Parse SingleSubstFormat1 int16_t delta_glyph_id = 0; @@ -170,7 +177,12 @@ bool ParseMutipleSubstitution(const ots::Font *font, return OTS_FAILURE_MSG("Bad multiple subst table format %d", format); } - const uint16_t num_glyphs = font->maxp->num_glyphs; + ots::OpenTypeMAXP *maxp = static_cast<ots::OpenTypeMAXP*>( + font->GetTypedTable(OTS_TAG_MAXP)); + if (!maxp) { + return OTS_FAILURE_MSG("Required maxp table missing"); + } + const uint16_t num_glyphs = maxp->num_glyphs; const unsigned sequence_end = static_cast<unsigned>(6) + sequence_count * 2; if (sequence_end > std::numeric_limits<uint16_t>::max()) { @@ -245,7 +257,12 @@ bool ParseAlternateSubstitution(const ots::Font *font, return OTS_FAILURE_MSG("Bad alternate subst table format %d", format); } - const uint16_t num_glyphs = font->maxp->num_glyphs; + ots::OpenTypeMAXP *maxp = static_cast<ots::OpenTypeMAXP*>( + font->GetTypedTable(OTS_TAG_MAXP)); + if (!maxp) { + return OTS_FAILURE_MSG("Required maxp table missing"); + } + const uint16_t num_glyphs = maxp->num_glyphs; const unsigned alternate_set_end = static_cast<unsigned>(6) + alternate_set_count * 2; if (alternate_set_end > std::numeric_limits<uint16_t>::max()) { @@ -362,7 +379,12 @@ bool ParseLigatureSubstitution(const ots::Font *font, return OTS_FAILURE_MSG("Bad ligature substitution table format %d", format); } - const uint16_t num_glyphs = font->maxp->num_glyphs; + ots::OpenTypeMAXP *maxp = static_cast<ots::OpenTypeMAXP*>( + font->GetTypedTable(OTS_TAG_MAXP)); + if (!maxp) { + return OTS_FAILURE_MSG("Required maxp table missing"); + } + const uint16_t num_glyphs = maxp->num_glyphs; const unsigned ligature_set_end = static_cast<unsigned>(6) + lig_set_count * 2; if (ligature_set_end > std::numeric_limits<uint16_t>::max()) { @@ -398,8 +420,18 @@ bool ParseLigatureSubstitution(const ots::Font *font, // Contextual Substitution Subtable bool ParseContextSubstitution(const ots::Font *font, const uint8_t *data, const size_t length) { - return ots::ParseContextSubtable(font, data, length, font->maxp->num_glyphs, - font->gsub->num_lookups); + ots::OpenTypeMAXP *maxp = static_cast<ots::OpenTypeMAXP*>( + font->GetTypedTable(OTS_TAG_MAXP)); + if (!maxp) { + return OTS_FAILURE_MSG("Required maxp table missing"); + } + ots::OpenTypeGSUB *gsub = static_cast<ots::OpenTypeGSUB*>( + font->GetTypedTable(OTS_TAG_GSUB)); + if (!gsub) { + return OTS_FAILURE_MSG("Internal error!"); + } + return ots::ParseContextSubtable(font, data, length, maxp->num_glyphs, + gsub->num_lookups); } // Lookup Type 6: @@ -407,9 +439,19 @@ bool ParseContextSubstitution(const ots::Font *font, bool ParseChainingContextSubstitution(const ots::Font *font, const uint8_t *data, const size_t length) { + ots::OpenTypeMAXP *maxp = static_cast<ots::OpenTypeMAXP*>( + font->GetTypedTable(OTS_TAG_MAXP)); + if (!maxp) { + return OTS_FAILURE_MSG("Required maxp table missing"); + } + ots::OpenTypeGSUB *gsub = static_cast<ots::OpenTypeGSUB*>( + font->GetTypedTable(OTS_TAG_GSUB)); + if (!gsub) { + return OTS_FAILURE_MSG("Internal error!"); + } return ots::ParseChainingContextSubtable(font, data, length, - font->maxp->num_glyphs, - font->gsub->num_lookups); + maxp->num_glyphs, + gsub->num_lookups); } // Lookup Type 7: @@ -434,7 +476,12 @@ bool ParseReverseChainingContextSingleSubstitution( return OTS_FAILURE_MSG("Failed to read reverse chaining header"); } - const uint16_t num_glyphs = font->maxp->num_glyphs; + ots::OpenTypeMAXP *maxp = static_cast<ots::OpenTypeMAXP*>( + font->GetTypedTable(OTS_TAG_MAXP)); + if (!maxp) { + return OTS_FAILURE_MSG("Required maxp table missing"); + } + const uint16_t num_glyphs = maxp->num_glyphs; uint16_t backtrack_glyph_count = 0; if (!subtable.ReadU16(&backtrack_glyph_count)) { @@ -530,143 +577,97 @@ bool ParseReverseChainingContextSingleSubstitution( namespace ots { -// As far as I checked, following fonts contain invalid values in GSUB table. -// OTS will drop their GSUB table. -// -// # too large substitute (value is 0xFFFF) -// kaiu.ttf -// mingliub2.ttf -// mingliub1.ttf -// mingliub0.ttf -// GraublauWeb.otf -// GraublauWebBold.otf -// -// # too large alternate (value is 0xFFFF) -// ManchuFont.ttf -// -// # bad offset to lang sys table (NULL offset) -// DejaVuMonoSansBold.ttf -// DejaVuMonoSansBoldOblique.ttf -// DejaVuMonoSansOblique.ttf -// DejaVuSansMono-BoldOblique.ttf -// DejaVuSansMono-Oblique.ttf -// DejaVuSansMono-Bold.ttf -// -// # bad start coverage index -// GenBasBI.ttf -// GenBasI.ttf -// AndBasR.ttf -// GenBkBasI.ttf -// CharisSILR.ttf -// CharisSILBI.ttf -// CharisSILI.ttf -// CharisSILB.ttf -// DoulosSILR.ttf -// CharisSILBI.ttf -// GenBkBasB.ttf -// GenBkBasR.ttf -// GenBkBasBI.ttf -// GenBasB.ttf -// GenBasR.ttf -// -// # glyph range is overlapping -// KacstTitleL.ttf -// KacstDecorative.ttf -// KacstTitle.ttf -// KacstArt.ttf -// KacstPoster.ttf -// KacstQurn.ttf -// KacstDigital.ttf -// KacstBook.ttf -// KacstFarsi.ttf - -bool ots_gsub_parse(Font *font, const uint8_t *data, size_t length) { - // Parsing gsub table requires |font->maxp->num_glyphs| - if (!font->maxp) { - return OTS_FAILURE_MSG("Missing maxp table in font, needed by GSUB"); - } - +bool OpenTypeGSUB::Parse(const uint8_t *data, size_t length) { + // Parsing gsub table requires |maxp->num_glyphs| + Font *font = GetFont(); Buffer table(data, length); - OpenTypeGSUB *gsub = new OpenTypeGSUB; - font->gsub = gsub; - - uint32_t version = 0; + uint16_t version_major = 0, version_minor = 0; uint16_t offset_script_list = 0; uint16_t offset_feature_list = 0; uint16_t offset_lookup_list = 0; - if (!table.ReadU32(&version) || + uint32_t offset_feature_variations = 0; + if (!table.ReadU16(&version_major) || + !table.ReadU16(&version_minor) || !table.ReadU16(&offset_script_list) || !table.ReadU16(&offset_feature_list) || !table.ReadU16(&offset_lookup_list)) { - return OTS_FAILURE_MSG("Incomplete table"); + return Error("Incomplete table"); } - if (version != 0x00010000) { - return OTS_FAILURE_MSG("Bad version"); + if (version_major != 1 || version_minor > 1) { + return Error("Bad version"); } + if (version_minor > 0) { + if (!table.ReadU32(&offset_feature_variations)) { + return Error("Incomplete table"); + } + } + + const size_t header_size = + (version_minor == 0) ? kGsubHeaderSize_1_0 : kGsubHeaderSize_1_1; + if (offset_lookup_list) { - if (offset_lookup_list < kGsubHeaderSize || offset_lookup_list >= length) { - return OTS_FAILURE_MSG("Bad lookup list offset in table header"); + if (offset_lookup_list < header_size || offset_lookup_list >= length) { + return Error("Bad lookup list offset in table header"); } if (!ParseLookupListTable(font, data + offset_lookup_list, length - offset_lookup_list, &kGsubLookupSubtableParser, - &gsub->num_lookups)) { - return OTS_FAILURE_MSG("Failed to parse lookup list table"); + &this->num_lookups)) { + return Error("Failed to parse lookup list table"); } } uint16_t num_features = 0; if (offset_feature_list) { - if (offset_feature_list < kGsubHeaderSize || offset_feature_list >= length) { - return OTS_FAILURE_MSG("Bad feature list offset in table header"); + if (offset_feature_list < header_size || offset_feature_list >= length) { + return Error("Bad feature list offset in table header"); } if (!ParseFeatureListTable(font, data + offset_feature_list, - length - offset_feature_list, gsub->num_lookups, + length - offset_feature_list, this->num_lookups, &num_features)) { - return OTS_FAILURE_MSG("Failed to parse feature list table"); + return Error("Failed to parse feature list table"); } } if (offset_script_list) { - if (offset_script_list < kGsubHeaderSize || offset_script_list >= length) { - return OTS_FAILURE_MSG("Bad script list offset in table header"); + if (offset_script_list < header_size || offset_script_list >= length) { + return Error("Bad script list offset in table header"); } if (!ParseScriptListTable(font, data + offset_script_list, length - offset_script_list, num_features)) { - return OTS_FAILURE_MSG("Failed to parse script list table"); + return Error("Failed to parse script list table"); } } - gsub->data = data; - gsub->length = length; - return true; -} - -bool ots_gsub_should_serialise(Font *font) { - return font->gsub != NULL && font->gsub->data != NULL; -} + if (offset_feature_variations) { + if (offset_feature_variations < header_size || offset_feature_variations >= length) { + return Error("Bad feature variations offset in table header"); + } -bool ots_gsub_serialise(OTSStream *out, Font *font) { - if (!out->Write(font->gsub->data, font->gsub->length)) { - return OTS_FAILURE_MSG("Failed to write GSUB table"); + if (!ParseFeatureVariationsTable(font, data + offset_feature_variations, + length - offset_feature_variations, + this->num_lookups)) { + return Error("Failed to parse feature variations table"); + } } + this->m_data = data; + this->m_length = length; return true; } -void ots_gsub_reuse(Font *font, Font *other) { - font->gsub = other->gsub; - font->gsub_reused = true; -} +bool OpenTypeGSUB::Serialize(OTSStream *out) { + if (!out->Write(this->m_data, this->m_length)) { + return Error("Failed to write GSUB table"); + } -void ots_gsub_free(Font *font) { - delete font->gsub; + return true; } } // namespace ots diff --git a/gfx/ots/src/gsub.h b/gfx/ots/src/gsub.h index f6f8cd3b1..76c990465 100644 --- a/gfx/ots/src/gsub.h +++ b/gfx/ots/src/gsub.h @@ -1,4 +1,4 @@ -// Copyright (c) 2011 The Chromium Authors. All rights reserved. +// Copyright (c) 2011-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -9,18 +9,24 @@ namespace ots { -struct OpenTypeGSUB { - OpenTypeGSUB() - : num_lookups(0), - data(NULL), - length(0) { +class OpenTypeGSUB : public Table { + public: + explicit OpenTypeGSUB(Font *font, uint32_t tag) + : Table(font, tag, tag), + num_lookups(0), + m_data(NULL), + m_length(0) { } + bool Parse(const uint8_t *data, size_t length); + bool Serialize(OTSStream *out); + // Number of lookups in GPSUB table uint16_t num_lookups; - const uint8_t *data; - size_t length; + //private: + const uint8_t *m_data; + size_t m_length; }; } // namespace ots diff --git a/gfx/ots/src/gvar.cc b/gfx/ots/src/gvar.cc new file mode 100644 index 000000000..324a0fc83 --- /dev/null +++ b/gfx/ots/src/gvar.cc @@ -0,0 +1,158 @@ +// Copyright (c) 2018 The OTS 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 "gvar.h" + +#include "fvar.h" +#include "maxp.h" +#include "variations.h" + +#define TABLE_NAME "gvar" + +namespace ots { + +// ----------------------------------------------------------------------------- +// OpenTypeGVAR +// ----------------------------------------------------------------------------- + +static bool ParseSharedTuples(const Font* font, const uint8_t* data, size_t length, + size_t sharedTupleCount, size_t axisCount) { + Buffer subtable(data, length); + for (unsigned i = 0; i < sharedTupleCount; i++) { + for (unsigned j = 0; j < axisCount; j++) { + int16_t coordinate; + if (!subtable.ReadS16(&coordinate)) { + return OTS_FAILURE_MSG("Failed to read shared tuple coordinate"); + } + } + } + return true; +} + +static bool ParseGlyphVariationDataArray(const Font* font, const uint8_t* data, size_t length, + uint16_t flags, size_t glyphCount, size_t axisCount, + size_t sharedTupleCount, + const uint8_t* glyphVariationData, + size_t glyphVariationDataLength) { + Buffer subtable(data, length); + + bool glyphVariationDataOffsetsAreLong = (flags & 0x0001u); + uint32_t prevOffset = 0; + for (size_t i = 0; i < glyphCount + 1; i++) { + uint32_t offset; + if (glyphVariationDataOffsetsAreLong) { + if (!subtable.ReadU32(&offset)) { + return OTS_FAILURE_MSG("Failed to read GlyphVariationData offset"); + } + } else { + uint16_t halfOffset; + if (!subtable.ReadU16(&halfOffset)) { + return OTS_FAILURE_MSG("Failed to read GlyphVariationData offset"); + } + offset = halfOffset * 2; + } + + if (i > 0 && offset > prevOffset) { + if (prevOffset > glyphVariationDataLength) { + return OTS_FAILURE_MSG("Invalid GlyphVariationData offset"); + } + if (!ParseVariationData(font, glyphVariationData + prevOffset, + glyphVariationDataLength - prevOffset, + axisCount, sharedTupleCount)) { + return OTS_FAILURE_MSG("Failed to parse GlyphVariationData"); + } + } + prevOffset = offset; + } + + return true; +} + +bool OpenTypeGVAR::Parse(const uint8_t* data, size_t length) { + Buffer table(data, length); + + uint16_t majorVersion; + uint16_t minorVersion; + uint16_t axisCount; + uint16_t sharedTupleCount; + uint32_t sharedTuplesOffset; + uint16_t glyphCount; + uint16_t flags; + uint32_t glyphVariationDataArrayOffset; + + if (!table.ReadU16(&majorVersion) || + !table.ReadU16(&minorVersion) || + !table.ReadU16(&axisCount) || + !table.ReadU16(&sharedTupleCount) || + !table.ReadU32(&sharedTuplesOffset) || + !table.ReadU16(&glyphCount) || + !table.ReadU16(&flags) || + !table.ReadU32(&glyphVariationDataArrayOffset)) { + return DropVariations("Failed to read table header"); + } + if (majorVersion != 1) { + return DropVariations("Unknown table version"); + } + + // check axisCount == fvar->axisCount + OpenTypeFVAR* fvar = static_cast<OpenTypeFVAR*>( + GetFont()->GetTypedTable(OTS_TAG_FVAR)); + if (!fvar) { + return DropVariations("Required fvar table is missing"); + } + if (axisCount != fvar->AxisCount()) { + return DropVariations("Axis count mismatch"); + } + + // check glyphCount == maxp->num_glyphs + OpenTypeMAXP* maxp = static_cast<OpenTypeMAXP*>( + GetFont()->GetTypedTable(OTS_TAG_MAXP)); + if (!maxp) { + return DropVariations("Required maxp table is missing"); + } + if (glyphCount != maxp->num_glyphs) { + return DropVariations("Glyph count mismatch"); + } + + if (sharedTupleCount > 0) { + if (sharedTuplesOffset < table.offset() || sharedTuplesOffset > length) { + return DropVariations("Invalid sharedTuplesOffset"); + } + if (!ParseSharedTuples(GetFont(), + data + sharedTuplesOffset, length - sharedTuplesOffset, + sharedTupleCount, axisCount)) { + return DropVariations("Failed to parse shared tuples"); + } + } + + if (glyphVariationDataArrayOffset) { + if (glyphVariationDataArrayOffset > length) { + return DropVariations("Invalid glyphVariationDataArrayOffset"); + } + if (!ParseGlyphVariationDataArray(GetFont(), + data + table.offset(), length - table.offset(), + flags, glyphCount, axisCount, sharedTupleCount, + data + glyphVariationDataArrayOffset, + length - glyphVariationDataArrayOffset)) { + return DropVariations("Failed to read glyph variation data array"); + } + } + + this->m_data = data; + this->m_length = length; + + return true; +} + +bool OpenTypeGVAR::Serialize(OTSStream* out) { + if (!out->Write(this->m_data, this->m_length)) { + return Error("Failed to write gvar table"); + } + + return true; +} + +} // namespace ots + +#undef TABLE_NAME diff --git a/gfx/ots/src/gvar.h b/gfx/ots/src/gvar.h new file mode 100644 index 000000000..8a90c57a3 --- /dev/null +++ b/gfx/ots/src/gvar.h @@ -0,0 +1,31 @@ +// Copyright (c) 2018 The OTS Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef OTS_GVAR_H_ +#define OTS_GVAR_H_ + +#include "ots.h" + +namespace ots { + +// ----------------------------------------------------------------------------- +// OpenTypeGVAR Interface +// ----------------------------------------------------------------------------- + +class OpenTypeGVAR : public Table { + public: + explicit OpenTypeGVAR(Font* font, uint32_t tag) + : Table(font, tag, tag) { } + + bool Parse(const uint8_t* data, size_t length); + bool Serialize(OTSStream* out); + + private: + const uint8_t *m_data; + size_t m_length; +}; + +} // namespace ots + +#endif // OTS_GVAR_H_ diff --git a/gfx/ots/src/hdmx.cc b/gfx/ots/src/hdmx.cc index f57b71f59..42ac9de8d 100644 --- a/gfx/ots/src/hdmx.cc +++ b/gfx/ots/src/hdmx.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -9,139 +9,112 @@ // hdmx - Horizontal Device Metrics // http://www.microsoft.com/typography/otspec/hdmx.htm -#define TABLE_NAME "hdmx" - -#define DROP_THIS_TABLE(...) \ - do { \ - OTS_FAILURE_MSG_(font->file, TABLE_NAME ": " __VA_ARGS__); \ - OTS_FAILURE_MSG("Table discarded"); \ - delete font->hdmx; \ - font->hdmx = 0; \ - } while (0) - namespace ots { -bool ots_hdmx_parse(Font *font, const uint8_t *data, size_t length) { +bool OpenTypeHDMX::Parse(const uint8_t *data, size_t length) { Buffer table(data, length); - font->hdmx = new OpenTypeHDMX; - OpenTypeHDMX * const hdmx = font->hdmx; - if (!font->head || !font->maxp) { - return OTS_FAILURE_MSG("Missing maxp or head tables in font, needed by hdmx"); + OpenTypeMAXP *maxp = static_cast<OpenTypeMAXP*>( + GetFont()->GetTypedTable(OTS_TAG_MAXP)); + OpenTypeHEAD *head = static_cast<OpenTypeHEAD*>( + GetFont()->GetTypedTable(OTS_TAG_HEAD)); + if (!head || !maxp) { + return Error("Missing maxp or head tables in font, needed by hdmx"); } - if ((font->head->flags & 0x14) == 0) { - // http://www.microsoft.com/typography/otspec/recom.htm - DROP_THIS_TABLE("the table should not be present when bit 2 and 4 of the " - "head->flags are not set"); - return true; + if ((head->flags & 0x14) == 0) { + // http://www.microsoft.com/typography/otspec/recom.htm#hdmx + return Drop("the table should not be present when bit 2 and 4 of the " + "head->flags are not set"); } int16_t num_recs; - if (!table.ReadU16(&hdmx->version) || + if (!table.ReadU16(&this->version) || !table.ReadS16(&num_recs) || - !table.ReadS32(&hdmx->size_device_record)) { - return OTS_FAILURE_MSG("Failed to read hdmx header"); + !table.ReadS32(&this->size_device_record)) { + return Error("Failed to read table header"); } - if (hdmx->version != 0) { - DROP_THIS_TABLE("bad version: %u", hdmx->version); - return true; + if (this->version != 0) { + return Drop("Unsupported version: %u", this->version); } if (num_recs <= 0) { - DROP_THIS_TABLE("bad num_recs: %d", num_recs); - return true; + return Drop("Bad numRecords: %d", num_recs); } - const int32_t actual_size_device_record = font->maxp->num_glyphs + 2; - if (hdmx->size_device_record < actual_size_device_record) { - DROP_THIS_TABLE("bad hdmx->size_device_record: %d", hdmx->size_device_record); - return true; + const int32_t actual_size_device_record = maxp->num_glyphs + 2; + if (this->size_device_record < actual_size_device_record) { + return Drop("Bad sizeDeviceRecord: %d", this->size_device_record); } - hdmx->pad_len = hdmx->size_device_record - actual_size_device_record; - if (hdmx->pad_len > 3) { - return OTS_FAILURE_MSG("Bad padding %d", hdmx->pad_len); + this->pad_len = this->size_device_record - actual_size_device_record; + if (this->pad_len > 3) { + return Error("Bad DeviceRecord padding %d", this->pad_len); } uint8_t last_pixel_size = 0; - hdmx->records.reserve(num_recs); + this->records.reserve(num_recs); for (int i = 0; i < num_recs; ++i) { OpenTypeHDMXDeviceRecord rec; if (!table.ReadU8(&rec.pixel_size) || !table.ReadU8(&rec.max_width)) { - return OTS_FAILURE_MSG("Failed to read hdmx record %d", i); + return Error("Failed to read DeviceRecord %d", i); } if ((i != 0) && (rec.pixel_size <= last_pixel_size)) { - DROP_THIS_TABLE("records are not sorted"); - return true; + return Drop("DeviceRecord's are not sorted"); } last_pixel_size = rec.pixel_size; - rec.widths.reserve(font->maxp->num_glyphs); - for (unsigned j = 0; j < font->maxp->num_glyphs; ++j) { + rec.widths.reserve(maxp->num_glyphs); + for (unsigned j = 0; j < maxp->num_glyphs; ++j) { uint8_t width; if (!table.ReadU8(&width)) { - return OTS_FAILURE_MSG("Failed to read glyph width %d in record %d", j, i); + return Error("Failed to read glyph width %d in DeviceRecord %d", j, i); } rec.widths.push_back(width); } - if ((hdmx->pad_len > 0) && - !table.Skip(hdmx->pad_len)) { - return OTS_FAILURE_MSG("Failed to skip padding %d", hdmx->pad_len); + if ((this->pad_len > 0) && + !table.Skip(this->pad_len)) { + return Error("DeviceRecord %d should be padded by %d", i, this->pad_len); } - hdmx->records.push_back(rec); + this->records.push_back(rec); } return true; } -bool ots_hdmx_should_serialise(Font *font) { - if (!font->hdmx) return false; - if (!font->glyf) return false; // this table is not for CFF fonts. - return true; +bool OpenTypeHDMX::ShouldSerialize() { + return Table::ShouldSerialize() && + // this table is not for CFF fonts. + GetFont()->GetTable(OTS_TAG_GLYF) != NULL; } -bool ots_hdmx_serialise(OTSStream *out, Font *font) { - OpenTypeHDMX * const hdmx = font->hdmx; - - const int16_t num_recs = static_cast<int16_t>(hdmx->records.size()); - if (hdmx->records.size() > +bool OpenTypeHDMX::Serialize(OTSStream *out) { + const int16_t num_recs = static_cast<int16_t>(this->records.size()); + if (this->records.size() > static_cast<size_t>(std::numeric_limits<int16_t>::max()) || - !out->WriteU16(hdmx->version) || + !out->WriteU16(this->version) || !out->WriteS16(num_recs) || - !out->WriteS32(hdmx->size_device_record)) { - return OTS_FAILURE_MSG("Failed to write hdmx header"); + !out->WriteS32(this->size_device_record)) { + return Error("Failed to write table header"); } for (int16_t i = 0; i < num_recs; ++i) { - const OpenTypeHDMXDeviceRecord& rec = hdmx->records[i]; + const OpenTypeHDMXDeviceRecord& rec = this->records[i]; if (!out->Write(&rec.pixel_size, 1) || !out->Write(&rec.max_width, 1) || !out->Write(&rec.widths[0], rec.widths.size())) { - return OTS_FAILURE_MSG("Failed to write hdmx record %d", i); + return Error("Failed to write DeviceRecord %d", i); } - if ((hdmx->pad_len > 0) && - !out->Write((const uint8_t *)"\x00\x00\x00", hdmx->pad_len)) { - return OTS_FAILURE_MSG("Failed to write hdmx padding of length %d", hdmx->pad_len); + if ((this->pad_len > 0) && + !out->Write((const uint8_t *)"\x00\x00\x00", this->pad_len)) { + return Error("Failed to write padding of length %d", this->pad_len); } } return true; } -void ots_hdmx_reuse(Font *font, Font *other) { - font->hdmx = other->hdmx; - font->hdmx_reused = true; -} - -void ots_hdmx_free(Font *font) { - delete font->hdmx; -} - } // namespace ots - -#undef TABLE_NAME -#undef DROP_THIS_TABLE diff --git a/gfx/ots/src/hdmx.h b/gfx/ots/src/hdmx.h index 9ec212437..5d323dd7e 100644 --- a/gfx/ots/src/hdmx.h +++ b/gfx/ots/src/hdmx.h @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -17,7 +17,16 @@ struct OpenTypeHDMXDeviceRecord { std::vector<uint8_t> widths; }; -struct OpenTypeHDMX { +class OpenTypeHDMX : public Table { + public: + explicit OpenTypeHDMX(Font *font, uint32_t tag) + : Table(font, tag, tag) { } + + bool Parse(const uint8_t *data, size_t length); + bool Serialize(OTSStream *out); + bool ShouldSerialize(); + + private: uint16_t version; int32_t size_device_record; int32_t pad_len; diff --git a/gfx/ots/src/head.cc b/gfx/ots/src/head.cc index 229ea71f9..6088504c8 100644 --- a/gfx/ots/src/head.cc +++ b/gfx/ots/src/head.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -9,151 +9,124 @@ // head - Font Header // http://www.microsoft.com/typography/otspec/head.htm -#define TABLE_NAME "head" - namespace ots { -bool ots_head_parse(Font* font, const uint8_t *data, size_t length) { +bool OpenTypeHEAD::Parse(const uint8_t *data, size_t length) { Buffer table(data, length); - OpenTypeHEAD *head = new OpenTypeHEAD; - font->head = head; uint32_t version = 0; if (!table.ReadU32(&version) || - !table.ReadU32(&head->revision)) { - return OTS_FAILURE_MSG("Failed to read head header"); + !table.ReadU32(&this->revision)) { + return Error("Failed to read table header"); } if (version >> 16 != 1) { - return OTS_FAILURE_MSG("Bad head table version of %d", version); + return Error("Unsupported majorVersion: %d", version >> 16); } // Skip the checksum adjustment if (!table.Skip(4)) { - return OTS_FAILURE_MSG("Failed to read checksum"); + return Error("Failed to read checksum"); } uint32_t magic; if (!table.ReadU32(&magic) || magic != 0x5F0F3CF5) { - return OTS_FAILURE_MSG("Failed to read font magic number"); + return Error("Failed to read or incorrect magicNumber"); } - if (!table.ReadU16(&head->flags)) { - return OTS_FAILURE_MSG("Failed to read head flags"); + if (!table.ReadU16(&this->flags)) { + return Error("Failed to read flags"); } // We allow bits 0..4, 11..13 - head->flags &= 0x381f; - - if (!table.ReadU16(&head->ppem)) { - return OTS_FAILURE_MSG("Failed to read pixels per em"); - } + this->flags &= 0x381f; - // ppem must be in range - if (head->ppem < 16 || - head->ppem > 16384) { - return OTS_FAILURE_MSG("Bad ppm of %d", head->ppem); + if (!table.ReadU16(&this->upem)) { + return Error("Failed to read unitsPerEm"); } - // ppem must be a power of two -#if 0 - // We don't call ots_failure() for now since lots of TrueType fonts are - // not following this rule. Putting OTS_WARNING here is too noisy. - if ((head->ppem - 1) & head->ppem) { - return OTS_FAILURE_MSG("ppm not a power of two: %d", head->ppem); + // upem must be in range + if (this->upem < 16 || + this->upem > 16384) { + return Error("unitsPerEm on in the range [16, 16384]: %d", this->upem); } -#endif - if (!table.ReadR64(&head->created) || - !table.ReadR64(&head->modified)) { - return OTS_FAILURE_MSG("Can't read font dates"); + if (!table.ReadR64(&this->created) || + !table.ReadR64(&this->modified)) { + return Error("Can't read font dates"); } - if (!table.ReadS16(&head->xmin) || - !table.ReadS16(&head->ymin) || - !table.ReadS16(&head->xmax) || - !table.ReadS16(&head->ymax)) { - return OTS_FAILURE_MSG("Failed to read font bounding box"); + if (!table.ReadS16(&this->xmin) || + !table.ReadS16(&this->ymin) || + !table.ReadS16(&this->xmax) || + !table.ReadS16(&this->ymax)) { + return Error("Failed to read font bounding box"); } - if (head->xmin > head->xmax) { - return OTS_FAILURE_MSG("Bad x dimension in the font bounding box (%d, %d)", head->xmin, head->xmax); + if (this->xmin > this->xmax) { + return Error("Bad x dimension in the font bounding box (%d, %d)", + this->xmin, this->xmax); } - if (head->ymin > head->ymax) { - return OTS_FAILURE_MSG("Bad y dimension in the font bounding box (%d, %d)", head->ymin, head->ymax); + if (this->ymin > this->ymax) { + return Error("Bad y dimension in the font bounding box (%d, %d)", + this->ymin, this->ymax); } - if (!table.ReadU16(&head->mac_style)) { - return OTS_FAILURE_MSG("Failed to read font style"); + if (!table.ReadU16(&this->mac_style)) { + return Error("Failed to read macStyle"); } // We allow bits 0..6 - head->mac_style &= 0x7f; + this->mac_style &= 0x7f; - if (!table.ReadU16(&head->min_ppem)) { - return OTS_FAILURE_MSG("Failed to read font minimum ppm"); + if (!table.ReadU16(&this->min_ppem)) { + return Error("Failed to read lowestRecPPEM"); } // We don't care about the font direction hint if (!table.Skip(2)) { - return OTS_FAILURE_MSG("Failed to skip font direction hint"); + return Error("Failed to read fontDirectionHint"); } - if (!table.ReadS16(&head->index_to_loc_format)) { - return OTS_FAILURE_MSG("Failed to read index to loc format"); + if (!table.ReadS16(&this->index_to_loc_format)) { + return Error("Failed to read indexToLocFormat"); } - if (head->index_to_loc_format < 0 || - head->index_to_loc_format > 1) { - return OTS_FAILURE_MSG("Bad index to loc format %d", head->index_to_loc_format); + if (this->index_to_loc_format < 0 || + this->index_to_loc_format > 1) { + return Error("Bad indexToLocFormat %d", this->index_to_loc_format); } int16_t glyph_data_format; if (!table.ReadS16(&glyph_data_format) || glyph_data_format) { - return OTS_FAILURE_MSG("Failed to read glyph data format"); + return Error("Failed to read or bad glyphDataFormat"); } return true; } -bool ots_head_should_serialise(Font *font) { - return font->head != NULL; -} - -bool ots_head_serialise(OTSStream *out, Font *font) { - const OpenTypeHEAD *head = font->head; +bool OpenTypeHEAD::Serialize(OTSStream *out) { if (!out->WriteU32(0x00010000) || - !out->WriteU32(head->revision) || + !out->WriteU32(this->revision) || !out->WriteU32(0) || // check sum not filled in yet !out->WriteU32(0x5F0F3CF5) || - !out->WriteU16(head->flags) || - !out->WriteU16(head->ppem) || - !out->WriteR64(head->created) || - !out->WriteR64(head->modified) || - !out->WriteS16(head->xmin) || - !out->WriteS16(head->ymin) || - !out->WriteS16(head->xmax) || - !out->WriteS16(head->ymax) || - !out->WriteU16(head->mac_style) || - !out->WriteU16(head->min_ppem) || + !out->WriteU16(this->flags) || + !out->WriteU16(this->upem) || + !out->WriteR64(this->created) || + !out->WriteR64(this->modified) || + !out->WriteS16(this->xmin) || + !out->WriteS16(this->ymin) || + !out->WriteS16(this->xmax) || + !out->WriteS16(this->ymax) || + !out->WriteU16(this->mac_style) || + !out->WriteU16(this->min_ppem) || !out->WriteS16(2) || - !out->WriteS16(head->index_to_loc_format) || + !out->WriteS16(this->index_to_loc_format) || !out->WriteS16(0)) { - return OTS_FAILURE_MSG("Failed to write head table"); + return Error("Failed to write table"); } return true; } -void ots_head_reuse(Font *font, Font *other) { - font->head = other->head; - font->head_reused = true; -} - -void ots_head_free(Font *font) { - delete font->head; -} - } // namespace - -#undef TABLE_NAME diff --git a/gfx/ots/src/head.h b/gfx/ots/src/head.h index 5967c4b89..a040fcf24 100644 --- a/gfx/ots/src/head.h +++ b/gfx/ots/src/head.h @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -9,10 +9,17 @@ namespace ots { -struct OpenTypeHEAD { +class OpenTypeHEAD : public Table { + public: + explicit OpenTypeHEAD(Font *font, uint32_t tag) + : Table(font, tag, tag) { } + + bool Parse(const uint8_t *data, size_t length); + bool Serialize(OTSStream *out); + uint32_t revision; uint16_t flags; - uint16_t ppem; + uint16_t upem; uint64_t created; uint64_t modified; diff --git a/gfx/ots/src/hhea.cc b/gfx/ots/src/hhea.cc index 624287280..d024aaac4 100644 --- a/gfx/ots/src/hhea.cc +++ b/gfx/ots/src/hhea.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -10,49 +10,23 @@ // hhea - Horizontal Header // http://www.microsoft.com/typography/otspec/hhea.htm -#define TABLE_NAME "hhea" - namespace ots { -bool ots_hhea_parse(Font *font, const uint8_t *data, size_t length) { +bool OpenTypeHHEA::Parse(const uint8_t *data, size_t length) { Buffer table(data, length); - OpenTypeHHEA *hhea = new OpenTypeHHEA; - font->hhea = hhea; - if (!table.ReadU32(&hhea->header.version)) { - return OTS_FAILURE_MSG("Failed to read hhea version"); - } - if (hhea->header.version >> 16 != 1) { - return OTS_FAILURE_MSG("Bad hhea version of %d", hhea->header.version); + if (!table.ReadU32(&this->version)) { + return Error("Failed to read table version"); } - - if (!ParseMetricsHeader(font, &table, &hhea->header)) { - return OTS_FAILURE_MSG("Failed to parse horizontal metrics"); + if (this->version >> 16 != 1) { + return Error("Unsupported majorVersion: %d", this->version >> 16); } - return true; + return OpenTypeMetricsHeader::Parse(data, length); } -bool ots_hhea_should_serialise(Font *font) { - return font->hhea != NULL; -} - -bool ots_hhea_serialise(OTSStream *out, Font *font) { - if (!SerialiseMetricsHeader(font, out, &font->hhea->header)) { - return OTS_FAILURE_MSG("Failed to serialise horizontal metrics"); - } - return true; -} - -void ots_hhea_reuse(Font *font, Font *other) { - font->hhea = other->hhea; - font->hhea_reused = true; -} - -void ots_hhea_free(Font *font) { - delete font->hhea; +bool OpenTypeHHEA::Serialize(OTSStream *out) { + return OpenTypeMetricsHeader::Serialize(out); } } // namespace ots - -#undef TABLE_NAME diff --git a/gfx/ots/src/hhea.h b/gfx/ots/src/hhea.h index bdea9aa0d..0405bd9d1 100644 --- a/gfx/ots/src/hhea.h +++ b/gfx/ots/src/hhea.h @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -10,8 +10,13 @@ namespace ots { -struct OpenTypeHHEA { - OpenTypeMetricsHeader header; +class OpenTypeHHEA : public OpenTypeMetricsHeader { + public: + explicit OpenTypeHHEA(Font *font, uint32_t tag) + : OpenTypeMetricsHeader(font, tag, tag) { } + + bool Parse(const uint8_t *data, size_t length); + bool Serialize(OTSStream *out); }; } // namespace ots diff --git a/gfx/ots/src/hmtx.cc b/gfx/ots/src/hmtx.cc index 667d1fe6f..2ef7771fd 100644 --- a/gfx/ots/src/hmtx.cc +++ b/gfx/ots/src/hmtx.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -10,47 +10,14 @@ // hmtx - Horizontal Metrics // http://www.microsoft.com/typography/otspec/hmtx.htm -#define TABLE_NAME "hmtx" - namespace ots { -bool ots_hmtx_parse(Font *font, const uint8_t *data, size_t length) { - Buffer table(data, length); - OpenTypeHMTX *hmtx = new OpenTypeHMTX; - font->hmtx = hmtx; - - if (!font->hhea || !font->maxp) { - return OTS_FAILURE_MSG("Missing hhea or maxp tables in font, needed by hmtx"); - } - - if (!ParseMetricsTable(font, &table, font->maxp->num_glyphs, - &font->hhea->header, &hmtx->metrics)) { - return OTS_FAILURE_MSG("Failed to parse hmtx metrics"); - } - - return true; -} - -bool ots_hmtx_should_serialise(Font *font) { - return font->hmtx != NULL; +bool OpenTypeHMTX::Parse(const uint8_t *data, size_t length) { + return OpenTypeMetricsTable::Parse(data, length); } -bool ots_hmtx_serialise(OTSStream *out, Font *font) { - if (!SerialiseMetricsTable(font, out, &font->hmtx->metrics)) { - return OTS_FAILURE_MSG("Failed to serialise htmx metrics"); - } - return true; -} - -void ots_hmtx_reuse(Font *font, Font *other) { - font->hmtx = other->hmtx; - font->hmtx_reused = true; -} - -void ots_hmtx_free(Font *font) { - delete font->hmtx; +bool OpenTypeHMTX::Serialize(OTSStream *out) { + return OpenTypeMetricsTable::Serialize(out); } } // namespace ots - -#undef TABLE_NAME diff --git a/gfx/ots/src/hmtx.h b/gfx/ots/src/hmtx.h index 435949c5e..dbea9c80c 100644 --- a/gfx/ots/src/hmtx.h +++ b/gfx/ots/src/hmtx.h @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -6,12 +6,18 @@ #define OTS_HMTX_H_ #include "metrics.h" +#include "hhea.h" #include "ots.h" namespace ots { -struct OpenTypeHMTX { - OpenTypeMetricsTable metrics; +class OpenTypeHMTX : public OpenTypeMetricsTable { + public: + explicit OpenTypeHMTX(Font *font, uint32_t tag) + : OpenTypeMetricsTable(font, tag, tag, OTS_TAG_HHEA) { } + + bool Parse(const uint8_t *data, size_t length); + bool Serialize(OTSStream *out); }; } // namespace ots diff --git a/gfx/ots/src/hvar.cc b/gfx/ots/src/hvar.cc new file mode 100644 index 000000000..2bcea8680 --- /dev/null +++ b/gfx/ots/src/hvar.cc @@ -0,0 +1,85 @@ +// Copyright (c) 2018 The OTS 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 "hvar.h" + +#include "variations.h" + +namespace ots { + +// ----------------------------------------------------------------------------- +// OpenTypeHVAR +// ----------------------------------------------------------------------------- + +bool OpenTypeHVAR::Parse(const uint8_t* data, size_t length) { + Buffer table(data, length); + + uint16_t majorVersion; + uint16_t minorVersion; + uint32_t itemVariationStoreOffset; + uint32_t advanceWidthMappingOffset; + uint32_t lsbMappingOffset; + uint32_t rsbMappingOffset; + + if (!table.ReadU16(&majorVersion) || + !table.ReadU16(&minorVersion) || + !table.ReadU32(&itemVariationStoreOffset) || + !table.ReadU32(&advanceWidthMappingOffset) || + !table.ReadU32(&lsbMappingOffset) || + !table.ReadU32(&rsbMappingOffset)) { + return DropVariations("Failed to read table header"); + } + + if (majorVersion != 1) { + return DropVariations("Unknown table version"); + } + + if (itemVariationStoreOffset > length || + advanceWidthMappingOffset > length || + lsbMappingOffset > length || + rsbMappingOffset > length) { + return DropVariations("Invalid subtable offset"); + } + + if (!ParseItemVariationStore(GetFont(), data + itemVariationStoreOffset, + length - itemVariationStoreOffset)) { + return DropVariations("Failed to parse item variation store"); + } + + if (advanceWidthMappingOffset) { + if (!ParseDeltaSetIndexMap(GetFont(), data + advanceWidthMappingOffset, + length - advanceWidthMappingOffset)) { + return DropVariations("Failed to parse advance width mappings"); + } + } + + if (lsbMappingOffset) { + if (!ParseDeltaSetIndexMap(GetFont(), data + lsbMappingOffset, + length - lsbMappingOffset)) { + return DropVariations("Failed to parse LSB mappings"); + } + } + + if (rsbMappingOffset) { + if (!ParseDeltaSetIndexMap(GetFont(), data + rsbMappingOffset, + length - rsbMappingOffset)) { + return DropVariations("Failed to parse RSB mappings"); + } + } + + this->m_data = data; + this->m_length = length; + + return true; +} + +bool OpenTypeHVAR::Serialize(OTSStream* out) { + if (!out->Write(this->m_data, this->m_length)) { + return Error("Failed to write HVAR table"); + } + + return true; +} + +} // namespace ots diff --git a/gfx/ots/src/hvar.h b/gfx/ots/src/hvar.h new file mode 100644 index 000000000..5bfd2e4ea --- /dev/null +++ b/gfx/ots/src/hvar.h @@ -0,0 +1,31 @@ +// Copyright (c) 2018 The OTS Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef OTS_HVAR_H_ +#define OTS_HVAR_H_ + +#include "ots.h" + +namespace ots { + +// ----------------------------------------------------------------------------- +// OpenTypeHVAR Interface +// ----------------------------------------------------------------------------- + +class OpenTypeHVAR : public Table { + public: + explicit OpenTypeHVAR(Font* font, uint32_t tag) + : Table(font, tag, tag) { } + + bool Parse(const uint8_t* data, size_t length); + bool Serialize(OTSStream* out); + + private: + const uint8_t *m_data; + size_t m_length; +}; + +} // namespace ots + +#endif // OTS_HVAR_H_ diff --git a/gfx/ots/src/kern.cc b/gfx/ots/src/kern.cc index d4ae8fcc4..ec41dfb9c 100644 --- a/gfx/ots/src/kern.cc +++ b/gfx/ots/src/kern.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -7,75 +7,61 @@ // kern - Kerning // http://www.microsoft.com/typography/otspec/kern.htm -#define TABLE_NAME "kern" - -#define DROP_THIS_TABLE(msg_) \ - do { \ - OTS_FAILURE_MSG(msg_ ", table discarded"); \ - delete font->kern; \ - font->kern = 0; \ - } while (0) - namespace ots { -bool ots_kern_parse(Font *font, const uint8_t *data, size_t length) { +bool OpenTypeKERN::Parse(const uint8_t *data, size_t length) { Buffer table(data, length); - OpenTypeKERN *kern = new OpenTypeKERN; - font->kern = kern; - uint16_t num_tables = 0; - if (!table.ReadU16(&kern->version) || + if (!table.ReadU16(&this->version) || !table.ReadU16(&num_tables)) { - return OTS_FAILURE_MSG("Failed to read kern header"); + return Error("Failed to read table header"); } - if (kern->version > 0) { - DROP_THIS_TABLE("bad table version"); - return true; + if (this->version > 0) { + return Drop("Unsupported table version: %d", this->version); } if (num_tables == 0) { - DROP_THIS_TABLE("num_tables is zero"); - return true; + return Drop("nTables is zero"); } - kern->subtables.reserve(num_tables); + this->subtables.reserve(num_tables); for (unsigned i = 0; i < num_tables; ++i) { OpenTypeKERNFormat0 subtable; uint16_t sub_length = 0; if (!table.ReadU16(&subtable.version) || !table.ReadU16(&sub_length)) { - return OTS_FAILURE_MSG("Failed to read kern subtable %d header", i); + return Error("Failed to read subtable %d header", i); } if (subtable.version > 0) { - OTS_WARNING("Bad subtable version: %d", subtable.version); + Warning("Ignoring subtable %d with unsupported version: %d", + i, subtable.version); continue; } const size_t current_offset = table.offset(); if (current_offset - 4 + sub_length > length) { - return OTS_FAILURE_MSG("Bad kern subtable %d offset %ld", i, current_offset); + return Error("Bad subtable %d offset %ld", i, current_offset); } if (!table.ReadU16(&subtable.coverage)) { - return OTS_FAILURE_MSG("Cailed to read kern subtable %d coverage", i); + return Error("Failed to read subtable %d coverage", i); } if (!(subtable.coverage & 0x1)) { - OTS_WARNING( + Warning( "We don't support vertical data as the renderer doesn't support it."); continue; } if (subtable.coverage & 0xF0) { - DROP_THIS_TABLE("Reserved fields should zero-filled"); - return true; + return Drop("Reserved fields should be zero"); } const uint32_t format = (subtable.coverage & 0xFF00) >> 8; if (format != 0) { - OTS_WARNING("Format %d is not supported.", format); + Warning("Ignoring subtable %d with unsupported format: %d", i, format); continue; } @@ -85,12 +71,11 @@ bool ots_kern_parse(Font *font, const uint8_t *data, size_t length) { !table.ReadU16(&subtable.search_range) || !table.ReadU16(&subtable.entry_selector) || !table.ReadU16(&subtable.range_shift)) { - return OTS_FAILURE_MSG("Failed to read kern subtable %d format 0 fields", i); + return Error("Failed to read subtable %d format 0 fields", i); } if (!num_pairs) { - DROP_THIS_TABLE("Zero length subtable is found"); - return true; + return Drop("Zero length subtable is found"); } // Sanity checks for search_range, entry_selector, and range_shift. See the @@ -98,8 +83,7 @@ bool ots_kern_parse(Font *font, const uint8_t *data, size_t length) { const size_t kFormat0PairSize = 6; // left, right, and value. 2 bytes each. if (num_pairs > (65536 / kFormat0PairSize)) { // Some fonts (e.g. calibri.ttf, pykes_peak_zero.ttf) have pairs >= 10923. - DROP_THIS_TABLE("Too large subtable"); - return true; + return Drop("Too large subtable"); } unsigned max_pow2 = 0; while (1u << (max_pow2 + 1) <= num_pairs) { @@ -107,16 +91,16 @@ bool ots_kern_parse(Font *font, const uint8_t *data, size_t length) { } const uint16_t expected_search_range = (1u << max_pow2) * kFormat0PairSize; if (subtable.search_range != expected_search_range) { - OTS_WARNING("bad search range"); + Warning("bad search range"); subtable.search_range = expected_search_range; } if (subtable.entry_selector != max_pow2) { - return OTS_FAILURE_MSG("Bad subtable %d entry selector %d", i, subtable.entry_selector); + return Error("Bad subtable %d entry selector %d", i, subtable.entry_selector); } const uint16_t expected_range_shift = kFormat0PairSize * num_pairs - subtable.search_range; if (subtable.range_shift != expected_range_shift) { - OTS_WARNING("bad range shift"); + Warning("bad range shift"); subtable.range_shift = expected_range_shift; } @@ -128,64 +112,55 @@ bool ots_kern_parse(Font *font, const uint8_t *data, size_t length) { if (!table.ReadU16(&kerning_pair.left) || !table.ReadU16(&kerning_pair.right) || !table.ReadS16(&kerning_pair.value)) { - return OTS_FAILURE_MSG("Failed to read subtable %d kerning pair %d", i, j); + return Error("Failed to read subtable %d kerning pair %d", i, j); } const uint32_t current_pair = (kerning_pair.left << 16) + kerning_pair.right; if (j != 0 && current_pair <= last_pair) { // Many free fonts don't follow this rule, so we don't call OTS_FAILURE // in order to support these fonts. - DROP_THIS_TABLE("Kerning pairs are not sorted"); - return true; + return Drop("Kerning pairs are not sorted"); } last_pair = current_pair; subtable.pairs.push_back(kerning_pair); } - kern->subtables.push_back(subtable); + this->subtables.push_back(subtable); } - if (!kern->subtables.size()) { - DROP_THIS_TABLE("All subtables are removed"); - return true; + if (!this->subtables.size()) { + return Drop("All subtables were removed"); } return true; } -bool ots_kern_should_serialise(Font *font) { - if (!font->glyf) return false; // this table is not for CFF fonts. - return font->kern != NULL; -} - -bool ots_kern_serialise(OTSStream *out, Font *font) { - const OpenTypeKERN *kern = font->kern; - - const uint16_t num_subtables = static_cast<uint16_t>(kern->subtables.size()); - if (num_subtables != kern->subtables.size() || - !out->WriteU16(kern->version) || +bool OpenTypeKERN::Serialize(OTSStream *out) { + const uint16_t num_subtables = static_cast<uint16_t>(this->subtables.size()); + if (num_subtables != this->subtables.size() || + !out->WriteU16(this->version) || !out->WriteU16(num_subtables)) { - return OTS_FAILURE_MSG("Can't write kern table header"); + return Error("Failed to write kern table header"); } for (uint16_t i = 0; i < num_subtables; ++i) { - const size_t length = 14 + (6 * kern->subtables[i].pairs.size()); + const size_t length = 14 + (6 * this->subtables[i].pairs.size()); if (length > std::numeric_limits<uint16_t>::max() || - !out->WriteU16(kern->subtables[i].version) || + !out->WriteU16(this->subtables[i].version) || !out->WriteU16(static_cast<uint16_t>(length)) || - !out->WriteU16(kern->subtables[i].coverage) || + !out->WriteU16(this->subtables[i].coverage) || !out->WriteU16( - static_cast<uint16_t>(kern->subtables[i].pairs.size())) || - !out->WriteU16(kern->subtables[i].search_range) || - !out->WriteU16(kern->subtables[i].entry_selector) || - !out->WriteU16(kern->subtables[i].range_shift)) { - return OTS_FAILURE_MSG("Failed to write kern subtable %d", i); - } - for (unsigned j = 0; j < kern->subtables[i].pairs.size(); ++j) { - if (!out->WriteU16(kern->subtables[i].pairs[j].left) || - !out->WriteU16(kern->subtables[i].pairs[j].right) || - !out->WriteS16(kern->subtables[i].pairs[j].value)) { - return OTS_FAILURE_MSG("Failed to write kern pair %d for subtable %d", j, i); + static_cast<uint16_t>(this->subtables[i].pairs.size())) || + !out->WriteU16(this->subtables[i].search_range) || + !out->WriteU16(this->subtables[i].entry_selector) || + !out->WriteU16(this->subtables[i].range_shift)) { + return Error("Failed to write kern subtable %d", i); + } + for (unsigned j = 0; j < this->subtables[i].pairs.size(); ++j) { + if (!out->WriteU16(this->subtables[i].pairs[j].left) || + !out->WriteU16(this->subtables[i].pairs[j].right) || + !out->WriteS16(this->subtables[i].pairs[j].value)) { + return Error("Failed to write kern pair %d for subtable %d", j, i); } } } @@ -193,16 +168,10 @@ bool ots_kern_serialise(OTSStream *out, Font *font) { return true; } -void ots_kern_reuse(Font *font, Font *other) { - font->kern = other->kern; - font->kern_reused = true; -} - -void ots_kern_free(Font *font) { - delete font->kern; +bool OpenTypeKERN::ShouldSerialize() { + return Table::ShouldSerialize() && + // this table is not for CFF fonts. + GetFont()->GetTable(OTS_TAG_GLYF) != NULL; } } // namespace ots - -#undef TABLE_NAME -#undef DROP_THIS_TABLE diff --git a/gfx/ots/src/kern.h b/gfx/ots/src/kern.h index 9350ef7f8..38f056851 100644 --- a/gfx/ots/src/kern.h +++ b/gfx/ots/src/kern.h @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -30,7 +30,16 @@ struct OpenTypeKERNFormat0 { // WebFonts unlikely use it. I've checked thousands of proprietary fonts and // free fonts, and found no font uses the format. -struct OpenTypeKERN { +class OpenTypeKERN : public Table { + public: + explicit OpenTypeKERN(Font *font, uint32_t tag) + : Table(font, tag, tag) { } + + bool Parse(const uint8_t *data, size_t length); + bool Serialize(OTSStream *out); + bool ShouldSerialize(); + + private: uint16_t version; std::vector<OpenTypeKERNFormat0> subtables; }; diff --git a/gfx/ots/src/layout.cc b/gfx/ots/src/layout.cc index 1d87b53d4..8e99f573d 100644 --- a/gfx/ots/src/layout.cc +++ b/gfx/ots/src/layout.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2011 The Chromium Authors. All rights reserved. +// Copyright (c) 2011-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -7,6 +7,7 @@ #include <limits> #include <vector> +#include "fvar.h" #include "gdef.h" // OpenType Layout Common Table Formats @@ -22,14 +23,11 @@ const uint32_t kScriptTableTagDflt = 0x44464c54; const uint16_t kNoRequiredFeatureIndexDefined = 0xFFFF; // The lookup flag bit which indicates existence of MarkFilteringSet. const uint16_t kUseMarkFilteringSetBit = 0x0010; -// The lookup flags which require GDEF table. -const uint16_t kGdefRequiredFlags = 0x0002 | 0x0004 | 0x0008; -// The mask for MarkAttachmentType. -const uint16_t kMarkAttachmentTypeMask = 0xFF00; // The maximum type number of format for device tables. const uint16_t kMaxDeltaFormatType = 3; -// The maximum number of class value. -const uint16_t kMaxClassDefValue = 0xFFFF; +// In variation fonts, Device Tables are replaced by VariationIndex tables, +// indicated by this flag in the deltaFormat field. +const uint16_t kVariationIndex = 0x8000; struct ScriptRecord { uint32_t tag; @@ -94,15 +92,12 @@ bool ParseScriptTable(const ots::Font *font, } // The spec requires a script table for 'DFLT' tag must contain non-NULL - // |offset_default_lang_sys| and |lang_sys_count| == 0 + // |offset_default_lang_sys|. // https://www.microsoft.com/typography/otspec/chapter2.htm if (tag == kScriptTableTagDflt) { if (offset_default_lang_sys == 0) { return OTS_FAILURE_MSG("DFLT script doesn't satisfy the spec. DefaultLangSys is NULL"); } - if (lang_sys_count != 0) { - return OTS_FAILURE_MSG("DFLT script doesn't satisfy the spec. LangSysCount is not zero: %d", lang_sys_count); - } } const unsigned lang_sys_record_end = @@ -197,27 +192,7 @@ bool ParseLookupTable(ots::Font *font, const uint8_t *data, return OTS_FAILURE_MSG("Bad lookup type %d", lookup_type); } - // Check lookup flags. - if ((lookup_flag & kGdefRequiredFlags) && - (!font->gdef || !font->gdef->has_glyph_class_def)) { - return OTS_FAILURE_MSG("Lookup flags require GDEF table, " - "but none was found: %d", lookup_flag); - } - if ((lookup_flag & kMarkAttachmentTypeMask) && - (!font->gdef || !font->gdef->has_mark_attachment_class_def)) { - return OTS_FAILURE_MSG("Lookup flags ask for mark attachment, " - "but there is no GDEF table or it has no " - "mark attachment classes: %d", lookup_flag); - } - bool use_mark_filtering_set = false; - if (lookup_flag & kUseMarkFilteringSetBit) { - if (!font->gdef || !font->gdef->has_mark_glyph_sets_def) { - return OTS_FAILURE_MSG("Lookup flags ask for mark filtering, " - "but there is no GDEF table or it has no " - "mark filtering sets: %d", lookup_flag); - } - use_mark_filtering_set = true; - } + bool use_mark_filtering_set = lookup_flag & kUseMarkFilteringSetBit; std::vector<uint16_t> subtables; subtables.reserve(subtable_count); @@ -248,8 +223,12 @@ bool ParseLookupTable(ots::Font *font, const uint8_t *data, if (!subtable.ReadU16(&mark_filtering_set)) { return OTS_FAILURE_MSG("Failed to read mark filtering set"); } - if (font->gdef->num_mark_glyph_sets == 0 || - mark_filtering_set >= font->gdef->num_mark_glyph_sets) { + + ots::OpenTypeGDEF *gdef = static_cast<ots::OpenTypeGDEF*>( + font->GetTypedTable(OTS_TAG_GDEF)); + + if (gdef && (gdef->num_mark_glyph_sets == 0 || + mark_filtering_set >= gdef->num_mark_glyph_sets)) { return OTS_FAILURE_MSG("Bad mark filtering set %d", mark_filtering_set); } } @@ -311,15 +290,15 @@ bool ParseClassDefFormat2(const ots::Font *font, // Skip format field. if (!subtable.Skip(2)) { - return OTS_FAILURE_MSG("Failed to skip format of class defintion header"); + return OTS_FAILURE_MSG("Failed to read class definition format"); } uint16_t range_count = 0; if (!subtable.ReadU16(&range_count)) { - return OTS_FAILURE_MSG("Failed to read range count in class definition"); + return OTS_FAILURE_MSG("Failed to read classRangeCount"); } if (range_count > num_glyphs) { - return OTS_FAILURE_MSG("bad range count: %u", range_count); + return OTS_FAILURE_MSG("classRangeCount > glyph count: %u > %u", range_count, num_glyphs); } uint16_t last_end = 0; @@ -330,13 +309,16 @@ bool ParseClassDefFormat2(const ots::Font *font, if (!subtable.ReadU16(&start) || !subtable.ReadU16(&end) || !subtable.ReadU16(&class_value)) { - return OTS_FAILURE_MSG("Failed to read class definition reange %d", i); + return OTS_FAILURE_MSG("Failed to read ClassRangeRecord %d", i); + } + if (start > end) { + return OTS_FAILURE_MSG("ClassRangeRecord %d, start > end: %u > %u", i, start, end); } - if (start > end || (last_end && start <= last_end)) { - return OTS_FAILURE_MSG("glyph range is overlapping.in range %d", i); + if (last_end && start <= last_end) { + return OTS_FAILURE_MSG("ClassRangeRecord %d start overlaps with end of the previous one: %u <= %u", i, start, last_end); } if (class_value > num_classes) { - return OTS_FAILURE_MSG("bad class value: %u", class_value); + return OTS_FAILURE_MSG("ClassRangeRecord %d class > number of classes: %u > %u", i, class_value, num_classes); } last_end = end; } @@ -661,7 +643,7 @@ bool ParseContextFormat2(const ots::Font *font, } if (!ots::ParseClassDefTable(font, data + offset_class_def, length - offset_class_def, - num_glyphs, kMaxClassDefValue)) { + num_glyphs, ots::kMaxClassDefValue)) { return OTS_FAILURE_MSG("Failed to parse class definition table in context format 2"); } @@ -1014,7 +996,7 @@ bool ParseChainContextFormat2(const ots::Font *font, } if (!ots::ParseClassDefTable(font, data + offset_backtrack_class_def, length - offset_backtrack_class_def, - num_glyphs, kMaxClassDefValue)) { + num_glyphs, ots::kMaxClassDefValue)) { return OTS_FAILURE_MSG("Failed to parse backtrack class defn table in chain context format 2"); } } @@ -1025,7 +1007,7 @@ bool ParseChainContextFormat2(const ots::Font *font, } if (!ots::ParseClassDefTable(font, data + offset_input_class_def, length - offset_input_class_def, - num_glyphs, kMaxClassDefValue)) { + num_glyphs, ots::kMaxClassDefValue)) { return OTS_FAILURE_MSG("Failed to parse input class defn in chain context format 2"); } @@ -1036,7 +1018,7 @@ bool ParseChainContextFormat2(const ots::Font *font, } if (!ots::ParseClassDefTable(font, data + offset_lookahead_class_def, length - offset_lookahead_class_def, - num_glyphs, kMaxClassDefValue)) { + num_glyphs, ots::kMaxClassDefValue)) { return OTS_FAILURE_MSG("Failed to parse lookahead class defn in chain context format 2"); } } @@ -1400,11 +1382,17 @@ bool ParseDeviceTable(const ots::Font *font, !subtable.ReadU16(&delta_format)) { return OTS_FAILURE_MSG("Failed to read device table header"); } + if (delta_format == kVariationIndex) { + // start_size and end_size are replaced by deltaSetOuterIndex + // and deltaSetInnerIndex respectively, but we don't attempt to + // check them here, so nothing more to do. + return true; + } if (start_size > end_size) { - return OTS_FAILURE_MSG("bad size range: %u > %u", start_size, end_size); + return OTS_FAILURE_MSG("Bad device table size range: %u > %u", start_size, end_size); } if (delta_format == 0 || delta_format > kMaxDeltaFormatType) { - return OTS_FAILURE_MSG("bad delta format: %u", delta_format); + return OTS_FAILURE_MSG("Bad device table delta format: 0x%x", delta_format); } // The number of delta values per uint16. The device table should contain // at least |num_units| * 2 bytes compressed data. @@ -1516,6 +1504,173 @@ bool ParseExtensionSubtable(const Font *font, return true; } +bool ParseConditionTable(const Font *font, + const uint8_t *data, const size_t length, + const uint16_t axis_count) { + Buffer subtable(data, length); + + uint16_t format = 0; + if (!subtable.ReadU16(&format)) { + return OTS_FAILURE_MSG("Failed to read condition table format"); + } + + if (format != 1) { + // An unknown format is not an error, but should be ignored per spec. + return true; + } + + uint16_t axis_index = 0; + int16_t filter_range_min_value = 0; + int16_t filter_range_max_value = 0; + if (!subtable.ReadU16(&axis_index) || + !subtable.ReadS16(&filter_range_min_value) || + !subtable.ReadS16(&filter_range_max_value)) { + return OTS_FAILURE_MSG("Failed to read condition table (format 1)"); + } + + if (axis_index >= axis_count) { + return OTS_FAILURE_MSG("Axis index out of range in condition"); + } + + // Check min/max values are within range -1.0 .. 1.0 and properly ordered + if (filter_range_min_value < -0x4000 || // -1.0 in F2DOT14 format + filter_range_max_value > 0x4000 || // +1.0 in F2DOT14 format + filter_range_min_value > filter_range_max_value) { + return OTS_FAILURE_MSG("Invalid filter range in condition"); + } + + return true; +} + +bool ParseConditionSetTable(const Font *font, + const uint8_t *data, const size_t length, + const uint16_t axis_count) { + Buffer subtable(data, length); + + uint16_t condition_count = 0; + if (!subtable.ReadU16(&condition_count)) { + return OTS_FAILURE_MSG("Failed to read condition count"); + } + + for (uint16_t i = 0; i < condition_count; i++) { + uint32_t condition_offset = 0; + if (!subtable.ReadU32(&condition_offset)) { + return OTS_FAILURE_MSG("Failed to read condition offset"); + } + if (condition_offset < subtable.offset() || condition_offset >= length) { + return OTS_FAILURE_MSG("Offset out of range"); + } + if (!ParseConditionTable(font, data + condition_offset, length - condition_offset, + axis_count)) { + return OTS_FAILURE_MSG("Failed to parse condition table"); + } + } + + return true; +} + +bool ParseFeatureTableSubstitutionTable(const Font *font, + const uint8_t *data, const size_t length, + const uint16_t num_lookups) { + Buffer subtable(data, length); + + uint16_t version_major = 0; + uint16_t version_minor = 0; + uint16_t substitution_count = 0; + const size_t kFeatureTableSubstitutionHeaderSize = 3 * sizeof(uint16_t); + + if (!subtable.ReadU16(&version_major) || + !subtable.ReadU16(&version_minor) || + !subtable.ReadU16(&substitution_count)) { + return OTS_FAILURE_MSG("Failed to read feature table substitution table header"); + } + + for (uint16_t i = 0; i < substitution_count; i++) { + uint16_t feature_index = 0; + uint32_t alternate_feature_table_offset = 0; + const size_t kFeatureTableSubstitutionRecordSize = sizeof(uint16_t) + sizeof(uint32_t); + + if (!subtable.ReadU16(&feature_index) || + !subtable.ReadU32(&alternate_feature_table_offset)) { + return OTS_FAILURE_MSG("Failed to read feature table substitution record"); + } + + if (alternate_feature_table_offset < kFeatureTableSubstitutionHeaderSize + + kFeatureTableSubstitutionRecordSize * substitution_count || + alternate_feature_table_offset >= length) { + return OTS_FAILURE_MSG("Invalid alternate feature table offset"); + } + + if (!ParseFeatureTable(font, data + alternate_feature_table_offset, + length - alternate_feature_table_offset, num_lookups)) { + return OTS_FAILURE_MSG("Failed to parse alternate feature table"); + } + } + + return true; +} + +bool ParseFeatureVariationsTable(const Font *font, + const uint8_t *data, const size_t length, + const uint16_t num_lookups) { + Buffer subtable(data, length); + + uint16_t version_major = 0; + uint16_t version_minor = 0; + uint32_t feature_variation_record_count = 0; + + if (!subtable.ReadU16(&version_major) || + !subtable.ReadU16(&version_minor) || + !subtable.ReadU32(&feature_variation_record_count)) { + return OTS_FAILURE_MSG("Failed to read feature variations table header"); + } + + OpenTypeFVAR* fvar = static_cast<OpenTypeFVAR*>(font->GetTypedTable(OTS_TAG_FVAR)); + if (!fvar) { + return OTS_FAILURE_MSG("Not a variation font"); + } + const uint16_t axis_count = fvar->AxisCount(); + + const size_t kEndOfFeatureVariationRecords = + 2 * sizeof(uint16_t) + sizeof(uint32_t) + + feature_variation_record_count * 2 * sizeof(uint32_t); + + for (uint32_t i = 0; i < feature_variation_record_count; i++) { + uint32_t condition_set_offset = 0; + uint32_t feature_table_substitution_offset = 0; + if (!subtable.ReadU32(&condition_set_offset) || + !subtable.ReadU32(&feature_table_substitution_offset)) { + return OTS_FAILURE_MSG("Failed to read feature variation record"); + } + + if (condition_set_offset) { + if (condition_set_offset < kEndOfFeatureVariationRecords || + condition_set_offset >= length) { + return OTS_FAILURE_MSG("Condition set offset out of range"); + } + if (!ParseConditionSetTable(font, data + condition_set_offset, + length - condition_set_offset, + axis_count)) { + return OTS_FAILURE_MSG("Failed to parse condition set table"); + } + } + + if (feature_table_substitution_offset) { + if (feature_table_substitution_offset < kEndOfFeatureVariationRecords || + feature_table_substitution_offset >= length) { + return OTS_FAILURE_MSG("Feature table substitution offset out of range"); + } + if (!ParseFeatureTableSubstitutionTable(font, data + feature_table_substitution_offset, + length - feature_table_substitution_offset, + num_lookups)) { + return OTS_FAILURE_MSG("Failed to parse feature table substitution table"); + } + } + } + + return true; +} + } // namespace ots #undef TABLE_NAME diff --git a/gfx/ots/src/layout.h b/gfx/ots/src/layout.h index d195646d4..d10a3be5b 100644 --- a/gfx/ots/src/layout.h +++ b/gfx/ots/src/layout.h @@ -1,4 +1,4 @@ -// Copyright (c) 2011 The Chromium Authors. All rights reserved. +// Copyright (c) 2011-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -12,6 +12,8 @@ namespace ots { +// The maximum number of class value. +const uint16_t kMaxClassDefValue = 0xFFFF; struct LookupSubtableParser { struct TypeParser { @@ -70,6 +72,23 @@ bool ParseExtensionSubtable(const Font *font, const uint8_t *data, const size_t length, const LookupSubtableParser* parser); +// For feature variations table (in GSUB/GPOS v1.1) +bool ParseConditionTable(const Font *font, + const uint8_t *data, const size_t length, + const uint16_t axis_count); + +bool ParseConditionSetTable(const Font *font, + const uint8_t *data, const size_t length, + const uint16_t axis_count); + +bool ParseFeatureTableSubstitutionTable(const Font *font, + const uint8_t *data, const size_t length, + const uint16_t num_lookups); + +bool ParseFeatureVariationsTable(const Font *font, + const uint8_t *data, const size_t length, + const uint16_t num_lookups); + } // namespace ots #endif // OTS_LAYOUT_H_ diff --git a/gfx/ots/src/loca.cc b/gfx/ots/src/loca.cc index aae04c25a..4f322027d 100644 --- a/gfx/ots/src/loca.cc +++ b/gfx/ots/src/loca.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -10,84 +10,79 @@ // loca - Index to Location // http://www.microsoft.com/typography/otspec/loca.htm -#define TABLE_NAME "loca" - namespace ots { -bool ots_loca_parse(Font *font, const uint8_t *data, size_t length) { +bool OpenTypeLOCA::Parse(const uint8_t *data, size_t length) { Buffer table(data, length); // We can't do anything useful in validating this data except to ensure that // the values are monotonically increasing. - OpenTypeLOCA *loca = new OpenTypeLOCA; - font->loca = loca; - - if (!font->maxp || !font->head) { - return OTS_FAILURE_MSG("maxp or head tables missing from font, needed by loca"); + OpenTypeMAXP *maxp = static_cast<OpenTypeMAXP*>( + GetFont()->GetTypedTable(OTS_TAG_MAXP)); + OpenTypeHEAD *head = static_cast<OpenTypeHEAD*>( + GetFont()->GetTypedTable(OTS_TAG_HEAD)); + if (!maxp || !head) { + return Error("Required maxp or head tables are missing"); } - const unsigned num_glyphs = font->maxp->num_glyphs; + const unsigned num_glyphs = maxp->num_glyphs; unsigned last_offset = 0; - loca->offsets.resize(num_glyphs + 1); + this->offsets.resize(num_glyphs + 1); // maxp->num_glyphs is uint16_t, thus the addition never overflows. - if (font->head->index_to_loc_format == 0) { + if (head->index_to_loc_format == 0) { // Note that the <= here (and below) is correct. There is one more offset // than the number of glyphs in order to give the length of the final // glyph. for (unsigned i = 0; i <= num_glyphs; ++i) { uint16_t offset = 0; if (!table.ReadU16(&offset)) { - return OTS_FAILURE_MSG("Failed to read offset for glyph %d", i); + return Error("Failed to read offset for glyph %d", i); } if (offset < last_offset) { - return OTS_FAILURE_MSG("Out of order offset %d < %d for glyph %d", offset, last_offset, i); + return Error("Out of order offset %d < %d for glyph %d", offset, last_offset, i); } last_offset = offset; - loca->offsets[i] = offset * 2; + this->offsets[i] = offset * 2; } } else { for (unsigned i = 0; i <= num_glyphs; ++i) { uint32_t offset = 0; if (!table.ReadU32(&offset)) { - return OTS_FAILURE_MSG("Failed to read offset for glyph %d", i); + return Error("Failed to read offset for glyph %d", i); } if (offset < last_offset) { - return OTS_FAILURE_MSG("Out of order offset %d < %d for glyph %d", offset, last_offset, i); + return Error("Out of order offset %d < %d for glyph %d", offset, last_offset, i); } last_offset = offset; - loca->offsets[i] = offset; + this->offsets[i] = offset; } } return true; } -bool ots_loca_should_serialise(Font *font) { - return font->loca != NULL; -} - -bool ots_loca_serialise(OTSStream *out, Font *font) { - const OpenTypeLOCA *loca = font->loca; - const OpenTypeHEAD *head = font->head; +bool OpenTypeLOCA::Serialize(OTSStream *out) { + OpenTypeHEAD *head = static_cast<OpenTypeHEAD*>( + GetFont()->GetTypedTable(OTS_TAG_HEAD)); if (!head) { - return OTS_FAILURE_MSG("Missing head table in font needed by loca"); + return Error("Required head table is missing"); } if (head->index_to_loc_format == 0) { - for (unsigned i = 0; i < loca->offsets.size(); ++i) { - const uint16_t offset = static_cast<uint16_t>(loca->offsets[i] >> 1); - if ((offset != (loca->offsets[i] >> 1)) || + for (unsigned i = 0; i < this->offsets.size(); ++i) { + const uint16_t offset = static_cast<uint16_t>(this->offsets[i] >> 1); + if ((offset != (this->offsets[i] >> 1)) || !out->WriteU16(offset)) { - return OTS_FAILURE_MSG("Failed to write glyph offset for glyph %d", i); + return Error("Failed to write glyph offset for glyph %d", i); } } } else { - for (unsigned i = 0; i < loca->offsets.size(); ++i) { - if (!out->WriteU32(loca->offsets[i])) { - return OTS_FAILURE_MSG("Failed to write glyph offset for glyph %d", i); + for (unsigned i = 0; i < this->offsets.size(); ++i) { + if (!out->WriteU32(this->offsets[i])) { + return Error("Failed to write glyph offset for glyph %d", i); } } } @@ -95,15 +90,4 @@ bool ots_loca_serialise(OTSStream *out, Font *font) { return true; } -void ots_loca_reuse(Font *font, Font *other) { - font->loca = other->loca; - font->loca_reused = true; -} - -void ots_loca_free(Font *font) { - delete font->loca; -} - } // namespace ots - -#undef TABLE_NAME diff --git a/gfx/ots/src/loca.h b/gfx/ots/src/loca.h index 255ef06ec..da3241842 100644 --- a/gfx/ots/src/loca.h +++ b/gfx/ots/src/loca.h @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -11,7 +11,14 @@ namespace ots { -struct OpenTypeLOCA { +class OpenTypeLOCA : public Table { + public: + explicit OpenTypeLOCA(Font *font, uint32_t tag) + : Table(font, tag, tag) { } + + bool Parse(const uint8_t *data, size_t length); + bool Serialize(OTSStream *out); + std::vector<uint32_t> offsets; }; diff --git a/gfx/ots/src/ltsh.cc b/gfx/ots/src/ltsh.cc index 5b34cf4ad..4c40c5eb7 100644 --- a/gfx/ots/src/ltsh.cc +++ b/gfx/ots/src/ltsh.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -9,89 +9,63 @@ // LTSH - Linear Threshold // http://www.microsoft.com/typography/otspec/ltsh.htm -#define TABLE_NAME "LTSH" - -#define DROP_THIS_TABLE(...) \ - do { \ - OTS_FAILURE_MSG_(font->file, TABLE_NAME ": " __VA_ARGS__); \ - OTS_FAILURE_MSG("Table discarded"); \ - delete font->ltsh; \ - font->ltsh = 0; \ - } while (0) - namespace ots { -bool ots_ltsh_parse(Font *font, const uint8_t *data, size_t length) { +bool OpenTypeLTSH::Parse(const uint8_t *data, size_t length) { Buffer table(data, length); - if (!font->maxp) { - return OTS_FAILURE_MSG("Missing maxp table from font needed by ltsh"); + OpenTypeMAXP *maxp = static_cast<OpenTypeMAXP*>( + GetFont()->GetTypedTable(OTS_TAG_MAXP)); + if (!maxp) { + return Error("Required maxp table is missing"); } - OpenTypeLTSH *ltsh = new OpenTypeLTSH; - font->ltsh = ltsh; - uint16_t num_glyphs = 0; - if (!table.ReadU16(<sh->version) || + if (!table.ReadU16(&this->version) || !table.ReadU16(&num_glyphs)) { - return OTS_FAILURE_MSG("Failed to read ltsh header"); + return Error("Failed to read table header"); } - if (ltsh->version != 0) { - DROP_THIS_TABLE("bad version: %u", ltsh->version); - return true; + if (this->version != 0) { + return Drop("Unsupported version: %u", this->version); } - if (num_glyphs != font->maxp->num_glyphs) { - DROP_THIS_TABLE("bad num_glyphs: %u", num_glyphs); - return true; + if (num_glyphs != maxp->num_glyphs) { + return Drop("Bad numGlyphs: %u", num_glyphs); } - ltsh->ypels.reserve(num_glyphs); + this->ypels.reserve(num_glyphs); for (unsigned i = 0; i < num_glyphs; ++i) { uint8_t pel = 0; if (!table.ReadU8(&pel)) { - return OTS_FAILURE_MSG("Failed to read pixels for glyph %d", i); + return Error("Failed to read pixels for glyph %d", i); } - ltsh->ypels.push_back(pel); + this->ypels.push_back(pel); } return true; } -bool ots_ltsh_should_serialise(Font *font) { - if (!font->glyf) return false; // this table is not for CFF fonts. - return font->ltsh != NULL; -} - -bool ots_ltsh_serialise(OTSStream *out, Font *font) { - const OpenTypeLTSH *ltsh = font->ltsh; - - const uint16_t num_ypels = static_cast<uint16_t>(ltsh->ypels.size()); - if (num_ypels != ltsh->ypels.size() || - !out->WriteU16(ltsh->version) || +bool OpenTypeLTSH::Serialize(OTSStream *out) { + const uint16_t num_ypels = static_cast<uint16_t>(this->ypels.size()); + if (num_ypels != this->ypels.size() || + !out->WriteU16(this->version) || !out->WriteU16(num_ypels)) { - return OTS_FAILURE_MSG("Failed to write pels size"); + return Error("Failed to write table header"); } for (uint16_t i = 0; i < num_ypels; ++i) { - if (!out->Write(&(ltsh->ypels[i]), 1)) { - return OTS_FAILURE_MSG("Failed to write pixel size for glyph %d", i); + if (!out->Write(&(this->ypels[i]), 1)) { + return Error("Failed to write pixel size for glyph %d", i); } } return true; } -void ots_ltsh_reuse(Font *font, Font *other) { - font->ltsh = other->ltsh; - font->ltsh_reused = true; -} - -void ots_ltsh_free(Font *font) { - delete font->ltsh; +bool OpenTypeLTSH::ShouldSerialize() { + return Table::ShouldSerialize() && + // this table is not for CFF fonts. + GetFont()->GetTable(OTS_TAG_GLYF) != NULL; } } // namespace ots - -#undef TABLE_NAME -#undef DROP_THIS_TABLE diff --git a/gfx/ots/src/ltsh.h b/gfx/ots/src/ltsh.h index 23d97d784..cc9fbf62d 100644 --- a/gfx/ots/src/ltsh.h +++ b/gfx/ots/src/ltsh.h @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -11,7 +11,16 @@ namespace ots { -struct OpenTypeLTSH { +class OpenTypeLTSH : public Table { + public: + explicit OpenTypeLTSH(Font *font, uint32_t tag) + : Table(font, tag, tag) { } + + bool Parse(const uint8_t *data, size_t length); + bool Serialize(OTSStream *out); + bool ShouldSerialize(); + + private: uint16_t version; std::vector<uint8_t> ypels; }; diff --git a/gfx/ots/src/math.cc b/gfx/ots/src/math.cc index 36417dc29..c94e3bee3 100644 --- a/gfx/ots/src/math.cc +++ b/gfx/ots/src/math.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2014 The Chromium Authors. All rights reserved. +// Copyright (c) 2014-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -12,12 +12,7 @@ #include "maxp.h" // MATH - The MATH Table -// The specification is not yet public but has been submitted to the MPEG group -// in response to the 'Call for Proposals for ISO/IEC 14496-22 "Open Font -// Format" Color Font Technology and MATH layout support'. Meanwhile, you can -// contact Microsoft's engineer Murray Sargent to obtain a copy. - -#define TABLE_NAME "MATH" +// http://www.microsoft.com/typography/otspec/math.htm namespace { @@ -48,11 +43,15 @@ const unsigned kMathValueRecordSize = 2 * 2; // PartFlags const unsigned kGlyphPartRecordSize = 5 * 2; +} // namespace + +namespace ots { + // Shared Table: MathValueRecord -bool ParseMathValueRecord(const ots::Font *font, - ots::Buffer* subtable, const uint8_t *data, - const size_t length) { +bool OpenTypeMATH::ParseMathValueRecord(ots::Buffer* subtable, + const uint8_t *data, + const size_t length) { // Check the Value field. if (!subtable->Skip(2)) { return OTS_FAILURE(); @@ -67,7 +66,7 @@ bool ParseMathValueRecord(const ots::Font *font, if (offset >= length) { return OTS_FAILURE(); } - if (!ots::ParseDeviceTable(font, data + offset, length - offset)) { + if (!ots::ParseDeviceTable(GetFont(), data + offset, length - offset)) { return OTS_FAILURE(); } } @@ -75,8 +74,8 @@ bool ParseMathValueRecord(const ots::Font *font, return true; } -bool ParseMathConstantsTable(const ots::Font *font, - const uint8_t *data, size_t length) { +bool OpenTypeMATH::ParseMathConstantsTable(const uint8_t *data, + size_t length) { ots::Buffer subtable(data, length); // Part 1: int16 or uint16 constants. @@ -146,7 +145,7 @@ bool ParseMathConstantsTable(const ots::Font *font, // // RadicalKernAfterDegree for (unsigned i = 0; i < static_cast<unsigned>(51); ++i) { - if (!ParseMathValueRecord(font, &subtable, data, length)) { + if (!ParseMathValueRecord(&subtable, data, length)) { return OTS_FAILURE(); } } @@ -160,11 +159,10 @@ bool ParseMathConstantsTable(const ots::Font *font, return true; } -bool ParseMathValueRecordSequenceForGlyphs(const ots::Font *font, - ots::Buffer* subtable, - const uint8_t *data, - const size_t length, - const uint16_t num_glyphs) { +bool OpenTypeMATH::ParseMathValueRecordSequenceForGlyphs(ots::Buffer* subtable, + const uint8_t *data, + const size_t length, + const uint16_t num_glyphs) { // Check the header. uint16_t offset_coverage = 0; uint16_t sequence_count = 0; @@ -183,7 +181,7 @@ bool ParseMathValueRecordSequenceForGlyphs(const ots::Font *font, if (offset_coverage < sequence_end || offset_coverage >= length) { return OTS_FAILURE(); } - if (!ots::ParseCoverageTable(font, data + offset_coverage, + if (!ots::ParseCoverageTable(GetFont(), data + offset_coverage, length - offset_coverage, num_glyphs, sequence_count)) { return OTS_FAILURE(); @@ -191,7 +189,7 @@ bool ParseMathValueRecordSequenceForGlyphs(const ots::Font *font, // Check sequence. for (unsigned i = 0; i < sequence_count; ++i) { - if (!ParseMathValueRecord(font, subtable, data, length)) { + if (!ParseMathValueRecord(subtable, data, length)) { return OTS_FAILURE(); } } @@ -199,26 +197,23 @@ bool ParseMathValueRecordSequenceForGlyphs(const ots::Font *font, return true; } -bool ParseMathItalicsCorrectionInfoTable(const ots::Font *font, - const uint8_t *data, - size_t length, - const uint16_t num_glyphs) { +bool OpenTypeMATH::ParseMathItalicsCorrectionInfoTable(const uint8_t *data, + size_t length, + const uint16_t num_glyphs) { ots::Buffer subtable(data, length); - return ParseMathValueRecordSequenceForGlyphs(font, &subtable, data, length, + return ParseMathValueRecordSequenceForGlyphs(&subtable, data, length, num_glyphs); } -bool ParseMathTopAccentAttachmentTable(const ots::Font *font, - const uint8_t *data, - size_t length, - const uint16_t num_glyphs) { +bool OpenTypeMATH::ParseMathTopAccentAttachmentTable(const uint8_t *data, + size_t length, + const uint16_t num_glyphs) { ots::Buffer subtable(data, length); - return ParseMathValueRecordSequenceForGlyphs(font, &subtable, data, length, + return ParseMathValueRecordSequenceForGlyphs(&subtable, data, length, num_glyphs); } -bool ParseMathKernTable(const ots::Font *font, - const uint8_t *data, size_t length) { +bool OpenTypeMATH::ParseMathKernTable(const uint8_t *data, size_t length) { ots::Buffer subtable(data, length); // Check the Height count. @@ -229,14 +224,14 @@ bool ParseMathKernTable(const ots::Font *font, // Check the Correction Heights. for (unsigned i = 0; i < height_count; ++i) { - if (!ParseMathValueRecord(font, &subtable, data, length)) { + if (!ParseMathValueRecord(&subtable, data, length)) { return OTS_FAILURE(); } } // Check the Kern Values. for (unsigned i = 0; i <= height_count; ++i) { - if (!ParseMathValueRecord(font, &subtable, data, length)) { + if (!ParseMathValueRecord(&subtable, data, length)) { return OTS_FAILURE(); } } @@ -244,9 +239,9 @@ bool ParseMathKernTable(const ots::Font *font, return true; } -bool ParseMathKernInfoTable(const ots::Font *font, - const uint8_t *data, size_t length, - const uint16_t num_glyphs) { +bool OpenTypeMATH::ParseMathKernInfoTable(const uint8_t *data, + size_t length, + const uint16_t num_glyphs) { ots::Buffer subtable(data, length); // Check the header. @@ -267,7 +262,7 @@ bool ParseMathKernInfoTable(const ots::Font *font, if (offset_coverage < sequence_end || offset_coverage >= length) { return OTS_FAILURE(); } - if (!ots::ParseCoverageTable(font, data + offset_coverage, length - offset_coverage, + if (!ots::ParseCoverageTable(GetFont(), data + offset_coverage, length - offset_coverage, num_glyphs, sequence_count)) { return OTS_FAILURE(); } @@ -282,7 +277,7 @@ bool ParseMathKernInfoTable(const ots::Font *font, } if (offset_math_kern) { if (offset_math_kern < sequence_end || offset_math_kern >= length || - !ParseMathKernTable(font, data + offset_math_kern, + !ParseMathKernTable(data + offset_math_kern, length - offset_math_kern)) { return OTS_FAILURE(); } @@ -293,9 +288,9 @@ bool ParseMathKernInfoTable(const ots::Font *font, return true; } -bool ParseMathGlyphInfoTable(const ots::Font *font, - const uint8_t *data, size_t length, - const uint16_t num_glyphs) { +bool OpenTypeMATH::ParseMathGlyphInfoTable(const uint8_t *data, + size_t length, + const uint16_t num_glyphs) { ots::Buffer subtable(data, length); // Check Header. @@ -318,7 +313,7 @@ bool ParseMathGlyphInfoTable(const ots::Font *font, if (offset_math_italics_correction_info >= length || offset_math_italics_correction_info < kMathGlyphInfoHeaderSize || !ParseMathItalicsCorrectionInfoTable( - font, data + offset_math_italics_correction_info, + data + offset_math_italics_correction_info, length - offset_math_italics_correction_info, num_glyphs)) { return OTS_FAILURE(); @@ -327,7 +322,7 @@ bool ParseMathGlyphInfoTable(const ots::Font *font, if (offset_math_top_accent_attachment) { if (offset_math_top_accent_attachment >= length || offset_math_top_accent_attachment < kMathGlyphInfoHeaderSize || - !ParseMathTopAccentAttachmentTable(font, data + + !ParseMathTopAccentAttachmentTable(data + offset_math_top_accent_attachment, length - offset_math_top_accent_attachment, @@ -338,7 +333,7 @@ bool ParseMathGlyphInfoTable(const ots::Font *font, if (offset_extended_shaped_coverage) { if (offset_extended_shaped_coverage >= length || offset_extended_shaped_coverage < kMathGlyphInfoHeaderSize || - !ots::ParseCoverageTable(font, data + offset_extended_shaped_coverage, + !ots::ParseCoverageTable(GetFont(), data + offset_extended_shaped_coverage, length - offset_extended_shaped_coverage, num_glyphs)) { return OTS_FAILURE(); @@ -347,7 +342,7 @@ bool ParseMathGlyphInfoTable(const ots::Font *font, if (offset_math_kern_info) { if (offset_math_kern_info >= length || offset_math_kern_info < kMathGlyphInfoHeaderSize || - !ParseMathKernInfoTable(font, data + offset_math_kern_info, + !ParseMathKernInfoTable(data + offset_math_kern_info, length - offset_math_kern_info, num_glyphs)) { return OTS_FAILURE(); } @@ -356,14 +351,14 @@ bool ParseMathGlyphInfoTable(const ots::Font *font, return true; } -bool ParseGlyphAssemblyTable(const ots::Font *font, - const uint8_t *data, - size_t length, const uint16_t num_glyphs) { +bool OpenTypeMATH::ParseGlyphAssemblyTable(const uint8_t *data, + size_t length, + const uint16_t num_glyphs) { ots::Buffer subtable(data, length); // Check the header. uint16_t part_count = 0; - if (!ParseMathValueRecord(font, &subtable, data, length) || + if (!ParseMathValueRecord(&subtable, data, length) || !subtable.ReadU16(&part_count)) { return OTS_FAILURE(); } @@ -384,19 +379,19 @@ bool ParseGlyphAssemblyTable(const ots::Font *font, return OTS_FAILURE(); } if (glyph >= num_glyphs) { - return OTS_FAILURE_MSG("bad glyph ID: %u", glyph); + return Error("bad glyph ID: %u", glyph); } if (part_flags & ~0x00000001) { - return OTS_FAILURE_MSG("unknown part flag: %u", part_flags); + return Error("unknown part flag: %u", part_flags); } } return true; } -bool ParseMathGlyphConstructionTable(const ots::Font *font, - const uint8_t *data, - size_t length, const uint16_t num_glyphs) { +bool OpenTypeMATH::ParseMathGlyphConstructionTable(const uint8_t *data, + size_t length, + const uint16_t num_glyphs) { ots::Buffer subtable(data, length); // Check the header. @@ -419,7 +414,7 @@ bool ParseMathGlyphConstructionTable(const ots::Font *font, offset_glyph_assembly < sequence_end) { return OTS_FAILURE(); } - if (!ParseGlyphAssemblyTable(font, data + offset_glyph_assembly, + if (!ParseGlyphAssemblyTable(data + offset_glyph_assembly, length - offset_glyph_assembly, num_glyphs)) { return OTS_FAILURE(); } @@ -433,21 +428,20 @@ bool ParseMathGlyphConstructionTable(const ots::Font *font, return OTS_FAILURE(); } if (glyph >= num_glyphs) { - return OTS_FAILURE_MSG("bad glyph ID: %u", glyph); + return Error("bad glyph ID: %u", glyph); } } return true; } -bool ParseMathGlyphConstructionSequence(const ots::Font *font, - ots::Buffer* subtable, - const uint8_t *data, - size_t length, - const uint16_t num_glyphs, - uint16_t offset_coverage, - uint16_t glyph_count, - const unsigned sequence_end) { +bool OpenTypeMATH::ParseMathGlyphConstructionSequence(ots::Buffer* subtable, + const uint8_t *data, + size_t length, + const uint16_t num_glyphs, + uint16_t offset_coverage, + uint16_t glyph_count, + const unsigned sequence_end) { // Zero glyph count, nothing to parse. if (!glyph_count) { return true; @@ -457,7 +451,7 @@ bool ParseMathGlyphConstructionSequence(const ots::Font *font, if (offset_coverage < sequence_end || offset_coverage >= length) { return OTS_FAILURE(); } - if (!ots::ParseCoverageTable(font, data + offset_coverage, + if (!ots::ParseCoverageTable(GetFont(), data + offset_coverage, length - offset_coverage, num_glyphs, glyph_count)) { return OTS_FAILURE(); @@ -471,7 +465,7 @@ bool ParseMathGlyphConstructionSequence(const ots::Font *font, } if (offset_glyph_construction < sequence_end || offset_glyph_construction >= length || - !ParseMathGlyphConstructionTable(font, data + offset_glyph_construction, + !ParseMathGlyphConstructionTable(data + offset_glyph_construction, length - offset_glyph_construction, num_glyphs)) { return OTS_FAILURE(); @@ -481,9 +475,9 @@ bool ParseMathGlyphConstructionSequence(const ots::Font *font, return true; } -bool ParseMathVariantsTable(const ots::Font *font, - const uint8_t *data, - size_t length, const uint16_t num_glyphs) { +bool OpenTypeMATH::ParseMathVariantsTable(const uint8_t *data, + size_t length, + const uint16_t num_glyphs) { ots::Buffer subtable(data, length); // Check the header. @@ -505,11 +499,11 @@ bool ParseMathVariantsTable(const ots::Font *font, return OTS_FAILURE(); } - if (!ParseMathGlyphConstructionSequence(font, &subtable, data, length, num_glyphs, + if (!ParseMathGlyphConstructionSequence(&subtable, data, length, num_glyphs, offset_vert_glyph_coverage, vert_glyph_count, sequence_end) || - !ParseMathGlyphConstructionSequence(font, &subtable, data, length, num_glyphs, + !ParseMathGlyphConstructionSequence(&subtable, data, length, num_glyphs, offset_horiz_glyph_coverage, horiz_glyph_count, sequence_end)) { @@ -519,37 +513,24 @@ bool ParseMathVariantsTable(const ots::Font *font, return true; } -} // namespace - -#define DROP_THIS_TABLE(msg_) \ - do { \ - OTS_FAILURE_MSG(msg_ ", table discarded"); \ - font->math->data = 0; \ - font->math->length = 0; \ - } while (0) - -namespace ots { - -bool ots_math_parse(Font *font, const uint8_t *data, size_t length) { +bool OpenTypeMATH::Parse(const uint8_t *data, size_t length) { // Grab the number of glyphs in the font from the maxp table to check // GlyphIDs in MATH table. - if (!font->maxp) { - return OTS_FAILURE(); + OpenTypeMAXP *maxp = static_cast<OpenTypeMAXP*>( + GetFont()->GetTypedTable(OTS_TAG_MAXP)); + if (!maxp) { + return Error("Required maxp table missing"); } - const uint16_t num_glyphs = font->maxp->num_glyphs; + const uint16_t num_glyphs = maxp->num_glyphs; Buffer table(data, length); - OpenTypeMATH* math = new OpenTypeMATH; - font->math = math; - uint32_t version = 0; if (!table.ReadU32(&version)) { return OTS_FAILURE(); } if (version != 0x00010000) { - DROP_THIS_TABLE("bad MATH version"); - return true; + return Drop("bad MATH version"); } uint16_t offset_math_constants = 0; @@ -567,53 +548,37 @@ bool ots_math_parse(Font *font, const uint8_t *data, size_t length) { offset_math_glyph_info < kMathHeaderSize || offset_math_variants >= length || offset_math_variants < kMathHeaderSize) { - DROP_THIS_TABLE("bad offset in MATH header"); - return true; + return Drop("bad offset in MATH header"); } - if (!ParseMathConstantsTable(font, data + offset_math_constants, + if (!ParseMathConstantsTable(data + offset_math_constants, length - offset_math_constants)) { - DROP_THIS_TABLE("failed to parse MathConstants table"); - return true; + return Drop("failed to parse MathConstants table"); } - if (!ParseMathGlyphInfoTable(font, data + offset_math_glyph_info, + if (!ParseMathGlyphInfoTable(data + offset_math_glyph_info, length - offset_math_glyph_info, num_glyphs)) { - DROP_THIS_TABLE("failed to parse MathGlyphInfo table"); - return true; + return Drop("failed to parse MathGlyphInfo table"); } - if (!ParseMathVariantsTable(font, data + offset_math_variants, + if (!ParseMathVariantsTable(data + offset_math_variants, length - offset_math_variants, num_glyphs)) { - DROP_THIS_TABLE("failed to parse MathVariants table"); - return true; + return Drop("failed to parse MathVariants table"); } - math->data = data; - math->length = length; + this->m_data = data; + this->m_length = length; return true; } -bool ots_math_should_serialise(Font *font) { - return font->math != NULL && font->math->data != NULL; -} - -bool ots_math_serialise(OTSStream *out, Font *font) { - if (!out->Write(font->math->data, font->math->length)) { +bool OpenTypeMATH::Serialize(OTSStream *out) { + if (!out->Write(this->m_data, this->m_length)) { return OTS_FAILURE(); } return true; } -void ots_math_reuse(Font *font, Font *other) { - font->math = other->math; - font->math_reused = true; -} - -void ots_math_free(Font *font) { - delete font->math; +bool OpenTypeMATH::ShouldSerialize() { + return Table::ShouldSerialize() && this->m_data != NULL; } } // namespace ots - -#undef TABLE_NAME -#undef DROP_THIS_TABLE diff --git a/gfx/ots/src/math_.h b/gfx/ots/src/math_.h index 91c54dbe1..875cacd4d 100644 --- a/gfx/ots/src/math_.h +++ b/gfx/ots/src/math_.h @@ -1,4 +1,4 @@ -// Copyright (c) 2014 The Chromium Authors. All rights reserved. +// Copyright (c) 2014-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -9,14 +9,58 @@ namespace ots { -struct OpenTypeMATH { - OpenTypeMATH() - : data(NULL), - length(0) { - } +class OpenTypeMATH : public Table { + public: + explicit OpenTypeMATH(Font *font, uint32_t tag) + : Table(font, tag, tag), + m_data(NULL), + m_length(0) { } - const uint8_t *data; - size_t length; + bool Parse(const uint8_t *data, size_t length); + bool Serialize(OTSStream *out); + bool ShouldSerialize(); + + private: + bool ParseMathValueRecord(ots::Buffer* subtable, + const uint8_t *data, + const size_t length); + bool ParseMathConstantsTable(const uint8_t *data, size_t length); + bool ParseMathValueRecordSequenceForGlyphs(ots::Buffer* subtable, + const uint8_t *data, + const size_t length, + const uint16_t num_glyphs); + bool ParseMathItalicsCorrectionInfoTable(const uint8_t *data, + size_t length, + const uint16_t num_glyphs); + bool ParseMathTopAccentAttachmentTable(const uint8_t *data, + size_t length, + const uint16_t num_glyphs); + bool ParseMathKernTable(const uint8_t *data, size_t length); + bool ParseMathKernInfoTable(const uint8_t *data, + size_t length, + const uint16_t num_glyphs); + bool ParseMathGlyphInfoTable(const uint8_t *data, + size_t length, + const uint16_t num_glyphs); + bool ParseGlyphAssemblyTable(const uint8_t *data, + size_t length, + const uint16_t num_glyphs); + bool ParseMathGlyphConstructionTable(const uint8_t *data, + size_t length, + const uint16_t num_glyphs); + bool ParseMathGlyphConstructionSequence(ots::Buffer* subtable, + const uint8_t *data, + size_t length, + const uint16_t num_glyphs, + uint16_t offset_coverage, + uint16_t glyph_count, + const unsigned sequence_end); + bool ParseMathVariantsTable(const uint8_t *data, + size_t length, + const uint16_t num_glyphs); + + const uint8_t *m_data; + size_t m_length; }; } // namespace ots diff --git a/gfx/ots/src/maxp.cc b/gfx/ots/src/maxp.cc index 41e29a745..232e4a988 100644 --- a/gfx/ots/src/maxp.cc +++ b/gfx/ots/src/maxp.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -7,119 +7,97 @@ // maxp - Maximum Profile // http://www.microsoft.com/typography/otspec/maxp.htm -#define TABLE_NAME "maxp" - namespace ots { -bool ots_maxp_parse(Font *font, const uint8_t *data, size_t length) { +bool OpenTypeMAXP::Parse(const uint8_t *data, size_t length) { Buffer table(data, length); - OpenTypeMAXP *maxp = new OpenTypeMAXP; - font->maxp = maxp; - uint32_t version = 0; if (!table.ReadU32(&version)) { - return OTS_FAILURE_MSG("Failed to read version of maxp table"); + return Error("Failed to read table version"); } if (version >> 16 > 1) { - return OTS_FAILURE_MSG("Bad maxp version %d", version); + return Error("Unsupported table version 0x%x", version); } - if (!table.ReadU16(&maxp->num_glyphs)) { - return OTS_FAILURE_MSG("Failed to read number of glyphs from maxp table"); + if (!table.ReadU16(&this->num_glyphs)) { + return Error("Failed to read numGlyphs"); } - if (!maxp->num_glyphs) { - return OTS_FAILURE_MSG("Bad number of glyphs 0 in maxp table"); + if (!this->num_glyphs) { + return Error("numGlyphs is 0"); } if (version >> 16 == 1) { - maxp->version_1 = true; - if (!table.ReadU16(&maxp->max_points) || - !table.ReadU16(&maxp->max_contours) || - !table.ReadU16(&maxp->max_c_points) || - !table.ReadU16(&maxp->max_c_contours) || - !table.ReadU16(&maxp->max_zones) || - !table.ReadU16(&maxp->max_t_points) || - !table.ReadU16(&maxp->max_storage) || - !table.ReadU16(&maxp->max_fdefs) || - !table.ReadU16(&maxp->max_idefs) || - !table.ReadU16(&maxp->max_stack) || - !table.ReadU16(&maxp->max_size_glyf_instructions) || - !table.ReadU16(&maxp->max_c_components) || - !table.ReadU16(&maxp->max_c_depth)) { - return OTS_FAILURE_MSG("Failed to read maxp table"); + this->version_1 = true; + if (!table.ReadU16(&this->max_points) || + !table.ReadU16(&this->max_contours) || + !table.ReadU16(&this->max_c_points) || + !table.ReadU16(&this->max_c_contours) || + !table.ReadU16(&this->max_zones) || + !table.ReadU16(&this->max_t_points) || + !table.ReadU16(&this->max_storage) || + !table.ReadU16(&this->max_fdefs) || + !table.ReadU16(&this->max_idefs) || + !table.ReadU16(&this->max_stack) || + !table.ReadU16(&this->max_size_glyf_instructions) || + !table.ReadU16(&this->max_c_components) || + !table.ReadU16(&this->max_c_depth)) { + return Error("Failed to read version 1 table data"); } - if (maxp->max_zones == 0) { + if (this->max_zones == 0) { // workaround for ipa*.ttf Japanese fonts. - OTS_WARNING("bad max_zones: %u", maxp->max_zones); - maxp->max_zones = 1; - } else if (maxp->max_zones == 3) { + Warning("Bad maxZones: %u", this->max_zones); + this->max_zones = 1; + } else if (this->max_zones == 3) { // workaround for Ecolier-*.ttf fonts. - OTS_WARNING("bad max_zones: %u", maxp->max_zones); - maxp->max_zones = 2; + Warning("Bad maxZones: %u", this->max_zones); + this->max_zones = 2; } - if ((maxp->max_zones != 1) && (maxp->max_zones != 2)) { - return OTS_FAILURE_MSG("Bad max zones %d in maxp", maxp->max_zones); + if ((this->max_zones != 1) && (this->max_zones != 2)) { + return Error("Bad maxZones: %u", this->max_zones); } } else { - maxp->version_1 = false; + this->version_1 = false; } return true; } -bool ots_maxp_should_serialise(Font *font) { - return font->maxp != NULL; -} - -bool ots_maxp_serialise(OTSStream *out, Font *font) { - const OpenTypeMAXP *maxp = font->maxp; - - if (!out->WriteU32(maxp->version_1 ? 0x00010000 : 0x00005000) || - !out->WriteU16(maxp->num_glyphs)) { - return OTS_FAILURE_MSG("Failed to write maxp version or number of glyphs"); +bool OpenTypeMAXP::Serialize(OTSStream *out) { + if (!out->WriteU32(this->version_1 ? 0x00010000 : 0x00005000) || + !out->WriteU16(this->num_glyphs)) { + return Error("Failed to write version or numGlyphs"); } - if (!maxp->version_1) return true; + if (!this->version_1) return true; - if (!out->WriteU16(maxp->max_points) || - !out->WriteU16(maxp->max_contours) || - !out->WriteU16(maxp->max_c_points) || - !out->WriteU16(maxp->max_c_contours)) { - return OTS_FAILURE_MSG("Failed to write maxp"); + if (!out->WriteU16(this->max_points) || + !out->WriteU16(this->max_contours) || + !out->WriteU16(this->max_c_points) || + !out->WriteU16(this->max_c_contours)) { + return Error("Failed to write maxp"); } - if (!out->WriteU16(maxp->max_zones) || - !out->WriteU16(maxp->max_t_points) || - !out->WriteU16(maxp->max_storage) || - !out->WriteU16(maxp->max_fdefs) || - !out->WriteU16(maxp->max_idefs) || - !out->WriteU16(maxp->max_stack) || - !out->WriteU16(maxp->max_size_glyf_instructions)) { - return OTS_FAILURE_MSG("Failed to write more maxp"); + if (!out->WriteU16(this->max_zones) || + !out->WriteU16(this->max_t_points) || + !out->WriteU16(this->max_storage) || + !out->WriteU16(this->max_fdefs) || + !out->WriteU16(this->max_idefs) || + !out->WriteU16(this->max_stack) || + !out->WriteU16(this->max_size_glyf_instructions)) { + return Error("Failed to write more maxp"); } - if (!out->WriteU16(maxp->max_c_components) || - !out->WriteU16(maxp->max_c_depth)) { - return OTS_FAILURE_MSG("Failed to write yet more maxp"); + if (!out->WriteU16(this->max_c_components) || + !out->WriteU16(this->max_c_depth)) { + return Error("Failed to write yet more maxp"); } return true; } -void ots_maxp_reuse(Font *font, Font *other) { - font->maxp = other->maxp; - font->maxp_reused = true; -} - -void ots_maxp_free(Font *font) { - delete font->maxp; -} - } // namespace ots - -#undef TABLE_NAME diff --git a/gfx/ots/src/maxp.h b/gfx/ots/src/maxp.h index efca0c91a..99dbdc439 100644 --- a/gfx/ots/src/maxp.h +++ b/gfx/ots/src/maxp.h @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -9,7 +9,14 @@ namespace ots { -struct OpenTypeMAXP { +class OpenTypeMAXP : public Table { + public: + explicit OpenTypeMAXP(Font *font, uint32_t tag) + : Table(font, tag, tag) { } + + bool Parse(const uint8_t *data, size_t length); + bool Serialize(OTSStream *out); + uint16_t num_glyphs; bool version_1; diff --git a/gfx/ots/src/metrics.cc b/gfx/ots/src/metrics.cc index cd89f4555..b49d73c5d 100644 --- a/gfx/ots/src/metrics.cc +++ b/gfx/ots/src/metrics.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2011 The Chromium Authors. All rights reserved. +// Copyright (c) 2011-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -11,149 +11,163 @@ // http://www.microsoft.com/typography/otspec/hhea.htm // http://www.microsoft.com/typography/otspec/vhea.htm -#define TABLE_NAME "metrics" // XXX: use individual table names - namespace ots { -bool ParseMetricsHeader(Font *font, Buffer *table, - OpenTypeMetricsHeader *header) { - if (!table->ReadS16(&header->ascent) || - !table->ReadS16(&header->descent) || - !table->ReadS16(&header->linegap) || - !table->ReadU16(&header->adv_width_max) || - !table->ReadS16(&header->min_sb1) || - !table->ReadS16(&header->min_sb2) || - !table->ReadS16(&header->max_extent) || - !table->ReadS16(&header->caret_slope_rise) || - !table->ReadS16(&header->caret_slope_run) || - !table->ReadS16(&header->caret_offset)) { - return OTS_FAILURE_MSG("Failed to read metrics header"); +bool OpenTypeMetricsHeader::Parse(const uint8_t *data, size_t length) { + Buffer table(data, length); + + // Skip already read version. + if (!table.Skip(4)) { + return false; + } + + if (!table.ReadS16(&this->ascent) || + !table.ReadS16(&this->descent) || + !table.ReadS16(&this->linegap) || + !table.ReadU16(&this->adv_width_max) || + !table.ReadS16(&this->min_sb1) || + !table.ReadS16(&this->min_sb2) || + !table.ReadS16(&this->max_extent) || + !table.ReadS16(&this->caret_slope_rise) || + !table.ReadS16(&this->caret_slope_run) || + !table.ReadS16(&this->caret_offset)) { + return Error("Failed to read table"); } - if (header->ascent < 0) { - OTS_WARNING("bad ascent: %d", header->ascent); - header->ascent = 0; + if (this->ascent < 0) { + Warning("bad ascent: %d", this->ascent); + this->ascent = 0; } - if (header->linegap < 0) { - OTS_WARNING("bad linegap: %d", header->linegap); - header->linegap = 0; + if (this->linegap < 0) { + Warning("bad linegap: %d", this->linegap); + this->linegap = 0; } - if (!font->head) { - return OTS_FAILURE_MSG("Missing head font table"); + OpenTypeHEAD *head = static_cast<OpenTypeHEAD*>( + GetFont()->GetTypedTable(OTS_TAG_HEAD)); + if (!head) { + return Error("Missing head font table"); } // if the font is non-slanted, caret_offset should be zero. - if (!(font->head->mac_style & 2) && - (header->caret_offset != 0)) { - OTS_WARNING("bad caret offset: %d", header->caret_offset); - header->caret_offset = 0; + if (!(head->mac_style & 2) && + (this->caret_offset != 0)) { + Warning("bad caret offset: %d", this->caret_offset); + this->caret_offset = 0; } // skip the reserved bytes - if (!table->Skip(8)) { - return OTS_FAILURE_MSG("Failed to skip reserverd bytes"); + if (!table.Skip(8)) { + return Error("Failed to read reserverd bytes"); } int16_t data_format; - if (!table->ReadS16(&data_format)) { - return OTS_FAILURE_MSG("Failed to read data format"); + if (!table.ReadS16(&data_format)) { + return Error("Failed to read metricDataFormat"); } if (data_format) { - return OTS_FAILURE_MSG("Bad data format %d", data_format); + return Error("Bad metricDataFormat: %d", data_format); } - if (!table->ReadU16(&header->num_metrics)) { - return OTS_FAILURE_MSG("Failed to read number of metrics"); + if (!table.ReadU16(&this->num_metrics)) { + return Error("Failed to read number of metrics"); } - if (!font->maxp) { - return OTS_FAILURE_MSG("Missing maxp font table"); + OpenTypeMAXP *maxp = static_cast<OpenTypeMAXP*>( + GetFont()->GetTypedTable(OTS_TAG_MAXP)); + if (!maxp) { + return Error("Missing maxp font table"); } - if (header->num_metrics > font->maxp->num_glyphs) { - return OTS_FAILURE_MSG("Bad number of metrics %d", header->num_metrics); + if (this->num_metrics > maxp->num_glyphs) { + return Error("Bad number of metrics %d", this->num_metrics); } return true; } -bool SerialiseMetricsHeader(const ots::Font *font, - OTSStream *out, - const OpenTypeMetricsHeader *header) { - if (!out->WriteU32(header->version) || - !out->WriteS16(header->ascent) || - !out->WriteS16(header->descent) || - !out->WriteS16(header->linegap) || - !out->WriteU16(header->adv_width_max) || - !out->WriteS16(header->min_sb1) || - !out->WriteS16(header->min_sb2) || - !out->WriteS16(header->max_extent) || - !out->WriteS16(header->caret_slope_rise) || - !out->WriteS16(header->caret_slope_run) || - !out->WriteS16(header->caret_offset) || +bool OpenTypeMetricsHeader::Serialize(OTSStream *out) { + if (!out->WriteU32(this->version) || + !out->WriteS16(this->ascent) || + !out->WriteS16(this->descent) || + !out->WriteS16(this->linegap) || + !out->WriteU16(this->adv_width_max) || + !out->WriteS16(this->min_sb1) || + !out->WriteS16(this->min_sb2) || + !out->WriteS16(this->max_extent) || + !out->WriteS16(this->caret_slope_rise) || + !out->WriteS16(this->caret_slope_run) || + !out->WriteS16(this->caret_offset) || !out->WriteR64(0) || // reserved !out->WriteS16(0) || // metric data format - !out->WriteU16(header->num_metrics)) { - return OTS_FAILURE_MSG("Failed to write metrics"); + !out->WriteU16(this->num_metrics)) { + return Error("Failed to write metrics"); } return true; } -bool ParseMetricsTable(const ots::Font *font, - Buffer *table, - const uint16_t num_glyphs, - const OpenTypeMetricsHeader *header, - OpenTypeMetricsTable *metrics) { +bool OpenTypeMetricsTable::Parse(const uint8_t *data, size_t length) { + Buffer table(data, length); + + // OpenTypeMetricsHeader is a superclass of both 'hhea' and 'vhea', + // so the cast here is OK, whichever m_header_tag we have. + OpenTypeMetricsHeader *header = static_cast<OpenTypeMetricsHeader*>( + GetFont()->GetTypedTable(m_header_tag)); + if (!header) { + return Error("Required %c%c%c%c table missing", OTS_UNTAG(m_header_tag)); + } // |num_metrics| is a uint16_t, so it's bounded < 65536. This limits that // amount of memory that we'll allocate for this to a sane amount. const unsigned num_metrics = header->num_metrics; - if (num_metrics > num_glyphs) { - return OTS_FAILURE_MSG("Bad number of metrics %d", num_metrics); + OpenTypeMAXP *maxp = static_cast<OpenTypeMAXP*>( + GetFont()->GetTypedTable(OTS_TAG_MAXP)); + if (!maxp) { + return Error("Required maxp table missing"); + } + if (num_metrics > maxp->num_glyphs) { + return Error("Bad number of metrics %d", num_metrics); } if (!num_metrics) { - return OTS_FAILURE_MSG("No metrics!"); + return Error("No metrics!"); } - const unsigned num_sbs = num_glyphs - num_metrics; + const unsigned num_sbs = maxp->num_glyphs - num_metrics; - metrics->entries.reserve(num_metrics); + this->entries.reserve(num_metrics); for (unsigned i = 0; i < num_metrics; ++i) { uint16_t adv = 0; int16_t sb = 0; - if (!table->ReadU16(&adv) || !table->ReadS16(&sb)) { - return OTS_FAILURE_MSG("Failed to read metric %d", i); + if (!table.ReadU16(&adv) || !table.ReadS16(&sb)) { + return Error("Failed to read metric %d", i); } - metrics->entries.push_back(std::make_pair(adv, sb)); + this->entries.push_back(std::make_pair(adv, sb)); } - metrics->sbs.reserve(num_sbs); + this->sbs.reserve(num_sbs); for (unsigned i = 0; i < num_sbs; ++i) { int16_t sb; - if (!table->ReadS16(&sb)) { + if (!table.ReadS16(&sb)) { // Some Japanese fonts (e.g., mona.ttf) fail this test. - return OTS_FAILURE_MSG("Failed to read side bearing %d", i + num_metrics); + return Error("Failed to read side bearing %d", i + num_metrics); } - metrics->sbs.push_back(sb); + this->sbs.push_back(sb); } return true; } -bool SerialiseMetricsTable(const ots::Font *font, - OTSStream *out, - const OpenTypeMetricsTable *metrics) { - for (unsigned i = 0; i < metrics->entries.size(); ++i) { - if (!out->WriteU16(metrics->entries[i].first) || - !out->WriteS16(metrics->entries[i].second)) { - return OTS_FAILURE_MSG("Failed to write metric %d", i); +bool OpenTypeMetricsTable::Serialize(OTSStream *out) { + for (unsigned i = 0; i < this->entries.size(); ++i) { + if (!out->WriteU16(this->entries[i].first) || + !out->WriteS16(this->entries[i].second)) { + return Error("Failed to write metric %d", i); } } - for (unsigned i = 0; i < metrics->sbs.size(); ++i) { - if (!out->WriteS16(metrics->sbs[i])) { - return OTS_FAILURE_MSG("Failed to write side bearing %ld", i + metrics->entries.size()); + for (unsigned i = 0; i < this->sbs.size(); ++i) { + if (!out->WriteS16(this->sbs[i])) { + return Error("Failed to write side bearing %ld", i + this->entries.size()); } } @@ -161,5 +175,3 @@ bool SerialiseMetricsTable(const ots::Font *font, } } // namespace ots - -#undef TABLE_NAME diff --git a/gfx/ots/src/metrics.h b/gfx/ots/src/metrics.h index 767be2fdb..efe14c070 100644 --- a/gfx/ots/src/metrics.h +++ b/gfx/ots/src/metrics.h @@ -1,4 +1,4 @@ -// Copyright (c) 2011 The Chromium Authors. All rights reserved. +// Copyright (c) 2011-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -13,7 +13,14 @@ namespace ots { -struct OpenTypeMetricsHeader { +class OpenTypeMetricsHeader : public Table { + public: + explicit OpenTypeMetricsHeader(Font *font, uint32_t tag, uint32_t type) + : Table(font, tag, type) { } + + bool Parse(const uint8_t *data, size_t length); + bool Serialize(OTSStream *out); + uint32_t version; int16_t ascent; int16_t descent; @@ -28,27 +35,22 @@ struct OpenTypeMetricsHeader { uint16_t num_metrics; }; -struct OpenTypeMetricsTable { +struct OpenTypeMetricsTable : public Table { + public: + explicit OpenTypeMetricsTable(Font *font, uint32_t tag, uint32_t type, + uint32_t header_tag) + : Table(font, tag, type), m_header_tag(header_tag) { } + + bool Parse(const uint8_t *data, size_t length); + bool Serialize(OTSStream *out); + + private: + uint32_t m_header_tag; + std::vector<std::pair<uint16_t, int16_t> > entries; std::vector<int16_t> sbs; }; -bool ParseMetricsHeader(Font *font, Buffer *table, - OpenTypeMetricsHeader *header); -bool SerialiseMetricsHeader(const ots::Font *font, - OTSStream *out, - const OpenTypeMetricsHeader *header); - -bool ParseMetricsTable(const ots::Font *font, - Buffer *table, - const uint16_t num_glyphs, - const OpenTypeMetricsHeader *header, - OpenTypeMetricsTable *metrics); -bool SerialiseMetricsTable(const ots::Font *font, - OTSStream *out, - const OpenTypeMetricsTable *metrics); - } // namespace ots #endif // OTS_METRICS_H_ - diff --git a/gfx/ots/src/moz.build b/gfx/ots/src/moz.build index f8e60d5f8..962a86a5b 100644 --- a/gfx/ots/src/moz.build +++ b/gfx/ots/src/moz.build @@ -9,41 +9,52 @@ EXPORTS += [ '../include/ots-memory-stream.h', ] -SOURCES += [ - # don't unify sources that use a (file-specific) DROP_THIS_TABLE macro - 'gasp.cc', - 'gdef.cc', - 'gpos.cc', - 'gsub.cc', - 'hdmx.cc', - 'kern.cc', - 'ltsh.cc', - 'math.cc', - 'vdmx.cc', - 'vorg.cc', -] - UNIFIED_SOURCES += [ + 'avar.cc', 'cff.cc', - 'cff_type2_charstring.cc', + 'cff_charstring.cc', 'cmap.cc', + 'cvar.cc', 'cvt.cc', + 'feat.cc', 'fpgm.cc', + 'fvar.cc', + 'gasp.cc', + 'gdef.cc', + 'glat.cc', + 'gloc.cc', 'glyf.cc', + 'gpos.cc', + 'gsub.cc', + 'gvar.cc', + 'hdmx.cc', 'head.cc', 'hhea.cc', 'hmtx.cc', + 'hvar.cc', + 'kern.cc', 'layout.cc', 'loca.cc', + 'ltsh.cc', + 'math.cc', 'maxp.cc', 'metrics.cc', + 'mvar.cc', 'name.cc', 'os2.cc', 'ots.cc', 'post.cc', 'prep.cc', + 'sile.cc', + 'silf.cc', + 'sill.cc', + 'stat.cc', + 'variations.cc', + 'vdmx.cc', 'vhea.cc', 'vmtx.cc', + 'vorg.cc', + 'vvar.cc', ] # We allow warnings for third-party code that can be updated from upstream. @@ -53,8 +64,14 @@ FINAL_LIBRARY = 'gkmedias' DEFINES['PACKAGE_VERSION'] = '"moz"' DEFINES['PACKAGE_BUGREPORT'] = '"http://bugzilla.mozilla.org/"' +DEFINES['OTS_GRAPHITE'] = 1 +DEFINES['OTS_VARIATIONS'] = 1 USE_LIBS += [ 'brotli', 'woff2', ] + +LOCAL_INCLUDES += [ + '/modules/woff2/src', +] diff --git a/gfx/ots/src/mvar.cc b/gfx/ots/src/mvar.cc new file mode 100644 index 000000000..d021203d3 --- /dev/null +++ b/gfx/ots/src/mvar.cc @@ -0,0 +1,105 @@ +// Copyright (c) 2018 The OTS 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 "mvar.h" + +#include "variations.h" + +namespace ots { + +// ----------------------------------------------------------------------------- +// OpenTypeMVAR +// ----------------------------------------------------------------------------- + +bool OpenTypeMVAR::Parse(const uint8_t* data, size_t length) { + Buffer table(data, length); + + uint16_t majorVersion; + uint16_t minorVersion; + uint16_t reserved; + uint16_t valueRecordSize; + uint16_t valueRecordCount; + uint16_t itemVariationStoreOffset; + + if (!table.ReadU16(&majorVersion) || + !table.ReadU16(&minorVersion) || + !table.ReadU16(&reserved) || + !table.ReadU16(&valueRecordSize) || + !table.ReadU16(&valueRecordCount) || + !table.ReadU16(&itemVariationStoreOffset)) { + return DropVariations("Failed to read table header"); + } + + if (majorVersion != 1) { + return DropVariations("Unknown table version"); + } + + if (reserved != 0) { + Warning("Expected reserved=0"); + } + + // The spec says that valueRecordSize "must be greater than zero", + // but we don't enforce this in the case where valueRecordCount + // is zero. + // The minimum size for a valueRecord to be valid is 8, for the + // three fields currently defined in the record (see below). + if (valueRecordSize < 8) { + if (valueRecordCount != 0) { + return DropVariations("Value record size too small"); + } + } + + if (valueRecordCount == 0) { + if (itemVariationStoreOffset != 0) { + // The spec says "if valueRecordCount is zero, set to zero", + // but having a variation store even when record count is zero + // should be harmless -- it just won't be useful for anything. + // But we don't need to reject altogether. + Warning("Unexpected item variation store"); + } + } else { + if (itemVariationStoreOffset < table.offset() || itemVariationStoreOffset > length) { + return DropVariations("Invalid item variation store offset"); + } + if (!ParseItemVariationStore(GetFont(), data + itemVariationStoreOffset, + length - itemVariationStoreOffset)) { + return DropVariations("Failed to parse item variation store"); + } + } + + uint32_t prevTag = 0; + size_t offset = table.offset(); + for (unsigned i = 0; i < valueRecordCount; i++) { + uint32_t tag; + uint16_t deltaSetOuterIndex, deltaSetInnerIndex; + if (!table.ReadU32(&tag) || + !table.ReadU16(&deltaSetOuterIndex) || + !table.ReadU16(&deltaSetInnerIndex)) { + return DropVariations("Failed to read value record"); + } + if (tag <= prevTag) { + return DropVariations("Invalid or out-of-order value tag"); + } + prevTag = tag; + // Adjust offset in case additional fields have been added to the + // valueRecord by a new minor version (allowed by spec). + offset += valueRecordSize; + table.set_offset(offset); + } + + this->m_data = data; + this->m_length = length; + + return true; +} + +bool OpenTypeMVAR::Serialize(OTSStream* out) { + if (!out->Write(this->m_data, this->m_length)) { + return Error("Failed to write MVAR table"); + } + + return true; +} + +} // namespace ots diff --git a/gfx/ots/src/mvar.h b/gfx/ots/src/mvar.h new file mode 100644 index 000000000..81fb6155d --- /dev/null +++ b/gfx/ots/src/mvar.h @@ -0,0 +1,31 @@ +// Copyright (c) 2018 The OTS Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef OTS_MVAR_H_ +#define OTS_MVAR_H_ + +#include "ots.h" + +namespace ots { + +// ----------------------------------------------------------------------------- +// OpenTypeMVAR Interface +// ----------------------------------------------------------------------------- + +class OpenTypeMVAR : public Table { + public: + explicit OpenTypeMVAR(Font* font, uint32_t tag) + : Table(font, tag, tag) { } + + bool Parse(const uint8_t* data, size_t length); + bool Serialize(OTSStream* out); + + private: + const uint8_t *m_data; + size_t m_length; +}; + +} // namespace ots + +#endif // OTS_MVAR_H_ diff --git a/gfx/ots/src/name.cc b/gfx/ots/src/name.cc index e55be7537..11deeecaa 100644 --- a/gfx/ots/src/name.cc +++ b/gfx/ots/src/name.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2011 The Chromium Authors. All rights reserved. +// Copyright (c) 2011-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -10,8 +10,6 @@ // name - Naming Table // http://www.microsoft.com/typography/otspec/name.htm -#define TABLE_NAME "name" - namespace { bool ValidInPsName(char c) { @@ -56,25 +54,22 @@ void AssignToUtf16BeFromAscii(std::string* target, namespace ots { -bool ots_name_parse(Font *font, const uint8_t* data, size_t length) { +bool OpenTypeNAME::Parse(const uint8_t* data, size_t length) { Buffer table(data, length); - OpenTypeNAME* name = new OpenTypeNAME; - font->name = name; - uint16_t format = 0; if (!table.ReadU16(&format) || format > 1) { - return OTS_FAILURE_MSG("Failed to read name table format or bad format %d", format); + return Error("Failed to read table format or bad format %d", format); } uint16_t count = 0; if (!table.ReadU16(&count)) { - return OTS_FAILURE_MSG("Failed to read name count"); + return Error("Failed to read name count"); } uint16_t string_offset = 0; if (!table.ReadU16(&string_offset) || string_offset > length) { - return OTS_FAILURE_MSG("Failed to read strings offset"); + return Error("Failed to read or bad stringOffset"); } const char* string_base = reinterpret_cast<const char*>(data) + string_offset; @@ -94,7 +89,7 @@ bool ots_name_parse(Font *font, const uint8_t* data, size_t length) { !table.ReadU16(&rec.name_id) || !table.ReadU16(&name_length) || !table.ReadU16(&name_offset)) { - return OTS_FAILURE_MSG("Failed to read name entry %d", i); + return Error("Failed to read name entry %d", i); } // check platform & encoding, discard names with unknown values switch (rec.platform_id) { @@ -148,40 +143,49 @@ bool ots_name_parse(Font *font, const uint8_t* data, size_t length) { } } - if (!name->names.empty() && !(name->names.back() < rec)) { - OTS_WARNING("name records are not sorted."); + if (!this->names.empty() && !(this->names.back() < rec)) { + Warning("name records are not sorted."); sort_required = true; } - name->names.push_back(rec); + this->names.push_back(rec); + this->name_ids.insert(rec.name_id); } if (format == 1) { // extended name table format with language tags uint16_t lang_tag_count; if (!table.ReadU16(&lang_tag_count)) { - return OTS_FAILURE_MSG("Failed to read language tag count"); + return Error("Failed to read langTagCount"); } for (unsigned i = 0; i < lang_tag_count; ++i) { uint16_t tag_length = 0; uint16_t tag_offset = 0; if (!table.ReadU16(&tag_length) || !table.ReadU16(&tag_offset)) { - return OTS_FAILURE_MSG("Faile to read tag length or offset"); + return Error("Faile to read length or offset for langTagRecord %d", i); } const unsigned tag_end = static_cast<unsigned>(string_offset) + tag_offset + tag_length; if (tag_end > length) { - return OTS_FAILURE_MSG("bad end of tag %d > %ld for name entry %d", tag_end, length, i); + return Error("bad end of tag %d > %ld for langTagRecord %d", tag_end, length, i); + } + // Lang tag is BCP 47 tag per the spec, the recommonded BCP 47 max tag + // length is 35: + // https://tools.ietf.org/html/bcp47#section-4.4.1 + // We are being too generous and allowing for 100 (multiplied by 2 since + // this is UTF-16 string). + if (tag_length > 100 * 2) { + return Error("Too long language tag for LangTagRecord %d: %d", i, tag_length); } std::string tag(string_base + tag_offset, tag_length); - name->lang_tags.push_back(tag); + this->lang_tags.push_back(tag); } } if (table.offset() > string_offset) { // the string storage apparently overlapped the name/tag records; // consider this font to be badly broken - return OTS_FAILURE_MSG("Bad table offset %ld > %d", table.offset(), string_offset); + return Error("Bad table offset %ld > %d", table.offset(), string_offset); } // check existence of required name strings (synthesize if necessary) @@ -207,17 +211,16 @@ bool ots_name_parse(Font *font, const uint8_t* data, size_t length) { // if not, we'll add our fixed versions here bool mac_name[kStdNameCount] = { 0 }; bool win_name[kStdNameCount] = { 0 }; - for (std::vector<NameRecord>::iterator name_iter = name->names.begin(); - name_iter != name->names.end(); ++name_iter) { - const uint16_t id = name_iter->name_id; + for (const auto& name : this->names) { + const uint16_t id = name.name_id; if (id >= kStdNameCount || kStdNames[id] == NULL) { continue; } - if (name_iter->platform_id == 1) { + if (name.platform_id == 1) { mac_name[id] = true; continue; } - if (name_iter->platform_id == 3) { + if (name.platform_id == 3) { win_name[id] = true; continue; } @@ -236,49 +239,41 @@ bool ots_name_parse(Font *font, const uint8_t* data, size_t length) { 1033 /* language_id */ , i /* name_id */); AssignToUtf16BeFromAscii(&win_rec.text, std::string(kStdNames[i])); - name->names.push_back(mac_rec); - name->names.push_back(win_rec); + this->names.push_back(mac_rec); + this->names.push_back(win_rec); sort_required = true; } } if (sort_required) { - std::sort(name->names.begin(), name->names.end()); + std::sort(this->names.begin(), this->names.end()); } return true; } -bool ots_name_should_serialise(Font *font) { - return font->name != NULL; -} - -bool ots_name_serialise(OTSStream* out, Font *font) { - const OpenTypeNAME* name = font->name; - - uint16_t name_count = static_cast<uint16_t>(name->names.size()); - uint16_t lang_tag_count = static_cast<uint16_t>(name->lang_tags.size()); +bool OpenTypeNAME::Serialize(OTSStream* out) { + uint16_t name_count = static_cast<uint16_t>(this->names.size()); + uint16_t lang_tag_count = static_cast<uint16_t>(this->lang_tags.size()); uint16_t format = 0; size_t string_offset = 6 + name_count * 12; - if (name->lang_tags.size() > 0) { + if (this->lang_tags.size() > 0) { // lang tags require a format-1 name table format = 1; string_offset += 2 + lang_tag_count * 4; } if (string_offset > 0xffff) { - return OTS_FAILURE_MSG("Bad string offset %ld", string_offset); + return Error("Bad stringOffset: %ld", string_offset); } if (!out->WriteU16(format) || !out->WriteU16(name_count) || !out->WriteU16(static_cast<uint16_t>(string_offset))) { - return OTS_FAILURE_MSG("Failed to write name header"); + return Error("Failed to write name header"); } std::string string_data; - for (std::vector<NameRecord>::const_iterator name_iter = name->names.begin(); - name_iter != name->names.end(); ++name_iter) { - const NameRecord& rec = *name_iter; + for (const auto& rec : this->names) { if (string_data.size() + rec.text.size() > std::numeric_limits<uint16_t>::max() || !out->WriteU16(rec.platform_id) || @@ -287,44 +282,77 @@ bool ots_name_serialise(OTSStream* out, Font *font) { !out->WriteU16(rec.name_id) || !out->WriteU16(static_cast<uint16_t>(rec.text.size())) || !out->WriteU16(static_cast<uint16_t>(string_data.size())) ) { - return OTS_FAILURE_MSG("Faile to write name entry"); + return Error("Faile to write nameRecord"); } string_data.append(rec.text); } if (format == 1) { if (!out->WriteU16(lang_tag_count)) { - return OTS_FAILURE_MSG("Faile to write language tag count"); + return Error("Faile to write langTagCount"); } - for (std::vector<std::string>::const_iterator tag_iter = - name->lang_tags.begin(); - tag_iter != name->lang_tags.end(); ++tag_iter) { - if (string_data.size() + tag_iter->size() > + for (const auto& tag : this->lang_tags) { + if (string_data.size() + tag.size() > std::numeric_limits<uint16_t>::max() || - !out->WriteU16(static_cast<uint16_t>(tag_iter->size())) || + !out->WriteU16(static_cast<uint16_t>(tag.size())) || !out->WriteU16(static_cast<uint16_t>(string_data.size()))) { - return OTS_FAILURE_MSG("Failed to write string"); + return Error("Failed to write langTagRecord"); } - string_data.append(*tag_iter); + string_data.append(tag); } } if (!out->Write(string_data.data(), string_data.size())) { - return OTS_FAILURE_MSG("Faile to write string data"); + return Error("Faile to write string data"); } return true; } -void ots_name_reuse(Font *font, Font *other) { - font->name = other->name; - font->name_reused = true; -} - -void ots_name_free(Font *font) { - delete font->name; +bool OpenTypeNAME::IsValidNameId(uint16_t nameID, bool addIfMissing) { + if (addIfMissing && !this->name_ids.count(nameID)) { + bool added_unicode = false; + bool added_macintosh = false; + bool added_windows = false; + const size_t names_size = this->names.size(); // original size + for (size_t i = 0; i < names_size; ++i) switch (names[i].platform_id) { + case 0: + if (!added_unicode) { + // If there is an existing NameRecord with platform_id == 0 (Unicode), + // then add a NameRecord for the the specified nameID with arguments + // 0 (Unicode), 0 (v1.0), 0 (unspecified language). + this->names.emplace_back(0, 0, 0, nameID); + this->names.back().text = "NoName"; + added_unicode = true; + } + break; + case 1: + if (!added_macintosh) { + // If there is an existing NameRecord with platform_id == 1 (Macintosh), + // then add a NameRecord for the specified nameID with arguments + // 1 (Macintosh), 0 (Roman), 0 (English). + this->names.emplace_back(1, 0, 0, nameID); + this->names.back().text = "NoName"; + added_macintosh = true; + } + break; + case 3: + if (!added_windows) { + // If there is an existing NameRecord with platform_id == 3 (Windows), + // then add a NameRecord for the specified nameID with arguments + // 3 (Windows), 1 (UCS), 1033 (US English). + this->names.emplace_back(3, 1, 1033, nameID); + this->names.back().text = "NoName"; + added_windows = true; + } + break; + } + if (added_unicode || added_macintosh || added_windows) { + std::sort(this->names.begin(), this->names.end()); + this->name_ids.insert(nameID); + } + } + return this->name_ids.count(nameID); } } // namespace - -#undef TABLE_NAME diff --git a/gfx/ots/src/name.h b/gfx/ots/src/name.h index a11965f46..68c7ac096 100644 --- a/gfx/ots/src/name.h +++ b/gfx/ots/src/name.h @@ -1,4 +1,4 @@ -// Copyright (c) 2011 The Chromium Authors. All rights reserved. +// Copyright (c) 2011-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -9,6 +9,7 @@ #include <string> #include <utility> #include <vector> +#include <unordered_set> #include "ots.h" @@ -43,9 +44,19 @@ struct NameRecord { } }; -struct OpenTypeNAME { +class OpenTypeNAME : public Table { + public: + explicit OpenTypeNAME(Font *font, uint32_t tag) + : Table(font, tag, tag) { } + + bool Parse(const uint8_t *data, size_t length); + bool Serialize(OTSStream *out); + bool IsValidNameId(uint16_t nameID, bool addIfMissing = false); + + private: std::vector<NameRecord> names; std::vector<std::string> lang_tags; + std::unordered_set<uint16_t> name_ids; }; } // namespace ots diff --git a/gfx/ots/src/os2.cc b/gfx/ots/src/os2.cc index fd5cdd1d6..5376a1dbb 100644 --- a/gfx/ots/src/os2.cc +++ b/gfx/ots/src/os2.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -10,77 +10,73 @@ // OS/2 - OS/2 and Windows Metrics // http://www.microsoft.com/typography/otspec/os2.htm -#define TABLE_NAME "OS/2" - namespace ots { -bool ots_os2_parse(Font *font, const uint8_t *data, size_t length) { +bool OpenTypeOS2::Parse(const uint8_t *data, size_t length) { Buffer table(data, length); - OpenTypeOS2 *os2 = new OpenTypeOS2; - font->os2 = os2; - - if (!table.ReadU16(&os2->version) || - !table.ReadS16(&os2->avg_char_width) || - !table.ReadU16(&os2->weight_class) || - !table.ReadU16(&os2->width_class) || - !table.ReadU16(&os2->type) || - !table.ReadS16(&os2->subscript_x_size) || - !table.ReadS16(&os2->subscript_y_size) || - !table.ReadS16(&os2->subscript_x_offset) || - !table.ReadS16(&os2->subscript_y_offset) || - !table.ReadS16(&os2->superscript_x_size) || - !table.ReadS16(&os2->superscript_y_size) || - !table.ReadS16(&os2->superscript_x_offset) || - !table.ReadS16(&os2->superscript_y_offset) || - !table.ReadS16(&os2->strikeout_size) || - !table.ReadS16(&os2->strikeout_position) || - !table.ReadS16(&os2->family_class)) { - return OTS_FAILURE_MSG("Error reading basic table elements"); - } - - if (os2->version > 5) { - return OTS_FAILURE_MSG("Unsupported table version: %u", os2->version); - } - - // Follow WPF Font Selection Model's advice. - if (1 <= os2->weight_class && os2->weight_class <= 9) { - OTS_WARNING("Bad usWeightClass: %u, changing it to: %u", os2->weight_class, os2->weight_class * 100); - os2->weight_class *= 100; - } - // Ditto. - if (os2->weight_class > 999) { - OTS_WARNING("Bad usWeightClass: %u, changing it to: %d", os2->weight_class, 999); - os2->weight_class = 999; - } - - if (os2->width_class < 1) { - OTS_WARNING("Bad usWidthClass: %u, changing it to: %d", os2->width_class, 1); - os2->width_class = 1; - } else if (os2->width_class > 9) { - OTS_WARNING("Bad usWidthClass: %u, changing it to: %d", os2->width_class, 9); - os2->width_class = 9; + if (!table.ReadU16(&this->table.version) || + !table.ReadS16(&this->table.avg_char_width) || + !table.ReadU16(&this->table.weight_class) || + !table.ReadU16(&this->table.width_class) || + !table.ReadU16(&this->table.type) || + !table.ReadS16(&this->table.subscript_x_size) || + !table.ReadS16(&this->table.subscript_y_size) || + !table.ReadS16(&this->table.subscript_x_offset) || + !table.ReadS16(&this->table.subscript_y_offset) || + !table.ReadS16(&this->table.superscript_x_size) || + !table.ReadS16(&this->table.superscript_y_size) || + !table.ReadS16(&this->table.superscript_x_offset) || + !table.ReadS16(&this->table.superscript_y_offset) || + !table.ReadS16(&this->table.strikeout_size) || + !table.ReadS16(&this->table.strikeout_position) || + !table.ReadS16(&this->table.family_class)) { + return Error("Error reading basic table elements"); + } + + if (this->table.version > 5) { + return Error("Unsupported table version: %u", this->table.version); + } + + if (this->table.weight_class < 1) { + Warning("Bad usWeightClass: %u, changing it to %d", + this->table.weight_class, 1); + this->table.weight_class = 1; + } else if (this->table.weight_class > 1000) { + Warning("Bad usWeightClass: %u, changing it to %d", + this->table.weight_class, 1000); + this->table.weight_class = 1000; + } + + if (this->table.width_class < 1) { + Warning("Bad usWidthClass: %u, changing it to %d", + this->table.width_class, 1); + this->table.width_class = 1; + } else if (this->table.width_class > 9) { + Warning("Bad usWidthClass: %u, changing it to %d", + this->table.width_class, 9); + this->table.width_class = 9; } // lowest 3 bits of fsType are exclusive. - if (os2->type & 0x2) { + if (this->table.type & 0x2) { // mask bits 2 & 3. - os2->type &= 0xfff3u; - } else if (os2->type & 0x4) { + this->table.type &= 0xfff3u; + } else if (this->table.type & 0x4) { // mask bits 1 & 3. - os2->type &= 0xfff4u; - } else if (os2->type & 0x8) { + this->table.type &= 0xfff4u; + } else if (this->table.type & 0x8) { // mask bits 1 & 2. - os2->type &= 0xfff9u; + this->table.type &= 0xfff9u; } // mask reserved bits. use only 0..3, 8, 9 bits. - os2->type &= 0x30f; + this->table.type &= 0x30f; -#define SET_TO_ZERO(a, b) \ - if (os2->b < 0) { \ - OTS_WARNING("Bad " a ": %d, setting it to zero", os2->b); \ - os2->b = 0; \ +#define SET_TO_ZERO(a, b) \ + if (this->table.b < 0) { \ + Warning("Bad " a ": %d, setting it to zero", this->table.b); \ + this->table.b = 0; \ } SET_TO_ZERO("ySubscriptXSize", subscript_x_size); @@ -90,7 +86,7 @@ bool ots_os2_parse(Font *font, const uint8_t *data, size_t length) { SET_TO_ZERO("yStrikeoutSize", strikeout_size); #undef SET_TO_ZERO - static std::string panose_strings[10] = { + static const char* panose_strings[10] = { "bFamilyType", "bSerifStyle", "bWeight", @@ -103,234 +99,222 @@ bool ots_os2_parse(Font *font, const uint8_t *data, size_t length) { "bXHeight", }; for (unsigned i = 0; i < 10; ++i) { - if (!table.ReadU8(&os2->panose[i])) { - return OTS_FAILURE_MSG("Error reading PANOSE %s", panose_strings[i].c_str()); + if (!table.ReadU8(&this->table.panose[i])) { + return Error("Failed to read PANOSE %s", panose_strings[i]); } } - if (!table.ReadU32(&os2->unicode_range_1) || - !table.ReadU32(&os2->unicode_range_2) || - !table.ReadU32(&os2->unicode_range_3) || - !table.ReadU32(&os2->unicode_range_4) || - !table.ReadU32(&os2->vendor_id) || - !table.ReadU16(&os2->selection) || - !table.ReadU16(&os2->first_char_index) || - !table.ReadU16(&os2->last_char_index) || - !table.ReadS16(&os2->typo_ascender) || - !table.ReadS16(&os2->typo_descender) || - !table.ReadS16(&os2->typo_linegap) || - !table.ReadU16(&os2->win_ascent) || - !table.ReadU16(&os2->win_descent)) { - return OTS_FAILURE_MSG("Error reading more basic table fields"); + if (!table.ReadU32(&this->table.unicode_range_1) || + !table.ReadU32(&this->table.unicode_range_2) || + !table.ReadU32(&this->table.unicode_range_3) || + !table.ReadU32(&this->table.unicode_range_4) || + !table.ReadU32(&this->table.vendor_id) || + !table.ReadU16(&this->table.selection) || + !table.ReadU16(&this->table.first_char_index) || + !table.ReadU16(&this->table.last_char_index) || + !table.ReadS16(&this->table.typo_ascender) || + !table.ReadS16(&this->table.typo_descender) || + !table.ReadS16(&this->table.typo_linegap) || + !table.ReadU16(&this->table.win_ascent) || + !table.ReadU16(&this->table.win_descent)) { + return Error("Error reading more basic table fields"); } // If bit 6 is set, then bits 0 and 5 must be clear. - if (os2->selection & 0x40) { - os2->selection &= 0xffdeu; + if (this->table.selection & 0x40) { + this->table.selection &= 0xffdeu; } // the settings of bits 0 and 1 must be reflected in the macStyle bits // in the 'head' table. - if (!font->head) { - return OTS_FAILURE_MSG("Needed head table is missing from the font"); - } - if ((os2->selection & 0x1) && - !(font->head->mac_style & 0x2)) { - OTS_WARNING("adjusting Mac style (italic)"); - font->head->mac_style |= 0x2; + OpenTypeHEAD *head = static_cast<OpenTypeHEAD*>( + GetFont()->GetTypedTable(OTS_TAG_HEAD)); + + if ((this->table.selection & 0x1) && + head && !(head->mac_style & 0x2)) { + Warning("Adjusting head.macStyle (italic) to match fsSelection"); + head->mac_style |= 0x2; } - if ((os2->selection & 0x2) && - !(font->head->mac_style & 0x4)) { - OTS_WARNING("adjusting Mac style (underscore)"); - font->head->mac_style |= 0x4; + if ((this->table.selection & 0x2) && + head && !(head->mac_style & 0x4)) { + Warning("Adjusting head.macStyle (underscore) to match fsSelection"); + head->mac_style |= 0x4; } // While bit 6 on implies that bits 0 and 1 of macStyle are clear, // the reverse is not true. - if ((os2->selection & 0x40) && - (font->head->mac_style & 0x3)) { - OTS_WARNING("adjusting Mac style (regular)"); - font->head->mac_style &= 0xfffcu; + if ((this->table.selection & 0x40) && + head && (head->mac_style & 0x3)) { + Warning("Adjusting head.macStyle (regular) to match fsSelection"); + head->mac_style &= 0xfffcu; } - if ((os2->version < 4) && - (os2->selection & 0x300)) { + if ((this->table.version < 4) && + (this->table.selection & 0x300)) { // bit 8 and 9 must be unset in OS/2 table versions less than 4. - return OTS_FAILURE_MSG("Version %d incompatible with selection %d", os2->version, os2->selection); + Warning("fsSelection bits 8 and 9 must be unset for table version %d", + this->table.version); } // mask reserved bits. use only 0..9 bits. - os2->selection &= 0x3ff; + this->table.selection &= 0x3ff; - if (os2->first_char_index > os2->last_char_index) { - return OTS_FAILURE_MSG("first char index %d > last char index %d in os2", os2->first_char_index, os2->last_char_index); + if (this->table.first_char_index > this->table.last_char_index) { + Warning("usFirstCharIndex %d > usLastCharIndex %d", + this->table.first_char_index, this->table.last_char_index); + this->table.first_char_index = this->table.last_char_index; } - if (os2->typo_linegap < 0) { - OTS_WARNING("bad linegap: %d", os2->typo_linegap); - os2->typo_linegap = 0; + if (this->table.typo_linegap < 0) { + Warning("Bad sTypoLineGap, setting it to 0: %d", this->table.typo_linegap); + this->table.typo_linegap = 0; } - if (os2->version < 1) { + if (this->table.version < 1) { // http://www.microsoft.com/typography/otspec/os2ver0.htm return true; } - if (length < offsetof(OpenTypeOS2, code_page_range_2)) { - OTS_WARNING("bad version number: %u", os2->version); + if (length < offsetof(OS2Data, code_page_range_2)) { + Warning("Bad version number, setting it to 0: %u", this->table.version); // Some fonts (e.g., kredit1.ttf and quinquef.ttf) have weird version // numbers. Fix them. - os2->version = 0; + this->table.version = 0; return true; } - if (!table.ReadU32(&os2->code_page_range_1) || - !table.ReadU32(&os2->code_page_range_2)) { - return OTS_FAILURE_MSG("Failed to read codepage ranges"); + if (!table.ReadU32(&this->table.code_page_range_1) || + !table.ReadU32(&this->table.code_page_range_2)) { + return Error("Failed to read ulCodePageRange1 or ulCodePageRange2"); } - if (os2->version < 2) { + if (this->table.version < 2) { // http://www.microsoft.com/typography/otspec/os2ver1.htm return true; } - if (length < offsetof(OpenTypeOS2, max_context)) { - OTS_WARNING("bad version number: %u", os2->version); + if (length < offsetof(OS2Data, max_context)) { + Warning("Bad version number, setting it to 1: %u", this->table.version); // some Japanese fonts (e.g., mona.ttf) have weird version number. // fix them. - os2->version = 1; + this->table.version = 1; return true; } - if (!table.ReadS16(&os2->x_height) || - !table.ReadS16(&os2->cap_height) || - !table.ReadU16(&os2->default_char) || - !table.ReadU16(&os2->break_char) || - !table.ReadU16(&os2->max_context)) { - return OTS_FAILURE_MSG("Failed to read version 2-specific fields"); + if (!table.ReadS16(&this->table.x_height) || + !table.ReadS16(&this->table.cap_height) || + !table.ReadU16(&this->table.default_char) || + !table.ReadU16(&this->table.break_char) || + !table.ReadU16(&this->table.max_context)) { + return Error("Failed to read version 2-specific fields"); } - if (os2->x_height < 0) { - OTS_WARNING("bad x_height: %d", os2->x_height); - os2->x_height = 0; + if (this->table.x_height < 0) { + Warning("Bad sxHeight settig it to 0: %d", this->table.x_height); + this->table.x_height = 0; } - if (os2->cap_height < 0) { - OTS_WARNING("bad cap_height: %d", os2->cap_height); - os2->cap_height = 0; + if (this->table.cap_height < 0) { + Warning("Bad sCapHeight setting it to 0: %d", this->table.cap_height); + this->table.cap_height = 0; } - if (os2->version < 5) { + if (this->table.version < 5) { // http://www.microsoft.com/typography/otspec/os2ver4.htm return true; } - if (!table.ReadU16(&os2->lower_optical_pointsize) || - !table.ReadU16(&os2->upper_optical_pointsize)) { - return OTS_FAILURE_MSG("Failed to read version 5-specific fields"); + if (!table.ReadU16(&this->table.lower_optical_pointsize) || + !table.ReadU16(&this->table.upper_optical_pointsize)) { + return Error("Failed to read version 5-specific fields"); } - if (os2->lower_optical_pointsize > 0xFFFE) { - OTS_WARNING("'usLowerOpticalPointSize' is bigger than 0xFFFE: %d", os2->lower_optical_pointsize); - os2->lower_optical_pointsize = 0xFFFE; + if (this->table.lower_optical_pointsize > 0xFFFE) { + Warning("usLowerOpticalPointSize is bigger than 0xFFFE: %d", + this->table.lower_optical_pointsize); + this->table.lower_optical_pointsize = 0xFFFE; } - if (os2->upper_optical_pointsize < 2) { - OTS_WARNING("'usUpperOpticalPointSize' is lower than 2: %d", os2->upper_optical_pointsize); - os2->upper_optical_pointsize = 2; + if (this->table.upper_optical_pointsize < 2) { + Warning("usUpperOpticalPointSize is lower than 2: %d", + this->table.upper_optical_pointsize); + this->table.upper_optical_pointsize = 2; } return true; } -bool ots_os2_should_serialise(Font *font) { - return font->os2 != NULL; -} - -bool ots_os2_serialise(OTSStream *out, Font *font) { - const OpenTypeOS2 *os2 = font->os2; - - if (!out->WriteU16(os2->version) || - !out->WriteS16(os2->avg_char_width) || - !out->WriteU16(os2->weight_class) || - !out->WriteU16(os2->width_class) || - !out->WriteU16(os2->type) || - !out->WriteS16(os2->subscript_x_size) || - !out->WriteS16(os2->subscript_y_size) || - !out->WriteS16(os2->subscript_x_offset) || - !out->WriteS16(os2->subscript_y_offset) || - !out->WriteS16(os2->superscript_x_size) || - !out->WriteS16(os2->superscript_y_size) || - !out->WriteS16(os2->superscript_x_offset) || - !out->WriteS16(os2->superscript_y_offset) || - !out->WriteS16(os2->strikeout_size) || - !out->WriteS16(os2->strikeout_position) || - !out->WriteS16(os2->family_class)) { - return OTS_FAILURE_MSG("Failed to write basic OS2 information"); +bool OpenTypeOS2::Serialize(OTSStream *out) { + if (!out->WriteU16(this->table.version) || + !out->WriteS16(this->table.avg_char_width) || + !out->WriteU16(this->table.weight_class) || + !out->WriteU16(this->table.width_class) || + !out->WriteU16(this->table.type) || + !out->WriteS16(this->table.subscript_x_size) || + !out->WriteS16(this->table.subscript_y_size) || + !out->WriteS16(this->table.subscript_x_offset) || + !out->WriteS16(this->table.subscript_y_offset) || + !out->WriteS16(this->table.superscript_x_size) || + !out->WriteS16(this->table.superscript_y_size) || + !out->WriteS16(this->table.superscript_x_offset) || + !out->WriteS16(this->table.superscript_y_offset) || + !out->WriteS16(this->table.strikeout_size) || + !out->WriteS16(this->table.strikeout_position) || + !out->WriteS16(this->table.family_class)) { + return Error("Failed to write basic table data"); } for (unsigned i = 0; i < 10; ++i) { - if (!out->Write(&os2->panose[i], 1)) { - return OTS_FAILURE_MSG("Failed to write os2 panose information"); + if (!out->Write(&this->table.panose[i], 1)) { + return Error("Failed to write PANOSE data"); } } - if (!out->WriteU32(os2->unicode_range_1) || - !out->WriteU32(os2->unicode_range_2) || - !out->WriteU32(os2->unicode_range_3) || - !out->WriteU32(os2->unicode_range_4) || - !out->WriteU32(os2->vendor_id) || - !out->WriteU16(os2->selection) || - !out->WriteU16(os2->first_char_index) || - !out->WriteU16(os2->last_char_index) || - !out->WriteS16(os2->typo_ascender) || - !out->WriteS16(os2->typo_descender) || - !out->WriteS16(os2->typo_linegap) || - !out->WriteU16(os2->win_ascent) || - !out->WriteU16(os2->win_descent)) { - return OTS_FAILURE_MSG("Failed to write version 1-specific fields"); + if (!out->WriteU32(this->table.unicode_range_1) || + !out->WriteU32(this->table.unicode_range_2) || + !out->WriteU32(this->table.unicode_range_3) || + !out->WriteU32(this->table.unicode_range_4) || + !out->WriteU32(this->table.vendor_id) || + !out->WriteU16(this->table.selection) || + !out->WriteU16(this->table.first_char_index) || + !out->WriteU16(this->table.last_char_index) || + !out->WriteS16(this->table.typo_ascender) || + !out->WriteS16(this->table.typo_descender) || + !out->WriteS16(this->table.typo_linegap) || + !out->WriteU16(this->table.win_ascent) || + !out->WriteU16(this->table.win_descent)) { + return Error("Failed to write version 1-specific fields"); } - if (os2->version < 1) { + if (this->table.version < 1) { return true; } - if (!out->WriteU32(os2->code_page_range_1) || - !out->WriteU32(os2->code_page_range_2)) { - return OTS_FAILURE_MSG("Failed to write codepage ranges"); + if (!out->WriteU32(this->table.code_page_range_1) || + !out->WriteU32(this->table.code_page_range_2)) { + return Error("Failed to write codepage ranges"); } - if (os2->version < 2) { + if (this->table.version < 2) { return true; } - if (!out->WriteS16(os2->x_height) || - !out->WriteS16(os2->cap_height) || - !out->WriteU16(os2->default_char) || - !out->WriteU16(os2->break_char) || - !out->WriteU16(os2->max_context)) { - return OTS_FAILURE_MSG("Failed to write version 2-specific fields"); + if (!out->WriteS16(this->table.x_height) || + !out->WriteS16(this->table.cap_height) || + !out->WriteU16(this->table.default_char) || + !out->WriteU16(this->table.break_char) || + !out->WriteU16(this->table.max_context)) { + return Error("Failed to write version 2-specific fields"); } - if (os2->version < 5) { + if (this->table.version < 5) { return true; } - if (!out->WriteU16(os2->lower_optical_pointsize) || - !out->WriteU16(os2->upper_optical_pointsize)) { - return OTS_FAILURE_MSG("Failed to write version 5-specific fields"); + if (!out->WriteU16(this->table.lower_optical_pointsize) || + !out->WriteU16(this->table.upper_optical_pointsize)) { + return Error("Failed to write version 5-specific fields"); } return true; } -void ots_os2_reuse(Font *font, Font *other) { - font->os2 = other->os2; - font->os2_reused = true; -} - -void ots_os2_free(Font *font) { - delete font->os2; -} - } // namespace ots - -#undef TABLE_NAME diff --git a/gfx/ots/src/os2.h b/gfx/ots/src/os2.h index 01511c5dc..b3f1bad9b 100644 --- a/gfx/ots/src/os2.h +++ b/gfx/ots/src/os2.h @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -9,7 +9,7 @@ namespace ots { -struct OpenTypeOS2 { +struct OS2Data { uint16_t version; int16_t avg_char_width; uint16_t weight_class; @@ -51,6 +51,17 @@ struct OpenTypeOS2 { uint16_t upper_optical_pointsize; }; +class OpenTypeOS2 : public Table { + public: + explicit OpenTypeOS2(Font *font, uint32_t tag) + : Table(font, tag, tag) { } + + bool Parse(const uint8_t *data, size_t length); + bool Serialize(OTSStream *out); + + OS2Data table; +}; + } // namespace ots #endif // OTS_OS2_H_ diff --git a/gfx/ots/src/ots.cc b/gfx/ots/src/ots.cc index 15794475a..38d97a9ed 100644 --- a/gfx/ots/src/ots.cc +++ b/gfx/ots/src/ots.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -14,25 +14,75 @@ #include <map> #include <vector> -#include "woff2_dec.h" +#include <woff2/decode.h> // The OpenType Font File -// http://www.microsoft.com/typography/otspec/cmap.htm +// http://www.microsoft.com/typography/otspec/otff.htm + +#include "avar.h" +#include "cff.h" +#include "cmap.h" +#include "cvar.h" +#include "cvt.h" +#include "fpgm.h" +#include "fvar.h" +#include "gasp.h" +#include "gdef.h" +#include "glyf.h" +#include "gpos.h" +#include "gsub.h" +#include "gvar.h" +#include "hdmx.h" +#include "head.h" +#include "hhea.h" +#include "hmtx.h" +#include "hvar.h" +#include "kern.h" +#include "loca.h" +#include "ltsh.h" +#include "math_.h" +#include "maxp.h" +#include "mvar.h" +#include "name.h" +#include "os2.h" +#include "ots.h" +#include "post.h" +#include "prep.h" +#include "stat.h" +#include "vdmx.h" +#include "vhea.h" +#include "vmtx.h" +#include "vorg.h" +#include "vvar.h" + +// Graphite tables +#ifdef OTS_GRAPHITE +#include "feat.h" +#include "glat.h" +#include "gloc.h" +#include "sile.h" +#include "silf.h" +#include "sill.h" +#endif -namespace { +namespace ots { -// Generate a message with or without a table tag, when 'header' is the OpenTypeFile pointer -#define OTS_FAILURE_MSG_TAG(msg_,tag_) OTS_FAILURE_MSG_TAG_(header, msg_, tag_) -#define OTS_FAILURE_MSG_HDR(msg_) OTS_FAILURE_MSG_(header, msg_) -#define OTS_WARNING_MSG_HDR(msg_) OTS_WARNING_MSG_(header, msg_) +struct Arena { + public: + ~Arena() { + for (auto& hunk : hunks_) { + delete[] hunk; + } + } + uint8_t* Allocate(size_t length) { + uint8_t* p = new uint8_t[length]; + hunks_.push_back(p); + return p; + } -struct OpenTypeTable { - uint32_t tag; - uint32_t chksum; - uint32_t offset; - uint32_t length; - uint32_t uncompressed_length; + private: + std::vector<uint8_t*> hunks_; }; bool CheckTag(uint32_t tag_value) { @@ -46,99 +96,83 @@ bool CheckTag(uint32_t tag_value) { return true; } -struct Arena { - public: - ~Arena() { - for (std::vector<uint8_t*>::iterator - i = hunks_.begin(); i != hunks_.end(); ++i) { - delete[] *i; - } - } +}; // namespace ots - uint8_t* Allocate(size_t length) { - uint8_t* p = new uint8_t[length]; - hunks_.push_back(p); - return p; - } +namespace { + +#define OTS_MSG_TAG_(level,otf_,msg_,tag_) \ + (OTS_MESSAGE_(level,otf_,"%c%c%c%c: %s", OTS_UNTAG(tag_), msg_), false) + +// Generate a message with or without a table tag, when 'header' is the FontFile pointer +#define OTS_FAILURE_MSG_TAG(msg_,tag_) OTS_MSG_TAG_(0, header, msg_, tag_) +#define OTS_FAILURE_MSG_HDR(...) OTS_FAILURE_MSG_(header, __VA_ARGS__) +#define OTS_WARNING_MSG_HDR(...) OTS_WARNING_MSG_(header, __VA_ARGS__) - private: - std::vector<uint8_t*> hunks_; -}; const struct { uint32_t tag; - bool (*parse)(ots::Font *font, const uint8_t *data, size_t length); - bool (*serialise)(ots::OTSStream *out, ots::Font *font); - bool (*should_serialise)(ots::Font *font); - void (*reuse)(ots::Font *font, ots::Font *other); bool required; -} table_parsers[] = { - { OTS_TAG('m','a','x','p'), ots::ots_maxp_parse, ots::ots_maxp_serialise, - ots::ots_maxp_should_serialise, ots::ots_maxp_reuse, true }, - { OTS_TAG('h','e','a','d'), ots::ots_head_parse, ots::ots_head_serialise, - ots::ots_head_should_serialise, ots::ots_head_reuse, true }, - { OTS_TAG('O','S','/','2'), ots::ots_os2_parse, ots::ots_os2_serialise, - ots::ots_os2_should_serialise, ots::ots_os2_reuse, true }, - { OTS_TAG('c','m','a','p'), ots::ots_cmap_parse, ots::ots_cmap_serialise, - ots::ots_cmap_should_serialise, ots::ots_cmap_reuse, true }, - { OTS_TAG('h','h','e','a'), ots::ots_hhea_parse, ots::ots_hhea_serialise, - ots::ots_hhea_should_serialise, ots::ots_hhea_reuse, true }, - { OTS_TAG('h','m','t','x'), ots::ots_hmtx_parse, ots::ots_hmtx_serialise, - ots::ots_hmtx_should_serialise, ots::ots_hmtx_reuse, true }, - { OTS_TAG('n','a','m','e'), ots::ots_name_parse, ots::ots_name_serialise, - ots::ots_name_should_serialise, ots::ots_name_reuse, true }, - { OTS_TAG('p','o','s','t'), ots::ots_post_parse, ots::ots_post_serialise, - ots::ots_post_should_serialise, ots::ots_post_reuse, true }, - { OTS_TAG('l','o','c','a'), ots::ots_loca_parse, ots::ots_loca_serialise, - ots::ots_loca_should_serialise, ots::ots_loca_reuse, false }, - { OTS_TAG('g','l','y','f'), ots::ots_glyf_parse, ots::ots_glyf_serialise, - ots::ots_glyf_should_serialise, ots::ots_glyf_reuse, false }, - { OTS_TAG('C','F','F',' '), ots::ots_cff_parse, ots::ots_cff_serialise, - ots::ots_cff_should_serialise, ots::ots_cff_reuse, false }, - { OTS_TAG('V','D','M','X'), ots::ots_vdmx_parse, ots::ots_vdmx_serialise, - ots::ots_vdmx_should_serialise, ots::ots_vdmx_reuse, false }, - { OTS_TAG('h','d','m','x'), ots::ots_hdmx_parse, ots::ots_hdmx_serialise, - ots::ots_hdmx_should_serialise, ots::ots_hdmx_reuse, false }, - { OTS_TAG('g','a','s','p'), ots::ots_gasp_parse, ots::ots_gasp_serialise, - ots::ots_gasp_should_serialise, ots::ots_gasp_reuse, false }, - { OTS_TAG('c','v','t',' '), ots::ots_cvt_parse, ots::ots_cvt_serialise, - ots::ots_cvt_should_serialise, ots::ots_cvt_reuse, false }, - { OTS_TAG('f','p','g','m'), ots::ots_fpgm_parse, ots::ots_fpgm_serialise, - ots::ots_fpgm_should_serialise, ots::ots_fpgm_reuse, false }, - { OTS_TAG('p','r','e','p'), ots::ots_prep_parse, ots::ots_prep_serialise, - ots::ots_prep_should_serialise, ots::ots_prep_reuse, false }, - { OTS_TAG('L','T','S','H'), ots::ots_ltsh_parse, ots::ots_ltsh_serialise, - ots::ots_ltsh_should_serialise, ots::ots_ltsh_reuse, false }, - { OTS_TAG('V','O','R','G'), ots::ots_vorg_parse, ots::ots_vorg_serialise, - ots::ots_vorg_should_serialise, ots::ots_vorg_reuse, false }, - { OTS_TAG('k','e','r','n'), ots::ots_kern_parse, ots::ots_kern_serialise, - ots::ots_kern_should_serialise, ots::ots_kern_reuse, false }, +} supported_tables[] = { + { OTS_TAG_MAXP, true }, + { OTS_TAG_HEAD, true }, + { OTS_TAG_OS2, true }, + { OTS_TAG_CMAP, true }, + { OTS_TAG_HHEA, true }, + { OTS_TAG_HMTX, true }, + { OTS_TAG_NAME, true }, + { OTS_TAG_POST, true }, + { OTS_TAG_LOCA, false }, + { OTS_TAG_GLYF, false }, + { OTS_TAG_CFF, false }, + { OTS_TAG_VDMX, false }, + { OTS_TAG_HDMX, false }, + { OTS_TAG_GASP, false }, + { OTS_TAG_CVT, false }, + { OTS_TAG_FPGM, false }, + { OTS_TAG_PREP, false }, + { OTS_TAG_LTSH, false }, + { OTS_TAG_VORG, false }, + { OTS_TAG_KERN, false }, + // We need to parse fvar table before other tables that may need to know + // the number of variation axes (if any) + { OTS_TAG_FVAR, false }, + { OTS_TAG_AVAR, false }, + { OTS_TAG_CVAR, false }, + { OTS_TAG_GVAR, false }, + { OTS_TAG_HVAR, false }, + { OTS_TAG_MVAR, false }, + { OTS_TAG_STAT, false }, + { OTS_TAG_VVAR, false }, + { OTS_TAG_CFF2, false }, // We need to parse GDEF table in advance of parsing GSUB/GPOS tables // because they could refer GDEF table. - { OTS_TAG('G','D','E','F'), ots::ots_gdef_parse, ots::ots_gdef_serialise, - ots::ots_gdef_should_serialise, ots::ots_gdef_reuse, false }, - { OTS_TAG('G','P','O','S'), ots::ots_gpos_parse, ots::ots_gpos_serialise, - ots::ots_gpos_should_serialise, ots::ots_gpos_reuse, false }, - { OTS_TAG('G','S','U','B'), ots::ots_gsub_parse, ots::ots_gsub_serialise, - ots::ots_gsub_should_serialise, ots::ots_gsub_reuse, false }, - { OTS_TAG('v','h','e','a'), ots::ots_vhea_parse, ots::ots_vhea_serialise, - ots::ots_vhea_should_serialise, ots::ots_vhea_reuse, false }, - { OTS_TAG('v','m','t','x'), ots::ots_vmtx_parse, ots::ots_vmtx_serialise, - ots::ots_vmtx_should_serialise, ots::ots_vmtx_reuse, false }, - { OTS_TAG('M','A','T','H'), ots::ots_math_parse, ots::ots_math_serialise, - ots::ots_math_should_serialise, ots::ots_math_reuse, false }, - { 0, NULL, NULL, NULL, NULL, false }, + { OTS_TAG_GDEF, false }, + { OTS_TAG_GPOS, false }, + { OTS_TAG_GSUB, false }, + { OTS_TAG_VHEA, false }, + { OTS_TAG_VMTX, false }, + { OTS_TAG_MATH, false }, + // Graphite tables +#ifdef OTS_GRAPHITE + { OTS_TAG_GLOC, false }, + { OTS_TAG_GLAT, false }, + { OTS_TAG_FEAT, false }, + { OTS_TAG_SILF, false }, + { OTS_TAG_SILE, false }, + { OTS_TAG_SILL, false }, +#endif + { 0, false }, }; -bool ProcessGeneric(ots::OpenTypeFile *header, +bool ProcessGeneric(ots::FontFile *header, ots::Font *font, uint32_t signature, ots::OTSStream *output, const uint8_t *data, size_t length, - const std::vector<OpenTypeTable>& tables, + const std::vector<ots::TableEntry>& tables, ots::Buffer& file); -bool ProcessTTF(ots::OpenTypeFile *header, +bool ProcessTTF(ots::FontFile *header, ots::Font *font, ots::OTSStream *output, const uint8_t *data, size_t length, uint32_t offset = 0) { @@ -202,10 +236,10 @@ bool ProcessTTF(ots::OpenTypeFile *header, } // Next up is the list of tables. - std::vector<OpenTypeTable> tables; + std::vector<ots::TableEntry> tables; for (unsigned i = 0; i < font->num_tables; ++i) { - OpenTypeTable table; + ots::TableEntry table; if (!file.ReadU32(&table.tag) || !file.ReadU32(&table.chksum) || !file.ReadU32(&table.offset) || @@ -221,7 +255,7 @@ bool ProcessTTF(ots::OpenTypeFile *header, tables, file); } -bool ProcessTTC(ots::OpenTypeFile *header, +bool ProcessTTC(ots::FontFile *header, ots::OTSStream *output, const uint8_t *data, size_t length, @@ -308,7 +342,7 @@ bool ProcessTTC(ots::OpenTypeFile *header, } } -bool ProcessWOFF(ots::OpenTypeFile *header, +bool ProcessWOFF(ots::FontFile *header, ots::Font *font, ots::OTSStream *output, const uint8_t *data, size_t length) { ots::Buffer file(data, length); @@ -388,14 +422,14 @@ bool ProcessWOFF(ots::OpenTypeFile *header, } // Next up is the list of tables. - std::vector<OpenTypeTable> tables; + std::vector<ots::TableEntry> tables; uint32_t first_index = 0; uint32_t last_index = 0; // Size of sfnt header plus size of table records. uint64_t total_sfnt_size = 12 + 16 * font->num_tables; for (unsigned i = 0; i < font->num_tables; ++i) { - OpenTypeTable table; + ots::TableEntry table; if (!file.ReadU32(&table.tag) || !file.ReadU32(&table.offset) || !file.ReadU32(&table.length) || @@ -463,13 +497,17 @@ bool ProcessWOFF(ots::OpenTypeFile *header, return ProcessGeneric(header, font, woff_tag, output, data, length, tables, file); } -bool ProcessWOFF2(ots::OpenTypeFile *header, +bool ProcessWOFF2(ots::FontFile *header, ots::OTSStream *output, const uint8_t *data, size_t length, uint32_t index) { size_t decompressed_size = woff2::ComputeWOFF2FinalSize(data, length); + if (decompressed_size < length) { + return OTS_FAILURE_MSG_HDR("Size of decompressed WOFF 2.0 is less than compressed size"); + } + if (decompressed_size == 0) { return OTS_FAILURE_MSG_HDR("Size of decompressed WOFF 2.0 is set to 0"); } @@ -493,16 +531,16 @@ bool ProcessWOFF2(ots::OpenTypeFile *header, } } -ots::TableAction GetTableAction(ots::OpenTypeFile *header, uint32_t tag) { +ots::TableAction GetTableAction(const ots::FontFile *header, uint32_t tag) { ots::TableAction action = header->context->GetTableAction(tag); if (action == ots::TABLE_ACTION_DEFAULT) { action = ots::TABLE_ACTION_DROP; for (unsigned i = 0; ; ++i) { - if (table_parsers[i].parse == NULL) break; + if (supported_tables[i].tag == 0) break; - if (table_parsers[i].tag == tag) { + if (supported_tables[i].tag == tag) { action = ots::TABLE_ACTION_SANITIZE; break; } @@ -514,14 +552,14 @@ ots::TableAction GetTableAction(ots::OpenTypeFile *header, uint32_t tag) { } bool GetTableData(const uint8_t *data, - const OpenTypeTable& table, - Arena *arena, + const ots::TableEntry& table, + ots::Arena &arena, size_t *table_length, const uint8_t **table_data) { if (table.uncompressed_length != table.length) { // Compressed table. Need to uncompress into memory first. *table_length = table.uncompressed_length; - *table_data = (*arena).Allocate(*table_length); + *table_data = arena.Allocate(*table_length); uLongf dest_len = *table_length; int r = uncompress((Bytef*) *table_data, &dest_len, data + table.offset, table.length); @@ -537,12 +575,12 @@ bool GetTableData(const uint8_t *data, return true; } -bool ProcessGeneric(ots::OpenTypeFile *header, +bool ProcessGeneric(ots::FontFile *header, ots::Font *font, uint32_t signature, ots::OTSStream *output, const uint8_t *data, size_t length, - const std::vector<OpenTypeTable>& tables, + const std::vector<ots::TableEntry>& tables, ots::Buffer& file) { const size_t data_offset = file.offset(); @@ -560,8 +598,8 @@ bool ProcessGeneric(ots::OpenTypeFile *header, } // all tag names must be built from printable ASCII characters - if (!CheckTag(tables[i].tag)) { - return OTS_FAILURE_MSG_TAG("invalid table tag", tables[i].tag); + if (!ots::CheckTag(tables[i].tag)) { + OTS_WARNING_MSG_HDR("Invalid table tag: 0x%X", tables[i].tag); } // tables must be 4-byte aligned @@ -616,11 +654,6 @@ bool ProcessGeneric(ots::OpenTypeFile *header, return OTS_FAILURE_MSG_HDR("uncompressed sum exceeds 30MB"); } - std::map<uint32_t, OpenTypeTable> table_map; - for (unsigned i = 0; i < font->num_tables; ++i) { - table_map[tables[i].tag] = tables[i]; - } - // check that the tables are not overlapping. std::vector<std::pair<uint32_t, uint8_t> > overlap_checker; for (unsigned i = 0; i < font->num_tables; ++i) { @@ -639,80 +672,66 @@ bool ProcessGeneric(ots::OpenTypeFile *header, } } - Arena arena; + std::map<uint32_t, ots::TableEntry> table_map; + for (unsigned i = 0; i < font->num_tables; ++i) { + table_map[tables[i].tag] = tables[i]; + } + ots::Arena arena; + // Parse known tables first as we need to parse them in specific order. for (unsigned i = 0; ; ++i) { - if (table_parsers[i].parse == NULL) break; - - uint32_t tag = table_parsers[i].tag; - const std::map<uint32_t, OpenTypeTable>::const_iterator it = table_map.find(tag); + if (supported_tables[i].tag == 0) break; - ots::TableAction action = GetTableAction(header, tag); - if (it == table_map.end()) { - if (table_parsers[i].required && action == ots::TABLE_ACTION_SANITIZE) { - return OTS_FAILURE_MSG_TAG("missing required table", table_parsers[i].tag); + uint32_t tag = supported_tables[i].tag; + const auto &it = table_map.find(tag); + if (it == table_map.cend()) { + if (supported_tables[i].required) { + return OTS_FAILURE_MSG_TAG("missing required table", tag); } - continue; - } - - uint32_t input_offset = it->second.offset; - const ots::TableMap::const_iterator ot = header->tables.find(input_offset); - if (ot == header->tables.end()) { - const uint8_t* table_data; - size_t table_length; - - if (!GetTableData(data, it->second, &arena, &table_length, &table_data)) { - return OTS_FAILURE_MSG_TAG("uncompress failed", table_parsers[i].tag); + } else { + if (!font->ParseTable(it->second, data, arena)) { + return OTS_FAILURE_MSG_TAG("Failed to parse table", tag); } + } + } - if (action == ots::TABLE_ACTION_SANITIZE && - !table_parsers[i].parse(font, table_data, table_length)) { - return OTS_FAILURE(); + // Then parse any tables left. + for (const auto &table_entry : tables) { + if (!font->GetTable(table_entry.tag)) { + if (!font->ParseTable(table_entry, data, arena)) { + return OTS_FAILURE_MSG_TAG("Failed to parse table", table_entry.tag); } - } else if (action == ots::TABLE_ACTION_SANITIZE) { - table_parsers[i].reuse(font, ot->second.first); } } - if (font->cff) { + if (font->GetTable(OTS_TAG_CFF) || font->GetTable(OTS_TAG_CFF2)) { // font with PostScript glyph if (font->version != OTS_TAG('O','T','T','O')) { return OTS_FAILURE_MSG_HDR("wrong font version for PostScript glyph data"); } - if (font->glyf || font->loca) { + if (font->GetTable(OTS_TAG_GLYF) || font->GetTable(OTS_TAG_LOCA)) { // mixing outline formats is not recommended return OTS_FAILURE_MSG_HDR("font contains both PS and TT glyphs"); } } else { - if (!font->glyf || !font->loca) { + if (!font->GetTable(OTS_TAG_GLYF) || !font->GetTable(OTS_TAG_LOCA)) { // No TrueType glyph found. -#define PASSTHRU_TABLE(tag_) (table_map.find(tag_) != table_map.end() && \ - GetTableAction(header, tag_) == ots::TABLE_ACTION_PASSTHRU) - // We don't sanitise bitmap table, but don't reject bitmap-only fonts if - // we keep the tables. - if (!PASSTHRU_TABLE(OTS_TAG('C','B','D','T')) || - !PASSTHRU_TABLE(OTS_TAG('C','B','L','C'))) { + // + // We don't sanitize bitmap tables, but don’t reject bitmap-only fonts if + // we are asked to pass them thru. + // Also don’t reject if we are asked to pass glyf/loca thru. + if (!font->GetTable(OTS_TAG('C','B','D','T')) && + !font->GetTable(OTS_TAG('C','B','L','C'))) { return OTS_FAILURE_MSG_HDR("no supported glyph shapes table(s) present"); } -#undef PASSTHRU_TABLE } } uint16_t num_output_tables = 0; - for (std::map<uint32_t, OpenTypeTable>::const_iterator it = table_map.begin(); - it != table_map.end(); ++it) { - ots::TableAction action = GetTableAction(header, it->first); - if (action == ots::TABLE_ACTION_PASSTHRU) { + for (const auto &it : table_map) { + ots::Table *table = font->GetTable(it.first); + if (table != NULL && table->ShouldSerialize()) num_output_tables++; - } else { - for (unsigned i = 0; table_parsers[i].parse != NULL; ++i) { - if (table_parsers[i].tag == it->first && - table_parsers[i].should_serialise(font)) { - num_output_tables++; - break; - } - } - } } uint16_t max_pow2 = 0; @@ -738,85 +757,49 @@ bool ProcessGeneric(ots::OpenTypeFile *header, return OTS_FAILURE_MSG_HDR("error writing output"); } - std::vector<ots::OutputTable> out_tables; + std::vector<ots::TableEntry> out_tables; size_t head_table_offset = 0; - for (std::map<uint32_t, OpenTypeTable>::const_iterator it = table_map.begin(); - it != table_map.end(); ++it) { - uint32_t input_offset = it->second.offset; - const ots::TableMap::const_iterator ot = header->tables.find(input_offset); - if (ot != header->tables.end()) { - ots::OutputTable out = ot->second.second; + for (const auto &it : table_map) { + uint32_t input_offset = it.second.offset; + const auto &ot = header->table_entries.find(input_offset); + if (ot != header->table_entries.end()) { + ots::TableEntry out = ot->second; if (out.tag == OTS_TAG('h','e','a','d')) { head_table_offset = out.offset; } out_tables.push_back(out); } else { - ots::OutputTable out; - out.tag = it->first; + ots::TableEntry out; + out.tag = it.first; out.offset = output->Tell(); if (out.tag == OTS_TAG('h','e','a','d')) { head_table_offset = out.offset; } - ots::TableAction action = GetTableAction(header, it->first); - if (action == ots::TABLE_ACTION_PASSTHRU) { + ots::Table *table = font->GetTable(out.tag); + if (table != NULL && table->ShouldSerialize()) { output->ResetChecksum(); - const uint8_t* table_data; - size_t table_length; - - if (!GetTableData(data, it->second, &arena, &table_length, &table_data)) { - return OTS_FAILURE_MSG_HDR("Failed to uncompress table"); - } - - if (!output->Write(table_data, table_length)) { - return OTS_FAILURE_MSG_HDR("Failed to serialize table"); + if (!table->Serialize(output)) { + return OTS_FAILURE_MSG_TAG("Failed to serialize table", out.tag); } const size_t end_offset = output->Tell(); if (end_offset <= out.offset) { // paranoid check. |end_offset| is supposed to be greater than the offset, // as long as the Tell() interface is implemented correctly. - return OTS_FAILURE_MSG_HDR("error writing output"); + return OTS_FAILURE_MSG_TAG("Table is empty or have -ve size", out.tag); } out.length = end_offset - out.offset; // align tables to four bytes if (!output->Pad((4 - (end_offset & 3)) % 4)) { - return OTS_FAILURE_MSG_HDR("error writing output"); + return OTS_FAILURE_MSG_TAG("Failed to pad table to 4 bytes", out.tag); } out.chksum = output->chksum(); out_tables.push_back(out); - header->tables[input_offset] = std::make_pair(font, out); - } else { - for (unsigned i = 0; table_parsers[i].parse != NULL; ++i) { - if (table_parsers[i].tag == it->first && - table_parsers[i].should_serialise(font)) { - output->ResetChecksum(); - if (!table_parsers[i].serialise(output, font)) { - return OTS_FAILURE_MSG_TAG("failed to serialize table", table_parsers[i].tag); - } - - const size_t end_offset = output->Tell(); - if (end_offset <= out.offset) { - // paranoid check. |end_offset| is supposed to be greater than the offset, - // as long as the Tell() interface is implemented correctly. - return OTS_FAILURE_MSG_HDR("error writing output"); - } - out.length = end_offset - out.offset; - - // align tables to four bytes - if (!output->Pad((4 - (end_offset & 3)) % 4)) { - return OTS_FAILURE_MSG_HDR("error writing output"); - } - out.chksum = output->chksum(); - out_tables.push_back(out); - header->tables[input_offset] = std::make_pair(font, out); - - break; - } - } + header->table_entries[input_offset] = out; } } } @@ -869,6 +852,225 @@ bool ProcessGeneric(ots::OpenTypeFile *header, namespace ots { +FontFile::~FontFile() { + for (const auto& it : tables) { + delete it.second; + } + tables.clear(); +} + +bool Font::ParseTable(const TableEntry& table_entry, const uint8_t* data, + Arena &arena) { + uint32_t tag = table_entry.tag; + TableAction action = GetTableAction(file, tag); + if (action == TABLE_ACTION_DROP) { + return true; + } + + const auto &it = file->tables.find(table_entry); + if (it != file->tables.end()) { + m_tables[tag] = it->second; + return true; + } + + Table *table = NULL; + bool ret = false; + + if (action == TABLE_ACTION_PASSTHRU) { + table = new TablePassthru(this, tag); + } else { + switch (tag) { + case OTS_TAG_AVAR: table = new OpenTypeAVAR(this, tag); break; + case OTS_TAG_CFF: table = new OpenTypeCFF(this, tag); break; + case OTS_TAG_CFF2: table = new OpenTypeCFF2(this, tag); break; + case OTS_TAG_CMAP: table = new OpenTypeCMAP(this, tag); break; + case OTS_TAG_CVAR: table = new OpenTypeCVAR(this, tag); break; + case OTS_TAG_CVT: table = new OpenTypeCVT(this, tag); break; + case OTS_TAG_FPGM: table = new OpenTypeFPGM(this, tag); break; + case OTS_TAG_FVAR: table = new OpenTypeFVAR(this, tag); break; + case OTS_TAG_GASP: table = new OpenTypeGASP(this, tag); break; + case OTS_TAG_GDEF: table = new OpenTypeGDEF(this, tag); break; + case OTS_TAG_GLYF: table = new OpenTypeGLYF(this, tag); break; + case OTS_TAG_GPOS: table = new OpenTypeGPOS(this, tag); break; + case OTS_TAG_GSUB: table = new OpenTypeGSUB(this, tag); break; + case OTS_TAG_GVAR: table = new OpenTypeGVAR(this, tag); break; + case OTS_TAG_HDMX: table = new OpenTypeHDMX(this, tag); break; + case OTS_TAG_HEAD: table = new OpenTypeHEAD(this, tag); break; + case OTS_TAG_HHEA: table = new OpenTypeHHEA(this, tag); break; + case OTS_TAG_HMTX: table = new OpenTypeHMTX(this, tag); break; + case OTS_TAG_HVAR: table = new OpenTypeHVAR(this, tag); break; + case OTS_TAG_KERN: table = new OpenTypeKERN(this, tag); break; + case OTS_TAG_LOCA: table = new OpenTypeLOCA(this, tag); break; + case OTS_TAG_LTSH: table = new OpenTypeLTSH(this, tag); break; + case OTS_TAG_MATH: table = new OpenTypeMATH(this, tag); break; + case OTS_TAG_MAXP: table = new OpenTypeMAXP(this, tag); break; + case OTS_TAG_MVAR: table = new OpenTypeMVAR(this, tag); break; + case OTS_TAG_NAME: table = new OpenTypeNAME(this, tag); break; + case OTS_TAG_OS2: table = new OpenTypeOS2(this, tag); break; + case OTS_TAG_POST: table = new OpenTypePOST(this, tag); break; + case OTS_TAG_PREP: table = new OpenTypePREP(this, tag); break; + case OTS_TAG_STAT: table = new OpenTypeSTAT(this, tag); break; + case OTS_TAG_VDMX: table = new OpenTypeVDMX(this, tag); break; + case OTS_TAG_VHEA: table = new OpenTypeVHEA(this, tag); break; + case OTS_TAG_VMTX: table = new OpenTypeVMTX(this, tag); break; + case OTS_TAG_VORG: table = new OpenTypeVORG(this, tag); break; + case OTS_TAG_VVAR: table = new OpenTypeVVAR(this, tag); break; + // Graphite tables +#ifdef OTS_GRAPHITE + case OTS_TAG_FEAT: table = new OpenTypeFEAT(this, tag); break; + case OTS_TAG_GLAT: table = new OpenTypeGLAT(this, tag); break; + case OTS_TAG_GLOC: table = new OpenTypeGLOC(this, tag); break; + case OTS_TAG_SILE: table = new OpenTypeSILE(this, tag); break; + case OTS_TAG_SILF: table = new OpenTypeSILF(this, tag); break; + case OTS_TAG_SILL: table = new OpenTypeSILL(this, tag); break; +#endif + default: break; + } + } + + if (table) { + const uint8_t* table_data; + size_t table_length; + + ret = GetTableData(data, table_entry, arena, &table_length, &table_data); + if (ret) { + // FIXME: Parsing some tables will fail if the table is not added to + // m_tables first. + m_tables[tag] = table; + ret = table->Parse(table_data, table_length); + if (ret) + file->tables[table_entry] = table; + else + m_tables.erase(tag); + } + } + + if (!ret) + delete table; + + return ret; +} + +Table* Font::GetTable(uint32_t tag) const { + const auto &it = m_tables.find(tag); + if (it != m_tables.end()) + return it->second; + return NULL; +} + +Table* Font::GetTypedTable(uint32_t tag) const { + Table* t = GetTable(tag); + if (t && t->Type() == tag) + return t; + return NULL; +} + +void Font::DropGraphite() { + file->context->Message(0, "Dropping all Graphite tables"); + for (const std::pair<uint32_t, Table*> entry : m_tables) { + if (entry.first == OTS_TAG_FEAT || + entry.first == OTS_TAG_GLAT || + entry.first == OTS_TAG_GLOC || + entry.first == OTS_TAG_SILE || + entry.first == OTS_TAG_SILF || + entry.first == OTS_TAG_SILL) { + entry.second->Drop("Discarding Graphite table"); + } + } + dropped_graphite = true; +} + +void Font::DropVariations() { + file->context->Message(0, "Dropping all Variation tables"); + for (const std::pair<uint32_t, Table*> entry : m_tables) { + if (entry.first == OTS_TAG_AVAR || + entry.first == OTS_TAG_CVAR || + entry.first == OTS_TAG_FVAR || + entry.first == OTS_TAG_GVAR || + entry.first == OTS_TAG_HVAR || + entry.first == OTS_TAG_MVAR || + entry.first == OTS_TAG_STAT || + entry.first == OTS_TAG_VVAR) { + entry.second->Drop("Discarding Variations table"); + } + } + dropped_variations = true; +} + +bool Table::ShouldSerialize() { + return m_shouldSerialize; +} + +void Table::Message(int level, const char *format, va_list va) { + char msg[206] = { OTS_UNTAG(m_tag), ':', ' ' }; + std::vsnprintf(msg + 6, 200, format, va); + m_font->file->context->Message(level, msg); +} + +bool Table::Error(const char *format, ...) { + va_list va; + va_start(va, format); + Message(0, format, va); + va_end(va); + + return false; +} + +bool Table::Warning(const char *format, ...) { + va_list va; + va_start(va, format); + Message(1, format, va); + va_end(va); + + return true; +} + +bool Table::Drop(const char *format, ...) { + m_shouldSerialize = false; + + va_list va; + va_start(va, format); + Message(0, format, va); + m_font->file->context->Message(0, "Table discarded"); + va_end(va); + + return true; +} + +bool Table::DropGraphite(const char *format, ...) { + va_list va; + va_start(va, format); + Message(0, format, va); + va_end(va); + + m_font->DropGraphite(); + return true; +} + +bool Table::DropVariations(const char *format, ...) { + va_list va; + va_start(va, format); + Message(0, format, va); + va_end(va); + + m_font->DropVariations(); + return true; +} + +bool TablePassthru::Parse(const uint8_t *data, size_t length) { + m_data = data; + m_length = length; + return true; +} + +bool TablePassthru::Serialize(OTSStream *out) { + if (!out->Write(m_data, m_length)) { + return Error("Failed to write table"); + } + + return true; +} + bool IsValidVersionTag(uint32_t tag) { return tag == 0x000010000 || // OpenType fonts with CFF data have 'OTTO' tag. @@ -882,7 +1084,7 @@ bool OTSContext::Process(OTSStream *output, const uint8_t *data, size_t length, uint32_t index) { - OpenTypeFile header; + FontFile header; Font font(&header); header.context = this; diff --git a/gfx/ots/src/ots.h b/gfx/ots/src/ots.h index 2d13f8d6d..4d2be1689 100644 --- a/gfx/ots/src/ots.h +++ b/gfx/ots/src/ots.h @@ -1,10 +1,14 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #ifndef OTS_H_ #define OTS_H_ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + #include <stddef.h> #include <cstdarg> #include <cstddef> @@ -54,13 +58,9 @@ namespace ots { #define OTS_WARNING_MSG_(otf_,...) \ OTS_MESSAGE_(1,otf_,__VA_ARGS__) -// Generate a message with an associated table tag -#define OTS_FAILURE_MSG_TAG_(otf_,msg_,tag_) \ - (OTS_MESSAGE_(0,otf_,"%c%c%c%c: %s", OTS_UNTAG(tag_), msg_), false) - // Convenience macros for use in files that only handle a single table tag, // defined as TABLE_NAME at the top of the file; the 'file' variable is -// expected to be the current OpenTypeFile pointer. +// expected to be the current FontFile pointer. #define OTS_FAILURE_MSG(...) OTS_FAILURE_MSG_(font->file, TABLE_NAME ": " __VA_ARGS__) #define OTS_WARNING(...) OTS_WARNING_MSG_(font->file, TABLE_NAME ": " __VA_ARGS__) @@ -112,7 +112,7 @@ class Buffer { return OTS_FAILURE(); } std::memcpy(value, buffer_ + offset_, sizeof(uint16_t)); - *value = ntohs(*value); + *value = ots_ntohs(*value); offset_ += 2; return true; } @@ -137,7 +137,7 @@ class Buffer { return OTS_FAILURE(); } std::memcpy(value, buffer_ + offset_, sizeof(uint32_t)); - *value = ntohl(*value); + *value = ots_ntohl(*value); offset_ += 4; return true; } @@ -184,111 +184,175 @@ template<typename T> T Round2(T value) { return (value + 1) & ~1; } +// Check that a tag consists entirely of printable ASCII characters +bool CheckTag(uint32_t tag_value); + bool IsValidVersionTag(uint32_t tag); -#define FOR_EACH_TABLE_TYPE \ - F(cff, CFF) \ - F(cmap, CMAP) \ - F(cvt, CVT) \ - F(fpgm, FPGM) \ - F(gasp, GASP) \ - F(gdef, GDEF) \ - F(glyf, GLYF) \ - F(gpos, GPOS) \ - F(gsub, GSUB) \ - F(hdmx, HDMX) \ - F(head, HEAD) \ - F(hhea, HHEA) \ - F(hmtx, HMTX) \ - F(kern, KERN) \ - F(loca, LOCA) \ - F(ltsh, LTSH) \ - F(math, MATH) \ - F(maxp, MAXP) \ - F(name, NAME) \ - F(os2, OS2) \ - F(post, POST) \ - F(prep, PREP) \ - F(vdmx, VDMX) \ - F(vorg, VORG) \ - F(vhea, VHEA) \ - F(vmtx, VMTX) - -#define F(name, capname) struct OpenType##capname; -FOR_EACH_TABLE_TYPE -#undef F +#define OTS_TAG_CFF OTS_TAG('C','F','F',' ') +#define OTS_TAG_CFF2 OTS_TAG('C','F','F','2') +#define OTS_TAG_CMAP OTS_TAG('c','m','a','p') +#define OTS_TAG_CVT OTS_TAG('c','v','t',' ') +#define OTS_TAG_FEAT OTS_TAG('F','e','a','t') +#define OTS_TAG_FPGM OTS_TAG('f','p','g','m') +#define OTS_TAG_GASP OTS_TAG('g','a','s','p') +#define OTS_TAG_GDEF OTS_TAG('G','D','E','F') +#define OTS_TAG_GLAT OTS_TAG('G','l','a','t') +#define OTS_TAG_GLOC OTS_TAG('G','l','o','c') +#define OTS_TAG_GLYF OTS_TAG('g','l','y','f') +#define OTS_TAG_GPOS OTS_TAG('G','P','O','S') +#define OTS_TAG_GSUB OTS_TAG('G','S','U','B') +#define OTS_TAG_HDMX OTS_TAG('h','d','m','x') +#define OTS_TAG_HEAD OTS_TAG('h','e','a','d') +#define OTS_TAG_HHEA OTS_TAG('h','h','e','a') +#define OTS_TAG_HMTX OTS_TAG('h','m','t','x') +#define OTS_TAG_KERN OTS_TAG('k','e','r','n') +#define OTS_TAG_LOCA OTS_TAG('l','o','c','a') +#define OTS_TAG_LTSH OTS_TAG('L','T','S','H') +#define OTS_TAG_MATH OTS_TAG('M','A','T','H') +#define OTS_TAG_MAXP OTS_TAG('m','a','x','p') +#define OTS_TAG_NAME OTS_TAG('n','a','m','e') +#define OTS_TAG_OS2 OTS_TAG('O','S','/','2') +#define OTS_TAG_POST OTS_TAG('p','o','s','t') +#define OTS_TAG_PREP OTS_TAG('p','r','e','p') +#define OTS_TAG_SILE OTS_TAG('S','i','l','e') +#define OTS_TAG_SILF OTS_TAG('S','i','l','f') +#define OTS_TAG_SILL OTS_TAG('S','i','l','l') +#define OTS_TAG_VDMX OTS_TAG('V','D','M','X') +#define OTS_TAG_VHEA OTS_TAG('v','h','e','a') +#define OTS_TAG_VMTX OTS_TAG('v','m','t','x') +#define OTS_TAG_VORG OTS_TAG('V','O','R','G') + +#define OTS_TAG_AVAR OTS_TAG('a','v','a','r') +#define OTS_TAG_CVAR OTS_TAG('c','v','a','r') +#define OTS_TAG_FVAR OTS_TAG('f','v','a','r') +#define OTS_TAG_GVAR OTS_TAG('g','v','a','r') +#define OTS_TAG_HVAR OTS_TAG('H','V','A','R') +#define OTS_TAG_MVAR OTS_TAG('M','V','A','R') +#define OTS_TAG_VVAR OTS_TAG('V','V','A','R') +#define OTS_TAG_STAT OTS_TAG('S','T','A','T') struct Font; -struct OpenTypeFile; +struct FontFile; +struct TableEntry; +struct Arena; + +class Table { + public: + explicit Table(Font *font, uint32_t tag, uint32_t type) + : m_tag(tag), + m_type(type), + m_font(font), + m_shouldSerialize(true) { + } + + virtual ~Table() { } -#define F(name, capname) \ -bool ots_##name##_parse(Font *f, const uint8_t *d, size_t l); \ -bool ots_##name##_should_serialise(Font *f); \ -bool ots_##name##_serialise(OTSStream *s, Font *f); \ -void ots_##name##_reuse(Font *f, Font *o);\ -void ots_##name##_free(Font *f); -FOR_EACH_TABLE_TYPE -#undef F + virtual bool Parse(const uint8_t *data, size_t length) = 0; + virtual bool Serialize(OTSStream *out) = 0; + virtual bool ShouldSerialize(); + + // Return the tag (table type) this Table was parsed as, to support + // "poor man's RTTI" so that we know if we can safely down-cast to + // a specific Table subclass. The m_type field is initialized to the + // appropriate tag when a subclass is constructed, or to zero for + // TablePassthru (indicating unparsed data). + uint32_t Type() { return m_type; } + + Font* GetFont() { return m_font; } + + bool Error(const char *format, ...); + bool Warning(const char *format, ...); + bool Drop(const char *format, ...); + bool DropGraphite(const char *format, ...); + bool DropVariations(const char *format, ...); + + private: + void Message(int level, const char *format, va_list va); + + uint32_t m_tag; + uint32_t m_type; + Font *m_font; + bool m_shouldSerialize; +}; + +class TablePassthru : public Table { + public: + explicit TablePassthru(Font *font, uint32_t tag) + : Table(font, tag, 0), + m_data(NULL), + m_length(0) { + } + + bool Parse(const uint8_t *data, size_t length); + bool Serialize(OTSStream *out); + + private: + const uint8_t *m_data; + size_t m_length; +}; struct Font { - explicit Font(const OpenTypeFile *f) + explicit Font(FontFile *f) : file(f), version(0), num_tables(0), search_range(0), entry_selector(0), - range_shift(0) { -#define F(name, capname) \ - name = NULL; \ - name##_reused = false; - FOR_EACH_TABLE_TYPE -#undef F + range_shift(0), + dropped_graphite(false), + dropped_variations(false) { } - ~Font() { -#define F(name, capname) \ - if (!name##_reused) {\ - ots_##name##_free(this); \ - } - FOR_EACH_TABLE_TYPE -#undef F - } + bool ParseTable(const TableEntry& tableinfo, const uint8_t* data, + Arena &arena); + Table* GetTable(uint32_t tag) const; + + // This checks that the returned Table is actually of the correct subclass + // for |tag|, so it can safely be downcast to the corresponding OpenTypeXXXX; + // if not (i.e. if the table was treated as Passthru), it will return NULL. + Table* GetTypedTable(uint32_t tag) const; + + // Drop all Graphite tables and don't parse new ones. + void DropGraphite(); - const OpenTypeFile *file; + // Drop all Variations tables and don't parse new ones. + void DropVariations(); + + FontFile *file; uint32_t version; uint16_t num_tables; uint16_t search_range; uint16_t entry_selector; uint16_t range_shift; + bool dropped_graphite; + bool dropped_variations; -#define F(name, capname) \ - OpenType##capname *name; \ - bool name##_reused; -FOR_EACH_TABLE_TYPE -#undef F + private: + std::map<uint32_t, Table*> m_tables; }; -struct OutputTable { +struct TableEntry { uint32_t tag; - size_t offset; - size_t length; + uint32_t offset; + uint32_t length; + uint32_t uncompressed_length; uint32_t chksum; - bool operator<(const OutputTable& other) const { + bool operator<(const TableEntry& other) const { return tag < other.tag; } }; -typedef std::map<uint32_t, std::pair<Font*, OutputTable> > TableMap; +struct FontFile { + ~FontFile(); -struct OpenTypeFile { OTSContext *context; - TableMap tables; + std::map<TableEntry, Table*> tables; + std::map<uint32_t, TableEntry> table_entries; }; } // namespace ots -#undef FOR_EACH_TABLE_TYPE - #endif // OTS_H_ diff --git a/gfx/ots/src/post.cc b/gfx/ots/src/post.cc index a110b2dea..704c32007 100644 --- a/gfx/ots/src/post.cc +++ b/gfx/ots/src/post.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -9,74 +9,73 @@ // post - PostScript // http://www.microsoft.com/typography/otspec/post.htm -#define TABLE_NAME "post" - namespace ots { -bool ots_post_parse(Font *font, const uint8_t *data, size_t length) { +bool OpenTypePOST::Parse(const uint8_t *data, size_t length) { Buffer table(data, length); - OpenTypePOST *post = new OpenTypePOST; - font->post = post; + if (!table.ReadU32(&this->version)) { + return Error("Failed to read table version"); + } - if (!table.ReadU32(&post->version) || - !table.ReadU32(&post->italic_angle) || - !table.ReadS16(&post->underline) || - !table.ReadS16(&post->underline_thickness) || - !table.ReadU32(&post->is_fixed_pitch)) { - return OTS_FAILURE_MSG("Failed to read post header"); + if (this->version != 0x00010000 && + this->version != 0x00020000 && + this->version != 0x00030000) { + // 0x00025000 is deprecated. We don't accept it. + return Error("Unsupported table version 0x%x", this->version); } - if (post->underline_thickness < 0) { - post->underline_thickness = 1; + if (!table.ReadU32(&this->italic_angle) || + !table.ReadS16(&this->underline) || + !table.ReadS16(&this->underline_thickness) || + !table.ReadU32(&this->is_fixed_pitch) || + // We don't care about the memory usage fields. We'll set all these to + // zero when serialising + !table.Skip(16)) { + return Error("Failed to read table header"); } - if (post->version == 0x00010000) { - return true; - } else if (post->version == 0x00030000) { + if (this->underline_thickness < 0) { + this->underline_thickness = 1; + } + + if (this->version == 0x00010000 || this->version == 0x00030000) { return true; - } else if (post->version != 0x00020000) { - // 0x00025000 is deprecated. We don't accept it. - return OTS_FAILURE_MSG("Bad post version %x", post->version); } // We have a version 2 table with a list of Pascal strings at the end - // We don't care about the memory usage fields. We'll set all these to zero - // when serialising - if (!table.Skip(16)) { - return OTS_FAILURE_MSG("Failed to skip memory usage in post table"); - } - uint16_t num_glyphs = 0; if (!table.ReadU16(&num_glyphs)) { - return OTS_FAILURE_MSG("Failed to read number of glyphs"); + return Error("Failed to read numberOfGlyphs"); } - if (!font->maxp) { - return OTS_FAILURE_MSG("No maxp table required by post table"); + OpenTypeMAXP* maxp = static_cast<OpenTypeMAXP*> + (GetFont()->GetTable(OTS_TAG_MAXP)); + if (!maxp) { + return Error("Missing required maxp table"); } if (num_glyphs == 0) { - if (font->maxp->num_glyphs > 258) { - return OTS_FAILURE_MSG("Can't have no glyphs in the post table if there are more than 256 glyphs in the font"); + if (maxp->num_glyphs > 258) { + return Error("Can't have no glyphs in the post table if there are more " + "than 258 glyphs in the font"); } - OTS_WARNING("table version is 1, but no glyf names are found"); // workaround for fonts in http://www.fontsquirrel.com/fontface // (e.g., yataghan.ttf). - post->version = 0x00010000; - return true; + this->version = 0x00010000; + return Warning("Table version is 1, but no glyph names are found"); } - if (num_glyphs != font->maxp->num_glyphs) { + if (num_glyphs != maxp->num_glyphs) { // Note: Fixedsys500c.ttf seems to have inconsistent num_glyphs values. - return OTS_FAILURE_MSG("Bad number of glyphs in post table %d", num_glyphs); + return Error("Bad number of glyphs: %d", num_glyphs); } - post->glyph_name_index.resize(num_glyphs); + this->glyph_name_index.resize(num_glyphs); for (unsigned i = 0; i < num_glyphs; ++i) { - if (!table.ReadU16(&post->glyph_name_index[i])) { - return OTS_FAILURE_MSG("Failed to read post information for glyph %d", i); + if (!table.ReadU16(&this->glyph_name_index[i])) { + return Error("Failed to read glyph name %d", i); } // Note: A strict interpretation of the specification requires name indexes // are less than 32768. This, however, excludes fonts like unifont.ttf @@ -93,101 +92,85 @@ bool ots_post_parse(Font *font, const uint8_t *data, size_t length) { if (strings == strings_end) break; const unsigned string_length = *strings; if (strings + 1 + string_length > strings_end) { - return OTS_FAILURE_MSG("Bad string length %d", string_length); + return Error("Bad string length %d", string_length); } if (std::memchr(strings + 1, '\0', string_length)) { - return OTS_FAILURE_MSG("Bad string of length %d", string_length); + return Error("Bad string of length %d", string_length); } - post->names.push_back( + this->names.push_back( std::string(reinterpret_cast<const char*>(strings + 1), string_length)); strings += 1 + string_length; } - const unsigned num_strings = post->names.size(); + const unsigned num_strings = this->names.size(); // check that all the references are within bounds for (unsigned i = 0; i < num_glyphs; ++i) { - unsigned offset = post->glyph_name_index[i]; + unsigned offset = this->glyph_name_index[i]; if (offset < 258) { continue; } offset -= 258; if (offset >= num_strings) { - return OTS_FAILURE_MSG("Bad string index %d", offset); + return Error("Bad string index %d", offset); } } return true; } -bool ots_post_should_serialise(Font *font) { - return font->post != NULL; -} - -bool ots_post_serialise(OTSStream *out, Font *font) { - const OpenTypePOST *post = font->post; - +bool OpenTypePOST::Serialize(OTSStream *out) { // OpenType with CFF glyphs must have v3 post table. - if (post && font->cff && post->version != 0x00030000) { - return OTS_FAILURE_MSG("Bad post version %x", post->version); + if (GetFont()->GetTable(OTS_TAG_CFF) && this->version != 0x00030000) { + return Error("Only version supported for fonts with CFF table is 0x00030000" + " not 0x%x", this->version); } - if (!out->WriteU32(post->version) || - !out->WriteU32(post->italic_angle) || - !out->WriteS16(post->underline) || - !out->WriteS16(post->underline_thickness) || - !out->WriteU32(post->is_fixed_pitch) || + if (!out->WriteU32(this->version) || + !out->WriteU32(this->italic_angle) || + !out->WriteS16(this->underline) || + !out->WriteS16(this->underline_thickness) || + !out->WriteU32(this->is_fixed_pitch) || !out->WriteU32(0) || !out->WriteU32(0) || !out->WriteU32(0) || !out->WriteU32(0)) { - return OTS_FAILURE_MSG("Failed to write post header"); + return Error("Failed to write post header"); } - if (post->version != 0x00020000) { + if (this->version != 0x00020000) { return true; // v1.0 and v3.0 does not have glyph names. } const uint16_t num_indexes = - static_cast<uint16_t>(post->glyph_name_index.size()); - if (num_indexes != post->glyph_name_index.size() || + static_cast<uint16_t>(this->glyph_name_index.size()); + if (num_indexes != this->glyph_name_index.size() || !out->WriteU16(num_indexes)) { - return OTS_FAILURE_MSG("Failed to write number of indices"); + return Error("Failed to write number of indices"); } for (uint16_t i = 0; i < num_indexes; ++i) { - if (!out->WriteU16(post->glyph_name_index[i])) { - return OTS_FAILURE_MSG("Failed to write name index %d", i); + if (!out->WriteU16(this->glyph_name_index[i])) { + return Error("Failed to write name index %d", i); } } // Now we just have to write out the strings in the correct order - for (unsigned i = 0; i < post->names.size(); ++i) { - const std::string& s = post->names[i]; + for (unsigned i = 0; i < this->names.size(); ++i) { + const std::string& s = this->names[i]; const uint8_t string_length = static_cast<uint8_t>(s.size()); if (string_length != s.size() || !out->Write(&string_length, 1)) { - return OTS_FAILURE_MSG("Failed to write string %d", i); + return Error("Failed to write string %d", i); } // Some ttf fonts (e.g., frank.ttf on Windows Vista) have zero-length name. // We allow them. if (string_length > 0 && !out->Write(s.data(), string_length)) { - return OTS_FAILURE_MSG("Failed to write string length for string %d", i); + return Error("Failed to write string length for string %d", i); } } return true; } -void ots_post_reuse(Font *font, Font *other) { - font->post = other->post; - font->post_reused = true; -} - -void ots_post_free(Font *font) { - delete font->post; -} - } // namespace ots - -#undef TABLE_NAME diff --git a/gfx/ots/src/post.h b/gfx/ots/src/post.h index f220d4fc7..c341e391c 100644 --- a/gfx/ots/src/post.h +++ b/gfx/ots/src/post.h @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -13,7 +13,15 @@ namespace ots { -struct OpenTypePOST { +class OpenTypePOST : public Table { + public: + explicit OpenTypePOST(Font *font, uint32_t tag) + : Table(font, tag, tag) { } + + bool Parse(const uint8_t *data, size_t length); + bool Serialize(OTSStream *out); + +private: uint32_t version; uint32_t italic_angle; int16_t underline; diff --git a/gfx/ots/src/prep.cc b/gfx/ots/src/prep.cc index 1c9b45f91..943bb45b9 100644 --- a/gfx/ots/src/prep.cc +++ b/gfx/ots/src/prep.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -7,53 +7,37 @@ // prep - Control Value Program // http://www.microsoft.com/typography/otspec/prep.htm -#define TABLE_NAME "prep" - namespace ots { -bool ots_prep_parse(Font *font, const uint8_t *data, size_t length) { +bool OpenTypePREP::Parse(const uint8_t *data, size_t length) { Buffer table(data, length); - OpenTypePREP *prep = new OpenTypePREP; - font->prep = prep; - if (length >= 128 * 1024u) { - return OTS_FAILURE_MSG("table length %ld > 120K", length); // almost all prep tables are less than 9k bytes. + // almost all prep tables are less than 9k bytes. + return Error("Table length %ld > 120K", length); } if (!table.Skip(length)) { - return OTS_FAILURE_MSG("Failed to read table of length %ld", length); + return Error("Failed to read table of length %ld", length); } - prep->data = data; - prep->length = length; + this->m_data = data; + this->m_length = length; return true; } -bool ots_prep_should_serialise(Font *font) { - if (!font->glyf) return false; // this table is not for CFF fonts. - return font->prep != NULL; -} - -bool ots_prep_serialise(OTSStream *out, Font *font) { - const OpenTypePREP *prep = font->prep; - - if (!out->Write(prep->data, prep->length)) { - return OTS_FAILURE_MSG("Failed to write table length"); +bool OpenTypePREP::Serialize(OTSStream *out) { + if (!out->Write(this->m_data, this->m_length)) { + return Error("Failed to write table length"); } return true; } -void ots_prep_reuse(Font *font, Font *other) { - font->prep = other->prep; - font->prep_reused = true; -} - -void ots_prep_free(Font *font) { - delete font->prep; +bool OpenTypePREP::ShouldSerialize() { + return Table::ShouldSerialize() && + // this table is not for CFF fonts. + GetFont()->GetTable(OTS_TAG_GLYF) != NULL; } } // namespace ots - -#undef TABLE_NAME diff --git a/gfx/ots/src/prep.h b/gfx/ots/src/prep.h index 935ca111c..4d3eda2cd 100644 --- a/gfx/ots/src/prep.h +++ b/gfx/ots/src/prep.h @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -9,9 +9,18 @@ namespace ots { -struct OpenTypePREP { - const uint8_t *data; - uint32_t length; +class OpenTypePREP : public Table { + public: + explicit OpenTypePREP(Font *font, uint32_t tag) + : Table(font, tag, tag) { } + + bool Parse(const uint8_t *data, size_t length); + bool Serialize(OTSStream *out); + bool ShouldSerialize(); + + private: + const uint8_t *m_data; + uint32_t m_length; }; } // namespace ots diff --git a/gfx/ots/src/sile.cc b/gfx/ots/src/sile.cc new file mode 100644 index 000000000..74405e56e --- /dev/null +++ b/gfx/ots/src/sile.cc @@ -0,0 +1,74 @@ +// Copyright (c) 2009-2017 The OTS 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 "sile.h" + +namespace ots { + +bool OpenTypeSILE::Parse(const uint8_t* data, size_t length) { + if (GetFont()->dropped_graphite) { + return Drop("Skipping Graphite table"); + } + Buffer table(data, length); + + if (!table.ReadU32(&this->version) || this->version >> 16 != 1) { + return DropGraphite("Failed to read valid version"); + } + if (!table.ReadU32(&this->checksum)) { + return DropGraphite("Failed to read checksum"); + } + if (!table.ReadU32(&this->createTime[0]) || + !table.ReadU32(&this->createTime[1])) { + return DropGraphite("Failed to read createTime"); + } + if (!table.ReadU32(&this->modifyTime[0]) || + !table.ReadU32(&this->modifyTime[1])) { + return DropGraphite("Failed to read modifyTime"); + } + + if (!table.ReadU16(&this->fontNameLength)) { + return DropGraphite("Failed to read fontNameLength"); + } + //this->fontName.resize(this->fontNameLength); + for (unsigned i = 0; i < this->fontNameLength; ++i) { + this->fontName.emplace_back(); + if (!table.ReadU16(&this->fontName[i])) { + return DropGraphite("Failed to read fontName[%u]", i); + } + } + + if (!table.ReadU16(&this->fontFileLength)) { + return DropGraphite("Failed to read fontFileLength"); + } + //this->baseFile.resize(this->fontFileLength); + for (unsigned i = 0; i < this->fontFileLength; ++i) { + this->baseFile.emplace_back(); + if (!table.ReadU16(&this->baseFile[i])) { + return DropGraphite("Failed to read baseFile[%u]", i); + } + } + + if (table.remaining()) { + return Warning("%zu bytes unparsed", table.remaining()); + } + return true; +} + +bool OpenTypeSILE::Serialize(OTSStream* out) { + if (!out->WriteU32(this->version) || + !out->WriteU32(this->checksum) || + !out->WriteU32(this->createTime[0]) || + !out->WriteU32(this->createTime[1]) || + !out->WriteU32(this->modifyTime[0]) || + !out->WriteU32(this->modifyTime[1]) || + !out->WriteU16(this->fontNameLength) || + !SerializeParts(this->fontName, out) || + !out->WriteU16(this->fontFileLength) || + !SerializeParts(this->baseFile, out)) { + return Error("Failed to write table"); + } + return true; +} + +} // namespace ots diff --git a/gfx/ots/src/sile.h b/gfx/ots/src/sile.h new file mode 100644 index 000000000..bdb00606f --- /dev/null +++ b/gfx/ots/src/sile.h @@ -0,0 +1,36 @@ +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef OTS_SILE_H_ +#define OTS_SILE_H_ + +#include "ots.h" +#include "graphite.h" + +#include <vector> + +namespace ots { + +class OpenTypeSILE : public Table { + public: + explicit OpenTypeSILE(Font* font, uint32_t tag) + : Table(font, tag, tag) { } + + bool Parse(const uint8_t* data, size_t length); + bool Serialize(OTSStream* out); + + private: + uint32_t version; + uint32_t checksum; + uint32_t createTime[2]; + uint32_t modifyTime[2]; + uint16_t fontNameLength; + std::vector<uint16_t> fontName; + uint16_t fontFileLength; + std::vector<uint16_t> baseFile; +}; + +} // namespace ots + +#endif // OTS_SILE_H_ diff --git a/gfx/ots/src/silf.cc b/gfx/ots/src/silf.cc new file mode 100644 index 000000000..fa4e59e52 --- /dev/null +++ b/gfx/ots/src/silf.cc @@ -0,0 +1,977 @@ +// Copyright (c) 2009-2017 The OTS 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 "silf.h" + +#include "name.h" +#include "mozilla/Compression.h" +#include <cmath> + +namespace ots { + +bool OpenTypeSILF::Parse(const uint8_t* data, size_t length, + bool prevent_decompression) { + if (GetFont()->dropped_graphite) { + return Drop("Skipping Graphite table"); + } + Buffer table(data, length); + + if (!table.ReadU32(&this->version)) { + return DropGraphite("Failed to read version"); + } + if (this->version >> 16 != 1 && + this->version >> 16 != 2 && + this->version >> 16 != 3 && + this->version >> 16 != 4 && + this->version >> 16 != 5) { + return DropGraphite("Unsupported table version: %u", this->version >> 16); + } + if (this->version >> 16 >= 3 && !table.ReadU32(&this->compHead)) { + return DropGraphite("Failed to read compHead"); + } + if (this->version >> 16 >= 5) { + switch ((this->compHead & SCHEME) >> 27) { + case 0: // uncompressed + break; + case 1: { // lz4 + if (prevent_decompression) { + return DropGraphite("Illegal nested compression"); + } + size_t decompressed_size = this->compHead & FULL_SIZE; + if (decompressed_size < length) { + return DropGraphite("Decompressed size is less than compressed size"); + } + if (decompressed_size == 0) { + return DropGraphite("Decompressed size is set to 0"); + } + // decompressed table must be <= 30MB + if (decompressed_size > 30 * 1024 * 1024) { + return DropGraphite("Decompressed size exceeds 30MB: %gMB", + decompressed_size / (1024.0 * 1024.0)); + } + std::vector<uint8_t> decompressed(decompressed_size); + size_t outputSize = 0; + bool ret = mozilla::Compression::LZ4::decompressPartial( + reinterpret_cast<const char*>(data + table.offset()), + table.remaining(), // input buffer size (input size + padding) + reinterpret_cast<char*>(decompressed.data()), + decompressed.size(), // target output size + &outputSize); // return output size + if (!ret || outputSize != decompressed.size()) { + return DropGraphite("Decompression failed"); + } + return this->Parse(decompressed.data(), decompressed.size(), true); + } + default: + return DropGraphite("Unknown compression scheme"); + } + } + if (!table.ReadU16(&this->numSub)) { + return DropGraphite("Failed to read numSub"); + } + if (this->version >> 16 >= 2 && !table.ReadU16(&this->reserved)) { + return DropGraphite("Failed to read reserved"); + } + if (this->version >> 16 >= 2 && this->reserved != 0) { + Warning("Nonzero reserved"); + } + + unsigned long last_offset = 0; + //this->offset.resize(this->numSub); + for (unsigned i = 0; i < this->numSub; ++i) { + this->offset.emplace_back(); + if (!table.ReadU32(&this->offset[i]) || this->offset[i] < last_offset) { + return DropGraphite("Failed to read offset[%u]", i); + } + last_offset = this->offset[i]; + } + + for (unsigned i = 0; i < this->numSub; ++i) { + if (table.offset() != this->offset[i]) { + return DropGraphite("Offset check failed for tables[%lu]", i); + } + SILSub subtable(this); + if (!subtable.ParsePart(table)) { + return DropGraphite("Failed to read tables[%u]", i); + } + tables.push_back(subtable); + } + + if (table.remaining()) { + return Warning("%zu bytes unparsed", table.remaining()); + } + return true; +} + +bool OpenTypeSILF::Serialize(OTSStream* out) { + if (!out->WriteU32(this->version) || + (this->version >> 16 >= 3 && !out->WriteU32(this->compHead)) || + !out->WriteU16(this->numSub) || + (this->version >> 16 >= 2 && !out->WriteU16(this->reserved)) || + !SerializeParts(this->offset, out) || + !SerializeParts(this->tables, out)) { + return Error("Failed to write table"); + } + return true; +} + +bool OpenTypeSILF::SILSub::ParsePart(Buffer& table) { + size_t init_offset = table.offset(); + if (parent->version >> 16 >= 3) { + if (!table.ReadU32(&this->ruleVersion)) { + return parent->Error("SILSub: Failed to read ruleVersion"); + } + if (!table.ReadU16(&this->passOffset)) { + return parent->Error("SILSub: Failed to read passOffset"); + } + if (!table.ReadU16(&this->pseudosOffset)) { + return parent->Error("SILSub: Failed to read pseudosOffset"); + } + } + if (!table.ReadU16(&this->maxGlyphID)) { + return parent->Error("SILSub: Failed to read maxGlyphID"); + } + if (!table.ReadS16(&this->extraAscent)) { + return parent->Error("SILSub: Failed to read extraAscent"); + } + if (!table.ReadS16(&this->extraDescent)) { + return parent->Error("SILSub: Failed to read extraDescent"); + } + if (!table.ReadU8(&this->numPasses)) { + return parent->Error("SILSub: Failed to read numPasses"); + } + if (!table.ReadU8(&this->iSubst) || this->iSubst > this->numPasses) { + return parent->Error("SILSub: Failed to read valid iSubst"); + } + if (!table.ReadU8(&this->iPos) || this->iPos > this->numPasses) { + return parent->Error("SILSub: Failed to read valid iPos"); + } + if (!table.ReadU8(&this->iJust) || this->iJust > this->numPasses) { + return parent->Error("SILSub: Failed to read valid iJust"); + } + if (!table.ReadU8(&this->iBidi) || + !(iBidi == 0xFF || this->iBidi <= this->iPos)) { + return parent->Error("SILSub: Failed to read valid iBidi"); + } + if (!table.ReadU8(&this->flags)) { + return parent->Error("SILSub: Failed to read flags"); + // checks omitted + } + if (!table.ReadU8(&this->maxPreContext)) { + return parent->Error("SILSub: Failed to read maxPreContext"); + } + if (!table.ReadU8(&this->maxPostContext)) { + return parent->Error("SILSub: Failed to read maxPostContext"); + } + if (!table.ReadU8(&this->attrPseudo)) { + return parent->Error("SILSub: Failed to read attrPseudo"); + } + if (!table.ReadU8(&this->attrBreakWeight)) { + return parent->Error("SILSub: Failed to read attrBreakWeight"); + } + if (!table.ReadU8(&this->attrDirectionality)) { + return parent->Error("SILSub: Failed to read attrDirectionality"); + } + if (parent->version >> 16 >= 2) { + if (!table.ReadU8(&this->attrMirroring)) { + return parent->Error("SILSub: Failed to read attrMirroring"); + } + if (!table.ReadU8(&this->attrSkipPasses)) { + return parent->Error("SILSub: Failed to read attrSkipPasses"); + } + + if (!table.ReadU8(&this->numJLevels)) { + return parent->Error("SILSub: Failed to read numJLevels"); + } + //this->jLevels.resize(this->numJLevels, parent); + for (unsigned i = 0; i < this->numJLevels; ++i) { + this->jLevels.emplace_back(parent); + if (!this->jLevels[i].ParsePart(table)) { + return parent->Error("SILSub: Failed to read jLevels[%u]", i); + } + } + } + + if (!table.ReadU16(&this->numLigComp)) { + return parent->Error("SILSub: Failed to read numLigComp"); + } + if (!table.ReadU8(&this->numUserDefn)) { + return parent->Error("SILSub: Failed to read numUserDefn"); + } + if (!table.ReadU8(&this->maxCompPerLig)) { + return parent->Error("SILSub: Failed to read maxCompPerLig"); + } + if (!table.ReadU8(&this->direction)) { + return parent->Error("SILSub: Failed to read direction"); + } + if (!table.ReadU8(&this->attCollisions)) { + return parent->Error("SILSub: Failed to read attCollisions"); + } + if (parent->version >> 16 < 5 && this->attCollisions != 0) { + parent->Warning("SILSub: Nonzero attCollisions (reserved before v5)"); + } + if (!table.ReadU8(&this->reserved4)) { + return parent->Error("SILSub: Failed to read reserved4"); + } + if (this->reserved4 != 0) { + parent->Warning("SILSub: Nonzero reserved4"); + } + if (!table.ReadU8(&this->reserved5)) { + return parent->Error("SILSub: Failed to read reserved5"); + } + if (this->reserved5 != 0) { + parent->Warning("SILSub: Nonzero reserved5"); + } + if (parent->version >> 16 >= 2) { + if (!table.ReadU8(&this->reserved6)) { + return parent->Error("SILSub: Failed to read reserved6"); + } + if (this->reserved6 != 0) { + parent->Warning("SILSub: Nonzero reserved6"); + } + + if (!table.ReadU8(&this->numCritFeatures)) { + return parent->Error("SILSub: Failed to read numCritFeatures"); + } + //this->critFeatures.resize(this->numCritFeatures); + for (unsigned i = 0; i < this->numCritFeatures; ++i) { + this->critFeatures.emplace_back(); + if (!table.ReadU16(&this->critFeatures[i])) { + return parent->Error("SILSub: Failed to read critFeatures[%u]", i); + } + } + + if (!table.ReadU8(&this->reserved7)) { + return parent->Error("SILSub: Failed to read reserved7"); + } + if (this->reserved7 != 0) { + parent->Warning("SILSub: Nonzero reserved7"); + } + } + + if (!table.ReadU8(&this->numScriptTag)) { + return parent->Error("SILSub: Failed to read numScriptTag"); + } + //this->scriptTag.resize(this->numScriptTag); + for (unsigned i = 0; i < this->numScriptTag; ++i) { + this->scriptTag.emplace_back(); + if (!table.ReadU32(&this->scriptTag[i])) { + return parent->Error("SILSub: Failed to read scriptTag[%u]", i); + } + } + + if (!table.ReadU16(&this->lbGID)) { + return parent->Error("SILSub: Failed to read lbGID"); + } + if (this->lbGID > this->maxGlyphID) { + parent->Warning("SILSub: lbGID %u outside range 0..%u, replaced with 0", + this->lbGID, this->maxGlyphID); + this->lbGID = 0; + } + + if (parent->version >> 16 >= 3 && + table.offset() != init_offset + this->passOffset) { + return parent->Error("SILSub: passOffset check failed"); + } + unsigned long last_oPass = 0; + //this->oPasses.resize(static_cast<unsigned>(this->numPasses) + 1); + for (unsigned i = 0; i <= this->numPasses; ++i) { + this->oPasses.emplace_back(); + if (!table.ReadU32(&this->oPasses[i]) || this->oPasses[i] < last_oPass) { + return false; + } + last_oPass = this->oPasses[i]; + } + + if (parent->version >> 16 >= 3 && + table.offset() != init_offset + this->pseudosOffset) { + return parent->Error("SILSub: pseudosOffset check failed"); + } + if (!table.ReadU16(&this->numPseudo)) { + return parent->Error("SILSub: Failed to read numPseudo"); + } + + // The following three fields are deprecated and ignored. We fix them up here + // just for internal consistency, but the Graphite engine doesn't care. + if (!table.ReadU16(&this->searchPseudo) || + !table.ReadU16(&this->pseudoSelector) || + !table.ReadU16(&this->pseudoShift)) { + return parent->Error("SILSub: Failed to read searchPseudo..pseudoShift"); + } + if (this->numPseudo == 0) { + if (this->searchPseudo != 0 || this->pseudoSelector != 0 || this->pseudoShift != 0) { + this->searchPseudo = this->pseudoSelector = this->pseudoShift = 0; + } + } else { + unsigned floorLog2 = std::floor(std::log2(this->numPseudo)); + if (this->searchPseudo != 6 * (unsigned)std::pow(2, floorLog2) || + this->pseudoSelector != floorLog2 || + this->pseudoShift != 6 * this->numPseudo - this->searchPseudo) { + this->searchPseudo = 6 * (unsigned)std::pow(2, floorLog2); + this->pseudoSelector = floorLog2; + this->pseudoShift = 6 * this->numPseudo - this->searchPseudo; + } + } + + //this->pMaps.resize(this->numPseudo, parent); + for (unsigned i = 0; i < numPseudo; i++) { + this->pMaps.emplace_back(parent); + if (!this->pMaps[i].ParsePart(table)) { + return parent->Error("SILSub: Failed to read pMaps[%u]", i); + } + } + + if (!this->classes.ParsePart(table)) { + return parent->Error("SILSub: Failed to read classes"); + } + + //this->passes.resize(this->numPasses, parent); + for (unsigned i = 0; i < this->numPasses; ++i) { + this->passes.emplace_back(parent); + if (table.offset() != init_offset + this->oPasses[i]) { + return parent->Error("SILSub: Offset check failed for passes[%u]", i); + } + if (!this->passes[i].ParsePart(table, init_offset, this->oPasses[i+1])) { + return parent->Error("SILSub: Failed to read passes[%u]", i); + } + } + return true; +} + +bool OpenTypeSILF::SILSub::SerializePart(OTSStream* out) const { + if ((parent->version >> 16 >= 3 && + (!out->WriteU32(this->ruleVersion) || + !out->WriteU16(this->passOffset) || + !out->WriteU16(this->pseudosOffset))) || + !out->WriteU16(this->maxGlyphID) || + !out->WriteS16(this->extraAscent) || + !out->WriteS16(this->extraDescent) || + !out->WriteU8(this->numPasses) || + !out->WriteU8(this->iSubst) || + !out->WriteU8(this->iPos) || + !out->WriteU8(this->iJust) || + !out->WriteU8(this->iBidi) || + !out->WriteU8(this->flags) || + !out->WriteU8(this->maxPreContext) || + !out->WriteU8(this->maxPostContext) || + !out->WriteU8(this->attrPseudo) || + !out->WriteU8(this->attrBreakWeight) || + !out->WriteU8(this->attrDirectionality) || + (parent->version >> 16 >= 2 && + (!out->WriteU8(this->attrMirroring) || + !out->WriteU8(this->attrSkipPasses) || + !out->WriteU8(this->numJLevels) || + !SerializeParts(this->jLevels, out))) || + !out->WriteU16(this->numLigComp) || + !out->WriteU8(this->numUserDefn) || + !out->WriteU8(this->maxCompPerLig) || + !out->WriteU8(this->direction) || + !out->WriteU8(this->attCollisions) || + !out->WriteU8(this->reserved4) || + !out->WriteU8(this->reserved5) || + (parent->version >> 16 >= 2 && + (!out->WriteU8(this->reserved6) || + !out->WriteU8(this->numCritFeatures) || + !SerializeParts(this->critFeatures, out) || + !out->WriteU8(this->reserved7))) || + !out->WriteU8(this->numScriptTag) || + !SerializeParts(this->scriptTag, out) || + !out->WriteU16(this->lbGID) || + !SerializeParts(this->oPasses, out) || + !out->WriteU16(this->numPseudo) || + !out->WriteU16(this->searchPseudo) || + !out->WriteU16(this->pseudoSelector) || + !out->WriteU16(this->pseudoShift) || + !SerializeParts(this->pMaps, out) || + !this->classes.SerializePart(out) || + !SerializeParts(this->passes, out)) { + return parent->Error("SILSub: Failed to write"); + } + return true; +} + +bool OpenTypeSILF::SILSub:: +JustificationLevel::ParsePart(Buffer& table) { + if (!table.ReadU8(&this->attrStretch)) { + return parent->Error("JustificationLevel: Failed to read attrStretch"); + } + if (!table.ReadU8(&this->attrShrink)) { + return parent->Error("JustificationLevel: Failed to read attrShrink"); + } + if (!table.ReadU8(&this->attrStep)) { + return parent->Error("JustificationLevel: Failed to read attrStep"); + } + if (!table.ReadU8(&this->attrWeight)) { + return parent->Error("JustificationLevel: Failed to read attrWeight"); + } + if (!table.ReadU8(&this->runto)) { + return parent->Error("JustificationLevel: Failed to read runto"); + } + if (!table.ReadU8(&this->reserved)) { + return parent->Error("JustificationLevel: Failed to read reserved"); + } + if (this->reserved != 0) { + parent->Warning("JustificationLevel: Nonzero reserved"); + } + if (!table.ReadU8(&this->reserved2)) { + return parent->Error("JustificationLevel: Failed to read reserved2"); + } + if (this->reserved2 != 0) { + parent->Warning("JustificationLevel: Nonzero reserved2"); + } + if (!table.ReadU8(&this->reserved3)) { + return parent->Error("JustificationLevel: Failed to read reserved3"); + } + if (this->reserved3 != 0) { + parent->Warning("JustificationLevel: Nonzero reserved3"); + } + return true; +} + +bool OpenTypeSILF::SILSub:: +JustificationLevel::SerializePart(OTSStream* out) const { + if (!out->WriteU8(this->attrStretch) || + !out->WriteU8(this->attrShrink) || + !out->WriteU8(this->attrStep) || + !out->WriteU8(this->attrWeight) || + !out->WriteU8(this->runto) || + !out->WriteU8(this->reserved) || + !out->WriteU8(this->reserved2) || + !out->WriteU8(this->reserved3)) { + return parent->Error("JustificationLevel: Failed to write"); + } + return true; +} + +bool OpenTypeSILF::SILSub:: +PseudoMap::ParsePart(Buffer& table) { + if (parent->version >> 16 >= 2 && !table.ReadU32(&this->unicode)) { + return parent->Error("PseudoMap: Failed to read unicode"); + } + if (parent->version >> 16 == 1) { + uint16_t unicode; + if (!table.ReadU16(&unicode)) { + return parent->Error("PseudoMap: Failed to read unicode"); + } + this->unicode = unicode; + } + if (!table.ReadU16(&this->nPseudo)) { + return parent->Error("PseudoMap: Failed to read nPseudo"); + } + return true; +} + +bool OpenTypeSILF::SILSub:: +PseudoMap::SerializePart(OTSStream* out) const { + if ((parent->version >> 16 >= 2 && !out->WriteU32(this->unicode)) || + (parent->version >> 16 == 1 && + !out->WriteU16(static_cast<uint16_t>(this->unicode))) || + !out->WriteU16(this->nPseudo)) { + return parent->Error("PseudoMap: Failed to write"); + } + return true; +} + +bool OpenTypeSILF::SILSub:: +ClassMap::ParsePart(Buffer& table) { + size_t init_offset = table.offset(); + if (!table.ReadU16(&this->numClass)) { + return parent->Error("ClassMap: Failed to read numClass"); + } + if (!table.ReadU16(&this->numLinear) || this->numLinear > this->numClass) { + return parent->Error("ClassMap: Failed to read valid numLinear"); + } + + //this->oClass.resize(static_cast<unsigned long>(this->numClass) + 1); + if (parent->version >> 16 >= 4) { + unsigned long last_oClass = 0; + for (unsigned long i = 0; i <= this->numClass; ++i) { + this->oClass.emplace_back(); + if (!table.ReadU32(&this->oClass[i]) || this->oClass[i] < last_oClass) { + return parent->Error("ClassMap: Failed to read oClass[%lu]", i); + } + last_oClass = this->oClass[i]; + } + } + if (parent->version >> 16 < 4) { + unsigned last_oClass = 0; + for (unsigned long i = 0; i <= this->numClass; ++i) { + uint16_t offset; + if (!table.ReadU16(&offset) || offset < last_oClass) { + return parent->Error("ClassMap: Failed to read oClass[%lu]", i); + } + last_oClass = offset; + this->oClass.push_back(static_cast<uint32_t>(offset)); + } + } + + if (table.offset() - init_offset > this->oClass[this->numLinear]) { + return parent->Error("ClassMap: Failed to calculate length of glyphs"); + } + unsigned long glyphs_len = (this->oClass[this->numLinear] - + (table.offset() - init_offset))/2; + //this->glyphs.resize(glyphs_len); + for (unsigned long i = 0; i < glyphs_len; ++i) { + this->glyphs.emplace_back(); + if (!table.ReadU16(&this->glyphs[i])) { + return parent->Error("ClassMap: Failed to read glyphs[%lu]", i); + } + } + + unsigned lookups_len = this->numClass - this->numLinear; + // this->numLinear <= this->numClass + //this->lookups.resize(lookups_len, parent); + for (unsigned i = 0; i < lookups_len; ++i) { + this->lookups.emplace_back(parent); + if (table.offset() != init_offset + oClass[this->numLinear + i]) { + return parent->Error("ClassMap: Offset check failed for lookups[%u]", i); + } + if (!this->lookups[i].ParsePart(table)) { + return parent->Error("ClassMap: Failed to read lookups[%u]", i); + } + } + return true; +} + +bool OpenTypeSILF::SILSub:: +ClassMap::SerializePart(OTSStream* out) const { + if (!out->WriteU16(this->numClass) || + !out->WriteU16(this->numLinear) || + (parent->version >> 16 >= 4 && !SerializeParts(this->oClass, out)) || + (parent->version >> 16 < 4 && + ![&] { + for (uint32_t offset : this->oClass) { + if (!out->WriteU16(static_cast<uint16_t>(offset))) { + return false; + } + } + return true; + }()) || + !SerializeParts(this->glyphs, out) || + !SerializeParts(this->lookups, out)) { + return parent->Error("ClassMap: Failed to write"); + } + return true; +} + +bool OpenTypeSILF::SILSub::ClassMap:: +LookupClass::ParsePart(Buffer& table) { + if (!table.ReadU16(&this->numIDs)) { + return parent->Error("LookupClass: Failed to read numIDs"); + } + if (!table.ReadU16(&this->searchRange) || + !table.ReadU16(&this->entrySelector) || + !table.ReadU16(&this->rangeShift)) { + return parent->Error("LookupClass: Failed to read searchRange..rangeShift"); + } + if (this->numIDs == 0) { + if (this->searchRange != 0 || this->entrySelector != 0 || this->rangeShift != 0) { + parent->Warning("LookupClass: Correcting binary-search header for zero-length LookupPair list"); + this->searchRange = this->entrySelector = this->rangeShift = 0; + } + } else { + unsigned floorLog2 = std::floor(std::log2(this->numIDs)); + if (this->searchRange != (unsigned)std::pow(2, floorLog2) || + this->entrySelector != floorLog2 || + this->rangeShift != this->numIDs - this->searchRange) { + parent->Warning("LookupClass: Correcting binary-search header for LookupPair list"); + this->searchRange = (unsigned)std::pow(2, floorLog2); + this->entrySelector = floorLog2; + this->rangeShift = this->numIDs - this->searchRange; + } + } + + //this->lookups.resize(this->numIDs, parent); + for (unsigned i = 0; i < numIDs; ++i) { + this->lookups.emplace_back(parent); + if (!this->lookups[i].ParsePart(table)) { + return parent->Error("LookupClass: Failed to read lookups[%u]", i); + } + } + return true; +} + +bool OpenTypeSILF::SILSub::ClassMap:: +LookupClass::SerializePart(OTSStream* out) const { + if (!out->WriteU16(this->numIDs) || + !out->WriteU16(this->searchRange) || + !out->WriteU16(this->entrySelector) || + !out->WriteU16(this->rangeShift) || + !SerializeParts(this->lookups, out)) { + return parent->Error("LookupClass: Failed to write"); + } + return true; +} + +bool OpenTypeSILF::SILSub::ClassMap::LookupClass:: +LookupPair::ParsePart(Buffer& table) { + if (!table.ReadU16(&this->glyphId)) { + return parent->Error("LookupPair: Failed to read glyphId"); + } + if (!table.ReadU16(&this->index)) { + return parent->Error("LookupPair: Failed to read index"); + } + return true; +} + +bool OpenTypeSILF::SILSub::ClassMap::LookupClass:: +LookupPair::SerializePart(OTSStream* out) const { + if (!out->WriteU16(this->glyphId) || + !out->WriteU16(this->index)) { + return parent->Error("LookupPair: Failed to write"); + } + return true; +} + +bool OpenTypeSILF::SILSub:: +SILPass::ParsePart(Buffer& table, const size_t SILSub_init_offset, + const size_t next_pass_offset) { + size_t init_offset = table.offset(); + if (!table.ReadU8(&this->flags)) { + return parent->Error("SILPass: Failed to read flags"); + // checks omitted + } + if (!table.ReadU8(&this->maxRuleLoop)) { + return parent->Error("SILPass: Failed to read valid maxRuleLoop"); + } + if (!table.ReadU8(&this->maxRuleContext)) { + return parent->Error("SILPass: Failed to read maxRuleContext"); + } + if (!table.ReadU8(&this->maxBackup)) { + return parent->Error("SILPass: Failed to read maxBackup"); + } + if (!table.ReadU16(&this->numRules)) { + return parent->Error("SILPass: Failed to read numRules"); + } + if (parent->version >> 16 >= 2) { + if (!table.ReadU16(&this->fsmOffset)) { + return parent->Error("SILPass: Failed to read fsmOffset"); + } + if (!table.ReadU32(&this->pcCode) || + (parent->version >= 3 && this->pcCode < this->fsmOffset)) { + return parent->Error("SILPass: Failed to read pcCode"); + } + } + if (!table.ReadU32(&this->rcCode) || + (parent->version >> 16 >= 2 && this->rcCode < this->pcCode)) { + return parent->Error("SILPass: Failed to read valid rcCode"); + } + if (!table.ReadU32(&this->aCode) || this->aCode < this->rcCode) { + return parent->Error("SILPass: Failed to read valid aCode"); + } + if (!table.ReadU32(&this->oDebug) || + (this->oDebug && this->oDebug < this->aCode)) { + return parent->Error("SILPass: Failed to read valid oDebug"); + } + if (parent->version >> 16 >= 3 && + table.offset() != init_offset + this->fsmOffset) { + return parent->Error("SILPass: fsmOffset check failed"); + } + if (!table.ReadU16(&this->numRows) || + (this->oDebug && this->numRows < this->numRules)) { + return parent->Error("SILPass: Failed to read valid numRows"); + } + if (!table.ReadU16(&this->numTransitional)) { + return parent->Error("SILPass: Failed to read numTransitional"); + } + if (!table.ReadU16(&this->numSuccess)) { + return parent->Error("SILPass: Failed to read numSuccess"); + } + if (!table.ReadU16(&this->numColumns)) { + return parent->Error("SILPass: Failed to read numColumns"); + } + if (!table.ReadU16(&this->numRange)) { + return parent->Error("SILPass: Failed to read numRange"); + } + + // The following three fields are deprecated and ignored. We fix them up here + // just for internal consistency, but the Graphite engine doesn't care. + if (!table.ReadU16(&this->searchRange) || + !table.ReadU16(&this->entrySelector) || + !table.ReadU16(&this->rangeShift)) { + return parent->Error("SILPass: Failed to read searchRange..rangeShift"); + } + if (this->numRange == 0) { + if (this->searchRange != 0 || this->entrySelector != 0 || this->rangeShift != 0) { + this->searchRange = this->entrySelector = this->rangeShift = 0; + } + } else { + unsigned floorLog2 = std::floor(std::log2(this->numRange)); + if (this->searchRange != 6 * (unsigned)std::pow(2, floorLog2) || + this->entrySelector != floorLog2 || + this->rangeShift != 6 * this->numRange - this->searchRange) { + this->searchRange = 6 * (unsigned)std::pow(2, floorLog2); + this->entrySelector = floorLog2; + this->rangeShift = 6 * this->numRange - this->searchRange; + } + } + + //this->ranges.resize(this->numRange, parent); + for (unsigned i = 0 ; i < this->numRange; ++i) { + this->ranges.emplace_back(parent); + if (!this->ranges[i].ParsePart(table)) { + return parent->Error("SILPass: Failed to read ranges[%u]", i); + } + } + unsigned ruleMap_len = 0; // maximum value in oRuleMap + //this->oRuleMap.resize(static_cast<unsigned long>(this->numSuccess) + 1); + for (unsigned long i = 0; i <= this->numSuccess; ++i) { + this->oRuleMap.emplace_back(); + if (!table.ReadU16(&this->oRuleMap[i])) { + return parent->Error("SILPass: Failed to read oRuleMap[%u]", i); + } + if (oRuleMap[i] > ruleMap_len) { + ruleMap_len = oRuleMap[i]; + } + } + + //this->ruleMap.resize(ruleMap_len); + for (unsigned i = 0; i < ruleMap_len; ++i) { + this->ruleMap.emplace_back(); + if (!table.ReadU16(&this->ruleMap[i])) { + return parent->Error("SILPass: Failed to read ruleMap[%u]", i); + } + } + + if (!table.ReadU8(&this->minRulePreContext)) { + return parent->Error("SILPass: Failed to read minRulePreContext"); + } + if (!table.ReadU8(&this->maxRulePreContext) || + this->maxRulePreContext < this->minRulePreContext) { + return parent->Error("SILPass: Failed to read valid maxRulePreContext"); + } + + unsigned startStates_len = this->maxRulePreContext - this->minRulePreContext + + 1; + // this->minRulePreContext <= this->maxRulePreContext + //this->startStates.resize(startStates_len); + for (unsigned i = 0; i < startStates_len; ++i) { + this->startStates.emplace_back(); + if (!table.ReadS16(&this->startStates[i])) { + return parent->Error("SILPass: Failed to read startStates[%u]", i); + } + } + + //this->ruleSortKeys.resize(this->numRules); + for (unsigned i = 0; i < this->numRules; ++i) { + this->ruleSortKeys.emplace_back(); + if (!table.ReadU16(&this->ruleSortKeys[i])) { + return parent->Error("SILPass: Failed to read ruleSortKeys[%u]", i); + } + } + + //this->rulePreContext.resize(this->numRules); + for (unsigned i = 0; i < this->numRules; ++i) { + this->rulePreContext.emplace_back(); + if (!table.ReadU8(&this->rulePreContext[i])) { + return parent->Error("SILPass: Failed to read rulePreContext[%u]", i); + } + } + + if (parent->version >> 16 >= 2) { + if (!table.ReadU8(&this->collisionThreshold)) { + return parent->Error("SILPass: Failed to read collisionThreshold"); + } + if (!table.ReadU16(&this->pConstraint)) { + return parent->Error("SILPass: Failed to read pConstraint"); + } + } + + unsigned long ruleConstraints_len = this->aCode - this->rcCode; + // this->rcCode <= this->aCode + //this->oConstraints.resize(static_cast<unsigned long>(this->numRules) + 1); + for (unsigned long i = 0; i <= this->numRules; ++i) { + this->oConstraints.emplace_back(); + if (!table.ReadU16(&this->oConstraints[i]) || + this->oConstraints[i] > ruleConstraints_len) { + return parent->Error("SILPass: Failed to read valid oConstraints[%lu]", + i); + } + } + + if (!this->oDebug && this->aCode > next_pass_offset) { + return parent->Error("SILPass: Failed to calculate length of actions"); + } + unsigned long actions_len = this->oDebug ? this->oDebug - this->aCode : + next_pass_offset - this->aCode; + // if this->oDebug, then this->aCode <= this->oDebug + //this->oActions.resize(static_cast<unsigned long>(this->numRules) + 1); + for (unsigned long i = 0; i <= this->numRules; ++i) { + this->oActions.emplace_back(); + if (!table.ReadU16(&this->oActions[i]) || + (this->oActions[i] > actions_len)) { + return parent->Error("SILPass: Failed to read valid oActions[%lu]", i); + } + } + + //this->stateTrans.resize(this->numTransitional); + for (unsigned i = 0; i < this->numTransitional; ++i) { + this->stateTrans.emplace_back(); + //this->stateTrans[i].resize(this->numColumns); + for (unsigned j = 0; j < this->numColumns; ++j) { + this->stateTrans[i].emplace_back(); + if (!table.ReadU16(&stateTrans[i][j])) { + return parent->Error("SILPass: Failed to read stateTrans[%u][%u]", + i, j); + } + } + } + + if (parent->version >> 16 >= 2) { + if (!table.ReadU8(&this->reserved2)) { + return parent->Error("SILPass: Failed to read reserved2"); + } + if (this->reserved2 != 0) { + parent->Warning("SILPass: Nonzero reserved2"); + } + + if (table.offset() != SILSub_init_offset + this->pcCode) { + return parent->Error("SILPass: pcCode check failed"); + } + //this->passConstraints.resize(this->pConstraint); + for (unsigned i = 0; i < this->pConstraint; ++i) { + this->passConstraints.emplace_back(); + if (!table.ReadU8(&this->passConstraints[i])) { + return parent->Error("SILPass: Failed to read passConstraints[%u]", i); + } + } + } + + if (table.offset() != SILSub_init_offset + this->rcCode) { + return parent->Error("SILPass: rcCode check failed"); + } + //this->ruleConstraints.resize(ruleConstraints_len); // calculated above + for (unsigned long i = 0; i < ruleConstraints_len; ++i) { + this->ruleConstraints.emplace_back(); + if (!table.ReadU8(&this->ruleConstraints[i])) { + return parent->Error("SILPass: Failed to read ruleConstraints[%u]", i); + } + } + + if (table.offset() != SILSub_init_offset + this->aCode) { + return parent->Error("SILPass: aCode check failed"); + } + //this->actions.resize(actions_len); // calculated above + for (unsigned long i = 0; i < actions_len; ++i) { + this->actions.emplace_back(); + if (!table.ReadU8(&this->actions[i])) { + return parent->Error("SILPass: Failed to read actions[%u]", i); + } + } + + if (this->oDebug) { + OpenTypeNAME* name = static_cast<OpenTypeNAME*>( + parent->GetFont()->GetTypedTable(OTS_TAG_NAME)); + if (!name) { + return parent->Error("SILPass: Required name table is missing"); + } + + if (table.offset() != SILSub_init_offset + this->oDebug) { + return parent->Error("SILPass: oDebug check failed"); + } + //this->dActions.resize(this->numRules); + for (unsigned i = 0; i < this->numRules; ++i) { + this->dActions.emplace_back(); + if (!table.ReadU16(&this->dActions[i]) || + !name->IsValidNameId(this->dActions[i])) { + return parent->Error("SILPass: Failed to read valid dActions[%u]", i); + } + } + + unsigned dStates_len = this->numRows - this->numRules; + // this->numRules <= this->numRows + //this->dStates.resize(dStates_len); + for (unsigned i = 0; i < dStates_len; ++i) { + this->dStates.emplace_back(); + if (!table.ReadU16(&this->dStates[i]) || + !name->IsValidNameId(this->dStates[i])) { + return parent->Error("SILPass: Failed to read valid dStates[%u]", i); + } + } + + //this->dCols.resize(this->numRules); + for (unsigned i = 0; i < this->numRules; ++i) { + this->dCols.emplace_back(); + if (!table.ReadU16(&this->dCols[i]) || + !name->IsValidNameId(this->dCols[i])) { + return parent->Error("SILPass: Failed to read valid dCols[%u]"); + } + } + } + return true; +} + +bool OpenTypeSILF::SILSub:: +SILPass::SerializePart(OTSStream* out) const { + if (!out->WriteU8(this->flags) || + !out->WriteU8(this->maxRuleLoop) || + !out->WriteU8(this->maxRuleContext) || + !out->WriteU8(this->maxBackup) || + !out->WriteU16(this->numRules) || + (parent->version >> 16 >= 2 && + (!out->WriteU16(this->fsmOffset) || + !out->WriteU32(this->pcCode))) || + !out->WriteU32(this->rcCode) || + !out->WriteU32(this->aCode) || + !out->WriteU32(this->oDebug) || + !out->WriteU16(this->numRows) || + !out->WriteU16(this->numTransitional) || + !out->WriteU16(this->numSuccess) || + !out->WriteU16(this->numColumns) || + !out->WriteU16(this->numRange) || + !out->WriteU16(this->searchRange) || + !out->WriteU16(this->entrySelector) || + !out->WriteU16(this->rangeShift) || + !SerializeParts(this->ranges, out) || + !SerializeParts(this->oRuleMap, out) || + !SerializeParts(this->ruleMap, out) || + !out->WriteU8(this->minRulePreContext) || + !out->WriteU8(this->maxRulePreContext) || + !SerializeParts(this->startStates, out) || + !SerializeParts(this->ruleSortKeys, out) || + !SerializeParts(this->rulePreContext, out) || + (parent->version >> 16 >= 2 && + (!out->WriteU8(this->collisionThreshold) || + !out->WriteU16(this->pConstraint))) || + !SerializeParts(this->oConstraints, out) || + !SerializeParts(this->oActions, out) || + !SerializeParts(this->stateTrans, out) || + (parent->version >> 16 >= 2 && + (!out->WriteU8(this->reserved2) || + !SerializeParts(this->passConstraints, out))) || + !SerializeParts(this->ruleConstraints, out) || + !SerializeParts(this->actions, out) || + !SerializeParts(this->dActions, out) || + !SerializeParts(this->dStates, out) || + !SerializeParts(this->dCols, out)) { + return parent->Error("SILPass: Failed to write"); + } + return true; +} + +bool OpenTypeSILF::SILSub::SILPass:: +PassRange::ParsePart(Buffer& table) { + if (!table.ReadU16(&this->firstId)) { + return parent->Error("PassRange: Failed to read firstId"); + } + if (!table.ReadU16(&this->lastId)) { + return parent->Error("PassRange: Failed to read lastId"); + } + if (!table.ReadU16(&this->colId)) { + return parent->Error("PassRange: Failed to read colId"); + } + return true; +} + +bool OpenTypeSILF::SILSub::SILPass:: +PassRange::SerializePart(OTSStream* out) const { + if (!out->WriteU16(this->firstId) || + !out->WriteU16(this->lastId) || + !out->WriteU16(this->colId)) { + return parent->Error("PassRange: Failed to write"); + } + return true; +} + +} // namespace ots diff --git a/gfx/ots/src/silf.h b/gfx/ots/src/silf.h new file mode 100644 index 000000000..b6c08032f --- /dev/null +++ b/gfx/ots/src/silf.h @@ -0,0 +1,196 @@ +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef OTS_SILF_H_ +#define OTS_SILF_H_ + +#include <vector> + +#include "ots.h" +#include "graphite.h" + +namespace ots { + +class OpenTypeSILF : public Table { + public: + explicit OpenTypeSILF(Font* font, uint32_t tag) + : Table(font, tag, tag) { } + + bool Parse(const uint8_t* data, size_t length) { + return this->Parse(data, length, false); + } + bool Serialize(OTSStream* out); + + private: + bool Parse(const uint8_t* data, size_t length, bool prevent_decompression); + struct SILSub : public TablePart<OpenTypeSILF> { + explicit SILSub(OpenTypeSILF* parent) + : TablePart<OpenTypeSILF>(parent), classes(parent) { } + bool ParsePart(Buffer& table); + bool SerializePart(OTSStream* out) const; + struct JustificationLevel : public TablePart<OpenTypeSILF> { + explicit JustificationLevel(OpenTypeSILF* parent) + : TablePart<OpenTypeSILF>(parent) { } + bool ParsePart(Buffer& table); + bool SerializePart(OTSStream* out) const; + uint8_t attrStretch; + uint8_t attrShrink; + uint8_t attrStep; + uint8_t attrWeight; + uint8_t runto; + uint8_t reserved; + uint8_t reserved2; + uint8_t reserved3; + }; + struct PseudoMap : public TablePart<OpenTypeSILF> { + explicit PseudoMap(OpenTypeSILF* parent) + : TablePart<OpenTypeSILF>(parent) { } + bool ParsePart(Buffer& table); + bool SerializePart(OTSStream* out) const; + uint32_t unicode; + uint16_t nPseudo; + }; + struct ClassMap : public TablePart<OpenTypeSILF> { + explicit ClassMap(OpenTypeSILF* parent) + : TablePart<OpenTypeSILF>(parent) { } + bool ParsePart(Buffer& table); + bool SerializePart(OTSStream* out) const; + struct LookupClass : public TablePart<OpenTypeSILF> { + explicit LookupClass(OpenTypeSILF* parent) + : TablePart<OpenTypeSILF>(parent) { } + bool ParsePart(Buffer& table); + bool SerializePart(OTSStream* out) const; + struct LookupPair : public TablePart<OpenTypeSILF> { + explicit LookupPair(OpenTypeSILF* parent) + : TablePart<OpenTypeSILF>(parent) { } + bool ParsePart(Buffer& table); + bool SerializePart(OTSStream* out) const; + uint16_t glyphId; + uint16_t index; + }; + uint16_t numIDs; + uint16_t searchRange; + uint16_t entrySelector; + uint16_t rangeShift; + std::vector<LookupPair> lookups; + }; + uint16_t numClass; + uint16_t numLinear; + std::vector<uint32_t> oClass; // uint16_t before v4 + std::vector<uint16_t> glyphs; + std::vector<LookupClass> lookups; + }; + struct SILPass : public TablePart<OpenTypeSILF> { + explicit SILPass(OpenTypeSILF* parent) + : TablePart<OpenTypeSILF>(parent) { } + bool ParsePart(Buffer& table) { return false; } + bool ParsePart(Buffer& table, const size_t SILSub_init_offset, + const size_t next_pass_offset); + bool SerializePart(OTSStream* out) const; + struct PassRange : public TablePart<OpenTypeSILF> { + explicit PassRange(OpenTypeSILF* parent) + : TablePart<OpenTypeSILF>(parent) { } + bool ParsePart(Buffer& table); + bool SerializePart(OTSStream* out) const; + uint16_t firstId; + uint16_t lastId; + uint16_t colId; + }; + uint8_t flags; + uint8_t maxRuleLoop; + uint8_t maxRuleContext; + uint8_t maxBackup; + uint16_t numRules; + uint16_t fsmOffset; + uint32_t pcCode; + uint32_t rcCode; + uint32_t aCode; + uint32_t oDebug; + uint16_t numRows; + uint16_t numTransitional; + uint16_t numSuccess; + uint16_t numColumns; + uint16_t numRange; + uint16_t searchRange; + uint16_t entrySelector; + uint16_t rangeShift; + std::vector<PassRange> ranges; + std::vector<uint16_t> oRuleMap; + std::vector<uint16_t> ruleMap; + uint8_t minRulePreContext; + uint8_t maxRulePreContext; + std::vector<int16_t> startStates; + std::vector<uint16_t> ruleSortKeys; + std::vector<uint8_t> rulePreContext; + uint8_t collisionThreshold; // reserved before v5 + uint16_t pConstraint; + std::vector<uint16_t> oConstraints; + std::vector<uint16_t> oActions; + std::vector<std::vector<uint16_t>> stateTrans; + uint8_t reserved2; + std::vector<uint8_t> passConstraints; + std::vector<uint8_t> ruleConstraints; + std::vector<uint8_t> actions; + std::vector<uint16_t> dActions; + std::vector<uint16_t> dStates; + std::vector<uint16_t> dCols; + }; + uint32_t ruleVersion; + uint16_t passOffset; + uint16_t pseudosOffset; + uint16_t maxGlyphID; + int16_t extraAscent; + int16_t extraDescent; + uint8_t numPasses; + uint8_t iSubst; + uint8_t iPos; + uint8_t iJust; + uint8_t iBidi; + uint8_t flags; + uint8_t maxPreContext; + uint8_t maxPostContext; + uint8_t attrPseudo; + uint8_t attrBreakWeight; + uint8_t attrDirectionality; + uint8_t attrMirroring; // reserved before v4 + uint8_t attrSkipPasses; // reserved2 before v4 + uint8_t numJLevels; + std::vector<JustificationLevel> jLevels; + uint16_t numLigComp; + uint8_t numUserDefn; + uint8_t maxCompPerLig; + uint8_t direction; + uint8_t attCollisions; // reserved3 before v5 + uint8_t reserved4; + uint8_t reserved5; + uint8_t reserved6; + uint8_t numCritFeatures; + std::vector<uint16_t> critFeatures; + uint8_t reserved7; + uint8_t numScriptTag; + std::vector<uint32_t> scriptTag; + uint16_t lbGID; + std::vector<uint32_t> oPasses; + uint16_t numPseudo; + uint16_t searchPseudo; + uint16_t pseudoSelector; + uint16_t pseudoShift; + std::vector<PseudoMap> pMaps; + ClassMap classes; + std::vector<SILPass> passes; + }; + uint32_t version; + uint32_t compHead; // compression header + static const uint32_t SCHEME = 0xF8000000; + static const uint32_t FULL_SIZE = 0x07FFFFFF; + static const uint32_t COMPILER_VERSION = 0x07FFFFFF; + uint16_t numSub; + uint16_t reserved; + std::vector<uint32_t> offset; + std::vector<SILSub> tables; +}; + +} // namespace ots + +#endif // OTS_SILF_H_ diff --git a/gfx/ots/src/sill.cc b/gfx/ots/src/sill.cc new file mode 100644 index 000000000..c7b20a980 --- /dev/null +++ b/gfx/ots/src/sill.cc @@ -0,0 +1,159 @@ +// Copyright (c) 2009-2017 The OTS 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 "sill.h" + +#include "feat.h" +#include <cmath> +#include <unordered_set> + +namespace ots { + +bool OpenTypeSILL::Parse(const uint8_t* data, size_t length) { + if (GetFont()->dropped_graphite) { + return Drop("Skipping Graphite table"); + } + Buffer table(data, length); + + if (!table.ReadU32(&this->version) || this->version >> 16 != 1) { + return Drop("Failed to read valid version"); + } + if (!table.ReadU16(&this->numLangs)) { + return Drop("Failed to read numLangs"); + } + + // The following three fields are deprecated and ignored. We fix them up here + // just for internal consistency, but the Graphite engine doesn't care. + if (!table.ReadU16(&this->searchRange) || + !table.ReadU16(&this->entrySelector) || + !table.ReadU16(&this->rangeShift)) { + return Drop("Failed to read searchRange..rangeShift"); + } + if (this->numLangs == 0) { + if (this->searchRange != 0 || this->entrySelector != 0 || this->rangeShift != 0) { + this->searchRange = this->entrySelector = this->rangeShift = 0; + } + } else { + unsigned floorLog2 = std::floor(std::log2(this->numLangs)); + if (this->searchRange != (unsigned)std::pow(2, floorLog2) || + this->entrySelector != floorLog2 || + this->rangeShift != this->numLangs - this->searchRange) { + this->searchRange = (unsigned)std::pow(2, floorLog2); + this->entrySelector = floorLog2; + this->rangeShift = this->numLangs - this->searchRange; + } + } + + std::unordered_set<size_t> unverified; + //this->entries.resize(static_cast<unsigned long>(this->numLangs) + 1, this); + for (unsigned long i = 0; i <= this->numLangs; ++i) { + this->entries.emplace_back(this); + LanguageEntry& entry = this->entries[i]; + if (!entry.ParsePart(table)) { + return Drop("Failed to read entries[%u]", i); + } + for (unsigned j = 0; j < entry.numSettings; ++j) { + size_t offset = entry.offset + j * 8; + if (offset < entry.offset || offset > length) { + return DropGraphite("Invalid LangFeatureSetting offset %zu/%zu", + offset, length); + } + unverified.insert(offset); + // need to verify that this LanguageEntry points to valid + // LangFeatureSetting + } + } + + while (table.remaining()) { + unverified.erase(table.offset()); + LangFeatureSetting setting(this); + if (!setting.ParsePart(table)) { + return Drop("Failed to read a LangFeatureSetting"); + } + settings.push_back(setting); + } + + if (!unverified.empty()) { + return Drop("%zu incorrect offsets into settings", unverified.size()); + } + if (table.remaining()) { + return Warning("%zu bytes unparsed", table.remaining()); + } + return true; +} + +bool OpenTypeSILL::Serialize(OTSStream* out) { + if (!out->WriteU32(this->version) || + !out->WriteU16(this->numLangs) || + !out->WriteU16(this->searchRange) || + !out->WriteU16(this->entrySelector) || + !out->WriteU16(this->rangeShift) || + !SerializeParts(this->entries, out) || + !SerializeParts(this->settings, out)) { + return Error("Failed to write table"); + } + return true; +} + +bool OpenTypeSILL::LanguageEntry::ParsePart(Buffer& table) { + if (!table.ReadU8(&this->langcode[0]) || + !table.ReadU8(&this->langcode[1]) || + !table.ReadU8(&this->langcode[2]) || + !table.ReadU8(&this->langcode[3])) { + return parent->Error("LanguageEntry: Failed to read langcode"); + } + if (!table.ReadU16(&this->numSettings)) { + return parent->Error("LanguageEntry: Failed to read numSettings"); + } + if (!table.ReadU16(&this->offset)) { + return parent->Error("LanguageEntry: Failed to read offset"); + } + return true; +} + +bool OpenTypeSILL::LanguageEntry::SerializePart(OTSStream* out) const { + if (!out->WriteU8(this->langcode[0]) || + !out->WriteU8(this->langcode[1]) || + !out->WriteU8(this->langcode[2]) || + !out->WriteU8(this->langcode[3]) || + !out->WriteU16(this->numSettings) || + !out->WriteU16(this->offset)) { + return parent->Error("LanguageEntry: Failed to write"); + } + return true; +} + +bool OpenTypeSILL::LangFeatureSetting::ParsePart(Buffer& table) { + OpenTypeFEAT* feat = static_cast<OpenTypeFEAT*>( + parent->GetFont()->GetTypedTable(OTS_TAG_FEAT)); + if (!feat) { + return parent->Error("FeatureDefn: Required Feat table is missing"); + } + + if (!table.ReadU32(&this->featureId) || + !feat->IsValidFeatureId(this->featureId)) { + return parent->Error("LangFeatureSetting: Failed to read valid featureId"); + } + if (!table.ReadS16(&this->value)) { + return parent->Error("LangFeatureSetting: Failed to read value"); + } + if (!table.ReadU16(&this->reserved)) { + return parent->Error("LangFeatureSetting: Failed to read reserved"); + } + if (this->reserved != 0) { + parent->Warning("LangFeatureSetting: Nonzero reserved"); + } + return true; +} + +bool OpenTypeSILL::LangFeatureSetting::SerializePart(OTSStream* out) const { + if (!out->WriteU32(this->featureId) || + !out->WriteS16(this->value) || + !out->WriteU16(this->reserved)) { + return parent->Error("LangFeatureSetting: Failed to read reserved"); + } + return true; +} + +} // namespace ots diff --git a/gfx/ots/src/sill.h b/gfx/ots/src/sill.h new file mode 100644 index 000000000..30f9b8d83 --- /dev/null +++ b/gfx/ots/src/sill.h @@ -0,0 +1,53 @@ +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef OTS_SILL_H_ +#define OTS_SILL_H_ + +#include "ots.h" +#include "graphite.h" + +#include <vector> + +namespace ots { + +class OpenTypeSILL : public Table { + public: + explicit OpenTypeSILL(Font* font, uint32_t tag) + : Table(font, tag, tag) { } + + bool Parse(const uint8_t* data, size_t length); + bool Serialize(OTSStream* out); + + private: + struct LanguageEntry : public TablePart<OpenTypeSILL> { + explicit LanguageEntry(OpenTypeSILL* parent) + : TablePart<OpenTypeSILL>(parent) { } + bool ParsePart(Buffer &table); + bool SerializePart(OTSStream* out) const; + uint8_t langcode[4]; + uint16_t numSettings; + uint16_t offset; + }; + struct LangFeatureSetting : public TablePart<OpenTypeSILL> { + explicit LangFeatureSetting(OpenTypeSILL* parent) + : TablePart<OpenTypeSILL>(parent) { } + bool ParsePart(Buffer &table); + bool SerializePart(OTSStream* out) const; + uint32_t featureId; + int16_t value; + uint16_t reserved; + }; + uint32_t version; + uint16_t numLangs; + uint16_t searchRange; + uint16_t entrySelector; + uint16_t rangeShift; + std::vector<LanguageEntry> entries; + std::vector<LangFeatureSetting> settings; +}; + +} // namespace ots + +#endif // OTS_SILL_H_ diff --git a/gfx/ots/src/stat.cc b/gfx/ots/src/stat.cc new file mode 100644 index 000000000..9b7828109 --- /dev/null +++ b/gfx/ots/src/stat.cc @@ -0,0 +1,347 @@ +// Copyright (c) 2018 The OTS 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 "stat.h" +#include "name.h" + +namespace ots { + +// ----------------------------------------------------------------------------- +// OpenTypeSTAT +// ----------------------------------------------------------------------------- + +bool OpenTypeSTAT::ValidateNameId(uint16_t nameid, bool allowPredefined) { + OpenTypeNAME* name = static_cast<OpenTypeNAME*>( + GetFont()->GetTypedTable(OTS_TAG_NAME)); + + if (!name || !name->IsValidNameId(nameid)) { + Drop("Invalid nameID: %d", nameid); + return false; + } + + if (!allowPredefined && nameid < 26) { + Warning("nameID out of range: %d", nameid); + return true; + } + + if ((nameid >= 26 && nameid <= 255) || nameid >= 32768) { + Warning("nameID out of range: %d", nameid); + return true; + } + + return true; +} + +bool OpenTypeSTAT::Parse(const uint8_t* data, size_t length) { + Buffer table(data, length); + if (!table.ReadU16(&this->majorVersion) || + !table.ReadU16(&this->minorVersion) || + !table.ReadU16(&this->designAxisSize) || + !table.ReadU16(&this->designAxisCount) || + !table.ReadU32(&this->designAxesOffset) || + !table.ReadU16(&this->axisValueCount) || + !table.ReadU32(&this->offsetToAxisValueOffsets) || + !(this->minorVersion < 1 || table.ReadU16(&this->elidedFallbackNameID))) { + return Drop("Failed to read table header"); + } + if (this->majorVersion != 1) { + return Drop("Unknown table version"); + } + if (this->minorVersion > 2) { + Warning("Unknown minor version, downgrading to 2"); + this->minorVersion = 2; + } + + if (this->designAxisSize < sizeof(AxisRecord)) { + return Drop("Invalid designAxisSize"); + } + + size_t headerEnd = table.offset(); + + if (this->designAxisCount == 0) { + if (this->designAxesOffset != 0) { + Warning("Unexpected non-zero designAxesOffset"); + this->designAxesOffset = 0; + } + } else { + if (this->designAxesOffset < headerEnd || + size_t(this->designAxesOffset) + + size_t(this->designAxisCount) * size_t(this->designAxisSize) > length) { + return Drop("Invalid designAxesOffset"); + } + } + + for (size_t i = 0; i < this->designAxisCount; i++) { + table.set_offset(this->designAxesOffset + i * this->designAxisSize); + this->designAxes.emplace_back(); + auto& axis = this->designAxes[i]; + if (!table.ReadU32(&axis.axisTag) || + !table.ReadU16(&axis.axisNameID) || + !table.ReadU16(&axis.axisOrdering)) { + return Drop("Failed to read design axis"); + } + if (!CheckTag(axis.axisTag)) { + return Drop("Bad design axis tag"); + } + if (!ValidateNameId(axis.axisNameID, false)) { + return true; + } + } + + // TODO + // - check that all axes defined in fvar are covered by STAT + // - check that axisOrdering values are not duplicated (warn only) + + if (this->axisValueCount == 0) { + if (this->offsetToAxisValueOffsets != 0) { + Warning("Unexpected non-zero offsetToAxisValueOffsets"); + this->offsetToAxisValueOffsets = 0; + } + } else { + if (this->offsetToAxisValueOffsets < headerEnd || + size_t(this->offsetToAxisValueOffsets) + + size_t(this->axisValueCount) * sizeof(uint16_t) > length) { + return Drop("Invalid offsetToAxisValueOffsets"); + } + } + + for (size_t i = 0; i < this->axisValueCount; i++) { + table.set_offset(this->offsetToAxisValueOffsets + i * sizeof(uint16_t)); + uint16_t axisValueOffset; + if (!table.ReadU16(&axisValueOffset)) { + return Drop("Failed to read axis value offset"); + } + if (this->offsetToAxisValueOffsets + axisValueOffset > length) { + return Drop("Invalid axis value offset"); + } + table.set_offset(this->offsetToAxisValueOffsets + axisValueOffset); + uint16_t format; + if (!table.ReadU16(&format)) { + return Drop("Failed to read axis value format"); + } + this->axisValues.emplace_back(format); + auto& axisValue = axisValues[i]; + switch (format) { + case 1: + if (!table.ReadU16(&axisValue.format1.axisIndex) || + !table.ReadU16(&axisValue.format1.flags) || + !table.ReadU16(&axisValue.format1.valueNameID) || + !table.ReadS32(&axisValue.format1.value)) { + return Drop("Failed to read axis value (format 1)"); + } + if (axisValue.format1.axisIndex >= this->designAxisCount) { + return Drop("Axis index out of range"); + } + if ((axisValue.format1.flags & 0xFFFCu) != 0) { + Warning("Unexpected axis value flags"); + axisValue.format1.flags &= ~0xFFFCu; + } + if (!ValidateNameId(axisValue.format1.valueNameID)) { + return true; + } + break; + case 2: + if (!table.ReadU16(&axisValue.format2.axisIndex) || + !table.ReadU16(&axisValue.format2.flags) || + !table.ReadU16(&axisValue.format2.valueNameID) || + !table.ReadS32(&axisValue.format2.nominalValue) || + !table.ReadS32(&axisValue.format2.rangeMinValue) || + !table.ReadS32(&axisValue.format2.rangeMaxValue)) { + return Drop("Failed to read axis value (format 2)"); + } + if (axisValue.format2.axisIndex >= this->designAxisCount) { + return Drop("Axis index out of range"); + } + if ((axisValue.format2.flags & 0xFFFCu) != 0) { + Warning("Unexpected axis value flags"); + axisValue.format1.flags &= ~0xFFFCu; + } + if (!ValidateNameId(axisValue.format2.valueNameID)) { + return true; + } + if (!(axisValue.format2.rangeMinValue <= axisValue.format2.nominalValue && + axisValue.format2.nominalValue <= axisValue.format2.rangeMaxValue)) { + Warning("Bad axis value range or nominal value"); + } + break; + case 3: + if (!table.ReadU16(&axisValue.format3.axisIndex) || + !table.ReadU16(&axisValue.format3.flags) || + !table.ReadU16(&axisValue.format3.valueNameID) || + !table.ReadS32(&axisValue.format3.value) || + !table.ReadS32(&axisValue.format3.linkedValue)) { + return Drop("Failed to read axis value (format 3)"); + } + if (axisValue.format3.axisIndex >= this->designAxisCount) { + return Drop("Axis index out of range"); + } + if ((axisValue.format3.flags & 0xFFFCu) != 0) { + Warning("Unexpected axis value flags"); + axisValue.format3.flags &= ~0xFFFCu; + } + if (!ValidateNameId(axisValue.format3.valueNameID)) { + return true; + } + break; + case 4: + if (this->minorVersion < 2) { + Warning("Invalid table version for format 4 axis values - updating"); + this->minorVersion = 2; + } + if (!table.ReadU16(&axisValue.format4.axisCount) || + !table.ReadU16(&axisValue.format4.flags) || + !table.ReadU16(&axisValue.format4.valueNameID)) { + return Drop("Failed to read axis value (format 4)"); + } + if (axisValue.format4.axisCount > this->designAxisCount) { + return Drop("Axis count out of range"); + } + if ((axisValue.format4.flags & 0xFFFCu) != 0) { + Warning("Unexpected axis value flags"); + axisValue.format4.flags &= ~0xFFFCu; + } + if (!ValidateNameId(axisValue.format4.valueNameID)) { + return true; + } + for (unsigned j = 0; j < axisValue.format4.axisCount; j++) { + axisValue.format4.axisValues.emplace_back(); + auto& v = axisValue.format4.axisValues[j]; + if (!table.ReadU16(&v.axisIndex) || + !table.ReadS32(&v.value)) { + return Drop("Failed to read axis value"); + } + if (v.axisIndex >= this->designAxisCount) { + return Drop("Axis index out of range"); + } + } + break; + default: + return Drop("Unknown axis value format"); + } + } + + return true; +} + +bool OpenTypeSTAT::Serialize(OTSStream* out) { + off_t tableStart = out->Tell(); + + size_t headerSize = 5 * sizeof(uint16_t) + 2 * sizeof(uint32_t); + if (this->minorVersion >= 1) { + headerSize += sizeof(uint16_t); + } + + if (this->designAxisCount == 0) { + this->designAxesOffset = 0; + } else { + this->designAxesOffset = headerSize; + } + + this->designAxisSize = sizeof(AxisRecord); + + if (this->axisValueCount == 0) { + this->offsetToAxisValueOffsets = 0; + } else { + if (this->designAxesOffset == 0) { + this->offsetToAxisValueOffsets = headerSize; + } else { + this->offsetToAxisValueOffsets = this->designAxesOffset + this->designAxisCount * this->designAxisSize; + } + } + + if (!out->WriteU16(this->majorVersion) || + !out->WriteU16(this->minorVersion) || + !out->WriteU16(this->designAxisSize) || + !out->WriteU16(this->designAxisCount) || + !out->WriteU32(this->designAxesOffset) || + !out->WriteU16(this->axisValueCount) || + !out->WriteU32(this->offsetToAxisValueOffsets) || + !(this->minorVersion < 1 || out->WriteU16(this->elidedFallbackNameID))) { + return Error("Failed to write table header"); + } + + if (this->designAxisCount > 0) { + if (out->Tell() - tableStart != this->designAxesOffset) { + return Error("Error computing designAxesOffset"); + } + } + + for (unsigned i = 0; i < this->designAxisCount; i++) { + const auto& axis = this->designAxes[i]; + if (!out->WriteU32(axis.axisTag) || + !out->WriteU16(axis.axisNameID) || + !out->WriteU16(axis.axisOrdering)) { + return Error("Failed to write design axis"); + } + } + + if (this->axisValueCount > 0) { + if (out->Tell() - tableStart != this->offsetToAxisValueOffsets) { + return Error("Error computing offsetToAxisValueOffsets"); + } + } + + uint32_t axisValueOffset = this->axisValueCount * sizeof(uint16_t); + for (unsigned i = 0; i < this->axisValueCount; i++) { + const auto& value = this->axisValues[i]; + if (!out->WriteU16(axisValueOffset)) { + return Error("Failed to write axis value offset"); + } + axisValueOffset += value.Length(); + } + for (unsigned i = 0; i < this->axisValueCount; i++) { + const auto& value = this->axisValues[i]; + if (!out->WriteU16(value.format)) { + return Error("Failed to write axis value"); + } + switch (value.format) { + case 1: + if (!out->WriteU16(value.format1.axisIndex) || + !out->WriteU16(value.format1.flags) || + !out->WriteU16(value.format1.valueNameID) || + !out->WriteS32(value.format1.value)) { + return Error("Failed to write axis value"); + } + break; + case 2: + if (!out->WriteU16(value.format2.axisIndex) || + !out->WriteU16(value.format2.flags) || + !out->WriteU16(value.format2.valueNameID) || + !out->WriteS32(value.format2.nominalValue) || + !out->WriteS32(value.format2.rangeMinValue) || + !out->WriteS32(value.format2.rangeMaxValue)) { + return Error("Failed to write axis value"); + } + break; + case 3: + if (!out->WriteU16(value.format3.axisIndex) || + !out->WriteU16(value.format3.flags) || + !out->WriteU16(value.format3.valueNameID) || + !out->WriteS32(value.format3.value) || + !out->WriteS32(value.format3.linkedValue)) { + return Error("Failed to write axis value"); + } + break; + case 4: + if (!out->WriteU16(value.format4.axisCount) || + !out->WriteU16(value.format4.flags) || + !out->WriteU16(value.format4.valueNameID)) { + return Error("Failed to write axis value"); + } + for (unsigned j = 0; j < value.format4.axisValues.size(); j++) { + if (!out->WriteU16(value.format4.axisValues[j].axisIndex) || + !out->WriteS32(value.format4.axisValues[j].value)) { + return Error("Failed to write axis value"); + } + } + break; + default: + return Error("Bad value format"); + } + } + + return true; +} + +} // namespace ots diff --git a/gfx/ots/src/stat.h b/gfx/ots/src/stat.h new file mode 100644 index 000000000..873d08edc --- /dev/null +++ b/gfx/ots/src/stat.h @@ -0,0 +1,155 @@ +// Copyright (c) 2018 The OTS Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef OTS_STAT_H_ +#define OTS_STAT_H_ + +#include <vector> + +#include "ots.h" + +namespace ots { + +// ----------------------------------------------------------------------------- +// OpenTypeSTAT Interface +// ----------------------------------------------------------------------------- + +class OpenTypeSTAT : public Table { + public: + explicit OpenTypeSTAT(Font* font, uint32_t tag) + : Table(font, tag, tag) { } + + bool Parse(const uint8_t* data, size_t length); + bool Serialize(OTSStream* out); + + private: + bool ValidateNameId(uint16_t nameid, bool allowPredefined = true); + + uint16_t majorVersion; + uint16_t minorVersion; + uint16_t designAxisSize; + uint16_t designAxisCount; + uint32_t designAxesOffset; + uint16_t axisValueCount; + uint32_t offsetToAxisValueOffsets; + uint16_t elidedFallbackNameID; + + struct AxisRecord { + uint32_t axisTag; + uint16_t axisNameID; + uint16_t axisOrdering; + }; + std::vector<AxisRecord> designAxes; + + typedef int32_t Fixed; /* 16.16 fixed-point value */ + + struct AxisValueFormat1 { + uint16_t axisIndex; + uint16_t flags; + uint16_t valueNameID; + Fixed value; + static size_t Length() { + return 3 * sizeof(uint16_t) + sizeof(Fixed); + } + }; + + struct AxisValueFormat2 { + uint16_t axisIndex; + uint16_t flags; + uint16_t valueNameID; + Fixed nominalValue; + Fixed rangeMinValue; + Fixed rangeMaxValue; + static size_t Length() { + return 3 * sizeof(uint16_t) + 3 * sizeof(Fixed); + } + }; + + struct AxisValueFormat3 { + uint16_t axisIndex; + uint16_t flags; + uint16_t valueNameID; + Fixed value; + Fixed linkedValue; + static size_t Length() { + return 3 * sizeof(uint16_t) + 2 * sizeof(Fixed); + } + }; + + struct AxisValueFormat4 { + uint16_t axisCount; + uint16_t flags; + uint16_t valueNameID; + struct AxisValue { + uint16_t axisIndex; + Fixed value; + }; + std::vector<AxisValue> axisValues; + size_t Length() const { + return 3 * sizeof(uint16_t) + axisValues.size() * (sizeof(uint16_t) + sizeof(Fixed)); + } + }; + + struct AxisValueRecord { + uint16_t format; + union { + AxisValueFormat1 format1; + AxisValueFormat2 format2; + AxisValueFormat3 format3; + AxisValueFormat4 format4; + }; + explicit AxisValueRecord(uint16_t format_) + : format(format_) + { + if (format == 4) { + new (&this->format4) AxisValueFormat4(); + } + } + AxisValueRecord(const AxisValueRecord& other_) + : format(other_.format) + { + switch (format) { + case 1: + format1 = other_.format1; + break; + case 2: + format2 = other_.format2; + break; + case 3: + format3 = other_.format3; + break; + case 4: + new (&this->format4) AxisValueFormat4(); + format4 = other_.format4; + break; + } + } + ~AxisValueRecord() { + if (format == 4) { + this->format4.~AxisValueFormat4(); + } + } + uint32_t Length() const { + switch (format) { + case 1: + return sizeof(uint16_t) + format1.Length(); + case 2: + return sizeof(uint16_t) + format2.Length(); + case 3: + return sizeof(uint16_t) + format3.Length(); + case 4: + return sizeof(uint16_t) + format4.Length(); + default: + // can't happen + return 0; + } + } + }; + + std::vector<AxisValueRecord> axisValues; +}; + +} // namespace ots + +#endif // OTS_STAT_H_ diff --git a/gfx/ots/src/variations.cc b/gfx/ots/src/variations.cc new file mode 100644 index 000000000..cb7e5fb32 --- /dev/null +++ b/gfx/ots/src/variations.cc @@ -0,0 +1,261 @@ +// Copyright (c) 2018 The OTS 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 "layout.h" + +#include "fvar.h" + +// OpenType Variations Common Table Formats + +#define TABLE_NAME "Variations" // XXX: use individual table names + +namespace { + +bool ParseVariationRegionList(const ots::Font* font, const uint8_t* data, const size_t length, + uint16_t* regionCount) { + ots::Buffer subtable(data, length); + + uint16_t axisCount; + + if (!subtable.ReadU16(&axisCount) || + !subtable.ReadU16(regionCount)) { + return OTS_FAILURE_MSG("Failed to read variation region list header"); + } + + if (*regionCount == 0) { + return true; + } + + const ots::OpenTypeFVAR* fvar = + static_cast<ots::OpenTypeFVAR*>(font->GetTypedTable(OTS_TAG_FVAR)); + if (!fvar) { + return OTS_FAILURE_MSG("Required fvar table is missing"); + } + if (axisCount != fvar->AxisCount()) { + return OTS_FAILURE_MSG("Axis count mismatch"); + } + + for (unsigned i = 0; i < *regionCount; i++) { + for (unsigned j = 0; j < axisCount; j++) { + int16_t startCoord, peakCoord, endCoord; + if (!subtable.ReadS16(&startCoord) || + !subtable.ReadS16(&peakCoord) || + !subtable.ReadS16(&endCoord)) { + return OTS_FAILURE_MSG("Failed to read region axis coordinates"); + } + if (startCoord > peakCoord || peakCoord > endCoord) { + return OTS_FAILURE_MSG("Region axis coordinates out of order"); + } + if (startCoord < -0x4000 || endCoord > 0x4000) { + return OTS_FAILURE_MSG("Region axis coordinate out of range"); + } + if ((peakCoord < 0 && endCoord > 0) || + (peakCoord > 0 && startCoord < 0)) { + return OTS_FAILURE_MSG("Invalid region axis coordinates"); + } + } + } + + return true; +} + +bool +ParseVariationDataSubtable(const ots::Font* font, const uint8_t* data, const size_t length, + const uint16_t regionCount, + uint16_t* regionIndexCount) { + ots::Buffer subtable(data, length); + + uint16_t itemCount; + uint16_t shortDeltaCount; + + if (!subtable.ReadU16(&itemCount) || + !subtable.ReadU16(&shortDeltaCount) || + !subtable.ReadU16(regionIndexCount)) { + return OTS_FAILURE_MSG("Failed to read variation data subtable header"); + } + + for (unsigned i = 0; i < *regionIndexCount; i++) { + uint16_t regionIndex; + if (!subtable.ReadU16(®ionIndex) || regionIndex >= regionCount) { + return OTS_FAILURE_MSG("Bad region index"); + } + } + + if (!subtable.Skip(size_t(itemCount) * (size_t(shortDeltaCount) + size_t(*regionIndexCount)))) { + return OTS_FAILURE_MSG("Failed to read delta data"); + } + + return true; +} + +} // namespace + +namespace ots { + +bool +ParseItemVariationStore(const Font* font, + const uint8_t* data, const size_t length, + std::vector<uint16_t>* regionIndexCounts) { + Buffer subtable(data, length); + + uint16_t format; + uint32_t variationRegionListOffset; + uint16_t itemVariationDataCount; + + if (!subtable.ReadU16(&format) || + !subtable.ReadU32(&variationRegionListOffset) || + !subtable.ReadU16(&itemVariationDataCount)) { + return OTS_FAILURE_MSG("Failed to read item variation store header"); + } + + if (format != 1) { + return OTS_FAILURE_MSG("Unknown item variation store format"); + } + + if (variationRegionListOffset < subtable.offset() + 4 * itemVariationDataCount || + variationRegionListOffset > length) { + return OTS_FAILURE_MSG("Invalid variation region list offset"); + } + + uint16_t regionCount; + if (!ParseVariationRegionList(font, + data + variationRegionListOffset, + length - variationRegionListOffset, + ®ionCount)) { + return OTS_FAILURE_MSG("Failed to parse variation region list"); + } + + for (unsigned i = 0; i < itemVariationDataCount; i++) { + uint32_t offset; + if (!subtable.ReadU32(&offset)) { + return OTS_FAILURE_MSG("Failed to read variation data subtable offset"); + } + if (offset >= length) { + return OTS_FAILURE_MSG("Bad offset to variation data subtable"); + } + uint16_t regionIndexCount = 0; + if (!ParseVariationDataSubtable(font, data + offset, length - offset, + regionCount, + ®ionIndexCount)) { + return OTS_FAILURE_MSG("Failed to parse variation data subtable"); + } + if (regionIndexCounts) { + regionIndexCounts->push_back(regionIndexCount); + } + } + + return true; +} + +bool ParseDeltaSetIndexMap(const Font* font, const uint8_t* data, const size_t length) { + Buffer subtable(data, length); + + uint16_t entryFormat; + uint16_t mapCount; + + if (!subtable.ReadU16(&entryFormat) || + !subtable.ReadU16(&mapCount)) { + return OTS_FAILURE_MSG("Failed to read delta set index map header"); + } + + const uint16_t MAP_ENTRY_SIZE_MASK = 0x0030; + + const uint16_t entrySize = (((entryFormat & MAP_ENTRY_SIZE_MASK) >> 4) + 1); + if (!subtable.Skip(entrySize * mapCount)) { + return OTS_FAILURE_MSG("Failed to read delta set index map data"); + } + + return true; +} + +bool ParseVariationData(const Font* font, const uint8_t* data, size_t length, + size_t axisCount, size_t sharedTupleCount) { + Buffer subtable(data, length); + + uint16_t tupleVariationCount; + uint16_t dataOffset; + if (!subtable.ReadU16(&tupleVariationCount) || + !subtable.ReadU16(&dataOffset)) { + return OTS_FAILURE_MSG("Failed to read variation data header"); + } + + if (dataOffset > length) { + return OTS_FAILURE_MSG("Invalid serialized data offset"); + } + + tupleVariationCount &= 0x0FFF; // mask off flags + + const uint16_t EMBEDDED_PEAK_TUPLE = 0x8000; + const uint16_t INTERMEDIATE_REGION = 0x4000; + const uint16_t TUPLE_INDEX_MASK = 0x0FFF; + + for (unsigned i = 0; i < tupleVariationCount; i++) { + uint16_t variationDataSize; + uint16_t tupleIndex; + + if (!subtable.ReadU16(&variationDataSize) || + !subtable.ReadU16(&tupleIndex)) { + return OTS_FAILURE_MSG("Failed to read tuple variation header"); + } + + if (tupleIndex & EMBEDDED_PEAK_TUPLE) { + for (unsigned axis = 0; axis < axisCount; axis++) { + int16_t coordinate; + if (!subtable.ReadS16(&coordinate)) { + return OTS_FAILURE_MSG("Failed to read tuple coordinate"); + } + if (coordinate < -0x4000 || coordinate > 0x4000) { + return OTS_FAILURE_MSG("Invalid tuple coordinate"); + } + } + } + + if (tupleIndex & INTERMEDIATE_REGION) { + std::vector<int16_t> startTuple(axisCount); + for (unsigned axis = 0; axis < axisCount; axis++) { + int16_t coordinate; + if (!subtable.ReadS16(&coordinate)) { + return OTS_FAILURE_MSG("Failed to read tuple coordinate"); + } + if (coordinate < -0x4000 || coordinate > 0x4000) { + return OTS_FAILURE_MSG("Invalid tuple coordinate"); + } + startTuple.push_back(coordinate); + } + + std::vector<int16_t> endTuple(axisCount); + for (unsigned axis = 0; axis < axisCount; axis++) { + int16_t coordinate; + if (!subtable.ReadS16(&coordinate)) { + return OTS_FAILURE_MSG("Failed to read tuple coordinate"); + } + if (coordinate < -0x4000 || coordinate > 0x4000) { + return OTS_FAILURE_MSG("Invalid tuple coordinate"); + } + endTuple.push_back(coordinate); + } + + for (unsigned axis = 0; axis < axisCount; axis++) { + if (startTuple[axis] > endTuple[axis]) { + return OTS_FAILURE_MSG("Invalid intermediate range"); + } + } + } + + if (!(tupleIndex & EMBEDDED_PEAK_TUPLE)) { + tupleIndex &= TUPLE_INDEX_MASK; + if (tupleIndex >= sharedTupleCount) { + return OTS_FAILURE_MSG("Tuple index out of range"); + } + } + } + + // TODO: we don't attempt to interpret the serialized data block + + return true; +} + +} // namespace ots + +#undef TABLE_NAME diff --git a/gfx/ots/src/variations.h b/gfx/ots/src/variations.h new file mode 100644 index 000000000..aaaac1784 --- /dev/null +++ b/gfx/ots/src/variations.h @@ -0,0 +1,26 @@ +// Copyright (c) 2018 The OTS Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef OTS_VARIATIONS_H_ +#define OTS_VARIATIONS_H_ + +#include <vector> +#include "ots.h" + +// Utility functions for OpenType variations common table formats. + +namespace ots { + +bool ParseItemVariationStore(const Font* font, + const uint8_t* data, const size_t length, + std::vector<uint16_t>* out_region_index_count = NULL); + +bool ParseDeltaSetIndexMap(const Font* font, const uint8_t* data, const size_t length); + +bool ParseVariationData(const Font* font, const uint8_t* data, size_t length, + size_t axisCount, size_t sharedTupleCount); + +} // namespace ots + +#endif // OTS_VARIATIONS_H_ diff --git a/gfx/ots/src/vdmx.cc b/gfx/ots/src/vdmx.cc index cd80946ae..54055777a 100644 --- a/gfx/ots/src/vdmx.cc +++ b/gfx/ots/src/vdmx.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -7,91 +7,75 @@ // VDMX - Vertical Device Metrics // http://www.microsoft.com/typography/otspec/vdmx.htm -#define TABLE_NAME "VDMX" - -#define DROP_THIS_TABLE(...) \ - do { \ - OTS_FAILURE_MSG_(font->file, TABLE_NAME ": " __VA_ARGS__); \ - OTS_FAILURE_MSG("Table discarded"); \ - delete font->vdmx; \ - font->vdmx = 0; \ - } while (0) - namespace ots { -bool ots_vdmx_parse(Font *font, const uint8_t *data, size_t length) { +bool OpenTypeVDMX::Parse(const uint8_t *data, size_t length) { Buffer table(data, length); - font->vdmx = new OpenTypeVDMX; - OpenTypeVDMX * const vdmx = font->vdmx; - if (!table.ReadU16(&vdmx->version) || - !table.ReadU16(&vdmx->num_recs) || - !table.ReadU16(&vdmx->num_ratios)) { - return OTS_FAILURE_MSG("Failed to read table header"); + if (!table.ReadU16(&this->version) || + !table.ReadU16(&this->num_recs) || + !table.ReadU16(&this->num_ratios)) { + return Error("Failed to read table header"); } - if (vdmx->version > 1) { - DROP_THIS_TABLE("bad version: %u", vdmx->version); - return true; // continue transcoding + if (this->version > 1) { + return Drop("Unsupported table version: %u", this->version); } - vdmx->rat_ranges.reserve(vdmx->num_ratios); - for (unsigned i = 0; i < vdmx->num_ratios; ++i) { + this->rat_ranges.reserve(this->num_ratios); + for (unsigned i = 0; i < this->num_ratios; ++i) { OpenTypeVDMXRatioRecord rec; if (!table.ReadU8(&rec.charset) || !table.ReadU8(&rec.x_ratio) || !table.ReadU8(&rec.y_start_ratio) || !table.ReadU8(&rec.y_end_ratio)) { - return OTS_FAILURE_MSG("Failed to read ratio header %d", i); + return Error("Failed to read RatioRange record %d", i); } if (rec.charset > 1) { - DROP_THIS_TABLE("bad charset: %u", rec.charset); - return true; + return Drop("Unsupported character set: %u", rec.charset); } if (rec.y_start_ratio > rec.y_end_ratio) { - DROP_THIS_TABLE("bad y ratio"); - return true; + return Drop("Bad y ratio"); } // All values set to zero signal the default grouping to use; // if present, this must be the last Ratio group in the table. - if ((i < vdmx->num_ratios - 1u) && + if ((i < this->num_ratios - 1u) && (rec.x_ratio == 0) && (rec.y_start_ratio == 0) && (rec.y_end_ratio == 0)) { // workaround for fonts which have 2 or more {0, 0, 0} terminators. - DROP_THIS_TABLE("superfluous terminator found"); - return true; + return Drop("Superfluous terminator found"); } - vdmx->rat_ranges.push_back(rec); + this->rat_ranges.push_back(rec); } - vdmx->offsets.reserve(vdmx->num_ratios); + this->offsets.reserve(this->num_ratios); const size_t current_offset = table.offset(); // current_offset is less than (2 bytes * 3) + (4 bytes * USHRT_MAX) = 256k. - for (unsigned i = 0; i < vdmx->num_ratios; ++i) { + for (unsigned i = 0; i < this->num_ratios; ++i) { uint16_t offset; if (!table.ReadU16(&offset)) { - return OTS_FAILURE_MSG("Failed to read ratio offset %d", i); + return Error("Failed to read ratio offset %d", i); } if (current_offset + offset >= length) { // thus doesn't overflow. - return OTS_FAILURE_MSG("Bad ratio offset %d for ration %d", offset, i); + return Error("Bad ratio offset %d for ration %d", offset, i); } - vdmx->offsets.push_back(offset); + this->offsets.push_back(offset); } - vdmx->groups.reserve(vdmx->num_recs); - for (unsigned i = 0; i < vdmx->num_recs; ++i) { + this->groups.reserve(this->num_recs); + for (unsigned i = 0; i < this->num_recs; ++i) { OpenTypeVDMXGroup group; if (!table.ReadU16(&group.recs) || !table.ReadU8(&group.startsz) || !table.ReadU8(&group.endsz)) { - return OTS_FAILURE_MSG("Failed to read record header %d", i); + return Error("Failed to read record header %d", i); } group.entries.reserve(group.recs); for (unsigned j = 0; j < group.recs; ++j) { @@ -99,71 +83,68 @@ bool ots_vdmx_parse(Font *font, const uint8_t *data, size_t length) { if (!table.ReadU16(&vt.y_pel_height) || !table.ReadS16(&vt.y_max) || !table.ReadS16(&vt.y_min)) { - return OTS_FAILURE_MSG("Failed to read reacord %d group %d", i, j); + return Error("Failed to read reacord %d group %d", i, j); } if (vt.y_max < vt.y_min) { - DROP_THIS_TABLE("bad y min/max"); - return true; + return Drop("bad y min/max"); } // This table must appear in sorted order (sorted by yPelHeight), // but need not be continuous. if ((j != 0) && (group.entries[j - 1].y_pel_height >= vt.y_pel_height)) { - DROP_THIS_TABLE("the table is not sorted"); - return true; + return Drop("The table is not sorted"); } group.entries.push_back(vt); } - vdmx->groups.push_back(group); + this->groups.push_back(group); } return true; } -bool ots_vdmx_should_serialise(Font *font) { - if (!font->glyf) return false; // this table is not for CFF fonts. - return font->vdmx != NULL; +bool OpenTypeVDMX::ShouldSerialize() { + return Table::ShouldSerialize() && + // this table is not for CFF fonts. + GetFont()->GetTable(OTS_TAG_GLYF) != NULL; } -bool ots_vdmx_serialise(OTSStream *out, Font *font) { - OpenTypeVDMX * const vdmx = font->vdmx; - - if (!out->WriteU16(vdmx->version) || - !out->WriteU16(vdmx->num_recs) || - !out->WriteU16(vdmx->num_ratios)) { - return OTS_FAILURE_MSG("Failed to write table header"); +bool OpenTypeVDMX::Serialize(OTSStream *out) { + if (!out->WriteU16(this->version) || + !out->WriteU16(this->num_recs) || + !out->WriteU16(this->num_ratios)) { + return Error("Failed to write table header"); } - for (unsigned i = 0; i < vdmx->rat_ranges.size(); ++i) { - const OpenTypeVDMXRatioRecord& rec = vdmx->rat_ranges[i]; + for (unsigned i = 0; i < this->rat_ranges.size(); ++i) { + const OpenTypeVDMXRatioRecord& rec = this->rat_ranges[i]; if (!out->Write(&rec.charset, 1) || !out->Write(&rec.x_ratio, 1) || !out->Write(&rec.y_start_ratio, 1) || !out->Write(&rec.y_end_ratio, 1)) { - return OTS_FAILURE_MSG("Failed to write ratio %d", i); + return Error("Failed to write RatioRange record %d", i); } } - for (unsigned i = 0; i < vdmx->offsets.size(); ++i) { - if (!out->WriteU16(vdmx->offsets[i])) { - return OTS_FAILURE_MSG("Failed to write ratio offset %d", i); + for (unsigned i = 0; i < this->offsets.size(); ++i) { + if (!out->WriteU16(this->offsets[i])) { + return Error("Failed to write ratio offset %d", i); } } - for (unsigned i = 0; i < vdmx->groups.size(); ++i) { - const OpenTypeVDMXGroup& group = vdmx->groups[i]; + for (unsigned i = 0; i < this->groups.size(); ++i) { + const OpenTypeVDMXGroup& group = this->groups[i]; if (!out->WriteU16(group.recs) || !out->Write(&group.startsz, 1) || !out->Write(&group.endsz, 1)) { - return OTS_FAILURE_MSG("Failed to write group %d", i); + return Error("Failed to write group %d", i); } for (unsigned j = 0; j < group.entries.size(); ++j) { const OpenTypeVDMXVTable& vt = group.entries[j]; if (!out->WriteU16(vt.y_pel_height) || !out->WriteS16(vt.y_max) || !out->WriteS16(vt.y_min)) { - return OTS_FAILURE_MSG("Failed to write group %d entry %d", i, j); + return Error("Failed to write group %d entry %d", i, j); } } } @@ -171,16 +152,4 @@ bool ots_vdmx_serialise(OTSStream *out, Font *font) { return true; } -void ots_vdmx_reuse(Font *font, Font *other) { - font->vdmx = other->vdmx; - font->vdmx_reused = true; -} - -void ots_vdmx_free(Font *font) { - delete font->vdmx; -} - } // namespace ots - -#undef TABLE_NAME -#undef DROP_THIS_TABLE diff --git a/gfx/ots/src/vdmx.h b/gfx/ots/src/vdmx.h index 1d959efe5..6ccf6dc1b 100644 --- a/gfx/ots/src/vdmx.h +++ b/gfx/ots/src/vdmx.h @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -31,7 +31,16 @@ struct OpenTypeVDMXGroup { std::vector<OpenTypeVDMXVTable> entries; }; -struct OpenTypeVDMX { +class OpenTypeVDMX : public Table { + public: + explicit OpenTypeVDMX(Font *font, uint32_t tag) + : Table(font, tag, tag) { } + + bool Parse(const uint8_t *data, size_t length); + bool Serialize(OTSStream *out); + bool ShouldSerialize(); + + private: uint16_t version; uint16_t num_recs; uint16_t num_ratios; diff --git a/gfx/ots/src/vhea.cc b/gfx/ots/src/vhea.cc index e721b971e..e44bedf20 100644 --- a/gfx/ots/src/vhea.cc +++ b/gfx/ots/src/vhea.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2011 The Chromium Authors. All rights reserved. +// Copyright (c) 2011-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -10,51 +10,30 @@ // vhea - Vertical Header Table // http://www.microsoft.com/typography/otspec/vhea.htm -#define TABLE_NAME "vhea" - namespace ots { -bool ots_vhea_parse(Font *font, const uint8_t *data, size_t length) { +bool OpenTypeVHEA::Parse(const uint8_t *data, size_t length) { Buffer table(data, length); - OpenTypeVHEA *vhea = new OpenTypeVHEA; - font->vhea = vhea; - if (!table.ReadU32(&vhea->header.version)) { - return OTS_FAILURE_MSG("Failed to read version"); - } - if (vhea->header.version != 0x00010000 && - vhea->header.version != 0x00011000) { - return OTS_FAILURE_MSG("Bad vhea version %x", vhea->header.version); + if (!table.ReadU32(&this->version)) { + return Error("Failed to read version"); } - - if (!ParseMetricsHeader(font, &table, &vhea->header)) { - return OTS_FAILURE_MSG("Failed to parse metrics in vhea"); + if (this->version != 0x00010000 && + this->version != 0x00011000) { + return Error("Unsupported table version: 0x%x", this->version); } - return true; + return OpenTypeMetricsHeader::Parse(data, length); } -bool ots_vhea_should_serialise(Font *font) { - // vhea should'nt serialise when vmtx doesn't exist. - return font->vhea != NULL && font->vmtx != NULL; +bool OpenTypeVHEA::Serialize(OTSStream *out) { + return OpenTypeMetricsHeader::Serialize(out); } -bool ots_vhea_serialise(OTSStream *out, Font *font) { - if (!SerialiseMetricsHeader(font, out, &font->vhea->header)) { - return OTS_FAILURE_MSG("Failed to write vhea metrics"); - } - return true; -} - -void ots_vhea_reuse(Font *font, Font *other) { - font->vhea = other->vhea; - font->vhea_reused = true; -} - -void ots_vhea_free(Font *font) { - delete font->vhea; +bool OpenTypeVHEA::ShouldSerialize() { + return OpenTypeMetricsHeader::ShouldSerialize() && + // vhea shouldn't serialise when vmtx doesn't exist. + GetFont()->GetTable(OTS_TAG_VMTX) != NULL; } } // namespace ots - -#undef TABLE_NAME diff --git a/gfx/ots/src/vhea.h b/gfx/ots/src/vhea.h index f8efde731..8776acd11 100644 --- a/gfx/ots/src/vhea.h +++ b/gfx/ots/src/vhea.h @@ -1,4 +1,4 @@ -// Copyright (c) 2011 The Chromium Authors. All rights reserved. +// Copyright (c) 2011-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -10,8 +10,14 @@ namespace ots { -struct OpenTypeVHEA { - OpenTypeMetricsHeader header; +class OpenTypeVHEA : public OpenTypeMetricsHeader { + public: + explicit OpenTypeVHEA(Font *font, uint32_t tag) + : OpenTypeMetricsHeader(font, tag, tag) { } + + bool Parse(const uint8_t *data, size_t length); + bool Serialize(OTSStream *out); + bool ShouldSerialize(); }; } // namespace ots diff --git a/gfx/ots/src/vmtx.cc b/gfx/ots/src/vmtx.cc index 64a706148..d576ae294 100644 --- a/gfx/ots/src/vmtx.cc +++ b/gfx/ots/src/vmtx.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2011 The Chromium Authors. All rights reserved. +// Copyright (c) 2011-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -10,48 +10,20 @@ // vmtx - Vertical Metrics Table // http://www.microsoft.com/typography/otspec/vmtx.htm -#define TABLE_NAME "vmtx" - namespace ots { -bool ots_vmtx_parse(Font *font, const uint8_t *data, size_t length) { - Buffer table(data, length); - OpenTypeVMTX *vmtx = new OpenTypeVMTX; - font->vmtx = vmtx; - - if (!font->vhea || !font->maxp) { - return OTS_FAILURE_MSG("vhea or maxp table missing as needed by vmtx"); - } - - if (!ParseMetricsTable(font, &table, font->maxp->num_glyphs, - &font->vhea->header, &vmtx->metrics)) { - return OTS_FAILURE_MSG("Failed to parse vmtx metrics"); - } - - return true; +bool OpenTypeVMTX::Parse(const uint8_t *data, size_t length) { + return OpenTypeMetricsTable::Parse(data, length); } -bool ots_vmtx_should_serialise(Font *font) { - // vmtx should serialise when vhea is preserved. - return font->vmtx != NULL && font->vhea != NULL; +bool OpenTypeVMTX::Serialize(OTSStream *out) { + return OpenTypeMetricsTable::Serialize(out); } -bool ots_vmtx_serialise(OTSStream *out, Font *font) { - if (!SerialiseMetricsTable(font, out, &font->vmtx->metrics)) { - return OTS_FAILURE_MSG("Failed to write vmtx metrics"); - } - return true; -} - -void ots_vmtx_reuse(Font *font, Font *other) { - font->vmtx = other->vmtx; - font->vmtx_reused = true; -} - -void ots_vmtx_free(Font *font) { - delete font->vmtx; +bool OpenTypeVMTX::ShouldSerialize() { + return OpenTypeMetricsTable::ShouldSerialize() && + // vmtx should serialise when vhea is preserved. + GetFont()->GetTable(OTS_TAG_VHEA) != NULL; } } // namespace ots - -#undef TABLE_NAME diff --git a/gfx/ots/src/vmtx.h b/gfx/ots/src/vmtx.h index 061dc73ed..b243fe214 100644 --- a/gfx/ots/src/vmtx.h +++ b/gfx/ots/src/vmtx.h @@ -1,4 +1,4 @@ -// Copyright (c) 2011 The Chromium Authors. All rights reserved. +// Copyright (c) 2011-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -6,12 +6,19 @@ #define OTS_VMTX_H_ #include "metrics.h" +#include "vhea.h" #include "ots.h" namespace ots { -struct OpenTypeVMTX { - OpenTypeMetricsTable metrics; +struct OpenTypeVMTX : public OpenTypeMetricsTable { + public: + explicit OpenTypeVMTX(Font *font, uint32_t tag) + : OpenTypeMetricsTable(font, tag, tag, OTS_TAG_VHEA) { } + + bool Parse(const uint8_t *data, size_t length); + bool Serialize(OTSStream *out); + bool ShouldSerialize(); }; } // namespace ots diff --git a/gfx/ots/src/vorg.cc b/gfx/ots/src/vorg.cc index 358923125..3b4b51c53 100644 --- a/gfx/ots/src/vorg.cc +++ b/gfx/ots/src/vorg.cc @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -9,37 +9,23 @@ // VORG - Vertical Origin Table // http://www.microsoft.com/typography/otspec/vorg.htm -#define TABLE_NAME "VORG" - -#define DROP_THIS_TABLE(...) \ - do { \ - OTS_FAILURE_MSG_(font->file, TABLE_NAME ": " __VA_ARGS__); \ - OTS_FAILURE_MSG("Table discarded"); \ - delete font->vorg; \ - font->vorg = 0; \ - } while (0) - namespace ots { -bool ots_vorg_parse(Font *font, const uint8_t *data, size_t length) { +bool OpenTypeVORG::Parse(const uint8_t *data, size_t length) { Buffer table(data, length); - font->vorg = new OpenTypeVORG; - OpenTypeVORG * const vorg = font->vorg; uint16_t num_recs; - if (!table.ReadU16(&vorg->major_version) || - !table.ReadU16(&vorg->minor_version) || - !table.ReadS16(&vorg->default_vert_origin_y) || + if (!table.ReadU16(&this->major_version) || + !table.ReadU16(&this->minor_version) || + !table.ReadS16(&this->default_vert_origin_y) || !table.ReadU16(&num_recs)) { - return OTS_FAILURE_MSG("Failed to read header"); + return Error("Failed to read header"); } - if (vorg->major_version != 1) { - DROP_THIS_TABLE("bad major version: %u", vorg->major_version); - return true; + if (this->major_version != 1) { + return Drop("Unsupported majorVersion: %u", this->major_version); } - if (vorg->minor_version != 0) { - DROP_THIS_TABLE("bad minor version: %u", vorg->minor_version); - return true; + if (this->minor_version != 0) { + return Drop("Unsupported minorVersion: %u", this->minor_version); } // num_recs might be zero (e.g., DFHSMinchoPro5-W3-Demo.otf). @@ -48,64 +34,50 @@ bool ots_vorg_parse(Font *font, const uint8_t *data, size_t length) { } uint16_t last_glyph_index = 0; - vorg->metrics.reserve(num_recs); + this->metrics.reserve(num_recs); for (unsigned i = 0; i < num_recs; ++i) { OpenTypeVORGMetrics rec; if (!table.ReadU16(&rec.glyph_index) || !table.ReadS16(&rec.vert_origin_y)) { - return OTS_FAILURE_MSG("Failed to read record %d", i); + return Error("Failed to read record %d", i); } if ((i != 0) && (rec.glyph_index <= last_glyph_index)) { - DROP_THIS_TABLE("the table is not sorted"); - return true; + return Drop("The table is not sorted"); } last_glyph_index = rec.glyph_index; - vorg->metrics.push_back(rec); + this->metrics.push_back(rec); } return true; } -bool ots_vorg_should_serialise(Font *font) { - if (!font->cff) return false; // this table is not for fonts with TT glyphs. - return font->vorg != NULL; -} - -bool ots_vorg_serialise(OTSStream *out, Font *font) { - OpenTypeVORG * const vorg = font->vorg; - - const uint16_t num_metrics = static_cast<uint16_t>(vorg->metrics.size()); - if (num_metrics != vorg->metrics.size() || - !out->WriteU16(vorg->major_version) || - !out->WriteU16(vorg->minor_version) || - !out->WriteS16(vorg->default_vert_origin_y) || +bool OpenTypeVORG::Serialize(OTSStream *out) { + const uint16_t num_metrics = static_cast<uint16_t>(this->metrics.size()); + if (num_metrics != this->metrics.size() || + !out->WriteU16(this->major_version) || + !out->WriteU16(this->minor_version) || + !out->WriteS16(this->default_vert_origin_y) || !out->WriteU16(num_metrics)) { - return OTS_FAILURE_MSG("Failed to write table header"); + return Error("Failed to write table header"); } for (uint16_t i = 0; i < num_metrics; ++i) { - const OpenTypeVORGMetrics& rec = vorg->metrics[i]; + const OpenTypeVORGMetrics& rec = this->metrics[i]; if (!out->WriteU16(rec.glyph_index) || !out->WriteS16(rec.vert_origin_y)) { - return OTS_FAILURE_MSG("Failed to write record %d", i); + return Error("Failed to write record %d", i); } } return true; } -void ots_vorg_reuse(Font *font, Font *other) { - font->vorg = other->vorg; - font->vorg_reused = true; -} - -void ots_vorg_free(Font *font) { - delete font->vorg; +bool OpenTypeVORG::ShouldSerialize() { + return Table::ShouldSerialize() && + // this table is not for fonts with TT glyphs. + GetFont()->GetTable(OTS_TAG_CFF) != NULL; } } // namespace ots - -#undef TABLE_NAME -#undef DROP_THIS_TABLE diff --git a/gfx/ots/src/vorg.h b/gfx/ots/src/vorg.h index c3d3ffdae..caffea875 100644 --- a/gfx/ots/src/vorg.h +++ b/gfx/ots/src/vorg.h @@ -1,4 +1,4 @@ -// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Copyright (c) 2009-2017 The OTS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -16,7 +16,16 @@ struct OpenTypeVORGMetrics { int16_t vert_origin_y; }; -struct OpenTypeVORG { +class OpenTypeVORG : public Table { + public: + explicit OpenTypeVORG(Font *font, uint32_t tag) + : Table(font, tag, tag) { } + + bool Parse(const uint8_t *data, size_t length); + bool Serialize(OTSStream *out); + bool ShouldSerialize(); + + private: uint16_t major_version; uint16_t minor_version; int16_t default_vert_origin_y; diff --git a/gfx/ots/src/vvar.cc b/gfx/ots/src/vvar.cc new file mode 100644 index 000000000..b47ea479d --- /dev/null +++ b/gfx/ots/src/vvar.cc @@ -0,0 +1,95 @@ +// Copyright (c) 2018 The OTS 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 "vvar.h" + +#include "variations.h" + +namespace ots { + +// ----------------------------------------------------------------------------- +// OpenTypeVVAR +// ----------------------------------------------------------------------------- + +bool OpenTypeVVAR::Parse(const uint8_t* data, size_t length) { + Buffer table(data, length); + + uint16_t majorVersion; + uint16_t minorVersion; + uint32_t itemVariationStoreOffset; + uint32_t advanceHeightMappingOffset; + uint32_t tsbMappingOffset; + uint32_t bsbMappingOffset; + uint32_t vOrgMappingOffset; + + if (!table.ReadU16(&majorVersion) || + !table.ReadU16(&minorVersion) || + !table.ReadU32(&itemVariationStoreOffset) || + !table.ReadU32(&advanceHeightMappingOffset) || + !table.ReadU32(&tsbMappingOffset) || + !table.ReadU32(&bsbMappingOffset) || + !table.ReadU32(&vOrgMappingOffset)) { + return DropVariations("Failed to read table header"); + } + + if (majorVersion != 1) { + return DropVariations("Unknown table version"); + } + + if (itemVariationStoreOffset > length || + advanceHeightMappingOffset > length || + tsbMappingOffset > length || + bsbMappingOffset > length || + vOrgMappingOffset > length) { + return DropVariations("Invalid subtable offset"); + } + + if (!ParseItemVariationStore(GetFont(), data + itemVariationStoreOffset, + length - itemVariationStoreOffset)) { + return DropVariations("Failed to parse item variation store"); + } + + if (advanceHeightMappingOffset) { + if (!ParseDeltaSetIndexMap(GetFont(), data + advanceHeightMappingOffset, + length - advanceHeightMappingOffset)) { + return DropVariations("Failed to parse advance height mappings"); + } + } + + if (tsbMappingOffset) { + if (!ParseDeltaSetIndexMap(GetFont(), data + tsbMappingOffset, + length - tsbMappingOffset)) { + return DropVariations("Failed to parse TSB mappings"); + } + } + + if (bsbMappingOffset) { + if (!ParseDeltaSetIndexMap(GetFont(), data + bsbMappingOffset, + length - bsbMappingOffset)) { + return DropVariations("Failed to parse BSB mappings"); + } + } + + if (vOrgMappingOffset) { + if (!ParseDeltaSetIndexMap(GetFont(), data + vOrgMappingOffset, + length - vOrgMappingOffset)) { + return DropVariations("Failed to parse vOrg mappings"); + } + } + + this->m_data = data; + this->m_length = length; + + return true; +} + +bool OpenTypeVVAR::Serialize(OTSStream* out) { + if (!out->Write(this->m_data, this->m_length)) { + return Error("Failed to write VVAR table"); + } + + return true; +} + +} // namespace ots diff --git a/gfx/ots/src/vvar.h b/gfx/ots/src/vvar.h new file mode 100644 index 000000000..15d435745 --- /dev/null +++ b/gfx/ots/src/vvar.h @@ -0,0 +1,31 @@ +// Copyright (c) 2018 The OTS Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef OTS_VVAR_H_ +#define OTS_VVAR_H_ + +#include "ots.h" + +namespace ots { + +// ----------------------------------------------------------------------------- +// OpenTypeVVAR Interface +// ----------------------------------------------------------------------------- + +class OpenTypeVVAR : public Table { + public: + explicit OpenTypeVVAR(Font* font, uint32_t tag) + : Table(font, tag, tag) { } + + bool Parse(const uint8_t* data, size_t length); + bool Serialize(OTSStream* out); + + private: + const uint8_t *m_data; + size_t m_length; +}; + +} // namespace ots + +#endif // OTS_VVAR_H_ diff --git a/gfx/ots/sync.sh b/gfx/ots/sync.sh index 5a7e54b0a..81738f9e1 100755 --- a/gfx/ots/sync.sh +++ b/gfx/ots/sync.sh @@ -20,10 +20,19 @@ echo "Updating include..." rm -rf include/ cp -r $1/include . +echo "Updating tests..." +rm -rf tests/* +mkdir -p tests +cp -r $1/tests/*.cc tests + echo "Updating README.mozilla..." REVISION=`cd $1; git log | head -1 | sed "s/commit //"` -sed -e "s/\(Current revision: \).*/\1$REVISION/" README.mozilla > README.tmp +VERSION=`cd $1; git describe | cut -d '-' -f 1 | sed 's/v//'` +sed -e "s/\(Current revision: \).*/\1$REVISION \($VERSION\)/" README.mozilla > README.tmp mv README.tmp README.mozilla echo "Applying ots-visibility.patch..." patch -p3 < ots-visibility.patch + +echo "Applying ots-lz4.patch..." +patch -p3 < ots-lz4.patch diff --git a/gfx/ots/tests/cff_charstring_test.cc b/gfx/ots/tests/cff_charstring_test.cc new file mode 100644 index 000000000..18e077e8f --- /dev/null +++ b/gfx/ots/tests/cff_charstring_test.cc @@ -0,0 +1,1588 @@ +// Copyright (c) 2010-2017 The OTS 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 "cff_charstring.h" + +#include <gtest/gtest.h> + +#include <climits> +#include <vector> + +#include "cff.h" + +// Returns a biased number for callsubr and callgsubr operators. +#define GET_SUBR_NUMBER(n) ((n) - 107) +#define ARRAYSIZE(a) (sizeof(a) / sizeof(a[0])) + +namespace { + +// A constant which is used in AddSubr function below. +const int kOpPrefix = INT_MAX; + +// Encodes an operator |op| to 1 or more bytes and pushes them to |out_bytes|. +// Returns true if the conversion succeeds. +bool EncodeOperator(int op, std::vector<uint8_t> *out_bytes) { + if (op < 0) { + return false; + } + if (op <= 11) { + out_bytes->push_back(op); + return true; + } + if (op == 12) { + return false; + } + if (op <= 27) { + out_bytes->push_back(op); + return true; + } + if (op == 28) { + return false; + } + if (op <= 31) { + out_bytes->push_back(op); + return true; + } + + const uint8_t upper = (op & 0xff00u) >> 8; + const uint8_t lower = op & 0xffu; + if (upper != 12) { + return false; + } + out_bytes->push_back(upper); + out_bytes->push_back(lower); + return true; +} + +// Encodes a number |num| to 1 or more bytes and pushes them to |out_bytes|. +// Returns true if the conversion succeeds. The function does not support 16.16 +// Fixed number. +bool EncodeNumber(int num, std::vector<uint8_t> *out_bytes) { + if (num >= -107 && num <= 107) { + out_bytes->push_back(num + 139); + return true; + } + if (num >= 108 && num <= 1131) { + const uint8_t v = ((num - 108) / 256) + 247; + const uint8_t w = (num - 108) % 256; + out_bytes->push_back(v); + out_bytes->push_back(w); + return true; + } + if (num <= -108 && num >= -1131) { + const uint8_t v = (-(num + 108) / 256) + 251; + const uint8_t w = -(num + 108) % 256; + out_bytes->push_back(v); + out_bytes->push_back(w); + return true; + } + if (num <= 32768 && num >= -32767) { + const uint8_t v = (num % 0xff00u) >> 8; + const uint8_t w = num % 0xffu; + out_bytes->push_back(28); + out_bytes->push_back(v); + out_bytes->push_back(w); + return true; + } + return false; +} + +// Adds a subroutine |subr| to |out_buffer| and |out_subr|. The contents of the +// subroutine is copied to |out_buffer|, and then the position of the subroutine +// in |out_buffer| is written to |out_subr|. Returns true on success. +bool AddSubr(const int *subr, size_t subr_len, + std::vector<uint8_t>* out_buffer, ots::CFFIndex *out_subr) { + size_t pre_offset = out_buffer->size(); + for (size_t i = 0; i < subr_len; ++i) { + if (subr[i] != kOpPrefix) { + if (!EncodeNumber(subr[i], out_buffer)) { + return false; + } + } else { + if (i + 1 == subr_len) { + return false; + } + ++i; + if (!EncodeOperator(subr[i], out_buffer)) { + return false; + } + } + } + + ++(out_subr->count); + out_subr->off_size = 1; + if (out_subr->offsets.empty()) { + out_subr->offsets.push_back(pre_offset); + } + out_subr->offsets.push_back(out_buffer->size()); + return true; +} + +// Validates |char_string| and returns true if it's valid. +bool Validate(const int *char_string, size_t char_string_len, + const int *global_subrs, size_t global_subrs_len, + const int *local_subrs, size_t local_subrs_len) { + std::vector<uint8_t> buffer; + ots::CFFIndex* char_strings_index = new ots::CFFIndex; + ots::CFFIndex global_subrs_index; + ots::CFFIndex* local_subrs_index = new ots::CFFIndex; + + if (char_string) { + if (!AddSubr(char_string, char_string_len, + &buffer, char_strings_index)) { + return false; + } + } + if (global_subrs) { + if (!AddSubr(global_subrs, global_subrs_len, + &buffer, &global_subrs_index)) { + return false; + } + } + if (local_subrs) { + if (!AddSubr(local_subrs, local_subrs_len, + &buffer, local_subrs_index)) { + return false; + } + } + + ots::Buffer ots_buffer(&buffer[0], buffer.size()); + + ots::FontFile* file = new ots::FontFile(); + file->context = new ots::OTSContext(); + ots::Font* font = new ots::Font(file); + ots::OpenTypeCFF* cff = new ots::OpenTypeCFF(font, OTS_TAG_CFF); + cff->charstrings_index = char_strings_index; + cff->local_subrs = local_subrs_index; + bool ret = ots::ValidateCFFCharStrings(*cff, + global_subrs_index, + &ots_buffer); + delete file->context; + delete file; + delete font; + delete cff; + + return ret; +} + +// Validates |char_string| and returns true if it's valid. +bool ValidateCharStrings(const int *char_string, size_t char_string_len) { + return Validate(char_string, char_string_len, NULL, 0, NULL, 0); +} + +} // namespace + +TEST(ValidateTest, TestRMoveTo) { + { + const int char_string[] = { + 1, 2, kOpPrefix, ots::kRMoveTo, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, // width + 1, 2, kOpPrefix, ots::kRMoveTo, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, 2, kOpPrefix, ots::kRMoveTo, + 1, 2, 3, kOpPrefix, ots::kRMoveTo, // invalid number of args + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestHMoveTo) { + { + const int char_string[] = { + 1, kOpPrefix, ots::kHMoveTo, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, // width + 1, kOpPrefix, ots::kHMoveTo, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, kOpPrefix, ots::kHMoveTo, + 1, 2, kOpPrefix, ots::kHMoveTo, // invalid + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestVMoveTo) { + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, // width + 1, kOpPrefix, ots::kVMoveTo, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + 1, 2, kOpPrefix, ots::kVMoveTo, // invalid + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestRLineTo) { + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + 1, 2, kOpPrefix, ots::kRLineTo, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + 1, 2, 3, kOpPrefix, ots::kRLineTo, // invalid + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + 1, 2, 3, 4, kOpPrefix, ots::kRLineTo, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, 2, kOpPrefix, ots::kRLineTo, // can't be the first op. + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestHLineTo) { + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + 1, kOpPrefix, ots::kHLineTo, + 1, 2, kOpPrefix, ots::kHLineTo, + 1, 2, 3, kOpPrefix, ots::kHLineTo, + 1, 2, 3, 4, kOpPrefix, ots::kHLineTo, + 1, 2, 3, 4, 5, kOpPrefix, ots::kHLineTo, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + kOpPrefix, ots::kHLineTo, // invalid + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, kOpPrefix, ots::kHLineTo, // can't be the first op. + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestVLineTo) { + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + 1, kOpPrefix, ots::kVLineTo, + 1, 2, kOpPrefix, ots::kVLineTo, + 1, 2, 3, kOpPrefix, ots::kVLineTo, + 1, 2, 3, 4, kOpPrefix, ots::kVLineTo, + 1, 2, 3, 4, 5, kOpPrefix, ots::kVLineTo, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + kOpPrefix, ots::kVLineTo, // invalid + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, kOpPrefix, ots::kVLineTo, // can't be the first op. + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestRRCurveTo) { + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + 1, 2, 3, 4, 5, 6, kOpPrefix, ots::kRRCurveTo, + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, kOpPrefix, ots::kRRCurveTo, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + kOpPrefix, ots::kRRCurveTo, // invalid + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, 2, 3, 4, 5, 6, kOpPrefix, ots::kRRCurveTo, // can't be the first op. + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestHHCurveTo) { + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + 1, 2, 3, 4, kOpPrefix, ots::kHHCurveTo, + 1, 2, 3, 4, 5, kOpPrefix, ots::kHHCurveTo, + 1, 2, 3, 4, 5, 6, 7, 8, 9, kOpPrefix, ots::kHHCurveTo, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + 1, kOpPrefix, ots::kHHCurveTo, // invalid + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + 1, 2, 3, kOpPrefix, ots::kHHCurveTo, // invalid + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, 2, 3, 4, 5, kOpPrefix, ots::kHHCurveTo, // can't be the first op. + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestHVCurveTo) { + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + // The first form. + 1, 2, 3, 4, kOpPrefix, ots::kHVCurveTo, + 1, 2, 3, 4, 5, kOpPrefix, ots::kHVCurveTo, + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, kOpPrefix, ots::kHVCurveTo, + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + kOpPrefix, ots::kHVCurveTo, + // The second form. + 1, 2, 3, 4, 5, 6, 7, 8, kOpPrefix, ots::kHVCurveTo, + 1, 2, 3, 4, 5, 6, 7, 8, 9, kOpPrefix, ots::kHVCurveTo, + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + kOpPrefix, ots::kHVCurveTo, + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, kOpPrefix, ots::kHVCurveTo, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + 1, kOpPrefix, ots::kHVCurveTo, // invalid + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + 1, 2, 3, kOpPrefix, ots::kHVCurveTo, // invalid + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, 2, 3, 4, kOpPrefix, ots::kHVCurveTo, // can't be the first op. + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestRCurveLine) { + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + 1, 2, 3, 4, 5, 6, 7, 8, kOpPrefix, ots::kRCurveLine, + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + kOpPrefix, ots::kRCurveLine, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + 1, 2, 3, 4, 5, 6, 7, kOpPrefix, ots::kRCurveLine, // invalid + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + // can't be the first op. + 1, 2, 3, 4, 5, 6, 7, 8, kOpPrefix, ots::kRCurveLine, + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestRLineCurve) { + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + 1, 2, 3, 4, 5, 6, 7, 8, kOpPrefix, ots::kRLineCurve, + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, kOpPrefix, ots::kRLineCurve, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + 1, 2, 3, 4, 5, 6, 7, kOpPrefix, ots::kRLineCurve, // invalid + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + // can't be the first op. + 1, 2, 3, 4, 5, 6, 7, 8, kOpPrefix, ots::kRLineCurve, + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestVHCurveTo) { + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + // The first form. + 1, 2, 3, 4, kOpPrefix, ots::kVHCurveTo, + 1, 2, 3, 4, 5, kOpPrefix, ots::kVHCurveTo, + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, kOpPrefix, ots::kVHCurveTo, + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + kOpPrefix, ots::kVHCurveTo, + // The second form. + 1, 2, 3, 4, 5, 6, 7, 8, kOpPrefix, ots::kVHCurveTo, + 1, 2, 3, 4, 5, 6, 7, 8, 9, kOpPrefix, ots::kVHCurveTo, + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + kOpPrefix, ots::kVHCurveTo, + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, kOpPrefix, ots::kVHCurveTo, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + 1, kOpPrefix, ots::kVHCurveTo, // invalid + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + 1, 2, 3, kOpPrefix, ots::kVHCurveTo, // invalid + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, 2, 3, 4, kOpPrefix, ots::kVHCurveTo, // can't be the first op. + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestVVCurveTo) { + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + 1, 2, 3, 4, kOpPrefix, ots::kVVCurveTo, + 1, 2, 3, 4, 5, kOpPrefix, ots::kVVCurveTo, + 1, 2, 3, 4, 5, 6, 7, 8, kOpPrefix, ots::kVVCurveTo, + 1, 2, 3, 4, 5, 6, 7, 8, 9, kOpPrefix, ots::kVVCurveTo, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + kOpPrefix, ots::kVVCurveTo, // invalid + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + 1, kOpPrefix, ots::kVVCurveTo, // invalid + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, 2, 3, 4, kOpPrefix, ots::kVVCurveTo, // can't be the first op. + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestFlex) { + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, kOpPrefix, ots::kFlex, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + kOpPrefix, ots::kFlex, // invalid + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, kOpPrefix, ots::kFlex, // invalid + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, kOpPrefix, ots::kFlex, + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestHFlex) { + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + 1, 2, 3, 4, 5, 6, 7, kOpPrefix, ots::kHFlex, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + kOpPrefix, ots::kHFlex, // invalid + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + 1, 2, 3, 4, 5, 6, kOpPrefix, ots::kHFlex, // invalid + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, 2, 3, 4, 5, 6, 7, kOpPrefix, ots::kHFlex, + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestHFlex1) { + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + 1, 2, 3, 4, 5, 6, 7, 8, 9, kOpPrefix, ots::kHFlex1, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + kOpPrefix, ots::kHFlex1, // invalid + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + 1, 2, 3, 4, 5, 6, 7, 8, kOpPrefix, ots::kHFlex1, // invalid + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, 2, 3, 4, 5, 6, 7, 8, 9, kOpPrefix, ots::kHFlex1, + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestFlex1) { + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, kOpPrefix, ots::kFlex1, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + kOpPrefix, ots::kFlex1, // invalid + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, kOpPrefix, ots::kFlex1, // invalid + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, kOpPrefix, ots::kFlex1, + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestEndChar) { + { + const int char_string[] = { + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + GET_SUBR_NUMBER(0), kOpPrefix, ots::kCallSubr, + }; + const int local_subrs[] = { + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(Validate(char_string, ARRAYSIZE(char_string), + NULL, 0, + local_subrs, ARRAYSIZE(local_subrs))); + } + { + const int char_string[] = { + GET_SUBR_NUMBER(0), kOpPrefix, ots::kCallGSubr, + }; + const int global_subrs[] = { + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(Validate(char_string, ARRAYSIZE(char_string), + global_subrs, ARRAYSIZE(global_subrs), + NULL, 0)); + } +} + +TEST(ValidateTest, TestHStem) { + { + const int char_string[] = { + 1, 2, kOpPrefix, ots::kHStem, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, 2, 3, 4, kOpPrefix, ots::kHStem, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 0, // width + 1, 2, kOpPrefix, ots::kHStem, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + 0, 1, 2, kOpPrefix, ots::kHStem, // invalid + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + 1, 2, 3, 4, 5, kOpPrefix, ots::kHStem, // invalid + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestVStem) { + { + const int char_string[] = { + 1, 2, kOpPrefix, ots::kVStem, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, 2, 3, 4, kOpPrefix, ots::kVStem, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 0, // width + 1, 2, kOpPrefix, ots::kVStem, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + 0, 1, 2, kOpPrefix, ots::kVStem, // invalid + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + 1, 2, 3, 4, 5, kOpPrefix, ots::kVStem, // invalid + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestHStemHm) { + { + const int char_string[] = { + 1, 2, kOpPrefix, ots::kHStemHm, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, 2, 3, 4, kOpPrefix, ots::kHStemHm, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 0, // width + 1, 2, kOpPrefix, ots::kHStemHm, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + 0, 1, 2, kOpPrefix, ots::kHStemHm, // invalid + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + 1, 2, 3, 4, 5, kOpPrefix, ots::kHStemHm, // invalid + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestVStemHm) { + { + const int char_string[] = { + 1, 2, kOpPrefix, ots::kVStemHm, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, 2, 3, 4, kOpPrefix, ots::kVStemHm, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 0, // width + 1, 2, kOpPrefix, ots::kVStemHm, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + 0, 1, 2, kOpPrefix, ots::kVStemHm, // invalid + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, kOpPrefix, ots::kVMoveTo, + 1, 2, 3, 4, 5, kOpPrefix, ots::kVStemHm, // invalid + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestHintMask) { + { + const int char_string[] = { + 1, 2, kOpPrefix, ots::kHStem, + kOpPrefix, ots::kHintMask, 0x00, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, 2, kOpPrefix, ots::kHStem, + 3, 4, 5, 6, kOpPrefix, ots::kHintMask, 0x00, // vstem + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + kOpPrefix, ots::kHintMask, 0x00, // no stems to mask + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, 2, kOpPrefix, ots::kHStem, + 3, 4, 5, kOpPrefix, ots::kHintMask, 0x00, // invalid vstem + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestCntrMask) { + { + const int char_string[] = { + 1, 2, kOpPrefix, ots::kHStem, + kOpPrefix, ots::kCntrMask, 0x00, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, 2, kOpPrefix, ots::kHStem, + 3, 4, 5, 6, kOpPrefix, ots::kCntrMask, 0x00, // vstem + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + kOpPrefix, ots::kCntrMask, 0x00, // no stems to mask + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, 2, kOpPrefix, ots::kHStem, + 3, 4, 5, kOpPrefix, ots::kCntrMask, 0x00, // invalid vstem + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestAbs) { + { + const int char_string[] = { + -1, kOpPrefix, ots::kAbs, + 2, kOpPrefix, ots::kHStem, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + kOpPrefix, ots::kAbs, // invalid + 2, kOpPrefix, ots::kHStem, + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestAdd) { + { + const int char_string[] = { + 0, 1, kOpPrefix, ots::kAdd, + 2, kOpPrefix, ots::kHStem, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, kOpPrefix, ots::kAdd, // invalid + 2, kOpPrefix, ots::kHStem, + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestSub) { + { + const int char_string[] = { + 2, 1, kOpPrefix, ots::kSub, + 2, kOpPrefix, ots::kHStem, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, kOpPrefix, ots::kSub, // invalid + 2, kOpPrefix, ots::kHStem, + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestDiv) { + // TODO(yusukes): Test div-by-zero. + { + const int char_string[] = { + 2, 1, kOpPrefix, ots::kDiv, + 2, kOpPrefix, ots::kHStem, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, kOpPrefix, ots::kDiv, // invalid + 2, kOpPrefix, ots::kHStem, + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestNeg) { + { + const int char_string[] = { + -1, kOpPrefix, ots::kNeg, + 2, kOpPrefix, ots::kHStem, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + kOpPrefix, ots::kNeg, // invalid + 2, kOpPrefix, ots::kHStem, + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestRandom) { + { + const int char_string[] = { + kOpPrefix, ots::kRandom, // OTS rejects the operator. + 2, kOpPrefix, ots::kHStem, + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestMul) { + { + const int char_string[] = { + 2, 1, kOpPrefix, ots::kMul, + 2, kOpPrefix, ots::kHStem, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, kOpPrefix, ots::kMul, // invalid + 2, kOpPrefix, ots::kHStem, + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestSqrt) { + // TODO(yusukes): Test negative numbers. + { + const int char_string[] = { + 4, kOpPrefix, ots::kSqrt, + 2, kOpPrefix, ots::kHStem, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + kOpPrefix, ots::kSqrt, // invalid + 2, kOpPrefix, ots::kHStem, + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestDrop) { + { + const int char_string[] = { + 1, 1, kOpPrefix, ots::kAdd, + kOpPrefix, ots::kDrop, + 1, 2, kOpPrefix, ots::kHStem, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + kOpPrefix, ots::kDrop, // invalid + 1, 2, kOpPrefix, ots::kHStem, + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestExch) { + { + const int char_string[] = { + 1, 1, kOpPrefix, ots::kAdd, + kOpPrefix, ots::kDup, + kOpPrefix, ots::kExch, + kOpPrefix, ots::kHStem, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, 1, kOpPrefix, ots::kAdd, + kOpPrefix, ots::kExch, // invalid + 2, kOpPrefix, ots::kHStem, + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestIndex) { + { + const int char_string[] = { + 1, 2, 3, -1, kOpPrefix, ots::kIndex, // OTS rejects the operator. + kOpPrefix, ots::kHStem, + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestRoll) { + { + const int char_string[] = { + 1, 2, 2, 1, kOpPrefix, ots::kRoll, // OTS rejects the operator. + kOpPrefix, ots::kHStem, + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestDup) { + { + const int char_string[] = { + 1, 1, kOpPrefix, ots::kAdd, + kOpPrefix, ots::kDup, + kOpPrefix, ots::kHStem, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + kOpPrefix, ots::kDup, // invalid + 2, kOpPrefix, ots::kHStem, + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestPut) { + { + const int char_string[] = { + 1, 10, kOpPrefix, ots::kPut, // OTS rejects the operator. + 1, 2, kOpPrefix, ots::kHStem, + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestGet) { + { + const int char_string[] = { + 1, 10, kOpPrefix, ots::kGet, // OTS rejects the operator. + 1, 2, kOpPrefix, ots::kHStem, + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestAnd) { + { + const int char_string[] = { + 2, 1, kOpPrefix, ots::kAnd, + 2, kOpPrefix, ots::kHStem, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, kOpPrefix, ots::kAnd, // invalid + 2, kOpPrefix, ots::kHStem, + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestOr) { + { + const int char_string[] = { + 2, 1, kOpPrefix, ots::kOr, + 2, kOpPrefix, ots::kHStem, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, kOpPrefix, ots::kOr, // invalid + 2, kOpPrefix, ots::kHStem, + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestNot) { + { + const int char_string[] = { + 1, kOpPrefix, ots::kNot, + 2, kOpPrefix, ots::kHStem, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + kOpPrefix, ots::kNot, // invalid + 2, kOpPrefix, ots::kHStem, + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestEq) { + { + const int char_string[] = { + 2, 1, kOpPrefix, ots::kEq, + 2, kOpPrefix, ots::kHStem, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, kOpPrefix, ots::kEq, // invalid + 2, kOpPrefix, ots::kHStem, + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestIfElse) { + { + const int char_string[] = { + 1, 2, 3, 4, kOpPrefix, ots::kIfElse, + 2, kOpPrefix, ots::kHStem, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, 2, 3, kOpPrefix, ots::kIfElse, // invalid + 2, kOpPrefix, ots::kHStem, + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestCallSubr) { + // Call valid subr. + { + const int char_string[] = { + GET_SUBR_NUMBER(0), kOpPrefix, ots::kCallSubr, + }; + const int local_subrs[] = { + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(Validate(char_string, ARRAYSIZE(char_string), + NULL, 0, + local_subrs, ARRAYSIZE(local_subrs))); + } + // Call undefined subr. + { + const int char_string[] = { + GET_SUBR_NUMBER(-1), kOpPrefix, ots::kCallSubr, + }; + const int local_subrs[] = { + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(Validate(char_string, ARRAYSIZE(char_string), + NULL, 0, + local_subrs, ARRAYSIZE(local_subrs))); + } + { + const int char_string[] = { + GET_SUBR_NUMBER(1), kOpPrefix, ots::kCallSubr, + }; + const int local_subrs[] = { + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(Validate(char_string, ARRAYSIZE(char_string), + NULL, 0, + local_subrs, ARRAYSIZE(local_subrs))); + } + { + const int char_string[] = { + GET_SUBR_NUMBER(-1), kOpPrefix, ots::kCallSubr, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + GET_SUBR_NUMBER(0), kOpPrefix, ots::kCallSubr, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + GET_SUBR_NUMBER(1), kOpPrefix, ots::kCallSubr, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestCallGSubr) { + // Call valid subr. + { + const int char_string[] = { + GET_SUBR_NUMBER(0), kOpPrefix, ots::kCallGSubr, + }; + const int global_subrs[] = { + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(Validate(char_string, ARRAYSIZE(char_string), + global_subrs, ARRAYSIZE(global_subrs), + NULL, 0)); + } + // Call undefined subr. + { + const int char_string[] = { + GET_SUBR_NUMBER(-1), kOpPrefix, ots::kCallGSubr, + }; + const int global_subrs[] = { + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(Validate(char_string, ARRAYSIZE(char_string), + global_subrs, ARRAYSIZE(global_subrs), + NULL, 0)); + } + { + const int char_string[] = { + GET_SUBR_NUMBER(1), kOpPrefix, ots::kCallGSubr, + }; + const int global_subrs[] = { + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(Validate(char_string, ARRAYSIZE(char_string), + global_subrs, ARRAYSIZE(global_subrs), + NULL, 0)); + } + { + const int char_string[] = { + GET_SUBR_NUMBER(-1), kOpPrefix, ots::kCallGSubr, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + GET_SUBR_NUMBER(0), kOpPrefix, ots::kCallGSubr, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + GET_SUBR_NUMBER(1), kOpPrefix, ots::kCallGSubr, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestCallGSubrWithComputedValues) { + { + // OTS does not allow to call(g)subr with a subroutine number which is + // not a immediate value for safety. + const int char_string[] = { + 0, 0, kOpPrefix, ots::kAdd, + kOpPrefix, ots::kCallGSubr, + }; + const int global_subrs[] = { + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(Validate(char_string, ARRAYSIZE(char_string), + global_subrs, ARRAYSIZE(global_subrs), + NULL, 0)); + } +} + +TEST(ValidateTest, TestInfiniteLoop) { + { + const int char_string[] = { + GET_SUBR_NUMBER(0), kOpPrefix, ots::kCallSubr, + }; + const int local_subrs[] = { + GET_SUBR_NUMBER(0), kOpPrefix, ots::kCallSubr, + }; + EXPECT_FALSE(Validate(char_string, ARRAYSIZE(char_string), + NULL, 0, + local_subrs, ARRAYSIZE(local_subrs))); + } + { + const int char_string[] = { + GET_SUBR_NUMBER(0), kOpPrefix, ots::kCallGSubr, + }; + const int global_subrs[] = { + GET_SUBR_NUMBER(0), kOpPrefix, ots::kCallGSubr, + }; + EXPECT_FALSE(Validate(char_string, ARRAYSIZE(char_string), + global_subrs, ARRAYSIZE(global_subrs), + NULL, 0)); + } + // mutual recursion which doesn't stop. + { + const int char_string[] = { + GET_SUBR_NUMBER(0), kOpPrefix, ots::kCallSubr, + }; + const int global_subrs[] = { + GET_SUBR_NUMBER(0), kOpPrefix, ots::kCallSubr, + }; + const int local_subrs[] = { + GET_SUBR_NUMBER(0), kOpPrefix, ots::kCallGSubr, + }; + EXPECT_FALSE(Validate(char_string, ARRAYSIZE(char_string), + global_subrs, ARRAYSIZE(global_subrs), + local_subrs, ARRAYSIZE(local_subrs))); + } +} + +TEST(ValidateTest, TestStackOverflow) { + { + const int char_string[] = { + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, + 1, 2, 3, 4, 5, 6, 7, 8, + kOpPrefix, ots::kEndChar, + }; + EXPECT_TRUE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, + 1, 2, 3, 4, 5, 6, 7, 8, 9, // overflow + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestDeprecatedOperators) { + { + const int char_string[] = { + kOpPrefix, 16, // 'blend'. + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + kOpPrefix, (12 << 8) + 8, // 'store'. + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + kOpPrefix, (12 << 8) + 13, // 'load'. + kOpPrefix, ots::kEndChar, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} + +TEST(ValidateTest, TestUnterminatedCharString) { + // No endchar operator. + { + const int char_string[] = { + 123, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 123, 456, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } + { + const int char_string[] = { + 123, 456, kOpPrefix, ots::kReturn, + }; + EXPECT_FALSE(ValidateCharStrings(char_string, ARRAYSIZE(char_string))); + } +} diff --git a/gfx/ots/tests/layout_common_table_test.cc b/gfx/ots/tests/layout_common_table_test.cc new file mode 100644 index 000000000..91e429741 --- /dev/null +++ b/gfx/ots/tests/layout_common_table_test.cc @@ -0,0 +1,770 @@ +// Copyright (c) 2011-2017 The OTS 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 <cmath> +#include <vector> +#include <gtest/gtest.h> + +#include "layout.h" +#include "ots-memory-stream.h" + +namespace { + +const uint32_t kFakeTag = 0x00000000; +const size_t kScriptRecordSize = 6; +const size_t kLangSysRecordSize = 6; + +bool BuildFakeScriptListTable(ots::OTSStream *out, const uint16_t script_count, + const uint16_t langsys_count, + const uint16_t feature_count) { + if (!out->WriteU16(script_count)) { + return false; + } + const off_t script_record_end = out->Tell() + + kScriptRecordSize * script_count; + const size_t script_table_size = 4 + kLangSysRecordSize * langsys_count; + for (unsigned i = 0; i < script_count; ++i) { + if (!out->WriteU32(kFakeTag) || + !out->WriteU16(script_record_end + i * script_table_size)) { + return false; + } + } + + // Offsets to LangSys tables are measured from the beginning of each + // script table. + const off_t langsys_record_end = 4 + kLangSysRecordSize * langsys_count; + const size_t langsys_table_size = 6 + 2 * feature_count; + // Write Fake Script tables. + for (unsigned i = 0; i < script_count; ++i) { + if (!out->WriteU16(0x0000) || + !out->WriteU16(langsys_count)) { + return false; + } + for (unsigned j = 0; j < langsys_count; ++j) { + if (!out->WriteU32(kFakeTag) || + !out->WriteU16(langsys_record_end + j * langsys_table_size)) { + return false; + } + } + } + + // Write Fake LangSys tables. + for (unsigned i = 0; i < langsys_count; ++i) { + if (!out->WriteU16(0x0000) || + !out->WriteU16(0xFFFF) || + !out->WriteU16(feature_count)) { + return false; + } + for (unsigned j = 0; j < feature_count; ++j) { + if (!out->WriteU16(j)) { + return false; + } + } + } + return true; +} + +const size_t kFeatureRecordSize = 6; + +bool BuildFakeFeatureListTable(ots::OTSStream *out, + const uint16_t feature_count, + const uint16_t lookup_count) { + if (!out->WriteU16(feature_count)) { + return false; + } + const off_t feature_record_end = out->Tell() + + kFeatureRecordSize * feature_count; + const size_t feature_table_size = 4 + 2 * lookup_count; + for (unsigned i = 0; i < feature_count; ++i) { + if (!out->WriteU32(kFakeTag) || + !out->WriteU16(feature_record_end + i * feature_table_size)) { + return false; + } + } + + // Write FeatureTable + for (unsigned i = 0; i < feature_count; ++i) { + if (!out->WriteU16(0x0000) || + !out->WriteU16(lookup_count)) { + return false; + } + for (uint16_t j = 0; j < lookup_count; ++j) { + if (!out->WriteU16(j)) { + return false; + } + } + } + return true; +} + +bool BuildFakeLookupListTable(ots::OTSStream *out, const uint16_t lookup_count, + const uint16_t subtable_count) { + if (!out->WriteU16(lookup_count)) { + return false; + } + const off_t base_offset_lookup = out->Tell(); + if (!out->Pad(2 * lookup_count)) { + return false; + } + + std::vector<off_t> offsets_lookup(lookup_count, 0); + for (uint16_t i = 0; i < lookup_count; ++i) { + offsets_lookup[i] = out->Tell(); + if (!out->WriteU16(i + 1) || + !out->WriteU16(0) || + !out->WriteU16(subtable_count) || + !out->Pad(2 * subtable_count) || + !out->WriteU16(0)) { + return false; + } + } + + const off_t offset_lookup_table_end = out->Tell(); + // Allocate 256 bytes for each subtable. + if (!out->Pad(256 * lookup_count * subtable_count)) { + return false; + } + + if (!out->Seek(base_offset_lookup)) { + return false; + } + for (unsigned i = 0; i < lookup_count; ++i) { + if (!out->WriteU16(offsets_lookup[i])) { + return false; + } + } + + for (unsigned i = 0; i < lookup_count; ++i) { + if (!out->Seek(offsets_lookup[i] + 6)) { + return false; + } + for (unsigned j = 0; j < subtable_count; ++j) { + if (!out->WriteU16(offset_lookup_table_end + + 256*i*subtable_count + 256*j)) { + return false; + } + } + } + return true; +} + +bool BuildFakeCoverageFormat1(ots::OTSStream *out, const uint16_t glyph_count) { + if (!out->WriteU16(1) || !out->WriteU16(glyph_count)) { + return false; + } + for (uint16_t glyph_id = 1; glyph_id <= glyph_count; ++glyph_id) { + if (!out->WriteU16(glyph_id)) { + return false; + } + } + return true; +} + +bool BuildFakeCoverageFormat2(ots::OTSStream *out, const uint16_t range_count) { + if (!out->WriteU16(2) || !out->WriteU16(range_count)) { + return false; + } + uint16_t glyph_id = 1; + uint16_t start_coverage_index = 0; + for (unsigned i = 0; i < range_count; ++i) { + // Write consecutive ranges in which each range consists of two glyph id. + if (!out->WriteU16(glyph_id) || + !out->WriteU16(glyph_id + 1) || + !out->WriteU16(start_coverage_index)) { + return false; + } + glyph_id += 2; + start_coverage_index += 2; + } + return true; +} + +bool BuildFakeClassDefFormat1(ots::OTSStream *out, const uint16_t glyph_count) { + if (!out->WriteU16(1) || + !out->WriteU16(1) || + !out->WriteU16(glyph_count)) { + return false; + } + for (uint16_t class_value = 1; class_value <= glyph_count; ++class_value) { + if (!out->WriteU16(class_value)) { + return false; + } + } + return true; +} + +bool BuildFakeClassDefFormat2(ots::OTSStream *out, const uint16_t range_count) { + if (!out->WriteU16(2) || !out->WriteU16(range_count)) { + return false; + } + uint16_t glyph_id = 1; + for (uint16_t class_value = 1; class_value <= range_count; ++class_value) { + // Write consecutive ranges in which each range consists of one glyph id. + if (!out->WriteU16(glyph_id) || + !out->WriteU16(glyph_id + 1) || + !out->WriteU16(class_value)) { + return false; + } + glyph_id += 2; + } + return true; +} + +bool BuildFakeDeviceTable(ots::OTSStream *out, const uint16_t start_size, + const uint16_t end_size, const uint16_t format) { + if (!out->WriteU16(start_size) || + !out->WriteU16(end_size) || + !out->WriteU16(format)) { + return false; + } + + const unsigned num_values = std::abs(end_size - start_size) + 1; + const unsigned num_bits = (1 << format) * num_values; + const unsigned num_units = (num_bits - 1) / 16 + 1; + if (!out->Pad(num_units * 2)) { + return false; + } + return true; +} + +class TestStream : public ots::MemoryStream { + public: + TestStream() + : ots::MemoryStream(data_, sizeof(data_)), size_(0) { + std::memset(reinterpret_cast<char*>(data_), 0, sizeof(data_)); + } + + uint8_t* data() { return data_; } + size_t size() const { return size_; } + + virtual bool WriteRaw(const void *d, size_t length) { + if (Tell() + length > size_) { + size_ = Tell() + length; + } + return ots::MemoryStream::WriteRaw(d, length); + } + + private: + size_t size_; + uint8_t data_[4096]; +}; + +class TableTest : public ::testing::Test { + protected: + + virtual void SetUp() { + ots::FontFile *file = new ots::FontFile(); + file->context = new ots::OTSContext(); + font = new ots::Font(file); + } + + virtual void TearDown() { + delete font->file->context; + delete font->file; + delete font; + } + + TestStream out; + ots::Font *font; +}; + +class ScriptListTableTest : public TableTest { }; +class DeviceTableTest : public TableTest { }; +class CoverageTableTest : public TableTest { }; +class CoverageFormat1Test : public TableTest { }; +class CoverageFormat2Test : public TableTest { }; +class ClassDefTableTest : public TableTest { }; +class ClassDefFormat1Test : public TableTest { }; +class ClassDefFormat2Test : public TableTest { }; +class LookupSubtableParserTest : public TableTest { }; + +class FeatureListTableTest : public TableTest { + protected: + + virtual void SetUp() { + TableTest::SetUp(); + num_features = 0; + } + + uint16_t num_features; +}; + +bool fakeTypeParserReturnsTrue(const ots::Font*, const uint8_t *, + const size_t) { + return true; +} + +bool fakeTypeParserReturnsFalse(const ots::Font*, const uint8_t *, + const size_t) { + return false; +} + +const ots::LookupSubtableParser::TypeParser TypeParsersReturnTrue[] = { + {1, fakeTypeParserReturnsTrue}, + {2, fakeTypeParserReturnsTrue}, + {3, fakeTypeParserReturnsTrue}, + {4, fakeTypeParserReturnsTrue}, + {5, fakeTypeParserReturnsTrue} +}; + +// Fake lookup subtable parser which always returns true. +const ots::LookupSubtableParser FakeLookupParserReturnsTrue = { + 5, 5, TypeParsersReturnTrue, +}; + +const ots::LookupSubtableParser::TypeParser TypeParsersReturnFalse[] = { + {1, fakeTypeParserReturnsFalse} +}; + +// Fake lookup subtable parser which always returns false. +const ots::LookupSubtableParser FakeLookupParserReturnsFalse = { + 1, 1, TypeParsersReturnFalse +}; + +class LookupListTableTest : public TableTest { + protected: + + virtual void SetUp() { + TableTest::SetUp(); + num_lookups = 0; + } + + bool Parse() { + return ots::ParseLookupListTable(font, out.data(), out.size(), + &FakeLookupParserReturnsTrue, + &num_lookups); + } + + uint16_t num_lookups; +}; + +} // namespace + +TEST_F(ScriptListTableTest, TestSuccess) { + BuildFakeScriptListTable(&out, 1, 1, 1); + EXPECT_TRUE(ots::ParseScriptListTable(font, out.data(), out.size(), 1)); +} + +TEST_F(ScriptListTableTest, TestBadScriptCount) { + BuildFakeScriptListTable(&out, 1, 1, 1); + // Set too large script count. + out.Seek(0); + out.WriteU16(2); + EXPECT_FALSE(ots::ParseScriptListTable(font, out.data(), out.size(), 1)); +} + +TEST_F(ScriptListTableTest, TestScriptRecordOffsetUnderflow) { + BuildFakeScriptListTable(&out, 1, 1, 1); + // Set bad offset to ScriptRecord[0]. + out.Seek(6); + out.WriteU16(0); + EXPECT_FALSE(ots::ParseScriptListTable(font, out.data(), out.size(), 1)); +} + +TEST_F(ScriptListTableTest, TestScriptRecordOffsetOverflow) { + BuildFakeScriptListTable(&out, 1, 1, 1); + // Set bad offset to ScriptRecord[0]. + out.Seek(6); + out.WriteU16(out.size()); + EXPECT_FALSE(ots::ParseScriptListTable(font, out.data(), out.size(), 1)); +} + +TEST_F(ScriptListTableTest, TestBadLangSysCount) { + BuildFakeScriptListTable(&out, 1, 1, 1); + // Set too large langsys count. + out.Seek(10); + out.WriteU16(2); + EXPECT_FALSE(ots::ParseScriptListTable(font, out.data(), out.size(), 1)); +} + +TEST_F(ScriptListTableTest, TestLangSysRecordOffsetUnderflow) { + BuildFakeScriptListTable(&out, 1, 1, 1); + // Set bad offset to LangSysRecord[0]. + out.Seek(16); + out.WriteU16(0); + EXPECT_FALSE(ots::ParseScriptListTable(font, out.data(), out.size(), 1)); +} + +TEST_F(ScriptListTableTest, TestLangSysRecordOffsetOverflow) { + BuildFakeScriptListTable(&out, 1, 1, 1); + // Set bad offset to LangSysRecord[0]. + out.Seek(16); + out.WriteU16(out.size()); + EXPECT_FALSE(ots::ParseScriptListTable(font, out.data(), out.size(), 1)); +} + +TEST_F(ScriptListTableTest, TestBadReqFeatureIndex) { + BuildFakeScriptListTable(&out, 1, 1, 1); + // Set too large feature index to ReqFeatureIndex of LangSysTable[0]. + out.Seek(20); + out.WriteU16(2); + EXPECT_FALSE(ots::ParseScriptListTable(font, out.data(), out.size(), 1)); +} + +TEST_F(ScriptListTableTest, TestBadFeatureCount) { + BuildFakeScriptListTable(&out, 1, 1, 1); + // Set too large feature count to LangSysTable[0]. + out.Seek(22); + out.WriteU16(2); + EXPECT_FALSE(ots::ParseScriptListTable(font, out.data(), out.size(), 1)); +} + +TEST_F(ScriptListTableTest, TestBadFeatureIndex) { + BuildFakeScriptListTable(&out, 1, 1, 1); + // Set too large feature index to ReatureIndex[0] of LangSysTable[0]. + out.Seek(24); + out.WriteU16(2); + EXPECT_FALSE(ots::ParseScriptListTable(font, out.data(), out.size(), 1)); +} + +TEST_F(FeatureListTableTest, TestSuccess) { + BuildFakeFeatureListTable(&out, 1, 1); + EXPECT_TRUE(ots::ParseFeatureListTable(font, out.data(), out.size(), 1, + &num_features)); + EXPECT_EQ(num_features, 1); +} + +TEST_F(FeatureListTableTest, TestSuccess2) { + BuildFakeFeatureListTable(&out, 5, 1); + EXPECT_TRUE(ots::ParseFeatureListTable(font, out.data(), out.size(), 1, + &num_features)); + EXPECT_EQ(num_features, 5); +} + +TEST_F(FeatureListTableTest, TestBadFeatureCount) { + BuildFakeFeatureListTable(&out, 1, 1); + // Set too large feature count. + out.Seek(0); + out.WriteU16(2); + EXPECT_FALSE(ots::ParseFeatureListTable(font, out.data(), out.size(), 1, + &num_features)); +} + +TEST_F(FeatureListTableTest, TestOffsetFeatureUnderflow) { + BuildFakeFeatureListTable(&out, 1, 1); + // Set bad offset to FeatureRecord[0]. + out.Seek(6); + out.WriteU16(0); + EXPECT_FALSE(ots::ParseFeatureListTable(font, out.data(), out.size(), 1, + &num_features)); +} + +TEST_F(FeatureListTableTest, TestOffsetFeatureOverflow) { + BuildFakeFeatureListTable(&out, 1, 1); + // Set bad offset to FeatureRecord[0]. + out.Seek(6); + out.WriteU16(out.size()); + EXPECT_FALSE(ots::ParseFeatureListTable(font, out.data(), out.size(), 1, + &num_features)); +} + +TEST_F(FeatureListTableTest, TestBadLookupCount) { + BuildFakeFeatureListTable(&out, 1, 1); + // Set too large lookup count to FeatureTable[0]. + out.Seek(10); + out.WriteU16(2); + EXPECT_FALSE(ots::ParseFeatureListTable(font, out.data(), out.size(), 1, + &num_features)); +} + +TEST_F(LookupListTableTest, TestSuccess) { + BuildFakeLookupListTable(&out, 1, 1); + EXPECT_TRUE(Parse()); + EXPECT_EQ(num_lookups, 1); +} + +TEST_F(LookupListTableTest, TestSuccess2) { + BuildFakeLookupListTable(&out, 5, 1); + EXPECT_TRUE(Parse()); + EXPECT_EQ(num_lookups, 5); +} + +TEST_F(LookupListTableTest, TestOffsetLookupTableUnderflow) { + BuildFakeLookupListTable(&out, 1, 1); + // Set bad offset to Lookup[0]. + out.Seek(2); + out.WriteU16(0); + EXPECT_FALSE(Parse()); +} + +TEST_F(LookupListTableTest, TestOffsetLookupTableOverflow) { + BuildFakeLookupListTable(&out, 1, 1); + // Set bad offset to Lookup[0]. + out.Seek(2); + out.WriteU16(out.size()); + EXPECT_FALSE(Parse()); +} + +TEST_F(LookupListTableTest, TestOffsetSubtableUnderflow) { + BuildFakeLookupListTable(&out, 1, 1); + // Set bad offset to SubTable[0] of LookupTable[0]. + out.Seek(10); + out.WriteU16(0); + EXPECT_FALSE(Parse()); +} + +TEST_F(LookupListTableTest, TestOffsetSubtableOverflow) { + BuildFakeLookupListTable(&out, 1, 1); + // Set bad offset to SubTable[0] of LookupTable[0]. + out.Seek(10); + out.WriteU16(out.size()); + EXPECT_FALSE(Parse()); +} + +TEST_F(LookupListTableTest, TesBadLookupCount) { + BuildFakeLookupListTable(&out, 1, 1); + // Set too large lookup count of LookupTable[0]. + out.Seek(0); + out.WriteU16(2); + EXPECT_FALSE(Parse()); +} + +TEST_F(LookupListTableTest, TesBadLookupType) { + BuildFakeLookupListTable(&out, 1, 1); + // Set too large lookup type of LookupTable[0]. + out.Seek(4); + out.WriteU16(6); + EXPECT_FALSE(Parse()); +} + +TEST_F(LookupListTableTest, TesBadLookupFlag) { + BuildFakeLookupListTable(&out, 1, 1); + // Set IgnoreBaseGlyphs(0x0002) to the lookup flag of LookupTable[0]. + out.Seek(6); + out.WriteU16(0x0002); + EXPECT_TRUE(Parse()); +} + +TEST_F(LookupListTableTest, TesBadSubtableCount) { + BuildFakeLookupListTable(&out, 1, 1); + // Set too large sutable count of LookupTable[0]. + out.Seek(8); + out.WriteU16(2); + EXPECT_FALSE(Parse()); +} + +TEST_F(CoverageTableTest, TestSuccessFormat1) { + BuildFakeCoverageFormat1(&out, 1); + EXPECT_TRUE(ots::ParseCoverageTable(font, out.data(), out.size(), 1)); +} + +TEST_F(CoverageTableTest, TestSuccessFormat2) { + BuildFakeCoverageFormat2(&out, 1); + EXPECT_TRUE(ots::ParseCoverageTable(font, out.data(), out.size(), 1)); +} + +TEST_F(CoverageTableTest, TestBadFormat) { + BuildFakeCoverageFormat1(&out, 1); + // Set bad format. + out.Seek(0); + out.WriteU16(3); + EXPECT_FALSE(ots::ParseCoverageTable(font, out.data(), out.size(), 1)); +} + +TEST_F(CoverageFormat1Test, TestBadGlyphCount) { + BuildFakeCoverageFormat1(&out, 1); + // Set too large glyph count. + out.Seek(2); + out.WriteU16(2); + EXPECT_FALSE(ots::ParseCoverageTable(font, out.data(), out.size(), 1)); +} + +TEST_F(CoverageFormat1Test, TestBadGlyphId) { + BuildFakeCoverageFormat1(&out, 1); + // Set too large glyph id. + out.Seek(4); + out.WriteU16(2); + EXPECT_FALSE(ots::ParseCoverageTable(font, out.data(), out.size(), 1)); +} + +TEST_F(CoverageFormat2Test, TestBadRangeCount) { + BuildFakeCoverageFormat2(&out, 1); + // Set too large range count. + out.Seek(2); + out.WriteU16(2); + EXPECT_FALSE(ots::ParseCoverageTable(font, out.data(), out.size(), 1)); +} + +TEST_F(CoverageFormat2Test, TestBadRange) { + BuildFakeCoverageFormat2(&out, 1); + // Set reverse order glyph id to start/end fields. + out.Seek(4); + out.WriteU16(2); + out.WriteU16(1); + EXPECT_FALSE(ots::ParseCoverageTable(font, out.data(), out.size(), 1)); +} + +TEST_F(CoverageFormat2Test, TestRangeOverlap) { + BuildFakeCoverageFormat2(&out, 2); + // Set overlapping glyph id to an end field. + out.Seek(12); + out.WriteU16(1); + EXPECT_FALSE(ots::ParseCoverageTable(font, out.data(), out.size(), 2)); +} + +TEST_F(CoverageFormat2Test, TestRangeOverlap2) { + BuildFakeCoverageFormat2(&out, 2); + // Set overlapping range. + out.Seek(10); + out.WriteU16(1); + out.WriteU16(2); + EXPECT_FALSE(ots::ParseCoverageTable(font, out.data(), out.size(), 2)); +} + +TEST_F(ClassDefTableTest, TestSuccessFormat1) { + BuildFakeClassDefFormat1(&out, 1); + EXPECT_TRUE(ots::ParseClassDefTable(font, out.data(), out.size(), 1, 1)); +} + +TEST_F(ClassDefTableTest, TestSuccessFormat2) { + BuildFakeClassDefFormat2(&out, 1); + EXPECT_TRUE(ots::ParseClassDefTable(font, out.data(), out.size(), 1, 1)); +} + +TEST_F(ClassDefTableTest, TestBadFormat) { + BuildFakeClassDefFormat1(&out, 1); + // Set bad format. + out.Seek(0); + out.WriteU16(3); + EXPECT_FALSE(ots::ParseClassDefTable(font, out.data(), out.size(), 1, 1)); +} + +TEST_F(ClassDefFormat1Test, TestBadStartGlyph) { + BuildFakeClassDefFormat1(&out, 1); + // Set too large start glyph id. + out.Seek(2); + out.WriteU16(2); + EXPECT_FALSE(ots::ParseClassDefTable(font, out.data(), out.size(), 1, 1)); +} + +TEST_F(ClassDefFormat1Test, TestBadGlyphCount) { + BuildFakeClassDefFormat1(&out, 1); + // Set too large glyph count. + out.Seek(4); + out.WriteU16(2); + EXPECT_FALSE(ots::ParseClassDefTable(font, out.data(), out.size(), 1, 1)); +} + +TEST_F(ClassDefFormat1Test, TestBadClassValue) { + BuildFakeClassDefFormat1(&out, 1); + // Set too large class value. + out.Seek(6); + out.WriteU16(2); + EXPECT_FALSE(ots::ParseClassDefTable(font, out.data(), out.size(), 1, 1)); +} + +TEST_F(ClassDefFormat2Test, TestBadRangeCount) { + BuildFakeClassDefFormat2(&out, 1); + // Set too large range count. + out.Seek(2); + out.WriteU16(2); + EXPECT_FALSE(ots::ParseClassDefTable(font, out.data(), out.size(), 1, 1)); +} + +TEST_F(ClassDefFormat2Test, TestRangeOverlap) { + BuildFakeClassDefFormat2(&out, 2); + // Set overlapping glyph id to an end field. + out.Seek(12); + out.WriteU16(1); + EXPECT_FALSE(ots::ParseClassDefTable(font, out.data(), out.size(), 1, 1)); +} + +TEST_F(ClassDefFormat2Test, TestRangeOverlap2) { + BuildFakeClassDefFormat2(&out, 2); + // Set overlapping range. + out.Seek(10); + out.WriteU16(1); + out.WriteU16(2); + EXPECT_FALSE(ots::ParseClassDefTable(font, out.data(), out.size(), 1, 1)); +} + +TEST_F(DeviceTableTest, TestDeltaFormat1Success) { + BuildFakeDeviceTable(&out, 1, 8, 1); + EXPECT_TRUE(ots::ParseDeviceTable(font, out.data(), out.size())); +} + +TEST_F(DeviceTableTest, TestDeltaFormat1Success2) { + BuildFakeDeviceTable(&out, 1, 9, 1); + EXPECT_TRUE(ots::ParseDeviceTable(font, out.data(), out.size())); +} + +TEST_F(DeviceTableTest, TestDeltaFormat1Fail) { + // Pass shorter length than expected. + BuildFakeDeviceTable(&out, 1, 8, 1); + EXPECT_FALSE(ots::ParseDeviceTable(font, out.data(), out.size() - 1)); +} + +TEST_F(DeviceTableTest, TestDeltaFormat1Fail2) { + // Pass shorter length than expected. + BuildFakeDeviceTable(&out, 1, 9, 1); + EXPECT_FALSE(ots::ParseDeviceTable(font, out.data(), out.size() - 1)); +} + +TEST_F(DeviceTableTest, TestDeltaFormat2Success) { + BuildFakeDeviceTable(&out, 1, 1, 2); + EXPECT_TRUE(ots::ParseDeviceTable(font, out.data(), out.size())); +} + +TEST_F(DeviceTableTest, TestDeltaFormat2Success2) { + BuildFakeDeviceTable(&out, 1, 8, 2); + EXPECT_TRUE(ots::ParseDeviceTable(font, out.data(), out.size())); +} + +TEST_F(DeviceTableTest, TestDeltaFormat2Fail) { + // Pass shorter length than expected. + BuildFakeDeviceTable(&out, 1, 8, 2); + EXPECT_FALSE(ots::ParseDeviceTable(font, out.data(), out.size() - 1)); +} + +TEST_F(DeviceTableTest, TestDeltaFormat2Fail2) { + // Pass shorter length than expected. + BuildFakeDeviceTable(&out, 1, 9, 2); + EXPECT_FALSE(ots::ParseDeviceTable(font, out.data(), out.size() - 1)); +} + +TEST_F(DeviceTableTest, TestDeltaFormat3Success) { + BuildFakeDeviceTable(&out, 1, 1, 3); + EXPECT_TRUE(ots::ParseDeviceTable(font, out.data(), out.size())); +} + +TEST_F(DeviceTableTest, TestDeltaFormat3Success2) { + BuildFakeDeviceTable(&out, 1, 8, 3); + EXPECT_TRUE(ots::ParseDeviceTable(font, out.data(), out.size())); +} + +TEST_F(DeviceTableTest, TestDeltaFormat3Fail) { + // Pass shorter length than expected. + BuildFakeDeviceTable(&out, 1, 8, 3); + EXPECT_FALSE(ots::ParseDeviceTable(font, out.data(), out.size() - 1)); +} + +TEST_F(DeviceTableTest, TestDeltaFormat3Fail2) { + // Pass shorter length than expected. + BuildFakeDeviceTable(&out, 1, 9, 3); + EXPECT_FALSE(ots::ParseDeviceTable(font, out.data(), out.size() - 1)); +} + +TEST_F(LookupSubtableParserTest, TestSuccess) { + { + EXPECT_TRUE(FakeLookupParserReturnsTrue.Parse(font, 0, 0, 1)); + } + { + EXPECT_TRUE(FakeLookupParserReturnsTrue.Parse(font, 0, 0, 5)); + } +} + +TEST_F(LookupSubtableParserTest, TestFail) { + { + // Pass bad lookup type which less than the smallest type. + EXPECT_FALSE(FakeLookupParserReturnsTrue.Parse(font, 0, 0, 0)); + } + { + // Pass bad lookup type which greater than the maximum type. + EXPECT_FALSE(FakeLookupParserReturnsTrue.Parse(font, 0, 0, 6)); + } + { + // Check the type parser failure. + EXPECT_FALSE(FakeLookupParserReturnsFalse.Parse(font, 0, 0, 1)); + } +} |