freetype.c 30.5 KB
Newer Older
1 2 3
/*
 *    FreeType integration
 *
4
 * Copyright 2014-2017 Nikolay Sivov for CodeWeavers
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */

21 22
#define COBJMACROS

23 24 25 26 27
#include "config.h"
#include "wine/port.h"

#ifdef HAVE_FT2BUILD_H
#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 33 34 35 36 37 38 39 40 41 42 43
#endif /* HAVE_FT2BUILD_H */

#include "windef.h"
#include "wine/library.h"
#include "wine/debug.h"

#include "dwrite_private.h"

WINE_DEFAULT_DEBUG_CHANNEL(dwrite);

#ifdef HAVE_FREETYPE

44 45 46 47 48 49 50 51 52
static CRITICAL_SECTION freetype_cs;
static CRITICAL_SECTION_DEBUG critsect_debug =
{
    0, 0, &freetype_cs,
    { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
      0, 0, { (DWORD_PTR)(__FILE__ ": freetype_cs") }
};
static CRITICAL_SECTION freetype_cs = { &critsect_debug, -1, 0, 0, 0, 0 };

53 54
static void *ft_handle = NULL;
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 59 60 61 62 63 64 65
typedef struct
{
    FT_Int major;
    FT_Int minor;
    FT_Int patch;
} FT_Version_t;

#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 75
MAKE_FUNCPTR(FT_Init_FreeType);
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 88
MAKE_FUNCPTR(FTC_CMapCache_Lookup);
MAKE_FUNCPTR(FTC_CMapCache_New);
89 90
MAKE_FUNCPTR(FTC_ImageCache_Lookup);
MAKE_FUNCPTR(FTC_ImageCache_New);
91 92
MAKE_FUNCPTR(FTC_Manager_New);
MAKE_FUNCPTR(FTC_Manager_Done);
93
MAKE_FUNCPTR(FTC_Manager_LookupFace);
94 95
MAKE_FUNCPTR(FTC_Manager_LookupSize);
MAKE_FUNCPTR(FTC_Manager_RemoveFaceID);
96
#undef MAKE_FUNCPTR
97
static FT_Error (*pFT_Outline_EmboldenXY)(FT_Outline *, FT_Pos, FT_Pos);
98

99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114
struct face_finalizer_data
{
    IDWriteFontFileStream *stream;
    void *context;
};

static void face_finalizer(void *object)
{
    FT_Face face = object;
    struct face_finalizer_data *data = (struct face_finalizer_data *)face->generic.data;

    IDWriteFontFileStream_ReleaseFileFragment(data->stream, data->context);
    IDWriteFontFileStream_Release(data->stream);
    heap_free(data);
}

115
static FT_Error face_requester(FTC_FaceID face_id, FT_Library library, FT_Pointer request_data, FT_Face *face)
116
{
117 118 119 120 121 122 123 124 125 126 127 128
    IDWriteFontFace *fontface = (IDWriteFontFace*)face_id;
    IDWriteFontFileStream *stream;
    IDWriteFontFile *file;
    const void *data_ptr;
    UINT32 index, count;
    FT_Error fterror;
    UINT64 data_size;
    void *context;
    HRESULT hr;

    *face = NULL;

129 130 131 132 133
    if (!fontface) {
        WARN("NULL fontface requested.\n");
        return FT_Err_Ok;
    }

134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157
    count = 1;
    hr = IDWriteFontFace_GetFiles(fontface, &count, &file);
    if (FAILED(hr))
        return FT_Err_Ok;

    hr = get_filestream_from_file(file, &stream);
    IDWriteFontFile_Release(file);
    if (FAILED(hr))
        return FT_Err_Ok;

    hr = IDWriteFontFileStream_GetFileSize(stream, &data_size);
    if (FAILED(hr)) {
        fterror = FT_Err_Invalid_Stream_Read;
        goto fail;
    }

    hr = IDWriteFontFileStream_ReadFileFragment(stream, &data_ptr, 0, data_size, &context);
    if (FAILED(hr)) {
        fterror = FT_Err_Invalid_Stream_Read;
        goto fail;
    }

    index = IDWriteFontFace_GetIndex(fontface);
    fterror = pFT_New_Memory_Face(library, data_ptr, data_size, index, face);
158 159 160 161 162 163 164 165 166 167 168 169 170
    if (fterror == FT_Err_Ok) {
        struct face_finalizer_data *data;

        data = heap_alloc(sizeof(*data));
        data->stream = stream;
        data->context = context;

        (*face)->generic.data = data;
        (*face)->generic.finalizer = face_finalizer;
        return fterror;
    }
    else
        IDWriteFontFileStream_ReleaseFileFragment(stream, context);
171 172 173 174 175 176

fail:
    IDWriteFontFileStream_Release(stream);

    return fterror;
}
177 178 179 180 181 182 183 184 185 186 187 188

BOOL init_freetype(void)
{
    FT_Version_t FT_Version;

    ft_handle = wine_dlopen(SONAME_LIBFREETYPE, RTLD_NOW, NULL, 0);
    if (!ft_handle) {
        WINE_MESSAGE("Wine cannot find the FreeType font library.\n");
	return FALSE;
    }

#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 198
    LOAD_FUNCPTR(FT_Init_FreeType)
    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 211
    LOAD_FUNCPTR(FTC_CMapCache_Lookup)
    LOAD_FUNCPTR(FTC_CMapCache_New)
212 213
    LOAD_FUNCPTR(FTC_ImageCache_Lookup)
    LOAD_FUNCPTR(FTC_ImageCache_New)
214 215
    LOAD_FUNCPTR(FTC_Manager_New)
    LOAD_FUNCPTR(FTC_Manager_Done)
216
    LOAD_FUNCPTR(FTC_Manager_LookupFace)
217 218
    LOAD_FUNCPTR(FTC_Manager_LookupSize)
    LOAD_FUNCPTR(FTC_Manager_RemoveFaceID)
219
#undef LOAD_FUNCPTR
220
    pFT_Outline_EmboldenXY = wine_dlsym(ft_handle, "FT_Outline_EmboldenXY", NULL, 0);
221 222 223 224 225 226 227 228 229

    if (pFT_Init_FreeType(&library) != 0) {
        ERR("Can't init FreeType library\n");
	wine_dlclose(ft_handle, NULL, 0);
        ft_handle = NULL;
	return FALSE;
    }
    pFT_Library_Version(library, &FT_Version.major, &FT_Version.minor, &FT_Version.patch);

230
    /* init cache manager */
231
    if (pFTC_Manager_New(library, 0, 0, 0, &face_requester, NULL, &cache_manager) != 0 ||
232 233
        pFTC_CMapCache_New(cache_manager, &cmap_cache) != 0 ||
        pFTC_ImageCache_New(cache_manager, &image_cache) != 0) {
234

235
        ERR("Failed to init FreeType cache\n");
236
        pFTC_Manager_Done(cache_manager);
237 238 239 240 241 242
        pFT_Done_FreeType(library);
        wine_dlclose(ft_handle, NULL, 0);
        ft_handle = NULL;
        return FALSE;
    }

243 244 245 246 247 248 249 250 251 252
    TRACE("FreeType version is %d.%d.%d\n", FT_Version.major, FT_Version.minor, FT_Version.patch);
    return TRUE;

sym_not_found:
    WINE_MESSAGE("Wine cannot find certain functions that it needs from FreeType library.\n");
    wine_dlclose(ft_handle, NULL, 0);
    ft_handle = NULL;
    return FALSE;
}

253
void release_freetype(void)
254
{
255 256 257
    pFTC_Manager_Done(cache_manager);
    pFT_Done_FreeType(library);
}
258

259
void freetype_notify_cacheremove(IDWriteFontFace4 *fontface)
260 261 262 263 264
{
    EnterCriticalSection(&freetype_cs);
    pFTC_Manager_RemoveFaceID(cache_manager, fontface);
    LeaveCriticalSection(&freetype_cs);
}
265

266
HRESULT freetype_get_design_glyph_metrics(IDWriteFontFace4 *fontface, UINT16 unitsperEm, UINT16 glyph, DWRITE_GLYPH_METRICS *ret)
267 268 269 270 271 272 273 274 275 276 277 278 279 280
{
    FTC_ScalerRec scaler;
    FT_Size size;

    scaler.face_id = fontface;
    scaler.width  = unitsperEm;
    scaler.height = unitsperEm;
    scaler.pixel = 1;
    scaler.x_res = 0;
    scaler.y_res = 0;

    EnterCriticalSection(&freetype_cs);
    if (pFTC_Manager_LookupSize(cache_manager, &scaler, &size) == 0) {
         if (pFT_Load_Glyph(size->face, glyph, FT_LOAD_NO_SCALE) == 0) {
281
             USHORT simulations = IDWriteFontFace4_GetSimulations(fontface);
282 283 284 285 286 287 288 289 290
             FT_Glyph_Metrics *metrics = &size->face->glyph->metrics;

             ret->leftSideBearing = metrics->horiBearingX;
             ret->advanceWidth = metrics->horiAdvance;
             ret->rightSideBearing = metrics->horiAdvance - metrics->horiBearingX - metrics->width;
             ret->topSideBearing = metrics->vertBearingY;
             ret->advanceHeight = metrics->vertAdvance;
             ret->bottomSideBearing = metrics->vertAdvance - metrics->vertBearingY - metrics->height;
             ret->verticalOriginY = metrics->height + metrics->vertBearingY;
291 292 293 294 295 296 297

             /* Adjust in case of bold simulation, glyphs without contours are ignored. */
             if (simulations & DWRITE_FONT_SIMULATIONS_BOLD && size->face->glyph->format == FT_GLYPH_FORMAT_OUTLINE &&
                     size->face->glyph->outline.n_contours != 0) {
                 if (ret->advanceWidth)
                     ret->advanceWidth += (unitsperEm + 49) / 50;
             }
298
         }
299
    }
300
    LeaveCriticalSection(&freetype_cs);
301 302 303 304

    return S_OK;
}

305
BOOL freetype_is_monospaced(IDWriteFontFace4 *fontface)
306 307 308 309 310 311
{
    BOOL is_monospaced = FALSE;
    FT_Face face;

    EnterCriticalSection(&freetype_cs);
    if (pFTC_Manager_LookupFace(cache_manager, fontface, &face) == 0)
312
        is_monospaced = !!FT_IS_FIXED_WIDTH(face);
313 314 315 316 317
    LeaveCriticalSection(&freetype_cs);

    return is_monospaced;
}

318 319 320 321 322 323 324 325 326 327 328
struct decompose_context {
    IDWriteGeometrySink *sink;
    FLOAT xoffset;
    FLOAT yoffset;
    BOOL figure_started;
    BOOL figure_closed;
    BOOL move_to;     /* last call was 'move_to' */
    FT_Vector origin; /* 'pen' position from last call */
};

static inline void ft_vector_to_d2d_point(const FT_Vector *v, FLOAT xoffset, FLOAT yoffset, D2D1_POINT_2F *p)
329
{
330 331
    p->x = (v->x / 64.0f) + xoffset;
    p->y = (v->y / 64.0f) + yoffset;
332 333
}

334
static int decompose_move_to(const FT_Vector *to, void *user)
335
{
336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380
    struct decompose_context *ctxt = (struct decompose_context*)user;
    D2D1_POINT_2F point;

    if (ctxt->figure_started) {
        ID2D1SimplifiedGeometrySink_EndFigure(ctxt->sink, D2D1_FIGURE_END_CLOSED);
        ctxt->figure_closed = TRUE;
    }
    else
        ctxt->figure_closed = FALSE;
    ctxt->figure_started = TRUE;

    ft_vector_to_d2d_point(to, ctxt->xoffset, ctxt->yoffset, &point);
    ID2D1SimplifiedGeometrySink_BeginFigure(ctxt->sink, point, D2D1_FIGURE_BEGIN_FILLED);
    ctxt->move_to = TRUE;
    ctxt->origin = *to;
    return 0;
}

static int decompose_line_to(const FT_Vector *to, void *user)
{
    struct decompose_context *ctxt = (struct decompose_context*)user;
    /* special case for empty contours, in a way freetype returns them */
    if (ctxt->move_to && !memcmp(to, &ctxt->origin, sizeof(*to))) {
        ID2D1SimplifiedGeometrySink_EndFigure(ctxt->sink, D2D1_FIGURE_END_CLOSED);
        ctxt->figure_closed = TRUE;
    }
    else {
        D2D1_POINT_2F point;
        ft_vector_to_d2d_point(to, ctxt->xoffset, ctxt->yoffset, &point);
        ID2D1SimplifiedGeometrySink_AddLines(ctxt->sink, &point, 1);
        ctxt->figure_closed = FALSE;
    }
    ctxt->move_to = FALSE;
    ctxt->origin = *to;
    return 0;
}

static int decompose_conic_to(const FT_Vector *control, const FT_Vector *to, void *user)
{
    struct decompose_context *ctxt = (struct decompose_context*)user;
    D2D1_POINT_2F points[3];
    FT_Vector cubic[3];

    /* convert from quadratic to cubic */

381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399
    /*
       The parametric eqn for a cubic Bezier is, from PLRM:
       r(t) = at^3 + bt^2 + ct + r0
       with the control points:
       r1 = r0 + c/3
       r2 = r1 + (c + b)/3
       r3 = r0 + c + b + a

       A quadratic Bezier has the form:
       p(t) = (1-t)^2 p0 + 2(1-t)t p1 + t^2 p2

       So equating powers of t leads to:
       r1 = 2/3 p1 + 1/3 p0
       r2 = 2/3 p1 + 1/3 p2
       and of course r0 = p0, r3 = p2
    */

    /* r1 = 1/3 p0 + 2/3 p1
       r2 = 1/3 p2 + 2/3 p1 */
400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417
    cubic[0].x = (2 * control->x + 1) / 3;
    cubic[0].y = (2 * control->y + 1) / 3;
    cubic[1] = cubic[0];
    cubic[0].x += (ctxt->origin.x + 1) / 3;
    cubic[0].y += (ctxt->origin.y + 1) / 3;
    cubic[1].x += (to->x + 1) / 3;
    cubic[1].y += (to->y + 1) / 3;
    cubic[2] = *to;

    ft_vector_to_d2d_point(cubic, ctxt->xoffset, ctxt->yoffset, points);
    ft_vector_to_d2d_point(cubic + 1, ctxt->xoffset, ctxt->yoffset, points + 1);
    ft_vector_to_d2d_point(cubic + 2, ctxt->xoffset, ctxt->yoffset, points + 2);
    ID2D1SimplifiedGeometrySink_AddBeziers(ctxt->sink, (D2D1_BEZIER_SEGMENT*)points, 1);
    ctxt->figure_closed = FALSE;
    ctxt->move_to = FALSE;
    ctxt->origin = *to;
    return 0;
}
418

419 420 421 422 423
static int decompose_cubic_to(const FT_Vector *control1, const FT_Vector *control2,
    const FT_Vector *to, void *user)
{
    struct decompose_context *ctxt = (struct decompose_context*)user;
    D2D1_POINT_2F points[3];
424

425 426 427 428 429 430 431 432 433
    ft_vector_to_d2d_point(control1, ctxt->xoffset, ctxt->yoffset, points);
    ft_vector_to_d2d_point(control2, ctxt->xoffset, ctxt->yoffset, points + 1);
    ft_vector_to_d2d_point(to, ctxt->xoffset, ctxt->yoffset, points + 2);
    ID2D1SimplifiedGeometrySink_AddBeziers(ctxt->sink, (D2D1_BEZIER_SEGMENT*)points, 1);
    ctxt->figure_closed = FALSE;
    ctxt->move_to = FALSE;
    ctxt->origin = *to;
    return 0;
}
434

435 436 437 438 439 440 441 442 443 444 445
static void decompose_outline(FT_Outline *outline, FLOAT xoffset, FLOAT yoffset, IDWriteGeometrySink *sink)
{
    static const FT_Outline_Funcs decompose_funcs = {
        decompose_move_to,
        decompose_line_to,
        decompose_conic_to,
        decompose_cubic_to,
        0,
        0
    };
    struct decompose_context context;
446

447 448 449 450 451 452 453 454
    context.sink = sink;
    context.xoffset = xoffset;
    context.yoffset = yoffset;
    context.figure_started = FALSE;
    context.figure_closed = FALSE;
    context.move_to = FALSE;
    context.origin.x = 0;
    context.origin.y = 0;
455

456 457 458 459
    pFT_Outline_Decompose(outline, &decompose_funcs, &context);

    if (!context.figure_closed && outline->n_points)
        ID2D1SimplifiedGeometrySink_EndFigure(sink, D2D1_FIGURE_END_CLOSED);
460 461
}

462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484
static void embolden_glyph_outline(FT_Outline *outline, FLOAT emsize)
{
    FT_Pos strength;

    strength = MulDiv(emsize, 1 << 6, 24);
    if (pFT_Outline_EmboldenXY)
        pFT_Outline_EmboldenXY(outline, strength, 0);
    else
        pFT_Outline_Embolden(outline, strength);
}

static void embolden_glyph(FT_Glyph glyph, FLOAT emsize)
{
    FT_OutlineGlyph outline_glyph = (FT_OutlineGlyph)glyph;

    if (glyph->format != FT_GLYPH_FORMAT_OUTLINE)
        return;

    embolden_glyph_outline(&outline_glyph->outline, emsize);
}

HRESULT freetype_get_glyphrun_outline(IDWriteFontFace4 *fontface, FLOAT emSize, UINT16 const *glyphs,
    FLOAT const *advances, DWRITE_GLYPH_OFFSET const *offsets, UINT32 count, BOOL is_rtl, IDWriteGeometrySink *sink)
485 486
{
    FTC_ScalerRec scaler;
487
    USHORT simulations;
488 489 490
    HRESULT hr = S_OK;
    FT_Size size;

491 492 493 494 495
    if (!count)
        return S_OK;

    ID2D1SimplifiedGeometrySink_SetFillMode(sink, D2D1_FILL_MODE_WINDING);

496
    simulations = IDWriteFontFace4_GetSimulations(fontface);
497

498 499 500 501 502 503 504 505 506
    scaler.face_id = fontface;
    scaler.width  = emSize;
    scaler.height = emSize;
    scaler.pixel = 1;
    scaler.x_res = 0;
    scaler.y_res = 0;

    EnterCriticalSection(&freetype_cs);
    if (pFTC_Manager_LookupSize(cache_manager, &scaler, &size) == 0) {
507 508 509 510 511 512 513 514 515 516
        FLOAT advance = 0.0f;
        UINT32 g;

        for (g = 0; g < count; g++) {
            if (pFT_Load_Glyph(size->face, glyphs[g], FT_LOAD_NO_BITMAP) == 0) {
                FLOAT ft_advance = size->face->glyph->metrics.horiAdvance >> 6;
                FT_Outline *outline = &size->face->glyph->outline;
                FLOAT xoffset = 0.0f, yoffset = 0.0f;
                FT_Matrix m;

517 518 519
                if (simulations & DWRITE_FONT_SIMULATIONS_BOLD)
                    embolden_glyph_outline(outline, emSize);

520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545
                m.xx = 1 << 16;
                m.xy = simulations & DWRITE_FONT_SIMULATIONS_OBLIQUE ? (1 << 16) / 3 : 0;
                m.yx = 0;
                m.yy = -(1 << 16); /* flip Y axis */

                pFT_Outline_Transform(outline, &m);

                /* glyph offsets act as current glyph adjustment */
                if (offsets) {
                    xoffset += is_rtl ? -offsets[g].advanceOffset : offsets[g].advanceOffset;
                    yoffset -= offsets[g].ascenderOffset;
                }

                if (g == 0 && is_rtl)
                    advance = advances ? -advances[g] : -ft_advance;

                xoffset += advance;
                decompose_outline(outline, xoffset, yoffset, sink);

                /* update advance to next glyph */
                if (advances)
                    advance += is_rtl ? -advances[g] : advances[g];
                else
                    advance += is_rtl ? -ft_advance : ft_advance;
            }
        }
546
    }
547 548
    else
        hr = E_FAIL;
549 550 551 552 553
    LeaveCriticalSection(&freetype_cs);

    return hr;
}

554
UINT16 freetype_get_glyphcount(IDWriteFontFace4 *fontface)
555 556 557 558 559 560 561 562 563 564 565 566
{
    UINT16 count = 0;
    FT_Face face;

    EnterCriticalSection(&freetype_cs);
    if (pFTC_Manager_LookupFace(cache_manager, fontface, &face) == 0)
        count = face->num_glyphs;
    LeaveCriticalSection(&freetype_cs);

    return count;
}

567
void freetype_get_glyphs(IDWriteFontFace4 *fontface, INT charmap, UINT32 const *codepoints, UINT32 count,
568
    UINT16 *glyphs)
569
{
570
    UINT32 i;
571 572

    EnterCriticalSection(&freetype_cs);
573 574 575 576 577 578 579 580 581 582 583
    for (i = 0; i < count; i++) {
        if (charmap == -1)
            glyphs[i] = pFTC_CMapCache_Lookup(cmap_cache, fontface, charmap, codepoints[i]);
        else {
            UINT32 codepoint = codepoints[i];
            /* special handling for symbol fonts */
            if (codepoint < 0x100) codepoint += 0xf000;
            glyphs[i] = pFTC_CMapCache_Lookup(cmap_cache, fontface, charmap, codepoint);
            if (!glyphs[i])
                glyphs[i] = pFTC_CMapCache_Lookup(cmap_cache, fontface, charmap, codepoint - 0xf000);
        }
584
    }
585 586 587
    LeaveCriticalSection(&freetype_cs);
}

588
BOOL freetype_has_kerning_pairs(IDWriteFontFace4 *fontface)
589 590 591 592 593 594
{
    BOOL has_kerning_pairs = FALSE;
    FT_Face face;

    EnterCriticalSection(&freetype_cs);
    if (pFTC_Manager_LookupFace(cache_manager, fontface, &face) == 0)
595
        has_kerning_pairs = !!FT_HAS_KERNING(face);
596 597 598 599 600
    LeaveCriticalSection(&freetype_cs);

    return has_kerning_pairs;
}

601
INT32 freetype_get_kerning_pair_adjustment(IDWriteFontFace4 *fontface, UINT16 left, UINT16 right)
602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618
{
    INT32 adjustment = 0;
    FT_Face face;

    EnterCriticalSection(&freetype_cs);
    if (pFTC_Manager_LookupFace(cache_manager, fontface, &face) == 0) {
        FT_Vector kern;
        if (FT_HAS_KERNING(face)) {
            pFT_Get_Kerning(face, left, right, FT_KERNING_UNSCALED, &kern);
            adjustment = kern.x;
        }
    }
    LeaveCriticalSection(&freetype_cs);

    return adjustment;
}

619 620 621 622 623 624 625 626 627
static inline void ft_matrix_from_dwrite_matrix(const DWRITE_MATRIX *m, FT_Matrix *ft_matrix)
{
    ft_matrix->xx =  m->m11 * 0x10000;
    ft_matrix->xy = -m->m21 * 0x10000;
    ft_matrix->yx = -m->m12 * 0x10000;
    ft_matrix->yy =  m->m22 * 0x10000;
}

/* Should be used only while holding 'freetype_cs' */
628
static BOOL is_face_scalable(IDWriteFontFace4 *fontface)
629 630 631 632 633 634 635 636
{
    FT_Face face;
    if (pFTC_Manager_LookupFace(cache_manager, fontface, &face) == 0)
        return FT_IS_SCALABLE(face);
    else
        return FALSE;
}

637 638 639 640 641 642 643 644 645 646 647 648
static BOOL get_glyph_transform(struct dwrite_glyphbitmap *bitmap, FT_Matrix *ret)
{
    USHORT simulations = IDWriteFontFace4_GetSimulations(bitmap->fontface);
    FT_Matrix m;

    ret->xx = 1 << 16;
    ret->xy = 0;
    ret->yx = 0;
    ret->yy = 1 << 16;

    /* Some fonts provide mostly bitmaps and very few outlines, for example for .notdef.
       Disable transform if that's the case. */
649
    if (!is_face_scalable(bitmap->fontface) || (!bitmap->m && simulations == 0))
650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667
        return FALSE;

    if (simulations & DWRITE_FONT_SIMULATIONS_OBLIQUE) {
        m.xx =  1 << 16;
        m.xy = (1 << 16) / 3;
        m.yx =  0;
        m.yy =  1 << 16;
        pFT_Matrix_Multiply(&m, ret);
    }

    if (bitmap->m) {
        ft_matrix_from_dwrite_matrix(bitmap->m, &m);
        pFT_Matrix_Multiply(&m, ret);
    }

    return TRUE;
}

668
void freetype_get_glyph_bbox(struct dwrite_glyphbitmap *bitmap)
669
{
670
    USHORT simulations = IDWriteFontFace4_GetSimulations(bitmap->fontface);
671 672
    FTC_ImageTypeRec imagetype;
    FT_BBox bbox = { 0 };
673
    BOOL needs_transform;
674
    FT_Glyph glyph;
675
    FT_Matrix m;
676

677 678
    EnterCriticalSection(&freetype_cs);

679
    needs_transform = get_glyph_transform(bitmap, &m);
680

681
    imagetype.face_id = bitmap->fontface;
682
    imagetype.width = 0;
683
    imagetype.height = bitmap->emsize;
684
    imagetype.flags = needs_transform ? FT_LOAD_NO_BITMAP : FT_LOAD_DEFAULT;
685 686

    if (pFTC_ImageCache_Lookup(image_cache, &imagetype, bitmap->index, &glyph, NULL) == 0) {
687
        if (needs_transform) {
688 689 690
            FT_Glyph glyph_copy;

            if (pFT_Glyph_Copy(glyph, &glyph_copy) == 0) {
691 692 693
                if (simulations & DWRITE_FONT_SIMULATIONS_BOLD)
                    embolden_glyph(glyph_copy, bitmap->emsize);

694 695
                /* Includes oblique and user transform. */
                pFT_Glyph_Transform(glyph_copy, &m, NULL);
696 697 698 699 700 701 702
                pFT_Glyph_Get_CBox(glyph_copy, FT_GLYPH_BBOX_PIXELS, &bbox);
                pFT_Done_Glyph(glyph_copy);
            }
        }
        else
            pFT_Glyph_Get_CBox(glyph, FT_GLYPH_BBOX_PIXELS, &bbox);
    }
703 704 705 706

    LeaveCriticalSection(&freetype_cs);

    /* flip Y axis */
707
    SetRect(&bitmap->bbox, bbox.xMin, -bbox.yMax, bbox.xMax, -bbox.yMin);
708 709
}

710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735
void freetype_get_design_glyph_bbox(IDWriteFontFace4 *fontface, UINT16 unitsperEm, UINT16 glyph, RECT *bbox)
{
    FTC_ScalerRec scaler;
    FT_Size size;

    scaler.face_id = fontface;
    scaler.width  = unitsperEm;
    scaler.height = unitsperEm;
    scaler.pixel = 1;
    scaler.x_res = 0;
    scaler.y_res = 0;

    EnterCriticalSection(&freetype_cs);
    if (pFTC_Manager_LookupSize(cache_manager, &scaler, &size) == 0) {
         if (pFT_Load_Glyph(size->face, glyph, FT_LOAD_NO_SCALE) == 0) {
             FT_Glyph_Metrics *metrics = &size->face->glyph->metrics;

             bbox->left = metrics->horiBearingX;
             bbox->right = bbox->left + metrics->horiAdvance;
             bbox->top = -metrics->horiBearingY;
             bbox->bottom = bbox->top + metrics->height;
         }
    }
    LeaveCriticalSection(&freetype_cs);
}

736
static BOOL freetype_get_aliased_glyph_bitmap(struct dwrite_glyphbitmap *bitmap, FT_Glyph glyph)
737
{
738
    const RECT *bbox = &bitmap->bbox;
739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828
    int width = bbox->right - bbox->left;
    int height = bbox->bottom - bbox->top;

    if (glyph->format == FT_GLYPH_FORMAT_OUTLINE) {
        FT_OutlineGlyph outline = (FT_OutlineGlyph)glyph;
        const FT_Outline *src = &outline->outline;
        FT_Bitmap ft_bitmap;
        FT_Outline copy;

        ft_bitmap.width = width;
        ft_bitmap.rows = height;
        ft_bitmap.pitch = bitmap->pitch;
        ft_bitmap.pixel_mode = FT_PIXEL_MODE_MONO;
        ft_bitmap.buffer = bitmap->buf;

        /* Note: FreeType will only set 'black' bits for us. */
        if (pFT_Outline_New(library, src->n_points, src->n_contours, &copy) == 0) {
            pFT_Outline_Copy(src, &copy);
            pFT_Outline_Translate(&copy, -bbox->left << 6, bbox->bottom << 6);
            pFT_Outline_Get_Bitmap(library, &copy, &ft_bitmap);
            pFT_Outline_Done(library, &copy);
        }
    }
    else if (glyph->format == FT_GLYPH_FORMAT_BITMAP) {
        FT_Bitmap *ft_bitmap = &((FT_BitmapGlyph)glyph)->bitmap;
        BYTE *src = ft_bitmap->buffer, *dst = bitmap->buf;
        int w = min(bitmap->pitch, (ft_bitmap->width + 7) >> 3);
        int h = min(height, ft_bitmap->rows);

        while (h--) {
            memcpy(dst, src, w);
            src += ft_bitmap->pitch;
            dst += bitmap->pitch;
        }
    }
    else
        FIXME("format %x not handled\n", glyph->format);

    return TRUE;
}

static BOOL freetype_get_aa_glyph_bitmap(struct dwrite_glyphbitmap *bitmap, FT_Glyph glyph)
{
    const RECT *bbox = &bitmap->bbox;
    int width = bbox->right - bbox->left;
    int height = bbox->bottom - bbox->top;
    BOOL ret = FALSE;

    if (glyph->format == FT_GLYPH_FORMAT_OUTLINE) {
        FT_OutlineGlyph outline = (FT_OutlineGlyph)glyph;
        const FT_Outline *src = &outline->outline;
        FT_Bitmap ft_bitmap;
        FT_Outline copy;

        ft_bitmap.width = width;
        ft_bitmap.rows = height;
        ft_bitmap.pitch = bitmap->pitch;
        ft_bitmap.pixel_mode = FT_PIXEL_MODE_GRAY;
        ft_bitmap.buffer = bitmap->buf;

        /* Note: FreeType will only set 'black' bits for us. */
        if (pFT_Outline_New(library, src->n_points, src->n_contours, &copy) == 0) {
            pFT_Outline_Copy(src, &copy);
            pFT_Outline_Translate(&copy, -bbox->left << 6, bbox->bottom << 6);
            pFT_Outline_Get_Bitmap(library, &copy, &ft_bitmap);
            pFT_Outline_Done(library, &copy);
        }
    }
    else if (glyph->format == FT_GLYPH_FORMAT_BITMAP) {
        FT_Bitmap *ft_bitmap = &((FT_BitmapGlyph)glyph)->bitmap;
        BYTE *src = ft_bitmap->buffer, *dst = bitmap->buf;
        int w = min(bitmap->pitch, (ft_bitmap->width + 7) >> 3);
        int h = min(height, ft_bitmap->rows);

        while (h--) {
            memcpy(dst, src, w);
            src += ft_bitmap->pitch;
            dst += bitmap->pitch;
        }

        ret = TRUE;
    }
    else
        FIXME("format %x not handled\n", glyph->format);

    return ret;
}

BOOL freetype_get_glyph_bitmap(struct dwrite_glyphbitmap *bitmap)
{
829
    USHORT simulations = IDWriteFontFace4_GetSimulations(bitmap->fontface);
830
    FTC_ImageTypeRec imagetype;
831
    BOOL needs_transform;
832
    BOOL ret = FALSE;
833
    FT_Glyph glyph;
834
    FT_Matrix m;
835

836 837
    EnterCriticalSection(&freetype_cs);

838
    needs_transform = get_glyph_transform(bitmap, &m);
839

840
    imagetype.face_id = bitmap->fontface;
841
    imagetype.width = 0;
842
    imagetype.height = bitmap->emsize;
843
    imagetype.flags = needs_transform ? FT_LOAD_NO_BITMAP : FT_LOAD_DEFAULT;
844

845
    if (pFTC_ImageCache_Lookup(image_cache, &imagetype, bitmap->index, &glyph, NULL) == 0) {
846 847
        FT_Glyph glyph_copy;

848
        if (needs_transform) {
849
            if (pFT_Glyph_Copy(glyph, &glyph_copy) == 0) {
850 851 852
                if (simulations & DWRITE_FONT_SIMULATIONS_BOLD)
                    embolden_glyph(glyph_copy, bitmap->emsize);

853 854
                /* Includes oblique and user transform. */
                pFT_Glyph_Transform(glyph_copy, &m, NULL);
855 856 857 858 859 860
                glyph = glyph_copy;
            }
        }
        else
            glyph_copy = NULL;

861 862
        if (bitmap->type == DWRITE_TEXTURE_CLEARTYPE_3x1)
            ret = freetype_get_aa_glyph_bitmap(bitmap, glyph);
863
        else
864
            ret = freetype_get_aliased_glyph_bitmap(bitmap, glyph);
865 866 867

        if (glyph_copy)
            pFT_Done_Glyph(glyph_copy);
868
    }
869

870
    LeaveCriticalSection(&freetype_cs);
871 872

    return ret;
873 874
}

875
INT freetype_get_charmap_index(IDWriteFontFace4 *fontface, BOOL *is_symbol)
876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891
{
    INT charmap_index = -1;
    FT_Face face;

    *is_symbol = FALSE;

    EnterCriticalSection(&freetype_cs);
    if (pFTC_Manager_LookupFace(cache_manager, fontface, &face) == 0) {
        TT_OS2 *os2 = pFT_Get_Sfnt_Table(face, ft_sfnt_os2);
        FT_Int i;

        if (os2) {
            FT_UInt dummy;
            if (os2->version == 0)
                *is_symbol = pFT_Get_First_Char(face, &dummy) >= 0x100;
            else
892
                *is_symbol = !!(os2->ulCodePageRange1 & FS_SYMBOL);
893 894 895 896 897 898 899 900 901 902 903 904 905 906
        }

        for (i = 0; i < face->num_charmaps; i++)
            if (face->charmaps[i]->encoding == FT_ENCODING_MS_SYMBOL) {
                *is_symbol = TRUE;
                charmap_index = i;
                break;
            }
    }
    LeaveCriticalSection(&freetype_cs);

    return charmap_index;
}

907 908
INT32 freetype_get_glyph_advance(IDWriteFontFace4 *fontface, FLOAT emSize, UINT16 index, DWRITE_MEASURING_MODE mode,
    BOOL *has_contours)
909 910 911 912 913 914 915 916 917 918 919 920 921
{
    FTC_ImageTypeRec imagetype;
    FT_Glyph glyph;
    INT32 advance;

    imagetype.face_id = fontface;
    imagetype.width = 0;
    imagetype.height = emSize;
    imagetype.flags = FT_LOAD_DEFAULT;
    if (mode == DWRITE_MEASURING_MODE_NATURAL)
        imagetype.flags |= FT_LOAD_NO_HINTING;

    EnterCriticalSection(&freetype_cs);
922 923
    if (pFTC_ImageCache_Lookup(image_cache, &imagetype, index, &glyph, NULL) == 0) {
        *has_contours = glyph->format == FT_GLYPH_FORMAT_OUTLINE && ((FT_OutlineGlyph)glyph)->outline.n_contours;
924
        advance = glyph->advance.x >> 16;
925 926 927
    }
    else {
        *has_contours = FALSE;
928
        advance = 0;
929
    }
930 931 932 933 934
    LeaveCriticalSection(&freetype_cs);

    return advance;
}

935 936 937 938 939 940 941
#else /* HAVE_FREETYPE */

BOOL init_freetype(void)
{
    return FALSE;
}

942 943 944 945
void release_freetype(void)
{
}

946
void freetype_notify_cacheremove(IDWriteFontFace4 *fontface)
947 948 949
{
}

950
HRESULT freetype_get_design_glyph_metrics(IDWriteFontFace4 *fontface, UINT16 unitsperEm, UINT16 glyph, DWRITE_GLYPH_METRICS *ret)
951
{
952
    return E_NOTIMPL;
953 954
}

955
BOOL freetype_is_monospaced(IDWriteFontFace4 *fontface)
956 957 958 959
{
    return FALSE;
}

960
HRESULT freetype_get_glyphrun_outline(IDWriteFontFace4 *fontface, FLOAT emSize, UINT16 const *glyphs, FLOAT const *advances,
961
    DWRITE_GLYPH_OFFSET const *offsets, UINT32 count, BOOL is_rtl, IDWriteGeometrySink *sink)
962 963 964 965
{
    return E_NOTIMPL;
}

966
UINT16 freetype_get_glyphcount(IDWriteFontFace4 *fontface)
967 968 969 970
{
    return 0;
}

971
void freetype_get_glyphs(IDWriteFontFace4 *fontface, INT charmap, UINT32 const *codepoints, UINT32 count,
972
    UINT16 *glyphs)
973
{
974
    memset(glyphs, 0, count * sizeof(*glyphs));
975 976
}

977
BOOL freetype_has_kerning_pairs(IDWriteFontFace4 *fontface)
978 979 980 981
{
    return FALSE;
}

982
INT32 freetype_get_kerning_pair_adjustment(IDWriteFontFace4 *fontface, UINT16 left, UINT16 right)
983 984 985 986
{
    return 0;
}

987
void freetype_get_glyph_bbox(struct dwrite_glyphbitmap *bitmap)
988
{
989
    memset(&bitmap->bbox, 0, sizeof(bitmap->bbox));
990 991
}

992 993 994 995 996
void freetype_get_design_glyph_bbox(IDWriteFontFace4 *fontface, UINT16 unitsperEm, UINT16 glyph, RECT *bbox)
{
    memset(bbox, 0, sizeof(*bbox));
}

997
BOOL freetype_get_glyph_bitmap(struct dwrite_glyphbitmap *bitmap)
998
{
999
    return FALSE;
1000 1001
}

1002
INT freetype_get_charmap_index(IDWriteFontFace4 *fontface, BOOL *is_symbol)
1003 1004 1005 1006 1007
{
    *is_symbol = FALSE;
    return -1;
}

1008 1009
INT32 freetype_get_glyph_advance(IDWriteFontFace4 *fontface, FLOAT emSize, UINT16 index, DWRITE_MEASURING_MODE mode,
    BOOL *has_contours)
1010
{
1011
    *has_contours = FALSE;
1012 1013 1014
    return 0;
}

1015
#endif /* HAVE_FREETYPE */