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"
 
+namespace {
+bool shouldUseMipMaps(const SkImage::DeferredTextureImageUsageParams & param) {
+    bool shouldUseMipMaps = false;
+
+    // Use mipmaps if either
+    // 1.) it is a perspective matrix, or
+    // 2.) the quality is med/high and the scale is < 1
+    if (param.fMatrix.hasPerspective()) {
+        shouldUseMipMaps = true;
+    }
+    if (param.fQuality == kMedium_SkFilterQuality ||
+        param.fQuality == kHigh_SkFilterQuality) {
+        SkScalar minAxisScale = param.fMatrix.getMinScale();
+        if (minAxisScale != -1.f && minAxisScale < 1.f) {
+            shouldUseMipMaps = true;
+        }
+    }
+
+    return shouldUseMipMaps;
+}
+}
+
 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)
 {
     SkASSERT(tex->width() == w);
     SkASSERT(tex->height() == h);
@@ skipping 337 matching lines @@
         // 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 params[],
-                                            int paramCnt, void* buffer) const {
+                                            int paramCnt, void* buffer,
+                                            SkSourceGammaTreatment treatment) const {
     // Extract relevant min/max values from the params array.
     int lowestPreScaleMipLevel = params[0].fPreScaleMipLevel;
     SkFilterQuality highestFilterQuality = params[0].fQuality;
+    bool useMipMaps = shouldUseMipMaps(params[0]);
     for (int i = 1; i < paramCnt; ++i) {
         if (lowestPreScaleMipLevel > params[i].fPreScaleMipLevel)
             lowestPreScaleMipLevel = params[i].fPreScaleMipLevel;
         if (highestFilterQuality < params[i].fQuality)
             highestFilterQuality = params[i].fQuality;
+        useMipMaps |= shouldUseMipMaps(params[i]);
     }
 
     const bool fillMode = SkToBool(buffer);
     if (fillMode && !SkIsAlign8(reinterpret_cast<intptr_t>(buffer))) {
         return 0;
     }
 
     // Calculate scaling parameters.
     bool isScaled = lowestPreScaleMipLevel != 0;
 
@@ skipping 49 matching lines @@
                     return 0;
                 }
             } else {
                 if (!this->readPixels(pixmap, 0, 0, SkImage::kDisallow_CachingHint)) {
                     return 0;
                 }
             }
             SkASSERT(!pixmap.ctable());
         }
     }
+    SkAlphaType at = this->isOpaque() ? kOpaque_SkAlphaType : kPremul_SkAlphaType;
     int mipMapLevelCount = 1;
+    if (useMipMaps) {
+        // SkMipMap only deals with the mipmap levels it generates, which does
+        // not include the base level.
+        // That means it generates and holds levels 1-x instead of 0-x.
+        // So the total mipmap level count is 1 more than what
+        // SkMipMap::ComputeLevelCount returns.
+        mipMapLevelCount = SkMipMap::ComputeLevelCount(width(), height()) + 1;
+
+        // We already initialized pixelSize to the size of the base level.
+        // SkMipMap will generate the extra mipmap levels. Their sizes need to
+        // be added to the total.
+        // Index 0 here does not refer to the base mipmap level -- it is
+        // SkMipMap's first generated mipmap level (level 1).
+        for (int currentMipMapLevelIndex = mipMapLevelCount - 1; currentMipMapLevelIndex >= 0;
+             currentMipMapLevelIndex--) {
+            SkISize mipSize = SkMipMap::ComputeLevelSize(this->width(), this->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 + SkAlign8(SkAutoPixmapStorage::AllocSize(
+        info, nullptr));
+    if (useMipMaps) {
+        SkAutoTDelete<SkMipMap> mipmaps(SkMipMap::Build(pixmap, treatment, nullptr));
+        // SkMipMap holds only the mipmap levels it generates.
+        // A programmer can use the data they provided to SkMipMap::Build as level 0.
+        // So the SkMipMap provides levels 1-x but it stores them in its own
+        // range 0-(x-1).
+        for (int generatedMipLevelIndex = 0; generatedMipLevelIndex < mipMapLevelCount - 1;
+             generatedMipLevelIndex++) {
+            SkISize mipSize = SkMipMap::ComputeLevelSize(width(), height(),
+                                                         generatedMipLevelIndex);
+            SkImageInfo mipInfo = SkImageInfo::MakeN32(mipSize.fWidth, mipSize.fHeight, at);
+            SkMipMap::Level mipLevel;
+            mipmaps->getLevel(generatedMipLevelIndex, &mipLevel);
+            memcpy(reinterpret_cast<void*>(mipLevelPtr), mipLevel.fPixmap.addr(),
+                       mipLevel.fPixmap.getSafeSize());
+            dti->fData.fMipMapLevelData[generatedMipLevelIndex + 1].fPixelData =
+                reinterpret_cast<void*>(mipLevelPtr);
+            dti->fData.fMipMapLevelData[generatedMipLevelIndex + 1].fRowBytes =
+                mipLevel.fPixmap.rowBytes();
+            mipLevelPtr += SkAlign8(mipLevel.fPixmap.getSafeSize());
+        }
+    }
     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 10 matching lines @@
 sk_sp<SkImage> SkImage::MakeTextureFromMipMap(GrContext* ctx, const SkImageInfo& info,
                                               const GrMipLevel* texels, int mipLevelCount,
                                               SkBudgeted budgeted) {
     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,

[Brian Osman, 2016/06/14 12:10:51]

FYI: Ganesh needs to know the gamma treatment value that was used to build the
mips (or it will assume that it's kIgnore by default). So you probably want to
store it in the DeferredTextureImage, and then plumb it to here from
MakeFromDeferredTextureImageData. Then just throw in:

texture->texturePriv().setGammaTreatment(treatment)

[cblume, 2016/06/14 20:44:29]

Done.

Should we also be thinking about gamma treatment for the non-mipmap cases? Maybe
in a separate CL. Or maybe when the time is right?

                                    info.alphaType(), texture, budgeted);
 }