SkComposeShader::~SkComposeShader() {
SkSafeUnref(fMode);
fShaderB->unref();
fShaderA->unref();
}
SkBoundaryPatch::~SkBoundaryPatch() {
SkSafeUnref(fBoundary);
}
SkGLContext::~SkGLContext() {
SkSafeUnref(fGL);
}
PictureLayerContent::~PictureLayerContent()
{
SkSafeUnref(m_picture);
}
SkGradientShaderBase::GradientShaderCache::~GradientShaderCache() {
sk_free(fCache16Storage);
SkSafeUnref(fCache32PixelRef);
}
static void setTypeface(SkPaint* paint, const char name[], SkTypeface::Style style) {
SkSafeUnref(paint->setTypeface(SkTypeface::CreateFromName(name, style)));
}
PictureBenchmark::~PictureBenchmark() {
SkSafeUnref(fRenderer);
}
static void finalizer(JNIEnv* env, jobject, jlong objHandle)
{
SkXfermode* obj = reinterpret_cast<SkXfermode *>(objHandle);
SkSafeUnref(obj);
}
SkPairPathEffect::~SkPairPathEffect() {
SkSafeUnref(fPE0);
SkSafeUnref(fPE1);
}
virtual ~AnimGifView()
{
SkSafeUnref(fMovie);
}
static void
SetPaintPattern(SkPaint& aPaint, const Pattern& aPattern, TempBitmap& aTmpBitmap,
Float aAlpha = 1.0)
{
switch (aPattern.GetType()) {
case PatternType::COLOR: {
Color color = static_cast<const ColorPattern&>(aPattern).mColor;
aPaint.setColor(ColorToSkColor(color, aAlpha));
break;
}
case PatternType::LINEAR_GRADIENT: {
const LinearGradientPattern& pat = static_cast<const LinearGradientPattern&>(aPattern);
GradientStopsSkia *stops = static_cast<GradientStopsSkia*>(pat.mStops.get());
SkShader::TileMode mode = ExtendModeToTileMode(stops->mExtendMode);
if (stops->mCount >= 2) {
SkPoint points[2];
points[0] = SkPoint::Make(SkFloatToScalar(pat.mBegin.x), SkFloatToScalar(pat.mBegin.y));
points[1] = SkPoint::Make(SkFloatToScalar(pat.mEnd.x), SkFloatToScalar(pat.mEnd.y));
SkShader* shader = SkGradientShader::CreateLinear(points,
&stops->mColors.front(),
&stops->mPositions.front(),
stops->mCount,
mode);
if (shader) {
SkMatrix mat;
GfxMatrixToSkiaMatrix(pat.mMatrix, mat);
shader->setLocalMatrix(mat);
SkSafeUnref(aPaint.setShader(shader));
}
} else {
aPaint.setColor(SkColorSetARGB(0, 0, 0, 0));
}
break;
}
case PatternType::RADIAL_GRADIENT: {
const RadialGradientPattern& pat = static_cast<const RadialGradientPattern&>(aPattern);
GradientStopsSkia *stops = static_cast<GradientStopsSkia*>(pat.mStops.get());
SkShader::TileMode mode = ExtendModeToTileMode(stops->mExtendMode);
if (stops->mCount >= 2) {
SkPoint points[2];
points[0] = SkPoint::Make(SkFloatToScalar(pat.mCenter1.x), SkFloatToScalar(pat.mCenter1.y));
points[1] = SkPoint::Make(SkFloatToScalar(pat.mCenter2.x), SkFloatToScalar(pat.mCenter2.y));
SkShader* shader = SkGradientShader::CreateTwoPointConical(points[0],
SkFloatToScalar(pat.mRadius1),
points[1],
SkFloatToScalar(pat.mRadius2),
&stops->mColors.front(),
&stops->mPositions.front(),
stops->mCount,
mode);
if (shader) {
SkMatrix mat;
GfxMatrixToSkiaMatrix(pat.mMatrix, mat);
shader->setLocalMatrix(mat);
SkSafeUnref(aPaint.setShader(shader));
}
} else {
aPaint.setColor(SkColorSetARGB(0, 0, 0, 0));
}
break;
}
case PatternType::SURFACE: {
const SurfacePattern& pat = static_cast<const SurfacePattern&>(aPattern);
aTmpBitmap = GetBitmapForSurface(pat.mSurface);
const SkBitmap& bitmap = aTmpBitmap.mBitmap;
SkShader::TileMode mode = ExtendModeToTileMode(pat.mExtendMode);
SkShader* shader = SkShader::CreateBitmapShader(bitmap, mode, mode);
SkMatrix mat;
GfxMatrixToSkiaMatrix(pat.mMatrix, mat);
shader->setLocalMatrix(mat);
SkSafeUnref(aPaint.setShader(shader));
if (pat.mFilter == Filter::POINT) {
aPaint.setFilterLevel(SkPaint::kNone_FilterLevel);
}
break;
}
}
}
SkImageDecoder::~SkImageDecoder() {
SkSafeUnref(fPeeker);
SkSafeUnref(fChooser);
SkSafeUnref(fAllocator);
}
virtual ~ComposeShaderGM() {
SkSafeUnref(fShader);
}
~ComposeShaderBitmapGM() {
SkSafeUnref(fColorBitmapShader);
SkSafeUnref(fAlpha8BitmapShader);
SkSafeUnref(fLinearGradientShader);
}
SkReadBuffer::~SkReadBuffer() {
sk_free(fMemoryPtr);
SkSafeUnref(fBitmapStorage);
}
SkColorFilterImageFilter::~SkColorFilterImageFilter() {
SkSafeUnref(fColorFilter);
}
SkMallocPixelRef::~SkMallocPixelRef() {
SkSafeUnref(fCTable);
if (fReleaseProc != NULL) {
fReleaseProc(fStorage, fReleaseProcContext);
}
}
SkDumpCanvas::~SkDumpCanvas() {
SkSafeUnref(fDumper);
}
SkBlurDrawLooper::~SkBlurDrawLooper() {
SkSafeUnref(fBlur);
SkSafeUnref(fColorFilter);
}
~ColorCubeBench() {
SkSafeUnref(fCubeData);
}
static void parse_commandline(int argc, char* const argv[], SkTArray<SkString>* inputs,
sk_tools::PictureRenderer*& renderer, SkString*& outputDir,
bool* validate, bool* writeWholeImage,
int* clones){
const char* argv0 = argv[0];
char* const* stop = argv + argc;
sk_tools::PictureRenderer::SkDeviceTypes deviceType =
sk_tools::PictureRenderer::kBitmap_DeviceType;
bool usePipe = false;
int numThreads = 1;
bool useTiles = false;
const char* widthString = NULL;
const char* heightString = NULL;
int gridWidth = 0;
int gridHeight = 0;
bool isPowerOf2Mode = false;
bool isCopyMode = false;
const char* xTilesString = NULL;
const char* yTilesString = NULL;
const char* mode = NULL;
bool gridSupported = false;
sk_tools::PictureRenderer::BBoxHierarchyType bbhType =
sk_tools::PictureRenderer::kNone_BBoxHierarchyType;
*validate = false;
*writeWholeImage = false;
*clones = 0;
SkISize viewport;
viewport.setEmpty();
SkScalar scaleFactor = SK_Scalar1;
for (++argv; argv < stop; ++argv) {
if (0 == strcmp(*argv, "--mode")) {
if (renderer != NULL) {
renderer->unref();
SkDebugf("Cannot combine modes.\n");
usage(argv0);
exit(-1);
}
++argv;
if (argv >= stop) {
SkDebugf("Missing mode for --mode\n");
usage(argv0);
exit(-1);
}
if (0 == strcmp(*argv, "simple")) {
renderer = SkNEW(sk_tools::SimplePictureRenderer);
} else if ((0 == strcmp(*argv, "tile")) || (0 == strcmp(*argv, "pow2tile"))
|| 0 == strcmp(*argv, "copyTile")) {
useTiles = true;
mode = *argv;
if (0 == strcmp(*argv, "pow2tile")) {
isPowerOf2Mode = true;
} else if (0 == strcmp(*argv, "copyTile")) {
isCopyMode = true;
} else {
gridSupported = true;
}
++argv;
if (argv >= stop) {
SkDebugf("Missing width for --mode %s\n", mode);
usage(argv0);
exit(-1);
}
widthString = *argv;
++argv;
if (argv >= stop) {
SkDebugf("Missing height for --mode %s\n", mode);
usage(argv0);
exit(-1);
}
heightString = *argv;
} else if (0 == strcmp(*argv, "rerecord")) {
renderer = SkNEW(sk_tools::RecordPictureRenderer);
} else {
SkDebugf("%s is not a valid mode for --mode\n", *argv);
usage(argv0);
exit(-1);
}
} else if (0 == strcmp(*argv, "--bbh")) {
++argv;
if (argv >= stop) {
SkDebugf("Missing value for --bbh\n");
usage(argv0);
exit(-1);
}
if (0 == strcmp(*argv, "none")) {
bbhType = sk_tools::PictureRenderer::kNone_BBoxHierarchyType;
} else if (0 == strcmp(*argv, "rtree")) {
bbhType = sk_tools::PictureRenderer::kRTree_BBoxHierarchyType;
} else if (0 == strcmp(*argv, "grid")) {
bbhType = sk_tools::PictureRenderer::kTileGrid_BBoxHierarchyType;
++argv;
if (argv >= stop) {
SkDebugf("Missing width for --bbh grid\n");
usage(argv0);
exit(-1);
}
gridWidth = atoi(*argv);
++argv;
if (argv >= stop) {
SkDebugf("Missing height for --bbh grid\n");
usage(argv0);
exit(-1);
}
gridHeight = atoi(*argv);
} else {
SkDebugf("%s is not a valid value for --bbhType\n", *argv);
usage(argv0);
exit(-1);;
}
} else if (0 == strcmp(*argv, "--viewport")) {
++argv;
if (argv >= stop) {
SkDebugf("Missing width for --viewport\n");
usage(argv0);
exit(-1);
}
viewport.fWidth = atoi(*argv);
++argv;
if (argv >= stop) {
SkDebugf("Missing height for --viewport\n");
usage(argv0);
exit(-1);
}
viewport.fHeight = atoi(*argv);
} else if (0 == strcmp(*argv, "--scale")) {
++argv;
if (argv >= stop) {
SkDebugf("Missing scaleFactor for --scale\n");
usage(argv0);
exit(-1);
}
scaleFactor = SkDoubleToScalar(atof(*argv));
} else if (0 == strcmp(*argv, "--tiles")) {
++argv;
if (argv >= stop) {
SkDebugf("Missing x for --tiles\n");
usage(argv0);
exit(-1);
}
xTilesString = *argv;
++argv;
if (argv >= stop) {
SkDebugf("Missing y for --tiles\n");
usage(argv0);
exit(-1);
}
yTilesString = *argv;
} else if (0 == strcmp(*argv, "--pipe")) {
usePipe = true;
} else if (0 == strcmp(*argv, "--multi")) {
++argv;
if (argv >= stop) {
SkSafeUnref(renderer);
SkDebugf("Missing arg for --multi\n");
usage(argv0);
exit(-1);
}
numThreads = atoi(*argv);
if (numThreads < 2) {
SkSafeUnref(renderer);
SkDebugf("Number of threads must be at least 2.\n");
usage(argv0);
exit(-1);
}
} else if (0 == strcmp(*argv, "--clone")) {
++argv;
if (argv >= stop) {
SkSafeUnref(renderer);
SkDebugf("Missing arg for --clone\n");
usage(argv0);
exit(-1);
}
*clones = atoi(*argv);
if (*clones < 0) {
SkSafeUnref(renderer);
SkDebugf("Number of clones must be at least 0.\n");
usage(argv0);
exit(-1);
}
} else if (0 == strcmp(*argv, "--device")) {
++argv;
if (argv >= stop) {
SkSafeUnref(renderer);
SkDebugf("Missing mode for --device\n");
usage(argv0);
exit(-1);
}
if (0 == strcmp(*argv, "bitmap")) {
deviceType = sk_tools::PictureRenderer::kBitmap_DeviceType;
}
#if SK_SUPPORT_GPU
else if (0 == strcmp(*argv, "gpu")) {
deviceType = sk_tools::PictureRenderer::kGPU_DeviceType;
}
#endif
else {
SkSafeUnref(renderer);
SkDebugf("%s is not a valid mode for --device\n", *argv);
usage(argv0);
exit(-1);
}
} else if ((0 == strcmp(*argv, "-h")) || (0 == strcmp(*argv, "--help"))) {
SkSafeUnref(renderer);
usage(argv0);
exit(-1);
} else if (0 == strcmp(*argv, "-w")) {
++argv;
if (argv >= stop) {
SkDebugf("Missing output directory for -w\n");
usage(argv0);
exit(-1);
}
outputDir = SkNEW_ARGS(SkString, (*argv));
} else if (0 == strcmp(*argv, "--validate")) {
*validate = true;
} else if (0 == strcmp(*argv, "--writeWholeImage")) {
*writeWholeImage = true;
} else {
inputs->push_back(SkString(*argv));
}
}
if (numThreads > 1 && !useTiles) {
SkSafeUnref(renderer);
SkDebugf("Multithreaded drawing requires tiled rendering.\n");
usage(argv0);
exit(-1);
}
if (usePipe && sk_tools::PictureRenderer::kNone_BBoxHierarchyType != bbhType) {
SkDebugf("--pipe and --bbh cannot be used together\n");
usage(argv0);
exit(-1);
}
if (sk_tools::PictureRenderer::kTileGrid_BBoxHierarchyType == bbhType &&
!gridSupported) {
SkDebugf("'--bbh grid' is not compatible with specified --mode.\n");
usage(argv0);
exit(-1);
}
if (useTiles) {
SkASSERT(NULL == renderer);
sk_tools::TiledPictureRenderer* tiledRenderer;
if (isCopyMode) {
int x, y;
if (xTilesString != NULL) {
SkASSERT(yTilesString != NULL);
x = atoi(xTilesString);
y = atoi(yTilesString);
if (x <= 0 || y <= 0) {
SkDebugf("--tiles must be given values > 0\n");
usage(argv0);
exit(-1);
}
} else {
x = y = 4;
}
tiledRenderer = SkNEW_ARGS(sk_tools::CopyTilesRenderer, (x, y));
} else if (numThreads > 1) {
tiledRenderer = SkNEW_ARGS(sk_tools::MultiCorePictureRenderer, (numThreads));
} else {
tiledRenderer = SkNEW(sk_tools::TiledPictureRenderer);
}
if (isPowerOf2Mode) {
int minWidth = atoi(widthString);
if (!SkIsPow2(minWidth) || minWidth < 0) {
tiledRenderer->unref();
SkString err;
err.printf("-mode %s must be given a width"
" value that is a power of two\n", mode);
SkDebugf(err.c_str());
usage(argv0);
exit(-1);
}
tiledRenderer->setTileMinPowerOf2Width(minWidth);
} else if (sk_tools::is_percentage(widthString)) {
if (isCopyMode) {
tiledRenderer->unref();
SkString err;
err.printf("--mode %s does not support percentages.\n", mode);
SkDebugf(err.c_str());
usage(argv0);
exit(-1);
}
tiledRenderer->setTileWidthPercentage(atof(widthString));
if (!(tiledRenderer->getTileWidthPercentage() > 0)) {
tiledRenderer->unref();
SkDebugf("--mode %s must be given a width percentage > 0\n", mode);
usage(argv0);
exit(-1);
}
} else {
tiledRenderer->setTileWidth(atoi(widthString));
if (!(tiledRenderer->getTileWidth() > 0)) {
tiledRenderer->unref();
SkDebugf("--mode %s must be given a width > 0\n", mode);
usage(argv0);
exit(-1);
}
}
if (sk_tools::is_percentage(heightString)) {
if (isCopyMode) {
tiledRenderer->unref();
SkString err;
err.printf("--mode %s does not support percentages.\n", mode);
SkDebugf(err.c_str());
usage(argv0);
exit(-1);
}
tiledRenderer->setTileHeightPercentage(atof(heightString));
if (!(tiledRenderer->getTileHeightPercentage() > 0)) {
tiledRenderer->unref();
SkDebugf("--mode %s must be given a height percentage > 0\n", mode);
usage(argv0);
exit(-1);
}
} else {
tiledRenderer->setTileHeight(atoi(heightString));
if (!(tiledRenderer->getTileHeight() > 0)) {
tiledRenderer->unref();
SkDebugf("--mode %s must be given a height > 0\n", mode);
usage(argv0);
exit(-1);
}
}
if (numThreads > 1) {
#if SK_SUPPORT_GPU
if (sk_tools::PictureRenderer::kGPU_DeviceType == deviceType) {
tiledRenderer->unref();
SkDebugf("GPU not compatible with multithreaded tiling.\n");
usage(argv0);
exit(-1);
}
#endif
}
renderer = tiledRenderer;
if (usePipe) {
SkDebugf("Pipe rendering is currently not compatible with tiling.\n"
"Turning off pipe.\n");
}
} else if (usePipe) {
if (renderer != NULL) {
renderer->unref();
SkDebugf("Pipe is incompatible with other modes.\n");
usage(argv0);
exit(-1);
}
renderer = SkNEW(sk_tools::PipePictureRenderer);
}
if (inputs->empty()) {
SkSafeUnref(renderer);
if (NULL != outputDir) {
SkDELETE(outputDir);
}
usage(argv0);
exit(-1);
}
if (NULL == renderer) {
renderer = SkNEW(sk_tools::SimplePictureRenderer);
}
renderer->setBBoxHierarchyType(bbhType);
renderer->setGridSize(gridWidth, gridHeight);
renderer->setViewport(viewport);
renderer->setScaleFactor(scaleFactor);
renderer->setDeviceType(deviceType);
}
SkDrawShapePathEffect::~SkDrawShapePathEffect() {
SkSafeUnref(fPathEffect);
}
PlatformGraphicsContext::State::~State()
{
SkSafeUnref(pathEffect);
SkSafeUnref(fillShader);
SkSafeUnref(strokeShader);
}
SkMallocPixelRef::~SkMallocPixelRef() {
SkSafeUnref(fCTable);
if (fOwnPixels) {
sk_free(fStorage);
}
}
GrDrawContext::~GrDrawContext() {
ASSERT_SINGLE_OWNER
SkSafeUnref(fDrawTarget);
}
SkPicture::~SkPicture() {
SkSafeUnref(fRecord);
SkDELETE(fPlayback);
SkSafeUnref(fAccelData);
}
~ComposeStep() {
SkSafeUnref(fSurf);
delete fPaint;
}
FontPlatformData::~FontPlatformData()
{
SkSafeUnref(m_typeface);
}
GrDrawContext::~GrDrawContext() {
SkSafeUnref(fDrawTarget);
SkDELETE(fTextContext);
}
virtual void onDrawContent(SkCanvas* canvas) {
canvas->translate(SkIntToScalar(10), SkIntToScalar(20));
if (false) {
SkPaint paint;
paint.setAntiAlias(true);
paint.setTextSize(50);
paint.setTypeface(SkTypeface::CreateFromName("Arial Unicode MS", SkTypeface::kNormal));
SkSafeUnref(paint.getTypeface());
char buffer[10];
size_t len = SkUTF8_FromUnichar(0x8500, buffer);
canvas->drawText(buffer, len, 40, 40, paint);
return;
}
if (false) {
SkPaint paint;
paint.setAntiAlias(true);
SkRect r0 = { 0, 0, 10.5f, 20 };
SkRect r1 = { 10.5f, 10, 20, 30 };
paint.setColor(SK_ColorRED);
canvas->drawRect(r0, paint);
paint.setColor(SK_ColorBLUE);
canvas->drawRect(r1, paint);
return;
}
const struct {
SkXfermode::Mode fMode;
const char* fLabel;
} gModes[] = {
{ SkXfermode::kClear_Mode, "Clear" },
{ SkXfermode::kSrc_Mode, "Src" },
{ SkXfermode::kDst_Mode, "Dst" },
{ SkXfermode::kSrcOver_Mode, "SrcOver" },
{ SkXfermode::kDstOver_Mode, "DstOver" },
{ SkXfermode::kSrcIn_Mode, "SrcIn" },
{ SkXfermode::kDstIn_Mode, "DstIn" },
{ SkXfermode::kSrcOut_Mode, "SrcOut" },
{ SkXfermode::kDstOut_Mode, "DstOut" },
{ SkXfermode::kSrcATop_Mode, "SrcATop" },
{ SkXfermode::kDstATop_Mode, "DstATop" },
{ SkXfermode::kXor_Mode, "Xor" },
{ SkXfermode::kPlus_Mode, "Plus" },
/*{ SkXfermode::kModulate_Mode, "Modulate" },
{ SkXfermode::kScreen_Mode, "Screen" },
{ SkXfermode::kOverlay_Mode, "Overlay" },
{ SkXfermode::kDarken_Mode, "Darken" },
{ SkXfermode::kLighten_Mode, "Lighten" },
{ SkXfermode::kColorDodge_Mode, "ColorDodge" },
{ SkXfermode::kColorBurn_Mode, "ColorBurn" },
{ SkXfermode::kHardLight_Mode, "HardLight" },
{ SkXfermode::kSoftLight_Mode, "SoftLight" },
{ SkXfermode::kDifference_Mode, "Difference" },
{ SkXfermode::kExclusion_Mode, "Exclusion" },*/
};
const SkScalar w = SkIntToScalar(W);
const SkScalar h = SkIntToScalar(H);
SkShader* s = SkShader::CreateBitmapShader(fBG,
SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode);
SkMatrix m;
m.setScale(SkIntToScalar(6), SkIntToScalar(6));
s->setLocalMatrix(m);
SkPaint labelP;
labelP.setAntiAlias(true);
labelP.setLCDRenderText(true);
labelP.setTextAlign(SkPaint::kCenter_Align);
setNamedTypeface(&labelP, "Menlo Regular");
const int W = 5;
SkScalar x0 = 0;
for (int twice = 0; twice < 2; twice++) {
SkScalar x = x0, y = 0;
for (size_t i = 0; i < SK_ARRAY_COUNT(gModes); i++) {
SkXfermode* mode = SkXfermode::Create(gModes[i].fMode);
SkAutoUnref aur(mode);
SkRect r;
r.set(x, y, x+w, y+h);
SkPaint p;
p.setStyle(SkPaint::kFill_Style);
p.setShader(s);
canvas->drawRect(r, p);
canvas->saveLayer(&r, NULL);
draw_mode(canvas, mode, twice ? 0x88 : 0xFF, r.fLeft, r.fTop);
canvas->restore();
r.inset(-SK_ScalarHalf, -SK_ScalarHalf);
p.setStyle(SkPaint::kStroke_Style);
p.setShader(NULL);
canvas->drawRect(r, p);
canvas->drawText(gModes[i].fLabel, strlen(gModes[i].fLabel),
x + w/2, y - labelP.getTextSize()/2, labelP);
x += w + SkIntToScalar(10);
if ((i % W) == W - 1) {
x = x0;
y += h + SkIntToScalar(30);
}
}
x0 += SkIntToScalar(400);
}
s->unref();
}
