Home | History | Annotate | Download | only in src 
      1 /*
      2  * Copyright  2015-2016  Ebrahim Byagowi
      3  *
      4  *  This is part of HarfBuzz, a text shaping library.
      5  *
      6  * Permission is hereby granted, without written agreement and without
      7  * license or royalty fees, to use, copy, modify, and distribute this
      8  * software and its documentation for any purpose, provided that the
      9  * above copyright notice and the following two paragraphs appear in
     10  * all copies of this software.
     11  *
     12  * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
     13  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
     14  * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
     15  * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
     16  * DAMAGE.
     17  *
     18  * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
     19  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
     20  * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
     21  * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
     22  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
     23  */
     24 
     25 #define HB_SHAPER directwrite
     26 #include "hb-shaper-impl-private.hh"
     27 
     28 #ifndef HB_DIRECTWRITE_EXPERIMENTAL_JUSTIFICATION
     29   #include <DWrite.h>
     30 #else
     31   #include <DWrite_1.h>
     32 #endif
     33 
     34 #include "hb-directwrite.h"
     35 
     36 #include "hb-open-file-private.hh"
     37 #include "hb-ot-name-table.hh"
     38 #include "hb-ot-tag.h"
     39 
     40 
     41 #ifndef HB_DEBUG_DIRECTWRITE
     42 #define HB_DEBUG_DIRECTWRITE (HB_DEBUG+0)
     43 #endif
     44 
     45 HB_SHAPER_DATA_ENSURE_DECLARE(directwrite, face)
     46 HB_SHAPER_DATA_ENSURE_DECLARE(directwrite, font)
     47 
     48 /*
     49 * shaper face data
     50 */
     51 
     52 struct hb_directwrite_shaper_face_data_t {
     53   HANDLE fh;
     54   wchar_t face_name[LF_FACESIZE];
     55 };
     56 
     57 /* face_name should point to a wchar_t[LF_FACESIZE] object. */
     58 static void
     59 _hb_generate_unique_face_name(wchar_t *face_name, unsigned int *plen)
     60 {
     61   /* We'll create a private name for the font from a UUID using a simple,
     62   * somewhat base64-like encoding scheme */
     63   const char *enc = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-";
     64   UUID id;
     65   UuidCreate ((UUID*)&id);
     66   ASSERT_STATIC (2 + 3 * (16 / 2) < LF_FACESIZE);
     67   unsigned int name_str_len = 0;
     68   face_name[name_str_len++] = 'F';
     69   face_name[name_str_len++] = '_';
     70   unsigned char *p = (unsigned char *)&id;
     71   for (unsigned int i = 0; i < 16; i += 2)
     72   {
     73     /* Spread the 16 bits from two bytes of the UUID across three chars of face_name,
     74     * using the bits in groups of 5,5,6 to select chars from enc.
     75     * This will generate 24 characters; with the 'F_' prefix we already provided,
     76     * the name will be 26 chars (plus the NUL terminator), so will always fit within
     77     * face_name (LF_FACESIZE = 32). */
     78     face_name[name_str_len++] = enc[p[i] >> 3];
     79     face_name[name_str_len++] = enc[((p[i] << 2) | (p[i + 1] >> 6)) & 0x1f];
     80     face_name[name_str_len++] = enc[p[i + 1] & 0x3f];
     81   }
     82   face_name[name_str_len] = 0;
     83   if (plen)
     84     *plen = name_str_len;
     85 }
     86 
     87 /* Destroys blob. */
     88 static hb_blob_t *
     89 _hb_rename_font(hb_blob_t *blob, wchar_t *new_name)
     90 {
     91   /* Create a copy of the font data, with the 'name' table replaced by a
     92    * table that names the font with our private F_* name created above.
     93    * For simplicity, we just append a new 'name' table and update the
     94    * sfnt directory; the original table is left in place, but unused.
     95    *
     96    * The new table will contain just 5 name IDs: family, style, unique,
     97    * full, PS. All of them point to the same name data with our unique name.
     98    */
     99 
    100   blob = OT::Sanitizer<OT::OpenTypeFontFile>::sanitize (blob);
    101 
    102   unsigned int length, new_length, name_str_len;
    103   const char *orig_sfnt_data = hb_blob_get_data (blob, &length);
    104 
    105   _hb_generate_unique_face_name (new_name, &name_str_len);
    106 
    107   static const uint16_t name_IDs[] = { 1, 2, 3, 4, 6 };
    108 
    109   unsigned int name_table_length = OT::name::min_size +
    110     ARRAY_LENGTH(name_IDs) * OT::NameRecord::static_size +
    111     name_str_len * 2; /* for name data in UTF16BE form */
    112   unsigned int name_table_offset = (length + 3) & ~3;
    113 
    114   new_length = name_table_offset + ((name_table_length + 3) & ~3);
    115   void *new_sfnt_data = calloc(1, new_length);
    116   if (!new_sfnt_data)
    117   {
    118     hb_blob_destroy (blob);
    119     return NULL;
    120   }
    121 
    122   memcpy(new_sfnt_data, orig_sfnt_data, length);
    123 
    124   OT::name &name = OT::StructAtOffset<OT::name> (new_sfnt_data, name_table_offset);
    125   name.format.set (0);
    126   name.count.set (ARRAY_LENGTH (name_IDs));
    127   name.stringOffset.set (name.get_size());
    128   for (unsigned int i = 0; i < ARRAY_LENGTH (name_IDs); i++)
    129   {
    130     OT::NameRecord &record = name.nameRecord[i];
    131     record.platformID.set(3);
    132     record.encodingID.set(1);
    133     record.languageID.set(0x0409u); /* English */
    134     record.nameID.set(name_IDs[i]);
    135     record.length.set(name_str_len * 2);
    136     record.offset.set(0);
    137   }
    138 
    139   /* Copy string data from new_name, converting wchar_t to UTF16BE. */
    140   unsigned char *p = &OT::StructAfter<unsigned char>(name);
    141   for (unsigned int i = 0; i < name_str_len; i++)
    142   {
    143     *p++ = new_name[i] >> 8;
    144     *p++ = new_name[i] & 0xff;
    145   }
    146 
    147   /* Adjust name table entry to point to new name table */
    148   const OT::OpenTypeFontFile &file = *(OT::OpenTypeFontFile *) (new_sfnt_data);
    149   unsigned int face_count = file.get_face_count ();
    150   for (unsigned int face_index = 0; face_index < face_count; face_index++)
    151   {
    152     /* Note: doing multiple edits (ie. TTC) can be unsafe.  There may be
    153     * toe-stepping.  But we don't really care. */
    154     const OT::OpenTypeFontFace &face = file.get_face (face_index);
    155     unsigned int index;
    156     if (face.find_table_index (HB_OT_TAG_name, &index))
    157     {
    158       OT::TableRecord &record = const_cast<OT::TableRecord &> (face.get_table (index));
    159       record.checkSum.set_for_data (&name, name_table_length);
    160       record.offset.set (name_table_offset);
    161       record.length.set (name_table_length);
    162     }
    163     else if (face_index == 0) /* Fail if first face doesn't have 'name' table. */
    164     {
    165       free (new_sfnt_data);
    166       hb_blob_destroy (blob);
    167       return NULL;
    168     }
    169   }
    170 
    171   /* The checkSumAdjustment field in the 'head' table is now wrong,
    172   * but that doesn't actually seem to cause any problems so we don't
    173   * bother. */
    174 
    175   hb_blob_destroy (blob);
    176   return hb_blob_create ((const char *)new_sfnt_data, new_length,
    177     HB_MEMORY_MODE_WRITABLE, NULL, free);
    178 }
    179 
    180 hb_directwrite_shaper_face_data_t *
    181 _hb_directwrite_shaper_face_data_create(hb_face_t *face)
    182 {
    183   hb_directwrite_shaper_face_data_t *data =
    184     (hb_directwrite_shaper_face_data_t *) calloc (1, sizeof (hb_directwrite_shaper_face_data_t));
    185   if (unlikely (!data))
    186     return NULL;
    187 
    188   hb_blob_t *blob = hb_face_reference_blob (face);
    189   if (unlikely (!hb_blob_get_length (blob)))
    190     DEBUG_MSG(DIRECTWRITE, face, "Face has empty blob");
    191 
    192   blob = _hb_rename_font (blob, data->face_name);
    193   if (unlikely (!blob))
    194   {
    195     free(data);
    196     return NULL;
    197   }
    198 
    199   DWORD num_fonts_installed;
    200   data->fh = AddFontMemResourceEx ((void *)hb_blob_get_data(blob, NULL),
    201     hb_blob_get_length (blob),
    202     0, &num_fonts_installed);
    203   if (unlikely (!data->fh))
    204   {
    205     DEBUG_MSG (DIRECTWRITE, face, "Face AddFontMemResourceEx() failed");
    206     free (data);
    207     return NULL;
    208   }
    209 
    210   return data;
    211 }
    212 
    213 void
    214 _hb_directwrite_shaper_face_data_destroy(hb_directwrite_shaper_face_data_t *data)
    215 {
    216   RemoveFontMemResourceEx(data->fh);
    217   free(data);
    218 }
    219 
    220 
    221 /*
    222  * shaper font data
    223  */
    224 
    225 struct hb_directwrite_shaper_font_data_t {
    226   HDC hdc;
    227   LOGFONTW log_font;
    228   HFONT hfont;
    229 };
    230 
    231 static bool
    232 populate_log_font (LOGFONTW  *lf,
    233        hb_font_t *font)
    234 {
    235   memset (lf, 0, sizeof (*lf));
    236   lf->lfHeight = -font->y_scale;
    237   lf->lfCharSet = DEFAULT_CHARSET;
    238 
    239   hb_face_t *face = font->face;
    240   hb_directwrite_shaper_face_data_t *face_data = HB_SHAPER_DATA_GET (face);
    241 
    242   memcpy (lf->lfFaceName, face_data->face_name, sizeof (lf->lfFaceName));
    243 
    244   return true;
    245 }
    246 
    247 hb_directwrite_shaper_font_data_t *
    248 _hb_directwrite_shaper_font_data_create (hb_font_t *font)
    249 {
    250   if (unlikely (!hb_directwrite_shaper_face_data_ensure (font->face))) return NULL;
    251 
    252   hb_directwrite_shaper_font_data_t *data =
    253     (hb_directwrite_shaper_font_data_t *) calloc (1, sizeof (hb_directwrite_shaper_font_data_t));
    254   if (unlikely (!data))
    255     return NULL;
    256 
    257   data->hdc = GetDC (NULL);
    258 
    259   if (unlikely (!populate_log_font (&data->log_font, font)))
    260   {
    261     DEBUG_MSG (DIRECTWRITE, font, "Font populate_log_font() failed");
    262     _hb_directwrite_shaper_font_data_destroy (data);
    263     return NULL;
    264   }
    265 
    266   data->hfont = CreateFontIndirectW (&data->log_font);
    267   if (unlikely (!data->hfont))
    268   {
    269     DEBUG_MSG (DIRECTWRITE, font, "Font CreateFontIndirectW() failed");
    270     _hb_directwrite_shaper_font_data_destroy (data);
    271      return NULL;
    272   }
    273 
    274   if (!SelectObject (data->hdc, data->hfont))
    275   {
    276     DEBUG_MSG (DIRECTWRITE, font, "Font SelectObject() failed");
    277     _hb_directwrite_shaper_font_data_destroy (data);
    278      return NULL;
    279   }
    280 
    281   return data;
    282 }
    283 
    284 void
    285 _hb_directwrite_shaper_font_data_destroy (hb_directwrite_shaper_font_data_t *data)
    286 {
    287   if (data->hdc)
    288     ReleaseDC (NULL, data->hdc);
    289   if (data->hfont)
    290     DeleteObject (data->hfont);
    291   free (data);
    292 }
    293 
    294 LOGFONTW *
    295 hb_directwrite_font_get_logfontw (hb_font_t *font)
    296 {
    297   if (unlikely (!hb_directwrite_shaper_font_data_ensure (font))) return NULL;
    298   hb_directwrite_shaper_font_data_t *font_data =  HB_SHAPER_DATA_GET (font);
    299   return &font_data->log_font;
    300 }
    301 
    302 HFONT
    303 hb_directwrite_font_get_hfont (hb_font_t *font)
    304 {
    305   if (unlikely (!hb_directwrite_shaper_font_data_ensure (font))) return NULL;
    306   hb_directwrite_shaper_font_data_t *font_data =  HB_SHAPER_DATA_GET (font);
    307   return font_data->hfont;
    308 }
    309 
    310 
    311 /*
    312  * shaper shape_plan data
    313  */
    314 
    315 struct hb_directwrite_shaper_shape_plan_data_t {};
    316 
    317 hb_directwrite_shaper_shape_plan_data_t *
    318 _hb_directwrite_shaper_shape_plan_data_create (hb_shape_plan_t    *shape_plan HB_UNUSED,
    319                const hb_feature_t *user_features HB_UNUSED,
    320                unsigned int        num_user_features HB_UNUSED)
    321 {
    322   return (hb_directwrite_shaper_shape_plan_data_t *) HB_SHAPER_DATA_SUCCEEDED;
    323 }
    324 
    325 void
    326 _hb_directwrite_shaper_shape_plan_data_destroy (hb_directwrite_shaper_shape_plan_data_t *data HB_UNUSED)
    327 {
    328 }
    329 
    330 // Most of here TextAnalysis is originally written by Bas Schouten for Mozilla project
    331 // but now is relicensed to MIT for HarfBuzz use
    332 class TextAnalysis
    333   : public IDWriteTextAnalysisSource, public IDWriteTextAnalysisSink
    334 {
    335 public:
    336 
    337   IFACEMETHOD(QueryInterface)(IID const& iid, OUT void** ppObject) { return S_OK; }
    338   IFACEMETHOD_(ULONG, AddRef)() { return 1; }
    339   IFACEMETHOD_(ULONG, Release)() { return 1; }
    340 
    341   // A single contiguous run of characters containing the same analysis
    342   // results.
    343   struct Run
    344   {
    345     uint32_t mTextStart;   // starting text position of this run
    346     uint32_t mTextLength;  // number of contiguous code units covered
    347     uint32_t mGlyphStart;  // starting glyph in the glyphs array
    348     uint32_t mGlyphCount;  // number of glyphs associated with this run of
    349     // text
    350     DWRITE_SCRIPT_ANALYSIS mScript;
    351     uint8_t mBidiLevel;
    352     bool mIsSideways;
    353 
    354     inline bool ContainsTextPosition(uint32_t aTextPosition) const
    355     {
    356       return aTextPosition >= mTextStart
    357         && aTextPosition <  mTextStart + mTextLength;
    358     }
    359 
    360     Run *nextRun;
    361   };
    362 
    363 public:
    364   TextAnalysis(const wchar_t* text,
    365     uint32_t textLength,
    366     const wchar_t* localeName,
    367     DWRITE_READING_DIRECTION readingDirection)
    368     : mText(text)
    369     , mTextLength(textLength)
    370     , mLocaleName(localeName)
    371     , mReadingDirection(readingDirection)
    372     , mCurrentRun(NULL) { };
    373 
    374   ~TextAnalysis() {
    375     // delete runs, except mRunHead which is part of the TextAnalysis object
    376     for (Run *run = mRunHead.nextRun; run;) {
    377       Run *origRun = run;
    378       run = run->nextRun;
    379       free (origRun);
    380     }
    381   }
    382 
    383   STDMETHODIMP GenerateResults(IDWriteTextAnalyzer* textAnalyzer,
    384     Run **runHead) {
    385     // Analyzes the text using the script analyzer and returns
    386     // the result as a series of runs.
    387 
    388     HRESULT hr = S_OK;
    389 
    390     // Initially start out with one result that covers the entire range.
    391     // This result will be subdivided by the analysis processes.
    392     mRunHead.mTextStart = 0;
    393     mRunHead.mTextLength = mTextLength;
    394     mRunHead.mBidiLevel =
    395       (mReadingDirection == DWRITE_READING_DIRECTION_RIGHT_TO_LEFT);
    396     mRunHead.nextRun = NULL;
    397     mCurrentRun = &mRunHead;
    398 
    399     // Call each of the analyzers in sequence, recording their results.
    400     if (SUCCEEDED (hr = textAnalyzer->AnalyzeScript (this, 0, mTextLength, this))) {
    401       *runHead = &mRunHead;
    402     }
    403 
    404     return hr;
    405   }
    406 
    407   // IDWriteTextAnalysisSource implementation
    408 
    409   IFACEMETHODIMP GetTextAtPosition(uint32_t textPosition,
    410     OUT wchar_t const** textString,
    411     OUT uint32_t* textLength)
    412   {
    413     if (textPosition >= mTextLength) {
    414       // No text at this position, valid query though.
    415       *textString = NULL;
    416       *textLength = 0;
    417     }
    418     else {
    419       *textString = mText + textPosition;
    420       *textLength = mTextLength - textPosition;
    421     }
    422     return S_OK;
    423   }
    424 
    425   IFACEMETHODIMP GetTextBeforePosition(uint32_t textPosition,
    426     OUT wchar_t const** textString,
    427     OUT uint32_t* textLength)
    428   {
    429     if (textPosition == 0 || textPosition > mTextLength) {
    430       // Either there is no text before here (== 0), or this
    431       // is an invalid position. The query is considered valid thouh.
    432       *textString = NULL;
    433       *textLength = 0;
    434     }
    435     else {
    436       *textString = mText;
    437       *textLength = textPosition;
    438     }
    439     return S_OK;
    440   }
    441 
    442   IFACEMETHODIMP_(DWRITE_READING_DIRECTION)
    443     GetParagraphReadingDirection() { return mReadingDirection; }
    444 
    445   IFACEMETHODIMP GetLocaleName(uint32_t textPosition,
    446     uint32_t* textLength,
    447     wchar_t const** localeName) {
    448     return S_OK;
    449   }
    450 
    451   IFACEMETHODIMP
    452     GetNumberSubstitution(uint32_t textPosition,
    453     OUT uint32_t* textLength,
    454     OUT IDWriteNumberSubstitution** numberSubstitution)
    455   {
    456     // We do not support number substitution.
    457     *numberSubstitution = NULL;
    458     *textLength = mTextLength - textPosition;
    459 
    460     return S_OK;
    461   }
    462 
    463   // IDWriteTextAnalysisSink implementation
    464 
    465   IFACEMETHODIMP
    466     SetScriptAnalysis(uint32_t textPosition,
    467     uint32_t textLength,
    468     DWRITE_SCRIPT_ANALYSIS const* scriptAnalysis)
    469   {
    470     SetCurrentRun(textPosition);
    471     SplitCurrentRun(textPosition);
    472     while (textLength > 0) {
    473       Run *run = FetchNextRun(&textLength);
    474       run->mScript = *scriptAnalysis;
    475     }
    476 
    477     return S_OK;
    478   }
    479 
    480   IFACEMETHODIMP
    481     SetLineBreakpoints(uint32_t textPosition,
    482     uint32_t textLength,
    483     const DWRITE_LINE_BREAKPOINT* lineBreakpoints) { return S_OK; }
    484 
    485   IFACEMETHODIMP SetBidiLevel(uint32_t textPosition,
    486     uint32_t textLength,
    487     uint8_t explicitLevel,
    488     uint8_t resolvedLevel) { return S_OK; }
    489 
    490   IFACEMETHODIMP
    491     SetNumberSubstitution(uint32_t textPosition,
    492     uint32_t textLength,
    493     IDWriteNumberSubstitution* numberSubstitution) { return S_OK; }
    494 
    495 protected:
    496   Run *FetchNextRun(IN OUT uint32_t* textLength)
    497   {
    498     // Used by the sink setters, this returns a reference to the next run.
    499     // Position and length are adjusted to now point after the current run
    500     // being returned.
    501 
    502     Run *origRun = mCurrentRun;
    503     // Split the tail if needed (the length remaining is less than the
    504     // current run's size).
    505     if (*textLength < mCurrentRun->mTextLength) {
    506       SplitCurrentRun(mCurrentRun->mTextStart + *textLength);
    507     }
    508     else {
    509       // Just advance the current run.
    510       mCurrentRun = mCurrentRun->nextRun;
    511     }
    512     *textLength -= origRun->mTextLength;
    513 
    514     // Return a reference to the run that was just current.
    515     return origRun;
    516   }
    517 
    518   void SetCurrentRun(uint32_t textPosition)
    519   {
    520     // Move the current run to the given position.
    521     // Since the analyzers generally return results in a forward manner,
    522     // this will usually just return early. If not, find the
    523     // corresponding run for the text position.
    524 
    525     if (mCurrentRun && mCurrentRun->ContainsTextPosition(textPosition)) {
    526       return;
    527     }
    528 
    529     for (Run *run = &mRunHead; run; run = run->nextRun) {
    530       if (run->ContainsTextPosition(textPosition)) {
    531         mCurrentRun = run;
    532         return;
    533       }
    534     }
    535     //NS_NOTREACHED("We should always be able to find the text position in one \
    536             //                of our runs");
    537   }
    538 
    539   void SplitCurrentRun(uint32_t splitPosition)
    540   {
    541     if (!mCurrentRun) {
    542       //NS_ASSERTION(false, "SplitCurrentRun called without current run.");
    543       // Shouldn't be calling this when no current run is set!
    544       return;
    545     }
    546     // Split the current run.
    547     if (splitPosition <= mCurrentRun->mTextStart) {
    548       // No need to split, already the start of a run
    549       // or before it. Usually the first.
    550       return;
    551     }
    552     Run *newRun = (Run*) malloc (sizeof (Run));
    553 
    554     *newRun = *mCurrentRun;
    555 
    556     // Insert the new run in our linked list.
    557     newRun->nextRun = mCurrentRun->nextRun;
    558     mCurrentRun->nextRun = newRun;
    559 
    560     // Adjust runs' text positions and lengths.
    561     uint32_t splitPoint = splitPosition - mCurrentRun->mTextStart;
    562     newRun->mTextStart += splitPoint;
    563     newRun->mTextLength -= splitPoint;
    564     mCurrentRun->mTextLength = splitPoint;
    565     mCurrentRun = newRun;
    566   }
    567 
    568 protected:
    569   // Input
    570   // (weak references are fine here, since this class is a transient
    571   //  stack-based helper that doesn't need to copy data)
    572   uint32_t mTextLength;
    573   const wchar_t* mText;
    574   const wchar_t* mLocaleName;
    575   DWRITE_READING_DIRECTION mReadingDirection;
    576 
    577   // Current processing state.
    578   Run *mCurrentRun;
    579 
    580   // Output is a list of runs starting here
    581   Run  mRunHead;
    582 };
    583 
    584 static inline uint16_t hb_uint16_swap (const uint16_t v)
    585 { return (v >> 8) | (v << 8); }
    586 static inline uint32_t hb_uint32_swap (const uint32_t v)
    587 { return (hb_uint16_swap(v) << 16) | hb_uint16_swap(v >> 16); }
    588 
    589 /*
    590  * shaper
    591  */
    592 
    593 hb_bool_t
    594 _hb_directwrite_shape(hb_shape_plan_t    *shape_plan,
    595   hb_font_t          *font,
    596   hb_buffer_t        *buffer,
    597   const hb_feature_t *features,
    598   unsigned int        num_features)
    599 {
    600   hb_face_t *face = font->face;
    601   hb_directwrite_shaper_face_data_t *face_data = HB_SHAPER_DATA_GET (face);
    602   hb_directwrite_shaper_font_data_t *font_data = HB_SHAPER_DATA_GET (font);
    603 
    604   // factory probably should be cached
    605 #ifndef HB_DIRECTWRITE_EXPERIMENTAL_JUSTIFICATION
    606   IDWriteFactory* dwriteFactory;
    607 #else
    608   IDWriteFactory1* dwriteFactory;
    609 #endif
    610   DWriteCreateFactory (
    611     DWRITE_FACTORY_TYPE_SHARED,
    612     __uuidof (IDWriteFactory),
    613     (IUnknown**) &dwriteFactory
    614   );
    615 
    616   IDWriteGdiInterop *gdiInterop;
    617   dwriteFactory->GetGdiInterop (&gdiInterop);
    618   IDWriteFontFace* fontFace;
    619   gdiInterop->CreateFontFaceFromHdc (font_data->hdc, &fontFace);
    620 
    621 #ifndef HB_DIRECTWRITE_EXPERIMENTAL_JUSTIFICATION
    622   IDWriteTextAnalyzer* analyzer;
    623   dwriteFactory->CreateTextAnalyzer(&analyzer);
    624 #else
    625   IDWriteTextAnalyzer* analyzer0;
    626   dwriteFactory->CreateTextAnalyzer (&analyzer0);
    627   IDWriteTextAnalyzer1* analyzer = (IDWriteTextAnalyzer1*) analyzer0;
    628 #endif
    629 
    630   unsigned int scratch_size;
    631   hb_buffer_t::scratch_buffer_t *scratch = buffer->get_scratch_buffer (&scratch_size);
    632 #define ALLOCATE_ARRAY(Type, name, len) \
    633   Type *name = (Type *) scratch; \
    634   { \
    635     unsigned int _consumed = DIV_CEIL ((len) * sizeof (Type), sizeof (*scratch)); \
    636     assert (_consumed <= scratch_size); \
    637     scratch += _consumed; \
    638     scratch_size -= _consumed; \
    639   }
    640 
    641 #define utf16_index() var1.u32
    642 
    643   ALLOCATE_ARRAY(wchar_t, textString, buffer->len * 2);
    644 
    645   unsigned int chars_len = 0;
    646   for (unsigned int i = 0; i < buffer->len; i++)
    647   {
    648     hb_codepoint_t c = buffer->info[i].codepoint;
    649     buffer->info[i].utf16_index() = chars_len;
    650     if (likely(c <= 0xFFFFu))
    651       textString[chars_len++] = c;
    652     else if (unlikely(c > 0x10FFFFu))
    653       textString[chars_len++] = 0xFFFDu;
    654     else {
    655       textString[chars_len++] = 0xD800u + ((c - 0x10000u) >> 10);
    656       textString[chars_len++] = 0xDC00u + ((c - 0x10000u) & ((1 << 10) - 1));
    657     }
    658   }
    659 
    660   ALLOCATE_ARRAY(WORD, log_clusters, chars_len);
    661   // if (num_features)
    662   {
    663     /* Need log_clusters to assign features. */
    664     chars_len = 0;
    665     for (unsigned int i = 0; i < buffer->len; i++)
    666     {
    667       hb_codepoint_t c = buffer->info[i].codepoint;
    668       unsigned int cluster = buffer->info[i].cluster;
    669       log_clusters[chars_len++] = cluster;
    670       if (hb_in_range(c, 0x10000u, 0x10FFFFu))
    671         log_clusters[chars_len++] = cluster; /* Surrogates. */
    672     }
    673   }
    674 
    675   HRESULT hr;
    676   // TODO: Handle TEST_DISABLE_OPTIONAL_LIGATURES
    677 
    678   DWRITE_READING_DIRECTION readingDirection = buffer->props.direction ?
    679     DWRITE_READING_DIRECTION_RIGHT_TO_LEFT :
    680     DWRITE_READING_DIRECTION_LEFT_TO_RIGHT;
    681 
    682   /*
    683   * There's an internal 16-bit limit on some things inside the analyzer,
    684   * but we never attempt to shape a word longer than 64K characters
    685   * in a single gfxShapedWord, so we cannot exceed that limit.
    686   */
    687   uint32_t textLength = buffer->len;
    688 
    689   TextAnalysis analysis(textString, textLength, NULL, readingDirection);
    690   TextAnalysis::Run *runHead;
    691   hr = analysis.GenerateResults(analyzer, &runHead);
    692 
    693 #define FAIL(...) \
    694   HB_STMT_START { \
    695     DEBUG_MSG (DIRECTWRITE, NULL, __VA_ARGS__); \
    696     return false; \
    697   } HB_STMT_END;
    698 
    699   if (FAILED (hr))
    700   {
    701     FAIL ("Analyzer failed to generate results.");
    702     return false;
    703   }
    704 
    705   uint32_t maxGlyphCount = 3 * textLength / 2 + 16;
    706   uint32_t glyphCount;
    707   bool isRightToLeft = HB_DIRECTION_IS_BACKWARD (buffer->props.direction);
    708 
    709   const wchar_t localeName[20] = {0};
    710   if (buffer->props.language != NULL)
    711   {
    712     mbstowcs ((wchar_t*) localeName,
    713       hb_language_to_string (buffer->props.language), 20);
    714   }
    715 
    716   DWRITE_TYPOGRAPHIC_FEATURES singleFeatures;
    717   singleFeatures.featureCount = num_features;
    718   if (num_features)
    719   {
    720     DWRITE_FONT_FEATURE* dwfeatureArray = (DWRITE_FONT_FEATURE*)
    721       malloc (sizeof (DWRITE_FONT_FEATURE) * num_features);
    722     for (unsigned int i = 0; i < num_features; ++i)
    723     {
    724       dwfeatureArray[i].nameTag = (DWRITE_FONT_FEATURE_TAG)
    725         hb_uint32_swap (features[i].tag);
    726       dwfeatureArray[i].parameter = features[i].value;
    727     }
    728     singleFeatures.features = dwfeatureArray;
    729   }
    730   const DWRITE_TYPOGRAPHIC_FEATURES* dwFeatures =
    731     (const DWRITE_TYPOGRAPHIC_FEATURES*) &singleFeatures;
    732   const uint32_t featureRangeLengths[] = { textLength };
    733 
    734 retry_getglyphs:
    735   uint16_t* clusterMap = (uint16_t*) malloc (maxGlyphCount * sizeof (uint16_t));
    736   uint16_t* glyphIndices = (uint16_t*) malloc (maxGlyphCount * sizeof (uint16_t));
    737   DWRITE_SHAPING_TEXT_PROPERTIES* textProperties = (DWRITE_SHAPING_TEXT_PROPERTIES*)
    738     malloc (maxGlyphCount * sizeof (DWRITE_SHAPING_TEXT_PROPERTIES));
    739   DWRITE_SHAPING_GLYPH_PROPERTIES* glyphProperties = (DWRITE_SHAPING_GLYPH_PROPERTIES*)
    740     malloc (maxGlyphCount * sizeof (DWRITE_SHAPING_GLYPH_PROPERTIES));
    741 
    742   hr = analyzer->GetGlyphs (textString, textLength, fontFace, FALSE,
    743     isRightToLeft, &runHead->mScript, localeName, NULL, &dwFeatures,
    744     featureRangeLengths, 1, maxGlyphCount, clusterMap, textProperties, glyphIndices,
    745     glyphProperties, &glyphCount);
    746 
    747   if (unlikely (hr == HRESULT_FROM_WIN32 (ERROR_INSUFFICIENT_BUFFER)))
    748   {
    749     free (clusterMap);
    750     free (glyphIndices);
    751     free (textProperties);
    752     free (glyphProperties);
    753 
    754     maxGlyphCount *= 2;
    755 
    756     goto retry_getglyphs;
    757   }
    758   if (FAILED (hr))
    759   {
    760     FAIL ("Analyzer failed to get glyphs.");
    761     return false;
    762   }
    763 
    764   float* glyphAdvances = (float*) malloc (maxGlyphCount * sizeof (float));
    765   DWRITE_GLYPH_OFFSET* glyphOffsets = (DWRITE_GLYPH_OFFSET*)
    766     malloc(maxGlyphCount * sizeof (DWRITE_GLYPH_OFFSET));
    767 
    768   /* The -2 in the following is to compensate for possible
    769    * alignment needed after the WORD array.  sizeof(WORD) == 2. */
    770   unsigned int glyphs_size = (scratch_size * sizeof(int) - 2)
    771          / (sizeof(WORD) +
    772             sizeof(DWRITE_SHAPING_GLYPH_PROPERTIES) +
    773             sizeof(int) +
    774             sizeof(DWRITE_GLYPH_OFFSET) +
    775             sizeof(uint32_t));
    776   ALLOCATE_ARRAY (uint32_t, vis_clusters, glyphs_size);
    777 
    778 #undef ALLOCATE_ARRAY
    779 
    780   int fontEmSize = font->face->get_upem();
    781   if (fontEmSize < 0)
    782     fontEmSize = -fontEmSize;
    783 
    784   if (fontEmSize < 0)
    785     fontEmSize = -fontEmSize;
    786   double x_mult = (double) font->x_scale / fontEmSize;
    787   double y_mult = (double) font->y_scale / fontEmSize;
    788 
    789   hr = analyzer->GetGlyphPlacements (textString,
    790     clusterMap, textProperties, textLength, glyphIndices,
    791     glyphProperties, glyphCount, fontFace, fontEmSize,
    792     FALSE, isRightToLeft, &runHead->mScript, localeName,
    793     &dwFeatures, featureRangeLengths, 1,
    794     glyphAdvances, glyphOffsets);
    795 
    796   if (FAILED (hr))
    797   {
    798     FAIL ("Analyzer failed to get glyph placements.");
    799     return false;
    800   }
    801 
    802 #ifdef HB_DIRECTWRITE_EXPERIMENTAL_JUSTIFICATION
    803 
    804   DWRITE_JUSTIFICATION_OPPORTUNITY* justificationOpportunities =
    805     (DWRITE_JUSTIFICATION_OPPORTUNITY*)
    806     malloc (maxGlyphCount * sizeof (DWRITE_JUSTIFICATION_OPPORTUNITY));
    807   hr = analyzer->GetJustificationOpportunities (fontFace, fontEmSize,
    808     runHead->mScript, textLength, glyphCount, textString, clusterMap,
    809     glyphProperties, justificationOpportunities);
    810 
    811   if (FAILED (hr))
    812   {
    813     FAIL ("Analyzer failed to get justification opportunities.");
    814     return false;
    815   }
    816 
    817   // TODO: get lineWith from somewhere
    818   float lineWidth = 60000;
    819 
    820   float* justifiedGlyphAdvances =
    821     (float*) malloc (maxGlyphCount * sizeof (float));
    822   DWRITE_GLYPH_OFFSET* justifiedGlyphOffsets = (DWRITE_GLYPH_OFFSET*)
    823     malloc (glyphCount * sizeof (DWRITE_GLYPH_OFFSET));
    824   hr = analyzer->JustifyGlyphAdvances (lineWidth, glyphCount, justificationOpportunities,
    825     glyphAdvances, glyphOffsets, justifiedGlyphAdvances, justifiedGlyphOffsets);
    826 
    827   if (FAILED (hr))
    828   {
    829     FAIL ("Analyzer failed to get justified glyph advances.");
    830     return false;
    831   }
    832 
    833   DWRITE_SCRIPT_PROPERTIES scriptProperties;
    834   hr = analyzer->GetScriptProperties (runHead->mScript, &scriptProperties);
    835   if (FAILED (hr))
    836   {
    837     FAIL ("Analyzer failed to get script properties.");
    838     return false;
    839   }
    840   uint32_t justificationCharacter = scriptProperties.justificationCharacter;
    841 
    842   // if a script justificationCharacter is not space, it can have GetJustifiedGlyphs
    843   if (justificationCharacter != 32)
    844   {
    845 retry_getjustifiedglyphs:
    846     uint16_t* modifiedClusterMap = (uint16_t*) malloc (maxGlyphCount * sizeof (uint16_t));
    847     uint16_t* modifiedGlyphIndices = (uint16_t*) malloc (maxGlyphCount * sizeof (uint16_t));
    848     float* modifiedGlyphAdvances = (float*) malloc (maxGlyphCount * sizeof (float));
    849     DWRITE_GLYPH_OFFSET* modifiedGlyphOffsets = (DWRITE_GLYPH_OFFSET*)
    850       malloc (maxGlyphCount * sizeof (DWRITE_GLYPH_OFFSET));
    851     uint32_t actualGlyphsCount;
    852     hr = analyzer->GetJustifiedGlyphs (fontFace, fontEmSize, runHead->mScript,
    853         textLength, glyphCount, maxGlyphCount, clusterMap, glyphIndices,
    854         glyphAdvances, justifiedGlyphAdvances, justifiedGlyphOffsets,
    855         glyphProperties, &actualGlyphsCount, modifiedClusterMap, modifiedGlyphIndices,
    856         modifiedGlyphAdvances, modifiedGlyphOffsets);
    857 
    858     if (hr == HRESULT_FROM_WIN32 (ERROR_INSUFFICIENT_BUFFER))
    859     {
    860       maxGlyphCount = actualGlyphsCount;
    861       free (modifiedClusterMap);
    862       free (modifiedGlyphIndices);
    863       free (modifiedGlyphAdvances);
    864       free (modifiedGlyphOffsets);
    865 
    866       maxGlyphCount = actualGlyphsCount;
    867 
    868       goto retry_getjustifiedglyphs;
    869     }
    870     if (FAILED (hr))
    871     {
    872       FAIL ("Analyzer failed to get justified glyphs.");
    873       return false;
    874     }
    875 
    876     free (clusterMap);
    877     free (glyphIndices);
    878     free (glyphAdvances);
    879     free (glyphOffsets);
    880 
    881     glyphCount = actualGlyphsCount;
    882     clusterMap = modifiedClusterMap;
    883     glyphIndices = modifiedGlyphIndices;
    884     glyphAdvances = modifiedGlyphAdvances;
    885     glyphOffsets = modifiedGlyphOffsets;
    886 
    887     free(justifiedGlyphAdvances);
    888     free(justifiedGlyphOffsets);
    889   }
    890   else
    891   {
    892     free(glyphAdvances);
    893     free(glyphOffsets);
    894 
    895     glyphAdvances = justifiedGlyphAdvances;
    896     glyphOffsets = justifiedGlyphOffsets;
    897   }
    898 
    899   free(justificationOpportunities);
    900 
    901 #endif
    902 
    903   /* Ok, we've got everything we need, now compose output buffer,
    904    * very, *very*, carefully! */
    905 
    906   /* Calculate visual-clusters.  That's what we ship. */
    907   for (unsigned int i = 0; i < glyphCount; i++)
    908     vis_clusters[i] = -1;
    909   for (unsigned int i = 0; i < buffer->len; i++)
    910   {
    911     uint32_t *p =
    912       &vis_clusters[log_clusters[buffer->info[i].utf16_index()]];
    913     *p = MIN (*p, buffer->info[i].cluster);
    914   }
    915   for (unsigned int i = 1; i < glyphCount; i++)
    916     if (vis_clusters[i] == -1)
    917       vis_clusters[i] = vis_clusters[i - 1];
    918 
    919 #undef utf16_index
    920 
    921   if (unlikely (!buffer->ensure (glyphCount)))
    922     FAIL ("Buffer in error");
    923 
    924 #undef FAIL
    925 
    926   /* Set glyph infos */
    927   buffer->len = 0;
    928   for (unsigned int i = 0; i < glyphCount; i++)
    929   {
    930     hb_glyph_info_t *info = &buffer->info[buffer->len++];
    931 
    932     info->codepoint = glyphIndices[i];
    933     info->cluster = vis_clusters[i];
    934 
    935     /* The rest is crap.  Let's store position info there for now. */
    936     info->mask = glyphAdvances[i];
    937     info->var1.i32 = glyphOffsets[i].advanceOffset;
    938     info->var2.i32 = glyphOffsets[i].ascenderOffset;
    939   }
    940 
    941   /* Set glyph positions */
    942   buffer->clear_positions ();
    943   for (unsigned int i = 0; i < glyphCount; i++)
    944   {
    945     hb_glyph_info_t *info = &buffer->info[i];
    946     hb_glyph_position_t *pos = &buffer->pos[i];
    947 
    948     /* TODO vertical */
    949     pos->x_advance = x_mult * (int32_t) info->mask;
    950     pos->x_offset =
    951       x_mult * (isRightToLeft ? -info->var1.i32 : info->var1.i32);
    952     pos->y_offset = y_mult * info->var2.i32;
    953   }
    954 
    955   if (isRightToLeft)
    956     hb_buffer_reverse (buffer);
    957 
    958   free (clusterMap);
    959   free (glyphIndices);
    960   free (textProperties);
    961   free (glyphProperties);
    962   free (glyphAdvances);
    963   free (glyphOffsets);
    964 
    965   if (num_features)
    966     free (singleFeatures.features);
    967 
    968   /* Wow, done! */
    969   return true;
    970 }
    971