| /* |
| * Copyright 2017 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #include "gm_knowledge.h" |
| |
| #include <cfloat> |
| #include <fstream> |
| #include <sstream> |
| #include <string> |
| #include <vector> |
| |
| #include "../../src/core/SkStreamPriv.h" |
| #include "SkBitmap.h" |
| #include "SkCodec.h" |
| #include "SkOSFile.h" |
| #include "SkPngEncoder.h" |
| #include "SkStream.h" |
| |
| #include "skqp_asset_manager.h" |
| |
| #define PATH_MAX_PNG "max.png" |
| #define PATH_MIN_PNG "min.png" |
| #define PATH_IMG_PNG "image.png" |
| #define PATH_ERR_PNG "errors.png" |
| #define PATH_REPORT "report.html" |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| inline void path_join_append(std::ostringstream* o) { } |
| |
| template<class... Types> |
| void path_join_append(std::ostringstream* o, const char* v, Types... args) { |
| constexpr char kPathSeparator[] = "/"; |
| *o << kPathSeparator << v; |
| path_join_append(o, args...); |
| } |
| |
| template<class... Types> |
| std::string path_join(const char* v, Types... args) { |
| std::ostringstream o; |
| o << v; |
| path_join_append(&o, args...); |
| return o.str(); |
| } |
| template<class... Types> |
| std::string path_join(const std::string& v, Types... args) { |
| return path_join(v.c_str(), args...); |
| } |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| static int get_error(uint32_t value, uint32_t value_max, uint32_t value_min) { |
| int error = 0; |
| for (int j : {0, 8, 16, 24}) { |
| uint8_t v = (value >> j) & 0xFF, |
| vmin = (value_min >> j) & 0xFF, |
| vmax = (value_max >> j) & 0xFF; |
| if (v > vmax) { |
| error = std::max(v - vmax, error); |
| } else if (v < vmin) { |
| error = std::max(vmin - v, error); |
| } |
| } |
| return error; |
| } |
| |
| static float set_error_code(gmkb::Error* error_out, gmkb::Error error) { |
| SkASSERT(error != gmkb::Error::kNone); |
| if (error_out) { |
| *error_out = error; |
| } |
| return FLT_MAX; |
| } |
| |
| static SkPixmap to_pixmap(const SkBitmap& bitmap) { |
| SkPixmap pixmap; |
| SkAssertResult(bitmap.peekPixels(&pixmap)); |
| return pixmap; |
| } |
| |
| |
| static bool WritePixmapToFile(const SkPixmap& pixmap, const char* path) { |
| SkFILEWStream wStream(path); |
| SkPngEncoder::Options options; |
| options.fUnpremulBehavior = SkTransferFunctionBehavior::kIgnore; |
| return wStream.isValid() && SkPngEncoder::Encode(&wStream, pixmap, options); |
| } |
| |
| constexpr SkColorType kColorType = kRGBA_8888_SkColorType; |
| constexpr SkAlphaType kAlphaType = kUnpremul_SkAlphaType; |
| |
| static SkPixmap rgba8888_to_pixmap(const uint32_t* pixels, int width, int height) { |
| SkImageInfo info = SkImageInfo::Make(width, height, kColorType, kAlphaType); |
| return SkPixmap(info, pixels, width * sizeof(uint32_t)); |
| } |
| |
| static bool asset_exists(skqp::AssetManager* mgr, const char* path) { |
| return mgr && nullptr != mgr->open(path); |
| } |
| |
| static bool copy(skqp::AssetManager* mgr, const char* path, const char* dst) { |
| if (mgr) { |
| if (auto stream = mgr->open(path)) { |
| SkFILEWStream wStream(dst); |
| return wStream.isValid() && SkStreamCopy(&wStream, stream.get()); |
| } |
| } |
| return false; |
| } |
| |
| static SkBitmap ReadPngRgba8888FromFile(skqp::AssetManager* assetManager, const char* path) { |
| SkBitmap bitmap; |
| if (auto codec = SkCodec::MakeFromStream(assetManager->open(path))) { |
| SkISize size = codec->getInfo().dimensions(); |
| SkASSERT(!size.isEmpty()); |
| SkImageInfo info = SkImageInfo::Make(size.width(), size.height(), kColorType, kAlphaType); |
| bitmap.allocPixels(info); |
| SkASSERT(bitmap.rowBytes() == (unsigned)bitmap.width() * sizeof(uint32_t)); |
| if (SkCodec::kSuccess != codec->getPixels(to_pixmap(bitmap))) { |
| bitmap.reset(); |
| } |
| } |
| return bitmap; |
| } |
| |
| namespace gmkb { |
| // Assumes that for each GM foo, asset_manager has files foo/{max,min}.png |
| float Check(const uint32_t* pixels, |
| int width, |
| int height, |
| const char* name, |
| const char* backend, |
| skqp::AssetManager* assetManager, |
| const char* report_directory_path, |
| Error* error_out) { |
| using std::string; |
| if (width <= 0 || height <= 0) { |
| return set_error_code(error_out, Error::kBadInput); |
| } |
| size_t N = (unsigned)width * (unsigned)height; |
| string max_path = path_join(name, PATH_MAX_PNG); |
| string min_path = path_join(name, PATH_MIN_PNG); |
| SkBitmap max_image = ReadPngRgba8888FromFile(assetManager, max_path.c_str()); |
| if (max_image.isNull()) { |
| return set_error_code(error_out, Error::kBadData); |
| } |
| SkBitmap min_image = ReadPngRgba8888FromFile(assetManager, min_path.c_str()); |
| if (min_image.isNull()) { |
| return set_error_code(error_out, Error::kBadData); |
| } |
| if (max_image.width() != min_image.width() || |
| max_image.height() != min_image.height()) |
| { |
| return set_error_code(error_out, Error::kBadData); |
| } |
| if (max_image.width() != width || max_image.height() != height) { |
| return set_error_code(error_out, Error::kBadInput); |
| } |
| int badness = 0; |
| int badPixelCount = 0; |
| const uint32_t* max_pixels = (uint32_t*)max_image.getPixels(); |
| const uint32_t* min_pixels = (uint32_t*)min_image.getPixels(); |
| |
| for (size_t i = 0; i < N; ++i) { |
| int error = get_error(pixels[i], max_pixels[i], min_pixels[i]); |
| if (error > 0) { |
| badness = SkTMax(error, badness); |
| ++badPixelCount; |
| } |
| } |
| if (report_directory_path && badness > 0 && report_directory_path[0] != '\0') { |
| sk_mkdir(report_directory_path); |
| if (!backend) { |
| backend = "skia"; |
| } |
| string report_directory = path_join(report_directory_path, backend); |
| sk_mkdir(report_directory.c_str()); |
| string report_subdirectory = path_join(report_directory, name); |
| sk_mkdir(report_subdirectory.c_str()); |
| string error_path = path_join(report_subdirectory, PATH_IMG_PNG); |
| SkAssertResult(WritePixmapToFile(rgba8888_to_pixmap(pixels, width, height), |
| error_path.c_str())); |
| SkBitmap errorBitmap; |
| errorBitmap.allocPixels(SkImageInfo::Make(width, height, kColorType, kAlphaType)); |
| uint32_t* errors = (uint32_t*)errorBitmap.getPixels(); |
| for (size_t i = 0; i < N; ++i) { |
| int error = get_error(pixels[i], max_pixels[i], min_pixels[i]); |
| errors[i] = error > 0 ? 0xFF000000 + (unsigned)error : 0x00000000; |
| } |
| error_path = path_join(report_subdirectory, PATH_ERR_PNG); |
| SkAssertResult(WritePixmapToFile(to_pixmap(errorBitmap), error_path.c_str())); |
| |
| auto report_path = path_join(report_subdirectory, PATH_REPORT); |
| auto rdir = path_join("..", "..", backend, name); |
| |
| auto max_path_out = path_join(report_subdirectory, PATH_MAX_PNG); |
| auto min_path_out = path_join(report_subdirectory, PATH_MIN_PNG); |
| (void)copy(assetManager, max_path.c_str(), max_path_out.c_str()); |
| (void)copy(assetManager, min_path.c_str(), min_path_out.c_str()); |
| |
| SkString text = SkStringPrintf( |
| "backend: %s\n<br>\n" |
| "gm name: %s\n<br>\n" |
| "maximum error: %d\n<br>\n" |
| "bad pixel counts: %d\n<br>\n" |
| "<a href=\"%s/" PATH_IMG_PNG "\">" |
| "<img src=\"%s/" PATH_IMG_PNG "\" alt='img'></a>\n" |
| "<a href=\"%s/" PATH_ERR_PNG "\">" |
| "<img src=\"%s/" PATH_ERR_PNG "\" alt='err'></a>\n<br>\n" |
| "<a href=\"%s/" PATH_MAX_PNG "\">max</a>\n<br>\n" |
| "<a href=\"%s/" PATH_MIN_PNG "\">min</a>\n<hr>\n", |
| backend, name, badness, badPixelCount, |
| rdir.c_str(), rdir.c_str(), rdir.c_str(), rdir.c_str(), rdir.c_str(), rdir.c_str()); |
| SkFILEWStream(report_path.c_str()).write(text.c_str(), text.size()); |
| } |
| if (error_out) { |
| *error_out = Error::kNone; |
| } |
| return (float)badness; |
| } |
| |
| bool IsGoodGM(const char* name, skqp::AssetManager* assetManager) { |
| std::string max_path = path_join(name, PATH_MAX_PNG); |
| std::string min_path = path_join(name, PATH_MIN_PNG); |
| return asset_exists(assetManager, max_path.c_str()) |
| && asset_exists(assetManager, min_path.c_str()); |
| } |
| } // namespace gmkb |
