TiledPipeController::TiledPipeController(const SkBitmap& bitmap, SkPicture::InstallPixelRefProc proc, const SkMatrix* initial) : INHERITED(NULL, proc) { int32_t top = 0; int32_t bottom; int32_t height = bitmap.height() / NumberOfTiles; SkIRect rect; for (int i = 0; i < NumberOfTiles; i++) { bottom = i + 1 == NumberOfTiles ? bitmap.height() : top + height; rect.setLTRB(0, top, bitmap.width(), bottom); top = bottom; SkDEBUGCODE(bool extracted = )bitmap.extractSubset(&fBitmaps[i], rect); SkASSERT(extracted); SkBaseDevice* device = new SkBitmapDevice(fBitmaps[i]); SkCanvas* canvas = new SkCanvas(device); device->unref(); if (initial != NULL) { canvas->setMatrix(*initial); } canvas->translate(SkIntToScalar(-rect.left()), SkIntToScalar(-rect.top())); if (0 == i) { fReader.setCanvas(canvas); } else { fReaders[i - 1].setCanvas(canvas); fReaders[i - 1].setBitmapDecoder(proc); } canvas->unref(); } }
bool SkAndroidFrameworkUtils::clipWithStencil(SkCanvas* canvas) { SkRegion clipRegion; canvas->temporary_internal_getRgnClip(&clipRegion); if (clipRegion.isEmpty()) { return false; } SkBaseDevice* device = canvas->getDevice(); if (!device) { return false; } GrRenderTargetContext* rtc = device->accessRenderTargetContext(); if (!rtc) { return false; } GrPaint grPaint; grPaint.setXPFactory(GrDisableColorXPFactory::Get()); GrNoClip noClip; static constexpr GrUserStencilSettings kDrawToStencil( GrUserStencilSettings::StaticInit< 0x1, GrUserStencilTest::kAlways, 0x1, GrUserStencilOp::kReplace, GrUserStencilOp::kReplace, 0x1>() ); rtc->drawRegion(noClip, std::move(grPaint), GrAA::kNo, SkMatrix::I(), clipRegion, GrStyle::SimpleFill(), &kDrawToStencil); return true; }
static SkSurface* compat_surface(SkCanvas* canvas, const SkISize& size, bool skipGPU) { SkImageInfo info = SkImageInfo::MakeN32Premul(size); #if SK_SUPPORT_GPU SkBaseDevice* dev = canvas->getDevice(); if (!skipGPU && dev->accessRenderTarget()) { SkGpuDevice* gd = (SkGpuDevice*)dev; GrContext* ctx = gd->context(); return SkSurface::NewRenderTarget(ctx, info, 0); } #endif return SkSurface::NewRaster(info); }
virtual void onDraw(const int loops, SkCanvas* canvas) { #if 0 // what specifically are we interested in timing here? SkBaseDevice *device = canvas->getDevice()->createCompatibleDevice( SkBitmap::kARGB_8888_Config, CANVAS_WIDTH, CANVAS_HEIGHT, false); SkAutoTUnref<SkDeferredCanvas> deferredCanvas(SkDeferredCanvas::Create(device)); device->unref(); initDeferredCanvas(deferredCanvas); drawInDeferredCanvas(loops, deferredCanvas); finalizeDeferredCanvas(deferredCanvas); deferredCanvas->flush(); #endif }
bool SkDownSampleImageFilter::onFilterImage(Proxy* proxy, const SkBitmap& src, const Context&, SkBitmap* result, SkIPoint*) const { SkScalar scale = fScale; if (scale > SK_Scalar1 || scale <= 0) { return false; } int dstW = SkScalarRoundToInt(src.width() * scale); int dstH = SkScalarRoundToInt(src.height() * scale); if (dstW < 1) { dstW = 1; } if (dstH < 1) { dstH = 1; } SkBitmap tmp; // downsample { SkBaseDevice* dev = proxy->createDevice(dstW, dstH); if (NULL == dev) { return false; } OwnDeviceCanvas canvas(dev); SkPaint paint; paint.setFilterLevel(SkPaint::kLow_FilterLevel); canvas.scale(scale, scale); canvas.drawBitmap(src, 0, 0, &paint); tmp = dev->accessBitmap(false); } // upscale { SkBaseDevice* dev = proxy->createDevice(src.width(), src.height()); if (NULL == dev) { return false; } OwnDeviceCanvas canvas(dev); SkRect r = SkRect::MakeWH(SkIntToScalar(src.width()), SkIntToScalar(src.height())); canvas.drawBitmapRect(tmp, NULL, r, NULL); *result = dev->accessBitmap(false); } return true; }
static void make_bitmap(SkBitmap* bitmap, GrContext* ctx, SkIRect* center) { SkBaseDevice* dev; const int kFixed = 28; const int kStretchy = 8; const int kSize = 2*kFixed + kStretchy; #if SK_SUPPORT_GPU if (ctx) { dev = new SkGpuDevice(ctx, SkBitmap::kARGB_8888_Config, kSize, kSize); *bitmap = dev->accessBitmap(false); } else #endif { bitmap->setConfig(SkBitmap::kARGB_8888_Config, kSize, kSize); bitmap->allocPixels(); dev = new SkBitmapDevice(*bitmap); } SkCanvas canvas(dev); dev->unref(); canvas.clear(SK_ColorTRANSPARENT); SkRect r = SkRect::MakeWH(SkIntToScalar(kSize), SkIntToScalar(kSize)); const SkScalar strokeWidth = SkIntToScalar(6); const SkScalar radius = SkIntToScalar(kFixed) - strokeWidth/2; center->setXYWH(kFixed, kFixed, kStretchy, kStretchy); SkPaint paint; paint.setAntiAlias(true); paint.setColor(0xFFFF0000); canvas.drawRoundRect(r, radius, radius, paint); r.setXYWH(SkIntToScalar(kFixed), 0, SkIntToScalar(kStretchy), SkIntToScalar(kSize)); paint.setColor(0x8800FF00); canvas.drawRect(r, paint); r.setXYWH(0, SkIntToScalar(kFixed), SkIntToScalar(kSize), SkIntToScalar(kStretchy)); paint.setColor(0x880000FF); canvas.drawRect(r, paint); }
virtual void onDraw(SkCanvas* canvas) { SkBaseDevice* device = canvas->getTopDevice(); GrRenderTarget* target = device->accessRenderTarget(); GrContext* ctx = GetGr(); if (ctx && target) { SkPMColor gTextureData[(2 * S) * (2 * S)]; static const int stride = 2 * S; static const SkPMColor gray = SkPackARGB32(0x40, 0x40, 0x40, 0x40); static const SkPMColor white = SkPackARGB32(0xff, 0xff, 0xff, 0xff); static const SkPMColor red = SkPackARGB32(0x80, 0x80, 0x00, 0x00); static const SkPMColor blue = SkPackARGB32(0x80, 0x00, 0x00, 0x80); static const SkPMColor green = SkPackARGB32(0x80, 0x00, 0x80, 0x00); static const SkPMColor black = SkPackARGB32(0x00, 0x00, 0x00, 0x00); for (int i = 0; i < 2; ++i) { int offset = 0; // fill upper-left for (int y = 0; y < S; ++y) { for (int x = 0; x < S; ++x) { gTextureData[offset + y * stride + x] = gray; } } // fill upper-right offset = S; for (int y = 0; y < S; ++y) { for (int x = 0; x < S; ++x) { gTextureData[offset + y * stride + x] = white; } } // fill lower left offset = S * stride; for (int y = 0; y < S; ++y) { for (int x = 0; x < S; ++x) { gTextureData[offset + y * stride + x] = black; } } // fill lower right offset = S * stride + S; for (int y = 0; y < S; ++y) { for (int x = 0; x < S; ++x) { gTextureData[offset + y * stride + x] = gray; } } GrTextureDesc desc; // use RT flag bit because in GL it makes the texture be bottom-up desc.fFlags = i ? kRenderTarget_GrTextureFlagBit : kNone_GrTextureFlags; desc.fConfig = kSkia8888_GrPixelConfig; desc.fWidth = 2 * S; desc.fHeight = 2 * S; GrTexture* texture = ctx->createUncachedTexture(desc, gTextureData, 0); if (!texture) { return; } GrAutoUnref au(texture); GrContext::AutoClip acs(ctx, SkRect::MakeWH(2*S, 2*S)); ctx->setRenderTarget(target); GrPaint paint; paint.setBlendFunc(kOne_GrBlendCoeff, kISA_GrBlendCoeff); SkMatrix vm; if (i) { vm.setRotate(90 * SK_Scalar1, S * SK_Scalar1, S * SK_Scalar1); } else { vm.reset(); } ctx->setMatrix(vm); SkMatrix tm; tm = vm; tm.postIDiv(2*S, 2*S); paint.addColorTextureEffect(texture, tm); ctx->drawRect(paint, SkRect::MakeWH(2*S, 2*S)); // now update the lower right of the texture in first pass // or upper right in second pass offset = 0; for (int y = 0; y < S; ++y) { for (int x = 0; x < S; ++x) { gTextureData[offset + y * stride + x] = ((x + y) % 2) ? (i ? green : red) : blue; } } texture->writePixels(S, (i ? 0 : S), S, S, texture->config(), gTextureData, 4 * stride); ctx->drawRect(paint, SkRect::MakeWH(2*S, 2*S)); } } }