码迷，mamicode.com
首页 > 移动开发 > 详细

Android Camera HAL浅析

时间：2015-11-04 12:56:40      阅读：366      评论：0      收藏：0      [点我收藏+]

标签：

1、Camera成像原理介绍

Camera工作流程图

技术分享

 

技术分享

 

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

景物(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 Camera框架

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

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

技术分享

 

 

 

--------------------------------------------------------------------------------------------

 

技术分享

-----------------------------------------------------------------------------------------------

技术分享

 

 

 

3.Camera HAL层部分 
代码存放目录：hardware\rk29\camera
编译：

 

[cpp] view plaincopy
  1. LOCAL_PATH:= $(call my-dir)  
  2. include $(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 ($(strip $(TARGET_BOARD_HARDWARE)),rk30board)  
  11. LOCAL_MODULE:= camera.rk30board  

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

 

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

[cpp] view plaincopy
  1. static int camera_device_open(const hw_module_t* module, const char* name,  
  2.                 hw_device_t** device);  
  3. static int camera_device_close(hw_device_t* device);  
  4. static int camera_get_number_of_cameras(void);  
  5. static int camera_get_camera_info(int camera_id, struct camera_info *info);  
  6.   
  7.   
  8. static struct hw_module_methods_t camera_module_methods = {  
  9.         open: camera_device_open  
  10. };  
  11.   
  12.   
  13. camera_module_t HAL_MODULE_INFO_SYM = {  
  14.     common: {  
  15.          tag: 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.          name: CAMERA_MODULE_NAME,  
  20.          author: "RockChip",  
  21.          methods: &camera_module_methods,  
  22.          dso: NULL, /* remove compilation warnings */  
  23.          reserved: {0}, /* remove compilation warnings */  
  24.     },  
  25.     get_number_of_cameras: camera_get_number_of_cameras,  
  26.     get_camera_info: camera_get_camera_info,  
  27. };  


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

[cpp] view plaincopy
  1. int camera_device_close(hw_device_t* device)  
  2. {  
  3.     int ret = 0;  
  4.     rk_camera_device_t* rk_dev = NULL;  
  5.   
  6.     LOGD("%s", __FUNCTION__);  
  7.   
  8.     android::Mutex::Autolock lock(gCameraHalDeviceLock);  
  9.   
  10.     if (!device) {  
  11.         ret = -EINVAL;  
  12.         goto done;  
  13.     }  
  14.   
  15.     rk_dev = (rk_camera_device_t*) device;  
  16.   
  17.     if (rk_dev) {  
  18.         if (gCameraHals[rk_dev->cameraid]) {  
  19.             delete gCameraHals[rk_dev->cameraid];  
  20.             gCameraHals[rk_dev->cameraid] = NULL;  
  21.             gCamerasOpen--;  
  22.         }  
  23.   
  24.         if (rk_dev->base.ops) {  
  25.             free(rk_dev->base.ops);  
  26.         }  
  27.         free(rk_dev);  
  28.     }  
  29. done:  
  30.   
  31.     return ret;  
  32. }  
  33.   
  34. /******************************************************************* 
  35.  * implementation of camera_module functions 
  36.  *******************************************************************/  
  37.   
  38. /* open device handle to one of the cameras 
  39.  * 
  40.  * assume camera service will keep singleton of each camera 
  41.  * so this function will always only be called once per camera instance 
  42.  */  
  43.   
  44. int camera_device_open(const hw_module_t* module, const char* name,  
  45.                 hw_device_t** device)  
  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.     android::CameraHal* camera = NULL;  
  52.   
  53.     android::Mutex::Autolock lock(gCameraHalDeviceLock);  
  54.   
  55.     LOGI("camera_device open");  
  56.   
  57.     if (name != NULL) {  
  58.         cameraid = atoi(name);  
  59.   
  60.         if(cameraid > gCamerasNumber) {  
  61.             LOGE("camera service provided cameraid out of bounds, "  
  62.                     "cameraid = %d, num supported = %d",  
  63.                     cameraid, gCamerasNumber);  
  64.             rv = -EINVAL;  
  65.             goto fail;  
  66.         }  
  67.   
  68.         if(gCamerasOpen >= CAMERAS_SUPPORTED_SIMUL_MAX) {  
  69.             LOGE("maximum number(%d) of cameras already open",gCamerasOpen);  
  70.             rv = -ENOMEM;  
  71.             goto fail;  
  72.         }  
  73.   
  74.         camera_device = (rk_camera_device_t*)malloc(sizeof(*camera_device));  
  75.         if(!camera_device) {  
  76.             LOGE("camera_device allocation fail");  
  77.             rv = -ENOMEM;  
  78.             goto fail;  
  79.         }  
  80.   
  81.         camera_ops = (camera_device_ops_t*)malloc(sizeof(*camera_ops));  
  82.         if(!camera_ops) {  
  83.             LOGE("camera_ops allocation fail");  
  84.             rv = -ENOMEM;  
  85.             goto fail;  
  86.         }  
  87.   
  88.         memset(camera_device, 0, sizeof(*camera_device));  
  89.         memset(camera_ops, 0, sizeof(*camera_ops));  
  90.   
  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 *)(module);  
  94.         camera_device->base.common.close = camera_device_close;  
  95.         camera_device->base.ops = camera_ops;  
  96.   
  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->release = camera_release;  
  119.         camera_ops->dump = camera_dump;  
  120.   
  121.         *device = &camera_device->base.common;  
  122.   
  123.         // -------- RockChip specific stuff --------  
  124.   
  125.         camera_device->cameraid = cameraid;  
  126.           
  127.         camera = new android::CameraHal(cameraid);  
  128.   
  129.         if(!camera) {  
  130.             LOGE("Couldn‘t create instance of CameraHal class");  
  131.             rv = -ENOMEM;  
  132.             goto fail;  
  133.         }  
  134.   
  135.         gCameraHals[cameraid] = camera;  
  136.         gCamerasOpen++;  
  137.     }  
  138.   
  139.     return rv;  
  140.   
  141. fail:  
  142.     if(camera_device) {  
  143.         free(camera_device);  
  144.         camera_device = NULL;  
  145.     }  
  146.     if(camera_ops) {  
  147.         free(camera_ops);  
  148.         camera_ops = NULL;  
  149.     }  
  150.     if(camera) {  
  151.         delete camera;  
  152.         camera = NULL;  
  153.     }  
  154.     *device = NULL;  
  155.     return rv;  
  156. }  
  157.   
  158. int camera_get_number_of_cameras(void)  
  159. {  
  160.     char cam_path[20];  
  161.     char cam_num[3],i;  
  162.     int cam_cnt=0,fd=-1,rk29_cam[CAMERAS_SUPPORT_MAX];  
  163.     struct v4l2_capability capability;  
  164.     rk_cam_info_t camInfoTmp[CAMERAS_SUPPORT_MAX];  
  165.     char *ptr,**ptrr;  
  166.     char version[PROPERTY_VALUE_MAX];  
  167.   
  168.     if (gCamerasNumber > 0)  
  169.         goto camera_get_number_of_cameras_end;  
  170.       
  171.     memset(version,0x00,sizeof(version));  
  172.     sprintf(version,"%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,version);  
  175.       
  176.     memset(&camInfoTmp[0],0x00,sizeof(rk_cam_info_t));  
  177.     memset(&camInfoTmp[1],0x00,sizeof(rk_cam_info_t));  
  178.       
  179.     for (i=0; i<10; i++) {  
  180.         cam_path[0] = 0x00;  
  181.         strcat(cam_path, CAMERA_DEVICE_NAME);  
  182.         sprintf(cam_num, "%d", i);  
  183.         strcat(cam_path,cam_num);  
  184.         fd = open(cam_path, O_RDONLY);  
  185.         if (fd < 0)  
  186.             break;  
  187.   
  188.         memset(&capability, 0, sizeof(struct v4l2_capability));  
  189.         if (ioctl(fd, VIDIOC_QUERYCAP, &capability) < 0) {  
  190.             LOGE("Video device(%s): query capability not supported.\n",cam_path);  
  191.             goto loop_continue;  
  192.         }  
  193.           
  194.         if ((capability.capabilities & (V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING)) != (V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING)) {  
  195.             LOGD("Video device(%s): video capture not supported.\n",cam_path);  
  196.         } else {  
  197.             memset(camInfoTmp[cam_cnt&0x01].device_path,0x00, sizeof(camInfoTmp[cam_cnt&0x01].device_path));  
  198.             strcat(camInfoTmp[cam_cnt&0x01].device_path,cam_path);  
  199.             memset(camInfoTmp[cam_cnt&0x01].fival_list,0x00, sizeof(camInfoTmp[cam_cnt&0x01].fival_list));  
  200.             memcpy(camInfoTmp[cam_cnt&0x01].driver,capability.driver, sizeof(camInfoTmp[cam_cnt&0x01].driver));  
  201.             camInfoTmp[cam_cnt&0x01].version = capability.version;  
  202.             if (strstr((char*)&capability.card[0], "front") != NULL) {  
  203.                 camInfoTmp[cam_cnt&0x01].facing_info.facing = CAMERA_FACING_FRONT;  
  204.             } else {  
  205.                 camInfoTmp[cam_cnt&0x01].facing_info.facing = CAMERA_FACING_BACK;  
  206.             }    
  207.             ptr = strstr((char*)&capability.card[0],"-");  
  208.             if (ptr != NULL) {  
  209.                 ptr++;  
  210.                 camInfoTmp[cam_cnt&0x01].facing_info.orientation = atoi(ptr);  
  211.             } else {  
  212.                 camInfoTmp[cam_cnt&0x01].facing_info.orientation = 0;  
  213.             }  
  214.             cam_cnt++;  
  215.   
  216.             memset(version,0x00,sizeof(version));  
  217.             sprintf(version,"%d.%d.%d",((capability.version&0xff0000)>>16),  
  218.                 ((capability.version&0xff00)>>8),capability.version&0xff);  
  219.             property_set(CAMERADRIVER_VERSION_PROPERTY_KEY,version);  
  220.   
  221.             LOGD("%s(%d): %s:%s",__FUNCTION__,__LINE__,CAMERADRIVER_VERSION_PROPERTY_KEY,version);  
  222.               
  223.             if (cam_cnt >= CAMERAS_SUPPORT_MAX)  
  224.                 i = 10;  
  225.         }  
  226. loop_continue:  
  227.         if (fd > 0) {  
  228.             close(fd);  
  229.             fd = -1;  
  230.         }  
  231.         continue;      
  232.     }  
  233.     //zyc , change the camera infomation if there is a usb camera  
  234.     if((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.     } else if((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;  
  242.   
  243. #if CONFIG_AUTO_DETECT_FRAMERATE  
  244.     rk29_cam[0] = 0xff;  
  245.     rk29_cam[1] = 0xff;  
  246.     for (i=0; i<cam_cnt; i++) {  < span="">
  247.         if (strcmp((char*)&camInfoTmp[i].driver[0],"rk29xx-camera") == 0) {  
  248.             if (strcmp((char*)&camInfoTmp[i].driver[0],(char*)&gCamInfos[i].driver[0]) != 0) {  
  249.                 rk29_cam[i] = i;   
  250.             }  
  251.         } else {  
  252.             rk29_cam[i] = 0xff;  
  253.         }  
  254.     }  
  255.   
  256.     if ((rk29_cam[0] != 0xff) || (rk29_cam[1] != 0xff)) {  
  257.         if (gCameraFpsDetectThread == NULL) {  
  258.             gCameraFpsDetectThread = new CameraFpsDetectThread();  
  259.             LOGD("%s create CameraFpsDetectThread for enum camera framerate!!",__FUNCTION__);  
  260.             gCameraFpsDetectThread->run("CameraFpsDetectThread", ANDROID_PRIORITY_AUDIO);  
  261.         }  
  262.     }  
  263. #endif  
  264.     #if CONFIG_CAMERA_SINGLE_SENSOR_FORCE_BACK_FOR_CTS  
  265.     if ((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.     #endif  
  271.       
  272.     memcpy(&gCamInfos[0], &camInfoTmp[0], sizeof(rk_cam_info_t));  
  273.     memcpy(&gCamInfos[1], &camInfoTmp[1], sizeof(rk_cam_info_t));  
  274.       
  275. camera_get_number_of_cameras_end:  
  276.     LOGD("%s(%d): Current board have %d cameras attached.",__FUNCTION__, __LINE__, gCamerasNumber);  
  277.     return gCamerasNumber;  
  278. }  
  279.   
  280. int camera_get_camera_info(int camera_id, struct camera_info *info)  
  281. {  
  282.     int rv = 0,fp;  
  283.     int face_value = CAMERA_FACING_BACK;  
  284.     int orientation = 0;  
  285.     char process_name[30];  
  286.           
  287.     if(camera_id > gCamerasNumber) {  
  288.         LOGE("%s camera_id out of bounds, camera_id = %d, num supported = %d",__FUNCTION__,  
  289.                 camera_id, gCamerasNumber);  
  290.         rv = -EINVAL;  
  291.         goto end;  
  292.     }  
  293.   
  294.     info->facing = gCamInfos[camera_id].facing_info.facing;  
  295.     info->orientation = gCamInfos[camera_id].facing_info.orientation;         
  296. end:  
  297.     LOGD("%s(%d): camera_%d facing(%d), orientation(%d)",__FUNCTION__,__LINE__,camera_id,info->facing,info->orientation);  
  298.     return rv;  
  299. }  

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

[cpp] view plaincopy
  1. int camera_start_preview(struct camera_device * device)  
  2. {  
  3.     int rv = -EINVAL;  
  4.     rk_camera_device_t* rk_dev = NULL;  
  5.   
  6.     LOGV("%s", __FUNCTION__);  
  7.   
  8.     if(!device)  
  9.         return rv;  
  10.   
  11.     rk_dev = (rk_camera_device_t*) device;  
  12.   
  13.     rv = gCameraHals[rk_dev->cameraid]->startPreview();  
  14.   
  15.     return rv;  
  16. }  
  17.   
  18. void camera_stop_preview(struct camera_device * device)  
  19. {  
  20.     rk_camera_device_t* rk_dev = NULL;  
  21.   
  22.     LOGV("%s", __FUNCTION__);  
  23.   
  24.     if(!device)  
  25.         return;  
  26.   
  27.     rk_dev = (rk_camera_device_t*) device;  
  28.   
  29.     gCameraHals[rk_dev->cameraid]->stopPreview();  
  30. }  


3.2CameraHal.cpp去操作节点来进行实际的操作。
//这个几个线程很关键，分别对应着各种不同的情况，但是一直在运行

[cpp] view plaincopy
  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,i;  
  45.       
  46.     cameraCallProcess[0] = 0x00;   
  47.     sprintf(cameraCallProcess,"/proc/%d/cmdline",getCallingPid());  
  48.     fp = open(cameraCallProcess, O_RDONLY);  
  49.     if (fp < 0) {  
  50.         memset(cameraCallProcess,0x00,sizeof(cameraCallProcess));  
  51.         LOGE("Obtain calling process info failed");  
  52.     } else {  
  53.         memset(cameraCallProcess,0x00,sizeof(cameraCallProcess));  
  54.         read(fp, cameraCallProcess, 30);  
  55.         close(fp);  
  56.         fp = -1;  
  57.         LOGD("Calling process is: %s",cameraCallProcess);  
  58.     }  
  59.       
  60.     iCamFd = -1;  
  61.     memset(&mCamDriverSupportFmt[0],0, sizeof(mCamDriverSupportFmt));  
  62.     mRecordRunning = false;  
  63.     mPictureRunning = STA_PICTURE_STOP;  
  64.     mExitAutoFocusThread = false;  
  65.     mDriverMirrorSupport = false;  
  66.     mDriverFlipSupport = false;  
  67.     mPreviewCmdReceived = false;  
  68.     mPreviewStartTimes = 0x00;      
  69.     memset(mCamDriverV4l2Buffer, 0x00, sizeof(mCamDriverV4l2Buffer));  
  70.     memset(mDisplayFormat,0x00,sizeof(mDisplayFormat));  
  71.     for (i=0; i<config_camera_prview_buf_cnt; i++) {  < span="">
  72.         mPreviewBufferMap[i] = NULL;  
  73.         mDisplayBufferMap[i] = NULL;  
  74.         memset(&mGrallocBufferMap[i],0x00,sizeof(rk_previewbuf_info_t));  
  75.         mPreviewBufs[i] = NULL;  
  76.         mVideoBufs[i] = NULL;  
  77.   
  78.         mPreviewBuffer[i] = NULL;  
  79.     }  
  80.       
  81.     //open the rga device,zyc  
  82.     mRGAFd = -1;  
  83.   
  84.     if (cameraCreate(cameraId) == 0) {  
  85.         initDefaultParameters();  
  86.   
  87.         cameraRawJpegBufferCreate(mRawBufferSize,mJpegBufferSize);  
  88.   
  89.         mDisplayThread = new DisplayThread(this);    
  90.         mPreviewThread = new PreviewThread(this);  
  91.         mCommandThread = new CommandThread(this);  
  92.         mPictureThread = new PictureThread(this);  
  93.     mSnapshotThread = new SnapshotThread(this);  
  94.         mAutoFocusThread = new AutoFocusThread(this);  
  95.         mDisplayThread->run("CameraDispThread",ANDROID_PRIORITY_URGENT_DISPLAY);  
  96.         mPreviewThread->run("CameraPreviewThread",ANDROID_PRIORITY_DISPLAY);  
  97.         mCommandThread->run("CameraCmdThread", ANDROID_PRIORITY_URGENT_DISPLAY);  
  98.         mAutoFocusThread->run("CameraAutoFocusThread", ANDROID_PRIORITY_DISPLAY);  
  99.         mSnapshotThread->run("CameraSnapshotThread", ANDROID_PRIORITY_NORMAL);  
  100.   
  101.         LOGD("CameraHal create success!");  
  102.     } else {  
  103.         mPreviewThread = NULL;  
  104.         mDisplayThread = NULL;  
  105.         mCommandThread = NULL;  
  106.         mPictureThread = NULL;  
  107.         mSnapshotThread = NULL;       
  108.         mAutoFocusThread = NULL;  
  109.     }  
  110.   
  111. }  



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

[cpp] view plaincopy
  1. void CameraHal::initDefaultParameters()  
  2. {  
  3.     CameraParameters params;  
  4.     String8 parameterString;  
  5.     int i,j,previewFrameSizeMax;  
  6.     char cur_param[32],cam_size[10];  
  7.     char str_picturesize[100];//We support at most 4 resolutions: 2592x1944,2048x1536,1600x1200,1024x768   
  8.     int ret,picture_size_bit;  
  9.     struct v4l2_format fmt;      
  10.       
  11.     LOG_FUNCTION_NAME      
  12.     memset(str_picturesize,0x00,sizeof(str_picturesize));  
  13.     if (CAMERA_IS_UVC_CAMERA()) {  
  14.         /*preview size setting*/  
  15.         struct v4l2_frmsizeenum fsize;                  
  16.           
  17.         memset(&fsize, 0, sizeof(fsize));           
  18.         picture_size_bit = 0;  
  19.         fsize.index = 0;         
  20.         fsize.pixel_format = mCamDriverPreviewFmt;  
  21.         while ((ret = ioctl(iCamFd, VIDIOC_ENUM_FRAMESIZES, &fsize)) == 0) {  
  22.             if (fsize.type == V4L2_FRMSIZE_TYPE_DISCRETE) {                   
  23.                 if ((fsize.discrete.width == 320) && (fsize.discrete.height == 240)) {  
  24.                     if (strcmp(cameraCallProcess,"com.tencent.android.pad") == 0) {  
  25.                         fsize.index++;  
  26.                         continue;  
  27.                     }  
  28.                 }  
  29.                 memset(cam_size,0x00,sizeof(cam_size));  
  30.                 if (parameterString.size() != 0)   
  31.                     cam_size[0]=‘,‘;  
  32.                 sprintf((char*)(&cam_size[strlen(cam_size)]),"%d",fsize.discrete.width);  
  33.                 strcat(cam_size, "x");  
  34.                 sprintf((char*)(&cam_size[strlen(cam_size)]),"%d",fsize.discrete.height);  
  35.                 parameterString.append((const char*)cam_size);  
  36.   
  37.                 if ((strlen(str_picturesize)+strlen(cam_size))<sizeof(str_picturesize)) {  
  38.                     if (fsize.discrete.width <= 2592) {  
  39.                         strcat(str_picturesize, cam_size);  
  40.                         if (fsize.discrete.width > mCamDriverFrmWidthMax) {  
  41.                             mCamDriverFrmWidthMax = fsize.discrete.width;  
  42.                             mCamDriverFrmHeightMax = fsize.discrete.height;  
  43.                         }   
  44.                     }  
  45.                 } else {  
  46.                     break;  
  47.                 }  
  48.             } else if (fsize.type == V4L2_FRMSIZE_TYPE_CONTINUOUS) {  
  49.   
  50.                 break;  
  51.             } else if (fsize.type == V4L2_FRMSIZE_TYPE_STEPWISE) {  
  52.                   
  53.                 break;  
  54.             }  
  55.             fsize.index++;  
  56.         }  
  57.         if (ret != 0 && errno != EINVAL) {  
  58.             LOGE("ERROR enumerating frame sizes: %d\n", errno);  
  59.         }  
  60.   
  61.         params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES, parameterString.string());  
  62.         params.setPreviewSize(640,480);  
  63.         /*picture size setting*/        
  64.         params.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES, str_picturesize);          
  65.         params.setPictureSize(mCamDriverFrmWidthMax,  mCamDriverFrmHeightMax);          
  66.   
  67.         if (mCamDriverFrmWidthMax <= 1024) {  
  68.             mRawBufferSize = RAW_BUFFER_SIZE_1M;  
  69.             mJpegBufferSize = JPEG_BUFFER_SIZE_1M;  
  70.         } else if (mCamDriverFrmWidthMax <= 1600) {  
  71.             mRawBufferSize = RAW_BUFFER_SIZE_2M;  
  72.             mJpegBufferSize = JPEG_BUFFER_SIZE_2M;  
  73.         } else if (mCamDriverFrmWidthMax <= 2048) {  
  74.             mRawBufferSize = RAW_BUFFER_SIZE_3M;  
  75.             mJpegBufferSize = JPEG_BUFFER_SIZE_3M;  
  76.         } else if (mCamDriverFrmWidthMax <= 2592) {                                
  77.             mRawBufferSize = RAW_BUFFER_SIZE_5M;  
  78.             mJpegBufferSize = JPEG_BUFFER_SIZE_5M;  
  79.         } else {  
  80.             LOGE("%s(%d):Camera Hal is only support 5Mega camera, but the uvc camera is %dx%d",  
  81.                  __FUNCTION__,__LINE__,mCamDriverFrmWidthMax, mCamDriverFrmHeightMax);  
  82.             mRawBufferSize = RAW_BUFFER_SIZE_5M;  
  83.             mJpegBufferSize = JPEG_BUFFER_SIZE_5M;  
  84.         }  
  85.           
  86.         /* set framerate */  
  87.         struct v4l2_streamparm setfps;            
  88.           
  89.         memset(&setfps, 0, sizeof(struct 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);   
  94.   
  95.         /*frame rate setting*/      
  96.         params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES, "15");  
  97.         params.setPreviewFrameRate(15);  
  98.         /*frame per second setting*/  
  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.         /*not support zoom */  
  104.         params.set(CameraParameters::KEY_ZOOM_SUPPORTED, "false");  
  105.   
  106.     } else if (CAMERA_IS_RKSOC_CAMERA()) {  
  107.       
  108.         fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;  
  109.         fmt.fmt.pix.pixelformat= mCamDriverPreviewFmt;  
  110.         fmt.fmt.pix.field = V4L2_FIELD_NONE;  
  111.           
  112.         /*picture size setting*/  
  113.         fmt.fmt.pix.width = 10000;  
  114.         fmt.fmt.pix.height = 10000;  
  115.         ret = ioctl(iCamFd, VIDIOC_TRY_FMT, &fmt);  
  116.           
  117.         mCamDriverFrmWidthMax = fmt.fmt.pix.width;  
  118.         mCamDriverFrmHeightMax = fmt.fmt.pix.height;          
  119.   
  120.         if (mCamDriverFrmWidthMax > 2592) {  
  121.             LOGE("Camera driver support maximum resolution(%dx%d) is overflow 5Mega!",mCamDriverFrmWidthMax,mCamDriverFrmHeightMax);  
  122.             mCamDriverFrmWidthMax = 2592;  
  123.             mCamDriverFrmHeightMax = 1944;  
  124.         }  
  125.           
  126.         /*preview size setting*/   
  127.         if (mCamDriverFrmWidthMax >= 176) {              
  128.             fmt.fmt.pix.width = 176;  
  129.             fmt.fmt.pix.height = 144;  
  130.             if (ioctl(iCamFd, VIDIOC_TRY_FMT, &fmt) == 0) {  
  131.                 if ((fmt.fmt.pix.width == 176) && (fmt.fmt.pix.height == 144)) {  
  132.                     parameterString.append("176x144");  
  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,"176x144");  
  136.                 }  
  137.             }  
  138.         }  
  139.   
  140.         if ((mCamDriverCapability.version & 0xff) >= 0x07) {  
  141.             int tmp0,tmp1;  
  142.             if (cameraFramerateQuery(mCamDriverPreviewFmt, 240,160,&tmp1,&tmp0) == 0) {  
  143.                 if (mCamDriverFrmWidthMax >= 240) {              
  144.                     fmt.fmt.pix.width = 240;  
  145.                     fmt.fmt.pix.height = 160;  
  146.                     if (ioctl(iCamFd, VIDIOC_TRY_FMT, &fmt) == 0) {  
  147.                         if ((fmt.fmt.pix.width == 240) && (fmt.fmt.pix.height == 160)) {  
  148.                             parameterString.append(",240x160");  
  149.                             params.setPreviewSize(240, 160);  
  150.                             previewFrameSizeMax =  PAGE_ALIGN(240*160*2)*2;          // 240*160*2     rgb565  
  151.                               
  152.                         }  
  153.                     }  
  154.                 }  
  155.             }  
  156.         }  
  157.           
  158.         if (strcmp(cameraCallProcess,"com.tencent.android.pad")) {  
  159.             if (mCamDriverFrmWidthMax >= 320) {              
  160.                 fmt.fmt.pix.width = 320;  
  161.                 fmt.fmt.pix.height = 240;  
  162.                 if (ioctl(iCamFd, VIDIOC_TRY_FMT, &fmt) == 0) {  
  163.                     if ((fmt.fmt.pix.width == 320) && (fmt.fmt.pix.height == 240)) {  
  164.                         parameterString.append(",320x240");  
  165.                         params.setPreviewSize(320, 240);  
  166.                         previewFrameSizeMax =  PAGE_ALIGN(320*240*2)*2;          // 320*240*2  
  167.                           
  168.                     }  
  169.                 }  
  170.             }  
  171.         }  
  172.         if (mCamDriverFrmWidthMax >= 352) {              
  173.             fmt.fmt.pix.width = 352;  
  174.             fmt.fmt.pix.height = 288;  
  175.             if (ioctl(iCamFd, VIDIOC_TRY_FMT, &fmt) == 0) {  
  176.                 if ((fmt.fmt.pix.width == 352) && (fmt.fmt.pix.height == 288)) {  
  177.                     parameterString.append(",352x288");  
  178.                     params.setPreviewSize(352, 288);  
  179.                     previewFrameSizeMax =  PAGE_ALIGN(352*288*2)*2;          // 352*288*1.5*2  
  180.                       
  181.                 }  
  182.             }  
  183.         }  
  184.           
  185.         if (mCamDriverFrmWidthMax >= 640) {              
  186.             fmt.fmt.pix.width = 640;  
  187.             fmt.fmt.pix.height = 480;  
  188.             if (ioctl(iCamFd, VIDIOC_TRY_FMT, &fmt) == 0) {  
  189.                 if ((fmt.fmt.pix.width == 640) && (fmt.fmt.pix.height == 480)) {  
  190.                     parameterString.append(",640x480");  
  191.                     params.setPreviewSize(640, 480);  
  192.                     previewFrameSizeMax =  PAGE_ALIGN(640*480*2)*2;          // 640*480*1.5*2  
  193.                       
  194.                 }  
  195.             }  
  196.         }  
  197.   
  198.         if (mCamDriverFrmWidthMax >= 720) {  
  199.             fmt.fmt.pix.width = 720;  
  200.             fmt.fmt.pix.height = 480;  
  201.             if (ioctl(iCamFd, VIDIOC_TRY_FMT, &fmt) == 0) {  
  202.                 if ((fmt.fmt.pix.width == 720) && (fmt.fmt.pix.height == 480)) {  
  203.                     parameterString.append(",720x480");  
  204.                     previewFrameSizeMax =  PAGE_ALIGN(720*480*2)*2;          // 720*480*1.5*2  
  205.                       
  206.                 }  
  207.             }  
  208.         }  
  209.   
  210.         if (mCamDriverFrmWidthMax >= 1280) {  
  211.             fmt.fmt.pix.width = 1280;  
  212.             fmt.fmt.pix.height = 720;  
  213.             if (ioctl(iCamFd, VIDIOC_TRY_FMT, &fmt) == 0) {  
  214.                 if ((fmt.fmt.pix.width == 1280) && (fmt.fmt.pix.height == 720)) {  
  215.                     parameterString.append(",1280x720");  
  216.                     previewFrameSizeMax =  PAGE_ALIGN(1280*720*2)*2;          // 1280*720*1.5*2  
  217.                       
  218.                 }  
  219.             }  
  220.         }  
  221.         mSupportPreviewSizeReally = parameterString;  
  222.         /* ddl@rock-chips.com: Facelock speed is low, so scale down preview data to facelock for speed up */  
  223.         if ((strcmp(cameraCallProcess,"com.android.facelock")==0)) {              
  224.             if (strstr(mSupportPreviewSizeReally.string(),"640x480")||  
  225.                 strstr(mSupportPreviewSizeReally.string(),"320x240")) {  
  226.                 parameterString = "160x120";  
  227.                 params.setPreviewSize(160, 120);      
  228.             }  
  229.         }  
  230.         params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES, parameterString.string());  
  231.           
  232.         strcat(str_picturesize,parameterString.string());  
  233.         strcat(str_picturesize,",");  
  234.         if(mCamDriverFrmWidthMax <= 640){  
  235.             strcat( str_picturesize,"640x480,320x240");  
  236.             mRawBufferSize = RAW_BUFFER_SIZE_0M3;  
  237.             mJpegBufferSize = JPEG_BUFFER_SIZE_0M3;  
  238.             params.setPictureSize(640,480);  
  239.         }else if (mCamDriverFrmWidthMax <= 1280) {  
  240.             strcat( str_picturesize,"1024x768,640x480,320x240");  
  241.             mRawBufferSize = RAW_BUFFER_SIZE_1M;  
  242.             mJpegBufferSize = JPEG_BUFFER_SIZE_1M;  
  243.             params.setPictureSize(1024,768);  
  244.         } else if (mCamDriverFrmWidthMax <= 1600) {  
  245.             strcat( str_picturesize,"1600x1200,1024x768,640x480");  
  246.             mRawBufferSize = RAW_BUFFER_SIZE_2M;  
  247.             mJpegBufferSize = JPEG_BUFFER_SIZE_2M;  
  248.             params.setPictureSize(1600,1200);  
  249.         } else if (mCamDriverFrmWidthMax <= 2048) {  
  250.             strcat( str_picturesize,"2048x1536,1600x1200,1024x768");  
  251.             mRawBufferSize = RAW_BUFFER_SIZE_3M;  
  252.             mJpegBufferSize = JPEG_BUFFER_SIZE_3M;    
  253.             params.setPictureSize(2048,1536);  
  254.         } else if (mCamDriverFrmWidthMax <= 2592) {                                
  255.             strcat( str_picturesize,"2592x1944,2048x1536,1600x1200,1024x768");  
  256.             params.setPictureSize(2592,1944);  
  257.             mRawBufferSize = RAW_BUFFER_SIZE_5M;  
  258.             mJpegBufferSize = JPEG_BUFFER_SIZE_5M;  
  259.         } else {  
  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.         }  
  265.           
  266.         params.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES, str_picturesize);  
  267.   
  268.         /*frame rate setting*/  
  269.         cameraFpsInfoSet(params);  
  270.           
  271.         /*zoom setting*/  
  272.         struct v4l2_queryctrl zoom;  
  273.         char str_zoom_max[3],str_zoom_element[5];  
  274.         char str_zoom[200];  
  275.         strcpy(str_zoom, "");//default zoom  
  276.         int max;  
  277.   
  278.         zoom.id = V4L2_CID_ZOOM_ABSOLUTE;  
  279.         if (!ioctl(iCamFd, VIDIOC_QUERYCTRL, &zoom)) {  
  280.             mZoomMax = zoom.maximum;  
  281.             mZoomMin= zoom.minimum;  
  282.             mZoomStep = zoom.step;    
  283.   
  284.             max = (mZoomMax - mZoomMin)/mZoomStep;  
  285.             sprintf(str_zoom_max,"%d",max);  
  286.             params.set(CameraParameters::KEY_ZOOM_SUPPORTED, "true");  
  287.             params.set(CameraParameters::KEY_MAX_ZOOM, str_zoom_max);  
  288.             params.set(CameraParameters::KEY_ZOOM, "0");  
  289.             for (i=mZoomMin; i<=mZoomMax; i+=mZoomStep) {  
  290.                 sprintf(str_zoom_element,"%d,", i);  
  291.                 strcat(str_zoom,str_zoom_element);  
  292.             }  
  293.             params.set(CameraParameters::KEY_ZOOM_RATIOS, str_zoom);  
  294.         }  
  295.     }  
  296.     /*preview format setting*/  
  297.     params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS, "yuv420sp,rgb565,yuv420p");  
  298.     params.set(CameraParameters::KEY_VIDEO_FRAME_FORMAT,CameraParameters::PIXEL_FORMAT_YUV420SP);  
  299.     if (strcmp(cameraCallProcess,"com.android.camera")==0) {    //for PanoramaActivity  
  300.         params.setPreviewFormat(CameraParameters::PIXEL_FORMAT_RGB565);     
  301.     } else {  
  302.         params.setPreviewFormat(CameraParameters::PIXEL_FORMAT_YUV420SP);     
  303.     }  
  304.     /* zyc@rock-chips.com: preset the displayformat for cts */  
  305.     strcpy(mDisplayFormat,CAMERA_DISPLAY_FORMAT_NV12);  
  306.   
  307.   
  308.     params.set(CameraParameters::KEY_VIDEO_FRAME_FORMAT,CameraParameters::PIXEL_FORMAT_YUV420SP);  
  309.   
  310.     /*picture format setting*/  
  311.     params.set(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS, CameraParameters::PIXEL_FORMAT_JPEG);  
  312.     params.setPictureFormat(CameraParameters::PIXEL_FORMAT_JPEG);  
  313.   
  314.     /*jpeg quality setting*/  
  315.     params.set(CameraParameters::KEY_JPEG_QUALITY, "70");  
  316.   
  317.     /*white balance setting*/  
  318.     struct v4l2_queryctrl whiteBalance;  
  319.     struct v4l2_querymenu *whiteBalance_menu = mWhiteBalance_menu;  
  320.     char str_whitebalance[200];  
  321.     strcpy(str_whitebalance, "");//default whitebalance  
  322.     whiteBalance.id = V4L2_CID_DO_WHITE_BALANCE;  
  323.     if (!ioctl(iCamFd, VIDIOC_QUERYCTRL, &whiteBalance)) {  
  324.         for (i = whiteBalance.minimum; i <= whiteBalance.maximum; i += whiteBalance.step) {  
  325.             whiteBalance_menu->id = V4L2_CID_DO_WHITE_BALANCE;  
  326.             whiteBalance_menu->index = i;  
  327.             if (!ioctl(iCamFd, VIDIOC_QUERYMENU, whiteBalance_menu)) {  
  328.                 if (i != whiteBalance.minimum)  
  329.                     strcat(str_whitebalance, ",");  
  330.                 strcat(str_whitebalance, (char *)whiteBalance_menu->name);  
  331.                 if (whiteBalance.default_value == i) {  
  332.                     strcpy(cur_param, (char *)whiteBalance_menu->name);  
  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.     }  
  341.   
  342.     /*color effect setting*/  
  343.     struct v4l2_queryctrl effect;  
  344.     struct v4l2_querymenu *effect_menu = mEffect_menu;  
  345.     char str_effect[200];  
  346.     strcpy(str_effect, "");//default effect  
  347.     effect.id = V4L2_CID_EFFECT;  
  348.     if (!ioctl(iCamFd, VIDIOC_QUERYCTRL, &effect)) {  
  349.         for (i = effect.minimum; i <= effect.maximum; i += effect.step) {  
  350.             effect_menu->id = V4L2_CID_EFFECT;  
  351.             effect_menu->index = i;  
  352.             if (!ioctl(iCamFd, VIDIOC_QUERYMENU, effect_menu)) {  
  353.                 if (i != effect.minimum)  
  354.                     strcat(str_effect, ",");  
  355.                 strcat(str_effect, (char *)effect_menu->name);  
  356.                 if (effect.default_value == i) {  
  357.                     strcpy(cur_param, (char *)effect_menu->name);  
  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.     }  
  366.   
  367.     /*scene setting*/  
  368.     struct v4l2_queryctrl scene;  
  369.     struct v4l2_querymenu *scene_menu = mScene_menu;  
  370.     char str_scene[200];  
  371.     strcpy(str_scene, "");//default scene  
  372.     scene.id = V4L2_CID_SCENE;  
  373.     if (!ioctl(iCamFd, VIDIOC_QUERYCTRL, &scene)) {  
  374.         for (i=scene.minimum; i<=scene.maximum; i+=scene.step) {  
  375.             scene_menu->id = V4L2_CID_SCENE;  
  376.             scene_menu->index = i;  
  377.             if (!ioctl(iCamFd, VIDIOC_QUERYMENU, scene_menu)) {  
  378.                 if (i != scene.minimum)  
  379.                     strcat(str_scene, ",");  
  380.                 strcat(str_scene, (char *)scene_menu->name);  
  381.                 if (scene.default_value == i) {  
  382.                     strcpy(cur_param, (char *)scene_menu->name);  
  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);  
  390.   
  391.     }  
  392.   
  393.     /*flash mode setting*/  
  394.     struct v4l2_queryctrl flashMode;  
  395.     struct v4l2_querymenu *flashMode_menu = mFlashMode_menu;  
  396.     char str_flash[200];  
  397.     strcpy(str_flash, "");//default flash  
  398.     flashMode.id = V4L2_CID_FLASH;  
  399.     if (!ioctl(iCamFd, VIDIOC_QUERYCTRL, &flashMode)) {  
  400.         for (i = flashMode.minimum; i <= flashMode.maximum; i += flashMode.step) {  
  401.             flashMode_menu->id = V4L2_CID_FLASH;  
  402.             flashMode_menu->index = i;  
  403.             if (!ioctl(iCamFd, VIDIOC_QUERYMENU, flashMode_menu)) {  
  404.                 if (i != flashMode.minimum)  
  405.                     strcat(str_flash, ",");  
  406.                 strcat(str_flash, (char *)flashMode_menu->name);  
  407.                 if (flashMode.default_value == i) {  
  408.                     strcpy(cur_param, (char *)flashMode_menu->name);  
  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.     }  
  417.       
  418.     /*focus mode setting*/  
  419.     struct v4l2_queryctrl focus;  
  420.   
  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.     if (!ioctl(iCamFd, VIDIOC_QUERYCTRL, &focus)) {  
  425.         parameterString.append(",");  
  426.         parameterString.append(CameraParameters::FOCUS_MODE_AUTO);  
  427.         params.set(CameraParameters::KEY_FOCUS_MODE, CameraParameters::FOCUS_MODE_AUTO);  
  428.     }  
  429.   
  430.     focus.id = V4L2_CID_FOCUS_CONTINUOUS;  
  431.     if (!ioctl(iCamFd, VIDIOC_QUERYCTRL, &focus)) {  
  432.         parameterString.append(",");  
  433.         parameterString.append(CameraParameters::FOCUS_MODE_EDOF);  
  434.     }  
  435.   
  436.     focus.id = V4L2_CID_FOCUS_ABSOLUTE;  
  437.     if (!ioctl(iCamFd, VIDIOC_QUERYCTRL, &focus)) {  
  438.         parameterString.append(",");  
  439.         parameterString.append(CameraParameters::FOCUS_MODE_INFINITY);  
  440.         parameterString.append(",");  
  441.         parameterString.append(CameraParameters::FOCUS_MODE_MACRO);  
  442.     }  
  443.   
  444.     params.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES, parameterString.string());  
  445.   
  446.     /*mirror and flip query*/  
  447.     struct v4l2_queryctrl mirror,flip;  
  448.       
  449.     mirror.id = V4L2_CID_HFLIP;  
  450.     if (!ioctl(iCamFd, VIDIOC_QUERYCTRL, &mirror)) {  
  451.         mDriverMirrorSupport = true;  
  452.     } else {  
  453.         mDriverMirrorSupport = false;  
  454.     }  
  455.   
  456.     flip.id = V4L2_CID_VFLIP;  
  457.     if (!ioctl(iCamFd, VIDIOC_QUERYCTRL, &flip)) {  
  458.         mDriverFlipSupport = true;  
  459.     } else {  
  460.         mDriverFlipSupport = false;  
  461.     }  
  462.   
  463.   
  464.     /*Exposure setting*/  
  465.     struct v4l2_queryctrl exposure;  
  466.     char str_exposure[16];  
  467.     exposure.id = V4L2_CID_EXPOSURE;  
  468.     if (!ioctl(iCamFd, VIDIOC_QUERYCTRL, &exposure)) {  
  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.     } else {  
  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.     /*rotation setting*/  
  484.     params.set(CameraParameters::KEY_ROTATION, "0");  
  485.   
  486.     /*lzg@rockchip.com :add some settings to pass cts*/      
  487.     /*focus distance setting ,no much meaning ,only for passing cts */  
  488.     parameterString = "0.3,50,Infinity";  
  489.     params.set(CameraParameters::KEY_FOCUS_DISTANCES, parameterString.string());  
  490.     /*focus length setting ,no much meaning ,only for passing cts */  
  491.     parameterString = "35";  
  492.     params.set(CameraParameters::KEY_FOCAL_LENGTH, parameterString.string());  
  493.    /*horizontal angle of view setting ,no much meaning ,only for passing cts */  
  494.     parameterString = "100";  
  495.     params.set(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, parameterString.string());  
  496.     /*vertical angle of view setting ,no much meaning ,only for passing cts */  
  497.     parameterString = "100";  
  498.     params.set(CameraParameters::KEY_VERTICAL_VIEW_ANGLE, parameterString.string());  
  499.   
  500.    /*quality of the EXIF thumbnail in Jpeg picture setting */  
  501.     parameterString = "50";  
  502.     params.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, parameterString.string());  
  503.    /*supported size of the EXIF thumbnail in Jpeg picture setting */  
  504.     parameterString = "0x0,160x128";  
  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: for cts ,KEY_MAX_NUM_DETECTED_FACES_HW should not be 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,"false");  
  514.     params.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED,"false");  
  515.     params.set(CameraParameters::KEY_VIDEO_SNAPSHOT_SUPPORTED,"true");  
  516.     params.set(CameraParameters::KEY_MAX_NUM_METERING_AREAS,"0");  
  517.   
  518.     LOGD ("Support Preview format: %s ",params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS));  
  519.     LOGD ("Support Preview sizes: %s ",params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES));  
  520.     LOGD ("Support Preview FPS range: %s",params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE));  
  521.     LOGD ("Support Preview framerate: %s",params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES));   
  522.     LOGD ("Support Picture sizes: %s ",params.get(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES));  
  523.     if (params.get(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE))  
  524.         LOGD ("Support white balance: %s",params.get(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE));  
  525.     if (params.get(CameraParameters::KEY_SUPPORTED_EFFECTS))  
  526.         LOGD ("Support color effect: %s",params.get(CameraParameters::KEY_SUPPORTED_EFFECTS));  
  527.     if (params.get(CameraParameters::KEY_SUPPORTED_SCENE_MODES))  
  528.         LOGD ("Support scene: %s",params.get(CameraParameters::KEY_SUPPORTED_SCENE_MODES));  
  529.     if (params.get(CameraParameters::KEY_SUPPORTED_FLASH_MODES))  
  530.         LOGD ("Support flash: %s",params.get(CameraParameters::KEY_SUPPORTED_FLASH_MODES));  
  531.     LOGD ("Support focus: %s",params.get(CameraParameters::KEY_SUPPORTED_FOCUS_MODES));  
  532.     LOGD ("Support zoom: %s(ratios: %s)",params.get(CameraParameters::KEY_ZOOM_SUPPORTED),  
  533.         params.get(CameraParameters::KEY_ZOOM_RATIOS));  
  534.     if (strcmp("0", params.get(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION))  
  535.         || strcmp("0", params.get(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION))) {  
  536.         LOGD ("Support exposure: (%s -> %s)",params.get(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION),  
  537.             params.get(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION));  
  538.     }  
  539.     LOGD ("Support hardware faces detecte: %s",params.get(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW));  
  540.     LOGD ("Support software faces detecte: %s",params.get(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_SW));  
  541.     LOGD ("Support video stabilization: %s",params.get(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED));  
  542.     LOGD ("Support recording hint: %s",params.get(CameraParameters::KEY_RECORDING_HINT));  
  543.     LOGD ("Support video snapshot: %s",params.get(CameraParameters::KEY_VIDEO_SNAPSHOT_SUPPORTED));  
  544.     LOGD ("Support Mirror and Filp: %s",(mDriverMirrorSupport && mDriverFlipSupport)? "true":"false");  
  545.   
  546.     cameraConfig(params);  
  547.     LOG_FUNCTION_NAME_EXIT  
  548.   
  549. }  

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

[cpp] view plaincopy
  1. int CameraHal::startPreview()  
  2. {  
  3.     LOG_FUNCTION_NAME  
  4.     Message msg;      
  5.     Mutex::Autolock lock(mLock);  
  6.       
  7.     if ((mPreviewThread != NULL) && (mCommandThread != NULL)) {  
  8.         msg.command = CMD_PREVIEW_START;  
  9.         msg.arg1 = (void*)CMDARG_NACK;  
  10.         commandThreadCommandQ.put(&msg);  
  11.     }  
  12.     mPreviewCmdReceived = true;  
  13.     LOG_FUNCTION_NAME_EXIT  
  14.     return NO_ERROR ;  
  15. }  
  16.   
  17. void CameraHal::stopPreview()  
  18. {  
  19.     LOG_FUNCTION_NAME      
  20.     Message msg;  
  21.     int ret = 0;  
  22.     Mutex::Autolock lock(mLock);  
  23.   
  24.     if ((mPreviewThread != NULL) && (mCommandThread != NULL)) {  
  25.         msg.command = CMD_PREVIEW_STOP;  
  26.         msg.arg1 = (void*)CMDARG_ACK;  
  27.         commandThreadCommandQ.put(&msg);  
  28.   
  29.         if (mANativeWindow == NULL) {  
  30.             mANativeWindowCond.signal();  
  31.             LOGD("%s(%d): wake up command thread for stop preview",__FUNCTION__,__LINE__);  
  32.         }  
  33.           
  34.         while (ret == 0) {              
  35.             ret = commandThreadAckQ.get(&msg);  
  36.             if (ret == 0) {  
  37.                 if (msg.command == CMD_PREVIEW_STOP) {                      
  38.                     ret = 1;  
  39.                 }  
  40.             }  
  41.         }  
  42.     } else {  
  43.         LOGE("%s(%d): cancel, because thread (%s %s) is NULL", __FUNCTION__,__LINE__,(mPreviewThread == NULL)?"mPreviewThread":" ",  
  44.             (mCommandThread == NULL)?"mCommandThread":" ");  
  45.     }  
  46.     mPreviewCmdReceived = false;  
  47.     LOG_FUNCTION_NAME_EXIT  
  48. }  
  49.   
  50. int CameraHal::autoFocus()  
  51. {  
  52.     LOG_FUNCTION_NAME  
  53.     int ret = 0;  
  54.     Message msg;  
  55.     Mutex::Autolock lock(mLock);  
  56.   
  57.     if ((mPreviewThread != NULL) && (mCommandThread != NULL)) {  
  58.         msg.command = CMD_AF_START;  
  59.         msg.arg1 = (void*)CMDARG_ACK;  
  60.         commandThreadCommandQ.put(&msg);  
  61.         while (ret == 0) {              
  62.             ret = commandThreadAckQ.get(&msg,5000);  
  63.             if (ret == 0) {  
  64.                 if (msg.command == CMD_AF_START) {                      
  65.                     ret = 1;  
  66.                 }  
  67.             } else {  
  68.                 LOGE("%s(%d): AutoFocus is time out!!!\n",__FUNCTION__,__LINE__);  
  69.             }  
  70.         }  
  71.     } else {  
  72.         LOGE("%s(%d):  cancel, because thread (%s %s) is NULL", __FUNCTION__,__LINE__,(mPreviewThread == NULL)?"mPreviewThread":" ",  
  73.             (mCommandThread == NULL)?"mCommandThread":" ");  
  74.     }  
  75.     LOG_FUNCTION_NAME_EXIT  
  76.     return NO_ERROR;  
  77. }  

 

[cpp] view plaincopy
    1. <pre name=< span="">"code" class="cpp"><pre name=< span="">"code" class="cpp"><pre name=< span="">"code" class="cpp">

Android Camera HAL浅析

标签：

原文地址：http://www.cnblogs.com/senior-engineer/p/4935506.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！