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 "GrTextureMaker.h"
+
 #include "SkGr.h"
 
 #include "GrCaps.h"
 #include "GrDrawContext.h"
 #include "GrXferProcessor.h"
 #include "GrYUVProvider.h"
 
 #include "SkColorFilter.h"
 #include "SkConfig8888.h"
 #include "SkCanvas.h"
@@ skipping 69 matching lines @@
         for (int y = 0; y < bitmap.height(); y++) {
             memcpy(dst, src, width);
             src += rowBytes;
             dst += width;
         }
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-struct Stretch {
-    enum Type {
-        kNone_Type,
-        kBilerp_Type,
-        kNearest_Type
-    } fType;
-    int fWidth;
-    int fHeight;
-};
-
 static void get_stretch(const GrContext* ctx, int width, int height,
-                        const GrTextureParams* params, Stretch* stretch) {
-    stretch->fType = Stretch::kNone_Type;
+                        const GrTextureParams* params, SkGrStretch* stretch) {
+    stretch->fType = SkGrStretch::kNone_Type;
     bool doStretch = false;
     if (params && params->isTiled() && !ctx->caps()->npotTextureTileSupport() &&
         (!SkIsPow2(width) || !SkIsPow2(height))) {
         doStretch = true;
         stretch->fWidth  = GrNextPow2(SkTMax(width, ctx->caps()->minTextureSize()));
         stretch->fHeight = GrNextPow2(SkTMax(height, ctx->caps()->minTextureSize()));
     } else if (width < ctx->caps()->minTextureSize() || height < ctx->caps()->minTextureSize()) {
         // The small texture issues appear to be with tiling. Hence it seems ok to scale them
         // up using the GPU. If issues persist we may need to CPU-stretch.
         doStretch = true;
         stretch->fWidth = SkTMax(width, ctx->caps()->minTextureSize());
         stretch->fHeight = SkTMax(height, ctx->caps()->minTextureSize());
     }
     if (doStretch) {
         if (params) {
             switch(params->filterMode()) {
                 case GrTextureParams::kNone_FilterMode:
-                    stretch->fType = Stretch::kNearest_Type;
+                    stretch->fType = SkGrStretch::kNearest_Type;
                     break;
                 case GrTextureParams::kBilerp_FilterMode:
                 case GrTextureParams::kMipMap_FilterMode:
-                    stretch->fType = Stretch::kBilerp_Type;
+                    stretch->fType = SkGrStretch::kBilerp_Type;
                     break;
             }
         } else {
-            stretch->fType = Stretch::kBilerp_Type;
+            stretch->fType = SkGrStretch::kBilerp_Type;
         }
     } else {
         stretch->fWidth  = -1;
         stretch->fHeight = -1;
-        stretch->fType = Stretch::kNone_Type;
+        stretch->fType = SkGrStretch::kNone_Type;
     }
 }
 
-static bool make_stretched_key(const GrUniqueKey& origKey, const Stretch& stretch,
+static bool make_stretched_key(const GrUniqueKey& origKey, const SkGrStretch& stretch,
                                GrUniqueKey* stretchedKey) {
-    if (origKey.isValid() && Stretch::kNone_Type != stretch.fType) {
+    if (origKey.isValid() && SkGrStretch::kNone_Type != stretch.fType) {
         uint32_t width = SkToU16(stretch.fWidth);
         uint32_t height = SkToU16(stretch.fHeight);
         static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
         GrUniqueKey::Builder builder(stretchedKey, origKey, kDomain, 2);
         builder[0] = stretch.fType;
         builder[1] = width | (height << 16);
         builder.finish();
         return true;
     }
     SkASSERT(!stretchedKey->isValid());
     return false;
 }
 
 static void make_unstretched_key(GrUniqueKey* key, uint32_t imageID, const SkIRect& subset) {
     SkASSERT(SkIsU16(subset.width()));
     SkASSERT(SkIsU16(subset.height()));
 
     static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
     GrUniqueKey::Builder builder(key, kDomain, 4);
     builder[0] = imageID;
     builder[1] = subset.x();
     builder[2] = subset.y();
     builder[3] = subset.width() | (subset.height() << 16);
 }
 
 void GrMakeKeyFromImageID(GrUniqueKey* key, uint32_t imageID, const SkIRect& subset,
                           const GrCaps& caps, SkImageUsageType usage) {
-    const Stretch::Type stretches[] = {
-        Stretch::kNone_Type,        // kUntiled_SkImageUsageType
-        Stretch::kNearest_Type,     // kTiled_Unfiltered_SkImageUsageType
-        Stretch::kBilerp_Type,      // kTiled_Filtered_SkImageUsageType
+    const SkGrStretch::Type stretches[] = {
+        SkGrStretch::kNone_Type,        // kUntiled_SkImageUsageType
+        SkGrStretch::kNearest_Type,     // kTiled_Unfiltered_SkImageUsageType
+        SkGrStretch::kBilerp_Type,      // kTiled_Filtered_SkImageUsageType
     };
 
     const bool isPow2 = SkIsPow2(subset.width()) && SkIsPow2(subset.height());
     const bool needToStretch = !isPow2 &&
                                usage != kUntiled_SkImageUsageType &&
                                !caps.npotTextureTileSupport();
 
     if (needToStretch) {
         GrUniqueKey tmpKey;
         make_unstretched_key(&tmpKey, imageID, subset);
 
-        Stretch stretch;
+        SkGrStretch stretch;
         stretch.fType = stretches[usage];
         stretch.fWidth = SkNextPow2(subset.width());
         stretch.fHeight = SkNextPow2(subset.height());
         if (!make_stretched_key(tmpKey, stretch, key)) {
             goto UNSTRETCHED;
         }
     } else {
         UNSTRETCHED:
         make_unstretched_key(key, imageID, subset);
     }
 }
 
-static void make_image_keys(uint32_t imageID, const SkIRect& subset, const Stretch& stretch,
+static void make_image_keys(uint32_t imageID, const SkIRect& subset, const SkGrStretch& stretch,
                             GrUniqueKey* key, GrUniqueKey* stretchedKey) {
     make_unstretched_key(key, imageID, subset);
-    if (Stretch::kNone_Type != stretch.fType) {
+    if (SkGrStretch::kNone_Type != stretch.fType) {
         make_stretched_key(*key, stretch, stretchedKey);
     }
 }
 
 GrSurfaceDesc GrImageInfoToSurfaceDesc(const SkImageInfo& info) {
     GrSurfaceDesc desc;
     desc.fFlags = kNone_GrSurfaceFlags;
     desc.fWidth = info.width();
     desc.fHeight = info.height();
     desc.fConfig = SkImageInfo2GrPixelConfig(info);
@@ skipping 31 matching lines @@
             pixelRefForInvalidationNotification->addGenIDChangeListener(listener);
         }
         ctx->textureProvider()->assignUniqueKeyToTexture(optionalKey, result);
     }
     return result;
 }
 
 // creates a new texture that is the input texture scaled up. If optionalKey is valid it will be
 // set on the new texture. stretch controls whether the scaling is done using nearest or bilerp
 // filtering and the size to stretch the texture to.
-GrTexture* stretch_texture(GrTexture* inputTexture, const Stretch& stretch,
+GrTexture* stretch_texture(GrTexture* inputTexture, const SkGrStretch& stretch,
                            SkPixelRef* pixelRef,
                            const GrUniqueKey& optionalKey) {
-    SkASSERT(Stretch::kNone_Type != stretch.fType);
+    SkASSERT(SkGrStretch::kNone_Type != stretch.fType);
 
     GrContext* context = inputTexture->getContext();
     SkASSERT(context);
     const GrCaps* caps = context->caps();
 
     // Either it's a cache miss or the original wasn't cached to begin with.
     GrSurfaceDesc rtDesc = inputTexture->desc();
     rtDesc.fFlags =  rtDesc.fFlags | kRenderTarget_GrSurfaceFlag;
     rtDesc.fWidth  = stretch.fWidth;
     rtDesc.fHeight = stretch.fHeight;
@@ skipping 25 matching lines @@
     SkAutoTUnref<GrTexture> stretched(GrCreateTextureForPixels(context, optionalKey, rtDesc,
                                                                pixelRef, nullptr,0));
     if (!stretched) {
         return nullptr;
     }
     GrPaint paint;
 
     // If filtering is not desired then we want to ensure all texels in the resampled image are
     // copies of texels from the original.
     GrTextureParams params(SkShader::kClamp_TileMode,
-                           Stretch::kBilerp_Type == stretch.fType ?
+                           SkGrStretch::kBilerp_Type == stretch.fType ?
                               GrTextureParams::kBilerp_FilterMode :
                               GrTextureParams::kNone_FilterMode);
     paint.addColorTextureProcessor(inputTexture, SkMatrix::I(), params);
 
     SkRect rect = SkRect::MakeWH(SkIntToScalar(rtDesc.fWidth), SkIntToScalar(rtDesc.fHeight));
     SkRect localRect = SkRect::MakeWH(1.f, 1.f);
 
     SkAutoTUnref<GrDrawContext> drawContext(context->drawContext());
     if (!drawContext) {
         return nullptr;
@@ skipping 158 matching lines @@
 
     SkAutoLockPixels alp(*bitmap);
     if (!bitmap->readyToDraw()) {
         return nullptr;
     }
 
     return GrCreateTextureForPixels(ctx, optionalKey, desc, origBitmap.pixelRef(),
                                     bitmap->getPixels(), bitmap->rowBytes());
 }
 
-static SkBitmap stretch_on_cpu(const SkBitmap& bmp, const Stretch& stretch) {
+static SkBitmap stretch_on_cpu(const SkBitmap& bmp, const SkGrStretch& stretch) {
     SkBitmap stretched;
     stretched.allocN32Pixels(stretch.fWidth, stretch.fHeight);
     SkCanvas canvas(stretched);
     SkPaint paint;
     switch (stretch.fType) {
-        case Stretch::kNearest_Type:
+        case SkGrStretch::kNearest_Type:
             paint.setFilterQuality(kNone_SkFilterQuality);
             break;
-        case Stretch::kBilerp_Type:
+        case SkGrStretch::kBilerp_Type:
             paint.setFilterQuality(kLow_SkFilterQuality);
             break;
-        case Stretch::kNone_Type:
+        case SkGrStretch::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;
+    SkGrStretch 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) {
+        if (SkGrStretch::kNone_Type == stretch.fType) {
             return true;
         }
         const GrUniqueKey& key = nativeTexture->getUniqueKey();
         if (!key.isValid()) {
             return false;
         }
         GrUniqueKey stretchedKey;
         make_stretched_key(key, stretch, &stretchedKey);
         return ctx->textureProvider()->existsTextureWithUniqueKey(stretchedKey);
     }
 
     GrUniqueKey key, stretchedKey;
     make_image_keys(imageID, subset, stretch, &key, &stretchedKey);
     return ctx->textureProvider()->existsTextureWithUniqueKey(
-        (Stretch::kNone_Type == stretch.fType) ? key : stretchedKey);
+        (SkGrStretch::kNone_Type == stretch.fType) ? key : stretchedKey);
 }
 
 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 Bitmap_GrTextureMaker : public GrTextureMaker {
+public:
+    Bitmap_GrTextureMaker(const SkBitmap& bitmap)
+        : INHERITED(bitmap.width(), bitmap.height())
+        , fBitmap(bitmap)
+    {}
 
-    Stretch stretch;
-    get_stretch(ctx, bitmap.width(), bitmap.height(), params, &stretch);
+protected:
+    GrTexture* onRefUnstretchedTexture(GrContext* ctx) override {
+        GrTexture* tex = fBitmap.getTexture();
+        if (tex) {
+            return SkRef(tex);
+        }
 
-    GrTexture* result = bitmap.getTexture();
-    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()) {
-            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);
-    }
+        GrUniqueKey unstretchedKey;
+        make_unstretched_key(&unstretchedKey, fBitmap.getGenerationID(), fBitmap.getSubset());
 
-    GrUniqueKey key, resizedKey;
-
-    if (!bitmap.isVolatile()) {
-        // If the bitmap isn't changing try to find a cached copy first.
-        make_image_keys(bitmap.getGenerationID(), bitmap.getSubset(), stretch, &key, &resizedKey);
-
-        result = ctx->textureProvider()->findAndRefTextureByUniqueKey(
-            resizedKey.isValid() ? resizedKey : key);
+        GrTexture* result = ctx->textureProvider()->findAndRefTextureByUniqueKey(unstretchedKey);
         if (result) {
             return result;
         }
+        return create_unstretched_bitmap_texture(ctx, fBitmap, unstretchedKey);
     }
 
-    result = create_bitmap_texture(ctx, bitmap, stretch, key, resizedKey);
-    if (result) {
-        return result;
+    bool onMakeStretchedKey(const SkGrStretch& stretch, GrUniqueKey* stretchedKey) override {
+        if (fBitmap.isVolatile()) {
+            return false;
+        }
+
+        GrUniqueKey unstretchedKey;
+        make_unstretched_key(&unstretchedKey, fBitmap.getGenerationID(), fBitmap.getSubset());
+        return make_stretched_key(unstretchedKey, stretch, stretchedKey);
     }
 
-    SkErrorInternals::SetError( kInternalError_SkError,
-                                "---- failed to create texture for cache [%d %d]\n",
-                                bitmap.width(), bitmap.height());
+    void onNotifyStretchCached(const GrUniqueKey& stretchedKey) override {
+        fBitmap.pixelRef()->addGenIDChangeListener(new BitmapInvalidator(stretchedKey));
+    }
 
-    return nullptr;
+    bool onGetROBitmap(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;
 }
+
+////////////////////////////////////////////////////////////////////////////////////////////////
+
+GrTexture* GrTextureMaker::refCachedTexture(GrContext* ctx, const GrTextureParams* params) {
+    SkGrStretch stretch;
+    get_stretch(ctx, this->width(), this->height(), params, &stretch);
+
+    if (SkGrStretch::kNone_Type == stretch.fType) {
+        return this->onRefUnstretchedTexture(ctx);
+    }
+
+    GrUniqueKey stretchedKey;
+    if (this->onMakeStretchedKey(stretch, &stretchedKey)) {
+        GrTexture* result = ctx->textureProvider()->findAndRefTextureByUniqueKey(stretchedKey);
+        if (result) {
+            return result;
+        }
+    }
+
+    GrTexture* result = this->onGenerateStretchedTexture(ctx, stretch);
+    if (!result) {
+        return nullptr;
+    }
+
+    if (stretchedKey.isValid()) {
+        ctx->textureProvider()->assignUniqueKeyToTexture(stretchedKey, result);
+        this->onNotifyStretchCached(stretchedKey);
+    }
+    return result;
+}
+
+GrTexture* GrTextureMaker::onGenerateStretchedTexture(GrContext* ctx, const SkGrStretch& stretch) {
+    if (this->width() < ctx->caps()->minTextureSize() ||
+        this->height() < ctx->caps()->minTextureSize())
+    {
+        // we can't trust our ability to use HW to perform the stretch, so we request
+        // a raster instead, and perform the stretch on the CPU.
+        SkBitmap bitmap;
+        if (!this->onGetROBitmap(&bitmap)) {
+            return nullptr;
+        }
+        SkBitmap stretchedBmp = stretch_on_cpu(bitmap, stretch);
+        return create_unstretched_bitmap_texture(ctx, stretchedBmp, GrUniqueKey());
+    } else {
+        SkAutoTUnref<GrTexture> unstretched(this->onRefUnstretchedTexture(ctx));
+        if (!unstretched) {
+            return nullptr;
+        }
+        return stretch_texture(unstretched, stretch, nullptr, GrUniqueKey());
+    }
+}