c06f309cf5
This reverts commit 9b848d5749
.
Reason for revert: ASAN reports leaked memory [1]. Google3 reports a "delete size mismatch" [2], which I suspect is the same issue.
[1] https://chromium-swarm.appspot.com/task?id=35e2c9fa9eac6310&refresh=10&show_raw=1
[2] https://test.corp.google.com/ui#cl=154838904&flags=CAMQBQ==&id=OCL:154838904:BASE:154839043:1493741642370:9c96115f&t=//chrome/skia/dm_wrapper:dm_wrapper
Original change's description:
> Add support for row-by-row jpeg encoding
>
> Bug: 713862
> Change-Id: I787b7c49662a00b89ae0ef35845dfbd6be3e6fb1
> Reviewed-on: https://skia-review.googlesource.com/14641
> Commit-Queue: Matt Sarett <msarett@google.com>
> Reviewed-by: Leon Scroggins <scroggo@google.com>
>
TBR=msarett@google.com,scroggo@google.com,reed@google.com
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
Change-Id: Ic5a8d67e0d4a7733662586055ceff086a2ab335d
Reviewed-on: https://skia-review.googlesource.com/15140
Reviewed-by: Leon Scroggins <scroggo@google.com>
Commit-Queue: Leon Scroggins <scroggo@google.com>
1592 lines
60 KiB
C++
1592 lines
60 KiB
C++
/*
|
|
* Copyright 2015 Google Inc.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
* found in the LICENSE file.
|
|
*/
|
|
|
|
#include "FakeStreams.h"
|
|
#include "Resources.h"
|
|
#include "SkAndroidCodec.h"
|
|
#include "SkAutoMalloc.h"
|
|
#include "SkBitmap.h"
|
|
#include "SkCodec.h"
|
|
#include "SkCodecImageGenerator.h"
|
|
#include "SkColorSpace_XYZ.h"
|
|
#include "SkColorSpacePriv.h"
|
|
#include "SkData.h"
|
|
#include "SkFrontBufferedStream.h"
|
|
#include "SkImageEncoder.h"
|
|
#include "SkImageEncoderPriv.h"
|
|
#include "SkMD5.h"
|
|
#include "SkOSPath.h"
|
|
#include "SkPngChunkReader.h"
|
|
#include "SkRandom.h"
|
|
#include "SkStream.h"
|
|
#include "SkStreamPriv.h"
|
|
#include "Test.h"
|
|
|
|
#include "png.h"
|
|
|
|
#include "sk_tool_utils.h"
|
|
|
|
#if PNG_LIBPNG_VER_MAJOR == 1 && PNG_LIBPNG_VER_MINOR < 5
|
|
// FIXME (scroggo): Google3 needs to be updated to use a newer version of libpng. In
|
|
// the meantime, we had to break some pieces of SkPngCodec in order to support Google3.
|
|
// The parts that are broken are likely not used by Google3.
|
|
#define SK_PNG_DISABLE_TESTS
|
|
#endif
|
|
|
|
static void md5(const SkBitmap& bm, SkMD5::Digest* digest) {
|
|
SkASSERT(bm.getPixels());
|
|
SkMD5 md5;
|
|
size_t rowLen = bm.info().bytesPerPixel() * bm.width();
|
|
for (int y = 0; y < bm.height(); ++y) {
|
|
md5.write(bm.getAddr(0, y), rowLen);
|
|
}
|
|
md5.finish(*digest);
|
|
}
|
|
|
|
/**
|
|
* Compute the digest for bm and compare it to a known good digest.
|
|
* @param r Reporter to assert that bm's digest matches goodDigest.
|
|
* @param goodDigest The known good digest to compare to.
|
|
* @param bm The bitmap to test.
|
|
*/
|
|
static void compare_to_good_digest(skiatest::Reporter* r, const SkMD5::Digest& goodDigest,
|
|
const SkBitmap& bm) {
|
|
SkMD5::Digest digest;
|
|
md5(bm, &digest);
|
|
REPORTER_ASSERT(r, digest == goodDigest);
|
|
}
|
|
|
|
/**
|
|
* Test decoding an SkCodec to a particular SkImageInfo.
|
|
*
|
|
* Calling getPixels(info) should return expectedResult, and if goodDigest is non nullptr,
|
|
* the resulting decode should match.
|
|
*/
|
|
template<typename Codec>
|
|
static void test_info(skiatest::Reporter* r, Codec* codec, const SkImageInfo& info,
|
|
SkCodec::Result expectedResult, const SkMD5::Digest* goodDigest) {
|
|
SkBitmap bm;
|
|
bm.allocPixels(info);
|
|
|
|
SkCodec::Result result = codec->getPixels(info, bm.getPixels(), bm.rowBytes());
|
|
REPORTER_ASSERT(r, result == expectedResult);
|
|
|
|
if (goodDigest) {
|
|
compare_to_good_digest(r, *goodDigest, bm);
|
|
}
|
|
}
|
|
|
|
SkIRect generate_random_subset(SkRandom* rand, int w, int h) {
|
|
SkIRect rect;
|
|
do {
|
|
rect.fLeft = rand->nextRangeU(0, w);
|
|
rect.fTop = rand->nextRangeU(0, h);
|
|
rect.fRight = rand->nextRangeU(0, w);
|
|
rect.fBottom = rand->nextRangeU(0, h);
|
|
rect.sort();
|
|
} while (rect.isEmpty());
|
|
return rect;
|
|
}
|
|
|
|
static void test_incremental_decode(skiatest::Reporter* r, SkCodec* codec, const SkImageInfo& info,
|
|
const SkMD5::Digest& goodDigest) {
|
|
SkBitmap bm;
|
|
bm.allocPixels(info);
|
|
|
|
REPORTER_ASSERT(r, SkCodec::kSuccess == codec->startIncrementalDecode(info, bm.getPixels(),
|
|
bm.rowBytes()));
|
|
|
|
REPORTER_ASSERT(r, SkCodec::kSuccess == codec->incrementalDecode());
|
|
|
|
compare_to_good_digest(r, goodDigest, bm);
|
|
}
|
|
|
|
// Test in stripes, similar to DM's kStripe_Mode
|
|
static void test_in_stripes(skiatest::Reporter* r, SkCodec* codec, const SkImageInfo& info,
|
|
const SkMD5::Digest& goodDigest) {
|
|
SkBitmap bm;
|
|
bm.allocPixels(info);
|
|
bm.eraseColor(SK_ColorYELLOW);
|
|
|
|
const int height = info.height();
|
|
// Note that if numStripes does not evenly divide height there will be an extra
|
|
// stripe.
|
|
const int numStripes = 4;
|
|
|
|
if (numStripes > height) {
|
|
// Image is too small.
|
|
return;
|
|
}
|
|
|
|
const int stripeHeight = height / numStripes;
|
|
|
|
// Iterate through the image twice. Once to decode odd stripes, and once for even.
|
|
for (int oddEven = 1; oddEven >= 0; oddEven--) {
|
|
for (int y = oddEven * stripeHeight; y < height; y += 2 * stripeHeight) {
|
|
SkIRect subset = SkIRect::MakeLTRB(0, y, info.width(),
|
|
SkTMin(y + stripeHeight, height));
|
|
SkCodec::Options options;
|
|
options.fSubset = ⊂
|
|
if (SkCodec::kSuccess != codec->startIncrementalDecode(info, bm.getAddr(0, y),
|
|
bm.rowBytes(), &options)) {
|
|
ERRORF(r, "failed to start incremental decode!\ttop: %i\tbottom%i\n",
|
|
subset.top(), subset.bottom());
|
|
return;
|
|
}
|
|
if (SkCodec::kSuccess != codec->incrementalDecode()) {
|
|
ERRORF(r, "failed incremental decode starting from line %i\n", y);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
compare_to_good_digest(r, goodDigest, bm);
|
|
}
|
|
|
|
template<typename Codec>
|
|
static void test_codec(skiatest::Reporter* r, Codec* codec, SkBitmap& bm, const SkImageInfo& info,
|
|
const SkISize& size, SkCodec::Result expectedResult, SkMD5::Digest* digest,
|
|
const SkMD5::Digest* goodDigest) {
|
|
|
|
REPORTER_ASSERT(r, info.dimensions() == size);
|
|
bm.allocPixels(info);
|
|
|
|
SkCodec::Result result = codec->getPixels(info, bm.getPixels(), bm.rowBytes());
|
|
REPORTER_ASSERT(r, result == expectedResult);
|
|
|
|
md5(bm, digest);
|
|
if (goodDigest) {
|
|
REPORTER_ASSERT(r, *digest == *goodDigest);
|
|
}
|
|
|
|
{
|
|
// Test decoding to 565
|
|
SkImageInfo info565 = info.makeColorType(kRGB_565_SkColorType);
|
|
if (info.alphaType() == kOpaque_SkAlphaType) {
|
|
// Decoding to 565 should succeed.
|
|
SkBitmap bm565;
|
|
bm565.allocPixels(info565);
|
|
|
|
// This will allow comparison even if the image is incomplete.
|
|
bm565.eraseColor(SK_ColorBLACK);
|
|
|
|
REPORTER_ASSERT(r, expectedResult == codec->getPixels(info565,
|
|
bm565.getPixels(), bm565.rowBytes()));
|
|
|
|
SkMD5::Digest digest565;
|
|
md5(bm565, &digest565);
|
|
|
|
// A dumb client's request for non-opaque should also succeed.
|
|
for (auto alpha : { kPremul_SkAlphaType, kUnpremul_SkAlphaType }) {
|
|
info565 = info565.makeAlphaType(alpha);
|
|
test_info(r, codec, info565, expectedResult, &digest565);
|
|
}
|
|
} else {
|
|
test_info(r, codec, info565, SkCodec::kInvalidConversion, nullptr);
|
|
}
|
|
}
|
|
|
|
if (codec->getInfo().colorType() == kGray_8_SkColorType) {
|
|
SkImageInfo grayInfo = codec->getInfo();
|
|
SkBitmap grayBm;
|
|
grayBm.allocPixels(grayInfo);
|
|
|
|
grayBm.eraseColor(SK_ColorBLACK);
|
|
|
|
REPORTER_ASSERT(r, expectedResult == codec->getPixels(grayInfo,
|
|
grayBm.getPixels(), grayBm.rowBytes()));
|
|
|
|
SkMD5::Digest grayDigest;
|
|
md5(grayBm, &grayDigest);
|
|
|
|
for (auto alpha : { kPremul_SkAlphaType, kUnpremul_SkAlphaType }) {
|
|
grayInfo = grayInfo.makeAlphaType(alpha);
|
|
test_info(r, codec, grayInfo, expectedResult, &grayDigest);
|
|
}
|
|
}
|
|
|
|
// Verify that re-decoding gives the same result. It is interesting to check this after
|
|
// a decode to 565, since choosing to decode to 565 may result in some of the decode
|
|
// options being modified. These options should return to their defaults on another
|
|
// decode to kN32, so the new digest should match the old digest.
|
|
test_info(r, codec, info, expectedResult, digest);
|
|
|
|
{
|
|
// Check alpha type conversions
|
|
if (info.alphaType() == kOpaque_SkAlphaType) {
|
|
test_info(r, codec, info.makeAlphaType(kUnpremul_SkAlphaType),
|
|
expectedResult, digest);
|
|
test_info(r, codec, info.makeAlphaType(kPremul_SkAlphaType),
|
|
expectedResult, digest);
|
|
} else {
|
|
// Decoding to opaque should fail
|
|
test_info(r, codec, info.makeAlphaType(kOpaque_SkAlphaType),
|
|
SkCodec::kInvalidConversion, nullptr);
|
|
SkAlphaType otherAt = info.alphaType();
|
|
if (kPremul_SkAlphaType == otherAt) {
|
|
otherAt = kUnpremul_SkAlphaType;
|
|
} else {
|
|
otherAt = kPremul_SkAlphaType;
|
|
}
|
|
// The other non-opaque alpha type should always succeed, but not match.
|
|
test_info(r, codec, info.makeAlphaType(otherAt), expectedResult, nullptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
static bool supports_partial_scanlines(const char path[]) {
|
|
static const char* const exts[] = {
|
|
"jpg", "jpeg", "png", "webp"
|
|
"JPG", "JPEG", "PNG", "WEBP"
|
|
};
|
|
|
|
for (uint32_t i = 0; i < SK_ARRAY_COUNT(exts); i++) {
|
|
if (SkStrEndsWith(path, exts[i])) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// FIXME: Break up this giant function
|
|
static void check(skiatest::Reporter* r,
|
|
const char path[],
|
|
SkISize size,
|
|
bool supportsScanlineDecoding,
|
|
bool supportsSubsetDecoding,
|
|
bool supportsIncomplete,
|
|
bool supportsNewScanlineDecoding = false) {
|
|
|
|
std::unique_ptr<SkStream> stream(GetResourceAsStream(path));
|
|
if (!stream) {
|
|
return;
|
|
}
|
|
|
|
std::unique_ptr<SkCodec> codec(nullptr);
|
|
bool isIncomplete = supportsIncomplete;
|
|
if (isIncomplete) {
|
|
size_t size = stream->getLength();
|
|
sk_sp<SkData> data((SkData::MakeFromStream(stream.get(), 2 * size / 3)));
|
|
codec.reset(SkCodec::NewFromData(data));
|
|
} else {
|
|
codec.reset(SkCodec::NewFromStream(stream.release()));
|
|
}
|
|
if (!codec) {
|
|
ERRORF(r, "Unable to decode '%s'", path);
|
|
return;
|
|
}
|
|
|
|
// Test full image decodes with SkCodec
|
|
SkMD5::Digest codecDigest;
|
|
const SkImageInfo info = codec->getInfo().makeColorType(kN32_SkColorType);
|
|
SkBitmap bm;
|
|
SkCodec::Result expectedResult = isIncomplete ? SkCodec::kIncompleteInput : SkCodec::kSuccess;
|
|
test_codec(r, codec.get(), bm, info, size, expectedResult, &codecDigest, nullptr);
|
|
|
|
// Scanline decoding follows.
|
|
|
|
if (supportsNewScanlineDecoding && !isIncomplete) {
|
|
test_incremental_decode(r, codec.get(), info, codecDigest);
|
|
// This is only supported by codecs that use incremental decoding to
|
|
// support subset decodes - png and jpeg (once SkJpegCodec is
|
|
// converted).
|
|
if (SkStrEndsWith(path, "png") || SkStrEndsWith(path, "PNG")) {
|
|
test_in_stripes(r, codec.get(), info, codecDigest);
|
|
}
|
|
}
|
|
|
|
// Need to call startScanlineDecode() first.
|
|
REPORTER_ASSERT(r, codec->getScanlines(bm.getAddr(0, 0), 1, 0) == 0);
|
|
REPORTER_ASSERT(r, !codec->skipScanlines(1));
|
|
const SkCodec::Result startResult = codec->startScanlineDecode(info);
|
|
if (supportsScanlineDecoding) {
|
|
bm.eraseColor(SK_ColorYELLOW);
|
|
|
|
REPORTER_ASSERT(r, startResult == SkCodec::kSuccess);
|
|
|
|
for (int y = 0; y < info.height(); y++) {
|
|
const int lines = codec->getScanlines(bm.getAddr(0, y), 1, 0);
|
|
if (!isIncomplete) {
|
|
REPORTER_ASSERT(r, 1 == lines);
|
|
}
|
|
}
|
|
// verify that scanline decoding gives the same result.
|
|
if (SkCodec::kTopDown_SkScanlineOrder == codec->getScanlineOrder()) {
|
|
compare_to_good_digest(r, codecDigest, bm);
|
|
}
|
|
|
|
// Cannot continue to decode scanlines beyond the end
|
|
REPORTER_ASSERT(r, codec->getScanlines(bm.getAddr(0, 0), 1, 0)
|
|
== 0);
|
|
|
|
// Interrupting a scanline decode with a full decode starts from
|
|
// scratch
|
|
REPORTER_ASSERT(r, codec->startScanlineDecode(info) == SkCodec::kSuccess);
|
|
const int lines = codec->getScanlines(bm.getAddr(0, 0), 1, 0);
|
|
if (!isIncomplete) {
|
|
REPORTER_ASSERT(r, lines == 1);
|
|
}
|
|
REPORTER_ASSERT(r, codec->getPixels(bm.info(), bm.getPixels(), bm.rowBytes())
|
|
== expectedResult);
|
|
REPORTER_ASSERT(r, codec->getScanlines(bm.getAddr(0, 0), 1, 0)
|
|
== 0);
|
|
REPORTER_ASSERT(r, codec->skipScanlines(1)
|
|
== 0);
|
|
|
|
// Test partial scanline decodes
|
|
if (supports_partial_scanlines(path) && info.width() >= 3) {
|
|
SkCodec::Options options;
|
|
int width = info.width();
|
|
int height = info.height();
|
|
SkIRect subset = SkIRect::MakeXYWH(2 * (width / 3), 0, width / 3, height);
|
|
options.fSubset = ⊂
|
|
|
|
const SkCodec::Result partialStartResult = codec->startScanlineDecode(info, &options,
|
|
nullptr, nullptr);
|
|
REPORTER_ASSERT(r, partialStartResult == SkCodec::kSuccess);
|
|
|
|
for (int y = 0; y < height; y++) {
|
|
const int lines = codec->getScanlines(bm.getAddr(0, y), 1, 0);
|
|
if (!isIncomplete) {
|
|
REPORTER_ASSERT(r, 1 == lines);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
REPORTER_ASSERT(r, startResult == SkCodec::kUnimplemented);
|
|
}
|
|
|
|
// The rest of this function tests decoding subsets, and will decode an arbitrary number of
|
|
// random subsets.
|
|
// Do not attempt to decode subsets of an image of only once pixel, since there is no
|
|
// meaningful subset.
|
|
if (size.width() * size.height() == 1) {
|
|
return;
|
|
}
|
|
|
|
SkRandom rand;
|
|
SkIRect subset;
|
|
SkCodec::Options opts;
|
|
opts.fSubset = ⊂
|
|
for (int i = 0; i < 5; i++) {
|
|
subset = generate_random_subset(&rand, size.width(), size.height());
|
|
SkASSERT(!subset.isEmpty());
|
|
const bool supported = codec->getValidSubset(&subset);
|
|
REPORTER_ASSERT(r, supported == supportsSubsetDecoding);
|
|
|
|
SkImageInfo subsetInfo = info.makeWH(subset.width(), subset.height());
|
|
SkBitmap bm;
|
|
bm.allocPixels(subsetInfo);
|
|
const SkCodec::Result result = codec->getPixels(bm.info(), bm.getPixels(), bm.rowBytes(),
|
|
&opts, nullptr, nullptr);
|
|
|
|
if (supportsSubsetDecoding) {
|
|
if (expectedResult == SkCodec::kSuccess) {
|
|
REPORTER_ASSERT(r, result == expectedResult);
|
|
} else {
|
|
SkASSERT(expectedResult == SkCodec::kIncompleteInput);
|
|
REPORTER_ASSERT(r, result == SkCodec::kIncompleteInput
|
|
|| result == SkCodec::kSuccess);
|
|
}
|
|
// Webp is the only codec that supports subsets, and it will have modified the subset
|
|
// to have even left/top.
|
|
REPORTER_ASSERT(r, SkIsAlign2(subset.fLeft) && SkIsAlign2(subset.fTop));
|
|
} else {
|
|
// No subsets will work.
|
|
REPORTER_ASSERT(r, result == SkCodec::kUnimplemented);
|
|
}
|
|
}
|
|
|
|
// SkAndroidCodec tests
|
|
if (supportsScanlineDecoding || supportsSubsetDecoding || supportsNewScanlineDecoding) {
|
|
|
|
std::unique_ptr<SkStream> stream(GetResourceAsStream(path));
|
|
if (!stream) {
|
|
return;
|
|
}
|
|
|
|
std::unique_ptr<SkAndroidCodec> androidCodec(nullptr);
|
|
if (isIncomplete) {
|
|
size_t size = stream->getLength();
|
|
sk_sp<SkData> data((SkData::MakeFromStream(stream.get(), 2 * size / 3)));
|
|
androidCodec.reset(SkAndroidCodec::NewFromData(data));
|
|
} else {
|
|
androidCodec.reset(SkAndroidCodec::NewFromStream(stream.release()));
|
|
}
|
|
if (!androidCodec) {
|
|
ERRORF(r, "Unable to decode '%s'", path);
|
|
return;
|
|
}
|
|
|
|
SkBitmap bm;
|
|
SkMD5::Digest androidCodecDigest;
|
|
test_codec(r, androidCodec.get(), bm, info, size, expectedResult, &androidCodecDigest,
|
|
&codecDigest);
|
|
}
|
|
|
|
if (!isIncomplete) {
|
|
// Test SkCodecImageGenerator
|
|
std::unique_ptr<SkStream> stream(GetResourceAsStream(path));
|
|
sk_sp<SkData> fullData(SkData::MakeFromStream(stream.get(), stream->getLength()));
|
|
std::unique_ptr<SkImageGenerator> gen(
|
|
SkCodecImageGenerator::MakeFromEncodedCodec(fullData));
|
|
SkBitmap bm;
|
|
bm.allocPixels(info);
|
|
REPORTER_ASSERT(r, gen->getPixels(info, bm.getPixels(), bm.rowBytes()));
|
|
compare_to_good_digest(r, codecDigest, bm);
|
|
|
|
#ifndef SK_PNG_DISABLE_TESTS
|
|
// Test using SkFrontBufferedStream, as Android does
|
|
SkStream* bufferedStream = SkFrontBufferedStream::Create(
|
|
new SkMemoryStream(std::move(fullData)), SkCodec::MinBufferedBytesNeeded());
|
|
REPORTER_ASSERT(r, bufferedStream);
|
|
codec.reset(SkCodec::NewFromStream(bufferedStream));
|
|
REPORTER_ASSERT(r, codec);
|
|
if (codec) {
|
|
test_info(r, codec.get(), info, SkCodec::kSuccess, &codecDigest);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
// If we've just tested incomplete decodes, let's run the same test again on full decodes.
|
|
if (isIncomplete) {
|
|
check(r, path, size, supportsScanlineDecoding, supportsSubsetDecoding, false,
|
|
supportsNewScanlineDecoding);
|
|
}
|
|
}
|
|
|
|
DEF_TEST(Codec_wbmp, r) {
|
|
check(r, "mandrill.wbmp", SkISize::Make(512, 512), true, false, true);
|
|
}
|
|
|
|
DEF_TEST(Codec_webp, r) {
|
|
check(r, "baby_tux.webp", SkISize::Make(386, 395), false, true, true);
|
|
check(r, "color_wheel.webp", SkISize::Make(128, 128), false, true, true);
|
|
check(r, "yellow_rose.webp", SkISize::Make(400, 301), false, true, true);
|
|
}
|
|
|
|
DEF_TEST(Codec_bmp, r) {
|
|
check(r, "randPixels.bmp", SkISize::Make(8, 8), true, false, true);
|
|
check(r, "rle.bmp", SkISize::Make(320, 240), true, false, true);
|
|
}
|
|
|
|
DEF_TEST(Codec_ico, r) {
|
|
// FIXME: We are not ready to test incomplete ICOs
|
|
// These two tests examine interestingly different behavior:
|
|
// Decodes an embedded BMP image
|
|
check(r, "color_wheel.ico", SkISize::Make(128, 128), true, false, false);
|
|
// Decodes an embedded PNG image
|
|
check(r, "google_chrome.ico", SkISize::Make(256, 256), false, false, false, true);
|
|
}
|
|
|
|
DEF_TEST(Codec_gif, r) {
|
|
check(r, "box.gif", SkISize::Make(200, 55), false, false, true, true);
|
|
check(r, "color_wheel.gif", SkISize::Make(128, 128), false, false, true, true);
|
|
// randPixels.gif is too small to test incomplete
|
|
check(r, "randPixels.gif", SkISize::Make(8, 8), false, false, false, true);
|
|
}
|
|
|
|
DEF_TEST(Codec_jpg, r) {
|
|
check(r, "CMYK.jpg", SkISize::Make(642, 516), true, false, true);
|
|
check(r, "color_wheel.jpg", SkISize::Make(128, 128), true, false, true);
|
|
// grayscale.jpg is too small to test incomplete
|
|
check(r, "grayscale.jpg", SkISize::Make(128, 128), true, false, false);
|
|
check(r, "mandrill_512_q075.jpg", SkISize::Make(512, 512), true, false, true);
|
|
// randPixels.jpg is too small to test incomplete
|
|
check(r, "randPixels.jpg", SkISize::Make(8, 8), true, false, false);
|
|
}
|
|
|
|
DEF_TEST(Codec_png, r) {
|
|
check(r, "arrow.png", SkISize::Make(187, 312), false, false, true, true);
|
|
check(r, "baby_tux.png", SkISize::Make(240, 246), false, false, true, true);
|
|
check(r, "color_wheel.png", SkISize::Make(128, 128), false, false, true, true);
|
|
// half-transparent-white-pixel.png is too small to test incomplete
|
|
check(r, "half-transparent-white-pixel.png", SkISize::Make(1, 1), false, false, false, true);
|
|
check(r, "mandrill_128.png", SkISize::Make(128, 128), false, false, true, true);
|
|
check(r, "mandrill_16.png", SkISize::Make(16, 16), false, false, true, true);
|
|
check(r, "mandrill_256.png", SkISize::Make(256, 256), false, false, true, true);
|
|
check(r, "mandrill_32.png", SkISize::Make(32, 32), false, false, true, true);
|
|
check(r, "mandrill_512.png", SkISize::Make(512, 512), false, false, true, true);
|
|
check(r, "mandrill_64.png", SkISize::Make(64, 64), false, false, true, true);
|
|
check(r, "plane.png", SkISize::Make(250, 126), false, false, true, true);
|
|
check(r, "plane_interlaced.png", SkISize::Make(250, 126), false, false, true, true);
|
|
check(r, "randPixels.png", SkISize::Make(8, 8), false, false, true, true);
|
|
check(r, "yellow_rose.png", SkISize::Make(400, 301), false, false, true, true);
|
|
}
|
|
|
|
// Disable RAW tests for Win32.
|
|
#if defined(SK_CODEC_DECODES_RAW) && (!defined(_WIN32))
|
|
DEF_TEST(Codec_raw, r) {
|
|
check(r, "sample_1mp.dng", SkISize::Make(600, 338), false, false, false);
|
|
check(r, "sample_1mp_rotated.dng", SkISize::Make(600, 338), false, false, false);
|
|
check(r, "dng_with_preview.dng", SkISize::Make(600, 338), true, false, false);
|
|
}
|
|
#endif
|
|
|
|
static void test_invalid_stream(skiatest::Reporter* r, const void* stream, size_t len) {
|
|
// Neither of these calls should return a codec. Bots should catch us if we leaked anything.
|
|
SkCodec* codec = SkCodec::NewFromStream(new SkMemoryStream(stream, len, false));
|
|
REPORTER_ASSERT(r, !codec);
|
|
|
|
SkAndroidCodec* androidCodec =
|
|
SkAndroidCodec::NewFromStream(new SkMemoryStream(stream, len, false));
|
|
REPORTER_ASSERT(r, !androidCodec);
|
|
}
|
|
|
|
// Ensure that SkCodec::NewFromStream handles freeing the passed in SkStream,
|
|
// even on failure. Test some bad streams.
|
|
DEF_TEST(Codec_leaks, r) {
|
|
// No codec should claim this as their format, so this tests SkCodec::NewFromStream.
|
|
const char nonSupportedStream[] = "hello world";
|
|
// The other strings should look like the beginning of a file type, so we'll call some
|
|
// internal version of NewFromStream, which must also delete the stream on failure.
|
|
const unsigned char emptyPng[] = { 0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a };
|
|
const unsigned char emptyJpeg[] = { 0xFF, 0xD8, 0xFF };
|
|
const char emptyWebp[] = "RIFF1234WEBPVP";
|
|
const char emptyBmp[] = { 'B', 'M' };
|
|
const char emptyIco[] = { '\x00', '\x00', '\x01', '\x00' };
|
|
const char emptyGif[] = "GIFVER";
|
|
|
|
test_invalid_stream(r, nonSupportedStream, sizeof(nonSupportedStream));
|
|
test_invalid_stream(r, emptyPng, sizeof(emptyPng));
|
|
test_invalid_stream(r, emptyJpeg, sizeof(emptyJpeg));
|
|
test_invalid_stream(r, emptyWebp, sizeof(emptyWebp));
|
|
test_invalid_stream(r, emptyBmp, sizeof(emptyBmp));
|
|
test_invalid_stream(r, emptyIco, sizeof(emptyIco));
|
|
test_invalid_stream(r, emptyGif, sizeof(emptyGif));
|
|
}
|
|
|
|
DEF_TEST(Codec_null, r) {
|
|
// Attempting to create an SkCodec or an SkAndroidCodec with null should not
|
|
// crash.
|
|
SkCodec* codec = SkCodec::NewFromStream(nullptr);
|
|
REPORTER_ASSERT(r, !codec);
|
|
|
|
SkAndroidCodec* androidCodec = SkAndroidCodec::NewFromStream(nullptr);
|
|
REPORTER_ASSERT(r, !androidCodec);
|
|
}
|
|
|
|
static void test_dimensions(skiatest::Reporter* r, const char path[]) {
|
|
// Create the codec from the resource file
|
|
std::unique_ptr<SkStream> stream(GetResourceAsStream(path));
|
|
if (!stream) {
|
|
return;
|
|
}
|
|
std::unique_ptr<SkAndroidCodec> codec(SkAndroidCodec::NewFromStream(stream.release()));
|
|
if (!codec) {
|
|
ERRORF(r, "Unable to create codec '%s'", path);
|
|
return;
|
|
}
|
|
|
|
// Check that the decode is successful for a variety of scales
|
|
for (int sampleSize = 1; sampleSize < 32; sampleSize++) {
|
|
// Scale the output dimensions
|
|
SkISize scaledDims = codec->getSampledDimensions(sampleSize);
|
|
SkImageInfo scaledInfo = codec->getInfo()
|
|
.makeWH(scaledDims.width(), scaledDims.height())
|
|
.makeColorType(kN32_SkColorType);
|
|
|
|
// Set up for the decode
|
|
size_t rowBytes = scaledDims.width() * sizeof(SkPMColor);
|
|
size_t totalBytes = scaledInfo.getSafeSize(rowBytes);
|
|
SkAutoTMalloc<SkPMColor> pixels(totalBytes);
|
|
|
|
SkAndroidCodec::AndroidOptions options;
|
|
options.fSampleSize = sampleSize;
|
|
SkCodec::Result result =
|
|
codec->getAndroidPixels(scaledInfo, pixels.get(), rowBytes, &options);
|
|
REPORTER_ASSERT(r, SkCodec::kSuccess == result);
|
|
}
|
|
}
|
|
|
|
// Ensure that onGetScaledDimensions returns valid image dimensions to use for decodes
|
|
DEF_TEST(Codec_Dimensions, r) {
|
|
// JPG
|
|
test_dimensions(r, "CMYK.jpg");
|
|
test_dimensions(r, "color_wheel.jpg");
|
|
test_dimensions(r, "grayscale.jpg");
|
|
test_dimensions(r, "mandrill_512_q075.jpg");
|
|
test_dimensions(r, "randPixels.jpg");
|
|
|
|
// Decoding small images with very large scaling factors is a potential
|
|
// source of bugs and crashes. We disable these tests in Gold because
|
|
// tiny images are not very useful to look at.
|
|
// Here we make sure that we do not crash or access illegal memory when
|
|
// performing scaled decodes on small images.
|
|
test_dimensions(r, "1x1.png");
|
|
test_dimensions(r, "2x2.png");
|
|
test_dimensions(r, "3x3.png");
|
|
test_dimensions(r, "3x1.png");
|
|
test_dimensions(r, "1x1.png");
|
|
test_dimensions(r, "16x1.png");
|
|
test_dimensions(r, "1x16.png");
|
|
test_dimensions(r, "mandrill_16.png");
|
|
|
|
// RAW
|
|
// Disable RAW tests for Win32.
|
|
#if defined(SK_CODEC_DECODES_RAW) && (!defined(_WIN32))
|
|
test_dimensions(r, "sample_1mp.dng");
|
|
test_dimensions(r, "sample_1mp_rotated.dng");
|
|
test_dimensions(r, "dng_with_preview.dng");
|
|
#endif
|
|
}
|
|
|
|
static void test_invalid(skiatest::Reporter* r, const char path[]) {
|
|
std::unique_ptr<SkStream> stream(GetResourceAsStream(path));
|
|
if (!stream) {
|
|
return;
|
|
}
|
|
std::unique_ptr<SkCodec> codec(SkCodec::NewFromStream(stream.release()));
|
|
REPORTER_ASSERT(r, nullptr == codec);
|
|
}
|
|
|
|
DEF_TEST(Codec_Empty, r) {
|
|
// Test images that should not be able to create a codec
|
|
test_invalid(r, "empty_images/zero-dims.gif");
|
|
test_invalid(r, "empty_images/zero-embedded.ico");
|
|
test_invalid(r, "empty_images/zero-width.bmp");
|
|
test_invalid(r, "empty_images/zero-height.bmp");
|
|
test_invalid(r, "empty_images/zero-width.jpg");
|
|
test_invalid(r, "empty_images/zero-height.jpg");
|
|
test_invalid(r, "empty_images/zero-width.png");
|
|
test_invalid(r, "empty_images/zero-height.png");
|
|
test_invalid(r, "empty_images/zero-width.wbmp");
|
|
test_invalid(r, "empty_images/zero-height.wbmp");
|
|
// This image is an ico with an embedded mask-bmp. This is illegal.
|
|
test_invalid(r, "invalid_images/mask-bmp-ico.ico");
|
|
// It is illegal for a webp frame to not be fully contained by the canvas.
|
|
test_invalid(r, "invalid_images/invalid-offset.webp");
|
|
#if defined(SK_CODEC_DECODES_RAW) && (!defined(_WIN32))
|
|
test_invalid(r, "empty_images/zero_height.tiff");
|
|
#endif
|
|
}
|
|
|
|
static void test_invalid_parameters(skiatest::Reporter* r, const char path[]) {
|
|
std::unique_ptr<SkStream> stream(GetResourceAsStream(path));
|
|
if (!stream) {
|
|
return;
|
|
}
|
|
std::unique_ptr<SkCodec> decoder(SkCodec::NewFromStream(stream.release()));
|
|
if (!decoder) {
|
|
SkDebugf("Missing codec for %s\n", path);
|
|
return;
|
|
}
|
|
|
|
const SkImageInfo info = decoder->getInfo().makeColorType(kIndex_8_SkColorType);
|
|
|
|
// This should return kSuccess because kIndex8 is supported.
|
|
SkPMColor colorStorage[256];
|
|
int colorCount;
|
|
SkCodec::Result result = decoder->startScanlineDecode(info, nullptr, colorStorage,
|
|
&colorCount);
|
|
if (SkCodec::kSuccess == result) {
|
|
// This should return kInvalidParameters because, in kIndex_8 mode, we must pass in a valid
|
|
// colorPtr and a valid colorCountPtr.
|
|
result = decoder->startScanlineDecode(info, nullptr, nullptr, nullptr);
|
|
REPORTER_ASSERT(r, SkCodec::kInvalidParameters == result);
|
|
result = decoder->startScanlineDecode(info);
|
|
REPORTER_ASSERT(r, SkCodec::kInvalidParameters == result);
|
|
} else if (SkCodec::kUnimplemented == result) {
|
|
// New method should be supported:
|
|
SkBitmap bm;
|
|
bm.allocPixels(info, SkColorTable::Make(colorStorage, 256));
|
|
result = decoder->startIncrementalDecode(info, bm.getPixels(), bm.rowBytes(), nullptr,
|
|
colorStorage, &colorCount);
|
|
REPORTER_ASSERT(r, SkCodec::kSuccess == result);
|
|
result = decoder->startIncrementalDecode(info, bm.getPixels(), bm.rowBytes());
|
|
REPORTER_ASSERT(r, SkCodec::kInvalidParameters == result);
|
|
} else {
|
|
// The test is uninteresting if kIndex8 is not supported
|
|
ERRORF(r, "Should not call test_invalid_parameters for non-Index8 file: %s\n", path);
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
DEF_TEST(Codec_Params, r) {
|
|
test_invalid_parameters(r, "index8.png");
|
|
test_invalid_parameters(r, "mandrill.wbmp");
|
|
}
|
|
|
|
#ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
|
|
|
|
#ifndef SK_PNG_DISABLE_TESTS // reading chunks does not work properly with older versions.
|
|
// It does not appear that anyone in Google3 is reading chunks.
|
|
|
|
static void codex_test_write_fn(png_structp png_ptr, png_bytep data, png_size_t len) {
|
|
SkWStream* sk_stream = (SkWStream*)png_get_io_ptr(png_ptr);
|
|
if (!sk_stream->write(data, len)) {
|
|
png_error(png_ptr, "sk_write_fn Error!");
|
|
}
|
|
}
|
|
|
|
DEF_TEST(Codec_pngChunkReader, r) {
|
|
// Create a dummy bitmap. Use unpremul RGBA for libpng.
|
|
SkBitmap bm;
|
|
const int w = 1;
|
|
const int h = 1;
|
|
const SkImageInfo bmInfo = SkImageInfo::Make(w, h, kRGBA_8888_SkColorType,
|
|
kUnpremul_SkAlphaType);
|
|
bm.setInfo(bmInfo);
|
|
bm.allocPixels();
|
|
bm.eraseColor(SK_ColorBLUE);
|
|
SkMD5::Digest goodDigest;
|
|
md5(bm, &goodDigest);
|
|
|
|
// Write to a png file.
|
|
png_structp png = png_create_write_struct(PNG_LIBPNG_VER_STRING, nullptr, nullptr, nullptr);
|
|
REPORTER_ASSERT(r, png);
|
|
if (!png) {
|
|
return;
|
|
}
|
|
|
|
png_infop info = png_create_info_struct(png);
|
|
REPORTER_ASSERT(r, info);
|
|
if (!info) {
|
|
png_destroy_write_struct(&png, nullptr);
|
|
return;
|
|
}
|
|
|
|
if (setjmp(png_jmpbuf(png))) {
|
|
ERRORF(r, "failed writing png");
|
|
png_destroy_write_struct(&png, &info);
|
|
return;
|
|
}
|
|
|
|
SkDynamicMemoryWStream wStream;
|
|
png_set_write_fn(png, (void*) (&wStream), codex_test_write_fn, nullptr);
|
|
|
|
png_set_IHDR(png, info, (png_uint_32)w, (png_uint_32)h, 8,
|
|
PNG_COLOR_TYPE_RGB_ALPHA, PNG_INTERLACE_NONE,
|
|
PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
|
|
|
|
// Create some chunks that match the Android framework's use.
|
|
static png_unknown_chunk gUnknowns[] = {
|
|
{ "npOl", (png_byte*)"outline", sizeof("outline"), PNG_HAVE_IHDR },
|
|
{ "npLb", (png_byte*)"layoutBounds", sizeof("layoutBounds"), PNG_HAVE_IHDR },
|
|
{ "npTc", (png_byte*)"ninePatchData", sizeof("ninePatchData"), PNG_HAVE_IHDR },
|
|
};
|
|
|
|
png_set_keep_unknown_chunks(png, PNG_HANDLE_CHUNK_ALWAYS, (png_byte*)"npOl\0npLb\0npTc\0", 3);
|
|
png_set_unknown_chunks(png, info, gUnknowns, SK_ARRAY_COUNT(gUnknowns));
|
|
#if PNG_LIBPNG_VER < 10600
|
|
/* Deal with unknown chunk location bug in 1.5.x and earlier */
|
|
png_set_unknown_chunk_location(png, info, 0, PNG_HAVE_IHDR);
|
|
png_set_unknown_chunk_location(png, info, 1, PNG_HAVE_IHDR);
|
|
#endif
|
|
|
|
png_write_info(png, info);
|
|
|
|
for (int j = 0; j < h; j++) {
|
|
png_bytep row = (png_bytep)(bm.getAddr(0, j));
|
|
png_write_rows(png, &row, 1);
|
|
}
|
|
png_write_end(png, info);
|
|
png_destroy_write_struct(&png, &info);
|
|
|
|
class ChunkReader : public SkPngChunkReader {
|
|
public:
|
|
ChunkReader(skiatest::Reporter* r)
|
|
: fReporter(r)
|
|
{
|
|
this->reset();
|
|
}
|
|
|
|
bool readChunk(const char tag[], const void* data, size_t length) override {
|
|
for (size_t i = 0; i < SK_ARRAY_COUNT(gUnknowns); ++i) {
|
|
if (!strcmp(tag, (const char*) gUnknowns[i].name)) {
|
|
// Tag matches. This should have been the first time we see it.
|
|
REPORTER_ASSERT(fReporter, !fSeen[i]);
|
|
fSeen[i] = true;
|
|
|
|
// Data and length should match
|
|
REPORTER_ASSERT(fReporter, length == gUnknowns[i].size);
|
|
REPORTER_ASSERT(fReporter, !strcmp((const char*) data,
|
|
(const char*) gUnknowns[i].data));
|
|
return true;
|
|
}
|
|
}
|
|
ERRORF(fReporter, "Saw an unexpected unknown chunk.");
|
|
return true;
|
|
}
|
|
|
|
bool allHaveBeenSeen() {
|
|
bool ret = true;
|
|
for (auto seen : fSeen) {
|
|
ret &= seen;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
void reset() {
|
|
sk_bzero(fSeen, sizeof(fSeen));
|
|
}
|
|
|
|
private:
|
|
skiatest::Reporter* fReporter; // Unowned
|
|
bool fSeen[3];
|
|
};
|
|
|
|
ChunkReader chunkReader(r);
|
|
|
|
// Now read the file with SkCodec.
|
|
std::unique_ptr<SkCodec> codec(SkCodec::NewFromData(wStream.detachAsData(), &chunkReader));
|
|
REPORTER_ASSERT(r, codec);
|
|
if (!codec) {
|
|
return;
|
|
}
|
|
|
|
// Now compare to the original.
|
|
SkBitmap decodedBm;
|
|
decodedBm.setInfo(codec->getInfo());
|
|
decodedBm.allocPixels();
|
|
SkCodec::Result result = codec->getPixels(codec->getInfo(), decodedBm.getPixels(),
|
|
decodedBm.rowBytes());
|
|
REPORTER_ASSERT(r, SkCodec::kSuccess == result);
|
|
|
|
if (decodedBm.colorType() != bm.colorType()) {
|
|
SkBitmap tmp;
|
|
bool success = sk_tool_utils::copy_to(&tmp, bm.colorType(), decodedBm);
|
|
REPORTER_ASSERT(r, success);
|
|
if (!success) {
|
|
return;
|
|
}
|
|
|
|
tmp.swap(decodedBm);
|
|
}
|
|
|
|
compare_to_good_digest(r, goodDigest, decodedBm);
|
|
REPORTER_ASSERT(r, chunkReader.allHaveBeenSeen());
|
|
|
|
// Decoding again will read the chunks again.
|
|
chunkReader.reset();
|
|
REPORTER_ASSERT(r, !chunkReader.allHaveBeenSeen());
|
|
result = codec->getPixels(codec->getInfo(), decodedBm.getPixels(), decodedBm.rowBytes());
|
|
REPORTER_ASSERT(r, SkCodec::kSuccess == result);
|
|
REPORTER_ASSERT(r, chunkReader.allHaveBeenSeen());
|
|
}
|
|
#endif // SK_PNG_DISABLE_TESTS
|
|
#endif // PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
|
|
|
|
// Stream that can only peek up to a limit
|
|
class LimitedPeekingMemStream : public SkStream {
|
|
public:
|
|
LimitedPeekingMemStream(sk_sp<SkData> data, size_t limit)
|
|
: fStream(std::move(data))
|
|
, fLimit(limit) {}
|
|
|
|
size_t peek(void* buf, size_t bytes) const override {
|
|
return fStream.peek(buf, SkTMin(bytes, fLimit));
|
|
}
|
|
size_t read(void* buf, size_t bytes) override {
|
|
return fStream.read(buf, bytes);
|
|
}
|
|
bool rewind() override {
|
|
return fStream.rewind();
|
|
}
|
|
bool isAtEnd() const override {
|
|
return fStream.isAtEnd();
|
|
}
|
|
private:
|
|
SkMemoryStream fStream;
|
|
const size_t fLimit;
|
|
};
|
|
|
|
// Disable RAW tests for Win32.
|
|
#if defined(SK_CODEC_DECODES_RAW) && (!defined(_WIN32))
|
|
// Test that the RawCodec works also for not asset stream. This will test the code path using
|
|
// SkRawBufferedStream instead of SkRawAssetStream.
|
|
DEF_TEST(Codec_raw_notseekable, r) {
|
|
const char* path = "dng_with_preview.dng";
|
|
SkString fullPath(GetResourcePath(path));
|
|
sk_sp<SkData> data(SkData::MakeFromFileName(fullPath.c_str()));
|
|
if (!data) {
|
|
SkDebugf("Missing resource '%s'\n", path);
|
|
return;
|
|
}
|
|
|
|
std::unique_ptr<SkCodec> codec(SkCodec::NewFromStream(new NotAssetMemStream(std::move(data))));
|
|
REPORTER_ASSERT(r, codec);
|
|
|
|
test_info(r, codec.get(), codec->getInfo(), SkCodec::kSuccess, nullptr);
|
|
}
|
|
#endif
|
|
|
|
// Test that even if webp_parse_header fails to peek enough, it will fall back to read()
|
|
// + rewind() and succeed.
|
|
DEF_TEST(Codec_webp_peek, r) {
|
|
const char* path = "baby_tux.webp";
|
|
SkString fullPath(GetResourcePath(path));
|
|
auto data = SkData::MakeFromFileName(fullPath.c_str());
|
|
if (!data) {
|
|
SkDebugf("Missing resource '%s'\n", path);
|
|
return;
|
|
}
|
|
|
|
// The limit is less than webp needs to peek or read.
|
|
std::unique_ptr<SkCodec> codec(SkCodec::NewFromStream(
|
|
new LimitedPeekingMemStream(data, 25)));
|
|
REPORTER_ASSERT(r, codec);
|
|
|
|
test_info(r, codec.get(), codec->getInfo(), SkCodec::kSuccess, nullptr);
|
|
|
|
// Similarly, a stream which does not peek should still succeed.
|
|
codec.reset(SkCodec::NewFromStream(new LimitedPeekingMemStream(data, 0)));
|
|
REPORTER_ASSERT(r, codec);
|
|
|
|
test_info(r, codec.get(), codec->getInfo(), SkCodec::kSuccess, nullptr);
|
|
}
|
|
|
|
// SkCodec's wbmp decoder was initially unnecessarily restrictive.
|
|
// It required the second byte to be zero. The wbmp specification allows
|
|
// a couple of bits to be 1 (so long as they do not overlap with 0x9F).
|
|
// Test that SkCodec now supports an image with these bits set.
|
|
DEF_TEST(Codec_wbmp_restrictive, r) {
|
|
const char* path = "mandrill.wbmp";
|
|
std::unique_ptr<SkStream> stream(GetResourceAsStream(path));
|
|
if (!stream) {
|
|
return;
|
|
}
|
|
|
|
// Modify the stream to contain a second byte with some bits set.
|
|
auto data = SkCopyStreamToData(stream.get());
|
|
uint8_t* writeableData = static_cast<uint8_t*>(data->writable_data());
|
|
writeableData[1] = static_cast<uint8_t>(~0x9F);
|
|
|
|
// SkCodec should support this.
|
|
std::unique_ptr<SkCodec> codec(SkCodec::NewFromData(data));
|
|
REPORTER_ASSERT(r, codec);
|
|
if (!codec) {
|
|
return;
|
|
}
|
|
test_info(r, codec.get(), codec->getInfo(), SkCodec::kSuccess, nullptr);
|
|
}
|
|
|
|
// wbmp images have a header that can be arbitrarily large, depending on the
|
|
// size of the image. We cap the size at 65535, meaning we only need to look at
|
|
// 8 bytes to determine whether we can read the image. This is important
|
|
// because SkCodec only passes 14 bytes to SkWbmpCodec to determine whether the
|
|
// image is a wbmp.
|
|
DEF_TEST(Codec_wbmp_max_size, r) {
|
|
const unsigned char maxSizeWbmp[] = { 0x00, 0x00, // Header
|
|
0x83, 0xFF, 0x7F, // W: 65535
|
|
0x83, 0xFF, 0x7F }; // H: 65535
|
|
std::unique_ptr<SkStream> stream(new SkMemoryStream(maxSizeWbmp, sizeof(maxSizeWbmp), false));
|
|
std::unique_ptr<SkCodec> codec(SkCodec::NewFromStream(stream.release()));
|
|
|
|
REPORTER_ASSERT(r, codec);
|
|
if (!codec) return;
|
|
|
|
REPORTER_ASSERT(r, codec->getInfo().width() == 65535);
|
|
REPORTER_ASSERT(r, codec->getInfo().height() == 65535);
|
|
|
|
// Now test an image which is too big. Any image with a larger header (i.e.
|
|
// has bigger width/height) is also too big.
|
|
const unsigned char tooBigWbmp[] = { 0x00, 0x00, // Header
|
|
0x84, 0x80, 0x00, // W: 65536
|
|
0x84, 0x80, 0x00 }; // H: 65536
|
|
stream.reset(new SkMemoryStream(tooBigWbmp, sizeof(tooBigWbmp), false));
|
|
codec.reset(SkCodec::NewFromStream(stream.release()));
|
|
|
|
REPORTER_ASSERT(r, !codec);
|
|
}
|
|
|
|
DEF_TEST(Codec_jpeg_rewind, r) {
|
|
const char* path = "mandrill_512_q075.jpg";
|
|
sk_sp<SkData> data(GetResourceAsData(path));
|
|
if (!data) {
|
|
return;
|
|
}
|
|
|
|
data = SkData::MakeSubset(data.get(), 0, data->size() / 2);
|
|
std::unique_ptr<SkAndroidCodec> codec(SkAndroidCodec::NewFromData(data));
|
|
if (!codec) {
|
|
ERRORF(r, "Unable to create codec '%s'.", path);
|
|
return;
|
|
}
|
|
|
|
const int width = codec->getInfo().width();
|
|
const int height = codec->getInfo().height();
|
|
size_t rowBytes = sizeof(SkPMColor) * width;
|
|
SkAutoMalloc pixelStorage(height * rowBytes);
|
|
|
|
// Perform a sampled decode.
|
|
SkAndroidCodec::AndroidOptions opts;
|
|
opts.fSampleSize = 12;
|
|
auto sampledInfo = codec->getInfo().makeWH(width / 12, height / 12);
|
|
auto result = codec->getAndroidPixels(sampledInfo, pixelStorage.get(), rowBytes, &opts);
|
|
REPORTER_ASSERT(r, SkCodec::kIncompleteInput == result);
|
|
|
|
// Rewind the codec and perform a full image decode.
|
|
result = codec->getPixels(codec->getInfo(), pixelStorage.get(), rowBytes);
|
|
REPORTER_ASSERT(r, SkCodec::kIncompleteInput == result);
|
|
|
|
// Now perform a subset decode.
|
|
{
|
|
opts.fSampleSize = 1;
|
|
SkIRect subset = SkIRect::MakeWH(100, 100);
|
|
opts.fSubset = ⊂
|
|
result = codec->getAndroidPixels(codec->getInfo().makeWH(100, 100), pixelStorage.get(),
|
|
rowBytes, &opts);
|
|
// Though we only have half the data, it is enough to decode this subset.
|
|
REPORTER_ASSERT(r, SkCodec::kSuccess == result);
|
|
}
|
|
|
|
// Perform another full image decode. ASAN will detect if we look at the subset when it is
|
|
// out of scope. This would happen if we depend on the old state in the codec.
|
|
// This tests two layers of bugs: both SkJpegCodec::readRows and SkCodec::fillIncompleteImage
|
|
// used to look at the old subset.
|
|
opts.fSubset = nullptr;
|
|
result = codec->getAndroidPixels(codec->getInfo(), pixelStorage.get(), rowBytes, &opts);
|
|
REPORTER_ASSERT(r, SkCodec::kIncompleteInput == result);
|
|
}
|
|
|
|
static void check_color_xform(skiatest::Reporter* r, const char* path) {
|
|
std::unique_ptr<SkAndroidCodec> codec(SkAndroidCodec::NewFromStream(GetResourceAsStream(path)));
|
|
|
|
SkAndroidCodec::AndroidOptions opts;
|
|
opts.fSampleSize = 3;
|
|
const int subsetWidth = codec->getInfo().width() / 2;
|
|
const int subsetHeight = codec->getInfo().height() / 2;
|
|
SkIRect subset = SkIRect::MakeWH(subsetWidth, subsetHeight);
|
|
opts.fSubset = ⊂
|
|
|
|
const int dstWidth = subsetWidth / opts.fSampleSize;
|
|
const int dstHeight = subsetHeight / opts.fSampleSize;
|
|
sk_sp<SkData> data = SkData::MakeFromFileName(
|
|
GetResourcePath("icc_profiles/HP_ZR30w.icc").c_str());
|
|
sk_sp<SkColorSpace> colorSpace = SkColorSpace::MakeICC(data->data(), data->size());
|
|
SkImageInfo dstInfo = codec->getInfo().makeWH(dstWidth, dstHeight)
|
|
.makeColorType(kN32_SkColorType)
|
|
.makeColorSpace(colorSpace);
|
|
|
|
size_t rowBytes = dstInfo.minRowBytes();
|
|
SkAutoMalloc pixelStorage(dstInfo.getSafeSize(rowBytes));
|
|
SkCodec::Result result = codec->getAndroidPixels(dstInfo, pixelStorage.get(), rowBytes, &opts);
|
|
REPORTER_ASSERT(r, SkCodec::kSuccess == result);
|
|
}
|
|
|
|
DEF_TEST(Codec_ColorXform, r) {
|
|
check_color_xform(r, "mandrill_512_q075.jpg");
|
|
check_color_xform(r, "mandrill_512.png");
|
|
}
|
|
|
|
static bool color_type_match(SkColorType origColorType, SkColorType codecColorType) {
|
|
switch (origColorType) {
|
|
case kRGBA_8888_SkColorType:
|
|
case kBGRA_8888_SkColorType:
|
|
return kRGBA_8888_SkColorType == codecColorType ||
|
|
kBGRA_8888_SkColorType == codecColorType;
|
|
default:
|
|
return origColorType == codecColorType;
|
|
}
|
|
}
|
|
|
|
static bool alpha_type_match(SkAlphaType origAlphaType, SkAlphaType codecAlphaType) {
|
|
switch (origAlphaType) {
|
|
case kUnpremul_SkAlphaType:
|
|
case kPremul_SkAlphaType:
|
|
return kUnpremul_SkAlphaType == codecAlphaType ||
|
|
kPremul_SkAlphaType == codecAlphaType;
|
|
default:
|
|
return origAlphaType == codecAlphaType;
|
|
}
|
|
}
|
|
|
|
static void check_round_trip(skiatest::Reporter* r, SkCodec* origCodec, const SkImageInfo& info) {
|
|
SkBitmap bm1;
|
|
SkPMColor colors[256];
|
|
sk_sp<SkColorTable> colorTable1 = SkColorTable::Make(colors, 256);
|
|
bm1.allocPixels(info, colorTable1);
|
|
int numColors;
|
|
SkCodec::Result result = origCodec->getPixels(info, bm1.getPixels(), bm1.rowBytes(), nullptr,
|
|
const_cast<SkPMColor*>(colorTable1->readColors()),
|
|
&numColors);
|
|
// This will fail to update colorTable1->count() but is fine for the purpose of this test.
|
|
REPORTER_ASSERT(r, SkCodec::kSuccess == result);
|
|
|
|
// Encode the image to png.
|
|
sk_sp<SkData> data =
|
|
sk_sp<SkData>(sk_tool_utils::EncodeImageToData(bm1, SkEncodedImageFormat::kPNG, 100));
|
|
|
|
std::unique_ptr<SkCodec> codec(SkCodec::NewFromData(data));
|
|
REPORTER_ASSERT(r, color_type_match(info.colorType(), codec->getInfo().colorType()));
|
|
REPORTER_ASSERT(r, alpha_type_match(info.alphaType(), codec->getInfo().alphaType()));
|
|
|
|
SkBitmap bm2;
|
|
sk_sp<SkColorTable> colorTable2 = SkColorTable::Make(colors, 256);
|
|
bm2.allocPixels(info, colorTable2);
|
|
result = codec->getPixels(info, bm2.getPixels(), bm2.rowBytes(), nullptr,
|
|
const_cast<SkPMColor*>(colorTable2->readColors()), &numColors);
|
|
REPORTER_ASSERT(r, SkCodec::kSuccess == result);
|
|
|
|
SkMD5::Digest d1, d2;
|
|
md5(bm1, &d1);
|
|
md5(bm2, &d2);
|
|
REPORTER_ASSERT(r, d1 == d2);
|
|
}
|
|
|
|
DEF_TEST(Codec_PngRoundTrip, r) {
|
|
const char* path = "mandrill_512_q075.jpg";
|
|
std::unique_ptr<SkStream> stream(GetResourceAsStream(path));
|
|
std::unique_ptr<SkCodec> codec(SkCodec::NewFromStream(stream.release()));
|
|
|
|
SkColorType colorTypesOpaque[] = {
|
|
kRGB_565_SkColorType, kRGBA_8888_SkColorType, kBGRA_8888_SkColorType
|
|
};
|
|
for (SkColorType colorType : colorTypesOpaque) {
|
|
SkImageInfo newInfo = codec->getInfo().makeColorType(colorType);
|
|
check_round_trip(r, codec.get(), newInfo);
|
|
}
|
|
|
|
path = "grayscale.jpg";
|
|
stream.reset(GetResourceAsStream(path));
|
|
codec.reset(SkCodec::NewFromStream(stream.release()));
|
|
check_round_trip(r, codec.get(), codec->getInfo());
|
|
|
|
path = "yellow_rose.png";
|
|
stream.reset(GetResourceAsStream(path));
|
|
codec.reset(SkCodec::NewFromStream(stream.release()));
|
|
|
|
SkColorType colorTypesWithAlpha[] = {
|
|
kRGBA_8888_SkColorType, kBGRA_8888_SkColorType
|
|
};
|
|
SkAlphaType alphaTypes[] = {
|
|
kUnpremul_SkAlphaType, kPremul_SkAlphaType
|
|
};
|
|
for (SkColorType colorType : colorTypesWithAlpha) {
|
|
for (SkAlphaType alphaType : alphaTypes) {
|
|
// Set color space to nullptr because color correct premultiplies do not round trip.
|
|
SkImageInfo newInfo = codec->getInfo().makeColorType(colorType)
|
|
.makeAlphaType(alphaType)
|
|
.makeColorSpace(nullptr);
|
|
check_round_trip(r, codec.get(), newInfo);
|
|
}
|
|
}
|
|
|
|
path = "index8.png";
|
|
stream.reset(GetResourceAsStream(path));
|
|
codec.reset(SkCodec::NewFromStream(stream.release()));
|
|
|
|
for (SkAlphaType alphaType : alphaTypes) {
|
|
SkImageInfo newInfo = codec->getInfo().makeAlphaType(alphaType)
|
|
.makeColorSpace(nullptr);
|
|
check_round_trip(r, codec.get(), newInfo);
|
|
}
|
|
}
|
|
|
|
static void test_conversion_possible(skiatest::Reporter* r, const char* path,
|
|
bool supportsScanlineDecoder,
|
|
bool supportsIncrementalDecoder) {
|
|
std::unique_ptr<SkStream> stream(GetResourceAsStream(path));
|
|
if (!stream) {
|
|
return;
|
|
}
|
|
|
|
std::unique_ptr<SkCodec> codec(SkCodec::NewFromStream(stream.release()));
|
|
if (!codec) {
|
|
ERRORF(r, "failed to create a codec for %s", path);
|
|
return;
|
|
}
|
|
|
|
SkImageInfo infoF16 = codec->getInfo().makeColorType(kRGBA_F16_SkColorType);
|
|
|
|
SkBitmap bm;
|
|
bm.allocPixels(infoF16);
|
|
SkCodec::Result result = codec->getPixels(infoF16, bm.getPixels(), bm.rowBytes());
|
|
REPORTER_ASSERT(r, SkCodec::kInvalidConversion == result);
|
|
|
|
result = codec->startScanlineDecode(infoF16);
|
|
if (supportsScanlineDecoder) {
|
|
REPORTER_ASSERT(r, SkCodec::kInvalidConversion == result);
|
|
} else {
|
|
REPORTER_ASSERT(r, SkCodec::kUnimplemented == result);
|
|
}
|
|
|
|
result = codec->startIncrementalDecode(infoF16, bm.getPixels(), bm.rowBytes());
|
|
if (supportsIncrementalDecoder) {
|
|
REPORTER_ASSERT(r, SkCodec::kInvalidConversion == result);
|
|
} else {
|
|
REPORTER_ASSERT(r, SkCodec::kUnimplemented == result);
|
|
}
|
|
|
|
SkASSERT(SkColorSpace_Base::Type::kXYZ == as_CSB(infoF16.colorSpace())->type());
|
|
SkColorSpace_XYZ* csXYZ = static_cast<SkColorSpace_XYZ*>(infoF16.colorSpace());
|
|
infoF16 = infoF16.makeColorSpace(csXYZ->makeLinearGamma());
|
|
result = codec->getPixels(infoF16, bm.getPixels(), bm.rowBytes());
|
|
REPORTER_ASSERT(r, SkCodec::kSuccess == result);
|
|
result = codec->startScanlineDecode(infoF16);
|
|
if (supportsScanlineDecoder) {
|
|
REPORTER_ASSERT(r, SkCodec::kSuccess == result);
|
|
} else {
|
|
REPORTER_ASSERT(r, SkCodec::kUnimplemented == result);
|
|
}
|
|
|
|
result = codec->startIncrementalDecode(infoF16, bm.getPixels(), bm.rowBytes());
|
|
if (supportsIncrementalDecoder) {
|
|
REPORTER_ASSERT(r, SkCodec::kSuccess == result);
|
|
} else {
|
|
REPORTER_ASSERT(r, SkCodec::kUnimplemented == result);
|
|
}
|
|
}
|
|
|
|
DEF_TEST(Codec_F16ConversionPossible, r) {
|
|
test_conversion_possible(r, "color_wheel.webp", false, false);
|
|
test_conversion_possible(r, "mandrill_512_q075.jpg", true, false);
|
|
test_conversion_possible(r, "yellow_rose.png", false, true);
|
|
}
|
|
|
|
static void decode_frame(skiatest::Reporter* r, SkCodec* codec, size_t frame) {
|
|
SkBitmap bm;
|
|
auto info = codec->getInfo().makeColorType(kN32_SkColorType);
|
|
bm.allocPixels(info);
|
|
|
|
SkCodec::Options opts;
|
|
opts.fFrameIndex = frame;
|
|
REPORTER_ASSERT(r, SkCodec::kSuccess == codec->getPixels(info,
|
|
bm.getPixels(), bm.rowBytes(), &opts, nullptr, nullptr));
|
|
}
|
|
|
|
// For an animated image, we should only read enough to decode the requested
|
|
// frame if the client never calls getFrameInfo.
|
|
DEF_TEST(Codec_skipFullParse, r) {
|
|
auto path = "test640x479.gif";
|
|
SkStream* stream(GetResourceAsStream(path));
|
|
if (!stream) {
|
|
return;
|
|
}
|
|
|
|
// Note that we cheat and hold on to the stream pointer, but SkCodec will
|
|
// take ownership. We will not refer to the stream after the SkCodec
|
|
// deletes it.
|
|
std::unique_ptr<SkCodec> codec(SkCodec::NewFromStream(stream));
|
|
if (!codec) {
|
|
ERRORF(r, "Failed to create codec for %s", path);
|
|
return;
|
|
}
|
|
|
|
REPORTER_ASSERT(r, stream->hasPosition());
|
|
const size_t sizePosition = stream->getPosition();
|
|
REPORTER_ASSERT(r, stream->hasLength() && sizePosition < stream->getLength());
|
|
|
|
// This should read more of the stream, but not the whole stream.
|
|
decode_frame(r, codec.get(), 0);
|
|
const size_t positionAfterFirstFrame = stream->getPosition();
|
|
REPORTER_ASSERT(r, positionAfterFirstFrame > sizePosition
|
|
&& positionAfterFirstFrame < stream->getLength());
|
|
|
|
// Again, this should read more of the stream.
|
|
decode_frame(r, codec.get(), 2);
|
|
const size_t positionAfterThirdFrame = stream->getPosition();
|
|
REPORTER_ASSERT(r, positionAfterThirdFrame > positionAfterFirstFrame
|
|
&& positionAfterThirdFrame < stream->getLength());
|
|
|
|
// This does not need to read any more of the stream, since it has already
|
|
// parsed the second frame.
|
|
decode_frame(r, codec.get(), 1);
|
|
REPORTER_ASSERT(r, stream->getPosition() == positionAfterThirdFrame);
|
|
|
|
// This should read the rest of the frames.
|
|
decode_frame(r, codec.get(), 3);
|
|
const size_t finalPosition = stream->getPosition();
|
|
REPORTER_ASSERT(r, finalPosition > positionAfterThirdFrame);
|
|
|
|
// There may be more data in the stream.
|
|
auto frameInfo = codec->getFrameInfo();
|
|
REPORTER_ASSERT(r, frameInfo.size() == 4);
|
|
REPORTER_ASSERT(r, stream->getPosition() >= finalPosition);
|
|
}
|
|
|
|
// Only rewinds up to a limit.
|
|
class LimitedRewindingStream : public SkStream {
|
|
public:
|
|
static SkStream* Make(const char path[], size_t limit) {
|
|
SkStream* stream = GetResourceAsStream(path);
|
|
if (!stream) {
|
|
return nullptr;
|
|
}
|
|
return new LimitedRewindingStream(stream, limit);
|
|
}
|
|
|
|
size_t read(void* buffer, size_t size) override {
|
|
const size_t bytes = fStream->read(buffer, size);
|
|
fPosition += bytes;
|
|
return bytes;
|
|
}
|
|
|
|
bool isAtEnd() const override {
|
|
return fStream->isAtEnd();
|
|
}
|
|
|
|
bool rewind() override {
|
|
if (fPosition <= fLimit && fStream->rewind()) {
|
|
fPosition = 0;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private:
|
|
std::unique_ptr<SkStream> fStream;
|
|
const size_t fLimit;
|
|
size_t fPosition;
|
|
|
|
LimitedRewindingStream(SkStream* stream, size_t limit)
|
|
: fStream(stream)
|
|
, fLimit(limit)
|
|
, fPosition(0)
|
|
{
|
|
SkASSERT(fStream);
|
|
}
|
|
};
|
|
|
|
DEF_TEST(Codec_fallBack, r) {
|
|
// SkAndroidCodec needs to be able to fall back to scanline decoding
|
|
// if incremental decoding does not work. Make sure this does not
|
|
// require a rewind.
|
|
|
|
// Formats that currently do not support incremental decoding
|
|
auto files = {
|
|
"CMYK.jpg",
|
|
"color_wheel.ico",
|
|
"mandrill.wbmp",
|
|
"randPixels.bmp",
|
|
};
|
|
for (auto file : files) {
|
|
SkStream* stream = LimitedRewindingStream::Make(file, 14);
|
|
if (!stream) {
|
|
SkDebugf("Missing resources (%s). Set --resourcePath.\n", file);
|
|
return;
|
|
}
|
|
|
|
std::unique_ptr<SkCodec> codec(SkCodec::NewFromStream(stream));
|
|
if (!codec) {
|
|
ERRORF(r, "Failed to create codec for %s,", file);
|
|
continue;
|
|
}
|
|
|
|
SkImageInfo info = codec->getInfo().makeColorType(kN32_SkColorType);
|
|
SkBitmap bm;
|
|
bm.allocPixels(info);
|
|
|
|
if (SkCodec::kUnimplemented != codec->startIncrementalDecode(info, bm.getPixels(),
|
|
bm.rowBytes())) {
|
|
ERRORF(r, "Is scanline decoding now implemented for %s?", file);
|
|
continue;
|
|
}
|
|
|
|
// Scanline decoding should not require a rewind.
|
|
SkCodec::Result result = codec->startScanlineDecode(info);
|
|
if (SkCodec::kSuccess != result) {
|
|
ERRORF(r, "Scanline decoding failed for %s with %i", file, result);
|
|
}
|
|
}
|
|
}
|
|
|
|
// This test verifies that we fixed an assert statement that fired when reusing a png codec
|
|
// after scaling.
|
|
DEF_TEST(Codec_reusePng, r) {
|
|
std::unique_ptr<SkStream> stream(GetResourceAsStream("plane.png"));
|
|
if (!stream) {
|
|
return;
|
|
}
|
|
|
|
std::unique_ptr<SkAndroidCodec> codec(SkAndroidCodec::NewFromStream(stream.release()));
|
|
if (!codec) {
|
|
ERRORF(r, "Failed to create codec\n");
|
|
return;
|
|
}
|
|
|
|
SkAndroidCodec::AndroidOptions opts;
|
|
opts.fSampleSize = 5;
|
|
auto size = codec->getSampledDimensions(opts.fSampleSize);
|
|
auto info = codec->getInfo().makeWH(size.fWidth, size.fHeight).makeColorType(kN32_SkColorType);
|
|
SkBitmap bm;
|
|
bm.allocPixels(info);
|
|
auto result = codec->getAndroidPixels(info, bm.getPixels(), bm.rowBytes(), &opts);
|
|
REPORTER_ASSERT(r, result == SkCodec::kSuccess);
|
|
|
|
info = codec->getInfo().makeColorType(kN32_SkColorType);
|
|
bm.allocPixels(info);
|
|
opts.fSampleSize = 1;
|
|
result = codec->getAndroidPixels(info, bm.getPixels(), bm.rowBytes(), &opts);
|
|
REPORTER_ASSERT(r, result == SkCodec::kSuccess);
|
|
}
|
|
|
|
DEF_TEST(Codec_rowsDecoded, r) {
|
|
auto file = "plane_interlaced.png";
|
|
std::unique_ptr<SkStream> stream(GetResourceAsStream(file));
|
|
if (!stream) {
|
|
return;
|
|
}
|
|
|
|
// This is enough to read the header etc, but no rows.
|
|
auto data = SkData::MakeFromStream(stream.get(), 99);
|
|
std::unique_ptr<SkCodec> codec(SkCodec::NewFromData(data));
|
|
if (!codec) {
|
|
ERRORF(r, "Failed to create codec\n");
|
|
return;
|
|
}
|
|
|
|
auto info = codec->getInfo().makeColorType(kN32_SkColorType);
|
|
SkBitmap bm;
|
|
bm.allocPixels(info);
|
|
auto result = codec->startIncrementalDecode(info, bm.getPixels(), bm.rowBytes());
|
|
REPORTER_ASSERT(r, result == SkCodec::kSuccess);
|
|
|
|
// This is an arbitrary value. The important fact is that it is not zero, and rowsDecoded
|
|
// should get set to zero by incrementalDecode.
|
|
int rowsDecoded = 77;
|
|
result = codec->incrementalDecode(&rowsDecoded);
|
|
REPORTER_ASSERT(r, result == SkCodec::kIncompleteInput);
|
|
REPORTER_ASSERT(r, rowsDecoded == 0);
|
|
}
|
|
|
|
static void test_invalid_images(skiatest::Reporter* r, const char* path,
|
|
SkCodec::Result expectedResult) {
|
|
auto* stream = GetResourceAsStream(path);
|
|
if (!stream) {
|
|
return;
|
|
}
|
|
|
|
std::unique_ptr<SkCodec> codec(SkCodec::NewFromStream(stream));
|
|
REPORTER_ASSERT(r, codec);
|
|
|
|
test_info(r, codec.get(), codec->getInfo().makeColorType(kN32_SkColorType), expectedResult,
|
|
nullptr);
|
|
}
|
|
|
|
DEF_TEST(Codec_InvalidImages, r) {
|
|
// ASAN will complain if there is an issue.
|
|
test_invalid_images(r, "invalid_images/skbug5887.gif", SkCodec::kIncompleteInput);
|
|
test_invalid_images(r, "invalid_images/many-progressive-scans.jpg", SkCodec::kInvalidInput);
|
|
test_invalid_images(r, "invalid_images/b33251605.bmp", SkCodec::kIncompleteInput);
|
|
test_invalid_images(r, "invalid_images/bad_palette.png", SkCodec::kInvalidInput);
|
|
}
|
|
|
|
static void test_invalid_header(skiatest::Reporter* r, const char* path) {
|
|
SkString resourcePath = GetResourcePath(path);
|
|
std::unique_ptr<SkFILEStream> stream(new SkFILEStream(resourcePath.c_str()));
|
|
if (!stream->isValid()) {
|
|
return;
|
|
}
|
|
|
|
std::unique_ptr<SkCodec> codec(SkCodec::NewFromStream(stream.release()));
|
|
REPORTER_ASSERT(r, !codec);
|
|
}
|
|
|
|
DEF_TEST(Codec_InvalidHeader, r) {
|
|
test_invalid_header(r, "invalid_images/int_overflow.ico");
|
|
|
|
// These files report values that have caused problems with SkFILEStreams.
|
|
// They are invalid, and should not create SkCodecs.
|
|
test_invalid_header(r, "invalid_images/b33651913.bmp");
|
|
test_invalid_header(r, "invalid_images/b34778578.bmp");
|
|
}
|
|
|
|
DEF_TEST(Codec_InvalidAnimated, r) {
|
|
// ASAN will complain if there is an issue.
|
|
auto path = "invalid_images/skbug6046.gif";
|
|
auto* stream = GetResourceAsStream(path);
|
|
if (!stream) {
|
|
return;
|
|
}
|
|
|
|
std::unique_ptr<SkCodec> codec(SkCodec::NewFromStream(stream));
|
|
REPORTER_ASSERT(r, codec);
|
|
if (!codec) {
|
|
return;
|
|
}
|
|
|
|
const auto info = codec->getInfo().makeColorType(kN32_SkColorType);
|
|
SkBitmap bm;
|
|
bm.allocPixels(info);
|
|
|
|
auto frameInfos = codec->getFrameInfo();
|
|
SkCodec::Options opts;
|
|
for (int i = 0; static_cast<size_t>(i) < frameInfos.size(); i++) {
|
|
opts.fFrameIndex = i;
|
|
opts.fHasPriorFrame = frameInfos[i].fRequiredFrame == i - 1;
|
|
auto result = codec->startIncrementalDecode(info, bm.getPixels(), bm.rowBytes(), &opts);
|
|
if (result != SkCodec::kSuccess) {
|
|
ERRORF(r, "Failed to start decoding frame %i (out of %i) with error %i\n", i,
|
|
frameInfos.size(), result);
|
|
continue;
|
|
}
|
|
|
|
codec->incrementalDecode();
|
|
}
|
|
}
|
|
|
|
static void encode_format(SkDynamicMemoryWStream* stream, const SkPixmap& pixmap,
|
|
const SkEncodeOptions& opts, SkEncodedImageFormat format) {
|
|
switch (format) {
|
|
case SkEncodedImageFormat::kPNG:
|
|
SkEncodeImageAsPNG(stream, pixmap, opts);
|
|
break;
|
|
case SkEncodedImageFormat::kJPEG:
|
|
SkEncodeImageAsJPEG(stream, pixmap, opts);
|
|
break;
|
|
case SkEncodedImageFormat::kWEBP:
|
|
SkEncodeImageAsWEBP(stream, pixmap, opts);
|
|
break;
|
|
default:
|
|
SkASSERT(false);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void test_encode_icc(skiatest::Reporter* r, SkEncodedImageFormat format,
|
|
SkTransferFunctionBehavior unpremulBehavior) {
|
|
// Test with sRGB color space.
|
|
SkBitmap srgbBitmap;
|
|
SkImageInfo srgbInfo = SkImageInfo::MakeS32(1, 1, kOpaque_SkAlphaType);
|
|
srgbBitmap.allocPixels(srgbInfo);
|
|
*srgbBitmap.getAddr32(0, 0) = 0;
|
|
SkPixmap pixmap;
|
|
srgbBitmap.peekPixels(&pixmap);
|
|
SkDynamicMemoryWStream srgbBuf;
|
|
SkEncodeOptions opts;
|
|
opts.fUnpremulBehavior = unpremulBehavior;
|
|
encode_format(&srgbBuf, pixmap, opts, format);
|
|
sk_sp<SkData> srgbData = srgbBuf.detachAsData();
|
|
std::unique_ptr<SkCodec> srgbCodec(SkCodec::NewFromData(srgbData));
|
|
REPORTER_ASSERT(r, srgbCodec->getInfo().colorSpace() == SkColorSpace::MakeSRGB().get());
|
|
|
|
// Test with P3 color space.
|
|
SkDynamicMemoryWStream p3Buf;
|
|
sk_sp<SkColorSpace> p3 = SkColorSpace::MakeRGB(SkColorSpace::kSRGB_RenderTargetGamma,
|
|
SkColorSpace::kDCIP3_D65_Gamut);
|
|
pixmap.setColorSpace(p3);
|
|
encode_format(&p3Buf, pixmap, opts, format);
|
|
sk_sp<SkData> p3Data = p3Buf.detachAsData();
|
|
std::unique_ptr<SkCodec> p3Codec(SkCodec::NewFromData(p3Data));
|
|
REPORTER_ASSERT(r, p3Codec->getInfo().colorSpace()->gammaCloseToSRGB());
|
|
SkMatrix44 mat0(SkMatrix44::kUninitialized_Constructor);
|
|
SkMatrix44 mat1(SkMatrix44::kUninitialized_Constructor);
|
|
bool success = p3->toXYZD50(&mat0);
|
|
REPORTER_ASSERT(r, success);
|
|
success = p3Codec->getInfo().colorSpace()->toXYZD50(&mat1);
|
|
REPORTER_ASSERT(r, success);
|
|
|
|
for (int i = 0; i < 4; i++) {
|
|
for (int j = 0; j < 4; j++) {
|
|
REPORTER_ASSERT(r, color_space_almost_equal(mat0.get(i, j), mat1.get(i, j)));
|
|
}
|
|
}
|
|
}
|
|
|
|
DEF_TEST(Codec_EncodeICC, r) {
|
|
test_encode_icc(r, SkEncodedImageFormat::kPNG, SkTransferFunctionBehavior::kRespect);
|
|
test_encode_icc(r, SkEncodedImageFormat::kJPEG, SkTransferFunctionBehavior::kRespect);
|
|
test_encode_icc(r, SkEncodedImageFormat::kWEBP, SkTransferFunctionBehavior::kRespect);
|
|
test_encode_icc(r, SkEncodedImageFormat::kPNG, SkTransferFunctionBehavior::kIgnore);
|
|
test_encode_icc(r, SkEncodedImageFormat::kJPEG, SkTransferFunctionBehavior::kIgnore);
|
|
test_encode_icc(r, SkEncodedImageFormat::kWEBP, SkTransferFunctionBehavior::kIgnore);
|
|
}
|