Don't upload texture smaller than the min texture size when stretching a bmp up to a POT

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"
 #include "GrDrawContext.h"
 #include "GrXferProcessor.h"
 #include "SkColorFilter.h"
 #include "SkConfig8888.h"
+#include "SkCanvas.h"
 #include "SkData.h"
 #include "SkErrorInternals.h"
 #include "SkGrPixelRef.h"
 #include "SkMessageBus.h"
 #include "SkPixelRef.h"
 #include "SkResourceCache.h"
 #include "SkTextureCompressor.h"
 #include "SkYUVPlanesCache.h"
 #include "effects/GrDitherEffect.h"
 #include "effects/GrPorterDuffXferProcessor.h"
@@ skipping 73 matching lines @@
     int fHeight;
 };
 
 static void get_stretch(const GrContext* ctx, int width, int height,
                         const GrTextureParams* params, Stretch* stretch) {
     stretch->fType = Stretch::kNone_Type;
     bool doStretch = false;
     if (params && params->isTiled() && !ctx->caps()->npotTextureTileSupport() &&
         (!SkIsPow2(width) || !SkIsPow2(height))) {
         doStretch = true;
-        stretch->fWidth  = GrNextPow2(width);
-        stretch->fHeight = GrNextPow2(height);
-    } else if (width < ctx->caps()->minTextureSize() ||
-               height < ctx->caps()->minTextureSize()) {
+        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:
@@ skipping 321 matching lines @@
     }
 
     drawContext->drawRect(renderTarget, GrClip::WideOpen(), paint, SkMatrix::I(), r);
 
     return result;
 }
 
 static GrTexture* create_unstretched_bitmap_texture(GrContext* ctx,
                                                     const SkBitmap& origBitmap,
                                                     const GrUniqueKey& optionalKey) {
+    if (origBitmap.width() < ctx->caps()->minTextureSize() ||
+        origBitmap.height() < ctx->caps()->minTextureSize()) {
+        return NULL;
+    }
     SkBitmap tmpBitmap;
 
     const SkBitmap* bitmap = &origBitmap;
 
     GrSurfaceDesc desc;
     generate_bitmap_texture_desc(*bitmap, &desc);
     const GrCaps* caps = ctx->caps();
 
     if (kIndex_8_SkColorType == bitmap->colorType()) {
         if (caps->isConfigTexturable(kIndex_8_GrPixelConfig)) {
@@ skipping 38 matching lines @@
 
     SkAutoLockPixels alp(*bitmap);
     if (!bitmap->readyToDraw()) {
         return NULL;
     }
 
     return create_texture_for_bmp(ctx, optionalKey, desc, origBitmap.pixelRef(),
                                   bitmap->getPixels(), bitmap->rowBytes());
 }
 
+static SkBitmap stretch_on_cpu(const SkBitmap& bmp, const Stretch& stretch) {
+    SkBitmap stretched;
+    stretched.allocN32Pixels(stretch.fWidth, stretch.fHeight);
+    SkCanvas canvas(stretched);
+    SkPaint paint;
+    switch (stretch.fType) {
+        case Stretch::kNearest_Type:
+            paint.setFilterQuality(kNone_SkFilterQuality);
+            break;
+        case Stretch::kBilerp_Type:
+            paint.setFilterQuality(kLow_SkFilterQuality);
+            break;
+        case Stretch::kNone_Type:
+            SkDEBUGFAIL("Shouldn't get here.");
+            break;
+    }
+    SkRect dstRect = SkRect::MakeWH(SkIntToScalar(stretch.fWidth), SkIntToScalar(stretch.fHeight));
+    canvas.drawBitmapRectToRect(bmp, NULL, 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) {
-                return NULL;
+                // 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);
             }
         }
-        GrTexture* stretched = stretch_texture(unstretched, stretch, bmp.pixelRef(), stretchedKey);
-        return stretched;
+        return stretch_texture(unstretched, stretch, bmp.pixelRef(), stretchedKey);
     }
-
     return create_unstretched_bitmap_texture(ctx, bmp, unstretchedKey);
-
 }
 
 bool GrIsBitmapInCache(const GrContext* ctx,
                        const SkBitmap& bitmap,
                        const GrTextureParams* params) {
     Stretch stretch;
     get_stretch(ctx, bitmap.width(), bitmap.height(), params, &stretch);
 
     // Handle the case where the bitmap is explicitly texture backed.
     GrTexture* texture = bitmap.getTexture();
@@ skipping 257 matching lines @@
     }
     return SkImageInfo::Make(w, h, ct, at);
 }
 
 
 void GrWrapTextureInBitmap(GrTexture* src, int w, int h, bool isOpaque, SkBitmap* dst) {
     const SkImageInfo info = GrMakeInfoFromTexture(src, w, h, isOpaque);
     dst->setInfo(info);
     dst->setPixelRef(SkNEW_ARGS(SkGrPixelRef, (info, src)))->unref();
 }