1 /*
2  * Copyright 2011 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 "src/gpu/GrAttachment.h"
9 
10 #include "include/private/GrResourceKey.h"
11 #include "src/gpu/GrBackendUtils.h"
12 #include "src/gpu/GrCaps.h"
13 #include "src/gpu/GrDataUtils.h"
14 #include "src/gpu/GrGpu.h"
15 
onGpuMemorySize() const16 size_t GrAttachment::onGpuMemorySize() const {
17     // The GrTexture[RenderTarget] is built up by a bunch of attachments each of which are their
18     // own GrGpuResource. Ideally the GrRenderTarget would not be a GrGpuResource and the GrTexture
19     // would just merge with the new GrSurface/Attachment world. Then we could just depend on each
20     // attachment to give its own size since we don't have GrGpuResources owning other
21     // GrGpuResources. Until we get to that point we need to live in some hybrid world. We will let
22     // the msaa and stencil attachments track their own size because they do get cached separately.
23     // For all GrTexture* based things we will continue to to use the GrTexture* to report size and
24     // the owned attachments will have no size and be uncached.
25     if (!(fSupportedUsages & UsageFlags::kTexture)) {
26         GrBackendFormat format = this->backendFormat();
27         SkImage::CompressionType compression = GrBackendFormatToCompressionType(format);
28 
29         uint64_t size = GrNumBlocks(compression, this->dimensions());
30         size *= GrBackendFormatBytesPerBlock(this->backendFormat());
31         size *= this->numSamples();
32         return size;
33     }
34     return 0;
35 }
36 
build_key(GrResourceKey::Builder * builder,const GrCaps & caps,const GrBackendFormat & format,SkISize dimensions,GrAttachment::UsageFlags requiredUsage,int sampleCnt,GrMipmapped mipmapped,GrProtected isProtected)37 static void build_key(GrResourceKey::Builder* builder,
38                       const GrCaps& caps,
39                       const GrBackendFormat& format,
40                       SkISize dimensions,
41                       GrAttachment::UsageFlags requiredUsage,
42                       int sampleCnt,
43                       GrMipmapped mipmapped,
44                       GrProtected isProtected) {
45     SkASSERT(!dimensions.isEmpty());
46 
47     SkASSERT(static_cast<uint32_t>(isProtected) <= 1);
48     SkASSERT(static_cast<uint32_t>(requiredUsage) < (1u << 8));
49     SkASSERT(static_cast<uint32_t>(sampleCnt) < (1u << (32 - 9)));
50 
51     uint64_t formatKey = caps.computeFormatKey(format);
52     (*builder)[0] = dimensions.width();
53     (*builder)[1] = dimensions.height();
54     (*builder)[2] = formatKey & 0xFFFFFFFF;
55     (*builder)[3] = (formatKey >> 32) & 0xFFFFFFFF;
56     (*builder)[4] = (static_cast<uint32_t>(isProtected) << 0) |
57                     (static_cast<uint32_t>(requiredUsage) << 1) |
58                     (static_cast<uint32_t>(sampleCnt) << 9);
59 }
60 
ComputeSharedAttachmentUniqueKey(const GrCaps & caps,const GrBackendFormat & format,SkISize dimensions,UsageFlags requiredUsage,int sampleCnt,GrMipmapped mipmapped,GrProtected isProtected,GrUniqueKey * key)61 void GrAttachment::ComputeSharedAttachmentUniqueKey(const GrCaps& caps,
62                                                     const GrBackendFormat& format,
63                                                     SkISize dimensions,
64                                                     UsageFlags requiredUsage,
65                                                     int sampleCnt,
66                                                     GrMipmapped mipmapped,
67                                                     GrProtected isProtected,
68                                                     GrUniqueKey* key) {
69     static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
70 
71     GrUniqueKey::Builder builder(key, kDomain, 5);
72     build_key(&builder, caps, format, dimensions, requiredUsage, sampleCnt, mipmapped, isProtected);
73 }
74 
ComputeScratchKey(const GrCaps & caps,const GrBackendFormat & format,SkISize dimensions,UsageFlags requiredUsage,int sampleCnt,GrMipmapped mipmapped,GrProtected isProtected,GrScratchKey * key)75 void GrAttachment::ComputeScratchKey(const GrCaps& caps,
76                                      const GrBackendFormat& format,
77                                      SkISize dimensions,
78                                      UsageFlags requiredUsage,
79                                      int sampleCnt,
80                                      GrMipmapped mipmapped,
81                                      GrProtected isProtected,
82                                      GrScratchKey* key) {
83     static const GrScratchKey::ResourceType kType = GrScratchKey::GenerateResourceType();
84 
85     GrScratchKey::Builder builder(key, kType, 5);
86     build_key(&builder, caps, format, dimensions, requiredUsage, sampleCnt, mipmapped, isProtected);
87 }
88 
computeScratchKey(GrScratchKey * key) const89 void GrAttachment::computeScratchKey(GrScratchKey* key) const {
90     if (!SkToBool(fSupportedUsages & UsageFlags::kStencilAttachment)) {
91         auto isProtected = this->isProtected() ? GrProtected::kYes : GrProtected::kNo;
92         ComputeScratchKey(*this->getGpu()->caps(), this->backendFormat(), this->dimensions(),
93                           fSupportedUsages, this->numSamples(), this->mipmapped(), isProtected,
94                           key);
95     }
96 }
97