d9c1853fb8
https://codereview.chromium.org/13261018/ git-svn-id: http://skia.googlecode.com/svn/trunk@8465 2bbb7eff-a529-9590-31e7-b0007b416f81
688 lines
24 KiB
C++
688 lines
24 KiB
C++
/*
|
|
* Copyright 2012 Google Inc.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
* found in the LICENSE file.
|
|
*/
|
|
|
|
#include "SkDebugCanvas.h"
|
|
#include "SkDevice.h"
|
|
#include "SkGraphics.h"
|
|
#include "SkImageDecoder.h"
|
|
#include "SkImageEncoder.h"
|
|
#include "SkOSFile.h"
|
|
#include "SkPicture.h"
|
|
#include "SkPicturePlayback.h"
|
|
#include "SkPictureRecord.h"
|
|
#include "SkStream.h"
|
|
#include "picture_utils.h"
|
|
#include "path_utils.h"
|
|
|
|
static void usage() {
|
|
SkDebugf("Usage: filter -i inFile [-o outFile] [--input-dir path] [--output-dir path]\n");
|
|
SkDebugf(" [-h|--help]\n\n");
|
|
SkDebugf(" -i inFile : file to file.\n");
|
|
SkDebugf(" -o outFile : result of filtering.\n");
|
|
SkDebugf(" --input-dir : process all files in dir with .skp extension.\n");
|
|
SkDebugf(" --output-dir : results of filtering the input dir.\n");
|
|
SkDebugf(" -h|--help : Show this help message.\n");
|
|
}
|
|
|
|
// Is the supplied paint simply a color?
|
|
static bool is_simple(const SkPaint& p) {
|
|
return NULL == p.getPathEffect() &&
|
|
NULL == p.getShader() &&
|
|
NULL == p.getXfermode() &&
|
|
NULL == p.getMaskFilter() &&
|
|
NULL == p.getColorFilter() &&
|
|
NULL == p.getRasterizer() &&
|
|
NULL == p.getLooper() &&
|
|
NULL == p.getImageFilter();
|
|
}
|
|
|
|
|
|
// Check for:
|
|
// SAVE_LAYER
|
|
// DRAW_BITMAP_RECT_TO_RECT
|
|
// RESTORE
|
|
// where the saveLayer's color can be moved into the drawBitmapRect
|
|
static bool check_0(SkDebugCanvas* canvas, int curCommand) {
|
|
if (SAVE_LAYER != canvas->getDrawCommandAt(curCommand)->getType() ||
|
|
canvas->getSize() <= curCommand+2 ||
|
|
DRAW_BITMAP_RECT_TO_RECT != canvas->getDrawCommandAt(curCommand+1)->getType() ||
|
|
RESTORE != canvas->getDrawCommandAt(curCommand+2)->getType()) {
|
|
return false;
|
|
}
|
|
|
|
SaveLayer* saveLayer = (SaveLayer*) canvas->getDrawCommandAt(curCommand);
|
|
DrawBitmapRect* dbmr = (DrawBitmapRect*) canvas->getDrawCommandAt(curCommand+1);
|
|
|
|
const SkPaint* saveLayerPaint = saveLayer->paint();
|
|
SkPaint* dbmrPaint = dbmr->paint();
|
|
|
|
// For this optimization we only fold the saveLayer and drawBitmapRect
|
|
// together if the saveLayer's draw is simple (i.e., no fancy effects) and
|
|
// and the only difference in the colors is that the saveLayer's can have
|
|
// an alpha while the drawBitmapRect's is opaque.
|
|
// TODO: it should be possible to fold them together even if they both
|
|
// have different non-255 alphas but this is low priority since we have
|
|
// never seen that case
|
|
// If either operation lacks a paint then the collapse is trivial
|
|
SkColor layerColor = saveLayerPaint->getColor() | 0xFF000000; // force opaque
|
|
|
|
return NULL == saveLayerPaint ||
|
|
NULL == dbmrPaint ||
|
|
(is_simple(*saveLayerPaint) && dbmrPaint->getColor() == layerColor);
|
|
}
|
|
|
|
// Fold the saveLayer's alpha into the drawBitmapRect and remove the saveLayer
|
|
// and restore
|
|
static void apply_0(SkDebugCanvas* canvas, int curCommand) {
|
|
SaveLayer* saveLayer = (SaveLayer*) canvas->getDrawCommandAt(curCommand);
|
|
const SkPaint* saveLayerPaint = saveLayer->paint();
|
|
|
|
// if (NULL == saveLayerPaint) the dbmr's paint doesn't need to be changed
|
|
if (NULL != saveLayerPaint) {
|
|
DrawBitmapRect* dbmr = (DrawBitmapRect*) canvas->getDrawCommandAt(curCommand+1);
|
|
SkPaint* dbmrPaint = dbmr->paint();
|
|
|
|
if (NULL == dbmrPaint) {
|
|
// if the DBMR doesn't have a paint just use the saveLayer's
|
|
dbmr->setPaint(*saveLayerPaint);
|
|
} else if (NULL != saveLayerPaint) {
|
|
SkColor newColor = SkColorSetA(dbmrPaint->getColor(),
|
|
SkColorGetA(saveLayerPaint->getColor()));
|
|
dbmrPaint->setColor(newColor);
|
|
}
|
|
}
|
|
|
|
canvas->deleteDrawCommandAt(curCommand+2); // restore
|
|
canvas->deleteDrawCommandAt(curCommand); // saveLayer
|
|
}
|
|
|
|
// Check for:
|
|
// SAVE_LAYER
|
|
// SAVE
|
|
// CLIP_RECT
|
|
// DRAW_BITMAP_RECT_TO_RECT
|
|
// RESTORE
|
|
// RESTORE
|
|
// where the saveLayer's color can be moved into the drawBitmapRect
|
|
static bool check_1(SkDebugCanvas* canvas, int curCommand) {
|
|
if (SAVE_LAYER != canvas->getDrawCommandAt(curCommand)->getType() ||
|
|
canvas->getSize() <= curCommand+5 ||
|
|
SAVE != canvas->getDrawCommandAt(curCommand+1)->getType() ||
|
|
CLIP_RECT != canvas->getDrawCommandAt(curCommand+2)->getType() ||
|
|
DRAW_BITMAP_RECT_TO_RECT != canvas->getDrawCommandAt(curCommand+3)->getType() ||
|
|
RESTORE != canvas->getDrawCommandAt(curCommand+4)->getType() ||
|
|
RESTORE != canvas->getDrawCommandAt(curCommand+5)->getType()) {
|
|
return false;
|
|
}
|
|
|
|
SaveLayer* saveLayer = (SaveLayer*) canvas->getDrawCommandAt(curCommand);
|
|
DrawBitmapRect* dbmr = (DrawBitmapRect*) canvas->getDrawCommandAt(curCommand+3);
|
|
|
|
const SkPaint* saveLayerPaint = saveLayer->paint();
|
|
SkPaint* dbmrPaint = dbmr->paint();
|
|
|
|
// For this optimization we only fold the saveLayer and drawBitmapRect
|
|
// together if the saveLayer's draw is simple (i.e., no fancy effects) and
|
|
// and the only difference in the colors is that the saveLayer's can have
|
|
// an alpha while the drawBitmapRect's is opaque.
|
|
// TODO: it should be possible to fold them together even if they both
|
|
// have different non-255 alphas but this is low priority since we have
|
|
// never seen that case
|
|
// If either operation lacks a paint then the collapse is trivial
|
|
SkColor layerColor = saveLayerPaint->getColor() | 0xFF000000; // force opaque
|
|
|
|
return NULL == saveLayerPaint ||
|
|
NULL == dbmrPaint ||
|
|
(is_simple(*saveLayerPaint) && dbmrPaint->getColor() == layerColor);
|
|
}
|
|
|
|
// Fold the saveLayer's alpha into the drawBitmapRect and remove the saveLayer
|
|
// and restore
|
|
static void apply_1(SkDebugCanvas* canvas, int curCommand) {
|
|
SaveLayer* saveLayer = (SaveLayer*) canvas->getDrawCommandAt(curCommand);
|
|
const SkPaint* saveLayerPaint = saveLayer->paint();
|
|
|
|
// if (NULL == saveLayerPaint) the dbmr's paint doesn't need to be changed
|
|
if (NULL != saveLayerPaint) {
|
|
DrawBitmapRect* dbmr = (DrawBitmapRect*) canvas->getDrawCommandAt(curCommand+3);
|
|
SkPaint* dbmrPaint = dbmr->paint();
|
|
|
|
if (NULL == dbmrPaint) {
|
|
dbmr->setPaint(*saveLayerPaint);
|
|
} else {
|
|
SkColor newColor = SkColorSetA(dbmrPaint->getColor(),
|
|
SkColorGetA(saveLayerPaint->getColor()));
|
|
dbmrPaint->setColor(newColor);
|
|
}
|
|
}
|
|
|
|
canvas->deleteDrawCommandAt(curCommand+5); // restore
|
|
canvas->deleteDrawCommandAt(curCommand); // saveLayer
|
|
}
|
|
|
|
// Check for:
|
|
// SAVE
|
|
// CLIP_RECT
|
|
// DRAW_RECT
|
|
// RESTORE
|
|
// where the rect is entirely within the clip and the clip is an intersect
|
|
static bool check_2(SkDebugCanvas* canvas, int curCommand) {
|
|
if (SAVE != canvas->getDrawCommandAt(curCommand)->getType() ||
|
|
canvas->getSize() <= curCommand+4 ||
|
|
CLIP_RECT != canvas->getDrawCommandAt(curCommand+1)->getType() ||
|
|
DRAW_RECT != canvas->getDrawCommandAt(curCommand+2)->getType() ||
|
|
RESTORE != canvas->getDrawCommandAt(curCommand+3)->getType()) {
|
|
return false;
|
|
}
|
|
|
|
ClipRect* cr = (ClipRect*) canvas->getDrawCommandAt(curCommand+1);
|
|
DrawRectC* dr = (DrawRectC*) canvas->getDrawCommandAt(curCommand+2);
|
|
|
|
if (SkRegion::kIntersect_Op != cr->op()) {
|
|
return false;
|
|
}
|
|
|
|
return cr->rect().contains(dr->rect());
|
|
}
|
|
|
|
// Remove everything but the drawRect
|
|
static void apply_2(SkDebugCanvas* canvas, int curCommand) {
|
|
canvas->deleteDrawCommandAt(curCommand+3); // restore
|
|
// drawRect
|
|
canvas->deleteDrawCommandAt(curCommand+1); // clipRect
|
|
canvas->deleteDrawCommandAt(curCommand); // save
|
|
}
|
|
|
|
// Check for:
|
|
// SAVE
|
|
// CLIP_RRECT
|
|
// DRAW_RECT
|
|
// RESTORE
|
|
// where the rect entirely encloses the clip
|
|
static bool check_3(SkDebugCanvas* canvas, int curCommand) {
|
|
if (SAVE != canvas->getDrawCommandAt(curCommand)->getType() ||
|
|
canvas->getSize() <= curCommand+4 ||
|
|
CLIP_RRECT != canvas->getDrawCommandAt(curCommand+1)->getType() ||
|
|
DRAW_RECT != canvas->getDrawCommandAt(curCommand+2)->getType() ||
|
|
RESTORE != canvas->getDrawCommandAt(curCommand+3)->getType()) {
|
|
return false;
|
|
}
|
|
|
|
ClipRRect* crr = (ClipRRect*) canvas->getDrawCommandAt(curCommand+1);
|
|
DrawRectC* dr = (DrawRectC*) canvas->getDrawCommandAt(curCommand+2);
|
|
|
|
if (SkRegion::kIntersect_Op != crr->op()) {
|
|
return false;
|
|
}
|
|
|
|
return dr->rect().contains(crr->rrect().rect());
|
|
}
|
|
|
|
// Replace everything with a drawRRect with the paint from the drawRect
|
|
// and the AA settings from the clipRRect
|
|
static void apply_3(SkDebugCanvas* canvas, int curCommand) {
|
|
|
|
canvas->deleteDrawCommandAt(curCommand+3); // restore
|
|
|
|
ClipRRect* crr = (ClipRRect*) canvas->getDrawCommandAt(curCommand+1);
|
|
DrawRectC* dr = (DrawRectC*) canvas->getDrawCommandAt(curCommand+2);
|
|
|
|
// TODO: could skip paint re-creation if the AA settings already match
|
|
SkPaint newPaint = dr->paint();
|
|
newPaint.setAntiAlias(crr->doAA());
|
|
DrawRRect* drr = new DrawRRect(crr->rrect(), newPaint);
|
|
canvas->setDrawCommandAt(curCommand+2, drr);
|
|
|
|
canvas->deleteDrawCommandAt(curCommand+1); // clipRRect
|
|
canvas->deleteDrawCommandAt(curCommand); // save
|
|
}
|
|
|
|
// Check for:
|
|
// SAVE
|
|
// CLIP_RECT
|
|
// DRAW_BITMAP_RECT_TO_RECT
|
|
// RESTORE
|
|
// where the rect and drawBitmapRect dst exactly match
|
|
static bool check_4(SkDebugCanvas* canvas, int curCommand) {
|
|
if (SAVE != canvas->getDrawCommandAt(curCommand)->getType() ||
|
|
canvas->getSize() <= curCommand+4 ||
|
|
CLIP_RECT != canvas->getDrawCommandAt(curCommand+1)->getType() ||
|
|
DRAW_BITMAP_RECT_TO_RECT != canvas->getDrawCommandAt(curCommand+2)->getType() ||
|
|
RESTORE != canvas->getDrawCommandAt(curCommand+3)->getType()) {
|
|
return false;
|
|
}
|
|
|
|
ClipRect* cr = (ClipRect*) canvas->getDrawCommandAt(curCommand+1);
|
|
DrawBitmapRect* dbmr = (DrawBitmapRect*) canvas->getDrawCommandAt(curCommand+2);
|
|
|
|
if (SkRegion::kIntersect_Op != cr->op()) {
|
|
return false;
|
|
}
|
|
|
|
return dbmr->dstRect() == cr->rect();
|
|
}
|
|
|
|
// Remove everything but the drawBitmapRect
|
|
static void apply_4(SkDebugCanvas* canvas, int curCommand) {
|
|
canvas->deleteDrawCommandAt(curCommand+3); // restore
|
|
// drawBitmapRectToRect
|
|
canvas->deleteDrawCommandAt(curCommand+1); // clipRect
|
|
canvas->deleteDrawCommandAt(curCommand); // save
|
|
}
|
|
|
|
// Check for:
|
|
// TRANSLATE
|
|
// where the translate is zero
|
|
static bool check_5(SkDebugCanvas* canvas, int curCommand) {
|
|
if (TRANSLATE != canvas->getDrawCommandAt(curCommand)->getType()) {
|
|
return false;
|
|
}
|
|
|
|
Translate* t = (Translate*) canvas->getDrawCommandAt(curCommand);
|
|
|
|
return 0 == t->x() && 0 == t->y();
|
|
}
|
|
|
|
// Just remove the translate
|
|
static void apply_5(SkDebugCanvas* canvas, int curCommand) {
|
|
canvas->deleteDrawCommandAt(curCommand); // translate
|
|
}
|
|
|
|
// Check for:
|
|
// SCALE
|
|
// where the scale is 1,1
|
|
static bool check_6(SkDebugCanvas* canvas, int curCommand) {
|
|
if (SCALE != canvas->getDrawCommandAt(curCommand)->getType()) {
|
|
return false;
|
|
}
|
|
|
|
Scale* s = (Scale*) canvas->getDrawCommandAt(curCommand);
|
|
|
|
return SK_Scalar1 == s->x() && SK_Scalar1 == s->y();
|
|
}
|
|
|
|
// Just remove the scale
|
|
static void apply_6(SkDebugCanvas* canvas, int curCommand) {
|
|
canvas->deleteDrawCommandAt(curCommand); // scale
|
|
}
|
|
|
|
// Check for:
|
|
// SAVE
|
|
// CLIP_RECT
|
|
// SAVE_LAYER
|
|
// SAVE
|
|
// CLIP_RECT
|
|
// SAVE_LAYER
|
|
// SAVE
|
|
// CLIP_RECT
|
|
// DRAWBITMAPRECTTORECT
|
|
// RESTORE
|
|
// RESTORE
|
|
// RESTORE
|
|
// RESTORE
|
|
// RESTORE
|
|
// where:
|
|
// all the clipRect's are BW, nested, intersections
|
|
// the drawBitmapRectToRect is a 1-1 copy from src to dest
|
|
// the last (smallest) clip rect is a subset of the drawBitmapRectToRect's dest rect
|
|
// all the saveLayer's paints can be rolled into the drawBitmapRectToRect's paint
|
|
// This pattern is used by Google spreadsheet when drawing the toolbar buttons
|
|
static bool check_7(SkDebugCanvas* canvas, int curCommand) {
|
|
if (SAVE != canvas->getDrawCommandAt(curCommand)->getType() ||
|
|
canvas->getSize() <= curCommand+13 ||
|
|
CLIP_RECT != canvas->getDrawCommandAt(curCommand+1)->getType() ||
|
|
SAVE_LAYER != canvas->getDrawCommandAt(curCommand+2)->getType() ||
|
|
SAVE != canvas->getDrawCommandAt(curCommand+3)->getType() ||
|
|
CLIP_RECT != canvas->getDrawCommandAt(curCommand+4)->getType() ||
|
|
SAVE_LAYER != canvas->getDrawCommandAt(curCommand+5)->getType() ||
|
|
SAVE != canvas->getDrawCommandAt(curCommand+6)->getType() ||
|
|
CLIP_RECT != canvas->getDrawCommandAt(curCommand+7)->getType() ||
|
|
DRAW_BITMAP_RECT_TO_RECT != canvas->getDrawCommandAt(curCommand+8)->getType() ||
|
|
RESTORE != canvas->getDrawCommandAt(curCommand+9)->getType() ||
|
|
RESTORE != canvas->getDrawCommandAt(curCommand+10)->getType() ||
|
|
RESTORE != canvas->getDrawCommandAt(curCommand+11)->getType() ||
|
|
RESTORE != canvas->getDrawCommandAt(curCommand+12)->getType() ||
|
|
RESTORE != canvas->getDrawCommandAt(curCommand+13)->getType()) {
|
|
return false;
|
|
}
|
|
|
|
ClipRect* clip0 = (ClipRect*) canvas->getDrawCommandAt(curCommand+1);
|
|
SaveLayer* saveLayer0 = (SaveLayer*) canvas->getDrawCommandAt(curCommand+2);
|
|
ClipRect* clip1 = (ClipRect*) canvas->getDrawCommandAt(curCommand+4);
|
|
SaveLayer* saveLayer1 = (SaveLayer*) canvas->getDrawCommandAt(curCommand+5);
|
|
ClipRect* clip2 = (ClipRect*) canvas->getDrawCommandAt(curCommand+7);
|
|
DrawBitmapRect* dbmr = (DrawBitmapRect*) canvas->getDrawCommandAt(curCommand+8);
|
|
|
|
if (clip0->doAA() || clip1->doAA() || clip2->doAA()) {
|
|
return false;
|
|
}
|
|
|
|
if (SkRegion::kIntersect_Op != clip0->op() ||
|
|
SkRegion::kIntersect_Op != clip1->op() ||
|
|
SkRegion::kIntersect_Op != clip2->op()) {
|
|
return false;
|
|
}
|
|
|
|
if (!clip0->rect().contains(clip1->rect()) ||
|
|
!clip1->rect().contains(clip2->rect())) {
|
|
return false;
|
|
}
|
|
|
|
// The src->dest mapping needs to be 1-to-1
|
|
if (NULL == dbmr->srcRect()) {
|
|
if (dbmr->bitmap().width() != dbmr->dstRect().width() ||
|
|
dbmr->bitmap().height() != dbmr->dstRect().height()) {
|
|
return false;
|
|
}
|
|
} else {
|
|
if (dbmr->srcRect()->width() != dbmr->dstRect().width() ||
|
|
dbmr->srcRect()->height() != dbmr->dstRect().height()) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (!dbmr->dstRect().contains(clip2->rect())) {
|
|
return false;
|
|
}
|
|
|
|
const SkPaint* saveLayerPaint0 = saveLayer0->paint();
|
|
const SkPaint* saveLayerPaint1 = saveLayer1->paint();
|
|
|
|
if ((NULL != saveLayerPaint0 && !is_simple(*saveLayerPaint0)) ||
|
|
(NULL != saveLayerPaint1 && !is_simple(*saveLayerPaint1))) {
|
|
return false;
|
|
}
|
|
|
|
SkPaint* dbmrPaint = dbmr->paint();
|
|
|
|
if (NULL == dbmrPaint) {
|
|
return true;
|
|
}
|
|
|
|
if (NULL != saveLayerPaint0) {
|
|
SkColor layerColor0 = saveLayerPaint0->getColor() | 0xFF000000; // force opaque
|
|
if (dbmrPaint->getColor() != layerColor0) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (NULL != saveLayerPaint1) {
|
|
SkColor layerColor1 = saveLayerPaint1->getColor() | 0xFF000000; // force opaque
|
|
if (dbmrPaint->getColor() != layerColor1) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// Reduce to a single drawBitmapRectToRect call by folding the clipRect's into
|
|
// the src and dst Rects and the saveLayer paints into the drawBitmapRectToRect's
|
|
// paint.
|
|
static void apply_7(SkDebugCanvas* canvas, int curCommand) {
|
|
SaveLayer* saveLayer0 = (SaveLayer*) canvas->getDrawCommandAt(curCommand+2);
|
|
SaveLayer* saveLayer1 = (SaveLayer*) canvas->getDrawCommandAt(curCommand+5);
|
|
ClipRect* clip2 = (ClipRect*) canvas->getDrawCommandAt(curCommand+7);
|
|
DrawBitmapRect* dbmr = (DrawBitmapRect*) canvas->getDrawCommandAt(curCommand+8);
|
|
|
|
SkScalar newSrcLeft = dbmr->srcRect()->fLeft + clip2->rect().fLeft - dbmr->dstRect().fLeft;
|
|
SkScalar newSrcTop = dbmr->srcRect()->fTop + clip2->rect().fTop - dbmr->dstRect().fTop;
|
|
|
|
SkRect newSrc = SkRect::MakeXYWH(newSrcLeft, newSrcTop,
|
|
clip2->rect().width(), clip2->rect().height());
|
|
|
|
dbmr->setSrcRect(newSrc);
|
|
dbmr->setDstRect(clip2->rect());
|
|
|
|
SkColor color = 0xFF000000;
|
|
int a0, a1;
|
|
|
|
const SkPaint* saveLayerPaint0 = saveLayer0->paint();
|
|
if (NULL != saveLayerPaint0) {
|
|
color = saveLayerPaint0->getColor();
|
|
a0 = SkColorGetA(color);
|
|
} else {
|
|
a0 = 0xFF;
|
|
}
|
|
|
|
const SkPaint* saveLayerPaint1 = saveLayer1->paint();
|
|
if (NULL != saveLayerPaint1) {
|
|
color = saveLayerPaint1->getColor();
|
|
a1 = SkColorGetA(color);
|
|
} else {
|
|
a1 = 0xFF;
|
|
}
|
|
|
|
int newA = (a0 * a1) / 255;
|
|
SkASSERT(newA <= 0xFF);
|
|
|
|
SkPaint* dbmrPaint = dbmr->paint();
|
|
|
|
if (NULL != dbmrPaint) {
|
|
SkColor newColor = SkColorSetA(dbmrPaint->getColor(), newA);
|
|
dbmrPaint->setColor(newColor);
|
|
} else {
|
|
SkColor newColor = SkColorSetA(color, newA);
|
|
|
|
SkPaint newPaint;
|
|
newPaint.setColor(newColor);
|
|
dbmr->setPaint(newPaint);
|
|
}
|
|
|
|
// remove everything except the drawbitmaprect
|
|
canvas->deleteDrawCommandAt(curCommand+13); // restore
|
|
canvas->deleteDrawCommandAt(curCommand+12); // restore
|
|
canvas->deleteDrawCommandAt(curCommand+11); // restore
|
|
canvas->deleteDrawCommandAt(curCommand+10); // restore
|
|
canvas->deleteDrawCommandAt(curCommand+9); // restore
|
|
canvas->deleteDrawCommandAt(curCommand+7); // clipRect
|
|
canvas->deleteDrawCommandAt(curCommand+6); // save
|
|
canvas->deleteDrawCommandAt(curCommand+5); // saveLayer
|
|
canvas->deleteDrawCommandAt(curCommand+4); // clipRect
|
|
canvas->deleteDrawCommandAt(curCommand+3); // save
|
|
canvas->deleteDrawCommandAt(curCommand+2); // saveLayer
|
|
canvas->deleteDrawCommandAt(curCommand+1); // clipRect
|
|
canvas->deleteDrawCommandAt(curCommand); // save
|
|
}
|
|
|
|
typedef bool (*PFCheck)(SkDebugCanvas* canvas, int curCommand);
|
|
typedef void (*PFApply)(SkDebugCanvas* canvas, int curCommand);
|
|
|
|
struct OptTableEntry {
|
|
PFCheck fCheck;
|
|
PFApply fApply;
|
|
int fNumTimesApplied;
|
|
} gOptTable[] = {
|
|
{ check_0, apply_0, 0 },
|
|
{ check_1, apply_1, 0 },
|
|
{ check_2, apply_2, 0 },
|
|
{ check_3, apply_3, 0 },
|
|
{ check_4, apply_4, 0 },
|
|
{ check_5, apply_5, 0 },
|
|
{ check_6, apply_6, 0 },
|
|
{ check_7, apply_7, 0 },
|
|
};
|
|
|
|
|
|
static int filter_picture(const SkString& inFile, const SkString& outFile) {
|
|
SkPicture* inPicture = NULL;
|
|
|
|
SkFILEStream inStream(inFile.c_str());
|
|
if (inStream.isValid()) {
|
|
inPicture = SkNEW_ARGS(SkPicture, (&inStream, NULL, &SkImageDecoder::DecodeMemory));
|
|
}
|
|
|
|
if (NULL == inPicture) {
|
|
SkDebugf("Could not read file %s\n", inFile.c_str());
|
|
return -1;
|
|
}
|
|
|
|
int localCount[SK_ARRAY_COUNT(gOptTable)];
|
|
|
|
memset(localCount, 0, sizeof(localCount));
|
|
|
|
SkDebugCanvas debugCanvas(inPicture->width(), inPicture->height());
|
|
debugCanvas.setBounds(inPicture->width(), inPicture->height());
|
|
inPicture->draw(&debugCanvas);
|
|
|
|
// delete the initial save and restore since replaying the commands will
|
|
// re-add them
|
|
if (debugCanvas.getSize() > 1) {
|
|
debugCanvas.deleteDrawCommandAt(0);
|
|
debugCanvas.deleteDrawCommandAt(debugCanvas.getSize()-1);
|
|
}
|
|
|
|
bool changed = true;
|
|
|
|
while (changed) {
|
|
changed = false;
|
|
for (int i = 0; i < debugCanvas.getSize(); ++i) {
|
|
for (size_t opt = 0; opt < SK_ARRAY_COUNT(gOptTable); ++opt) {
|
|
if ((*gOptTable[opt].fCheck)(&debugCanvas, i)) {
|
|
(*gOptTable[opt].fApply)(&debugCanvas, i);
|
|
|
|
++gOptTable[opt].fNumTimesApplied;
|
|
++localCount[opt];
|
|
|
|
if (debugCanvas.getSize() == i) {
|
|
// the optimization removed all the remaining operations
|
|
break;
|
|
}
|
|
|
|
opt = 0; // try all the opts all over again
|
|
changed = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!outFile.isEmpty()) {
|
|
SkPicture outPicture;
|
|
|
|
SkCanvas* canvas = outPicture.beginRecording(inPicture->width(), inPicture->height());
|
|
debugCanvas.draw(canvas);
|
|
outPicture.endRecording();
|
|
|
|
SkFILEWStream outStream(outFile.c_str());
|
|
|
|
outPicture.serialize(&outStream);
|
|
}
|
|
|
|
bool someOptFired = false;
|
|
for (size_t opt = 0; opt < SK_ARRAY_COUNT(gOptTable); ++opt) {
|
|
if (0 != localCount[opt]) {
|
|
SkDebugf("%d: %d ", opt, localCount[opt]);
|
|
someOptFired = true;
|
|
}
|
|
}
|
|
|
|
if (!someOptFired) {
|
|
SkDebugf("No opts fired\n");
|
|
} else {
|
|
SkDebugf("\n");
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
// This function is not marked as 'static' so it can be referenced externally
|
|
// in the iOS build.
|
|
int tool_main(int argc, char** argv); // suppress a warning on mac
|
|
|
|
int tool_main(int argc, char** argv) {
|
|
SkGraphics::Init();
|
|
|
|
if (argc < 3) {
|
|
usage();
|
|
return -1;
|
|
}
|
|
|
|
SkString inFile, outFile, inDir, outDir;
|
|
|
|
char* const* stop = argv + argc;
|
|
for (++argv; argv < stop; ++argv) {
|
|
if (strcmp(*argv, "-i") == 0) {
|
|
argv++;
|
|
if (argv < stop && **argv) {
|
|
inFile.set(*argv);
|
|
} else {
|
|
SkDebugf("missing arg for -i\n");
|
|
usage();
|
|
return -1;
|
|
}
|
|
} else if (strcmp(*argv, "--input-dir") == 0) {
|
|
argv++;
|
|
if (argv < stop && **argv) {
|
|
inDir.set(*argv);
|
|
} else {
|
|
SkDebugf("missing arg for --input-dir\n");
|
|
usage();
|
|
return -1;
|
|
}
|
|
} else if (strcmp(*argv, "--output-dir") == 0) {
|
|
argv++;
|
|
if (argv < stop && **argv) {
|
|
outDir.set(*argv);
|
|
} else {
|
|
SkDebugf("missing arg for --output-dir\n");
|
|
usage();
|
|
return -1;
|
|
}
|
|
} else if (strcmp(*argv, "-o") == 0) {
|
|
argv++;
|
|
if (argv < stop && **argv) {
|
|
outFile.set(*argv);
|
|
} else {
|
|
SkDebugf("missing arg for -o\n");
|
|
usage();
|
|
return -1;
|
|
}
|
|
} else if (strcmp(*argv, "--help") == 0 || strcmp(*argv, "-h") == 0) {
|
|
usage();
|
|
return 0;
|
|
} else {
|
|
SkDebugf("unknown arg %s\n", *argv);
|
|
usage();
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
SkOSFile::Iter iter(inDir.c_str(), "skp");
|
|
|
|
SkString inputFilename, outputFilename;
|
|
if (iter.next(&inputFilename)) {
|
|
|
|
do {
|
|
sk_tools::make_filepath(&inFile, inDir, inputFilename);
|
|
if (!outDir.isEmpty()) {
|
|
sk_tools::make_filepath(&outFile, outDir, inputFilename);
|
|
}
|
|
SkDebugf("Executing %s\n", inputFilename.c_str());
|
|
filter_picture(inFile, outFile);
|
|
} while(iter.next(&inputFilename));
|
|
|
|
} else if (!inFile.isEmpty()) {
|
|
filter_picture(inFile, outFile);
|
|
} else {
|
|
usage();
|
|
return -1;
|
|
}
|
|
|
|
for (size_t opt = 0; opt < SK_ARRAY_COUNT(gOptTable); ++opt) {
|
|
SkDebugf("opt %d: %d\n", opt, gOptTable[opt].fNumTimesApplied);
|
|
}
|
|
|
|
SkGraphics::Term();
|
|
return 0;
|
|
}
|
|
|
|
#if !defined SK_BUILD_FOR_IOS
|
|
int main(int argc, char * const argv[]) {
|
|
return tool_main(argc, (char**) argv);
|
|
}
|
|
#endif
|