AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Flags for render_pictures: verify, clone and writeWholeImage:

Browse Source 
1) flag to verify PNGs produced by render_picture that produce the same pixels
as simple renderer.
2) flag to write one single image (in tile we write individual tiles) - this
will help running skdiff also
3) flag to clone the picture before rendering

git-svn-id: http://skia.googlecode.com/svn/trunk@6890 2bbb7eff-a529-9590-31e7-b0007b416f81
This commit is contained in:
edisonn@google.com 2012-12-18 22:24:03 +00:00
parent 6d0673042f
commit 84f548cc9d
5 changed files with 300 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
tools/CopyTilesRenderer.cpp
View File

@ -34,7 +34,7 @@ namespace sk_tools {
fCanvas.reset(this->INHERITED::setupCanvas(fLargeTileWidth, fLargeTileHeight));
}
bool CopyTilesRenderer::render(const SkString* path) {
bool CopyTilesRenderer::render(const SkString* path, SkBitmap** out) {
int i = 0;
bool success = true;
SkBitmap dst;

2
tools/CopyTilesRenderer.h
View File

@ -29,7 +29,7 @@ namespace sk_tools {
* Similar to TiledPictureRenderer, this will draw a PNG for each tile. However, the
* numbering (and actual tiles) will be different.
*/
virtual bool render(const SkString* path) SK_OVERRIDE;
virtual bool render(const SkString* path, SkBitmap** out) SK_OVERRIDE;
private:
int fXTilesPerLargeTile;

88
tools/PictureRenderer.cpp
View File

@ -243,7 +243,7 @@ static bool PNGEncodeBitmapToStream(SkWStream* wStream, const SkBitmap& bm) {
return SkImageEncoder::EncodeStream(wStream, bm, SkImageEncoder::kPNG_Type, 100);
}
bool RecordPictureRenderer::render(const SkString* path) {
bool RecordPictureRenderer::render(const SkString* path, SkBitmap** out) {
SkAutoTUnref<SkPicture> replayer(this->createPicture());
SkCanvas* recorder = replayer->beginRecording(this->getViewWidth(), this->getViewHeight(),
this->recordFlags());
@ -268,7 +268,7 @@ SkString RecordPictureRenderer::getConfigNameInternal() {
///////////////////////////////////////////////////////////////////////////////////////////////
bool PipePictureRenderer::render(const SkString* path) {
bool PipePictureRenderer::render(const SkString* path, SkBitmap** out) {
SkASSERT(fCanvas.get() != NULL);
SkASSERT(fPicture != NULL);
if (NULL == fCanvas.get() || NULL == fPicture) {
@ -284,6 +284,11 @@ bool PipePictureRenderer::render(const SkString* path) {
if (NULL != path) {
return write(fCanvas, *path);
}
if (NULL != out) {
*out = SkNEW(SkBitmap);
setup_bitmap(*out, fPicture->width(), fPicture->height());
fCanvas->readPixels(*out, 0, 0);
}
return true;
}
@ -298,7 +303,7 @@ void SimplePictureRenderer::init(SkPicture* picture) {
this->buildBBoxHierarchy();
}
bool SimplePictureRenderer::render(const SkString* path) {
bool SimplePictureRenderer::render(const SkString* path, SkBitmap** out) {
SkASSERT(fCanvas.get() != NULL);
SkASSERT(fPicture != NULL);
if (NULL == fCanvas.get() || NULL == fPicture) {
@ -310,6 +315,13 @@ bool SimplePictureRenderer::render(const SkString* path) {
if (NULL != path) {
return write(fCanvas, *path);
}
if (NULL != out) {
*out = SkNEW(SkBitmap);
setup_bitmap(*out, fPicture->width(), fPicture->height());
fCanvas->readPixels(*out, 0, 0);
}
return true;
}
@ -467,6 +479,15 @@ static void DrawTileToCanvas(SkCanvas* canvas, const SkRect& tileRect, T* playba
///////////////////////////////////////////////////////////////////////////////////////////////
static void bitmapCopySubset(const SkBitmap& src, SkBitmap* dst, int xDst,
int yDst) {
for (int y = 0; y <src.height() && y + yDst < dst->height() ; y++) {
for (int x = 0; x < src.width() && x + xDst < dst->width() ; x++) {
*dst->getAddr32(xDst + x, yDst + y) = *src.getAddr32(x, y);
}
}
}
bool TiledPictureRenderer::nextTile(int &i, int &j) {
if (++fCurrentTileOffset < fTileRects.count()) {
i = fCurrentTileOffset % fTilesX;
@ -481,18 +502,32 @@ void TiledPictureRenderer::drawCurrentTile() {
DrawTileToCanvas(fCanvas, fTileRects[fCurrentTileOffset], fPicture);
}
bool TiledPictureRenderer::render(const SkString* path) {
bool TiledPictureRenderer::render(const SkString* path, SkBitmap** out) {
SkASSERT(fPicture != NULL);
if (NULL == fPicture) {
return false;
}
SkBitmap bitmap;
if (out){
*out = SkNEW(SkBitmap);
setup_bitmap(*out, fPicture->width(), fPicture->height());
setup_bitmap(&bitmap, fTileWidth, fTileHeight);
}
bool success = true;
for (int i = 0; i < fTileRects.count(); ++i) {
DrawTileToCanvas(fCanvas, fTileRects[i], fPicture);
if (NULL != path) {
success &= writeAppendNumber(fCanvas, path, i);
}
if (NULL != out) {
if (fCanvas->readPixels(&bitmap, 0, 0)) {
bitmapCopySubset(bitmap, *out, fTileRects[i].left(),
fTileRects[i].top());
} else {
success = false;
}
}
}
return success;
}
@ -555,6 +590,13 @@ public:
virtual void run() SK_OVERRIDE {
SkGraphics::SetTLSFontCacheLimit(1024 * 1024);
SkBitmap bitmap;
if (fBitmap != NULL) {
// All tiles are the same size.
setup_bitmap(&bitmap, fRects[0].width(), fRects[0].height());
}
for (int i = fStart; i < fEnd; i++) {
DrawTileToCanvas(fCanvas, fRects[i], fClone);
if (fPath != NULL && !writeAppendNumber(fCanvas, fPath, i)
@ -563,6 +605,17 @@ public:
// If one tile fails to write to a file, do not continue drawing the rest.
break;
}
if (fBitmap != NULL) {
if (fCanvas->readPixels(&bitmap, 0, 0)) {
SkAutoLockPixels alp(*fBitmap);
bitmapCopySubset(bitmap, fBitmap, fRects[i].left(),
fRects[i].top());
} else {
*fSuccess = false;
// If one tile fails to read pixels, do not continue drawing the rest.
break;
}
}
}
fDone->run();
}
@ -572,6 +625,10 @@ public:
fSuccess = success;
}
void setBitmap(SkBitmap* bitmap) {
fBitmap = bitmap;
}
private:
// All pointers unowned.
SkPicture* fClone; // Picture to draw from. Each CloneData has a unique one which
@ -584,6 +641,7 @@ private:
bool* fSuccess; // Only meaningful if path is non-null. Shared by all threads,
// and only set to false upon failure to write to a PNG.
SkRunnable* fDone;
SkBitmap* fBitmap;
};
MultiCorePictureRenderer::MultiCorePictureRenderer(int threadCount)
@ -623,7 +681,7 @@ void MultiCorePictureRenderer::init(SkPicture *pict) {
}
}
bool MultiCorePictureRenderer::render(const SkString *path) {
bool MultiCorePictureRenderer::render(const SkString *path, SkBitmap** out) {
bool success = true;
if (path != NULL) {
for (int i = 0; i < fNumThreads-1; i++) {
@ -631,6 +689,18 @@ bool MultiCorePictureRenderer::render(const SkString *path) {
}
}
if (NULL != out) {
*out = SkNEW(SkBitmap);
setup_bitmap(*out, fPicture->width(), fPicture->height());
for (int i = 0; i < fNumThreads; i++) {
fCloneData[i]->setBitmap(*out);
}
} else {
for (int i = 0; i < fNumThreads; i++) {
fCloneData[i]->setBitmap(NULL);
}
}
fCountdown.reset(fNumThreads);
for (int i = 0; i < fNumThreads; i++) {
fThreadPool.add(fCloneData[i]);
@ -673,7 +743,7 @@ void PlaybackCreationRenderer::setup() {
fPicture->draw(recorder);
}
bool PlaybackCreationRenderer::render(const SkString*) {
bool PlaybackCreationRenderer::render(const SkString*, SkBitmap** out) {
fReplayer->endRecording();
// Since this class does not actually render, return false.
return false;
@ -716,7 +786,8 @@ SkPicture* PictureRenderer::createPicture() {
class GatherRenderer : public PictureRenderer {
public:
virtual bool render(const SkString* path) SK_OVERRIDE {
virtual bool render(const SkString* path, SkBitmap** out = NULL)
SK_OVERRIDE {
SkRect bounds = SkRect::MakeWH(SkIntToScalar(fPicture->width()),
SkIntToScalar(fPicture->height()));
SkData* data = SkPictureUtils::GatherPixelRefs(fPicture, bounds);
@ -739,7 +810,8 @@ PictureRenderer* CreateGatherPixelRefsRenderer() {
class PictureCloneRenderer : public PictureRenderer {
public:
virtual bool render(const SkString* path) SK_OVERRIDE {
virtual bool render(const SkString* path, SkBitmap** out = NULL)
SK_OVERRIDE {
for (int i = 0; i < 100; ++i) {
SkPicture* clone = fPicture->clone();
SkSafeUnref(clone);

14
tools/PictureRenderer.h
View File

@ -96,7 +96,7 @@ public:
* @return bool True if rendering succeeded and, if path is non-null, the output was
* successfully written to a file.
*/
virtual bool render(const SkString* path) = 0;
virtual bool render(const SkString* path, SkBitmap** out = NULL) = 0;
/**
* Called once finished with a particular SkPicture, before calling init again, and before
@ -245,7 +245,7 @@ private:
* to time.
*/
class RecordPictureRenderer : public PictureRenderer {
virtual bool render(const SkString*) SK_OVERRIDE;
virtual bool render(const SkString*, SkBitmap** out = NULL) SK_OVERRIDE;
virtual SkString getPerIterTimeFormat() SK_OVERRIDE { return SkString("%.4f"); }
@ -260,7 +260,7 @@ private:
class PipePictureRenderer : public PictureRenderer {
public:
virtual bool render(const SkString*) SK_OVERRIDE;
virtual bool render(const SkString*, SkBitmap** out = NULL) SK_OVERRIDE;
private:
virtual SkString getConfigNameInternal() SK_OVERRIDE;
@ -272,7 +272,7 @@ class SimplePictureRenderer : public PictureRenderer {
public:
virtual void init(SkPicture* pict) SK_OVERRIDE;
virtual bool render(const SkString*) SK_OVERRIDE;
virtual bool render(const SkString*, SkBitmap** out = NULL) SK_OVERRIDE;
private:
virtual SkString getConfigNameInternal() SK_OVERRIDE;
@ -291,7 +291,7 @@ public:
* created for each tile, named "path0.png", "path1.png", etc.
* Multithreaded mode currently does not support writing to a file.
*/
virtual bool render(const SkString* path) SK_OVERRIDE;
virtual bool render(const SkString* path, SkBitmap** out = NULL) SK_OVERRIDE;
virtual void end() SK_OVERRIDE;
@ -410,7 +410,7 @@ public:
/**
* Behaves like TiledPictureRenderer::render(), only using multiple threads.
*/
virtual bool render(const SkString* path) SK_OVERRIDE;
virtual bool render(const SkString* path, SkBitmap** out = NULL) SK_OVERRIDE;
virtual void end() SK_OVERRIDE;
@ -435,7 +435,7 @@ class PlaybackCreationRenderer : public PictureRenderer {
public:
virtual void setup() SK_OVERRIDE;
virtual bool render(const SkString*) SK_OVERRIDE;
virtual bool render(const SkString*, SkBitmap** out = NULL) SK_OVERRIDE;
virtual SkString getPerIterTimeFormat() SK_OVERRIDE { return SkString("%.4f"); }

222
tools/render_pictures_main.cpp
View File

@ -11,6 +11,7 @@
#include "SkDevice.h"
#include "SkGraphics.h"
#include "SkImageDecoder.h"
#include "SkImageEncoder.h"
#include "SkMath.h"
#include "SkOSFile.h"
#include "SkPicture.h"
@ -29,7 +30,11 @@ static void usage(const char* argv0) {
" [--mode pow2tile minWidth height | copyTile width height | simple\n"
" | tile width height]\n"
" [--pipe]\n"
" [--bbh bbhType]\n"
" [--multi count]\n"
" [--validate]\n"
" [--writeWholeImage]\n"
" [--clone n]\n"
" [--viewport width height][--scale sf]\n"
" [--device bitmap"
#if SK_SUPPORT_GPU
@ -79,6 +84,20 @@ static void usage(const char* argv0) {
" --scale sf : Scale drawing by sf.\n"
" --pipe: Benchmark SkGPipe rendering. Currently incompatible with \"mode\".\n");
SkDebugf(
" --validate: Verify that the rendered image contains the same pixels as "
"the picture rendered in simple mode.\n"
" --writeWholeImage: In tile mode, write the entire rendered image to a "
"file, instead of an image for each tile.\n");
SkDebugf(
" --clone n: Clone the picture n times before rendering.\n");
SkDebugf(
" --bbh bbhType [width height]: Set the bounding box hierarchy type to\n"
" be used. Accepted values are: none, rtree, grid. Default\n"
" value is none. Not compatible with --pipe. With value\n"
" 'grid', width and height must be specified. 'grid' can\n"
" only be used with modes tile, record, and\n"
" playbackCreation.");
SkDebugf(
" --device bitmap"
#if SK_SUPPORT_GPU
" | gpu"
@ -100,7 +119,9 @@ static void make_output_filepath(SkString* path, const SkString& dir,
}
static bool render_picture(const SkString& inputPath, const SkString* outputDir,
sk_tools::PictureRenderer& renderer) {
sk_tools::PictureRenderer& renderer,
SkBitmap** out,
int clones) {
SkString inputFilename;
sk_tools::get_basename(&inputFilename, inputPath);
@ -112,16 +133,23 @@ static bool render_picture(const SkString& inputPath, const SkString* outputDir,
}
bool success = false;
SkPicture picture(&inputStream, &success, &SkImageDecoder::DecodeStream);
SkPicture* picture = SkNEW_ARGS(SkPicture,
(&inputStream, &success, &SkImageDecoder::DecodeStream));
if (!success) {
SkDebugf("Could not read an SkPicture from %s\n", inputPath.c_str());
return false;
}
SkDebugf("drawing... [%i %i] %s\n", picture.width(), picture.height(),
for (int i = 0; i < clones; ++i) {
SkPicture* clone = picture->clone();
SkDELETE(picture);
picture = clone;
}
SkDebugf("drawing... [%i %i] %s\n", picture->width(), picture->height(),
inputPath.c_str());
renderer.init(&picture);
renderer.init(picture);
renderer.setup();
SkString* outputPath = NULL;
@ -129,7 +157,8 @@ static bool render_picture(const SkString& inputPath, const SkString* outputDir,
outputPath = SkNEW(SkString);
make_output_filepath(outputPath, *outputDir, inputFilename);
}
success = renderer.render(outputPath);
success = renderer.render(outputPath, out);
if (outputPath) {
if (!success) {
SkDebugf("Could not write to file %s\n", outputPath->c_str());
@ -140,11 +169,96 @@ static bool render_picture(const SkString& inputPath, const SkString* outputDir,
renderer.resetState();
renderer.end();
SkDELETE(picture);
return success;
}
static bool render_picture(const SkString& inputPath, const SkString* outputDir,
sk_tools::PictureRenderer& renderer,
bool validate,
bool writeWholeImage,
int clones) {
SkBitmap* bitmap = NULL;
bool success = render_picture(inputPath,
writeWholeImage ? NULL : outputDir,
renderer,
validate || writeWholeImage ? &bitmap : NULL, clones);
if (!success || ((validate || writeWholeImage) && bitmap == NULL)) {
SkDebugf("Failed to draw the picture.\n");
SkDELETE(bitmap);
return false;
}
if (validate) {
SkBitmap* referenceBitmap = NULL;
sk_tools::SimplePictureRenderer referenceRenderer;
success = render_picture(inputPath, NULL, referenceRenderer,
&referenceBitmap, 0);
if (!success || !referenceBitmap) {
SkDebugf("Failed to draw the reference picture.\n");
SkDELETE(bitmap);
SkDELETE(referenceBitmap);
return false;
}
if (success && (bitmap->width() != referenceBitmap->width())) {
SkDebugf("Expected image width: %i, actual image width %i.\n",
referenceBitmap->width(), bitmap->width());
SkDELETE(bitmap);
SkDELETE(referenceBitmap);
return false;
}
if (success && (bitmap->height() != referenceBitmap->height())) {
SkDebugf("Expected image height: %i, actual image height %i",
referenceBitmap->height(), bitmap->height());
SkDELETE(bitmap);
SkDELETE(referenceBitmap);
return false;
}
for (int y = 0; success && y < bitmap->height(); y++) {
for (int x = 0; success && x < bitmap->width(); x++) {
if (*referenceBitmap->getAddr32(x, y) != *bitmap->getAddr32(x, y)) {
SkDebugf("Expected pixel at (%i %i): 0x%x, actual 0x%x\n",
x, y,
referenceBitmap->getAddr32(x, y),
*bitmap->getAddr32(x, y));
SkDELETE(bitmap);
SkDELETE(referenceBitmap);
return false;
}
}
}
SkDELETE(referenceBitmap);
}
if (writeWholeImage) {
sk_tools::force_all_opaque(*bitmap);
if (NULL != outputDir && writeWholeImage) {
SkString inputFilename;
sk_tools::get_basename(&inputFilename, inputPath);
SkString outputPath;
make_output_filepath(&outputPath, *outputDir, inputFilename);
outputPath.append(".png");
if (!SkImageEncoder::EncodeFile(outputPath.c_str(), *bitmap,
SkImageEncoder::kPNG_Type, 100)) {
SkDebugf("Failed to draw the picture.\n");
success = false;
}
}
}
SkDELETE(bitmap);
return success;
}
static int process_input(const SkString& input, const SkString* outputDir,
sk_tools::PictureRenderer& renderer) {
sk_tools::PictureRenderer& renderer,
bool validate, bool writeWholeImage, int clones) {
SkOSFile::Iter iter(input.c_str(), "skp");
SkString inputFilename;
int failures = 0;
@ -153,13 +267,15 @@ static int process_input(const SkString& input, const SkString* outputDir,
do {
SkString inputPath;
sk_tools::make_filepath(&inputPath, input, inputFilename);
if (!render_picture(inputPath, outputDir, renderer)) {
if (!render_picture(inputPath, outputDir, renderer,
validate, writeWholeImage, clones)) {
++failures;
}
} while(iter.next(&inputFilename));
} else if (SkStrEndsWith(input.c_str(), ".skp")) {
SkString inputPath(input);
if (!render_picture(inputPath, outputDir, renderer)) {
if (!render_picture(inputPath, outputDir, renderer,
validate, writeWholeImage, clones)) {
++failures;
}
} else {
@ -171,7 +287,9 @@ static int process_input(const SkString& input, const SkString* outputDir,
}
static void parse_commandline(int argc, char* const argv[], SkTArray<SkString>* inputs,
sk_tools::PictureRenderer*& renderer, SkString*& outputDir){
sk_tools::PictureRenderer*& renderer, SkString*& outputDir,
bool* validate, bool* writeWholeImage,
int* clones){
const char* argv0 = argv[0];
char* const* stop = argv + argc;
@ -183,14 +301,23 @@ static void parse_commandline(int argc, char* const argv[], SkTArray<SkString>*
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) {
@ -218,6 +345,8 @@ static void parse_commandline(int argc, char* const argv[], SkTArray<SkString>*
isPowerOf2Mode = true;
} else if (0 == strcmp(*argv, "copyTile")) {
isCopyMode = true;
} else {
gridSupported = true;
}
++argv;
@ -242,6 +371,38 @@ static void parse_commandline(int argc, char* const argv[], SkTArray<SkString>*
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) {
@ -297,6 +458,21 @@ static void parse_commandline(int argc, char* const argv[], SkTArray<SkString>*
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) {
@ -333,6 +509,10 @@ static void parse_commandline(int argc, char* const argv[], SkTArray<SkString>*
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));
}
@ -345,6 +525,19 @@ static void parse_commandline(int argc, char* const argv[], SkTArray<SkString>*
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;
@ -469,6 +662,8 @@ static void parse_commandline(int argc, char* const argv[], SkTArray<SkString>*
renderer = SkNEW(sk_tools::SimplePictureRenderer);
}
renderer->setBBoxHierarchyType(bbhType);
renderer->setGridSize(gridWidth, gridHeight);
renderer->setViewport(viewport);
renderer->setScaleFactor(scaleFactor);
renderer->setDeviceType(deviceType);
@ -480,12 +675,17 @@ int tool_main(int argc, char** argv) {
SkTArray<SkString> inputs;
sk_tools::PictureRenderer* renderer = NULL;
SkString* outputDir = NULL;
parse_commandline(argc, argv, &inputs, renderer, outputDir);
bool validate = false;
bool writeWholeImage = false;
int clones = 0;
parse_commandline(argc, argv, &inputs, renderer, outputDir,
&validate, &writeWholeImage, &clones);
SkASSERT(renderer);
int failures = 0;
for (int i = 0; i < inputs.count(); i ++) {
failures += process_input(inputs[i], outputDir, *renderer);
failures += process_input(inputs[i], outputDir, *renderer,
validate, writeWholeImage, clones);
}
if (failures != 0) {
SkDebugf("Failed to render %i pictures.\n", failures);