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
diff --git a/src/core/SkAAClip.cpp b/src/core/SkAAClip.cpp
index 19e94c8..e55451e 100644
--- a/src/core/SkAAClip.cpp
+++ b/src/core/SkAAClip.cpp
@@ -1297,7 +1297,7 @@
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 @@
} 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 9f6a3d6..1daeb38 100644
--- a/src/core/SkAAClip.h
+++ b/src/core/SkAAClip.h
@@ -110,11 +110,12 @@
}
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 accf498..798e44a 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 @@
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 3fc306f..32db43c 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 @@
* 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 2108108..594a274 100644
--- a/src/core/SkBlitMask_D32.cpp
+++ b/src/core/SkBlitMask_D32.cpp
@@ -147,13 +147,13 @@
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 59078d6..2ac7b51 100644
--- a/src/core/SkBlitter.cpp
+++ b/src/core/SkBlitter.cpp
@@ -33,7 +33,7 @@
return NULL;
}
-const SkPixmap* SkBlitter::justAnOpaqueColor(uint32_t* value) {
+const SkBitmap* SkBlitter::justAnOpaqueColor(uint32_t* value) {
return NULL;
}
@@ -243,7 +243,7 @@
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 @@
}
}
-const SkPixmap* SkRectClipBlitter::justAnOpaqueColor(uint32_t* value) {
+const SkBitmap* SkRectClipBlitter::justAnOpaqueColor(uint32_t* value) {
return fBlitter->justAnOpaqueColor(value);
}
@@ -540,7 +540,7 @@
}
}
-const SkPixmap* SkRgnClipBlitter::justAnOpaqueColor(uint32_t* value) {
+const SkBitmap* SkRgnClipBlitter::justAnOpaqueColor(uint32_t* value) {
return fBlitter->justAnOpaqueColor(value);
}
@@ -778,7 +778,7 @@
#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 @@
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 b8126c2..695585a 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 @@
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 @@
/** @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 @@
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 @@
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 @@
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 ce7d6e7..11f4259 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 @@
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 @@
return;
}
- uint8_t* device = fDevice.writable_addr8(x, y);
+ uint8_t* device = fDevice.getAddr8(x, y);
unsigned srcA = fSrcA;
for (;;) {
@@ -96,7 +97,7 @@
#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 @@
#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 @@
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 @@
}
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 @@
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 @@
///////////////////////////////////////////////////////////////////////
-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 @@
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 @@
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 @@
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 @@
///////////////////////////////////////////////////////////////////////////////
-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 @@
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::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 @@
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::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 @@
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 @@
}
}
-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 683acf0..f2de82a 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 @@
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 @@
//////////////////////////////////////////////////////////////////////////////////////
-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 @@
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 @@
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 @@
}
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::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 @@
#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 @@
#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::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 @@
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 @@
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_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::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 @@
}
}
-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 @@
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 @@
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::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 @@
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::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 6724b12..ed9e103 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 @@
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 @@
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 @@
#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 @@
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 @@
// 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 @@
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 @@
///////////////////////////////////////////////////////////////////////////////
#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 @@
#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 @@
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::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 @@
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
-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 @@
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 @@
#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 @@
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::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::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 @@
///////////////////////////////////////////////////////////////////////////////
-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 @@
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 @@
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::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 @@
#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 @@
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::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::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 @@
///////////////////////////////////////////////////////////////////////////////
-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::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 @@
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 @@
///////////////////////////////////////////////////////////////////////////////
-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 @@
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 @@
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 @@
///////////////////////////////////////////////////////////////////////
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 @@
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 @@
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 @@
///////////////////////////////////////////////////////////////////////////////
-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 056a4e9..26b76df 100644
--- a/src/core/SkCanvas.cpp
+++ b/src/core/SkCanvas.cpp
@@ -271,9 +271,7 @@
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 31f3397..18821dc 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 @@
* 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 840a050..a8350cc 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() {}
+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::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 @@
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 @@
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 dd346d7..a218345 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 @@
bool next();
private:
- const SkPixmap& fBaseDst;
+ const SkBitmap& fBaseBitmap;
const SkRasterClip& fBaseRC;
enum State {
@@ -70,10 +71,10 @@
};
// 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 0069087..ac69680 100644
--- a/src/core/SkDraw.cpp
+++ b/src/core/SkDraw.cpp
@@ -44,18 +44,20 @@
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 @@
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 @@
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 @@
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 @@
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 @@
}
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 @@
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 @@
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 @@
}
// 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
}
SkAutoMaskFreeImage ami(dstM.fImage);
- SkAutoBlitterChoose blitterChooser(fDst, *fMatrix, paint);
+ SkAutoBlitterChoose blitterChooser(*fBitmap, *fMatrix, paint);
SkBlitter* blitter = blitterChooser.get();
SkAAClipBlitterWrapper wrapper;
@@ -986,7 +989,7 @@
// 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 @@
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 @@
// 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 @@
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 @@
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 @@
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 @@
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 @@
}
}
- 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 @@
#ifdef SK_DEBUG
void SkDraw::validate() const {
+ SkASSERT(fBitmap != NULL);
SkASSERT(fMatrix != NULL);
SkASSERT(fClip != NULL);
SkASSERT(fRC != NULL);
@@ -2162,7 +2174,7 @@
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 @@
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 4ce42dd..7747cae 100644
--- a/src/core/SkScalerContext.cpp
+++ b/src/core/SkScalerContext.cpp
@@ -248,7 +248,7 @@
}
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 @@
};
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 @@
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 @@
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 b7db3b4..9b4b9fd 100644
--- a/src/core/SkScan_Path.cpp
+++ b/src/core/SkScan_Path.cpp
@@ -344,7 +344,7 @@
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 8403d06..d3e112c 100644
--- a/src/effects/SkLayerRasterizer.cpp
+++ b/src/effects/SkLayerRasterizer.cpp
@@ -116,12 +116,9 @@
}
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 @@
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 3c7648a..21fbcb3 100755
--- a/src/gpu/GrAADistanceFieldPathRenderer.cpp
+++ b/src/gpu/GrAADistanceFieldPathRenderer.cpp
@@ -354,12 +354,14 @@
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 @@
draw.fRC = &rasterClip;
draw.fClip = &rasterClip.bwRgn();
draw.fMatrix = &drawMatrix;
- draw.fDst = dst;
+ draw.fBitmap = &bmp;
draw.drawPathCoverage(path, paint);
@@ -398,9 +400,13 @@
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 9b9865e..c13d2d8 100644
--- a/src/gpu/GrSWMaskHelper.cpp
+++ b/src/gpu/GrSWMaskHelper.cpp
@@ -146,8 +146,7 @@
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 @@
}
}
- 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 @@
*/
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 @@
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 @@
* 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 @@
* 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 b90205b..a69e4be 100644
--- a/src/gpu/GrSWMaskHelper.h
+++ b/src/gpu/GrSWMaskHelper.h
@@ -69,7 +69,7 @@
// 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 @@
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 9d29d51..12621e1 100644
--- a/src/utils/SkTextureCompressor.cpp
+++ b/src/utils/SkTextureCompressor.cpp
@@ -173,17 +173,19 @@
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 e31a5ab..e35bc95 100644
--- a/src/utils/SkTextureCompressor.h
+++ b/src/utils/SkTextureCompressor.h
@@ -55,10 +55,10 @@
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 e522375..73d8ee4 100644
--- a/src/utils/SkTextureCompressor_Blitter.h
+++ b/src/utils/SkTextureCompressor_Blitter.h
@@ -368,7 +368,7 @@
// 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;
}