Handling large jpegs in CPU raster - downsample to display res and 565

src/core/SkImageCacherator.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmap.h"
 #include "SkBitmapCache.h"
 #include "SkImage_Base.h"
 #include "SkImageCacherator.h"
 #include "SkMallocPixelRef.h"
 #include "SkNextID.h"
 #include "SkPixelRef.h"
 #include "SkResourceCache.h"
+#include <SkCanvas.h>
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #include "GrGpuResourcePriv.h"
 #include "GrResourceKey.h"
 #include "GrTextureParams.h"
 #include "GrYUVProvider.h"
 #include "SkGr.h"
 #include "SkGrPriv.h"
 #endif
@@ skipping 50 matching lines @@
 static bool check_output_bitmap(const SkBitmap& bitmap, uint32_t expectedID) {
     SkASSERT(bitmap.getGenerationID() == expectedID);
     SkASSERT(bitmap.isImmutable());
     SkASSERT(bitmap.getPixels());
     return true;
 }
 
 // Note, this returns a new, mutable, bitmap, with a new genID.
 // If you want the immutable bitmap with the same ID as our cacherator, call tryLockAsBitmap()
 //
-bool SkImageCacherator::generateBitmap(SkBitmap* bitmap) {
+bool SkImageCacherator::generateBitmap(SkBitmap* bitmap, SkScalar scaleHint) {
     SkBitmap::Allocator* allocator = SkResourceCache::GetAllocator();
 
     ScopedGenerator generator(this);
-    const SkImageInfo& genInfo = generator->getInfo();
+    SkImageInfo genInfo = generator->getInfo();
     if (fInfo.dimensions() == genInfo.dimensions()) {
         SkASSERT(fOrigin.x() == 0 && fOrigin.y() == 0);
-        // fast-case, no copy needed
-        return generator->tryGenerateBitmap(bitmap, fInfo, allocator);
+        SkISize size;
+        SkImageGenerator::Result res = generator->canDecodeAndScale(kRGB_565_SkColorType, scaleHint, &size, nullptr);
+        if (!(res & SkImageGenerator::kScale))
+            size = genInfo.dimensions();
+        if (res & SkImageGenerator::kDecode) {
+            genInfo = genInfo.Make(size.width(), size.height(), kRGB_565_SkColorType,
+                                kOpaque_SkAlphaType, genInfo.profileType());
+        } else {
+            genInfo = genInfo.makeWH(size.width(), size.height());
+        }
+        return generator->tryGenerateBitmap(bitmap, genInfo, allocator);
     } else {
         // need to handle subsetting, so we first generate the full size version, and then
         // "read" from it to get our subset. See skbug.com/4213
-
+        // TODO SkImageGenerator::getPixels with smaller size implies downscalling, not a subset
         SkBitmap full;
         if (!generator->tryGenerateBitmap(&full, genInfo, allocator)) {
             return false;
         }
         if (!bitmap->tryAllocPixels(fInfo, nullptr, full.getColorTable())) {
             return false;
         }
         return full.readPixels(bitmap->info(), bitmap->getPixels(), bitmap->rowBytes(),
                                fOrigin.x(), fOrigin.y());
     }
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
 
-bool SkImageCacherator::tryLockAsBitmap(SkBitmap* bitmap, const SkImage* client) {
-    if (SkBitmapCache::Find(fUniqueID, bitmap)) {
-        return check_output_bitmap(*bitmap, fUniqueID);
+static bool bitmap_fits_scale(const SkISize &fullSize, const SkBitmap *scaled, const SkScalar scaleHint) {
+    // This optimization is about memory and required quality - it is not about sample cost of large textures on GPU:
+    // if the bitmap is already available and larger than hinted, use it.
+    if (scaled->width() < SkScalarFloorToInt(scaleHint * SkIntToScalar(fullSize.width())))
+        return false;
+    return true;
+}
+
+bool SkImageCacherator::tryLockAsBitmap(SkBitmap* bitmap, const SkImage* client, const SkScalar scaleHint) {
+    bool foundInCache = SkBitmapCache::Find(fUniqueID, bitmap);
+    if (foundInCache) {
+        if (bitmap_fits_scale(info().dimensions(), bitmap, scaleHint)) {
+            return check_output_bitmap(*bitmap, fUniqueID);
+        }
+        // if it doesn't fit the size, generate new one
     }
 
-    if (!this->generateBitmap(bitmap)) {
+    if (!this->generateBitmap(bitmap, scaleHint)) {
         return false;
     }
 
     bitmap->pixelRef()->setImmutableWithID(fUniqueID);
+    // if inadequate scale was in cache, remove it from cache first
+    if (foundInCache)
+        SkNotifyBitmapGenIDIsStale(fUniqueID);
     SkBitmapCache::Add(fUniqueID, *bitmap);
     if (client) {
         as_IB(client)->notifyAddedToCache();
     }
 
     return true;
 }
 
-bool SkImageCacherator::lockAsBitmap(SkBitmap* bitmap, const SkImage* client) {
-    if (this->tryLockAsBitmap(bitmap, client)) {
+bool SkImageCacherator::lockAsBitmap(SkBitmap* bitmap, const SkImage* client, SkScalar scaleHint) {
+    if (this->tryLockAsBitmap(bitmap, client, scaleHint)) {
         return check_output_bitmap(*bitmap, fUniqueID);
     }
 
 #if SK_SUPPORT_GPU
     // Try to get a texture and read it back to raster (and then cache that with our ID)
     SkAutoTUnref<GrTexture> tex;
 
     {
         ScopedGenerator generator(this);
         SkIRect subset = SkIRect::MakeXYWH(fOrigin.x(), fOrigin.y(), fInfo.width(), fInfo.height());
@@ skipping 34 matching lines @@
 
 static GrTexture* load_compressed_into_texture(GrContext* ctx, SkData* data, GrSurfaceDesc desc) {
     const void* rawStart;
     GrPixelConfig config = GrIsCompressedTextureDataSupported(ctx, data, desc.fWidth, desc.fHeight,
                                                               &rawStart);
     if (kUnknown_GrPixelConfig == config) {
         return nullptr;
     }
 
     desc.fConfig = config;
+
     return ctx->textureProvider()->createTexture(desc, true, rawStart, 0);
 }
 
 class Generator_GrYUVProvider : public GrYUVProvider {
     SkImageGenerator* fGen;
 
 public:
     Generator_GrYUVProvider(SkImageGenerator* gen) : fGen(gen) {}
 
     uint32_t onGetID() override { return fGen->uniqueID(); }
@@ skipping 134 matching lines @@
 }
 
 #else
 
 GrTexture* SkImageCacherator::lockAsTexture(GrContext* ctx, const GrTextureParams&,
                                             const SkImage* client) {
     return nullptr;
 }
 
 #endif