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

Android Camera 通过V4L2与kernel driver的完整交互过程

时间：2017-06-08 13:14:58      阅读：462      评论：0      收藏：0      [点我收藏+]

标签：protect   source   public   parameter   nts   word   mac   memset   详细   

http://blog.chinaunix.net/uid-26215986-id-3552456.html

原文地址：Android Camera 通过V4L2与kernel driver的完整交互过程 作者：xinyuwuxian

 

Android Camera 通过V4L2与kernel driver的完整交互过程

之前在 Android Camera 的执行流程 http://blog.chinaunix.net/uid-26765074-id-3499537.html 这篇文章中已经详细介绍了
Android Camera app到调用open打开camera 设备的完成过程，但是只是到此为止，并未对较底层的操作控制等做任何分析，
今天就要进入这个环节了
技术分享技术分享
这里就直接从open那个方法开始了，先说一下这个open是怎么被调用的

实例化Camera Hal接口 hardware，hardware调用initialize()进入HAL层打开Camear驱动。
CameraHardwareInterface中initialize()定义在以下路径:frameworks/base/services/camera/libcameraservice/CameraHardwareInterface.h

代码如下：

    status_t initialize(hw_module_t *module)
    {
        LOGI("Opening camera %s", mName.string());
        int rc = module->methods->open(module, mName.string(),(hw_device_t **)&mDevice);
        if (rc != OK) {
            LOGE("Could not open camera %s: %d", mName.string(), rc);
            return rc;
        }
#ifdef OMAP_ENHANCEMENT_CPCAM
        initHalPreviewWindow(&mHalPreviewWindow);
        initHalPreviewWindow(&mHalTapin);
        initHalPreviewWindow(&mHalTapout);
#else
        initHalPreviewWindow();
#endif
        return rc;
    }
此处通过module->method->open()方法真正打开Camera设备,

其中module的定义在以下路径:frameworks/base/services/camera/libcameraservice/CameraService.h

class CameraService :
    public BinderService<CameraService>,
    public BnCameraService
{

    class Client : public BnCamera
    {
    public:
        ......

    private:

        .....

    };

    camera_module_t *mModule;

};

此处还必须找到camera_module_t 的定义,以更好的理解整个运行流程,通过追根溯源找到了camera_module_t 定义,

camera_module_t的定义在以下路径:hardware/libhardware/include/hardware/camera.h

typedef struct camera_module {
    hw_module_t common;
    int (*get_number_of_cameras)(void);
    int (*get_camera_info)(int camera_id, struct camera_info *info);
} camera_module_t;
其中包含get_number_of_cameras方法和get_camera_info方法用于获取camera info

另外hw_module_t common;这个选项十分重要,此处应重点关注,因为是使用hw_module_t结构体中的open()方法打开设备文件的

继续找到hw_module_t 结构体的定义.在以下路径:hardware/libhardware/include/hardware/hardware.h

 

  1. typedef struct hw_module_t {
  2.     /** tag must be initialized to HARDWARE_MODULE_TAG */
  3.     uint32_t tag;
  5.     /** major version number for the module */
  6.     uint16_t version_major;
  8.     /** minor version number of the module */
  9.     uint16_t version_minor;
  11.     /** Identifier of module */
  12.     const char *id;
  14.     /** Name of this module */
  15.     const char *name;
  17.     /** Author/owner/implementor of the module */
  18.     const char *author;
  20.     /** Modules methods */
  21.     struct hw_module_methods_t* methods;
  23.     /** module‘s dso */
  24.     void* dso;
  26.     /** padding to 128 bytes, reserved for future use */
  27.     uint32_t reserved[32-7];
  29. } hw_module_t;
  1. typedef struct hw_module_methods_t {
  2.     /** Open a specific device */
  3.     int (*open)(const struct hw_module_t* module, const char* id,
  4.             struct hw_device_t** device);
  6. } hw_module_methods_t;
这里的这个open方法才是我们真正调用的open方法，那么这里只是定义，他又是在哪里实现的呢？？
这个问题我们还是需要往前面追溯啊，当然这在上一篇文章中也没有提到，不卖关子了，其实重点就是我们调用了这个module->methods->open(module, mName.string(),(hw_device_t **)&mDevice)方法
但是这个module是在哪里初始化的呢？看看CameraService类里的这个方法吧，路径：frameworks/base/services/camera/libcameraservice/CameraService.cpp
  1. void CameraService::onFirstRef()
  2. {
  3.     BnCameraService::onFirstRef();
  5.     if (hw_get_module(CAMERA_HARDWARE_MODULE_ID,
  6.                 (const hw_module_t **)&mModule) < 0) {
  7.         LOGE("Could not load camera HAL module");
  8.         mNumberOfCameras = 0;
  9.     }
  10.     else {
  11.         mNumberOfCameras = mModule->get_number_of_cameras();
  12.         if (mNumberOfCameras > MAX_CAMERAS) {
  13.             LOGE("Number of cameras(%d) > MAX_CAMERAS(%d).",
  14.                     mNumberOfCameras, MAX_CAMERAS);
  15.             mNumberOfCameras = MAX_CAMERAS;
  16.         }
  17.         for (int i = 0; i < mNumberOfCameras; i++) {
  18.             setCameraFree(i);
  19.         }
  20.     }
  21. }
不错，这个module正是通过这个hw_get_module方法获得的，其实他是通过方法中的CAMERA_HARDWARE_MODULE_ID作为flag最终找到已经定义好的module，那么这个已经定义好的module又在哪呢，是什么样子的呢？
这里我就直接放在这里，不在拐弯抹角了，方法路径：hardware/ti/omap4xxx/camera/CameraHal_Module.cpp
  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);
  7. static struct hw_module_methods_t camera_module_methods = {
  8.         open: camera_device_open
  9. };
  11. camera_module_t HAL_MODULE_INFO_SYM = {
  12.     common: {
  13.          tag: HARDWARE_MODULE_TAG,
  14.          version_major: 1,
  15.          version_minor: 0,
  16.          id: CAMERA_HARDWARE_MODULE_ID,
  17.          name: "TI OMAP CameraHal Module",
  18.          author: "TI",
  19.          methods: &camera_module_methods,
  20.          dso: NULL, /* remove compilation warnings */
  21.          reserved: {0}, /* remove compilation warnings */
  22.     },
  23.     get_number_of_cameras: camera_get_number_of_cameras,
  24.     get_camera_info: camera_get_camera_info,
  25. };
这里还是很关键的，通过id：CAMERA_HARDWARE_MODULE_ID作为识别码找到这个module，get module完成任务，大家可以看到，这个定义好的module实现了methods中的open方法，
实现了camera_get_number_of_cameras和camera_get_camera_info，当然还包括了其他一些变量的初始化
这里开始我们找到了我们真正需要的open方法，万里长征走完一大步了，现在就去看看这个open方法干了些什么吧
  1. /* open device handle to one of the cameras
  2.  *
  3.  * assume camera service will keep singleton of each camera
  4.  * so this function will always only be called once per camera instance
  5.  */
  7. int camera_device_open(const hw_module_t* module, const char* name,
  8.                 hw_device_t** device)
  9. {
  10.     int rv = 0;
  11.     int num_cameras = 0;
  12.     int cameraid;
  13.     ti_camera_device_t* camera_device = NULL;
  14.     camera_device_ops_t* camera_ops = NULL;
  15.     android::CameraHal* camera = NULL;
  16.     android::CameraProperties::Properties* properties = NULL;
  18.     android::Mutex::Autolock lock(gCameraHalDeviceLock);
  20.     CAMHAL_LOGI("camera_device open");
  22.     if (name != NULL) {
  23.         cameraid = atoi(name);
  24.         num_cameras = gCameraProperties.camerasSupported();
  26.         if(cameraid > num_cameras)
  27.         {
  28.             LOGE("camera service provided cameraid out of bounds, "
  29.                     "cameraid = %d, num supported = %d",
  30.                     cameraid, num_cameras);
  31.             rv = -EINVAL;
  32.             goto fail;
  33.         }
  35.         if(gCamerasOpen >= MAX_SIMUL_CAMERAS_SUPPORTED)
  36.         {
  37.             LOGE("maximum number of cameras already open");
  38.             rv = -ENOMEM;
  39.             goto fail;
  40.         }
  42.         camera_device = (ti_camera_device_t*)malloc(sizeof(*camera_device));
  43.         if(!camera_device)
  44.         {
  45.             LOGE("camera_device allocation fail");
  46.             rv = -ENOMEM;
  47.             goto fail;
  48.         }
  50.         camera_ops = (camera_device_ops_t*)malloc(sizeof(*camera_ops));
  51.         if(!camera_ops)
  52.         {
  53.             LOGE("camera_ops allocation fail");
  54.             rv = -ENOMEM;
  55.             goto fail;
  56.         }
  58.         memset(camera_device, 0, sizeof(*camera_device));
  59.         memset(camera_ops, 0, sizeof(*camera_ops));
  61.         camera_device->base.common.tag = HARDWARE_DEVICE_TAG;
  62.         camera_device->base.common.version = 0;
  63.         camera_device->base.common.module = (hw_module_t *)(module);
  64.         camera_device->base.common.close = camera_device_close;
  65.         camera_device->base.ops = camera_ops;
  67.         camera_ops->set_preview_window = camera_set_preview_window;
  68. #ifdef OMAP_ENHANCEMENT_CPCAM
  69.         camera_ops->set_buffer_source = camera_set_buffer_source;
  70. #endif
  71.         camera_ops->set_callbacks = camera_set_callbacks;
  72.         camera_ops->enable_msg_type = camera_enable_msg_type;
  73.         camera_ops->disable_msg_type = camera_disable_msg_type;
  74.         camera_ops->msg_type_enabled = camera_msg_type_enabled;
  75.         camera_ops->start_preview = camera_start_preview;
  76.         camera_ops->stop_preview = camera_stop_preview;
  77.         camera_ops->preview_enabled = camera_preview_enabled;
  78.         camera_ops->store_meta_data_in_buffers = camera_store_meta_data_in_buffers;
  79.         camera_ops->start_recording = camera_start_recording;
  80.         camera_ops->stop_recording = camera_stop_recording;
  81.         camera_ops->recording_enabled = camera_recording_enabled;
  82.         camera_ops->release_recording_frame = camera_release_recording_frame;
  83.         camera_ops->auto_focus = camera_auto_focus;
  84.         camera_ops->cancel_auto_focus = camera_cancel_auto_focus;
  85.         camera_ops->take_picture = camera_take_picture;
  86.         camera_ops->cancel_picture = camera_cancel_picture;
  87.         camera_ops->set_parameters = camera_set_parameters;
  88.         camera_ops->get_parameters = camera_get_parameters;
  89.         camera_ops->put_parameters = camera_put_parameters;
  90.         camera_ops->send_command = camera_send_command;
  91.         camera_ops->release = camera_release;
  92.         camera_ops->dump = camera_dump;
  93. #ifdef OMAP_ENHANCEMENT_CPCAM
  94.         camera_ops->reprocess = camera_reprocess;
  95.         camera_ops->cancel_reprocess = camera_cancel_reprocess;
  96. #endif
  98.         *device = &camera_device->base.common;
  100.         // -------- TI specific stuff --------
  102.         camera_device->cameraid = cameraid;
  104.         if(gCameraProperties.getProperties(cameraid, &properties) < 0)
  105.         {
  106.             LOGE("Couldn‘t get camera properties");
  107.             rv = -ENOMEM;
  108.             goto fail;
  109.         }
  111.         camera = new android::CameraHal(cameraid);
  113.         if(!camera)
  114.         {
  115.             LOGE("Couldn‘t create instance of CameraHal class");
  116.             rv = -ENOMEM;
  117.             goto fail;
  118.         }
  120.         if(properties && (camera->initialize(properties) != android::NO_ERROR))
  121.         {
  122.             LOGE("Couldn‘t initialize camera instance");
  123.             rv = -ENODEV;
  124.             goto fail;
  125.         }
  127.         gCameraHals[cameraid] = camera;
  128.         gCamerasOpen++;
  129.     }
  131.     return rv;
  133. fail:
  134.     if(camera_device) {
  135.         free(camera_device);
  136.         camera_device = NULL;
  137.     }
  138.     if(camera_ops) {
  139.         free(camera_ops);
  140.         camera_ops = NULL;
  141.     }
  142.     if(camera) {
  143.         delete camera;
  144.         camera = NULL;
  145.     }
  146.     *device = NULL;
  147.     return rv;
  148. }
看看这么长的代码，open的任务还是比较中的，没办法，能者多劳嘛，红色部分是最重点的部分
从这里可以知道，这里就像一个控制中心，上传调用到这里被分发出去，实现各自的操作，我们就以startPreview为例进行分析

  1. int camera_start_preview(struct camera_device * device)
  2. {
  3.     int rv = -EINVAL;
  4.     ti_camera_device_t* ti_dev = NULL;
  6.     LOGV("%s", __FUNCTION__);
  8.     if(!device)
  9.         return rv;
  11.     ti_dev = (ti_camera_device_t*) device;
  13.     rv = gCameraHals[ti_dev->cameraid]->startPreview();
  15.     return rv;
  16. }
这里每open一个device就会相应的创建并且初始化一个CameraHal 对象，定义在：hardware/ti/omap4xxx/camera/CameraHal.cpp
并且把这个对象保存在gCameraHals这个数组中，正因为这样这里camera_start_preview才可以通过这个数据检索对象调用方法
现在我们就看看这个startPreview()方法是怎样实现的
  1. /**
  2.    @brief Start preview mode.
  4.    @param none
  5.    @return NO_ERROR Camera switched to VF mode
  6.    @todo Update function header with the different errors that are possible
  8.  */
  9. status_t CameraHal::startPreview() {
  10.     LOG_FUNCTION_NAME;
  12.     // When tunneling is enabled during VTC, startPreview happens in 2 steps:
  13.     // When the application sends the command CAMERA_CMD_PREVIEW_INITIALIZATION,
  14.     // cameraPreviewInitialization() is called, which in turn causes the CameraAdapter
  15.     // to move from loaded to idle state. And when the application calls startPreview,
  16.     // the CameraAdapter moves from idle to executing state.
  17.     //
  18.     // If the application calls startPreview() without sending the command
  19.     // CAMERA_CMD_PREVIEW_INITIALIZATION, then the function cameraPreviewInitialization()
  20.     // AND startPreview() are executed. In other words, if the application calls
  21.     // startPreview() without sending the command CAMERA_CMD_PREVIEW_INITIALIZATION,
  22.     // then the CameraAdapter moves from loaded to idle to executing state in one shot.
  23.     status_t ret = cameraPreviewInitialization();
  25.     // The flag mPreviewInitializationDone is set to true at the end of the function
  26.     // cameraPreviewInitialization(). Therefore, if everything goes alright, then the
  27.     // flag will be set. Sometimes, the function cameraPreviewInitialization() may
  28.     // return prematurely if all the resources are not available for starting preview.
  29.     // For example, if the preview window is not set, then it would return NO_ERROR.
  30.     // Under such circumstances, one should return from startPreview as well and should
  31.     // not continue execution. That is why, we check the flag and not the return value.
  32.     if (!mPreviewInitializationDone) return ret;
  34.     // Once startPreview is called, there is no need to continue to remember whether
  35.     // the function cameraPreviewInitialization() was called earlier or not. And so
  36.     // the flag mPreviewInitializationDone is reset here. Plus, this preserves the
  37.     // current behavior of startPreview under the circumstances where the application
  38.     // calls startPreview twice or more.
  39.     mPreviewInitializationDone = false;
  41.     ///Enable the display adapter if present, actual overlay enable happens when we post the buffer
  42.     if(mDisplayAdapter.get() != NULL) {
  43.         CAMHAL_LOGDA("Enabling display");
  44.         int width, height;
  45.         mParameters.getPreviewSize(&width, &height);
  47. #if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
  48.         ret = mDisplayAdapter->enableDisplay(width, height, &mStartPreview);
  49. #else
  50.         ret = mDisplayAdapter->enableDisplay(width, height, NULL);
  51. #endif
  53.         if ( ret != NO_ERROR ) {
  54.             CAMHAL_LOGEA("Couldn‘t enable display");
  56.             // FIXME: At this stage mStateSwitchLock is locked and unlock is supposed to be called
  57.             // only from mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_PREVIEW)
  58.             // below. But this will never happen because of goto error. Thus at next
  59.             // startPreview() call CameraHAL will be deadlocked.
  60.             // Need to revisit mStateSwitch lock, for now just abort the process.
  61.             CAMHAL_ASSERT_X(false,
  62.                 "At this stage mCameraAdapter->mStateSwitchLock is still locked, "
  63.                 "deadlock is guaranteed");
  65.             goto error;
  66.         }
  68.     }
  70.     ///Send START_PREVIEW command to adapter
  71.     CAMHAL_LOGDA("Starting CameraAdapter preview mode");
  73.     ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_PREVIEW);
  75.     if(ret!=NO_ERROR) {
  76.         CAMHAL_LOGEA("Couldn‘t start preview w/ CameraAdapter");
  77.         goto error;
  78.     }
  79.     CAMHAL_LOGDA("Started preview");
  81.     mPreviewEnabled = true;
  82.     mPreviewStartInProgress = false;
  83.     return ret;
  85.     error:
  87.         CAMHAL_LOGEA("Performing cleanup after error");
  89.         //Do all the cleanup
  90.         freePreviewBufs();
  91.         mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_PREVIEW);
  92.         if(mDisplayAdapter.get() != NULL) {
  93.             mDisplayAdapter->disableDisplay(false);
  94.         }
  95.         mAppCallbackNotifier->stop();
  96.         mPreviewStartInProgress = false;
  97.         mPreviewEnabled = false;
  98.         LOG_FUNCTION_NAME_EXIT;
  100.         return ret;
  101. }
在我的理解看来上面标注的部分是这个方法的关键，这个地方可是会让初次研究这里的人晕头转向的，因为我就在这里犯了错误，走岔道了，下面会说明到底是怎么走岔道的：
先说一下吧，这里调用mCameraAdapter对象的sendCommand方法

  1. status_t BaseCameraAdapter::sendCommand(CameraCommands operation, int value1, int value2, int value3, int value4) {
  2.     status_t ret = NO_ERROR;
  3.     struct timeval *refTimestamp;
  4.     BuffersDescriptor *desc = NULL;
  5.     CameraFrame *frame = NULL;
  7.     LOG_FUNCTION_NAME;
  9.     switch ( operation ) {
  10.         case：
  11.             ...............
  12.         case CameraAdapter::CAMERA_START_PREVIEW:
            {
                CAMHAL_LOGDA("Start Preview");
                if ( ret == NO_ERROR )
                {
                    ret = setState(operation);
                }

                if ( ret == NO_ERROR )
                {
                    ret = startPreview();
                }

                if ( ret == NO_ERROR )
                {
                    ret = commitState();
                }else{
                    ret |= rollbackState();
                }
                break;
            }
  13.     }
  14. }
  1. status_t BaseCameraAdapter::setState(CameraCommands operation)
  2. {
  3.     status_t ret = NO_ERROR;
  5.     LOG_FUNCTION_NAME;
  7.     const char *printState = getLUTvalue_translateHAL(operation, CamCommandsLUT);
  9.     mLock.lock();
  11.     switch ( mAdapterState )
  12.         {
  14.         case INTIALIZED_STATE:
  15.             ............
  17.         case LOADED_PREVIEW_STATE:
  19.             switch ( operation )
  20.                 {
  22.                 case CAMERA_START_PREVIEW:
  23.                     CAMHAL_LOGDB("Adapter state switch LOADED_PREVIEW_STATE->PREVIEW_STATE event = %s",
  24.                             printState);
  25.                     mNextState = PREVIEW_STATE;
  26.                     break;
  27.                 }
  28.         }
  29. }
  1. status_t BaseCameraAdapter::startPreview()
  2. {
  3.     status_t ret = NO_ERROR;
  5.     LOG_FUNCTION_NAME;
  7.     LOG_FUNCTION_NAME_EXIT;
  9.     return ret;
  10. }
就是这里了，所以我用可很醒目的颜色标注出来，很多人会想当然的理解，你不是调用了startPreview方法嘛，那就是他了啊！可是这里为什么什么动作都没做呢？？
于是就卡在这里不知所措了，那个纠结啊技术分享技术分享
现在就来解开这个谜团吧！！！

这个我们还是要往前追溯了，追溯到哪里呢？？那就从这里开始吧
mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_PREVIEW);
这个方式是在CameraHal的startPreview() 方法中被调用的
所以我要知道这个mCameraAdapter对象原型是什么啊，他从哪里而来，原来他是CameraHal这个类的一个成员，定义在：hardware/ti/omap4xxx/camera/inc/CameraHal.h
CameraAdapter *mCameraAdapter;
这里必须打破砂锅追到底，找到CameraAdapter 这个类的定义，他的定义同样这这个.h文件中

  1. /**
  2.   * CameraAdapter interface class
  3.   * Concrete classes derive from this class and provide implementations based on the specific camera h/w interface
  4.   */
  6. class CameraAdapter: public FrameNotifier, public virtual RefBase
  7. {
  8. protected:
  9.     enum AdapterActiveStates {
  10.         INTIALIZED_ACTIVE = 1 << 0,
  11.         LOADED_PREVIEW_ACTIVE = 1 << 1,
  12.         PREVIEW_ACTIVE = 1 << 2,
  13.         LOADED_CAPTURE_ACTIVE = 1 << 3,
  14.         CAPTURE_ACTIVE = 1 << 4,
  15.         BRACKETING_ACTIVE = 1 << 5,
  16.         AF_ACTIVE = 1 << 6,
  17.         ZOOM_ACTIVE = 1 << 7,
  18.         VIDEO_ACTIVE = 1 << 8,
  19.         LOADED_REPROCESS_ACTIVE = 1 << 9,
  20.         REPROCESS_ACTIVE = 1 << 10,
  21.     };
  22. public:
  23.     typedef struct
  24.         {
  25.          CameraBuffer *mBuffers;
  26.          uint32_t *mOffsets;
  27.          int mFd;
  28.          size_t mLength;
  29.          size_t mCount;
  30.          size_t mMaxQueueable;
  31.         } BuffersDescriptor;
  33.     enum CameraCommands
  34.         {
  35.         CAMERA_START_PREVIEW = 0,
  36.         CAMERA_STOP_PREVIEW = 1,
  37.         CAMERA_START_VIDEO = 2,
  38.         CAMERA_STOP_VIDEO = 3,
  39.         CAMERA_START_IMAGE_CAPTURE = 4,
  40.         CAMERA_STOP_IMAGE_CAPTURE = 5,
  41.         CAMERA_PERFORM_AUTOFOCUS = 6,
  42.         CAMERA_CANCEL_AUTOFOCUS = 7,
  43.         CAMERA_PREVIEW_FLUSH_BUFFERS = 8,
  44.         CAMERA_START_SMOOTH_ZOOM = 9,
  45.         CAMERA_STOP_SMOOTH_ZOOM = 10,
  46.         CAMERA_USE_BUFFERS_PREVIEW = 11,
  47.         CAMERA_SET_TIMEOUT = 12,
  48.         CAMERA_CANCEL_TIMEOUT = 13,
  49.         CAMERA_START_BRACKET_CAPTURE = 14,
  50.         CAMERA_STOP_BRACKET_CAPTURE = 15,
  51.         CAMERA_QUERY_RESOLUTION_PREVIEW = 16,
  52.         CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE = 17,
  53.         CAMERA_QUERY_BUFFER_SIZE_PREVIEW_DATA = 18,
  54.         CAMERA_USE_BUFFERS_IMAGE_CAPTURE = 19,
  55.         CAMERA_USE_BUFFERS_PREVIEW_DATA = 20,
  56.         CAMERA_TIMEOUT_EXPIRED = 21,
  57.         CAMERA_START_FD = 22,
  58.         CAMERA_STOP_FD = 23,
  59.         CAMERA_SWITCH_TO_EXECUTING = 24,
  60.         CAMERA_USE_BUFFERS_VIDEO_CAPTURE = 25,
  61. #ifdef OMAP_ENHANCEMENT_CPCAM
  62.         CAMERA_USE_BUFFERS_REPROCESS = 26,
  63.         CAMERA_START_REPROCESS = 27,
  64. #endif
  65. #ifdef OMAP_ENHANCEMENT_VTC
  66.         CAMERA_SETUP_TUNNEL = 28,
  67.         CAMERA_DESTROY_TUNNEL = 29,
  68. #endif
  69.         CAMERA_PREVIEW_INITIALIZATION = 30,
  70.         };
  72.     enum CameraMode
  73.         {
  74.         CAMERA_PREVIEW,
  75.         CAMERA_IMAGE_CAPTURE,
  76.         CAMERA_VIDEO,
  77.         CAMERA_MEASUREMENT,
  78.         CAMERA_REPROCESS,
  79.         };
  81.     enum AdapterState {
  82.         INTIALIZED_STATE = INTIALIZED_ACTIVE,
  83.         LOADED_PREVIEW_STATE = LOADED_PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
  84.         PREVIEW_STATE = PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
  85.         LOADED_CAPTURE_STATE = LOADED_CAPTURE_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
  86.         CAPTURE_STATE = CAPTURE_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
  87.         BRACKETING_STATE = BRACKETING_ACTIVE | CAPTURE_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE ,
  88.         AF_STATE = AF_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
  89.         ZOOM_STATE = ZOOM_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
  90.         VIDEO_STATE = VIDEO_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
  91.         VIDEO_AF_STATE = VIDEO_ACTIVE | AF_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
  92.         VIDEO_ZOOM_STATE = VIDEO_ACTIVE | ZOOM_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
  93.         VIDEO_LOADED_CAPTURE_STATE = VIDEO_ACTIVE | LOADED_CAPTURE_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
  94.         VIDEO_CAPTURE_STATE = VIDEO_ACTIVE | CAPTURE_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
  95.         AF_ZOOM_STATE = AF_ACTIVE | ZOOM_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
  96.         BRACKETING_ZOOM_STATE = BRACKETING_ACTIVE | ZOOM_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
  97.         LOADED_REPROCESS_STATE = LOADED_REPROCESS_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
  98.         LOADED_REPROCESS_CAPTURE_STATE = LOADED_REPROCESS_ACTIVE | LOADED_CAPTURE_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
  99.         REPROCESS_STATE = REPROCESS_ACTIVE | CAPTURE_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
  100.     };
  103. public:
  105.     ///Initialzes the camera adapter creates any resources required
  106.     virtual int initialize(CameraProperties::Properties*) = 0;
  108.     virtual int setErrorHandler(ErrorNotifier *errorNotifier) = 0;
  110.     //Message/Frame notification APIs
  111.     virtual void enableMsgType(int32_t msgs,
  112.                                frame_callback callback = NULL,
  113.                                event_callback eventCb = NULL,
  114.                                void *cookie = NULL) = 0;
  115.     virtual void disableMsgType(int32_t msgs, void* cookie) = 0;
  116.     virtual void returnFrame(CameraBuffer* frameBuf, CameraFrame::FrameType frameType) = 0;
  117.     virtual void addFramePointers(CameraBuffer *frameBuf, void *buf) = 0;
  118.     virtual void removeFramePointers() = 0;
  120.     //APIs to configure Camera adapter and get the current parameter set
  121.     virtual int setParameters(const CameraParameters& params) = 0;
  122.     virtual void getParameters(CameraParameters& params) = 0;
  124.     //Registers callback for returning image buffers back to CameraHAL
  125.     virtual int registerImageReleaseCallback(release_image_buffers_callback callback, void *user_data) = 0;
  127.     //Registers callback, which signals a completed image capture
  128.     virtual int registerEndCaptureCallback(end_image_capture_callback callback, void *user_data) = 0;
  130.     //API to send a command to the camera
  131.     virtual status_t sendCommand(CameraCommands operation, int value1=0, int value2=0, int value3=0, int value4=0) = 0;
  133.     virtual ~CameraAdapter() {};
  135.     //Retrieves the current Adapter state
  136.     virtual AdapterState getState() = 0;
  138.     //Retrieves the next Adapter state
  139.     virtual AdapterState getNextState() = 0;
  141.     // Receive orientation events from CameraHal
  142.     virtual void onOrientationEvent(uint32_t orientation, uint32_t tilt) = 0;
  144.     // Rolls the state machine back to INTIALIZED_STATE from the current state
  145.     virtual status_t rollbackToInitializedState() = 0;
  147.     // Retrieves the current Adapter state - for internal use (not locked)
  148.     virtual status_t getState(AdapterState &state) = 0;
  149.     // Retrieves the next Adapter state - for internal use (not locked)
  150.     virtual status_t getNextState(AdapterState &state) = 0;
  152. protected:
  153.     //The first two methods will try to switch the adapter state.
  154.     //Every call to setState() should be followed by a corresponding
  155.     //call to commitState(). If the state switch fails, then it will
  156.     //get reset to the previous state via rollbackState().
  157.     virtual status_t setState(CameraCommands operation) = 0;
  158.     virtual status_t commitState() = 0;
  159.     virtual status_t rollbackState() = 0;
  160. };
看一下我标出的这是红色部分啊，为什么我要把它们标注成红色呢？？
懂C++面向对象思想应该都知道virtual这个关键字是干什么的，
如果一个类的方法被定义为virtual，如果该类的子类实现了同样的方法，则这个方法被调用的时候，会忽略父类的实现，而直接调用子类的实现，前提是方法名，包括变量类型，个数必须一致
那么这里有没有类继承了CameraAdapter 这个类，并且实现了其中的一些虚拟函数呢？？答案是肯定的，我可是吃了苦头才发现的技术分享技术分享
不过也是赖自己，这是只有定义是没有实现的，肯定是由子类来实现这是方法的，不，还是不赖自己，让我吃苦头的是这里是双层继承的，双层继承啊，我怎么知道技术分享技术分享
不卖关子了，那么谁继承了CameraAdapter 这个类呢？ 先给路径：hardware/ti/omap4xxx/camera/inc/BaseCameraAdapter.h

  1. class BaseCameraAdapter : public CameraAdapter
  2. {
  4. public:
  6.     BaseCameraAdapter();
  7.     virtual ~BaseCameraAdapter();
  9.     ///Initialzes the camera adapter creates any resources required
  10.     virtual status_t initialize(CameraProperties::Properties*) = 0;
  12.     virtual int setErrorHandler(ErrorNotifier *errorNotifier);
  14.     //Message/Frame notification APIs
  15.     virtual void enableMsgType(int32_t msgs, frame_callback callback=NULL, event_callback eventCb=NULL, void* cookie=NULL);
  16.     virtual void disableMsgType(int32_t msgs, void* cookie);
  17.     virtual void returnFrame(CameraBuffer * frameBuf, CameraFrame::FrameType frameType);
  18.     virtual void addFramePointers(CameraBuffer *frameBuf, void *y_uv);
  19.     virtual void removeFramePointers();
  21.     //APIs to configure Camera adapter and get the current parameter set
  22.     virtual status_t setParameters(const CameraParameters& params) = 0;
  23.     virtual void getParameters(CameraParameters& params) = 0;
  25.     //API to send a command to the camera
  26.     virtual status_t sendCommand(CameraCommands operation, int value1 = 0, int value2 = 0, int value3 = 0, int value4 = 0 );
  28.     virtual status_t registerImageReleaseCallback(release_image_buffers_callback callback, void *user_data);
  30.     virtual status_t registerEndCaptureCallback(end_image_capture_callback callback, void *user_data);
  32.     //Retrieves the current Adapter state
  33.     virtual AdapterState getState();
  34.     //Retrieves the next Adapter state
  35.     virtual AdapterState getNextState();
  37.     // Rolls the state machine back to INTIALIZED_STATE from the current state
  38.     virtual status_t rollbackToInitializedState();
  40. protected:
  41.     //The first two methods will try to switch the adapter state.
  42.     //Every call to setState() should be followed by a corresponding
  43.     //call to commitState(). If the state switch fails, then it will
  44.     //get reset to the previous state via rollbackState().
  45.     virtual status_t setState(CameraCommands operation);
  46.     virtual status_t commitState();
  47.     virtual status_t rollbackState();
  49.     // Retrieves the current Adapter state - for internal use (not locked)
  50.     virtual status_t getState(AdapterState &state);
  51.     // Retrieves the next Adapter state - for internal use (not locked)
  52.     virtual status_t getNextState(AdapterState &state);
  54.     //-----------Interface that needs to be implemented by deriving classes --------------------
  56.     //Should be implmented by deriving classes in order to start image capture
  57.     virtual status_t takePicture();
  59.     //Should be implmented by deriving classes in order to start image capture
  60.     virtual status_t stopImageCapture();
  62.     //Should be implmented by deriving classes in order to start temporal bracketing
  63.     virtual status_t startBracketing(int range);
  65.     //Should be implemented by deriving classes in order to stop temporal bracketing
  66.     virtual status_t stopBracketing();
  68.     //Should be implemented by deriving classes in oder to initiate autoFocus
  69.     virtual status_t autoFocus();
  71.     //Should be implemented by deriving classes in oder to initiate autoFocus
  72.     virtual status_t cancelAutoFocus();
  74.     //Should be called by deriving classes in order to do some bookkeeping
  75.     virtual status_t startVideoCapture();
  77.     //Should be called by deriving classes in order to do some bookkeeping
  78.     virtual status_t stopVideoCapture();
  80.     //Should be implemented by deriving classes in order to start camera preview
  81.     virtual status_t startPreview();
  83.     //Should be implemented by deriving classes in order to stop camera preview
  84.     virtual status_t stopPreview();
  86.     //Should be implemented by deriving classes in order to start smooth zoom
  87.     virtual status_t startSmoothZoom(int targetIdx);
  89.     //Should be implemented by deriving classes in order to stop smooth zoom
  90.     virtual status_t stopSmoothZoom();
  92.     //Should be implemented by deriving classes in order to stop smooth zoom
  93.     virtual status_t useBuffers(CameraMode mode, CameraBuffer* bufArr, int num, size_t length, unsigned int queueable);
  95.     //Should be implemented by deriving classes in order queue a released buffer in CameraAdapter
  96.     virtual status_t fillThisBuffer(CameraBuffer* frameBuf, CameraFrame::FrameType frameType);
  98.     //API to get the frame size required to be allocated. This size is used to override the size passed
  99.     //by camera service when VSTAB/VNF is turned ON for example
  100.     virtual status_t getFrameSize(size_t &width, size_t &height);
  102.     //API to get required data frame size
  103.     virtual status_t getFrameDataSize(size_t &dataFrameSize, size_t bufferCount);
  105.     //API to get required picture buffers size with the current configuration in CameraParameters
  106.     virtual status_t getPictureBufferSize(size_t &length, size_t bufferCount);
  108.     // Should be implemented by deriving classes in order to start face detection
  109.     // ( if supported )
  110.     virtual status_t startFaceDetection();
  112.     // Should be implemented by deriving classes in order to stop face detection
  113.     // ( if supported )
  114.     virtual status_t stopFaceDetection();
  116.     virtual status_t switchToExecuting();
  118.     virtual status_t setupTunnel(uint32_t SliceHeight, uint32_t EncoderHandle, uint32_t width, uint32_t height);
  120.     virtual status_t destroyTunnel();
  122.     virtual status_t cameraPreviewInitialization();
  124.     // Receive orientation events from CameraHal
  125.     virtual void onOrientationEvent(uint32_t orientation, uint32_t tilt);
  127.     // ---------------------Interface ends-----------------------------------
  129.     status_t notifyFocusSubscribers(CameraHalEvent::FocusStatus status);
  130.     status_t notifyShutterSubscribers();
  131.     status_t notifyZoomSubscribers(int zoomIdx, bool targetReached);
  132.     status_t notifyMetadataSubscribers(sp<CameraMetadataResult> &meta);
  134.     //Send the frame to subscribers
  135.     status_t sendFrameToSubscribers(CameraFrame *frame);
  137.     //Resets the refCount for this particular frame
  138.     status_t resetFrameRefCount(CameraFrame &frame);
  140.     //A couple of helper functions
  141.     void setFrameRefCount(CameraBuffer* frameBuf, CameraFrame::FrameType frameType, int refCount);
  142.     int getFrameRefCount(CameraBuffer* frameBuf, CameraFrame::FrameType frameType);
  143.     int setInitFrameRefCount(CameraBuffer* buf, unsigned int mask);
  144.     static const char* getLUTvalue_translateHAL(int Value, LUTtypeHAL LUT);
  146.     .................
  147.     .................
  148. }
这里我只列出了一部分代码，不过大家清楚了，BaseCameraAdapter 继承CameraAdapter，不过这里还没完呢，看看这个类中定义的方法
那么多的virtual 方法，后来自己才发现的，他还是被别的类继承了，而且其中的很多方法被子类重新实现了
所以实现上上面调用的startPreview方法其实不是BaseCameraAdapter.cpp中实现的那个startPreview方法
那挺调用的startPreview方法在哪里呢，自然是继承了BaseCameraAdapter 类的那个子类实现的startPreview
现在就把这个罪魁祸首拉上来，先看定义：hardware/ti/omap4xxx/camera/inc/V4LCameraAdapter/V4LCameraAdapter.h

  1. /**
  2.   * Class which completely abstracts the camera hardware interaction from camera hal
  3.   * TODO: Need to list down here, all the message types that will be supported by this class
  4.                 Need to implement BufferProvider interface to use AllocateBuffer of OMX if needed
  5.   */
  6. class V4LCameraAdapter : public BaseCameraAdapter
  7. {
  8. public:
  10.     /*--------------------Constant declarations----------------------------------------*/
  11.     static const int32_t MAX_NO_BUFFERS = 20;
  13.     ///@remarks OMX Camera has six ports - buffer input, time input, preview, image, video, and meta data
  14.     static const int MAX_NO_PORTS = 6;
  16.     ///Five second timeout
  17.     static const int CAMERA_ADAPTER_TIMEOUT = 5000*1000;
  19. public:
  21.     V4LCameraAdapter(size_t sensor_index);
  22.     ~V4LCameraAdapter();
  25.     ///Initialzes the camera adapter creates any resources required
  26.     virtual status_t initialize(CameraProperties::Properties*);
  28.     //APIs to configure Camera adapter and get the current parameter set
  29.     virtual status_t setParameters(const CameraParameters& params);
  30.     virtual void getParameters(CameraParameters& params);
  32.     // API
  33.     virtual status_t UseBuffersPreview(CameraBuffer *bufArr, int num);
  34.     virtual status_t UseBuffersCapture(CameraBuffer *bufArr, int num);
  36.     static status_t getCaps(const int sensorId, CameraProperties::Properties* params, V4L_HANDLETYPE handle);
  38. protected:
  40. //----------Parent class method implementation------------------------------------//看看人家这里说的很清楚，这是父类的方法
  41.     virtual status_t startPreview();
  42.     virtual status_t stopPreview();
  43.     virtual status_t takePicture();
  44.     virtual status_t stopImageCapture();
  45.     virtual status_t autoFocus();
  46.     virtual status_t useBuffers(CameraMode mode, CameraBuffer *bufArr, int num, size_t length, unsigned int queueable);
  47.     virtual status_t fillThisBuffer(CameraBuffer *frameBuf, CameraFrame::FrameType frameType);
  48.     virtual status_t getFrameSize(size_t &width, size_t &height);
  49.     virtual status_t getPictureBufferSize(size_t &length, size_t bufferCount);
  50.     virtual status_t getFrameDataSize(size_t &dataFrameSize, size_t bufferCount);
  51.     virtual void onOrientationEvent(uint32_t orientation, uint32_t tilt);
  52. //-----------------------------------------------------------------------------
  55. private:
  57.     class PreviewThread : public Thread {
  58.             V4LCameraAdapter* mAdapter;
  59.         public:
  60.             PreviewThread(V4LCameraAdapter* hw) :
  61.                     Thread(false), mAdapter(hw) { }
  62.             virtual void onFirstRef() {
  63.                 run("CameraPreviewThread", PRIORITY_URGENT_DISPLAY);
  64.             }
  65.             virtual bool threadLoop() {
  66.                 mAdapter->previewThread();
  67.                 // loop until we need to quit
  68.                 return true;
  69.             }
  70.         };
  72.     //Used for calculation of the average frame rate during preview
  73.     status_t recalculateFPS();
  75.     char * GetFrame(int &index);
  77.     int previewThread();
  79. public:
  81. private:
  82.     //capabilities data
  83.     static const CapPixelformat mPixelformats [];
  84.     static const CapResolution mPreviewRes [];
  85.     static const CapFramerate mFramerates [];
  86.     static const CapResolution mImageCapRes [];
  88.     //camera defaults
  89.     static const char DEFAULT_PREVIEW_FORMAT[];
  90.     static const char DEFAULT_PREVIEW_SIZE[];
  91.     static const char DEFAULT_FRAMERATE[];
  92.     static const char DEFAULT_NUM_PREV_BUFS[];
  94.     static const char DEFAULT_PICTURE_FORMAT[];
  95.     static const char DEFAULT_PICTURE_SIZE[];
  96.     static const char DEFAULT_FOCUS_MODE[];
  97.     static const char * DEFAULT_VSTAB;
  98.     static const char * DEFAULT_VNF;
  100.     static status_t insertDefaults(CameraProperties::Properties*, V4L_TI_CAPTYPE&);
  101.     static status_t insertCapabilities(CameraProperties::Properties*, V4L_TI_CAPTYPE&);
  102.     static status_t insertPreviewFormats(CameraProperties::Properties* , V4L_TI_CAPTYPE&);
  103.     static status_t insertPreviewSizes(CameraProperties::Properties* , V4L_TI_CAPTYPE&);
  104.     static status_t insertImageSizes(CameraProperties::Properties* , V4L_TI_CAPTYPE&);
  105.     static status_t insertFrameRates(CameraProperties::Properties* , V4L_TI_CAPTYPE&);
  106.     static status_t sortAscend(V4L_TI_CAPTYPE&, uint16_t ) ;
  108.     status_t v4lIoctl(int, int, void*);
  109.     status_t v4lInitMmap(int&);
  110.     status_t v4lInitUsrPtr(int&);
  111.     status_t v4lStartStreaming();
  112.     status_t v4lStopStreaming(int nBufferCount);
  113.     status_t v4lSetFormat(int, int, uint32_t);
  114.     status_t restartPreview();
  117.     int mPreviewBufferCount;
  118.     int mPreviewBufferCountQueueable;
  119.     int mCaptureBufferCount;
  120.     int mCaptureBufferCountQueueable;
  121.     KeyedVector<CameraBuffer *, int> mPreviewBufs;
  122.     KeyedVector<CameraBuffer *, int> mCaptureBufs;
  123.     mutable Mutex mPreviewBufsLock;
  124.     mutable Mutex mCaptureBufsLock;
  125.     mutable Mutex mStopPreviewLock;
  127.     CameraParameters mParams;
  129.     bool mPreviewing;
  130.     bool mCapturing;
  131.     Mutex mLock;
  133.     int mFrameCount;
  134.     int mLastFrameCount;
  135.     unsigned int mIter;
  136.     nsecs_t mLastFPSTime;
  138.     //variables holding the estimated framerate
  139.     float mFPS, mLastFPS;
  141.     int mSensorIndex;
  143.     // protected by mLoc
大家看到了V4LCameraAdapter 又继承了BaseCameraAdapter，双层继承，实现了父类的一些方法
所有这里算是媳妇熬着婆了，终于找到了我们想要的startPreview
不过看到终于进入了V4LCameraAdapter 这个类，我知道，离成功已经很近了，V4L2就是直接去和driver谈判的
那么我们就看看V4LCameraAdapter 这个类中的startPreview方法吧，路径：ardware/ti/omap4xxx/camera/V4LCameraAdapter/V4LCameraAdapter.cpp

  1. status_t V4LCameraAdapter::startPreview()
  2. {
  3.     status_t ret = NO_ERROR;
  5.     LOG_FUNCTION_NAME;
  6.     Mutex::Autolock lock(mPreviewBufsLock);
  8.     if(mPreviewing) {
  9.         ret = BAD_VALUE;
  10.         goto EXIT;
  11.     }
  13.     for (int i = 0; i < mPreviewBufferCountQueueable; i++) {
  15.         mVideoInfo->buf.index = i;
  16.         mVideoInfo->buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  17.         mVideoInfo->buf.memory = V4L2_MEMORY_MMAP;
  19.         ret = v4lIoctl(mCameraHandle, VIDIOC_QBUF, &mVideoInfo->buf);
  20.         if (ret < 0) {
  21.             CAMHAL_LOGEA("VIDIOC_QBUF Failed");
  22.             goto EXIT;
  23.         }
  24.         nQueued++;
  25.     }
  27.     ret = v4lStartStreaming();
  29.     // Create and start preview thread for receiving buffers from V4L Camera
  30.     if(!mCapturing) {
  31.         mPreviewThread = new PreviewThread(this);
  32.         CAMHAL_LOGDA("Created preview thread");
  33.     }
不错，这条语句就是我一直找寻的，真是众里寻他千百度，蓦然回首，那句就在灯火阑珊处
这样，其他的事情就全部由v4l2去做了，这些过程会单独分一章去学习
还有就是上面绿的部分，同样要分一章学习，很重要

待续。。。。。。。。。。。

Android Camera 通过V4L2与kernel driver的完整交互过程

标签：protect   source   public   parameter   nts   word   mac   memset   详细   

原文地址：http://www.cnblogs.com/jukan/p/6961997.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
迷上了代码！