harfbuzz/src/hb-ot-color-cbdt-table.hh

536 lines
14 KiB
C++
Raw Normal View History

/*
* Copyright © 2016 Google, Inc.
*
* This is part of HarfBuzz, a text shaping library.
*
* Permission is hereby granted, without written agreement and without
* license or royalty fees, to use, copy, modify, and distribute this
* software and its documentation for any purpose, provided that the
* above copyright notice and the following two paragraphs appear in
* all copies of this software.
*
* IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
* DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
* ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
* IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
* DAMAGE.
*
* THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
* BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
* FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
* ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
* PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
*
* Google Author(s): Seigo Nonaka
*/
#ifndef HB_OT_COLOR_CBDT_TABLE_HH
#define HB_OT_COLOR_CBDT_TABLE_HH
#include "hb-open-type.hh"
/*
* CBLC -- Color Bitmap Location
* https://docs.microsoft.com/en-us/typography/opentype/spec/cblc
* https://docs.microsoft.com/en-us/typography/opentype/spec/eblc
* CBDT -- Color Bitmap Data
* https://docs.microsoft.com/en-us/typography/opentype/spec/cbdt
* https://docs.microsoft.com/en-us/typography/opentype/spec/ebdt
*/
#define HB_OT_TAG_CBLC HB_TAG('C','B','L','C')
#define HB_OT_TAG_CBDT HB_TAG('C','B','D','T')
namespace OT {
struct SmallGlyphMetrics
{
bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
return_trace (c->check_struct (this));
}
void get_extents (hb_glyph_extents_t *extents) const
{
extents->x_bearing = bearingX;
extents->y_bearing = bearingY;
extents->width = width;
extents->height = - (hb_position_t) height;
}
2018-03-14 15:52:53 +01:00
HBUINT8 height;
HBUINT8 width;
HBINT8 bearingX;
HBINT8 bearingY;
HBUINT8 advance;
public:
DEFINE_SIZE_STATIC(5);
};
2016-12-05 04:43:33 +01:00
struct BigGlyphMetrics : SmallGlyphMetrics
{
2018-03-14 15:52:53 +01:00
HBINT8 vertBearingX;
HBINT8 vertBearingY;
HBUINT8 vertAdvance;
public:
2016-12-05 04:43:33 +01:00
DEFINE_SIZE_STATIC(8);
};
struct SBitLineMetrics
{
bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
return_trace (c->check_struct (this));
}
2018-03-14 15:52:53 +01:00
HBINT8 ascender;
HBINT8 decender;
HBUINT8 widthMax;
HBINT8 caretSlopeNumerator;
HBINT8 caretSlopeDenominator;
HBINT8 caretOffset;
HBINT8 minOriginSB;
HBINT8 minAdvanceSB;
HBINT8 maxBeforeBL;
HBINT8 minAfterBL;
HBINT8 padding1;
HBINT8 padding2;
public:
DEFINE_SIZE_STATIC(12);
};
2016-12-05 04:12:52 +01:00
/*
* Index Subtables.
*/
2016-12-05 04:12:52 +01:00
struct IndexSubtableHeader
{
bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
return_trace (c->check_struct (this));
}
2018-03-14 15:52:53 +01:00
HBUINT16 indexFormat;
HBUINT16 imageFormat;
HBUINT32 imageDataOffset;
public:
DEFINE_SIZE_STATIC(8);
};
2016-12-05 04:26:54 +01:00
template <typename OffsetType>
struct IndexSubtableFormat1Or3
{
bool sanitize (hb_sanitize_context_t *c, unsigned int glyph_count) const
{
TRACE_SANITIZE (this);
return_trace (c->check_struct (this) &&
2018-10-15 05:49:21 +02:00
offsetArrayZ.sanitize (c, glyph_count + 1));
}
bool get_image_data (unsigned int idx,
unsigned int *offset,
unsigned int *length) const
{
if (unlikely (offsetArrayZ[idx + 1] <= offsetArrayZ[idx]))
return false;
*offset = header.imageDataOffset + offsetArrayZ[idx];
*length = offsetArrayZ[idx + 1] - offsetArrayZ[idx];
return true;
}
2018-03-14 15:52:53 +01:00
IndexSubtableHeader header;
UnsizedArrayOf<Offset<OffsetType>>
2018-09-10 23:29:26 +02:00
offsetArrayZ;
2018-03-14 15:52:53 +01:00
public:
DEFINE_SIZE_ARRAY(8, offsetArrayZ);
};
struct IndexSubtableFormat1 : IndexSubtableFormat1Or3<HBUINT32> {};
struct IndexSubtableFormat3 : IndexSubtableFormat1Or3<HBUINT16> {};
2016-12-05 04:26:54 +01:00
struct IndexSubtable
{
bool sanitize (hb_sanitize_context_t *c, unsigned int glyph_count) const
{
TRACE_SANITIZE (this);
if (!u.header.sanitize (c)) return_trace (false);
switch (u.header.indexFormat) {
case 1: return_trace (u.format1.sanitize (c, glyph_count));
2016-12-05 04:26:54 +01:00
case 3: return_trace (u.format3.sanitize (c, glyph_count));
default:return_trace (true);
}
}
bool get_extents (hb_glyph_extents_t *extents HB_UNUSED) const
{
switch (u.header.indexFormat) {
case 2: case 5: /* TODO */
case 1: case 3: case 4: /* Variable-metrics formats do not have metrics here. */
default:return (false);
}
}
bool get_image_data (unsigned int idx,
unsigned int *offset,
unsigned int *length,
unsigned int *format) const
{
*format = u.header.imageFormat;
switch (u.header.indexFormat) {
case 1: return u.format1.get_image_data (idx, offset, length);
2016-12-05 04:26:54 +01:00
case 3: return u.format3.get_image_data (idx, offset, length);
default: return false;
}
}
protected:
union {
IndexSubtableHeader header;
IndexSubtableFormat1 format1;
2016-12-05 04:26:54 +01:00
IndexSubtableFormat3 format3;
2016-12-05 04:43:33 +01:00
/* TODO: Format 2, 4, 5. */
} u;
public:
DEFINE_SIZE_UNION (8, header);
};
struct IndexSubtableRecord
{
bool sanitize (hb_sanitize_context_t *c, const void *base) const
{
TRACE_SANITIZE (this);
return_trace (c->check_struct (this) &&
firstGlyphIndex <= lastGlyphIndex &&
offsetToSubtable.sanitize (c, base, lastGlyphIndex - firstGlyphIndex + 1));
}
bool get_extents (hb_glyph_extents_t *extents,
const void *base) const
{
return (base+offsetToSubtable).get_extents (extents);
}
bool get_image_data (unsigned int gid,
const void *base,
unsigned int *offset,
unsigned int *length,
unsigned int *format) const
{
if (gid < firstGlyphIndex || gid > lastGlyphIndex) return false;
return (base+offsetToSubtable).get_image_data (gid - firstGlyphIndex,
offset, length, format);
}
2018-03-14 15:52:53 +01:00
GlyphID firstGlyphIndex;
GlyphID lastGlyphIndex;
LOffsetTo<IndexSubtable> offsetToSubtable;
public:
DEFINE_SIZE_STATIC(8);
};
struct IndexSubtableArray
{
friend struct CBDT;
bool sanitize (hb_sanitize_context_t *c, unsigned int count) const
2016-12-03 05:12:57 +01:00
{
TRACE_SANITIZE (this);
2018-10-15 05:37:57 +02:00
return_trace (indexSubtablesZ.sanitize (c, count, this));
2016-12-03 05:12:57 +01:00
}
public:
const IndexSubtableRecord* find_table (hb_codepoint_t glyph, unsigned int numTables) const
{
for (unsigned int i = 0; i < numTables; ++i)
{
unsigned int firstGlyphIndex = indexSubtablesZ[i].firstGlyphIndex;
unsigned int lastGlyphIndex = indexSubtablesZ[i].lastGlyphIndex;
2018-09-10 23:29:26 +02:00
if (firstGlyphIndex <= glyph && glyph <= lastGlyphIndex)
return &indexSubtablesZ[i];
}
2017-10-15 12:11:08 +02:00
return nullptr;
}
protected:
2018-09-10 23:29:26 +02:00
UnsizedArrayOf<IndexSubtableRecord> indexSubtablesZ;
2016-12-03 05:12:57 +01:00
};
struct BitmapSizeTable
{
2016-12-05 04:12:52 +01:00
friend struct CBLC;
friend struct CBDT;
2016-12-05 04:12:52 +01:00
bool sanitize (hb_sanitize_context_t *c, const void *base) const
2016-12-03 05:12:57 +01:00
{
TRACE_SANITIZE (this);
return_trace (c->check_struct (this) &&
indexSubtableArrayOffset.sanitize (c, base, numberOfIndexSubtables) &&
horizontal.sanitize (c) &&
vertical.sanitize (c));
}
const IndexSubtableRecord *find_table (hb_codepoint_t glyph,
const void *base,
const void **out_base) const
2016-12-05 04:12:52 +01:00
{
*out_base = &(base+indexSubtableArrayOffset);
2016-12-05 04:12:52 +01:00
return (base+indexSubtableArrayOffset).find_table (glyph, numberOfIndexSubtables);
}
protected:
2019-01-18 00:17:04 +01:00
LNNOffsetTo<IndexSubtableArray>
2018-03-14 15:52:53 +01:00
indexSubtableArrayOffset;
HBUINT32 indexTablesSize;
HBUINT32 numberOfIndexSubtables;
HBUINT32 colorRef;
SBitLineMetrics horizontal;
SBitLineMetrics vertical;
GlyphID startGlyphIndex;
GlyphID endGlyphIndex;
HBUINT8 ppemX;
HBUINT8 ppemY;
HBUINT8 bitDepth;
HBINT8 flags;
2017-11-15 04:54:48 +01:00
public:
2016-12-03 05:12:57 +01:00
DEFINE_SIZE_STATIC(48);
};
2016-12-05 04:12:52 +01:00
/*
* Glyph Bitmap Data Formats.
*/
struct GlyphBitmapDataFormat17
{
2018-04-11 14:43:20 +02:00
SmallGlyphMetrics glyphMetrics;
LArrayOf<HBUINT8> data;
2018-03-14 15:52:53 +01:00
public:
DEFINE_SIZE_ARRAY(9, data);
2016-12-05 04:12:52 +01:00
};
struct GlyphBitmapDataFormat18
{
2018-04-11 14:43:20 +02:00
BigGlyphMetrics glyphMetrics;
LArrayOf<HBUINT8> data;
public:
DEFINE_SIZE_ARRAY(12, data);
};
struct GlyphBitmapDataFormat19
{
2018-04-11 14:43:20 +02:00
LArrayOf<HBUINT8> data;
public:
DEFINE_SIZE_ARRAY(4, data);
};
struct CBLC
{
2017-11-15 04:54:48 +01:00
friend struct CBDT;
static constexpr hb_tag_t tableTag = HB_OT_TAG_CBLC;
bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
return_trace (c->check_struct (this) &&
likely (version.major == 2 || version.major == 3) &&
2016-12-03 05:12:57 +01:00
sizeTables.sanitize (c, this));
}
2017-11-15 04:54:48 +01:00
protected:
2018-10-29 07:07:59 +01:00
const BitmapSizeTable &choose_strike (hb_font_t *font) const
{
unsigned count = sizeTables.len;
if (unlikely (!count))
return Null(BitmapSizeTable);
2016-12-05 04:12:52 +01:00
unsigned int requested_ppem = MAX (font->x_ppem, font->y_ppem);
if (!requested_ppem)
requested_ppem = 1<<30; /* Choose largest strike. */
unsigned int best_i = 0;
unsigned int best_ppem = MAX (sizeTables[0].ppemX, sizeTables[0].ppemY);
2016-12-05 04:12:52 +01:00
for (unsigned int i = 1; i < count; i++)
{
unsigned int ppem = MAX (sizeTables[i].ppemX, sizeTables[i].ppemY);
if ((requested_ppem <= ppem && ppem < best_ppem) ||
(requested_ppem > best_ppem && ppem > best_ppem))
{
best_i = i;
best_ppem = ppem;
}
}
return sizeTables[best_i];
}
protected:
2017-01-23 05:31:53 +01:00
FixedVersion<> version;
LArrayOf<BitmapSizeTable> sizeTables;
public:
DEFINE_SIZE_ARRAY(8, sizeTables);
};
struct CBDT
{
static constexpr hb_tag_t tableTag = HB_OT_TAG_CBDT;
struct accelerator_t
{
void init (hb_face_t *face)
{
cblc = hb_sanitize_context_t().reference_table<CBLC> (face);
cbdt = hb_sanitize_context_t().reference_table<CBDT> (face);
upem = hb_face_get_upem (face);
}
void fini ()
{
2018-11-11 17:40:57 +01:00
this->cblc.destroy ();
this->cbdt.destroy ();
}
bool get_extents (hb_font_t *font, hb_codepoint_t glyph,
hb_glyph_extents_t *extents) const
{
const void *base;
2018-10-29 07:07:59 +01:00
const BitmapSizeTable &strike = this->cblc->choose_strike (font);
2018-10-29 07:01:57 +01:00
const IndexSubtableRecord *subtable_record = strike.find_table (glyph, cblc, &base);
2018-10-29 07:07:59 +01:00
if (!subtable_record || !strike.ppemX || !strike.ppemY)
return false;
if (subtable_record->get_extents (extents, base))
return true;
unsigned int image_offset = 0, image_length = 0, image_format = 0;
if (!subtable_record->get_image_data (glyph, base, &image_offset, &image_length, &image_format))
return false;
{
unsigned int cbdt_len = cbdt.get_length ();
if (unlikely (image_offset > cbdt_len || cbdt_len - image_offset < image_length))
return false;
switch (image_format)
{
case 17: {
if (unlikely (image_length < GlyphBitmapDataFormat17::min_size))
return false;
const GlyphBitmapDataFormat17& glyphFormat17 =
StructAtOffset<GlyphBitmapDataFormat17> (this->cbdt, image_offset);
glyphFormat17.glyphMetrics.get_extents (extents);
break;
}
case 18: {
if (unlikely (image_length < GlyphBitmapDataFormat18::min_size))
return false;
const GlyphBitmapDataFormat18& glyphFormat18 =
StructAtOffset<GlyphBitmapDataFormat18> (this->cbdt, image_offset);
glyphFormat18.glyphMetrics.get_extents (extents);
break;
}
default:
// TODO: Support other image formats.
return false;
}
}
2018-10-29 06:45:53 +01:00
/* Convert to font units. */
2018-10-29 07:07:59 +01:00
double x_scale = upem / (double) strike.ppemX;
double y_scale = upem / (double) strike.ppemY;
2018-10-29 06:45:53 +01:00
extents->x_bearing = round (extents->x_bearing * x_scale);
extents->y_bearing = round (extents->y_bearing * y_scale);
extents->width = round (extents->width * x_scale);
extents->height = round (extents->height * y_scale);
return true;
}
hb_blob_t* reference_png (hb_font_t *font,
2018-10-29 07:01:57 +01:00
hb_codepoint_t glyph) const
2018-10-26 22:25:11 +02:00
{
2018-10-27 12:02:14 +02:00
const void *base;
2018-10-29 07:07:59 +01:00
const BitmapSizeTable &strike = this->cblc->choose_strike (font);
2018-10-29 07:01:57 +01:00
const IndexSubtableRecord *subtable_record = strike.find_table (glyph, cblc, &base);
2018-10-29 07:07:59 +01:00
if (!subtable_record || !strike.ppemX || !strike.ppemY)
2018-10-27 12:02:14 +02:00
return hb_blob_get_empty ();
unsigned int image_offset = 0, image_length = 0, image_format = 0;
2018-10-29 07:01:57 +01:00
if (!subtable_record->get_image_data (glyph, base, &image_offset, &image_length, &image_format))
2018-10-27 12:02:14 +02:00
return hb_blob_get_empty ();
{
unsigned int cbdt_len = cbdt.get_length ();
2018-10-30 21:14:56 +01:00
if (unlikely (image_offset > cbdt_len || cbdt_len - image_offset < image_length))
return hb_blob_get_empty ();
switch (image_format)
{
case 17: {
if (unlikely (image_length < GlyphBitmapDataFormat17::min_size))
return hb_blob_get_empty ();
const GlyphBitmapDataFormat17& glyphFormat17 =
StructAtOffset<GlyphBitmapDataFormat17> (this->cbdt, image_offset);
return hb_blob_create_sub_blob (cbdt.get_blob (),
2018-10-30 21:14:56 +01:00
image_offset + GlyphBitmapDataFormat17::min_size,
glyphFormat17.data.len);
}
case 18: {
if (unlikely (image_length < GlyphBitmapDataFormat18::min_size))
return hb_blob_get_empty ();
const GlyphBitmapDataFormat18& glyphFormat18 =
StructAtOffset<GlyphBitmapDataFormat18> (this->cbdt, image_offset);
return hb_blob_create_sub_blob (cbdt.get_blob (),
2018-10-30 21:14:56 +01:00
image_offset + GlyphBitmapDataFormat18::min_size,
glyphFormat18.data.len);
}
case 19: {
if (unlikely (image_length < GlyphBitmapDataFormat19::min_size))
return hb_blob_get_empty ();
const GlyphBitmapDataFormat19& glyphFormat19 =
StructAtOffset<GlyphBitmapDataFormat19> (this->cbdt, image_offset);
return hb_blob_create_sub_blob (cbdt.get_blob (),
2018-10-30 21:14:56 +01:00
image_offset + GlyphBitmapDataFormat19::min_size,
glyphFormat19.data.len);
}
}
2018-10-27 12:02:14 +02:00
}
2018-10-30 21:14:56 +01:00
return hb_blob_get_empty ();
2018-10-26 22:25:11 +02:00
}
bool has_data () const { return cbdt.get_length (); }
2018-10-26 22:25:11 +02:00
private:
hb_blob_ptr_t<CBLC> cblc;
hb_blob_ptr_t<CBDT> cbdt;
unsigned int upem;
};
bool sanitize (hb_sanitize_context_t *c) const
2018-10-26 22:25:11 +02:00
{
TRACE_SANITIZE (this);
return_trace (c->check_struct (this) &&
likely (version.major == 2 || version.major == 3));
}
protected:
2018-09-10 23:29:26 +02:00
FixedVersion<> version;
UnsizedArrayOf<HBUINT8> dataZ;
public:
DEFINE_SIZE_ARRAY(4, dataZ);
};
struct CBDT_accelerator_t : CBDT::accelerator_t {};
} /* namespace OT */
#endif /* HB_OT_COLOR_CBDT_TABLE_HH */