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 "components/favicon_base/select_favicon_frames.h"
6
7 #include <algorithm>
8 #include <cmath>
9 #include <limits>
10 #include <map>
11 #include <set>
12
13 #include "components/favicon_base/favicon_util.h"
14 #include "skia/ext/image_operations.h"
15 #include "third_party/skia/include/core/SkCanvas.h"
16 #include "ui/gfx/image/image.h"
17 #include "ui/gfx/image/image_skia.h"
18 #include "ui/gfx/image/image_skia_source.h"
19 #include "ui/gfx/size.h"
20
21 namespace {
22
BiggestCandidate(const std::vector<gfx::Size> & candidate_sizes)23 size_t BiggestCandidate(const std::vector<gfx::Size>& candidate_sizes) {
24 size_t max_index = 0;
25 int max_area = candidate_sizes[0].GetArea();
26 for (size_t i = 1; i < candidate_sizes.size(); ++i) {
27 int area = candidate_sizes[i].GetArea();
28 if (area > max_area) {
29 max_area = area;
30 max_index = i;
31 }
32 }
33 return max_index;
34 }
35
SampleNearestNeighbor(const SkBitmap & contents,int desired_size)36 SkBitmap SampleNearestNeighbor(const SkBitmap& contents, int desired_size) {
37 SkBitmap bitmap;
38 bitmap.setConfig(SkBitmap::kARGB_8888_Config, desired_size, desired_size);
39 bitmap.allocPixels();
40 if (!contents.isOpaque())
41 bitmap.eraseARGB(0, 0, 0, 0);
42
43 {
44 SkCanvas canvas(bitmap);
45 SkRect dest(SkRect::MakeWH(desired_size, desired_size));
46 canvas.drawBitmapRect(contents, NULL, dest);
47 }
48
49 return bitmap;
50 }
51
GetCandidateIndexWithBestScore(const std::vector<gfx::Size> & candidate_sizes,int desired_size,float * score)52 size_t GetCandidateIndexWithBestScore(
53 const std::vector<gfx::Size>& candidate_sizes,
54 int desired_size,
55 float* score) {
56 DCHECK_NE(desired_size, 0);
57
58 // Try to find an exact match.
59 for (size_t i = 0; i < candidate_sizes.size(); ++i) {
60 if (candidate_sizes[i].width() == desired_size &&
61 candidate_sizes[i].height() == desired_size) {
62 *score = 1;
63 return i;
64 }
65 }
66
67 // Huge favicon bitmaps often have a completely different visual style from
68 // smaller favicon bitmaps. Avoid them.
69 const int kHugeEdgeSize = desired_size * 8;
70
71 // Order of preference:
72 // 1) Bitmaps with width and height smaller than |kHugeEdgeSize|.
73 // 2) Bitmaps which need to be scaled down instead of up.
74 // 3) Bitmaps which do not need to be scaled as much.
75 size_t candidate_index = std::numeric_limits<size_t>::max();
76 float candidate_score = 0;
77 for (size_t i = 0; i < candidate_sizes.size(); ++i) {
78 float average_edge =
79 (candidate_sizes[i].width() + candidate_sizes[i].height()) / 2.0f;
80
81 float score = 0;
82 if (candidate_sizes[i].width() >= kHugeEdgeSize ||
83 candidate_sizes[i].height() >= kHugeEdgeSize) {
84 score = std::min(1.0f, desired_size / average_edge) * 0.01f;
85 } else if (candidate_sizes[i].width() >= desired_size &&
86 candidate_sizes[i].height() >= desired_size) {
87 score = desired_size / average_edge * 0.01f + 0.15f;
88 } else {
89 score = std::min(1.0f, average_edge / desired_size) * 0.01f + 0.1f;
90 }
91
92 if (candidate_index == std::numeric_limits<size_t>::max() ||
93 score > candidate_score) {
94 candidate_index = i;
95 candidate_score = score;
96 }
97 }
98 *score = candidate_score;
99
100 return candidate_index;
101 }
102
103 // Represents the index of the best candidate for |desired_size| from the
104 // |candidate_sizes| passed into GetCandidateIndicesWithBestScores().
105 struct SelectionResult {
106 // index in |candidate_sizes| of the best candidate.
107 size_t index;
108
109 // The desired size for which |index| is the best candidate.
110 int desired_size;
111 };
112
GetCandidateIndicesWithBestScores(const std::vector<gfx::Size> & candidate_sizes,const std::vector<int> & desired_sizes,float * match_score,std::vector<SelectionResult> * results)113 void GetCandidateIndicesWithBestScores(
114 const std::vector<gfx::Size>& candidate_sizes,
115 const std::vector<int>& desired_sizes,
116 float* match_score,
117 std::vector<SelectionResult>* results) {
118 if (candidate_sizes.empty() || desired_sizes.empty()) {
119 if (match_score)
120 *match_score = 0.0f;
121 return;
122 }
123
124 std::vector<int>::const_iterator zero_size_it =
125 std::find(desired_sizes.begin(), desired_sizes.end(), 0);
126 if (zero_size_it != desired_sizes.end()) {
127 // Just return the biggest image available.
128 SelectionResult result;
129 result.index = BiggestCandidate(candidate_sizes);
130 result.desired_size = 0;
131 results->push_back(result);
132 if (match_score)
133 *match_score = 1.0f;
134 return;
135 }
136
137 float total_score = 0;
138 for (size_t i = 0; i < desired_sizes.size(); ++i) {
139 float score;
140 SelectionResult result;
141 result.desired_size = desired_sizes[i];
142 result.index = GetCandidateIndexWithBestScore(
143 candidate_sizes, result.desired_size, &score);
144 results->push_back(result);
145 total_score += score;
146 }
147
148 if (match_score)
149 *match_score = total_score / desired_sizes.size();
150 }
151
152 // Resize |source_bitmap|
GetResizedBitmap(const SkBitmap & source_bitmap,gfx::Size original_size,int desired_size_in_pixel)153 SkBitmap GetResizedBitmap(const SkBitmap& source_bitmap,
154 gfx::Size original_size,
155 int desired_size_in_pixel) {
156 if (desired_size_in_pixel == 0 ||
157 (original_size.width() == desired_size_in_pixel &&
158 original_size.height() == desired_size_in_pixel)) {
159 return source_bitmap;
160 }
161 if (desired_size_in_pixel % original_size.width() == 0 &&
162 desired_size_in_pixel % original_size.height() == 0) {
163 return SampleNearestNeighbor(source_bitmap, desired_size_in_pixel);
164 }
165 return skia::ImageOperations::Resize(source_bitmap,
166 skia::ImageOperations::RESIZE_LANCZOS3,
167 desired_size_in_pixel,
168 desired_size_in_pixel);
169 }
170
171 class FaviconImageSource : public gfx::ImageSkiaSource {
172 public:
FaviconImageSource()173 FaviconImageSource() {}
~FaviconImageSource()174 virtual ~FaviconImageSource() {}
175
176 // gfx::ImageSkiaSource:
GetImageForScale(float scale)177 virtual gfx::ImageSkiaRep GetImageForScale(float scale) OVERRIDE {
178 const gfx::ImageSkiaRep* rep = NULL;
179 // gfx::ImageSkia passes one of the resource scale factors. The source
180 // should return:
181 // 1) The ImageSkiaRep with the highest scale if all available
182 // scales are smaller than |scale|.
183 // 2) The ImageSkiaRep with the smallest one that is larger than |scale|.
184 // Note: Keep this logic consistent with the PNGImageSource in
185 // ui/gfx/image.cc.
186 // TODO(oshima): consolidate these logic into one place.
187 for (std::vector<gfx::ImageSkiaRep>::const_iterator iter =
188 image_skia_reps_.begin();
189 iter != image_skia_reps_.end(); ++iter) {
190 if ((*iter).scale() == scale)
191 return (*iter);
192 if (!rep || rep->scale() < (*iter).scale())
193 rep = &(*iter);
194 if (rep->scale() >= scale)
195 break;
196 }
197 DCHECK(rep);
198 return rep ? *rep : gfx::ImageSkiaRep();
199 }
200
AddImageSkiaRep(const gfx::ImageSkiaRep & rep)201 void AddImageSkiaRep(const gfx::ImageSkiaRep& rep) {
202 image_skia_reps_.push_back(rep);
203 }
204
205 private:
206 std::vector<gfx::ImageSkiaRep> image_skia_reps_;
207 DISALLOW_COPY_AND_ASSIGN(FaviconImageSource);
208 };
209
210 } // namespace
211
212 const float kSelectFaviconFramesInvalidScore = -1.0f;
213
CreateFaviconImageSkia(const std::vector<SkBitmap> & bitmaps,const std::vector<gfx::Size> & original_sizes,int desired_size_in_dip,float * score)214 gfx::ImageSkia CreateFaviconImageSkia(
215 const std::vector<SkBitmap>& bitmaps,
216 const std::vector<gfx::Size>& original_sizes,
217 int desired_size_in_dip,
218 float* score) {
219
220 const std::vector<float>& favicon_scales = favicon_base::GetFaviconScales();
221 std::vector<int> desired_sizes;
222
223 if (desired_size_in_dip == 0) {
224 desired_sizes.push_back(0);
225 } else {
226 for (std::vector<float>::const_iterator iter = favicon_scales.begin();
227 iter != favicon_scales.end(); ++iter) {
228 desired_sizes.push_back(ceil(desired_size_in_dip * (*iter)));
229 }
230 }
231
232 std::vector<SelectionResult> results;
233 GetCandidateIndicesWithBestScores(original_sizes,
234 desired_sizes,
235 score,
236 &results);
237 if (results.size() == 0)
238 return gfx::ImageSkia();
239
240 if (desired_size_in_dip == 0) {
241 size_t index = results[0].index;
242 return gfx::ImageSkia(gfx::ImageSkiaRep(bitmaps[index], 1.0f));
243 }
244
245 FaviconImageSource* image_source = new FaviconImageSource;
246
247 for (size_t i = 0; i < results.size(); ++i) {
248 size_t index = results[i].index;
249 image_source->AddImageSkiaRep(
250 gfx::ImageSkiaRep(GetResizedBitmap(bitmaps[index],
251 original_sizes[index],
252 desired_sizes[i]),
253 favicon_scales[i]));
254 }
255 return gfx::ImageSkia(image_source,
256 gfx::Size(desired_size_in_dip, desired_size_in_dip));
257 }
258
SelectFaviconFrameIndices(const std::vector<gfx::Size> & frame_pixel_sizes,const std::vector<int> & desired_sizes,std::vector<size_t> * best_indices,float * match_score)259 void SelectFaviconFrameIndices(const std::vector<gfx::Size>& frame_pixel_sizes,
260 const std::vector<int>& desired_sizes,
261 std::vector<size_t>* best_indices,
262 float* match_score) {
263 std::vector<SelectionResult> results;
264 GetCandidateIndicesWithBestScores(
265 frame_pixel_sizes, desired_sizes, match_score, &results);
266
267 std::set<size_t> already_added;
268 for (size_t i = 0; i < results.size(); ++i) {
269 size_t index = results[i].index;
270 // GetCandidateIndicesWithBestScores() will return duplicate indices if the
271 // bitmap data with |frame_pixel_sizes[index]| should be used for multiple
272 // scale factors. Remove duplicates here such that |best_indices| contains
273 // no duplicates.
274 if (already_added.find(index) == already_added.end()) {
275 already_added.insert(index);
276 best_indices->push_back(index);
277 }
278 }
279 }
280