AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Revert "Alloc glyph image correctly for SkMask::k3D_Format."

Browse Source 
This reverts commit 6b26deb8d6.

Reason for revert: GPU bots failing

Original change's description:
> Alloc glyph image correctly for SkMask::k3D_Format.
> 
> This removes the no longer used outside Skia
> SK_SUPPORT_LEGACY_EMBOSSMASKFILTER define, and either deletes the code
> it guards or updates it to use the new emboss mask filter factory. This
> re-enables the code to test the emboss mask filter. Also added is a test
> to ensure that embossed text is drawn correctly, as before this glyphs
> did not allocate the proper amount of memory for the k3D_Format which
> this mask filter produces. This also fixes SkEmbossMask::Emboss to write
> the whole of the mul and add planes to avoid pixel differences and
> MemorySanitizer errors.
> 
> Change-Id: Ib492c72a19d6a27d140e3cd48179a3ca9ce313f5
> Reviewed-on: https://skia-review.googlesource.com/70260
> Commit-Queue: Ben Wagner <bungeman@google.com>
> Reviewed-by: Herb Derby <herb@google.com>

TBR=djsollen@google.com,bungeman@google.com,herb@google.com,reed@google.com

Change-Id: I8a9db6c00e0cb84bdd4833474a9ffffa6ecc606c
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://skia-review.googlesource.com/70920
Reviewed-by: Ben Wagner <bungeman@google.com>
Commit-Queue: Ben Wagner <bungeman@google.com>
This commit is contained in:
Ben Wagner 2017-11-13 20:41:14 +00:00 committed by Skia Commit-Bot
parent 5254ccc181
commit 3ae1a307f6
8 changed files with 96 additions and 92 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
gm/emboss.cpp
View File

@ -6,11 +6,11 @@
*/
#include "gm.h"
#include "SkBlurMask.h"
#include "SkBlurMaskFilter.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,36 +41,17 @@ protected:
SkPaint paint;
SkBitmap bm = make_bm();
canvas->drawBitmap(bm, 10, 10, &paint);
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);
const SkScalar dir[] = { 1, 1, 1 };
paint.setMaskFilter(SkBlurMaskFilter::MakeEmboss(3, dir, 0.3f, 0.1f));
canvas->translate(bm.width() + SkIntToScalar(10), 0);
canvas->drawBitmap(bm, 10, 10, &paint);
// 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->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);
canvas->drawBitmap(bm, 10, 10, &paint);
}
private:
@ -78,3 +59,4 @@ private:
};
DEF_GM(return new EmbossGM;)
#endif

13
include/effects/SkBlurMaskFilter.h
View File

@ -48,6 +48,19 @@ public:
return Make(style, sigma, SkRect::MakeEmpty(), flags);
}
#ifdef SK_SUPPORT_LEGACY_EMBOSSMASKFILTER
/** Create an emboss maskfilter
@param blurSigma standard deviation of the Gaussian blur to apply
before applying lighting (e.g. 3)
@param direction array of 3 scalars [x, y, z] specifying the direction of the light source
@param ambient 0...1 amount of ambient light
@param specular coefficient for specular highlights (e.g. 8)
@return the emboss maskfilter
*/
static sk_sp<SkMaskFilter> MakeEmboss(SkScalar blurSigma, const SkScalar direction[3],
SkScalar ambient, SkScalar specular);
#endif
static const int kMaxDivisions = 6;
// This method computes all the parameters for drawing a partially occluded nine-patched

9
samplecode/SampleAll.cpp
View File

@ -208,10 +208,13 @@ static void apply_shader(SkPaint* paint, int index) {
paint->setRasterizer(rastBuilder.detach());
}
paint->setMaskFilter(SkEmbossMaskFilter::Make(
SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(3)),
{ { SK_Scalar1, SK_Scalar1, SK_Scalar1 }, 0, 128, 16*2 }));
#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->setColor(SK_ColorBLUE);
#endif
}
class DemoView : public SampleView {

9
samplecode/SampleEffects.cpp
View File

@ -10,7 +10,6 @@
#include "SkCanvas.h"
#include "SkColorMatrixFilter.h"
#include "SkDiscretePathEffect.h"
#include "SkEmbossMaskFilter.h"
#include "SkGradientShader.h"
#include "SkPaint.h"
#include "SkView.h"
@ -29,9 +28,11 @@ static void paint_proc1(SkPaint* paint) {
}
static void paint_proc2(SkPaint* paint) {
paint->setMaskFilter(SkEmbossMaskFilter::Make(
SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(1)),
{ { SK_Scalar1, SK_Scalar1, SK_Scalar1 }, 0, 64, 16 }));
#ifdef SK_SUPPORT_LEGACY_EMBOSSMASKFILTER
SkScalar dir[3] = { 1, 1, 1};
paint->setMaskFilter(
SkBlurMaskFilter::MakeEmboss(SkBlurMask::ConvertRadiusToSigma(1), dir, 0.1f, 0.05f));
#endif
}
static void paint_proc3(SkPaint* paint) {

45
src/core/SkGlyph.h
View File

@ -172,57 +172,34 @@ public:
*/
static unsigned ComputeRowBytes(unsigned width, SkMask::Format format) {
unsigned rb = width;
switch (format) {
case SkMask::kBW_Format:
if (SkMask::kBW_Format == format) {
rb = BitsToBytes(rb);
break;
case SkMask::kA8_Format:
rb = SkAlign4(rb);
break;
case SkMask::k3D_Format:
rb = SkAlign4(rb);
break;
case SkMask::kARGB32_Format:
} else if (SkMask::kARGB32_Format == format) {
rb <<= 2;
break;
case SkMask::kLCD16_Format:
} else if (SkMask::kLCD16_Format == format) {
rb = SkAlign4(rb << 1);
break;
default:
SK_ABORT("Unknown mask format.");
break;
} else {
rb = SkAlign4(rb);
}
return rb;
}
size_t allocImage(SkArenaAlloc* alloc) {
size_t allocSize;
switch (static_cast<SkMask::Format>(fMaskFormat)) {
case SkMask::kBW_Format:
if (SkMask::kBW_Format == fMaskFormat) {
allocSize = BitsToBytes(fWidth) * fHeight;
fImage = alloc->makeArrayDefault<char>(allocSize);
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:
} else if (SkMask::kARGB32_Format == fMaskFormat) {
allocSize = fWidth * fHeight;
fImage = alloc->makeArrayDefault<uint32_t>(fWidth * fHeight);
allocSize *= sizeof(uint32_t);
break;
case SkMask::kLCD16_Format:
} else if (SkMask::kLCD16_Format == fMaskFormat) {
allocSize = SkAlign2(fWidth) * fHeight;
fImage = alloc->makeArrayDefault<uint16_t>(allocSize);
allocSize *= sizeof(uint16_t);
break;
default:
SK_ABORT("Unknown mask format.");
break;
} else {
allocSize = SkAlign4(fWidth) * fHeight;
fImage = alloc->makeArrayDefault<char>(allocSize);
}
return allocSize;
}

2
src/core/SkScalerContext.cpp
View File

@ -26,6 +26,8 @@
#include "SkStrokeRec.h"
#include "SkWriteBuffer.h"
#define ComputeBWRowBytes(width) (((unsigned)(width) + 7) >> 3)
void SkGlyph::toMask(SkMask* mask) const {
SkASSERT(mask);

58
src/effects/SkEmbossMask.cpp
View File

@ -68,41 +68,47 @@ 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++) {
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];
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;
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);
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
// now for the reflection
// R = 2 (Light * Normal) Normal - Light
// hilite = R * Eye(0, 0, 1)
// 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);
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);
// 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;

20
src/effects/SkEmbossMaskFilter.cpp
View File

@ -17,6 +17,26 @@ sk_sp<SkMaskFilter> SkEmbossMaskFilter::Make(SkScalar blurSigma, const Light& li
return sk_sp<SkMaskFilter>(new SkEmbossMaskFilter(blurSigma, light));
}
#ifdef SK_SUPPORT_LEGACY_EMBOSSMASKFILTER
sk_sp<SkMaskFilter> SkBlurMaskFilter::MakeEmboss(SkScalar blurSigma, const SkScalar direction[3],
SkScalar ambient, SkScalar specular) {
if (direction == nullptr) {
return nullptr;
}
SkEmbossMaskFilter::Light light;
memcpy(light.fDirection, direction, sizeof(light.fDirection));
// ambient should be 0...1 as a scalar
light.fAmbient = SkUnitScalarClampToByte(ambient);
// specular should be 0..15.99 as a scalar
static const SkScalar kSpecularMultiplier = SkIntToScalar(255) / 16;
light.fSpecular = static_cast<U8CPU>(SkScalarPin(specular, 0, 16) * kSpecularMultiplier + 0.5);
return SkEmbossMaskFilter::Make(blurSigma, light);
}
#endif
///////////////////////////////////////////////////////////////////////////////
static void normalize(SkScalar v[3]) {