try texture-maker to generalize stretching for npot and min-tex-size

src/gpu/SkGr.cpp

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkGr.h"
 
 #include "GrCaps.h"
@@ skipping 485 matching lines @@
             break;
         case Stretch::kNone_Type:
             SkDEBUGFAIL("Shouldn't get here.");
             break;
     }
     SkRect dstRect = SkRect::MakeWH(SkIntToScalar(stretch.fWidth), SkIntToScalar(stretch.fHeight));
     canvas.drawBitmapRect(bmp, dstRect, &paint);
     return stretched;
 }
 
-static GrTexture* create_bitmap_texture(GrContext* ctx,
-                                        const SkBitmap& bmp,
-                                        const Stretch& stretch,
-                                        const GrUniqueKey& unstretchedKey,
-                                        const GrUniqueKey& stretchedKey) {
-    if (Stretch::kNone_Type != stretch.fType) {
-        SkAutoTUnref<GrTexture> unstretched;
-        // Check if we have the unstretched version in the cache, if not create it.
-        if (unstretchedKey.isValid()) {
-            unstretched.reset(ctx->textureProvider()->findAndRefTextureByUniqueKey(unstretchedKey));
-        }
-        if (!unstretched) {
-            unstretched.reset(create_unstretched_bitmap_texture(ctx, bmp, unstretchedKey));
-            if (!unstretched) {
-                // We might not have been able to create a unstrecthed texture because it is smaller
-                // than the min texture size. In that case do cpu stretching.
-                SkBitmap stretchedBmp = stretch_on_cpu(bmp, stretch);
-                return create_unstretched_bitmap_texture(ctx, stretchedBmp, stretchedKey);
-            }
-        }
-        return stretch_texture(unstretched, stretch, bmp.pixelRef(), stretchedKey);
-    }
-    return create_unstretched_bitmap_texture(ctx, bmp, unstretchedKey);
-}
-
 bool GrIsImageInCache(const GrContext* ctx, uint32_t imageID, const SkIRect& subset,
                       GrTexture* nativeTexture, const GrTextureParams* params) {
     Stretch stretch;
     get_stretch(ctx, subset.width(), subset.height(), params, &stretch);
 
     // Handle the case where the bitmap/image is explicitly texture backed.
     if (nativeTexture) {
         if (Stretch::kNone_Type == stretch.fType) {
             return true;
         }
@@ skipping 14 matching lines @@
 
 bool GrIsBitmapInCache(const GrContext* ctx, const SkBitmap& bitmap,
                        const GrTextureParams* params) {
     if (bitmap.isVolatile()) {
         return false;   // we don't cache volatile bitmaps.
     }
     return GrIsImageInCache(ctx, bitmap.getGenerationID(), bitmap.getSubset(), bitmap.getTexture(),
                             params);
 }
 
-GrTexture* GrRefCachedBitmapTexture(GrContext* ctx,
-                                    const SkBitmap& bitmap,
-                                    const GrTextureParams* params) {
+class GrTextureMaker {

[bsalomon, 2015/09/29 13:23:24]

Is this going to be exposed outside of this cpp? Just curious.

[reed1, 2015/09/29 17:41:17]

Not sure, but likely (for generators, etc.) so I will move to a header.

+public:
+    GrTextureMaker(int width, int height) : fWidth(width), fHeight(height) {}
 
+    int width() const { return fWidth; }
+    int height() const { return fHeight; }
+
+    GrTexture* refCachedTexture(GrContext*, const GrTextureParams*);
+
+protected:
+    virtual GrTexture* peekTexture() = 0;

[bsalomon, 2015/09/29 13:23:24]

wonder about all these virtuals... this guy can get called with high frequency,
e.g. a client loop on drawBitmapRect().

What if the class had a field for the cache key that the subclass constructor
initialized (or not if say its volatile). Might remove the need for
isVolatile(), imageID(), and subset(). notifyCachedStretchCached(),
onRefCachedTexture(), and getROBitmap() should be really rare, so not worried
about that.

I think it's true (and worthy of comment) that it's ok for getROBitmap() to fail
if peekTexture() returns a non-null texture.

[reed1, 2015/09/29 17:41:17]

Agree to all concerns. Will start with trying to return an entire key

+    virtual void notifyStretchCached(const GrUniqueKey& stretchedKey) = 0;
+    virtual bool isVolatile() = 0;
+    virtual uint32_t imageID() = 0;
+    virtual SkIRect subset() = 0;
+    virtual GrTexture* onRefCachedTexture(GrContext*, const GrUniqueKey& unstretchedKey) = 0;
+    virtual bool getROBitmap(SkBitmap*) = 0;
+
+private:
+    const int fWidth;
+    const int fHeight;
+
+    GrTexture* stretchTexture(GrTexture* tex, const Stretch& stretch,
+                              const GrUniqueKey& stretchedKey) {
+        GrTexture* result = stretch_texture(tex, stretch, nullptr, stretchedKey);
+        if (result && stretchedKey.isValid()) {
+            this->notifyStretchCached(stretchedKey);
+        }
+        return result;
+    }
+};
+
+GrTexture* GrTextureMaker::refCachedTexture(GrContext* ctx, const GrTextureParams* params) {
     Stretch stretch;
-    get_stretch(ctx, bitmap.width(), bitmap.height(), params, &stretch);
+    get_stretch(ctx, this->width(), this->height(), params, &stretch);
 
-    GrTexture* result = bitmap.getTexture();
+    GrTexture* result = this->peekTexture();
     if (result) {
         if (Stretch::kNone_Type == stretch.fType) {
             return SkRef(result);
         }
         GrUniqueKey stretchedKey;
         // Don't create a key for the resized version if the bmp is volatile.
-        if (!bitmap.isVolatile()) {
+        if (!this->isVolatile()) {
             const GrUniqueKey& key = result->getUniqueKey();
             if (key.isValid()) {
                 make_stretched_key(key, stretch, &stretchedKey);
                 GrTexture* stretched =
                     ctx->textureProvider()->findAndRefTextureByUniqueKey(stretchedKey);
                 if (stretched) {
                     return stretched;
                 }
             }
         }
-        return stretch_texture(result, stretch, bitmap.pixelRef(), stretchedKey);
+        return this->stretchTexture(result, stretch, stretchedKey);
     }
 
-    GrUniqueKey key, resizedKey;
+    GrUniqueKey key, stretchedKey;
 
-    if (!bitmap.isVolatile()) {
+    if (!this->isVolatile()) {
         // If the bitmap isn't changing try to find a cached copy first.
-        make_image_keys(bitmap.getGenerationID(), bitmap.getSubset(), stretch, &key, &resizedKey);
+        make_image_keys(this->imageID(), this->subset(), stretch, &key, &stretchedKey);
 
         result = ctx->textureProvider()->findAndRefTextureByUniqueKey(
-            resizedKey.isValid() ? resizedKey : key);
+            stretchedKey.isValid() ? stretchedKey : key);
         if (result) {
             return result;
         }
     }
 
-    result = create_bitmap_texture(ctx, bitmap, stretch, key, resizedKey);
-    if (result) {
-        return result;
+    if (Stretch::kNone_Type != stretch.fType) {
+        SkAutoTUnref<GrTexture> unstretched;
+        // Check if we have the unstretched version in the cache, if not create it.
+        if (key.isValid()) {
+            unstretched.reset(ctx->textureProvider()->findAndRefTextureByUniqueKey(key));
+        }
+        if (!unstretched) {
+            if (this->width() < ctx->caps()->minTextureSize() ||
+                this->height() < ctx->caps()->minTextureSize()) {
+                SkBitmap bitmap;
+                if (!this->getROBitmap(&bitmap)) {
+                    return nullptr;
+                }
+                SkBitmap stretchedBmp = stretch_on_cpu(bitmap, stretch);
+                return create_unstretched_bitmap_texture(ctx, stretchedBmp, stretchedKey);
+            } else {
+                unstretched.reset(this->onRefCachedTexture(ctx, key));
+                if (!unstretched) {
+                    return nullptr;
+                }
+            }
+        }
+        return this->stretchTexture(unstretched, stretch, stretchedKey);
+    } else {
+        return this->onRefCachedTexture(ctx, key);
     }
+}
 
-    SkErrorInternals::SetError( kInternalError_SkError,
-                                "---- failed to create texture for cache [%d %d]\n",
-                                bitmap.width(), bitmap.height());
+class Bitmap_GrTextureMaker : public GrTextureMaker {
+public:
+    Bitmap_GrTextureMaker(const SkBitmap& bitmap)
+        : INHERITED(bitmap.width(), bitmap.height())
+        , fBitmap(bitmap)
+    {}
 
-    return nullptr;
+protected:
+    bool isVolatile() override { return fBitmap.isVolatile(); }
+    uint32_t imageID() override { return fBitmap.getGenerationID(); }
+    SkIRect subset() override { return fBitmap.getSubset(); }
+    GrTexture* peekTexture() override {
+        return fBitmap.getTexture();
+    }
+    void notifyStretchCached(const GrUniqueKey& stretchedKey) override {
+        fBitmap.pixelRef()->addGenIDChangeListener(new BitmapInvalidator(stretchedKey));
+    }
+    GrTexture* onRefCachedTexture(GrContext* ctx, const GrUniqueKey& unstretchedKey) override {
+        return create_unstretched_bitmap_texture(ctx, fBitmap, unstretchedKey);
+    }
+    bool getROBitmap(SkBitmap* bitmap) override {
+        *bitmap = fBitmap;
+        return true;
+    }
+private:
+    const SkBitmap fBitmap;
+
+    typedef GrTextureMaker INHERITED;
+};
+
+GrTexture* GrRefCachedBitmapTexture(GrContext* ctx, const SkBitmap& bitmap,
+                                    const GrTextureParams* params) {
+    return Bitmap_GrTextureMaker(bitmap).refCachedTexture(ctx, params);
 }
 
 // TODO: make this be the canonical signature, and turn the version that takes GrTextureParams*
 //       into a wrapper that contains the inverse of these tables.
 GrTexture* GrRefCachedBitmapTexture(GrContext* ctx,
                                     const SkBitmap& bitmap,
                                     SkImageUsageType usage) {
     // Just need a params that will trigger the correct cache key / etc, since the usage doesn't
     // tell us the specifics about filter level or specific tiling.
 
@@ skipping 315 matching lines @@
             SkErrorInternals::SetError( kInvalidPaint_SkError,
                                         "Sorry, I don't understand the filtering "
                                         "mode you asked for.  Falling back to "
                                         "MIPMaps.");
             textureFilterMode = GrTextureParams::kMipMap_FilterMode;
             break;
 
     }
     return textureFilterMode;
 }