{
}
-static void
-wrapper_default_dis_process (struct atomisp_dis_statistics *stats,
- struct atomisp_dis_vector *motion_vector)
-{
-}
-
-static void
-wrapper_default_dis_calc_still (struct atomisp_dis_vector * vector, int frame_number)
+static void wrapper_default_enable(gboolean enable)
{
}
}
static void
-wrapper_default_still_compose (advci_frame_t *com_buf,
- advci_frame_t bufs[],
- int frame_dis,
- struct atomisp_dis_vector vectors[])
-{
-}
-
-static void
wrapper_default_AeSetFlickerMode(advci_ae_flicker_mode mode)
{
}
-static void
-wrapper_default_AeGetFlickerMode(advci_ae_flicker_mode *mode)
+static advci_ae_flicker_mode
+wrapper_default_AeGetFlickerMode(void)
{
+
+return advci_ae_flicker_mode_off;
}
+
static void
wrapper_default_AeSetExposureProgram(advci_ae_exposure_program program)
{
{
}
-static void wrapper_default_AfGetMode(advci_af_mode *mode)
+static advci_af_mode wrapper_default_AfGetMode()
{
+return advci_af_mode_auto;
}
static void wrapper_default_AfSetRange(advci_af_range range)
{
}
-static void wrapper_default_AfGetRange(advci_af_range *range)
+static advci_af_range wrapper_default_AfGetRange(advci_af_range *range)
{
+ return advci_af_range_norm;
}
static void wrapper_default_AwbSetMode(advci_awb_mode mode)
{
}
-static void wrapper_default_AwbGetMode(advci_awb_mode *mode)
+static advci_awb_mode wrapper_default_AwbGetMode()
{
+ return advci_awb_mode_auto;
}
static void wrapper_default_AwbSetLightSource(advci_awb_light_source ls)
{
}
-static void
-wrapper_default_AwbGetLightSource(advci_awb_light_source *ls)
+static advci_awb_light_source
+wrapper_default_AwbGetLightSource(void)
{
+return advci_awb_light_source_other;
}
static ci_adv_Err
{
}
-static void wrapper_default_AfGetStillAfStatus(advci_af_status *status)
-{
-}
-
-static gboolean wrapper_default_af_is_complete(void)
+static advci_af_status wrapper_default_AfGetStillAfStatus()
{
- return TRUE;
+ return advci_af_status_busy;
}
static void wrapper_default_RerVersion(int * major, int * minor)
return;
}
-static ci_adv_Err wrapper_default_AeGetManualShutter(int *time)
+static ci_adv_Err wrapper_default_AeGetManualShutter(float *time)
{
return ci_adv_Success;
}
-static void
-wrapper_default_Awbdata(unsigned * num_p, unsigned * avg_r,
- unsigned * avg_gr,
- unsigned * avg_b, unsigned * avg_gb)
-{
- return;
-}
-
-static void wrapper_default_AeGetManualAperture(int *aperture)
+static int wrapper_default_AeGetManualAperture()
{
+return 1;
}
static void wrapper_default_AeGetFlashMode(advci_ae_flash_mode *mode)
{
}
-static void wrapper_default_AwbGetManualColorTemperature(int *ctemp)
-{
-}
-
-static void
-wrapper_default_Awbmatrix(int msqWbGain[3], int msqCcMtrx[9], unsigned short * shift)
-{
-}
-
-static void wrapper_default_GetGridInfo(void * grid_info)
+static int wrapper_default_AwbGetManualColorTemperature()
{
+return 0;
}
static void
}
static void
-wrapper_default_Ae_Af_SetWindow( advci_window *window)
+wrapper_default_Ae_Af_SetWindows(int count, advci_window *window)
{
}
static void wrapper_default_af_start( )
static void wrapper_default_af_stop( )
{
}
-static void wrapper_default_ae_calc_for_flash( )
-{
-}
-static void wrapper_default_calc_without_flash( )
-{
-}
-
-static void wrapper_default_calc_with_flash( )
+static void wrapper_default_process_flash(advci_flash_stage stage )
{
}
static void wrapper_default_AeAfAwb_process( struct timeval *frame_timestamp)
{
}
-static void wrapper_default_get_statistics( )
-{
-}
-
-static void wrapper_default_awb_apply_results( )
-{
-}
static void wrapper_default_AwbSetImageEffect(advci_image_effect effect)
{
}
{
}
-static gboolean
-wrapper_default_af_assist_light_needed(void)
+static void
+wrapper_default_af_assist_light_needed(gboolean *need)
{
-return FALSE;
}
static ci_adv_Err wrapper_default_AeSetManualIso(int sensitivity)
return 0;
}
-static void
-wrapper_default_GetMakerNote(advci_mknote_mode mknMode, advci_mknote *note)
-{
-}
-
-static void
-wrapper_default_PutMakerNote(advci_mknote *mknData)
-{
-
-}
-
-static void
-wrapper_default_ResetMakerNote(void)
-{
-}
-
/*------------------------------------------------------------------------------------------------*/
-#ifdef USE_STATIC_3A
-static void
-lib_3a_void (void)
-{
- return;
-}
-
-static int
-lib_3a_int_void (void)
-{
- return 0;
-}
-
-static void
-lib_3a_ae (void)
-{
- return;
-}
-
-static void
-lib_3a_init(void)
+void
+lib_3a_link_functions_init (GstV4l2MFLDAdvCI *mfldadvci, GModule *mod)
{
+ gboolean ret = TRUE;
const char *env;
use_3A_debug= ((env = getenv ("LIBMFLDCAM_DEBUG")) && strstr (env, "verbose"));
- cam_lib_3a_dbg("%s:%d", __func__, __LINE__);
-}
-
-static void
-lib_3a_uninit(void)
-{
- cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
- ci_adv_uninit();
-}
-
-static void
-lib_3a_dis_process (struct atomisp_dis_statistics *stats,
- struct atomisp_dis_vector *motion_vector)
-{
- cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
- return;
-}
-static void
-lib_3a_dis_calc_still (struct atomisp_dis_vector * vector, int frame_number)
-{
- cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
- return;
-}
-
-static void
-lib_3a_do_redeye_removal (advci_frame_t *frame)
-{
- cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
-}
-
-static void
-lib_3a_still_compose (advci_frame_t *com_buf,
- advci_frame_t bufs[],
- int frame_dis,
- struct atomisp_dis_vector vectors[])
-{
- cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
- return;
-}
-
-static void
-lib_3a_AeSetFlickerMode(advci_ae_flicker_mode mode)
-{
- cam_lib_3a_dbg("%s:%d mode:%d\n", __func__, __LINE__,mode);
- ci_adv_ae_set_flicker_mode((advci_ae_flicker_mode)mode);
-}
-
-static void
-lib_3a_AeGetFlickerMode(advci_ae_flicker_mode *mode)
-{
- cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
- *mode= ia_3a_ae_get_flicker_mode();
-}
-
-static void
-lib_3a_AeSetExposureProgram(advci_ae_exposure_program program)
-{
- cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
- ci_adv_ae_set_exposure_program(program);
-}
-
-static void
-lib_3a_AeGetExposureProgram(advci_ae_exposure_program *program)
-{
- cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
- ci_adv_ae_get_exposure_program((ia_3a_ae_exposure_program *)program);
-}
-
-static void
-lib_3a_AfSetMode(advci_af_mode mode)
-{
- cam_lib_3a_dbg("%s:%d mode:%d\n", __func__, __LINE__,mode);
- ci_adv_af_set_mode(mode);
-}
-
-static void
-lib_3a_AfGetMode(advci_af_mode *mode)
-{
- cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
- *mode = ia_3a_af_get_focus_mode();
-}
-
-static void
-lib_3a_AfSetRange(advci_af_range range)
-{
- cam_lib_3a_dbg ("%s:%d\n", __func__, __LINE__);
- ci_adv_af_set_range(range);
-}
-
-static void
-lib_3a_AfGetRange(advci_af_range *range)
-{
- cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
- *range = ia_3a_af_get_focus_range();
-}
-
-static void
-lib_3a_AwbSetMode(advci_awb_mode mode)
-{
- cam_lib_3a_dbg("%s:%d mode:%d\n" , __func__, __LINE__,mode);
- ci_adv_awb_set_mode(mode);
-}
-
-static void
-lib_3a_AwbGetMode(advci_awb_mode *mode)
-{
- *mode = ia_3a_awb_get_mode();
-}
-
-static void
-lib_3a_AwbSetLightSource(advci_awb_light_source ls)
-{
- cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
- ci_adv_awb_set_light_source(ls);
-}
-
-static void
-lib_3a_AwbGetLightSource(advci_awb_light_source *ls)
-{
- cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
- *ls = ia_3a_awb_get_light_source();
-}
-
-static ci_adv_Err
-lib_3a_int_int (int i)
-{
- cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
- return ci_adv_Success;
-}
-
-static ci_adv_Err
-lib_3a_intp (int *p)
-{
- cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
- return ci_adv_Success;
-}
-
-static int
-lib_3a_isp_set_fd (int fd, const char *sensor_id)
-{
- int sensor_type;
- ia_3a_window window;
-
- cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
- if (ci_adv_init(sensor_id, fd, NULL) == 0) {
- sensor_type = SENSOR_TYPE_RAW;
- } else {
- sensor_type = SENSOR_TYPE_SOC;
- }
-
- if (sensor_type == SENSOR_TYPE_RAW) {
- cam_lib_3a_dbg("SENSOR_TYPE_RAW");
- ci_adv_awb_enable(TRUE);
- ci_adv_awb_lock(FALSE);
-
- ci_adv_ae_enable(TRUE);
- ci_adv_ae_lock(FALSE);
-
- ci_adv_af_enable(TRUE);
- ci_adv_af_lock(FALSE);
-
- window.x_left = 0;
- window.x_right = 0,
- window.y_top = 0;
- window.y_bottom = 0;
- window.weight = 0;
-
- ci_adv_ae_set_window(&window);
-
- ci_adv_ae_set_exposure_program(advci_ae_exposure_program_auto);
- ci_adv_ae_set_mode(ia_3a_ae_mode_auto);
- ci_adv_ae_set_metering_mode(advci_ae_metering_mode_center);
- ci_adv_af_set_range (advci_af_range_full);
- ci_adv_awb_set_mode(advci_awb_mode_auto);
- ci_adv_af_set_mode(advci_af_mode_auto);
- ci_adv_af_set_metering_mode (advci_af_metering_mode_auto);
-
- }
-
- return sensor_type;
-}
-
-static void
-lib_3a_switch_mode (advci_isp_mode mode, float frame_rate)
-{
- cam_lib_3a_dbg("%s:%d mode:%d frame_rate:%f\n", __func__, __LINE__, mode,frame_rate);
- ci_adv_configure((ia_3a_isp_mode)mode, frame_rate);
-}
-
-static ci_adv_Err lib_3a_AeGetWindowsNum(int *num)
-{
- cam_lib_3a_dbg ("%s:%d\n", __func__, __LINE__);
- return ci_adv_Success;
-}
+ g_module_symbol (mod, "ci_adv_af_set_mode", (gpointer) &mfldadvci->AfSetMode);
+ g_module_symbol (mod, "ia_3a_af_get_focus_mode", (gpointer) &mfldadvci->AfGetMode);
+
+ g_module_symbol (mod, "ci_adv_af_start", (gpointer) &mfldadvci->af_start);
+ g_module_symbol (mod, "ci_adv_af_stop", (gpointer) &mfldadvci->af_stop);
+
+ g_module_symbol (mod, "ci_adv_process_frame", (gpointer) &mfldadvci->AeAfAwb_process);
+ g_module_symbol (mod, "ci_adv_uninit", (gpointer) &mfldadvci->uninit);
+ g_module_symbol (mod, "ci_adv_init", (gpointer) &mfldadvci->isp_set_fd);
+ g_module_symbol (mod, "ci_adv_configure", (gpointer) &mfldadvci->switch_mode);
+ g_module_symbol (mod, "ci_adv_ae_set_flash_mode", (gpointer) &mfldadvci->AeSetFlashMode);
+ g_module_symbol (mod, "ia_3a_ae_get_flash_mode", (gpointer) &mfldadvci->AeGetFlashMode);
+ g_module_symbol (mod, "ci_adv_awb_set_mode", (gpointer) &mfldadvci->AwbSetMode);
+ g_module_symbol (mod, "ia_3a_awb_get_mode", (gpointer) &mfldadvci->AwbGetMode);
+ g_module_symbol (mod, "ci_adv_ae_is_flash_necessary", (gpointer) &mfldadvci->ae_is_flash_needed);
+ g_module_symbol (mod, "ci_adv_af_need_assist_light", (gpointer) &mfldadvci->af_assist_light_needed);
+ g_module_symbol (mod, "ci_adv_ae_set_manual_iso", (gpointer) &mfldadvci->AeSetIso);
+ g_module_symbol (mod, "ci_adv_ae_set_flicker_mode", (gpointer) &mfldadvci->AeSetFlickerMode);
+ g_module_symbol (mod, "ia_3a_ae_get_flicker_mode", (gpointer) &mfldadvci->AeGetFlickerMode);
+ g_module_symbol (mod, "ci_adv_ae_set_exposure_program", (gpointer) &mfldadvci->AeSetExposureProgram);
+ g_module_symbol (mod, "ci_adv_ae_get_exposure_program", (gpointer) &mfldadvci->AeGetExposureProgram);
+ g_module_symbol (mod, "ci_adv_process_for_flash", (gpointer) &mfldadvci->process_flash);
+ g_module_symbol (mod, "ci_adv_af_set_range", (gpointer) &mfldadvci->AfSetRange);
+ g_module_symbol (mod, "ia_3a_af_get_focus_range", (gpointer) &mfldadvci->AfGetRange);
+ g_module_symbol (mod, "ci_adv_af_version", (gpointer) &mfldadvci->AfVersion);
+ g_module_symbol (mod, "ci_adv_awb_version", (gpointer) &mfldadvci->AwbVersion);
+ g_module_symbol (mod, "ci_adv_ae_version", (gpointer) &mfldadvci->AeVersion);
+ g_module_symbol (mod, "ci_adv_awb_set_light_source", (gpointer) &mfldadvci->AwbSetLightSource);
+ g_module_symbol (mod, "ia_3a_awb_get_light_source", (gpointer) &mfldadvci->AwbGetLightSource);
+ g_module_symbol (mod, "ci_adv_ae_set_manual_shutter", (gpointer) &mfldadvci->AeGetManualShutter);
+ g_module_symbol (mod, "ia_3a_ae_get_manual_aperture", (gpointer) &mfldadvci->AeGetManualAperture);
+ g_module_symbol (mod, "ia_3a_awb_get_manual_color_temperature", (gpointer) &mfldadvci->AwbGetManualColorTemperature);
+ g_module_symbol (mod, "ci_adv_ae_set_window", (gpointer) &mfldadvci->AeSetWindow);
+ g_module_symbol (mod, "ci_adv_af_set_windows", (gpointer) &mfldadvci->AfSetWindows);
+ g_module_symbol (mod, "ia_3a_ae_get_window", (gpointer) &mfldadvci->AeGetWindow);
+ g_module_symbol (mod, "ci_adv_ae_set_metering_mode", (gpointer) &mfldadvci->AeSetMeteringMode);
+ g_module_symbol (mod, "ia_3a_ae_get_metering_mode", (gpointer) &mfldadvci->AeGetMeteringMode);
+ g_module_symbol (mod, "ci_adv_af_set_metering_mode", (gpointer) &mfldadvci->AfSetMeteringMode);
+ g_module_symbol (mod, "ci_adv_af_get_metering_mode", (gpointer) &mfldadvci->AfGetMeteringMode);
+ g_module_symbol (mod, "ia_3a_ae_get_window", (gpointer) &mfldadvci->AfGetWindow);
+ g_module_symbol (mod, "ci_adv_isp_set_image_effect", (gpointer) &mfldadvci->AwbSetImageEffect);
+ g_module_symbol (mod, "ci_adv_isp_get_image_effect", (gpointer) &mfldadvci->AwbGetImageEffect);
+ g_module_symbol (mod, "ci_adv_af_get_status", (gpointer) &mfldadvci->AfGetStillAfStatus);
+
+ g_module_symbol (mod, "ci_adv_ae_enable", (gpointer) &mfldadvci->AwbEnable);
+ g_module_symbol (mod, "ci_adv_af_enable", (gpointer) &mfldadvci->AeEnable);
+ g_module_symbol (mod, "ci_adv_awb_enable", (gpointer) &mfldadvci->AfEnable);
+
+
+ g_module_symbol (mod, "ci_adv_awb_lock", (gpointer) &mfldadvci->AwbLock);
+ g_module_symbol (mod, "ci_adv_ae_lock", (gpointer) &mfldadvci->AeLock);
+ g_module_symbol (mod, "ci_adv_af_lock", (gpointer) &mfldadvci->AfLock);
-static void lib_3a_AwbVersion(int * major, int * minor)
-{
- cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
- ci_adv_awb_version(major,minor);
-}
-
-static void lib_3a_AeVersion(int * major, int * minor)
-{
- cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
- ci_adv_ae_version(major,minor);
-}
-
-static void lib_3a_AfVersion(int * major, int * minor)
-{
- cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
- ci_adv_af_version(major,minor);
-}
-
-static void lib_3a_AfGetStillAfStatus(advci_af_status *status)
-{
- *status = ci_adv_af_get_status();
-}
-
-static gboolean lib_3a_af_is_complete(void)
-{
-
- advci_af_status status;
- gboolean completed = FALSE;
-
- lib_3a_AfGetStillAfStatus(&status);
-
- if (status == advci_af_status_error) {
- cam_lib_3a_dbg("==== still AF failed \n");
- completed = TRUE;
- }
- else if (status == advci_af_status_success) {
- cam_lib_3a_dbg("==== still AF success");
- completed = TRUE;
- } else if (status == advci_af_status_cancelled) {
- cam_lib_3a_dbg("==== still AF cancelled \n");
- completed = TRUE;
- }
- else {
- cam_lib_3a_dbg("==== still AF continue %d \n", status);
- }
-
- return completed;
-}
-
-static void lib_3a_RerVersion(int * major, int * minor)
-{
- cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
- return;
-}
-
-static ci_adv_Err lib_3a_AeGetManualShutter(int *time)
-{
- /* TODO time is float */
- cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
- ci_adv_ae_set_manual_shutter((float)*time);
- return ci_adv_Success;
-}
-
-static void lib_3a_Awbdata(unsigned * num_p, unsigned * avg_r, unsigned * avg_gr,
- unsigned * avg_b, unsigned * avg_gb)
-{
- cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
- return;
-}
-
-static void lib_3a_AeGetManualAperture(int *aperture)
-{
- // TODO returns float
- cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
- *aperture = (int)ia_3a_ae_get_manual_aperture();
-}
-
-static void lib_3a_AeGetFlashMode(advci_ae_flash_mode *mode)
-{
- cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
- *mode= ia_3a_ae_get_flash_mode();
-}
-
-static void lib_3a_AeSetFlashMode(advci_ae_flash_mode mode)
-{
- cam_lib_3a_dbg("%s:%d mode:%d \n", __func__, __LINE__, mode);
- ci_adv_ae_set_flash_mode(mode);
-}
-
-static void lib_3a_AwbGetManualColorTemperature(int *ctemp)
-{
- cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
- *ctemp = ia_3a_awb_get_manual_color_temperature();
-}
-
-static void
-lib_3a_Awbmatrix(int msqWbGain[3], int msqCcMtrx[9], unsigned short * shift)
-{
- cam_lib_3a_dbg ("%s:%d\n", __func__, __LINE__);
-}
-
-static void lib_3a_GetGridInfo(void * grid_info)
-{
- cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
-}
-
-static void
-lib_3a_AeSetMeteringMode(advci_ae_metering_mode mode)
-{
- cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
- ci_adv_ae_set_metering_mode((ia_3a_ae_metering_mode)mode);
-}
-
-static void
-lib_3a_AeGetMeteringMode(advci_ae_metering_mode *mode)
-{
- cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
- *mode = ia_3a_ae_get_metering_mode();
-}
-
-static void
-lib_3a_AfSetMeteringMode(advci_af_metering_mode mode)
-{
- cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
- ci_adv_af_set_metering_mode(mode);
-}
-
-static void
-lib_3a_AfGetMeteringMode(advci_af_metering_mode *mode)
-{
- cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
- ci_adv_af_get_metering_mode((ia_3a_af_metering_mode *)mode);
-}
-
-static void
-lib_3a_Ae_Af_GetWindow(advci_window *window)
-{
- cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
- ia_3a_ae_get_window((ia_3a_window *)window);
-}
-
-static void
-lib_3a_Ae_Af_SetWindow( advci_window *window)
-{
- cam_lib_3a_dbg("%s:window....%d:%d:%d:%d:%d\n",
- __func__, window->x_left,window->x_right,
- window->y_top , window->y_bottom, window->weight);
-
- ci_adv_ae_set_window((ia_3a_window *)window);
- ci_adv_af_set_windows(1, (ia_3a_window *)window);
-}
-
-static void
-lib_3a_af_start( )
-{
- cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
- ci_adv_af_start();
-}
-
-static void
-lib_3a_af_stop( )
-{
- cam_lib_3a_dbg ("%s:%d\n", __func__, __LINE__);
- ci_adv_af_stop();
-}
-
-static void
-lib_3a_ae_calc_for_flash( )
-{
- cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
- ci_adv_process_for_flash(ia_3a_flash_stage_none);
-}
-static void
-lib_3a_calc_without_flash( )
-{
- cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
- ci_adv_process_for_flash(ia_3a_flash_stage_pre);
-}
-
-static void
-lib_3a_calc_with_flash( )
-{
- cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
- ci_adv_process_for_flash(ia_3a_flash_stage_main);
-}
-
-static void
-lib_3a_AeAfAwb_process( struct timeval *frame_timestamp)
-{
- int status;
- // cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
- status = ci_adv_process_frame(TRUE,frame_timestamp);
-}
-static void
-lib_3a_get_statistics( )
-{
- // cam_lib_3a_dbg("%s:%d\n", __func__, __LINE__);
- ci_adv_3a_stat cur_stat;
- ci_adv_get_3a_stat (&cur_stat);
- /* cam_lib_3a_dbg("%8.3f, %8.3f, %8.3f, %8.3f, %8d, %8.3f, %8.3f, %8.3f\n",
- cur_stat.bv,
- cur_stat.tv,
- cur_stat.sv,
- cur_stat.av,
- cur_stat.focus_pos,
- cur_stat.wb_gain_r,
- cur_stat.wb_gain_g,
- cur_stat.wb_gain_b);
-*/
-}
-
-static void
-lib_3a_awb_apply_results( )
-{
-}
-static void
-lib_3a_AwbSetImageEffect(advci_image_effect effect)
-{
- cam_lib_3a_dbg("%s:%d effect %d\n", __func__, __LINE__, effect);
-
- ci_adv_isp_set_image_effect(effect);
-}
-
-static void
-lib_3a_AwbGetImageEffect(advci_image_effect *effect)
-{
- *effect = ci_adv_isp_get_image_effect();
- cam_lib_3a_dbg("%s:%d effect: %d\n", __func__, __LINE__, *effect);
-
-}
-
-static void
-lib_ae_is_flash_needed(gboolean *useflash)
-{
- ci_adv_ae_is_flash_necessary((_Bool *)useflash);
- cam_lib_3a_dbg("%s:%d useflash: %d\n", __func__, __LINE__, *useflash);
-
-}
-
-static ci_adv_Err
-lib_3a_AeSetManualIso(int sensitivity)
-{
- float sv;
- if (sensitivity <=0)
- {
- cam_lib_3a_dbg("error in get log2 math computation in line %d; sensitivity: %d\n", __LINE__, sensitivity);
- return ci_adv_InvalidArgument;
- }
-
- sv = log10((float)sensitivity / 3.125) / log10(2.0);
- ci_adv_err ret = ci_adv_ae_set_manual_iso(sv);
- if(ci_adv_success != ret)
- return ret;
-
- cam_lib_3a_dbg(" *** manual set iso in EV: %f\n", sv);
-
- return ci_adv_success;
-}
-
-static ci_adv_Err
-lib_3a_AeGetManualIso(int *sensitivity)
-{
- float sv;
- ci_adv_err ret = ci_adv_ae_get_manual_iso(&sv);
- if(ci_adv_success != ret)
- return ret;
- *sensitivity = (int)(3.125 * pow(2, sv));
-
- return ci_adv_success;
-}
-
-static void
-lib_3a_GetMakerNote(advci_mknote_mode mknMode, advci_mknote *note)
-{
- note = (advci_mknote *)ci_adv_get_maker_note((ia_3a_mknote_mode)mknMode);
-}
-
-static void
-lib_3a_PutMakerNote(advci_mknote *mknData)
-{
- if (mknData != NULL)
- {
- ci_adv_put_maker_note((ia_3a_mknote *)mknData);
- }
-}
-
-static void
-lib_3a_ResetMakerNote(void)
-{
- ci_adv_reset_maker_note();
-}
-
-static gboolean
-lib_3a_af_assist_light_needed(void)
-{
- bool bNeed = FALSE;
- ci_adv_err ret = ci_adv_af_need_assist_light(&bNeed);
- cam_lib_3a_dbg("%s:%d assist_light_needed: %d\n", __func__, __LINE__, bNeed);
+ mfldadvci->initialized = 0;
+ // TODO
+ mfldadvci->init = wrapper_default_init;
+ mfldadvci->mode_spec_init = wrapper_default_int_void;
+ mfldadvci->update_dis_results = wrapper_default_void;
+ mfldadvci->do_redeye_removal = wrapper_default_do_redeye_removal;
+ mfldadvci->load_gdc_table = wrapper_default_void;
+ mfldadvci->AeSetBias = wrapper_default_int_int;
+ mfldadvci->AeGetBias = wrapper_default_intp;
+ mfldadvci->AeGetIso = wrapper_default_AeGetManualIso;
+ mfldadvci->RerVersion = wrapper_default_RerVersion;
- return bNeed;
}
void
-lib_3a_link_functions_init (GstV4l2MFLDAdvCI *mfldadvci)
-{
-
- mfldadvci->initialized = 0;
- mfldadvci->init = lib_3a_init;
- mfldadvci->uninit = lib_3a_uninit;
- mfldadvci->isp_set_fd = lib_3a_isp_set_fd;
- mfldadvci->mode_spec_init = lib_3a_int_void; /* TODO */
- mfldadvci->switch_mode = lib_3a_switch_mode;
-
- mfldadvci->AeAfAwb_process = lib_3a_AeAfAwb_process;
- mfldadvci->get_statistics = lib_3a_get_statistics; /* TODO atomisp_dis_statistics ? */
-
- mfldadvci->ae_calc_for_flash = lib_3a_ae_calc_for_flash;
- mfldadvci->ae_calc_without_flash = lib_3a_calc_without_flash;
- mfldadvci->ae_calc_with_flash = lib_3a_calc_with_flash;
-
- mfldadvci->ae_is_flash_needed = lib_ae_is_flash_needed;
- mfldadvci->af_assist_light_needed = lib_3a_af_assist_light_needed;
-
- mfldadvci->ae_apply_results = lib_3a_ae;
-
- mfldadvci->af_start = lib_3a_af_start;
- mfldadvci->af_stop = lib_3a_af_stop;
- mfldadvci->af_is_complete = lib_3a_af_is_complete;
- mfldadvci->awb_apply_results = lib_3a_awb_apply_results;
- mfldadvci->awb_calc_flash = lib_3a_void;
-
- mfldadvci->dis_read_statistics = lib_3a_void;
- mfldadvci->update_dis_results = lib_3a_void;
- mfldadvci->dis_process = lib_3a_dis_process;
- mfldadvci->dis_calc_still = lib_3a_dis_calc_still;
-
- mfldadvci->do_redeye_removal = lib_3a_do_redeye_removal;
- mfldadvci->still_compose = lib_3a_still_compose;
- mfldadvci->load_gdc_table = lib_3a_void;
-
- mfldadvci->AeSetBias = lib_3a_int_int;
- mfldadvci->AeGetBias = lib_3a_intp;
- mfldadvci->AeSetFlickerMode = lib_3a_AeSetFlickerMode;
- mfldadvci->AeGetFlickerMode = lib_3a_AeGetFlickerMode;
- mfldadvci->AeSetExposureProgram = lib_3a_AeSetExposureProgram;
- mfldadvci->AeGetExposureProgram = lib_3a_AeGetExposureProgram;
- mfldadvci->AeSetMeteringMode = lib_3a_AeSetMeteringMode;
- mfldadvci->AeGetMeteringMode = lib_3a_AeGetMeteringMode;
- mfldadvci->AeGetWindow = lib_3a_Ae_Af_GetWindow;
- mfldadvci->AeSetWindow = lib_3a_Ae_Af_SetWindow;
- mfldadvci->AeSetIso = lib_3a_AeSetManualIso;
- mfldadvci->AeGetIso = lib_3a_AeGetManualIso;
-
-
- mfldadvci->AfSetMode = lib_3a_AfSetMode;
- mfldadvci->AfGetMode = lib_3a_AfGetMode;
- mfldadvci->AfSetRange = lib_3a_AfSetRange;
- mfldadvci->AfGetRange = lib_3a_AfGetRange;
- mfldadvci->AfSetMeteringMode = lib_3a_AfSetMeteringMode;
- mfldadvci->AfGetMeteringMode = lib_3a_AfGetMeteringMode;
- mfldadvci->AfGetWindow = lib_3a_Ae_Af_GetWindow;
- mfldadvci->AfSetWindow = lib_3a_Ae_Af_SetWindow;
-
- mfldadvci->AwbSetMode = lib_3a_AwbSetMode;
- mfldadvci->AwbGetMode = lib_3a_AwbGetMode;
- mfldadvci->AwbSetLightSource = lib_3a_AwbSetLightSource;
- mfldadvci->AwbGetLightSource = lib_3a_AwbGetLightSource;
- mfldadvci->AwbSetImageEffect = lib_3a_AwbSetImageEffect;
- mfldadvci->AwbGetImageEffect = lib_3a_AwbGetImageEffect;
-
- mfldadvci->AeGetWindowsNum = lib_3a_AeGetWindowsNum;
- mfldadvci->AwbVersion = lib_3a_AwbVersion;
- mfldadvci->AeVersion = lib_3a_AeVersion;
- mfldadvci->AfVersion = lib_3a_AfVersion;
- mfldadvci->AfGetStillAfStatus = lib_3a_AfGetStillAfStatus;
- mfldadvci->RerVersion = lib_3a_RerVersion;
- mfldadvci->AeGetManualShutter = lib_3a_AeGetManualShutter;
- mfldadvci->Awbdata = lib_3a_Awbdata;
- mfldadvci->AeGetManualAperture = lib_3a_AeGetManualAperture;
- mfldadvci->AeSetFlashMode = lib_3a_AeSetFlashMode;
- mfldadvci->AeGetFlashMode = lib_3a_AeGetFlashMode;
- mfldadvci->AwbGetManualColorTemperature = lib_3a_AwbGetManualColorTemperature;
- mfldadvci->Awbmatrix = lib_3a_Awbmatrix;
- mfldadvci->GetGridInfo = lib_3a_GetGridInfo;
- mfldadvci->GetMakerNote = lib_3a_GetMakerNote;
- mfldadvci->PutMakerNote = lib_3a_PutMakerNote;
- mfldadvci->ResetMakerNote = lib_3a_ResetMakerNote;
-}
-#endif /* USE_STATIC_3A */
-void
wrapper_default_link_functions_init (GstV4l2MFLDAdvCI *mfldadvci)
{
mfldadvci->switch_mode = wrapper_default_switch_mode;
mfldadvci->AeAfAwb_process = wrapper_default_AeAfAwb_process;
- mfldadvci->get_statistics = wrapper_default_get_statistics; /* TODO atomisp_dis_statistics ? */
- mfldadvci->ae_calc_for_flash = wrapper_default_ae_calc_for_flash;
- mfldadvci->ae_calc_without_flash = wrapper_default_calc_without_flash;
- mfldadvci->ae_calc_with_flash = wrapper_default_calc_with_flash;
+ mfldadvci->process_flash = wrapper_default_process_flash;
mfldadvci->ae_is_flash_needed = wrapper_default_is_flash_needed;
mfldadvci->af_assist_light_needed = wrapper_default_af_assist_light_needed;
mfldadvci->af_start = wrapper_default_af_start;
mfldadvci->af_stop = wrapper_default_af_stop;
- mfldadvci->af_is_complete = wrapper_default_af_is_complete;
- mfldadvci->awb_apply_results = wrapper_default_awb_apply_results;
- mfldadvci->awb_calc_flash = wrapper_default_void;
- mfldadvci->dis_read_statistics = wrapper_default_void;
mfldadvci->update_dis_results = wrapper_default_void;
- mfldadvci->dis_process = wrapper_default_dis_process;
- mfldadvci->dis_calc_still = wrapper_default_dis_calc_still;
mfldadvci->do_redeye_removal = wrapper_default_do_redeye_removal;
- mfldadvci->still_compose = wrapper_default_still_compose;
mfldadvci->load_gdc_table = wrapper_default_void;
mfldadvci->AeSetBias = wrapper_default_int_int;
mfldadvci->AeSetMeteringMode = wrapper_default_AeSetMeteringMode;
mfldadvci->AeGetMeteringMode = wrapper_default_AeGetMeteringMode;
mfldadvci->AeGetWindow = wrapper_default_Ae_Af_GetWindow;
- mfldadvci->AeSetWindow = wrapper_default_Ae_Af_SetWindow;
+ mfldadvci->AeSetWindow = wrapper_default_Ae_Af_SetWindows;
mfldadvci->AeSetIso = wrapper_default_AeSetManualIso;
mfldadvci->AeGetIso = wrapper_default_AeGetManualIso;
mfldadvci->AfSetMeteringMode = wrapper_default_AfSetMeteringMode;
mfldadvci->AfGetMeteringMode = wrapper_default_AfGetMeteringMode;
mfldadvci->AfGetWindow = wrapper_default_Ae_Af_GetWindow;
- mfldadvci->AfSetWindow = wrapper_default_Ae_Af_SetWindow;
+ mfldadvci->AfSetWindows = wrapper_default_Ae_Af_SetWindows;
mfldadvci->AwbSetMode = wrapper_default_AwbSetMode;
mfldadvci->AwbGetMode = wrapper_default_AwbGetMode;
mfldadvci->AfGetStillAfStatus = wrapper_default_AfGetStillAfStatus;
mfldadvci->RerVersion = wrapper_default_RerVersion;
mfldadvci->AeGetManualShutter = wrapper_default_AeGetManualShutter;
- mfldadvci->Awbdata = wrapper_default_Awbdata;
mfldadvci->AeGetManualAperture = wrapper_default_AeGetManualAperture;
mfldadvci->AeSetFlashMode = wrapper_default_AeSetFlashMode;
mfldadvci->AeGetFlashMode = wrapper_default_AeGetFlashMode;
mfldadvci->AwbGetManualColorTemperature = wrapper_default_AwbGetManualColorTemperature;
- mfldadvci->Awbmatrix = wrapper_default_Awbmatrix;
- mfldadvci->GetGridInfo = wrapper_default_GetGridInfo;
- mfldadvci->GetMakerNote = wrapper_default_GetMakerNote;
- mfldadvci->PutMakerNote = wrapper_default_PutMakerNote;
- mfldadvci->ResetMakerNote = wrapper_default_ResetMakerNote;
+
+ mfldadvci->AwbEnable = wrapper_default_enable;
+ mfldadvci->AeEnable = wrapper_default_enable;
+ mfldadvci->AfEnable = wrapper_default_enable;
+
+ mfldadvci->AwbLock = wrapper_default_enable;
+ mfldadvci->AeLock = wrapper_default_enable;
+ mfldadvci->AfLock = wrapper_default_enable;
+
}
return CAM_ERR_NONE;
}
- mfldadvci->AwbGetMode (&mode);
+ mode = mfldadvci->AwbGetMode();
if (mode == advci_awb_mode_auto) {
*wb_mode = CAM_AWB_MODE_AUTO;
return CAM_ERR_NONE;
set_iso_speed (int iso)
{
cam_err_t ret = CAM_ERR_NONE;
+
+ float sv;
mfld_cam_settings.iso_speed = iso;
if (mfld_driver.sensor_type == SENSOR_TYPE_RAW) {
+ if (iso <=0)
+ return CAM_ERR_PARAM;
+ sv = log10((float)iso / 3.125) / log10(2.0);
ret = mfldadvci->AeSetIso(mfld_cam_settings.iso_speed);
}
return ret;
*mode = CAM_GENERAL_FLICKER_REDUCTION_MODE_AUTO;
return ret;
}
- mfldadvci->AeGetFlickerMode (&flicker_mode);
+ flicker_mode = mfldadvci->AeGetFlickerMode();
/* Convert AE flicker mode to camera general flicker mode */
switch (flicker_mode) {
do_read = TRUE;
}
if ((do_read == TRUE) || (force_update == 1)) {
- mfldadvci->AfGetStillAfStatus (&af_status);
+ af_status = mfldadvci->AfGetStillAfStatus();
*status = cam_find_item_new (focus_status_map, af_status, 1);
cam_driver_dbg ("%s *status : %d\n ", __func__, *status);
return 1;
cam_err_t
cam_driver_init (int fd, const char *sensor_id)
{
+ advci_window window;
cam_driver_dbg ("%s\n", __func__);
mfld_driver.fd = fd;
- mfld_driver.sensor_type = mfldadvci->isp_set_fd (fd, sensor_id);
+ if (mfldadvci->isp_set_fd (sensor_id, fd, NULL) == 0){
+ mfld_driver.sensor_type = SENSOR_TYPE_RAW;
+
+ mfldadvci->AwbEnable(TRUE);
+ mfldadvci->AwbLock(FALSE);
+ mfldadvci->AeEnable(TRUE);
+ mfldadvci->AeLock(FALSE);
+ mfldadvci->AfEnable(TRUE);
+ mfldadvci->AfLock(FALSE);
+
+ window.x_left = 0;
+ window.x_right = 0,
+ window.y_top = 0;
+ window.y_bottom = 0;
+ window.weight = 0;
+ mfldadvci->AeSetWindow(&window);
+
+ mfldadvci->AeSetExposureProgram(advci_ae_exposure_program_auto);
+// ci_adv_ae_set_mode(ia_3a_ae_mode_auto);
+ mfldadvci->AeSetMeteringMode(advci_ae_metering_mode_center);
+ mfldadvci->AfSetRange (advci_af_range_full);
+ mfldadvci->AwbSetMode(advci_awb_mode_auto);
+ mfldadvci->AfSetMode(advci_af_mode_auto);
+ mfldadvci->AfSetMeteringMode (advci_af_metering_mode_auto);
+
+
+
+ }
+ else
+ mfld_driver.sensor_type = SENSOR_TYPE_SOC;
cam_driver_init_gamma (fd);
com_buf.width = mfld_driver.width;
com_buf.height = mfld_driver.height;
- mfldadvci->still_compose (&com_buf, bufs, frame_dis, vectors);
-
if (mfld_driver.mmap)
munmap (com_buf.addr, com_buf.length);
}
|| mfld_driver.awb_enabled || mfld_driver.dis_enabled
|| mfld_driver.dvs_enabled) && (mfld_driver.sensor_type == SENSOR_TYPE_RAW) )
{
- mfldadvci->get_statistics ();
-
/* AE, AWB and AF Process */
- mfldadvci->AeAfAwb_process(&mfld_driver.timestamp);
+ mfldadvci->AeAfAwb_process(TRUE,&mfld_driver.timestamp);
- /* apply Results */
- if (mfld_driver.awb_enabled)
- mfldadvci->awb_apply_results ();
- if (mfld_driver.ae_enabled)
- mfldadvci->ae_apply_results ();
} else
return NULL;
}
{
// non flash
led_flash_off (fd);
- mfldadvci->ae_calc_for_flash ();
- mfldadvci->ae_apply_results ();
+ mfldadvci->process_flash(advci_flash_stage_none);
if (-1 == ioctl (fd, VIDIOC_DQBUF, buffer)) {
cam_driver_dbg ("%s: Error dqbuf %d\n", __func__, 0);
return CAM_ERR_SYS;
}
- mfldadvci->get_statistics ();
-
// pre flash
- mfldadvci->ae_calc_without_flash ();
- mfldadvci->ae_apply_results ();
+ mfldadvci->process_flash (advci_flash_stage_pre);
led_flash_trigger (fd, 0, 0);
- mfldadvci->awb_apply_results ();
if (-1 == ioctl (fd, VIDIOC_QBUF, buffer)) {
cam_driver_dbg ("%s: Error qbuf %d\n", __func__, 1);
return CAM_ERR_SYS;
cam_driver_dbg ("%s: Error dqbuf %d\n", __func__, 1);
return CAM_ERR_SYS;
}
- mfldadvci->get_statistics ();
-
// main flash
- mfldadvci->ae_calc_with_flash ();
- mfldadvci->ae_apply_results ();
- mfldadvci->awb_calc_flash ();
+ mfldadvci->process_flash (advci_flash_stage_main);
led_flash_trigger (fd, 0, 15);
- mfldadvci->awb_apply_results ();
if (-1 == ioctl (fd, VIDIOC_QBUF, buffer)) {
cam_driver_dbg ("%s: Error qbuf %d\n", __func__, 2);
return CAM_ERR_SYS;
struct cam_capture_settings *capture_settings)
{
int i;
-
+ gboolean need_assist = FALSE;
mfld_driver.mmap = capture_settings->mmap;
mfld_driver.ae_enabled = capture_settings->ae;
mfld_driver.af_enabled = capture_settings->af;
mfld_driver.start_still_af = 0;
mfld_driver.still_af_count = 1;
mfld_driver.af_start_time = mfld_driver.timestamp;
-
- if (mfldadvci->af_assist_light_needed()) {
+ mfldadvci->af_assist_light_needed(&need_assist);
+ if (need_assist) {
mfld_driver.enable_torch = TRUE;
cam_driver_set_torch(fd, TRUE);
}
cam_driver_dbg ("Begin cam_dis_get_statices\n");
if (mfld_driver.sensor_type == SENSOR_TYPE_RAW) {
- mfldadvci->dis_read_statistics (); //read_dis_stats_from_xmem();
cam_driver_dbg ("Begin cam_dis_still_process\n");
// mfldadvci->dis_process (dvs_vector); /* dis_vector only valid in video mode */
if (dis_enabled) {
- mfldadvci->dis_calc_still (&vectors[frame_cnt], frame_cnt);
+ // mfldadvci->dis_calc_still (&vectors[frame_cnt], frame_cnt);
cam_copy_v4l2buf_to_user (&bufs[frame_cnt], buffer);
}
}
}
+static gboolean cam_af_is_complete(void)
+{
+ cam_driver_dbg("%s:%d\n", __func__, __LINE__);
+
+ advci_af_status status;
+ gboolean completed = FALSE;
+
+ status = mfldadvci->AfGetStillAfStatus();
+
+ if (status == advci_af_status_error) {
+ cam_driver_dbg("==== still AF failed \n");
+ completed = TRUE;
+ }
+ else if (status == advci_af_status_success) {
+ cam_driver_dbg("==== still AF success\n");
+ completed = TRUE;
+ } else if (status == advci_af_status_cancelled) {
+ cam_driver_dbg("==== still AF cancelled \n");
+ completed = TRUE;
+ }
+ else {
+ cam_driver_dbg("==== still AF continue %d \n", status);
+ }
+
+ return completed;
+}
+
static cam_err_t
run_normal_sequence(int fd, struct v4l2_buffer *buffer)
{
gboolean complete = TRUE; /* AF status */
if (mfld_driver.af_enabled)
- complete = mfldadvci->af_is_complete ();
+ complete = cam_af_is_complete();
if (complete ||
(calculate_timediff(&mfld_driver.af_start_time, &mfld_driver.timestamp)
if (complete == 0) {
mfldadvci->af_stop();
cam_driver_dbg ("AF: Focus Failed %s\n", __func__);
- if(mfld_driver.enable_torch) {
- mfld_driver.enable_torch= FALSE;
- cam_driver_set_torch(fd, FALSE);
- }
}
+ mfld_driver.enable_torch= FALSE;
+ cam_driver_set_torch(fd, FALSE);
}
else
mfld_driver.still_af_count++;
cam_err_t get_ae_windows_num(int fd, int * num)
{
- if(ci_adv_Success != mfldadvci->AeGetWindowsNum(num))
- return CAM_ERR_3A;
+ *num = 1;
return CAM_ERR_NONE;
}
advci_af_status st;
- mfldadvci->AfGetStillAfStatus(&st);
+ st = mfldadvci->AfGetStillAfStatus();
if(advci_af_status_success == st)
*status = 1;
return CAM_ERR_NONE;
}
-cam_err_t get_awb_data(int fd, unsigned * num_p, unsigned * avg_r,
- unsigned * avg_gr, unsigned * avg_b, unsigned * avg_gb)
-{
- mfldadvci->Awbdata(num_p, avg_r, avg_gr, avg_b, avg_gb);
- return CAM_ERR_NONE;
-}
-
cam_err_t get_ae_manual_aperture(int fd, int *aperture)
{
- mfldadvci->AeGetManualAperture(aperture);
+ *aperture = mfldadvci->AeGetManualAperture();
return CAM_ERR_NONE;
}
cam_flash_mode_t ci_mode;
if (mfld_driver.sensor_type == SENSOR_TYPE_RAW) {
- mfldadvci->AeGetFlashMode(&ci_mode);
+ ci_mode = mfldadvci->AeGetFlashMode();
switch(ci_mode)
{
case advci_ae_flash_mode_auto:
return CAM_ERR_NONE;
}
-void get_awb_matrix(int fd, int msqWbGain[3],
- int msqCcMtrx[9], unsigned short *shift)
-{
-//int msqWbGain[3]; /* White balance Gain [0]:R [1]:G [2]:B */
-//int msqCcMtrx[9]; /* Color adjustment Matrix */
- mfldadvci->Awbmatrix(msqWbGain, msqCcMtrx, shift);
-}
struct sh_css_grid_info_maker_note {
/* 3A statistics grid: */
unsigned int dis_ver_coef_num;
};
-void get_grid_info(int fd, unsigned * width, unsigned * height)
-{
- struct sh_css_grid_info_maker_note grid;
-
- mfldadvci->GetGridInfo(&grid);
- *width = grid.s3a_width;
- *height = grid.s3a_height;
-}
gboolean cam_is_flash_used()
{
projects / adaptation / intel_mfld / gst-plugins-atomisp.git / commitdiff