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

[subset] Remove subset-glyf; want everything to point to new iter-based edition. Some of the code will resurface as impl builds out.

Browse Source
This commit is contained in:
rsheeter 2019-05-08 14:59:03 -07:00 committed by Rod Sheeter
parent 02d4d4f3e6
commit 240bc86e3a
5 changed files with 6 additions and 392 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/Makefile.sources
View File

@ -241,8 +241,6 @@ HB_SUBSET_sources = \
hb-subset-cff1.hh \
hb-subset-cff2.cc \
hb-subset-cff2.hh \
hb-subset-glyf.cc \
hb-subset-glyf.hh \
hb-subset-glyf.hh \
hb-subset-input.cc \
hb-subset-input.hh \

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

@ -21,7 +21,7 @@
* ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
* PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
*
* Google Author(s): Behdad Esfahbod
* Google Author(s): Behdad Esfahbod, Garret Reiger, Roderick Sheeter
*/
#ifndef HB_OT_GLYF_TABLE_HH
@ -29,7 +29,6 @@
#include "hb-open-type.hh"
#include "hb-ot-head-table.hh"
#include "hb-subset-glyf.hh"
namespace OT {
@ -111,10 +110,14 @@ struct glyf
+ hb_iota (c->plan->num_output_glyphs ())
| hb_map ([&] (hb_codepoint_t new_gid) {
unsigned int start_offset = 0, end_offset = 0;
// simple case: empty glyph
hb_codepoint_t old_gid;
// should never happen, ALL old gids should be mapped
if (!c->plan->old_gid_for_new_gid (new_gid, &old_gid)) return hb_pair (start_offset, end_offset);
// being empty is perfectly normal
if (c->plan->is_empty_glyph (old_gid)) return hb_pair (start_offset, end_offset);
if (unlikely (!(glyf.get_offsets (old_gid, &start_offset, &end_offset) &&
glyf.remove_padding (start_offset, &end_offset))))
{

346
src/hb-subset-glyf.cc
View File

@ -1,346 +0,0 @@
/*
* Copyright © 2018 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): Garret Rieger, Roderick Sheeter
*/
#include "hb-open-type.hh"
#include "hb-ot-glyf-table.hh"
#include "hb-set.h"
#include "hb-subset-glyf.hh"
struct loca_data_t
{
bool is_short;
void *data;
unsigned int size;
inline bool
_write_loca_entry (unsigned int id,
unsigned int offset)
{
unsigned int entry_size = is_short ? sizeof (OT::HBUINT16) : sizeof (OT::HBUINT32);
if ((id + 1) * entry_size <= size)
{
if (is_short) {
((OT::HBUINT16*) data) [id] = offset / 2;
} else {
((OT::HBUINT32*) data) [id] = offset;
}
return true;
}
// Offset was not written because the write is out of bounds.
DEBUG_MSG(SUBSET,
nullptr,
"WARNING: Attempted to write an out of bounds loca entry at index %d. Loca size is %d.",
id,
size);
return false;
}
};
/*
* If hints are being dropped find the range which in glyf at which
* the hinting instructions are located. Add them to the instruction_ranges
* vector.
*/
static bool
_add_instructions_range (const OT::glyf::accelerator_t &glyf,
hb_codepoint_t glyph_id,
unsigned int glyph_start_offset,
unsigned int glyph_end_offset,
bool drop_hints,
hb_vector_t<unsigned int> *instruction_ranges /* OUT */)
{
if (!instruction_ranges->resize (instruction_ranges->length + 2))
{
DEBUG_MSG(SUBSET, nullptr, "Failed to resize instruction_ranges.");
return false;
}
unsigned int *instruction_start = &(*instruction_ranges)[instruction_ranges->length - 2];
*instruction_start = 0;
unsigned int *instruction_end = &(*instruction_ranges)[instruction_ranges->length - 1];
*instruction_end = 0;
if (drop_hints)
{
if (unlikely (!glyf.get_instruction_offsets (glyph_start_offset, glyph_end_offset,
instruction_start, instruction_end)))
{
DEBUG_MSG(SUBSET, nullptr, "Unable to get instruction offsets for %d", glyph_id);
return false;
}
}
return true;
}
static bool
_calculate_glyf_and_loca_prime_size (const OT::glyf::accelerator_t &glyf,
const hb_subset_plan_t *plan,
loca_data_t *loca_data, /* OUT */
unsigned int *glyf_size /* OUT */,
hb_vector_t<unsigned int> *instruction_ranges /* OUT */)
{
unsigned int total = 0;
hb_codepoint_t next_glyph = HB_SET_VALUE_INVALID;
while (plan->glyphset ()->next (&next_glyph))
{
unsigned int start_offset = 0, end_offset = 0;
if (unlikely (!(glyf.get_offsets (next_glyph, &start_offset, &end_offset) &&
glyf.remove_padding (start_offset, &end_offset))))
{
DEBUG_MSG(SUBSET, nullptr, "Invalid gid %d", next_glyph);
start_offset = end_offset = 0;
}
bool is_zero_length = end_offset - start_offset < OT::glyf::GlyphHeader::static_size;
if (!_add_instructions_range (glyf,
next_glyph,
start_offset,
end_offset,
plan->drop_hints && !is_zero_length,
instruction_ranges))
return false;
if (is_zero_length)
continue; /* 0-length glyph */
total += end_offset - start_offset
- ((*instruction_ranges)[instruction_ranges->length - 1]
- (*instruction_ranges)[instruction_ranges->length - 2]);
/* round2 so short loca will work */
total += total % 2;
}
*glyf_size = total;
loca_data->is_short = (total <= 131070);
loca_data->size = (plan->num_output_glyphs () + 1)
* (loca_data->is_short ? sizeof (OT::HBUINT16) : sizeof (OT::HBUINT32));
DEBUG_MSG(SUBSET, nullptr, "preparing to subset glyf: final size %d, loca size %d, using %s loca",
total,
loca_data->size,
loca_data->is_short ? "short" : "long");
return true;
}
static void
_update_components (const hb_subset_plan_t *plan,
char *glyph_start,
unsigned int length)
{
OT::glyf::CompositeGlyphHeader::Iterator iterator;
if (OT::glyf::CompositeGlyphHeader::get_iterator (glyph_start,
length,
&iterator))
{
do
{
hb_codepoint_t new_gid;
if (!plan->new_gid_for_old_gid (iterator.current->glyphIndex,
&new_gid))
continue;
((OT::glyf::CompositeGlyphHeader *) iterator.current)->glyphIndex = new_gid;
} while (iterator.move_to_next ());
}
}
static bool _remove_composite_instruction_flag (char *glyf_prime, unsigned int length)
{
/* remove WE_HAVE_INSTRUCTIONS from flags in dest */
OT::glyf::CompositeGlyphHeader::Iterator composite_it;
if (unlikely (!OT::glyf::CompositeGlyphHeader::get_iterator (glyf_prime, length, &composite_it))) return false;
const OT::glyf::CompositeGlyphHeader *glyph;
do {
glyph = composite_it.current;
OT::HBUINT16 *flags = const_cast<OT::HBUINT16 *> (&glyph->flags);
*flags = (uint16_t) *flags & ~OT::glyf::CompositeGlyphHeader::WE_HAVE_INSTRUCTIONS;
} while (composite_it.move_to_next ());
return true;
}
static bool
_write_glyf_and_loca_prime (const hb_subset_plan_t *plan,
const OT::glyf::accelerator_t &glyf,
const char *glyf_data,
hb_vector_t<unsigned int> &instruction_ranges,
unsigned int glyf_prime_size,
char *glyf_prime_data /* OUT */,
loca_data_t *loca_prime /* OUT */)
{
char *glyf_prime_data_next = glyf_prime_data;
bool success = true;
unsigned int i = 0;
hb_codepoint_t new_gid;
for (new_gid = 0; new_gid < plan->num_output_glyphs (); new_gid++)
{
hb_codepoint_t old_gid;
if (!plan->old_gid_for_new_gid (new_gid, &old_gid))
{
// Empty glyph, add a loca entry and carry on.
loca_prime->_write_loca_entry (new_gid,
glyf_prime_data_next - glyf_prime_data);
continue;
}
unsigned int start_offset = 0, end_offset = 0;
if (unlikely (!(glyf.get_offsets (old_gid, &start_offset, &end_offset) &&
glyf.remove_padding (start_offset, &end_offset))))
end_offset = start_offset = 0;
unsigned int instruction_start = instruction_ranges[i * 2];
unsigned int instruction_end = instruction_ranges[i * 2 + 1];
int length = end_offset - start_offset - (instruction_end - instruction_start);
if (glyf_prime_data_next + length > glyf_prime_data + glyf_prime_size)
{
DEBUG_MSG(SUBSET,
nullptr,
"WARNING: Attempted to write an out of bounds glyph entry for gid %d (length %d)",
i, length);
return false;
}
if (instruction_start == instruction_end)
memcpy (glyf_prime_data_next, glyf_data + start_offset, length);
else
{
memcpy (glyf_prime_data_next, glyf_data + start_offset, instruction_start - start_offset);
memcpy (glyf_prime_data_next + instruction_start - start_offset, glyf_data + instruction_end, end_offset - instruction_end);
/* if the instructions end at the end this was a composite glyph, else simple */
if (instruction_end == end_offset)
{
if (unlikely (!_remove_composite_instruction_flag (glyf_prime_data_next, length))) return false;
}
else
/* zero instruction length, which is just before instruction_start */
memset (glyf_prime_data_next + instruction_start - start_offset - 2, 0, 2);
}
success = success && loca_prime->_write_loca_entry (new_gid,
glyf_prime_data_next - glyf_prime_data);
_update_components (plan, glyf_prime_data_next, length);
// TODO: don't align to two bytes if using long loca.
glyf_prime_data_next += length + (length % 2); // Align to 2 bytes for short loca.
i++;
}
// loca table has n+1 entries where the last entry signifies the end location of the last
// glyph.
success = success && loca_prime->_write_loca_entry (new_gid,
glyf_prime_data_next - glyf_prime_data);
return success;
}
static bool
_hb_subset_glyf_and_loca (const OT::glyf::accelerator_t &glyf,
const char *glyf_data,
hb_subset_plan_t *plan,
bool *use_short_loca,
hb_blob_t **glyf_prime_blob /* OUT */,
hb_blob_t **loca_prime_blob /* OUT */)
{
// TODO(grieger): Sanity check allocation size for the new table.
loca_data_t loca_prime;
unsigned int glyf_prime_size;
hb_vector_t<unsigned int> instruction_ranges;
instruction_ranges.init ();
if (unlikely (!_calculate_glyf_and_loca_prime_size (glyf,
plan,
&loca_prime,
&glyf_prime_size,
&instruction_ranges))) {
instruction_ranges.fini ();
return false;
}
*use_short_loca = loca_prime.is_short;
char *glyf_prime_data = (char *) calloc (1, glyf_prime_size);
loca_prime.data = (void *) calloc (1, loca_prime.size);
if (unlikely (!_write_glyf_and_loca_prime (plan, glyf, glyf_data,
instruction_ranges,
glyf_prime_size, glyf_prime_data,
&loca_prime))) {
free (glyf_prime_data);
free (loca_prime.data);
instruction_ranges.fini ();
return false;
}
instruction_ranges.fini ();
*glyf_prime_blob = hb_blob_create (glyf_prime_data,
glyf_prime_size,
HB_MEMORY_MODE_READONLY,
glyf_prime_data,
free);
*loca_prime_blob = hb_blob_create ((char *) loca_prime.data,
loca_prime.size,
HB_MEMORY_MODE_READONLY,
loca_prime.data,
free);
return true;
}
/**
* hb_subset_glyf:
* Subsets the glyph table according to a provided plan.
*
* Return value: subsetted glyf table.
*
* Since: 1.7.5
**/
bool
hb_subset_glyf_and_loca (hb_subset_plan_t *plan,
bool *use_short_loca, /* OUT */
hb_blob_t **glyf_prime, /* OUT */
hb_blob_t **loca_prime /* OUT */)
{
hb_blob_t *glyf_blob = hb_sanitize_context_t ().reference_table<OT::glyf> (plan->source);
const char *glyf_data = hb_blob_get_data (glyf_blob, nullptr);
OT::glyf::accelerator_t glyf;
glyf.init (plan->source);
bool result = _hb_subset_glyf_and_loca (glyf,
glyf_data,
plan,
use_short_loca,
glyf_prime,
loca_prime);
hb_blob_destroy (glyf_blob);
glyf.fini ();
return result;
}

40
src/hb-subset-glyf.hh
View File

@ -1,40 +0,0 @@
/*
* Copyright © 2018 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): Garret Rieger
*/
#ifndef HB_SUBSET_GLYF_HH
#define HB_SUBSET_GLYF_HH
#include "hb.hh"
#include "hb-subset.hh"
HB_INTERNAL bool
hb_subset_glyf_and_loca (hb_subset_plan_t *plan,
bool *use_short_loca, /* OUT */
hb_blob_t **glyf_prime /* OUT */,
hb_blob_t **loca_prime /* OUT */);
#endif /* HB_SUBSET_GLYF_HH */

1
src/hb-subset.cc
View File

@ -28,7 +28,6 @@
#include "hb-open-type.hh"
#include "hb-subset.hh"
#include "hb-subset-glyf.hh"
#include "hb-open-file.hh"
#include "hb-ot-cmap-table.hh"