blob: 6895eaa393cdb082d24cf27a38544545b9bb86cb [file] [log] [blame]
tomhudson@google.com168e6342012-04-18 17:49:20 +00001/*
2 * Copyright 2012 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
joshualittb0a8a372014-09-23 09:50:21 -07008#include "GrProcessor.h"
bsalomon@google.com2eaaefd2012-10-29 19:51:22 +00009#include "GrContext.h"
joshualitt2e3b3e32014-12-09 13:31:14 -080010#include "GrGeometryProcessor.h"
tomhudson@google.comdcba4c22012-07-24 21:36:16 +000011#include "GrMemoryPool.h"
Brian Salomon514baff2016-11-17 15:17:07 -050012#include "GrSamplerParams.h"
Brian Salomon0bbecb22016-11-17 11:38:22 -050013#include "GrTexturePriv.h"
Robert Phillipsbc7a4fb2017-01-23 15:30:35 -050014#include "GrTextureProxy.h"
egdaniel915187b2014-12-05 12:58:28 -080015#include "GrXferProcessor.h"
joshualitt23ac62c2015-03-30 09:53:47 -070016#include "SkSpinlock.h"
tomhudson@google.com168e6342012-04-18 17:49:20 +000017
Hal Canary6f6961e2017-01-31 13:50:44 -050018#if GR_TEST_UTILS
Robert Phillips296b1cc2017-03-15 10:42:12 -040019
20GrResourceProvider* GrProcessorTestData::resourceProvider() {
21 return fContext->resourceProvider();
22}
23
24const GrCaps* GrProcessorTestData::caps() {
25 return fContext->caps();
26}
27
28#if SK_ALLOW_STATIC_GLOBAL_INITIALIZERS
joshualitteb2a6762014-12-04 11:35:33 -080029class GrFragmentProcessor;
30class GrGeometryProcessor;
31
joshualitt9e87fa72014-10-09 13:12:35 -070032/*
33 * Originally these were both in the processor unit test header, but then it seemed to cause linker
34 * problems on android.
35 */
36template<>
37SkTArray<GrProcessorTestFactory<GrFragmentProcessor>*, true>*
38GrProcessorTestFactory<GrFragmentProcessor>::GetFactories() {
39 static SkTArray<GrProcessorTestFactory<GrFragmentProcessor>*, true> gFactories;
40 return &gFactories;
41}
42
43template<>
Brian Salomon003312a2017-01-09 16:00:33 +000044SkTArray<GrProcessorTestFactory<GrGeometryProcessor>*, true>*
45GrProcessorTestFactory<GrGeometryProcessor>::GetFactories() {
46 static SkTArray<GrProcessorTestFactory<GrGeometryProcessor>*, true> gFactories;
Brian Salomona8f80de2017-01-07 09:37:13 -050047 return &gFactories;
48}
49
Brian Salomona1633922017-01-09 11:46:10 -050050SkTArray<GrXPFactoryTestFactory*, true>* GrXPFactoryTestFactory::GetFactories() {
51 static SkTArray<GrXPFactoryTestFactory*, true> gFactories;
52 return &gFactories;
53}
54
joshualitt9e87fa72014-10-09 13:12:35 -070055/*
56 * To ensure we always have successful static initialization, before creating from the factories
57 * we verify the count is as expected. If a new factory is added, then these numbers must be
58 * manually adjusted.
59 */
Brian Osman63954c92017-03-14 12:07:12 -040060static const int kFPFactoryCount = 41;
joshualitt4973d9d2014-11-08 09:24:25 -080061static const int kGPFactoryCount = 14;
Brian Salomon1c4717b2017-01-06 12:54:58 -050062static const int kXPFactoryCount = 4;
joshualitt9e87fa72014-10-09 13:12:35 -070063
64template<>
65void GrProcessorTestFactory<GrFragmentProcessor>::VerifyFactoryCount() {
66 if (kFPFactoryCount != GetFactories()->count()) {
Ben Wagnerc03e1c52016-10-17 15:20:02 -040067 SkDebugf("\nExpected %d fragment processor factories, found %d.\n",
68 kFPFactoryCount, GetFactories()->count());
joshualitt9e87fa72014-10-09 13:12:35 -070069 SkFAIL("Wrong number of fragment processor factories!");
70 }
71}
72
73template<>
74void GrProcessorTestFactory<GrGeometryProcessor>::VerifyFactoryCount() {
75 if (kGPFactoryCount != GetFactories()->count()) {
Ben Wagnerc03e1c52016-10-17 15:20:02 -040076 SkDebugf("\nExpected %d geometry processor factories, found %d.\n",
77 kGPFactoryCount, GetFactories()->count());
joshualitt9e87fa72014-10-09 13:12:35 -070078 SkFAIL("Wrong number of geometry processor factories!");
79 }
80}
81
Brian Salomona1633922017-01-09 11:46:10 -050082void GrXPFactoryTestFactory::VerifyFactoryCount() {
egdaniel378092f2014-12-03 10:40:13 -080083 if (kXPFactoryCount != GetFactories()->count()) {
Ben Wagnerc03e1c52016-10-17 15:20:02 -040084 SkDebugf("\nExpected %d xp factory factories, found %d.\n",
85 kXPFactoryCount, GetFactories()->count());
egdanielc2304142014-12-11 13:15:13 -080086 SkFAIL("Wrong number of xp factory factories!");
egdaniel378092f2014-12-03 10:40:13 -080087 }
88}
89
joshualitt9e87fa72014-10-09 13:12:35 -070090#endif
Hal Canary6f6961e2017-01-31 13:50:44 -050091#endif
joshualitt9e87fa72014-10-09 13:12:35 -070092
bsalomon5baedd62015-03-09 12:15:53 -070093
joshualitt23ac62c2015-03-30 09:53:47 -070094// We use a global pool protected by a mutex(spinlock). Chrome may use the same GrContext on
95// different threads. The GrContext is not used concurrently on different threads and there is a
96// memory barrier between accesses of a context on different threads. Also, there may be multiple
bsalomon5baedd62015-03-09 12:15:53 -070097// GrContexts and those contexts may be in use concurrently on different threads.
98namespace {
mtklein15923c92016-02-29 10:14:38 -080099static SkSpinlock gProcessorSpinlock;
bsalomon5baedd62015-03-09 12:15:53 -0700100class MemoryPoolAccessor {
tomhudson@google.comdcba4c22012-07-24 21:36:16 +0000101public:
tomhudson@google.comdcba4c22012-07-24 21:36:16 +0000102
msarett68440f82016-08-29 14:52:24 -0700103// We know in the Android framework there is only one GrContext.
104#if defined(SK_BUILD_FOR_ANDROID_FRAMEWORK)
105 MemoryPoolAccessor() {}
106 ~MemoryPoolAccessor() {}
107#else
108 MemoryPoolAccessor() { gProcessorSpinlock.acquire(); }
joshualitt23ac62c2015-03-30 09:53:47 -0700109 ~MemoryPoolAccessor() { gProcessorSpinlock.release(); }
msarett68440f82016-08-29 14:52:24 -0700110#endif
tomhudson@google.comdcba4c22012-07-24 21:36:16 +0000111
bsalomon5baedd62015-03-09 12:15:53 -0700112 GrMemoryPool* pool() const {
113 static GrMemoryPool gPool(4096, 4096);
114 return &gPool;
tomhudson@google.comdcba4c22012-07-24 21:36:16 +0000115 }
116};
bsalomon5baedd62015-03-09 12:15:53 -0700117}
tomhudson@google.comdcba4c22012-07-24 21:36:16 +0000118
bsalomon5baedd62015-03-09 12:15:53 -0700119int32_t GrProcessor::gCurrProcessorClassID = GrProcessor::kIllegalProcessorClassID;
tomhudson@google.com168e6342012-04-18 17:49:20 +0000120
bsalomon@google.com0ac6af42013-01-16 15:16:18 +0000121///////////////////////////////////////////////////////////////////////////////
122
Brian Salomonab015ef2017-04-04 10:15:51 -0400123void* GrProcessor::operator new(size_t size) { return MemoryPoolAccessor().pool()->allocate(size); }
tomhudson@google.com168e6342012-04-18 17:49:20 +0000124
Brian Salomonab015ef2017-04-04 10:15:51 -0400125void GrProcessor::operator delete(void* target) {
126 return MemoryPoolAccessor().pool()->release(target);
127}
128
129///////////////////////////////////////////////////////////////////////////////
130
131void GrResourceIOProcessor::addTextureSampler(const TextureSampler* access) {
Brian Salomon0bbecb22016-11-17 11:38:22 -0500132 fTextureSamplers.push_back(access);
twiz@google.coma5e65ec2012-08-02 15:15:16 +0000133}
134
Brian Salomonab015ef2017-04-04 10:15:51 -0400135void GrResourceIOProcessor::addBufferAccess(const BufferAccess* access) {
cdalton74b8d322016-04-11 14:47:28 -0700136 fBufferAccesses.push_back(access);
Brian Salomonf9f45122016-11-29 11:59:17 -0500137}
138
Robert Phillips8a02f652017-05-12 14:49:16 -0400139void GrResourceIOProcessor::addImageStorageAccess(GrResourceProvider* resourceProvider,
140 const ImageStorageAccess* access) {
Brian Salomonf9f45122016-11-29 11:59:17 -0500141 fImageStorageAccesses.push_back(access);
Brian Salomone57194f2017-01-09 15:30:02 -0500142}
143
Brian Salomonab015ef2017-04-04 10:15:51 -0400144void GrResourceIOProcessor::addPendingIOs() const {
Brian Salomone57194f2017-01-09 15:30:02 -0500145 for (const auto& sampler : fTextureSamplers) {
146 sampler->programTexture()->markPendingIO();
147 }
148 for (const auto& buffer : fBufferAccesses) {
149 buffer->programBuffer()->markPendingIO();
150 }
151 for (const auto& imageStorage : fImageStorageAccesses) {
Robert Phillips8a02f652017-05-12 14:49:16 -0400152 imageStorage->programProxy()->markPendingIO();
Brian Salomone57194f2017-01-09 15:30:02 -0500153 }
154}
155
Brian Salomonab015ef2017-04-04 10:15:51 -0400156void GrResourceIOProcessor::removeRefs() const {
Brian Salomone57194f2017-01-09 15:30:02 -0500157 for (const auto& sampler : fTextureSamplers) {
158 sampler->programTexture()->removeRef();
159 }
160 for (const auto& buffer : fBufferAccesses) {
161 buffer->programBuffer()->removeRef();
162 }
163 for (const auto& imageStorage : fImageStorageAccesses) {
Robert Phillips8a02f652017-05-12 14:49:16 -0400164 imageStorage->programProxy()->removeRef();
Brian Salomone57194f2017-01-09 15:30:02 -0500165 }
166}
167
Brian Salomonab015ef2017-04-04 10:15:51 -0400168void GrResourceIOProcessor::pendingIOComplete() const {
Brian Salomone57194f2017-01-09 15:30:02 -0500169 for (const auto& sampler : fTextureSamplers) {
170 sampler->programTexture()->pendingIOComplete();
171 }
172 for (const auto& buffer : fBufferAccesses) {
173 buffer->programBuffer()->pendingIOComplete();
174 }
175 for (const auto& imageStorage : fImageStorageAccesses) {
Robert Phillips8a02f652017-05-12 14:49:16 -0400176 imageStorage->programProxy()->pendingIOComplete();
Brian Salomone57194f2017-01-09 15:30:02 -0500177 }
cdalton74b8d322016-04-11 14:47:28 -0700178}
179
Robert Phillips9bee2e52017-05-29 12:37:20 -0400180bool GrResourceIOProcessor::instantiate(GrResourceProvider* resourceProvider) const {
181 for (const auto& sampler : fTextureSamplers) {
182 if (!sampler->instantiate(resourceProvider)) {
183 return false;
184 }
185 }
186
187 for (const auto& imageStorage : fImageStorageAccesses) {
188 if (!imageStorage->instantiate(resourceProvider)) {
189 return false;
190 }
191 }
192
193 return true;
194}
195
Brian Salomonab015ef2017-04-04 10:15:51 -0400196bool GrResourceIOProcessor::hasSameSamplersAndAccesses(const GrResourceIOProcessor& that) const {
Brian Salomon0bbecb22016-11-17 11:38:22 -0500197 if (this->numTextureSamplers() != that.numTextureSamplers() ||
Brian Salomonf9f45122016-11-29 11:59:17 -0500198 this->numBuffers() != that.numBuffers() ||
199 this->numImageStorages() != that.numImageStorages()) {
bsalomon420d7e92014-10-16 09:18:09 -0700200 return false;
bsalomon@google.com77af6802013-10-02 13:04:56 +0000201 }
Brian Salomon0bbecb22016-11-17 11:38:22 -0500202 for (int i = 0; i < this->numTextureSamplers(); ++i) {
203 if (this->textureSampler(i) != that.textureSampler(i)) {
bsalomon420d7e92014-10-16 09:18:09 -0700204 return false;
205 }
206 }
cdalton74b8d322016-04-11 14:47:28 -0700207 for (int i = 0; i < this->numBuffers(); ++i) {
208 if (this->bufferAccess(i) != that.bufferAccess(i)) {
209 return false;
210 }
211 }
Brian Salomonf9f45122016-11-29 11:59:17 -0500212 for (int i = 0; i < this->numImageStorages(); ++i) {
213 if (this->imageStorageAccess(i) != that.imageStorageAccess(i)) {
214 return false;
215 }
216 }
bsalomon420d7e92014-10-16 09:18:09 -0700217 return true;
bsalomon@google.com77af6802013-10-02 13:04:56 +0000218}
egdaniel1a8ecdf2014-10-03 06:24:12 -0700219
joshualitta5305a12014-10-10 17:47:00 -0700220///////////////////////////////////////////////////////////////////////////////////////////////////
221
Brian Salomonab015ef2017-04-04 10:15:51 -0400222GrResourceIOProcessor::TextureSampler::TextureSampler() {}
Brian Salomon0bbecb22016-11-17 11:38:22 -0500223
Brian Salomonab015ef2017-04-04 10:15:51 -0400224GrResourceIOProcessor::TextureSampler::TextureSampler(GrResourceProvider* resourceProvider,
225 sk_sp<GrTextureProxy> proxy,
226 const GrSamplerParams& params) {
Brian Osman32342f02017-03-04 08:12:46 -0500227 this->reset(resourceProvider, std::move(proxy), params);
Robert Phillips901f29a2017-01-24 16:24:41 -0500228}
229
Brian Salomonab015ef2017-04-04 10:15:51 -0400230GrResourceIOProcessor::TextureSampler::TextureSampler(GrResourceProvider* resourceProvider,
231 sk_sp<GrTextureProxy> proxy,
232 GrSamplerParams::FilterMode filterMode,
233 SkShader::TileMode tileXAndY,
234 GrShaderFlags visibility) {
Brian Osman32342f02017-03-04 08:12:46 -0500235 this->reset(resourceProvider, std::move(proxy), filterMode, tileXAndY, visibility);
Robert Phillipsbc7a4fb2017-01-23 15:30:35 -0500236}
237
Robert Phillipsc3757042017-05-17 13:00:14 +0000238// MDB TODO: remove this!
239void GrResourceIOProcessor::TextureSampler::reset(GrTexture* texture,
240 GrSamplerParams::FilterMode filterMode,
241 SkShader::TileMode tileXAndY,
242 GrShaderFlags visibility) {
243 SkASSERT(texture);
244 fTexture.set(SkRef(texture), kRead_GrIOType);
245 filterMode = SkTMin(filterMode, texture->texturePriv().highestFilterMode());
246 fParams.reset(tileXAndY, filterMode);
247 fVisibility = visibility;
248}
249
Brian Salomonab015ef2017-04-04 10:15:51 -0400250void GrResourceIOProcessor::TextureSampler::reset(GrResourceProvider* resourceProvider,
251 sk_sp<GrTextureProxy> proxy,
252 const GrSamplerParams& params,
253 GrShaderFlags visibility) {
Robert Phillipsa91e0b72017-05-01 13:12:20 -0400254 fParams = params;
255
Robert Phillips30f9bc62017-02-22 15:28:38 -0500256 // For now, end the deferral at this time. Once all the TextureSamplers are swapped over
257 // to taking a GrSurfaceProxy just use the IORefs on the proxy
Brian Salomonbb5711a2017-05-17 13:49:59 -0400258 GrTexture* texture = proxy->instantiateTexture(resourceProvider);
Robert Phillipsa91e0b72017-05-01 13:12:20 -0400259 if (texture) {
260 fTexture.set(SkRef(texture), kRead_GrIOType);
Robert Phillips49081d12017-05-08 13:41:35 -0400261 SkASSERT(texture->texturePriv().highestFilterMode() == proxy->highestFilterMode());
262 fParams.setFilterMode(SkTMin(params.filterMode(), proxy->highestFilterMode()));
Robert Phillipsa91e0b72017-05-01 13:12:20 -0400263 }
264
Robert Phillips30f9bc62017-02-22 15:28:38 -0500265 fVisibility = visibility;
266}
267
Brian Salomonab015ef2017-04-04 10:15:51 -0400268void GrResourceIOProcessor::TextureSampler::reset(GrResourceProvider* resourceProvider,
269 sk_sp<GrTextureProxy> proxy,
270 GrSamplerParams::FilterMode filterMode,
271 SkShader::TileMode tileXAndY,
272 GrShaderFlags visibility) {
Robert Phillips30f9bc62017-02-22 15:28:38 -0500273 // For now, end the deferral at this time. Once all the TextureSamplers are swapped over
274 // to taking a GrSurfaceProxy just use the IORefs on the proxy
Brian Salomonbb5711a2017-05-17 13:49:59 -0400275 GrTexture* texture = proxy->instantiateTexture(resourceProvider);
Robert Phillipsa91e0b72017-05-01 13:12:20 -0400276 if (texture) {
277 fTexture.set(SkRef(texture), kRead_GrIOType);
Robert Phillips49081d12017-05-08 13:41:35 -0400278 SkASSERT(texture->texturePriv().highestFilterMode() == proxy->highestFilterMode());
279 filterMode = SkTMin(filterMode, proxy->highestFilterMode());
Robert Phillipsa91e0b72017-05-01 13:12:20 -0400280 }
281
Robert Phillips30f9bc62017-02-22 15:28:38 -0500282 fParams.reset(tileXAndY, filterMode);
283 fVisibility = visibility;
284}
285
Brian Salomon0bbecb22016-11-17 11:38:22 -0500286///////////////////////////////////////////////////////////////////////////////////////////////////
287
Robert Phillips8a02f652017-05-12 14:49:16 -0400288GrResourceIOProcessor::ImageStorageAccess::ImageStorageAccess(sk_sp<GrTextureProxy> proxy,
Brian Salomonab015ef2017-04-04 10:15:51 -0400289 GrIOType ioType,
290 GrSLMemoryModel memoryModel,
291 GrSLRestrict restrict,
Robert Phillips8a02f652017-05-12 14:49:16 -0400292 GrShaderFlags visibility)
293 : fProxyRef(std::move(proxy), ioType) {
294 SkASSERT(fProxyRef.getProxy());
295
Brian Salomonf9f45122016-11-29 11:59:17 -0500296 fMemoryModel = memoryModel;
297 fRestrict = restrict;
298 fVisibility = visibility;
299 // We currently infer this from the config. However, we could allow the client to specify
300 // a format that is different but compatible with the config.
Robert Phillips8a02f652017-05-12 14:49:16 -0400301 switch (fProxyRef.getProxy()->config()) {
Brian Salomonf9f45122016-11-29 11:59:17 -0500302 case kRGBA_8888_GrPixelConfig:
303 fFormat = GrImageStorageFormat::kRGBA8;
304 break;
305 case kRGBA_8888_sint_GrPixelConfig:
306 fFormat = GrImageStorageFormat::kRGBA8i;
307 break;
308 case kRGBA_half_GrPixelConfig:
309 fFormat = GrImageStorageFormat::kRGBA16f;
310 break;
311 case kRGBA_float_GrPixelConfig:
312 fFormat = GrImageStorageFormat::kRGBA32f;
313 break;
314 default:
315 SkFAIL("Config is not (yet) supported as image storage.");
316 break;
317 }
318}