[Android]-图片JNI（C++\Java）高斯模糊的实现与比较

转自：http://blog.csdn.net/qiujuer/article/details/24282047

前几天一直在弄android上的图片模糊效果的实现！

一直找不到方法，看别人说都是调用JNI，但是JNI这个东西我还真不熟悉啊！

只好从零开始了！这里不讲JNI的平台搭建，只讲JNI的关键代码，具体的项目我会共享出来给大家！

对于JNI下使用C++来模糊图片这个我真的没找到，只好自己写C++的来实现了。

在国外的一个项目中找到了一个”堆栈模糊效果“，原型如下：

// Stack Blur v1.0
//
// Author: Mario Klingemann <[email protected]>
// http://incubator.quasimondo.com
// created Feburary 29, 2004
// This is a compromise between Gaussian Blur and Box blur
// It creates much better looking blurs than Box Blur, but is
// 7x faster than my Gaussian Blur implementation.
//
// I called it Stack Blur because this describes best how this
// filter works internally: it creates a kind of moving stack
// of colors whilst scanning through the image. Thereby it
// just has to add one new block of color to the right side
// of the stack and remove the leftmost color. The remaining
// colors on the topmost layer of the stack are either added on
// or reduced by one, depending on if they are on the right or
// on the left side of the stack.
//
// If you are using this algorithm in your code please add
// the following line:
//
// Stack Blur Algorithm by Mario Klingemann <[email protected]>
PImage a;
PImage b;
void setup()
{
  a=loadImage("dog.jpg");
  size(a.width, a.height);
  b=new PImage(a.width, a.height);
  fill(255);
  noStroke();
  frameRate(25);
}
void draw()
{
  System.arraycopy(a.pixels,0,b.pixels,0,a.pixels.length);
  fastblur(b,mouseY/4);
  image(b, 0, 0);
}
void fastblur(PImage img,int radius){
  if (radius<1){
    return;
  }
  int\[\] pix=img.pixels;
  int w=img.width;
  int h=img.height;
  int wm=w-1;
  int hm=h-1;
  int wh=w*h;
  int div=radius+radius+1;
  int r\[\]=new int\[wh\];
  int g\[\]=new int\[wh\];
  int b\[\]=new int\[wh\];
  int rsum,gsum,bsum,x,y,i,p,yp,yi,yw;
  int vmin\[\] = new int\[max(w,h)\];
  int divsum=(div+1)>>1;
  divsum*=divsum;
  int dv\[\]=new int\[256*divsum\];
  for (i=0;i<256*divsum;i++){
    dv\[i\]=(i/divsum);
  }
  yw=yi=0;
  int\[\]\[\] stack=new int\[div\]\[3\];
  int stackpointer;
  int stackstart;
  int\[\] sir;
  int rbs;
  int r1=radius+1;
  int routsum,goutsum,boutsum;
  int rinsum,ginsum,binsum;
  for (y=0;y<h;y++){
    rinsum=ginsum=binsum=routsum=goutsum=boutsum=rsum=gsum=bsum=0;
    for(i=-radius;i<=radius;i++){
      p=pix\[yi+min(wm,max(i,0))\];
      sir=stack\[i+radius\];
      sir\[0\]=(p & 0xff0000)>>16;
      sir\[1\]=(p & 0x00ff00)>>8;
      sir\[2\]=(p & 0x0000ff);
      rbs=r1-abs(i);
      rsum+=sir\[0\]*rbs;
      gsum+=sir\[1\]*rbs;
      bsum+=sir\[2\]*rbs;
      if (i>0){
        rinsum+=sir\[0\];
        ginsum+=sir\[1\];
        binsum+=sir\[2\];
      } else {
        routsum+=sir\[0\];
        goutsum+=sir\[1\];
        boutsum+=sir\[2\];
      }
    }
    stackpointer=radius;
    for (x=0;x<w;x++){
      r\[yi\]=dv\[rsum\];
      g\[yi\]=dv\[gsum\];
      b\[yi\]=dv\[bsum\];
      rsum-=routsum;
      gsum-=goutsum;
      bsum-=boutsum;
      stackstart=stackpointer-radius+div;
      sir=stack\[stackstart%div\];
      routsum-=sir\[0\];
      goutsum-=sir\[1\];
      boutsum-=sir\[2\];
      if(y==0){
        vmin\[x\]=min(x+radius+1,wm);
      }
      p=pix\[yw+vmin\[x\]\];
      sir\[0\]=(p & 0xff0000)>>16;
      sir\[1\]=(p & 0x00ff00)>>8;
      sir\[2\]=(p & 0x0000ff);
      rinsum+=sir\[0\];
      ginsum+=sir\[1\];
      binsum+=sir\[2\];
      rsum+=rinsum;
      gsum+=ginsum;
      bsum+=binsum;
      stackpointer=(stackpointer+1)%div;
      sir=stack\[(stackpointer)%div\];
      routsum+=sir\[0\];
      goutsum+=sir\[1\];
      boutsum+=sir\[2\];
       rinsum-=sir\[0\];
      ginsum-=sir\[1\];
      binsum-=sir\[2\];
       yi++;
    }
    yw+=w;
  }
  for (x=0;x<w;x++){
    rinsum=ginsum=binsum=routsum=goutsum=boutsum=rsum=gsum=bsum=0;
    yp=-radius*w;
    for(i=-radius;i<=radius;i++){
      yi=max(0,yp)+x;
       sir=stack\[i+radius\];
      sir\[0\]=r\[yi\];
      sir\[1\]=g\[yi\];
      sir\[2\]=b\[yi\];
      rbs=r1-abs(i);
      rsum+=r\[yi\]*rbs;
      gsum+=g\[yi\]*rbs;
      bsum+=b\[yi\]*rbs;
      if (i>0){
        rinsum+=sir\[0\];
        ginsum+=sir\[1\];
        binsum+=sir\[2\];
      } else {
        routsum+=sir\[0\];
        goutsum+=sir\[1\];
        boutsum+=sir\[2\];
      }
      if(i<hm){
        yp+=w;
      }
    }
    yi=x;
    stackpointer=radius;
    for (y=0;y<h;y++){
      pix\[yi\]=0xff000000 | (dv\[rsum\]<<16) | (dv\[gsum\]<<8) | dv\[bsum\];
      rsum-=routsum;
      gsum-=goutsum;
      bsum-=boutsum;
      stackstart=stackpointer-radius+div;
      sir=stack\[stackstart%div\];
      routsum-=sir\[0\];
      goutsum-=sir\[1\];
      boutsum-=sir\[2\];
       if(x==0){
        vmin\[y\]=min(y+r1,hm)*w;
      }
      p=x+vmin\[y\];
      sir\[0\]=r\[p\];
      sir\[1\]=g\[p\];
      sir\[2\]=b\[p\];
      rinsum+=sir\[0\];
      ginsum+=sir\[1\];
      binsum+=sir\[2\];
      rsum+=rinsum;
      gsum+=ginsum;
      bsum+=binsum;
      stackpointer=(stackpointer+1)%div;
      sir=stack\[stackpointer\];
      routsum+=sir\[0\];
      goutsum+=sir\[1\];
      boutsum+=sir\[2\];
      rinsum-=sir\[0\];
      ginsum-=sir\[1\];
      binsum-=sir\[2\];
      yi+=w;
    }
  }
  img.updatePixels();
}

同时找到一个借鉴这个所改进后成为Java的代码，具体如下：

public static Bitmap doBlur(Bitmap sentBitmap, int radius, boolean canReuseInBitmap) {
    // Stack Blur v1.0 from
    // http://www.quasimondo.com/StackBlurForCanvas/StackBlurDemo.html
    //
    // Java Author: Mario Klingemann <mario at quasimondo.com>
    // http://incubator.quasimondo.com
    // created Feburary 29, 2004
    // Android port : Yahel Bouaziz <yahel at kayenko.com>
    // http://www.kayenko.com
    // ported april 5th, 2012
    // This is a compromise between Gaussian Blur and Box blur
    // It creates much better looking blurs than Box Blur, but is
    // 7x faster than my Gaussian Blur implementation.
    //
    // I called it Stack Blur because this describes best how this
    // filter works internally: it creates a kind of moving stack
    // of colors whilst scanning through the image. Thereby it
    // just has to add one new block of color to the right side
    // of the stack and remove the leftmost color. The remaining
    // colors on the topmost layer of the stack are either added on
    // or reduced by one, depending on if they are on the right or
    // on the left side of the stack.
    //
    // If you are using this algorithm in your code please add
    // the following line:
    //
    // Stack Blur Algorithm by Mario Klingemann <[email protected]>
    Bitmap bitmap;
    if (canReuseInBitmap) {
        bitmap = sentBitmap;
    } else {
        bitmap = sentBitmap.copy(sentBitmap.getConfig(), true);
    }
    if (radius < 1) {
        return (null);
    }
    int w = bitmap.getWidth();
    int h = bitmap.getHeight();
    int\[\] pix = new int\[w * h\];
    bitmap.getPixels(pix, 0, w, 0, 0, w, h);
    int wm = w - 1;
    int hm = h - 1;
    int wh = w * h;
    int div = radius + radius + 1;
    int r\[\] = new int\[wh\];
    int g\[\] = new int\[wh\];
    int b\[\] = new int\[wh\];
    int rsum, gsum, bsum, x, y, i, p, yp, yi, yw;
    int vmin\[\] = new int\[Math.max(w, h)\];
    int divsum = (div + 1) >> 1;
    divsum *= divsum;
    int dv\[\] = new int\[256 * divsum\];
    for (i = 0; i < 256 * divsum; i++) {
        dv\[i\] = (i / divsum);
    }
    yw = yi = 0;
    int\[\]\[\] stack = new int\[div\]\[3\];
    int stackpointer;
    int stackstart;
    int\[\] sir;
    int rbs;
    int r1 = radius + 1;
    int routsum, goutsum, boutsum;
    int rinsum, ginsum, binsum;
    for (y = 0; y < h; y++) {
        rinsum = ginsum = binsum = routsum = goutsum = boutsum = rsum = gsum = bsum = 0;
        for (i = -radius; i <= radius; i++) {
            p = pix\[yi + Math.min(wm, Math.max(i, 0))\];
            sir = stack\[i + radius\];
            sir\[0\] = (p & 0xff0000) >> 16;
            sir\[1\] = (p & 0x00ff00) >> 8;
            sir\[2\] = (p & 0x0000ff);
            rbs = r1 - Math.abs(i);
            rsum += sir\[0\] * rbs;
            gsum += sir\[1\] * rbs;
            bsum += sir\[2\] * rbs;
            if (i > 0) {
                rinsum += sir\[0\];
                ginsum += sir\[1\];
                binsum += sir\[2\];
            } else {
                routsum += sir\[0\];
                goutsum += sir\[1\];
                boutsum += sir\[2\];
            }
        }
        stackpointer = radius;
        for (x = 0; x < w; x++) {
            r\[yi\] = dv\[rsum\];
            g\[yi\] = dv\[gsum\];
            b\[yi\] = dv\[bsum\];
            rsum -= routsum;
            gsum -= goutsum;
            bsum -= boutsum;
            stackstart = stackpointer - radius + div;
            sir = stack\[stackstart % div\];
            routsum -= sir\[0\];
            goutsum -= sir\[1\];
            boutsum -= sir\[2\];
            if (y == 0) {
                vmin\[x\] = Math.min(x + radius + 1, wm);
            }
            p = pix\[yw + vmin\[x\]\];
            sir\[0\] = (p & 0xff0000) >> 16;
            sir\[1\] = (p & 0x00ff00) >> 8;
            sir\[2\] = (p & 0x0000ff);
            rinsum += sir\[0\];
            ginsum += sir\[1\];
            binsum += sir\[2\];
            rsum += rinsum;
            gsum += ginsum;
            bsum += binsum;
            stackpointer = (stackpointer + 1) % div;
            sir = stack\[(stackpointer) % div\];
            routsum += sir\[0\];
            goutsum += sir\[1\];
            boutsum += sir\[2\];
            rinsum -= sir\[0\];
            ginsum -= sir\[1\];
            binsum -= sir\[2\];
            yi++;
        }
        yw += w;
    }
    for (x = 0; x < w; x++) {
        rinsum = ginsum = binsum = routsum = goutsum = boutsum = rsum = gsum = bsum = 0;
        yp = -radius * w;
        for (i = -radius; i <= radius; i++) {
            yi = Math.max(0, yp) + x;
            sir = stack\[i + radius\];
            sir\[0\] = r\[yi\];
            sir\[1\] = g\[yi\];
            sir\[2\] = b\[yi\];
            rbs = r1 - Math.abs(i);
            rsum += r\[yi\] * rbs;
            gsum += g\[yi\] * rbs;
            bsum += b\[yi\] * rbs;
            if (i > 0) {
                rinsum += sir\[0\];
                ginsum += sir\[1\];
                binsum += sir\[2\];
            } else {
                routsum += sir\[0\];
                goutsum += sir\[1\];
                boutsum += sir\[2\];
            }
            if (i < hm) {
                yp += w;
            }
        }
        yi = x;
        stackpointer = radius;
        for (y = 0; y < h; y++) {
            // Preserve alpha channel: ( 0xff000000 & pix\[yi\] )
            pix\[yi\] = (0xff000000 & pix\[yi\]) | (dv\[rsum\] << 16) | (dv\[gsum\] << 8) | dv\[bsum\];
            rsum -= routsum;
            gsum -= goutsum;
            bsum -= boutsum;
            stackstart = stackpointer - radius + div;
            sir = stack\[stackstart % div\];
            routsum -= sir\[0\];
            goutsum -= sir\[1\];
            boutsum -= sir\[2\];
            if (x == 0) {
                vmin\[y\] = Math.min(y + r1, hm) * w;
            }
            p = x + vmin\[y\];
            sir\[0\] = r\[p\];
            sir\[1\] = g\[p\];
            sir\[2\] = b\[p\];
            rinsum += sir\[0\];
            ginsum += sir\[1\];
            binsum += sir\[2\];
            rsum += rinsum;
            gsum += ginsum;
            bsum += binsum;
            stackpointer = (stackpointer + 1) % div;
            sir = stack\[stackpointer\];
            routsum += sir\[0\];
            goutsum += sir\[1\];
            boutsum += sir\[2\];
            rinsum -= sir\[0\];
            ginsum -= sir\[1\];
            binsum -= sir\[2\];
            yi += w;
        }
    }
    bitmap.setPixels(pix, 0, w, 0, 0, w, h);
    return (bitmap);
}

借鉴于此我弄了一个C的代码，基本上的整体过程都没有变化，只是改变成了C（C++也可已）的而已：

文件名：ImageBlur.c

/*************************************************
Copyright:  Copyright QIUJUER 2013.
Author:     Qiujuer
Date:       2014-04-18
Description:实现图片模糊处理
**************************************************/
#include<malloc.h>
#define ABS(a) ((a)<(0)?(-a):(a))
#define MAX(a,b) ((a)>(b)?(a):(b))
#define MIN(a,b) ((a)<(b)?(a):(b))
/*************************************************
Function:       StackBlur(堆栈模糊)
Description:    使用堆栈方式进行图片像素模糊处理
Calls:          malloc
Table Accessed: NULL
Table Updated:  NULL
Input:          像素点集合，图片宽，图片高，模糊半径
Output:         返回模糊后的像素点集合
Return:         返回模糊后的像素点集合
Others:         NULL
*************************************************/
static int* StackBlur(int* pix, int w, int h, int radius) {
    int wm = w - 1;
    int hm = h - 1;
    int wh = w * h;
    int div = radius + radius + 1;
    int *r = (int *)malloc(wh * sizeof(int));
    int *g = (int *)malloc(wh * sizeof(int));
    int *b = (int *)malloc(wh * sizeof(int));
    int rsum, gsum, bsum, x, y, i, p, yp, yi, yw;
    int *vmin = (int *)malloc(MAX(w,h) * sizeof(int));
    int divsum = (div + 1) >> 1;
    divsum *= divsum;
    int *dv = (int *)malloc(256 * divsum * sizeof(int));
    for (i = 0; i < 256 * divsum; i++) {
        dv\[i\] = (i / divsum);
    }
    yw = yi = 0;
    int(*stack)\[3\] = (int(*)\[3\])malloc(div * 3 * sizeof(int));
    int stackpointer;
    int stackstart;
    int *sir;
    int rbs;
    int r1 = radius + 1;
    int routsum, goutsum, boutsum;
    int rinsum, ginsum, binsum;
    for (y = 0; y < h; y++) {
        rinsum = ginsum = binsum = routsum = goutsum = boutsum = rsum = gsum = bsum = 0;
        for (i = -radius; i <= radius; i++) {
            p = pix\[yi + (MIN(wm, MAX(i, 0)))\];
            sir = stack\[i + radius\];
            sir\[0\] = (p & 0xff0000) >> 16;
            sir\[1\] = (p & 0x00ff00) >> 8;
            sir\[2\] = (p & 0x0000ff);
            rbs = r1 - ABS(i);
            rsum += sir\[0\] * rbs;
            gsum += sir\[1\] * rbs;
            bsum += sir\[2\] * rbs;
            if (i > 0) {
                rinsum += sir\[0\];
                ginsum += sir\[1\];
                binsum += sir\[2\];
            }
            else {
                routsum += sir\[0\];
                goutsum += sir\[1\];
                boutsum += sir\[2\];
            }
        }
        stackpointer = radius;
        for (x = 0; x < w; x++) {
            r\[yi\] = dv\[rsum\];
            g\[yi\] = dv\[gsum\];
            b\[yi\] = dv\[bsum\];
            rsum -= routsum;
            gsum -= goutsum;
            bsum -= boutsum;
            stackstart = stackpointer - radius + div;
            sir = stack\[stackstart % div\];
            routsum -= sir\[0\];
            goutsum -= sir\[1\];
            boutsum -= sir\[2\];
            if (y == 0) {
                vmin\[x\] = MIN(x + radius + 1, wm);
            }
            p = pix\[yw + vmin\[x\]\];
            sir\[0\] = (p & 0xff0000) >> 16;
            sir\[1\] = (p & 0x00ff00) >> 8;
            sir\[2\] = (p & 0x0000ff);
            rinsum += sir\[0\];
            ginsum += sir\[1\];
            binsum += sir\[2\];
            rsum += rinsum;
            gsum += ginsum;
            bsum += binsum;
            stackpointer = (stackpointer + 1) % div;
            sir = stack\[(stackpointer) % div\];
            routsum += sir\[0\];
            goutsum += sir\[1\];
            boutsum += sir\[2\];
            rinsum -= sir\[0\];
            ginsum -= sir\[1\];
            binsum -= sir\[2\];
            yi++;
        }
        yw += w;
    }
    for (x = 0; x < w; x++) {
        rinsum = ginsum = binsum = routsum = goutsum = boutsum = rsum = gsum = bsum = 0;
        yp = -radius * w;
        for (i = -radius; i <= radius; i++) {
            yi = MAX(0, yp) + x;
            sir = stack\[i + radius\];
            sir\[0\] = r\[yi\];
            sir\[1\] = g\[yi\];
            sir\[2\] = b\[yi\];
            rbs = r1 - ABS(i);
            rsum += r\[yi\] * rbs;
            gsum += g\[yi\] * rbs;
            bsum += b\[yi\] * rbs;
            if (i > 0) {
                rinsum += sir\[0\];
                ginsum += sir\[1\];
                binsum += sir\[2\];
            }
            else {
                routsum += sir\[0\];
                goutsum += sir\[1\];
                boutsum += sir\[2\];
            }
            if (i < hm) {
                yp += w;
            }
        }
        yi = x;
        stackpointer = radius;
        for (y = 0; y < h; y++) {
            // Preserve alpha channel: ( 0xff000000 & pix\[yi\] )
            pix\[yi\] = (0xff000000 & pix\[yi\]) | (dv\[rsum\] << 16) | (dv\[gsum\] << 8) | dv\[bsum\];
            rsum -= routsum;
            gsum -= goutsum;
            bsum -= boutsum;
            stackstart = stackpointer - radius + div;
            sir = stack\[stackstart % div\];
            routsum -= sir\[0\];
            goutsum -= sir\[1\];
            boutsum -= sir\[2\];
            if (x == 0) {
                vmin\[y\] = MIN(y + r1, hm) * w;
            }
            p = x + vmin\[y\];
            sir\[0\] = r\[p\];
            sir\[1\] = g\[p\];
            sir\[2\] = b\[p\];
            rinsum += sir\[0\];
            ginsum += sir\[1\];
            binsum += sir\[2\];
            rsum += rinsum;
            gsum += ginsum;
            bsum += binsum;
            stackpointer = (stackpointer + 1) % div;
            sir = stack\[stackpointer\];
            routsum += sir\[0\];
            goutsum += sir\[1\];
            boutsum += sir\[2\];
            rinsum -= sir\[0\];
            ginsum -= sir\[1\];
            binsum -= sir\[2\];
            yi += w;
        }
    }
    free(r);
    free(g);
    free(b);
    free(vmin);
    free(dv);
    free(stack);
    return(pix);
}

在改为这个的过程中还遇到了一个很喜剧的问题，我发现我使用这个来进行调用后结果程序内存一直增大，直到500多M，直接卡死。我知道是我写的有内存泄漏了！

然后找了一下，发现果然是。只好进行free了。然后一下就好了，发现内存占用的确比Java的要少，速度也是要快一些！

在JNI中的实现我使用了两种方案，一种是直接传递文件，一直是传递像素点集合进行模糊！分别如下：

/*
 * Class:     com_accumulation_imageblurring_app_jni_ImageBlur
 * Method:    blurIntArray
 * Signature: (\[IIII)V
 */
JNIEXPORT void JNICALL Java_com_accumulation_imageblurring_app_jni_ImageBlur_blurIntArray
  (JNIEnv *, jclass, jintArray, jint, jint, jint);
/*
 * Class:     com_accumulation_imageblurring_app_jni_ImageBlur
 * Method:    blurBitMap
 * Signature: (Landroid/graphics/Bitmap;I)V
 */
JNIEXPORT void JNICALL Java_com_accumulation_imageblurring_app_jni_ImageBlur_blurBitMap
  (JNIEnv *, jclass, jobject, jint);

对应的Java调用：

public class ImageBlur {
    public static native void blurIntArray(int\[\] pImg, int w, int h, int r);
    public static native void blurBitMap(Bitmap bitmap, int r);
    static {
        System.loadLibrary("JNI_ImageBlur");
    }
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

此时我做了3种测试，一种是直接在Java层实现，一种是传递像素点集合模糊，还有就是直接传递图片进行模糊，结果如下：