mirror of
https://github.com/storytold/harfbuzz.git
synced 2026-11-20 06:21:16 +01:00
* [uniscribe] Read font directories from the sanitized original Renaming a face's name table record can change another face's header when TTC directories overlap. Parsing the edited copy then uses table counts and offsets that were never sanitized. Find each record in the original blob and edit the copy at that byte offset, keeping both directory reads and record writes within validated data. Add a bounded overlapping-collection regression and a non-overlapping control, gated on Uniscribe support. The original renamer fails under ASan; the patched public-API test passes with Windows stand-ins. Ordinary TTF, TTC, and dfont outputs remain byte-identical. MinGW builds the 64-bit Windows executable and the 32-bit backend, including HB_NO_OT_FONT. Windows execution was unavailable. The full native Meson suite passes (274 tests). Reported by Anthropic's OSS Scanner as ANT-2026-2VV35K9M. Assisted-by: OpenAI Codex * [uniscribe] Don't create font data without face data When face-data creation fails -- eg. AddFontMemResourceEx() rejects a malformed font and returns NULL -- face->data.uniscribe is left NULL. populate_log_font() then dereferences it (font->face->data.uniscribe->face_name) and crashes. This is reachable from the public hb_uniscribe_font_get_hfont() and from shaping with any font GDI declines, not just the overlapping-TTC case. Bail out of _hb_uniscribe_shaper_font_data_create() when face data is NULL, matching _hb_coretext_shaper_font_data_create(). This is what made the new test-uniscribe regression crash on the Windows CI jobs: Wine reported "page fault on read access to 0x0000000000000010", ie. a NULL + offsetof(face_name) read. Verified by cross-compiling with MinGW and running the test under Wine: it hits the same 0x10 page fault without this change and exits cleanly with it. Assisted-by: Claude Opus 4.8 <noreply@anthropic.com> * [directwrite] Don't create font data without face data Same NULL face-data dereference as the uniscribe backend: when _hb_directwrite_shaper_face_data_create() fails (dw_face_create() returns NULL for a font DirectWrite rejects), face->data.directwrite is left NULL. _hb_directwrite_shaper_font_data_create() then calls fontFace->QueryInterface() through that NULL pointer and crashes. Bail out when face data is NULL, matching the uniscribe and coretext backends. Assisted-by: Claude Opus 4.8 <noreply@anthropic.com>
665 lines
19 KiB
C++
665 lines
19 KiB
C++
/*
|
|
* 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.
|
|
*
|
|
* Author(s): Behdad Esfahbod
|
|
*/
|
|
|
|
#include "hb.hh"
|
|
|
|
#ifdef HAVE_DIRECTWRITE
|
|
|
|
#include "hb-shaper-impl.hh"
|
|
|
|
#include "hb-directwrite.hh"
|
|
|
|
#include "hb-ms-feature-ranges.hh"
|
|
|
|
|
|
/*
|
|
* shaper face data
|
|
*/
|
|
|
|
hb_directwrite_face_data_t *
|
|
_hb_directwrite_shaper_face_data_create (hb_face_t *face)
|
|
{
|
|
hb_blob_t *blob = hb_face_reference_blob (face);
|
|
|
|
hb_directwrite_face_data_t *data = (hb_directwrite_face_data_t *) dw_face_create (blob, face->index);
|
|
|
|
hb_blob_destroy (blob);
|
|
|
|
return data;
|
|
}
|
|
|
|
void
|
|
_hb_directwrite_shaper_face_data_destroy (hb_directwrite_face_data_t *data)
|
|
{
|
|
((IDWriteFontFace *) data)->Release ();
|
|
}
|
|
|
|
|
|
/*
|
|
* shaper font data
|
|
*/
|
|
|
|
struct hb_directwrite_font_data_t {};
|
|
|
|
hb_directwrite_font_data_t *
|
|
_hb_directwrite_shaper_font_data_create (hb_font_t *font)
|
|
{
|
|
IDWriteFontFace *fontFace = (IDWriteFontFace *) (const void *) font->face->data.directwrite;
|
|
|
|
/* Face data creation may have failed, eg. for a font DirectWrite rejected;
|
|
* we dereference fontFace below, so bail out first. */
|
|
if (unlikely (!fontFace))
|
|
return nullptr;
|
|
|
|
/*
|
|
* Set up variations.
|
|
*/
|
|
IDWriteFontFace5 *fontFaceVariations = nullptr;
|
|
{
|
|
IDWriteFontFace5 *fontFace5;
|
|
if (SUCCEEDED (fontFace->QueryInterface (__uuidof (IDWriteFontFace5), (void **) &fontFace5)))
|
|
{
|
|
IDWriteFontResource *fontResource;
|
|
if (SUCCEEDED (fontFace5->GetFontResource (&fontResource)))
|
|
{
|
|
hb_vector_t<DWRITE_FONT_AXIS_VALUE> axis_values;
|
|
if (likely (axis_values.resize_exact (font->num_coords)))
|
|
{
|
|
for (unsigned int i = 0; i < font->num_coords; i++)
|
|
{
|
|
hb_ot_var_axis_info_t info;
|
|
unsigned int c = 1;
|
|
hb_ot_var_get_axis_infos (font->face, i, &c, &info);
|
|
axis_values[i].axisTag = (DWRITE_FONT_AXIS_TAG) hb_uint32_swap (info.tag);
|
|
axis_values[i].value = i < font->num_coords ?
|
|
hb_clamp (font->design_coords[i], info.min_value, info.max_value) :
|
|
info.default_value;
|
|
}
|
|
|
|
fontResource->CreateFontFace (DWRITE_FONT_SIMULATIONS::DWRITE_FONT_SIMULATIONS_NONE,
|
|
axis_values.arrayZ, axis_values.length, &fontFaceVariations);
|
|
}
|
|
fontResource->Release ();
|
|
}
|
|
fontFace5->Release ();
|
|
}
|
|
}
|
|
|
|
return (hb_directwrite_font_data_t *) fontFaceVariations;
|
|
}
|
|
|
|
void
|
|
_hb_directwrite_shaper_font_data_destroy (hb_directwrite_font_data_t *data)
|
|
{
|
|
((IDWriteFontFace *) (const void *) data)->Release ();
|
|
}
|
|
|
|
|
|
// Most of TextAnalysis is originally written by Bas Schouten for Mozilla project
|
|
// but now is relicensed to MIT for HarfBuzz use
|
|
class TextAnalysis : public IDWriteTextAnalysisSource, public IDWriteTextAnalysisSink
|
|
{
|
|
private:
|
|
hb_reference_count_t mRefCount;
|
|
public:
|
|
IFACEMETHOD (QueryInterface) (IID const& iid, OUT void** ppObject)
|
|
{ return S_OK; }
|
|
IFACEMETHOD_ (ULONG, AddRef) ()
|
|
{
|
|
return mRefCount.inc () + 1;
|
|
}
|
|
IFACEMETHOD_ (ULONG, Release) ()
|
|
{
|
|
signed refCount = mRefCount.dec () - 1;
|
|
assert (refCount >= 0);
|
|
if (refCount)
|
|
return refCount;
|
|
return 0;
|
|
}
|
|
|
|
// A single contiguous run of characters containing the same analysis
|
|
// results.
|
|
struct Run
|
|
{
|
|
uint32_t mTextStart; // starting text position of this run
|
|
uint32_t mTextLength; // number of contiguous code units covered
|
|
uint32_t mGlyphStart; // starting glyph in the glyphs array
|
|
uint32_t mGlyphCount; // number of glyphs associated with this run
|
|
// text
|
|
DWRITE_SCRIPT_ANALYSIS mScript;
|
|
uint8_t mBidiLevel;
|
|
bool mIsSideways;
|
|
|
|
bool ContainsTextPosition (uint32_t aTextPosition) const
|
|
{
|
|
return aTextPosition >= mTextStart &&
|
|
aTextPosition < mTextStart + mTextLength;
|
|
}
|
|
|
|
Run *nextRun;
|
|
};
|
|
|
|
public:
|
|
TextAnalysis (const wchar_t* text, uint32_t textLength,
|
|
const wchar_t* localeName, DWRITE_READING_DIRECTION readingDirection)
|
|
: mTextLength (textLength), mText (text), mLocaleName (localeName),
|
|
mReadingDirection (readingDirection), mCurrentRun (nullptr)
|
|
{
|
|
mRefCount.init ();
|
|
}
|
|
~TextAnalysis ()
|
|
{
|
|
// free runs, except mRunHead which is part of the TextAnalysis object
|
|
for (Run *run = mRunHead.nextRun; run;)
|
|
{
|
|
Run *origRun = run;
|
|
run = run->nextRun;
|
|
hb_free (origRun);
|
|
}
|
|
}
|
|
|
|
STDMETHODIMP
|
|
GenerateResults (IDWriteTextAnalyzer* textAnalyzer, Run **runHead)
|
|
{
|
|
// Analyzes the text using the script analyzer and returns
|
|
// the result as a series of runs.
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
// Initially start out with one result that covers the entire range.
|
|
// This result will be subdivided by the analysis processes.
|
|
mRunHead.mTextStart = 0;
|
|
mRunHead.mTextLength = mTextLength;
|
|
mRunHead.mBidiLevel =
|
|
(mReadingDirection == DWRITE_READING_DIRECTION_RIGHT_TO_LEFT);
|
|
mRunHead.nextRun = nullptr;
|
|
mCurrentRun = &mRunHead;
|
|
|
|
// Call each of the analyzers in sequence, recording their results.
|
|
if (SUCCEEDED (hr = textAnalyzer->AnalyzeScript (this, 0, mTextLength, this)))
|
|
*runHead = &mRunHead;
|
|
|
|
return hr;
|
|
}
|
|
|
|
// IDWriteTextAnalysisSource implementation
|
|
|
|
IFACEMETHODIMP
|
|
GetTextAtPosition (uint32_t textPosition,
|
|
OUT wchar_t const** textString,
|
|
OUT uint32_t* textLength)
|
|
{
|
|
if (textPosition >= mTextLength)
|
|
{
|
|
// No text at this position, valid query though.
|
|
*textString = nullptr;
|
|
*textLength = 0;
|
|
}
|
|
else
|
|
{
|
|
*textString = mText + textPosition;
|
|
*textLength = mTextLength - textPosition;
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
IFACEMETHODIMP
|
|
GetTextBeforePosition (uint32_t textPosition,
|
|
OUT wchar_t const** textString,
|
|
OUT uint32_t* textLength)
|
|
{
|
|
if (textPosition == 0 || textPosition > mTextLength)
|
|
{
|
|
// Either there is no text before here (== 0), or this
|
|
// is an invalid position. The query is considered valid though.
|
|
*textString = nullptr;
|
|
*textLength = 0;
|
|
}
|
|
else
|
|
{
|
|
*textString = mText;
|
|
*textLength = textPosition;
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
IFACEMETHODIMP_ (DWRITE_READING_DIRECTION)
|
|
GetParagraphReadingDirection () { return mReadingDirection; }
|
|
|
|
IFACEMETHODIMP GetLocaleName (uint32_t textPosition, uint32_t* textLength,
|
|
wchar_t const** localeName)
|
|
{ return S_OK; }
|
|
|
|
IFACEMETHODIMP
|
|
GetNumberSubstitution (uint32_t textPosition,
|
|
OUT uint32_t* textLength,
|
|
OUT IDWriteNumberSubstitution** numberSubstitution)
|
|
{
|
|
// We do not support number substitution.
|
|
*numberSubstitution = nullptr;
|
|
*textLength = mTextLength - textPosition;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
// IDWriteTextAnalysisSink implementation
|
|
|
|
IFACEMETHODIMP
|
|
SetScriptAnalysis (uint32_t textPosition, uint32_t textLength,
|
|
DWRITE_SCRIPT_ANALYSIS const* scriptAnalysis)
|
|
{
|
|
SetCurrentRun (textPosition);
|
|
if (unlikely (!SplitCurrentRun (textPosition)))
|
|
return E_OUTOFMEMORY;
|
|
while (textLength > 0)
|
|
{
|
|
Run *run = FetchNextRun (&textLength);
|
|
if (unlikely (!run))
|
|
return E_OUTOFMEMORY;
|
|
run->mScript = *scriptAnalysis;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
IFACEMETHODIMP
|
|
SetLineBreakpoints (uint32_t textPosition,
|
|
uint32_t textLength,
|
|
const DWRITE_LINE_BREAKPOINT* lineBreakpoints)
|
|
{ return S_OK; }
|
|
|
|
IFACEMETHODIMP SetBidiLevel (uint32_t textPosition, uint32_t textLength,
|
|
uint8_t explicitLevel, uint8_t resolvedLevel)
|
|
{ return S_OK; }
|
|
|
|
IFACEMETHODIMP
|
|
SetNumberSubstitution (uint32_t textPosition, uint32_t textLength,
|
|
IDWriteNumberSubstitution* numberSubstitution)
|
|
{ return S_OK; }
|
|
|
|
protected:
|
|
Run *FetchNextRun (IN OUT uint32_t* textLength)
|
|
{
|
|
// Used by the sink setters, this returns a reference to the next run.
|
|
// Position and length are adjusted to now point after the current run
|
|
// being returned.
|
|
|
|
Run *origRun = mCurrentRun;
|
|
// Split the tail if needed (the length remaining is less than the
|
|
// current run's size).
|
|
if (*textLength < mCurrentRun->mTextLength)
|
|
{
|
|
if (unlikely (!SplitCurrentRun (mCurrentRun->mTextStart + *textLength)))
|
|
return nullptr;
|
|
}
|
|
else
|
|
// Just advance the current run.
|
|
mCurrentRun = mCurrentRun->nextRun;
|
|
*textLength -= origRun->mTextLength;
|
|
|
|
// Return a reference to the run that was just current.
|
|
return origRun;
|
|
}
|
|
|
|
void SetCurrentRun (uint32_t textPosition)
|
|
{
|
|
// Move the current run to the given position.
|
|
// Since the analyzers generally return results in a forward manner,
|
|
// this will usually just return early. If not, find the
|
|
// corresponding run for the text position.
|
|
|
|
if (mCurrentRun && mCurrentRun->ContainsTextPosition (textPosition))
|
|
return;
|
|
|
|
for (Run *run = &mRunHead; run; run = run->nextRun)
|
|
if (run->ContainsTextPosition (textPosition))
|
|
{
|
|
mCurrentRun = run;
|
|
return;
|
|
}
|
|
assert (0); // We should always be able to find the text position in one of our runs
|
|
}
|
|
|
|
bool SplitCurrentRun (uint32_t splitPosition)
|
|
{
|
|
if (!mCurrentRun)
|
|
{
|
|
assert (0); // SplitCurrentRun called without current run
|
|
// Shouldn't be calling this when no current run is set!
|
|
return false;
|
|
}
|
|
// Split the current run.
|
|
if (splitPosition <= mCurrentRun->mTextStart)
|
|
{
|
|
// No need to split, already the start of a run
|
|
// or before it. Usually the first.
|
|
return true;
|
|
}
|
|
Run *newRun = (Run *) hb_malloc (sizeof (Run));
|
|
if (unlikely (!newRun))
|
|
return false;
|
|
|
|
*newRun = *mCurrentRun;
|
|
|
|
// Insert the new run in our linked list.
|
|
newRun->nextRun = mCurrentRun->nextRun;
|
|
mCurrentRun->nextRun = newRun;
|
|
|
|
// Adjust runs' text positions and lengths.
|
|
uint32_t splitPoint = splitPosition - mCurrentRun->mTextStart;
|
|
newRun->mTextStart += splitPoint;
|
|
newRun->mTextLength -= splitPoint;
|
|
mCurrentRun->mTextLength = splitPoint;
|
|
mCurrentRun = newRun;
|
|
return true;
|
|
}
|
|
|
|
protected:
|
|
// Input
|
|
// (weak references are fine here, since this class is a transient
|
|
// stack-based helper that doesn't need to copy data)
|
|
uint32_t mTextLength;
|
|
const wchar_t* mText;
|
|
const wchar_t* mLocaleName;
|
|
DWRITE_READING_DIRECTION mReadingDirection;
|
|
|
|
// Current processing state.
|
|
Run *mCurrentRun;
|
|
|
|
// Output is a list of runs starting here
|
|
Run mRunHead;
|
|
};
|
|
|
|
/*
|
|
* shaper
|
|
*/
|
|
|
|
hb_bool_t
|
|
_hb_directwrite_shape (hb_shape_plan_t *shape_plan,
|
|
hb_font_t *font,
|
|
hb_buffer_t *buffer,
|
|
const hb_feature_t *features,
|
|
unsigned int num_features)
|
|
{
|
|
IDWriteFontFace *fontFace = (IDWriteFontFace *) (const void *) font->data.directwrite;
|
|
auto *global = get_directwrite_global ();
|
|
if (unlikely (!global))
|
|
return false;
|
|
IDWriteFactory *dwriteFactory = global->dwriteFactory;
|
|
|
|
IDWriteTextAnalyzer* analyzer;
|
|
dwriteFactory->CreateTextAnalyzer (&analyzer);
|
|
|
|
unsigned int scratch_size;
|
|
hb_buffer_t::scratch_buffer_t *scratch = buffer->get_scratch_buffer (&scratch_size);
|
|
#define ALLOCATE_ARRAY(Type, name, len) \
|
|
Type *name = (Type *) scratch; \
|
|
do { \
|
|
unsigned int _consumed = DIV_CEIL ((len) * sizeof (Type), sizeof (*scratch)); \
|
|
assert (_consumed <= scratch_size); \
|
|
scratch += _consumed; \
|
|
scratch_size -= _consumed; \
|
|
} while (0)
|
|
|
|
#define utf16_index() var1.u32
|
|
|
|
ALLOCATE_ARRAY (wchar_t, textString, buffer->len * 2);
|
|
|
|
unsigned int chars_len = 0;
|
|
for (unsigned int i = 0; i < buffer->len; i++)
|
|
{
|
|
hb_codepoint_t c = buffer->info[i].codepoint;
|
|
buffer->info[i].utf16_index () = chars_len;
|
|
if (likely (c <= 0xFFFFu))
|
|
textString[chars_len++] = c;
|
|
else if (unlikely (c > 0x10FFFFu))
|
|
textString[chars_len++] = 0xFFFDu;
|
|
else
|
|
{
|
|
textString[chars_len++] = 0xD800u + ((c - 0x10000u) >> 10);
|
|
textString[chars_len++] = 0xDC00u + ((c - 0x10000u) & ((1u << 10) - 1));
|
|
}
|
|
}
|
|
|
|
ALLOCATE_ARRAY (WORD, log_clusters, chars_len);
|
|
#undef ALLOCATE_ARRAY
|
|
/* Need log_clusters to assign features. */
|
|
chars_len = 0;
|
|
for (unsigned int i = 0; i < buffer->len; i++)
|
|
{
|
|
hb_codepoint_t c = buffer->info[i].codepoint;
|
|
unsigned int cluster = buffer->info[i].cluster;
|
|
log_clusters[chars_len++] = cluster;
|
|
if (hb_in_range (c, 0x10000u, 0x10FFFFu))
|
|
log_clusters[chars_len++] = cluster; /* Surrogates. */
|
|
}
|
|
|
|
DWRITE_READING_DIRECTION readingDirection;
|
|
readingDirection = buffer->props.direction ?
|
|
DWRITE_READING_DIRECTION_RIGHT_TO_LEFT :
|
|
DWRITE_READING_DIRECTION_LEFT_TO_RIGHT;
|
|
|
|
/*
|
|
* There's an internal 16-bit limit on some things inside the analyzer,
|
|
* but we never attempt to shape a word longer than 64K characters
|
|
* in a single gfxShapedWord, so we cannot exceed that limit.
|
|
*/
|
|
uint32_t textLength = chars_len;
|
|
|
|
TextAnalysis analysis (textString, textLength, nullptr, readingDirection);
|
|
TextAnalysis::Run *runHead;
|
|
HRESULT hr;
|
|
hr = analysis.GenerateResults (analyzer, &runHead);
|
|
|
|
#define FAIL(...) \
|
|
HB_STMT_START { \
|
|
DEBUG_MSG (DIRECTWRITE, nullptr, __VA_ARGS__); \
|
|
return false; \
|
|
} HB_STMT_END
|
|
|
|
if (FAILED (hr))
|
|
FAIL ("Analyzer failed to generate results.");
|
|
|
|
uint32_t maxGlyphCount = 3 * textLength / 2 + 16;
|
|
uint32_t glyphCount;
|
|
bool isRightToLeft = HB_DIRECTION_IS_BACKWARD (buffer->props.direction);
|
|
|
|
const wchar_t localeName[20] = {0};
|
|
if (buffer->props.language)
|
|
mbstowcs ((wchar_t*) localeName,
|
|
hb_language_to_string (buffer->props.language), 20);
|
|
|
|
/*
|
|
* Set up features.
|
|
*/
|
|
static_assert ((sizeof (DWRITE_TYPOGRAPHIC_FEATURES) == sizeof (hb_ms_features_t)), "");
|
|
static_assert ((sizeof (DWRITE_FONT_FEATURE) == sizeof (hb_ms_feature_t)), "");
|
|
hb_vector_t<hb_ms_features_t *> range_features;
|
|
hb_vector_t<uint32_t> range_char_counts;
|
|
|
|
// https://github.com/harfbuzz/harfbuzz/pull/5114
|
|
// The data allocated by these two vectors are used by the above two, so they
|
|
// should remain alive as long as the above two are.
|
|
hb_vector_t<hb_ms_feature_t> feature_records;
|
|
hb_vector_t<hb_ms_range_record_t> range_records;
|
|
if (num_features)
|
|
{
|
|
if (hb_ms_setup_features (features, num_features, feature_records, range_records))
|
|
{
|
|
hb_ms_make_feature_ranges (feature_records,
|
|
range_records,
|
|
0,
|
|
chars_len,
|
|
log_clusters,
|
|
range_features,
|
|
range_char_counts);
|
|
}
|
|
}
|
|
|
|
hb_vector_t<uint16_t> clusterMap;
|
|
hb_vector_t<DWRITE_SHAPING_TEXT_PROPERTIES> textProperties;
|
|
if (unlikely (!clusterMap.resize_exact (textLength) ||
|
|
!textProperties.resize_exact (textLength)))
|
|
FAIL ("Failed to allocate shaping text data.");
|
|
|
|
hb_vector_t<uint16_t> glyphIndices;
|
|
hb_vector_t<DWRITE_SHAPING_GLYPH_PROPERTIES> glyphProperties;
|
|
|
|
retry_getglyphs:
|
|
if (unlikely (!glyphIndices.resize_exact (maxGlyphCount) ||
|
|
!glyphProperties.resize_exact (maxGlyphCount)))
|
|
FAIL ("Failed to allocate shaping glyph data.");
|
|
|
|
hr = analyzer->GetGlyphs (textString,
|
|
chars_len,
|
|
fontFace,
|
|
false,
|
|
isRightToLeft,
|
|
&runHead->mScript,
|
|
localeName,
|
|
nullptr,
|
|
(const DWRITE_TYPOGRAPHIC_FEATURES**) range_features.arrayZ,
|
|
range_char_counts.arrayZ,
|
|
range_features.length,
|
|
maxGlyphCount,
|
|
clusterMap.arrayZ,
|
|
textProperties.arrayZ,
|
|
glyphIndices.arrayZ,
|
|
glyphProperties.arrayZ,
|
|
&glyphCount);
|
|
|
|
if (unlikely (hr == HRESULT_FROM_WIN32 (ERROR_INSUFFICIENT_BUFFER)))
|
|
{
|
|
maxGlyphCount *= 2;
|
|
|
|
goto retry_getglyphs;
|
|
}
|
|
if (FAILED (hr))
|
|
FAIL ("Analyzer failed to get glyphs.");
|
|
|
|
hb_vector_t<float> glyphAdvances;
|
|
hb_vector_t<DWRITE_GLYPH_OFFSET> glyphOffsets;
|
|
if (unlikely (!glyphAdvances.resize_exact (maxGlyphCount) ||
|
|
!glyphOffsets.resize_exact (maxGlyphCount)))
|
|
FAIL ("Failed to allocate glyph positioning data.");
|
|
|
|
|
|
unsigned fontEmSize = font->face->get_upem ();
|
|
|
|
float x_mult = font->x_multf;
|
|
float y_mult = font->y_multf;
|
|
|
|
hr = analyzer->GetGlyphPlacements (textString,
|
|
clusterMap.arrayZ,
|
|
textProperties.arrayZ,
|
|
chars_len,
|
|
glyphIndices.arrayZ,
|
|
glyphProperties.arrayZ,
|
|
glyphCount,
|
|
fontFace,
|
|
fontEmSize,
|
|
false,
|
|
isRightToLeft,
|
|
&runHead->mScript,
|
|
localeName,
|
|
(const DWRITE_TYPOGRAPHIC_FEATURES**) range_features.arrayZ,
|
|
range_char_counts.arrayZ,
|
|
range_features.length,
|
|
glyphAdvances.arrayZ,
|
|
glyphOffsets.arrayZ);
|
|
|
|
if (FAILED (hr))
|
|
FAIL ("Analyzer failed to get glyph placements.");
|
|
|
|
/* Ok, we've got everything we need, now compose output buffer,
|
|
* very, *very*, carefully! */
|
|
|
|
/* Calculate visual-clusters. That's what we ship. */
|
|
hb_vector_t<uint32_t> vis_clusters;
|
|
if (unlikely (!vis_clusters.resize_exact (glyphCount)))
|
|
FAIL ("Failed to allocate visual clusters.");
|
|
|
|
for (unsigned int i = 0; i < glyphCount; i++)
|
|
vis_clusters[i] = (uint32_t) -1;
|
|
for (unsigned int i = 0; i < buffer->len; i++)
|
|
{
|
|
unsigned int c = clusterMap[buffer->info[i].utf16_index ()];
|
|
if (likely (c < glyphCount))
|
|
vis_clusters[c] = hb_min (vis_clusters[c], buffer->info[i].cluster);
|
|
}
|
|
for (unsigned int i = 1; i < glyphCount; i++)
|
|
if (vis_clusters[i] == (uint32_t) -1)
|
|
vis_clusters[i] = vis_clusters[i - 1];
|
|
for (int i = (int) glyphCount - 2; i >= 0; i--)
|
|
if (vis_clusters[i] == (uint32_t) -1)
|
|
vis_clusters[i] = vis_clusters[i + 1];
|
|
|
|
#undef utf16_index
|
|
|
|
if (unlikely (!buffer->ensure (glyphCount)))
|
|
FAIL ("Buffer in error");
|
|
|
|
#undef FAIL
|
|
|
|
/* Set glyph infos */
|
|
buffer->len = 0;
|
|
for (unsigned int i = 0; i < glyphCount; i++)
|
|
{
|
|
hb_glyph_info_t *info = &buffer->info[buffer->len++];
|
|
|
|
info->codepoint = glyphIndices[i];
|
|
info->cluster = vis_clusters[i];
|
|
|
|
/* The rest is crap. Let's store position info there for now. */
|
|
info->mask = (hb_mask_t) hb_clamp_to<int32_t> (glyphAdvances[i]);
|
|
info->var1.i32 = hb_clamp_to<int32_t> (glyphOffsets[i].advanceOffset);
|
|
info->var2.i32 = hb_clamp_to<int32_t> (glyphOffsets[i].ascenderOffset);
|
|
}
|
|
|
|
/* Set glyph positions */
|
|
buffer->clear_positions ();
|
|
for (unsigned int i = 0; i < glyphCount; i++)
|
|
{
|
|
hb_glyph_info_t *info = &buffer->info[i];
|
|
hb_glyph_position_t *pos = &buffer->pos[i];
|
|
|
|
/* TODO vertical */
|
|
pos->x_advance = hb_clamp_to<hb_position_t> (round (x_mult * (int32_t) info->mask));
|
|
double x_offset = isRightToLeft ? -(double) info->var1.i32 : info->var1.i32;
|
|
pos->x_offset = hb_clamp_to<hb_position_t> (round ((double) x_mult * x_offset));
|
|
pos->y_offset = hb_clamp_to<hb_position_t> (round (y_mult * info->var2.i32));
|
|
}
|
|
|
|
if (isRightToLeft) hb_buffer_reverse (buffer);
|
|
|
|
buffer->clear_glyph_flags ();
|
|
buffer->unsafe_to_break ();
|
|
|
|
/* Wow, done! */
|
|
return true;
|
|
}
|
|
|
|
|
|
#endif
|