Revert of Support pixel antialising in DirectWrite.

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 16 matching lines @@
 #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>
-#else
-#  pragma message("No dwrite_1.h is available, font metrics may be affected.")
-#endif
-
-#if SK_HAS_DWRITE_2_H
-#  include <dwrite_2.h>
-#else
-#  pragma message("No dwrite_2.h is available, pixel antialiased glyph quality may be affected.")
 #endif
 
 /* Note:
  * In versions 8 and 8.1 of Windows, some calls in DWrite are not thread safe.
  * The DWriteFactoryMutex protects the calls that are problematic.
  */
 static SkSharedMutex DWriteFactoryMutex;
 
 typedef SkAutoSharedMutexShared Shared;
 
@@ skipping 158 matching lines @@
 }
 
 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
-    fIsColorFont = fTypeface->fFactory2 &&
-                   fTypeface->fDWriteFontFace2 &&
-                   fTypeface->fDWriteFontFace2->IsColorFont();
+    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.
@@ skipping 87 matching lines @@
 
     // The normal case is to use natural symmetric rendering and linear metrics.
     } else {
         fTextSizeRender = realTextSize;
         fRenderingMode = DWRITE_RENDERING_MODE_CLEARTYPE_NATURAL_SYMMETRIC;
         fTextureType = DWRITE_TEXTURE_CLEARTYPE_3x1;
         fTextSizeMeasure = realTextSize;
         fMeasuringMode = DWRITE_MEASURING_MODE_NATURAL;
     }
 
-    // DirectWrite2 allows for grayscale hinting.
-#if SK_HAS_DWRITE_2_H
-    fAntiAliasMode = DWRITE_TEXT_ANTIALIAS_MODE_CLEARTYPE;
-#ifndef SK_IGNORE_DW_GRAY_FIX
-    if (fTypeface->fFactory2 && fTypeface->fDWriteFontFace2 &&
-        !isLCD(fRec) && !(fRec.fFlags & SkScalerContext::kGenA8FromLCD_Flag))
-    {
-        // DWRITE_TEXTURE_ALIASED_1x1 is now misnamed, it must also be used with grayscale.
-        fTextureType = DWRITE_TEXTURE_ALIASED_1x1;
-        fAntiAliasMode = DWRITE_TEXT_ANTIALIAS_MODE_GRAYSCALE;
-    }
-#endif
-#endif
-
-    // DirectWrite2 allows hinting to be disabled.
-#if SK_HAS_DWRITE_2_H
-    fGridFitMode = DWRITE_GRID_FIT_MODE_ENABLED;
-    if (fTypeface->fFactory2 && fTypeface->fDWriteFontFace2 &&
-        fRec.getHinting() == SkPaint::kNo_Hinting)
-    {
-        fGridFitMode = DWRITE_GRID_FIT_MODE_DISABLED;
-    }
-#endif
-
     if (this->isSubpixel()) {
         fTextSizeMeasure = realTextSize;
         fMeasuringMode = DWRITE_MEASURING_MODE_NATURAL;
     }
 }
 
 SkScalerContext_DW::~SkScalerContext_DW() {
 }
 
 unsigned SkScalerContext_DW::generateGlyphCount() {
@@ skipping 88 matching lines @@
     run.fontFace = fTypeface->fDWriteFontFace.get();
     run.fontEmSize = SkScalarToFloat(fTextSizeRender);
     run.bidiLevel = 0;
     run.glyphIndices = &glyphId;
     run.isSideways = FALSE;
     run.glyphOffsets = &offset;
 
     SkTScopedComPtr<IDWriteGlyphRunAnalysis> glyphRunAnalysis;
     {
         SkAutoExclusive l(DWriteFactoryMutex);
-        if (fTypeface->fFactory2) {
-#if SK_HAS_DWRITE_2_H
-            HRNM(fTypeface->fFactory2->CreateGlyphRunAnalysis(
-                     &run,
-                     &fXform,
-                     renderingMode,
-                     fMeasuringMode,
-                     fGridFitMode,
-                     fAntiAliasMode,
-                     0.0f, // baselineOriginX,
-                     0.0f, // baselineOriginY,
-                     &glyphRunAnalysis),
-                 "Could not create DW2 glyph run analysis.");
-#endif
-        } else {
-            HRNM(fTypeface->fFactory->CreateGlyphRunAnalysis(&run,
-                     1.0f, // pixelsPerDip,
-                     &fXform,
-                     renderingMode,
-                     fMeasuringMode,
-                     0.0f, // baselineOriginX,
-                     0.0f, // baselineOriginY,
-                     &glyphRunAnalysis),
-                "Could not create glyph run analysis.");
-        }
+        HRM(fTypeface->fFactory->CreateGlyphRunAnalysis(
+            &run,
+            1.0f, // pixelsPerDip,
+            &fXform,
+            renderingMode,
+            fMeasuringMode,
+            0.0f, // baselineOriginX,
+            0.0f, // baselineOriginY,
+            &glyphRunAnalysis),
+            "Could not create glyph run analysis.");
     }
     {
         Shared l(DWriteFactoryMutex);
         HRM(glyphRunAnalysis->GetAlphaTextureBounds(textureType, bbox),
             "Could not get texture bounds.");
     }
     return S_OK;
 }
 
 /** GetAlphaTextureBounds succeeds but sometimes returns empty bounds like
@@ skipping 36 matching lines @@
     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 = fTypeface->fFactory2->TranslateColorGlyphRun(
+    HRESULT hr = fFactory2->TranslateColorGlyphRun(
         0, 0, &run, nullptr, fMeasuringMode, &fXform, 0, colorGlyph);
     if (hr == DWRITE_E_NOCOLOR) {
         return false;
     }
     HRBM(hr, "Failed to translate color glyph run");
     return true;
 }
 #endif
 
 void SkScalerContext_DW::generateMetrics(SkGlyph* glyph) {
@@ skipping 72 matching lines @@
         DWRITE_FONT_METRICS1 dwfm1;
         fTypeface->fDWriteFontFace1->GetMetrics(&dwfm1);
         metrics->fTop = -fTextSizeRender * SkIntToScalar(dwfm1.glyphBoxTop) / upem;
         metrics->fBottom = -fTextSizeRender * SkIntToScalar(dwfm1.glyphBoxBottom) / upem;
         metrics->fXMin = fTextSizeRender * SkIntToScalar(dwfm1.glyphBoxLeft) / upem;
         metrics->fXMax = fTextSizeRender * SkIntToScalar(dwfm1.glyphBoxRight) / upem;
 
         metrics->fMaxCharWidth = metrics->fXMax - metrics->fXMin;
         return;
     }
+#else
+#  pragma message("No dwrite_1.h is available, font metrics may be affected.")
 #endif
 
     AutoTDWriteTable<SkOTTableHead> head(fTypeface->fDWriteFontFace.get());
     if (head.fExists &&
         head.fSize >= sizeof(SkOTTableHead) &&
         head->version == SkOTTableHead::version1)
     {
         metrics->fTop = -fTextSizeRender * (int16_t)SkEndian_SwapBE16(head->yMax) / upem;
         metrics->fBottom = -fTextSizeRender * (int16_t)SkEndian_SwapBE16(head->yMin) / upem;
         metrics->fXMin = fTextSizeRender * (int16_t)SkEndian_SwapBE16(head->xMin) / upem;
@@ skipping 43 matching lines @@
                 mask >>= 1;
             }
             dst[byteCount] = byte;
         }
         src += bitCount;
         dst += dstRB;
     }
 }
 
 template<bool APPLY_PREBLEND>
-static void grayscale_to_a8(const uint8_t* SK_RESTRICT src, const SkGlyph& glyph,
-                            const uint8_t* table8) {
-    const size_t dstRB = glyph.rowBytes();
-    const U16CPU width = glyph.fWidth;
-    uint8_t* SK_RESTRICT dst = static_cast<uint8_t*>(glyph.fImage);
-
-    for (U16CPU y = 0; y < glyph.fHeight; y++) {
-        for (U16CPU i = 0; i < width; i++) {
-            U8CPU a = *(src++);
-            dst[i] = sk_apply_lut_if<APPLY_PREBLEND>(a, table8);
-        }
-        dst = SkTAddOffset<uint8_t>(dst, dstRB);
-    }
-}
-
-template<bool APPLY_PREBLEND>
 static void rgb_to_a8(const uint8_t* SK_RESTRICT src, const SkGlyph& glyph, const uint8_t* table8) {
     const size_t dstRB = glyph.rowBytes();
     const U16CPU width = glyph.fWidth;
     uint8_t* SK_RESTRICT dst = static_cast<uint8_t*>(glyph.fImage);
 
     for (U16CPU y = 0; y < glyph.fHeight; y++) {
         for (U16CPU i = 0; i < width; i++) {
             U8CPU r = *(src++);
             U8CPU g = *(src++);
             U8CPU b = *(src++);
             dst[i] = sk_apply_lut_if<APPLY_PREBLEND>((r + g + b) / 3, table8);
         }
-        dst = SkTAddOffset<uint8_t>(dst, dstRB);
+        dst = (uint8_t*)((char*)dst + dstRB);
     }
 }
 
 template<bool APPLY_PREBLEND, bool RGB>
 static void rgb_to_lcd16(const uint8_t* SK_RESTRICT src, const SkGlyph& glyph,
                          const uint8_t* tableR, const uint8_t* tableG, const uint8_t* tableB) {
     const size_t dstRB = glyph.rowBytes();
     const U16CPU width = glyph.fWidth;
     uint16_t* SK_RESTRICT dst = static_cast<uint16_t*>(glyph.fImage);
 
     for (U16CPU y = 0; y < glyph.fHeight; y++) {
         for (U16CPU i = 0; i < width; i++) {
             U8CPU r, g, b;
             if (RGB) {
                 r = sk_apply_lut_if<APPLY_PREBLEND>(*(src++), tableR);
                 g = sk_apply_lut_if<APPLY_PREBLEND>(*(src++), tableG);
                 b = sk_apply_lut_if<APPLY_PREBLEND>(*(src++), tableB);
             } else {
                 b = sk_apply_lut_if<APPLY_PREBLEND>(*(src++), tableB);
                 g = sk_apply_lut_if<APPLY_PREBLEND>(*(src++), tableG);
                 r = sk_apply_lut_if<APPLY_PREBLEND>(*(src++), tableR);
             }
             dst[i] = SkPack888ToRGB16(r, g, b);
         }
-        dst = SkTAddOffset<uint16_t>(dst, dstRB);
+        dst = (uint16_t*)((char*)dst + dstRB);
     }
 }
 
 const void* SkScalerContext_DW::drawDWMask(const SkGlyph& glyph,
                                            DWRITE_RENDERING_MODE renderingMode,
                                            DWRITE_TEXTURE_TYPE textureType)
 {
     int sizeNeeded = glyph.fWidth * glyph.fHeight;
-    if (DWRITE_TEXTURE_CLEARTYPE_3x1 == textureType) {
+    if (DWRITE_RENDERING_MODE_ALIASED != renderingMode) {
         sizeNeeded *= 3;
     }
     if (sizeNeeded > fBits.count()) {
         fBits.setCount(sizeNeeded);
     }
 
     // erase
     memset(fBits.begin(), 0, sizeNeeded);
 
     fXform.dx = SkFixedToFloat(glyph.getSubXFixed());
@@ skipping 10 matching lines @@
     DWRITE_GLYPH_RUN run;
     run.glyphCount = 1;
     run.glyphAdvances = &advance;
     run.fontFace = fTypeface->fDWriteFontFace.get();
     run.fontEmSize = SkScalarToFloat(fTextSizeRender);
     run.bidiLevel = 0;
     run.glyphIndices = &index;
     run.isSideways = FALSE;
     run.glyphOffsets = &offset;
     {
+
         SkTScopedComPtr<IDWriteGlyphRunAnalysis> glyphRunAnalysis;
         {
             SkAutoExclusive l(DWriteFactoryMutex);
-            if (fTypeface->fFactory2) {
-#if SK_HAS_DWRITE_2_H
-                HRNM(fTypeface->fFactory2->CreateGlyphRunAnalysis(&run,
-                         &fXform,
-                         renderingMode,
-                         fMeasuringMode,
-                         fGridFitMode,
-                         fAntiAliasMode,
-                         0.0f, // baselineOriginX,
-                         0.0f, // baselineOriginY,
-                         &glyphRunAnalysis),
-                     "Could not create DW2 glyph run analysis.");
-#endif
-            } else {
-                HRNM(fTypeface->fFactory->CreateGlyphRunAnalysis(&run,
-                         1.0f, // pixelsPerDip,
-                         &fXform,
-                         renderingMode,
-                         fMeasuringMode,
-                         0.0f, // baselineOriginX,
-                         0.0f, // baselineOriginY,
-                         &glyphRunAnalysis),
-                     "Could not create glyph run analysis.");
-            }
+            HRNM(fTypeface->fFactory->CreateGlyphRunAnalysis(&run,
+                1.0f, // pixelsPerDip,
+                &fXform,
+                renderingMode,
+                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;
         {
             Shared l(DWriteFactoryMutex);
@@ skipping 99 matching lines @@
         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);
         const_cast<SkGlyph&>(glyph).fMaskFormat = SkMask::kBW_Format;
     } else if (!isLCD(fRec)) {
-        if (textureType == DWRITE_TEXTURE_ALIASED_1x1) {
-            if (fPreBlend.isApplicable()) {
-                grayscale_to_a8<true>(src, glyph, fPreBlend.fG);
-            } else {
-                grayscale_to_a8<false>(src, glyph, fPreBlend.fG);
-            }
+        if (fPreBlend.isApplicable()) {
+            rgb_to_a8<true>(src, glyph, fPreBlend.fG);
         } else {
-            if (fPreBlend.isApplicable()) {
-                rgb_to_a8<true>(src, glyph, fPreBlend.fG);
-            } else {
-                rgb_to_a8<false>(src, glyph, fPreBlend.fG);
-            }
+            rgb_to_a8<false>(src, glyph, fPreBlend.fG);
         }
     } else {
         SkASSERT(SkMask::kLCD16_Format == glyph.fMaskFormat);
         if (fPreBlend.isApplicable()) {
             if (fRec.fFlags & SkScalerContext::kLCD_BGROrder_Flag) {
                 rgb_to_lcd16<true, false>(src, glyph, fPreBlend.fR, fPreBlend.fG, fPreBlend.fB);
             } else {
                 rgb_to_lcd16<true, true>(src, glyph, fPreBlend.fR, fPreBlend.fG, fPreBlend.fB);
             }
         } else {
@@ skipping 27 matching lines @@
             FALSE, //sideways
             FALSE, //rtl
             geometryToPath.get()),
             "Could not create glyph outline.");
     }
 
     path->transform(fSkXform);
 }
 
 #endif//defined(SK_BUILD_FOR_WIN32)