text: /*
   * 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 "tests/Test.h"
  #include "tools/Resources.h"
  
  #include "include/core/SkBitmap.h"
  #include "include/core/SkCanvas.h"
  #include "include/core/SkColorPriv.h"
  #include "include/core/SkEncodedImageFormat.h"
  #include "include/core/SkImage.h"
  #include "include/core/SkImageEncoder.h"
  #include "include/core/SkStream.h"
  #include "include/core/SkSurface.h"
  #include "include/encode/SkJpegEncoder.h"
  #include "include/encode/SkPngEncoder.h"
  #include "include/encode/SkWebpEncoder.h"
  #include "include/private/SkImageInfoPriv.h"
  
  #include <png.h>
  
  #include <algorithm>
  #include <string>
  #include <vector>
  
  // FIXME: Update the Google3 build's dependencies so it can run this test.
  #ifndef SK_BUILD_FOR_GOOGLE3
  #include "webp/decode.h"
  #endif
  
  static bool encode(SkEncodedImageFormat format, SkWStream* dst, const SkPixmap& src) {
      switch (format) {
          case SkEncodedImageFormat::kJPEG:
              return SkJpegEncoder::Encode(dst, src, SkJpegEncoder::Options());
          case SkEncodedImageFormat::kPNG:
              return SkPngEncoder::Encode(dst, src, SkPngEncoder::Options());
          default:
              return false;
      }
  }
  
  static std::unique_ptr<SkEncoder> make(SkEncodedImageFormat format, SkWStream* dst,
                                         const SkPixmap& src) {
      switch (format) {
          case SkEncodedImageFormat::kJPEG:
              return SkJpegEncoder::Make(dst, src, SkJpegEncoder::Options());
          case SkEncodedImageFormat::kPNG:
              return SkPngEncoder::Make(dst, src, SkPngEncoder::Options());
          default:
              return nullptr;
      }
  }
  
  static void test_encode(skiatest::Reporter* r, SkEncodedImageFormat format) {
      SkBitmap bitmap;
      bool success = GetResourceAsBitmap("images/mandrill_128.png", &bitmap);
      if (!success) {
          return;
      }
  
      SkPixmap src;
      success = bitmap.peekPixels(&src);
      REPORTER_ASSERT(r, success);
      if (!success) {
          return;
      }
  
      SkDynamicMemoryWStream dst0, dst1, dst2, dst3;
      success = encode(format, &dst0, src);
      REPORTER_ASSERT(r, success);
  
      auto encoder1 = make(format, &dst1, src);
      for (int i = 0; i < src.height(); i++) {
          success = encoder1->encodeRows(1);
          REPORTER_ASSERT(r, success);
      }
  
      auto encoder2 = make(format, &dst2, src);
      for (int i = 0; i < src.height(); i+=3) {
          success = encoder2->encodeRows(3);
          REPORTER_ASSERT(r, success);
      }
  
      auto encoder3 = make(format, &dst3, src);
      success = encoder3->encodeRows(200);
      REPORTER_ASSERT(r, success);
  
      sk_sp<SkData> data0 = dst0.detachAsData();
      sk_sp<SkData> data1 = dst1.detachAsData();
      sk_sp<SkData> data2 = dst2.detachAsData();
      sk_sp<SkData> data3 = dst3.detachAsData();
      REPORTER_ASSERT(r, data0->equals(data1.get()));
      REPORTER_ASSERT(r, data0->equals(data2.get()));
      REPORTER_ASSERT(r, data0->equals(data3.get()));
  }
  
  DEF_TEST(Encode, r) {
      test_encode(r, SkEncodedImageFormat::kJPEG);
      test_encode(r, SkEncodedImageFormat::kPNG);
  }
  
  static inline bool almost_equals(SkPMColor a, SkPMColor b, int tolerance) {
      if (SkTAbs((int)SkGetPackedR32(a) - (int)SkGetPackedR32(b)) > tolerance) {
          return false;
      }
  
      if (SkTAbs((int)SkGetPackedG32(a) - (int)SkGetPackedG32(b)) > tolerance) {
          return false;
      }
  
      if (SkTAbs((int)SkGetPackedB32(a) - (int)SkGetPackedB32(b)) > tolerance) {
          return false;
      }
  
      if (SkTAbs((int)SkGetPackedA32(a) - (int)SkGetPackedA32(b)) > tolerance) {
          return false;
      }
  
      return true;
  }
  
  static inline bool almost_equals(const SkBitmap& a, const SkBitmap& b, int tolerance) {
      if (a.info() != b.info()) {
          return false;
      }
  
      SkASSERT(kN32_SkColorType == a.colorType());
      for (int y = 0; y < a.height(); y++) {
          for (int x = 0; x < a.width(); x++) {
              if (!almost_equals(*a.getAddr32(x, y), *b.getAddr32(x, y), tolerance)) {
                  return false;
              }
          }
      }
  
      return true;
  }
  
  DEF_TEST(Encode_JPG, r) {
      auto image = GetResourceAsImage("images/mandrill_128.png");
      if (!image) {
          return;
      }
  
      for (auto ct : { kRGBA_8888_SkColorType,
                       kBGRA_8888_SkColorType,
                       kRGB_565_SkColorType,
                       kARGB_4444_SkColorType,
                       kGray_8_SkColorType,
                       kRGBA_F16_SkColorType }) {
          for (auto at : { kPremul_SkAlphaType, kUnpremul_SkAlphaType, kOpaque_SkAlphaType }) {
              auto info = SkImageInfo::Make(image->width(), image->height(), ct, at);
              auto surface = SkSurface::MakeRaster(info);
              auto canvas = surface->getCanvas();
              canvas->drawImage(image, 0, 0);
  
              SkBitmap bm;
              bm.allocPixels(info);
              if (!surface->makeImageSnapshot()->readPixels(nullptr, bm.pixmap(), 0, 0)) {
                  ERRORF(r, "failed to readPixels! ct: %i\tat: %i\n", ct, at);
                  continue;
              }
              for (auto alphaOption : { SkJpegEncoder::AlphaOption::kIgnore,
                                        SkJpegEncoder::AlphaOption::kBlendOnBlack }) {
                  SkJpegEncoder::Options opts;
                  opts.fAlphaOption = alphaOption;
                  SkNullWStream ignored;
                  if (!SkJpegEncoder::Encode(&ignored, bm.pixmap(), opts)) {
                      REPORTER_ASSERT(r, ct == kARGB_4444_SkColorType
                                      && alphaOption == SkJpegEncoder::AlphaOption::kBlendOnBlack);
                  }
              }
          }
      }
  }
  
  DEF_TEST(Encode_JpegDownsample, r) {
      SkBitmap bitmap;
      bool success = GetResourceAsBitmap("images/mandrill_128.png", &bitmap);
      if (!success) {
          return;
      }
  
      SkPixmap src;
      success = bitmap.peekPixels(&src);
      REPORTER_ASSERT(r, success);
      if (!success) {
          return;
      }
  
      SkDynamicMemoryWStream dst0, dst1, dst2;
      SkJpegEncoder::Options options;
      success = SkJpegEncoder::Encode(&dst0, src, options);
      REPORTER_ASSERT(r, success);
  
      options.fDownsample = SkJpegEncoder::Downsample::k422;
      success = SkJpegEncoder::Encode(&dst1, src, options);
      REPORTER_ASSERT(r, success);
  
      options.fDownsample = SkJpegEncoder::Downsample::k444;
      success = SkJpegEncoder::Encode(&dst2, src, options);
      REPORTER_ASSERT(r, success);
  
      sk_sp<SkData> data0 = dst0.detachAsData();
      sk_sp<SkData> data1 = dst1.detachAsData();
      sk_sp<SkData> data2 = dst2.detachAsData();
      REPORTER_ASSERT(r, data0->size() < data1->size());
      REPORTER_ASSERT(r, data1->size() < data2->size());
  
      SkBitmap bm0, bm1, bm2;
      SkImage::MakeFromEncoded(data0)->asLegacyBitmap(&bm0);
      SkImage::MakeFromEncoded(data1)->asLegacyBitmap(&bm1);
      SkImage::MakeFromEncoded(data2)->asLegacyBitmap(&bm2);
      REPORTER_ASSERT(r, almost_equals(bm0, bm1, 60));
      REPORTER_ASSERT(r, almost_equals(bm1, bm2, 60));
  }
  
  static inline void pushComment(
          std::vector<std::string>& comments, const char* keyword, const char* text) {
      comments.push_back(keyword);
      comments.push_back(text);
  }
  
  static void testPngComments(const SkPixmap& src, SkPngEncoder::Options& options,
          skiatest::Reporter* r) {
      std::vector<std::string> commentStrings;
      pushComment(commentStrings, "key", "text");
      pushComment(commentStrings, "test", "something");
      pushComment(commentStrings, "have some", "spaces in both");
  
      std::string longKey(PNG_KEYWORD_MAX_LENGTH, 'x');
  #ifdef SK_DEBUG
      commentStrings.push_back(longKey);
  #else
      // We call SkDEBUGFAILF it the key is too long so we'll only test this in release mode.
      commentStrings.push_back(longKey + "x");
  #endif
      commentStrings.push_back("");
  
      std::vector<const char*> commentPointers;
      std::vector<size_t> commentSizes;
      for(auto& str : commentStrings) {
          commentPointers.push_back(str.c_str());
          commentSizes.push_back(str.length() + 1);
      }
  
      options.fComments = SkDataTable::MakeCopyArrays((void const *const *)commentPointers.data(),
              commentSizes.data(), commentStrings.size());
  
  
      SkDynamicMemoryWStream dst;
      bool success = SkPngEncoder::Encode(&dst, src, options);
      REPORTER_ASSERT(r, success);
  
      std::vector<char> output(dst.bytesWritten());
      dst.copyTo(output.data());
  
      // Each chunk is of the form length (4 bytes), chunk type (tEXt), data,
      // checksum (4 bytes).  Make sure we find all of them in the encoded
      // results.
      const char kExpected1[] =
          "\x00\x00\x00\x08tEXtkey\x00text\x9e\xe7\x66\x51";
      const char kExpected2[] =
          "\x00\x00\x00\x0etEXttest\x00something\x29\xba\xef\xac";
      const char kExpected3[] =
          "\x00\x00\x00\x18tEXthave some\x00spaces in both\x8d\x69\x34\x2d";
      std::string longKeyRecord = "tEXt" + longKey; // A snippet of our long key comment
      std::string tooLongRecord = "tExt" + longKey + "x"; // A snippet whose key is too long
  
      auto search1 = std::search(output.begin(), output.end(),
              kExpected1, kExpected1 + sizeof(kExpected1));
      auto search2 = std::search(output.begin(), output.end(),
              kExpected2, kExpected2 + sizeof(kExpected2));
      auto search3 = std::search(output.begin(), output.end(),
              kExpected3, kExpected3 + sizeof(kExpected3));
      auto search4 = std::search(output.begin(), output.end(),
              longKeyRecord.begin(), longKeyRecord.end());
      auto search5 = std::search(output.begin(), output.end(),
              tooLongRecord.begin(), tooLongRecord.end());
  
      REPORTER_ASSERT(r, search1 != output.end());
      REPORTER_ASSERT(r, search2 != output.end());
      REPORTER_ASSERT(r, search3 != output.end());
      REPORTER_ASSERT(r, search4 != output.end());
      REPORTER_ASSERT(r, search5 == output.end());
      // Comments test ends
  }
  
  DEF_TEST(Encode_PngOptions, r) {
      SkBitmap bitmap;
      bool success = GetResourceAsBitmap("images/mandrill_128.png", &bitmap);
      if (!success) {
          return;
      }
  
      SkPixmap src;
      success = bitmap.peekPixels(&src);
      REPORTER_ASSERT(r, success);
      if (!success) {
          return;
      }
  
      SkDynamicMemoryWStream dst0, dst1, dst2;
      SkPngEncoder::Options options;
      success = SkPngEncoder::Encode(&dst0, src, options);
      REPORTER_ASSERT(r, success);
  
      options.fFilterFlags = SkPngEncoder::FilterFlag::kUp;
      success = SkPngEncoder::Encode(&dst1, src, options);
      REPORTER_ASSERT(r, success);
  
      options.fZLibLevel = 3;
      success = SkPngEncoder::Encode(&dst2, src, options);
      REPORTER_ASSERT(r, success);
  
      testPngComments(src, options, r);
  
      sk_sp<SkData> data0 = dst0.detachAsData();
      sk_sp<SkData> data1 = dst1.detachAsData();
      sk_sp<SkData> data2 = dst2.detachAsData();
      REPORTER_ASSERT(r, data0->size() < data1->size());
      REPORTER_ASSERT(r, data1->size() < data2->size());
  
      SkBitmap bm0, bm1, bm2;
      SkImage::MakeFromEncoded(data0)->asLegacyBitmap(&bm0);
      SkImage::MakeFromEncoded(data1)->asLegacyBitmap(&bm1);
      SkImage::MakeFromEncoded(data2)->asLegacyBitmap(&bm2);
      REPORTER_ASSERT(r, almost_equals(bm0, bm1, 0));
      REPORTER_ASSERT(r, almost_equals(bm0, bm2, 0));
  }
  
  #ifndef SK_BUILD_FOR_GOOGLE3
  DEF_TEST(Encode_WebpQuality, r) {
      SkBitmap bm;
      bm.allocN32Pixels(100, 100);
      bm.eraseColor(SK_ColorBLUE);
  
      auto dataLossy    = SkEncodeBitmap(bm, SkEncodedImageFormat::kWEBP, 99);
      auto dataLossLess = SkEncodeBitmap(bm, SkEncodedImageFormat::kWEBP, 100);
  
      enum Format {
          kMixed    = 0,
          kLossy    = 1,
          kLossless = 2,
      };
  
      auto test = [&r](const sk_sp<SkData>& data, Format expected) {
          auto printFormat = [](int f) {
              switch (f) {
                  case kMixed:    return "mixed";
                  case kLossy:    return "lossy";
                  case kLossless: return "lossless";
                  default:        return "unknown";
              }
          };
  
          if (!data) {
              ERRORF(r, "Failed to encode. Expected %s", printFormat(expected));
              return;
          }
  
          WebPBitstreamFeatures features;
          auto status = WebPGetFeatures(data->bytes(), data->size(), &features);
          if (status != VP8_STATUS_OK) {
              ERRORF(r, "Encode had an error %i. Expected %s", status, printFormat(expected));
              return;
          }
  
          if (expected != features.format) {
              ERRORF(r, "Expected %s encode, but got format %s", printFormat(expected),
                                                                 printFormat(features.format));
          }
      };
  
      test(dataLossy,    kLossy);
      test(dataLossLess, kLossless);
  }
  #endif
  
  DEF_TEST(Encode_WebpOptions, r) {
      SkBitmap bitmap;
      bool success = GetResourceAsBitmap("images/google_chrome.ico", &bitmap);
      if (!success) {
          return;
      }
  
      SkPixmap src;
      success = bitmap.peekPixels(&src);
      REPORTER_ASSERT(r, success);
      if (!success) {
          return;
      }
  
      SkDynamicMemoryWStream dst0, dst1, dst2, dst3;
      SkWebpEncoder::Options options;
      options.fCompression = SkWebpEncoder::Compression::kLossless;
      options.fQuality = 0.0f;
      success = SkWebpEncoder::Encode(&dst0, src, options);
      REPORTER_ASSERT(r, success);
  
      options.fQuality = 100.0f;
      success = SkWebpEncoder::Encode(&dst1, src, options);
      REPORTER_ASSERT(r, success);
  
      options.fCompression = SkWebpEncoder::Compression::kLossy;
      options.fQuality = 100.0f;
      success = SkWebpEncoder::Encode(&dst2, src, options);
      REPORTER_ASSERT(r, success);
  
      options.fCompression = SkWebpEncoder::Compression::kLossy;
      options.fQuality = 50.0f;
      success = SkWebpEncoder::Encode(&dst3, src, options);
      REPORTER_ASSERT(r, success);
  
      sk_sp<SkData> data0 = dst0.detachAsData();
      sk_sp<SkData> data1 = dst1.detachAsData();
      sk_sp<SkData> data2 = dst2.detachAsData();
      sk_sp<SkData> data3 = dst3.detachAsData();
      REPORTER_ASSERT(r, data0->size() > data1->size());
      REPORTER_ASSERT(r, data1->size() > data2->size());
      REPORTER_ASSERT(r, data2->size() > data3->size());
  
      SkBitmap bm0, bm1, bm2, bm3;
      SkImage::MakeFromEncoded(data0)->asLegacyBitmap(&bm0);
      SkImage::MakeFromEncoded(data1)->asLegacyBitmap(&bm1);
      SkImage::MakeFromEncoded(data2)->asLegacyBitmap(&bm2);
      SkImage::MakeFromEncoded(data3)->asLegacyBitmap(&bm3);
      REPORTER_ASSERT(r, almost_equals(bm0, bm1, 0));
      REPORTER_ASSERT(r, almost_equals(bm0, bm2, 90));
      REPORTER_ASSERT(r, almost_equals(bm2, bm3, 50));
  }
  
  DEF_TEST(Encode_Alpha, r) {
      // These formats have no sensible way to encode alpha images.
      for (auto format : { SkEncodedImageFormat::kJPEG,
                           SkEncodedImageFormat::kPNG,
                           SkEncodedImageFormat::kWEBP }) {
          for (int ctAsInt = kUnknown_SkColorType + 1; ctAsInt <= kLastEnum_SkColorType; ctAsInt++) {
              auto ct = static_cast<SkColorType>(ctAsInt);
              // Non-alpha-only colortypes are tested elsewhere.
              if (!SkColorTypeIsAlphaOnly(ct)) continue;
              SkBitmap bm;
              bm.allocPixels(SkImageInfo::Make(10, 10, ct, kPremul_SkAlphaType));
              sk_bzero(bm.getPixels(), bm.computeByteSize());
              auto data = SkEncodeBitmap(bm, format, 100);
              if (format == SkEncodedImageFormat::kPNG && ct == kAlpha_8_SkColorType) {
                  // We support encoding alpha8 to png with our own private meaning.
                  REPORTER_ASSERT(r, data != nullptr);
              } else {
                  REPORTER_ASSERT(r, data == nullptr);
              }
          }
      }
  }
  