src/third_party/skia/tools/lua/lua_pictures.cpp

   1 /*
   2  * Copyright 2013 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 "SkLua.h"
  10 #include "SkLuaCanvas.h"
  11 #include "SkPicture.h"
  12 #include "SkCommandLineFlags.h"
  13 #include "SkGraphics.h"
  14 #include "SkStream.h"
  15 #include "SkData.h"
  16 #include "picture_utils.h"
  17 #include "SkOSFile.h"
  18 #include "SkImageDecoder.h"
  19
  20 extern "C" {
  21     #include "lua.h"
  22     #include "lualib.h"
  23     #include "lauxlib.h"
  24 }
  25
  26 static const char gStartCanvasFunc[] = "sk_scrape_startcanvas";
  27 static const char gEndCanvasFunc[] = "sk_scrape_endcanvas";
  28 static const char gAccumulateFunc[] = "sk_scrape_accumulate";
  29 static const char gSummarizeFunc[] = "sk_scrape_summarize";
  30
  31 // Example usage for the modulo flag:
  32 // for i in {0..5}; do lua_pictures --skpPath SKP_PATH -l YOUR_SCRIPT --modulo $i 6 &; done
  33 DEFINE_string(modulo, "", "[--modulo <remainder> <divisor>]: only run tests for which "
  34               "testIndex %% divisor == remainder.");
  35 DEFINE_string2(skpPath, r, "", "Read this .skp file or .skp files from this dir");
  36 DEFINE_string2(luaFile, l, "", "File containing lua script to run");
  37 DEFINE_string2(headCode, s, "", "Optional lua code to call at beginning");
  38 DEFINE_string2(tailFunc, s, "", "Optional lua function to call at end");
  39 DEFINE_bool2(quiet, q, false, "Silence all non-error related output");
  40
  41 static SkPicture* load_picture(const char path[]) {
  42     SkAutoTUnref<SkStream> stream(SkStream::NewFromFile(path));
  43     SkPicture* pic = NULL;
  44     if (stream.get()) {
  45         pic = SkPicture::CreateFromStream(stream.get(), &sk_tools::LazyDecodeBitmap);
  46     }
  47     return pic;
  48 }
  49
  50 static SkData* read_into_data(const char file[]) {
  51     SkAutoTUnref<SkStream> stream(SkStream::NewFromFile(file));
  52     if (!stream.get()) {
  53         return SkData::NewEmpty();
  54     }
  55     size_t len = stream->getLength();
  56     void* buffer = sk_malloc_throw(len);
  57     stream->read(buffer, len);
  58     return SkData::NewFromMalloc(buffer, len);
  59 }
  60
  61 static void call_canvas(lua_State* L, SkLuaCanvas* canvas,
  62                         const char pictureFile[], const char funcName[]) {
  63     lua_getglobal(L, funcName);
  64     if (!lua_isfunction(L, -1)) {
  65         int t = lua_type(L, -1);
  66         SkDebugf("--- expected %s function %d, ignoring.\n", funcName, t);
  67         lua_settop(L, -2);
  68     } else {
  69         canvas->pushThis();
  70         lua_pushstring(L, pictureFile);
  71         if (lua_pcall(L, 2, 0, 0) != LUA_OK) {
  72             SkDebugf("lua err: %s\n", lua_tostring(L, -1));
  73         }
  74     }
  75 }
  76
  77 int tool_main(int argc, char** argv);
  78 int tool_main(int argc, char** argv) {
  79     SkCommandLineFlags::SetUsage("apply lua script to .skp files.");
  80     SkCommandLineFlags::Parse(argc, argv);
  81
  82     if (FLAGS_skpPath.isEmpty()) {
  83         SkDebugf(".skp files or directories are required.\n");
  84         exit(-1);
  85     }
  86     if (FLAGS_luaFile.isEmpty()) {
  87         SkDebugf("missing luaFile(s)\n");
  88         exit(-1);
  89     }
  90
  91     const char* summary = gSummarizeFunc;
  92     if (!FLAGS_tailFunc.isEmpty()) {
  93         summary = FLAGS_tailFunc[0];
  94     }
  95
  96     SkAutoGraphics ag;
  97     SkLua L(summary);
  98
  99     for (int i = 0; i < FLAGS_luaFile.count(); ++i) {
 100         SkAutoDataUnref data(read_into_data(FLAGS_luaFile[i]));
 101         if (!FLAGS_quiet) {
 102             SkDebugf("loading %s...\n", FLAGS_luaFile[i]);
 103         }
 104         if (!L.runCode(data->data(), data->size())) {
 105             SkDebugf("failed to load luaFile %s\n", FLAGS_luaFile[i]);
 106             exit(-1);
 107         }
 108     }
 109
 110     if (!FLAGS_headCode.isEmpty()) {
 111         L.runCode(FLAGS_headCode[0]);
 112     }
 113
 114     int moduloRemainder = -1;
 115     int moduloDivisor = -1;
 116     SkString moduloStr;
 117
 118     if (FLAGS_modulo.count() == 2) {
 119         moduloRemainder = atoi(FLAGS_modulo[0]);
 120         moduloDivisor = atoi(FLAGS_modulo[1]);
 121         if (moduloRemainder < 0 || moduloDivisor <= 0 || moduloRemainder >= moduloDivisor) {
 122             SkDebugf("invalid modulo values.\n");
 123             return -1;
 124         }
 125     }
 126
 127     for (int i = 0; i < FLAGS_skpPath.count(); i ++) {
 128         SkTArray<SkString> paths;
 129         if (sk_isdir(FLAGS_skpPath[i])) {
 130             // Add all .skp in this directory.
 131             const SkString directory(FLAGS_skpPath[i]);
 132             SkString filename;
 133             SkOSFile::Iter iter(FLAGS_skpPath[i], "skp");
 134             while(iter.next(&filename)) {
 135                 paths.push_back() = SkOSPath::Join(directory.c_str(), filename.c_str());
 136             }
 137         } else {
 138             // Add this as an .skp itself.
 139             paths.push_back() = FLAGS_skpPath[i];
 140         }
 141
 142         for (int i = 0; i < paths.count(); i++) {
 143             if (moduloRemainder >= 0) {
 144                 if ((i % moduloDivisor) != moduloRemainder) {
 145                     continue;
 146                 }
 147                 moduloStr.printf("[%d.%d] ", i, moduloDivisor);
 148             }
 149             const char* path = paths[i].c_str();
 150             if (!FLAGS_quiet) {
 151                 SkDebugf("scraping %s %s\n", path, moduloStr.c_str());
 152             }
 153
 154             SkAutoTUnref<SkPicture> pic(load_picture(path));
 155             if (pic.get()) {
 156                 SkAutoTUnref<SkLuaCanvas> canvas(
 157                                     new SkLuaCanvas(pic->width(), pic->height(),
 158                                                     L.get(), gAccumulateFunc));
 159
 160                 call_canvas(L.get(), canvas.get(), path, gStartCanvasFunc);
 161                 canvas->drawPicture(pic);
 162                 call_canvas(L.get(), canvas.get(), path, gEndCanvasFunc);
 163
 164             } else {
 165                 SkDebugf("failed to load\n");
 166             }
 167         }
 168     }
 169     return 0;
 170 }
 171
 172 #if !defined SK_BUILD_FOR_IOS
 173 int main(int argc, char * const argv[]) {
 174     return tool_main(argc, (char**) argv);
 175 }
 176 #endif