• Home
  • History
  • Annotate
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
downsampleby2_proc32(SkBitmap * dst,int x,int y,const SkBitmap & src)12 static void downsampleby2_proc32(SkBitmap* dst, int x, int y,
13                                  const SkBitmap& src) {
14     x <<= 1;
15     y <<= 1;
16     const SkPMColor* p = src.getAddr32(x, y);
17     const SkPMColor* baseP = p;
18     SkPMColor c, ag, rb;
19 
20     c = *p; ag = (c >> 8) & 0xFF00FF; rb = c & 0xFF00FF;
21     if (x < src.width() - 1) {
22         p += 1;
23     }
24     c = *p; ag += (c >> 8) & 0xFF00FF; rb += c & 0xFF00FF;
25 
26     p = baseP;
27     if (y < src.height() - 1) {
28         p += src.rowBytes() >> 2;
29     }
30     c = *p; ag += (c >> 8) & 0xFF00FF; rb += c & 0xFF00FF;
31     if (x < src.width() - 1) {
32         p += 1;
33     }
34     c = *p; ag += (c >> 8) & 0xFF00FF; rb += c & 0xFF00FF;
35 
36     *dst->getAddr32(x >> 1, y >> 1) =
37     ((rb >> 2) & 0xFF00FF) | ((ag << 6) & 0xFF00FF00);
38 }
39 
expand16(U16CPU c)40 static inline uint32_t expand16(U16CPU c) {
41     return (c & ~SK_G16_MASK_IN_PLACE) | ((c & SK_G16_MASK_IN_PLACE) << 16);
42 }
43 
44 // returns dirt in the top 16bits, but we don't care, since we only
45 // store the low 16bits.
pack16(uint32_t c)46 static inline U16CPU pack16(uint32_t c) {
47     return (c & ~SK_G16_MASK_IN_PLACE) | ((c >> 16) & SK_G16_MASK_IN_PLACE);
48 }
49 
downsampleby2_proc16(SkBitmap * dst,int x,int y,const SkBitmap & src)50 static void downsampleby2_proc16(SkBitmap* dst, int x, int y,
51                                  const SkBitmap& src) {
52     x <<= 1;
53     y <<= 1;
54     const uint16_t* p = src.getAddr16(x, y);
55     const uint16_t* baseP = p;
56     SkPMColor       c;
57 
58     c = expand16(*p);
59     if (x < src.width() - 1) {
60         p += 1;
61     }
62     c += expand16(*p);
63 
64     p = baseP;
65     if (y < src.height() - 1) {
66         p += src.rowBytes() >> 1;
67     }
68     c += expand16(*p);
69     if (x < src.width() - 1) {
70         p += 1;
71     }
72     c += expand16(*p);
73 
74     *dst->getAddr16(x >> 1, y >> 1) = (uint16_t)pack16(c >> 2);
75 }
76 
expand4444(U16CPU c)77 static uint32_t expand4444(U16CPU c) {
78     return (c & 0xF0F) | ((c & ~0xF0F) << 12);
79 }
80 
collaps4444(uint32_t c)81 static U16CPU collaps4444(uint32_t c) {
82     return (c & 0xF0F) | ((c >> 12) & ~0xF0F);
83 }
84 
downsampleby2_proc4444(SkBitmap * dst,int x,int y,const SkBitmap & src)85 static void downsampleby2_proc4444(SkBitmap* dst, int x, int y,
86                                    const SkBitmap& src) {
87     x <<= 1;
88     y <<= 1;
89     const uint16_t* p = src.getAddr16(x, y);
90     const uint16_t* baseP = p;
91     uint32_t        c;
92 
93     c = expand4444(*p);
94     if (x < src.width() - 1) {
95         p += 1;
96     }
97     c += expand4444(*p);
98 
99     p = baseP;
100     if (y < src.height() - 1) {
101         p += src.rowBytes() >> 1;
102     }
103     c += expand4444(*p);
104     if (x < src.width() - 1) {
105         p += 1;
106     }
107     c += expand4444(*p);
108 
109     *dst->getAddr16(x >> 1, y >> 1) = (uint16_t)collaps4444(c >> 2);
110 }
111 
AllocLevels(int levelCount,size_t pixelSize)112 SkMipMap::Level* SkMipMap::AllocLevels(int levelCount, size_t pixelSize) {
113     if (levelCount < 0) {
114         return NULL;
115     }
116     int64_t size = sk_64_mul(levelCount + 1, sizeof(Level)) + pixelSize;
117     if (!sk_64_isS32(size)) {
118         return NULL;
119     }
120     return (Level*)sk_malloc_throw(sk_64_asS32(size));
121 }
122 
Build(const SkBitmap & src)123 SkMipMap* SkMipMap::Build(const SkBitmap& src) {
124     void (*proc)(SkBitmap* dst, int x, int y, const SkBitmap& src);
125 
126     const SkColorType ct = src.colorType();
127     const SkAlphaType at = src.alphaType();
128     switch (ct) {
129         case kRGBA_8888_SkColorType:
130         case kBGRA_8888_SkColorType:
131             proc = downsampleby2_proc32;
132             break;
133         case kRGB_565_SkColorType:
134             proc = downsampleby2_proc16;
135             break;
136         case kARGB_4444_SkColorType:
137             proc = downsampleby2_proc4444;
138             break;
139         default:
140             return NULL; // don't build mipmaps for any other colortypes (yet)
141     }
142 
143     SkAutoLockPixels alp(src);
144     if (!src.readyToDraw()) {
145         return NULL;
146     }
147 
148     // whip through our loop to compute the exact size needed
149     size_t  size = 0;
150     int     countLevels = 0;
151     {
152         int width = src.width();
153         int height = src.height();
154         for (;;) {
155             width >>= 1;
156             height >>= 1;
157             if (0 == width || 0 == height) {
158                 break;
159             }
160             size += SkColorTypeMinRowBytes(ct, width) * height;
161             countLevels += 1;
162         }
163     }
164     if (0 == countLevels) {
165         return NULL;
166     }
167 
168     Level* levels = SkMipMap::AllocLevels(countLevels, size);
169     if (NULL == levels) {
170         return NULL;
171     }
172 
173     uint8_t*    baseAddr = (uint8_t*)&levels[countLevels];
174     uint8_t*    addr = baseAddr;
175     int         width = src.width();
176     int         height = src.height();
177     uint32_t    rowBytes;
178     SkBitmap    srcBM(src);
179 
180     for (int i = 0; i < countLevels; ++i) {
181         width >>= 1;
182         height >>= 1;
183         rowBytes = SkToU32(SkColorTypeMinRowBytes(ct, width));
184 
185         levels[i].fPixels   = addr;
186         levels[i].fWidth    = width;
187         levels[i].fHeight   = height;
188         levels[i].fRowBytes = rowBytes;
189         levels[i].fScale    = (float)width / src.width();
190 
191         SkBitmap dstBM;
192         dstBM.installPixels(SkImageInfo::Make(width, height, ct, at), addr, rowBytes);
193 
194         srcBM.lockPixels();
195         for (int y = 0; y < height; y++) {
196             for (int x = 0; x < width; x++) {
197                 proc(&dstBM, x, y, srcBM);
198             }
199         }
200         srcBM.unlockPixels();
201 
202         srcBM = dstBM;
203         addr += height * rowBytes;
204     }
205     SkASSERT(addr == baseAddr + size);
206 
207     return SkNEW_ARGS(SkMipMap, (levels, countLevels, size));
208 }
209 
210 ///////////////////////////////////////////////////////////////////////////////
211 
212 //static int gCounter;
213 
SkMipMap(Level * levels,int count,size_t size)214 SkMipMap::SkMipMap(Level* levels, int count, size_t size)
215     : fSize(size), fLevels(levels), fCount(count) {
216     SkASSERT(levels);
217     SkASSERT(count > 0);
218 //    SkDebugf("mips %d\n", ++gCounter);
219 }
220 
~SkMipMap()221 SkMipMap::~SkMipMap() {
222     sk_free(fLevels);
223 //    SkDebugf("mips %d\n", --gCounter);
224 }
225 
compute_level(SkScalar scale)226 static SkFixed compute_level(SkScalar scale) {
227     SkFixed s = SkAbs32(SkScalarToFixed(SkScalarInvert(scale)));
228 
229     if (s < SK_Fixed1) {
230         return 0;
231     }
232     int clz = SkCLZ(s);
233     SkASSERT(clz >= 1 && clz <= 15);
234     return SkIntToFixed(15 - clz) + ((unsigned)(s << (clz + 1)) >> 16);
235 }
236 
extractLevel(SkScalar scale,Level * levelPtr) const237 bool SkMipMap::extractLevel(SkScalar scale, Level* levelPtr) const {
238     if (scale >= SK_Scalar1) {
239         return false;
240     }
241 
242     int level = compute_level(scale) >> 16;
243     SkASSERT(level >= 0);
244     if (level <= 0) {
245         return false;
246     }
247 
248     if (level > fCount) {
249         level = fCount;
250     }
251     if (levelPtr) {
252         *levelPtr = fLevels[level - 1];
253     }
254     return true;
255 }
256