android camera开发的一些问题记录

注：一下所有数据都是基于小米Pad调试得来的

屏幕角度说明：
关于屏幕的横竖屏旋转首先要分清屏幕旋转角度和摄像头旋转角度的对应关系（如附图1)
屏幕旋转角度：正常竖屏情况下是0度，顺时针栓转依次为 90,180 270
相机旋转角度：正常竖屏情况下是90度， 顺时针依次为 180,270,0
他们的对应关系相差90度
cameraDegrees = （90+orientation）% 360;

屏幕旋转与摄像头旋转
首先可以通过 mCamera.setDisplayOrientation(degrees);来设置随着屏幕旋转相机预览的角度
其中参数degrees是当前屏幕状态对应的相机旋转角度，
因为相机成像即预览时捕获的data[]数据是始终获取的横屏数据（这个data是没有角度的，始终如一）即 相机角度为0度的状态，所以在预览时如果预览的surfaceView有跟着屏幕转动，就要设置相应的相机旋转角度来达到预览效果始终跟屏幕旋转到正确方向。

关于相机预览角度的总结：捕获的raw数据是没有跟随屏幕的旋转而改变的，在没有旋转屏幕时，始终与屏幕保持逆时针90度（顺时针270度）的角度，而一段预览view跟谁屏幕发生旋转就要设置相机旋转角度以匹配屏幕旋转的预览角度。

摄像头实际成像数据的旋转
方法一：直接对数组旋转
参数说明：
data 是摄像头捕获数据转灰度后的数据，因为摄像头捕获数据是YUV格式，这样的格式不能直接用该方法旋转否则会出现错误
width：相机使用像素对应的宽度
height: 相机使用像素对应的高度

 

   //旋90度
    public voidgetRotation_90(int[] data, int width, int height) {
       int len = data.length;
       if (len != width * height) {
           return;
       }
       int[] rotation = new int[len];
       int index = 0;
       for (int i = 0; i < width; i++) {
           for (int j = height - 1; j >= 0; j--) {
               rotation[index++] = data[j * width + i];
           }
       }
       for (int i = 0; i < len; i++) {
           data[i] = rotation[i];
       }
       rotation = null;
    }

    //旋180度
    public voidgetRotation_180(int[] data, int width, int height) {
       int len = data.length;
       if (len != width * height) {
           return;
       }
       for (int i = 0; i < len / 2; i++) {
           int temp = data[i];
           data[i] = data[len - 1 - i];
           data[len - 1 - i] = temp;
       }
    }

    //旋270度
    public voidgetRotation_270(int[] data, int width, int height) {
       int len = data.length;
       if (len != width * height) {
           return;
       }
       int[] rotation = new int[len];
       int index = 0;
       for (int j = width - 1; j >= 0; j--) {
           for (int i = 0; i < height; i++) {
               rotation[index++] = data[i * width + j];
           }
       }
       for (int i = 0; i < len; i++) {
           data[i] = rotation[i];
       }
       rotation = null;
    }
方法二：通过bitmap来转
注意使用万bitmap 记得recycle（）
参数说明：
b：将摄像头捕获的图像信息转转化为像素数组之后生成bitmap 相关转化方法见下文
degrees： 将当前图像旋转的角度（该角度值同样是当前屏幕状态下的相机角度）

public static Bitmap rotateBitmap(Bitmap b, int degrees) {
       if (degrees != 0 && b != null) {
           Matrix m = new Matrix();
           m.setRotate(degrees, (float) b.getWidth() / 2, (float)b.getHeight() / 2);
           try {
               Bitmap b2 = Bitmap.createBitmap(b, 0, 0, b.getWidth(),b.getHeight(), m, true);
               if (b != b2) {
                   b.recycle();
                   b = b2;
               }
           } catch (OutOfMemoryError ex) {
               return b;
           }
       }
       return b;
    }

摄像头捕获的YUV格式的数据转灰度
参数说明：
data： 摄像头传回的数据信息（YUV格式）
pixels：保存转灰度后的数据信息
w:摄像头使用的像素宽度
h：摄像头使用的像素高度

    private voidYUVToGray(int[] pixels, byte[] data, int w, int h) {

       int inputOffset = 0;
       for (int y = 0; y < h; y++) {
           int outputOffset = y * w;
           for (int x = 0; x < w; x++) {
               int grey = data[inputOffset + x] & 0xff;
               pixels[outputOffset + x] = 0xFF000000 | (grey * 0x00010101);
           }
           inputOffset += w;
       }
    }

摄像头捕获的YUV格式数据转RGB
参数说明：
yuv420sp: 摄像头捕获的数据
rgbBuf： 转换的rgb格式的数据
width： 摄像头像素宽度
height：摄像头像素高度

private void decodeYUV420SP(byte[] rgbBuf, byte[] yuv420sp, intwidth, int height) {
       final int frameSize = width * height;
       if (rgbBuf == null)
           throw new NullPointerException("buffer 'rgbBuf' is null");
       if (rgbBuf.length < frameSize * 3)
           throw new IllegalArgumentException("buffer 'rgbBuf' size " +rgbBuf.length
                   + " < minimum " + frameSize * 3);

       if (yuv420sp == null)
           throw new NullPointerException("buffer 'yuv420sp' is null");

       if (yuv420sp.length < frameSize * 3 / 2)
           throw new IllegalArgumentException("buffer 'yuv420sp' size " +yuv420sp.length
                   + " < minimum " + frameSize * 3 / 2);

       int i = 0, y = 0;
       int uvp = 0, u = 0, v = 0;
       int y1192 = 0, r = 0, g = 0, b = 0;

       for (int j = 0, yp = 0; j < height; j++) {
           uvp = frameSize + (j >> 1) * width;
           u = 0;
           v = 0;
           for (i = 0; i < width; i++, yp++) {
               y = (0xff & ((int) yuv420sp[yp])) - 16;
               if (y < 0)
                   y = 0;
               if ((i & 1) == 0) {
                   v = (0xff & yuv420sp[uvp++]) - 128;
                   u = (0xff & yuv420sp[uvp++]) - 128;
               }

               y1192 = 1192 * y;
               r = (y1192 + 1634 * v);
               g = (y1192 - 833 * v - 400 * u);
               b = (y1192 + 2066 * u);

               if (r < 0)
                   r = 0;
               else if (r > 262143)
                   r = 262143;
               if (g < 0)
                   g = 0;
               else if (g > 262143)
                   g = 262143;
               if (b < 0)
                   b = 0;
               else if (b > 262143)
                   b = 262143;

               rgbBuf[yp * 3] = (byte) (r >> 10);
               rgbBuf[yp * 3 + 1] = (byte) (g >> 10);
               rgbBuf[yp * 3 + 2] = (byte) (b >> 10);
           }
       }
    }

用GRB格式数据创建bitmap
首先通过rgb数据得到colors数组
其次使用bitmap想官方法创建

private int[] convertByteToColor(byte[] data) {
       int size = data.length;
       if (size == 0) {
           return null;
       }

       // 理论上data的长度应该是3的倍数，这里做个兼容
       int arg = 0;
       if (size % 3 != 0) {
           arg = 1;
       }

       int[] color = new int[size / 3 + arg];
       int red, green, blue;

       if (arg == 0) { // 正好是3的倍数
           for (int i = 0; i < color.length; ++i) {

               color[i] = (data[i * 3] << 16 & 0x00FF0000) | (data[i * 3+ 1] << 8 & 0x0000FF00)
                       | (data[i * 3 + 2] & 0x000000FF) | 0xFF000000;
           }
       } else { // 不是3的倍数
           for (int i = 0; i < color.length - 1; ++i) {
               color[i] = (data[i * 3] << 16 & 0x00FF0000) | (data[i * 3+ 1] << 8 & 0x0000FF00)
                       | (data[i * 3 + 2] & 0x000000FF) | 0xFF000000;
           }

           color[color.length - 1] = 0xFF000000; // 最后一个像素用黑色填充
       }

       return color;
    }

//得到colors后通过
   int[] colors =convertByteToColor(rgbBuf);
       Bitmap bitmap = Bitmap.createBitmap(colors, 0, width, width,height,
               Bitmap.Config.ARGB_8888);

通常在旋转屏幕时可以正确做的选择90度，没转换一次相关activity就会重新进入一个生命周期，但是在屏幕平放旋转180度时，pad并不能捕获到相关的旋转操作，这时候使用为了达到目的需要使用OrientationEventListener来时时捕获屏幕旋转角度（注：该监听捕获的角度是屏幕角度）


1.创建相关的监听类实现捕获相关信息后的处理方法
class MyOrientationEventListener extends OrientationEventListener{

       public MyOrientationEventListener(Context context) {
           super(context);
       }

       @Override
       public void onOrientationChanged(int orientation) {
           
               if (orientation == 90 || orientation == 180 || orientation ==270
                       || orientation == 0) {
                   int rotationDegree = mConfigManager.getRotationDegrees();
                   if ((orientation + 90) % 360 == rotationDegree) {
                       return;
                   }
                   rotationDegree = (90 + orientation) % 360;
                   mConfigManager.setRotationDegrees(rotationDegree);
                   mCameraManager.setPreviewOrientation(rotationDegree);
               }
           
       }
    }
2.在Create（）中创建MyOrientationEventListener（Context）对象
   在onResume()中调用MyOrientationEventListener.enable()方法开启
  在onPause（）中调用MyOrientationEventListener.disable()方法关闭


最终获取的图片的剪切
与前面对应也有两个方法进行图片剪切
方法一：直接对像素操作

参数说明：
data： 是摄像头捕获数据转灰度后的数据（也是根据屏幕转换处理后的数据）
mFramingRectInPreview： 是要剪切的矩形框，其坐标是相对与捕获图片的坐标（因为data是捕获图片）

其中的pWidth是摄像头的x即 宽度
public int[] getCutMatrix(int[] data, Rect mFramingRectInPreview){
       Point cameraResolution =mConfigManager.getCameraResolution();
       int pWidth = cameraResolution.x;

       if (mFramingRectInPreview == null) {
           return null;
       }

       int width = mFramingRectInPreview.width();
       int height = mFramingRectInPreview.height();
       int inputOffset = mFramingRectInPreview.top * pWidth +mFramingRectInPreview.left;
       int area = width * height;
       int[] matrix = new int[area];
       int[] copyData = data;
       for (int y = 0; y < height; y++) {
           int outPutOffset = y * width;
           System.arraycopy(copyData, inputOffset, matrix, outPutOffset,width);
           inputOffset += pWidth;
       }
       return matrix;
    }

方法二：
通过bitmap剪切：前面有提到过可以将捕获的YUV数据转化为bitmap，当然可以通过bitmap的相关方法剪切
即：根据原来的bitmap剪切出来一个新的
参数说明：
rBitmap ： 被剪切的原图
retX ：剪切矩形左上角的x坐标（相对于原图）
retY : 剪切矩形左上角的y坐标
width：剪切矩形的宽度
height： 剪切矩形的高度
bitmap = Bitmap.createBitmap(rBitmap, retX, retY, width,height);



附图1