DirectWrite to use aliased if ClearType is empty.

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"
 #undef GetGlyphIndices
 
@@ skipping 380 matching lines @@
         vecs[0].fX = SkScalarRoundToScalar(advanceX);
         fG_inv.mapVectors(vecs, SK_ARRAY_COUNT(vecs));
     } else {
         fSkXform.mapVectors(vecs, SK_ARRAY_COUNT(vecs));
     }
 
     glyph->fAdvanceX = SkScalarToFixed(vecs[0].fX);
     glyph->fAdvanceY = SkScalarToFixed(vecs[0].fY);
 }
 
-void SkScalerContext_DW::generateMetrics(SkGlyph* glyph) {
-    glyph->fWidth = 0;
-
-    this->generateAdvance(glyph);
-
+void SkScalerContext_DW::getBoundingBox(SkGlyph* glyph,
+                                        DWRITE_RENDERING_MODE renderingMode,
+                                        DWRITE_TEXTURE_TYPE textureType,
+                                        RECT* bbox)
+{
     //Measure raster size.
     fXform.dx = SkFixedToFloat(glyph->getSubXFixed());
     fXform.dy = SkFixedToFloat(glyph->getSubYFixed());
 
     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;
 
     SkTScopedComPtr<IDWriteGlyphRunAnalysis> glyphRunAnalysis;
     HRVM(fTypeface->fFactory->CreateGlyphRunAnalysis(
              &run,
              1.0f, // pixelsPerDip,
              &fXform,
-             fRenderingMode,
+             renderingMode,
              fMeasuringMode,
              0.0f, // baselineOriginX,
              0.0f, // baselineOriginY,
              &glyphRunAnalysis),
          "Could not create glyph run analysis.");
 
+    HRVM(glyphRunAnalysis->GetAlphaTextureBounds(textureType, bbox),
+         "Could not get texture bounds.");
+}
+
+void SkScalerContext_DW::generateMetrics(SkGlyph* glyph) {
+    glyph->fWidth = 0;
+
+    this->generateAdvance(glyph);
+
     RECT bbox;
-    HRVM(glyphRunAnalysis->GetAlphaTextureBounds(fTextureType, &bbox),
-         "Could not get texture bounds.");
+    this->getBoundingBox(glyph, fRenderingMode, fTextureType, &bbox);
+
+    // GetAlphaTextureBounds succeeds but returns an empty RECT if there are no
+    // glyphs of the specified texture type. When this happens, try with the
+    // alternate texture type.
+    if (bbox.left == bbox.right || bbox.top == bbox.bottom) {
+        if (DWRITE_TEXTURE_CLEARTYPE_3x1 == fTextureType) {
+            this->getBoundingBox(glyph,
+                                 DWRITE_RENDERING_MODE_ALIASED,
+                                 DWRITE_TEXTURE_ALIASED_1x1,
+                                 &bbox);
+            if (bbox.left != bbox.right && bbox.top != bbox.bottom) {
+                glyph->fForceBW = 1;
+            }
+        }
+        // TODO: handle the case where a request for DWRITE_TEXTURE_ALIASED_1x1
+        // fails, and try DWRITE_TEXTURE_CLEARTYPE_3x1.
+    }
 
     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* metrics) {
     if (NULL == metrics) {
         return;
@@ skipping 142 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) {
+const void* SkScalerContext_DW::drawDWMask(const SkGlyph& glyph,
+                                           DWRITE_RENDERING_MODE renderingMode,
+                                           DWRITE_TEXTURE_TYPE textureType)
+{
     int sizeNeeded = glyph.fWidth * glyph.fHeight;
-    if (DWRITE_RENDERING_MODE_ALIASED != fRenderingMode) {
+    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 14 matching lines @@
     run.fontEmSize = SkScalarToFloat(fTextSizeRender);
     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,
+                                          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;
-    HRNM(glyphRunAnalysis->CreateAlphaTexture(fTextureType,
+    HRNM(glyphRunAnalysis->CreateAlphaTexture(textureType,
                                               &bbox,
                                               fBits.begin(),
                                               sizeNeeded),
          "Could not draw mask.");
     return fBits.begin();
 }
 
 void SkScalerContext_DW::generateImage(const SkGlyph& glyph) {
     //Create the mask.
-    const void* bits = this->drawDWMask(glyph);
+    DWRITE_RENDERING_MODE renderingMode = fRenderingMode;
+    DWRITE_TEXTURE_TYPE textureType = fTextureType;
+    if (glyph.fForceBW) {
+        renderingMode = DWRITE_RENDERING_MODE_ALIASED;
+        textureType = DWRITE_TEXTURE_ALIASED_1x1;
+    }
+    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 == fRenderingMode) {
+    if (DWRITE_RENDERING_MODE_ALIASED == renderingMode) {
         bilevel_to_bw(src, glyph);
         const_cast<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()) {
@@ skipping 27 matching lines @@
                                        NULL, //advances
                                        NULL, //offsets
                                        1, //num glyphs
                                        FALSE, //sideways
                                        FALSE, //rtl
                                        geometryToPath.get()),
          "Could not create glyph outline.");
 
     path->transform(fSkXform);
 }