Creating functions for uploading a mipmapped texture.

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 "GrYUVProvider.h"
 
 #include "SkColorFilter.h"
 #include "SkConfig8888.h"
 #include "SkCanvas.h"
 #include "SkData.h"
 #include "SkErrorInternals.h"
 #include "SkGrPixelRef.h"
 #include "SkMessageBus.h"
+#include "SkMipMap.h"
+#include "SkMipMapLevel.h"
 #include "SkPixelRef.h"
 #include "SkResourceCache.h"
 #include "SkTextureCompressor.h"
 #include "SkYUVPlanesCache.h"
 #include "effects/GrBicubicEffect.h"
 #include "effects/GrDitherEffect.h"
 #include "effects/GrPorterDuffXferProcessor.h"
 #include "effects/GrYUVtoRGBEffect.h"
 
 #ifndef SK_IGNORE_ETC1_SUPPORT
@@ skipping 382 matching lines @@
     GrTexture* texture = provider.refAsTexture(ctx, desc, useCache);
     if (!texture) {
         return nullptr;
     }
 
     if (useCache) {
         BitmapInvalidator* listener = new BitmapInvalidator(optionalKey);
         pixelRef->addGenIDChangeListener(listener);
         ctx->textureProvider()->assignUniqueKeyToTexture(optionalKey, texture);
     }
-    return texture;
+   return texture;
 }
 
 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 nullptr;
     }
     SkBitmap tmpBitmap;
@@ skipping 118 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);
 }
 
+static GrTexture* create_mipmapped_texture(GrContext* ctx,

[bsalomon, 2015/09/30 18:01:29]

You should coordinate with reed@ about landing this. I think you guys are headed
for merge conflict as he is restructuring a lot of the code in here.

[cblume, 2015/10/08 09:27:57]

I rebased ontop of those changes. There was a conflict but I think it is
resolved.

+                                    const SkBitmap& bitmap,
+                                    const GrUniqueKey& optionalKey,
+                                    SkDiscardableFactoryProc fact) {
+    GrTexture* texture = bitmap.getTexture();
+    // If the SkBitmap is already backed by a texture, we do not want to read the contents back
+    // to the cpu and generate the mipmap only to send it back to the GPU.
+    SkASSERT(!texture);
+
+    GrSurfaceDesc desc = GrImageInfoToSurfaceDesc(bitmap.info());
+
+    SkMipMap* mipmap = SkMipMap::Build(bitmap, fact);
+    if (mipmap == nullptr) {
+        // could not create the mipmap
+        return nullptr;
+    } else {
+        int mipLevelCount = mipmap->getLevelsCount() + 1;
+        desc.fIsMipMapped = mipLevelCount > 1;
+        SkTArray<SkMipMapLevel> texels(mipLevelCount);
+
+        SkAutoPixmapUnlock srcUnlocker;
+        if (!bitmap.requestLock(&srcUnlocker)) {
+            return nullptr;
+        }
+        const SkPixmap& srcPixmap = srcUnlocker.pixmap();
+        if (nullptr == srcPixmap.addr()) {
+            return nullptr;
+        }
+
+        int width = bitmap.width();
+        int height = bitmap.height();
+        if (width < 0 || height < 0) {
+            return nullptr;
+        }
+        uint32_t baseLevelWidth = width;
+        uint32_t baseLevelHeight = height;
+        SkMipMapLevel baseLevel(srcPixmap.addr(), bitmap.rowBytes(), baseLevelWidth,
+                                baseLevelHeight);
+        texels.push_back(baseLevel);
+
+        for (int i = 1; i < mipLevelCount; i++) {
+            SkMipMap::Level level;
+            if (!mipmap->getLevel(i, &level)) {
+                return nullptr;
+            }
+
+            SkMipMapLevel currentMipLevel(level.fPixels, level.fRowBytes, level.fWidth,
+                                          level.fHeight);
+            texels.push_back(currentMipLevel);
+        }
+
+        SkPixelRef* pixelRef = bitmap.pixelRef();
+        if (optionalKey.isValid()) {
+            BitmapInvalidator* listener = new BitmapInvalidator(optionalKey);
+            pixelRef->addGenIDChangeListener(listener);
+            ctx->textureProvider()->assignUniqueKeyToTexture(optionalKey, texture);
+        }
+
+        return ctx->textureProvider()->createTexture(desc, true, texels);
+    }
+}
+
 GrTexture* GrRefCachedBitmapTexture(GrContext* ctx,
                                     const SkBitmap& bitmap,
                                     const GrTextureParams* params) {
 
     Stretch stretch;
     get_stretch(ctx, bitmap.width(), bitmap.height(), params, &stretch);
 
     GrTexture* result = bitmap.getTexture();
     if (result) {
         if (Stretch::kNone_Type == stretch.fType) {
@@ skipping 21 matching lines @@
         // 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);
         if (result) {
             return result;
         }
     }
 
-    result = create_bitmap_texture(ctx, bitmap, stretch, key, resizedKey);
+    if (params && params->filterMode() == GrTextureParams::kMipMap_FilterMode) {
+        const SkDiscardableFactoryProc fact = nullptr;
+        result = create_mipmapped_texture(ctx, bitmap, key, fact);
+    } else {
+        result = create_bitmap_texture(ctx, bitmap, stretch, key, resizedKey);
+    }
+
     if (result) {
         return result;
     }
 
     SkErrorInternals::SetError( kInternalError_SkError,
                                 "---- failed to create texture for cache [%d %d]\n",
                                 bitmap.width(), bitmap.height());
 
     return nullptr;
 }
@@ skipping 218 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;
 }