diff options
Diffstat (limited to 'gfx/graphite2/geckoextra/src/GraphiteExtra.cpp')
| -rw-r--r-- | gfx/graphite2/geckoextra/src/GraphiteExtra.cpp | 167 |
1 files changed, 167 insertions, 0 deletions
diff --git a/gfx/graphite2/geckoextra/src/GraphiteExtra.cpp b/gfx/graphite2/geckoextra/src/GraphiteExtra.cpp new file mode 100644 index 0000000000..b5c8802b15 --- /dev/null +++ b/gfx/graphite2/geckoextra/src/GraphiteExtra.cpp @@ -0,0 +1,167 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "graphite2/Font.h" +#include "graphite2/Segment.h" +#include "graphite2/GraphiteExtra.h" + +#include <stdlib.h> +#include <memory> +#include <limits> + +#define CHECK(cond, str) \ + do { \ + if (!(cond)) { \ + return false; \ + } \ + } while (false) + +// High surrogates are in the range 0xD800 -- OxDBFF +#define NS_IS_HIGH_SURROGATE(u) ((uint32_t(u) & 0xFFFFFC00) == 0xD800) +// Low surrogates are in the range 0xDC00 -- 0xDFFF +#define NS_IS_LOW_SURROGATE(u) ((uint32_t(u) & 0xFFFFFC00) == 0xDC00) + +#define IS_POWER_OF_2(n) (n & (n - 1)) == 0 + +typedef gr_glyph_to_char_cluster Cluster; + +// returns whether successful +static bool LoopThrough(gr_segment* aSegment, const uint32_t aLength, + const uint32_t aGlyphCount, const char16_t* aText, + uint32_t& aCIndex, Cluster* aClusters, uint16_t* aGids, + float* aXLocs, float* aYLocs) { + // walk through the glyph slots and check which original character + // each is associated with + uint32_t gIndex = 0; // glyph slot index + for (const gr_slot* slot = gr_seg_first_slot(aSegment); slot != nullptr; + slot = gr_slot_next_in_segment(slot), gIndex++) { + CHECK(gIndex < aGlyphCount, "iterating past glyphcount"); + uint32_t before = + gr_cinfo_base(gr_seg_cinfo(aSegment, gr_slot_before(slot))); + uint32_t after = gr_cinfo_base(gr_seg_cinfo(aSegment, gr_slot_after(slot))); + aGids[gIndex] = gr_slot_gid(slot); + aXLocs[gIndex] = gr_slot_origin_X(slot); + aYLocs[gIndex] = gr_slot_origin_Y(slot); + + // if this glyph has a "before" character index that precedes the + // current cluster's char index, we need to merge preceding + // aClusters until it gets included + while (before < aClusters[aCIndex].baseChar && aCIndex > 0) { + aClusters[aCIndex - 1].nChars += aClusters[aCIndex].nChars; + aClusters[aCIndex - 1].nGlyphs += aClusters[aCIndex].nGlyphs; + --aCIndex; + } + + // if there's a gap between the current cluster's base character and + // this glyph's, extend the cluster to include the intervening chars + if (gr_slot_can_insert_before(slot) && aClusters[aCIndex].nChars && + before >= aClusters[aCIndex].baseChar + aClusters[aCIndex].nChars) { + CHECK(aCIndex < aLength - 1, "aCIndex at end of word"); + Cluster& c = aClusters[aCIndex + 1]; + c.baseChar = aClusters[aCIndex].baseChar + aClusters[aCIndex].nChars; + c.nChars = before - c.baseChar; + c.baseGlyph = gIndex; + c.nGlyphs = 0; + ++aCIndex; + } + + // increment cluster's glyph count to include current slot + CHECK(aCIndex < aLength, "aCIndex beyond word length"); + ++aClusters[aCIndex].nGlyphs; + + // bump |after| index if it falls in the middle of a surrogate pair + if (NS_IS_HIGH_SURROGATE(aText[after]) && after < aLength - 1 && + NS_IS_LOW_SURROGATE(aText[after + 1])) { + after++; + } + + // extend cluster if necessary to reach the glyph's "after" index + if (aClusters[aCIndex].baseChar + aClusters[aCIndex].nChars < after + 1) { + aClusters[aCIndex].nChars = after + 1 - aClusters[aCIndex].baseChar; + } + } + + // Succeeded + return true; +} + +static gr_glyph_to_char_association* calloc_glyph_to_char_association( + uint32_t aGlyphCount, uint32_t aLength) { + using Type1 = gr_glyph_to_char_association; + using Type2 = gr_glyph_to_char_cluster; + using Type3 = float; + using Type4 = float; + using Type5 = uint16_t; + + // We are allocating memory in a pool. To avoid dealing with thorny alignment + // issues, we allocate from most to least aligned + static_assert( + alignof(Type1) >= alignof(Type2) && alignof(Type2) >= alignof(Type3) && + alignof(Type3) >= alignof(Type4) && alignof(Type4) >= alignof(Type5), + "Unexpected alignments of types"); + + const uint64_t size1 = sizeof(Type1) * static_cast<uint64_t>(1); + const uint64_t size2 = sizeof(Type2) * static_cast<uint64_t>(aLength); + const uint64_t size3 = sizeof(Type3) * static_cast<uint64_t>(aGlyphCount); + const uint64_t size4 = sizeof(Type4) * static_cast<uint64_t>(aGlyphCount); + const uint64_t size5 = sizeof(Type5) * static_cast<uint64_t>(aGlyphCount); + + uint64_t totalSize = size1 + size2 + size3 + size4 + size5; + + if (totalSize > std::numeric_limits<uint32_t>::max()) { + // allocation request got too large + return nullptr; + } + + char* const memoryPool = static_cast<char*>(calloc(1, totalSize)); + if (!memoryPool) { + return nullptr; + } + + char* currentPoolFront = memoryPool; + + auto data = reinterpret_cast<Type1*>(currentPoolFront); + currentPoolFront += size1; + data->clusters = reinterpret_cast<Type2*>(currentPoolFront); + currentPoolFront += size2; + data->xLocs = reinterpret_cast<Type3*>(currentPoolFront); + currentPoolFront += size3; + data->yLocs = reinterpret_cast<Type4*>(currentPoolFront); + currentPoolFront += size4; + data->gids = reinterpret_cast<Type5*>(currentPoolFront); + + return data; +} + +// returns nullptr on failure and the glyph to char association on success +gr_glyph_to_char_association* gr_get_glyph_to_char_association( + gr_segment* aSegment, uint32_t aLength, const char16_t* aText) { + uint32_t glyphCount = gr_seg_n_slots(aSegment); + + gr_glyph_to_char_association* data = + calloc_glyph_to_char_association(glyphCount, aLength); + if (!data) { + return nullptr; + } + + bool succeeded = + LoopThrough(aSegment, aLength, glyphCount, aText, data->cIndex, + data->clusters, data->gids, data->xLocs, data->yLocs); + if (!succeeded) { + gr_free_char_association(data); + return nullptr; + } + return data; +} + +void gr_free_char_association(gr_glyph_to_char_association* aData) { + free(aData); +} + +#undef CHECK +#undef NS_IS_HIGH_SURROGATE +#undef NS_IS_LOW_SURROGATE +#undef IS_POWER_OF_2 |