zoukankan      html  css  js  c++  java

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

    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去做了，这些过程会单独分一章去学习
    还有就是上面绿的部分，同样要分一章学习，很重要

    待续。。。。。。。。。。。
  • 相关阅读:
    php javascript
    在线支付接口之PHP支付宝接口开发
    作业9 最长公共子序列
    第十二章 税制的设计
    第十一章 公共物品和公共资源
    第十章 外部性
    第九章 应用：国际贸易
    作业8 矩阵乘法链
    第八章 应用：赋税的代价
    第七章 消费者、生产者与市场效率
  • 原文地址：https://www.cnblogs.com/jukan/p/6961997.html
Copyright © 2011-2022 走看看