reed@google.com | 5d4ba88 | 2012-07-31 15:45:27 +0000 | [diff] [blame] | 1 | /* |
| 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 | |
bsalomon | afe3005 | 2015-01-16 07:32:33 -0800 | [diff] [blame] | 8 | #include "SkSurface_Gpu.h" |
Greg Daniel | 173464d | 2019-02-06 15:30:34 -0500 | [diff] [blame] | 9 | #include "GrAHardwareBufferUtils.h" |
Greg Daniel | 7ef28f3 | 2017-04-20 16:41:55 +0000 | [diff] [blame] | 10 | #include "GrBackendSurface.h" |
Brian Salomon | c7fe0f7 | 2018-05-11 10:14:21 -0400 | [diff] [blame] | 11 | #include "GrCaps.h" |
robertphillips | 15c42ca | 2016-08-04 08:45:02 -0700 | [diff] [blame] | 12 | #include "GrContextPriv.h" |
Robert Phillips | fe0963c | 2019-02-07 13:25:07 -0500 | [diff] [blame] | 13 | #include "GrContextThreadSafeProxyPriv.h" |
Robert Phillips | 9338c60 | 2019-02-19 12:52:29 -0500 | [diff] [blame] | 14 | #include "GrRecordingContext.h" |
| 15 | #include "GrRecordingContextPriv.h" |
Robert Phillips | 2890fbf | 2017-07-26 15:48:41 -0400 | [diff] [blame] | 16 | #include "GrRenderTarget.h" |
Robert Phillips | 0ae6faa | 2017-03-21 16:22:00 -0400 | [diff] [blame] | 17 | #include "GrRenderTargetContextPriv.h" |
Greg Daniel | a070ed7 | 2018-04-26 16:31:38 -0400 | [diff] [blame] | 18 | #include "GrRenderTargetProxyPriv.h" |
Robert Phillips | 646e429 | 2017-06-13 12:44:56 -0400 | [diff] [blame] | 19 | #include "GrTexture.h" |
reed@google.com | 5d4ba88 | 2012-07-31 15:45:27 +0000 | [diff] [blame] | 20 | #include "SkCanvas.h" |
Robert Phillips | ad8a43f | 2017-08-30 12:06:35 -0400 | [diff] [blame] | 21 | #include "SkDeferredDisplayList.h" |
robertphillips@google.com | 97b6b07 | 2012-10-31 14:48:39 +0000 | [diff] [blame] | 22 | #include "SkGpuDevice.h" |
Brian Salomon | c7fe0f7 | 2018-05-11 10:14:21 -0400 | [diff] [blame] | 23 | #include "SkImagePriv.h" |
bsalomon | afe3005 | 2015-01-16 07:32:33 -0800 | [diff] [blame] | 24 | #include "SkImage_Base.h" |
reed | 8b26b99 | 2015-05-07 15:36:17 -0700 | [diff] [blame] | 25 | #include "SkImage_Gpu.h" |
Robert Phillips | ad8a43f | 2017-08-30 12:06:35 -0400 | [diff] [blame] | 26 | #include "SkSurfaceCharacterization.h" |
Brian Salomon | c7fe0f7 | 2018-05-11 10:14:21 -0400 | [diff] [blame] | 27 | #include "SkSurface_Base.h" |
reed@google.com | 5d4ba88 | 2012-07-31 15:45:27 +0000 | [diff] [blame] | 28 | |
reed | f037e0b | 2014-10-30 11:34:15 -0700 | [diff] [blame] | 29 | #if SK_SUPPORT_GPU |
| 30 | |
robertphillips | 24e9128 | 2016-04-29 06:46:36 -0700 | [diff] [blame] | 31 | SkSurface_Gpu::SkSurface_Gpu(sk_sp<SkGpuDevice> device) |
bsalomon | afe3005 | 2015-01-16 07:32:33 -0800 | [diff] [blame] | 32 | : INHERITED(device->width(), device->height(), &device->surfaceProps()) |
robertphillips | 24e9128 | 2016-04-29 06:46:36 -0700 | [diff] [blame] | 33 | , fDevice(std::move(device)) { |
Robert Phillips | 0ae6faa | 2017-03-21 16:22:00 -0400 | [diff] [blame] | 34 | SkASSERT(fDevice->accessRenderTargetContext()->asSurfaceProxy()->priv().isExact()); |
robertphillips@google.com | 97b6b07 | 2012-10-31 14:48:39 +0000 | [diff] [blame] | 35 | } |
reed@google.com | 5d4ba88 | 2012-07-31 15:45:27 +0000 | [diff] [blame] | 36 | |
robertphillips@google.com | 97b6b07 | 2012-10-31 14:48:39 +0000 | [diff] [blame] | 37 | SkSurface_Gpu::~SkSurface_Gpu() { |
reed@google.com | 5d4ba88 | 2012-07-31 15:45:27 +0000 | [diff] [blame] | 38 | } |
| 39 | |
joshualitt | 8179341 | 2015-07-08 12:54:04 -0700 | [diff] [blame] | 40 | static GrRenderTarget* prepare_rt_for_external_access(SkSurface_Gpu* surface, |
| 41 | SkSurface::BackendHandleAccess access) { |
reed | fa5e68e | 2015-06-29 07:37:01 -0700 | [diff] [blame] | 42 | switch (access) { |
joshualitt | 8179341 | 2015-07-08 12:54:04 -0700 | [diff] [blame] | 43 | case SkSurface::kFlushRead_BackendHandleAccess: |
reed | fa5e68e | 2015-06-29 07:37:01 -0700 | [diff] [blame] | 44 | break; |
joshualitt | 8179341 | 2015-07-08 12:54:04 -0700 | [diff] [blame] | 45 | case SkSurface::kFlushWrite_BackendHandleAccess: |
| 46 | case SkSurface::kDiscardWrite_BackendHandleAccess: |
reed | 884200e | 2015-06-29 09:00:20 -0700 | [diff] [blame] | 47 | // for now we don't special-case on Discard, but we may in the future. |
joshualitt | 8179341 | 2015-07-08 12:54:04 -0700 | [diff] [blame] | 48 | surface->notifyContentWillChange(SkSurface::kRetain_ContentChangeMode); |
reed | fa5e68e | 2015-06-29 07:37:01 -0700 | [diff] [blame] | 49 | break; |
reed | fa5e68e | 2015-06-29 07:37:01 -0700 | [diff] [blame] | 50 | } |
fmalita | e263908 | 2015-08-06 07:04:51 -0700 | [diff] [blame] | 51 | |
| 52 | // Grab the render target *after* firing notifications, as it may get switched if CoW kicks in. |
Robert Phillips | 9882dae | 2019-03-04 11:00:10 -0500 | [diff] [blame] | 53 | surface->getDevice()->flushAndSignalSemaphores(SkSurface::BackendSurfaceAccess::kNoAccess, |
Greg Daniel | b9990e4 | 2019-04-10 16:28:52 -0400 | [diff] [blame^] | 54 | kNone_GrFlushFlags, 0, nullptr); |
Brian Osman | 1105224 | 2016-10-27 14:47:55 -0400 | [diff] [blame] | 55 | GrRenderTargetContext* rtc = surface->getDevice()->accessRenderTargetContext(); |
| 56 | return rtc->accessRenderTarget(); |
joshualitt | 8179341 | 2015-07-08 12:54:04 -0700 | [diff] [blame] | 57 | } |
| 58 | |
Robert Phillips | 8caf85f | 2018-04-05 09:30:38 -0400 | [diff] [blame] | 59 | GrBackendTexture SkSurface_Gpu::onGetBackendTexture(BackendHandleAccess access) { |
| 60 | GrRenderTarget* rt = prepare_rt_for_external_access(this, access); |
| 61 | if (!rt) { |
| 62 | return GrBackendTexture(); // invalid |
| 63 | } |
| 64 | GrTexture* texture = rt->asTexture(); |
| 65 | if (texture) { |
| 66 | return texture->getBackendTexture(); |
| 67 | } |
| 68 | return GrBackendTexture(); // invalid |
| 69 | } |
| 70 | |
| 71 | GrBackendRenderTarget SkSurface_Gpu::onGetBackendRenderTarget(BackendHandleAccess access) { |
| 72 | GrRenderTarget* rt = prepare_rt_for_external_access(this, access); |
| 73 | if (!rt) { |
| 74 | return GrBackendRenderTarget(); // invalid |
| 75 | } |
| 76 | |
| 77 | return rt->getBackendRenderTarget(); |
| 78 | } |
| 79 | |
Hal Canary | 363a3f8 | 2018-10-04 11:04:48 -0400 | [diff] [blame] | 80 | SkCanvas* SkSurface_Gpu::onNewCanvas() { return new SkCanvas(fDevice); } |
reed@google.com | 5d4ba88 | 2012-07-31 15:45:27 +0000 | [diff] [blame] | 81 | |
reed | e8f3062 | 2016-03-23 18:59:25 -0700 | [diff] [blame] | 82 | sk_sp<SkSurface> SkSurface_Gpu::onNewSurface(const SkImageInfo& info) { |
Brian Osman | 1105224 | 2016-10-27 14:47:55 -0400 | [diff] [blame] | 83 | int sampleCount = fDevice->accessRenderTargetContext()->numColorSamples(); |
| 84 | GrSurfaceOrigin origin = fDevice->accessRenderTargetContext()->origin(); |
bsalomon | afe3005 | 2015-01-16 07:32:33 -0800 | [diff] [blame] | 85 | // TODO: Make caller specify this (change virtual signature of onNewSurface). |
bsalomon | 5ec26ae | 2016-02-25 08:33:02 -0800 | [diff] [blame] | 86 | static const SkBudgeted kBudgeted = SkBudgeted::kNo; |
reed | e8f3062 | 2016-03-23 18:59:25 -0700 | [diff] [blame] | 87 | return SkSurface::MakeRenderTarget(fDevice->context(), kBudgeted, info, sampleCount, |
robertphillips | 7e92276 | 2016-07-26 11:38:17 -0700 | [diff] [blame] | 88 | origin, &this->props()); |
reed@google.com | 5d4ba88 | 2012-07-31 15:45:27 +0000 | [diff] [blame] | 89 | } |
| 90 | |
Mike Reed | 114bde8 | 2018-11-21 09:12:09 -0500 | [diff] [blame] | 91 | sk_sp<SkImage> SkSurface_Gpu::onNewImageSnapshot(const SkIRect* subset) { |
Robert Phillips | e2f7d18 | 2016-12-15 09:23:05 -0500 | [diff] [blame] | 92 | GrRenderTargetContext* rtc = fDevice->accessRenderTargetContext(); |
| 93 | if (!rtc) { |
Robert Phillips | e60ad62 | 2016-11-17 10:22:48 -0500 | [diff] [blame] | 94 | return nullptr; |
| 95 | } |
| 96 | |
Robert Phillips | e2f7d18 | 2016-12-15 09:23:05 -0500 | [diff] [blame] | 97 | GrContext* ctx = fDevice->context(); |
| 98 | |
Robert Phillips | 0ae6faa | 2017-03-21 16:22:00 -0400 | [diff] [blame] | 99 | if (!rtc->asSurfaceProxy()) { |
| 100 | return nullptr; |
| 101 | } |
| 102 | |
| 103 | SkBudgeted budgeted = rtc->asSurfaceProxy()->isBudgeted(); |
| 104 | |
| 105 | sk_sp<GrTextureProxy> srcProxy = rtc->asTextureProxyRef(); |
Mike Reed | 114bde8 | 2018-11-21 09:12:09 -0500 | [diff] [blame] | 106 | |
| 107 | if (subset) { |
| 108 | srcProxy = GrSurfaceProxy::Copy(ctx, rtc->asSurfaceProxy(), rtc->mipMapped(), *subset, |
Brian Salomon | fee3f9b | 2018-12-19 12:34:12 -0500 | [diff] [blame] | 109 | SkBackingFit::kExact, budgeted); |
Mike Reed | 114bde8 | 2018-11-21 09:12:09 -0500 | [diff] [blame] | 110 | } else if (!srcProxy || rtc->priv().refsWrappedObjects()) { |
| 111 | // If the original render target is a buffer originally created by the client, then we don't |
| 112 | // want to ever retarget the SkSurface at another buffer we create. Force a copy now to avoid |
| 113 | // copy-on-write. |
Robert Phillips | 81dd3e0 | 2017-06-23 11:59:24 -0400 | [diff] [blame] | 114 | SkASSERT(rtc->origin() == rtc->asSurfaceProxy()->origin()); |
Robert Phillips | e2f7d18 | 2016-12-15 09:23:05 -0500 | [diff] [blame] | 115 | |
Brian Salomon | fee3f9b | 2018-12-19 12:34:12 -0500 | [diff] [blame] | 116 | srcProxy = GrSurfaceProxy::Copy(ctx, rtc->asSurfaceProxy(), rtc->mipMapped(), |
| 117 | SkBackingFit::kExact, budgeted); |
bsalomon | f47b9a3 | 2016-02-22 11:02:58 -0800 | [diff] [blame] | 118 | } |
Robert Phillips | e2f7d18 | 2016-12-15 09:23:05 -0500 | [diff] [blame] | 119 | |
reed | 8b26b99 | 2015-05-07 15:36:17 -0700 | [diff] [blame] | 120 | const SkImageInfo info = fDevice->imageInfo(); |
reed | e8f3062 | 2016-03-23 18:59:25 -0700 | [diff] [blame] | 121 | sk_sp<SkImage> image; |
Robert Phillips | 0ae6faa | 2017-03-21 16:22:00 -0400 | [diff] [blame] | 122 | if (srcProxy) { |
| 123 | // The renderTargetContext coming out of SkGpuDevice should always be exact and the |
| 124 | // above copy creates a kExact surfaceContext. |
| 125 | SkASSERT(srcProxy->priv().isExact()); |
Brian Salomon | 8a8dd33 | 2018-05-24 14:08:31 -0400 | [diff] [blame] | 126 | image = sk_make_sp<SkImage_Gpu>(sk_ref_sp(ctx), kNeedNewImageUniqueID, info.alphaType(), |
Brian Salomon | f05e6d3 | 2018-12-20 08:41:41 -0500 | [diff] [blame] | 127 | std::move(srcProxy), info.refColorSpace()); |
reed | 8b26b99 | 2015-05-07 15:36:17 -0700 | [diff] [blame] | 128 | } |
reed | 4af267b | 2014-11-21 08:46:37 -0800 | [diff] [blame] | 129 | return image; |
reed@google.com | 5d4ba88 | 2012-07-31 15:45:27 +0000 | [diff] [blame] | 130 | } |
| 131 | |
Mike Reed | 4c790bd | 2018-02-08 14:10:40 -0500 | [diff] [blame] | 132 | void SkSurface_Gpu::onWritePixels(const SkPixmap& src, int x, int y) { |
| 133 | fDevice->writePixels(src, x, y); |
| 134 | } |
| 135 | |
kkinnunen | abcfab4 | 2015-02-22 22:53:44 -0800 | [diff] [blame] | 136 | // Create a new render target and, if necessary, copy the contents of the old |
| 137 | // render target into it. Note that this flushes the SkGpuDevice but |
robertphillips@google.com | 97b6b07 | 2012-10-31 14:48:39 +0000 | [diff] [blame] | 138 | // doesn't force an OpenGL flush. |
commit-bot@chromium.org | c4c9870 | 2013-04-22 14:28:01 +0000 | [diff] [blame] | 139 | void SkSurface_Gpu::onCopyOnWrite(ContentChangeMode mode) { |
Robert Phillips | 602b79c | 2017-06-23 11:26:28 -0400 | [diff] [blame] | 140 | GrRenderTargetContext* rtc = fDevice->accessRenderTargetContext(); |
| 141 | |
| 142 | // are we sharing our backing proxy with the image? Note this call should never create a new |
bsalomon | eaaaf0b | 2015-01-23 08:08:04 -0800 | [diff] [blame] | 143 | // image because onCopyOnWrite is only called when there is a cached image. |
Robert Phillips | ac6b1fa | 2017-03-20 08:38:50 -0400 | [diff] [blame] | 144 | sk_sp<SkImage> image(this->refCachedImage()); |
bsalomon | eaaaf0b | 2015-01-23 08:08:04 -0800 | [diff] [blame] | 145 | SkASSERT(image); |
Robert Phillips | 602b79c | 2017-06-23 11:26:28 -0400 | [diff] [blame] | 146 | |
| 147 | GrSurfaceProxy* imageProxy = ((SkImage_Base*) image.get())->peekProxy(); |
| 148 | SkASSERT(imageProxy); |
| 149 | |
| 150 | if (rtc->asSurfaceProxy()->underlyingUniqueID() == imageProxy->underlyingUniqueID()) { |
Robert Phillips | 6de9904 | 2017-01-31 11:31:39 -0500 | [diff] [blame] | 151 | fDevice->replaceRenderTargetContext(SkSurface::kRetain_ContentChangeMode == mode); |
commit-bot@chromium.org | 28361fa | 2014-03-28 16:08:05 +0000 | [diff] [blame] | 152 | } else if (kDiscard_ContentChangeMode == mode) { |
| 153 | this->SkSurface_Gpu::onDiscard(); |
robertphillips@google.com | 97b6b07 | 2012-10-31 14:48:39 +0000 | [diff] [blame] | 154 | } |
reed@google.com | 5d4ba88 | 2012-07-31 15:45:27 +0000 | [diff] [blame] | 155 | } |
| 156 | |
commit-bot@chromium.org | 28361fa | 2014-03-28 16:08:05 +0000 | [diff] [blame] | 157 | void SkSurface_Gpu::onDiscard() { |
Brian Osman | 1105224 | 2016-10-27 14:47:55 -0400 | [diff] [blame] | 158 | fDevice->accessRenderTargetContext()->discard(); |
commit-bot@chromium.org | 28361fa | 2014-03-28 16:08:05 +0000 | [diff] [blame] | 159 | } |
| 160 | |
Greg Daniel | b9990e4 | 2019-04-10 16:28:52 -0400 | [diff] [blame^] | 161 | GrSemaphoresSubmitted SkSurface_Gpu::onFlush(BackendSurfaceAccess access, GrFlushFlags flags, |
Greg Daniel | bae7121 | 2019-03-01 15:24:35 -0500 | [diff] [blame] | 162 | int numSemaphores, |
Greg Daniel | 5131678 | 2017-08-02 15:10:09 +0000 | [diff] [blame] | 163 | GrBackendSemaphore signalSemaphores[]) { |
Greg Daniel | bae7121 | 2019-03-01 15:24:35 -0500 | [diff] [blame] | 164 | return fDevice->flushAndSignalSemaphores(access, flags, numSemaphores, signalSemaphores); |
Greg Daniel | a5cb781 | 2017-06-16 09:45:32 -0400 | [diff] [blame] | 165 | } |
| 166 | |
Greg Daniel | c64ee46 | 2017-06-15 16:59:49 -0400 | [diff] [blame] | 167 | bool SkSurface_Gpu::onWait(int numSemaphores, const GrBackendSemaphore* waitSemaphores) { |
| 168 | return fDevice->wait(numSemaphores, waitSemaphores); |
ericrk | f7b8b8a | 2016-02-24 14:49:51 -0800 | [diff] [blame] | 169 | } |
| 170 | |
Robert Phillips | be77a02 | 2018-04-03 17:17:05 -0400 | [diff] [blame] | 171 | bool SkSurface_Gpu::onCharacterize(SkSurfaceCharacterization* characterization) const { |
Robert Phillips | ad8a43f | 2017-08-30 12:06:35 -0400 | [diff] [blame] | 172 | GrRenderTargetContext* rtc = fDevice->accessRenderTargetContext(); |
Robert Phillips | 8def8bf | 2017-11-30 08:46:03 -0500 | [diff] [blame] | 173 | GrContext* ctx = fDevice->context(); |
Robert Phillips | ad8a43f | 2017-08-30 12:06:35 -0400 | [diff] [blame] | 174 | |
Robert Phillips | 8d1e67e | 2017-12-04 13:48:14 -0500 | [diff] [blame] | 175 | int maxResourceCount; |
| 176 | size_t maxResourceBytes; |
| 177 | ctx->getResourceCacheLimits(&maxResourceCount, &maxResourceBytes); |
| 178 | |
Robert Phillips | e8fabb2 | 2018-02-04 14:33:21 -0500 | [diff] [blame] | 179 | bool mipmapped = rtc->asTextureProxy() ? GrMipMapped::kYes == rtc->asTextureProxy()->mipMapped() |
| 180 | : false; |
| 181 | |
Robert Phillips | be77a02 | 2018-04-03 17:17:05 -0400 | [diff] [blame] | 182 | // TODO: the addition of colorType to the surfaceContext should remove this calculation |
| 183 | SkColorType ct; |
| 184 | if (!GrPixelConfigToColorType(rtc->colorSpaceInfo().config(), &ct)) { |
| 185 | return false; |
| 186 | } |
| 187 | |
Greg Daniel | a070ed7 | 2018-04-26 16:31:38 -0400 | [diff] [blame] | 188 | bool usesGLFBO0 = rtc->asRenderTargetProxy()->rtPriv().glRTFBOIDIs0(); |
| 189 | // We should never get in the situation where we have a texture render target that is also |
| 190 | // backend by FBO 0. |
| 191 | SkASSERT(!usesGLFBO0 || !SkToBool(rtc->asTextureProxy())); |
| 192 | |
Robert Phillips | be77a02 | 2018-04-03 17:17:05 -0400 | [diff] [blame] | 193 | SkImageInfo ii = SkImageInfo::Make(rtc->width(), rtc->height(), ct, kPremul_SkAlphaType, |
| 194 | rtc->colorSpaceInfo().refColorSpace()); |
| 195 | |
| 196 | characterization->set(ctx->threadSafeProxy(), maxResourceBytes, ii, rtc->origin(), |
| 197 | rtc->colorSpaceInfo().config(), rtc->fsaaType(), rtc->numStencilSamples(), |
| 198 | SkSurfaceCharacterization::Textureable(SkToBool(rtc->asTextureProxy())), |
Greg Daniel | a070ed7 | 2018-04-26 16:31:38 -0400 | [diff] [blame] | 199 | SkSurfaceCharacterization::MipMapped(mipmapped), |
Greg Daniel | b46add8 | 2019-01-02 14:51:29 -0500 | [diff] [blame] | 200 | SkSurfaceCharacterization::UsesGLFBO0(usesGLFBO0), |
| 201 | SkSurfaceCharacterization::VulkanSecondaryCBCompatible(false), |
| 202 | this->props()); |
Robert Phillips | 8def8bf | 2017-11-30 08:46:03 -0500 | [diff] [blame] | 203 | |
Robert Phillips | ad8a43f | 2017-08-30 12:06:35 -0400 | [diff] [blame] | 204 | return true; |
| 205 | } |
| 206 | |
Brian Salomon | c552eaf | 2019-03-20 15:45:50 -0400 | [diff] [blame] | 207 | void SkSurface_Gpu::onDraw(SkCanvas* canvas, SkScalar x, SkScalar y, const SkPaint* paint) { |
| 208 | // If the dst is also GPU we try to not force a new image snapshot (by calling the base class |
| 209 | // onDraw) since that may not always perform the copy-on-write optimization. |
| 210 | auto tryDraw = [&] { |
| 211 | SkASSERT(fDevice->context()->priv().asDirectContext()); |
| 212 | GrContext* context = fDevice->context(); |
| 213 | GrContext* canvasContext = canvas->getGrContext(); |
| 214 | if (!canvasContext) { |
| 215 | return false; |
| 216 | } |
| 217 | if (!canvasContext->priv().asDirectContext() || |
| 218 | canvasContext->priv().contextID() != context->priv().contextID()) { |
| 219 | return false; |
| 220 | } |
| 221 | GrRenderTargetContext* rtc = fDevice->accessRenderTargetContext(); |
| 222 | if (!rtc) { |
| 223 | return false; |
| 224 | } |
| 225 | sk_sp<GrTextureProxy> srcProxy = rtc->asTextureProxyRef(); |
| 226 | if (!srcProxy) { |
| 227 | return false; |
| 228 | } |
| 229 | // Possibly we could skip making an image here if SkGpuDevice exposed a lower level way |
| 230 | // of drawing a texture proxy. |
| 231 | const SkImageInfo info = fDevice->imageInfo(); |
| 232 | sk_sp<SkImage> image; |
| 233 | image = sk_make_sp<SkImage_Gpu>(sk_ref_sp(context), kNeedNewImageUniqueID, info.alphaType(), |
| 234 | std::move(srcProxy), info.refColorSpace()); |
| 235 | canvas->drawImage(image, x, y, paint); |
| 236 | return true; |
| 237 | }; |
| 238 | if (!tryDraw()) { |
| 239 | INHERITED::onDraw(canvas, x, y, paint); |
| 240 | } |
| 241 | } |
| 242 | |
Robert Phillips | be77a02 | 2018-04-03 17:17:05 -0400 | [diff] [blame] | 243 | bool SkSurface_Gpu::isCompatible(const SkSurfaceCharacterization& characterization) const { |
Robert Phillips | ad8a43f | 2017-08-30 12:06:35 -0400 | [diff] [blame] | 244 | GrRenderTargetContext* rtc = fDevice->accessRenderTargetContext(); |
Robert Phillips | 8def8bf | 2017-11-30 08:46:03 -0500 | [diff] [blame] | 245 | GrContext* ctx = fDevice->context(); |
Robert Phillips | ad8a43f | 2017-08-30 12:06:35 -0400 | [diff] [blame] | 246 | |
Robert Phillips | be77a02 | 2018-04-03 17:17:05 -0400 | [diff] [blame] | 247 | if (!characterization.isValid()) { |
Robert Phillips | fc711a2 | 2018-02-13 17:03:00 -0500 | [diff] [blame] | 248 | return false; |
| 249 | } |
| 250 | |
Greg Daniel | b085fa9 | 2019-03-05 16:55:12 -0500 | [diff] [blame] | 251 | if (characterization.vulkanSecondaryCBCompatible()) { |
| 252 | return false; |
| 253 | } |
| 254 | |
Robert Phillips | 8d1e67e | 2017-12-04 13:48:14 -0500 | [diff] [blame] | 255 | // As long as the current state if the context allows for greater or equal resources, |
| 256 | // we allow the DDL to be replayed. |
Robert Phillips | fc711a2 | 2018-02-13 17:03:00 -0500 | [diff] [blame] | 257 | // DDL TODO: should we just remove the resource check and ignore the cache limits on playback? |
Robert Phillips | 8d1e67e | 2017-12-04 13:48:14 -0500 | [diff] [blame] | 258 | int maxResourceCount; |
| 259 | size_t maxResourceBytes; |
| 260 | ctx->getResourceCacheLimits(&maxResourceCount, &maxResourceBytes); |
| 261 | |
Robert Phillips | be77a02 | 2018-04-03 17:17:05 -0400 | [diff] [blame] | 262 | if (characterization.isTextureable()) { |
Robert Phillips | e8fabb2 | 2018-02-04 14:33:21 -0500 | [diff] [blame] | 263 | if (!rtc->asTextureProxy()) { |
| 264 | // If the characterization was textureable we require the replay dest to also be |
| 265 | // textureable. If the characterized surface wasn't textureable we allow the replay |
| 266 | // dest to be textureable. |
| 267 | return false; |
| 268 | } |
| 269 | |
Robert Phillips | be77a02 | 2018-04-03 17:17:05 -0400 | [diff] [blame] | 270 | if (characterization.isMipMapped() && |
| 271 | GrMipMapped::kNo == rtc->asTextureProxy()->mipMapped()) { |
Robert Phillips | e8fabb2 | 2018-02-04 14:33:21 -0500 | [diff] [blame] | 272 | // Fail if the DDL's surface was mipmapped but the replay surface is not. |
| 273 | // Allow drawing to proceed if the DDL was not mipmapped but the replay surface is. |
| 274 | return false; |
| 275 | } |
| 276 | } |
| 277 | |
Greg Daniel | a070ed7 | 2018-04-26 16:31:38 -0400 | [diff] [blame] | 278 | if (characterization.usesGLFBO0() != rtc->asRenderTargetProxy()->rtPriv().glRTFBOIDIs0()) { |
| 279 | return false; |
| 280 | } |
| 281 | |
Robert Phillips | be77a02 | 2018-04-03 17:17:05 -0400 | [diff] [blame] | 282 | // TODO: the addition of colorType to the surfaceContext should remove this calculation |
| 283 | SkColorType rtcColorType; |
| 284 | if (!GrPixelConfigToColorType(rtc->colorSpaceInfo().config(), &rtcColorType)) { |
| 285 | return false; |
| 286 | } |
| 287 | |
Robert Phillips | fe0963c | 2019-02-07 13:25:07 -0500 | [diff] [blame] | 288 | return characterization.contextInfo() && characterization.contextInfo()->priv().matches(ctx) && |
Robert Phillips | be77a02 | 2018-04-03 17:17:05 -0400 | [diff] [blame] | 289 | characterization.cacheMaxResourceBytes() <= maxResourceBytes && |
| 290 | characterization.origin() == rtc->origin() && |
| 291 | characterization.config() == rtc->colorSpaceInfo().config() && |
| 292 | characterization.width() == rtc->width() && |
| 293 | characterization.height() == rtc->height() && |
| 294 | characterization.colorType() == rtcColorType && |
| 295 | characterization.fsaaType() == rtc->fsaaType() && |
| 296 | characterization.stencilCount() == rtc->numStencilSamples() && |
| 297 | SkColorSpace::Equals(characterization.colorSpace(), |
| 298 | rtc->colorSpaceInfo().colorSpace()) && |
| 299 | characterization.surfaceProps() == rtc->surfaceProps(); |
Robert Phillips | ad8a43f | 2017-08-30 12:06:35 -0400 | [diff] [blame] | 300 | } |
| 301 | |
Robert Phillips | d5f9cdd | 2018-01-31 09:29:48 -0500 | [diff] [blame] | 302 | bool SkSurface_Gpu::onDraw(const SkDeferredDisplayList* ddl) { |
Robert Phillips | fc711a2 | 2018-02-13 17:03:00 -0500 | [diff] [blame] | 303 | if (!ddl || !this->isCompatible(ddl->characterization())) { |
Robert Phillips | 7ffbcf9 | 2017-12-04 12:52:46 -0500 | [diff] [blame] | 304 | return false; |
Robert Phillips | ad8a43f | 2017-08-30 12:06:35 -0400 | [diff] [blame] | 305 | } |
| 306 | |
Robert Phillips | 6200036 | 2018-02-01 09:10:04 -0500 | [diff] [blame] | 307 | GrRenderTargetContext* rtc = fDevice->accessRenderTargetContext(); |
| 308 | GrContext* ctx = fDevice->context(); |
| 309 | |
Robert Phillips | 9da87e0 | 2019-02-04 13:26:26 -0500 | [diff] [blame] | 310 | ctx->priv().copyOpListsFromDDL(ddl, rtc->asRenderTargetProxy()); |
Robert Phillips | 6200036 | 2018-02-01 09:10:04 -0500 | [diff] [blame] | 311 | return true; |
Robert Phillips | ad8a43f | 2017-08-30 12:06:35 -0400 | [diff] [blame] | 312 | } |
| 313 | |
| 314 | |
reed@google.com | 5d4ba88 | 2012-07-31 15:45:27 +0000 | [diff] [blame] | 315 | /////////////////////////////////////////////////////////////////////////////// |
| 316 | |
brianosman | 0e22eb8 | 2016-08-30 07:07:59 -0700 | [diff] [blame] | 317 | bool SkSurface_Gpu::Valid(const SkImageInfo& info) { |
Brian Osman | 38a62bd | 2018-10-11 14:45:07 -0400 | [diff] [blame] | 318 | return true; |
brianosman | 0e22eb8 | 2016-08-30 07:07:59 -0700 | [diff] [blame] | 319 | } |
| 320 | |
Robert Phillips | be77a02 | 2018-04-03 17:17:05 -0400 | [diff] [blame] | 321 | bool SkSurface_Gpu::Valid(const GrCaps* caps, GrPixelConfig config, SkColorSpace* colorSpace) { |
brianosman | 0e22eb8 | 2016-08-30 07:07:59 -0700 | [diff] [blame] | 322 | switch (config) { |
brianosman | 0e22eb8 | 2016-08-30 07:07:59 -0700 | [diff] [blame] | 323 | case kSRGBA_8888_GrPixelConfig: |
| 324 | case kSBGRA_8888_GrPixelConfig: |
Brian Osman | 2b23c4b | 2018-06-01 12:25:08 -0400 | [diff] [blame] | 325 | return caps->srgbSupport(); |
Greg Daniel | f421685 | 2018-10-11 17:47:17 +0000 | [diff] [blame] | 326 | default: |
Brian Osman | 38a62bd | 2018-10-11 14:45:07 -0400 | [diff] [blame] | 327 | return true; |
brianosman | 0e22eb8 | 2016-08-30 07:07:59 -0700 | [diff] [blame] | 328 | } |
| 329 | } |
| 330 | |
Robert Phillips | 9338c60 | 2019-02-19 12:52:29 -0500 | [diff] [blame] | 331 | sk_sp<SkSurface> SkSurface::MakeRenderTarget(GrRecordingContext* context, |
Robert Phillips | 6b6fcc7 | 2018-03-30 13:57:00 -0400 | [diff] [blame] | 332 | const SkSurfaceCharacterization& c, |
| 333 | SkBudgeted budgeted) { |
Robert Phillips | be77a02 | 2018-04-03 17:17:05 -0400 | [diff] [blame] | 334 | if (!context || !c.isValid()) { |
Robert Phillips | 6b6fcc7 | 2018-03-30 13:57:00 -0400 | [diff] [blame] | 335 | return nullptr; |
| 336 | } |
| 337 | |
Greg Daniel | a070ed7 | 2018-04-26 16:31:38 -0400 | [diff] [blame] | 338 | if (c.usesGLFBO0()) { |
| 339 | // If we are making the surface we will never use FBO0. |
| 340 | return nullptr; |
| 341 | } |
| 342 | |
Robert Phillips | 9da87e0 | 2019-02-04 13:26:26 -0500 | [diff] [blame] | 343 | if (!SkSurface_Gpu::Valid(context->priv().caps(), c.config(), c.colorSpace())) { |
Robert Phillips | 6b6fcc7 | 2018-03-30 13:57:00 -0400 | [diff] [blame] | 344 | return nullptr; |
| 345 | } |
| 346 | |
Robert Phillips | be77a02 | 2018-04-03 17:17:05 -0400 | [diff] [blame] | 347 | // In order to ensure compatibility we have to match the backend format (i.e. the GrPixelConfig |
| 348 | // of the characterization) |
| 349 | GrSurfaceDesc desc; |
| 350 | desc.fFlags = kRenderTarget_GrSurfaceFlag; |
| 351 | desc.fWidth = c.width(); |
| 352 | desc.fHeight = c.height(); |
| 353 | desc.fConfig = c.config(); |
| 354 | desc.fSampleCnt = c.stencilCount(); |
Robert Phillips | 6b6fcc7 | 2018-03-30 13:57:00 -0400 | [diff] [blame] | 355 | |
Greg Daniel | 4065d45 | 2018-11-16 15:43:41 -0500 | [diff] [blame] | 356 | const GrBackendFormat format = |
Robert Phillips | 9da87e0 | 2019-02-04 13:26:26 -0500 | [diff] [blame] | 357 | context->priv().caps()->getBackendFormatFromColorType(c.colorType()); |
Greg Daniel | 4065d45 | 2018-11-16 15:43:41 -0500 | [diff] [blame] | 358 | |
Robert Phillips | be77a02 | 2018-04-03 17:17:05 -0400 | [diff] [blame] | 359 | sk_sp<GrSurfaceContext> sc( |
Robert Phillips | 9da87e0 | 2019-02-04 13:26:26 -0500 | [diff] [blame] | 360 | context->priv().makeDeferredSurfaceContext(format, desc, c.origin(), |
| 361 | GrMipMapped(c.isMipMapped()), |
| 362 | SkBackingFit::kExact, budgeted, |
| 363 | c.refColorSpace(), |
| 364 | &c.surfaceProps())); |
Robert Phillips | be77a02 | 2018-04-03 17:17:05 -0400 | [diff] [blame] | 365 | if (!sc || !sc->asRenderTargetContext()) { |
| 366 | return nullptr; |
| 367 | } |
| 368 | |
Robert Phillips | 9338c60 | 2019-02-19 12:52:29 -0500 | [diff] [blame] | 369 | // CONTEXT TODO: remove this use of 'backdoor' to create an SkGpuDevice |
| 370 | sk_sp<SkGpuDevice> device(SkGpuDevice::Make(context->priv().backdoor(), |
| 371 | sk_ref_sp(sc->asRenderTargetContext()), |
Robert Phillips | be77a02 | 2018-04-03 17:17:05 -0400 | [diff] [blame] | 372 | c.width(), c.height(), |
| 373 | SkGpuDevice::kClear_InitContents)); |
| 374 | if (!device) { |
| 375 | return nullptr; |
| 376 | } |
| 377 | |
| 378 | sk_sp<SkSurface> s = sk_make_sp<SkSurface_Gpu>(std::move(device)); |
| 379 | #ifdef SK_DEBUG |
| 380 | if (s) { |
| 381 | SkSurface_Gpu* gpuSurface = static_cast<SkSurface_Gpu*>(s.get()); |
| 382 | SkASSERT(gpuSurface->isCompatible(c)); |
| 383 | } |
| 384 | #endif |
| 385 | |
| 386 | return s; |
Robert Phillips | 6b6fcc7 | 2018-03-30 13:57:00 -0400 | [diff] [blame] | 387 | } |
| 388 | |
| 389 | |
reed | e8f3062 | 2016-03-23 18:59:25 -0700 | [diff] [blame] | 390 | sk_sp<SkSurface> SkSurface::MakeRenderTarget(GrContext* ctx, SkBudgeted budgeted, |
| 391 | const SkImageInfo& info, int sampleCount, |
Greg Daniel | e252f08 | 2017-10-23 16:05:23 -0400 | [diff] [blame] | 392 | GrSurfaceOrigin origin, const SkSurfaceProps* props, |
| 393 | bool shouldCreateWithMips) { |
Greg Daniel | f47069c | 2017-10-24 11:57:01 -0400 | [diff] [blame] | 394 | if (!ctx) { |
| 395 | return nullptr; |
| 396 | } |
brianosman | 0e22eb8 | 2016-08-30 07:07:59 -0700 | [diff] [blame] | 397 | if (!SkSurface_Gpu::Valid(info)) { |
| 398 | return nullptr; |
| 399 | } |
Brian Salomon | bdecacf | 2018-02-02 20:32:49 -0500 | [diff] [blame] | 400 | sampleCount = SkTMax(1, sampleCount); |
Greg Daniel | e252f08 | 2017-10-23 16:05:23 -0400 | [diff] [blame] | 401 | GrMipMapped mipMapped = shouldCreateWithMips ? GrMipMapped::kYes : GrMipMapped::kNo; |
| 402 | |
Robert Phillips | 9da87e0 | 2019-02-04 13:26:26 -0500 | [diff] [blame] | 403 | if (!ctx->priv().caps()->mipMapSupport()) { |
Greg Daniel | f47069c | 2017-10-24 11:57:01 -0400 | [diff] [blame] | 404 | mipMapped = GrMipMapped::kNo; |
| 405 | } |
| 406 | |
robertphillips | 24e9128 | 2016-04-29 06:46:36 -0700 | [diff] [blame] | 407 | sk_sp<SkGpuDevice> device(SkGpuDevice::Make( |
Greg Daniel | e252f08 | 2017-10-23 16:05:23 -0400 | [diff] [blame] | 408 | ctx, budgeted, info, sampleCount, origin, props, mipMapped, |
| 409 | SkGpuDevice::kClear_InitContents)); |
bsalomon | afe3005 | 2015-01-16 07:32:33 -0800 | [diff] [blame] | 410 | if (!device) { |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 411 | return nullptr; |
reed@google.com | 5d4ba88 | 2012-07-31 15:45:27 +0000 | [diff] [blame] | 412 | } |
robertphillips | 24e9128 | 2016-04-29 06:46:36 -0700 | [diff] [blame] | 413 | return sk_make_sp<SkSurface_Gpu>(std::move(device)); |
reed@google.com | 5d4ba88 | 2012-07-31 15:45:27 +0000 | [diff] [blame] | 414 | } |
reed | f037e0b | 2014-10-30 11:34:15 -0700 | [diff] [blame] | 415 | |
Robert Phillips | d5f9cdd | 2018-01-31 09:29:48 -0500 | [diff] [blame] | 416 | sk_sp<SkSurface> SkSurface_Gpu::MakeWrappedRenderTarget(GrContext* context, |
| 417 | sk_sp<GrRenderTargetContext> rtc) { |
| 418 | if (!context) { |
| 419 | return nullptr; |
| 420 | } |
| 421 | |
Brian Salomon | f777897 | 2018-03-08 10:13:17 -0500 | [diff] [blame] | 422 | int w = rtc->width(); |
| 423 | int h = rtc->height(); |
| 424 | sk_sp<SkGpuDevice> device( |
| 425 | SkGpuDevice::Make(context, std::move(rtc), w, h, SkGpuDevice::kUninit_InitContents)); |
Robert Phillips | d5f9cdd | 2018-01-31 09:29:48 -0500 | [diff] [blame] | 426 | if (!device) { |
| 427 | return nullptr; |
| 428 | } |
| 429 | |
| 430 | return sk_make_sp<SkSurface_Gpu>(std::move(device)); |
| 431 | } |
| 432 | |
Greg Daniel | faa095e | 2017-12-19 13:15:02 -0500 | [diff] [blame] | 433 | bool validate_backend_texture(GrContext* ctx, const GrBackendTexture& tex, GrPixelConfig* config, |
| 434 | int sampleCnt, SkColorType ct, sk_sp<SkColorSpace> cs, |
| 435 | bool texturable) { |
Greg Daniel | 66aebf3 | 2018-04-09 09:15:56 -0400 | [diff] [blame] | 436 | if (!tex.isValid()) { |
| 437 | return false; |
| 438 | } |
Greg Daniel | faa095e | 2017-12-19 13:15:02 -0500 | [diff] [blame] | 439 | // TODO: Create a SkImageColorInfo struct for color, alpha, and color space so we don't need to |
| 440 | // create a fake image info here. |
| 441 | SkImageInfo info = SkImageInfo::Make(1, 1, ct, kPremul_SkAlphaType, cs); |
| 442 | |
| 443 | if (!SkSurface_Gpu::Valid(info)) { |
| 444 | return false; |
| 445 | } |
| 446 | |
Brian Salomon | f391d0f | 2018-12-14 09:18:50 -0500 | [diff] [blame] | 447 | GrBackendFormat backendFormat = tex.getBackendFormat(); |
| 448 | if (!backendFormat.isValid()) { |
| 449 | return false; |
| 450 | } |
Robert Phillips | 9da87e0 | 2019-02-04 13:26:26 -0500 | [diff] [blame] | 451 | *config = ctx->priv().caps()->getConfigFromBackendFormat(backendFormat, ct); |
Brian Salomon | f391d0f | 2018-12-14 09:18:50 -0500 | [diff] [blame] | 452 | if (*config == kUnknown_GrPixelConfig) { |
Greg Daniel | faa095e | 2017-12-19 13:15:02 -0500 | [diff] [blame] | 453 | return false; |
| 454 | } |
| 455 | |
Brian Salomon | bdecacf | 2018-02-02 20:32:49 -0500 | [diff] [blame] | 456 | // We don't require that the client gave us an exact valid sample cnt. However, it must be |
| 457 | // less than the max supported sample count and 1 if MSAA is unsupported for the color type. |
Robert Phillips | 9da87e0 | 2019-02-04 13:26:26 -0500 | [diff] [blame] | 458 | if (!ctx->priv().caps()->getRenderTargetSampleCount(sampleCnt, *config)) { |
Greg Daniel | faa095e | 2017-12-19 13:15:02 -0500 | [diff] [blame] | 459 | return false; |
| 460 | } |
| 461 | |
Robert Phillips | 9da87e0 | 2019-02-04 13:26:26 -0500 | [diff] [blame] | 462 | if (texturable && !ctx->priv().caps()->isConfigTexturable(*config)) { |
Greg Daniel | faa095e | 2017-12-19 13:15:02 -0500 | [diff] [blame] | 463 | return false; |
| 464 | } |
| 465 | return true; |
| 466 | } |
| 467 | |
| 468 | sk_sp<SkSurface> SkSurface::MakeFromBackendTexture(GrContext* context, const GrBackendTexture& tex, |
| 469 | GrSurfaceOrigin origin, int sampleCnt, |
| 470 | SkColorType colorType, |
| 471 | sk_sp<SkColorSpace> colorSpace, |
Greg Daniel | 8ce7991 | 2019-02-05 10:08:43 -0500 | [diff] [blame] | 472 | const SkSurfaceProps* props, |
| 473 | SkSurface::TextureReleaseProc textureReleaseProc, |
| 474 | SkSurface::ReleaseContext releaseContext) { |
Greg Daniel | faa095e | 2017-12-19 13:15:02 -0500 | [diff] [blame] | 475 | if (!context) { |
| 476 | return nullptr; |
| 477 | } |
Brian Salomon | bdecacf | 2018-02-02 20:32:49 -0500 | [diff] [blame] | 478 | sampleCnt = SkTMax(1, sampleCnt); |
Greg Daniel | faa095e | 2017-12-19 13:15:02 -0500 | [diff] [blame] | 479 | GrBackendTexture texCopy = tex; |
| 480 | if (!validate_backend_texture(context, texCopy, &texCopy.fConfig, |
| 481 | sampleCnt, colorType, colorSpace, true)) { |
| 482 | return nullptr; |
| 483 | } |
| 484 | |
Brian Salomon | 5370677 | 2018-03-19 14:18:08 -0400 | [diff] [blame] | 485 | if (!context) { |
| 486 | return nullptr; |
| 487 | } |
Robert Phillips | 9da87e0 | 2019-02-04 13:26:26 -0500 | [diff] [blame] | 488 | if (!SkSurface_Gpu::Valid(context->priv().caps(), texCopy.config(), colorSpace.get())) { |
Brian Salomon | 5370677 | 2018-03-19 14:18:08 -0400 | [diff] [blame] | 489 | return nullptr; |
| 490 | } |
| 491 | sampleCnt = SkTMax(1, sampleCnt); |
| 492 | |
Robert Phillips | 9da87e0 | 2019-02-04 13:26:26 -0500 | [diff] [blame] | 493 | sk_sp<GrRenderTargetContext> rtc(context->priv().makeBackendTextureRenderTargetContext( |
Brian Salomon | 5370677 | 2018-03-19 14:18:08 -0400 | [diff] [blame] | 494 | texCopy, |
| 495 | origin, |
| 496 | sampleCnt, |
| 497 | std::move(colorSpace), |
Greg Daniel | 8ce7991 | 2019-02-05 10:08:43 -0500 | [diff] [blame] | 498 | props, |
| 499 | textureReleaseProc, |
| 500 | releaseContext)); |
Brian Salomon | 5370677 | 2018-03-19 14:18:08 -0400 | [diff] [blame] | 501 | if (!rtc) { |
| 502 | return nullptr; |
| 503 | } |
| 504 | |
| 505 | sk_sp<SkGpuDevice> device(SkGpuDevice::Make(context, std::move(rtc), texCopy.width(), |
| 506 | texCopy.height(), |
| 507 | SkGpuDevice::kUninit_InitContents)); |
| 508 | if (!device) { |
| 509 | return nullptr; |
| 510 | } |
| 511 | return sk_make_sp<SkSurface_Gpu>(std::move(device)); |
Greg Daniel | faa095e | 2017-12-19 13:15:02 -0500 | [diff] [blame] | 512 | } |
| 513 | |
Greg Daniel | faa095e | 2017-12-19 13:15:02 -0500 | [diff] [blame] | 514 | bool validate_backend_render_target(GrContext* ctx, const GrBackendRenderTarget& rt, |
| 515 | GrPixelConfig* config, SkColorType ct, sk_sp<SkColorSpace> cs) { |
| 516 | // TODO: Create a SkImageColorInfo struct for color, alpha, and color space so we don't need to |
| 517 | // create a fake image info here. |
| 518 | SkImageInfo info = SkImageInfo::Make(1, 1, ct, kPremul_SkAlphaType, cs); |
| 519 | |
| 520 | if (!SkSurface_Gpu::Valid(info)) { |
| 521 | return false; |
| 522 | } |
| 523 | |
Robert Phillips | 9da87e0 | 2019-02-04 13:26:26 -0500 | [diff] [blame] | 524 | *config = ctx->priv().caps()->validateBackendRenderTarget(rt, ct); |
Brian Salomon | f391d0f | 2018-12-14 09:18:50 -0500 | [diff] [blame] | 525 | if (*config == kUnknown_GrPixelConfig) { |
Greg Daniel | faa095e | 2017-12-19 13:15:02 -0500 | [diff] [blame] | 526 | return false; |
| 527 | } |
| 528 | |
Brian Salomon | bdecacf | 2018-02-02 20:32:49 -0500 | [diff] [blame] | 529 | if (rt.sampleCnt() > 1) { |
Robert Phillips | 9da87e0 | 2019-02-04 13:26:26 -0500 | [diff] [blame] | 530 | if (ctx->priv().caps()->maxRenderTargetSampleCount(*config) <= 1) { |
Brian Salomon | bdecacf | 2018-02-02 20:32:49 -0500 | [diff] [blame] | 531 | return false; |
| 532 | } |
Robert Phillips | 9da87e0 | 2019-02-04 13:26:26 -0500 | [diff] [blame] | 533 | } else if (!ctx->priv().caps()->isConfigRenderable(*config)) { |
Greg Daniel | faa095e | 2017-12-19 13:15:02 -0500 | [diff] [blame] | 534 | return false; |
| 535 | } |
| 536 | |
| 537 | return true; |
| 538 | } |
| 539 | |
| 540 | sk_sp<SkSurface> SkSurface::MakeFromBackendRenderTarget(GrContext* context, |
| 541 | const GrBackendRenderTarget& rt, |
| 542 | GrSurfaceOrigin origin, |
| 543 | SkColorType colorType, |
| 544 | sk_sp<SkColorSpace> colorSpace, |
Greg Daniel | 8ce7991 | 2019-02-05 10:08:43 -0500 | [diff] [blame] | 545 | const SkSurfaceProps* props, |
| 546 | SkSurface::RenderTargetReleaseProc relProc, |
| 547 | SkSurface::ReleaseContext releaseContext) { |
Greg Daniel | faa095e | 2017-12-19 13:15:02 -0500 | [diff] [blame] | 548 | if (!context) { |
| 549 | return nullptr; |
| 550 | } |
Brian Salomon | 49edccd | 2018-03-23 15:31:32 -0400 | [diff] [blame] | 551 | |
Greg Daniel | faa095e | 2017-12-19 13:15:02 -0500 | [diff] [blame] | 552 | GrBackendRenderTarget rtCopy = rt; |
| 553 | if (!validate_backend_render_target(context, rtCopy, &rtCopy.fConfig, colorType, colorSpace)) { |
| 554 | return nullptr; |
| 555 | } |
Robert Phillips | 9da87e0 | 2019-02-04 13:26:26 -0500 | [diff] [blame] | 556 | if (!SkSurface_Gpu::Valid(context->priv().caps(), rtCopy.config(), colorSpace.get())) { |
Brian Salomon | 49edccd | 2018-03-23 15:31:32 -0400 | [diff] [blame] | 557 | return nullptr; |
| 558 | } |
Greg Daniel | faa095e | 2017-12-19 13:15:02 -0500 | [diff] [blame] | 559 | |
Brian Salomon | 49edccd | 2018-03-23 15:31:32 -0400 | [diff] [blame] | 560 | if (!context) { |
| 561 | return nullptr; |
| 562 | } |
| 563 | |
| 564 | sk_sp<GrRenderTargetContext> rtc( |
Robert Phillips | 9da87e0 | 2019-02-04 13:26:26 -0500 | [diff] [blame] | 565 | context->priv().makeBackendRenderTargetRenderTargetContext( |
Greg Daniel | 8ce7991 | 2019-02-05 10:08:43 -0500 | [diff] [blame] | 566 | rtCopy, origin, std::move(colorSpace), props, relProc, releaseContext)); |
Brian Salomon | 49edccd | 2018-03-23 15:31:32 -0400 | [diff] [blame] | 567 | if (!rtc) { |
| 568 | return nullptr; |
| 569 | } |
| 570 | |
| 571 | sk_sp<SkGpuDevice> device(SkGpuDevice::Make(context, std::move(rtc), rtCopy.width(), |
| 572 | rtCopy.height(), |
| 573 | SkGpuDevice::kUninit_InitContents)); |
| 574 | if (!device) { |
| 575 | return nullptr; |
| 576 | } |
| 577 | |
| 578 | return sk_make_sp<SkSurface_Gpu>(std::move(device)); |
Greg Daniel | faa095e | 2017-12-19 13:15:02 -0500 | [diff] [blame] | 579 | } |
| 580 | |
reed | e8f3062 | 2016-03-23 18:59:25 -0700 | [diff] [blame] | 581 | sk_sp<SkSurface> SkSurface::MakeFromBackendTextureAsRenderTarget(GrContext* context, |
Greg Daniel | 7ef28f3 | 2017-04-20 16:41:55 +0000 | [diff] [blame] | 582 | const GrBackendTexture& tex, |
| 583 | GrSurfaceOrigin origin, |
| 584 | int sampleCnt, |
Brian Salomon | cb88470 | 2018-03-19 14:01:21 -0400 | [diff] [blame] | 585 | SkColorType colorType, |
Greg Daniel | 7ef28f3 | 2017-04-20 16:41:55 +0000 | [diff] [blame] | 586 | sk_sp<SkColorSpace> colorSpace, |
| 587 | const SkSurfaceProps* props) { |
| 588 | if (!context) { |
| 589 | return nullptr; |
| 590 | } |
Justin Novosad | 21a99d4 | 2018-07-17 16:53:43 -0400 | [diff] [blame] | 591 | |
Brian Salomon | bdecacf | 2018-02-02 20:32:49 -0500 | [diff] [blame] | 592 | sampleCnt = SkTMax(1, sampleCnt); |
Brian Salomon | cb88470 | 2018-03-19 14:01:21 -0400 | [diff] [blame] | 593 | GrBackendTexture texCopy = tex; |
| 594 | if (!validate_backend_texture(context, texCopy, &texCopy.fConfig, |
| 595 | sampleCnt, colorType, colorSpace, false)) { |
| 596 | return nullptr; |
| 597 | } |
robertphillips | 15c42ca | 2016-08-04 08:45:02 -0700 | [diff] [blame] | 598 | |
Robert Phillips | 9da87e0 | 2019-02-04 13:26:26 -0500 | [diff] [blame] | 599 | if (!SkSurface_Gpu::Valid(context->priv().caps(), texCopy.config(), colorSpace.get())) { |
Justin Novosad | 21a99d4 | 2018-07-17 16:53:43 -0400 | [diff] [blame] | 600 | return nullptr; |
| 601 | } |
| 602 | |
Brian Osman | 1105224 | 2016-10-27 14:47:55 -0400 | [diff] [blame] | 603 | sk_sp<GrRenderTargetContext> rtc( |
Robert Phillips | 9da87e0 | 2019-02-04 13:26:26 -0500 | [diff] [blame] | 604 | context->priv().makeBackendTextureAsRenderTargetRenderTargetContext( |
Brian Salomon | cb88470 | 2018-03-19 14:01:21 -0400 | [diff] [blame] | 605 | texCopy, |
| 606 | origin, |
| 607 | sampleCnt, |
| 608 | std::move(colorSpace), |
| 609 | props)); |
Brian Osman | 1105224 | 2016-10-27 14:47:55 -0400 | [diff] [blame] | 610 | if (!rtc) { |
ericrk | f7b8b8a | 2016-02-24 14:49:51 -0800 | [diff] [blame] | 611 | return nullptr; |
| 612 | } |
robertphillips | 15c42ca | 2016-08-04 08:45:02 -0700 | [diff] [blame] | 613 | |
Greg Daniel | 7ef28f3 | 2017-04-20 16:41:55 +0000 | [diff] [blame] | 614 | sk_sp<SkGpuDevice> device(SkGpuDevice::Make(context, std::move(rtc), tex.width(), tex.height(), |
robertphillips | 24e9128 | 2016-04-29 06:46:36 -0700 | [diff] [blame] | 615 | SkGpuDevice::kUninit_InitContents)); |
ericrk | f7b8b8a | 2016-02-24 14:49:51 -0800 | [diff] [blame] | 616 | if (!device) { |
| 617 | return nullptr; |
| 618 | } |
robertphillips | 24e9128 | 2016-04-29 06:46:36 -0700 | [diff] [blame] | 619 | return sk_make_sp<SkSurface_Gpu>(std::move(device)); |
ericrk | f7b8b8a | 2016-02-24 14:49:51 -0800 | [diff] [blame] | 620 | } |
| 621 | |
Greg Daniel | 173464d | 2019-02-06 15:30:34 -0500 | [diff] [blame] | 622 | #if defined(SK_BUILD_FOR_ANDROID) && __ANDROID_API__ >= 26 |
| 623 | sk_sp<SkSurface> SkSurface::MakeFromAHardwareBuffer(GrContext* context, |
| 624 | AHardwareBuffer* hardwareBuffer, |
| 625 | GrSurfaceOrigin origin, |
| 626 | sk_sp<SkColorSpace> colorSpace, |
| 627 | const SkSurfaceProps* surfaceProps) { |
| 628 | AHardwareBuffer_Desc bufferDesc; |
| 629 | AHardwareBuffer_describe(hardwareBuffer, &bufferDesc); |
| 630 | |
| 631 | if (!SkToBool(bufferDesc.usage & AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT)) { |
| 632 | return nullptr; |
| 633 | } |
| 634 | |
| 635 | bool isTextureable = SkToBool(bufferDesc.usage & AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE); |
| 636 | bool isProtectedContent = SkToBool(bufferDesc.usage & AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT); |
| 637 | |
| 638 | // We currently don't support protected content |
| 639 | if (isProtectedContent) { |
| 640 | return nullptr; |
| 641 | } |
| 642 | |
| 643 | GrBackendFormat backendFormat = GrAHardwareBufferUtils::GetBackendFormat(context, |
| 644 | hardwareBuffer, |
| 645 | bufferDesc.format, |
| 646 | true); |
| 647 | if (!backendFormat.isValid()) { |
| 648 | return nullptr; |
| 649 | } |
| 650 | |
| 651 | if (isTextureable) { |
| 652 | GrAHardwareBufferUtils::DeleteImageProc deleteImageProc = nullptr; |
| 653 | GrAHardwareBufferUtils::DeleteImageCtx deleteImageCtx = nullptr; |
| 654 | |
| 655 | GrBackendTexture backendTexture = |
| 656 | GrAHardwareBufferUtils::MakeBackendTexture(context, hardwareBuffer, |
| 657 | bufferDesc.width, bufferDesc.height, |
| 658 | &deleteImageProc, &deleteImageCtx, |
| 659 | isProtectedContent, backendFormat, |
| 660 | true); |
| 661 | if (!backendTexture.isValid()) { |
| 662 | return nullptr; |
| 663 | } |
| 664 | |
| 665 | SkColorType colorType = |
| 666 | GrAHardwareBufferUtils::GetSkColorTypeFromBufferFormat(bufferDesc.format); |
| 667 | |
Greg Daniel | b6c15ba | 2019-03-04 13:08:25 -0500 | [diff] [blame] | 668 | sk_sp<SkSurface> surface = SkSurface::MakeFromBackendTexture(context, backendTexture, |
| 669 | origin, 0, colorType, std::move(colorSpace), surfaceProps, deleteImageProc, |
| 670 | deleteImageCtx); |
| 671 | |
| 672 | if (!surface) { |
| 673 | SkASSERT(deleteImageProc); |
| 674 | deleteImageProc(deleteImageCtx); |
| 675 | } |
| 676 | return surface; |
Greg Daniel | 173464d | 2019-02-06 15:30:34 -0500 | [diff] [blame] | 677 | } else { |
| 678 | return nullptr; |
| 679 | } |
| 680 | } |
| 681 | #endif |
| 682 | |
reed | f037e0b | 2014-10-30 11:34:15 -0700 | [diff] [blame] | 683 | #endif |