dlls/dwrite/freetype.c

   1 /*
   2  *    FreeType integration
   3  *
   4  * Copyright 2014-2017 Nikolay Sivov for CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #define COBJMACROS
  22
  23 #include "config.h"
  24 #include "wine/port.h"
  25
  26 #ifdef HAVE_FT2BUILD_H
  27 #include <ft2build.h>
  28 #include FT_CACHE_H
  29 #include FT_FREETYPE_H
  30 #include FT_OUTLINE_H
  31 #include FT_TRUETYPE_TABLES_H
  32 #endif /* HAVE_FT2BUILD_H */
  33
  34 #include "windef.h"
  35 #include "wine/library.h"
  36 #include "wine/debug.h"
  37
  38 #include "dwrite_private.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(dwrite);
  41
  42 #ifdef HAVE_FREETYPE
  43
  44 static CRITICAL_SECTION freetype_cs;
  45 static CRITICAL_SECTION_DEBUG critsect_debug =
  46 {
  47     0, 0, &freetype_cs,
  48     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
  49       0, 0, { (DWORD_PTR)(__FILE__ ": freetype_cs") }
  50 };
  51 static CRITICAL_SECTION freetype_cs = { &critsect_debug, -1, 0, 0, 0, 0 };
  52
  53 static void *ft_handle = NULL;
  54 static FT_Library library = 0;
  55 static FTC_Manager cache_manager = 0;
  56 static FTC_CMapCache cmap_cache = 0;
  57 static FTC_ImageCache image_cache = 0;
  58 typedef struct
  59 {
  60     FT_Int major;
  61     FT_Int minor;
  62     FT_Int patch;
  63 } FT_Version_t;
  64
  65 #define MAKE_FUNCPTR(f) static typeof(f) * p##f = NULL
  66 MAKE_FUNCPTR(FT_Done_FreeType);
  67 MAKE_FUNCPTR(FT_Done_Glyph);
  68 MAKE_FUNCPTR(FT_Get_First_Char);
  69 MAKE_FUNCPTR(FT_Get_Kerning);
  70 MAKE_FUNCPTR(FT_Get_Sfnt_Table);
  71 MAKE_FUNCPTR(FT_Glyph_Copy);
  72 MAKE_FUNCPTR(FT_Glyph_Get_CBox);
  73 MAKE_FUNCPTR(FT_Glyph_Transform);
  74 MAKE_FUNCPTR(FT_Init_FreeType);
  75 MAKE_FUNCPTR(FT_Library_Version);
  76 MAKE_FUNCPTR(FT_Load_Glyph);
  77 MAKE_FUNCPTR(FT_Matrix_Multiply);
  78 MAKE_FUNCPTR(FT_New_Memory_Face);
  79 MAKE_FUNCPTR(FT_Outline_Copy);
  80 MAKE_FUNCPTR(FT_Outline_Decompose);
  81 MAKE_FUNCPTR(FT_Outline_Done);
  82 MAKE_FUNCPTR(FT_Outline_Embolden);
  83 MAKE_FUNCPTR(FT_Outline_Get_Bitmap);
  84 MAKE_FUNCPTR(FT_Outline_New);
  85 MAKE_FUNCPTR(FT_Outline_Transform);
  86 MAKE_FUNCPTR(FT_Outline_Translate);
  87 MAKE_FUNCPTR(FTC_CMapCache_Lookup);
  88 MAKE_FUNCPTR(FTC_CMapCache_New);
  89 MAKE_FUNCPTR(FTC_ImageCache_Lookup);
  90 MAKE_FUNCPTR(FTC_ImageCache_New);
  91 MAKE_FUNCPTR(FTC_Manager_New);
  92 MAKE_FUNCPTR(FTC_Manager_Done);
  93 MAKE_FUNCPTR(FTC_Manager_LookupFace);
  94 MAKE_FUNCPTR(FTC_Manager_LookupSize);
  95 MAKE_FUNCPTR(FTC_Manager_RemoveFaceID);
  96 #undef MAKE_FUNCPTR
  97 static FT_Error (*pFT_Outline_EmboldenXY)(FT_Outline *, FT_Pos, FT_Pos);
  98
  99 struct face_finalizer_data
 100 {
 101     IDWriteFontFileStream *stream;
 102     void *context;
 103 };
 104
 105 static void face_finalizer(void *object)
 106 {
 107     FT_Face face = object;
 108     struct face_finalizer_data *data = (struct face_finalizer_data *)face->generic.data;
 109
 110     IDWriteFontFileStream_ReleaseFileFragment(data->stream, data->context);
 111     IDWriteFontFileStream_Release(data->stream);
 112     heap_free(data);
 113 }
 114
 115 static FT_Error face_requester(FTC_FaceID face_id, FT_Library library, FT_Pointer request_data, FT_Face *face)
 116 {
 117     IDWriteFontFace *fontface = (IDWriteFontFace*)face_id;
 118     IDWriteFontFileStream *stream;
 119     IDWriteFontFile *file;
 120     const void *data_ptr;
 121     UINT32 index, count;
 122     FT_Error fterror;
 123     UINT64 data_size;
 124     void *context;
 125     HRESULT hr;
 126
 127     *face = NULL;
 128
 129     if (!fontface) {
 130         WARN("NULL fontface requested.\n");
 131         return FT_Err_Ok;
 132     }
 133
 134     count = 1;
 135     hr = IDWriteFontFace_GetFiles(fontface, &count, &file);
 136     if (FAILED(hr))
 137         return FT_Err_Ok;
 138
 139     hr = get_filestream_from_file(file, &stream);
 140     IDWriteFontFile_Release(file);
 141     if (FAILED(hr))
 142         return FT_Err_Ok;
 143
 144     hr = IDWriteFontFileStream_GetFileSize(stream, &data_size);
 145     if (FAILED(hr)) {
 146         fterror = FT_Err_Invalid_Stream_Read;
 147         goto fail;
 148     }
 149
 150     hr = IDWriteFontFileStream_ReadFileFragment(stream, &data_ptr, 0, data_size, &context);
 151     if (FAILED(hr)) {
 152         fterror = FT_Err_Invalid_Stream_Read;
 153         goto fail;
 154     }
 155
 156     index = IDWriteFontFace_GetIndex(fontface);
 157     fterror = pFT_New_Memory_Face(library, data_ptr, data_size, index, face);
 158     if (fterror == FT_Err_Ok) {
 159         struct face_finalizer_data *data;
 160
 161         data = heap_alloc(sizeof(*data));
 162         data->stream = stream;
 163         data->context = context;
 164
 165         (*face)->generic.data = data;
 166         (*face)->generic.finalizer = face_finalizer;
 167         return fterror;
 168     }
 169     else
 170         IDWriteFontFileStream_ReleaseFileFragment(stream, context);
 171
 172 fail:
 173     IDWriteFontFileStream_Release(stream);
 174
 175     return fterror;
 176 }
 177
 178 BOOL init_freetype(void)
 179 {
 180     FT_Version_t FT_Version;
 181
 182     ft_handle = wine_dlopen(SONAME_LIBFREETYPE, RTLD_NOW, NULL, 0);
 183     if (!ft_handle) {
 184         WINE_MESSAGE("Wine cannot find the FreeType font library.\n");
 185         return FALSE;
 186     }
 187
 188 #define LOAD_FUNCPTR(f) if((p##f = wine_dlsym(ft_handle, #f, NULL, 0)) == NULL){WARN("Can't find symbol %s\n", #f); goto sym_not_found;}
 189     LOAD_FUNCPTR(FT_Done_FreeType)
 190     LOAD_FUNCPTR(FT_Done_Glyph)
 191     LOAD_FUNCPTR(FT_Get_First_Char)
 192     LOAD_FUNCPTR(FT_Get_Kerning)
 193     LOAD_FUNCPTR(FT_Get_Sfnt_Table)
 194     LOAD_FUNCPTR(FT_Glyph_Copy)
 195     LOAD_FUNCPTR(FT_Glyph_Get_CBox)
 196     LOAD_FUNCPTR(FT_Glyph_Transform)
 197     LOAD_FUNCPTR(FT_Init_FreeType)
 198     LOAD_FUNCPTR(FT_Library_Version)
 199     LOAD_FUNCPTR(FT_Load_Glyph)
 200     LOAD_FUNCPTR(FT_Matrix_Multiply)
 201     LOAD_FUNCPTR(FT_New_Memory_Face)
 202     LOAD_FUNCPTR(FT_Outline_Copy)
 203     LOAD_FUNCPTR(FT_Outline_Decompose)
 204     LOAD_FUNCPTR(FT_Outline_Done)
 205     LOAD_FUNCPTR(FT_Outline_Embolden)
 206     LOAD_FUNCPTR(FT_Outline_Get_Bitmap)
 207     LOAD_FUNCPTR(FT_Outline_New)
 208     LOAD_FUNCPTR(FT_Outline_Transform)
 209     LOAD_FUNCPTR(FT_Outline_Translate)
 210     LOAD_FUNCPTR(FTC_CMapCache_Lookup)
 211     LOAD_FUNCPTR(FTC_CMapCache_New)
 212     LOAD_FUNCPTR(FTC_ImageCache_Lookup)
 213     LOAD_FUNCPTR(FTC_ImageCache_New)
 214     LOAD_FUNCPTR(FTC_Manager_New)
 215     LOAD_FUNCPTR(FTC_Manager_Done)
 216     LOAD_FUNCPTR(FTC_Manager_LookupFace)
 217     LOAD_FUNCPTR(FTC_Manager_LookupSize)
 218     LOAD_FUNCPTR(FTC_Manager_RemoveFaceID)
 219 #undef LOAD_FUNCPTR
 220     pFT_Outline_EmboldenXY = wine_dlsym(ft_handle, "FT_Outline_EmboldenXY", NULL, 0);
 221
 222     if (pFT_Init_FreeType(&library) != 0) {
 223         ERR("Can't init FreeType library\n");
 224         wine_dlclose(ft_handle, NULL, 0);
 225         ft_handle = NULL;
 226         return FALSE;
 227     }
 228     pFT_Library_Version(library, &FT_Version.major, &FT_Version.minor, &FT_Version.patch);
 229
 230     /* init cache manager */
 231     if (pFTC_Manager_New(library, 0, 0, 0, &face_requester, NULL, &cache_manager) != 0 ||
 232         pFTC_CMapCache_New(cache_manager, &cmap_cache) != 0 ||
 233         pFTC_ImageCache_New(cache_manager, &image_cache) != 0) {
 234
 235         ERR("Failed to init FreeType cache\n");
 236         pFTC_Manager_Done(cache_manager);
 237         pFT_Done_FreeType(library);
 238         wine_dlclose(ft_handle, NULL, 0);
 239         ft_handle = NULL;
 240         return FALSE;
 241     }
 242
 243     TRACE("FreeType version is %d.%d.%d\n", FT_Version.major, FT_Version.minor, FT_Version.patch);
 244     return TRUE;
 245
 246 sym_not_found:
 247     WINE_MESSAGE("Wine cannot find certain functions that it needs from FreeType library.\n");
 248     wine_dlclose(ft_handle, NULL, 0);
 249     ft_handle = NULL;
 250     return FALSE;
 251 }
 252
 253 void release_freetype(void)
 254 {
 255     pFTC_Manager_Done(cache_manager);
 256     pFT_Done_FreeType(library);
 257 }
 258
 259 void freetype_notify_cacheremove(IDWriteFontFace4 *fontface)
 260 {
 261     EnterCriticalSection(&freetype_cs);
 262     pFTC_Manager_RemoveFaceID(cache_manager, fontface);
 263     LeaveCriticalSection(&freetype_cs);
 264 }
 265
 266 HRESULT freetype_get_design_glyph_metrics(IDWriteFontFace4 *fontface, UINT16 unitsperEm, UINT16 glyph, DWRITE_GLYPH_METRICS *ret)
 267 {
 268     FTC_ScalerRec scaler;
 269     FT_Size size;
 270
 271     scaler.face_id = fontface;
 272     scaler.width  = unitsperEm;
 273     scaler.height = unitsperEm;
 274     scaler.pixel = 1;
 275     scaler.x_res = 0;
 276     scaler.y_res = 0;
 277
 278     EnterCriticalSection(&freetype_cs);
 279     if (pFTC_Manager_LookupSize(cache_manager, &scaler, &size) == 0) {
 280          if (pFT_Load_Glyph(size->face, glyph, FT_LOAD_NO_SCALE) == 0) {
 281              USHORT simulations = IDWriteFontFace4_GetSimulations(fontface);
 282              FT_Glyph_Metrics *metrics = &size->face->glyph->metrics;
 283
 284              ret->leftSideBearing = metrics->horiBearingX;
 285              ret->advanceWidth = metrics->horiAdvance;
 286              ret->rightSideBearing = metrics->horiAdvance - metrics->horiBearingX - metrics->width;
 287              ret->topSideBearing = metrics->vertBearingY;
 288              ret->advanceHeight = metrics->vertAdvance;
 289              ret->bottomSideBearing = metrics->vertAdvance - metrics->vertBearingY - metrics->height;
 290              ret->verticalOriginY = metrics->height + metrics->vertBearingY;
 291
 292              /* Adjust in case of bold simulation, glyphs without contours are ignored. */
 293              if (simulations & DWRITE_FONT_SIMULATIONS_BOLD && size->face->glyph->format == FT_GLYPH_FORMAT_OUTLINE &&
 294                      size->face->glyph->outline.n_contours != 0) {
 295                  if (ret->advanceWidth)
 296                      ret->advanceWidth += (unitsperEm + 49) / 50;
 297              }
 298          }
 299     }
 300     LeaveCriticalSection(&freetype_cs);
 301
 302     return S_OK;
 303 }
 304
 305 BOOL freetype_is_monospaced(IDWriteFontFace4 *fontface)
 306 {
 307     BOOL is_monospaced = FALSE;
 308     FT_Face face;
 309
 310     EnterCriticalSection(&freetype_cs);
 311     if (pFTC_Manager_LookupFace(cache_manager, fontface, &face) == 0)
 312         is_monospaced = !!FT_IS_FIXED_WIDTH(face);
 313     LeaveCriticalSection(&freetype_cs);
 314
 315     return is_monospaced;
 316 }
 317
 318 struct decompose_context {
 319     IDWriteGeometrySink *sink;
 320     FLOAT xoffset;
 321     FLOAT yoffset;
 322     BOOL figure_started;
 323     BOOL move_to;     /* last call was 'move_to' */
 324     FT_Vector origin; /* 'pen' position from last call */
 325 };
 326
 327 static inline void ft_vector_to_d2d_point(const FT_Vector *v, FLOAT xoffset, FLOAT yoffset, D2D1_POINT_2F *p)
 328 {
 329     p->x = (v->x / 64.0f) + xoffset;
 330     p->y = (v->y / 64.0f) + yoffset;
 331 }
 332
 333 static void decompose_beginfigure(struct decompose_context *ctxt)
 334 {
 335     D2D1_POINT_2F point;
 336
 337     if (!ctxt->move_to)
 338         return;
 339
 340     ft_vector_to_d2d_point(&ctxt->origin, ctxt->xoffset, ctxt->yoffset, &point);
 341     ID2D1SimplifiedGeometrySink_BeginFigure(ctxt->sink, point, D2D1_FIGURE_BEGIN_FILLED);
 342
 343     ctxt->figure_started = TRUE;
 344     ctxt->move_to = FALSE;
 345 }
 346
 347 static int decompose_move_to(const FT_Vector *to, void *user)
 348 {
 349     struct decompose_context *ctxt = (struct decompose_context*)user;
 350
 351     if (ctxt->figure_started) {
 352         ID2D1SimplifiedGeometrySink_EndFigure(ctxt->sink, D2D1_FIGURE_END_CLOSED);
 353         ctxt->figure_started = FALSE;
 354     }
 355
 356     ctxt->move_to = TRUE;
 357     ctxt->origin = *to;
 358     return 0;
 359 }
 360
 361 static int decompose_line_to(const FT_Vector *to, void *user)
 362 {
 363     struct decompose_context *ctxt = (struct decompose_context*)user;
 364     D2D1_POINT_2F point;
 365
 366     /* Special case for empty contours, in a way freetype returns them. */
 367     if (ctxt->move_to && !memcmp(to, &ctxt->origin, sizeof(*to)))
 368         return 0;
 369
 370     decompose_beginfigure(ctxt);
 371
 372     ft_vector_to_d2d_point(to, ctxt->xoffset, ctxt->yoffset, &point);
 373     ID2D1SimplifiedGeometrySink_AddLines(ctxt->sink, &point, 1);
 374
 375     ctxt->origin = *to;
 376     return 0;
 377 }
 378
 379 static int decompose_conic_to(const FT_Vector *control, const FT_Vector *to, void *user)
 380 {
 381     struct decompose_context *ctxt = (struct decompose_context*)user;
 382     D2D1_POINT_2F points[3];
 383     FT_Vector cubic[3];
 384
 385     decompose_beginfigure(ctxt);
 386
 387     /* convert from quadratic to cubic */
 388
 389     /*
 390        The parametric eqn for a cubic Bezier is, from PLRM:
 391        r(t) = at^3 + bt^2 + ct + r0
 392        with the control points:
 393        r1 = r0 + c/3
 394        r2 = r1 + (c + b)/3
 395        r3 = r0 + c + b + a
 396
 397        A quadratic Bezier has the form:
 398        p(t) = (1-t)^2 p0 + 2(1-t)t p1 + t^2 p2
 399
 400        So equating powers of t leads to:
 401        r1 = 2/3 p1 + 1/3 p0
 402        r2 = 2/3 p1 + 1/3 p2
 403        and of course r0 = p0, r3 = p2
 404     */
 405
 406     /* r1 = 1/3 p0 + 2/3 p1
 407        r2 = 1/3 p2 + 2/3 p1 */
 408     cubic[0].x = (2 * control->x + 1) / 3;
 409     cubic[0].y = (2 * control->y + 1) / 3;
 410     cubic[1] = cubic[0];
 411     cubic[0].x += (ctxt->origin.x + 1) / 3;
 412     cubic[0].y += (ctxt->origin.y + 1) / 3;
 413     cubic[1].x += (to->x + 1) / 3;
 414     cubic[1].y += (to->y + 1) / 3;
 415     cubic[2] = *to;
 416
 417     ft_vector_to_d2d_point(cubic, ctxt->xoffset, ctxt->yoffset, points);
 418     ft_vector_to_d2d_point(cubic + 1, ctxt->xoffset, ctxt->yoffset, points + 1);
 419     ft_vector_to_d2d_point(cubic + 2, ctxt->xoffset, ctxt->yoffset, points + 2);
 420     ID2D1SimplifiedGeometrySink_AddBeziers(ctxt->sink, (D2D1_BEZIER_SEGMENT*)points, 1);
 421     ctxt->origin = *to;
 422     return 0;
 423 }
 424
 425 static int decompose_cubic_to(const FT_Vector *control1, const FT_Vector *control2,
 426     const FT_Vector *to, void *user)
 427 {
 428     struct decompose_context *ctxt = (struct decompose_context*)user;
 429     D2D1_POINT_2F points[3];
 430
 431     decompose_beginfigure(ctxt);
 432
 433     ft_vector_to_d2d_point(control1, ctxt->xoffset, ctxt->yoffset, points);
 434     ft_vector_to_d2d_point(control2, ctxt->xoffset, ctxt->yoffset, points + 1);
 435     ft_vector_to_d2d_point(to, ctxt->xoffset, ctxt->yoffset, points + 2);
 436     ID2D1SimplifiedGeometrySink_AddBeziers(ctxt->sink, (D2D1_BEZIER_SEGMENT*)points, 1);
 437     ctxt->origin = *to;
 438     return 0;
 439 }
 440
 441 static void decompose_outline(FT_Outline *outline, FLOAT xoffset, FLOAT yoffset, IDWriteGeometrySink *sink)
 442 {
 443     static const FT_Outline_Funcs decompose_funcs = {
 444         decompose_move_to,
 445         decompose_line_to,
 446         decompose_conic_to,
 447         decompose_cubic_to,
 448         0,
 449         0
 450     };
 451     struct decompose_context context;
 452
 453     context.sink = sink;
 454     context.xoffset = xoffset;
 455     context.yoffset = yoffset;
 456     context.figure_started = FALSE;
 457     context.move_to = FALSE;
 458     context.origin.x = 0;
 459     context.origin.y = 0;
 460
 461     pFT_Outline_Decompose(outline, &decompose_funcs, &context);
 462
 463     if (context.figure_started)
 464         ID2D1SimplifiedGeometrySink_EndFigure(sink, D2D1_FIGURE_END_CLOSED);
 465 }
 466
 467 static void embolden_glyph_outline(FT_Outline *outline, FLOAT emsize)
 468 {
 469     FT_Pos strength;
 470
 471     strength = MulDiv(emsize, 1 << 6, 24);
 472     if (pFT_Outline_EmboldenXY)
 473         pFT_Outline_EmboldenXY(outline, strength, 0);
 474     else
 475         pFT_Outline_Embolden(outline, strength);
 476 }
 477
 478 static void embolden_glyph(FT_Glyph glyph, FLOAT emsize)
 479 {
 480     FT_OutlineGlyph outline_glyph = (FT_OutlineGlyph)glyph;
 481
 482     if (glyph->format != FT_GLYPH_FORMAT_OUTLINE)
 483         return;
 484
 485     embolden_glyph_outline(&outline_glyph->outline, emsize);
 486 }
 487
 488 HRESULT freetype_get_glyphrun_outline(IDWriteFontFace4 *fontface, FLOAT emSize, UINT16 const *glyphs,
 489     FLOAT const *advances, DWRITE_GLYPH_OFFSET const *offsets, UINT32 count, BOOL is_rtl, IDWriteGeometrySink *sink)
 490 {
 491     FTC_ScalerRec scaler;
 492     USHORT simulations;
 493     HRESULT hr = S_OK;
 494     FT_Size size;
 495
 496     if (!count)
 497         return S_OK;
 498
 499     ID2D1SimplifiedGeometrySink_SetFillMode(sink, D2D1_FILL_MODE_WINDING);
 500
 501     simulations = IDWriteFontFace4_GetSimulations(fontface);
 502
 503     scaler.face_id = fontface;
 504     scaler.width  = emSize;
 505     scaler.height = emSize;
 506     scaler.pixel = 1;
 507     scaler.x_res = 0;
 508     scaler.y_res = 0;
 509
 510     EnterCriticalSection(&freetype_cs);
 511     if (pFTC_Manager_LookupSize(cache_manager, &scaler, &size) == 0) {
 512         FLOAT advance = 0.0f;
 513         UINT32 g;
 514
 515         for (g = 0; g < count; g++) {
 516             if (pFT_Load_Glyph(size->face, glyphs[g], FT_LOAD_NO_BITMAP) == 0) {
 517                 FLOAT ft_advance = size->face->glyph->metrics.horiAdvance >> 6;
 518                 FT_Outline *outline = &size->face->glyph->outline;
 519                 FLOAT xoffset = 0.0f, yoffset = 0.0f;
 520                 FT_Matrix m;
 521
 522                 if (simulations & DWRITE_FONT_SIMULATIONS_BOLD)
 523                     embolden_glyph_outline(outline, emSize);
 524
 525                 m.xx = 1 << 16;
 526                 m.xy = simulations & DWRITE_FONT_SIMULATIONS_OBLIQUE ? (1 << 16) / 3 : 0;
 527                 m.yx = 0;
 528                 m.yy = -(1 << 16); /* flip Y axis */
 529
 530                 pFT_Outline_Transform(outline, &m);
 531
 532                 /* glyph offsets act as current glyph adjustment */
 533                 if (offsets) {
 534                     xoffset += is_rtl ? -offsets[g].advanceOffset : offsets[g].advanceOffset;
 535                     yoffset -= offsets[g].ascenderOffset;
 536                 }
 537
 538                 if (g == 0 && is_rtl)
 539                     advance = advances ? -advances[g] : -ft_advance;
 540
 541                 xoffset += advance;
 542                 decompose_outline(outline, xoffset, yoffset, sink);
 543
 544                 /* update advance to next glyph */
 545                 if (advances)
 546                     advance += is_rtl ? -advances[g] : advances[g];
 547                 else
 548                     advance += is_rtl ? -ft_advance : ft_advance;
 549             }
 550         }
 551     }
 552     else
 553         hr = E_FAIL;
 554     LeaveCriticalSection(&freetype_cs);
 555
 556     return hr;
 557 }
 558
 559 UINT16 freetype_get_glyphcount(IDWriteFontFace4 *fontface)
 560 {
 561     UINT16 count = 0;
 562     FT_Face face;
 563
 564     EnterCriticalSection(&freetype_cs);
 565     if (pFTC_Manager_LookupFace(cache_manager, fontface, &face) == 0)
 566         count = face->num_glyphs;
 567     LeaveCriticalSection(&freetype_cs);
 568
 569     return count;
 570 }
 571
 572 void freetype_get_glyphs(IDWriteFontFace4 *fontface, INT charmap, UINT32 const *codepoints, UINT32 count,
 573     UINT16 *glyphs)
 574 {
 575     UINT32 i;
 576
 577     EnterCriticalSection(&freetype_cs);
 578     for (i = 0; i < count; i++) {
 579         if (charmap == -1)
 580             glyphs[i] = pFTC_CMapCache_Lookup(cmap_cache, fontface, charmap, codepoints[i]);
 581         else {
 582             UINT32 codepoint = codepoints[i];
 583             /* special handling for symbol fonts */
 584             if (codepoint < 0x100) codepoint += 0xf000;
 585             glyphs[i] = pFTC_CMapCache_Lookup(cmap_cache, fontface, charmap, codepoint);
 586             if (!glyphs[i])
 587                 glyphs[i] = pFTC_CMapCache_Lookup(cmap_cache, fontface, charmap, codepoint - 0xf000);
 588         }
 589     }
 590     LeaveCriticalSection(&freetype_cs);
 591 }
 592
 593 BOOL freetype_has_kerning_pairs(IDWriteFontFace4 *fontface)
 594 {
 595     BOOL has_kerning_pairs = FALSE;
 596     FT_Face face;
 597
 598     EnterCriticalSection(&freetype_cs);
 599     if (pFTC_Manager_LookupFace(cache_manager, fontface, &face) == 0)
 600         has_kerning_pairs = !!FT_HAS_KERNING(face);
 601     LeaveCriticalSection(&freetype_cs);
 602
 603     return has_kerning_pairs;
 604 }
 605
 606 INT32 freetype_get_kerning_pair_adjustment(IDWriteFontFace4 *fontface, UINT16 left, UINT16 right)
 607 {
 608     INT32 adjustment = 0;
 609     FT_Face face;
 610
 611     EnterCriticalSection(&freetype_cs);
 612     if (pFTC_Manager_LookupFace(cache_manager, fontface, &face) == 0) {
 613         FT_Vector kern;
 614         if (FT_HAS_KERNING(face)) {
 615             pFT_Get_Kerning(face, left, right, FT_KERNING_UNSCALED, &kern);
 616             adjustment = kern.x;
 617         }
 618     }
 619     LeaveCriticalSection(&freetype_cs);
 620
 621     return adjustment;
 622 }
 623
 624 static inline void ft_matrix_from_dwrite_matrix(const DWRITE_MATRIX *m, FT_Matrix *ft_matrix)
 625 {
 626     ft_matrix->xx =  m->m11 * 0x10000;
 627     ft_matrix->xy = -m->m21 * 0x10000;
 628     ft_matrix->yx = -m->m12 * 0x10000;
 629     ft_matrix->yy =  m->m22 * 0x10000;
 630 }
 631
 632 /* Should be used only while holding 'freetype_cs' */
 633 static BOOL is_face_scalable(IDWriteFontFace4 *fontface)
 634 {
 635     FT_Face face;
 636     if (pFTC_Manager_LookupFace(cache_manager, fontface, &face) == 0)
 637         return FT_IS_SCALABLE(face);
 638     else
 639         return FALSE;
 640 }
 641
 642 static BOOL get_glyph_transform(struct dwrite_glyphbitmap *bitmap, FT_Matrix *ret)
 643 {
 644     FT_Matrix m;
 645
 646     ret->xx = 1 << 16;
 647     ret->xy = 0;
 648     ret->yx = 0;
 649     ret->yy = 1 << 16;
 650
 651     /* Some fonts provide mostly bitmaps and very few outlines, for example for .notdef.
 652        Disable transform if that's the case. */
 653     if (!is_face_scalable(bitmap->fontface) || (!bitmap->m && bitmap->simulations == 0))
 654         return FALSE;
 655
 656     if (bitmap->simulations & DWRITE_FONT_SIMULATIONS_OBLIQUE) {
 657         m.xx =  1 << 16;
 658         m.xy = (1 << 16) / 3;
 659         m.yx =  0;
 660         m.yy =  1 << 16;
 661         pFT_Matrix_Multiply(&m, ret);
 662     }
 663
 664     if (bitmap->m) {
 665         ft_matrix_from_dwrite_matrix(bitmap->m, &m);
 666         pFT_Matrix_Multiply(&m, ret);
 667     }
 668
 669     return TRUE;
 670 }
 671
 672 void freetype_get_glyph_bbox(struct dwrite_glyphbitmap *bitmap)
 673 {
 674     FTC_ImageTypeRec imagetype;
 675     FT_BBox bbox = { 0 };
 676     BOOL needs_transform;
 677     FT_Glyph glyph;
 678     FT_Matrix m;
 679
 680     EnterCriticalSection(&freetype_cs);
 681
 682     needs_transform = get_glyph_transform(bitmap, &m);
 683
 684     imagetype.face_id = bitmap->fontface;
 685     imagetype.width = 0;
 686     imagetype.height = bitmap->emsize;
 687     imagetype.flags = needs_transform ? FT_LOAD_NO_BITMAP : FT_LOAD_DEFAULT;
 688
 689     if (pFTC_ImageCache_Lookup(image_cache, &imagetype, bitmap->index, &glyph, NULL) == 0) {
 690         if (needs_transform) {
 691             FT_Glyph glyph_copy;
 692
 693             if (pFT_Glyph_Copy(glyph, &glyph_copy) == 0) {
 694                 if (bitmap->simulations & DWRITE_FONT_SIMULATIONS_BOLD)
 695                     embolden_glyph(glyph_copy, bitmap->emsize);
 696
 697                 /* Includes oblique and user transform. */
 698                 pFT_Glyph_Transform(glyph_copy, &m, NULL);
 699                 pFT_Glyph_Get_CBox(glyph_copy, FT_GLYPH_BBOX_PIXELS, &bbox);
 700                 pFT_Done_Glyph(glyph_copy);
 701             }
 702         }
 703         else
 704             pFT_Glyph_Get_CBox(glyph, FT_GLYPH_BBOX_PIXELS, &bbox);
 705     }
 706
 707     LeaveCriticalSection(&freetype_cs);
 708
 709     /* flip Y axis */
 710     SetRect(&bitmap->bbox, bbox.xMin, -bbox.yMax, bbox.xMax, -bbox.yMin);
 711 }
 712
 713 void freetype_get_design_glyph_bbox(IDWriteFontFace4 *fontface, UINT16 unitsperEm, UINT16 glyph, RECT *bbox)
 714 {
 715     FTC_ScalerRec scaler;
 716     FT_Size size;
 717
 718     scaler.face_id = fontface;
 719     scaler.width  = unitsperEm;
 720     scaler.height = unitsperEm;
 721     scaler.pixel = 1;
 722     scaler.x_res = 0;
 723     scaler.y_res = 0;
 724
 725     EnterCriticalSection(&freetype_cs);
 726     if (pFTC_Manager_LookupSize(cache_manager, &scaler, &size) == 0) {
 727          if (pFT_Load_Glyph(size->face, glyph, FT_LOAD_NO_SCALE) == 0) {
 728              FT_Glyph_Metrics *metrics = &size->face->glyph->metrics;
 729
 730              bbox->left = metrics->horiBearingX;
 731              bbox->right = bbox->left + metrics->horiAdvance;
 732              bbox->top = -metrics->horiBearingY;
 733              bbox->bottom = bbox->top + metrics->height;
 734          }
 735     }
 736     LeaveCriticalSection(&freetype_cs);
 737 }
 738
 739 static BOOL freetype_get_aliased_glyph_bitmap(struct dwrite_glyphbitmap *bitmap, FT_Glyph glyph)
 740 {
 741     const RECT *bbox = &bitmap->bbox;
 742     int width = bbox->right - bbox->left;
 743     int height = bbox->bottom - bbox->top;
 744
 745     if (glyph->format == FT_GLYPH_FORMAT_OUTLINE) {
 746         FT_OutlineGlyph outline = (FT_OutlineGlyph)glyph;
 747         const FT_Outline *src = &outline->outline;
 748         FT_Bitmap ft_bitmap;
 749         FT_Outline copy;
 750
 751         ft_bitmap.width = width;
 752         ft_bitmap.rows = height;
 753         ft_bitmap.pitch = bitmap->pitch;
 754         ft_bitmap.pixel_mode = FT_PIXEL_MODE_MONO;
 755         ft_bitmap.buffer = bitmap->buf;
 756
 757         /* Note: FreeType will only set 'black' bits for us. */
 758         if (pFT_Outline_New(library, src->n_points, src->n_contours, &copy) == 0) {
 759             pFT_Outline_Copy(src, &copy);
 760             pFT_Outline_Translate(&copy, -bbox->left << 6, bbox->bottom << 6);
 761             pFT_Outline_Get_Bitmap(library, &copy, &ft_bitmap);
 762             pFT_Outline_Done(library, &copy);
 763         }
 764     }
 765     else if (glyph->format == FT_GLYPH_FORMAT_BITMAP) {
 766         FT_Bitmap *ft_bitmap = &((FT_BitmapGlyph)glyph)->bitmap;
 767         BYTE *src = ft_bitmap->buffer, *dst = bitmap->buf;
 768         int w = min(bitmap->pitch, (ft_bitmap->width + 7) >> 3);
 769         int h = min(height, ft_bitmap->rows);
 770
 771         while (h--) {
 772             memcpy(dst, src, w);
 773             src += ft_bitmap->pitch;
 774             dst += bitmap->pitch;
 775         }
 776     }
 777     else
 778         FIXME("format %x not handled\n", glyph->format);
 779
 780     return TRUE;
 781 }
 782
 783 static BOOL freetype_get_aa_glyph_bitmap(struct dwrite_glyphbitmap *bitmap, FT_Glyph glyph)
 784 {
 785     const RECT *bbox = &bitmap->bbox;
 786     int width = bbox->right - bbox->left;
 787     int height = bbox->bottom - bbox->top;
 788     BOOL ret = FALSE;
 789
 790     if (glyph->format == FT_GLYPH_FORMAT_OUTLINE) {
 791         FT_OutlineGlyph outline = (FT_OutlineGlyph)glyph;
 792         const FT_Outline *src = &outline->outline;
 793         FT_Bitmap ft_bitmap;
 794         FT_Outline copy;
 795
 796         ft_bitmap.width = width;
 797         ft_bitmap.rows = height;
 798         ft_bitmap.pitch = bitmap->pitch;
 799         ft_bitmap.pixel_mode = FT_PIXEL_MODE_GRAY;
 800         ft_bitmap.buffer = bitmap->buf;
 801
 802         /* Note: FreeType will only set 'black' bits for us. */
 803         if (pFT_Outline_New(library, src->n_points, src->n_contours, &copy) == 0) {
 804             pFT_Outline_Copy(src, &copy);
 805             pFT_Outline_Translate(&copy, -bbox->left << 6, bbox->bottom << 6);
 806             pFT_Outline_Get_Bitmap(library, &copy, &ft_bitmap);
 807             pFT_Outline_Done(library, &copy);
 808         }
 809     }
 810     else if (glyph->format == FT_GLYPH_FORMAT_BITMAP) {
 811         FT_Bitmap *ft_bitmap = &((FT_BitmapGlyph)glyph)->bitmap;
 812         BYTE *src = ft_bitmap->buffer, *dst = bitmap->buf;
 813         int w = min(bitmap->pitch, (ft_bitmap->width + 7) >> 3);
 814         int h = min(height, ft_bitmap->rows);
 815
 816         while (h--) {
 817             memcpy(dst, src, w);
 818             src += ft_bitmap->pitch;
 819             dst += bitmap->pitch;
 820         }
 821
 822         ret = TRUE;
 823     }
 824     else
 825         FIXME("format %x not handled\n", glyph->format);
 826
 827     return ret;
 828 }
 829
 830 BOOL freetype_get_glyph_bitmap(struct dwrite_glyphbitmap *bitmap)
 831 {
 832     FTC_ImageTypeRec imagetype;
 833     BOOL needs_transform;
 834     BOOL ret = FALSE;
 835     FT_Glyph glyph;
 836     FT_Matrix m;
 837
 838     EnterCriticalSection(&freetype_cs);
 839
 840     needs_transform = get_glyph_transform(bitmap, &m);
 841
 842     imagetype.face_id = bitmap->fontface;
 843     imagetype.width = 0;
 844     imagetype.height = bitmap->emsize;
 845     imagetype.flags = needs_transform ? FT_LOAD_NO_BITMAP : FT_LOAD_DEFAULT;
 846
 847     if (pFTC_ImageCache_Lookup(image_cache, &imagetype, bitmap->index, &glyph, NULL) == 0) {
 848         FT_Glyph glyph_copy;
 849
 850         if (needs_transform) {
 851             if (pFT_Glyph_Copy(glyph, &glyph_copy) == 0) {
 852                 if (bitmap->simulations & DWRITE_FONT_SIMULATIONS_BOLD)
 853                     embolden_glyph(glyph_copy, bitmap->emsize);
 854
 855                 /* Includes oblique and user transform. */
 856                 pFT_Glyph_Transform(glyph_copy, &m, NULL);
 857                 glyph = glyph_copy;
 858             }
 859         }
 860         else
 861             glyph_copy = NULL;
 862
 863         if (bitmap->aliased)
 864             ret = freetype_get_aliased_glyph_bitmap(bitmap, glyph);
 865         else
 866             ret = freetype_get_aa_glyph_bitmap(bitmap, glyph);
 867
 868         if (glyph_copy)
 869             pFT_Done_Glyph(glyph_copy);
 870     }
 871
 872     LeaveCriticalSection(&freetype_cs);
 873
 874     return ret;
 875 }
 876
 877 INT freetype_get_charmap_index(IDWriteFontFace4 *fontface, BOOL *is_symbol)
 878 {
 879     INT charmap_index = -1;
 880     FT_Face face;
 881
 882     *is_symbol = FALSE;
 883
 884     EnterCriticalSection(&freetype_cs);
 885     if (pFTC_Manager_LookupFace(cache_manager, fontface, &face) == 0) {
 886         TT_OS2 *os2 = pFT_Get_Sfnt_Table(face, ft_sfnt_os2);
 887         FT_Int i;
 888
 889         if (os2) {
 890             FT_UInt dummy;
 891             if (os2->version == 0)
 892                 *is_symbol = pFT_Get_First_Char(face, &dummy) >= 0x100;
 893             else
 894                 *is_symbol = !!(os2->ulCodePageRange1 & FS_SYMBOL);
 895         }
 896
 897         for (i = 0; i < face->num_charmaps; i++)
 898             if (face->charmaps[i]->encoding == FT_ENCODING_MS_SYMBOL) {
 899                 *is_symbol = TRUE;
 900                 charmap_index = i;
 901                 break;
 902             }
 903     }
 904     LeaveCriticalSection(&freetype_cs);
 905
 906     return charmap_index;
 907 }
 908
 909 INT32 freetype_get_glyph_advance(IDWriteFontFace4 *fontface, FLOAT emSize, UINT16 index, DWRITE_MEASURING_MODE mode,
 910     BOOL *has_contours)
 911 {
 912     FTC_ImageTypeRec imagetype;
 913     FT_Glyph glyph;
 914     INT32 advance;
 915
 916     imagetype.face_id = fontface;
 917     imagetype.width = 0;
 918     imagetype.height = emSize;
 919     imagetype.flags = FT_LOAD_DEFAULT;
 920     if (mode == DWRITE_MEASURING_MODE_NATURAL)
 921         imagetype.flags |= FT_LOAD_NO_HINTING;
 922
 923     EnterCriticalSection(&freetype_cs);
 924     if (pFTC_ImageCache_Lookup(image_cache, &imagetype, index, &glyph, NULL) == 0) {
 925         *has_contours = glyph->format == FT_GLYPH_FORMAT_OUTLINE && ((FT_OutlineGlyph)glyph)->outline.n_contours;
 926         advance = glyph->advance.x >> 16;
 927     }
 928     else {
 929         *has_contours = FALSE;
 930         advance = 0;
 931     }
 932     LeaveCriticalSection(&freetype_cs);
 933
 934     return advance;
 935 }
 936
 937 #else /* HAVE_FREETYPE */
 938
 939 BOOL init_freetype(void)
 940 {
 941     return FALSE;
 942 }
 943
 944 void release_freetype(void)
 945 {
 946 }
 947
 948 void freetype_notify_cacheremove(IDWriteFontFace4 *fontface)
 949 {
 950 }
 951
 952 HRESULT freetype_get_design_glyph_metrics(IDWriteFontFace4 *fontface, UINT16 unitsperEm, UINT16 glyph, DWRITE_GLYPH_METRICS *ret)
 953 {
 954     return E_NOTIMPL;
 955 }
 956
 957 BOOL freetype_is_monospaced(IDWriteFontFace4 *fontface)
 958 {
 959     return FALSE;
 960 }
 961
 962 HRESULT freetype_get_glyphrun_outline(IDWriteFontFace4 *fontface, FLOAT emSize, UINT16 const *glyphs, FLOAT const *advances,
 963     DWRITE_GLYPH_OFFSET const *offsets, UINT32 count, BOOL is_rtl, IDWriteGeometrySink *sink)
 964 {
 965     return E_NOTIMPL;
 966 }
 967
 968 UINT16 freetype_get_glyphcount(IDWriteFontFace4 *fontface)
 969 {
 970     return 0;
 971 }
 972
 973 void freetype_get_glyphs(IDWriteFontFace4 *fontface, INT charmap, UINT32 const *codepoints, UINT32 count,
 974     UINT16 *glyphs)
 975 {
 976     memset(glyphs, 0, count * sizeof(*glyphs));
 977 }
 978
 979 BOOL freetype_has_kerning_pairs(IDWriteFontFace4 *fontface)
 980 {
 981     return FALSE;
 982 }
 983
 984 INT32 freetype_get_kerning_pair_adjustment(IDWriteFontFace4 *fontface, UINT16 left, UINT16 right)
 985 {
 986     return 0;
 987 }
 988
 989 void freetype_get_glyph_bbox(struct dwrite_glyphbitmap *bitmap)
 990 {
 991     SetRectEmpty(&bitmap->bbox);
 992 }
 993
 994 void freetype_get_design_glyph_bbox(IDWriteFontFace4 *fontface, UINT16 unitsperEm, UINT16 glyph, RECT *bbox)
 995 {
 996     SetRectEmpty(bbox);
 997 }
 998
 999 BOOL freetype_get_glyph_bitmap(struct dwrite_glyphbitmap *bitmap)
1000 {
1001     return FALSE;
1002 }
1003
1004 INT freetype_get_charmap_index(IDWriteFontFace4 *fontface, BOOL *is_symbol)
1005 {
1006     *is_symbol = FALSE;
1007     return -1;
1008 }
1009
1010 INT32 freetype_get_glyph_advance(IDWriteFontFace4 *fontface, FLOAT emSize, UINT16 index, DWRITE_MEASURING_MODE mode,
1011     BOOL *has_contours)
1012 {
1013     *has_contours = FALSE;
1014     return 0;
1015 }
1016
1017 #endif /* HAVE_FREETYPE */