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

update cff & cff2 subsetters

This commit is contained in:
ariza 2020-03-02 16:51:19 -08:00 committed by Ebrahim Byagowi
parent 446d1e3bbc
commit c05458ec7f
9 changed files with 458 additions and 775 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

199
src/hb-ot-cff-common.hh
View File

@ -38,6 +38,9 @@ using namespace OT;
#define CFF_UNDEF_CODE 0xFFFFFFFF #define CFF_UNDEF_CODE 0xFFFFFFFF
using objidx_t = hb_serialize_context_t::objidx_t;
using whence_t = hb_serialize_context_t::whence_t;
/* utility macro */ /* utility macro */
template<typename Type> template<typename Type>
static inline const Type& StructAtOffsetOrNull (const void *P, unsigned int offset) static inline const Type& StructAtOffsetOrNull (const void *P, unsigned int offset)
@ -89,6 +92,16 @@ struct CFFIndex
unsigned int offset_array_size () const unsigned int offset_array_size () const
{ return calculate_offset_array_size (offSize, count); } { return calculate_offset_array_size (offSize, count); }
CFFIndex *copy (hb_serialize_context_t *c) const
{
TRACE_SERIALIZE (this);
unsigned int size = get_size ();
CFFIndex *out = c->allocate_size<CFFIndex> (size);
if (likely (out))
memcpy (out, this, size);
return_trace (out);
}
static unsigned int calculate_serialized_size (unsigned int offSize_, unsigned int count, static unsigned int calculate_serialized_size (unsigned int offSize_, unsigned int count,
unsigned int dataSize) unsigned int dataSize)
{ {
@ -163,6 +176,72 @@ struct CFFIndex
return result; return result;
} }
template <typename Iterator,
hb_requires (hb_is_iterator (Iterator))>
bool serialize (hb_serialize_context_t *c,
Iterator it)
{
TRACE_SERIALIZE (this);
if (it.len () == 0)
{
COUNT *dest = c->allocate_min<COUNT> ();
if (unlikely (dest == nullptr)) return_trace (false);
*dest = 0;
}
else
{
serialize_header(c, + it | hb_map ([] (const byte_str_t &_) { return _.length; }));
+ it | hb_apply ([&] (const byte_str_t &_) { _.copy (c); });
}
return_trace (true);
}
bool serialize (hb_serialize_context_t *c,
const byte_str_array_t &byteArray)
{ return serialize (c, + hb_iter (byteArray)); }
bool serialize (hb_serialize_context_t *c,
const str_buff_vec_t &buffArray)
{
auto it =
+ hb_iter (buffArray)
| hb_map ([] (const str_buff_t &_) { return byte_str_t (_.arrayZ, _.length); })
;
return serialize (c, it);
}
template <typename Iterator,
hb_requires (hb_is_iterator (Iterator))>
bool serialize_header (hb_serialize_context_t *c,
Iterator it)
{
TRACE_SERIALIZE (this);
unsigned total = + it | hb_reduce (hb_add, 0);
unsigned off_size = calcOffSize (total);
/* serialize CFFIndex header */
if (unlikely (!c->extend_min (*this))) return_trace (false);
this->count = it.len ();
this->offSize = off_size;
if (unlikely (!c->allocate_size<HBUINT8> (off_size * (it.len () + 1))))
return_trace (false);
/* serialize indices */
unsigned int offset = 1;
unsigned int i = 0;
+ it
| hb_apply ([&] (unsigned _)
{
CFFIndex<COUNT>::set_offset_at (i++, offset);
offset += _;
})
;
CFFIndex<COUNT>::set_offset_at (i, offset);
return_trace (true);
}
void set_offset_at (unsigned int index, unsigned int offset) void set_offset_at (unsigned int index, unsigned int offset)
{ {
HBUINT8 *p = offsets + offSize * index + offSize; HBUINT8 *p = offsets + offSize * index + offSize;
@ -316,15 +395,15 @@ struct CFFIndexOf : CFFIndex<COUNT>
/* Top Dict, Font Dict, Private Dict */ /* Top Dict, Font Dict, Private Dict */
struct Dict : UnsizedByteStr struct Dict : UnsizedByteStr
{ {
template <typename DICTVAL, typename OP_SERIALIZER, typename PARAM> template <typename DICTVAL, typename OP_SERIALIZER, typename ...Ts>
bool serialize (hb_serialize_context_t *c, bool serialize (hb_serialize_context_t *c,
const DICTVAL &dictval, const DICTVAL &dictval,
OP_SERIALIZER& opszr, OP_SERIALIZER& opszr,
PARAM& param) Ts&&... ds)
{ {
TRACE_SERIALIZE (this); TRACE_SERIALIZE (this);
for (unsigned int i = 0; i < dictval.get_count (); i++) for (unsigned int i = 0; i < dictval.get_count (); i++)
if (unlikely (!opszr.serialize (c, dictval[i], param))) if (unlikely (!opszr.serialize (c, dictval[i], hb_forward<Ts> (ds)...)))
return_trace (false); return_trace (false);
return_trace (true); return_trace (true);
@ -386,6 +465,21 @@ struct Dict : UnsizedByteStr
static bool serialize_offset2_op (hb_serialize_context_t *c, op_code_t op, unsigned value) static bool serialize_offset2_op (hb_serialize_context_t *c, op_code_t op, unsigned value)
{ return serialize_int2_op (c, op, value); } { return serialize_int2_op (c, op, value); }
template <typename T, int int_op>
static bool serialize_link_op (hb_serialize_context_t *c, op_code_t op, objidx_t link, whence_t whence)
{
T &ofs = *(T *) (c->head + OpCode_Size (int_op));
if (unlikely (!serialize_int_op<T> (c, op, 0, int_op))) return false;
c->add_link (ofs, link, nullptr, whence);
return true;
}
static bool serialize_link4_op (hb_serialize_context_t *c, op_code_t op, objidx_t link, whence_t whence = whence_t::Head)
{ return serialize_link_op<HBINT32, OpCode_longintdict> (c, op, link, whence); }
static bool serialize_link2_op (hb_serialize_context_t *c, op_code_t op, objidx_t link, whence_t whence = whence_t::Head)
{ return serialize_link_op<HBINT16, OpCode_shortint> (c, op, link, whence); }
}; };
struct TopDict : Dict {}; struct TopDict : Dict {};
@ -394,105 +488,40 @@ struct PrivateDict : Dict {};
struct table_info_t struct table_info_t
{ {
void init () { offSize = offset = size = 0; } void init () { offSize = offset = size = 0; link = 0; }
unsigned int offset; unsigned int offset;
unsigned int size; unsigned int size;
unsigned int offSize; unsigned int offSize;
objidx_t link;
}; };
template <typename COUNT> template <typename COUNT>
struct FDArray : CFFIndexOf<COUNT, FontDict> struct FDArray : CFFIndexOf<COUNT, FontDict>
{ {
/* used by CFF1 */ template <typename DICTVAL, typename INFO, typename Iterator, typename OP_SERIALIZER>
template <typename DICTVAL, typename OP_SERIALIZER>
bool serialize (hb_serialize_context_t *c, bool serialize (hb_serialize_context_t *c,
unsigned int offSize_, Iterator it,
const hb_vector_t<DICTVAL> &fontDicts,
OP_SERIALIZER& opszr) OP_SERIALIZER& opszr)
{ {
TRACE_SERIALIZE (this); TRACE_SERIALIZE (this);
if (unlikely (!c->extend_min (*this))) return_trace (false);
this->count = fontDicts.length;
this->offSize = offSize_;
if (unlikely (!c->allocate_size<HBUINT8> (offSize_ * (fontDicts.length + 1))))
return_trace (false);
/* serialize font dict offsets */ /* serialize INDEX data */
unsigned int offset = 1; hb_vector_t<unsigned> sizes;
unsigned int fid = 0; c->push ();
for (; fid < fontDicts.length; fid++) + it
{ | hb_map ([&] (const hb_pair_t<const DICTVAL&, const INFO&> &_)
CFFIndexOf<COUNT, FontDict>::set_offset_at (fid, offset);
offset += FontDict::calculate_serialized_size (fontDicts[fid], opszr);
}
CFFIndexOf<COUNT, FontDict>::set_offset_at (fid, offset);
/* serialize font dicts */
for (unsigned int i = 0; i < fontDicts.length; i++)
{ {
FontDict *dict = c->start_embed<FontDict> (); FontDict *dict = c->start_embed<FontDict> ();
if (unlikely (!dict->serialize (c, fontDicts[i], opszr, fontDicts[i]))) dict->serialize (c, _.first, opszr, _.second);
return_trace (false); return c->head - (const char*)dict;
} })
return_trace (true); | hb_sink (sizes)
} ;
c->pop_pack (false);
/* used by CFF2 */ /* serialize INDEX header */
template <typename DICTVAL, typename OP_SERIALIZER> return_trace (CFFIndex<COUNT>::serialize_header (c, hb_iter (sizes)));
bool serialize (hb_serialize_context_t *c,
unsigned int offSize_,
const hb_vector_t<DICTVAL> &fontDicts,
unsigned int fdCount,
const hb_inc_bimap_t &fdmap,
OP_SERIALIZER& opszr,
const hb_vector_t<table_info_t> &privateInfos)
{
TRACE_SERIALIZE (this);
if (unlikely (!c->extend_min (*this))) return_trace (false);
this->count = fdCount;
this->offSize = offSize_;
if (unlikely (!c->allocate_size<HBUINT8> (offSize_ * (fdCount + 1))))
return_trace (false);
/* serialize font dict offsets */
unsigned int offset = 1;
unsigned int fid = 0;
for (unsigned i = 0; i < fontDicts.length; i++)
if (fdmap.has (i))
{
if (unlikely (fid >= fdCount)) return_trace (false);
CFFIndexOf<COUNT, FontDict>::set_offset_at (fid++, offset);
offset += FontDict::calculate_serialized_size (fontDicts[i], opszr);
}
CFFIndexOf<COUNT, FontDict>::set_offset_at (fid, offset);
/* serialize font dicts */
for (unsigned int i = 0; i < fontDicts.length; i++)
if (fdmap.has (i))
{
FontDict *dict = c->start_embed<FontDict> ();
if (unlikely (!dict->serialize (c, fontDicts[i], opszr, privateInfos[fdmap[i]])))
return_trace (false);
}
return_trace (true);
}
/* in parallel to above */
template <typename OP_SERIALIZER, typename DICTVAL>
static unsigned int calculate_serialized_size (unsigned int &offSize_ /* OUT */,
const hb_vector_t<DICTVAL> &fontDicts,
unsigned int fdCount,
const hb_inc_bimap_t &fdmap,
OP_SERIALIZER& opszr)
{
unsigned int dictsSize = 0;
for (unsigned int i = 0; i < fontDicts.len; i++)
if (fdmap.has (i))
dictsSize += FontDict::calculate_serialized_size (fontDicts[i], opszr);
offSize_ = calcOffSize (dictsSize);
return CFFIndex<COUNT>::calculate_serialized_size (offSize_, fdCount, dictsSize);
} }
}; };

52
src/hb-ot-cff1-table.hh
View File

@ -55,7 +55,6 @@ template <typename Type> struct CFF1IndexOf : CFFIndexOf<HBUINT16, Type> {};
typedef CFFIndex<HBUINT16> CFF1Index; typedef CFFIndex<HBUINT16> CFF1Index;
typedef CFF1Index CFF1CharStrings; typedef CFF1Index CFF1CharStrings;
typedef FDArray<HBUINT16> CFF1FDArray;
typedef Subrs<HBUINT16> CFF1Subrs; typedef Subrs<HBUINT16> CFF1Subrs;
struct CFF1FDSelect : FDSelect {}; struct CFF1FDSelect : FDSelect {};
@ -601,7 +600,7 @@ struct Charset
struct CFF1StringIndex : CFF1Index struct CFF1StringIndex : CFF1Index
{ {
bool serialize (hb_serialize_context_t *c, const CFF1StringIndex &strings, bool serialize (hb_serialize_context_t *c, const CFF1StringIndex &strings,
unsigned int offSize_, const hb_inc_bimap_t &sidmap) const hb_inc_bimap_t &sidmap)
{ {
TRACE_SERIALIZE (this); TRACE_SERIALIZE (this);
if (unlikely ((strings.count == 0) || (sidmap.get_population () == 0))) if (unlikely ((strings.count == 0) || (sidmap.get_population () == 0)))
@ -623,26 +622,10 @@ struct CFF1StringIndex : CFF1Index
bytesArray[j] = strings[i]; bytesArray[j] = strings[i];
} }
bool result = CFF1Index::serialize (c, offSize_, bytesArray); bool result = CFF1Index::serialize (c, bytesArray);
bytesArray.fini (); bytesArray.fini ();
return_trace (result); return_trace (result);
} }
/* in parallel to above */
unsigned int calculate_serialized_size (unsigned int &offSize_ /*OUT*/, const hb_inc_bimap_t &sidmap) const
{
offSize_ = 0;
if ((count == 0) || (sidmap.get_population () == 0))
return count.static_size;
unsigned int dataSize = 0;
for (unsigned int i = 0; i < count; i++)
if (sidmap[i] != HB_MAP_VALUE_INVALID)
dataSize += length_at (i);
offSize_ = calcOffSize(dataSize);
return CFF1Index::calculate_serialized_size (offSize_, sidmap.get_population (), dataSize);
}
}; };
struct cff1_top_dict_interp_env_t : num_interp_env_t struct cff1_top_dict_interp_env_t : num_interp_env_t
@ -1004,6 +987,37 @@ typedef dict_interpreter_t<cff1_font_dict_opset_t, cff1_font_dict_values_t> cff1
typedef CFF1Index CFF1NameIndex; typedef CFF1Index CFF1NameIndex;
typedef CFF1IndexOf<TopDict> CFF1TopDictIndex; typedef CFF1IndexOf<TopDict> CFF1TopDictIndex;
struct cff1_font_dict_values_mod_t
{
cff1_font_dict_values_mod_t() { init (); }
void init () { init ( &Null(cff1_font_dict_values_t), CFF_UNDEF_SID ); }
void init (const cff1_font_dict_values_t *base_,
unsigned int fontName_)
{
base = base_;
fontName = fontName_;
privateDictInfo.init ();
}
unsigned get_count () const { return base->get_count (); }
const op_str_t &operator [] (unsigned int i) const { return (*base)[i]; }
const cff1_font_dict_values_t *base;
table_info_t privateDictInfo;
unsigned int fontName;
};
struct CFF1FDArray : FDArray<HBUINT16>
{
/* FDArray::serialize() requires this partial specialization to compile */
template <typename ITER, typename OP_SERIALIZER>
bool serialize (hb_serialize_context_t *c, ITER it, OP_SERIALIZER& opszr)
{ return FDArray<HBUINT16>::serialize<cff1_font_dict_values_mod_t, cff1_font_dict_values_mod_t> (c, it, opszr); }
};
} /* namespace CFF */ } /* namespace CFF */
namespace OT { namespace OT {

9
src/hb-ot-cff2-table.hh
View File

@ -43,7 +43,6 @@ typedef CFFIndex<HBUINT32> CFF2Index;
template <typename Type> struct CFF2IndexOf : CFFIndexOf<HBUINT32, Type> {}; template <typename Type> struct CFF2IndexOf : CFFIndexOf<HBUINT32, Type> {};
typedef CFF2Index CFF2CharStrings; typedef CFF2Index CFF2CharStrings;
typedef FDArray<HBUINT32> CFF2FDArray;
typedef Subrs<HBUINT32> CFF2Subrs; typedef Subrs<HBUINT32> CFF2Subrs;
typedef FDSelect3_4<HBUINT32, HBUINT16> FDSelect4; typedef FDSelect3_4<HBUINT32, HBUINT16> FDSelect4;
@ -404,6 +403,14 @@ struct cff2_private_dict_opset_subset_t : dict_opset_t
typedef dict_interpreter_t<cff2_top_dict_opset_t, cff2_top_dict_values_t> cff2_top_dict_interpreter_t; typedef dict_interpreter_t<cff2_top_dict_opset_t, cff2_top_dict_values_t> cff2_top_dict_interpreter_t;
typedef dict_interpreter_t<cff2_font_dict_opset_t, cff2_font_dict_values_t> cff2_font_dict_interpreter_t; typedef dict_interpreter_t<cff2_font_dict_opset_t, cff2_font_dict_values_t> cff2_font_dict_interpreter_t;
struct CFF2FDArray : FDArray<HBUINT32>
{
/* FDArray::serialize does not compile without this partial specialization */
template <typename ITER, typename OP_SERIALIZER>
bool serialize (hb_serialize_context_t *c, ITER it, OP_SERIALIZER& opszr)
{ return FDArray<HBUINT32>::serialize<cff2_font_dict_values_t, table_info_t> (c, it, opszr); }
};
} /* namespace CFF */ } /* namespace CFF */
namespace OT { namespace OT {

57
src/hb-subset-cff-common.hh
View File

@ -128,26 +128,23 @@ struct str_encoder_t
bool error; bool error;
}; };
struct cff_sub_table_offsets_t { struct cff_sub_table_info_t {
cff_sub_table_offsets_t () : privateDictsOffset (0) cff_sub_table_info_t ()
: fd_array_link (0),
char_strings_link (0),
private_dicts_offset (0)
{ {
topDictInfo.init (); top_dict.init ();
FDSelectInfo.init (); fd_select.init ();
FDArrayInfo.init (); global_subrs.init ();
charStringsInfo.init ();
globalSubrsInfo.init ();
localSubrsInfos.init ();
} }
~cff_sub_table_offsets_t () { localSubrsInfos.fini (); } table_info_t top_dict;
table_info_t fd_select;
table_info_t topDictInfo; objidx_t fd_array_link;
table_info_t FDSelectInfo; objidx_t char_strings_link;
table_info_t FDArrayInfo; unsigned int private_dicts_offset;
table_info_t charStringsInfo; table_info_t global_subrs;
unsigned int privateDictsOffset;
table_info_t globalSubrsInfo;
hb_vector_t<table_info_t> localSubrsInfos;
}; };
template <typename OPSTR=op_str_t> template <typename OPSTR=op_str_t>
@ -155,20 +152,20 @@ struct cff_top_dict_op_serializer_t : op_serializer_t
{ {
bool serialize (hb_serialize_context_t *c, bool serialize (hb_serialize_context_t *c,
const OPSTR &opstr, const OPSTR &opstr,
const cff_sub_table_offsets_t &offsets) const const cff_sub_table_info_t &info) const
{ {
TRACE_SERIALIZE (this); TRACE_SERIALIZE (this);
switch (opstr.op) switch (opstr.op)
{ {
case OpCode_CharStrings: case OpCode_CharStrings:
return_trace (FontDict::serialize_offset4_op(c, opstr.op, offsets.charStringsInfo.offset)); return_trace (FontDict::serialize_link4_op(c, opstr.op, info.char_strings_link, whence_t::Absolute));
case OpCode_FDArray: case OpCode_FDArray:
return_trace (FontDict::serialize_offset4_op(c, opstr.op, offsets.FDArrayInfo.offset)); return_trace (FontDict::serialize_link4_op(c, opstr.op, info.fd_array_link, whence_t::Absolute));
case OpCode_FDSelect: case OpCode_FDSelect:
return_trace (FontDict::serialize_offset4_op(c, opstr.op, offsets.FDSelectInfo.offset)); return_trace (FontDict::serialize_link4_op(c, opstr.op, info.fd_select.link, whence_t::Absolute));
default: default:
return_trace (copy_opstr (c, opstr)); return_trace (copy_opstr (c, opstr));
@ -202,16 +199,8 @@ struct cff_font_dict_op_serializer_t : op_serializer_t
if (opstr.op == OpCode_Private) if (opstr.op == OpCode_Private)
{ {
/* serialize the private dict size & offset as 2-byte & 4-byte integers */ /* serialize the private dict size & offset as 2-byte & 4-byte integers */
if (unlikely (!UnsizedByteStr::serialize_int2 (c, privateDictInfo.size) || return_trace (UnsizedByteStr::serialize_int2 (c, privateDictInfo.size) &&
!UnsizedByteStr::serialize_int4 (c, privateDictInfo.offset))) Dict::serialize_link4_op (c, opstr.op, privateDictInfo.link, whence_t::Absolute));
return_trace (false);
/* serialize the opcode */
HBUINT8 *p = c->allocate_size<HBUINT8> (1);
if (unlikely (p == nullptr)) return_trace (false);
*p = OpCode_Private;
return_trace (true);
} }
else else
{ {
@ -238,7 +227,7 @@ struct cff_private_dict_op_serializer_t : op_serializer_t
bool serialize (hb_serialize_context_t *c, bool serialize (hb_serialize_context_t *c,
const op_str_t &opstr, const op_str_t &opstr,
const unsigned int subrsOffset) const objidx_t subrs_link) const
{ {
TRACE_SERIALIZE (this); TRACE_SERIALIZE (this);
@ -246,10 +235,10 @@ struct cff_private_dict_op_serializer_t : op_serializer_t
return true; return true;
if (opstr.op == OpCode_Subrs) if (opstr.op == OpCode_Subrs)
{ {
if (desubroutinize || (subrsOffset == 0)) if (desubroutinize || !subrs_link)
return_trace (true); return_trace (true);
else else
return_trace (FontDict::serialize_offset2_op (c, opstr.op, subrsOffset)); return_trace (FontDict::serialize_link2_op (c, opstr.op, subrs_link));
} }
else else
return_trace (copy_opstr (c, opstr)); return_trace (copy_opstr (c, opstr));

560
src/hb-subset-cff1.cc
View File

@ -64,22 +64,18 @@ struct remap_sid_t : hb_inc_bimap_t
static unsigned int unoffset_sid (unsigned int sid) { return sid - num_std_strings; } static unsigned int unoffset_sid (unsigned int sid) { return sid - num_std_strings; }
}; };
struct cff1_sub_table_offsets_t : cff_sub_table_offsets_t struct cff1_sub_table_info_t : cff_sub_table_info_t
{ {
cff1_sub_table_offsets_t () cff1_sub_table_info_t ()
: cff_sub_table_offsets_t (), : cff_sub_table_info_t (),
nameIndexOffset (0), encoding_link (0),
encodingOffset (0) charset_link (0)
{ {
stringIndexInfo.init ();
charsetInfo.init ();
privateDictInfo.init (); privateDictInfo.init ();
} }
unsigned int nameIndexOffset; objidx_t encoding_link;
table_info_t stringIndexInfo; objidx_t charset_link;
unsigned int encodingOffset;
table_info_t charsetInfo;
table_info_t privateDictInfo; table_info_t privateDictInfo;
}; };
@ -117,13 +113,13 @@ struct cff1_top_dict_values_mod_t : cff1_top_dict_values_t
struct top_dict_modifiers_t struct top_dict_modifiers_t
{ {
top_dict_modifiers_t (const cff1_sub_table_offsets_t &offsets_, top_dict_modifiers_t (const cff1_sub_table_info_t &info_,
const unsigned int (&nameSIDs_)[name_dict_values_t::ValCount]) const unsigned int (&nameSIDs_)[name_dict_values_t::ValCount])
: offsets (offsets_), : info (info_),
nameSIDs (nameSIDs_) nameSIDs (nameSIDs_)
{} {}
const cff1_sub_table_offsets_t &offsets; const cff1_sub_table_info_t &info;
const unsigned int (&nameSIDs)[name_dict_values_t::ValCount]; const unsigned int (&nameSIDs)[name_dict_values_t::ValCount];
}; };
@ -139,22 +135,20 @@ struct cff1_top_dict_op_serializer_t : cff_top_dict_op_serializer_t<cff1_top_dic
switch (op) switch (op)
{ {
case OpCode_charset: case OpCode_charset:
return_trace (FontDict::serialize_offset4_op(c, op, mod.offsets.charsetInfo.offset)); if (mod.info.charset_link)
return_trace (FontDict::serialize_link4_op(c, op, mod.info.charset_link, whence_t::Absolute));
else
goto fall_back;
case OpCode_Encoding: case OpCode_Encoding:
return_trace (FontDict::serialize_offset4_op(c, op, mod.offsets.encodingOffset)); if (mod.info.encoding_link)
return_trace (FontDict::serialize_link4_op(c, op, mod.info.encoding_link, whence_t::Absolute));
else
goto fall_back;
case OpCode_Private: case OpCode_Private:
{ return_trace (UnsizedByteStr::serialize_int2 (c, mod.info.privateDictInfo.size) &&
if (unlikely (!UnsizedByteStr::serialize_int2 (c, mod.offsets.privateDictInfo.size))) Dict::serialize_link4_op (c, op, mod.info.privateDictInfo.link, whence_t::Absolute));
return_trace (false);
if (unlikely (!UnsizedByteStr::serialize_int4 (c, mod.offsets.privateDictInfo.offset)))
return_trace (false);
HBUINT8 *p = c->allocate_size<HBUINT8> (1);
if (unlikely (p == nullptr)) return_trace (false);
*p = OpCode_Private;
}
break;
case OpCode_version: case OpCode_version:
case OpCode_Notice: case OpCode_Notice:
@ -180,69 +174,20 @@ struct cff1_top_dict_op_serializer_t : cff_top_dict_op_serializer_t<cff1_top_dic
UnsizedByteStr::serialize_int2 (c, mod.nameSIDs[name_dict_values_t::ordering]) && UnsizedByteStr::serialize_int2 (c, mod.nameSIDs[name_dict_values_t::ordering]) &&
copy_opstr (c, supp_op)); copy_opstr (c, supp_op));
} }
fall_back:
default: default:
return_trace (cff_top_dict_op_serializer_t<cff1_top_dict_val_t>::serialize (c, opstr, mod.offsets)); return_trace (cff_top_dict_op_serializer_t<cff1_top_dict_val_t>::serialize (c, opstr, mod.info));
} }
return_trace (true); return_trace (true);
} }
unsigned int calculate_serialized_size (const cff1_top_dict_val_t &opstr) const
{
op_code_t op = opstr.op;
switch (op)
{
case OpCode_charset:
case OpCode_Encoding:
return OpCode_Size (OpCode_longintdict) + 4 + OpCode_Size (op);
case OpCode_Private:
return OpCode_Size (OpCode_longintdict) + 4 + OpCode_Size (OpCode_shortint) + 2 + OpCode_Size (OpCode_Private);
case OpCode_version:
case OpCode_Notice:
case OpCode_Copyright:
case OpCode_FullName:
case OpCode_FamilyName:
case OpCode_Weight:
case OpCode_PostScript:
case OpCode_BaseFontName:
case OpCode_FontName:
return OpCode_Size (OpCode_shortint) + 2 + OpCode_Size (op);
case OpCode_ROS:
return ((OpCode_Size (OpCode_shortint) + 2) * 2) + (opstr.str.length - opstr.last_arg_offset)/* supplement + op */;
default:
return cff_top_dict_op_serializer_t<cff1_top_dict_val_t>::calculate_serialized_size (opstr);
}
}
};
struct font_dict_values_mod_t
{
void init (const cff1_font_dict_values_t *base_,
unsigned int fontName_,
const table_info_t &privateDictInfo_)
{
base = base_;
fontName = fontName_;
privateDictInfo = privateDictInfo_;
}
unsigned get_count () const { return base->get_count (); }
const op_str_t &operator [] (unsigned int i) const { return (*base)[i]; }
const cff1_font_dict_values_t *base;
table_info_t privateDictInfo;
unsigned int fontName;
}; };
struct cff1_font_dict_op_serializer_t : cff_font_dict_op_serializer_t struct cff1_font_dict_op_serializer_t : cff_font_dict_op_serializer_t
{ {
bool serialize (hb_serialize_context_t *c, bool serialize (hb_serialize_context_t *c,
const op_str_t &opstr, const op_str_t &opstr,
const font_dict_values_mod_t &mod) const const cff1_font_dict_values_mod_t &mod) const
{ {
TRACE_SERIALIZE (this); TRACE_SERIALIZE (this);
@ -252,14 +197,6 @@ struct cff1_font_dict_op_serializer_t : cff_font_dict_op_serializer_t
return_trace (SUPER::serialize (c, opstr, mod.privateDictInfo)); return_trace (SUPER::serialize (c, opstr, mod.privateDictInfo));
} }
unsigned int calculate_serialized_size (const op_str_t &opstr) const
{
if (opstr.op == OpCode_FontName)
return OpCode_Size (OpCode_shortint) + 2 + OpCode_Size (OpCode_FontName);
else
return SUPER::calculate_serialized_size (opstr);
}
private: private:
typedef cff_font_dict_op_serializer_t SUPER; typedef cff_font_dict_op_serializer_t SUPER;
}; };
@ -425,8 +362,7 @@ struct cff1_subr_subsetter_t : subr_subsetter_t<cff1_subr_subsetter_t, CFF1Subrs
struct cff_subset_plan { struct cff_subset_plan {
cff_subset_plan () cff_subset_plan ()
: final_size (0), : info (),
offsets (),
orig_fdcount (0), orig_fdcount (0),
subset_fdcount (1), subset_fdcount (1),
subset_fdselect_format (0), subset_fdselect_format (0),
@ -466,7 +402,7 @@ struct cff_subset_plan {
sidmap.fini (); sidmap.fini ();
} }
unsigned int plan_subset_encoding (const OT::cff1::accelerator_subset_t &acc, hb_subset_plan_t *plan) void plan_subset_encoding (const OT::cff1::accelerator_subset_t &acc, hb_subset_plan_t *plan)
{ {
const Encoding *encoding = acc.encoding; const Encoding *encoding = acc.encoding;
unsigned int size0, size1, supp_size; unsigned int size0, size1, supp_size;
@ -525,14 +461,9 @@ struct cff_subset_plan {
subset_enc_format = 0; subset_enc_format = 0;
else else
subset_enc_format = 1; subset_enc_format = 1;
return Encoding::calculate_serialized_size (
subset_enc_format,
subset_enc_format? subset_enc_code_ranges.length: subset_enc_num_codes,
subset_enc_supp_codes.length);
} }
unsigned int plan_subset_charset (const OT::cff1::accelerator_subset_t &acc, hb_subset_plan_t *plan) void plan_subset_charset (const OT::cff1::accelerator_subset_t &acc, hb_subset_plan_t *plan)
{ {
unsigned int size0, size_ranges; unsigned int size0, size_ranges;
hb_codepoint_t sid, last_sid = CFF_UNDEF_CODE; hb_codepoint_t sid, last_sid = CFF_UNDEF_CODE;
@ -574,10 +505,6 @@ struct cff_subset_plan {
subset_charset_format = 1; subset_charset_format = 1;
else else
subset_charset_format = 2; subset_charset_format = 2;
return Charset::calculate_serialized_size (
subset_charset_format,
subset_charset_format? subset_charset_ranges.length: plan->num_output_glyphs ());
} }
bool collect_sids_in_dicts (const OT::cff1::accelerator_subset_t &acc) bool collect_sids_in_dicts (const OT::cff1::accelerator_subset_t &acc)
@ -609,7 +536,6 @@ struct cff_subset_plan {
hb_codepoint_t old_glyph; hb_codepoint_t old_glyph;
if (!plan->old_gid_for_new_gid (0, &old_glyph) || (old_glyph != 0)) return false; if (!plan->old_gid_for_new_gid (0, &old_glyph) || (old_glyph != 0)) return false;
final_size = 0;
num_glyphs = plan->num_output_glyphs (); num_glyphs = plan->num_output_glyphs ();
orig_fdcount = acc.fdCount; orig_fdcount = acc.fdCount;
drop_hints = plan->drop_hints; drop_hints = plan->drop_hints;
@ -630,13 +556,6 @@ struct cff_subset_plan {
subset_charset = gid_renum || !acc.is_predef_charset (); subset_charset = gid_renum || !acc.is_predef_charset ();
subset_encoding = !acc.is_CID() && !acc.is_predef_encoding (); subset_encoding = !acc.is_CID() && !acc.is_predef_encoding ();
/* CFF header */
final_size += OT::cff1::static_size;
/* Name INDEX */
offsets.nameIndexOffset = final_size;
final_size += acc.nameIndex->get_size ();
/* top dict INDEX */ /* top dict INDEX */
{ {
/* Add encoding/charset to a (copy of) top dict as necessary */ /* Add encoding/charset to a (copy of) top dict as necessary */
@ -650,15 +569,6 @@ struct cff_subset_plan {
if (need_to_add_set) if (need_to_add_set)
topdict_mod.add_op (OpCode_charset); topdict_mod.add_op (OpCode_charset);
} }
offsets.topDictInfo.offset = final_size;
cff1_top_dict_op_serializer_t topSzr;
unsigned int topDictSize = TopDict::calculate_serialized_size (topdict_mod, topSzr);
offsets.topDictInfo.offSize = calcOffSize(topDictSize);
if (unlikely (offsets.topDictInfo.offSize > 4))
return false;
final_size += CFF1IndexOf<TopDict>::calculate_serialized_size<cff1_top_dict_values_mod_t>
(offsets.topDictInfo.offSize,
&topdict_mod, 1, topdict_sizes, topSzr);
} }
/* Determine re-mapping of font index as fdmap among other info */ /* Determine re-mapping of font index as fdmap among other info */
@ -668,7 +578,7 @@ struct cff_subset_plan {
orig_fdcount, orig_fdcount,
*acc.fdSelect, *acc.fdSelect,
subset_fdcount, subset_fdcount,
offsets.FDSelectInfo.size, info.fd_select.size,
subset_fdselect_format, subset_fdselect_format,
subset_fdselect_ranges, subset_fdselect_ranges,
fdmap))) fdmap)))
@ -684,19 +594,12 @@ struct cff_subset_plan {
return false; return false;
if (unlikely (sidmap.get_population () > 0x8000)) /* assumption: a dict won't reference that many strings */ if (unlikely (sidmap.get_population () > 0x8000)) /* assumption: a dict won't reference that many strings */
return false; return false;
if (subset_charset)
offsets.charsetInfo.size = plan_subset_charset (acc, plan); if (subset_charset) plan_subset_charset (acc, plan);
topdict_mod.reassignSIDs (sidmap); topdict_mod.reassignSIDs (sidmap);
} }
/* String INDEX */
{
offsets.stringIndexInfo.offset = final_size;
offsets.stringIndexInfo.size = acc.stringIndex->calculate_serialized_size (offsets.stringIndexInfo.offSize, sidmap);
final_size += offsets.stringIndexInfo.size;
}
if (desubroutinize) if (desubroutinize)
{ {
/* Flatten global & local subrs */ /* Flatten global & local subrs */
@ -704,9 +607,6 @@ struct cff_subset_plan {
flattener(acc, plan); flattener(acc, plan);
if (!flattener.flatten (subset_charstrings)) if (!flattener.flatten (subset_charstrings))
return false; return false;
/* no global/local subroutines */
offsets.globalSubrsInfo.size = CFF1Subrs::calculate_serialized_size (1, 0, 0);
} }
else else
{ {
@ -723,131 +623,49 @@ struct cff_subset_plan {
if (!subr_subsetter.encode_globalsubrs (subset_globalsubrs)) if (!subr_subsetter.encode_globalsubrs (subset_globalsubrs))
return false; return false;
/* global subrs */
unsigned int dataSize = subset_globalsubrs.total_size ();
offsets.globalSubrsInfo.offSize = calcOffSize (dataSize);
if (unlikely (offsets.globalSubrsInfo.offSize > 4))
return false;
offsets.globalSubrsInfo.size = CFF1Subrs::calculate_serialized_size (offsets.globalSubrsInfo.offSize, subset_globalsubrs.length, dataSize);
/* local subrs */ /* local subrs */
if (!offsets.localSubrsInfos.resize (orig_fdcount))
return false;
if (!subset_localsubrs.resize (orig_fdcount)) if (!subset_localsubrs.resize (orig_fdcount))
return false; return false;
for (unsigned int fd = 0; fd < orig_fdcount; fd++) for (unsigned int fd = 0; fd < orig_fdcount; fd++)
{ {
subset_localsubrs[fd].init (); subset_localsubrs[fd].init ();
offsets.localSubrsInfos[fd].init ();
if (fdmap.has (fd)) if (fdmap.has (fd))
{ {
if (!subr_subsetter.encode_localsubrs (fd, subset_localsubrs[fd])) if (!subr_subsetter.encode_localsubrs (fd, subset_localsubrs[fd]))
return false; return false;
unsigned int dataSize = subset_localsubrs[fd].total_size ();
if (dataSize > 0)
{
offsets.localSubrsInfos[fd].offset = final_size;
offsets.localSubrsInfos[fd].offSize = calcOffSize (dataSize);
if (unlikely (offsets.localSubrsInfos[fd].offSize > 4))
return false;
offsets.localSubrsInfos[fd].size = CFF1Subrs::calculate_serialized_size (offsets.localSubrsInfos[fd].offSize, subset_localsubrs[fd].length, dataSize);
} }
} }
} }
}
/* global subrs */
offsets.globalSubrsInfo.offset = final_size;
final_size += offsets.globalSubrsInfo.size;
/* Encoding */ /* Encoding */
if (!subset_encoding) if (subset_encoding)
offsets.encodingOffset = acc.topDict.EncodingOffset; plan_subset_encoding (acc, plan);
else
{
offsets.encodingOffset = final_size;
final_size += plan_subset_encoding (acc, plan);
}
/* Charset */
if (!subset_charset && acc.is_predef_charset ())
offsets.charsetInfo.offset = acc.topDict.CharsetOffset;
else
offsets.charsetInfo.offset = final_size;
final_size += offsets.charsetInfo.size;
/* FDSelect */
if (acc.fdSelect != &Null(CFF1FDSelect))
{
offsets.FDSelectInfo.offset = final_size;
final_size += offsets.FDSelectInfo.size;
}
/* FDArray (FDIndex) */
if (acc.fdArray != &Null(CFF1FDArray)) {
offsets.FDArrayInfo.offset = final_size;
cff1_font_dict_op_serializer_t fontSzr;
unsigned int dictsSize = 0;
for (unsigned int i = 0; i < acc.fontDicts.length; i++)
if (fdmap.has (i))
dictsSize += FontDict::calculate_serialized_size (acc.fontDicts[i], fontSzr);
offsets.FDArrayInfo.offSize = calcOffSize (dictsSize);
if (unlikely (offsets.FDArrayInfo.offSize > 4))
return false;
final_size += CFF1Index::calculate_serialized_size (offsets.FDArrayInfo.offSize, subset_fdcount, dictsSize);
}
/* CharStrings */
{
offsets.charStringsInfo.offset = final_size;
unsigned int dataSize = subset_charstrings.total_size ();
offsets.charStringsInfo.offSize = calcOffSize (dataSize);
if (unlikely (offsets.charStringsInfo.offSize > 4))
return false;
final_size += CFF1CharStrings::calculate_serialized_size (offsets.charStringsInfo.offSize, plan->num_output_glyphs (), dataSize);
}
/* private dicts & local subrs */ /* private dicts & local subrs */
offsets.privateDictInfo.offset = final_size;
for (unsigned int i = 0; i < orig_fdcount; i++)
{
if (fdmap.has (i))
{
bool has_localsubrs = offsets.localSubrsInfos[i].size > 0;
cff_private_dict_op_serializer_t privSzr (desubroutinize, plan->drop_hints);
unsigned int priv_size = PrivateDict::calculate_serialized_size (acc.privateDicts[i], privSzr, has_localsubrs);
table_info_t privInfo = { final_size, priv_size, 0 };
font_dict_values_mod_t fontdict_mod;
if (!acc.is_CID ()) if (!acc.is_CID ())
fontdict_mod.init ( &Null(cff1_font_dict_values_t), CFF_UNDEF_SID, privInfo ); fontdicts_mod.push (cff1_font_dict_values_mod_t ());
else else
fontdict_mod.init ( &acc.fontDicts[i], sidmap[acc.fontDicts[i].fontName], privInfo );
fontdicts_mod.push (fontdict_mod);
final_size += privInfo.size;
if (!plan->desubroutinize && has_localsubrs)
{ {
offsets.localSubrsInfos[i].offset = final_size; + hb_iter (acc.fontDicts)
final_size += offsets.localSubrsInfos[i].size; | hb_filter ([&] (const cff1_font_dict_values_t &_)
{ return fdmap.has (&_ - &acc.fontDicts[0]); } )
| hb_map ([&] (const cff1_font_dict_values_t &_)
{
cff1_font_dict_values_mod_t mod;
mod.init (&_, sidmap[_.fontName]);
return mod;
})
| hb_sink (fontdicts_mod)
;
} }
}
}
if (!acc.is_CID ())
offsets.privateDictInfo = fontdicts_mod[0].privateDictInfo;
return ((subset_charstrings.length == plan->num_output_glyphs ()) return ((subset_charstrings.length == plan->num_output_glyphs ())
&& (fontdicts_mod.length == subset_fdcount)); && (fontdicts_mod.length == subset_fdcount));
} }
unsigned int get_final_size () const { return final_size; }
unsigned int final_size;
hb_vector_t<unsigned int> topdict_sizes; hb_vector_t<unsigned int> topdict_sizes;
cff1_top_dict_values_mod_t topdict_mod; cff1_top_dict_values_mod_t topdict_mod;
cff1_sub_table_offsets_t offsets; cff1_sub_table_info_t info;
unsigned int num_glyphs; unsigned int num_glyphs;
unsigned int orig_fdcount; unsigned int orig_fdcount;
@ -862,7 +680,7 @@ struct cff_subset_plan {
str_buff_vec_t subset_charstrings; str_buff_vec_t subset_charstrings;
str_buff_vec_t subset_globalsubrs; str_buff_vec_t subset_globalsubrs;
hb_vector_t<str_buff_vec_t> subset_localsubrs; hb_vector_t<str_buff_vec_t> subset_localsubrs;
hb_vector_t<font_dict_values_mod_t> fontdicts_mod; hb_vector_t<cff1_font_dict_values_mod_t> fontdicts_mod;
bool drop_hints; bool drop_hints;
@ -883,11 +701,119 @@ struct cff_subset_plan {
bool desubroutinize; bool desubroutinize;
}; };
static inline bool _write_cff1 (hb_serialize_context_t *c, static bool _serialize_cff1 (hb_serialize_context_t *c,
const cff_subset_plan &plan, cff_subset_plan &plan,
const OT::cff1::accelerator_subset_t &acc, const OT::cff1::accelerator_subset_t &acc,
unsigned int num_glyphs) unsigned int num_glyphs)
{ {
/* private dicts & local subrs */
for (int i = (int)acc.privateDicts.length; --i >= 0 ;)
{
if (plan.fdmap.has (i))
{
objidx_t subrs_link = 0;
if (plan.subset_localsubrs[i].length > 0)
{
c->push ();
CFF1Subrs *dest = c->start_embed <CFF1Subrs> ();
if (unlikely (dest == nullptr)) return false;
if (unlikely (!dest->serialize (c, plan.subset_localsubrs[i]))) return false;
subrs_link = c->pop_pack ();
}
c->push ();
PrivateDict *pd = c->start_embed<PrivateDict> ();
if (unlikely (pd == nullptr)) return false;
bool result;
cff_private_dict_op_serializer_t privSzr (plan.desubroutinize, plan.drop_hints);
/* N.B. local subrs immediately follows its corresponding private dict. i.e., subr offset == private dict size */
result = pd->serialize (c, acc.privateDicts[i], privSzr, subrs_link);
if (unlikely (!result)) return false;
unsigned fd = plan.fdmap[i];
plan.fontdicts_mod[fd].privateDictInfo.size = c->length ();
plan.fontdicts_mod[fd].privateDictInfo.link = c->pop_pack ();
}
}
if (!acc.is_CID ())
plan.info.privateDictInfo = plan.fontdicts_mod[0].privateDictInfo;
/* CharStrings */
{
c->push ();
CFF1CharStrings *cs = c->start_embed<CFF1CharStrings> ();
if (unlikely (cs == nullptr)) return false;
if (unlikely (!cs->serialize (c, plan.subset_charstrings))) return false;
plan.info.char_strings_link = c->pop_pack ();
}
/* FDArray (FD Index) */
if (acc.fdArray != &Null(CFF1FDArray))
{
c->push ();
CFF1FDArray *fda = c->start_embed<CFF1FDArray> ();
if (unlikely (fda == nullptr)) return false;
cff1_font_dict_op_serializer_t fontSzr;
auto it = + hb_zip (+ hb_iter (plan.fontdicts_mod), + hb_iter (plan.fontdicts_mod));
if (unlikely (!fda->serialize (c, it, fontSzr))) return false;
plan.info.fd_array_link = c->pop_pack (false);
}
/* FDSelect */
if (acc.fdSelect != &Null(CFF1FDSelect))
{
c->push ();
if (unlikely (!hb_serialize_cff_fdselect (c, num_glyphs, *acc.fdSelect, acc.fdCount,
plan.subset_fdselect_format, plan.info.fd_select.size,
plan.subset_fdselect_ranges))) return false;
plan.info.fd_select.link = c->pop_pack ();
}
/* Charset */
if (plan.subset_charset)
{
c->push ();
Charset *dest = c->start_embed<Charset> ();
if (unlikely (dest == nullptr)) return false;
if (unlikely (!dest->serialize (c,
plan.subset_charset_format,
plan.num_glyphs,
plan.subset_charset_ranges))) return false;
plan.info.charset_link = c->pop_pack ();
}
/* Encoding */
if (plan.subset_encoding)
{
Encoding *dest = c->start_embed<Encoding> ();
if (unlikely (dest == nullptr)) return false;
c->push ();
if (unlikely (!dest->serialize (c,
plan.subset_enc_format,
plan.subset_enc_num_codes,
plan.subset_enc_code_ranges,
plan.subset_enc_supp_codes))) return false;
plan.info.encoding_link = c->pop_pack ();
}
/* global subrs */
{
c->push ();
CFF1Subrs *dest = c->start_embed <CFF1Subrs> ();
if (unlikely (dest == nullptr)) return false;
if (unlikely (!dest->serialize (c, plan.subset_globalsubrs))) return false;
c->pop_pack ();
}
/* String INDEX */
{
c->push ();
CFF1StringIndex *dest = c->start_embed<CFF1StringIndex> ();
if (unlikely (dest == nullptr)) return false;
if (unlikely (!dest->serialize (c, *acc.stringIndex, plan.sidmap))) return false;
c->pop_pack ();
}
OT::cff1 *cff = c->allocate_min<OT::cff1> (); OT::cff1 *cff = c->allocate_min<OT::cff1> ();
if (unlikely (!cff)) if (unlikely (!cff))
return false; return false;
@ -899,170 +825,29 @@ static inline bool _write_cff1 (hb_serialize_context_t *c,
cff->offSize = 4; /* unused? */ cff->offSize = 4; /* unused? */
/* name INDEX */ /* name INDEX */
{ if (unlikely (!(*acc.nameIndex).copy (c))) return false;
assert (cff->nameIndex == (unsigned) (c->head - c->start));
CFF1NameIndex *dest = c->start_embed<CFF1NameIndex> ();
if (unlikely (dest == nullptr)) return false;
if (unlikely (!dest->serialize (c, *acc.nameIndex)))
{
DEBUG_MSG (SUBSET, nullptr, "failed to serialize CFF name INDEX");
return false;
}
}
/* top dict INDEX */ /* top dict INDEX */
{ {
assert (plan.offsets.topDictInfo.offset == (unsigned) (c->head - c->start)); /* serialize singleton TopDict */
CFF1IndexOf<TopDict> *dest = c->start_embed< CFF1IndexOf<TopDict>> (); c->push ();
if (dest == nullptr) return false; TopDict *top = c->start_embed<TopDict> ();
if (top == nullptr) return false;
cff1_top_dict_op_serializer_t topSzr; cff1_top_dict_op_serializer_t topSzr;
top_dict_modifiers_t modifier (plan.offsets, plan.topDictModSIDs); top_dict_modifiers_t modifier (plan.info, plan.topDictModSIDs);
if (unlikely (!dest->serialize (c, plan.offsets.topDictInfo.offSize, if (unlikely (!top->serialize (c, plan.topdict_mod, topSzr, modifier)))
&plan.topdict_mod, 1,
plan.topdict_sizes, topSzr, modifier)))
{
DEBUG_MSG (SUBSET, nullptr, "failed to serialize CFF top dict");
return false; return false;
} unsigned top_size = c->length ();
} c->pop_pack (false);
/* String INDEX */ /* serialize INDEX header for above */
{ CFF1Index *dest = c->start_embed<CFF1Index> ();
assert (plan.offsets.stringIndexInfo.offset == (unsigned) (c->head - c->start)); if (dest == nullptr) return false;
CFF1StringIndex *dest = c->start_embed<CFF1StringIndex> (); return dest->serialize_header (c, hb_iter (hb_array_t<unsigned> (&top_size, 1)));
if (unlikely (dest == nullptr)) return false;
if (unlikely (!dest->serialize (c, *acc.stringIndex, plan.offsets.stringIndexInfo.offSize, plan.sidmap)))
{
DEBUG_MSG (SUBSET, nullptr, "failed to serialize CFF string INDEX");
return false;
} }
}
/* global subrs */
{
assert (plan.offsets.globalSubrsInfo.offset != 0);
assert (plan.offsets.globalSubrsInfo.offset == (unsigned) (c->head - c->start));
CFF1Subrs *dest = c->start_embed <CFF1Subrs> ();
if (unlikely (dest == nullptr)) return false;
if (unlikely (!dest->serialize (c, plan.offsets.globalSubrsInfo.offSize, plan.subset_globalsubrs)))
{
DEBUG_MSG (SUBSET, nullptr, "failed to serialize global subroutines");
return false;
}
}
/* Encoding */
if (plan.subset_encoding)
{
assert (plan.offsets.encodingOffset == (unsigned) (c->head - c->start));
Encoding *dest = c->start_embed<Encoding> ();
if (unlikely (dest == nullptr)) return false;
if (unlikely (!dest->serialize (c,
plan.subset_enc_format,
plan.subset_enc_num_codes,
plan.subset_enc_code_ranges,
plan.subset_enc_supp_codes)))
{
DEBUG_MSG (SUBSET, nullptr, "failed to serialize Encoding");
return false;
}
}
/* Charset */
if (plan.subset_charset)
{
assert (plan.offsets.charsetInfo.offset == (unsigned) (c->head - c->start));
Charset *dest = c->start_embed<Charset> ();
if (unlikely (dest == nullptr)) return false;
if (unlikely (!dest->serialize (c,
plan.subset_charset_format,
plan.num_glyphs,
plan.subset_charset_ranges)))
{
DEBUG_MSG (SUBSET, nullptr, "failed to serialize Charset");
return false;
}
}
/* FDSelect */
if (acc.fdSelect != &Null(CFF1FDSelect))
{
assert (plan.offsets.FDSelectInfo.offset == (unsigned) (c->head - c->start));
if (unlikely (!hb_serialize_cff_fdselect (c, num_glyphs, *acc.fdSelect, acc.fdCount,
plan.subset_fdselect_format, plan.offsets.FDSelectInfo.size,
plan.subset_fdselect_ranges)))
{
DEBUG_MSG (SUBSET, nullptr, "failed to serialize CFF subset FDSelect");
return false;
}
}
/* FDArray (FD Index) */
if (acc.fdArray != &Null(CFF1FDArray))
{
assert (plan.offsets.FDArrayInfo.offset == (unsigned) (c->head - c->start));
CFF1FDArray *fda = c->start_embed<CFF1FDArray> ();
if (unlikely (fda == nullptr)) return false;
cff1_font_dict_op_serializer_t fontSzr;
if (unlikely (!fda->serialize (c, plan.offsets.FDArrayInfo.offSize,
plan.fontdicts_mod,
fontSzr)))
{
DEBUG_MSG (SUBSET, nullptr, "failed to serialize CFF FDArray");
return false;
}
}
/* CharStrings */
{
assert (plan.offsets.charStringsInfo.offset == (unsigned) (c->head - c->start));
CFF1CharStrings *cs = c->start_embed<CFF1CharStrings> ();
if (unlikely (cs == nullptr)) return false;
if (unlikely (!cs->serialize (c, plan.offsets.charStringsInfo.offSize, plan.subset_charstrings)))
{
DEBUG_MSG (SUBSET, nullptr, "failed to serialize CFF CharStrings");
return false;
}
}
/* private dicts & local subrs */
assert (plan.offsets.privateDictInfo.offset == (unsigned) (c->head - c->start));
for (unsigned int i = 0; i < acc.privateDicts.length; i++)
{
if (plan.fdmap.has (i))
{
PrivateDict *pd = c->start_embed<PrivateDict> ();
if (unlikely (pd == nullptr)) return false;
unsigned int priv_size = plan.fontdicts_mod[plan.fdmap[i]].privateDictInfo.size;
bool result;
cff_private_dict_op_serializer_t privSzr (plan.desubroutinize, plan.drop_hints);
/* N.B. local subrs immediately follows its corresponding private dict. i.e., subr offset == private dict size */
unsigned int subroffset = (plan.offsets.localSubrsInfos[i].size > 0) ? priv_size : 0;
result = pd->serialize (c, acc.privateDicts[i], privSzr, subroffset);
if (unlikely (!result))
{
DEBUG_MSG (SUBSET, nullptr, "failed to serialize CFF Private Dict[%d]", i);
return false;
}
if (plan.offsets.localSubrsInfos[i].size > 0)
{
CFF1Subrs *dest = c->start_embed <CFF1Subrs> ();
if (unlikely (dest == nullptr)) return false;
if (unlikely (!dest->serialize (c, plan.offsets.localSubrsInfos[i].offSize, plan.subset_localsubrs[i])))
{
DEBUG_MSG (SUBSET, nullptr, "failed to serialize local subroutines");
return false;
}
}
}
}
return true;
} }
static inline bool static bool
_hb_subset_cff1 (const OT::cff1::accelerator_subset_t &acc, _hb_subset_cff1 (const OT::cff1::accelerator_subset_t &acc,
hb_subset_context_t *c) hb_subset_context_t *c)
{ {
@ -1074,12 +859,7 @@ _hb_subset_cff1 (const OT::cff1::accelerator_subset_t &acc,
return false; return false;
} }
if (unlikely (!_write_cff1 (c->serializer, cff_plan, acc, c->plan->num_output_glyphs ()))) { return _serialize_cff1 (c->serializer, cff_plan, acc, c->plan->num_output_glyphs ());
DEBUG_MSG(SUBSET, nullptr, "Failed to write a subset cff.");
return false;
}
return true;
} }
/** /**

332
src/hb-subset-cff2.cc
View File

@ -38,43 +38,31 @@
using namespace CFF; using namespace CFF;
struct cff2_sub_table_offsets_t : cff_sub_table_offsets_t struct cff2_sub_table_info_t : cff_sub_table_info_t
{ {
cff2_sub_table_offsets_t () cff2_sub_table_info_t ()
: cff_sub_table_offsets_t (), : cff_sub_table_info_t (),
varStoreOffset (0) var_store_link (0)
{} {}
unsigned int varStoreOffset; objidx_t var_store_link;
}; };
struct cff2_top_dict_op_serializer_t : cff_top_dict_op_serializer_t<> struct cff2_top_dict_op_serializer_t : cff_top_dict_op_serializer_t<>
{ {
bool serialize (hb_serialize_context_t *c, bool serialize (hb_serialize_context_t *c,
const op_str_t &opstr, const op_str_t &opstr,
const cff2_sub_table_offsets_t &offsets) const const cff2_sub_table_info_t &info) const
{ {
TRACE_SERIALIZE (this); TRACE_SERIALIZE (this);
switch (opstr.op) switch (opstr.op)
{ {
case OpCode_vstore: case OpCode_vstore:
return_trace (FontDict::serialize_offset4_op(c, opstr.op, offsets.varStoreOffset)); return_trace (FontDict::serialize_link4_op(c, opstr.op, info.var_store_link));
default: default:
return_trace (cff_top_dict_op_serializer_t<>::serialize (c, opstr, offsets)); return_trace (cff_top_dict_op_serializer_t<>::serialize (c, opstr, info));
}
}
unsigned int calculate_serialized_size (const op_str_t &opstr) const
{
switch (opstr.op)
{
case OpCode_vstore:
return OpCode_Size (OpCode_longintdict) + 4 + OpCode_Size (opstr.op);
default:
return cff_top_dict_op_serializer_t<>::calculate_serialized_size (opstr);
} }
} }
}; };
@ -246,9 +234,9 @@ struct cff2_subr_subsetter_t : subr_subsetter_t<cff2_subr_subsetter_t, CFF2Subrs
struct cff2_subset_plan { struct cff2_subset_plan {
cff2_subset_plan () cff2_subset_plan ()
: final_size (0), : orig_fdcount (0),
orig_fdcount (0),
subset_fdcount(1), subset_fdcount(1),
subset_fdselect_size (0),
subset_fdselect_format (0), subset_fdselect_format (0),
drop_hints (false), drop_hints (false),
desubroutinize (false) desubroutinize (false)
@ -258,7 +246,6 @@ struct cff2_subset_plan {
subset_charstrings.init (); subset_charstrings.init ();
subset_globalsubrs.init (); subset_globalsubrs.init ();
subset_localsubrs.init (); subset_localsubrs.init ();
privateDictInfos.init ();
} }
~cff2_subset_plan () ~cff2_subset_plan ()
@ -268,28 +255,16 @@ struct cff2_subset_plan {
subset_charstrings.fini_deep (); subset_charstrings.fini_deep ();
subset_globalsubrs.fini_deep (); subset_globalsubrs.fini_deep ();
subset_localsubrs.fini_deep (); subset_localsubrs.fini_deep ();
privateDictInfos.fini ();
} }
bool create (const OT::cff2::accelerator_subset_t &acc, bool create (const OT::cff2::accelerator_subset_t &acc,
hb_subset_plan_t *plan) hb_subset_plan_t *plan)
{ {
final_size = 0;
orig_fdcount = acc.fdArray->count; orig_fdcount = acc.fdArray->count;
drop_hints = plan->drop_hints; drop_hints = plan->drop_hints;
desubroutinize = plan->desubroutinize; desubroutinize = plan->desubroutinize;
/* CFF2 header */
final_size += OT::cff2::static_size;
/* top dict */
{
cff2_top_dict_op_serializer_t topSzr;
offsets.topDictInfo.size = TopDict::calculate_serialized_size (acc.topDict, topSzr);
final_size += offsets.topDictInfo.size;
}
if (desubroutinize) if (desubroutinize)
{ {
/* Flatten global & local subrs */ /* Flatten global & local subrs */
@ -297,9 +272,6 @@ struct cff2_subset_plan {
flattener(acc, plan); flattener(acc, plan);
if (!flattener.flatten (subset_charstrings)) if (!flattener.flatten (subset_charstrings))
return false; return false;
/* no global/local subroutines */
offsets.globalSubrsInfo.size = CFF2Subrs::calculate_serialized_size (1, 0, 0);
} }
else else
{ {
@ -316,115 +288,41 @@ struct cff2_subset_plan {
if (!subr_subsetter.encode_globalsubrs (subset_globalsubrs)) if (!subr_subsetter.encode_globalsubrs (subset_globalsubrs))
return false; return false;
/* global subrs */
unsigned int dataSize = subset_globalsubrs.total_size ();
offsets.globalSubrsInfo.offSize = calcOffSize (dataSize);
offsets.globalSubrsInfo.size = CFF2Subrs::calculate_serialized_size (offsets.globalSubrsInfo.offSize, subset_globalsubrs.length, dataSize);
/* local subrs */ /* local subrs */
if (!offsets.localSubrsInfos.resize (orig_fdcount))
return false;
if (!subset_localsubrs.resize (orig_fdcount)) if (!subset_localsubrs.resize (orig_fdcount))
return false; return false;
for (unsigned int fd = 0; fd < orig_fdcount; fd++) for (unsigned int fd = 0; fd < orig_fdcount; fd++)
{ {
subset_localsubrs[fd].init (); subset_localsubrs[fd].init ();
offsets.localSubrsInfos[fd].init ();
if (!subr_subsetter.encode_localsubrs (fd, subset_localsubrs[fd])) if (!subr_subsetter.encode_localsubrs (fd, subset_localsubrs[fd]))
return false; return false;
unsigned int dataSize = subset_localsubrs[fd].total_size ();
if (dataSize > 0)
{
offsets.localSubrsInfos[fd].offset = final_size;
offsets.localSubrsInfos[fd].offSize = calcOffSize (dataSize);
offsets.localSubrsInfos[fd].size = CFF2Subrs::calculate_serialized_size (offsets.localSubrsInfos[fd].offSize, subset_localsubrs[fd].length, dataSize);
} }
} }
}
/* global subrs */
offsets.globalSubrsInfo.offset = final_size;
final_size += offsets.globalSubrsInfo.size;
/* variation store */
if (acc.varStore != &Null(CFF2VariationStore))
{
offsets.varStoreOffset = final_size;
final_size += acc.varStore->get_size ();
}
/* FDSelect */ /* FDSelect */
if (acc.fdSelect != &Null(CFF2FDSelect)) if (acc.fdSelect != &Null(CFF2FDSelect))
{ {
offsets.FDSelectInfo.offset = final_size;
if (unlikely (!hb_plan_subset_cff_fdselect (plan, if (unlikely (!hb_plan_subset_cff_fdselect (plan,
orig_fdcount, orig_fdcount,
*(const FDSelect *)acc.fdSelect, *(const FDSelect *)acc.fdSelect,
subset_fdcount, subset_fdcount,
offsets.FDSelectInfo.size, subset_fdselect_size,
subset_fdselect_format, subset_fdselect_format,
subset_fdselect_ranges, subset_fdselect_ranges,
fdmap))) fdmap)))
return false; return false;
final_size += offsets.FDSelectInfo.size;
} }
else else
fdmap.identity (1); fdmap.identity (1);
/* FDArray (FDIndex) */
{
offsets.FDArrayInfo.offset = final_size;
cff_font_dict_op_serializer_t fontSzr;
unsigned int dictsSize = 0;
for (unsigned int i = 0; i < acc.fontDicts.length; i++)
if (fdmap.has (i))
dictsSize += FontDict::calculate_serialized_size (acc.fontDicts[i], fontSzr);
offsets.FDArrayInfo.offSize = calcOffSize (dictsSize);
final_size += CFF2Index::calculate_serialized_size (offsets.FDArrayInfo.offSize, subset_fdcount, dictsSize);
}
/* CharStrings */
{
offsets.charStringsInfo.offset = final_size;
unsigned int dataSize = subset_charstrings.total_size ();
offsets.charStringsInfo.offSize = calcOffSize (dataSize);
final_size += CFF2CharStrings::calculate_serialized_size (offsets.charStringsInfo.offSize, plan->num_output_glyphs (), dataSize);
}
/* private dicts & local subrs */
offsets.privateDictsOffset = final_size;
for (unsigned int i = 0; i < orig_fdcount; i++)
{
if (fdmap.has (i))
{
bool has_localsubrs = offsets.localSubrsInfos[i].size > 0;
cff_private_dict_op_serializer_t privSzr (desubroutinize, drop_hints);
unsigned int priv_size = PrivateDict::calculate_serialized_size (acc.privateDicts[i], privSzr, has_localsubrs);
table_info_t privInfo = { final_size, priv_size, 0 };
privateDictInfos.push (privInfo);
final_size += privInfo.size;
if (!plan->desubroutinize && has_localsubrs)
{
offsets.localSubrsInfos[i].offset = final_size;
final_size += offsets.localSubrsInfos[i].size;
}
}
}
return true; return true;
} }
unsigned int get_final_size () const { return final_size; } cff2_sub_table_info_t info;
unsigned int final_size;
cff2_sub_table_offsets_t offsets;
unsigned int orig_fdcount; unsigned int orig_fdcount;
unsigned int subset_fdcount; unsigned int subset_fdcount;
unsigned int subset_fdselect_size;
unsigned int subset_fdselect_format; unsigned int subset_fdselect_format;
hb_vector_t<code_pair_t> subset_fdselect_ranges; hb_vector_t<code_pair_t> subset_fdselect_ranges;
@ -433,20 +331,94 @@ struct cff2_subset_plan {
str_buff_vec_t subset_charstrings; str_buff_vec_t subset_charstrings;
str_buff_vec_t subset_globalsubrs; str_buff_vec_t subset_globalsubrs;
hb_vector_t<str_buff_vec_t> subset_localsubrs; hb_vector_t<str_buff_vec_t> subset_localsubrs;
hb_vector_t<table_info_t> privateDictInfos;
bool drop_hints; bool drop_hints;
bool desubroutinize; bool desubroutinize;
}; };
static inline bool _write_cff2 (hb_serialize_context_t *c, static bool _serialize_cff2 (hb_serialize_context_t *c,
const cff2_subset_plan &plan, cff2_subset_plan &plan,
const OT::cff2::accelerator_subset_t &acc, const OT::cff2::accelerator_subset_t &acc,
unsigned int num_glyphs) unsigned int num_glyphs)
{ {
/* private dicts & local subrs */
hb_vector_t<table_info_t> private_dict_infos;
private_dict_infos.resize (plan.subset_fdcount);
for (int i = (int)acc.privateDicts.length; --i >= 0 ;)
{
if (plan.fdmap.has (i))
{
objidx_t subrs_link = 0;
if (plan.subset_localsubrs[i].length > 0)
{
c->push ();
CFF2Subrs *dest = c->start_embed <CFF2Subrs> ();
if (unlikely (dest == nullptr)) return false;
if (unlikely (!dest->serialize (c, plan.subset_localsubrs[i]))) return false;
subrs_link = c->pop_pack ();
}
c->push ();
PrivateDict *pd = c->start_embed<PrivateDict> ();
if (unlikely (pd == nullptr)) return false;
bool result;
cff_private_dict_op_serializer_t privSzr (plan.desubroutinize, plan.drop_hints);
result = pd->serialize (c, acc.privateDicts[i], privSzr, subrs_link);
if (unlikely (!result)) return false;
unsigned fd = plan.fdmap[i];
private_dict_infos[fd].size = c->length ();
private_dict_infos[fd].link = c->pop_pack ();
}
}
/* CharStrings */
{
c->push ();
CFF2CharStrings *cs = c->start_embed<CFF2CharStrings> ();
if (unlikely (cs == nullptr)) return false;
if (unlikely (!cs->serialize (c, plan.subset_charstrings))) return false;
plan.info.char_strings_link = c->pop_pack ();
}
/* FDSelect */
if (acc.fdSelect != &Null(CFF2FDSelect))
{
c->push ();
if (unlikely (!hb_serialize_cff_fdselect (c, num_glyphs, *(const FDSelect *)acc.fdSelect, plan.orig_fdcount,
plan.subset_fdselect_format, plan.subset_fdselect_size,
plan.subset_fdselect_ranges))) return false;
plan.info.fd_select.link = c->pop_pack ();
}
/* FDArray (FD Index) */
{
c->push ();
CFF2FDArray *fda = c->start_embed<CFF2FDArray> ();
if (unlikely (fda == nullptr)) return false;
cff_font_dict_op_serializer_t fontSzr;
auto it =
+ hb_zip (+ hb_iter (acc.fontDicts)
| hb_filter ([&] (const cff2_font_dict_values_t &_)
{ return plan.fdmap.has (&_ - &acc.fontDicts[0]); }),
hb_iter (private_dict_infos))
;
if (unlikely (!fda->serialize (c, it, fontSzr))) return false;
plan.info.fd_array_link = c->pop_pack ();
}
/* variation store */
if (acc.varStore != &Null(CFF2VariationStore))
{
c->push ();
CFF2VariationStore *dest = c->start_embed<CFF2VariationStore> ();
if (unlikely (dest == nullptr)) return false;
if (unlikely (!dest->serialize (c, acc.varStore))) return false;
plan.info.var_store_link = c->pop_pack ();
}
OT::cff2 *cff2 = c->allocate_min<OT::cff2> (); OT::cff2 *cff2 = c->allocate_min<OT::cff2> ();
if (unlikely (!cff2)) if (unlikely (!cff2)) return false;
return false;
/* header */ /* header */
cff2->version.major = 0x02; cff2->version.major = 0x02;
@ -455,135 +427,28 @@ static inline bool _write_cff2 (hb_serialize_context_t *c,
/* top dict */ /* top dict */
{ {
assert (cff2->topDict == (unsigned) (c->head - c->start));
cff2->topDictSize = plan.offsets.topDictInfo.size;
TopDict &dict = cff2 + cff2->topDict; TopDict &dict = cff2 + cff2->topDict;
cff2_top_dict_op_serializer_t topSzr; cff2_top_dict_op_serializer_t topSzr;
if (unlikely (!dict.serialize (c, acc.topDict, topSzr, plan.offsets))) if (unlikely (!dict.serialize (c, acc.topDict, topSzr, plan.info))) return false;
{ cff2->topDictSize = c->head - (const char *)&dict;
DEBUG_MSG (SUBSET, nullptr, "failed to serialize CFF2 top dict");
return false;
}
} }
/* global subrs */ /* global subrs */
{ {
assert (cff2->topDict + plan.offsets.topDictInfo.size == (unsigned) (c->head - c->start));
CFF2Subrs *dest = c->start_embed <CFF2Subrs> (); CFF2Subrs *dest = c->start_embed <CFF2Subrs> ();
if (unlikely (dest == nullptr)) return false; if (unlikely (dest == nullptr)) return false;
if (unlikely (!dest->serialize (c, plan.offsets.globalSubrsInfo.offSize, plan.subset_globalsubrs))) return dest->serialize (c, plan.subset_globalsubrs);
{
DEBUG_MSG (SUBSET, nullptr, "failed to serialize global subroutines");
return false;
} }
}
/* variation store */
if (acc.varStore != &Null(CFF2VariationStore))
{
assert (plan.offsets.varStoreOffset == (unsigned) (c->head - c->start));
CFF2VariationStore *dest = c->start_embed<CFF2VariationStore> ();
if (unlikely (!dest->serialize (c, acc.varStore)))
{
DEBUG_MSG (SUBSET, nullptr, "failed to serialize CFF2 Variation Store");
return false;
}
}
/* FDSelect */
if (acc.fdSelect != &Null(CFF2FDSelect))
{
assert (plan.offsets.FDSelectInfo.offset == (unsigned) (c->head - c->start));
if (unlikely (!hb_serialize_cff_fdselect (c, num_glyphs, *(const FDSelect *)acc.fdSelect, acc.fdArray->count,
plan.subset_fdselect_format, plan.offsets.FDSelectInfo.size,
plan.subset_fdselect_ranges)))
{
DEBUG_MSG (SUBSET, nullptr, "failed to serialize CFF2 subset FDSelect");
return false;
}
}
/* FDArray (FD Index) */
{
assert (plan.offsets.FDArrayInfo.offset == (unsigned) (c->head - c->start));
CFF2FDArray *fda = c->start_embed<CFF2FDArray> ();
if (unlikely (fda == nullptr)) return false;
cff_font_dict_op_serializer_t fontSzr;
if (unlikely (!fda->serialize (c, plan.offsets.FDArrayInfo.offSize,
acc.fontDicts, plan.subset_fdcount, plan.fdmap,
fontSzr, plan.privateDictInfos)))
{
DEBUG_MSG (SUBSET, nullptr, "failed to serialize CFF2 FDArray");
return false;
}
}
/* CharStrings */
{
assert (plan.offsets.charStringsInfo.offset == (unsigned) (c->head - c->start));
CFF2CharStrings *cs = c->start_embed<CFF2CharStrings> ();
if (unlikely (cs == nullptr)) return false;
if (unlikely (!cs->serialize (c, plan.offsets.charStringsInfo.offSize, plan.subset_charstrings)))
{
DEBUG_MSG (SUBSET, nullptr, "failed to serialize CFF2 CharStrings");
return false;
}
}
/* private dicts & local subrs */
assert (plan.offsets.privateDictsOffset == (unsigned) (c->head - c->start));
for (unsigned int i = 0; i < acc.privateDicts.length; i++)
{
if (plan.fdmap.has (i))
{
PrivateDict *pd = c->start_embed<PrivateDict> ();
if (unlikely (pd == nullptr)) return false;
unsigned int priv_size = plan.privateDictInfos[plan.fdmap[i]].size;
bool result;
cff_private_dict_op_serializer_t privSzr (plan.desubroutinize, plan.drop_hints);
/* N.B. local subrs immediately follows its corresponding private dict. i.e., subr offset == private dict size */
unsigned int subroffset = (plan.offsets.localSubrsInfos[i].size > 0) ? priv_size : 0;
result = pd->serialize (c, acc.privateDicts[i], privSzr, subroffset);
if (unlikely (!result))
{
DEBUG_MSG (SUBSET, nullptr, "failed to serialize CFF Private Dict[%d]", i);
return false;
}
if (plan.offsets.localSubrsInfos[i].size > 0)
{
CFF2Subrs *dest = c->start_embed <CFF2Subrs> ();
if (unlikely (dest == nullptr)) return false;
if (unlikely (!dest->serialize (c, plan.offsets.localSubrsInfos[i].offSize, plan.subset_localsubrs[i])))
{
DEBUG_MSG (SUBSET, nullptr, "failed to serialize local subroutines");
return false;
}
}
}
}
return true;
} }
static inline bool static bool
_hb_subset_cff2 (const OT::cff2::accelerator_subset_t &acc, _hb_subset_cff2 (const OT::cff2::accelerator_subset_t &acc,
hb_subset_context_t *c) hb_subset_context_t *c)
{ {
cff2_subset_plan cff2_plan; cff2_subset_plan cff2_plan;
if (unlikely (!cff2_plan.create (acc, c->plan))) if (unlikely (!cff2_plan.create (acc, c->plan))) return false;
{ return _serialize_cff2 (c->serializer, cff2_plan, acc, c->plan->num_output_glyphs ());
DEBUG_MSG(SUBSET, nullptr, "Failed to generate a cff2 subsetting plan.");
return false;
}
if (unlikely (!_write_cff2 (c->serializer, cff2_plan, acc, c->plan->num_output_glyphs ()))) {
DEBUG_MSG(SUBSET, nullptr, "Failed to write a subset cff2.");
return false;
}
return true;
} }
/** /**
@ -606,5 +471,4 @@ hb_subset_cff2 (hb_subset_context_t *c)
return result; return result;
} }
#endif #endif

BIN
test/api/fonts/AdobeVFPrototype.ac.nohints.otf
View File

Binary file not shown.

BIN
test/api/fonts/AdobeVFPrototype.ac.nosubrs.nohints.otf
View File

Binary file not shown.

BIN
test/api/fonts/cff1_expert.2D,F6E9,FB00.otf
View File

Binary file not shown.