harfbuzz/src/hb-ot-color-sbix-table.hh

287 lines
8.6 KiB
C++
Raw Normal View History

/*
* Copyright © 2018 Ebrahim Byagowi
*
* 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.
*/
#ifndef HB_OT_COLOR_SBIX_TABLE_HH
#define HB_OT_COLOR_SBIX_TABLE_HH
#include "hb-open-type.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
{
2018-03-11 20:38:40 +01:00
HBINT16 xOffset; /* The horizontal (x-axis) offset from the left
* edge of the graphic to the glyphs 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 glyphs 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'. */
2018-04-11 14:43:20 +02:00
UnsizedArrayOf<HBUINT8>
data; /* The actual embedded graphic data. The total
2018-03-11 20:38:40 +01:00
* length is inferred from sequential entries in
* the glyphDataOffsets array and the fixed size
* (8 bytes) of the preceding fields. */
public:
2018-03-11 20:38:40 +01:00
DEFINE_SIZE_ARRAY (8, data);
};
2018-03-11 20:38:40 +01:00
struct SBIXStrike
{
bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
return_trace (c->check_struct (this) &&
2018-07-17 18:45:25 +02:00
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
2018-10-26 22:25:11 +02:00
{
if (unlikely (!ppem)) return hb_blob_get_empty (); /* To get Null() object out of the way. */
2018-10-28 23:30:57 +01:00
unsigned int retry_count = 8;
2018-10-28 23:12:05 +01:00
unsigned int sbix_len = sbix_blob->length;
2018-10-28 23:11:10 +01:00
unsigned int strike_offset = (const char *) this - (const char *) sbix_blob->data;
assert (strike_offset < sbix_len);
2018-10-28 23:30:57 +01:00
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))
2018-10-26 22:25:11 +02:00
return hb_blob_get_empty ();
2018-10-28 23:36:17 +01:00
unsigned int glyph_offset = strike_offset + (unsigned int) imageOffsetsZ[glyph_id] + SBIXGlyph::min_size;
2018-10-28 23:43:54 +01:00
unsigned int glyph_length = imageOffsetsZ[glyph_id + 1] - imageOffsetsZ[glyph_id] - SBIXGlyph::min_size;
2018-10-26 22:25:11 +02:00
const SBIXGlyph *glyph = &(this+imageOffsetsZ[glyph_id]);
2018-10-28 23:30:57 +01:00
if (glyph->graphicType == HB_TAG ('d','u','p','e'))
2018-10-26 22:25:11 +02:00
{
2018-10-28 23:43:54 +01:00
if (glyph_length >= 2)
2018-10-26 22:25:11 +02:00
{
2018-10-28 23:30:57 +01:00
glyph_id = *((HBUINT16 *) &glyph->data);
if (retry_count--)
2018-10-28 23:30:57 +01:00
goto retry;
2018-10-26 22:25:11 +02:00
}
2018-10-28 23:30:57 +01:00
return hb_blob_get_empty ();
2018-10-26 22:25:11 +02:00
}
2018-10-28 23:30:57 +01:00
2018-10-28 19:08:56 +01:00
if (unlikely (file_type != glyph->graphicType))
2018-10-26 22:25:11 +02:00
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;
2018-10-28 23:43:54 +01:00
return hb_blob_create_sub_blob (sbix_blob, glyph_offset, glyph_length);
2018-10-26 22:25:11 +02:00
}
public:
2018-04-11 14:43:20 +02:00
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:
2018-04-11 14:43:20 +02:00
UnsizedArrayOf<LOffsetTo<SBIXGlyph> >
imageOffsetsZ; /* Offset from the beginning of the strike data header
* to bitmap data for an individual glyph ID. */
public:
DEFINE_SIZE_STATIC (8);
};
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]; }
2018-10-29 00:26:03 +01:00
struct accelerator_t
{
void init (hb_face_t *face)
{
table = hb_sanitize_context_t().reference_table<sbix> (face);
2018-10-26 22:25:11 +02:00
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
2018-10-28 23:11:10 +01:00
{
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);
2018-10-28 23:11:10 +01:00
}
private:
const SBIXStrike &choose_strike (hb_font_t *font) const
2018-10-26 22:25:11 +02:00
{
2018-10-29 07:14:15 +01:00
unsigned count = table->strikes.len;
if (unlikely (!count))
2018-10-28 23:11:10 +01:00
return Null(SBIXStrike);
2018-10-26 22:25:11 +02:00
unsigned int requested_ppem = 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;
2018-10-29 00:26:03 +01:00
unsigned int best_ppem = table->get_strike (0).ppem;
2018-10-29 07:14:15 +01:00
for (unsigned int i = 1; i < count; i++)
{
2018-10-29 00:26:03 +01:00
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;
}
}
2018-10-26 22:25:11 +02:00
2018-10-29 00:26:03 +01:00
return table->get_strike (best_i);
}
struct PNGHeader
{
2018-10-28 21:58:44 +01:00
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. */
2018-10-28 23:58:48 +01:00
if (!has_data ())
return false;
2018-10-28 22:52:25 +01:00
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);
2018-10-28 21:37:26 +01:00
2018-10-28 22:52:25 +01:00
const PNGHeader &png = *blob->as<PNGHeader>();
extents->x_bearing = x_offset;
extents->y_bearing = y_offset;
extents->width = png.IHDR.width;
extents->height = png.IHDR.height;
2018-10-29 06:45:53 +01:00
/* Convert to font units. */
if (strike_ppem)
{
double scale = font->face->get_upem () / (double) strike_ppem;
2018-10-29 06:45:53 +01:00
extents->x_bearing = round (extents->x_bearing * scale);
extents->y_bearing = round (extents->y_bearing * scale);
extents->width = round (extents->width * scale);
extents->height = round (extents->height * scale);
}
hb_blob_destroy (blob);
return strike_ppem;
2018-10-26 22:25:11 +02:00
}
private:
hb_blob_ptr_t<sbix> table;
unsigned int num_glyphs;
};
bool sanitize (hb_sanitize_context_t *c) const
2018-10-28 23:58:48 +01:00
{
TRACE_SANITIZE (this);
return_trace (likely (c->check_struct (this) &&
version >= 1 &&
strikes.sanitize (c, this)));
}
protected:
2018-03-11 20:38:40 +01:00
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). */
2018-10-29 00:27:18 +01:00
LOffsetLArrayOf<SBIXStrike>
2018-03-11 20:38:40 +01:00
strikes; /* Offsets from the beginning of the 'sbix'
* table to data for each individual bitmap strike. */
public:
2018-03-11 20:38:40 +01:00
DEFINE_SIZE_ARRAY (8, strikes);
};
struct sbix_accelerator_t : sbix::accelerator_t {};
} /* namespace OT */
#endif /* HB_OT_COLOR_SBIX_TABLE_HH */