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

最新推荐文章于 2024-09-12 03:09:01 发布
最新推荐文章于 2024-09-12 03:09:01 发布
阅读量3k 收藏 6
点赞数 1
分类专栏： android camera
之前在  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去做了，这些过程会单独分一章去学习
还有就是上面绿的部分，同样要分一章学习，很重要

待续。。。。。。。。。。。
tigerly
关注
专栏目录
Camx架构-Camera kernel Driver & debugging
我的博客
06-03 2874
Camx架构-Camera kernel Driver & debugging
android camera HAL资料及V4L2资料（含V4L2例程）
02-24
网上找的android camera HAL资料及V4L2资料，V4L2一个文档中含V4L2的简单实现例程
android的camera学习（4）——V4L2框架及源码整理_android+v4l2(1)
最新发布
2401_87125938的博客
09-12 706
* mem_ops由kernel自身实现并提供了三种类型的视频缓存区操作方法：连续的DMA缓冲区、集散的DMA缓冲区以及vmalloc创建的缓冲区，分别由videobuf2-dma-contig.c、videobuf2-dma-sg.c和videobuf-vmalloc.c文件实现，可以根据实际情况来使用。/* vb2_queue代表一个videobuffer队列，vb2_buffer是这个队列中的成员，vb2_mem_ops是缓冲内存的操作函数集，vb2_ops用来管理队列 */
V4L2用户空间和kernel层driver的交互过程
Seal--学海无涯
04-22 2496
V4L2用户空间和kernel层driver的交互过程 ​ 这篇文章详细分析了V4L2用户空间和kernel层driver的交互过程，目的只有一个： 更清晰的理解V4L2视频驱动程序的系统结构，驱动编程方法，为以后开发视频驱动打好基础 既然从用户层出发探究驱动层，这里先贴出应用层code： #include stdio.h> #include stdlib.h> #inc
一文分析Linux v4l2框架
youzhangjing_的博客
03-11 1162
V4L2(Video for Linux 2)：Linux内核中关于视频设备驱动的框架，对上向应用层提供统一的接口，对下支持各类复杂硬件的灵活扩展；V4L2框架，主要包括v4l2-core、meida framework、videobuf2等模块，这也是本文将要展开的内容，仅提纲挈领；开始吧。
linux V4L2子系统——v4l2的结构体（4）之ioctl， my write
小硕算法工程师
07-31 882
在应用程序获取视频数据的流程中，都是通过 ioctl 命令与驱动程序进行交互，结合实际需求，实现struct v4l2_ioctl_ops相关的成员即可。//源码：include/media/v4l2-ioctl.h/*** output* capture*//**/
android camera V4L2 FIMC
u010783226的专栏
12-30 532
camera
基于V4L2驱动程序的USB摄像头Android(JNI)的编写(一)
JansonZhe
08-06 9169
video4 linux2(V4L2)是Linux内核中关于视频设备的内核驱动，它为Linux中视频设备访问提供了通用接口，在Linux系统中，本文主要介绍如何使用V4L2驱动程序打开我们的USB摄像头。同时着重介绍如何编写相应JNI(NDK)使Android应用程序能够打开我们外接的USB摄像头，并获取视频流信息。
android高通camera驱动调试,高通Camera模块驱动指南资料
weixin_39895684的博客
05-27 402
Multimedia Driver Development and Bringup Guide – Camera原资料内容节选：3.1 Reference drivers for YUV and Bayer sensorsBayer reference driversUser space drivers are located in $(MM_CAMERA_DIR)/mm-camera2/medi...
Android Camera2 HAL3 高通Qualcomm Camera底层initialize代码流程
SSSS的博客
04-20 795
本文列出代码调用流程，作为参考，要想了解高通驱动架构需要结核实际理解代码，不要一味的沉浸在代码中，这样是没有任何效果的。 当相机打开成功后会紧接着执行initialize，代码流程如下 /*initialize_flow*/ #if 1 /*************************initialize_flow_start***************************...
QCOM_CAMERA内存管理之 kernel 篇（一）
a185531353的博客
08-26 1779
QC_CAM内存管理之 kernel 篇（一）一.相关变量二.alloc and map阶段三.map 阶段四.release 阶段 一.相关变量 1.buffer flag // 对应HAL的CSLMemFlagHw #define CAM_MEM_FLAG_HW_READ_WRITE (1<<0) // 下面两个在hal中未使用 #define CAM_MEM_FLAG_HW_READ_ONLY (1<<1) #define
高通mm-camera_kernel
h_8410435的博客
06-16 1140
高通 mm-camera_kernel code
Android Camera HAL浅析
石虎
06-24 1024
//联系人:石虎  QQ: 1224614774昵称:嗡嘛呢叭咪哄 1、Camera成像原理介绍 Camera工作流程图 Camera的成像原理可以简单概括如下： 景物(SCENE)通过镜头（LENS）生成的光学图像投射到图像传感器(Sensor)表面上，然后转为电信号，经过A/D（模数转换）转换后变为数字图像
Android源码笔记——Camera系统架构
weixin_30340617的博客
04-01 316
Camera的架构与Android系统的整体架构保持一致，如下图所示，本文主要从以下四个方面对其进行说明。 Framework：Camera.java Android Runtime：android_hardware_Camera.cpp Library：Camera Client和Camera Service HAL：CameraHardwareInterface 一、Fr...
V4L2驱动框架详解
arvin_xiong的博客
06-29 832
④ video_device->ioctl_ops: 设置成v4l2_ioctl_ops结构, 该结构体成员为应用层操作video_device_fd句柄的ioctl(VIDEOC_XXX) ,所回调的函数指针。我们配置/dev/video主要通过使用ioctl(VIDEOC_XXX), 命令宏如:VIDIOC_S_FMT, VIDIOC_G_FMT, VIDIOC_REQBUFS, VIDIOC_QUERYBUF, VIDIOC_DQBUF, VIDIOC_STREAMOFF。性能最高,实现起来复杂。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值