Android JavaCameraView图像预览失真且不成比例

所以，我正在使用OpenCv库来识别图片中的图像。我使用的是

JavaCameraView

，它在大多数设备上运行良好，但在某些设备上，它可以做到：

好照片（三星Galaxy s6 edge plus）

这是一张照片（三星J5和华为p7）

现在，我不知道问题在哪里，因为我在网上找不到任何解决方案，也许有人有类似的问题

这是我的

JavaCameraView

代码：

    /**
 * This class is an implementation of the Bridge View between OpenCV and Java Camera.
 * This class relays on the functionality available in base class and only implements
 * required functions:
 * connectCamera - opens Java camera and sets the PreviewCallback to be delivered.
 * disconnectCamera - closes the camera and stops preview.
 * When frame is delivered via callback from Camera - it processed via OpenCV to be
 * converted to RGBA32 and then passed to the external callback for modifications if required.
 */
public class JavaCameraView extends CameraBridgeViewBase implements PreviewCallback {

    private static final int MAGIC_TEXTURE_ID = 10;
    private static final String TAG = "JavaCameraView";
    protected Camera mCamera;
    protected JavaCameraFrame[] mCameraFrame;
    private byte mBuffer[];
    private Mat[] mFrameChain;
    private int mChainIdx = 0;
    private Thread mThread;
    private boolean mStopThread;
    private SurfaceTexture mSurfaceTexture;
    private boolean mCameraFrameReady = false;

    public JavaCameraView(Context context, int cameraId) {
        super(context, cameraId);
    }

    public JavaCameraView(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    protected boolean initializeCamera(int width, int height) {
        Log.d(TAG, "Initialize java camera");
        boolean result = true;
        synchronized (this) {
            mCamera = null;

            if (mCameraIndex == CAMERA_ID_ANY) {
                Log.d(TAG, "Trying to open camera with old open()");
                try {
                    mCamera = Camera.open();
                } catch (Exception e) {
                    Log.e(TAG, "Camera is not available (in use or does not exist): " + e.getLocalizedMessage());
                }

                if (mCamera == null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.GINGERBREAD) {
                    boolean connected = false;
                    for (int camIdx = 0; camIdx < Camera.getNumberOfCameras(); ++camIdx) {
                        Log.d(TAG, "Trying to open camera with new open(" + Integer.valueOf(camIdx) + ")");
                        try {
                            mCamera = Camera.open(camIdx);
                            connected = true;
                        } catch (RuntimeException e) {
                            Log.e(TAG, "Camera #" + camIdx + "failed to open: " + e.getLocalizedMessage());
                        }
                        if (connected) break;
                    }
                }
            } else {
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.GINGERBREAD) {
                    int localCameraIndex = mCameraIndex;
                    if (mCameraIndex == CAMERA_ID_BACK) {
                        Log.i(TAG, "Trying to open back camera");
                        Camera.CameraInfo cameraInfo = new Camera.CameraInfo();
                        for (int camIdx = 0; camIdx < Camera.getNumberOfCameras(); ++camIdx) {
                            Camera.getCameraInfo(camIdx, cameraInfo);
                            if (cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_BACK) {
                                localCameraIndex = camIdx;
                                break;
                            }
                        }
                    } else if (mCameraIndex == CAMERA_ID_FRONT) {
                        Log.i(TAG, "Trying to open front camera");
                        Camera.CameraInfo cameraInfo = new Camera.CameraInfo();
                        for (int camIdx = 0; camIdx < Camera.getNumberOfCameras(); ++camIdx) {
                            Camera.getCameraInfo(camIdx, cameraInfo);
                            if (cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
                                localCameraIndex = camIdx;
                                break;
                            }
                        }
                    }
                    if (localCameraIndex == CAMERA_ID_BACK) {
                        Log.e(TAG, "Back camera not found!");
                    } else if (localCameraIndex == CAMERA_ID_FRONT) {
                        Log.e(TAG, "Front camera not found!");
                    } else {
                        Log.d(TAG, "Trying to open camera with new open(" + Integer.valueOf(localCameraIndex) + ")");
                        try {
                            mCamera = Camera.open(localCameraIndex);
                        } catch (RuntimeException e) {
                            Log.e(TAG, "Camera #" + localCameraIndex + "failed to open: " + e.getLocalizedMessage());
                        }
                    }
                }
            }

            if (mCamera == null)
                return false;

            /* Now set camera parameters */
            try {
                Camera.Parameters params = mCamera.getParameters();
                Log.d(TAG, "getSupportedPreviewSizes()");
                List<android.hardware.Camera.Size> sizes = params.getSupportedPreviewSizes();

                if (sizes != null) {
                    /* Select the size that fits surface considering maximum size allowed */
                    Size frameSize = calculateCameraFrameSize(sizes, new JavaCameraSizeAccessor(), width, height);

                    params.setPreviewFormat(ImageFormat.NV21);
                    Log.d(TAG, "Set preview size to " + Integer.valueOf((int) frameSize.width) + "x" + Integer.valueOf((int) frameSize.height));
                    params.setPreviewSize((int) frameSize.width, (int) frameSize.height);

                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH && !android.os.Build.MODEL.equals("GT-I9100"))
                        params.setRecordingHint(true);

                    List<String> FocusModes = params.getSupportedFocusModes();
                    if (FocusModes != null && FocusModes.contains(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO)) {
                        params.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO);
                    }

                    mCamera.setParameters(params);
                    params = mCamera.getParameters();

                    mFrameWidth = params.getPreviewSize().width;
                    mFrameHeight = params.getPreviewSize().height;

                    if ((getLayoutParams().width == LayoutParams.MATCH_PARENT) && (getLayoutParams().height == LayoutParams.MATCH_PARENT))
                        mScale = Math.min(((float) height) / mFrameHeight, ((float) width) / mFrameWidth);
                    else
                        mScale = 0;


                    int size = mFrameWidth * mFrameHeight;
                    size = size * ImageFormat.getBitsPerPixel(params.getPreviewFormat()) / 8;
                    mBuffer = new byte[size];

                    mCamera.addCallbackBuffer(mBuffer);
                    mCamera.setPreviewCallbackWithBuffer(this);

                    mFrameChain = new Mat[2];
                    mFrameChain[0] = new Mat(mFrameHeight + (mFrameHeight / 2), mFrameWidth, CvType.CV_8UC1);
                    mFrameChain[1] = new Mat(mFrameHeight + (mFrameHeight / 2), mFrameWidth, CvType.CV_8UC1);

                    AllocateCache();

                    mCameraFrame = new JavaCameraFrame[2];
                    mCameraFrame[0] = new JavaCameraFrame(mFrameChain[0], mFrameWidth, mFrameHeight);
                    mCameraFrame[1] = new JavaCameraFrame(mFrameChain[1], mFrameWidth, mFrameHeight);

                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
                        mSurfaceTexture = new SurfaceTexture(MAGIC_TEXTURE_ID);
                        mCamera.setPreviewTexture(mSurfaceTexture);
                    } else
                        mCamera.setPreviewDisplay(null);

                    /* Finally we are ready to start the preview */
                    Log.d(TAG, "startPreview");
                    mCamera.startPreview();


//                    mCamera.autoFocus(new Camera.AutoFocusCallback() {
//                        @Override
//                        public void onAutoFocus(boolean success, Camera camera) {
//                            Log.d("Autofocus", String.valueOf(success));
//                        }
//                    });

                } else
                    result = false;
            } catch (Exception e) {
                result = false;
                e.printStackTrace();
            }
        }

        return result;
    }

//    protected void setDisplayOrientation(Camera camera, int angle) {
//        Method downPolymorphic;
//        try {
//            downPolymorphic = camera.getClass().getMethod("setDisplayOrientation", new Class[]{int.class});
//            if (downPolymorphic != null)
//                downPolymorphic.invoke(camera, new Object[]{angle});
//        } catch (Exception e1) {
//        }
//    }

    protected void releaseCamera() {
        synchronized (this) {
            if (mCamera != null) {
                mCamera.stopPreview();
                mCamera.setPreviewCallback(null);

                mCamera.release();
            }
            mCamera = null;
            if (mFrameChain != null) {
                mFrameChain[0].release();
                mFrameChain[1].release();
            }
            if (mCameraFrame != null) {
                mCameraFrame[0].release();
                mCameraFrame[1].release();
            }
        }
    }

public void turnOffTheFlash() {
    Camera.Parameters params = mCamera.getParameters();
    params.setFlashMode(Camera.Parameters.FLASH_MODE_OFF);
    mCamera.setParameters(params);
}

public void turnOnTheFlash() {
    Camera.Parameters params = mCamera.getParameters();
    params.setFlashMode(Camera.Parameters.FLASH_MODE_TORCH);
    mCamera.setParameters(params);
}

@Override
protected boolean connectCamera(int width, int height) {

    /* 1. We need to instantiate camera
     * 2. We need to start thread which will be getting frames
     */
    /* First step - initialize camera connection */
    Log.d(TAG, "Connecting to camera");
    if (!initializeCamera(width, height))
        return false;

    mCameraFrameReady = false;

    /* now we can start update thread */
    Log.d(TAG, "Starting processing thread");
    mStopThread = false;
    mThread = new Thread(new CameraWorker());
    mThread.start();

    return true;
}

@Override
protected void disconnectCamera() {
    /* 1. We need to stop thread which updating the frames
     * 2. Stop camera and release it
     */
    Log.d(TAG, "Disconnecting from camera");
    try {
        mStopThread = true;
        Log.d(TAG, "Notify thread");
        synchronized (this) {
            this.notify();
        }
        Log.d(TAG, "Wating for thread");
        if (mThread != null)
            mThread.join();
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        mThread = null;
    }

    /* Now release camera */
    releaseCamera();

    mCameraFrameReady = false;
}

@Override
public void onPreviewFrame(byte[] frame, Camera arg1) {
    if (BuildConfig.DEBUG)
        Log.d(TAG, "Preview Frame received. Frame size: " + frame.length);
    synchronized (this) {
        mFrameChain[mChainIdx].put(0, 0, frame);
        mCameraFrameReady = true;
        this.notify();
    }
    if (mCamera != null)
        mCamera.addCallbackBuffer(mBuffer);
}

public static class JavaCameraSizeAccessor implements ListItemAccessor {

    @Override
    public int getWidth(Object obj) {
        Camera.Size size = (Camera.Size) obj;
        return size.width;
    }

    @Override
    public int getHeight(Object obj) {
        Camera.Size size = (Camera.Size) obj;
        return size.height;
    }
}

private class JavaCameraFrame implements CvCameraViewFrame {
    private Mat mYuvFrameData;
    private Mat mRgba;
    private int mWidth;
    private int mHeight;

    public JavaCameraFrame(Mat Yuv420sp, int width, int height) {
        super();
        mWidth = width;
        mHeight = height;
        mYuvFrameData = Yuv420sp;
        mRgba = new Mat();
    }

    @Override
    public Mat gray() {
        return mYuvFrameData.submat(0, mHeight, 0, mWidth);
    }

    @Override
    public Mat rgba() {
        Imgproc.cvtColor(mYuvFrameData, mRgba, Imgproc.COLOR_YUV2RGBA_NV21, 4);
        return mRgba;
    }

    public void release() {
        mRgba.release();
    }
}

;

private class CameraWorker implements Runnable {

    @Override
    public void run() {
        do {
            boolean hasFrame = false;
            synchronized (JavaCameraView.this) {
                try {
                    while (!mCameraFrameReady && !mStopThread) {
                        JavaCameraView.this.wait();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (mCameraFrameReady) {
                    mChainIdx = 1 - mChainIdx;
                    mCameraFrameReady = false;
                    hasFrame = true;
                }
            }

            if (!mStopThread && hasFrame) {
                if (!mFrameChain[1 - mChainIdx].empty())
                    deliverAndDrawFrame(mCameraFrame[1 - mChainIdx]);
            }
        } while (!mStopThread);
        Log.d(TAG, "Finish processing thread");
    }
}

/**
*此类是OpenCV和Java Camera之间桥接视图的实现。
*此类依赖于基类中可用的功能，并且仅实现
*所需功能：
*connectCamera-打开Java camera并设置要交付的预览回调。
*断开摄影机-关闭摄影机并停止预览。
*当帧通过相机的回调传递时，它通过OpenCV进行处理
*转换为RGBA32，然后传递到外部回调进行修改（如果需要）。
*/
公共类JavaCameraView扩展了CameraBridgeViewBase，实现了PreviewCallback{
私有静态最终整型魔法纹理ID=10；
私有静态最终字符串TAG=“JavaCameraView”；
受保护的摄像机mCamera；
受保护的JavaCameraFrame[]mCameraFrame；
专用字节mBuffer[]；
私人地毯链；
私有整数mChainIdx=0；
私有线程mThread；
私有布尔mStopThread；
私人表面结构；
私有布尔值mCameraFrameReady=false；
公共JavaCameraView（上下文，int-cameraview）{
超级（上下文，cameraId）；
}
公共JavaCameraView（上下文，属性集属性）{
超级（上下文，attrs）；
}
受保护的布尔初始值设定项（整数宽度、整数高度）{
d（标记“初始化java摄像头”）；
布尔结果=真；
已同步（此）{
mCamera=null；
如果（mCameraIndex==摄像机ID\u任何）{
Log.d（标记“尝试用旧的open（）打开相机”）；
试一试{
mCamera=Camera.open（）；
}捕获（例外e）{
Log.e（标记“照相机不可用（正在使用或不存在）：”+e.getLocalizedMessage（））；
}
if（mCamera==null&&Build.VERSION.SDK\u INT>=Build.VERSION\u code.gingerbrand）{
布尔连接=假；
对于（int-camIdx=0；camIdx=Build.VERSION\u code.gingerbrand）{
int localCameraIndex=mcameraaindex；
如果（mCameraIndex==摄像机ID\u返回）{
Log.i（标签，“试图打开后摄像头”）；
Camera.CameraInfo CameraInfo=新的Camera.CameraInfo（）；
对于（int-camIdx=0；camIdx