2013-03-28 13:49:22 +00:00
|
|
|
/*
|
|
|
|
|
* Copyright 2013 Google Inc.
|
|
|
|
|
*
|
|
|
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
|
|
|
* found in the LICENSE file.
|
|
|
|
|
*/
|
2014-01-10 22:08:27 +00:00
|
|
|
|
2018-09-04 17:27:00 +00:00
|
|
|
#include "GrBackendSurface.h"
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
#include "GrContext.h"
|
2017-01-18 15:08:39 +00:00
|
|
|
#include "GrContextPriv.h"
|
2018-02-03 00:25:12 +00:00
|
|
|
#include "GrGpu.h"
|
2018-02-03 01:32:49 +00:00
|
|
|
#include "GrGpuResourcePriv.h"
|
|
|
|
|
#include "GrRenderTargetContext.h"
|
2016-05-04 19:01:58 +00:00
|
|
|
#include "GrResourceProvider.h"
|
2018-05-31 18:27:17 +00:00
|
|
|
#include "SkCanvas.h"
|
|
|
|
|
#include "SkData.h"
|
|
|
|
|
#include "SkDevice.h"
|
2018-02-03 01:32:49 +00:00
|
|
|
#include "SkGpuDevice.h"
|
2018-05-31 18:27:17 +00:00
|
|
|
#include "SkImage_Base.h"
|
2018-02-03 01:32:49 +00:00
|
|
|
#include "SkImage_Gpu.h"
|
2018-05-31 18:27:17 +00:00
|
|
|
#include "SkOverdrawCanvas.h"
|
|
|
|
|
#include "SkPath.h"
|
|
|
|
|
#include "SkRegion.h"
|
|
|
|
|
#include "SkRRect.h"
|
|
|
|
|
#include "SkSurface.h"
|
2018-02-03 01:32:49 +00:00
|
|
|
#include "SkSurface_Gpu.h"
|
2018-05-31 18:27:17 +00:00
|
|
|
#include "SkUtils.h"
|
|
|
|
|
#include "Test.h"
|
2013-03-28 13:49:22 +00:00
|
|
|
|
2018-09-19 15:31:27 +00:00
|
|
|
#include <functional>
|
|
|
|
|
#include <initializer_list>
|
|
|
|
|
#include <vector>
|
|
|
|
|
|
2018-02-07 21:05:29 +00:00
|
|
|
#include "sk_tool_utils.h"
|
|
|
|
|
|
2015-06-23 21:38:48 +00:00
|
|
|
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
static void release_direct_surface_storage(void* pixels, void* context) {
|
2014-06-27 13:48:14 +00:00
|
|
|
SkASSERT(pixels == context);
|
|
|
|
|
sk_free(pixels);
|
|
|
|
|
}
|
2016-03-24 01:59:25 +00:00
|
|
|
static sk_sp<SkSurface> create_surface(SkAlphaType at = kPremul_SkAlphaType,
|
|
|
|
|
SkImageInfo* requestedInfo = nullptr) {
|
2015-06-23 21:38:48 +00:00
|
|
|
const SkImageInfo info = SkImageInfo::MakeN32(10, 10, at);
|
2014-02-13 17:14:46 +00:00
|
|
|
if (requestedInfo) {
|
|
|
|
|
*requestedInfo = info;
|
|
|
|
|
}
|
2016-03-24 01:59:25 +00:00
|
|
|
return SkSurface::MakeRaster(info);
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
}
|
2016-03-24 01:59:25 +00:00
|
|
|
static sk_sp<SkSurface> create_direct_surface(SkAlphaType at = kPremul_SkAlphaType,
|
|
|
|
|
SkImageInfo* requestedInfo = nullptr) {
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
const SkImageInfo info = SkImageInfo::MakeN32(10, 10, at);
|
|
|
|
|
if (requestedInfo) {
|
|
|
|
|
*requestedInfo = info;
|
|
|
|
|
}
|
|
|
|
|
const size_t rowBytes = info.minRowBytes();
|
2017-10-03 18:47:21 +00:00
|
|
|
void* storage = sk_malloc_throw(info.computeByteSize(rowBytes));
|
2016-03-24 01:59:25 +00:00
|
|
|
return SkSurface::MakeRasterDirectReleaseProc(info, storage, rowBytes,
|
|
|
|
|
release_direct_surface_storage,
|
|
|
|
|
storage);
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
}
|
2016-03-24 01:59:25 +00:00
|
|
|
static sk_sp<SkSurface> create_gpu_surface(GrContext* context, SkAlphaType at = kPremul_SkAlphaType,
|
|
|
|
|
SkImageInfo* requestedInfo = nullptr) {
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
const SkImageInfo info = SkImageInfo::MakeN32(10, 10, at);
|
|
|
|
|
if (requestedInfo) {
|
|
|
|
|
*requestedInfo = info;
|
|
|
|
|
}
|
2016-07-26 18:38:17 +00:00
|
|
|
return SkSurface::MakeRenderTarget(context, SkBudgeted::kNo, info);
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
}
|
2016-03-24 01:59:25 +00:00
|
|
|
static sk_sp<SkSurface> create_gpu_scratch_surface(GrContext* context,
|
|
|
|
|
SkAlphaType at = kPremul_SkAlphaType,
|
|
|
|
|
SkImageInfo* requestedInfo = nullptr) {
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
const SkImageInfo info = SkImageInfo::MakeN32(10, 10, at);
|
|
|
|
|
if (requestedInfo) {
|
|
|
|
|
*requestedInfo = info;
|
2013-03-28 13:49:22 +00:00
|
|
|
}
|
2016-07-26 18:38:17 +00:00
|
|
|
return SkSurface::MakeRenderTarget(context, SkBudgeted::kYes, info);
|
2013-03-28 13:49:22 +00:00
|
|
|
}
|
|
|
|
|
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
DEF_TEST(SurfaceEmpty, reporter) {
|
2014-12-31 20:31:43 +00:00
|
|
|
const SkImageInfo info = SkImageInfo::Make(0, 0, kN32_SkColorType, kPremul_SkAlphaType);
|
2016-03-24 01:59:25 +00:00
|
|
|
REPORTER_ASSERT(reporter, nullptr == SkSurface::MakeRaster(info));
|
|
|
|
|
REPORTER_ASSERT(reporter, nullptr == SkSurface::MakeRasterDirect(info, nullptr, 0));
|
2014-12-31 20:31:43 +00:00
|
|
|
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
}
|
2016-06-28 15:07:26 +00:00
|
|
|
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceEmpty_Gpu, reporter, ctxInfo) {
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
const SkImageInfo info = SkImageInfo::Make(0, 0, kN32_SkColorType, kPremul_SkAlphaType);
|
|
|
|
|
REPORTER_ASSERT(reporter, nullptr ==
|
2016-07-26 18:38:17 +00:00
|
|
|
SkSurface::MakeRenderTarget(ctxInfo.grContext(), SkBudgeted::kNo, info));
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
}
|
2015-06-16 15:07:16 +00:00
|
|
|
|
2018-02-03 01:32:49 +00:00
|
|
|
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(GrContext_colorTypeSupportedAsSurface, reporter, ctxInfo) {
|
|
|
|
|
for (int ct = 0; ct < kLastEnum_SkColorType; ++ct) {
|
|
|
|
|
static constexpr int kSize = 10;
|
|
|
|
|
|
|
|
|
|
SkColorType colorType = static_cast<SkColorType>(ct);
|
|
|
|
|
auto info = SkImageInfo::Make(kSize, kSize, colorType, kOpaque_SkAlphaType, nullptr);
|
|
|
|
|
bool can = ctxInfo.grContext()->colorTypeSupportedAsSurface(colorType);
|
|
|
|
|
auto surf = SkSurface::MakeRenderTarget(ctxInfo.grContext(), SkBudgeted::kYes, info, 1,
|
|
|
|
|
nullptr);
|
|
|
|
|
REPORTER_ASSERT(reporter, can == SkToBool(surf), "ct: %d, can: %d, surf: %d",
|
|
|
|
|
colorType, can, SkToBool(surf));
|
|
|
|
|
|
|
|
|
|
auto* gpu = ctxInfo.grContext()->contextPriv().getGpu();
|
|
|
|
|
GrBackendTexture backendTex = gpu->createTestingOnlyBackendTexture(
|
Dest color space no longer impacts mipmaps or texture sampling
PS5: Removes SkDestinationSurfaceColorMode, tracking of mipmap
mode on GrTexture, sRGB decode state per-texture. Because we
were often choosing sRGB configs for RGB color types, legacy
rendering would then be incorrect (too dark). So...
PS7: Stops ever using sRGB pixel configs when translating
image info or color type. Also removes a bunch of GrCaps bits
and a GrContextOption that are no longer relevant.
PS9: Adjusts surface creation unit test expectations, and
changes the raster rules accordingly.
At this point, sRGB configs are (obviously) going to be broken.
Locally, I ran 8888, gl, and the gbr- versions of both. Across
all GMs x configs, there are 13 diffs. 12 are GMs that create
surfaces with a color-space attached (and thus, the offscreen
is no longer getting sRGB pixel config). The only remainder
constructs an SkPictureImageGenerator, (with an attached color
space) and renders it to the gbr-gl canvas, which triggers a
a tagged surface inside the generator.
Bug: skia:
Change-Id: Ie5edfa157dd799f3121e8173fc4f97f6c8ed6789
Reviewed-on: https://skia-review.googlesource.com/131282
Commit-Queue: Brian Osman <brianosman@google.com>
Reviewed-by: Mike Klein <mtklein@google.com>
Reviewed-by: Brian Salomon <bsalomon@google.com>
2018-06-01 16:25:08 +00:00
|
|
|
nullptr, kSize, kSize, colorType, true, GrMipMapped::kNo);
|
2018-02-03 01:32:49 +00:00
|
|
|
surf = SkSurface::MakeFromBackendTexture(ctxInfo.grContext(), backendTex,
|
|
|
|
|
kTopLeft_GrSurfaceOrigin, 0, colorType, nullptr,
|
|
|
|
|
nullptr);
|
|
|
|
|
REPORTER_ASSERT(reporter, can == SkToBool(surf), "ct: %d, can: %d, surf: %d",
|
|
|
|
|
colorType, can, SkToBool(surf));
|
|
|
|
|
|
|
|
|
|
surf = SkSurface::MakeFromBackendTextureAsRenderTarget(ctxInfo.grContext(), backendTex,
|
|
|
|
|
kTopLeft_GrSurfaceOrigin, 1,
|
|
|
|
|
colorType, nullptr, nullptr);
|
|
|
|
|
REPORTER_ASSERT(reporter, can == SkToBool(surf), "ct: %d, can: %d, surf: %d",
|
|
|
|
|
colorType, can, SkToBool(surf));
|
|
|
|
|
|
|
|
|
|
surf.reset();
|
|
|
|
|
ctxInfo.grContext()->flush();
|
|
|
|
|
if (backendTex.isValid()) {
|
2018-03-09 14:33:19 +00:00
|
|
|
gpu->deleteTestingOnlyBackendTexture(backendTex);
|
2018-02-03 01:32:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static constexpr int kSampleCnt = 2;
|
|
|
|
|
|
|
|
|
|
can = ctxInfo.grContext()->maxSurfaceSampleCountForColorType(colorType) >= kSampleCnt;
|
|
|
|
|
surf = SkSurface::MakeRenderTarget(ctxInfo.grContext(), SkBudgeted::kYes, info, kSampleCnt,
|
|
|
|
|
nullptr);
|
|
|
|
|
REPORTER_ASSERT(reporter, can == SkToBool(surf), "ct: %d, can: %d, surf: %d",
|
|
|
|
|
colorType, can, SkToBool(surf));
|
|
|
|
|
|
Dest color space no longer impacts mipmaps or texture sampling
PS5: Removes SkDestinationSurfaceColorMode, tracking of mipmap
mode on GrTexture, sRGB decode state per-texture. Because we
were often choosing sRGB configs for RGB color types, legacy
rendering would then be incorrect (too dark). So...
PS7: Stops ever using sRGB pixel configs when translating
image info or color type. Also removes a bunch of GrCaps bits
and a GrContextOption that are no longer relevant.
PS9: Adjusts surface creation unit test expectations, and
changes the raster rules accordingly.
At this point, sRGB configs are (obviously) going to be broken.
Locally, I ran 8888, gl, and the gbr- versions of both. Across
all GMs x configs, there are 13 diffs. 12 are GMs that create
surfaces with a color-space attached (and thus, the offscreen
is no longer getting sRGB pixel config). The only remainder
constructs an SkPictureImageGenerator, (with an attached color
space) and renders it to the gbr-gl canvas, which triggers a
a tagged surface inside the generator.
Bug: skia:
Change-Id: Ie5edfa157dd799f3121e8173fc4f97f6c8ed6789
Reviewed-on: https://skia-review.googlesource.com/131282
Commit-Queue: Brian Osman <brianosman@google.com>
Reviewed-by: Mike Klein <mtklein@google.com>
Reviewed-by: Brian Salomon <bsalomon@google.com>
2018-06-01 16:25:08 +00:00
|
|
|
backendTex = gpu->createTestingOnlyBackendTexture(nullptr, kSize, kSize, colorType, true,
|
|
|
|
|
GrMipMapped::kNo);
|
2018-02-03 01:32:49 +00:00
|
|
|
surf = SkSurface::MakeFromBackendTexture(ctxInfo.grContext(), backendTex,
|
|
|
|
|
kTopLeft_GrSurfaceOrigin, kSampleCnt, colorType,
|
|
|
|
|
nullptr, nullptr);
|
|
|
|
|
REPORTER_ASSERT(reporter, can == SkToBool(surf),
|
|
|
|
|
"colorTypeSupportedAsSurface:%d, surf:%d, ct:%d", can, SkToBool(surf),
|
|
|
|
|
colorType);
|
|
|
|
|
// Ensure that the sample count stored on the resulting SkSurface is a valid value.
|
|
|
|
|
if (surf) {
|
|
|
|
|
auto* rtc = ((SkSurface_Gpu*)(surf.get()))->getDevice()->accessRenderTargetContext();
|
|
|
|
|
int storedCnt = rtc->numStencilSamples();
|
2018-05-11 14:14:21 +00:00
|
|
|
int allowedCnt = ctxInfo.grContext()->contextPriv().caps()->getSampleCount(
|
2018-02-03 01:32:49 +00:00
|
|
|
storedCnt, rtc->asSurfaceProxy()->config());
|
|
|
|
|
REPORTER_ASSERT(reporter, storedCnt == allowedCnt,
|
|
|
|
|
"Should store an allowed sample count (%d vs %d)", allowedCnt,
|
|
|
|
|
storedCnt);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
surf = SkSurface::MakeFromBackendTextureAsRenderTarget(ctxInfo.grContext(), backendTex,
|
|
|
|
|
kTopLeft_GrSurfaceOrigin, kSampleCnt,
|
|
|
|
|
colorType, nullptr, nullptr);
|
|
|
|
|
REPORTER_ASSERT(reporter, can == SkToBool(surf),
|
|
|
|
|
"colorTypeSupportedAsSurface:%d, surf:%d, ct:%d", can, SkToBool(surf),
|
|
|
|
|
colorType);
|
|
|
|
|
if (surf) {
|
|
|
|
|
auto* rtc = ((SkSurface_Gpu*)(surf.get()))->getDevice()->accessRenderTargetContext();
|
|
|
|
|
int storedCnt = rtc->numStencilSamples();
|
2018-05-11 14:14:21 +00:00
|
|
|
int allowedCnt = ctxInfo.grContext()->contextPriv().caps()->getSampleCount(
|
2018-02-03 01:32:49 +00:00
|
|
|
storedCnt, rtc->asSurfaceProxy()->config());
|
|
|
|
|
REPORTER_ASSERT(reporter, storedCnt == allowedCnt,
|
|
|
|
|
"Should store an allowed sample count (%d vs %d)", allowedCnt,
|
|
|
|
|
storedCnt);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
surf.reset();
|
|
|
|
|
ctxInfo.grContext()->flush();
|
|
|
|
|
if (backendTex.isValid()) {
|
2018-03-09 14:33:19 +00:00
|
|
|
gpu->deleteTestingOnlyBackendTexture(backendTex);
|
2018-02-03 01:32:49 +00:00
|
|
|
}
|
2018-08-29 16:56:23 +00:00
|
|
|
|
|
|
|
|
GrBackendRenderTarget backendRenderTarget = gpu->createTestingOnlyBackendRenderTarget(
|
|
|
|
|
16, 16, SkColorTypeToGrColorType(colorType));
|
|
|
|
|
can = ctxInfo.grContext()->colorTypeSupportedAsSurface(colorType);
|
|
|
|
|
surf = SkSurface::MakeFromBackendRenderTarget(ctxInfo.grContext(), backendRenderTarget,
|
|
|
|
|
kTopLeft_GrSurfaceOrigin, colorType, nullptr,
|
|
|
|
|
nullptr);
|
|
|
|
|
REPORTER_ASSERT(reporter, can == SkToBool(surf), "ct: %d, can: %d, surf: %d", colorType,
|
|
|
|
|
can, SkToBool(surf));
|
|
|
|
|
surf.reset();
|
|
|
|
|
ctxInfo.grContext()->flush();
|
|
|
|
|
if (backendRenderTarget.isValid()) {
|
|
|
|
|
gpu->deleteTestingOnlyBackendRenderTarget(backendRenderTarget);
|
|
|
|
|
}
|
2018-02-03 01:32:49 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(GrContext_maxSurfaceSamplesForColorType, reporter, ctxInfo) {
|
|
|
|
|
for (int ct = 0; ct < kLastEnum_SkColorType; ++ct) {
|
|
|
|
|
static constexpr int kSize = 10;
|
|
|
|
|
|
|
|
|
|
SkColorType colorType = static_cast<SkColorType>(ct);
|
|
|
|
|
int max = ctxInfo.grContext()->maxSurfaceSampleCountForColorType(colorType);
|
|
|
|
|
if (!max) {
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
auto* gpu = ctxInfo.grContext()->contextPriv().getGpu();
|
|
|
|
|
GrBackendTexture backendTex = gpu->createTestingOnlyBackendTexture(
|
Dest color space no longer impacts mipmaps or texture sampling
PS5: Removes SkDestinationSurfaceColorMode, tracking of mipmap
mode on GrTexture, sRGB decode state per-texture. Because we
were often choosing sRGB configs for RGB color types, legacy
rendering would then be incorrect (too dark). So...
PS7: Stops ever using sRGB pixel configs when translating
image info or color type. Also removes a bunch of GrCaps bits
and a GrContextOption that are no longer relevant.
PS9: Adjusts surface creation unit test expectations, and
changes the raster rules accordingly.
At this point, sRGB configs are (obviously) going to be broken.
Locally, I ran 8888, gl, and the gbr- versions of both. Across
all GMs x configs, there are 13 diffs. 12 are GMs that create
surfaces with a color-space attached (and thus, the offscreen
is no longer getting sRGB pixel config). The only remainder
constructs an SkPictureImageGenerator, (with an attached color
space) and renders it to the gbr-gl canvas, which triggers a
a tagged surface inside the generator.
Bug: skia:
Change-Id: Ie5edfa157dd799f3121e8173fc4f97f6c8ed6789
Reviewed-on: https://skia-review.googlesource.com/131282
Commit-Queue: Brian Osman <brianosman@google.com>
Reviewed-by: Mike Klein <mtklein@google.com>
Reviewed-by: Brian Salomon <bsalomon@google.com>
2018-06-01 16:25:08 +00:00
|
|
|
nullptr, kSize, kSize, colorType, true, GrMipMapped::kNo);
|
2018-03-23 15:26:11 +00:00
|
|
|
if (!backendTex.isValid()) {
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
SkScopeExit freeTex([&backendTex, gpu] {gpu->deleteTestingOnlyBackendTexture(backendTex);});
|
2018-02-03 01:32:49 +00:00
|
|
|
auto info = SkImageInfo::Make(kSize, kSize, colorType, kOpaque_SkAlphaType, nullptr);
|
|
|
|
|
auto surf = SkSurface::MakeFromBackendTexture(ctxInfo.grContext(), backendTex,
|
|
|
|
|
kTopLeft_GrSurfaceOrigin, max,
|
|
|
|
|
colorType, nullptr, nullptr);
|
|
|
|
|
REPORTER_ASSERT(reporter, surf);
|
|
|
|
|
if (!surf) {
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
int sampleCnt = ((SkSurface_Gpu*)(surf.get()))
|
|
|
|
|
->getDevice()
|
|
|
|
|
->accessRenderTargetContext()
|
|
|
|
|
->numStencilSamples();
|
|
|
|
|
REPORTER_ASSERT(reporter, sampleCnt == max, "Exected: %d, actual: %d", max, sampleCnt);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
static void test_canvas_peek(skiatest::Reporter* reporter,
|
2016-03-24 01:59:25 +00:00
|
|
|
sk_sp<SkSurface>& surface,
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
const SkImageInfo& requestInfo,
|
|
|
|
|
bool expectPeekSuccess) {
|
2014-02-13 17:14:46 +00:00
|
|
|
const SkColor color = SK_ColorRED;
|
|
|
|
|
const SkPMColor pmcolor = SkPreMultiplyColor(color);
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
surface->getCanvas()->clear(color);
|
|
|
|
|
|
2016-03-09 22:26:26 +00:00
|
|
|
SkPixmap pmap;
|
|
|
|
|
bool success = surface->getCanvas()->peekPixels(&pmap);
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
REPORTER_ASSERT(reporter, expectPeekSuccess == success);
|
|
|
|
|
|
2016-03-09 22:26:26 +00:00
|
|
|
SkPixmap pmap2;
|
|
|
|
|
const void* addr2 = surface->peekPixels(&pmap2) ? pmap2.addr() : nullptr;
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
|
|
|
|
|
if (success) {
|
2016-03-09 22:26:26 +00:00
|
|
|
REPORTER_ASSERT(reporter, requestInfo == pmap.info());
|
|
|
|
|
REPORTER_ASSERT(reporter, requestInfo.minRowBytes() <= pmap.rowBytes());
|
|
|
|
|
REPORTER_ASSERT(reporter, pmcolor == *pmap.addr32());
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
|
2016-03-09 22:26:26 +00:00
|
|
|
REPORTER_ASSERT(reporter, pmap.addr() == pmap2.addr());
|
|
|
|
|
REPORTER_ASSERT(reporter, pmap.info() == pmap2.info());
|
|
|
|
|
REPORTER_ASSERT(reporter, pmap.rowBytes() == pmap2.rowBytes());
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
} else {
|
|
|
|
|
REPORTER_ASSERT(reporter, nullptr == addr2);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
DEF_TEST(SurfaceCanvasPeek, reporter) {
|
|
|
|
|
for (auto& surface_func : { &create_surface, &create_direct_surface }) {
|
|
|
|
|
SkImageInfo requestInfo;
|
2016-03-24 01:59:25 +00:00
|
|
|
auto surface(surface_func(kPremul_SkAlphaType, &requestInfo));
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
test_canvas_peek(reporter, surface, requestInfo, true);
|
|
|
|
|
}
|
|
|
|
|
}
|
2016-06-28 15:07:26 +00:00
|
|
|
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceCanvasPeek_Gpu, reporter, ctxInfo) {
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
for (auto& surface_func : { &create_gpu_surface, &create_gpu_scratch_surface }) {
|
|
|
|
|
SkImageInfo requestInfo;
|
2016-05-11 13:33:06 +00:00
|
|
|
auto surface(surface_func(ctxInfo.grContext(), kPremul_SkAlphaType, &requestInfo));
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
test_canvas_peek(reporter, surface, requestInfo, false);
|
2014-02-13 17:14:46 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2016-03-24 01:59:25 +00:00
|
|
|
static void test_snapshot_alphatype(skiatest::Reporter* reporter, const sk_sp<SkSurface>& surface,
|
2016-08-17 21:01:05 +00:00
|
|
|
SkAlphaType expectedAlphaType) {
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
REPORTER_ASSERT(reporter, surface);
|
|
|
|
|
if (surface) {
|
2016-03-17 17:51:11 +00:00
|
|
|
sk_sp<SkImage> image(surface->makeImageSnapshot());
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
REPORTER_ASSERT(reporter, image);
|
|
|
|
|
if (image) {
|
2016-08-17 21:01:05 +00:00
|
|
|
REPORTER_ASSERT(reporter, image->alphaType() == expectedAlphaType);
|
2015-06-09 19:16:53 +00:00
|
|
|
}
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
DEF_TEST(SurfaceSnapshotAlphaType, reporter) {
|
|
|
|
|
for (auto& surface_func : { &create_surface, &create_direct_surface }) {
|
2016-08-17 21:01:05 +00:00
|
|
|
for (auto& at: { kOpaque_SkAlphaType, kPremul_SkAlphaType, kUnpremul_SkAlphaType }) {
|
|
|
|
|
auto surface(surface_func(at, nullptr));
|
|
|
|
|
test_snapshot_alphatype(reporter, surface, at);
|
2015-06-09 19:16:53 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2016-06-28 15:07:26 +00:00
|
|
|
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceSnapshotAlphaType_Gpu, reporter, ctxInfo) {
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
for (auto& surface_func : { &create_gpu_surface, &create_gpu_scratch_surface }) {
|
2016-08-17 21:01:05 +00:00
|
|
|
// GPU doesn't support creating unpremul surfaces, so only test opaque + premul
|
|
|
|
|
for (auto& at : { kOpaque_SkAlphaType, kPremul_SkAlphaType }) {
|
|
|
|
|
auto surface(surface_func(ctxInfo.grContext(), at, nullptr));
|
|
|
|
|
test_snapshot_alphatype(reporter, surface, at);
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
}
|
2015-06-23 21:38:48 +00:00
|
|
|
}
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
}
|
|
|
|
|
|
2018-04-05 13:30:38 +00:00
|
|
|
static void test_backend_texture_access_copy_on_write(
|
|
|
|
|
skiatest::Reporter* reporter, SkSurface* surface, SkSurface::BackendHandleAccess access) {
|
|
|
|
|
GrBackendTexture tex1 = surface->getBackendTexture(access);
|
|
|
|
|
sk_sp<SkImage> snap1(surface->makeImageSnapshot());
|
|
|
|
|
|
|
|
|
|
GrBackendTexture tex2 = surface->getBackendTexture(access);
|
|
|
|
|
sk_sp<SkImage> snap2(surface->makeImageSnapshot());
|
|
|
|
|
|
|
|
|
|
// If the access mode triggers CoW, then the backend objects should reflect it.
|
|
|
|
|
REPORTER_ASSERT(reporter, GrBackendTexture::TestingOnly_Equals(tex1, tex2) == (snap1 == snap2));
|
2015-06-23 21:38:48 +00:00
|
|
|
}
|
|
|
|
|
|
2018-04-05 13:30:38 +00:00
|
|
|
static void test_backend_rendertarget_access_copy_on_write(
|
|
|
|
|
skiatest::Reporter* reporter, SkSurface* surface, SkSurface::BackendHandleAccess access) {
|
|
|
|
|
GrBackendRenderTarget rt1 = surface->getBackendRenderTarget(access);
|
2016-03-17 17:51:11 +00:00
|
|
|
sk_sp<SkImage> snap1(surface->makeImageSnapshot());
|
2015-08-06 14:04:51 +00:00
|
|
|
|
2018-04-05 13:30:38 +00:00
|
|
|
GrBackendRenderTarget rt2 = surface->getBackendRenderTarget(access);
|
2016-03-17 17:51:11 +00:00
|
|
|
sk_sp<SkImage> snap2(surface->makeImageSnapshot());
|
2015-08-06 14:04:51 +00:00
|
|
|
|
|
|
|
|
// If the access mode triggers CoW, then the backend objects should reflect it.
|
2018-04-05 13:30:38 +00:00
|
|
|
REPORTER_ASSERT(reporter, GrBackendRenderTarget::TestingOnly_Equals(rt1, rt2) ==
|
|
|
|
|
(snap1 == snap2));
|
2015-08-06 14:04:51 +00:00
|
|
|
}
|
2018-04-05 13:30:38 +00:00
|
|
|
|
|
|
|
|
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceBackendSurfaceAccessCopyOnWrite_Gpu, reporter, ctxInfo) {
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
const SkSurface::BackendHandleAccess accessModes[] = {
|
|
|
|
|
SkSurface::kFlushRead_BackendHandleAccess,
|
|
|
|
|
SkSurface::kFlushWrite_BackendHandleAccess,
|
|
|
|
|
SkSurface::kDiscardWrite_BackendHandleAccess,
|
|
|
|
|
};
|
2018-04-05 13:30:38 +00:00
|
|
|
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
for (auto& surface_func : { &create_gpu_surface, &create_gpu_scratch_surface }) {
|
2018-04-05 13:30:38 +00:00
|
|
|
for (auto& accessMode : accessModes) {
|
|
|
|
|
{
|
2016-05-11 13:33:06 +00:00
|
|
|
auto surface(surface_func(ctxInfo.grContext(), kPremul_SkAlphaType, nullptr));
|
2018-04-05 13:30:38 +00:00
|
|
|
test_backend_texture_access_copy_on_write(reporter, surface.get(), accessMode);
|
|
|
|
|
}
|
|
|
|
|
{
|
|
|
|
|
auto surface(surface_func(ctxInfo.grContext(), kPremul_SkAlphaType, nullptr));
|
|
|
|
|
test_backend_rendertarget_access_copy_on_write(reporter, surface.get(), accessMode);
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2016-07-21 14:17:54 +00:00
|
|
|
|
2018-04-05 13:30:38 +00:00
|
|
|
template<typename Type, Type(SkSurface::*func)(SkSurface::BackendHandleAccess)>
|
|
|
|
|
static void test_backend_unique_id(skiatest::Reporter* reporter, SkSurface* surface) {
|
2016-03-17 17:51:11 +00:00
|
|
|
sk_sp<SkImage> image0(surface->makeImageSnapshot());
|
2018-04-05 13:30:38 +00:00
|
|
|
|
|
|
|
|
Type obj = (surface->*func)(SkSurface::kFlushRead_BackendHandleAccess);
|
|
|
|
|
REPORTER_ASSERT(reporter, obj.isValid());
|
2016-03-17 17:51:11 +00:00
|
|
|
sk_sp<SkImage> image1(surface->makeImageSnapshot());
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
// just read access should not affect the snapshot
|
|
|
|
|
REPORTER_ASSERT(reporter, image0->uniqueID() == image1->uniqueID());
|
|
|
|
|
|
2018-04-05 13:30:38 +00:00
|
|
|
obj = (surface->*func)(SkSurface::kFlushWrite_BackendHandleAccess);
|
|
|
|
|
REPORTER_ASSERT(reporter, obj.isValid());
|
2016-03-17 17:51:11 +00:00
|
|
|
sk_sp<SkImage> image2(surface->makeImageSnapshot());
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
// expect a new image, since we claimed we would write
|
|
|
|
|
REPORTER_ASSERT(reporter, image0->uniqueID() != image2->uniqueID());
|
|
|
|
|
|
2018-04-05 13:30:38 +00:00
|
|
|
obj = (surface->*func)(SkSurface::kDiscardWrite_BackendHandleAccess);
|
|
|
|
|
REPORTER_ASSERT(reporter, obj.isValid());
|
2016-03-17 17:51:11 +00:00
|
|
|
sk_sp<SkImage> image3(surface->makeImageSnapshot());
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
// expect a new(er) image, since we claimed we would write
|
|
|
|
|
REPORTER_ASSERT(reporter, image0->uniqueID() != image3->uniqueID());
|
|
|
|
|
REPORTER_ASSERT(reporter, image2->uniqueID() != image3->uniqueID());
|
|
|
|
|
}
|
2018-04-05 13:30:38 +00:00
|
|
|
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
// No CPU test.
|
2016-04-12 16:59:58 +00:00
|
|
|
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceBackendHandleAccessIDs_Gpu, reporter, ctxInfo) {
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
for (auto& surface_func : { &create_gpu_surface, &create_gpu_scratch_surface }) {
|
2018-04-05 13:30:38 +00:00
|
|
|
{
|
|
|
|
|
auto surface(surface_func(ctxInfo.grContext(), kPremul_SkAlphaType, nullptr));
|
|
|
|
|
test_backend_unique_id<GrBackendTexture, &SkSurface::getBackendTexture>(reporter,
|
|
|
|
|
surface.get());
|
|
|
|
|
}
|
|
|
|
|
{
|
|
|
|
|
auto surface(surface_func(ctxInfo.grContext(), kPremul_SkAlphaType, nullptr));
|
|
|
|
|
test_backend_unique_id<GrBackendRenderTarget, &SkSurface::getBackendRenderTarget>(
|
|
|
|
|
reporter, surface.get());
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Verify that the right canvas commands trigger a copy on write.
|
|
|
|
|
static void test_copy_on_write(skiatest::Reporter* reporter, SkSurface* surface) {
|
2013-03-28 13:49:22 +00:00
|
|
|
SkCanvas* canvas = surface->getCanvas();
|
|
|
|
|
|
|
|
|
|
const SkRect testRect =
|
|
|
|
|
SkRect::MakeXYWH(SkIntToScalar(0), SkIntToScalar(0),
|
|
|
|
|
SkIntToScalar(4), SkIntToScalar(5));
|
|
|
|
|
SkPath testPath;
|
|
|
|
|
testPath.addRect(SkRect::MakeXYWH(SkIntToScalar(0), SkIntToScalar(0),
|
|
|
|
|
SkIntToScalar(2), SkIntToScalar(1)));
|
|
|
|
|
|
|
|
|
|
const SkIRect testIRect = SkIRect::MakeXYWH(0, 0, 2, 1);
|
|
|
|
|
|
|
|
|
|
SkRegion testRegion;
|
|
|
|
|
testRegion.setRect(testIRect);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const SkColor testColor = 0x01020304;
|
|
|
|
|
const SkPaint testPaint;
|
|
|
|
|
const SkPoint testPoints[3] = {
|
|
|
|
|
{SkIntToScalar(0), SkIntToScalar(0)},
|
|
|
|
|
{SkIntToScalar(2), SkIntToScalar(1)},
|
|
|
|
|
{SkIntToScalar(0), SkIntToScalar(2)}
|
|
|
|
|
};
|
|
|
|
|
const size_t testPointCount = 3;
|
|
|
|
|
|
|
|
|
|
SkBitmap testBitmap;
|
2014-02-13 14:41:43 +00:00
|
|
|
testBitmap.allocN32Pixels(10, 10);
|
2013-10-09 12:51:09 +00:00
|
|
|
testBitmap.eraseColor(0);
|
2013-03-28 13:49:22 +00:00
|
|
|
|
|
|
|
|
SkRRect testRRect;
|
|
|
|
|
testRRect.setRectXY(testRect, SK_Scalar1, SK_Scalar1);
|
|
|
|
|
|
|
|
|
|
SkString testText("Hello World");
|
|
|
|
|
const SkPoint testPoints2[] = {
|
|
|
|
|
{ SkIntToScalar(0), SkIntToScalar(1) },
|
|
|
|
|
{ SkIntToScalar(1), SkIntToScalar(1) },
|
|
|
|
|
{ SkIntToScalar(2), SkIntToScalar(1) },
|
|
|
|
|
{ SkIntToScalar(3), SkIntToScalar(1) },
|
|
|
|
|
{ SkIntToScalar(4), SkIntToScalar(1) },
|
|
|
|
|
{ SkIntToScalar(5), SkIntToScalar(1) },
|
|
|
|
|
{ SkIntToScalar(6), SkIntToScalar(1) },
|
|
|
|
|
{ SkIntToScalar(7), SkIntToScalar(1) },
|
|
|
|
|
{ SkIntToScalar(8), SkIntToScalar(1) },
|
|
|
|
|
{ SkIntToScalar(9), SkIntToScalar(1) },
|
|
|
|
|
{ SkIntToScalar(10), SkIntToScalar(1) },
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#define EXPECT_COPY_ON_WRITE(command) \
|
|
|
|
|
{ \
|
2016-03-17 17:51:11 +00:00
|
|
|
sk_sp<SkImage> imageBefore = surface->makeImageSnapshot(); \
|
|
|
|
|
sk_sp<SkImage> aur_before(imageBefore); \
|
2013-03-28 13:49:22 +00:00
|
|
|
canvas-> command ; \
|
2016-03-17 17:51:11 +00:00
|
|
|
sk_sp<SkImage> imageAfter = surface->makeImageSnapshot(); \
|
|
|
|
|
sk_sp<SkImage> aur_after(imageAfter); \
|
2013-03-28 13:49:22 +00:00
|
|
|
REPORTER_ASSERT(reporter, imageBefore != imageAfter); \
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
EXPECT_COPY_ON_WRITE(clear(testColor))
|
|
|
|
|
EXPECT_COPY_ON_WRITE(drawPaint(testPaint))
|
|
|
|
|
EXPECT_COPY_ON_WRITE(drawPoints(SkCanvas::kPoints_PointMode, testPointCount, testPoints, \
|
|
|
|
|
testPaint))
|
|
|
|
|
EXPECT_COPY_ON_WRITE(drawOval(testRect, testPaint))
|
|
|
|
|
EXPECT_COPY_ON_WRITE(drawRect(testRect, testPaint))
|
|
|
|
|
EXPECT_COPY_ON_WRITE(drawRRect(testRRect, testPaint))
|
|
|
|
|
EXPECT_COPY_ON_WRITE(drawPath(testPath, testPaint))
|
|
|
|
|
EXPECT_COPY_ON_WRITE(drawBitmap(testBitmap, 0, 0))
|
2015-08-06 17:02:53 +00:00
|
|
|
EXPECT_COPY_ON_WRITE(drawBitmapRect(testBitmap, testRect, nullptr))
|
2015-08-27 14:41:13 +00:00
|
|
|
EXPECT_COPY_ON_WRITE(drawBitmapNine(testBitmap, testIRect, testRect, nullptr))
|
2017-04-28 19:35:12 +00:00
|
|
|
EXPECT_COPY_ON_WRITE(drawString(testText, 0, 1, testPaint))
|
2013-03-28 13:49:22 +00:00
|
|
|
EXPECT_COPY_ON_WRITE(drawPosText(testText.c_str(), testText.size(), testPoints2, \
|
|
|
|
|
testPaint))
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
}
|
|
|
|
|
DEF_TEST(SurfaceCopyOnWrite, reporter) {
|
2016-03-24 01:59:25 +00:00
|
|
|
test_copy_on_write(reporter, create_surface().get());
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
}
|
2016-06-28 15:07:26 +00:00
|
|
|
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceCopyOnWrite_Gpu, reporter, ctxInfo) {
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
for (auto& surface_func : { &create_gpu_surface, &create_gpu_scratch_surface }) {
|
2016-05-11 13:33:06 +00:00
|
|
|
auto surface(surface_func(ctxInfo.grContext(), kPremul_SkAlphaType, nullptr));
|
2016-03-24 01:59:25 +00:00
|
|
|
test_copy_on_write(reporter, surface.get());
|
2015-08-06 14:04:51 +00:00
|
|
|
}
|
2013-03-28 13:49:22 +00:00
|
|
|
}
|
|
|
|
|
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
static void test_writable_after_snapshot_release(skiatest::Reporter* reporter,
|
|
|
|
|
SkSurface* surface) {
|
2013-04-03 15:03:26 +00:00
|
|
|
// This test succeeds by not triggering an assertion.
|
|
|
|
|
// The test verifies that the surface remains writable (usable) after
|
|
|
|
|
// acquiring and releasing a snapshot without triggering a copy on write.
|
|
|
|
|
SkCanvas* canvas = surface->getCanvas();
|
|
|
|
|
canvas->clear(1);
|
2016-03-17 17:51:11 +00:00
|
|
|
surface->makeImageSnapshot(); // Create and destroy SkImage
|
2013-07-25 23:29:40 +00:00
|
|
|
canvas->clear(2); // Must not assert internally
|
2013-03-28 13:49:22 +00:00
|
|
|
}
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
DEF_TEST(SurfaceWriteableAfterSnapshotRelease, reporter) {
|
2016-03-24 01:59:25 +00:00
|
|
|
test_writable_after_snapshot_release(reporter, create_surface().get());
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
}
|
2016-06-28 15:07:26 +00:00
|
|
|
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceWriteableAfterSnapshotRelease_Gpu, reporter, ctxInfo) {
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
for (auto& surface_func : { &create_gpu_surface, &create_gpu_scratch_surface }) {
|
2016-05-11 13:33:06 +00:00
|
|
|
auto surface(surface_func(ctxInfo.grContext(), kPremul_SkAlphaType, nullptr));
|
2016-03-24 01:59:25 +00:00
|
|
|
test_writable_after_snapshot_release(reporter, surface.get());
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
}
|
|
|
|
|
}
|
2013-05-01 22:38:16 +00:00
|
|
|
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
static void test_crbug263329(skiatest::Reporter* reporter,
|
|
|
|
|
SkSurface* surface1,
|
|
|
|
|
SkSurface* surface2) {
|
2013-07-25 23:29:40 +00:00
|
|
|
// This is a regression test for crbug.com/263329
|
|
|
|
|
// Bug was caused by onCopyOnWrite releasing the old surface texture
|
|
|
|
|
// back to the scratch texture pool even though the texture is used
|
|
|
|
|
// by and active SkImage_Gpu.
|
|
|
|
|
SkCanvas* canvas1 = surface1->getCanvas();
|
|
|
|
|
SkCanvas* canvas2 = surface2->getCanvas();
|
|
|
|
|
canvas1->clear(1);
|
2016-03-17 17:51:11 +00:00
|
|
|
sk_sp<SkImage> image1(surface1->makeImageSnapshot());
|
2013-07-25 23:29:40 +00:00
|
|
|
// Trigger copy on write, new backing is a scratch texture
|
|
|
|
|
canvas1->clear(2);
|
2016-03-17 17:51:11 +00:00
|
|
|
sk_sp<SkImage> image2(surface1->makeImageSnapshot());
|
2013-07-25 23:29:40 +00:00
|
|
|
// Trigger copy on write, old backing should not be returned to scratch
|
|
|
|
|
// pool because it is held by image2
|
|
|
|
|
canvas1->clear(3);
|
|
|
|
|
|
|
|
|
|
canvas2->clear(4);
|
2016-03-17 17:51:11 +00:00
|
|
|
sk_sp<SkImage> image3(surface2->makeImageSnapshot());
|
2013-07-25 23:29:40 +00:00
|
|
|
// Trigger copy on write on surface2. The new backing store should not
|
|
|
|
|
// be recycling a texture that is held by an existing image.
|
|
|
|
|
canvas2->clear(5);
|
2016-03-17 17:51:11 +00:00
|
|
|
sk_sp<SkImage> image4(surface2->makeImageSnapshot());
|
2017-06-23 18:09:30 +00:00
|
|
|
REPORTER_ASSERT(reporter, as_IB(image4)->getTexture() != as_IB(image3)->getTexture());
|
2013-07-25 23:29:40 +00:00
|
|
|
// The following assertion checks crbug.com/263329
|
2017-06-23 18:09:30 +00:00
|
|
|
REPORTER_ASSERT(reporter, as_IB(image4)->getTexture() != as_IB(image2)->getTexture());
|
|
|
|
|
REPORTER_ASSERT(reporter, as_IB(image4)->getTexture() != as_IB(image1)->getTexture());
|
|
|
|
|
REPORTER_ASSERT(reporter, as_IB(image3)->getTexture() != as_IB(image2)->getTexture());
|
|
|
|
|
REPORTER_ASSERT(reporter, as_IB(image3)->getTexture() != as_IB(image1)->getTexture());
|
|
|
|
|
REPORTER_ASSERT(reporter, as_IB(image2)->getTexture() != as_IB(image1)->getTexture());
|
2013-07-25 23:29:40 +00:00
|
|
|
}
|
2016-06-28 15:07:26 +00:00
|
|
|
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceCRBug263329_Gpu, reporter, ctxInfo) {
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
for (auto& surface_func : { &create_gpu_surface, &create_gpu_scratch_surface }) {
|
2016-05-11 13:33:06 +00:00
|
|
|
auto surface1(surface_func(ctxInfo.grContext(), kPremul_SkAlphaType, nullptr));
|
|
|
|
|
auto surface2(surface_func(ctxInfo.grContext(), kPremul_SkAlphaType, nullptr));
|
2016-03-24 01:59:25 +00:00
|
|
|
test_crbug263329(reporter, surface1.get(), surface2.get());
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
}
|
|
|
|
|
}
|
2013-07-25 23:29:40 +00:00
|
|
|
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
DEF_TEST(SurfaceGetTexture, reporter) {
|
2016-03-24 01:59:25 +00:00
|
|
|
auto surface(create_surface());
|
2016-03-17 17:51:11 +00:00
|
|
|
sk_sp<SkImage> image(surface->makeImageSnapshot());
|
2017-01-31 16:31:39 +00:00
|
|
|
REPORTER_ASSERT(reporter, !as_IB(image)->isTextureBacked());
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
surface->notifyContentWillChange(SkSurface::kDiscard_ContentChangeMode);
|
2017-01-31 16:31:39 +00:00
|
|
|
REPORTER_ASSERT(reporter, !as_IB(image)->isTextureBacked());
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
}
|
2016-06-28 15:07:26 +00:00
|
|
|
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfacepeekTexture_Gpu, reporter, ctxInfo) {
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
for (auto& surface_func : { &create_gpu_surface, &create_gpu_scratch_surface }) {
|
2016-05-11 13:33:06 +00:00
|
|
|
auto surface(surface_func(ctxInfo.grContext(), kPremul_SkAlphaType, nullptr));
|
2016-03-17 17:51:11 +00:00
|
|
|
sk_sp<SkImage> image(surface->makeImageSnapshot());
|
2017-01-31 16:31:39 +00:00
|
|
|
|
|
|
|
|
REPORTER_ASSERT(reporter, as_IB(image)->isTextureBacked());
|
2018-04-04 19:54:55 +00:00
|
|
|
GrBackendTexture backendTex = image->getBackendTexture(false);
|
|
|
|
|
REPORTER_ASSERT(reporter, backendTex.isValid());
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
surface->notifyContentWillChange(SkSurface::kDiscard_ContentChangeMode);
|
2017-01-31 16:31:39 +00:00
|
|
|
REPORTER_ASSERT(reporter, as_IB(image)->isTextureBacked());
|
2018-04-04 19:54:55 +00:00
|
|
|
GrBackendTexture backendTex2 = image->getBackendTexture(false);
|
|
|
|
|
REPORTER_ASSERT(reporter, GrBackendTexture::TestingOnly_Equals(backendTex, backendTex2));
|
2013-05-01 22:38:16 +00:00
|
|
|
}
|
|
|
|
|
}
|
2015-01-23 16:08:04 +00:00
|
|
|
|
2016-03-24 01:59:25 +00:00
|
|
|
static SkBudgeted is_budgeted(const sk_sp<SkSurface>& surf) {
|
|
|
|
|
SkSurface_Gpu* gsurf = (SkSurface_Gpu*)surf.get();
|
2017-01-31 16:31:39 +00:00
|
|
|
|
|
|
|
|
GrRenderTargetProxy* proxy = gsurf->getDevice()->accessRenderTargetContext()
|
|
|
|
|
->asRenderTargetProxy();
|
|
|
|
|
return proxy->isBudgeted();
|
2015-01-23 16:08:04 +00:00
|
|
|
}
|
|
|
|
|
|
2016-02-25 16:33:02 +00:00
|
|
|
static SkBudgeted is_budgeted(SkImage* image) {
|
2017-03-21 20:22:00 +00:00
|
|
|
return ((SkImage_Gpu*)image)->peekProxy()->isBudgeted();
|
2015-01-23 16:08:04 +00:00
|
|
|
}
|
|
|
|
|
|
2016-03-17 17:51:11 +00:00
|
|
|
static SkBudgeted is_budgeted(const sk_sp<SkImage> image) {
|
|
|
|
|
return is_budgeted(image.get());
|
|
|
|
|
}
|
|
|
|
|
|
2016-06-28 15:07:26 +00:00
|
|
|
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceBudget, reporter, ctxInfo) {
|
2015-01-23 16:08:04 +00:00
|
|
|
SkImageInfo info = SkImageInfo::MakeN32Premul(8,8);
|
2017-03-20 12:38:50 +00:00
|
|
|
for (auto budgeted : { SkBudgeted::kNo, SkBudgeted::kYes }) {
|
|
|
|
|
auto surface(SkSurface::MakeRenderTarget(ctxInfo.grContext(), budgeted, info));
|
|
|
|
|
SkASSERT(surface);
|
|
|
|
|
REPORTER_ASSERT(reporter, budgeted == is_budgeted(surface));
|
|
|
|
|
|
|
|
|
|
sk_sp<SkImage> image(surface->makeImageSnapshot());
|
|
|
|
|
|
|
|
|
|
// Initially the image shares a texture with the surface, and the
|
|
|
|
|
// the budgets should always match.
|
|
|
|
|
REPORTER_ASSERT(reporter, budgeted == is_budgeted(surface));
|
|
|
|
|
REPORTER_ASSERT(reporter, budgeted == is_budgeted(image));
|
|
|
|
|
|
|
|
|
|
// Now trigger copy-on-write
|
|
|
|
|
surface->getCanvas()->clear(SK_ColorBLUE);
|
|
|
|
|
|
|
|
|
|
// They don't share a texture anymore but the budgets should still match.
|
|
|
|
|
REPORTER_ASSERT(reporter, budgeted == is_budgeted(surface));
|
|
|
|
|
REPORTER_ASSERT(reporter, budgeted == is_budgeted(image));
|
2015-01-23 16:08:04 +00:00
|
|
|
}
|
|
|
|
|
}
|
2013-05-01 22:38:16 +00:00
|
|
|
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
static void test_no_canvas1(skiatest::Reporter* reporter,
|
|
|
|
|
SkSurface* surface,
|
|
|
|
|
SkSurface::ContentChangeMode mode) {
|
|
|
|
|
// Test passes by not asserting
|
|
|
|
|
surface->notifyContentWillChange(mode);
|
|
|
|
|
SkDEBUGCODE(surface->validate();)
|
|
|
|
|
}
|
|
|
|
|
static void test_no_canvas2(skiatest::Reporter* reporter,
|
|
|
|
|
SkSurface* surface,
|
|
|
|
|
SkSurface::ContentChangeMode mode) {
|
2013-04-16 19:41:09 +00:00
|
|
|
// Verifies the robustness of SkSurface for handling use cases where calls
|
|
|
|
|
// are made before a canvas is created.
|
2016-03-17 17:51:11 +00:00
|
|
|
sk_sp<SkImage> image1 = surface->makeImageSnapshot();
|
|
|
|
|
sk_sp<SkImage> aur_image1(image1);
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
SkDEBUGCODE(image1->validate();)
|
|
|
|
|
SkDEBUGCODE(surface->validate();)
|
|
|
|
|
surface->notifyContentWillChange(mode);
|
|
|
|
|
SkDEBUGCODE(image1->validate();)
|
|
|
|
|
SkDEBUGCODE(surface->validate();)
|
2016-03-17 17:51:11 +00:00
|
|
|
sk_sp<SkImage> image2 = surface->makeImageSnapshot();
|
|
|
|
|
sk_sp<SkImage> aur_image2(image2);
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
SkDEBUGCODE(image2->validate();)
|
|
|
|
|
SkDEBUGCODE(surface->validate();)
|
|
|
|
|
REPORTER_ASSERT(reporter, image1 != image2);
|
|
|
|
|
}
|
|
|
|
|
DEF_TEST(SurfaceNoCanvas, reporter) {
|
|
|
|
|
SkSurface::ContentChangeMode modes[] =
|
|
|
|
|
{ SkSurface::kDiscard_ContentChangeMode, SkSurface::kRetain_ContentChangeMode};
|
|
|
|
|
for (auto& test_func : { &test_no_canvas1, &test_no_canvas2 }) {
|
|
|
|
|
for (auto& mode : modes) {
|
2016-03-24 01:59:25 +00:00
|
|
|
test_func(reporter, create_surface().get(), mode);
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
}
|
2013-04-16 19:41:09 +00:00
|
|
|
}
|
|
|
|
|
}
|
2016-06-28 15:07:26 +00:00
|
|
|
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceNoCanvas_Gpu, reporter, ctxInfo) {
|
Generate list of GPU contexts outside SurfaceTest tests
Add support for feeding the tests with contexts directly to the unit
test framework.
This fixes the problem where tests are more complex than needed just in
order to run the test code with multiple backends.
Also makes it possible to change the logic how contexts are
created. Instead of direct numbering, the different testable contexts
may be generated from filtered cross-product of context options. For
example: currently NVPR is a type of context. However, it could be also
an on/off feature of any context. In order to test this kind of context,
the enumeration can not be just of context type. It's simpler
to move the enumeration out of the tests.
A test targeting both normal and GPU backends would look like:
static void test_obj_behavior(skiatest::Reporter* reporter,
SkObj* obj, [other params] ) {
... test with obj and param ..
}
DEF_TEST(ObjBehavior, reporter) {
for (auto& object : generate_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#if SK_SUPPORT_GPU
DEF_GPUTEST_FOR_ALL_CONTEXTS(ObjBehavior_Gpu, reporter, context) {
for (auto& object : generate_gpu_object) {
for (auto& other_param : generate_other_variant) {
test_obj_behavior(reporter, object, other_param);
}
}
}
#endif
Uses the feature in SurfaceTests as an example.
Moves SkSurface -related tests from ImageTest to SurfaceTest.
BUG=skia:2992
Review URL: https://codereview.chromium.org/1446453003
2015-11-20 21:32:24 +00:00
|
|
|
SkSurface::ContentChangeMode modes[] =
|
|
|
|
|
{ SkSurface::kDiscard_ContentChangeMode, SkSurface::kRetain_ContentChangeMode};
|
|
|
|
|
for (auto& surface_func : { &create_gpu_surface, &create_gpu_scratch_surface }) {
|
|
|
|
|
for (auto& test_func : { &test_no_canvas1, &test_no_canvas2 }) {
|
|
|
|
|
for (auto& mode : modes) {
|
2016-05-11 13:33:06 +00:00
|
|
|
auto surface(surface_func(ctxInfo.grContext(), kPremul_SkAlphaType, nullptr));
|
2016-03-24 01:59:25 +00:00
|
|
|
test_func(reporter, surface.get(), mode);
|
2014-07-17 17:50:59 +00:00
|
|
|
}
|
2013-11-12 13:51:03 +00:00
|
|
|
}
|
2013-04-03 15:03:26 +00:00
|
|
|
}
|
2013-03-28 13:49:22 +00:00
|
|
|
}
|
2016-01-30 18:01:06 +00:00
|
|
|
|
|
|
|
|
static void check_rowbytes_remain_consistent(SkSurface* surface, skiatest::Reporter* reporter) {
|
2016-03-09 22:26:26 +00:00
|
|
|
SkPixmap surfacePM;
|
|
|
|
|
REPORTER_ASSERT(reporter, surface->peekPixels(&surfacePM));
|
2016-01-30 18:01:06 +00:00
|
|
|
|
2016-03-17 17:51:11 +00:00
|
|
|
sk_sp<SkImage> image(surface->makeImageSnapshot());
|
2016-03-09 22:26:26 +00:00
|
|
|
SkPixmap pm;
|
|
|
|
|
REPORTER_ASSERT(reporter, image->peekPixels(&pm));
|
2016-01-30 18:01:06 +00:00
|
|
|
|
2016-03-09 22:26:26 +00:00
|
|
|
REPORTER_ASSERT(reporter, surfacePM.rowBytes() == pm.rowBytes());
|
2016-01-30 18:01:06 +00:00
|
|
|
|
|
|
|
|
// trigger a copy-on-write
|
|
|
|
|
surface->getCanvas()->drawPaint(SkPaint());
|
2016-03-17 17:51:11 +00:00
|
|
|
sk_sp<SkImage> image2(surface->makeImageSnapshot());
|
2016-01-30 18:01:06 +00:00
|
|
|
REPORTER_ASSERT(reporter, image->uniqueID() != image2->uniqueID());
|
|
|
|
|
|
2016-03-09 22:26:26 +00:00
|
|
|
SkPixmap pm2;
|
|
|
|
|
REPORTER_ASSERT(reporter, image2->peekPixels(&pm2));
|
|
|
|
|
REPORTER_ASSERT(reporter, pm2.rowBytes() == pm.rowBytes());
|
2016-01-30 18:01:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
DEF_TEST(surface_rowbytes, reporter) {
|
|
|
|
|
const SkImageInfo info = SkImageInfo::MakeN32Premul(100, 100);
|
|
|
|
|
|
2016-03-24 01:59:25 +00:00
|
|
|
auto surf0(SkSurface::MakeRaster(info));
|
|
|
|
|
check_rowbytes_remain_consistent(surf0.get(), reporter);
|
2016-01-30 18:01:06 +00:00
|
|
|
|
|
|
|
|
// specify a larger rowbytes
|
2016-03-24 01:59:25 +00:00
|
|
|
auto surf1(SkSurface::MakeRaster(info, 500, nullptr));
|
|
|
|
|
check_rowbytes_remain_consistent(surf1.get(), reporter);
|
2016-01-30 18:01:06 +00:00
|
|
|
|
|
|
|
|
// Try some illegal rowByte values
|
2016-03-24 01:59:25 +00:00
|
|
|
auto s = SkSurface::MakeRaster(info, 396, nullptr); // needs to be at least 400
|
2016-01-30 18:01:06 +00:00
|
|
|
REPORTER_ASSERT(reporter, nullptr == s);
|
2017-10-03 18:47:21 +00:00
|
|
|
s = SkSurface::MakeRaster(info, std::numeric_limits<size_t>::max(), nullptr);
|
2016-01-30 18:01:06 +00:00
|
|
|
REPORTER_ASSERT(reporter, nullptr == s);
|
|
|
|
|
}
|
2016-02-05 15:17:34 +00:00
|
|
|
|
2016-07-06 13:22:06 +00:00
|
|
|
DEF_TEST(surface_raster_zeroinitialized, reporter) {
|
|
|
|
|
sk_sp<SkSurface> s(SkSurface::MakeRasterN32Premul(100, 100));
|
|
|
|
|
SkPixmap pixmap;
|
|
|
|
|
REPORTER_ASSERT(reporter, s->peekPixels(&pixmap));
|
|
|
|
|
|
|
|
|
|
for (int i = 0; i < pixmap.info().width(); ++i) {
|
|
|
|
|
for (int j = 0; j < pixmap.info().height(); ++j) {
|
|
|
|
|
REPORTER_ASSERT(reporter, *pixmap.addr32(i, j) == 0);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2016-05-04 19:01:58 +00:00
|
|
|
static sk_sp<SkSurface> create_gpu_surface_backend_texture(
|
2017-12-12 18:01:25 +00:00
|
|
|
GrContext* context, int sampleCnt, uint32_t color, GrBackendTexture* outTexture) {
|
2018-01-22 15:48:15 +00:00
|
|
|
GrGpu* gpu = context->contextPriv().getGpu();
|
|
|
|
|
|
2016-05-04 19:01:58 +00:00
|
|
|
const int kWidth = 10;
|
|
|
|
|
const int kHeight = 10;
|
2016-11-02 21:07:33 +00:00
|
|
|
std::unique_ptr<uint32_t[]> pixels(new uint32_t[kWidth * kHeight]);
|
2016-05-04 19:01:58 +00:00
|
|
|
sk_memset32(pixels.get(), color, kWidth * kHeight);
|
Revert "Revert "Plumb GrBackendTexture throughout skia.""
This reverts commit 7fa5c31c2c9af834bee66d5fcf476e250076c8d6.
Reason for revert: Relanding this change now that other fixes have landed.
Original change's description:
> Revert "Plumb GrBackendTexture throughout skia."
>
> This reverts commit 7da62b9059f3c1d31624a0e4da96ee5f908f9c12.
>
> Reason for revert: fix android roll
>
> Original change's description:
> > Plumb GrBackendTexture throughout skia.
> >
> > Bug: skia:
> > Change-Id: I1bae6768ee7229818a83ba608035a1f7867e6875
> > Reviewed-on: https://skia-review.googlesource.com/13645
> > Commit-Queue: Greg Daniel <egdaniel@google.com>
> > Reviewed-by: Robert Phillips <robertphillips@google.com>
> >
>
> TBR=egdaniel@google.com,bsalomon@google.com,robertphillips@google.com,brianosman@google.com,reviews@skia.org,stani@google.com
> NOPRESUBMIT=true
> NOTREECHECKS=true
> NOTRY=true
>
> Change-Id: I5cb8763cc837c83ebc6d10366fe2dd3efe35fb89
> Reviewed-on: https://skia-review.googlesource.com/13773
> Reviewed-by: Stan Iliev <stani@google.com>
> Commit-Queue: Stan Iliev <stani@google.com>
>
TBR=egdaniel@google.com,bsalomon@google.com,robertphillips@google.com,reviews@skia.org,brianosman@google.com,stani@google.com
# Not skipping CQ checks because original CL landed > 1 day ago.
Change-Id: I92bc074e4fe37fa5c83186afadc472c03802e8f2
Reviewed-on: https://skia-review.googlesource.com/13975
Reviewed-by: Greg Daniel <egdaniel@google.com>
Commit-Queue: Greg Daniel <egdaniel@google.com>
2017-04-20 16:41:55 +00:00
|
|
|
|
2018-01-22 15:48:15 +00:00
|
|
|
*outTexture = gpu->createTestingOnlyBackendTexture(
|
2017-12-12 18:01:25 +00:00
|
|
|
pixels.get(), kWidth, kHeight, kRGBA_8888_GrPixelConfig, true, GrMipMapped::kNo);
|
Revert "Revert "Plumb GrBackendTexture throughout skia.""
This reverts commit 7fa5c31c2c9af834bee66d5fcf476e250076c8d6.
Reason for revert: Relanding this change now that other fixes have landed.
Original change's description:
> Revert "Plumb GrBackendTexture throughout skia."
>
> This reverts commit 7da62b9059f3c1d31624a0e4da96ee5f908f9c12.
>
> Reason for revert: fix android roll
>
> Original change's description:
> > Plumb GrBackendTexture throughout skia.
> >
> > Bug: skia:
> > Change-Id: I1bae6768ee7229818a83ba608035a1f7867e6875
> > Reviewed-on: https://skia-review.googlesource.com/13645
> > Commit-Queue: Greg Daniel <egdaniel@google.com>
> > Reviewed-by: Robert Phillips <robertphillips@google.com>
> >
>
> TBR=egdaniel@google.com,bsalomon@google.com,robertphillips@google.com,brianosman@google.com,reviews@skia.org,stani@google.com
> NOPRESUBMIT=true
> NOTREECHECKS=true
> NOTRY=true
>
> Change-Id: I5cb8763cc837c83ebc6d10366fe2dd3efe35fb89
> Reviewed-on: https://skia-review.googlesource.com/13773
> Reviewed-by: Stan Iliev <stani@google.com>
> Commit-Queue: Stan Iliev <stani@google.com>
>
TBR=egdaniel@google.com,bsalomon@google.com,robertphillips@google.com,reviews@skia.org,brianosman@google.com,stani@google.com
# Not skipping CQ checks because original CL landed > 1 day ago.
Change-Id: I92bc074e4fe37fa5c83186afadc472c03802e8f2
Reviewed-on: https://skia-review.googlesource.com/13975
Reviewed-by: Greg Daniel <egdaniel@google.com>
Commit-Queue: Greg Daniel <egdaniel@google.com>
2017-04-20 16:41:55 +00:00
|
|
|
|
2018-01-22 15:48:15 +00:00
|
|
|
if (!outTexture->isValid() || !gpu->isTestingOnlyBackendTexture(*outTexture)) {
|
2017-12-12 18:01:25 +00:00
|
|
|
return nullptr;
|
|
|
|
|
}
|
Revert "Revert "Plumb GrBackendTexture throughout skia.""
This reverts commit 7fa5c31c2c9af834bee66d5fcf476e250076c8d6.
Reason for revert: Relanding this change now that other fixes have landed.
Original change's description:
> Revert "Plumb GrBackendTexture throughout skia."
>
> This reverts commit 7da62b9059f3c1d31624a0e4da96ee5f908f9c12.
>
> Reason for revert: fix android roll
>
> Original change's description:
> > Plumb GrBackendTexture throughout skia.
> >
> > Bug: skia:
> > Change-Id: I1bae6768ee7229818a83ba608035a1f7867e6875
> > Reviewed-on: https://skia-review.googlesource.com/13645
> > Commit-Queue: Greg Daniel <egdaniel@google.com>
> > Reviewed-by: Robert Phillips <robertphillips@google.com>
> >
>
> TBR=egdaniel@google.com,bsalomon@google.com,robertphillips@google.com,brianosman@google.com,reviews@skia.org,stani@google.com
> NOPRESUBMIT=true
> NOTREECHECKS=true
> NOTRY=true
>
> Change-Id: I5cb8763cc837c83ebc6d10366fe2dd3efe35fb89
> Reviewed-on: https://skia-review.googlesource.com/13773
> Reviewed-by: Stan Iliev <stani@google.com>
> Commit-Queue: Stan Iliev <stani@google.com>
>
TBR=egdaniel@google.com,bsalomon@google.com,robertphillips@google.com,reviews@skia.org,brianosman@google.com,stani@google.com
# Not skipping CQ checks because original CL landed > 1 day ago.
Change-Id: I92bc074e4fe37fa5c83186afadc472c03802e8f2
Reviewed-on: https://skia-review.googlesource.com/13975
Reviewed-by: Greg Daniel <egdaniel@google.com>
Commit-Queue: Greg Daniel <egdaniel@google.com>
2017-04-20 16:41:55 +00:00
|
|
|
|
2017-12-12 18:01:25 +00:00
|
|
|
sk_sp<SkSurface> surface = SkSurface::MakeFromBackendTexture(context, *outTexture,
|
2017-07-21 19:37:19 +00:00
|
|
|
kTopLeft_GrSurfaceOrigin, sampleCnt,
|
2017-12-19 18:15:02 +00:00
|
|
|
kRGBA_8888_SkColorType,
|
Revert "Revert "Plumb GrBackendTexture throughout skia.""
This reverts commit 7fa5c31c2c9af834bee66d5fcf476e250076c8d6.
Reason for revert: Relanding this change now that other fixes have landed.
Original change's description:
> Revert "Plumb GrBackendTexture throughout skia."
>
> This reverts commit 7da62b9059f3c1d31624a0e4da96ee5f908f9c12.
>
> Reason for revert: fix android roll
>
> Original change's description:
> > Plumb GrBackendTexture throughout skia.
> >
> > Bug: skia:
> > Change-Id: I1bae6768ee7229818a83ba608035a1f7867e6875
> > Reviewed-on: https://skia-review.googlesource.com/13645
> > Commit-Queue: Greg Daniel <egdaniel@google.com>
> > Reviewed-by: Robert Phillips <robertphillips@google.com>
> >
>
> TBR=egdaniel@google.com,bsalomon@google.com,robertphillips@google.com,brianosman@google.com,reviews@skia.org,stani@google.com
> NOPRESUBMIT=true
> NOTREECHECKS=true
> NOTRY=true
>
> Change-Id: I5cb8763cc837c83ebc6d10366fe2dd3efe35fb89
> Reviewed-on: https://skia-review.googlesource.com/13773
> Reviewed-by: Stan Iliev <stani@google.com>
> Commit-Queue: Stan Iliev <stani@google.com>
>
TBR=egdaniel@google.com,bsalomon@google.com,robertphillips@google.com,reviews@skia.org,brianosman@google.com,stani@google.com
# Not skipping CQ checks because original CL landed > 1 day ago.
Change-Id: I92bc074e4fe37fa5c83186afadc472c03802e8f2
Reviewed-on: https://skia-review.googlesource.com/13975
Reviewed-by: Greg Daniel <egdaniel@google.com>
Commit-Queue: Greg Daniel <egdaniel@google.com>
2017-04-20 16:41:55 +00:00
|
|
|
nullptr, nullptr);
|
2016-05-04 19:01:58 +00:00
|
|
|
if (!surface) {
|
2018-03-09 14:33:19 +00:00
|
|
|
gpu->deleteTestingOnlyBackendTexture(*outTexture);
|
2016-05-04 19:01:58 +00:00
|
|
|
return nullptr;
|
|
|
|
|
}
|
|
|
|
|
return surface;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static sk_sp<SkSurface> create_gpu_surface_backend_texture_as_render_target(
|
2017-12-12 18:01:25 +00:00
|
|
|
GrContext* context, int sampleCnt, uint32_t color, GrBackendTexture* outTexture) {
|
2018-01-22 15:48:15 +00:00
|
|
|
GrGpu* gpu = context->contextPriv().getGpu();
|
|
|
|
|
|
2016-05-04 19:01:58 +00:00
|
|
|
const int kWidth = 10;
|
|
|
|
|
const int kHeight = 10;
|
2016-11-02 21:07:33 +00:00
|
|
|
std::unique_ptr<uint32_t[]> pixels(new uint32_t[kWidth * kHeight]);
|
2016-05-04 19:01:58 +00:00
|
|
|
sk_memset32(pixels.get(), color, kWidth * kHeight);
|
Revert "Revert "Plumb GrBackendTexture throughout skia.""
This reverts commit 7fa5c31c2c9af834bee66d5fcf476e250076c8d6.
Reason for revert: Relanding this change now that other fixes have landed.
Original change's description:
> Revert "Plumb GrBackendTexture throughout skia."
>
> This reverts commit 7da62b9059f3c1d31624a0e4da96ee5f908f9c12.
>
> Reason for revert: fix android roll
>
> Original change's description:
> > Plumb GrBackendTexture throughout skia.
> >
> > Bug: skia:
> > Change-Id: I1bae6768ee7229818a83ba608035a1f7867e6875
> > Reviewed-on: https://skia-review.googlesource.com/13645
> > Commit-Queue: Greg Daniel <egdaniel@google.com>
> > Reviewed-by: Robert Phillips <robertphillips@google.com>
> >
>
> TBR=egdaniel@google.com,bsalomon@google.com,robertphillips@google.com,brianosman@google.com,reviews@skia.org,stani@google.com
> NOPRESUBMIT=true
> NOTREECHECKS=true
> NOTRY=true
>
> Change-Id: I5cb8763cc837c83ebc6d10366fe2dd3efe35fb89
> Reviewed-on: https://skia-review.googlesource.com/13773
> Reviewed-by: Stan Iliev <stani@google.com>
> Commit-Queue: Stan Iliev <stani@google.com>
>
TBR=egdaniel@google.com,bsalomon@google.com,robertphillips@google.com,reviews@skia.org,brianosman@google.com,stani@google.com
# Not skipping CQ checks because original CL landed > 1 day ago.
Change-Id: I92bc074e4fe37fa5c83186afadc472c03802e8f2
Reviewed-on: https://skia-review.googlesource.com/13975
Reviewed-by: Greg Daniel <egdaniel@google.com>
Commit-Queue: Greg Daniel <egdaniel@google.com>
2017-04-20 16:41:55 +00:00
|
|
|
|
2018-01-22 15:48:15 +00:00
|
|
|
*outTexture = gpu->createTestingOnlyBackendTexture(
|
2017-12-12 18:01:25 +00:00
|
|
|
pixels.get(), kWidth, kHeight, kRGBA_8888_GrPixelConfig, true, GrMipMapped::kNo);
|
|
|
|
|
|
2018-01-22 15:48:15 +00:00
|
|
|
if (!outTexture->isValid() || !gpu->isTestingOnlyBackendTexture(*outTexture)) {
|
2017-12-12 18:01:25 +00:00
|
|
|
return nullptr;
|
|
|
|
|
}
|
Revert "Revert "Plumb GrBackendTexture throughout skia.""
This reverts commit 7fa5c31c2c9af834bee66d5fcf476e250076c8d6.
Reason for revert: Relanding this change now that other fixes have landed.
Original change's description:
> Revert "Plumb GrBackendTexture throughout skia."
>
> This reverts commit 7da62b9059f3c1d31624a0e4da96ee5f908f9c12.
>
> Reason for revert: fix android roll
>
> Original change's description:
> > Plumb GrBackendTexture throughout skia.
> >
> > Bug: skia:
> > Change-Id: I1bae6768ee7229818a83ba608035a1f7867e6875
> > Reviewed-on: https://skia-review.googlesource.com/13645
> > Commit-Queue: Greg Daniel <egdaniel@google.com>
> > Reviewed-by: Robert Phillips <robertphillips@google.com>
> >
>
> TBR=egdaniel@google.com,bsalomon@google.com,robertphillips@google.com,brianosman@google.com,reviews@skia.org,stani@google.com
> NOPRESUBMIT=true
> NOTREECHECKS=true
> NOTRY=true
>
> Change-Id: I5cb8763cc837c83ebc6d10366fe2dd3efe35fb89
> Reviewed-on: https://skia-review.googlesource.com/13773
> Reviewed-by: Stan Iliev <stani@google.com>
> Commit-Queue: Stan Iliev <stani@google.com>
>
TBR=egdaniel@google.com,bsalomon@google.com,robertphillips@google.com,reviews@skia.org,brianosman@google.com,stani@google.com
# Not skipping CQ checks because original CL landed > 1 day ago.
Change-Id: I92bc074e4fe37fa5c83186afadc472c03802e8f2
Reviewed-on: https://skia-review.googlesource.com/13975
Reviewed-by: Greg Daniel <egdaniel@google.com>
Commit-Queue: Greg Daniel <egdaniel@google.com>
2017-04-20 16:41:55 +00:00
|
|
|
|
|
|
|
|
sk_sp<SkSurface> surface = SkSurface::MakeFromBackendTextureAsRenderTarget(
|
2017-12-19 18:15:02 +00:00
|
|
|
context, *outTexture, kTopLeft_GrSurfaceOrigin, sampleCnt, kRGBA_8888_SkColorType,
|
|
|
|
|
nullptr, nullptr);
|
Revert "Revert "Plumb GrBackendTexture throughout skia.""
This reverts commit 7fa5c31c2c9af834bee66d5fcf476e250076c8d6.
Reason for revert: Relanding this change now that other fixes have landed.
Original change's description:
> Revert "Plumb GrBackendTexture throughout skia."
>
> This reverts commit 7da62b9059f3c1d31624a0e4da96ee5f908f9c12.
>
> Reason for revert: fix android roll
>
> Original change's description:
> > Plumb GrBackendTexture throughout skia.
> >
> > Bug: skia:
> > Change-Id: I1bae6768ee7229818a83ba608035a1f7867e6875
> > Reviewed-on: https://skia-review.googlesource.com/13645
> > Commit-Queue: Greg Daniel <egdaniel@google.com>
> > Reviewed-by: Robert Phillips <robertphillips@google.com>
> >
>
> TBR=egdaniel@google.com,bsalomon@google.com,robertphillips@google.com,brianosman@google.com,reviews@skia.org,stani@google.com
> NOPRESUBMIT=true
> NOTREECHECKS=true
> NOTRY=true
>
> Change-Id: I5cb8763cc837c83ebc6d10366fe2dd3efe35fb89
> Reviewed-on: https://skia-review.googlesource.com/13773
> Reviewed-by: Stan Iliev <stani@google.com>
> Commit-Queue: Stan Iliev <stani@google.com>
>
TBR=egdaniel@google.com,bsalomon@google.com,robertphillips@google.com,reviews@skia.org,brianosman@google.com,stani@google.com
# Not skipping CQ checks because original CL landed > 1 day ago.
Change-Id: I92bc074e4fe37fa5c83186afadc472c03802e8f2
Reviewed-on: https://skia-review.googlesource.com/13975
Reviewed-by: Greg Daniel <egdaniel@google.com>
Commit-Queue: Greg Daniel <egdaniel@google.com>
2017-04-20 16:41:55 +00:00
|
|
|
|
2016-05-04 19:01:58 +00:00
|
|
|
if (!surface) {
|
2018-03-09 14:33:19 +00:00
|
|
|
gpu->deleteTestingOnlyBackendTexture(*outTexture);
|
2016-05-04 19:01:58 +00:00
|
|
|
return nullptr;
|
|
|
|
|
}
|
|
|
|
|
return surface;
|
|
|
|
|
}
|
2016-02-05 15:17:34 +00:00
|
|
|
|
2016-05-04 19:01:58 +00:00
|
|
|
static void test_surface_clear(skiatest::Reporter* reporter, sk_sp<SkSurface> surface,
|
2017-01-18 15:08:39 +00:00
|
|
|
std::function<sk_sp<GrSurfaceContext>(SkSurface*)> grSurfaceGetter,
|
2016-05-04 19:01:58 +00:00
|
|
|
uint32_t expectedValue) {
|
2016-02-05 15:17:34 +00:00
|
|
|
if (!surface) {
|
|
|
|
|
ERRORF(reporter, "Could not create GPU SkSurface.");
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
int w = surface->width();
|
|
|
|
|
int h = surface->height();
|
2016-11-02 21:07:33 +00:00
|
|
|
std::unique_ptr<uint32_t[]> pixels(new uint32_t[w * h]);
|
2016-05-04 19:01:58 +00:00
|
|
|
sk_memset32(pixels.get(), ~expectedValue, w * h);
|
2016-02-05 15:17:34 +00:00
|
|
|
|
2017-01-18 15:08:39 +00:00
|
|
|
sk_sp<GrSurfaceContext> grSurfaceContext(grSurfaceGetter(surface.get()));
|
|
|
|
|
if (!grSurfaceContext) {
|
2016-02-05 15:17:34 +00:00
|
|
|
ERRORF(reporter, "Could access render target of GPU SkSurface.");
|
|
|
|
|
return;
|
|
|
|
|
}
|
2016-02-05 21:47:06 +00:00
|
|
|
surface.reset();
|
2017-01-18 15:08:39 +00:00
|
|
|
|
|
|
|
|
SkImageInfo ii = SkImageInfo::Make(w, h, kRGBA_8888_SkColorType, kPremul_SkAlphaType);
|
|
|
|
|
grSurfaceContext->readPixels(ii, pixels.get(), 0, 0, 0);
|
2016-02-05 15:17:34 +00:00
|
|
|
for (int y = 0; y < h; ++y) {
|
|
|
|
|
for (int x = 0; x < w; ++x) {
|
|
|
|
|
uint32_t pixel = pixels.get()[y * w + x];
|
|
|
|
|
if (pixel != expectedValue) {
|
|
|
|
|
SkString msg;
|
|
|
|
|
if (expectedValue) {
|
|
|
|
|
msg = "SkSurface should have left render target unmodified";
|
|
|
|
|
} else {
|
|
|
|
|
msg = "SkSurface should have cleared the render target";
|
|
|
|
|
}
|
|
|
|
|
ERRORF(reporter,
|
|
|
|
|
"%s but read 0x%08x (instead of 0x%08x) at %x,%d", msg.c_str(), pixel,
|
|
|
|
|
expectedValue, x, y);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2016-04-06 21:02:39 +00:00
|
|
|
DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(SurfaceClear_Gpu, reporter, ctxInfo) {
|
2016-05-11 13:33:06 +00:00
|
|
|
GrContext* context = ctxInfo.grContext();
|
2018-01-22 15:48:15 +00:00
|
|
|
GrGpu* gpu = context->contextPriv().getGpu();
|
2016-05-04 19:01:58 +00:00
|
|
|
|
2017-01-18 15:08:39 +00:00
|
|
|
std::function<sk_sp<GrSurfaceContext>(SkSurface*)> grSurfaceContextGetters[] = {
|
|
|
|
|
[] (SkSurface* s){
|
|
|
|
|
return sk_ref_sp(s->getCanvas()->internal_private_accessTopLayerRenderTargetContext());
|
|
|
|
|
},
|
2016-06-28 15:07:26 +00:00
|
|
|
[] (SkSurface* s){
|
2017-01-18 15:08:39 +00:00
|
|
|
sk_sp<SkImage> i(s->makeImageSnapshot());
|
|
|
|
|
SkImage_Gpu* gpuImage = (SkImage_Gpu *) as_IB(i);
|
2017-01-31 16:31:39 +00:00
|
|
|
sk_sp<GrTextureProxy> proxy = gpuImage->asTextureProxyRef();
|
2017-01-18 15:08:39 +00:00
|
|
|
GrContext* context = gpuImage->context();
|
|
|
|
|
return context->contextPriv().makeWrappedSurfaceContext(std::move(proxy),
|
|
|
|
|
gpuImage->refColorSpace());
|
|
|
|
|
}
|
2016-02-05 15:17:34 +00:00
|
|
|
};
|
2016-05-04 19:01:58 +00:00
|
|
|
|
2017-01-18 15:08:39 +00:00
|
|
|
for (auto grSurfaceGetter : grSurfaceContextGetters) {
|
2016-05-04 19:01:58 +00:00
|
|
|
// Test that non-wrapped RTs are created clear.
|
2016-02-05 15:17:34 +00:00
|
|
|
for (auto& surface_func : {&create_gpu_surface, &create_gpu_scratch_surface}) {
|
2016-03-24 01:59:25 +00:00
|
|
|
auto surface = surface_func(context, kPremul_SkAlphaType, nullptr);
|
2016-02-05 15:17:34 +00:00
|
|
|
test_surface_clear(reporter, surface, grSurfaceGetter, 0x0);
|
|
|
|
|
}
|
|
|
|
|
// Wrapped RTs are *not* supposed to clear (to allow client to partially update a surface).
|
2016-05-04 19:01:58 +00:00
|
|
|
const uint32_t kOrigColor = 0xABABABAB;
|
|
|
|
|
for (auto& surfaceFunc : {&create_gpu_surface_backend_texture,
|
|
|
|
|
&create_gpu_surface_backend_texture_as_render_target}) {
|
2017-12-12 18:01:25 +00:00
|
|
|
GrBackendTexture backendTex;
|
2018-02-03 01:32:49 +00:00
|
|
|
auto surface = surfaceFunc(context, 1, kOrigColor, &backendTex);
|
2016-05-04 19:01:58 +00:00
|
|
|
test_surface_clear(reporter, surface, grSurfaceGetter, kOrigColor);
|
|
|
|
|
surface.reset();
|
2018-03-09 14:33:19 +00:00
|
|
|
gpu->deleteTestingOnlyBackendTexture(backendTex);
|
2016-05-04 19:01:58 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void test_surface_draw_partially(
|
|
|
|
|
skiatest::Reporter* reporter, sk_sp<SkSurface> surface, uint32_t origColor) {
|
|
|
|
|
const int kW = surface->width();
|
|
|
|
|
const int kH = surface->height();
|
|
|
|
|
SkPaint paint;
|
|
|
|
|
const SkColor kRectColor = ~origColor | 0xFF000000;
|
|
|
|
|
paint.setColor(kRectColor);
|
|
|
|
|
surface->getCanvas()->drawRect(SkRect::MakeWH(SkIntToScalar(kW), SkIntToScalar(kH)/2),
|
|
|
|
|
paint);
|
2016-11-02 21:07:33 +00:00
|
|
|
std::unique_ptr<uint32_t[]> pixels(new uint32_t[kW * kH]);
|
2016-05-04 19:01:58 +00:00
|
|
|
sk_memset32(pixels.get(), ~origColor, kW * kH);
|
|
|
|
|
// Read back RGBA to avoid format conversions that may not be supported on all platforms.
|
|
|
|
|
SkImageInfo readInfo = SkImageInfo::Make(kW, kH, kRGBA_8888_SkColorType, kPremul_SkAlphaType);
|
|
|
|
|
SkAssertResult(surface->readPixels(readInfo, pixels.get(), kW * sizeof(uint32_t), 0, 0));
|
|
|
|
|
bool stop = false;
|
|
|
|
|
SkPMColor origColorPM = SkPackARGB_as_RGBA((origColor >> 24 & 0xFF),
|
|
|
|
|
(origColor >> 0 & 0xFF),
|
|
|
|
|
(origColor >> 8 & 0xFF),
|
|
|
|
|
(origColor >> 16 & 0xFF));
|
|
|
|
|
SkPMColor rectColorPM = SkPackARGB_as_RGBA((kRectColor >> 24 & 0xFF),
|
|
|
|
|
(kRectColor >> 16 & 0xFF),
|
|
|
|
|
(kRectColor >> 8 & 0xFF),
|
|
|
|
|
(kRectColor >> 0 & 0xFF));
|
|
|
|
|
for (int y = 0; y < kH/2 && !stop; ++y) {
|
|
|
|
|
for (int x = 0; x < kW && !stop; ++x) {
|
|
|
|
|
REPORTER_ASSERT(reporter, rectColorPM == pixels[x + y * kW]);
|
|
|
|
|
if (rectColorPM != pixels[x + y * kW]) {
|
|
|
|
|
stop = true;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
stop = false;
|
|
|
|
|
for (int y = kH/2; y < kH && !stop; ++y) {
|
|
|
|
|
for (int x = 0; x < kW && !stop; ++x) {
|
|
|
|
|
REPORTER_ASSERT(reporter, origColorPM == pixels[x + y * kW]);
|
|
|
|
|
if (origColorPM != pixels[x + y * kW]) {
|
|
|
|
|
stop = true;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2016-02-05 15:17:34 +00:00
|
|
|
|
2016-06-28 15:07:26 +00:00
|
|
|
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfacePartialDraw_Gpu, reporter, ctxInfo) {
|
2018-01-22 15:48:15 +00:00
|
|
|
GrGpu* gpu = ctxInfo.grContext()->contextPriv().getGpu();
|
2016-05-04 19:01:58 +00:00
|
|
|
if (!gpu) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
static const uint32_t kOrigColor = 0xFFAABBCC;
|
2016-05-04 00:14:07 +00:00
|
|
|
|
2016-05-04 19:01:58 +00:00
|
|
|
for (auto& surfaceFunc : {&create_gpu_surface_backend_texture,
|
|
|
|
|
&create_gpu_surface_backend_texture_as_render_target}) {
|
|
|
|
|
// Validate that we can draw to the canvas and that the original texture color is
|
|
|
|
|
// preserved in pixels that aren't rendered to via the surface.
|
|
|
|
|
// This works only for non-multisampled case.
|
2017-12-12 18:01:25 +00:00
|
|
|
GrBackendTexture backendTex;
|
2018-02-03 01:32:49 +00:00
|
|
|
auto surface = surfaceFunc(ctxInfo.grContext(), 1, kOrigColor, &backendTex);
|
2016-05-04 19:01:58 +00:00
|
|
|
if (surface) {
|
|
|
|
|
test_surface_draw_partially(reporter, surface, kOrigColor);
|
|
|
|
|
surface.reset();
|
2018-03-09 14:33:19 +00:00
|
|
|
gpu->deleteTestingOnlyBackendTexture(backendTex);
|
2016-05-04 19:01:58 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2016-05-04 00:14:07 +00:00
|
|
|
|
2016-05-04 19:01:58 +00:00
|
|
|
|
|
|
|
|
DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(SurfaceAttachStencil_Gpu, reporter, ctxInfo) {
|
2018-01-22 15:48:15 +00:00
|
|
|
GrGpu* gpu = ctxInfo.grContext()->contextPriv().getGpu();
|
2016-05-04 19:01:58 +00:00
|
|
|
if (!gpu) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
2017-05-08 19:02:07 +00:00
|
|
|
if (gpu->caps()->avoidStencilBuffers()) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
2016-05-04 19:01:58 +00:00
|
|
|
static const uint32_t kOrigColor = 0xFFAABBCC;
|
|
|
|
|
|
2018-01-16 20:07:54 +00:00
|
|
|
auto resourceProvider = ctxInfo.grContext()->contextPriv().resourceProvider();
|
|
|
|
|
|
2016-05-04 19:01:58 +00:00
|
|
|
for (auto& surfaceFunc : {&create_gpu_surface_backend_texture,
|
|
|
|
|
&create_gpu_surface_backend_texture_as_render_target}) {
|
2018-02-03 01:32:49 +00:00
|
|
|
for (int sampleCnt : {1, 4, 8}) {
|
2017-12-12 18:01:25 +00:00
|
|
|
GrBackendTexture backendTex;
|
|
|
|
|
auto surface = surfaceFunc(ctxInfo.grContext(), sampleCnt, kOrigColor, &backendTex);
|
2016-05-04 19:01:58 +00:00
|
|
|
|
2018-02-03 01:32:49 +00:00
|
|
|
if (!surface && sampleCnt > 1) {
|
2017-12-12 18:01:25 +00:00
|
|
|
// Certain platforms don't support MSAA, skip these.
|
|
|
|
|
continue;
|
2016-05-04 19:01:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Validate that we can attach a stencil buffer to an SkSurface created by either of
|
|
|
|
|
// our surface functions.
|
2016-10-27 18:47:55 +00:00
|
|
|
GrRenderTarget* rt = surface->getCanvas()
|
|
|
|
|
->internal_private_accessTopLayerRenderTargetContext()->accessRenderTarget();
|
2018-01-16 20:07:54 +00:00
|
|
|
REPORTER_ASSERT(reporter, resourceProvider->attachStencilAttachment(rt));
|
2018-03-09 14:33:19 +00:00
|
|
|
gpu->deleteTestingOnlyBackendTexture(backendTex);
|
2016-05-04 19:01:58 +00:00
|
|
|
}
|
2016-02-05 15:17:34 +00:00
|
|
|
}
|
|
|
|
|
}
|
2016-08-30 14:07:59 +00:00
|
|
|
|
|
|
|
|
static void test_surface_creation_and_snapshot_with_color_space(
|
|
|
|
|
skiatest::Reporter* reporter,
|
|
|
|
|
const char* prefix,
|
2018-06-26 15:43:06 +00:00
|
|
|
bool supportsF16,
|
|
|
|
|
bool supportsF32,
|
2018-03-02 16:01:10 +00:00
|
|
|
bool supports1010102,
|
2016-08-30 14:07:59 +00:00
|
|
|
std::function<sk_sp<SkSurface>(const SkImageInfo&)> surfaceMaker) {
|
|
|
|
|
|
2017-02-07 18:56:11 +00:00
|
|
|
auto srgbColorSpace = SkColorSpace::MakeSRGB();
|
2017-12-12 19:09:31 +00:00
|
|
|
const SkMatrix44* srgbMatrix = srgbColorSpace->toXYZD50();
|
2016-10-18 17:02:51 +00:00
|
|
|
SkASSERT(srgbMatrix);
|
2016-10-28 16:51:08 +00:00
|
|
|
SkColorSpaceTransferFn oddGamma;
|
|
|
|
|
oddGamma.fA = 1.0f;
|
|
|
|
|
oddGamma.fB = oddGamma.fC = oddGamma.fD = oddGamma.fE = oddGamma.fF = 0.0f;
|
|
|
|
|
oddGamma.fG = 4.0f;
|
2016-10-24 13:24:02 +00:00
|
|
|
auto oddColorSpace = SkColorSpace::MakeRGB(oddGamma, *srgbMatrix);
|
2017-02-07 18:56:11 +00:00
|
|
|
auto linearColorSpace = SkColorSpace::MakeSRGBLinear();
|
2016-08-30 14:07:59 +00:00
|
|
|
|
|
|
|
|
const struct {
|
|
|
|
|
SkColorType fColorType;
|
|
|
|
|
sk_sp<SkColorSpace> fColorSpace;
|
|
|
|
|
bool fShouldWork;
|
|
|
|
|
const char* fDescription;
|
|
|
|
|
} testConfigs[] = {
|
2018-06-26 15:43:06 +00:00
|
|
|
{ kN32_SkColorType, nullptr, true, "N32-nullptr" },
|
|
|
|
|
{ kN32_SkColorType, linearColorSpace, true, "N32-linear" },
|
|
|
|
|
{ kN32_SkColorType, srgbColorSpace, true, "N32-srgb" },
|
|
|
|
|
{ kN32_SkColorType, oddColorSpace, true, "N32-odd" },
|
|
|
|
|
{ kRGBA_F16_SkColorType, nullptr, supportsF16, "F16-nullptr" },
|
|
|
|
|
{ kRGBA_F16_SkColorType, linearColorSpace, supportsF16, "F16-linear" },
|
|
|
|
|
{ kRGBA_F16_SkColorType, srgbColorSpace, supportsF16, "F16-srgb" },
|
|
|
|
|
{ kRGBA_F16_SkColorType, oddColorSpace, supportsF16, "F16-odd" },
|
|
|
|
|
{ kRGBA_F32_SkColorType, nullptr, supportsF32, "F32-nullptr" },
|
|
|
|
|
{ kRGBA_F32_SkColorType, linearColorSpace, supportsF32, "F32-linear" },
|
|
|
|
|
{ kRGBA_F32_SkColorType, srgbColorSpace, supportsF32, "F32-srgb" },
|
|
|
|
|
{ kRGBA_F32_SkColorType, oddColorSpace, supportsF32, "F32-odd" },
|
|
|
|
|
{ kRGB_565_SkColorType, srgbColorSpace, false, "565-srgb" },
|
|
|
|
|
{ kAlpha_8_SkColorType, srgbColorSpace, false, "A8-srgb" },
|
|
|
|
|
{ kRGBA_1010102_SkColorType, nullptr, supports1010102, "1010102-nullptr" },
|
2016-08-30 14:07:59 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
for (auto& testConfig : testConfigs) {
|
|
|
|
|
SkString fullTestName = SkStringPrintf("%s-%s", prefix, testConfig.fDescription);
|
|
|
|
|
SkImageInfo info = SkImageInfo::Make(10, 10, testConfig.fColorType, kPremul_SkAlphaType,
|
|
|
|
|
testConfig.fColorSpace);
|
|
|
|
|
|
|
|
|
|
auto surface(surfaceMaker(info));
|
2018-06-26 15:43:06 +00:00
|
|
|
REPORTER_ASSERT(reporter,
|
|
|
|
|
SkToBool(surface) == testConfig.fShouldWork, fullTestName.c_str());
|
2016-08-30 14:07:59 +00:00
|
|
|
|
2018-06-26 15:43:06 +00:00
|
|
|
if (testConfig.fShouldWork && surface) {
|
2016-08-30 14:07:59 +00:00
|
|
|
sk_sp<SkImage> image(surface->makeImageSnapshot());
|
2018-01-29 14:50:47 +00:00
|
|
|
REPORTER_ASSERT(reporter, image, testConfig.fDescription);
|
2016-08-30 14:07:59 +00:00
|
|
|
SkColorSpace* imageColorSpace = as_IB(image)->onImageInfo().colorSpace();
|
2018-01-29 14:50:47 +00:00
|
|
|
REPORTER_ASSERT(reporter, imageColorSpace == testConfig.fColorSpace.get(),
|
|
|
|
|
fullTestName.c_str());
|
2016-08-30 14:07:59 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
DEF_TEST(SurfaceCreationWithColorSpace, reporter) {
|
|
|
|
|
auto surfaceMaker = [](const SkImageInfo& info) {
|
|
|
|
|
return SkSurface::MakeRaster(info);
|
|
|
|
|
};
|
|
|
|
|
|
2018-06-26 15:43:06 +00:00
|
|
|
test_surface_creation_and_snapshot_with_color_space(reporter, "raster",
|
|
|
|
|
true, true, true,
|
2018-03-02 16:01:10 +00:00
|
|
|
surfaceMaker);
|
2016-08-30 14:07:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceCreationWithColorSpace_Gpu, reporter, ctxInfo) {
|
2018-05-11 14:14:21 +00:00
|
|
|
auto context = ctxInfo.grContext();
|
2018-01-22 15:48:15 +00:00
|
|
|
|
2018-06-26 15:43:06 +00:00
|
|
|
bool supportsF16 = context->contextPriv().caps()->isConfigRenderable(kRGBA_half_GrPixelConfig),
|
|
|
|
|
supportsF32 = context->contextPriv().caps()->isConfigRenderable(kRGBA_float_GrPixelConfig),
|
|
|
|
|
supports1010102 = context->contextPriv().caps()->isConfigRenderable(kRGBA_1010102_GrPixelConfig);
|
|
|
|
|
|
2016-08-30 14:07:59 +00:00
|
|
|
auto surfaceMaker = [context](const SkImageInfo& info) {
|
|
|
|
|
return SkSurface::MakeRenderTarget(context, SkBudgeted::kNo, info);
|
|
|
|
|
};
|
|
|
|
|
|
2018-06-26 15:43:06 +00:00
|
|
|
test_surface_creation_and_snapshot_with_color_space(reporter, "gpu",
|
|
|
|
|
supportsF16, supportsF32, supports1010102,
|
|
|
|
|
surfaceMaker);
|
2016-08-30 14:07:59 +00:00
|
|
|
|
2017-12-12 18:01:25 +00:00
|
|
|
std::vector<GrBackendTexture> backendTextures;
|
|
|
|
|
auto wrappedSurfaceMaker = [ context, &backendTextures ](const SkImageInfo& info) {
|
2018-01-22 15:48:15 +00:00
|
|
|
GrGpu* gpu = context->contextPriv().getGpu();
|
|
|
|
|
|
Revert "Revert "Plumb GrBackendTexture throughout skia.""
This reverts commit 7fa5c31c2c9af834bee66d5fcf476e250076c8d6.
Reason for revert: Relanding this change now that other fixes have landed.
Original change's description:
> Revert "Plumb GrBackendTexture throughout skia."
>
> This reverts commit 7da62b9059f3c1d31624a0e4da96ee5f908f9c12.
>
> Reason for revert: fix android roll
>
> Original change's description:
> > Plumb GrBackendTexture throughout skia.
> >
> > Bug: skia:
> > Change-Id: I1bae6768ee7229818a83ba608035a1f7867e6875
> > Reviewed-on: https://skia-review.googlesource.com/13645
> > Commit-Queue: Greg Daniel <egdaniel@google.com>
> > Reviewed-by: Robert Phillips <robertphillips@google.com>
> >
>
> TBR=egdaniel@google.com,bsalomon@google.com,robertphillips@google.com,brianosman@google.com,reviews@skia.org,stani@google.com
> NOPRESUBMIT=true
> NOTREECHECKS=true
> NOTRY=true
>
> Change-Id: I5cb8763cc837c83ebc6d10366fe2dd3efe35fb89
> Reviewed-on: https://skia-review.googlesource.com/13773
> Reviewed-by: Stan Iliev <stani@google.com>
> Commit-Queue: Stan Iliev <stani@google.com>
>
TBR=egdaniel@google.com,bsalomon@google.com,robertphillips@google.com,reviews@skia.org,brianosman@google.com,stani@google.com
# Not skipping CQ checks because original CL landed > 1 day ago.
Change-Id: I92bc074e4fe37fa5c83186afadc472c03802e8f2
Reviewed-on: https://skia-review.googlesource.com/13975
Reviewed-by: Greg Daniel <egdaniel@google.com>
Commit-Queue: Greg Daniel <egdaniel@google.com>
2017-04-20 16:41:55 +00:00
|
|
|
static const int kSize = 10;
|
Dest color space no longer impacts mipmaps or texture sampling
PS5: Removes SkDestinationSurfaceColorMode, tracking of mipmap
mode on GrTexture, sRGB decode state per-texture. Because we
were often choosing sRGB configs for RGB color types, legacy
rendering would then be incorrect (too dark). So...
PS7: Stops ever using sRGB pixel configs when translating
image info or color type. Also removes a bunch of GrCaps bits
and a GrContextOption that are no longer relevant.
PS9: Adjusts surface creation unit test expectations, and
changes the raster rules accordingly.
At this point, sRGB configs are (obviously) going to be broken.
Locally, I ran 8888, gl, and the gbr- versions of both. Across
all GMs x configs, there are 13 diffs. 12 are GMs that create
surfaces with a color-space attached (and thus, the offscreen
is no longer getting sRGB pixel config). The only remainder
constructs an SkPictureImageGenerator, (with an attached color
space) and renders it to the gbr-gl canvas, which triggers a
a tagged surface inside the generator.
Bug: skia:
Change-Id: Ie5edfa157dd799f3121e8173fc4f97f6c8ed6789
Reviewed-on: https://skia-review.googlesource.com/131282
Commit-Queue: Brian Osman <brianosman@google.com>
Reviewed-by: Mike Klein <mtklein@google.com>
Reviewed-by: Brian Salomon <bsalomon@google.com>
2018-06-01 16:25:08 +00:00
|
|
|
GrPixelConfig config = SkImageInfo2GrPixelConfig(info);
|
2018-02-21 18:02:32 +00:00
|
|
|
SkASSERT(kUnknown_GrPixelConfig != config);
|
Revert "Revert "Plumb GrBackendTexture throughout skia.""
This reverts commit 7fa5c31c2c9af834bee66d5fcf476e250076c8d6.
Reason for revert: Relanding this change now that other fixes have landed.
Original change's description:
> Revert "Plumb GrBackendTexture throughout skia."
>
> This reverts commit 7da62b9059f3c1d31624a0e4da96ee5f908f9c12.
>
> Reason for revert: fix android roll
>
> Original change's description:
> > Plumb GrBackendTexture throughout skia.
> >
> > Bug: skia:
> > Change-Id: I1bae6768ee7229818a83ba608035a1f7867e6875
> > Reviewed-on: https://skia-review.googlesource.com/13645
> > Commit-Queue: Greg Daniel <egdaniel@google.com>
> > Reviewed-by: Robert Phillips <robertphillips@google.com>
> >
>
> TBR=egdaniel@google.com,bsalomon@google.com,robertphillips@google.com,brianosman@google.com,reviews@skia.org,stani@google.com
> NOPRESUBMIT=true
> NOTREECHECKS=true
> NOTRY=true
>
> Change-Id: I5cb8763cc837c83ebc6d10366fe2dd3efe35fb89
> Reviewed-on: https://skia-review.googlesource.com/13773
> Reviewed-by: Stan Iliev <stani@google.com>
> Commit-Queue: Stan Iliev <stani@google.com>
>
TBR=egdaniel@google.com,bsalomon@google.com,robertphillips@google.com,reviews@skia.org,brianosman@google.com,stani@google.com
# Not skipping CQ checks because original CL landed > 1 day ago.
Change-Id: I92bc074e4fe37fa5c83186afadc472c03802e8f2
Reviewed-on: https://skia-review.googlesource.com/13975
Reviewed-by: Greg Daniel <egdaniel@google.com>
Commit-Queue: Greg Daniel <egdaniel@google.com>
2017-04-20 16:41:55 +00:00
|
|
|
|
2018-01-22 15:48:15 +00:00
|
|
|
GrBackendTexture backendTex = gpu->createTestingOnlyBackendTexture(
|
2017-12-12 18:01:25 +00:00
|
|
|
nullptr, kSize, kSize, config, true, GrMipMapped::kNo);
|
Revert "Revert "Plumb GrBackendTexture throughout skia.""
This reverts commit 7fa5c31c2c9af834bee66d5fcf476e250076c8d6.
Reason for revert: Relanding this change now that other fixes have landed.
Original change's description:
> Revert "Plumb GrBackendTexture throughout skia."
>
> This reverts commit 7da62b9059f3c1d31624a0e4da96ee5f908f9c12.
>
> Reason for revert: fix android roll
>
> Original change's description:
> > Plumb GrBackendTexture throughout skia.
> >
> > Bug: skia:
> > Change-Id: I1bae6768ee7229818a83ba608035a1f7867e6875
> > Reviewed-on: https://skia-review.googlesource.com/13645
> > Commit-Queue: Greg Daniel <egdaniel@google.com>
> > Reviewed-by: Robert Phillips <robertphillips@google.com>
> >
>
> TBR=egdaniel@google.com,bsalomon@google.com,robertphillips@google.com,brianosman@google.com,reviews@skia.org,stani@google.com
> NOPRESUBMIT=true
> NOTREECHECKS=true
> NOTRY=true
>
> Change-Id: I5cb8763cc837c83ebc6d10366fe2dd3efe35fb89
> Reviewed-on: https://skia-review.googlesource.com/13773
> Reviewed-by: Stan Iliev <stani@google.com>
> Commit-Queue: Stan Iliev <stani@google.com>
>
TBR=egdaniel@google.com,bsalomon@google.com,robertphillips@google.com,reviews@skia.org,brianosman@google.com,stani@google.com
# Not skipping CQ checks because original CL landed > 1 day ago.
Change-Id: I92bc074e4fe37fa5c83186afadc472c03802e8f2
Reviewed-on: https://skia-review.googlesource.com/13975
Reviewed-by: Greg Daniel <egdaniel@google.com>
Commit-Queue: Greg Daniel <egdaniel@google.com>
2017-04-20 16:41:55 +00:00
|
|
|
|
2018-01-10 14:57:53 +00:00
|
|
|
if (!backendTex.isValid() ||
|
2018-01-22 15:48:15 +00:00
|
|
|
!gpu->isTestingOnlyBackendTexture(backendTex)) {
|
2016-08-30 14:07:59 +00:00
|
|
|
return sk_sp<SkSurface>(nullptr);
|
|
|
|
|
}
|
2017-12-12 18:01:25 +00:00
|
|
|
backendTextures.push_back(backendTex);
|
2016-08-30 14:07:59 +00:00
|
|
|
|
Revert "Revert "Plumb GrBackendTexture throughout skia.""
This reverts commit 7fa5c31c2c9af834bee66d5fcf476e250076c8d6.
Reason for revert: Relanding this change now that other fixes have landed.
Original change's description:
> Revert "Plumb GrBackendTexture throughout skia."
>
> This reverts commit 7da62b9059f3c1d31624a0e4da96ee5f908f9c12.
>
> Reason for revert: fix android roll
>
> Original change's description:
> > Plumb GrBackendTexture throughout skia.
> >
> > Bug: skia:
> > Change-Id: I1bae6768ee7229818a83ba608035a1f7867e6875
> > Reviewed-on: https://skia-review.googlesource.com/13645
> > Commit-Queue: Greg Daniel <egdaniel@google.com>
> > Reviewed-by: Robert Phillips <robertphillips@google.com>
> >
>
> TBR=egdaniel@google.com,bsalomon@google.com,robertphillips@google.com,brianosman@google.com,reviews@skia.org,stani@google.com
> NOPRESUBMIT=true
> NOTREECHECKS=true
> NOTRY=true
>
> Change-Id: I5cb8763cc837c83ebc6d10366fe2dd3efe35fb89
> Reviewed-on: https://skia-review.googlesource.com/13773
> Reviewed-by: Stan Iliev <stani@google.com>
> Commit-Queue: Stan Iliev <stani@google.com>
>
TBR=egdaniel@google.com,bsalomon@google.com,robertphillips@google.com,reviews@skia.org,brianosman@google.com,stani@google.com
# Not skipping CQ checks because original CL landed > 1 day ago.
Change-Id: I92bc074e4fe37fa5c83186afadc472c03802e8f2
Reviewed-on: https://skia-review.googlesource.com/13975
Reviewed-by: Greg Daniel <egdaniel@google.com>
Commit-Queue: Greg Daniel <egdaniel@google.com>
2017-04-20 16:41:55 +00:00
|
|
|
return SkSurface::MakeFromBackendTexture(context, backendTex,
|
2017-07-21 19:37:19 +00:00
|
|
|
kTopLeft_GrSurfaceOrigin, 0,
|
2017-12-19 18:15:02 +00:00
|
|
|
info.colorType(),
|
Revert "Revert "Plumb GrBackendTexture throughout skia.""
This reverts commit 7fa5c31c2c9af834bee66d5fcf476e250076c8d6.
Reason for revert: Relanding this change now that other fixes have landed.
Original change's description:
> Revert "Plumb GrBackendTexture throughout skia."
>
> This reverts commit 7da62b9059f3c1d31624a0e4da96ee5f908f9c12.
>
> Reason for revert: fix android roll
>
> Original change's description:
> > Plumb GrBackendTexture throughout skia.
> >
> > Bug: skia:
> > Change-Id: I1bae6768ee7229818a83ba608035a1f7867e6875
> > Reviewed-on: https://skia-review.googlesource.com/13645
> > Commit-Queue: Greg Daniel <egdaniel@google.com>
> > Reviewed-by: Robert Phillips <robertphillips@google.com>
> >
>
> TBR=egdaniel@google.com,bsalomon@google.com,robertphillips@google.com,brianosman@google.com,reviews@skia.org,stani@google.com
> NOPRESUBMIT=true
> NOTREECHECKS=true
> NOTRY=true
>
> Change-Id: I5cb8763cc837c83ebc6d10366fe2dd3efe35fb89
> Reviewed-on: https://skia-review.googlesource.com/13773
> Reviewed-by: Stan Iliev <stani@google.com>
> Commit-Queue: Stan Iliev <stani@google.com>
>
TBR=egdaniel@google.com,bsalomon@google.com,robertphillips@google.com,reviews@skia.org,brianosman@google.com,stani@google.com
# Not skipping CQ checks because original CL landed > 1 day ago.
Change-Id: I92bc074e4fe37fa5c83186afadc472c03802e8f2
Reviewed-on: https://skia-review.googlesource.com/13975
Reviewed-by: Greg Daniel <egdaniel@google.com>
Commit-Queue: Greg Daniel <egdaniel@google.com>
2017-04-20 16:41:55 +00:00
|
|
|
sk_ref_sp(info.colorSpace()), nullptr);
|
2016-08-30 14:07:59 +00:00
|
|
|
};
|
|
|
|
|
|
2018-06-26 15:43:06 +00:00
|
|
|
test_surface_creation_and_snapshot_with_color_space(reporter, "wrapped",
|
|
|
|
|
supportsF16, supportsF32, supports1010102,
|
|
|
|
|
wrappedSurfaceMaker);
|
2016-08-30 14:07:59 +00:00
|
|
|
|
2017-05-11 20:29:14 +00:00
|
|
|
context->flush();
|
|
|
|
|
|
2018-01-22 15:48:15 +00:00
|
|
|
GrGpu* gpu = context->contextPriv().getGpu();
|
2018-04-10 14:26:44 +00:00
|
|
|
gpu->testingOnly_flushGpuAndSync();
|
2017-12-12 18:01:25 +00:00
|
|
|
for (auto backendTex : backendTextures) {
|
2018-03-09 14:33:19 +00:00
|
|
|
gpu->deleteTestingOnlyBackendTexture(backendTex);
|
2016-08-30 14:07:59 +00:00
|
|
|
}
|
|
|
|
|
}
|
2016-11-22 16:31:41 +00:00
|
|
|
|
|
|
|
|
static void test_overdraw_surface(skiatest::Reporter* r, SkSurface* surface) {
|
2016-11-28 23:28:07 +00:00
|
|
|
SkOverdrawCanvas canvas(surface->getCanvas());
|
|
|
|
|
canvas.drawPaint(SkPaint());
|
2016-11-22 16:31:41 +00:00
|
|
|
sk_sp<SkImage> image = surface->makeImageSnapshot();
|
|
|
|
|
|
|
|
|
|
SkBitmap bitmap;
|
2018-02-07 20:51:00 +00:00
|
|
|
image->asLegacyBitmap(&bitmap);
|
2016-11-22 16:31:41 +00:00
|
|
|
for (int y = 0; y < 10; y++) {
|
|
|
|
|
for (int x = 0; x < 10; x++) {
|
|
|
|
|
REPORTER_ASSERT(r, 1 == SkGetPackedA32(*bitmap.getAddr32(x, y)));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
DEF_TEST(OverdrawSurface_Raster, r) {
|
|
|
|
|
sk_sp<SkSurface> surface = create_surface();
|
|
|
|
|
test_overdraw_surface(r, surface.get());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(OverdrawSurface_Gpu, r, ctxInfo) {
|
|
|
|
|
GrContext* context = ctxInfo.grContext();
|
|
|
|
|
sk_sp<SkSurface> surface = create_gpu_surface(context);
|
|
|
|
|
test_overdraw_surface(r, surface.get());
|
|
|
|
|
}
|
2017-06-28 23:57:21 +00:00
|
|
|
|
|
|
|
|
DEF_TEST(Surface_null, r) {
|
|
|
|
|
REPORTER_ASSERT(r, SkSurface::MakeNull(0, 0) == nullptr);
|
|
|
|
|
|
|
|
|
|
const int w = 37;
|
|
|
|
|
const int h = 1000;
|
|
|
|
|
auto surf = SkSurface::MakeNull(w, h);
|
|
|
|
|
auto canvas = surf->getCanvas();
|
|
|
|
|
|
|
|
|
|
canvas->drawPaint(SkPaint()); // should not crash, but don't expect anything to draw
|
|
|
|
|
REPORTER_ASSERT(r, surf->makeImageSnapshot() == nullptr);
|
|
|
|
|
}
|
2018-02-07 21:05:29 +00:00
|
|
|
|
|
|
|
|
// assert: if a given imageinfo is valid for a surface, then it must be valid for an image
|
|
|
|
|
// (so the snapshot can succeed)
|
|
|
|
|
DEF_TEST(surface_image_unity, reporter) {
|
|
|
|
|
auto do_test = [reporter](const SkImageInfo& info) {
|
|
|
|
|
size_t rowBytes = info.minRowBytes();
|
|
|
|
|
auto surf = SkSurface::MakeRaster(info, rowBytes, nullptr);
|
|
|
|
|
if (surf) {
|
|
|
|
|
auto img = surf->makeImageSnapshot();
|
|
|
|
|
if (!img && false) { // change to true to document the differences
|
|
|
|
|
SkDebugf("image failed: [%08X %08X] %14s %s\n",
|
|
|
|
|
info.width(), info.height(),
|
|
|
|
|
sk_tool_utils::colortype_name(info.colorType()),
|
|
|
|
|
sk_tool_utils::alphatype_name(info.alphaType()));
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
REPORTER_ASSERT(reporter, img != nullptr);
|
|
|
|
|
|
|
|
|
|
char dummyPixel = 0; // just need a valid address (not a valid size)
|
|
|
|
|
SkPixmap pmap = { info, &dummyPixel, rowBytes };
|
|
|
|
|
img = SkImage::MakeFromRaster(pmap, nullptr, nullptr);
|
|
|
|
|
REPORTER_ASSERT(reporter, img != nullptr);
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
2018-02-20 16:55:48 +00:00
|
|
|
const int32_t sizes[] = { 0, 1, 1 << 15, 1 << 16, 1 << 18, 1 << 28, 1 << 29, 1 << 30, -1 };
|
2018-02-16 15:08:10 +00:00
|
|
|
for (int cti = 0; cti <= kLastEnum_SkColorType; ++cti) {
|
2018-02-07 21:05:29 +00:00
|
|
|
SkColorType ct = static_cast<SkColorType>(cti);
|
2018-02-16 15:08:10 +00:00
|
|
|
for (int ati = 0; ati <= kLastEnum_SkAlphaType; ++ati) {
|
2018-02-07 21:05:29 +00:00
|
|
|
SkAlphaType at = static_cast<SkAlphaType>(ati);
|
|
|
|
|
for (int32_t size : sizes) {
|
2018-02-20 16:55:48 +00:00
|
|
|
// Large allocations tend to make the 32-bit bots run out of virtual address space.
|
|
|
|
|
if (sizeof(size_t) == 4 && size > (1<<20)) {
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2018-02-07 21:05:29 +00:00
|
|
|
do_test(SkImageInfo::Make(1, size, ct, at));
|
|
|
|
|
do_test(SkImageInfo::Make(size, 1, ct, at));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
