int main(int argc, char** argv) { SkCommandLineFlags::SetUsage( "Usage: get_images_from_skps -s <dir of skps> -o <dir for output images>\n"); SkCommandLineFlags::Parse(argc, argv); const char* inputs = FLAGS_skps[0]; gOutputDir = FLAGS_out[0]; if (!sk_isdir(inputs) || !sk_isdir(gOutputDir)) { SkCommandLineFlags::PrintUsage(); return 1; } SkOSFile::Iter iter(inputs, "skp"); for (SkString file; iter.next(&file); ) { SkAutoTDelete<SkStream> stream = SkStream::NewFromFile(SkOSPath::Join(inputs, file.c_str()).c_str()); SkAutoTUnref<SkPicture> picture(SkPicture::CreateFromStream(stream)); SkDynamicMemoryWStream scratch; Sniffer sniff; picture->serialize(&scratch, &sniff); } SkDebugf("%d known, %d unknown\n", gKnown, gUnknown); return 0; }
int main(int argc, char** argv) { SkCommandLineFlags::SetUsage( "Usage: get_images_from_skps -s <dir of skps> -o <dir for output images> --testDecode " "-j <output JSON path>\n"); SkCommandLineFlags::Parse(argc, argv); const char* inputs = FLAGS_skps[0]; gOutputDir = FLAGS_out[0]; if (!sk_isdir(inputs) || !sk_isdir(gOutputDir)) { SkCommandLineFlags::PrintUsage(); return 1; } SkOSFile::Iter iter(inputs, "skp"); for (SkString file; iter.next(&file); ) { SkAutoTDelete<SkStream> stream = SkStream::NewFromFile(SkOSPath::Join(inputs, file.c_str()).c_str()); sk_sp<SkPicture> picture(SkPicture::MakeFromStream(stream)); SkDynamicMemoryWStream scratch; Sniffer sniff(file.c_str()); picture->serialize(&scratch, &sniff); } int totalUnknowns = 0; /** JSON results are written out in the following format: { "failures": { "skp1": 12, "skp4": 2, ... }, "totalFailures": 32, "totalSuccesses": 21, } */ Json::Value fRoot; for(auto it = gSkpToUnknownCount.cbegin(); it != gSkpToUnknownCount.cend(); ++it) { SkDebugf("%s %d\n", it->first.c_str(), it->second); totalUnknowns += it->second; fRoot["failures"][it->first.c_str()] = it->second; } SkDebugf("%d known, %d unknown\n", gKnown, totalUnknowns); fRoot["totalFailures"] = totalUnknowns; fRoot["totalSuccesses"] = gKnown; if (totalUnknowns > 0) { if (!FLAGS_failuresJsonPath.isEmpty()) { SkDebugf("Writing failures to %s\n", FLAGS_failuresJsonPath[0]); SkFILEWStream stream(FLAGS_failuresJsonPath[0]); stream.writeText(Json::StyledWriter().write(fRoot).c_str()); stream.flush(); } return -1; } return 0; }
bool sk_mkdir(const char* path) { if (sk_isdir(path)) { return true; } if (sk_exists(path)) { fprintf(stderr, "sk_mkdir: path '%s' already exists but is not a directory\n", path); return false; } int retval; #ifdef _WIN32 retval = _mkdir(path); #else retval = mkdir(path, 0777); #endif if (0 == retval) { return true; } else { fprintf(stderr, "sk_mkdir: error %d creating dir '%s'\n", errno, path); return false; } }
/** * @param A list of directories or a skp files. * @returns an alphabetical list of skp files. */ static void process_input_files( const SkCommandLineFlags::StringArray& inputs, SkTArray<SkString>* files) { for (int i = 0; i < inputs.count(); i ++) { const char* input = inputs[i]; if (sk_isdir(input)) { SkOSFile::Iter iter(input, SKP_FILE_EXTENSION); SkString inputFilename; while (iter.next(&inputFilename)) { if (!SkCommandLineFlags::ShouldSkip( FLAGS_match, inputFilename.c_str())) { files->push_back( SkOSPath::Join(input, inputFilename.c_str())); } } } else { if (!SkCommandLineFlags::ShouldSkip(FLAGS_match, input)) { files->push_back(SkString(input)); } } } if (files->count() > 0) { SkTQSort<SkString>(files->begin(), files->end() - 1); } }
int tool_main(int argc, char** argv) { SkCommandLineFlags::SetUsage("Decode files, and optionally write the results to files."); SkCommandLineFlags::Parse(argc, argv); if (FLAGS_readPath.count() < 1) { SkDebugf("Folder(s) or image(s) to decode are required.\n"); return -1; } SkAutoGraphics ag; for (int i = 0; i < FLAGS_readPath.count(); i++) { const char* readPath = FLAGS_readPath[i]; if (strlen(readPath) < 1) { break; } if (sk_isdir(readPath)) { const char* dir = readPath; SkOSFile::Iter iter(dir); SkString filename; while (iter.next(&filename)) { if (!is_image_file(filename.c_str())) { continue; } SkString fullname = SkOSPath::SkPathJoin(dir, filename.c_str()); decodeFileAndWrite(fullname.c_str()); } } else if (sk_exists(readPath) && is_image_file(readPath)) { decodeFileAndWrite(readPath); } } return 0; }
bool get_directory(const char path[], SkTArray<SkString>* entries) { #if SK_BUILD_FOR_MAC || SK_BUILD_FOR_UNIX || SK_BUILD_FOR_ANDROID // Open the directory and check for success DIR* dir = opendir(path); if (NULL == dir) { return false; } // Loop through dir entries until there are none left (i.e. readdir returns NULL) struct dirent* entry; while ((entry = readdir(dir))) { // dirent only gives relative paths, we need to join them to the base path to check if they // are directories. SkString joinedPath = SkOSPath::SkPathJoin(path, entry->d_name); // We only care about files if (!sk_isdir(joinedPath.c_str())) { entries->push_back(SkString(entry->d_name)); } } closedir(dir); return true; #elif SK_BUILD_FOR_WIN32 char pathDirGlob[MAX_PATH]; size_t pathLength = strlen(path); strncpy(pathDirGlob, path, pathLength); if (path[pathLength - 1] == '/' || path[pathLength - 1] == '\\') { SkASSERT(pathLength + 2 <= MAX_PATH); pathDirGlob[pathLength] = '*'; pathDirGlob[pathLength + 1] = '\0'; } else { SkASSERT(pathLength + 3 <= MAX_PATH); pathDirGlob[pathLength] = '\\'; pathDirGlob[pathLength + 1] = '*'; pathDirGlob[pathLength + 2] = '\0'; } WIN32_FIND_DATA findFileData; HANDLE hFind = FindFirstFile(pathDirGlob, &findFileData); if (INVALID_HANDLE_VALUE == hFind) { return false; } do { if ((findFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0) { entries->push_back(SkString(findFileData.cFileName)); } } while (FindNextFile(hFind, &findFileData) != 0); FindClose(hFind); return true; #else return false; #endif }
/** For each file in the directory or for the file passed in input, call * parse_pdf. * @param input A directory or an pdf file. * @param outputDir Output dir. */ static int process_input(const char* input, const SkString& outputDir) { int failures = 0; if (sk_isdir(input)) { SkOSFile::Iter iter(input, PDF_FILE_EXTENSION); SkString inputFilename; while (iter.next(&inputFilename)) { SkString inputPath = SkOSPath::SkPathJoin(input, inputFilename.c_str()); if (!process_pdf(inputPath, outputDir)) { ++failures; } } } else { SkString inputPath(input); if (!process_pdf(inputPath, outputDir)) { ++failures; } } return failures; }
bool CollectImages(SkCommandLineFlags::StringArray images, SkTArray<SkString>* output) { SkASSERT(output); static const char* const exts[] = { "bmp", "gif", "jpg", "jpeg", "png", "webp", "ktx", "astc", "wbmp", "ico", "BMP", "GIF", "JPG", "JPEG", "PNG", "WEBP", "KTX", "ASTC", "WBMP", "ICO", #ifdef SK_CODEC_DECODES_RAW "arw", "cr2", "dng", "nef", "nrw", "orf", "raf", "rw2", "pef", "srw", "ARW", "CR2", "DNG", "NEF", "NRW", "ORF", "RAF", "RW2", "PEF", "SRW", #endif }; for (int i = 0; i < images.count(); ++i) { const char* flag = images[i]; if (!sk_exists(flag)) { SkDebugf("%s does not exist!\n", flag); return false; } if (sk_isdir(flag)) { // If the value passed in is a directory, add all the images bool foundAnImage = false; for (const char* ext : exts) { SkOSFile::Iter it(flag, ext); SkString file; while (it.next(&file)) { foundAnImage = true; output->push_back() = SkOSPath::Join(flag, file.c_str()); } } if (!foundAnImage) { SkDebugf("No supported images found in %s!\n", flag); return false; } } else { // Also add the value if it is a single image output->push_back() = flag; } } return true; }
/** For each file in the directory or for the file passed in input, call * render_pdf. * @param input A directory or an skp file. * @param outputDir Output dir. * @param renderer The object responsible to render the skp object into pdf. */ static int process_input(const SkString& input, const SkString& outputDir, sk_tools::PdfRenderer& renderer) { int failures = 0; if (sk_isdir(input.c_str())) { SkOSFile::Iter iter(input.c_str(), SKP_FILE_EXTENSION); SkString inputFilename; while (iter.next(&inputFilename)) { SkString inputPath; sk_tools::make_filepath(&inputPath, input, inputFilename); if (!render_pdf(inputPath, outputDir, renderer)) { ++failures; } } } else { SkString inputPath(input); if (!render_pdf(inputPath, outputDir, renderer)) { ++failures; } } return failures; }
void SkDiffContext::diffDirectories(const char baselinePath[], const char testPath[]) { // Get the files in the baseline, we will then look for those inside the test path SkTArray<SkString> baselineEntries; if (!get_directory(baselinePath, &baselineEntries)) { SkDebugf("Unable to open path \"%s\"\n", baselinePath); return; } for (int baselineIndex = 0; baselineIndex < baselineEntries.count(); baselineIndex++) { const char* baseFilename = baselineEntries[baselineIndex].c_str(); // Find the real location of each file to compare SkString baselineFile = SkOSPath::SkPathJoin(baselinePath, baseFilename); SkString testFile = SkOSPath::SkPathJoin(testPath, baseFilename); // Check that the test file exists and is a file if (sk_exists(testFile.c_str()) && !sk_isdir(testFile.c_str())) { // Queue up the comparison with the differ this->addDiff(baselineFile.c_str(), testFile.c_str()); } else { SkDebugf("Baseline file \"%s\" has no corresponding test file\n", baselineFile.c_str()); } } }
bool get_directory(const char path[], SkTArray<SkString>* entries) { // Open the directory and check for success DIR* dir = opendir(path); if (NULL == dir) { return false; } // Loop through dir entries until there are none left (i.e. readdir returns NULL) struct dirent* entry; while ((entry = readdir(dir))) { // dirent only gives relative paths, we need to join them to the base path to check if they // are directories. SkString joinedPath = SkOSPath::SkPathJoin(path, entry->d_name); // We only care about files if (!sk_isdir(joinedPath.c_str())) { entries->push_back(SkString(entry->d_name)); } } closedir(dir); return true; }
int tool_main(int argc, char** argv) { SkCommandLineFlags::SetUsage("apply lua script to .skp files."); SkCommandLineFlags::Parse(argc, argv); if (FLAGS_skpPath.isEmpty()) { SkDebugf(".skp files or directories are required.\n"); exit(-1); } if (FLAGS_luaFile.isEmpty()) { SkDebugf("missing luaFile(s)\n"); exit(-1); } const char* summary = gSummarizeFunc; if (!FLAGS_tailFunc.isEmpty()) { summary = FLAGS_tailFunc[0]; } SkAutoGraphics ag; SkLua L(summary); for (int i = 0; i < FLAGS_luaFile.count(); ++i) { SkAutoDataUnref data(SkData::NewFromFileName(FLAGS_luaFile[i])); if (NULL == data.get()) { data.reset(SkData::NewEmpty()); } if (!FLAGS_quiet) { SkDebugf("loading %s...\n", FLAGS_luaFile[i]); } if (!L.runCode(data->data(), data->size())) { SkDebugf("failed to load luaFile %s\n", FLAGS_luaFile[i]); exit(-1); } } if (!FLAGS_headCode.isEmpty()) { L.runCode(FLAGS_headCode[0]); } int moduloRemainder = -1; int moduloDivisor = -1; SkString moduloStr; if (FLAGS_modulo.count() == 2) { moduloRemainder = atoi(FLAGS_modulo[0]); moduloDivisor = atoi(FLAGS_modulo[1]); if (moduloRemainder < 0 || moduloDivisor <= 0 || moduloRemainder >= moduloDivisor) { SkDebugf("invalid modulo values.\n"); return -1; } } for (int i = 0; i < FLAGS_skpPath.count(); i ++) { SkTArray<SkString> paths; if (sk_isdir(FLAGS_skpPath[i])) { // Add all .skp in this directory. const SkString directory(FLAGS_skpPath[i]); SkString filename; SkOSFile::Iter iter(FLAGS_skpPath[i], "skp"); while(iter.next(&filename)) { paths.push_back() = SkOSPath::Join(directory.c_str(), filename.c_str()); } } else { // Add this as an .skp itself. paths.push_back() = FLAGS_skpPath[i]; } for (int i = 0; i < paths.count(); i++) { if (moduloRemainder >= 0) { if ((i % moduloDivisor) != moduloRemainder) { continue; } moduloStr.printf("[%d.%d] ", i, moduloDivisor); } const char* path = paths[i].c_str(); if (!FLAGS_quiet) { SkDebugf("scraping %s %s\n", path, moduloStr.c_str()); } SkAutoTUnref<SkPicture> pic(load_picture(path)); if (pic.get()) { SkAutoTUnref<SkLuaCanvas> canvas( new SkLuaCanvas(SkScalarCeilToInt(pic->cullRect().width()), SkScalarCeilToInt(pic->cullRect().height()), L.get(), gAccumulateFunc)); call_canvas(L.get(), canvas.get(), path, gStartCanvasFunc); canvas->drawPicture(pic); call_canvas(L.get(), canvas.get(), path, gEndCanvasFunc); } else { SkDebugf("failed to load\n"); } } } return 0; }