epoger@google.com | ec3ed6a | 2011-07-28 14:26:00 +0000 | [diff] [blame] | 1 | |
bsalomon@google.com | 669fdc4 | 2011-04-05 17:08:27 +0000 | [diff] [blame] | 2 | /* |
epoger@google.com | ec3ed6a | 2011-07-28 14:26:00 +0000 | [diff] [blame] | 3 | * Copyright 2011 Google Inc. |
| 4 | * |
| 5 | * Use of this source code is governed by a BSD-style license that can be |
| 6 | * found in the LICENSE file. |
bsalomon@google.com | 669fdc4 | 2011-04-05 17:08:27 +0000 | [diff] [blame] | 7 | */ |
| 8 | |
epoger@google.com | ec3ed6a | 2011-07-28 14:26:00 +0000 | [diff] [blame] | 9 | |
bsalomon@google.com | 669fdc4 | 2011-04-05 17:08:27 +0000 | [diff] [blame] | 10 | #include "GrTexture.h" |
bsalomon@google.com | aa5b673 | 2011-07-29 15:13:20 +0000 | [diff] [blame] | 11 | |
bsalomon@google.com | 669fdc4 | 2011-04-05 17:08:27 +0000 | [diff] [blame] | 12 | #include "GrContext.h" |
bsalomon@google.com | c26d94f | 2013-03-25 18:19:00 +0000 | [diff] [blame] | 13 | #include "GrDrawTargetCaps.h" |
bsalomon@google.com | 05ef510 | 2011-05-02 21:14:59 +0000 | [diff] [blame] | 14 | #include "GrGpu.h" |
bsalomon@google.com | aa5b673 | 2011-07-29 15:13:20 +0000 | [diff] [blame] | 15 | #include "GrRenderTarget.h" |
robertphillips@google.com | a1e5795 | 2012-06-04 20:05:28 +0000 | [diff] [blame] | 16 | #include "GrResourceCache.h" |
bsalomon@google.com | 8295dc1 | 2011-05-02 12:53:34 +0000 | [diff] [blame] | 17 | |
bsalomon@google.com | 686bcb8 | 2013-04-09 15:04:12 +0000 | [diff] [blame] | 18 | GrTexture::~GrTexture() { |
| 19 | if (NULL != fRenderTarget.get()) { |
| 20 | fRenderTarget.get()->owningTextureDestroyed(); |
| 21 | } |
| 22 | } |
| 23 | |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 24 | /** |
robertphillips@google.com | 15c0fea | 2012-06-22 12:41:43 +0000 | [diff] [blame] | 25 | * This method allows us to interrupt the normal deletion process and place |
| 26 | * textures back in the texture cache when their ref count goes to zero. |
| 27 | */ |
| 28 | void GrTexture::internal_dispose() const { |
commit-bot@chromium.org | e49157f | 2014-05-09 20:46:48 +0000 | [diff] [blame] | 29 | if (this->impl()->isSetFlag((GrTextureFlags) GrTextureImpl::kReturnToCache_FlagBit) && |
robertphillips@google.com | 15c0fea | 2012-06-22 12:41:43 +0000 | [diff] [blame] | 30 | NULL != this->INHERITED::getContext()) { |
| 31 | GrTexture* nonConstThis = const_cast<GrTexture *>(this); |
| 32 | this->fRefCnt = 1; // restore ref count to initial setting |
| 33 | |
commit-bot@chromium.org | e49157f | 2014-05-09 20:46:48 +0000 | [diff] [blame] | 34 | nonConstThis->impl()->resetFlag((GrTextureFlags) GrTextureImpl::kReturnToCache_FlagBit); |
robertphillips@google.com | 15c0fea | 2012-06-22 12:41:43 +0000 | [diff] [blame] | 35 | nonConstThis->INHERITED::getContext()->addExistingTextureToCache(nonConstThis); |
| 36 | |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 37 | // Note: "this" texture might be freed inside addExistingTextureToCache |
robertphillips@google.com | f41f4d2 | 2012-06-25 17:26:29 +0000 | [diff] [blame] | 38 | // if it is purged. |
robertphillips@google.com | 15c0fea | 2012-06-22 12:41:43 +0000 | [diff] [blame] | 39 | return; |
| 40 | } |
| 41 | |
robertphillips@google.com | 0255a5d | 2013-10-24 14:03:01 +0000 | [diff] [blame] | 42 | SkASSERT(0 == this->getDeferredRefCount()); |
robertphillips@google.com | 15c0fea | 2012-06-22 12:41:43 +0000 | [diff] [blame] | 43 | this->INHERITED::internal_dispose(); |
| 44 | } |
| 45 | |
commit-bot@chromium.org | e49157f | 2014-05-09 20:46:48 +0000 | [diff] [blame] | 46 | void GrTextureImpl::dirtyMipMaps(bool mipMapsDirty) { |
commit-bot@chromium.org | 11c6b39 | 2014-05-05 19:09:13 +0000 | [diff] [blame] | 47 | if (mipMapsDirty) { |
| 48 | if (kValid_MipMapsStatus == fMipMapsStatus) { |
| 49 | fMipMapsStatus = kAllocated_MipMapsStatus; |
| 50 | } |
| 51 | } else { |
| 52 | const bool sizeChanged = kNotAllocated_MipMapsStatus == fMipMapsStatus; |
| 53 | fMipMapsStatus = kValid_MipMapsStatus; |
| 54 | if (sizeChanged) { |
| 55 | // This must not be called until after changing fMipMapsStatus. |
| 56 | this->didChangeGpuMemorySize(); |
| 57 | } |
| 58 | } |
| 59 | } |
| 60 | |
| 61 | size_t GrTexture::gpuMemorySize() const { |
| 62 | size_t textureSize = (size_t) fDesc.fWidth * |
| 63 | fDesc.fHeight * |
| 64 | GrBytesPerPixel(fDesc.fConfig); |
commit-bot@chromium.org | 6e7ddaa | 2014-05-30 13:55:58 +0000 | [diff] [blame] | 65 | |
| 66 | if (GrPixelConfigIsCompressed(fDesc.fConfig)) { |
| 67 | // Figure out the width and height corresponding to the data... |
| 68 | |
| 69 | // Both of the available formats (ETC1 and LATC) have 4x4 |
| 70 | // blocks that compress down to 8 bytes. |
| 71 | switch(fDesc.fConfig) { |
| 72 | case kETC1_GrPixelConfig: |
| 73 | case kLATC_GrPixelConfig: |
| 74 | SkASSERT((fDesc.fWidth & 3) == 0); |
| 75 | SkASSERT((fDesc.fHeight & 3) == 0); |
| 76 | textureSize = (fDesc.fWidth >> 2) * (fDesc.fHeight >> 2) * 8; |
| 77 | break; |
| 78 | |
| 79 | default: |
| 80 | SkFAIL("Unknown compressed config"); |
| 81 | } |
| 82 | } |
| 83 | |
commit-bot@chromium.org | e49157f | 2014-05-09 20:46:48 +0000 | [diff] [blame] | 84 | if (this->impl()->hasMipMaps()) { |
commit-bot@chromium.org | 11c6b39 | 2014-05-05 19:09:13 +0000 | [diff] [blame] | 85 | // We don't have to worry about the mipmaps being a different size than |
| 86 | // we'd expect because we never change fDesc.fWidth/fHeight. |
| 87 | textureSize *= 2; |
| 88 | } |
| 89 | return textureSize; |
| 90 | } |
| 91 | |
bsalomon@google.com | 669fdc4 | 2011-04-05 17:08:27 +0000 | [diff] [blame] | 92 | bool GrTexture::readPixels(int left, int top, int width, int height, |
bsalomon@google.com | 6f37951 | 2011-11-16 20:36:03 +0000 | [diff] [blame] | 93 | GrPixelConfig config, void* buffer, |
bsalomon@google.com | 0342a85 | 2012-08-20 19:22:38 +0000 | [diff] [blame] | 94 | size_t rowBytes, uint32_t pixelOpsFlags) { |
bsalomon@google.com | 669fdc4 | 2011-04-05 17:08:27 +0000 | [diff] [blame] | 95 | // go through context so that all necessary flushing occurs |
bsalomon@google.com | 6f37951 | 2011-11-16 20:36:03 +0000 | [diff] [blame] | 96 | GrContext* context = this->getContext(); |
| 97 | if (NULL == context) { |
| 98 | return false; |
| 99 | } |
bsalomon@google.com | 669fdc4 | 2011-04-05 17:08:27 +0000 | [diff] [blame] | 100 | return context->readTexturePixels(this, |
bsalomon@google.com | 0342a85 | 2012-08-20 19:22:38 +0000 | [diff] [blame] | 101 | left, top, width, height, |
| 102 | config, buffer, rowBytes, |
| 103 | pixelOpsFlags); |
bsalomon@google.com | 6f37951 | 2011-11-16 20:36:03 +0000 | [diff] [blame] | 104 | } |
| 105 | |
| 106 | void GrTexture::writePixels(int left, int top, int width, int height, |
| 107 | GrPixelConfig config, const void* buffer, |
bsalomon@google.com | 0342a85 | 2012-08-20 19:22:38 +0000 | [diff] [blame] | 108 | size_t rowBytes, uint32_t pixelOpsFlags) { |
bsalomon@google.com | 6f37951 | 2011-11-16 20:36:03 +0000 | [diff] [blame] | 109 | // go through context so that all necessary flushing occurs |
| 110 | GrContext* context = this->getContext(); |
| 111 | if (NULL == context) { |
| 112 | return; |
| 113 | } |
| 114 | context->writeTexturePixels(this, |
bsalomon@google.com | 0342a85 | 2012-08-20 19:22:38 +0000 | [diff] [blame] | 115 | left, top, width, height, |
| 116 | config, buffer, rowBytes, |
| 117 | pixelOpsFlags); |
bsalomon@google.com | 669fdc4 | 2011-04-05 17:08:27 +0000 | [diff] [blame] | 118 | } |
bsalomon@google.com | cee661a | 2011-07-26 12:32:36 +0000 | [diff] [blame] | 119 | |
robertphillips@google.com | 15c0fea | 2012-06-22 12:41:43 +0000 | [diff] [blame] | 120 | void GrTexture::onRelease() { |
commit-bot@chromium.org | e49157f | 2014-05-09 20:46:48 +0000 | [diff] [blame] | 121 | SkASSERT(!this->impl()->isSetFlag((GrTextureFlags) GrTextureImpl::kReturnToCache_FlagBit)); |
robertphillips@google.com | d364554 | 2012-09-05 18:37:39 +0000 | [diff] [blame] | 122 | INHERITED::onRelease(); |
robertphillips@google.com | 15c0fea | 2012-06-22 12:41:43 +0000 | [diff] [blame] | 123 | } |
| 124 | |
bsalomon@google.com | aa5b673 | 2011-07-29 15:13:20 +0000 | [diff] [blame] | 125 | void GrTexture::onAbandon() { |
bsalomon@google.com | 686bcb8 | 2013-04-09 15:04:12 +0000 | [diff] [blame] | 126 | if (NULL != fRenderTarget.get()) { |
bsalomon@google.com | aa5b673 | 2011-07-29 15:13:20 +0000 | [diff] [blame] | 127 | fRenderTarget->abandon(); |
| 128 | } |
robertphillips@google.com | d364554 | 2012-09-05 18:37:39 +0000 | [diff] [blame] | 129 | INHERITED::onAbandon(); |
bsalomon@google.com | aa5b673 | 2011-07-29 15:13:20 +0000 | [diff] [blame] | 130 | } |
| 131 | |
robertphillips@google.com | 3271628 | 2012-06-04 12:48:45 +0000 | [diff] [blame] | 132 | void GrTexture::validateDesc() const { |
| 133 | if (NULL != this->asRenderTarget()) { |
| 134 | // This texture has a render target |
tfarina@chromium.org | f6de475 | 2013-08-17 00:02:59 +0000 | [diff] [blame] | 135 | SkASSERT(0 != (fDesc.fFlags & kRenderTarget_GrTextureFlagBit)); |
robertphillips@google.com | 3271628 | 2012-06-04 12:48:45 +0000 | [diff] [blame] | 136 | |
| 137 | if (NULL != this->asRenderTarget()->getStencilBuffer()) { |
tfarina@chromium.org | f6de475 | 2013-08-17 00:02:59 +0000 | [diff] [blame] | 138 | SkASSERT(0 != (fDesc.fFlags & kNoStencil_GrTextureFlagBit)); |
robertphillips@google.com | 3271628 | 2012-06-04 12:48:45 +0000 | [diff] [blame] | 139 | } else { |
tfarina@chromium.org | f6de475 | 2013-08-17 00:02:59 +0000 | [diff] [blame] | 140 | SkASSERT(0 == (fDesc.fFlags & kNoStencil_GrTextureFlagBit)); |
robertphillips@google.com | 3271628 | 2012-06-04 12:48:45 +0000 | [diff] [blame] | 141 | } |
| 142 | |
tfarina@chromium.org | f6de475 | 2013-08-17 00:02:59 +0000 | [diff] [blame] | 143 | SkASSERT(fDesc.fSampleCnt == this->asRenderTarget()->numSamples()); |
robertphillips@google.com | 3271628 | 2012-06-04 12:48:45 +0000 | [diff] [blame] | 144 | } else { |
tfarina@chromium.org | f6de475 | 2013-08-17 00:02:59 +0000 | [diff] [blame] | 145 | SkASSERT(0 == (fDesc.fFlags & kRenderTarget_GrTextureFlagBit)); |
| 146 | SkASSERT(0 == (fDesc.fFlags & kNoStencil_GrTextureFlagBit)); |
| 147 | SkASSERT(0 == fDesc.fSampleCnt); |
robertphillips@google.com | 3271628 | 2012-06-04 12:48:45 +0000 | [diff] [blame] | 148 | } |
| 149 | } |
robertphillips@google.com | a1e5795 | 2012-06-04 20:05:28 +0000 | [diff] [blame] | 150 | |
commit-bot@chromium.org | e49157f | 2014-05-09 20:46:48 +0000 | [diff] [blame] | 151 | ////////////////////////////////////////////////////////////////////////////// |
| 152 | |
bsalomon@google.com | 0797c2c | 2012-12-20 15:13:01 +0000 | [diff] [blame] | 153 | // These flags need to fit in a GrResourceKey::ResourceFlags so they can be folded into the texture |
robertphillips@google.com | 46a8600 | 2012-08-08 10:42:44 +0000 | [diff] [blame] | 154 | // key |
bsalomon@google.com | 0797c2c | 2012-12-20 15:13:01 +0000 | [diff] [blame] | 155 | enum TextureFlags { |
| 156 | /** |
| 157 | * The kStretchToPOT bit is set when the texture is NPOT and is being repeated but the |
| 158 | * hardware doesn't support that feature. |
robertphillips@google.com | a1e5795 | 2012-06-04 20:05:28 +0000 | [diff] [blame] | 159 | */ |
bsalomon@google.com | 0797c2c | 2012-12-20 15:13:01 +0000 | [diff] [blame] | 160 | kStretchToPOT_TextureFlag = 0x1, |
| 161 | /** |
humper@google.com | b86add1 | 2013-07-25 18:49:07 +0000 | [diff] [blame] | 162 | * The kBilerp bit can only be set when the kStretchToPOT flag is set and indicates whether the |
| 163 | * stretched texture should be bilerped. |
robertphillips@google.com | a1e5795 | 2012-06-04 20:05:28 +0000 | [diff] [blame] | 164 | */ |
humper@google.com | b86add1 | 2013-07-25 18:49:07 +0000 | [diff] [blame] | 165 | kBilerp_TextureFlag = 0x2, |
robertphillips@google.com | a1e5795 | 2012-06-04 20:05:28 +0000 | [diff] [blame] | 166 | }; |
| 167 | |
| 168 | namespace { |
bsalomon@google.com | 0797c2c | 2012-12-20 15:13:01 +0000 | [diff] [blame] | 169 | GrResourceKey::ResourceFlags get_texture_flags(const GrGpu* gpu, |
| 170 | const GrTextureParams* params, |
| 171 | const GrTextureDesc& desc) { |
| 172 | GrResourceKey::ResourceFlags flags = 0; |
| 173 | bool tiled = NULL != params && params->isTiled(); |
bsalomon@google.com | bcce892 | 2013-03-25 15:38:39 +0000 | [diff] [blame] | 174 | if (tiled && !gpu->caps()->npotTextureTileSupport()) { |
tfarina | f9dae78 | 2014-06-06 06:35:28 -0700 | [diff] [blame^] | 175 | if (!SkIsPow2(desc.fWidth) || !SkIsPow2(desc.fHeight)) { |
bsalomon@google.com | 0797c2c | 2012-12-20 15:13:01 +0000 | [diff] [blame] | 176 | flags |= kStretchToPOT_TextureFlag; |
humper@google.com | b86add1 | 2013-07-25 18:49:07 +0000 | [diff] [blame] | 177 | switch(params->filterMode()) { |
| 178 | case GrTextureParams::kNone_FilterMode: |
| 179 | break; |
| 180 | case GrTextureParams::kBilerp_FilterMode: |
| 181 | case GrTextureParams::kMipMap_FilterMode: |
| 182 | flags |= kBilerp_TextureFlag; |
| 183 | break; |
robertphillips@google.com | a1e5795 | 2012-06-04 20:05:28 +0000 | [diff] [blame] | 184 | } |
| 185 | } |
| 186 | } |
bsalomon@google.com | 0797c2c | 2012-12-20 15:13:01 +0000 | [diff] [blame] | 187 | return flags; |
| 188 | } |
robertphillips@google.com | a1e5795 | 2012-06-04 20:05:28 +0000 | [diff] [blame] | 189 | |
bsalomon@google.com | 0797c2c | 2012-12-20 15:13:01 +0000 | [diff] [blame] | 190 | GrResourceKey::ResourceType texture_resource_type() { |
| 191 | static const GrResourceKey::ResourceType gType = GrResourceKey::GenerateResourceType(); |
| 192 | return gType; |
robertphillips@google.com | a1e5795 | 2012-06-04 20:05:28 +0000 | [diff] [blame] | 193 | } |
senorblanco@chromium.org | 709906b | 2013-02-07 00:35:25 +0000 | [diff] [blame] | 194 | |
| 195 | // FIXME: This should be refactored with the code in gl/GrGpuGL.cpp. |
| 196 | GrSurfaceOrigin resolve_origin(const GrTextureDesc& desc) { |
| 197 | // By default, GrRenderTargets are GL's normal orientation so that they |
| 198 | // can be drawn to by the outside world without the client having |
| 199 | // to render upside down. |
| 200 | bool renderTarget = 0 != (desc.fFlags & kRenderTarget_GrTextureFlagBit); |
| 201 | if (kDefault_GrSurfaceOrigin == desc.fOrigin) { |
| 202 | return renderTarget ? kBottomLeft_GrSurfaceOrigin : kTopLeft_GrSurfaceOrigin; |
| 203 | } else { |
| 204 | return desc.fOrigin; |
| 205 | } |
| 206 | } |
robertphillips@google.com | a1e5795 | 2012-06-04 20:05:28 +0000 | [diff] [blame] | 207 | } |
| 208 | |
commit-bot@chromium.org | e49157f | 2014-05-09 20:46:48 +0000 | [diff] [blame] | 209 | ////////////////////////////////////////////////////////////////////////////// |
| 210 | |
| 211 | GrResourceKey GrTextureImpl::ComputeKey(const GrGpu* gpu, |
bsalomon@google.com | b867099 | 2012-07-25 21:27:09 +0000 | [diff] [blame] | 212 | const GrTextureParams* params, |
robertphillips@google.com | a1e5795 | 2012-06-04 20:05:28 +0000 | [diff] [blame] | 213 | const GrTextureDesc& desc, |
bsalomon@google.com | 0797c2c | 2012-12-20 15:13:01 +0000 | [diff] [blame] | 214 | const GrCacheID& cacheID) { |
| 215 | GrResourceKey::ResourceFlags flags = get_texture_flags(gpu, params, desc); |
| 216 | return GrResourceKey(cacheID, texture_resource_type(), flags); |
| 217 | } |
robertphillips@google.com | 46a8600 | 2012-08-08 10:42:44 +0000 | [diff] [blame] | 218 | |
commit-bot@chromium.org | e49157f | 2014-05-09 20:46:48 +0000 | [diff] [blame] | 219 | GrResourceKey GrTextureImpl::ComputeScratchKey(const GrTextureDesc& desc) { |
bsalomon@google.com | 0797c2c | 2012-12-20 15:13:01 +0000 | [diff] [blame] | 220 | GrCacheID::Key idKey; |
| 221 | // Instead of a client-provided key of the texture contents we create a key from the |
| 222 | // descriptor. |
senorblanco@chromium.org | 3cb406b | 2013-02-05 19:50:46 +0000 | [diff] [blame] | 223 | GR_STATIC_ASSERT(sizeof(idKey) >= 16); |
tfarina@chromium.org | f6de475 | 2013-08-17 00:02:59 +0000 | [diff] [blame] | 224 | SkASSERT(desc.fHeight < (1 << 16)); |
| 225 | SkASSERT(desc.fWidth < (1 << 16)); |
bsalomon@google.com | 0797c2c | 2012-12-20 15:13:01 +0000 | [diff] [blame] | 226 | idKey.fData32[0] = (desc.fWidth) | (desc.fHeight << 16); |
| 227 | idKey.fData32[1] = desc.fConfig | desc.fSampleCnt << 16; |
| 228 | idKey.fData32[2] = desc.fFlags; |
senorblanco@chromium.org | 709906b | 2013-02-07 00:35:25 +0000 | [diff] [blame] | 229 | idKey.fData32[3] = resolve_origin(desc); // Only needs 2 bits actually |
senorblanco@chromium.org | 3cb406b | 2013-02-05 19:50:46 +0000 | [diff] [blame] | 230 | static const int kPadSize = sizeof(idKey) - 16; |
| 231 | GR_STATIC_ASSERT(kPadSize >= 0); |
| 232 | memset(idKey.fData8 + 16, 0, kPadSize); |
bsalomon@google.com | 0797c2c | 2012-12-20 15:13:01 +0000 | [diff] [blame] | 233 | |
| 234 | GrCacheID cacheID(GrResourceKey::ScratchDomain(), idKey); |
| 235 | return GrResourceKey(cacheID, texture_resource_type(), 0); |
robertphillips@google.com | a1e5795 | 2012-06-04 20:05:28 +0000 | [diff] [blame] | 236 | } |
| 237 | |
commit-bot@chromium.org | e49157f | 2014-05-09 20:46:48 +0000 | [diff] [blame] | 238 | bool GrTextureImpl::NeedsResizing(const GrResourceKey& key) { |
bsalomon@google.com | 0797c2c | 2012-12-20 15:13:01 +0000 | [diff] [blame] | 239 | return SkToBool(key.getResourceFlags() & kStretchToPOT_TextureFlag); |
robertphillips@google.com | a1e5795 | 2012-06-04 20:05:28 +0000 | [diff] [blame] | 240 | } |
| 241 | |
commit-bot@chromium.org | e49157f | 2014-05-09 20:46:48 +0000 | [diff] [blame] | 242 | bool GrTextureImpl::NeedsBilerp(const GrResourceKey& key) { |
humper@google.com | b86add1 | 2013-07-25 18:49:07 +0000 | [diff] [blame] | 243 | return SkToBool(key.getResourceFlags() & kBilerp_TextureFlag); |
robertphillips@google.com | a1e5795 | 2012-06-04 20:05:28 +0000 | [diff] [blame] | 244 | } |