camera HAL 学习

camera HAL :  camerasevice.cpp

1       mNumberOfCameras = mModule->get_number_of_cameras();

    handle_base= mm_camera_query(&num_camera);   

根据/dev/media0 1 来num_camera ，同时初始化 static mm_camera_ctrl_t g_cam_ctrl;  //HAL主要结构

2         if (mModule->get_camera_info(cameraId, &info) != OK)   //sp<ICamera> CameraService::connect中调用

    android::HAL_getCameraInfo(camera_id, &camInfo);

 

3      sp<ICamera> CameraService::connect(

 hardware = new CameraHardwareInterface(camera_device_name);

 if (hardware->initialize(&mModule->common) != OK) 

//        int rc = module->methods->open(module, mName.string(),  (hw_device_t **)&mDevice);

//extern "C" int  camera_device_open

//{            camHal->hardware = new QCameraHardwareInterface(cameraId, mode); //HAL_openCameraHardware(cameraId);                      100

client = new Client(this, cameraClient, hardware, cameraId, info.facing, callingPid);

{

    mHardware->setCallbacks(notifyCallback,

                            dataCallback,

                            dataCallbackTimestamp,

                            (void *)cameraId);

}

 100  NEW QCameraHardwareInterface(cameraId, mode)  

    result=cam_ops_open(mCameraId, MM_CAMERA_OP_MODE_NOTUSED);                       101

    loadTables();

    /* Setup Picture Size and Preview size tables */

    setPictureSizeTable();

    setMyMode(mode);

    initDefaultParameters();                                                                                                                   102

    result = createPreview();   //    //Create Stream Objects

    result = createRecord();

    result = createSnapshot();

    result = createRdi();

int32_t QCameraHardwareInterface::createPreview()

    mStreamDisplay = QCameraStream_preview::createInstance(mCameraId, myMode);

    ret = mStreamDisplay->init();

  ret = QCameraStream::initChannel (mCameraId, MM_CAMERA_CH_PREVIEW_MASK);

rc = cam_ops_ch_acquire(cameraId, MM_CAMERA_CH_PREVIEW);

        rc = mm_camera_ch_acquire(my_obj, ch_type);

    return mm_camera_ch_fn(my_obj,ch_type, MM_CAMERA_STATE_EVT_ACQUIRE, 0);

    case MM_CAMERA_CH_PREVIEW:

        stream1 = &my_obj->ch[ch_type].preview.stream;

        type1 = MM_CAMERA_STREAM_PREVIEW;

    if(stream1) rc = mm_camera_stream_fsm_fn_vtbl(my_obj, stream1,MM_CAMERA_STATE_EVT_ACQUIRE, &type1);

static int32_t mm_camera_stream_fsm_notused(mm_camera_obj_t * my_obj, mm_camera_stream_t *stream,  mm_camera_state_evt_type_t evt, void *val)

    case MM_CAMERA_STATE_EVT_ACQUIRE: 

 snprintf(dev_name, sizeof(dev_name), "/dev/%s", mm_camera_util_get_dev_name(my_obj)); 

stream->fd = open(dev_name, O_RDWR | O_NONBLOCK);

 

/* register a notify into the mmmm_camera_t object*/

  (void) cam_evt_register_buf_notify(mCameraId, MM_CAMERA_CH_PREVIEW,

                                     preview_notify_cb,

                                     MM_CAMERA_REG_BUF_CB_INFINITE,

                                     0,this);

        rc = mm_camera_ch_fn(my_obj,ch_type,

                            MM_CAMERA_STATE_EVT_REG_BUF_CB, (void *)&reg);

        rc = mm_camera_ch_util_reg_buf_cb(my_obj, ch_type,

                                          (mm_camera_buf_cb_t *)val);

    for( i=0 ;i < MM_CAMERA_BUF_CB_MAX; i++ ) {   //完成注册

        if(my_obj->ch[ch_type].buf_cb[i].cb==NULL) {

            memcpy(&my_obj->ch[ch_type].buf_cb[i],val,sizeof(mm_camera_buf_cb_t));

            break;

        }

    }

 101  NEW QCameraHardwareInterface cam_ops_open

    rc = mm_camera_open(g_cam_ctrl.cam_obj[camera_id], op_mode);

    //my_obj->ctrl_fd = open(dev_name,O_RDWR | O_NONBLOCK);   //dev_name 为video，video0 or 1 ；

    //my_obj->ds_fd = mm_camera_socket_create(my_obj->my_id, MM_CAMERA_SOCK_TYPE_UDP); //"/data/cam_socket%d"

  //    在qcamsvr_process_server_node_event的rc = pthread_create(&pme->cam_mctl_thread_id, NULL, cam_mctl_thread, pme);中有对应socket；

    /* set ctrl_fd to be the mem_mapping fd */

    rc =  mm_camera_util_s_ctrl(my_obj->ctrl_fd, MSM_V4L2_PID_MMAP_INST, 0);  // msm_mmap: pcam_inst->is_mem_map_inst = 1;

    rc = mm_camera_send_native_ctrl_cmd(my_obj,

                                        CAMERA_GET_CAPABILITIES,

                                        sizeof(cam_prop_t),

                                        (void *)& my_obj->properties);

//kernel中由ioctl分发到msm_server_control，通过下面函数，把消息通过queue传到proprietary用户空间

/* now send command to config thread in userspace, * and wait for results */

v4l2_event_queue(server_dev->server_command_queue.pvdev,  &v4l2_evt);

    mm_camera_poll_threads_init(my_obj);

    mm_camera_init_ch_stream_count(my_obj);

    for(i = 0; i < MM_CAMERA_CH_MAX; i++) {

        mm_camera_poll_thread_launch(my_obj,(mm_camera_channel_type_t)i); }

rc = mm_camera_poll_start(my_obj, poll_cb);

  pthread_create(&poll_cb->data.pid, NULL, mm_camera_poll_thread, (void *)poll_cb);

mm_camera_poll_sig_done(poll_cb); 

 ret = mm_camera_poll_fn(poll_cb); 

rc = poll(fds, poll_cb->data.num_fds, timeoutms); 

 if(rc > 0) {

 if((fds[0].revents & POLLIN) && (fds[0].revents & POLLRDNORM)) mm_camera_poll_proc_pipe(poll_cb);

  else mm_camera_poll_proc_msm(poll_cb, &fds[1]); }

 102 initDefaultParameters();    

    cam_ctrl_dimension_t mDimension;

    ret = native_set_parms(MM_CAMERA_PARM_DIMENSION,

                              sizeof(cam_ctrl_dimension_t), (void *) &mDimension);

    hasAutoFocusSupport();

  (MM_CAMERA_OK != cam_config_get_parm(mCameraId,  MM_CAMERA_PARM_MAXZOOM, &mMaxZoom)

MEDIA_DEVICE : 

struct media_device {

/* dev->driver_data points to this struct. */

struct device *dev;

struct media_devnode devnode;

char model[32];

char serial[40];

char bus_info[32];

u32 hw_revision;

u32 driver_version;

u32 entity_id;

struct list_head entities;

/* Protects the entities list */

spinlock_t lock;

/* Serializes graph operations. */

struct mutex graph_mutex;

int (*link_notify)(struct media_pad *source,

  struct media_pad *sink, u32 flags);

};

int __must_check media_device_register(struct media_device *mdev) 

{ 

mdev->devnode.fops = &media_device_fops;

mdev->devnode.parent = mdev->dev;

mdev->devnode.release = media_device_release;

ret = media_devnode_register(&mdev->devnode); 

}

int __must_check media_devnode_register(struct media_devnode *mdev)

{

ret = cdev_add(&mdev->cdev, MKDEV(MAJOR(media_dev_t), mdev->minor), 1);

  mdev->dev.bus = &media_bus_type;

        mdev->dev.devt = MKDEV(MAJOR(media_dev_t), mdev->minor); 

mdev->dev.release = media_devnode_release; 

ret = device_register(&mdev->dev);

}

重点有2处调用：

rc = media_device_register(&g_server_dev.media_dev);  

rc = media_device_register(&pcam->media_dev);        ///dev/media0 来num_camera 

// msm_sensor_register(struct v4l2_subdev *sensor_sd)

// rc = v4l2_device_register(pcam->v4l2_dev.dev, &pcam->v4l2_dev);

// /* register v4l2 video device to kernel as /dev/videoXX */

// D("video_register_device\n");

// rc = video_register_device(pvdev,VFL_TYPE_GRABBER,msm_camera_v4l2_nr);