Android下Camera框架解析
【Android】AndroidCamera实时数据采集及通过MediaCodec硬编码编。。。
【Android】AndroidCamera实时数据采集及通过MediaCodec硬编码编。
吐槽： 其实常⽤流程都差不多，但是有时候还是会忘记某⼀步的详细⽤法，但是各位朋友请注意，官⽅已经不推荐Camera类的使⽤（现在是android.hardware.camera2），但⽆奈公司项⽬之前是使⽤Camera类实现的，并且Camera2貌似是基于API 21以上的，这Android 7的风声都放出来了，可是6.0现在出了3个多⽉了市场占有率也才貌似3%不到，什么时候才能有个标准化和统⼀规范，作为⼀名Android开发者实属不易啊，叹⽓~Android实现摄像头实时数据采集及通过硬编码编码数据的流程：/** 编码器获取数据，编码，编码后的数据的处理等⼤致流程如下：*//* 1.获取原始帧 */@OverrideonPreviewFrame( byte[] onPreviewData, Camera camera) {/* 在此可以对onPreviewData进⾏Rotate或者Scale* 也可以转换yuv的格式，例如yuv420P(YV12)或者yuv420SP(NV21/NV12)* 相关开源类库可以使⽤libyuv/ffmpeg等*/getRawFrame(onPreviewData)/* 然后将onPreviewData加⼊Camera回调*/addCallbackBuffer(onPreviewData);}private void getRawFrame( byte[] rawFrame ) { encodFrame(rawFrame); }/* 2.进⾏编码 */private byte[] encodFrame(byte[] inputData) { return encodedData; }/* 3.取得编码后的数据便可进⾏相应的操作，可以保存为本地⽂件，也可进⾏推流 */Operation ? Send(byte[] sendData) : Save(byte[] saveData)上述代码onPreviewFrame为Camera类的接⼝，使⽤Camera前需要进⾏SurfaceView及SurfaceHolder的初始化及相应interface的实现：// init the preview surfaceprivate void initview() {SurfaceView surfaceView = (SurfaceView) findViewById(R.id.record_surface);SurfaceHolder surfaceHolder = surfaceView.getHolder();surfaceHolder.addCallback(this);surfaceHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);}@Overridepublic void surfaceCreated(SurfaceHolder holder) {openCamera(holder); // 开启相机}@Overridepublic void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {}@Overridepublic void surfaceDestroyed(SurfaceHolder holder) {releaseCamera(); // 在surfaceDestroyed的时候记得releaseCamera}private void openCamera(SurfaceHolder holder) {releaseCamera();try {camera = getCamera(Camera.CameraInfo.CAMERA_FACING_BACK); // 根据需求选择前/后置摄像头} catch (Exception e) {camera = null;if (AppContext.isDebugMode) {e.printStackTrace();}}if(mCamera != null){try {mCamera.setPreviewCallback(this);mCamera.setDisplayOrientation(90); // 此⽅法为官⽅提供的旋转显⽰部分的⽅法，并不会影响onPreviewFrame⽅法中的原始数据；if(parameters == null){parameters = mCamera.getParameters();}parameters.setPreviewFormat(ImageFormat.NV21); // 常⽤格式：NV21 / YV12parameters.setPreviewSize(width, height); // 还可以设置很多相机的参数，但是建议先遍历当前相机是否⽀持该配置，不然可能会导致出错；mCamera.setParameters(parameters);mCamera.setPreviewDisplay(holder);mCamera.startPreview();} catch (IOException e) {e.printStackTrace();}}}@TargetApi(9)private Camera getCamera(int cameraType) {Camera camera = null;try {camera = Camera.open(cameraType);} catch (Exception e) {e.printStackTrace();}return camera; // returns null if camera is unavailable}private synchronized void releaseCamera() {if (camera != null) {try {camera.setPreviewCallback(null);} catch (Exception e) {e.printStackTrace();}try {camera.stopPreview();} catch (Exception e) {e.printStackTrace();}try {camera.release();} catch (Exception e) {e.printStackTrace();}camera = null;}}MediaCodec硬编码实现部分：此处推荐参考SRS开源项⽬中的实现⽅法：// video device.private Camera camera;private MediaCodec vencoder;private MediaCodecInfo vmci;private MediaCodec.BufferInfo vebi;private byte[] vbuffer;// video camera settings.private Camera.Size vsize;private int vcolor;private int vbitrate_kbps = 300;private final static int VFPS = 20;private final static int VGOP = 5;private final static int VWIDTH = 640;private final static int VHEIGHT = 480;/* ⾸先需要初始化MediaCodec的配置 */private void initMediaCodec() {// choose the right vencoder, perfer qcom then google.vcolor = chooseVideoEncoder();// vencoder yuv to 264 es stream.// requires sdk level 16+, Android 4.1, 4.1.1, the JELLY_BEANtry {vencoder = MediaCodec.createByCodecName(vmci.getName());} catch (IOException e) {Log.e(TAG, "create vencoder failed.");e.printStackTrace();return;}vebi = new MediaCodec.BufferInfo();// setup the vencoder.// @see https:///reference/android/media/MediaCodec.htmlMediaFormat vformat = MediaFormat.createVideoFormat(MediaFormat.MIMETYPE_VIDEO_AVC, vsize.width, vsize.height); vformat.setInteger(MediaFormat.KEY_COLOR_FORMAT, vcolor);vformat.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE, 0);vformat.setInteger(MediaFormat.KEY_BIT_RATE, 1000 * vbitrate_kbps);vformat.setInteger(MediaFormat.KEY_FRAME_RATE, VFPS);vformat.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, VGOP);Log.i(TAG, String.format("vencoder %s, color=%d, bitrate=%d, fps=%d, gop=%d, size=%dx%d",vmci.getName(), vcolor, vbitrate_kbps, VFPS, VGOP, vsize.width, vsize.height));// the following error can be ignored:// 1. the storeMetaDataInBuffers error:// [OMX.qcom.video.encoder.avc] storeMetaDataInBuffers (output) failed w/ err -2147483648// @see /mediacodec/#q12vencoder.configure(vformat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);vencoder.start();}// for the vbuffer for YV12(android YUV), @see below://https:///reference/android/hardware/Camera.Parameters.html#setPreviewFormat(int)//https:///reference/android/graphics/ImageFormat.html#YV12private int getYuvBuffer(int width, int height) {// stride = ALIGN(width, 16)int stride = (int) Math.ceil(width / 16.0) * 16;// y_size = stride * heightint y_size = stride * height;// c_stride = ALIGN(stride/2, 16)int c_stride = (int) Math.ceil(width / 32.0) * 16;// c_size = c_stride * height/2int c_size = c_stride * height / 2;// size = y_size + c_size * 2return y_size + c_size * 2;}// choose the video encoder by name.private MediaCodecInfo chooseVideoEncoder(String name, MediaCodecInfo def) {int nbCodecs = MediaCodecList.getCodecCount();for (int i = 0; i < nbCodecs; i++) {MediaCodecInfo mci = MediaCodecList.getCodecInfoAt(i);if (!mci.isEncoder()) {continue;}String[] types = mci.getSupportedTypes();for (int j = 0; j < types.length; j++) {if (types[j].equalsIgnoreCase(VCODEC)) {//Log.i(TAG, String.format("vencoder %s types: %s", mci.getName(), types[j]));if (name == null) {return mci;}if (mci.getName().contains(name)) {return mci;}}}}return def;}// choose the right supported color format. @see below://https:///reference/android/media/MediaCodecInfo.html//https:///reference/android/media/MediaCodecInfo.CodecCapabilities.htmlprivate int chooseVideoEncoder() {// choose the encoder "video/avc":// 1. select one when type matched.// 2. perfer google avc.// 3. perfer qcom avc.vmci = chooseVideoEncoder(null, null);//vmci = chooseVideoEncoder("google", vmci);//vmci = chooseVideoEncoder("qcom", vmci);int matchedColorFormat = 0;MediaCodecInfo.CodecCapabilities cc = vmci.getCapabilitiesForType(VCODEC);for (int i = 0; i < cc.colorFormats.length; i++) {int cf = cc.colorFormats[i];Log.i(TAG, String.format("vencoder %s supports color fomart 0x%x(%d)", vmci.getName(), cf, cf));// choose YUV for h.264, prefer the bigger one.// corresponding to the color space transform in onPreviewFrameif ((cf >= cc.COLOR_FormatYUV420Planar && cf <= cc.COLOR_FormatYUV420SemiPlanar)) {if (cf > matchedColorFormat) {matchedColorFormat = cf;}}}for (int i = 0; i < cc.profileLevels.length; i++) {MediaCodecInfo.CodecProfileLevel pl = cc.profileLevels[i];Log.i(TAG, String.format("vencoder %s support profile %d, level %d", vmci.getName(), pl.profile, pl.level));}Log.i(TAG, String.format("vencoder %s choose color format 0x%x(%d)", vmci.getName(), matchedColorFormat, matchedColorFormat));return matchedColorFormat;} 上述代码为SRS的部分实现，仅作参考。
cameraview框架用法
cameraview框架用法Cameraview是一个用于在Android应用中显示相机预览的框架。
它简化了相机预览的实现过程，并提供了一些常用的功能和配置选项。
下面是使用Cameraview框架的基本步骤：1. 在build.gradle文件中添加Cameraview依赖项：```implementation 'com.otaliastudios:cameraview:x.x.x'```请将`x.x.x`替换为最新的版本号。
2. 在布局文件中添加Cameraview控件：```xml<com.otaliastudios.cameraview.CameraViewandroid:id="@+id/cameraView"android:layout_width="match_parent"android:layout_height="match_parent" />```3. 在Activity或Fragment中找到相机视图（CameraView）并进行初始化：```javaCameraView cameraView = findViewById(R.id.cameraView);cameraView.setLifecycleOwner(this);```这里使用了`setLifecycleOwner()`方法将当前Activity或Fragment作为相机视图的生命周期所有者。
4. 启动和停止相机预览：```javacameraView.start();``````javacameraView.stop();```可以在合适的生命周期方法中调用这两个方法，比如在`onResume()`和`onPause()`方法中。
5. 配置相机参数和功能：Cameraview提供了一系列方法用于配置相机的参数和功能，如设置前后摄像头、设置预览分辨率、设置闪光灯模式等。
AndroidCamera详解
AndroidCamera详解相关的类1. android.hardware.camera22. Camera3. SurfaceView---这个类⽤于向⽤户呈现实时相机预览。
4. MediaRecorder---这个类⽤于从摄像机录制视频。
5. Intent---MediaStore.ACTION_IMAGE_CAPTURE或MediaStore.ACTION_VIDEO_CAPTURE可⽤于捕获图像或视频，⽽⽆需直接使⽤Camera对象。
清单声明在使⽤Camera API开始开发应⽤程序之前，应确保您的清单具有适当的声明，以允许使⽤相机硬件和其他相关功能。
相机权限 - 您的应⽤程序必须请求使⽤设备相机的权限。
<uses-permission android:name="android.permission.CAMERA" />注意：如果您通过调⽤现有的摄像头应⽤程序来使⽤摄像头，则应⽤程序不需要请求此权限。
相机功能 - 您的应⽤程序还必须声明使⽤相机功能，例如：<uses-feature android:name="android.hardware.camera" />存储权限 - 如果应⽤程序将图像或视频保存到设备的外部存储设备（SD卡），则还必须在清单中指定此选项。
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />⾳频录制权限 - 对于使⽤视频捕获录制⾳频，应⽤程序必须请求获取⾳频捕获权限。
<uses-permission android:name="android.permission.RECORD_AUDIO" />创建⾃定义摄像头为应⽤程序创建⾃定义摄像头界⾯的⼀般步骤如下：1. 检测和访问摄像机 - 创建代码以检查摄像机是否存在并请求访问。
Android Camera HAL3 分析
1Android Camera HAL3 分析本文均属自己阅读源码的点滴总结，转账请注明出处谢谢。
欢迎和大家交流。
qq:1037701636 email:gzzaigcn2009@Software ：系统源码Android 5.1Camera3研读前沿：当初在研读Camera1.0相关的内容时，主要围绕着CameraClient 、CameraHardwareInterface 等方面进行工作的开展，无论是数据流还是控制流看起来都很简单、明了，一系列的流程化操作使得整个框架学起来特别的容易。
因为没有Camera2.0相关的基础，所以这次直接看3.0相关的源码时，显得十分的吃紧，再加上底层高通HAL3.0实现的过程也是相当的复杂，都给整个研读过程带来了很多的困难。
可以说，自身目前对Camera3.0框架的熟悉度也大概只有70%左右，希望通过总结来进一步梳理他的工作原理与整个框架，并进一步熟悉与加深理解。
1.Camera3下的整体架构图。
整个CameraService 建立起一个可用操作底层Camera device 大致需要经过Camera2Client 、Camera3Device 以及HAL 层的camera3_device_t 三个部分。
2从上图中可以发现Camera3架构看上去明显比camera1来的复杂，但他更加的模块化。
对比起Android4.2.2 Camer 系统架构图（HAL 和回调处理）一文中描述的单顺序执行流程，Camera3将更多的工作集中在了Framework 去完成，将更多的控制权掌握在自己的手里，从而与HAL 的交互的数据信息更少，也进一步减轻了一些在旧版本中HAL 层所需要做的事情。
2. Camera2Client 的建立与初始化过程在建立好Camera2Client 后会进行initialize 操作，完成各个处理模块的创建： ?123 .... mStreamingProcessor = new StreamingProcessor(this);//preview 和recorder threadName = String8::format(C2-%d-StreamProc,mCameraId);4 5 6 7 8 910111213141516171819202122232425 mStreamingProcessor->run(threadName.string());//预览与录像mFrameProcessor = new FrameProcessor(mDevice, this);// 3AthreadName = String8::format(C2-%d-FrameProc,mCameraId);mFrameProcessor->run(threadName.string()); //3AmCaptureSequencer = new CaptureSequencer(this);threadName = String8::format(C2-%d-CaptureSeq,mCameraId);mCaptureSequencer->run(threadName.string());//录像，拍照mJpegProcessor = new JpegProcessor(this, mCaptureSequencer); threadName = String8::format(C2-%d-JpegProc,mCameraId);mJpegProcessor->run(threadName.string());....mCallbackProcessor = new CallbackProcessor(this);//回调处理threadName = String8::format(C2-%d-CallbkProc,mCameraId);mCallbackProcessor->run(threadName.string());依次分别创建了：StreamingProcessor并启动一个他所属的thread，该模块主要负责处理previews 与record两种视频流的处理，用于从hal层获取原始的视频数据FrameProcessor并启动一个thread，该模块专门用于处理回调回来的每一帧的3A等信息，即每一帧视频除去原始视频数据外，还应该有其他附加的数据信息，如3A值。
android cameradevice用法 -回复
android cameradevice用法-回复Android CameraDevice用法指的是在Android操作系统中，通过使用CameraDevice API来控制和操作设备上的相机。
CameraDevice API提供了许多功能，包括启动相机、预览图像、拍照以及设置相机参数等。
本文将一步一步回答关于Android CameraDevice用法的问题，帮助读者了解如何使用该API来实现各种相机功能。
1. 什么是CameraDevice？CameraDevice是Android相机架构中的一个关键组件，是与硬件相机设备进行交互和通信的接口。
它通过提供方法来管理相机资源、控制相机参数和处理相机数据等。
在应用程序中，可以使用CameraManager类来获取CameraDevice实例。
2. 如何获取CameraManager实例？要获取CameraManager实例，可以调用Context.getSystemService()方法，并传入参数Context.CAMERA_SERVICE。
然后，可以通过此CameraManager实例来获取相机设备列表以及管理相机资源。
示例代码：CameraManager cameraManager = (CameraManager) context.getSystemService(Context.CAMERA_SERVICE);3. 如何获取相机设备列表？可以通过调用CameraManager的getCameraIdList()方法来获取相机设备列表。
该方法将返回一个包含所有可用相机设备ID的字符串数组。
示例代码：String[] cameraIds = cameraManager.getCameraIdList();4. 如何打开相机设备？调用CameraManager的openCamera()方法来打开相机设备，需要传入相机设备的ID、一个CameraDevice.StateCallback回调以及一个可选的Handler对象。
android Camera框架分析
Android的Camera系统分析一、Camera构架分析Android 的Camera包含取景（preview）和拍摄照片（take picture）的功能。
目前Android 发布版的Camera程序虽然功能比较简单，但是其程序的架构分成客户端和服务器两个部分，它们建立在Android的进程间通讯Binder的结构上。
Android中Camera模块同样遵循Andorid的框架，如下图所示Camera ArchitectureCamera模块主要包含了libandroid_runtime.so、libui.so和libcameraservice.so等几个库文件，它们之间的调用关系如下所示：在Camera模块的各个库中，libui.so位于核心的位置，它对上层的提供的接口主要是Camera 类。
libcameraservice.so是Camera的server程序，它通过继承libui.so中的类实现server的功能，并且与libui.so中的另外一部分内容通过进程间通讯（即Binder机制）的方式进行通讯。
libandroid_runtime.so和libui.so两个库是公用的,其中除了Camera还有其他方面的功能。
整个Camera在运行的时候，可以大致上分成Client和Server两个部分，它们分别在两个进程中运行，它们之间使用Binder机制实现进程间通讯。
这样在client 调用接口，功能则在server中实现，但是在client中调用就好像直接调用server中的功能，进程间通讯的部分对上层程序不可见。
从框架结构上来看，源码中ICameraService.h、ICameraClient.h和ICamera.h三个类定义了MeidaPlayer的接口和架构，ICameraService.cpp和Camera.cpp两个文件则用于Camera 架构的实现，Camera的具体功能在下层调用硬件相关的接口来实现。
AndroidCamera原理之cameraHAL底层数据结构与类总结
AndroidCamera原理之cameraHAL底层数据结构与类总结camera HAL层数据结构非常多，看代码的时候常常为了了解这些数据结构找半天，为了方便大家学习，特地总结了一些数据结构以及这些数据结构的位置：1.hardware/libhardware/include/hardware/camera_common. h：1.1 camera_info_t : camera_info1.2 camera_device_status_t : camera_device_status1.3 torch_mode_status_t : torch_mode_status1.4 camera_module_callbacks_t : camera_module_callbacks1.5 camera_module_t : camera_module2.hardware/libhardware/include/hardware/hardware.h：2.1 hw_module_t : hw_module_t2.2 hw_module_methods_t : hw_module_methods_t, 其中hw_module_methods_t 结构如下：这个结构体里面有一个函数指针，什么地方明确了函数指针的指向了？在hardware/libhardware/modules/camera/3_0/CameraHAL.cpp中的167行明确了函数指针指向。
指向其中的open_dev函数。
2.3 hw_device_t : hw_device_t3.hardware/libhardware/include/hardware/camera3.h3.1 camera3_device_t : camera3_device3.2 camera3_device_ops_t : camera3_device_opscamera3_device_ops_t 映射函数指针操作：hardware/libhardware/modules/camera/3_0/Camera.cpp上面的函数指针映射只是抽象层提供一个默认映射方法，实际上芯片中都会复写这个指针函数的映射关系。
AndroidCamera原理之setRepeatingRequest与capture模块
AndroidCamera原理之setRepeatingRequest与capture模块在Android相机API中，setRepeatingRequest和capture是两个用于控制相机捕获图像的重要方法。
它们的原理和使用方式如下：1. setRepeatingRequest原理：setRepeatingRequest方法用于连续捕获图像，可以在预览或录制视频时使用。
其原理如下：- 首先，创建一个CaptureRequest.Builder对象，该对象用于配置相机捕获的各种参数，如图像分辨率、曝光时间、焦距等。
- 然后，使用CameraDevice.createCaptureSession方法创建一个CaptureSession对象，该对象用于管理相机的捕获请求。
- 接下来，调用CaptureRequest.Builder的build方法构建一个CaptureRequest对象，该对象代表了一个捕获请求。
- 最后，调用CaptureSession.setRepeatingRequest方法传入CaptureRequest对象，即可开始连续捕获图像。
2. setRepeatingRequest使用：setRepeatingRequest方法的使用非常简单，只需要按照上述原理进行步骤即可。
具体使用时，可以根据实际需求对CaptureRequest.Builder进行配置，例如设置预览分辨率、曝光时间、自动对焦等参数，然后传入CaptureSession.setRepeatingRequest方法即可开始预览或录制视频。
3. capture原理：capture方法用于单次捕获图像，可以用于拍照等场景。
其原理如下：- 首先，创建一个CaptureRequest.Builder对象，该对象用于配置相机捕获的各种参数，如图像分辨率、曝光时间、焦距等。
- 然后，使用CameraDevice.createCaptureSession方法创建一个CaptureSession对象，该对象用于管理相机的捕获请求。
Android Camera 调用流程
Android Camera 调用流程Android Camera的代码结构Android的Camera代码主要在以下的目录中：Camera的JAVA部分packages/apps/Camera/。
其中Camera.java是主要实现的文件。
这部分内容编译成为目标是Camera.apkcom.android.camera这个包，几个主要的类文件如下：PhotoViewer：GalleryPicker.java（所有图片集）--->ImageGallery.java（某个Folder下图片列表）--->ViewImage.java（看某张具体图片）VideoPlayer：GalleryPicker.java（所有视频集）--->MovieView.java（看某一个视频）Camera：Camera.java（Camera取景及拍照）VideoCamera：VideoCamera.java（VideoCamera取景及摄像）Camera的framework供上层应用调用的部分base/core/java/android/hardware/Camera.java这部分目标是framework.jarCamera的JNI部分frameworks/base/core/jni/android_hardware_Camera.cpp这部分内容编译成为目标是libandroid_runtime.so。
Camera UI库部分frameworks/base/libs/camera这部分的内容被编译成库libcamera_client.so。
Camera服务部分frameworks/base/services/camera/libcameraservic这部分内容被编译成库libcameraservice.so。
Camera HAL层部分hardware/msm7k/libcamera或vendor/qcom/android-open/libcamera2为了实现一个具体功能的Camera，在HAL层需要一个硬件相关的Camera库（例如通过调用video for linux驱动程序和Jpeg编码程序实现或者直接用各个chip厂商实现的私有库来实现，比如Qualcomm实现的libcamera.so和libqcamera.so），实现CameraHardwareInterface规定的接口，来调用相关的库，驱动相关的driver，实现对camera 硬件的操作。
camera驱动调试
最近学习了一下camera驱动，除了查看平台文档和sensor的规格书，也在网上查看了高手们到经验。
对camera还是比较陌生的，和大部分驱动的调试相差无几，还是在前人的工作基础上进行的。
下面将我的学习和大家交流一下：一.Framework层1.android.hardware.Camera：代码位置/ap-scr/frameworks/base/core/java/android/hardware/Camera.java这部分目标是framework.jar。
这是是Android 提供给app层调用的java接口。
这个类用来连接或断开一个Camera 服务，设置拍摄参数，开始、停止预览，拍照等。
2.android.hardware.Camera这个类是和JNI中定义的类是一个，有些方法通过JNI的方式调用本地代码得到，有些方法自己实现。
Camera的JAVA native调用部分（JNI）：/android/frameworks/base/core/jni/android_hardware_Camera.cpp。
Camera.java 承接JAVA 代码到C++ 代码的桥梁。
编译生成libandroid_runtime.so 。
libandroid_runtime.so库是公用的, 其中除了Camera 还有其他方面的功能。
3.Camera框架的client部分：代码位置：\ap-src\frameworks\av\camera下5个文件。
Camera.cppCameraParameters.cppICamera.cppICameraClient.cppICameraService.cpp它们的头文件在\ap-src\frameworks\av\include\camera目录下。
这部分的内容编译生成libcamera_client.so 。
在Camera 模块的各个库中，libcamera_client.so 位于核心的位置，作为Camera 框架的Client 客户端部分，与另外一部分内容服务端 libcameraservice.so 通过进程间通讯（即Binder 机制）的方式进行通讯。
Camera模块解析
手机摄像头功能由多个功能模块组成，主要三个部分，采集，加工，显示。
（1）采集部分由感光的sensor完成，通过CAM IF接口与手机芯片内的CAM连接。
（2）CAM对CAM IF数据进行加工，主要是格式转换，特殊效果等。
最终处理出来的一帧数据，存在内存中。
（3）手机的刷新线程，使用手机内部的DMA功能，或者OVERLAY技术，把处理好的camera图像，显示到LCD上。
刷新部分，不在camera框架范围内，后面只做简单讨论。
图1：Camera典型硬件模块图2 Sensor简介Sensor是对图像的采集系统，通常采用的是ov系列的芯片。
如ov2655等。
通常包含两路接口：（1）控制总线：Sensor也是一个智能嵌入式系统，一般通过I2C总线与手机芯片通信。
手机可以通过I2C读写Sensor的寄存器，改变Sensor的参数，从而改变其工作方式。
（2）数据总线：Sensor通过CAM IF接口与CAM联系。
图2：sensor硬件连接图由图可知，sensor工作的条件需要：（1）电压供应，一般模拟电压，数字电压。
（2）工作时钟，通常为24M HZ的正弦波。
一般为手机芯片产生（3）SDA,SCL，i2c总线连接，sensor通常为从设备。
（4）standby控制线，手机芯片通过这条GPIO控制线，控制sensor的工作是否开启。
（5）Sensor输出给手机芯片的接口，CAM IF接口：（6）并行数据线，通常8位，10位。
分辨率高的sensor数据线需要更多。
（7）提供给手机芯片内集成的camera模块的PCLK,HCLK,VCLK.(像素同步信号，行同步信号，帧同步信号)。
Sensor通常产出稳定频率的数据图像流，手机芯片可以通过I2C总线接口，修改寄存器，改变帧频率。
也可以改变sensor的输出流的格式，通常采用yuv422格式。
3 CAM简介CAM就是将Sensor采集过来的数据，转换相应格式，及其他加工，最后存放到内存中。
Android自定义相机超详细讲解
Android⾃定义相机超详细讲解Android⾃定义相机超详细讲解由于⽹上关于Android⾃定义相机的⽂章写得不是太详细，Google官⽅的⽂档⼜说得不太容易理解，所以今天我来详细讲解⼀下Android⾃定义相机。
这篇⽂章主要写给⼀些刚刚接触Android的那些看官⽅API困难以及不太了解Android机制的同学们，所以熟练开发者可以绕道了。
最近在使⽤Camera类的时候发现居然被弃⽤了，API 21中出现了camera2这个类来代替camera类，但是笔者的⼿机才andorid 4.4，国内要⽤上6.0⾄少明年去了，所以本次还是讲解Camera这个类。
⾸先是加⼊权限，这个直接按照google的api向导或者看api⽂档会有详细说明的，所以这⾥不讲了。
那么接下来，使⽤相机我们总需要⼀个能够看到图像的地⽅吧，这⾥Google叫我们使⽤SurfaceView这个类，那么SurfaceView这个类是什么呢，⾸先这个类是继承View的，可以在将图像绘制在屏幕上并显⽰给⽤户。
其实能够显⽰的原因是SurfaceView中包含⼀个Surface对象，Surface是SurfaceView的可见部分，好了我们提到了Surface，⼜是⼀个让很多⼈头疼的概念，好吧让我们重头来讲解。
⾸先我们在⼿机屏幕上看到的是这些画⾯都可以算是View(当然SurfaceView也算View)，那么View是什么？View其实就是⼿机内存中的⼀⼩块区域，所谓显⽰，就是显卡等硬件将内存中的信息显⽰在屏幕上的过程，这下我想⼤家应该清楚⼀点了吧，我们继续，那我们说到的可见部分⼜是怎么回事呢，其实我们看到的屏幕可以说是2维的，也就是长和宽，但是在它的内部其实是3维的，还有⼀个维度就是层Layer，也就是层的概念，⽤过Visio或者AutoCAD的同学应该很好理解，在画图的时候，上层有时会将下层的遮挡，我们看到的图像就是这样⼀层⼀层堆叠起来的，这当中有些层不可见，有些层部分可见，有些层完全可见，我们看到的就是它们之中可见的部分，⽽Surface就是SurfaceView中的⼀个可见的部分，我们在摄像或者拍照⽤的就是它显⽰了。
CameraProvider启动流程分析
CameraProvider启动流程分析CameraProvider是Android相机框架中的一个重要组件，它负责管理系统中可用的相机设备，并为应用程序提供访问相机功能的接口。
在本文中，我们将对CameraProvider的启动流程进行详细分析。
1. 创建CameraProvider实例：首先，应用程序需要通过CameraX的静态方法`CameraX.initialize(context)`来初始化CameraX库。
在初始化过程中，CameraX会创建一个全局的CameraProvider实例，用于管理系统中的相机设备。
2. 查询可用的相机设备：一旦CameraProvider实例创建完成，应用程序可以通过调用`CameraX.getCameraProvider(`方法来获取CameraProvider实例。
然后，应用程序可以调用CameraProvider的`getCameraIdList(`方法来获取系统中可用的相机设备的ID列表。
3. 创建相机实例：在获取到相机设备的ID列表后，应用程序可以通过调用CameraProvider的`bindToLifecycle(`方法来创建相机实例。
该方法需要传入一个LifecycleOwner对象，用于管理相机实例的生命周期。
4. 配置相机参数：一旦相机实例创建完成，应用程序可以通过调用相机实例的`getCameraControl(`方法来获取相机控制器实例。
然后，应用程序可以使用相机控制器实例来配置相机的各种参数，例如闪光灯模式、曝光模式、对焦模式等。
5. 启动预览：配置相机参数完成后，应用程序可以通过调用相机实例的`getCameraInfo(`方法来获取相机信息实例。
然后，应用程序可以使用相机信息实例来获取相机的预览输出目标，例如SurfaceTexture或SurfaceView。
最后，应用程序可以调用相机实例的`setPreviewSurface(`方法，将预览输出目标设置给相机实例，从而启动相机的预览功能。
camera驱动调试
最近学习了一下camera驱动，除了查看平台文档和sensor的规格书，也在网上查看了高手们到经验。
对camera还是比较陌生的，和大部分驱动的调试相差无几，还是在前人的工作基础上进行的。
下面将我的学习和大家交流一下：一.Framework层1.android.hardware.Camera：代码位置/ap-scr/frameworks/base/core/java/android/hardware/Camera.java这部分目标是framework.jar。
这是是Android 提供给app层调用的java接口。
这个类用来连接或断开一个Camera 服务，设置拍摄参数，开始、停止预览，拍照等。
2.android.hardware.Camera这个类是和JNI中定义的类是一个，有些方法通过JNI的方式调用本地代码得到，有些方法自己实现。
Camera的JAVA native调用部分（JNI）：/android/frameworks/base/core/jni/android_hardware_Camera.cpp。
Camera.java 承接JAVA 代码到C++ 代码的桥梁。
编译生成libandroid_runtime.so 。
libandroid_runtime.so库是公用的, 其中除了Camera 还有其他方面的功能。
3.Camera框架的client部分：代码位置：\ap-src\frameworks\av\camera下5个文件。
Camera.cppCameraParameters.cppICamera.cppICameraClient.cppICameraService.cpp它们的头文件在\ap-src\frameworks\av\include\camera目录下。
这部分的内容编译生成libcamera_client.so 。
在Camera 模块的各个库中，libcamera_client.so 位于核心的位置，作为Camera 框架的Client 客户端部分，与另外一部分内容服务端 libcameraservice.so 通过进程间通讯（即Binder 机制）的方式进行通讯。
Android framework camera分析
1 AndroiHale Waihona Puke 's camera 模块概述
Camera 模块是 android 系统中用于处理视频输入的模块。Android 将 camera 定义为一个 framework, 这样客户可以使用 camera's framework 支持不同的硬件,只需客户实现 camera 的 framework 。本文主要介绍 camera framework 和如何实现 camera framework。
class CameraHardwareInterface : public virtual RefBase 类 CameraHardwareInterface 虚拟继承于 RefBase 防止二意性。 RefBase 是引用计数基础类。几乎每个 class 都会继承自 RefBase。
CameraHardwareInterface 中定义了若干函数，下面逐个介绍 virtual ~CameraHardwareInterface() { }
pure vitual function， 设置 3 个 callback,(3 个 callback 一般由 CameraService::Client 中实现）。 下面是 3 个 callback 函数的原型： typedef void (*notify_callback)(int32_t msgType,
virtual sp<IMemoryHeap> getRawHeap() const = 0; pure vitual function, 返回由 new MemoryHeapBase(size) 分配的用于保存 camera 拍照时返回的 rowdata。
virtual void setCallbacks(notify_callback notify_cb, data_callback data_cb, data_callback_timestamp data_cb_timestamp, void* user) = 0;
Android 的照相机系统
硬件 操作
字符设备驱动程序核心
硬件层 摄像头 视频输出设备
2.2 硬件抽象层的内容
Camera 的硬件抽象层的在 UI 库的头文件 CameraHardwareInterface.h 文件定义。 在这个接口中，包含了控制通道和数据通道 ，控制通道用于处理预览和视频获取的开始 / 停 止、拍摄照片、自动对焦等功能，数据通道通过 回调函数来获得预览、视频录制、自动对焦等数 据。 Camera 的硬件抽象层中还可以使用 Overlay 来实现预览功能。
Android 的照相机系统
韩 超 @ Android 技术
Android 的 Camera 系统
第一部分 Camera 系统的结构 第二部分 移植和调试的要点 第三部分 Camera 实现方式
第一部分 Camera 系统的结构
照相机系统下层的硬件通常是摄像头 设备，主要用于向系统输入视频数据。摄像 头设备通常包括处理器中的数据信号处理相 关的控制器和摄像头传感器。摄像头传感器 又可以分为普通型和智能型的。摄像机硬件 对软件部分主要提供视频数据。
第一部分 Camera 系统的结构
在理论上，照相机的取景器、视频、 照片等数据都可以传送到 Java 层，但是通常 情况下，这些数据不需要传递到 Java 层。仅 有少数情况需要在 Java 层获取数据流，例如 通过摄像头进行扫面识别的时候，需要取景 器的数据帧。
第一部分 Camera 系统的结构
第一部分 Camera 系统的结构
自下而上， Camera 系统分成了以下几个部分。 （ 1 ）摄像头驱动程序：通常基于 Linux 的 Video for Linux 视频驱动框架。 （ 2 ） Camera 硬件抽象层 frameworks/base/include/ui/ frameworks/base/include/camera/ 主要的文件为 CameraHardwareInterface.h ，需要各 个系统根据自己的情况实现。 （ 3 ） Camera 服务部分 frameworks/base/camera/libcameraservice/ Camera 服务是 Android 系统中一个单独部分，通过 调用 Camera 硬件抽象层来实现。
AndroidCameraHAL3分析剖析
Android Camera HAL3 分析本文均属自己阅读源码的点滴总结，转账请注明出处谢谢。
欢迎和大家交流。
qq:1037701636email:********************Software：系统源码Android5.1Camera3研读前沿：当初在研读Camera1.0相关的内容时，主要围绕着CameraClient、CameraHardwareInterface等方面进行工作的开展，无论是数据流还是控制流看起来都很简单、明了，一系列的流程化操作使得整个框架学起来特别的容易。
因为没有Camera2.0相关的基础，所以这次直接看3.0相关的源码时，显得十分的吃紧，再加上底层高通HAL3.0实现的过程也是相当的复杂，都给整个研读过程带来了很多的困难。
可以说，自身目前对Camera3.0框架的熟悉度也大概只有70%左右，希望通过总结来进一步梳理他的工作原理与整个框架，并进一步熟悉与加深理解。
1.Camera3下的整体架构图。
整个CameraService建立起一个可用操作底层Camera device大致需要经过Camera2Client、Camera3Device以及HAL层的camera3_device_t三个部分。
1从上图中可以发现Camera3架构看上去明显比camera1来的复杂，但他更加的模块化。
对比起Android4.2.2 Camer系统架构图（HAL和回调处理）一文中描述的单顺序执行流程，Camera3将更多的工作集中在了Framework去完成，将更多的控制权掌握在自己的手里，从而与HAL的交互的数据信息更少，也进一步减轻了一些在旧版本中HAL层所需要做的事情。
2. Camera2Client的建立与初始化过程在建立好Camera2Client后会进行initialize操作，完成各个处理模块的创建：1 2 3 ....mStreamingProcessor = new StreamingProcessor(this);//preview和recorder threadName = String8::format(C2-%d-StreamProc,mCameraId);24 5 6 7 8 910111213141516171819202122232425 mStreamingProcessor->run(threadName.string());//预览与录像mFrameProcessor = new FrameProcessor(mDevice, this);// 3AthreadName = String8::format(C2-%d-FrameProc,mCameraId);mFrameProcessor->run(threadName.string()); //3AmCaptureSequencer = new CaptureSequencer(this);threadName = String8::format(C2-%d-CaptureSeq,mCameraId);mCaptureSequencer->run(threadName.string());//录像，拍照mJpegProcessor = new JpegProcessor(this, mCaptureSequencer); threadName = String8::format(C2-%d-JpegProc,mCameraId);mJpegProcessor->run(threadName.string());....mCallbackProcessor = new CallbackProcessor(this);//回调处理threadName = String8::format(C2-%d-CallbkProc,mCameraId);mCallbackProcessor->run(threadName.string());依次分别创建了：StreamingProcessor并启动一个他所属的thread，该模块主要负责处理previews 与record两种视频流的处理，用于从hal层获取原始的视频数据FrameProcessor并启动一个thread，该模块专门用于处理回调回来的每一帧的3A等信息，即每一帧视频除去原始视频数据外，还应该有其他附加的数据信息，如3A值。
AndroidCamera之CameraMetadata分析
AndroidCamera之CameraMetadata分析⼀、camera_metadata简介Camera_metadata数据结构在Camera流程中起到了很⼤重要,可以说所有的⾃顶层下发给hal层的参数都是通过camera_metadata 传递的。
今天我们就来好好看看它到底如何保存的，以及它的数据组织形式如何表现。
和Camera_metadata数据结构相关的主要有以下⼏个⽂件：system/media/camera/include/system/Camera_metadata_tags.hsystem/media/camera/src/Camera_metadata_tag_info.csystem/media/camera/src/Camera_metadata.csystem/media/camera/include/system/Camera_metadata.hFramework/av/camera/CameraMetadata.cppFramework/av/include/camera/CameraMetadata.h这些⽂件的调⽤和包含关系如下图所⽰。
其中camera_metadata_tag_info.h包含了所有的基本宏，其中包含了下⾯的section枚举类型，在代码中可以看到，每⼀个section 的⼤⼩是64K，因为他们根据之前枚举变量向左偏移16位(64K喽)。
每个段有64K，⽬前在本世纪够⽤了。
根据这样层层包扎，所以说每⼀个tag的值都是不同的，⽽且有序的组织在⼀起。
/*** Top level hierarchy definitions for camera metadata. *_INFO sections are for* the static metadata that can be retrived without opening the camera device.* New sections must be added right before ANDROID_SECTION_COUNT to maintain* existing enumerations.*/typedef enum camera_metadata_section {ANDROID_COLOR_CORRECTION,ANDROID_CONTROL,ANDROID_DEMOSAIC,ANDROID_EDGE,.............}<pre name="code" class="cpp">/*** Hierarchy positions in enum space. All vendor extension tags must be* defined with tag >= VENDOR_SECTION_START*/typedef enum camera_metadata_section_start {ANDROID_COLOR_CORRECTION_START = ANDROID_COLOR_CORRECTION << 16,ANDROID_CONTROL_START = ANDROID_CONTROL << 16,ANDROID_DEMOSAIC_START = ANDROID_DEMOSAIC << 16,ANDROID_EDGE_START = ANDROID_EDGE << 16,.............}下图我们就以ANDROID_FLASH_START section来说事吧。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
Android 下Camera 构架分析一. Android Camera 层次结构Android 下Camera 子系统从上到下可以分为应用层、框架层、运行库层及内核层，其结构如下图所示。
从整体上看，它还是属于Android 下典型的client/service 的结构，运行在两个进程中，一个是client 进程，主要包括JA V A 代码与一些Native c/c++代码；另一个是service 进程，属于服务端，是native c/c++代码，并且，camera service 属于Android 系统的一个native 服务，用native c/c++代码实现，主要负责和Linux kernel 中的Camera Driver 交互，搜集Linux kernel 中Camera Driver 上传的数据，并交给显示系统(surface)显示。
client 进程与service 进程通过Binder 机制通信，client 端通过调用service 端的接口实现各个具体的功能。
但真正的preview 数据不会通过Binder IPC 机制从service 端复制到client 端，而是通过回调函数与消息的机制将preview 数据buffer 的地址传到client 端，最终可在Java 应用中操作处理这个preview 数据。
android_hardware.cameraCamera Apps Libandroid_runtime.so (android_hardware_Camera.cpp)libcamera_client.so (Camara.cpp)应用层框架层运行库层硬件层Libcamera.so (HAL)libcameraservice.so (CameraService.cpp)Linux 内核层V4L2 Kernel Driver Camera Hardware BinderIPCJNIClient Service二. Android Camera 的代码结构1）应用层Camera 的应用层在Android 上表现为直接调用SDK API 开发的一个Camera应用APK包，代码在/android/packages/apps/Camera下，其主要作用是对android.hardware.Camer(frameworks/base/core/java/android/hardware/Camera.java)类的调用，并且实现Camera 应用的业务逻辑和UI 显示。
2）框架层框架层包含了camera的JNI实现，Camera Client和Service三部分。
其中，JNI提供接口给上层JA V A代码(android.hardware.Camer类)调用，文件路径为：frameworks/base/core/jni/android_hardware_Camera.cpp，这部分内容编译成为目标libandroid_runtime.so。
Camera Client实现的代码在frameworks/av/camera/下，这部分的内容被编译成库libcamera_client.so，主要实现了以下几个类：Camera--->Camera.cpp/Camera.hCameraParameters---->CameraParameters.cpp/CameraParameters.hICamera----> ICamera.cpp/ ICamera.hICameraClient----> ICameraClient.cpp/ ICameraClient.hICameraService---> ICameraService.cpp/ ICameraService.hICamera、ICameraClient、ICameraServide三个类是按照Binder IPC通信要求的框架实现的，用来与service端通信。
类CameraParameters接收Framework层的android.hardware.camera::Parameters类为参数，解析与格式化所有的参数配置。
Camera是个很重要的类，它与Camera Service端通过Binder IPC机制交互来实现具体功能。
Camera继承自BnCameraClient，并最终继承自ICameraClient。
Camera Service文件分布在frameworks/av/services/camera/libcameraservice/，这部分内容被编译成库libcameraservice.so, libcameraservice.so是Camera的服务器程序，它通过继承libcamera_client.so的类实现服务器的功能，并且与libcamera_client.so中的另外一部分内容则通过进程间通讯（即Binder机制）的方式进行通讯。
里面主要实现了两个类:CameraService---->BnCameraService---->ICameraServiceCameraService::Client---->BnCamera---->ICameraCameraService::Client通过调用CameraHardwareInterface类来实现具体的功能，CameraHardwareInterface直接与camera HAL层交互。
3）HAL层Camera HAL一般实现为一个动态库libcamera.so(动态库的名字可以修改，只需要与android.mk一致即可)。
所有java应用层中camera的功能最终会调用到HAL层这里，Camera HAL层的实现依赖于硬件，在这些头文件Camera.h提供了对上层的接口，而其他的几个头文件都是提供一些接口类（即包含了纯虚函数的类），这些接口类必须被实现类继承才能够使用。
一般通过V4L2 command从linux kernel中的camera driver获得preview数据，然后交给surface（overlay）显示或者保存为文件。
在HAL层需要打开对应的设备文件，并通过ioctrl访问camera driver。
Android通过这个HAL层来保证底层硬件（驱动）改变，只需修改对应的HAL层代码，FrameWork层与JA V A AP层都不用改变。
三.Android Camera构架分析在Camera系统的各个库中，libui.so位于核心的位置，它对上层的提供的接口主要是Camera类，类libandroid_runtime.so通过调用Camera类提供对JA V A 的接口，并且实现了android.hardware.camera 类。
libcameraservice.so是Camera 的服务器程序，它通过继承libcamera_client.so的类实现服务器的功能，并且与libcamera_client.so中的另外一部分内容则通过进程间通讯（即Binder机制）的方式进行通讯。
Camera主要的头文件有以下几个：ICameraClient.hCamera.hICamera.hICameraService.hCameraHardwareInterface.h在这些头文件Camera.h提供了对上层的接口，而其他的几个头文件都是提供一些接口类（即包含了纯虚函数的类），这些接口类必须被实现类继承才能够使用。
Android下Camera涉及的各个类和接口的UML关系如下图所示。
整个Camera子系统运行时，可以分成Client和Server两个部分，它们之间使用Binder机制实现进程间通讯。
这样在客户端调用接口，功能则在服务器中实现，但在客户端中调用就好像直接调用服务器中的功能，进程间通讯的部分对上层程序不可见。
从框架结构上来看，ICameraService.h、ICameraClient.h和ICamera.h三个类定义了Camera的接口和架构，ICameraService.cpp和Camera.cpp两个文件用于Camera架构的实现，Camera.cpp里实现了camera子系统的Client核心Camera 类，它是整个系统核心，里面有startPreview()、takePicture()等函数用于实现camera 的预览、拍照等工作。
ICamera类提供了Camera主要功能的接口，在客户端方调用。
CameraService.cpp实现camera子系统的service，camera各种具体功能实现在CameraService的子类Client里面完成，而最终是通过调用CameraHardwareInterface的接口来实现具体功能，CameraHardwareInterface类直接与camera的HAL层交互。
在上图中，图中红色虚线框的部分都是Camera子系统的Framework部分，它主要利用了Android系统最为常见的Binder机制来完成通讯。
蓝色的部分通过调用Camera硬件相关的接口完成具体的Camera服务功能，其它的部分是为上层的JA V A程序提供JNI 接口。
在整体结构上，左边可以视为一个客户端，右边是一个可以视为服务器，二者通过Android的Binder来实现进程间的通讯，而应用程序则无需关心这些service、client及直接的通信机制、camera的数据流，直接调用android.hardware.camera类的相关接口，就可以实现camera的预览、拍照和参数设置功能。
本文对Android下的camera子系统的层次结构、代码分布及实现框架进行了分析，由于设计代码太多，文章里并未拿出代码对进行分析，但对整体构架理解清楚后，读懂其源码将变的得心应手。
产品开发部手持产品组徐东。