Chiebot-Mirror
/
harfbuzz
mirror of https://github.com/harfbuzz/harfbuzz.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

renamed hb_map2_t to hb_bimap_h in its own .hh

Browse Source
pull/1939/head
Michiharu Ariza 6 years ago
parent d102c7a652
commit 9168b32a1b
2 changed files with 211 additions and 77 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 211
      src/hb-ot-gvar-table.hh
  2. 77
      src/hb-ot-layout-common.hh

211
src/hb-ot-gvar-table.hh
Unescape View File

@ -0,0 +1,211 @@
/*
* Copyright © 2018 Adobe 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.
*
* Adobe Author(s): Michiharu Ariza
*/
#ifndef HB_OT_GVAR_TABLE_HH
#define HB_OT_GVAR_TABLE_HH
#include "hb-open-type.hh"
/*
* gvar -- Glyph Variation Table
* https://docs.microsoft.com/en-us/typography/opentype/spec/gvar
*/
#define HB_OT_TAG_gvar HB_TAG('g','v','a','r')
namespace OT {
struct Tupple
{
bool sanitize (hb_sanitize_context_t *c, unsigned int axis_count) const
{
TRACE_SANITIZE (this);
return_trace (coords.sanitize (c, axis_count, this));s
}
protected:
UnsizedArrayOf<F2DOT14>
coords;
public:
DEFINE_SIZE_ARRAY (0, coords);
};
struct TupleVarHeader
{
HBUINT16 varDataSize;
HBUINT16 tupleIndex;
/* Tuple peakTuple */
/* Tuple intermediateStartTuple */
/* Tuple intermediateEndTuple */
};
struct GlyphVarData
{
HBUINT16 tupleVarCount;
OffsetTo<HBUINT8>
data;
UnsizedArrayOf<TupleVarHeader>
tupleVarHeaders;
};
struct gvar
{
static constexpr hb_tag_t tableTag = HB_OT_TAG_gvar;
bool has_data () const { return version.to_int (); }
int get_y_origin (hb_codepoint_t glyph) const
{
unsigned int i;
if (!vertYOrigins.bfind (glyph, &i))
return defaultVertOriginY;
return vertYOrigins[i].vertOriginY;
}
bool _subset (const hb_subset_plan_t *plan HB_UNUSED,
const gvar *vorg_table,
const hb_vector_t<VertOriginMetric> &subset_metrics,
unsigned int dest_sz,
void *dest) const
{
hb_serialize_context_t c (dest, dest_sz);
gvar *subset_table = c.start_serialize<gvar> ();
if (unlikely (!c.extend_min (*subset_table)))
return false;
subset_table->version.major.set (1);
subset_table->version.minor.set (0);
subset_table->defaultVertOriginY.set (vorg_table->defaultVertOriginY);
subset_table->vertYOrigins.len.set (subset_metrics.length);
bool success = true;
if (subset_metrics.length > 0)
{
unsigned int size = VertOriginMetric::static_size * subset_metrics.length;
VertOriginMetric *metrics = c.allocate_size<VertOriginMetric> (size);
if (likely (metrics != nullptr))
memcpy (metrics, &subset_metrics[0], size);
else
success = false;
}
c.end_serialize ();
return success;
}
bool subset (hb_subset_plan_t *plan) const
{
hb_blob_t *vorg_blob = hb_sanitize_context_t().reference_table<gvar> (plan->source);
const gvar *vorg_table = vorg_blob->as<gvar> ();
/* count the number of glyphs to be included in the subset table */
hb_vector_t<VertOriginMetric> subset_metrics;
subset_metrics.init ();
hb_codepoint_t old_glyph = HB_SET_VALUE_INVALID;
unsigned int i = 0;
while (i < vertYOrigins.len
&& plan->glyphset ()->next (&old_glyph))
{
while (old_glyph > vertYOrigins[i].glyph)
{
i++;
if (i >= vertYOrigins.len)
break;
}
if (old_glyph == vertYOrigins[i].glyph)
{
hb_codepoint_t new_glyph;
if (plan->new_gid_for_old_gid (old_glyph, &new_glyph))
{
VertOriginMetric *metrics = subset_metrics.push ();
metrics->glyph.set (new_glyph);
metrics->vertOriginY.set (vertYOrigins[i].vertOriginY);
}
}
}
/* alloc the new table */
unsigned int dest_sz = gvar::min_size + VertOriginMetric::static_size * subset_metrics.length;
void *dest = (void *) malloc (dest_sz);
if (unlikely (!dest))
{
subset_metrics.fini ();
hb_blob_destroy (vorg_blob);
return false;
}
/* serialize the new table */
if (!_subset (plan, vorg_table, subset_metrics, dest_sz, dest))
{
subset_metrics.fini ();
free (dest);
hb_blob_destroy (vorg_blob);
return false;
}
hb_blob_t *result = hb_blob_create ((const char *)dest,
dest_sz,
HB_MEMORY_MODE_READONLY,
dest,
free);
bool success = plan->add_table (HB_OT_TAG_gvar, result);
hb_blob_destroy (result);
subset_metrics.fini ();
hb_blob_destroy (vorg_blob);
return success;
}
bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
return_trace (c->check_struct (this) &&
version.major == 1 &&
glyphVarDataArray.sanitize (c));
}
protected:
FixedVersion<> version; /* Version of gvar table. Set to 0x00010000u. */
HBUINT16 axisCount;
HBUINT16 sharedTupleCount;
LOffsetTo<Tupple> sharedTuples;
HBUINT16 glyphCount;
HBUINT16 flags;
LOffsetTo<GlyphVarData>
glyphVarDataArray;
/* OffsetTo<GlyphVariationData> glyphVariationDataOffsets */
public:
DEFINE_SIZE_ARRAY(8, vertYOrigins);
};
} /* namespace OT */
#endif /* HB_OT_GVAR_TABLE_HH */

77
src/hb-ot-layout-common.hh
Unescape View File

@ -1587,83 +1587,6 @@ static inline void ClassDef_serialize (hb_serialize_context_t *c,
hb_array_t<const HBUINT16> klasses)
{ c->start_embed<ClassDef> ()->serialize (c, glyphs, klasses); }
/* Bi-directional map.
* nww ids are assigned incrementally & contiguous; old ids may be random & sparse
* all mappings unique & no duplicate */
struct hb_map2_t
{
hb_map2_t () { init (); }
~hb_map2_t () { fini (); }
void init (void)
{
count = 0;
old_to_new_map.init ();
new_to_old_map.init ();
}
void fini (void)
{
old_to_new_map.fini ();
new_to_old_map.fini ();
}
bool has (hb_codepoint_t _old) const { return old_to_new_map.has (_old); }
hb_codepoint_t add (hb_codepoint_t _old)
{
hb_codepoint_t _new = old_to_new_map[_old];
if (_new == HB_MAP_VALUE_INVALID)
{
_new = count++;
old_to_new_map.set (_old, _new);
new_to_old_map.set (_new, _old);
}
return _new;
}
/* returns HB_MAP_VALUE_INVALID if unmapped */
hb_codepoint_t operator [] (hb_codepoint_t _old) const { return old_to_new (_old); }
hb_codepoint_t old_to_new (hb_codepoint_t _old) const { return old_to_new_map[_old]; }
hb_codepoint_t new_to_old (hb_codepoint_t _new) const { return new_to_old_map[_new]; }
bool identity (unsigned int size)
{
hb_codepoint_t i;
old_to_new_map.clear ();
new_to_old_map.clear ();
for (i = 0; i < size; i++)
{
old_to_new_map.set (i, i);
new_to_old_map.set (i, i);
}
count = i;
return old_to_new_map.successful && new_to_old_map.successful;
}
/* Optional: after finished adding all mappings in a random order,
* reassign new ids to old ids so that they are in the same order. */
void reorder (void)
{
hb_codepoint_t _new = 0;
for (hb_codepoint_t _old = 0; _new < count; _old++)
{
if (!has (_old)) continue;
new_to_old_map.set (_new, _old);
old_to_new_map.set (_old, _new);
_old++;
_new++;
}
}
unsigned int get_count () const { return count; }
protected:
unsigned int count;
hb_map_t old_to_new_map;
hb_map_t new_to_old_map;
};
/*
* Item Variation Store
*/

Write Preview
Loading…
Cancel
Save