1 /*
2  * Copyright 2016 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 "GrBitmapTextureMaker.h"
9 
10 #include "GrContext.h"
11 #include "GrContextPriv.h"
12 #include "GrGpuResourcePriv.h"
13 #include "GrProxyProvider.h"
14 #include "GrSurfaceContext.h"
15 #include "SkBitmap.h"
16 #include "SkGr.h"
17 #include "SkMipMap.h"
18 #include "SkPixelRef.h"
19 
bmp_is_alpha_only(const SkBitmap & bm)20 static bool bmp_is_alpha_only(const SkBitmap& bm) { return kAlpha_8_SkColorType == bm.colorType(); }
21 
GrBitmapTextureMaker(GrContext * context,const SkBitmap & bitmap)22 GrBitmapTextureMaker::GrBitmapTextureMaker(GrContext* context, const SkBitmap& bitmap)
23     : INHERITED(context, bitmap.width(), bitmap.height(), bmp_is_alpha_only(bitmap))
24     , fBitmap(bitmap) {
25     if (!bitmap.isVolatile()) {
26         SkIPoint origin = bitmap.pixelRefOrigin();
27         SkIRect subset = SkIRect::MakeXYWH(origin.fX, origin.fY, bitmap.width(),
28                                            bitmap.height());
29         GrMakeKeyFromImageID(&fOriginalKey, bitmap.pixelRef()->getGenerationID(), subset);
30     }
31 }
32 
refOriginalTextureProxy(bool willBeMipped,AllowedTexGenType onlyIfFast)33 sk_sp<GrTextureProxy> GrBitmapTextureMaker::refOriginalTextureProxy(bool willBeMipped,
34                                                                     AllowedTexGenType onlyIfFast) {
35     if (AllowedTexGenType::kCheap == onlyIfFast) {
36         return nullptr;
37     }
38 
39     GrProxyProvider* proxyProvider = this->context()->contextPriv().proxyProvider();
40     sk_sp<GrTextureProxy> proxy;
41 
42     if (fOriginalKey.isValid()) {
43         proxy = proxyProvider->findOrCreateProxyByUniqueKey(fOriginalKey, kTopLeft_GrSurfaceOrigin);
44         if (proxy && (!willBeMipped || GrMipMapped::kYes == proxy->mipMapped())) {
45             return proxy;
46         }
47     }
48 
49     if (!proxy) {
50         if (willBeMipped) {
51             proxy = proxyProvider->createMipMapProxyFromBitmap(fBitmap);
52         }
53         if (!proxy) {
54             proxy = GrUploadBitmapToTextureProxy(proxyProvider, fBitmap);
55         }
56         if (proxy) {
57             if (fOriginalKey.isValid()) {
58                 proxyProvider->assignUniqueKeyToProxy(fOriginalKey, proxy.get());
59             }
60             if (!willBeMipped || GrMipMapped::kYes == proxy->mipMapped()) {
61                 SkASSERT(proxy->origin() == kTopLeft_GrSurfaceOrigin);
62                 if (fOriginalKey.isValid()) {
63                     GrInstallBitmapUniqueKeyInvalidator(
64                             fOriginalKey, proxyProvider->contextUniqueID(), fBitmap.pixelRef());
65                 }
66                 return proxy;
67             }
68         }
69     }
70 
71     if (proxy) {
72         SkASSERT(willBeMipped);
73         SkASSERT(GrMipMapped::kNo == proxy->mipMapped());
74         // We need a mipped proxy, but we either found a proxy earlier that wasn't mipped or
75         // generated a non mipped proxy. Thus we generate a new mipped surface and copy the original
76         // proxy into the base layer. We will then let the gpu generate the rest of the mips.
77         if (auto mippedProxy = GrCopyBaseMipMapToTextureProxy(this->context(), proxy.get())) {
78             SkASSERT(mippedProxy->origin() == kTopLeft_GrSurfaceOrigin);
79             if (fOriginalKey.isValid()) {
80                 // In this case we are stealing the key from the original proxy which should only
81                 // happen when we have just generated mipmaps for an originally unmipped
82                 // proxy/texture. This means that all future uses of the key will access the
83                 // mipmapped version. The texture backing the unmipped version will remain in the
84                 // resource cache until the last texture proxy referencing it is deleted at which
85                 // time it too will be deleted or recycled.
86                 SkASSERT(proxy->getUniqueKey() == fOriginalKey);
87                 proxyProvider->removeUniqueKeyFromProxy(proxy.get());
88                 proxyProvider->assignUniqueKeyToProxy(fOriginalKey, mippedProxy.get());
89                 GrInstallBitmapUniqueKeyInvalidator(fOriginalKey, proxyProvider->contextUniqueID(),
90                                                     fBitmap.pixelRef());
91             }
92             return mippedProxy;
93         }
94         // We failed to make a mipped proxy with the base copied into it. This could have
95         // been from failure to make the proxy or failure to do the copy. Thus we will fall
96         // back to just using the non mipped proxy; See skbug.com/7094.
97         return proxy;
98     }
99     return nullptr;
100 }
101 
makeCopyKey(const CopyParams & copyParams,GrUniqueKey * copyKey)102 void GrBitmapTextureMaker::makeCopyKey(const CopyParams& copyParams, GrUniqueKey* copyKey) {
103     // Destination color space is irrelevant - we always upload the bitmap's contents as-is
104     if (fOriginalKey.isValid()) {
105         MakeCopyKeyFromOrigKey(fOriginalKey, copyParams, copyKey);
106     }
107 }
108 
didCacheCopy(const GrUniqueKey & copyKey,uint32_t contextUniqueID)109 void GrBitmapTextureMaker::didCacheCopy(const GrUniqueKey& copyKey, uint32_t contextUniqueID) {
110     GrInstallBitmapUniqueKeyInvalidator(copyKey, contextUniqueID, fBitmap.pixelRef());
111 }
112 
alphaType() const113 SkAlphaType GrBitmapTextureMaker::alphaType() const {
114     return fBitmap.alphaType();
115 }
116 
colorSpace() const117 SkColorSpace* GrBitmapTextureMaker::colorSpace() const {
118     return fBitmap.colorSpace();
119 }
120