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

Simplified linear pipeline.

Browse Source 
BUG=skia:
GOLD_TRYBOT_URL= https://gold.skia.org/search2?unt=true&query=source_type%3Dgm&master=false&issue=1704583003

Review URL: https://codereview.chromium.org/1704583003
This commit is contained in:
herb 2016-02-17 10:00:07 -08:00 committed by Commit bot
parent 68c063bf11
commit feec878e85
7 changed files with 1084 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

288
bench/SkLinearBitmapPipelineBench.cpp Normal file
View File

@ -0,0 +1,288 @@
/*
* Copyright 2016 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include <memory>
#include "SkColor.h"
#include "SkLinearBitmapPipeline.h"
#include "Benchmark.h"
#include "SkShader.h"
#include "SkImage.h"
struct CommonBitmapFPBenchmark : public Benchmark {
CommonBitmapFPBenchmark(
SkISize srcSize,
SkColorProfileType colorProfile,
SkMatrix m,
bool useBilerp,
SkShader::TileMode xTile,
SkShader::TileMode yTile)
: fColorProfile(colorProfile)
, fM{m}
, fUseBilerp{useBilerp}
, fXTile{xTile}
, fYTile{yTile} {
fSrcSize = srcSize;
}
static SkString tileName(const char* pre, SkShader::TileMode mode) {
SkString name{pre};
switch (mode) {
case SkShader::kClamp_TileMode:
name.append("Clamp");
return name;
case SkShader::kRepeat_TileMode:
name.append("Repeat");
return name;
case SkShader::kMirror_TileMode:
name.append("Mirror");
return name;
default:
name.append("Unknown");
return name;
}
}
const char* onGetName() override {
SkString name {"SkBitmapFP"};
if (fM.getType() & SkMatrix::kPerspective_Mask) {
name.append("Perspective");
} else if (fM.getType() & SkMatrix::kAffine_Mask) {
name.append("Affine");
} else if (fM.getType() & SkMatrix::kScale_Mask) {
name.append("Scale");
} else if (fM.getType() & SkMatrix::kTranslate_Mask) {
name.append("Translate");
} else {
name.append("Identity");
}
name.append(tileName("X", fXTile));
name.append(tileName("Y", fYTile));
if (fUseBilerp) {
name.append("Filter");
} else {
name.append("Nearest");
}
name.appendf("%s", BaseName().c_str());
return name.c_str();
}
void onPreDraw(SkCanvas*) override {
int width = fSrcSize.fWidth;
int height = fSrcSize.fHeight;
fBitmap.reset(new uint32_t[width * height]);
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
fBitmap[y * width + x] = (y << 8) + x + (128<<24);
}
}
bool trash = fM.invert(&fInvert);
sk_ignore_unused_variable(trash);
fInfo = SkImageInfo::MakeN32Premul(width, height, fColorProfile);
}
bool isSuitableFor(Backend backend) override {
return backend == kNonRendering_Backend;
}
virtual SkString BaseName() = 0;
SkISize fSrcSize;
SkColorProfileType fColorProfile;
SkMatrix fM;
SkMatrix fInvert;
bool fUseBilerp;
SkShader::TileMode fXTile;
SkShader::TileMode fYTile;
SkImageInfo fInfo;
std::unique_ptr<uint32_t[]> fBitmap;
};
struct SkBitmapFPGeneral final : public CommonBitmapFPBenchmark {
SkBitmapFPGeneral(
SkISize srcSize,
SkColorProfileType colorProfile,
SkMatrix m,
bool useBilerp,
SkShader::TileMode xTile,
SkShader::TileMode yTile)
: CommonBitmapFPBenchmark(srcSize, colorProfile, m, useBilerp, xTile, yTile) { }
SkString BaseName() override {
SkString name;
if (fInfo.isSRGB()) {
name.set("sRGB");
} else {
name.set("Linr");
}
return name;
}
void onDraw(int loops, SkCanvas*) override {
int width = fSrcSize.fWidth;
int height = fSrcSize.fHeight;
SkPM4f* FPbuffer = new SkPM4f[width * height];
SkLinearBitmapPipeline pipeline{fInvert, fXTile, fYTile, fInfo, fBitmap.get(), };
int count = 100;
for (int n = 0; n < 1000*loops; n++) {
pipeline.shadeSpan4f(3, 6, FPbuffer, count);
}
delete [] FPbuffer;
}
};
struct SkBitmapFPOrigShader : public CommonBitmapFPBenchmark {
SkBitmapFPOrigShader(
SkISize srcSize,
SkColorProfileType colorProfile,
SkMatrix m,
bool useBilerp,
SkShader::TileMode xTile,
SkShader::TileMode yTile)
: CommonBitmapFPBenchmark(srcSize, colorProfile, m, useBilerp, xTile, yTile) { }
SkString BaseName() override {
SkString name{"Orig"};
return name;
}
void onPreDraw(SkCanvas* c) override {
CommonBitmapFPBenchmark::onPreDraw(c);
SkImage* image = SkImage::NewRasterCopy(
fInfo, fBitmap.get(), sizeof(SkPMColor) * fSrcSize.fWidth);
fImage.reset(image);
SkShader* shader = fImage->newShader(fXTile, fYTile);
if (fUseBilerp) {
fPaint.setFilterQuality(SkFilterQuality::kLow_SkFilterQuality);
} else {
fPaint.setFilterQuality(SkFilterQuality::kNone_SkFilterQuality);
}
fPaint.setShader(shader)->unref();
}
void onPostDraw(SkCanvas*) override {
}
void onDraw(int loops, SkCanvas*) override {
int width = fSrcSize.fWidth;
int height = fSrcSize.fHeight;
SkPMColor *buffer4b = new SkPMColor[width * height];
uint32_t storage[200];
SkASSERT(fPaint.getShader()->contextSize() <= sizeof(storage));
SkShader::Context* ctx = fPaint.getShader()->createContext(
{fPaint, fM, nullptr},
storage);
int count = 100;
for (int n = 0; n < 1000*loops; n++) {
ctx->shadeSpan(3, 6, buffer4b, count);
}
ctx->~Context();
delete buffer4b;
}
SkPaint fPaint;
SkAutoTUnref<SkImage> fImage;
};
static SkISize srcSize = SkISize::Make(120, 100);
static SkMatrix mI = SkMatrix::I();
DEF_BENCH(return new SkBitmapFPGeneral(
srcSize, kSRGB_SkColorProfileType, mI, false,
SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
DEF_BENCH(return new SkBitmapFPGeneral(
srcSize, kLinear_SkColorProfileType, mI, false,
SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
DEF_BENCH(return new SkBitmapFPOrigShader(
srcSize, kLinear_SkColorProfileType, mI, false,
SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
DEF_BENCH(return new SkBitmapFPGeneral(
srcSize, kSRGB_SkColorProfileType, mI, true,
SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
DEF_BENCH(return new SkBitmapFPGeneral(
srcSize, kLinear_SkColorProfileType, mI, true,
SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
DEF_BENCH(return new SkBitmapFPOrigShader(
srcSize, kLinear_SkColorProfileType, mI, true,
SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
static SkMatrix mS = SkMatrix::MakeScale(2.7f, 2.7f);
DEF_BENCH(return new SkBitmapFPGeneral(
srcSize, kSRGB_SkColorProfileType, mS, false,
SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
DEF_BENCH(return new SkBitmapFPGeneral(
srcSize, kLinear_SkColorProfileType, mS, false,
SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
DEF_BENCH(return new SkBitmapFPOrigShader(
srcSize, kLinear_SkColorProfileType, mS, false,
SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
DEF_BENCH(return new SkBitmapFPGeneral(
srcSize, kSRGB_SkColorProfileType, mS, true,
SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
DEF_BENCH(return new SkBitmapFPGeneral(
srcSize, kLinear_SkColorProfileType, mS, true,
SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
DEF_BENCH(return new SkBitmapFPOrigShader(
srcSize, kLinear_SkColorProfileType, mS, true,
SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
static SkMatrix rotate(SkScalar r) {
SkMatrix m;
m.setRotate(30);
return m;
}
static SkMatrix mR = rotate(30);
DEF_BENCH(return new SkBitmapFPGeneral(
srcSize, kSRGB_SkColorProfileType, mR, false,
SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
DEF_BENCH(return new SkBitmapFPGeneral(
srcSize, kLinear_SkColorProfileType, mR, false,
SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
DEF_BENCH(return new SkBitmapFPOrigShader(
srcSize, kLinear_SkColorProfileType, mR, false,
SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
DEF_BENCH(return new SkBitmapFPGeneral(
srcSize, kSRGB_SkColorProfileType, mR, true,
SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
DEF_BENCH(return new SkBitmapFPGeneral(
srcSize, kLinear_SkColorProfileType, mR, true,
SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)
DEF_BENCH(return new SkBitmapFPOrigShader(
srcSize, kLinear_SkColorProfileType, mR, true,
SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);)

192
gm/SkLinearBitmapPipelineGM.cpp Normal file
View File

@ -0,0 +1,192 @@
/*
* Copyright 2016 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "gm.h"
#include "SkCanvas.h"
#include "SkColor.h"
#include "SkImage.h"
#include "SkImageInfo.h"
#include "SkLinearBitmapPipeline.h"
#include "SkXfermode.h"
#include "SkPM4fPriv.h"
#include "SkShader.h"
static void fill_in_bits(SkBitmap& bm, SkIRect ir, SkColor c, bool premul) {
bm.allocN32Pixels(ir.width(), ir.height());
SkPixmap pm;
bm.peekPixels(&pm);
SkPMColor b = SkColorSetARGBMacro(255, 0, 0, 0);
SkPMColor w;
if (premul) {
w = SkPreMultiplyColor(c);
} else {
w = SkPackARGB32NoCheck(SkColorGetA(c), SkColorGetR(c), SkColorGetG(c), SkColorGetB(c));
}
for (int y = 0; y < ir.height(); y++) {
for (int x = 0; x < ir.width(); x++) {
if ((x ^ y) & 16) {
*pm.writable_addr32(x, y) = b;
} else {
*pm.writable_addr32(x, y) = w;
}
}
}
}
static void draw_rect_orig(SkCanvas* canvas, const SkRect& r, SkColor c, const SkMatrix* mat, bool useBilerp) {
const SkIRect ir = r.round();
SkBitmap bmsrc;
fill_in_bits(bmsrc, ir, c, true);
SkPixmap pmsrc;
bmsrc.peekPixels(&pmsrc);
SkBitmap bmdst;
bmdst.allocN32Pixels(ir.width(), ir.height());
bmdst.eraseColor(0xFFFFFFFF);
SkPixmap pmdst;
bmdst.peekPixels(&pmdst);
SkImageInfo info = SkImageInfo::MakeN32Premul(ir.width(), ir.height(), kLinear_SkColorProfileType);
SkAutoTUnref<SkImage> image{SkImage::NewRasterCopy(
info, pmsrc.addr32(), pmsrc.rowBytes())};
SkPaint paint;
int32_t storage[200];
SkShader* shader = image->newShader(SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
if (useBilerp) {
paint.setFilterQuality(SkFilterQuality::kLow_SkFilterQuality);
} else {
paint.setFilterQuality(SkFilterQuality::kNone_SkFilterQuality);
}
paint.setShader(shader)->unref();
SkASSERT(paint.getShader()->contextSize() <= sizeof(storage));
SkShader::Context* ctx = paint.getShader()->createContext(
{paint, *mat, nullptr},
storage);
for (int y = 0; y < ir.height(); y++) {
ctx->shadeSpan(0, y, pmdst.writable_addr32(0, y), ir.width());
}
canvas->drawBitmap(bmdst, r.left(), r.top(), nullptr);
ctx->~Context();
}
static void draw_rect_fp(SkCanvas* canvas, const SkRect& r, SkColor c, const SkMatrix* mat, bool useBilerp) {
const SkIRect ir = r.round();
SkBitmap bmsrc;
fill_in_bits(bmsrc, ir, c, true);
SkPixmap pmsrc;
bmsrc.peekPixels(&pmsrc);
SkBitmap bmdst;
bmdst.allocN32Pixels(ir.width(), ir.height());
bmdst.eraseColor(0xFFFFFFFF);
SkPixmap pmdst;
bmdst.peekPixels(&pmdst);
SkPM4f* dstBits = new SkPM4f[ir.width()];
SkImageInfo info = SkImageInfo::MakeN32(ir.width(), ir.height(), kPremul_SkAlphaType);
SkMatrix inv;
bool trash = mat->invert(&inv);
sk_ignore_unused_variable(trash);
uint32_t flags = 0;
//if (kSRGB_SkColorProfileType == profile) {
//flags |= SkXfermode::kDstIsSRGB_PM4fFlag;
//}
const SkXfermode::PM4fState state { nullptr, flags };
auto procN = SkXfermode::GetPM4fProcN(SkXfermode::kSrcOver_Mode, flags);
SkLinearBitmapPipeline pipeline{
inv, SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, info, pmsrc.addr32()};
for (int y = 0; y < ir.height(); y++) {
pipeline.shadeSpan4f(0, y, dstBits, ir.width());
procN(state, pmdst.writable_addr32(0, y), dstBits, ir.width(), nullptr);
}
delete [] dstBits;
canvas->drawBitmap(bmdst, r.left(), r.top(), nullptr);
}
static void draw_rect_none(SkCanvas* canvas, const SkRect& r, SkColor c) {
const SkIRect ir = r.round();
SkBitmap bm;
fill_in_bits(bm, ir, c, true);
canvas->drawBitmap(bm, r.left(), r.top(), nullptr);
}
/*
* Test SkXfer4fProcs directly for src-over, comparing them to current SkColor blits.
*/
DEF_SIMPLE_GM(linear_pipeline, canvas, 580, 1400) {
const int IW = 50;
const SkScalar W = IW;
const SkScalar H = 100;
const SkColor colors[] = {
0x880000FF, 0x8800FF00, 0x88FF0000, 0x88000000,
SK_ColorBLUE, SK_ColorGREEN, SK_ColorRED, SK_ColorBLACK,
};
canvas->translate(20, 20);
SkMatrix mi = SkMatrix::I();
SkMatrix mt;
mt.setTranslate(8, 8);
SkMatrix ms;
ms.setScale(2.7f, 2.7f);
SkMatrix mr;
mr.setRotate(10);
const SkMatrix* mats[] = {nullptr, &mi, &mt, &ms, &mr};
const SkRect r = SkRect::MakeWH(W, H);
bool useBilerp = false;
while (true) {
canvas->save();
for (auto mat : mats) {
canvas->save();
for (SkColor c : colors) {
if (mat == nullptr) {
SkPaint p;
p.setColor(c);
draw_rect_none(canvas, r, c);
canvas->translate(W + 20, 0);
draw_rect_none(canvas, r, c);
} else {
draw_rect_orig(canvas, r, c, mat, useBilerp);
canvas->translate(W + 20, 0);
draw_rect_fp(canvas, r, c, mat, useBilerp);
}
canvas->translate(W + 20, 0);
}
canvas->restore();
canvas->translate(0, H + 20);
}
canvas->restore();
canvas->translate(0, (H + 20) * SK_ARRAY_COUNT(mats));
if (useBilerp) break;
useBilerp = true;
}
}

2
gyp/core.gypi
View File

@ -149,6 +149,8 @@
'<(skia_src_path)/core/SkLight.h',
'<(skia_src_path)/core/SkLightingShader.h',
'<(skia_src_path)/core/SkLightingShader.cpp',
'<(skia_src_path)/core/SkLinearBitmapPipeline.cpp',
'<(skia_src_path)/core/SkLinearBitmapPipeline.h',
'<(skia_src_path)/core/SkLineClipper.cpp',
'<(skia_src_path)/core/SkLocalMatrixImageFilter.cpp',
'<(skia_src_path)/core/SkLocalMatrixImageFilter.h',

449
src/core/SkLinearBitmapPipeline.cpp Normal file
View File

@ -0,0 +1,449 @@
/*
* Copyright 2016 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "SkLinearBitmapPipeline.h"
struct X {
explicit X(SkScalar val) : fVal{val} { }
explicit X(SkPoint pt) : fVal{pt.fX} { }
explicit X(SkSize s) : fVal{s.fWidth} { }
explicit X(SkISize s) : fVal(s.fWidth) { }
operator float () const {return fVal;}
private:
float fVal;
};
struct Y {
explicit Y(SkScalar val) : fVal{val} { }
explicit Y(SkPoint pt) : fVal{pt.fY} { }
explicit Y(SkSize s) : fVal{s.fHeight} { }
explicit Y(SkISize s) : fVal(s.fHeight) { }
operator float () const {return fVal;}
private:
float fVal;
};
template<typename Strategy, typename Next>
class PointProcessor : public PointProcessorInterface {
public:
template <typename... Args>
PointProcessor(Next* next, Args&&... args)
: fNext{next}
, fStrategy{std::forward<Args>(args)...}{ }
void pointListFew(int n, Sk4fArg xs, Sk4fArg ys) override {
Sk4f newXs = xs;
Sk4f newYs = ys;
fStrategy.processPoints(&newXs, &newYs);
fNext->pointListFew(n, newXs, newYs);
}
void pointList4(Sk4fArg xs, Sk4fArg ys) override {
Sk4f newXs = xs;
Sk4f newYs = ys;
fStrategy.processPoints(&newXs, &newYs);
fNext->pointList4(newXs, newYs);
}
private:
Next* const fNext;
Strategy fStrategy;
};
class SkippedStage final : public PointProcessorInterface {
void pointListFew(int n, Sk4fArg xs, Sk4fArg ys) override {
SkFAIL("Abort tiler.");
}
void pointList4(Sk4fArg Xs, Sk4fArg Ys) override {
SkFAIL("Abort point processor.");
}
};
class TranslateMatrixStrategy {
public:
TranslateMatrixStrategy(SkVector offset)
: fXOffset{X(offset)}
, fYOffset{Y(offset)} { }
void processPoints(Sk4f* xs, Sk4f* ys) {
*xs = *xs + fXOffset;
*ys = *ys + fYOffset;
}
private:
const Sk4f fXOffset, fYOffset;
};
template <typename Next = PointProcessorInterface>
using TranslateMatrix = PointProcessor<TranslateMatrixStrategy, Next>;
class ScaleMatrixStrategy {
public:
ScaleMatrixStrategy(SkVector offset, SkVector scale)
: fXOffset{X(offset)}, fYOffset{Y(offset)}
, fXScale{X(scale)}, fYScale{Y(scale)} { }
void processPoints(Sk4f* xs, Sk4f* ys) {
*xs = *xs * fXScale + fXOffset;
*ys = *ys * fYScale + fYOffset;
}
private:
const Sk4f fXOffset, fYOffset;
const Sk4f fXScale, fYScale;
};
template <typename Next = PointProcessorInterface>
using ScaleMatrix = PointProcessor<ScaleMatrixStrategy, Next>;
class AffineMatrixStrategy {
public:
AffineMatrixStrategy(SkVector offset, SkVector scale, SkVector skew)
: fXOffset{X(offset)}, fYOffset{Y(offset)}
, fXScale{X(scale)}, fYScale{Y(scale)}
, fXSkew{X(skew)}, fYSkew{Y(skew)} { }
void processPoints(Sk4f* xs, Sk4f* ys) {
Sk4f newXs = fXScale * *xs + fXSkew * *ys + fXOffset;
Sk4f newYs = fYSkew * *xs + fYScale * *ys + fYOffset;
*xs = newXs;
*ys = newYs;
}
private:
const Sk4f fXOffset, fYOffset;
const Sk4f fXScale, fYScale;
const Sk4f fXSkew, fYSkew;
};
template <typename Next = PointProcessorInterface>
using AffineMatrix = PointProcessor<AffineMatrixStrategy, Next>;
static PointProcessorInterface* choose_matrix(
PointProcessorInterface* next,
const SkMatrix& inverse,
SkLinearBitmapPipeline::MatrixStage* matrixProc) {
if (inverse.hasPerspective()) {
SkFAIL("Not implemented.");
} else if (inverse.getSkewX() != 0.0f || inverse.getSkewY() != 0.0f) {
matrixProc->Initialize<AffineMatrix<>>(
next,
SkVector{inverse.getTranslateX(), inverse.getTranslateY()},
SkVector{inverse.getScaleX(), inverse.getScaleY()},
SkVector{inverse.getSkewX(), inverse.getSkewY()});
} else if (inverse.getScaleX() != 1.0f || inverse.getScaleY() != 1.0f) {
matrixProc->Initialize<ScaleMatrix<>>(
next,
SkVector{inverse.getTranslateX(), inverse.getTranslateY()},
SkVector{inverse.getScaleX(), inverse.getScaleY()});
} else if (inverse.getTranslateX() != 0.0f || inverse.getTranslateY() != 0.0f) {
matrixProc->Initialize<TranslateMatrix<>>(
next,
SkVector{inverse.getTranslateX(), inverse.getTranslateY()});
} else {
matrixProc->Initialize<SkippedStage>();
return next;
}
return matrixProc->get();
}
class ClampStrategy {
public:
ClampStrategy(X max)
: fXMin{0.0f}
, fXMax{max - 1.0f} { }
ClampStrategy(Y max)
: fYMin{0.0f}
, fYMax{max - 1.0f} { }
ClampStrategy(SkSize max)
: fXMin{0.0f}
, fYMin{0.0f}
, fXMax{X(max) - 1.0f}
, fYMax{Y(max) - 1.0f} { }
void processPoints(Sk4f* xs, Sk4f* ys) {
*xs = Sk4f::Min(Sk4f::Max(*xs, fXMin), fXMax);
*ys = Sk4f::Min(Sk4f::Max(*ys, fYMin), fYMax);
}
private:
const Sk4f fXMin{SK_FloatNegativeInfinity};
const Sk4f fYMin{SK_FloatNegativeInfinity};
const Sk4f fXMax{SK_FloatInfinity};
const Sk4f fYMax{SK_FloatInfinity};
};
template <typename Next = PointProcessorInterface>
using Clamp = PointProcessor<ClampStrategy, Next>;
class RepeatStrategy {
public:
RepeatStrategy(X max) : fXMax{max}, fXInvMax{1.0f/max} { }
RepeatStrategy(Y max) : fYMax{max}, fYInvMax{1.0f/max} { }
RepeatStrategy(SkSize max)
: fXMax{X(max)}
, fXInvMax{1.0f / X(max)}
, fYMax{Y(max)}
, fYInvMax{1.0f / Y(max)} { }
void processPoints(Sk4f* xs, Sk4f* ys) {
Sk4f divX = (*xs * fXInvMax).floor();
Sk4f divY = (*ys * fYInvMax).floor();
Sk4f baseX = (divX * fXMax);
Sk4f baseY = (divY * fYMax);
*xs = *xs - baseX;
*ys = *ys - baseY;
}
private:
const Sk4f fXMax{0.0f};
const Sk4f fXInvMax{0.0f};
const Sk4f fYMax{0.0f};
const Sk4f fYInvMax{0.0f};
};
template <typename Next = PointProcessorInterface>
using Repeat = PointProcessor<RepeatStrategy, Next>;
static PointProcessorInterface* choose_tiler(
PointProcessorInterface* next,
SkSize dimensions,
SkShader::TileMode xMode,
SkShader::TileMode yMode,
SkLinearBitmapPipeline::TileStage* tileProcXOrBoth,
SkLinearBitmapPipeline::TileStage* tileProcY) {
if (xMode == yMode) {
switch (xMode) {
case SkShader::kClamp_TileMode:
tileProcXOrBoth->Initialize<Clamp<>>(next, dimensions);
break;
case SkShader::kRepeat_TileMode:
tileProcXOrBoth->Initialize<Repeat<>>(next, dimensions);
break;
case SkShader::kMirror_TileMode:
SkFAIL("Not implemented.");
break;
}
tileProcY->Initialize<SkippedStage>();
} else {
switch (yMode) {
case SkShader::kClamp_TileMode:
tileProcY->Initialize<Clamp<>>(next, Y(dimensions));
break;
case SkShader::kRepeat_TileMode:
tileProcY->Initialize<Repeat<>>(next, Y(dimensions));
break;
case SkShader::kMirror_TileMode:
SkFAIL("Not implemented.");
break;
}
switch (xMode) {
case SkShader::kClamp_TileMode:
tileProcXOrBoth->Initialize<Clamp<>>(tileProcY->get(), X(dimensions));
break;
case SkShader::kRepeat_TileMode:
tileProcXOrBoth->Initialize<Repeat<>>(tileProcY->get(), X(dimensions));
break;
case SkShader::kMirror_TileMode:
SkFAIL("Not implemented.");
break;
}
}
return tileProcXOrBoth->get();
}
class sRGBFast {
public:
static Sk4f sRGBToLinear(Sk4fArg pixel) {
Sk4f l = pixel * pixel;
return Sk4f{l[0], l[1], l[2], pixel[3]};
}
};
template <SkColorProfileType colorProfile>
class Passthrough8888 {
public:
Passthrough8888(int width, const uint32_t* src)
: fSrc{src}, fWidth{width}{ }
void getFewPixels(int n, Sk4fArg xs, Sk4fArg ys, Sk4f* px0, Sk4f* px1, Sk4f* px2) {
Sk4i XIs = SkNx_cast<int, float>(xs);
Sk4i YIs = SkNx_cast<int, float>(ys);
Sk4i bufferLoc = YIs * fWidth + XIs;
switch (n) {
case 3:
*px2 = getPixel(fSrc, bufferLoc[2]);
case 2:
*px1 = getPixel(fSrc, bufferLoc[1]);
case 1:
*px0 = getPixel(fSrc, bufferLoc[0]);
default:
break;
}
}
void get4Pixels(Sk4fArg xs, Sk4fArg ys, Sk4f* px0, Sk4f* px1, Sk4f* px2, Sk4f* px3) {
Sk4i XIs = SkNx_cast<int, float>(xs);
Sk4i YIs = SkNx_cast<int, float>(ys);
Sk4i bufferLoc = YIs * fWidth + XIs;
*px0 = getPixel(fSrc, bufferLoc[0]);
*px1 = getPixel(fSrc, bufferLoc[1]);
*px2 = getPixel(fSrc, bufferLoc[2]);
*px3 = getPixel(fSrc, bufferLoc[3]);
}
const uint32_t* row(int y) { return fSrc + y * fWidth[0]; }
private:
Sk4f getPixel(const uint32_t* src, int index) {
Sk4b bytePixel = Sk4b::Load((uint8_t *)(&src[index]));
Sk4f pixel = SkNx_cast<float, uint8_t>(bytePixel);
pixel = pixel * Sk4f{1.0f/255.0f};
if (colorProfile == kSRGB_SkColorProfileType) {
pixel = sRGBFast::sRGBToLinear(pixel);
}
return pixel;
}
const uint32_t* const fSrc;
const Sk4i fWidth;
};
template <typename SourceStrategy>
class Sampler final : public PointProcessorInterface {
public:
template <typename... Args>
Sampler(PixelPlacerInterface* next, Args&&... args)
: fNext{next}
, fStrategy{std::forward<Args>(args)...} { }
void pointListFew(int n, Sk4fArg xs, Sk4fArg ys) override {
SkASSERT(0 < n && n < 4);
Sk4f px0, px1, px2;
fStrategy.getFewPixels(n, xs, ys, &px0, &px1, &px2);
if (n >= 1) fNext->placePixel(px0);
if (n >= 2) fNext->placePixel(px1);
if (n >= 3) fNext->placePixel(px2);
}
void pointList4(Sk4fArg xs, Sk4fArg ys) override {
Sk4f px0, px1, px2, px3;
fStrategy.get4Pixels(xs, ys, &px0, &px1, &px2, &px3);
fNext->place4Pixels(px0, px1, px2, px3);
}
private:
PixelPlacerInterface* const fNext;
SourceStrategy fStrategy;
};
static PointProcessorInterface* choose_pixel_sampler(
PixelPlacerInterface* next,
const SkImageInfo& imageInfo,
const void* imageData,
SkLinearBitmapPipeline::SampleStage* sampleStage) {
switch (imageInfo.colorType()) {
case kRGBA_8888_SkColorType:
case kBGRA_8888_SkColorType:
if (kN32_SkColorType == imageInfo.colorType()) {
if (imageInfo.profileType() == kSRGB_SkColorProfileType) {
sampleStage->Initialize<Sampler<Passthrough8888<kSRGB_SkColorProfileType>>>(
next, imageInfo.width(),
(uint32_t*)imageData);
} else {
sampleStage->Initialize<Sampler<Passthrough8888<kLinear_SkColorProfileType>>>(
next, imageInfo.width(),
(uint32_t*)imageData);
}
} else {
SkFAIL("Not implemented. No 8888 Swizzle");
}
break;
default:
SkFAIL("Not implemented. Unsupported src");
break;
}
return sampleStage->get();
}
template <SkAlphaType alphaType>
class PlaceFPPixel final : public PixelPlacerInterface {
public:
void placePixel(Sk4fArg pixel) override {
PlacePixel(fDst, pixel, 0);
fDst += 1;
}
void place4Pixels(Sk4fArg p0, Sk4fArg p1, Sk4fArg p2, Sk4fArg p3) override {
SkPM4f* dst = fDst;
PlacePixel(dst, p0, 0);
PlacePixel(dst, p1, 1);
PlacePixel(dst, p2, 2);
PlacePixel(dst, p3, 3);
fDst += 4;
}
void setDestination(SkPM4f* dst) override {
fDst = dst;
}
private:
static void PlacePixel(SkPM4f* dst, Sk4fArg pixel, int index) {
Sk4f newPixel = pixel;
if (alphaType == kUnpremul_SkAlphaType) {
newPixel = Premultiply(pixel);
}
newPixel.store(dst + index);
}
static Sk4f Premultiply(Sk4fArg pixel) {
float alpha = pixel[3];
return pixel * Sk4f{alpha, alpha, alpha, 1.0f};
}
SkPM4f* fDst;
};
static PixelPlacerInterface* choose_pixel_placer(
SkAlphaType alphaType,
SkLinearBitmapPipeline::PixelStage* placerStage) {
if (alphaType == kUnpremul_SkAlphaType) {
placerStage->Initialize<PlaceFPPixel<kUnpremul_SkAlphaType>>();
} else {
// kOpaque_SkAlphaType is treated the same as kPremul_SkAlphaType
placerStage->Initialize<PlaceFPPixel<kPremul_SkAlphaType>>();
}
return placerStage->get();
}
SkLinearBitmapPipeline::SkLinearBitmapPipeline(
const SkMatrix& inverse,
SkShader::TileMode xTile, SkShader::TileMode yTile,
const SkImageInfo& srcImageInfo,
const void* srcImageData) {
SkSize size;
size = srcImageInfo.dimensions();
// As the stages are built, the chooser function may skip a stage. For example, with the
// identity matrix, the matrix stage is skipped, and the tilerStage is the first stage.
auto placementStage = choose_pixel_placer(srcImageInfo.alphaType(), &fPixelStage);
auto samplerStage = choose_pixel_sampler(placementStage, srcImageInfo,
srcImageData, &fSampleStage);
auto tilerStage = choose_tiler(samplerStage, size, xTile, yTile, &fTileXOrBothStage,
&fTileYStage);
fFirstStage = choose_matrix(tilerStage, inverse, &fMatrixStage);
}
void SkLinearBitmapPipeline::shadeSpan4f(int x, int y, SkPM4f* dst, int count) {
fPixelStage->setDestination(dst);
Sk4f Xs = Sk4f(x) + Sk4f{0.5f, 1.5f, 2.5f, 3.5f};
Sk4f Ys(y);
Sk4f fours{4.0f};
while (count >= 4) {
fFirstStage->pointList4(Xs, Ys);
Xs = Xs + fours;
count -= 4;
}
if (count > 0) {
fFirstStage->pointListFew(count, Xs, Ys);
}
}

89
src/core/SkLinearBitmapPipeline.h Normal file
View File

@ -0,0 +1,89 @@
/*
* Copyright 2016 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SkLinearBitmapPipeline_DEFINED
#define SkLinearBitmapPipeline_DEFINED
#include <algorithm>
#include <cmath>
#include <limits>
#include <cstdio>
#include "SkColor.h"
#include "SkImageInfo.h"
#include "SkMatrix.h"
#include "SkShader.h"
#include "SkSize.h"
#include "SkNx.h"
using Sk4fArg = const Sk4f&;
class PointProcessorInterface {
public:
virtual ~PointProcessorInterface() { }
virtual void pointListFew(int n, Sk4fArg xs, Sk4fArg ys) = 0;
virtual void pointList4(Sk4fArg xs, Sk4fArg ys) = 0;
};
class PixelPlacerInterface {
public:
virtual ~PixelPlacerInterface() { }
virtual void setDestination(SkPM4f* dst) = 0;
virtual void placePixel(Sk4fArg pixel0) = 0;
virtual void place4Pixels(Sk4fArg p0, Sk4fArg p1, Sk4fArg p2, Sk4fArg p3) = 0;
};
class SkLinearBitmapPipeline {
public:
SkLinearBitmapPipeline(
const SkMatrix& inverse,
SkShader::TileMode xTile, SkShader::TileMode yTile,
const SkImageInfo& srcImageInfo,
const void* srcImageData);
void shadeSpan4f(int x, int y, SkPM4f* dst, int count);
template<typename Base, size_t kSize>
class PolymorphicUnion {
public:
PolymorphicUnion() {}
~PolymorphicUnion() { get()->~Base(); }
template<typename Variant, typename... Args>
void Initialize(Args&&... args) {
SkASSERTF(sizeof(Variant) <= sizeof(fSpace),
"Size Variant: %d, Space: %d", sizeof(Variant), sizeof(fSpace));
new(&fSpace) Variant(std::forward<Args>(args)...);
};
Base* get() const { return reinterpret_cast<Base*>(&fSpace); }
Base* operator->() const { return get(); }
Base& operator*() const { return *get(); }
private:
struct SK_STRUCT_ALIGN(16) Space {
char space[kSize];
};
mutable Space fSpace;
};
using MatrixStage = PolymorphicUnion<PointProcessorInterface, 112>;
using TileStage = PolymorphicUnion<PointProcessorInterface, 96>;
using SampleStage = PolymorphicUnion<PointProcessorInterface, 80>;
using PixelStage = PolymorphicUnion<PixelPlacerInterface, 80>;
private:
PointProcessorInterface* fFirstStage;
MatrixStage fMatrixStage;
TileStage fTileXOrBothStage;
TileStage fTileYStage;
SampleStage fSampleStage;
PixelStage fPixelStage;
};
#endif // SkLinearBitmapPipeline_DEFINED

1
src/core/SkNx.h
View File

@ -198,6 +198,7 @@ typedef SkNx<4, uint8_t> Sk4b;
typedef SkNx<16, uint8_t> Sk16b;
typedef SkNx<4, uint16_t> Sk4h;
typedef SkNx<16, uint16_t> Sk16h;
typedef SkNx<4, int> Sk4i;
typedef SkNx<4, int> Sk4i;

63
tests/SkLinearBitmapPipelineTest.cpp Normal file
View File

@ -0,0 +1,63 @@
/*
* Copyright 2016 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "SkLinearBitmapPipeline.h"
#include "SkColor.h"
#include "Test.h"
struct SinkBilerpProcessor final : public PointProcessorInterface {
void pointListFew(int n, Sk4fArg xs, Sk4fArg ys) override { fXs = xs; fYs = ys; }
void pointList4(Sk4fArg Xs, Sk4fArg Ys) override { fXs = Xs; fYs = Ys; }
Sk4f fXs;
Sk4f fYs;
};
using Pixel = float[4];
DEF_TEST(SkBitmapFP, reporter) {
int width = 10;
int height = 10;
uint32_t* bitmap = new uint32_t[width * height];
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
bitmap[y * width + x] = (y << 8) + x + (128<<24);
}
}
SkPM4f* FPbuffer = new SkPM4f[width * height];
SkMatrix m = SkMatrix::I();
//m.setRotate(30.0f, 1.0f, 1.0f);
SkMatrix invert;
bool trash = m.invert(&invert);
sk_ignore_unused_variable(trash);
const SkImageInfo info =
SkImageInfo::MakeN32Premul(width, height, kLinear_SkColorProfileType);
SkLinearBitmapPipeline pipeline{invert, SkShader::kClamp_TileMode,
SkShader::kClamp_TileMode, info, bitmap};
int count = 10;
pipeline.shadeSpan4f(3, 6, FPbuffer, count);
Pixel* pixelBuffer = (Pixel*)FPbuffer;
for (int i = 0; i < count; i++) {
printf("i: %d - (%g, %g, %g, %g)\n", i,
pixelBuffer[i][0] * 255.0f,
pixelBuffer[i][1] * 255.0f,
pixelBuffer[i][2] * 255.0f,
pixelBuffer[i][3] * 255.0f);
}
delete [] bitmap;
delete [] FPbuffer;
}