/*---------------------------------------------------------------------------
| LOCAL VARIABLE DEFINITIONS for internal |
---------------------------------------------------------------------------*/
-#define MM_CAMCORDER_ATTR_NONE -1
// Rule 1. 1:1 match except NONE.
"WDR"
};
+static int __enum_conv_flip_ctrl[MM_CAMCORDER_FLIP_NUM];
+
+_MMCamcorderEnumConvert _mmcamcorder_enum_conv_flip_ctrl =
+{
+ MM_CAMCORDER_FLIP_NUM,
+ __enum_conv_flip_ctrl,
+ CONFIGURE_CATEGORY_CTRL_EFFECT,
+ "Flip"
+};
+
+static int __enum_conv_rotation_ctrl[MM_CAMCORDER_ROTATION_NUM];
+
+_MMCamcorderEnumConvert _mmcamcorder_enum_conv_rotation_ctrl =
+{
+ MM_CAMCORDER_ROTATION_NUM,
+ __enum_conv_rotation_ctrl,
+ CONFIGURE_CATEGORY_CTRL_EFFECT,
+ "Rotation"
+};
+
static int __enum_conv_ahs[MM_CAMCORDER_AHS_NUM];
"AntiHandshake"
};
-static int __enum_conv_picture_format[MM_PIXEL_FORMAT_NUM];
-_MMCamcorderEnumConvert _mmcamcorder_enum_conv_picture_format =
+static int __enum_conv_video_stabilization[MM_CAMCORDER_VIDEO_STABILIZATION_NUM];
+
+_MMCamcorderEnumConvert _mmcamcorder_enum_conv_video_stabilization =
{
- MM_PIXEL_FORMAT_NUM,
- __enum_conv_picture_format,
- CONFIGURE_CATEGORY_CTRL_CAMERA,
- "PictureFormat"
+ MM_CAMCORDER_VIDEO_STABILIZATION_NUM,
+ __enum_conv_video_stabilization,
+ CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
+ "VideoStabilization"
};
-static int __enum_conv_vid_dev[MM_VIDEO_DEVICE_NUM] =
+
+static int __enum_conv_hdr_capture[MM_CAMCORDER_HDR_CAPTURE_NUM];
+
+_MMCamcorderEnumConvert _mmcamcorder_enum_conv_hdr_capture =
{
- //{Enum of (Plugin or Kernel) , Enum of MSL Camcorder}
- 2, //MM_VIDEO_DEVICE_CAMERA0
- 1, //MM_VIDEO_DEVICE_CAMERA1
+ MM_CAMCORDER_HDR_CAPTURE_NUM,
+ __enum_conv_hdr_capture,
+ CONFIGURE_CATEGORY_CTRL_CAPTURE,
+ "SupportHDR"
};
-_MMCamcorderEnumConvert _mmcamcorder_enum_conv_vid_dev =
+static int __enum_conv_detect_mode[MM_CAMCORDER_DETECT_MODE_NUM];
+
+_MMCamcorderEnumConvert _mmcamcorder_enum_conv_detect_mode =
{
- MM_VIDEO_DEVICE_NUM,
- __enum_conv_vid_dev,
- 0,
- NULL
+ MM_CAMCORDER_DETECT_MODE_NUM,
+ __enum_conv_detect_mode,
+ CONFIGURE_CATEGORY_CTRL_DETECT,
+ "DetectMode"
};
* For detail information, refer below documents.
*
*/
+static _MMCamcorderInfoConverting g_audio_info[] = {
+ {
+ CONFIGURE_TYPE_MAIN,
+ CONFIGURE_CATEGORY_MAIN_AUDIO_INPUT,
+ MM_CAM_AUDIO_DEVICE,
+ MM_CAMCORDER_ATTR_NONE,
+ "AudioDevice",
+ MM_CAMCONVERT_TYPE_INT_ARRAY,
+ NULL,
+ }
+};
+
static _MMCamcorderInfoConverting g_display_info[] = {
{
CONFIGURE_TYPE_MAIN,
{
CONFIGURE_TYPE_MAIN,
CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
- MM_CAM_DISPLAY_SURFACE,
+ MM_CAM_DISPLAY_MODE,
MM_CAMCORDER_ATTR_NONE,
- "Videosink",
+ "DisplayMode",
MM_CAMCONVERT_TYPE_INT_ARRAY,
NULL,
},
-};
-
-static _MMCamcorderInfoConverting g_caminfo_convert[] = {
{
- CONFIGURE_TYPE_CTRL,
- CONFIGURE_CATEGORY_CTRL_CAMERA,
- MM_CAM_CAMERA_DEVICE,
+ CONFIGURE_TYPE_MAIN,
+ CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
+ MM_CAM_DISPLAY_SURFACE,
MM_CAMCORDER_ATTR_NONE,
- "InputIndex",
+ "Videosink",
MM_CAMCONVERT_TYPE_INT_ARRAY,
- &_mmcamcorder_enum_conv_vid_dev,
+ NULL,
},
+};
+
+static _MMCamcorderInfoConverting g_caminfo_convert[CAMINFO_CONVERT_NUM] = {
{
CONFIGURE_TYPE_CTRL,
CONFIGURE_CATEGORY_CTRL_CAMERA,
{
CONFIGURE_TYPE_CTRL,
CONFIGURE_CATEGORY_CTRL_CAMERA,
- MM_CAM_CAMERA_FPS,
+ MM_CAM_CAMERA_FORMAT,
MM_CAMCORDER_ATTR_NONE,
- "FPS",
+ "PictureFormat",
MM_CAMCONVERT_TYPE_INT_ARRAY,
NULL,
},
{
CONFIGURE_TYPE_CTRL,
CONFIGURE_CATEGORY_CTRL_CAMERA,
- MM_CAM_CAMERA_FORMAT,
+ MM_CAM_CAMERA_PAN_MECHA,
MM_CAMCORDER_ATTR_NONE,
- "PictureFormat",
- MM_CAMCONVERT_TYPE_INT_ARRAY,
+ "PanMecha",
+ MM_CAMCONVERT_TYPE_INT_RANGE,
+ NULL,
+ },
+ {
+ CONFIGURE_TYPE_CTRL,
+ CONFIGURE_CATEGORY_CTRL_CAMERA,
+ MM_CAM_CAMERA_PAN_ELEC,
+ MM_CAMCORDER_ATTR_NONE,
+ "PanElec",
+ MM_CAMCONVERT_TYPE_INT_RANGE,
+ NULL,
+ },
+ {
+ CONFIGURE_TYPE_CTRL,
+ CONFIGURE_CATEGORY_CTRL_CAMERA,
+ MM_CAM_CAMERA_TILT_MECHA,
+ MM_CAMCORDER_ATTR_NONE,
+ "TiltMecha",
+ MM_CAMCONVERT_TYPE_INT_RANGE,
+ NULL,
+ },
+ {
+ CONFIGURE_TYPE_CTRL,
+ CONFIGURE_CATEGORY_CTRL_CAMERA,
+ MM_CAM_CAMERA_TILT_ELEC,
+ MM_CAMCORDER_ATTR_NONE,
+ "TiltElec",
+ MM_CAMCONVERT_TYPE_INT_RANGE,
NULL,
},
{
CONFIGURE_TYPE_CTRL,
+ CONFIGURE_CATEGORY_CTRL_CAMERA,
+ MM_CAM_CAMERA_PTZ_TYPE,
+ MM_CAMCORDER_ATTR_NONE,
+ "PtzType",
+ MM_CAMCONVERT_TYPE_INT_ARRAY,
+ NULL,
+ },
+ {/* 10 */
+ CONFIGURE_TYPE_CTRL,
CONFIGURE_CATEGORY_CTRL_STROBE,
MM_CAM_STROBE_CONTROL,
MM_CAMCORDER_ATTR_NONE,
MM_CAMCONVERT_TYPE_INT_ARRAY,
&_mmcamcorder_enum_conv_colortone,
},
- {
+ {/* 20 */
CONFIGURE_TYPE_CTRL,
CONFIGURE_CATEGORY_CTRL_EFFECT,
MM_CAM_CAMERA_WDR,
},
{
CONFIGURE_TYPE_CTRL,
+ CONFIGURE_CATEGORY_CTRL_EFFECT,
+ MM_CAM_CAMERA_FLIP,
+ MM_CAMCORDER_ATTR_NONE,
+ "Flip",
+ MM_CAMCONVERT_TYPE_INT_ARRAY,
+ &_mmcamcorder_enum_conv_flip_ctrl,
+ },
+ {
+ CONFIGURE_TYPE_CTRL,
+ CONFIGURE_CATEGORY_CTRL_EFFECT,
+ MM_CAM_CAMERA_ROTATION,
+ MM_CAMCORDER_ATTR_NONE,
+ "Rotation",
+ MM_CAMCONVERT_TYPE_INT_ARRAY,
+ &_mmcamcorder_enum_conv_rotation_ctrl,
+ },
+ {
+ CONFIGURE_TYPE_CTRL,
CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
MM_CAM_CAMERA_DIGITAL_ZOOM,
MM_CAMCORDER_ATTR_NONE,
MM_CAMCONVERT_TYPE_INT_ARRAY,
NULL,
},
- {
+ {/* 30 */
CONFIGURE_TYPE_CTRL,
CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
MM_CAM_CAMERA_SHUTTER_SPEED,
},
{
CONFIGURE_TYPE_CTRL,
+ CONFIGURE_CATEGORY_CTRL_CAPTURE,
+ MM_CAM_CAMERA_HDR_CAPTURE,
+ MM_CAMCORDER_ATTR_NONE,
+ "SupportHDR",
+ MM_CAMCONVERT_TYPE_INT_ARRAY,
+ &_mmcamcorder_enum_conv_hdr_capture,
+ },
+ {
+ CONFIGURE_TYPE_CTRL,
CONFIGURE_CATEGORY_CTRL_DETECT,
MM_CAM_DETECT_MODE,
MM_CAMCORDER_ATTR_NONE,
"DetectMode",
MM_CAMCONVERT_TYPE_INT_ARRAY,
- NULL,
+ &_mmcamcorder_enum_conv_detect_mode,
},
{
CONFIGURE_TYPE_CTRL,
MM_CAMCONVERT_TYPE_INT_RANGE,
NULL,
},
- {
+ {/* 40 */
CONFIGURE_TYPE_CTRL,
CONFIGURE_CATEGORY_CTRL_DETECT,
MM_CAM_DETECT_FOCUS_SELECT,
MM_CAMCONVERT_TYPE_INT_ARRAY,
NULL,
},
+ {
+ CONFIGURE_TYPE_CTRL,
+ CONFIGURE_CATEGORY_CTRL_CAMERA,
+ MM_CAM_RECOMMEND_CAMERA_WIDTH,
+ MM_CAM_RECOMMEND_CAMERA_HEIGHT,
+ "RecommendPreviewResolution",
+ MM_CAMCONVERT_TYPE_INT_PAIR_ARRAY,
+ NULL,
+ },
+ {
+ CONFIGURE_TYPE_CTRL,
+ CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
+ MM_CAM_CAMERA_VIDEO_STABILIZATION,
+ MM_CAMCORDER_ATTR_NONE,
+ "VideoStabilization",
+ MM_CAMCONVERT_TYPE_INT_ARRAY,
+ &_mmcamcorder_enum_conv_video_stabilization,
+ },
+ {
+ CONFIGURE_TYPE_CTRL,
+ CONFIGURE_CATEGORY_CTRL_CAMERA,
+ MM_CAM_VIDEO_WIDTH,
+ MM_CAM_VIDEO_HEIGHT,
+ "VideoResolution",
+ MM_CAMCONVERT_TYPE_INT_PAIR_ARRAY,
+ NULL,
+ }
};
/*---------------------------------------------------------------------------
| LOCAL FUNCTION PROTOTYPES: |
---------------------------------------------------------------------------*/
/* STATIC INTERNAL FUNCTION */
-static int __mmcamcorder_set_info_to_attr( MMHandleType handle, _MMCamcorderInfoConverting *info, int table_size );
static int __mmcamcorder_get_valid_array(int * original_array, int original_count, int ** valid_array, int * valid_default );
/*===========================================================================================
| GLOBAL FUNCTION DEFINITIONS: |
---------------------------------------------------------------------------*/
//convert MSL value to sensor value
-int _mmcamcorder_convert_msl_to_sensor( int attr_idx, int mslval )
+int _mmcamcorder_convert_msl_to_sensor(MMHandleType handle, int attr_idx, int mslval)
{
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
_MMCamcorderInfoConverting *info = NULL;
int i =0;
int size = sizeof(g_caminfo_convert) / sizeof(_MMCamcorderInfoConverting);
+ mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
+
//_mmcam_dbg_log("attr_idx(%d), mslval(%d)", attr_idx, mslval);
- info = g_caminfo_convert;
-
+ info = hcamcorder->caminfo_convert;
+
for (i = 0; i < size; i++)
{
if (info[i].attr_idx == attr_idx)
}
_mmcam_dbg_warn("There is no category to match. Just return the original value.");
+
return mslval;
}
+int _mmcamcorder_get_fps_array_by_resolution(MMHandleType handle, int width, int height, MMCamAttrsInfo* fps_info)
+{
+ MMCamAttrsInfo *infoW = NULL;
+ MMCamAttrsInfo *infoH = NULL;
+ int i = 0;
+ char nameFps[10] = {0,};
+ bool valid_check = false;
+
+ type_int_array *fps_array;
+
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
+
+ //_mmcam_dbg_log("prev resolution w:%d, h:%d", width, height);
+
+ infoW = (MMCamAttrsInfo*)calloc(1, sizeof(MMCamAttrsInfo));
+ if (infoW == NULL) {
+ _mmcam_dbg_err("failed to alloc infoW");
+ return MM_ERROR_CAMCORDER_LOW_MEMORY;
+ }
+
+ infoH = (MMCamAttrsInfo*)calloc(1, sizeof(MMCamAttrsInfo));
+ if (infoH == NULL) {
+ _mmcam_dbg_err("failed to alloc infoH");
+
+ free(infoW);
+ infoW = NULL;
+
+ return MM_ERROR_CAMCORDER_LOW_MEMORY;
+ }
+
+ mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_WIDTH, infoW);
+ mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_HEIGHT, infoH);
+
+ for(i=0; i < infoW->int_array.count; i++) {
+ //_mmcam_dbg_log("width :%d, height : %d\n", infoW->int_array.array[i], infoH->int_array.array[i]);
+ if(infoW->int_array.array[i] == width && infoH->int_array.array[i] == height) {
+ valid_check = true;
+ snprintf(nameFps, 10, "FPS%d", i);
+ _mmcam_dbg_log("nameFps : %s!!!", nameFps);
+ break;
+ }
+ }
+
+ free(infoW);
+ infoW = NULL;
+ free(infoH);
+ infoH = NULL;
+
+ if(!valid_check) {
+ _mmcam_dbg_err("FAILED : Can't find the valid resolution from attribute.");
+ return MM_ERROR_CAMCORDER_NOT_SUPPORTED;
+ }
+
+ if (!_mmcamcorder_conf_get_value_int_array(hcamcorder->conf_ctrl, CONFIGURE_CATEGORY_CTRL_CAMERA, nameFps, &fps_array)) {
+ _mmcam_dbg_err("FAILED : Can't find the valid FPS array.");
+ return MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
+ }
+
+ fps_info->int_array.count = fps_array->count;
+ fps_info->int_array.array = fps_array->value;
+ fps_info->int_array.def = fps_array->default_value;
+
+ return MM_ERROR_NONE;
+}
+
//convert sensor value to MSL value
-int _mmcamcorder_convert_sensor_to_msl(int attr_idx, int sensval)
+int _mmcamcorder_convert_sensor_to_msl(MMHandleType handle, int attr_idx, int sensval)
{
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
+ _MMCamcorderInfoConverting *info = NULL;
int i = 0, j = 0;
int size = sizeof(g_caminfo_convert) / sizeof(_MMCamcorderInfoConverting);
-
- _MMCamcorderInfoConverting *info = NULL;
- info = g_caminfo_convert;
-
+ mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
+
+ info = hcamcorder->caminfo_convert;
+
for( i = 0 ; i < size ; i++ )
{
if( info[i].attr_idx == attr_idx )
int i = 0;
int valid_count = 0;
int new_default = _MMCAMCORDER_SENSOR_ENUM_NONE;
-
- for (i = 0; i < original_count; i++)
- {
- if (original_array[i] != _MMCAMCORDER_SENSOR_ENUM_NONE)
+
+ for (i = 0; i < original_count; i++) {
+ if (original_array[i] != _MMCAMCORDER_SENSOR_ENUM_NONE) {
valid_count++;
+ }
}
- if (valid_count > 0)
- {
+ if (valid_count > 0) {
*valid_array = (int*)malloc(sizeof(int) * valid_count);
- valid_count = 0;
- for (i = 0; i < original_count; i++)
- {
- if (original_array[i] != _MMCAMCORDER_SENSOR_ENUM_NONE)
- {
- (*valid_array)[valid_count++] = i;
- //_mmcam_dbg_log( "valid_array[%d] = %d", valid_count-1, (*valid_array)[valid_count-1] );
-
- if( original_array[i] == *valid_default )
- {
- new_default = i;
- //_mmcam_dbg_log( "converted MSL default[%d]", new_default );
+ if (*valid_array) {
+ valid_count = 0;
+ for (i = 0; i < original_count; i++) {
+ if (original_array[i] != _MMCAMCORDER_SENSOR_ENUM_NONE) {
+ (*valid_array)[valid_count++] = i;
+ /*_mmcam_dbg_log( "valid_array[%d] = %d", valid_count-1, (*valid_array)[valid_count-1] );*/
+
+ if (original_array[i] == *valid_default &&
+ new_default == _MMCAMCORDER_SENSOR_ENUM_NONE) {
+ new_default = i;
+ /*_mmcam_dbg_log( "converted MSL default[%d]", new_default );*/
+ }
}
}
- }
+ }
+ else {
+ valid_count = 0;
+ }
}
- if( new_default != _MMCAMCORDER_SENSOR_ENUM_NONE )
- {
+ if (new_default != _MMCAMCORDER_SENSOR_ENUM_NONE) {
*valid_default = new_default;
}
}
-int _mmcamcorder_init_attr_from_configure(MMHandleType handle)
+int _mmcamcorder_init_attr_from_configure(MMHandleType handle, MMCamConvertingCategory category)
{
- _MMCamcorderInfoConverting *info = NULL;
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
+ _MMCamcorderInfoConverting *info = NULL;
int table_size = 0;
int ret = MM_ERROR_NONE;
- _mmcam_dbg_log("");
+ mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
- /* Initialize attribute related to camera control */
- info = g_caminfo_convert;
- table_size = sizeof(g_caminfo_convert) / sizeof(_MMCamcorderInfoConverting);
- ret = __mmcamcorder_set_info_to_attr( handle, info, table_size );
- if( ret != MM_ERROR_NONE )
- {
- _mmcam_dbg_err( "ret : %x", ret );
- return ret;
+ _mmcam_dbg_log("category : %d", category);
+
+ if (category & MM_CAMCONVERT_CATEGORY_CAMERA) {
+ /* Initialize attribute related to camera control */
+ info = hcamcorder->caminfo_convert;
+ table_size = sizeof(g_caminfo_convert) / sizeof(_MMCamcorderInfoConverting);
+ ret = __mmcamcorder_set_info_to_attr(handle, info, table_size);
+ if (ret != MM_ERROR_NONE) {
+ _mmcam_dbg_err("camera info set error : 0x%x", ret);
+ return ret;
+ }
+ }
+
+ if (category & MM_CAMCONVERT_CATEGORY_DISPLAY) {
+ /* Initialize attribute related to display */
+ info = g_display_info;
+ table_size = sizeof(g_display_info) / sizeof(_MMCamcorderInfoConverting);
+ ret = __mmcamcorder_set_info_to_attr(handle, info, table_size);
+ if (ret != MM_ERROR_NONE) {
+ _mmcam_dbg_err("display info set error : 0x%x", ret);
+ return ret;
+ }
+ }
+
+ if (category & MM_CAMCONVERT_CATEGORY_AUDIO) {
+ /* Initialize attribute related to audio */
+ info = g_audio_info;
+ table_size = sizeof(g_audio_info) / sizeof(_MMCamcorderInfoConverting);
+ ret = __mmcamcorder_set_info_to_attr(handle, info, table_size);
+ if (ret != MM_ERROR_NONE) {
+ _mmcam_dbg_err("audio info set error : 0x%x", ret);
+ return ret;
+ }
}
- /* Initialize attribute related to display */
- info = g_display_info;
- table_size = sizeof(g_display_info) / sizeof(_MMCamcorderInfoConverting);
- ret = __mmcamcorder_set_info_to_attr( handle, info, table_size );
- _mmcam_dbg_log( "result: %x", ret );
+ _mmcam_dbg_log("done");
return ret;
}
-static int
-__mmcamcorder_set_info_to_attr( MMHandleType handle, _MMCamcorderInfoConverting *info, int table_size )
+
+int __mmcamcorder_set_info_to_attr(MMHandleType handle, _MMCamcorderInfoConverting *info, int table_size)
{
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
MMHandleType attrs = 0;
- int i;
+ int i = 0;
+ int ret = MM_ERROR_NONE;
mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
for (i = 0; i < table_size ; i++ )
{
- int ret = MM_ERROR_NONE;
-
/*
_mmcam_dbg_log( "%d,%d,%d,%d,%s,%d",
info[i].type,
info[i].category,
info[i].attr_idx,
- info[i].attr_idx_sub,
+ info[i].attr_idx_pair,
info[i].keyword,
info[i].conv_type );
*/
if( info[i].type == CONFIGURE_TYPE_MAIN )
{
conf_info = hcamcorder->conf_main;
- _mmcam_dbg_log( "MAIN configure [%s]", info[i].keyword );
+ /*_mmcam_dbg_log( "MAIN configure [%s]", info[i].keyword );*/
}
else
{
conf_info = hcamcorder->conf_ctrl;
- _mmcam_dbg_log( "CTRL configure [%s]", info[i].keyword );
+ /*_mmcam_dbg_log( "CTRL configure [%s]", info[i].keyword );*/
}
switch(info[i].conv_type)
{
case MM_CAMCONVERT_TYPE_INT:
{
- int iarray = (int)NULL;
+ int ivalue = 0;
- if (!_mmcamcorder_conf_get_value_int( conf_info, info[i].category, info[i].keyword, &iarray ))
+ if (!_mmcamcorder_conf_get_value_int(handle, conf_info, info[i].category, info[i].keyword, &ivalue))
{
ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
break; //skip to set
}
- ret = mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx, iarray);
-
- //_mmcam_dbg_log("INT . m:%d, s:%d, arr=%d", info[i].main_key, info[i].sub_key1, iarray);
+ ret = mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx, ivalue);
break;
}
case MM_CAMCONVERT_TYPE_INT_ARRAY:
if( tarray )
{
idefault = tarray->default_value;
-
+
if( info[i].enum_convert )
{
iarray_size = __mmcamcorder_get_valid_array(tarray->value, tarray->count, &iarray, &idefault);
if( iarray_size > 0 )
{
/*
- _mmcam_dbg_log("INT Array. m:%d, s:%d, arr=%x, size=%d, default=%d",
- info[i].main_key, info[i].sub_key1, iarray, iarray_size, idefault);
+ _mmcam_dbg_log("INT Array. attr idx=%d array=%p, size=%d, default=%d",
+ info[i].attr_idx, iarray, iarray_size, idefault);
*/
-
- mmf_attrs_set_valid_type (attrs, info[i].attr_idx, MM_ATTRS_VALID_TYPE_INT_ARRAY);
- mmf_attrs_set_valid_array (attrs, info[i].attr_idx, iarray, iarray_size);
- }
- ret = mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx, idefault);
+ /* "mmf_attrs_set_valid_type" initializes spec value in attribute, so allocated memory could be missed */
+ //mmf_attrs_set_valid_type(attrs, info[i].attr_idx, MM_ATTRS_VALID_TYPE_INT_ARRAY);
+ mmf_attrs_set_valid_array(attrs, info[i].attr_idx, iarray, iarray_size, idefault);
+
+ ret = mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx, idefault);
+ }
}
if (iarray && iarray != tarray->value )
if( irange )
{
//_mmcam_dbg_log("INT Range. m:%d, s:%d, min=%d, max=%d", info[i].main_key, info[i].sub_key1, irange->min, irange->max);
-
- mmf_attrs_set_valid_type (attrs, info[i].attr_idx, MM_ATTRS_VALID_TYPE_INT_RANGE);
- mmf_attrs_set_valid_range(attrs, info[i].attr_idx, irange->min, irange->max);
+ /* "mmf_attrs_set_valid_type" initializes spec value in attribute, so allocated memory could be missed */
+ //mmf_attrs_set_valid_type (attrs, info[i].attr_idx, MM_ATTRS_VALID_TYPE_INT_RANGE);
+ mmf_attrs_set_valid_range(attrs, info[i].attr_idx, irange->min, irange->max, irange->default_value);
ret = mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx, irange->default_value);
}
}
case MM_CAMCONVERT_TYPE_STRING:
{
- char* cString = NULL;
+ const char *cString = NULL;
unsigned int iString_len = 0;
- if (!_mmcamcorder_conf_get_value_string(conf_info, info[i].category, info[i].keyword, &cString ))
+ if (!_mmcamcorder_conf_get_value_string(handle, conf_info, info[i].category, info[i].keyword, &cString ))
{
ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
break; //skip to set
{
type_int_pair_array *pair_array = NULL;
- //_mmcam_dbg_log("INT PAIR Array. type:%d, attr_idx:%d, attr_idx_pair:%d", info[i].type, info[i].attr_idx, info[i].attr_idx_pair);
+ /*_mmcam_dbg_log("INT PAIR Array. type:%d, attr_idx:%d, attr_idx_pair:%d", info[i].type, info[i].attr_idx, info[i].attr_idx_pair);*/
if (!_mmcamcorder_conf_get_value_int_pair_array(conf_info, info[i].category, info[i].keyword, &pair_array))
{
if( pair_array && pair_array->count > 0 )
{
- mmf_attrs_set_valid_type (attrs, info[i].attr_idx, MM_ATTRS_VALID_TYPE_INT_ARRAY);
- mmf_attrs_set_valid_array (attrs, info[i].attr_idx, pair_array->value[0], pair_array->count);
- mmf_attrs_set_valid_type (attrs, info[i].attr_idx_pair, MM_ATTRS_VALID_TYPE_INT_ARRAY);
- mmf_attrs_set_valid_array (attrs, info[i].attr_idx_pair, pair_array->value[1], pair_array->count);
+ /* "mmf_attrs_set_valid_type" initializes spec value in attribute, so allocated memory could be missed */
+ //mmf_attrs_set_valid_type(attrs, info[i].attr_idx, MM_ATTRS_VALID_TYPE_INT_ARRAY);
+ mmf_attrs_set_valid_array(attrs, info[i].attr_idx,
+ pair_array->value[0],
+ pair_array->count,
+ pair_array->default_value[0]);
+ /* "mmf_attrs_set_valid_type" initializes spec value in attribute, so allocated memory could be missed */
+ //mmf_attrs_set_valid_type(attrs, info[i].attr_idx_pair, MM_ATTRS_VALID_TYPE_INT_ARRAY);
+ mmf_attrs_set_valid_array(attrs, info[i].attr_idx_pair,
+ pair_array->value[1],
+ pair_array->count,
+ pair_array->default_value[1]);
mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx, pair_array->default_value[0]);
mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx_pair, pair_array->default_value[1]);
_mmcam_dbg_log("default : s:%d", info[i].attr_idx);
break;
}
-
- if (ret != MM_ERROR_NONE)
- {
- _mmcam_dbg_warn("Setting error. ( s:%d, ret:%x)", info[i].attr_idx, ret);
- }
}
- if (mmf_attrs_commit(attrs) == -1)
+ if (ret != MM_ERROR_NONE || mmf_attrs_commit(attrs) == -1)
return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
- else
+ else
return MM_ERROR_NONE;
}
int _mmcamcorder_init_convert_table(MMHandleType handle)
{
- mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
-
- _mmcamcorder_set_converted_value(handle, &_mmcamcorder_enum_conv_whitebalance);
- _mmcamcorder_set_converted_value(handle, &_mmcamcorder_enum_conv_colortone);
- _mmcamcorder_set_converted_value(handle, &_mmcamcorder_enum_conv_iso);
- _mmcamcorder_set_converted_value(handle, &_mmcamcorder_enum_conv_prgrm);
- _mmcamcorder_set_converted_value(handle, &_mmcamcorder_enum_conv_focus_mode);
- _mmcamcorder_set_converted_value(handle, &_mmcamcorder_enum_conv_focus_type);
- _mmcamcorder_set_converted_value(handle, &_mmcamcorder_enum_conv_ae_type);
-// _mmcamcorder_set_converted_value(handle, &_mmcamcorder_enum_conv_pcolor_mode);
-// _mmcamcorder_set_converted_value(handle, &_mmcamcorder_enum_conv_flip);
-// _mmcamcorder_set_converted_value(handle, &_mmcamcorder_enum_conv_pcolor);
- _mmcamcorder_set_converted_value(handle, &_mmcamcorder_enum_conv_strobe_mode);
- _mmcamcorder_set_converted_value(handle, &_mmcamcorder_enum_conv_wdr_ctrl);
- _mmcamcorder_set_converted_value(handle, &_mmcamcorder_enum_conv_ahs);
-// _mmcamcorder_set_converted_value(handle, &_mmcamcorder_enum_conv_picture_format);
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
+ int enum_conv_size = sizeof(_MMCamcorderEnumConvert);
+ int caminfo_conv_size = sizeof(g_caminfo_convert);
+ int caminfo_conv_length = sizeof(g_caminfo_convert) / sizeof(_MMCamcorderInfoConverting);
+ int i = 0;
+
+ mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
+
+ /* copy default conv data into memory of handle */
+ memcpy(&(hcamcorder->caminfo_convert), &g_caminfo_convert, caminfo_conv_size);
+ memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_WHITE_BALANCE]), &_mmcamcorder_enum_conv_whitebalance, enum_conv_size);
+ memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_COLOR_TONE]), &_mmcamcorder_enum_conv_colortone, enum_conv_size);
+ memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_ISO]), &_mmcamcorder_enum_conv_iso, enum_conv_size);
+ memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_PROGRAM_MODE]), &_mmcamcorder_enum_conv_prgrm, enum_conv_size);
+ memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_FOCUS_MODE]), &_mmcamcorder_enum_conv_focus_mode, enum_conv_size);
+ memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_AF_RANGE]), &_mmcamcorder_enum_conv_focus_type, enum_conv_size);
+ memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_EXPOSURE_MODE]), &_mmcamcorder_enum_conv_ae_type, enum_conv_size);
+ memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_STROBE_MODE]), &_mmcamcorder_enum_conv_strobe_mode, enum_conv_size);
+ memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_WDR]), &_mmcamcorder_enum_conv_wdr_ctrl, enum_conv_size);
+ memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_FLIP]), &_mmcamcorder_enum_conv_flip_ctrl, enum_conv_size);
+ memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_ROTATION]), &_mmcamcorder_enum_conv_rotation_ctrl, enum_conv_size);
+ memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_ANTI_HAND_SHAKE]), &_mmcamcorder_enum_conv_ahs, enum_conv_size);
+ memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_VIDEO_STABILIZATION]), &_mmcamcorder_enum_conv_video_stabilization, enum_conv_size);
+
+ /* set ini info to conv data */
+ _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_WHITE_BALANCE]));
+ _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_COLOR_TONE]));
+ _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_ISO]));
+ _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_PROGRAM_MODE]));
+ _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_FOCUS_MODE]));
+ _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_AF_RANGE]));
+ _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_EXPOSURE_MODE]));
+ _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_STROBE_MODE]));
+ _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_WDR]));
+ _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_FLIP]));
+ _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_ROTATION]));
+ _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_ANTI_HAND_SHAKE]));
+ _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_VIDEO_STABILIZATION]));
+
+ /* set modified conv data to handle */
+ for (i = 0 ; i < caminfo_conv_length ; i++) {
+ if (hcamcorder->caminfo_convert[i].type == CONFIGURE_TYPE_CTRL) {
+ switch (hcamcorder->caminfo_convert[i].category) {
+ case CONFIGURE_CATEGORY_CTRL_STROBE:
+ if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "StrobeMode")) {
+ hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_STROBE_MODE]);
+ }
+ break;
+ case CONFIGURE_CATEGORY_CTRL_EFFECT:
+ if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "WhiteBalance")) {
+ hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_WHITE_BALANCE]);
+ } else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "ColorTone")) {
+ hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_COLOR_TONE]);
+ } else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "WDR")) {
+ hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_WDR]);
+ } else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "Flip")) {
+ hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_FLIP]);
+ } else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "Rotation")) {
+ hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_ROTATION]);
+ }
+ break;
+ case CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH:
+ if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "FocusMode")) {
+ hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_FOCUS_MODE]);
+ } else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "AFType")) {
+ hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_AF_RANGE]);
+ } else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "AEType")) {
+ hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_EXPOSURE_MODE]);
+ } else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "ISO")) {
+ hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_ISO]);
+ } else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "ProgramMode")) {
+ hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_PROGRAM_MODE]);
+ } else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "AntiHandshake")) {
+ hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_ANTI_HAND_SHAKE]);
+ } else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "VideoStabilization")) {
+ hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_VIDEO_STABILIZATION]);
+ }
+ break;
+ default:
+ break;
+ }
+ }
+ }
return MM_ERROR_NONE;
}
projects / platform / core / multimedia / libmm-camcorder.git / blobdiff