Alloc glyph image correctly for SkMask::k3D_Format.

Re-enable the code to test the emboss mask filter, updating it to use
the new emboss mask filter factory.

Add a test to ensure that embossed text is drawn correctly, as before
glyphs did not allocate the proper amount of memory for the k3D_Format
which the emboss mask filter produces.

Fixes SkEmbossMask::Emboss to write the whole of the mul and add planes
to avoid pixel differences and MemorySanitizer errors.

Update the GPU to understand the k3D_Format and use just the alpha
plane, ignoring the mul and add plane which it currently cannot support.

Change-Id: I90edf34a918c06b0c6b24bfc43ce7031419eca41
Reviewed-on: https://skia-review.googlesource.com/70260
Reviewed-on: https://skia-review.googlesource.com/70962
Reviewed-on: https://skia-review.googlesource.com/71282
Reviewed-by: Ben Wagner <bungeman@google.com>
Commit-Queue: Ben Wagner <bungeman@google.com>

7 files changed, 100 insertions, 69 deletions

diff --git a/gm/emboss.cpp b/gm/emboss.cpp
index c14c9d9278..a8483d0882 100644
--- a/gm/emboss.cpp
+++ b/gm/emboss.cpp
@@ -6,11 +6,11 @@
  */
 
 #include "gm.h"
-#include "SkBlurMaskFilter.h"
+#include "SkBlurMask.h"
 #include "SkCanvas.h"
 #include "SkColorFilter.h"
+#include "SkEmbossMaskFilter.h"
 
-#ifdef SK_SUPPORT_LEGACY_EMBOSSMASKFILTER
 static SkBitmap make_bm() {
     SkBitmap bm;
     bm.allocN32Pixels(100, 100);
@@ -41,17 +41,36 @@ protected:
         SkPaint paint;
         SkBitmap bm = make_bm();
         canvas->drawBitmap(bm, 10, 10, &paint);
-
-        const SkScalar dir[] = { 1, 1, 1 };
-        paint.setMaskFilter(SkBlurMaskFilter::MakeEmboss(3, dir, 0.3f, 0.1f));
         canvas->translate(bm.width() + SkIntToScalar(10), 0);
+
+        paint.setMaskFilter(SkEmbossMaskFilter::Make(
+            SkBlurMask::ConvertRadiusToSigma(3),
+            { { SK_Scalar1, SK_Scalar1, SK_Scalar1 }, 0, 128, 16*2 }));
         canvas->drawBitmap(bm, 10, 10, &paint);
+        canvas->translate(bm.width() + SkIntToScalar(10), 0);
 
         // this combination of emboss+colorfilter used to crash -- so we exercise it to
         // confirm that we have a fix.
         paint.setColorFilter(SkColorFilter::MakeModeFilter(0xFFFF0000, SkBlendMode::kSrcATop));
-        canvas->translate(bm.width() + SkIntToScalar(10), 0);
         canvas->drawBitmap(bm, 10, 10, &paint);
+        canvas->translate(bm.width() + SkIntToScalar(10), 0);
+
+        paint.setAntiAlias(true);
+        paint.setStyle(SkPaint::kStroke_Style);
+        paint.setStrokeWidth(SkIntToScalar(10));
+        paint.setMaskFilter(SkEmbossMaskFilter::Make(
+            SkBlurMask::ConvertRadiusToSigma(4),
+            { { SK_Scalar1, SK_Scalar1, SK_Scalar1 }, 0, 128, 16*2 }));
+        paint.setColorFilter(nullptr);
+        paint.setShader(SkShader::MakeColorShader(SK_ColorBLUE));
+        paint.setDither(true);
+        canvas->drawCircle(SkIntToScalar(50), SkIntToScalar(50),
+                           SkIntToScalar(30), paint);
+        canvas->translate(SkIntToScalar(100), 0);
+
+        paint.setStyle(SkPaint::kFill_Style);
+        paint.setTextSize(50);
+        canvas->drawText("Hello", 5, 0, 50, paint);
     }
 
 private:
@@ -59,4 +78,3 @@ private:
 };
 
 DEF_GM(return new EmbossGM;)
-#endif
diff --git a/samplecode/SampleAll.cpp b/samplecode/SampleAll.cpp
index e1b85934b1..ea7d508979 100644
--- a/samplecode/SampleAll.cpp
+++ b/samplecode/SampleAll.cpp
@@ -208,13 +208,10 @@ static void apply_shader(SkPaint* paint, int index) {
         paint->setRasterizer(rastBuilder.detach());
     }
 
-#ifdef SK_SUPPORT_LEGACY_EMBOSSMASKFILTER
-    SkScalar dir[] = { SK_Scalar1, SK_Scalar1, SK_Scalar1 };
-    paint->setMaskFilter(SkBlurMaskFilter::MakeEmboss(
-                SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(3)), dir,
-                SK_Scalar1/4, SkIntToScalar(4)));
+    paint->setMaskFilter(SkEmbossMaskFilter::Make(
+                SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(3)),
+                { { SK_Scalar1, SK_Scalar1, SK_Scalar1 }, 0, 128, 16*2 }));
     paint->setColor(SK_ColorBLUE);
-#endif
 }
 
 class DemoView : public SampleView {
diff --git a/samplecode/SampleEffects.cpp b/samplecode/SampleEffects.cpp
index 8c6793eb67..49654983da 100644
--- a/samplecode/SampleEffects.cpp
+++ b/samplecode/SampleEffects.cpp
@@ -10,6 +10,7 @@
 #include "SkCanvas.h"
 #include "SkColorMatrixFilter.h"
 #include "SkDiscretePathEffect.h"
+#include "SkEmbossMaskFilter.h"
 #include "SkGradientShader.h"
 #include "SkPaint.h"
 #include "SkView.h"
@@ -28,11 +29,9 @@ static void paint_proc1(SkPaint* paint) {
 }
 
 static void paint_proc2(SkPaint* paint) {
-#ifdef SK_SUPPORT_LEGACY_EMBOSSMASKFILTER
-    SkScalar dir[3] = { 1, 1, 1};
-    paint->setMaskFilter(
-            SkBlurMaskFilter::MakeEmboss(SkBlurMask::ConvertRadiusToSigma(1), dir, 0.1f, 0.05f));
-#endif
+    paint->setMaskFilter(SkEmbossMaskFilter::Make(
+            SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(1)),
+            { { SK_Scalar1, SK_Scalar1, SK_Scalar1 }, 0, 64, 16 }));
 }
 
 static void paint_proc3(SkPaint* paint) {
diff --git a/src/core/SkGlyph.h b/src/core/SkGlyph.h
index 06c1d76fb3..b54635277b 100644
--- a/src/core/SkGlyph.h
+++ b/src/core/SkGlyph.h
@@ -172,34 +172,57 @@ public:
      */
     static unsigned ComputeRowBytes(unsigned width, SkMask::Format format) {
         unsigned rb = width;
-        if (SkMask::kBW_Format == format) {
+        switch (format) {
+        case SkMask::kBW_Format:
             rb = BitsToBytes(rb);
-        } else if (SkMask::kARGB32_Format == format) {
+            break;
+        case SkMask::kA8_Format:
+            rb = SkAlign4(rb);
+            break;
+        case SkMask::k3D_Format:
+            rb = SkAlign4(rb);
+            break;
+        case SkMask::kARGB32_Format:
             rb <<= 2;
-        } else if (SkMask::kLCD16_Format == format) {
+            break;
+        case SkMask::kLCD16_Format:
             rb = SkAlign4(rb << 1);
-        } else {
-            rb = SkAlign4(rb);
+            break;
+        default:
+            SK_ABORT("Unknown mask format.");
+            break;
         }
         return rb;
     }
 
     size_t allocImage(SkArenaAlloc* alloc) {
         size_t allocSize;
-        if (SkMask::kBW_Format == fMaskFormat) {
+        switch (static_cast<SkMask::Format>(fMaskFormat)) {
+        case SkMask::kBW_Format:
             allocSize = BitsToBytes(fWidth) * fHeight;
             fImage = alloc->makeArrayDefault<char>(allocSize);
-        } else if (SkMask::kARGB32_Format == fMaskFormat) {
+            break;
+        case SkMask::kA8_Format:
+            allocSize = SkAlign4(fWidth) * fHeight;
+            fImage = alloc->makeArrayDefault<char>(allocSize);
+            break;
+        case SkMask::k3D_Format:
+            allocSize = SkAlign4(fWidth) * fHeight * 3;
+            fImage = alloc->makeArrayDefault<char>(allocSize);
+            break;
+        case SkMask::kARGB32_Format:
             allocSize = fWidth * fHeight;
             fImage = alloc->makeArrayDefault<uint32_t>(fWidth * fHeight);
             allocSize *= sizeof(uint32_t);
-        } else if (SkMask::kLCD16_Format == fMaskFormat) {
+            break;
+        case SkMask::kLCD16_Format:
             allocSize = SkAlign2(fWidth) * fHeight;
             fImage = alloc->makeArrayDefault<uint16_t>(allocSize);
             allocSize *= sizeof(uint16_t);
-        } else {
-            allocSize = SkAlign4(fWidth) * fHeight;
-            fImage = alloc->makeArrayDefault<char>(allocSize);
+            break;
+        default:
+            SK_ABORT("Unknown mask format.");
+            break;
         }
         return allocSize;
     }
diff --git a/src/core/SkScalerContext.cpp b/src/core/SkScalerContext.cpp
index 8a1ab60ae8..828f978287 100644
--- a/src/core/SkScalerContext.cpp
+++ b/src/core/SkScalerContext.cpp
@@ -26,8 +26,6 @@
 #include "SkStrokeRec.h"
 #include "SkWriteBuffer.h"
 
-#define ComputeBWRowBytes(width)        (((unsigned)(width) + 7) >> 3)
-
 void SkGlyph::toMask(SkMask* mask) const {
     SkASSERT(mask);
 
diff --git a/src/effects/SkEmbossMask.cpp b/src/effects/SkEmbossMask.cpp
index c73d0c8406..e081186564 100644
--- a/src/effects/SkEmbossMask.cpp
+++ b/src/effects/SkEmbossMask.cpp
@@ -68,47 +68,41 @@ void SkEmbossMask::Emboss(SkMask* mask, const SkEmbossMaskFilter::Light& light)
         int next_row = neq_to_mask(y, maxy) & rowBytes;
 
         for (int x = 0; x <= maxx; x++) {
-            if (alpha[x]) {
-                int nx = alpha[x + neq_to_one(x, maxx)] - alpha[x - nonzero_to_one(x)];
-                int ny = alpha[x + next_row] - alpha[x - prev_row];
-
-                SkFixed numer = lx * nx + ly * ny + lz_dot_nz;
-                int     mul = ambient;
-                int     add = 0;
-
-                if (numer > 0) {  // preflight when numer/denom will be <= 0
-                    int denom = SkSqrt32(nx * nx + ny * ny + kDelta*kDelta);
-                    SkFixed dot = numer / denom;
-                    dot >>= 8;  // now dot is 2^8 instead of 2^16
-                    mul = SkFastMin32(mul + dot, 255);
-
-                    // now for the reflection
-
-                    //  R = 2 (Light * Normal) Normal - Light
-                    //  hilite = R * Eye(0, 0, 1)
-
-                    int hilite = (2 * dot - lz_dot8) * lz_dot8 >> 8;
-                    if (hilite > 0) {
-                        // pin hilite to 255, since our fast math is also a little sloppy
-                        hilite = SkClampMax(hilite, 255);
-
-                        // specular is 4.4
-                        // would really like to compute the fractional part of this
-                        // and then possibly cache a 256 table for a given specular
-                        // value in the light, and just pass that in to this function.
-                        add = hilite;
-                        for (int i = specular >> 4; i > 0; --i) {
-                            add = div255(add * hilite);
-                        }
+            int nx = alpha[x + neq_to_one(x, maxx)] - alpha[x - nonzero_to_one(x)];
+            int ny = alpha[x + next_row] - alpha[x - prev_row];
+
+            SkFixed numer = lx * nx + ly * ny + lz_dot_nz;
+            int     mul = ambient;
+            int     add = 0;
+
+            if (numer > 0) {  // preflight when numer/denom will be <= 0
+                int denom = SkSqrt32(nx * nx + ny * ny + kDelta*kDelta);
+                SkFixed dot = numer / denom;
+                dot >>= 8;  // now dot is 2^8 instead of 2^16
+                mul = SkFastMin32(mul + dot, 255);
+
+                // now for the reflection
+
+                //  R = 2 (Light * Normal) Normal - Light
+                //  hilite = R * Eye(0, 0, 1)
+
+                int hilite = (2 * dot - lz_dot8) * lz_dot8 >> 8;
+                if (hilite > 0) {
+                    // pin hilite to 255, since our fast math is also a little sloppy
+                    hilite = SkClampMax(hilite, 255);
+
+                    // specular is 4.4
+                    // would really like to compute the fractional part of this
+                    // and then possibly cache a 256 table for a given specular
+                    // value in the light, and just pass that in to this function.
+                    add = hilite;
+                    for (int i = specular >> 4; i > 0; --i) {
+                        add = div255(add * hilite);
                     }
                 }
-                multiply[x] = SkToU8(mul);
-                additive[x] = SkToU8(add);
-
-            //  multiply[x] = 0xFF;
-            //  additive[x] = 0;
-            //  ((uint8_t*)alpha)[x] = alpha[x] * multiply[x] >> 8;
             }
+            multiply[x] = SkToU8(mul);
+            additive[x] = SkToU8(add);
         }
         alpha += rowBytes;
         multiply += rowBytes;
diff --git a/src/gpu/text/GrAtlasGlyphCache.cpp b/src/gpu/text/GrAtlasGlyphCache.cpp
index 80f4314b91..421160f28f 100644
--- a/src/gpu/text/GrAtlasGlyphCache.cpp
+++ b/src/gpu/text/GrAtlasGlyphCache.cpp
@@ -213,6 +213,8 @@ static inline GrMaskFormat get_packed_glyph_mask_format(const SkGlyph& glyph) {
             // fall through to kA8 -- we store BW glyphs in our 8-bit cache
         case SkMask::kA8_Format:
             return kA8_GrMaskFormat;
+        case SkMask::k3D_Format:
+            return kA8_GrMaskFormat; // ignore the mul and add planes, just use the mask
         case SkMask::kLCD16_Format:
             return kA565_GrMaskFormat;
         case SkMask::kARGB32_Format: