Implement support for rendering color emoji on Windows

src/ports/SkScalerContext_win_dw.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkTypes.h"
 #if defined(SK_BUILD_FOR_WIN32)
 
@@ skipping 192 matching lines @@
             both_zero(rec.fPost2x2[0][0], rec.fPost2x2[1][1]));
 }
 
 SkScalerContext_DW::SkScalerContext_DW(DWriteFontTypeface* typeface,
                                        const SkScalerContextEffects& effects,
                                        const SkDescriptor* desc)
         : SkScalerContext(typeface, effects, desc)
         , fTypeface(SkRef(typeface))
         , fGlyphCount(-1) {
 
+#if SK_HAS_DWRITE_2_H
+    SkTScopedComPtr<IDWriteFactory> factory(SkSafeRefComPtr(sk_get_dwrite_factory()));

[bungeman-skia, 2016/05/18 14:50:55]

You cannot create a factory here, you must use the one provided by
fTypeface->fFactory. You'll then call QueryInterface on that. In general, you
cannot use sk_get_dwrite_factory unless you're just creating the top level
object; the user may have provided their own factory (and Chromium always does).

[Ilya Kulshin, 2016/05/18 22:43:38]

Done.

+    factory->QueryInterface<IDWriteFactory2>(&fFactory2);
+
+    SkTScopedComPtr<IDWriteFontFace2> fontFace2;
+    fTypeface->fDWriteFontFace->QueryInterface<IDWriteFontFace2>(&fontFace2);
+    fIsColorFont = fFactory2.get() && fontFace2.get() && fontFace2->IsColorFont();
+#endif
+
     // In general, all glyphs should use CLEARTYPE_NATURAL_SYMMETRIC
     // except when bi-level rendering is requested or there are embedded
     // bi-level bitmaps (and the embedded bitmap flag is set and no rotation).
     //
     // DirectWrite's IDWriteFontFace::GetRecommendedRenderingMode does not do
     // this. As a result, determine the actual size of the text and then see if
     // there are any embedded bi-level bitmaps of that size. If there are, then
     // force bitmaps by requesting bi-level rendering.
     //
     // FreeType allows for separate ppemX and ppemY, but DirectWrite assumes
@@ skipping 228 matching lines @@
     if (bbox.left >= bbox.right || bbox.top >= bbox.bottom) {
         return false;
     }
     glyph->fWidth = SkToU16(bbox.right - bbox.left);
     glyph->fHeight = SkToU16(bbox.bottom - bbox.top);
     glyph->fLeft = SkToS16(bbox.left);
     glyph->fTop = SkToS16(bbox.top);
     return true;
 }
 
+bool SkScalerContext_DW::isColorGlyph(const SkGlyph& glyph) {
+#if SK_HAS_DWRITE_2_H
+    SkTScopedComPtr<IDWriteColorGlyphRunEnumerator> colorLayer;
+    if (getColorGlyphRun(glyph, &colorLayer)) {
+        return true;
+    }
+#endif
+    return false;
+}
+
+#if SK_HAS_DWRITE_2_H
+bool SkScalerContext_DW::getColorGlyphRun(const SkGlyph& glyph,
+                                          IDWriteColorGlyphRunEnumerator** colorGlyph)
+{
+    FLOAT advance = 0;
+    UINT16 glyphId = glyph.getGlyphID();
+
+    DWRITE_GLYPH_OFFSET offset;
+    offset.advanceOffset = 0.0f;
+    offset.ascenderOffset = 0.0f;
+
+    DWRITE_GLYPH_RUN run;
+    run.glyphCount = 1;
+    run.glyphAdvances = &advance;
+    run.fontFace = fTypeface->fDWriteFontFace.get();
+    run.fontEmSize = SkScalarToFloat(fTextSizeRender);
+    run.bidiLevel = 0;
+    run.glyphIndices = &glyphId;
+    run.isSideways = FALSE;
+    run.glyphOffsets = &offset;
+
+    HRESULT hr = fFactory2->TranslateColorGlyphRun(
+        0, 0, &run, nullptr, DWRITE_MEASURING_MODE_NATURAL, nullptr, 0, colorGlyph);

[bungeman-skia, 2016/05/18 14:50:55]

Need to pass in fXform and fMeasuringMode.

[Ilya Kulshin, 2016/05/18 22:43:38]

Done.

+    if (SUCCEEDED(hr)) {
+        return true;
+    } else {
+        SkASSERT(hr == DWRITE_E_NOCOLOR);
+    }
+    return false;

[bungeman-skia, 2016/05/18 14:50:55]

The return value handling here should be more like

if (DWRITE_E_NOCOLOR == hr) {
    return false;
}
HRBM(hr, "Failed to get color glyph run.")
return true;

it's unfortunate that in this case they used the return value to indicate
'negative success' instead of an actual error. Most other calls in the
DirectWrite API have an out BOOL parameter to indicate this instead.

[Ilya Kulshin, 2016/05/18 22:43:38]

Done.

+}
+#endif
+
 void SkScalerContext_DW::generateMetrics(SkGlyph* glyph) {
     glyph->fWidth = 0;
     glyph->fHeight = 0;
     glyph->fLeft = 0;
     glyph->fTop = 0;
 
     this->generateAdvance(glyph);
 
+#if SK_HAS_DWRITE_2_H
+    if (fIsColorFont && isColorGlyph(*glyph)) {
+        glyph->fMaskFormat = SkMask::kARGB32_Format;
+    }
+#endif
+
     RECT bbox;
     HRVM(this->getBoundingBox(glyph, fRenderingMode, fTextureType, &bbox),
          "Requested bounding box could not be determined.");
 
     if (glyph_check_and_set_bounds(glyph, bbox)) {
         return;
     }
 
     // GetAlphaTextureBounds succeeds but returns an empty RECT if there are no
     // glyphs of the specified texture type. When this happens, try with the
@@ skipping 224 matching lines @@
             HRNM(glyphRunAnalysis->CreateAlphaTexture(textureType,
                 &bbox,
                 fBits.begin(),
                 sizeNeeded),
                 "Could not draw mask.");
         }
     }
     return fBits.begin();
 }
 
+#if SK_HAS_DWRITE_2_H
+void SkScalerContext_DW::generateColorGlyphImage(const SkGlyph& glyph) {
+    SkASSERT(isColorGlyph(glyph));
+    HRESULT hr = S_OK;

[bungeman-skia, 2016/05/18 14:50:55]

Remove this.

[Ilya Kulshin, 2016/05/18 22:43:38]

Done.

+
+    memset(glyph.fImage, 0, glyph.computeImageSize());
+
+    SkTScopedComPtr<IDWriteColorGlyphRunEnumerator> colorLayers;
+    getColorGlyphRun(glyph, &colorLayers);
+    SkASSERT(colorLayers.get());
+
+    int layerSize = glyph.fWidth * glyph.fHeight; // layers are drawn in monochrome
+    SkASSERT_RELEASE(layerSize * sizeof(uint32_t) == glyph.computeImageSize());
+    fBits.setCount(layerSize);
+
+    RECT bbox;
+    bbox.left = glyph.fLeft;
+    bbox.top = glyph.fTop;
+    bbox.right = glyph.fLeft + glyph.fWidth;
+    bbox.bottom = glyph.fTop + glyph.fHeight;
+
+    BOOL hasNextRun = FALSE;
+    while (SUCCEEDED(colorLayers->MoveNext(&hasNextRun)) && hasNextRun) {
+        const DWRITE_COLOR_GLYPH_RUN* colorGlyph;
+        if (!SUCCEEDED(colorLayers->GetCurrentRun(&colorGlyph))) {

[bungeman-skia, 2016/05/18 14:50:55]

Use the HRNM macro for proper logging and for consistency.

[Ilya Kulshin, 2016/05/18 22:43:38]

Done.

+            SkASSERT(false);
+            return;
+        }
+
+        SkTScopedComPtr<IDWriteGlyphRunAnalysis> glyphRunAnalysis;
+        {
+            Exclusive l(DWriteFactoryMutex);
+            hr = fTypeface->fFactory->CreateGlyphRunAnalysis(&colorGlyph->glyphRun,

[bungeman-skia, 2016/05/18 14:50:55]

The result is never checked. Use the HRNM macro like drawDWMask does. In general
it's an anti-pattern to have a local 'hr' variable. Usually if the result isn't
immediately checked then it's ignored, like here.

[Ilya Kulshin, 2016/05/18 22:43:38]

Done.

+                1.0f, // pixelsPerDip,
+                nullptr,

[bungeman-skia, 2016/05/18 14:50:55]

If you don't pass the fXForm, how does this work for anything other than
identity matrix?

[Ilya Kulshin, 2016/05/18 22:43:38]

Added fXfrom, but I'm not sure when it will be something other than the identity
matrix.

[bungeman-skia, 2016/05/19 18:52:37]

Any time there is skew/rotation.

+                DWRITE_RENDERING_MODE_ALIASED,
+                DWRITE_MEASURING_MODE_NATURAL,

[bungeman-skia, 2016/05/18 14:50:55]

fRenderingMode and fMeasuringMode

[Ilya Kulshin, 2016/05/18 22:43:38]

Done.

+                colorGlyph->baselineOriginX,
+                colorGlyph->baselineOriginY,
+                &glyphRunAnalysis);
+        }
+        //NOTE: this assumes that the glyph has already been measured
+        //with an exact same glyph run analysis.
+        {
+            Shared l(DWriteFactoryMutex);
+            hr = glyphRunAnalysis->CreateAlphaTexture(DWRITE_TEXTURE_ALIASED_1x1,

[bungeman-skia, 2016/05/18 14:50:55]

HRNM, fRenderingMode

[Ilya Kulshin, 2016/05/18 22:43:38]

Done.

+                &bbox,
+                fBits.begin(),
+                layerSize);
+        }
+
+        uint32_t* colorPixels = reinterpret_cast<uint32_t*>(glyph.fImage);
+        SkColor color = SkColorSetARGB(colorGlyph->runColor.a * 255,

[bungeman-skia, 2016/05/18 14:50:55]

Note that if all components of runColor are 0 or (equivalently) paletteIndex is
0xFFFF then the 'current brush' is used. fRec.getLuminanceColor() is kinda sorta
what is wanted here, but not really, it will often be the wrong value because it
wan't designed for this. Fixing this is quite difficult and one of the reasons
this hasn't already been done.

[Ilya Kulshin, 2016/05/20 03:41:40]

Changed to fRec.getLuminanceColor() and added a comment and an assert. In
practice, I haven't found a glyph that uses the current brush, and verified that
no such glyphs exist in Microsoft's color emoji font. Perhaps this case was
added for handling runs of mixed color and non-color glyphs?

+                                       colorGlyph->runColor.r * 255,

[reed1, 2016/05/18 00:42:53]

is runColor premultiplied?

[Ilya Kulshin, 2016/05/18 00:56:46]

I'm not actually sure. It's of type D3DCOLORVALUE. The phrasing of the docs
makes me think it isn't, but I haven't found anything definitive. In either
case, while testing I've only seen alpha values of 0 and 1.

+                                       colorGlyph->runColor.g * 255,
+                                       colorGlyph->runColor.b * 255);
+        for (int pixel = 0; pixel < layerSize; pixel++) {
+            if (fBits[pixel] != 0) {

[bungeman-skia, 2016/05/18 14:50:54]

This seems like a really bad blend, this should be SrcOver. It appears that's
why you're hard coding ALIASED? That seems like a bad idea.

[Ilya Kulshin, 2016/05/18 22:43:38]

Originally I thought antialiasing/subpixel rendering wouldn't work with color
glyphs, but now I think it could. Although I'm not sure exactly how the
different layers need to be combined when one or both are partially transparent.
I need to think a bit more about this.

+                colorPixels[pixel] = color;
+            }
+        }
+    }
+}
+#endif
+
 void SkScalerContext_DW::generateImage(const SkGlyph& glyph) {
     //Create the mask.
     DWRITE_RENDERING_MODE renderingMode = fRenderingMode;
     DWRITE_TEXTURE_TYPE textureType = fTextureType;
     if (glyph.fForceBW) {
         renderingMode = DWRITE_RENDERING_MODE_ALIASED;
         textureType = DWRITE_TEXTURE_ALIASED_1x1;
     }
+
+#if SK_HAS_DWRITE_2_H
+    if (SkMask::kARGB32_Format == glyph.fMaskFormat) {
+        generateColorGlyphImage(glyph);
+        return;
+    }
+#endif
+
     const void* bits = this->drawDWMask(glyph, renderingMode, textureType);
     if (!bits) {
         sk_bzero(glyph.fImage, glyph.computeImageSize());
         return;
     }
 
     //Copy the mask into the glyph.
     const uint8_t* src = (const uint8_t*)bits;
     if (DWRITE_RENDERING_MODE_ALIASED == renderingMode) {
         bilevel_to_bw(src, glyph);
@@ skipping 43 matching lines @@
             FALSE, //sideways
             FALSE, //rtl
             geometryToPath.get()),
             "Could not create glyph outline.");
     }
 
     path->transform(fSkXform);
 }
 
 #endif//defined(SK_BUILD_FOR_WIN32)