src/hb-open-type-private.hh | 99 +++++++++++++++++++++++++++++++++++++ src/hb-ot-layout-common-private.hh | 62 +++++++++++++++++++++++ src/hb-ot-shape-fallback.cc | 8 +- 3 files changed, 165 insertions(+), 4 deletions(-)
New commits: commit 5a7f18767a87a3f07269d0814f984a98f86ab852 Author: Behdad Esfahbod <[email protected]> Date: Thu Aug 30 22:53:29 2012 -0400 [OT] Better fallback-position Thai / Lao ccc!=0 marks diff --git a/src/hb-ot-shape-fallback.cc b/src/hb-ot-shape-fallback.cc index aa6239c..abacfa3 100644 --- a/src/hb-ot-shape-fallback.cc +++ b/src/hb-ot-shape-fallback.cc @@ -105,19 +105,19 @@ recategorize_combining_class (unsigned int modified_combining_class) * But viramas can be both above and below based on the codepoint / script. */ case HB_MODIFIED_COMBINING_CLASS_CCC103: /* sara u / sara uu */ - return HB_UNICODE_COMBINING_CLASS_BELOW; + return HB_UNICODE_COMBINING_CLASS_BELOW_RIGHT; case HB_MODIFIED_COMBINING_CLASS_CCC107: /* mai */ - return HB_UNICODE_COMBINING_CLASS_ABOVE; + return HB_UNICODE_COMBINING_CLASS_ABOVE_RIGHT; /* Lao */ case HB_MODIFIED_COMBINING_CLASS_CCC118: /* sign u / sign uu */ - return HB_UNICODE_COMBINING_CLASS_BELOW; + return HB_UNICODE_COMBINING_CLASS_BELOW_RIGHT; case HB_MODIFIED_COMBINING_CLASS_CCC122: /* mai */ - return HB_UNICODE_COMBINING_CLASS_ABOVE; + return HB_UNICODE_COMBINING_CLASS_ABOVE_RIGHT; /* Tibetan */ commit 9f2348de58f0f85593027378169bc03c4dd64e59 Author: Behdad Esfahbod <[email protected]> Date: Wed Aug 29 21:08:59 2012 -0400 [OT] Add serialize() for Coverage diff --git a/src/hb-open-type-private.hh b/src/hb-open-type-private.hh index 7cd8212..10e777e 100644 --- a/src/hb-open-type-private.hh +++ b/src/hb-open-type-private.hh @@ -337,7 +337,7 @@ struct Sanitizer #define TRACE_SERIALIZE() \ - hb_auto_trace_t<HB_DEBUG_SERIALIZE> trace (&c->debug_depth, "SERIALIZE", this, HB_FUNC, ""); + hb_auto_trace_t<HB_DEBUG_SERIALIZE> trace (&c->debug_depth, "SERIALIZE", c, HB_FUNC, ""); struct hb_serialize_context_t @@ -371,25 +371,43 @@ struct hb_serialize_context_t } template <typename Type> - inline Type *allocate (unsigned int size = -1, unsigned int alignment = 2) + inline Type *allocate (unsigned int size, unsigned int alignment = 2) { - if (size == -1) - size == Type::static_size; unsigned int padding = (alignment - (this->head - this->start) % alignment) % alignment; /* TODO speedup */ if (unlikely (this->ran_out_of_room || this->end - this->head > padding + size)) { this->ran_out_of_room = true; return NULL; } this->head += padding; - const char *ret = this->head; + char *ret = this->head; this->head += size; return reinterpret_cast<Type *> (ret); } template <typename Type> + inline Type *allocate_min (unsigned int alignment = 2) + { + return this->allocate<Type> (Type::min_size, alignment); + } + + template <typename Type> inline Type *embed (const Type &obj, unsigned int alignment = 2) { - return allocate (obj.size (), alignment); + return this->allocate<Type> (obj.get_size (), alignment); + } + + template <typename Type> + inline Type *extend (Type &obj, unsigned int size, unsigned int alignment = 2) + { + assert (this->start < (char *) &obj && (char *) &obj <= this->head && (char *) &obj + size >= this->head); + this->allocate<Type> (((char *) &obj) + size - this->head, alignment); + return reinterpret_cast<Type *> (&obj); + } + + template <typename Type> + inline Type *extend (Type &obj) + { + return this->extend<Type> (obj, obj.get_size ()); } inline void truncate (void *head) @@ -630,6 +648,10 @@ struct GenericArrayOf if (unlikely (i >= len)) return Null(Type); return array[i]; } + inline Type& operator [] (unsigned int i) + { + return array[i]; + } inline unsigned int get_size (void) const { return len.static_size + len * Type::static_size; } diff --git a/src/hb-ot-layout-common-private.hh b/src/hb-ot-layout-common-private.hh index 48c7e0c..91d5a19 100644 --- a/src/hb-ot-layout-common-private.hh +++ b/src/hb-ot-layout-common-private.hh @@ -355,6 +355,21 @@ struct CoverageFormat1 return i; } + inline static bool serialize (hb_serialize_context_t *c, + const USHORT *glyphs, + unsigned int num_glyphs) + { + TRACE_SERIALIZE (); + CoverageFormat1 *t = c->allocate_min<CoverageFormat1> (); + if (unlikely (!t)) return TRACE_RETURN (false); + t->coverageFormat.set (1); + t->glyphArray.len.set (num_glyphs); + if (unlikely (!c->extend (t->glyphArray))) return TRACE_RETURN (false); + for (unsigned int i = 0; i < num_glyphs; i++) + t->glyphArray[i].set (glyphs[i]); + return TRACE_RETURN (true); + } + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); return TRACE_RETURN (glyphArray.sanitize (c)); @@ -406,6 +421,35 @@ struct CoverageFormat2 return NOT_COVERED; } + inline static bool serialize (hb_serialize_context_t *c, + const USHORT *glyphs, + unsigned int num_glyphs) + { + TRACE_SERIALIZE (); + CoverageFormat2 *t = c->allocate_min<CoverageFormat2> (); + unsigned int num_ranges = 1; + for (unsigned int i = 1; i < num_glyphs; i++) + if (glyphs[i - 1] + 1 != glyphs[i]) + num_ranges++; + if (unlikely (!t)) return TRACE_RETURN (false); + t->coverageFormat.set (2); + t->rangeRecord.len.set (num_ranges); + if (unlikely (!c->extend (t->rangeRecord))) return TRACE_RETURN (false); + if (unlikely (!num_glyphs)) return TRACE_RETURN (true); + unsigned int range = 0; + t->rangeRecord[range].start.set (glyphs[0]); + t->rangeRecord[range].value.set (0); + for (unsigned int i = 1; i < num_glyphs; i++) + if (glyphs[i - 1] + 1 != glyphs[i]) { + t->rangeRecord[range].start.set (glyphs[i]); + t->rangeRecord[range].value.set (i); + range++; + } else { + t->rangeRecord[range].end = glyphs[i]; + } + return TRACE_RETURN (true); + } + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); return TRACE_RETURN (rangeRecord.sanitize (c)); @@ -482,6 +526,24 @@ struct Coverage } } + inline static bool serialize (hb_serialize_context_t *c, + const USHORT *glyphs, + unsigned int num_glyphs) + { + TRACE_SERIALIZE (); + unsigned int format; + unsigned int num_ranges = 1; + for (unsigned int i = 1; i < num_glyphs; i++) + if (glyphs[i - 1] + 1 != glyphs[i]) + num_ranges++; + format = num_glyphs * 2 < num_ranges * 3 ? 1 : 2; + switch (format) { + case 1: return TRACE_RETURN (CoverageFormat1::serialize (c, glyphs, num_glyphs)); + case 2: return TRACE_RETURN (CoverageFormat2::serialize (c, glyphs, num_glyphs)); + default:return TRACE_RETURN (false); + } + } + inline bool sanitize (hb_sanitize_context_t *c) { TRACE_SANITIZE (); if (!u.format.sanitize (c)) return TRACE_RETURN (false); commit e901b954c6ec44ac3ae7fb3c326e6e7a40718e4b Author: Behdad Esfahbod <[email protected]> Date: Wed Aug 29 20:26:08 2012 -0400 [OT] Start adding serialize() API diff --git a/src/hb-open-type-private.hh b/src/hb-open-type-private.hh index 4cbb855..7cd8212 100644 --- a/src/hb-open-type-private.hh +++ b/src/hb-open-type-private.hh @@ -327,6 +327,83 @@ struct Sanitizer +/* + * Serialize + */ + +#ifndef HB_DEBUG_SERIALIZE +#define HB_DEBUG_SERIALIZE (HB_DEBUG+0) +#endif + + +#define TRACE_SERIALIZE() \ + hb_auto_trace_t<HB_DEBUG_SERIALIZE> trace (&c->debug_depth, "SERIALIZE", this, HB_FUNC, ""); + + +struct hb_serialize_context_t +{ + inline void init (void *start, unsigned int size) + { + this->start = (char *) start; + this->end = this->start + size; + } + + inline void start_processing (void) + { + this->ran_out_of_room = false; + this->head = this->start; + this->debug_depth = 0; + + DEBUG_MSG_LEVEL (SERIALIZE, this->start, 0, +1, + "start [%p..%p] (%lu bytes)", + this->start, this->end, + (unsigned long) (this->end - this->start)); + } + + inline void end_processing (void) + { + DEBUG_MSG_LEVEL (SERIALIZE, this->start, 0, -1, + "end [%p..%p] %s", + this->start, this->end, + this->ran_out_of_room ? "RAN OUT OF ROOM" : "did not ran out of room"); + + this->start = this->end = this->head = NULL; + } + + template <typename Type> + inline Type *allocate (unsigned int size = -1, unsigned int alignment = 2) + { + if (size == -1) + size == Type::static_size; + unsigned int padding = (alignment - (this->head - this->start) % alignment) % alignment; /* TODO speedup */ + if (unlikely (this->ran_out_of_room || this->end - this->head > padding + size)) { + this->ran_out_of_room = true; + return NULL; + } + this->head += padding; + const char *ret = this->head; + this->head += size; + return reinterpret_cast<Type *> (ret); + } + + template <typename Type> + inline Type *embed (const Type &obj, unsigned int alignment = 2) + { + return allocate (obj.size (), alignment); + } + + inline void truncate (void *head) + { + assert (this->start < head && head <= this->head); + this->head = (char *) head; + } + + unsigned int debug_depth; + char *start, *end, *head; + bool ran_out_of_room; +}; + + /* * _______________________________________________ HarfBuzz mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/harfbuzz
