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)
 
 #undef GetGlyphIndices
 
+#include "SkDraw.h"
 #include "SkDWrite.h"
 #include "SkDWriteGeometrySink.h"
 #include "SkEndian.h"
 #include "SkGlyph.h"
 #include "SkHRESULT.h"
 #include "SkMaskGamma.h"
 #include "SkMatrix22.h"
 #include "SkMutex.h"
 #include "SkOTTable_EBLC.h"
 #include "SkOTTable_EBSC.h"
 #include "SkOTTable_gasp.h"
 #include "SkOTTable_maxp.h"
 #include "SkPath.h"
+#include "SkRasterClip.h"
 #include "SkScalerContext.h"
 #include "SkScalerContext_win_dw.h"
 #include "SkSharedMutex.h"
 #include "SkTScopedComPtr.h"
 #include "SkTypeface_win_dw.h"
 
 #include <dwrite.h>
 #if SK_HAS_DWRITE_1_H
 #  include <dwrite_1.h>
 #endif
@@ skipping 167 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
+    fTypeface->fFactory->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, fMeasuringMode, &fXform, 0, colorGlyph);
+    if (hr == DWRITE_E_NOCOLOR) {
+      return false;

[bungeman-skia, 2016/05/23 22:03:41]

nit: four space indent

[Ilya Kulshin, 2016/05/25 18:52:07]

Done.

+    }
+    HRBM(hr, "Failed to translate color glyph run");
+    return true;
+}
+#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));
+    SkASSERT(glyph.fMaskFormat == SkMask::Format::kARGB32_Format);
+
+    memset(glyph.fImage, 0, glyph.computeImageSize());
+
+    SkTScopedComPtr<IDWriteColorGlyphRunEnumerator> colorLayers;
+    getColorGlyphRun(glyph, &colorLayers);
+    SkASSERT(colorLayers.get());
+
+    SkMatrix matrix = fSkXform;
+    matrix.postTranslate(-glyph.fLeft, -glyph.fTop);

[bungeman-skia, 2016/05/23 22:03:40]

For some reason the bots don't seem to be running with the right warnings. These
conversions will need to look like -SkIntToScalar(glyph.fLeft) to avoid
conversion warnings.

[Ilya Kulshin, 2016/05/25 18:52:07]

Done.

+    SkRasterClip rc(SkIRect::MakeWH(glyph.fWidth, glyph.fHeight));
+    SkDraw draw;
+    draw.fDst = SkPixmap(SkImageInfo::MakeN32(glyph.fWidth, glyph.fHeight, kPremul_SkAlphaType),
+                         glyph.fImage,
+                         glyph.ComputeRowBytes(glyph.fWidth, SkMask::Format::kARGB32_Format));
+    draw.fMatrix = &matrix;
+    draw.fRC = &rc;
+
+    SkPaint paint;
+    if (fRenderingMode != DWRITE_RENDERING_MODE_ALIASED) {
+        paint.setFlags(SkPaint::Flags::kAntiAlias_Flag);
+    }
+
+    BOOL hasNextRun = FALSE;
+    while (SUCCEEDED(colorLayers->MoveNext(&hasNextRun)) && hasNextRun) {
+        const DWRITE_COLOR_GLYPH_RUN* colorGlyph;
+        HRVM(colorLayers->GetCurrentRun(&colorGlyph), "Could not get current color glyph run");
+
+        SkColor color;
+        if (colorGlyph->paletteIndex != 0xffff) {
+            color = SkColorSetARGB(colorGlyph->runColor.a * 255,

[bungeman-skia, 2016/05/23 22:03:41]

Similarly these give warnings. I think these need to be like

SkFloatToIntRound(colorGlyph->runColor.a * 255)

[Ilya Kulshin, 2016/05/25 18:52:07]

Done.

+                                   colorGlyph->runColor.r * 255,
+                                   colorGlyph->runColor.g * 255,
+                                   colorGlyph->runColor.b * 255);
+        } else {
+            // 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.
+            // In practice, I've not encountered a color glyph that uses the current brush color,
+            // so I'm not sure it's even possible (it might be reserved for a run with a mix of

[bungeman-skia, 2016/05/23 22:03:41]

Remove this 'possible' speculation. The specification explicitly states that
it's allowed.

[Ilya Kulshin, 2016/05/25 18:52:07]

Done.

+            // color and non-color glyphs, which never happens here). If this assert ever fires, we
+            // should verify that the color is rendered properly.
+            SkASSERT(false);
+            color = fRec.getLuminanceColor();
+        }
+        paint.setColor(color);
+
+        SkPath path;
+        SkTScopedComPtr<IDWriteGeometrySink> geometryToPath;
+        HRVM(SkDWriteGeometrySink::Create(&path, &geometryToPath),
+             "Could not create geometry to path converter.");
+        {
+            Exclusive l(DWriteFactoryMutex);
+            // If only DirectWrite had a "GetGlyphrunOutlineForThisGlyphRun" API...

[bungeman-skia, 2016/05/23 22:03:41]

nit: it would be named GetGlyphRunOutlineForGlyphRun

[Ilya Kulshin, 2016/05/25 18:52:07]

Removed the comment altogether, since it wasn't really serving any purpose.

+            HRVM(colorGlyph->glyphRun.fontFace->GetGlyphRunOutline(
+                colorGlyph->glyphRun.fontEmSize,
+                colorGlyph->glyphRun.glyphIndices,
+                colorGlyph->glyphRun.glyphAdvances,
+                colorGlyph->glyphRun.glyphOffsets,
+                colorGlyph->glyphRun.glyphCount,
+                colorGlyph->glyphRun.isSideways,
+                colorGlyph->glyphRun.bidiLevel % 2, //rtl
+                geometryToPath.get()),
+                "Could not create glyph outline.");
+        }
+        draw.drawPath(path, paint, nullptr, true /* pathIsMutable */);
+    }
+}
+#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)