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

Use rasterpipeline for drawVertices

Browse Source 
Bug: skia:
Change-Id: If6da119ee98f26981cef9373162ddb526db77be5
Reviewed-on: https://skia-review.googlesource.com/17422
Commit-Queue: Mike Reed <reed@google.com>
Reviewed-by: Florin Malita <fmalita@chromium.org>
Reviewed-by: Mike Klein <mtklein@google.com>
This commit is contained in:
Mike Reed 2017-05-24 13:53:36 -04:00 committed by Skia Commit-Bot
parent f6ca16e6ec
commit 176f19cce5
2 changed files with 114 additions and 403 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

488
src/core/SkDraw_vertices.cpp
View File

@ -7,7 +7,7 @@
#include "SkArenaAlloc.h"
#include "SkAutoBlitterChoose.h"
#include "SkColorShader.h"
#include "SkComposeShader.h"
#include "SkDraw.h"
#include "SkNx.h"
#include "SkPM4fPriv.h"
@ -17,7 +17,6 @@
#include "SkString.h"
#include "SkVertState.h"
#include "SkRasterPipeline.h"
#include "SkArenaAlloc.h"
#include "SkCoreBlitters.h"
#include "SkColorSpaceXform.h"
@ -72,188 +71,40 @@ static bool texture_to_matrix(const VertState& state, const SkPoint verts[],
class SkTriColorShader : public SkShader {
public:
SkTriColorShader();
SkTriColorShader(bool isOpaque) : fIsOpaque(isOpaque) {}
class TriColorShaderContext : public SkShader::Context {
public:
TriColorShaderContext(const SkTriColorShader& shader, const ContextRec&);
~TriColorShaderContext() override;
void shadeSpan(int x, int y, SkPMColor dstC[], int count) override;
void shadeSpan4f(int x, int y, SkPM4f dstC[], int count) override;
Matrix43* getMatrix43() { return &fM43; }
private:
bool setup(const SkPoint pts[], const SkColor colors[], int, int, int);
SkMatrix fDstToUnit;
SkPMColor fColors[3];
bool fSetup;
Matrix43 fM43;
typedef SkShader::Context INHERITED;
};
struct TriColorShaderData {
const SkPoint* pts;
const SkColor* colors;
const VertState *state;
};
bool isOpaque() const override { return fIsOpaque; }
SK_TO_STRING_OVERRIDE()
// For serialization. This will never be called.
Factory getFactory() const override { sk_throw(); return nullptr; }
// Supply setup data to context from drawing setup
void bindSetupData(TriColorShaderData* setupData) { fSetupData = setupData; }
// Take the setup data from context when needed.
TriColorShaderData* takeSetupData() {
TriColorShaderData *data = fSetupData;
fSetupData = NULL;
return data;
}
protected:
Context* onMakeContext(const ContextRec& rec, SkArenaAlloc* alloc) const override {
return alloc->make<TriColorShaderContext>(*this, rec);
return nullptr;
}
bool onAppendStages(SkRasterPipeline* pipeine, SkColorSpace* dstCS, SkArenaAlloc* alloc,
const SkMatrix&, const SkPaint&, const SkMatrix*) const override {
pipeine->append(SkRasterPipeline::matrix_4x3, &fM43);
// In theory we should never need to clamp. However, either due to imprecision in our
// matrix43, or the scan converter passing us pixel centers that in fact are not within
// the triangle, we do see occasional (slightly) out-of-range values, so we add these
// clamp stages. It would be nice to find a way to detect when these are not needed.
pipeine->append(SkRasterPipeline::clamp_0);
pipeine->append(SkRasterPipeline::clamp_a);
return true;
}
private:
TriColorShaderData *fSetupData;
Matrix43 fM43;
const bool fIsOpaque;
typedef SkShader INHERITED;
};
bool SkTriColorShader::TriColorShaderContext::setup(const SkPoint pts[], const SkColor colors[],
int index0, int index1, int index2) {
fColors[0] = SkPreMultiplyColor(colors[index0]);
fColors[1] = SkPreMultiplyColor(colors[index1]);
fColors[2] = SkPreMultiplyColor(colors[index2]);
SkMatrix m, im;
m.reset();
m.set(0, pts[index1].fX - pts[index0].fX);
m.set(1, pts[index2].fX - pts[index0].fX);
m.set(2, pts[index0].fX);
m.set(3, pts[index1].fY - pts[index0].fY);
m.set(4, pts[index2].fY - pts[index0].fY);
m.set(5, pts[index0].fY);
if (!m.invert(&im)) {
return false;
}
// We can't call getTotalInverse(), because we explicitly don't want to look at the localmatrix
// as our interators are intrinsically tied to the vertices, and nothing else.
SkMatrix ctmInv;
if (!this->getCTM().invert(&ctmInv)) {
return false;
}
// TODO replace INV(m) * INV(ctm) with INV(ctm * m)
fDstToUnit.setConcat(im, ctmInv);
Sk4f alpha(this->getPaintAlpha() * (1.0f / 255)),
c0 = SkPM4f::FromPMColor(fColors[0]).to4f() * alpha,
c1 = SkPM4f::FromPMColor(fColors[1]).to4f() * alpha,
c2 = SkPM4f::FromPMColor(fColors[2]).to4f() * alpha;
Matrix43 colorm;
(c1 - c0).store(&colorm.fMat[0]);
(c2 - c0).store(&colorm.fMat[4]);
c0.store(&colorm.fMat[8]);
fM43.setConcat(colorm, fDstToUnit);
return true;
}
#include "SkColorPriv.h"
#include "SkComposeShader.h"
static int ScalarTo256(SkScalar v) {
return static_cast<int>(SkScalarPin(v, 0, 1) * 256 + 0.5);
}
SkTriColorShader::SkTriColorShader()
: INHERITED(NULL)
, fSetupData(NULL) {}
SkTriColorShader::TriColorShaderContext::TriColorShaderContext(const SkTriColorShader& shader,
const ContextRec& rec)
: INHERITED(shader, rec)
, fSetup(false) {}
SkTriColorShader::TriColorShaderContext::~TriColorShaderContext() {}
void SkTriColorShader::TriColorShaderContext::shadeSpan(int x, int y, SkPMColor dstC[], int count) {
SkTriColorShader* parent = static_cast<SkTriColorShader*>(const_cast<SkShader*>(&fShader));
TriColorShaderData* set = parent->takeSetupData();
if (set) {
fSetup = setup(set->pts, set->colors, set->state->f0, set->state->f1, set->state->f2);
}
if (!fSetup) {
// Invalid matrices. Not checked before so no need to assert.
return;
}
const int alphaScale = Sk255To256(this->getPaintAlpha());
SkPoint src;
fDstToUnit.mapXY(SkIntToScalar(x) + 0.5, SkIntToScalar(y) + 0.5, &src);
for (int i = 0; i < count; i++) {
int scale1 = ScalarTo256(src.fX);
int scale2 = ScalarTo256(src.fY);
int scale0 = 256 - scale1 - scale2;
if (scale0 < 0) {
if (scale1 > scale2) {
scale2 = 256 - scale1;
} else {
scale1 = 256 - scale2;
}
scale0 = 0;
}
if (256 != alphaScale) {
scale0 = SkAlphaMul(scale0, alphaScale);
scale1 = SkAlphaMul(scale1, alphaScale);
scale2 = SkAlphaMul(scale2, alphaScale);
}
dstC[i] = SkAlphaMulQ(fColors[0], scale0) +
SkAlphaMulQ(fColors[1], scale1) +
SkAlphaMulQ(fColors[2], scale2);
src.fX += fDstToUnit.getScaleX();
src.fY += fDstToUnit.getSkewY();
}
}
void SkTriColorShader::TriColorShaderContext::shadeSpan4f(int x, int y, SkPM4f dstC[], int count) {
SkTriColorShader* parent = static_cast<SkTriColorShader*>(const_cast<SkShader*>(&fShader));
TriColorShaderData* set = parent->takeSetupData();
if (set) {
fSetup = setup(set->pts, set->colors, set->state->f0, set->state->f1, set->state->f2);
}
if (!fSetup) {
// Invalid matrices. Not checked before so no need to assert.
return;
}
Sk4f c = fM43.map(SkIntToScalar(x) + 0.5, SkIntToScalar(y) + 0.5),
dc = Sk4f::Load(&fM43.fMat[0]),
zero(0.0f),
one(1.0f);
for (int i = 0; i < count; i++) {
// We don't expect to be wildly out of 0...1, but we pin just because of minor
// numerical imprecision.
Sk4f::Min(Sk4f::Max(c, zero), Sk4f::Min(c[3], one)).store(dstC + i);
c += dc;
}
}
#ifndef SK_IGNORE_TO_STRING
void SkTriColorShader::toString(SkString* str) const {
str->append("SkTriColorShader: (");
@ -264,106 +115,6 @@ void SkTriColorShader::toString(SkString* str) const {
}
#endif
namespace {
// Similar to SkLocalMatrixShader, but composes the local matrix with the CTM (instead
// of composing with the inherited local matrix):
//
// rec' = {rec.ctm x localMatrix, rec.localMatrix}
//
// (as opposed to rec' = {rec.ctm, rec.localMatrix x localMatrix})
//
class SkLocalInnerMatrixShader final : public SkShader {
public:
SkLocalInnerMatrixShader(sk_sp<SkShader> proxy, const SkMatrix& localMatrix)
: INHERITED(&localMatrix)
, fProxyShader(std::move(proxy)) {}
Factory getFactory() const override {
SkASSERT(false);
return nullptr;
}
protected:
void flatten(SkWriteBuffer&) const override {
SkASSERT(false);
}
Context* onMakeContext(const ContextRec& rec, SkArenaAlloc* alloc) const override {
SkMatrix adjustedCTM = SkMatrix::Concat(*rec.fMatrix, this->getLocalMatrix());
ContextRec newRec(rec);
newRec.fMatrix = &adjustedCTM;
return fProxyShader->makeContext(newRec, alloc);
}
bool onAppendStages(SkRasterPipeline* p, SkColorSpace* cs, SkArenaAlloc* alloc,
const SkMatrix& ctm, const SkPaint& paint,
const SkMatrix* localM) const override {
// We control the shader graph ancestors, so we know there's no local matrix being
// injected before this.
SkASSERT(!localM);
SkMatrix adjustedCTM = SkMatrix::Concat(ctm, this->getLocalMatrix());
return fProxyShader->appendStages(p, cs, alloc, adjustedCTM, paint);
}
private:
sk_sp<SkShader> fProxyShader;
typedef SkShader INHERITED;
};
sk_sp<SkShader> MakeTextureShader(const VertState& state, const SkPoint verts[],
const SkPoint texs[], const SkPaint& paint,
SkColorSpace* dstColorSpace,
SkArenaAlloc* alloc) {
SkASSERT(paint.getShader());
const auto& p0 = texs[state.f0],
p1 = texs[state.f1],
p2 = texs[state.f2];
if (p0 != p1 || p0 != p2) {
// Common case (non-collapsed texture coordinates).
// Map the texture to vertices using a local transform.
// We cannot use a plain SkLocalMatrix shader, because we need the texture matrix
// to compose next to the CTM.
SkMatrix localMatrix;
return texture_to_matrix(state, verts, texs, &localMatrix)
? alloc->makeSkSp<SkLocalInnerMatrixShader>(paint.refShader(), localMatrix)
: nullptr;
}
// Collapsed texture coordinates special case.
// The texture is a solid color, sampled at the given point.
SkMatrix shaderInvLocalMatrix;
SkAssertResult(paint.getShader()->getLocalMatrix().invert(&shaderInvLocalMatrix));
const auto sample = SkPoint::Make(0.5f, 0.5f);
const auto mappedSample = shaderInvLocalMatrix.mapXY(sample.x(), sample.y()),
mappedPoint = shaderInvLocalMatrix.mapXY(p0.x(), p0.y());
const auto localMatrix = SkMatrix::MakeTrans(mappedSample.x() - mappedPoint.x(),
mappedSample.y() - mappedPoint.y());
SkShader::ContextRec rec(paint, SkMatrix::I(), &localMatrix,
SkShader::ContextRec::kPMColor_DstType, dstColorSpace);
auto* ctx = paint.getShader()->makeContext(rec, alloc);
if (!ctx) {
return nullptr;
}
SkPMColor pmColor;
ctx->shadeSpan(SkScalarFloorToInt(sample.x()), SkScalarFloorToInt(sample.y()), &pmColor, 1);
// no need to keep this temp context around.
alloc->reset();
return alloc->makeSkSp<SkColorShader>(SkUnPreMultiply::PMColorToColor(pmColor));
}
} // anonymous ns
static bool update_tricolor_matrix(const SkMatrix& ctmInv,
const SkPoint pts[], const SkPM4f colors[],
int index0, int index1, int index2, Matrix43* result) {
@ -394,6 +145,15 @@ static bool update_tricolor_matrix(const SkMatrix& ctmInv,
return true;
}
// Convert the SkColors into float colors. The conversion depends on some conditions:
// - If the pixmap has a dst colorspace, we have to be "color-correct".
// Do we map into dst-colorspace before or after we interpolate?
// - We have to decide when to apply per-color alpha (before or after we interpolate)
//
// For now, we will take a simple approach, but recognize this is just a start:
// - convert colors into dst colorspace before interpolation (matches gradients)
// - apply per-color alpha before interpolation (matches old version of vertices)
//
static SkPM4f* convert_colors(const SkColor src[], int count, SkColorSpace* deviceCS,
SkArenaAlloc* alloc) {
SkPM4f* dst = alloc->makeArray<SkPM4f>(count);
@ -435,159 +195,81 @@ void SkDraw::drawVertices(SkVertices::VertexMode vmode, int count,
return;
}
// transform out vertices into device coordinates
SkAutoSTMalloc<16, SkPoint> storage(count);
SkPoint* devVerts = storage.get();
// make textures and shader mutually consistent
SkShader* shader = paint.getShader();
if (!(shader && textures)) {
shader = nullptr;
textures = nullptr;
}
constexpr size_t defCount = 16;
constexpr size_t outerSize = sizeof(SkTriColorShader) +
sizeof(SkComposeShader) +
(sizeof(SkPoint) + sizeof(SkPM4f)) * defCount;
char outerStorage[outerSize];
SkArenaAlloc outerAlloc(outerStorage, sizeof(outerStorage));
SkPoint* devVerts = outerAlloc.makeArray<SkPoint>(count);
fMatrix->mapPoints(devVerts, vertices, count);
/*
We can draw the vertices in 1 of 4 ways:
- solid color (no shader/texture[], no colors[])
- just colors (no shader/texture[], has colors[])
- just texture (has shader/texture[], no colors[])
- colors * texture (has shader/texture[], has colors[])
Thus for texture drawing, we need both texture[] and a shader.
*/
if (colors && !textures) {
char arenaStorage[4096];
SkArenaAlloc alloc(arenaStorage, sizeof(storage));
Matrix43 matrix43;
SkRasterPipeline shaderPipeline(&alloc);
// Convert the SkColors into float colors. The conversion depends on some conditions:
// - If the pixmap has a dst colorspace, we have to be "color-correct".
// Do we map into dst-colorspace before or after we interpolate?
// - We have to decide when to apply per-color alpha (before or after we interpolate)
//
// For now, we will take a simple approach, but recognize this is just a start:
// - convert colors into dst colorspace before interpolation (matches gradients)
// - apply per-color alpha before interpolation (matches old version of vertices)
//
SkPM4f* dstColors = convert_colors(colors, count, fDst.colorSpace(), &alloc);
bool is_opaque;
if (paint.getAlpha() == 0xff) {
is_opaque = compute_is_opaque(colors, count);
} else {
is_opaque = false;
Sk4f alpha = paint.getAlpha() * (1/255.0f);
for (int i = 0; i < count; i++) {
(dstColors[i].to4f() * alpha).store(dstColors + i);
}
}
shaderPipeline.append(SkRasterPipeline::matrix_4x3, &matrix43);
// In theory we should never need to clamp. However, either due to imprecision in our
// matrix43, or the scan converter passing us pixel centers that in fact are not within
// the triangle, we do see occasional (slightly) out-of-range values, so we add these
// clamp stages. It would be nice to find a way to detect when these are not needed.
shaderPipeline.append(SkRasterPipeline::clamp_0);
shaderPipeline.append(SkRasterPipeline::clamp_a);
bool wants_dither = paint.isDither();
auto blitter = SkCreateRasterPipelineBlitter(fDst, paint, shaderPipeline,
is_opaque, wants_dither, &alloc);
SkASSERT(!blitter->isNullBlitter());
// setup our state and function pointer for iterating triangles
VertState state(count, indices, indexCount);
VertState::Proc vertProc = state.chooseProc(vmode);
if (colors || textures) {
SkPM4f* dstColors = nullptr;
Matrix43* matrix43 = nullptr;
if (colors) {
dstColors = convert_colors(colors, count, fDst.colorSpace(), &outerAlloc);
SkTriColorShader* triShader = outerAlloc.make<SkTriColorShader>(
compute_is_opaque(colors, count));
matrix43 = triShader->getMatrix43();
if (shader) {
shader = outerAlloc.make<SkComposeShader>(sk_ref_sp(triShader), sk_ref_sp(shader),
bmode);
} else {
shader = triShader;
}
}
SkPaint p(paint);
p.setShader(sk_ref_sp(shader));
while (vertProc(&state)) {
char innerStorage[2048];
SkArenaAlloc innerAlloc(innerStorage, sizeof(innerStorage));
const SkMatrix* ctm = fMatrix;
SkMatrix tmpCtm;
if (textures) {
SkMatrix localM;
texture_to_matrix(state, vertices, textures, &localM);
tmpCtm = SkMatrix::Concat(*fMatrix, localM);
ctm = &tmpCtm;
}
if (matrix43 && !update_tricolor_matrix(ctmInv, vertices, dstColors,
state.f0, state.f1, state.f2,
matrix43)) {
continue;
}
SkPoint tmp[] = {
devVerts[state.f0], devVerts[state.f1], devVerts[state.f2]
};
if (update_tricolor_matrix(ctmInv, vertices, dstColors, state.f0, state.f1, state.f2,
&matrix43)) {
auto blitter = SkCreateRasterPipelineBlitter(fDst, p, *ctm, &innerAlloc);
SkScan::FillTriangle(tmp, *fRC, blitter);
}
}
return;
}
auto triShader = sk_make_sp<SkTriColorShader>();
SkPaint p(paint);
SkShader* shader = p.getShader();
if (nullptr == shader) {
// if we have no shader, we ignore the texture coordinates
textures = nullptr;
} else if (nullptr == textures) {
// if we don't have texture coordinates, ignore the shader
p.setShader(nullptr);
shader = nullptr;
}
// setup the custom shader (if needed)
if (colors) {
if (nullptr == textures) {
// just colors (no texture)
p.setShader(triShader);
} else {
// colors * texture
SkASSERT(shader);
p.setShader(SkShader::MakeComposeShader(triShader, sk_ref_sp(shader), bmode));
}
}
// no colors[] and no texture, stroke hairlines with paint's color.
SkPaint p;
p.setStyle(SkPaint::kStroke_Style);
SkAutoBlitterChoose blitter(fDst, *fMatrix, p);
// Abort early if we failed to create a shader context.
if (blitter->isNullBlitter()) {
return;
}
// setup our state and function pointer for iterating triangles
VertState state(count, indices, indexCount);
VertState::Proc vertProc = state.chooseProc(vmode);
if (textures || colors) {
SkTriColorShader::TriColorShaderData verticesSetup = { vertices, colors, &state };
while (vertProc(&state)) {
auto* blitterPtr = blitter.get();
// We're going to allocate at most
//
// * one SkLocalMatrixShader OR one SkColorShader
// * one SkComposeShader
// * one SkAutoBlitterChoose
//
static constexpr size_t kAllocSize =
sizeof(SkAutoBlitterChoose) + sizeof(SkComposeShader) +
SkTMax(sizeof(SkLocalInnerMatrixShader), sizeof(SkColorShader));
char allocBuffer[kAllocSize];
SkArenaAlloc alloc(allocBuffer);
if (textures) {
sk_sp<SkShader> texShader = MakeTextureShader(state, vertices, textures, paint,
fDst.colorSpace(), &alloc);
if (texShader) {
SkPaint localPaint(p);
localPaint.setShader(colors
? alloc.makeSkSp<SkComposeShader>(triShader, std::move(texShader), bmode)
: std::move(texShader));
blitterPtr = alloc.make<SkAutoBlitterChoose>(fDst, *fMatrix, localPaint)->get();
if (blitterPtr->isNullBlitter()) {
continue;
}
}
}
if (colors) {
triShader->bindSetupData(&verticesSetup);
}
SkPoint tmp[] = {
devVerts[state.f0], devVerts[state.f1], devVerts[state.f2]
};
SkScan::FillTriangle(tmp, *fRC, blitterPtr);
triShader->bindSetupData(nullptr);
}
} else {
// no colors[] and no texture, stroke hairlines with paint's color.
SkScan::HairRCProc hairProc = ChooseHairProc(paint.isAntiAlias());
const SkRasterClip& clip = *fRC;
while (vertProc(&state)) {

31
tests/BlitRowTest.cpp
View File

@ -185,6 +185,35 @@ static void save_bm(const SkBitmap& bm, const char name[]) {
sk_tool_utils::EncodeImageToFile(name, bm, SkEncodedImageFormat::kPNG, 100);
}
static int max_diff(uint32_t u, uint32_t v) {
int d0 = SkAbs32(int((u >> 24) & 0xFF) - int((v >> 24) & 0xFF));
int d1 = SkAbs32(int((u >> 16) & 0xFF) - int((v >> 16) & 0xFF));
int d2 = SkAbs32(int((u >> 8) & 0xFF) - int((v >> 8) & 0xFF));
int d3 = SkAbs32(int((u >> 0) & 0xFF) - int((v >> 0) & 0xFF));
return SkMax32(d0, SkMax32(d1, SkMax32(d2, d3)));
}
static bool nearly_eq(const SkBitmap& a, const SkBitmap& b) {
switch (a.colorType()) {
case kN32_SkColorType: {
for (int y = 0; y < a.width(); ++y) {
const SkPMColor* ap = a.getAddr32(0, y);
const SkPMColor* bp = b.getAddr32(0, y);
for (int x = 0; x < a.width(); ++x) {
int diff = max_diff(ap[x], bp[x]);
if (diff > 1) {
return false;
}
}
}
return true;
} break;
default:
break;
}
return !memcmp(a.getPixels(), b.getPixels(), a.getSize());
}
static bool gOnce;
// Make sure our blits are invariant with the width of the blit (i.e. that
@ -243,7 +272,7 @@ static void test_diagonal(skiatest::Reporter* reporter) {
gOnce = true;
}
if (memcmp(dstBM0.getPixels(), dstBM1.getPixels(), dstBM0.getSize())) {
if (!nearly_eq(dstBM0, dstBM1)) {
ERRORF(reporter, "Diagonal colortype=%s bg=0x%x dither=%d"
" alpha=0x%x src=0x%x",
gColorTypeName[gDstColorType[i]], bgColor, dither,