diff options
| author |  reed <reed@chromium.org> | 2015-06-08 19:58:07 -0700 |
|---|---|---|
| committer |  Commit bot <commit-bot@chromium.org> | 2015-06-08 19:58:07 -0700 |
| commit | b3f0ec9f9967da2f80f0d842cb7fd53617b48de3 (patch) | |
| tree | f00f2095e30e48180a2a3a073be5bf1a1fe3f4c2 | |
| parent | 86ae0a9e465f157eaa263ef7515e10619946ff83 (diff) | |
Revert of change SkDraw and all Blitters to use pixmap instead of bitmap (patchset #6 id:100001 of https://codereview.chromium.org/1148793007/)
Reason for revert:
speculative revert to try to unblock DEPS roll
Original issue's description:
> change SkDraw and all Blitters to use pixmap instead of bitmap
>
> BUG=skia:
>
> Committed: https://skia.googlesource.com/skia/+/c31af44336f5eb4a50e83e76e51962d46c3ed458
TBR=scroggo@google.com,jvanverth@google.com,reed@google.com
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=skia:
Review URL: https://codereview.chromium.org/1164373003
29 files changed, 374 insertions, 305 deletions
diff --git a/bench/CoverageBench.cpp b/bench/CoverageBench.cpp index 135ef39233..96eafaaace 100644 --- a/bench/CoverageBench.cpp +++ b/bench/CoverageBench.cpp @@ -19,7 +19,7 @@ class DrawPathBench : public Benchmark { SkString fName; SkPath fPath; SkRasterClip fRC; - SkAutoPixmapStorage fPixmap; + SkBitmap fBitmap; SkMatrix fIdentity; SkDraw fDraw; bool fDrawCoverage; @@ -32,12 +32,12 @@ public: fPath.quadTo(500, 0, 500, 500); fPath.quadTo(250, 0, 0, 500); - fPixmap.alloc(SkImageInfo::MakeA8(500, 500)); + fBitmap.allocPixels(SkImageInfo::MakeA8(500, 500)); fIdentity.setIdentity(); fRC.setRect(fPath.getBounds().round()); - fDraw.fDst = fPixmap; + fDraw.fBitmap = &fBitmap; fDraw.fMatrix = &fIdentity; fDraw.fClip = &fRC.bwRgn(); fDraw.fRC = &fRC; diff --git a/gm/fatpathfill.cpp b/gm/fatpathfill.cpp index 43e10059c1..1d269a0289 100644 --- a/gm/fatpathfill.cpp +++ b/gm/fatpathfill.cpp @@ -31,17 +31,22 @@ static void draw_pixel_centers(SkCanvas* canvas) { } } -static void draw_fatpath(SkCanvas* canvas, SkSurface* surface, const SkPath& path) { +static void draw_fatpath(SkCanvas* canvas, SkSurface* surface, + const SkPath paths[], int count) { SkPaint paint; surface->getCanvas()->clear(SK_ColorTRANSPARENT); - surface->getCanvas()->drawPath(path, paint); + for (int i = 0; i < count; ++i) { + surface->getCanvas()->drawPath(paths[i], paint); + } surface->draw(canvas, 0, 0, NULL); paint.setAntiAlias(true); paint.setColor(SK_ColorRED); paint.setStyle(SkPaint::kStroke_Style); - canvas->drawPath(path, paint); + for (int j = 0; j < count; ++j) { + canvas->drawPath(paths[j], paint); + } draw_pixel_centers(canvas); } @@ -52,15 +57,15 @@ public: protected: - SkString onShortName() override { + virtual SkString onShortName() { return SkString("fatpathfill"); } - SkISize onISize() override { + virtual SkISize onISize() { return SkISize::Make(SMALL_W * ZOOM, SMALL_H * ZOOM * REPEAT_LOOP); } - void onDraw(SkCanvas* canvas) override { + virtual void onDraw(SkCanvas* canvas) { SkAutoTUnref<SkSurface> surface(new_surface(SMALL_W, SMALL_H)); canvas->scale(ZOOM, ZOOM); @@ -71,10 +76,10 @@ protected: for (int i = 0; i < REPEAT_LOOP; ++i) { SkPath line, path; - line.moveTo(1, 2); - line.lineTo(SkIntToScalar(4 + i), 1); + line.moveTo(SkIntToScalar(1), SkIntToScalar(2)); + line.lineTo(SkIntToScalar(4 + i), SkIntToScalar(1)); paint.getFillPath(line, &path); - draw_fatpath(canvas, surface, path); + draw_fatpath(canvas, surface, &path, 1); canvas->translate(0, SMALL_H); } diff --git a/include/core/SkDraw.h b/include/core/SkDraw.h index 1f7d8174c1..7b5514d13b 100644 --- a/include/core/SkDraw.h +++ b/include/core/SkDraw.h @@ -140,8 +140,7 @@ private: computeConservativeLocalClipBounds(SkRect* bounds) const; public: -// const SkBitmap* fBitmap; // required - SkPixmap fDst; + const SkBitmap* fBitmap; // required const SkMatrix* fMatrix; // required const SkRegion* fClip; // DEPRECATED const SkRasterClip* fRC; // required diff --git a/src/core/SkAAClip.cpp b/src/core/SkAAClip.cpp index 19e94c8c86..e55451e3d9 100644 --- a/src/core/SkAAClip.cpp +++ b/src/core/SkAAClip.cpp @@ -1297,7 +1297,7 @@ public: void blitMask(const SkMask&, const SkIRect& clip) override { unexpected(); } - const SkPixmap* justAnOpaqueColor(uint32_t*) override { + const SkBitmap* justAnOpaqueColor(uint32_t*) override { return NULL; } @@ -2219,6 +2219,6 @@ void SkAAClipBlitter::blitMask(const SkMask& origMask, const SkIRect& clip) { } while (y < stopY); } -const SkPixmap* SkAAClipBlitter::justAnOpaqueColor(uint32_t* value) { +const SkBitmap* SkAAClipBlitter::justAnOpaqueColor(uint32_t* value) { return NULL; } diff --git a/src/core/SkAAClip.h b/src/core/SkAAClip.h index 9f6a3d6012..1daeb38f59 100644 --- a/src/core/SkAAClip.h +++ b/src/core/SkAAClip.h @@ -110,11 +110,12 @@ public: } void blitH(int x, int y, int width) override; - void blitAntiH(int x, int y, const SkAlpha[], const int16_t runs[]) override; + virtual void blitAntiH(int x, int y, const SkAlpha[], + const int16_t runs[]) override; void blitV(int x, int y, int height, SkAlpha alpha) override; void blitRect(int x, int y, int width, int height) override; void blitMask(const SkMask&, const SkIRect& clip) override; - const SkPixmap* justAnOpaqueColor(uint32_t* value) override; + const SkBitmap* justAnOpaqueColor(uint32_t* value) override; private: SkBlitter* fBlitter; diff --git a/src/core/SkBlitBWMaskTemplate.h b/src/core/SkBlitBWMaskTemplate.h index accf498aba..798e44aaa4 100644 --- a/src/core/SkBlitBWMaskTemplate.h +++ b/src/core/SkBlitBWMaskTemplate.h @@ -19,19 +19,19 @@ SK_BLITBWMASK_NAME name of function(const SkBitmap& bitmap, const SkMask& mask, const SkIRect& clip, SK_BLITBWMASK_ARGS) SK_BLITBWMASK_ARGS list of additional arguments to SK_BLITBWMASK_NAME, beginning with a comma SK_BLITBWMASK_BLIT8 name of function(U8CPU byteMask, SK_BLITBWMASK_DEVTYPE* dst, int x, int y) - SK_BLITBWMASK_GETADDR either writable_addr[8,16,32] + SK_BLITBWMASK_GETADDR either getAddr32 or getAddr16 or getAddr8 SK_BLITBWMASK_DEVTYPE either U32 or U16 or U8 */ -static void SK_BLITBWMASK_NAME(const SkPixmap& dst, const SkMask& srcMask, - const SkIRect& clip SK_BLITBWMASK_ARGS) { +static void SK_BLITBWMASK_NAME(const SkBitmap& bitmap, const SkMask& srcMask, const SkIRect& clip SK_BLITBWMASK_ARGS) +{ SkASSERT(clip.fRight <= srcMask.fBounds.fRight); int cx = clip.fLeft; int cy = clip.fTop; int maskLeft = srcMask.fBounds.fLeft; unsigned mask_rowBytes = srcMask.fRowBytes; - size_t bitmap_rowBytes = dst.rowBytes(); + size_t bitmap_rowBytes = bitmap.rowBytes(); unsigned height = clip.height(); SkASSERT(mask_rowBytes != 0); @@ -39,7 +39,7 @@ static void SK_BLITBWMASK_NAME(const SkPixmap& dst, const SkMask& srcMask, SkASSERT(height != 0); const uint8_t* bits = srcMask.getAddr1(cx, cy); - SK_BLITBWMASK_DEVTYPE* device = dst.SK_BLITBWMASK_GETADDR(cx, cy); + SK_BLITBWMASK_DEVTYPE* device = bitmap.SK_BLITBWMASK_GETADDR(cx, cy); if (cx == maskLeft && clip.fRight == srcMask.fBounds.fRight) { diff --git a/src/core/SkBlitMask.h b/src/core/SkBlitMask.h index 3fc306f8c8..32db43c3d8 100644 --- a/src/core/SkBlitMask.h +++ b/src/core/SkBlitMask.h @@ -8,9 +8,9 @@ #ifndef SkBlitMask_DEFINED #define SkBlitMask_DEFINED +#include "SkBitmap.h" #include "SkColor.h" #include "SkMask.h" -#include "SkPixmap.h" class SkBlitMask { public: @@ -18,7 +18,7 @@ public: * Returns true if the device config and mask format were supported. * else return false (nothing was drawn) */ - static bool BlitColor(const SkPixmap& device, const SkMask& mask, + static bool BlitColor(const SkBitmap& device, const SkMask& mask, const SkIRect& clip, SkColor color); /** diff --git a/src/core/SkBlitMask_D32.cpp b/src/core/SkBlitMask_D32.cpp index 210810801a..594a274d42 100644 --- a/src/core/SkBlitMask_D32.cpp +++ b/src/core/SkBlitMask_D32.cpp @@ -147,13 +147,13 @@ SkBlitMask::ColorProc SkBlitMask::ColorFactory(SkColorType ct, return NULL; } -bool SkBlitMask::BlitColor(const SkPixmap& device, const SkMask& mask, +bool SkBlitMask::BlitColor(const SkBitmap& device, const SkMask& mask, const SkIRect& clip, SkColor color) { ColorProc proc = ColorFactory(device.colorType(), mask.fFormat, color); if (proc) { int x = clip.fLeft; int y = clip.fTop; - proc(device.writable_addr32(x, y), device.rowBytes(), mask.getAddr(x, y), + proc(device.getAddr32(x, y), device.rowBytes(), mask.getAddr(x, y), mask.fRowBytes, color, clip.width(), clip.height()); return true; } diff --git a/src/core/SkBlitter.cpp b/src/core/SkBlitter.cpp index 59078d6a87..2ac7b51180 100644 --- a/src/core/SkBlitter.cpp +++ b/src/core/SkBlitter.cpp @@ -33,7 +33,7 @@ SkShader::Context* SkBlitter::getShaderContext() const { return NULL; } -const SkPixmap* SkBlitter::justAnOpaqueColor(uint32_t* value) { +const SkBitmap* SkBlitter::justAnOpaqueColor(uint32_t* value) { return NULL; } @@ -243,7 +243,7 @@ void SkNullBlitter::blitRect(int x, int y, int width, int height) {} void SkNullBlitter::blitMask(const SkMask& mask, const SkIRect& clip) {} -const SkPixmap* SkNullBlitter::justAnOpaqueColor(uint32_t* value) { +const SkBitmap* SkNullBlitter::justAnOpaqueColor(uint32_t* value) { return NULL; } @@ -404,7 +404,7 @@ void SkRectClipBlitter::blitMask(const SkMask& mask, const SkIRect& clip) { } } -const SkPixmap* SkRectClipBlitter::justAnOpaqueColor(uint32_t* value) { +const SkBitmap* SkRectClipBlitter::justAnOpaqueColor(uint32_t* value) { return fBlitter->justAnOpaqueColor(value); } @@ -540,7 +540,7 @@ void SkRgnClipBlitter::blitMask(const SkMask& mask, const SkIRect& clip) { } } -const SkPixmap* SkRgnClipBlitter::justAnOpaqueColor(uint32_t* value) { +const SkBitmap* SkRgnClipBlitter::justAnOpaqueColor(uint32_t* value) { return fBlitter->justAnOpaqueColor(value); } @@ -778,7 +778,7 @@ private: #include "SkCoreBlitters.h" -SkBlitter* SkBlitter::Choose(const SkPixmap& device, +SkBlitter* SkBlitter::Choose(const SkBitmap& device, const SkMatrix& matrix, const SkPaint& origPaint, SkTBlitterAllocator* allocator, @@ -944,7 +944,7 @@ private: typedef SkShader::Context INHERITED; }; -SkShaderBlitter::SkShaderBlitter(const SkPixmap& device, const SkPaint& paint, +SkShaderBlitter::SkShaderBlitter(const SkBitmap& device, const SkPaint& paint, SkShader::Context* shaderContext) : INHERITED(device) , fShader(paint.getShader()) diff --git a/src/core/SkBlitter.h b/src/core/SkBlitter.h index b8126c24c6..695585a798 100644 --- a/src/core/SkBlitter.h +++ b/src/core/SkBlitter.h @@ -8,11 +8,11 @@ #ifndef SkBlitter_DEFINED #define SkBlitter_DEFINED +#include "SkBitmap.h" #include "SkBitmapProcShader.h" #include "SkMask.h" #include "SkMatrix.h" #include "SkPaint.h" -#include "SkPixmap.h" #include "SkRefCnt.h" #include "SkRegion.h" #include "SkShader.h" @@ -51,7 +51,7 @@ public: bitmap it draws into, and assign value. If not, return NULL and ignore the value parameter. */ - virtual const SkPixmap* justAnOpaqueColor(uint32_t* value); + virtual const SkBitmap* justAnOpaqueColor(uint32_t* value); // (x, y), (x + 1, y) virtual void blitAntiH2(int x, int y, U8CPU a0, U8CPU a1) { @@ -122,7 +122,7 @@ public: /** @name Factories Return the correct blitter to use given the specified context. */ - static SkBlitter* Choose(const SkPixmap& dst, + static SkBlitter* Choose(const SkBitmap& device, const SkMatrix& matrix, const SkPaint& paint, SkTBlitterAllocator*, @@ -152,7 +152,7 @@ public: void blitV(int x, int y, int height, SkAlpha alpha) override; void blitRect(int x, int y, int width, int height) override; void blitMask(const SkMask&, const SkIRect& clip) override; - const SkPixmap* justAnOpaqueColor(uint32_t* value) override; + const SkBitmap* justAnOpaqueColor(uint32_t* value) override; bool isNullBlitter() const override; }; @@ -176,7 +176,7 @@ public: virtual void blitAntiRect(int x, int y, int width, int height, SkAlpha leftAlpha, SkAlpha rightAlpha) override; void blitMask(const SkMask&, const SkIRect& clip) override; - const SkPixmap* justAnOpaqueColor(uint32_t* value) override; + const SkBitmap* justAnOpaqueColor(uint32_t* value) override; int requestRowsPreserved() const override { return fBlitter->requestRowsPreserved(); @@ -211,7 +211,7 @@ public: virtual void blitAntiRect(int x, int y, int width, int height, SkAlpha leftAlpha, SkAlpha rightAlpha) override; void blitMask(const SkMask&, const SkIRect& clip) override; - const SkPixmap* justAnOpaqueColor(uint32_t* value) override; + const SkBitmap* justAnOpaqueColor(uint32_t* value) override; int requestRowsPreserved() const override { return fBlitter->requestRowsPreserved(); diff --git a/src/core/SkBlitter_A8.cpp b/src/core/SkBlitter_A8.cpp index ce7d6e7ad2..11f425903b 100644 --- a/src/core/SkBlitter_A8.cpp +++ b/src/core/SkBlitter_A8.cpp @@ -12,11 +12,12 @@ #include "SkShader.h" #include "SkXfermode.h" -SkA8_Blitter::SkA8_Blitter(const SkPixmap& device, const SkPaint& paint) : INHERITED(device) { +SkA8_Blitter::SkA8_Blitter(const SkBitmap& device, const SkPaint& paint) + : INHERITED(device) { fSrcA = paint.getAlpha(); } -const SkPixmap* SkA8_Blitter::justAnOpaqueColor(uint32_t* value) { +const SkBitmap* SkA8_Blitter::justAnOpaqueColor(uint32_t* value) { if (255 == fSrcA) { *value = 255; return &fDevice; @@ -32,7 +33,7 @@ void SkA8_Blitter::blitH(int x, int y, int width) { return; } - uint8_t* device = fDevice.writable_addr8(x, y); + uint8_t* device = fDevice.getAddr8(x, y); if (fSrcA == 255) { memset(device, 0xFF, width); @@ -52,7 +53,7 @@ void SkA8_Blitter::blitAntiH(int x, int y, const SkAlpha antialias[], return; } - uint8_t* device = fDevice.writable_addr8(x, y); + uint8_t* device = fDevice.getAddr8(x, y); unsigned srcA = fSrcA; for (;;) { @@ -96,7 +97,7 @@ void SkA8_Blitter::blitAntiH(int x, int y, const SkAlpha antialias[], #define SK_BLITBWMASK_NAME SkA8_BlitBW #define SK_BLITBWMASK_ARGS #define SK_BLITBWMASK_BLIT8(mask, dst) solid_8_pixels(mask, dst) -#define SK_BLITBWMASK_GETADDR writable_addr8 +#define SK_BLITBWMASK_GETADDR getAddr8 #define SK_BLITBWMASK_DEVTYPE uint8_t #include "SkBlitBWMaskTemplate.h" @@ -115,7 +116,7 @@ static inline void blend_8_pixels(U8CPU bw, uint8_t dst[], U8CPU sa, #define SK_BLITBWMASK_NAME SkA8_BlendBW #define SK_BLITBWMASK_ARGS , U8CPU sa, unsigned dst_scale #define SK_BLITBWMASK_BLIT8(mask, dst) blend_8_pixels(mask, dst, sa, dst_scale) -#define SK_BLITBWMASK_GETADDR writable_addr8 +#define SK_BLITBWMASK_GETADDR getAddr8 #define SK_BLITBWMASK_DEVTYPE uint8_t #include "SkBlitBWMaskTemplate.h" @@ -138,7 +139,7 @@ void SkA8_Blitter::blitMask(const SkMask& mask, const SkIRect& clip) { int y = clip.fTop; int width = clip.width(); int height = clip.height(); - uint8_t* device = fDevice.writable_addr8(x, y); + uint8_t* device = fDevice.getAddr8(x, y); const uint8_t* alpha = mask.getAddr8(x, y); unsigned srcA = fSrcA; @@ -178,7 +179,7 @@ void SkA8_Blitter::blitV(int x, int y, int height, SkAlpha alpha) { } unsigned sa = SkAlphaMul(fSrcA, SkAlpha255To256(alpha)); - uint8_t* device = fDevice.writable_addr8(x, y); + uint8_t* device = fDevice.getAddr8(x, y); size_t rowBytes = fDevice.rowBytes(); if (sa == 0xFF) { @@ -205,7 +206,7 @@ void SkA8_Blitter::blitRect(int x, int y, int width, int height) { return; } - uint8_t* device = fDevice.writable_addr8(x, y); + uint8_t* device = fDevice.getAddr8(x, y); unsigned srcA = fSrcA; if (srcA == 255) { @@ -227,10 +228,9 @@ void SkA8_Blitter::blitRect(int x, int y, int width, int height) { /////////////////////////////////////////////////////////////////////// -SkA8_Shader_Blitter::SkA8_Shader_Blitter(const SkPixmap& device, const SkPaint& paint, +SkA8_Shader_Blitter::SkA8_Shader_Blitter(const SkBitmap& device, const SkPaint& paint, SkShader::Context* shaderContext) - : INHERITED(device, paint, shaderContext) -{ + : INHERITED(device, paint, shaderContext) { if ((fXfermode = paint.getXfermode()) != NULL) { fXfermode->ref(); SkASSERT(fShaderContext); @@ -250,7 +250,7 @@ void SkA8_Shader_Blitter::blitH(int x, int y, int width) { SkASSERT(x >= 0 && y >= 0 && (unsigned)(x + width) <= (unsigned)fDevice.width()); - uint8_t* device = fDevice.writable_addr8(x, y); + uint8_t* device = fDevice.getAddr8(x, y); SkShader::Context* shaderContext = fShaderContext; if ((shaderContext->getFlags() & SkShader::kOpaqueAlpha_Flag) && !fXfermode) { @@ -288,7 +288,7 @@ void SkA8_Shader_Blitter::blitAntiH(int x, int y, const SkAlpha antialias[], SkXfermode* mode = fXfermode; uint8_t* aaExpand = fAAExpand; SkPMColor* span = fBuffer; - uint8_t* device = fDevice.writable_addr8(x, y); + uint8_t* device = fDevice.getAddr8(x, y); int opaque = shaderContext->getFlags() & SkShader::kOpaqueAlpha_Flag; for (;;) { @@ -329,7 +329,7 @@ void SkA8_Shader_Blitter::blitMask(const SkMask& mask, const SkIRect& clip) { int y = clip.fTop; int width = clip.width(); int height = clip.height(); - uint8_t* device = fDevice.writable_addr8(x, y); + uint8_t* device = fDevice.getAddr8(x, y); const uint8_t* alpha = mask.getAddr8(x, y); SkShader::Context* shaderContext = fShaderContext; @@ -353,7 +353,7 @@ void SkA8_Shader_Blitter::blitMask(const SkMask& mask, const SkIRect& clip) { /////////////////////////////////////////////////////////////////////////////// -SkA8_Coverage_Blitter::SkA8_Coverage_Blitter(const SkPixmap& device, +SkA8_Coverage_Blitter::SkA8_Coverage_Blitter(const SkBitmap& device, const SkPaint& paint) : SkRasterBlitter(device) { SkASSERT(NULL == paint.getShader()); SkASSERT(NULL == paint.getXfermode()); @@ -362,7 +362,7 @@ SkA8_Coverage_Blitter::SkA8_Coverage_Blitter(const SkPixmap& device, void SkA8_Coverage_Blitter::blitAntiH(int x, int y, const SkAlpha antialias[], const int16_t runs[]) { - uint8_t* device = fDevice.writable_addr8(x, y); + uint8_t* device = fDevice.getAddr8(x, y); SkDEBUGCODE(int totalCount = 0;) for (;;) { @@ -384,7 +384,7 @@ void SkA8_Coverage_Blitter::blitAntiH(int x, int y, const SkAlpha antialias[], } void SkA8_Coverage_Blitter::blitH(int x, int y, int width) { - memset(fDevice.writable_addr8(x, y), 0xFF, width); + memset(fDevice.getAddr8(x, y), 0xFF, width); } void SkA8_Coverage_Blitter::blitV(int x, int y, int height, SkAlpha alpha) { @@ -392,7 +392,7 @@ void SkA8_Coverage_Blitter::blitV(int x, int y, int height, SkAlpha alpha) { return; } - uint8_t* dst = fDevice.writable_addr8(x, y); + uint8_t* dst = fDevice.getAddr8(x, y); const size_t dstRB = fDevice.rowBytes(); while (--height >= 0) { *dst = alpha; @@ -401,7 +401,7 @@ void SkA8_Coverage_Blitter::blitV(int x, int y, int height, SkAlpha alpha) { } void SkA8_Coverage_Blitter::blitRect(int x, int y, int width, int height) { - uint8_t* dst = fDevice.writable_addr8(x, y); + uint8_t* dst = fDevice.getAddr8(x, y); const size_t dstRB = fDevice.rowBytes(); while (--height >= 0) { memset(dst, 0xFF, width); @@ -417,7 +417,7 @@ void SkA8_Coverage_Blitter::blitMask(const SkMask& mask, const SkIRect& clip) { int width = clip.width(); int height = clip.height(); - uint8_t* dst = fDevice.writable_addr8(x, y); + uint8_t* dst = fDevice.getAddr8(x, y); const uint8_t* src = mask.getAddr8(x, y); const size_t srcRB = mask.fRowBytes; const size_t dstRB = fDevice.rowBytes(); @@ -429,6 +429,6 @@ void SkA8_Coverage_Blitter::blitMask(const SkMask& mask, const SkIRect& clip) { } } -const SkPixmap* SkA8_Coverage_Blitter::justAnOpaqueColor(uint32_t*) { +const SkBitmap* SkA8_Coverage_Blitter::justAnOpaqueColor(uint32_t*) { return NULL; } diff --git a/src/core/SkBlitter_ARGB32.cpp b/src/core/SkBlitter_ARGB32.cpp index 683acf0aae..f2de82a2e9 100644 --- a/src/core/SkBlitter_ARGB32.cpp +++ b/src/core/SkBlitter_ARGB32.cpp @@ -14,7 +14,7 @@ /////////////////////////////////////////////////////////////////////////////// -static void SkARGB32_Blit32(const SkPixmap& device, const SkMask& mask, +static void SkARGB32_Blit32(const SkBitmap& device, const SkMask& mask, const SkIRect& clip, SkPMColor srcColor) { U8CPU alpha = SkGetPackedA32(srcColor); unsigned flags = SkBlitRow::kSrcPixelAlpha_Flag32; @@ -28,7 +28,7 @@ static void SkARGB32_Blit32(const SkPixmap& device, const SkMask& mask, int width = clip.width(); int height = clip.height(); - SkPMColor* dstRow = device.writable_addr32(x, y); + SkPMColor* dstRow = device.getAddr32(x, y); const SkPMColor* srcRow = reinterpret_cast<const SkPMColor*>(mask.getAddr8(x, y)); do { @@ -40,7 +40,7 @@ static void SkARGB32_Blit32(const SkPixmap& device, const SkMask& mask, ////////////////////////////////////////////////////////////////////////////////////// -SkARGB32_Blitter::SkARGB32_Blitter(const SkPixmap& device, const SkPaint& paint) +SkARGB32_Blitter::SkARGB32_Blitter(const SkBitmap& device, const SkPaint& paint) : INHERITED(device) { SkColor color = paint.getColor(); fColor = color; @@ -54,7 +54,7 @@ SkARGB32_Blitter::SkARGB32_Blitter(const SkPixmap& device, const SkPaint& paint) fPMColor = SkPackARGB32(fSrcA, fSrcR, fSrcG, fSrcB); } -const SkPixmap* SkARGB32_Blitter::justAnOpaqueColor(uint32_t* value) { +const SkBitmap* SkARGB32_Blitter::justAnOpaqueColor(uint32_t* value) { if (255 == fSrcA) { *value = fPMColor; return &fDevice; @@ -70,7 +70,7 @@ const SkPixmap* SkARGB32_Blitter::justAnOpaqueColor(uint32_t* value) { void SkARGB32_Blitter::blitH(int x, int y, int width) { SkASSERT(x >= 0 && y >= 0 && x + width <= fDevice.width()); - uint32_t* device = fDevice.writable_addr32(x, y); + uint32_t* device = fDevice.getAddr32(x, y); SkBlitRow::Color32(device, device, width, fPMColor); } @@ -81,7 +81,7 @@ void SkARGB32_Blitter::blitAntiH(int x, int y, const SkAlpha antialias[], } uint32_t color = fPMColor; - uint32_t* device = fDevice.writable_addr32(x, y); + uint32_t* device = fDevice.getAddr32(x, y); unsigned opaqueMask = fSrcA; // if fSrcA is 0xFF, then we will catch the fast opaque case for (;;) { @@ -106,16 +106,16 @@ void SkARGB32_Blitter::blitAntiH(int x, int y, const SkAlpha antialias[], } void SkARGB32_Blitter::blitAntiH2(int x, int y, U8CPU a0, U8CPU a1) { - uint32_t* device = fDevice.writable_addr32(x, y); - SkDEBUGCODE((void)fDevice.writable_addr32(x + 1, y);) + uint32_t* device = fDevice.getAddr32(x, y); + SkDEBUGCODE((void)fDevice.getAddr32(x + 1, y);) device[0] = SkBlendARGB32(fPMColor, device[0], a0); device[1] = SkBlendARGB32(fPMColor, device[1], a1); } void SkARGB32_Blitter::blitAntiV2(int x, int y, U8CPU a0, U8CPU a1) { - uint32_t* device = fDevice.writable_addr32(x, y); - SkDEBUGCODE((void)fDevice.writable_addr32(x, y + 1);) + uint32_t* device = fDevice.getAddr32(x, y); + SkDEBUGCODE((void)fDevice.getAddr32(x, y + 1);) device[0] = SkBlendARGB32(fPMColor, device[0], a0); device = (uint32_t*)((char*)device + fDevice.rowBytes()); @@ -139,7 +139,7 @@ void SkARGB32_Blitter::blitAntiV2(int x, int y, U8CPU a0, U8CPU a1) { #define SK_BLITBWMASK_NAME SkARGB32_BlitBW #define SK_BLITBWMASK_ARGS , SkPMColor color #define SK_BLITBWMASK_BLIT8(mask, dst) solid_8_pixels(mask, dst, color) -#define SK_BLITBWMASK_GETADDR writable_addr32 +#define SK_BLITBWMASK_GETADDR getAddr32 #define SK_BLITBWMASK_DEVTYPE uint32_t #include "SkBlitBWMaskTemplate.h" @@ -158,7 +158,7 @@ void SkARGB32_Blitter::blitAntiV2(int x, int y, U8CPU a0, U8CPU a1) { #define SK_BLITBWMASK_NAME SkARGB32_BlendBW #define SK_BLITBWMASK_ARGS , uint32_t sc, unsigned dst_scale #define SK_BLITBWMASK_BLIT8(mask, dst) blend_8_pixels(mask, dst, sc, dst_scale) -#define SK_BLITBWMASK_GETADDR writable_addr32 +#define SK_BLITBWMASK_GETADDR getAddr32 #define SK_BLITBWMASK_DEVTYPE uint32_t #include "SkBlitBWMaskTemplate.h" @@ -197,16 +197,16 @@ void SkARGB32_Opaque_Blitter::blitMask(const SkMask& mask, } void SkARGB32_Opaque_Blitter::blitAntiH2(int x, int y, U8CPU a0, U8CPU a1) { - uint32_t* device = fDevice.writable_addr32(x, y); - SkDEBUGCODE((void)fDevice.writable_addr32(x + 1, y);) + uint32_t* device = fDevice.getAddr32(x, y); + SkDEBUGCODE((void)fDevice.getAddr32(x + 1, y);) device[0] = SkFastFourByteInterp(fPMColor, device[0], a0); device[1] = SkFastFourByteInterp(fPMColor, device[1], a1); } void SkARGB32_Opaque_Blitter::blitAntiV2(int x, int y, U8CPU a0, U8CPU a1) { - uint32_t* device = fDevice.writable_addr32(x, y); - SkDEBUGCODE((void)fDevice.writable_addr32(x, y + 1);) + uint32_t* device = fDevice.getAddr32(x, y); + SkDEBUGCODE((void)fDevice.getAddr32(x, y + 1);) device[0] = SkFastFourByteInterp(fPMColor, device[0], a0); device = (uint32_t*)((char*)device + fDevice.rowBytes()); @@ -220,7 +220,7 @@ void SkARGB32_Blitter::blitV(int x, int y, int height, SkAlpha alpha) { return; } - uint32_t* device = fDevice.writable_addr32(x, y); + uint32_t* device = fDevice.getAddr32(x, y); uint32_t color = fPMColor; if (alpha != 255) { @@ -242,7 +242,7 @@ void SkARGB32_Blitter::blitRect(int x, int y, int width, int height) { return; } - uint32_t* device = fDevice.writable_addr32(x, y); + uint32_t* device = fDevice.getAddr32(x, y); uint32_t color = fPMColor; size_t rowBytes = fDevice.rowBytes(); @@ -260,7 +260,7 @@ void SkARGB32_Blitter::blitRect(int x, int y, int width, int height) { void SkARGB32_Black_Blitter::blitAntiH(int x, int y, const SkAlpha antialias[], const int16_t runs[]) { - uint32_t* device = fDevice.writable_addr32(x, y); + uint32_t* device = fDevice.getAddr32(x, y); SkPMColor black = (SkPMColor)(SK_A32_MASK << SK_A32_SHIFT); for (;;) { @@ -290,16 +290,16 @@ void SkARGB32_Black_Blitter::blitAntiH(int x, int y, const SkAlpha antialias[], } void SkARGB32_Black_Blitter::blitAntiH2(int x, int y, U8CPU a0, U8CPU a1) { - uint32_t* device = fDevice.writable_addr32(x, y); - SkDEBUGCODE((void)fDevice.writable_addr32(x + 1, y);) + uint32_t* device = fDevice.getAddr32(x, y); + SkDEBUGCODE((void)fDevice.getAddr32(x + 1, y);) device[0] = (a0 << SK_A32_SHIFT) + SkAlphaMulQ(device[0], 256 - a0); device[1] = (a1 << SK_A32_SHIFT) + SkAlphaMulQ(device[1], 256 - a1); } void SkARGB32_Black_Blitter::blitAntiV2(int x, int y, U8CPU a0, U8CPU a1) { - uint32_t* device = fDevice.writable_addr32(x, y); - SkDEBUGCODE((void)fDevice.writable_addr32(x, y + 1);) + uint32_t* device = fDevice.getAddr32(x, y); + SkDEBUGCODE((void)fDevice.getAddr32(x, y + 1);) device[0] = (a0 << SK_A32_SHIFT) + SkAlphaMulQ(device[0], 256 - a0); device = (uint32_t*)((char*)device + fDevice.rowBytes()); @@ -319,7 +319,7 @@ static void blend_srcmode(SkPMColor* SK_RESTRICT device, } } -SkARGB32_Shader_Blitter::SkARGB32_Shader_Blitter(const SkPixmap& device, +SkARGB32_Shader_Blitter::SkARGB32_Shader_Blitter(const SkBitmap& device, const SkPaint& paint, SkShader::Context* shaderContext) : INHERITED(device, paint, shaderContext) { @@ -363,7 +363,7 @@ SkARGB32_Shader_Blitter::~SkARGB32_Shader_Blitter() { void SkARGB32_Shader_Blitter::blitH(int x, int y, int width) { SkASSERT(x >= 0 && y >= 0 && x + width <= fDevice.width()); - uint32_t* device = fDevice.writable_addr32(x, y); + uint32_t* device = fDevice.getAddr32(x, y); if (fShadeDirectlyIntoDevice) { fShaderContext->shadeSpan(x, y, device, width); @@ -382,7 +382,7 @@ void SkARGB32_Shader_Blitter::blitRect(int x, int y, int width, int height) { SkASSERT(x >= 0 && y >= 0 && x + width <= fDevice.width() && y + height <= fDevice.height()); - uint32_t* device = fDevice.writable_addr32(x, y); + uint32_t* device = fDevice.getAddr32(x, y); size_t deviceRB = fDevice.rowBytes(); SkShader::Context* shaderContext = fShaderContext; SkPMColor* span = fBuffer; @@ -457,7 +457,7 @@ void SkARGB32_Shader_Blitter::blitRect(int x, int y, int width, int height) { void SkARGB32_Shader_Blitter::blitAntiH(int x, int y, const SkAlpha antialias[], const int16_t runs[]) { SkPMColor* span = fBuffer; - uint32_t* device = fDevice.writable_addr32(x, y); + uint32_t* device = fDevice.getAddr32(x, y); SkShader::Context* shaderContext = fShaderContext; if (fXfermode && !fShadeDirectlyIntoDevice) { @@ -558,7 +558,7 @@ void SkARGB32_Shader_Blitter::blitMask(const SkMask& mask, const SkIRect& clip) int y = clip.fTop; int height = clip.height(); - char* dstRow = (char*)fDevice.writable_addr32(x, y); + char* dstRow = (char*)fDevice.getAddr32(x, y); const size_t dstRB = fDevice.rowBytes(); const uint8_t* maskRow = (const uint8_t*)mask.getAddr(x, y); const size_t maskRB = mask.fRowBytes; @@ -589,7 +589,7 @@ void SkARGB32_Shader_Blitter::blitMask(const SkMask& mask, const SkIRect& clip) void SkARGB32_Shader_Blitter::blitV(int x, int y, int height, SkAlpha alpha) { SkASSERT(x >= 0 && y >= 0 && y + height <= fDevice.height()); - uint32_t* device = fDevice.writable_addr32(x, y); + uint32_t* device = fDevice.getAddr32(x, y); size_t deviceRB = fDevice.rowBytes(); SkShader::Context* shaderContext = fShaderContext; diff --git a/src/core/SkBlitter_RGB16.cpp b/src/core/SkBlitter_RGB16.cpp index 6724b12ace..ed9e103b6d 100644 --- a/src/core/SkBlitter_RGB16.cpp +++ b/src/core/SkBlitter_RGB16.cpp @@ -1,3 +1,4 @@ + /* * Copyright 2006 The Android Open Source Project * @@ -5,6 +6,7 @@ * found in the LICENSE file. */ + #include "SkBlitRow.h" #include "SkCoreBlitters.h" #include "SkColorPriv.h" @@ -56,14 +58,15 @@ void sk_dither_memset16(uint16_t dst[], uint16_t value, uint16_t other, class SkRGB16_Blitter : public SkRasterBlitter { public: - SkRGB16_Blitter(const SkPixmap& device, const SkPaint& paint); + SkRGB16_Blitter(const SkBitmap& device, const SkPaint& paint); void blitH(int x, int y, int width) override; virtual void blitAntiH(int x, int y, const SkAlpha* antialias, const int16_t* runs) override; void blitV(int x, int y, int height, SkAlpha alpha) override; void blitRect(int x, int y, int width, int height) override; - void blitMask(const SkMask&, const SkIRect&) override; - const SkPixmap* justAnOpaqueColor(uint32_t*) override; + virtual void blitMask(const SkMask&, + const SkIRect&) override; + const SkBitmap* justAnOpaqueColor(uint32_t*) override; protected: SkPMColor fSrcColor32; @@ -84,12 +87,14 @@ protected: class SkRGB16_Opaque_Blitter : public SkRGB16_Blitter { public: - SkRGB16_Opaque_Blitter(const SkPixmap& device, const SkPaint& paint); + SkRGB16_Opaque_Blitter(const SkBitmap& device, const SkPaint& paint); void blitH(int x, int y, int width) override; - void blitAntiH(int x, int y, const SkAlpha* antialias, const int16_t* runs) override; + virtual void blitAntiH(int x, int y, const SkAlpha* antialias, + const int16_t* runs) override; void blitV(int x, int y, int height, SkAlpha alpha) override; void blitRect(int x, int y, int width, int height) override; - void blitMask(const SkMask&, const SkIRect&) override; + virtual void blitMask(const SkMask&, + const SkIRect&) override; private: typedef SkRGB16_Blitter INHERITED; @@ -98,9 +103,10 @@ private: #ifdef USE_BLACK_BLITTER class SkRGB16_Black_Blitter : public SkRGB16_Opaque_Blitter { public: - SkRGB16_Black_Blitter(const SkPixmap& device, const SkPaint& paint); + SkRGB16_Black_Blitter(const SkBitmap& device, const SkPaint& paint); void blitMask(const SkMask&, const SkIRect&) override; - void blitAntiH(int x, int y, const SkAlpha* antialias, const int16_t* runs) override; + virtual void blitAntiH(int x, int y, const SkAlpha* antialias, + const int16_t* runs) override; private: typedef SkRGB16_Opaque_Blitter INHERITED; @@ -109,7 +115,7 @@ private: class SkRGB16_Shader_Blitter : public SkShaderBlitter { public: - SkRGB16_Shader_Blitter(const SkPixmap& device, const SkPaint& paint, + SkRGB16_Shader_Blitter(const SkBitmap& device, const SkPaint& paint, SkShader::Context* shaderContext); virtual ~SkRGB16_Shader_Blitter(); void blitH(int x, int y, int width) override; @@ -132,7 +138,7 @@ private: // used only if the shader can perform shadSpan16 class SkRGB16_Shader16_Blitter : public SkRGB16_Shader_Blitter { public: - SkRGB16_Shader16_Blitter(const SkPixmap& device, const SkPaint& paint, + SkRGB16_Shader16_Blitter(const SkBitmap& device, const SkPaint& paint, SkShader::Context* shaderContext); void blitH(int x, int y, int width) override; virtual void blitAntiH(int x, int y, const SkAlpha* antialias, @@ -145,7 +151,7 @@ private: class SkRGB16_Shader_Xfermode_Blitter : public SkShaderBlitter { public: - SkRGB16_Shader_Xfermode_Blitter(const SkPixmap& device, const SkPaint& paint, + SkRGB16_Shader_Xfermode_Blitter(const SkBitmap& device, const SkPaint& paint, SkShader::Context* shaderContext); virtual ~SkRGB16_Shader_Xfermode_Blitter(); void blitH(int x, int y, int width) override; @@ -165,7 +171,7 @@ private: /////////////////////////////////////////////////////////////////////////////// #ifdef USE_BLACK_BLITTER -SkRGB16_Black_Blitter::SkRGB16_Black_Blitter(const SkPixmap& device, const SkPaint& paint) +SkRGB16_Black_Blitter::SkRGB16_Black_Blitter(const SkBitmap& device, const SkPaint& paint) : INHERITED(device, paint) { SkASSERT(paint.getShader() == NULL); SkASSERT(paint.getColorFilter() == NULL); @@ -202,7 +208,7 @@ static inline black_8_pixels(U8CPU mask, uint16_t dst[]) #define SK_BLITBWMASK_NAME SkRGB16_Black_BlitBW #define SK_BLITBWMASK_ARGS #define SK_BLITBWMASK_BLIT8(mask, dst) black_8_pixels(mask, dst) -#define SK_BLITBWMASK_GETADDR writable_addr16 +#define SK_BLITBWMASK_GETADDR getAddr16 #define SK_BLITBWMASK_DEVTYPE uint16_t #include "SkBlitBWMaskTemplate.h" @@ -211,7 +217,7 @@ void SkRGB16_Black_Blitter::blitMask(const SkMask& mask, if (mask.fFormat == SkMask::kBW_Format) { SkRGB16_Black_BlitBW(fDevice, mask, clip); } else { - uint16_t* SK_RESTRICT device = fDevice.writable_addr16(clip.fLeft, clip.fTop); + uint16_t* SK_RESTRICT device = fDevice.getAddr16(clip.fLeft, clip.fTop); const uint8_t* SK_RESTRICT alpha = mask.getAddr8(clip.fLeft, clip.fTop); unsigned width = clip.width(); unsigned height = clip.height(); @@ -239,7 +245,7 @@ void SkRGB16_Black_Blitter::blitMask(const SkMask& mask, void SkRGB16_Black_Blitter::blitAntiH(int x, int y, const SkAlpha* SK_RESTRICT antialias, const int16_t* SK_RESTRICT runs) { - uint16_t* SK_RESTRICT device = fDevice.writable_addr16(x, y); + uint16_t* SK_RESTRICT device = fDevice.getAddr16(x, y); for (;;) { int count = runs[0]; @@ -271,13 +277,14 @@ void SkRGB16_Black_Blitter::blitAntiH(int x, int y, /////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////// -SkRGB16_Opaque_Blitter::SkRGB16_Opaque_Blitter(const SkPixmap& device, const SkPaint& paint) - : INHERITED(device, paint) {} +SkRGB16_Opaque_Blitter::SkRGB16_Opaque_Blitter(const SkBitmap& device, + const SkPaint& paint) +: INHERITED(device, paint) {} void SkRGB16_Opaque_Blitter::blitH(int x, int y, int width) { SkASSERT(width > 0); SkASSERT(x + width <= fDevice.width()); - uint16_t* SK_RESTRICT device = fDevice.writable_addr16(x, y); + uint16_t* SK_RESTRICT device = fDevice.getAddr16(x, y); uint16_t srcColor = fColor16; SkASSERT(fRawColor16 == srcColor); @@ -300,7 +307,7 @@ static inline int Bool2Int(int value) { void SkRGB16_Opaque_Blitter::blitAntiH(int x, int y, const SkAlpha* SK_RESTRICT antialias, const int16_t* SK_RESTRICT runs) { - uint16_t* SK_RESTRICT device = fDevice.writable_addr16(x, y); + uint16_t* SK_RESTRICT device = fDevice.getAddr16(x, y); uint16_t srcColor = fRawColor16; uint32_t srcExpanded = fExpandedRaw16; int ditherInt = Bool2Int(fDoDither); @@ -365,7 +372,7 @@ void SkRGB16_Opaque_Blitter::blitAntiH(int x, int y, #define SK_BLITBWMASK_NAME SkRGB16_BlitBW #define SK_BLITBWMASK_ARGS , uint16_t color #define SK_BLITBWMASK_BLIT8(mask, dst) solid_8_pixels(mask, dst, color) -#define SK_BLITBWMASK_GETADDR writable_addr16 +#define SK_BLITBWMASK_GETADDR getAddr16 #define SK_BLITBWMASK_DEVTYPE uint16_t #include "SkBlitBWMaskTemplate.h" @@ -382,7 +389,7 @@ void SkRGB16_Opaque_Blitter::blitMask(const SkMask& mask, return; } - uint16_t* SK_RESTRICT device = fDevice.writable_addr16(clip.fLeft, clip.fTop); + uint16_t* SK_RESTRICT device = fDevice.getAddr16(clip.fLeft, clip.fTop); const uint8_t* SK_RESTRICT alpha = mask.getAddr8(clip.fLeft, clip.fTop); int width = clip.width(); int height = clip.height(); @@ -477,7 +484,7 @@ void SkRGB16_Opaque_Blitter::blitMask(const SkMask& mask, } void SkRGB16_Opaque_Blitter::blitV(int x, int y, int height, SkAlpha alpha) { - uint16_t* SK_RESTRICT device = fDevice.writable_addr16(x, y); + uint16_t* SK_RESTRICT device = fDevice.getAddr16(x, y); size_t deviceRB = fDevice.rowBytes(); // TODO: respect fDoDither @@ -493,7 +500,7 @@ void SkRGB16_Opaque_Blitter::blitV(int x, int y, int height, SkAlpha alpha) { void SkRGB16_Opaque_Blitter::blitRect(int x, int y, int width, int height) { SkASSERT(x + width <= fDevice.width() && y + height <= fDevice.height()); - uint16_t* SK_RESTRICT device = fDevice.writable_addr16(x, y); + uint16_t* SK_RESTRICT device = fDevice.getAddr16(x, y); size_t deviceRB = fDevice.rowBytes(); uint16_t color16 = fColor16; @@ -517,7 +524,7 @@ void SkRGB16_Opaque_Blitter::blitRect(int x, int y, int width, int height) { /////////////////////////////////////////////////////////////////////////////// -SkRGB16_Blitter::SkRGB16_Blitter(const SkPixmap& device, const SkPaint& paint) +SkRGB16_Blitter::SkRGB16_Blitter(const SkBitmap& device, const SkPaint& paint) : INHERITED(device) { SkColor color = paint.getColor(); @@ -554,7 +561,7 @@ SkRGB16_Blitter::SkRGB16_Blitter(const SkPixmap& device, const SkPaint& paint) fColorProc16 = SkBlitRow::ColorFactory16(flags); } -const SkPixmap* SkRGB16_Blitter::justAnOpaqueColor(uint32_t* value) { +const SkBitmap* SkRGB16_Blitter::justAnOpaqueColor(uint32_t* value) { if (!fDoDither && 256 == fScale) { *value = fRawColor16; return &fDevice; @@ -565,7 +572,7 @@ const SkPixmap* SkRGB16_Blitter::justAnOpaqueColor(uint32_t* value) { void SkRGB16_Blitter::blitH(int x, int y, int width) { SkASSERT(width > 0); SkASSERT(x + width <= fDevice.width()); - uint16_t* SK_RESTRICT device = fDevice.writable_addr16(x, y); + uint16_t* SK_RESTRICT device = fDevice.getAddr16(x, y); fColorProc16(device, fSrcColor32, width, x, y); } @@ -573,7 +580,7 @@ void SkRGB16_Blitter::blitH(int x, int y, int width) { void SkRGB16_Blitter::blitAntiH(int x, int y, const SkAlpha* SK_RESTRICT antialias, const int16_t* SK_RESTRICT runs) { - uint16_t* SK_RESTRICT device = fDevice.writable_addr16(x, y); + uint16_t* SK_RESTRICT device = fDevice.getAddr16(x, y); uint32_t srcExpanded = fExpandedRaw16; unsigned scale = fScale; @@ -617,7 +624,7 @@ static inline void blend_8_pixels(U8CPU bw, uint16_t dst[], unsigned dst_scale, #define SK_BLITBWMASK_NAME SkRGB16_BlendBW #define SK_BLITBWMASK_ARGS , unsigned dst_scale, U16CPU src_color #define SK_BLITBWMASK_BLIT8(mask, dst) blend_8_pixels(mask, dst, dst_scale, src_color) -#define SK_BLITBWMASK_GETADDR writable_addr16 +#define SK_BLITBWMASK_GETADDR getAddr16 #define SK_BLITBWMASK_DEVTYPE uint16_t #include "SkBlitBWMaskTemplate.h" @@ -628,7 +635,7 @@ void SkRGB16_Blitter::blitMask(const SkMask& mask, return; } - uint16_t* SK_RESTRICT device = fDevice.writable_addr16(clip.fLeft, clip.fTop); + uint16_t* SK_RESTRICT device = fDevice.getAddr16(clip.fLeft, clip.fTop); const uint8_t* SK_RESTRICT alpha = mask.getAddr8(clip.fLeft, clip.fTop); int width = clip.width(); int height = clip.height(); @@ -652,7 +659,7 @@ void SkRGB16_Blitter::blitMask(const SkMask& mask, } void SkRGB16_Blitter::blitV(int x, int y, int height, SkAlpha alpha) { - uint16_t* SK_RESTRICT device = fDevice.writable_addr16(x, y); + uint16_t* SK_RESTRICT device = fDevice.getAddr16(x, y); size_t deviceRB = fDevice.rowBytes(); // TODO: respect fDoDither @@ -668,7 +675,7 @@ void SkRGB16_Blitter::blitV(int x, int y, int height, SkAlpha alpha) { void SkRGB16_Blitter::blitRect(int x, int y, int width, int height) { SkASSERT(x + width <= fDevice.width() && y + height <= fDevice.height()); - uint16_t* SK_RESTRICT device = fDevice.writable_addr16(x, y); + uint16_t* SK_RESTRICT device = fDevice.getAddr16(x, y); size_t deviceRB = fDevice.rowBytes(); while (--height >= 0) { @@ -679,18 +686,17 @@ void SkRGB16_Blitter::blitRect(int x, int y, int width, int height) { /////////////////////////////////////////////////////////////////////////////// -SkRGB16_Shader16_Blitter::SkRGB16_Shader16_Blitter(const SkPixmap& device, +SkRGB16_Shader16_Blitter::SkRGB16_Shader16_Blitter(const SkBitmap& device, const SkPaint& paint, SkShader::Context* shaderContext) - : SkRGB16_Shader_Blitter(device, paint, shaderContext) -{ + : SkRGB16_Shader_Blitter(device, paint, shaderContext) { SkASSERT(SkShader::CanCallShadeSpan16(fShaderFlags)); } void SkRGB16_Shader16_Blitter::blitH(int x, int y, int width) { SkASSERT(x + width <= fDevice.width()); - uint16_t* SK_RESTRICT device = fDevice.writable_addr16(x, y); + uint16_t* SK_RESTRICT device = fDevice.getAddr16(x, y); SkShader::Context* shaderContext = fShaderContext; int alpha = shaderContext->getSpan16Alpha(); @@ -705,7 +711,7 @@ void SkRGB16_Shader16_Blitter::blitH(int x, int y, int width) { void SkRGB16_Shader16_Blitter::blitRect(int x, int y, int width, int height) { SkShader::Context* shaderContext = fShaderContext; - uint16_t* dst = fDevice.writable_addr16(x, y); + uint16_t* dst = fDevice.getAddr16(x, y); size_t dstRB = fDevice.rowBytes(); int alpha = shaderContext->getSpan16Alpha(); @@ -753,7 +759,7 @@ void SkRGB16_Shader16_Blitter::blitAntiH(int x, int y, const int16_t* SK_RESTRICT runs) { SkShader::Context* shaderContext = fShaderContext; SkPMColor* SK_RESTRICT span = fBuffer; - uint16_t* SK_RESTRICT device = fDevice.writable_addr16(x, y); + uint16_t* SK_RESTRICT device = fDevice.getAddr16(x, y); int alpha = shaderContext->getSpan16Alpha(); uint16_t* span16 = (uint16_t*)span; @@ -804,11 +810,10 @@ void SkRGB16_Shader16_Blitter::blitAntiH(int x, int y, /////////////////////////////////////////////////////////////////////////////// -SkRGB16_Shader_Blitter::SkRGB16_Shader_Blitter(const SkPixmap& device, +SkRGB16_Shader_Blitter::SkRGB16_Shader_Blitter(const SkBitmap& device, const SkPaint& paint, SkShader::Context* shaderContext) - : INHERITED(device, paint, shaderContext) -{ +: INHERITED(device, paint, shaderContext) { SkASSERT(paint.getXfermode() == NULL); fBuffer = (SkPMColor*)sk_malloc_throw(device.width() * sizeof(SkPMColor)); @@ -840,14 +845,14 @@ void SkRGB16_Shader_Blitter::blitH(int x, int y, int width) { fShaderContext->shadeSpan(x, y, fBuffer, width); // shaders take care of global alpha, so we pass 0xFF (should be ignored) - fOpaqueProc(fDevice.writable_addr16(x, y), fBuffer, width, 0xFF, x, y); + fOpaqueProc(fDevice.getAddr16(x, y), fBuffer, width, 0xFF, x, y); } void SkRGB16_Shader_Blitter::blitRect(int x, int y, int width, int height) { SkShader::Context* shaderContext = fShaderContext; SkBlitRow::Proc16 proc = fOpaqueProc; SkPMColor* buffer = fBuffer; - uint16_t* dst = fDevice.writable_addr16(x, y); + uint16_t* dst = fDevice.getAddr16(x, y); size_t dstRB = fDevice.rowBytes(); if (fShaderFlags & SkShader::kConstInY32_Flag) { @@ -886,7 +891,7 @@ void SkRGB16_Shader_Blitter::blitAntiH(int x, int y, const int16_t* SK_RESTRICT runs) { SkShader::Context* shaderContext = fShaderContext; SkPMColor* SK_RESTRICT span = fBuffer; - uint16_t* SK_RESTRICT device = fDevice.writable_addr16(x, y); + uint16_t* SK_RESTRICT device = fDevice.getAddr16(x, y); for (;;) { int count = *runs; @@ -932,10 +937,9 @@ void SkRGB16_Shader_Blitter::blitAntiH(int x, int y, /////////////////////////////////////////////////////////////////////// SkRGB16_Shader_Xfermode_Blitter::SkRGB16_Shader_Xfermode_Blitter( - const SkPixmap& device, const SkPaint& paint, + const SkBitmap& device, const SkPaint& paint, SkShader::Context* shaderContext) - : INHERITED(device, paint, shaderContext) -{ +: INHERITED(device, paint, shaderContext) { fXfermode = paint.getXfermode(); SkASSERT(fXfermode); fXfermode->ref(); @@ -953,7 +957,7 @@ SkRGB16_Shader_Xfermode_Blitter::~SkRGB16_Shader_Xfermode_Blitter() { void SkRGB16_Shader_Xfermode_Blitter::blitH(int x, int y, int width) { SkASSERT(x + width <= fDevice.width()); - uint16_t* device = fDevice.writable_addr16(x, y); + uint16_t* device = fDevice.getAddr16(x, y); SkPMColor* span = fBuffer; fShaderContext->shadeSpan(x, y, span, width); @@ -967,7 +971,7 @@ void SkRGB16_Shader_Xfermode_Blitter::blitAntiH(int x, int y, SkXfermode* mode = fXfermode; SkPMColor* SK_RESTRICT span = fBuffer; uint8_t* SK_RESTRICT aaExpand = fAAExpand; - uint16_t* SK_RESTRICT device = fDevice.writable_addr16(x, y); + uint16_t* SK_RESTRICT device = fDevice.getAddr16(x, y); for (;;) { int count = *runs; @@ -1017,7 +1021,7 @@ void SkRGB16_Shader_Xfermode_Blitter::blitAntiH(int x, int y, /////////////////////////////////////////////////////////////////////////////// -SkBlitter* SkBlitter_ChooseD565(const SkPixmap& device, const SkPaint& paint, +SkBlitter* SkBlitter_ChooseD565(const SkBitmap& device, const SkPaint& paint, SkShader::Context* shaderContext, SkTBlitterAllocator* allocator) { SkASSERT(allocator != NULL); diff --git a/src/core/SkCanvas.cpp b/src/core/SkCanvas.cpp index 056a4e96d2..26b76df9be 100644 --- a/src/core/SkCanvas.cpp +++ b/src/core/SkCanvas.cpp @@ -271,9 +271,7 @@ public: fClip = &((SkRasterClip*)&rec->fClip)->forceGetBW(); fRC = &rec->fClip; fDevice = rec->fDevice; - if (!fDevice->accessPixels(&fDst)) { - fDst.reset(fDevice->imageInfo(), NULL, 0); - } + fBitmap = &fDevice->accessBitmap(true); fPaint = rec->fPaint; SkDEBUGCODE(this->validate();) diff --git a/src/core/SkCoreBlitters.h b/src/core/SkCoreBlitters.h index 31f33979db..18821dc0d1 100644 --- a/src/core/SkCoreBlitters.h +++ b/src/core/SkCoreBlitters.h @@ -16,10 +16,10 @@ class SkRasterBlitter : public SkBlitter { public: - SkRasterBlitter(const SkPixmap& device) : fDevice(device) {} + SkRasterBlitter(const SkBitmap& device) : fDevice(device) {} protected: - const SkPixmap fDevice; + const SkBitmap& fDevice; private: typedef SkBlitter INHERITED; @@ -32,7 +32,7 @@ public: * The blitter only ensures that the storage always holds a live object, but it may * exchange that object. */ - SkShaderBlitter(const SkPixmap& device, const SkPaint& paint, + SkShaderBlitter(const SkBitmap& device, const SkPaint& paint, SkShader::Context* shaderContext); virtual ~SkShaderBlitter(); @@ -61,24 +61,24 @@ private: class SkA8_Coverage_Blitter : public SkRasterBlitter { public: - SkA8_Coverage_Blitter(const SkPixmap& device, const SkPaint& paint); + SkA8_Coverage_Blitter(const SkBitmap& device, const SkPaint& paint); void blitH(int x, int y, int width) override; void blitAntiH(int x, int y, const SkAlpha antialias[], const int16_t runs[]) override; void blitV(int x, int y, int height, SkAlpha alpha) override; void blitRect(int x, int y, int width, int height) override; void blitMask(const SkMask&, const SkIRect&) override; - const SkPixmap* justAnOpaqueColor(uint32_t*) override; + const SkBitmap* justAnOpaqueColor(uint32_t*) override; }; class SkA8_Blitter : public SkRasterBlitter { public: - SkA8_Blitter(const SkPixmap& device, const SkPaint& paint); + SkA8_Blitter(const SkBitmap& device, const SkPaint& paint); virtual void blitH(int x, int y, int width); virtual void blitAntiH(int x, int y, const SkAlpha antialias[], const int16_t runs[]); virtual void blitV(int x, int y, int height, SkAlpha alpha); virtual void blitRect(int x, int y, int width, int height); virtual void blitMask(const SkMask&, const SkIRect&); - virtual const SkPixmap* justAnOpaqueColor(uint32_t*); + virtual const SkBitmap* justAnOpaqueColor(uint32_t*); private: unsigned fSrcA; @@ -91,7 +91,7 @@ private: class SkA8_Shader_Blitter : public SkShaderBlitter { public: - SkA8_Shader_Blitter(const SkPixmap& device, const SkPaint& paint, + SkA8_Shader_Blitter(const SkBitmap& device, const SkPaint& paint, SkShader::Context* shaderContext); virtual ~SkA8_Shader_Blitter(); virtual void blitH(int x, int y, int width); @@ -113,13 +113,13 @@ private: class SkARGB32_Blitter : public SkRasterBlitter { public: - SkARGB32_Blitter(const SkPixmap& device, const SkPaint& paint); + SkARGB32_Blitter(const SkBitmap& device, const SkPaint& paint); virtual void blitH(int x, int y, int width); virtual void blitAntiH(int x, int y, const SkAlpha antialias[], const int16_t runs[]); virtual void blitV(int x, int y, int height, SkAlpha alpha); virtual void blitRect(int x, int y, int width, int height); virtual void blitMask(const SkMask&, const SkIRect&); - virtual const SkPixmap* justAnOpaqueColor(uint32_t*); + virtual const SkBitmap* justAnOpaqueColor(uint32_t*); void blitAntiH2(int x, int y, U8CPU a0, U8CPU a1) override; void blitAntiV2(int x, int y, U8CPU a0, U8CPU a1) override; @@ -138,7 +138,7 @@ private: class SkARGB32_Opaque_Blitter : public SkARGB32_Blitter { public: - SkARGB32_Opaque_Blitter(const SkPixmap& device, const SkPaint& paint) + SkARGB32_Opaque_Blitter(const SkBitmap& device, const SkPaint& paint) : INHERITED(device, paint) { SkASSERT(paint.getAlpha() == 0xFF); } virtual void blitMask(const SkMask&, const SkIRect&); void blitAntiH2(int x, int y, U8CPU a0, U8CPU a1) override; @@ -150,7 +150,7 @@ private: class SkARGB32_Black_Blitter : public SkARGB32_Opaque_Blitter { public: - SkARGB32_Black_Blitter(const SkPixmap& device, const SkPaint& paint) + SkARGB32_Black_Blitter(const SkBitmap& device, const SkPaint& paint) : INHERITED(device, paint) {} virtual void blitAntiH(int x, int y, const SkAlpha antialias[], const int16_t runs[]); void blitAntiH2(int x, int y, U8CPU a0, U8CPU a1) override; @@ -162,7 +162,7 @@ private: class SkARGB32_Shader_Blitter : public SkShaderBlitter { public: - SkARGB32_Shader_Blitter(const SkPixmap& device, const SkPaint& paint, + SkARGB32_Shader_Blitter(const SkBitmap& device, const SkPaint& paint, SkShader::Context* shaderContext); virtual ~SkARGB32_Shader_Blitter(); void blitH(int x, int y, int width) override; @@ -200,7 +200,7 @@ private: SkBlitter::Choose(...) */ -SkBlitter* SkBlitter_ChooseD565(const SkPixmap& device, const SkPaint& paint, +SkBlitter* SkBlitter_ChooseD565(const SkBitmap& device, const SkPaint& paint, SkShader::Context* shaderContext, SkTBlitterAllocator* allocator); diff --git a/src/core/SkDeviceLooper.cpp b/src/core/SkDeviceLooper.cpp index 840a050436..a8350cc027 100644 --- a/src/core/SkDeviceLooper.cpp +++ b/src/core/SkDeviceLooper.cpp @@ -7,16 +7,17 @@ #include "SkDeviceLooper.h" -SkDeviceLooper::SkDeviceLooper(const SkPixmap& base, const SkRasterClip& rc, const SkIRect& bounds, - bool aa) - : fBaseDst(base) +SkDeviceLooper::SkDeviceLooper(const SkBitmap& base, + const SkRasterClip& rc, + const SkIRect& bounds, bool aa) + : fBaseBitmap(base) , fBaseRC(rc) , fSubsetRC(rc.isForceConservativeRects()) , fDelta(aa ? kAA_Delta : kBW_Delta) { // sentinels that next() has not yet been called, and so our mapper functions // should not be called either. - fCurrDst = NULL; + fCurrBitmap = NULL; fCurrRC = NULL; if (!rc.isEmpty()) { @@ -37,11 +38,12 @@ SkDeviceLooper::SkDeviceLooper(const SkPixmap& base, const SkRasterClip& rc, con } } -SkDeviceLooper::~SkDeviceLooper() {} +SkDeviceLooper::~SkDeviceLooper() { +} void SkDeviceLooper::mapRect(SkRect* dst, const SkRect& src) const { SkASSERT(kDone_State != fState); - SkASSERT(fCurrDst); + SkASSERT(fCurrBitmap); SkASSERT(fCurrRC); *dst = src; @@ -51,11 +53,12 @@ void SkDeviceLooper::mapRect(SkRect* dst, const SkRect& src) const { void SkDeviceLooper::mapMatrix(SkMatrix* dst, const SkMatrix& src) const { SkASSERT(kDone_State != fState); - SkASSERT(fCurrDst); + SkASSERT(fCurrBitmap); SkASSERT(fCurrRC); *dst = src; - dst->postTranslate(SkIntToScalar(-fCurrOffset.fX), SkIntToScalar(-fCurrOffset.fY)); + dst->postTranslate(SkIntToScalar(-fCurrOffset.fX), + SkIntToScalar(-fCurrOffset.fY)); } bool SkDeviceLooper::computeCurrBitmapAndClip() { @@ -63,14 +66,16 @@ bool SkDeviceLooper::computeCurrBitmapAndClip() { SkIRect r = SkIRect::MakeXYWH(fCurrOffset.x(), fCurrOffset.y(), fDelta, fDelta); - if (!fBaseDst.extractSubset(&fSubsetDst, r)) { + if (!fBaseBitmap.extractSubset(&fSubsetBitmap, r)) { fSubsetRC.setEmpty(); } else { + fSubsetBitmap.lockPixels(); fBaseRC.translate(-r.left(), -r.top(), &fSubsetRC); - (void)fSubsetRC.op(SkIRect::MakeWH(fDelta, fDelta), SkRegion::kIntersect_Op); + (void)fSubsetRC.op(SkIRect::MakeWH(fDelta, fDelta), + SkRegion::kIntersect_Op); } - fCurrDst = &fSubsetDst; + fCurrBitmap = &fSubsetBitmap; fCurrRC = &fSubsetRC; return !fCurrRC->isEmpty(); } @@ -102,8 +107,8 @@ bool SkDeviceLooper::next() { case kSimple_State: // first time for simple - if (NULL == fCurrDst) { - fCurrDst = &fBaseDst; + if (NULL == fCurrBitmap) { + fCurrBitmap = &fBaseBitmap; fCurrRC = &fBaseRC; fCurrOffset.set(0, 0); return true; diff --git a/src/core/SkDeviceLooper.h b/src/core/SkDeviceLooper.h index dd346d7445..a218345ae8 100644 --- a/src/core/SkDeviceLooper.h +++ b/src/core/SkDeviceLooper.h @@ -30,13 +30,14 @@ */ class SkDeviceLooper { public: - SkDeviceLooper(const SkPixmap& base, const SkRasterClip&, const SkIRect& bounds, bool aa); + SkDeviceLooper(const SkBitmap& base, const SkRasterClip&, + const SkIRect& bounds, bool aa); ~SkDeviceLooper(); - const SkPixmap& getPixmap() const { + const SkBitmap& getBitmap() const { SkASSERT(kDone_State != fState); - SkASSERT(fCurrDst); - return *fCurrDst; + SkASSERT(fCurrBitmap); + return *fCurrBitmap; } const SkRasterClip& getRC() const { @@ -60,7 +61,7 @@ public: bool next(); private: - const SkPixmap& fBaseDst; + const SkBitmap& fBaseBitmap; const SkRasterClip& fBaseRC; enum State { @@ -70,10 +71,10 @@ private: }; // storage for our tiled versions. Perhaps could use SkTLazy - SkPixmap fSubsetDst; + SkBitmap fSubsetBitmap; SkRasterClip fSubsetRC; - const SkPixmap* fCurrDst; + const SkBitmap* fCurrBitmap; const SkRasterClip* fCurrRC; SkIRect fClippedBounds; SkIPoint fCurrOffset; diff --git a/src/core/SkDraw.cpp b/src/core/SkDraw.cpp index 0069087a92..ac69680811 100644 --- a/src/core/SkDraw.cpp +++ b/src/core/SkDraw.cpp @@ -44,18 +44,20 @@ public: SkAutoBlitterChoose() { fBlitter = NULL; } - SkAutoBlitterChoose(const SkPixmap& dst, const SkMatrix& matrix, + SkAutoBlitterChoose(const SkBitmap& device, const SkMatrix& matrix, const SkPaint& paint, bool drawCoverage = false) { - fBlitter = SkBlitter::Choose(dst, matrix, paint, &fAllocator, drawCoverage); + fBlitter = SkBlitter::Choose(device, matrix, paint, &fAllocator, + drawCoverage); } - + SkBlitter* operator->() { return fBlitter; } SkBlitter* get() const { return fBlitter; } - void choose(const SkPixmap& dst, const SkMatrix& matrix, + void choose(const SkBitmap& device, const SkMatrix& matrix, const SkPaint& paint, bool drawCoverage = false) { SkASSERT(!fBlitter); - fBlitter = SkBlitter::Choose(dst, matrix, paint, &fAllocator, drawCoverage); + fBlitter = SkBlitter::Choose(device, matrix, paint, &fAllocator, + drawCoverage); } private: @@ -150,7 +152,8 @@ static void DA8_Src_BitmapXferProc(void* pixels, size_t bytes, uint32_t data) { memset(pixels, data, bytes); } -static BitmapXferProc ChooseBitmapXferProc(const SkPixmap& dst, const SkPaint& paint, +static BitmapXferProc ChooseBitmapXferProc(const SkBitmap& bitmap, + const SkPaint& paint, uint32_t* data) { // todo: we can apply colorfilter up front if no shader, so we wouldn't // need to abort this fastpath @@ -187,7 +190,7 @@ static BitmapXferProc ChooseBitmapXferProc(const SkPixmap& dst, const SkPaint& p should I worry about dithering for the lower depths? */ SkPMColor pmc = SkPreMultiplyColor(color); - switch (dst.colorType()) { + switch (bitmap.colorType()) { case kN32_SkColorType: if (data) { *data = pmc; @@ -217,10 +220,10 @@ static BitmapXferProc ChooseBitmapXferProc(const SkPixmap& dst, const SkPaint& p return NULL; } -static void CallBitmapXferProc(const SkPixmap& dst, const SkIRect& rect, BitmapXferProc proc, - uint32_t procData) { +static void CallBitmapXferProc(const SkBitmap& bitmap, const SkIRect& rect, + BitmapXferProc proc, uint32_t procData) { int shiftPerPixel; - switch (dst.colorType()) { + switch (bitmap.colorType()) { case kN32_SkColorType: shiftPerPixel = 2; break; @@ -235,9 +238,9 @@ static void CallBitmapXferProc(const SkPixmap& dst, const SkIRect& rect, BitmapX return; } - uint8_t* pixels = (uint8_t*)dst.writable_addr(); + uint8_t* pixels = (uint8_t*)bitmap.getPixels(); SkASSERT(pixels); - const size_t rowBytes = dst.rowBytes(); + const size_t rowBytes = bitmap.rowBytes(); const int widthBytes = rect.width() << shiftPerPixel; // skip down to the first scanline and X position @@ -256,7 +259,7 @@ void SkDraw::drawPaint(const SkPaint& paint) const { } SkIRect devRect; - devRect.set(0, 0, fDst.width(), fDst.height()); + devRect.set(0, 0, fBitmap->width(), fBitmap->height()); if (fRC->isBW()) { /* If we don't have a shader (i.e. we're just a solid color) we may @@ -266,7 +269,7 @@ void SkDraw::drawPaint(const SkPaint& paint) const { in the clip, we don't have to worry about antialiasing. */ uint32_t procData = 0; // to avoid the warning - BitmapXferProc proc = ChooseBitmapXferProc(fDst, paint, &procData); + BitmapXferProc proc = ChooseBitmapXferProc(*fBitmap, paint, &procData); if (proc) { if (D_Dst_BitmapXferProc == proc) { // nothing to do return; @@ -274,7 +277,7 @@ void SkDraw::drawPaint(const SkPaint& paint) const { SkRegion::Iterator iter(fRC->bwRgn()); while (!iter.done()) { - CallBitmapXferProc(fDst, iter.rect(), proc, procData); + CallBitmapXferProc(*fBitmap, iter.rect(), proc, procData); iter.next(); } return; @@ -282,7 +285,7 @@ void SkDraw::drawPaint(const SkPaint& paint) const { } // normal case: use a blitter - SkAutoBlitterChoose blitter(fDst, *fMatrix, paint); + SkAutoBlitterChoose blitter(*fBitmap, *fMatrix, paint); SkScan::FillIRect(devRect, *fRC, blitter.get()); } @@ -328,11 +331,11 @@ static void bw_pt_rect_16_hair_proc(const PtProcRec& rec, SkASSERT(rec.fRC->isRect()); const SkIRect& r = rec.fRC->getBounds(); uint32_t value; - const SkPixmap* dst = blitter->justAnOpaqueColor(&value); - SkASSERT(dst); + const SkBitmap* bitmap = blitter->justAnOpaqueColor(&value); + SkASSERT(bitmap); - uint16_t* addr = dst->writable_addr16(0, 0); - size_t rb = dst->rowBytes(); + uint16_t* addr = bitmap->getAddr16(0, 0); + size_t rb = bitmap->rowBytes(); for (int i = 0; i < count; i++) { int x = SkScalarFloorToInt(devPts[i].fX); @@ -349,11 +352,11 @@ static void bw_pt_rect_32_hair_proc(const PtProcRec& rec, SkASSERT(rec.fRC->isRect()); const SkIRect& r = rec.fRC->getBounds(); uint32_t value; - const SkPixmap* dst = blitter->justAnOpaqueColor(&value); - SkASSERT(dst); + const SkBitmap* bitmap = blitter->justAnOpaqueColor(&value); + SkASSERT(bitmap); - SkPMColor* addr = dst->writable_addr32(0, 0); - size_t rb = dst->rowBytes(); + SkPMColor* addr = bitmap->getAddr32(0, 0); + size_t rb = bitmap->rowBytes(); for (int i = 0; i < count; i++) { int x = SkScalarFloorToInt(devPts[i].fX); @@ -509,7 +512,7 @@ PtProcRec::Proc PtProcRec::chooseProc(SkBlitter** blitterPtr) { if (fRadius <= SK_FixedHalf) { // small radii and hairline if (SkCanvas::kPoints_PointMode == fMode && fClip->isRect()) { uint32_t value; - const SkPixmap* bm = blitter->justAnOpaqueColor(&value); + const SkBitmap* bm = blitter->justAnOpaqueColor(&value); if (bm && kRGB_565_SkColorType == bm->colorType()) { proc = bw_pt_rect_16_hair_proc; } else if (bm && kN32_SkColorType == bm->colorType()) { @@ -556,7 +559,7 @@ void SkDraw::drawPoints(SkCanvas::PointMode mode, size_t count, PtProcRec rec; if (!forceUseDevice && rec.init(mode, paint, fMatrix, fRC)) { - SkAutoBlitterChoose blitter(fDst, *fMatrix, paint); + SkAutoBlitterChoose blitter(*fBitmap, *fMatrix, paint); SkPoint devPts[MAX_DEV_PTS]; const SkMatrix* matrix = fMatrix; @@ -850,14 +853,14 @@ void SkDraw::drawRect(const SkRect& prePaintRect, const SkPaint& paint, return; } - SkDeviceLooper looper(fDst, *fRC, ir, paint.isAntiAlias()); + SkDeviceLooper looper(*fBitmap, *fRC, ir, paint.isAntiAlias()); while (looper.next()) { SkRect localDevRect; looper.mapRect(&localDevRect, devRect); SkMatrix localMatrix; looper.mapMatrix(&localMatrix, *matrix); - SkAutoBlitterChoose blitterStorage(looper.getPixmap(), localMatrix, paint); + SkAutoBlitterChoose blitterStorage(looper.getBitmap(), localMatrix, paint); const SkRasterClip& clip = looper.getRC(); SkBlitter* blitter = blitterStorage.get(); @@ -908,7 +911,7 @@ void SkDraw::drawDevMask(const SkMask& srcM, const SkPaint& paint) const { } SkAutoMaskFreeImage ami(dstM.fImage); - SkAutoBlitterChoose blitterChooser(fDst, *fMatrix, paint); + SkAutoBlitterChoose blitterChooser(*fBitmap, *fMatrix, paint); SkBlitter* blitter = blitterChooser.get(); SkAAClipBlitterWrapper wrapper; @@ -986,7 +989,7 @@ void SkDraw::drawRRect(const SkRRect& rrect, const SkPaint& paint) const { // Transform the rrect into device space. SkRRect devRRect; if (rrect.transform(*fMatrix, &devRRect)) { - SkAutoBlitterChoose blitter(fDst, *fMatrix, paint); + SkAutoBlitterChoose blitter(*fBitmap, *fMatrix, paint); if (paint.getMaskFilter()->filterRRect(devRRect, *fMatrix, *fRC, blitter.get(), SkPaint::kFill_Style)) { return; // filterRRect() called the blitter, so we're done @@ -1105,7 +1108,7 @@ void SkDraw::drawPath(const SkPath& origSrcPath, const SkPaint& origPaint, SkBlitter* blitter = NULL; SkAutoBlitterChoose blitterStorage; if (NULL == customBlitter) { - blitterStorage.choose(fDst, *fMatrix, *paint, drawCoverage); + blitterStorage.choose(*fBitmap, *fMatrix, *paint, drawCoverage); blitter = blitterStorage.get(); } else { blitter = customBlitter; @@ -1179,7 +1182,7 @@ void SkDraw::drawBitmapAsMask(const SkBitmap& bitmap, // clipped to the actual device { SkIRect devBounds; - devBounds.set(0, 0, fDst.width(), fDst.height()); + devBounds.set(0, 0, fBitmap->width(), fBitmap->height()); // need intersect(l, t, r, b) on irect if (!mask.fBounds.intersect(devBounds)) { return; @@ -1277,9 +1280,13 @@ void SkDraw::drawBitmap(const SkBitmap& bitmap, const SkMatrix& prematrix, int ix = SkScalarRoundToInt(matrix.getTranslateX()); int iy = SkScalarRoundToInt(matrix.getTranslateY()); if (clipHandlesSprite(*fRC, ix, iy, pmap)) { + SkPixmap dstPM; + if (!fBitmap->peekPixels(&dstPM)) { + return; + } SkTBlitterAllocator allocator; // blitter will be owned by the allocator. - SkBlitter* blitter = SkBlitter::ChooseSprite(fDst, paint, pmap, ix, iy, &allocator); + SkBlitter* blitter = SkBlitter::ChooseSprite(dstPM, paint, pmap, ix, iy, &allocator); if (blitter) { SkScan::FillIRect(SkIRect::MakeXYWH(ix, iy, pmap.width(), pmap.height()), *fRC, blitter); @@ -1334,9 +1341,13 @@ void SkDraw::drawSprite(const SkBitmap& bitmap, int x, int y, const SkPaint& ori const SkPixmap& pmap = unlocker.pixmap(); if (NULL == paint.getColorFilter() && clipHandlesSprite(*fRC, x, y, pmap)) { + SkPixmap dstPM; + if (!fBitmap->peekPixels(&dstPM)) { + return; + } SkTBlitterAllocator allocator; // blitter will be owned by the allocator. - SkBlitter* blitter = SkBlitter::ChooseSprite(fDst, paint, pmap, x, y, &allocator); + SkBlitter* blitter = SkBlitter::ChooseSprite(dstPM, paint, pmap, x, y, &allocator); if (blitter) { SkScan::FillIRect(bounds, *fRC, blitter); return; @@ -1635,7 +1646,7 @@ void SkDraw::drawText(const char text[], size_t byteLength, SkAutoBlitterChoose blitterChooser; SkBlitter* blitter = NULL; if (needsRasterTextBlit(*this)) { - blitterChooser.choose(fDst, *fMatrix, paint); + blitterChooser.choose(*fBitmap, *fMatrix, paint); blitter = blitterChooser.get(); if (fRC->isAA()) { aaBlitter.init(blitter, &fRC->aaRgn()); @@ -1754,7 +1765,7 @@ void SkDraw::drawPosText(const char text[], size_t byteLength, SkAutoBlitterChoose blitterChooser; SkBlitter* blitter = NULL; if (needsRasterTextBlit(*this)) { - blitterChooser.choose(fDst, *fMatrix, paint); + blitterChooser.choose(*fBitmap, *fMatrix, paint); blitter = blitterChooser.get(); if (fRC->isAA()) { wrapper.init(*fRC, blitter); @@ -2084,7 +2095,7 @@ void SkDraw::drawVertices(SkCanvas::VertexMode vmode, int count, } } - SkAutoBlitterChoose blitter(fDst, *fMatrix, p); + SkAutoBlitterChoose blitter(*fBitmap, *fMatrix, p); // Abort early if we failed to create a shader context. if (blitter->isNullBlitter()) { return; @@ -2155,6 +2166,7 @@ void SkDraw::drawVertices(SkCanvas::VertexMode vmode, int count, #ifdef SK_DEBUG void SkDraw::validate() const { + SkASSERT(fBitmap != NULL); SkASSERT(fMatrix != NULL); SkASSERT(fClip != NULL); SkASSERT(fRC != NULL); @@ -2162,7 +2174,7 @@ void SkDraw::validate() const { const SkIRect& cr = fRC->getBounds(); SkIRect br; - br.set(0, 0, fDst.width(), fDst.height()); + br.set(0, 0, fBitmap->width(), fBitmap->height()); SkASSERT(cr.isEmpty() || br.contains(cr)); } @@ -2218,20 +2230,22 @@ static bool compute_bounds(const SkPath& devPath, const SkIRect* clipBounds, return true; } -static void draw_into_mask(const SkMask& mask, const SkPath& devPath, SkPaint::Style style) { - SkDraw draw; - if (!draw.fDst.reset(mask)) { - return; - } - +static void draw_into_mask(const SkMask& mask, const SkPath& devPath, + SkPaint::Style style) { + SkBitmap bm; + SkDraw draw; SkRasterClip clip; SkMatrix matrix; SkPaint paint; + bm.installPixels(SkImageInfo::MakeA8(mask.fBounds.width(), mask.fBounds.height()), + mask.fImage, mask.fRowBytes); + clip.setRect(SkIRect::MakeWH(mask.fBounds.width(), mask.fBounds.height())); matrix.setTranslate(-SkIntToScalar(mask.fBounds.fLeft), -SkIntToScalar(mask.fBounds.fTop)); + draw.fBitmap = &bm; draw.fRC = &clip; draw.fClip = &clip.bwRgn(); draw.fMatrix = &matrix; diff --git a/src/core/SkScalerContext.cpp b/src/core/SkScalerContext.cpp index 4ce42ddc07..7747cae0df 100644 --- a/src/core/SkScalerContext.cpp +++ b/src/core/SkScalerContext.cpp @@ -248,7 +248,7 @@ static void applyLUTToA8Mask(const SkMask& mask, const uint8_t* lut) { } template<bool APPLY_PREBLEND> -static void pack4xHToLCD16(const SkPixmap& src, const SkMask& dst, +static void pack4xHToLCD16(const SkBitmap& src, const SkMask& dst, const SkMaskGamma::PreBlend& maskPreBlend) { #define SAMPLES_PER_PIXEL 4 #define LCD_PER_PIXEL 3 @@ -291,7 +291,7 @@ static void pack4xHToLCD16(const SkPixmap& src, const SkMask& dst, }; for (int y = 0; y < height; ++y) { - const uint8_t* srcP = src.addr8(0, y); + const uint8_t* srcP = src.getAddr8(0, y); // TODO: this fir filter implementation is straight forward, but slow. // It should be possible to make it much faster. @@ -406,29 +406,29 @@ static void generateMask(const SkMask& mask, const SkPath& path, clip.setRect(SkIRect::MakeWH(dstW, dstH)); const SkImageInfo info = SkImageInfo::MakeA8(dstW, dstH); - SkAutoPixmapStorage dst; + SkBitmap bm; if (0 == dstRB) { - if (!dst.tryAlloc(info)) { + if (!bm.tryAllocPixels(info)) { // can't allocate offscreen, so empty the mask and return sk_bzero(mask.fImage, mask.computeImageSize()); return; } } else { - dst.reset(info, mask.fImage, dstRB); + bm.installPixels(info, mask.fImage, dstRB); } - sk_bzero(dst.writable_addr(), dst.getSafeSize()); + sk_bzero(bm.getPixels(), bm.getSafeSize()); SkDraw draw; - draw.fDst = dst; draw.fRC = &clip; draw.fClip = &clip.bwRgn(); draw.fMatrix = &matrix; + draw.fBitmap = &bm; draw.drawPath(path, paint); switch (mask.fFormat) { case SkMask::kBW_Format: - packA8ToA1(mask, dst.addr8(0, 0), dst.rowBytes()); + packA8ToA1(mask, bm.getAddr8(0, 0), bm.rowBytes()); break; case SkMask::kA8_Format: if (maskPreBlend.isApplicable()) { @@ -437,9 +437,9 @@ static void generateMask(const SkMask& mask, const SkPath& path, break; case SkMask::kLCD16_Format: if (maskPreBlend.isApplicable()) { - pack4xHToLCD16<true>(dst, mask, maskPreBlend); + pack4xHToLCD16<true>(bm, mask, maskPreBlend); } else { - pack4xHToLCD16<false>(dst, mask, maskPreBlend); + pack4xHToLCD16<false>(bm, mask, maskPreBlend); } break; default: diff --git a/src/core/SkScan_Path.cpp b/src/core/SkScan_Path.cpp index b7db3b410d..9b4b9fd897 100644 --- a/src/core/SkScan_Path.cpp +++ b/src/core/SkScan_Path.cpp @@ -344,7 +344,7 @@ public: void blitMask(const SkMask&, const SkIRect& clip) override { SkDEBUGFAIL("blitMask unexpected"); } - const SkPixmap* justAnOpaqueColor(uint32_t* value) override { + const SkBitmap* justAnOpaqueColor(uint32_t* value) override { SkDEBUGFAIL("justAnOpaqueColor unexpected"); return NULL; } diff --git a/src/effects/SkLayerRasterizer.cpp b/src/effects/SkLayerRasterizer.cpp index 8403d06147..d3e112c3a4 100644 --- a/src/effects/SkLayerRasterizer.cpp +++ b/src/effects/SkLayerRasterizer.cpp @@ -116,12 +116,9 @@ bool SkLayerRasterizer::onRasterize(const SkPath& path, const SkMatrix& matrix, } if (SkMask::kJustComputeBounds_CreateMode != mode) { - SkDraw draw; - if (!draw.fDst.reset(*mask)) { - return false; - } - + SkBitmap device; SkRasterClip rectClip; + SkDraw draw; SkMatrix translatedMatrix; // this translates us to our local pixels SkMatrix drawMatrix; // this translates the path by each layer's offset @@ -131,6 +128,9 @@ bool SkLayerRasterizer::onRasterize(const SkPath& path, const SkMatrix& matrix, translatedMatrix.postTranslate(-SkIntToScalar(mask->fBounds.fLeft), -SkIntToScalar(mask->fBounds.fTop)); + device.installMaskPixels(*mask); + + draw.fBitmap = &device; draw.fMatrix = &drawMatrix; draw.fRC = &rectClip; draw.fClip = &rectClip.bwRgn(); diff --git a/src/gpu/GrAADistanceFieldPathRenderer.cpp b/src/gpu/GrAADistanceFieldPathRenderer.cpp index 3c7648aae3..21fbcb37fb 100755 --- a/src/gpu/GrAADistanceFieldPathRenderer.cpp +++ b/src/gpu/GrAADistanceFieldPathRenderer.cpp @@ -354,12 +354,14 @@ private: SkIRect pathBounds = SkIRect::MakeWH(devPathBounds.width(), devPathBounds.height()); - SkAutoPixmapStorage dst; - if (!dst.tryAlloc(SkImageInfo::MakeA8(pathBounds.width(), - pathBounds.height()))) { + SkBitmap bmp; + const SkImageInfo bmImageInfo = SkImageInfo::MakeA8(pathBounds.fRight, + pathBounds.fBottom); + if (!bmp.tryAllocPixels(bmImageInfo)) { return false; } - sk_bzero(dst.writable_addr(), dst.getSafeSize()); + + sk_bzero(bmp.getPixels(), bmp.getSafeSize()); // rasterize path SkPaint paint; @@ -386,7 +388,7 @@ private: draw.fRC = &rasterClip; draw.fClip = &rasterClip.bwRgn(); draw.fMatrix = &drawMatrix; - draw.fDst = dst; + draw.fBitmap = &bmp; draw.drawPathCoverage(path, paint); @@ -398,9 +400,13 @@ private: SkAutoSMalloc<1024> dfStorage(width * height * sizeof(unsigned char)); // Generate signed distance field - SkGenerateDistanceFieldFromA8Image((unsigned char*)dfStorage.get(), - (const unsigned char*)dst.addr(), - dst.width(), dst.height(), dst.rowBytes()); + { + SkAutoLockPixels alp(bmp); + + SkGenerateDistanceFieldFromA8Image((unsigned char*)dfStorage.get(), + (const unsigned char*)bmp.getPixels(), + bmp.width(), bmp.height(), bmp.rowBytes()); + } // add to atlas SkIPoint16 atlasLocation; diff --git a/src/gpu/GrSWMaskHelper.cpp b/src/gpu/GrSWMaskHelper.cpp index 9b9865e92b..c13d2d839d 100644 --- a/src/gpu/GrSWMaskHelper.cpp +++ b/src/gpu/GrSWMaskHelper.cpp @@ -146,8 +146,7 @@ void GrSWMaskHelper::draw(const SkPath& path, const SkStrokeRec& stroke, SkRegio if (kBlitter_CompressionMode == fCompressionMode) { SkASSERT(fCompressedBuffer.get()); blitter = SkTextureCompressor::CreateBlitterForFormat( - fPixels.width(), fPixels.height(), fCompressedBuffer.get(), &allocator, - fCompressedFormat); + fBM.width(), fBM.height(), fCompressedBuffer.get(), &allocator, fCompressedFormat); } if (SkRegion::kReplace_Op == op && 0xFF == alpha) { @@ -203,26 +202,28 @@ bool GrSWMaskHelper::init(const SkIRect& resultBounds, } } - sk_bzero(&fDraw, sizeof(fDraw)); - // If we don't have a custom blitter, then we either need a bitmap to compress // from or a bitmap that we're going to use as a texture. In any case, we should // allocate the pixels for a bitmap const SkImageInfo bmImageInfo = SkImageInfo::MakeA8(cmpWidth, cmpHeight); if (kBlitter_CompressionMode != fCompressionMode) { - if (!fPixels.tryAlloc(bmImageInfo)) { + if (!fBM.tryAllocPixels(bmImageInfo)) { return false; } - fPixels.erase(0); + + sk_bzero(fBM.getPixels(), fBM.getSafeSize()); } else { // Otherwise, we just need to remember how big the buffer is... - fPixels.reset(bmImageInfo); + fBM.setInfo(bmImageInfo); } - fDraw.fDst = fPixels; + + sk_bzero(&fDraw, sizeof(fDraw)); + fRasterClip.setRect(bounds); - fDraw.fRC = &fRasterClip; - fDraw.fClip = &fRasterClip.bwRgn(); - fDraw.fMatrix = &fMatrix; + fDraw.fRC = &fRasterClip; + fDraw.fClip = &fRasterClip.bwRgn(); + fDraw.fMatrix = &fMatrix; + fDraw.fBitmap = &fBM; return true; } @@ -231,8 +232,8 @@ bool GrSWMaskHelper::init(const SkIRect& resultBounds, */ GrTexture* GrSWMaskHelper::createTexture() { GrSurfaceDesc desc; - desc.fWidth = fPixels.width(); - desc.fHeight = fPixels.height(); + desc.fWidth = fBM.width(); + desc.fHeight = fBM.height(); desc.fConfig = kAlpha_8_GrPixelConfig; if (kNone_CompressionMode != fCompressionMode) { @@ -272,8 +273,7 @@ void GrSWMaskHelper::compressTextureData(GrTexture *texture, const GrSurfaceDesc SkASSERT(GrPixelConfigIsCompressed(desc.fConfig)); SkASSERT(fmt_to_config(fCompressedFormat) == desc.fConfig); - SkAutoDataUnref cmpData(SkTextureCompressor::CompressBitmapToFormat(fPixels, - fCompressedFormat)); + SkAutoDataUnref cmpData(SkTextureCompressor::CompressBitmapToFormat(fBM, fCompressedFormat)); SkASSERT(cmpData); this->sendTextureData(texture, desc, cmpData->data(), 0); @@ -283,15 +283,17 @@ void GrSWMaskHelper::compressTextureData(GrTexture *texture, const GrSurfaceDesc * Move the result of the software mask generation back to the gpu */ void GrSWMaskHelper::toTexture(GrTexture *texture) { + SkAutoLockPixels alp(fBM); + GrSurfaceDesc desc; - desc.fWidth = fPixels.width(); - desc.fHeight = fPixels.height(); + desc.fWidth = fBM.width(); + desc.fHeight = fBM.height(); desc.fConfig = texture->config(); // First see if we should compress this texture before uploading. switch (fCompressionMode) { case kNone_CompressionMode: - this->sendTextureData(texture, desc, fPixels.addr(), fPixels.rowBytes()); + this->sendTextureData(texture, desc, fBM.getPixels(), fBM.rowBytes()); break; case kCompress_CompressionMode: @@ -309,8 +311,10 @@ void GrSWMaskHelper::toTexture(GrTexture *texture) { * Convert mask generation results to a signed distance field */ void GrSWMaskHelper::toSDF(unsigned char* sdf) { - SkGenerateDistanceFieldFromA8Image(sdf, (const unsigned char*)fPixels.addr(), - fPixels.width(), fPixels.height(), fPixels.rowBytes()); + SkAutoLockPixels alp(fBM); + + SkGenerateDistanceFieldFromA8Image(sdf, (const unsigned char*)fBM.getPixels(), + fBM.width(), fBM.height(), fBM.rowBytes()); } //////////////////////////////////////////////////////////////////////////////// diff --git a/src/gpu/GrSWMaskHelper.h b/src/gpu/GrSWMaskHelper.h index b90205b1a1..a69e4bec99 100644 --- a/src/gpu/GrSWMaskHelper.h +++ b/src/gpu/GrSWMaskHelper.h @@ -69,7 +69,7 @@ public: // Reset the internal bitmap void clear(uint8_t alpha) { - fPixels.erase(SkColorSetARGB(alpha, 0xFF, 0xFF, 0xFF)); + fBM.eraseColor(SkColorSetARGB(alpha, alpha, alpha, alpha)); } // Canonical usage utility that draws a single path and uploads it @@ -105,7 +105,7 @@ private: GrContext* fContext; SkMatrix fMatrix; - SkAutoPixmapStorage fPixels; + SkBitmap fBM; SkDraw fDraw; SkRasterClip fRasterClip; diff --git a/src/utils/SkTextureCompressor.cpp b/src/utils/SkTextureCompressor.cpp index 9d29d51d60..12621e118f 100644 --- a/src/utils/SkTextureCompressor.cpp +++ b/src/utils/SkTextureCompressor.cpp @@ -173,17 +173,19 @@ bool CompressBufferToFormat(uint8_t* dst, const uint8_t* src, SkColorType srcCol return false; } -SkData* CompressBitmapToFormat(const SkPixmap& pixmap, Format format) { - int compressedDataSize = GetCompressedDataSize(format, pixmap.width(), pixmap.height()); +SkData* CompressBitmapToFormat(const SkBitmap &bitmap, Format format) { + SkAutoLockPixels alp(bitmap); + + int compressedDataSize = GetCompressedDataSize(format, bitmap.width(), bitmap.height()); if (compressedDataSize < 0) { return NULL; } - const uint8_t* src = reinterpret_cast<const uint8_t*>(pixmap.addr()); + const uint8_t* src = reinterpret_cast<const uint8_t*>(bitmap.getPixels()); SkData* dst = SkData::NewUninitialized(compressedDataSize); - if (!CompressBufferToFormat((uint8_t*)dst->writable_data(), src, pixmap.colorType(), - pixmap.width(), pixmap.height(), pixmap.rowBytes(), format)) { + if (!CompressBufferToFormat((uint8_t*)dst->writable_data(), src, bitmap.colorType(), + bitmap.width(), bitmap.height(), bitmap.rowBytes(), format)) { dst->unref(); dst = NULL; } diff --git a/src/utils/SkTextureCompressor.h b/src/utils/SkTextureCompressor.h index e31a5ab48d..e35bc957ac 100644 --- a/src/utils/SkTextureCompressor.h +++ b/src/utils/SkTextureCompressor.h @@ -55,10 +55,10 @@ namespace SkTextureCompressor { int GetCompressedDataSize(Format fmt, int width, int height); // Returns an SkData holding a blob of compressed data that corresponds - // to the pixmap. If the pixmap colorType cannot be compressed using the + // to the bitmap. If the bitmap colorType cannot be compressed using the // associated format, then we return NULL. The caller is responsible for // calling unref() on the returned data. - SkData* CompressBitmapToFormat(const SkPixmap&, Format format); + SkData* CompressBitmapToFormat(const SkBitmap& bitmap, Format format); // Compresses the given src data into dst. The src data is assumed to be // large enough to hold width*height pixels. The dst data is expected to diff --git a/src/utils/SkTextureCompressor_Blitter.h b/src/utils/SkTextureCompressor_Blitter.h index e52237518f..73d8ee4ffb 100644 --- a/src/utils/SkTextureCompressor_Blitter.h +++ b/src/utils/SkTextureCompressor_Blitter.h @@ -368,7 +368,7 @@ public: // If the blitter just sets a single value for each pixel, return the // bitmap it draws into, and assign value. If not, return NULL and ignore // the value parameter. - const SkPixmap* justAnOpaqueColor(uint32_t* value) override { + const SkBitmap* justAnOpaqueColor(uint32_t* value) override { return NULL; } diff --git a/tests/DeviceLooperTest.cpp b/tests/DeviceLooperTest.cpp index 1a51b58980..5735043074 100644 --- a/tests/DeviceLooperTest.cpp +++ b/tests/DeviceLooperTest.cpp @@ -9,8 +9,9 @@ #include "SkRasterClip.h" #include "Test.h" -static void make_pm(SkAutoPixmapStorage* pixmap, int w, int h) { - pixmap->alloc(SkImageInfo::Make(w, h, kAlpha_8_SkColorType, kPremul_SkAlphaType)); +static void make_bm(SkBitmap* bm, int w, int h) { + bm->allocPixels(SkImageInfo::Make(w, h, kAlpha_8_SkColorType, + kPremul_SkAlphaType)); } static bool equal(const SkRasterClip& a, const SkRasterClip& b) { @@ -39,19 +40,19 @@ static const struct { static void test_simple(skiatest::Reporter* reporter) { for (size_t i = 0; i < SK_ARRAY_COUNT(gRec); ++i) { - SkAutoPixmapStorage pmap; - make_pm(&pmap, gRec[i].fDevSize.width(), gRec[i].fDevSize.height()); + SkBitmap bitmap; + make_bm(&bitmap, gRec[i].fDevSize.width(), gRec[i].fDevSize.height()); SkRasterClip rc(gRec[i].fRCBounds); for (int aa = 0; aa <= 1; ++aa) { - SkDeviceLooper looper(pmap, rc, gRec[i].fRect, SkToBool(aa)); + SkDeviceLooper looper(bitmap, rc, gRec[i].fRect, SkToBool(aa)); bool valid = looper.next(); REPORTER_ASSERT(reporter, valid); if (valid) { - REPORTER_ASSERT(reporter, looper.getPixmap().width() == pmap.width()); - REPORTER_ASSERT(reporter, looper.getPixmap().height() == pmap.height()); + REPORTER_ASSERT(reporter, looper.getBitmap().width() == bitmap.width()); + REPORTER_ASSERT(reporter, looper.getBitmap().height() == bitmap.height()); REPORTER_ASSERT(reporter, equal(looper.getRC(), rc)); REPORTER_ASSERT(reporter, !looper.next()); @@ -61,7 +62,7 @@ static void test_simple(skiatest::Reporter* reporter) { { SkIRect r = rc.getBounds(); r.offset(r.width(), 0); - SkDeviceLooper looper(pmap, rc, r, false); + SkDeviceLooper looper(bitmap, rc, r, false); REPORTER_ASSERT(reporter, !looper.next()); } } @@ -108,8 +109,8 @@ static void test_complex(skiatest::Reporter* reporter) { const int w = gRec[i].fSize.width(); const int h = gRec[i].fSize.height(); - SkAutoPixmapStorage pmap; - make_pm(&pmap, w, h); + SkBitmap bitmap; + make_bm(&bitmap, w, h); const SkIRect rect = SkIRect::MakeWH(w, h); @@ -124,7 +125,7 @@ static void test_complex(skiatest::Reporter* reporter) { SkRasterClip rc; rc.op(rgn, SkRegion::kReplace_Op); - SkDeviceLooper looper(pmap, rc, rect, gRec[i].fAA); + SkDeviceLooper looper(bitmap, rc, rect, gRec[i].fAA); while (looper.next()) { REPORTER_ASSERT(reporter, !looper.getRC().isEmpty()); } diff --git a/tests/TextureCompressionTest.cpp b/tests/TextureCompressionTest.cpp index ca8da28858..568d4d14b6 100644 --- a/tests/TextureCompressionTest.cpp +++ b/tests/TextureCompressionTest.cpp @@ -42,8 +42,10 @@ static bool compresses_a8(SkTextureCompressor::Format fmt) { * Make sure that we properly fail when we don't have multiple of four image dimensions. */ DEF_TEST(CompressAlphaFailDimensions, reporter) { + SkBitmap bitmap; static const int kWidth = 17; static const int kHeight = 17; + SkImageInfo info = SkImageInfo::MakeA8(kWidth, kHeight); // R11_EAC and LATC are both dimensions of 4, so we need to make sure that we // are violating those assumptions. And if we are, then we're also violating the @@ -53,16 +55,18 @@ DEF_TEST(CompressAlphaFailDimensions, reporter) { REPORTER_ASSERT(reporter, kWidth % 4 != 0); REPORTER_ASSERT(reporter, kHeight % 4 != 0); - SkAutoPixmapStorage pixmap; - pixmap.alloc(SkImageInfo::MakeA8(kWidth, kHeight)); - // leaving the pixels uninitialized, as they don't affect the test... + bool setInfoSuccess = bitmap.setInfo(info); + REPORTER_ASSERT(reporter, setInfoSuccess); + + bitmap.allocPixels(info); + bitmap.unlockPixels(); for (int i = 0; i < SkTextureCompressor::kFormatCnt; ++i) { const SkTextureCompressor::Format fmt = static_cast<SkTextureCompressor::Format>(i); if (!compresses_a8(fmt)) { continue; } - SkAutoDataUnref data(SkTextureCompressor::CompressBitmapToFormat(pixmap, fmt)); + SkAutoDataUnref data(SkTextureCompressor::CompressBitmapToFormat(bitmap, fmt)); REPORTER_ASSERT(reporter, NULL == data); } } @@ -72,8 +76,10 @@ DEF_TEST(CompressAlphaFailDimensions, reporter) { * compressed textures can (currently) only be created from A8 bitmaps. */ DEF_TEST(CompressAlphaFailColorType, reporter) { + SkBitmap bitmap; static const int kWidth = 12; static const int kHeight = 12; + SkImageInfo info = SkImageInfo::MakeN32Premul(kWidth, kHeight); // ASTC is at most 12x12, and any dimension divisible by 12 is also divisible // by 4, which is the dimensions of R11_EAC and LATC. In the future, we might @@ -82,16 +88,18 @@ DEF_TEST(CompressAlphaFailColorType, reporter) { REPORTER_ASSERT(reporter, kWidth % 12 == 0); REPORTER_ASSERT(reporter, kHeight % 12 == 0); - SkAutoPixmapStorage pixmap; - pixmap.alloc(SkImageInfo::MakeN32Premul(kWidth, kHeight)); - // leaving the pixels uninitialized, as they don't affect the test... + bool setInfoSuccess = bitmap.setInfo(info); + REPORTER_ASSERT(reporter, setInfoSuccess); + + bitmap.allocPixels(info); + bitmap.unlockPixels(); for (int i = 0; i < SkTextureCompressor::kFormatCnt; ++i) { const SkTextureCompressor::Format fmt = static_cast<SkTextureCompressor::Format>(i); if (!compresses_a8(fmt)) { continue; } - SkAutoDataUnref data(SkTextureCompressor::CompressBitmapToFormat(pixmap, fmt)); + SkAutoDataUnref data(SkTextureCompressor::CompressBitmapToFormat(bitmap, fmt)); REPORTER_ASSERT(reporter, NULL == data); } } @@ -101,8 +109,10 @@ DEF_TEST(CompressAlphaFailColorType, reporter) { * then decompress it, you get what you started with. */ DEF_TEST(CompressCheckerboard, reporter) { + SkBitmap bitmap; static const int kWidth = 48; // We need the number to be divisible by both static const int kHeight = 48; // 12 (ASTC) and 16 (ARM NEON R11 EAC). + SkImageInfo info = SkImageInfo::MakeA8(kWidth, kHeight); // ASTC is at most 12x12, and any dimension divisible by 12 is also divisible // by 4, which is the dimensions of R11_EAC and LATC. In the future, we might @@ -113,12 +123,17 @@ DEF_TEST(CompressCheckerboard, reporter) { REPORTER_ASSERT(reporter, kWidth % 48 == 0); REPORTER_ASSERT(reporter, kHeight % 48 == 0); - SkAutoPixmapStorage pixmap; - pixmap.alloc(SkImageInfo::MakeA8(kWidth, kHeight)); + bool setInfoSuccess = bitmap.setInfo(info); + REPORTER_ASSERT(reporter, setInfoSuccess); + + bitmap.allocPixels(info); + bitmap.unlockPixels(); - // Populate the pixels + // Populate bitmap { - uint8_t* pixels = reinterpret_cast<uint8_t*>(pixmap.writable_addr()); + SkAutoLockPixels alp(bitmap); + + uint8_t* pixels = reinterpret_cast<uint8_t*>(bitmap.getPixels()); REPORTER_ASSERT(reporter, pixels); if (NULL == pixels) { return; @@ -132,7 +147,7 @@ DEF_TEST(CompressCheckerboard, reporter) { pixels[x] = 0; } } - pixels += pixmap.rowBytes(); + pixels += bitmap.rowBytes(); } } @@ -152,7 +167,7 @@ DEF_TEST(CompressCheckerboard, reporter) { continue; } - SkAutoDataUnref data(SkTextureCompressor::CompressBitmapToFormat(pixmap, fmt)); + SkAutoDataUnref data(SkTextureCompressor::CompressBitmapToFormat(bitmap, fmt)); REPORTER_ASSERT(reporter, data); if (NULL == data) { continue; @@ -165,7 +180,8 @@ DEF_TEST(CompressCheckerboard, reporter) { kWidth, kHeight, fmt); REPORTER_ASSERT(reporter, decompResult); - const uint8_t* pixels = reinterpret_cast<const uint8_t*>(pixmap.addr()); + SkAutoLockPixels alp(bitmap); + uint8_t* pixels = reinterpret_cast<uint8_t*>(bitmap.getPixels()); REPORTER_ASSERT(reporter, pixels); if (NULL == pixels) { continue; @@ -173,7 +189,7 @@ DEF_TEST(CompressCheckerboard, reporter) { for (int y = 0; y < kHeight; ++y) { for (int x = 0; x < kWidth; ++x) { - bool ok = pixels[y*pixmap.rowBytes() + x] == decompBuffer[y*kWidth + x]; + bool ok = pixels[y*bitmap.rowBytes() + x] == decompBuffer[y*kWidth + x]; REPORTER_ASSERT(reporter, ok); } } @@ -188,11 +204,16 @@ DEF_TEST(CompressLATC, reporter) { const SkTextureCompressor::Format kLATCFormat = SkTextureCompressor::kLATC_Format; static const int kLATCEncodedBlockSize = 8; + SkBitmap bitmap; static const int kWidth = 8; static const int kHeight = 8; + SkImageInfo info = SkImageInfo::MakeA8(kWidth, kHeight); + + bool setInfoSuccess = bitmap.setInfo(info); + REPORTER_ASSERT(reporter, setInfoSuccess); - SkAutoPixmapStorage pixmap; - pixmap.alloc(SkImageInfo::MakeA8(kWidth, kHeight)); + bitmap.allocPixels(info); + bitmap.unlockPixels(); int latcDimX, latcDimY; SkTextureCompressor::GetBlockDimensions(kLATCFormat, &latcDimX, &latcDimY); @@ -205,13 +226,21 @@ DEF_TEST(CompressLATC, reporter) { REPORTER_ASSERT(reporter, (kSizeToBe % kLATCEncodedBlockSize) == 0); for (int lum = 0; lum < 256; ++lum) { - uint8_t* pixels = reinterpret_cast<uint8_t*>(pixmap.writable_addr()); + bitmap.lockPixels(); + uint8_t* pixels = reinterpret_cast<uint8_t*>(bitmap.getPixels()); + REPORTER_ASSERT(reporter, pixels); + if (NULL == pixels) { + bitmap.unlockPixels(); + continue; + } + for (int i = 0; i < kWidth*kHeight; ++i) { pixels[i] = lum; } + bitmap.unlockPixels(); SkAutoDataUnref latcData( - SkTextureCompressor::CompressBitmapToFormat(pixmap, kLATCFormat)); + SkTextureCompressor::CompressBitmapToFormat(bitmap, kLATCFormat)); REPORTER_ASSERT(reporter, latcData); if (NULL == latcData) { continue; |