1 /*
2 * Copyright 2013 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8 #include "SkMipMap.h"
9 #include "SkBitmap.h"
10 #include "SkColorPriv.h"
11 #include "SkHalf.h"
12 #include "SkMathPriv.h"
13 #include "SkNx.h"
14 #include "SkPM4fPriv.h"
15 #include "SkSRGB.h"
16 #include "SkTypes.h"
17
18 //
19 // ColorTypeFilter is the "Type" we pass to some downsample template functions.
20 // It controls how we expand a pixel into a large type, with space between each component,
21 // so we can then perform our simple filter (either box or triangle) and store the intermediates
22 // in the expanded type.
23 //
24
25 struct ColorTypeFilter_8888 {
26 typedef uint32_t Type;
ExpandColorTypeFilter_888827 static Sk4h Expand(uint32_t x) {
28 return SkNx_cast<uint16_t>(Sk4b::Load(&x));
29 }
CompactColorTypeFilter_888830 static uint32_t Compact(const Sk4h& x) {
31 uint32_t r;
32 SkNx_cast<uint8_t>(x).store(&r);
33 return r;
34 }
35 };
36
37 struct ColorTypeFilter_S32 {
38 typedef uint32_t Type;
ExpandColorTypeFilter_S3239 static Sk4h Expand(uint32_t x) {
40 return Sk4h(sk_linear12_from_srgb[(x ) & 0xFF],
41 sk_linear12_from_srgb[(x >> 8) & 0xFF],
42 sk_linear12_from_srgb[(x >> 16) & 0xFF],
43 (x >> 24) << 4);
44 }
CompactColorTypeFilter_S3245 static uint32_t Compact(const Sk4h& x) {
46 return sk_linear12_to_srgb[x[0]] |
47 sk_linear12_to_srgb[x[1]] << 8 |
48 sk_linear12_to_srgb[x[2]] << 16 |
49 (x[3] >> 4) << 24;
50 }
51 };
52
53 struct ColorTypeFilter_565 {
54 typedef uint16_t Type;
ExpandColorTypeFilter_56555 static uint32_t Expand(uint16_t x) {
56 return (x & ~SK_G16_MASK_IN_PLACE) | ((x & SK_G16_MASK_IN_PLACE) << 16);
57 }
CompactColorTypeFilter_56558 static uint16_t Compact(uint32_t x) {
59 return (x & ~SK_G16_MASK_IN_PLACE) | ((x >> 16) & SK_G16_MASK_IN_PLACE);
60 }
61 };
62
63 struct ColorTypeFilter_4444 {
64 typedef uint16_t Type;
ExpandColorTypeFilter_444465 static uint32_t Expand(uint16_t x) {
66 return (x & 0xF0F) | ((x & ~0xF0F) << 12);
67 }
CompactColorTypeFilter_444468 static uint16_t Compact(uint32_t x) {
69 return (x & 0xF0F) | ((x >> 12) & ~0xF0F);
70 }
71 };
72
73 struct ColorTypeFilter_8 {
74 typedef uint8_t Type;
ExpandColorTypeFilter_875 static unsigned Expand(unsigned x) {
76 return x;
77 }
CompactColorTypeFilter_878 static uint8_t Compact(unsigned x) {
79 return (uint8_t)x;
80 }
81 };
82
83 struct ColorTypeFilter_F16 {
84 typedef uint64_t Type; // SkHalf x4
ExpandColorTypeFilter_F1685 static Sk4f Expand(uint64_t x) {
86 return SkHalfToFloat_finite_ftz(x);
87 }
CompactColorTypeFilter_F1688 static uint64_t Compact(const Sk4f& x) {
89 uint64_t r;
90 SkFloatToHalf_finite_ftz(x).store(&r);
91 return r;
92 }
93 };
94
add_121(const T & a,const T & b,const T & c)95 template <typename T> T add_121(const T& a, const T& b, const T& c) {
96 return a + b + b + c;
97 }
98
shift_right(const T & x,int bits)99 template <typename T> T shift_right(const T& x, int bits) {
100 return x >> bits;
101 }
102
shift_right(const Sk4f & x,int bits)103 Sk4f shift_right(const Sk4f& x, int bits) {
104 return x * (1.0f / (1 << bits));
105 }
106
shift_left(const T & x,int bits)107 template <typename T> T shift_left(const T& x, int bits) {
108 return x << bits;
109 }
110
shift_left(const Sk4f & x,int bits)111 Sk4f shift_left(const Sk4f& x, int bits) {
112 return x * (1 << bits);
113 }
114
115 //
116 // To produce each mip level, we need to filter down by 1/2 (e.g. 100x100 -> 50,50)
117 // If the starting dimension is odd, we floor the size of the lower level (e.g. 101 -> 50)
118 // In those (odd) cases, we use a triangle filter, with 1-pixel overlap between samplings,
119 // else for even cases, we just use a 2x box filter.
120 //
121 // This produces 4 possible isotropic filters: 2x2 2x3 3x2 3x3 where WxH indicates the number of
122 // src pixels we need to sample in each dimension to produce 1 dst pixel.
123 //
124 // OpenGL expects a full mipmap stack to contain anisotropic space as well.
125 // This means a 100x1 image would continue down to a 50x1 image, 25x1 image...
126 // Because of this, we need 4 more anisotropic filters: 1x2, 1x3, 2x1, 3x1.
127
downsample_1_2(void * dst,const void * src,size_t srcRB,int count)128 template <typename F> void downsample_1_2(void* dst, const void* src, size_t srcRB, int count) {
129 SkASSERT(count > 0);
130 auto p0 = static_cast<const typename F::Type*>(src);
131 auto p1 = (const typename F::Type*)((const char*)p0 + srcRB);
132 auto d = static_cast<typename F::Type*>(dst);
133
134 for (int i = 0; i < count; ++i) {
135 auto c00 = F::Expand(p0[0]);
136 auto c10 = F::Expand(p1[0]);
137
138 auto c = c00 + c10;
139 d[i] = F::Compact(shift_right(c, 1));
140 p0 += 2;
141 p1 += 2;
142 }
143 }
144
downsample_1_3(void * dst,const void * src,size_t srcRB,int count)145 template <typename F> void downsample_1_3(void* dst, const void* src, size_t srcRB, int count) {
146 SkASSERT(count > 0);
147 auto p0 = static_cast<const typename F::Type*>(src);
148 auto p1 = (const typename F::Type*)((const char*)p0 + srcRB);
149 auto p2 = (const typename F::Type*)((const char*)p1 + srcRB);
150 auto d = static_cast<typename F::Type*>(dst);
151
152 for (int i = 0; i < count; ++i) {
153 auto c00 = F::Expand(p0[0]);
154 auto c10 = F::Expand(p1[0]);
155 auto c20 = F::Expand(p2[0]);
156
157 auto c = add_121(c00, c10, c20);
158 d[i] = F::Compact(shift_right(c, 2));
159 p0 += 2;
160 p1 += 2;
161 p2 += 2;
162 }
163 }
164
downsample_2_1(void * dst,const void * src,size_t srcRB,int count)165 template <typename F> void downsample_2_1(void* dst, const void* src, size_t srcRB, int count) {
166 SkASSERT(count > 0);
167 auto p0 = static_cast<const typename F::Type*>(src);
168 auto d = static_cast<typename F::Type*>(dst);
169
170 for (int i = 0; i < count; ++i) {
171 auto c00 = F::Expand(p0[0]);
172 auto c01 = F::Expand(p0[1]);
173
174 auto c = c00 + c01;
175 d[i] = F::Compact(shift_right(c, 1));
176 p0 += 2;
177 }
178 }
179
downsample_2_2(void * dst,const void * src,size_t srcRB,int count)180 template <typename F> void downsample_2_2(void* dst, const void* src, size_t srcRB, int count) {
181 SkASSERT(count > 0);
182 auto p0 = static_cast<const typename F::Type*>(src);
183 auto p1 = (const typename F::Type*)((const char*)p0 + srcRB);
184 auto d = static_cast<typename F::Type*>(dst);
185
186 for (int i = 0; i < count; ++i) {
187 auto c00 = F::Expand(p0[0]);
188 auto c01 = F::Expand(p0[1]);
189 auto c10 = F::Expand(p1[0]);
190 auto c11 = F::Expand(p1[1]);
191
192 auto c = c00 + c10 + c01 + c11;
193 d[i] = F::Compact(shift_right(c, 2));
194 p0 += 2;
195 p1 += 2;
196 }
197 }
198
downsample_2_3(void * dst,const void * src,size_t srcRB,int count)199 template <typename F> void downsample_2_3(void* dst, const void* src, size_t srcRB, int count) {
200 SkASSERT(count > 0);
201 auto p0 = static_cast<const typename F::Type*>(src);
202 auto p1 = (const typename F::Type*)((const char*)p0 + srcRB);
203 auto p2 = (const typename F::Type*)((const char*)p1 + srcRB);
204 auto d = static_cast<typename F::Type*>(dst);
205
206 for (int i = 0; i < count; ++i) {
207 auto c00 = F::Expand(p0[0]);
208 auto c01 = F::Expand(p0[1]);
209 auto c10 = F::Expand(p1[0]);
210 auto c11 = F::Expand(p1[1]);
211 auto c20 = F::Expand(p2[0]);
212 auto c21 = F::Expand(p2[1]);
213
214 auto c = add_121(c00, c10, c20) + add_121(c01, c11, c21);
215 d[i] = F::Compact(shift_right(c, 3));
216 p0 += 2;
217 p1 += 2;
218 p2 += 2;
219 }
220 }
221
downsample_3_1(void * dst,const void * src,size_t srcRB,int count)222 template <typename F> void downsample_3_1(void* dst, const void* src, size_t srcRB, int count) {
223 SkASSERT(count > 0);
224 auto p0 = static_cast<const typename F::Type*>(src);
225 auto d = static_cast<typename F::Type*>(dst);
226
227 auto c02 = F::Expand(p0[0]);
228 for (int i = 0; i < count; ++i) {
229 auto c00 = c02;
230 auto c01 = F::Expand(p0[1]);
231 c02 = F::Expand(p0[2]);
232
233 auto c = add_121(c00, c01, c02);
234 d[i] = F::Compact(shift_right(c, 2));
235 p0 += 2;
236 }
237 }
238
downsample_3_2(void * dst,const void * src,size_t srcRB,int count)239 template <typename F> void downsample_3_2(void* dst, const void* src, size_t srcRB, int count) {
240 SkASSERT(count > 0);
241 auto p0 = static_cast<const typename F::Type*>(src);
242 auto p1 = (const typename F::Type*)((const char*)p0 + srcRB);
243 auto d = static_cast<typename F::Type*>(dst);
244
245 auto c02 = F::Expand(p0[0]);
246 auto c12 = F::Expand(p1[0]);
247 for (int i = 0; i < count; ++i) {
248 auto c00 = c02;
249 auto c01 = F::Expand(p0[1]);
250 c02 = F::Expand(p0[2]);
251 auto c10 = c12;
252 auto c11 = F::Expand(p1[1]);
253 c12 = F::Expand(p1[2]);
254
255 auto c = add_121(c00, c01, c02) + add_121(c10, c11, c12);
256 d[i] = F::Compact(shift_right(c, 3));
257 p0 += 2;
258 p1 += 2;
259 }
260 }
261
downsample_3_3(void * dst,const void * src,size_t srcRB,int count)262 template <typename F> void downsample_3_3(void* dst, const void* src, size_t srcRB, int count) {
263 SkASSERT(count > 0);
264 auto p0 = static_cast<const typename F::Type*>(src);
265 auto p1 = (const typename F::Type*)((const char*)p0 + srcRB);
266 auto p2 = (const typename F::Type*)((const char*)p1 + srcRB);
267 auto d = static_cast<typename F::Type*>(dst);
268
269 // Given pixels:
270 // a0 b0 c0 d0 e0 ...
271 // a1 b1 c1 d1 e1 ...
272 // a2 b2 c2 d2 e2 ...
273 // We want:
274 // (a0 + 2*b0 + c0 + 2*a1 + 4*b1 + 2*c1 + a2 + 2*b2 + c2) / 16
275 // (c0 + 2*d0 + e0 + 2*c1 + 4*d1 + 2*e1 + c2 + 2*d2 + e2) / 16
276 // ...
277
278 auto c0 = F::Expand(p0[0]);
279 auto c1 = F::Expand(p1[0]);
280 auto c2 = F::Expand(p2[0]);
281 auto c = add_121(c0, c1, c2);
282 for (int i = 0; i < count; ++i) {
283 auto a = c;
284
285 auto b0 = F::Expand(p0[1]);
286 auto b1 = F::Expand(p1[1]);
287 auto b2 = F::Expand(p2[1]);
288 auto b = shift_left(add_121(b0, b1, b2), 1);
289
290 c0 = F::Expand(p0[2]);
291 c1 = F::Expand(p1[2]);
292 c2 = F::Expand(p2[2]);
293 c = add_121(c0, c1, c2);
294
295 auto sum = a + b + c;
296 d[i] = F::Compact(shift_right(sum, 4));
297 p0 += 2;
298 p1 += 2;
299 p2 += 2;
300 }
301 }
302
303 ///////////////////////////////////////////////////////////////////////////////////////////////////
304
305 // Some sRGB specific performance optimizations.
306
downsample_2_2_srgb(void * dst,const void * src,size_t srcRB,int count)307 void downsample_2_2_srgb(void* dst, const void* src, size_t srcRB, int count) {
308 const uint8_t* p0 = ((const uint8_t*) src);
309 const uint8_t* p1 = ((const uint8_t*) src) + srcRB;
310 uint8_t* d = (uint8_t*) dst;
311
312 // Given pixels:
313 // a0 b0 c0 d0 ...
314 // a1 b1 c1 d1 ...
315 // We want:
316 // (a0 + b0 + a1 + b1) / 4
317 // (c0 + d0 + c1 + d1) / 4
318 // ...
319 while (count >= 2) {
320 Sk8h a0c0 = Sk8h(sk_linear12_from_srgb[p0[ 0]],
321 sk_linear12_from_srgb[p0[ 1]],
322 sk_linear12_from_srgb[p0[ 2]],
323 p0[ 3] << 4 ,
324 sk_linear12_from_srgb[p0[ 8]],
325 sk_linear12_from_srgb[p0[ 9]],
326 sk_linear12_from_srgb[p0[10]],
327 p0[11] << 4 );
328 Sk8h b0d0 = Sk8h(sk_linear12_from_srgb[p0[ 4]],
329 sk_linear12_from_srgb[p0[ 5]],
330 sk_linear12_from_srgb[p0[ 6]],
331 p0[ 7] << 4 ,
332 sk_linear12_from_srgb[p0[12]],
333 sk_linear12_from_srgb[p0[13]],
334 sk_linear12_from_srgb[p0[14]],
335 p0[15] << 4 );
336 Sk8h a1c1 = Sk8h(sk_linear12_from_srgb[p1[ 0]],
337 sk_linear12_from_srgb[p1[ 1]],
338 sk_linear12_from_srgb[p1[ 2]],
339 p1[ 3] << 4 ,
340 sk_linear12_from_srgb[p1[ 8]],
341 sk_linear12_from_srgb[p1[ 9]],
342 sk_linear12_from_srgb[p1[10]],
343 p1[11] << 4 );
344 Sk8h b1d1 = Sk8h(sk_linear12_from_srgb[p1[ 4]],
345 sk_linear12_from_srgb[p1[ 5]],
346 sk_linear12_from_srgb[p1[ 6]],
347 p1[ 7] << 4 ,
348 sk_linear12_from_srgb[p1[12]],
349 sk_linear12_from_srgb[p1[13]],
350 sk_linear12_from_srgb[p1[14]],
351 p1[15] << 4 );
352
353 Sk8h avg = (a0c0 + b0d0 + a1c1 + b1d1) >> 2;
354 d[0] = sk_linear12_to_srgb[avg[0]];
355 d[1] = sk_linear12_to_srgb[avg[1]];
356 d[2] = sk_linear12_to_srgb[avg[2]];
357 d[3] = avg[3] >> 4;
358 d[4] = sk_linear12_to_srgb[avg[4]];
359 d[5] = sk_linear12_to_srgb[avg[5]];
360 d[6] = sk_linear12_to_srgb[avg[6]];
361 d[7] = avg[7] >> 4;
362
363 p0 += 16;
364 p1 += 16;
365 d += 8;
366 count -= 2;
367 }
368
369 if (count) {
370 downsample_2_2<ColorTypeFilter_S32>(d, p0, srcRB, count);
371 }
372 }
373
374 ///////////////////////////////////////////////////////////////////////////////////////////////////
375
AllocLevelsSize(int levelCount,size_t pixelSize)376 size_t SkMipMap::AllocLevelsSize(int levelCount, size_t pixelSize) {
377 if (levelCount < 0) {
378 return 0;
379 }
380 int64_t size = sk_64_mul(levelCount + 1, sizeof(Level)) + pixelSize;
381 if (!sk_64_isS32(size)) {
382 return 0;
383 }
384 return sk_64_asS32(size);
385 }
386
Build(const SkPixmap & src,SkDestinationSurfaceColorMode colorMode,SkDiscardableFactoryProc fact)387 SkMipMap* SkMipMap::Build(const SkPixmap& src, SkDestinationSurfaceColorMode colorMode,
388 SkDiscardableFactoryProc fact) {
389 typedef void FilterProc(void*, const void* srcPtr, size_t srcRB, int count);
390
391 FilterProc* proc_1_2 = nullptr;
392 FilterProc* proc_1_3 = nullptr;
393 FilterProc* proc_2_1 = nullptr;
394 FilterProc* proc_2_2 = nullptr;
395 FilterProc* proc_2_3 = nullptr;
396 FilterProc* proc_3_1 = nullptr;
397 FilterProc* proc_3_2 = nullptr;
398 FilterProc* proc_3_3 = nullptr;
399
400 const SkColorType ct = src.colorType();
401 const SkAlphaType at = src.alphaType();
402 const bool srgbGamma = (SkDestinationSurfaceColorMode::kGammaAndColorSpaceAware == colorMode)
403 && src.info().gammaCloseToSRGB();
404
405 switch (ct) {
406 case kRGBA_8888_SkColorType:
407 case kBGRA_8888_SkColorType:
408 if (srgbGamma) {
409 proc_1_2 = downsample_1_2<ColorTypeFilter_S32>;
410 proc_1_3 = downsample_1_3<ColorTypeFilter_S32>;
411 proc_2_1 = downsample_2_1<ColorTypeFilter_S32>;
412 proc_2_2 = downsample_2_2_srgb;
413 proc_2_3 = downsample_2_3<ColorTypeFilter_S32>;
414 proc_3_1 = downsample_3_1<ColorTypeFilter_S32>;
415 proc_3_2 = downsample_3_2<ColorTypeFilter_S32>;
416 proc_3_3 = downsample_3_3<ColorTypeFilter_S32>;
417 } else {
418 proc_1_2 = downsample_1_2<ColorTypeFilter_8888>;
419 proc_1_3 = downsample_1_3<ColorTypeFilter_8888>;
420 proc_2_1 = downsample_2_1<ColorTypeFilter_8888>;
421 proc_2_2 = downsample_2_2<ColorTypeFilter_8888>;
422 proc_2_3 = downsample_2_3<ColorTypeFilter_8888>;
423 proc_3_1 = downsample_3_1<ColorTypeFilter_8888>;
424 proc_3_2 = downsample_3_2<ColorTypeFilter_8888>;
425 proc_3_3 = downsample_3_3<ColorTypeFilter_8888>;
426 }
427 break;
428 case kRGB_565_SkColorType:
429 proc_1_2 = downsample_1_2<ColorTypeFilter_565>;
430 proc_1_3 = downsample_1_3<ColorTypeFilter_565>;
431 proc_2_1 = downsample_2_1<ColorTypeFilter_565>;
432 proc_2_2 = downsample_2_2<ColorTypeFilter_565>;
433 proc_2_3 = downsample_2_3<ColorTypeFilter_565>;
434 proc_3_1 = downsample_3_1<ColorTypeFilter_565>;
435 proc_3_2 = downsample_3_2<ColorTypeFilter_565>;
436 proc_3_3 = downsample_3_3<ColorTypeFilter_565>;
437 break;
438 case kARGB_4444_SkColorType:
439 proc_1_2 = downsample_1_2<ColorTypeFilter_4444>;
440 proc_1_3 = downsample_1_3<ColorTypeFilter_4444>;
441 proc_2_1 = downsample_2_1<ColorTypeFilter_4444>;
442 proc_2_2 = downsample_2_2<ColorTypeFilter_4444>;
443 proc_2_3 = downsample_2_3<ColorTypeFilter_4444>;
444 proc_3_1 = downsample_3_1<ColorTypeFilter_4444>;
445 proc_3_2 = downsample_3_2<ColorTypeFilter_4444>;
446 proc_3_3 = downsample_3_3<ColorTypeFilter_4444>;
447 break;
448 case kAlpha_8_SkColorType:
449 case kGray_8_SkColorType:
450 proc_1_2 = downsample_1_2<ColorTypeFilter_8>;
451 proc_1_3 = downsample_1_3<ColorTypeFilter_8>;
452 proc_2_1 = downsample_2_1<ColorTypeFilter_8>;
453 proc_2_2 = downsample_2_2<ColorTypeFilter_8>;
454 proc_2_3 = downsample_2_3<ColorTypeFilter_8>;
455 proc_3_1 = downsample_3_1<ColorTypeFilter_8>;
456 proc_3_2 = downsample_3_2<ColorTypeFilter_8>;
457 proc_3_3 = downsample_3_3<ColorTypeFilter_8>;
458 break;
459 case kRGBA_F16_SkColorType:
460 proc_1_2 = downsample_1_2<ColorTypeFilter_F16>;
461 proc_1_3 = downsample_1_3<ColorTypeFilter_F16>;
462 proc_2_1 = downsample_2_1<ColorTypeFilter_F16>;
463 proc_2_2 = downsample_2_2<ColorTypeFilter_F16>;
464 proc_2_3 = downsample_2_3<ColorTypeFilter_F16>;
465 proc_3_1 = downsample_3_1<ColorTypeFilter_F16>;
466 proc_3_2 = downsample_3_2<ColorTypeFilter_F16>;
467 proc_3_3 = downsample_3_3<ColorTypeFilter_F16>;
468 break;
469 default:
470 // TODO: We could build miplevels for kIndex8 if the levels were in 8888.
471 // Means using more ram, but the quality would be fine.
472 return nullptr;
473 }
474
475 if (src.width() <= 1 && src.height() <= 1) {
476 return nullptr;
477 }
478 // whip through our loop to compute the exact size needed
479 size_t size = 0;
480 int countLevels = ComputeLevelCount(src.width(), src.height());
481 for (int currentMipLevel = countLevels; currentMipLevel >= 0; currentMipLevel--) {
482 SkISize mipSize = ComputeLevelSize(src.width(), src.height(), currentMipLevel);
483 size += SkColorTypeMinRowBytes(ct, mipSize.fWidth) * mipSize.fHeight;
484 }
485
486 size_t storageSize = SkMipMap::AllocLevelsSize(countLevels, size);
487 if (0 == storageSize) {
488 return nullptr;
489 }
490
491 SkMipMap* mipmap;
492 if (fact) {
493 SkDiscardableMemory* dm = fact(storageSize);
494 if (nullptr == dm) {
495 return nullptr;
496 }
497 mipmap = new SkMipMap(storageSize, dm);
498 } else {
499 mipmap = new SkMipMap(sk_malloc_throw(storageSize), storageSize);
500 }
501
502 // init
503 mipmap->fCS = sk_ref_sp(src.info().colorSpace());
504 mipmap->fCount = countLevels;
505 mipmap->fLevels = (Level*)mipmap->writable_data();
506 SkASSERT(mipmap->fLevels);
507
508 Level* levels = mipmap->fLevels;
509 uint8_t* baseAddr = (uint8_t*)&levels[countLevels];
510 uint8_t* addr = baseAddr;
511 int width = src.width();
512 int height = src.height();
513 uint32_t rowBytes;
514 SkPixmap srcPM(src);
515
516 for (int i = 0; i < countLevels; ++i) {
517 FilterProc* proc;
518 if (height & 1) {
519 if (height == 1) { // src-height is 1
520 if (width & 1) { // src-width is 3
521 proc = proc_3_1;
522 } else { // src-width is 2
523 proc = proc_2_1;
524 }
525 } else { // src-height is 3
526 if (width & 1) {
527 if (width == 1) { // src-width is 1
528 proc = proc_1_3;
529 } else { // src-width is 3
530 proc = proc_3_3;
531 }
532 } else { // src-width is 2
533 proc = proc_2_3;
534 }
535 }
536 } else { // src-height is 2
537 if (width & 1) {
538 if (width == 1) { // src-width is 1
539 proc = proc_1_2;
540 } else { // src-width is 3
541 proc = proc_3_2;
542 }
543 } else { // src-width is 2
544 proc = proc_2_2;
545 }
546 }
547 width = SkTMax(1, width >> 1);
548 height = SkTMax(1, height >> 1);
549 rowBytes = SkToU32(SkColorTypeMinRowBytes(ct, width));
550
551 // We make the Info w/o any colorspace, since that storage is not under our control, and
552 // will not be deleted in a controlled fashion. When the caller is given the pixmap for
553 // a given level, we augment this pixmap with fCS (which we do manage).
554 new (&levels[i].fPixmap) SkPixmap(SkImageInfo::Make(width, height, ct, at), addr, rowBytes);
555 levels[i].fScale = SkSize::Make(SkIntToScalar(width) / src.width(),
556 SkIntToScalar(height) / src.height());
557
558 const SkPixmap& dstPM = levels[i].fPixmap;
559 const void* srcBasePtr = srcPM.addr();
560 void* dstBasePtr = dstPM.writable_addr();
561
562 const size_t srcRB = srcPM.rowBytes();
563 for (int y = 0; y < height; y++) {
564 proc(dstBasePtr, srcBasePtr, srcRB, width);
565 srcBasePtr = (char*)srcBasePtr + srcRB * 2; // jump two rows
566 dstBasePtr = (char*)dstBasePtr + dstPM.rowBytes();
567 }
568 srcPM = dstPM;
569 addr += height * rowBytes;
570 }
571 SkASSERT(addr == baseAddr + size);
572
573 SkASSERT(mipmap->fLevels);
574 return mipmap;
575 }
576
ComputeLevelCount(int baseWidth,int baseHeight)577 int SkMipMap::ComputeLevelCount(int baseWidth, int baseHeight) {
578 if (baseWidth < 1 || baseHeight < 1) {
579 return 0;
580 }
581
582 // OpenGL's spec requires that each mipmap level have height/width equal to
583 // max(1, floor(original_height / 2^i)
584 // (or original_width) where i is the mipmap level.
585 // Continue scaling down until both axes are size 1.
586
587 const int largestAxis = SkTMax(baseWidth, baseHeight);
588 if (largestAxis < 2) {
589 // SkMipMap::Build requires a minimum size of 2.
590 return 0;
591 }
592 const int leadingZeros = SkCLZ(static_cast<uint32_t>(largestAxis));
593 // If the value 00011010 has 3 leading 0s then it has 5 significant bits
594 // (the bits which are not leading zeros)
595 const int significantBits = (sizeof(uint32_t) * 8) - leadingZeros;
596 // This is making the assumption that the size of a byte is 8 bits
597 // and that sizeof(uint32_t)'s implementation-defined behavior is 4.
598 int mipLevelCount = significantBits;
599
600 // SkMipMap does not include the base mip level.
601 // For example, it contains levels 1-x instead of 0-x.
602 // This is because the image used to create SkMipMap is the base level.
603 // So subtract 1 from the mip level count.
604 if (mipLevelCount > 0) {
605 --mipLevelCount;
606 }
607
608 return mipLevelCount;
609 }
610
ComputeLevelSize(int baseWidth,int baseHeight,int level)611 SkISize SkMipMap::ComputeLevelSize(int baseWidth, int baseHeight, int level) {
612 if (baseWidth < 1 || baseHeight < 1) {
613 return SkISize::Make(0, 0);
614 }
615
616 int maxLevelCount = ComputeLevelCount(baseWidth, baseHeight);
617 if (level >= maxLevelCount || level < 0) {
618 return SkISize::Make(0, 0);
619 }
620 // OpenGL's spec requires that each mipmap level have height/width equal to
621 // max(1, floor(original_height / 2^i)
622 // (or original_width) where i is the mipmap level.
623
624 // SkMipMap does not include the base mip level.
625 // For example, it contains levels 1-x instead of 0-x.
626 // This is because the image used to create SkMipMap is the base level.
627 // So subtract 1 from the mip level to get the index stored by SkMipMap.
628 int width = SkTMax(1, baseWidth >> (level + 1));
629 int height = SkTMax(1, baseHeight >> (level + 1));
630
631 return SkISize::Make(width, height);
632 }
633
634 ///////////////////////////////////////////////////////////////////////////////
635
extractLevel(const SkSize & scaleSize,Level * levelPtr) const636 bool SkMipMap::extractLevel(const SkSize& scaleSize, Level* levelPtr) const {
637 if (nullptr == fLevels) {
638 return false;
639 }
640
641 SkASSERT(scaleSize.width() >= 0 && scaleSize.height() >= 0);
642
643 #ifndef SK_SUPPORT_LEGACY_ANISOTROPIC_MIPMAP_SCALE
644 // Use the smallest scale to match the GPU impl.
645 const SkScalar scale = SkTMin(scaleSize.width(), scaleSize.height());
646 #else
647 // Ideally we'd pick the smaller scale, to match Ganesh. But ignoring one of the
648 // scales can produce some atrocious results, so for now we use the geometric mean.
649 // (https://bugs.chromium.org/p/skia/issues/detail?id=4863)
650 const SkScalar scale = SkScalarSqrt(scaleSize.width() * scaleSize.height());
651 #endif
652
653 if (scale >= SK_Scalar1 || scale <= 0 || !SkScalarIsFinite(scale)) {
654 return false;
655 }
656
657 SkScalar L = -SkScalarLog2(scale);
658 if (!SkScalarIsFinite(L)) {
659 return false;
660 }
661 SkASSERT(L >= 0);
662 int level = SkScalarFloorToInt(L);
663
664 SkASSERT(level >= 0);
665 if (level <= 0) {
666 return false;
667 }
668
669 if (level > fCount) {
670 level = fCount;
671 }
672 if (levelPtr) {
673 *levelPtr = fLevels[level - 1];
674 // need to augment with our colorspace
675 levelPtr->fPixmap.setColorSpace(fCS);
676 }
677 return true;
678 }
679
680 // Helper which extracts a pixmap from the src bitmap
681 //
Build(const SkBitmap & src,SkDestinationSurfaceColorMode colorMode,SkDiscardableFactoryProc fact)682 SkMipMap* SkMipMap::Build(const SkBitmap& src, SkDestinationSurfaceColorMode colorMode,
683 SkDiscardableFactoryProc fact) {
684 SkAutoPixmapUnlock srcUnlocker;
685 if (!src.requestLock(&srcUnlocker)) {
686 return nullptr;
687 }
688 const SkPixmap& srcPixmap = srcUnlocker.pixmap();
689 // Try to catch where we might have returned nullptr for src crbug.com/492818
690 if (nullptr == srcPixmap.addr()) {
691 sk_throw();
692 }
693 return Build(srcPixmap, colorMode, fact);
694 }
695
countLevels() const696 int SkMipMap::countLevels() const {
697 return fCount;
698 }
699
getLevel(int index,Level * levelPtr) const700 bool SkMipMap::getLevel(int index, Level* levelPtr) const {
701 if (NULL == fLevels) {
702 return false;
703 }
704 if (index < 0) {
705 return false;
706 }
707 if (index > fCount - 1) {
708 return false;
709 }
710 if (levelPtr) {
711 *levelPtr = fLevels[index];
712 }
713 return true;
714 }
715