Add prescale option to deferred params

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 315 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 {
+    // Extract relevant min/max values from the params array.
+    int lowestPreScaleMipLevel = params[0].fPreScaleMipLevel;
+    SkFilterQuality highestFilterQuality = params[0].fQuality;
+    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;
+    }
+
     const bool fillMode = SkToBool(buffer);
     if (fillMode && !SkIsAlign8(reinterpret_cast<intptr_t>(buffer))) {
         return 0;
     }
 
+    // Calculate scaling parameters.
+    const SkISize scaledSize = SkMipMap::ComputeLevelSize(this->width(), this->height(),
+                                                          lowestPreScaleMipLevel);
+    const bool isScaled = lowestPreScaleMipLevel != 0;
+    // We never want to scale at higher than SW medium quality, as SW medium matches GPU high.
+    SkFilterQuality scaleFilterQuality = highestFilterQuality;
+    if (scaleFilterQuality > kMedium_SkFilterQuality) {
+        scaleFilterQuality = kMedium_SkFilterQuality;
+    }
+
     const int maxTextureSize = proxy.fCaps->maxTextureSize();
-    if (width() > maxTextureSize || height() > maxTextureSize) {
+    if (scaledSize.width() > maxTextureSize || scaledSize.height() > maxTextureSize) {
         return 0;
     }
 
     SkAutoPixmapStorage pixmap;
     SkImageInfo info;
     size_t pixelSize = 0;
     size_t ctSize = 0;
     int ctCount = 0;
-    if (this->peekPixels(&pixmap)) {
+    if (!isScaled && this->peekPixels(&pixmap)) {
         info = pixmap.info();
         pixelSize = SkAlign8(pixmap.getSafeSize());
         if (pixmap.ctable()) {
             ctCount = pixmap.ctable()->count();
             ctSize = SkAlign8(pixmap.ctable()->count() * 4);
         }
     } else {
         // Here we're just using presence of data to know whether there is a codec behind the image.
         // In the future we will access the cacherator and get the exact data that we want to (e.g.
         // yuv planes) upload.
         SkAutoTUnref<SkData> data(this->refEncoded());
-        if (!data) {
+        if (!data && !this->peekPixels(nullptr)) {
             return 0;
         }
         SkAlphaType at = this->isOpaque() ? kOpaque_SkAlphaType : kPremul_SkAlphaType;
-        info = SkImageInfo::MakeN32(this->width(), this->height(), at);
+        info = SkImageInfo::MakeN32(scaledSize.width(), scaledSize.height(), at);
         pixelSize = SkAlign8(SkAutoPixmapStorage::AllocSize(info, nullptr));
         if (fillMode) {
             pixmap.alloc(info);
-            if (!this->readPixels(pixmap, 0, 0, SkImage::kDisallow_CachingHint)) {
-                return 0;
+            if (isScaled) {
+                if (!this->scalePixels(pixmap, scaleFilterQuality,
+                                       SkImage::kDisallow_CachingHint)) {
+                    return 0;
+                }
+            } else {
+                if (!this->readPixels(pixmap, 0, 0, SkImage::kDisallow_CachingHint)) {
+                    return 0;
+                }
             }
             SkASSERT(!pixmap.ctable());
         }
     }
     int mipMapLevelCount = 1;
     size_t size = 0;
     size_t dtiSize = SkAlign8(sizeof(DeferredTextureImage));
     size += dtiSize;
     size += mipMapLevelCount * sizeof(DeferredTextureImage::MipMapLevelData);
     size_t pixelOffset = size;
@@ skipping 74 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);
 }