src/hb-ot-color-sbix-table.hh - third_party/harfbuzz - Git at Google

 /*
  * Copyright © 2018  Ebrahim Byagowi
  * Copyright © 2020  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): Calder Kitagawa
  */

 #ifndef HB_OT_COLOR_SBIX_TABLE_HH
 #define HB_OT_COLOR_SBIX_TABLE_HH

 #include "hb-open-type.hh"
 #include "hb-ot-layout-common.hh"

 /*
  * sbix -- Standard Bitmap Graphics
  * https://docs.microsoft.com/en-us/typography/opentype/spec/sbix
  * https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6sbix.html
  */
 #define HB_OT_TAG_sbix HB_TAG('s','b','i','x')


 namespace OT {


 struct SBIXGlyph
 {
   SBIXGlyph* copy (hb_serialize_context_t *c, unsigned int data_length) const
   {
     TRACE_SERIALIZE (this);
     SBIXGlyph* new_glyph = c->start_embed<SBIXGlyph> ();
     if (unlikely (!new_glyph)) return_trace (nullptr);
     if (unlikely (!c->extend_min (new_glyph))) return_trace (nullptr);

     new_glyph->xOffset = xOffset;
     new_glyph->yOffset = yOffset;
     new_glyph->graphicType = graphicType;
     data.copy (c, data_length);
     return_trace (new_glyph);
   }

   HBINT16	xOffset;	/* The horizontal (x-axis) offset from the left
 				 * edge of the graphic to the glyph’s origin.
 				 * That is, the x-coordinate of the point on the
 				 * baseline at the left edge of the glyph. */
   HBINT16	yOffset;	/* The vertical (y-axis) offset from the bottom
 				 * edge of the graphic to the glyph’s origin.
 				 * That is, the y-coordinate of the point on the
 				 * baseline at the left edge of the glyph. */
   Tag		graphicType;	/* Indicates the format of the embedded graphic
 				 * data: one of 'jpg ', 'png ' or 'tiff', or the
 				 * special format 'dupe'. */
   UnsizedArrayOf<HBUINT8>
 		data;		/* The actual embedded graphic data. The total
 				 * length is inferred from sequential entries in
 				 * the glyphDataOffsets array and the fixed size
 				 * (8 bytes) of the preceding fields. */
   public:
   DEFINE_SIZE_ARRAY (8, data);
 };

 struct SBIXStrike
 {
   static unsigned int get_size (unsigned num_glyphs)
   { return min_size + num_glyphs * HBUINT32::static_size; }

   bool sanitize (hb_sanitize_context_t *c) const
   {
     TRACE_SANITIZE (this);
     return_trace (c->check_struct (this) &&
 		  imageOffsetsZ.sanitize_shallow (c, c->get_num_glyphs () + 1));
   }

   hb_blob_t *get_glyph_blob (unsigned int  glyph_id,
 			     hb_blob_t    *sbix_blob,
 			     hb_tag_t      file_type,
 			     int          *x_offset,
 			     int          *y_offset,
 			     unsigned int  num_glyphs,
 			     unsigned int *strike_ppem) const
   {
     if (unlikely (!ppem)) return hb_blob_get_empty (); /* To get Null() object out of the way. */

     unsigned int retry_count = 8;
     unsigned int sbix_len = sbix_blob->length;
     unsigned int strike_offset = (const char *) this - (const char *) sbix_blob->data;
     assert (strike_offset < sbix_len);

   retry:
     if (unlikely (glyph_id >= num_glyphs ||
 		  imageOffsetsZ[glyph_id + 1] <= imageOffsetsZ[glyph_id] ||
 		  imageOffsetsZ[glyph_id + 1] - imageOffsetsZ[glyph_id] <= SBIXGlyph::min_size ||
 		  (unsigned int) imageOffsetsZ[glyph_id + 1] > sbix_len - strike_offset))
       return hb_blob_get_empty ();

     unsigned int glyph_offset = strike_offset + (unsigned int) imageOffsetsZ[glyph_id] + SBIXGlyph::min_size;
     unsigned int glyph_length = imageOffsetsZ[glyph_id + 1] - imageOffsetsZ[glyph_id] - SBIXGlyph::min_size;

     const SBIXGlyph *glyph = &(this+imageOffsetsZ[glyph_id]);

     if (glyph->graphicType == HB_TAG ('d','u','p','e'))
     {
       if (glyph_length >= 2)
       {
 	glyph_id = *((HBUINT16 *) &glyph->data);
 	if (retry_count--)
 	  goto retry;
       }
       return hb_blob_get_empty ();
     }

     if (unlikely (file_type != glyph->graphicType))
       return hb_blob_get_empty ();

     if (strike_ppem) *strike_ppem = ppem;
     if (x_offset) *x_offset = glyph->xOffset;
     if (y_offset) *y_offset = glyph->yOffset;
     return hb_blob_create_sub_blob (sbix_blob, glyph_offset, glyph_length);
   }

   bool subset (hb_subset_context_t *c, unsigned int available_len) const
   {
     TRACE_SUBSET (this);
     unsigned int num_output_glyphs = c->plan->num_output_glyphs ();

     auto* out = c->serializer->start_embed<SBIXStrike> ();
     if (unlikely (!out)) return_trace (false);
     auto snap = c->serializer->snapshot ();
     if (unlikely (!c->serializer->extend (out, num_output_glyphs + 1))) return_trace (false);
     out->ppem = ppem;
     out->resolution = resolution;
     HBUINT32 head;
     head = get_size (num_output_glyphs + 1);

     bool has_glyphs = false;
     for (unsigned new_gid = 0; new_gid < num_output_glyphs; new_gid++)
     {
       hb_codepoint_t old_gid;
       if (!c->plan->old_gid_for_new_gid (new_gid, &old_gid) ||
 	  unlikely (imageOffsetsZ[old_gid].is_null () ||
 		    imageOffsetsZ[old_gid + 1].is_null () ||
 		    imageOffsetsZ[old_gid + 1] <= imageOffsetsZ[old_gid] ||
 		    imageOffsetsZ[old_gid + 1] - imageOffsetsZ[old_gid] <= SBIXGlyph::min_size) ||
 		    (unsigned int) imageOffsetsZ[old_gid + 1] > available_len)
       {
 	out->imageOffsetsZ[new_gid] = head;
 	continue;
       }
       has_glyphs = true;
       unsigned int delta = imageOffsetsZ[old_gid + 1] - imageOffsetsZ[old_gid];
       unsigned int glyph_data_length = delta - SBIXGlyph::min_size;
       if (!(this+imageOffsetsZ[old_gid]).copy (c->serializer, glyph_data_length))
 	return_trace (false);
       out->imageOffsetsZ[new_gid] = head;
       head += delta;
     }
     if (has_glyphs)
       out->imageOffsetsZ[num_output_glyphs] = head;
     else
       c->serializer->revert (snap);
     return_trace (has_glyphs);
   }

   public:
   HBUINT16	ppem;		/* The PPEM size for which this strike was designed. */
   HBUINT16	resolution;	/* The device pixel density (in PPI) for which this
 				 * strike was designed. (E.g., 96 PPI, 192 PPI.) */
   protected:
   UnsizedArrayOf<Offset32To<SBIXGlyph>>
 		imageOffsetsZ;	/* Offset from the beginning of the strike data header
 				 * to bitmap data for an individual glyph ID. */
   public:
   DEFINE_SIZE_ARRAY (4, imageOffsetsZ);
 };

 struct sbix
 {
   static constexpr hb_tag_t tableTag = HB_OT_TAG_sbix;

   bool has_data () const { return version; }

   const SBIXStrike &get_strike (unsigned int i) const { return this+strikes[i]; }

   struct accelerator_t
   {
     void init (hb_face_t *face)
     {
       table = hb_sanitize_context_t ().reference_table<sbix> (face);
       num_glyphs = face->get_num_glyphs ();
     }
     void fini () { table.destroy (); }

     bool has_data () const { return table->has_data (); }

     bool get_extents (hb_font_t          *font,
 		      hb_codepoint_t      glyph,
 		      hb_glyph_extents_t *extents) const
     {
       /* We only support PNG right now, and following function checks type. */
       return get_png_extents (font, glyph, extents);
     }

     hb_blob_t *reference_png (hb_font_t      *font,
 			      hb_codepoint_t  glyph_id,
 			      int            *x_offset,
 			      int            *y_offset,
 			      unsigned int   *available_ppem) const
     {
       return choose_strike (font).get_glyph_blob (glyph_id, table.get_blob (),
 						  HB_TAG ('p','n','g',' '),
 						  x_offset, y_offset,
 						  num_glyphs, available_ppem);
     }

     private:

     const SBIXStrike &choose_strike (hb_font_t *font) const
     {
       unsigned count = table->strikes.len;
       if (unlikely (!count))
 	return Null (SBIXStrike);

       unsigned int requested_ppem = hb_max (font->x_ppem, font->y_ppem);
       if (!requested_ppem)
 	requested_ppem = 1<<30; /* Choose largest strike. */
       /* TODO Add DPI sensitivity as well? */
       unsigned int best_i = 0;
       unsigned int best_ppem = table->get_strike (0).ppem;

       for (unsigned int i = 1; i < count; i++)
       {
 	unsigned int ppem = (table->get_strike (i)).ppem;
 	if ((requested_ppem <= ppem && ppem < best_ppem) ||
 	    (requested_ppem > best_ppem && ppem > best_ppem))
 	{
 	  best_i = i;
 	  best_ppem = ppem;
 	}
       }

       return table->get_strike (best_i);
     }

     struct PNGHeader
     {
       HBUINT8	signature[8];
       struct
       {
 	struct
 	{
 	  HBUINT32	length;
 	  Tag		type;
 	}		header;
 	HBUINT32	width;
 	HBUINT32	height;
 	HBUINT8		bitDepth;
 	HBUINT8		colorType;
 	HBUINT8		compressionMethod;
 	HBUINT8		filterMethod;
 	HBUINT8		interlaceMethod;
       } IHDR;

       public:
       DEFINE_SIZE_STATIC (29);
     };

     bool get_png_extents (hb_font_t          *font,
 			  hb_codepoint_t      glyph,
 			  hb_glyph_extents_t *extents) const
     {
       /* Following code is safe to call even without data.
        * But faster to short-circuit. */
       if (!has_data ())
 	return false;

       int x_offset = 0, y_offset = 0;
       unsigned int strike_ppem = 0;
       hb_blob_t *blob = reference_png (font, glyph, &x_offset, &y_offset, &strike_ppem);

       const PNGHeader &png = *blob->as<PNGHeader>();

       extents->x_bearing = x_offset;
       extents->y_bearing = png.IHDR.height + y_offset;
       extents->width     = png.IHDR.width;
       extents->height    = -1 * png.IHDR.height;

       /* Convert to font units. */
       if (strike_ppem)
       {
 	float scale = font->face->get_upem () / (float) strike_ppem;
 	extents->x_bearing = font->em_scalef_x (extents->x_bearing * scale);
 	extents->y_bearing = font->em_scalef_y (extents->y_bearing * scale);
 	extents->width = font->em_scalef_x (extents->width * scale);
 	extents->height = font->em_scalef_y (extents->height * scale);
       }
       else
       {
 	extents->x_bearing = font->em_scale_x (extents->x_bearing);
 	extents->y_bearing = font->em_scale_y (extents->y_bearing);
 	extents->width = font->em_scale_x (extents->width);
 	extents->height = font->em_scale_y (extents->height);
       }

       hb_blob_destroy (blob);

       return strike_ppem;
     }

     private:
     hb_blob_ptr_t<sbix> table;

     unsigned int num_glyphs;
   };

   bool sanitize (hb_sanitize_context_t *c) const
   {
     TRACE_SANITIZE (this);
     return_trace (likely (c->check_struct (this) &&
 			  version >= 1 &&
 			  strikes.sanitize (c, this)));
   }

   bool
   add_strike (hb_subset_context_t *c, unsigned i) const
   {
     if (strikes[i].is_null () || c->source_blob->length < (unsigned) strikes[i])
       return false;

     return (this+strikes[i]).subset (c, c->source_blob->length - (unsigned) strikes[i]);
   }

   bool serialize_strike_offsets (hb_subset_context_t *c) const
   {
     TRACE_SERIALIZE (this);

     auto *out = c->serializer->start_embed<Array32OfOffset32To<SBIXStrike>> ();
     if (unlikely (!out)) return_trace (false);
     if (unlikely (!c->serializer->extend_min (out))) return_trace (false);

     hb_vector_t<Offset32To<SBIXStrike>*> new_strikes;
     hb_vector_t<hb_serialize_context_t::objidx_t> objidxs;
     for (int i = strikes.len - 1; i >= 0; --i)
     {
       auto* o = out->serialize_append (c->serializer);
       if (unlikely (!o)) return_trace (false);
       *o = 0;
       auto snap = c->serializer->snapshot ();
       c->serializer->push ();
       bool ret = add_strike (c, i);
       if (!ret)
       {
 	c->serializer->pop_discard ();
 	out->pop ();
 	c->serializer->revert (snap);
       }
       else
       {
 	objidxs.push (c->serializer->pop_pack ());
 	new_strikes.push (o);
       }
     }
     for (unsigned int i = 0; i < new_strikes.length; ++i)
       c->serializer->add_link (*new_strikes[i], objidxs[new_strikes.length - 1 - i]);

     return_trace (true);
   }

   bool subset (hb_subset_context_t* c) const
   {
     TRACE_SUBSET (this);

     sbix *sbix_prime = c->serializer->start_embed<sbix> ();
     if (unlikely (!sbix_prime)) return_trace (false);
     if (unlikely (!c->serializer->embed (this->version))) return_trace (false);
     if (unlikely (!c->serializer->embed (this->flags))) return_trace (false);

     return_trace (serialize_strike_offsets (c));
   }

   protected:
   HBUINT16	version;	/* Table version number — set to 1 */
   HBUINT16	flags;		/* Bit 0: Set to 1. Bit 1: Draw outlines.
 				 * Bits 2 to 15: reserved (set to 0). */
   Array32OfOffset32To<SBIXStrike>
 		strikes;	/* Offsets from the beginning of the 'sbix'
 				 * table to data for each individual bitmap strike. */
   public:
   DEFINE_SIZE_ARRAY (8, strikes);
 };

 struct sbix_accelerator_t : sbix::accelerator_t {};

 } /* namespace OT */

 #endif /* HB_OT_COLOR_SBIX_TABLE_HH */
	/*
	* Copyright © 2018 Ebrahim Byagowi
	* Copyright © 2020 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): Calder Kitagawa
	*/

	#ifndef HB_OT_COLOR_SBIX_TABLE_HH
	#define HB_OT_COLOR_SBIX_TABLE_HH

	#include "hb-open-type.hh"
	#include "hb-ot-layout-common.hh"

	/*
	* sbix -- Standard Bitmap Graphics
	* https://docs.microsoft.com/en-us/typography/opentype/spec/sbix
	* https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6sbix.html
	*/
	#define HB_OT_TAG_sbix HB_TAG('s','b','i','x')


	namespace OT {


	struct SBIXGlyph
	{
	SBIXGlyph* copy (hb_serialize_context_t *c, unsigned int data_length) const
	{
	TRACE_SERIALIZE (this);
	SBIXGlyph* new_glyph = c->start_embed<SBIXGlyph> ();
	if (unlikely (!new_glyph)) return_trace (nullptr);
	if (unlikely (!c->extend_min (new_glyph))) return_trace (nullptr);

	new_glyph->xOffset = xOffset;
	new_glyph->yOffset = yOffset;
	new_glyph->graphicType = graphicType;
	data.copy (c, data_length);
	return_trace (new_glyph);
	}

	HBINT16 xOffset; /* The horizontal (x-axis) offset from the left
	* edge of the graphic to the glyph’s origin.
	* That is, the x-coordinate of the point on the
	* baseline at the left edge of the glyph. */
	HBINT16 yOffset; /* The vertical (y-axis) offset from the bottom
	* edge of the graphic to the glyph’s origin.
	* That is, the y-coordinate of the point on the
	* baseline at the left edge of the glyph. */
	Tag graphicType; /* Indicates the format of the embedded graphic
	* data: one of 'jpg ', 'png ' or 'tiff', or the
	* special format 'dupe'. */
	UnsizedArrayOf<HBUINT8>
	data; /* The actual embedded graphic data. The total
	* length is inferred from sequential entries in
	* the glyphDataOffsets array and the fixed size
	* (8 bytes) of the preceding fields. */
	public:
	DEFINE_SIZE_ARRAY (8, data);
	};

	struct SBIXStrike
	{
	static unsigned int get_size (unsigned num_glyphs)
	{ return min_size + num_glyphs * HBUINT32::static_size; }

	bool sanitize (hb_sanitize_context_t *c) const
	{
	TRACE_SANITIZE (this);
	return_trace (c->check_struct (this) &&
	imageOffsetsZ.sanitize_shallow (c, c->get_num_glyphs () + 1));
	}

	hb_blob_t *get_glyph_blob (unsigned int glyph_id,
	hb_blob_t *sbix_blob,
	hb_tag_t file_type,
	int *x_offset,
	int *y_offset,
	unsigned int num_glyphs,
	unsigned int *strike_ppem) const
	{
	if (unlikely (!ppem)) return hb_blob_get_empty (); /* To get Null() object out of the way. */

	unsigned int retry_count = 8;
	unsigned int sbix_len = sbix_blob->length;
	unsigned int strike_offset = (const char ) this - (const char ) sbix_blob->data;
	assert (strike_offset < sbix_len);

	retry:
	if (unlikely (glyph_id >= num_glyphs \|\|
	imageOffsetsZ[glyph_id + 1] <= imageOffsetsZ[glyph_id] \|\|
	imageOffsetsZ[glyph_id + 1] - imageOffsetsZ[glyph_id] <= SBIXGlyph::min_size \|\|
	(unsigned int) imageOffsetsZ[glyph_id + 1] > sbix_len - strike_offset))
	return hb_blob_get_empty ();

	unsigned int glyph_offset = strike_offset + (unsigned int) imageOffsetsZ[glyph_id] + SBIXGlyph::min_size;
	unsigned int glyph_length = imageOffsetsZ[glyph_id + 1] - imageOffsetsZ[glyph_id] - SBIXGlyph::min_size;

	const SBIXGlyph *glyph = &(this+imageOffsetsZ[glyph_id]);

	if (glyph->graphicType == HB_TAG ('d','u','p','e'))
	{
	if (glyph_length >= 2)
	{
	glyph_id = ((HBUINT16 ) &glyph->data);
	if (retry_count--)
	goto retry;
	}
	return hb_blob_get_empty ();
	}

	if (unlikely (file_type != glyph->graphicType))
	return hb_blob_get_empty ();

	if (strike_ppem) *strike_ppem = ppem;
	if (x_offset) *x_offset = glyph->xOffset;
	if (y_offset) *y_offset = glyph->yOffset;
	return hb_blob_create_sub_blob (sbix_blob, glyph_offset, glyph_length);
	}

	bool subset (hb_subset_context_t *c, unsigned int available_len) const
	{
	TRACE_SUBSET (this);
	unsigned int num_output_glyphs = c->plan->num_output_glyphs ();

	auto* out = c->serializer->start_embed<SBIXStrike> ();
	if (unlikely (!out)) return_trace (false);
	auto snap = c->serializer->snapshot ();
	if (unlikely (!c->serializer->extend (out, num_output_glyphs + 1))) return_trace (false);
	out->ppem = ppem;
	out->resolution = resolution;
	HBUINT32 head;
	head = get_size (num_output_glyphs + 1);

	bool has_glyphs = false;
	for (unsigned new_gid = 0; new_gid < num_output_glyphs; new_gid++)
	{
	hb_codepoint_t old_gid;
	if (!c->plan->old_gid_for_new_gid (new_gid, &old_gid) \|\|
	unlikely (imageOffsetsZ[old_gid].is_null () \|\|
	imageOffsetsZ[old_gid + 1].is_null () \|\|
	imageOffsetsZ[old_gid + 1] <= imageOffsetsZ[old_gid] \|\|
	imageOffsetsZ[old_gid + 1] - imageOffsetsZ[old_gid] <= SBIXGlyph::min_size) \|\|
	(unsigned int) imageOffsetsZ[old_gid + 1] > available_len)
	{
	out->imageOffsetsZ[new_gid] = head;
	continue;
	}
	has_glyphs = true;
	unsigned int delta = imageOffsetsZ[old_gid + 1] - imageOffsetsZ[old_gid];
	unsigned int glyph_data_length = delta - SBIXGlyph::min_size;
	if (!(this+imageOffsetsZ[old_gid]).copy (c->serializer, glyph_data_length))
	return_trace (false);
	out->imageOffsetsZ[new_gid] = head;
	head += delta;
	}
	if (has_glyphs)
	out->imageOffsetsZ[num_output_glyphs] = head;
	else
	c->serializer->revert (snap);
	return_trace (has_glyphs);
	}

	public:
	HBUINT16 ppem; /* The PPEM size for which this strike was designed. */
	HBUINT16 resolution; /* The device pixel density (in PPI) for which this
	* strike was designed. (E.g., 96 PPI, 192 PPI.) */
	protected:
	UnsizedArrayOf<Offset32To<SBIXGlyph>>
	imageOffsetsZ; /* Offset from the beginning of the strike data header
	* to bitmap data for an individual glyph ID. */
	public:
	DEFINE_SIZE_ARRAY (4, imageOffsetsZ);
	};

	struct sbix
	{
	static constexpr hb_tag_t tableTag = HB_OT_TAG_sbix;

	bool has_data () const { return version; }

	const SBIXStrike &get_strike (unsigned int i) const { return this+strikes[i]; }

	struct accelerator_t
	{
	void init (hb_face_t *face)
	{
	table = hb_sanitize_context_t ().reference_table<sbix> (face);
	num_glyphs = face->get_num_glyphs ();
	}
	void fini () { table.destroy (); }

	bool has_data () const { return table->has_data (); }

	bool get_extents (hb_font_t *font,
	hb_codepoint_t glyph,
	hb_glyph_extents_t *extents) const
	{
	/* We only support PNG right now, and following function checks type. */
	return get_png_extents (font, glyph, extents);
	}

	hb_blob_t reference_png (hb_font_t font,
	hb_codepoint_t glyph_id,
	int *x_offset,
	int *y_offset,
	unsigned int *available_ppem) const
	{
	return choose_strike (font).get_glyph_blob (glyph_id, table.get_blob (),
	HB_TAG ('p','n','g',' '),
	x_offset, y_offset,
	num_glyphs, available_ppem);
	}

	private:

	const SBIXStrike &choose_strike (hb_font_t *font) const
	{
	unsigned count = table->strikes.len;
	if (unlikely (!count))
	return Null (SBIXStrike);

	unsigned int requested_ppem = hb_max (font->x_ppem, font->y_ppem);
	if (!requested_ppem)
	requested_ppem = 1<<30; /* Choose largest strike. */
	/* TODO Add DPI sensitivity as well? */
	unsigned int best_i = 0;
	unsigned int best_ppem = table->get_strike (0).ppem;

	for (unsigned int i = 1; i < count; i++)
	{
	unsigned int ppem = (table->get_strike (i)).ppem;
	if ((requested_ppem <= ppem && ppem < best_ppem) \|\|
	(requested_ppem > best_ppem && ppem > best_ppem))
	{
	best_i = i;
	best_ppem = ppem;
	}
	}

	return table->get_strike (best_i);
	}

	struct PNGHeader
	{
	HBUINT8 signature[8];
	struct
	{
	struct
	{
	HBUINT32 length;
	Tag type;
	} header;
	HBUINT32 width;
	HBUINT32 height;
	HBUINT8 bitDepth;
	HBUINT8 colorType;
	HBUINT8 compressionMethod;
	HBUINT8 filterMethod;
	HBUINT8 interlaceMethod;
	} IHDR;

	public:
	DEFINE_SIZE_STATIC (29);
	};

	bool get_png_extents (hb_font_t *font,
	hb_codepoint_t glyph,
	hb_glyph_extents_t *extents) const
	{
	/* Following code is safe to call even without data.
	* But faster to short-circuit. */
	if (!has_data ())
	return false;

	int x_offset = 0, y_offset = 0;
	unsigned int strike_ppem = 0;
	hb_blob_t *blob = reference_png (font, glyph, &x_offset, &y_offset, &strike_ppem);

	const PNGHeader &png = *blob->as<PNGHeader>();

	extents->x_bearing = x_offset;
	extents->y_bearing = png.IHDR.height + y_offset;
	extents->width = png.IHDR.width;
	extents->height = -1 * png.IHDR.height;

	/* Convert to font units. */
	if (strike_ppem)
	{
	float scale = font->face->get_upem () / (float) strike_ppem;
	extents->x_bearing = font->em_scalef_x (extents->x_bearing * scale);
	extents->y_bearing = font->em_scalef_y (extents->y_bearing * scale);
	extents->width = font->em_scalef_x (extents->width * scale);
	extents->height = font->em_scalef_y (extents->height * scale);
	}
	else
	{
	extents->x_bearing = font->em_scale_x (extents->x_bearing);
	extents->y_bearing = font->em_scale_y (extents->y_bearing);
	extents->width = font->em_scale_x (extents->width);
	extents->height = font->em_scale_y (extents->height);
	}

	hb_blob_destroy (blob);

	return strike_ppem;
	}

	private:
	hb_blob_ptr_t<sbix> table;

	unsigned int num_glyphs;
	};

	bool sanitize (hb_sanitize_context_t *c) const
	{
	TRACE_SANITIZE (this);
	return_trace (likely (c->check_struct (this) &&
	version >= 1 &&
	strikes.sanitize (c, this)));
	}

	bool
	add_strike (hb_subset_context_t *c, unsigned i) const
	{
	if (strikes[i].is_null () \|\| c->source_blob->length < (unsigned) strikes[i])
	return false;

	return (this+strikes[i]).subset (c, c->source_blob->length - (unsigned) strikes[i]);
	}

	bool serialize_strike_offsets (hb_subset_context_t *c) const
	{
	TRACE_SERIALIZE (this);

	auto *out = c->serializer->start_embed<Array32OfOffset32To<SBIXStrike>> ();
	if (unlikely (!out)) return_trace (false);
	if (unlikely (!c->serializer->extend_min (out))) return_trace (false);

	hb_vector_t<Offset32To<SBIXStrike>*> new_strikes;
	hb_vector_t<hb_serialize_context_t::objidx_t> objidxs;
	for (int i = strikes.len - 1; i >= 0; --i)
	{
	auto* o = out->serialize_append (c->serializer);
	if (unlikely (!o)) return_trace (false);
	*o = 0;
	auto snap = c->serializer->snapshot ();
	c->serializer->push ();
	bool ret = add_strike (c, i);
	if (!ret)
	{
	c->serializer->pop_discard ();
	out->pop ();
	c->serializer->revert (snap);
	}
	else
	{
	objidxs.push (c->serializer->pop_pack ());
	new_strikes.push (o);
	}
	}
	for (unsigned int i = 0; i < new_strikes.length; ++i)
	c->serializer->add_link (*new_strikes[i], objidxs[new_strikes.length - 1 - i]);

	return_trace (true);
	}

	bool subset (hb_subset_context_t* c) const
	{
	TRACE_SUBSET (this);

	sbix *sbix_prime = c->serializer->start_embed<sbix> ();
	if (unlikely (!sbix_prime)) return_trace (false);
	if (unlikely (!c->serializer->embed (this->version))) return_trace (false);
	if (unlikely (!c->serializer->embed (this->flags))) return_trace (false);

	return_trace (serialize_strike_offsets (c));
	}

	protected:
	HBUINT16 version; /* Table version number — set to 1 */
	HBUINT16 flags; /* Bit 0: Set to 1. Bit 1: Draw outlines.
	* Bits 2 to 15: reserved (set to 0). */
	Array32OfOffset32To<SBIXStrike>
	strikes; /* Offsets from the beginning of the 'sbix'
	* table to data for each individual bitmap strike. */
	public:
	DEFINE_SIZE_ARRAY (8, strikes);
	};

	struct sbix_accelerator_t : sbix::accelerator_t {};

	} /* namespace OT */

	#endif /* HB_OT_COLOR_SBIX_TABLE_HH */