1/*
2 * Copyright 2012 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8#include "LazyDecodeBitmap.h"
9#include "CopyTilesRenderer.h"
10#include "SkBitmap.h"
11#include "SkDevice.h"
12#include "SkCommandLineFlags.h"
13#include "SkGraphics.h"
14#include "SkImageDecoder.h"
15#include "SkImageEncoder.h"
16#include "SkMath.h"
17#include "SkOSFile.h"
18#include "SkPicture.h"
19#include "SkPictureRecorder.h"
20#include "SkStream.h"
21#include "SkString.h"
22
23#include "image_expectations.h"
24#include "PictureRenderer.h"
25#include "PictureRenderingFlags.h"
26#include "picture_utils.h"
27
28// Flags used by this file, alphabetically:
29DEFINE_bool(bench_record, false, "If true, drop into an infinite loop of recording the picture.");
30DECLARE_bool(deferImageDecoding);
31DEFINE_string(descriptions, "", "one or more key=value pairs to add to the descriptions section "
32              "of the JSON summary.");
33DEFINE_string(imageBaseGSUrl, "", "The Google Storage image base URL the images are stored in.");
34DEFINE_int32(maxComponentDiff, 256, "Maximum diff on a component, 0 - 256. Components that differ "
35             "by more than this amount are considered errors, though all diffs are reported. "
36             "Requires --validate.");
37DEFINE_string(mismatchPath, "", "Write images for tests that failed due to "
38              "pixel mismatches into this directory.");
39#if GR_GPU_STATS
40DEFINE_bool(gpuStats, false, "Only meaningful with gpu configurations. "
41            "Report some GPU call statistics.");
42#endif
43DEFINE_bool(mpd, false, "If true, use MultiPictureDraw for rendering.");
44DEFINE_string(readJsonSummaryPath, "", "JSON file to read image expectations from.");
45DECLARE_string(readPath);
46DEFINE_bool(writeChecksumBasedFilenames, false,
47            "When writing out images, use checksum-based filenames.");
48DEFINE_bool(writeEncodedImages, false, "Any time the skp contains an encoded image, write it to a "
49            "file rather than decoding it. Requires writePath to be set. Skips drawing the full "
50            "skp to a file. Not compatible with deferImageDecoding.");
51DEFINE_string(writeJsonSummaryPath, "", "File to write a JSON summary of image results to.");
52DEFINE_string2(writePath, w, "", "Directory to write the rendered images into.");
53DEFINE_bool(writeWholeImage, false, "In tile mode, write the entire rendered image to a "
54            "file, instead of an image for each tile.");
55DEFINE_bool(validate, false, "Verify that the rendered image contains the same pixels as "
56            "the picture rendered in simple mode. When used in conjunction with --bbh, results "
57            "are validated against the picture rendered in the same mode, but without the bbh.");
58
59////////////////////////////////////////////////////////////////////////////////////////////////////
60
61/**
62 *  Table for translating from format of data to a suffix.
63 */
64struct Format {
65    SkImageDecoder::Format  fFormat;
66    const char*             fSuffix;
67};
68static const Format gFormats[] = {
69    { SkImageDecoder::kBMP_Format, ".bmp" },
70    { SkImageDecoder::kGIF_Format, ".gif" },
71    { SkImageDecoder::kICO_Format, ".ico" },
72    { SkImageDecoder::kJPEG_Format, ".jpg" },
73    { SkImageDecoder::kPNG_Format, ".png" },
74    { SkImageDecoder::kWBMP_Format, ".wbmp" },
75    { SkImageDecoder::kWEBP_Format, ".webp" },
76    { SkImageDecoder::kUnknown_Format, "" },
77};
78
79/**
80 *  Get an appropriate suffix for an image format.
81 */
82static const char* get_suffix_from_format(SkImageDecoder::Format format) {
83    for (size_t i = 0; i < SK_ARRAY_COUNT(gFormats); i++) {
84        if (gFormats[i].fFormat == format) {
85            return gFormats[i].fSuffix;
86        }
87    }
88    return "";
89}
90
91/**
92 *  Base name for an image file created from the encoded data in an skp.
93 */
94static SkString gInputFileName;
95
96/**
97 *  Number to be appended to the image file name so that it is unique.
98 */
99static uint32_t gImageNo;
100
101/**
102 *  Set up the name for writing encoded data to a file.
103 *  Sets gInputFileName to name, minus any extension ".*"
104 *  Sets gImageNo to 0, so images from file "X.skp" will
105 *  look like "X_<gImageNo>.<suffix>", beginning with 0
106 *  for each new skp.
107 */
108static void reset_image_file_base_name(const SkString& name) {
109    gImageNo = 0;
110    // Remove ".skp"
111    const char* cName = name.c_str();
112    const char* dot = strrchr(cName, '.');
113    if (dot != NULL) {
114        gInputFileName.set(cName, dot - cName);
115    } else {
116        gInputFileName.set(name);
117    }
118}
119
120/**
121 *  Write the raw encoded bitmap data to a file.
122 */
123static bool write_image_to_file(const void* buffer, size_t size, SkBitmap* bitmap) {
124    SkASSERT(!FLAGS_writePath.isEmpty());
125    SkMemoryStream memStream(buffer, size);
126    SkString outPath;
127    SkImageDecoder::Format format = SkImageDecoder::GetStreamFormat(&memStream);
128    SkString name = SkStringPrintf("%s_%d%s", gInputFileName.c_str(), gImageNo++,
129                                   get_suffix_from_format(format));
130    SkString dir(FLAGS_writePath[0]);
131    outPath = SkOSPath::Join(dir.c_str(), name.c_str());
132    SkFILEWStream fileStream(outPath.c_str());
133    if (!(fileStream.isValid() && fileStream.write(buffer, size))) {
134        SkDebugf("Failed to write encoded data to \"%s\"\n", outPath.c_str());
135    }
136    // Put in a dummy bitmap.
137    return SkImageDecoder::DecodeStream(&memStream, bitmap, kUnknown_SkColorType,
138                                        SkImageDecoder::kDecodeBounds_Mode);
139}
140
141////////////////////////////////////////////////////////////////////////////////////////////////////
142
143/**
144 * Called only by render_picture().
145 */
146static bool render_picture_internal(const SkString& inputPath, const SkString* writePath,
147                                    const SkString* mismatchPath,
148                                    sk_tools::PictureRenderer& renderer,
149                                    SkBitmap** out) {
150    SkString inputFilename = SkOSPath::Basename(inputPath.c_str());
151    SkString writePathString;
152    if (writePath && writePath->size() > 0 && !FLAGS_writeEncodedImages) {
153        writePathString.set(*writePath);
154    }
155    SkString mismatchPathString;
156    if (mismatchPath && mismatchPath->size() > 0) {
157        mismatchPathString.set(*mismatchPath);
158    }
159
160    SkFILEStream inputStream;
161    inputStream.setPath(inputPath.c_str());
162    if (!inputStream.isValid()) {
163        SkDebugf("Could not open file %s\n", inputPath.c_str());
164        return false;
165    }
166
167    SkPicture::InstallPixelRefProc proc;
168    if (FLAGS_deferImageDecoding) {
169        proc = &sk_tools::LazyDecodeBitmap;
170    } else if (FLAGS_writeEncodedImages) {
171        SkASSERT(!FLAGS_writePath.isEmpty());
172        reset_image_file_base_name(inputFilename);
173        proc = &write_image_to_file;
174    } else {
175        proc = &SkImageDecoder::DecodeMemory;
176    }
177
178    SkDebugf("deserializing... %s\n", inputPath.c_str());
179
180    SkAutoTUnref<SkPicture> picture(SkPicture::CreateFromStream(&inputStream, proc));
181
182    if (NULL == picture) {
183        SkDebugf("Could not read an SkPicture from %s\n", inputPath.c_str());
184        return false;
185    }
186
187    while (FLAGS_bench_record) {
188        SkPictureRecorder recorder;
189        picture->playback(recorder.beginRecording(picture->cullRect().width(),
190                                                  picture->cullRect().height(),
191                                                  NULL, 0));
192        SkAutoTUnref<SkPicture> other(recorder.endRecording());
193    }
194
195    SkDebugf("drawing... [%f %f %f %f] %s\n",
196             picture->cullRect().fLeft, picture->cullRect().fTop,
197             picture->cullRect().fRight, picture->cullRect().fBottom,
198             inputPath.c_str());
199
200    renderer.init(picture, &writePathString, &mismatchPathString, &inputFilename,
201                  FLAGS_writeChecksumBasedFilenames, FLAGS_mpd);
202
203    renderer.setup();
204    renderer.enableWrites();
205
206    bool success = renderer.render(out);
207    if (!success) {
208        SkDebugf("Failed to render %s\n", inputFilename.c_str());
209    }
210
211    renderer.end();
212
213    return success;
214}
215
216static inline int getByte(uint32_t value, int index) {
217    SkASSERT(0 <= index && index < 4);
218    return (value >> (index * 8)) & 0xFF;
219}
220
221static int MaxByteDiff(uint32_t v1, uint32_t v2) {
222    return SkMax32(SkMax32(abs(getByte(v1, 0) - getByte(v2, 0)), abs(getByte(v1, 1) - getByte(v2, 1))),
223                   SkMax32(abs(getByte(v1, 2) - getByte(v2, 2)), abs(getByte(v1, 3) - getByte(v2, 3))));
224}
225
226class AutoRestoreBbhType {
227public:
228    AutoRestoreBbhType() {
229        fRenderer = NULL;
230        fSavedBbhType = sk_tools::PictureRenderer::kNone_BBoxHierarchyType;
231    }
232
233    void set(sk_tools::PictureRenderer* renderer,
234             sk_tools::PictureRenderer::BBoxHierarchyType bbhType) {
235        fRenderer = renderer;
236        fSavedBbhType = renderer->getBBoxHierarchyType();
237        renderer->setBBoxHierarchyType(bbhType);
238    }
239
240    ~AutoRestoreBbhType() {
241        if (fRenderer) {
242            fRenderer->setBBoxHierarchyType(fSavedBbhType);
243        }
244    }
245
246private:
247    sk_tools::PictureRenderer* fRenderer;
248    sk_tools::PictureRenderer::BBoxHierarchyType fSavedBbhType;
249};
250
251/**
252 * Render the SKP file(s) within inputPath.
253 *
254 * @param inputPath path to an individual SKP file, or a directory of SKP files
255 * @param writePath if not NULL, write all image(s) generated into this directory
256 * @param mismatchPath if not NULL, write any image(s) not matching expectations into this directory
257 * @param renderer PictureRenderer to use to render the SKPs
258 * @param jsonSummaryPtr if not NULL, add the image(s) generated to this summary
259 */
260static bool render_picture(const SkString& inputPath, const SkString* writePath,
261                           const SkString* mismatchPath, sk_tools::PictureRenderer& renderer,
262                           sk_tools::ImageResultsAndExpectations *jsonSummaryPtr) {
263    int diffs[256] = {0};
264    SkBitmap* bitmap = NULL;
265    renderer.setJsonSummaryPtr(jsonSummaryPtr);
266    bool success = render_picture_internal(inputPath,
267        FLAGS_writeWholeImage ? NULL : writePath,
268        FLAGS_writeWholeImage ? NULL : mismatchPath,
269        renderer,
270        FLAGS_validate || FLAGS_writeWholeImage ? &bitmap : NULL);
271
272    if (!success || ((FLAGS_validate || FLAGS_writeWholeImage) && bitmap == NULL)) {
273        SkDebugf("Failed to draw the picture.\n");
274        SkDELETE(bitmap);
275        return false;
276    }
277
278    if (FLAGS_validate) {
279        SkBitmap* referenceBitmap = NULL;
280        sk_tools::PictureRenderer* referenceRenderer;
281        // If the renderer uses a BBoxHierarchy, then the reference renderer
282        // will be the same renderer, without the bbh.
283        AutoRestoreBbhType arbbh;
284        if (sk_tools::PictureRenderer::kNone_BBoxHierarchyType !=
285            renderer.getBBoxHierarchyType()) {
286            referenceRenderer = &renderer;
287            referenceRenderer->ref();  // to match auto unref below
288            arbbh.set(referenceRenderer, sk_tools::PictureRenderer::kNone_BBoxHierarchyType);
289        } else {
290#if SK_SUPPORT_GPU
291            referenceRenderer = SkNEW_ARGS(sk_tools::SimplePictureRenderer,
292                                           (renderer.getGrContextOptions()));
293#else
294            referenceRenderer = SkNEW(sk_tools::SimplePictureRenderer);
295#endif
296        }
297        SkAutoTUnref<sk_tools::PictureRenderer> aurReferenceRenderer(referenceRenderer);
298
299        success = render_picture_internal(inputPath, NULL, NULL, *referenceRenderer,
300                                          &referenceBitmap);
301
302        if (!success || NULL == referenceBitmap || NULL == referenceBitmap->getPixels()) {
303            SkDebugf("Failed to draw the reference picture.\n");
304            SkDELETE(bitmap);
305            SkDELETE(referenceBitmap);
306            return false;
307        }
308
309        if (success && (bitmap->width() != referenceBitmap->width())) {
310            SkDebugf("Expected image width: %i, actual image width %i.\n",
311                     referenceBitmap->width(), bitmap->width());
312            SkDELETE(bitmap);
313            SkDELETE(referenceBitmap);
314            return false;
315        }
316        if (success && (bitmap->height() != referenceBitmap->height())) {
317            SkDebugf("Expected image height: %i, actual image height %i",
318                     referenceBitmap->height(), bitmap->height());
319            SkDELETE(bitmap);
320            SkDELETE(referenceBitmap);
321            return false;
322        }
323
324        for (int y = 0; success && y < bitmap->height(); y++) {
325            for (int x = 0; success && x < bitmap->width(); x++) {
326                int diff = MaxByteDiff(*referenceBitmap->getAddr32(x, y),
327                                       *bitmap->getAddr32(x, y));
328                SkASSERT(diff >= 0 && diff <= 255);
329                diffs[diff]++;
330
331                if (diff > FLAGS_maxComponentDiff) {
332                    SkDebugf("Expected pixel at (%i %i) exceedds maximum "
333                                 "component diff of %i: 0x%x, actual 0x%x\n",
334                             x, y, FLAGS_maxComponentDiff,
335                             *referenceBitmap->getAddr32(x, y),
336                             *bitmap->getAddr32(x, y));
337                    SkDELETE(bitmap);
338                    SkDELETE(referenceBitmap);
339                    return false;
340                }
341            }
342        }
343        SkDELETE(referenceBitmap);
344
345        for (int i = 1; i <= 255; ++i) {
346            if(diffs[i] > 0) {
347                SkDebugf("Number of pixels with max diff of %i is %i\n", i, diffs[i]);
348            }
349        }
350    }
351
352    if (FLAGS_writeWholeImage) {
353        sk_tools::force_all_opaque(*bitmap);
354
355        SkString inputFilename = SkOSPath::Basename(inputPath.c_str());
356        SkString outputFilename(inputFilename);
357        sk_tools::replace_char(&outputFilename, '.', '_');
358        outputFilename.append(".png");
359
360        if (jsonSummaryPtr) {
361            sk_tools::ImageDigest imageDigest(*bitmap);
362            jsonSummaryPtr->add(inputFilename.c_str(), outputFilename.c_str(), imageDigest);
363            if ((mismatchPath) && !mismatchPath->isEmpty() &&
364                !jsonSummaryPtr->getExpectation(inputFilename.c_str()).matches(imageDigest)) {
365                success &= sk_tools::write_bitmap_to_disk(*bitmap, *mismatchPath, NULL,
366                                                          outputFilename);
367            }
368        }
369
370        if ((writePath) && !writePath->isEmpty()) {
371            success &= sk_tools::write_bitmap_to_disk(*bitmap, *writePath, NULL, outputFilename);
372        }
373    }
374    SkDELETE(bitmap);
375
376    return success;
377}
378
379
380static int process_input(const char* input, const SkString* writePath,
381                         const SkString* mismatchPath, sk_tools::PictureRenderer& renderer,
382                         sk_tools::ImageResultsAndExpectations *jsonSummaryPtr) {
383    SkOSFile::Iter iter(input, "skp");
384    SkString inputFilename;
385    int failures = 0;
386    SkDebugf("process_input, %s\n", input);
387    if (iter.next(&inputFilename)) {
388        do {
389            SkString inputPath = SkOSPath::Join(input, inputFilename.c_str());
390            if (!render_picture(inputPath, writePath, mismatchPath, renderer, jsonSummaryPtr)) {
391                ++failures;
392            }
393        } while(iter.next(&inputFilename));
394    } else if (SkStrEndsWith(input, ".skp")) {
395        SkString inputPath(input);
396        if (!render_picture(inputPath, writePath, mismatchPath, renderer, jsonSummaryPtr)) {
397            ++failures;
398        }
399    } else {
400        SkString warning;
401        warning.printf("Warning: skipping %s\n", input);
402        SkDebugf("%s", warning.c_str());
403    }
404    return failures;
405}
406
407int tool_main(int argc, char** argv);
408int tool_main(int argc, char** argv) {
409    SkCommandLineFlags::SetUsage("Render .skp files.");
410    SkCommandLineFlags::Parse(argc, argv);
411
412    if (FLAGS_readPath.isEmpty()) {
413        SkDebugf(".skp files or directories are required.\n");
414        exit(-1);
415    }
416
417    if (FLAGS_maxComponentDiff < 0 || FLAGS_maxComponentDiff > 256) {
418        SkDebugf("--maxComponentDiff must be between 0 and 256\n");
419        exit(-1);
420    }
421
422    if (FLAGS_maxComponentDiff != 256 && !FLAGS_validate) {
423        SkDebugf("--maxComponentDiff requires --validate\n");
424        exit(-1);
425    }
426
427    if (FLAGS_writeEncodedImages) {
428        if (FLAGS_writePath.isEmpty()) {
429            SkDebugf("--writeEncodedImages requires --writePath\n");
430            exit(-1);
431        }
432        if (FLAGS_deferImageDecoding) {
433            SkDebugf("--writeEncodedImages is not compatible with --deferImageDecoding\n");
434            exit(-1);
435        }
436    }
437
438    SkString errorString;
439    SkAutoTUnref<sk_tools::PictureRenderer> renderer(parseRenderer(errorString,
440                                                                   kRender_PictureTool));
441    if (errorString.size() > 0) {
442        SkDebugf("%s\n", errorString.c_str());
443    }
444
445    if (renderer.get() == NULL) {
446        exit(-1);
447    }
448
449    SkAutoGraphics ag;
450
451    SkString writePath;
452    if (FLAGS_writePath.count() == 1) {
453        writePath.set(FLAGS_writePath[0]);
454    }
455    SkString mismatchPath;
456    if (FLAGS_mismatchPath.count() == 1) {
457        mismatchPath.set(FLAGS_mismatchPath[0]);
458    }
459    sk_tools::ImageResultsAndExpectations jsonSummary;
460    sk_tools::ImageResultsAndExpectations* jsonSummaryPtr = NULL;
461    if (FLAGS_writeJsonSummaryPath.count() == 1) {
462        jsonSummaryPtr = &jsonSummary;
463        if (FLAGS_readJsonSummaryPath.count() == 1) {
464            SkASSERT(jsonSummary.readExpectationsFile(FLAGS_readJsonSummaryPath[0]));
465        }
466    }
467
468    int failures = 0;
469    for (int i = 0; i < FLAGS_readPath.count(); i ++) {
470        failures += process_input(FLAGS_readPath[i], &writePath, &mismatchPath, *renderer.get(),
471                                  jsonSummaryPtr);
472    }
473    if (failures != 0) {
474        SkDebugf("Failed to render %i pictures.\n", failures);
475        return 1;
476    }
477#if GR_CACHE_STATS && SK_SUPPORT_GPU
478    if (renderer->isUsingGpuDevice()) {
479        GrContext* ctx = renderer->getGrContext();
480        ctx->printCacheStats();
481    }
482#endif
483
484#if GR_GPU_STATS && SK_SUPPORT_GPU
485    if (FLAGS_gpuStats && renderer->isUsingGpuDevice()) {
486        renderer->getGrContext()->printGpuStats();
487    }
488#endif
489
490    if (FLAGS_writeJsonSummaryPath.count() == 1) {
491        // If there were any descriptions on the command line, insert them now.
492        for (int i=0; i<FLAGS_descriptions.count(); i++) {
493            SkTArray<SkString> tokens;
494            SkStrSplit(FLAGS_descriptions[i], "=", &tokens);
495            SkASSERT(tokens.count() == 2);
496            jsonSummary.addDescription(tokens[0].c_str(), tokens[1].c_str());
497        }
498        if (FLAGS_imageBaseGSUrl.count() == 1) {
499          jsonSummary.setImageBaseGSUrl(FLAGS_imageBaseGSUrl[0]);
500        }
501        jsonSummary.writeToFile(FLAGS_writeJsonSummaryPath[0]);
502    }
503    return 0;
504}
505
506#if !defined SK_BUILD_FOR_IOS
507int main(int argc, char * const argv[]) {
508    return tool_main(argc, (char**) argv);
509}
510#endif
511