a1cc9f6b84
This mimics Chromium's TestResumePartialDecodeAfterClearFrameBufferCache, which expects the frame count to increase as more data comes in, even if the decoder is in the middle of an incremental decode: https://cs.chromium.org/chromium/src/third_party/blink/renderer/platform/image-decoders/image_decoder_test_helpers.cc?l=365&rcl=23787ba147959ebf4ad168c595d5ec87919fdbd2 Bug: skia:8235 Change-Id: Icc19ebea6d77f6b6fb62e3b2ff0c2ffb1ef0950d Reviewed-on: https://skia-review.googlesource.com/c/skia/+/250476 Reviewed-by: Leon Scroggins <scroggo@google.com> Commit-Queue: Leon Scroggins <scroggo@google.com>
554 lines
19 KiB
C++
554 lines
19 KiB
C++
/*
|
|
* Copyright 2016 Google Inc.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
* found in the LICENSE file.
|
|
*/
|
|
|
|
#include "include/codec/SkCodec.h"
|
|
#include "include/core/SkBitmap.h"
|
|
#include "include/core/SkData.h"
|
|
#include "include/core/SkImageInfo.h"
|
|
#include "include/core/SkRefCnt.h"
|
|
#include "include/core/SkStream.h"
|
|
#include "include/core/SkString.h"
|
|
#include "include/core/SkTypes.h"
|
|
#include "src/core/SkMakeUnique.h"
|
|
#include "tests/CodecPriv.h"
|
|
#include "tests/FakeStreams.h"
|
|
#include "tests/Test.h"
|
|
#include "tools/Resources.h"
|
|
|
|
#include <cstring>
|
|
#include <initializer_list>
|
|
#include <memory>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
static SkImageInfo standardize_info(SkCodec* codec) {
|
|
SkImageInfo defaultInfo = codec->getInfo();
|
|
// Note: This drops the SkColorSpace, allowing the equality check between two
|
|
// different codecs created from the same file to have the same SkImageInfo.
|
|
return SkImageInfo::MakeN32Premul(defaultInfo.width(), defaultInfo.height());
|
|
}
|
|
|
|
static bool create_truth(sk_sp<SkData> data, SkBitmap* dst) {
|
|
std::unique_ptr<SkCodec> codec(SkCodec::MakeFromData(std::move(data)));
|
|
if (!codec) {
|
|
return false;
|
|
}
|
|
|
|
const SkImageInfo info = standardize_info(codec.get());
|
|
dst->allocPixels(info);
|
|
return SkCodec::kSuccess == codec->getPixels(info, dst->getPixels(), dst->rowBytes());
|
|
}
|
|
|
|
static bool compare_bitmaps(skiatest::Reporter* r, const SkBitmap& bm1, const SkBitmap& bm2) {
|
|
const SkImageInfo& info = bm1.info();
|
|
if (info != bm2.info()) {
|
|
ERRORF(r, "Bitmaps have different image infos!");
|
|
return false;
|
|
}
|
|
const size_t rowBytes = info.minRowBytes();
|
|
for (int i = 0; i < info.height(); i++) {
|
|
if (memcmp(bm1.getAddr(0, i), bm2.getAddr(0, i), rowBytes)) {
|
|
ERRORF(r, "Bitmaps have different pixels, starting on line %i!", i);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static void test_partial(skiatest::Reporter* r, const char* name, const sk_sp<SkData>& file,
|
|
size_t minBytes, size_t increment) {
|
|
SkBitmap truth;
|
|
if (!create_truth(file, &truth)) {
|
|
ERRORF(r, "Failed to decode %s\n", name);
|
|
return;
|
|
}
|
|
|
|
// Now decode part of the file
|
|
HaltingStream* stream = new HaltingStream(file, minBytes);
|
|
|
|
// Note that we cheat and hold on to a pointer to stream, though it is owned by
|
|
// partialCodec.
|
|
auto partialCodec = SkCodec::MakeFromStream(std::unique_ptr<SkStream>(stream));
|
|
if (!partialCodec) {
|
|
ERRORF(r, "Failed to create codec for %s with %zu bytes", name, minBytes);
|
|
return;
|
|
}
|
|
|
|
const SkImageInfo info = standardize_info(partialCodec.get());
|
|
SkASSERT(info == truth.info());
|
|
SkBitmap incremental;
|
|
incremental.allocPixels(info);
|
|
|
|
while (true) {
|
|
const SkCodec::Result startResult = partialCodec->startIncrementalDecode(info,
|
|
incremental.getPixels(), incremental.rowBytes());
|
|
if (startResult == SkCodec::kSuccess) {
|
|
break;
|
|
}
|
|
|
|
if (stream->isAllDataReceived()) {
|
|
ERRORF(r, "Failed to start incremental decode\n");
|
|
return;
|
|
}
|
|
|
|
stream->addNewData(increment);
|
|
}
|
|
|
|
while (true) {
|
|
// This imitates how Chromium calls getFrameCount before resuming a decode.
|
|
partialCodec->getFrameCount();
|
|
|
|
const SkCodec::Result result = partialCodec->incrementalDecode();
|
|
|
|
if (result == SkCodec::kSuccess) {
|
|
break;
|
|
}
|
|
|
|
REPORTER_ASSERT(r, result == SkCodec::kIncompleteInput);
|
|
|
|
if (stream->isAllDataReceived()) {
|
|
ERRORF(r, "Failed to completely decode %s", name);
|
|
return;
|
|
}
|
|
|
|
stream->addNewData(increment);
|
|
}
|
|
|
|
// compare to original
|
|
compare_bitmaps(r, truth, incremental);
|
|
}
|
|
|
|
static void test_partial(skiatest::Reporter* r, const char* name, size_t minBytes = 0) {
|
|
sk_sp<SkData> file = GetResourceAsData(name);
|
|
if (!file) {
|
|
SkDebugf("missing resource %s\n", name);
|
|
return;
|
|
}
|
|
|
|
// This size is arbitrary, but deliberately different from the buffer size used by SkPngCodec.
|
|
constexpr size_t kIncrement = 1000;
|
|
test_partial(r, name, file, SkTMax(file->size() / 2, minBytes), kIncrement);
|
|
}
|
|
|
|
DEF_TEST(Codec_partial, r) {
|
|
#if 0
|
|
// FIXME (scroggo): SkPngCodec needs to use SkStreamBuffer in order to
|
|
// support incremental decoding.
|
|
test_partial(r, "images/plane.png");
|
|
test_partial(r, "images/plane_interlaced.png");
|
|
test_partial(r, "images/yellow_rose.png");
|
|
test_partial(r, "images/index8.png");
|
|
test_partial(r, "images/color_wheel.png");
|
|
test_partial(r, "images/mandrill_256.png");
|
|
test_partial(r, "images/mandrill_32.png");
|
|
test_partial(r, "images/arrow.png");
|
|
test_partial(r, "images/randPixels.png");
|
|
test_partial(r, "images/baby_tux.png");
|
|
#endif
|
|
test_partial(r, "images/box.gif");
|
|
test_partial(r, "images/randPixels.gif", 215);
|
|
test_partial(r, "images/color_wheel.gif");
|
|
}
|
|
|
|
DEF_TEST(Codec_partialWuffs, r) {
|
|
const char* path = "images/alphabetAnim.gif";
|
|
auto file = GetResourceAsData(path);
|
|
if (!file) {
|
|
ERRORF(r, "missing %s", path);
|
|
} else {
|
|
// This is the end of the first frame. SkCodec will treat this as a
|
|
// single frame gif.
|
|
file = SkData::MakeSubset(file.get(), 0, 153);
|
|
// Start with 100 to get a partial decode, then add the rest of the
|
|
// first frame to decode a full image.
|
|
test_partial(r, path, file, 100, 53);
|
|
}
|
|
}
|
|
|
|
#ifndef SK_HAS_WUFFS_LIBRARY
|
|
DEF_TEST(Codec_frameCountUpdatesInIncrementalDecode, r) {
|
|
sk_sp<SkData> file = GetResourceAsData("images/colorTables.gif");
|
|
size_t fileSize = file->size();
|
|
REPORTER_ASSERT(r, fileSize == 2829);
|
|
std::unique_ptr<SkCodec> fullCodec(SkCodec::MakeFromData(file));
|
|
REPORTER_ASSERT(r, fullCodec->getFrameCount() == 2);
|
|
const SkImageInfo info = standardize_info(fullCodec.get());
|
|
|
|
static const size_t n = 1000;
|
|
HaltingStream* stream = new HaltingStream(file, n);
|
|
// Note that we cheat and hold on to a pointer to stream, though it is owned by
|
|
// partialCodec.
|
|
auto partialCodec = SkCodec::MakeFromStream(std::unique_ptr<SkStream>(stream));
|
|
REPORTER_ASSERT(r, partialCodec->getFrameCount() == 1);
|
|
|
|
SkBitmap bitmap;
|
|
bitmap.allocPixels(info);
|
|
REPORTER_ASSERT(r, SkCodec::kSuccess ==
|
|
partialCodec->startIncrementalDecode(
|
|
info, bitmap.getPixels(), bitmap.rowBytes()));
|
|
REPORTER_ASSERT(r, SkCodec::kIncompleteInput ==
|
|
partialCodec->incrementalDecode());
|
|
|
|
REPORTER_ASSERT(r, partialCodec->getFrameCount() == 1);
|
|
stream->addNewData(fileSize - n);
|
|
REPORTER_ASSERT(r, partialCodec->getFrameCount() == 2);
|
|
}
|
|
#endif
|
|
|
|
// Verify that when decoding an animated gif byte by byte we report the correct
|
|
// fRequiredFrame as soon as getFrameInfo reports the frame.
|
|
DEF_TEST(Codec_requiredFrame, r) {
|
|
auto path = "images/colorTables.gif";
|
|
sk_sp<SkData> file = GetResourceAsData(path);
|
|
if (!file) {
|
|
return;
|
|
}
|
|
|
|
std::unique_ptr<SkCodec> codec(SkCodec::MakeFromData(file));
|
|
if (!codec) {
|
|
ERRORF(r, "Failed to create codec from %s", path);
|
|
return;
|
|
}
|
|
|
|
auto frameInfo = codec->getFrameInfo();
|
|
if (frameInfo.size() <= 1) {
|
|
ERRORF(r, "Test is uninteresting with 0 or 1 frames");
|
|
return;
|
|
}
|
|
|
|
HaltingStream* stream(nullptr);
|
|
std::unique_ptr<SkCodec> partialCodec(nullptr);
|
|
for (size_t i = 0; !partialCodec; i++) {
|
|
if (file->size() == i) {
|
|
ERRORF(r, "Should have created a partial codec for %s", path);
|
|
return;
|
|
}
|
|
stream = new HaltingStream(file, i);
|
|
partialCodec = SkCodec::MakeFromStream(std::unique_ptr<SkStream>(stream));
|
|
}
|
|
|
|
std::vector<SkCodec::FrameInfo> partialInfo;
|
|
size_t frameToCompare = 0;
|
|
while (true) {
|
|
partialInfo = partialCodec->getFrameInfo();
|
|
for (; frameToCompare < partialInfo.size(); frameToCompare++) {
|
|
REPORTER_ASSERT(r, partialInfo[frameToCompare].fRequiredFrame
|
|
== frameInfo[frameToCompare].fRequiredFrame);
|
|
}
|
|
|
|
if (frameToCompare == frameInfo.size()) {
|
|
break;
|
|
}
|
|
|
|
if (stream->getLength() == file->size()) {
|
|
ERRORF(r, "Should have found all frames for %s", path);
|
|
return;
|
|
}
|
|
stream->addNewData(1);
|
|
}
|
|
}
|
|
|
|
DEF_TEST(Codec_partialAnim, r) {
|
|
auto path = "images/test640x479.gif";
|
|
sk_sp<SkData> file = GetResourceAsData(path);
|
|
if (!file) {
|
|
return;
|
|
}
|
|
|
|
// This stream will be owned by fullCodec, but we hang on to the pointer
|
|
// to determine frame offsets.
|
|
std::unique_ptr<SkCodec> fullCodec(SkCodec::MakeFromStream(skstd::make_unique<SkMemoryStream>(file)));
|
|
const auto info = standardize_info(fullCodec.get());
|
|
|
|
// frameByteCounts stores the number of bytes to decode a particular frame.
|
|
// - [0] is the number of bytes for the header
|
|
// - frames[i] requires frameByteCounts[i+1] bytes to decode
|
|
const std::vector<size_t> frameByteCounts = { 455, 69350, 1344, 1346, 1327 };
|
|
std::vector<SkBitmap> frames;
|
|
for (size_t i = 0; true; i++) {
|
|
SkBitmap frame;
|
|
frame.allocPixels(info);
|
|
|
|
SkCodec::Options opts;
|
|
opts.fFrameIndex = i;
|
|
const SkCodec::Result result = fullCodec->getPixels(info, frame.getPixels(),
|
|
frame.rowBytes(), &opts);
|
|
|
|
if (result == SkCodec::kIncompleteInput || result == SkCodec::kInvalidInput) {
|
|
// We need to distinguish between a partial frame and no more frames.
|
|
// getFrameInfo lets us do this, since it tells the number of frames
|
|
// not considering whether they are complete.
|
|
// FIXME: Should we use a different Result?
|
|
if (fullCodec->getFrameInfo().size() > i) {
|
|
// This is a partial frame.
|
|
frames.push_back(frame);
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (result != SkCodec::kSuccess) {
|
|
ERRORF(r, "Failed to decode frame %i from %s", i, path);
|
|
return;
|
|
}
|
|
|
|
frames.push_back(frame);
|
|
}
|
|
|
|
// Now decode frames partially, then completely, and compare to the original.
|
|
HaltingStream* haltingStream = new HaltingStream(file, frameByteCounts[0]);
|
|
std::unique_ptr<SkCodec> partialCodec(SkCodec::MakeFromStream(
|
|
std::unique_ptr<SkStream>(haltingStream)));
|
|
if (!partialCodec) {
|
|
ERRORF(r, "Failed to create a partial codec from %s with %i bytes out of %i",
|
|
path, frameByteCounts[0], file->size());
|
|
return;
|
|
}
|
|
|
|
SkASSERT(frameByteCounts.size() > frames.size());
|
|
for (size_t i = 0; i < frames.size(); i++) {
|
|
const size_t fullFrameBytes = frameByteCounts[i + 1];
|
|
const size_t firstHalf = fullFrameBytes / 2;
|
|
const size_t secondHalf = fullFrameBytes - firstHalf;
|
|
|
|
haltingStream->addNewData(firstHalf);
|
|
auto frameInfo = partialCodec->getFrameInfo();
|
|
REPORTER_ASSERT(r, frameInfo.size() == i + 1);
|
|
REPORTER_ASSERT(r, !frameInfo[i].fFullyReceived);
|
|
|
|
SkBitmap frame;
|
|
frame.allocPixels(info);
|
|
|
|
SkCodec::Options opts;
|
|
opts.fFrameIndex = i;
|
|
SkCodec::Result result = partialCodec->startIncrementalDecode(info,
|
|
frame.getPixels(), frame.rowBytes(), &opts);
|
|
if (result != SkCodec::kSuccess) {
|
|
ERRORF(r, "Failed to start incremental decode for %s on frame %i",
|
|
path, i);
|
|
return;
|
|
}
|
|
|
|
result = partialCodec->incrementalDecode();
|
|
REPORTER_ASSERT(r, SkCodec::kIncompleteInput == result);
|
|
|
|
haltingStream->addNewData(secondHalf);
|
|
result = partialCodec->incrementalDecode();
|
|
REPORTER_ASSERT(r, SkCodec::kSuccess == result);
|
|
|
|
frameInfo = partialCodec->getFrameInfo();
|
|
REPORTER_ASSERT(r, frameInfo.size() == i + 1);
|
|
REPORTER_ASSERT(r, frameInfo[i].fFullyReceived);
|
|
if (!compare_bitmaps(r, frames[i], frame)) {
|
|
ERRORF(r, "\tfailure was on frame %i", i);
|
|
SkString name = SkStringPrintf("expected_%i", i);
|
|
write_bm(name.c_str(), frames[i]);
|
|
|
|
name = SkStringPrintf("actual_%i", i);
|
|
write_bm(name.c_str(), frame);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Test that calling getPixels when an incremental decode has been
|
|
// started (but not finished) makes the next call to incrementalDecode
|
|
// require a call to startIncrementalDecode.
|
|
static void test_interleaved(skiatest::Reporter* r, const char* name) {
|
|
sk_sp<SkData> file = GetResourceAsData(name);
|
|
if (!file) {
|
|
return;
|
|
}
|
|
const size_t halfSize = file->size() / 2;
|
|
std::unique_ptr<SkCodec> partialCodec(SkCodec::MakeFromStream(
|
|
skstd::make_unique<HaltingStream>(std::move(file), halfSize)));
|
|
if (!partialCodec) {
|
|
ERRORF(r, "Failed to create codec for %s", name);
|
|
return;
|
|
}
|
|
|
|
const SkImageInfo info = standardize_info(partialCodec.get());
|
|
SkBitmap incremental;
|
|
incremental.allocPixels(info);
|
|
|
|
const SkCodec::Result startResult = partialCodec->startIncrementalDecode(info,
|
|
incremental.getPixels(), incremental.rowBytes());
|
|
if (startResult != SkCodec::kSuccess) {
|
|
ERRORF(r, "Failed to start incremental decode\n");
|
|
return;
|
|
}
|
|
|
|
SkCodec::Result result = partialCodec->incrementalDecode();
|
|
REPORTER_ASSERT(r, result == SkCodec::kIncompleteInput);
|
|
|
|
SkBitmap full;
|
|
full.allocPixels(info);
|
|
result = partialCodec->getPixels(info, full.getPixels(), full.rowBytes());
|
|
REPORTER_ASSERT(r, result == SkCodec::kIncompleteInput);
|
|
|
|
// Now incremental decode will fail
|
|
result = partialCodec->incrementalDecode();
|
|
REPORTER_ASSERT(r, result == SkCodec::kInvalidParameters);
|
|
}
|
|
|
|
DEF_TEST(Codec_rewind, r) {
|
|
test_interleaved(r, "images/plane.png");
|
|
test_interleaved(r, "images/plane_interlaced.png");
|
|
test_interleaved(r, "images/box.gif");
|
|
}
|
|
|
|
// Modified version of the giflib logo, from
|
|
// http://giflib.sourceforge.net/whatsinagif/bits_and_bytes.html
|
|
// The global color map has been replaced with a local color map.
|
|
static unsigned char gNoGlobalColorMap[] = {
|
|
// Header
|
|
0x47, 0x49, 0x46, 0x38, 0x39, 0x61,
|
|
|
|
// Logical screen descriptor
|
|
0x0A, 0x00, 0x0A, 0x00, 0x11, 0x00, 0x00,
|
|
|
|
// Image descriptor
|
|
0x2C, 0x00, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x0A, 0x00, 0x81,
|
|
|
|
// Local color table
|
|
0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00,
|
|
|
|
// Image data
|
|
0x02, 0x16, 0x8C, 0x2D, 0x99, 0x87, 0x2A, 0x1C, 0xDC, 0x33, 0xA0, 0x02, 0x75,
|
|
0xEC, 0x95, 0xFA, 0xA8, 0xDE, 0x60, 0x8C, 0x04, 0x91, 0x4C, 0x01, 0x00,
|
|
|
|
// Trailer
|
|
0x3B,
|
|
};
|
|
|
|
// Test that a gif file truncated before its local color map behaves as expected.
|
|
DEF_TEST(Codec_GifPreMap, r) {
|
|
sk_sp<SkData> data = SkData::MakeWithoutCopy(gNoGlobalColorMap, sizeof(gNoGlobalColorMap));
|
|
std::unique_ptr<SkCodec> codec(SkCodec::MakeFromData(data));
|
|
if (!codec) {
|
|
ERRORF(r, "failed to create codec");
|
|
return;
|
|
}
|
|
|
|
SkBitmap truth;
|
|
auto info = standardize_info(codec.get());
|
|
truth.allocPixels(info);
|
|
|
|
auto result = codec->getPixels(info, truth.getPixels(), truth.rowBytes());
|
|
REPORTER_ASSERT(r, result == SkCodec::kSuccess);
|
|
|
|
// Truncate to 23 bytes, just before the color map. This should fail to decode.
|
|
//
|
|
// See also Codec_GifTruncated2 in GifTest.cpp for this magic 23.
|
|
codec = SkCodec::MakeFromData(SkData::MakeWithoutCopy(gNoGlobalColorMap, 23));
|
|
REPORTER_ASSERT(r, codec);
|
|
if (codec) {
|
|
SkBitmap bm;
|
|
bm.allocPixels(info);
|
|
result = codec->getPixels(info, bm.getPixels(), bm.rowBytes());
|
|
|
|
// See the comments in Codec_GifTruncated2.
|
|
#ifdef SK_HAS_WUFFS_LIBRARY
|
|
REPORTER_ASSERT(r, result == SkCodec::kIncompleteInput);
|
|
#else
|
|
REPORTER_ASSERT(r, result == SkCodec::kInvalidInput);
|
|
#endif
|
|
}
|
|
|
|
// Again, truncate to 23 bytes, this time for an incremental decode. We
|
|
// cannot start an incremental decode until we have more data. If we did,
|
|
// we would be using the wrong color table.
|
|
HaltingStream* stream = new HaltingStream(data, 23);
|
|
codec = SkCodec::MakeFromStream(std::unique_ptr<SkStream>(stream));
|
|
REPORTER_ASSERT(r, codec);
|
|
if (codec) {
|
|
SkBitmap bm;
|
|
bm.allocPixels(info);
|
|
result = codec->startIncrementalDecode(info, bm.getPixels(), bm.rowBytes());
|
|
|
|
// See the comments in Codec_GifTruncated2.
|
|
#ifdef SK_HAS_WUFFS_LIBRARY
|
|
REPORTER_ASSERT(r, result == SkCodec::kSuccess);
|
|
|
|
// Note that this is incrementalDecode, not startIncrementalDecode.
|
|
result = codec->incrementalDecode();
|
|
REPORTER_ASSERT(r, result == SkCodec::kIncompleteInput);
|
|
|
|
stream->addNewData(data->size());
|
|
#else
|
|
REPORTER_ASSERT(r, result == SkCodec::kIncompleteInput);
|
|
|
|
// Note that this is startIncrementalDecode, not incrementalDecode.
|
|
stream->addNewData(data->size());
|
|
result = codec->startIncrementalDecode(info, bm.getPixels(), bm.rowBytes());
|
|
REPORTER_ASSERT(r, result == SkCodec::kSuccess);
|
|
#endif
|
|
|
|
result = codec->incrementalDecode();
|
|
REPORTER_ASSERT(r, result == SkCodec::kSuccess);
|
|
compare_bitmaps(r, truth, bm);
|
|
}
|
|
}
|
|
|
|
DEF_TEST(Codec_emptyIDAT, r) {
|
|
const char* name = "images/baby_tux.png";
|
|
sk_sp<SkData> file = GetResourceAsData(name);
|
|
if (!file) {
|
|
return;
|
|
}
|
|
|
|
// Truncate to the beginning of the IDAT, immediately after the IDAT tag.
|
|
file = SkData::MakeSubset(file.get(), 0, 80);
|
|
|
|
std::unique_ptr<SkCodec> codec(SkCodec::MakeFromData(std::move(file)));
|
|
if (!codec) {
|
|
ERRORF(r, "Failed to create a codec for %s", name);
|
|
return;
|
|
}
|
|
|
|
SkBitmap bm;
|
|
const auto info = standardize_info(codec.get());
|
|
bm.allocPixels(info);
|
|
|
|
const auto result = codec->getPixels(info, bm.getPixels(), bm.rowBytes());
|
|
REPORTER_ASSERT(r, SkCodec::kIncompleteInput == result);
|
|
}
|
|
|
|
DEF_TEST(Codec_incomplete, r) {
|
|
for (const char* name : { "images/baby_tux.png",
|
|
"images/baby_tux.webp",
|
|
"images/CMYK.jpg",
|
|
"images/color_wheel.gif",
|
|
"images/google_chrome.ico",
|
|
"images/rle.bmp",
|
|
"images/mandrill.wbmp",
|
|
}) {
|
|
sk_sp<SkData> file = GetResourceAsData(name);
|
|
if (!file) {
|
|
continue;
|
|
}
|
|
|
|
for (size_t len = 14; len <= file->size(); len += 5) {
|
|
SkCodec::Result result;
|
|
std::unique_ptr<SkCodec> codec(SkCodec::MakeFromStream(
|
|
skstd::make_unique<SkMemoryStream>(file->data(), len), &result));
|
|
if (codec) {
|
|
if (result != SkCodec::kSuccess) {
|
|
ERRORF(r, "Created an SkCodec for %s with %lu bytes, but "
|
|
"reported an error %i", name, len, result);
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (SkCodec::kIncompleteInput != result) {
|
|
ERRORF(r, "Reported error %i for %s with %lu bytes",
|
|
result, name, len);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|