C++ CDBG_HIGH函数代码示例

/*===========================================================================
 * FUNCTION    - hdr_set_params -
 *
 * DESCRIPTION:
 *==========================================================================*/
int hdr_set_params(frame_proc_t *frameCtrl, frame_proc_set_hdr_data_t *data)
{
  int rc = 0;
  uint32_t index = frameCtrl->handle & 0xFF;
  hdr_t *hdr = hdrCtrl[index];
  switch (data->type) {
  case FRAME_PROC_HDR_ENABLE:
    frameCtrl->output.hdr_d.hdr_enable = data->hdr_init_info.hdr_enable;
    if (frameCtrl->output.hdr_d.hdr_enable) {
      rc = hdr_init(frameCtrl);
      //hdr->num_hal_buf = data->hdr_init_info.num_hal_buf;
    }
    else
      rc = hdr_exit(frameCtrl);
    break;
  case FRAME_PROC_HDR_HW_INFO:
    {
    /*  memcpy(&hdr->pGammaTableStruct.gamma_tbl,frameCtrl->input.isp_info.RGB_gamma_table,
        frameCtrl->input.isp_info.VFE_GAMMA_NUM_ENTRIES*sizeof(int16_t));*/
      hdr->pGammaTableStruct.gamma_tbl = frameCtrl->input.isp_info.RGB_gamma_table;
      hdr->pGammaTableStruct.entry = frameCtrl->input.isp_info.VFE_GAMMA_NUM_ENTRIES;
      hdr->pGammaTableStruct.gamma_t = GAMMA_TBL_ALL;
	  CDBG_HIGH("%s Gamma Table entries %d",__func__,hdr->pGammaTableStruct.entry );
      if (hdr->pGammaTableStruct.entry!=64) {
        CDBG_HIGH("Error: Invalid gamma table\n");
        return -1;
      }
      rc = hdr_calculate_gammatbl(frameCtrl,hdr);
    }
    break;
  default:
    return -1;
  }
  return rc;
}  /* hdr_set_params */

/*===========================================================================
 * FUNCTION    - release_c2d_buffer -
 *
 * DESCRIPTION:  unregister C2D buffer with kernel and deallocate.
 *==========================================================================*/
static int release_c2d_buffer(config_ctrl_t *ctrl, struct msm_pmem_info *info)
{
  C2D_STATUS rc;
  if (ioctl(ctrl->camfd, MSM_CAM_IOCTL_UNREGISTER_PMEM, info) < 0) {
    CDBG_HIGH("%s: ioctl MSM_CAM_IOCTL_UNREGISTER_PMEM is failed.\n", __func__);
    return FALSE;
  }

  if (do_munmap(info->fd, (void *)info->vaddr, info->cbcr_off * 3/2)) {
    CDBG_HIGH("%s: munmap failed\n", __func__);
    return FALSE;
  }

  rc = LINK_c2dDestroySurface(c2d_obj.src_id);
  if (rc != C2D_STATUS_OK)
    CDBG_HIGH("%s: LINK_c2dDestroySurface failed\n", __func__);

  rc = LINK_c2dDestroySurface(c2d_obj.dst_id);
  if (rc != C2D_STATUS_OK)
    CDBG_HIGH("%s: LINK_c2dDestroySurface failed\n", __func__);

  delete_gpu_addr_list();
  close(kgsl_fd);
  return TRUE;
} /* release_c2d_buffer */

/** eis2_initialize:
 *    @eis: EIS2 context
 *    @data: initialization parameters
 *
 * This function initializes the EIS2 algorithm.
 *
 * Returns 0 on success.
 **/
int eis2_initialize(eis2_context_type *eis, is_init_data_t *data)
{
  int rc = 0;
  eis_init_type init_param;
  frame_cfg_t *frame_cfg = &data->frame_cfg;
  rs_cs_config_t *rs_cs_config = &data->rs_cs_config;

  init_param.sensor_mount_angle = data->sensor_mount_angle;
  init_param.camera_position = data->camera_position;

  init_param.width = frame_cfg->dis_frame_width;
  init_param.height = frame_cfg->dis_frame_height;

  init_param.margin_x = (frame_cfg->vfe_output_width -
      frame_cfg->dis_frame_width) / 2;
  init_param.margin_y = (frame_cfg->vfe_output_height -
      frame_cfg->dis_frame_height) / 2;

  CDBG_HIGH("%s: init_param->margin_x = %u", __func__, init_param.margin_x);
  CDBG_HIGH("%s: init_param->margin_y = %u", __func__, init_param.margin_y);

  if (eis2_init(eis, &init_param) > 0) {
    CDBG_HIGH("%s: eis_init failed \n", __func__);
    rc = -1;
  }
  return rc;
}

int start_preview(struct camera_device * device)
{
    CDBG_HIGH("Q%s: E", __func__);
    int rc = -1;
    QCamera2HardwareInterface *hardware = util_get_Hal_obj(device);
    if(hardware != NULL){
        rc = hardware->start_preview(device);
    }
    CDBG_HIGH("Q%s: X", __func__);
    return rc;
}

/*===========================================================================

Function           : hdr_config_2frame

Description        : configure 2 frame
============================================================================= */
int hdr_config_2frame(frame_proc_t *frameCtrl,hdr_t *hdrCtrl,image_type type)
{
  hdr_config_t *pIn = &(hdrCtrl->structHdrConfig);
  struct msm_pp_frame *hdr_frame[MAX_HDR_NUM_FRAMES];
  switch (type) {
  case THUMBNAIL :
    CDBG_HIGH("%s E thumbnail",__func__);
    pIn->imageWidth=frameCtrl->input.mctl_info.thumbnail_dim.width;
    pIn->imageHeight=frameCtrl->input.mctl_info.thumbnail_dim.height;
    pIn->thumbMainIndicator=1;
    pIn->calculatedExposureRatioG=0;
    hdr_frame[0] = &(frameCtrl->input.mctl_info.thumb_img_frame[1]);
    hdr_frame[1] = &(frameCtrl->input.mctl_info.thumb_img_frame[2]);
    break;
  case MAINIMG:
    CDBG_HIGH("%s main img  ratio : %d E",__func__,hdrCtrl->mParamterStruct.mCalculatedExposureRatioG);
    pIn->imageWidth=frameCtrl->input.mctl_info.picture_dim.width;
    pIn->imageHeight=frameCtrl->input.mctl_info.picture_dim.height;
    pIn->thumbMainIndicator=0;
    pIn->calculatedExposureRatioG=hdrCtrl->mParamterStruct.mCalculatedExposureRatioG;
    hdr_frame[0] = &(frameCtrl->input.mctl_info.main_img_frame[1]);
    hdr_frame[1] = &(frameCtrl->input.mctl_info.main_img_frame[2]);
    break;
  default:
    return -1;
  }
  //Get the pIn config settings
  pIn->subSampleFormat=HDR_H2V2;
  pIn->chromaOrder=YCRCB;
  pIn->maxLag=200;
  //Set the gamm tables
  pIn->pRedGammaInvTable=hdrCtrl->mParamterStruct.mpRedInverseGammatable;
  pIn->pGreenGammaInvTable=hdrCtrl->mParamterStruct.mpGreenInverseGammatable;
  pIn->pBlueGammaInvTable=hdrCtrl->mParamterStruct.mpBlueInverseGammatable;
  pIn->pRedGammaTable=hdrCtrl->mParamterStruct.mpRedNewGammatable;
  pIn->pGreenGammaTable=hdrCtrl->mParamterStruct.mpGreenNewGammatable;
  pIn->pBlueGammaTable=hdrCtrl->mParamterStruct.mpBlueNewGammatable;
  pIn->pHdrBuffer2Y=
    (uint8_t*)((uint8_t*)hdr_frame[0]->mp[0].vaddr+ hdr_frame[0]->mp[0].data_offset);
  pIn->pHdrBuffer2C=
    (uint8_t*)((uint8_t*)hdr_frame[0]->mp[1].vaddr+hdr_frame[0]->mp[1].data_offset);
  pIn->pHdrBuffer1Y=
    (uint8_t*)((uint8_t*)hdr_frame[1]->mp[0].vaddr+ hdr_frame[1]->mp[0].data_offset);
  pIn->pHdrBuffer1C=
    (uint8_t*)((uint8_t*)hdr_frame[1]->mp[1].vaddr+hdr_frame[1]->mp[1].data_offset);
	CDBG_HIGH("%s X",__func__);
  return 0;
}

/** color_conversion_config:
 *
 *    @mod:
 *    @in_params:
 *    @in_param_size:
 *
 * configure initial settings
 *
 **/
static int color_conversion_config(isp_color_conversion_mod_t *mod, isp_hw_pix_setting_params_t *in_params, uint32_t in_param_size)
{
  int  rc = 0;
  chromatix_parms_type *chromatix_ptr =
    (chromatix_parms_type *)in_params->chromatix_ptrs.chromatixPtr;
  chromatix_CV_type *chromatix_CV_ptr =
      &chromatix_ptr->chromatix_VFE.chromatix_CV;

  if (in_param_size != sizeof(isp_hw_pix_setting_params_t)) {
    /* size mismatch */
    CDBG_ERROR("%s: size mismatch, expecting = %d, received = %d",
      __func__, sizeof(isp_hw_pix_setting_params_t), in_param_size);
    return -1;
  }

  ISP_DBG(ISP_MOD_COLOR_CONV, "%s: enter", __func__);

  if (!mod->enable) {
    CDBG_HIGH("%s: Mod not Enable.", __func__);
    return rc;
  }

  /* set old cfg to invalid value to trigger the first trigger update */
  SET_UNITY_MATRIX(mod->effects_matrix, 2);
  mod->cv_data = chromatix_CV_ptr->TL84_color_conversion;
  mod->p_cv = &(chromatix_CV_ptr->TL84_color_conversion);

  util_color_conversion_cmd_config(mod);
  mod->hw_update_pending = TRUE;

  return rc;
} /* color_conversion_config */

/*===========================================================================
 * FUNCTION    - vfe_rolloff_update -
 *
 * DESCRIPTION:
 *==========================================================================*/
vfe_status_t vfe_rolloff_update(int mod_id, void *module, void *vparams)
{
  rolloff_mod_t *rolloff_ctrl = (rolloff_mod_t*)module;
  vfe_params_t *vfe_params = (vfe_params_t *)vparams;
  vfe_status_t rc = VFE_SUCCESS;

  if (rolloff_ctrl->hw_enable_cmd) {
    if (VFE_SUCCESS != vfe_util_write_hw_cmd(vfe_params->camfd, CMD_GENERAL,
      (void *)vfe_params->moduleCfg, sizeof(vfe_params->moduleCfg),
      VFE_CMD_MODULE_CFG)) {
      CDBG_HIGH("%s: Module config failed\n", __func__);
      return VFE_ERROR_GENERAL;
    }
    rolloff_ctrl->hw_enable_cmd = FALSE;
  }

  if (rolloff_ctrl->rolloff_enable) {
    if (vfe_params->vfe_version == MSM8974)
      rc = mesh_rolloff_V4_update(&(rolloff_ctrl->mesh_v4_ctrl), vfe_params);
    else if (USE_PCA(vfe_params->vfe_version))
      rc = pca_rolloff_update(&(rolloff_ctrl->pca_ctrl), vfe_params);
    else
      rc = mesh_rolloff_update(&(rolloff_ctrl->mesh_ctrl), vfe_params);

    if (rc != VFE_SUCCESS)
      CDBG_ERROR("%s: ROLLOFF update failed\n", __func__);
  }

end:
  return rc;
} /* vfe_rolloff_update */

extern "C" int get_number_of_cameras()
{
    /* try to query every time we get the call!*/

    CDBG_HIGH("Q%s: E", __func__);
    return QCamera2Factory::get_number_of_cameras();
}

/*===========================================================================
FUNCTION      isp_tintless_stat_config

DESCRIPTION   Update the stat params for the tintless algo.
              Should be called after the BG stat config has
              been called.
===========================================================================*/
static tintless_return_t isp_tintless_stat_config(void * const res, tintless_stats_config_t * cfg)
{
    tintless_return_t rc;
    tintless_cfg_t c;
    tintless_lib_t * const tintless_lib = (tintless_lib_t *) res;

    CDBG_TINTLESS("%s: Enter \n", __func__);

    CDBG_HIGH("%s: stats : camif hxw %d x %d, ele col,row %d, %d, hxw %d x %d, type %d",__func__,
               cfg->camif_win_h, cfg->camif_win_w,
               cfg->num_stat_elem_cols, cfg->num_stat_elem_rows,
               cfg->stat_elem_h, cfg->stat_elem_w,
               cfg->stats_type);

    if (tintless_lib == NULL || tintless_lib->init_func == NULL)
    {
        CDBG_ERROR("%s: Tintless lib is NULL\n", __func__);
        rc = TINTLESS_LIB_NOT_LOADED;
    }
    else
    {
        CDBG_ERROR("%s: pointer okay \n", __func__);
        c.stats = cfg;
        if (tintless_lib->updates & ( 1 << UPDATES_STAT_CONFIG)) {
            rc = isp_tintless_config(tintless_lib, UPDATES_STAT_CONFIG, c);
            CDBG_ERROR("%s: lib returned config err=%d", __func__, rc);
        } else {
            CDBG_ERROR("%s: Stat cfg updates not needed", __func__);
            rc = TINTLESS_UPDATES_NOT_SUPPORTED;
        }
    }

    return rc;
} /* isp_tintless_stat_config */

/** bpc_action
 *    @mod_ctrl: bpc module control struct
 *    @action_code : action code
 *    @data: not used
 *    @data_size: not used
 *
 *  processing the hw action like update or reset
 *
 * Return: 0 - success and negative value - failure
 **/
static int bpc_action (void *mod_ctrl, uint32_t action_code, void *data,
  uint32_t data_size)
{
  int rc = 0;
  isp_bpc_mod_t *mod = mod_ctrl;

  switch (action_code) {
  case ISP_HW_MOD_ACTION_HW_UPDATE: {
    rc = bpc_do_hw_update(mod);
  }
    break;

  case ISP_HW_MOD_ACTION_RESET: {
    bpc_reset(mod);
  }
    break;

  default: {
    /* no op */
    CDBG_HIGH("%s: action code = %d is not supported. nop",
      __func__, action_code);
    rc = -EAGAIN;
  }
    break;
  }
  return rc;
} /* bpc_action */

/*===========================================================================
 * FUNCTION    - vfe_chroma_suppression_config -
 *
 * DESCRIPTION:
 *==========================================================================*/
vfe_status_t vfe_chroma_suppression_config(int mod_id, void *mod_csupp,
  void *parms)
{
  VFE_ChromaSuppress_ConfigCmdType *chroma_supp_cmd;
  chroma_supp_mod_t *mod = (chroma_supp_mod_t *)mod_csupp;
  vfe_params_t *p_obj = (vfe_params_t *)parms;

  if (!mod->chroma_supp_enable) {
    CDBG("%s: Chroma Suppression not enabled", __func__);
    return VFE_SUCCESS;
  }
  CDBG("%s: mode: %d\n", __func__, p_obj->vfe_op_mode);

  if(IS_SNAP_MODE(p_obj)) {
    chroma_supp_cmd = &(mod->chroma_supp_snap_cmd);
  } else
    chroma_supp_cmd = &(mod->chroma_supp_video_cmd);

  vfe_chrom_supp_config_debug(chroma_supp_cmd);
  if (VFE_SUCCESS != vfe_util_write_hw_cmd(p_obj->camfd, CMD_GENERAL,
    (void *)chroma_supp_cmd, sizeof(*chroma_supp_cmd),
     VFE_CMD_CHROMA_SUP_CFG)) {
    CDBG_HIGH("%s: chroma sup config for op mode = %d failed\n", __func__,
      p_obj->vfe_op_mode);
    return VFE_ERROR_GENERAL;
  }

  return VFE_SUCCESS;
} /* vfe_chroma_suppression_config */

/** demux_action:
 *    @mod_ctrl: demux module instance
 *    @action_code: action id
 *    @data: input parameter data
 *    @data_size: input parameter size
 *
 *  This function runs in ISP HW thread context.
 *
 *  This function executes an demux module action
 *
 *  Return:   0 - Success
 *            Negative - action execution error
 **/
static int demux_action (void *mod_ctrl, uint32_t action_code, void *data,
  uint32_t data_size)
{
  int rc = 0;
  isp_demux_mod_t *demux = mod_ctrl;

  switch (action_code) {
  case ISP_HW_MOD_ACTION_HW_UPDATE:
    rc = demux_do_hw_update(demux);
    break;

  case ISP_HW_MOD_ACTION_RESET:
    demux_reset(demux);
    break;

  default:
    /* no op */
    rc = -EAGAIN;
    CDBG_HIGH("%s: action code = %d is not supported. nop",
              __func__, action_code);
    break;
  }

  return rc;
} /* demux_action */

/*===========================================================================
FUNCTION    - vfe_test_gamma_get_hw_table -

DESCRIPTION
===========================================================================*/
static vfe_status_t vfe_test_gamma_get_hw_table(vfe_test_vector_t *mod)
{
  vfe_status_t status = VFE_SUCCESS;
  uint32_t i;
  uint32_t *data = NULL, *dummy = NULL;
  vfe_test_module_output_t *tv_params = &(mod->mod_output);
  vfe_ctrl_info_t *p_vfe_obj = (vfe_ctrl_info_t *)(mod->vfe_obj);
  vfe_params_t *params = &p_vfe_obj->vfe_params;

  CDBG("%s: enter", __func__);
  data = tv_params->gamma_table;
  if (!data) {
    if (NULL == (data = malloc(tv_params->gamma_table_len))) {
      CDBG_HIGH("%s: Not enough memory\n", __func__);
      return VFE_ERROR_GENERAL;
    }
  }

  status = vfe_util_write_hw_cmd(params->camfd, CMD_GENERAL, data,
    tv_params->gamma_table_len, VFE_CMD_GET_RGB_G_TABLE);
  if (VFE_SUCCESS != status) {
    CDBG_HIGH("%s: VFE_CMD_GET_GAMMA_TABLE failed\n", __func__);
    return status;
  }

  dummy = data;
  CDBG("%s: Channel 0\n", __func__);
  for (i = 0; i < VFE_GAMMA_NUM_ENTRIES; i++) {
    CDBG("%s: %08x \n", __func__, *dummy);
    dummy++;
  }
  CDBG("%s: Channel 1\n", __func__);
  for (i = 0; i < VFE_GAMMA_NUM_ENTRIES; i++) {
    CDBG("%s: %08x \n", __func__, *dummy);
    dummy++;
  }
  CDBG("%s: Channel 2\n", __func__);
  for (i = 0; i < VFE_GAMMA_NUM_ENTRIES; i++) {
    CDBG("%s: %08x \n", __func__, *dummy);
    dummy++;
  }

  if (data != tv_params->gamma_table)
    tv_params->gamma_table = data;

  return status;
} /* vfe_test_gamma_get_hw_table */

/*===========================================================================
 * FUNCTION    - prepare_non_fusible_frame -
 *
 * DESCRIPTION: Currrent frame is not fusible so left frame should
 *              be copied into right frame buffer.
 *==========================================================================*/
static int prepare_non_fusible_frame(config_ctrl_t *ctrl,
  struct msm_st_frame *ip_frame, struct msm_st_frame *op_frame,
  stereo_frame_t *pStereoFrame)
{
  uint32_t stride = 0;
  uint32_t mono_w_scale = 0, mono_h_scale = 0;

  uint8_t pad_2K_bool = (ctrl->vfeCtrl.vfeMode == VFE_MODE_SNAPSHOT) ?
    FALSE : TRUE;

  FIND_STEREO_SIZE_FACTOR(pStereoFrame->packing, FALSE,
    mono_w_scale, mono_h_scale);

  CDBG("%s: R.pix_x_off:%d R.pix_y_off:%d", __func__,
    op_frame->R.pix_x_off, op_frame->R.pix_y_off);

  c2d_obj.src_addr.vAddr0 = ip_frame->buf_info.buffer;
  c2d_obj.src_addr.gAddr0 = find_gpu_addr_item(ip_frame->buf_info.fd,
    c2d_obj.src_addr.vAddr0);

  if (!c2d_obj.src_addr.gAddr0) {
    uint32_t buf_gAddr;
    buf_gAddr = get_gpu_addr(ip_frame->buf_info.fd,
      PAD_2_2K((dim_t.pad_r_w * mono_w_scale) * (dim_t.pad_l_h * mono_h_scale),
      pad_2K_bool) * 3/2, ip_frame->buf_info.phy_offset,
      ip_frame->buf_info.buffer);

    c2d_obj.src_addr.gAddr0 = buf_gAddr;
    add_gpu_addr_item(ip_frame->buf_info.fd, c2d_obj.src_addr.vAddr0,
      c2d_obj.src_addr.gAddr0, buf_gAddr);
  }

  c2d_obj.src_addr.vAddr1 = c2d_obj.src_addr.vAddr0 +
    PAD_2_2K((dim_t.pad_r_w * mono_w_scale) * (dim_t.pad_l_h * mono_h_scale),
      pad_2K_bool);
  c2d_obj.src_addr.gAddr1 = c2d_obj.src_addr.gAddr0 +
    PAD_2_2K((dim_t.pad_r_w * mono_w_scale) * (dim_t.pad_l_h * mono_h_scale),
      pad_2K_bool);

  stride = dim_t.pad_r_w * mono_w_scale;

  /* update C2D source surface. */
  update_C2D_surface(&(c2d_obj.srcSurfaceDef), dim_t.pad_r_w, dim_t.pad_r_h,
    c2d_obj.src_id, &(c2d_obj.src_addr), stride, C2D_SOURCE, c2d_format);

  if (!stereo_geo_correction(dim_t.pad_r_w, dim_t.pad_r_h, pStereoFrame)) {
    CDBG_HIGH("%s: stereo_geo_correction failed.\n", __func__);
    return FALSE;
  }
  /* Prepare C2D output buffer for VPE. */
  op_frame->R.buf_y_off = 0;
  op_frame->R.buf_cbcr_off =
    PAD_2_2K(dim_t.pad_l_w * dim_t.pad_l_h, pad_2K_bool);

  op_frame->R.buf_y_stride = dim_t.pad_l_w;
  op_frame->R.buf_cbcr_stride = dim_t.pad_l_w;

  return TRUE;
} /* prepare_non_fusible_frame */

void disable_msg_type(struct camera_device * device, int32_t msg_type)
{
    QCamera2HardwareInterface *hardware = util_get_Hal_obj(device);
    CDBG_HIGH("Q%s: E", __func__);
    if(hardware != NULL){
        hardware->disable_msg_type(device, msg_type);
    }
}