/*
* 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 "CopyTilesRenderer.h"
#include "SkBitmap.h"
#include "SkCanvas.h"
#include "SkDevice.h"
#include "SkGraphics.h"
#include "SkImageDecoder.h"
#include "SkImageEncoder.h"
#include "SkMath.h"
#include "SkOSFile.h"
#include "SkPicture.h"
#include "SkStream.h"
#include "SkString.h"
#include "SkTArray.h"
#include "PictureRenderer.h"
#include "picture_utils.h"
static void usage(const char* argv0) {
SkDebugf("SkPicture rendering tool\n");
SkDebugf("\n"
"Usage: \n"
" %s <input>... \n"
" [-w <outputDir>]\n"
" [--mode pow2tile minWidth height | copyTile width height | simple\n"
" | tile width height]\n"
" [--pipe]\n"
" [--bbh bbhType]\n"
" [--multi count]\n"
" [--validate [--maxComponentDiff n]]\n"
" [--writeWholeImage]\n"
" [--clone n]\n"
" [--viewport width height][--scale sf]\n"
" [--device bitmap"
#if SK_SUPPORT_GPU
" | gpu"
#endif
"]"
, argv0);
SkDebugf("\n\n");
SkDebugf(
" input: A list of directories and files to use as input. Files are\n"
" expected to have the .skp extension.\n\n");
SkDebugf(
" outputDir: directory to write the rendered images.\n\n");
SkDebugf(
" --mode pow2tile minWidth height | copyTile width height | simple\n"
" | tile width height | rerecord: Run in the corresponding mode.\n"
" Default is simple.\n");
SkDebugf(
" pow2tile minWidth height, Creates tiles with widths\n"
" that are all a power of two\n"
" such that they minimize the\n"
" amount of wasted tile space.\n"
" minWidth is the minimum width\n"
" of these tiles and must be a\n"
" power of two. A simple render\n"
" is done with these tiles.\n");
SkDebugf(
" simple, Render using the default rendering method.\n"
" rerecord, Record the picture as a new skp, with the bitmaps PNG encoded.\n"
);
SkDebugf(
" tile width height, Do a simple render using tiles\n"
" with the given dimensions.\n"
" copyTile width height, Draw the picture, then copy it into tiles.\n"
" Does not support percentages.\n"
" If the picture is large enough, breaks it into\n"
" larger tiles (and draws the picture once per\n"
" larger tile) to avoid creating a large canvas.\n"
" Add --tiles x y to specify the number of tiles\n"
" per larger tile in the x and y direction.\n"
);
SkDebugf("\n");
SkDebugf(
" --multi count : Set the number of threads for multi threaded drawing. Must be greater\n"
" than 1. Only works with tiled rendering.\n"
" --viewport width height : Set the viewport.\n"
" --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"
" --maxComponentDiff: maximum diff on a component. Default is 256, "
"which means we report but we do not generate an error.\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"
#endif
": Use the corresponding device. Default is bitmap.\n");
SkDebugf(
" bitmap, Render to a bitmap.\n");
#if SK_SUPPORT_GPU
SkDebugf(
" gpu, Render to the GPU.\n");
#endif
}
static void make_output_filepath(SkString* path, const SkString& dir,
const SkString& name) {
sk_tools::make_filepath(path, dir, name);
// Remove ".skp"
path->remove(path->size() - 4, 4);
}
static bool render_picture(const SkString& inputPath, const SkString* outputDir,
sk_tools::PictureRenderer& renderer,
SkBitmap** out,
int clones) {
SkString inputFilename;
sk_tools::get_basename(&inputFilename, inputPath);
SkFILEStream inputStream;
inputStream.setPath(inputPath.c_str());
if (!inputStream.isValid()) {
SkDebugf("Could not open file %s\n", inputPath.c_str());
return false;
}
bool success = false;
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;
}
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.setup();
SkString* outputPath = NULL;
if (NULL != outputDir) {
outputPath = SkNEW(SkString);
make_output_filepath(outputPath, *outputDir, inputFilename);
}
success = renderer.render(outputPath, out);
if (outputPath) {
if (!success) {
SkDebugf("Could not write to file %s\n", outputPath->c_str());
}
SkDELETE(outputPath);
}
renderer.end();
SkDELETE(picture);
return success;
}
static inline int getByte(uint32_t value, int index) {
SkASSERT(0 <= index && index < 4);
return (value >> (index * 8)) & 0xFF;
}
static int MaxByteDiff(uint32_t v1, uint32_t v2) {
return SkMax32(SkMax32(abs(getByte(v1, 0) - getByte(v2, 0)), abs(getByte(v1, 1) - getByte(v2, 1))),
SkMax32(abs(getByte(v1, 2) - getByte(v2, 2)), abs(getByte(v1, 3) - getByte(v2, 3))));
}
static bool render_picture(const SkString& inputPath, const SkString* outputDir,
sk_tools::PictureRenderer& renderer,
bool validate, int maxComponentDiff,
bool writeWholeImage,
int clones) {
int diffs[256] = {0};
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++) {
int diff = MaxByteDiff(*referenceBitmap->getAddr32(x, y),
*bitmap->getAddr32(x, y));
SkASSERT(diff >= 0 && diff <= 255);
diffs[diff]++;
if (diff > maxComponentDiff) {
SkDebugf("Expected pixel at (%i %i) exceedds maximum "
"component diff of %i: 0x%x, actual 0x%x\n",
x, y, maxComponentDiff,
*referenceBitmap->getAddr32(x, y),
*bitmap->getAddr32(x, y));
SkDELETE(bitmap);
SkDELETE(referenceBitmap);
return false;
}
}
}
SkDELETE(referenceBitmap);
for (int i = 1; i <= 255; ++i) {
if(diffs[i] > 0) {
SkDebugf("Number of pixels with max diff of %i is %i\n", i, diffs[i]);
}
}
}
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,
bool validate, int maxComponentDiff,
bool writeWholeImage, int clones) {
SkOSFile::Iter iter(input.c_str(), "skp");
SkString inputFilename;
int failures = 0;
SkDebugf("process_input, %s\n", input.c_str());
if (iter.next(&inputFilename)) {
do {
SkString inputPath;
sk_tools::make_filepath(&inputPath, input, inputFilename);
if (!render_picture(inputPath, outputDir, renderer,
validate, maxComponentDiff,
writeWholeImage, clones)) {
++failures;
}
} while(iter.next(&inputFilename));
} else if (SkStrEndsWith(input.c_str(), ".skp")) {
SkString inputPath(input);
if (!render_picture(inputPath, outputDir, renderer,
validate, maxComponentDiff,
writeWholeImage, clones)) {
++failures;
}
} else {
SkString warning;
warning.printf("Warning: skipping %s\n", input.c_str());
SkDebugf(warning.c_str());
}
return failures;
}
static void parse_commandline(int argc, char* const argv[], SkTArray<SkString>* inputs,
sk_tools::PictureRenderer*& renderer, SkString*& outputDir,
bool* validate, int* maxComponentDiff,
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;
*maxComponentDiff = 256;
*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, "--maxComponentDiff")) {
if (!*validate) {
SkDebugf("--maxComponentDiff must be used only with --validate\n");
usage(argv0);
exit(-1);
}
++argv;
if (argv >= stop) {
SkDebugf("Missing arg for --maxComponentDiff\n");
usage(argv0);
exit(-1);
}
*maxComponentDiff = atoi(*argv);
if (*maxComponentDiff < 0 || *maxComponentDiff > 256) {
SkSafeUnref(renderer);
SkDebugf("maxComponentDiff: 0 - 256.\n");
usage(argv0);
exit(-1);
}
} 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);
}
int tool_main(int argc, char** argv);
int tool_main(int argc, char** argv) {
SkAutoGraphics ag;
SkTArray<SkString> inputs;
sk_tools::PictureRenderer* renderer = NULL;
SkString* outputDir = NULL;
bool validate = false;
int maxComponentDiff = 256;
bool writeWholeImage = false;
int clones = 0;
parse_commandline(argc, argv, &inputs, renderer, outputDir,
&validate, &maxComponentDiff, &writeWholeImage, &clones);
SkASSERT(renderer);
int failures = 0;
for (int i = 0; i < inputs.count(); i ++) {
failures += process_input(inputs[i], outputDir, *renderer,
validate, maxComponentDiff,
writeWholeImage, clones);
}
if (failures != 0) {
SkDebugf("Failed to render %i pictures.\n", failures);
return 1;
}
#if SK_SUPPORT_GPU
#if GR_CACHE_STATS
if (renderer->isUsingGpuDevice()) {
GrContext* ctx = renderer->getGrContext();
ctx->printCacheStats();
}
#endif
#endif
if (NULL != outputDir) {
SkDELETE(outputDir);
}
SkDELETE(renderer);
return 0;
}
#if !defined SK_BUILD_FOR_IOS
int main(int argc, char * const argv[]) {
return tool_main(argc, (char**) argv);
}
#endif