/**
* Finally, make sure that if we get ETC1 data from a PKM file that we can then
* accurately write it out into a KTX file (i.e. transferring the ETC1 data from
* the PKM to the KTX should produce an identical KTX to the one we have on file)
*/
DEF_TEST(KtxReexportPKM, reporter) {
SkString pkmFilename = GetResourcePath("mandrill_128.pkm");
// Load PKM file into a bitmap
SkBitmap etcBitmap;
SkAutoTUnref<SkData> fileData(SkData::NewFromFileName(pkmFilename.c_str()));
if (nullptr == fileData) {
SkDebugf("KtxReexportPKM: can't load test file %s\n", pkmFilename.c_str());
return;
}
bool installDiscardablePixelRefSuccess =
SkDEPRECATED_InstallDiscardablePixelRef(fileData, &etcBitmap);
if (!installDiscardablePixelRefSuccess) {
ERRORF(reporter, "failed to create discardable pixelRef from KTX file");
return;
}
// Write the bitmap out to a KTX file.
SkData *ktxDataPtr = SkImageEncoder::EncodeData(etcBitmap, SkImageEncoder::kKTX_Type, 0);
SkAutoDataUnref newKtxData(ktxDataPtr);
REPORTER_ASSERT(reporter, ktxDataPtr);
// See is this data is identical to data in existing ktx file.
SkString ktxFilename = GetResourcePath("mandrill_128.ktx");
SkAutoDataUnref oldKtxData(SkData::NewFromFileName(ktxFilename.c_str()));
REPORTER_ASSERT(reporter, oldKtxData->equals(newKtxData));
}
DEF_TEST(Picture_EncodedData, reporter) {
// Create a bitmap that will be encoded.
SkBitmap original;
make_bm(&original, 100, 100, SK_ColorBLUE, true);
SkDynamicMemoryWStream wStream;
if (!SkImageEncoder::EncodeStream(&wStream, original, SkImageEncoder::kPNG_Type, 100)) {
return;
}
SkAutoDataUnref data(wStream.copyToData());
SkBitmap bm;
bool installSuccess = SkDEPRECATED_InstallDiscardablePixelRef(data, &bm);
REPORTER_ASSERT(reporter, installSuccess);
// Write both bitmaps to pictures, and ensure that the resulting data streams are the same.
// Flattening original will follow the old path of performing an encode, while flattening bm
// will use the already encoded data.
SkAutoDataUnref picture1(serialized_picture_from_bitmap(original));
SkAutoDataUnref picture2(serialized_picture_from_bitmap(bm));
REPORTER_ASSERT(reporter, picture1->equals(picture2));
// Now test that a parse error was generated when trying to create a new SkPicture without
// providing a function to decode the bitmap.
ErrorContext context;
context.fErrors = 0;
context.fReporter = reporter;
SkSetErrorCallback(assert_one_parse_error_cb, &context);
SkMemoryStream pictureStream(picture1);
SkClearLastError();
sk_sp<SkPicture> pictureFromStream(SkPicture::MakeFromStream(&pictureStream, nullptr));
REPORTER_ASSERT(reporter, pictureFromStream.get() != nullptr);
SkClearLastError();
SkSetErrorCallback(nullptr, nullptr);
// Test that using the version of CreateFromStream that just takes a stream also decodes the
// bitmap. Drawing this picture should look exactly like the original bitmap.
SkMD5::Digest referenceDigest;
md5(original, &referenceDigest);
SkBitmap dst;
dst.allocPixels(original.info());
dst.eraseColor(SK_ColorRED);
SkCanvas canvas(dst);
pictureStream.rewind();
pictureFromStream = SkPicture::MakeFromStream(&pictureStream);
canvas.drawPicture(pictureFromStream.get());
SkMD5::Digest digest2;
md5(dst, &digest2);
REPORTER_ASSERT(reporter, referenceDigest == digest2);
}
static void check_pixelref(TestImageGenerator::TestType type,
skiatest::Reporter* reporter,
SkDiscardableMemory::Factory* factory) {
SkAutoTDelete<SkImageGenerator> gen(new TestImageGenerator(type, reporter));
REPORTER_ASSERT(reporter, gen.get() != nullptr);
SkBitmap lazy;
bool success = SkDEPRECATED_InstallDiscardablePixelRef(gen.detach(), nullptr, &lazy, factory);
REPORTER_ASSERT(reporter, success);
if (TestImageGenerator::kSucceedGetPixels_TestType == type) {
check_test_image_generator_bitmap(reporter, lazy);
} else if (TestImageGenerator::kFailGetPixels_TestType == type) {
SkAutoLockPixels autoLockPixels(lazy);
REPORTER_ASSERT(reporter, nullptr == lazy.getPixels());
}
}
static bool default_install(const void* src, size_t length, SkBitmap* dst) {
sk_sp<SkData> encoded(SkData::MakeWithCopy(src, length));
return encoded && SkDEPRECATED_InstallDiscardablePixelRef(
SkImageGenerator::NewFromEncoded(encoded.get()), dst);
}
static bool install_skDiscardablePixelRef(SkData* encoded, SkBitmap* dst) {
// Use system-default discardable memory.
return SkDEPRECATED_InstallDiscardablePixelRef(encoded, dst);
}
// Returned bitmap is lazy. Only lazy bitmaps hold onto the original data.
static SkBitmap bitmap_from_data(SkData* data) {
SkASSERT(data);
SkBitmap bm;
SkDEPRECATED_InstallDiscardablePixelRef(data, &bm);
return bm;
}
bool SkDEPRECATED_InstallDiscardablePixelRef(SkData* encoded, SkBitmap* dst) {
SkImageGenerator* generator = SkImageGenerator::NewFromEncoded(encoded);
return generator ?
SkDEPRECATED_InstallDiscardablePixelRef(generator, nullptr, dst, nullptr) : false;
}
bool SkDEPRECATED_InstallDiscardablePixelRef(SkImageGenerator* generator, SkBitmap* dst) {
return SkDEPRECATED_InstallDiscardablePixelRef(generator, nullptr, dst, nullptr);
}
