Android 音视频开发(三) -- Camera2 实现预览、拍照功能

最新推荐文章于 2023-12-14 15:45:06 发布

夏至的稻穗

最新推荐文章于 2023-12-14 15:45:06 发布

阅读量5.1k

点赞数 8

分类专栏： Android 音视频文章标签： Camera2 Camera2预览 Camera2拍照 ImageReader CaptureRequest

本文链接：https://blog.csdn.net/u011418943/article/details/107279236

版权

Android 音视频专栏收录该内容

27 篇文章 93 订阅

订阅专栏

音视频系列文章
Android 音视频开发(一) – 使用AudioRecord 录制PCM(录音)；AudioTrack播放音频
 Android 音视频开发(二) – Camera1 实现预览、拍照功能
 Android 音视频开发(三) – Camera2 实现预览、拍照功能
 Android 音视频开发(四) – CameraX 实现预览、拍照功能
 Android 音视频开发(五) – 使用 MediaExtractor 分离音视频，并使用 MediaMuxer合成新视频(音视频同步)
音视频工程

上一章，已经我们已经用 Camera1 实现了预览和拍照的功能，但也说到，在API21的时候，Camera1已经被标注为弃用，因为它的API功能和灵活性满足不了现在日益复杂的相机开发了，所以在 API21之后，引入了 Camera2 。

一. Camera2 简介

从功能来讲，Camera2 废弃了 Camera1 的框架，它支持更多的功能，比如：

获取更多的帧(预览/拍照)信息，以及每一帧的参数配置
支持更多的图片格式(yuv/raw)等
一些新特性
…

而今天要完成的效果如下：
在这里插入图片描述

1.1. Pipeline

Camera2 的将摄像头包装成管道(Pipeline)，它会捕获单个帧的输入请求，每个请求捕获单个图像，然后把这些数据包装成数据包，从而把这些图像数据输出到图片缓冲区中。

这些请求时按顺序处理的，它按顺序处理每一帧的请求，并返回请求结果给客户端，看下面这张图：

在这里插入图片描述
假设我们要拍摄同时拍摄两张不同尺寸的图片，那么它的过程应该是这样的：

创建一个用于 Pipeline 获取图片信息的 CaptureRequest
创建两个不同的 Surface ，用来接收图片数据，并把他们加到 CaptureRequest 中
发送配置好的的 CaptureRequest 到Pipeline 中，等待返回拍照结果

上面需要记住的是，CaptureReuqest 创建之前，我们已经把相机的数据都配置好，比如聚焦、闪光灯等，接着才把它输入给 Camrea2 的底层，它会被放入到一个被叫做 In-Flight Capture Queue 的队列中，当 In-Flight Capture Queue 队列空闲时，我们就可以从它拿到不同的图片数据 给到Surface ，且能拿到 CaptureResult 这个返回结果信息。

1.2. Supported Hardware Level

我们支持，Camera 支持了很多新功能的特性，但这也要看你的手机厂商的支持程度，所以，为了方便区分，Camera2 使用 Supported Hardware Level 来判断你是否支持 Camera2 的特性，它分为4个登记：

LEGACY ：向后兼容模式，支持Camera1 的功能，不支持 Camera2 的新特性
LIMITED ：除了支持 Camera1 的特性，还支持部分 Camera2 的高级特性
FULL ：支持所有 Camera2 的高级特性
LEVEL_3 ：新增更多的 Camera2 特性，利于YUV 数据等

下面我们将根据这些特性，来完成 Camera2 的开发。

二. 相机预览

要注意的是，Camera2 与 Camera1 是两个不同的框架，不要被 Camera1 的思想禁锢，把它当做新知识学习即可，一个相机的流程图如下：
在这里插入图片描述

通过context.getSystemService(Context.CAMERA_SERVICE) 获取CameraManager.
通过 getCameraCharacteristics() 方法，拿到相机的所有信息，比如支持的预览大小，level 等
通过 CameraManager 的 openCamera() 方法，从回调中拿到 CameraDevice ，它表示当前相机设备
CameraDevice 通过 createCaptureRequest 创建 CaptureRequest.Builder ，用来配置相机属性，通过 createCaptureSession 创建 CameraCaptureSession ，它是 Pipeline 的实例，然后交给底层处理

别忘了，您要添加以下权限：

    <uses-permission android:name="android.permission.CAMERA" /> <!-- 支持相机才能运行 -->
    <!--需要设备有相机-->
    <uses-feature
        android:name="android.hardware.camera"
        android:required="true" />
    <uses-feature android:name="android.hardware.camera.autofocus" />

2.1. 获取相机信息

从上面的流程图支持，我们需要通过 CameraManager 的 getCameraCharacteristics() 方法，来获取相机的信息;
CameraManager 是一个负责查询和建立相机连接的系统服务，它的功能不多，主要如下：

将相机信息装载到 CameraCharacteristics 中。
根据指定的相机ID 连接相机
提供将闪光灯设置为手电筒的快捷方式

所以它的代码如下：

try {
    //获取相机服务 CameraManager
    mCameraManager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);

    //遍历设备支持的相机 ID ，比如前置，后置等
    String[] cameraIdList = mCameraManager.getCameraIdList();
    for (String cameraId : cameraIdList) {
        // 拿到装在所有相机信息的  CameraCharacteristics 类
        CameraCharacteristics characteristics = mCameraManager.getCameraCharacteristics(cameraId);
        //拿到相机的方向，前置，后置，外置
        Integer facing = characteristics.get(CameraCharacteristics.LENS_FACING);

        if (facing != null) {
            //后置摄像头
            if (facing == CameraCharacteristics.LENS_FACING_BACK) {
                mBackCameraId = cameraId;
                mBackCameraCharacteristics = characteristics;
            }else if (facing == CameraCharacteristics.LENS_FACING_FRONT){
                //前置摄像头
                mFrontCameraId = cameraId;
                mFrontCameraCharacteristics = characteristics;
            }
            mCameraId = cameraId;
        }

        //是否支持 Camera2 的高级特性
        Integer level = characteristics.get(CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL);
        /**
         * 不支持 Camera2 的特性
         */
        if (level == null || level == CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LEGACY){
          //  Toast.makeText(this, "您的手机不支持Camera2的高级特效", Toast.LENGTH_SHORT).show();
         //   break;
        }

    }

} catch (CameraAccessException e) {
    e.printStackTrace();
}

上面的注释都很清晰了，我们是通过 CameraCharacteristics 去知道当前的相机方向；除了这些，它还包含相机的其他信息，比如：

是否有闪光灯 FLASH_INFO_AVAILABLE
是否有 AE 模式 CONTROL_AE_AVAILABLE_MODES
光爆等，如果你对 Camera1 比较熟悉，那么 CameraCharacteristics 有点像 Camera1 的 Camera.CameraInfo 或者 Camera.Parameters

2.2 打开摄像头

比 Camera1 好的就是，Camera2 在打开摄像头之前，就可以进行参数的配置，比如预览尺寸等。
我们知道，摄像头需要 Surface 来装载数据，这里使用的是 TextureView 来装载：

  mTextureView = findViewById(R.id.surface);

所以，当它创建完成拿到宽高之后，我们就可以打开摄像头了：

    private void openCamera(int width, int height) {
        //判断不同摄像头，拿到 CameraCharacteristics
        CameraCharacteristics characteristics = mCameraId.equals(mBackCameraId) ? mBackCameraCharacteristics : mFrontCameraCharacteristics;
        //拿到配置的map
        StreamConfigurationMap map = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);

        //获取摄像头传感器的方向
        mSensorOrientation = characteristics.get(CameraCharacteristics.SENSOR_ORIENTATION);
        //获取预览尺寸
        Size[] previewSizes = map.getOutputSizes(SurfaceTexture.class);
             //获取最佳尺寸
        Size bestSize = getBestSize(width, height, previewSizes);
        /**
         * 配置预览属性
         * 与 Cmaera1 不同的是，Camera2 是把尺寸信息给到 Surface (SurfaceView 或者 ImageReader)，
         * Camera2 会根据 Surface 配置的大小，输出对应尺寸的画面;
         * 注意摄像头的 width > height ，而我们使用竖屏，所以宽高要变化一下
         */
        mTextureView.getSurfaceTexture().setDefaultBufferSize(bestSize.getHeight(),bestSize.getWidth());

        /**
         * 设置图片尺寸，这里图片的话，选择最大的分辨率即可
         */
        Size[] sizes = map.getOutputSizes(ImageFormat.JPEG);
        Size largest = Collections.max(
                Arrays.asList(sizes),
                new CompareSizesByArea());
        //设置imagereader，配置大小，且最大Image为 1，因为是 JPEG
        mImageReader = ImageReader.newInstance(largest.getWidth(),largest.getHeight(),
                ImageFormat.JPEG,1);

        //拍照监听
        mImageReader.setOnImageAvailableListener(new ImageAvailable(),null);
        
        try {
            //打开摄像头，监听数据
            mCameraManager.openCamera(mCameraId,new CameraDeviceCallback(),null);
        } catch (CameraAccessException e) {
            e.printStackTrace();
        }

    }

在用 mCameraManager.openCamera() 打开摄像头之前，我们通过

//拿到配置的map
StreamConfigurationMap map = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);

拿到可用流的map，这样就可以通过 getOutputSizes() 等拿到相机支持的所有尺寸了，通过上一章 Android 音视频开发(二) – Camera1 实现预览、拍照功能也解释了，为啥要有最佳尺寸，不然会有图片拉伸的问题。
而与 Camera1 不同的是，Camera2 会根据 Surface 配置的大小，输出对应尺寸的画面，所以这里设置 mTextureView 的大小即可，注意摄像头的 width > height ，而我们使用竖屏，所以宽高要变化一下。

接着设置图片的尺寸，这里当然是越轻越好了，所以选择最大尺寸即可。ImageReader 等到后面拍照时再讲解。

最后调用 mCameraManager.openCamera() ，它有三个参数：

cameraId ：Camera 的 ID，比如前置、后置和外置
CameraDevice.StateCallback ：当连接到相机时，该回调就会被调用，生成 CameraDevice
handler ：调用 CameraDevice.StateCallback 的 Handler，传null，则调用主线程，建议传入 HandlerThread 的hander，毕竟这种都是耗时的。

2.3. CameraDevice

CameraDevice 表示当前的相机设备，它的主要职责有:

根据指定的参数创建 CameraCaptureSession
根据指定的模板创建 CaptureRequest
关闭相机设备
监听相机状态，比如断开，开启成功失败的监听

如下：

    class CameraDeviceCallback extends CameraDevice.StateCallback{

        @Override
        public void onOpened(@NonNull CameraDevice camera) {
            mCameraDevice = camera;
            //此时摄像头已经打开，可以预览了
            createPreviewPipeline(camera);
        }

        @Override
        public void onDisconnected(@NonNull CameraDevice camera) {
            camera.close();
        }

        @Override
        public void onError(@NonNull CameraDevice camera, int error) {
            camera.close();
        }
    }

在 onOpened 创建我们CaptureRequest ，配置相机参数信息，如下：

    private void createPreviewPipeline(CameraDevice cameraDevice){
        try {
            //创建作为预览的 CaptureRequst.builder
            final CaptureRequest.Builder captureBuilder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
            Surface surface = new Surface(mTextureView.getSurfaceTexture());
            //添加 surface 容器
            captureBuilder.addTarget(surface);
            // 创建CameraCaptureSession，该对象负责管理处理预览请求和拍照请求,这个必须在创建 Seesion 之前就准备好，传递给底层用于皮遏制 pipeline
            cameraDevice.createCaptureSession(Arrays.asList(surface, mImageReader.getSurface()), new CameraCaptureSession.StateCallback() {
                @Override
                public void onConfigured(@NonNull CameraCaptureSession session) {
                    mCameraCaptureSession = session;
                   try {
                       //设置自动聚焦
                       captureBuilder.set(CaptureRequest.CONTROL_AE_MODE,CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
                       //设置自动曝光
                       captureBuilder.set(CaptureRequest.CONTROL_AE_MODE,CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH);

                       //创建 CaptureRequest
                       CaptureRequest build = captureBuilder.build();
                        //设置预览时连续捕获图片数据
                       session.setRepeatingRequest(build,null,null);
                   }catch (Exception e){

                   }
                }

                @Override
                public void onConfigureFailed(@NonNull CameraCaptureSession session) {
                    Toast.makeText(Camera2Activity.this, "配置失败", Toast.LENGTH_SHORT).show();
                }
            },null);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

在开启预览之前，我们需要先创建 CaptureRequest ，上面已经说过 CaptureRequest 是向 CameraCaptureSession 提交 Capture 请求的信息载体，内部包含了本次的 Capture 参数配置和接受图像数据的 Surface。

CaptureRequest 可以配置的信息非常多，比如图像格式、图像分辨率、聚焦、闪光灯控制等，可以说绝大部分配置都是通过 CaptureRequest 配置的。

上面通过 cameraDevice.createCaptureRequest() 来创建一个 CaptureRequest.Builder 对象，其中createCaptureRequest() 方法的参数是 templateType 用于指定哪种模板，Camera2 根据不同场景，为我们配置了一些常用的参数模板：

TEMPLATE_PREVIEW：适用于配置预览的模板
TEMPLATE_RECORD：适用于视频录制的模板。
TEMPLATE_STILL_CAPTURE：适用于拍照的模板。
TEMPLATE_VIDEO_SNAPSHOT：适用于在录制视频过程中支持拍照的模板。
TEMPLATE_MANUAL：适用于希望自己手动配置大部分参数的模板。

这里我们需要一个预览的 CaptureRequest ，所以选择 TEMPLATE_PREVIEW的模板。

接着，需要设置要承载图像数据的 Surface，我们用到两个，一个是 TextureView 用来预览的，一个是 ImageReader 用来拍照的。

目前这个 CaptureRequest 是用来预览的，所以通过 addTarget 设置进去：

 //添加 surface 容器
 captureBuilder.addTarget(surface);

最后通过 cameraDevice.createCaptureSession() 创建 CameraCaptureSession ，然后再配置一下聚焦和曝光的配置，就可以把 CaptureRequest 通过 Session 发送给底层了：

// 创建CameraCaptureSession，该对象负责管理处理预览请求和拍照请求,这个必须在创建 Seesion 之前就准备好，传递给底层用于配置 pipeline
            cameraDevice.createCaptureSession(Arrays.asList(surface, mImageReader.getSurface()), new CameraCaptureSession.StateCallback() {
                @Override
                public void onConfigured(@NonNull CameraCaptureSession session) {
                    mCameraCaptureSession = session;
                   try {
                       //设置自动聚焦
                       captureBuilder.set(CaptureRequest.CONTROL_AE_MODE,CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
                       //设置自动曝光
                       captureBuilder.set(CaptureRequest.CONTROL_AE_MODE,CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH);

                       //创建 CaptureRequest
                       CaptureRequest build = captureBuilder.build();
                        //设置预览时连续捕获图片数据
                       session.setRepeatingRequest(build,null,null);
                   }catch (Exception e){

                   }
                }

                @Override
                public void onConfigureFailed(@NonNull CameraCaptureSession session) {
                    Toast.makeText(Camera2Activity.this, "配置失败", Toast.LENGTH_SHORT).show();
                }
            },null);

2.4. 开启和关闭预览

在 Camera2 中，本质上是不断的重复 Captrue 的过程，每一次 Capture 都会把预览的数据输出到对应的 Surface 中，所以，为了达到预览的效果，需要使用：

    session.setRepeatingRequest(build,null,null);

它的三个参数如下：

request ：在不断重复执行 Capture 时使用的 CaptureRequest 对象
callback ：监听每一次 Capture 状态的 CameraCaptureSession.CaptureCallback 对象，例如 onCaptureStarted() 意味着一次 Capture 的开始，而 onCaptureCompleted() 意味着一次 Capture 的结束。
handler ：用于执行 CameraCaptureSession.CaptureCallback 的Handler 对象，传null为主线程，也可以使用其他线程的 Handler

关闭预览
通过上面的理解，关闭预览也很简单啦：

 //停止预览
  mCameraCaptureSession.stopRepeating();

三. 拍照

上面我们学习了预览，也提到了 ImageReader 是用来接收图像数据的，那怎么拍照呢？

拍照其实也是一个 Captrue，这样的话，我们就可以再创建一个 CaptureRequest 去执行拍照的就可以了，代码如下：

 //创建一个拍照的 session
 final CaptureRequest.Builder captureRequest = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
 //设置装在图像数据的 Surface
 captureRequest.addTarget(mImageReader.getSurface());
 //聚焦
 captureRequest.set(CaptureRequest.CONTROL_AF_MODE, 
         CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
 //自动曝光
 captureRequest.set(CaptureRequest.CONTROL_AF_MODE,
         CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH);
 // 获取设备方向
 int rotation = getWindowManager().getDefaultDisplay().getRotation();
 // 根据设备方向计算设置照片的方向
 captureRequest.set(CaptureRequest.JPEG_ORIENTATION
         , getOrientation(rotation));
 // 先停止预览
 mCameraCaptureSession.stopRepeating();

代码比较好理解，只是通过 mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE) 创建了一个拍照的模板

而且在执行拍照之前，先停止预览：

 mCameraCaptureSession.stopRepeating();

接着就可以使用 mCameraCaptureSession.capture() 执行拍照了：

mCameraCaptureSession.capture(captureRequest.build(), new CameraCaptureSession.CaptureCallback() {
                    @Override
                    public void onCaptureCompleted(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull TotalCaptureResult result) {
                        super.onCaptureCompleted(session, request, result);
                        try {
                            //拍完之后，让它继续可以预览
                            CaptureRequest.Builder captureRequest1 = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
                            captureRequest1.addTarget(new Surface(mTextureView.getSurfaceTexture()));
                            mCameraCaptureSession.setRepeatingRequest(captureRequest1.build(),null,null);
                        } catch (CameraAccessException e) {
                            e.printStackTrace();
                        }
                    }
                },null);

可以看到，当拍照结束的时候，我们又让它重新预览了，当然这里也看你的需求去设置。

3.1 保存图片

那保存图片在哪里弄呢？还记得我们在打开摄像头的时候，配置了 ImageReader 监听吗：

//拍照监听
mImageReader.setOnImageAvailableListener(new ImageAvailable(),null);

在保存之前，我们先来了解一下，什么是 ImageReader

3.2 ImageReader

在 Camrea2 中，Imageread 是获取图像数据的一个重要途径，我们可以通过它获取各种各样格式的图像数据，比如 JPEG、YUV和 RAW 等。通过 ImageReader.newInstance() 方法创建 ImageReader 对象，如下：

//设置imagereader，配置大小，且最大Image为 1，因为是 JPEG
mImageReader = ImageReader.newInstance(largest.getWidth(),largest.getHeight(),
        ImageFormat.JPEG,1);
mImageReader.setOnImageAvailableListener(new ImageAvailable(),null);

其中前面两个号理解，第三个参数，则是你要获取的图像数据的格式，这里使用 JPEG 即可，而最后一个参数，则表示最大 Image 的个数，可以理解成图像池的大小。

当有图像数据生成时，就是调用 ImageReader.OnImageAvailableListener 里面的 onImageAvailable() 方法

    /**
     * 拍照监听,当有图片数据时，回调该接口
     */
    class ImageAvailable implements ImageReader.OnImageAvailableListener{

        @Override
        public void onImageAvailable(ImageReader reader) {
            new SavePicAsyncTask(reader).executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
        }
    }

接着，我们可以调用 ImageReader 的acquireNextImage()方法，来获取存有最新的 Image 对象，而 Image 对象里的图像数据又根据不同格式被划分成多个部分，分别存储在单独的 Plane 对象里，我们可以调用 Image.getPalnes() 获取所有有的 Palne 对象的数组，如下

//获取捕获的照片数据
Image image = imageReader.acquireLatestImage();
//拿到所有的 Plane 数组
Image.Plane[] planes = image.getPlanes();

最后则通过 Plane.getBuffer() 获取每一个在 Plane 里存储的图像数据 ByteBuffer。比如

格式	Image个数	Plane 层级
JPEG	1	压缩过的数据，所以行数为0，解压缩需要使用BitmapFactory#decodeByteArray
YUV	3	一个明度通道+两个色彩CbCr通道，UV的宽高是Y的一半。

YUV 可以用下图来表示(图片来源)：

在这里插入图片描述
所以，我们获取的图片如下：

FileOutputStream fos = null;
Image image = null;
try {
    fos = new FileOutputStream(file);
    //获取捕获的照片数据
    image = imageReader.acquireLatestImage();
    //拿到所有的 Plane 数组
    Image.Plane[] planes = image.getPlanes();
    //由于是 JPEG ，只需要获取下标为 0 的数据即可
    ByteBuffer buffer = planes[0].getBuffer();
    data = new byte[buffer.remaining()];
    //把 bytebuffer 的数据给 byte数组
    buffer.get(data);
    Bitmap bitmap = BitmapFactory.decodeByteArray(data,0,data.length);
    //旋转图片
    if (mCameraId.equals(mFrontCameraId)){
        bitmap = BitmapUtils.rotate(bitmap,270);
        bitmap = BitmapUtils.mirror(bitmap);
    }else{
        bitmap = BitmapUtils.rotate(bitmap,90);
    }
    bitmap.compress(Bitmap.CompressFormat.JPEG,100,fos);
    fos.flush();
    return bitmap;
}catch (Exception e){
    Log.d(TAG, "zsr doInBackground: "+e.toString());
}finally {
    CloseUtils.close(fos);
    //记得关闭 image
    if (image != null) {
        image.close();
    }
}

这样，我们就写好了，下一章，我们学习 CameraX。

参考:
https://developer.android.google.cn/reference/android/hardware/camera2/package-summary?hl=en
https://www.jianshu.com/p/9a2e66916fcb
https://www.jianshu.com/p/23e8789fbc10
https://www.jianshu.com/p/067889611ae7

夏至的稻穗

关注

8
点赞
踩
41

收藏

觉得还不错? 一键收藏
5
评论
Android 音视频开发(三) -- Camera2 实现预览、拍照功能

音视频系列文章：Android 音视频开发(一) – 使用AudioRecord 录制PCM(录音)；AudioTrack播放音频Android 音视频开发(二) – Camera1 实现预览、拍照功能工程：VideoDemo上一章，已经我们已经用 Camera1 实现了预览和拍照的功能，但也说到，在API21的时候，Camera1已经被标注为弃用，因为它的API功能和灵活性满足不了现在日益复杂的相机开发了，所以在 API21之后，引入了 Camera2 ，参考:https://devel.
复制链接

扫一扫