walkero
/
harfbuzz
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

[cbdt] minor, tweak spaces

This commit is contained in:
Ebrahim Byagowi 2020-02-05 17:15:50 +03:30
parent eaa2402a79
commit 71a2018600
1 changed files with 215 additions and 224 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

439
src/hb-ot-color-cbdt-table.hh
View File

@ -48,16 +48,16 @@ struct cblc_bitmap_size_subset_context_t
const char *cbdt; const char *cbdt;
unsigned int cbdt_length; unsigned int cbdt_length;
hb_vector_t<char> *cbdt_prime; hb_vector_t<char> *cbdt_prime;
unsigned int size; /* INOUT unsigned int size; /* INOUT
* Input: old size of IndexSubtable * Input: old size of IndexSubtable
* Output: new size of IndexSubtable * Output: new size of IndexSubtable
*/ */
unsigned int num_tables; /* INOUT unsigned int num_tables; /* INOUT
* Input: old number of subtables. * Input: old number of subtables.
* Output: new number of subtables. * Output: new number of subtables.
*/ */
hb_codepoint_t start_glyph; /* OUT */ hb_codepoint_t start_glyph; /* OUT */
hb_codepoint_t end_glyph; /* OUT */ hb_codepoint_t end_glyph; /* OUT */
}; };
static inline bool static inline bool
@ -94,7 +94,7 @@ struct SmallGlyphMetrics
HBINT8 bearingY; HBINT8 bearingY;
HBUINT8 advance; HBUINT8 advance;
public: public:
DEFINE_SIZE_STATIC(5); DEFINE_SIZE_STATIC (5);
}; };
struct BigGlyphMetrics : SmallGlyphMetrics struct BigGlyphMetrics : SmallGlyphMetrics
@ -103,7 +103,7 @@ struct BigGlyphMetrics : SmallGlyphMetrics
HBINT8 vertBearingY; HBINT8 vertBearingY;
HBUINT8 vertAdvance; HBUINT8 vertAdvance;
public: public:
DEFINE_SIZE_STATIC(8); DEFINE_SIZE_STATIC (8);
}; };
struct SBitLineMetrics struct SBitLineMetrics
@ -127,7 +127,7 @@ struct SBitLineMetrics
HBINT8 padding1; HBINT8 padding1;
HBINT8 padding2; HBINT8 padding2;
public: public:
DEFINE_SIZE_STATIC(12); DEFINE_SIZE_STATIC (12);
}; };
@ -147,7 +147,7 @@ struct IndexSubtableHeader
HBUINT16 imageFormat; HBUINT16 imageFormat;
HBUINT32 imageDataOffset; HBUINT32 imageDataOffset;
public: public:
DEFINE_SIZE_STATIC(8); DEFINE_SIZE_STATIC (8);
}; };
template <typename OffsetType> template <typename OffsetType>
@ -173,14 +173,14 @@ struct IndexSubtableFormat1Or3
} }
bool add_offset (hb_serialize_context_t *c, bool add_offset (hb_serialize_context_t *c,
unsigned int offset, unsigned int offset,
unsigned int *size /* OUT (accumulated) */) unsigned int *size /* OUT (accumulated) */)
{ {
TRACE_SERIALIZE (this); TRACE_SERIALIZE (this);
Offset<OffsetType> embedded_offset; Offset<OffsetType> embedded_offset;
embedded_offset = offset; embedded_offset = offset;
*size += sizeof(OffsetType); *size += sizeof (OffsetType);
auto* o = c->embed (embedded_offset); auto *o = c->embed (embedded_offset);
return_trace ((bool) o); return_trace ((bool) o);
} }
@ -188,7 +188,7 @@ struct IndexSubtableFormat1Or3
UnsizedArrayOf<Offset<OffsetType>> UnsizedArrayOf<Offset<OffsetType>>
offsetArrayZ; offsetArrayZ;
public: public:
DEFINE_SIZE_ARRAY(8, offsetArrayZ); DEFINE_SIZE_ARRAY (8, offsetArrayZ);
}; };
struct IndexSubtableFormat1 : IndexSubtableFormat1Or3<HBUINT32> {}; struct IndexSubtableFormat1 : IndexSubtableFormat1Or3<HBUINT32> {};
@ -200,29 +200,32 @@ struct IndexSubtable
{ {
TRACE_SANITIZE (this); TRACE_SANITIZE (this);
if (!u.header.sanitize (c)) return_trace (false); if (!u.header.sanitize (c)) return_trace (false);
switch (u.header.indexFormat) { switch (u.header.indexFormat)
{
case 1: return_trace (u.format1.sanitize (c, glyph_count)); case 1: return_trace (u.format1.sanitize (c, glyph_count));
case 3: return_trace (u.format3.sanitize (c, glyph_count)); case 3: return_trace (u.format3.sanitize (c, glyph_count));
default:return_trace (true); default:return_trace (true);
} }
} }
bool finish_subtable (hb_serialize_context_t *c, bool
unsigned int cbdt_prime_len, finish_subtable (hb_serialize_context_t *c,
unsigned int num_glyphs, unsigned int cbdt_prime_len,
unsigned int *size /* OUT (accumulated) */) unsigned int num_glyphs,
unsigned int *size /* OUT (accumulated) */)
{ {
TRACE_SERIALIZE (this); TRACE_SERIALIZE (this);
unsigned int local_offset = cbdt_prime_len - u.header.imageDataOffset; unsigned int local_offset = cbdt_prime_len - u.header.imageDataOffset;
switch (u.header.indexFormat) { switch (u.header.indexFormat)
{
case 1: return_trace (u.format1.add_offset (c, local_offset, size)); case 1: return_trace (u.format1.add_offset (c, local_offset, size));
case 3: { case 3: {
if (!u.format3.add_offset (c, local_offset, size)) if (!u.format3.add_offset (c, local_offset, size))
return_trace (false); return_trace (false);
if (!(num_glyphs & 0x01)) // Pad to 32-bit alignment if needed. if (!(num_glyphs & 0x01)) // Pad to 32-bit alignment if needed.
return_trace (u.format3.add_offset (c, 0, size)); return_trace (u.format3.add_offset (c, 0, size));
return_trace(true); return_trace (true);
} }
// TODO: implement 2, 4, 5. // TODO: implement 2, 4, 5.
case 2: case 4: // No-op. case 2: case 4: // No-op.
@ -231,31 +234,33 @@ struct IndexSubtable
} }
} }
bool fill_missing_glyphs (hb_serialize_context_t *c, bool
unsigned int cbdt_prime_len, fill_missing_glyphs (hb_serialize_context_t *c,
unsigned int num_missing, unsigned int cbdt_prime_len,
unsigned int *size /* OUT (accumulated) */, unsigned int num_missing,
unsigned int *num_glyphs /* OUT (accumulated) */) unsigned int *size /* OUT (accumulated) */,
unsigned int *num_glyphs /* OUT (accumulated) */)
{ {
TRACE_SERIALIZE (this); TRACE_SERIALIZE (this);
unsigned int local_offset = cbdt_prime_len - u.header.imageDataOffset; unsigned int local_offset = cbdt_prime_len - u.header.imageDataOffset;
switch (u.header.indexFormat) { switch (u.header.indexFormat)
{
case 1: { case 1: {
for (unsigned int i = 0; i < num_missing; i++) for (unsigned int i = 0; i < num_missing; i++)
{ {
if (unlikely (!u.format1.add_offset (c, local_offset, size))) if (unlikely (!u.format1.add_offset (c, local_offset, size)))
return_trace (false); return_trace (false);
*num_glyphs += 1; *num_glyphs += 1;
} }
return_trace (true); return_trace (true);
} }
case 3: { case 3: {
for (unsigned int i = 0; i < num_missing; i++) for (unsigned int i = 0; i < num_missing; i++)
{ {
if (unlikely (!u.format3.add_offset (c, local_offset, size))) if (unlikely (!u.format3.add_offset (c, local_offset, size)))
return_trace (false); return_trace (false);
*num_glyphs += 1; *num_glyphs += 1;
} }
return_trace (true); return_trace (true);
} }
@ -266,13 +271,12 @@ struct IndexSubtable
} }
} }
bool copy_glyph_at_idx (hb_serialize_context_t *c, bool
unsigned int idx, copy_glyph_at_idx (hb_serialize_context_t *c, unsigned int idx,
const char *cbdt, const char *cbdt, unsigned int cbdt_length,
unsigned int cbdt_length, hb_vector_t<char> *cbdt_prime /* INOUT */,
hb_vector_t<char> *cbdt_prime /* INOUT */, IndexSubtable *subtable_prime /* INOUT */,
IndexSubtable *subtable_prime /* INOUT */, unsigned int *size /* OUT (accumulated) */) const
unsigned int *size /* OUT (accumulated) */) const
{ {
TRACE_SERIALIZE (this); TRACE_SERIALIZE (this);
@ -280,19 +284,20 @@ struct IndexSubtable
if (unlikely (!get_image_data (idx, &offset, &length, &format))) return_trace (false); if (unlikely (!get_image_data (idx, &offset, &length, &format))) return_trace (false);
if (unlikely (offset > cbdt_length || cbdt_length - offset < length)) return_trace (false); if (unlikely (offset > cbdt_length || cbdt_length - offset < length)) return_trace (false);
auto* header_prime = subtable_prime->get_header(); auto *header_prime = subtable_prime->get_header ();
unsigned int new_local_offset = cbdt_prime->length - (unsigned int) header_prime->imageDataOffset; unsigned int new_local_offset = cbdt_prime->length - (unsigned int) header_prime->imageDataOffset;
if (unlikely (!_copy_data_to_cbdt (cbdt_prime, cbdt + offset, length))) return_trace (false); if (unlikely (!_copy_data_to_cbdt (cbdt_prime, cbdt + offset, length))) return_trace (false);
return_trace (subtable_prime->add_offset (c, new_local_offset, size)); return_trace (subtable_prime->add_offset (c, new_local_offset, size));
} }
bool add_offset (hb_serialize_context_t *c, bool
unsigned int local_offset, add_offset (hb_serialize_context_t *c, unsigned int local_offset,
unsigned int *size /* OUT (accumulated) */) unsigned int *size /* OUT (accumulated) */)
{ {
TRACE_SERIALIZE (this); TRACE_SERIALIZE (this);
switch (u.header.indexFormat) { switch (u.header.indexFormat)
{
case 1: return_trace (u.format1.add_offset (c, local_offset, size)); case 1: return_trace (u.format1.add_offset (c, local_offset, size));
case 3: return_trace (u.format3.add_offset (c, local_offset, size)); case 3: return_trace (u.format3.add_offset (c, local_offset, size));
// TODO: Implement tables 2, 4, 5 // TODO: Implement tables 2, 4, 5
@ -304,40 +309,39 @@ struct IndexSubtable
bool get_extents (hb_glyph_extents_t *extents HB_UNUSED) const bool get_extents (hb_glyph_extents_t *extents HB_UNUSED) const
{ {
switch (u.header.indexFormat) { switch (u.header.indexFormat)
{
case 2: case 5: /* TODO */ case 2: case 5: /* TODO */
case 1: case 3: case 4: /* Variable-metrics formats do not have metrics here. */ case 1: case 3: case 4: /* Variable-metrics formats do not have metrics here. */
default:return (false); default:return (false);
} }
} }
bool get_image_data (unsigned int idx, bool
unsigned int *offset, get_image_data (unsigned int idx, unsigned int *offset,
unsigned int *length, unsigned int *length, unsigned int *format) const
unsigned int *format) const
{ {
*format = u.header.imageFormat; *format = u.header.imageFormat;
switch (u.header.indexFormat) { switch (u.header.indexFormat)
{
case 1: return u.format1.get_image_data (idx, offset, length); case 1: return u.format1.get_image_data (idx, offset, length);
case 3: return u.format3.get_image_data (idx, offset, length); case 3: return u.format3.get_image_data (idx, offset, length);
default: return false; default: return false;
} }
} }
const IndexSubtableHeader* get_header() const const IndexSubtableHeader* get_header () const { return &u.header; }
{
return &u.header;
}
void populate_header (unsigned index_format, void populate_header (unsigned index_format,
unsigned image_format, unsigned image_format,
unsigned int image_data_offset, unsigned int image_data_offset,
unsigned int *size) unsigned int *size)
{ {
u.header.indexFormat = index_format; u.header.indexFormat = index_format;
u.header.imageFormat = image_format; u.header.imageFormat = image_format;
u.header.imageDataOffset = image_data_offset; u.header.imageDataOffset = image_data_offset;
switch (u.header.indexFormat) { switch (u.header.indexFormat)
{
case 1: *size += IndexSubtableFormat1::min_size; break; case 1: *size += IndexSubtableFormat1::min_size; break;
case 3: *size += IndexSubtableFormat3::min_size; break; case 3: *size += IndexSubtableFormat3::min_size; break;
} }
@ -370,25 +374,25 @@ struct IndexSubtableRecord
} }
bool add_new_subtable (hb_subset_context_t* c, bool add_new_subtable (hb_subset_context_t* c,
cblc_bitmap_size_subset_context_t *bitmap_size_context, cblc_bitmap_size_subset_context_t *bitmap_size_context,
IndexSubtableRecord *record, IndexSubtableRecord *record,
const hb_vector_t<hb_pair_t<hb_codepoint_t, const IndexSubtableRecord*>> *lookup, /* IN */ const hb_vector_t<hb_pair_t<hb_codepoint_t, const IndexSubtableRecord*>> *lookup, /* IN */
const void *base, const void *base,
unsigned int *start /* INOUT */) const unsigned int *start /* INOUT */) const
{ {
TRACE_SERIALIZE (this); TRACE_SERIALIZE (this);
auto* subtable = c->serializer->start_embed<IndexSubtable> (); auto *subtable = c->serializer->start_embed<IndexSubtable> ();
if (unlikely (!subtable)) return_trace (false); if (unlikely (!subtable)) return_trace (false);
if (unlikely (!c->serializer->extend_min (subtable))) return_trace (false); if (unlikely (!c->serializer->extend_min (subtable))) return_trace (false);
auto* old_subtable = get_subtable (base); auto *old_subtable = get_subtable (base);
auto* old_header = old_subtable->get_header (); auto *old_header = old_subtable->get_header ();
subtable->populate_header (old_header->indexFormat, subtable->populate_header (old_header->indexFormat,
old_header->imageFormat, old_header->imageFormat,
bitmap_size_context->cbdt_prime->length, bitmap_size_context->cbdt_prime->length,
&bitmap_size_context->size); &bitmap_size_context->size);
unsigned int num_glyphs = 0; unsigned int num_glyphs = 0;
bool early_exit = false; bool early_exit = false;
@ -397,52 +401,53 @@ struct IndexSubtableRecord
hb_codepoint_t new_gid = (*lookup)[i].first; hb_codepoint_t new_gid = (*lookup)[i].first;
const IndexSubtableRecord *next_record = (*lookup)[i].second; const IndexSubtableRecord *next_record = (*lookup)[i].second;
const IndexSubtable *next_subtable = next_record->get_subtable (base); const IndexSubtable *next_subtable = next_record->get_subtable (base);
auto* next_header = next_subtable->get_header (); auto *next_header = next_subtable->get_header ();
if (next_header != old_header) { if (next_header != old_header)
*start = i; {
early_exit = true; *start = i;
break; early_exit = true;
break;
} }
unsigned int num_missing = record->add_glyph_for_subset (new_gid); unsigned int num_missing = record->add_glyph_for_subset (new_gid);
if (unlikely (!subtable->fill_missing_glyphs (c->serializer, if (unlikely (!subtable->fill_missing_glyphs (c->serializer,
bitmap_size_context->cbdt_prime->length, bitmap_size_context->cbdt_prime->length,
num_missing, num_missing,
&bitmap_size_context->size, &bitmap_size_context->size,
&num_glyphs))) &num_glyphs)))
return_trace (false); return_trace (false);
hb_codepoint_t old_gid = 0; hb_codepoint_t old_gid = 0;
c->plan->old_gid_for_new_gid (new_gid, &old_gid); c->plan->old_gid_for_new_gid (new_gid, &old_gid);
if (old_gid < next_record->firstGlyphIndex) if (old_gid < next_record->firstGlyphIndex)
return_trace (false); return_trace (false);
unsigned int old_idx = (unsigned int) old_gid - next_record->firstGlyphIndex; unsigned int old_idx = (unsigned int) old_gid - next_record->firstGlyphIndex;
if (unlikely (!next_subtable->copy_glyph_at_idx (c->serializer, if (unlikely (!next_subtable->copy_glyph_at_idx (c->serializer,
old_idx, old_idx,
bitmap_size_context->cbdt, bitmap_size_context->cbdt,
bitmap_size_context->cbdt_length, bitmap_size_context->cbdt_length,
bitmap_size_context->cbdt_prime, bitmap_size_context->cbdt_prime,
subtable, subtable,
&bitmap_size_context->size))) &bitmap_size_context->size)))
return_trace (false); return_trace (false);
num_glyphs += 1; num_glyphs += 1;
} }
if (!early_exit) if (!early_exit)
*start = lookup->length; *start = lookup->length;
if (unlikely (!subtable->finish_subtable (c->serializer, if (unlikely (!subtable->finish_subtable (c->serializer,
bitmap_size_context->cbdt_prime->length, bitmap_size_context->cbdt_prime->length,
num_glyphs, num_glyphs,
&bitmap_size_context->size))) &bitmap_size_context->size)))
return_trace (false); return_trace (false);
return_trace (true); return_trace (true);
} }
bool add_new_record (hb_subset_context_t *c, bool add_new_record (hb_subset_context_t *c,
cblc_bitmap_size_subset_context_t *bitmap_size_context, cblc_bitmap_size_subset_context_t *bitmap_size_context,
const hb_vector_t<hb_pair_t<hb_codepoint_t, const IndexSubtableRecord*>> *lookup, /* IN */ const hb_vector_t<hb_pair_t<hb_codepoint_t, const IndexSubtableRecord*>> *lookup, /* IN */
const void *base, const void *base,
unsigned int *start, /* INOUT */ unsigned int *start, /* INOUT */
hb_vector_t<IndexSubtableRecord>* records /* INOUT */) const hb_vector_t<IndexSubtableRecord>* records /* INOUT */) const
{ {
TRACE_SERIALIZE (this); TRACE_SERIALIZE (this);
auto snap = c->serializer->snapshot (); auto snap = c->serializer->snapshot ();
@ -471,7 +476,8 @@ struct IndexSubtableRecord
return_trace (true); return_trace (true);
} }
unsigned int add_glyph_for_subset (hb_codepoint_t gid) { unsigned int add_glyph_for_subset (hb_codepoint_t gid)
{
if (firstGlyphIndex > lastGlyphIndex) if (firstGlyphIndex > lastGlyphIndex)
{ {
firstGlyphIndex = gid; firstGlyphIndex = gid;
@ -486,11 +492,8 @@ struct IndexSubtableRecord
return num_missing; return num_missing;
} }
bool get_extents (hb_glyph_extents_t *extents, bool get_extents (hb_glyph_extents_t *extents, const void *base) const
const void *base) const { return (base+offsetToSubtable).get_extents (extents); }
{
return (base+offsetToSubtable).get_extents (extents);
}
bool get_image_data (unsigned int gid, bool get_image_data (unsigned int gid,
const void *base, const void *base,
@ -507,7 +510,7 @@ struct IndexSubtableRecord
HBGlyphID lastGlyphIndex; HBGlyphID lastGlyphIndex;
LOffsetTo<IndexSubtable> offsetToSubtable; LOffsetTo<IndexSubtable> offsetToSubtable;
public: public:
DEFINE_SIZE_STATIC(8); DEFINE_SIZE_STATIC (8);
}; };
struct IndexSubtableArray struct IndexSubtableArray
@ -520,9 +523,10 @@ struct IndexSubtableArray
return_trace (indexSubtablesZ.sanitize (c, count, this)); return_trace (indexSubtablesZ.sanitize (c, count, this));
} }
void build_lookup (hb_subset_context_t *c, void
cblc_bitmap_size_subset_context_t *bitmap_size_context, build_lookup (hb_subset_context_t *c, cblc_bitmap_size_subset_context_t *bitmap_size_context,
hb_vector_t<hb_pair_t<hb_codepoint_t, const IndexSubtableRecord*>> *lookup /* OUT */) const hb_vector_t<hb_pair_t<hb_codepoint_t,
const IndexSubtableRecord*>> *lookup /* OUT */) const
{ {
bool start_glyph_is_set = false; bool start_glyph_is_set = false;
for (hb_codepoint_t new_gid = 0; new_gid < c->plan->num_output_glyphs (); new_gid++) for (hb_codepoint_t new_gid = 0; new_gid < c->plan->num_output_glyphs (); new_gid++)
@ -530,7 +534,7 @@ struct IndexSubtableArray
hb_codepoint_t old_gid; hb_codepoint_t old_gid;
if (unlikely (!c->plan->old_gid_for_new_gid (new_gid, &old_gid))) continue; if (unlikely (!c->plan->old_gid_for_new_gid (new_gid, &old_gid))) continue;
const IndexSubtableRecord* record = find_table(old_gid, bitmap_size_context->num_tables); const IndexSubtableRecord* record = find_table (old_gid, bitmap_size_context->num_tables);
if (unlikely (!record)) continue; if (unlikely (!record)) continue;
// Don't add gaps to the lookup. The best way to determine if a glyph is a // Don't add gaps to the lookup. The best way to determine if a glyph is a
@ -542,20 +546,21 @@ struct IndexSubtableArray
if (!start_glyph_is_set) if (!start_glyph_is_set)
{ {
bitmap_size_context->start_glyph = new_gid; bitmap_size_context->start_glyph = new_gid;
start_glyph_is_set = true; start_glyph_is_set = true;
} }
bitmap_size_context->end_glyph = new_gid; bitmap_size_context->end_glyph = new_gid;
} }
} }
bool subset (hb_subset_context_t *c, bool
cblc_bitmap_size_subset_context_t *bitmap_size_context) const subset (hb_subset_context_t *c,
cblc_bitmap_size_subset_context_t *bitmap_size_context) const
{ {
TRACE_SUBSET (this); TRACE_SUBSET (this);
auto* dst = c->serializer->start_embed<IndexSubtableArray> (); auto *dst = c->serializer->start_embed<IndexSubtableArray> ();
if (unlikely (!dst)) return_trace (false); if (unlikely (!dst)) return_trace (false);
hb_vector_t<hb_pair_t<hb_codepoint_t, const IndexSubtableRecord*>> lookup; hb_vector_t<hb_pair_t<hb_codepoint_t, const IndexSubtableRecord*>> lookup;
@ -567,14 +572,14 @@ struct IndexSubtableArray
for (unsigned int start = 0; start < lookup.length;) for (unsigned int start = 0; start < lookup.length;)
{ {
if (unlikely (!lookup[start].second->add_new_record (c, bitmap_size_context, &lookup, this, &start, &records))) if (unlikely (!lookup[start].second->add_new_record (c, bitmap_size_context, &lookup, this, &start, &records)))
return_trace (false); return_trace (false);
} }
// Workaround to ensure offset ordering is from least to greatest when // Workaround to ensure offset ordering is from least to greatest when
// resolving links. // resolving links.
hb_vector_t<hb_serialize_context_t::objidx_t> objidxs; hb_vector_t<hb_serialize_context_t::objidx_t> objidxs;
for (unsigned int i = 0; i < records.length; i++) for (unsigned int i = 0; i < records.length; i++)
objidxs.push (c->serializer->pop_pack()); objidxs.push (c->serializer->pop_pack ());
for (unsigned int i = 0; i < records.length; i++) for (unsigned int i = 0; i < records.length; i++)
{ {
IndexSubtableRecord* record = c->serializer->embed (records[i]); IndexSubtableRecord* record = c->serializer->embed (records[i]);
@ -615,23 +620,20 @@ struct BitmapSizeTable
vertical.sanitize (c)); vertical.sanitize (c));
} }
const IndexSubtableRecord *find_table (hb_codepoint_t glyph, const IndexSubtableRecord *
const void *base, find_table (hb_codepoint_t glyph, const void *base, const void **out_base) const
const void **out_base) const
{ {
*out_base = &(base+indexSubtableArrayOffset); *out_base = &(base+indexSubtableArrayOffset);
return (base+indexSubtableArrayOffset).find_table (glyph, numberOfIndexSubtables); return (base+indexSubtableArrayOffset).find_table (glyph, numberOfIndexSubtables);
} }
bool subset(hb_subset_context_t *c, bool
const void *src_base, subset (hb_subset_context_t *c, const void *src_base, const void *dst_base,
const void *dst_base, const char *cbdt, unsigned int cbdt_length,
const char *cbdt, hb_vector_t<char> *cbdt_prime /* INOUT */) const
unsigned int cbdt_length,
hb_vector_t<char> *cbdt_prime /* INOUT */) const
{ {
TRACE_SUBSET (this); TRACE_SUBSET (this);
auto* out_table = c->serializer->embed (this); auto *out_table = c->serializer->embed (this);
if (unlikely (!out_table)) return_trace (false); if (unlikely (!out_table)) return_trace (false);
cblc_bitmap_size_subset_context_t bitmap_size_context; cblc_bitmap_size_subset_context_t bitmap_size_context;
@ -643,15 +645,15 @@ struct BitmapSizeTable
bitmap_size_context.start_glyph = 1; bitmap_size_context.start_glyph = 1;
bitmap_size_context.end_glyph = 0; bitmap_size_context.end_glyph = 0;
if (!out_table->indexSubtableArrayOffset.serialize_subset(c, if (!out_table->indexSubtableArrayOffset.serialize_subset (c,
indexSubtableArrayOffset, indexSubtableArrayOffset,
src_base, src_base,
dst_base, dst_base,
&bitmap_size_context)) &bitmap_size_context))
return_trace (false); return_trace (false);
if (!bitmap_size_context.size || if (!bitmap_size_context.size ||
!bitmap_size_context.num_tables || !bitmap_size_context.num_tables ||
bitmap_size_context.start_glyph > bitmap_size_context.end_glyph) bitmap_size_context.start_glyph > bitmap_size_context.end_glyph)
return_trace (false); return_trace (false);
out_table->indexTablesSize = bitmap_size_context.size; out_table->indexTablesSize = bitmap_size_context.size;
@ -676,7 +678,7 @@ struct BitmapSizeTable
HBUINT8 bitDepth; HBUINT8 bitDepth;
HBINT8 flags; HBINT8 flags;
public: public:
DEFINE_SIZE_STATIC(48); DEFINE_SIZE_STATIC (48);
}; };
@ -689,7 +691,7 @@ struct GlyphBitmapDataFormat17
SmallGlyphMetrics glyphMetrics; SmallGlyphMetrics glyphMetrics;
LArrayOf<HBUINT8> data; LArrayOf<HBUINT8> data;
public: public:
DEFINE_SIZE_ARRAY(9, data); DEFINE_SIZE_ARRAY (9, data);
}; };
struct GlyphBitmapDataFormat18 struct GlyphBitmapDataFormat18
@ -697,14 +699,14 @@ struct GlyphBitmapDataFormat18
BigGlyphMetrics glyphMetrics; BigGlyphMetrics glyphMetrics;
LArrayOf<HBUINT8> data; LArrayOf<HBUINT8> data;
public: public:
DEFINE_SIZE_ARRAY(12, data); DEFINE_SIZE_ARRAY (12, data);
}; };
struct GlyphBitmapDataFormat19 struct GlyphBitmapDataFormat19
{ {
LArrayOf<HBUINT8> data; LArrayOf<HBUINT8> data;
public: public:
DEFINE_SIZE_ARRAY(4, data); DEFINE_SIZE_ARRAY (4, data);
}; };
struct CBLC struct CBLC
@ -721,26 +723,24 @@ struct CBLC
sizeTables.sanitize (c, this)); sizeTables.sanitize (c, this));
} }
static bool sink_cbdt(hb_subset_context_t *c, static bool
hb_vector_t<char>* cbdt_prime) sink_cbdt (hb_subset_context_t *c, hb_vector_t<char>* cbdt_prime)
{ {
hb_blob_t *cbdt_prime_blob = hb_blob_create (cbdt_prime->arrayZ, hb_blob_t *cbdt_prime_blob = hb_blob_create (cbdt_prime->arrayZ,
cbdt_prime->length, cbdt_prime->length,
HB_MEMORY_MODE_WRITABLE, HB_MEMORY_MODE_WRITABLE,
cbdt_prime->arrayZ, cbdt_prime->arrayZ,
free); free);
cbdt_prime->init (); // Leak arrayZ to the blob. cbdt_prime->init (); // Leak arrayZ to the blob.
bool ret = c->plan->add_table (HB_OT_TAG_CBDT, cbdt_prime_blob); bool ret = c->plan->add_table (HB_OT_TAG_CBDT, cbdt_prime_blob);
hb_blob_destroy (cbdt_prime_blob); hb_blob_destroy (cbdt_prime_blob);
return ret; return ret;
} }
bool subset_size_table (hb_subset_context_t *c, bool
const BitmapSizeTable& table, subset_size_table (hb_subset_context_t *c, const BitmapSizeTable& table,
const char *cbdt /* IN */, const char *cbdt /* IN */, unsigned int cbdt_length,
unsigned int cbdt_length, CBLC *cblc_prime /* INOUT */, hb_vector_t<char> *cbdt_prime /* INOUT */) const
CBLC *cblc_prime /* INOUT */,
hb_vector_t<char> *cbdt_prime /* INOUT */) const
{ {
TRACE_SUBSET (this); TRACE_SUBSET (this);
cblc_prime->sizeTables.len++; cblc_prime->sizeTables.len++;
@ -766,7 +766,7 @@ struct CBLC
{ {
unsigned count = sizeTables.len; unsigned count = sizeTables.len;
if (unlikely (!count)) if (unlikely (!count))
return Null(BitmapSizeTable); return Null (BitmapSizeTable);
unsigned int requested_ppem = hb_max (font->x_ppem, font->y_ppem); unsigned int requested_ppem = hb_max (font->x_ppem, font->y_ppem);
if (!requested_ppem) if (!requested_ppem)
@ -792,7 +792,7 @@ struct CBLC
FixedVersion<> version; FixedVersion<> version;
LArrayOf<BitmapSizeTable> sizeTables; LArrayOf<BitmapSizeTable> sizeTables;
public: public:
DEFINE_SIZE_ARRAY(8, sizeTables); DEFINE_SIZE_ARRAY (8, sizeTables);
}; };
struct CBDT struct CBDT
@ -803,8 +803,8 @@ struct CBDT
{ {
void init (hb_face_t *face) void init (hb_face_t *face)
{ {
cblc = hb_sanitize_context_t().reference_table<CBLC> (face); cblc = hb_sanitize_context_t ().reference_table<CBLC> (face);
cbdt = hb_sanitize_context_t().reference_table<CBDT> (face); cbdt = hb_sanitize_context_t ().reference_table<CBDT> (face);
upem = hb_face_get_upem (face); upem = hb_face_get_upem (face);
} }
@ -815,8 +815,8 @@ struct CBDT
this->cbdt.destroy (); this->cbdt.destroy ();
} }
bool get_extents (hb_font_t *font, hb_codepoint_t glyph, bool
hb_glyph_extents_t *extents) const get_extents (hb_font_t *font, hb_codepoint_t glyph, hb_glyph_extents_t *extents) const
{ {
const void *base; const void *base;
const BitmapSizeTable &strike = this->cblc->choose_strike (font); const BitmapSizeTable &strike = this->cblc->choose_strike (font);
@ -831,33 +831,27 @@ struct CBDT
if (!subtable_record->get_image_data (glyph, base, &image_offset, &image_length, &image_format)) if (!subtable_record->get_image_data (glyph, base, &image_offset, &image_length, &image_format))
return false; return false;
{ unsigned int cbdt_len = cbdt.get_length ();
unsigned int cbdt_len = cbdt.get_length (); if (unlikely (image_offset > cbdt_len || cbdt_len - image_offset < image_length))
if (unlikely (image_offset > cbdt_len || cbdt_len - image_offset < image_length)) return false;
return false;
switch (image_format) switch (image_format)
{ {
case 17: { case 17: {
if (unlikely (image_length < GlyphBitmapDataFormat17::min_size)) if (unlikely (image_length < GlyphBitmapDataFormat17::min_size))
return false; return false;
const GlyphBitmapDataFormat17& glyphFormat17 = auto &glyphFormat17 = StructAtOffset<GlyphBitmapDataFormat17> (this->cbdt, image_offset);
StructAtOffset<GlyphBitmapDataFormat17> (this->cbdt, image_offset); glyphFormat17.glyphMetrics.get_extents (font, extents);
glyphFormat17.glyphMetrics.get_extents (font, extents); break;
break; }
} case 18: {
case 18: { if (unlikely (image_length < GlyphBitmapDataFormat18::min_size))
if (unlikely (image_length < GlyphBitmapDataFormat18::min_size)) return false;
return false; auto &glyphFormat18 = StructAtOffset<GlyphBitmapDataFormat18> (this->cbdt, image_offset);
const GlyphBitmapDataFormat18& glyphFormat18 = glyphFormat18.glyphMetrics.get_extents (font, extents);
StructAtOffset<GlyphBitmapDataFormat18> (this->cbdt, image_offset); break;
glyphFormat18.glyphMetrics.get_extents (font, extents); }
break; default: return false; /* TODO: Support other image formats. */
}
default:
// TODO: Support other image formats.
return false;
}
} }
/* Convert to font units. */ /* Convert to font units. */
@ -884,44 +878,41 @@ struct CBDT
if (!subtable_record->get_image_data (glyph, base, &image_offset, &image_length, &image_format)) if (!subtable_record->get_image_data (glyph, base, &image_offset, &image_length, &image_format))
return hb_blob_get_empty (); return hb_blob_get_empty ();
unsigned int cbdt_len = cbdt.get_length ();
if (unlikely (image_offset > cbdt_len || cbdt_len - image_offset < image_length))
return hb_blob_get_empty ();
switch (image_format)
{ {
unsigned int cbdt_len = cbdt.get_length (); case 17:
if (unlikely (image_offset > cbdt_len || cbdt_len - image_offset < image_length)) {
if (unlikely (image_length < GlyphBitmapDataFormat17::min_size))
return hb_blob_get_empty (); return hb_blob_get_empty ();
auto &glyphFormat17 = StructAtOffset<GlyphBitmapDataFormat17> (this->cbdt, image_offset);
switch (image_format) return hb_blob_create_sub_blob (cbdt.get_blob (),
{ image_offset + GlyphBitmapDataFormat17::min_size,
case 17: { glyphFormat17.data.len);
if (unlikely (image_length < GlyphBitmapDataFormat17::min_size)) }
return hb_blob_get_empty (); case 18:
const GlyphBitmapDataFormat17& glyphFormat17 = {
StructAtOffset<GlyphBitmapDataFormat17> (this->cbdt, image_offset); if (unlikely (image_length < GlyphBitmapDataFormat18::min_size))
return hb_blob_create_sub_blob (cbdt.get_blob (), return hb_blob_get_empty ();
image_offset + GlyphBitmapDataFormat17::min_size, auto &glyphFormat18 = StructAtOffset<GlyphBitmapDataFormat18> (this->cbdt, image_offset);
glyphFormat17.data.len); return hb_blob_create_sub_blob (cbdt.get_blob (),
} image_offset + GlyphBitmapDataFormat18::min_size,
case 18: { glyphFormat18.data.len);
if (unlikely (image_length < GlyphBitmapDataFormat18::min_size)) }
return hb_blob_get_empty (); case 19:
const GlyphBitmapDataFormat18& glyphFormat18 = {
StructAtOffset<GlyphBitmapDataFormat18> (this->cbdt, image_offset); if (unlikely (image_length < GlyphBitmapDataFormat19::min_size))
return hb_blob_create_sub_blob (cbdt.get_blob (), return hb_blob_get_empty ();
image_offset + GlyphBitmapDataFormat18::min_size, auto &glyphFormat19 = StructAtOffset<GlyphBitmapDataFormat19> (this->cbdt, image_offset);
glyphFormat18.data.len); return hb_blob_create_sub_blob (cbdt.get_blob (),
} image_offset + GlyphBitmapDataFormat19::min_size,
case 19: { glyphFormat19.data.len);
if (unlikely (image_length < GlyphBitmapDataFormat19::min_size)) }
return hb_blob_get_empty (); default: return hb_blob_get_empty (); /* TODO: Support other image formats. */
const GlyphBitmapDataFormat19& glyphFormat19 =
StructAtOffset<GlyphBitmapDataFormat19> (this->cbdt, image_offset);
return hb_blob_create_sub_blob (cbdt.get_blob (),
image_offset + GlyphBitmapDataFormat19::min_size,
glyphFormat19.data.len);
}
}
} }
return hb_blob_get_empty ();
} }
bool has_data () const { return cbdt.get_length (); } bool has_data () const { return cbdt.get_length (); }
@ -944,7 +935,7 @@ struct CBDT
FixedVersion<> version; FixedVersion<> version;
UnsizedArrayOf<HBUINT8> dataZ; UnsizedArrayOf<HBUINT8> dataZ;
public: public:
DEFINE_SIZE_ARRAY(4, dataZ); DEFINE_SIZE_ARRAY (4, dataZ);
}; };
inline bool inline bool
@ -952,13 +943,13 @@ CBLC::subset (hb_subset_context_t *c) const
{ {
TRACE_SUBSET (this); TRACE_SUBSET (this);
auto* cblc_prime = c->serializer->start_embed<CBLC> (); auto *cblc_prime = c->serializer->start_embed<CBLC> ();
// Use a vector as a secondary buffer as the tables need to be built in parallel. // Use a vector as a secondary buffer as the tables need to be built in parallel.
hb_vector_t<char> cbdt_prime; hb_vector_t<char> cbdt_prime;
if (unlikely (!cblc_prime)) return_trace (false); if (unlikely (!cblc_prime)) return_trace (false);
if (unlikely (!c->serializer->extend_min(cblc_prime))) return_trace (false); if (unlikely (!c->serializer->extend_min (cblc_prime))) return_trace (false);
cblc_prime->version = version; cblc_prime->version = version;
hb_blob_t* cbdt_blob = hb_sanitize_context_t ().reference_table<CBDT> (c->plan->source); hb_blob_t* cbdt_blob = hb_sanitize_context_t ().reference_table<CBDT> (c->plan->source);