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 "GrContext.h"
 #include "GrTextureParamsAdjuster.h"
 #include "GrGpuResourcePriv.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 "SkMath.h"
+#include "SkMipMapLevel.h"
 #include "SkPixelRef.h"
 #include "SkResourceCache.h"
 #include "SkTextureCompressor.h"
+#include "SkTypes.h"
 #include "SkYUVPlanesCache.h"
 #include "effects/GrBicubicEffect.h"
 #include "effects/GrConstColorProcessor.h"
 #include "effects/GrDitherEffect.h"
 #include "effects/GrPorterDuffXferProcessor.h"
 #include "effects/GrXfermodeFragmentProcessor.h"
 #include "effects/GrYUVtoRGBEffect.h"
 
 #ifndef SK_IGNORE_ETC1_SUPPORT
 #  include "ktx.h"
 #  include "etc1.h"
 #endif
 
 GrSurfaceDesc GrImageInfoToSurfaceDesc(const SkImageInfo& info) {
     GrSurfaceDesc desc;
     desc.fFlags = kNone_GrSurfaceFlags;
     desc.fWidth = info.width();
     desc.fHeight = info.height();
     desc.fConfig = SkImageInfo2GrPixelConfig(info);
     desc.fSampleCnt = 0;
     return desc;
 }
 
-void GrMakeKeyFromImageID(GrUniqueKey* key, uint32_t imageID, const SkIRect& imageBounds) {
+void GrMakeKeyFromImageID(GrUniqueKey* key, uint32_t imageID, const SkIRect& imageBounds, bool isMipMapped) {
     SkASSERT(key);
     SkASSERT(imageID);
     SkASSERT(!imageBounds.isEmpty());
     static const GrUniqueKey::Domain kImageIDDomain = GrUniqueKey::GenerateDomain();
     GrUniqueKey::Builder builder(key, kImageIDDomain, 5);
     builder[0] = imageID;
     builder[1] = imageBounds.fLeft;
     builder[2] = imageBounds.fTop;
     builder[3] = imageBounds.fRight;
     builder[4] = imageBounds.fBottom;
+    builder[5] = isMipMapped;

[bsalomon, 2015/10/28 16:40:45]

This will cause us to potentially create two versions of the bitmap, mipped and
unmipped. Seems kinda wasteful. I see two potential fixes:

1) Just eat the glGenerateMipMaps cost if the first draw doesn't require MIPs
and a latter draw does.

2) When searching for an existing texture do something like this pseudocode

if (needMIPS) {
   GrMakeKeyFromImageID(&key, ..., true);
   if (tex = provider->findTexture(key)) {
      return tex;
   } else {
      tex = make_mipped_texture_and_assign_key(key, ...);
      // If we had a non-mipped version, let it go free
      GrMakeKeyFromImageID(&key, ..., false);
      nonMipTex = provider->findTexture(key);
      if (nonMipTex) {
          nonMipTex->removeUniqueKey();
      }
      return tex;
   }
} else {
   // prefer the mip version if it exists
   GrMakeKeyFromImageID(&key, ..., true);
   if (tex = provider->findTexture(key)) {
      return tex;
   }
   // check for non-mipped
   GrMakeKeyFromImageID(&key, ..., false);
   if (tex = provider->findTexture(key)) {
      return tex;
   }
   // create non-mipped
   tex = make_nonmipped_texture_and_assign_key(key, ...);
   return tex;
}

3) Don't include mip status in the key. If we find a texture using the key and
need mips and the texture doesn't already have mips, compute the upper levels
and add them to the texture. I think this is the best option. However, this
bumps into the problems I cited in GrContext::writeSurfacePixels. So it's
feasibility depends on how we answer that.

+}
+
+void GrMakeKeyFromImageID(GrUniqueKey* key, uint32_t imageID, const SkIRect& imageBounds) {
+    const bool isMipMapped = false;
+    GrMakeKeyFromImageID(key, imageID, imageBounds, isMipMapped);
 }
 
 GrPixelConfig GrIsCompressedTextureDataSupported(GrContext* ctx, SkData* data,
                                                  int expectedW, int expectedH,
                                                  const void** outStartOfDataToUpload) {
     *outStartOfDataToUpload = nullptr;
 #ifndef SK_IGNORE_ETC1_SUPPORT
     if (!ctx->caps()->isConfigTexturable(kETC1_GrPixelConfig)) {
         return kUnknown_GrPixelConfig;
     }
@@ skipping 197 matching lines @@
         return nullptr;
     }
 
     return ctx->textureProvider()->createTexture(desc, true, bitmap->getPixels(),
                                                  bitmap->rowBytes());
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 
+static GrTexture* generate_mipmaps(GrContext* ctx,
+                                   const SkBitmap& bitmap) {
+    SkASSERT(sizeof(int) <= sizeof(uint32_t));
+    const uint32_t baseWidth = static_cast<uint32_t>(bitmap.width());
+    const uint32_t baseHeight = static_cast<uint32_t>(bitmap.height());
+
+    // OpenGL's spec requires that each mipmap level has height/width equal to
+    // max(1, floor(original_height / 2^i)
+    // (or original_height) where i is the mipmap level.
+    // Keep scaling down until both axes are size 1.
+
+    const uint32_t largestAxis = SkTMax(baseWidth, baseHeight);
+    const int leadingZeros = SkCLZ(largestAxis);
+    // If the value 00011010 has 3 leading 0s, it has 5 significant bits
+    // (the bits which are not leading zeros)
+    const int significantBits = (sizeof(uint32_t) * 8) - leadingZeros;
+    if (significantBits < 0)
+    {
+        return nullptr;
+    }
+    const uint32_t unsignedSignificantBits = static_cast<uint32_t>(significantBits);
+    const uint32_t mipLevelCount = unsignedSignificantBits;
+
+    GrSurfaceDesc desc = GrImageInfoToSurfaceDesc(bitmap.info());
+    const bool isMipMapped = mipLevelCount > 1;
+    desc.fIsMipMapped = isMipMapped;
+
+    SkAutoPixmapUnlock srcUnlocker;
+    if (!bitmap.requestLock(&srcUnlocker)) {
+        return nullptr;
+    }
+    const SkPixmap& srcPixmap = srcUnlocker.pixmap();
+    if (nullptr == srcPixmap.addr()) {
+        return nullptr;
+    }
+
+    SkTArray<SkMipMapLevel> texels(mipLevelCount);
+    SkMipMapLevel baseLevel(srcPixmap.addr(), bitmap.rowBytes(), baseWidth, baseHeight);
+    texels.push_back(baseLevel);
+
+    SkTArray<SkBitmap> mipLevelBitmaps(mipLevelCount - 1);
+    mipLevelBitmaps.push_back_n(mipLevelCount - 1);
+
+    for (uint32_t i = 1; i < mipLevelCount; i++) {
+        SkBitmap& currentMipBitmap = mipLevelBitmaps[i - 1];
+
+        uint32_t twoToTheMipLevel = 1 << (i + 1);
+        uint32_t currentMipLevelWidth = SkTMax(1u, baseWidth / twoToTheMipLevel);
+        uint32_t currentMipLevelHeight = SkTMax(1u, baseHeight / twoToTheMipLevel);
+
+        SkImageInfo info = SkImageInfo::Make(currentMipLevelWidth, currentMipLevelHeight,
+                                             currentMipBitmap.colorType(),
+                                             bitmap.alphaType());
+        if (!currentMipBitmap.tryAllocPixels(info))
+        {
+            return nullptr;
+        }
+
+        SkCanvas canvas(currentMipBitmap);
+        canvas.clear(SK_ColorTRANSPARENT);
+        canvas.drawBitmap(bitmap, SkIntToScalar(0), SkIntToScalar(0));
+
+        SkMipMapLevel currentMipLevel(currentMipBitmap.getPixels(),
+                                      currentMipBitmap.rowBytes(),
+                                      currentMipLevelWidth, currentMipLevelHeight);
+        texels.push_back(currentMipLevel);
+    }
+
+    return ctx->textureProvider()->createTexture(desc, true, texels);
+}
+
 class Bitmap_GrTextureParamsAdjuster : public GrTextureParamsAdjuster {
 public:
     Bitmap_GrTextureParamsAdjuster(const SkBitmap& bitmap)
         : INHERITED(bitmap.width(), bitmap.height())
         , fBitmap(bitmap)
     {
         if (!bitmap.isVolatile()) {
             SkIPoint origin = bitmap.pixelRefOrigin();
             SkIRect subset = SkIRect::MakeXYWH(origin.fX, origin.fY, bitmap.width(),
                                                bitmap.height());
             GrMakeKeyFromImageID(&fOriginalKey, bitmap.pixelRef()->getGenerationID(), subset);
         }
     }
 
 protected:
     GrTexture* peekOriginalTexture() override { return fBitmap.getTexture();  }
 
-    GrTexture* refOriginalTexture(GrContext* ctx) override {
+    GrTexture* refOriginalTexture(GrContext* ctx, const GrTextureParams& params) override {
         GrTexture* tex = fBitmap.getTexture();
         if (tex) {
             return SkRef(tex);
         }
 
         if (fOriginalKey.isValid()) {
             tex = ctx->textureProvider()->findAndRefTextureByUniqueKey(fOriginalKey);
             if (tex) {
                 return tex;
             }
         }
 
-        tex = GrUploadBitmapToTexture(ctx, fBitmap);
+        if (params.filterMode() == GrTextureParams::kMipMap_FilterMode) {
+            // 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(!tex);
+            tex = generate_mipmaps(ctx, fBitmap);
+        } else {
+            tex = GrUploadBitmapToTexture(ctx, fBitmap);
+        }
         if (tex && fOriginalKey.isValid()) {
             tex->resourcePriv().setUniqueKey(fOriginalKey);
             InstallInvalidator(fOriginalKey, fBitmap.pixelRef());
         }
         return tex;
     }
 
     void makeCopyKey(const CopyParams& copyParams, GrUniqueKey* copyKey) override {
         if (fOriginalKey.isValid()) {
             MakeCopyKeyFromOrigKey(fOriginalKey, copyParams, copyKey);
@@ skipping 348 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;
 }