a1193e4b0e
SkStream is a stateful object, so it does not make sense for it to have multiple owners. Make SkStream inherit directly from SkNoncopyable. Update methods which previously called SkStream::ref() (e.g. SkImageDecoder::buildTileIndex() and SkFrontBufferedStream::Create(), which required the existing owners to call SkStream::unref()) to take ownership of their SkStream parameters and delete when done (including on failure). Switch all SkAutoTUnref<SkStream>s to SkAutoTDelete<SkStream>s. In some cases this means heap allocating streams that were previously stack allocated. Respect ownership rules of SkTypeface::CreateFromStream() and SkImageDecoder::buildTileIndex(). Update the comments for exceptional methods which do not affect the ownership of their SkStream parameters (e.g. SkPicture::CreateFromStream() and SkTypeface::Deserialize()) to be explicit about ownership. Remove test_stream_life, which tested that buildTileIndex() behaved correctly when SkStream was a ref counted object. The test does not make sense now that it is not. In SkPDFStream, remove the SkMemoryStream member. Instead of using it, create a new SkMemoryStream to pass to fDataStream (which is now an SkAutoTDelete). Make other pdf rasterizers behave like SkPDFDocumentToBitmap. SkPDFDocumentToBitmap delete the SkStream, so do the same in the following pdf rasterizers: SkPopplerRasterizePDF SkNativeRasterizePDF SkNoRasterizePDF Requires a change to Android, which currently treats SkStreams as ref counted objects. Review URL: https://codereview.chromium.org/849103004
167 lines
6.3 KiB
C++
167 lines
6.3 KiB
C++
/*
|
|
* Copyright 2014 Google Inc.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
* found in the LICENSE file.
|
|
*/
|
|
|
|
#include "Resources.h"
|
|
#include "SkBitmap.h"
|
|
#include "SkData.h"
|
|
#include "SkImageGenerator.h"
|
|
#include "SkForceLinking.h"
|
|
#include "SkImageDecoder.h"
|
|
#include "SkOSFile.h"
|
|
#include "SkRandom.h"
|
|
#include "SkStream.h"
|
|
#include "Test.h"
|
|
|
|
__SK_FORCE_IMAGE_DECODER_LINKING;
|
|
|
|
/**
|
|
* First, make sure that writing an 8-bit RGBA KTX file and then
|
|
* reading it produces the same bitmap.
|
|
*/
|
|
DEF_TEST(KtxReadWrite, reporter) {
|
|
|
|
// Random number generator with explicit seed for reproducibility
|
|
SkRandom rand(0x1005cbad);
|
|
|
|
SkBitmap bm8888;
|
|
bm8888.allocN32Pixels(128, 128);
|
|
|
|
uint8_t *pixels = reinterpret_cast<uint8_t*>(bm8888.getPixels());
|
|
REPORTER_ASSERT(reporter, pixels);
|
|
|
|
if (NULL == pixels) {
|
|
return;
|
|
}
|
|
|
|
uint8_t *row = pixels;
|
|
for (int y = 0; y < bm8888.height(); ++y) {
|
|
for (int x = 0; x < bm8888.width(); ++x) {
|
|
uint8_t a = rand.nextRangeU(0, 255);
|
|
uint8_t r = rand.nextRangeU(0, 255);
|
|
uint8_t g = rand.nextRangeU(0, 255);
|
|
uint8_t b = rand.nextRangeU(0, 255);
|
|
|
|
SkPMColor &pixel = *(reinterpret_cast<SkPMColor*>(row + x*sizeof(SkPMColor)));
|
|
pixel = SkPreMultiplyARGB(a, r, g, b);
|
|
}
|
|
row += bm8888.rowBytes();
|
|
}
|
|
REPORTER_ASSERT(reporter, !(bm8888.empty()));
|
|
|
|
SkAutoDataUnref encodedData(SkImageEncoder::EncodeData(bm8888, SkImageEncoder::kKTX_Type, 0));
|
|
REPORTER_ASSERT(reporter, encodedData);
|
|
|
|
SkAutoTDelete<SkMemoryStream> stream(SkNEW_ARGS(SkMemoryStream, (encodedData)));
|
|
REPORTER_ASSERT(reporter, stream);
|
|
|
|
SkBitmap decodedBitmap;
|
|
bool imageDecodeSuccess = SkImageDecoder::DecodeStream(stream, &decodedBitmap);
|
|
REPORTER_ASSERT(reporter, imageDecodeSuccess);
|
|
|
|
REPORTER_ASSERT(reporter, decodedBitmap.colorType() == bm8888.colorType());
|
|
REPORTER_ASSERT(reporter, decodedBitmap.alphaType() == bm8888.alphaType());
|
|
REPORTER_ASSERT(reporter, decodedBitmap.width() == bm8888.width());
|
|
REPORTER_ASSERT(reporter, decodedBitmap.height() == bm8888.height());
|
|
REPORTER_ASSERT(reporter, !(decodedBitmap.empty()));
|
|
|
|
uint8_t *decodedPixels = reinterpret_cast<uint8_t*>(decodedBitmap.getPixels());
|
|
REPORTER_ASSERT(reporter, decodedPixels);
|
|
REPORTER_ASSERT(reporter, decodedBitmap.getSize() == bm8888.getSize());
|
|
|
|
if (NULL == decodedPixels) {
|
|
return;
|
|
}
|
|
|
|
REPORTER_ASSERT(reporter, memcmp(decodedPixels, pixels, decodedBitmap.getSize()) == 0);
|
|
}
|
|
|
|
/**
|
|
* Next test is to see whether or not reading an unpremultiplied KTX file accurately
|
|
* creates a premultiplied buffer...
|
|
*/
|
|
DEF_TEST(KtxReadUnpremul, reporter) {
|
|
|
|
static const uint8_t kHalfWhiteKTX[] = {
|
|
0xAB, 0x4B, 0x54, 0x58, 0x20, 0x31, // First twelve bytes is magic
|
|
0x31, 0xBB, 0x0D, 0x0A, 0x1A, 0x0A, // KTX identifier string
|
|
0x01, 0x02, 0x03, 0x04, // Then magic endian specifier
|
|
0x01, 0x14, 0x00, 0x00, // uint32_t fGLType;
|
|
0x01, 0x00, 0x00, 0x00, // uint32_t fGLTypeSize;
|
|
0x08, 0x19, 0x00, 0x00, // uint32_t fGLFormat;
|
|
0x58, 0x80, 0x00, 0x00, // uint32_t fGLInternalFormat;
|
|
0x08, 0x19, 0x00, 0x00, // uint32_t fGLBaseInternalFormat;
|
|
0x02, 0x00, 0x00, 0x00, // uint32_t fPixelWidth;
|
|
0x02, 0x00, 0x00, 0x00, // uint32_t fPixelHeight;
|
|
0x00, 0x00, 0x00, 0x00, // uint32_t fPixelDepth;
|
|
0x00, 0x00, 0x00, 0x00, // uint32_t fNumberOfArrayElements;
|
|
0x01, 0x00, 0x00, 0x00, // uint32_t fNumberOfFaces;
|
|
0x01, 0x00, 0x00, 0x00, // uint32_t fNumberOfMipmapLevels;
|
|
0x00, 0x00, 0x00, 0x00, // uint32_t fBytesOfKeyValueData;
|
|
0x10, 0x00, 0x00, 0x00, // image size: 2x2 image of RGBA = 4 * 4 = 16 bytes
|
|
0xFF, 0xFF, 0xFF, 0x80, // Pixel 1
|
|
0xFF, 0xFF, 0xFF, 0x80, // Pixel 2
|
|
0xFF, 0xFF, 0xFF, 0x80, // Pixel 3
|
|
0xFF, 0xFF, 0xFF, 0x80};// Pixel 4
|
|
|
|
SkAutoTDelete<SkMemoryStream> stream(
|
|
SkNEW_ARGS(SkMemoryStream, (kHalfWhiteKTX, sizeof(kHalfWhiteKTX))));
|
|
REPORTER_ASSERT(reporter, stream);
|
|
|
|
SkBitmap decodedBitmap;
|
|
bool imageDecodeSuccess = SkImageDecoder::DecodeStream(stream, &decodedBitmap);
|
|
REPORTER_ASSERT(reporter, imageDecodeSuccess);
|
|
|
|
REPORTER_ASSERT(reporter, decodedBitmap.colorType() == kN32_SkColorType);
|
|
REPORTER_ASSERT(reporter, decodedBitmap.alphaType() == kPremul_SkAlphaType);
|
|
REPORTER_ASSERT(reporter, decodedBitmap.width() == 2);
|
|
REPORTER_ASSERT(reporter, decodedBitmap.height() == 2);
|
|
REPORTER_ASSERT(reporter, !(decodedBitmap.empty()));
|
|
|
|
uint8_t *decodedPixels = reinterpret_cast<uint8_t*>(decodedBitmap.getPixels());
|
|
REPORTER_ASSERT(reporter, decodedPixels);
|
|
|
|
uint8_t *row = decodedPixels;
|
|
for (int j = 0; j < decodedBitmap.height(); ++j) {
|
|
for (int i = 0; i < decodedBitmap.width(); ++i) {
|
|
SkPMColor pixel = *(reinterpret_cast<SkPMColor*>(row + i*sizeof(SkPMColor)));
|
|
REPORTER_ASSERT(reporter, SkPreMultiplyARGB(0x80, 0xFF, 0xFF, 0xFF) == pixel);
|
|
}
|
|
row += decodedBitmap.rowBytes();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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 (NULL == fileData) {
|
|
SkDebugf("KtxReexportPKM: can't load test file %s\n", pkmFilename.c_str());
|
|
return;
|
|
}
|
|
|
|
bool installDiscardablePixelRefSuccess =
|
|
SkInstallDiscardablePixelRef(fileData, &etcBitmap);
|
|
REPORTER_ASSERT(reporter, installDiscardablePixelRefSuccess);
|
|
|
|
// 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));
|
|
}
|