1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
|
package com.bumptech.glide.resize.bitmap_recycle;
import android.annotation.TargetApi;
import android.graphics.Bitmap;
import java.util.TreeMap;
@TargetApi(19)
class SizeStrategy implements LruPoolStrategy {
private static final int MAX_SIZE_MULTIPLE = 4;
private final KeyPool keyPool = new KeyPool();
private final GroupedLinkedMap<Key, Bitmap> groupedMap = new GroupedLinkedMap<Key, Bitmap>();
private final TreeMap<Integer, Integer> sortedSizes = new TreeMap<Integer, Integer>();
@Override
public void put(Bitmap bitmap) {
final Key key = keyPool.get(bitmap.getAllocationByteCount());
groupedMap.put(key, bitmap);
Integer current = sortedSizes.get(key.size);
sortedSizes.put(key.size, current == null ? 1 : current + 1);
}
@Override
public Bitmap get(int width, int height, Bitmap.Config config) {
final int size = getSize(width, height, config);
Key key = keyPool.get(size);
Integer possibleSize = sortedSizes.ceilingKey(size);
if (possibleSize != null && possibleSize != size && possibleSize <= size * MAX_SIZE_MULTIPLE) {
keyPool.offer(key);
key = keyPool.get(possibleSize);
}
// Do a get even if we know we don't have a bitmap so that the key moves to the front in the lru pool
final Bitmap result = groupedMap.get(key);
if (result != null) {
result.reconfigure(width, height, config);
decrementBitmapOfSize(possibleSize);
}
return result;
}
@Override
public Bitmap removeLast() {
Bitmap removed = groupedMap.removeLast();
if (removed != null) {
final int removedSize = removed.getAllocationByteCount();
decrementBitmapOfSize(removedSize);
}
return removed;
}
private void decrementBitmapOfSize(Integer size) {
Integer current = sortedSizes.get(size);
if (current == 1) {
sortedSizes.remove(size);
} else {
sortedSizes.put(size, current - 1);
}
}
@Override
public String logBitmap(Bitmap bitmap) {
return getBitmapString(bitmap);
}
@Override
public String logBitmap(int width, int height, Bitmap.Config config) {
return getBitmapString(getSize(width, height, config));
}
@Override
public int getSize(Bitmap bitmap) {
return bitmap.getAllocationByteCount();
}
@Override
public String toString() {
String result = "SizeStrategy:\n " + groupedMap + "\n SortedSizes( ";
boolean hadAtLeastOneKey = false;
for (Integer size : sortedSizes.keySet()) {
hadAtLeastOneKey = true;
result += "{" + getBitmapString(size) + ":" + sortedSizes.get(size) + "}, ";
}
if (hadAtLeastOneKey) {
result = result.substring(0, result.length() - 2);
}
return result + " )";
}
private static String getBitmapString(Bitmap bitmap) {
return getBitmapString(bitmap.getAllocationByteCount());
}
private static String getBitmapString(int size) {
return "[" + size + "]";
}
private static int getSize(int width, int height, Bitmap.Config config) {
return width * height * getBytesPerPixel(config);
}
private static int getBytesPerPixel(Bitmap.Config config) {
switch (config) {
case ARGB_8888:
return 4;
case RGB_565:
return 2;
case ARGB_4444:
return 2;
case ALPHA_8:
return 1;
default:
// We only use this to calculate sizes to get, so choosing 4 bytes per pixel is conservative and
// probably forces us to get a larger bitmap than we really need. Since we can't tell for sure, probably
// better safe than sorry.
return 4;
}
}
private static class KeyPool extends BaseKeyPool<Key> {
public Key get(int size) {
Key result = get();
result.init(size);
return result;
}
@Override
protected Key create() {
return new Key(this);
}
}
private static class Key implements Poolable {
private final KeyPool pool;
private int size;
private Key(KeyPool pool) {
this.pool = pool;
}
public void init(int size) {
this.size = size;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Key key = (Key) o;
return size == key.size;
}
@Override
public int hashCode() {
return size;
}
@Override
public String toString() {
return getBitmapString(size);
}
@Override
public void offer() {
pool.offer(this);
}
}
}
|
