2019-12-19 16:19:16 +00:00
|
|
|
/*
|
|
|
|
* Copyright 2019 Google Inc.
|
|
|
|
*
|
|
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
|
|
* found in the LICENSE file.
|
|
|
|
*/
|
|
|
|
|
2020-04-06 17:57:30 +00:00
|
|
|
#include "include/core/SkCanvas.h"
|
2019-12-19 16:19:16 +00:00
|
|
|
#include "include/gpu/GrContext.h"
|
|
|
|
#include "src/core/SkAutoPixmapStorage.h"
|
2020-01-27 21:11:57 +00:00
|
|
|
#include "src/core/SkCompressedDataUtils.h"
|
2019-12-19 16:19:16 +00:00
|
|
|
#include "src/core/SkMipMap.h"
|
|
|
|
#include "src/gpu/GrContextPriv.h"
|
|
|
|
#include "src/image/SkImage_Base.h"
|
|
|
|
#include "tests/Test.h"
|
|
|
|
#include "tests/TestUtils.h"
|
|
|
|
#include "tools/ToolUtils.h"
|
|
|
|
|
2020-01-17 20:20:00 +00:00
|
|
|
// Just verify that 'actual' is entirely 'expected'
|
2019-12-19 16:19:16 +00:00
|
|
|
static void check_solid_pixmap(skiatest::Reporter* reporter,
|
|
|
|
const SkColor4f& expected, const SkPixmap& actual,
|
|
|
|
const char* label0, const char* label1, const char* label2) {
|
|
|
|
const float tols[4] = { 0.01f, 0.01f, 0.01f, 0.01f };
|
|
|
|
|
|
|
|
auto error = std::function<ComparePixmapsErrorReporter>(
|
|
|
|
[reporter, label0, label1, label2](int x, int y, const float diffs[4]) {
|
|
|
|
SkASSERT(x >= 0 && y >= 0);
|
|
|
|
ERRORF(reporter, "%s %s %s - mismatch at %d, %d (%f, %f, %f %f)",
|
|
|
|
label0, label1, label2, x, y,
|
|
|
|
diffs[0], diffs[1], diffs[2], diffs[3]);
|
|
|
|
});
|
|
|
|
|
|
|
|
CheckSolidPixels(expected, actual, tols, error);
|
|
|
|
}
|
|
|
|
|
2020-01-17 20:20:00 +00:00
|
|
|
// Create an SkImage to wrap 'backendTex'
|
|
|
|
sk_sp<SkImage> create_image(GrContext* context, const GrBackendTexture& backendTex) {
|
2019-12-19 16:19:16 +00:00
|
|
|
const GrCaps* caps = context->priv().caps();
|
|
|
|
|
|
|
|
SkImage::CompressionType compression = caps->compressionType(backendTex.getBackendFormat());
|
|
|
|
|
2020-01-27 21:11:57 +00:00
|
|
|
SkAlphaType at = SkCompressionTypeIsOpaque(compression) ? kOpaque_SkAlphaType
|
2020-01-15 17:56:52 +00:00
|
|
|
: kPremul_SkAlphaType;
|
2019-12-19 16:19:16 +00:00
|
|
|
|
2020-01-17 20:20:00 +00:00
|
|
|
return SkImage::MakeFromCompressedTexture(context,
|
|
|
|
backendTex,
|
|
|
|
kTopLeft_GrSurfaceOrigin,
|
|
|
|
at,
|
|
|
|
nullptr);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Draw the compressed backend texture (wrapped in an SkImage) into an RGBA surface, attempting
|
|
|
|
// to access all the mipMap levels.
|
|
|
|
static void check_compressed_mipmaps(GrContext* context, sk_sp<SkImage> img,
|
|
|
|
SkImage::CompressionType compressionType,
|
|
|
|
const SkColor4f expectedColors[6],
|
|
|
|
GrMipMapped mipMapped,
|
|
|
|
skiatest::Reporter* reporter, const char* label) {
|
2019-12-19 16:19:16 +00:00
|
|
|
|
|
|
|
SkImageInfo readbackSurfaceII = SkImageInfo::Make(32, 32, kRGBA_8888_SkColorType,
|
|
|
|
kPremul_SkAlphaType);
|
|
|
|
|
|
|
|
sk_sp<SkSurface> surf = SkSurface::MakeRenderTarget(context,
|
|
|
|
SkBudgeted::kNo,
|
|
|
|
readbackSurfaceII, 1,
|
|
|
|
kTopLeft_GrSurfaceOrigin,
|
|
|
|
nullptr);
|
|
|
|
if (!surf) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
SkCanvas* canvas = surf->getCanvas();
|
|
|
|
|
|
|
|
SkPaint p;
|
2020-01-15 17:56:52 +00:00
|
|
|
p.setFilterQuality(kHigh_SkFilterQuality); // to force mipMapping
|
|
|
|
p.setBlendMode(SkBlendMode::kSrc);
|
2019-12-19 16:19:16 +00:00
|
|
|
|
|
|
|
int numMipLevels = 1;
|
|
|
|
if (mipMapped == GrMipMapped::kYes) {
|
|
|
|
numMipLevels = SkMipMap::ComputeLevelCount(32, 32)+1;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (int i = 0, rectSize = 32; i < numMipLevels; ++i, rectSize /= 2) {
|
|
|
|
SkASSERT(rectSize >= 1);
|
|
|
|
|
|
|
|
canvas->clear(SK_ColorTRANSPARENT);
|
|
|
|
|
|
|
|
SkRect r = SkRect::MakeWH(rectSize, rectSize);
|
|
|
|
canvas->drawImageRect(img, r, &p);
|
|
|
|
|
|
|
|
SkImageInfo readbackII = SkImageInfo::Make(rectSize, rectSize,
|
|
|
|
kRGBA_8888_SkColorType,
|
|
|
|
kUnpremul_SkAlphaType);
|
|
|
|
SkAutoPixmapStorage actual2;
|
|
|
|
SkAssertResult(actual2.tryAlloc(readbackII));
|
|
|
|
actual2.erase(SkColors::kTransparent);
|
|
|
|
|
|
|
|
bool result = surf->readPixels(actual2, 0, 0);
|
|
|
|
REPORTER_ASSERT(reporter, result);
|
|
|
|
|
|
|
|
SkString str;
|
|
|
|
str.appendf("mip-level %d", i);
|
|
|
|
|
|
|
|
check_solid_pixmap(reporter, expectedColors[i], actual2,
|
2020-01-17 20:20:00 +00:00
|
|
|
GrCompressionTypeToStr(compressionType), label, str.c_str());
|
2019-12-19 16:19:16 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-01-17 20:20:00 +00:00
|
|
|
// Verify that we can readback from a compressed texture
|
|
|
|
static void check_readback(GrContext* context, sk_sp<SkImage> img,
|
|
|
|
SkImage::CompressionType compressionType,
|
|
|
|
const SkColor4f& expectedColor,
|
|
|
|
skiatest::Reporter* reporter, const char* label) {
|
2020-01-30 13:38:40 +00:00
|
|
|
#ifdef SK_BUILD_FOR_IOS
|
|
|
|
// reading back ETC2 is broken on Metal/iOS (skbug.com/9839)
|
|
|
|
if (context->backend() == GrBackendApi::kMetal) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2020-01-17 20:20:00 +00:00
|
|
|
SkAutoPixmapStorage actual;
|
|
|
|
|
|
|
|
SkImageInfo readBackII = SkImageInfo::Make(img->width(), img->height(),
|
|
|
|
kRGBA_8888_SkColorType,
|
|
|
|
kUnpremul_SkAlphaType);
|
|
|
|
|
|
|
|
SkAssertResult(actual.tryAlloc(readBackII));
|
|
|
|
actual.erase(SkColors::kTransparent);
|
|
|
|
|
|
|
|
bool result = img->readPixels(actual, 0, 0);
|
|
|
|
REPORTER_ASSERT(reporter, result);
|
|
|
|
|
|
|
|
check_solid_pixmap(reporter, expectedColor, actual,
|
|
|
|
GrCompressionTypeToStr(compressionType), label, "");
|
|
|
|
}
|
|
|
|
|
|
|
|
// Test initialization of compressed GrBackendTextures to a specific color
|
|
|
|
static void test_compressed_color_init(GrContext* context,
|
|
|
|
skiatest::Reporter* reporter,
|
2019-12-19 16:19:16 +00:00
|
|
|
std::function<GrBackendTexture (GrContext*,
|
|
|
|
const SkColor4f&,
|
|
|
|
GrMipMapped)> create,
|
2020-01-17 20:20:00 +00:00
|
|
|
const SkColor4f& color,
|
|
|
|
SkImage::CompressionType compression,
|
|
|
|
GrMipMapped mipMapped) {
|
2019-12-19 16:19:16 +00:00
|
|
|
GrBackendTexture backendTex = create(context, color, mipMapped);
|
|
|
|
if (!backendTex.isValid()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-01-17 20:20:00 +00:00
|
|
|
sk_sp<SkImage> img = create_image(context, backendTex);
|
|
|
|
if (!img) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-12-19 16:19:16 +00:00
|
|
|
SkColor4f expectedColors[6] = { color, color, color, color, color, color };
|
|
|
|
|
2020-01-17 20:20:00 +00:00
|
|
|
check_compressed_mipmaps(context, img, compression, expectedColors, mipMapped,
|
|
|
|
reporter, "colorinit");
|
|
|
|
check_readback(context, std::move(img), compression, color, reporter,
|
|
|
|
"solid readback");
|
2019-12-19 16:19:16 +00:00
|
|
|
|
|
|
|
context->deleteBackendTexture(backendTex);
|
|
|
|
}
|
|
|
|
|
2020-01-17 20:20:00 +00:00
|
|
|
// Create compressed data pulling the color for each mipmap level from 'levelColors'.
|
2019-12-20 14:57:41 +00:00
|
|
|
static std::unique_ptr<const char[]> make_compressed_data(SkImage::CompressionType compression,
|
|
|
|
SkColor4f levelColors[6],
|
|
|
|
GrMipMapped mipMapped) {
|
2019-12-19 16:19:16 +00:00
|
|
|
SkISize dimensions { 32, 32 };
|
|
|
|
|
|
|
|
int numMipLevels = 1;
|
|
|
|
if (mipMapped == GrMipMapped::kYes) {
|
|
|
|
numMipLevels = SkMipMap::ComputeLevelCount(dimensions.width(), dimensions.height()) + 1;
|
|
|
|
}
|
|
|
|
|
2019-12-20 14:57:41 +00:00
|
|
|
SkTArray<size_t> mipMapOffsets(numMipLevels);
|
2019-12-19 16:19:16 +00:00
|
|
|
|
2020-01-27 21:11:57 +00:00
|
|
|
size_t dataSize = SkCompressedDataSize(compression, dimensions, &mipMapOffsets,
|
|
|
|
mipMapped == GrMipMapped::kYes);
|
2019-12-20 14:57:41 +00:00
|
|
|
char* data = new char[dataSize];
|
|
|
|
|
|
|
|
for (int level = 0; level < numMipLevels; ++level) {
|
|
|
|
// We have to do this a level at a time bc we might have a different color for
|
|
|
|
// each level
|
|
|
|
GrFillInCompressedData(compression, dimensions,
|
|
|
|
GrMipMapped::kNo, &data[mipMapOffsets[level]], levelColors[level]);
|
2019-12-19 16:19:16 +00:00
|
|
|
|
2020-02-07 15:36:46 +00:00
|
|
|
dimensions = {std::max(1, dimensions.width() /2), std::max(1, dimensions.height()/2)};
|
2019-12-19 16:19:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return std::unique_ptr<const char[]>(data);
|
|
|
|
}
|
|
|
|
|
2020-01-17 20:20:00 +00:00
|
|
|
// Verify that we can initialize a compressed backend texture with data (esp.
|
|
|
|
// the mipmap levels).
|
2019-12-19 16:19:16 +00:00
|
|
|
static void test_compressed_data_init(GrContext* context,
|
|
|
|
skiatest::Reporter* reporter,
|
|
|
|
std::function<GrBackendTexture (GrContext*,
|
|
|
|
const char* data,
|
|
|
|
size_t dataSize,
|
|
|
|
GrMipMapped)> create,
|
2019-12-20 14:57:41 +00:00
|
|
|
SkImage::CompressionType compression,
|
2019-12-19 16:19:16 +00:00
|
|
|
GrMipMapped mipMapped) {
|
|
|
|
|
|
|
|
SkColor4f expectedColors[6] = {
|
|
|
|
{ 1.0f, 0.0f, 0.0f, 1.0f }, // R
|
|
|
|
{ 0.0f, 1.0f, 0.0f, 1.0f }, // G
|
|
|
|
{ 0.0f, 0.0f, 1.0f, 1.0f }, // B
|
|
|
|
{ 0.0f, 1.0f, 1.0f, 1.0f }, // C
|
|
|
|
{ 1.0f, 0.0f, 1.0f, 1.0f }, // M
|
|
|
|
{ 1.0f, 1.0f, 0.0f, 1.0f }, // Y
|
|
|
|
};
|
|
|
|
|
2019-12-20 14:57:41 +00:00
|
|
|
std::unique_ptr<const char[]> data(make_compressed_data(compression, expectedColors,
|
|
|
|
mipMapped));
|
2020-01-27 21:11:57 +00:00
|
|
|
size_t dataSize = SkCompressedDataSize(compression, { 32, 32 }, nullptr,
|
|
|
|
mipMapped == GrMipMapped::kYes);
|
2019-12-19 16:19:16 +00:00
|
|
|
|
|
|
|
GrBackendTexture backendTex = create(context, data.get(), dataSize, mipMapped);
|
|
|
|
if (!backendTex.isValid()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-01-17 20:20:00 +00:00
|
|
|
sk_sp<SkImage> img = create_image(context, backendTex);
|
|
|
|
if (!img) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
check_compressed_mipmaps(context, img, compression, expectedColors,
|
|
|
|
mipMapped, reporter, "pixmap");
|
|
|
|
check_readback(context, std::move(img), compression, expectedColors[0], reporter,
|
|
|
|
"data readback");
|
2019-12-19 16:19:16 +00:00
|
|
|
|
|
|
|
context->deleteBackendTexture(backendTex);
|
|
|
|
}
|
|
|
|
|
|
|
|
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(CompressedBackendAllocationTest, reporter, ctxInfo) {
|
|
|
|
GrContext* context = ctxInfo.grContext();
|
|
|
|
const GrCaps* caps = context->priv().caps();
|
|
|
|
|
|
|
|
struct {
|
|
|
|
SkImage::CompressionType fCompression;
|
|
|
|
SkColor4f fColor;
|
|
|
|
} combinations[] = {
|
2020-01-13 18:02:26 +00:00
|
|
|
{ SkImage::CompressionType::kETC2_RGB8_UNORM, SkColors::kRed },
|
2020-01-17 20:20:00 +00:00
|
|
|
{ SkImage::CompressionType::kBC1_RGB8_UNORM, SkColors::kBlue },
|
2020-01-15 17:56:52 +00:00
|
|
|
{ SkImage::CompressionType::kBC1_RGBA8_UNORM, SkColors::kTransparent },
|
2019-12-19 16:19:16 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
for (auto combo : combinations) {
|
|
|
|
GrBackendFormat format = context->compressedBackendFormat(combo.fCompression);
|
|
|
|
if (!format.isValid()) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!caps->isFormatTexturable(format)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (auto mipMapped : { GrMipMapped::kNo, GrMipMapped::kYes }) {
|
|
|
|
if (GrMipMapped::kYes == mipMapped && !caps->mipMapSupport()) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// color initialized
|
|
|
|
{
|
|
|
|
auto createWithColorMtd = [format](GrContext* context,
|
|
|
|
const SkColor4f& color,
|
|
|
|
GrMipMapped mipMapped) {
|
|
|
|
return context->createCompressedBackendTexture(32, 32, format, color,
|
|
|
|
mipMapped, GrProtected::kNo);
|
|
|
|
};
|
|
|
|
|
|
|
|
test_compressed_color_init(context, reporter, createWithColorMtd,
|
2020-01-17 20:20:00 +00:00
|
|
|
combo.fColor, combo.fCompression, mipMapped);
|
2019-12-19 16:19:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// data initialized
|
|
|
|
{
|
|
|
|
auto createWithDataMtd = [format](GrContext* context,
|
|
|
|
const char* data, size_t dataSize,
|
|
|
|
GrMipMapped mipMapped) {
|
|
|
|
return context->createCompressedBackendTexture(32, 32, format, data, dataSize,
|
|
|
|
mipMapped, GrProtected::kNo);
|
|
|
|
};
|
|
|
|
|
2019-12-20 14:57:41 +00:00
|
|
|
test_compressed_data_init(context, reporter, createWithDataMtd,
|
|
|
|
combo.fCompression, mipMapped);
|
2019-12-19 16:19:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|