Home编程语言AndroidAndroid相机HAL浅析

Android相机HAL浅析

2016 年 8 月 19 日

1，摄像头成像原理介绍

相机工作流程图

相机的成像原理可以简单概括如下：

景物(SCENE)通过镜头（LENS）生成的光学图像投射到图像传感器(Sensor)表面上，然后转为电信号，经过A/D（模数转换）转换后变为数字图像信号，再送到数字信号处理芯片（DSP）中加工处理，再通过IO接口传输到CPU中处理，通过DISPLAY就可以看到图像了。

电荷耦合器件(CCD)或互补金属氧化物半导体（CMOS）接收光学镜头传递来的影像，经模/数转换器(A/D)转换成数字信号，经过编码后存储。

流程如下：

1）、CCD/CMOS将被摄体的光信号转变为电信号—电子图像（模拟信号）

2）、由模/数转换器（ADC）芯片来将模拟信号转化为数字信号

3）、数字信号形成后，由DSP或编码库对信号进行压缩并转化为特定的图像文件格式储存

数码相机的光学镜头与传统相机相同，将影像聚到感光器件上，即(光)电荷耦合器件(CCD) 。CCD替代了传统相机中的感光胶片的位置，其功能是将光信号转换成电信号，与电视摄像相同。

CCD是半导体器件，是数码相机的核心，其内含器件的单元数量决定了数码相机的成像质量——像素，单元越多，即像素数高，成像质量越好，通常情况下像素的高低代表了数码相机的档次和技术指标。

2，Android的相机框架

Android版的相机子系统提供一个拍照和录制视频的框架。

它将摄像头的上层应用与应用Framework、用户库串接起来，而正是这个用户库来与Camera的硬件层通信，从而实现操作camera硬件。

————————————————– ——————————————

————————————————– ———————————————

3.Camera HAL部分层

代码存放目录：硬件 RK29 摄像头

编译：

[CPP] 查看纯副本

打印？

  1. LOCAL_PATH：= $（叫我-DIR）
  2. 包括$（CLEAR_VARS）
  3. LOCAL_SRC_FILES：=
  4.     CameraHal_Module.cpp
  5.     CameraHal.cpp
  6.     CameraHal_Utils.cpp
  7.     MessageQueue.cpp
  8.     CameraHal_Mem.cpp
  9. ……………….
  10. IFEQ（$（$条（TARGET_BOARD_HARDWARE）），rk30board）
  11. LOCAL_MODULE：= camera.rk30board
 

为了实现一个具体功能的Camera，在HAL层需要一个硬件相关的Camera库（例如通过调用video对于linux驱动程序和Jpeg编码程序实现或者直接用各个chip厂商实现的私有库来实现，比如Qualcomm实现的libcamera.so和libqcamera.so），此处为camera.rk30board.so实现CameraHardwareInterface规定的接口，来调用相关的库，驱动相关的driver，实现对camera硬件的操作。这个库将被Camera的服务库libcameraservice.so调用。

 

3.1CameraHal_Module.cpp主要是摄像头HAL对上层提供的接口，和实际设备无关，上层的本地库都直接调用这个文件里面提供的接口。

[CPP] 查看纯副本

打印？

  1. 静态INT  camera_device_open（常量 hw_module_t *模块，  常量字符*名称，
  2.                 hw_device_t **设备）;
  3. 静态INT  camera_device_close（hw_device_t *设备）;
  4. 静态INT  camera_get_number_of_cameras（无效）;
  5. 静态INT  camera_get_camera_info（INT  camera_id，  结构 camera_info *信息）;
  8. 静态结构 hw_module_methods_t camera_module_methods = {
  9.         打开：camera_device_open
  10. };
  13. camera_module_t HAL_MODULE_INFO_SYM = {
  14.     常见的有：{
  15.          标签：HARDWARE_MODULE_TAG，
  16.          version_major：（（CONFIG_CAMERAHAL_VERSION＆为0xFF00）>> 8），
  17.          version_minor：CONFIG_CAMERAHAL_VERSION＆0xFF的，
  18.          ID：CAMERA_HARDWARE_MODULE_ID，
  19.          名称：CAMERA_MODULE_NAME，
  20.          作者：  “瑞芯” ，
  21.          方法：camera_module_methods，
  22.          DSO：NULL，  / *删除编译警告* /
  23.          版权所有：{0}  / *删除编译警告* /
  24.     }，
  25.     get_number_of_cameras：camera_get_number_of_cameras，
  26.     get_camera_info：camera_get_camera_info，
  27. };

// CAMERA_DEVICE_NAME“的/ dev /视频”以下都是通过读取节点信息来获取摄像头的数目及摄像头设备信息

[CPP] 查看纯副本

打印？

  1. INT  camera_device_close（hw_device_t *设备）
  2. {
  3.     INT  RET = 0;
  4.     rk_camera_device_t * rk_dev = NULL;
  6.     LOGD（ “％S” ，__FUNCTION__）;
  8.     安卓:: ::互斥锁自动锁（gCameraHalDeviceLock）;
  10.     如果 （！设备）{
  11.         RET = -EINVAL;
  12.         后藤 做的;
  13.     }
  15.     rk_dev =（rk_camera_device_t *）设备;
  17.     如果 （rk_dev）{
  18.         如果 （gCameraHals [rk_dev-> cameraid]）{
  19.             删除 gCameraHals [rk_dev-> cameraid];
  20.             gCameraHals [rk_dev-> cameraid] = NULL;
  21.             gCamerasOpen–;
  22.         }
  24.         如果 （rk_dev-> base.ops）{
  25.             免费（rk_dev-> base.ops）;
  26.         }
  27.         免费（rk_dev）;
  28.     }
  29. 完成：
  31.     返回 RET;
  32. }
  34. / ******************* ******************
  35.  *实现camera_module功能
  36.  ************************************************** ***************** /
  38. / *打开设备手柄的相机之一
  39.  *
  40.  *承担摄像机的服务将让每个摄像机单
  41.  *所以这个函数永远只能被称为相机的每一次实例
  42.  * /
  44. INT  camera_device_open（常量 hw_module_t *模块，  常量字符*名称，
  45.                 hw_device_t **设备）
  46. {
  47.     INT  RV = 0;
  48.     INT  cameraid;
  49.     rk_camera_device_t * camera_device = NULL;
  50.     camera_device_ops_t * camera_ops = NULL;
  51.     安卓:: CameraHal *摄像头= NULL;
  53.     安卓:: ::互斥锁自动锁（gCameraHalDeviceLock）;
  55.     LOGI（“camera_device开放” ）;
  57.     如果 （名字！= NULL）{
  58.         cameraid =的atoi（名）;
  60.         如果（cameraid> gCamerasNumber）{
  61.             LOGE（ “ 照相服务提供cameraid出界，”
  62.                     “cameraid =％d个，NUM支持=％d个” ，
  63.                     cameraid，gCamerasNumber）;
  64.             RV = -EINVAL;
  65.             转到 失败;
  66.         }
  68.         如果（gCamerasOpen> = CAMERAS_SUPPORTED_SIMUL_MAX）{
  69.             LOGE（ “ 最大数量（％D）的摄像头已打开” ，gCamerasOpen）;
  70.             RV = -ENOMEM;
  71.             转到 失败;
  72.         }
  74.         camera_device =（rk_camera_device_t *）malloc的（sizeof的（* camera_device））;
  75.         如果（！camera_device）{
  76.             LOGE（“camera_device分配失败” ）;
  77.             RV = -ENOMEM;
  78.             转到 失败;
  79.         }
  81.         camera_ops =（camera_device_ops_t *）malloc的（sizeof的（* camera_ops））;
  82.         如果（！camera_ops）{
  83.             LOGE（“camera_ops分配失败” ）;
  84.             RV = -ENOMEM;
  85.             转到 失败;
  86.         }
  88.         memset的（camera_device，0，  sizeof的（* camera_device））;
  89.         memset的（camera_ops，0，  sizeof的（* camera_ops））;
  91.         camera_device-> base.common.tag = HARDWARE_DEVICE_TAG;
  92.         camera_device-> base.common.version = 0;
  93.         camera_device-> base.common.module =（hw_module_t *）（模块）;
  94.         camera_device-> base.common.close = camera_device_close;
  95.         camera_device-> base.ops = camera_ops;
  97.         camera_ops-> set_preview_window = camera_set_preview_window;
  98.         camera_ops-> set_callbacks = camera_set_callbacks;
  99.         camera_ops-> enable_msg_type = camera_enable_msg_type;
  100.         camera_ops-> disable_msg_type = camera_disable_msg_type;
  101.         camera_ops-> msg_type_enabled = camera_msg_type_enabled;
  102.         camera_ops-> start_preview = camera_start_preview;
  103.         camera_ops-> stop_preview = camera_stop_preview;
  104.         camera_ops-> preview_enabled = camera_preview_enabled;
  105.         camera_ops-> store_meta_data_in_buffers = camera_store_meta_data_in_buffers;
  106.         camera_ops-> start_recording = camera_start_recording;
  107.         camera_ops-> stop_recording = camera_stop_recording;
  108.         camera_ops-> recording_enabled = camera_recording_enabled;
  109.         camera_ops-> release_recording_frame = camera_release_recording_frame;
  110.         camera_ops-> auto_focus = camera_auto_focus;
  111.         camera_ops-> cancel_auto_focus = camera_cancel_auto_focus;
  112.         camera_ops-> take_picture = camera_take_picture;
  113.         camera_ops-> cancel_picture = camera_cancel_picture;
  114.         camera_ops-> set_parameters = camera_set_parameters;
  115.         camera_ops-> get_parameters = camera_get_parameters;
  116.         camera_ops-> put_parameters = camera_put_parameters;
  117.         camera_ops-> send_command = camera_send_command;
  118.         camera_ops->发布= camera_release;
  119.         camera_ops-> =倾倒camera_dump;
  121.         *设备= camera_device-> base.common;
  123.         // ——–瑞芯微具体的东西——–
  125.         camera_device-> cameraid = cameraid;
  127.         摄像头=  新 的Android :: CameraHal（cameraid）;
  129.         如果（！相机）{
  130.             LOGE（ “ 无法创建CameraHal类的实例” ）;
  131.             RV = -ENOMEM;
  132.             转到 失败;
  133.         }
  135.         gCameraHals [cameraid] =相机;
  136.         gCamerasOpen ++;
  137.     }
  139.     返回 RV;
  141. 失败：
  142.     如果（camera_device）{
  143.         免费（camera_device）;
  144.         camera_device = NULL;
  145.     }
  146.     如果（camera_ops）{
  147.         免费（camera_ops）;
  148.         camera_ops = NULL;
  149.     }
  150.     如果（摄像机）{
  151.         删除 摄像头;
  152.         相机= NULL;
  153.     }
  154.     *器件= NULL;
  155.     返回 RV;
  156. }
  158. INT  camera_get_number_of_cameras（无效）
  159. {
  160.     炭 cam_path [20];
  161.     CHAR  cam_num [3]，I;
  162.     INT  cam_cnt = 0，FD = -1，rk29_cam [CAMERAS_SUPPORT_MAX];
  163.     结构 v4l2_capability能力;
  164.     rk_cam_info_t camInfoTmp [CAMERAS_SUPPORT_MAX]
  165.     字符 * PTR，** ptrr;
  166.     字符 版本[PROPERTY_VALUE_MAX]
  168.     如果 （gCamerasNumber> 0）
  169.         转到 camera_get_number_of_cameras_end;
  171.     memset的（版本，为0x00，sizeof的（版本））;
  172.     sprintf的（版本，“％d个，％d个％D” ，（（CONFIG_CAMERAHAL_VERSION 及为0xFF0000）>> 16）
  173.         （（CONFIG_CAMERAHAL_VERSION及为0xFF00）>> 8），CONFIG_CAMERAHAL_VERSION＆0xFF的）;
  174.     property_set（CAMERAHAL_VERSION_PROPERTY_KEY，版本）;
  176.     memset的（camInfoTmp [0]，0×00，的sizeof （rk_cam_info_t））;
  177.     memset的（camInfoTmp [1]，0×00，的sizeof （rk_cam_info_t））;
  179.     对于 （i = 0; I <10;我++）{
  180.         cam_path [0] = 0×00;
  181.         strcat的（cam_path，CAMERA_DEVICE_NAME）;
  182.         sprintf的（cam_num， “％D” ，我）;
  183.         strcat的（cam_path，cam_num）;
  184.         FD =开（cam_path，O_RDONLY）;
  185.         如果 （FD <0）
  186.             突破;
  188.         memset的（能力，0，  sizeof的（结构 v4l2_capability））;
  189.         如果 （的ioctl（FD，VIDIOC_QUERYCAP，＆能力）<0）{
  190.             LOGE（ “ 视频设备（％S）：查询功能，不支持 n” ，cam_path）;
  191.             转到 loop_continue;
  192.         }
  194.         如果 （（capability.capabilities及（V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING））=（V4L2_CAP_VIDEO_CAPTURE |！V4L2_CAP_STREAMING））{
  195.             LOGD（ “ 视频设备（％S）：视频拍摄不支持 n” ，cam_path）;
  196.         }  其他 {
  197.             memset的（camInfoTmp [cam_cnt＆0×01] .device_path，为0x00，  sizeof的（camInfoTmp [cam_cnt＆0×01] .device_path））;
  198.             strcat的（camInfoTmp [cam_cnt＆0×01] .device_path，cam_path）;
  199.             memset的（camInfoTmp [cam_cnt＆0×01] .fival_list，为0x00，  sizeof的（camInfoTmp [cam_cnt＆0×01] .fival_list））;
  200.             的memcpy（camInfoTmp [cam_cnt＆0×01] .driver，capability.driver，  sizeof的（camInfoTmp [cam_cnt＆0×01] .driver））;
  201.             camInfoTmp [cam_cnt＆0×01] .version = capability.version;
  202.             如果 （的strstr（（字符*）＆capability.card [0]， “ 前” ）！= NULL）{
  203.                 camInfoTmp [cam_cnt＆0×01] .facing_info.facing = CAMERA_FACING_FRONT;
  204.             }  其他 {
  205.                 camInfoTmp [cam_cnt＆0×01] .facing_info.facing = CAMERA_FACING_BACK;
  206.             }
  207.             PTR =的strstr（（字符*）＆capability.card [0]， “ – ” ）;
  208.             如果 （PTR！= NULL）{
  209.                 PTR ++;
  210.                 camInfoTmp [cam_cnt＆0×01] .facing_info.orientation =的atoi（PTR）;
  211.             }  其他 {
  212.                 camInfoTmp [cam_cnt＆0×01] .facing_info.orientation = 0;
  213.             }
  214.             cam_cnt ++;
  216.             memset的（版本，为0x00，sizeof的（版本））;
  217.             sprintf的（版本，“％d个，％d个％D” ，（（capability.version 及为0xFF0000）>> 16）
  218.                 （（capability.version及为0xFF00）>> 8），capability.version＆0xFF的）;
  219.             property_set（CAMERADRIVER_VERSION_PROPERTY_KEY，版本）;
  221.             LOGD（ “％S（％D）：％S：％S” ，__ __功能__ __ LINE，CAMERADRIVER_VERSION_PROPERTY_KEY，版本）;
  223.             如果 （cam_cnt> = CAMERAS_SUPPORT_MAX）
  224.                 我= 10;
  225.         }
  226. loop_continue：
  227.         如果 （FD> 0）{
  228.             关闭（FD）;
  229.             FD = -1;
  230.         }
  231.         继续;
  232.     }
  233.     // ZYC，改变相机的信息来源，如果有一个USB摄像头
  234.     如果（（STRCMP（camInfoTmp [0] .driver，“uvcvideo” ）== 0））{
  235.         camInfoTmp [0] .facing_info.facing =（camInfoTmp [1] .facing_info.facing == CAMERA_FACING_FRONT）？CAMERA_FACING_BACK：CAMERA_FACING_FRONT;
  236.         camInfoTmp [0] = .facing_info.orientation（camInfoTmp [0] == .facing_info.facing CAMERA_FACING_FRONT）270：90;
  237.     }  否则如果（（STRCMP（camInfoTmp [1] .driver，“uvcvideo” ）== 0））{
  238.         camInfoTmp [1] .facing_info.facing =（camInfoTmp [0] .facing_info.facing == CAMERA_FACING_FRONT）？CAMERA_FACING_BACK：CAMERA_FACING_FRONT;
  239.         camInfoTmp [1] .facing_info.orientation =（camInfoTmp [1] .facing_info.facing == CAMERA_FACING_FRONT）270：90;
  240.     }
  241.     gCamerasNumber = cam_cnt;
  243. ＃如果CONFIG_AUTO_DETECT_FRAMERATE
  244.     rk29_cam [0] = 0xff的;
  245.     rk29_cam [1] = 0xff的;
  246.     对于 （i = 0; I <cam_cnt;我++）{
  247.         如果 （STRCMP（（字符*）＆camInfoTmp [I] .driver [0]，“rk29xx相机” ）== 0）{
  248.             如果 （的strcmp（（字符*）＆camInfoTmp [I] .driver [0]，（字符*）＆gCamInfos [I] .driver [0]）！= 0）{
  249.                 rk29_cam [我] =我;
  250.             }
  251.         }  其他 {
  252.             rk29_cam [I] = 0xFF的;
  253.         }
  254.     }
  256.     如果 （（rk29_cam [0]！= 0xff的）||（rk29_cam [1]！= 0xff的））{
  257.         如果 （gCameraFpsDetectThread == NULL）{
  258.             gCameraFpsDetectThread =  新 CameraFpsDetectThread（）;
  259.             LOGD（ “％S 创建枚举摄像机的帧率CameraFpsDetectThread !!” ，__ FUNCTION__）;
  260.             gCameraFpsDetectThread->运行（“CameraFpsDetectThread” ，ANDROID_PRIORITY_AUDIO）;
  261.         }
  262.     }
  263. ＃万一
  264.     ＃如果CONFIG_CAMERA_SINGLE_SENSOR_FORCE_BACK_FOR_CTS
  265.     如果 （（gCamerasNumber == 1）&&（camInfoTmp [0] == .facing_info.facing CAMERA_FACING_FRONT））{
  266.         gCamerasNumber = 2;
  267.         的memcpy（＆camInfoTmp [1]，＆camInfoTmp [0]，  sizeof的（rk_cam_info_t））;
  268.         camInfoTmp [1] .facing_info.facing = CAMERA_FACING_BACK;
  269.     }
  270.     ＃万一
  272.     的memcpy（＆gCamInfos [0]，＆camInfoTmp [0]，  sizeof的（rk_cam_info_t））;
  273.     的memcpy（＆gCamInfos [1]，＆camInfoTmp [1]，  sizeof的（rk_cam_info_t））;
  275. camera_get_number_of_cameras_end：
  276.     LOGD（ “％S（％D）：当前董事会有附加％d个摄像头。” ，__ FUNCTION__，__LINE__，gCamerasNumber）;
  277.     返回 gCamerasNumber;
  278. }
  280. INT  camera_get_camera_info（INT  camera_id，  结构 camera_info *信息）
  281. {
  282.     INT  RV = 0，FP;
  283.     INT  face_value = CAMERA_FACING_BACK;
  284.     INT  方向= 0;
  285.     CHAR  PROCESS_NAME [30];
  287.     如果（camera_id> gCamerasNumber）{
  288.         LOGE（ “％S camera_id出界，camera_id =％d个，NUM支持=％d个” ，__ FUNCTION__，
  289.                 camera_id，gCamerasNumber）;
  290.         RV = -EINVAL;
  291.         转到 结束;
  292.     }
  294.     信息 – > =面临gCamInfos [camera_id] .facing_info.facing;
  295.     信息 – >方向= gCamInfos [camera_id] .facing_info.orientation;
  296. 结束：
  297.     LOGD（ “％S（％D）：camera_％d 个面向（％D），朝向（％D）” ，__ __功能__ __ LINE，camera_id，信息- >面对，信息- >方向）;
  298.     返回 RV;
  299. }

而对于为上层提供的HAL层接口函数，并不直接操作节点，而是间接的去调用CameraHal.cpp去操作节点。

[CPP] 查看纯副本

打印？

  1. INT  camera_start_preview（结构 camera_device *设备）
  2. {
  3.     INT  RV = -EINVAL;
  4.     rk_camera_device_t * rk_dev = NULL;
  6.     LOGV（ “％S” ，__FUNCTION__）;
  8.     如果（！设备）
  9.         返回 RV;
  11.     rk_dev =（rk_camera_device_t *）设备;
  13.     RV = gCameraHals [rk_dev-> cameraid] – > startPreview（）;
  15.     返回 RV;
  16. }
  18. 无效 camera_stop_preview（结构 camera_device *设备）
  19. {
  20.     rk_camera_device_t * rk_dev = NULL;
  22.     LOGV（ “％S” ，__FUNCTION__）;
  24.     如果（！设备）
  25.         返回;
  27.     rk_dev =（rk_camera_device_t *）设备;
  29.     gCameraHals [rk_dev-> cameraid] – > stopPreview（）;
  30. }

3.2CameraHal.cpp去操作节点来进行实际的操作。

//这个几个线程很关键，分别对应着各种不同的情况，但是一直在运行

[CPP] 查看纯副本

打印？

  1. CameraHal :: CameraHal（INT  cameraId）
  2.             ：mParameters（），
  3.             mSnapshotRunning（-1），
  4.             mCommandRunning（-1），
  5.             mPreviewRunning（STA_PREVIEW_PAUSE）
  6.             mPreviewLock（），
  7.             mPreviewCond（），
  8.             mDisplayRuning（STA_DISPLAY_PAUSE）
  9.             mDisplayLock（），
  10.             mDisplayCond（），
  11.             mANativeWindowLock（），
  12.             mANativeWindowCond（），
  13.             mANativeWindow（NULL）
  14.             mPreviewErrorFrameCount（0），
  15.             mPreviewFrameSize（0），
  16.             mCamDriverFrmHeightMax（0），
  17.             mCamDriverFrmWidthMax（0），
  18.             mPreviewBufferCount（0），
  19.             mCamDriverPreviewFmt（0），
  20.             mCamDriverPictureFmt（0），
  21.             mCamDriverV4l2BufferLen（0），
  22.             mPreviewMemory（NULL）
  23.             mRawBufferSize（0），
  24.             mJpegBufferSize（0），
  25.             mMsgEnabled（0），
  26.             mEffect_number（0），
  27.             mScene_number（0），
  28.             mWhiteBalance_number（0），
  29.             mFlashMode_number（0），
  30.             mGps_latitude（-1），
  31.             mGps_longitude（-1），
  32.             mGps_altitude（-1），
  33.             mGps_timestamp（-1），
  34.             displayThreadCommandQ（“displayCmdQ” ），
  35.             displayThreadAckQ（“displayAckQ” ），
  36.             previewThreadCommandQ（“previewCmdQ” ），
  37.             previewThreadAckQ（“previewAckQ” ），
  38.             commandThreadCommandQ（“commandCmdQ” ），
  39.             commandThreadAckQ（“commandAckQ” ），
  40.             snapshotThreadCommandQ（“snapshotCmdQ” ），
  41.             snapshotThreadAckQ（“snapshotAckQ” ），
  42.             mCamBuffer（NULL）
  43. {
  44.     INT  FP，我;
  46.     cameraCallProcess [0] = 0×00;
  47.     sprintf的（cameraCallProcess， “ 的/ proc /％D / CMDLINE” ，getCallingPid（））;
  48.     计划生育=打开（cameraCallProcess，O_RDONLY）;
  49.     如果 （FP <0）{
  50.         memset的（cameraCallProcess，为0x00，sizeof的（cameraCallProcess））;
  51.         LOGE（ “ 获取调用进程信息失败” ）;
  52.     }  其他 {
  53.         memset的（cameraCallProcess，为0x00，sizeof的（cameraCallProcess））;
  54.         阅读（FP，cameraCallProcess，30）;
  55.         关闭（FP）;
  56.         FP = -1;
  57.         LOGD（ “ 调用过程是：％S” ，cameraCallProcess）;
  58.     }
  60.     iCamFd = -1;
  61.     memset的（mCamDriverSupportFmt [0]，0，  sizeof的（mCamDriverSupportFmt））;
  62.     mRecordRunning =  虚假的;
  63.     mPictureRunning = STA_PICTURE_STOP;
  64.     mExitAutoFocusThread =  虚假的;
  65.     mDriverMirrorSupport =  虚假的;
  66.     mDriverFlipSupport =  虚假的;
  67.     mPreviewCmdReceived =  虚假的;
  68.     mPreviewStartTimes = 0×00;
  69.     memset的（mCamDriverV4l2Buffer，为0x00，  sizeof的（mCamDriverV4l2Buffer））;
  70.     memset的（mDisplayFormat，为0x00，sizeof的（mDisplayFormat））;
  71.     对于 （i = 0; I <CONFIG_CAMERA_PRVIEW_BUF_CNT;我++）{
  72.         mPreviewBufferMap [I] = NULL;
  73.         mDisplayBufferMap [I] = NULL;
  74.         memset的（mGrallocBufferMap [I]，0×00，的sizeof （rk_previewbuf_info_t））;
  75.         mPreviewBufs [I] = NULL;
  76.         mVideoBufs [I] = NULL;
  78.         mPreviewBuffer [I] = NULL;
  79.     }
  81.     //打开RGA设备，ZYC
  82.     mRGAFd = -1;
  84.     如果 （cameraCreate（cameraId）== 0）{
  85.         initDefaultParameters（）;
  87.         cameraRawJpegBufferCreate（mRawBufferSize，mJpegBufferSize）;
  89.         mDisplayThread =  新 DisplayThread（本）;
  90.         mPreviewThread =  新 PreviewThread（本）;
  91.         mCommandThread =  新 CommandThread（本）;
  92.         mPictureThread =  新 PictureThread（本）;
  93.     mSnapshotThread =  新 SnapshotThread（本）;
  94.         mAutoFocusThread =  新 AutoFocusThread（本）;
  95.         mDisplayThread->运行（“CameraDispThread” ，ANDROID_PRIORITY_URGENT_DISPLAY）;
  96.         mPreviewThread->运行（“CameraPreviewThread” ，ANDROID_PRIORITY_DISPLAY）;
  97.         mCommandThread->运行（“CameraCmdThread” ，ANDROID_PRIORITY_URGENT_DISPLAY）;
  98.         mAutoFocusThread->运行（“CameraAutoFocusThread” ，ANDROID_PRIORITY_DISPLAY）;
  99.         mSnapshotThread->运行（“CameraSnapshotThread” ，ANDROID_PRIORITY_NORMAL）;
  101.         LOGD（“CameraHal共创佳绩！” ）;
  102.     }  其他 {
  103.         mPreviewThread = NULL;
  104.         mDisplayThread = NULL;
  105.         mCommandThread = NULL;
  106.         mPictureThread = NULL;
  107.         mSnapshotThread = NULL;
  108.         mAutoFocusThread = NULL;
  109.     }
  111. }

初始化时参数的配置，默认参数图片大小，分辨率，帧等：

[CPP] 查看纯副本

打印？

  1. 无效 CameraHal :: initDefaultParameters（）
  2. {
  3.     CameraParameters PARAMS;
  4.     String8 parameterString;
  5.     诠释 I，J，previewFrameSizeMax;
  6.     炭 cur_param [32]，cam_size [10];
  7.     焦炭 str_picturesize [100]; //我们是在4分辨率支持：2592×1944,2048×1536,1600×1200,1024×768 
  8.     INT  RET，picture_size_bit;
  9.     结构 v4l2_format FMT;
  11.     LOG_FUNCTION_NAME
  12.     memset的（str_picturesize，为0x00，sizeof的（str_picturesize））;
  13.     如果 （CAMERA_IS_UVC_CAMERA（））{
  14.         / *预览大小设置* /
  15.         结构 v4l2_frmsizeenum FSIZE;
  17.         memset的（FSIZE，0，  sizeof的（FSIZE））;
  18.         picture_size_bit = 0;
  19.         fsize.index = 0;
  20.         fsize.pixel_format = mCamDriverPreviewFmt;
  21.         而 （（RET =的ioctl（iCamFd，VIDIOC_ENUM_FRAMESIZES，与FSIZE））== 0）{
  22.             如果 （fsize.type == V4L2_FRMSIZE_TYPE_DISCRETE）{
  23.                 如果 （（fsize.discrete.width == 320）&&（fsize.discrete.height == 240））{
  24.                     如果 （STRCMP（cameraCallProcess，“com.tencent.android.pad” ）== 0）{
  25.                         fsize.index ++;
  26.                         继续;
  27.                     }
  28.                 }
  29.                 memset的（cam_size，为0x00，sizeof的（cam_size））;
  30.                 如果 （parameterString.size（）！= 0）
  31.                     cam_size [0] = ‘，’ ;
  32.                 sprintf的（（字符*）（cam_size [strlen的（cam_size）]）， “％D” ，fsize.discrete.width）;
  33.                 的strcat（cam_size，  “×” ）;
  34.                 sprintf的（（字符*）（cam_size [strlen的（cam_size）]）， “％D” ，fsize.discrete.height）;
  35.                 parameterString.append（（常量字符*）cam_size）;
  37.                 如果 （（strlen的（str_picturesize）+ strlen的（cam_size））< 的sizeof （str_picturesize））{
  38.                     如果 （fsize.discrete.width <= 2592）{
  39.                         strcat的（str_picturesize，cam_size）;
  40.                         如果 （fsize.discrete.width> mCamDriverFrmWidthMax）{
  41.                             mCamDriverFrmWidthMax = fsize.discrete.width;
  42.                             mCamDriverFrmHeightMax = fsize.discrete.height;
  43.                         }
  44.                     }
  45.                 }  其他 {
  46.                     突破;
  47.                 }
  48.             }  否则如果 （fsize.type == V4L2_FRMSIZE_TYPE_CONTINUOUS）{
  50.                 突破;
  51.             }  否则如果 （fsize.type == V4L2_FRMSIZE_TYPE_STEPWISE）{
  53.                 突破;
  54.             }
  55.             fsize.index ++;
  56.         }
  57.         如果 （RET！= 0 &&错误号！= EINVAL）{
  58.             LOGE（“ERROR枚举帧大小数：％d n” ，错误号）;
  59.         }
  61.         params.set（CameraParameters :: KEY_SUPPORTED_PREVIEW_SIZES，parameterString.string（））;
  62.         params.setPreviewSize（640,480）;
  63.         / *照片尺寸设置* /
  64.         params.set（CameraParameters :: KEY_SUPPORTED_PICTURE_SIZES，str_picturesize）;
  65.         params.setPictureSize（mCamDriverFrmWidthMax，mCamDriverFrmHeightMax）;
  67.         如果 （mCamDriverFrmWidthMax <= 1024）{
  68.             mRawBufferSize = RAW_BUFFER_SIZE_1M;
  69.             mJpegBufferSize = JPEG_BUFFER_SIZE_1M;
  70.         }  否则如果 （mCamDriverFrmWidthMax <= 1600）{
  71.             mRawBufferSize = RAW_BUFFER_SIZE_2M;
  72.             mJpegBufferSize = JPEG_BUFFER_SIZE_2M;
  73.         }  否则如果 （mCamDriverFrmWidthMax <= 2048）{
  74.             mRawBufferSize = RAW_BUFFER_SIZE_3M;
  75.             mJpegBufferSize = JPEG_BUFFER_SIZE_3M;
  76.         }  否则如果 （mCamDriverFrmWidthMax <= 2592）{
  77.             mRawBufferSize = RAW_BUFFER_SIZE_5M;
  78.             mJpegBufferSize = JPEG_BUFFER_SIZE_5M;
  79.         }  其他 {
  80.             LOGE（ “％S（％D）：相机哈尔只支持5Mega摄像头，但UVC摄像头DX％％D” ，
  81.                  __FUNCTION __，__ __ LINE，mCamDriverFrmWidthMax，mCamDriverFrmHeightMax）;
  82.             mRawBufferSize = RAW_BUFFER_SIZE_5M;
  83.             mJpegBufferSize = JPEG_BUFFER_SIZE_5M;
  84.         }
  86.         / *设置帧率* /
  87.         结构 v4l2_streamparm setfps;
  89.         memset的（setfps，0，  sizeof的（结构 v4l2_streamparm））;
  90.         setfps.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  91.         setfps.parm.capture.timeperframe.numerator = 1;
  92.         setfps.parm.capture.timeperframe.denominator = 15;
  93.         RET =的ioctl（iCamFd，VIDIOC_S_PARM，与setfps）;
  95.         / *帧速率设置* /
  96.         params.set（CameraParameters :: KEY_SUPPORTED_PREVIEW_FRAME_RATES，  “15” ）;
  97.         params.setPreviewFrameRate（15）;
  98.         / *每秒帧的设置* /
  99.         parameterString =  “15000,15000” ;
  100.         params.set（CameraParameters :: KEY_PREVIEW_FPS_RANGE，parameterString.string（））;
  101.         parameterString =  “（15000,15000）” ;
  102.         params.set（CameraParameters :: KEY_SUPPORTED_PREVIEW_FPS_RANGE，parameterString.string（））;
  103.         / *不支持变焦* /
  104.         params.set（CameraParameters :: KEY_ZOOM_SUPPORTED， “ 假” ）;
  106.     }  否则如果 （CAMERA_IS_RKSOC_CAMERA（））{
  108.         fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  109.         fmt.fmt.pix.pixelformat = mCamDriverPreviewFmt;
  110.         fmt.fmt.pix.field = V4L2_FIELD_NONE;
  112.         / *照片尺寸设置* /
  113.         fmt.fmt.pix.width = 10000;
  114.         fmt.fmt.pix.height = 10000;
  115.         RET =的ioctl（iCamFd，VIDIOC_TRY_FMT，与FMT）;
  117.         mCamDriverFrmWidthMax = fmt.fmt.pix.width;
  118.         mCamDriverFrmHeightMax = fmt.fmt.pix.height;
  120.         如果 （mCamDriverFrmWidthMax> 2592）{
  121.             LOGE（ “ 相机的驱动程序支持的最大分辨率（％DX％D）溢出5Mega！” ，mCamDriverFrmWidthMax，mCamDriverFrmHeightMax）;
  122.             mCamDriverFrmWidthMax = 2592;
  123.             mCamDriverFrmHeightMax = 1944年;
  124.         }
  126.         / *预览大小设置* /
  127.         如果 （mCamDriverFrmWidthMax> = 176）{
  128.             fmt.fmt.pix.width = 176;
  129.             fmt.fmt.pix.height = 144;
  130.             如果 （的ioctl（iCamFd，VIDIOC_TRY_FMT，与FMT）== 0）{
  131.                 如果 （（fmt.fmt.pix.width == 176）&&（fmt.fmt.pix.height == 144））{
  132.                     parameterString.append（“176×144” ）;
  133.                     params.setPreviewSize（176，144）;
  134.                     previewFrameSizeMax = PAGE_ALIGN（176 * 144 * 2）* 2;           // 176 * 144 * 2 RGB565
  135.                     //params.set(CameraParameters::KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO,”176×144“）;
  136.                 }
  137.             }
  138.         }
  140.         如果 （（mCamDriverCapability.version＆0xff的）> = 0×07）{
  141.             INT  TMP0，TMP1;
  142.             如果 （cameraFramerateQuery（mCamDriverPreviewFmt，240,160，和TMP1，与TMP0）== 0）{
  143.                 如果 （mCamDriverFrmWidthMax> = 240）{
  144.                     fmt.fmt.pix.width = 240;
  145.                     fmt.fmt.pix.height = 160;
  146.                     如果 （的ioctl（iCamFd，VIDIOC_TRY_FMT，与FMT）== 0）{
  147.                         如果 （（fmt.fmt.pix.width == 240）&&（fmt.fmt.pix.height == 160））{
  148.                             parameterString.append（“240×160” ）;
  149.                             params.setPreviewSize（240，160）;
  150.                             previewFrameSizeMax = PAGE_ALIGN（240 * 160 * 2）* 2;           // 240 * 160 * 2 RGB565
  152.                         }
  153.                     }
  154.                 }
  155.             }
  156.         }
  158.         如果 （的strcmp（cameraCallProcess，“com.tencent.android.pad” ））{
  159.             如果 （mCamDriverFrmWidthMax> = 320）{
  160.                 fmt.fmt.pix.width = 320;
  161.                 fmt.fmt.pix.height = 240;
  162.                 如果 （的ioctl（iCamFd，VIDIOC_TRY_FMT，与FMT）== 0）{
  163.                     如果 （（fmt.fmt.pix.width == 320）&&（fmt.fmt.pix.height == 240））{
  164.                         parameterString.append（“320×240” ）;
  165.                         params.setPreviewSize（320，240）;
  166.                         previewFrameSizeMax = PAGE_ALIGN（320 * 240 * 2）* 2;           // 320 * 240 * 2
  168.                     }
  169.                 }
  170.             }
  171.         }
  172.         如果 （mCamDriverFrmWidthMax> = 352）{
  173.             fmt.fmt.pix.width = 352;
  174.             fmt.fmt.pix.height = 288;
  175.             如果 （的ioctl（iCamFd，VIDIOC_TRY_FMT，与FMT）== 0）{
  176.                 如果 （（fmt.fmt.pix.width == 352）&&（fmt.fmt.pix.height == 288））{
  177.                     parameterString.append（“352×288” ）;
  178.                     params.setPreviewSize（352，288）;
  179.                     previewFrameSizeMax = PAGE_ALIGN（352 * 288 * 2）* 2;           // 352 * 288 * 1.5 * 2
  181.                 }
  182.             }
  183.         }
  185.         如果 （mCamDriverFrmWidthMax> = 640）{
  186.             fmt.fmt.pix.width = 640;
  187.             fmt.fmt.pix.height = 480;
  188.             如果 （的ioctl（iCamFd，VIDIOC_TRY_FMT，与FMT）== 0）{
  189.                 如果 （（fmt.fmt.pix.width == 640）&&（fmt.fmt.pix.height == 480））{
  190.                     parameterString.append（“640×480” ）;
  191.                     params.setPreviewSize（640，480）;
  192.                     previewFrameSizeMax = PAGE_ALIGN（640 * 480 * 2）* 2;           // 640 * 480 * 1.5 * 2
  194.                 }
  195.             }
  196.         }
  198.         如果 （mCamDriverFrmWidthMax> = 720）{
  199.             fmt.fmt.pix.width = 720;
  200.             fmt.fmt.pix.height = 480;
  201.             如果 （的ioctl（iCamFd，VIDIOC_TRY_FMT，与FMT）== 0）{
  202.                 如果 （（fmt.fmt.pix.width == 720）&&（fmt.fmt.pix.height == 480））{
  203.                     parameterString.append（“720×480” ）;
  204.                     previewFrameSizeMax = PAGE_ALIGN（720 * 480 * 2）* 2;           // 720 * 480 * 1.5 * 2
  206.                 }
  207.             }
  208.         }
  210.         如果 （mCamDriverFrmWidthMax> 1280）{
  211.             fmt.fmt.pix.width = 1280;
  212.             fmt.fmt.pix.height = 720;
  213.             如果 （的ioctl（iCamFd，VIDIOC_TRY_FMT，与FMT）== 0）{
  214.                 如果 （（fmt.fmt.pix.width == 1280）&&（fmt.fmt.pix.height == 720））{
  215.                     parameterString.append（“1280×720” ）;
  216.                     previewFrameSizeMax = PAGE_ALIGN（1280 * 720 * 2）* 2;           // 1280 * 720 * 1.5 * 2
  218.                 }
  219.             }
  220.         }
  221.         mSupportPreviewSizeReally = parameterString;
  222.         / * ddl@rock-chips.com：面部锁速度低，所以缩小预览数据到面部锁为加快* /
  223.         如果 （（STRCMP（cameraCallProcess，“com.android.facelock” ）== 0））{
  224.             如果 （的strstr（mSupportPreviewSizeReally.string（），“640×480” ）||
  225.                 的strstr（mSupportPreviewSizeReally.string（），“320×240” ））{
  226.                 parameterString =  “160×120” ;
  227.                 params.setPreviewSize（160，120）;
  228.             }
  229.         }
  230.         params.set（CameraParameters :: KEY_SUPPORTED_PREVIEW_SIZES，parameterString.string（））;
  232.         的strcat（str_picturesize，parameterString.string（））;
  233.         的strcat（str_picturesize， “，” ）;
  234.         如果（mCamDriverFrmWidthMax <= 640）{
  235.             的strcat（str_picturesize，“640×480,320×240” ）;
  236.             mRawBufferSize = RAW_BUFFER_SIZE_0M3;
  237.             mJpegBufferSize = JPEG_BUFFER_SIZE_0M3;
  238.             params.setPictureSize（640,480）;
  239.         } 否则如果 （mCamDriverFrmWidthMax <1280）{
  240.             的strcat（str_picturesize，“1024×768,640×480,320×240” ）;
  241.             mRawBufferSize = RAW_BUFFER_SIZE_1M;
  242.             mJpegBufferSize = JPEG_BUFFER_SIZE_1M;
  243.             params.setPictureSize（1024,768）;
  244.         }  否则如果 （mCamDriverFrmWidthMax <= 1600）{
  245.             的strcat（str_picturesize，“1600×1200,1024×768,640×480” ）;
  246.             mRawBufferSize = RAW_BUFFER_SIZE_2M;
  247.             mJpegBufferSize = JPEG_BUFFER_SIZE_2M;
  248.             params.setPictureSize（1600,1200）;
  249.         }  否则如果 （mCamDriverFrmWidthMax <= 2048）{
  250.             的strcat（str_picturesize，“2048×1536,1600×1200,1024×768” ）;
  251.             mRawBufferSize = RAW_BUFFER_SIZE_3M;
  252.             mJpegBufferSize = JPEG_BUFFER_SIZE_3M;
  253.             params.setPictureSize（2048,1536）;
  254.         }  否则如果 （mCamDriverFrmWidthMax <= 2592）{
  255.             的strcat（str_picturesize，“2592×1944,2048×1536,1600×1200,1024×768” ）;
  256.             params.setPictureSize（2592,1944）;
  257.             mRawBufferSize = RAW_BUFFER_SIZE_5M;
  258.             mJpegBufferSize = JPEG_BUFFER_SIZE_5M;
  259.         }  其他 {
  260.             sprintf的（str_picturesize， “％DX％D” ，mCamDriverFrmWidthMax，mCamDriverFrmHeightMax）;
  261.             mRawBufferSize = RAW_BUFFER_SIZE_5M;
  262.             mJpegBufferSize = JPEG_BUFFER_SIZE_5M;
  263.             params.setPictureSize（mCamDriverFrmWidthMax，mCamDriverFrmHeightMax）;
  264.         }
  266.         params.set（CameraParameters :: KEY_SUPPORTED_PICTURE_SIZES，str_picturesize）;
  268.         / *帧速率设置* /
  269.         cameraFpsInfoSet（PARAMS）;
  271.         / *缩放设置* /
  272.         结构 v4l2_queryctrl变焦;
  273.         炭 str_zoom_max [3]，str_zoom_element [5];
  274.         焦炭 str_zoom [200];
  275.         的strcpy（str_zoom， “” ）; //默认缩放
  276.         INT  最大;
  278.         zoom.id = V4L2_CID_ZOOM_ABSOLUTE;
  279.         如果 （！的ioctl（iCamFd，VIDIOC_QUERYCTRL，和缩放））{
  280.             mZoomMax = zoom.maximum;
  281.             mZoomMin = zoom.minimum;
  282.             mZoomStep = zoom.step;
  284.             最大=（mZoomMax – mZoomMin）/ mZoomStep;
  285.             sprintf的（str_zoom_max， “％D” ，最大值）;
  286.             params.set（CameraParameters :: KEY_ZOOM_SUPPORTED， “ 真” ）;
  287.             params.set（CameraParameters :: KEY_MAX_ZOOM，str_zoom_max）;
  288.             params.set（CameraParameters :: KEY_ZOOM，  “0” ）;
  289.             对于 （i = mZoomMin;我<= mZoomMax; I + = mZoomStep）{
  290.                 sprintf的（str_zoom_element， “％D” ，我）;
  291.                 strcat的（str_zoom，str_zoom_element）;
  292.             }
  293.             params.set（CameraParameters :: KEY_ZOOM_RATIOS，str_zoom）;
  294.         }
  295.     }
  296.     / *预览格式设置* /
  297.     params.set（CameraParameters :: KEY_SUPPORTED_PREVIEW_FORMATS，  “yuv420sp，RGB565，YUV420P” ）;
  298.     params.set（CameraParameters :: KEY_VIDEO_FRAME_FORMAT，CameraParameters :: PIXEL_FORMAT_YUV420SP）;
  299.     如果 （STRCMP（cameraCallProcess，“com.android.camera” ）== 0）{     //为PanoramaActivity
  300.         params.setPreviewFormat（CameraParameters :: PIXEL_FORMAT_RGB565）;
  301.     }  其他 {
  302.         params.setPreviewFormat（CameraParameters :: PIXEL_FORMAT_YUV420SP）;
  303.     }
  304.     / * zyc@rock-chips.com：预设为displayformat CTS * /
  305.     的strcpy（mDisplayFormat，CAMERA_DISPLAY_FORMAT_NV12）;
  308.     params.set（CameraParameters :: KEY_VIDEO_FRAME_FORMAT，CameraParameters :: PIXEL_FORMAT_YUV420SP）;
  310.     / *图片格式设置* /
  311.     params.set（CameraParameters :: KEY_SUPPORTED_PICTURE_FORMATS，CameraParameters :: PIXEL_FORMAT_JPEG）;
  312.     params.setPictureFormat（CameraParameters :: PIXEL_FORMAT_JPEG）;
  314.     / * JPEG画质设置* /
  315.     params.set（CameraParameters :: KEY_JPEG_QUALITY，  “70” ）;
  317.     / *白平衡设置* /
  318.     结构 v4l2_queryctrl最大光圈;
  319.     结构 v4l2_querymenu * whiteBalance_menu = mWhiteBalance_menu;
  320.     焦炭 str_whitebalance [200];
  321.     的strcpy（str_whitebalance， “” ）; //默认最大光圈
  322.     whiteBalance.id = V4L2_CID_DO_WHITE_BALANCE;
  323.     如果 （！的ioctl（iCamFd，VIDIOC_QUERYCTRL，与最大光圈））{
  324.         对于 （i = whiteBalance.minimum;我<= whiteBalance.maximum; I + = whiteBalance.step）{
  325.             whiteBalance_menu-> ID = V4L2_CID_DO_WHITE_BALANCE;
  326.             whiteBalance_menu->指数= I;
  327.             如果 （！的ioctl（iCamFd，VIDIOC_QUERYMENU，whiteBalance_menu））{
  328.                 如果 （我！= whiteBalance.minimum）
  329.                     的strcat（str_whitebalance， “，” ）;
  330.                 strcat的（str_whitebalance，（字符 *）whiteBalance_menu->名）;
  331.                 如果 （whiteBalance.default_value == I）{
  332.                     的strcpy（cur_param，（字符 *）whiteBalance_menu->名）;
  333.                 }
  334.                 mWhiteBalance_number ++;
  335.             }
  336.             whiteBalance_menu ++;
  337.         }
  338.         params.set（CameraParameters :: KEY_SUPPORTED_WHITE_BALANCE，str_whitebalance）;
  339.         params.set（CameraParameters :: KEY_WHITE_BALANCE，cur_param）;
  340.     }
  342.     / *色彩效果设置* /
  343.     结构 v4l2_queryctrl效果;
  344.     结构 v4l2_querymenu * effect_menu = mEffect_menu;
  345.     焦炭 str_effect [200];
  346.     的strcpy（str_effect， “” ）; //默认效果
  347.     effect.id = V4L2_CID_EFFECT;
  348.     如果 （！的ioctl（iCamFd，VIDIOC_QUERYCTRL，及效果））{
  349.         对于 （i = effect.minimum;我<= effect.maximum; I + = effect.step）{
  350.             effect_menu-> ID = V4L2_CID_EFFECT;
  351.             effect_menu->指数= I;
  352.             如果 （！的ioctl（iCamFd，VIDIOC_QUERYMENU，effect_menu））{
  353.                 如果 （我！= effect.minimum）
  354.                     的strcat（str_effect， “，” ）;
  355.                 strcat的（str_effect，（字符 *）effect_menu->名）;
  356.                 如果 （effect.default_value == I）{
  357.                     的strcpy（cur_param，（字符 *）effect_menu->名）;
  358.                 }
  359.                 mEffect_number ++;
  360.             }
  361.             effect_menu ++;
  362.         }
  363.         params.set（CameraParameters :: KEY_SUPPORTED_EFFECTS，str_effect）;
  364.         params.set（CameraParameters :: KEY_EFFECT，cur_param）;
  365.     }
  367.     / *场景设置* /
  368.     结构 v4l2_queryctrl现场;
  369.     结构 v4l2_querymenu * scene_menu = mScene_menu;
  370.     焦炭 str_scene [200];
  371.     的strcpy（str_scene， “” ）; //默认场景
  372.     scene.id = V4L2_CID_SCENE;
  373.     如果 （！的ioctl（iCamFd，VIDIOC_QUERYCTRL，与场景））{
  374.         对于 （i = scene.minimum;我<= scene.maximum; I + = scene.step）{
  375.             scene_menu-> ID = V4L2_CID_SCENE;
  376.             scene_menu->指数= I;
  377.             如果 （！的ioctl（iCamFd，VIDIOC_QUERYMENU，scene_menu））{
  378.                 如果 （我！= scene.minimum）
  379.                     的strcat（str_scene， “，” ）;
  380.                 strcat的（str_scene，（字符 *）scene_menu->名）;
  381.                 如果 （scene.default_value == I）{
  382.                     的strcpy（cur_param，（字符 *）scene_menu->名）;
  383.                 }
  384.                 mScene_number ++;
  385.             }
  386.             scene_menu ++;
  387.         }
  388.         params.set（CameraParameters :: KEY_SUPPORTED_SCENE_MODES，str_scene）;
  389.         params.set（CameraParameters :: KEY_SCENE_MODE，cur_param）;
  391.     }
  393.     / *闪光灯模式设置* /
  394.     结构 v4l2_queryctrl flashMode;
  395.     结构 v4l2_querymenu * flashMode_menu = mFlashMode_menu;
  396.     焦炭 str_flash [200];
  397.     的strcpy（str_flash， “” ）; //默认闪光
  398.     flashMode.id = V4L2_CID_FLASH;
  399.     如果 （！的ioctl（iCamFd，VIDIOC_QUERYCTRL，与flashMode））{
  400.         对于 （i = flashMode.minimum;我<= flashMode.maximum; I + = flashMode.step）{
  401.             flashMode_menu-> ID = V4L2_CID_FLASH;
  402.             flashMode_menu->指数= I;
  403.             如果 （！的ioctl（iCamFd，VIDIOC_QUERYMENU，flashMode_menu））{
  404.                 如果 （我！= flashMode.minimum）
  405.                     的strcat（str_flash， “，” ）;
  406.                 strcat的（str_flash，（字符 *）flashMode_menu->名）;
  407.                 如果 （flashMode.default_value == I）{
  408.                     的strcpy（cur_param，（字符 *）flashMode_menu->名）;
  409.                 }
  410.                 mFlashMode_number ++;
  411.             }
  412.             flashMode_menu ++;
  413.         }
  414.         params.set（CameraParameters :: KEY_SUPPORTED_FLASH_MODES，str_flash）;
  415.         params.set（CameraParameters :: KEY_FLASH_MODE，cur_param）;
  416.     }
  418.     / *对焦模式设置* /
  419.     结构 v4l2_queryctrl重点;
  421.     parameterString = CameraParameters :: FOCUS_MODE_FIXED;
  422.     params.set（CameraParameters :: KEY_FOCUS_MODE，CameraParameters :: FOCUS_MODE_FIXED）;
  423.     focus.id = V4L2_CID_FOCUS_AUTO;
  424.     如果 （！的ioctl（iCamFd，VIDIOC_QUERYCTRL，和对焦））{
  425.         parameterString.append（ “，” ）;
  426.         parameterString.append（CameraParameters :: FOCUS_MODE_AUTO）;
  427.         params.set（CameraParameters :: KEY_FOCUS_MODE，CameraParameters :: FOCUS_MODE_AUTO）;
  428.     }
  430.     focus.id = V4L2_CID_FOCUS_CONTINUOUS;
  431.     如果 （！的ioctl（iCamFd，VIDIOC_QUERYCTRL，和对焦））{
  432.         parameterString.append（ “，” ）;
  433.         parameterString.append（CameraParameters :: FOCUS_MODE_EDOF）;
  434.     }
  436.     focus.id = V4L2_CID_FOCUS_ABSOLUTE;
  437.     如果 （！的ioctl（iCamFd，VIDIOC_QUERYCTRL，和对焦））{
  438.         parameterString.append（ “，” ）;
  439.         parameterString.append（CameraParameters :: FOCUS_MODE_INFINITY）;
  440.         parameterString.append（ “，” ）;
  441.         parameterString.append（CameraParameters :: FOCUS_MODE_MACRO）;
  442.     }
  444.     params.set（CameraParameters :: KEY_SUPPORTED_FOCUS_MODES，parameterString.string（））;
  446.     / *镜和翻转查询* /
  447.     结构 v4l2_queryctrl镜像，翻转;
  449.     mirror.id = V4L2_CID_HFLIP;
  450.     如果 （！的ioctl（iCamFd，VIDIOC_QUERYCTRL，与镜））{
  451.         mDriverMirrorSupport =  真;
  452.     }  其他 {
  453.         mDriverMirrorSupport =  虚假的;
  454.     }
  456.     flip.id = V4L2_CID_VFLIP;
  457.     如果 （！的ioctl（iCamFd，VIDIOC_QUERYCTRL，与翻转））{
  458.         mDriverFlipSupport =  真;
  459.     }  其他 {
  460.         mDriverFlipSupport =  虚假的;
  461.     }
  464.     / *曝光设置* /
  465.     结构 v4l2_queryctrl曝光;
  466.     炭 str_exposure [16];
  467.     exposure.id = V4L2_CID_EXPOSURE;
  468.     如果 （！的ioctl（iCamFd，VIDIOC_QUERYCTRL，与曝光））{
  469.         sprintf的（str_exposure， “％D” ，exposure.default_value）;
  470.         params.set（CameraParameters :: KEY_EXPOSURE_COMPENSATION，str_exposure）;
  471.         sprintf的（str_exposure， “％D” ，exposure.maximum）;
  472.         params.set（CameraParameters :: KEY_MAX_EXPOSURE_COMPENSATION，str_exposure）;
  473.         sprintf的（str_exposure， “％D” ，exposure.minimum）;
  474.         params.set（CameraParameters :: KEY_MIN_EXPOSURE_COMPENSATION，str_exposure）;
  475.         sprintf的（str_exposure， “％D” ，exposure.step）;
  476.         params.set（CameraParameters :: KEY_EXPOSURE_COMPENSATION_STEP，str_exposure）;
  477.     }  其他 {
  478.         params.set（CameraParameters :: KEY_EXPOSURE_COMPENSATION，  “0” ）;
  479.         params.set（CameraParameters :: KEY_MAX_EXPOSURE_COMPENSATION，  “0” ）;
  480.         params.set（CameraParameters :: KEY_MIN_EXPOSURE_COMPENSATION，  “0” ）;
  481.         params.set（CameraParameters :: KEY_EXPOSURE_COMPENSATION_STEP，  “0.000001f” ）;
  482.     }
  483.     / *旋转设置* /
  484.     params.set（CameraParameters :: KEY_ROTATION，  “0” ）;
  486.     /*lzg@rockchip.com：添加一些设置，通过CTS * /
  487.     / *对焦距离设置，没有太多的意义，只为传递CTS * /
  488.     parameterString =  “0.3,50，无限” ;
  489.     params.set（CameraParameters :: KEY_FOCUS_DISTANCES，parameterString.string（））;
  490.     / *焦距设置，没有太多的意义，只为传递CTS * /
  491.     parameterString =  “35” ;
  492.     params.set（CameraParameters :: KEY_FOCAL_LENGTH，parameterString.string（））;
  493.    / *只传递CTS视图设置，没有太大的意义，水平角度* /
  494.     parameterString =  “100” ;
  495.     params.set（CameraParameters :: KEY_HORIZONTAL_VIEW_ANGLE，parameterString.string（））;
  496.     / *只传递CTS视图设置，没有太大的意义，垂直角* /
  497.     parameterString =  “100” ;
  498.     params.set（CameraParameters :: KEY_VERTICAL_VIEW_ANGLE，parameterString.string（））;
  500.    / *在JPEG图片设置的EXIF缩略图的质量* /
  501.     parameterString =  “50” ;
  502.     params.set（CameraParameters :: KEY_JPEG_THUMBNAIL_QUALITY，parameterString.string（））;
  503.    / *在JPEG图片设置的EXIF缩略图的尺寸支持* /
  504.     parameterString =  “0x0,160×128” ;
  505.     params.set（CameraParameters :: KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES，parameterString.string（））;
  506.     parameterString =  “160” ;
  507.     params.set（CameraParameters :: KEY_JPEG_THUMBNAIL_WIDTH，parameterString.string（））;
  508.     parameterString =  “128” ;
  509.     params.set（CameraParameters :: KEY_JPEG_THUMBNAIL_HEIGHT，parameterString.string（））;
  510.     / * zyc@rock-chips.com：对于CTS，KEY_MAX_NUM_DETECTED_FACES_HW不应该是0 * /
  511.     params.set（CameraParameters :: KEY_MAX_NUM_DETECTED_FACES_HW，  “0” ）;
  512.     params.set（CameraParameters :: KEY_MAX_NUM_DETECTED_FACES_SW，  “0” ）;
  513.     params.set（CameraParameters :: KEY_RECORDING_HINT， “ 假” ）;
  514.     params.set（CameraParameters :: KEY_VIDEO_STABILIZATION_SUPPORTED， “ 假” ）;
  515.     params.set（CameraParameters :: KEY_VIDEO_SNAPSHOT_SUPPORTED， “ 真” ）;
  516.     params.set（CameraParameters :: KEY_MAX_NUM_METERING_AREAS，“0” ）;
  518.     LOGD（ “ 支持预览格式：％S” ，params.get（CameraParameters :: KEY_SUPPORTED_PREVIEW_FORMATS））;
  519.     LOGD（ “ 支持预览大小：％S” ，params.get（CameraParameters :: KEY_SUPPORTED_PREVIEW_SIZES））;
  520.     LOGD（ “ 支持预览FPS范围：％S” ，params.get（CameraParameters :: KEY_SUPPORTED_PREVIEW_FPS_RANGE））;
  521.     LOGD（ “ 支持预览帧率：％S” ，params.get（CameraParameters :: KEY_SUPPORTED_PREVIEW_FRAME_RATES））;
  522.     LOGD（ “ 支持图片大小：％S” ，params.get（CameraParameters :: KEY_SUPPORTED_PICTURE_SIZES））;
  523.     如果 （params.get（CameraParameters :: KEY_SUPPORTED_WHITE_BALANCE））
  524.         LOGD（ “ 支持白平衡：％S” ，params.get（CameraParameters :: KEY_SUPPORTED_WHITE_BALANCE））;
  525.     如果 （params.get（CameraParameters :: KEY_SUPPORTED_EFFECTS））
  526.         LOGD（ “ 支持色彩效果：％S” ，params.get（CameraParameters :: KEY_SUPPORTED_EFFECTS））;
  527.     如果 （params.get（CameraParameters :: KEY_SUPPORTED_SCENE_MODES））
  528.         LOGD（ “ 支持场景：％S” ，params.get（CameraParameters :: KEY_SUPPORTED_SCENE_MODES））;
  529.     如果 （params.get（CameraParameters :: KEY_SUPPORTED_FLASH_MODES））
  530.         LOGD（ “ 支持flash：％S” ，params.get（CameraParameters :: KEY_SUPPORTED_FLASH_MODES））;
  531.     LOGD（ “ 支持重点：％S” ，params.get（CameraParameters :: KEY_SUPPORTED_FOCUS_MODES））;
  532.     LOGD（ “ 支持缩放：％S（比例：％S）” ，params.get（CameraParameters :: KEY_ZOOM_SUPPORTED）
  533.         params.get（CameraParameters :: KEY_ZOOM_RATIOS））;
  534.     如果 （的strcmp（“0” ，params.get（CameraParameters :: KEY_MAX_EXPOSURE_COMPENSATION））
  535.         || 的strcmp（“0” ，params.get（CameraParameters :: KEY_MIN_EXPOSURE_COMPENSATION）））{
  536.         LOGD（ “ 支持曝光：（％S – >％S）” ，params.get（CameraParameters :: KEY_MIN_EXPOSURE_COMPENSATION）
  537.             params.get（CameraParameters :: KEY_MAX_EXPOSURE_COMPENSATION））;
  538.     }
  539.     LOGD（ “ 支持硬件面临detecte：％S” ，params.get（CameraParameters :: KEY_MAX_NUM_DETECTED_FACES_HW））;
  540.     LOGD（ “ 支持软件面临detecte：％S” ，params.get（CameraParameters :: KEY_MAX_NUM_DETECTED_FACES_SW））;
  541.     LOGD（ “ 支持视频稳定：％S” ，params.get（CameraParameters :: KEY_VIDEO_STABILIZATION_SUPPORTED））;
  542.     LOGD（ “ 支持录音提示：％S” ，params.get（CameraParameters :: KEY_RECORDING_HINT））;
  543.     LOGD（ “ 支持视频快照：％S” ，params.get（CameraParameters :: KEY_VIDEO_SNAPSHOT_SUPPORTED））;
  544.     LOGD（ “ 支持镜像和财政投融资：％S” ，（mDriverMirrorSupport && mDriverFlipSupport）？ “ 真” ：“假” ）;
  546.     cameraConfig（PARAMS）;
  547.     LOG_FUNCTION_NAME_EXIT
  549. }

然后剩下的大部分都是针对这个线程的运行实现以及对于CameraHal_Module.cpp中实现的为上层提供的接口的具体实现，比如：

[CPP] 查看纯副本

打印？

  1. INT  CameraHal :: startPreview（）
  2. {
  3.     LOG_FUNCTION_NAME
  4.     信息MSG;
  5.     ::互斥锁自动锁定（MLOCK）;
  7.     如果 （（mPreviewThread！= NULL）&&（mCommandThread！= NULL））{
  8.         msg.command = CMD_PREVIEW_START;
  9.         msg.arg1 =（无效*）CMDARG_NACK;
  10.         commandThreadCommandQ.put（MSG）;
  11.     }
  12.     mPreviewCmdReceived =  真;
  13.     LOG_FUNCTION_NAME_EXIT
  14.     返回 NO_ERROR;
  15. }
  17. 无效 CameraHal :: stopPreview（）
  18. {
  19.     LOG_FUNCTION_NAME
  20.     信息MSG;
  21.     INT  RET = 0;
  22.     ::互斥锁自动锁定（MLOCK）;
  24.     如果 （（mPreviewThread！= NULL）&&（mCommandThread！= NULL））{
  25.         msg.command = CMD_PREVIEW_STOP;
  26.         msg.arg1 =（无效*）CMDARG_ACK;
  27.         commandThreadCommandQ.put（MSG）;
  29.         如果 （mANativeWindow == NULL）{
  30.             mANativeWindowCond.signal（）;
  31.             LOGD（ “％S（％D）：为停止预览唤醒命令线程” ，__ __功能__ LINE__）;
  32.         }
  34.         而 （RET == 0）{
  35.             RET = commandThreadAckQ.get（MSG）;
  36.             如果 （RET == 0）{
  37.                 如果 （msg.command == CMD_PREVIEW_STOP）{
  38.                     RET = 1;
  39.                 }
  40.             }
  41.         }
  42.     }  其他 {
  43.         LOGE（ “％S（％D）：取消，是因为线程（％s％S）为空” ，__FUNCTION __，__ __ LINE（mPreviewThread == NULL）？“mPreviewThread” ：“” ，
  44.             （mCommandThread == NULL）？“mCommandThread” ：“” ）;
  45.     }
  46.     mPreviewCmdReceived =  虚假的;
  47.     LOG_FUNCTION_NAME_EXIT
  48. }
  50. INT  CameraHal ::自动对焦（）
  51. {
  52.     LOG_FUNCTION_NAME
  53.     INT  RET = 0;
  54.     信息MSG;
  55.     ::互斥锁自动锁定（MLOCK）;
  57.     如果 （（mPreviewThread！= NULL）&&（mCommandThread！= NULL））{
  58.         msg.command = CMD_AF_START;
  59.         msg.arg1 =（无效*）CMDARG_ACK;
  60.         commandThreadCommandQ.put（MSG）;
  61.         而 （RET == 0）{
  62.             RET = commandThreadAckQ.get（味精，5000）;
  63.             如果 （RET == 0）{
  64.                 如果 （msg.command == CMD_AF_START）{
  65.                     RET = 1;
  66.                 }
  67.             }  其他 {
  68.                 LOGE（ “％S（％D）：自动对焦时间了！ n” ，__ __功能__ LINE__）;
  69.             }
  70.         }
  71.     }  其他 {
  72.         LOGE（ “％S（％D）：取消，是因为线程（％s％S）为空” ，__FUNCTION __，__ __ LINE（mPreviewThread == NULL）？“mPreviewThread” ：“” ，
  73.             （mCommandThread == NULL）？“mCommandThread” ：“” ）;
  74.     }
  75.     LOG_FUNCTION_NAME_EXIT
  76.     返回 NO_ERROR;
  77. }

Related Posts

About The Author

bjmayor

程序员，码农，php,python,ios,android,go，产品经理，创业。

5 Comments
  1. EllNaKe

    Cialis En Ligne Belgique [url=http://priliorder.com]cialis dapoxetine overnight shipping[/url] Buy Revatio Online

  2. EllNaKe

    Viagra Generico Mexico [url=http://bestviaonline.com]online pharmacy[/url] Finasteride Acne Flagyl For Sell Cialis Without A Script

  3. EllNaKe

    Kamagra Autorise En France [url=http://cialionline.com]generic cialis canada[/url] Tarif Levitra 10mg Kamagra En Ligne France Keflex And Breastfeeding

  4. EllNaKe

    Pharmacy 2u Prozac Secure Real Progesterone 100mg Menopause Best Website Shop [url=http://bpdrug.com]pastillas priligy 30 mg[/url] Metronidazole

  5. EllNaKe

    Cialis Generico Effetti Collaterali [url=http://cialonlineno.com]cialis generic[/url] Kamagra Jelly 100mg Strasburgo Finasteride 5mg Side Effects