Add medium image quality to software predecode.

cc/tiles/software_image_decode_controller.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/tiles/software_image_decode_controller.h"
 
 #include <stdint.h>
 
+#include <algorithm>
 #include <functional>
 
 #include "base/format_macros.h"
 #include "base/macros.h"
 #include "base/memory/discardable_memory.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/trace_event/memory_dump_manager.h"
@@ skipping 70 matching lines @@
 
  private:
   SoftwareImageDecodeController* controller_;
   SoftwareImageDecodeController::ImageKey image_key_;
   DrawImage image_;
   const ImageDecodeController::TracingInfo tracing_info_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageDecodeTaskImpl);
 };
 
+// Most images are scaled from the source image's size to the target size.
+// But in the case of mipmaps, we are scaling from the mip level which is
+// larger than we need.
+// This function gets the scale of the mip level which will be used.
+SkSize GetMipMapScaleAdjustment(const gfx::Size& src_size,
+                                const gfx::Size& target_size) {
+  int src_height = src_size.height();
+  int src_width = src_size.width();
+  int target_height = target_size.height();
+  int target_width = target_size.width();
+  if (target_height == 0 || target_width == 0) {
+    return SkSize::Make(-1.f, -1.f);
+  }
+
+  int next_mip_height = src_height;
+  int next_mip_width = src_width;
+  for (int current_mip_level = 0;; current_mip_level++) {
+    int mip_height = next_mip_height;
+    int mip_width = next_mip_width;
+
+    next_mip_height = std::max(1, src_height / (1 << (current_mip_level + 1)));
+    next_mip_width = std::max(1, src_width / (1 << (current_mip_level + 1)));
+
+    // Check if an axis on the next mip level would be smaller than the target.
+    // If so, use the current mip level.
+    // This effectively always uses the larger image and always scales down.
+    if (next_mip_height < target_height || next_mip_width < target_width) {
+      SkScalar y_scale = static_cast<float>(mip_height) / src_height;
+      SkScalar x_scale = static_cast<float>(mip_width) / src_width;
+
+      return SkSize::Make(x_scale, y_scale);
+    }
+
+    if (mip_height == 1 && mip_width == 1) {
+      // We have reached the final mip level
+      if (target_height == 1 && target_width == 1) {

[vmpstr, 2016/05/02 23:13:16]

nit: don't need this if anymore

[cblume, 2016/05/02 23:35:14]

Wait, I think we might, right?
This isn't for 1.0x scale.
This is for the mipmap level that is 1x1.

[vmpstr, 2016/05/02 23:39:06]

Right, it has to be 1x1 here, since if it's > then we would've returned already
and if it's 0x1 then we would've earlied out earlier.

[cblume, 2016/05/02 23:59:20]

Done.

+        SkScalar y_scale = static_cast<float>(mip_height) / src_height;
+        SkScalar x_scale = static_cast<float>(mip_width) / src_width;
+
+        return SkSize::Make(x_scale, y_scale);
+      }
+
+      break;
+    }
+  }
+
+  NOTREACHED();
+  return SkSize::Make(-1.f, -1.f);
+}
+
 SkSize GetScaleAdjustment(const ImageDecodeControllerKey& key) {
   // If the requested filter quality did not require scale, then the adjustment
   // is identity.
-  if (key.can_use_original_decode())
+  if (key.can_use_original_decode()) {
     return SkSize::Make(1.f, 1.f);
-
-  float x_scale =
-      key.target_size().width() / static_cast<float>(key.src_rect().width());
-  float y_scale =
-      key.target_size().height() / static_cast<float>(key.src_rect().height());
-  return SkSize::Make(x_scale, y_scale);
+  } else if (key.filter_quality() == kMedium_SkFilterQuality) {
+    return GetMipMapScaleAdjustment(key.src_rect().size(), key.target_size());
+  } else {
+    float x_scale =
+        key.target_size().width() / static_cast<float>(key.src_rect().width());
+    float y_scale = key.target_size().height() /
+                    static_cast<float>(key.src_rect().height());
+    return SkSize::Make(x_scale, y_scale);
+  }
 }
 
 SkFilterQuality GetDecodedFilterQuality(const ImageDecodeControllerKey& key) {
   return std::min(key.filter_quality(), kLow_SkFilterQuality);
 }
 
 SkImageInfo CreateImageInfo(size_t width,
                             size_t height,
                             ResourceFormat format) {
   return SkImageInfo::Make(width, height,
@@ skipping 61 matching lines @@
                "SoftwareImageDecodeController::GetTaskForImageAndRef", "key",
                key.ToString());
 
   // If the target size is empty, we can skip this image during draw (and thus
   // we don't need to decode it or ref it).
   if (key.target_size().IsEmpty()) {
     *task = nullptr;
     return false;
   }
 
-  // If we're not going to do a scale, we will just create a task to preroll the
-  // image the first time we see it. This doesn't need to account for memory.
-  // TODO(vmpstr): We can also lock the original sized image, in which case it
-  // does require memory bookkeeping.
-  if (!CanHandleImage(key)) {
-    base::AutoLock lock(lock_);
-    if (prerolled_images_.count(key.image_id()) == 0) {
-      scoped_refptr<TileTask>& existing_task = pending_image_tasks_[key];
-      if (!existing_task) {
-        existing_task = make_scoped_refptr(
-            new ImageDecodeTaskImpl(this, key, image, tracing_info));
-      }
-      *task = existing_task;
-    } else {
-      *task = nullptr;
-    }
-    return false;
-  }
-
   base::AutoLock lock(lock_);
 
   // If we already have the image in cache, then we can return it.
   auto decoded_it = decoded_images_.Get(key);
   bool new_image_fits_in_memory =
       locked_images_budget_.AvailableMemoryBytes() >= key.locked_bytes();
   if (decoded_it != decoded_images_.end()) {
     bool image_was_locked = decoded_it->second->is_locked();
     if (image_was_locked ||
         (new_image_fits_in_memory && decoded_it->second->Lock())) {
@@ skipping 62 matching lines @@
 }
 
 void SoftwareImageDecodeController::UnrefImage(const DrawImage& image) {
   // When we unref the image, there are several situations we need to consider:
   // 1. The ref did not reach 0, which means we have to keep the image locked.
   // 2. The ref reached 0, we should unlock it.
   //   2a. The image isn't in the locked cache because we didn't get to decode
   //       it yet (or failed to decode it).
   //   2b. Unlock the image but keep it in list.
   const ImageKey& key = ImageKey::FromDrawImage(image);
-  DCHECK(CanHandleImage(key)) << key.ToString();
   TRACE_EVENT1("disabled-by-default-cc.debug",
                "SoftwareImageDecodeController::UnrefImage", "key",
                key.ToString());
 
   base::AutoLock lock(lock_);
   auto ref_count_it = decoded_images_ref_counts_.find(key);
   DCHECK(ref_count_it != decoded_images_ref_counts_.end());
 
   --ref_count_it->second;
   if (ref_count_it->second == 0) {
@@ skipping 10 matching lines @@
     DCHECK(decoded_image_it->second->is_locked());
     decoded_image_it->second->Unlock();
   }
   SanityCheckState(__LINE__, true);
 }
 
 void SoftwareImageDecodeController::DecodeImage(const ImageKey& key,
                                                 const DrawImage& image) {
   TRACE_EVENT1("cc", "SoftwareImageDecodeController::DecodeImage", "key",
                key.ToString());
-  if (!CanHandleImage(key)) {
-    image.image()->preroll();
-
-    base::AutoLock lock(lock_);
-    prerolled_images_.insert(key.image_id());
-    // Erase the pending task from the queue, since the task won't be doing
-    // anything useful after this function terminates. Since we don't preroll
-    // images twice, this is actually not necessary but it behaves similar to
-    // the other code path: when this function finishes, the task isn't in the
-    // pending_image_tasks_ list.
-    pending_image_tasks_.erase(key);
-    return;
-  }
-
   base::AutoLock lock(lock_);
   AutoRemoveKeyFromTaskMap remove_key_from_task_map(&pending_image_tasks_, key);
 
   // We could have finished all of the raster tasks (cancelled) while the task
   // was just starting to run. Since this task already started running, it
   // wasn't cancelled. So, if the ref count for the image is 0 then we can just
   // abort.
   if (decoded_images_ref_counts_.find(key) ==
       decoded_images_ref_counts_.end()) {
     return;
@@ skipping 51 matching lines @@
                key.ToString());
   sk_sp<const SkImage> image = draw_image.image();
   if (!image)
     return nullptr;
 
   switch (key.filter_quality()) {
     case kNone_SkFilterQuality:
     case kLow_SkFilterQuality:
       return GetOriginalImageDecode(key, std::move(image));
     case kMedium_SkFilterQuality:
-      NOTIMPLEMENTED();
-      return nullptr;
     case kHigh_SkFilterQuality:
       return GetScaledImageDecode(key, std::move(image));
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 DecodedDrawImage SoftwareImageDecodeController::GetDecodedImageForDraw(
     const DrawImage& draw_image) {
   ImageKey key = ImageKey::FromDrawImage(draw_image);
   TRACE_EVENT1("disabled-by-default-cc.debug",
                "SoftwareImageDecodeController::GetDecodedImageForDraw", "key",
                key.ToString());
   // If the target size is empty, we can skip this image draw.
   if (key.target_size().IsEmpty())
     return DecodedDrawImage(nullptr, kNone_SkFilterQuality);
 
-  if (!CanHandleImage(key))
-    return DecodedDrawImage(draw_image.image(), draw_image.filter_quality());
-
   return GetDecodedImageForDrawInternal(key, draw_image);
 }
 
 DecodedDrawImage SoftwareImageDecodeController::GetDecodedImageForDrawInternal(
     const ImageKey& key,
     const DrawImage& draw_image) {
   TRACE_EVENT1("disabled-by-default-cc.debug",
                "SoftwareImageDecodeController::GetDecodedImageForDrawInternal",
                "key", key.ToString());
   base::AutoLock lock(lock_);
@@ skipping 157 matching lines @@
   {
     TRACE_EVENT0(
         "disabled-by-default-cc.debug",
         "SoftwareImageDecodeController::ScaleImage - allocate scaled pixels");
     scaled_pixels = base::DiscardableMemoryAllocator::GetInstance()
                         ->AllocateLockedDiscardableMemory(
                             scaled_info.minRowBytes() * scaled_info.height());
   }
   SkPixmap scaled_pixmap(scaled_info, scaled_pixels->data(),
                          scaled_info.minRowBytes());
-  // TODO(vmpstr): Start handling more than just high filter quality.
-  DCHECK_EQ(kHigh_SkFilterQuality, key.filter_quality());
+  DCHECK(key.filter_quality() == kHigh_SkFilterQuality ||
+         key.filter_quality() == kMedium_SkFilterQuality);
   {
     TRACE_EVENT0("disabled-by-default-cc.debug",
                  "SoftwareImageDecodeController::ScaleImage - scale pixels");
     bool result =
         decoded_pixmap.scalePixels(scaled_pixmap, key.filter_quality());
     DCHECK(result) << key.ToString();
   }
 
   // Release the original sized decode. Any other intermediate result to release
   // would be the subrect memory. However, that's in a scoped_ptr and will be
   // deleted automatically when we return.
   DrawWithImageFinished(original_size_draw_image, decoded_draw_image);
 
   return base::WrapUnique(
       new DecodedImage(scaled_info, std::move(scaled_pixels),
                        SkSize::Make(-key.src_rect().x(), -key.src_rect().y()),
                        next_tracing_id_.GetNext()));
 }
 
 void SoftwareImageDecodeController::DrawWithImageFinished(
     const DrawImage& image,
     const DecodedDrawImage& decoded_image) {
   TRACE_EVENT1("disabled-by-default-cc.debug",
                "SoftwareImageDecodeController::DrawWithImageFinished", "key",
                ImageKey::FromDrawImage(image).ToString());
   ImageKey key = ImageKey::FromDrawImage(image);
-  if (!decoded_image.image() || !CanHandleImage(key))
+  if (!decoded_image.image())
     return;
 
   if (decoded_image.is_at_raster_decode())
     UnrefAtRasterImage(key);
   else
     UnrefImage(image);
   SanityCheckState(__LINE__, false);
 }
 
 void SoftwareImageDecodeController::RefAtRasterImage(const ImageKey& key) {
@@ skipping 46 matching lines @@
       DCHECK(decoded_images_ref_counts_.find(key) ==
              decoded_images_ref_counts_.end());
       at_raster_image_it->second->Unlock();
       decoded_images_.Erase(image_it);
       decoded_images_.Put(key, std::move(at_raster_image_it->second));
     }
     at_raster_decoded_images_.Erase(at_raster_image_it);
   }
 }
 
-bool SoftwareImageDecodeController::CanHandleImage(const ImageKey& key) {
-  // TODO(vmpstr): Start handling medium filter quality as well.
-  return key.filter_quality() != kMedium_SkFilterQuality;
-}
-
 void SoftwareImageDecodeController::ReduceCacheUsage() {
   TRACE_EVENT0("cc", "SoftwareImageDecodeController::ReduceCacheUsage");
   base::AutoLock lock(lock_);
   size_t num_to_remove = (decoded_images_.size() > kMaxItemsInCache)
                              ? (decoded_images_.size() - kMaxItemsInCache)
                              : 0;
   for (auto it = decoded_images_.rbegin();
        num_to_remove != 0 && it != decoded_images_.rend();) {
     if (it->second->is_locked()) {
       ++it;
@@ skipping 131 matching lines @@
   bool can_use_original_decode =
       quality == kLow_SkFilterQuality || quality == kNone_SkFilterQuality;
 
   // If we're going to use the original decode, then the target size should be
   // the full image size, since that will allow for proper memory accounting.
   // Note we skip the decode if the target size is empty altogether, so don't
   // update the target size in that case.
   if (can_use_original_decode && !target_size.IsEmpty())
     target_size = gfx::Size(image.image()->width(), image.image()->height());
 
+  if (quality == kMedium_SkFilterQuality && !target_size.IsEmpty()) {
+    SkSize mip_target_size =
+        GetMipMapScaleAdjustment(src_rect.size(), target_size);

[vmpstr, 2016/05/02 23:13:16]

nit: dcheck mipmap scale != -1?

[cblume, 2016/05/02 23:35:14]

Done.

+    target_size.set_width(src_rect.width() * mip_target_size.width());
+    target_size.set_height(src_rect.height() * mip_target_size.height());
+  }
+
   return ImageDecodeControllerKey(image.image()->uniqueID(), src_rect,
                                   target_size, quality,
                                   can_use_original_decode);
 }
 
 ImageDecodeControllerKey::ImageDecodeControllerKey(
     uint32_t image_id,
     const gfx::Rect& src_rect,
     const gfx::Size& target_size,
     SkFilterQuality filter_quality,
@@ skipping 92 matching lines @@
 void SoftwareImageDecodeController::MemoryBudget::ResetUsage() {
   current_usage_bytes_ = 0;
 }
 
 size_t SoftwareImageDecodeController::MemoryBudget::GetCurrentUsageSafe()
     const {
   return current_usage_bytes_.ValueOrDie();
 }
 
 }  // namespace cc