remove SkRefCnt safeRef() and safeUnref(), and replace the call-sites with
SkSafeRef() and SkSafeUnref().
This is basically a bug waiting to happen. An optimizing compiler can remove
checks for null on "this" if it chooses. However, SkRefCnt::safeRef() relies on
precisely this check...
void SkRefCnt::safeRef() {
if (this) {
this->ref();
}
}
Since a compiler might skip the if-clause, it breaks the intention of this
method, hence its removal.
static inline void SkSafeRef(SkRefCnt* obj) {
if (obj) {
obj->ref();
}
}
This form is not ignored by an optimizing compile, so we use it instead.
git-svn-id: http://skia.googlecode.com/svn/trunk@762 2bbb7eff-a529-9590-31e7-b0007b416f81
diff --git a/include/core/SkRefCnt.h b/include/core/SkRefCnt.h
index be6ad0e..f109ead 100644
--- a/include/core/SkRefCnt.h
+++ b/include/core/SkRefCnt.h
@@ -62,24 +62,6 @@
SkDELETE(this);
}
}
-
- /** Helper version of ref(), that first checks to see if this is not null.
- If this is null, then do nothing.
- */
- void safeRef() const {
- if (this) {
- this->ref();
- }
- }
-
- /** Helper version of unref(), that first checks to see if this is not null.
- If this is null, then do nothing.
- */
- void safeUnref() const {
- if (this) {
- this->unref();
- }
- }
private:
mutable int32_t fRefCnt;
diff --git a/samplecode/SampleDrawLooper.cpp b/samplecode/SampleDrawLooper.cpp
index 7ea7b75..7cf53b2 100644
--- a/samplecode/SampleDrawLooper.cpp
+++ b/samplecode/SampleDrawLooper.cpp
@@ -27,9 +27,9 @@
{ SK_ColorBLUE, SkPaint::kFill_Style, 0, 0, 0 },
{ 0x88000000, SkPaint::kFill_Style, 0, SkIntToScalar(10), 3 }
};
-
+
fLooper = new SkLayerDrawLooper;
-
+
for (int i = 0; i < SK_ARRAY_COUNT(gParams); i++) {
SkPaint* paint = fLooper->addLayer(gParams[i].fOffset,
gParams[i].fOffset);
@@ -45,11 +45,11 @@
}
}
}
-
+
virtual ~LooperView() {
- fLooper->safeUnref();
+ SkSafeUnref(fLooper);
}
-
+
protected:
// overrides from SkEventSink
virtual bool onQuery(SkEvent* evt) {
@@ -59,18 +59,18 @@
}
return this->INHERITED::onQuery(evt);
}
-
+
void drawBG(SkCanvas* canvas) {
canvas->drawColor(0xFFDDDDDD);
// canvas->drawColor(SK_ColorWHITE);
}
-
+
virtual void onDraw(SkCanvas* canvas) {
this->drawBG(canvas);
-
+
SkPaint paint;
paint.setLooper(fLooper);
-
+
canvas->drawCircle(SkIntToScalar(50), SkIntToScalar(50),
SkIntToScalar(30), paint);
@@ -80,16 +80,16 @@
canvas->drawText("Looper", 6, SkIntToScalar(230), SkIntToScalar(100),
paint);
}
-
+
virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
this->inval(NULL);
return this->INHERITED::onFindClickHandler(x, y);
}
-
+
virtual bool onClick(Click* click) {
return this->INHERITED::onClick(click);
}
-
+
private:
typedef SkView INHERITED;
};
diff --git a/samplecode/SampleFontScalerTest.cpp b/samplecode/SampleFontScalerTest.cpp
index d597a9a..de70292 100644
--- a/samplecode/SampleFontScalerTest.cpp
+++ b/samplecode/SampleFontScalerTest.cpp
@@ -39,10 +39,10 @@
gFaces[i].fStyle);
}
}
-
+
virtual ~FontScalerTestView() {
for (int i = 0; i < gFaceCount; i++) {
- fFaces[i]->safeUnref();
+ SkSafeUnref(fFaces[i]);
}
}
@@ -55,14 +55,14 @@
}
return this->INHERITED::onQuery(evt);
}
-
+
void drawBG(SkCanvas* canvas) {
canvas->drawColor(0xFFDDDDDD);
}
-
+
virtual void onDraw(SkCanvas* canvas) {
this->drawBG(canvas);
-
+
SkPaint paint;
// test handling of obscene cubic values (currently broken)
@@ -72,19 +72,19 @@
pts[1].set(-7.18397061e+15, -1.53091184e+13);
pts[2].set(-1.30077315e+16, -2.77196141e+13);
pts[3].set(-1.30077315e+16, -2.77196162e+13);
-
+
SkPath path;
path.moveTo(pts[0]);
path.cubicTo(pts[1], pts[2], pts[3]);
canvas->drawPath(path, paint);
}
-
+
canvas->translate(200, 20);
canvas->rotate(30);
paint.setAntiAlias(true);
- paint.setTypeface(SkTypeface::CreateFromName("Times Roman", SkTypeface::kNormal))->safeUnref();
-
+ SkSafeUnref(paint.setTypeface(SkTypeface::CreateFromName("Times Roman", SkTypeface::kNormal)));
+
// const char* text = "abcdefghijklmnopqrstuvwxyz";
const char* text = "HnHnHnHnHnHnHnHnH";
size_t textLen = strlen(text);
@@ -99,7 +99,7 @@
r.set(0, 0, x, y*20);
canvas->drawRect(r, p);
}
-
+
int index = 0;
for (int ps = 9; ps <= 24; ps++) {
textLen = strlen(text);
@@ -109,7 +109,7 @@
index += 1;
}
}
-
+
private:
typedef SkView INHERITED;
};
diff --git a/samplecode/SampleMovie.cpp b/samplecode/SampleMovie.cpp
index ed1a844..af34198 100644
--- a/samplecode/SampleMovie.cpp
+++ b/samplecode/SampleMovie.cpp
@@ -11,9 +11,9 @@
AnimGifView() {
fMovie = SkMovie::DecodeFile("/skimages/dollarblk.gif");
}
-
+
virtual ~AnimGifView() {
- fMovie->safeUnref();
+ SkSafeUnref(fMovie);
}
protected:
@@ -25,14 +25,14 @@
}
return this->INHERITED::onQuery(evt);
}
-
+
void drawBG(SkCanvas* canvas) {
canvas->drawColor(0xFFDDDDDD);
}
-
+
virtual void onDraw(SkCanvas* canvas) {
this->drawBG(canvas);
-
+
if (fMovie) {
if (fMovie->duration()) {
fMovie->setTime(SkTime::GetMSecs() % fMovie->duration());
@@ -44,7 +44,7 @@
this->inval(NULL);
}
}
-
+
private:
SkRect fClip;
SkIPoint* fPoints;
diff --git a/samplecode/SamplePatch.cpp b/samplecode/SamplePatch.cpp
index fb70dba..4203391 100644
--- a/samplecode/SamplePatch.cpp
+++ b/samplecode/SamplePatch.cpp
@@ -23,17 +23,17 @@
static void drawtriangle(SkCanvas* canvas, const SkPaint& paint,
const SkPoint pts[3]) {
SkPath path;
-
+
path.moveTo(pts[0]);
path.lineTo(pts[1]);
path.lineTo(pts[2]);
-
+
canvas->drawPath(path, paint);
}
static SkShader* make_shader0(SkIPoint* size) {
SkBitmap bm;
-
+
// SkImageDecoder::DecodeFile("/skimages/progressivejpg.jpg", &bm);
SkImageDecoder::DecodeFile("/skimages/logo.png", &bm);
size->set(bm.width(), bm.height());
@@ -54,7 +54,7 @@
public:
Patch() { sk_bzero(fPts, sizeof(fPts)); }
~Patch() {}
-
+
void setPatch(const SkPoint pts[12]) {
memcpy(fPts, pts, 12 * sizeof(SkPoint));
fPts[12] = pts[0]; // the last shall be first
@@ -63,7 +63,7 @@
void draw(SkCanvas*, const SkPaint&, int segsU, int segsV,
bool doTextures, bool doColors);
-
+
private:
SkPoint fPts[13];
int fW, fH;
@@ -89,12 +89,12 @@
SkScalar u = SkIntToScalar(iu) / nu;
SkScalar v = SkIntToScalar(iv) / nv;
-
+
SkScalar uv = SkScalarMul(u, v);
SkScalar Uv = SkScalarMul(SK_Scalar1 - u, v);
SkScalar uV = SkScalarMul(u, SK_Scalar1 - v);
SkScalar UV = SkScalarMul(SK_Scalar1 - u, SK_Scalar1 - v);
-
+
SkScalar x0 = SkScalarMul(UV, edge[TL].fX) + SkScalarMul(uV, edge[TR].fX) +
SkScalarMul(Uv, edge[BL].fX) + SkScalarMul(uv, edge[BR].fX);
SkScalar y0 = SkScalarMul(UV, edge[TL].fY) + SkScalarMul(uV, edge[TR].fY) +
@@ -123,7 +123,7 @@
static SkColor make_color(SkScalar s, SkScalar t) {
int cs = ScalarTo255(s);
- int ct = ScalarTo255(t);
+ int ct = ScalarTo255(t);
return SkColorSetARGB(0xFF, cs, 0, 0) + SkColorSetARGB(0, 0, ct, 0);
}
@@ -139,22 +139,22 @@
SkPoint* edge1 = edge0 + nu;
SkPoint* edge2 = edge1 + nv;
SkPoint* edge3 = edge2 + nu;
-
+
// evaluate the edge points
eval_patch_edge(fPts + 0, edge0, nu);
eval_patch_edge(fPts + 3, edge1, nv);
eval_patch_edge(fPts + 6, edge2, nu);
eval_patch_edge(fPts + 9, edge3, nv);
edge3[nv] = edge0[0]; // the last shall be first
-
+
for (i = 0; i < npts; i++) {
// canvas->drawLine(edge0[i].fX, edge0[i].fY, edge0[i+1].fX, edge0[i+1].fY, paint);
}
-
+
int row, vertCount = (nu + 1) * (nv + 1);
SkAutoTMalloc<SkPoint> vertStorage(vertCount);
SkPoint* verts = vertStorage.get();
-
+
// first row
memcpy(verts, edge0, (nu + 1) * sizeof(SkPoint));
// rows
@@ -172,9 +172,9 @@
for (i = 0; i <= nu; i++) {
last[i] = edge2[nu - i];
}
-
+
// canvas->drawPoints(verts, vertCount, paint);
-
+
int stripCount = (nu + 1) * 2;
SkAutoTMalloc<SkPoint> stripStorage(stripCount * 2);
SkAutoTMalloc<SkColor> colorStorage(stripCount);
@@ -226,8 +226,8 @@
SkShader* fShader1;
SkIPoint fSize0, fSize1;
SkPoint fPts[12];
-
-public:
+
+public:
PatchView() {
fShader0 = make_shader0(&fSize0);
fSize1 = fSize0;
@@ -251,12 +251,12 @@
fPts[10].set(S*0, T*3);
fPts[11].set(S*0, T*2);
}
-
+
virtual ~PatchView() {
- fShader0->safeUnref();
- fShader1->safeUnref();
+ SkSafeUnref(fShader0);
+ SkSafeUnref(fShader1);
}
-
+
protected:
// overrides from SkEventSink
virtual bool onQuery(SkEvent* evt) {
@@ -268,22 +268,22 @@
}
return this->INHERITED::onQuery(evt);
}
-
+
void drawBG(SkCanvas* canvas) {
canvas->drawColor(SK_ColorGRAY);
}
-
+
virtual void onDraw(SkCanvas* canvas) {
this->drawBG(canvas);
-
+
SkPaint paint;
paint.setDither(true);
paint.setFilterBitmap(true);
-
+
canvas->translate(SkIntToScalar(20), 0);
Patch patch;
-
+
paint.setShader(fShader0);
if (fSize0.fX == 0) {
fSize0.fX = 1;
@@ -292,33 +292,33 @@
fSize0.fY = 1;
}
patch.setBounds(fSize0.fX, fSize0.fY);
-
- patch.setPatch(fPts);
+
+ patch.setPatch(fPts);
drawpatches(canvas, paint, 10, 10, &patch);
-
+
paint.setShader(NULL);
paint.setAntiAlias(true);
paint.setStrokeWidth(SkIntToScalar(5));
canvas->drawPoints(SkCanvas::kPoints_PointMode, SK_ARRAY_COUNT(fPts), fPts, paint);
-
+
canvas->translate(0, SkIntToScalar(300));
-
+
paint.setAntiAlias(false);
paint.setShader(fShader1);
patch.setBounds(fSize1.fX, fSize1.fY);
drawpatches(canvas, paint, 10, 10, &patch);
}
-
+
class PtClick : public Click {
public:
int fIndex;
PtClick(SkView* view, int index) : Click(view), fIndex(index) {}
};
-
+
static bool hittest(const SkPoint& pt, SkScalar x, SkScalar y) {
return SkPoint::Length(pt.fX - x, pt.fY - y) < SkIntToScalar(5);
}
-
+
virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
for (int i = 0; i < SK_ARRAY_COUNT(fPts); i++) {
if (hittest(fPts[i], x, y)) {
@@ -327,13 +327,13 @@
}
return this->INHERITED::onFindClickHandler(x, y);
}
-
+
virtual bool onClick(Click* click) {
fPts[((PtClick*)click)->fIndex].set(click->fCurr.fX, click->fCurr.fY);
this->inval(NULL);
return true;
}
-
+
private:
typedef SkView INHERITED;
};
diff --git a/samplecode/SampleShaders.cpp b/samplecode/SampleShaders.cpp
index 115f9f5..86c8b17 100644
--- a/samplecode/SampleShaders.cpp
+++ b/samplecode/SampleShaders.cpp
@@ -36,7 +36,7 @@
shaderA->unref();
shaderB->unref();
mode->unref();
-
+
return shader;
}
@@ -51,19 +51,19 @@
SkPoint pts[2];
SkColor colors[2];
-
+
pts[0].set(0, 0);
pts[1].set(SkIntToScalar(100), 0);
colors[0] = SK_ColorRED;
colors[1] = SK_ColorBLUE;
SkShader* shaderA = SkGradientShader::CreateLinear(pts, colors, NULL, 2, SkShader::kClamp_TileMode);
-
+
pts[0].set(0, 0);
pts[1].set(0, SkIntToScalar(100));
colors[0] = SK_ColorBLACK;
colors[1] = SkColorSetARGB(0x80, 0, 0, 0);
SkShader* shaderB = SkGradientShader::CreateLinear(pts, colors, NULL, 2, SkShader::kClamp_TileMode);
-
+
SkXfermode* mode = SkXfermode::Create(SkXfermode::kDstIn_Mode);
fShader = new SkComposeShader(shaderA, shaderB, mode);
@@ -73,9 +73,9 @@
}
virtual ~ShaderView()
{
- fShader->safeUnref();
+ SkSafeUnref(fShader);
}
-
+
protected:
// overrides from SkEventSink
virtual bool onQuery(SkEvent* evt) {
@@ -85,21 +85,21 @@
}
return this->INHERITED::onQuery(evt);
}
-
+
void drawBG(SkCanvas* canvas)
{
// canvas->drawColor(0xFFDDDDDD);
canvas->drawColor(SK_ColorWHITE);
}
-
+
virtual void onDraw(SkCanvas* canvas)
{
this->drawBG(canvas);
-
+
canvas->drawBitmap(fBitmap, 0, 0);
-
+
canvas->translate(SkIntToScalar(20), SkIntToScalar(120));
-
+
SkPaint paint;
SkRect r;
@@ -120,22 +120,22 @@
canvas->drawRect(r, paint);
paint.setShader(make_bitmapfade(fBitmap))->unref();
canvas->drawRect(r, paint);
-
+
paint.setShader(new SkTransparentShader)->unref();
canvas->drawRect(r, paint);
}
-
- virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y)
+
+ virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y)
{
this->inval(NULL);
return this->INHERITED::onFindClickHandler(x, y);
}
-
- virtual bool onClick(Click* click)
+
+ virtual bool onClick(Click* click)
{
return this->INHERITED::onClick(click);
}
-
+
private:
typedef SkView INHERITED;
};
diff --git a/samplecode/SampleText.cpp b/samplecode/SampleText.cpp
index abd88be..b1bb6cb 100644
--- a/samplecode/SampleText.cpp
+++ b/samplecode/SampleText.cpp
@@ -63,7 +63,7 @@
{
int c = srcRows[1][1];
float f = c / 255.f;
-
+
if (c >= 0)
{
f = sqrtf(f);
@@ -96,7 +96,7 @@
SkTypeface* t1 = SkTypeface::CreateFromName(NULL, SkTypeface::kNormal);
SkTypeface* t2 = SkTypeface::CreateFromName("arial", SkTypeface::kNormal);
SkTypeface* t3 = SkTypeface::CreateFromName("helvetica", SkTypeface::kItalic);
-
+
SkASSERT(t0 == t1);
SkASSERT(t0 == t2);
SkASSERT(t0 == t3);
@@ -109,7 +109,7 @@
const char* text = "sdfkljAKLDFJKEWkldfjlk#$%&sdfs.dsj";
size_t length = strlen(text);
SkScalar width = paint.measureText(text, length);
-
+
SkScalar mm = 0;
SkScalar nn = 0;
for (SkScalar w = 0; w <= width; w += SK_Scalar1)
@@ -117,10 +117,10 @@
SkScalar m;
size_t n = paint.breakText(text, length, w, &m,
SkPaint::kBackward_TextBufferDirection);
-
+
SkASSERT(n <= length);
SkASSERT(m <= width);
-
+
if (n == 0)
SkASSERT(m == 0);
else
@@ -152,7 +152,7 @@
virtual void xfer16(uint16_t dst[], const SkPMColor src[], int count, const SkAlpha aa[]);
typedef SkFlattenable* (*Factory)(SkFlattenableReadBuffer&);
-
+
// overrides for SkFlattenable
virtual Factory getFactory() { return Create; }
virtual void flatten(SkFlattenableWriteBuffer& b)
@@ -160,7 +160,7 @@
// this->INHERITED::flatten(b); How can we know if this is legal????
b.write32(SkScalarToFixed(fExp));
}
-
+
private:
SkScalar fExp; // user's value
uint8_t fTable[256]; // cache
@@ -175,7 +175,7 @@
{
return SkNEW_ARGS(SkPowerMode, (b));
}
-
+
typedef SkXfermode INHERITED;
};
@@ -183,7 +183,7 @@
{
fExp = e;
float ee = SkScalarToFloat(e);
-
+
printf("------ %g\n", ee);
for (int i = 0; i < 256; i++)
{
@@ -231,7 +231,7 @@
static int count_char_points(const SkPaint& paint, char c)
{
SkPath path;
-
+
paint.getTextPath(&c, 1, 0, 0, &path);
return path.getPoints(NULL, 0);
}
@@ -264,7 +264,7 @@
{
SkRect16 r, bounds;
int i;
-
+
rgn->setEmpty();
bounds.setEmpty();
@@ -281,7 +281,7 @@
for (i = 0; i < SK_ARRAY_COUNT(badrects); i++)
{
- r.set(badrects[i].x, badrects[i].y, badrects[i].x + badrects[i].width, badrects[i].y + badrects[i].height);
+ r.set(badrects[i].x, badrects[i].y, badrects[i].x + badrects[i].width, badrects[i].y + badrects[i].height);
SkASSERT(rgn->contains(r));
}
}
@@ -291,7 +291,7 @@
{
SkRect r;
SkRegion::Iterator iter(rgn);
-
+
for (; !iter.done(); iter.next())
{
r.set(iter.rect());
@@ -304,11 +304,11 @@
SkScalar clickX)
{
SkPaint linePaint;
-
+
linePaint.setAntiAlias(true);
-
+
SkScalar measured;
-
+
if (paint.breakText(text, length, clickX - x, &measured, SkPaint::kForward_TextBufferDirection))
{
linePaint.setColor(SK_ColorRED);
@@ -331,20 +331,20 @@
SkIntToScalar(5), SkIntToScalar(3),
SkIntToScalar(2), SkIntToScalar(3)
};
-
+
static const SkPoint src[] = {
SkIntToScalar(0), SkIntToScalar(0),
SkIntToScalar(1), SkIntToScalar(0),
SkIntToScalar(1), SkIntToScalar(1),
SkIntToScalar(0), SkIntToScalar(1)
};
-
+
SkMatrix matrix;
-
+
if (matrix.setPolyToPoly(src, dst, 4))
{
SkPoint pt = { SK_Scalar1/2, SK_Scalar1/2 };
- matrix.mapPoints(&pt, 1);
+ matrix.mapPoints(&pt, 1);
printf("---- x = %g y = %g\n", SkScalarToFloat(pt.fX), SkScalarToFloat(pt.fY));
}
else
@@ -424,25 +424,25 @@
printf("--- ave reduction = %g%%\n", 100. * (gOld - gNew) / gOld);
}
-
+
if (true)
{
SkPoint pts[] = { SkIntToScalar(20), 0, SkIntToScalar(256+20), 0 };
SkColor colors[] = { SkColorSetARGB(0, 255, 255, 255), SkColorSetARGB(255, 255, 255, 255) };
fGradient = SkGradientShader::CreateLinear(pts, colors, NULL, 2, SkShader::kClamp_TileMode);
}
-
+
fClickX = 0;
- test_breakText();
+ test_breakText();
test_typefaceCache();
// test_poly();
}
-
+
virtual ~TextSpeedView()
{
fGradient->unref();
- fMF->safeUnref();
+ SkSafeUnref(fMF);
}
protected:
@@ -456,36 +456,36 @@
}
return this->INHERITED::onQuery(evt);
}
-
+
void drawBG(SkCanvas* canvas)
{
// canvas->drawColor(0xFFDDDDDD);
canvas->drawColor(SK_ColorWHITE);
// canvas->drawColor(SK_ColorBLACK);
}
-
+
static void make_textstrip(SkBitmap* bm)
{
bm->setConfig(SkBitmap::kRGB_565_Config, 200, 18);
bm->allocPixels();
bm->eraseColor(SK_ColorWHITE);
-
+
SkCanvas canvas(*bm);
SkPaint paint;
const char* s = "Lorem ipsum dolor sit amet, consectetuer adipiscing elit";
-
+
paint.setFlags(paint.getFlags() | SkPaint::kAntiAlias_Flag
| SkPaint::kDevKernText_Flag);
paint.setTextSize(SkIntToScalar(14));
canvas.drawText(s, strlen(s), SkIntToScalar(8), SkIntToScalar(14), paint);
}
-
+
static void fill_pts(SkPoint pts[], size_t n, SkRandom* rand)
{
for (size_t i = 0; i < n; i++)
pts[i].set(rand->nextUScalar1() * 640, rand->nextUScalar1() * 480);
}
-
+
virtual void onDraw(SkCanvas* canvas)
{
inval(NULL);
@@ -494,22 +494,22 @@
canvas->translate(SkIntToScalar(480), 0);
canvas->rotate(SkIntToScalar(90));
}
-
+
this->drawBG(canvas);
-
+
if (false)
{
SkPaint p;
-
+
p.setAntiAlias(true);
p.setSubpixelText(true);
// p.setLinearText(true);
-
+
SkScalar size = SkIntToScalar(6);
SkMSec dur = 0;
const int LOOP = 16;
const int TIMES = 10;
-
+
for (int times = 0; times < TIMES; times++)
{
SkMSec now = SkTime::GetMSecs();
@@ -522,12 +522,12 @@
dur += SkTime::GetMSecs() - now;
SkGraphics::SetFontCacheUsed(0);
}
-
+
printf("----- duration = %g\n", dur * 1.0 / TIMES);
this->inval(NULL);
return;
}
-
+
if (false)
{
SkPaint p;
@@ -552,7 +552,7 @@
}
}
}
-
+
if (false)
{
SkPaint p;
@@ -569,11 +569,11 @@
#endif
return;
}
-
+
if (false)
{
SkBitmap bm;
-
+
make_textstrip(&bm);
canvas->translate(0, SkIntToScalar(50));
for (int i = 0; i < 10; i++)
@@ -582,16 +582,16 @@
SkPowerMode mode(SkFloatToScalar(1 / gamma));
SkPaint p;
p.setXfermode(&mode);
-
+
canvas->drawBitmap(bm, 0, SkIntToScalar(i) * bm.height(), &p);
}
return;
}
-
+
if (false)
{
SkPaint paint;
-
+
paint.setAntiAlias(true);
paint.setDevKernText(true);
SkMSec now = SkTime::GetMSecs();
@@ -609,9 +609,9 @@
SkRegion rgn;
SkPath path;
SkPaint paint;
-
+
// make_badrgn(&rgn, -2);
-
+
if (false)
{
paint.setColor(SK_ColorBLUE);
@@ -619,7 +619,7 @@
}
paint.setColor(SK_ColorRED);
draw_rgn(rgn, canvas, paint);
-
+
rgn.getBoundaryPath(&path);
paint.setARGB(0x80, 0, 0, 0xFF);
canvas->drawPath(path, paint);
@@ -630,13 +630,13 @@
{
SkRect r = { SkIntToScalar(50), SkIntToScalar(50), SkIntToScalar(300), SkIntToScalar(300) };
SkPaint p;
-
+
p.setStyle(SkPaint::kStroke_Style);
p.setAlpha(0x80);
p.setStrokeWidth(SkIntToScalar(20));
canvas->drawRect(r, p);
}
-
+
if (false)
{
SkPaint p;
@@ -648,7 +648,7 @@
canvas->drawRect(r, p);
return;
}
-
+
if (false)
{
Sk64 aa, bb;
@@ -661,19 +661,19 @@
b = a >> 16;
// SkFixed c = aa.addGetFixed(bb);
-
+
printf("%d %d\n", (int)a, a >> 32);
-
+
SkBitmap bm;
SkPaint paint;
SkScalar scale = SkFloatToScalar(0.5625f);
SkScalar x = SkIntToScalar(100);
SkScalar y = SkIntToScalar(100);
-
+
//paint.setFilterType(SkPaint::kBilinear_FilterType);
-
+
SkImageDecoder::DecodeFile("/app_web_browser.png", &bm);
-
+
// canvas->drawBitmap(bm, x, y, paint);
x += SkIntToScalar(100);
canvas->save();
@@ -691,7 +691,7 @@
canvas->restore();
return;
}
-
+
SkAutoCanvasRestore restore(canvas, false);
{
SkRect r;
@@ -704,7 +704,7 @@
int index = fHints % SK_ARRAY_COUNT(gHints);
index = 1;
// const char* style = gHints[index].fName;
-
+
// canvas->translate(0, SkIntToScalar(50));
// canvas->drawText(style, strlen(style), SkIntToScalar(20), SkIntToScalar(20), paint);
@@ -712,20 +712,20 @@
SkSafeUnref(paint.setTypeface(SkTypeface::CreateFromFile("/skimages/samplefont.ttf")));
paint.setAntiAlias(true);
paint.setFlags(paint.getFlags() | gHints[index].fFlags);
-
+
SkMSec now = 0;
if (REPEAT_COUNT > 1)
now = SkTime::GetMSecs();
SkRect clip;
clip.set(SkIntToScalar(25), SkIntToScalar(34), SkIntToScalar(88), SkIntToScalar(155));
-
+
if (0) {
canvas->clipRect(clip);
}
if (0) {
- SkPath clipPath;
+ SkPath clipPath;
clipPath.addOval(clip);
canvas->clipPath(clipPath);
}
@@ -736,7 +736,7 @@
#ifdef TEST_CLICKX
{
SkPaint p;
-
+
p.setColor(SK_ColorGREEN);
p.setAntiAlias(true);
canvas->drawLine(fClickX, 0, fClickX, SkIntToScalar(1000), p);
@@ -758,26 +758,26 @@
// SkGraphics::SetFontCacheUsed(0);
}
}
-
+
if (REPEAT_COUNT > 1)
{
printf("--------- FPS = %g\n", REPEAT_COUNT * 1000. / (SkTime::GetMSecs() - now));
this->inval(NULL);
}
}
-
- virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y)
+
+ virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y)
{
fClickX = x;
this->inval(NULL);
return this->INHERITED::onFindClickHandler(x, y);
}
-
- virtual bool onClick(Click* click)
+
+ virtual bool onClick(Click* click)
{
return this->INHERITED::onClick(click);
}
-
+
private:
int fHints;
SkScalar fClickX;
diff --git a/samplecode/SampleTextEffects.cpp b/samplecode/SampleTextEffects.cpp
index b71f5b4..77a3bd7 100644
--- a/samplecode/SampleTextEffects.cpp
+++ b/samplecode/SampleTextEffects.cpp
@@ -16,9 +16,9 @@
unsigned r = SkGetPackedR32(c);
unsigned g = SkGetPackedG32(c);
unsigned b = SkGetPackedB32(c);
-
+
unsigned x = r * 5 + g * 7 + b * 4 >> 4;
-
+
return SkPackARGB32(0, x, x, x) | (c & (SK_A32_MASK << SK_A32_SHIFT));
}
@@ -44,7 +44,7 @@
for (int i = 0; i < count; i++)
result[i] = src[i] & mask;
}
-
+
private:
SkPMColor fMask;
};
@@ -82,7 +82,7 @@
p.setStrokeWidth(SK_Scalar1*2);
rast->addLayer(p);
}
-
+
static void r2(SkLayerRasterizer* rast, SkPaint& p)
{
p.setStyle(SkPaint::kStrokeAndFill_Style);
@@ -134,7 +134,7 @@
static void r6(SkLayerRasterizer* rast, SkPaint& p)
{
rast->addLayer(p);
-
+
p.setAntiAlias(false);
SkLayerRasterizer* rast2 = new SkLayerRasterizer;
r5(rast2, p);
@@ -153,7 +153,7 @@
virtual void flatten(SkFlattenableWriteBuffer& buffer)
{
this->INHERITED::flatten(buffer);
-
+
buffer.writeScalar(fRadius);
}
virtual Factory getFactory() { return CreateProc; }
@@ -163,7 +163,7 @@
{
dst->addCircle(loc.fX, loc.fY, fRadius);
}
-
+
Dot2DPathEffect(SkFlattenableReadBuffer& buffer) : Sk2DPathEffect(buffer)
{
fRadius = buffer.readScalar();
@@ -191,7 +191,7 @@
static void r8(SkLayerRasterizer* rast, SkPaint& p)
{
rast->addLayer(p);
-
+
SkMatrix lattice;
lattice.setScale(SK_Scalar1*6, SK_Scalar1*6, 0, 0);
lattice.postSkew(SK_Scalar1/3, 0, 0, 0);
@@ -220,7 +220,7 @@
}
return false;
}
-
+
virtual Factory getFactory() { return CreateProc; }
virtual void flatten(SkFlattenableWriteBuffer& buffer)
{
@@ -239,17 +239,17 @@
src[1].set(SkIntToScalar(u+ucount) + SK_ScalarHalf,
SkIntToScalar(v) + SK_ScalarHalf);
this->getMatrix().mapPoints(dstP, src, 2);
-
+
dst->moveTo(dstP[0]);
dst->lineTo(dstP[1]);
}
}
-
+
Line2DPathEffect(SkFlattenableReadBuffer& buffer) : Sk2DPathEffect(buffer)
{
fWidth = buffer.readScalar();
}
-
+
private:
SkScalar fWidth;
@@ -264,7 +264,7 @@
static void r9(SkLayerRasterizer* rast, SkPaint& p)
{
rast->addLayer(p);
-
+
SkMatrix lattice;
lattice.setScale(SK_Scalar1, SK_Scalar1*6, 0, 0);
lattice.postRotate(SkIntToScalar(30), 0, 0);
@@ -302,7 +302,7 @@
unsigned dr = SkAbs32(SkPacked16ToR32(a) - SkPacked16ToR32(b));
unsigned dg = SkAbs32(SkPacked16ToG32(a) - SkPacked16ToG32(b));
unsigned db = SkAbs32(SkPacked16ToB32(a) - SkPacked16ToB32(b));
-
+
return SkMax32(dr, SkMax32(dg, db));
}
@@ -317,7 +317,7 @@
}
static void apply_shader(SkPaint* paint, int index)
-{
+{
raster_proc proc = gRastProcs[index];
if (proc)
{
@@ -331,7 +331,7 @@
#if 0
SkScalar dir[] = { SK_Scalar1, SK_Scalar1, SK_Scalar1 };
- paint->setMaskFilter(SkBlurMaskFilter::CreateEmboss(dir, SK_Scalar1/4, SkIntToScalar(4), SkIntToScalar(3)))->unref();
+ paint->setMaskFilter(SkBlurMaskFilter::CreateEmboss(dir, SK_Scalar1/4, SkIntToScalar(4), SkIntToScalar(3)))->unref();
#endif
paint->setColor(SK_ColorBLUE);
}
@@ -345,10 +345,10 @@
{
fFace = SkTypeface::CreateFromFile("/Users/reed/Downloads/p052024l.pfb");
}
-
+
virtual ~TextEffectView()
{
- fFace->safeUnref();
+ SkSafeUnref(fFace);
}
protected:
@@ -362,22 +362,22 @@
}
return this->INHERITED::onQuery(evt);
}
-
+
void drawBG(SkCanvas* canvas)
{
// canvas->drawColor(0xFFDDDDDD);
canvas->drawColor(SK_ColorWHITE);
}
-
+
virtual void onDraw(SkCanvas* canvas)
{
this->drawBG(canvas);
-
+
canvas->save();
// canvas->scale(SK_Scalar1*2, SK_Scalar1*2, 0, 0);
SkPaint paint;
-
+
paint.setAntiAlias(true);
paint.setTextSize(SkIntToScalar(56));
paint.setTypeface(SkTypeface::CreateFromName("sans-serif",
@@ -389,11 +389,11 @@
SkString str("TextEffects");
paint.setTypeface(fFace);
-
+
for (int i = 0; i < SK_ARRAY_COUNT(gRastProcs); i++)
{
apply_shader(&paint, i);
-
+
// paint.setMaskFilter(NULL);
// paint.setColor(SK_ColorBLACK);
@@ -403,7 +403,7 @@
gLightingColors[index].fMul,
gLightingColors[index].fAdd))->unref();
#endif
-
+
canvas->drawText(str.c_str(), str.size(), x, y, paint);
if (0)
@@ -417,7 +417,7 @@
}
canvas->restore();
-
+
if (0)
{
SkPoint pts[] = { 0, 0, 0, SkIntToScalar(150) };
@@ -428,7 +428,7 @@
paint.setShader(s);
canvas->drawRectCoords(0, 0, SkIntToScalar(120), SkIntToScalar(150), paint);
}
-
+
if (0)
{
SkAvoidXfermode mode(SK_ColorWHITE, 0xFF,
@@ -442,20 +442,20 @@
canvas->drawOval(r, paint);
}
}
-
- virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y)
+
+ virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y)
{
gRastIndex = (gRastIndex + 1) % SK_ARRAY_COUNT(gRastProcs);
this->inval(NULL);
return this->INHERITED::onFindClickHandler(x, y);
}
-
- virtual bool onClick(Click* click)
+
+ virtual bool onClick(Click* click)
{
return this->INHERITED::onClick(click);
}
-
+
private:
typedef SkView INHERITED;
};
diff --git a/samplecode/SampleTypeface.cpp b/samplecode/SampleTypeface.cpp
index fa2f546..96082af 100644
--- a/samplecode/SampleTypeface.cpp
+++ b/samplecode/SampleTypeface.cpp
@@ -70,10 +70,10 @@
gFaces[i].fStyle);
}
}
-
+
virtual ~TypefaceView() {
for (int i = 0; i < gFaceCount; i++) {
- fFaces[i]->safeUnref();
+ SkSafeUnref(fFaces[i]);
}
}
@@ -86,11 +86,11 @@
}
return this->INHERITED::onQuery(evt);
}
-
+
void drawBG(SkCanvas* canvas) {
canvas->drawColor(0xFFDDDDDD);
}
-
+
virtual void onDraw(SkCanvas* canvas) {
this->drawBG(canvas);
@@ -105,17 +105,17 @@
const char* text = "Hamburgefons";
const size_t textLen = strlen(text);
-
+
SkScalar x = SkIntToScalar(10);
SkScalar dy = paint.getFontMetrics(NULL);
SkScalar y = dy;
-
+
for (int i = 0; i < gFaceCount; i++) {
paint.setTypeface(fFaces[i]);
canvas->drawText(text, textLen, x, y, paint);
y += dy;
}
-
+
SkRect r;
if (false) {
r.set(10, 10, 100, 100);
@@ -132,7 +132,7 @@
paint.setStyle(SkPaint::kFill_Style);
canvas->drawRect(r, paint);
}
-
+
if (false) {
SkScalar rad = 90;
SkScalar angle = 210;
@@ -142,12 +142,12 @@
SkPath path;
path.arcTo(r, angle, -(angle + 90), true);
path.close();
-
+
paint.setColor(SK_ColorRED);
canvas->drawRect(path.getBounds(), paint);
paint.setColor(SK_ColorBLUE);
canvas->drawPath(path, paint);
-
+
paint.setColor(SK_ColorGREEN);
SkPoint pts[100];
int count = path.getPoints(pts, 100);
@@ -155,7 +155,7 @@
canvas->drawPoints(SkCanvas::kPoints_PointMode, count, pts, paint);
}
}
-
+
private:
typedef SkView INHERITED;
};
diff --git a/samplecode/SampleVertices.cpp b/samplecode/SampleVertices.cpp
index 96fa0da..7f5aa96 100644
--- a/samplecode/SampleVertices.cpp
+++ b/samplecode/SampleVertices.cpp
@@ -21,7 +21,7 @@
static SkShader* make_shader0(SkIPoint* size) {
SkBitmap bm;
-
+
SkImageDecoder::DecodeFile("/skimages/logo.png", &bm);
size->set(bm.width(), bm.height());
return SkShader::CreateBitmapShader(bm, SkShader::kClamp_TileMode,
@@ -39,25 +39,25 @@
SkShader* fShader0;
SkShader* fShader1;
-public:
+public:
VerticesView() {
SkIPoint size;
-
+
fShader0 = make_shader0(&size);
fShader1 = make_shader1(size);
make_strip(&fRecs[0], size.fX, size.fY);
make_fan(&fRecs[1], size.fX, size.fY);
make_tris(&fRecs[2]);
-
+
fScale = SK_Scalar1;
}
-
+
virtual ~VerticesView() {
- fShader0->safeUnref();
- fShader1->safeUnref();
+ SkSafeUnref(fShader0);
+ SkSafeUnref(fShader1);
}
-
+
protected:
// overrides from SkEventSink
virtual bool onQuery(SkEvent* evt) {
@@ -69,65 +69,65 @@
}
return this->INHERITED::onQuery(evt);
}
-
+
void drawBG(SkCanvas* canvas) {
canvas->drawColor(SK_ColorGRAY);
}
-
+
SkScalar fScale;
-
+
virtual void onDraw(SkCanvas* canvas) {
this->drawBG(canvas);
-
+
SkPaint paint;
paint.setDither(true);
paint.setFilterBitmap(true);
-
+
for (int i = 0; i < SK_ARRAY_COUNT(fRecs); i++) {
canvas->save();
-
+
paint.setShader(NULL);
canvas->drawVertices(fRecs[i].fMode, fRecs[i].fCount,
fRecs[i].fVerts, fRecs[i].fTexs,
NULL, NULL, NULL, 0, paint);
-
+
canvas->translate(SkIntToScalar(250), 0);
-
+
paint.setShader(fShader0);
canvas->drawVertices(fRecs[i].fMode, fRecs[i].fCount,
fRecs[i].fVerts, fRecs[i].fTexs,
NULL, NULL, NULL, 0, paint);
canvas->translate(SkIntToScalar(250), 0);
-
+
paint.setShader(fShader1);
canvas->drawVertices(fRecs[i].fMode, fRecs[i].fCount,
fRecs[i].fVerts, fRecs[i].fTexs,
NULL, NULL, NULL, 0, paint);
canvas->restore();
-
+
canvas->translate(0, SkIntToScalar(250));
}
}
-
+
virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
return new Click(this);
}
-
+
virtual bool onClick(Click* click) {
// fCurrX = click->fICurr.fX;
// fCurrY = click->fICurr.fY;
this->inval(NULL);
return true;
}
-
+
private:
struct Rec {
SkCanvas::VertexMode fMode;
int fCount;
SkPoint* fVerts;
SkPoint* fTexs;
-
+
Rec() : fCount(0), fVerts(NULL), fTexs(NULL) {}
~Rec() { delete[] fVerts; delete[] fTexs; }
};
@@ -135,11 +135,11 @@
void make_tris(Rec* rec) {
int n = 10;
SkRandom rand;
-
+
rec->fMode = SkCanvas::kTriangles_VertexMode;
rec->fCount = n * 3;
rec->fVerts = new SkPoint[rec->fCount];
-
+
for (int i = 0; i < n; i++) {
SkPoint* v = &rec->fVerts[i*3];
for (int j = 0; j < 3; j++) {
@@ -147,17 +147,17 @@
}
}
}
-
+
void make_fan(Rec* rec, int texWidth, int texHeight) {
const SkScalar tx = SkIntToScalar(texWidth);
const SkScalar ty = SkIntToScalar(texHeight);
const int n = 24;
-
+
rec->fMode = SkCanvas::kTriangleFan_VertexMode;
rec->fCount = n + 2;
rec->fVerts = new SkPoint[rec->fCount];
rec->fTexs = new SkPoint[rec->fCount];
-
+
SkPoint* v = rec->fVerts;
SkPoint* t = rec->fTexs;
@@ -171,47 +171,47 @@
}
v[n+1] = v[1];
t[n+1].set(tx, ty);
-
+
SkMatrix m;
m.setScale(SkIntToScalar(100), SkIntToScalar(100));
m.postTranslate(SkIntToScalar(110), SkIntToScalar(110));
m.mapPoints(v, rec->fCount);
}
-
+
void make_strip(Rec* rec, int texWidth, int texHeight) {
const SkScalar tx = SkIntToScalar(texWidth);
const SkScalar ty = SkIntToScalar(texHeight);
const int n = 24;
-
+
rec->fMode = SkCanvas::kTriangleStrip_VertexMode;
rec->fCount = 2 * (n + 1);
rec->fVerts = new SkPoint[rec->fCount];
rec->fTexs = new SkPoint[rec->fCount];
-
+
SkPoint* v = rec->fVerts;
SkPoint* t = rec->fTexs;
-
+
for (int i = 0; i < n; i++) {
SkScalar cos;
SkScalar sin = SkScalarSinCos(SK_ScalarPI * 2 * i / n, &cos);
v[i*2 + 0].set(cos/2, sin/2);
v[i*2 + 1].set(cos, sin);
-
+
t[i*2 + 0].set(tx * i / n, ty);
t[i*2 + 1].set(tx * i / n, 0);
}
v[2*n + 0] = v[0];
v[2*n + 1] = v[1];
-
+
t[2*n + 0].set(tx, ty);
t[2*n + 1].set(tx, 0);
-
+
SkMatrix m;
m.setScale(SkIntToScalar(100), SkIntToScalar(100));
m.postTranslate(SkIntToScalar(110), SkIntToScalar(110));
m.mapPoints(v, rec->fCount);
}
-
+
Rec fRecs[3];
typedef SkView INHERITED;
diff --git a/src/animator/SkDrawExtraPathEffect.cpp b/src/animator/SkDrawExtraPathEffect.cpp
index 4cca738..76b55c6 100644
--- a/src/animator/SkDrawExtraPathEffect.cpp
+++ b/src/animator/SkDrawExtraPathEffect.cpp
@@ -2,16 +2,16 @@
**
** Copyright 2006, The Android Open Source Project
**
-** Licensed under the Apache License, Version 2.0 (the "License");
-** you may not use this file except in compliance with the License.
-** You may obtain a copy of the License at
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
**
-** http://www.apache.org/licenses/LICENSE-2.0
+** http://www.apache.org/licenses/LICENSE-2.0
**
-** Unless required by applicable law or agreed to in writing, software
-** distributed under the License is distributed on an "AS IS" BASIS,
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-** See the License for the specific language governing permissions and
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
** limitations under the License.
*/
@@ -70,7 +70,7 @@
virtual ~SkDrawComposePathEffect();
virtual bool add(SkAnimateMaker& , SkDisplayable* );
virtual SkPathEffect* getPathEffect();
- virtual bool isPaint() const;
+ virtual bool isPaint() const;
private:
SkDrawPathEffect* effect1;
SkDrawPathEffect* effect2;
@@ -127,7 +127,7 @@
m.reset();
if (fDraw->addMatrix) {
SkDrawMatrix* matrix;
- if (fDraw->addMatrix->getType() == SkType_Matrix)
+ if (fDraw->addMatrix->getType() == SkType_Matrix)
matrix = (SkDrawMatrix*) fDraw->addMatrix;
else {
SkApply* apply = (SkApply*) fDraw->addMatrix;
@@ -185,12 +185,12 @@
DEFINE_GET_MEMBER(SkDrawShapePathEffect);
-SkDrawShapePathEffect::SkDrawShapePathEffect() :
+SkDrawShapePathEffect::SkDrawShapePathEffect() :
addPath(NULL), addMatrix(NULL), path(NULL), fPathEffect(NULL) {
}
SkDrawShapePathEffect::~SkDrawShapePathEffect() {
- fPathEffect->safeUnref();
+ SkSafeUnref(fPathEffect);
}
bool SkDrawShapePathEffect::add(SkAnimateMaker& , SkDisplayable* child) {
@@ -234,7 +234,7 @@
class SkShape2DPathEffect : public Sk2DPathEffect {
public:
- SkShape2DPathEffect(SkDrawShape2DPathEffect* draw, SkAnimateMaker* maker,
+ SkShape2DPathEffect(SkDrawShape2DPathEffect* draw, SkAnimateMaker* maker,
const SkMatrix& matrix) : Sk2DPathEffect(matrix), fDraw(draw), fMaker(maker) {
}
@@ -265,7 +265,7 @@
goto clearCallBack;
if (fDraw->matrix) {
SkDrawMatrix* matrix;
- if (fDraw->matrix->getType() == SkType_Matrix)
+ if (fDraw->matrix->getType() == SkType_Matrix)
matrix = (SkDrawMatrix*) fDraw->matrix;
else {
SkApply* apply = (SkApply*) fDraw->matrix;
@@ -301,7 +301,7 @@
}
return true;
}
-
+
SkPoint fLoc;
SkRect fUVBounds;
int32_t fU;
@@ -418,13 +418,13 @@
class SkExtraPathEffects : public SkExtras {
public:
- SkExtraPathEffects(SkAnimator* animator) :
+ SkExtraPathEffects(SkAnimator* animator) :
skDrawShape1DPathEffectType(SkType_Unknown),
skDrawShape2DPathEffectType(SkType_Unknown),
skDrawComposePathEffectType(SkType_Unknown),
skDrawCornerPathEffectType(SkType_Unknown) {
}
-
+
virtual SkDisplayable* createInstance(SkDisplayTypes type) {
SkDisplayable* result = NULL;
if (skDrawShape1DPathEffectType == type)
@@ -439,8 +439,8 @@
}
virtual bool definesType(SkDisplayTypes type) {
- return type == skDrawShape1DPathEffectType ||
- type == skDrawShape2DPathEffectType ||
+ return type == skDrawShape1DPathEffectType ||
+ type == skDrawShape2DPathEffectType ||
type == skDrawComposePathEffectType ||
type == skDrawCornerPathEffectType;
}
diff --git a/src/animator/SkDrawPaint.cpp b/src/animator/SkDrawPaint.cpp
index 0c23771..f21a15a 100644
--- a/src/animator/SkDrawPaint.cpp
+++ b/src/animator/SkDrawPaint.cpp
@@ -2,16 +2,16 @@
**
** Copyright 2006, The Android Open Source Project
**
-** Licensed under the Apache License, Version 2.0 (the "License");
-** you may not use this file except in compliance with the License.
-** You may obtain a copy of the License at
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
**
-** http://www.apache.org/licenses/LICENSE-2.0
+** http://www.apache.org/licenses/LICENSE-2.0
**
-** Unless required by applicable law or agreed to in writing, software
-** distributed under the License is distributed on an "AS IS" BASIS,
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-** See the License for the specific language governing permissions and
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
** limitations under the License.
*/
@@ -77,11 +77,11 @@
SkDrawPaint::SkDrawPaint() : antiAlias(-1), color(NULL), fakeBold(-1), filterBitmap(-1),
linearText(-1), maskFilter((SkDrawMaskFilter*) -1), pathEffect((SkDrawPathEffect*) -1),
shader((SkDrawShader*) -1), strikeThru(-1), stroke(-1),
- strokeCap((SkPaint::Cap) -1), strokeJoin((SkPaint::Join) -1), strokeMiter(SK_ScalarNaN),
+ strokeCap((SkPaint::Cap) -1), strokeJoin((SkPaint::Join) -1), strokeMiter(SK_ScalarNaN),
strokeWidth(SK_ScalarNaN), style((SkPaint::Style) -1),
- textAlign((SkPaint::Align) -1), textScaleX(SK_ScalarNaN), textSize(SK_ScalarNaN),
+ textAlign((SkPaint::Align) -1), textScaleX(SK_ScalarNaN), textSize(SK_ScalarNaN),
textSkewX(SK_ScalarNaN), typeface((SkDrawTypeface*) -1),
- underline(-1), xfermode((SkXfermode::Mode) -1), fOwnsColor(false), fOwnsMaskFilter(false),
+ underline(-1), xfermode((SkXfermode::Mode) -1), fOwnsColor(false), fOwnsMaskFilter(false),
fOwnsPathEffect(false), fOwnsShader(false), fOwnsTypeface(false) {
}
@@ -102,7 +102,7 @@
SkASSERT(child && child->isPaintPart());
SkPaintPart* part = (SkPaintPart*) child;
if (part->add())
- maker.setErrorCode(SkDisplayXMLParserError::kErrorAddingToPaint);
+ maker.setErrorCode(SkDisplayXMLParserError::kErrorAddingToPaint);
return true;
}
@@ -154,8 +154,8 @@
dumpChildren(maker, closedYet);
}
#endif
-
-void SkDrawPaint::executeFunction(SkDisplayable* target, int index,
+
+void SkDrawPaint::executeFunction(SkDisplayable* target, int index,
SkTDArray<SkScriptValue>& parameters, SkDisplayTypes type,
SkScriptValue* scriptValue) {
if (scriptValue == NULL)
@@ -169,9 +169,9 @@
setupPaint(&paint);
scriptValue->fType = SkType_Float;
SkASSERT(parameters[0].fType == SkType_String);
- scriptValue->fOperand.fScalar = paint.measureText(parameters[0].fOperand.fString->c_str(),
- parameters[0].fOperand.fString->size());
-// SkDebugf("measureText: %s = %g\n", parameters[0].fOperand.fString->c_str(),
+ scriptValue->fOperand.fScalar = paint.measureText(parameters[0].fOperand.fString->c_str(),
+ parameters[0].fOperand.fString->size());
+// SkDebugf("measureText: %s = %g\n", parameters[0].fOperand.fString->c_str(),
// scriptValue->fOperand.fScalar / 65536.0f);
} break;
default:
@@ -195,7 +195,7 @@
case SK_PROPERTY(descent):
value->fOperand.fScalar = metrics.fDescent;
break;
- // should consider returning fLeading as well (or roll it into ascent/descent somehow
+ // should consider returning fLeading as well (or roll it into ascent/descent somehow
default:
SkASSERT(0);
return false;
@@ -217,7 +217,7 @@
return true;
if (fOwnsTypeface && maker.resolveID(typeface, original->typeface) == false)
return true;
- return false; // succeeded
+ return false; // succeeded
}
void SkDrawPaint::setupPaint(SkPaint* paint) const {
@@ -239,15 +239,15 @@
if (maskFilter == NULL)
paint->setMaskFilter(NULL);
else if (maskFilter != (SkDrawMaskFilter*) -1)
- paint->setMaskFilter(maskFilter->getMaskFilter())->safeUnref();
+ SkSafeUnref(paint->setMaskFilter(maskFilter->getMaskFilter()));
if (pathEffect == NULL)
paint->setPathEffect(NULL);
else if (pathEffect != (SkDrawPathEffect*) -1)
- paint->setPathEffect(pathEffect->getPathEffect())->safeUnref();
+ SkSafeUnref(paint->setPathEffect(pathEffect->getPathEffect()));
if (shader == NULL)
paint->setShader(NULL);
else if (shader != (SkDrawShader*) -1)
- paint->setShader(shader->getShader())->safeUnref();
+ SkSafeUnref(paint->setShader(shader->getShader()));
if (strikeThru != -1)
paint->setStrikeThruText(SkToBool(strikeThru));
if (strokeCap != (SkPaint::Cap) -1)
@@ -269,7 +269,7 @@
if (typeface == NULL)
paint->setTypeface(NULL);
else if (typeface != (SkDrawTypeface*) -1)
- paint->setTypeface(typeface->getTypeface())->safeUnref();
+ SkSafeUnref(paint->setTypeface(typeface->getTypeface()));
if (underline != -1)
paint->setUnderlineText(SkToBool(underline));
if (xfermode != (SkXfermode::Mode) -1)
diff --git a/src/core/SkBitmap.cpp b/src/core/SkBitmap.cpp
index 8266dfe..3e26639 100644
--- a/src/core/SkBitmap.cpp
+++ b/src/core/SkBitmap.cpp
@@ -116,7 +116,7 @@
*/
if (NULL == fPixelRef) {
// leave fPixels as it is
- fColorTable->safeRef(); // ref the user's ctable if present
+ SkSafeRef(fColorTable); // ref the user's ctable if present
} else { // we have a pixelref, so pixels/ctable reflect it
// ignore the values from the memcpy
fPixels = NULL;
@@ -311,7 +311,7 @@
this->freePixels();
SkASSERT(NULL == fPixelRef);
- pr->safeRef();
+ SkSafeRef(pr);
fPixelRef = pr;
}
fPixelRefOffset = offset;
@@ -1135,7 +1135,7 @@
}
return false;
}
-
+
if (SkBitmap::kA8_Config == config && !src.isOpaque()) {
const uint8_t* s = src.getAddr8(0, 0);
while (--h >= 0) {
@@ -1351,7 +1351,7 @@
size_t offset = buffer.readU32();
SkPixelRef::Factory fact = deserialize_factory(buffer);
SkPixelRef* pr = fact(buffer);
- this->setPixelRef(pr, offset)->safeUnref();
+ SkSafeUnref(this->setPixelRef(pr, offset));
break;
}
case SERIALIZE_PIXELTYPE_RAW_WITH_CTABLE:
diff --git a/src/core/SkBlitter.cpp b/src/core/SkBlitter.cpp
index 930f9bf..cd3cb1b 100644
--- a/src/core/SkBlitter.cpp
+++ b/src/core/SkBlitter.cpp
@@ -2,16 +2,16 @@
**
** Copyright 2006, The Android Open Source Project
**
-** Licensed under the Apache License, Version 2.0 (the "License");
-** you may not use this file except in compliance with the License.
-** You may obtain a copy of the License at
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
**
-** http://www.apache.org/licenses/LICENSE-2.0
+** http://www.apache.org/licenses/LICENSE-2.0
**
-** Unless required by applicable law or agreed to in writing, software
-** distributed under the License is distributed on an "AS IS" BASIS,
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-** See the License for the specific language governing permissions and
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
** limitations under the License.
*/
@@ -27,70 +27,62 @@
SkBlitter::~SkBlitter() {}
-const SkBitmap* SkBlitter::justAnOpaqueColor(uint32_t* value)
-{
+const SkBitmap* SkBlitter::justAnOpaqueColor(uint32_t* value) {
return NULL;
}
-void SkBlitter::blitH(int x, int y, int width)
-{
+void SkBlitter::blitH(int x, int y, int width) {
SkASSERT(!"unimplemented");
}
-void SkBlitter::blitAntiH(int x, int y, const SkAlpha antialias[], const int16_t runs[])
-{
+void SkBlitter::blitAntiH(int x, int y, const SkAlpha antialias[],
+ const int16_t runs[]) {
SkASSERT(!"unimplemented");
}
-void SkBlitter::blitV(int x, int y, int height, SkAlpha alpha)
-{
- if (alpha == 255)
+void SkBlitter::blitV(int x, int y, int height, SkAlpha alpha) {
+ if (alpha == 255) {
this->blitRect(x, y, 1, height);
- else
- {
+ } else {
int16_t runs[2];
runs[0] = 1;
runs[1] = 0;
- while (--height >= 0)
+ while (--height >= 0) {
this->blitAntiH(x, y++, &alpha, runs);
+ }
}
}
-void SkBlitter::blitRect(int x, int y, int width, int height)
-{
- while (--height >= 0)
+void SkBlitter::blitRect(int x, int y, int width, int height) {
+ while (--height >= 0) {
this->blitH(x, y++, width);
+ }
}
//////////////////////////////////////////////////////////////////////////////
-static inline void bits_to_runs(SkBlitter* blitter, int x, int y, const uint8_t bits[],
- U8CPU left_mask, int rowBytes, U8CPU right_mask)
-{
+static inline void bits_to_runs(SkBlitter* blitter, int x, int y,
+ const uint8_t bits[],
+ U8CPU left_mask, int rowBytes,
+ U8CPU right_mask) {
int inFill = 0;
int pos = 0;
- while (--rowBytes >= 0)
- {
+ while (--rowBytes >= 0) {
unsigned b = *bits++ & left_mask;
- if (rowBytes == 0)
+ if (rowBytes == 0) {
b &= right_mask;
+ }
- for (unsigned test = 0x80; test != 0; test >>= 1)
- {
- if (b & test)
- {
- if (!inFill)
- {
+ for (unsigned test = 0x80; test != 0; test >>= 1) {
+ if (b & test) {
+ if (!inFill) {
pos = x;
inFill = true;
}
- }
- else
- {
- if (inFill)
- {
+ } else {
+ if (inFill) {
blitter->blitH(pos, y, x - pos);
inFill = false;
}
@@ -101,16 +93,15 @@
}
// final cleanup
- if (inFill)
+ if (inFill) {
blitter->blitH(pos, y, x - pos);
+ }
}
-void SkBlitter::blitMask(const SkMask& mask, const SkIRect& clip)
-{
+void SkBlitter::blitMask(const SkMask& mask, const SkIRect& clip) {
SkASSERT(mask.fBounds.contains(clip));
- if (mask.fFormat == SkMask::kBW_Format)
- {
+ if (mask.fFormat == SkMask::kBW_Format) {
int cx = clip.fLeft;
int cy = clip.fTop;
int maskLeft = mask.fBounds.fLeft;
@@ -119,17 +110,13 @@
const uint8_t* bits = mask.getAddr1(cx, cy);
- if (cx == maskLeft && clip.fRight == mask.fBounds.fRight)
- {
- while (--height >= 0)
- {
+ if (cx == maskLeft && clip.fRight == mask.fBounds.fRight) {
+ while (--height >= 0) {
bits_to_runs(this, cx, cy, bits, 0xFF, mask_rowBytes, 0xFF);
bits += mask_rowBytes;
cy += 1;
}
- }
- else
- {
+ } else {
int left_edge = cx - maskLeft;
SkASSERT(left_edge >= 0);
int rite_edge = clip.fRight - maskLeft;
@@ -140,42 +127,35 @@
int full_runs = (rite_edge >> 3) - ((left_edge + 7) >> 3);
// check for empty right mask, so we don't read off the end (or go slower than we need to)
- if (rite_mask == 0)
- {
+ if (rite_mask == 0) {
SkASSERT(full_runs >= 0);
full_runs -= 1;
rite_mask = 0xFF;
}
- if (left_mask == 0xFF)
+ if (left_mask == 0xFF) {
full_runs -= 1;
+ }
// back up manually so we can keep in sync with our byte-aligned src
// have cx reflect our actual starting x-coord
cx -= left_edge & 7;
- if (full_runs < 0)
- {
+ if (full_runs < 0) {
SkASSERT((left_mask & rite_mask) != 0);
- while (--height >= 0)
- {
+ while (--height >= 0) {
bits_to_runs(this, cx, cy, bits, left_mask, 1, rite_mask);
bits += mask_rowBytes;
cy += 1;
}
- }
- else
- {
- while (--height >= 0)
- {
+ } else {
+ while (--height >= 0) {
bits_to_runs(this, cx, cy, bits, left_mask, full_runs + 2, rite_mask);
bits += mask_rowBytes;
cy += 1;
}
}
}
- }
- else
- {
+ } else {
int width = clip.width();
SkAutoSTMalloc<64, int16_t> runStorage(width + 1);
int16_t* runs = runStorage.get();
@@ -186,8 +166,7 @@
int height = clip.height();
int y = clip.fTop;
- while (--height >= 0)
- {
+ while (--height >= 0) {
this->blitAntiH(clip.fLeft, y, aa, runs);
aa += mask.fRowBytes;
y += 1;
@@ -201,9 +180,9 @@
if (clip.quickReject(mask.fBounds)) {
return;
}
-
+
SkRegion::Cliperator clipper(clip, mask.fBounds);
-
+
while (!clipper.done()) {
const SkIRect& cr = clipper.rect();
this->blitMask(mask, cr);
@@ -213,7 +192,7 @@
void SkBlitter::blitRectRegion(const SkIRect& rect, const SkRegion& clip) {
SkRegion::Cliperator clipper(clip, rect);
-
+
while (!clipper.done()) {
const SkIRect& cr = clipper.rect();
this->blitRect(cr.fLeft, cr.fTop, cr.width(), cr.height());
@@ -223,7 +202,7 @@
void SkBlitter::blitRegion(const SkRegion& clip) {
SkRegion::Iterator iter(clip);
-
+
while (!iter.done()) {
const SkIRect& cr = iter.rect();
this->blitRect(cr.fLeft, cr.fTop, cr.width(), cr.height());
@@ -231,99 +210,88 @@
}
}
-///////////////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
-void SkNullBlitter::blitH(int x, int y, int width)
-{
-}
+void SkNullBlitter::blitH(int x, int y, int width) {}
-void SkNullBlitter::blitAntiH(int x, int y, const SkAlpha antialias[], const int16_t runs[])
-{
-}
+void SkNullBlitter::blitAntiH(int x, int y, const SkAlpha antialias[],
+ const int16_t runs[]) {}
-void SkNullBlitter::blitV(int x, int y, int height, SkAlpha alpha)
-{
-}
+void SkNullBlitter::blitV(int x, int y, int height, SkAlpha alpha) {}
-void SkNullBlitter::blitRect(int x, int y, int width, int height)
-{
-}
+void SkNullBlitter::blitRect(int x, int y, int width, int height) {}
-void SkNullBlitter::blitMask(const SkMask& mask, const SkIRect& clip)
-{
-}
+void SkNullBlitter::blitMask(const SkMask& mask, const SkIRect& clip) {}
-const SkBitmap* SkNullBlitter::justAnOpaqueColor(uint32_t* value)
-{
+const SkBitmap* SkNullBlitter::justAnOpaqueColor(uint32_t* value) {
return NULL;
}
-///////////////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
-static int compute_anti_width(const int16_t runs[])
-{
+static int compute_anti_width(const int16_t runs[]) {
int width = 0;
-
- for (;;)
- {
+
+ for (;;) {
int count = runs[0];
-
+
SkASSERT(count >= 0);
- if (count == 0)
+ if (count == 0) {
break;
+ }
width += count;
runs += count;
-
+
SkASSERT(width < 20000);
}
return width;
}
-static inline bool y_in_rect(int y, const SkIRect& rect)
-{
+static inline bool y_in_rect(int y, const SkIRect& rect) {
return (unsigned)(y - rect.fTop) < (unsigned)rect.height();
}
-static inline bool x_in_rect(int x, const SkIRect& rect)
-{
+static inline bool x_in_rect(int x, const SkIRect& rect) {
return (unsigned)(x - rect.fLeft) < (unsigned)rect.width();
}
-void SkRectClipBlitter::blitH(int left, int y, int width)
-{
+void SkRectClipBlitter::blitH(int left, int y, int width) {
SkASSERT(width > 0);
- if (!y_in_rect(y, fClipRect))
+ if (!y_in_rect(y, fClipRect)) {
return;
+ }
int right = left + width;
- if (left < fClipRect.fLeft)
+ if (left < fClipRect.fLeft) {
left = fClipRect.fLeft;
- if (right > fClipRect.fRight)
+ }
+ if (right > fClipRect.fRight) {
right = fClipRect.fRight;
+ }
width = right - left;
- if (width > 0)
+ if (width > 0) {
fBlitter->blitH(left, y, width);
+ }
}
-void SkRectClipBlitter::blitAntiH(int left, int y, const SkAlpha aa[], const int16_t runs[])
-{
- if (!y_in_rect(y, fClipRect) || left >= fClipRect.fRight)
+void SkRectClipBlitter::blitAntiH(int left, int y, const SkAlpha aa[],
+ const int16_t runs[]) {
+ if (!y_in_rect(y, fClipRect) || left >= fClipRect.fRight) {
return;
+ }
int x0 = left;
int x1 = left + compute_anti_width(runs);
- if (x1 <= fClipRect.fLeft)
+ if (x1 <= fClipRect.fLeft) {
return;
+ }
SkASSERT(x0 < x1);
- if (x0 < fClipRect.fLeft)
- {
+ if (x0 < fClipRect.fLeft) {
int dx = fClipRect.fLeft - x0;
SkAlphaRuns::BreakAt((int16_t*)runs, (uint8_t*)aa, dx);
runs += dx;
@@ -332,8 +300,7 @@
}
SkASSERT(x0 < x1 && runs[x1 - x0] == 0);
- if (x1 > fClipRect.fRight)
- {
+ if (x1 > fClipRect.fRight) {
x1 = fClipRect.fRight;
SkAlphaRuns::BreakAt((int16_t*)runs, (uint8_t*)aa, x1 - x0);
((int16_t*)runs)[x1 - x0] = 0;
@@ -345,95 +312,91 @@
fBlitter->blitAntiH(x0, y, aa, runs);
}
-void SkRectClipBlitter::blitV(int x, int y, int height, SkAlpha alpha)
-{
+void SkRectClipBlitter::blitV(int x, int y, int height, SkAlpha alpha) {
SkASSERT(height > 0);
- if (!x_in_rect(x, fClipRect))
+ if (!x_in_rect(x, fClipRect)) {
return;
+ }
int y0 = y;
int y1 = y + height;
- if (y0 < fClipRect.fTop)
+ if (y0 < fClipRect.fTop) {
y0 = fClipRect.fTop;
- if (y1 > fClipRect.fBottom)
+ }
+ if (y1 > fClipRect.fBottom) {
y1 = fClipRect.fBottom;
+ }
- if (y0 < y1)
+ if (y0 < y1) {
fBlitter->blitV(x, y0, y1 - y0, alpha);
+ }
}
-void SkRectClipBlitter::blitRect(int left, int y, int width, int height)
-{
+void SkRectClipBlitter::blitRect(int left, int y, int width, int height) {
SkIRect r;
r.set(left, y, left + width, y + height);
- if (r.intersect(fClipRect))
+ if (r.intersect(fClipRect)) {
fBlitter->blitRect(r.fLeft, r.fTop, r.width(), r.height());
+ }
}
-void SkRectClipBlitter::blitMask(const SkMask& mask, const SkIRect& clip)
-{
+void SkRectClipBlitter::blitMask(const SkMask& mask, const SkIRect& clip) {
SkASSERT(mask.fBounds.contains(clip));
SkIRect r = clip;
- if (r.intersect(fClipRect))
+ if (r.intersect(fClipRect)) {
fBlitter->blitMask(mask, r);
+ }
}
-const SkBitmap* SkRectClipBlitter::justAnOpaqueColor(uint32_t* value)
-{
+const SkBitmap* SkRectClipBlitter::justAnOpaqueColor(uint32_t* value) {
return fBlitter->justAnOpaqueColor(value);
}
-///////////////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
-void SkRgnClipBlitter::blitH(int x, int y, int width)
-{
+void SkRgnClipBlitter::blitH(int x, int y, int width) {
SkRegion::Spanerator span(*fRgn, y, x, x + width);
int left, right;
- while (span.next(&left, &right))
- {
+ while (span.next(&left, &right)) {
SkASSERT(left < right);
fBlitter->blitH(left, y, right - left);
}
}
-void SkRgnClipBlitter::blitAntiH(int x, int y, const SkAlpha aa[], const int16_t runs[])
-{
+void SkRgnClipBlitter::blitAntiH(int x, int y, const SkAlpha aa[],
+ const int16_t runs[]) {
int width = compute_anti_width(runs);
SkRegion::Spanerator span(*fRgn, y, x, x + width);
int left, right;
SkDEBUGCODE(const SkIRect& bounds = fRgn->getBounds();)
-
+
int prevRite = x;
- while (span.next(&left, &right))
- {
+ while (span.next(&left, &right)) {
SkASSERT(x <= left);
SkASSERT(left < right);
SkASSERT(left >= bounds.fLeft && right <= bounds.fRight);
-
+
SkAlphaRuns::Break((int16_t*)runs, (uint8_t*)aa, left - x, right - left);
// now zero before left
- if (left > prevRite)
- {
+ if (left > prevRite) {
int index = prevRite - x;
((uint8_t*)aa)[index] = 0; // skip runs after right
((int16_t*)runs)[index] = SkToS16(left - prevRite);
}
-
+
prevRite = right;
}
-
- if (prevRite > x)
- {
+
+ if (prevRite > x) {
((int16_t*)runs)[prevRite - x] = 0;
-
+
if (x < 0) {
int skip = runs[0];
SkASSERT(skip >= -x);
@@ -445,15 +408,13 @@
}
}
-void SkRgnClipBlitter::blitV(int x, int y, int height, SkAlpha alpha)
-{
+void SkRgnClipBlitter::blitV(int x, int y, int height, SkAlpha alpha) {
SkIRect bounds;
bounds.set(x, y, x + 1, y + height);
SkRegion::Cliperator iter(*fRgn, bounds);
- while (!iter.done())
- {
+ while (!iter.done()) {
const SkIRect& r = iter.rect();
SkASSERT(bounds.contains(r));
@@ -462,15 +423,13 @@
}
}
-void SkRgnClipBlitter::blitRect(int x, int y, int width, int height)
-{
+void SkRgnClipBlitter::blitRect(int x, int y, int width, int height) {
SkIRect bounds;
bounds.set(x, y, x + width, y + height);
SkRegion::Cliperator iter(*fRgn, bounds);
- while (!iter.done())
- {
+ while (!iter.done()) {
const SkIRect& r = iter.rect();
SkASSERT(bounds.contains(r));
@@ -479,47 +438,38 @@
}
}
-void SkRgnClipBlitter::blitMask(const SkMask& mask, const SkIRect& clip)
-{
+void SkRgnClipBlitter::blitMask(const SkMask& mask, const SkIRect& clip) {
SkASSERT(mask.fBounds.contains(clip));
SkRegion::Cliperator iter(*fRgn, clip);
const SkIRect& r = iter.rect();
SkBlitter* blitter = fBlitter;
- while (!iter.done())
- {
+ while (!iter.done()) {
blitter->blitMask(mask, r);
iter.next();
}
}
-const SkBitmap* SkRgnClipBlitter::justAnOpaqueColor(uint32_t* value)
-{
+const SkBitmap* SkRgnClipBlitter::justAnOpaqueColor(uint32_t* value) {
return fBlitter->justAnOpaqueColor(value);
}
-///////////////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
-SkBlitter* SkBlitterClipper::apply(SkBlitter* blitter, const SkRegion* clip, const SkIRect* ir)
-{
- if (clip)
- {
+SkBlitter* SkBlitterClipper::apply(SkBlitter* blitter, const SkRegion* clip,
+ const SkIRect* ir) {
+ if (clip) {
const SkIRect& clipR = clip->getBounds();
- if (clip->isEmpty() || (ir && !SkIRect::Intersects(clipR, *ir)))
+ if (clip->isEmpty() || (ir && !SkIRect::Intersects(clipR, *ir))) {
blitter = &fNullBlitter;
- else if (clip->isRect())
- {
- if (ir == NULL || !clipR.contains(*ir))
- {
+ } else if (clip->isRect()) {
+ if (ir == NULL || !clipR.contains(*ir)) {
fRectBlitter.init(blitter, clipR);
blitter = &fRectBlitter;
}
- }
- else
- {
+ } else {
fRgnBlitter.init(blitter, clip);
blitter = &fRgnBlitter;
}
@@ -527,44 +477,43 @@
return blitter;
}
-///////////////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
#include "SkColorShader.h"
#include "SkColorPriv.h"
class Sk3DShader : public SkShader {
public:
- Sk3DShader(SkShader* proxy) : fProxy(proxy)
- {
- proxy->safeRef();
+ Sk3DShader(SkShader* proxy) : fProxy(proxy) {
+ SkSafeRef(proxy);
fMask = NULL;
}
- virtual ~Sk3DShader()
- {
- fProxy->safeUnref();
+
+ virtual ~Sk3DShader() {
+ SkSafeUnref(fProxy);
}
+
void setMask(const SkMask* mask) { fMask = mask; }
- virtual bool setContext(const SkBitmap& device, const SkPaint& paint, const SkMatrix& matrix)
- {
- if (fProxy)
+ virtual bool setContext(const SkBitmap& device, const SkPaint& paint,
+ const SkMatrix& matrix) {
+ if (fProxy) {
return fProxy->setContext(device, paint, matrix);
- else
- {
+ } else {
fPMColor = SkPreMultiplyColor(paint.getColor());
return this->INHERITED::setContext(device, paint, matrix);
}
}
- virtual void shadeSpan(int x, int y, SkPMColor span[], int count)
- {
- if (fProxy)
- fProxy->shadeSpan(x, y, span, count);
- if (fMask == NULL)
- {
- if (fProxy == NULL)
+ virtual void shadeSpan(int x, int y, SkPMColor span[], int count) {
+ if (fProxy) {
+ fProxy->shadeSpan(x, y, span, count);
+ }
+
+ if (fMask == NULL) {
+ if (fProxy == NULL) {
sk_memset32(span, fPMColor, count);
+ }
return;
}
@@ -576,15 +525,11 @@
const uint8_t* mulp = alpha + size;
const uint8_t* addp = mulp + size;
- if (fProxy)
- {
- for (int i = 0; i < count; i++)
- {
- if (alpha[i])
- {
+ if (fProxy) {
+ for (int i = 0; i < count; i++) {
+ if (alpha[i]) {
SkPMColor c = span[i];
- if (c)
- {
+ if (c) {
unsigned a = SkGetPackedA32(c);
unsigned r = SkGetPackedR32(c);
unsigned g = SkGetPackedG32(c);
@@ -599,73 +544,65 @@
span[i] = SkPackARGB32(a, r, g, b);
}
- }
- else
+ } else {
span[i] = 0;
+ }
}
- }
- else // color
- {
+ } else { // color
unsigned a = SkGetPackedA32(fPMColor);
unsigned r = SkGetPackedR32(fPMColor);
unsigned g = SkGetPackedG32(fPMColor);
unsigned b = SkGetPackedB32(fPMColor);
- for (int i = 0; i < count; i++)
- {
- if (alpha[i])
- {
+ for (int i = 0; i < count; i++) {
+ if (alpha[i]) {
unsigned mul = SkAlpha255To256(mulp[i]);
unsigned add = addp[i];
span[i] = SkPackARGB32( a,
- SkFastMin32(SkAlphaMul(r, mul) + add, a),
- SkFastMin32(SkAlphaMul(g, mul) + add, a),
- SkFastMin32(SkAlphaMul(b, mul) + add, a));
- }
- else
+ SkFastMin32(SkAlphaMul(r, mul) + add, a),
+ SkFastMin32(SkAlphaMul(g, mul) + add, a),
+ SkFastMin32(SkAlphaMul(b, mul) + add, a));
+ } else {
span[i] = 0;
+ }
}
}
}
-
- virtual void beginSession()
- {
+
+ virtual void beginSession() {
this->INHERITED::beginSession();
- if (fProxy)
+ if (fProxy) {
fProxy->beginSession();
+ }
}
-
- virtual void endSession()
- {
- if (fProxy)
+
+ virtual void endSession() {
+ if (fProxy) {
fProxy->endSession();
+ }
this->INHERITED::endSession();
}
protected:
Sk3DShader(SkFlattenableReadBuffer& buffer) :
- INHERITED(buffer)
- {
+ INHERITED(buffer) {
fProxy = static_cast<SkShader*>(buffer.readFlattenable());
fPMColor = buffer.readU32();
fMask = NULL;
}
-
- virtual void flatten(SkFlattenableWriteBuffer& buffer)
- {
+
+ virtual void flatten(SkFlattenableWriteBuffer& buffer) {
this->INHERITED::flatten(buffer);
buffer.writeFlattenable(fProxy);
buffer.write32(fPMColor);
}
-
- virtual Factory getFactory()
- {
+
+ virtual Factory getFactory() {
return CreateProc;
}
private:
- static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer)
- {
+ static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) {
return SkNEW_ARGS(Sk3DShader, (buffer));
}
@@ -679,36 +616,34 @@
class Sk3DBlitter : public SkBlitter {
public:
Sk3DBlitter(SkBlitter* proxy, Sk3DShader* shader, void (*killProc)(void*))
- : fProxy(proxy), f3DShader(shader), fKillProc(killProc)
- {
+ : fProxy(proxy), f3DShader(shader), fKillProc(killProc) {
shader->ref();
}
- virtual ~Sk3DBlitter()
- {
+
+ virtual ~Sk3DBlitter() {
f3DShader->unref();
fKillProc(fProxy);
}
- virtual void blitH(int x, int y, int width)
- {
+ virtual void blitH(int x, int y, int width) {
fProxy->blitH(x, y, width);
}
- virtual void blitAntiH(int x, int y, const SkAlpha antialias[], const int16_t runs[])
- {
+
+ virtual void blitAntiH(int x, int y, const SkAlpha antialias[],
+ const int16_t runs[]) {
fProxy->blitAntiH(x, y, antialias, runs);
}
- virtual void blitV(int x, int y, int height, SkAlpha alpha)
- {
+
+ virtual void blitV(int x, int y, int height, SkAlpha alpha) {
fProxy->blitV(x, y, height, alpha);
}
- virtual void blitRect(int x, int y, int width, int height)
- {
+
+ virtual void blitRect(int x, int y, int width, int height) {
fProxy->blitRect(x, y, width, height);
}
- virtual void blitMask(const SkMask& mask, const SkIRect& clip)
- {
- if (mask.fFormat == SkMask::k3D_Format)
- {
+
+ virtual void blitMask(const SkMask& mask, const SkIRect& clip) {
+ if (mask.fFormat == SkMask::k3D_Format) {
f3DShader->setMask(&mask);
((SkMask*)&mask)->fFormat = SkMask::kA8_Format;
@@ -716,18 +651,18 @@
((SkMask*)&mask)->fFormat = SkMask::k3D_Format;
f3DShader->setMask(NULL);
- }
- else
+ } else {
fProxy->blitMask(mask, clip);
+ }
}
+
private:
SkBlitter* fProxy;
Sk3DShader* f3DShader;
void (*fKillProc)(void*);
};
-///////////////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
#include "SkCoreBlitters.h"
@@ -739,6 +674,7 @@
fXfer = fPaint->getXfermode();
SkSafeRef(fXfer);
}
+
~SkAutoRestoreShaderXfer() {
fPaint->setShader(fShader);
SkSafeUnref(fShader);
@@ -763,34 +699,34 @@
class SkAutoCallProc {
public:
typedef void (*Proc)(void*);
+
SkAutoCallProc(void* obj, Proc proc)
- : fObj(obj), fProc(proc)
- {
- }
- ~SkAutoCallProc()
- {
- if (fObj && fProc)
+ : fObj(obj), fProc(proc) {}
+
+ ~SkAutoCallProc() {
+ if (fObj && fProc) {
fProc(fObj);
+ }
}
+
void* get() const { return fObj; }
- void* detach()
- {
+
+ void* detach() {
void* obj = fObj;
fObj = NULL;
return obj;
}
+
private:
void* fObj;
Proc fProc;
};
-static void destroy_blitter(void* blitter)
-{
+static void destroy_blitter(void* blitter) {
((SkBlitter*)blitter)->~SkBlitter();
}
-static void delete_blitter(void* blitter)
-{
+static void delete_blitter(void* blitter) {
SkDELETE((SkBlitter*)blitter);
}
@@ -804,7 +740,7 @@
}
return false;
}
-
+
/** By analyzing the paint (with an xfermode), we may decide we can take
special action. This enum lists our possible actions
*/
@@ -817,7 +753,7 @@
static XferInterp interpret_xfermode(const SkPaint& paint, SkXfermode* xfer,
SkBitmap::Config deviceConfig) {
SkXfermode::Mode mode;
-
+
if (SkXfermode::IsMode(xfer, &mode)) {
switch (mode) {
case SkXfermode::kSrc_Mode:
@@ -855,16 +791,14 @@
SkBlitter* SkBlitter::Choose(const SkBitmap& device,
const SkMatrix& matrix,
const SkPaint& paint,
- void* storage, size_t storageSize)
-{
+ void* storage, size_t storageSize) {
SkASSERT(storageSize == 0 || storage != NULL);
SkBlitter* blitter = NULL;
// which check, in case we're being called by a client with a dummy device
// (e.g. they have a bounder that always aborts the draw)
- if (SkBitmap::kNo_Config == device.getConfig())
- {
+ if (SkBitmap::kNo_Config == device.getConfig()) {
SK_PLACEMENT_NEW(blitter, SkNullBlitter, storage, storageSize);
return blitter;
}
@@ -873,8 +807,8 @@
SkShader* shader = paint.getShader();
Sk3DShader* shader3D = NULL;
- if (paint.getMaskFilter() != NULL && paint.getMaskFilter()->getFormat() == SkMask::k3D_Format)
- {
+ if (paint.getMaskFilter() != NULL &&
+ paint.getMaskFilter()->getFormat() == SkMask::k3D_Format) {
shader3D = SkNEW_ARGS(Sk3DShader, (shader));
restorePaint.setShader(shader3D)->unref();
shader = shader3D;
@@ -900,58 +834,66 @@
shader = SkNEW(SkColorShader);
restorePaint.setShader(shader)->unref();
}
-
- if (paint.getColorFilter() != NULL)
- {
+
+ if (paint.getColorFilter() != NULL) {
SkASSERT(shader);
shader = SkNEW_ARGS(SkFilterShader, (shader, paint.getColorFilter()));
restorePaint.setShader(shader)->unref();
// blitters should ignore the presence/absence of a filter, since
// if there is one, the shader will take care of it.
}
-
+
if (shader && !shader->setContext(device, paint, matrix)) {
return SkNEW(SkNullBlitter);
}
switch (device.getConfig()) {
- case SkBitmap::kA1_Config:
- SK_PLACEMENT_NEW_ARGS(blitter, SkA1_Blitter, storage, storageSize, (device, paint));
- break;
+ case SkBitmap::kA1_Config:
+ SK_PLACEMENT_NEW_ARGS(blitter, SkA1_Blitter,
+ storage, storageSize, (device, paint));
+ break;
- case SkBitmap::kA8_Config:
- if (shader)
- SK_PLACEMENT_NEW_ARGS(blitter, SkA8_Shader_Blitter, storage, storageSize, (device, paint));
- else
- SK_PLACEMENT_NEW_ARGS(blitter, SkA8_Blitter, storage, storageSize, (device, paint));
- break;
-
- case SkBitmap::kARGB_4444_Config:
- blitter = SkBlitter_ChooseD4444(device, paint, storage, storageSize);
- break;
+ case SkBitmap::kA8_Config:
+ if (shader) {
+ SK_PLACEMENT_NEW_ARGS(blitter, SkA8_Shader_Blitter,
+ storage, storageSize, (device, paint));
+ } else {
+ SK_PLACEMENT_NEW_ARGS(blitter, SkA8_Blitter,
+ storage, storageSize, (device, paint));
+ }
+ break;
- case SkBitmap::kRGB_565_Config:
- blitter = SkBlitter_ChooseD565(device, paint, storage, storageSize);
- break;
+ case SkBitmap::kARGB_4444_Config:
+ blitter = SkBlitter_ChooseD4444(device, paint, storage, storageSize);
+ break;
- case SkBitmap::kARGB_8888_Config:
- if (shader)
- SK_PLACEMENT_NEW_ARGS(blitter, SkARGB32_Shader_Blitter, storage, storageSize, (device, paint));
- else if (paint.getColor() == SK_ColorBLACK)
- SK_PLACEMENT_NEW_ARGS(blitter, SkARGB32_Black_Blitter, storage, storageSize, (device, paint));
- else if (paint.getAlpha() == 0xFF)
- SK_PLACEMENT_NEW_ARGS(blitter, SkARGB32_Opaque_Blitter, storage, storageSize, (device, paint));
- else
- SK_PLACEMENT_NEW_ARGS(blitter, SkARGB32_Blitter, storage, storageSize, (device, paint));
- break;
+ case SkBitmap::kRGB_565_Config:
+ blitter = SkBlitter_ChooseD565(device, paint, storage, storageSize);
+ break;
- default:
- SkASSERT(!"unsupported device config");
- SK_PLACEMENT_NEW(blitter, SkNullBlitter, storage, storageSize);
+ case SkBitmap::kARGB_8888_Config:
+ if (shader) {
+ SK_PLACEMENT_NEW_ARGS(blitter, SkARGB32_Shader_Blitter,
+ storage, storageSize, (device, paint));
+ } else if (paint.getColor() == SK_ColorBLACK) {
+ SK_PLACEMENT_NEW_ARGS(blitter, SkARGB32_Black_Blitter,
+ storage, storageSize, (device, paint));
+ } else if (paint.getAlpha() == 0xFF) {
+ SK_PLACEMENT_NEW_ARGS(blitter, SkARGB32_Opaque_Blitter,
+ storage, storageSize, (device, paint));
+ } else {
+ SK_PLACEMENT_NEW_ARGS(blitter, SkARGB32_Blitter,
+ storage, storageSize, (device, paint));
+ }
+ break;
+
+ default:
+ SkASSERT(!"unsupported device config");
+ SK_PLACEMENT_NEW(blitter, SkNullBlitter, storage, storageSize);
+ break;
}
- if (shader3D)
- {
+ if (shader3D) {
void (*proc)(void*) = ((void*)storage == (void*)blitter) ? destroy_blitter : delete_blitter;
SkAutoCallProc tmp(blitter, proc);
@@ -961,12 +903,12 @@
return blitter;
}
-//////////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
const uint16_t gMask_0F0F = 0xF0F;
const uint32_t gMask_00FF00FF = 0xFF00FF;
-//////////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
SkShaderBlitter::SkShaderBlitter(const SkBitmap& device, const SkPaint& paint)
: INHERITED(device) {
diff --git a/src/core/SkBlitter_4444.cpp b/src/core/SkBlitter_4444.cpp
index 81bbc48..e1c519a 100644
--- a/src/core/SkBlitter_4444.cpp
+++ b/src/core/SkBlitter_4444.cpp
@@ -2,16 +2,16 @@
**
** Copyright 2006, The Android Open Source Project
**
- ** Licensed under the Apache License, Version 2.0 (the "License");
- ** you may not use this file except in compliance with the License.
- ** You may obtain a copy of the License at
+ ** Licensed under the Apache License, Version 2.0 (the "License");
+ ** you may not use this file except in compliance with the License.
+ ** You may obtain a copy of the License at
**
- ** http://www.apache.org/licenses/LICENSE-2.0
+ ** http://www.apache.org/licenses/LICENSE-2.0
**
- ** Unless required by applicable law or agreed to in writing, software
- ** distributed under the License is distributed on an "AS IS" BASIS,
- ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- ** See the License for the specific language governing permissions and
+ ** Unless required by applicable law or agreed to in writing, software
+ ** distributed under the License is distributed on an "AS IS" BASIS,
+ ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ** See the License for the specific language governing permissions and
** limitations under the License.
*/
@@ -23,13 +23,13 @@
#include "SkUtils.h"
#include "SkXfermode.h"
-inline SkPMColor SkBlendARGB4444(SkPMColor16 src, SkPMColor16 dst, U8CPU aa)
-{
+static inline SkPMColor SkBlendARGB4444(SkPMColor16 src, SkPMColor16 dst,
+ U8CPU aa) {
SkASSERT((unsigned)aa <= 255);
-
+
unsigned src_scale = SkAlpha255To256(aa) >> 4;
unsigned dst_scale = SkAlpha15To16(15 - SkAlphaMul4(SkGetPackedA4444(src), src_scale));
-
+
uint32_t src32 = SkExpand_4444(src) * src_scale;
uint32_t dst32 = SkExpand_4444(dst) * dst_scale;
return SkCompact_4444((src32 + dst32) >> 4);
@@ -46,16 +46,16 @@
virtual void blitRect(int x, int y, int width, int height);
virtual void blitMask(const SkMask&, const SkIRect&);
virtual const SkBitmap* justAnOpaqueColor(uint32_t*);
-
+
protected:
SkPMColor16 fPMColor16, fPMColor16Other;
SkPMColor16 fRawColor16, fRawColor16Other;
uint8_t fScale16;
-
+
private:
// illegal
SkARGB4444_Blitter& operator=(const SkARGB4444_Blitter&);
-
+
typedef SkRasterBlitter INHERITED;
};
@@ -81,7 +81,7 @@
} else {
fRawColor16Other = fRawColor16;
}
-
+
#if 0 /// don't think this assertion is true, but need it be?
// our dithered color will be the same or more opaque than the original
@@ -146,19 +146,19 @@
void SkARGB4444_Blitter::blitH(int x, int y, int width)
{
SkASSERT(x >= 0 && y >= 0 && x + width <= fDevice.width());
-
+
if (0 == fScale16) {
return;
}
-
+
SkPMColor16* device = fDevice.getAddr16(x, y);
SkPMColor16 color = fPMColor16;
SkPMColor16 other = fPMColor16Other;
-
+
if ((x ^ y) & 1) {
SkTSwap<SkPMColor16>(color, other);
}
-
+
if (16 == fScale16) {
sk_dither_memset16(device, color, other, width);
}
@@ -174,12 +174,12 @@
if (0 == alpha || 0 == fScale16) {
return;
}
-
+
SkPMColor16* device = fDevice.getAddr16(x, y);
SkPMColor16 color = fPMColor16;
SkPMColor16 other = fPMColor16Other;
unsigned rb = fDevice.rowBytes();
-
+
if ((x ^ y) & 1) {
SkTSwap<SkPMColor16>(color, other);
}
@@ -211,19 +211,19 @@
void SkARGB4444_Blitter::blitRect(int x, int y, int width, int height)
{
SkASSERT(x >= 0 && y >= 0 && x + width <= fDevice.width() && y + height <= fDevice.height());
-
+
if (0 == fScale16) {
return;
}
-
+
SkPMColor16* device = fDevice.getAddr16(x, y);
SkPMColor16 color = fPMColor16;
SkPMColor16 other = fPMColor16Other;
-
+
if ((x ^ y) & 1) {
SkTSwap<SkPMColor16>(color, other);
}
-
+
if (16 == fScale16) {
while (--height >= 0) {
sk_dither_memset16(device, color, other, width);
@@ -248,22 +248,22 @@
if (0 == fScale16) {
return;
}
-
+
SkPMColor16* device = fDevice.getAddr16(x, y);
SkPMColor16 color = fPMColor16;
SkPMColor16 other = fPMColor16Other;
-
+
if ((x ^ y) & 1) {
SkTSwap<SkPMColor16>(color, other);
}
-
+
for (;;) {
int count = runs[0];
SkASSERT(count >= 0);
if (count <= 0) {
return;
}
-
+
unsigned aa = antialias[0];
if (aa) {
if (0xFF == aa) {
@@ -338,11 +338,11 @@
void SkARGB4444_Blitter::blitMask(const SkMask& mask, const SkIRect& clip)
{
SkASSERT(mask.fBounds.contains(clip));
-
+
if (0 == fScale16) {
return;
}
-
+
if (mask.fFormat == SkMask::kBW_Format) {
if (16 == fScale16) {
SkARGB4444_BlitBW(fDevice, mask, clip, fPMColor16);
@@ -351,18 +351,18 @@
}
return;
}
-
+
int x = clip.fLeft;
int y = clip.fTop;
int width = clip.width();
int height = clip.height();
-
+
SkPMColor16* device = fDevice.getAddr16(x, y);
const uint8_t* alpha = mask.getAddr(x, y);
SkPMColor16 srcColor = fPMColor16;
unsigned devRB = fDevice.rowBytes() - (width << 1);
unsigned maskRB = mask.fRowBytes - width;
-
+
do {
int w = width;
do {
@@ -384,15 +384,17 @@
SkPMColor* fBuffer;
uint8_t* fAAExpand;
public:
+
SkARGB4444_Shader_Blitter(const SkBitmap& device, const SkPaint& paint)
: INHERITED(device, paint)
{
const int width = device.width();
fBuffer = (SkPMColor*)sk_malloc_throw(width * sizeof(SkPMColor) + width);
fAAExpand = (uint8_t*)(fBuffer + width);
-
- (fXfermode = paint.getXfermode())->safeRef();
-
+
+ fXfermode = paint.getXfermode();
+ SkSafeRef(fXfermode);
+
unsigned flags = 0;
if (!(fShader->getFlags() & SkShader::kOpaqueAlpha_Flag)) {
flags |= SkBlitRow::kSrcPixelAlpha_Flag;
@@ -405,41 +407,39 @@
SkBitmap::kARGB_4444_Config);
}
-virtual ~SkARGB4444_Shader_Blitter()
-{
- fXfermode->safeUnref();
+virtual ~SkARGB4444_Shader_Blitter() {
+ SkSafeUnref(fXfermode);
sk_free(fBuffer);
}
-virtual void blitH(int x, int y, int width)
-{
+virtual void blitH(int x, int y, int width) {
SkASSERT(x >= 0 && y >= 0 && x + width <= fDevice.width());
-
- SkPMColor16* device = fDevice.getAddr16(x, y);
+
+ SkPMColor16* device = fDevice.getAddr16(x, y);
SkPMColor* span = fBuffer;
-
+
fShader->shadeSpan(x, y, span, width);
if (fXfermode) {
fXfermode->xfer4444(device, span, width, NULL);
- }
- else {
+ } else {
fOpaqueProc(device, span, width, 0xFF, x, y);
}
}
-virtual void blitAntiH(int x, int y, const SkAlpha antialias[], const int16_t runs[])
-{
+virtual void blitAntiH(int x, int y, const SkAlpha antialias[],
+ const int16_t runs[]) {
SkPMColor* SK_RESTRICT span = fBuffer;
uint8_t* SK_RESTRICT aaExpand = fAAExpand;
SkPMColor16* device = fDevice.getAddr16(x, y);
SkShader* shader = fShader;
SkXfermode* xfer = fXfermode;
-
+
if (NULL != xfer) {
for (;;) {
int count = *runs;
- if (count <= 0)
+ if (count <= 0) {
break;
+ }
int aa = *antialias;
if (aa) {
shader->shadeSpan(x, y, span, count);
@@ -458,12 +458,13 @@
runs += count;
antialias += count;
x += count;
- }
+ }
} else { // no xfermode
for (;;) {
int count = *runs;
- if (count <= 0)
+ if (count <= 0) {
break;
+ }
int aa = *antialias;
if (aa) {
fShader->shadeSpan(x, y, span, count);
@@ -477,7 +478,7 @@
runs += count;
antialias += count;
x += count;
- }
+ }
}
}
diff --git a/src/core/SkBlitter_A8.cpp b/src/core/SkBlitter_A8.cpp
index 18b0881..f2d73e3 100644
--- a/src/core/SkBlitter_A8.cpp
+++ b/src/core/SkBlitter_A8.cpp
@@ -2,16 +2,16 @@
**
** Copyright 2006, The Android Open Source Project
**
-** Licensed under the Apache License, Version 2.0 (the "License");
-** you may not use this file except in compliance with the License.
-** You may obtain a copy of the License at
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
**
-** http://www.apache.org/licenses/LICENSE-2.0
+** http://www.apache.org/licenses/LICENSE-2.0
**
-** Unless required by applicable law or agreed to in writing, software
-** distributed under the License is distributed on an "AS IS" BASIS,
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-** See the License for the specific language governing permissions and
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
** limitations under the License.
*/
@@ -21,71 +21,64 @@
#include "SkXfermode.h"
SkA8_Blitter::SkA8_Blitter(const SkBitmap& device, const SkPaint& paint)
- : INHERITED(device)
-{
+ : INHERITED(device) {
fSrcA = SkColorGetA(paint.getColor());
}
-const SkBitmap* SkA8_Blitter::justAnOpaqueColor(uint32_t* value)
-{
- if (255 == fSrcA)
- {
+const SkBitmap* SkA8_Blitter::justAnOpaqueColor(uint32_t* value) {
+ if (255 == fSrcA) {
*value = 255;
return &fDevice;
}
return NULL;
}
-void SkA8_Blitter::blitH(int x, int y, int width)
-{
- SkASSERT(x >= 0 && y >= 0 && (unsigned)(x + width) <= (unsigned)fDevice.width());
+void SkA8_Blitter::blitH(int x, int y, int width) {
+ SkASSERT(x >= 0 && y >= 0 &&
+ (unsigned)(x + width) <= (unsigned)fDevice.width());
- if (fSrcA == 0)
+ if (fSrcA == 0) {
return;
+ }
uint8_t* device = fDevice.getAddr8(x, y);
- if (fSrcA == 255)
- {
+ if (fSrcA == 255) {
memset(device, 0xFF, width);
- }
- else
- {
+ } else {
unsigned scale = 256 - SkAlpha255To256(fSrcA);
unsigned srcA = fSrcA;
- for (int i = 0; i < width; i++)
- {
+ for (int i = 0; i < width; i++) {
device[i] = SkToU8(srcA + SkAlphaMul(device[i], scale));
}
}
}
-void SkA8_Blitter::blitAntiH(int x, int y, const SkAlpha antialias[], const int16_t runs[])
-{
- if (fSrcA == 0)
+void SkA8_Blitter::blitAntiH(int x, int y, const SkAlpha antialias[],
+ const int16_t runs[]) {
+ if (fSrcA == 0) {
return;
+ }
uint8_t* device = fDevice.getAddr8(x, y);
unsigned srcA = fSrcA;
- for (;;)
- {
+ for (;;) {
int count = runs[0];
SkASSERT(count >= 0);
- if (count == 0)
+ if (count == 0) {
return;
+ }
unsigned aa = antialias[0];
- if (aa == 255 && srcA == 255)
+ if (aa == 255 && srcA == 255) {
memset(device, 0xFF, count);
- else
- {
+ } else {
unsigned sa = SkAlphaMul(srcA, SkAlpha255To256(aa));
unsigned scale = 256 - sa;
- for (int i = 0; i < count; i++)
- {
+ for (int i = 0; i < count; i++) {
device[i] = SkToU8(sa + SkAlphaMul(device[i], scale));
}
}
@@ -110,14 +103,14 @@
} while (0)
#define SK_BLITBWMASK_NAME SkA8_BlitBW
-#define SK_BLITBWMASK_ARGS
+#define SK_BLITBWMASK_ARGS
#define SK_BLITBWMASK_BLIT8(mask, dst) solid_8_pixels(mask, dst)
#define SK_BLITBWMASK_GETADDR getAddr8
#define SK_BLITBWMASK_DEVTYPE uint8_t
#include "SkBlitBWMaskTemplate.h"
-static inline void blend_8_pixels(U8CPU bw, uint8_t dst[], U8CPU sa, unsigned dst_scale)
-{
+static inline void blend_8_pixels(U8CPU bw, uint8_t dst[], U8CPU sa,
+ unsigned dst_scale) {
if (bw & 0x80) dst[0] = SkToU8(sa + SkAlphaMul(dst[0], dst_scale));
if (bw & 0x40) dst[1] = SkToU8(sa + SkAlphaMul(dst[1], dst_scale));
if (bw & 0x20) dst[2] = SkToU8(sa + SkAlphaMul(dst[2], dst_scale));
@@ -135,17 +128,18 @@
#define SK_BLITBWMASK_DEVTYPE uint8_t
#include "SkBlitBWMaskTemplate.h"
-void SkA8_Blitter::blitMask(const SkMask& mask, const SkIRect& clip)
-{
- if (fSrcA == 0)
+void SkA8_Blitter::blitMask(const SkMask& mask, const SkIRect& clip) {
+ if (fSrcA == 0) {
return;
+ }
- if (mask.fFormat == SkMask::kBW_Format)
- {
- if (fSrcA == 0xFF)
+ if (mask.fFormat == SkMask::kBW_Format) {
+ if (fSrcA == 0xFF) {
SkA8_BlitBW(fDevice, mask, clip);
- else
- SkA8_BlendBW(fDevice, mask, clip, fSrcA, SkAlpha255To256(255 - fSrcA));
+ } else {
+ SkA8_BlendBW(fDevice, mask, clip, fSrcA,
+ SkAlpha255To256(255 - fSrcA));
+ }
return;
}
@@ -157,28 +151,24 @@
const uint8_t* alpha = mask.getAddr(x, y);
unsigned srcA = fSrcA;
- while (--height >= 0)
- {
- for (int i = width - 1; i >= 0; --i)
- {
+ while (--height >= 0) {
+ for (int i = width - 1; i >= 0; --i) {
unsigned sa;
// scale our src by the alpha value
{
int aa = alpha[i];
- if (aa == 0)
+ if (aa == 0) {
continue;
-
- if (aa == 255)
- {
- if (srcA == 255)
- {
+ }
+ if (aa == 255) {
+ if (srcA == 255) {
device[i] = 0xFF;
continue;
}
sa = srcA;
- }
- else
+ } else {
sa = SkAlphaMul(srcA, SkAlpha255To256(aa));
+ }
}
int scale = 256 - SkAlpha255To256(sa);
@@ -189,63 +179,54 @@
}
}
-///////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
-void SkA8_Blitter::blitV(int x, int y, int height, SkAlpha alpha)
-{
- if (fSrcA == 0)
+void SkA8_Blitter::blitV(int x, int y, int height, SkAlpha alpha) {
+ if (fSrcA == 0) {
return;
+ }
unsigned sa = SkAlphaMul(fSrcA, SkAlpha255To256(alpha));
uint8_t* device = fDevice.getAddr8(x, y);
int rowBytes = fDevice.rowBytes();
- if (sa == 0xFF)
- {
- for (int i = 0; i < height; i++)
- {
+ if (sa == 0xFF) {
+ for (int i = 0; i < height; i++) {
*device = SkToU8(sa);
device += rowBytes;
}
- }
- else
- {
+ } else {
unsigned scale = 256 - SkAlpha255To256(sa);
- for (int i = 0; i < height; i++)
- {
+ for (int i = 0; i < height; i++) {
*device = SkToU8(sa + SkAlphaMul(*device, scale));
device += rowBytes;
}
}
}
-void SkA8_Blitter::blitRect(int x, int y, int width, int height)
-{
- SkASSERT(x >= 0 && y >= 0 && (unsigned)(x + width) <= (unsigned)fDevice.width() && (unsigned)(y + height) <= (unsigned)fDevice.height());
+void SkA8_Blitter::blitRect(int x, int y, int width, int height) {
+ SkASSERT(x >= 0 && y >= 0 &&
+ (unsigned)(x + width) <= (unsigned)fDevice.width() &&
+ (unsigned)(y + height) <= (unsigned)fDevice.height());
- if (fSrcA == 0)
+ if (fSrcA == 0) {
return;
+ }
uint8_t* device = fDevice.getAddr8(x, y);
unsigned srcA = fSrcA;
- if (srcA == 255)
- {
- while (--height >= 0)
- {
+ if (srcA == 255) {
+ while (--height >= 0) {
memset(device, 0xFF, width);
device += fDevice.rowBytes();
}
- }
- else
- {
+ } else {
unsigned scale = 256 - SkAlpha255To256(srcA);
- while (--height >= 0)
- {
- for (int i = 0; i < width; i++)
- {
+ while (--height >= 0) {
+ for (int i = 0; i < width; i++) {
device[i] = SkToU8(srcA + SkAlphaMul(device[i], scale));
}
device += fDevice.rowBytes();
@@ -256,10 +237,8 @@
///////////////////////////////////////////////////////////////////////
SkA8_Shader_Blitter::SkA8_Shader_Blitter(const SkBitmap& device, const SkPaint& paint)
- : INHERITED(device, paint)
-{
- if ((fXfermode = paint.getXfermode()) != NULL)
- {
+ : INHERITED(device, paint) {
+ if ((fXfermode = paint.getXfermode()) != NULL) {
fXfermode->ref();
SkASSERT(fShader);
}
@@ -269,33 +248,27 @@
fAAExpand = (uint8_t*)(fBuffer + width);
}
-SkA8_Shader_Blitter::~SkA8_Shader_Blitter()
-{
- fXfermode->safeUnref();
+SkA8_Shader_Blitter::~SkA8_Shader_Blitter() {
+ SkSafeUnref(fXfermode);
sk_free(fBuffer);
}
-void SkA8_Shader_Blitter::blitH(int x, int y, int width)
-{
- SkASSERT(x >= 0 && y >= 0 && (unsigned)(x + width) <= (unsigned)fDevice.width());
+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.getAddr8(x, y);
- if ((fShader->getFlags() & SkShader::kOpaqueAlpha_Flag) && fXfermode == NULL)
- {
+ if ((fShader->getFlags() & SkShader::kOpaqueAlpha_Flag) && !fXfermode) {
memset(device, 0xFF, width);
- }
- else
- {
+ } else {
SkPMColor* span = fBuffer;
fShader->shadeSpan(x, y, span, width);
- if (fXfermode)
+ if (fXfermode) {
fXfermode->xferA8(device, span, width, NULL);
- else
- {
- for (int i = width - 1; i >= 0; --i)
- {
+ } else {
+ for (int i = width - 1; i >= 0; --i) {
unsigned srcA = SkGetPackedA32(span[i]);
unsigned scale = 256 - SkAlpha255To256(srcA);
@@ -305,8 +278,7 @@
}
}
-static inline uint8_t aa_blend8(SkPMColor src, U8CPU da, int aa)
-{
+static inline uint8_t aa_blend8(SkPMColor src, U8CPU da, int aa) {
SkASSERT((unsigned)aa <= 255);
int src_scale = SkAlpha255To256(aa);
@@ -316,8 +288,8 @@
return SkToU8((sa * src_scale + da * dst_scale) >> 8);
}
-void SkA8_Shader_Blitter::blitAntiH(int x, int y, const SkAlpha antialias[], const int16_t runs[])
-{
+void SkA8_Shader_Blitter::blitAntiH(int x, int y, const SkAlpha antialias[],
+ const int16_t runs[]) {
SkShader* shader = fShader;
SkXfermode* mode = fXfermode;
uint8_t* aaExpand = fAAExpand;
@@ -325,28 +297,24 @@
uint8_t* device = fDevice.getAddr8(x, y);
int opaque = fShader->getFlags() & SkShader::kOpaqueAlpha_Flag;
- for (;;)
- {
+ for (;;) {
int count = *runs;
- if (count == 0)
+ if (count == 0) {
break;
+ }
int aa = *antialias;
- if (aa)
- {
- if (opaque && aa == 255 && mode == NULL)
+ if (aa) {
+ if (opaque && aa == 255 && mode == NULL) {
memset(device, 0xFF, count);
- else
- {
+ } else {
shader->shadeSpan(x, y, span, count);
- if (mode)
- {
+ if (mode) {
memset(aaExpand, aa, count);
mode->xferA8(device, span, count, aaExpand);
- }
- else
- {
- for (int i = count - 1; i >= 0; --i)
+ } else {
+ for (int i = count - 1; i >= 0; --i) {
device[i] = aa_blend8(span[i], device[i], aa);
+ }
}
}
}
@@ -354,17 +322,15 @@
runs += count;
antialias += count;
x += count;
- }
+ }
}
-void SkA8_Shader_Blitter::blitMask(const SkMask& mask, const SkIRect& clip)
-{
- if (mask.fFormat == SkMask::kBW_Format)
- {
+void SkA8_Shader_Blitter::blitMask(const SkMask& mask, const SkIRect& clip) {
+ if (mask.fFormat == SkMask::kBW_Format) {
this->INHERITED::blitMask(mask, clip);
return;
}
-
+
int x = clip.fLeft;
int y = clip.fTop;
int width = clip.width();
@@ -374,11 +340,10 @@
SkPMColor* span = fBuffer;
- while (--height >= 0)
- {
+ while (--height >= 0) {
fShader->shadeSpan(x, y, span, width);
fXfermode->xferA8(device, span, width, alpha);
-
+
y += 1;
device += fDevice.rowBytes();
alpha += mask.fRowBytes;
diff --git a/src/core/SkBlitter_ARGB32.cpp b/src/core/SkBlitter_ARGB32.cpp
index 88b9491..a775adb 100644
--- a/src/core/SkBlitter_ARGB32.cpp
+++ b/src/core/SkBlitter_ARGB32.cpp
@@ -2,16 +2,16 @@
**
** Copyright 2006, The Android Open Source Project
**
-** Licensed under the Apache License, Version 2.0 (the "License");
-** you may not use this file except in compliance with the License.
-** You may obtain a copy of the License at
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
**
-** http://www.apache.org/licenses/LICENSE-2.0
+** http://www.apache.org/licenses/LICENSE-2.0
**
-** Unless required by applicable law or agreed to in writing, software
-** distributed under the License is distributed on an "AS IS" BASIS,
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-** See the License for the specific language governing permissions and
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
** limitations under the License.
*/
@@ -53,7 +53,7 @@
int y = clip.fTop;
int width = clip.width();
int height = clip.height();
-
+
SkPMColor* dstRow = device.getAddr32(x, y);
const SkPMColor* srcRow = reinterpret_cast<const SkPMColor*>(mask.getAddr(x, y));
@@ -448,7 +448,7 @@
}
SkARGB32_Shader_Blitter::~SkARGB32_Shader_Blitter() {
- fXfermode->safeUnref();
+ SkSafeUnref(fXfermode);
sk_free(fBuffer);
}
@@ -501,7 +501,7 @@
runs += count;
antialias += count;
x += count;
- }
+ }
} else if (fShader->getFlags() & SkShader::kOpaqueAlpha_Flag) {
for (;;) {
int count = *runs;
@@ -522,7 +522,7 @@
runs += count;
antialias += count;
x += count;
- }
+ }
} else { // no xfermode but the shader not opaque
for (;;) {
int count = *runs;
@@ -542,6 +542,6 @@
runs += count;
antialias += count;
x += count;
- }
+ }
}
}
diff --git a/src/core/SkCanvas.cpp b/src/core/SkCanvas.cpp
index 79915f8..faf030c 100644
--- a/src/core/SkCanvas.cpp
+++ b/src/core/SkCanvas.cpp
@@ -197,7 +197,7 @@
}
fFilter = prev->fFilter;
- fFilter->safeRef();
+ SkSafeRef(fFilter);
fTopLayer = prev->fTopLayer;
} else { // no prev
@@ -214,7 +214,7 @@
inc_rec();
}
~MCRec() {
- fFilter->safeUnref();
+ SkSafeUnref(fFilter);
SkDELETE(fLayer);
dec_rec();
}
diff --git a/src/core/SkComposeShader.cpp b/src/core/SkComposeShader.cpp
index 7e566a3..62bb2d6 100644
--- a/src/core/SkComposeShader.cpp
+++ b/src/core/SkComposeShader.cpp
@@ -2,16 +2,16 @@
**
** Copyright 2006, The Android Open Source Project
**
-** Licensed under the Apache License, Version 2.0 (the "License");
-** you may not use this file except in compliance with the License.
-** You may obtain a copy of the License at
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
**
-** http://www.apache.org/licenses/LICENSE-2.0
+** http://www.apache.org/licenses/LICENSE-2.0
**
-** Unless required by applicable law or agreed to in writing, software
-** distributed under the License is distributed on an "AS IS" BASIS,
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-** See the License for the specific language governing permissions and
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
** limitations under the License.
*/
@@ -20,40 +20,36 @@
#include "SkColorPriv.h"
#include "SkXfermode.h"
-//////////////////////////////////////////////////////////////////////////////////////
-
-SkComposeShader::SkComposeShader(SkShader* sA, SkShader* sB, SkXfermode* mode)
-{
+///////////////////////////////////////////////////////////////////////////////
+
+SkComposeShader::SkComposeShader(SkShader* sA, SkShader* sB, SkXfermode* mode) {
fShaderA = sA; sA->ref();
fShaderB = sB; sB->ref();
// mode may be null
- fMode = mode; mode->safeRef();
+ fMode = mode;
+ SkSafeRef(mode);
}
SkComposeShader::SkComposeShader(SkFlattenableReadBuffer& buffer) :
- INHERITED(buffer)
-{
+ INHERITED(buffer) {
fShaderA = static_cast<SkShader*>(buffer.readFlattenable());
fShaderB = static_cast<SkShader*>(buffer.readFlattenable());
fMode = static_cast<SkXfermode*>(buffer.readFlattenable());
}
-SkComposeShader::~SkComposeShader()
-{
- fMode->safeUnref(); // may be null
+SkComposeShader::~SkComposeShader() {
+ SkSafeUnref(fMode);
fShaderB->unref();
fShaderA->unref();
}
-void SkComposeShader::beginSession()
-{
+void SkComposeShader::beginSession() {
this->INHERITED::beginSession();
fShaderA->beginSession();
fShaderB->beginSession();
}
-void SkComposeShader::endSession()
-{
+void SkComposeShader::endSession() {
fShaderA->endSession();
fShaderB->endSession();
this->INHERITED::endSession();
@@ -61,14 +57,13 @@
class SkAutoAlphaRestore {
public:
- SkAutoAlphaRestore(SkPaint* paint, uint8_t newAlpha)
- {
+ SkAutoAlphaRestore(SkPaint* paint, uint8_t newAlpha) {
fAlpha = paint->getAlpha();
fPaint = paint;
paint->setAlpha(newAlpha);
}
- ~SkAutoAlphaRestore()
- {
+
+ ~SkAutoAlphaRestore() {
fPaint->setAlpha(fAlpha);
}
private:
@@ -76,8 +71,7 @@
uint8_t fAlpha;
};
-void SkComposeShader::flatten(SkFlattenableWriteBuffer& buffer)
-{
+void SkComposeShader::flatten(SkFlattenableWriteBuffer& buffer) {
this->INHERITED::flatten(buffer);
buffer.writeFlattenable(fShaderA);
buffer.writeFlattenable(fShaderB);
@@ -90,19 +84,19 @@
*/
bool SkComposeShader::setContext(const SkBitmap& device,
const SkPaint& paint,
- const SkMatrix& matrix)
-{
- if (!this->INHERITED::setContext(device, paint, matrix))
+ const SkMatrix& matrix) {
+ if (!this->INHERITED::setContext(device, paint, matrix)) {
return false;
+ }
// we preconcat our localMatrix (if any) with the device matrix
// before calling our sub-shaders
SkMatrix tmpM;
-
+
(void)this->getLocalMatrix(&tmpM);
tmpM.setConcat(matrix, tmpM);
-
+
SkAutoAlphaRestore restore(const_cast<SkPaint*>(&paint), 0xFF);
return fShaderA->setContext(device, paint, tmpM) &&
@@ -113,58 +107,56 @@
// take up too much stack-space (each element is 4 bytes)
#define TMP_COLOR_COUNT 64
-void SkComposeShader::shadeSpan(int x, int y, SkPMColor result[], int count)
-{
+void SkComposeShader::shadeSpan(int x, int y, SkPMColor result[], int count) {
SkShader* shaderA = fShaderA;
SkShader* shaderB = fShaderB;
SkXfermode* mode = fMode;
unsigned scale = SkAlpha255To256(this->getPaintAlpha());
-
+
SkPMColor tmp[TMP_COLOR_COUNT];
- if (NULL == mode) // implied SRC_OVER
- {
+ if (NULL == mode) { // implied SRC_OVER
// TODO: when we have a good test-case, should use SkBlitRow::Proc32
// for these loops
do {
int n = count;
- if (n > TMP_COLOR_COUNT)
+ if (n > TMP_COLOR_COUNT) {
n = TMP_COLOR_COUNT;
-
+ }
+
shaderA->shadeSpan(x, y, result, n);
shaderB->shadeSpan(x, y, tmp, n);
- if (256 == scale)
- {
- for (int i = 0; i < n; i++)
+ if (256 == scale) {
+ for (int i = 0; i < n; i++) {
result[i] = SkPMSrcOver(tmp[i], result[i]);
+ }
+ } else {
+ for (int i = 0; i < n; i++) {
+ result[i] = SkAlphaMulQ(SkPMSrcOver(tmp[i], result[i]),
+ scale);
+ }
}
- else
- {
- for (int i = 0; i < n; i++)
- result[i] = SkAlphaMulQ(SkPMSrcOver(tmp[i], result[i]), scale);
- }
-
+
result += n;
x += n;
count -= n;
} while (count > 0);
- }
- else // use mode for the composition
- {
+ } else { // use mode for the composition
do {
int n = count;
- if (n > TMP_COLOR_COUNT)
+ if (n > TMP_COLOR_COUNT) {
n = TMP_COLOR_COUNT;
-
+ }
+
shaderA->shadeSpan(x, y, result, n);
shaderB->shadeSpan(x, y, tmp, n);
mode->xfer32(result, tmp, n, NULL);
- if (256 == scale)
- {
- for (int i = 0; i < n; i++)
+ if (256 == scale) {
+ for (int i = 0; i < n; i++) {
result[i] = SkAlphaMulQ(result[i], scale);
+ }
}
result += n;
@@ -173,4 +165,4 @@
} while (count > 0);
}
}
-
+
diff --git a/src/core/SkDraw.cpp b/src/core/SkDraw.cpp
index 541860c..8378e73 100644
--- a/src/core/SkDraw.cpp
+++ b/src/core/SkDraw.cpp
@@ -76,6 +76,7 @@
fBlitter = SkBlitter::Choose(device, matrix, paint,
fStorage, sizeof(fStorage));
}
+
~SkAutoBlitterChoose();
SkBlitter* operator->() { return fBlitter; }
@@ -99,16 +100,17 @@
SkAutoBitmapShaderInstall(const SkBitmap& src, const SkPaint* paint)
: fPaint((SkPaint*)paint) {
fPrevShader = paint->getShader();
- fPrevShader->safeRef();
+ SkSafeRef(fPrevShader);
fPaint->setShader(SkShader::CreateBitmapShader( src,
SkShader::kClamp_TileMode, SkShader::kClamp_TileMode,
fStorage, sizeof(fStorage)));
}
+
~SkAutoBitmapShaderInstall() {
SkShader* shader = fPaint->getShader();
fPaint->setShader(fPrevShader);
- fPrevShader->safeUnref();
+ SkSafeUnref(fPrevShader);
if ((void*)shader == (void*)fStorage) {
shader->~SkShader();
@@ -116,6 +118,7 @@
SkDELETE(shader);
}
}
+
private:
SkPaint* fPaint;
SkShader* fPrevShader;
@@ -129,9 +132,11 @@
fStyle = paint.getStyle(); // record the old
fPaint.setStyle(style); // change it to the specified style
}
+
~SkAutoPaintStyleRestore() {
fPaint.setStyle(fStyle); // restore the old
}
+
private:
SkPaint& fPaint;
SkPaint::Style fStyle;
diff --git a/src/core/SkFlattenable.cpp b/src/core/SkFlattenable.cpp
index 3558519..dcdaa92 100644
--- a/src/core/SkFlattenable.cpp
+++ b/src/core/SkFlattenable.cpp
@@ -15,10 +15,10 @@
SkFlattenableReadBuffer::SkFlattenableReadBuffer() {
fRCArray = NULL;
fRCCount = 0;
-
+
fTFArray = NULL;
fTFCount = 0;
-
+
fFactoryArray = NULL;
fFactoryCount = 0;
}
@@ -27,10 +27,10 @@
INHERITED(data, 1024 * 1024) {
fRCArray = NULL;
fRCCount = 0;
-
+
fTFArray = NULL;
fTFCount = 0;
-
+
fFactoryArray = NULL;
fFactoryCount = 0;
}
@@ -39,10 +39,10 @@
: INHERITED(data, size) {
fRCArray = NULL;
fRCCount = 0;
-
+
fTFArray = NULL;
fTFCount = 0;
-
+
fFactoryArray = NULL;
fFactoryCount = 0;
}
@@ -72,7 +72,7 @@
SkFlattenable* SkFlattenableReadBuffer::readFlattenable() {
SkFlattenable::Factory factory = NULL;
-
+
if (fFactoryCount > 0) {
uint32_t index = this->readU32();
if (index > 0) {
@@ -123,9 +123,9 @@
}
SkFlattenableWriteBuffer::~SkFlattenableWriteBuffer() {
- fRCRecorder->safeUnref();
- fTFRecorder->safeUnref();
- fFactoryRecorder->safeUnref();
+ SkSafeUnref(fRCRecorder);
+ SkSafeUnref(fTFRecorder);
+ SkSafeUnref(fFactoryRecorder);
}
SkRefCntRecorder* SkFlattenableWriteBuffer::setRefCntRecorder(
@@ -173,7 +173,7 @@
} else {
this->writeFunctionPtr((void*)factory);
}
-
+
if (factory) {
// make room for the size of the flatttened object
(void)this->reserve(sizeof(uint32_t));
@@ -223,15 +223,15 @@
void SkFlattenable::Register(const char name[], Factory factory) {
SkASSERT(name);
SkASSERT(factory);
-
+
static bool gOnce;
if (!gOnce) {
gCount = 0;
gOnce = true;
}
-
+
SkASSERT(gCount < MAX_PAIR_COUNT);
-
+
gPairs[gCount].fName = name;
gPairs[gCount].fFactory = factory;
gCount += 1;
diff --git a/src/core/SkMallocPixelRef.cpp b/src/core/SkMallocPixelRef.cpp
index 726baca..7b97f16 100644
--- a/src/core/SkMallocPixelRef.cpp
+++ b/src/core/SkMallocPixelRef.cpp
@@ -10,7 +10,7 @@
fStorage = storage;
fSize = size;
fCTable = ctable;
- ctable->safeRef();
+ SkSafeRef(ctable);
}
SkMallocPixelRef::~SkMallocPixelRef() {
@@ -40,7 +40,8 @@
}
}
-SkMallocPixelRef::SkMallocPixelRef(SkFlattenableReadBuffer& buffer) : INHERITED(buffer, NULL) {
+SkMallocPixelRef::SkMallocPixelRef(SkFlattenableReadBuffer& buffer)
+ : INHERITED(buffer, NULL) {
fSize = buffer.readU32();
fStorage = sk_malloc_throw(fSize);
buffer.read(fStorage, fSize);
diff --git a/src/core/SkPaint.cpp b/src/core/SkPaint.cpp
index 1c65a7d..0fb2254 100644
--- a/src/core/SkPaint.cpp
+++ b/src/core/SkPaint.cpp
@@ -71,49 +71,49 @@
{
memcpy(this, &src, sizeof(src));
- fTypeface->safeRef();
- fPathEffect->safeRef();
- fShader->safeRef();
- fXfermode->safeRef();
- fMaskFilter->safeRef();
- fColorFilter->safeRef();
- fRasterizer->safeRef();
- fLooper->safeRef();
+ SkSafeRef(fTypeface);
+ SkSafeRef(fPathEffect);
+ SkSafeRef(fShader);
+ SkSafeRef(fXfermode);
+ SkSafeRef(fMaskFilter);
+ SkSafeRef(fColorFilter);
+ SkSafeRef(fRasterizer);
+ SkSafeRef(fLooper);
}
SkPaint::~SkPaint()
{
- fTypeface->safeUnref();
- fPathEffect->safeUnref();
- fShader->safeUnref();
- fXfermode->safeUnref();
- fMaskFilter->safeUnref();
- fColorFilter->safeUnref();
- fRasterizer->safeUnref();
- fLooper->safeUnref();
+ SkSafeUnref(fTypeface);
+ SkSafeUnref(fPathEffect);
+ SkSafeUnref(fShader);
+ SkSafeUnref(fXfermode);
+ SkSafeUnref(fMaskFilter);
+ SkSafeUnref(fColorFilter);
+ SkSafeUnref(fRasterizer);
+ SkSafeUnref(fLooper);
}
SkPaint& SkPaint::operator=(const SkPaint& src)
{
SkASSERT(&src);
- src.fTypeface->safeRef();
- src.fPathEffect->safeRef();
- src.fShader->safeRef();
- src.fXfermode->safeRef();
- src.fMaskFilter->safeRef();
- src.fColorFilter->safeRef();
- src.fRasterizer->safeRef();
- src.fLooper->safeRef();
+ SkSafeRef(src.fTypeface);
+ SkSafeRef(src.fPathEffect);
+ SkSafeRef(src.fShader);
+ SkSafeRef(src.fXfermode);
+ SkSafeRef(src.fMaskFilter);
+ SkSafeRef(src.fColorFilter);
+ SkSafeRef(src.fRasterizer);
+ SkSafeRef(src.fLooper);
- fTypeface->safeUnref();
- fPathEffect->safeUnref();
- fShader->safeUnref();
- fXfermode->safeUnref();
- fMaskFilter->safeUnref();
- fColorFilter->safeUnref();
- fRasterizer->safeUnref();
- fLooper->safeUnref();
+ SkSafeUnref(fTypeface);
+ SkSafeUnref(fPathEffect);
+ SkSafeUnref(fShader);
+ SkSafeUnref(fXfermode);
+ SkSafeUnref(fMaskFilter);
+ SkSafeUnref(fColorFilter);
+ SkSafeUnref(fRasterizer);
+ SkSafeUnref(fLooper);
memcpy(this, &src, sizeof(src));
@@ -1511,13 +1511,13 @@
}
if (flatFlags & kHasEffects_FlatFlag) {
- this->setPathEffect((SkPathEffect*) buffer.readFlattenable())->safeUnref();
- this->setShader((SkShader*) buffer.readFlattenable())->safeUnref();
- this->setXfermode((SkXfermode*) buffer.readFlattenable())->safeUnref();
- this->setMaskFilter((SkMaskFilter*) buffer.readFlattenable())->safeUnref();
- this->setColorFilter((SkColorFilter*) buffer.readFlattenable())->safeUnref();
- this->setRasterizer((SkRasterizer*) buffer.readFlattenable())->safeUnref();
- this->setLooper((SkDrawLooper*) buffer.readFlattenable())->safeUnref();
+ SkSafeUnref(this->setPathEffect((SkPathEffect*) buffer.readFlattenable()));
+ SkSafeUnref(this->setShader((SkShader*) buffer.readFlattenable()));
+ SkSafeUnref(this->setXfermode((SkXfermode*) buffer.readFlattenable()));
+ SkSafeUnref(this->setMaskFilter((SkMaskFilter*) buffer.readFlattenable()));
+ SkSafeUnref(this->setColorFilter((SkColorFilter*) buffer.readFlattenable()));
+ SkSafeUnref(this->setRasterizer((SkRasterizer*) buffer.readFlattenable()));
+ SkSafeUnref(this->setLooper((SkDrawLooper*) buffer.readFlattenable()));
} else {
this->setPathEffect(NULL);
this->setShader(NULL);
@@ -1531,20 +1531,17 @@
///////////////////////////////////////////////////////////////////////////////
-SkShader* SkPaint::setShader(SkShader* shader)
-{
+SkShader* SkPaint::setShader(SkShader* shader) {
SkRefCnt_SafeAssign(fShader, shader);
return shader;
}
-SkColorFilter* SkPaint::setColorFilter(SkColorFilter* filter)
-{
+SkColorFilter* SkPaint::setColorFilter(SkColorFilter* filter) {
SkRefCnt_SafeAssign(fColorFilter, filter);
return filter;
}
-SkXfermode* SkPaint::setXfermode(SkXfermode* mode)
-{
+SkXfermode* SkPaint::setXfermode(SkXfermode* mode) {
SkRefCnt_SafeAssign(fXfermode, mode);
return mode;
}
@@ -1555,19 +1552,17 @@
return fXfermode;
}
-SkPathEffect* SkPaint::setPathEffect(SkPathEffect* effect)
-{
+SkPathEffect* SkPaint::setPathEffect(SkPathEffect* effect) {
SkRefCnt_SafeAssign(fPathEffect, effect);
return effect;
}
-SkMaskFilter* SkPaint::setMaskFilter(SkMaskFilter* filter)
-{
+SkMaskFilter* SkPaint::setMaskFilter(SkMaskFilter* filter) {
SkRefCnt_SafeAssign(fMaskFilter, filter);
return filter;
}
-////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
bool SkPaint::getFillPath(const SkPath& src, SkPath* dst) const
{
diff --git a/src/core/SkPicture.cpp b/src/core/SkPicture.cpp
index 343ca2b..c199cae 100644
--- a/src/core/SkPicture.cpp
+++ b/src/core/SkPicture.cpp
@@ -2,16 +2,16 @@
**
** Copyright 2007, The Android Open Source Project
**
-** Licensed under the Apache License, Version 2.0 (the "License");
-** you may not use this file except in compliance with the License.
-** You may obtain a copy of the License at
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
**
-** http://www.apache.org/licenses/LICENSE-2.0
+** http://www.apache.org/licenses/LICENSE-2.0
**
-** Unless required by applicable law or agreed to in writing, software
-** distributed under the License is distributed on an "AS IS" BASIS,
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-** See the License for the specific language governing permissions and
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
** limitations under the License.
*/
@@ -37,7 +37,7 @@
#ifdef SK_DEBUG
-// enable SK_DEBUG_TRACE to trace DrawType elements when
+// enable SK_DEBUG_TRACE to trace DrawType elements when
// recorded and played back
// #define SK_DEBUG_TRACE
// enable SK_DEBUG_SIZE to see the size of picture components
@@ -77,12 +77,12 @@
case SCALE: return "SCALE";
case SKEW: return "SKEW";
case TRANSLATE: return "TRANSLATE";
- default:
- SkDebugf("DrawType error 0x%08x\n", drawType);
- SkASSERT(0);
+ default:
+ SkDebugf("DrawType error 0x%08x\n", drawType);
+ SkASSERT(0);
break;
}
- SkASSERT(0);
+ SkASSERT(0);
return NULL;
}
#endif
@@ -133,7 +133,7 @@
}
SkPicture::~SkPicture() {
- fRecord->safeUnref();
+ SkSafeUnref(fRecord);
SkDELETE(fPlayback);
}
@@ -166,7 +166,7 @@
SkBitmap bm;
bm.setConfig(SkBitmap::kNo_Config, width, height);
fRecord->setBitmapDevice(bm);
-
+
return fRecord;
}
@@ -217,7 +217,7 @@
void SkPicture::serialize(SkWStream* stream) const {
SkPicturePlayback* playback = fPlayback;
-
+
if (NULL == playback && fRecord) {
playback = SkNEW_ARGS(SkPicturePlayback, (*fRecord));
}
diff --git a/src/core/SkPicturePlayback.cpp b/src/core/SkPicturePlayback.cpp
index f488565..0232cc0 100644
--- a/src/core/SkPicturePlayback.cpp
+++ b/src/core/SkPicturePlayback.cpp
@@ -14,7 +14,7 @@
SkPicturePlayback::SkPicturePlayback(const SkPictureRecord& record) {
#ifdef SK_DEBUG_SIZE
- size_t overallBytes, bitmapBytes, matricesBytes,
+ size_t overallBytes, bitmapBytes, matricesBytes,
paintBytes, pathBytes, pictureBytes, regionBytes;
int bitmaps = record.bitmaps(&bitmapBytes);
int matrices = record.matrices(&matricesBytes);
@@ -42,7 +42,7 @@
SkDebugf("rects size %zd (rects:%d) ", record.fRectBytes, record.fRectWrites);
if (record.fTextWrites != 0)
SkDebugf("text size %zd (text strings:%d) ", record.fTextBytes, record.fTextWrites);
-
+
SkDebugf("\n");
#endif
#ifdef SK_DEBUG_DUMP
@@ -55,27 +55,27 @@
init();
if (writer.size() == 0)
return;
-
+
{
size_t size = writer.size();
void* buffer = sk_malloc_throw(size);
writer.flatten(buffer);
fReader.setMemory(buffer, size); // fReader owns buffer now
}
-
+
// copy over the refcnt dictionary to our reader
//
fRCPlayback.reset(&record.fRCRecorder);
fRCPlayback.setupBuffer(fReader);
-
+
fTFPlayback.reset(&record.fTFRecorder);
fTFPlayback.setupBuffer(fReader);
-
+
const SkTDArray<const SkFlatBitmap* >& bitmaps = record.getBitmaps();
fBitmapCount = bitmaps.count();
if (fBitmapCount > 0) {
fBitmaps = SkNEW_ARRAY(SkBitmap, fBitmapCount);
- for (const SkFlatBitmap** flatBitmapPtr = bitmaps.begin();
+ for (const SkFlatBitmap** flatBitmapPtr = bitmaps.begin();
flatBitmapPtr != bitmaps.end(); flatBitmapPtr++) {
const SkFlatBitmap* flatBitmap = *flatBitmapPtr;
int index = flatBitmap->index() - 1;
@@ -87,7 +87,7 @@
fMatrixCount = matrices.count();
if (fMatrixCount > 0) {
fMatrices = SkNEW_ARRAY(SkMatrix, fMatrixCount);
- for (const SkFlatMatrix** matrixPtr = matrices.begin();
+ for (const SkFlatMatrix** matrixPtr = matrices.begin();
matrixPtr != matrices.end(); matrixPtr++) {
const SkFlatMatrix* flatMatrix = *matrixPtr;
flatMatrix->unflatten(&fMatrices[flatMatrix->index() - 1]);
@@ -98,7 +98,7 @@
fPaintCount = paints.count();
if (fPaintCount > 0) {
fPaints = SkNEW_ARRAY(SkPaint, fPaintCount);
- for (const SkFlatPaint** flatPaintPtr = paints.begin();
+ for (const SkFlatPaint** flatPaintPtr = paints.begin();
flatPaintPtr != paints.end(); flatPaintPtr++) {
const SkFlatPaint* flatPaint = *flatPaintPtr;
int index = flatPaint->index() - 1;
@@ -108,7 +108,7 @@
}
fPathHeap = record.fPathHeap;
- fPathHeap->safeRef();
+ SkSafeRef(fPathHeap);
const SkTDArray<SkPicture* >& pictures = record.getPictureRefs();
fPictureCount = pictures.count();
@@ -119,7 +119,7 @@
fPictureRefs[i]->ref();
}
}
-
+
const SkTDArray<SkShape* >& shapes = record.getShapes();
fShapeCount = shapes.count();
if (fShapeCount > 0) {
@@ -130,18 +130,18 @@
fShapes[i] = s;
}
}
-
+
const SkTDArray<const SkFlatRegion* >& regions = record.getRegions();
fRegionCount = regions.count();
if (fRegionCount > 0) {
fRegions = SkNEW_ARRAY(SkRegion, fRegionCount);
- for (const SkFlatRegion** flatRegionPtr = regions.begin();
+ for (const SkFlatRegion** flatRegionPtr = regions.begin();
flatRegionPtr != regions.end(); flatRegionPtr++) {
const SkFlatRegion* flatRegion = *flatRegionPtr;
flatRegion->unflatten(&fRegions[flatRegion->index() - 1]);
}
}
-
+
#ifdef SK_DEBUG_SIZE
int overall = fPlayback->size(&overallBytes);
bitmaps = fPlayback->bitmaps(&bitmapBytes);
@@ -194,7 +194,7 @@
}
fPathHeap = src.fPathHeap;
- fPathHeap->safeRef();
+ SkSafeRef(fPathHeap);
fPictureCount = src.fPictureCount;
fPictureRefs = SkNEW_ARRAY(SkPicture*, fPictureCount);
@@ -202,7 +202,7 @@
fPictureRefs[i] = src.fPictureRefs[i];
fPictureRefs[i]->ref();
}
-
+
fShapeCount = src.fShapeCount;
fShapes = SkNEW_ARRAY(SkShape*, fShapeCount);
for (int i = 0; i < fShapeCount; i++) {
@@ -210,7 +210,7 @@
SkSafeRef(s);
fShapes[i] = s;
}
-
+
fRegionCount = src.fRegionCount;
fRegions = SkNEW_ARRAY(SkRegion, fRegionCount);
for (i = 0; i < fRegionCount; i++) {
@@ -226,9 +226,9 @@
fPictureRefs = NULL;
fShapes = NULL;
fRegions = NULL;
- fBitmapCount = fMatrixCount = fPaintCount = fPictureCount =
+ fBitmapCount = fMatrixCount = fPaintCount = fPictureCount =
fRegionCount = fShapeCount = 0;
-
+
fFactoryPlayback = NULL;
}
@@ -239,19 +239,19 @@
SkDELETE_ARRAY(fMatrices);
SkDELETE_ARRAY(fPaints);
SkDELETE_ARRAY(fRegions);
-
- fPathHeap->safeUnref();
-
+
+ SkSafeUnref(fPathHeap);
+
for (int i = 0; i < fPictureCount; i++) {
fPictureRefs[i]->unref();
}
SkDELETE_ARRAY(fPictureRefs);
-
+
for (int i = 0; i < fShapeCount; i++) {
SkSafeUnref(fShapes[i]);
}
SkDELETE_ARRAY(fShapes);
-
+
SkDELETE(fFactoryPlayback);
}
@@ -299,13 +299,13 @@
static void writeFactories(SkWStream* stream, const SkFactoryRecorder& rec) {
int count = rec.count();
-
+
writeTagSize(stream, PICT_FACTORY_TAG, count);
-
+
SkAutoSTMalloc<16, SkFlattenable::Factory> storage(count);
SkFlattenable::Factory* array = (SkFlattenable::Factory*)storage.get();
rec.get(array);
-
+
for (int i = 0; i < count; i++) {
const char* name = SkFlattenable::FactoryToName(array[i]);
// SkDebugf("---- write factories [%d] %p <%s>\n", i, array[i], name);
@@ -321,13 +321,13 @@
static void writeTypefaces(SkWStream* stream, const SkRefCntRecorder& rec) {
int count = rec.count();
-
+
writeTagSize(stream, PICT_TYPEFACE_TAG, count);
-
+
SkAutoSTMalloc<16, SkTypeface*> storage(count);
SkTypeface** array = (SkTypeface**)storage.get();
rec.get((SkRefCnt**)array);
-
+
for (int i = 0; i < count; i++) {
array[i]->serialize(stream);
}
@@ -336,7 +336,7 @@
void SkPicturePlayback::serialize(SkWStream* stream) const {
writeTagSize(stream, PICT_READER_TAG, fReader.size());
stream->write(fReader.base(), fReader.size());
-
+
SkRefCntRecorder typefaceRecorder;
SkFactoryRecorder factRecorder;
@@ -347,7 +347,7 @@
buffer.setFactoryRecorder(&factRecorder);
int i;
-
+
writeTagSize(buffer, PICT_BITMAP_TAG, fBitmapCount);
for (i = 0; i < fBitmapCount; i++) {
fBitmaps[i].flatten(buffer);
@@ -360,7 +360,7 @@
for (i = 0; i < fPaintCount; i++) {
fPaints[i].flatten(buffer);
}
-
+
{
int count = fPathHeap ? fPathHeap->count() : 0;
writeTagSize(buffer, PICT_PATH_TAG, count);
@@ -368,7 +368,7 @@
fPathHeap->flatten(buffer);
}
}
-
+
writeTagSize(buffer, PICT_REGION_TAG, fRegionCount);
for (i = 0; i < fRegionCount; i++) {
uint32_t size = fRegions[i].flatten(NULL);
@@ -377,7 +377,7 @@
fRegions[i].flatten(storage.get());
buffer.writePad(storage.get(), size);
}
-
+
writeTagSize(buffer, PICT_SHAPE_TAG, fShapeCount);
for (i = 0; i < fShapeCount; i++) {
buffer.writeFlattenable(fShapes[i]);
@@ -392,7 +392,7 @@
for (i = 0; i < fPictureCount; i++) {
fPictureRefs[i]->serialize(stream);
}
-
+
writeTagSize(stream, PICT_ARRAYS_TAG, buffer.size());
buffer.writeToStream(stream);
}
@@ -419,14 +419,14 @@
this->init();
int i;
-
+
{
size_t size = readTagSize(stream, PICT_READER_TAG);
void* storage = sk_malloc_throw(size);
stream->read(storage, size);
fReader.setMemory(storage, size);
}
-
+
int factoryCount = readTagSize(stream, PICT_FACTORY_TAG);
fFactoryPlayback = SkNEW_ARGS(SkFactoryPlayback, (factoryCount));
for (i = 0; i < factoryCount; i++) {
@@ -437,19 +437,19 @@
// SkDebugf("--- factory playback [%d] <%s>\n", i, str.c_str());
fFactoryPlayback->base()[i] = SkFlattenable::NameToFactory(str.c_str());
}
-
+
int typefaceCount = readTagSize(stream, PICT_TYPEFACE_TAG);
fTFPlayback.setCount(typefaceCount);
for (i = 0; i < typefaceCount; i++) {
fTFPlayback.set(i, SkTypeface::Deserialize(stream))->unref();
- }
+ }
fPictureCount = readTagSize(stream, PICT_PICTURE_TAG);
fPictureRefs = SkNEW_ARRAY(SkPicture*, fPictureCount);
for (i = 0; i < fPictureCount; i++) {
fPictureRefs[i] = SkNEW_ARGS(SkPicture, (stream));
}
-
+
/*
Now read the arrays chunk, and parse using a read buffer
*/
@@ -470,20 +470,20 @@
fMatrixCount = readTagSize(buffer, PICT_MATRIX_TAG);
fMatrices = SkNEW_ARRAY(SkMatrix, fMatrixCount);
buffer.read(fMatrices, fMatrixCount * sizeof(SkMatrix));
-
+
fPaintCount = readTagSize(buffer, PICT_PAINT_TAG);
fPaints = SkNEW_ARRAY(SkPaint, fPaintCount);
for (i = 0; i < fPaintCount; i++) {
fPaints[i].unflatten(buffer);
}
-
+
{
int count = readTagSize(buffer, PICT_PATH_TAG);
if (count > 0) {
fPathHeap = SkNEW_ARGS(SkPathHeap, (buffer));
}
}
-
+
fRegionCount = readTagSize(buffer, PICT_REGION_TAG);
fRegions = SkNEW_ARRAY(SkRegion, fRegionCount);
for (i = 0; i < fRegionCount; i++) {
@@ -506,12 +506,12 @@
struct SkipClipRec {
int fCount;
size_t fSize;
-
+
SkipClipRec() {
fCount = 0;
fSize = 0;
}
-
+
void recordSkip(size_t bytes) {
fCount += 1;
fSize += bytes;
@@ -523,7 +523,7 @@
#ifdef ENABLE_TIME_DRAW
SkAutoTime at("SkPicture::draw", 50);
#endif
-
+
#ifdef SPEW_CLIP_SKIPPING
SkipClipRec skipRect, skipRegion, skipPath;
#endif
@@ -537,7 +537,7 @@
const SkPath& path = getPath();
SkRegion::Op op = (SkRegion::Op) getInt();
size_t offsetToRestore = getInt();
- // HACK (false) until I can handle op==kReplace
+ // HACK (false) until I can handle op==kReplace
if (!canvas.clipPath(path, op)) {
#ifdef SPEW_CLIP_SKIPPING
skipPath.recordSkip(offsetToRestore - fReader.offset());
@@ -642,7 +642,7 @@
} break;
case DRAW_RECT: {
const SkPaint& paint = *getPaint();
- canvas.drawRect(*fReader.skipRect(), paint);
+ canvas.drawRect(*fReader.skipRect(), paint);
} break;
case DRAW_SHAPE: {
SkShape* shape = getShape();
@@ -652,10 +652,10 @@
} break;
case DRAW_SPRITE: {
const SkPaint* paint = getPaint();
- const SkBitmap& bitmap = getBitmap();
+ const SkBitmap& bitmap = getBitmap();
int left = getInt();
int top = getInt();
- canvas.drawSprite(bitmap, left, top, paint);
+ canvas.drawSprite(bitmap, left, top, paint);
} break;
case DRAW_TEXT: {
const SkPaint& paint = *getPaint();
@@ -683,7 +683,7 @@
getText(&text);
const SkPath& path = getPath();
const SkMatrix* matrix = getMatrix();
- canvas.drawTextOnPath(text.text(), text.length(), path,
+ canvas.drawTextOnPath(text.text(), text.length(), path,
matrix, paint);
} break;
case DRAW_VERTICES: {
@@ -749,7 +749,7 @@
SkASSERT(0);
}
}
-
+
#ifdef SPEW_CLIP_SKIPPING
{
size_t size = skipRect.fSize + skipPath.fSize + skipRegion.fSize;
@@ -768,7 +768,7 @@
///////////////////////////////////////////////////////////////////////////////
#if 0
-uint32_t SkPicturePlayback::flatten(void* storage) const {
+uint32_t SkPicturePlayback::flatten(void* storage) const {
SkWBuffer buffer(storage);
buffer.write32(fBitmapCount);
int index;
@@ -849,7 +849,7 @@
const void* local = buffer.skip(size);
fPaths[index].unflatten(local);
}
-
+
#if 0
fPictureCount = buffer.readU32();
fPictures = new SkPicture[fPictureCount];
@@ -859,7 +859,7 @@
fPictures[index].unflatten(local);
}
#endif
-
+
fRegionCount = buffer.readU32();
fRegions = new SkRegion[fRegionCount];
for (index = 0; index < fRegionCount; index++) {
@@ -876,14 +876,14 @@
///////////////////////////////////////////////////////////////////////////////
#ifdef SK_DEBUG_SIZE
-int SkPicturePlayback::size(size_t* sizePtr) {
+int SkPicturePlayback::size(size_t* sizePtr) {
int objects = bitmaps(sizePtr);
objects += paints(sizePtr);
objects += paths(sizePtr);
objects += pictures(sizePtr);
objects += regions(sizePtr);
*sizePtr = fReader.size();
- return objects;
+ return objects;
}
int SkPicturePlayback::bitmaps(size_t* size) {
@@ -1110,7 +1110,7 @@
int SkPicturePlayback::dumpRect(char* bufferPtr, char* buffer, char* name) {
const SkRect* rect = fReader.skipRect();
return snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer),
- "%s:{l:%g t:%g r:%g b:%g}, ", name, SkScalarToFloat(rect.fLeft),
+ "%s:{l:%g t:%g r:%g b:%g}, ", name, SkScalarToFloat(rect.fLeft),
SkScalarToFloat(rect.fTop),
SkScalarToFloat(rect.fRight), SkScalarToFloat(rect.fBottom));
}
@@ -1119,7 +1119,7 @@
SkPoint pt;
getPoint(&pt);
return snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer),
- "%s:{x:%g y:%g}, ", name, SkScalarToFloat(pt.fX),
+ "%s:{x:%g y:%g}, ", name, SkScalarToFloat(pt.fX),
SkScalarToFloat(pt.fY));
}
@@ -1131,7 +1131,7 @@
"count:%d {", count);
for (int index = 0; index < count; index++)
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer),
- "{x:%g y:%g}, ", SkScalarToFloat(pts[index].fX),
+ "{x:%g y:%g}, ", SkScalarToFloat(pts[index].fX),
SkScalarToFloat(pts[index].fY));
bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - buffer),
"} ");
@@ -1341,10 +1341,10 @@
dumpBitmap(bitmap);
}
if (fBitmapCount > 0)
- bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
+ bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"Bitmaps bitmaps = {");
for (index = 0; index < fBitmapCount; index++)
- bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
+ bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"bitmap%p, ", &fBitmaps[index]);
if (fBitmapCount > 0)
SkDebugf("%s0};\n", pBuffer);
@@ -1357,10 +1357,10 @@
}
bufferPtr = pBuffer;
if (fMatrixCount > 0)
- bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
+ bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"Matrices matrices = {");
for (index = 0; index < fMatrixCount; index++)
- bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
+ bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"matrix%p, ", &fMatrices[index]);
if (fMatrixCount > 0)
SkDebugf("%s0};\n", pBuffer);
@@ -1373,10 +1373,10 @@
}
bufferPtr = pBuffer;
if (fPaintCount > 0)
- bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
+ bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"Paints paints = {");
for (index = 0; index < fPaintCount; index++)
- bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
+ bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"paint%p, ", &fPaints[index]);
if (fPaintCount > 0)
SkDebugf("%s0};\n", pBuffer);
@@ -1387,10 +1387,10 @@
}
bufferPtr = pBuffer;
if (fPathCount > 0)
- bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
+ bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"Paths paths = {");
for (index = 0; index < fPathCount; index++)
- bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
+ bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"path%p, ", &fPaths[index]);
if (fPathCount > 0)
SkDebugf("%s0};\n", pBuffer);
@@ -1400,10 +1400,10 @@
}
bufferPtr = pBuffer;
if (fPictureCount > 0)
- bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
+ bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"Pictures pictures = {");
for (index = 0; index < fPictureCount; index++)
- bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
+ bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"picture%p, ", fPictureRefs[index]);
if (fPictureCount > 0)
SkDebugf("%s0};\n", pBuffer);
@@ -1414,10 +1414,10 @@
}
bufferPtr = pBuffer;
if (fRegionCount > 0)
- bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
+ bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"Regions regions = {");
for (index = 0; index < fRegionCount; index++)
- bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
+ bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
"region%p, ", &fRegions[index]);
if (fRegionCount > 0)
SkDebugf("%s0};\n", pBuffer);
diff --git a/src/core/SkPictureRecord.cpp b/src/core/SkPictureRecord.cpp
index 9844a48..00e4b60 100644
--- a/src/core/SkPictureRecord.cpp
+++ b/src/core/SkPictureRecord.cpp
@@ -15,7 +15,7 @@
fRestoreOffsetStack.setReserve(32);
fRestoreOffsetStack.push(0);
-
+
fPathHeap = NULL; // lazy allocate
}
@@ -28,9 +28,9 @@
int SkPictureRecord::save(SaveFlags flags) {
addDraw(SAVE);
addInt(flags);
-
+
fRestoreOffsetStack.push(0);
-
+
validate();
return this->INHERITED::save(flags);
}
@@ -84,7 +84,7 @@
}
bool SkPictureRecord::scale(SkScalar sx, SkScalar sy) {
- addDraw(SCALE);
+ addDraw(SCALE);
addScalar(sx);
addScalar(sy);
validate();
@@ -92,14 +92,14 @@
}
bool SkPictureRecord::rotate(SkScalar degrees) {
- addDraw(ROTATE);
- addScalar(degrees);
+ addDraw(ROTATE);
+ addScalar(degrees);
validate();
return this->INHERITED::rotate(degrees);
}
bool SkPictureRecord::skew(SkScalar sx, SkScalar sy) {
- addDraw(SKEW);
+ addDraw(SKEW);
addScalar(sx);
addScalar(sy);
validate();
@@ -126,7 +126,7 @@
addDraw(CLIP_RECT);
addRect(rect);
addInt(op);
-
+
size_t offset = fWriter.size();
addInt(fRestoreOffsetStack.top());
fRestoreOffsetStack.top() = offset;
@@ -139,13 +139,13 @@
addDraw(CLIP_PATH);
addPath(path);
addInt(op);
-
+
size_t offset = fWriter.size();
addInt(fRestoreOffsetStack.top());
fRestoreOffsetStack.top() = offset;
-
+
validate();
-
+
if (fRecordFlags & SkPicture::kUsePathBoundsForClip_RecordingFlag) {
return this->INHERITED::clipRect(path.getBounds(), op);
} else {
@@ -154,14 +154,14 @@
}
bool SkPictureRecord::clipRegion(const SkRegion& region, SkRegion::Op op) {
- addDraw(CLIP_REGION);
+ addDraw(CLIP_REGION);
addRegion(region);
addInt(op);
-
+
size_t offset = fWriter.size();
addInt(fRestoreOffsetStack.top());
fRestoreOffsetStack.top() = offset;
-
+
validate();
return this->INHERITED::clipRegion(region, op);
}
@@ -250,10 +250,10 @@
addScalar(bounds.fBottom);
}
-void SkPictureRecord::drawText(const void* text, size_t byteLength, SkScalar x,
+void SkPictureRecord::drawText(const void* text, size_t byteLength, SkScalar x,
SkScalar y, const SkPaint& paint) {
bool fast = paint.canComputeFastBounds();
-
+
addDraw(fast ? DRAW_TEXT_TOP_BOTTOM : DRAW_TEXT);
addPaint(paint);
addText(text, byteLength);
@@ -265,7 +265,7 @@
validate();
}
-void SkPictureRecord::drawPosText(const void* text, size_t byteLength,
+void SkPictureRecord::drawPosText(const void* text, size_t byteLength,
const SkPoint pos[], const SkPaint& paint) {
size_t points = paint.countText(text, byteLength);
if (0 == points)
@@ -282,7 +282,7 @@
}
}
}
-
+
bool fast = canUseDrawH && paint.canComputeFastBounds();
if (fast) {
@@ -303,7 +303,7 @@
}
addScalar(pos[0].fY);
SkScalar* xptr = (SkScalar*)fWriter.reserve(points * sizeof(SkScalar));
- for (size_t index = 0; index < points; index++)
+ for (size_t index = 0; index < points; index++)
*xptr++ = pos[index].fX;
}
else {
@@ -322,14 +322,14 @@
size_t points = paint.countText(text, byteLength);
if (0 == points)
return;
-
+
bool fast = paint.canComputeFastBounds();
addDraw(fast ? DRAW_POS_TEXT_H_TOP_BOTTOM : DRAW_POS_TEXT_H);
addPaint(paint);
addText(text, byteLength);
addInt(points);
-
+
#ifdef SK_DEBUG_SIZE
size_t start = fWriter.size();
#endif
@@ -345,8 +345,8 @@
validate();
}
-void SkPictureRecord::drawTextOnPath(const void* text, size_t byteLength,
- const SkPath& path, const SkMatrix* matrix,
+void SkPictureRecord::drawTextOnPath(const void* text, size_t byteLength,
+ const SkPath& path, const SkMatrix* matrix,
const SkPaint& paint) {
addDraw(DRAW_TEXT_ON_PATH);
addPaint(paint);
@@ -417,9 +417,9 @@
}
///////////////////////////////////////////////////////////////////////////////
-
+
void SkPictureRecord::reset() {
- fPathHeap->safeUnref();
+ SkSafeUnref(fPathHeap);
fPathHeap = NULL;
fBitmaps.reset();
@@ -430,10 +430,10 @@
fShapes.safeUnrefAll();
fWriter.reset();
fHeap.reset();
-
+
fRestoreOffsetStack.setCount(1);
fRestoreOffsetStack.top() = 0;
-
+
fRCRecorder.reset();
fTFRecorder.reset();
}
@@ -486,7 +486,7 @@
fPointWrites++;
#endif
}
-
+
void SkPictureRecord::addPoints(const SkPoint pts[], int count) {
fWriter.writeMul4(pts, count * sizeof(SkPoint));
#ifdef SK_DEBUG_SIZE
@@ -539,7 +539,7 @@
int SkPictureRecord::find(SkTDArray<const SkFlatBitmap* >& bitmaps, const SkBitmap& bitmap) {
SkFlatBitmap* flat = SkFlatBitmap::Flatten(&fHeap, bitmap, fBitmapIndex,
&fRCRecorder);
- int index = SkTSearch<SkFlatData>((const SkFlatData**) bitmaps.begin(),
+ int index = SkTSearch<SkFlatData>((const SkFlatData**) bitmaps.begin(),
bitmaps.count(), (SkFlatData*) flat, sizeof(flat), &SkFlatData::Compare);
if (index >= 0) {
(void)fHeap.unalloc(flat);
@@ -554,7 +554,7 @@
if (matrix == NULL)
return 0;
SkFlatMatrix* flat = SkFlatMatrix::Flatten(&fHeap, *matrix, fMatrixIndex);
- int index = SkTSearch<SkFlatData>((const SkFlatData**) matrices.begin(),
+ int index = SkTSearch<SkFlatData>((const SkFlatData**) matrices.begin(),
matrices.count(), (SkFlatData*) flat, sizeof(flat), &SkFlatData::Compare);
if (index >= 0) {
(void)fHeap.unalloc(flat);
@@ -569,10 +569,10 @@
if (paint == NULL) {
return 0;
}
-
+
SkFlatPaint* flat = SkFlatPaint::Flatten(&fHeap, *paint, fPaintIndex,
&fRCRecorder, &fTFRecorder);
- int index = SkTSearch<SkFlatData>((const SkFlatData**) paints.begin(),
+ int index = SkTSearch<SkFlatData>((const SkFlatData**) paints.begin(),
paints.count(), (SkFlatData*) flat, sizeof(flat), &SkFlatData::Compare);
if (index >= 0) {
(void)fHeap.unalloc(flat);
@@ -586,7 +586,7 @@
int SkPictureRecord::find(SkTDArray<const SkFlatRegion* >& regions, const SkRegion& region) {
SkFlatRegion* flat = SkFlatRegion::Flatten(&fHeap, region, fRegionIndex);
- int index = SkTSearch<SkFlatData>((const SkFlatData**) regions.begin(),
+ int index = SkTSearch<SkFlatData>((const SkFlatData**) regions.begin(),
regions.count(), (SkFlatData*) flat, sizeof(flat), &SkFlatData::Compare);
if (index >= 0) {
(void)fHeap.unalloc(flat);
@@ -610,7 +610,7 @@
void SkPictureRecord::dumpPaints() {
int count = fPaints.count();
- for (int index = 0; index < count; index++)
+ for (int index = 0; index < count; index++)
fPaints[index]->dump();
}
#endif
@@ -638,7 +638,7 @@
int SkPictureRecord::bitmaps(size_t* size) const {
size_t result = 0;
int count = fBitmaps.count();
- for (int index = 0; index < count; index++)
+ for (int index = 0; index < count; index++)
result += sizeof(fBitmaps[index]) + fBitmaps[index]->size();
*size = result;
return count;
@@ -653,7 +653,7 @@
int SkPictureRecord::paints(size_t* size) const {
size_t result = 0;
int count = fPaints.count();
- for (int index = 0; index < count; index++)
+ for (int index = 0; index < count; index++)
result += sizeof(fPaints[index]) + fPaints[index]->size();
*size = result;
return count;
@@ -662,7 +662,7 @@
int SkPictureRecord::paths(size_t* size) const {
size_t result = 0;
int count = fPaths.count();
- for (int index = 0; index < count; index++)
+ for (int index = 0; index < count; index++)
result += sizeof(fPaths[index]) + fPaths[index]->size();
*size = result;
return count;
@@ -671,7 +671,7 @@
int SkPictureRecord::regions(size_t* size) const {
size_t result = 0;
int count = fRegions.count();
- for (int index = 0; index < count; index++)
+ for (int index = 0; index < count; index++)
result += sizeof(fRegions[index]) + fRegions[index]->size();
*size = result;
return count;
@@ -708,7 +708,7 @@
for (int index = 0; index < count; index++) {
const SkFlatMatrix* matrix = fMatrices[index];
SkASSERT(matrix);
- matrix->validate();
+ matrix->validate();
}
}
diff --git a/src/core/SkScalerContext.cpp b/src/core/SkScalerContext.cpp
index 983f1ad..f98969c 100644
--- a/src/core/SkScalerContext.cpp
+++ b/src/core/SkScalerContext.cpp
@@ -2,16 +2,16 @@
**
** Copyright 2006, The Android Open Source Project
**
-** Licensed under the Apache License, Version 2.0 (the "License");
-** you may not use this file except in compliance with the License.
-** You may obtain a copy of the License at
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
**
-** http://www.apache.org/licenses/LICENSE-2.0
+** http://www.apache.org/licenses/LICENSE-2.0
**
-** Unless required by applicable law or agreed to in writing, software
-** distributed under the License is distributed on an "AS IS" BASIS,
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-** See the License for the specific language governing permissions and
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
** limitations under the License.
*/
@@ -173,9 +173,9 @@
SkScalerContext::~SkScalerContext() {
SkDELETE(fNextContext);
- fPathEffect->safeUnref();
- fMaskFilter->safeUnref();
- fRasterizer->safeUnref();
+ SkSafeUnref(fPathEffect);
+ SkSafeUnref(fMaskFilter);
+ SkSafeUnref(fRasterizer);
}
static SkScalerContext* allocNextContext(const SkScalerContext::Rec& rec) {
@@ -309,7 +309,7 @@
glyph->fMaskFormat = 0;
return;
}
-
+
if (fRec.fFrameWidth > 0 || fPathEffect != NULL || fRasterizer != NULL) {
SkPath devPath, fillPath;
SkMatrix fillToDevMatrix;
@@ -333,7 +333,7 @@
// just use devPath
SkIRect ir;
devPath.getBounds().roundOut(&ir);
-
+
if (ir.isEmpty() || !ir.is16Bit()) {
goto SK_ERROR;
}
@@ -366,7 +366,7 @@
}
}
return;
-
+
SK_ERROR:
// draw nothing 'cause we failed
glyph->fLeft = 0;
@@ -410,11 +410,11 @@
if (fRasterizer) {
SkMask mask;
-
+
glyph->toMask(&mask);
mask.fFormat = SkMask::kA8_Format;
sk_bzero(glyph->fImage, mask.computeImageSize());
-
+
if (!fRasterizer->rasterize(fillPath, fillToDevMatrix, NULL,
fMaskFilter, &mask,
SkMask::kJustRenderImage_CreateMode)) {
@@ -472,7 +472,7 @@
int height = SkFastMin32(origGlyph.fHeight, dstM.fBounds.height());
int dstRB = origGlyph.rowBytes();
int srcRB = dstM.fRowBytes;
-
+
const uint8_t* src = (const uint8_t*)dstM.fImage;
uint8_t* dst = (uint8_t*)origGlyph.fImage;
@@ -492,7 +492,7 @@
SkMask::FreeImage(dstM.fImage);
}
}
-
+
// check to see if we should filter the alpha channel
if (NULL == fMaskFilter &&
@@ -504,7 +504,7 @@
{
uint8_t* dst = (uint8_t*)origGlyph.fImage;
unsigned rowBytes = origGlyph.rowBytes();
-
+
for (int y = origGlyph.fHeight - 1; y >= 0; --y)
{
for (int x = origGlyph.fWidth - 1; x >= 0; --x)
@@ -536,7 +536,7 @@
SkPath path;
this->getGlyphContext(glyph)->generatePath(glyph, &path);
-
+
if (fRec.fFrameWidth > 0 || fPathEffect != NULL)
{
// need the path in user-space, with only the point-size applied
@@ -573,14 +573,14 @@
stroker.strokePath(localPath, &outline);
localPath.swap(outline);
}
-
+
// now return stuff to the caller
if (fillToDevMatrix)
*fillToDevMatrix = matrix;
-
+
if (devPath)
localPath.transform(matrix, devPath);
-
+
if (fillPath)
fillPath->swap(localPath);
}
@@ -588,7 +588,7 @@
{
if (fillToDevMatrix)
fillToDevMatrix->reset();
-
+
if (devPath)
{
if (fillPath == NULL)
@@ -596,11 +596,11 @@
else
*devPath = path;
}
-
+
if (fillPath)
fillPath->swap(path);
}
-
+
if (devPath)
devPath->updateBoundsCache();
if (fillPath)
diff --git a/src/core/SkSpriteBlitter_ARGB32.cpp b/src/core/SkSpriteBlitter_ARGB32.cpp
index 01ee9f1..df9e2a1 100644
--- a/src/core/SkSpriteBlitter_ARGB32.cpp
+++ b/src/core/SkSpriteBlitter_ARGB32.cpp
@@ -2,16 +2,16 @@
**
** Copyright 2006, The Android Open Source Project
**
-** Licensed under the Apache License, Version 2.0 (the "License");
-** you may not use this file except in compliance with the License.
-** You may obtain a copy of the License at
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
**
-** http://www.apache.org/licenses/LICENSE-2.0
+** http://www.apache.org/licenses/LICENSE-2.0
**
-** Unless required by applicable law or agreed to in writing, software
-** distributed under the License is distributed on an "AS IS" BASIS,
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-** See the License for the specific language governing permissions and
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
** limitations under the License.
*/
@@ -41,7 +41,7 @@
fProc32 = SkBlitRow::Factory32(flags32);
fAlpha = alpha;
}
-
+
virtual void blitRect(int x, int y, int width, int height) {
SkASSERT(width > 0 && height > 0);
SK_RESTRICT uint32_t* dst = fDevice->getAddr32(x, y);
@@ -62,7 +62,7 @@
private:
SkBlitRow::Proc32 fProc32;
U8CPU fAlpha;
-
+
typedef SkSpriteBlitter INHERITED;
};
@@ -73,11 +73,11 @@
Sprite_D32_XferFilter(const SkBitmap& source, const SkPaint& paint)
: SkSpriteBlitter(source) {
fColorFilter = paint.getColorFilter();
- fColorFilter->safeRef();
-
+ SkSafeRef(fColorFilter);
+
fXfermode = paint.getXfermode();
- fXfermode->safeRef();
-
+ SkSafeRef(fXfermode);
+
fBufferSize = 0;
fBuffer = NULL;
@@ -88,21 +88,21 @@
if (!source.isOpaque()) {
flags32 |= SkBlitRow::kSrcPixelAlpha_Flag32;
}
-
+
fProc32 = SkBlitRow::Factory32(flags32);
fAlpha = paint.getAlpha();
}
-
+
virtual ~Sprite_D32_XferFilter() {
delete[] fBuffer;
- fXfermode->safeUnref();
- fColorFilter->safeUnref();
+ SkSafeUnref(fXfermode);
+ SkSafeUnref(fColorFilter);
}
-
+
virtual void setup(const SkBitmap& device, int left, int top,
const SkPaint& paint) {
this->INHERITED::setup(device, left, top, paint);
-
+
int width = device.width();
if (width > fBufferSize) {
fBufferSize = width;
@@ -142,12 +142,12 @@
do {
const SkPMColor* tmp = src;
-
+
if (NULL != colorFilter) {
colorFilter->filterSpan(src, width, fBuffer);
tmp = fBuffer;
}
-
+
if (NULL != xfermode) {
xfermode->xfer32(dst, tmp, width, NULL);
} else {
@@ -158,7 +158,7 @@
src = (const SK_RESTRICT uint32_t*)((const char*)src + srcRB);
} while (--height != 0);
}
-
+
private:
typedef Sprite_D32_XferFilter INHERITED;
};
@@ -166,7 +166,7 @@
static void fillbuffer(SK_RESTRICT SkPMColor dst[],
const SK_RESTRICT SkPMColor16 src[], int count) {
SkASSERT(count > 0);
-
+
do {
*dst++ = SkPixel4444ToPixel32(*src++);
} while (--count != 0);
@@ -176,7 +176,7 @@
public:
Sprite_D32_S4444_XferFilter(const SkBitmap& source, const SkPaint& paint)
: Sprite_D32_XferFilter(source, paint) {}
-
+
virtual void blitRect(int x, int y, int width, int height) {
SkASSERT(width > 0 && height > 0);
SK_RESTRICT SkPMColor* dst = fDevice->getAddr32(x, y);
@@ -190,7 +190,7 @@
do {
fillbuffer(buffer, src, width);
-
+
if (NULL != colorFilter) {
colorFilter->filterSpan(buffer, width, buffer);
}
@@ -199,12 +199,12 @@
} else {
fProc32(dst, buffer, width, fAlpha);
}
-
+
dst = (SK_RESTRICT SkPMColor*)((char*)dst + dstRB);
src = (const SK_RESTRICT SkPMColor16*)((const char*)src + srcRB);
} while (--height != 0);
}
-
+
private:
typedef Sprite_D32_XferFilter INHERITED;
};
@@ -223,7 +223,7 @@
class Sprite_D32_S4444_Opaque : public SkSpriteBlitter {
public:
Sprite_D32_S4444_Opaque(const SkBitmap& source) : SkSpriteBlitter(source) {}
-
+
virtual void blitRect(int x, int y, int width, int height) {
SkASSERT(width > 0 && height > 0);
SK_RESTRICT SkPMColor* dst = fDevice->getAddr32(x, y);
@@ -231,7 +231,7 @@
y - fTop);
unsigned dstRB = fDevice->rowBytes();
unsigned srcRB = fSource->rowBytes();
-
+
do {
src_row(dst, src, width);
dst = (SK_RESTRICT SkPMColor*)((char*)dst + dstRB);
@@ -252,7 +252,7 @@
class Sprite_D32_S4444 : public SkSpriteBlitter {
public:
Sprite_D32_S4444(const SkBitmap& source) : SkSpriteBlitter(source) {}
-
+
virtual void blitRect(int x, int y, int width, int height) {
SkASSERT(width > 0 && height > 0);
SK_RESTRICT SkPMColor* dst = fDevice->getAddr32(x, y);
@@ -260,7 +260,7 @@
y - fTop);
unsigned dstRB = fDevice->rowBytes();
unsigned srcRB = fSource->rowBytes();
-
+
do {
srcover_row(dst, src, width);
dst = (SK_RESTRICT SkPMColor*)((char*)dst + dstRB);
diff --git a/src/effects/SkBlurDrawLooper.cpp b/src/effects/SkBlurDrawLooper.cpp
index 2af6097..a3c4eac 100644
--- a/src/effects/SkBlurDrawLooper.cpp
+++ b/src/effects/SkBlurDrawLooper.cpp
@@ -11,12 +11,12 @@
SkASSERT(flags <= kAll_BlurFlag);
if (radius > 0)
{
- uint32_t blurFlags = flags & kIgnoreTransform_BlurFlag ?
- SkBlurMaskFilter::kIgnoreTransform_BlurFlag :
+ uint32_t blurFlags = flags & kIgnoreTransform_BlurFlag ?
+ SkBlurMaskFilter::kIgnoreTransform_BlurFlag :
SkBlurMaskFilter::kNone_BlurFlag;
fBlur = SkBlurMaskFilter::Create(radius,
- SkBlurMaskFilter::kNormal_BlurStyle,
+ SkBlurMaskFilter::kNormal_BlurStyle,
blurFlags);
}
else
@@ -34,7 +34,7 @@
SkBlurDrawLooper::~SkBlurDrawLooper()
{
- fBlur->safeUnref();
+ SkSafeUnref(fBlur);
}
void SkBlurDrawLooper::flatten(SkFlattenableWriteBuffer& buffer)
diff --git a/src/effects/SkGradientShader.cpp b/src/effects/SkGradientShader.cpp
index 81a8d68..64a78c7 100644
--- a/src/effects/SkGradientShader.cpp
+++ b/src/effects/SkGradientShader.cpp
@@ -169,7 +169,7 @@
fCacheAlpha = 256; // init to a value that paint.getAlpha() can't return
fMapper = mapper;
- mapper->safeRef();
+ SkSafeRef(mapper);
SkASSERT((unsigned)mode < SkShader::kTileModeCount);
SkASSERT(SkShader::kTileModeCount == SK_ARRAY_COUNT(gTileProcs));
@@ -321,7 +321,7 @@
if (fOrigColors != fStorage) {
sk_free(fOrigColors);
}
- fMapper->safeUnref();
+ SkSafeUnref(fMapper);
}
void Gradient_Shader::flatten(SkFlattenableWriteBuffer& buffer) {
diff --git a/src/effects/SkLayerRasterizer.cpp b/src/effects/SkLayerRasterizer.cpp
index 5aa883d..168fbe9 100644
--- a/src/effects/SkLayerRasterizer.cpp
+++ b/src/effects/SkLayerRasterizer.cpp
@@ -2,16 +2,16 @@
**
** Copyright 2006, The Android Open Source Project
**
-** Licensed under the Apache License, Version 2.0 (the "License");
-** you may not use this file except in compliance with the License.
-** You may obtain a copy of the License at
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
**
-** http://www.apache.org/licenses/LICENSE-2.0
+** http://www.apache.org/licenses/LICENSE-2.0
**
-** Unless required by applicable law or agreed to in writing, software
-** distributed under the License is distributed on an "AS IS" BASIS,
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-** See the License for the specific language governing permissions and
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
** limitations under the License.
*/
@@ -59,7 +59,7 @@
SkLayerRasterizer_Rec* rec;
bounds->set(SK_MaxS32, SK_MaxS32, SK_MinS32, SK_MinS32);
-
+
while ((rec = (SkLayerRasterizer_Rec*)iter.next()) != NULL)
{
const SkPaint& paint = rec->fPaint;
@@ -117,13 +117,13 @@
}
if (SkMask::kJustComputeBounds_CreateMode != mode)
- {
+ {
SkBitmap device;
SkDraw draw;
SkMatrix translatedMatrix; // this translates us to our local pixels
SkMatrix drawMatrix; // this translates the path by each layer's offset
SkRegion rectClip;
-
+
rectClip.setRect(0, 0, mask->fBounds.width(), mask->fBounds.height());
translatedMatrix = matrix;
@@ -138,7 +138,7 @@
draw.fClip = &rectClip;
// we set the matrixproc in the loop, as the matrix changes each time (potentially)
draw.fBounder = NULL;
-
+
SkDeque::Iter iter(fLayers);
SkLayerRasterizer_Rec* rec;
@@ -158,7 +158,7 @@
paint->setAntiAlias(buffer.readBool());
paint->setStyle((SkPaint::Style)buffer.readU8());
paint->setAlpha(buffer.readU8());
-
+
if (paint->getStyle() != SkPaint::kFill_Style)
{
paint->setStrokeWidth(buffer.readScalar());
@@ -167,10 +167,10 @@
paint->setStrokeJoin((SkPaint::Join)buffer.readU8());
}
- paint->setMaskFilter((SkMaskFilter*)buffer.readFlattenable())->safeUnref();
- paint->setPathEffect((SkPathEffect*)buffer.readFlattenable())->safeUnref();
- paint->setRasterizer((SkRasterizer*)buffer.readFlattenable())->safeUnref();
- paint->setXfermode((SkXfermode*)buffer.readFlattenable())->safeUnref();
+ SkSafeUnref(paint->setMaskFilter((SkMaskFilter*)buffer.readFlattenable()));
+ SkSafeUnref(paint->setPathEffect((SkPathEffect*)buffer.readFlattenable()));
+ SkSafeUnref(paint->setRasterizer((SkRasterizer*)buffer.readFlattenable()));
+ SkSafeUnref(paint->setXfermode((SkXfermode*)buffer.readFlattenable()));
}
static void paint_write(const SkPaint& paint, SkFlattenableWriteBuffer& buffer)
@@ -178,7 +178,7 @@
buffer.writeBool(paint.isAntiAlias());
buffer.write8(paint.getStyle());
buffer.write8(paint.getAlpha());
-
+
if (paint.getStyle() != SkPaint::kFill_Style)
{
buffer.writeScalar(paint.getStrokeWidth());
@@ -186,7 +186,7 @@
buffer.write8(paint.getStrokeCap());
buffer.write8(paint.getStrokeJoin());
}
-
+
buffer.writeFlattenable(paint.getMaskFilter());
buffer.writeFlattenable(paint.getPathEffect());
buffer.writeFlattenable(paint.getRasterizer());
@@ -197,11 +197,11 @@
: SkRasterizer(buffer), fLayers(sizeof(SkLayerRasterizer_Rec))
{
int count = buffer.readS32();
-
+
for (int i = 0; i < count; i++)
{
SkLayerRasterizer_Rec* rec = (SkLayerRasterizer_Rec*)fLayers.push_back();
-
+
#if 0
new (&rec->fPaint) SkPaint(buffer);
#else
diff --git a/src/images/SkImageDecoder.cpp b/src/images/SkImageDecoder.cpp
index 768d671..347a6da 100644
--- a/src/images/SkImageDecoder.cpp
+++ b/src/images/SkImageDecoder.cpp
@@ -42,9 +42,9 @@
}
SkImageDecoder::~SkImageDecoder() {
- fPeeker->safeUnref();
- fChooser->safeUnref();
- fAllocator->safeUnref();
+ SkSafeUnref(fPeeker);
+ SkSafeUnref(fChooser);
+ SkSafeUnref(fAllocator);
}
SkImageDecoder::Format SkImageDecoder::getFormat() const {
diff --git a/src/images/SkImageRef.cpp b/src/images/SkImageRef.cpp
index 60e01c6..16c2820 100644
--- a/src/images/SkImageRef.cpp
+++ b/src/images/SkImageRef.cpp
@@ -40,16 +40,16 @@
#endif
fStream->unref();
- fFactory->safeUnref();
+ SkSafeUnref(fFactory);
}
bool SkImageRef::getInfo(SkBitmap* bitmap) {
SkAutoMutexAcquire ac(gImageRefMutex);
-
+
if (!this->prepareBitmap(SkImageDecoder::kDecodeBounds_Mode)) {
return false;
}
-
+
SkASSERT(SkBitmap::kNo_Config != fBitmap.config());
if (bitmap) {
bitmap->setConfig(fBitmap.config(), fBitmap.width(), fBitmap.height());
@@ -77,7 +77,7 @@
if (fErrorInDecoding) {
return false;
}
-
+
/* As soon as we really know our config, we record it, so that on
subsequent calls to the codec, we are sure we will always get the same
result.
@@ -85,7 +85,7 @@
if (SkBitmap::kNo_Config != fBitmap.config()) {
fConfig = fBitmap.config();
}
-
+
if (NULL != fBitmap.getPixels() ||
(SkBitmap::kNo_Config != fBitmap.config() &&
SkImageDecoder::kDecodeBounds_Mode == mode)) {
diff --git a/src/pdf/SkPDFPage.cpp b/src/pdf/SkPDFPage.cpp
index 98d7682..1c470c7 100644
--- a/src/pdf/SkPDFPage.cpp
+++ b/src/pdf/SkPDFPage.cpp
@@ -73,7 +73,7 @@
SkTDArray<SkPDFDict*> curNodes;
curNodes.setReserve(pages.count());
for (int i = 0; i < pages.count(); i++) {
- pages[i]->safeRef();
+ SkSafeRef(pages[i]);
curNodes.push(pages[i]);
}
@@ -107,7 +107,7 @@
pageTree->push(curNodes[i]); // Transfer reference.
catalog->addObject(curNodes[i], false);
} else {
- curNodes[i]->safeUnref();
+ SkSafeUnref(curNodes[i]);
}
}
diff --git a/src/pdf/SkPDFTypes.cpp b/src/pdf/SkPDFTypes.cpp
index cc1735e..209a2cf 100644
--- a/src/pdf/SkPDFTypes.cpp
+++ b/src/pdf/SkPDFTypes.cpp
@@ -323,8 +323,8 @@
void SkPDFDict::clear() {
for (int i = 0; i < fValue.count(); i++) {
- fValue[i].key->safeUnref();
- fValue[i].value->safeUnref();
+ SkSafeUnref(fValue[i].key);
+ SkSafeUnref(fValue[i].value);
}
fValue.reset();
}
diff --git a/src/utils/SkDumpCanvas.cpp b/src/utils/SkDumpCanvas.cpp
index 4ff7a50..223a4f7 100644
--- a/src/utils/SkDumpCanvas.cpp
+++ b/src/utils/SkDumpCanvas.cpp
@@ -1,5 +1,5 @@
#include "SkDumpCanvas.h"
-#include "SkPicture.h"
+#include "SkPicture.h"
#include "SkPixelRef.h"
#include "SkString.h"
#include <stdarg.h>
@@ -105,7 +105,7 @@
static void toString(const SkBitmap& bm, SkString* str) {
str->printf("bitmap:[%d %d] %s", bm.width(), bm.height(),
toString(bm.config()));
-
+
SkPixelRef* pr = bm.pixelRef();
if (NULL == pr) {
// show null or the explicit pixel address (rare)
@@ -140,7 +140,7 @@
///////////////////////////////////////////////////////////////////////////////
SkDumpCanvas::SkDumpCanvas(Dumper* dumper) : fNestLevel(0) {
- dumper->safeRef();
+ SkSafeRef(dumper);
fDumper = dumper;
static const int WIDE_OPEN = 16384;
@@ -151,7 +151,7 @@
}
SkDumpCanvas::~SkDumpCanvas() {
- fDumper->safeUnref();
+ SkSafeUnref(fDumper);
}
void SkDumpCanvas::dump(Verb verb, const SkPaint* paint,
@@ -163,7 +163,7 @@
va_start(args, format);
vsnprintf(buffer, BUFFER_SIZE, format, args);
va_end(args);
-
+
if (fDumper) {
fDumper->dump(this, verb, buffer, paint);
}
@@ -420,7 +420,7 @@
tab.append("\t");
}
msg.printf("%s%s", tab.c_str(), str);
-
+
if (p) {
msg.appendf(" color:0x%08X flags:%X", p->getColor(), p->getFlags());
appendFlattenable(&msg, p->getShader(), "shader");
@@ -429,13 +429,13 @@
appendFlattenable(&msg, p->getMaskFilter(), "maskFilter");
appendFlattenable(&msg, p->getPathEffect(), "pathEffect");
appendFlattenable(&msg, p->getColorFilter(), "filter");
-
+
if (SkDumpCanvas::kDrawText_Verb == verb) {
msg.appendf(" textSize:%g", SkScalarToFloat(p->getTextSize()));
appendPtr(&msg, p->getTypeface(), "typeface");
}
}
-
+
fProc(msg.c_str(), fRefcon);
}
diff --git a/src/utils/SkProxyCanvas.cpp b/src/utils/SkProxyCanvas.cpp
index d462d01..4336181 100644
--- a/src/utils/SkProxyCanvas.cpp
+++ b/src/utils/SkProxyCanvas.cpp
@@ -1,13 +1,13 @@
#include "SkProxyCanvas.h"
SkProxyCanvas::SkProxyCanvas(SkCanvas* proxy) : fProxy(proxy) {
- fProxy->safeRef();
+ SkSafeRef(fProxy);
}
SkProxyCanvas::~SkProxyCanvas() {
- fProxy->safeUnref();
+ SkSafeUnref(fProxy);
}
-
+
void SkProxyCanvas::setProxy(SkCanvas* proxy) {
SkRefCnt_SafeAssign(fProxy, proxy);
}
diff --git a/tests/Test.cpp b/tests/Test.cpp
index 4bbe83a..2bcd3e0 100644
--- a/tests/Test.cpp
+++ b/tests/Test.cpp
@@ -42,7 +42,7 @@
Test::Test() : fReporter(NULL) {}
Test::~Test() {
- fReporter->safeUnref();
+ SkSafeUnref(fReporter);
}
void Test::setReporter(Reporter* r) {