1 public static Bitmap fastblur(Context context, Bitmap sentBitmap, int radius) {
  2 
  3         if (VERSION.SDK_INT > 20) {
  4             Bitmap bitmap = sentBitmap.copy(sentBitmap.getConfig(), true);
  5 
  6             final RenderScript rs = RenderScript.create(context);
  7             final Allocation input = Allocation.createFromBitmap(rs, sentBitmap,
  8                     Allocation.MipmapControl.MIPMAP_NONE, Allocation.USAGE_SCRIPT);
  9             final Allocation output = Allocation.createTyped(rs, input.getType());
 10             final ScriptIntrinsicBlur script = ScriptIntrinsicBlur.create(rs, Element.U8_4(rs));
 11             script.setRadius(radius /* e.g. 3.f */);
 12             script.setInput(input);
 13             script.forEach(output);
 14             output.copyTo(bitmap);
 15             return bitmap;
 16         }
 17 
 18         Bitmap bitmap = sentBitmap.copy(sentBitmap.getConfig(), true);
 19 
 20         if (radius < 1) {
 21             return (null);
 22         }
 23 
 24         int w = bitmap.getWidth();
 25         int h = bitmap.getHeight();
 26 
 27         int[] pix = new int[w * h];
 28         Log.e("pix", w + " " + h + " " + pix.length);
 29         bitmap.getPixels(pix, 0, w, 0, 0, w, h);
 30 
 31         int wm = w - 1;
 32         int hm = h - 1;
 33         int wh = w * h;
 34         int div = radius + radius + 1;
 35 
 36         int r[] = new int[wh];
 37         int g[] = new int[wh];
 38         int b[] = new int[wh];
 39         int rsum, gsum, bsum, x, y, i, p, yp, yi, yw;
 40         int vmin[] = new int[Math.max(w, h)];
 41 
 42         int divsum = (div + 1) >> 1;
 43         divsum *= divsum;
 44         int dv[] = new int[256 * divsum];
 45         for (i = 0; i < 256 * divsum; i++) {
 46             dv[i] = (i / divsum);
 47         }
 48 
 49         yw = yi = 0;
 50 
 51         int[][] stack = new int[div][3];
 52         int stackpointer;
 53         int stackstart;
 54         int[] sir;
 55         int rbs;
 56         int r1 = radius + 1;
 57         int routsum, goutsum, boutsum;
 58         int rinsum, ginsum, binsum;
 59 
 60         for (y = 0; y < h; y++) {
 61             rinsum = ginsum = binsum = routsum = goutsum = boutsum = rsum = gsum = bsum = 0;
 62             for (i = -radius; i <= radius; i++) {
 63                 p = pix[yi + Math.min(wm, Math.max(i, 0))];
 64                 sir = stack[i + radius];
 65                 sir[0] = (p & 0xff0000) >> 16;
 66                 sir[1] = (p & 0x00ff00) >> 8;
 67                 sir[2] = (p & 0x0000ff);
 68                 rbs = r1 - Math.abs(i);
 69                 rsum += sir[0] * rbs;
 70                 gsum += sir[1] * rbs;
 71                 bsum += sir[2] * rbs;
 72                 if (i > 0) {
 73                     rinsum += sir[0];
 74                     ginsum += sir[1];
 75                     binsum += sir[2];
 76                 } else {
 77                     routsum += sir[0];
 78                     goutsum += sir[1];
 79                     boutsum += sir[2];
 80                 }
 81             }
 82             stackpointer = radius;
 83 
 84             for (x = 0; x < w; x++) {
 85 
 86                 r[yi] = dv[rsum];
 87                 g[yi] = dv[gsum];
 88                 b[yi] = dv[bsum];
 89 
 90                 rsum -= routsum;
 91                 gsum -= goutsum;
 92                 bsum -= boutsum;
 93 
 94                 stackstart = stackpointer - radius + div;
 95                 sir = stack[stackstart % div];
 96 
 97                 routsum -= sir[0];
 98                 goutsum -= sir[1];
 99                 boutsum -= sir[2];
100 
101                 if (y == 0) {
102                     vmin[x] = Math.min(x + radius + 1, wm);
103                 }
104                 p = pix[yw + vmin[x]];
105 
106                 sir[0] = (p & 0xff0000) >> 16;
107                 sir[1] = (p & 0x00ff00) >> 8;
108                 sir[2] = (p & 0x0000ff);
109 
110                 rinsum += sir[0];
111                 ginsum += sir[1];
112                 binsum += sir[2];
113 
114                 rsum += rinsum;
115                 gsum += ginsum;
116                 bsum += binsum;
117 
118                 stackpointer = (stackpointer + 1) % div;
119                 sir = stack[(stackpointer) % div];
120 
121                 routsum += sir[0];
122                 goutsum += sir[1];
123                 boutsum += sir[2];
124 
125                 rinsum -= sir[0];
126                 ginsum -= sir[1];
127                 binsum -= sir[2];
128 
129                 yi++;
130             }
131             yw += w;
132         }
133         for (x = 0; x < w; x++) {
134             rinsum = ginsum = binsum = routsum = goutsum = boutsum = rsum = gsum = bsum = 0;
135             yp = -radius * w;
136             for (i = -radius; i <= radius; i++) {
137                 yi = Math.max(0, yp) + x;
138 
139                 sir = stack[i + radius];
140 
141                 sir[0] = r[yi];
142                 sir[1] = g[yi];
143                 sir[2] = b[yi];
144 
145                 rbs = r1 - Math.abs(i);
146 
147                 rsum += r[yi] * rbs;
148                 gsum += g[yi] * rbs;
149                 bsum += b[yi] * rbs;
150 
151                 if (i > 0) {
152                     rinsum += sir[0];
153                     ginsum += sir[1];
154                     binsum += sir[2];
155                 } else {
156                     routsum += sir[0];
157                     goutsum += sir[1];
158                     boutsum += sir[2];
159                 }
160 
161                 if (i < hm) {
162                     yp += w;
163                 }
164             }
165             yi = x;
166             stackpointer = radius;
167             for (y = 0; y < h; y++) {
168                 // Preserve alpha channel: ( 0xff000000 & pix[yi] )
169                 pix[yi] = (0xff000000 & pix[yi]) | (dv[rsum] << 16) | (dv[gsum] << 8) | dv[bsum];
170 
171                 rsum -= routsum;
172                 gsum -= goutsum;
173                 bsum -= boutsum;
174 
175                 stackstart = stackpointer - radius + div;
176                 sir = stack[stackstart % div];
177 
178                 routsum -= sir[0];
179                 goutsum -= sir[1];
180                 boutsum -= sir[2];
181 
182                 if (x == 0) {
183                     vmin[y] = Math.min(y + r1, hm) * w;
184                 }
185                 p = x + vmin[y];
186 
187                 sir[0] = r[p];
188                 sir[1] = g[p];
189                 sir[2] = b[p];
190 
191                 rinsum += sir[0];
192                 ginsum += sir[1];
193                 binsum += sir[2];
194 
195                 rsum += rinsum;
196                 gsum += ginsum;
197                 bsum += binsum;
198 
199                 stackpointer = (stackpointer + 1) % div;
200                 sir = stack[stackpointer];
201 
202                 routsum += sir[0];
203                 goutsum += sir[1];
204                 boutsum += sir[2];
205 
206                 rinsum -= sir[0];
207                 ginsum -= sir[1];
208                 binsum -= sir[2];
209 
210                 yi += w;
211             }
212         }
213 
214         Log.e("pix", w + " " + h + " " + pix.length);
215         bitmap.setPixels(pix, 0, w, 0, 0, w, h);
216         return (bitmap);
217     }

1 private static Bitmap small(Bitmap bitmap) {
2         Matrix matrix = new Matrix();
3         matrix.postScale(0.08f, 0.08f); // 长和宽放大缩小的比例
4         Bitmap resizeBmp = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix,
5                 true);
6         return resizeBmp;
7     }