mirror of
https://github.com/harfbuzz/harfbuzz.git
synced 2025-04-06 22:15:04 +00:00
Move CFF Index types to open-type
https://github.com/harfbuzz/boring-expansion-spec/blob/main/VARC.md#cff2indexof
This commit is contained in:
Behdad Esfahbod
parent
cf3e88e17f
commit
fa9dc530fc
4 changed files with 245 additions and 244 deletions
|
|
@ -1244,6 +1244,251 @@ struct VarSizedBinSearchArrayOf
|
|||
};
|
||||
|
||||
|
||||
/* CFF INDEX */
|
||||
|
||||
template <typename COUNT>
|
||||
struct CFFIndex
|
||||
{
|
||||
struct length_f_t
|
||||
{
|
||||
template <typename Iterable,
|
||||
hb_requires (hb_is_iterable (Iterable))>
|
||||
unsigned operator () (const Iterable &_) const { return hb_len (hb_iter (_)); }
|
||||
|
||||
unsigned operator () (unsigned _) const { return _; }
|
||||
}
|
||||
HB_FUNCOBJ (length_f);
|
||||
|
||||
unsigned int offset_array_size () const
|
||||
{ return offSize * (count + 1); }
|
||||
|
||||
template <typename Iterable,
|
||||
hb_requires (hb_is_iterable (Iterable))>
|
||||
bool serialize (hb_serialize_context_t *c,
|
||||
const Iterable &iterable,
|
||||
const unsigned *p_data_size = nullptr,
|
||||
unsigned min_off_size = 0)
|
||||
{
|
||||
TRACE_SERIALIZE (this);
|
||||
unsigned data_size;
|
||||
if (p_data_size)
|
||||
data_size = *p_data_size;
|
||||
else
|
||||
total_size (iterable, &data_size);
|
||||
|
||||
auto it = hb_iter (iterable);
|
||||
if (unlikely (!serialize_header (c, +it, data_size, min_off_size))) return_trace (false);
|
||||
unsigned char *ret = c->allocate_size<unsigned char> (data_size, false);
|
||||
if (unlikely (!ret)) return_trace (false);
|
||||
for (const auto &_ : +it)
|
||||
{
|
||||
unsigned len = _.length;
|
||||
if (!len)
|
||||
continue;
|
||||
if (len <= 1)
|
||||
{
|
||||
*ret++ = *_.arrayZ;
|
||||
continue;
|
||||
}
|
||||
hb_memcpy (ret, _.arrayZ, len);
|
||||
ret += len;
|
||||
}
|
||||
return_trace (true);
|
||||
}
|
||||
|
||||
template <typename Iterator,
|
||||
hb_requires (hb_is_iterator (Iterator))>
|
||||
bool serialize_header (hb_serialize_context_t *c,
|
||||
Iterator it,
|
||||
unsigned data_size,
|
||||
unsigned min_off_size = 0)
|
||||
{
|
||||
TRACE_SERIALIZE (this);
|
||||
|
||||
unsigned off_size = (hb_bit_storage (data_size + 1) + 7) / 8;
|
||||
off_size = hb_max(min_off_size, off_size);
|
||||
|
||||
/* serialize CFFIndex header */
|
||||
if (unlikely (!c->extend_min (this))) return_trace (false);
|
||||
this->count = hb_len (it);
|
||||
if (!this->count) return_trace (true);
|
||||
if (unlikely (!c->extend (this->offSize))) return_trace (false);
|
||||
this->offSize = off_size;
|
||||
if (unlikely (!c->allocate_size<HBUINT8> (off_size * (this->count + 1), false)))
|
||||
return_trace (false);
|
||||
|
||||
/* serialize indices */
|
||||
unsigned int offset = 1;
|
||||
if (HB_OPTIMIZE_SIZE_VAL)
|
||||
{
|
||||
unsigned int i = 0;
|
||||
for (const auto &_ : +it)
|
||||
{
|
||||
set_offset_at (i++, offset);
|
||||
offset += length_f (_);
|
||||
}
|
||||
set_offset_at (i, offset);
|
||||
}
|
||||
else
|
||||
switch (off_size)
|
||||
{
|
||||
case 1:
|
||||
{
|
||||
HBUINT8 *p = (HBUINT8 *) offsets;
|
||||
for (const auto &_ : +it)
|
||||
{
|
||||
*p++ = offset;
|
||||
offset += length_f (_);
|
||||
}
|
||||
*p = offset;
|
||||
}
|
||||
break;
|
||||
case 2:
|
||||
{
|
||||
HBUINT16 *p = (HBUINT16 *) offsets;
|
||||
for (const auto &_ : +it)
|
||||
{
|
||||
*p++ = offset;
|
||||
offset += length_f (_);
|
||||
}
|
||||
*p = offset;
|
||||
}
|
||||
break;
|
||||
case 3:
|
||||
{
|
||||
HBUINT24 *p = (HBUINT24 *) offsets;
|
||||
for (const auto &_ : +it)
|
||||
{
|
||||
*p++ = offset;
|
||||
offset += length_f (_);
|
||||
}
|
||||
*p = offset;
|
||||
}
|
||||
break;
|
||||
case 4:
|
||||
{
|
||||
HBUINT32 *p = (HBUINT32 *) offsets;
|
||||
for (const auto &_ : +it)
|
||||
{
|
||||
*p++ = offset;
|
||||
offset += length_f (_);
|
||||
}
|
||||
*p = offset;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
assert (offset == data_size + 1);
|
||||
return_trace (true);
|
||||
}
|
||||
|
||||
template <typename Iterable,
|
||||
hb_requires (hb_is_iterable (Iterable))>
|
||||
static unsigned total_size (const Iterable &iterable, unsigned *data_size = nullptr, unsigned min_off_size = 0)
|
||||
{
|
||||
auto it = + hb_iter (iterable);
|
||||
if (!it)
|
||||
{
|
||||
if (data_size) *data_size = 0;
|
||||
return min_size;
|
||||
}
|
||||
|
||||
unsigned total = 0;
|
||||
for (const auto &_ : +it)
|
||||
total += length_f (_);
|
||||
|
||||
if (data_size) *data_size = total;
|
||||
|
||||
unsigned off_size = (hb_bit_storage (total + 1) + 7) / 8;
|
||||
off_size = hb_max(min_off_size, off_size);
|
||||
|
||||
return min_size + HBUINT8::static_size + (hb_len (it) + 1) * off_size + total;
|
||||
}
|
||||
|
||||
void set_offset_at (unsigned int index, unsigned int offset)
|
||||
{
|
||||
assert (index <= count);
|
||||
|
||||
unsigned int size = offSize;
|
||||
const HBUINT8 *p = offsets;
|
||||
switch (size)
|
||||
{
|
||||
case 1: ((HBUINT8 *) p)[index] = offset; break;
|
||||
case 2: ((HBUINT16 *) p)[index] = offset; break;
|
||||
case 3: ((HBUINT24 *) p)[index] = offset; break;
|
||||
case 4: ((HBUINT32 *) p)[index] = offset; break;
|
||||
default: return;
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
unsigned int offset_at (unsigned int index) const
|
||||
{
|
||||
assert (index <= count);
|
||||
|
||||
unsigned int size = offSize;
|
||||
const HBUINT8 *p = offsets;
|
||||
switch (size)
|
||||
{
|
||||
case 1: return ((HBUINT8 *) p)[index];
|
||||
case 2: return ((HBUINT16 *) p)[index];
|
||||
case 3: return ((HBUINT24 *) p)[index];
|
||||
case 4: return ((HBUINT32 *) p)[index];
|
||||
default: return 0;
|
||||
}
|
||||
}
|
||||
|
||||
const unsigned char *data_base () const
|
||||
{ return (const unsigned char *) this + min_size + offSize.static_size - 1 + offset_array_size (); }
|
||||
public:
|
||||
|
||||
hb_ubytes_t operator [] (unsigned int index) const
|
||||
{
|
||||
if (unlikely (index >= count)) return hb_ubytes_t ();
|
||||
_hb_compiler_memory_r_barrier ();
|
||||
unsigned offset0 = offset_at (index);
|
||||
unsigned offset1 = offset_at (index + 1);
|
||||
if (unlikely (offset1 < offset0 || offset1 > offset_at (count)))
|
||||
return hb_ubytes_t ();
|
||||
return hb_ubytes_t (data_base () + offset0, offset1 - offset0);
|
||||
}
|
||||
|
||||
unsigned int get_size () const
|
||||
{
|
||||
if (count)
|
||||
return min_size + offSize.static_size + offset_array_size () + (offset_at (count) - 1);
|
||||
return min_size; /* empty CFFIndex contains count only */
|
||||
}
|
||||
|
||||
bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
return_trace (likely (c->check_struct (this) &&
|
||||
hb_barrier () &&
|
||||
(count == 0 || /* empty INDEX */
|
||||
(count < count + 1u &&
|
||||
hb_barrier () &&
|
||||
c->check_struct (&offSize) && offSize >= 1 && offSize <= 4 &&
|
||||
c->check_array (offsets, offSize, count + 1u) &&
|
||||
c->check_array ((const HBUINT8*) data_base (), 1, offset_at (count))))));
|
||||
}
|
||||
|
||||
public:
|
||||
COUNT count; /* Number of object data. Note there are (count+1) offsets */
|
||||
private:
|
||||
HBUINT8 offSize; /* The byte size of each offset in the offsets array. */
|
||||
HBUINT8 offsets[HB_VAR_ARRAY];
|
||||
/* The array of (count + 1) offsets into objects array (1-base). */
|
||||
/* HBUINT8 data[HB_VAR_ARRAY]; Object data */
|
||||
public:
|
||||
DEFINE_SIZE_MIN (COUNT::static_size);
|
||||
};
|
||||
typedef CFFIndex<HBUINT16> CFF1Index;
|
||||
typedef CFFIndex<HBUINT32> CFF2Index;
|
||||
|
||||
|
||||
} /* namespace OT */
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -68,247 +68,6 @@ using str_buff_t = hb_vector_t<unsigned char>;
|
|||
using str_buff_vec_t = hb_vector_t<str_buff_t>;
|
||||
using glyph_to_sid_map_t = hb_vector_t<code_pair_t>;
|
||||
|
||||
struct length_f_t
|
||||
{
|
||||
template <typename Iterable,
|
||||
hb_requires (hb_is_iterable (Iterable))>
|
||||
unsigned operator () (const Iterable &_) const { return hb_len (hb_iter (_)); }
|
||||
|
||||
unsigned operator () (unsigned _) const { return _; }
|
||||
}
|
||||
HB_FUNCOBJ (length_f);
|
||||
|
||||
/* CFF INDEX */
|
||||
template <typename COUNT>
|
||||
struct CFFIndex
|
||||
{
|
||||
unsigned int offset_array_size () const
|
||||
{ return offSize * (count + 1); }
|
||||
|
||||
template <typename Iterable,
|
||||
hb_requires (hb_is_iterable (Iterable))>
|
||||
bool serialize (hb_serialize_context_t *c,
|
||||
const Iterable &iterable,
|
||||
const unsigned *p_data_size = nullptr,
|
||||
unsigned min_off_size = 0)
|
||||
{
|
||||
TRACE_SERIALIZE (this);
|
||||
unsigned data_size;
|
||||
if (p_data_size)
|
||||
data_size = *p_data_size;
|
||||
else
|
||||
total_size (iterable, &data_size);
|
||||
|
||||
auto it = hb_iter (iterable);
|
||||
if (unlikely (!serialize_header (c, +it, data_size, min_off_size))) return_trace (false);
|
||||
unsigned char *ret = c->allocate_size<unsigned char> (data_size, false);
|
||||
if (unlikely (!ret)) return_trace (false);
|
||||
for (const auto &_ : +it)
|
||||
{
|
||||
unsigned len = _.length;
|
||||
if (!len)
|
||||
continue;
|
||||
if (len <= 1)
|
||||
{
|
||||
*ret++ = *_.arrayZ;
|
||||
continue;
|
||||
}
|
||||
hb_memcpy (ret, _.arrayZ, len);
|
||||
ret += len;
|
||||
}
|
||||
return_trace (true);
|
||||
}
|
||||
|
||||
template <typename Iterator,
|
||||
hb_requires (hb_is_iterator (Iterator))>
|
||||
bool serialize_header (hb_serialize_context_t *c,
|
||||
Iterator it,
|
||||
unsigned data_size,
|
||||
unsigned min_off_size = 0)
|
||||
{
|
||||
TRACE_SERIALIZE (this);
|
||||
|
||||
unsigned off_size = (hb_bit_storage (data_size + 1) + 7) / 8;
|
||||
off_size = hb_max(min_off_size, off_size);
|
||||
|
||||
/* serialize CFFIndex header */
|
||||
if (unlikely (!c->extend_min (this))) return_trace (false);
|
||||
this->count = hb_len (it);
|
||||
if (!this->count) return_trace (true);
|
||||
if (unlikely (!c->extend (this->offSize))) return_trace (false);
|
||||
this->offSize = off_size;
|
||||
if (unlikely (!c->allocate_size<HBUINT8> (off_size * (this->count + 1), false)))
|
||||
return_trace (false);
|
||||
|
||||
/* serialize indices */
|
||||
unsigned int offset = 1;
|
||||
if (HB_OPTIMIZE_SIZE_VAL)
|
||||
{
|
||||
unsigned int i = 0;
|
||||
for (const auto &_ : +it)
|
||||
{
|
||||
set_offset_at (i++, offset);
|
||||
offset += length_f (_);
|
||||
}
|
||||
set_offset_at (i, offset);
|
||||
}
|
||||
else
|
||||
switch (off_size)
|
||||
{
|
||||
case 1:
|
||||
{
|
||||
HBUINT8 *p = (HBUINT8 *) offsets;
|
||||
for (const auto &_ : +it)
|
||||
{
|
||||
*p++ = offset;
|
||||
offset += length_f (_);
|
||||
}
|
||||
*p = offset;
|
||||
}
|
||||
break;
|
||||
case 2:
|
||||
{
|
||||
HBUINT16 *p = (HBUINT16 *) offsets;
|
||||
for (const auto &_ : +it)
|
||||
{
|
||||
*p++ = offset;
|
||||
offset += length_f (_);
|
||||
}
|
||||
*p = offset;
|
||||
}
|
||||
break;
|
||||
case 3:
|
||||
{
|
||||
HBUINT24 *p = (HBUINT24 *) offsets;
|
||||
for (const auto &_ : +it)
|
||||
{
|
||||
*p++ = offset;
|
||||
offset += length_f (_);
|
||||
}
|
||||
*p = offset;
|
||||
}
|
||||
break;
|
||||
case 4:
|
||||
{
|
||||
HBUINT32 *p = (HBUINT32 *) offsets;
|
||||
for (const auto &_ : +it)
|
||||
{
|
||||
*p++ = offset;
|
||||
offset += length_f (_);
|
||||
}
|
||||
*p = offset;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
assert (offset == data_size + 1);
|
||||
return_trace (true);
|
||||
}
|
||||
|
||||
template <typename Iterable,
|
||||
hb_requires (hb_is_iterable (Iterable))>
|
||||
static unsigned total_size (const Iterable &iterable, unsigned *data_size = nullptr, unsigned min_off_size = 0)
|
||||
{
|
||||
auto it = + hb_iter (iterable);
|
||||
if (!it)
|
||||
{
|
||||
if (data_size) *data_size = 0;
|
||||
return min_size;
|
||||
}
|
||||
|
||||
unsigned total = 0;
|
||||
for (const auto &_ : +it)
|
||||
total += length_f (_);
|
||||
|
||||
if (data_size) *data_size = total;
|
||||
|
||||
unsigned off_size = (hb_bit_storage (total + 1) + 7) / 8;
|
||||
off_size = hb_max(min_off_size, off_size);
|
||||
|
||||
return min_size + HBUINT8::static_size + (hb_len (it) + 1) * off_size + total;
|
||||
}
|
||||
|
||||
void set_offset_at (unsigned int index, unsigned int offset)
|
||||
{
|
||||
assert (index <= count);
|
||||
|
||||
unsigned int size = offSize;
|
||||
const HBUINT8 *p = offsets;
|
||||
switch (size)
|
||||
{
|
||||
case 1: ((HBUINT8 *) p)[index] = offset; break;
|
||||
case 2: ((HBUINT16 *) p)[index] = offset; break;
|
||||
case 3: ((HBUINT24 *) p)[index] = offset; break;
|
||||
case 4: ((HBUINT32 *) p)[index] = offset; break;
|
||||
default: return;
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
unsigned int offset_at (unsigned int index) const
|
||||
{
|
||||
assert (index <= count);
|
||||
|
||||
unsigned int size = offSize;
|
||||
const HBUINT8 *p = offsets;
|
||||
switch (size)
|
||||
{
|
||||
case 1: return ((HBUINT8 *) p)[index];
|
||||
case 2: return ((HBUINT16 *) p)[index];
|
||||
case 3: return ((HBUINT24 *) p)[index];
|
||||
case 4: return ((HBUINT32 *) p)[index];
|
||||
default: return 0;
|
||||
}
|
||||
}
|
||||
|
||||
const unsigned char *data_base () const
|
||||
{ return (const unsigned char *) this + min_size + offSize.static_size - 1 + offset_array_size (); }
|
||||
public:
|
||||
|
||||
hb_ubytes_t operator [] (unsigned int index) const
|
||||
{
|
||||
if (unlikely (index >= count)) return hb_ubytes_t ();
|
||||
_hb_compiler_memory_r_barrier ();
|
||||
unsigned offset0 = offset_at (index);
|
||||
unsigned offset1 = offset_at (index + 1);
|
||||
if (unlikely (offset1 < offset0 || offset1 > offset_at (count)))
|
||||
return hb_ubytes_t ();
|
||||
return hb_ubytes_t (data_base () + offset0, offset1 - offset0);
|
||||
}
|
||||
|
||||
unsigned int get_size () const
|
||||
{
|
||||
if (count)
|
||||
return min_size + offSize.static_size + offset_array_size () + (offset_at (count) - 1);
|
||||
return min_size; /* empty CFFIndex contains count only */
|
||||
}
|
||||
|
||||
bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
return_trace (likely (c->check_struct (this) &&
|
||||
hb_barrier () &&
|
||||
(count == 0 || /* empty INDEX */
|
||||
(count < count + 1u &&
|
||||
hb_barrier () &&
|
||||
c->check_struct (&offSize) && offSize >= 1 && offSize <= 4 &&
|
||||
c->check_array (offsets, offSize, count + 1u) &&
|
||||
c->check_array ((const HBUINT8*) data_base (), 1, offset_at (count))))));
|
||||
}
|
||||
|
||||
public:
|
||||
COUNT count; /* Number of object data. Note there are (count+1) offsets */
|
||||
private:
|
||||
HBUINT8 offSize; /* The byte size of each offset in the offsets array. */
|
||||
HBUINT8 offsets[HB_VAR_ARRAY];
|
||||
/* The array of (count + 1) offsets into objects array (1-base). */
|
||||
/* HBUINT8 data[HB_VAR_ARRAY]; Object data */
|
||||
public:
|
||||
DEFINE_SIZE_MIN (COUNT::static_size);
|
||||
};
|
||||
|
||||
/* Top Dict, Font Dict, Private Dict */
|
||||
struct Dict : UnsizedByteStr
|
||||
{
|
||||
|
|
|
|||
|
|
@ -51,7 +51,6 @@ namespace CFF {
|
|||
enum EncodingID { StandardEncoding = 0, ExpertEncoding = 1 };
|
||||
enum CharsetID { ISOAdobeCharset = 0, ExpertCharset = 1, ExpertSubsetCharset = 2 };
|
||||
|
||||
typedef CFFIndex<HBUINT16> CFF1Index;
|
||||
typedef CFF1Index CFF1CharStrings;
|
||||
typedef Subrs<HBUINT16> CFF1Subrs;
|
||||
|
||||
|
|
|
|||
|
|
@ -40,8 +40,6 @@ namespace CFF {
|
|||
*/
|
||||
#define HB_OT_TAG_CFF2 HB_TAG('C','F','F','2')
|
||||
|
||||
typedef CFFIndex<HBUINT32> CFF2Index;
|
||||
|
||||
typedef CFF2Index CFF2CharStrings;
|
||||
typedef Subrs<HBUINT32> CFF2Subrs;
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue