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