2022-08-11 21:08:04 +02:00
|
|
|
/*
|
|
|
|
* Copyright © 2022 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 GRAPH_MARKBASEPOS_GRAPH_HH
|
|
|
|
#define GRAPH_MARKBASEPOS_GRAPH_HH
|
|
|
|
|
|
|
|
#include "split-helpers.hh"
|
|
|
|
#include "coverage-graph.hh"
|
|
|
|
#include "../OT/Layout/GPOS/MarkBasePos.hh"
|
|
|
|
#include "../OT/Layout/GPOS/PosLookupSubTable.hh"
|
|
|
|
|
|
|
|
namespace graph {
|
|
|
|
|
|
|
|
struct AnchorMatrix : public OT::Layout::GPOS_impl::AnchorMatrix
|
|
|
|
{
|
|
|
|
bool sanitize (graph_t::vertex_t& vertex) const
|
|
|
|
{
|
|
|
|
// TODO
|
|
|
|
return false;
|
|
|
|
}
|
2022-08-11 22:22:31 +02:00
|
|
|
|
|
|
|
unsigned clone (gsubgpos_graph_context_t& c,
|
|
|
|
unsigned this_index,
|
|
|
|
const hb_hashmap_t<unsigned, unsigned>& pos_to_index,
|
|
|
|
unsigned start,
|
|
|
|
unsigned end)
|
|
|
|
{
|
|
|
|
// TODO
|
|
|
|
return -1;
|
|
|
|
}
|
2022-08-11 21:08:04 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
struct MarkArray : public OT::Layout::GPOS_impl::MarkArray
|
|
|
|
{
|
|
|
|
bool sanitize (graph_t::vertex_t& vertex) const
|
|
|
|
{
|
|
|
|
// TODO
|
|
|
|
return false;
|
|
|
|
}
|
2022-08-11 22:22:31 +02:00
|
|
|
|
|
|
|
unsigned clone (gsubgpos_graph_context_t& c,
|
|
|
|
unsigned this_index,
|
|
|
|
const hb_hashmap_t<unsigned, unsigned>& pos_to_index,
|
|
|
|
hb_set_t& marks)
|
|
|
|
{
|
|
|
|
// TODO
|
|
|
|
return -1;
|
|
|
|
}
|
2022-08-11 21:08:04 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
struct MarkBasePosFormat1 : public OT::Layout::GPOS_impl::MarkBasePosFormat1_2<SmallTypes>
|
|
|
|
{
|
|
|
|
bool sanitize (graph_t::vertex_t& vertex) const
|
|
|
|
{
|
|
|
|
int64_t vertex_len = vertex.obj.tail - vertex.obj.head;
|
|
|
|
unsigned min_size = OT::Layout::GPOS_impl::MarkBasePosFormat1_2<SmallTypes>::min_size;
|
|
|
|
if (vertex_len < min_size) return false;
|
|
|
|
|
|
|
|
// TODO
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
hb_vector_t<unsigned> split_subtables (gsubgpos_graph_context_t& c, unsigned this_index)
|
|
|
|
{
|
|
|
|
hb_set_t visited;
|
|
|
|
|
|
|
|
const unsigned base_coverage_id = c.graph.index_for_offset (this_index, &baseCoverage);
|
|
|
|
const unsigned base_size =
|
|
|
|
OT::Layout::GPOS_impl::PairPosFormat1_3<SmallTypes>::min_size +
|
|
|
|
c.graph.vertices_[base_coverage_id].table_size ();
|
|
|
|
|
|
|
|
hb_vector_t<class_info_t> class_to_info = get_class_info (c, this_index);
|
|
|
|
|
|
|
|
unsigned partial_coverage_size = 4;
|
|
|
|
unsigned accumulated = base_size;
|
|
|
|
hb_vector_t<unsigned> split_points;
|
|
|
|
unsigned class_count = classCount;
|
|
|
|
for (unsigned klass = 0; klass < class_count; klass++)
|
|
|
|
{
|
|
|
|
class_info_t& info = class_to_info[klass];
|
2022-08-11 22:22:31 +02:00
|
|
|
partial_coverage_size += OT::HBUINT16::static_size * info.marks.get_population ();
|
|
|
|
unsigned accumulated_delta = OT::Layout::GPOS_impl::MarkRecord::static_size * info.marks.get_population ();
|
2022-08-11 21:26:59 +02:00
|
|
|
// TODO this doesn't count up null offsets.
|
2022-08-11 21:08:04 +02:00
|
|
|
accumulated_delta += OT::Offset16::static_size * info.child_indices.length;
|
|
|
|
for (unsigned objidx : info.child_indices)
|
|
|
|
accumulated_delta += c.graph.find_subgraph_size (objidx, visited);
|
|
|
|
|
|
|
|
accumulated += accumulated_delta;
|
|
|
|
unsigned total = accumulated + partial_coverage_size;
|
|
|
|
|
|
|
|
if (total >= (1 << 16))
|
|
|
|
{
|
|
|
|
split_points.push (klass);
|
|
|
|
accumulated = base_size + accumulated_delta;
|
2022-08-11 22:22:31 +02:00
|
|
|
partial_coverage_size = 4 + OT::HBUINT16::static_size * info.marks.get_population ();
|
2022-08-11 21:08:04 +02:00
|
|
|
visited.clear (); // node sharing isn't allowed between splits.
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-08-11 22:22:31 +02:00
|
|
|
|
|
|
|
const unsigned mark_array_id = c.graph.index_for_offset (this_index, &markArray);
|
|
|
|
const unsigned base_array_id = c.graph.index_for_offset (this_index, &baseArray);
|
|
|
|
|
|
|
|
|
2022-08-11 21:08:04 +02:00
|
|
|
split_context_t split_context {
|
|
|
|
c,
|
|
|
|
this,
|
|
|
|
this_index,
|
2022-08-11 22:22:31 +02:00
|
|
|
std::move (class_to_info),
|
|
|
|
c.graph.vertices_[mark_array_id].position_to_index_map (),
|
|
|
|
c.graph.vertices_[base_array_id].position_to_index_map ()
|
2022-08-11 21:08:04 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
return actuate_subtable_split<split_context_t> (split_context, split_points);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
2022-08-11 22:22:31 +02:00
|
|
|
struct class_info_t {
|
|
|
|
hb_set_t marks;
|
|
|
|
hb_vector_t<unsigned> child_indices;
|
|
|
|
};
|
|
|
|
|
2022-08-11 21:08:04 +02:00
|
|
|
struct split_context_t {
|
|
|
|
gsubgpos_graph_context_t& c;
|
|
|
|
MarkBasePosFormat1* thiz;
|
|
|
|
unsigned this_index;
|
2022-08-11 22:22:31 +02:00
|
|
|
hb_vector_t<class_info_t> class_to_info;
|
|
|
|
hb_hashmap_t<unsigned, unsigned> mark_array_links;
|
|
|
|
hb_hashmap_t<unsigned, unsigned> base_array_links;
|
2022-08-11 21:08:04 +02:00
|
|
|
|
|
|
|
unsigned original_count ()
|
|
|
|
{
|
2022-08-11 21:26:59 +02:00
|
|
|
return thiz->classCount;
|
2022-08-11 21:08:04 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
unsigned clone_range (unsigned start, unsigned end)
|
|
|
|
{
|
2022-08-11 22:22:31 +02:00
|
|
|
return thiz->clone_range (*this, this->this_index, start, end);
|
2022-08-11 21:08:04 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
bool shrink (unsigned count)
|
|
|
|
{
|
2022-08-11 22:22:31 +02:00
|
|
|
return thiz->shrink (*this, this->this_index, count);
|
2022-08-11 21:08:04 +02:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
hb_vector_t<class_info_t> get_class_info (gsubgpos_graph_context_t& c,
|
|
|
|
unsigned this_index)
|
|
|
|
{
|
|
|
|
hb_vector_t<class_info_t> class_to_info;
|
|
|
|
|
|
|
|
unsigned class_count= classCount;
|
2022-08-11 21:26:59 +02:00
|
|
|
class_to_info.resize (class_count);
|
2022-08-11 21:08:04 +02:00
|
|
|
|
|
|
|
unsigned mark_array_id =
|
|
|
|
c.graph.index_for_offset (this_index, &markArray);
|
2022-08-11 21:26:59 +02:00
|
|
|
auto& mark_array_v = c.graph.vertices_[mark_array_id];
|
|
|
|
MarkArray* mark_array = (MarkArray*) mark_array_v.obj.head;
|
2022-08-11 21:08:04 +02:00
|
|
|
// TODO sanitize
|
|
|
|
|
2022-08-11 21:26:59 +02:00
|
|
|
unsigned mark_count = mark_array->len;
|
2022-08-11 21:08:04 +02:00
|
|
|
for (unsigned mark = 0; mark < mark_count; mark++)
|
|
|
|
{
|
2022-08-11 21:26:59 +02:00
|
|
|
unsigned klass = (*mark_array)[mark].get_class ();
|
2022-08-11 22:22:31 +02:00
|
|
|
class_to_info[klass].marks.add (mark);
|
2022-08-11 21:08:04 +02:00
|
|
|
}
|
|
|
|
|
2022-08-11 21:26:59 +02:00
|
|
|
for (const auto& link : mark_array_v.obj.real_links)
|
2022-08-11 21:08:04 +02:00
|
|
|
{
|
2022-08-11 21:26:59 +02:00
|
|
|
unsigned mark = (link.position - 2) /
|
|
|
|
OT::Layout::GPOS_impl::MarkRecord::static_size;
|
|
|
|
unsigned klass = (*mark_array)[mark].get_class ();
|
2022-08-11 21:08:04 +02:00
|
|
|
class_to_info[klass].child_indices.push (link.objidx);
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned base_array_id =
|
|
|
|
c.graph.index_for_offset (this_index, &baseArray);
|
2022-08-11 21:26:59 +02:00
|
|
|
auto& base_array_v = c.graph.vertices_[base_array_id];
|
2022-08-11 21:08:04 +02:00
|
|
|
|
2022-08-11 21:26:59 +02:00
|
|
|
for (const auto& link : base_array_v.obj.real_links)
|
2022-08-11 21:08:04 +02:00
|
|
|
{
|
2022-08-11 21:26:59 +02:00
|
|
|
unsigned index = (link.position - 2) / OT::Offset16::static_size;
|
2022-08-11 21:08:04 +02:00
|
|
|
unsigned klass = index % class_count;
|
2022-08-11 21:26:59 +02:00
|
|
|
class_to_info[klass].child_indices.push (link.objidx);
|
2022-08-11 21:08:04 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return class_to_info;
|
|
|
|
}
|
|
|
|
|
2022-08-11 22:22:31 +02:00
|
|
|
bool shrink (split_context_t& c,
|
2022-08-11 21:08:04 +02:00
|
|
|
unsigned this_index,
|
|
|
|
unsigned count)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
DEBUG_MSG (SUBSET_REPACK, nullptr,
|
|
|
|
" Shrinking PairPosFormat1 (%u) to [0, %u).",
|
|
|
|
this_index,
|
|
|
|
count);
|
|
|
|
unsigned old_count = pairSet.len;
|
|
|
|
if (count >= old_count)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
pairSet.len = count;
|
|
|
|
c.graph.vertices_[this_index].obj.tail -= (old_count - count) * SmallTypes::size;
|
|
|
|
|
|
|
|
unsigned coverage_id = c.graph.mutable_index_for_offset (this_index, &coverage);
|
|
|
|
unsigned coverage_size = c.graph.vertices_[coverage_id].table_size ();
|
|
|
|
auto& coverage_v = c.graph.vertices_[coverage_id];
|
|
|
|
|
|
|
|
Coverage* coverage_table = (Coverage*) coverage_v.obj.head;
|
|
|
|
if (!coverage_table || !coverage_table->sanitize (coverage_v))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
auto new_coverage =
|
|
|
|
+ hb_zip (coverage_table->iter (), hb_range ())
|
|
|
|
| hb_filter ([&] (hb_pair_t<unsigned, unsigned> p) {
|
|
|
|
return p.second < count;
|
|
|
|
})
|
|
|
|
| hb_map_retains_sorting (hb_first)
|
|
|
|
;
|
|
|
|
|
|
|
|
return Coverage::make_coverage (c, new_coverage, coverage_id, coverage_size);
|
|
|
|
*/
|
2022-08-11 22:22:31 +02:00
|
|
|
return -1; // TODO
|
2022-08-11 21:08:04 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// Create a new PairPos including PairSet's from start (inclusive) to end (exclusive).
|
|
|
|
// Returns object id of the new object.
|
2022-08-11 22:22:31 +02:00
|
|
|
unsigned clone_range (split_context_t& sc,
|
2022-08-11 21:08:04 +02:00
|
|
|
unsigned this_index,
|
|
|
|
unsigned start, unsigned end) const
|
|
|
|
{
|
|
|
|
DEBUG_MSG (SUBSET_REPACK, nullptr,
|
2022-08-11 22:22:31 +02:00
|
|
|
" Cloning MarkBasePosFormat1 (%u) range [%u, %u).", this_index, start, end);
|
|
|
|
|
|
|
|
// TODO
|
|
|
|
|
|
|
|
graph_t& graph = sc.c.graph;
|
|
|
|
unsigned prime_size = OT::Layout::GPOS_impl::MarkBasePosFormat1_2<SmallTypes>::static_size;
|
2022-08-11 21:08:04 +02:00
|
|
|
|
2022-08-11 22:22:31 +02:00
|
|
|
unsigned prime_id = sc.c.create_node (prime_size);
|
|
|
|
if (prime_id == (unsigned) -1) return -1;
|
2022-08-11 21:08:04 +02:00
|
|
|
|
2022-08-11 22:22:31 +02:00
|
|
|
MarkBasePosFormat1* prime = (MarkBasePosFormat1*) graph.object (prime_id).head;
|
|
|
|
prime->format = this->format;
|
|
|
|
prime->classCount = this->classCount;
|
2022-08-11 21:08:04 +02:00
|
|
|
|
2022-08-11 22:22:31 +02:00
|
|
|
unsigned base_coverage_id =
|
|
|
|
graph.index_for_offset (sc.this_index, &baseCoverage);
|
2022-08-11 22:33:21 +02:00
|
|
|
graph.add_link (&(prime->baseCoverage), prime_id, base_coverage_id);
|
2022-08-11 22:22:31 +02:00
|
|
|
graph.duplicate (prime_id, base_coverage_id);
|
2022-08-11 21:08:04 +02:00
|
|
|
|
2022-08-11 22:22:31 +02:00
|
|
|
hb_set_t marks;
|
|
|
|
for (unsigned klass = start; klass < end; klass++)
|
2022-08-11 21:08:04 +02:00
|
|
|
{
|
2022-08-11 22:22:31 +02:00
|
|
|
+ sc.class_to_info[klass].marks.iter ()
|
|
|
|
| hb_sink (marks)
|
|
|
|
;
|
2022-08-11 21:08:04 +02:00
|
|
|
}
|
|
|
|
|
2022-08-11 22:22:31 +02:00
|
|
|
if (!Coverage::add_coverage (sc.c,
|
|
|
|
prime_id,
|
|
|
|
2,
|
|
|
|
+ marks.iter (),
|
|
|
|
marks.get_population () * 2 + 4))
|
2022-08-11 21:08:04 +02:00
|
|
|
return -1;
|
|
|
|
|
2022-08-11 22:22:31 +02:00
|
|
|
unsigned mark_array_id =
|
|
|
|
graph.index_for_offset (sc.this_index, &markArray);
|
|
|
|
auto& mark_array_v = graph.vertices_[mark_array_id];
|
|
|
|
MarkArray* mark_array = (MarkArray*) mark_array_v.obj.head;
|
|
|
|
// TODO sanitize
|
|
|
|
unsigned new_mark_array = mark_array->clone (sc.c,
|
|
|
|
mark_array_id,
|
|
|
|
sc.mark_array_links,
|
|
|
|
marks);
|
2022-08-11 22:33:21 +02:00
|
|
|
graph.add_link (&(prime->markArray), prime_id, new_mark_array);
|
2022-08-11 22:22:31 +02:00
|
|
|
|
|
|
|
unsigned base_array_id =
|
|
|
|
graph.index_for_offset (sc.this_index, &baseArray);
|
|
|
|
auto& base_array_v = graph.vertices_[base_array_id];
|
|
|
|
AnchorMatrix* base_array = (AnchorMatrix*) base_array_v.obj.head;
|
|
|
|
// TODO sanitize
|
|
|
|
unsigned new_base_array = base_array->clone (sc.c,
|
|
|
|
mark_array_id,
|
|
|
|
sc.base_array_links,
|
|
|
|
start, end);
|
2022-08-11 22:33:21 +02:00
|
|
|
graph.add_link (&(prime->baseArray), prime_id, new_base_array);
|
2022-08-11 22:22:31 +02:00
|
|
|
|
|
|
|
return prime_id;
|
2022-08-11 21:08:04 +02:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
struct MarkBasePos : public OT::Layout::GPOS_impl::MarkBasePos
|
|
|
|
{
|
|
|
|
hb_vector_t<unsigned> split_subtables (gsubgpos_graph_context_t& c,
|
|
|
|
unsigned this_index)
|
|
|
|
{
|
|
|
|
switch (u.format) {
|
|
|
|
case 1:
|
|
|
|
return ((MarkBasePosFormat1*)(&u.format1))->split_subtables (c, this_index);
|
|
|
|
#ifndef HB_NO_BORING_EXPANSION
|
|
|
|
case 2: HB_FALLTHROUGH;
|
|
|
|
// Don't split 24bit PairPos's.
|
|
|
|
#endif
|
|
|
|
default:
|
|
|
|
return hb_vector_t<unsigned> ();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool sanitize (graph_t::vertex_t& vertex) const
|
|
|
|
{
|
|
|
|
int64_t vertex_len = vertex.obj.tail - vertex.obj.head;
|
|
|
|
if (vertex_len < u.format.get_size ()) return false;
|
|
|
|
|
|
|
|
switch (u.format) {
|
|
|
|
case 1:
|
|
|
|
return ((PairPosFormat1*)(&u.format1))->sanitize (vertex);
|
|
|
|
#ifndef HB_NO_BORING_EXPANSION
|
|
|
|
case 2: HB_FALLTHROUGH;
|
|
|
|
#endif
|
|
|
|
default:
|
|
|
|
// We don't handle format 3 and 4 here.
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif // GRAPH_MARKBASEPOS_GRAPH_HH
|