static SkCanvas* MakeCanvas(const SkIRect& bounds) {
SkBitmap bm;
- bm.setConfig(SkBitmap::kARGB_8888_Config, bounds.width(), bounds.height());
- bm.allocPixels();
+ bm.allocN32Pixels(bounds.width(), bounds.height());
bm.eraseColor(SK_ColorTRANSPARENT);
SkCanvas* canvas = new SkCanvas(bm);
static SkShader* make_bg_shader() {
SkBitmap bm;
- bm.setConfig(SkBitmap::kARGB_8888_Config, 2, 2);
- bm.allocPixels();
+ bm.allocN32Pixels(2, 2);
*bm.getAddr32(0, 0) = *bm.getAddr32(1, 1) = 0xFFFFFFFF;
*bm.getAddr32(1, 0) = *bm.getAddr32(0, 1) = SkPackARGB32(0xFF, 0xCC,
0xCC, 0xCC);
static SkBitmap make_bm() {
SkBitmap bm;
- bm.setConfig(SkBitmap::kARGB_8888_Config, WW, HH);
- bm.allocPixels();
+ bm.allocN32Pixels(WW, HH);
bm.eraseColor(SK_ColorTRANSPARENT);
return bm;
}
void make_checkerboard(int width, int height) {
SkASSERT(width % 2 == 0);
SkASSERT(height % 2 == 0);
- fCheckerboard.setConfig(SkBitmap::kARGB_8888_Config, width, height);
- fCheckerboard.allocPixels();
- SkAutoLockPixels lock(fCheckerboard);
+ fCheckerboard.allocN32Pixels(width, height);
for (int y = 0; y < height; y += 2) {
SkPMColor* s = fCheckerboard.getAddr32(0, y);
for (int x = 0; x < width; x += 2) {
canvas->drawRect(rect, paint);
SkBitmap bmp;
- bmp.setConfig(SkBitmap::kARGB_8888_Config, 2, 2);
- bmp.allocPixels();
- bmp.lockPixels();
+ bmp.allocN32Pixels(2, 2);
uint32_t* pixels = reinterpret_cast<uint32_t*>(bmp.getPixels());
pixels[0] = SkPackARGB32(0xFF, 0xFF, 0x00, 0x00);
pixels[1] = SkPackARGB32(0xFF, 0x00, 0xFF, 0x00);
pixels[2] = SkPackARGB32(0x80, 0x00, 0x00, 0x00);
pixels[3] = SkPackARGB32(0xFF, 0x00, 0x00, 0xFF);
- bmp.unlockPixels();
pt.set(30 * SK_Scalar1, 30 * SK_Scalar1);
m.mapPoints(&pt, 1);
SkShader* shader = SkShader::CreateBitmapShader(
void setupBitmap(SkBitmap* bm) {
SkASSERT(bm);
static const int SIZE = 64;
- bm->setConfig(SkBitmap::kARGB_8888_Config, SIZE, SIZE);
- bm->allocPixels();
+ bm->allocN32Pixels(SIZE, SIZE);
SkCanvas canvas(*bm);
SkPaint paint;
static const int PIXEL_SIZE_4444 = SLIDE_SIZE / 16;
static void init_bitmap(SkBitmap::Config config, SkBitmap* bitmap) {
- bitmap->setConfig(config, SLIDE_SIZE, SLIDE_SIZE);
- bitmap->allocPixels();
+ bitmap->allocConfigPixels(config, SLIDE_SIZE, SLIDE_SIZE);
bitmap->eraseColor(SK_ColorWHITE);
}
#include "SkShader.h"
static void make_bitmap(SkBitmap* bitmap) {
- bitmap->setConfig(SkBitmap::kARGB_8888_Config, 64, 64);
- bitmap->allocPixels();
+ bitmap->allocN32Pixels(64, 64);
SkCanvas canvas(*bitmap);
};
- bitmap->setConfig(SkBitmap::kARGB_8888_Config, gXSize, gYSize);
- bitmap->allocPixels();
-
- SkAutoLockPixels lock(*bitmap);
+ bitmap->allocN32Pixels(gXSize, gYSize);
for (int y = 0; y < gYSize; y++) {
for (int x = 0; x < gXSize; x++) {
*bitmap->getAddr32(x, y) = textureData[x][y];
static const int gYSize = 4096;
static const int gBorderWidth = 10;
- bitmap->setConfig(SkBitmap::kARGB_8888_Config, gXSize, gYSize);
- bitmap->allocPixels();
-
- SkAutoLockPixels lock(*bitmap);
+ bitmap->allocN32Pixels(gXSize, gYSize);
for (int y = 0; y < gYSize; ++y) {
for (int x = 0; x < gXSize; ++x) {
if (x <= gBorderWidth || x >= gXSize-gBorderWidth ||
#include "SkCanvas.h"
static void make_bm(SkBitmap* bm) {
- bm->setConfig(SkBitmap::kARGB_8888_Config, 60, 60);
- bm->allocPixels();
+ bm->allocN32Pixels(60, 60);
bm->eraseColor(0);
SkCanvas canvas(*bm);
pAlphaGray.setColor(0x66888888);
// Prepare bitmap, and a canvas that draws into it.
- bitmap->reset();
- bitmap->setConfig(SkBitmap::kARGB_8888_Config,
- quarterWidth*4, quarterHeight*4);
- bitmap->allocPixels();
+ bitmap->allocN32Pixels(quarterWidth*4, quarterHeight*4);
SkCanvas canvas(*bitmap);
SkScalar w = SkIntToScalar(quarterWidth);
SkPaint bluePaint;
bluePaint.setColor(SK_ColorBLUE);
- bm->setConfig(SkBitmap::kARGB_8888_Config, 20, 20);
- bm->allocPixels();
+ bm->allocN32Pixels(20, 20);
bm->eraseColor(SK_ColorRED);
SkCanvas canvas(*bm);
SkPaint circlePaint;
circlePaint.setColor(SK_ColorBLACK);
- bm->setConfig(SkBitmap::kA8_Config, 20, 20);
- bm->allocPixels();
+ bm->allocConfigPixels(SkBitmap::kA8_Config, 20, 20);
bm->eraseColor(SK_ColorTRANSPARENT);
SkCanvas canvas(*bm);
}
void makeBitmap() {
- fBitmap.setConfig(SkBitmap::kARGB_8888_Config, 100, 100);
- fBitmap.allocPixels();
+ fBitmap.allocN32Pixels(100, 100);
SkBitmapDevice device(fBitmap);
SkCanvas canvas(&device);
canvas.clear(0x00000000);
static const SkPMColor kBlack = SkPreMultiplyColor(SK_ColorBLACK);
static const SkPMColor kWhite = SkPreMultiplyColor(SK_ColorWHITE);
- result->setConfig(SkBitmap::kARGB_8888_Config, width, height, 0,
- kOpaque_SkAlphaType);
- result->allocPixels();
- SkAutoLockPixels lock(*result);
+ result->allocN32Pixels(width, height, true);
SkPMColor* scanline = result->getAddr32(0, 0);
for (int x = 0; x < width; ++x) {
static SkBitmap create_bitmap() {
SkBitmap bmp;
- bmp.setConfig(SkBitmap::kARGB_8888_Config, 2, 2);
- bmp.allocPixels();
- bmp.lockPixels();
+ bmp.allocN32Pixels(2, 2);
uint32_t* pixels = reinterpret_cast<uint32_t*>(bmp.getPixels());
pixels[0] = SkPreMultiplyColor(SK_ColorRED);
pixels[1] = SkPreMultiplyColor(SK_ColorGREEN);
pixels[2] = SkPreMultiplyColor(SK_ColorBLACK);
pixels[3] = SkPreMultiplyColor(SK_ColorBLUE);
- bmp.unlockPixels();
return bmp;
}
SkBitmap createSolidBitmap(int width, int height) {
SkBitmap bm;
- bm.setConfig(SkBitmap::kARGB_8888_Config, width, height);
- bm.allocPixels();
+ bm.allocN32Pixels(width, height);
SkCanvas canvas(bm);
canvas.clear(0x0);
for (int y = 0; y < height; ++y) {
// creates a bitmap with shades of transparent gray.
SkBitmap createTransparentBitmap(int width, int height) {
SkBitmap bm;
- bm.setConfig(SkBitmap::kARGB_8888_Config, width, height);
- bm.allocPixels();
+ bm.allocN32Pixels(width, height);
SkCanvas canvas(bm);
canvas.clear(0x0);
virtual void onDraw(SkCanvas* originalCanvas) {
SkISize size = this->getISize();
SkBitmap bitmap;
- bitmap.setConfig(SkBitmap::kARGB_8888_Config, size.width(), size.height());
- bitmap.allocPixels();
+ bitmap.allocN32Pixels(size.width(), size.height());
SkDeviceProperties properties = SkDeviceProperties::Make(
SkDeviceProperties::Geometry::Make(SkDeviceProperties::Geometry::kVertical_Orientation,
SkDeviceProperties::Geometry::kBGR_Layout),
}
void make_bitmap() {
- fBitmap.setConfig(SkBitmap::kARGB_8888_Config, 80, 80);
- fBitmap.allocPixels();
+ fBitmap.allocN32Pixels(80, 80);
SkBitmapDevice device(fBitmap);
SkCanvas canvas(&device);
canvas.clear(0x00000000);
}
void make_checkerboard(SkBitmap* bitmap, int w, int h) {
- bitmap->setConfig(SkBitmap::kARGB_8888_Config, w, h);
- bitmap->allocPixels();
+ bitmap->allocN32Pixels(w, h);
SkBitmapDevice device(*bitmap);
SkCanvas canvas(&device);
canvas.clear(0x00000000);
float fTextSize;
virtual void make_bitmap() SK_OVERRIDE {
- fBM.setConfig(SkBitmap::kARGB_8888_Config, int(fTextSize * 8), int(fTextSize * 6));
- fBM.allocPixels();
+ fBM.allocN32Pixels(int(fTextSize * 8), int(fTextSize * 6));
SkCanvas canvas(fBM);
canvas.drawColor(SK_ColorWHITE);
int fNumChecks;
virtual void make_bitmap() SK_OVERRIDE {
- fBM.setConfig(SkBitmap::kARGB_8888_Config, fSize, fSize);
- fBM.allocPixels();
- SkAutoLockPixels lock(fBM);
+ fBM.allocN32Pixels(fSize, fSize);
for (int y = 0; y < fSize; ++y) {
for (int x = 0; x < fSize; ++x) {
SkPMColor* s = fBM.getAddr32(x, y);
SkImageDecoder::kDecodePixels_Mode);
SkDELETE(codec);
} else {
- fBM.setConfig(SkBitmap::kARGB_8888_Config, 1, 1);
- fBM.allocPixels();
+ fBM.allocN32Pixels(1, 1);
*(fBM.getAddr32(0,0)) = 0xFF0000FF; // red == bad
}
fSize = fBM.height();
static SkBitmap make_chessbm(int w, int h) {
SkBitmap bm;
- bm.setConfig(SkBitmap::kARGB_8888_Config , w, h);
- bm.allocPixels();
+ bm.allocN32Pixels(w, h);
for (int y = 0; y < bm.height(); y++) {
uint32_t* p = bm.getAddr32(0, y);
}
static void makebm(SkBitmap* bm, SkBitmap::Config config, int w, int h) {
- bm->setConfig(config, w, h);
- bm->allocPixels();
+ bm->allocConfigPixels(config, w, h);
bm->eraseColor(SK_ColorTRANSPARENT);
SkCanvas canvas(*bm);
r.roundOut(&bounds);
SkBitmap bm;
- bm.setConfig(SkBitmap::kARGB_8888_Config, bounds.width(), bounds.height());
- bm.allocPixels();
+ bm.allocN32Pixels(bounds.width(), bounds.height());
bm.eraseColor(SK_ColorTRANSPARENT);
SkCanvas c(bm);
draw_path(&c, r, NULL);
r.roundOut(&bounds);
SkBitmap bm;
- bm.setConfig(SkBitmap::kARGB_8888_Config, bounds.width(), bounds.height());
- bm.allocPixels();
+ bm.allocN32Pixels(bounds.width(), bounds.height());
bm.eraseColor(SK_ColorRED);
SkCanvas c(bm);
static void create_bitmap(SkBitmap* bitmap) {
const int W = 100;
const int H = 100;
- bitmap->setConfig(SkBitmap::kARGB_8888_Config, W, H);
- bitmap->allocPixels();
+ bitmap->allocN32Pixels(W, H);
SkCanvas canvas(*bitmap);
canvas.drawColor(SK_ColorRED);
}
void makeBitmap() SK_OVERRIDE {
- fBM.setConfig(SkBitmap::kARGB_8888_Config, int(fTextSize * 8), int(fTextSize * 6));
- fBM.allocPixels();
+ fBM.allocN32Pixels(int(fTextSize * 8), int(fTextSize * 6));
SkCanvas canvas(fBM);
canvas.drawColor(SK_ColorWHITE);
}
void makeBitmap() SK_OVERRIDE {
- fBM.setConfig(SkBitmap::kARGB_8888_Config, fSize, fSize);
- fBM.allocPixels();
- SkAutoLockPixels lock(fBM);
+ fBM.allocN32Pixels(fSize, fSize);
for (int y = 0; y < fSize; y ++) {
for (int x = 0; x < fSize; x ++) {
SkPMColor* s = fBM.getAddr32(x, y);
SkImageDecoder::kDecodePixels_Mode);
SkDELETE(codec);
} else {
- fBM.setConfig(SkBitmap::kARGB_8888_Config, 1, 1);
- fBM.allocPixels();
+ fBM.allocN32Pixels(1, 1);
*(fBM.getAddr32(0,0)) = 0xFF0000FF; // red == bad
}
fSize = fBM.height();
const SkBitmap& getBitmap() {
if (NULL == fBM) {
fBM = new SkBitmap;
- fBM->setConfig(SkBitmap::kARGB_8888_Config, W, H);
- fBM->allocPixels();
+ fBM->allocN32Pixels(W, H);
fBM->eraseColor(SK_ColorWHITE);
const SkColor colors[] = {
*/
static void setup_bitmap(const ConfigData& gRec, SkISize& size,
SkBitmap* bitmap) {
- bitmap->setConfig(gRec.fConfig, size.width(), size.height());
- bitmap->allocPixels();
+ bitmap->allocConfigPixels(gRec.fConfig, size.width(), size.height());
bitmap->eraseColor(SK_ColorTRANSPARENT);
}
static SkShader* make_bg_shader() {
SkBitmap bm;
- bm.setConfig(SkBitmap::kARGB_8888_Config, 2, 2);
- bm.allocPixels();
+ bm.allocN32Pixels(2, 2);
*bm.getAddr32(0, 0) = *bm.getAddr32(1, 1) = 0xFFFFFFFF;
*bm.getAddr32(1, 0) = *bm.getAddr32(0, 1) = SkPackARGB32(0xFF, 0xCC, 0xCC, 0xCC);
r.roundOut(&bounds);
SkBitmap bm;
- bm.setConfig(SkBitmap::kARGB_8888_Config, bounds.width(), bounds.height());
- bm.allocPixels();
+ bm.allocN32Pixels(bounds.width(), bounds.height());
bm.eraseColor(SK_ColorTRANSPARENT);
SkCanvas c(bm);
draw_path(&c, r, NULL);
r.roundOut(&bounds);
SkBitmap bm;
- bm.setConfig(SkBitmap::kARGB_8888_Config, bounds.width(), bounds.height());
- bm.allocPixels();
+ bm.allocN32Pixels(bounds.width(), bounds.height());
bm.eraseColor(SK_ColorTRANSPARENT);
SkCanvas c(bm);
draw_path(&c, r, NULL);
r.roundOut(&bounds);
SkBitmap bm;
- bm.setConfig(SkBitmap::kARGB_8888_Config, bounds.width(), bounds.height());
- bm.allocPixels();
+ bm.allocN32Pixels(bounds.width(), bounds.height());
bm.eraseColor(SK_ColorTRANSPARENT);
SkCanvas c(bm);
draw_path(&c, r, NULL);
r.roundOut(&bounds);
SkBitmap bm;
- bm.setConfig(SkBitmap::kARGB_8888_Config, bounds.width(), bounds.height());
- bm.allocPixels();
+ bm.allocN32Pixels(bounds.width(), bounds.height());
bm.eraseColor(SK_ColorRED);
SkCanvas c(bm);
}
void make_bitmap() {
- fBitmap.setConfig(SkBitmap::kARGB_8888_Config, 100, 100);
- fBitmap.allocPixels();
+ fBitmap.allocN32Pixels(100, 100);
SkBitmapDevice device(fBitmap);
SkCanvas canvas(&device);
canvas.clear(0x00000000);
}
void make_checkerboard() {
- fCheckerboard.setConfig(SkBitmap::kARGB_8888_Config, 64, 64);
- fCheckerboard.allocPixels();
+ fCheckerboard.allocN32Pixels(64, 64);
SkBitmapDevice device(fCheckerboard);
SkCanvas canvas(&device);
canvas.clear(0x00000000);
SkScalar x = SkIntToScalar(width / 2);
SkScalar y = SkIntToScalar(height / 2);
SkScalar radius = SkScalarMul(SkMinScalar(x, y), SkIntToScalar(4) / SkIntToScalar(5));
- fGradientCircle.setConfig(SkBitmap::kARGB_8888_Config, width, height);
- fGradientCircle.allocPixels();
+ fGradientCircle.allocN32Pixels(width, height);
SkBitmapDevice device(fGradientCircle);
SkCanvas canvas(&device);
canvas.clear(0x00000000);
}
void make_bitmap() {
- fBitmap.setConfig(SkBitmap::kARGB_8888_Config, 100, 100);
- fBitmap.allocPixels();
+ fBitmap.allocN32Pixels(100, 100);
SkBitmapDevice device(fBitmap);
SkCanvas canvas(&device);
canvas.clear(0x00000000);
}
void make_bitmap() {
- fBitmap.setConfig(SkBitmap::kARGB_8888_Config, 80, 80);
- fBitmap.allocPixels();
+ fBitmap.allocN32Pixels(80, 80);
SkBitmapDevice device(fBitmap);
SkCanvas canvas(&device);
canvas.clear(0x00000000);
0xFFCCCCCC,
0xFFFFFFFF };
SkBitmap bitmap;
- bitmap.setConfig(SkBitmap::kARGB_8888_Config, 2, 2, 2 * sizeof(uint32_t));
- bitmap.allocPixels();
- bitmap.lockPixels();
+ bitmap.allocN32Pixels(2, 2);
memcpy(bitmap.getPixels(), kCheckerPixelData, sizeof(kCheckerPixelData));
- bitmap.unlockPixels();
fBG.reset(SkShader::CreateBitmapShader(bitmap,
SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode));
// draws a background behind each test rect to see transparency
static SkShader* make_bg_shader(int checkSize) {
SkBitmap bmp;
- bmp.setConfig(SkBitmap::kARGB_8888_Config, 2 * checkSize, 2 * checkSize);
- bmp.allocPixels();
+ bmp.allocN32Pixels(2 * checkSize, 2 * checkSize);
SkCanvas canvas(bmp);
canvas.clear(0xFF800000);
SkPaint paint;
}
void make_bitmap() {
- fBitmap.setConfig(SkBitmap::kARGB_8888_Config, 135, 135);
- fBitmap.allocPixels();
+ fBitmap.allocN32Pixels(135, 135);
SkBitmapDevice device(fBitmap);
SkCanvas canvas(&device);
canvas.clear(0x0);
const int kStretchy = 8;
const int kSize = 2*kFixed + kStretchy;
- bitmap->setConfig(SkBitmap::kARGB_8888_Config, kSize, kSize);
- bitmap->allocPixels();
+ bitmap->allocN32Pixels(kSize, kSize);
SkBaseDevice* dev = new SkBitmapDevice(*bitmap);
SkCanvas canvas(dev);
}
void make_bitmap() {
- fBitmap.setConfig(SkBitmap::kARGB_8888_Config, 80, 80);
- fBitmap.allocPixels();
+ fBitmap.allocN32Pixels(80, 80);
SkBitmapDevice device(fBitmap);
SkCanvas canvas(&device);
canvas.clear(0x00000000);
static const unsigned int kCheckerboardWidth = 16;
static const unsigned int kCheckerboardHeight = 16;
- fCheckerboard.setConfig(SkBitmap::kARGB_8888_Config,
- kCheckerboardWidth, kCheckerboardHeight);
- fCheckerboard.allocPixels();
- SkAutoLockPixels lock(fCheckerboard);
+ fCheckerboard.allocN32Pixels(kCheckerboardWidth, kCheckerboardHeight);
for (unsigned int y = 0; y < kCheckerboardHeight; y += 2) {
SkPMColor* scanline = fCheckerboard.getAddr32(0, y);
for (unsigned int x = 0; x < kCheckerboardWidth; x += 2) {
SkColor blend(SkColor one, SkColor two) {
SkBitmap temp;
- temp.setConfig(SkBitmap::kARGB_8888_Config, 1, 1);
- temp.allocPixels();
+ temp.allocN32Pixels(1, 1);
SkCanvas canvas(temp);
canvas.drawColor(one);
canvas.drawColor(two);
static const int xSize = 16;
static const int ySize = 16;
- fTexture.setConfig(SkBitmap::kARGB_8888_Config,
- xSize,
- ySize,
- xSize*sizeof(SkColor));
-
- fTexture.allocPixels();
- fTexture.lockPixels();
+ fTexture.allocN32Pixels(xSize, ySize);
SkPMColor* addr = fTexture.getAddr32(0, 0);
for (int y = 0; y < ySize; ++y) {
}
}
- fTexture.unlockPixels();
-
fTextureCreated = true;
}
SkImageDecoder::kDecodePixels_Mode);
SkDELETE(codec);
} else {
- fBM.setConfig(SkBitmap::kARGB_8888_Config, 1, 1);
- fBM.allocPixels();
+ fBM.allocN32Pixels(1, 1);
*(fBM.getAddr32(0,0)) = 0xFF0000FF; // red == bad
}
fSize = fBM.height();
virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
SkBitmap dst;
- dst.setConfig(SkBitmap::kARGB_8888_Config, fBM.width() * fScale, fBM.height() * fScale);
- dst.allocPixels();
+ dst.allocN32Pixels(fBM.width() * fScale, fBM.height() * fScale);
fBM.scale(&dst);
canvas->drawBitmap(dst, 0, 0);
namespace skiagm {
static void makebm(SkBitmap* bm, SkBitmap::Config config, int w, int h) {
- bm->setConfig(config, w, h);
- bm->allocPixels();
+ bm->allocConfigPixels(config, w, h);
bm->eraseColor(SK_ColorTRANSPARENT);
SkCanvas canvas(*bm);
namespace skiagm {
static void makebm(SkBitmap* bm, SkBitmap::Config config, int w, int h) {
- bm->setConfig(config, w, h);
- bm->allocPixels();
+ bm->allocConfigPixels(config, w, h);
bm->eraseColor(SK_ColorTRANSPARENT);
SkCanvas canvas(*bm);
namespace skiagm {
static void makebm(SkBitmap* bm, SkBitmap::Config config, int w, int h) {
- bm->setConfig(config, w, h);
- bm->allocPixels();
+ bm->allocConfigPixels(config, w, h);
bm->eraseColor(SK_ColorTRANSPARENT);
SkCanvas canvas(*bm);
#include "SkBlurImageFilter.h"
static void make_bm(SkBitmap* bm) {
- bm->setConfig(SkBitmap::kARGB_8888_Config, 100, 100);
- bm->allocPixels();
+ bm->allocN32Pixels(100, 100);
bm->eraseColor(SK_ColorBLUE);
SkCanvas canvas(*bm);
static void make_bm0(SkBitmap* bm) {
int W = 120;
int H = 120;
- bm->setConfig(SkBitmap::kARGB_8888_Config, W, H);
- bm->allocPixels();
+ bm->allocN32Pixels(W, H);
bm->eraseColor(SK_ColorTRANSPARENT);
SkCanvas canvas(*bm);
static void make_bm1(SkBitmap* bm) {
int W = 120;
int H = 120;
- bm->setConfig(SkBitmap::kARGB_8888_Config, W, H);
- bm->allocPixels();
+ bm->allocN32Pixels(W, H);
bm->eraseColor(SK_ColorTRANSPARENT);
SkCanvas canvas(*bm);
}
void make_bitmap() {
- fBitmap.setConfig(SkBitmap::kARGB_8888_Config, 80, 80);
- fBitmap.allocPixels();
+ fBitmap.allocN32Pixels(80, 80);
SkBitmapDevice device(fBitmap);
SkCanvas canvas(&device);
canvas.clear(0xFF000000);
}
void make_checkerboard() {
- fCheckerboard.setConfig(SkBitmap::kARGB_8888_Config, 80, 80);
- fCheckerboard.allocPixels();
+ fCheckerboard.allocN32Pixels(80, 80);
SkBitmapDevice device(fCheckerboard);
SkCanvas canvas(&device);
canvas.clear(0x00000000);
#include "SkBlurDrawLooper.h"
static void makebm(SkBitmap* bm, SkBitmap::Config config, int w, int h) {
- bm->setConfig(config, w, h);
- bm->allocPixels();
+ bm->allocConfigPixels(config, w, h);
bm->eraseColor(SK_ColorTRANSPARENT);
SkCanvas canvas(*bm);
#include "SkBlurDrawLooper.h"
static void makebm(SkBitmap* bm, SkBitmap::Config config, int w, int h) {
- bm->setConfig(config, w, h);
- bm->allocPixels();
+ bm->allocConfigPixels(config, w, h);
bm->eraseColor(SK_ColorTRANSPARENT);
SkCanvas canvas(*bm);
#include "SkPath.h"
static void make_bm(SkBitmap* bm, int width, int height, SkColor colors[2]) {
- bm->setConfig(SkBitmap::kARGB_8888_Config, width, height);
- bm->allocPixels();
+ bm->allocN32Pixels(width, height);
SkCanvas canvas(*bm);
SkPoint center = {SkIntToScalar(width)/2, SkIntToScalar(height)/2};
SkScalar radius = 40;
}
void make_bitmap() {
- fBitmap.setConfig(SkBitmap::kARGB_8888_Config, 80, 80);
- fBitmap.allocPixels();
+ fBitmap.allocN32Pixels(80, 80);
SkBitmapDevice device(fBitmap);
SkCanvas canvas(&device);
canvas.clear(0x00000000);
}
void make_checkerboard() {
- fCheckerboard.setConfig(SkBitmap::kARGB_8888_Config, 80, 80);
- fCheckerboard.allocPixels();
+ fCheckerboard.allocN32Pixels(80, 80);
SkBitmapDevice device(fCheckerboard);
SkCanvas canvas(&device);
canvas.clear(0x00000000);
static void make_bitmaps(int w, int h, SkBitmap* src, SkBitmap* dst,
SkBitmap* transparent) {
- src->setConfig(SkBitmap::kARGB_8888_Config, w, h);
- src->allocPixels();
+ src->allocN32Pixels(w, h);
src->eraseColor(SK_ColorTRANSPARENT);
SkPaint p;
SkPackARGB32(0xFF, 0x40, 0x40, 0x40)
};
SkBitmap bg;
- bg.setConfig(SkBitmap::kARGB_8888_Config, 2, 2, 0, kOpaque_SkAlphaType);
- bg.allocPixels();
- SkAutoLockPixels bgAlp(bg);
+ bg.allocN32Pixels(2, 2, true);
memcpy(bg.getPixels(), kCheckData, sizeof(kCheckData));
fBG.reset(SkShader::CreateBitmapShader(bg,
fBG->setLocalMatrix(lm);
SkBitmap dstBmp;
- dstBmp.setConfig(SkBitmap::kARGB_8888_Config, kSize, kSize);
- dstBmp.allocPixels();
- SkAutoLockPixels dstAlp(dstBmp);
+ dstBmp.allocN32Pixels(kSize, kSize);
SkPMColor* pixels = reinterpret_cast<SkPMColor*>(dstBmp.getPixels());
for (int y = 0; y < kSize; ++y) {
SkShader::kClamp_TileMode,
SkShader::kClamp_TileMode));
SkBitmap srcBmp;
- srcBmp.setConfig(SkBitmap::kARGB_8888_Config, kSize, kSize);
- srcBmp.allocPixels();
- SkAutoLockPixels srcAlp(srcBmp);
+ srcBmp.allocN32Pixels(kSize, kSize);
pixels = reinterpret_cast<SkPMColor*>(srcBmp.getPixels());
for (int x = 0; x < kSize; ++x) {
SkPackARGB32(0xFF, 0x40, 0x40, 0x40)
};
SkBitmap bg;
- bg.setConfig(SkBitmap::kARGB_8888_Config, 2, 2, 0, kOpaque_SkAlphaType);
- bg.allocPixels();
+ bg.allocN32Pixels(2, 2, true);
SkAutoLockPixels bgAlp(bg);
memcpy(bg.getPixels(), kCheckData, sizeof(kCheckData));
SkShader::kRepeat_TileMode))->unref();
SkBitmap bmp;
- bmp.setConfig(SkBitmap::kARGB_8888_Config, kSize, kSize);
- bmp.allocPixels();
+ bmp.allocN32Pixels(kSize, kSize);
SkCanvas bmpCanvas(bmp);
bmpCanvas.clear(SK_ColorTRANSPARENT);
}
/**
+ * Legacy helper function, which creates an SkImageInfo from the specified
+ * config and then calls allocPixels(info).
+ */
+ bool allocConfigPixels(Config, int width, int height, bool isOpaque = false);
+
+ bool allocN32Pixels(int width, int height, bool isOpaque = false) {
+ SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
+ if (isOpaque) {
+ info.fAlphaType = kOpaque_SkAlphaType;
+ }
+ return this->allocPixels(info);
+ }
+
+ /**
* Install a pixelref that wraps the specified pixels and rowBytes, and
* optional ReleaseProc and context. When the pixels are no longer
* referenced, if ReleaseProc is not null, it will be called with the
return true;
}
+bool SkBitmap::allocConfigPixels(Config config, int width, int height,
+ bool isOpaque) {
+ SkColorType ct;
+ if (!config_to_colorType(config, &ct)) {
+ return false;
+ }
+
+ SkAlphaType at = isOpaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType;
+ if (!validate_alphaType(config, at, &at)) {
+ return false;
+ }
+
+ return this->allocPixels(SkImageInfo::Make(width, height, ct, at));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
void SkBitmap::freePixels() {
// if we're gonna free the pixels, we certainly need to free the mipmap
this->freeMipMap();