int32_t mm_camera_set_parm(mm_camera_obj_t * my_obj,
    mm_camera_parm_t *parm)
{
    int32_t rc = -1;
    uint16_t len;
    CDBG("%s type =%d", __func__, parm->parm_type);
    switch(parm->parm_type) {
    case MM_CAMERA_PARM_OP_MODE:
        rc = mm_camera_util_set_op_mode(my_obj,
                        (mm_camera_op_mode_type_t *)parm->p_value);
        break;
    case MM_CAMERA_PARM_DIMENSION:
        rc = mm_camera_send_native_ctrl_cmd(my_obj,
                    CAMERA_SET_PARM_DIMENSION, sizeof(cam_ctrl_dimension_t), parm->p_value);
        if(rc != MM_CAMERA_OK) {
            CDBG("%s: mm_camera_send_native_ctrl_cmd err=%d\n", __func__, rc);
            break;
        }
        memcpy(&my_obj->dim, (cam_ctrl_dimension_t *)parm->p_value,
                     sizeof(cam_ctrl_dimension_t));
        CDBG("%s: dw=%d,dh=%d,vw=%d,vh=%d,pw=%d,ph=%d,tw=%d,th=%d,raw_w=%d,raw_h=%d\n",
                 __func__,
                 my_obj->dim.display_width,my_obj->dim.display_height,
                 my_obj->dim.video_width, my_obj->dim.video_height,
                 my_obj->dim.picture_width,my_obj->dim.picture_height,
                 my_obj->dim.ui_thumbnail_width,my_obj->dim.ui_thumbnail_height,
                 my_obj->dim.raw_picture_width,my_obj->dim.raw_picture_height);
        break;
    case MM_CAMERA_PARM_SNAPSHOT_BURST_NUM:
        CDBG("%s: Setting snapshot burst number: %d\n", __func__, *((int *)parm->p_value));
        my_obj->snap_burst_num_by_user = *((int *)parm->p_value);
        rc = MM_CAMERA_OK;
        break;
    case MM_CAMERA_PARM_CH_IMAGE_FMT:
        {
            mm_camera_ch_image_fmt_parm_t *fmt;
            fmt = (mm_camera_ch_image_fmt_parm_t *)parm->p_value;
            rc = mm_camera_ch_fn(my_obj,    fmt->ch_type,
                            MM_CAMERA_STATE_EVT_SET_FMT, fmt);
        }
        break;
    case MM_CAMERA_PARM_CHECK_AF_RETRY:
        return mm_camera_send_native_ctrl_cmd(my_obj,   CAMERA_CHECK_AF_RETRY,
                 0, (void *)NULL);
    case MM_CAMERA_PARM_LG_CAF_LOCK:
        return mm_camera_send_native_ctrl_cmd(my_obj,   CAMERA_SET_LG_CAF_LOCK,
                 0, (void *)NULL);
    case MM_CAMERA_PARM_INFORM_STARTPRVIEW:
        return mm_camera_send_native_ctrl_cmd(my_obj,   CAMERA_SET_INFORM_STARTPREVIEW,
                 0, (void *)NULL);
    default:
        rc = mm_camera_set_general_parm(my_obj, parm);
        break;
    }
    return rc;
}
Пример #2
0
int32_t mm_camera_action_stop(mm_camera_obj_t *my_obj, 
	mm_camera_ops_type_t opcode, void *parm)
{
	int32_t rc = -MM_CAMERA_E_GENERAL;
	mm_camera_channel_type_t ch_type;

	if(opcode == MM_CAMERA_OPS_FOCUS) {
		if(!parm) return rc;
		return mm_camera_send_native_ctrl_cmd(my_obj,	
					CAMERA_AUTO_FOCUS_CANCEL, 0, NULL);
	}

	ch_type = mm_camera_util_opcode_2_ch_type(my_obj, opcode);
	switch(my_obj->op_mode) {
	case MM_CAMERA_OP_MODE_CAPTURE:
		switch(opcode) {
		case MM_CAMERA_OPS_PREVIEW:
		case MM_CAMERA_OPS_SNAPSHOT:
		case MM_CAMERA_OPS_RAW:
			rc = mm_camera_ch_fn(my_obj, ch_type, 
							MM_CAMERA_STATE_EVT_STREAM_OFF, NULL);
			CDBG("%s:CAPTURE mode STREAMOFF rc=%d\n",__func__, rc);
			break;
		default:
			break;
		}
		break;
	case MM_CAMERA_OP_MODE_VIDEO:
		switch(opcode) {
		case MM_CAMERA_OPS_PREVIEW:
		case MM_CAMERA_OPS_VIDEO:
			rc = mm_camera_ch_fn(my_obj , ch_type, 
							MM_CAMERA_STATE_EVT_STREAM_OFF, NULL);
			CDBG("%s:VIDEO mode STREAMOFF rc=%d\n",__func__, rc);
			break;
		default:
			break;
		}
		break;
	case MM_CAMERA_OP_MODE_ZSL:
		switch(opcode) {
		case MM_CAMERA_OPS_PREVIEW:
		case MM_CAMERA_OPS_ZSL:
			rc = mm_camera_ch_fn(my_obj,	ch_type, 
							MM_CAMERA_STATE_EVT_STREAM_OFF, NULL);
			break;
		default:
			break;
		}
		break;
	default:
		break;
	}
	CDBG("%s:ch=%d\n",__func__, ch_type);
	return rc;
}
Пример #3
0
int32_t mm_camera_set_parm(mm_camera_obj_t * my_obj, 
	mm_camera_parm_t *parm)
{
	int32_t rc = -1;
	uint16_t len;
	switch(parm->parm_type) {
	case MM_CAMERA_PARM_OP_MODE:
		rc = mm_camera_util_set_op_mode(my_obj, 
						(mm_camera_op_mode_type_t *)parm->p_value);
		break;
	case MM_CAMERA_PARM_DIMENSION:
		rc = mm_camera_send_native_ctrl_cmd(my_obj,	
					CAMERA_SET_PARM_DIMENSION, sizeof(cam_ctrl_dimension_t), parm->p_value);
		if(rc != MM_CAMERA_OK) {
			CDBG("%s: mm_camera_send_native_ctrl_cmd err=%d\n", __func__, rc);
			break;
		}
		memcpy(&my_obj->dim, (cam_ctrl_dimension_t *)parm->p_value, 
					 sizeof(cam_ctrl_dimension_t));
		CDBG("%s: dw=%d,dh=%d,vw=%d,vh=%d,pw=%d,ph=%d,tw=%d,th=%d,raw_w=%d,raw_h=%d\n",
				 __func__,
				 my_obj->dim.display_width,my_obj->dim.display_height,
				 my_obj->dim.video_width,my_obj->dim.video_height,
				 my_obj->dim.picture_width,my_obj->dim.picture_height,
				 my_obj->dim.ui_thumbnail_width,my_obj->dim.ui_thumbnail_height,
				 my_obj->dim.raw_picture_width,my_obj->dim.raw_picture_height);
		break;
	case MM_CAMERA_PARM_SNAPSHOT_BURST_NUM:
		break;
	case MM_CAMERA_PARM_CH_IMAGE_FMT:
		{
			mm_camera_ch_image_fmt_parm_t *fmt;
			fmt = (mm_camera_ch_image_fmt_parm_t *)parm->p_value;
			rc = mm_camera_ch_fn(my_obj,	fmt->ch_type, 
							MM_CAMERA_STATE_EVT_SET_FMT, fmt);
		}
		break;
	default:
		rc = mm_camera_set_general_parm(my_obj, parm);
		break;
	}
	return rc;
}
Пример #4
0
int32_t mm_camera_get_parm(mm_camera_obj_t * my_obj, 
																								mm_camera_parm_t *parm)
{
	int32_t rc = MM_CAMERA_OK;

	switch(parm->parm_type) {
	case MM_CAMERA_PARM_DIMENSION:
		memcpy(parm->p_value, &my_obj->dim, sizeof(my_obj->dim));
		CDBG("%s: dw=%d,dh=%d,vw=%d,vh=%d,pw=%d,ph=%d,tw=%d,th=%d,ovx=%x,ovy=%d,opx=%d,opy=%d\n",
				 __func__,
				 my_obj->dim.display_width,my_obj->dim.display_height,
				 my_obj->dim.video_width,my_obj->dim.video_height,
				 my_obj->dim.picture_width,my_obj->dim.picture_height,
				 my_obj->dim.ui_thumbnail_width,my_obj->dim.ui_thumbnail_height,
				 my_obj->dim.orig_video_width,my_obj->dim.orig_video_height,
				 my_obj->dim.orig_picture_width,my_obj->dim.orig_picture_height);
		break;
	case MM_CAMERA_PARM_FOCAL_LENGTH:
		return mm_camera_send_native_ctrl_cmd(my_obj,	CAMERA_GET_PARM_FOCAL_LENGTH,
													 sizeof(focus_distances_info_t), (void *)parm->p_value);
	case MM_CAMERA_PARM_FOCUS_DISTANCES:
		return mm_camera_send_native_ctrl_cmd(my_obj,	CAMERA_GET_PARM_FOCUS_DISTANCES,
													 sizeof(focus_distances_info_t), (void *)parm->p_value);
  case MM_CAMERA_PARM_QUERY_FALSH4SNAP:
		return mm_camera_send_native_ctrl_cmd(my_obj,	CAMERA_QUERY_FLASH_FOR_SNAPSHOT,
													 sizeof(int), (void *)parm->p_value);
  case MM_CAMERA_PARM_3D_FRAME_FORMAT:
		return mm_camera_send_native_ctrl_cmd(my_obj,	CAMERA_GET_PARM_3D_FRAME_FORMAT,
													 sizeof(camera_3d_frame_t), (void *)parm->p_value); 
	case MM_CAMERA_PARM_MAXZOOM:
		return mm_camera_send_native_ctrl_cmd(my_obj,	CAMERA_GET_PARM_MAXZOOM,
													 sizeof(int), (void *)parm->p_value);
	case MM_CAMERA_PARM_ZOOM_RATIO: {
		mm_camera_zoom_tbl_t *tbl = (mm_camera_zoom_tbl_t *)parm->p_value; 
		return mm_camera_send_native_ctrl_cmd(my_obj,	CAMERA_GET_PARM_ZOOMRATIOS,
													 sizeof(int16_t)*tbl->size, tbl->zoom_ratio_tbl);
	}
	case MM_CAMERA_PARM_OP_MODE:
		*((mm_camera_op_mode_type_t *)parm->p_value) = my_obj->op_mode;
		break;
	default:
		/* needs to add more implementation */
		rc = -1;
		break;
	}
	return rc;
}
int32_t mm_camera_open(mm_camera_obj_t *my_obj,
                    mm_camera_op_mode_type_t op_mode)
{
    char dev_name[MM_CAMERA_DEV_NAME_LEN];
    int32_t rc = MM_CAMERA_OK;
    int8_t n_try=MM_CAMERA_DEV_OPEN_TRIES;
    uint8_t sleep_msec=MM_CAMERA_DEV_OPEN_RETRY_SLEEP;
    uint8_t i;

	CDBG("%s:  begin\n", __func__);

    if(my_obj->op_mode != MM_CAMERA_OP_MODE_NOTUSED) {
        CDBG("%s: not allowed in existing op mode %d\n",
                 __func__, my_obj->op_mode);
        return -MM_CAMERA_E_INVALID_OPERATION;
    }
    if(op_mode >= MM_CAMERA_OP_MODE_MAX) {
        CDBG("%s: invalid input %d\n",
                 __func__, op_mode);
        return -MM_CAMERA_E_INVALID_INPUT;
    }
    snprintf(dev_name, sizeof(dev_name), "/dev/%s", mm_camera_util_get_dev_name(my_obj));
    //rc = mm_camera_dev_open(&my_obj->ctrl_fd, dev_name);
	CDBG("%s: mm_camera_dev_open rc = %d\n", __func__, rc);

    do{
        n_try--;
        my_obj->ctrl_fd = open(dev_name,O_RDWR | O_NONBLOCK);
		ALOGV("%s:  ctrl_fd = %d", __func__, my_obj->ctrl_fd);
        ALOGV("Errno:%d",errno);
        if((my_obj->ctrl_fd > 0) || (errno != EIO) || (n_try <= 0 )) {
			ALOGV("%s:  opened, break out while loop", __func__);

            break;
		}
        CDBG("%s:failed with I/O error retrying after %d milli-seconds",
             __func__,sleep_msec);
        usleep(sleep_msec*1000);
    }while(n_try>0);

	ALOGV("%s:  after while loop", __func__);
    if (my_obj->ctrl_fd <= 0) {
        CDBG("%s: cannot open control fd of '%s' Errno = %d\n",
                 __func__, mm_camera_util_get_dev_name(my_obj),errno);
        return -MM_CAMERA_E_GENERAL;
    }
	ALOGV("%s:  2\n", __func__);

    /* open domain socket*/
    n_try=MM_CAMERA_DEV_OPEN_TRIES;
    do{
        n_try--;
        my_obj->ds_fd = mm_camera_socket_create(my_obj->my_id, MM_CAMERA_SOCK_TYPE_UDP); // TODO: UDP for now, change to TCP
        ALOGV("%s:  ds_fd = %d", __func__, my_obj->ds_fd);
        ALOGV("Errno:%d",errno);
        if((my_obj->ds_fd > 0) || (n_try <= 0 )) {
            ALOGV("%s:  opened, break out while loop", __func__);
            break;
        }
        CDBG("%s:failed with I/O error retrying after %d milli-seconds",
             __func__,sleep_msec);
        usleep(sleep_msec*1000);
    }while(n_try>0);

    ALOGV("%s:  after while loop for domain socket open", __func__);
    if (my_obj->ds_fd <= 0) {
        CDBG_ERROR("%s: cannot open domain socket fd of '%s' Errno = %d\n",
                 __func__, mm_camera_util_get_dev_name(my_obj),errno);
        close(my_obj->ctrl_fd);
        my_obj->ctrl_fd = -1;
        return -MM_CAMERA_E_GENERAL;
    }

    /* 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);
    if (rc != MM_CAMERA_OK) {
        CDBG_ERROR("error: ioctl VIDIOC_S_CTRL MSM_V4L2_PID_MMAP_INST failed: %s\n",
        strerror(errno));
        close(my_obj->ctrl_fd);
        close(my_obj->ds_fd);
        my_obj->ctrl_fd = -1;
        my_obj->ds_fd = -1;
        return -MM_CAMERA_E_GENERAL;
    }
    if(op_mode != MM_CAMERA_OP_MODE_NOTUSED)
        rc =  mm_camera_util_s_ctrl(my_obj->ctrl_fd,
                            MSM_V4L2_PID_CAM_MODE, op_mode);
    if(!rc) {
        my_obj->op_mode = op_mode;
        my_obj->current_mode = CAMERA_MODE_2D; /* set geo mode to 2D by default */
    }

    /* get camera capabilities */
    memset(&my_obj->properties, 0, sizeof(cam_prop_t));
    rc = mm_camera_send_native_ctrl_cmd(my_obj,
                                        CAMERA_GET_CAPABILITIES,
                                        sizeof(cam_prop_t),
                                        (void *)& my_obj->properties);
    if (rc != MM_CAMERA_OK) {
        CDBG_ERROR("%s: cannot get camera capabilities\n", __func__);
        close(my_obj->ctrl_fd);
        close(my_obj->ds_fd);
        my_obj->ctrl_fd = -1;
        my_obj->ds_fd = -1;
        return -MM_CAMERA_E_GENERAL;
    }

    mm_camera_poll_threads_init(my_obj);
    mm_camera_init_ch_stream_count(my_obj);
    CDBG("%s : Launch Threads in Cam Open",__func__);
    for(i = 0; i < MM_CAMERA_CH_MAX; i++) {
        mm_camera_poll_thread_launch(my_obj,(mm_camera_channel_type_t)i);
    }
    CDBG("%s: '%s', ctrl_fd=%d,op_mode=%d,rc=%d\n",
             __func__, dev_name, my_obj->ctrl_fd, my_obj->op_mode, rc);
    return rc;
}
int32_t mm_camera_action_start(mm_camera_obj_t *my_obj,
                            mm_camera_ops_type_t opcode, void *parm)
{
    int32_t rc = -MM_CAMERA_E_GENERAL;
    int send_on_off_evt = 1;
    mm_camera_channel_type_t ch_type;
    switch(opcode) {
    case MM_CAMERA_OPS_FOCUS: {
        if(!parm) return rc;
        if(0 > mm_camera_send_native_ctrl_cmd(my_obj,
          CAMERA_SET_PARM_AUTO_FOCUS,
          sizeof(isp3a_af_mode_t), parm))
          mm_camera_send_af_failed_event(my_obj);
        return MM_CAMERA_OK;
    }
    case MM_CAMERA_OPS_GET_BUFFERED_FRAME: {
        mm_camera_ops_parm_get_buffered_frame_t *tmp =
            (mm_camera_ops_parm_get_buffered_frame_t *)parm;
        rc = mm_camera_ch_fn(my_obj, tmp->ch_type,
                 MM_CAMERA_STATE_EVT_DISPATCH_BUFFERED_FRAME, NULL);
        return rc;
    }
    default:
        break;
    }
    ch_type = mm_camera_util_opcode_2_ch_type(my_obj, opcode);
    CDBG("%s:ch=%d,op_mode=%d,opcode=%d\n",
        __func__,ch_type,my_obj->op_mode,opcode);
    switch(my_obj->op_mode) {
    case MM_CAMERA_OP_MODE_ZSL:
    case MM_CAMERA_OP_MODE_CAPTURE:
        switch(opcode) {
        case MM_CAMERA_OPS_PREVIEW:
        case MM_CAMERA_OPS_SNAPSHOT:
        case MM_CAMERA_OPS_ZSL:
        case MM_CAMERA_OPS_RAW:
            rc = mm_camera_ch_fn(my_obj, ch_type,
                    MM_CAMERA_STATE_EVT_STREAM_ON, NULL);
            break;
        default:
            break;
        }
        break;
    case MM_CAMERA_OP_MODE_VIDEO:
        switch(opcode) {
        case MM_CAMERA_OPS_PREVIEW:
        case MM_CAMERA_OPS_VIDEO:
        case MM_CAMERA_OPS_SNAPSHOT:
            rc = mm_camera_ch_fn(my_obj,    ch_type,
                    MM_CAMERA_STATE_EVT_STREAM_ON, NULL);
            CDBG("%s: op_mode=%d, ch %d, rc=%d\n",
                __func__, MM_CAMERA_OP_MODE_VIDEO, ch_type ,rc);
            break;
        case MM_CAMERA_OPS_PREPARE_SNAPSHOT:
            send_on_off_evt = 0;
            rc = mm_camera_send_native_ctrl_timeout_cmd(my_obj,CAMERA_PREPARE_SNAPSHOT, 0, NULL, 2000);
            CDBG("%s: prepare snapshot done opcode = %d, rc= %d\n", __func__, opcode, rc);
            break;
        default:
            break;
        }
        break;
    default:
        break;
    }
    CDBG("%s: ch=%d,op_mode=%d,opcode=%d\n", __func__, ch_type,
      my_obj->op_mode, opcode);
    if(send_on_off_evt)
      rc = mm_camera_send_ch_on_off_event(my_obj,ch_type,MM_CAMERA_CH_EVT_STREAMING_ON);
    return rc;
}
int32_t mm_camera_get_parm(mm_camera_obj_t * my_obj,
                            mm_camera_parm_t *parm)
{
    int32_t rc = MM_CAMERA_OK;

    switch(parm->parm_type) {
    case MM_CAMERA_PARM_CROP:
      return rc = mm_camera_ch_fn(my_obj,
                    ((mm_camera_ch_crop_t *)parm->p_value)->ch_type,
                    MM_CAMERA_STATE_EVT_GET_CROP, parm->p_value);
      break;
    case MM_CAMERA_PARM_DIMENSION:
        memcpy(parm->p_value, &my_obj->dim, sizeof(my_obj->dim));
        CDBG("%s: dw=%d,dh=%d,vw=%d,vh=%d,pw=%d,ph=%d,tw=%d,th=%d,ovx=%x,ovy=%d,opx=%d,opy=%d, m_fmt=%d, t_ftm=%d\n",
                 __func__,
                 my_obj->dim.display_width,my_obj->dim.display_height,
                 my_obj->dim.video_width,my_obj->dim.video_height,
                 my_obj->dim.picture_width,my_obj->dim.picture_height,
                 my_obj->dim.ui_thumbnail_width,my_obj->dim.ui_thumbnail_height,
                 my_obj->dim.orig_video_width,my_obj->dim.orig_video_height,
                 my_obj->dim.orig_picture_width,my_obj->dim.orig_picture_height,
                 my_obj->dim.main_img_format, my_obj->dim.thumb_format);
        break;
    case MM_CAMERA_PARM_MAX_PICTURE_SIZE: {
        mm_camera_dimension_t *dim =
            (mm_camera_dimension_t *)parm->p_value;
        dim->height = my_obj->properties.max_pict_height;
        dim->width = my_obj->properties.max_pict_width;
        CDBG("%s: Max Picture Size: %d X %d\n", __func__,
             dim->width, dim->height);
    }
        break;
    case MM_CAMERA_PARM_RAW_SNAPSHOT_FMT:
        *((cam_format_t *)parm->p_value) = my_obj->properties.pxlcode;
        break;
    case MM_CAMERA_PARM_PREVIEW_FORMAT:
        *((int *)parm->p_value) = my_obj->properties.preview_format;
        break;
    case MM_CAMERA_PARM_PREVIEW_SIZES_CNT:
        *((int *)parm->p_value) = my_obj->properties.preview_sizes_cnt;
        break;
    case MM_CAMERA_PARM_VIDEO_SIZES_CNT:
        *((int *)parm->p_value) = my_obj->properties.video_sizes_cnt;
        break;
    case MM_CAMERA_PARM_THUMB_SIZES_CNT:
        *((int *)parm->p_value) = my_obj->properties.thumb_sizes_cnt;
        break;
    case MM_CAMERA_PARM_HFR_SIZES_CNT:
        *((int *)parm->p_value) = my_obj->properties.hfr_sizes_cnt;
        break;
    case MM_CAMERA_PARM_HFR_FRAME_SKIP:
        *((int *)parm->p_value) = my_obj->properties.hfr_frame_skip;
        break;
    case MM_CAMERA_PARM_DEFAULT_PREVIEW_WIDTH:
        *((int *)parm->p_value) = my_obj->properties.default_preview_width;
        break;
    case MM_CAMERA_PARM_DEFAULT_PREVIEW_HEIGHT:
        *((int *)parm->p_value) = my_obj->properties.default_preview_height;
        break;
    case MM_CAMERA_PARM_BESTSHOT_RECONFIGURE:
        *((int *)parm->p_value) = my_obj->properties.bestshot_reconfigure;
        break;
    case MM_CAMERA_PARM_MAX_PREVIEW_SIZE: {
        mm_camera_dimension_t *dim =
            (mm_camera_dimension_t *)parm->p_value;
        dim->height = my_obj->properties.max_preview_height;
        dim->width = my_obj->properties.max_preview_width;
        CDBG("%s: Max Preview Size: %d X %d\n", __func__,
             dim->width, dim->height);
    }
        break;
    case MM_CAMERA_PARM_MAX_VIDEO_SIZE: {
        mm_camera_dimension_t *dim =
            (mm_camera_dimension_t *)parm->p_value;
        dim->height = my_obj->properties.max_video_height;
        dim->width = my_obj->properties.max_video_width;
        CDBG("%s: Max Video Size: %d X %d\n", __func__,
             dim->width, dim->height);
    }
        break;
    case MM_CAMERA_PARM_MAX_HFR_MODE:
        return mm_camera_send_native_ctrl_cmd(my_obj, CAMERA_GET_PARM_MAX_HFR_MODE,
                sizeof(camera_hfr_mode_t), (void *)parm->p_value);
    case MM_CAMERA_PARM_FOCAL_LENGTH:
        return mm_camera_send_native_ctrl_cmd(my_obj, CAMERA_GET_PARM_FOCAL_LENGTH,
                     sizeof(focus_distances_info_t), (void *)parm->p_value);
    case MM_CAMERA_PARM_HORIZONTAL_VIEW_ANGLE:
        return mm_camera_send_native_ctrl_cmd(my_obj,   CAMERA_GET_PARM_HORIZONTAL_VIEW_ANGLE,
                                                     sizeof(focus_distances_info_t), (void *)parm->p_value);
    case MM_CAMERA_PARM_VERTICAL_VIEW_ANGLE:
        return mm_camera_send_native_ctrl_cmd(my_obj,   CAMERA_GET_PARM_VERTICAL_VIEW_ANGLE,
                                                     sizeof(focus_distances_info_t), (void *)parm->p_value);
    case MM_CAMERA_PARM_FOCUS_DISTANCES:
        return mm_camera_send_native_ctrl_cmd(my_obj,   CAMERA_GET_PARM_FOCUS_DISTANCES,
                     sizeof(focus_distances_info_t), (void *)parm->p_value);
  case MM_CAMERA_PARM_QUERY_FALSH4SNAP:
        return mm_camera_send_native_ctrl_cmd(my_obj,   CAMERA_QUERY_FLASH_FOR_SNAPSHOT,
                     sizeof(int), (void *)parm->p_value);
  case MM_CAMERA_PARM_3D_FRAME_FORMAT:
        return mm_camera_send_native_ctrl_cmd(my_obj,   CAMERA_GET_PARM_3D_FRAME_FORMAT,
                     sizeof(camera_3d_frame_t), (void *)parm->p_value);
    case MM_CAMERA_PARM_MAXZOOM:
        return mm_camera_send_native_ctrl_cmd(my_obj,   CAMERA_GET_PARM_MAXZOOM,
                     sizeof(int), (void *)parm->p_value);
    case MM_CAMERA_PARM_ZOOM_RATIO: {
        mm_camera_zoom_tbl_t *tbl = (mm_camera_zoom_tbl_t *)parm->p_value;
        return mm_camera_send_native_ctrl_cmd(my_obj,   CAMERA_GET_PARM_ZOOMRATIOS,
                     sizeof(int16_t)*tbl->size, tbl->zoom_ratio_tbl);
    }
    case MM_CAMERA_PARM_DEF_PREVIEW_SIZES: {
        default_sizes_tbl_t *tbl = (default_sizes_tbl_t*)parm->p_value;
        return mm_camera_send_native_ctrl_cmd(my_obj, CAMERA_GET_PARM_DEF_PREVIEW_SIZES,
                     sizeof(struct camera_size_type)*tbl->tbl_size, tbl->sizes_tbl);
    }
    case MM_CAMERA_PARM_DEF_VIDEO_SIZES: {
        default_sizes_tbl_t *tbl = (default_sizes_tbl_t*)parm->p_value;
        return mm_camera_send_native_ctrl_cmd(my_obj, CAMERA_GET_PARM_DEF_VIDEO_SIZES,
                     sizeof(struct camera_size_type)*tbl->tbl_size, tbl->sizes_tbl);
    }
    case MM_CAMERA_PARM_DEF_THUMB_SIZES: {
        default_sizes_tbl_t *tbl = (default_sizes_tbl_t*)parm->p_value;
        return mm_camera_send_native_ctrl_cmd(my_obj, CAMERA_GET_PARM_DEF_THUMB_SIZES,
                     sizeof(struct camera_size_type)*tbl->tbl_size, tbl->sizes_tbl);
    }
    case MM_CAMERA_PARM_DEF_HFR_SIZES:{
        default_sizes_tbl_t *tbl = (default_sizes_tbl_t*)parm->p_value;
        return mm_camera_send_native_ctrl_cmd(my_obj, CAMERA_GET_PARM_DEF_HFR_SIZES,
                     sizeof(struct camera_size_type)*tbl->tbl_size, tbl->sizes_tbl);
    }
    case MM_CAMERA_PARM_OP_MODE:
        *((mm_camera_op_mode_type_t *)parm->p_value) = my_obj->op_mode;
        break;
    case MM_CAMERA_PARM_SNAPSHOT_BURST_NUM:
        *((int *)parm->p_value) = my_obj->snap_burst_num_by_user;
        break;
    case MM_CAMERA_PARM_VFE_OUTPUT_ENABLE:
        *((int *)parm->p_value) = my_obj->properties.vfe_output_enable;
        break;
    case MM_CAMERA_PARM_LUX_IDX:
        CDBG("%s: MM_CAMERA_PARM_LUX_IDX\n", __func__);
        return mm_camera_send_native_ctrl_cmd(my_obj, CAMERA_GET_PARM_LUX_IDX,
                     sizeof(int), (void *)parm->p_value);
    case MM_CAMERA_PARM_MAX_NUM_FACES_DECT:
        return mm_camera_send_native_ctrl_cmd(my_obj, CAMERA_GET_MAX_NUM_FACES_DECT,
                     sizeof(int), (void *)parm->p_value);
    case MM_CAMERA_PARM_FACIAL_FEATURE_INFO:
        return mm_camera_send_native_ctrl_cmd(my_obj, CAMERA_GET_FACIAL_FEATURE_INFO,
                     sizeof(int), (void *)parm->p_value);
    case MM_CAMERA_PARM_HDR:
        rc = mm_camera_send_native_ctrl_cmd(my_obj,
                  CAMERA_GET_PARM_HDR, sizeof(exp_bracketing_t), (void *)parm->p_value);
        //my_obj->channel_interface_mask = *((exp_bracketing_t *)(parm->p_value));
        break;
    case MM_CAMERA_GET_PARM_LOW_LIGHT_FOR_ZSL:
        return mm_camera_send_native_ctrl_cmd(my_obj,   CAMERA_GET_PARM_LOW_LIGHT_FOR_ZSL,
                     sizeof(aec_info_for_flash_t), (void *)parm->p_value);

    case MM_CAMERA_PARM_GET_AF_STATUS:
        return mm_camera_send_native_ctrl_cmd(my_obj,   CAMERA_GET_PARM_AF_STATUS,
                     sizeof(af_actuator_status_t), (void *)parm->p_value);

    case MM_CAMERA_PARM_F_NUMBER:
        return mm_camera_send_native_ctrl_cmd(my_obj,   CAMERA_GET_PARM_F_NUMBER,
                     sizeof(float), (void *)parm->p_value);
    default:
        /* needs to add more implementation */
        rc = -1;
        break;
    }
    return rc;
}
int32_t mm_camera_set_general_parm(mm_camera_obj_t * my_obj, mm_camera_parm_t *parm)
{
    int rc = -MM_CAMERA_E_NOT_SUPPORTED;
    int isZSL =0;

    switch(parm->parm_type)  {
    case MM_CAMERA_PARM_EXPOSURE:
        return mm_camera_util_s_ctrl(my_obj->ctrl_fd,
                                                                        MSM_V4L2_PID_EXP_METERING,
                                                                            *((int *)(parm->p_value)));
    case MM_CAMERA_PARM_SHARPNESS:
        return mm_camera_util_s_ctrl(my_obj->ctrl_fd, V4L2_CID_SHARPNESS,
                                                                            *((int *)(parm->p_value)));
    case MM_CAMERA_PARM_CONTRAST:
        return mm_camera_util_s_ctrl(my_obj->ctrl_fd, V4L2_CID_CONTRAST,
                                                                            *((int *)(parm->p_value)));
    case MM_CAMERA_PARM_SATURATION:
        return mm_camera_util_s_ctrl(my_obj->ctrl_fd, V4L2_CID_SATURATION,
                                                                            *((int *)(parm->p_value)));
    case MM_CAMERA_PARM_BRIGHTNESS:
        return mm_camera_util_s_ctrl(my_obj->ctrl_fd, V4L2_CID_BRIGHTNESS,
                                                                            *((int *)(parm->p_value)));
    case MM_CAMERA_PARM_WHITE_BALANCE:
        return mm_camera_ctrl_set_whitebalance (my_obj, *((int *)(parm->p_value)));
    case MM_CAMERA_PARM_ISO:
        return mm_camera_util_s_ctrl(my_obj->ctrl_fd, MSM_V4L2_PID_ISO,
                                                                            *((int *)(parm->p_value)));
    case MM_CAMERA_PARM_ZOOM:
        return mm_camera_util_s_ctrl(my_obj->ctrl_fd, V4L2_CID_ZOOM_ABSOLUTE,
                                                                            *((int *)(parm->p_value)));
    case MM_CAMERA_PARM_LUMA_ADAPTATION:
        return mm_camera_util_s_ctrl(my_obj->ctrl_fd, MSM_V4L2_PID_LUMA_ADAPTATION,
                                                                            *((int *)(parm->p_value)));
    case MM_CAMERA_PARM_ANTIBANDING:
        return mm_camera_ctrl_set_antibanding (my_obj, *((int *)(parm->p_value)));
    case MM_CAMERA_PARM_CONTINUOUS_AF:
        return mm_camera_ctrl_set_auto_focus(my_obj, *((int *)(parm->p_value)));
    case MM_CAMERA_PARM_HJR:
        return mm_camera_util_s_ctrl(my_obj->ctrl_fd, MSM_V4L2_PID_HJR, *((int *)(parm->p_value)));
    case MM_CAMERA_PARM_EFFECT:
        return mm_camera_ctrl_set_specialEffect (my_obj, *((int *)(parm->p_value)));
    case MM_CAMERA_PARM_FPS:
        return mm_camera_send_native_ctrl_cmd(my_obj,
                    CAMERA_SET_PARM_FPS, sizeof(uint32_t), (void *)parm->p_value);
    case MM_CAMERA_PARM_FPS_MODE:
        return mm_camera_send_native_ctrl_cmd(my_obj,
                    CAMERA_SET_FPS_MODE, sizeof(int32_t), (void *)parm->p_value);
    case MM_CAMERA_PARM_EXPOSURE_COMPENSATION:
        return mm_camera_send_native_ctrl_cmd(my_obj,
                    CAMERA_SET_PARM_EXPOSURE_COMPENSATION, sizeof(int32_t), (void *)parm->p_value);
    case MM_CAMERA_PARM_LED_MODE:
        return mm_camera_send_native_ctrl_cmd(my_obj,
                    CAMERA_SET_PARM_LED_MODE, sizeof(int32_t), (void *)parm->p_value);
    case MM_CAMERA_PARM_ROLLOFF:
        return mm_camera_send_native_ctrl_cmd(my_obj,
                    CAMERA_SET_PARM_ROLLOFF, sizeof(int32_t), (void *)parm->p_value);
    case MM_CAMERA_PARM_MODE:
        my_obj->current_mode = *((camera_mode_t *)parm->p_value);
        break;
    case MM_CAMERA_PARM_FOCUS_RECT:
        return mm_camera_send_native_ctrl_cmd(my_obj,
                    CAMERA_SET_PARM_FOCUS_RECT, sizeof(int32_t), (void *)parm->p_value);
    case MM_CAMERA_PARM_AEC_ROI:
        return mm_camera_send_native_ctrl_cmd(my_obj,
                    CAMERA_SET_PARM_AEC_ROI, sizeof(cam_set_aec_roi_t), (void *)parm->p_value);
    case MM_CAMERA_PARM_AF_ROI:
        return mm_camera_send_native_ctrl_cmd(my_obj,
                    CAMERA_SET_PARM_AF_ROI, sizeof(roi_info_t), (void *)parm->p_value);
    case MM_CAMERA_PARM_FOCUS_MODE:
        return mm_camera_send_native_ctrl_cmd(my_obj,
                    CAMERA_SET_PARM_AF_MODE, sizeof(int32_t), (void *)parm->p_value);
#if 0 //to be enabled later: @punits
    case MM_CAMERA_PARM_AF_MTR_AREA:
        return mm_camera_send_native_ctrl_cmd(my_obj,
                    CAMERA_SET_PARM_AF_MTR_AREA, sizeof(af_mtr_area_t), (void *)parm->p_value);*/
    case MM_CAMERA_PARM_AEC_MTR_AREA:
        return mm_camera_send_native_ctrl_cmd(my_obj,
                    CAMERA_SET_AEC_MTR_AREA, sizeof(aec_mtr_area_t), (void *)parm->p_value);
#endif
    case MM_CAMERA_PARM_CAF_ENABLE:
        return mm_camera_send_native_ctrl_cmd(my_obj,
                    CAMERA_SET_PARM_CAF, sizeof(uint32_t), (void *)parm->p_value);
    case MM_CAMERA_PARM_BESTSHOT_MODE:
        CDBG("%s : MM_CAMERA_PARM_BESTSHOT_MODE value : %d",__func__,*((int *)(parm->p_value)));
        return mm_camera_send_native_ctrl_cmd(my_obj,
                    CAMERA_SET_PARM_BESTSHOT_MODE, sizeof(int32_t), (void *)parm->p_value);
        break;
    case MM_CAMERA_PARM_VIDEO_DIS:
        return mm_camera_send_native_ctrl_cmd(my_obj,
                    CAMERA_SET_VIDEO_DIS_PARAMS, sizeof(video_dis_param_ctrl_t), (void *)parm->p_value);
    case MM_CAMERA_PARM_VIDEO_ROT:
        return mm_camera_send_native_ctrl_cmd(my_obj,
                    CAMERA_SET_VIDEO_ROT_PARAMS, sizeof(video_rotation_param_ctrl_t), (void *)parm->p_value);
    case MM_CAMERA_PARM_SCE_FACTOR:
        return mm_camera_send_native_ctrl_cmd(my_obj,
                    CAMERA_SET_SCE_FACTOR, sizeof(int32_t), (void *)parm->p_value);
    case MM_CAMERA_PARM_FD:
        return mm_camera_send_native_ctrl_cmd(my_obj,
                    CAMERA_SET_PARM_FD, sizeof(fd_set_parm_t), (void *)parm->p_value);
    case MM_CAMERA_PARM_AEC_LOCK:
        return mm_camera_send_native_ctrl_cmd(my_obj,
                    CAMERA_SET_AEC_LOCK, sizeof(int32_t), (void *)parm->p_value);
    case MM_CAMERA_PARM_AWB_LOCK:
        return mm_camera_send_native_ctrl_cmd(my_obj,   CAMERA_SET_AWB_LOCK,
                                                     sizeof(int32_t), (void *)parm->p_value);
    case MM_CAMERA_PARM_MCE:
        return mm_camera_send_native_ctrl_cmd(my_obj,   CAMERA_SET_PARM_MCE,
                                                     sizeof(int32_t), (void *)parm->p_value);
    case MM_CAMERA_PARM_HORIZONTAL_VIEW_ANGLE:
        return mm_camera_send_native_ctrl_cmd(my_obj,   CAMERA_GET_PARM_HORIZONTAL_VIEW_ANGLE,
                                                     sizeof(focus_distances_info_t), (void *)parm->p_value);
    case MM_CAMERA_PARM_VERTICAL_VIEW_ANGLE:
        return mm_camera_send_native_ctrl_cmd(my_obj,   CAMERA_GET_PARM_VERTICAL_VIEW_ANGLE,
                                                     sizeof(focus_distances_info_t), (void *)parm->p_value);
    case MM_CAMERA_PARM_RESET_LENS_TO_INFINITY:
        return mm_camera_send_native_ctrl_cmd(my_obj,
                            CAMERA_SET_PARM_RESET_LENS_TO_INFINITY,
                            0, NULL);
    case MM_CAMERA_PARM_SNAPSHOTDATA:
        return mm_camera_send_native_ctrl_cmd(my_obj,   CAMERA_GET_PARM_SNAPSHOTDATA,
                                                     sizeof(snapshotData_info_t), (void *)parm->p_value);
    case MM_CAMERA_PARM_HFR:
        return mm_camera_send_native_ctrl_cmd(my_obj,
                    CAMERA_SET_PARM_HFR, sizeof(int32_t), (void *)parm->p_value);
    case MM_CAMERA_PARM_REDEYE_REDUCTION:
        return mm_camera_send_native_ctrl_cmd(my_obj,
                    CAMERA_SET_REDEYE_REDUCTION, sizeof(int32_t), (void *)parm->p_value);
    case MM_CAMERA_PARM_WAVELET_DENOISE:
        return mm_camera_send_native_ctrl_cmd(my_obj,
                    CAMERA_SET_PARM_WAVELET_DENOISE, sizeof(denoise_param_t), (void *)parm->p_value);
    case MM_CAMERA_PARM_3D_DISPLAY_DISTANCE:
        return mm_camera_send_native_ctrl_cmd(my_obj,
                    CAMERA_SET_PARM_3D_DISPLAY_DISTANCE, sizeof(float), (void *)parm->p_value);
    case MM_CAMERA_PARM_3D_VIEW_ANGLE:
        return mm_camera_send_native_ctrl_cmd(my_obj,
                    CAMERA_SET_PARM_3D_VIEW_ANGLE, sizeof(uint32_t), (void *)parm->p_value);
    case MM_CAMERA_PARM_ZOOM_RATIO:
        break;
    case MM_CAMERA_PARM_HISTOGRAM:
        return mm_camera_send_native_ctrl_cmd(my_obj,
                    CAMERA_SET_PARM_HISTOGRAM, sizeof(int8_t), (void *)parm->p_value);
    case MM_CAMERA_PARM_JPEG_ROTATION:
        if(my_obj->op_mode == MM_CAMERA_OP_MODE_ZSL){
           isZSL =1;
        }
        mm_jpeg_encoder_setRotation(*((int *)parm->p_value),isZSL);
        return MM_CAMERA_OK;

    case MM_CAMERA_PARM_ASD_ENABLE:
      return mm_camera_send_native_ctrl_cmd(my_obj,
                  CAMERA_SET_ASD_ENABLE, sizeof(uint32_t), (void *)parm->p_value);

    case MM_CAMERA_PARM_RECORDING_HINT:
      return mm_camera_send_native_ctrl_cmd(my_obj,
                  CAMERA_SET_RECORDING_HINT, sizeof(uint32_t), (void *)parm->p_value);

    case MM_CAMERA_PARM_PREVIEW_FORMAT:
      return mm_camera_send_native_ctrl_cmd(my_obj,
                  CAMERA_SET_PARM_PREVIEW_FORMAT, sizeof(uint32_t), (void *)parm->p_value);

    case MM_CAMERA_PARM_DIS_ENABLE:
      return mm_camera_send_native_ctrl_cmd(my_obj,
                  CAMERA_SET_DIS_ENABLE, sizeof(uint32_t), (void *)parm->p_value);

    case MM_CAMERA_PARM_FULL_LIVESHOT: {
      my_obj->full_liveshot = *((int *)(parm->p_value));
      return mm_camera_send_native_ctrl_cmd(my_obj,
                  CAMERA_SET_FULL_LIVESHOT, sizeof(uint32_t), (void *)parm->p_value);
    }

    case MM_CAMERA_PARM_LOW_POWER_MODE:
      return mm_camera_send_native_ctrl_cmd(my_obj,
                  CAMERA_SET_LOW_POWER_MODE, sizeof(uint32_t), (void *)parm->p_value);

    case MM_CAMERA_PARM_CAF_TYPE:
      CDBG("SM : %s : MM_CAMERA_PARM_CAF_TYPE value : %d",__func__,*((int *)(parm->p_value)));
      return mm_camera_send_native_ctrl_cmd(my_obj,
                  CAMERA_SET_PARM_CAF_TYPE, sizeof(int32_t), (void *)parm->p_value);

    case MM_CAMERA_PARM_HDR:
      return mm_camera_send_native_ctrl_cmd(my_obj,
                        CAMERA_SET_PARM_HDR, sizeof(exp_bracketing_t), (void *)parm->p_value);

    case MM_CAMERA_PARM_CAF_LOCK_CANCEL:
      return mm_camera_send_native_ctrl_cmd(my_obj,
                  CAMERA_SET_CAF_LOCK_CANCEL, sizeof(uint32_t), (void *)parm->p_value);

    default:
        CDBG("%s: default: parm %d not supported\n", __func__, parm->parm_type);
        break;
    }
    return rc;
}
Пример #9
0
int32_t mm_camera_action_start(mm_camera_obj_t *my_obj, 
															 mm_camera_ops_type_t opcode, void *parm)
{
	int32_t rc = -MM_CAMERA_E_GENERAL;
	mm_camera_channel_type_t ch_type;
	if(opcode == MM_CAMERA_OPS_FOCUS) {
		if(!parm) return rc;
		return mm_camera_send_native_ctrl_cmd(my_obj,	
					CAMERA_SET_PARM_AUTO_FOCUS, sizeof(isp3a_af_mode_t), parm);
		/*return mm_camera_util_s_ctrl(my_obj->ctrl_fd,  
																		MSM_V4L2_PID_FOCUS_MODE, 
																			*((isp3a_af_mode_t *)parm));*/
	}
	ch_type = mm_camera_util_opcode_2_ch_type(my_obj, opcode);
	CDBG("%s:ch=%d,op_mode=%d,opcode=%d\n",
			 __func__,ch_type,my_obj->op_mode,opcode);
	switch(my_obj->op_mode) {
	case MM_CAMERA_OP_MODE_CAPTURE:
		switch(opcode) {
		case MM_CAMERA_OPS_PREVIEW:
		case MM_CAMERA_OPS_SNAPSHOT:
		case MM_CAMERA_OPS_RAW:
			rc = mm_camera_ch_fn(my_obj, ch_type, 
							MM_CAMERA_STATE_EVT_STREAM_ON, NULL);
			break;
		case MM_CAMERA_OPS_PREPARE_SNAPSHOT:
			/* TBD: do g_ext_ctrl */
			rc = MM_CAMERA_OK;
			break;
		default:
			break;
		}
		break;
	case MM_CAMERA_OP_MODE_VIDEO:
		switch(opcode) {
		case MM_CAMERA_OPS_PREVIEW:
		case MM_CAMERA_OPS_VIDEO:
			rc = mm_camera_ch_fn(my_obj,	ch_type, 
							MM_CAMERA_STATE_EVT_STREAM_ON, NULL);
			CDBG("%s: op_mode=%d, ch %d, rc=%d\n",
					 __func__, MM_CAMERA_OP_MODE_VIDEO, ch_type ,rc);
			break;
		default:
			break;
		}
		break;
	case MM_CAMERA_OP_MODE_ZSL:
		switch(opcode) {
		case MM_CAMERA_OPS_PREVIEW:
		case MM_CAMERA_OPS_ZSL:
			rc = mm_camera_ch_fn(my_obj,	ch_type, 
							MM_CAMERA_STATE_EVT_STREAM_ON, NULL);
			break;
		default:
			break;
		}
		break;
	default:
		break;
	}
	return rc;
}
Пример #10
0
int32_t mm_camera_set_general_parm(mm_camera_obj_t * my_obj, mm_camera_parm_t *parm)
{
	int rc = -MM_CAMERA_E_NOT_SUPPORTED;

	switch(parm->parm_type)  {
	case MM_CAMERA_PARM_EXPOSURE:
		return mm_camera_util_s_ctrl(my_obj->ctrl_fd,  
																		MSM_V4L2_PID_EXP_METERING, 
																			*((int *)(parm->p_value)));
	case MM_CAMERA_PARM_SHARPNESS:
		return mm_camera_util_s_ctrl(my_obj->ctrl_fd, V4L2_CID_SHARPNESS, 
																			*((int *)(parm->p_value)));
	case MM_CAMERA_PARM_CONTRAST:
		return mm_camera_util_s_ctrl(my_obj->ctrl_fd, V4L2_CID_CONTRAST, 
																			*((int *)(parm->p_value)));
	case MM_CAMERA_PARM_SATURATION:
		return mm_camera_util_s_ctrl(my_obj->ctrl_fd, V4L2_CID_SATURATION, 
																			*((int *)(parm->p_value)));
	case MM_CAMERA_PARM_BRIGHTNESS:
		return mm_camera_util_s_ctrl(my_obj->ctrl_fd, V4L2_CID_BRIGHTNESS, 
																			*((int *)(parm->p_value)));
  case MM_CAMERA_PARM_WHITE_BALANCE:
		return mm_camera_ctrl_set_whitebalance (my_obj,	*((int *)(parm->p_value)));
	case MM_CAMERA_PARM_ISO:
		return mm_camera_util_s_ctrl(my_obj->ctrl_fd, MSM_V4L2_PID_ISO, 
																			*((int *)(parm->p_value)) -1);
	case MM_CAMERA_PARM_ZOOM:
		return mm_camera_util_s_ctrl(my_obj->ctrl_fd, V4L2_CID_ZOOM_ABSOLUTE, 
																			*((int *)(parm->p_value)));
	case MM_CAMERA_PARM_LUMA_ADAPTATION:
		return mm_camera_util_s_ctrl(my_obj->ctrl_fd, MSM_V4L2_PID_LUMA_ADAPTATION, 
																			*((int *)(parm->p_value)));
	case MM_CAMERA_PARM_ANTIBANDING:
		return mm_camera_ctrl_set_antibanding (my_obj, *((int *)(parm->p_value)));
  case MM_CAMERA_PARM_CONTINUOUS_AF:
		return mm_camera_ctrl_set_auto_focus(my_obj, *((int *)(parm->p_value)));
	case MM_CAMERA_PARM_HJR:
		return mm_camera_util_s_ctrl(my_obj->ctrl_fd, MSM_V4L2_PID_HJR, 
																			*((int *)(parm->p_value)));
	case MM_CAMERA_PARM_EFFECT:
		return mm_camera_ctrl_set_specialEffect (my_obj, *((int *)(parm->p_value)));
	case MM_CAMERA_PARM_FPS:
		return mm_camera_send_native_ctrl_cmd(my_obj,	
					CAMERA_SET_PARM_FPS, sizeof(uint16_t), (void *)parm->p_value);
  case MM_CAMERA_PARM_FPS_MODE:
		return mm_camera_send_native_ctrl_cmd(my_obj,	
					CAMERA_SET_FPS_MODE, sizeof(int32_t), (void *)parm->p_value);
  case MM_CAMERA_PARM_EXPOSURE_COMPENSATION:
		return mm_camera_send_native_ctrl_cmd(my_obj,	
					CAMERA_SET_PARM_EXPOSURE_COMPENSATION, sizeof(int32_t), (void *)parm->p_value);
  case MM_CAMERA_PARM_LED_MODE:
		return mm_camera_send_native_ctrl_cmd(my_obj,	
					CAMERA_SET_PARM_LED_MODE, sizeof(int32_t), (void *)parm->p_value);
  case MM_CAMERA_PARM_ROLLOFF:
		return mm_camera_send_native_ctrl_cmd(my_obj,	
					CAMERA_SET_PARM_ROLLOFF, sizeof(int32_t), (void *)parm->p_value);
	case MM_CAMERA_PARM_MODE:
		my_obj->current_mode = *((camera_mode_t *)parm->p_value);
		break;
	case MM_CAMERA_PARM_FOCUS_RECT:
		return mm_camera_send_native_ctrl_cmd(my_obj,	
					CAMERA_SET_PARM_FOCUS_RECT, sizeof(int32_t), (void *)parm->p_value);
	case MM_CAMERA_PARM_AEC_ROI:
		return mm_camera_send_native_ctrl_cmd(my_obj,	
					CAMERA_SET_PARM_AEC_ROI, sizeof(cam_set_aec_roi_t), (void *)parm->p_value);
	case MM_CAMERA_PARM_AF_ROI:
		return mm_camera_send_native_ctrl_cmd(my_obj,	
					CAMERA_SET_PARM_AF_ROI, sizeof(roi_info_t), (void *)parm->p_value);
	case MM_CAMERA_PARM_BL_DETECTION:
		return mm_camera_util_s_ctrl(my_obj->ctrl_fd, MSM_V4L2_PID_BL_DETECTION, 
																				*((int *)(parm->p_value)));
	case MM_CAMERA_PARM_SNOW_DETECTION:
		return mm_camera_util_s_ctrl(my_obj->ctrl_fd, MSM_V4L2_PID_SNOW_DETECTION, 
																				*((int *)(parm->p_value)));
	case MM_CAMERA_PARM_BESTSHOT_MODE:
		CDBG("%s : MM_CAMERA_PARM_BESTSHOT_MODE value : %d",__func__,*((int *)(parm->p_value)));
		return mm_camera_send_native_ctrl_cmd(my_obj,	
					CAMERA_SET_PARM_BESTSHOT_MODE, sizeof(int32_t), (void *)parm->p_value);
		break;
	case MM_CAMERA_PARM_VIDEO_DIS:
		return mm_camera_send_native_ctrl_cmd(my_obj,	
					CAMERA_SET_VIDEO_DIS_PARAMS, sizeof(video_dis_param_ctrl_t), (void *)parm->p_value);
	case MM_CAMERA_PARM_VIDEO_ROT:
		return mm_camera_send_native_ctrl_cmd(my_obj,	
					CAMERA_SET_VIDEO_ROT_PARAMS, sizeof(video_rotation_param_ctrl_t), (void *)parm->p_value);
  case MM_CAMERA_PARM_SCE_FACTOR:
		return mm_camera_send_native_ctrl_cmd(my_obj,	
					CAMERA_SET_SCE_FACTOR, sizeof(int32_t), (void *)parm->p_value);
  case MM_CAMERA_PARM_FD:
		return mm_camera_send_native_ctrl_cmd(my_obj,	
					CAMERA_SET_PARM_FD, sizeof(int32_t), (void *)parm->p_value);
	case MM_CAMERA_PARM_MCE:
		return mm_camera_send_native_ctrl_cmd(my_obj,	CAMERA_SET_PARM_MCE,
													 sizeof(int32_t), (void *)parm->p_value);
	case MM_CAMERA_PARM_HORIZONTAL_VIEW_ANGLE:
		return mm_camera_send_native_ctrl_cmd(my_obj,	CAMERA_GET_PARM_HORIZONTAL_VIEW_ANGLE,
													 sizeof(focus_distances_info_t), (void *)parm->p_value);
	case MM_CAMERA_PARM_VERTICAL_VIEW_ANGLE:
		return mm_camera_send_native_ctrl_cmd(my_obj,	CAMERA_GET_PARM_VERTICAL_VIEW_ANGLE,
													 sizeof(focus_distances_info_t), (void *)parm->p_value);
	case MM_CAMERA_PARM_RESET_LENS_TO_INFINITY:
		return mm_camera_send_native_ctrl_cmd(my_obj,	
							CAMERA_SET_PARM_RESET_LENS_TO_INFINITY,
							0, NULL);
  case MM_CAMERA_PARM_SNAPSHOTDATA:
		return mm_camera_send_native_ctrl_cmd(my_obj,	CAMERA_GET_PARM_SNAPSHOTDATA,
													 sizeof(snapshotData_info_t), (void *)parm->p_value);
  case MM_CAMERA_PARM_HFR:
		return mm_camera_send_native_ctrl_cmd(my_obj,	
					CAMERA_SET_PARM_HFR, sizeof(int32_t), (void *)parm->p_value);
  case MM_CAMERA_PARM_REDEYE_REDUCTION:
		return mm_camera_send_native_ctrl_cmd(my_obj,	
					CAMERA_SET_REDEYE_REDUCTION, sizeof(int32_t), (void *)parm->p_value);
  case MM_CAMERA_PARM_WAVELET_DENOISE:
		return mm_camera_send_native_ctrl_cmd(my_obj,	
					CAMERA_SET_PARM_WAVELET_DENOISE, sizeof(int32_t), (void *)parm->p_value);
	case MM_CAMERA_PARM_3D_DISPLAY_DISTANCE:
		return mm_camera_send_native_ctrl_cmd(my_obj,	
					CAMERA_SET_PARM_3D_DISPLAY_DISTANCE, sizeof(float), (void *)parm->p_value);
	case MM_CAMERA_PARM_3D_VIEW_ANGLE:
		return mm_camera_send_native_ctrl_cmd(my_obj,	
					CAMERA_SET_PARM_3D_VIEW_ANGLE, sizeof(uint32_t), (void *)parm->p_value);
	case MM_CAMERA_PARM_ZOOM_RATIO:
		break;
	case MM_CAMERA_PARM_HISTOGRAM:
		return mm_camera_send_native_ctrl_cmd(my_obj,	
					CAMERA_SET_PARM_HISTOGRAM, sizeof(int8_t), (void *)parm->p_value);
	default:
		CDBG("%s:parm %d not supported\n", __func__, parm->parm_type);
		break; 
	}
	return rc;
}
int32_t mm_camera_get_parm(mm_camera_obj_t * my_obj,
                            mm_camera_parm_t *parm)
{
    int32_t rc = MM_CAMERA_OK;

    switch(parm->parm_type) {
    case MM_CAMERA_PARM_CROP:
      return rc = mm_camera_ch_fn(my_obj,
                    ((mm_camera_ch_crop_t *)parm->p_value)->ch_type,
                    MM_CAMERA_STATE_EVT_GET_CROP, parm->p_value);
      break;
    case MM_CAMERA_PARM_DIMENSION:
        memcpy(parm->p_value, &my_obj->dim, sizeof(my_obj->dim));
        CDBG("%s: dw=%d,dh=%d,vw=%d,vh=%d,pw=%d,ph=%d,tw=%d,th=%d,ovx=%x,ovy=%d,opx=%d,opy=%d, m_fmt=%d, t_ftm=%d\n",
                 __func__,
                 my_obj->dim.display_width,my_obj->dim.display_height,
                 my_obj->dim.video_width,my_obj->dim.video_height,
                 my_obj->dim.picture_width,my_obj->dim.picture_height,
                 my_obj->dim.ui_thumbnail_width,my_obj->dim.ui_thumbnail_height,
                 my_obj->dim.orig_video_width,my_obj->dim.orig_video_height,
                 my_obj->dim.orig_picture_width,my_obj->dim.orig_picture_height,
                 my_obj->dim.main_img_format, my_obj->dim.thumb_format);
        break;
    case MM_CAMERA_PARM_MAX_PICTURE_SIZE: {
        mm_camera_dimension_t *dim =
            (mm_camera_dimension_t *)parm->p_value;
        dim->height = my_obj->properties.max_pict_height;
        dim->width = my_obj->properties.max_pict_width;
        CDBG("%s: Max Picture Size: %d X %d\n", __func__,
             dim->width, dim->height);
    }
        break;
    case MM_CAMERA_PARM_MAX_PREVIEW_SIZE: {
        mm_camera_dimension_t *dim =
            (mm_camera_dimension_t *)parm->p_value;
        dim->height = my_obj->properties.max_preview_height;
        dim->width = my_obj->properties.max_preview_width;
        CDBG("%s: Max Preview Size: %d X %d\n", __func__,
             dim->width, dim->height);
    }
        break;
    case MM_CAMERA_PARM_MAX_VIDEO_SIZE: {
        mm_camera_dimension_t *dim =
            (mm_camera_dimension_t *)parm->p_value;
        dim->height = my_obj->properties.max_video_height;
        dim->width = my_obj->properties.max_video_width;
        CDBG("%s: Max Video Size: %d X %d\n", __func__,
             dim->width, dim->height);
    }
        break;
    case MM_CAMERA_PARM_MAX_HFR_MODE:
        return mm_camera_send_native_ctrl_cmd(my_obj, CAMERA_GET_PARM_MAX_HFR_MODE,
                sizeof(camera_hfr_mode_t), (void *)parm->p_value);
    case MM_CAMERA_PARM_FOCAL_LENGTH:
        return mm_camera_send_native_ctrl_cmd(my_obj, CAMERA_GET_PARM_FOCAL_LENGTH,
                     sizeof(focus_distances_info_t), (void *)parm->p_value);
    case MM_CAMERA_PARM_HORIZONTAL_VIEW_ANGLE:
        return mm_camera_send_native_ctrl_cmd(my_obj,   CAMERA_GET_PARM_HORIZONTAL_VIEW_ANGLE,
                                                     sizeof(focus_distances_info_t), (void *)parm->p_value);
    case MM_CAMERA_PARM_VERTICAL_VIEW_ANGLE:
        return mm_camera_send_native_ctrl_cmd(my_obj,   CAMERA_GET_PARM_VERTICAL_VIEW_ANGLE,
                                                     sizeof(focus_distances_info_t), (void *)parm->p_value);
    case MM_CAMERA_PARM_FOCUS_DISTANCES:
        return mm_camera_send_native_ctrl_cmd(my_obj,   CAMERA_GET_PARM_FOCUS_DISTANCES,
                     sizeof(focus_distances_info_t), (void *)parm->p_value);
  case MM_CAMERA_PARM_QUERY_FALSH4SNAP:
        return mm_camera_send_native_ctrl_cmd(my_obj,   CAMERA_QUERY_FLASH_FOR_SNAPSHOT,
                     sizeof(int), (void *)parm->p_value);
  case MM_CAMERA_PARM_3D_FRAME_FORMAT:
        return mm_camera_send_native_ctrl_cmd(my_obj,   CAMERA_GET_PARM_3D_FRAME_FORMAT,
                     sizeof(camera_3d_frame_t), (void *)parm->p_value);
    case MM_CAMERA_PARM_MAXZOOM:
        return mm_camera_send_native_ctrl_cmd(my_obj,   CAMERA_GET_PARM_MAXZOOM,
                     sizeof(int), (void *)parm->p_value);
    case MM_CAMERA_PARM_ZOOM_RATIO: {
        mm_camera_zoom_tbl_t *tbl = (mm_camera_zoom_tbl_t *)parm->p_value;
        return mm_camera_send_native_ctrl_cmd(my_obj,   CAMERA_GET_PARM_ZOOMRATIOS,
                     sizeof(int16_t)*tbl->size, tbl->zoom_ratio_tbl);
    }
    case MM_CAMERA_PARM_OP_MODE:
        *((mm_camera_op_mode_type_t *)parm->p_value) = my_obj->op_mode;
        break;
    case MM_CAMERA_PARM_SNAPSHOT_BURST_NUM:
        *((int *)parm->p_value) = my_obj->snap_burst_num_by_user;
        break;
    default:
        /* needs to add more implementation */
        rc = -1;
        break;
    }
    return rc;
}