blob: d71dda8dc04d2a047a982b1968306b4026decef5 [file] [log] [blame]
Greg Daniel177e6952017-10-12 12:27:11 -04001/*
2 * Copyright 2017 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8#include "SkTypes.h"
9
10#if SK_SUPPORT_GPU
11
12#include "GrBackendSurface.h"
Greg Daniel261b8aa2017-10-23 09:37:36 -040013#include "GrBackendTextureImageGenerator.h"
Greg Daniel177e6952017-10-12 12:27:11 -040014#include "GrContext.h"
15#include "GrContextPriv.h"
16#include "GrGpu.h"
17#include "GrRenderTargetContext.h"
Greg Daniel261b8aa2017-10-23 09:37:36 -040018#include "GrSemaphore.h"
Greg Daniel177e6952017-10-12 12:27:11 -040019#include "GrSurfaceProxyPriv.h"
20#include "GrTest.h"
21#include "GrTexturePriv.h"
22#include "GrTextureProxy.h"
23#include "SkCanvas.h"
24#include "SkImage_Base.h"
25#include "SkGpuDevice.h"
Greg Daniel261b8aa2017-10-23 09:37:36 -040026#include "SkPoint.h"
Greg Daniel177e6952017-10-12 12:27:11 -040027#include "SkSurface.h"
28#include "SkSurface_Gpu.h"
29#include "Test.h"
30
Greg Daniel45d63032017-10-30 13:41:26 -040031static constexpr int kSize = 8;
32
Greg Daniel177e6952017-10-12 12:27:11 -040033// Test that the correct mip map states are on the GrTextures when wrapping GrBackendTextures in
34// SkImages and SkSurfaces
35DEF_GPUTEST_FOR_RENDERING_CONTEXTS(GrWrappedMipMappedTest, reporter, ctxInfo) {
36 GrContext* context = ctxInfo.grContext();
Greg Daniel261b8aa2017-10-23 09:37:36 -040037 if (!context->caps()->mipMapSupport()) {
38 return;
39 }
Robert Phillipsf35fd8d2018-01-22 10:48:15 -050040 GrGpu* gpu = context->contextPriv().getGpu();
41
Greg Daniel177e6952017-10-12 12:27:11 -040042 for (auto mipMapped : {GrMipMapped::kNo, GrMipMapped::kYes}) {
43 for (auto isRT : {false, true}) {
44 // CreateTestingOnlyBackendTexture currently doesn't support uploading data to mip maps
45 // so we don't send any. However, we pretend there is data for the checks below which is
46 // fine since we are never actually using these textures for any work on the gpu.
Robert Phillipsf35fd8d2018-01-22 10:48:15 -050047 GrBackendTexture backendTex = gpu->createTestingOnlyBackendTexture(
Robert Phillips57e08282017-11-16 14:59:48 -050048 nullptr, kSize, kSize, kRGBA_8888_GrPixelConfig, isRT, mipMapped);
Greg Daniel177e6952017-10-12 12:27:11 -040049
Robert Phillipse0070c02017-11-13 12:47:24 -050050 sk_sp<GrTextureProxy> proxy;
Greg Daniel177e6952017-10-12 12:27:11 -040051 sk_sp<SkImage> image;
52 if (isRT) {
53 sk_sp<SkSurface> surface = SkSurface::MakeFromBackendTexture(
54 context,
55 backendTex,
56 kTopLeft_GrSurfaceOrigin,
57 0,
Greg Danielfaa095e2017-12-19 13:15:02 -050058 kRGBA_8888_SkColorType,
Greg Daniel177e6952017-10-12 12:27:11 -040059 nullptr,
60 nullptr);
61
62 SkGpuDevice* device = ((SkSurface_Gpu*)surface.get())->getDevice();
Robert Phillipse0070c02017-11-13 12:47:24 -050063 proxy = device->accessRenderTargetContext()->asTextureProxyRef();
Greg Daniel177e6952017-10-12 12:27:11 -040064 } else {
65 image = SkImage::MakeFromTexture(context, backendTex,
66 kTopLeft_GrSurfaceOrigin,
Greg Danielf5d87582017-12-18 14:48:15 -050067 kRGBA_8888_SkColorType,
68 kPremul_SkAlphaType, nullptr,
69 nullptr, nullptr);
Robert Phillipse0070c02017-11-13 12:47:24 -050070 proxy = as_IB(image)->asTextureProxyRef();
Greg Daniel177e6952017-10-12 12:27:11 -040071 }
72 REPORTER_ASSERT(reporter, proxy);
73 if (!proxy) {
Brian Salomon26102cb2018-03-09 09:33:19 -050074 gpu->deleteTestingOnlyBackendTexture(backendTex);
Greg Daniel177e6952017-10-12 12:27:11 -040075 return;
76 }
77
78 REPORTER_ASSERT(reporter, proxy->priv().isInstantiated());
79
80 GrTexture* texture = proxy->priv().peekTexture();
81 REPORTER_ASSERT(reporter, texture);
82 if (!texture) {
Brian Salomon26102cb2018-03-09 09:33:19 -050083 gpu->deleteTestingOnlyBackendTexture(backendTex);
Greg Daniel177e6952017-10-12 12:27:11 -040084 return;
85 }
86
87 if (GrMipMapped::kYes == mipMapped) {
Greg Daniele252f082017-10-23 16:05:23 -040088 REPORTER_ASSERT(reporter, GrMipMapped::kYes == texture->texturePriv().mipMapped());
Greg Daniel177e6952017-10-12 12:27:11 -040089 if (isRT) {
90 REPORTER_ASSERT(reporter, texture->texturePriv().mipMapsAreDirty());
91 } else {
92 REPORTER_ASSERT(reporter, !texture->texturePriv().mipMapsAreDirty());
93 }
94 } else {
Greg Daniele252f082017-10-23 16:05:23 -040095 REPORTER_ASSERT(reporter, GrMipMapped::kNo == texture->texturePriv().mipMapped());
Greg Daniel177e6952017-10-12 12:27:11 -040096 }
Brian Salomon26102cb2018-03-09 09:33:19 -050097 gpu->deleteTestingOnlyBackendTexture(backendTex);
Greg Daniel177e6952017-10-12 12:27:11 -040098 }
99 }
100}
101
Greg Daniel261b8aa2017-10-23 09:37:36 -0400102// Test that we correctly copy or don't copy GrBackendTextures in the GrBackendTextureImageGenerator
103// based on if we will use mips in the draw and the mip status of the GrBackendTexture.
104DEF_GPUTEST_FOR_RENDERING_CONTEXTS(GrBackendTextureImageMipMappedTest, reporter, ctxInfo) {
Greg Daniel261b8aa2017-10-23 09:37:36 -0400105 GrContext* context = ctxInfo.grContext();
106 if (!context->caps()->mipMapSupport()) {
107 return;
108 }
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500109 GrGpu* gpu = context->contextPriv().getGpu();
110
Greg Daniel261b8aa2017-10-23 09:37:36 -0400111 for (auto mipMapped : {GrMipMapped::kNo, GrMipMapped::kYes}) {
112 for (auto willUseMips : {false, true}) {
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500113 GrBackendTexture backendTex = gpu->createTestingOnlyBackendTexture(
Greg Daniel261b8aa2017-10-23 09:37:36 -0400114 nullptr, kSize, kSize, kRGBA_8888_GrPixelConfig, false, mipMapped);
115
Greg Daniel261b8aa2017-10-23 09:37:36 -0400116 sk_sp<SkImage> image = SkImage::MakeFromTexture(context, backendTex,
117 kTopLeft_GrSurfaceOrigin,
Greg Danielf5d87582017-12-18 14:48:15 -0500118 kRGBA_8888_SkColorType,
119 kPremul_SkAlphaType, nullptr,
120 nullptr, nullptr);
Greg Daniel261b8aa2017-10-23 09:37:36 -0400121
122 GrTextureProxy* proxy = as_IB(image)->peekProxy();
123 REPORTER_ASSERT(reporter, proxy);
124 if (!proxy) {
Brian Salomon26102cb2018-03-09 09:33:19 -0500125 gpu->deleteTestingOnlyBackendTexture(backendTex);
Greg Daniel261b8aa2017-10-23 09:37:36 -0400126 return;
127 }
128
129 REPORTER_ASSERT(reporter, proxy->priv().isInstantiated());
130
131 sk_sp<GrTexture> texture = sk_ref_sp(proxy->priv().peekTexture());
132 REPORTER_ASSERT(reporter, texture);
133 if (!texture) {
Brian Salomon26102cb2018-03-09 09:33:19 -0500134 gpu->deleteTestingOnlyBackendTexture(backendTex);
Greg Daniel261b8aa2017-10-23 09:37:36 -0400135 return;
136 }
137
138 std::unique_ptr<SkImageGenerator> imageGen = GrBackendTextureImageGenerator::Make(
139 texture, kTopLeft_GrSurfaceOrigin, nullptr, kPremul_SkAlphaType, nullptr);
140 REPORTER_ASSERT(reporter, imageGen);
141 if (!imageGen) {
Brian Salomon26102cb2018-03-09 09:33:19 -0500142 gpu->deleteTestingOnlyBackendTexture(backendTex);
Greg Daniel261b8aa2017-10-23 09:37:36 -0400143 return;
144 }
145
146 SkIPoint origin = SkIPoint::Make(0,0);
147 // The transfer function behavior isn't used in the generator so set we set it
148 // arbitrarily here.
149 SkTransferFunctionBehavior behavior = SkTransferFunctionBehavior::kIgnore;
150 SkImageInfo imageInfo = SkImageInfo::Make(kSize, kSize, kRGBA_8888_SkColorType,
151 kPremul_SkAlphaType);
152 sk_sp<GrTextureProxy> genProxy = imageGen->generateTexture(context, imageInfo,
153 origin, behavior,
154 willUseMips);
155
156 REPORTER_ASSERT(reporter, genProxy);
157 if (!genProxy) {
Brian Salomon26102cb2018-03-09 09:33:19 -0500158 gpu->deleteTestingOnlyBackendTexture(backendTex);
Greg Daniel261b8aa2017-10-23 09:37:36 -0400159 return;
160 }
161
Greg Daniele728f672018-01-17 10:52:04 -0500162 if (GrSurfaceProxy::LazyState::kNot != genProxy->lazyInstantiationState()) {
163 genProxy->priv().doLazyInstantiation(context->contextPriv().resourceProvider());
Greg Danielf6f7b672018-02-15 13:06:26 -0500164 } else if (!genProxy->priv().isInstantiated()) {
165 genProxy->instantiate(context->contextPriv().resourceProvider());
Greg Daniele728f672018-01-17 10:52:04 -0500166 }
167
Greg Daniel261b8aa2017-10-23 09:37:36 -0400168 REPORTER_ASSERT(reporter, genProxy->priv().isInstantiated());
Greg Danielbddcc952018-01-24 13:22:24 -0500169 if (!genProxy->priv().isInstantiated()) {
Brian Salomon26102cb2018-03-09 09:33:19 -0500170 gpu->deleteTestingOnlyBackendTexture(backendTex);
Greg Danielbddcc952018-01-24 13:22:24 -0500171 return;
172 }
Greg Daniel261b8aa2017-10-23 09:37:36 -0400173
174 GrTexture* genTexture = genProxy->priv().peekTexture();
175 REPORTER_ASSERT(reporter, genTexture);
176 if (!genTexture) {
Brian Salomon26102cb2018-03-09 09:33:19 -0500177 gpu->deleteTestingOnlyBackendTexture(backendTex);
Greg Daniel261b8aa2017-10-23 09:37:36 -0400178 return;
179 }
180
Robert Phillipsb67821d2017-12-13 15:00:45 -0500181 GrBackendTexture genBackendTex = genTexture->getBackendTexture();
Greg Daniel261b8aa2017-10-23 09:37:36 -0400182
Robert Phillipsb67821d2017-12-13 15:00:45 -0500183 if (const GrGLTextureInfo* genTexInfo = genBackendTex.getGLTextureInfo()) {
Greg Daniel261b8aa2017-10-23 09:37:36 -0400184 const GrGLTextureInfo* origTexInfo = backendTex.getGLTextureInfo();
Greg Daniel261b8aa2017-10-23 09:37:36 -0400185 if (willUseMips && GrMipMapped::kNo == mipMapped) {
186 // We did a copy so the texture IDs should be different
187 REPORTER_ASSERT(reporter, origTexInfo->fID != genTexInfo->fID);
188 } else {
189 REPORTER_ASSERT(reporter, origTexInfo->fID == genTexInfo->fID);
190 }
Greg Daniel261b8aa2017-10-23 09:37:36 -0400191#ifdef SK_VULKAN
Robert Phillipsb67821d2017-12-13 15:00:45 -0500192 } else if (const GrVkImageInfo* genImageInfo = genBackendTex.getVkImageInfo()) {
Greg Daniel261b8aa2017-10-23 09:37:36 -0400193 const GrVkImageInfo* origImageInfo = backendTex.getVkImageInfo();
Greg Daniel261b8aa2017-10-23 09:37:36 -0400194 if (willUseMips && GrMipMapped::kNo == mipMapped) {
195 // We did a copy so the texture IDs should be different
196 REPORTER_ASSERT(reporter, origImageInfo->fImage != genImageInfo->fImage);
197 } else {
198 REPORTER_ASSERT(reporter, origImageInfo->fImage == genImageInfo->fImage);
199 }
200#endif
Greg Daniel261b8aa2017-10-23 09:37:36 -0400201 } else {
202 REPORTER_ASSERT(reporter, false);
203 }
204
205 // Must make sure the uses of the backend texture have finished (we possibly have a
Greg Daniel26b50a42018-03-08 09:49:58 -0500206 // queued up copy) before we delete the backend texture.
207 context->flush();
208 gpu->testingOnly_flushGpuAndSync();
Greg Daniel261b8aa2017-10-23 09:37:36 -0400209
Brian Salomon26102cb2018-03-09 09:33:19 -0500210 gpu->deleteTestingOnlyBackendTexture(backendTex);
Greg Daniel261b8aa2017-10-23 09:37:36 -0400211 }
212 }
213}
214
Greg Daniel45d63032017-10-30 13:41:26 -0400215// Test that when we call makeImageSnapshot on an SkSurface we retains the same mip status as the
216// resource we took the snapshot of.
217DEF_GPUTEST_FOR_RENDERING_CONTEXTS(GrImageSnapshotMipMappedTest, reporter, ctxInfo) {
218 GrContext* context = ctxInfo.grContext();
219 if (!context->caps()->mipMapSupport()) {
220 return;
221 }
222
Robert Phillips6be756b2018-01-16 15:07:54 -0500223 auto resourceProvider = context->contextPriv().resourceProvider();
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500224 GrGpu* gpu = context->contextPriv().getGpu();
Robert Phillips6be756b2018-01-16 15:07:54 -0500225
Greg Daniel45d63032017-10-30 13:41:26 -0400226 for (auto willUseMips : {false, true}) {
227 for (auto isWrapped : {false, true}) {
228 GrMipMapped mipMapped = willUseMips ? GrMipMapped::kYes : GrMipMapped::kNo;
229 sk_sp<SkSurface> surface;
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500230 GrBackendTexture backendTex = gpu->createTestingOnlyBackendTexture(
Robert Phillipsd21b2a52017-12-12 13:01:25 -0500231 nullptr, kSize, kSize, kRGBA_8888_GrPixelConfig, true, mipMapped);
Greg Daniel45d63032017-10-30 13:41:26 -0400232 if (isWrapped) {
Greg Daniel45d63032017-10-30 13:41:26 -0400233 surface = SkSurface::MakeFromBackendTexture(context,
234 backendTex,
235 kTopLeft_GrSurfaceOrigin,
236 0,
Greg Danielfaa095e2017-12-19 13:15:02 -0500237 kRGBA_8888_SkColorType,
Greg Daniel45d63032017-10-30 13:41:26 -0400238 nullptr,
239 nullptr);
240 } else {
241 SkImageInfo info = SkImageInfo::Make(kSize, kSize, kRGBA_8888_SkColorType,
242 kPremul_SkAlphaType);
243 surface = SkSurface::MakeRenderTarget(context, SkBudgeted::kYes, info, 0,
244 kTopLeft_GrSurfaceOrigin, nullptr,
245 willUseMips);
246 }
247 REPORTER_ASSERT(reporter, surface);
248 if (!surface) {
Brian Salomon26102cb2018-03-09 09:33:19 -0500249 gpu->deleteTestingOnlyBackendTexture(backendTex);
Greg Daniel45d63032017-10-30 13:41:26 -0400250 }
251 SkGpuDevice* device = ((SkSurface_Gpu*)surface.get())->getDevice();
252 GrTextureProxy* texProxy = device->accessRenderTargetContext()->asTextureProxy();
253 REPORTER_ASSERT(reporter, mipMapped == texProxy->mipMapped());
254
Robert Phillips6be756b2018-01-16 15:07:54 -0500255 texProxy->instantiate(resourceProvider);
Greg Daniel45d63032017-10-30 13:41:26 -0400256 GrTexture* texture = texProxy->priv().peekTexture();
257 REPORTER_ASSERT(reporter, mipMapped == texture->texturePriv().mipMapped());
258
259 sk_sp<SkImage> image = surface->makeImageSnapshot();
260 REPORTER_ASSERT(reporter, image);
261 if (!image) {
Brian Salomon26102cb2018-03-09 09:33:19 -0500262 gpu->deleteTestingOnlyBackendTexture(backendTex);
Greg Daniel45d63032017-10-30 13:41:26 -0400263 }
264 texProxy = as_IB(image)->peekProxy();
265 REPORTER_ASSERT(reporter, mipMapped == texProxy->mipMapped());
266
Robert Phillips6be756b2018-01-16 15:07:54 -0500267 texProxy->instantiate(resourceProvider);
Greg Daniel45d63032017-10-30 13:41:26 -0400268 texture = texProxy->priv().peekTexture();
269 REPORTER_ASSERT(reporter, mipMapped == texture->texturePriv().mipMapped());
270
271 // Must flush the context to make sure all the cmds (copies, etc.) from above are sent
272 // to the gpu before we delete the backendHandle.
273 context->flush();
Brian Salomon26102cb2018-03-09 09:33:19 -0500274 gpu->deleteTestingOnlyBackendTexture(backendTex);
Greg Daniel45d63032017-10-30 13:41:26 -0400275 }
276 }
277}
Greg Daniel261b8aa2017-10-23 09:37:36 -0400278
Greg Daniel177e6952017-10-12 12:27:11 -0400279#endif