cc/playback/pixel_ref_map.cc

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/playback/pixel_ref_map.h"
   6
   7 #include <algorithm>
   8 #include <limits>
   9
  10 #include "cc/base/math_util.h"
  11 #include "cc/playback/display_item_list.h"
  12 #include "cc/playback/picture.h"
  13 #include "skia/ext/pixel_ref_utils.h"
  14
  15 namespace cc {
  16
  17 PixelRefMap::PixelRefMap(const gfx::Size& cell_size) : cell_size_(cell_size) {
  18   DCHECK(!cell_size.IsEmpty());
  19 }
  20
  21 PixelRefMap::~PixelRefMap() {
  22 }
  23
  24 void PixelRefMap::GatherPixelRefsFromPicture(SkPicture* picture) {
  25   DCHECK(picture);
  26
  27   int min_x = std::numeric_limits<int>::max();
  28   int min_y = std::numeric_limits<int>::max();
  29   int max_x = 0;
  30   int max_y = 0;
  31
  32   skia::DiscardablePixelRefList pixel_refs;
  33   skia::PixelRefUtils::GatherDiscardablePixelRefs(picture, &pixel_refs);
  34   for (skia::DiscardablePixelRefList::const_iterator it = pixel_refs.begin();
  35        it != pixel_refs.end(); ++it) {
  36     gfx::Point min(MathUtil::RoundDown(static_cast<int>(it->pixel_ref_rect.x()),
  37                                        cell_size_.width()),
  38                    MathUtil::RoundDown(static_cast<int>(it->pixel_ref_rect.y()),
  39                                        cell_size_.height()));
  40     gfx::Point max(MathUtil::RoundDown(
  41                        static_cast<int>(std::ceil(it->pixel_ref_rect.right())),
  42                        cell_size_.width()),
  43                    MathUtil::RoundDown(
  44                        static_cast<int>(std::ceil(it->pixel_ref_rect.bottom())),
  45                        cell_size_.height()));
  46
  47     for (int y = min.y(); y <= max.y(); y += cell_size_.height()) {
  48       for (int x = min.x(); x <= max.x(); x += cell_size_.width()) {
  49         PixelRefMapKey key(x, y);
  50         data_hash_map_[key].push_back(it->pixel_ref);
  51       }
  52     }
  53
  54     min_x = std::min(min_x, min.x());
  55     min_y = std::min(min_y, min.y());
  56     max_x = std::max(max_x, max.x());
  57     max_y = std::max(max_y, max.y());
  58   }
  59
  60   min_pixel_cell_ = gfx::Point(min_x, min_y);
  61   max_pixel_cell_ = gfx::Point(max_x, max_y);
  62 }
  63
  64 base::LazyInstance<PixelRefs> PixelRefMap::Iterator::empty_pixel_refs_;
  65
  66 PixelRefMap::Iterator::Iterator()
  67     : target_pixel_ref_map_(NULL),
  68       current_pixel_refs_(empty_pixel_refs_.Pointer()),
  69       current_index_(0),
  70       min_point_(-1, -1),
  71       max_point_(-1, -1),
  72       current_x_(0),
  73       current_y_(0) {
  74 }
  75
  76 PixelRefMap::Iterator::Iterator(const gfx::Rect& rect, const Picture* picture)
  77     : target_pixel_ref_map_(&(picture->pixel_refs_)),
  78       current_pixel_refs_(empty_pixel_refs_.Pointer()),
  79       current_index_(0) {
  80   map_layer_rect_ = picture->layer_rect_;
  81   PointToFirstPixelRef(rect);
  82 }
  83
  84 PixelRefMap::Iterator::Iterator(const gfx::Rect& rect,
  85                                 const DisplayItemList* display_list)
  86     : target_pixel_ref_map_(display_list->pixel_refs_.get()),
  87       current_pixel_refs_(empty_pixel_refs_.Pointer()),
  88       current_index_(0) {
  89   map_layer_rect_ = display_list->layer_rect_;
  90   PointToFirstPixelRef(rect);
  91 }
  92
  93 PixelRefMap::Iterator::~Iterator() {
  94 }
  95
  96 PixelRefMap::Iterator& PixelRefMap::Iterator::operator++() {
  97   ++current_index_;
  98   // If we're not at the end of the list, then we have the next item.
  99   if (current_index_ < current_pixel_refs_->size())
 100     return *this;
 101
 102   DCHECK(current_y_ <= max_point_.y());
 103   while (true) {
 104     gfx::Size cell_size = target_pixel_ref_map_->cell_size_;
 105
 106     // Advance the current grid cell.
 107     current_x_ += cell_size.width();
 108     if (current_x_ > max_point_.x()) {
 109       current_y_ += cell_size.height();
 110       current_x_ = min_point_.x();
 111       if (current_y_ > max_point_.y()) {
 112         current_pixel_refs_ = empty_pixel_refs_.Pointer();
 113         current_index_ = 0;
 114         break;
 115       }
 116     }
 117
 118     // If there are no pixel refs at this grid cell, keep incrementing.
 119     PixelRefMapKey key(current_x_, current_y_);
 120     PixelRefHashmap::const_iterator iter =
 121         target_pixel_ref_map_->data_hash_map_.find(key);
 122     if (iter == target_pixel_ref_map_->data_hash_map_.end())
 123       continue;
 124
 125     // We found a non-empty list: store it and get the first pixel ref.
 126     current_pixel_refs_ = &iter->second;
 127     current_index_ = 0;
 128     break;
 129   }
 130   return *this;
 131 }
 132
 133 void PixelRefMap::Iterator::PointToFirstPixelRef(const gfx::Rect& rect) {
 134   gfx::Rect query_rect(rect);
 135   // Early out if the query rect doesn't intersect this picture.
 136   if (!query_rect.Intersects(map_layer_rect_) || !target_pixel_ref_map_) {
 137     min_point_ = gfx::Point(0, 0);
 138     max_point_ = gfx::Point(0, 0);
 139     current_x_ = 1;
 140     current_y_ = 1;
 141     return;
 142   }
 143
 144   // First, subtract the layer origin as cells are stored in layer space.
 145   query_rect.Offset(-map_layer_rect_.OffsetFromOrigin());
 146
 147   DCHECK(!target_pixel_ref_map_->cell_size_.IsEmpty());
 148   gfx::Size cell_size(target_pixel_ref_map_->cell_size_);
 149   // We have to find a cell_size aligned point that corresponds to
 150   // query_rect. Point is a multiple of cell_size.
 151   min_point_ =
 152       gfx::Point(MathUtil::RoundDown(query_rect.x(), cell_size.width()),
 153                  MathUtil::RoundDown(query_rect.y(), cell_size.height()));
 154   max_point_ = gfx::Point(
 155       MathUtil::RoundDown(query_rect.right() - 1, cell_size.width()),
 156       MathUtil::RoundDown(query_rect.bottom() - 1, cell_size.height()));
 157
 158   // Limit the points to known pixel ref boundaries.
 159   min_point_ = gfx::Point(
 160       std::max(min_point_.x(), target_pixel_ref_map_->min_pixel_cell_.x()),
 161       std::max(min_point_.y(), target_pixel_ref_map_->min_pixel_cell_.y()));
 162   max_point_ = gfx::Point(
 163       std::min(max_point_.x(), target_pixel_ref_map_->max_pixel_cell_.x()),
 164       std::min(max_point_.y(), target_pixel_ref_map_->max_pixel_cell_.y()));
 165
 166   // Make the current x be cell_size.width() less than min point, so that
 167   // the first increment will point at min_point_.
 168   current_x_ = min_point_.x() - cell_size.width();
 169   current_y_ = min_point_.y();
 170   if (current_y_ <= max_point_.y())
 171     ++(*this);
 172 }
 173
 174 }  // namespace cc