Store mipmap levels in deferred texture image

src/image/SkImage_Gpu.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkAutoPixmapStorage.h"
 #include "GrCaps.h"
 #include "GrContext.h"
 #include "GrDrawContext.h"
 #include "GrImageIDTextureAdjuster.h"
 #include "effects/GrYUVEffect.h"
 #include "SkCanvas.h"
 #include "SkBitmapCache.h"
 #include "SkGrPixelRef.h"
 #include "SkGrPriv.h"
 #include "SkImage_Gpu.h"
+#include "SkMipMap.h"
 #include "SkPixelRef.h"
 
 SkImage_Gpu::SkImage_Gpu(int w, int h, uint32_t uniqueID, SkAlphaType at, GrTexture* tex,
                          SkBudgeted budgeted)
     : INHERITED(w, h, uniqueID)
     , fTexture(SkRef(tex))
     , fAlphaType(at)
     , fBudgeted(budgeted)
     , fAddedRasterVersionToCache(false)
 {
@@ skipping 312 matching lines @@
         // It contains fMipMapLevelCount elements.
         // That means this struct's size is not known at compile-time.
         MipMapLevelData fMipMapLevelData[1];
     };
     Data fData;
 
     friend class SkImage;
 };
 
 size_t SkImage::getDeferredTextureImageData(const GrContextThreadSafeProxy& proxy,
-                                            const DeferredTextureImageUsageParams[],
+                                            const DeferredTextureImageUsageParams params[],
                                             int paramCnt, void* buffer) const {
     const bool fillMode = SkToBool(buffer);
     if (fillMode && !SkIsAlign8(reinterpret_cast<intptr_t>(buffer))) {
         return 0;
     }
 
     const int maxTextureSize = proxy.fCaps->maxTextureSize();
     if (width() > maxTextureSize || height() > maxTextureSize) {
         return 0;
     }
@@ skipping 22 matching lines @@
         info = SkImageInfo::MakeN32(this->width(), this->height(), at);
         pixelSize = SkAlign8(SkAutoPixmapStorage::AllocSize(info, nullptr));
         if (fillMode) {
             pixmap.alloc(info);
             if (!this->readPixels(pixmap, 0, 0, SkImage::kDisallow_CachingHint)) {
                 return 0;
             }
             SkASSERT(!pixmap.ctable());
         }
     }
+    bool shouldUseMipMaps = false;
     int mipMapLevelCount = 1;

[ericrk, 2016/06/03 18:05:45]

This is a bit misleading - if we are using mips, mipMapLevelCount is equal to
the number of levels excluding the base level, if we are not using mips,
mipMapLevelCount is equal to 1 (the number of levels including the base level).
Why not make this uniform?

[cblume, 2016/06/03 18:57:31]

Hrmmm perhaps I made a mistake.
The way it *should* be is that there is always 1 level (index 0).
Levels indexed 1-x only exist if there are mipmaps. These are the ones generated
by SkMipMap.

I'll double check myself and fix it if I did this wrong. It should be uniform.

+    for (int currentParamIndex = paramCnt; currentParamIndex > 0; currentParamIndex--) {

[ericrk, 2016/06/03 18:05:45]

I'm going to need to extract things from params (and I expect others will in the
future) - might be nicer to put this at the top and extract all relevant values
for params - especially if we need these in both branches - we could even
separate into a helper function (but feel free to do that later, or I can in my
patch).

[cblume, 2016/06/03 18:57:31]

Good idea. I'll put this at the top and see how it looks. I may then do a
follow-up patch to refactor it if I think of a lovely way.

+        const SkMatrix& currentMatrix = params[currentParamIndex].fMatrix;

[ericrk, 2016/06/03 18:05:45]

won't this index out of bounds and skip the 0th param - I expect params to be
zero indexed and to go up to paramCnt-1. Why not just

for (int currentParamIndex = 0; currentParamIndex < paramCnt;
++currentParamIndex)?

[cblume, 2016/06/03 18:57:31]

Hrmm it will indeed skip the 0th. It should be for(int currentParamIndex =
paramCnt - 1; currentParamIndex >= 0, ...).

When the code is simple enough, I prefer to have comparisons against 0. 0 is a
special value for CPUs almost always, resulting in more simple machine code. It
is unlikely to matter here as this isn't exactly a performance-critical area.
But it is a good general habit if it makes no difference to readability. If you
think it is less readable I'm happy to iterate up.

+        SkScalar minScaleFactor = currentMatrix.getMinScale();
+        if (currentMatrix.hasPerspective() ||

[ericrk, 2016/06/03 18:05:45]

Can you add a comment explaining the logic here (it seems correct, but a comment
would be nice for future reference). Also, it *might* be nicer to break out some
of this into individual bools rather than having one complex if, but up to you.

[cblume, 2016/06/03 18:57:31]

I agree 100% on the individual bools. That might actually make it more readable
anyway to the point where a comment is no longer helpful (just restating what
the code clearly says). I'll do that.

+            ((params[currentParamIndex].fQuality == kMedium_SkFilterQuality ||
+            params[currentParamIndex].fQuality == kHigh_SkFilterQuality) &&
+            minScaleFactor != -1.f && minScaleFactor < 1.f)) {
+            shouldUseMipMaps = true;
+            mipMapLevelCount = SkMipMap::ComputeLevelCount(width(), height());
+            break;
+        }
+    }
+    SkAlphaType at = this->isOpaque() ? kOpaque_SkAlphaType : kPremul_SkAlphaType;
+    if (shouldUseMipMaps) {
+        for (int currentMipMapLevelIndex = mipMapLevelCount; currentMipMapLevelIndex > 0;
+             currentMipMapLevelIndex--) {
+            SkISize mipSize = SkMipMap::ComputeLevelSize(width(), height(), currentMipMapLevelIndex);
+            SkImageInfo mipInfo = SkImageInfo::MakeN32(mipSize.fWidth, mipSize.fHeight, at);
+            pixelSize += SkAlign8(SkAutoPixmapStorage::AllocSize(mipInfo, nullptr));
+        }
+    }
     size_t size = 0;
     size_t dtiSize = SkAlign8(sizeof(DeferredTextureImage));
     size += dtiSize;
     size += mipMapLevelCount * sizeof(DeferredTextureImage::MipMapLevelData);
     size_t pixelOffset = size;
     size += pixelSize;
     size_t ctOffset = size;
     size += ctSize;
     if (!fillMode) {
         return size;
@@ skipping 13 matching lines @@
     SkASSERT(info == pixmap.info());
     size_t rowBytes = pixmap.rowBytes();
     DeferredTextureImage* dti = new (buffer) DeferredTextureImage();
     dti->fContextUniqueID = proxy.fContextUniqueID;
     dti->fData.fInfo = info;
     dti->fData.fColorTableCnt = ctCount;
     dti->fData.fColorTableData = ct;
     dti->fData.fMipMapLevelCount = mipMapLevelCount;
     dti->fData.fMipMapLevelData[0].fPixelData = pixels;
     dti->fData.fMipMapLevelData[0].fRowBytes = rowBytes;
+
+    // Fill in the mipmap levels if they exist
+    intptr_t mipLevelPtr = bufferAsInt + pixelOffset;
+    if (shouldUseMipMaps) {
+        SkAutoTDelete<SkMipMap> mipmaps(SkMipMap::Build(pixmap, nullptr));
+        for (int currentMipMapLevelIndex = 1; currentMipMapLevelIndex < mipMapLevelCount;

[ericrk, 2016/06/03 18:05:45]

Wont this skip the last mip level? when computed by SkMipMap::ComputeLevelCount,
this number excludes the base level, so souldn't you really want to generate
levels 1 through mipLevelCount inclusive?

[cblume, 2016/06/03 18:57:31]

Good catch.

+             currentMipMapLevelIndex++) {
+            SkISize prevMipSize = SkMipMap::ComputeLevelSize(width(), height(), currentMipMapLevelIndex);
+            SkImageInfo prevMipInfo = SkImageInfo::MakeN32(prevMipSize.fWidth, prevMipSize.fHeight, at);
+            mipLevelPtr += SkAlign8(SkAutoPixmapStorage::AllocSize(prevMipInfo, nullptr));
+
+            SkMipMap::Level currentMipMapLevel;
+            mipmaps->getLevel(currentMipMapLevelIndex, &currentMipMapLevel);
+            memcpy(reinterpret_cast<void*>(mipLevelPtr), currentMipMapLevel.fPixmap.addr(),
+                   currentMipMapLevel.fPixmap.getSafeSize());
+            dti->fData.fMipMapLevelData[currentMipMapLevelIndex].fPixelData =
+                reinterpret_cast<void*>(mipLevelPtr);
+            dti->fData.fMipMapLevelData[currentMipMapLevelIndex].fRowBytes =
+                currentMipMapLevel.fPixmap.rowBytes();
+        }
+    }
     return size;
 }
 
 sk_sp<SkImage> SkImage::MakeFromDeferredTextureImageData(GrContext* context, const void* data,
                                                          SkBudgeted budgeted) {
     if (!data) {
         return nullptr;
     }
     const DeferredTextureImage* dti = reinterpret_cast<const DeferredTextureImage*>(data);
 
     if (!context || context->uniqueID() != dti->fContextUniqueID) {
         return nullptr;
     }
     SkAutoTUnref<SkColorTable> colorTable;
     if (dti->fData.fColorTableCnt) {
         SkASSERT(dti->fData.fColorTableData);
         colorTable.reset(new SkColorTable(dti->fData.fColorTableData, dti->fData.fColorTableCnt));
     }
-    SkASSERT(dti->fData.fMipMapLevelCount == 1);
-    SkPixmap pixmap;
-    pixmap.reset(dti->fData.fInfo, dti->fData.fMipMapLevelData[0].fPixelData,
-                 dti->fData.fMipMapLevelData[0].fRowBytes, colorTable.get());
-    return SkImage::MakeTextureFromPixmap(context, pixmap, budgeted);
+    int mipLevelCount = dti->fData.fMipMapLevelCount;
+    SkASSERT(mipLevelCount >= 1);
+    if (mipLevelCount == 1) {
+        SkPixmap pixmap;
+        pixmap.reset(dti->fData.fInfo, dti->fData.fMipMapLevelData[0].fPixelData,
+                     dti->fData.fMipMapLevelData[0].fRowBytes, colorTable.get());
+        return SkImage::MakeTextureFromPixmap(context, pixmap, budgeted);
+    } else {
+        SkAutoTDeleteArray<GrMipLevel> texels(new GrMipLevel[mipLevelCount]);
+        for (int i = 0; i < mipLevelCount; i++) {
+            texels[i].fPixels = dti->fData.fMipMapLevelData[i].fPixelData;
+            texels[i].fRowBytes = dti->fData.fMipMapLevelData[i].fRowBytes;
+        }
+
+        return SkImage::MakeTextureFromMipMap(context, dti->fData.fInfo, texels.get(),
+                                              mipLevelCount, SkBudgeted::kYes);
+    }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 GrTexture* GrDeepCopyTexture(GrTexture* src, SkBudgeted budgeted) {
     GrContext* ctx = src->getContext();
 
     GrSurfaceDesc desc = src->desc();
     GrTexture* dst = ctx->textureProvider()->createTexture(desc, budgeted, nullptr, 0);
     if (!dst) {
@@ skipping 13 matching lines @@
     if (!ctx) {
         return nullptr;
     }
     SkAutoTUnref<GrTexture> texture(GrUploadMipMapToTexture(ctx, info, texels, mipLevelCount));
     if (!texture) {
         return nullptr;
     }
     return sk_make_sp<SkImage_Gpu>(texture->width(), texture->height(), kNeedNewImageUniqueID,
                                    info.alphaType(), texture, budgeted);
 }