Robert Phillips | ad8a43f | 2017-08-30 12:06:35 -0400 | [diff] [blame] | 1 | /* |
| 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 | |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 8 | #include "include/core/SkDeferredDisplayListRecorder.h" |
Robert Phillips | 4d5594d | 2020-02-21 14:24:40 -0500 | [diff] [blame] | 9 | |
| 10 | #include "include/core/SkDeferredDisplayList.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 11 | #include "include/core/SkSurface.h" |
| 12 | #include "include/core/SkSurfaceCharacterization.h" |
Ben Wagner | 21bca28 | 2019-05-15 10:15:52 -0400 | [diff] [blame] | 13 | #include "src/core/SkMessageBus.h" |
Robert Phillips | ad8a43f | 2017-08-30 12:06:35 -0400 | [diff] [blame] | 14 | |
Robert Phillips | 6ceaafa | 2018-03-15 16:53:06 -0400 | [diff] [blame] | 15 | #if !SK_SUPPORT_GPU |
| 16 | SkDeferredDisplayListRecorder::SkDeferredDisplayListRecorder(const SkSurfaceCharacterization&) {} |
| 17 | |
| 18 | SkDeferredDisplayListRecorder::~SkDeferredDisplayListRecorder() {} |
| 19 | |
| 20 | bool SkDeferredDisplayListRecorder::init() { return false; } |
| 21 | |
| 22 | SkCanvas* SkDeferredDisplayListRecorder::getCanvas() { return nullptr; } |
| 23 | |
| 24 | std::unique_ptr<SkDeferredDisplayList> SkDeferredDisplayListRecorder::detach() { return nullptr; } |
| 25 | |
| 26 | sk_sp<SkImage> SkDeferredDisplayListRecorder::makePromiseTexture( |
| 27 | const GrBackendFormat& backendFormat, |
| 28 | int width, |
| 29 | int height, |
| 30 | GrMipMapped mipMapped, |
| 31 | GrSurfaceOrigin origin, |
| 32 | SkColorType colorType, |
| 33 | SkAlphaType alphaType, |
| 34 | sk_sp<SkColorSpace> colorSpace, |
Brian Salomon | cdd8a0a | 2019-01-10 12:09:52 -0500 | [diff] [blame] | 35 | PromiseImageTextureFulfillProc textureFulfillProc, |
| 36 | PromiseImageTextureReleaseProc textureReleaseProc, |
| 37 | PromiseImageTextureDoneProc textureDoneProc, |
Brian Salomon | 0cc5754 | 2019-03-08 13:28:46 -0500 | [diff] [blame] | 38 | PromiseImageTextureContext textureContext, |
| 39 | PromiseImageApiVersion) { |
Brian Salomon | cdd8a0a | 2019-01-10 12:09:52 -0500 | [diff] [blame] | 40 | return nullptr; |
| 41 | } |
| 42 | |
Robert Phillips | e8e2bb1 | 2018-09-27 14:26:47 -0400 | [diff] [blame] | 43 | sk_sp<SkImage> SkDeferredDisplayListRecorder::makeYUVAPromiseTexture( |
Brian Salomon | cdd8a0a | 2019-01-10 12:09:52 -0500 | [diff] [blame] | 44 | SkYUVColorSpace yuvColorSpace, |
| 45 | const GrBackendFormat yuvaFormats[], |
| 46 | const SkISize yuvaSizes[], |
| 47 | const SkYUVAIndex yuvaIndices[4], |
| 48 | int imageWidth, |
| 49 | int imageHeight, |
| 50 | GrSurfaceOrigin imageOrigin, |
| 51 | sk_sp<SkColorSpace> imageColorSpace, |
| 52 | PromiseImageTextureFulfillProc textureFulfillProc, |
| 53 | PromiseImageTextureReleaseProc textureReleaseProc, |
| 54 | PromiseImageTextureDoneProc textureDoneProc, |
Brian Salomon | 0cc5754 | 2019-03-08 13:28:46 -0500 | [diff] [blame] | 55 | PromiseImageTextureContext textureContexts[], |
| 56 | PromiseImageApiVersion) { |
Brian Salomon | cdd8a0a | 2019-01-10 12:09:52 -0500 | [diff] [blame] | 57 | return nullptr; |
| 58 | } |
| 59 | |
Robert Phillips | 6ceaafa | 2018-03-15 16:53:06 -0400 | [diff] [blame] | 60 | #else |
| 61 | |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 62 | #include "include/core/SkPromiseImageTexture.h" |
| 63 | #include "include/core/SkYUVASizeInfo.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 64 | #include "src/gpu/GrContextPriv.h" |
| 65 | #include "src/gpu/GrProxyProvider.h" |
| 66 | #include "src/gpu/GrRenderTargetContext.h" |
Greg Daniel | 456f9b5 | 2020-03-05 19:14:18 +0000 | [diff] [blame] | 67 | #include "src/gpu/GrTexture.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 68 | #include "src/gpu/SkGr.h" |
| 69 | #include "src/image/SkImage_Gpu.h" |
| 70 | #include "src/image/SkImage_GpuYUVA.h" |
| 71 | #include "src/image/SkSurface_Gpu.h" |
Robert Phillips | 6ceaafa | 2018-03-15 16:53:06 -0400 | [diff] [blame] | 72 | |
| 73 | SkDeferredDisplayListRecorder::SkDeferredDisplayListRecorder(const SkSurfaceCharacterization& c) |
| 74 | : fCharacterization(c) { |
| 75 | if (fCharacterization.isValid()) { |
| 76 | fContext = GrContextPriv::MakeDDL(fCharacterization.refContextInfo()); |
| 77 | } |
Robert Phillips | ad8a43f | 2017-08-30 12:06:35 -0400 | [diff] [blame] | 78 | } |
| 79 | |
Robert Phillips | 6200036 | 2018-02-01 09:10:04 -0500 | [diff] [blame] | 80 | SkDeferredDisplayListRecorder::~SkDeferredDisplayListRecorder() { |
Robert Phillips | 6ceaafa | 2018-03-15 16:53:06 -0400 | [diff] [blame] | 81 | if (fContext) { |
Robert Phillips | 9da87e0 | 2019-02-04 13:26:26 -0500 | [diff] [blame] | 82 | auto proxyProvider = fContext->priv().proxyProvider(); |
Robert Phillips | 6200036 | 2018-02-01 09:10:04 -0500 | [diff] [blame] | 83 | |
Robert Phillips | 0790f8a | 2018-09-18 13:11:03 -0400 | [diff] [blame] | 84 | // This allows the uniquely keyed proxies to keep their keys but removes their back |
| 85 | // pointer to the about-to-be-deleted proxy provider. The proxies will use their |
| 86 | // unique key to reattach to cached versions of themselves or to appropriately tag new |
| 87 | // resources (if a cached version was not found). This system operates independent of |
| 88 | // the replaying context's proxy provider (i.e., these uniquely keyed proxies will not |
| 89 | // appear in the replaying proxy providers uniquely keyed proxy map). This should be fine |
| 90 | // since no one else should be trying to reconnect to the orphaned proxies and orphaned |
| 91 | // proxies from different DDLs that share the same key should simply reconnect to the |
| 92 | // same cached resource. |
| 93 | proxyProvider->orphanAllUniqueKeys(); |
Robert Phillips | 6ceaafa | 2018-03-15 16:53:06 -0400 | [diff] [blame] | 94 | } |
Robert Phillips | 6200036 | 2018-02-01 09:10:04 -0500 | [diff] [blame] | 95 | } |
| 96 | |
| 97 | |
Robert Phillips | e42edcc | 2017-12-13 11:50:22 -0500 | [diff] [blame] | 98 | bool SkDeferredDisplayListRecorder::init() { |
Robert Phillips | 6ceaafa | 2018-03-15 16:53:06 -0400 | [diff] [blame] | 99 | SkASSERT(fContext); |
| 100 | SkASSERT(!fLazyProxyData); |
Robert Phillips | e42edcc | 2017-12-13 11:50:22 -0500 | [diff] [blame] | 101 | SkASSERT(!fSurface); |
| 102 | |
Robert Phillips | fc711a2 | 2018-02-13 17:03:00 -0500 | [diff] [blame] | 103 | if (!fCharacterization.isValid()) { |
| 104 | return false; |
| 105 | } |
| 106 | |
Robert Phillips | 6200036 | 2018-02-01 09:10:04 -0500 | [diff] [blame] | 107 | fLazyProxyData = sk_sp<SkDeferredDisplayList::LazyProxyData>( |
| 108 | new SkDeferredDisplayList::LazyProxyData); |
Robert Phillips | e42edcc | 2017-12-13 11:50:22 -0500 | [diff] [blame] | 109 | |
Robert Phillips | 9da87e0 | 2019-02-04 13:26:26 -0500 | [diff] [blame] | 110 | auto proxyProvider = fContext->priv().proxyProvider(); |
Robert Phillips | b2adbef | 2019-07-02 16:33:05 -0400 | [diff] [blame] | 111 | const GrCaps* caps = fContext->priv().caps(); |
Robert Phillips | e42edcc | 2017-12-13 11:50:22 -0500 | [diff] [blame] | 112 | |
Greg Daniel | a070ed7 | 2018-04-26 16:31:38 -0400 | [diff] [blame] | 113 | bool usesGLFBO0 = fCharacterization.usesGLFBO0(); |
| 114 | if (usesGLFBO0) { |
Robert Phillips | 4217ea7 | 2019-01-30 13:08:28 -0500 | [diff] [blame] | 115 | if (GrBackendApi::kOpenGL != fContext->backend() || |
Greg Daniel | a070ed7 | 2018-04-26 16:31:38 -0400 | [diff] [blame] | 116 | fCharacterization.isTextureable()) { |
| 117 | return false; |
| 118 | } |
| 119 | } |
| 120 | |
Greg Daniel | b085fa9 | 2019-03-05 16:55:12 -0500 | [diff] [blame] | 121 | if (fCharacterization.vulkanSecondaryCBCompatible()) { |
| 122 | // Because of the restrictive API allowed for a GrVkSecondaryCBDrawContext, we know ahead |
| 123 | // of time that we don't be able to support certain parameter combinations. Specifially we |
| 124 | // fail on usesGLFBO0 since we can't mix GL and Vulkan. We can't have a texturable object. |
| 125 | // And finally the GrVkSecondaryCBDrawContext always assumes a top left origin. |
| 126 | if (usesGLFBO0 || |
| 127 | fCharacterization.isTextureable() || |
| 128 | fCharacterization.origin() == kBottomLeft_GrSurfaceOrigin) { |
| 129 | return false; |
| 130 | } |
| 131 | } |
| 132 | |
Greg Daniel | 627d053 | 2019-07-08 16:48:14 -0400 | [diff] [blame] | 133 | GrColorType grColorType = SkColorTypeToGrColorType(fCharacterization.colorType()); |
| 134 | |
Robert Phillips | 6200036 | 2018-02-01 09:10:04 -0500 | [diff] [blame] | 135 | sk_sp<SkDeferredDisplayList::LazyProxyData> lazyProxyData = fLazyProxyData; |
| 136 | |
| 137 | // What we're doing here is we're creating a lazy proxy to back the SkSurface. The lazy |
Robert Phillips | e8fabb2 | 2018-02-04 14:33:21 -0500 | [diff] [blame] | 138 | // proxy, when instantiated, will use the GrRenderTarget that backs the SkSurface that the |
Robert Phillips | 6200036 | 2018-02-01 09:10:04 -0500 | [diff] [blame] | 139 | // DDL is being replayed into. |
| 140 | |
Robert Phillips | abf7b76 | 2018-03-21 12:13:37 -0400 | [diff] [blame] | 141 | GrInternalSurfaceFlags surfaceFlags = GrInternalSurfaceFlags::kNone; |
Greg Daniel | a070ed7 | 2018-04-26 16:31:38 -0400 | [diff] [blame] | 142 | if (usesGLFBO0) { |
Jim Van Verth | 5fab909 | 2019-11-25 21:23:53 +0000 | [diff] [blame] | 143 | surfaceFlags |= GrInternalSurfaceFlags::kGLRTFBOIDIs0; |
Greg Daniel | a070ed7 | 2018-04-26 16:31:38 -0400 | [diff] [blame] | 144 | } |
Chris Dalton | 95d8ceb | 2019-07-30 11:17:59 -0600 | [diff] [blame] | 145 | // FIXME: Why do we use GrMipMapped::kNo instead of SkSurfaceCharacterization::fIsMipMapped? |
Brian Salomon | 7226c23 | 2018-07-30 13:13:17 -0400 | [diff] [blame] | 146 | static constexpr GrProxyProvider::TextureInfo kTextureInfo{GrMipMapped::kNo, |
| 147 | GrTextureType::k2D}; |
| 148 | const GrProxyProvider::TextureInfo* optionalTextureInfo = nullptr; |
| 149 | if (fCharacterization.isTextureable()) { |
| 150 | optionalTextureInfo = &kTextureInfo; |
| 151 | } |
Robert Phillips | abf7b76 | 2018-03-21 12:13:37 -0400 | [diff] [blame] | 152 | |
Greg Daniel | ce3ddaa | 2020-01-22 16:58:15 -0500 | [diff] [blame] | 153 | GrSwizzle readSwizzle = caps->getReadSwizzle(fCharacterization.backendFormat(), grColorType); |
| 154 | |
Robert Phillips | e8fabb2 | 2018-02-04 14:33:21 -0500 | [diff] [blame] | 155 | sk_sp<GrRenderTargetProxy> proxy = proxyProvider->createLazyRenderTargetProxy( |
Brian Salomon | f777897 | 2018-03-08 10:13:17 -0500 | [diff] [blame] | 156 | [lazyProxyData](GrResourceProvider* resourceProvider) { |
Robert Phillips | 83373a8 | 2018-02-14 07:35:32 -0500 | [diff] [blame] | 157 | // The proxy backing the destination surface had better have been instantiated |
| 158 | // prior to the proxy backing the DLL's surface. Steal its GrRenderTarget. |
Brian Salomon | fd98c2c | 2018-07-31 17:25:29 -0400 | [diff] [blame] | 159 | SkASSERT(lazyProxyData->fReplayDest->peekSurface()); |
Brian Salomon | b6a3a3b | 2019-04-01 12:29:34 -0400 | [diff] [blame] | 160 | auto surface = sk_ref_sp<GrSurface>(lazyProxyData->fReplayDest->peekSurface()); |
Brian Salomon | beb7f52 | 2019-08-30 16:19:42 -0400 | [diff] [blame] | 161 | return GrSurfaceProxy::LazyCallbackResult(std::move(surface)); |
Robert Phillips | 83373a8 | 2018-02-14 07:35:32 -0500 | [diff] [blame] | 162 | }, |
Robert Phillips | 0e0113d | 2019-07-03 10:16:37 -0400 | [diff] [blame] | 163 | fCharacterization.backendFormat(), |
Brian Salomon | a56a746 | 2020-02-07 14:17:25 -0500 | [diff] [blame] | 164 | fCharacterization.dimensions(), |
Brian Salomon | 27b4d8d | 2019-07-22 14:23:45 -0400 | [diff] [blame] | 165 | fCharacterization.sampleCount(), |
Robert Phillips | abf7b76 | 2018-03-21 12:13:37 -0400 | [diff] [blame] | 166 | surfaceFlags, |
Brian Salomon | 7226c23 | 2018-07-30 13:13:17 -0400 | [diff] [blame] | 167 | optionalTextureInfo, |
Chris Dalton | 95d8ceb | 2019-07-30 11:17:59 -0600 | [diff] [blame] | 168 | GrMipMapsStatus::kNotAllocated, |
Robert Phillips | 83373a8 | 2018-02-14 07:35:32 -0500 | [diff] [blame] | 169 | SkBackingFit::kExact, |
Greg Daniel | b085fa9 | 2019-03-05 16:55:12 -0500 | [diff] [blame] | 170 | SkBudgeted::kYes, |
Brian Salomon | e8a766b | 2019-07-19 14:24:36 -0400 | [diff] [blame] | 171 | fCharacterization.isProtected(), |
Brian Salomon | beb7f52 | 2019-08-30 16:19:42 -0400 | [diff] [blame] | 172 | fCharacterization.vulkanSecondaryCBCompatible(), |
| 173 | GrSurfaceProxy::UseAllocator::kYes); |
Robert Phillips | 6200036 | 2018-02-01 09:10:04 -0500 | [diff] [blame] | 174 | |
Brian Salomon | 9d8cac8 | 2019-07-16 15:59:31 -0400 | [diff] [blame] | 175 | if (!proxy) { |
| 176 | return false; |
| 177 | } |
| 178 | |
Brian Salomon | 982f546 | 2020-03-30 12:52:33 -0400 | [diff] [blame] | 179 | GrSwizzle writeSwizzle = caps->getWriteSwizzle(fCharacterization.backendFormat(), grColorType); |
Greg Daniel | bfa19c4 | 2019-12-19 16:41:40 -0500 | [diff] [blame] | 180 | |
Greg Daniel | 3912a4b | 2020-01-14 09:56:04 -0500 | [diff] [blame] | 181 | GrSurfaceProxyView readView(proxy, fCharacterization.origin(), readSwizzle); |
Brian Salomon | 8afde5f | 2020-04-01 16:22:00 -0400 | [diff] [blame^] | 182 | GrSurfaceProxyView writeView(std::move(proxy), fCharacterization.origin(), writeSwizzle); |
Greg Daniel | 3912a4b | 2020-01-14 09:56:04 -0500 | [diff] [blame] | 183 | |
| 184 | auto rtc = std::make_unique<GrRenderTargetContext>(fContext.get(), std::move(readView), |
Brian Salomon | 8afde5f | 2020-04-01 16:22:00 -0400 | [diff] [blame^] | 185 | std::move(writeView), grColorType, |
Greg Daniel | bfa19c4 | 2019-12-19 16:41:40 -0500 | [diff] [blame] | 186 | fCharacterization.refColorSpace(), |
| 187 | &fCharacterization.surfaceProps()); |
Brian Salomon | bf6b979 | 2019-08-21 09:38:10 -0400 | [diff] [blame] | 188 | fSurface = SkSurface_Gpu::MakeWrappedRenderTarget(fContext.get(), std::move(rtc)); |
Robert Phillips | e42edcc | 2017-12-13 11:50:22 -0500 | [diff] [blame] | 189 | return SkToBool(fSurface.get()); |
| 190 | } |
| 191 | |
Robert Phillips | ad8a43f | 2017-08-30 12:06:35 -0400 | [diff] [blame] | 192 | SkCanvas* SkDeferredDisplayListRecorder::getCanvas() { |
Robert Phillips | 6ceaafa | 2018-03-15 16:53:06 -0400 | [diff] [blame] | 193 | if (!fContext) { |
| 194 | return nullptr; |
| 195 | } |
| 196 | |
| 197 | if (!fSurface && !this->init()) { |
| 198 | return nullptr; |
Robert Phillips | ad8a43f | 2017-08-30 12:06:35 -0400 | [diff] [blame] | 199 | } |
| 200 | |
| 201 | return fSurface->getCanvas(); |
| 202 | } |
| 203 | |
| 204 | std::unique_ptr<SkDeferredDisplayList> SkDeferredDisplayListRecorder::detach() { |
Robert Phillips | b67edbd | 2018-12-18 12:45:00 +0000 | [diff] [blame] | 205 | if (!fContext) { |
Robert Phillips | 6ceaafa | 2018-03-15 16:53:06 -0400 | [diff] [blame] | 206 | return nullptr; |
| 207 | } |
| 208 | |
Robert Phillips | f54883c | 2018-12-18 08:29:09 -0500 | [diff] [blame] | 209 | if (fSurface) { |
| 210 | SkCanvas* canvas = fSurface->getCanvas(); |
| 211 | |
| 212 | canvas->restoreToCount(0); |
| 213 | } |
| 214 | |
Robert Phillips | 6200036 | 2018-02-01 09:10:04 -0500 | [diff] [blame] | 215 | auto ddl = std::unique_ptr<SkDeferredDisplayList>( |
| 216 | new SkDeferredDisplayList(fCharacterization, std::move(fLazyProxyData))); |
| 217 | |
Chris Dalton | 6b49810 | 2019-08-01 14:14:52 -0600 | [diff] [blame] | 218 | fContext->priv().moveRenderTasksToDDL(ddl.get()); |
Robert Phillips | f54883c | 2018-12-18 08:29:09 -0500 | [diff] [blame] | 219 | |
| 220 | // We want a new lazy proxy target for each recorded DDL so force the (lazy proxy-backed) |
| 221 | // SkSurface to be regenerated for each DDL. |
| 222 | fSurface = nullptr; |
Robert Phillips | 6200036 | 2018-02-01 09:10:04 -0500 | [diff] [blame] | 223 | return ddl; |
Robert Phillips | ad8a43f | 2017-08-30 12:06:35 -0400 | [diff] [blame] | 224 | } |
| 225 | |
Greg Daniel | a8d9211 | 2018-03-09 12:05:04 -0500 | [diff] [blame] | 226 | sk_sp<SkImage> SkDeferredDisplayListRecorder::makePromiseTexture( |
| 227 | const GrBackendFormat& backendFormat, |
| 228 | int width, |
| 229 | int height, |
| 230 | GrMipMapped mipMapped, |
| 231 | GrSurfaceOrigin origin, |
| 232 | SkColorType colorType, |
| 233 | SkAlphaType alphaType, |
| 234 | sk_sp<SkColorSpace> colorSpace, |
Brian Salomon | cdd8a0a | 2019-01-10 12:09:52 -0500 | [diff] [blame] | 235 | PromiseImageTextureFulfillProc textureFulfillProc, |
| 236 | PromiseImageTextureReleaseProc textureReleaseProc, |
| 237 | PromiseImageTextureDoneProc textureDoneProc, |
Brian Salomon | 0cc5754 | 2019-03-08 13:28:46 -0500 | [diff] [blame] | 238 | PromiseImageTextureContext textureContext, |
| 239 | PromiseImageApiVersion version) { |
Robert Phillips | 6ceaafa | 2018-03-15 16:53:06 -0400 | [diff] [blame] | 240 | if (!fContext) { |
| 241 | return nullptr; |
| 242 | } |
| 243 | |
Greg Daniel | a8d9211 | 2018-03-09 12:05:04 -0500 | [diff] [blame] | 244 | return SkImage_Gpu::MakePromiseTexture(fContext.get(), |
| 245 | backendFormat, |
| 246 | width, |
| 247 | height, |
| 248 | mipMapped, |
| 249 | origin, |
| 250 | colorType, |
| 251 | alphaType, |
Kevin Lubick | b5502b2 | 2018-03-12 10:17:06 -0400 | [diff] [blame] | 252 | std::move(colorSpace), |
Greg Daniel | a8d9211 | 2018-03-09 12:05:04 -0500 | [diff] [blame] | 253 | textureFulfillProc, |
| 254 | textureReleaseProc, |
Brian Salomon | cdd8a0a | 2019-01-10 12:09:52 -0500 | [diff] [blame] | 255 | textureDoneProc, |
Brian Salomon | 0cc5754 | 2019-03-08 13:28:46 -0500 | [diff] [blame] | 256 | textureContext, |
| 257 | version); |
Greg Daniel | a8d9211 | 2018-03-09 12:05:04 -0500 | [diff] [blame] | 258 | } |
Robert Phillips | 6ceaafa | 2018-03-15 16:53:06 -0400 | [diff] [blame] | 259 | |
Robert Phillips | e8e2bb1 | 2018-09-27 14:26:47 -0400 | [diff] [blame] | 260 | sk_sp<SkImage> SkDeferredDisplayListRecorder::makeYUVAPromiseTexture( |
| 261 | SkYUVColorSpace yuvColorSpace, |
| 262 | const GrBackendFormat yuvaFormats[], |
Jim Van Verth | f9f0735 | 2018-10-24 10:32:20 -0400 | [diff] [blame] | 263 | const SkISize yuvaSizes[], |
Robert Phillips | e8e2bb1 | 2018-09-27 14:26:47 -0400 | [diff] [blame] | 264 | const SkYUVAIndex yuvaIndices[4], |
| 265 | int imageWidth, |
| 266 | int imageHeight, |
| 267 | GrSurfaceOrigin imageOrigin, |
| 268 | sk_sp<SkColorSpace> imageColorSpace, |
Brian Salomon | cdd8a0a | 2019-01-10 12:09:52 -0500 | [diff] [blame] | 269 | PromiseImageTextureFulfillProc textureFulfillProc, |
| 270 | PromiseImageTextureReleaseProc textureReleaseProc, |
| 271 | PromiseImageTextureDoneProc textureDoneProc, |
Brian Salomon | 0cc5754 | 2019-03-08 13:28:46 -0500 | [diff] [blame] | 272 | PromiseImageTextureContext textureContexts[], |
| 273 | PromiseImageApiVersion version) { |
Robert Phillips | e8e2bb1 | 2018-09-27 14:26:47 -0400 | [diff] [blame] | 274 | if (!fContext) { |
| 275 | return nullptr; |
| 276 | } |
| 277 | |
Jim Van Verth | 21bd60d | 2018-10-12 15:00:20 -0400 | [diff] [blame] | 278 | return SkImage_GpuYUVA::MakePromiseYUVATexture(fContext.get(), |
| 279 | yuvColorSpace, |
| 280 | yuvaFormats, |
Jim Van Verth | f9f0735 | 2018-10-24 10:32:20 -0400 | [diff] [blame] | 281 | yuvaSizes, |
Jim Van Verth | 21bd60d | 2018-10-12 15:00:20 -0400 | [diff] [blame] | 282 | yuvaIndices, |
Jim Van Verth | cea3902 | 2018-10-12 16:15:34 -0400 | [diff] [blame] | 283 | imageWidth, |
| 284 | imageHeight, |
Jim Van Verth | 21bd60d | 2018-10-12 15:00:20 -0400 | [diff] [blame] | 285 | imageOrigin, |
| 286 | std::move(imageColorSpace), |
| 287 | textureFulfillProc, |
| 288 | textureReleaseProc, |
Brian Salomon | cdd8a0a | 2019-01-10 12:09:52 -0500 | [diff] [blame] | 289 | textureDoneProc, |
Brian Salomon | 0cc5754 | 2019-03-08 13:28:46 -0500 | [diff] [blame] | 290 | textureContexts, |
| 291 | version); |
Jim Van Verth | 21bd60d | 2018-10-12 15:00:20 -0400 | [diff] [blame] | 292 | } |
| 293 | |
Robert Phillips | 6ceaafa | 2018-03-15 16:53:06 -0400 | [diff] [blame] | 294 | #endif |