int legacy_camera_attr_get_whitebalance(camera_h camera, camera_attr_whitebalance_e *whitebalance);
/**
+ * @brief Sets the white balance temperature.
+ * @since_tizen 7.5
+ * @param[in] camera The handle to the camera
+ * @param[in] temperature The white balance temperature
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #CAMERA_ERROR_NONE Successful
+ * @retval #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #CAMERA_ERROR_NOT_SUPPORTED The feature is not supported
+ * @see legacy_camera_attr_get_whitebalance_temperature()
+ * @see legacy_camera_attr_get_whitebalance_temperature_range()
+ * @see legacy_camera_attr_get_whitebalance_temperature_step()
+ */
+int legacy_camera_attr_set_whitebalance_temperature(camera_h camera, int temperature);
+
+/**
+ * @brief Gets the white balance temperature.
+ * @since_tizen 7.5
+ * @param[in] camera The handle to the camera
+ * @param[out] temperature The white balance temperature
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #CAMERA_ERROR_NONE Successful
+ * @retval #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #CAMERA_ERROR_NOT_SUPPORTED The feature is not supported
+ * @see legacy_camera_attr_set_whitebalance_temperature()
+ * @see legacy_camera_attr_get_whitebalance_temperature_range()
+ * @see legacy_camera_attr_get_whitebalance_temperature_step()
+ */
+int legacy_camera_attr_get_whitebalance_temperature(camera_h camera, int *temperature);
+
+/**
+ * @brief Gets the available white balance temperature.
+ * @since_tizen 7.5
+ * @remarks If the min value is greater than the max value, it means that this feature is not supported.
+ * @param[in] camera The handle to the camera
+ * @param[out] min The minimum white balance temperature
+ * @param[out] max The maximum white balance temperature
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #CAMERA_ERROR_NONE Successful
+ * @retval #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #CAMERA_ERROR_NOT_SUPPORTED The feature is not supported
+ * @see legacy_camera_attr_set_whitebalance_temperature()
+ * @see legacy_camera_attr_get_whitebalance_temperature()
+ * @see legacy_camera_attr_get_whitebalance_temperature_step()
+ */
+int legacy_camera_attr_get_whitebalance_temperature_range(camera_h camera, int *min, int *max);
+
+/**
+ * @brief Gets the step of white balance temperature.
+ * @since_tizen 7.5
+ * @param[in] camera The handle to the camera
+ * @param[out] step The step of white balance temperature
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #CAMERA_ERROR_NONE Successful
+ * @retval #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #CAMERA_ERROR_NOT_SUPPORTED The feature is not supported
+ * @see legacy_camera_attr_set_whitebalance_temperature()
+ * @see legacy_camera_attr_get_whitebalance_temperature()
+ * @see legacy_camera_attr_get_whitebalance_temperature_range()
+ */
+int legacy_camera_attr_get_whitebalance_temperature_step(camera_h camera, int *step);
+
+/**
+ * @brief Sets the saturation level.
+ * @since_tizen 7.5
+ * @param[in] level The saturation level
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #CAMERA_ERROR_NONE Successful
+ * @retval #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #CAMERA_ERROR_NOT_SUPPORTED The feature is not supported
+ * @see legacy_camera_attr_get_saturation()
+ * @see legacy_camera_attr_get_saturation_range()
+ */
+int legacy_camera_attr_set_saturation(camera_h camera, int level);
+
+/**
+ * @brief Gets the saturation level.
+ * @since_tizen 7.5
+ * @param[in] camera The handle to the camera
+ * @param[out] level The saturation level
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #CAMERA_ERROR_NONE Successful
+ * @retval #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #CAMERA_ERROR_NOT_SUPPORTED The feature is not supported
+ * @see legacy_camera_attr_set_saturation()
+ * @see legacy_camera_attr_get_saturation_range()
+ */
+int legacy_camera_attr_get_saturation(camera_h camera, int *level);
+
+/**
+ * @brief Gets the available saturation level.
+ * @since_tizen 7.5
+ * @remarks If the min value is greater than the max value, it means that this feature is not supported.
+ * @param[in] camera The handle to the camera
+ * @param[out] min The minimum saturation level
+ * @param[out] max The maximum saturation level
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #CAMERA_ERROR_NONE Successful
+ * @retval #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #CAMERA_ERROR_NOT_SUPPORTED The feature is not supported
+ * @see legacy_camera_attr_set_saturation()
+ * @see legacy_camera_attr_get_saturation()
+ */
+int legacy_camera_attr_get_saturation_range(camera_h camera, int *min, int *max);
+
+/**
+ * @brief Sets the sharpness level.
+ * @since_tizen 7.5
+ * @param[in] level The sharpness level
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #CAMERA_ERROR_NONE Successful
+ * @retval #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #CAMERA_ERROR_NOT_SUPPORTED The feature is not supported
+ * @see legacy_camera_attr_get_sharpness()
+ * @see legacy_camera_attr_get_sharpness_range()
+ */
+int legacy_camera_attr_set_sharpness(camera_h camera, int level);
+
+/**
+ * @brief Gets the sharpness level.
+ * @since_tizen 7.5
+ * @param[in] camera The handle to the camera
+ * @param[out] level The sharpness level
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #CAMERA_ERROR_NONE Successful
+ * @retval #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #CAMERA_ERROR_NOT_SUPPORTED The feature is not supported
+ * @see legacy_camera_attr_set_sharpness()
+ * @see legacy_camera_attr_get_sharpness_range()
+ */
+int legacy_camera_attr_get_sharpness(camera_h camera, int *level);
+
+/**
+ * @brief Gets the available sharpness level.
+ * @since_tizen 7.5
+ * @remarks If the min value is greater than the max value, it means that this feature is not supported.
+ * @param[in] camera The handle to the camera
+ * @param[out] min The minimum sharpness level
+ * @param[out] max The maximum sharpness level
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #CAMERA_ERROR_NONE Successful
+ * @retval #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #CAMERA_ERROR_NOT_SUPPORTED The feature is not supported
+ * @see legacy_camera_attr_set_sharpness()
+ * @see legacy_camera_attr_get_sharpness()
+ */
+int legacy_camera_attr_get_sharpness_range(camera_h camera, int *min, int *max);
+
+/**
+ * @brief Sets the gain level.
+ * @since_tizen 7.5
+ * @param[in] level The gain level
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #CAMERA_ERROR_NONE Successful
+ * @retval #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #CAMERA_ERROR_NOT_SUPPORTED The feature is not supported
+ * @see legacy_camera_attr_get_gain()
+ * @see legacy_camera_attr_get_gain_range()
+ * @see legacy_camera_attr_get_gain_step()
+ */
+int legacy_camera_attr_set_gain(camera_h camera, int level);
+
+/**
+ * @brief Gets the gain level.
+ * @since_tizen 7.5
+ * @param[in] camera The handle to the camera
+ * @param[out] level The gain level
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #CAMERA_ERROR_NONE Successful
+ * @retval #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #CAMERA_ERROR_NOT_SUPPORTED The feature is not supported
+ * @see legacy_camera_attr_set_gain()
+ * @see legacy_camera_attr_get_gain_range()
+ * @see legacy_camera_attr_get_gain_step()
+ */
+int legacy_camera_attr_get_gain(camera_h camera, int *level);
+
+/**
+ * @brief Gets the available gain level.
+ * @since_tizen 7.5
+ * @remarks If the min value is greater than the max value, it means that this feature is not supported.
+ * @param[in] camera The handle to the camera
+ * @param[out] min The minimum gain level
+ * @param[out] max The maximum gain level
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #CAMERA_ERROR_NONE Successful
+ * @retval #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #CAMERA_ERROR_NOT_SUPPORTED The feature is not supported
+ * @see legacy_camera_attr_set_gain()
+ * @see legacy_camera_attr_get_gain()
+ * @see legacy_camera_attr_get_gain_step()
+ */
+int legacy_camera_attr_get_gain_range(camera_h camera, int *min, int *max);
+
+/**
+ * @brief Gets the step of gain level.
+ * @since_tizen 7.5
+ * @param[in] camera The handle to the camera
+ * @param[out] level The step of gain level
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #CAMERA_ERROR_NONE Successful
+ * @retval #CAMERA_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #CAMERA_ERROR_NOT_SUPPORTED The feature is not supported
+ * @see legacy_camera_attr_set_gain()
+ * @see legacy_camera_attr_get_gain()
+ * @see legacy_camera_attr_get_gain_range()
+ */
+int legacy_camera_attr_get_gain_step(camera_h camera, int *step);
+
+/**
* @}
*/
}
+int legacy_camera_attr_set_saturation(camera_h camera, int level)
+{
+ int ret = MM_ERROR_NONE;
+ camera_s *handle = (camera_s *)camera;
+
+ camera_return_val_if_fail(handle, CAMERA_ERROR_INVALID_PARAMETER);
+
+ ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
+ MMCAM_FILTER_SATURATION, level,
+ NULL);
+
+ return __convert_camera_error_code(__func__, ret);
+}
+
+
+int legacy_camera_attr_set_sharpness(camera_h camera, int level)
+{
+ int ret = MM_ERROR_NONE;
+ camera_s *handle = (camera_s *)camera;
+
+ camera_return_val_if_fail(handle, CAMERA_ERROR_INVALID_PARAMETER);
+
+ ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
+ MMCAM_FILTER_SHARPNESS, level,
+ NULL);
+
+ return __convert_camera_error_code(__func__, ret);
+}
+
+
+int legacy_camera_attr_set_gain(camera_h camera, int level)
+{
+ int ret = MM_ERROR_NONE;
+ camera_s *handle = (camera_s *)camera;
+
+ camera_return_val_if_fail(handle, CAMERA_ERROR_INVALID_PARAMETER);
+
+ ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
+ MMCAM_CAMERA_GAIN, level,
+ NULL);
+
+ return __convert_camera_error_code(__func__, ret);
+}
+
+
int legacy_camera_attr_set_whitebalance(camera_h camera, camera_attr_whitebalance_e wb)
{
int ret = MM_ERROR_NONE;
}
+int legacy_camera_attr_set_whitebalance_temperature(camera_h camera, int temperature)
+{
+ int ret = MM_ERROR_NONE;
+ camera_s *handle = (camera_s *)camera;
+
+ camera_return_val_if_fail(handle, CAMERA_ERROR_INVALID_PARAMETER);
+
+ ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
+ MMCAM_FILTER_WB_TEMPERATURE, temperature,
+ NULL);
+
+ return __convert_camera_error_code(__func__, ret);
+}
+
+
int legacy_camera_attr_set_effect(camera_h camera, camera_attr_effect_mode_e effect)
{
int ret = MM_ERROR_NONE;
}
+int legacy_camera_attr_get_saturation(camera_h camera, int *level)
+{
+ int ret = MM_ERROR_NONE;
+ camera_s *handle = (camera_s *)camera;
+
+ camera_return_val_if_fail(handle && level, CAMERA_ERROR_INVALID_PARAMETER);
+
+ ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
+ MMCAM_FILTER_SATURATION, level,
+ NULL);
+
+ return __convert_camera_error_code(__func__, ret);
+}
+
+
+int legacy_camera_attr_get_saturation_range(camera_h camera, int *min, int *max)
+{
+ int ret = MM_ERROR_NONE;
+ camera_s *handle = (camera_s *)camera;
+ MMCamAttrsInfo ainfo;
+
+ camera_return_val_if_fail(handle && min && max, CAMERA_ERROR_INVALID_PARAMETER);
+
+ ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_FILTER_SATURATION, &ainfo);
+ if (ret == MM_ERROR_NONE) {
+ *min = ainfo.int_range.min;
+ *max = ainfo.int_range.max;
+ }
+
+ return __convert_camera_error_code(__func__, ret);
+}
+
+
+int legacy_camera_attr_get_sharpness(camera_h camera, int *level)
+{
+ int ret = MM_ERROR_NONE;
+ camera_s *handle = (camera_s *)camera;
+
+ camera_return_val_if_fail(handle && level, CAMERA_ERROR_INVALID_PARAMETER);
+
+ ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
+ MMCAM_FILTER_SHARPNESS, level,
+ NULL);
+
+ return __convert_camera_error_code(__func__, ret);
+}
+
+
+int legacy_camera_attr_get_sharpness_range(camera_h camera, int *min, int *max)
+{
+ int ret = MM_ERROR_NONE;
+ camera_s *handle = (camera_s *)camera;
+ MMCamAttrsInfo ainfo;
+
+ camera_return_val_if_fail(handle && min && max, CAMERA_ERROR_INVALID_PARAMETER);
+
+ ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_FILTER_SHARPNESS, &ainfo);
+ if (ret == MM_ERROR_NONE) {
+ *min = ainfo.int_range.min;
+ *max = ainfo.int_range.max;
+ }
+
+ return __convert_camera_error_code(__func__, ret);
+}
+
+
+int legacy_camera_attr_get_gain(camera_h camera, int *level)
+{
+ int ret = MM_ERROR_NONE;
+ camera_s *handle = (camera_s *)camera;
+
+ camera_return_val_if_fail(handle && level, CAMERA_ERROR_INVALID_PARAMETER);
+
+ ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
+ MMCAM_CAMERA_GAIN, level,
+ NULL);
+
+ return __convert_camera_error_code(__func__, ret);
+}
+
+
+int legacy_camera_attr_get_gain_range(camera_h camera, int *min, int *max)
+{
+ int ret = MM_ERROR_NONE;
+ camera_s *handle = (camera_s *)camera;
+ MMCamAttrsInfo ainfo;
+
+ camera_return_val_if_fail(handle && min && max, CAMERA_ERROR_INVALID_PARAMETER);
+
+ ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_CAMERA_GAIN, &ainfo);
+ if (ret == MM_ERROR_NONE) {
+ *min = ainfo.int_range.min;
+ *max = ainfo.int_range.max;
+ }
+
+ return __convert_camera_error_code(__func__, ret);
+}
+
+int legacy_camera_attr_get_gain_step(camera_h camera, int *step)
+{
+ int ret = MM_ERROR_NONE;
+ camera_s *handle = (camera_s *)camera;
+
+ camera_return_val_if_fail(handle && step, CAMERA_ERROR_INVALID_PARAMETER);
+
+ ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
+ MMCAM_CAMERA_GAIN_STEP, step,
+ NULL);
+
+ return __convert_camera_error_code(__func__, ret);
+}
+
+
int legacy_camera_attr_get_whitebalance(camera_h camera, camera_attr_whitebalance_e *wb)
{
int ret = MM_ERROR_NONE;
}
+int legacy_camera_attr_get_whitebalance_temperature(camera_h camera, int *temperature)
+{
+ int ret = MM_ERROR_NONE;
+ camera_s *handle = (camera_s *)camera;
+
+ camera_return_val_if_fail(handle && temperature, CAMERA_ERROR_INVALID_PARAMETER);
+
+ ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
+ MMCAM_FILTER_WB_TEMPERATURE, temperature,
+ NULL);
+
+ return __convert_camera_error_code(__func__, ret);
+}
+
+
+int legacy_camera_attr_get_whitebalance_temperature_range(camera_h camera, int *min, int *max)
+{
+ int ret = MM_ERROR_NONE;
+ camera_s *handle = (camera_s *)camera;
+ MMCamAttrsInfo ainfo;
+
+ camera_return_val_if_fail(handle && min && max, CAMERA_ERROR_INVALID_PARAMETER);
+
+ ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_FILTER_WB_TEMPERATURE, &ainfo);
+ if (ret == MM_ERROR_NONE) {
+ *min = ainfo.int_range.min;
+ *max = ainfo.int_range.max;
+ }
+
+ return __convert_camera_error_code(__func__, ret);
+}
+
+int legacy_camera_attr_get_whitebalance_temperature_step(camera_h camera, int *step)
+{
+ int ret = MM_ERROR_NONE;
+ camera_s *handle = (camera_s *)camera;
+
+ camera_return_val_if_fail(handle && step, CAMERA_ERROR_INVALID_PARAMETER);
+
+ ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
+ MMCAM_FILTER_WB_TEMPERATURE_STEP, step,
+ NULL);
+
+ return __convert_camera_error_code(__func__, ret);
+}
+
+
int legacy_camera_attr_get_effect(camera_h camera, camera_attr_effect_mode_e *effect)
{
int ret = MM_ERROR_NONE;
MUSE_CAMERA_API_ATTR_GET_FLASH_BRIGHTNESS_RANGE,
MUSE_CAMERA_API_SET_MEDIA_BRIDGE,
MUSE_CAMERA_API_UNSET_MEDIA_BRIDGE,
- MUSE_CAMERA_API_SET_EXTRA_PREVIEW_CB, /* 160 */
+ MUSE_CAMERA_API_SET_EXTRA_PREVIEW_CB, /* 160 */
MUSE_CAMERA_API_UNSET_EXTRA_PREVIEW_CB,
MUSE_CAMERA_API_ATTR_SET_FOCUS_LEVEL,
MUSE_CAMERA_API_ATTR_GET_FOCUS_LEVEL,
MUSE_CAMERA_API_ATTR_GET_FOCUS_LEVEL_RANGE,
- MUSE_CAMERA_API_SET_EXTRA_PREVIEW_STREAM_FORMAT, /* 165 */
+ MUSE_CAMERA_API_SET_EXTRA_PREVIEW_STREAM_FORMAT, /* 165 */
MUSE_CAMERA_API_GET_EXTRA_PREVIEW_STREAM_FORMAT,
MUSE_CAMERA_API_ATTR_SET_EXTRA_PREVIEW_BITRATE,
MUSE_CAMERA_API_ATTR_GET_EXTRA_PREVIEW_BITRATE,
MUSE_CAMERA_API_ATTR_SET_EXTRA_PREVIEW_GOP_INTERVAL,
- MUSE_CAMERA_API_ATTR_GET_EXTRA_PREVIEW_GOP_INTERVAL, /* 170 */
+ MUSE_CAMERA_API_ATTR_GET_EXTRA_PREVIEW_GOP_INTERVAL, /* 170 */
MUSE_CAMERA_API_SUPPORT_EXTRA_PREVIEW,
MUSE_CAMERA_API_SET_EXTRA_PREVIEW_DEVICE,
MUSE_CAMERA_API_REQUEST_CODEC_CONFIG,
+ MUSE_CAMERA_API_ATTR_SET_SATURATION,
+ MUSE_CAMERA_API_ATTR_GET_SATURATION, /* 175 */
+ MUSE_CAMERA_API_ATTR_GET_SATURATION_RANGE,
+ MUSE_CAMERA_API_ATTR_SET_SHARPNESS,
+ MUSE_CAMERA_API_ATTR_GET_SHARPNESS,
+ MUSE_CAMERA_API_ATTR_GET_SHARPNESS_RANGE,
+ MUSE_CAMERA_API_ATTR_SET_GAIN, /* 180 */
+ MUSE_CAMERA_API_ATTR_GET_GAIN,
+ MUSE_CAMERA_API_ATTR_GET_GAIN_RANGE,
+ MUSE_CAMERA_API_ATTR_GET_GAIN_STEP,
+ MUSE_CAMERA_API_ATTR_SET_WHITEBALANCE_TEMPERATURE,
+ MUSE_CAMERA_API_ATTR_GET_WHITEBALANCE_TEMPERATURE, /* 185 */
+ MUSE_CAMERA_API_ATTR_GET_WHITEBALANCE_TEMPERATURE_RANGE,
+ MUSE_CAMERA_API_ATTR_GET_WHITEBALANCE_TEMPERATURE_STEP,
MUSE_CAMERA_API_MAX
} muse_camera_api_e;
MUSE_CAMERA_GET_INT_FOCUS_LEVEL,
MUSE_CAMERA_GET_INT_EXTRA_PREVIEW_BITRATE,
MUSE_CAMERA_GET_INT_EXTRA_PREVIEW_GOP_INTERVAL,
+ MUSE_CAMERA_GET_INT_SATURATION,
+ MUSE_CAMERA_GET_INT_SHARPNESS,
+ MUSE_CAMERA_GET_INT_GAIN,
+ MUSE_CAMERA_GET_INT_GAIN_STEP,
+ MUSE_CAMERA_GET_INT_WHITE_BALANCE_TEMPERATURE,
+ MUSE_CAMERA_GET_INT_WHITE_BALANCE_TEMPERATURE_STEP,
MUSE_CAMERA_GET_INT_NUM
} muse_camera_get_int_e;
MUSE_CAMERA_GET_INT_PAIR_HUE_RANGE,
MUSE_CAMERA_GET_INT_PAIR_FLASH_BRIGHTNESS_RANGE,
MUSE_CAMERA_GET_INT_PAIR_FOCUS_LEVEL_RANGE,
+ MUSE_CAMERA_GET_INT_PAIR_SATURATION_RANGE,
+ MUSE_CAMERA_GET_INT_PAIR_SHARPNESS_RANGE,
+ MUSE_CAMERA_GET_INT_PAIR_GAIN_RANGE,
+ MUSE_CAMERA_GET_INT_PAIR_WHITE_BALANCE_TEMPERATURE_RANGE,
MUSE_CAMERA_GET_INT_PAIR_NUM
} muse_camera_get_int_pair_e;
return MUSE_CAMERA_ERROR_NONE;
}
+int camera_dispatcher_attr_set_whitebalance_temperature(muse_module_h module)
+{
+ int ret = CAMERA_ERROR_NONE;
+ muse_camera_handle_s *muse_camera = NULL;
+ int temperature;
+ muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_WHITEBALANCE_TEMPERATURE;
+ muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
+
+ muse_camera = (muse_camera_handle_s *)muse_server_ipc_get_handle(module);
+
+ muse_camera_msg_get(temperature, muse_server_module_get_msg(module));
+
+ CAM_LOG_INFO("handle[%p], temperature[%d]", muse_camera, temperature);
+
+ ret = legacy_camera_attr_set_whitebalance_temperature(muse_camera->camera_handle, temperature);
+
+ CAM_LOG_INFO("ret[0x%x]", ret);
+
+ muse_camera_msg_return(api, class, ret, module);
+
+ return MUSE_CAMERA_ERROR_NONE;
+}
+
int camera_dispatcher_attr_set_effect(muse_module_h module)
{
int ret = CAMERA_ERROR_NONE;
return MUSE_CAMERA_ERROR_NONE;
}
+int camera_dispatcher_attr_set_saturation(muse_module_h module)
+{
+ int ret = CAMERA_ERROR_NONE;
+ muse_camera_handle_s *muse_camera = NULL;
+ int level;
+ muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_SATURATION;
+ muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
+
+ muse_camera = (muse_camera_handle_s *)muse_server_ipc_get_handle(module);
+
+ muse_camera_msg_get(level, muse_server_module_get_msg(module));
+
+ CAM_LOG_INFO("handle[%p], level[%d]", muse_camera, level);
+
+ ret = legacy_camera_attr_set_saturation(muse_camera->camera_handle, level);
+
+ CAM_LOG_INFO("ret[0x%x]", ret);
+
+ muse_camera_msg_return(api, class, ret, module);
+
+ return MUSE_CAMERA_ERROR_NONE;
+}
+
+int camera_dispatcher_attr_set_sharpness(muse_module_h module)
+{
+ int ret = CAMERA_ERROR_NONE;
+ muse_camera_handle_s *muse_camera = NULL;
+ int level;
+ muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_SHARPNESS;
+ muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
+
+ muse_camera = (muse_camera_handle_s *)muse_server_ipc_get_handle(module);
+
+ muse_camera_msg_get(level, muse_server_module_get_msg(module));
+
+ CAM_LOG_INFO("handle[%p], level[%d]", muse_camera, level);
+
+ ret = legacy_camera_attr_set_sharpness(muse_camera->camera_handle, level);
+
+ CAM_LOG_INFO("ret[0x%x]", ret);
+
+ muse_camera_msg_return(api, class, ret, module);
+
+ return MUSE_CAMERA_ERROR_NONE;
+}
+
+int camera_dispatcher_attr_set_gain(muse_module_h module)
+{
+ int ret = CAMERA_ERROR_NONE;
+ muse_camera_handle_s *muse_camera = NULL;
+ int level;
+ muse_camera_api_e api = MUSE_CAMERA_API_ATTR_SET_GAIN;
+ muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
+
+ muse_camera = (muse_camera_handle_s *)muse_server_ipc_get_handle(module);
+
+ muse_camera_msg_get(level, muse_server_module_get_msg(module));
+
+ CAM_LOG_INFO("handle[%p], level[%d]", muse_camera, level);
+
+ ret = legacy_camera_attr_set_gain(muse_camera->camera_handle, level);
+
+ CAM_LOG_INFO("ret[0x%x]", ret);
+
+ muse_camera_msg_return(api, class, ret, module);
+
+ return MUSE_CAMERA_ERROR_NONE;
+}
+
int camera_dispatcher_attr_enable_tag(muse_module_h module)
{
int ret = CAMERA_ERROR_NONE;
ret = legacy_camera_attr_get_hue(muse_camera->camera_handle, &get_value);
if (ret == CAMERA_ERROR_NONE) {
muse_camera_msg_return1(api, class, ret, module, MUSE_CAMERA_GET_TYPE_INT,
- MUSE_CAMERA_GET_INT_CONTRAST, "get_value", get_value, NULL);
+ MUSE_CAMERA_GET_INT_HUE, "get_value", get_value, NULL);
} else {
muse_camera_msg_return(api, class, ret, module);
}
return MUSE_CAMERA_ERROR_NONE;
}
+int camera_dispatcher_attr_get_saturation(muse_module_h module)
+{
+ int ret = CAMERA_ERROR_NONE;
+ muse_camera_handle_s *muse_camera = NULL;
+ int get_value = 0;
+ muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_SATURATION;
+ muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
+
+ muse_camera = (muse_camera_handle_s *)muse_server_ipc_get_handle(module);
+
+ CAM_LOG_INFO("handle[%p]", muse_camera);
+
+ ret = legacy_camera_attr_get_saturation(muse_camera->camera_handle, &get_value);
+ if (ret == CAMERA_ERROR_NONE) {
+ muse_camera_msg_return1(api, class, ret, module, MUSE_CAMERA_GET_TYPE_INT,
+ MUSE_CAMERA_GET_INT_SATURATION, "get_value", get_value, NULL);
+ } else {
+ muse_camera_msg_return(api, class, ret, module);
+ }
+
+ return MUSE_CAMERA_ERROR_NONE;
+}
+
+int camera_dispatcher_attr_get_saturation_range(muse_module_h module)
+{
+ int ret = CAMERA_ERROR_NONE;
+ muse_camera_handle_s *muse_camera = NULL;
+ int get_value0 = 0;
+ int get_value1 = 0;
+ muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_SATURATION_RANGE;
+ muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
+ muse_camera_get_type_e get_type = MUSE_CAMERA_GET_TYPE_INT_PAIR;
+ muse_camera_get_int_pair_e index = MUSE_CAMERA_GET_INT_PAIR_SATURATION_RANGE;
+
+ muse_camera = (muse_camera_handle_s *)muse_server_ipc_get_handle(module);
+
+ CAM_LOG_INFO("handle[%p]", muse_camera);
+
+ ret = legacy_camera_attr_get_saturation_range(muse_camera->camera_handle, &get_value0, &get_value1);
+ if (ret == CAMERA_ERROR_NONE)
+ muse_camera_msg_return2(api, class, ret, module, get_type, index, get_value0, get_value1);
+ else
+ muse_camera_msg_return(api, class, ret, module);
+
+ return MUSE_CAMERA_ERROR_NONE;
+}
+
+int camera_dispatcher_attr_get_sharpness(muse_module_h module)
+{
+ int ret = CAMERA_ERROR_NONE;
+ muse_camera_handle_s *muse_camera = NULL;
+ int get_value = 0;
+ muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_SHARPNESS;
+ muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
+
+ muse_camera = (muse_camera_handle_s *)muse_server_ipc_get_handle(module);
+
+ CAM_LOG_INFO("handle[%p]", muse_camera);
+
+ ret = legacy_camera_attr_get_sharpness(muse_camera->camera_handle, &get_value);
+ if (ret == CAMERA_ERROR_NONE) {
+ muse_camera_msg_return1(api, class, ret, module, MUSE_CAMERA_GET_TYPE_INT,
+ MUSE_CAMERA_GET_INT_SHARPNESS, "get_value", get_value, NULL);
+ } else {
+ muse_camera_msg_return(api, class, ret, module);
+ }
+
+ return MUSE_CAMERA_ERROR_NONE;
+}
+
+int camera_dispatcher_attr_get_sharpness_range(muse_module_h module)
+{
+ int ret = CAMERA_ERROR_NONE;
+ muse_camera_handle_s *muse_camera = NULL;
+ int get_value0 = 0;
+ int get_value1 = 0;
+ muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_SHARPNESS_RANGE;
+ muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
+ muse_camera_get_type_e get_type = MUSE_CAMERA_GET_TYPE_INT_PAIR;
+ muse_camera_get_int_pair_e index = MUSE_CAMERA_GET_INT_PAIR_SHARPNESS_RANGE;
+
+ muse_camera = (muse_camera_handle_s *)muse_server_ipc_get_handle(module);
+
+ CAM_LOG_INFO("handle[%p]", muse_camera);
+
+ ret = legacy_camera_attr_get_sharpness_range(muse_camera->camera_handle, &get_value0, &get_value1);
+ if (ret == CAMERA_ERROR_NONE)
+ muse_camera_msg_return2(api, class, ret, module, get_type, index, get_value0, get_value1);
+ else
+ muse_camera_msg_return(api, class, ret, module);
+
+ return MUSE_CAMERA_ERROR_NONE;
+}
+
+int camera_dispatcher_attr_get_gain(muse_module_h module)
+{
+ int ret = CAMERA_ERROR_NONE;
+ muse_camera_handle_s *muse_camera = NULL;
+ int get_value = 0;
+ muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_GAIN;
+ muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
+
+ muse_camera = (muse_camera_handle_s *)muse_server_ipc_get_handle(module);
+
+ CAM_LOG_INFO("handle[%p]", muse_camera);
+
+ ret = legacy_camera_attr_get_gain(muse_camera->camera_handle, &get_value);
+ if (ret == CAMERA_ERROR_NONE) {
+ muse_camera_msg_return1(api, class, ret, module, MUSE_CAMERA_GET_TYPE_INT,
+ MUSE_CAMERA_GET_INT_GAIN, "get_value", get_value, NULL);
+ } else {
+ muse_camera_msg_return(api, class, ret, module);
+ }
+
+ return MUSE_CAMERA_ERROR_NONE;
+}
+
+int camera_dispatcher_attr_get_gain_range(muse_module_h module)
+{
+ int ret = CAMERA_ERROR_NONE;
+ muse_camera_handle_s *muse_camera = NULL;
+ int get_value0 = 0;
+ int get_value1 = 0;
+ muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_GAIN_RANGE;
+ muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
+ muse_camera_get_type_e get_type = MUSE_CAMERA_GET_TYPE_INT_PAIR;
+ muse_camera_get_int_pair_e index = MUSE_CAMERA_GET_INT_PAIR_GAIN_RANGE;
+
+ muse_camera = (muse_camera_handle_s *)muse_server_ipc_get_handle(module);
+
+ CAM_LOG_INFO("handle[%p]", muse_camera);
+
+ ret = legacy_camera_attr_get_gain_range(muse_camera->camera_handle, &get_value0, &get_value1);
+ if (ret == CAMERA_ERROR_NONE)
+ muse_camera_msg_return2(api, class, ret, module, get_type, index, get_value0, get_value1);
+ else
+ muse_camera_msg_return(api, class, ret, module);
+
+ return MUSE_CAMERA_ERROR_NONE;
+}
+
+int camera_dispatcher_attr_get_gain_step(muse_module_h module)
+{
+ int ret = CAMERA_ERROR_NONE;
+ muse_camera_handle_s *muse_camera = NULL;
+ int get_value = 0;
+ muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_GAIN_STEP;
+ muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
+
+ muse_camera = (muse_camera_handle_s *)muse_server_ipc_get_handle(module);
+
+ CAM_LOG_INFO("handle[%p]", muse_camera);
+
+ ret = legacy_camera_attr_get_gain_step(muse_camera->camera_handle, &get_value);
+ if (ret == CAMERA_ERROR_NONE) {
+ muse_camera_msg_return1(api, class, ret, module, MUSE_CAMERA_GET_TYPE_INT,
+ MUSE_CAMERA_GET_INT_GAIN_STEP, "get_value", get_value, NULL);
+ } else {
+ muse_camera_msg_return(api, class, ret, module);
+ }
+
+ return MUSE_CAMERA_ERROR_NONE;
+}
+
int camera_dispatcher_attr_get_whitebalance(muse_module_h module)
{
int ret = CAMERA_ERROR_NONE;
return MUSE_CAMERA_ERROR_NONE;
}
+int camera_dispatcher_attr_get_whitebalance_temperature(muse_module_h module)
+{
+ int ret = CAMERA_ERROR_NONE;
+ muse_camera_handle_s *muse_camera = NULL;
+ int get_value = 0;
+ muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_WHITEBALANCE_TEMPERATURE;
+ muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
+
+ muse_camera = (muse_camera_handle_s *)muse_server_ipc_get_handle(module);
+
+ CAM_LOG_INFO("handle[%p]", muse_camera);
+
+ ret = legacy_camera_attr_get_whitebalance_temperature(muse_camera->camera_handle, &get_value);
+ if (ret == CAMERA_ERROR_NONE) {
+ muse_camera_msg_return1(api, class, ret, module, MUSE_CAMERA_GET_TYPE_INT,
+ MUSE_CAMERA_GET_INT_WHITE_BALANCE_TEMPERATURE, "get_value", get_value, NULL);
+ } else {
+ muse_camera_msg_return(api, class, ret, module);
+ }
+
+ return MUSE_CAMERA_ERROR_NONE;
+}
+
+int camera_dispatcher_attr_get_whitebalance_temperature_range(muse_module_h module)
+{
+ int ret = CAMERA_ERROR_NONE;
+ muse_camera_handle_s *muse_camera = NULL;
+ int get_value0 = 0;
+ int get_value1 = 0;
+ muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_WHITEBALANCE_TEMPERATURE_RANGE;
+ muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
+ muse_camera_get_type_e get_type = MUSE_CAMERA_GET_TYPE_INT_PAIR;
+ muse_camera_get_int_pair_e index = MUSE_CAMERA_GET_INT_PAIR_WHITE_BALANCE_TEMPERATURE_RANGE;
+
+ muse_camera = (muse_camera_handle_s *)muse_server_ipc_get_handle(module);
+
+ CAM_LOG_INFO("handle[%p]", muse_camera);
+
+ ret = legacy_camera_attr_get_whitebalance_temperature_range(muse_camera->camera_handle, &get_value0, &get_value1);
+ if (ret == CAMERA_ERROR_NONE)
+ muse_camera_msg_return2(api, class, ret, module, get_type, index, get_value0, get_value1);
+ else
+ muse_camera_msg_return(api, class, ret, module);
+
+ return MUSE_CAMERA_ERROR_NONE;
+}
+
+int camera_dispatcher_attr_get_whitebalance_temperature_step(muse_module_h module)
+{
+ int ret = CAMERA_ERROR_NONE;
+ muse_camera_handle_s *muse_camera = NULL;
+ int get_value = 0;
+ muse_camera_api_e api = MUSE_CAMERA_API_ATTR_GET_WHITEBALANCE_TEMPERATURE_STEP;
+ muse_camera_api_class_e class = MUSE_CAMERA_API_CLASS_IMMEDIATE;
+
+ muse_camera = (muse_camera_handle_s *)muse_server_ipc_get_handle(module);
+
+ CAM_LOG_INFO("handle[%p]", muse_camera);
+
+ ret = legacy_camera_attr_get_whitebalance_temperature_step(muse_camera->camera_handle, &get_value);
+ if (ret == CAMERA_ERROR_NONE) {
+ muse_camera_msg_return1(api, class, ret, module, MUSE_CAMERA_GET_TYPE_INT,
+ MUSE_CAMERA_GET_INT_WHITE_BALANCE_TEMPERATURE_STEP, "get_value", get_value, NULL);
+ } else {
+ muse_camera_msg_return(api, class, ret, module);
+ }
+
+ return MUSE_CAMERA_ERROR_NONE;
+}
+
int camera_dispatcher_attr_get_effect(muse_module_h module)
{
int ret = CAMERA_ERROR_NONE;
camera_dispatcher_attr_get_extra_preview_gop_interval, /* MUSE_CAMERA_API_ATTR_GET_EXTRA_PREVIEW_GOP_INTERVAL */
camera_dispatcher_is_supported_extra_preview, /* MUSE_CAMERA_API_SUPPORT_EXTRA_PREVIEW, */
camera_dispatcher_set_extra_preview_device, /* MUSE_CAMERA_API_SET_EXTRA_PREVIEW_DEVICE */
- camera_dispatcher_request_codec_config /* MUSE_CAMERA_API_REQUEST_CODEC_CONFIG */
+ camera_dispatcher_request_codec_config, /* MUSE_CAMERA_API_REQUEST_CODEC_CONFIG */
+ camera_dispatcher_attr_set_saturation, /* MUSE_CAMERA_API_ATTR_SET_SATURATION */
+ camera_dispatcher_attr_get_saturation, /* MUSE_CAMERA_API_ATTR_GET_SATURATION */
+ camera_dispatcher_attr_get_saturation_range, /* MUSE_CAMERA_API_ATTR_GET_SATURATION_RANGE */
+ camera_dispatcher_attr_set_sharpness, /* MUSE_CAMERA_API_ATTR_SET_SHARPNESS */
+ camera_dispatcher_attr_get_sharpness, /* MUSE_CAMERA_API_ATTR_GET_SHARPNESS */
+ camera_dispatcher_attr_get_sharpness_range, /* MUSE_CAMERA_API_ATTR_GET_SHARPNESS_RANGE */
+ camera_dispatcher_attr_set_gain, /* MUSE_CAMERA_API_ATTR_SET_GAIN */
+ camera_dispatcher_attr_get_gain, /* MUSE_CAMERA_API_ATTR_GET_GAIN */
+ camera_dispatcher_attr_get_gain_range, /* MUSE_CAMERA_API_ATTR_GET_GAIN_RANGE */
+ camera_dispatcher_attr_get_gain_step, /* MUSE_CAMERA_API_ATTR_GET_GAIN_STEP */
+ camera_dispatcher_attr_set_whitebalance_temperature, /* MUSE_CAMERA_API_ATTR_SET_WHITEBALANCE_TEMPERATURE */
+ camera_dispatcher_attr_get_whitebalance_temperature, /* MUSE_CAMERA_API_ATTR_GET_WHITEBALANCE_TEMPERATURE */
+ camera_dispatcher_attr_get_whitebalance_temperature_range, /* MUSE_CAMERA_API_ATTR_GET_WHITEBALANCE_TEMPERATURE_RANGE */
+ camera_dispatcher_attr_get_whitebalance_temperature_step /* MUSE_CAMERA_API_ATTR_GET_WHITEBALANCE_TEMPERATURE_STEP */
};
Name: mmsvc-camera
Summary: A Camera module for muse server
-Version: 0.3.56
+Version: 0.3.57
Release: 0
Group: Multimedia/Libraries
License: Apache-2.0
projects / platform / core / multimedia / mmsvc-camera.git / commitdiff