C++ CDBG_ERROR函数代码示例

/*===========================================================================
 * FUNCTION    - vfe_client_parse_stats -
 *
 * DESCRIPTION:
 *==========================================================================*/
static int vfe_client_parse_stats(uint32_t handle,
  int isp_started, stats_type_t stats_type, void *stats, void *stats_output)
{
  vfe_ctrl_info_t *vfe_ctrl_obj;
  vfe_client_t *vfe_client;
  vfe_op_mode_t op_mode;
  int rc = 0;

  vfe_client = get_vfe_client_info(handle);
  if(!vfe_client) {
    CDBG_ERROR("%s: null vfe client",  __func__);
    return -1;
  }

  rc = vfe_client->vfe_ops.parse_stats(vfe_client, isp_started,
    stats_type, stats, stats_output);
  if(rc < 0) {
    CDBG_ERROR("%s: vfe process failed : %d ", __func__, rc);
    return -1;
  }
  return rc;
}

boolean cpp_module_util_free_buffer_info(void *d1, void *d2)
{
  cpp_module_buffer_info_t      *buffer_info =
    (cpp_module_buffer_info_t *)d1;
  cpp_module_stream_buff_info_t *stream_buff_info =
    (cpp_module_stream_buff_info_t *)d2;

  if (!buffer_info || !stream_buff_info) {
    CDBG_ERROR("%s:%d] error buffer_info:%p stream_buff_info:%p\n", __func__,
      __LINE__, buffer_info, stream_buff_info);
    return FALSE;
  }

  if (stream_buff_info->num_buffs == 0) {
    CDBG_ERROR("%s:%d] error in num of buffs\n", __func__, __LINE__);
    return FALSE;
  }

  free(buffer_info);
  stream_buff_info->num_buffs--;
  return TRUE;
}

/** bhist_stats_open:
 *    @stats: isp module data
 *    @stats_type: statistic type
 *
 * Allocate instance private data for submodule.
 *
 * This function executes in ISP thread context
 *
 * Return pointer to struct which contain module operations.
 **/
isp_ops_t *bhist_stats32_open(isp_stats_mod_t *stats,
  enum msm_isp_stats_type stats_type)
{
  int rc = 0;
  isp_stats_entry_t *entry = NULL;
  ISP_StatsBhist_CfgCmdType *cmd = NULL;

  ISP_DBG(ISP_MOD_STATS, "%s: E\n", __func__);
  entry = malloc(sizeof(isp_stats_entry_t));
  if (!entry) {
    CDBG_ERROR("%s: no mem for aec\n", __func__);
    return NULL;
  }
  cmd = malloc(sizeof(ISP_StatsBhist_CfgCmdType));
  if (!cmd) {
    CDBG_ERROR("%s: no mem\n", __func__);
    free(entry);
    return NULL;
  }
  memset(entry, 0, sizeof(*entry));
  memset(cmd, 0, sizeof(*cmd));

  entry->len_parsed_stats_buf = sizeof(q3a_bhist_stats_t);
  entry->parsed_stats_buf = malloc(entry->len_parsed_stats_buf);
  if (entry->parsed_stats_buf == NULL) {
    CDBG_ERROR("%s: no mem\n", __func__);
    free(cmd);
    free(entry);
    return NULL;
  }
  entry->reg_cmd = cmd;
  entry->ops.ctrl = (void *)entry;
  entry->ops.init = bhist_stats_init;
  entry->ops.destroy = bhist_stats_destroy;
  entry->ops.set_params = bhist_stats_set_params;
  entry->ops.get_params = bhist_stats_get_params;
  entry->ops.action = bhist_stats_action;
  return &entry->ops;
}

int mm_app_take_picture(mm_camera_test_obj_t *test_obj, uint8_t is_burst_mode)
{
    CDBG_HIGH("\nEnter %s!!\n",__func__);
    int rc = MM_CAMERA_OK;
    int num_snapshot = 1;
    int num_rcvd_snapshot = 0;

    if (is_burst_mode)
       num_snapshot = 6;

    //stop preview before starting capture.
    rc = mm_app_stop_preview(test_obj);
    if (rc != MM_CAMERA_OK) {
        CDBG_ERROR("%s: stop preview failed before capture!!, err=%d\n",__func__, rc);
        return rc;
    }

    rc = mm_app_start_capture(test_obj, num_snapshot);
    if (rc != MM_CAMERA_OK) {
        CDBG_ERROR("%s: mm_app_start_capture(), err=%d\n", __func__,rc);
        return rc;
    }
    while (num_rcvd_snapshot < num_snapshot) {
        CDBG_HIGH("\nWaiting mm_camera_app_wait !!\n");
        mm_camera_app_wait();
        num_rcvd_snapshot++;
    }
    rc = mm_app_stop_capture(test_obj);
    if (rc != MM_CAMERA_OK) {
       CDBG_ERROR("%s: mm_app_stop_capture(), err=%d\n",__func__, rc);
       return rc;
    }
    //start preview after capture.
    rc = mm_app_start_preview(test_obj);
    if (rc != MM_CAMERA_OK) {
        CDBG_ERROR("%s: start preview failed after capture!!, err=%d\n",__func__,rc);
    }
    return rc;
}

/*===========================================================================
 * FUNCTION    - vfe_af_stats_stop -
 *
 * DESCRIPTION:  Disable the af stats
 *==========================================================================*/
vfe_status_t vfe_af_stats_stop(af_stats_t *stats, vfe_params_t *params)
{
  vfe_status_t status = VFE_SUCCESS;

  CDBG("vfe_af_stats_stop\n");
  status = vfe_util_write_hw_cmd(params->camfd,
    CMD_GENERAL, 0, 0, VFE_CMD_STATS_AF_STOP);
  if (VFE_SUCCESS != status) {
    CDBG_ERROR("%s: failed %d", __func__, status);
    return VFE_ERROR_GENERAL;
  }
  return VFE_SUCCESS;
}

/*===========================================================================
 * FUNCTION    - sensor_util_config -
 *
 * DESCRIPTION:
 *==========================================================================*/
int8_t sensor_util_config(void *sctrl)
{
  struct sensor_cfg_data cfg;
  sensor_ctrl_t *ctrl = (sensor_ctrl_t *) sctrl;
  CDBG("%s enter\n", __func__);

  if (ctrl->sfd <= 0) {
    CDBG_ERROR("%s failed %d\n", __func__, __LINE__);
    return -EINVAL;
  }

  cfg.cfgtype = CFG_SENSOR_INIT;
  cfg.mode = ctrl->sensor.cam_mode;
  cfg.cfg.init_info.prev_res = ctrl->sensor.mode_res[SENSOR_MODE_PREVIEW];
  cfg.cfg.init_info.pict_res = ctrl->sensor.mode_res[SENSOR_MODE_SNAPSHOT];
  if (ioctl(ctrl->sfd, MSM_CAM_IOCTL_SENSOR_IO_CFG, &cfg) < 0) {
    CDBG_ERROR("%s failed %d\n", __func__, __LINE__);
    return -EIO;
  }
  CDBG("%s exit\n", __func__);
  return 0;
}

/** color_conversion_trigger_enable:
 *
 *    @mod:
 *    @enable:
 *    @in_param_size:
 *
 * enable color_conversion trigger update feature
 *
 **/
static int color_conversion_trigger_enable(isp_color_conversion_mod_t *mod,
  isp_mod_set_enable_t *enable, uint32_t in_param_size)
{
  if (in_param_size != sizeof(isp_mod_set_enable_t)) {
    CDBG_ERROR("%s: size mismatch, expecting = %d, received = %d",
      __func__, sizeof(isp_mod_set_enable_t), in_param_size);
    return -1;
  }

  mod->trigger_enable = enable->enable;

  return 0;
} /* color_conversion_trigger_enable */

int mm_app_start_preview_zsl(int cam_id)
{
    int rc = MM_CAMERA_OK;

    mm_camera_app_obj_t *pme = mm_app_get_cam_obj(cam_id);

    CDBG("pme = %p, pme->cam =%p, pme->cam->camera_handle = %d",
         pme,pme->cam,pme->cam->camera_handle);

    if (!my_cam_app.run_sanity) {
        if (MM_CAMERA_OK != initDisplay()) {
            CDBG_ERROR("%s : Could not initalize display",__func__);
            goto end;
        }
    }

    pme->mem_cam->get_buf = mm_stream_initbuf;
    pme->mem_cam->put_buf = mm_stream_deinitbuf;
    pme->mem_cam->user_data = pme;

    if (MM_CAMERA_OK != (rc = mm_app_prepare_preview_zsl(cam_id))) {
        CDBG_ERROR("%s:Prepare preview err=%d\n", __func__, rc);
        goto end;
    }

    if (MM_CAMERA_OK != (rc = mm_app_streamon_preview_zsl(cam_id))) {
        CDBG_ERROR("%s:stream on preview err=%d\n", __func__, rc);
        goto end;
    }

    /*if(MM_CAMERA_OK != (rc = mm_app_bundle_zsl_stream(cam_id))){
        CDBG_ERROR("%s: bundle and start of ZSl err=%d\n", __func__, rc);
        goto end;
    }*/

    end:
    CDBG("%s: END, rc=%d\n", __func__, rc); 
    return rc;
}

/** sce_enable
 *
 * description: enable sce
 *
 **/
static int sce_enable(isp_sce_mod_t *sce,
                isp_mod_set_enable_t *enable,
                uint32_t in_param_size)
{
  if (in_param_size != sizeof(isp_mod_set_enable_t)) {
    CDBG_ERROR("%s: size mismatch, expecting = %d, received = %d",
      __func__, sizeof(isp_mod_set_enable_t), in_param_size);
    return -1;
  }
  sce->sce_enable = enable->enable;

  return 0;
}

/*===========================================================================
 * FUNCTION    - vfe_bf_stats_config -
 *
 * DESCRIPTION:
 *==========================================================================*/
vfe_status_t vfe_bf_stats_config(int mod_id, void *stats, void *vparams)
{
  vfe_status_t status = VFE_SUCCESS;
  bf_stats_t *mod = (bf_stats_t *)stats;
  vfe_params_t *params = (vfe_params_t *)vparams;
  uint32_t camif_window_w_t, camif_window_h_t;
  if (!mod->enable) {
    CDBG("%s: BF not enabled", __func__);
    return status;
  }

  camif_window_w_t = params->sensor_parms.lastPixel -
    params->sensor_parms.firstPixel + 1;
  camif_window_h_t = params->sensor_parms.lastLine -
    params->sensor_parms.firstLine + 1;

  CDBG("%s:\n",__func__);
  CDBG("camif_window_w_t :%u\n", camif_window_w_t);
  CDBG("camif_window_h_t :%u\n", camif_window_h_t);

  mod->bf_stats_cmd.rgnHOffset = 8;//FLOOR2(camif_window_w_t%18);
  mod->bf_stats_cmd.rgnVOffset = 2;//FLOOR2(camif_window_h_t%14);
  mod->bf_stats_cmd.rgnWidth   = FLOOR2((camif_window_w_t - 8 )/18) - 1;
  mod->bf_stats_cmd.rgnHeight  = FLOOR2((camif_window_h_t - 2 )/14) - 1;
  mod->bf_stats_cmd.rgnHNum    = 17;
  mod->bf_stats_cmd.rgnVNum    = 13;
  mod->bf_stats_cmd.r_fv_min   = 10;
  mod->bf_stats_cmd.gr_fv_min  = 10;
  mod->bf_stats_cmd.b_fv_min   = 10;
  mod->bf_stats_cmd.gb_fv_min  = 10;
  mod->bf_stats_cmd.a00        = 0;
  mod->bf_stats_cmd.a01        = 0;
  mod->bf_stats_cmd.a02        = 5;
  mod->bf_stats_cmd.a03        = 0;
  mod->bf_stats_cmd.a04        = 0;
  mod->bf_stats_cmd.a10        = -2;
  mod->bf_stats_cmd.a11        = -2;
  mod->bf_stats_cmd.a12        = 3;
  mod->bf_stats_cmd.a13        = -2;
  mod->bf_stats_cmd.a14        = -2;

  vfe_bf_stats_debug(mod);
  status = vfe_util_write_hw_cmd(params->camfd, CMD_GENERAL,
    &(mod->bf_stats_cmd),
    sizeof(mod->bf_stats_cmd), VFE_CMD_STATS_BF_START);
  if (VFE_SUCCESS != status) {
    CDBG_ERROR("%s: failed %d", __func__, status);
    return status;
  }
  return status;
} /* vfe_bf_stats_config */

/*===========================================================================
 * FUNCTION   : mm_camera_poll_fn
 *
 * DESCRIPTION: polling thread routine
 *
 * PARAMETERS :
 *   @poll_cb : ptr to poll thread object
 *
 * RETURN     : none
 *==========================================================================*/
static void *mm_camera_poll_fn(mm_camera_poll_thread_t *poll_cb)
{
    int rc = 0, i;

    if (NULL == poll_cb) {
        CDBG_ERROR("%s: poll_cb is NULL!\n", __func__);
        return NULL;
    }
    CDBG("%s: poll type = %d, num_fd = %d poll_cb = %p\n",
         __func__, poll_cb->poll_type, poll_cb->num_fds,poll_cb);
    do {
         for(i = 0; i < poll_cb->num_fds; i++) {
            poll_cb->poll_fds[i].events = POLLIN|POLLRDNORM|POLLPRI;
         }

         rc = poll(poll_cb->poll_fds, poll_cb->num_fds, poll_cb->timeoutms);
         if(rc > 0) {
            if ((poll_cb->poll_fds[0].revents & POLLIN) &&
                (poll_cb->poll_fds[0].revents & POLLRDNORM)) {
                /* if we have data on pipe, we only process pipe in this iteration */
                CDBG("%s: cmd received on pipe\n", __func__);
                mm_camera_poll_proc_pipe(poll_cb);
            } else {
                for(i=1; i<poll_cb->num_fds; i++) {
                    /* Checking for ctrl events */
                    if ((poll_cb->poll_type == MM_CAMERA_POLL_TYPE_EVT) &&
                        (poll_cb->poll_fds[i].revents & POLLPRI)) {
                        CDBG("%s: mm_camera_evt_notify\n", __func__);
                        if (NULL != poll_cb->poll_entries[i-1].notify_cb) {
                            poll_cb->poll_entries[i-1].notify_cb(poll_cb->poll_entries[i-1].user_data);
                        }
                    }

                    if ((MM_CAMERA_POLL_TYPE_DATA == poll_cb->poll_type) &&
                        (poll_cb->poll_fds[i].revents & POLLIN) &&
                        (poll_cb->poll_fds[i].revents & POLLRDNORM)) {
                        CDBG("%s: mm_stream_data_notify\n", __func__);
                        if (NULL != poll_cb->poll_entries[i-1].notify_cb) {
                            poll_cb->poll_entries[i-1].notify_cb(poll_cb->poll_entries[i-1].user_data);
                        }
                    }
                }
            }
        } else {
            /* in error case sleep 10 us and then continue. hard coded here */
            usleep(10);
            continue;
        }
    } while ((poll_cb != NULL) && (poll_cb->state == MM_CAMERA_POLL_TASK_STATE_POLL));
    return NULL;
}

/*===========================================================================
 * FUNCTION    - isp_stats_config_stream -
 *
 * DESCRIPTION:
 *==========================================================================*/
int isp_stats_config_stats_stream(isp_stats_entry_t *entry, int num_bufs)
{
  int rc = 0;
  struct msm_vfe_stats_stream_request_cmd req_cmd;

  entry->num_bufs = num_bufs;
  memset(&req_cmd, 0, sizeof(req_cmd));
  req_cmd.session_id = entry->session_id;
  req_cmd.stream_id = isp_stats_get_stream_id(entry);
  req_cmd.stats_type = entry->stats_type;
  req_cmd.buffer_offset = entry->buf_offset;
  req_cmd.composite_flag = entry->comp_flag;

  switch (entry->hfr_mode) {
  case CAM_HFR_MODE_OFF:
    req_cmd.framedrop_pattern = NO_SKIP;
    break;
  case CAM_HFR_MODE_60FPS:
    req_cmd.framedrop_pattern = EVERY_2FRAME;
    break;
  case CAM_HFR_MODE_90FPS:
    req_cmd.framedrop_pattern = EVERY_3FRAME;
    break;
  case CAM_HFR_MODE_120FPS:
    req_cmd.framedrop_pattern = EVERY_4FRAME;
    break;
  case CAM_HFR_MODE_150FPS:
    req_cmd.framedrop_pattern = EVERY_5FRAME;
    break;
  default:
    req_cmd.framedrop_pattern = NO_SKIP;
  }

  rc = ioctl(entry->fd, VIDIOC_MSM_ISP_REQUEST_STATS_STREAM, &req_cmd);
  if (rc < 0) {
    CDBG_ERROR("%s: cannot request stream for stats 0x%x\n",
      __func__, entry->stats_type);
    return rc;
  }

  entry->stream_handle = req_cmd.stream_handle;
  rc = isp_stats_reg_buf(entry);
  if (rc < 0) {
     ISP_DBG(ISP_MOD_STATS, "%s: isp request buffer failed, rc = %d\n", __func__, rc);
    struct msm_vfe_stats_stream_release_cmd rel_cmd;
    rel_cmd.stream_handle = entry->stream_handle;
    ioctl(entry->fd, VIDIOC_MSM_ISP_RELEASE_STATS_STREAM, &rel_cmd);
  }

  return rc;
}

/*===========================================================================
 * FUNCTION    - isp_pix_pipeline_trigger_update -
 *
 * DESCRIPTION:
 *
 * DEPENDENCY: This function needs to be called after set_parms.
 *==========================================================================*/
int isp_pipeline_util_trigger_update(isp_pipeline_t *pix)
{
  int i, num, rc = 0;
  uint16_t *module_ids = NULL;
  isp_pix_params_t *params = &pix->pix_params;
  isp_pix_trigger_update_input_t *trigger_update_params =
    &params->cfg_and_3a_params;
  isp_stats_udpate_t *stats_update =
    &trigger_update_params->trigger_input.stats_update;
   uint8_t is_bayer_input = isp_pipeline_util_is_bayer_fmt(pix);

  if (!is_bayer_input) {
    return rc;
  }

  module_ids = pix->dep.mod_trigger_update_order_bayer;
  num = pix->dep.num_mod_trigger_update_order_bayer;
  if (stats_update->awb_update.color_temp == 0) {
    /* zero color temperature. no update needed */
    CDBG_ERROR("%s: zero color temperture. No update needed\n", __func__);
    return 0;
  }
  for (i = 0; i < num; i++) {
    if (((1 << module_ids[i]) & pix->pix_params.cur_module_mask) &&
        pix->mod_ops[module_ids[i]] && (module_ids[i] != ISP_MOD_STATS)) {
      rc = pix->mod_ops[module_ids[i]]->set_params(
             pix->mod_ops[module_ids[i]]->ctrl,
             ISP_HW_MOD_SET_TRIGGER_UPDATE,
             trigger_update_params,
             sizeof(isp_pix_trigger_update_input_t));
      if (rc < 0) {
        CDBG_ERROR("%s: module %d config failed\n", __func__, i);
        return rc;
      }
    }
  }
  return 0;
}

/*===========================================================================
 * FUNCTION    - x -
 *
 * DESCRIPTION:
 *==========================================================================*/
static int8_t sensor_util_get_output_dimension_info(void *sctrl)
{
  struct sensor_cfg_data cfg;
  int index = 0;
  sensor_ctrl_t *ctrl = (sensor_ctrl_t *) sctrl;
  if (ctrl->sfd <= 0) {
    CDBG_ERROR("%s failed %d\n", __func__, __LINE__);
    return -EINVAL;
  }

  cfg.cfgtype = CFG_GET_OUTPUT_INFO;
  cfg.cfg.output_info.output_info = &ctrl->sensor.output_info[0];
  if (ioctl(ctrl->sfd, MSM_CAM_IOCTL_SENSOR_IO_CFG, &cfg) < 0) {
    CDBG_ERROR("%s failed %d\n", __func__, __LINE__);
    return -EIO;
  }
  ctrl->sensor.num_res = cfg.cfg.output_info.num_info;

  for (index = 0; index < ctrl->sensor.num_res; index++) {
    CDBG("%s: x_output[%d]: %d\n", __func__, index,
         ctrl->sensor.output_info[index].x_output);
    CDBG("%s: y_output[%d]: %d\n", __func__, index,
         ctrl->sensor.output_info[index].y_output);
    CDBG("%s: line_length_pclk[%d]: %d\n", __func__, index,
         ctrl->sensor.output_info[index].line_length_pclk);
    CDBG("%s: frame_length_lines[%d]: %d\n", __func__, index,
         ctrl->sensor.output_info[index].frame_length_lines);
    CDBG("%s: vt_pixel_clk[%d]: %d\n", __func__, index,
         ctrl->sensor.output_info[index].vt_pixel_clk);
    CDBG("%s: op_pixel_clk[%d]: %d\n", __func__, index,
         ctrl->sensor.output_info[index].op_pixel_clk);
    CDBG("%s: binning_factor[%d]: %d\n", __func__, index,
         ctrl->sensor.output_info[index].binning_factor);
  }

  CDBG("%s exit\n", __func__);
  return 0;
}

/** main:
 *
 *  Arguments:
 *    @argc
 *    @argv
 *
 *  Return:
 *       0 or -ve values
 *
 *  Description:
 *       main function
 *
 **/
int main(int argc, char* argv[])
{
  jpeg_test_input_t *p_test_input;
  int ret = 0;
  if (argc > 1) {
    p_test_input = calloc(2, sizeof(*p_test_input));
    if (!p_test_input) {
      CDBG_ERROR("%s:%d] Error",__func__, __LINE__);
      goto exit;
    }
    memcpy(p_test_input, &jpeg_input[0], sizeof(*p_test_input));
    ret = mm_jpeg_test_get_input(argc, argv, p_test_input);
    if (ret) {
      CDBG_ERROR("%s:%d] Error",__func__, __LINE__);
      goto exit;
    }
  } else {
    mm_jpeg_test_print_usage();
    return 1;
  }
  ret = encode_test(p_test_input);

exit:
  if (!ret) {
    fprintf(stderr, "%-25s\n", "Success!");
  } else {
    fprintf(stderr, "%-25s\n", "Fail!");
  }

  if (argc > 1) {
    if (p_test_input) {
      free(p_test_input);
      p_test_input = NULL;
    }
  }

  return ret;
}