logo

开发者热搜

Android Camera2 实战：全屏预览与实时帧处理全解析

作者：半吊子全栈工匠2025.09.19 11:24浏览量：0

简介：本文深入探讨Android Camera2 API实现全屏预览及实时获取预览帧进行图像处理的技术方案，涵盖Camera2基础架构、全屏预览配置、帧捕获回调机制及实时处理优化策略，为开发者提供完整的实现路径。

Android Camera2 全屏预览+实时获取预览帧进行图像处理

一、Camera2 API基础架构解析

Camera2 API作为Android 5.0引入的全新摄像头控制框架，采用三级管道架构：CameraDevice（设备层）、CameraCaptureSession（会话层）、CaptureRequest（请求层）。这种设计模式使开发者能够精细控制摄像头参数，包括曝光补偿、白平衡、对焦模式等。

1.1 核心组件说明

  • CameraManager：系统摄像头服务入口，通过getCameraIdList()获取可用设备列表
  • CameraCharacteristics：包含设备特性信息（如传感器方向、硬件支持级别）
  • Surface：作为图像数据的输出目标，支持SurfaceView、TextureView、ImageReader等多种类型

1.2 初始化流程

  1. // 1. 获取CameraManager实例
  2. CameraManager manager = (CameraManager) context.getSystemService(Context.CAMERA_SERVICE);
  3. // 2. 选择后置摄像头（通常ID为"0"）
  4. String cameraId = manager.getCameraIdList()[0];
  5. // 3. 获取设备特性
  6. CameraCharacteristics characteristics = manager.getCameraCharacteristics(cameraId);
  7. // 4. 配置预览Surface
  8. SurfaceTexture surfaceTexture = textureView.getSurfaceTexture();
  9. surfaceTexture.setDefaultBufferSize(1920, 1080);
  10. Surface previewSurface = new Surface(surfaceTexture);

二、全屏预览实现方案

2.1 视图组件选择

  • SurfaceView：双缓冲机制，性能最优但Z轴控制困难
  • TextureView：支持透明、变换动画，适合UI集成场景
  • ImageReader：用于获取原始图像数据，需配合其他视图使用

2.2 最佳实践配置

  1. // 配置预览请求
  2. CaptureRequest.Builder previewBuilder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
  3. previewBuilder.addTarget(previewSurface);
  5. // 设置自动对焦
  6. previewBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
  8. // 优化预览帧率
  9. previewBuilder.set(CaptureRequest.CONTROL_AE_TARGET_FPS_RANGE, 
  10.     new Range<>(30, 30)); // 固定30fps

2.3 屏幕适配策略

  1. 计算最佳预览尺寸：

    1. StreamConfigurationMap map = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
    2. Size[] previewSizes = map.getOutputSizes(SurfaceTexture.class);
    3. // 根据屏幕宽高比选择最接近的尺寸
    4. Size optimalSize = findOptimalSize(previewSizes, screenWidth, screenHeight);

  2. 处理方向旋转：

    1. int displayRotation = getWindowManager().getDefaultDisplay().getRotation();
    2. int sensorOrientation = characteristics.get(CameraCharacteristics.SENSOR_ORIENTATION);
    3. int totalRotation = (sensorOrientation + displayRotation + 270) % 360;

三、实时帧捕获与处理

3.1 ImageReader配置要点

  1. // 创建ImageReader（YUV_420_888格式兼容性最好）
  2. ImageReader imageReader = ImageReader.newInstance(
  3.     1280, 720, ImageFormat.YUV_420_888, 2);
  5. // 设置帧到达监听
  6. imageReader.setOnImageAvailableListener(new ImageReader.OnImageAvailableListener() {
  7.     @Override
  8.     public void onImageAvailable(ImageReader reader) {
  9.         try (Image image = reader.acquireLatestImage()) {
  10.             // 处理YUV数据
  11.             processYUVImage(image);
  12.         }
  13.     }
  14. }, backgroundHandler);

3.2 同步捕获机制

  1. // 创建捕获会话时同时添加预览和图像Surface
  2. List<Surface> outputSurfaces = new ArrayList<>();
  3. outputSurfaces.add(previewSurface);
  4. outputSurfaces.add(imageReader.getSurface());
  6. cameraDevice.createCaptureSession(outputSurfaces, 
  7.     new CameraCaptureSession.StateCallback() {
  8.         @Override
  9.         public void onConfigured(CameraCaptureSession session) {
  10.             try {
  11.                 // 创建重复请求
  12.                 CaptureRequest request = previewBuilder.build();
  13.                 session.setRepeatingRequest(request, null, backgroundHandler);
  14.             } catch (CameraAccessException e) {
  15.                 e.printStackTrace();
  16.             }
  17.         }
  18.     }, backgroundHandler);

3.3 YUV数据处理优化

  1. private void processYUVImage(Image image) {
  2.     // 获取YUV平面
  3.     Image.Plane yPlane = image.getPlanes()[0];
  4.     Image.Plane uPlane = image.getPlanes()[1];
  5.     Image.Plane vPlane = image.getPlanes()[2];
  7.     ByteBuffer yBuffer = yPlane.getBuffer();
  8.     ByteBuffer uBuffer = uPlane.getBuffer();
  9.     ByteBuffer vBuffer = vPlane.getBuffer();
  11.     // 转换为NV21格式（兼容Android Bitmap）
  12.     byte[] nv21 = yuv420ToNv21(
  13.         yBuffer, uBuffer, vBuffer,
  14.         image.getWidth(), image.getHeight()
  15.     );
  17.     // 创建Bitmap进行显示或处理
  18.     YuvImage yuvImage = new YuvImage(nv21, ImageFormat.NV21, 
  19.         image.getWidth(), image.getHeight(), null);
  20.     ByteArrayOutputStream os = new ByteArrayOutputStream();
  21.     yuvImage.compressToJpeg(new Rect(0, 0, width, height), 100, os);
  22.     Bitmap bitmap = BitmapFactory.decodeByteArray(os.toByteArray(), 0, os.size());
  24.     // 释放资源
  25.     image.close();
  26. }

四、性能优化策略

4.1 帧率控制方案

  • 动态调整目标FPS：根据场景复杂度在15-30fps间切换
  • 丢帧策略：当处理耗时超过帧间隔时，主动丢弃后续帧
    1. long lastProcessingTime = 0;
    2. private boolean shouldProcessFrame(long currentTimestamp) {
    3.   long elapsed = currentTimestamp - lastProcessingTime;
    4.   if (elapsed < 33_000_000) { // 30fps间隔
    5.       return false;
    6.   }
    7.   lastProcessingTime = currentTimestamp;
    8.   return true;
    9. }

4.2 线程模型设计

  • 双线程架构：
    • 摄像头线程：负责帧捕获和基础处理
    • 渲染线程：负责UI更新和复杂计算
      ```java
      // 创建带缓冲的线程池
      ExecutorService cameraExecutor = Executors.newFixedThreadPool(2);
      ExecutorService renderExecutor = Executors.newSingleThreadExecutor();

// 帧处理流程
imageReader.setOnImageAvailableListener(image -> {
cameraExecutor.execute(() -> {
// 基础处理
byte[] processedData = preProcess(image);
renderExecutor.execute(() -> {
// UI更新
updateUI(processedData);
});
});
}, backgroundHandler);

  2. ### 4.3 内存管理技巧
  3. - 使用`ImageReader`的`setMaxImages()`控制缓存数量
  4. - 及时关闭不再使用的`Image`对象
  5. - 采用对象池模式复用处理资源
  7. ## 五、常见问题解决方案
  9. ### 5.1 预览变形问题
  10. **原因**：SurfaceView/TextureView尺寸与摄像头输出尺寸不匹配  
  11. **解决**：
  12. ```java
  13. // 在SurfaceHolder.Callback中动态调整
  14. @Override
  15. public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
  16.     if (cameraCaptureSession != null) {
  17.         try {
  18.             // 重新配置会话
  19.             cameraCaptureSession.stopRepeating();
  20.             configurePreviewSize(width, height);
  21.             startPreview();
  22.         } catch (CameraAccessException e) {
  23.             e.printStackTrace();
  24.         }
  25.     }
  26. }

5.2 帧丢失问题

诊断步骤：

  1. 检查CameraCaptureSession.CaptureCallback中的onCaptureFailed()回调
  2. 监控CameraDevice.StateCallback中的错误状态
  3. 使用CameraCharacteristics.get(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES)验证设备能力

优化方案：

  • 降低输出分辨率
  • 减少同时处理的Surface数量
  • 检查后台应用资源占用

六、高级功能扩展

6.1 多摄像头同步

  1. // 获取物理摄像头ID列表
  2. String[] physicalCameraIds = manager.getCameraIdList();
  3. // 创建逻辑摄像头设备（Android 9+）
  4. CameraDevice logicalDevice = ...; // 通过CameraManager.openCamera()创建
  6. // 配置跨摄像头会话
  7. List<Surface> multiSurfaces = new ArrayList<>();
  8. multiSurfaces.add(wideAngleSurface);
  9. multiSurfaces.add(telephotoSurface);
  10. logicalDevice.createCaptureSession(multiSurfaces, ...);

6.2 深度数据获取

  1. // 检查深度功能支持
  2. Integer depthAvailable = characteristics.get(
  3.     CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES
  4. ).contains(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_DEPTH_OUTPUT);
  6. if (depthAvailable != null && depthAvailable) {
  7.     // 配置深度输出
  8.     Size depthSize = characteristics.get(
  9.         CameraCharacteristics.DEPTH_OUTPUT_SIZES_SUPPORTED
  10.     )[0];
  11.     ImageReader depthReader = ImageReader.newInstance(
  12.         depthSize.getWidth(), depthSize.getHeight(),
  13.         ImageFormat.DEPTH16, 2
  14.     );
  15. }

七、完整代码示例

  1. public class Camera2PreviewProcessor {
  2.     private CameraDevice cameraDevice;
  3.     private CameraCaptureSession captureSession;
  4.     private ImageReader imageReader;
  5.     private Handler backgroundHandler;
  7.     public void startCamera(Context context, TextureView textureView) {
  8.         // 1. 初始化组件
  9.         CameraManager manager = (CameraManager) context.getSystemService(Context.CAMERA_SERVICE);
  10.         String cameraId = manager.getCameraIdList()[0];
  12.         // 2. 配置预览Surface
  13.         SurfaceTexture surfaceTexture = textureView.getSurfaceTexture();
  14.         surfaceTexture.setDefaultBufferSize(1920, 1080);
  15.         Surface previewSurface = new Surface(surfaceTexture);
  17.         // 3. 配置ImageReader
  18.         imageReader = ImageReader.newInstance(640, 480, 
  19.             ImageFormat.YUV_420_888, 2);
  21.         // 4. 打开摄像头
  22.         try {
  23.             manager.openCamera(cameraId, new CameraDevice.StateCallback() {
  24.                 @Override
  25.                 public void onOpened(CameraDevice device) {
  26.                     cameraDevice = device;
  27.                     startPreviewSession(previewSurface);
  28.                 }
  29.                 // 其他回调方法...
  30.             }, backgroundHandler);
  31.         } catch (CameraAccessException e) {
  32.             e.printStackTrace();
  33.         }
  34.     }
  36.     private void startPreviewSession(Surface previewSurface) {
  37.         try {
  38.             // 创建捕获请求构建器
  39.             CaptureRequest.Builder previewBuilder = 
  40.                 cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
  41.             previewBuilder.addTarget(previewSurface);
  42.             previewBuilder.addTarget(imageReader.getSurface());
  44.             // 创建捕获会话
  45.             List<Surface> surfaces = Arrays.asList(previewSurface, imageReader.getSurface());
  46.             cameraDevice.createCaptureSession(surfaces, 
  47.                 new CameraCaptureSession.StateCallback() {
  48.                     @Override
  49.                     public void onConfigured(CameraCaptureSession session) {
  50.                         captureSession = session;
  51.                         try {
  52.                             session.setRepeatingRequest(
  53.                                 previewBuilder.build(), null, backgroundHandler);
  54.                         } catch (CameraAccessException e) {
  55.                             e.printStackTrace();
  56.                         }
  57.                     }
  58.                     // 其他回调方法...
  59.                 }, backgroundHandler);
  60.         } catch (CameraAccessException e) {
  61.             e.printStackTrace();
  62.         }
  63.     }
  65.     // 图像处理回调
  66.     imageReader.setOnImageAvailableListener(new ImageReader.OnImageAvailableListener() {
  67.         @Override
  68.         public void onImageAvailable(ImageReader reader) {
  69.             try (Image image = reader.acquireLatestImage()) {
  70.                 // 在此实现图像处理逻辑
  71.                 processImage(image);
  72.             }
  73.         }
  74.     }, backgroundHandler);
  75. }

八、最佳实践总结

  1. 资源管理：始终在onPause()中释放摄像头资源
  2. 错误处理：实现完整的CameraDevice.StateCallback和CameraCaptureSession.StateCallback
  3. 权限管理：动态请求CAMERA和WRITE_EXTERNAL_STORAGE权限
  4. 兼容性处理：检查CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL
  5. 性能监控：使用System.nanoTime()测量帧处理耗时

通过以上技术方案，开发者可以实现稳定的Camera2全屏预览，并构建高效的实时图像处理流水线。实际开发中需根据具体设备特性进行参数调优，建议使用Camera2 API Interop Test应用进行兼容性测试。

相关文章推荐

发表评论

最热文章

关于作者

  • 被阅读数
  • 被赞数
  • 被收藏数