1 2 /* 3 * Copyright 2010 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. 7 */ 8 9 10 11 #include "SkGrPixelRef.h" 12 13 #include "GrContext.h" 14 #include "GrTexture.h" 15 #include "GrTexturePriv.h" 16 #include "SkBitmapCache.h" 17 #include "SkGr.h" 18 #include "SkRect.h" 19 20 SkROLockPixelsPixelRef::SkROLockPixelsPixelRef(const SkImageInfo& info) 21 : INHERITED(info) {} 22 23 SkROLockPixelsPixelRef::~SkROLockPixelsPixelRef() {} 24 25 bool SkROLockPixelsPixelRef::onNewLockPixels(LockRec* rec) { 26 fBitmap.reset(); 27 // SkDebugf("---------- calling readpixels in support of lockpixels\n"); 28 if (!this->onReadPixels(&fBitmap, this->info().colorType(), nullptr)) { 29 SkDebugf("SkROLockPixelsPixelRef::onLockPixels failed!\n"); 30 return false; 31 } 32 fBitmap.lockPixels(); 33 if (nullptr == fBitmap.getPixels()) { 34 return false; 35 } 36 37 rec->fPixels = fBitmap.getPixels(); 38 rec->fColorTable = nullptr; 39 rec->fRowBytes = fBitmap.rowBytes(); 40 return true; 41 } 42 43 void SkROLockPixelsPixelRef::onUnlockPixels() { 44 fBitmap.unlockPixels(); 45 } 46 47 bool SkROLockPixelsPixelRef::onLockPixelsAreWritable() const { 48 return false; 49 } 50 51 /////////////////////////////////////////////////////////////////////////////// 52 53 static SkGrPixelRef* copy_to_new_texture_pixelref(GrTexture* texture, SkColorType dstCT, 54 SkColorProfileType dstPT, const SkIRect* subset) { 55 if (nullptr == texture || kUnknown_SkColorType == dstCT) { 56 return nullptr; 57 } 58 GrContext* context = texture->getContext(); 59 if (nullptr == context) { 60 return nullptr; 61 } 62 GrSurfaceDesc desc; 63 64 SkIRect srcRect; 65 66 if (!subset) { 67 desc.fWidth = texture->width(); 68 desc.fHeight = texture->height(); 69 srcRect = SkIRect::MakeWH(texture->width(), texture->height()); 70 } else { 71 SkASSERT(SkIRect::MakeWH(texture->width(), texture->height()).contains(*subset)); 72 // Create a new texture that is the size of subset. 73 desc.fWidth = subset->width(); 74 desc.fHeight = subset->height(); 75 srcRect = *subset; 76 } 77 desc.fFlags = kRenderTarget_GrSurfaceFlag; 78 desc.fConfig = SkImageInfo2GrPixelConfig(dstCT, kPremul_SkAlphaType, dstPT); 79 desc.fTextureStorageAllocator = texture->desc().fTextureStorageAllocator; 80 81 GrTexture* dst = context->textureProvider()->createTexture(desc, SkBudgeted::kNo, nullptr, 0); 82 if (nullptr == dst) { 83 return nullptr; 84 } 85 86 // Blink is relying on the above copy being sent to GL immediately in the case when the source 87 // is a WebGL canvas backing store. We could have a TODO to remove this flush, but we have 88 // a larger TODO to remove SkGrPixelRef entirely. 89 context->copySurface(dst, texture, srcRect, SkIPoint::Make(0,0)); 90 context->flushSurfaceWrites(dst); 91 92 SkImageInfo info = SkImageInfo::Make(desc.fWidth, desc.fHeight, dstCT, kPremul_SkAlphaType, 93 dstPT); 94 SkGrPixelRef* pixelRef = new SkGrPixelRef(info, dst); 95 SkSafeUnref(dst); 96 return pixelRef; 97 } 98 99 /////////////////////////////////////////////////////////////////////////////// 100 101 SkGrPixelRef::SkGrPixelRef(const SkImageInfo& info, GrSurface* surface) : INHERITED(info) { 102 // For surfaces that are both textures and render targets, the texture owns the 103 // render target but not vice versa. So we ref the texture to keep both alive for 104 // the lifetime of this pixel ref. 105 fSurface = SkSafeRef(surface->asTexture()); 106 if (nullptr == fSurface) { 107 fSurface = SkSafeRef(surface); 108 } 109 110 if (fSurface) { 111 SkASSERT(info.width() <= fSurface->width()); 112 SkASSERT(info.height() <= fSurface->height()); 113 } 114 } 115 116 SkGrPixelRef::~SkGrPixelRef() { 117 SkSafeUnref(fSurface); 118 } 119 120 GrTexture* SkGrPixelRef::getTexture() { 121 if (fSurface) { 122 return fSurface->asTexture(); 123 } 124 return nullptr; 125 } 126 127 void SkGrPixelRef::onNotifyPixelsChanged() { 128 GrTexture* texture = this->getTexture(); 129 if (texture) { 130 texture->texturePriv().dirtyMipMaps(true); 131 } 132 } 133 134 SkPixelRef* SkGrPixelRef::deepCopy(SkColorType dstCT, SkColorProfileType dstPT, 135 const SkIRect* subset) { 136 if (nullptr == fSurface) { 137 return nullptr; 138 } 139 140 // Note that when copying a render-target-backed pixel ref, we 141 // return a texture-backed pixel ref instead. This is because 142 // render-target pixel refs are usually created in conjunction with 143 // a GrTexture owned elsewhere (e.g., SkGpuDevice), and cannot live 144 // independently of that texture. Texture-backed pixel refs, on the other 145 // hand, own their GrTextures, and are thus self-contained. 146 return copy_to_new_texture_pixelref(fSurface->asTexture(), dstCT, dstPT, subset); 147 } 148 149 static bool tryAllocBitmapPixels(SkBitmap* bitmap) { 150 SkBitmap::Allocator* allocator = SkBitmapCache::GetAllocator(); 151 if (nullptr != allocator) { 152 return allocator->allocPixelRef(bitmap, 0); 153 } else { 154 // DiscardableMemory is not available, fallback to default allocator 155 return bitmap->tryAllocPixels(); 156 } 157 } 158 159 bool SkGrPixelRef::onReadPixels(SkBitmap* dst, SkColorType colorType, const SkIRect* subset) { 160 if (nullptr == fSurface || fSurface->wasDestroyed()) { 161 return false; 162 } 163 164 GrPixelConfig config; 165 if (kRGBA_8888_SkColorType == colorType) { 166 config = kRGBA_8888_GrPixelConfig; 167 } else if (kBGRA_8888_SkColorType == colorType) { 168 config = kBGRA_8888_GrPixelConfig; 169 } else { 170 return false; 171 } 172 173 SkIRect bounds; 174 if (subset) { 175 bounds = *subset; 176 } else { 177 bounds = SkIRect::MakeWH(this->info().width(), this->info().height()); 178 } 179 180 //Check the cache 181 if(!SkBitmapCache::Find(this->getGenerationID(), bounds, dst)) { 182 //Cache miss 183 184 SkBitmap cachedBitmap; 185 cachedBitmap.setInfo(SkImageInfo::Make(bounds.width(), bounds.height(), colorType, 186 this->info().alphaType(), 187 this->info().profileType())); 188 189 // If we can't alloc the pixels, then fail 190 if (!tryAllocBitmapPixels(&cachedBitmap)) { 191 return false; 192 } 193 194 // Try to read the pixels from the surface 195 void* buffer = cachedBitmap.getPixels(); 196 bool readPixelsOk = fSurface->readPixels(bounds.fLeft, bounds.fTop, 197 bounds.width(), bounds.height(), 198 config, buffer, cachedBitmap.rowBytes()); 199 200 if (!readPixelsOk) { 201 return false; 202 } 203 204 // If we are here, pixels were read correctly from the surface. 205 cachedBitmap.setImmutable(); 206 //Add to the cache 207 SkBitmapCache::Add(this, bounds, cachedBitmap); 208 209 dst->swap(cachedBitmap); 210 } 211 212 return true; 213 214 } 215
