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