Measure DirectWrite BW consistently with rendering.

src/ports/SkFontHost_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"
 #undef GetGlyphIndices
 
@@ skipping 105 matching lines @@
     virtual SkTypeface* createTypeface(int index) SK_OVERRIDE;
     virtual SkTypeface* matchStyle(const SkFontStyle& pattern) SK_OVERRIDE;
 
 private:
     SkAutoTUnref<const SkFontMgr_DirectWrite> fFontMgr;
     SkTScopedComPtr<IDWriteFontFamily> fFontFamily;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
-class DWriteOffscreen {
-public:
-    DWriteOffscreen() : fWidth(0), fHeight(0) { }
-
-    void init(IDWriteFactory* factory, IDWriteFontFace* fontFace,
-              const DWRITE_MATRIX& xform, FLOAT fontSize)
-    {
-        fFactory = factory;
-        fFontFace = fontFace;
-        fFontSize = fontSize;
-        fXform = xform;
-    }
-
-    const void* draw(const SkGlyph&, bool isBW);
-
-private:
-    uint16_t fWidth;
-    uint16_t fHeight;
-    IDWriteFactory* fFactory;
-    IDWriteFontFace* fFontFace;
-    FLOAT fFontSize;
-    DWRITE_MATRIX fXform;
-    SkTDArray<uint8_t> fBits;
-};
-
-const void* DWriteOffscreen::draw(const SkGlyph& glyph, bool isBW) {
-    if (fWidth < glyph.fWidth || fHeight < glyph.fHeight) {
-        fWidth = SkMax32(fWidth, glyph.fWidth);
-        fHeight = SkMax32(fHeight, glyph.fHeight);
-
-        if (isBW) {
-            fBits.setCount(fWidth * fHeight);
-        } else {
-            fBits.setCount(fWidth * fHeight * 3);
-        }
-    }
-
-    // erase
-    memset(fBits.begin(), 0, fBits.count());
-
-    fXform.dx = SkFixedToFloat(glyph.getSubXFixed());
-    fXform.dy = SkFixedToFloat(glyph.getSubYFixed());
-
-    FLOAT advance = 0.0f;
-
-    UINT16 index = 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 = fFontFace;
-    run.fontEmSize = fFontSize;
-    run.bidiLevel = 0;
-    run.glyphIndices = &index;
-    run.isSideways = FALSE;
-    run.glyphOffsets = &offset;
-
-    DWRITE_RENDERING_MODE renderingMode;
-    DWRITE_TEXTURE_TYPE textureType;
-    if (isBW) {
-        renderingMode = DWRITE_RENDERING_MODE_ALIASED;
-        textureType = DWRITE_TEXTURE_ALIASED_1x1;
-    } else {
-        renderingMode = DWRITE_RENDERING_MODE_CLEARTYPE_NATURAL_SYMMETRIC;
-        textureType = DWRITE_TEXTURE_CLEARTYPE_3x1;
-    }
-    SkTScopedComPtr<IDWriteGlyphRunAnalysis> glyphRunAnalysis;
-    HRNM(fFactory->CreateGlyphRunAnalysis(&run,
-                                          1.0f, // pixelsPerDip,
-                                          &fXform,
-                                          renderingMode,
-                                          DWRITE_MEASURING_MODE_NATURAL,
-                                          0.0f, // baselineOriginX,
-                                          0.0f, // baselineOriginY,
-                                          &glyphRunAnalysis),
-         "Could not create glyph run analysis.");
-
-    //NOTE: this assumes that the glyph has already been measured
-    //with an exact same glyph run analysis.
-    RECT bbox;
-    bbox.left = glyph.fLeft;
-    bbox.top = glyph.fTop;
-    bbox.right = glyph.fLeft + glyph.fWidth;
-    bbox.bottom = glyph.fTop + glyph.fHeight;
-    HRNM(glyphRunAnalysis->CreateAlphaTexture(textureType,
-                                              &bbox,
-                                              fBits.begin(),
-                                              fBits.count()),
-         "Could not draw mask.");
-    return fBits.begin();
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
 class StreamFontFileLoader : public IDWriteFontFileLoader {
 public:
     // IUnknown methods
     virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID iid, void** ppvObject);
     virtual ULONG STDMETHODCALLTYPE AddRef();
     virtual ULONG STDMETHODCALLTYPE Release();
 
     // IDWriteFontFileLoader methods
     virtual HRESULT STDMETHODCALLTYPE CreateStreamFromKey(
         void const* fontFileReferenceKey,
@@ skipping 303 matching lines @@
     virtual unsigned generateGlyphCount() SK_OVERRIDE;
     virtual uint16_t generateCharToGlyph(SkUnichar uni) SK_OVERRIDE;
     virtual void generateAdvance(SkGlyph* glyph) SK_OVERRIDE;
     virtual void generateMetrics(SkGlyph* glyph) SK_OVERRIDE;
     virtual void generateImage(const SkGlyph& glyph) SK_OVERRIDE;
     virtual void generatePath(const SkGlyph& glyph, SkPath* path) SK_OVERRIDE;
     virtual void generateFontMetrics(SkPaint::FontMetrics* mX,
                                      SkPaint::FontMetrics* mY) SK_OVERRIDE;
 
 private:
-    DWriteOffscreen fOffscreen;
+    const void* drawDWMask(const SkGlyph& glyph);
+
+    SkTDArray<uint8_t> fBits;
     DWRITE_MATRIX fXform;
     SkAutoTUnref<DWriteFontTypeface> fTypeface;
     int fGlyphCount;
+    DWRITE_RENDERING_MODE fRenderingMode;
+    DWRITE_TEXTURE_TYPE fTextureType;
+    DWRITE_MEASURING_MODE fMeasuringMode;
 };
 
 static bool are_same(IUnknown* a, IUnknown* b) {
     SkTScopedComPtr<IUnknown> iunkA;
     if (FAILED(a->QueryInterface(&iunkA))) {
         return false;
     }
 
     SkTScopedComPtr<IUnknown> iunkB;
     if (FAILED(b->QueryInterface(&iunkB))) {
@@ skipping 108 matching lines @@
         , fTypeface(SkRef(typeface))
         , fGlyphCount(-1) {
 
     fXform.m11 = SkScalarToFloat(fRec.fPost2x2[0][0]);
     fXform.m12 = SkScalarToFloat(fRec.fPost2x2[1][0]);
     fXform.m21 = SkScalarToFloat(fRec.fPost2x2[0][1]);
     fXform.m22 = SkScalarToFloat(fRec.fPost2x2[1][1]);
     fXform.dx = 0;
     fXform.dy = 0;
 
-    fOffscreen.init(fTypeface->fFactory.get(), fTypeface->fDWriteFontFace.get(),
-                    fXform, SkScalarToFloat(fRec.fTextSize));
+    if (SkMask::kBW_Format == fRec.fMaskFormat) {
+        fRenderingMode = DWRITE_RENDERING_MODE_ALIASED;
+        fTextureType = DWRITE_TEXTURE_ALIASED_1x1;
+        fMeasuringMode = DWRITE_MEASURING_MODE_GDI_CLASSIC;
+    } else {
+        fRenderingMode = DWRITE_RENDERING_MODE_CLEARTYPE_NATURAL_SYMMETRIC;
+        fTextureType = DWRITE_TEXTURE_CLEARTYPE_3x1;
+        fMeasuringMode = DWRITE_MEASURING_MODE_NATURAL;
+    }
+
+    if (this->isSubpixel()) {
+        fMeasuringMode = DWRITE_MEASURING_MODE_NATURAL;
+    }
 }
 
 SkScalerContext_DW::~SkScalerContext_DW() {
 }
 
 unsigned SkScalerContext_DW::generateGlyphCount() {
     if (fGlyphCount < 0) {
         fGlyphCount = fTypeface->fDWriteFontFace->GetGlyphCount();
     }
     return fGlyphCount;
@@ skipping 10 matching lines @@
     //and where the right/left side bearing ends up after hinting.
     //DirectWrite does not provide this information.
     glyph->fRsbDelta = 0;
     glyph->fLsbDelta = 0;
 
     glyph->fAdvanceX = 0;
     glyph->fAdvanceY = 0;
 
     uint16_t glyphId = glyph->getGlyphID();
     DWRITE_GLYPH_METRICS gm;
-    HRVM(fTypeface->fDWriteFontFace->GetDesignGlyphMetrics(&glyphId, 1, &gm),
-         "Could not get design metrics.");
+
+    if (DWRITE_MEASURING_MODE_GDI_CLASSIC == fMeasuringMode ||
+        DWRITE_MEASURING_MODE_GDI_NATURAL == fMeasuringMode)
+    {
+        HRVM(fTypeface->fDWriteFontFace->GetGdiCompatibleGlyphMetrics(
+                 fRec.fTextSize,
+                 1.0f, // pixelsPerDip
+                 &fXform,
+                 DWRITE_MEASURING_MODE_GDI_NATURAL == fMeasuringMode,
+                 &glyphId, 1,
+                 &gm),
+             "Could not get gdi compatible glyph metrics.");
+    } else {
+        HRVM(fTypeface->fDWriteFontFace->GetDesignGlyphMetrics(&glyphId, 1, &gm),
+             "Could not get design metrics.");
+    }
 
     DWRITE_FONT_METRICS dwfm;
     fTypeface->fDWriteFontFace->GetMetrics(&dwfm);
-
     SkScalar advanceX = SkScalarMulDiv(fRec.fTextSize,
                                        SkIntToScalar(gm.advanceWidth),
                                        SkIntToScalar(dwfm.designUnitsPerEm));
 
-    if (!(fRec.fFlags & kSubpixelPositioning_Flag)) {
+    if (!this->isSubpixel()) {
         advanceX = SkScalarRoundToScalar(advanceX);
     }
 
     SkVector vecs[1] = { { advanceX, 0 } };
     SkMatrix mat;
     fRec.getMatrixFrom2x2(&mat);
     mat.mapVectors(vecs, SK_ARRAY_COUNT(vecs));
 
     glyph->fAdvanceX = SkScalarToFixed(vecs[0].fX);
     glyph->fAdvanceY = SkScalarToFixed(vecs[0].fY);
@@ skipping 19 matching lines @@
     DWRITE_GLYPH_RUN run;
     run.glyphCount = 1;
     run.glyphAdvances = &advance;
     run.fontFace = fTypeface->fDWriteFontFace.get();
     run.fontEmSize = SkScalarToFloat(fRec.fTextSize);
     run.bidiLevel = 0;
     run.glyphIndices = &glyphId;
     run.isSideways = FALSE;
     run.glyphOffsets = &offset;
 
-    const bool isBW = SkMask::kBW_Format == fRec.fMaskFormat;
-    DWRITE_RENDERING_MODE renderingMode;
-    DWRITE_TEXTURE_TYPE textureType;
-    if (isBW) {
-        renderingMode = DWRITE_RENDERING_MODE_ALIASED;
-        textureType = DWRITE_TEXTURE_ALIASED_1x1;
-    } else {
-        renderingMode = DWRITE_RENDERING_MODE_CLEARTYPE_NATURAL_SYMMETRIC;
-        textureType = DWRITE_TEXTURE_CLEARTYPE_3x1;
-    }
-
     SkTScopedComPtr<IDWriteGlyphRunAnalysis> glyphRunAnalysis;
     HRVM(fTypeface->fFactory->CreateGlyphRunAnalysis(
              &run,
              1.0f, // pixelsPerDip,
              &fXform,
-             renderingMode,
-             DWRITE_MEASURING_MODE_NATURAL,
+             fRenderingMode,
+             fMeasuringMode,
              0.0f, // baselineOriginX,
              0.0f, // baselineOriginY,
              &glyphRunAnalysis),
          "Could not create glyph run analysis.");
 
     RECT bbox;
-    HRVM(glyphRunAnalysis->GetAlphaTextureBounds(textureType, &bbox),
+    HRVM(glyphRunAnalysis->GetAlphaTextureBounds(fTextureType, &bbox),
          "Could not get texture bounds.");
 
     glyph->fWidth = SkToU16(bbox.right - bbox.left);
     glyph->fHeight = SkToU16(bbox.bottom - bbox.top);
     glyph->fLeft = SkToS16(bbox.left);
     glyph->fTop = SkToS16(bbox.top);
 }
 
 void SkScalerContext_DW::generateFontMetrics(SkPaint::FontMetrics* mx,
-                                                  SkPaint::FontMetrics* my) {
+                                             SkPaint::FontMetrics* my) {
     if (!(mx || my))
       return;
 
     if (mx) {
         sk_bzero(mx, sizeof(*mx));
     }
     if (my) {
         sk_bzero(my, sizeof(*my));
     }
 
     DWRITE_FONT_METRICS dwfm;
-    fTypeface->fDWriteFontFace->GetMetrics(&dwfm);
+    if (DWRITE_MEASURING_MODE_GDI_CLASSIC == fMeasuringMode ||
+        DWRITE_MEASURING_MODE_GDI_NATURAL == fMeasuringMode)
+    {
+        fTypeface->fDWriteFontFace->GetGdiCompatibleMetrics(
+             fRec.fTextSize,
+             1.0f, // pixelsPerDip
+             &fXform,
+             &dwfm);
+    } else {
+        fTypeface->fDWriteFontFace->GetMetrics(&dwfm);
+    }
 
     SkScalar upem = SkIntToScalar(dwfm.designUnitsPerEm);
     if (mx) {
         mx->fTop = -fRec.fTextSize * SkIntToScalar(dwfm.ascent) / upem;
         mx->fAscent = mx->fTop;
         mx->fDescent = fRec.fTextSize * SkIntToScalar(dwfm.descent) / upem;
         mx->fBottom = mx->fDescent;
         mx->fLeading = fRec.fTextSize * SkIntToScalar(dwfm.lineGap) / upem;
         mx->fXHeight = fRec.fTextSize * SkIntToScalar(dwfm.xHeight) / upem;
         mx->fUnderlineThickness = fRec.fTextSize * SkIntToScalar(dwfm.underlinePosition) / upem;
@@ skipping 106 matching lines @@
         for (U16CPU i = 0; i < width; i++) {
             U8CPU r = sk_apply_lut_if<APPLY_PREBLEND>(*(src++), tableR);
             U8CPU g = sk_apply_lut_if<APPLY_PREBLEND>(*(src++), tableG);
             U8CPU b = sk_apply_lut_if<APPLY_PREBLEND>(*(src++), tableB);
             dst[i] = SkPackARGB32(0xFF, r, g, b);
         }
         dst = (SkPMColor*)((char*)dst + dstRB);
     }
 }
 
+const void* SkScalerContext_DW::drawDWMask(const SkGlyph& glyph) {
+    int sizeNeeded = glyph.fWidth * glyph.fHeight;
+    if (DWRITE_RENDERING_MODE_ALIASED != fRenderingMode) {
+        sizeNeeded *= 3;
+    }
+    if (sizeNeeded > fBits.count()) {
+        fBits.setCount(sizeNeeded);
+    }
+
+    // erase
+    memset(fBits.begin(), 0, sizeNeeded);
+
+    fXform.dx = SkFixedToFloat(glyph.getSubXFixed());
+    fXform.dy = SkFixedToFloat(glyph.getSubYFixed());
+
+    FLOAT advance = 0.0f;
+
+    UINT16 index = 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(fRec.fTextSize);
+    run.bidiLevel = 0;
+    run.glyphIndices = &index;
+    run.isSideways = FALSE;
+    run.glyphOffsets = &offset;
+
+    SkTScopedComPtr<IDWriteGlyphRunAnalysis> glyphRunAnalysis;
+    HRNM(fTypeface->fFactory->CreateGlyphRunAnalysis(&run,
+                                          1.0f, // pixelsPerDip,
+                                          &fXform,
+                                          fRenderingMode,
+                                          fMeasuringMode,
+                                          0.0f, // baselineOriginX,
+                                          0.0f, // baselineOriginY,
+                                          &glyphRunAnalysis),
+         "Could not create glyph run analysis.");
+
+    //NOTE: this assumes that the glyph has already been measured
+    //with an exact same glyph run analysis.
+    RECT bbox;
+    bbox.left = glyph.fLeft;
+    bbox.top = glyph.fTop;
+    bbox.right = glyph.fLeft + glyph.fWidth;
+    bbox.bottom = glyph.fTop + glyph.fHeight;
+    HRNM(glyphRunAnalysis->CreateAlphaTexture(fTextureType,
+                                              &bbox,
+                                              fBits.begin(),
+                                              sizeNeeded),
+         "Could not draw mask.");
+    return fBits.begin();
+}
+
 void SkScalerContext_DW::generateImage(const SkGlyph& glyph) {
-    const bool isBW = SkMask::kBW_Format == fRec.fMaskFormat;
-    const bool isAA = !isLCD(fRec);
-
     //Create the mask.
-    const void* bits = fOffscreen.draw(glyph, isBW);
+    const void* bits = this->drawDWMask(glyph);
     if (!bits) {
         sk_bzero(glyph.fImage, glyph.computeImageSize());
         return;
     }
 
     //Copy the mask into the glyph.
     const uint8_t* src = (const uint8_t*)bits;
-    if (isBW) {
+    if (DWRITE_RENDERING_MODE_ALIASED == fRenderingMode) {
         bilevel_to_bw(src, glyph);
-    } else if (isAA) {
+        ((SkGlyph*)&glyph)->fMaskFormat = SkMask::kBW_Format;
+    } else if (!isLCD(fRec)) {
         if (fPreBlend.isApplicable()) {
             rgb_to_a8<true>(src, glyph, fPreBlend.fG);
         } else {
             rgb_to_a8<false>(src, glyph, fPreBlend.fG);
         }
     } else if (SkMask::kLCD16_Format == glyph.fMaskFormat) {
         if (fPreBlend.isApplicable()) {
             rgb_to_lcd16<true>(src, glyph, fPreBlend.fR, fPreBlend.fG, fPreBlend.fB);
         } else {
             rgb_to_lcd16<false>(src, glyph, fPreBlend.fR, fPreBlend.fG, fPreBlend.fB);
@@ skipping 874 matching lines @@
 }
 
 #include "SkFontMgr_indirect.h"
 SkFontMgr* SkFontMgr_New_DirectWriteRenderer(SkRemotableFontMgr* proxy) {
     SkAutoTUnref<SkFontMgr> impl(SkFontMgr_New_DirectWrite());
     if (impl.get() == NULL) {
         return NULL;
     }
     return SkNEW_ARGS(SkFontMgr_Indirect, (impl.get(), proxy));
 }