/*
================================================================================
FUNCTION
================================================================================
*/
static void icp_hd_tup_load_init_params (const int8_t *stream)
{
int8_t *my_ptr = NULL;
CAM_INFO(">>%s ()", __func__);
CAM_INFO("- stream = 0x%08x", stream, 0, 0);
my_ptr = strstr(stream, ICP_HD_TUP_INIT_MARK);
if (my_ptr == NULL)
{
CAM_INFO("Can't find INIT mark! [stream = 0x%08x]", stream, 0, 0);
return;
}
icp_hd_tup_init_num_params = icp_hd_tup_parse_params(my_ptr, &icp_hd_tup_init_params[0]);
CAM_INFO("Number of params in %s = %d", ICP_HD_TUP_INIT_MARK, icp_hd_tup_init_num_params, 0);
CAM_INFO("========== %s ==========", ICP_HD_TUP_INIT_MARK, 0, 0);
#ifdef F_PANTECH_CAMERA_TUP_PRINT_LOAD_VALUE
icp_hd_tup_print_params(&icp_hd_tup_init_params[0], icp_hd_tup_init_num_params);
#endif
CAM_INFO("<<%s ()", __func__);
return;
}
/*
================================================================================
FUNCTION
================================================================================
*/
static void icp_hd_tup_load_antishake_params (const int8_t *stream)
{
int8_t *my_ptr = NULL;
int8_t *my_mark = NULL;
int32_t i = 0;
CAM_INFO(">>%s ()", __func__);
CAM_INFO("- stream = 0x%08x", stream, 0, 0);
for (i = 0; i < ICP_HD_CFG_ANTISHAKE_MAX; i++)
{
switch (i)
{
case ICP_HD_CFG_ANTISHAKE_OFF: my_mark = (int8_t *)ICP_HD_TUP_ANTISHAKE_NONE_MARK; break;
case ICP_HD_CFG_ANTISHAKE_ON: my_mark = (int8_t *)ICP_HD_TUP_ANTISHAKE_ON_MARK; break;
}
my_ptr = strstr(stream, my_mark);
if (my_ptr == NULL)
{
CAM_INFO("Can't find ANTISHAKE mark! [stream = 0x%08x][i = %d]", stream, i, 0);
return;
}
icp_hd_tup_antishake_num_params[i] = icp_hd_tup_parse_params(my_ptr, &icp_hd_tup_antishake_params[i][0]);
CAM_INFO("Number of params in %s = %d", my_mark, icp_hd_tup_antishake_num_params[i], 0);
CAM_INFO("========== %s ==========", my_mark, 0, 0);
#ifdef F_PANTECH_CAMERA_TUP_PRINT_LOAD_VALUE
icp_hd_tup_print_params(&icp_hd_tup_antishake_params[i][0], icp_hd_tup_antishake_num_params[i]);
#endif
}
CAM_INFO("<<%s ()", __func__);
return;
}
/*
================================================================================
FUNCTION
================================================================================
*/
static void icp_hd_tup_load_bright_params (const int8_t *stream)
{
int8_t *my_ptr = NULL;
int8_t *my_mark = NULL;
int32_t i = 0;
CAM_INFO(">>%s ()", __func__);
CAM_INFO("- stream = 0x%08x", stream, 0, 0);
for (i = ICP_HD_CFG_BRIGHT_M5; i < ICP_HD_CFG_BRIGHT_MAX; i++)
{
switch (i)
{
#ifndef BRIGHTNESS_STEP_8
case ICP_HD_CFG_BRIGHT_M5: my_mark = (int8_t *)ICP_HD_TUP_BRIGHT_M5_MARK; break;
#endif
case ICP_HD_CFG_BRIGHT_M4: my_mark = (int8_t *)ICP_HD_TUP_BRIGHT_M4_MARK; break;
case ICP_HD_CFG_BRIGHT_M3: my_mark = (int8_t *)ICP_HD_TUP_BRIGHT_M3_MARK; break;
case ICP_HD_CFG_BRIGHT_M2: my_mark = (int8_t *)ICP_HD_TUP_BRIGHT_M2_MARK; break;
case ICP_HD_CFG_BRIGHT_M1: my_mark = (int8_t *)ICP_HD_TUP_BRIGHT_M1_MARK; break;
case ICP_HD_CFG_BRIGHT_0: my_mark = (int8_t *)ICP_HD_TUP_BRIGHT_0_MARK; break;
case ICP_HD_CFG_BRIGHT_P1: my_mark = (int8_t *)ICP_HD_TUP_BRIGHT_P1_MARK; break;
case ICP_HD_CFG_BRIGHT_P2: my_mark = (int8_t *)ICP_HD_TUP_BRIGHT_P2_MARK; break;
case ICP_HD_CFG_BRIGHT_P3: my_mark = (int8_t *)ICP_HD_TUP_BRIGHT_P3_MARK; break;
case ICP_HD_CFG_BRIGHT_P4: my_mark = (int8_t *)ICP_HD_TUP_BRIGHT_P4_MARK; break;
#ifndef BRIGHTNESS_STEP_8
case ICP_HD_CFG_BRIGHT_P5: my_mark = (int8_t *)ICP_HD_TUP_BRIGHT_P5_MARK; break;
#endif
}
my_ptr = strstr(stream, my_mark);
if (my_ptr == NULL)
{
CAM_INFO("Can't find BRIGHT mark! [stream = 0x%08x][i = %d]", stream, i, 0);
return;
}
icp_hd_tup_bright_num_params[i] = icp_hd_tup_parse_params(my_ptr, &icp_hd_tup_bright_params[i][0]);
CAM_INFO("Number of params in %s = %d", my_mark, icp_hd_tup_bright_num_params[i], 0);
CAM_INFO("========== %s ==========", my_mark, 0, 0);
#ifdef F_PANTECH_CAMERA_TUP_PRINT_LOAD_VALUE
icp_hd_tup_print_params(&icp_hd_tup_bright_params[i][0], icp_hd_tup_bright_num_params[i]);
#endif
}
CAM_INFO("<<%s ()", __func__);
return;
}
/*
================================================================================
FUNCTION
================================================================================
*/
static void icp_hd_tup_load_effect_params (const int8_t *stream)
{
int8_t *my_ptr = NULL;
int8_t *my_mark = NULL;
int32_t i = 0;
CAM_INFO(">>%s ()", __func__);
CAM_INFO("- stream = 0x%08x", stream, 0, 0);
for (i = 0; i < ICP_HD_CFG_EFFECT_MAX; i++)
{
switch (i)
{
case ICP_HD_CFG_EFFECT_NONE: my_mark = (char *)ICP_HD_TUP_EFFECT_NONE_MARK; break;
case ICP_HD_CFG_EFFECT_GRAY: my_mark = (char *)ICP_HD_TUP_EFFECT_GRAY_MARK; break;
case ICP_HD_CFG_EFFECT_GREEN: my_mark = (char *)ICP_HD_TUP_EFFECT_GREEN_MARK; break;
case ICP_HD_CFG_EFFECT_COOL: my_mark = (char *)ICP_HD_TUP_EFFECT_COOL_MARK; break;
case ICP_HD_CFG_EFFECT_YELLOW: my_mark = (char *)ICP_HD_TUP_EFFECT_YELLOW_MARK; break;
case ICP_HD_CFG_EFFECT_SEPIA: my_mark = (char *)ICP_HD_TUP_EFFECT_SEPIA_MARK; break;
case ICP_HD_CFG_EFFECT_PURPLE: my_mark = (char *)ICP_HD_TUP_EFFECT_PURPLE_MARK; break;
case ICP_HD_CFG_EFFECT_RED: my_mark = (char *)ICP_HD_TUP_EFFECT_RED_MARK; break;
case ICP_HD_CFG_EFFECT_PINK: my_mark = (char *)ICP_HD_TUP_EFFECT_PINK_MARK; break;
case ICP_HD_CFG_EFFECT_AQUA: my_mark = (char *)ICP_HD_TUP_EFFECT_AQUA_MARK; break;
case ICP_HD_CFG_EFFECT_NEGATIVE: my_mark = (char *)ICP_HD_TUP_EFFECT_NEGATIVE_MARK; break;
case ICP_HD_CFG_EFFECT_SOLARIZE_1: my_mark = (char *)ICP_HD_TUP_EFFECT_SOLARIZE_1_MARK; break;
case ICP_HD_CFG_EFFECT_SOLARIZE_2: my_mark = (char *)ICP_HD_TUP_EFFECT_SOLARIZE_2_MARK; break;
}
my_ptr = strstr(stream, my_mark);
if (my_ptr == NULL)
{
CAM_INFO("Can't find EFFECT mark! [stream = 0x%08x][i = %d]", stream, i, 0);
return;
}
icp_hd_tup_effect_num_params[i] = icp_hd_tup_parse_params(my_ptr, &icp_hd_tup_effect_params[i][0]);
CAM_INFO("Number of params in %s = %d", my_mark, icp_hd_tup_effect_num_params[i], 0);
CAM_INFO("========== %s ==========", my_mark, 0, 0);
#ifdef F_PANTECH_CAMERA_TUP_PRINT_LOAD_VALUE
icp_hd_tup_print_params(&icp_hd_tup_effect_params[i][0], icp_hd_tup_effect_num_params[i]);
#endif
}
CAM_INFO("<<%s ()", __func__);
return;
}
/*
================================================================================
FUNCTION
================================================================================
*/
static void icp_hd_tup_load_ffps_params (const int8_t *stream)
{
int8_t *my_ptr = NULL;
int8_t *my_mark = NULL;
int32_t i = 0;
CAM_INFO(">>%s ()", __func__);
CAM_INFO("- stream = 0x%08x", stream, 0, 0);
for (i = ICP_HD_CFG_FFPS_MIN; i <= ICP_HD_CFG_FFPS_MAX; i++)
{
switch (i)
{
case 5: my_mark = (int8_t *)ICP_HD_TUP_FFPS_5_MARK; break;
case 6: my_mark = (int8_t *)ICP_HD_TUP_FFPS_6_MARK; break;
case 7: my_mark = (int8_t *)ICP_HD_TUP_FFPS_7_MARK; break;
case 8: my_mark = (int8_t *)ICP_HD_TUP_FFPS_8_MARK; break;
case 9: my_mark = (int8_t *)ICP_HD_TUP_FFPS_9_MARK; break;
case 10: my_mark = (int8_t *)ICP_HD_TUP_FFPS_10_MARK; break;
case 11: my_mark = (int8_t *)ICP_HD_TUP_FFPS_11_MARK; break;
case 12: my_mark = (int8_t *)ICP_HD_TUP_FFPS_12_MARK; break;
case 13: my_mark = (int8_t *)ICP_HD_TUP_FFPS_13_MARK; break;
case 14: my_mark = (int8_t *)ICP_HD_TUP_FFPS_14_MARK; break;
case 15: my_mark = (int8_t *)ICP_HD_TUP_FFPS_15_MARK; break;
}
my_ptr = strstr(stream, my_mark);
if (my_ptr == NULL)
{
CAM_INFO("Can't find fixed FPS mark! [stream = 0x%08x][i = %d]", stream, i, 0);
return;
}
icp_hd_tup_ffps_num_params[i - ICP_HD_CFG_FFPS_MIN] = icp_hd_tup_parse_params(my_ptr, &icp_hd_tup_ffps_params[i - ICP_HD_CFG_FFPS_MIN][0]);
CAM_INFO("Number of params in %s = %d", my_mark, icp_hd_tup_ffps_num_params[i - ICP_HD_CFG_FFPS_MIN], 0);
CAM_INFO("========== %s ==========", my_mark, 0, 0);
#ifdef F_PANTECH_CAMERA_TUP_PRINT_LOAD_VALUE
icp_hd_tup_print_params(&icp_hd_tup_ffps_params[i - ICP_HD_CFG_FFPS_MIN][0], icp_hd_tup_ffps_num_params[i - ICP_HD_CFG_FFPS_MIN]);
#endif
}
CAM_INFO("<<%s ()", __func__);
return;
}
/*
================================================================================
FUNCTION
================================================================================
*/
static void icp_hd_tup_load_scene_params (const int8_t *stream)
{
int8_t *my_ptr = NULL;
int8_t *my_mark = NULL;
int32_t i = 0;
CAM_INFO(">>%s ()", __func__);
CAM_INFO("- stream = 0x%08x", stream, 0, 0);
for (i = 0; i < ICP_HD_CFG_SCENE_MODE_MAX; i++)
{
switch (i)
{
case ICP_HD_CFG_SCENE_MODE_OFF: my_mark = (int8_t *)ICP_HD_TUP_SCENE_NONE_MARK; break;
case ICP_HD_CFG_SCENE_MODE_PORTRAIT: my_mark = (int8_t *)ICP_HD_TUP_SCENE_PORTRAIT_MARK; break;
case ICP_HD_CFG_SCENE_MODE_LANDSCAPE: my_mark = (int8_t *)ICP_HD_TUP_SCENE_LANDSCAPE_MARK; break;
case ICP_HD_CFG_SCENE_MODE_INDOOR: my_mark = (int8_t *)ICP_HD_TUP_SCENE_INDOOR_MARK; break;
case ICP_HD_CFG_SCENE_MODE_SPORTS: my_mark = (int8_t *)ICP_HD_TUP_SCENE_SPORTS_MARK; break;
case ICP_HD_CFG_SCENE_MODE_NIGHT: my_mark = (int8_t *)ICP_HD_TUP_SCENE_NIGHT_MARK; break;
case ICP_HD_CFG_SCENE_MODE_BEACH: my_mark = (int8_t *)ICP_HD_TUP_SCENE_BEACH_MARK; break;
case ICP_HD_CFG_SCENE_MODE_WINTER: my_mark = (int8_t *)ICP_HD_TUP_SCENE_WINTER_MARK; break;
case ICP_HD_CFG_SCENE_MODE_SUNSET: my_mark = (int8_t *)ICP_HD_TUP_SCENE_SUNSET_MARK; break;
case ICP_HD_CFG_SCENE_MODE_TEXT: my_mark = (int8_t *)ICP_HD_TUP_SCENE_TEXT_MARK; break;
case ICP_HD_CFG_SCENE_MODE_PARTY: my_mark = (int8_t *)ICP_HD_TUP_SCENE_PARTY_MARK; break;
}
my_ptr = strstr(stream, my_mark);
if (my_ptr == NULL)
{
CAM_INFO("Can't find SCENE mark! [stream = 0x%08x][i = %d]", stream, i, 0);
return;
}
icp_hd_tup_scene_num_params[i] = icp_hd_tup_parse_params(my_ptr, &icp_hd_tup_scene_params[i][0]);
CAM_INFO("Number of params in %s = %d", my_mark, icp_hd_tup_scene_num_params[i], 0);
CAM_INFO("========== %s ==========", my_mark, 0, 0);
#ifdef F_PANTECH_CAMERA_TUP_PRINT_LOAD_VALUE
icp_hd_tup_print_params(&icp_hd_tup_scene_params[i][0], icp_hd_tup_scene_num_params[i]);
#endif
}
CAM_INFO("<<%s ()", __func__);
return;
}
/*
================================================================================
FUNCTION
================================================================================
*/
static void icp_hd_tup_load_focus_step_params (const int8_t *stream)
{
int8_t *my_ptr = NULL;
int8_t *my_mark = NULL;
int32_t i = 0;
CAM_INFO(">>%s ()", __func__);
CAM_INFO("- stream = 0x%08x", stream, 0, 0);
for (i = 0; i < ICP_HD_CFG_FOCUS_STEP_MAX; i++)
{
switch (i)
{
case ICP_HD_CFG_FOCUS_STEP_0: my_mark = (int8_t *)ICP_HD_TUP_FOCUS_STEP_0_MARK; break;
case ICP_HD_CFG_FOCUS_STEP_1: my_mark = (int8_t *)ICP_HD_TUP_FOCUS_STEP_1_MARK; break;
case ICP_HD_CFG_FOCUS_STEP_2: my_mark = (int8_t *)ICP_HD_TUP_FOCUS_STEP_2_MARK; break;
case ICP_HD_CFG_FOCUS_STEP_3: my_mark = (int8_t *)ICP_HD_TUP_FOCUS_STEP_3_MARK; break;
case ICP_HD_CFG_FOCUS_STEP_4: my_mark = (int8_t *)ICP_HD_TUP_FOCUS_STEP_4_MARK; break;
case ICP_HD_CFG_FOCUS_STEP_5: my_mark = (int8_t *)ICP_HD_TUP_FOCUS_STEP_5_MARK; break;
case ICP_HD_CFG_FOCUS_STEP_6: my_mark = (int8_t *)ICP_HD_TUP_FOCUS_STEP_6_MARK; break;
case ICP_HD_CFG_FOCUS_STEP_7: my_mark = (int8_t *)ICP_HD_TUP_FOCUS_STEP_7_MARK; break;
case ICP_HD_CFG_FOCUS_STEP_8: my_mark = (int8_t *)ICP_HD_TUP_FOCUS_STEP_8_MARK; break;
case ICP_HD_CFG_FOCUS_STEP_9: my_mark = (int8_t *)ICP_HD_TUP_FOCUS_STEP_9_MARK; break;
case ICP_HD_CFG_FOCUS_STEP_10: my_mark = (int8_t *)ICP_HD_TUP_FOCUS_STEP_10_MARK; break;
}
my_ptr = strstr(stream, my_mark);
if (my_ptr == NULL)
{
CAM_INFO("Can't find FOCUS_STEP mark! [stream = 0x%08x][i = %d]", stream, i, 0);
return;
}
icp_hd_tup_focus_step_num_params[i] = icp_hd_tup_parse_params(my_ptr, &icp_hd_tup_focus_step_params[i][0]);
CAM_INFO("Number of params in %s = %d", my_mark, icp_hd_tup_focus_step_num_params[i], 0);
CAM_INFO("========== %s ==========", my_mark, 0, 0);
#ifdef F_PANTECH_CAMERA_TUP_PRINT_LOAD_VALUE
icp_hd_tup_print_params(&icp_hd_tup_focus_step_params[i][0], icp_hd_tup_focus_step_num_params[i]);
#endif
}
CAM_INFO("<<%s ()", __func__);
return;
}
/*
================================================================================
FUNCTION
================================================================================
*/
static void icp_hd_tup_load_wb_params (const int8_t *stream)
{
int8_t *my_ptr = NULL;
int8_t *my_mark = NULL;
int32_t i = 0;
CAM_INFO(">>%s ()", __func__);
CAM_INFO("- stream = 0x%08x", stream, 0, 0);
for (i = ICP_HD_CFG_WB_AUTO; i < ICP_HD_CFG_WB_MAX; i++)
{
switch (i)
{
case ICP_HD_CFG_WB_AUTO: my_mark = (int8_t *)ICP_HD_TUP_WB_AUTO_MARK; break;
case ICP_HD_CFG_WB_CLOUDY: my_mark = (int8_t *)ICP_HD_TUP_WB_CLOUDY_MARK; break;
case ICP_HD_CFG_WB_DAYLIGHT: my_mark = (int8_t *)ICP_HD_TUP_WB_DAYLIGHT_MARK; break;
case ICP_HD_CFG_WB_FLUORESCENT: my_mark = (int8_t *)ICP_HD_TUP_WB_FLUORESCENT_MARK; break;
case ICP_HD_CFG_WB_INCANDESCENT: my_mark = (int8_t *)ICP_HD_TUP_WB_INCANDESCENT_MARK; break;
}
my_ptr = strstr(stream, my_mark);
if (my_ptr == NULL)
{
CAM_INFO("Can't find WB mark! [stream = 0x%08x][i = %d]", stream, i, 0);
return;
}
icp_hd_tup_wb_num_params[i] = icp_hd_tup_parse_params(my_ptr, &icp_hd_tup_wb_params[i][0]);
CAM_INFO("Number of params in %s = %d", my_mark, icp_hd_tup_wb_num_params[i], 0);
CAM_INFO("========== %s ==========", my_mark, 0, 0);
#ifdef F_PANTECH_CAMERA_TUP_PRINT_LOAD_VALUE
icp_hd_tup_print_params(&icp_hd_tup_wb_params[i][0], icp_hd_tup_wb_num_params[i]);
#endif
}
CAM_INFO("<<%s ()", __func__);
return;
}
/*
================================================================================
FUNCTION
================================================================================
*/
static void icp_hd_tup_load_flicker_params (const int8_t *stream)
{
int8_t *my_ptr = NULL;
int8_t *my_mark = NULL;
int32_t i = 0;
CAM_INFO(">>%s ()", __func__);
CAM_INFO("- stream = 0x%08x", stream, 0, 0);
for (i = 0; i < ICP_HD_CFG_FLICKER_MAX; i++)
{
switch (i)
{
case ICP_HD_CFG_FLICKER_OFF: my_mark = (int8_t *)ICP_HD_TUP_FLICKER_NONE_MARK; break;
case ICP_HD_CFG_FLICKER_60HZ: my_mark = (int8_t *)ICP_HD_TUP_FLICKER_60HZ_MARK; break;
case ICP_HD_CFG_FLICKER_50HZ: my_mark = (int8_t *)ICP_HD_TUP_FLICKER_50HZ_MARK; break;
case ICP_HD_CFG_FLICKER_AUTO: my_mark = (int8_t *)ICP_HD_TUP_FLICKER_AUTO_MARK; break;
}
my_ptr = strstr(stream, my_mark);
if (my_ptr == NULL)
{
CAM_INFO("Can't find FLICKER mark! [stream = 0x%08x][i = %d]", stream, i, 0);
return;
}
icp_hd_tup_flicker_num_params[i] = icp_hd_tup_parse_params(my_ptr, &icp_hd_tup_flicker_params[i][0]);
CAM_INFO("Number of params in %s = %d", my_mark, icp_hd_tup_flicker_num_params[i], 0);
CAM_INFO("========== %s ==========", my_mark, 0, 0);
#ifdef F_SKYCAM_TUP_PRINT_LOAD_VALUE
icp_hd_tup_print_params(&icp_hd_tup_flicker_params[i][0], icp_hd_tup_flicker_num_params[i]);
#endif
}
CAM_INFO("<<%s ()", __func__);
return;
}
/*
================================================================================
FUNCTION
================================================================================
*/
static void icp_hd_tup_load_exposure_params (const int8_t *stream)
{
int8_t *my_ptr = NULL;
int8_t *my_mark = NULL;
int32_t i = 0;
CAM_INFO(">>%s ()", __func__);
CAM_INFO("- stream = 0x%08x", stream, 0, 0);
for (i = ICP_HD_CFG_EXPOSURE_NORMAL; i < ICP_HD_CFG_EXPOSURE_MAX; i++)
{
switch (i)
{
case ICP_HD_CFG_EXPOSURE_NORMAL: my_mark = (int8_t *)ICP_HD_TUP_EXPOSURE_NORMAL; break;
case ICP_HD_CFG_EXPOSURE_SPOT: my_mark = (int8_t *)ICP_HD_TUP_EXPOSURE_SPOT; break;
case ICP_HD_CFG_EXPOSURE_AVERAGE: my_mark = (int8_t *)ICP_HD_TUP_EXPOSURE_AVERAGE; break;
}
my_ptr = strstr(stream, my_mark);
if (my_ptr == NULL)
{
CAM_INFO("Can't find EXPOSURE mark! [stream = 0x%08x][i = %d]", stream, i, 0);
return;
}
icp_hd_tup_exposure_num_params[i] = icp_hd_tup_parse_params(my_ptr, &icp_hd_tup_exposure_params[i][0]);
CAM_INFO("Number of params in %s = %d", my_mark, icp_hd_tup_exposure_num_params[i], 0);
CAM_INFO("========== %s ==========", my_mark, 0, 0);
#ifdef F_SKYCAM_TUP_PRINT_LOAD_VALUE
icp_hd_tup_print_params(&icp_hd_tup_exposure_params[i][0], icp_hd_tup_exposure_num_params[i]);
#endif
}
CAM_INFO("<<%s ()", __func__);
return;
}
