mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Bug 1835833 - Update OTS to 9.1.0. r=jfkthame 

Differential Revision: https://phabricator.services.mozilla.com/D179464
This commit is contained in:
Ryan VanderMeulen 2023-05-30 16:56:48 +00:00
Родитель 738c5394ac
Коммит d10b5739d2
16 изменённых файлов: 1009 добавлений и 1937 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

2
gfx/ots/README.mozilla
Просмотреть файл

@ -2,7 +2,7 @@ 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: 35643038c4904538aa74c2c691f8d792efdbd6c0 (9.0.0)
Current revision: 75933e1bdc98bdb095f6274b284e1c365f2c510e (9.1.0)
Upstream files included: LICENSE, src/, include/, tests/*.cc

73
gfx/ots/src/avar.cc
Просмотреть файл

@ -6,6 +6,8 @@
#include "fvar.h"
#include "variations.h"
namespace ots {
// -----------------------------------------------------------------------------
@ -20,17 +22,28 @@ bool OpenTypeAVAR::Parse(const uint8_t* data, size_t length) {
!table.ReadU16(&this->axisCount)) {
return Drop("Failed to read table header");
}
if (this->majorVersion != 1) {
if (this->majorVersion > 2) {
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;
if (this->majorVersion == 1) {
// We can fix table
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;
}
} else {
// We serialize data unchanged, so drop even for minor errors
if (this->minorVersion > 0) {
return Drop("Unknown minor table version");
}
if (this->reserved != 0) {
return Drop("Expected reserved=0");
}
}
OpenTypeFVAR* fvar = static_cast<OpenTypeFVAR*>(
@ -79,10 +92,52 @@ bool OpenTypeAVAR::Parse(const uint8_t* data, size_t length) {
}
}
if (this->majorVersion < 2)
return true;
uint32_t axisIndexMapOffset;
uint32_t varStoreOffset;
if (!table.ReadU32(&axisIndexMapOffset) ||
!table.ReadU32(&varStoreOffset)) {
return Drop("Failed to read version 2 offsets");
}
Font *font = GetFont();
uint32_t headerSize = table.offset();
if (axisIndexMapOffset) {
if (axisIndexMapOffset < headerSize || axisIndexMapOffset >= length) {
return Drop("Bad delta set index offset in table header");
}
if (!ParseDeltaSetIndexMap(font, data + axisIndexMapOffset, length - axisIndexMapOffset)) {
return Drop("Failed to parse delta set index map");
}
}
if (varStoreOffset) {
if (varStoreOffset < headerSize || varStoreOffset >= length) {
return Drop("Bad item variation store offset in table header");
}
if (!ParseItemVariationStore(font, data + varStoreOffset, length - varStoreOffset)) {
return Drop("Failed to parse item variation store");
}
}
this->m_data = data;
this->m_length = length;
return true;
}
bool OpenTypeAVAR::Serialize(OTSStream* out) {
if (this->majorVersion >= 2) {
if (!out->Write(this->m_data, this->m_length)) {
return Error("Failed to write table");
}
return true;
}
if (!out->WriteU16(this->majorVersion) ||
!out->WriteU16(this->minorVersion) ||
!out->WriteU16(this->reserved) ||

4
gfx/ots/src/avar.h
Просмотреть файл

@ -35,6 +35,10 @@ class OpenTypeAVAR : public Table {
};
std::vector<std::vector<AxisValueMap>> axisSegmentMaps;
// Only used for versions >= 2
const uint8_t *m_data;
size_t m_length;
};
} // namespace ots

2
gfx/ots/src/cff_charstring.cc
Просмотреть файл

@ -384,7 +384,7 @@ bool ExecuteCharStringOperator(ots::OpenTypeCFF& cff,
}
uint16_t k = cff.region_index_count.at(cs_ctx.vsindex);
uint16_t n = argument_stack->top();
if (stack_size < n * (k + 1) + 1) {
if (stack_size < n * (k + 1u) + 1u) {
return OTS_FAILURE();
}

2
gfx/ots/src/cpal.cc
Просмотреть файл

@ -194,7 +194,9 @@ bool OpenTypeCPAL::Serialize(OTSStream *out) {
uint16_t numPalettes = this->colorRecordIndices.size();
uint16_t numColorRecords = this->colorRecords.size();
#ifndef NDEBUG
off_t start = out->Tell();
#endif
size_t colorRecordsArrayOffset = 4 * sizeof(uint16_t) + sizeof(uint32_t) +
numPalettes * sizeof(uint16_t);

4
gfx/ots/src/glyf.cc
Просмотреть файл

@ -112,9 +112,9 @@ bool OpenTypeGLYF::ParseSimpleGlyph(Buffer &glyph,
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);
this->maxp->max_size_glyf_instructions = bytecode_length;
}
if (!glyph.Skip(bytecode_length)) {
@ -215,10 +215,10 @@ bool OpenTypeGLYF::ParseCompositeGlyph(
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);
this->maxp->max_size_glyf_instructions = bytecode_length;
}
if (!glyph.Skip(bytecode_length)) {

576
gfx/ots/src/gpos.cc
Просмотреть файл

@ -30,50 +30,9 @@ enum GPOS_TYPE {
GPOS_TYPE_RESERVED = 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;
// Lookup type parsers.
bool ParseSingleAdjustment(const ots::Font *font,
const uint8_t *data, const size_t length);
bool ParsePairAdjustment(const ots::Font *font,
const uint8_t *data, const size_t length);
bool ParseCursiveAttachment(const ots::Font *font,
const uint8_t *data, const size_t length);
bool ParseMarkToBaseAttachment(const ots::Font *font,
const uint8_t *data, const size_t length);
bool ParseMarkToLigatureAttachment(const ots::Font *font,
const uint8_t *data, const size_t length);
bool ParseMarkToMarkAttachment(const ots::Font *font,
const uint8_t *data, const size_t length);
bool ParseContextPositioning(const ots::Font *font,
const uint8_t *data, const size_t length);
bool ParseChainedContextPositioning(const ots::Font *font,
const uint8_t *data, const size_t length);
bool ParseExtensionPositioning(const ots::Font *font,
const uint8_t *data, const size_t length);
const ots::LookupSubtableParser::TypeParser kGposTypeParsers[] = {
{GPOS_TYPE_SINGLE_ADJUSTMENT, ParseSingleAdjustment},
{GPOS_TYPE_PAIR_ADJUSTMENT, ParsePairAdjustment},
{GPOS_TYPE_CURSIVE_ATTACHMENT, ParseCursiveAttachment},
{GPOS_TYPE_MARK_TO_BASE_ATTACHMENT, ParseMarkToBaseAttachment},
{GPOS_TYPE_MARK_TO_LIGATURE_ATTACHMENT, ParseMarkToLigatureAttachment},
{GPOS_TYPE_MARK_TO_MARK_ATTACHMENT, ParseMarkToMarkAttachment},
{GPOS_TYPE_CONTEXT_POSITIONING, ParseContextPositioning},
{GPOS_TYPE_CHAINED_CONTEXT_POSITIONING, ParseChainedContextPositioning},
{GPOS_TYPE_EXTENSION_POSITIONING, ParseExtensionPositioning}
};
const ots::LookupSubtableParser kGposLookupSubtableParser = {
arraysize(kGposTypeParsers),
GPOS_TYPE_EXTENSION_POSITIONING, kGposTypeParsers
};
// Shared Tables: ValueRecord, Anchor Table, and MarkArray
size_t CalcValueRecordSize(const uint16_t value_format) {
@ -214,59 +173,6 @@ bool ParseMarkArrayTable(const ots::Font *font,
return true;
}
// Lookup Type 1:
// Single Adjustment Positioning Subtable
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;
if (!subtable.ReadU16(&format) ||
!subtable.ReadU16(&offset_coverage) ||
!subtable.ReadU16(&value_format)) {
return OTS_FAILURE_MSG("Can't read single adjustment information");
}
if (format == 1) {
// Format 1 exactly one value record.
if (!ParseValueRecord(font, &subtable, value_format)) {
return OTS_FAILURE_MSG("Failed to parse format 1 single adjustment table");
}
} else if (format == 2) {
uint16_t value_count = 0;
if (!subtable.ReadU16(&value_count)) {
return OTS_FAILURE_MSG("Failed to parse format 2 single adjustment table");
}
for (unsigned i = 0; i < value_count; ++i) {
if (!ParseValueRecord(font, &subtable, value_format)) {
return OTS_FAILURE_MSG("Failed to parse value record %d in format 2 single adjustment table", i);
}
}
} else {
return OTS_FAILURE_MSG("Bad format %d in single adjustment table", format);
}
if (offset_coverage < subtable.offset() || offset_coverage >= length) {
return OTS_FAILURE_MSG("Bad coverage offset %d in single adjustment table", offset_coverage);
}
if (!ots::ParseCoverageTable(font, data + offset_coverage,
length - offset_coverage,
maxp->num_glyphs)) {
return OTS_FAILURE_MSG("Failed to parse coverage table in single adjustment table");
}
return true;
}
bool ParsePairSetTable(const ots::Font *font,
const uint8_t *data, const size_t length,
const uint16_t value_format1,
@ -404,128 +310,6 @@ bool ParsePairPosFormat2(const ots::Font *font,
return true;
}
// Lookup Type 2:
// Pair Adjustment Positioning Subtable
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;
uint16_t value_format2 = 0;
if (!subtable.ReadU16(&format) ||
!subtable.ReadU16(&offset_coverage) ||
!subtable.ReadU16(&value_format1) ||
!subtable.ReadU16(&value_format2)) {
return OTS_FAILURE_MSG("Failed to read pair adjustment structure");
}
if (format == 1) {
if (!ParsePairPosFormat1(font, data, length, value_format1, value_format2,
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,
maxp->num_glyphs)) {
return OTS_FAILURE_MSG("Failed to parse pair format 2");
}
} else {
return OTS_FAILURE_MSG("Bad pos pair format %d", format);
}
if (offset_coverage < subtable.offset() || offset_coverage >= length) {
return OTS_FAILURE_MSG("Bad pair pos offset coverage %d", offset_coverage);
}
if (!ots::ParseCoverageTable(font, data + offset_coverage,
length - offset_coverage,
maxp->num_glyphs)) {
return OTS_FAILURE_MSG("Failed to parse coverage table");
}
return true;
}
// Lookup Type 3
// Cursive Attachment Positioning Subtable
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;
if (!subtable.ReadU16(&format) ||
!subtable.ReadU16(&offset_coverage) ||
!subtable.ReadU16(&entry_exit_count)) {
return OTS_FAILURE_MSG("Failed to read cursive attachment structure");
}
if (format != 1) {
return OTS_FAILURE_MSG("Bad cursive attachment format %d", format);
}
// Check entry exit records.
const unsigned entry_exit_records_end =
2 * static_cast<unsigned>(entry_exit_count) + 6;
if (entry_exit_records_end > std::numeric_limits<uint16_t>::max()) {
return OTS_FAILURE_MSG("Bad entry exit record end %d", entry_exit_records_end);
}
for (unsigned i = 0; i < entry_exit_count; ++i) {
uint16_t offset_entry_anchor = 0;
uint16_t offset_exit_anchor = 0;
if (!subtable.ReadU16(&offset_entry_anchor) ||
!subtable.ReadU16(&offset_exit_anchor)) {
return OTS_FAILURE_MSG("Can't read entry exit record %d", i);
}
// These offsets could be NULL.
if (offset_entry_anchor) {
if (offset_entry_anchor < entry_exit_records_end ||
offset_entry_anchor >= length) {
return OTS_FAILURE_MSG("Bad entry anchor offset %d in entry exit record %d", offset_entry_anchor, i);
}
if (!ParseAnchorTable(font, data + offset_entry_anchor,
length - offset_entry_anchor)) {
return OTS_FAILURE_MSG("Failed to parse entry anchor table in entry exit record %d", i);
}
}
if (offset_exit_anchor) {
if (offset_exit_anchor < entry_exit_records_end ||
offset_exit_anchor >= length) {
return OTS_FAILURE_MSG("Bad exit anchor offset %d in entry exit record %d", offset_exit_anchor, i);
}
if (!ParseAnchorTable(font, data + offset_exit_anchor,
length - offset_exit_anchor)) {
return OTS_FAILURE_MSG("Failed to parse exit anchor table in entry exit record %d", i);
}
}
}
if (offset_coverage < subtable.offset() || offset_coverage >= length) {
return OTS_FAILURE_MSG("Bad coverage offset in cursive attachment %d", offset_coverage);
}
if (!ots::ParseCoverageTable(font, data + offset_coverage,
length - offset_coverage,
maxp->num_glyphs)) {
return OTS_FAILURE_MSG("Failed to parse coverage table in cursive attachment");
}
return true;
}
bool ParseAnchorArrayTable(const ots::Font *font,
const uint8_t *data, const size_t length,
const uint16_t class_count) {
@ -671,169 +455,255 @@ bool ParseMarkToAttachmentSubtables(const ots::Font *font,
return true;
}
} // namespace
namespace ots {
// Lookup Type 1:
// Single Adjustment Positioning Subtable
bool OpenTypeGPOS::ParseSingleAdjustment(const uint8_t *data,
const size_t length) {
Font* font = GetFont();
Buffer subtable(data, length);
OpenTypeMAXP *maxp = static_cast<OpenTypeMAXP*>(
font->GetTypedTable(OTS_TAG_MAXP));
if (!maxp) {
return Error("Required maxp table missing");
}
uint16_t format = 0;
uint16_t offset_coverage = 0;
uint16_t value_format = 0;
if (!subtable.ReadU16(&format) ||
!subtable.ReadU16(&offset_coverage) ||
!subtable.ReadU16(&value_format)) {
return Error("Can't read single adjustment information");
}
if (format == 1) {
// Format 1 exactly one value record.
if (!ParseValueRecord(font, &subtable, value_format)) {
return Error("Failed to parse format 1 single adjustment table");
}
} else if (format == 2) {
uint16_t value_count = 0;
if (!subtable.ReadU16(&value_count)) {
return Error("Failed to parse format 2 single adjustment table");
}
for (unsigned i = 0; i < value_count; ++i) {
if (!ParseValueRecord(font, &subtable, value_format)) {
return Error("Failed to parse value record %d in format 2 single adjustment table", i);
}
}
} else {
return Error("Bad format %d in single adjustment table", format);
}
if (offset_coverage < subtable.offset() || offset_coverage >= length) {
return Error("Bad coverage offset %d in single adjustment table", offset_coverage);
}
if (!ots::ParseCoverageTable(font, data + offset_coverage,
length - offset_coverage,
maxp->num_glyphs)) {
return Error("Failed to parse coverage table in single adjustment table");
}
return true;
}
// Lookup Type 2:
// Pair Adjustment Positioning Subtable
bool OpenTypeGPOS::ParsePairAdjustment(const uint8_t *data,
const size_t length) {
Font* font = GetFont();
Buffer subtable(data, length);
OpenTypeMAXP *maxp = static_cast<OpenTypeMAXP*>(
font->GetTypedTable(OTS_TAG_MAXP));
if (!maxp) {
return Error("Required maxp table missing");
}
uint16_t format = 0;
uint16_t offset_coverage = 0;
uint16_t value_format1 = 0;
uint16_t value_format2 = 0;
if (!subtable.ReadU16(&format) ||
!subtable.ReadU16(&offset_coverage) ||
!subtable.ReadU16(&value_format1) ||
!subtable.ReadU16(&value_format2)) {
return Error("Failed to read pair adjustment structure");
}
if (format == 1) {
if (!ParsePairPosFormat1(font, data, length, value_format1, value_format2,
maxp->num_glyphs)) {
return Error("Failed to parse pair pos format 1");
}
} else if (format == 2) {
if (!ParsePairPosFormat2(font, data, length, value_format1, value_format2,
maxp->num_glyphs)) {
return Error("Failed to parse pair format 2");
}
} else {
return Error("Bad pos pair format %d", format);
}
if (offset_coverage < subtable.offset() || offset_coverage >= length) {
return Error("Bad pair pos offset coverage %d", offset_coverage);
}
if (!ots::ParseCoverageTable(font, data + offset_coverage,
length - offset_coverage,
maxp->num_glyphs)) {
return Error("Failed to parse coverage table");
}
return true;
}
// Lookup Type 3
// Cursive Attachment Positioning Subtable
bool OpenTypeGPOS::ParseCursiveAttachment(const uint8_t *data,
const size_t length) {
Font* font = GetFont();
Buffer subtable(data, length);
OpenTypeMAXP *maxp = static_cast<OpenTypeMAXP*>(
font->GetTypedTable(OTS_TAG_MAXP));
if (!maxp) {
return Error("Required maxp table missing");
}
uint16_t format = 0;
uint16_t offset_coverage = 0;
uint16_t entry_exit_count = 0;
if (!subtable.ReadU16(&format) ||
!subtable.ReadU16(&offset_coverage) ||
!subtable.ReadU16(&entry_exit_count)) {
return Error("Failed to read cursive attachment structure");
}
if (format != 1) {
return Error("Bad cursive attachment format %d", format);
}
// Check entry exit records.
const unsigned entry_exit_records_end =
2 * static_cast<unsigned>(entry_exit_count) + 6;
if (entry_exit_records_end > std::numeric_limits<uint16_t>::max()) {
return Error("Bad entry exit record end %d", entry_exit_records_end);
}
for (unsigned i = 0; i < entry_exit_count; ++i) {
uint16_t offset_entry_anchor = 0;
uint16_t offset_exit_anchor = 0;
if (!subtable.ReadU16(&offset_entry_anchor) ||
!subtable.ReadU16(&offset_exit_anchor)) {
return Error("Can't read entry exit record %d", i);
}
// These offsets could be NULL.
if (offset_entry_anchor) {
if (offset_entry_anchor < entry_exit_records_end ||
offset_entry_anchor >= length) {
return Error("Bad entry anchor offset %d in entry exit record %d", offset_entry_anchor, i);
}
if (!ParseAnchorTable(font, data + offset_entry_anchor,
length - offset_entry_anchor)) {
return Error("Failed to parse entry anchor table in entry exit record %d", i);
}
}
if (offset_exit_anchor) {
if (offset_exit_anchor < entry_exit_records_end ||
offset_exit_anchor >= length) {
return Error("Bad exit anchor offset %d in entry exit record %d", offset_exit_anchor, i);
}
if (!ParseAnchorTable(font, data + offset_exit_anchor,
length - offset_exit_anchor)) {
return Error("Failed to parse exit anchor table in entry exit record %d", i);
}
}
}
if (offset_coverage < subtable.offset() || offset_coverage >= length) {
return Error("Bad coverage offset in cursive attachment %d", offset_coverage);
}
if (!ots::ParseCoverageTable(font, data + offset_coverage,
length - offset_coverage,
maxp->num_glyphs)) {
return Error("Failed to parse coverage table in cursive attachment");
}
return true;
}
// Lookup Type 4:
// MarkToBase Attachment Positioning Subtable
bool ParseMarkToBaseAttachment(const ots::Font *font,
const uint8_t *data, const size_t length) {
return ParseMarkToAttachmentSubtables(font, data, length,
bool OpenTypeGPOS::ParseMarkToBaseAttachment(const uint8_t *data,
const size_t length) {
return ParseMarkToAttachmentSubtables(GetFont(), data, length,
GPOS_TYPE_MARK_TO_BASE_ATTACHMENT);
}
// Lookup Type 5:
// MarkToLigature Attachment Positioning Subtable
bool ParseMarkToLigatureAttachment(const ots::Font *font,
const uint8_t *data, const size_t length) {
return ParseMarkToAttachmentSubtables(font, data, length,
bool OpenTypeGPOS::ParseMarkToLigatureAttachment(const uint8_t *data,
const size_t length) {
return ParseMarkToAttachmentSubtables(GetFont(), data, length,
GPOS_TYPE_MARK_TO_LIGATURE_ATTACHMENT);
}
// Lookup Type 6:
// MarkToMark Attachment Positioning Subtable
bool ParseMarkToMarkAttachment(const ots::Font *font,
const uint8_t *data, const size_t length) {
return ParseMarkToAttachmentSubtables(font, data, length,
bool OpenTypeGPOS::ParseMarkToMarkAttachment(const uint8_t *data,
const size_t length) {
return ParseMarkToAttachmentSubtables(GetFont(), data, length,
GPOS_TYPE_MARK_TO_MARK_ATTACHMENT);
}
// Lookup Type 7:
// Contextual Positioning Subtables
bool ParseContextPositioning(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::ParseContextSubtable(font, data, length, maxp->num_glyphs,
gpos->num_lookups);
}
// OpenTypeLayoutTable::ParseContextSubtable()
// 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,
maxp->num_glyphs,
gpos->num_lookups);
}
// OpenTypeLayoutTable::ParseChainingContextSubtable()
// Lookup Type 9:
// Extension Positioning
bool ParseExtensionPositioning(const ots::Font *font,
const uint8_t *data, const size_t length) {
return ots::ParseExtensionSubtable(font, data, length,
&kGposLookupSubtableParser);
// OpenTypeLayoutTable::ParseExtensionSubtable
bool OpenTypeGPOS::ValidLookupSubtableType(const uint16_t lookup_type,
bool extension) const {
if (extension && lookup_type == GPOS_TYPE_EXTENSION_POSITIONING)
return false;
return lookup_type >= GPOS_TYPE_SINGLE_ADJUSTMENT && lookup_type < GPOS_TYPE_RESERVED;
}
} // namespace
namespace ots {
bool OpenTypeGPOS::Parse(const uint8_t *data, size_t length) {
Font *font = GetFont();
Buffer table(data, length);
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;
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 Error("Incomplete table");
bool OpenTypeGPOS::ParseLookupSubtable(const uint8_t *data, const size_t length,
const uint16_t lookup_type) {
switch (lookup_type) {
case GPOS_TYPE_SINGLE_ADJUSTMENT:
return ParseSingleAdjustment(data, length);
case GPOS_TYPE_PAIR_ADJUSTMENT:
return ParsePairAdjustment(data, length);
case GPOS_TYPE_CURSIVE_ATTACHMENT:
return ParseCursiveAttachment(data, length);
case GPOS_TYPE_MARK_TO_BASE_ATTACHMENT:
return ParseMarkToBaseAttachment(data, length);
case GPOS_TYPE_MARK_TO_LIGATURE_ATTACHMENT:
return ParseMarkToLigatureAttachment(data, length);
case GPOS_TYPE_MARK_TO_MARK_ATTACHMENT:
return ParseMarkToMarkAttachment(data, length);
case GPOS_TYPE_CONTEXT_POSITIONING:
return ParseContextSubtable(data, length);
case GPOS_TYPE_CHAINED_CONTEXT_POSITIONING:
return ParseChainingContextSubtable(data, length);
case GPOS_TYPE_EXTENSION_POSITIONING:
return ParseExtensionSubtable(data, length);
}
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 < 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,
&this->num_lookups)) {
return Error("Failed to parse lookup list table");
}
}
uint16_t num_features = 0;
if (offset_feature_list) {
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, this->num_lookups,
&num_features)) {
return Error("Failed to parse feature list table");
}
}
if (offset_script_list) {
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 Error("Failed to parse script list table");
}
}
if (offset_feature_variations) {
if (offset_feature_variations < header_size || offset_feature_variations >= length) {
return Error("Bad feature variations offset in table header");
}
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;
}
bool OpenTypeGPOS::Serialize(OTSStream *out) {
if (!out->Write(this->m_data, this->m_length)) {
return Error("Failed to write GPOS table");
}
return true;
return false;
}
} // namespace ots

28
gfx/ots/src/gpos.h
Просмотреть файл

@ -6,27 +6,27 @@
#define OTS_GPOS_H_
#include "ots.h"
#include "layout.h"
namespace ots {
class OpenTypeGPOS : public Table {
class OpenTypeGPOS : public OpenTypeLayoutTable {
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;
: OpenTypeLayoutTable(font, tag, tag) { }
private:
const uint8_t *m_data;
size_t m_length;
bool ValidLookupSubtableType(const uint16_t lookup_type,
bool extension = false) const;
bool ParseLookupSubtable(const uint8_t *data, const size_t length,
const uint16_t lookup_type);
bool ParseSingleAdjustment(const uint8_t *data, const size_t length);
bool ParsePairAdjustment(const uint8_t *data, const size_t length);
bool ParseCursiveAttachment(const uint8_t *data, const size_t length);
bool ParseMarkToBaseAttachment(const uint8_t *data, const size_t length);
bool ParseMarkToLigatureAttachment(const uint8_t *data, const size_t length);
bool ParseMarkToMarkAttachment(const uint8_t *data, const size_t length);
};
} // namespace ots

625
gfx/ots/src/gsub.cc
Просмотреть файл

@ -17,11 +17,6 @@
namespace {
// 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,
GSUB_TYPE_MULTIPLE = 2,
@ -34,104 +29,6 @@ enum GSUB_TYPE {
GSUB_TYPE_RESERVED = 9
};
// Lookup type parsers.
bool ParseSingleSubstitution(const ots::Font *font,
const uint8_t *data, const size_t length);
bool ParseMutipleSubstitution(const ots::Font *font,
const uint8_t *data, const size_t length);
bool ParseAlternateSubstitution(const ots::Font *font,
const uint8_t *data, const size_t length);
bool ParseLigatureSubstitution(const ots::Font *font,
const uint8_t *data, const size_t length);
bool ParseContextSubstitution(const ots::Font *font,
const uint8_t *data, const size_t length);
bool ParseChainingContextSubstitution(const ots::Font *font,
const uint8_t *data,
const size_t length);
bool ParseExtensionSubstitution(const ots::Font *font,
const uint8_t *data, const size_t length);
bool ParseReverseChainingContextSingleSubstitution(
const ots::Font *font, const uint8_t *data, const size_t length);
const ots::LookupSubtableParser::TypeParser kGsubTypeParsers[] = {
{GSUB_TYPE_SINGLE, ParseSingleSubstitution},
{GSUB_TYPE_MULTIPLE, ParseMutipleSubstitution},
{GSUB_TYPE_ALTERNATE, ParseAlternateSubstitution},
{GSUB_TYPE_LIGATURE, ParseLigatureSubstitution},
{GSUB_TYPE_CONTEXT, ParseContextSubstitution},
{GSUB_TYPE_CHANGING_CONTEXT, ParseChainingContextSubstitution},
{GSUB_TYPE_EXTENSION_SUBSTITUTION, ParseExtensionSubstitution},
{GSUB_TYPE_REVERSE_CHAINING_CONTEXT_SINGLE,
ParseReverseChainingContextSingleSubstitution}
};
const ots::LookupSubtableParser kGsubLookupSubtableParser = {
arraysize(kGsubTypeParsers),
GSUB_TYPE_EXTENSION_SUBSTITUTION, kGsubTypeParsers
};
// Lookup Type 1:
// Single Substitution Subtable
bool ParseSingleSubstitution(const ots::Font *font,
const uint8_t *data, const size_t length) {
ots::Buffer subtable(data, length);
uint16_t format = 0;
uint16_t offset_coverage = 0;
if (!subtable.ReadU16(&format) ||
!subtable.ReadU16(&offset_coverage)) {
return OTS_FAILURE_MSG("Failed to read single subst table header");
}
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;
if (!subtable.ReadS16(&delta_glyph_id)) {
return OTS_FAILURE_MSG("Failed to read glyph shift from format 1 single subst table");
}
if (std::abs(delta_glyph_id) >= num_glyphs) {
return OTS_FAILURE_MSG("bad glyph shift of %d in format 1 single subst table", delta_glyph_id);
}
} else if (format == 2) {
// Parse SingleSubstFormat2
uint16_t glyph_count = 0;
if (!subtable.ReadU16(&glyph_count)) {
return OTS_FAILURE_MSG("Failed to read glyph cound in format 2 single subst table");
}
if (glyph_count > num_glyphs) {
return OTS_FAILURE_MSG("Bad glyph count %d > %d in format 2 single subst table", glyph_count, num_glyphs);
}
for (unsigned i = 0; i < glyph_count; ++i) {
uint16_t substitute = 0;
if (!subtable.ReadU16(&substitute)) {
return OTS_FAILURE_MSG("Failed to read substitution %d in format 2 single subst table", i);
}
if (substitute >= num_glyphs) {
return OTS_FAILURE_MSG("too large substitute: %u", substitute);
}
}
} else {
return OTS_FAILURE_MSG("Bad single subst table format %d", format);
}
if (offset_coverage < subtable.offset() || offset_coverage >= length) {
return OTS_FAILURE_MSG("Bad coverage offset %x", offset_coverage);
}
if (!ots::ParseCoverageTable(font, data + offset_coverage,
length - offset_coverage, num_glyphs)) {
return OTS_FAILURE_MSG("Failed to parse coverage table");
}
return true;
}
bool ParseSequenceTable(const ots::Font *font,
const uint8_t *data, const size_t length,
const uint16_t num_glyphs) {
@ -157,62 +54,6 @@ bool ParseSequenceTable(const ots::Font *font,
return true;
}
// Lookup Type 2:
// Multiple Substitution Subtable
bool ParseMutipleSubstitution(const ots::Font *font,
const uint8_t *data, const size_t length) {
ots::Buffer subtable(data, length);
uint16_t format = 0;
uint16_t offset_coverage = 0;
uint16_t sequence_count = 0;
if (!subtable.ReadU16(&format) ||
!subtable.ReadU16(&offset_coverage) ||
!subtable.ReadU16(&sequence_count)) {
return OTS_FAILURE_MSG("Can't read header of multiple subst table");
}
if (format != 1) {
return OTS_FAILURE_MSG("Bad multiple subst table format %d", format);
}
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()) {
return OTS_FAILURE_MSG("Bad sequence end %d, in multiple subst", sequence_end);
}
for (unsigned i = 0; i < sequence_count; ++i) {
uint16_t offset_sequence = 0;
if (!subtable.ReadU16(&offset_sequence)) {
return OTS_FAILURE_MSG("Failed to read sequence offset for sequence %d", i);
}
if (offset_sequence < sequence_end || offset_sequence >= length) {
return OTS_FAILURE_MSG("Bad sequence offset %d for sequence %d", offset_sequence, i);
}
if (!ParseSequenceTable(font, data + offset_sequence, length - offset_sequence,
num_glyphs)) {
return OTS_FAILURE_MSG("Failed to parse sequence table %d", i);
}
}
if (offset_coverage < sequence_end || offset_coverage >= length) {
return OTS_FAILURE_MSG("Bad coverage offset %d", offset_coverage);
}
if (!ots::ParseCoverageTable(font, data + offset_coverage,
length - offset_coverage, num_glyphs)) {
return OTS_FAILURE_MSG("Failed to parse coverage table");
}
return true;
}
bool ParseAlternateSetTable(const ots::Font *font,
const uint8_t *data, const size_t length,
const uint16_t num_glyphs) {
@ -237,64 +78,6 @@ bool ParseAlternateSetTable(const ots::Font *font,
return true;
}
// Lookup Type 3:
// Alternate Substitution Subtable
bool ParseAlternateSubstitution(const ots::Font *font,
const uint8_t *data, const size_t length) {
ots::Buffer subtable(data, length);
uint16_t format = 0;
uint16_t offset_coverage = 0;
uint16_t alternate_set_count = 0;
if (!subtable.ReadU16(&format) ||
!subtable.ReadU16(&offset_coverage) ||
!subtable.ReadU16(&alternate_set_count)) {
return OTS_FAILURE_MSG("Can't read alternate subst header");
}
if (format != 1) {
return OTS_FAILURE_MSG("Bad alternate subst table format %d", format);
}
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()) {
return OTS_FAILURE_MSG("Bad end of alternate set %d", alternate_set_end);
}
for (unsigned i = 0; i < alternate_set_count; ++i) {
uint16_t offset_alternate_set = 0;
if (!subtable.ReadU16(&offset_alternate_set)) {
return OTS_FAILURE_MSG("Can't read alternate set offset for set %d", i);
}
if (offset_alternate_set < alternate_set_end ||
offset_alternate_set >= length) {
return OTS_FAILURE_MSG("Bad alternate set offset %d for set %d", offset_alternate_set, i);
}
if (!ParseAlternateSetTable(font, data + offset_alternate_set,
length - offset_alternate_set,
num_glyphs)) {
return OTS_FAILURE_MSG("Failed to parse alternate set");
}
}
if (offset_coverage < alternate_set_end || offset_coverage >= length) {
return OTS_FAILURE_MSG("Bad coverage offset %d", offset_coverage);
}
if (!ots::ParseCoverageTable(font, data + offset_coverage,
length - offset_coverage, num_glyphs)) {
return OTS_FAILURE_MSG("Failed to parse coverage table");
}
return true;
}
bool ParseLigatureTable(const ots::Font *font,
const uint8_t *data, const size_t length,
const uint16_t num_glyphs) {
@ -359,11 +142,195 @@ bool ParseLigatureSetTable(const ots::Font *font,
return true;
}
} // namespace
namespace ots {
// Lookup Type 1:
// Single Substitution Subtable
bool OpenTypeGSUB::ParseSingleSubstitution(const uint8_t *data,
const size_t length) {
Font* font = GetFont();
Buffer subtable(data, length);
uint16_t format = 0;
uint16_t offset_coverage = 0;
if (!subtable.ReadU16(&format) ||
!subtable.ReadU16(&offset_coverage)) {
return Error("Failed to read single subst table header");
}
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;
if (format == 1) {
// Parse SingleSubstFormat1
int16_t delta_glyph_id = 0;
if (!subtable.ReadS16(&delta_glyph_id)) {
return Error("Failed to read glyph shift from format 1 single subst table");
}
if (std::abs(delta_glyph_id) >= num_glyphs) {
return Error("bad glyph shift of %d in format 1 single subst table", delta_glyph_id);
}
} else if (format == 2) {
// Parse SingleSubstFormat2
uint16_t glyph_count = 0;
if (!subtable.ReadU16(&glyph_count)) {
return Error("Failed to read glyph cound in format 2 single subst table");
}
if (glyph_count > num_glyphs) {
return Error("Bad glyph count %d > %d in format 2 single subst table", glyph_count, num_glyphs);
}
for (unsigned i = 0; i < glyph_count; ++i) {
uint16_t substitute = 0;
if (!subtable.ReadU16(&substitute)) {
return Error("Failed to read substitution %d in format 2 single subst table", i);
}
if (substitute >= num_glyphs) {
return Error("too large substitute: %u", substitute);
}
}
} else {
return Error("Bad single subst table format %d", format);
}
if (offset_coverage < subtable.offset() || offset_coverage >= length) {
return Error("Bad coverage offset %x", offset_coverage);
}
if (!ots::ParseCoverageTable(font, data + offset_coverage,
length - offset_coverage, num_glyphs)) {
return Error("Failed to parse coverage table");
}
return true;
}
// Lookup Type 2:
// Multiple Substitution Subtable
bool OpenTypeGSUB::ParseMutipleSubstitution(const uint8_t *data,
const size_t length) {
Font* font = GetFont();
Buffer subtable(data, length);
uint16_t format = 0;
uint16_t offset_coverage = 0;
uint16_t sequence_count = 0;
if (!subtable.ReadU16(&format) ||
!subtable.ReadU16(&offset_coverage) ||
!subtable.ReadU16(&sequence_count)) {
return Error("Can't read header of multiple subst table");
}
if (format != 1) {
return Error("Bad multiple subst table format %d", format);
}
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 unsigned sequence_end = static_cast<unsigned>(6) +
sequence_count * 2;
if (sequence_end > std::numeric_limits<uint16_t>::max()) {
return Error("Bad sequence end %d, in multiple subst", sequence_end);
}
for (unsigned i = 0; i < sequence_count; ++i) {
uint16_t offset_sequence = 0;
if (!subtable.ReadU16(&offset_sequence)) {
return Error("Failed to read sequence offset for sequence %d", i);
}
if (offset_sequence < sequence_end || offset_sequence >= length) {
return Error("Bad sequence offset %d for sequence %d", offset_sequence, i);
}
if (!ParseSequenceTable(font, data + offset_sequence, length - offset_sequence,
num_glyphs)) {
return Error("Failed to parse sequence table %d", i);
}
}
if (offset_coverage < sequence_end || offset_coverage >= length) {
return Error("Bad coverage offset %d", offset_coverage);
}
if (!ots::ParseCoverageTable(font, data + offset_coverage,
length - offset_coverage, num_glyphs)) {
return Error("Failed to parse coverage table");
}
return true;
}
// Lookup Type 3:
// Alternate Substitution Subtable
bool OpenTypeGSUB::ParseAlternateSubstitution(const uint8_t *data,
const size_t length) {
Font* font = GetFont();
Buffer subtable(data, length);
uint16_t format = 0;
uint16_t offset_coverage = 0;
uint16_t alternate_set_count = 0;
if (!subtable.ReadU16(&format) ||
!subtable.ReadU16(&offset_coverage) ||
!subtable.ReadU16(&alternate_set_count)) {
return Error("Can't read alternate subst header");
}
if (format != 1) {
return Error("Bad alternate subst table format %d", format);
}
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 unsigned alternate_set_end = static_cast<unsigned>(6) +
alternate_set_count * 2;
if (alternate_set_end > std::numeric_limits<uint16_t>::max()) {
return Error("Bad end of alternate set %d", alternate_set_end);
}
for (unsigned i = 0; i < alternate_set_count; ++i) {
uint16_t offset_alternate_set = 0;
if (!subtable.ReadU16(&offset_alternate_set)) {
return Error("Can't read alternate set offset for set %d", i);
}
if (offset_alternate_set < alternate_set_end ||
offset_alternate_set >= length) {
return Error("Bad alternate set offset %d for set %d", offset_alternate_set, i);
}
if (!ParseAlternateSetTable(font, data + offset_alternate_set,
length - offset_alternate_set,
num_glyphs)) {
return Error("Failed to parse alternate set");
}
}
if (offset_coverage < alternate_set_end || offset_coverage >= length) {
return Error("Bad coverage offset %d", offset_coverage);
}
if (!ots::ParseCoverageTable(font, data + offset_coverage,
length - offset_coverage, num_glyphs)) {
return Error("Failed to parse coverage table");
}
return true;
}
// Lookup Type 4:
// Ligature Substitution Subtable
bool ParseLigatureSubstitution(const ots::Font *font,
const uint8_t *data, const size_t length) {
ots::Buffer subtable(data, length);
bool OpenTypeGSUB::ParseLigatureSubstitution(const uint8_t *data,
const size_t length) {
Font* font = GetFont();
Buffer subtable(data, length);
uint16_t format = 0;
uint16_t offset_coverage = 0;
@ -372,45 +339,45 @@ bool ParseLigatureSubstitution(const ots::Font *font,
if (!subtable.ReadU16(&format) ||
!subtable.ReadU16(&offset_coverage) ||
!subtable.ReadU16(&lig_set_count)) {
return OTS_FAILURE_MSG("Failed to read ligature substitution header");
return Error("Failed to read ligature substitution header");
}
if (format != 1) {
return OTS_FAILURE_MSG("Bad ligature substitution table format %d", format);
return Error("Bad ligature substitution table format %d", format);
}
ots::OpenTypeMAXP *maxp = static_cast<ots::OpenTypeMAXP*>(
OpenTypeMAXP *maxp = static_cast<OpenTypeMAXP*>(
font->GetTypedTable(OTS_TAG_MAXP));
if (!maxp) {
return OTS_FAILURE_MSG("Required maxp table missing");
return Error("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()) {
return OTS_FAILURE_MSG("Bad end of ligature set %d in ligature substitution table", ligature_set_end);
return Error("Bad end of ligature set %d in ligature substitution table", ligature_set_end);
}
for (unsigned i = 0; i < lig_set_count; ++i) {
uint16_t offset_ligature_set = 0;
if (!subtable.ReadU16(&offset_ligature_set)) {
return OTS_FAILURE_MSG("Can't read ligature set offset %d", i);
return Error("Can't read ligature set offset %d", i);
}
if (offset_ligature_set < ligature_set_end ||
offset_ligature_set >= length) {
return OTS_FAILURE_MSG("Bad ligature set offset %d for set %d", offset_ligature_set, i);
return Error("Bad ligature set offset %d for set %d", offset_ligature_set, i);
}
if (!ParseLigatureSetTable(font, data + offset_ligature_set,
length - offset_ligature_set, num_glyphs)) {
return OTS_FAILURE_MSG("Failed to parse ligature set %d", i);
return Error("Failed to parse ligature set %d", i);
}
}
if (offset_coverage < ligature_set_end || offset_coverage >= length) {
return OTS_FAILURE_MSG("Bad coverage offset %d", offset_coverage);
return Error("Bad coverage offset %d", offset_coverage);
}
if (!ots::ParseCoverageTable(font, data + offset_coverage,
length - offset_coverage, num_glyphs)) {
return OTS_FAILURE_MSG("Failed to parse coverage table");
return Error("Failed to parse coverage table");
}
return true;
@ -418,247 +385,147 @@ bool ParseLigatureSubstitution(const ots::Font *font,
// Lookup Type 5:
// Contextual Substitution Subtable
bool ParseContextSubstitution(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::ParseContextSubtable(font, data, length, maxp->num_glyphs,
gsub->num_lookups);
}
// OpenTypeLayoutTable::ParseContextSubtable()
// Lookup Type 6:
// Chaining Contextual Substitution Subtable
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,
maxp->num_glyphs,
gsub->num_lookups);
}
// OpenTypeLayoutTable::ParseChainingContextSubtable
// Lookup Type 7:
// Extension Substition
bool ParseExtensionSubstitution(const ots::Font *font,
const uint8_t *data, const size_t length) {
return ots::ParseExtensionSubtable(font, data, length,
&kGsubLookupSubtableParser);
}
// OpenTypeLayoutTable::ParseExtensionSubtable
// Lookup Type 8:
// Reverse Chaining Contexual Single Substitution Subtable
bool ParseReverseChainingContextSingleSubstitution(
const ots::Font *font, const uint8_t *data, const size_t length) {
ots::Buffer subtable(data, length);
bool OpenTypeGSUB::ParseReverseChainingContextSingleSubstitution(const uint8_t *data,
const size_t length) {
Font* font = GetFont();
Buffer subtable(data, length);
uint16_t format = 0;
uint16_t offset_coverage = 0;
if (!subtable.ReadU16(&format) ||
!subtable.ReadU16(&offset_coverage)) {
return OTS_FAILURE_MSG("Failed to read reverse chaining header");
return Error("Failed to read reverse chaining header");
}
ots::OpenTypeMAXP *maxp = static_cast<ots::OpenTypeMAXP*>(
OpenTypeMAXP *maxp = static_cast<OpenTypeMAXP*>(
font->GetTypedTable(OTS_TAG_MAXP));
if (!maxp) {
return OTS_FAILURE_MSG("Required maxp table missing");
return Error("Required maxp table missing");
}
const uint16_t num_glyphs = maxp->num_glyphs;
uint16_t backtrack_glyph_count = 0;
if (!subtable.ReadU16(&backtrack_glyph_count)) {
return OTS_FAILURE_MSG("Failed to read backtrack glyph count in reverse chaining table");
return Error("Failed to read backtrack glyph count in reverse chaining table");
}
std::vector<uint16_t> offsets_backtrack;
offsets_backtrack.reserve(backtrack_glyph_count);
for (unsigned i = 0; i < backtrack_glyph_count; ++i) {
uint16_t offset = 0;
if (!subtable.ReadU16(&offset)) {
return OTS_FAILURE_MSG("Failed to read backtrack offset %d", i);
return Error("Failed to read backtrack offset %d", i);
}
offsets_backtrack.push_back(offset);
}
uint16_t lookahead_glyph_count = 0;
if (!subtable.ReadU16(&lookahead_glyph_count)) {
return OTS_FAILURE_MSG("Failed to read look ahead glyph count");
return Error("Failed to read look ahead glyph count");
}
std::vector<uint16_t> offsets_lookahead;
offsets_lookahead.reserve(lookahead_glyph_count);
for (unsigned i = 0; i < lookahead_glyph_count; ++i) {
uint16_t offset = 0;
if (!subtable.ReadU16(&offset)) {
return OTS_FAILURE_MSG("Can't read look ahead offset %d", i);
return Error("Can't read look ahead offset %d", i);
}
offsets_lookahead.push_back(offset);
}
uint16_t glyph_count = 0;
if (!subtable.ReadU16(&glyph_count)) {
return OTS_FAILURE_MSG("Can't read glyph count in reverse chaining table");
return Error("Can't read glyph count in reverse chaining table");
}
for (unsigned i = 0; i < glyph_count; ++i) {
uint16_t substitute = 0;
if (!subtable.ReadU16(&substitute)) {
return OTS_FAILURE_MSG("Failed to read substitution %d reverse chaining table", i);
return Error("Failed to read substitution %d reverse chaining table", i);
}
if (substitute >= num_glyphs) {
return OTS_FAILURE_MSG("Bad substitute glyph %d in reverse chaining table substitution %d", substitute, i);
return Error("Bad substitute glyph %d in reverse chaining table substitution %d", substitute, i);
}
}
const unsigned substitute_end = static_cast<unsigned>(10) +
(backtrack_glyph_count + lookahead_glyph_count + glyph_count) * 2;
if (substitute_end > std::numeric_limits<uint16_t>::max()) {
return OTS_FAILURE_MSG("Bad substitute end offset in reverse chaining table");
return Error("Bad substitute end offset in reverse chaining table");
}
if (offset_coverage < substitute_end || offset_coverage >= length) {
return OTS_FAILURE_MSG("Bad coverage offset %d in reverse chaining table", offset_coverage);
return Error("Bad coverage offset %d in reverse chaining table", offset_coverage);
}
if (!ots::ParseCoverageTable(font, data + offset_coverage,
length - offset_coverage, num_glyphs)) {
return OTS_FAILURE_MSG("Failed to parse coverage table in reverse chaining table");
return Error("Failed to parse coverage table in reverse chaining table");
}
for (unsigned i = 0; i < backtrack_glyph_count; ++i) {
if (offsets_backtrack[i] < substitute_end ||
offsets_backtrack[i] >= length) {
return OTS_FAILURE_MSG("Bad backtrack offset %d for backtrack %d in reverse chaining table", offsets_backtrack[i], i);
return Error("Bad backtrack offset %d for backtrack %d in reverse chaining table", offsets_backtrack[i], i);
}
if (!ots::ParseCoverageTable(font, data + offsets_backtrack[i],
length - offsets_backtrack[i], num_glyphs)) {
return OTS_FAILURE_MSG("Failed to parse coverage table for backtrack %d in reverse chaining table", i);
return Error("Failed to parse coverage table for backtrack %d in reverse chaining table", i);
}
}
for (unsigned i = 0; i < lookahead_glyph_count; ++i) {
if (offsets_lookahead[i] < substitute_end ||
offsets_lookahead[i] >= length) {
return OTS_FAILURE_MSG("Bad lookahead offset %d for lookahead %d in reverse chaining table", offsets_lookahead[i], i);
return Error("Bad lookahead offset %d for lookahead %d in reverse chaining table", offsets_lookahead[i], i);
}
if (!ots::ParseCoverageTable(font, data + offsets_lookahead[i],
length - offsets_lookahead[i], num_glyphs)) {
return OTS_FAILURE_MSG("Failed to parse lookahead coverage table %d in reverse chaining table", i);
return Error("Failed to parse lookahead coverage table %d in reverse chaining table", i);
}
}
return true;
}
} // namespace
namespace ots {
bool OpenTypeGSUB::Parse(const uint8_t *data, size_t length) {
// Parsing gsub table requires |maxp->num_glyphs|
Font *font = GetFont();
Buffer table(data, length);
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;
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 Error("Incomplete table");
}
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 < 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,
&this->num_lookups)) {
return Error("Failed to parse lookup list table");
}
}
uint16_t num_features = 0;
if (offset_feature_list) {
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, this->num_lookups,
&num_features)) {
return Error("Failed to parse feature list table");
}
}
if (offset_script_list) {
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 Error("Failed to parse script list table");
}
}
if (offset_feature_variations) {
if (offset_feature_variations < header_size || offset_feature_variations >= length) {
return Error("Bad feature variations offset in table header");
}
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;
bool OpenTypeGSUB::ValidLookupSubtableType(const uint16_t lookup_type,
bool extension) const {
if (extension && lookup_type == GSUB_TYPE_EXTENSION_SUBSTITUTION)
return false;
return lookup_type >= GSUB_TYPE_SINGLE && lookup_type < GSUB_TYPE_RESERVED;
}
bool OpenTypeGSUB::Serialize(OTSStream *out) {
if (!out->Write(this->m_data, this->m_length)) {
return Error("Failed to write GSUB table");
bool OpenTypeGSUB::ParseLookupSubtable(const uint8_t *data, const size_t length,
const uint16_t lookup_type) {
switch (lookup_type) {
case GSUB_TYPE_SINGLE:
return ParseSingleSubstitution(data, length);
case GSUB_TYPE_MULTIPLE:
return ParseMutipleSubstitution(data, length);
case GSUB_TYPE_ALTERNATE:
return ParseAlternateSubstitution(data, length);
case GSUB_TYPE_LIGATURE:
return ParseLigatureSubstitution(data, length);
case GSUB_TYPE_CONTEXT:
return ParseContextSubtable(data, length);
case GSUB_TYPE_CHANGING_CONTEXT:
return ParseChainingContextSubtable(data, length);
case GSUB_TYPE_EXTENSION_SUBSTITUTION:
return ParseExtensionSubtable(data, length);
case GSUB_TYPE_REVERSE_CHAINING_CONTEXT_SINGLE:
return ParseReverseChainingContextSingleSubstitution(data, length);
}
return true;
return false;
}
} // namespace ots

27
gfx/ots/src/gsub.h
Просмотреть файл

@ -6,27 +6,26 @@
#define OTS_GSUB_H_
#include "ots.h"
#include "layout.h"
namespace ots {
class OpenTypeGSUB : public Table {
class OpenTypeGSUB : public OpenTypeLayoutTable {
public:
explicit OpenTypeGSUB(Font *font, uint32_t tag)
: Table(font, tag, tag),
num_lookups(0),
m_data(NULL),
m_length(0) {
}
: OpenTypeLayoutTable(font, tag, tag) { }
bool Parse(const uint8_t *data, size_t length);
bool Serialize(OTSStream *out);
private:
bool ValidLookupSubtableType(uint16_t lookup_type,
bool extension = false) const;
bool ParseLookupSubtable(const uint8_t *data, const size_t length,
const uint16_t lookup_type);
// Number of lookups in GPSUB table
uint16_t num_lookups;
//private:
const uint8_t *m_data;
size_t m_length;
bool ParseSingleSubstitution(const uint8_t *data, const size_t length);
bool ParseMutipleSubstitution(const uint8_t *data, const size_t length);
bool ParseAlternateSubstitution(const uint8_t *data, const size_t length);
bool ParseLigatureSubstitution(const uint8_t *data, const size_t length);
bool ParseReverseChainingContextSingleSubstitution(const uint8_t *data, const size_t length);
};
} // namespace ots

657
gfx/ots/src/layout.cc
Просмотреть файл

@ -9,6 +9,7 @@
#include "fvar.h"
#include "gdef.h"
#include "maxp.h"
// OpenType Layout Common Table Formats
// http://www.microsoft.com/typography/otspec/chapter2.htm
@ -174,75 +175,6 @@ bool ParseFeatureTable(const ots::Font *font,
return true;
}
bool ParseLookupTable(ots::Font *font, const uint8_t *data,
const size_t length,
const ots::LookupSubtableParser* parser) {
ots::Buffer subtable(data, length);
uint16_t lookup_type = 0;
uint16_t lookup_flag = 0;
uint16_t subtable_count = 0;
if (!subtable.ReadU16(&lookup_type) ||
!subtable.ReadU16(&lookup_flag) ||
!subtable.ReadU16(&subtable_count)) {
return OTS_FAILURE_MSG("Failed to read lookup table header");
}
if (lookup_type == 0 || lookup_type > parser->num_types) {
return OTS_FAILURE_MSG("Bad lookup type %d", lookup_type);
}
bool use_mark_filtering_set = lookup_flag & kUseMarkFilteringSetBit;
std::vector<uint16_t> subtables;
subtables.reserve(subtable_count);
// If the |kUseMarkFilteringSetBit| of |lookup_flag| is set,
// extra 2 bytes will follow after subtable offset array.
const unsigned lookup_table_end = 2 * static_cast<unsigned>(subtable_count) +
(use_mark_filtering_set ? 8 : 6);
if (lookup_table_end > std::numeric_limits<uint16_t>::max()) {
return OTS_FAILURE_MSG("Bad end of lookup %d", lookup_table_end);
}
for (unsigned i = 0; i < subtable_count; ++i) {
uint16_t offset_subtable = 0;
if (!subtable.ReadU16(&offset_subtable)) {
return OTS_FAILURE_MSG("Failed to read subtable offset %d", i);
}
if (offset_subtable < lookup_table_end ||
offset_subtable >= length) {
return OTS_FAILURE_MSG("Bad subtable offset %d for subtable %d", offset_subtable, i);
}
subtables.push_back(offset_subtable);
}
if (subtables.size() != subtable_count) {
return OTS_FAILURE_MSG("Bad subtable size %ld", subtables.size());
}
if (use_mark_filtering_set) {
uint16_t mark_filtering_set = 0;
if (!subtable.ReadU16(&mark_filtering_set)) {
return OTS_FAILURE_MSG("Failed to read mark filtering set");
}
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);
}
}
// Parse lookup subtables for this lookup type.
for (unsigned i = 0; i < subtable_count; ++i) {
if (!parser->Parse(font, data + subtables[i], length - subtables[i],
lookup_type)) {
return OTS_FAILURE_MSG("Failed to parse subtable %d", i);
}
}
return true;
}
bool ParseClassDefFormat1(const ots::Font *font,
const uint8_t *data, size_t length,
const uint16_t num_glyphs,
@ -446,7 +378,7 @@ bool ParseRuleSubtable(const ots::Font *font,
return OTS_FAILURE_MSG("Failed to read rule subtable header");
}
if (glyph_count == 0 || glyph_count >= num_glyphs) {
if (glyph_count == 0) {
return OTS_FAILURE_MSG("Bad glyph count %d in rule subtable", glyph_count);
}
for (unsigned i = 0; i < glyph_count - static_cast<unsigned>(1); ++i) {
@ -725,9 +657,6 @@ bool ParseChainRuleSubtable(const ots::Font *font,
if (!subtable.ReadU16(&backtrack_count)) {
return OTS_FAILURE_MSG("Failed to read backtrack count in chain rule subtable");
}
if (backtrack_count >= num_glyphs) {
return OTS_FAILURE_MSG("Bad backtrack count %d in chain rule subtable", backtrack_count);
}
for (unsigned i = 0; i < backtrack_count; ++i) {
uint16_t glyph_id = 0;
if (!subtable.ReadU16(&glyph_id)) {
@ -742,7 +671,7 @@ bool ParseChainRuleSubtable(const ots::Font *font,
if (!subtable.ReadU16(&input_count)) {
return OTS_FAILURE_MSG("Failed to read input count in chain rule subtable");
}
if (input_count == 0 || input_count >= num_glyphs) {
if (input_count == 0) {
return OTS_FAILURE_MSG("Bad input count %d in chain rule subtable", input_count);
}
for (unsigned i = 0; i < input_count - static_cast<unsigned>(1); ++i) {
@ -759,9 +688,6 @@ bool ParseChainRuleSubtable(const ots::Font *font,
if (!subtable.ReadU16(&lookahead_count)) {
return OTS_FAILURE_MSG("Failed to read lookahead count in chain rule subtable");
}
if (lookahead_count >= num_glyphs) {
return OTS_FAILURE_MSG("Bad lookahead count %d in chain rule subtable", lookahead_count);
}
for (unsigned i = 0; i < lookahead_count; ++i) {
uint16_t glyph_id = 0;
if (!subtable.ReadU16(&glyph_id)) {
@ -878,9 +804,6 @@ bool ParseChainClassRuleSubtable(const ots::Font *font,
if (!subtable.ReadU16(&backtrack_count)) {
return OTS_FAILURE_MSG("Failed to read backtrack count in chain class rule subtable");
}
if (backtrack_count >= num_glyphs) {
return OTS_FAILURE_MSG("Bad backtrack count %d in chain class rule subtable", backtrack_count);
}
if (!subtable.Skip(2 * backtrack_count)) {
return OTS_FAILURE_MSG("Failed to skip backtrack offsets in chain class rule subtable");
}
@ -889,7 +812,7 @@ bool ParseChainClassRuleSubtable(const ots::Font *font,
if (!subtable.ReadU16(&input_count)) {
return OTS_FAILURE_MSG("Failed to read input count in chain class rule subtable");
}
if (input_count == 0 || input_count >= num_glyphs) {
if (input_count == 0) {
return OTS_FAILURE_MSG("Bad input count %d in chain class rule subtable", input_count);
}
if (!subtable.Skip(2 * (input_count - 1))) {
@ -900,9 +823,6 @@ bool ParseChainClassRuleSubtable(const ots::Font *font,
if (!subtable.ReadU16(&lookahead_count)) {
return OTS_FAILURE_MSG("Failed to read lookahead count in chain class rule subtable");
}
if (lookahead_count >= num_glyphs) {
return OTS_FAILURE_MSG("Bad lookahead count %d in chain class rule subtable", lookahead_count);
}
if (!subtable.Skip(2 * lookahead_count)) {
return OTS_FAILURE_MSG("Failed to skip lookahead offsets in chain class rule subtable");
}
@ -1058,9 +978,6 @@ bool ParseChainContextFormat3(const ots::Font *font,
return OTS_FAILURE_MSG("Failed to read backtrack count in chain context format 3");
}
if (backtrack_count >= num_glyphs) {
return OTS_FAILURE_MSG("Bad backtrack count %d in chain context format 3", backtrack_count);
}
std::vector<uint16_t> offsets_backtrack;
offsets_backtrack.reserve(backtrack_count);
for (unsigned i = 0; i < backtrack_count; ++i) {
@ -1078,9 +995,6 @@ bool ParseChainContextFormat3(const ots::Font *font,
if (!subtable.ReadU16(&input_count)) {
return OTS_FAILURE_MSG("Failed to read input count in chain context format 3");
}
if (input_count >= num_glyphs) {
return OTS_FAILURE_MSG("Bad input count %d in chain context format 3", input_count);
}
std::vector<uint16_t> offsets_input;
offsets_input.reserve(input_count);
for (unsigned i = 0; i < input_count; ++i) {
@ -1098,9 +1012,6 @@ bool ParseChainContextFormat3(const ots::Font *font,
if (!subtable.ReadU16(&lookahead_count)) {
return OTS_FAILURE_MSG("Failed ot read lookahead count in chain context format 3");
}
if (lookahead_count >= num_glyphs) {
return OTS_FAILURE_MSG("Bad lookahead count %d in chain context format 3", lookahead_count);
}
std::vector<uint16_t> offsets_lookahead;
offsets_lookahead.reserve(lookahead_count);
for (unsigned i = 0; i < lookahead_count; ++i) {
@ -1165,40 +1076,131 @@ bool ParseChainContextFormat3(const ots::Font *font,
return true;
}
bool ParseFeatureTableSubstitutionTable(const ots::Font *font,
const uint8_t *data, const size_t length,
const uint16_t num_lookups) {
ots::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 ParseConditionTable(const ots::Font *font,
const uint8_t *data, const size_t length,
const uint16_t axis_count) {
ots::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 ots::Font *font,
const uint8_t *data, const size_t length,
const uint16_t axis_count) {
ots::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;
}
} // namespace
namespace ots {
bool LookupSubtableParser::Parse(const Font *font, const uint8_t *data,
const size_t length,
const uint16_t lookup_type) const {
for (unsigned i = 0; i < num_types; ++i) {
if (parsers[i].type == lookup_type && parsers[i].parse) {
if (!parsers[i].parse(font, data, length)) {
return OTS_FAILURE_MSG("Failed to parse lookup subtable %d", i);
}
return true;
}
}
return OTS_FAILURE_MSG("No lookup subtables to parse");
}
// Parsing ScriptListTable requires number of features so we need to
// parse FeatureListTable before calling this function.
bool ParseScriptListTable(const ots::Font *font,
const uint8_t *data, const size_t length,
const uint16_t num_features) {
bool OpenTypeLayoutTable::ParseScriptListTable(const uint8_t *data, const size_t length) {
Font* font = GetFont();
Buffer subtable(data, length);
uint16_t script_count = 0;
if (!subtable.ReadU16(&script_count)) {
return OTS_FAILURE_MSG("Failed to read script count in script list table");
return Error("Failed to read script count in script list table");
}
const unsigned script_record_end =
6 * static_cast<unsigned>(script_count) + 2;
if (script_record_end > std::numeric_limits<uint16_t>::max()) {
return OTS_FAILURE_MSG("Bad end of script record %d in script list table", script_record_end);
return Error("Bad end of script record %d in script list table", script_record_end);
}
std::vector<ScriptRecord> script_list;
script_list.reserve(script_count);
@ -1207,7 +1209,7 @@ bool ParseScriptListTable(const ots::Font *font,
ScriptRecord record;
if (!subtable.ReadU32(&record.tag) ||
!subtable.ReadU16(&record.offset)) {
return OTS_FAILURE_MSG("Failed to read script record %d in script list table", i);
return Error("Failed to read script record %d in script list table", i);
}
// Script tags should be arranged alphabetically by tag
if (last_tag != 0 && last_tag > record.tag) {
@ -1218,20 +1220,20 @@ bool ParseScriptListTable(const ots::Font *font,
}
last_tag = record.tag;
if (record.offset < script_record_end || record.offset >= length) {
return OTS_FAILURE_MSG("Bad record offset %d for script %c%c%c%c entry %d in script list table", record.offset, OTS_UNTAG(record.tag), i);
return Error("Bad record offset %d for script %c%c%c%c entry %d in script list table", record.offset, OTS_UNTAG(record.tag), i);
}
script_list.push_back(record);
}
if (script_list.size() != script_count) {
return OTS_FAILURE_MSG("Bad script list size %ld in script list table", script_list.size());
return Error("Bad script list size %ld in script list table", script_list.size());
}
// Check script records.
for (unsigned i = 0; i < script_count; ++i) {
if (!ParseScriptTable(font, data + script_list[i].offset,
length - script_list[i].offset,
script_list[i].tag, num_features)) {
return OTS_FAILURE_MSG("Failed to parse script table %d", i);
script_list[i].tag, m_num_features)) {
return Error("Failed to parse script table %d", i);
}
}
@ -1240,15 +1242,13 @@ bool ParseScriptListTable(const ots::Font *font,
// Parsing FeatureListTable requires number of lookups so we need to parse
// LookupListTable before calling this function.
bool ParseFeatureListTable(const ots::Font *font,
const uint8_t *data, const size_t length,
const uint16_t num_lookups,
uint16_t* num_features) {
bool OpenTypeLayoutTable::ParseFeatureListTable(const uint8_t *data, const size_t length) {
Font *font = GetFont();
Buffer subtable(data, length);
uint16_t feature_count = 0;
if (!subtable.ReadU16(&feature_count)) {
return OTS_FAILURE_MSG("Failed to read feature count");
return Error("Failed to read feature count");
}
std::vector<FeatureRecord> feature_records;
@ -1256,13 +1256,13 @@ bool ParseFeatureListTable(const ots::Font *font,
const unsigned feature_record_end =
6 * static_cast<unsigned>(feature_count) + 2;
if (feature_record_end > std::numeric_limits<uint16_t>::max()) {
return OTS_FAILURE_MSG("Bad end of feature record %d", feature_record_end);
return Error("Bad end of feature record %d", feature_record_end);
}
uint32_t last_tag = 0;
for (unsigned i = 0; i < feature_count; ++i) {
if (!subtable.ReadU32(&feature_records[i].tag) ||
!subtable.ReadU16(&feature_records[i].offset)) {
return OTS_FAILURE_MSG("Failed to read feature header %d", i);
return Error("Failed to read feature header %d", i);
}
// Feature record array should be arranged alphabetically by tag
if (last_tag != 0 && last_tag > feature_records[i].tag) {
@ -1274,58 +1274,124 @@ bool ParseFeatureListTable(const ots::Font *font,
last_tag = feature_records[i].tag;
if (feature_records[i].offset < feature_record_end ||
feature_records[i].offset >= length) {
return OTS_FAILURE_MSG("Bad feature offset %d for feature %d %c%c%c%c", feature_records[i].offset, i, OTS_UNTAG(feature_records[i].tag));
return Error("Bad feature offset %d for feature %d %c%c%c%c", feature_records[i].offset, i, OTS_UNTAG(feature_records[i].tag));
}
}
for (unsigned i = 0; i < feature_count; ++i) {
if (!ParseFeatureTable(font, data + feature_records[i].offset,
length - feature_records[i].offset, num_lookups)) {
return OTS_FAILURE_MSG("Failed to parse feature table %d", i);
length - feature_records[i].offset, m_num_lookups)) {
return Error("Failed to parse feature table %d", i);
}
}
m_num_features = feature_count;
return true;
}
bool OpenTypeLayoutTable::ParseLookupTable(const uint8_t *data,
const size_t length) {
Font* font = GetFont();
Buffer subtable(data, length);
uint16_t lookup_type = 0;
uint16_t lookup_flag = 0;
uint16_t subtable_count = 0;
if (!subtable.ReadU16(&lookup_type) ||
!subtable.ReadU16(&lookup_flag) ||
!subtable.ReadU16(&subtable_count)) {
return Error("Failed to read lookup table header");
}
if (!ValidLookupSubtableType(lookup_type)) {
return Error("Bad lookup type %d", lookup_type);
}
bool use_mark_filtering_set = lookup_flag & kUseMarkFilteringSetBit;
std::vector<uint16_t> subtables;
subtables.reserve(subtable_count);
// If the |kUseMarkFilteringSetBit| of |lookup_flag| is set,
// extra 2 bytes will follow after subtable offset array.
const unsigned lookup_table_end = 2 * static_cast<unsigned>(subtable_count) +
(use_mark_filtering_set ? 8 : 6);
if (lookup_table_end > std::numeric_limits<uint16_t>::max()) {
return Error("Bad end of lookup %d", lookup_table_end);
}
for (unsigned i = 0; i < subtable_count; ++i) {
uint16_t offset_subtable = 0;
if (!subtable.ReadU16(&offset_subtable)) {
return Error("Failed to read subtable offset %d", i);
}
if (offset_subtable < lookup_table_end ||
offset_subtable >= length) {
return Error("Bad subtable offset %d for subtable %d", offset_subtable, i);
}
subtables.push_back(offset_subtable);
}
if (subtables.size() != subtable_count) {
return Error("Bad subtable size %ld", subtables.size());
}
if (use_mark_filtering_set) {
uint16_t mark_filtering_set = 0;
if (!subtable.ReadU16(&mark_filtering_set)) {
return Error("Failed to read mark filtering set");
}
OpenTypeGDEF *gdef = static_cast<OpenTypeGDEF*>(
font->GetTypedTable(OTS_TAG_GDEF));
if (gdef && (gdef->num_mark_glyph_sets == 0 ||
mark_filtering_set >= gdef->num_mark_glyph_sets)) {
return Error("Bad mark filtering set %d", mark_filtering_set);
}
}
// Parse lookup subtables for this lookup type.
for (unsigned i = 0; i < subtable_count; ++i) {
if (!ParseLookupSubtable(data + subtables[i], length - subtables[i],
lookup_type)) {
return Error("Failed to parse subtable %d", i);
}
}
*num_features = feature_count;
return true;
}
// For parsing GPOS/GSUB tables, this function should be called at first to
// obtain the number of lookups because parsing FeatureTableList requires
// the number.
bool ParseLookupListTable(Font *font, const uint8_t *data,
const size_t length,
const LookupSubtableParser* parser,
uint16_t *num_lookups) {
bool OpenTypeLayoutTable::ParseLookupListTable(const uint8_t *data,
const size_t length) {
Buffer subtable(data, length);
if (!subtable.ReadU16(num_lookups)) {
return OTS_FAILURE_MSG("Failed to read number of lookups");
if (!subtable.ReadU16(&m_num_lookups)) {
return Error("Failed to read number of lookups");
}
std::vector<uint16_t> lookups;
lookups.reserve(*num_lookups);
lookups.reserve(m_num_lookups);
const unsigned lookup_end =
2 * static_cast<unsigned>(*num_lookups) + 2;
2 * static_cast<unsigned>(m_num_lookups) + 2;
if (lookup_end > std::numeric_limits<uint16_t>::max()) {
return OTS_FAILURE_MSG("Bad end of lookups %d", lookup_end);
return Error("Bad end of lookups %d", lookup_end);
}
for (unsigned i = 0; i < *num_lookups; ++i) {
for (unsigned i = 0; i < m_num_lookups; ++i) {
uint16_t offset = 0;
if (!subtable.ReadU16(&offset)) {
return OTS_FAILURE_MSG("Failed to read lookup offset %d", i);
return Error("Failed to read lookup offset %d", i);
}
if (offset < lookup_end || offset >= length) {
return OTS_FAILURE_MSG("Bad lookup offset %d for lookup %d", offset, i);
return Error("Bad lookup offset %d for lookup %d", offset, i);
}
lookups.push_back(offset);
}
if (lookups.size() != *num_lookups) {
return OTS_FAILURE_MSG("Bad lookup offsets list size %ld", lookups.size());
if (lookups.size() != m_num_lookups) {
return Error("Bad lookup offsets list size %ld", lookups.size());
}
for (unsigned i = 0; i < *num_lookups; ++i) {
if (!ParseLookupTable(font, data + lookups[i], length - lookups[i],
parser)) {
return OTS_FAILURE_MSG("Failed to parse lookup %d", i);
for (unsigned i = 0; i < m_num_lookups; ++i) {
if (!ParseLookupTable(data + lookups[i], length - lookups[i])) {
return Error("Failed to parse lookup %d", i);
}
}
@ -1406,69 +1472,78 @@ bool ParseDeviceTable(const ots::Font *font,
return true;
}
bool ParseContextSubtable(const ots::Font *font,
const uint8_t *data, const size_t length,
const uint16_t num_glyphs,
const uint16_t num_lookups) {
bool OpenTypeLayoutTable::ParseContextSubtable(const uint8_t *data,
const size_t length) {
Font *font = GetFont();
Buffer subtable(data, length);
uint16_t format = 0;
if (!subtable.ReadU16(&format)) {
return OTS_FAILURE_MSG("Failed to read context subtable format");
return Error("Failed to read context subtable format");
}
OpenTypeMAXP *maxp = static_cast<OpenTypeMAXP*>(
font->GetTypedTable(OTS_TAG_MAXP));
if (!maxp) {
return Error("Required maxp table missing");
}
if (format == 1) {
if (!ParseContextFormat1(font, data, length, num_glyphs, num_lookups)) {
return OTS_FAILURE_MSG("Failed to parse context format 1 subtable");
if (!ParseContextFormat1(font, data, length, maxp->num_glyphs, m_num_lookups)) {
return Error("Failed to parse context format 1 subtable");
}
} else if (format == 2) {
if (!ParseContextFormat2(font, data, length, num_glyphs, num_lookups)) {
return OTS_FAILURE_MSG("Failed to parse context format 2 subtable");
if (!ParseContextFormat2(font, data, length, maxp->num_glyphs, m_num_lookups)) {
return Error("Failed to parse context format 2 subtable");
}
} else if (format == 3) {
if (!ParseContextFormat3(font, data, length, num_glyphs, num_lookups)) {
return OTS_FAILURE_MSG("Failed to parse context format 3 subtable");
if (!ParseContextFormat3(font, data, length, maxp->num_glyphs, m_num_lookups)) {
return Error("Failed to parse context format 3 subtable");
}
} else {
return OTS_FAILURE_MSG("Bad context subtable format %d", format);
return Error("Bad context subtable format %d", format);
}
return true;
}
bool ParseChainingContextSubtable(const ots::Font *font,
const uint8_t *data, const size_t length,
const uint16_t num_glyphs,
const uint16_t num_lookups) {
bool OpenTypeLayoutTable::ParseChainingContextSubtable(const uint8_t *data,
const size_t length) {
Font *font = GetFont();
Buffer subtable(data, length);
uint16_t format = 0;
if (!subtable.ReadU16(&format)) {
return OTS_FAILURE_MSG("Failed to read chaining context subtable format");
return Error("Failed to read chaining context subtable format");
}
OpenTypeMAXP *maxp = static_cast<OpenTypeMAXP*>(
font->GetTypedTable(OTS_TAG_MAXP));
if (!maxp) {
return Error("Required maxp table missing");
}
if (format == 1) {
if (!ParseChainContextFormat1(font, data, length, num_glyphs, num_lookups)) {
return OTS_FAILURE_MSG("Failed to parse chaining context format 1 subtable");
if (!ParseChainContextFormat1(font, data, length, maxp->num_glyphs, m_num_lookups)) {
return Error("Failed to parse chaining context format 1 subtable");
}
} else if (format == 2) {
if (!ParseChainContextFormat2(font, data, length, num_glyphs, num_lookups)) {
return OTS_FAILURE_MSG("Failed to parse chaining context format 2 subtable");
if (!ParseChainContextFormat2(font, data, length, maxp->num_glyphs, m_num_lookups)) {
return Error("Failed to parse chaining context format 2 subtable");
}
} else if (format == 3) {
if (!ParseChainContextFormat3(font, data, length, num_glyphs, num_lookups)) {
return OTS_FAILURE_MSG("Failed to parse chaining context format 3 subtable");
if (!ParseChainContextFormat3(font, data, length, maxp->num_glyphs, m_num_lookups)) {
return Error("Failed to parse chaining context format 3 subtable");
}
} else {
return OTS_FAILURE_MSG("Bad chaining context subtable format %d", format);
return Error("Bad chaining context subtable format %d", format);
}
return true;
}
bool ParseExtensionSubtable(const Font *font,
const uint8_t *data, const size_t length,
const LookupSubtableParser* parser) {
bool OpenTypeLayoutTable::ParseExtensionSubtable(const uint8_t *data,
const size_t length) {
Buffer subtable(data, length);
uint16_t format = 0;
@ -1477,142 +1552,35 @@ bool ParseExtensionSubtable(const Font *font,
if (!subtable.ReadU16(&format) ||
!subtable.ReadU16(&lookup_type) ||
!subtable.ReadU32(&offset_extension)) {
return OTS_FAILURE_MSG("Failed to read extension table header");
return Error("Failed to read extension table header");
}
if (format != 1) {
return OTS_FAILURE_MSG("Bad extension table format %d", format);
return Error("Bad extension table format %d", format);
}
// |lookup_type| should be other than |parser->extension_type|.
if (lookup_type < 1 || lookup_type > parser->num_types ||
lookup_type == parser->extension_type) {
return OTS_FAILURE_MSG("Bad lookup type %d in extension table", lookup_type);
if (!ValidLookupSubtableType(lookup_type, true)) {
return Error("Bad lookup type %d in extension table", lookup_type);
}
const unsigned format_end = static_cast<unsigned>(8);
if (offset_extension < format_end ||
offset_extension >= length) {
return OTS_FAILURE_MSG("Bad extension offset %d", offset_extension);
return Error("Bad extension offset %d", offset_extension);
}
// Parse the extension subtable of |lookup_type|.
if (!parser->Parse(font, data + offset_extension, length - offset_extension,
lookup_type)) {
return OTS_FAILURE_MSG("Failed to parse lookup from extension lookup");
if (!ParseLookupSubtable(data + offset_extension, length - offset_extension,
lookup_type)) {
return Error("Failed to parse lookup from extension lookup");
}
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) {
// Parsing feature variations table (in GSUB/GPOS v1.1)
bool OpenTypeLayoutTable::ParseFeatureVariationsTable(const uint8_t *data, const size_t length) {
Font *font = GetFont();
Buffer subtable(data, length);
uint16_t version_major = 0;
@ -1622,12 +1590,12 @@ bool ParseFeatureVariationsTable(const Font *font,
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");
return Error("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");
return Error("Not a variation font");
}
const uint16_t axis_count = fvar->AxisCount();
@ -1640,30 +1608,30 @@ bool ParseFeatureVariationsTable(const Font *font,
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");
return Error("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");
return Error("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");
return Error("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");
return Error("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");
m_num_lookups)) {
return Error("Failed to parse feature table substitution table");
}
}
}
@ -1671,6 +1639,97 @@ bool ParseFeatureVariationsTable(const Font *font,
return true;
}
// GSUB/GPOS header size for table version 1.0
const size_t kHeaderSize_1_0 = 4 + 3 * 2;
// GSUB/GPOS header size for table versio 1.1
const size_t kHeaderSize_1_1 = 4 + 3 * 2 + 4;
bool OpenTypeLayoutTable::Parse(const uint8_t *data, size_t length) {
Buffer table(data, length);
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;
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 Error("Incomplete table");
}
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) ? kHeaderSize_1_0 : kHeaderSize_1_1;
if (offset_lookup_list) {
if (offset_lookup_list < header_size || offset_lookup_list >= length) {
return Error("Bad lookup list offset in table header");
}
if (!ParseLookupListTable(data + offset_lookup_list,
length - offset_lookup_list)) {
return Error("Failed to parse lookup list table");
}
}
if (offset_feature_list) {
if (offset_feature_list < header_size || offset_feature_list >= length) {
return Error("Bad feature list offset in table header");
}
if (!ParseFeatureListTable(data + offset_feature_list,
length - offset_feature_list)) {
return Error("Failed to parse feature list table");
}
}
if (offset_script_list) {
if (offset_script_list < header_size || offset_script_list >= length) {
return Error("Bad script list offset in table header");
}
if (!ParseScriptListTable(data + offset_script_list,
length - offset_script_list)) {
return Error("Failed to parse script list table");
}
}
if (offset_feature_variations) {
if (offset_feature_variations < header_size || offset_feature_variations >= length) {
return Error("Bad feature variations offset in table header");
}
if (!ParseFeatureVariationsTable(data + offset_feature_variations,
length - offset_feature_variations)) {
return Error("Failed to parse feature variations table");
}
}
this->m_data = data;
this->m_length = length;
return true;
}
bool OpenTypeLayoutTable::Serialize(OTSStream *out) {
if (!out->Write(this->m_data, this->m_length)) {
return Error("Failed to write table");
}
return true;
}
} // namespace ots
#undef TABLE_NAME

86
gfx/ots/src/layout.h
Просмотреть файл

@ -15,34 +15,37 @@ namespace ots {
// The maximum number of class value.
const uint16_t kMaxClassDefValue = 0xFFFF;
struct LookupSubtableParser {
struct TypeParser {
uint16_t type;
bool (*parse)(const Font *font, const uint8_t *data,
const size_t length);
};
size_t num_types;
uint16_t extension_type;
const TypeParser *parsers;
class OpenTypeLayoutTable : public Table {
public:
explicit OpenTypeLayoutTable(Font *font, uint32_t tag, uint32_t type)
: Table(font, tag, type) { }
bool Parse(const Font *font, const uint8_t *data,
const size_t length, const uint16_t lookup_type) const;
bool Parse(const uint8_t *data, size_t length);
bool Serialize(OTSStream *out);
protected:
bool ParseContextSubtable(const uint8_t *data, const size_t length);
bool ParseChainingContextSubtable(const uint8_t *data, const size_t length);
bool ParseExtensionSubtable(const uint8_t *data, const size_t length);
private:
bool ParseScriptListTable(const uint8_t *data, const size_t length);
bool ParseFeatureListTable(const uint8_t *data, const size_t length);
bool ParseLookupListTable(const uint8_t *data, const size_t length);
bool ParseFeatureVariationsTable(const uint8_t *data, const size_t length);
bool ParseLookupTable(const uint8_t *data, const size_t length);
virtual bool ValidLookupSubtableType(const uint16_t lookup_type,
bool extension = false) const = 0;
virtual bool ParseLookupSubtable(const uint8_t *data, const size_t length,
const uint16_t lookup_type) = 0;
const uint8_t *m_data = nullptr;
size_t m_length = 0;
uint16_t m_num_features = 0;
uint16_t m_num_lookups = 0;
};
bool ParseScriptListTable(const ots::Font *font,
const uint8_t *data, const size_t length,
const uint16_t num_features);
bool ParseFeatureListTable(const ots::Font *font,
const uint8_t *data, const size_t length,
const uint16_t num_lookups,
uint16_t *num_features);
bool ParseLookupListTable(Font *font, const uint8_t *data,
const size_t length,
const LookupSubtableParser* parser,
uint16_t* num_lookups);
bool ParseClassDefTable(const ots::Font *font,
const uint8_t *data, size_t length,
const uint16_t num_glyphs,
@ -56,39 +59,6 @@ bool ParseCoverageTable(const ots::Font *font,
bool ParseDeviceTable(const ots::Font *font,
const uint8_t *data, size_t length);
// Parser for 'Contextual' subtable shared by GSUB/GPOS tables.
bool ParseContextSubtable(const ots::Font *font,
const uint8_t *data, const size_t length,
const uint16_t num_glyphs,
const uint16_t num_lookups);
// Parser for 'Chaining Contextual' subtable shared by GSUB/GPOS tables.
bool ParseChainingContextSubtable(const ots::Font *font,
const uint8_t *data, const size_t length,
const uint16_t num_glyphs,
const uint16_t num_lookups);
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_

75
gfx/ots/src/ots.cc
Просмотреть файл

@ -707,10 +707,19 @@ bool ProcessGeneric(ots::FontFile *header,
// If there was an fvar table but no gvar, synthesize an empty gvar to avoid
// issues with rasterizers (e.g. Core Text) that assume it must be present.
if (font->GetTable(OTS_TAG_FVAR) && !font->GetTable(OTS_TAG_GVAR)) {
ots::OpenTypeGVAR *gvar = new ots::OpenTypeGVAR(font, OTS_TAG_GVAR);
if (gvar->InitEmpty()) {
table_map[OTS_TAG_GVAR] = { OTS_TAG_GVAR, 0, 0, 0, 0 };
font->AddTable(gvar);
ots::TableEntry table_entry{ OTS_TAG_GVAR, 0, 0, 0, 0 };
const auto &it = font->file->tables.find(table_entry);
if (it != font->file->tables.end()) {
table_map[OTS_TAG_GVAR] = table_entry;
font->AddTable(table_entry, it->second);
} else {
ots::OpenTypeGVAR *gvar = new ots::OpenTypeGVAR(font, OTS_TAG_GVAR);
if (gvar->InitEmpty()) {
table_map[OTS_TAG_GVAR] = table_entry;
font->AddTable(table_entry, gvar);
} else {
delete gvar;
}
}
}
#endif
@ -867,6 +876,32 @@ bool ProcessGeneric(ots::FontFile *header,
return true;
}
bool IsGraphiteTag(uint32_t tag) {
if (tag == OTS_TAG_FEAT ||
tag == OTS_TAG_GLAT ||
tag == OTS_TAG_GLOC ||
tag == OTS_TAG_SILE ||
tag == OTS_TAG_SILF ||
tag == OTS_TAG_SILL) {
return true;
}
return false;
}
bool IsVariationsTag(uint32_t tag) {
if (tag == OTS_TAG_AVAR ||
tag == OTS_TAG_CVAR ||
tag == OTS_TAG_FVAR ||
tag == OTS_TAG_GVAR ||
tag == OTS_TAG_HVAR ||
tag == OTS_TAG_MVAR ||
tag == OTS_TAG_STAT ||
tag == OTS_TAG_VVAR) {
return true;
}
return false;
}
} // namespace
namespace ots {
@ -955,14 +990,9 @@ bool Font::ParseTable(const TableEntry& table_entry, const uint8_t* data,
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);
AddTable(table_entry, table);
}
}
@ -986,22 +1016,18 @@ Table* Font::GetTypedTable(uint32_t tag) const {
return NULL;
}
void Font::AddTable(Table* table) {
void Font::AddTable(TableEntry entry, Table* table) {
// Attempting to add a duplicate table would be an error; this should only
// be used to add a table that does not already exist.
assert(m_tables.find(table->Tag()) == m_tables.end());
m_tables[table->Tag()] = table;
file->tables[entry] = table;
}
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) {
if (IsGraphiteTag(entry.first)) {
entry.second->Drop("Discarding Graphite table");
}
}
@ -1010,14 +1036,7 @@ void Font::DropGraphite() {
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) {
if (IsVariationsTag(entry.first)) {
entry.second->Drop("Discarding Variations table");
}
}
@ -1070,6 +1089,9 @@ bool Table::DropGraphite(const char *format, ...) {
va_end(va);
m_font->DropGraphite();
if (IsGraphiteTag(m_tag))
Drop("Discarding Graphite table");
return true;
}
@ -1080,6 +1102,9 @@ bool Table::DropVariations(const char *format, ...) {
va_end(va);
m_font->DropVariations();
if (IsVariationsTag(m_tag))
Drop("Discarding Variations table");
return true;
}

2
gfx/ots/src/ots.h
Просмотреть файл

@ -319,7 +319,7 @@ struct Font {
Table* GetTypedTable(uint32_t tag) const;
// Insert a new table. Asserts if a table with the same tag already exists.
void AddTable(Table* table);
void AddTable(TableEntry entry, Table* table);
// Drop all Graphite tables and don't parse new ones.
void DropGraphite();

770
gfx/ots/tests/layout_common_table_test.cc
Просмотреть файл

@ -1,770 +0,0 @@
// 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() override { return size_; }
bool WriteRaw(const void *d, size_t length) override {
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));
}
}

13
gfx/tests/gtest/moz.build
Просмотреть файл

@ -49,17 +49,8 @@ UNIFIED_SOURCES += [
]
]
# not UNIFIED_SOURCES because layout_common_table_test.cc has classes
# in an anonymous namespace which result in a GCC error when used in
# tests (e g. "error: 'ScriptListTableTest_TestSuccess_Test' has a field
# 'ScriptListTableTest_TestSuccess_Test::<anonymous>' whose type uses
# the anonymous namespace").
SOURCES += [
"/gfx/ots/tests/%s" % p
for p in [
"cff_charstring_test.cc",
"layout_common_table_test.cc",
]
UNIFIED_SOURCES += [
"/gfx/ots/tests/cff_charstring_test.cc",
]
# ICC profiles used for verifying QCMS transformations. The copyright