tor-browser

VARC.hh (6307B)

---

#ifndef OT_VAR_VARC_VARC_HH
#define OT_VAR_VARC_VARC_HH

#include "../../../hb-decycler.hh"
#include "../../../hb-geometry.hh"
#include "../../../hb-ot-layout-common.hh"
#include "../../../hb-ot-glyf-table.hh"
#include "../../../hb-ot-cff2-table.hh"
#include "../../../hb-ot-cff1-table.hh"

#include "coord-setter.hh"

namespace OT {

//namespace Var {

/*
* VARC -- Variable Composites
* https://github.com/harfbuzz/boring-expansion-spec/blob/main/VARC.md
*/

#ifndef HB_NO_VAR_COMPOSITES

struct hb_varc_scratch_t
{
 hb_vector_t<unsigned> axisIndices;
 hb_vector_t<float> axisValues;
 hb_glyf_scratch_t glyf_scratch;
};

struct hb_varc_context_t
{
 hb_font_t *font;
 hb_draw_session_t *draw_session;
 hb_extents_t<> *extents;
 mutable hb_decycler_t decycler;
 mutable signed edges_left;
 mutable signed depth_left;
 hb_varc_scratch_t &scratch;
};

struct VarComponent
{
 enum class flags_t : uint32_t
 {
   RESET_UNSPECIFIED_AXES	= 1u << 0,
   HAVE_AXES			= 1u << 1,
   AXIS_VALUES_HAVE_VARIATION	= 1u << 2,
   TRANSFORM_HAS_VARIATION	= 1u << 3,
   HAVE_TRANSLATE_X		= 1u << 4,
   HAVE_TRANSLATE_Y		= 1u << 5,
   HAVE_ROTATION		= 1u << 6,
   HAVE_CONDITION		= 1u << 7,
   HAVE_SCALE_X		= 1u << 8,
   HAVE_SCALE_Y		= 1u << 9,
   HAVE_TCENTER_X		= 1u << 10,
   HAVE_TCENTER_Y		= 1u << 11,
   GID_IS_24BIT		= 1u << 12,
   HAVE_SKEW_X			= 1u << 13,
   HAVE_SKEW_Y			= 1u << 14,
   RESERVED_MASK		= ~((1u << 15) - 1),
 };

 HB_INTERNAL hb_ubytes_t
 get_path_at (const hb_varc_context_t &c,
       hb_codepoint_t parent_gid,
       hb_array_t<const int> coords,
       hb_transform_t<> transform,
       hb_ubytes_t record,
       hb_scalar_cache_t *cache = nullptr) const;
};

struct VarCompositeGlyph
{
 static void
 get_path_at (const hb_varc_context_t &c,
       hb_codepoint_t gid,
       hb_array_t<const int> coords,
       hb_transform_t<> transform,
       hb_ubytes_t record,
       hb_scalar_cache_t *cache)
 {
   while (record)
   {
     const VarComponent &comp = * (const VarComponent *) (record.arrayZ);
     record = comp.get_path_at (c,
			 gid,
			 coords, transform,
			 record,
			 cache);
   }
 }
};

HB_MARK_AS_FLAG_T (VarComponent::flags_t);

struct VARC
{
 friend struct VarComponent;

 static constexpr hb_tag_t tableTag = HB_TAG ('V', 'A', 'R', 'C');

 HB_INTERNAL bool
 get_path_at (const hb_varc_context_t &c,
       hb_codepoint_t gid,
       hb_array_t<const int> coords,
       hb_transform_t<> transform = HB_TRANSFORM_IDENTITY,
       hb_codepoint_t parent_gid = HB_CODEPOINT_INVALID,
       hb_scalar_cache_t *parent_cache = nullptr) const;

 bool
 get_path (hb_font_t *font,
    hb_codepoint_t gid,
    hb_draw_session_t &draw_session,
    hb_varc_scratch_t &scratch) const
 {
   hb_varc_context_t c {font,
		 &draw_session,
		 nullptr,
		 hb_decycler_t {},
		 HB_MAX_GRAPH_EDGE_COUNT,
		 HB_MAX_NESTING_LEVEL,
		 scratch};

   return get_path_at (c, gid,
		hb_array (font->coords, font->num_coords));
 }

 bool
 get_extents (hb_font_t *font,
       hb_codepoint_t gid,
       hb_extents_t<> *extents,
       hb_varc_scratch_t &scratch) const
 {
   hb_varc_context_t c {font,
		 nullptr,
		 extents,
		 hb_decycler_t {},
		 HB_MAX_GRAPH_EDGE_COUNT,
		 HB_MAX_NESTING_LEVEL,
		 scratch};

   return get_path_at (c, gid,
		hb_array (font->coords, font->num_coords));
 }

 bool sanitize (hb_sanitize_context_t *c) const
 {
   TRACE_SANITIZE (this);
   return_trace (version.sanitize (c) &&
	  hb_barrier () &&
	  version.major == 1 &&
	  coverage.sanitize (c, this) &&
	  varStore.sanitize (c, this) &&
	  conditionList.sanitize (c, this) &&
	  axisIndicesList.sanitize (c, this) &&
	  glyphRecords.sanitize (c, this));
 }

 struct accelerator_t
 {
   friend struct VarComponent;

   accelerator_t (hb_face_t *face)
   {
     table = hb_sanitize_context_t ().reference_table<VARC> (face);
   }
   ~accelerator_t ()
   {
     auto *scratch = cached_scratch.get_relaxed ();
     if (scratch)
     {
scratch->~hb_varc_scratch_t ();
hb_free (scratch);
     }

     table.destroy ();
   }

   bool
   get_path (hb_font_t *font, hb_codepoint_t gid, hb_draw_session_t &draw_session) const
   {
     if (!table->has_data ()) return false;

     auto *scratch = acquire_scratch ();
     if (unlikely (!scratch)) return true;
     bool ret = table->get_path (font, gid, draw_session, *scratch);
     release_scratch (scratch);
     return ret;
   }

   bool
   get_extents (hb_font_t *font,
	 hb_codepoint_t gid,
	 hb_glyph_extents_t *extents) const
   {
#ifndef HB_NO_DRAW
     if (!table->has_data ()) return false;

     hb_extents_t<> f_extents;

     auto *scratch = acquire_scratch ();
     if (unlikely (!scratch)) return true;
     bool ret = table->get_extents (font, gid, &f_extents, *scratch);
     release_scratch (scratch);

     if (ret)
*extents = f_extents.to_glyph_extents (font->x_scale < 0, font->y_scale < 0);

     return ret;
#else
     return false;
#endif
   }

   private:

   hb_varc_scratch_t *acquire_scratch () const
   {
     hb_varc_scratch_t *scratch = cached_scratch.get_acquire ();

     if (!scratch || unlikely (!cached_scratch.cmpexch (scratch, nullptr)))
     {
scratch = (hb_varc_scratch_t *) hb_calloc (1, sizeof (hb_varc_scratch_t));
if (unlikely (!scratch))
  return nullptr;
     }

     return scratch;
   }
   void release_scratch (hb_varc_scratch_t *scratch) const
   {
     if (!cached_scratch.cmpexch (nullptr, scratch))
     {
scratch->~hb_varc_scratch_t ();
hb_free (scratch);
     }
   }

   private:
   hb_blob_ptr_t<VARC> table;
   mutable hb_atomic_t<hb_varc_scratch_t *> cached_scratch;
 };

 bool has_data () const { return version.major != 0; }

 protected:
 FixedVersion<> version; /* Version identifier */
 Offset32To<Coverage> coverage;
 Offset32To<MultiItemVariationStore> varStore;
 Offset32To<ConditionList> conditionList;
 Offset32To<TupleList> axisIndicesList;
 Offset32To<CFF2Index/*Of<VarCompositeGlyph>*/> glyphRecords;
 public:
 DEFINE_SIZE_STATIC (24);
};

struct VARC_accelerator_t : VARC::accelerator_t {
 VARC_accelerator_t (hb_face_t *face) : VARC::accelerator_t (face) {}
};

#endif

//}

}

#endif  /* OT_VAR_VARC_VARC_HH */