Home | History | Annotate | Download | only in gpu 
      1 /*
      2  * Copyright 2015 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 "GrImageIDTextureAdjuster.h"
      9 
     10 #include "GrContext.h"
     11 #include "GrGpuResourcePriv.h"
     12 #include "SkBitmap.h"
     13 #include "SkGrPriv.h"
     14 #include "SkImage_Base.h"
     15 #include "SkImageCacherator.h"
     16 #include "SkPixelRef.h"
     17 
     18 static bool bmp_is_alpha_only(const SkBitmap& bm) { return kAlpha_8_SkColorType == bm.colorType(); }
     19 
     20 GrBitmapTextureAdjuster::GrBitmapTextureAdjuster(const SkBitmap* bmp)
     21     : INHERITED(bmp->getTexture(),
     22                 SkIRect::MakeWH(bmp->width(), bmp->height()),
     23                 bmp_is_alpha_only(*bmp))
     24     , fBmp(bmp) {}
     25 
     26 void GrBitmapTextureAdjuster::makeCopyKey(const CopyParams& params, GrUniqueKey* copyKey) {
     27     if (fBmp->isVolatile()) {
     28         return;
     29     }
     30     // The content area must represent the whole bitmap. Texture-backed bitmaps don't support
     31     // extractSubset(). Therefore, either the bitmap and the texture are the same size or the
     32     // content's dimensions are the bitmap's dimensions which is pinned to the upper left
     33     // of the texture.
     34     GrUniqueKey baseKey;
     35     GrMakeKeyFromImageID(&baseKey, fBmp->getGenerationID(),
     36                          SkIRect::MakeWH(fBmp->width(), fBmp->height()));
     37     MakeCopyKeyFromOrigKey(baseKey, params, copyKey);
     38 }
     39 
     40 void GrBitmapTextureAdjuster::didCacheCopy(const GrUniqueKey& copyKey) {
     41     GrInstallBitmapUniqueKeyInvalidator(copyKey, fBmp->pixelRef());
     42 }
     43 
     44 //////////////////////////////////////////////////////////////////////////////
     45 
     46 // SkImage's don't have a way of communicating whether they're alpha-only. So we fallback to
     47 // inspecting the texture.
     48 static bool tex_image_is_alpha_only(const SkImage_Base& img) {
     49     return GrPixelConfigIsAlphaOnly(img.peekTexture()->config());
     50 }
     51 
     52 GrImageTextureAdjuster::GrImageTextureAdjuster(const SkImage_Base* img)
     53     : INHERITED(img->peekTexture(), SkIRect::MakeWH(img->width(), img->height()),
     54                 tex_image_is_alpha_only(*img))
     55     , fImageBase(img) {}
     56 
     57 void GrImageTextureAdjuster::makeCopyKey(const CopyParams& params, GrUniqueKey* copyKey) {
     58     // By construction this texture adjuster always represents an entire SkImage, so use the
     59     // image's width and height for the key's rectangle.
     60     GrUniqueKey baseKey;
     61     GrMakeKeyFromImageID(&baseKey, fImageBase->uniqueID(),
     62                          SkIRect::MakeWH(fImageBase->width(), fImageBase->height()));
     63     MakeCopyKeyFromOrigKey(baseKey, params, copyKey);
     64 }
     65 
     66 void GrImageTextureAdjuster::didCacheCopy(const GrUniqueKey& copyKey) {
     67     // We don't currently have a mechanism for notifications on Images!
     68 }
     69 
     70 //////////////////////////////////////////////////////////////////////////////
     71 
     72 GrBitmapTextureMaker::GrBitmapTextureMaker(GrContext* context, const SkBitmap& bitmap)
     73     : INHERITED(context, bitmap.width(), bitmap.height(), bmp_is_alpha_only(bitmap))
     74     , fBitmap(bitmap) {
     75     SkASSERT(!bitmap.getTexture());
     76     if (!bitmap.isVolatile()) {
     77         SkIPoint origin = bitmap.pixelRefOrigin();
     78         SkIRect subset = SkIRect::MakeXYWH(origin.fX, origin.fY, bitmap.width(),
     79                                            bitmap.height());
     80         GrMakeKeyFromImageID(&fOriginalKey, bitmap.pixelRef()->getGenerationID(), subset);
     81     }
     82 }
     83 
     84 GrTexture* GrBitmapTextureMaker::refOriginalTexture() {
     85     GrTexture* tex;
     86 
     87     if (fOriginalKey.isValid()) {
     88         tex = this->context()->textureProvider()->findAndRefTextureByUniqueKey(fOriginalKey);
     89         if (tex) {
     90             return tex;
     91         }
     92     }
     93 
     94     tex = GrUploadBitmapToTexture(this->context(), fBitmap);
     95     if (tex && fOriginalKey.isValid()) {
     96         tex->resourcePriv().setUniqueKey(fOriginalKey);
     97         GrInstallBitmapUniqueKeyInvalidator(fOriginalKey, fBitmap.pixelRef());
     98     }
     99     return tex;
    100 }
    101 
    102 void GrBitmapTextureMaker::makeCopyKey(const CopyParams& copyParams, GrUniqueKey* copyKey) {
    103     if (fOriginalKey.isValid()) {
    104         MakeCopyKeyFromOrigKey(fOriginalKey, copyParams, copyKey);
    105     }
    106 }
    107 
    108 void GrBitmapTextureMaker::didCacheCopy(const GrUniqueKey& copyKey) {
    109     GrInstallBitmapUniqueKeyInvalidator(copyKey, fBitmap.pixelRef());
    110 }
    111 
    112 //////////////////////////////////////////////////////////////////////////////
    113 static bool cacher_is_alpha_only(const SkImageCacherator& cacher) {
    114     return kAlpha_8_SkColorType == cacher.info().colorType();
    115 }
    116 GrImageTextureMaker::GrImageTextureMaker(GrContext* context, SkImageCacherator* cacher,
    117                                          const SkImage* client, SkImage::CachingHint chint)
    118     : INHERITED(context, cacher->info().width(), cacher->info().height(),
    119                 cacher_is_alpha_only(*cacher))
    120     , fCacher(cacher)
    121     , fClient(client)
    122     , fCachingHint(chint) {
    123     if (client) {
    124         GrMakeKeyFromImageID(&fOriginalKey, client->uniqueID(),
    125                              SkIRect::MakeWH(this->width(), this->height()));
    126     }
    127 }
    128 
    129 GrTexture* GrImageTextureMaker::refOriginalTexture() {
    130     return fCacher->lockTexture(this->context(), fOriginalKey, fClient, fCachingHint);
    131 }
    132 
    133 void GrImageTextureMaker::makeCopyKey(const CopyParams& stretch, GrUniqueKey* paramsCopyKey) {
    134     if (fOriginalKey.isValid() && SkImage::kAllow_CachingHint == fCachingHint) {
    135         MakeCopyKeyFromOrigKey(fOriginalKey, stretch, paramsCopyKey);
    136     }
    137 }
    138 
    139 void GrImageTextureMaker::didCacheCopy(const GrUniqueKey& copyKey) {
    140     if (fClient) {
    141         as_IB(fClient)->notifyAddedToCache();
    142     }
    143 }
    144