directwrite: convert to C

Unfortunately, nobody ever tested the MinGW dwrite.h header in C. There
are multiple glaring mistakes, and the header doesn't even compile by
itself. The main issues are overloaded functions (which doesn't work
in C), and broken COBJMACROS defines.

dwrite.diff contains changes to dwrite.h which make libass work.
Warning: the patch lacks a required change to the DrawInlineObject
method of IDWriteTextRenderer (missing THIS_).

Additionally, these definitions would ideally be provided by dwrite.h:

DEFINE_GUID(IID_IDWriteFactory, 0xb859ee5a,0xd838,0x4b5b,0xa2,0xe8,0x1a,0xdc,0x7d,0x93,0xdb,0x48);
DEFINE_GUID(IID_IDWritePixelSnapping, 0xeaf3a2da,0xecf4,0x4d24,0xb6,0x44,0xb3,0x4f,0x68,0x42,0x02,0x4b);
DEFINE_GUID(IID_IDWriteTextRenderer, 0xef8a8135,0x5cc6,0x45fe,0x88,0x25,0xc5,0xa0,0x72,0x4e,0xb8,0x19);

Also, in order to make libass compile out of the box with current
MinGW/msys installations, a very stripped down in-tree copy of dwrite.h
is provided.

1 files changed, 706 insertions, 0 deletions

diff --git a/libass/ass_directwrite.c b/libass/ass_directwrite.c
new file mode 100644
index 0000000..483af50
--- /dev/null
+++ b/libass/ass_directwrite.c
@@ -0,0 +1,706 @@
+/*
+ * Copyright (C) 2015 Stephan Vedder <stephan.vedder@gmail.com>
+ *
+ * This file is part of libass.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+#define COBJMACROS
+
+#include "config.h"
+
+#include <initguid.h>
+#include <ole2.h>
+#include <shobjidl.h>
+
+#include "dwrite.h"
+
+DEFINE_GUID(IID_IDWriteFactory, 0xb859ee5a,0xd838,0x4b5b,0xa2,0xe8,0x1a,0xdc,0x7d,0x93,0xdb,0x48);
+DEFINE_GUID(IID_IDWritePixelSnapping, 0xeaf3a2da,0xecf4,0x4d24,0xb6,0x44,0xb3,0x4f,0x68,0x42,0x02,0x4b);
+DEFINE_GUID(IID_IDWriteTextRenderer, 0xef8a8135,0x5cc6,0x45fe,0x88,0x25,0xc5,0xa0,0x72,0x4e,0xb8,0x19);
+
+#include "ass_directwrite.h"
+#include "ass_utils.h"
+
+#define NAME_MAX_LENGTH 256
+#define FALLBACK_DEFAULT_FONT L"Arial"
+
+/*
+ * The private data stored for every font, detected by this backend.
+ */
+typedef struct {
+    IDWriteFont *font;
+    IDWriteFontFileStream *stream;
+} FontPrivate;
+
+typedef struct {
+    HMODULE directwrite_lib;
+    IDWriteFactory *factory;
+} ProviderPrivate;
+
+/**
+ * Custom text renderer class for logging the fonts used. It does not
+ * actually render anything or do anything apart from that.
+ */
+
+typedef struct FallbackLogTextRenderer {
+    IDWriteTextRenderer iface;
+    IDWriteTextRendererVtbl vtbl;
+    IDWriteFactory *dw_factory;
+    LONG ref_count;
+} FallbackLogTextRenderer;
+
+static HRESULT STDMETHODCALLTYPE FallbackLogTextRenderer_IsPixelSnappingDisabled(
+    IDWriteTextRenderer *This,
+    _In_opt_ void* clientDrawingContext,
+    _Out_ BOOL* isDisabled
+    )
+{
+    *isDisabled = true;
+    return S_OK;
+}
+
+static HRESULT STDMETHODCALLTYPE FallbackLogTextRenderer_GetCurrentTransform(
+    IDWriteTextRenderer *This,
+    _In_opt_ void* clientDrawingContext,
+    _Out_ DWRITE_MATRIX* transform
+    )
+{
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE FallbackLogTextRenderer_GetPixelsPerDip(
+    IDWriteTextRenderer *This,
+    _In_opt_ void* clientDrawingContext,
+    _Out_ FLOAT* pixelsPerDip
+    )
+{
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE FallbackLogTextRenderer_DrawGlyphRun(
+    IDWriteTextRenderer *This,
+    _In_opt_ void* clientDrawingContext,
+    FLOAT baselineOriginX,
+    FLOAT baselineOriginY,
+    DWRITE_MEASURING_MODE measuringMode,
+    _In_ DWRITE_GLYPH_RUN const* glyphRun,
+    _In_ DWRITE_GLYPH_RUN_DESCRIPTION const* glyphRunDescription,
+    IUnknown* clientDrawingEffect
+    )
+{
+    FallbackLogTextRenderer *this = (FallbackLogTextRenderer *)This;
+    HRESULT hr;
+    IDWriteFontCollection *font_coll = NULL;
+    IDWriteFont **font = (IDWriteFont **)clientDrawingContext;
+
+    hr = IDWriteFactory_GetSystemFontCollection(this->dw_factory, &font_coll, FALSE);
+    if (FAILED(hr))
+        return E_FAIL;
+
+    hr = IDWriteFontCollection_GetFontFromFontFace(font_coll, glyphRun->fontFace,
+                                                   font);
+    if (FAILED(hr))
+        return E_FAIL;
+
+    return S_OK;
+}
+
+static HRESULT STDMETHODCALLTYPE FallbackLogTextRenderer_DrawUnderline(
+    IDWriteTextRenderer *This,
+    _In_opt_ void* clientDrawingContext,
+    FLOAT baselineOriginX,
+    FLOAT baselineOriginY,
+    _In_ DWRITE_UNDERLINE const* underline,
+    IUnknown* clientDrawingEffect
+    )
+{
+    return S_OK;
+}
+
+static HRESULT STDMETHODCALLTYPE FallbackLogTextRenderer_DrawStrikethrough(
+    IDWriteTextRenderer *This,
+    _In_opt_ void* clientDrawingContext,
+    FLOAT baselineOriginX,
+    FLOAT baselineOriginY,
+    _In_ DWRITE_STRIKETHROUGH const* strikethrough,
+    IUnknown* clientDrawingEffect
+    )
+{
+    return S_OK;
+}
+
+static HRESULT STDMETHODCALLTYPE FallbackLogTextRenderer_DrawInlineObject(
+    IDWriteTextRenderer *This,
+    void *clientDrawingContext,
+    FLOAT originX,
+    FLOAT originY,
+    IDWriteInlineObject *inlineObject,
+    WINBOOL isSideways,
+    WINBOOL isRightToLeft,
+    IUnknown *clientDrawingEffect
+    )
+{
+    return S_OK;
+}
+
+// IUnknown methods
+
+static ULONG STDMETHODCALLTYPE FallbackLogTextRenderer_AddRef(
+    IDWriteTextRenderer *This
+    )
+{
+    FallbackLogTextRenderer *this = (FallbackLogTextRenderer *)This;
+    return InterlockedIncrement(&this->ref_count);
+}
+
+static ULONG STDMETHODCALLTYPE FallbackLogTextRenderer_Release(
+    IDWriteTextRenderer *This
+    )
+{
+    FallbackLogTextRenderer *this = (FallbackLogTextRenderer *)This;
+    unsigned long new_count = InterlockedDecrement(&this->ref_count);
+    if (new_count == 0) {
+        free(this);
+        return 0;
+    }
+
+    return new_count;
+}
+
+static HRESULT STDMETHODCALLTYPE FallbackLogTextRenderer_QueryInterface(
+    IDWriteTextRenderer *This,
+    REFIID riid,
+    void **ppvObject
+    )
+{
+    if (IsEqualGUID(riid, &IID_IDWriteTextRenderer)
+        || IsEqualGUID(riid, &IID_IDWritePixelSnapping)
+        || IsEqualGUID(riid, &IID_IUnknown)) {
+        *ppvObject = This;
+    } else {
+        *ppvObject = NULL;
+        return E_FAIL;
+    }
+
+    This->lpVtbl->AddRef(This);
+    return S_OK;
+}
+
+static void init_FallbackLogTextRenderer(FallbackLogTextRenderer *r,
+                                         IDWriteFactory *factory)
+{
+    *r = (FallbackLogTextRenderer){
+        .iface = {
+            .lpVtbl = &r->vtbl,
+        },
+        .vtbl = {
+            FallbackLogTextRenderer_QueryInterface,
+            FallbackLogTextRenderer_AddRef,
+            FallbackLogTextRenderer_Release,
+            FallbackLogTextRenderer_IsPixelSnappingDisabled,
+            FallbackLogTextRenderer_GetCurrentTransform,
+            FallbackLogTextRenderer_GetPixelsPerDip,
+            FallbackLogTextRenderer_DrawGlyphRun,
+            FallbackLogTextRenderer_DrawUnderline,
+            FallbackLogTextRenderer_DrawStrikethrough,
+            FallbackLogTextRenderer_DrawInlineObject,
+        },
+        .dw_factory = factory,
+    };
+}
+
+/*
+ * This function is called whenever a font is used for the first
+ * time. It will create a FontStream for memory reading, which
+ * will be stored within the private data.
+ */
+static bool init_font_private(FontPrivate *priv)
+{
+    HRESULT hr = S_OK;
+    IDWriteFont *font = priv->font;
+    IDWriteFontFace *face = NULL;
+    IDWriteFontFile *file = NULL;
+    IDWriteFontFileStream *stream = NULL;
+    IDWriteFontFileLoader *loader = NULL;
+    UINT32 n_files = 1;
+    const void *refKey = NULL;
+    UINT32 keySize = 0;
+
+    if (priv->stream != NULL)
+        return true;
+
+    hr = IDWriteFont_CreateFontFace(font, &face);
+    if (FAILED(hr) || !face)
+        return false;
+
+    /* DirectWrite only supports one file per face */
+    hr = IDWriteFontFace_GetFiles(face, &n_files, &file);
+    if (FAILED(hr) || !file) {
+        IDWriteFontFace_Release(face);
+        return false;
+    }
+
+    hr = IDWriteFontFile_GetReferenceKey(file, &refKey, &keySize);
+    if (FAILED(hr)) {
+        IDWriteFontFile_Release(file);
+        IDWriteFontFace_Release(face);
+        return false;
+    }
+
+    hr = IDWriteFontFile_GetLoader(file, &loader);
+    if (FAILED(hr) || !loader) {
+        IDWriteFontFile_Release(file);
+        IDWriteFontFace_Release(face);
+        return false;
+    }
+
+    hr = IDWriteFontFileLoader_CreateStreamFromKey(loader, refKey, keySize, &stream);
+    if (FAILED(hr) || !stream) {
+        IDWriteFontFile_Release(file);
+        IDWriteFontFace_Release(face);
+        return false;
+    }
+
+    priv->stream = stream;
+    IDWriteFontFile_Release(file);
+    IDWriteFontFace_Release(face);
+
+    return true;
+}
+
+/*
+ * Read a specified part of a fontfile into memory.
+ * If the font wasn't used before first creates a
+ * FontStream and save it into the private data for later usage.
+ * If the parameter "buf" is NULL libass wants to know the
+ * size of the Fontfile
+ */
+static size_t get_data(void *data, unsigned char *buf, size_t offset,
+                       size_t length)
+{
+    HRESULT hr = S_OK;
+    FontPrivate *priv = (FontPrivate *) data;
+    const void *fileBuf = NULL;
+    void *fragContext = NULL;
+
+    if (!init_font_private(priv))
+        return 0;
+
+    if (buf == NULL) {
+        UINT64 fileSize;
+        hr = IDWriteFontFileStream_GetFileSize(priv->stream, &fileSize);
+        if (FAILED(hr))
+            return 0;
+
+        return fileSize;
+    }
+
+    hr = IDWriteFontFileStream_ReadFileFragment(priv->stream, &fileBuf, offset,
+                                                length, &fragContext);
+
+    if (FAILED(hr) || !fileBuf)
+        return 0;
+
+    memcpy(buf, fileBuf, length);
+
+    IDWriteFontFileStream_ReleaseFileFragment(priv->stream, fragContext);
+
+    return length;
+}
+
+/*
+ * Checks if the passed font has a specific unicode
+ * character. Returns 0 for failure and 1 for success
+ */
+static int check_glyph(void *data, uint32_t code)
+{
+    HRESULT hr = S_OK;
+    FontPrivate *priv = (FontPrivate *) data;
+    BOOL exists = FALSE;
+
+    if (code == 0)
+        return 1;
+
+    IDWriteFont_HasCharacter(priv->font, code, &exists);
+    if (FAILED(hr))
+        return 0;
+
+    return exists;
+}
+
+/*
+ * This will release the directwrite backend
+ */
+static void destroy_provider(void *priv)
+{
+    ProviderPrivate *provider_priv = (ProviderPrivate *)priv;
+    provider_priv->factory->lpVtbl->Release(provider_priv->factory);
+    FreeLibrary(provider_priv->directwrite_lib);
+    free(provider_priv);
+}
+
+/*
+ * This will destroy a specific font and it's
+ * Fontstream (in case it does exist)
+ */
+
+static void destroy_font(void *data)
+{
+    FontPrivate *priv = (FontPrivate *) data;
+
+    IDWriteFont_Release(priv->font);
+    if (priv->stream != NULL)
+        IDWriteFontFileStream_Release(priv->stream);
+
+    free(priv);
+}
+
+static int encode_utf16(wchar_t *chars, uint32_t codepoint)
+{
+    if (codepoint < 0x10000) {
+        chars[0] = codepoint;
+        return 1;
+    } else {
+        chars[0] = (codepoint >> 10) + 0xD7C0;
+        chars[1] = (codepoint & 0x3FF) + 0xDC00;
+        return 2;
+    }
+}
+
+static char *get_fallback(void *priv, ASS_FontProviderMetaData *meta,
+                          uint32_t codepoint)
+{
+    HRESULT hr;
+    ProviderPrivate *provider_priv = (ProviderPrivate *)priv;
+    IDWriteFactory *dw_factory = provider_priv->factory;
+    IDWriteTextFormat *text_format = NULL;
+    IDWriteTextLayout *text_layout = NULL;
+    FallbackLogTextRenderer renderer;
+
+    init_FallbackLogTextRenderer(&renderer, dw_factory);
+
+    hr = IDWriteFactory_CreateTextFormat(dw_factory, FALLBACK_DEFAULT_FONT, NULL,
+            DWRITE_FONT_WEIGHT_MEDIUM, DWRITE_FONT_STYLE_NORMAL,
+            DWRITE_FONT_STRETCH_NORMAL, 1.0f, L"", &text_format);
+    if (FAILED(hr)) {
+        return NULL;
+    }
+
+    // Encode codepoint as UTF-16
+    wchar_t char_string[2];
+    int char_len = encode_utf16(char_string, codepoint);
+
+    // Create a text_layout, a high-level text rendering facility, using
+    // the given codepoint and dummy format.
+    hr = IDWriteFactory_CreateTextLayout(dw_factory, char_string, char_len, text_format,
+        0.0f, 0.0f, &text_layout);
+    if (FAILED(hr)) {
+        IDWriteTextFormat_Release(text_format);
+        return NULL;
+    }
+
+    // Draw the layout with a dummy renderer, which logs the
+    // font used and stores it.
+    IDWriteFont *font = NULL;
+    hr = IDWriteTextLayout_Draw(text_layout, &font, &renderer.iface, 0.0f, 0.0f);
+    if (FAILED(hr) || font == NULL) {
+        IDWriteTextLayout_Release(text_layout);
+        IDWriteTextFormat_Release(text_format);
+        return NULL;
+    }
+
+    // We're done with these now
+    IDWriteTextLayout_Release(text_layout);
+    IDWriteTextFormat_Release(text_format);
+
+    // Now, just extract the first family name
+    BOOL exists = FALSE;
+    IDWriteLocalizedStrings *familyNames = NULL;
+    hr = IDWriteFont_GetInformationalStrings(font,
+            DWRITE_INFORMATIONAL_STRING_WIN32_FAMILY_NAMES,
+            &familyNames, &exists);
+    if (FAILED(hr) || !exists) {
+        IDWriteFont_Release(font);
+        return NULL;
+    }
+
+    wchar_t temp_name[NAME_MAX_LENGTH];
+    hr = IDWriteLocalizedStrings_GetString(familyNames, 0, temp_name, NAME_MAX_LENGTH);
+    if (FAILED(hr)) {
+        IDWriteLocalizedStrings_Release(familyNames);
+        IDWriteFont_Release(font);
+        return NULL;
+    }
+    temp_name[NAME_MAX_LENGTH-1] = 0;
+
+    // DirectWrite may not have found a valid fallback, so check that
+    // the selected font actually has the requested glyph.
+    hr = IDWriteFont_HasCharacter(font, codepoint, &exists);
+    if (FAILED(hr) || !exists) {
+        IDWriteLocalizedStrings_Release(familyNames);
+        IDWriteFont_Release(font);
+        return NULL;
+    }
+
+    int size_needed = WideCharToMultiByte(CP_UTF8, 0, temp_name, -1, NULL, 0,NULL, NULL);
+    char *family = (char *) malloc(size_needed);
+    WideCharToMultiByte(CP_UTF8, 0, temp_name, -1, family, size_needed, NULL, NULL);
+
+    IDWriteLocalizedStrings_Release(familyNames);
+    IDWriteFont_Release(font);
+    return family;
+}
+
+static int map_width(enum DWRITE_FONT_STRETCH stretch)
+{
+    switch (stretch) {
+    case DWRITE_FONT_STRETCH_ULTRA_CONDENSED: return 50;
+    case DWRITE_FONT_STRETCH_EXTRA_CONDENSED: return 63;
+    case DWRITE_FONT_STRETCH_CONDENSED:       return FONT_WIDTH_CONDENSED;
+    case DWRITE_FONT_STRETCH_SEMI_CONDENSED:  return 88;
+    case DWRITE_FONT_STRETCH_MEDIUM:          return FONT_WIDTH_NORMAL;
+    case DWRITE_FONT_STRETCH_SEMI_EXPANDED:   return 113;
+    case DWRITE_FONT_STRETCH_EXPANDED:        return FONT_WIDTH_EXPANDED;
+    case DWRITE_FONT_STRETCH_EXTRA_EXPANDED:  return 150;
+    case DWRITE_FONT_STRETCH_ULTRA_EXPANDED:  return 200;
+    default:
+        assert(0);
+    }
+}
+
+/*
+ * Scan every system font on the current machine and add it
+ * to the libass lookup. Stores the FontPrivate as private data
+ * for later memory reading
+ */
+static void scan_fonts(IDWriteFactory *factory,
+                       ASS_FontProvider *provider)
+{
+    HRESULT hr = S_OK;
+    IDWriteFontCollection *fontCollection = NULL;
+    IDWriteFont *font = NULL;
+    DWRITE_FONT_METRICS metrics;
+    DWRITE_FONT_STYLE style;
+    ASS_FontProviderMetaData meta = {0};
+    hr = IDWriteFactory_GetSystemFontCollection(factory, &fontCollection, FALSE);
+    wchar_t temp_name[NAME_MAX_LENGTH];
+    int size_needed = 0;
+
+    if (FAILED(hr) || !fontCollection)
+        return;
+
+    UINT32 familyCount = IDWriteFontCollection_GetFontFamilyCount(fontCollection);
+
+    for (UINT32 i = 0; i < familyCount; ++i) {
+        IDWriteFontFamily *fontFamily = NULL;
+        IDWriteLocalizedStrings *familyNames = NULL;
+        IDWriteLocalizedStrings *fontNames = NULL;
+        IDWriteLocalizedStrings *psNames = NULL;
+        BOOL exists = FALSE;
+        char *psName = NULL;
+
+        hr = IDWriteFontCollection_GetFontFamily(fontCollection, i, &fontFamily);
+        if (FAILED(hr))
+            continue;
+
+        UINT32 fontCount = IDWriteFontFamily_GetFontCount(fontFamily);
+        for (UINT32 j = 0; j < fontCount; ++j) {
+            hr = IDWriteFontFamily_GetFont(fontFamily, j, &font);
+            if (FAILED(hr))
+                continue;
+
+            // Simulations for bold or oblique are sometimes synthesized by
+            // DirectWrite. We are only interested in physical fonts.
+            if (IDWriteFont_GetSimulations(font) != 0) {
+                IDWriteFont_Release(font);
+                continue;
+            }
+
+            meta.weight = IDWriteFont_GetWeight(font);
+            meta.width = map_width(IDWriteFont_GetStretch(font));
+            IDWriteFont_GetMetrics(font, &metrics);
+            style = IDWriteFont_GetStyle(font);
+            meta.slant = (style == DWRITE_FONT_STYLE_NORMAL) ? FONT_SLANT_NONE :
+                         (style == DWRITE_FONT_STYLE_OBLIQUE)? FONT_SLANT_OBLIQUE :
+                         (style == DWRITE_FONT_STYLE_ITALIC) ? FONT_SLANT_ITALIC : FONT_SLANT_NONE;
+
+            hr = IDWriteFont_GetInformationalStrings(font,
+                    DWRITE_INFORMATIONAL_STRING_POSTSCRIPT_NAME, &psNames,&exists);
+            if (FAILED(hr)) {
+                IDWriteFont_Release(font);
+                continue;
+            }
+
+            if (exists) {
+                hr = IDWriteLocalizedStrings_GetString(psNames, 0, temp_name, NAME_MAX_LENGTH);
+                if (FAILED(hr)) {
+                    IDWriteLocalizedStrings_Release(psNames);
+                    IDWriteFont_Release(font);
+                    continue;
+                }
+
+                temp_name[NAME_MAX_LENGTH-1] = 0;
+                size_needed = WideCharToMultiByte(CP_UTF8, 0, temp_name, -1, NULL, 0,NULL, NULL);
+                psName = (char *) malloc(size_needed);
+                WideCharToMultiByte(CP_UTF8, 0, temp_name, -1, psName, size_needed, NULL, NULL);
+                IDWriteLocalizedStrings_Release(psNames);
+            }
+
+            hr = IDWriteFont_GetInformationalStrings(font,
+                    DWRITE_INFORMATIONAL_STRING_FULL_NAME, &fontNames,&exists);
+            if (FAILED(hr)) {
+                IDWriteFont_Release(font);
+                continue;
+            }
+
+            if (exists) {
+                meta.n_fullname = IDWriteLocalizedStrings_GetCount(fontNames);
+                meta.fullnames = (char **) calloc(meta.n_fullname, sizeof(char *));
+                for (UINT32 k = 0; k < meta.n_fullname; ++k) {
+                    hr = IDWriteLocalizedStrings_GetString(fontNames, k,
+                                                           temp_name,
+                                                           NAME_MAX_LENGTH);
+                    if (FAILED(hr)) {
+                        continue;
+                    }
+
+                    temp_name[NAME_MAX_LENGTH-1] = 0;
+                    size_needed = WideCharToMultiByte(CP_UTF8, 0, temp_name, -1, NULL, 0, NULL, NULL);
+                    char *mbName = (char *) malloc(size_needed);
+                    WideCharToMultiByte(CP_UTF8, 0, temp_name, -1, mbName, size_needed, NULL, NULL);
+                    meta.fullnames[k] = mbName;
+                }
+                IDWriteLocalizedStrings_Release(fontNames);
+            }
+
+            hr = IDWriteFont_GetInformationalStrings(font,
+                    DWRITE_INFORMATIONAL_STRING_WIN32_FAMILY_NAMES, &familyNames, &exists);
+            if (!exists)
+                hr = IDWriteFontFamily_GetFamilyNames(fontFamily, &familyNames);
+            if (FAILED(hr)) {
+                IDWriteFont_Release(font);
+                continue;
+            }
+
+            meta.n_family = IDWriteLocalizedStrings_GetCount(familyNames);
+            meta.families = (char **) calloc(meta.n_family, sizeof(char *));
+            for (UINT32 k = 0; k < meta.n_family; ++k) {
+                hr = IDWriteLocalizedStrings_GetString(familyNames, k,
+                                                       temp_name,
+                                                       NAME_MAX_LENGTH);
+                if (FAILED(hr)) {
+                    continue;
+                }
+
+                temp_name[NAME_MAX_LENGTH-1] = 0;
+                size_needed = WideCharToMultiByte(CP_UTF8, 0, temp_name, -1, NULL, 0,NULL, NULL);
+                char *mbName = (char *) malloc(size_needed);
+                WideCharToMultiByte(CP_UTF8, 0, temp_name, -1, mbName, size_needed, NULL, NULL);
+                meta.families[k] = mbName;
+            }
+            IDWriteLocalizedStrings_Release(familyNames);
+
+            FontPrivate *font_priv = (FontPrivate *) calloc(1, sizeof(*font_priv));
+            font_priv->font = font;
+
+            ass_font_provider_add_font(provider, &meta, NULL, 0, psName, font_priv);
+
+            for (UINT32 k = 0; k < meta.n_family; ++k)
+                free(meta.families[k]);
+            for (UINT32 k = 0; k < meta.n_fullname; ++k)
+                free(meta.fullnames[k]);
+            free(meta.fullnames);
+            free(meta.families);
+            free(psName);
+        }
+    }
+}
+
+/*
+ * Called by libass when the provider should perform the
+ * specified task
+ */
+static ASS_FontProviderFuncs directwrite_callbacks = {
+    get_data,
+    check_glyph,
+    destroy_font,
+    destroy_provider,
+    NULL,
+    NULL,
+    get_fallback
+};
+
+typedef HRESULT WINAPI (*DWriteCreateFactoryFn)(
+  _In_  DWRITE_FACTORY_TYPE factoryType,
+  _In_  REFIID              iid,
+  _Out_ IUnknown            **factory
+);
+
+/*
+ * Register the directwrite provider. Upon registering
+ * scans all system fonts. The private data for this
+ * provider is IDWriteFactory
+ * On failure returns NULL
+ */
+ASS_FontProvider *ass_directwrite_add_provider(ASS_Library *lib,
+                                               ASS_FontSelector *selector,
+                                               const char *config)
+{
+    HRESULT hr = S_OK;
+    IDWriteFactory *dwFactory = NULL;
+    ASS_FontProvider *provider = NULL;
+    DWriteCreateFactoryFn DWriteCreateFactoryPtr = NULL;
+    ProviderPrivate *priv = NULL;
+
+    HMODULE directwrite_lib = LoadLibraryW(L"Dwrite.dll");
+    if (!directwrite_lib)
+        goto cleanup;
+
+    DWriteCreateFactoryPtr = (DWriteCreateFactoryFn)GetProcAddress(directwrite_lib,
+                                                                   "DWriteCreateFactory");
+    if (!DWriteCreateFactoryPtr)
+        goto cleanup;
+
+    hr = DWriteCreateFactoryPtr(DWRITE_FACTORY_TYPE_SHARED,
+                                &IID_IDWriteFactory,
+                                (IUnknown **) (&dwFactory));
+    if (FAILED(hr) || !dwFactory) {
+        ass_msg(lib, MSGL_WARN, "Failed to initialize directwrite.");
+        dwFactory = NULL;
+        goto cleanup;
+    }
+
+    priv = (ProviderPrivate *)calloc(sizeof(*priv), 1);
+    if (!priv)
+        goto cleanup;
+
+    priv->directwrite_lib = directwrite_lib;
+    priv->factory = dwFactory;
+    provider = ass_font_provider_new(selector, &directwrite_callbacks, priv);
+    if (!provider)
+        goto cleanup;
+
+    scan_fonts(dwFactory, provider);
+    return provider;
+
+cleanup:
+
+    free(priv);
+    if (dwFactory)
+        dwFactory->lpVtbl->Release(dwFactory);
+    if (directwrite_lib)
+        FreeLibrary(directwrite_lib);
+
+    return NULL;
+}