Java Android摄像头存储图片（原始）：更新后的奇怪图片

目前，我正在尝试使用安卓摄像头，我的测试项目已经完成了很多。在我的HTC Desire S上使用姜饼Android进行测试时，它工作得非常好。然而，在我更新到ICS后，用测试应用程序拍摄的照片只显示奇怪的垂直线（代码完全相同）。 以下是现在突然创建的图像：

这是我的代码（全班）：

package-inter.rebuilder；
导入inter.rebuilder.R；
导入java.io.BufferedOutputStream；
导入java.io.ByteArrayOutputStream；
导入java.io.File；
导入java.io.FileNotFoundException；
导入java.io.FileOutputStream；
导入java.io.IOException；
导入java.util.List；
导入android.app.Activity；
导入android.content.Context；
导入android.content.Intent；
导入android.content.pm.PackageManager；
导入android.content.res.Configuration；
导入android.graphics.Bitmap；
导入android.graphics.BitmapFactory；
导入android.graphics.Color；
导入android.graphics.ImageFormat；
导入android.graphics.Matrix；
导入android.graphics.PixelFormat；
导入android.graphics.Bitmap.CompressFormat；
导入android.graphics.Rect；
导入android.graphics.YuvImage；
导入android.hardware.Camera；
导入android.hardware.Camera.AutoFocusCallback；
导入android.hardware.Camera.ErrorCallback；
导入android.hardware.Camera.PreviewCallback；
导入android.hardware.Camera.Size；
导入android.os.Bundle；
导入android.os.Environment；
导入android.util.Log；
导入android.view.KeyEvent；
导入android.view.Menu；
导入android.view.MotionEvent；
导入android.view.Surface；
导入android.view.SurfaceHolder；
导入android.view.SurfaceView；
导入android.view.view；
导入android.view.Window；
导入android.view.WindowManager；
导入android.view.view.OnClickListener；
导入android.view.view.OnTouchListener；
公共类CameraView扩展活动实现SurfaceHolder.Callback，
onclick侦听器{
静态最终int FOTO_模式=0；
私有静态最终字符串TAG=“CameraTest”；
麦克默拉照相机；
布尔值mPreviewRunning=false；
私有上下文mContext=此；
创建公共空间（捆绑冰柱）{
超级冰柱；
//布尔hasCam=checkCameraHardware（mContext）；
Log.e（标记为“onCreate”）；
Bundle extras=getIntent（）.getExtras（）；
getWindow（）.setFormat（像素格式.半透明）；
requestWindowFeature（窗口。功能\u无\u标题）；
getWindow（）.setFlags（WindowManager.LayoutParams.FLAG_全屏，
WindowManager.LayoutParams.FLAG（全屏）；
setContentView（R.layout.main）；
mSurfaceView=（SurfaceView）findViewById（R.id.surface\u摄像头）；
mSurfaceView.setOnClickListener（这个）；
mSurfaceHolder=mSurfaceView.getHolder（）；
mSurfaceHolder.addCallback（此）；
mSurfaceHolder.setType（SurfaceHolder.SURFACE类型推送缓冲区）；
}
@凌驾
RestoreInstanceState上的受保护无效（Bundle savedInstanceState）{
super.onRestoreInstanceState（savedInstanceState）；
}
Camera.PreviewCallback mPreviewCallback=新建PreviewCallback（）{
预览帧上的公共无效（字节[]数据，摄像头）{
Camera.Parameters=Camera.getParameters（）；
int width=parameters.getPreviewSize（）.width；
int height=parameters.getPreviewSize（）.height；
ByteArrayOutputStream Outtr=新建ByteArrayOutputStream（）；
Rect Rect=新的Rect（0，0，宽度，高度）；
YuvImage YuvImage=新的YuvImage（数据，ImageFormat.NV21，宽度，高度，null）；
yuvimage.compressToJpeg（rect，100，outtr）；
位图bmp=BitmapFactory.decodeByteArray（outstr.toByteArray（），0，outstr.size（））；
}
};
Camera.PictureCallback mPictureCallback=新建Camera.PictureCallback（）{
公共void onPictureTaken（字节[]图像数据，摄像机c）{
如果（imageData！=null）{
Intent MINENT=新Intent（）；
storeByteImage（mContext，imageData，100）；
试一试{
mCamera.unlock（）；
mCamera.reconnect（）；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
设置结果（FOTO_模式，MINENT）；
startCameraPreview（）；
//mCamera.startPreview（）；
//完成（）；
//Intent Intent=newintent（CameraView.this、AndroidBoxExample.class）；
//摄像师。这。星际触觉（意图）；
}
}
};
专用布尔checkCameraHardware（上下文）{
if（context.getPackageManager（）.hasSystemFeature（PackageManager.FEATURE\u摄像头））{
//这个装置有一个照相机
返回true；
}否则{
//此设备上没有摄像头
返回false；
}
}
受保护的void onResume（）{
Log.e（标签“onResume”）；
super.onResume（）；
}
SaveInstanceState上受保护的无效（束超出状态）{
super.onSaveInstanceState（超出状态）；
}
受保护的void onPause（）{
Log.e（标签“onPause”）；
super.onPause（）；
}
受保护的void onStop（）{
Log.e（标签“顶部”）；
super.onStop（）；
}
已创建的公共空白表面（表面持有人）{
Log.e（标签“表面处理”）；
mCamera=Camera.open（）；
//mCamera.unlock（）；
//mCamera.setDisplayOrientation（180）；
}
私有void startCameraPreview（）{
Camera.Parameters p=mCamera.getParameters（）；
p、 setPictureFormat（PixelFormat.JPEG）；
//p、 设置预览大小（w，h）；
List List=p.getSupportedPreviewSizes（）；
Camera.Size=list.get（0）；
p、 setPreviewSize（size.width、size.height）；
mCamera.setParameters（p）；
mCamera.startPreview（）；
mPreview
    package inter.rebuilder;

import inter.rebuilder.R;

import java.io.BufferedOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.List;

import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.content.res.Configuration;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Color;
import android.graphics.ImageFormat;
import android.graphics.Matrix;
import android.graphics.PixelFormat;
import android.graphics.Bitmap.CompressFormat;
import android.graphics.Rect;
import android.graphics.YuvImage;
import android.hardware.Camera;
import android.hardware.Camera.AutoFocusCallback;
import android.hardware.Camera.ErrorCallback;
import android.hardware.Camera.PreviewCallback;
import android.hardware.Camera.Size;
import android.os.Bundle;
import android.os.Environment;
import android.util.Log;
import android.view.KeyEvent;
import android.view.Menu;
import android.view.MotionEvent;
import android.view.Surface;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.View;
import android.view.Window;
import android.view.WindowManager;
import android.view.View.OnClickListener;
import android.view.View.OnTouchListener;

public class CameraView extends Activity implements SurfaceHolder.Callback,
        OnClickListener {
    static final int FOTO_MODE = 0;
    private static final String TAG = "CameraTest";
    Camera mCamera;
    boolean mPreviewRunning = false;
    private Context mContext = this;

    public void onCreate(Bundle icicle) {
        super.onCreate(icicle);
        //boolean hasCam = checkCameraHardware(mContext);
        Log.e(TAG, "onCreate");

        Bundle extras = getIntent().getExtras();

        getWindow().setFormat(PixelFormat.TRANSLUCENT);
        requestWindowFeature(Window.FEATURE_NO_TITLE);
        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
                WindowManager.LayoutParams.FLAG_FULLSCREEN);
        setContentView(R.layout.main);
        mSurfaceView = (SurfaceView) findViewById(R.id.surface_camera);
        mSurfaceView.setOnClickListener(this);
        mSurfaceHolder = mSurfaceView.getHolder();
        mSurfaceHolder.addCallback(this);
        mSurfaceHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
    }

    @Override
    protected void onRestoreInstanceState(Bundle savedInstanceState) {
        super.onRestoreInstanceState(savedInstanceState);
    }

    Camera.PreviewCallback mPreviewCallback = new PreviewCallback() {

        public void onPreviewFrame(byte[] data, Camera camera) {

            Camera.Parameters parameters = camera.getParameters();

            int width = parameters.getPreviewSize().width;
            int height = parameters.getPreviewSize().height;

            ByteArrayOutputStream outstr = new ByteArrayOutputStream();
            Rect rect = new Rect(0, 0, width, height); 
            YuvImage yuvimage=new YuvImage(data,ImageFormat.NV21,width,height,null);
            yuvimage.compressToJpeg(rect, 100, outstr);
            Bitmap bmp = BitmapFactory.decodeByteArray(outstr.toByteArray(), 0, outstr.size());
        }
    };

    Camera.PictureCallback mPictureCallback = new Camera.PictureCallback() {
        public void onPictureTaken(byte[] imageData, Camera c) {

            if (imageData != null) {
                Intent mIntent = new Intent();
                storeByteImage(mContext, imageData, 100);
                try {
                    mCamera.unlock();
                    mCamera.reconnect();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                setResult(FOTO_MODE, mIntent);
                startCameraPreview();

                //mCamera.startPreview();
                //finish();
                //Intent intent = new Intent(CameraView.this, AndroidBoxExample.class);
                //CameraView.this.startActivity(intent);
            }
        }
    };

    private boolean checkCameraHardware(Context context) {
        if (context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_CAMERA)){
            // this device has a camera
            return true;
        } else {
            // no camera on this device
            return false;
        }
    }

    protected void onResume() {
        Log.e(TAG, "onResume");
        super.onResume();
    }

    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
    }

    protected void onPause() {
        Log.e(TAG, "onPause");
        super.onPause();
    }

    protected void onStop() {
        Log.e(TAG, "onStop");
        super.onStop();
    }

    public void surfaceCreated(SurfaceHolder holder) {
        Log.e(TAG, "surfaceCreated");
        mCamera = Camera.open();
        //mCamera.unlock();
        //mCamera.setDisplayOrientation(180);

    }

    private void startCameraPreview() {
        Camera.Parameters p = mCamera.getParameters();
        p.setPictureFormat(PixelFormat.JPEG);
        //p.setPreviewSize(w, h);

        List<Size> list = p.getSupportedPreviewSizes();
        Camera.Size size = list.get(0);
        p.setPreviewSize(size.width, size.height);
        mCamera.setParameters(p);
        mCamera.startPreview();
        mPreviewRunning = true;
    }

    private void startCameraPreview(SurfaceHolder holder) {
        Camera.Parameters p = mCamera.getParameters();
        //p.setPreviewSize(w, h);

        List<Size> list = p.getSupportedPreviewSizes();
        Camera.Size size = list.get(0);
        p.setPreviewSize(size.width, size.height);
        mCamera.setParameters(p);
        try {
            mCamera.setPreviewDisplay(holder);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        mCamera.startPreview();
        mPreviewRunning = true;
        //setCameraDisplayOrientation(this, 0, mCamera);
    }

    public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
        Log.e(TAG, "surfaceChanged");

        // XXX stopPreview() will crash if preview is not running
        if (mPreviewRunning) {
            mCamera.stopPreview();
            mPreviewRunning = false;
        }

        startCameraPreview(holder);
    }

    public void surfaceDestroyed(SurfaceHolder holder) {
        Log.e(TAG, "surfaceDestroyed");
        mCamera.setPreviewCallback(null);
        mCamera.stopPreview();
        mPreviewRunning = false;
        mCamera.release();
    }



    @Override
    public void onConfigurationChanged(Configuration newConfig) {
        // TODO Auto-generated method stub
        mCamera.setPreviewCallback(null);
        mCamera.stopPreview();
        mPreviewRunning = false;
        mCamera.release();
        super.onConfigurationChanged(newConfig);
    }

    @Override
    public void onContentChanged() {
        // TODO Auto-generated method stub
        super.onContentChanged();
    }

    @Override
    public void onContextMenuClosed(Menu menu) {
        // TODO Auto-generated method stub
        mCamera.setPreviewCallback(null);
        mCamera.stopPreview();
        mPreviewRunning = false;
        mCamera.release();
        super.onContextMenuClosed(menu);
    }

    private SurfaceView mSurfaceView;
    private SurfaceHolder mSurfaceHolder;

    public void onClick(View arg0) {

        mCamera.takePicture(null, mPictureCallback, mPictureCallback);

    }

    private static File createDir() throws IOException {
        String nameDir = "rebuilder";
        File extStorageDir = Environment.getExternalStorageDirectory();
        File sdImageMainDirectory = extStorageDir; //new File("/sdcard");
        File dirFile = new File(sdImageMainDirectory.getPath()+"/"+nameDir);

        boolean fileExisted = dirFile.exists();
        if(!fileExisted) {
            dirFile.mkdirs();
        }
        return dirFile;
    }

    private static File createFile(String name, File dirFile) throws IOException {
        int counter = 1;
        String fileName = name + counter+".jpg";
        File imageFile = new File(dirFile.getPath()+"/"+fileName);
        while(imageFile.exists()) {
            counter = counter + 1;
            fileName = name + counter+".jpg";
            imageFile = new File(dirFile.getPath()+"/"+fileName);
        }
        imageFile.createNewFile();
        return imageFile;
    }

    static Bitmap image1 = null;
    static Bitmap image2 = null;
    public static void blendTest(Bitmap myImage) throws IOException {
        if(image1 == null && image2 == null) {
            image1 = myImage;
            return;
        }

        if(image1 != null && image2 != null) {
            image2 = null;
            image1 = myImage;
            return;
        }

        if(image1 != null && image2 == null) {
            image2 = myImage;
        }

        int width = Math.min(image1.getWidth(), image2.getWidth());
        int height = Math.min(image1.getHeight(), image2.getHeight());
        int[][] pixels1 = new int[width][height];
        int[][] pixels2 = new int[width][height];

        for(int i = 0; i < width; i++) {
            for(int j = 0; j < height; j++) {
                pixels1[i][j] = image1.getPixel(i, j);
            }
        }

        for(int i = 0; i < width; i++) {
            for(int j = 0; j < height; j++) {
                pixels2[i][j] = image2.getPixel(i, j);
            }
        }

        Bitmap image3 = Bitmap.createBitmap(width, height, image1.getConfig());
        for(int i = 0; i < width; i++) {
            for(int j = 0; j < height; j++) {
                int color1 = pixels1[i][j];
                int color2 = pixels2[i][j];

                int red1 = Color.red(color1);
                int red2 = Color.red(color2);
                int green1 = Color.green(color1);
                int green2 = Color.green(color2);
                int blue1 = Color.blue(color1);
                int blue2 = Color.blue(color2);

                int newColor = Color.rgb((red1 + red2)/2, (green1 + green2)/2, (blue1 + blue2)/2);
                image3.setPixel(i, j, newColor);
            }
        }

        File dirFile = createDir();
        File newBlend = createFile("blend", dirFile);

        FileOutputStream fileOutputStream = new FileOutputStream(newBlend);         

        BufferedOutputStream bos = new BufferedOutputStream(
                fileOutputStream);

        image3.compress(CompressFormat.JPEG, 100, bos);

        bos.flush();
        bos.close();

    }

//   public static void setCameraDisplayOrientation(Activity activity,
//           int cameraId, android.hardware.Camera camera) {
//       android.hardware.Camera.CameraInfo info =
//               new android.hardware.Camera.CameraInfo();
//       android.hardware.Camera.getCameraInfo(cameraId, info);
//       int rotation = activity.getWindowManager().getDefaultDisplay()
//               .getRotation();
//       int degrees = 0;
//       switch (rotation) {
//           case Surface.ROTATION_0: degrees = 0; break;
//           case Surface.ROTATION_90: degrees = 90; break;
//           case Surface.ROTATION_180: degrees = 180; break;
//           case Surface.ROTATION_270: degrees = 270; break;
//       }
//
//       int result;
//       if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
//           result = (info.orientation + degrees) % 360;
//           result = (360 - result) % 360;  // compensate the mirror
//       } else {  // back-facing
//           result = (info.orientation - degrees + 360) % 360;
//       }
//       camera.setDisplayOrientation(result);
//   }

    public static boolean storeByteImage(Context mContext, byte[] imageData, int quality) {
        FileOutputStream fileOutputStream = null;       
        try {
            File dirFile = createDir();
            File imageFile = createFile("rebuilder", dirFile);

            BitmapFactory.Options options=new BitmapFactory.Options();
            options.inSampleSize = 5;  //5

            options.inDither = false; // Disable Dithering mode
            options.inPurgeable = true; // Tell to gc that whether it needs free
                                        // memory, the Bitmap can be cleared
            options.inInputShareable = true; // Which kind of reference will be
                                                // used to recover the Bitmap
                                                // data after being clear, when
                                                // it will be used in the future
            options.inTempStorage = new byte[32 * 1024];
            options.inPreferredConfig = Bitmap.Config.RGB_565;

            Bitmap myImage = BitmapFactory.decodeByteArray(imageData, 0,
                    imageData.length,options);

            int orientation;
             // others devices
            if(myImage.getHeight() < myImage.getWidth()){
                orientation = 90;
            } else {
                orientation = 0;
            }

            Bitmap bMapRotate;
            if (orientation != 0) {
                Matrix matrix = new Matrix();
                matrix.postRotate(orientation);
                bMapRotate = Bitmap.createBitmap(myImage, 0, 0, myImage.getWidth(),
                        myImage.getHeight(), matrix, true);
            } else
                bMapRotate = Bitmap.createScaledBitmap(myImage, myImage.getWidth(),
                        myImage.getHeight(), true);


            //blendTest(myImage);

            fileOutputStream = new FileOutputStream(imageFile);         

            BufferedOutputStream bos = new BufferedOutputStream(
                    fileOutputStream);

            bMapRotate.compress(CompressFormat.JPEG, quality, bos);
            if (bMapRotate != null) {
                bMapRotate.recycle();
                bMapRotate = null;
            }

            bos.flush();
            bos.close();

        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            System.out.println("SD Card not ready");
        }


        return true;
    }

}

    //   public static void setCameraDisplayOrientation(Activity activity,
    //           int cameraId, android.hardware.Camera camera) {
    //       android.hardware.Camera.CameraInfo info =
    //               new android.hardware.Camera.CameraInfo();
    //       android.hardware.Camera.getCameraInfo(cameraId, info);
    //       int rotation = activity.getWindowManager().getDefaultDisplay()
    //               .getRotation();
    //       int degrees = 0;
    //       switch (rotation) {
    //           case Surface.ROTATION_0: degrees = 0; break;
    //           case Surface.ROTATION_90: degrees = 90; break;
    //           case Surface.ROTATION_180: degrees = 180; break;
    //           case Surface.ROTATION_270: degrees = 270; break;
    //       }
    //
    //       int result;
    //       if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
    //           result = (info.orientation + degrees) % 360;
    //           result = (360 - result) % 360;  // compensate the mirror
    //       } else {  // back-facing
    //           result = (info.orientation - degrees + 360) % 360;
    //       }
    //       camera.setDisplayOrientation(result);
    //   }