OLD | NEW |
| (Empty) |
1 // Copyright 2014 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/resources/tiling_set_raster_queue.h" | |
6 | |
7 #include <utility> | |
8 | |
9 #include "cc/resources/picture_layer_tiling_set.h" | |
10 #include "cc/resources/tile.h" | |
11 #include "cc/resources/tile_priority.h" | |
12 | |
13 namespace cc { | |
14 | |
15 TilingSetRasterQueue::TilingSetRasterQueue() | |
16 : tiling_set_(nullptr), current_stage_(arraysize(stages_)) { | |
17 } | |
18 | |
19 TilingSetRasterQueue::TilingSetRasterQueue(PictureLayerTilingSet* tiling_set, | |
20 bool prioritize_low_res) | |
21 : tiling_set_(tiling_set), current_stage_(0) { | |
22 DCHECK(tiling_set_); | |
23 | |
24 // Early out if the tiling set has no tilings. | |
25 if (!tiling_set_->num_tilings()) { | |
26 current_stage_ = arraysize(stages_); | |
27 return; | |
28 } | |
29 | |
30 // Find high and low res tilings and initialize the iterators. | |
31 for (size_t i = 0; i < tiling_set_->num_tilings(); ++i) { | |
32 PictureLayerTiling* tiling = tiling_set_->tiling_at(i); | |
33 if (tiling->resolution() == HIGH_RESOLUTION) | |
34 iterators_[HIGH_RES] = TilingIterator(tiling, &tiling->tiling_data_); | |
35 if (prioritize_low_res && tiling->resolution() == LOW_RESOLUTION) | |
36 iterators_[LOW_RES] = TilingIterator(tiling, &tiling->tiling_data_); | |
37 } | |
38 | |
39 if (prioritize_low_res) { | |
40 stages_[0].iterator_type = LOW_RES; | |
41 stages_[0].tile_type = TilePriority::NOW; | |
42 | |
43 stages_[1].iterator_type = HIGH_RES; | |
44 stages_[1].tile_type = TilePriority::NOW; | |
45 } else { | |
46 stages_[0].iterator_type = HIGH_RES; | |
47 stages_[0].tile_type = TilePriority::NOW; | |
48 | |
49 stages_[1].iterator_type = LOW_RES; | |
50 stages_[1].tile_type = TilePriority::NOW; | |
51 } | |
52 | |
53 stages_[2].iterator_type = HIGH_RES; | |
54 stages_[2].tile_type = TilePriority::SOON; | |
55 | |
56 stages_[3].iterator_type = HIGH_RES; | |
57 stages_[3].tile_type = TilePriority::EVENTUALLY; | |
58 | |
59 IteratorType index = stages_[current_stage_].iterator_type; | |
60 TilePriority::PriorityBin tile_type = stages_[current_stage_].tile_type; | |
61 if (!iterators_[index] || iterators_[index].type() != tile_type) | |
62 AdvanceToNextStage(); | |
63 } | |
64 | |
65 TilingSetRasterQueue::~TilingSetRasterQueue() { | |
66 } | |
67 | |
68 bool TilingSetRasterQueue::IsEmpty() const { | |
69 return current_stage_ >= arraysize(stages_); | |
70 } | |
71 | |
72 void TilingSetRasterQueue::Pop() { | |
73 IteratorType index = stages_[current_stage_].iterator_type; | |
74 TilePriority::PriorityBin tile_type = stages_[current_stage_].tile_type; | |
75 | |
76 // First advance the iterator. | |
77 DCHECK(iterators_[index]); | |
78 DCHECK(iterators_[index].type() == tile_type); | |
79 ++iterators_[index]; | |
80 | |
81 if (!iterators_[index] || iterators_[index].type() != tile_type) | |
82 AdvanceToNextStage(); | |
83 } | |
84 | |
85 Tile* TilingSetRasterQueue::Top() { | |
86 DCHECK(!IsEmpty()); | |
87 | |
88 IteratorType index = stages_[current_stage_].iterator_type; | |
89 DCHECK(iterators_[index]); | |
90 DCHECK(iterators_[index].type() == stages_[current_stage_].tile_type); | |
91 | |
92 return *iterators_[index]; | |
93 } | |
94 | |
95 const Tile* TilingSetRasterQueue::Top() const { | |
96 DCHECK(!IsEmpty()); | |
97 | |
98 IteratorType index = stages_[current_stage_].iterator_type; | |
99 DCHECK(iterators_[index]); | |
100 DCHECK(iterators_[index].type() == stages_[current_stage_].tile_type); | |
101 | |
102 return *iterators_[index]; | |
103 } | |
104 | |
105 void TilingSetRasterQueue::AdvanceToNextStage() { | |
106 DCHECK_LT(current_stage_, arraysize(stages_)); | |
107 ++current_stage_; | |
108 while (current_stage_ < arraysize(stages_)) { | |
109 IteratorType index = stages_[current_stage_].iterator_type; | |
110 TilePriority::PriorityBin tile_type = stages_[current_stage_].tile_type; | |
111 | |
112 if (iterators_[index] && iterators_[index].type() == tile_type) | |
113 break; | |
114 ++current_stage_; | |
115 } | |
116 } | |
117 | |
118 TilingSetRasterQueue::TilingIterator::TilingIterator() | |
119 : tiling_(NULL), current_tile_(NULL) { | |
120 } | |
121 | |
122 TilingSetRasterQueue::TilingIterator::TilingIterator(PictureLayerTiling* tiling, | |
123 TilingData* tiling_data) | |
124 : tiling_(tiling), | |
125 tiling_data_(tiling_data), | |
126 phase_(VISIBLE_RECT), | |
127 current_tile_(NULL) { | |
128 if (!tiling_->has_visible_rect_tiles()) { | |
129 AdvancePhase(); | |
130 return; | |
131 } | |
132 | |
133 visible_iterator_ = | |
134 TilingData::Iterator(tiling_data_, tiling_->current_visible_rect(), | |
135 false /* include_borders */); | |
136 if (!visible_iterator_) { | |
137 AdvancePhase(); | |
138 return; | |
139 } | |
140 | |
141 current_tile_ = | |
142 tiling_->TileAt(visible_iterator_.index_x(), visible_iterator_.index_y()); | |
143 if (!current_tile_ || !TileNeedsRaster(current_tile_)) { | |
144 ++(*this); | |
145 return; | |
146 } | |
147 tiling_->UpdateTileAndTwinPriority(current_tile_); | |
148 } | |
149 | |
150 TilingSetRasterQueue::TilingIterator::~TilingIterator() { | |
151 } | |
152 | |
153 void TilingSetRasterQueue::TilingIterator::AdvancePhase() { | |
154 DCHECK_LT(phase_, EVENTUALLY_RECT); | |
155 | |
156 do { | |
157 phase_ = static_cast<Phase>(phase_ + 1); | |
158 switch (phase_) { | |
159 case VISIBLE_RECT: | |
160 NOTREACHED(); | |
161 return; | |
162 case SKEWPORT_RECT: | |
163 if (!tiling_->has_skewport_rect_tiles()) | |
164 continue; | |
165 | |
166 spiral_iterator_ = TilingData::SpiralDifferenceIterator( | |
167 tiling_data_, tiling_->current_skewport_rect(), | |
168 tiling_->current_visible_rect(), tiling_->current_visible_rect()); | |
169 break; | |
170 case SOON_BORDER_RECT: | |
171 if (!tiling_->has_soon_border_rect_tiles()) | |
172 continue; | |
173 | |
174 spiral_iterator_ = TilingData::SpiralDifferenceIterator( | |
175 tiling_data_, tiling_->current_soon_border_rect(), | |
176 tiling_->current_skewport_rect(), tiling_->current_visible_rect()); | |
177 break; | |
178 case EVENTUALLY_RECT: | |
179 if (!tiling_->has_eventually_rect_tiles()) { | |
180 current_tile_ = NULL; | |
181 return; | |
182 } | |
183 | |
184 spiral_iterator_ = TilingData::SpiralDifferenceIterator( | |
185 tiling_data_, tiling_->current_eventually_rect(), | |
186 tiling_->current_skewport_rect(), | |
187 tiling_->current_soon_border_rect()); | |
188 break; | |
189 } | |
190 | |
191 while (spiral_iterator_) { | |
192 current_tile_ = tiling_->TileAt(spiral_iterator_.index_x(), | |
193 spiral_iterator_.index_y()); | |
194 if (current_tile_ && TileNeedsRaster(current_tile_)) | |
195 break; | |
196 ++spiral_iterator_; | |
197 } | |
198 | |
199 if (!spiral_iterator_ && phase_ == EVENTUALLY_RECT) { | |
200 current_tile_ = NULL; | |
201 break; | |
202 } | |
203 } while (!spiral_iterator_); | |
204 | |
205 if (current_tile_) | |
206 tiling_->UpdateTileAndTwinPriority(current_tile_); | |
207 } | |
208 | |
209 TilingSetRasterQueue::TilingIterator& TilingSetRasterQueue::TilingIterator:: | |
210 operator++() { | |
211 current_tile_ = NULL; | |
212 while (!current_tile_ || !TileNeedsRaster(current_tile_)) { | |
213 std::pair<int, int> next_index; | |
214 switch (phase_) { | |
215 case VISIBLE_RECT: | |
216 ++visible_iterator_; | |
217 if (!visible_iterator_) { | |
218 AdvancePhase(); | |
219 return *this; | |
220 } | |
221 next_index = visible_iterator_.index(); | |
222 break; | |
223 case SKEWPORT_RECT: | |
224 case SOON_BORDER_RECT: | |
225 ++spiral_iterator_; | |
226 if (!spiral_iterator_) { | |
227 AdvancePhase(); | |
228 return *this; | |
229 } | |
230 next_index = spiral_iterator_.index(); | |
231 break; | |
232 case EVENTUALLY_RECT: | |
233 ++spiral_iterator_; | |
234 if (!spiral_iterator_) { | |
235 current_tile_ = NULL; | |
236 return *this; | |
237 } | |
238 next_index = spiral_iterator_.index(); | |
239 break; | |
240 } | |
241 current_tile_ = tiling_->TileAt(next_index.first, next_index.second); | |
242 } | |
243 | |
244 if (current_tile_) | |
245 tiling_->UpdateTileAndTwinPriority(current_tile_); | |
246 return *this; | |
247 } | |
248 | |
249 } // namespace cc | |
OLD | NEW |